diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 335c0cdf65094ee70b93bdb5d95512ab6534b673..95f7c40d8e9fc43a8ca737936969da3c953f10b5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -6,73 +6,67 @@ jobs:
Ubuntu-1604:
runs-on: ubuntu-16.04
env:
- MRUBY_CONFIG: travis_config.rb
+ MRUBY_TARGET: travis
steps:
- uses: actions/checkout@v1
- name: apt
run: sudo apt install ruby gperf
- - name: build
- run: rake -m
- - name: test
- run: rake test
+ - name: build and test
+ run: rake -m -j4 gensym all test
Ubuntu-1804-gcc:
runs-on: ubuntu-18.04
env:
- MRUBY_CONFIG: travis_config.rb
+ MRUBY_TARGET: travis
CC: gcc
CXX: g++
steps:
- uses: actions/checkout@v1
- name: apt
run: sudo apt install ruby gperf gcc g++
- - name: build
- run: rake -m
- - name: test
- run: rake test
+ - name: build and test
+ run: rake -m -j4 gensym all test
Ubuntu-1804-clang:
runs-on: ubuntu-18.04
env:
- MRUBY_CONFIG: travis_config.rb
+ MRUBY_TARGET: travis
CC: clang
CXX: clang++
steps:
- uses: actions/checkout@v1
- name: apt
run: sudo apt install ruby gperf
- - name: build
- run: rake -m
- - name: test
- run: rake test
+ - name: build and test
+ run: rake -m -j4 gensym all test
macOS:
runs-on: macos-latest
env:
- MRUBY_CONFIG: travis_config.rb
+ MRUBY_TARGET: travis
steps:
- uses: actions/checkout@v1
- name: brew
run: brew install ruby gperf
- - name: build
- run: rake -m
- - name: test
- run: rake test
+ - name: build and test
+ run: rake -m -j4 gensym all test
Windows-MinGW:
runs-on: windows-latest
+ env:
+ MRUBY_TARGET: travis
+ CFLAGS: -g -O1 -Wall -Wundef
steps:
- uses: actions/checkout@v1
- name: chocolatey
run: choco install -y ruby gperf
- name: build
- run: rake -E 'STDOUT.sync=true' test
- env:
- MRUBY_CONFIG: travis_config.rb
- CFLAGS: -g -O1 -Wall -Wundef
+ run: rake -E 'STDOUT.sync=true' -j4 gensym all test
Windows-Cygwin:
runs-on: windows-latest
+ env:
+ MRUBY_TARGET: travis
steps:
- uses: actions/checkout@v1
- uses: actions/cache@v1
@@ -90,13 +84,23 @@ jobs:
- name: Set ENV
run: |
echo '::set-env name=PATH::C:\tools\cygwin\bin;C:\tools\cygwin\usr\bin'
- - name: build
+ - name: build and test
shell: cmd
- run: C:\tools\cygwin\bin\ruby.exe /usr/bin/rake -E 'STDOUT.sync=true' -m
- env:
- MRUBY_CONFIG: travis_config.rb
- - name: test
+ run: C:\tools\cygwin\bin\ruby.exe /usr/bin/rake -E 'STDOUT.sync=true' -m gensym all test
+
+ Windows-VC:
+ runs-on: windows-latest
+ env:
+ MRUBY_TARGET: appveyor
+ # TODO(take-cheeze): Re-enable /O2
+ CFLAGS: "/c /nologo /W3 /we4013 /Zi /MD /D_CRT_SECURE_NO_WARNINGS"
+ CXXFLAGS: "/c /nologo /W3 /Zi /MD /EHs /D_CRT_SECURE_NO_WARNINGS"
+ steps:
+ - uses: actions/checkout@v1
+ - name: chocolatey
+ run: choco install -y ruby gperf
+ - name: build and test
shell: cmd
- run: C:\tools\cygwin\bin\ruby.exe /usr/bin/rake -E 'STDOUT.sync=true' test
- env:
- MRUBY_CONFIG: travis_config.rb
+ run: |
+ call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+ rake -E "STDOUT.sync=true" gensym all test
diff --git a/.travis.yml b/.travis.yml
index f04132d07140aaa4e584641e774d443a2d131ec2..676ac27b599e211bd96f4e61c253a04c497871d5 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,9 +3,12 @@ language: c
jobs:
- os: linux
- os: osx
+ before_install:
+ - HOMEBREW_NO_AUTO_UPDATE=1 HOMEBREW_NO_INSTALL_CLEANUP=1 brew install bison
+ - export PATH="/usr/local/opt/bison/bin:$PATH"
env:
- - MRUBY_CONFIG=travis_config.rb
+ - MRUBY_TARGET=travis
script:
- - rake -m && rake test
+ - rake gensym && rake -m && rake test
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0b632f51c0e812e2758664561b58d93e0cab6323..ec25f89b137753c510f51060fa2613d8bd9871b2 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -56,7 +56,7 @@ on-demand.
Use C++ style comments only for temporary comment e.g. commenting out some code lines.
-#### Insert a break after the method return value:
+#### Insert a break after the function return value:
int
main(void)
@@ -72,4 +72,5 @@ language itself. Please note the following hints for your Ruby code:
#### Comply with the Ruby standard (ISO/IEC 30170:2012)
mruby is currently targeting to execute Ruby code which complies to ISO/IEC
-30170:2012 (http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579).
+30170:2012 (http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579),
+unless there's a clear reason, e.g. the latest Ruby has changed behavior from ISO.
diff --git a/README.md b/README.md
index 5bea9d4420a2ec1bc43a5ed3658ffda59098f86c..f7db82375976aa8c2b8622d2e9e12e9775ad1fa4 100644
--- a/README.md
+++ b/README.md
@@ -40,11 +40,13 @@ We don't have a mailing list, but you can use [GitHub issues](https://github.com
See the [compile.md](https://github.com/mruby/mruby/blob/master/doc/guides/compile.md) file.
-## Running Tests
+## How to Build
-To run the tests, execute the following from the project's root directory.
+To build mruby, execute the following from the project's root directory.
- $ rake test
+ $ rake TARGET=<target> test
+
+The default `TARGET` is `host`. `TARGET` will be loaded from `target` directory.
Note: `bison` bundled with MacOS is too old to compile `mruby`.
Try `brew install bison` and follow the instuction shown to update
diff --git a/Rakefile b/Rakefile
index 4115d9e8ef020f79227122e7f530649d6da82aaa..5c5a6e8ebe1a8960c9ebd0b1b74c32534ec097d2 100644
--- a/Rakefile
+++ b/Rakefile
@@ -14,7 +14,13 @@ require "mruby-core-ext"
require "mruby/build"
# load configuration file
-MRUBY_CONFIG = (ENV['MRUBY_CONFIG'] && ENV['MRUBY_CONFIG'] != '') ? ENV['MRUBY_CONFIG'] : "#{MRUBY_ROOT}/build_config.rb"
+if ENV['MRUBY_CONFIG']
+ MRUBY_CONFIG = ENV['MRUBY_CONFIG']
+ MRUBY_TARGET = File.basename(MRUBY_CONFIG, ".rb")
+else
+ MRUBY_TARGET = ENV['MRUBY_TARGET'] || ENV['TARGET'] || "host"
+ MRUBY_CONFIG = "#{MRUBY_ROOT}/target/#{MRUBY_TARGET}.rb"
+end
load MRUBY_CONFIG
# load basic rules
@@ -46,15 +52,19 @@ task :default => :all
bin_path = ENV['INSTALL_DIR'] || "#{MRUBY_ROOT}/bin"
-depfiles = MRuby.targets['host'].bins.map do |bin|
- install_path = MRuby.targets['host'].exefile("#{bin_path}/#{bin}")
- source_path = MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/#{bin}")
+if MRuby.targets['host']
+ target = MRuby.targets['host']
+ depfiles = target.bins.map do |bin|
+ install_path = target.exefile("#{bin_path}/#{bin}")
+ source_path = target.exefile("#{target.build_dir}/bin/#{bin}")
- file install_path => source_path do |t|
- install_D t.prerequisites.first, t.name
+ file install_path => source_path do |t|
+ install_D t.prerequisites.first, t.name
+ end
+ install_path
end
-
- install_path
+else
+ depfiles = []
end
MRuby.each_target do |target|
@@ -87,15 +97,6 @@ MRuby.each_target do |target|
install_D t.prerequisites.first, t.name
end
depfiles += [ install_path ]
- elsif target == MRuby.targets['host-debug']
- unless MRuby.targets['host'].gems.map {|g| g.bins}.include?([bin])
- install_path = MRuby.targets['host-debug'].exefile("#{bin_path}/#{bin}")
-
- file install_path => exec do |t|
- install_D t.prerequisites.first, t.name
- end
- depfiles += [ install_path ]
- end
else
depfiles += [ exec ]
end
@@ -103,6 +104,143 @@ MRuby.each_target do |target|
end
end
+mkdir_p "#{MRUBY_ROOT}/build"
+cfiles = (
+ Dir.glob("#{MRUBY_ROOT}/src/*.c")+
+ Dir.glob("#{MRUBY_ROOT}/mrbgems/**/*.c")+
+ Dir.glob("#{MRUBY_ROOT}/build/repos/**/{src,core}/*.c")
+).uniq
+rbfiles = (
+ Dir.glob("#{MRUBY_ROOT}/mrblib/**/*.rb")+
+ Dir.glob("#{MRUBY_ROOT}/mrbgems/*/mrblib/**/*.rb")+
+ Dir.glob("#{MRUBY_ROOT}/build/repos/**/mrblib/**/*.rb")
+).uniq
+psfiles = Dir.glob("#{MRUBY_ROOT}/{mrblib,mrbgems,build/repos}/**/presym")
+symbols = []
+psfiles.each do |file|
+ symbols += File.readlines(file).grep_v(/^# /)
+end
+symbols.each{|x| x.chomp!}
+presym_file="#{MRUBY_ROOT}/build/presym"
+op_table = {
+ "!" => "not",
+ "!=" => "neq",
+ "!~" => "nmatch",
+ "%" => "mod",
+ "&" => "and",
+ "&&" => "andand",
+ "*" => "mul",
+ "**" => "pow",
+ "+" => "add",
+ "+@" => "plus",
+ "-" => "sub",
+ "-@" => "minus",
+ "/" => "div",
+ "<" => "lt",
+ "<=" => "le",
+ "<<" => "lshift",
+ "<=>" => "cmp",
+ "==" => "eq",
+ "===" => "eqq",
+ "=~" => "match",
+ ">" => "gt",
+ ">=" => "ge",
+ ">>" => "rshift",
+ "[]" => "aref",
+ "[]=" => "aset",
+ "^" => "xor",
+ "`" => "tick",
+ "|" => "or",
+ "||" => "oror",
+ "~" => "neg",
+}
+
+file presym_file => cfiles+rbfiles+psfiles+[__FILE__] do
+ csymbols = cfiles.map do |f|
+ src = File.read(f)
+ src.gsub!(/\/\/.+(\n|$)/, "\n")
+ [src.scan(/intern_lit\([^\n"]*"([^\n "]*)"/),
+ src.scan(/mrb_define_method\([^\n"]*"([^\n"]*)"/),
+ src.scan(/mrb_define_class_method\([^\n"]*"([^\n"]*)"/),
+ src.scan(/mrb_define_class\([^\n"]*"([^\n"]*)"/),
+ src.scan(/mrb_define_module\([^\n"]*"([^\n"]*)"/),
+ src.scan(/mrb_define_module_function\([^\n"]*"([^\n"]*)"/),
+ src.scan(/mrb_define_const\([^\n"]*"([^\n"]*)"/),
+ src.scan(/mrb_define_global_const\([^\n"]*"([^\n"]*)"/),
+ src.scan(/MRB_SYM\((\w+)\)/),
+ src.scan(/MRB_QSYM\((\w+)\)/).map{|x,|
+ x.sub!(/_p$/, "?") || x.sub!(/_b$/, "!") || x.sub!(/_e$/, "=") || x.sub!(/^0_/, "@") || x.sub!(/^00_/, "@@")
+ }.compact]
+ end
+ rbsymbols = rbfiles.map do |f|
+ src = File.read(f)
+ src.force_encoding(Encoding::BINARY)
+ [src.scan(/\bclass +([A-Z]\w*)/),
+ src.scan(/\bmodule +([A-Z]\w*)/),
+ src.scan(/\bdef +(\w+[!?=]?)/),
+ src.scan(/\balias +(\w+[!?]?)/),
+ src.scan(/\b([A-Z]\w*) *=[^=]/),
+ src.scan(/(\$[a-zA-Z_]\w*)/),
+ src.scan(/(\$[$!?0-9]\w*)/),
+ src.scan(/(@@?[a-zA-Z_]\w*)/),
+ src.scan(/[^.]\.([a-zA-Z_]\w*[!?]?)/),
+ src.scan(/\.([a-zA-Z_]\w* *=)/).map{|x|x.map{|s|s.gsub(' ', '')}},
+ src.scan(/\b([a-zA-Z_]\w*):/),
+ src.scan(/:([a-zA-Z_]\w*[!?=]?)/),
+ src.scan(/[\(\[\{ ]:"([^"]+)"/).map{|x|x.map{|s|s.gsub('\#', '#')}},
+ src.scan(/[ \(\[\{]:'([^']+)'/)
+ ]
+ end
+ symbols = (symbols+csymbols+rbsymbols+op_table.keys).flatten.compact.uniq.sort.map{|x| x.gsub("\n", '\n')}
+ presyms = File.readlines(presym_file) rescue []
+ presyms.each{|x| x.chomp!}
+ if presyms != symbols
+ File.write(presym_file, symbols.join("\n"))
+ end
+end
+
+presym_inc=presym_file+".inc"
+file presym_inc => presym_file do
+ presyms = File.readlines(presym_file)
+ presyms.each{|x| x.chomp!}
+ File.open(presym_inc, "w") do |f|
+ f.print "/* MRB_PRESYM_CSYM(sym, num) - symbol which is valid C id name */\n"
+ f.print "/* MRB_PRESYM_QSYM(name, sym, num) - symbol with alias name */\n"
+ f.print "/* MRB_PRESYM_SYM(name, num) - symbol which is not valid C id */\n"
+ presyms.each.with_index do |sym,i|
+ if sym.bytes.detect{|x|x>0x80} || /\A\$/ =~ sym
+ f.print "MRB_PRESYM_SYM(\"#{sym}\", #{i+1})\n"
+ elsif /\A\w+\Z/ =~ sym
+ f.print "MRB_PRESYM_CSYM(#{sym}, #{i+1})\n"
+ elsif op_table.key?(sym)
+ f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{op_table[sym]}, #{i+1})\n"
+ elsif /\A[A-Za-z_]\w*\?\Z/ =~ sym
+ s = sym.dup; s[-1] = "_p"
+ f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+ elsif /\A[A-Za-z_]\w*\!\Z/ =~ sym
+ s = sym.dup; s[-1] = "_b"
+ f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+ elsif /\A[A-Za-z_]\w*\=\Z/ =~ sym
+ s = sym.dup; s[-1] = "_e"
+ f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+ elsif /\A@@/ =~ sym
+ s = sym.dup; s[0,2] = "00_"
+ f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+ elsif /\A@/ =~ sym
+ s = sym.dup; s[0] = "0_"
+ f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+ else
+ f.print "MRB_PRESYM_SYM(\"#{sym}\", #{i+1})\n"
+ end
+ end
+ f.print "#define MRB_PRESYM_MAX #{presyms.size}"
+ end
+end
+
+desc "preallocated symbols"
+task :gensym => presym_inc
+task :all => :gensym
+
depfiles += MRuby.targets.map { |n, t|
t.libraries
}.flatten
@@ -156,5 +294,7 @@ task :deep_clean => ["clean", "clean_doc"] do
MRuby.each_target do |t|
rm_rf t.gem_clone_dir
end
+ rm_f presym_file
+ rm_f presym_inc
puts "Cleaned up mrbgems build folder"
end
diff --git a/appveyor.yml b/appveyor.yml
index e963ea0356433bc211d268704d7ce86747ad09e1..e2fa0e900d8fc2f56113ce5d5d0459668602c00f 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -38,7 +38,9 @@ init:
- set PATH=C:\Ruby26-x64\bin;%PATH%
- ruby --version
+
build_script:
- - set MRUBY_CONFIG=appveyor_config.rb
- - rake -m -j4
- - rake -E STDOUT.sync=true test
+ - set MRUBY_TARGET=appveyor
+ - rake gensym
+ - rake -m all
+ - rake -E $stdout.sync=true test
diff --git a/appveyor_config.rb b/appveyor_config.rb
deleted file mode 100644
index 25745daa8ae651c16f997ee2a0d914b428e33e8b..0000000000000000000000000000000000000000
--- a/appveyor_config.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-def setup_option(conf)
- conf.cc.flags[0].delete("/Zi") unless ENV['CFLAGS']
- conf.cxx.flags[0].delete("/Zi") unless ENV['CFLAGS'] || ENV['CXXFLAGS']
- conf.linker.flags << "/DEBUG:NONE" unless ENV['LDFLAGS']
-end
-
-MRuby::Build.new('full-debug') do |conf|
- toolchain :visualcpp
- enable_debug
-
- # include all core GEMs
- conf.gembox 'full-core'
- conf.cc.defines += %w(MRB_GC_STRESS MRB_METHOD_CACHE MRB_ENABLE_DEBUG_HOOK)
- setup_option(conf)
-
- conf.enable_test
-end
-
-MRuby::Build.new do |conf|
- toolchain :visualcpp
-
- # include all core GEMs
- conf.gembox 'full-core'
- conf.compilers.each do |c|
- c.defines += %w(MRB_GC_FIXED_ARENA)
- end
- setup_option(conf)
- conf.enable_bintest
- conf.enable_test
-end
-
-MRuby::Build.new('cxx_abi') do |conf|
- toolchain :visualcpp
-
- conf.gembox 'full-core'
- conf.compilers.each do |c|
- c.defines += %w(MRB_GC_FIXED_ARENA)
- end
- setup_option(conf)
- conf.enable_bintest
- conf.enable_test
-
- enable_cxx_abi
-
- build_mrbc_exec
-end
diff --git a/doc/guides/compile.md b/doc/guides/compile.md
index d7937bb2ea3c7a9afae00150653baac86ddb7ed0..233c3e594e103a9242843f7351b906bae381b38a 100644
--- a/doc/guides/compile.md
+++ b/doc/guides/compile.md
@@ -14,37 +14,53 @@ To compile mruby out of the source code you need the following tools:
Note that `bison` bundled with MacOS is too old to compile `mruby`.
Try `brew install bison` and follow the instuction shown to update
-the `$PATH` to compile `mruby`.
+the `$PATH` to compile `mruby`. We also encourage to upgrade `ruby`
+on MacOS in similar manner.
Optional:
-* GIT (to update mruby source and integrate mrbgems easier)
+* git (to update mruby source and integrate mrbgems easier)
* C++ compiler (to use GEMs which include \*.cpp, \*.cxx, \*.cc)
* Assembler (to use GEMs which include \*.asm)
-## Usage
+## Build
+
+To compile `mruby`, just call `rake` inside of the mruby source
+root. To generate and execute the test tools call `rake test`. To
+clean all build files call `rake clean`. To see full command line on
+build, call `rake -v`.
+
+If you want to compile for the specific configuration, specify
+`MRUBY_TARGET` or `TARGET` environment variable, e.g
+
+```sh
+rake TAGRET=host
+```
+
+The default target is `host`. The compilation target desciption files
+(with `.rb` suffix) are contained in the `target` directory.
+
+A build description file contains the build configuration of mruby and
+looks like the following for example:
-Inside of the root directory of the mruby source a file exists
-called *build_config.rb*. This file contains the build configuration
-of mruby and looks like this for example:
```ruby
MRuby::Build.new do |conf|
toolchain :gcc
end
```
-All tools necessary to compile mruby can be set or modified here. In case
-you want to maintain an additional *build_config.rb* you can define a
-customized path using the *$MRUBY_CONFIG* environment variable.
-
-To compile just call `rake` inside of the mruby source root. To
-generate and execute the test tools call `rake test`. To clean
-all build files call `rake clean`. To see full command line on
-build, call `rake -v`.
+All tools necessary to compile mruby can be set or modified here. In
+case you want to try different configuration, you can create a new
+configuration file under `target` and specify the configuration using
+the `MRUBY_TARGET` environment variable.
## Build Configuration
-Inside of the *build_config.rb* the following options can be configured
-based on your environment.
+To create a new configuration, copy the existing configuration in the
+`target` directory, and modify it. We wish you submit a pull-request,
+once you created a new configuration for a new platform.
+
+Inside of the configuration file, the following options can be
+configured based on your environment.
### Toolchains
@@ -88,15 +104,12 @@ in `ANDROID_STANDALONE_TOOLCHAIN`.
### Binaries
It is possible to select which tools should be compiled during the compilation
-process. The following tools can be selected:
-* mruby (mruby interpreter)
-* mirb (mruby interactive shell)
+process. For example,
-To select them declare conf.gem as follows:
-```ruby
-conf.gem "#{root}/mrbgems/mruby-bin-mruby"
-conf.gem "#{root}/mrbgems/mruby-bin-mirb"
-```
+* `mruby`
+* `mirb`
+
+The configuration are done via `mrbgems`. See `Mrbgems` section.
### File Separator
@@ -209,17 +222,33 @@ end
### Mrbgems
-Integrate GEMs in the build process.
+`mruby` comes with the (sort of) packaging system named `mrbgems`. To
+specify `gem`, you can use `conf.gem` in the configuration file.
+
```ruby
-# Integrate GEM with additional configuration
-conf.gem 'path/to/gem' do |g|
- g.cc.flags << ...
-end
+# Integrate a bundled Gem you see in `mrbgems` directory
+conf.gem :core => 'mruby-something'
+
+# Integrate a Gem from GitHub
+conf.gem :github => 'someone/mruby-another'
-# Integrate GEM without additional configuration
-conf.gem 'path/to/another/gem'
+# Integrate a mruby binary Gem
+conf.gem :core => 'mruby-bin-mruby'
+
+# Integrate a interactive mruby binary Gem
+conf.gem :core => 'mruby-bin-mirb'
+
+# Integrate GemBox (set of Gems)
+conf.gembox "default"
```
+A GemBox is a set of Gems defined in `mrbgems/default.gembox` for example.
+It's just a set of `mrbgem` configurations.
+
+There is a `RubyGem` (gem for CRuby) named `mgem` that help you to
+manage `mrbgems`. Try `gem install mgem`. `mgem` can show you the list
+of registered `mrbgems`.
+
See doc/mrbgems/README.md for more option about mrbgems.
### Mrbtest
@@ -327,6 +356,10 @@ root directory. The structure of this directory will look like this:
+- build
|
+ +- presym <- List of preallocated symbolx
+ |
+ +- presym.inc <- C source file for preallocated symbols
+ |
+- host
|
+- bin <- Binaries (mirb, mrbc and mruby)
@@ -378,6 +411,10 @@ In case of a cross-compilation to *i386* the *build* directory structure looks
like this:
+- build
+ |
+ +- presym <- List of preallocated symbolx
+ |
+ +- presym.inc <- C source file for preallocated symbols
|
+- host
| |
diff --git a/doc/guides/mrbconf.md b/doc/guides/mrbconf.md
index 1e1a5afcf6d2d60b73d58c8ece8c621e15e1f15d..c95634604e8e629e318808da5260688a3e86c3c9 100644
--- a/doc/guides/mrbconf.md
+++ b/doc/guides/mrbconf.md
@@ -46,11 +46,11 @@ You can use mrbconfs with following ways:
## Primitive type configuration.
-`MRB_USE_FLOAT`
+`MRB_USE_FLOAT32`
* When defined single precision floating point type(C type `float`) is used as `mrb_float`.
-* Else double precision floating point type(C type `double`) is used as `mrb_float`.
+* Otherwise double precision floating point type(C type `double`) is used as `mrb_float`.
-`MRB_WITHOUT_FLOAT`
+`MRB_NO_FLOAT`
* When defined removes floating point numbers from mruby.
* It makes mruby easier to handle in "Microcontroller without FPU" and "Kernel Space".
@@ -117,7 +117,7 @@ largest value of required alignment.
`MRB_NAN_BOXING`
* If defined represent `mrb_value` in boxed `double`.
-* Conflicts with `MRB_USE_FLOAT` and `MRB_WITHOUT_FLOAT`.
+* Conflicts with `MRB_USE_FLOAT32` and `MRB_NO_FLOAT`.
`MRB_WORD_BOXING`
* If defined represent `mrb_value` as a word.
@@ -163,17 +163,17 @@ largest value of required alignment.
* Default value is `128`.
* Specifies initial capacity of `RString` created by `mrb_str_buf_new` function..
-`MRB_METHOD_CACHE`
-* Improve performance for method dispatch.
+`MRB_NO_METHOD_CACHE`
+* Disable method cache to save memory.
`MRB_METHOD_CACHE_SIZE`
-* Default value is `128`.
-* Ignored if `MRB_METHOD_CACHE` is not defined.
+* Default value is `256`.
+* Ignored if `MRB_NO_METHOD_CACHE` is defined.
* Need to be the power of 2.
-`MRB_METHOD_T_STRUCT`
+`MRB_USE_METHOD_T_STRUCT`
* Use C struct to represent `mrb_method_t`
-* No `MRB_METHOD_T_STRUCT` requires highest 2 bits of function pointers to be zero
+* No `MRB_USE_METHOD_T_STRUCT` requires highest 2 bits of function pointers to be zero
* Define this macro on machines that use higher bits of pointers
`MRB_ENABLE_ALL_SYMBOLS`
diff --git a/doc/limitations.md b/doc/limitations.md
index 770daa7a46ee5e724bac636dba728f00040be0ac..8ac959b982b3b6473c29f6173a78c02b869cd1ef 100644
--- a/doc/limitations.md
+++ b/doc/limitations.md
@@ -17,7 +17,7 @@ Please help to improve it by submitting your findings.
## `1/2` gives `0.5`
Since mruby does not have `Bignum`, bigger integers are represented
-by `Float` numbers. To enhance interoperability between `Fixnum`
+by `Float` numbers. To enhance interoperability between `Integer`
and `Float`, mruby provides `Float#upto` and other iterating
methods for the `Float` class. As a side effect, `1/2` gives `0.5`
not `0`.
@@ -63,8 +63,15 @@ end
#### mruby [2.1.2 (2020-08-06)]
-No exception is raised.
+No exception is raised. Instead you have to do:
+```ruby
+begin
+ 1 / 0
+rescue => e
+ raise e
+end
+```
## Fiber execution can't cross C function boundary
mruby's `Fiber` is implemented in a similar way to Lua's co-routine. This
@@ -245,8 +252,7 @@ trace (most recent call last):
## Keyword arguments
mruby keyword arguments behave slightly different from CRuby 2.5
-to make the behavior simpler and less confusing. Maybe in the
-future, the simpler behavior will be adopted to CRuby as well.
+to make the behavior simpler and less confusing.
#### Ruby [ruby 2.5.1p57 (2018-03-29 revision 63029)]
@@ -264,6 +270,20 @@ trace (most recent call last):
-e:1: keyword argument hash with non symbol keys (ArgumentError)
```
+## `nil?` redefinition in conditional expressions
+
+Redefinition of `nil?` is ignored in conditional expressions.
+
+```ruby
+a = "a"
+def a.nil?
+ true
+end
+puts(a.nil? ? "truthy" : "falsy")
+```
+
+Ruby outputs `falsy`. mruby outputs `truthy`.
+
## Argument Destructuring
```ruby
@@ -283,17 +303,3 @@ f(1,[2,3])
```
CRuby gives `[1,2,3,nil]`. mruby raises `NoMethodError` for `b`.
-
-## `nil?` redefinition in conditional expressions
-
-Redefinition of `nil?` is ignored in conditional expressions.
-
-```ruby
-a = "a"
-def a.nil?
- true
-end
-puts(a.nil? ? "truthy" : "falsy")
-```
-
-Ruby outputs `falsy`. mruby outputs `truthy`.
diff --git a/doc/mruby3.md b/doc/mruby3.md
new file mode 100644
index 0000000000000000000000000000000000000000..4e4f94d07d5dab06e07b6a0bfb96bdd59a4108a5
--- /dev/null
+++ b/doc/mruby3.md
@@ -0,0 +1,108 @@
+User visible changes in `mruby3`
+===
+
+# Build System
+
+You can specify `TARGET` option to `rake` via a command line
+option, or via an environment variable, e.g.
+
+`rake TARGET=host all`
+
+or
+
+`TARGET=host rake all`
+
+It's much easier to switch multiple targets than the
+previous `build_config.rb` system.
+
+## `presym` target
+
+The first compilation of `mruby` may require generation of a
+static symbol table named `build/presym`. You can generate
+the table by `rake gensym`.
+
+## `target` directory
+
+Build target specification files are loaded from `target`
+directory. The default `TARGET` is `host` which is described
+in `target/host.rb`. There are many other targets for example:
+
+* `host-gprof`: compiles with `gprof` for performance tuning
+* `host-m32`: compiles in gcc 32bit mode on 64bit platforms
+* `boxing`: compiles all three boxing options
+* `clang-asan`: compiles with `clang`'s Address Sanitizer
+
+`target/host.rb` comes with comments to help writing a new
+target description.
+
+If you want to have your target description out of the
+source tree, you can specify the path to the description
+file in `MRUBY_CONFIG`.
+
+# Build Target Contribution
+
+When you write a new target description, please
+contribute. We welcome your contribution as a GitHub
+pull-request.
+
+# Languge Changes
+
+## New Syntax
+
+We have ported some new syntax from CRuby.
+
+* R-assignment (`12 => x`)
+* Numbered block parameter (`x.map{_1 * 2}`)
+* End-less `def` (`def double(x) = x*2`)
+
+# Configuration Options Changed
+
+Some configuration macro names are changed for consistency
+
+## `MRB_NO_FLOAT`
+
+Changed from `MRB_WITHOUT_FLOAT` to conform `USE_XXX` naming
+convention.
+
+## `MRB_USE_FLOAT32`
+
+Changed from `MRB_USE_FLOAT` to make sure `float` here means
+using single precision float, and not the opposite of
+`MRB_NO_FLOAT`.
+
+## `MRB_USE_METHOD_T_STRUCT`
+
+Changed from `MRB_METHOD_T_STRUCT`.
+
+To use `struct` version of `mrb_method_t`. More portable but consumes more memory.
+Turned on by default on 32bit platforms.
+
+## `MRB_NO_BOXING`
+
+Uses `struct` to represent `mrb_value`. Consumes more memory
+but easier to inveticate the internal and to debug. It used
+to be default `mrb_value` representation. Now the default is
+`MRB_WORD_BOXING`.
+
+## `MRB_WORD_BOXING`
+
+Pack `mrb_value` in an `intptr_t` integer. Consumes less
+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.
+
+## `MRB_NAN_BOXING`
+
+Pack `mrb_value` in a floating pointer number. Nothing
+changed from previous versions.
+
+## `MRB_USE_MALLOC_TRIM`
+
+Call `malloc_trim(0)` from mrb_full_gc() if this macro is defined.
+If you are using glibc malloc, this macro could reduce memory consumption.
+
+# Internal Changes
+
+## `Random` now use `xoshiro128++`.
+
+For better and faster random number generation.
diff --git a/doc/opcode.md b/doc/opcode.md
index a79453e8a55215015ef997e016d1866a3d0bc5f1..513b283024639263901445c54c1baca0cd604d54 100644
--- a/doc/opcode.md
+++ b/doc/opcode.md
@@ -20,121 +20,107 @@ sign) of operands.
* sS: signed 16bit
* W: 24bit
-First two byte operands may be extended to 16bit. When those byte
-operands are bigger than 256, the instruction will be prefixed by
-`OP_EXT1` (means 1st operand is 16bit) or `OP_EXT2` (means 2nd operand
-is 16bit) or `OP_EXT3` (means 1st and 2nd operands are 16bit).
-
-For instructions marked by `'`, `OP_EXT1` can be prefixed. For those
-with `"`, either `OP_EXT1` or `OP_EXT2` or `OP_EXT2` can be prefixed.
-
## table.1 Instruction Table
| Instruction Name | Operand type | Semantics |
|------------------|--------------|--------------------------------------------------------|
| 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' | BsS | R(a) = mrb_int(b) |
-| 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_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 | BsS | R(a) = mrb_int(b) |
+| 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_ONERR | S | rescue_push(a) |
-| OP_EXCEPT' | B | R(a) = exc |
-| OP_RESCUE" | BB | R(b) = R(a).isa?(R(b)) |
-| OP_POPERR' | B | a.times{rescue_pop()} |
-| OP_RAISE' | B | raise(R(a)) |
-| OP_EPUSH' | B | ensure_push(SEQ[a]) |
-| OP_EPOP' | B | A.times{ensure_pop().call} |
-| OP_SENDV" | BB | R(a) = call(R(a),Syms(b),*R(a+1)) |
-| OP_SENDVB" | BB | R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) |
-| OP_SEND" | BBB | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) |
-| OP_SENDB" | BBB | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1)) |
+| 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_SENDV | BB | R(a) = call(R(a),Syms(b),*R(a+1)) |
+| OP_SENDVB | BB | R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) |
+| OP_SEND | BBB | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) |
+| 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=5:1:5:1:4) |
+| OP_SUPER | BB | R(a) = super(R(a+1),... ,R(a+b+1)) |
+| OP_ARGARY | BS | R(a) = argument array (16=5:1:5:1:4) |
| OP_ENTER | W | arg setup according to flags (23=5:5:1:5:5:1:1) |
-| OP_KEY_P" | BB | R(a) = kdict.key?(Syms(b)) |
+| 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=5:1:5:1:4) |
-| 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_LE' | B | R(a) = R(a)<=R(a+1) |
-| OP_GT' | 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' | B | ary_push(R(a),R(a+1)) |
-| OP_ARYDUP' | B | R(a) = ary_dup(R(a)) |
-| OP_AREF" | BBB | R(a) = R(b)[c] |
-| OP_ASET" | BBB | R(a)[c] = R(b) |
-| 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(Lit(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)) |
-| OP_HASHADD" | BB | R(a) = hash_push(R(a),R(a+1)..R(a+b)) |
-| OP_HASHCAT' | B | R(a) = hash_cat(R(a),R(a+1)) |
-| OP_LAMBDA" | BB | R(a) = lambda(SEQ[b],OP_L_LAMBDA) |
-| OP_BLOCK" | BB | R(a) = lambda(SEQ[b],OP_L_BLOCK) |
-| OP_METHOD" | BB | R(a) = lambda(SEQ[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),SEQ[b]) |
-| OP_DEF" | BB | R(a).newmethod(Syms(b),R(a+1)) |
-| 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, Lit(a)) |
-| OP_EXT1 | - | make 1st operand 16bit |
-| OP_EXT2 | - | make 2nd operand 16bit |
-| OP_EXT3 | - | make 1st and 2nd operands 16bit |
+| 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=5:1:5:1:4) |
+| 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_LE | B | R(a) = R(a)<=R(a+1) |
+| OP_GT | 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 | B | ary_push(R(a),R(a+1)) |
+| OP_ARYDUP | B | R(a) = ary_dup(R(a)) |
+| OP_AREF | BBB | R(a) = R(b)[c] |
+| OP_ASET | BBB | R(a)[c] = R(b) |
+| 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(Lit(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)) |
+| OP_HASHADD | BB | R(a) = hash_push(R(a),R(a+1)..R(a+b)) |
+| OP_HASHCAT | B | R(a) = hash_cat(R(a),R(a+1)) |
+| OP_LAMBDA | BB | R(a) = lambda(SEQ[b],OP_L_LAMBDA) |
+| OP_BLOCK | BB | R(a) = lambda(SEQ[b],OP_L_BLOCK) |
+| OP_METHOD | BB | R(a) = lambda(SEQ[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),SEQ[b]) |
+| OP_DEF | BB | R(a).newmethod(Syms(b),R(a+1)) |
+| 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, Lit(a)) |
| OP_STOP | - | stop VM |
|------------------|--------------|--------------------------------------------------------|
diff --git a/examples/targets/build_config_android_arm64-v8a.rb b/examples/targets/build_config_android_arm64-v8a.rb
deleted file mode 100644
index 70b0f4b975812b74f181282b3fa5cbb4e3cfdf24..0000000000000000000000000000000000000000
--- a/examples/targets/build_config_android_arm64-v8a.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-MRuby::Build.new do |conf|
-
- # Gets set by the VS command prompts.
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
- enable_debug
-
- # include the default GEMs
- conf.gembox 'default'
-end
-
-# Requires Android NDK r13 or later.
-MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
- params = {
- :arch => 'arm64-v8a',
- :platform => 'android-24',
- :toolchain => :clang,
- }
- toolchain :android, params
-
- conf.gembox 'default'
-end
diff --git a/examples/targets/build_config_android_armeabi.rb b/examples/targets/build_config_android_armeabi.rb
deleted file mode 100644
index 17330242ae35e55156ac63d17d53c9f44909e2ec..0000000000000000000000000000000000000000
--- a/examples/targets/build_config_android_armeabi.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-MRuby::Build.new do |conf|
-
- # Gets set by the VS command prompts.
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
- enable_debug
-
- # include the default GEMs
- conf.gembox 'default'
-end
-
-# Requires Android NDK r13 or later.
-MRuby::CrossBuild.new('android-armeabi') do |conf|
- params = {
- :arch => 'armeabi',
- :platform => 'android-24',
- :toolchain => :clang,
- }
- toolchain :android, params
-
- conf.gembox 'default'
-end
diff --git a/include/mrbconf.h b/include/mrbconf.h
index 2b1adb24ea84cbb4a01f76095d16572c3b69c5bb..89b3e90221fbc7ae1fd4176e20cf0805e16cda1f 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -25,33 +25,69 @@
#endif
/* configuration options: */
-/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
-//#define MRB_USE_FLOAT
+/* add -DMRB_USE_FLOAT32 to use float instead of double for floating point numbers */
+//#define MRB_USE_FLOAT32
/* exclude floating point numbers */
-//#define MRB_WITHOUT_FLOAT
+//#define MRB_NO_FLOAT
-/* add -DMRB_METHOD_CACHE to use method cache to improve performance */
-//#define MRB_METHOD_CACHE
+/* obsolete configuration */
+#if defined(MRB_USE_FLOAT)
+# define MRB_USE_FLOAT32
+#endif
+
+/* obsolete configuration */
+#if defined(MRB_WITHOUT_FLOAT)
+# define MRB_NO_FLOAT
+#endif
+
+#if defined(MRB_USE_FLOAT32) && defined(MRB_NO_FLOAT)
+#error Cannot define MRB_USE_FLOAT32 and MRB_NO_FLOAT at the same time
+#endif
+
+/* add -DMRB_NO_METHOD_CACHE to disable method cache to save memory */
+//#define MRB_NO_METHOD_CACHE
/* size of the method cache (need to be the power of 2) */
-//#define MRB_METHOD_CACHE_SIZE (1<<7)
+//#define MRB_METHOD_CACHE_SIZE (1<<8)
-/* add -DMRB_METHOD_T_STRUCT on machines that use higher bits of pointers */
-/* no MRB_METHOD_T_STRUCT requires highest 2 bits of function pointers to be zero */
-#ifndef MRB_METHOD_T_STRUCT
+/* add -DMRB_USE_METHOD_T_STRUCT on machines that use higher bits of function pointers */
+/* no MRB_USE_METHOD_T_STRUCT requires highest 2 bits of function pointers to be zero */
+#ifndef MRB_USE_METHOD_T_STRUCT
// can't use highest 2 bits of function pointers at least on 32bit
// Windows and 32bit Linux.
# ifdef MRB_32BIT
-# define MRB_METHOD_T_STRUCT
+# define MRB_USE_METHOD_T_STRUCT
+# endif
+#endif
+
+/* define on big endian machines; used by MRB_NAN_BOXING, etc. */
+#ifndef MRB_ENDIAN_BIG
+# if (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \
+ (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+# define MRB_ENDIAN_BIG
# endif
#endif
+/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT32 and MRB_NO_FLOAT */
+//#define MRB_NAN_BOXING
+
+/* represent mrb_value as a word (natural unit of data for the processor) */
+//#define MRB_WORD_BOXING
+
+/* represent mrb_value as a struct; occupies 2 words */
+//#define MRB_NO_BOXING
+
+/* if no specific boxing type is chosen */
+#if !defined(MRB_NAN_BOXING) && !defined(MRB_WORD_BOXING) && !defined(MRB_NO_BOXING)
+# define MRB_WORD_BOXING
+#endif
+
/* add -DMRB_INT32 to use 32bit integer for mrb_int; conflict with MRB_INT64;
Default for 32-bit CPU mode. */
//#define MRB_INT32
/* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT32;
- Default for 64-bit CPU mode. */
+ Default for 64-bit CPU mode (unless using MRB_NAN_BOXING). */
//#define MRB_INT64
/* if no specific integer type is chosen */
@@ -65,19 +101,8 @@
# endif
#endif
-/* define on big endian machines; used by MRB_NAN_BOXING, etc. */
-#ifndef MRB_ENDIAN_BIG
-# if (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \
- (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-# define MRB_ENDIAN_BIG
-# endif
-#endif
-
-/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT and MRB_WITHOUT_FLOAT */
-//#define MRB_NAN_BOXING
-
-/* represent mrb_value as a word (natural unit of data for the processor) */
-//#define MRB_WORD_BOXING
+/* call malloc_trim(0) from mrb_full_gc() */
+//#define MRB_USE_MALLOC_TRIM
/* string class to handle UTF-8 encoding */
//#define MRB_UTF8_STRING
@@ -160,6 +185,10 @@
/* A profile for micro controllers */
#if defined(MRB_CONSTRAINED_BASELINE_PROFILE)
+# ifndef MRB_NO_METHOD_CACHE
+# define MRB_NO_METHOD_CACHE
+# endif
+
# ifndef KHASH_DEFAULT_SIZE
# define KHASH_DEFAULT_SIZE 16
# endif
@@ -177,10 +206,6 @@
/* A profile for desktop computers or workstations; rich memory! */
#elif defined(MRB_MAIN_PROFILE)
-# ifndef MRB_METHOD_CACHE
-# define MRB_METHOD_CACHE
-# endif
-
# ifndef MRB_METHOD_CACHE_SIZE
# define MRB_METHOD_CACHE_SIZE (1<<10)
# endif
@@ -195,10 +220,6 @@
/* A profile for server; mruby vm is long life */
#elif defined(MRB_HIGH_PROFILE)
-# ifndef MRB_METHOD_CACHE
-# define MRB_METHOD_CACHE
-# endif
-
# ifndef MRB_METHOD_CACHE_SIZE
# define MRB_METHOD_CACHE_SIZE (1<<12)
# endif
diff --git a/include/mruby.h b/include/mruby.h
index 6d884b146c2c8741382ccdc4644ef037072bdef7..52bcd58bfdf7b4b47a83f4044eba8b91b3e3a28e 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -89,9 +89,10 @@
#include <mruby/common.h>
#include <mruby/value.h>
#include <mruby/gc.h>
+#include <mruby/presym.h>
#include <mruby/version.h>
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#include <float.h>
#ifndef FLT_EPSILON
#define FLT_EPSILON (1.19209290e-07f)
@@ -103,7 +104,7 @@
#define LDBL_EPSILON (1.08420217248550443401e-19L)
#endif
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
#define MRB_FLOAT_EPSILON FLT_EPSILON
#else
#define MRB_FLOAT_EPSILON DBL_EPSILON
@@ -146,15 +147,13 @@ typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud);
typedef struct {
mrb_sym mid;
- struct RProc *proc;
+ const struct RProc *proc;
mrb_value *stackent;
- uint16_t ridx;
- uint16_t epos;
struct REnv *env;
const mrb_code *pc; /* return address */
const mrb_code *err; /* error position */
- int argc;
- int acc;
+ mrb_int argc;
+ mrb_int acc;
struct RClass *target_class;
} mrb_callinfo;
@@ -176,22 +175,17 @@ struct mrb_context {
mrb_callinfo *ci;
mrb_callinfo *cibase, *ciend;
- uint16_t *rescue; /* exception handler stack */
- uint16_t rsize;
- struct RProc **ensure; /* ensure handler stack */
- uint16_t esize, eidx;
-
enum mrb_fiber_state status : 4;
mrb_bool vmexec : 1;
struct RFiber *fib;
};
#ifdef MRB_METHOD_CACHE_SIZE
-# define MRB_METHOD_CACHE
+# undef MRB_NO_METHOD_CACHE
#else
-/* default method cache size: 128 */
+/* default method cache size: 256 */
/* cache size needs to be power of 2 */
-# define MRB_METHOD_CACHE_SIZE (1<<7)
+# define MRB_METHOD_CACHE_SIZE (1<<8)
#endif
/**
@@ -205,7 +199,7 @@ struct mrb_context {
*/
typedef mrb_value (*mrb_func_t)(struct mrb_state *mrb, mrb_value self);
-#ifndef MRB_METHOD_T_STRUCT
+#ifndef MRB_USE_METHOD_T_STRUCT
typedef uintptr_t mrb_method_t;
#else
typedef struct {
@@ -217,7 +211,7 @@ typedef struct {
} mrb_method_t;
#endif
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
struct mrb_cache_entry {
struct RClass *c, *c0;
mrb_sym mid;
@@ -251,10 +245,10 @@ typedef struct mrb_state {
struct RClass *hash_class;
struct RClass *range_class;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
struct RClass *float_class;
#endif
- struct RClass *fixnum_class;
+ struct RClass *integer_class;
struct RClass *true_class;
struct RClass *false_class;
struct RClass *nil_class;
@@ -263,7 +257,7 @@ typedef struct mrb_state {
mrb_gc gc;
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
struct mrb_cache_entry cache[MRB_METHOD_CACHE_SIZE];
#endif
@@ -276,8 +270,8 @@ typedef struct mrb_state {
#endif
#ifdef MRB_ENABLE_DEBUG_HOOK
- void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
- void (*debug_op_hook)(struct mrb_state* mrb, struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
+ void (*code_fetch_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
+ void (*debug_op_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
#endif
#ifdef MRB_BYTECODE_DECODE_OPTION
@@ -300,7 +294,6 @@ typedef struct mrb_state {
mrb_atexit_func *atexit_stack;
#endif
uint16_t atexit_stack_len;
- uint16_t ecall_nest; /* prevent infinite recursive ecall() */
} mrb_state;
/**
@@ -325,6 +318,7 @@ typedef struct mrb_state {
* @see mrb_define_class_under
*/
MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super);
+MRB_API struct RClass *mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super);
/**
* Defines a new module.
@@ -334,6 +328,7 @@ MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct
* @return [struct RClass *] Reference to the newly defined module.
*/
MRB_API struct RClass *mrb_define_module(mrb_state *mrb, const char *name);
+MRB_API struct RClass *mrb_define_module_id(mrb_state *mrb, mrb_sym name);
MRB_API mrb_value mrb_singleton_class(mrb_state *mrb, mrb_value val);
MRB_API struct RClass *mrb_singleton_class_ptr(mrb_state *mrb, mrb_value val);
@@ -389,6 +384,7 @@ MRB_API void mrb_prepend_module(mrb_state *mrb, struct RClass *cla, struct RClas
* @param aspec The method parameters declaration.
*/
MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t func, mrb_aspec aspec);
+MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
/**
* Defines a class method.
@@ -416,6 +412,7 @@ MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *n
* @param aspec The method parameters declaration.
*/
MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
+MRB_API void mrb_define_class_method_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
/**
* Defines a singleton method
@@ -423,6 +420,7 @@ MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *cla, const c
* @see mrb_define_class_method
*/
MRB_API void mrb_define_singleton_method(mrb_state *mrb, struct RObject *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
+MRB_API void mrb_define_singleton_method_id(mrb_state *mrb, struct RObject *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
/**
* Defines a module function.
@@ -450,6 +448,7 @@ MRB_API void mrb_define_singleton_method(mrb_state *mrb, struct RObject *cla, co
* @param aspec The method parameters declaration.
*/
MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
+MRB_API void mrb_define_module_function_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
/**
* Defines a constant.
@@ -478,6 +477,7 @@ MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *cla, cons
* @param val The value for the constant.
*/
MRB_API void mrb_define_const(mrb_state* mrb, struct RClass* cla, const char *name, mrb_value val);
+MRB_API void mrb_define_const_id(mrb_state* mrb, struct RClass* cla, mrb_sym name, mrb_value val);
/**
* Undefines a method.
@@ -568,6 +568,7 @@ MRB_API void mrb_undef_method_id(mrb_state*, struct RClass*, mrb_sym);
* @param name The name of the class method to be undefined.
*/
MRB_API void mrb_undef_class_method(mrb_state *mrb, struct RClass *cls, const char *name);
+MRB_API void mrb_undef_class_method_id(mrb_state *mrb, struct RClass *cls, mrb_sym name);
/**
* Initialize a new object instance of c class.
@@ -669,6 +670,7 @@ MRB_API struct RClass * mrb_module_new(mrb_state *mrb);
* @return [mrb_bool] A boolean value.
*/
MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
+MRB_API mrb_bool mrb_class_defined_id(mrb_state *mrb, mrb_sym name);
/**
* Gets a class.
@@ -676,7 +678,8 @@ MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
* @param name The name of the class.
* @return [struct RClass *] A reference to the class.
*/
-MRB_API struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass* mrb_class_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass* mrb_class_get_id(mrb_state *mrb, mrb_sym name);
/**
* Gets a exception class.
@@ -684,7 +687,8 @@ MRB_API struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
* @param name The name of the class.
* @return [struct RClass *] A reference to the class.
*/
-MRB_API struct RClass * mrb_exc_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass* mrb_exc_get_id(mrb_state *mrb, mrb_sym name);
+#define mrb_exc_get(mrb, name) mrb_exc_get_id(mrb, mrb_intern_cstr(mrb, name))
/**
* Returns an mrb_bool. True if inner class was defined, and false if the inner class was not defined.
@@ -716,6 +720,7 @@ MRB_API struct RClass * mrb_exc_get(mrb_state *mrb, const char *name);
* @return [mrb_bool] A boolean value.
*/
MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API mrb_bool mrb_class_defined_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
/**
* Gets a child class.
@@ -725,6 +730,7 @@ MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, c
* @return [struct RClass *] A reference to the class.
*/
MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass * mrb_class_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
/**
* Gets a module.
@@ -733,6 +739,7 @@ MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer
* @return [struct RClass *] A reference to the module.
*/
MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass * mrb_module_get_id(mrb_state *mrb, mrb_sym name);
/**
* Gets a module defined under another module.
@@ -742,6 +749,8 @@ MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
* @return [struct RClass *] A reference to the module.
*/
MRB_API struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass * mrb_module_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
+
/* a function to raise NotImplementedError with current method name */
MRB_API void mrb_notimplement(mrb_state*);
/* a function to be replacement of unimplemented method */
@@ -810,9 +819,11 @@ MRB_API mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mi
* @return [struct RClass *] Reference to the newly defined class
* @see mrb_define_class
*/
-MRB_API struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
+MRB_API struct RClass* mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
+MRB_API struct RClass* mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super);
-MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass* mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass* mrb_define_module_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
/**
* Function requires n arguments.
@@ -879,8 +890,8 @@ MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *o
* | `s` | {String} | const char *, {mrb_int} | Receive two arguments; `s!` gives (`NULL`,`0`) for `nil` |
* | `z` | {String} | const char * | `NULL` terminated string; `z!` gives `NULL` for `nil` |
* | `a` | {Array} | {mrb_value} *, {mrb_int} | Receive two arguments; `a!` gives (`NULL`,`0`) for `nil` |
- * | `f` | {Fixnum}/{Float} | {mrb_float} | |
- * | `i` | {Fixnum}/{Float} | {mrb_int} | |
+ * | `f` | {Integer}/{Float} | {mrb_float} | |
+ * | `i` | {Integer}/{Float} | {mrb_int} | |
* | `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` |
@@ -918,7 +929,7 @@ typedef const char *mrb_args_format;
* const char *kw_names[kw_num] = { "a", "b" };
* uint32_t kw_required = 0;
* mrb_value kw_values[kw_num];
- * const mrb_kwargs kwargs = { kw_num, kw_values, kw_names, kw_required, NULL };
+ * const 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); }
@@ -929,10 +940,10 @@ typedef const char *mrb_args_format;
*
* mrb_value str, kw_rest;
* uint32_t kw_num = 3;
- * const char *kw_names[kw_num] = { "x", "y", "z" };
+ * const mrb_sym kw_names[kw_num] = { MRB_SYM(x), MRB_SYM(y), MRB_SYM(z) };
* uint32_t kw_required = 1;
* mrb_value kw_values[kw_num];
- * const mrb_kwargs kwargs = { kw_num, kw_values, kw_names, kw_required, &kw_rest };
+ * const 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);
@@ -943,11 +954,11 @@ typedef struct mrb_kwargs mrb_kwargs;
struct mrb_kwargs
{
- uint32_t num;
- mrb_value *values;
- const char *const *table;
- uint32_t required;
- mrb_value *rest;
+ uint32_t num; /* number of keyword arguments */
+ uint32_t required; /* number of required keyword arguments */
+ const mrb_sym *table; /* C array of symbols for keyword names */
+ mrb_value *values; /* keyword argument values */
+ mrb_value *rest; /* keyword rest (dict) */
};
/**
@@ -1017,6 +1028,7 @@ MRB_API mrb_value mrb_get_arg1(mrb_state *mrb);
* FILE *fp = fopen("test.rb","r");
* mrb_value obj = mrb_load_file(mrb,fp);
* mrb_funcall(mrb, obj, "method_name", 1, mrb_fixnum_value(i));
+ * mrb_funcall_id(mrb, obj, MRB_SYM(method_name), 1, mrb_fixnum_value(i));
* fclose(fp);
* mrb_close(mrb);
* }
@@ -1029,6 +1041,7 @@ MRB_API mrb_value mrb_get_arg1(mrb_state *mrb);
* @return [mrb_value] mruby function value.
*/
MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, mrb_int argc, ...);
+MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, mrb_int argc, ...);
/**
* Call existing ruby functions. This is basically the type safe version of mrb_funcall.
*
@@ -1038,15 +1051,14 @@ MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, m
* int
* main()
* {
- * mrb_int i = 99;
* mrb_state *mrb = mrb_open();
+ * mrb_value obj = mrb_fixnum_value(1);
*
* if (!mrb) { }
- * mrb_sym m_sym = mrb_intern_lit(mrb, "method_name"); // Symbol for method.
*
* FILE *fp = fopen("test.rb","r");
* mrb_value obj = mrb_load_file(mrb,fp);
- * mrb_funcall_argv(mrb, obj, m_sym, 1, &obj); // Calling ruby function from test.rb.
+ * mrb_funcall_argv(mrb, obj, MRB_SYM(method_name), 1, &obj); // Calling ruby function from test.rb.
* fclose(fp);
* mrb_close(mrb);
* }
@@ -1064,7 +1076,7 @@ MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name,
*/
MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv, mrb_value block);
/**
- * Create a symbol
+ * Create a symbol from C string. But usually it's better to use MRB_SYM(sym) and MRB_QSYM(qsym).
*
* Example:
*
@@ -1072,7 +1084,9 @@ MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym
* :pizza # => :pizza
*
* // C style:
- * mrb_sym m_sym = mrb_intern_lit(mrb, "pizza"); // => :pizza
+ * mrb_sym sym1 = mrb_intern_lit(mrb, "pizza"); // => :pizza
+ * mrb_sym sym2 = MRB_SYM(pizza); // => :pizza
+ * mrb_sym sym3 = MRB_SYM(pizza_p); // => :pizza?
*
* @param mrb The current mruby state.
* @param str The string to be symbolized
@@ -1081,8 +1095,14 @@ MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym
MRB_API mrb_sym mrb_intern_cstr(mrb_state *mrb, const char* str);
MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t);
MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
-#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, lit, mrb_strlen_lit(lit))
+#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
MRB_API mrb_sym mrb_intern_str(mrb_state*,mrb_value);
+/* mrb_intern_check series functions returns 0 if the symbol is not defined */
+MRB_API mrb_sym mrb_intern_check_cstr(mrb_state*,const char*);
+MRB_API mrb_sym mrb_intern_check(mrb_state*,const char*,size_t);
+MRB_API mrb_sym mrb_intern_check_str(mrb_state*,mrb_value);
+/* mrb_check_intern series functions returns nil if the symbol is not defined */
+/* otherwise returns mrb_value */
MRB_API mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
MRB_API mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
MRB_API mrb_value mrb_check_intern_str(mrb_state*,mrb_value);
@@ -1180,9 +1200,9 @@ MRB_API void mrb_close(mrb_state *mrb);
MRB_API void* mrb_default_allocf(mrb_state*, void*, size_t, void*);
MRB_API mrb_value mrb_top_self(mrb_state *mrb);
-MRB_API mrb_value mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep);
-MRB_API mrb_value mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep);
-MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *iseq);
+MRB_API mrb_value mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep);
+MRB_API mrb_value mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep);
+MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *iseq);
/* compatibility macros */
#define mrb_toplevel_run_keep(m,p,k) mrb_top_run((m),(p),mrb_top_self(m),(k))
#define mrb_toplevel_run(m,p) mrb_toplevel_run_keep((m),(p),0)
@@ -1197,7 +1217,7 @@ MRB_API mrb_bool mrb_obj_equal(mrb_state *mrb, mrb_value a, mrb_value b);
MRB_API mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
MRB_API mrb_value mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base);
MRB_API mrb_value mrb_Integer(mrb_state *mrb, mrb_value val);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val);
#endif
MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj);
@@ -1230,12 +1250,15 @@ MRB_API void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*
} while (0)
MRB_API void mrb_write_barrier(mrb_state *, struct RBasic*);
-MRB_API mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
+MRB_API mrb_value mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method);
+#define mrb_convert_type(mrb, val, type, tname, method) mrb_type_convert(mrb, val, type, mrb_intern_lit(mrb, method))
+MRB_API mrb_value mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method);
+#define mrb_check_convert_type(mrb, val, type, tname, method) mrb_type_convert_check(mrb, val, type, mrb_intern_lit(mrb, method))
+
MRB_API mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj);
MRB_API const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj);
MRB_API struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj);
MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c);
-MRB_API mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
MRB_API mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
MRB_API mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self);
MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
@@ -1276,25 +1299,26 @@ MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap);
+ those E_* macros requires mrb_state* variable named mrb.
+ exception objects obtained from those macros are local to mrb
*/
-#define E_RUNTIME_ERROR (mrb_exc_get(mrb, "RuntimeError"))
-#define E_TYPE_ERROR (mrb_exc_get(mrb, "TypeError"))
-#define E_ARGUMENT_ERROR (mrb_exc_get(mrb, "ArgumentError"))
-#define E_INDEX_ERROR (mrb_exc_get(mrb, "IndexError"))
-#define E_RANGE_ERROR (mrb_exc_get(mrb, "RangeError"))
-#define E_NAME_ERROR (mrb_exc_get(mrb, "NameError"))
-#define E_NOMETHOD_ERROR (mrb_exc_get(mrb, "NoMethodError"))
-#define E_SCRIPT_ERROR (mrb_exc_get(mrb, "ScriptError"))
-#define E_SYNTAX_ERROR (mrb_exc_get(mrb, "SyntaxError"))
-#define E_LOCALJUMP_ERROR (mrb_exc_get(mrb, "LocalJumpError"))
-#define E_REGEXP_ERROR (mrb_exc_get(mrb, "RegexpError"))
-#define E_FROZEN_ERROR (mrb_exc_get(mrb, "FrozenError"))
-
-#define E_NOTIMP_ERROR (mrb_exc_get(mrb, "NotImplementedError"))
-#ifndef MRB_WITHOUT_FLOAT
-#define E_FLOATDOMAIN_ERROR (mrb_exc_get(mrb, "FloatDomainError"))
+#define E_RUNTIME_ERROR (mrb_exc_get_id(mrb, MRB_SYM(RuntimeError)))
+#define E_TYPE_ERROR (mrb_exc_get_id(mrb, MRB_SYM(TypeError)))
+#define E_ZERODIV_ERROR (mrb_exc_get_id(mrb, MRB_SYM(ZeroDivisionError)))
+#define E_ARGUMENT_ERROR (mrb_exc_get_id(mrb, MRB_SYM(ArgumentError)))
+#define E_INDEX_ERROR (mrb_exc_get_id(mrb, MRB_SYM(IndexError)))
+#define E_RANGE_ERROR (mrb_exc_get_id(mrb, MRB_SYM(RangeError)))
+#define E_NAME_ERROR (mrb_exc_get_id(mrb, MRB_SYM(NameError)))
+#define E_NOMETHOD_ERROR (mrb_exc_get_id(mrb, MRB_SYM(NoMethodError)))
+#define E_SCRIPT_ERROR (mrb_exc_get_id(mrb, MRB_SYM(ScriptError)))
+#define E_SYNTAX_ERROR (mrb_exc_get_id(mrb, MRB_SYM(SyntaxError)))
+#define E_LOCALJUMP_ERROR (mrb_exc_get_id(mrb, MRB_SYM(LocalJumpError)))
+#define E_REGEXP_ERROR (mrb_exc_get_id(mrb, MRB_SYM(RegexpError)))
+#define E_FROZEN_ERROR (mrb_exc_get_id(mrb, MRB_SYM(FrozenError)))
+
+#define E_NOTIMP_ERROR (mrb_exc_get_id(mrb, MRB_SYM(NotImplementedError)))
+#ifndef MRB_NO_FLOAT
+#define E_FLOATDOMAIN_ERROR (mrb_exc_get_id(mrb, MRB_SYM(FloatDomainError)))
#endif
-#define E_KEY_ERROR (mrb_exc_get(mrb, "KeyError"))
+#define E_KEY_ERROR (mrb_exc_get_id(mrb, MRB_SYM(KeyError)))
MRB_API mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
MRB_API mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv);
@@ -1313,7 +1337,7 @@ MRB_API void mrb_gc_register(mrb_state *mrb, mrb_value obj);
MRB_API void mrb_gc_unregister(mrb_state *mrb, mrb_value obj);
MRB_API mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
-#define mrb_int(mrb, val) mrb_fixnum(mrb_to_int(mrb, val))
+#define mrb_int(mrb, val) mrb_integer(mrb_to_int(mrb, val))
/* string type checking (contrary to the name, it doesn't convert) */
MRB_API mrb_value mrb_to_str(mrb_state *mrb, mrb_value val);
MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
@@ -1324,6 +1348,7 @@ MRB_INLINE void mrb_check_frozen(mrb_state *mrb, void *o)
}
MRB_API void mrb_define_alias(mrb_state *mrb, struct RClass *c, const char *a, const char *b);
+MRB_API void mrb_define_alias_id(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b);
MRB_API const char *mrb_class_name(mrb_state *mrb, struct RClass* klass);
MRB_API void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
@@ -1360,7 +1385,7 @@ MRB_API mrb_value mrb_fiber_alive_p(mrb_state *mrb, mrb_value fib);
*
* Implemented in mruby-fiber
*/
-#define E_FIBER_ERROR (mrb_exc_get(mrb, "FiberError"))
+#define E_FIBER_ERROR (mrb_exc_get_id(mrb, MRB_SYM(FiberError)))
MRB_API void mrb_stack_extend(mrb_state*, mrb_int);
/* memory pool implementation */
diff --git a/include/mruby/array.h b/include/mruby/array.h
index 92c86a8c57f5862f88eb258f34a44189668ef23f..5164efa69d8b2054145bd98ed56dd0556ad7d89c 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -21,7 +21,14 @@ typedef struct mrb_shared_array {
mrb_value *ptr;
} mrb_shared_array;
-#define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
+#if defined(MRB_32BIT) && defined(MRB_NO_BOXING)
+# define MRB_ARY_NO_EMBED
+# define MRB_ARY_EMBED_LEN_MAX 0
+#else
+# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
+mrb_static_assert(MRB_ARY_EMBED_LEN_MAX > 0, "MRB_ARY_EMBED_LEN_MAX > 0");
+#endif
+
struct RArray {
MRB_OBJECT_HEADER;
union {
@@ -33,7 +40,9 @@ struct RArray {
} aux;
mrb_value *ptr;
} heap;
- void *ary[3];
+#ifndef MRB_ARY_NO_EMBED
+ mrb_value ary[MRB_ARY_EMBED_LEN_MAX];
+#endif
} as;
};
@@ -41,13 +50,21 @@ struct RArray {
#define mrb_ary_value(p) mrb_obj_value((void*)(p))
#define RARRAY(v) ((struct RArray*)(mrb_ptr(v)))
+#ifdef MRB_ARY_NO_EMBED
+#define ARY_EMBED_P(a) 0
+#define ARY_UNSET_EMBED_FLAG(a) (void)0
+#define ARY_EMBED_LEN(a) 0
+#define ARY_SET_EMBED_LEN(a,len) (void)0
+#define ARY_EMBED_PTR(a) 0
+#else
#define MRB_ARY_EMBED_MASK 7
#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
#define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK))
#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
-#define ARY_EMBED_PTR(a) ((mrb_value*)(&(a)->as.ary))
-
+#define ARY_EMBED_PTR(a) ((a)->as.ary)
+#endif
+
#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(a)->as.heap.len)
#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h
index fae3b76303a77a887d269b49f28d5c9f210d8502..3a99aeca6964d3914c9763f4bdea6e191cb5eecc 100644
--- a/include/mruby/boxing_nan.h
+++ b/include/mruby/boxing_nan.h
@@ -7,12 +7,12 @@
#ifndef MRUBY_BOXING_NAN_H
#define MRUBY_BOXING_NAN_H
-#ifdef MRB_USE_FLOAT
-# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT conflict <<----
+#ifdef MRB_USE_FLOAT32
+# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT32 conflict <<----
#endif
-#ifdef MRB_WITHOUT_FLOAT
-# error ---->> MRB_NAN_BOXING and MRB_WITHOUT_FLOAT conflict <<----
+#ifdef MRB_NO_FLOAT
+# error ---->> MRB_NAN_BOXING and MRB_NO_FLOAT conflict <<----
#endif
#ifdef MRB_INT64
@@ -30,76 +30,91 @@
* In order to get enough bit size to save TT, all pointers are shifted 2 bits
* in the right direction. Also, TTTTTT is the mrb_vtype + 1;
*/
-typedef struct mrb_value {
- union {
- mrb_float f;
- union {
- void *p;
- struct {
- MRB_ENDIAN_LOHI(
- uint32_t ttt;
- ,union {
- mrb_int i;
- mrb_sym sym;
- };
- )
- };
+typedef uint64_t mrb_value;
+
+union mrb_value_ {
+ mrb_float f;
+ uint64_t u;
#ifdef MRB_64BIT
- struct RCptr *vp;
+ void *p;
#endif
- } value;
+ struct {
+ MRB_ENDIAN_LOHI(
+ uint32_t ttt;
+ ,uint32_t i;
+ )
};
-} mrb_value;
+};
-#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
+static inline union mrb_value_
+mrb_val_union(mrb_value v)
+{
+ union mrb_value_ x;
+ x.u = v;
+ return x;
+}
-#define mrb_tt(o) ((enum mrb_vtype)(((o).value.ttt & 0xfc000)>>14)-1)
-#define mrb_type(o) (enum mrb_vtype)((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT)
-#define mrb_ptr(o) ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2))
-#define mrb_float(o) (o).f
-#define mrb_fixnum(o) (o).value.i
-#define mrb_symbol(o) (o).value.sym
+#define mrb_tt(o) ((enum mrb_vtype)((mrb_val_union(o).ttt & 0xfc000)>>14)-1)
+#define mrb_type(o) (enum mrb_vtype)((uint32_t)0xfff00000 < mrb_val_union(o).ttt ? mrb_tt(o) : MRB_TT_FLOAT)
+#define mrb_float(o) mrb_val_union(o).f
+#define mrb_fixnum(o) ((mrb_int)mrb_val_union(o).i)
+#define mrb_integer(o) mrb_fixnum(o)
+#define mrb_symbol(o) ((mrb_sym)mrb_val_union(o).i)
#ifdef MRB_64BIT
-MRB_API mrb_value mrb_nan_boxing_cptr_value(struct mrb_state*, void*);
+#define mrb_ptr(o) ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)(mrb_val_union(o).p)))<<2))
#define mrb_cptr(o) (((struct RCptr*)mrb_ptr(o))->p)
#define BOXNAN_SHIFT_LONG_POINTER(v) (((uintptr_t)(v)>>34)&0x3fff)
#else
-#define mrb_cptr(o) ((o).value.p)
+#define mrb_ptr(o) ((void*)mrb_val_union(o).i)
+#define mrb_cptr(o) mrb_ptr(o)
#define BOXNAN_SHIFT_LONG_POINTER(v) 0
#endif
-#define BOXNAN_SET_VALUE(o, tt, attr, v) do {\
- (o).attr = (v);\
- (o).value.ttt = 0xfff00000 | (((tt)+1)<<14);\
+#define BOXNAN_SET_VALUE(o, tt, attr, v) do { \
+ union mrb_value_ mrb_value_union_variable; \
+ mrb_value_union_variable.attr = (v);\
+ mrb_value_union_variable.ttt = 0xfff00000 | (((tt)+1)<<14);\
+ o = mrb_value_union_variable.u;\
} while (0)
+#ifdef MRB_64BIT
#define BOXNAN_SET_OBJ_VALUE(o, tt, v) do {\
- (o).value.p = (void*)((uintptr_t)(v)>>2);\
- (o).value.ttt = (0xfff00000|(((tt)+1)<<14)|BOXNAN_SHIFT_LONG_POINTER(v));\
+ union mrb_value_ mrb_value_union_variable;\
+ mrb_value_union_variable.p = (void*)((uintptr_t)(v)>>2);\
+ mrb_value_union_variable.ttt = (0xfff00000|(((tt)+1)<<14)|BOXNAN_SHIFT_LONG_POINTER(v));\
+ o = mrb_value_union_variable.u;\
} while (0)
+#else
+#define BOXNAN_SET_OBJ_VALUE(o, tt, v) BOXNAN_SET_VALUE(o, tt, i, (uint32_t)v)
+#endif
#define SET_FLOAT_VALUE(mrb,r,v) do { \
- if ((v) != (v)) { \
- (r).value.ttt = 0x7ff80000; \
- (r).value.i = 0; \
+ union mrb_value_ mrb_value_union_variable; \
+ if ((v) != (v)) { /* NaN */ \
+ mrb_value_union_variable.ttt = 0x7ff80000; \
+ mrb_value_union_variable.i = 0; \
} \
else { \
- (r).f = v; \
- }} while(0)
+ mrb_value_union_variable.f = (v); \
+ } \
+ r = mrb_value_union_variable.u; \
+} while(0)
-#define SET_NIL_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
-#define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
-#define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
-#define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
+#define SET_NIL_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, i, 0)
+#define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, i, 1)
+#define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, i, 1)
+#define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, i, 1)
+#define SET_INT_VALUE(mrb, r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n))
+#define SET_FIXNUM_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n))
+#define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, i, (uint32_t)(v))
#define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v))
#ifdef MRB_64BIT
+MRB_API mrb_value mrb_nan_boxing_cptr_value(struct mrb_state*, void*);
#define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_nan_boxing_cptr_value(mrb, v))
#else
-#define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_VALUE(r, MRB_TT_CPTR, value.p, v)
+#define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_VALUE(r, MRB_TT_CPTR, p, v)
#endif
-#define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
+#define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, i, 0)
#endif /* MRUBY_BOXING_NAN_H */
diff --git a/include/mruby/boxing_no.h b/include/mruby/boxing_no.h
index 7573428e675cc773711515bb4b6b668dd8b1fb87..0b14590d9a39c77cb5b082e0a24a2ef12344be5a 100644
--- a/include/mruby/boxing_no.h
+++ b/include/mruby/boxing_no.h
@@ -11,7 +11,7 @@
#define MRB_SYMBOL_SHIFT 0
union mrb_value_union {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
mrb_float f;
#endif
void *p;
@@ -24,16 +24,13 @@ typedef struct mrb_value {
enum mrb_vtype tt;
} mrb_value;
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
-#endif
-
#define mrb_ptr(o) (o).value.p
#define mrb_cptr(o) mrb_ptr(o)
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#define mrb_float(o) (o).value.f
#endif
#define mrb_fixnum(o) (o).value.i
+#define mrb_integer(o) mrb_fixnum(o)
#define mrb_symbol(o) (o).value.sym
#define mrb_type(o) (o).tt
@@ -46,8 +43,9 @@ typedef struct mrb_value {
#define SET_FALSE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
#define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
#define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#ifndef MRB_WITHOUT_FLOAT
+#define SET_INT_VALUE(mrb,r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#define SET_FIXNUM_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#ifndef MRB_NO_FLOAT
#define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v))
#endif
#define SET_SYM_VALUE(r,v) BOXNIX_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h
index 1b7815b7f5e8ee1881bff8d409882ac662571dd7..d7b5ff9903458fe0568c4182fc673fc1211fbe9c 100644
--- a/include/mruby/boxing_word.h
+++ b/include/mruby/boxing_word.h
@@ -11,13 +11,18 @@
#error MRB_INT64 cannot be used with MRB_WORD_BOXING in 32-bit mode.
#endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
struct RFloat {
MRB_OBJECT_HEADER;
mrb_float f;
};
#endif
+struct RInteger {
+ MRB_OBJECT_HEADER;
+ mrb_int i;
+};
+
enum mrb_special_consts {
MRB_Qnil = 0,
MRB_Qfalse = 4,
@@ -47,13 +52,13 @@ enum mrb_special_consts {
#define BOXWORD_IMMEDIATE_MASK 0x07
#define BOXWORD_SHIFT_VALUE(o,n,t) \
- (t)(((long)(o).w) >> BOXWORD_##n##_SHIFT)
+ (t)(((intptr_t)(o)) >> BOXWORD_##n##_SHIFT)
#define BOXWORD_SET_SHIFT_VALUE(o,n,v) \
- ((o).w = (((unsigned long)(v)) << BOXWORD_##n##_SHIFT) | BOXWORD_##n##_FLAG)
+ ((o) = (((uintptr_t)(v)) << BOXWORD_##n##_SHIFT) | BOXWORD_##n##_FLAG)
#define BOXWORD_SHIFT_VALUE_P(o,n) \
- (((o).w & BOXWORD_##n##_MASK) == BOXWORD_##n##_FLAG)
+ (((o) & BOXWORD_##n##_MASK) == BOXWORD_##n##_FLAG)
#define BOXWORD_OBJ_TYPE_P(o,n) \
- (!mrb_immediate_p(o) && (o).value.bp->tt == MRB_TT_##n)
+ (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
/*
* mrb_value representation:
@@ -66,62 +71,74 @@ enum mrb_special_consts {
* symbol: ...SSSS SS10 (use only upper 32-bit as symbol value on 64-bit CPU)
* object: ...PPPP P000 (any bits are 1)
*/
-typedef union mrb_value {
- union {
- void *p;
+typedef uintptr_t mrb_value;
+union mrb_value_ {
+ void *p;
#ifdef MRB_64BIT
- /* use struct to avoid bit shift. */
- struct {
- MRB_ENDIAN_LOHI(
- mrb_sym sym;
- ,uint32_t sym_flag;
- )
- };
+ /* use struct to avoid bit shift. */
+ struct {
+ MRB_ENDIAN_LOHI(
+ mrb_sym sym;
+ ,uint32_t sym_flag;
+ )
+ };
#endif
- struct RBasic *bp;
-#ifndef MRB_WITHOUT_FLOAT
- struct RFloat *fp;
+ struct RBasic *bp;
+#ifndef MRB_NO_FLOAT
+ struct RFloat *fp;
#endif
- struct RCptr *vp;
- } value;
- unsigned long w;
-} mrb_value;
+ struct RInteger *ip;
+ struct RCptr *vp;
+ uintptr_t w;
+};
+
+static inline union mrb_value_
+mrb_val_union(mrb_value v)
+{
+ union mrb_value_ x;
+ x.w = v;
+ return x;
+}
MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
-MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float);
#endif
+MRB_API mrb_value mrb_word_boxing_int_value(struct mrb_state*, mrb_int);
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_pool(mrb,f) mrb_word_boxing_float_pool(mrb,f)
-#endif
+#define mrb_immediate_p(o) ((o) & BOXWORD_IMMEDIATE_MASK || (o) == MRB_Qnil)
-#define mrb_ptr(o) (o).value.p
-#define mrb_cptr(o) (o).value.vp->p
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float(o) (o).value.fp->f
+#define mrb_ptr(o) mrb_val_union(o).p
+#define mrb_cptr(o) mrb_val_union(o).vp->p
+#ifndef MRB_NO_FLOAT
+#define mrb_float(o) mrb_val_union(o).fp->f
#endif
#define mrb_fixnum(o) BOXWORD_SHIFT_VALUE(o, FIXNUM, mrb_int)
+MRB_INLINE mrb_int
+mrb_integer_func(mrb_value o) {
+ if (mrb_immediate_p(o)) return mrb_fixnum(o);
+ return mrb_val_union(o).ip->i;
+}
+#define mrb_integer(o) mrb_integer_func(o)
#ifdef MRB_64BIT
-#define mrb_symbol(o) (o).value.sym
+#define mrb_symbol(o) mrb_val_union(o).sym
#else
#define mrb_symbol(o) BOXWORD_SHIFT_VALUE(o, SYMBOL, mrb_sym)
#endif
-#define mrb_bool(o) (((o).w & ~(unsigned long)MRB_Qfalse) != 0)
+#define mrb_bool(o) (((o) & ~(unsigned long)MRB_Qfalse) != 0)
-#define mrb_immediate_p(o) ((o).w & BOXWORD_IMMEDIATE_MASK || (o).w == MRB_Qnil)
#define mrb_fixnum_p(o) BOXWORD_SHIFT_VALUE_P(o, FIXNUM)
+#define mrb_integer_p(o) (BOXWORD_SHIFT_VALUE_P(o, FIXNUM)||BOXWORD_OBJ_TYPE_P(o, INTEGER))
#ifdef MRB_64BIT
-#define mrb_symbol_p(o) ((o).value.sym_flag == BOXWORD_SYMBOL_FLAG)
+#define mrb_symbol_p(o) (mrb_val_union(o).sym_flag == BOXWORD_SYMBOL_FLAG)
#else
#define mrb_symbol_p(o) BOXWORD_SHIFT_VALUE_P(o, SYMBOL)
#endif
-#define mrb_undef_p(o) ((o).w == MRB_Qundef)
-#define mrb_nil_p(o) ((o).w == MRB_Qnil)
-#define mrb_false_p(o) ((o).w == MRB_Qfalse)
-#define mrb_true_p(o) ((o).w == MRB_Qtrue)
-#ifndef MRB_WITHOUT_FLOAT
+#define mrb_undef_p(o) ((o) == MRB_Qundef)
+#define mrb_nil_p(o) ((o) == MRB_Qnil)
+#define mrb_false_p(o) ((o) == MRB_Qfalse)
+#define mrb_true_p(o) ((o) == MRB_Qtrue)
+#ifndef MRB_NO_FLOAT
#define mrb_float_p(o) BOXWORD_OBJ_TYPE_P(o, FLOAT)
#endif
#define mrb_array_p(o) BOXWORD_OBJ_TYPE_P(o, ARRAY)
@@ -143,32 +160,38 @@ MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float);
#define mrb_istruct_p(o) BOXWORD_OBJ_TYPE_P(o, ISTRUCT)
#define mrb_break_p(o) BOXWORD_OBJ_TYPE_P(o, BREAK)
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
#endif
#define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_word_boxing_cptr_value(mrb, v))
-#define SET_UNDEF_VALUE(r) ((r).w = MRB_Qundef)
-#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
-#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
-#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
+#define SET_UNDEF_VALUE(r) ((r) = MRB_Qundef)
+#define SET_NIL_VALUE(r) ((r) = MRB_Qnil)
+#define SET_FALSE_VALUE(r) ((r) = MRB_Qfalse)
+#define SET_TRUE_VALUE(r) ((r) = MRB_Qtrue)
#define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
-#define SET_INT_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n)
+#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_word_boxing_int_value(mrb, n))
+#define SET_FIXNUM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n)
#ifdef MRB_64BIT
-#define SET_SYM_VALUE(r,v) ((r).value.sym = v, (r).value.sym_flag = BOXWORD_SYMBOL_FLAG)
+#define SET_SYM_VALUE(r,v) do {\
+ union mrb_value_ mrb_value_union_variable;\
+ mrb_value_union_variable.sym = v;\
+ mrb_value_union_variable.sym_flag = BOXWORD_SYMBOL_FLAG;\
+ (r) = mrb_value_union_variable.w;\
+} while (0)
#else
#define SET_SYM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, SYMBOL, n)
#endif
-#define SET_OBJ_VALUE(r,v) ((r).value.p = v)
+#define SET_OBJ_VALUE(r,v) ((r) = (uintptr_t)v)
MRB_INLINE enum mrb_vtype
mrb_type(mrb_value o)
{
return !mrb_bool(o) ? MRB_TT_FALSE :
mrb_true_p(o) ? MRB_TT_TRUE :
- mrb_fixnum_p(o) ? MRB_TT_FIXNUM :
+ mrb_fixnum_p(o) ? MRB_TT_INTEGER :
mrb_symbol_p(o) ? MRB_TT_SYMBOL :
mrb_undef_p(o) ? MRB_TT_UNDEF :
- o.value.bp->tt;
+ mrb_val_union(o).bp->tt;
}
#endif /* MRUBY_BOXING_WORD_H */
diff --git a/include/mruby/class.h b/include/mruby/class.h
index cbf96fef22781bd6ff798e0d93b75296e58a96bd..c88079e59b295b1d1d1e1125cadc72cbf26e5b52 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -17,7 +17,7 @@ MRB_BEGIN_DECL
struct RClass {
MRB_OBJECT_HEADER;
struct iv_tbl *iv;
- struct kh_mt *mt;
+ struct mt_tbl *mt;
struct RClass *super;
};
@@ -35,9 +35,9 @@ mrb_class(mrb_state *mrb, mrb_value v)
return mrb->true_class;
case MRB_TT_SYMBOL:
return mrb->symbol_class;
- case MRB_TT_FIXNUM:
- return mrb->fixnum_class;
-#ifndef MRB_WITHOUT_FLOAT
+ case MRB_TT_INTEGER:
+ return mrb->integer_class;
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
return mrb->float_class;
#endif
@@ -73,13 +73,11 @@ 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)
-MRB_API struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*);
-MRB_API struct RClass* mrb_define_module_id(mrb_state*, mrb_sym);
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_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
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);
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);
@@ -95,12 +93,17 @@ 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*);
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
void mrb_mc_clear_by_class(mrb_state *mrb, struct RClass* c);
#else
#define mrb_mc_clear_by_class(mrb,c)
#endif
+/* return non zero to break the loop */
+struct mt_elem;
+typedef int (mrb_mt_foreach_func)(mrb_state*,mrb_sym,struct mt_elem*,void*);
+MRB_API void mrb_mt_foreach(mrb_state*, struct RClass*, mrb_mt_foreach_func*, void*);
+
MRB_END_DECL
#endif /* MRUBY_CLASS_H */
diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index e8ab91eb9608746db1b3d3bfa21985b805fb5c92..36adf5a32b7aa320731b600d9d3a67668c56f60a 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -33,7 +33,7 @@ typedef struct mrbc_context {
mrb_bool no_exec:1;
mrb_bool keep_lv:1;
mrb_bool no_optimize:1;
- struct RProc *upper;
+ const struct RProc *upper;
size_t parser_nerr;
} mrbc_context;
@@ -153,7 +153,7 @@ struct mrb_parser_state {
mrb_bool no_optimize:1;
mrb_bool capture_errors:1;
- struct RProc *upper;
+ const struct RProc *upper;
struct mrb_parser_message error_buffer[10];
struct mrb_parser_message warn_buffer[10];
diff --git a/include/mruby/debug.h b/include/mruby/debug.h
index 5c5d569240ea24ddbf64b086752c1c45c8f766fb..f22c7c77bec07b5d48083e73aa9686f42420bc72 100644
--- a/include/mruby/debug.h
+++ b/include/mruby/debug.h
@@ -46,7 +46,7 @@ typedef struct mrb_irep_debug_info {
* get line from irep's debug info and program counter
* @return returns NULL if not found
*/
-MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc);
+MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t pc);
/*
* get line from irep's debug info and program counter
diff --git a/include/mruby/dump.h b/include/mruby/dump.h
index db3e287d38134362ffb88bf40a0ed84c96029a25..90eaca18434021ba8ad943984af67bc4307f1747 100644
--- a/include/mruby/dump.h
+++ b/include/mruby/dump.h
@@ -18,10 +18,11 @@ MRB_BEGIN_DECL
#define DUMP_DEBUG_INFO 1
-int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
+int mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
#ifndef MRB_DISABLE_STDIO
-int mrb_dump_irep_binary(mrb_state*, mrb_irep*, uint8_t, FILE*);
-int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, uint8_t flags, FILE *f, const char *initname);
+int mrb_dump_irep_binary(mrb_state*, const mrb_irep*, uint8_t, FILE*);
+int mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname);
+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*);
@@ -48,11 +49,16 @@ MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t);
/* Rite Binary File header */
#define RITE_BINARY_IDENT "RITE"
-#define RITE_BINARY_FORMAT_VER "0007"
+/* Binary Format Version Major:Minor */
+/* Major: Incompatible to prior versions */
+/* Minor: Upper-compatible to prior versions */
+#define RITE_BINARY_MAJOR_VER "01"
+#define RITE_BINARY_MINOR_VER "00"
+#define RITE_BINARY_FORMAT_VER RITE_BINARY_MAJOR_VER RITE_BINARY_MINOR_VER
#define RITE_COMPILER_NAME "MATZ"
#define RITE_COMPILER_VERSION "0000"
-#define RITE_VM_VER "0002"
+#define RITE_VM_VER "0300"
#define RITE_BINARY_EOF "END\0"
#define RITE_SECTION_IREP_IDENT "IREP"
@@ -65,7 +71,8 @@ MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t);
/* binary header */
struct rite_binary_header {
uint8_t binary_ident[4]; /* Binary Identifier */
- uint8_t binary_version[4]; /* Binary Format Version */
+ uint8_t major_version[2]; /* Binary Format Major Version */
+ uint8_t minor_version[2]; /* Binary Format Minor Version */
uint8_t binary_crc[2]; /* Binary CRC */
uint8_t binary_size[4]; /* Binary Size */
uint8_t compiler_name[4]; /* Compiler name */
@@ -126,16 +133,6 @@ uint32_to_bin(uint32_t l, uint8_t *bin)
return sizeof(uint32_t);
}
-static inline size_t
-uint32l_to_bin(uint32_t l, uint8_t *bin)
-{
- bin[3] = (l >> 24) & 0xff;
- bin[2] = (l >> 16) & 0xff;
- bin[1] = (l >> 8) & 0xff;
- bin[0] = l & 0xff;
- return sizeof(uint32_t);
-}
-
static inline uint32_t
bin_to_uint32(const uint8_t *bin)
{
@@ -145,15 +142,6 @@ bin_to_uint32(const uint8_t *bin)
(uint32_t)bin[3];
}
-static inline uint32_t
-bin_to_uint32l(const uint8_t *bin)
-{
- return (uint32_t)bin[3] << 24 |
- (uint32_t)bin[2] << 16 |
- (uint32_t)bin[1] << 8 |
- (uint32_t)bin[0];
-}
-
static inline uint16_t
bin_to_uint16(const uint8_t *bin)
{
diff --git a/include/mruby/endian.h b/include/mruby/endian.h
new file mode 100644
index 0000000000000000000000000000000000000000..477f3bc94e09f3398d88765d8c7bfa614676d054
--- /dev/null
+++ b/include/mruby/endian.h
@@ -0,0 +1,44 @@
+/**
+** @file mruby/endian.h - detect endian-ness
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ENDIAN_H
+#define MRUBY_ENDIAN_H
+
+#include <limits.h>
+
+MRB_BEGIN_DECL
+
+#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER__)
+# define BYTE_ORDER __BYTE_ORDER__
+#endif
+#if !defined(BIG_ENDIAN) && defined(__ORDER_BIG_ENDIAN__)
+# define BIG_ENDIAN __ORDER_BIG_ENDIAN__
+#endif
+#if !defined(LITTLE_ENDIAN) && defined(__ORDER_LITTLE_ENDIAN__)
+# define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__
+#endif
+
+#ifdef BYTE_ORDER
+# if BYTE_ORDER == BIG_ENDIAN
+# define littleendian 0
+# elif BYTE_ORDER == LITTLE_ENDIAN
+# define littleendian 1
+# endif
+#endif
+#ifndef littleendian
+/* can't distinguish endian in compile time */
+static inline int
+check_little_endian(void)
+{
+ unsigned int n = 1;
+ return (*(unsigned char *)&n == 1);
+}
+# define littleendian check_little_endian()
+#endif
+
+MRB_END_DECL
+
+#endif /* MRUBY_ENDIAN_H */
diff --git a/include/mruby/error.h b/include/mruby/error.h
index d24b5b0c3ed19df1848229de49dc18c13df5ab9c..9ad115f4b40f60b216f491bbc47feb9030a2ce9f 100644
--- a/include/mruby/error.h
+++ b/include/mruby/error.h
@@ -23,7 +23,8 @@ struct RException {
MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg);
MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
-#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+#define mrb_exc_new_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str_lit(mrb, c, lit)
MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb);
@@ -32,10 +33,10 @@ MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_va
/* declaration for `fail` method */
MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
-#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING)
+#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING)
struct RBreak {
MRB_OBJECT_HEADER;
- struct RProc *proc;
+ const struct RProc *proc;
mrb_value val;
};
#define mrb_break_value_get(brk) ((brk)->val)
@@ -43,7 +44,7 @@ struct RBreak {
#else
struct RBreak {
MRB_OBJECT_HEADER;
- struct RProc *proc;
+ const struct RProc *proc;
union mrb_value_union value;
};
#define RBREAK_VALUE_TT_MASK ((1 << 8) - 1)
@@ -62,10 +63,43 @@ mrb_break_value_set(struct RBreak *brk, mrb_value val)
brk->flags &= ~RBREAK_VALUE_TT_MASK;
brk->flags |= val.tt;
}
-#endif /* MRB_64BIT || MRB_USE_FLOAT || MRB_NAN_BOXING || MRB_WORD_BOXING */
+#endif /* MRB_64BIT || MRB_USE_FLOAT32 || MRB_NAN_BOXING || MRB_WORD_BOXING */
#define mrb_break_proc_get(brk) ((brk)->proc)
#define mrb_break_proc_set(brk, p) ((brk)->proc = p)
+#define RBREAK_TAG_FOREACH(f) \
+ f(RBREAK_TAG_BREAK, 0) \
+ f(RBREAK_TAG_BREAK_UPPER, 1) \
+ f(RBREAK_TAG_BREAK_INTARGET, 2) \
+ f(RBREAK_TAG_RETURN_BLOCK, 3) \
+ f(RBREAK_TAG_RETURN, 4) \
+ f(RBREAK_TAG_RETURN_TOPLEVEL, 5) \
+ f(RBREAK_TAG_JUMP, 6) \
+ f(RBREAK_TAG_STOP, 7)
+
+#define RBREAK_TAG_DEFINE(tag, i) tag = i,
+enum {
+ RBREAK_TAG_FOREACH(RBREAK_TAG_DEFINE)
+};
+#undef RBREAK_TAG_DEFINE
+
+#define RBREAK_TAG_BIT 3
+#define RBREAK_TAG_BIT_OFF 8
+#define RBREAK_TAG_MASK (~(~UINT32_C(0) << RBREAK_TAG_BIT))
+
+static inline uint32_t
+mrb_break_tag_get(struct RBreak *brk)
+{
+ return (brk->flags >> RBREAK_TAG_BIT_OFF) & RBREAK_TAG_MASK;
+}
+
+static inline void
+mrb_break_tag_set(struct RBreak *brk, uint32_t tag)
+{
+ brk->flags &= ~(RBREAK_TAG_MASK << RBREAK_TAG_BIT_OFF);
+ brk->flags |= (tag & RBREAK_TAG_MASK) << RBREAK_TAG_BIT_OFF;
+}
+
/**
* Protect
*
diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index 86fbe329d109e384b225d1360e68e734cceb0696..7dab4a85c5e0c7f39d0c7dc2f9934d5a575bc282 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -201,7 +201,7 @@ MRB_API void mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2);
/* RHASH_TBL allocates st_table if not available. */
#define RHASH(obj) ((struct RHash*)(mrb_ptr(obj)))
#define RHASH_TBL(h) (RHASH(h)->ht)
-#define RHASH_IFNONE(h) mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone"))
+#define RHASH_IFNONE(h) mrb_iv_get(mrb, (h), MRB_SYM(ifnone))
#define RHASH_PROCDEFAULT(h) RHASH_IFNONE(h)
#define MRB_HASH_DEFAULT 1
diff --git a/include/mruby/irep.h b/include/mruby/irep.h
index 661ef2b486f8b6c581bb949cdb0ab92cb1e51b49..a9c20681cb5ed96fa7de2282d352a5a3e1f383f3 100644
--- a/include/mruby/irep.h
+++ b/include/mruby/irep.h
@@ -16,28 +16,58 @@
MRB_BEGIN_DECL
enum irep_pool_type {
- IREP_TT_STRING,
- IREP_TT_FIXNUM,
- IREP_TT_FLOAT,
+ IREP_TT_STR = 0, /* string (need free) */
+ IREP_TT_SSTR = 2, /* string (static) */
+ IREP_TT_INT32 = 1, /* 32bit integer */
+ IREP_TT_INT64 = 3, /* 64bit integer */
+ IREP_TT_FLOAT = 5, /* float (double/float) */
};
-struct mrb_locals {
- mrb_sym name;
- uint16_t r;
+#define IREP_TT_NFLAG 1 /* number (non string) flag */
+#define IREP_TT_SFLAG 2 /* static string flag */
+
+typedef struct mrb_pool_value {
+ uint32_t tt; /* packed type and length (for string) */
+ union {
+ const char *str;
+ int32_t i32;
+#ifdef MRB_64BIT
+ int64_t i64;
+#endif
+ mrb_float f;
+ } u;
+} mrb_pool_value;
+
+enum mrb_catch_type {
+ MRB_CATCH_RESCUE = 0,
+ MRB_CATCH_ENSURE = 1,
+};
+
+struct mrb_irep_catch_handler {
+ uint8_t type; /* enum mrb_catch_type */
+ uint8_t begin[2]; /* The starting address to match the hander. Includes this. */
+ uint8_t end[2]; /* The endpoint address that matches the hander. Not Includes this. */
+ uint8_t target[2]; /* The address to jump to if a match is made. */
};
/* Program data array struct */
typedef struct mrb_irep {
uint16_t nlocals; /* Number of local variables */
uint16_t nregs; /* Number of register variables */
+ uint16_t clen; /* Number of catch handlers */
uint8_t flags;
const mrb_code *iseq;
- mrb_value *pool;
- mrb_sym *syms;
- struct mrb_irep **reps;
-
- struct mrb_locals *lv;
+ /*
+ * A catch handler table is placed after the iseq entity.
+ * The reason it doesn't add fields to the structure is to keep the mrb_irep structure from bloating.
+ * The catch handler table can be obtained with `mrb_irep_catch_handler_table(irep)`.
+ */
+ const mrb_pool_value *pool;
+ const mrb_sym *syms;
+ const struct mrb_irep * const *reps;
+
+ const mrb_sym *lv;
/* debug info */
struct mrb_irep_debug_info* debug_info;
@@ -46,6 +76,8 @@ typedef struct mrb_irep {
} mrb_irep;
#define MRB_ISEQ_NO_FREE 1
+#define MRB_IREP_NO_FREE 2
+#define MRB_IREP_STATIC (MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE)
MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
@@ -92,6 +124,17 @@ struct mrb_insn_data {
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;
+ }
+}
+
MRB_END_DECL
#endif /* MRUBY_IREP_H */
diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h
index 06a33cc6f2a4537bad32b5519add42cb1bf516d2..7e70b9deedfc71fdeb20e402efe2035fd7f615ad 100644
--- a/include/mruby/numeric.h
+++ b/include/mruby/numeric.h
@@ -1,5 +1,5 @@
/**
-** @file mruby/numeric.h - Numeric, Integer, Float, Fixnum class
+** @file mruby/numeric.h - Numeric, Integer, Float class
**
** See Copyright Notice in mruby.h
*/
@@ -12,17 +12,17 @@
/**
* Numeric class and it's sub-classes.
*
- * Integer, Float and Fixnum
+ * Integer and Float
*/
MRB_BEGIN_DECL
-#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_INT_MAX)
-#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_INT_MIN)
+#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX)
+#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN)
#define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
#define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int)
#define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int)
#define FIXABLE(f) TYPED_FIXABLE(f,mrb_int)
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#ifdef MRB_INT64
#define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0)
#else
@@ -30,16 +30,15 @@ MRB_BEGIN_DECL
#endif
#endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
MRB_API mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val);
#endif
MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base);
/* ArgumentError if format string doesn't match /%(\.[0-9]+)?[aAeEfFgG]/ */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt);
MRB_API int mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float f);
MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x);
-MRB_API mrb_value mrb_int_value(mrb_state *mrb, mrb_float f);
#endif
MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y);
@@ -137,15 +136,15 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
if (multiplicand > 0) {
if (multiplier > MRB_INT_MAX / multiplicand) return TRUE;
}
- else {
+ else if (multiplicand < 0) {
if (multiplicand < MRB_INT_MAX / multiplier) return TRUE;
}
}
- else {
+ else if (multiplier < 0) {
if (multiplicand > 0) {
if (multiplier < MRB_INT_MAX / multiplicand) return TRUE;
}
- else {
+ else if (multiplicand < 0) {
if (multiplier != 0 && multiplicand < MRB_INT_MAX / multiplier) return TRUE;
}
}
@@ -161,13 +160,13 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
#endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
# include <stdint.h>
# include <float.h>
# define MRB_FLT_RADIX FLT_RADIX
-# ifdef MRB_USE_FLOAT
+# ifdef MRB_USE_FLOAT32
# define MRB_FLT_MANT_DIG FLT_MANT_DIG
# define MRB_FLT_EPSILON FLT_EPSILON
# define MRB_FLT_DIG FLT_DIG
@@ -178,7 +177,7 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
# define MRB_FLT_MAX FLT_MAX
# define MRB_FLT_MAX_10_EXP FLT_MAX_10_EXP
-# else /* not MRB_USE_FLOAT */
+# else /* not MRB_USE_FLOAT32 */
# define MRB_FLT_MANT_DIG DBL_MANT_DIG
# define MRB_FLT_EPSILON DBL_EPSILON
# define MRB_FLT_DIG DBL_DIG
@@ -188,8 +187,8 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
# define MRB_FLT_MAX_EXP DBL_MAX_EXP
# define MRB_FLT_MAX DBL_MAX
# define MRB_FLT_MAX_10_EXP DBL_MAX_10_EXP
-# endif /* MRB_USE_FLOAT */
-#endif /* MRB_WITHOUT_FLOAT */
+# endif /* MRB_USE_FLOAT32 */
+#endif /* MRB_NO_FLOAT */
MRB_END_DECL
diff --git a/include/mruby/opcode.h b/include/mruby/opcode.h
index 95e6736a438df29849a9d69debebd7b93386c690..a6c636cf88e9411bed526a2d5bb94515df7c306d 100644
--- a/include/mruby/opcode.h
+++ b/include/mruby/opcode.h
@@ -39,31 +39,4 @@ enum mrb_insn {
#define FETCH_S() do {a=READ_S();} while (0)
#define FETCH_W() do {a=READ_W();} while (0)
-/* with OP_EXT1 (1st 16bit) */
-#define FETCH_Z_1() FETCH_Z()
-#define FETCH_B_1() FETCH_S()
-#define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0)
-#define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0)
-#define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_1() FETCH_S()
-#define FETCH_W_1() FETCH_W()
-
-/* with OP_EXT2 (2nd 16bit) */
-#define FETCH_Z_2() FETCH_Z()
-#define FETCH_B_2() FETCH_B()
-#define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0)
-#define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_2() FETCH_BS()
-#define FETCH_S_2() FETCH_S()
-#define FETCH_W_2() FETCH_W()
-
-/* with OP_EXT3 (1st & 2nd 16bit) */
-#define FETCH_Z_3() FETCH_Z()
-#define FETCH_B_3() FETCH_B()
-#define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_3() FETCH_S()
-#define FETCH_W_3() FETCH_W()
-
#endif /* MRUBY_OPCODE_H */
diff --git a/include/mruby/ops.h b/include/mruby/ops.h
index e85ee3133a06845eb1b0471c6414484981a3c9fc..75936a791cd7e1ea942950ee2c4d21022b17f600 100644
--- a/include/mruby/ops.h
+++ b/include/mruby/ops.h
@@ -25,6 +25,7 @@ OPCODE(LOADI_4, B) /* R(a) = mrb_int(4) */
OPCODE(LOADI_5, B) /* R(a) = mrb_int(5) */
OPCODE(LOADI_6, B) /* R(a) = mrb_int(6) */
OPCODE(LOADI_7, B) /* R(a) = mrb_int(7) */
+OPCODE(LOADI16, BS) /* R(a) = mrb_int(b) */
OPCODE(LOADSYM, BB) /* R(a) = Syms(b) */
OPCODE(LOADNIL, B) /* R(a) = nil */
OPCODE(LOADSELF, B) /* R(a) = self */
@@ -48,13 +49,10 @@ OPCODE(JMP, S) /* pc=a */
OPCODE(JMPIF, BS) /* if R(a) pc=b */
OPCODE(JMPNOT, BS) /* if !R(a) pc=b */
OPCODE(JMPNIL, BS) /* if R(a)==nil pc=b */
-OPCODE(ONERR, S) /* rescue_push(a) */
+OPCODE(JMPUW, S) /* unwind_and_jump_to(a) */
OPCODE(EXCEPT, B) /* R(a) = exc */
OPCODE(RESCUE, BB) /* R(b) = R(a).isa?(R(b)) */
-OPCODE(POPERR, B) /* a.times{rescue_pop()} */
-OPCODE(RAISE, B) /* raise(R(a)) */
-OPCODE(EPUSH, B) /* ensure_push(SEQ[a]) */
-OPCODE(EPOP, B) /* A.times{ensure_pop().call} */
+OPCODE(RAISEIF, B) /* raise(R(a)) if R(a) */
OPCODE(SENDV, BB) /* R(a) = call(R(a),Syms(b),*R(a+1)) */
OPCODE(SENDVB, BB) /* R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) */
OPCODE(SEND, BBB) /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) */
@@ -111,8 +109,4 @@ OPCODE(SCLASS, B) /* R(a) = R(a).singleton_class */
OPCODE(TCLASS, B) /* R(a) = target_class */
OPCODE(DEBUG, BBB) /* print a,b,c */
OPCODE(ERR, B) /* raise(LocalJumpError, Lit(a)) */
-OPCODE(EXT1, Z) /* make 1st operand 16bit */
-OPCODE(EXT2, Z) /* make 2nd operand 16bit */
-OPCODE(EXT3, Z) /* make 1st and 2nd operands 16bit */
OPCODE(STOP, Z) /* stop VM */
-OPCODE(LOADI16, BS) /* R(a) = mrb_int(b) */
diff --git a/include/mruby/presym.h b/include/mruby/presym.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cc12e8fbef2e3dd638393b357dbc09b3d600574
--- /dev/null
+++ b/include/mruby/presym.h
@@ -0,0 +1,25 @@
+/**
+** @file mruby/presym.h - Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_H
+#define MRUBY_PRESYM_H
+
+#undef MRB_PRESYM_MAX
+#define MRB_PRESYM_CSYM(sym, num) MRB_PRESYM__##sym = (num<<1),
+#define MRB_PRESYM_QSYM(str, sym, num) MRB_PRESYM_q_##sym = (num<<1),
+#define MRB_PRESYM_SYM(sym, num)
+
+enum mruby_presym {
+#include <../build/presym.inc>
+};
+
+#undef MRB_PRESYM_CSYM
+#undef MRB_PRESYM_QSYM
+#undef MRB_PRESYM_SYM
+
+#define MRB_SYM(sym) MRB_PRESYM__##sym
+#define MRB_QSYM(sym) MRB_PRESYM_q_##sym
+#endif /* MRUBY_PRESYM_H */
diff --git a/include/mruby/proc.h b/include/mruby/proc.h
index 12013c3ae09341a73d42e5205a041c6f1bfa5371..981e1111dd8db9bd4cd2324ac18d9cc711095553 100644
--- a/include/mruby/proc.h
+++ b/include/mruby/proc.h
@@ -41,10 +41,10 @@ void mrb_env_unshare(mrb_state*, struct REnv*);
struct RProc {
MRB_OBJECT_HEADER;
union {
- mrb_irep *irep;
+ const mrb_irep *irep;
mrb_func_t func;
} body;
- struct RProc *upper;
+ const struct RProc *upper;
union {
struct RClass *target_class;
struct REnv *env;
@@ -57,7 +57,7 @@ struct RProc {
#define MRB_ASPEC_REST(a) (((a) >> 12) & 0x1)
#define MRB_ASPEC_POST(a) (((a) >> 7) & 0x1f)
#define MRB_ASPEC_KEY(a) (((a) >> 2) & 0x1f)
-#define MRB_ASPEC_KDICT(a) ((a) & (1<<1))
+#define MRB_ASPEC_KDICT(a) (((a) >> 1) & 0x1)
#define MRB_ASPEC_BLOCK(a) ((a) & 1)
#define MRB_PROC_CFUNC_FL 128
@@ -86,16 +86,13 @@ struct RProc {
#define mrb_proc_ptr(v) ((struct RProc*)(mrb_ptr(v)))
-struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
-struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
+struct RProc *mrb_proc_new(mrb_state*, const mrb_irep*);
+struct RProc *mrb_closure_new(mrb_state*, const mrb_irep*);
MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals);
void mrb_proc_copy(struct RProc *a, struct RProc *b);
mrb_int mrb_proc_arity(const struct RProc *p);
-/* implementation of #send method */
-mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
-
/* following functions are defined in mruby-proc-ext so please include it when using */
MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const mrb_value *argv);
MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
@@ -104,7 +101,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
#define MRB_METHOD_FUNC_FL 1
#define MRB_METHOD_NOARG_FL 2
-#ifndef MRB_METHOD_T_STRUCT
+
+#ifndef MRB_USE_METHOD_T_STRUCT
#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
#define MRB_METHOD_NOARG_P(m) (((uintptr_t)(m))&MRB_METHOD_NOARG_FL)
@@ -128,7 +126,7 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
#define MRB_METHOD_PROC(m) ((m).proc)
#define MRB_METHOD_UNDEF_P(m) ((m).proc==NULL)
-#endif /* MRB_METHOD_T_STRUCT */
+#endif /* MRB_USE_METHOD_T_STRUCT */
#define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
#define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
@@ -137,6 +135,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
#include <mruby/khash.h>
KHASH_DECLARE(mt, mrb_sym, mrb_method_t, TRUE)
+MRB_API mrb_value mrb_load_proc(mrb_state *mrb, const struct RProc *proc);
+
MRB_END_DECL
#endif /* MRUBY_PROC_H */
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 93c94ef5d0312ee806abf55e6deb4fefee4d5026..8384128c7e3af9db2f193a7f0b5d0b61b7a920b6 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -35,7 +35,7 @@ struct RString {
};
struct RStringEmbed {
MRB_OBJECT_HEADER;
- char ary[];
+ char ary[RSTRING_EMBED_LEN_MAX+1];
};
#define RSTR_SET_TYPE_FLAG(s, type) (RSTR_UNSET_TYPE_FLAG(s), (s)->flags |= MRB_STR_##type)
@@ -92,9 +92,6 @@ struct RStringEmbed {
# define RSTR_COPY_ASCII_FLAG(dst, src) (void)0
#endif
-#define RSTR_POOL_P(s) ((s)->flags & MRB_STR_POOL)
-#define RSTR_SET_POOL_FLAG(s) ((s)->flags |= MRB_STR_POOL)
-
/**
* Returns a pointer from a Ruby string
*/
@@ -112,13 +109,11 @@ MRB_API mrb_int mrb_str_strlen(mrb_state*, struct RString*);
#define MRB_STR_FSHARED 2
#define MRB_STR_NOFREE 4
#define MRB_STR_EMBED 8 /* type flags up to here */
-#define MRB_STR_POOL 16 /* status flags from here */
-#define MRB_STR_ASCII 32
+#define MRB_STR_ASCII 16
#define MRB_STR_EMBED_LEN_SHIFT 6
#define MRB_STR_EMBED_LEN_BIT 5
#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
-#define MRB_STR_TYPE_MASK (MRB_STR_POOL - 1)
-
+#define MRB_STR_TYPE_MASK 15
void mrb_gc_free_str(mrb_state*, struct RString*);
@@ -382,8 +377,9 @@ MRB_API double mrb_cstr_to_dbl(mrb_state *mrb, const char *s, mrb_bool badcheck)
/**
* Returns a converted string type.
* For type checking, non converting `mrb_to_str` is recommended.
+ * obsolete: use `mrb_obj_as_string()` instead.
*/
-MRB_API mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
+#define mrb_str_to_str(mrb, str) mrb_obj_as_string(mrb, str)
/**
* Returns true if the strings match and false if the strings don't match.
@@ -447,7 +443,6 @@ MRB_API int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
*/
MRB_API char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str);
-mrb_value mrb_str_pool(mrb_state *mrb, const char *s, mrb_int len, mrb_bool nofree);
uint32_t mrb_str_hash(mrb_state *mrb, mrb_value str);
mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
diff --git a/include/mruby/throw.h b/include/mruby/throw.h
index 1f1298d7d9bdafd573bf50e1ca1de8756a2bafeb..b5ea7312e0a355cc144513e8d961db015f665b55 100644
--- a/include/mruby/throw.h
+++ b/include/mruby/throw.h
@@ -13,7 +13,9 @@
# endif
#endif
-#if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
+#if defined(MRB_ENABLE_CXX_EXCEPTION)
+
+# if defined(__cplusplus)
#define MRB_TRY(buf) try {
#define MRB_CATCH(buf) } catch(mrb_jmpbuf_impl e) { if (e != (buf)->impl) { throw e; }
@@ -22,6 +24,10 @@
#define MRB_THROW(buf) throw((buf)->impl)
typedef mrb_int mrb_jmpbuf_impl;
+# else
+# error "need to be compiled with C++ compiler"
+# endif /* __cplusplus */
+
#else
#include <setjmp.h>
@@ -46,9 +52,11 @@ typedef mrb_int mrb_jmpbuf_impl;
struct mrb_jmpbuf {
mrb_jmpbuf_impl impl;
-#if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
+#if defined(MRB_ENABLE_CXX_EXCEPTION)
static mrb_int jmpbuf_id;
+# if defined(__cplusplus)
mrb_jmpbuf() : impl(jmpbuf_id++) {}
+# endif
#endif
};
diff --git a/include/mruby/value.h b/include/mruby/value.h
index 473774b00a020d7131f935fde2db0225cbb54faf..698c83300c8abd73bb15556509613f4fd685844f 100644
--- a/include/mruby/value.h
+++ b/include/mruby/value.h
@@ -54,16 +54,20 @@ struct mrb_state;
#if defined(MRB_INT64)
typedef int64_t mrb_int;
# define MRB_INT_BIT 64
-# define MRB_INT_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
-# define MRB_INT_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
+# define MRB_INT_MIN INT64_MIN
+# define MRB_INT_MAX INT64_MAX
+# define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
# define MRB_PRIo PRIo64
# define MRB_PRId PRId64
# define MRB_PRIx PRIx64
#else
typedef int32_t mrb_int;
# define MRB_INT_BIT 32
-# define MRB_INT_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
-# define MRB_INT_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
+# define MRB_INT_MIN INT32_MIN
+# define MRB_INT_MAX INT32_MAX
+# define MRB_FIXNUM_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
# define MRB_PRIo PRIo32
# define MRB_PRId PRId32
# define MRB_PRIx PRIx32
@@ -75,9 +79,9 @@ struct mrb_state;
# define MRB_ENDIAN_LOHI(a,b) b a
#endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
MRB_API double mrb_float_read(const char*, char**);
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
typedef float mrb_float;
#else
typedef double mrb_float;
@@ -90,7 +94,7 @@ MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list ar
MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...);
# define vsnprintf(s, n, format, arg) mrb_msvc_vsnprintf(s, n, format, arg)
# define snprintf(s, n, format, ...) mrb_msvc_snprintf(s, n, format, __VA_ARGS__)
-# if _MSC_VER < 1800 && !defined MRB_WITHOUT_FLOAT
+# if _MSC_VER < 1800 && !defined MRB_NO_FLOAT
# include <float.h>
# define isfinite(n) _finite(n)
# define isnan _isnan
@@ -106,7 +110,7 @@ enum mrb_vtype {
MRB_TT_FALSE = 0,
MRB_TT_TRUE,
MRB_TT_FLOAT,
- MRB_TT_FIXNUM,
+ MRB_TT_INTEGER,
MRB_TT_SYMBOL,
MRB_TT_UNDEF,
MRB_TT_CPTR,
@@ -130,6 +134,9 @@ enum mrb_vtype {
MRB_TT_MAXDEFINE
};
+/* for compatibility */
+#define MRB_TT_FIXNUM MRB_TT_INTEGER
+
#include <mruby/object.h>
#ifdef MRB_DOCUMENTATION_BLOCK
@@ -177,8 +184,11 @@ struct RCptr {
#ifndef mrb_immediate_p
#define mrb_immediate_p(o) (mrb_type(o) < MRB_TT_FREE)
#endif
+#ifndef mrb_integer_p
+#define mrb_integer_p(o) (mrb_type(o) == MRB_TT_INTEGER)
+#endif
#ifndef mrb_fixnum_p
-#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM)
+#define mrb_fixnum_p(o) mrb_integer_p(o)
#endif
#ifndef mrb_symbol_p
#define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL)
@@ -195,7 +205,7 @@ struct RCptr {
#ifndef mrb_true_p
#define mrb_true_p(o) (mrb_type(o) == MRB_TT_TRUE)
#endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#ifndef mrb_float_p
#define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT)
#endif
@@ -264,7 +274,7 @@ struct RCptr {
*
* Takes a float and boxes it into an mrb_value
*/
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
MRB_INLINE mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f)
{
mrb_value v;
@@ -284,14 +294,19 @@ mrb_cptr_value(struct mrb_state *mrb, void *p)
}
/**
- * Returns a fixnum in Ruby.
- *
- * Takes an integer and boxes it into an mrb_value
+ * Returns an integer in Ruby.
*/
+MRB_INLINE mrb_value mrb_int_value(struct mrb_state *mrb, mrb_int i)
+{
+ mrb_value v;
+ SET_INT_VALUE(mrb, v, i);
+ return v;
+}
+
MRB_INLINE mrb_value mrb_fixnum_value(mrb_int i)
{
mrb_value v;
- SET_INT_VALUE(v, i);
+ SET_FIXNUM_VALUE(v, i);
return v;
}
diff --git a/lib/mruby/build.rb b/lib/mruby/build.rb
index 9ba136cf329cc3598ff56959449f970bb9ef94d5..fa3853342ab2bf6203857ace20cbbedee9bbf5a3 100644
--- a/lib/mruby/build.rb
+++ b/lib/mruby/build.rb
@@ -81,7 +81,8 @@ module MRuby
@mrbc = Command::Mrbc.new(self)
@bins = []
- @gems, @libmruby_objs = MRuby::Gem::List.new, []
+ @gems = MRuby::Gem::List.new
+ @libmruby_objs = []
@build_mrbtest_lib_only = false
@cxx_exception_enabled = false
@cxx_exception_disabled = false
@@ -95,11 +96,10 @@ module MRuby
MRuby.targets[@name] = self
end
- MRuby::Build.current = MRuby.targets[@name]
- MRuby.targets[@name].instance_eval(&block)
-
- build_mrbc_exec if name == 'host'
- build_mrbtest if test_enabled?
+ current = MRuby.targets[@name]
+ MRuby::Build.current = current
+ current.instance_eval(&block)
+ current.build_mrbtest if current.test_enabled?
end
def debug_enabled?
@@ -196,6 +196,7 @@ EOS
end
def enable_bintest
+ raise "bintest works only on 'host' target" unless name == "host"
@enable_bintest = true
end
@@ -246,9 +247,11 @@ EOS
def mrbcfile
return @mrbcfile if @mrbcfile
- mrbc_build = MRuby.targets['host']
- gems.each { |v| mrbc_build = self if v.name == 'mruby-bin-mrbc' }
- @mrbcfile = mrbc_build.exefile("#{mrbc_build.build_dir}/bin/mrbc")
+ unless gems.detect {|v| v.name == 'mruby-bin-mrbc' }
+ build_mrbc_exec
+ gems.detect {|v| v.name == 'mruby-bin-mrbc' }.setup
+ end
+ @mrbcfile = self.exefile("#{self.build_dir}/bin/mrbc")
end
def compilers
@@ -369,13 +372,25 @@ EOS
attr_accessor :host_target, :build_target
def initialize(name, build_dir=nil, &block)
+ unless MRuby.targets['host']
+ # add minimal 'host'
+ MRuby::Build.new('host') do |conf|
+ if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+ toolchain :visualcpp
+ else
+ toolchain :gcc
+ end
+ conf.gem :core => 'mruby-bin-mrbc'
+ end
+ end
@endian = nil
@test_runner = Command::CrossTestRunner.new(self)
super
end
def mrbcfile
- MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/mrbc")
+ host = MRuby.targets['host']
+ host.exefile("#{host.build_dir}/bin/mrbc")
end
def run_test
diff --git a/lib/mruby/build/command.rb b/lib/mruby/build/command.rb
index 84ce78cb9171401c235c79efd6e71d9ff40e6cd7..3d47c304f627e5e1521c4d001b3ac57904187753 100644
--- a/lib/mruby/build/command.rb
+++ b/lib/mruby/build/command.rb
@@ -313,13 +313,13 @@ module MRuby
@compile_options = "-B%{funcname} -o-"
end
- def run(out, infiles, funcname)
+ def run(out, infiles, funcname, cdump = true)
@command ||= @build.mrbcfile
infiles = [infiles].flatten
infiles.each do |f|
_pp "MRBC", f.relative_path, nil, :indent => 2
end
- cmd = %Q["#{filename @command}" #{@compile_options % {:funcname => funcname}} #{filename(infiles).map{|f| %Q["#{f}"]}.join(' ')}]
+ cmd = %Q["#{filename @command}" #{cdump ? "-S" : ""} #{@compile_options % {:funcname => funcname}} #{filename(infiles).map{|f| %Q["#{f}"]}.join(' ')}]
puts cmd if Rake.verbose
IO.popen(cmd, 'r+') do |io|
out.puts io.read
diff --git a/lib/mruby/build/load_gems.rb b/lib/mruby/build/load_gems.rb
index 522b8a17ef437291444b272075cc41c41b5d3f20..4f5bde7afcd4ac99035071f8373fe5950327044c 100644
--- a/lib/mruby/build/load_gems.rb
+++ b/lib/mruby/build/load_gems.rb
@@ -28,18 +28,19 @@ module MRuby
Gem.current = nil
load gemrake
return nil unless Gem.current
+ current = Gem.current
- Gem.current.dir = gemdir
- Gem.current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current
- Gem.current.build_config_initializer = block
- gems << Gem.current
+ current.dir = gemdir
+ current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current
+ current.build_config_initializer = block
+ gems << current
cxx_srcs = ['src', 'test', 'tools'].map do |subdir|
- Dir.glob("#{Gem.current.dir}/#{subdir}/*.{cpp,cxx,cc}")
+ Dir.glob("#{current.dir}/#{subdir}/*.{cpp,cxx,cc}")
end.flatten
enable_cxx_exception unless cxx_srcs.empty?
- Gem.current
+ current
end
def load_special_path_gem(params)
diff --git a/lib/mruby/gem.rb b/lib/mruby/gem.rb
index 6fcaad9c1f9d3f415c6c841d78608062236f9746..d4b43b094ea4e81474e0ff2535aa93990325b248 100644
--- a/lib/mruby/gem.rb
+++ b/lib/mruby/gem.rb
@@ -47,12 +47,14 @@ module MRuby
@version = "0.0.0"
@mrblib_dir = "mrblib"
@objs_dir = "src"
+ @dependencies = []
+ @conflicts = []
MRuby::Gem.current = self
end
def setup
return if defined?(@linker) # return if already set up
-
+
MRuby::Gem.current = self
MRuby::Build::COMMANDS.each do |command|
instance_variable_set("@#{command}", @build.send(command).clone)
@@ -75,7 +77,6 @@ module MRuby
@bins = []
@requirements = []
- @dependencies, @conflicts = [], []
@export_include_paths = []
@export_include_paths << "#{dir}/include" if File.directory? "#{dir}/include"
@@ -174,7 +175,7 @@ module MRuby
def generate_gem_init(fname)
open(fname, 'w') do |f|
print_gem_init_header f
- build.mrbc.run f, rbfiles, "gem_mrblib_irep_#{funcname}" unless rbfiles.empty?
+ build.mrbc.run f, rbfiles, "gem_mrblib_#{funcname}_proc" unless rbfiles.empty?
f.puts %Q[void mrb_#{funcname}_gem_init(mrb_state *mrb);]
f.puts %Q[void mrb_#{funcname}_gem_final(mrb_state *mrb);]
f.puts %Q[]
@@ -183,7 +184,7 @@ module MRuby
f.puts %Q[ struct REnv *e;] unless rbfiles.empty?
f.puts %Q[ mrb_#{funcname}_gem_init(mrb);] if objs != [objfile("#{build_dir}/gem_init")]
unless rbfiles.empty?
- f.puts %Q[ mrb_load_irep(mrb, gem_mrblib_irep_#{funcname});]
+ f.puts %Q[ mrb_load_proc(mrb, gem_mrblib_#{funcname}_proc);]
f.puts %Q[ if (mrb->exc) {]
f.puts %Q[ mrb_print_error(mrb);]
f.puts %Q[ mrb_close(mrb);]
@@ -215,10 +216,13 @@ module MRuby
def print_gem_init_header(f)
print_gem_comment(f)
- f.puts %Q[#include <stdlib.h>] unless rbfiles.empty?
- f.puts %Q[#include <mruby.h>]
- f.puts %Q[#include <mruby/irep.h>] unless rbfiles.empty?
- f.puts %Q[#include <mruby/proc.h>] unless rbfiles.empty?
+ unless rbfiles.empty?
+ f.puts %Q[#include <stdlib.h>]
+ f.puts %Q[#include <mruby.h>]
+ f.puts %Q[#include <mruby/proc.h>]
+ else
+ f.puts %Q[#include <mruby.h>]
+ end
end
def print_gem_test_header(f)
@@ -226,7 +230,7 @@ module MRuby
f.puts %Q[#include <stdio.h>]
f.puts %Q[#include <stdlib.h>]
f.puts %Q[#include <mruby.h>]
- f.puts %Q[#include <mruby/irep.h>]
+ f.puts %Q[#include <mruby/proc.h>]
f.puts %Q[#include <mruby/variable.h>]
f.puts %Q[#include <mruby/hash.h>] unless test_args.empty?
end
diff --git a/lib/mruby/lockfile.rb b/lib/mruby/lockfile.rb
index 0d2455b4c420af902681fd2a80163c078f992200..5d4313649ad290ce1d39f6cd6566e9214223396f 100644
--- a/lib/mruby/lockfile.rb
+++ b/lib/mruby/lockfile.rb
@@ -26,7 +26,7 @@ module MRuby
end
def instance
- @instance ||= new("#{MRUBY_CONFIG}.lock")
+ @instance ||= new("#{MRUBY_ROOT}/build/#{MRUBY_TARGET}.lock")
end
end
@@ -39,7 +39,7 @@ module MRuby
end
def write
- locks = {"mruby_version" => mruby}
+ locks = {"mruby" => mruby}
locks["builds"] = @builds if @builds
File.write(@filename, YAML.dump(locks))
end
diff --git a/mrbgems/default.gembox b/mrbgems/default.gembox
index de1e9a573f49ef3ef9aafd9e8c3f612f6db8c084..de169906b3a5709b4237740445a7d4c0d005565f 100644
--- a/mrbgems/default.gembox
+++ b/mrbgems/default.gembox
@@ -5,6 +5,9 @@ MRuby::GemBox.new do |conf|
# Use standard IO/File class
conf.gem :core => "mruby-io"
+ # Use standard IO/File class
+ conf.gem :core => "mruby-socket"
+
# Use standard Array#pack, String#unpack methods
conf.gem :core => "mruby-pack"
@@ -84,6 +87,9 @@ MRuby::GemBox.new do |conf|
# Generate mruby-strip command
conf.gem :core => "mruby-bin-strip"
+ # Generate mruby-config command
+ conf.gem :core => "mruby-bin-config"
+
# Use Kernel module extension
conf.gem :core => "mruby-kernel-ext"
diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c
index 3ce5d822e3a9a3e10f996873d1ec77a462d4be0c..9d7f1b28a5081b8a89cbec5b394b35cd7c253e78 100644
--- a/mrbgems/mruby-array-ext/src/array.c
+++ b/mrbgems/mruby-array-ext/src/array.c
@@ -148,11 +148,11 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self)
else {
return mrb_nil_value();
}
- case MRB_TT_FIXNUM:
- val = mrb_funcall(mrb, self, "delete_at", 1, index);
+ case MRB_TT_INTEGER:
+ val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index);
return val;
default:
- val = mrb_funcall(mrb, self, "delete_at", 1, index);
+ val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index);
return val;
}
}
diff --git a/mrbgems/mruby-bin-debugger/bintest/print.rb b/mrbgems/mruby-bin-debugger/bintest/print.rb
index a8401963f28a8a1eb60977cdbfbe05fd5180508a..653be0ce682b14e4839fdea59c21243b48be831a 100644
--- a/mrbgems/mruby-bin-debugger/bintest/print.rb
+++ b/mrbgems/mruby-bin-debugger/bintest/print.rb
@@ -516,7 +516,7 @@ SRC
tc << {:cmd=>'p a+1', :exp=>'$1 = 2'}
tc << {:cmd=>'p 2-b', :exp=>'$2 = -3'}
tc << {:cmd=>'p c * 3', :exp=>'$3 = 24'}
- tc << {:cmd=>'p a/b', :exp=>'$4 = 0.2'}
+ tc << {:cmd=>'p a/b', :exp=>'$4 = 0'}
tc << {:cmd=>'p c%b', :exp=>'$5 = 3'}
tc << {:cmd=>'p 2**10', :exp=>'$6 = 1024'}
tc << {:cmd=>'p ~3', :exp=>'$7 = -4'}
@@ -614,13 +614,13 @@ SRC
tc << {:cmd=>'p a+=9', :exp=>'$1 = 10'}
tc << {:cmd=>'p b-=c', :exp=>'$2 = 15'}
tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'}
- tc << {:cmd=>'p a/=4', :exp=>'$4 = 2.5'}
+ tc << {:cmd=>'p a/=4', :exp=>'$4 = 2'}
tc << {:cmd=>'p c%=4', :exp=>'$5 = 2'}
tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'}
tc << {:cmd=>'p c|=0x10', :exp=>'$7 = 18'}
- tc << {:cmd=>'p "#{a} #{b} #{c}"', :exp=>'$8 = "2.5 5 18"'}
+ tc << {:cmd=>'p "#{a} #{b} #{c}"', :exp=>'$8 = "2 5 18"'}
tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'}
tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'}
@@ -682,13 +682,13 @@ SRC
tc << {:cmd=>'p a+=9', :exp=>'$1 = 10'}
tc << {:cmd=>'p b-=c', :exp=>'$2 = 15'}
tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'}
- tc << {:cmd=>'p a/=4', :exp=>'$4 = 2.5'}
+ tc << {:cmd=>'p a/=4', :exp=>'$4 = 2'}
tc << {:cmd=>'p c%=4', :exp=>'$5 = 2'}
tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'}
tc << {:cmd=>'p c|=0x10', :exp=>'$7 = 18'}
- tc << {:cmd=>'p "#{a} #{b} #{c}"', :exp=>'$8 = "2.5 5 18"'}
+ tc << {:cmd=>'p "#{a} #{b} #{c}"', :exp=>'$8 = "2 5 18"'}
tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'}
tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'}
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
index ceeb2739374afe337f7f776f1e7d75185c4c9a80..1507926f2f553970356968eaaff246a19f6af44f 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
@@ -84,7 +84,7 @@ free_breakpoint(mrb_state *mrb, mrb_debug_breakpoint *bp)
}
static uint16_t
-check_file_lineno(mrb_state *mrb, struct mrb_irep *irep, const char *file, uint16_t lineno)
+check_file_lineno(mrb_state *mrb, const struct mrb_irep *irep, const char *file, uint16_t lineno)
{
mrb_irep_debug_info_file *info_file;
uint16_t result = 0;
@@ -151,7 +151,7 @@ compare_break_method(mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *cl
}
sc = mrb_class_get(mrb, method_p->class_name);
- ssym = mrb_symbol(mrb_check_intern_cstr(mrb, method_p->method_name));
+ ssym = mrb_intern_check_cstr(mrb, method_p->method_name);
m = mrb_method_search_vm(mrb, &sc, ssym);
if (MRB_METHOD_UNDEF_P(m)) {
return MRB_DEBUG_OK;
@@ -428,7 +428,7 @@ mrb_debug_disable_break_all(mrb_state *mrb, mrb_debug_context *dbg)
}
static mrb_bool
-check_start_pc_for_line(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, uint16_t line)
+check_start_pc_for_line(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, uint16_t line)
{
if (pc > irep->iseq) {
if (line == mrb_debug_get_line(mrb, irep, pc - irep->iseq - 1)) {
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
index e8702f4df1363563ba23055d52b17d6cc84274eb..e18dbcbfc4cb8d73fade1700c657e530bb581a19 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
@@ -33,7 +33,7 @@ mrdb_check_syntax(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size
mrb_value
mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t len, mrb_bool *exc, int direct_eval)
{
- void (*tmp)(struct mrb_state *, struct mrb_irep *, const mrb_code *, mrb_value *);
+ void (*tmp)(struct mrb_state *, const struct mrb_irep *, const mrb_code *, mrb_value *);
mrb_value ruby_code;
mrb_value s;
mrb_value v;
@@ -67,7 +67,7 @@ mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t
recv = dbg->regs[0];
- v = mrb_funcall(mrb, recv, "instance_eval", 1, ruby_code);
+ v = mrb_funcall_id(mrb, recv, MRB_SYM(instance_eval), 1, ruby_code);
}
if (exc) {
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
index 8fab3c2e88903b3c7ce1850cbdc724515ed70e27..f55e443fe0c9c092056a2087244dd132f3a38a03 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
@@ -504,7 +504,7 @@ get_and_parse_command(mrb_state *mrb, mrdb_state *mrdb)
}
static int32_t
-check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
+check_method_breakpoint(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
{
struct RClass* c;
mrb_sym sym;
@@ -545,7 +545,7 @@ check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_
}
static void
-mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
+mrb_code_fetch_hook(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
{
const char *file;
int32_t line;
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h
index 7c21de3173fb2af1cec0c638703e6b452954f043..0c65057372e22a628047293a5ace65d236f98534 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h
@@ -103,8 +103,8 @@ typedef struct mrb_debug_breakpoint {
} mrb_debug_breakpoint;
typedef struct mrb_debug_context {
- struct mrb_irep *root_irep;
- struct mrb_irep *irep;
+ const struct mrb_irep *root_irep;
+ const struct mrb_irep *irep;
const mrb_code *pc;
mrb_value *regs;
diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
index 51ba3fd78a5086fea438fe86c0c6eb92414b05c4..8fa4fa822ec07fa555bd09c7c7ec2f29a328074b 100644
--- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
+++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
@@ -104,13 +104,13 @@ p(mrb_state *mrb, mrb_value obj, int prompt)
mrb_value val;
char* msg;
- val = mrb_funcall(mrb, obj, "inspect", 0);
+ val = mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0);
if (prompt) {
if (!mrb->exc) {
fputs(" => ", stdout);
}
else {
- val = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0);
+ val = mrb_funcall_id(mrb, mrb_obj_value(mrb->exc), MRB_SYM(inspect), 0);
}
}
if (!mrb_string_p(val)) {
@@ -525,10 +525,7 @@ main(int argc, char **argv)
while (TRUE) {
char *utf8;
- struct mrb_jmpbuf c_jmp;
- MRB_TRY(&c_jmp);
- mrb->jmp = &c_jmp;
if (args.rfp) {
if (fgets(last_code_line, sizeof(last_code_line)-1, args.rfp) != NULL)
goto done;
@@ -672,7 +669,7 @@ main(int argc, char **argv)
}
else {
/* no */
- if (!mrb_respond_to(mrb, result, mrb_intern_lit(mrb, "inspect"))){
+ if (!mrb_respond_to(mrb, result, MRB_SYM(inspect))){
result = mrb_any_to_s(mrb, result);
}
p(mrb, result, 1);
@@ -687,11 +684,6 @@ main(int argc, char **argv)
}
mrb_parser_free(parser);
cxt->lineno++;
- MRB_CATCH(&c_jmp) {
- p(mrb, mrb_obj_value(mrb->exc), 0);
- mrb->exc = 0;
- }
- MRB_END_EXC(&c_jmp);
}
#ifdef ENABLE_READLINE
diff --git a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c
index 4d984e7732efe72b3d2808138ada18bf95dd2624..acad28bd8ea80d1b7831f3e760fcde7fb1042165 100644
--- a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c
+++ b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c
@@ -20,6 +20,7 @@ struct mrbc_args {
const char *prog;
const char *outfile;
const char *initname;
+ mrb_bool dump_struct : 1;
mrb_bool check_syntax : 1;
mrb_bool verbose : 1;
mrb_bool remove_lv : 1;
@@ -32,10 +33,11 @@ usage(const char *name)
static const char *const usage_msg[] = {
"switches:",
"-c check syntax only",
- "-o<outfile> place the output into <outfile>",
+ "-o<outfile> place the output into <outfile>; required for multi-files",
"-v print version number, then turn on verbose mode",
"-g produce debugging information",
"-B<symbol> binary <symbol> output in C language format",
+ "-S dump C struct (requires -B)",
"--remove-lv remove local variables",
"--verbose run at verbose mode",
"--version print the version",
@@ -44,7 +46,7 @@ usage(const char *name)
};
const char *const *p = usage_msg;
- printf("Usage: %s [switches] programfile\n", name);
+ printf("Usage: %s [switches] programfile...\n", name);
while (*p)
printf(" %s\n", *p++);
}
@@ -105,6 +107,9 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
args->outfile = get_outfilename(mrb, argv[i] + 2, "");
}
break;
+ case 'S':
+ args->dump_struct = TRUE;
+ break;
case 'B':
if (argv[i][2] == '\0' && argv[i+1]) {
i++;
@@ -238,13 +243,18 @@ static int
dump_file(mrb_state *mrb, FILE *wfp, const char *outfile, struct RProc *proc, struct mrbc_args *args)
{
int n = MRB_DUMP_OK;
- mrb_irep *irep = proc->body.irep;
+ const mrb_irep *irep = proc->body.irep;
if (args->remove_lv) {
- mrb_irep_remove_lv(mrb, irep);
+ mrb_irep_remove_lv(mrb, (mrb_irep*)irep);
}
if (args->initname) {
- n = mrb_dump_irep_cfunc(mrb, irep, args->flags, wfp, args->initname);
+ if (args->dump_struct) {
+ n = mrb_dump_irep_cstruct(mrb, irep, args->flags, wfp, args->initname);
+ }
+ else {
+ n = mrb_dump_irep_cfunc(mrb, irep, args->flags, wfp, args->initname);
+ }
if (n == MRB_DUMP_INVALID_ARGUMENT) {
fprintf(stderr, "%s: invalid C language symbol name\n", args->initname);
}
diff --git a/mrbgems/mruby-catch/mrbgem.rake b/mrbgems/mruby-catch/mrbgem.rake
new file mode 100644
index 0000000000000000000000000000000000000000..c714d443d183dc39d8fe29c259a695f92101bb45
--- /dev/null
+++ b/mrbgems/mruby-catch/mrbgem.rake
@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-catch') do |spec|
+ spec.license = 'MIT'
+ spec.author = 'mruby developers'
+ spec.summary = 'Catch / Throw non-local Jump'
+end
diff --git a/mrbgems/mruby-catch/mrblib/catch.rb b/mrbgems/mruby-catch/mrblib/catch.rb
new file mode 100644
index 0000000000000000000000000000000000000000..89eedf66a0e7549cefd21983d9318ab82ab82904
--- /dev/null
+++ b/mrbgems/mruby-catch/mrblib/catch.rb
@@ -0,0 +1,27 @@
+class ThrowCatchJump < Exception
+ def initialize(tag, val)
+ @tag = tag
+ @val = val
+ super("uncaught throw :#{tag}")
+ end
+ def _tag
+ @tag
+ end
+ def _val
+ @val
+ end
+end
+
+module Kernel
+ def catch(tag, &block)
+ block.call(tag)
+ rescue ThrowCatchJump => e
+ unless e._tag == tag
+ raise e
+ end
+ return e._val
+ end
+ def throw(tag, val=nil)
+ raise ThrowCatchJump.new(tag, val)
+ end
+end
diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c
index c64ffc473a9164fe537c785bb81ea245c513ee61..eb37cd701e8033aa64fdc5eba46d0659f9134b76 100644
--- a/mrbgems/mruby-compiler/core/codegen.c
+++ b/mrbgems/mruby-compiler/core/codegen.c
@@ -5,13 +5,13 @@
*/
#include <ctype.h>
-#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <mruby.h>
#include <mruby/compile.h>
#include <mruby/proc.h>
+#include <mruby/dump.h>
#include <mruby/numeric.h>
#include <mruby/string.h>
#include <mruby/debug.h>
@@ -40,7 +40,6 @@ enum looptype {
struct loopinfo {
enum looptype type;
int pc0, pc1, pc2, pc3, acc;
- int ensure_level;
struct loopinfo *prev;
};
@@ -61,7 +60,6 @@ typedef struct scope {
mrb_bool mscope:1;
struct loopinfo *loop;
- int ensure_level;
mrb_sym filename_sym;
uint16_t lineno;
@@ -70,6 +68,10 @@ typedef struct scope {
uint32_t icapa;
mrb_irep *irep;
+ mrb_pool_value *pool;
+ mrb_sym *syms;
+ mrb_irep **reps;
+ struct mrb_irep_catch_handler *catch_table;
uint32_t pcapa, scapa, rcapa;
uint16_t nlocals;
@@ -89,6 +91,15 @@ static struct loopinfo *loop_push(codegen_scope *s, enum looptype t);
static void loop_break(codegen_scope *s, node *tree);
static void loop_pop(codegen_scope *s, int val);
+/*
+ * The search for catch handlers starts at the end of the table in mrb_vm_run().
+ * Therefore, the next handler to be added must meet one of the following conditions.
+ * - Larger start position
+ * - Same start position but smaller end position
+ */
+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);
@@ -98,10 +109,22 @@ static void raise_error(codegen_scope *s, const char *msg);
static void
codegen_error(codegen_scope *s, const char *message)
{
+ int i;
+
if (!s) return;
while (s->prev) {
codegen_scope *tmp = s->prev;
mrb_free(s->mrb, s->iseq);
+ mrb_free(s->mrb, s->pool);
+ mrb_free(s->mrb, s->syms);
+ if (s->reps) {
+ /* copied from mrb_irep_free() in state.c */
+ for (i=0; i<s->irep->rlen; i++) {
+ if (s->reps[i])
+ mrb_irep_decref(s->mrb, (mrb_irep*)s->reps[i]);
+ }
+ mrb_free(s->mrb, s->reps);
+ }
mrb_free(s->mrb, s->lines);
mrb_pool_close(s->mpool);
s = tmp;
@@ -203,9 +226,7 @@ genop_1(codegen_scope *s, mrb_code i, uint16_t a)
{
s->lastpc = s->pc;
if (a > 0xff) {
- gen_B(s, OP_EXT1);
- gen_B(s, i);
- gen_S(s, a);
+ codegen_error(s, "too big operand");
}
else {
gen_B(s, i);
@@ -217,23 +238,8 @@ static void
genop_2(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b)
{
s->lastpc = s->pc;
- if (a > 0xff && b > 0xff) {
- gen_B(s, OP_EXT3);
- gen_B(s, i);
- gen_S(s, a);
- gen_S(s, b);
- }
- else if (b > 0xff) {
- gen_B(s, OP_EXT2);
- gen_B(s, i);
- gen_B(s, (uint8_t)a);
- gen_S(s, b);
- }
- else if (a > 0xff) {
- gen_B(s, OP_EXT1);
- gen_B(s, i);
- gen_S(s, a);
- gen_B(s, (uint8_t)b);
+ if (a > 0xff || b > 0xff) {
+ codegen_error(s, "too big operand");
}
else {
gen_B(s, i);
@@ -295,32 +301,6 @@ mrb_decode_insn(const mrb_code *pc)
#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
#include "mruby/ops.h"
#undef OPCODE
- }
- switch (insn) {
- case OP_EXT1:
- insn = READ_B();
- switch (insn) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
-#include "mruby/ops.h"
-#undef OPCODE
- }
- break;
- case OP_EXT2:
- insn = READ_B();
- switch (insn) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
-#include "mruby/ops.h"
-#undef OPCODE
- }
- break;
- case OP_EXT3:
- insn = READ_B();
- switch (insn) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
-#include "mruby/ops.h"
-#undef OPCODE
- }
- break;
default:
break;
}
@@ -377,11 +357,8 @@ genjmp2(codegen_scope *s, mrb_code i, uint16_t a, int pc, int val)
s->lastpc = s->pc;
if (a > 0xff) {
- gen_B(s, OP_EXT1);
- gen_B(s, i);
- gen_S(s, a);
- pos = s->pc;
- gen_S(s, pc);
+ codegen_error(s, "too big operand");
+ pos = 0;
}
else {
gen_B(s, i);
@@ -539,37 +516,46 @@ static inline int
new_lit(codegen_scope *s, mrb_value val)
{
int i;
- mrb_value *pv;
+ mrb_pool_value *pv;
switch (mrb_type(val)) {
case MRB_TT_STRING:
for (i=0; i<s->irep->plen; i++) {
mrb_int len;
- pv = &s->irep->pool[i];
-
- if (!mrb_string_p(*pv)) continue;
- if ((len = RSTRING_LEN(*pv)) != RSTRING_LEN(val)) continue;
- if (memcmp(RSTRING_PTR(*pv), RSTRING_PTR(val), len) == 0)
+ 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_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
for (i=0; i<s->irep->plen; i++) {
mrb_float f1, f2;
- pv = &s->irep->pool[i];
- if (!mrb_float_p(*pv)) continue;
- f1 = mrb_float(*pv);
+ 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_FIXNUM:
+ case MRB_TT_INTEGER:
for (i=0; i<s->irep->plen; i++) {
- pv = &s->irep->pool[i];
- if (!mrb_fixnum_p(*pv)) continue;
- if (mrb_fixnum(*pv) == mrb_fixnum(val)) return 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:
@@ -579,26 +565,43 @@ new_lit(codegen_scope *s, mrb_value val)
if (s->irep->plen == s->pcapa) {
s->pcapa *= 2;
- s->irep->pool = (mrb_value *)codegen_realloc(s, s->irep->pool, sizeof(mrb_value)*s->pcapa);
+ s->pool = (mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*s->pcapa);
}
- pv = &s->irep->pool[s->irep->plen];
+ pv = &s->pool[s->irep->plen];
i = s->irep->plen++;
switch (mrb_type(val)) {
case MRB_TT_STRING:
- *pv = mrb_str_pool(s->mrb, RSTRING_PTR(val), RSTRING_LEN(val), RSTR_NOFREE_P(RSTRING(val)));
+ if (RSTR_NOFREE_P(RSTRING(val))) {
+ pv->tt = (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_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
-#ifdef MRB_WORD_BOXING
- *pv = mrb_float_pool(s->mrb, mrb_float(val));
+ pv->tt = IREP_TT_FLOAT;
+ pv->u.f = mrb_float(val);
break;
#endif
+ 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
- case MRB_TT_FIXNUM:
- *pv = val;
break;
default:
@@ -620,13 +623,13 @@ new_sym(codegen_scope *s, mrb_sym sym)
len = s->irep->slen;
for (i=0; i<len; i++) {
- if (s->irep->syms[i] == sym) return i;
+ if (s->syms[i] == sym) return i;
}
if (s->irep->slen >= s->scapa) {
s->scapa *= 2;
- s->irep->syms = (mrb_sym*)codegen_realloc(s, s->irep->syms, sizeof(mrb_sym)*s->scapa);
+ s->syms = (mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*s->scapa);
}
- s->irep->syms[s->irep->slen] = sym;
+ s->syms[s->irep->slen] = sym;
return s->irep->slen++;
}
@@ -665,7 +668,7 @@ lv_idx(codegen_scope *s, mrb_sym id)
static int
search_upvar(codegen_scope *s, mrb_sym id, int *idx)
{
- struct RProc *u;
+ const struct RProc *u;
int lv = 0;
codegen_scope *up = s->prev;
@@ -681,12 +684,14 @@ search_upvar(codegen_scope *s, mrb_sym id, int *idx)
if (lv < 1) lv = 1;
u = s->parser->upper;
while (u && !MRB_PROC_CFUNC_P(u)) {
- struct mrb_irep *ir = u->body.irep;
+ const struct mrb_irep *ir = u->body.irep;
uint_fast16_t n = ir->nlocals;
- const struct mrb_locals *v = ir->lv;
- for (; n > 1; n --, v ++) {
- if (v->name == id) {
- *idx = v->r;
+ int i;
+
+ const mrb_sym *v = ir->lv;
+ for (i=1; n > 1; n--, v++, i++) {
+ if (*v == id) {
+ *idx = i;
return lv - 1;
}
}
@@ -737,7 +742,7 @@ for_body(codegen_scope *s, node *tree)
genop_2(s, OP_BLOCK, cursp(), s->irep->rlen-1);
push();pop(); /* space for a block */
pop();
- idx = new_sym(s, mrb_intern_lit(s->mrb, "each"));
+ idx = new_sym(s, MRB_SYM(each));
genop_3(s, OP_SENDB, cursp(), idx, 0);
}
@@ -1325,7 +1330,7 @@ raise_error(codegen_scope *s, const char *msg)
genop_1(s, OP_ERR, idx);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static double
readint_float(codegen_scope *s, const char *p, int base)
{
@@ -1458,16 +1463,19 @@ codegen(codegen_scope *s, node *tree, int val)
{
int noexc, exend, pos1, pos2, tmp;
struct loopinfo *lp;
+ int catch_entry, begin, end;
if (tree->car == NULL) goto exit;
lp = loop_push(s, LOOP_BEGIN);
lp->pc0 = new_label(s);
- lp->pc1 = genjmp(s, OP_ONERR, 0);
+ catch_entry = catch_handler_new(s);
+ begin = s->pc;
codegen(s, tree->car, VAL);
pop();
lp->type = LOOP_RESCUE;
+ end = s->pc;
noexc = genjmp(s, OP_JMP, 0);
- dispatch(s, lp->pc1);
+ catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc);
tree = tree->cdr;
exend = 0;
pos1 = 0;
@@ -1489,14 +1497,14 @@ codegen(codegen_scope *s, node *tree, int val)
gen_move(s, cursp(), exc, 0);
push_n(2); pop_n(2); /* space for one arg and a block */
pop();
- genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1);
+ genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM(__case_eqq)), 1);
}
else {
if (n4) {
codegen(s, n4->car, VAL);
}
else {
- genop_2(s, OP_GETCONST, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "StandardError")));
+ genop_2(s, OP_GETCONST, cursp(), new_sym(s, MRB_SYM(StandardError)));
push();
}
pop();
@@ -1526,13 +1534,12 @@ codegen(codegen_scope *s, node *tree, int val)
}
if (pos1) {
dispatch(s, pos1);
- genop_1(s, OP_RAISE, exc);
+ genop_1(s, OP_RAISEIF, exc);
}
}
pop();
tree = tree->cdr;
dispatch(s, noexc);
- genop_1(s, OP_POPERR, 1);
if (tree->car) {
codegen(s, tree->car, val);
}
@@ -1548,14 +1555,22 @@ codegen(codegen_scope *s, node *tree, int val)
if (!tree->cdr || !tree->cdr->cdr ||
(nint(tree->cdr->cdr->car) == NODE_BEGIN &&
tree->cdr->cdr->cdr)) {
+ int catch_entry, begin, end, target;
int idx;
- s->ensure_level++;
- idx = scope_body(s, tree->cdr, NOVAL);
- genop_1(s, OP_EPUSH, idx);
+ catch_entry = catch_handler_new(s);
+ begin = s->pc;
codegen(s, tree->car, val);
- s->ensure_level--;
- genop_1(s, OP_EPOP, 1);
+ end = target = s->pc;
+ push();
+ idx = cursp();
+ genop_1(s, OP_EXCEPT, idx);
+ push();
+ codegen(s, tree->cdr->cdr, NOVAL);
+ pop();
+ genop_1(s, OP_RAISEIF, idx);
+ pop();
+ catch_handler_set(s, catch_entry, MRB_CATCH_ENSURE, begin, end, target);
}
else { /* empty ensure ignored */
codegen(s, tree->car, val);
@@ -1603,7 +1618,7 @@ codegen(codegen_scope *s, node *tree, int val)
{
node *n = tree->car->cdr;
mrb_sym mid = nsym(n->cdr->car);
- mrb_sym mnil = mrb_intern_lit(s->mrb, "nil?");
+ mrb_sym mnil = MRB_QSYM(nil_p);
if (mid == mnil && n->cdr->cdr->car == NULL) {
nil_p = TRUE;
codegen(s, n->car, VAL);
@@ -1739,10 +1754,10 @@ codegen(codegen_scope *s, node *tree, int val)
gen_move(s, cursp(), head, 0);
push(); push(); pop(); pop(); pop();
if (nint(n->car->car) == NODE_SPLAT) {
- genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1);
+ genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM(__case_eqq)), 1);
}
else {
- genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "===")), 1);
+ genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_QSYM(eqq)), 1);
}
}
else {
@@ -2017,18 +2032,20 @@ codegen(codegen_scope *s, node *tree, int val)
if ((len == 2 && name[0] == '|' && name[1] == '|') &&
(nint(tree->car->car) == NODE_CONST ||
nint(tree->car->car) == NODE_CVAR)) {
- int onerr, noexc, exc;
+ int catch_entry, begin, end;
+ int noexc, exc;
struct loopinfo *lp;
- onerr = genjmp(s, OP_ONERR, 0);
lp = loop_push(s, LOOP_BEGIN);
- lp->pc1 = onerr;
+ lp->pc0 = new_label(s);
+ catch_entry = catch_handler_new(s);
+ begin = s->pc;
exc = cursp();
codegen(s, tree->car, VAL);
- lp->type = LOOP_RESCUE;
- genop_1(s, OP_POPERR, 1);
+ end = s->pc;
noexc = genjmp(s, OP_JMP, 0);
- dispatch(s, onerr);
+ lp->type = LOOP_RESCUE;
+ catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc);
genop_1(s, OP_EXCEPT, exc);
genop_1(s, OP_LOADF, exc);
dispatch(s, noexc);
@@ -2266,7 +2283,7 @@ codegen(codegen_scope *s, node *tree, int val)
pop_n(n+1);
genop_2S(s, OP_BLKPUSH, cursp(), (ainfo<<4)|(lv & 0xf));
if (sendv) n = CALL_MAXARGS;
- genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "call")), n);
+ genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM(call)), n);
if (val) push();
}
break;
@@ -2281,11 +2298,8 @@ codegen(codegen_scope *s, node *tree, int val)
raise_error(s, "unexpected next");
}
else if (s->loop->type == LOOP_NORMAL) {
- if (s->ensure_level > s->loop->ensure_level) {
- genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
- }
codegen(s, tree, NOVAL);
- genjmp(s, OP_JMP, s->loop->pc0);
+ genjmp(s, OP_JMPUW, s->loop->pc0);
}
else {
if (tree) {
@@ -2305,10 +2319,7 @@ codegen(codegen_scope *s, node *tree, int val)
raise_error(s, "unexpected redo");
}
else {
- if (s->ensure_level > s->loop->ensure_level) {
- genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
- }
- genjmp(s, OP_JMP, s->loop->pc2);
+ genjmp(s, OP_JMPUW, s->loop->pc2);
}
if (val) push();
break;
@@ -2316,32 +2327,16 @@ codegen(codegen_scope *s, node *tree, int val)
case NODE_RETRY:
{
const char *msg = "unexpected retry";
+ const struct loopinfo *lp = s->loop;
- if (!s->loop) {
+ while (lp && lp->type != LOOP_RESCUE) {
+ lp = lp->prev;
+ }
+ if (!lp) {
raise_error(s, msg);
}
else {
- struct loopinfo *lp = s->loop;
- int n = 0;
-
- while (lp && lp->type != LOOP_RESCUE) {
- if (lp->type == LOOP_BEGIN) {
- n++;
- }
- lp = lp->prev;
- }
- if (!lp) {
- raise_error(s, msg);
- }
- else {
- if (n > 0) {
- genop_1(s, OP_POPERR, n);
- }
- if (s->ensure_level > lp->ensure_level) {
- genop_1(s, OP_EPOP, s->ensure_level - lp->ensure_level);
- }
- genjmp(s, OP_JMP, lp->pc0);
- }
+ genjmp(s, OP_JMPUW, lp->pc0);
}
if (val) push();
}
@@ -2447,7 +2442,7 @@ codegen(codegen_scope *s, node *tree, int val)
mrb_bool overflow;
i = readint_mrb_int(s, p, base, FALSE, &overflow);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
if (overflow) {
double f = readint_float(s, p, base);
int off = new_lit(s, mrb_float_value(s->mrb, f));
@@ -2470,7 +2465,7 @@ codegen(codegen_scope *s, node *tree, int val)
int off;
lit_int:
- off = new_lit(s, mrb_fixnum_value(i));
+ off = new_lit(s, mrb_int_value(s->mrb, i));
genop_2(s, OP_LOADL, cursp(), off);
}
}
@@ -2478,7 +2473,7 @@ codegen(codegen_scope *s, node *tree, int val)
}
break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case NODE_FLOAT:
if (val) {
char *p = (char*)tree;
@@ -2495,7 +2490,7 @@ codegen(codegen_scope *s, node *tree, int val)
{
nt = nint(tree->car);
switch (nt) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case NODE_FLOAT:
if (val) {
char *p = (char*)tree->cdr;
@@ -2516,7 +2511,7 @@ codegen(codegen_scope *s, node *tree, int val)
mrb_bool overflow;
i = readint_mrb_int(s, p, base, TRUE, &overflow);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
if (overflow) {
double f = readint_float(s, p, base);
int off = new_lit(s, mrb_float_value(s->mrb, -f));
@@ -2533,10 +2528,10 @@ codegen(codegen_scope *s, node *tree, int val)
genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i);
}
else {
- int off = new_lit(s, mrb_fixnum_value(i));
+ int off = new_lit(s, mrb_int_value(s->mrb, i));
genop_2(s, OP_LOADL, cursp(), off);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
}
#endif
push();
@@ -2545,7 +2540,7 @@ codegen(codegen_scope *s, node *tree, int val)
default:
if (val) {
- int sym = new_sym(s, mrb_intern_lit(s->mrb, "-@"));
+ int sym = new_sym(s, MRB_QSYM(minus));
codegen(s, tree, VAL);
pop();
genop_3(s, OP_SEND, cursp(), sym, 0);
@@ -2618,7 +2613,7 @@ codegen(codegen_scope *s, node *tree, int val)
{
node *n;
int ai = mrb_gc_arena_save(s->mrb);
- int sym = new_sym(s, mrb_intern_lit(s->mrb, "Kernel"));
+ int sym = new_sym(s, MRB_SYM(Kernel));
genop_1(s, OP_LOADSELF, cursp());
push();
@@ -2637,7 +2632,7 @@ codegen(codegen_scope *s, node *tree, int val)
}
push(); /* for block */
pop_n(3);
- sym = new_sym(s, mrb_intern_lit(s->mrb, "`"));
+ sym = new_sym(s, MRB_QSYM(tick)); /* ` */
genop_3(s, OP_SEND, cursp(), sym, 1);
if (val) push();
mrb_gc_arena_restore(s->mrb, ai);
@@ -2657,7 +2652,7 @@ codegen(codegen_scope *s, node *tree, int val)
genop_2(s, OP_STRING, cursp(), off);
push(); push();
pop_n(3);
- sym = new_sym(s, mrb_intern_lit(s->mrb, "`"));
+ sym = new_sym(s, MRB_QSYM(tick)); /* ` */
genop_3(s, OP_SEND, cursp(), sym, 1);
if (val) push();
mrb_gc_arena_restore(s->mrb, ai);
@@ -2698,7 +2693,7 @@ codegen(codegen_scope *s, node *tree, int val)
}
push(); /* space for a block */
pop_n(argc+2);
- sym = new_sym(s, mrb_intern_lit(s->mrb, "compile"));
+ sym = new_sym(s, MRB_SYM(compile));
genop_3(s, OP_SEND, cursp(), sym, argc);
mrb_gc_arena_restore(s->mrb, ai);
push();
@@ -2752,7 +2747,7 @@ codegen(codegen_scope *s, node *tree, int val)
}
push(); /* space for a block */
pop_n(argc+2);
- sym = new_sym(s, mrb_intern_lit(s->mrb, "compile"));
+ sym = new_sym(s, MRB_SYM(compile));
genop_3(s, OP_SEND, cursp(), sym, argc);
mrb_gc_arena_restore(s->mrb, ai);
push();
@@ -2993,91 +2988,86 @@ scope_add_irep(codegen_scope *s, mrb_irep *irep)
}
if (s->irep->rlen == s->rcapa) {
s->rcapa *= 2;
- s->irep->reps = (mrb_irep**)codegen_realloc(s, s->irep->reps, sizeof(mrb_irep*)*s->rcapa);
+ s->reps = (mrb_irep**)codegen_realloc(s, s->reps, sizeof(mrb_irep*)*s->rcapa);
}
- s->irep->reps[s->irep->rlen] = irep;
+ s->reps[s->irep->rlen] = irep;
s->irep->rlen++;
}
static codegen_scope*
-scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
+scope_new(mrb_state *mrb, codegen_scope *prev, node *nlv)
{
static const codegen_scope codegen_scope_zero = { 0 };
mrb_pool *pool = mrb_pool_open(mrb);
- codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope));
+ codegen_scope *s = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope));
- if (!p) {
+ if (!s) {
if (prev)
codegen_error(prev, "unexpected scope");
return NULL;
}
- *p = codegen_scope_zero;
- p->mrb = mrb;
- p->mpool = pool;
- if (!prev) return p;
- p->prev = prev;
- p->ainfo = -1;
- p->mscope = 0;
-
- p->irep = mrb_add_irep(mrb);
- scope_add_irep(prev, p->irep);
-
- p->rcapa = 8;
- p->irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*p->rcapa);
-
- p->icapa = 1024;
- p->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*p->icapa);
- p->irep->iseq = NULL;
-
- p->pcapa = 32;
- p->irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*p->pcapa);
- p->irep->plen = 0;
-
- p->scapa = 256;
- p->irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*p->scapa);
- p->irep->slen = 0;
-
- p->lv = lv;
- p->sp += node_len(lv)+1; /* add self */
- p->nlocals = p->sp;
- if (lv) {
- node *n = lv;
+ *s = codegen_scope_zero;
+ s->mrb = mrb;
+ s->mpool = pool;
+ if (!prev) return s;
+ s->prev = prev;
+ s->ainfo = -1;
+ s->mscope = 0;
+
+ s->irep = mrb_add_irep(mrb);
+ scope_add_irep(prev, s->irep);
+
+ s->rcapa = 8;
+ s->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*s->rcapa);
+
+ s->icapa = 1024;
+ s->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*s->icapa);
+ s->irep->iseq = NULL;
+
+ s->pcapa = 32;
+ s->pool = (mrb_pool_value*)mrb_malloc(mrb, sizeof(mrb_pool_value)*s->pcapa);
+ s->irep->plen = 0;
+
+ s->scapa = 256;
+ s->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*s->scapa);
+ s->irep->slen = 0;
+
+ s->lv = nlv;
+ s->sp += node_len(nlv)+1; /* add self */
+ s->nlocals = s->sp;
+ if (nlv) {
+ mrb_sym *lv;
+ node *n = nlv;
size_t i = 0;
- p->irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (p->nlocals - 1));
- for (i=0, n=lv; n; i++,n=n->cdr) {
- p->irep->lv[i].name = lv_name(n);
- if (lv_name(n)) {
- p->irep->lv[i].r = lv_idx(p, lv_name(n));
- }
- else {
- p->irep->lv[i].r = 0;
- }
+ s->irep->lv = lv = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*(s->nlocals-1));
+ for (i=0, n=nlv; n; i++,n=n->cdr) {
+ lv[i] = lv_name(n);
}
- mrb_assert(i + 1 == p->nlocals);
+ mrb_assert(i + 1 == s->nlocals);
}
- p->ai = mrb_gc_arena_save(mrb);
+ s->ai = mrb_gc_arena_save(mrb);
- p->filename_sym = prev->filename_sym;
- if (p->filename_sym) {
- p->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*p->icapa);
+ s->filename_sym = prev->filename_sym;
+ if (s->filename_sym) {
+ s->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*s->icapa);
}
- p->lineno = prev->lineno;
+ s->lineno = prev->lineno;
/* debug setting */
- p->debug_start_pos = 0;
- if (p->filename_sym) {
- mrb_debug_info_alloc(mrb, p->irep);
+ s->debug_start_pos = 0;
+ if (s->filename_sym) {
+ mrb_debug_info_alloc(mrb, s->irep);
}
else {
- p->irep->debug_info = NULL;
+ s->irep->debug_info = NULL;
}
- p->parser = prev->parser;
- p->filename_index = prev->filename_index;
+ s->parser = prev->parser;
+ s->filename_index = prev->filename_index;
- p->rlev = prev->rlev+1;
+ s->rlev = prev->rlev+1;
- return p;
+ return s;
}
static void
@@ -3091,12 +3081,21 @@ scope_finish(codegen_scope *s)
}
irep->flags = 0;
if (s->iseq) {
- irep->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc);
+ size_t catchsize = sizeof(struct mrb_irep_catch_handler) * irep->clen;
+ irep->iseq = (const mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc + catchsize);
irep->ilen = s->pc;
+ if (irep->clen > 0) {
+ memcpy((void *)(irep->iseq + irep->ilen), s->catch_table, catchsize);
+ }
+ }
+ else {
+ irep->clen = 0;
}
- irep->pool = (mrb_value*)codegen_realloc(s, irep->pool, sizeof(mrb_value)*irep->plen);
- irep->syms = (mrb_sym*)codegen_realloc(s, irep->syms, sizeof(mrb_sym)*irep->slen);
- irep->reps = (mrb_irep**)codegen_realloc(s, irep->reps, sizeof(mrb_irep*)*irep->rlen);
+ mrb_free(s->mrb, s->catch_table);
+ s->catch_table = NULL;
+ irep->pool = (const mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*irep->plen);
+ irep->syms = (const mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*irep->slen);
+ irep->reps = (const mrb_irep**)codegen_realloc(s, s->reps, sizeof(mrb_irep*)*irep->rlen);
if (s->filename_sym) {
mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index);
const char *filename = mrb_sym_name_len(s->mrb, fname, NULL);
@@ -3121,7 +3120,6 @@ loop_push(codegen_scope *s, enum looptype t)
p->type = t;
p->pc0 = p->pc1 = p->pc2 = p->pc3 = 0;
p->prev = s->loop;
- p->ensure_level = s->ensure_level;
p->acc = cursp();
s->loop = p;
@@ -3137,7 +3135,6 @@ loop_break(codegen_scope *s, node *tree)
}
else {
struct loopinfo *loop;
- int n = 0;
if (tree) {
gen_retval(s, tree);
@@ -3146,7 +3143,6 @@ loop_break(codegen_scope *s, node *tree)
loop = s->loop;
while (loop) {
if (loop->type == LOOP_BEGIN) {
- n++;
loop = loop->prev;
}
else if (loop->type == LOOP_RESCUE) {
@@ -3160,20 +3156,14 @@ loop_break(codegen_scope *s, node *tree)
raise_error(s, "unexpected break");
return;
}
- if (n > 0) {
- genop_1(s, OP_POPERR, n);
- }
if (loop->type == LOOP_NORMAL) {
int tmp;
- if (s->ensure_level > s->loop->ensure_level) {
- genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
- }
if (tree) {
gen_move(s, loop->acc, cursp(), 0);
}
- tmp = genjmp(s, OP_JMP, loop->pc3);
+ tmp = genjmp(s, OP_JMPUW, loop->pc3);
loop->pc3 = tmp;
}
else {
@@ -3196,6 +3186,31 @@ loop_pop(codegen_scope *s, int val)
if (val) push();
}
+static int
+catch_handler_new(codegen_scope *s)
+{
+ size_t newsize = sizeof(struct mrb_irep_catch_handler) * (s->irep->clen + 1);
+ s->catch_table = (struct mrb_irep_catch_handler *)codegen_realloc(s, (void *)s->catch_table, newsize);
+ return s->irep->clen ++;
+}
+
+static void
+catch_handler_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target)
+{
+ struct mrb_irep_catch_handler *e;
+
+ mrb_assert(ent >= 0 && ent < s->irep->clen);
+ mrb_assert(begin < MAXARG_S);
+ mrb_assert(end < MAXARG_S);
+ mrb_assert(target < MAXARG_S);
+
+ e = &s->catch_table[ent];
+ uint8_to_bin(type, &e->type);
+ uint16_to_bin(begin, e->begin);
+ uint16_to_bin(end, e->end);
+ uint16_to_bin(target, e->target);
+}
+
static struct RProc*
generate_code(mrb_state *mrb, parser_state *p, int val)
{
@@ -3242,13 +3257,14 @@ mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep)
{
int i;
+ if (irep->flags & MRB_IREP_NO_FREE) return;
if (irep->lv) {
- mrb_free(mrb, irep->lv);
+ mrb_free(mrb, (void*)irep->lv);
irep->lv = NULL;
}
-
+ if (!irep->reps) return;
for (i = 0; i < irep->rlen; ++i) {
- mrb_irep_remove_lv(mrb, irep->reps[i]);
+ mrb_irep_remove_lv(mrb, (mrb_irep*)irep->reps[i]);
}
}
@@ -3272,35 +3288,3 @@ uint8_t mrb_insn_size[] = {
#undef SB
#undef BBB
};
-/* EXT1 instruction sizes */
-uint8_t mrb_insn_size1[] = {
-#define B 3
-#define BB 4
-#define BBB 5
-#define BS 5
-#define SB 5
-#define OPCODE(_,x) x,
-#include "mruby/ops.h"
-#undef OPCODE
-#undef B
-};
-/* EXT2 instruction sizes */
-uint8_t mrb_insn_size2[] = {
-#define B 2
-#define OPCODE(_,x) x,
-#include "mruby/ops.h"
-#undef OPCODE
-#undef BB
-#undef BBB
-#undef BS
-#undef SB
-};
-/* EXT3 instruction sizes */
-#define BB 5
-#define BBB 6
-#define BS 4
-#define SB 5
-uint8_t mrb_insn_size3[] = {
-#define OPCODE(_,x) x,
-#include "mruby/ops.h"
-};
diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y
index 9de45a5361ea510baa810c7c43397220a41a757f..3cd74971fd3fe32f30fd829d66459a9c033448df 100644
--- a/mrbgems/mruby-compiler/core/parse.y
+++ b/mrbgems/mruby-compiler/core/parse.y
@@ -265,7 +265,7 @@ local_unnest(parser_state *p)
static mrb_bool
local_var_p(parser_state *p, mrb_sym sym)
{
- struct RProc *u;
+ const struct RProc *u;
node *l = p->locals;
while (l) {
@@ -279,11 +279,13 @@ local_var_p(parser_state *p, mrb_sym sym)
u = p->upper;
while (u && !MRB_PROC_CFUNC_P(u)) {
- struct mrb_irep *ir = u->body.irep;
- uint_fast16_t n = ir->nlocals;
- const struct mrb_locals *v = ir->lv;
- for (; n > 1; n --, v ++) {
- if (v->name == sym) return TRUE;
+ const struct mrb_irep *ir = u->body.irep;
+ const mrb_sym *v = ir->lv;
+ int i;
+
+ if (!v) break;
+ for (i=0; i < ir->nlocals; i++) {
+ if (v[i] == sym) return TRUE;
}
if (MRB_PROC_SCOPE_P(u)) break;
u = u->upper;
@@ -311,14 +313,14 @@ static void
local_add_blk(parser_state *p, mrb_sym blk)
{
/* allocate register for block */
- local_add_f(p, blk ? blk : mrb_intern_lit(p->mrb, "&"));
+ local_add_f(p, blk ? blk : MRB_QSYM(and));
}
static void
local_add_kw(parser_state *p, mrb_sym kwd)
{
/* allocate register for keywords hash */
- local_add_f(p, kwd ? kwd : mrb_intern_lit(p->mrb, "**"));
+ local_add_f(p, kwd ? kwd : MRB_QSYM(pow));
}
static node*
@@ -730,7 +732,19 @@ new_module(parser_state *p, node *m, node *b)
static node*
new_def(parser_state *p, mrb_sym m, node *a, node *b)
{
- return list5((node*)NODE_DEF, nsym(m), locals_node(p), a, b);
+ return list5((node*)NODE_DEF, nsym(m), 0, a, b);
+}
+
+static void
+defn_setup(parser_state *p, node *d, node *a, node *b)
+{
+ node *n = d->cdr->cdr;
+
+ n->car = locals_node(p);
+ p->cmdarg_stack = intn(n->cdr->car);
+ n->cdr->car = a;
+ local_resume(p, n->cdr->cdr->car);
+ n->cdr->cdr->car = b;
}
/* (:sdef obj m lv (arg . body)) */
@@ -738,7 +752,19 @@ static node*
new_sdef(parser_state *p, node *o, mrb_sym m, node *a, node *b)
{
void_expr_error(p, o);
- return list6((node*)NODE_SDEF, o, nsym(m), locals_node(p), a, b);
+ return list6((node*)NODE_SDEF, o, nsym(m), 0, a, b);
+}
+
+static void
+defs_setup(parser_state *p, node *d, node *a, node *b)
+{
+ node *n = d->cdr->cdr->cdr;
+
+ n->car = locals_node(p);
+ p->cmdarg_stack = intn(n->cdr->car);
+ n->cdr->car = a;
+ local_resume(p, n->cdr->cdr->car);
+ n->cdr->cdr->car = b;
}
/* (:arg . sym) */
@@ -932,13 +958,13 @@ new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
static node*
new_imaginary(parser_state *p, node *imaginary)
{
- return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Complex"), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
+ return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Complex), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
}
static node*
new_rational(parser_state *p, node *rational)
{
- return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Rational"), list1(list1(rational)), 1);
+ return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Rational), list1(list1(rational)), 1);
}
/* (:int . i) */
@@ -955,7 +981,7 @@ new_int(parser_state *p, const char *s, int base, int suffix)
return result;
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/* (:float . i) */
static node*
new_float(parser_state *p, const char *s, int suffix)
@@ -1415,8 +1441,8 @@ heredoc_end(parser_state *p)
%token <num> tNUMPARAM
%type <nd> singleton string string_fragment string_rep string_interp xstring regexp
-%type <nd> literal numeric cpath symbol
-%type <nd> top_compstmt top_stmts top_stmt
+%type <nd> literal numeric cpath symbol defn_head defs_head
+%type <nd> top_compstmt top_stmts top_stmt rassign
%type <nd> bodystmt compstmt stmts stmt expr arg primary command command_call method_call
%type <nd> expr_value arg_rhs primary_value
%type <nd> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure
@@ -1425,7 +1451,7 @@ heredoc_end(parser_state *p)
%type <nd> command_args aref_args opt_block_arg block_arg var_ref var_lhs
%type <nd> command_asgn command_rhs mrhs superclass block_call block_command
%type <nd> f_block_optarg f_block_opt
-%type <nd> f_arglist f_args f_arg f_arg_item f_optarg f_margs
+%type <nd> f_arglist_paren f_arglist f_args f_arg f_arg_item f_optarg f_margs
%type <nd> assoc_list assocs assoc undef_list backref for_var
%type <nd> block_param opt_block_param block_param_def f_opt
%type <nd> bv_decls opt_bv_decl bvar f_larglist lambda_body
@@ -1658,9 +1684,30 @@ stmt : keyword_alias fsym {p->lstate = EXPR_FNAME;} fsym
{
$$ = new_masgn(p, $1, new_array(p, $3));
}
+ | rassign
| expr
;
+rassign : arg tASSOC lhs
+ {
+ void_expr_error(p, $1);
+ $$ = new_asgn(p, $3, $1);
+ }
+ | arg tASSOC mlhs
+ {
+ void_expr_error(p, $1);
+ $$ = new_masgn(p, $3, $1);
+ }
+ | rassign tASSOC lhs
+ {
+ $$ = new_asgn(p, $3, $1);
+ }
+ | rassign tASSOC mlhs
+ {
+ $$ = new_masgn(p, $3, $1);
+ }
+ ;
+
command_asgn : lhs '=' command_rhs
{
$$ = new_asgn(p, $1, $3);
@@ -1671,7 +1718,7 @@ command_asgn : lhs '=' command_rhs
}
| primary_value '[' opt_call_args ']' tOP_ASGN command_rhs
{
- $$ = new_op_asgn(p, new_call(p, $1, intern_lit("[]"), $3, '.'), $5, $6);
+ $$ = new_op_asgn(p, new_call(p, $1, MRB_QSYM(aref), $3, '.'), $5, $6);
}
| primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
{
@@ -1726,6 +1773,31 @@ expr : command_call
| arg
;
+
+defn_head : keyword_def fname
+ {
+ $$ = new_def(p, $2, nint(p->cmdarg_stack), local_switch(p));
+ p->cmdarg_stack = 0;
+ p->in_def++;
+ nvars_block(p);
+ }
+ ;
+
+defs_head : keyword_def singleton dot_or_colon
+ {
+ p->lstate = EXPR_FNAME;
+ }
+ fname
+ {
+ $$ = new_sdef(p, $2, $5, nint(p->cmdarg_stack), local_switch(p));
+ p->cmdarg_stack = 0;
+ p->in_def++;
+ p->in_single++;
+ nvars_block(p);
+ p->lstate = EXPR_ENDFN; /* force for args */
+ }
+ ;
+
expr_value : expr
{
if (!$1) $$ = new_nil(p);
@@ -1902,7 +1974,7 @@ mlhs_node : variable
}
| primary_value '[' opt_call_args ']'
{
- $$ = new_call(p, $1, intern_lit("[]"), $3, '.');
+ $$ = new_call(p, $1, MRB_QSYM(aref), $3, '.');
}
| primary_value call_op tIDENTIFIER
{
@@ -1941,7 +2013,7 @@ lhs : variable
}
| primary_value '[' opt_call_args ']'
{
- $$ = new_call(p, $1, intern_lit("[]"), $3, '.');
+ $$ = new_call(p, $1, MRB_QSYM(aref), $3, '.');
}
| primary_value call_op tIDENTIFIER
{
@@ -2029,36 +2101,36 @@ undef_list : fsym
}
;
-op : '|' { $$ = intern_lit("|"); }
- | '^' { $$ = intern_lit("^"); }
- | '&' { $$ = intern_lit("&"); }
- | tCMP { $$ = intern_lit("<=>"); }
- | tEQ { $$ = intern_lit("=="); }
- | tEQQ { $$ = intern_lit("==="); }
- | tMATCH { $$ = intern_lit("=~"); }
- | tNMATCH { $$ = intern_lit("!~"); }
- | '>' { $$ = intern_lit(">"); }
- | tGEQ { $$ = intern_lit(">="); }
- | '<' { $$ = intern_lit("<"); }
- | tLEQ { $$ = intern_lit("<="); }
- | tNEQ { $$ = intern_lit("!="); }
- | tLSHFT { $$ = intern_lit("<<"); }
- | tRSHFT { $$ = intern_lit(">>"); }
- | '+' { $$ = intern_lit("+"); }
- | '-' { $$ = intern_lit("-"); }
- | '*' { $$ = intern_lit("*"); }
- | tSTAR { $$ = intern_lit("*"); }
- | '/' { $$ = intern_lit("/"); }
- | '%' { $$ = intern_lit("%"); }
- | tPOW { $$ = intern_lit("**"); }
- | tDSTAR { $$ = intern_lit("**"); }
- | '!' { $$ = intern_lit("!"); }
- | '~' { $$ = intern_lit("~"); }
- | tUPLUS { $$ = intern_lit("+@"); }
- | tUMINUS { $$ = intern_lit("-@"); }
- | tAREF { $$ = intern_lit("[]"); }
- | tASET { $$ = intern_lit("[]="); }
- | '`' { $$ = intern_lit("`"); }
+op : '|' { $$ = MRB_QSYM(or); }
+ | '^' { $$ = MRB_QSYM(xor); }
+ | '&' { $$ = MRB_QSYM(and); }
+ | tCMP { $$ = MRB_QSYM(cmp); }
+ | tEQ { $$ = MRB_QSYM(eq); }
+ | tEQQ { $$ = MRB_QSYM(eqq); }
+ | tMATCH { $$ = MRB_QSYM(match); }
+ | tNMATCH { $$ = MRB_QSYM(nmatch); }
+ | '>' { $$ = MRB_QSYM(gt); }
+ | tGEQ { $$ = MRB_QSYM(ge); }
+ | '<' { $$ = MRB_QSYM(lt); }
+ | tLEQ { $$ = MRB_QSYM(le); }
+ | tNEQ { $$ = MRB_QSYM(neq); }
+ | tLSHFT { $$ = MRB_QSYM(lshift); }
+ | tRSHFT { $$ = MRB_QSYM(rshift); }
+ | '+' { $$ = MRB_QSYM(add); }
+ | '-' { $$ = MRB_QSYM(sub); }
+ | '*' { $$ = MRB_QSYM(mul); }
+ | tSTAR { $$ = MRB_QSYM(mul); }
+ | '/' { $$ = MRB_QSYM(div); }
+ | '%' { $$ = MRB_QSYM(mod); }
+ | tPOW { $$ = MRB_QSYM(pow); }
+ | tDSTAR { $$ = MRB_QSYM(pow); }
+ | '!' { $$ = MRB_QSYM(not); }
+ | '~' { $$ = MRB_QSYM(neg); }
+ | tUPLUS { $$ = MRB_QSYM(plus); }
+ | tUMINUS { $$ = MRB_QSYM(minus); }
+ | tAREF { $$ = MRB_QSYM(aref); }
+ | tASET { $$ = MRB_QSYM(aset); }
+ | '`' { $$ = MRB_QSYM(tick); }
;
reswords : keyword__LINE__ | keyword__FILE__ | keyword__ENCODING__
@@ -2085,7 +2157,7 @@ arg : lhs '=' arg_rhs
}
| primary_value '[' opt_call_args ']' tOP_ASGN arg_rhs
{
- $$ = new_op_asgn(p, new_call(p, $1, intern_lit("[]"), $3, '.'), $5, $6);
+ $$ = new_op_asgn(p, new_call(p, $1, MRB_QSYM(aref), $3, '.'), $5, $6);
}
| primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
{
@@ -2246,6 +2318,42 @@ arg : lhs '=' arg_rhs
{
$$ = new_if(p, cond($1), $3, $6);
}
+ | defn_head f_arglist_paren '=' arg
+ {
+ $$ = $1;
+ void_expr_error(p, $4);
+ defn_setup(p, $$, $2, $4);
+ nvars_unnest(p);
+ p->in_def--;
+ }
+ | defn_head f_arglist_paren '=' arg modifier_rescue arg
+ {
+ $$ = $1;
+ void_expr_error(p, $4);
+ void_expr_error(p, $6);
+ defn_setup(p, $$, $2, new_mod_rescue(p, $4, $6));
+ nvars_unnest(p);
+ p->in_def--;
+ }
+ | defs_head f_arglist_paren '=' arg
+ {
+ $$ = $1;
+ void_expr_error(p, $4);
+ defs_setup(p, $$, $2, $4);
+ nvars_unnest(p);
+ p->in_def--;
+ p->in_single--;
+ }
+ | defs_head f_arglist_paren '=' arg modifier_rescue arg
+ {
+ $$ = $1;
+ void_expr_error(p, $4);
+ void_expr_error(p, $6);
+ defs_setup(p, $$, $2, new_mod_rescue(p, $4, $6));
+ nvars_unnest(p);
+ p->in_def--;
+ p->in_single--;
+ }
| primary
{
$$ = $1;
@@ -2288,16 +2396,16 @@ paren_args : '(' opt_call_args ')'
| '(' tDOT3 rparen
{
#if 1
- mrb_sym r = mrb_intern_lit(p->mrb, "*");
- mrb_sym b = mrb_intern_lit(p->mrb, "&");
+ mrb_sym r = MRB_QSYM(mul);
+ mrb_sym b = MRB_QSYM(and);
if (local_var_p(p, r) && local_var_p(p, b)) {
$$ = cons(list1(new_splat(p, new_lvar(p, r))),
new_block_arg(p, new_lvar(p, b)));
}
#else
- mrb_sym r = mrb_intern_lit(p->mrb, "*");
- mrb_sym k = mrb_intern_lit(p->mrb, "**");
- mrb_sym b = mrb_intern_lit(p->mrb, "&");
+ mrb_sym r = MRB_QSYM(mul);
+ mrb_sym k = MRB_QSYM(pow);
+ mrb_sym b = MRB_QSYM(and);
if (local_var_p(p, r) && local_var_p(p, k) && local_var_p(p, b)) {
$$ = cons(list2(new_splat(p, new_lvar(p, r)),
new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_lvar(p, k))))),
@@ -2645,50 +2753,26 @@ primary : literal
local_resume(p, $<nd>3);
nvars_unnest(p);
}
- | keyword_def fname
- {
- $<stack>$ = p->cmdarg_stack;
- p->cmdarg_stack = 0;
- }
- {
- p->in_def++;
- $<nd>$ = local_switch(p);
- nvars_block(p);
- }
+ | defn_head
f_arglist
bodystmt
keyword_end
{
- $$ = new_def(p, $2, $5, $6);
- SET_LINENO($$, $1);
- local_resume(p, $<nd>4);
+ $$ = $1;
+ defn_setup(p, $$, $2, $3);
nvars_unnest(p);
p->in_def--;
- p->cmdarg_stack = $<stack>3;
- }
- | keyword_def singleton dot_or_colon
- {
- p->lstate = EXPR_FNAME;
- $<stack>$ = p->cmdarg_stack;
- p->cmdarg_stack = 0;
- }
- fname
- {
- p->in_single++;
- p->lstate = EXPR_ENDFN; /* force for args */
- $<nd>$ = local_switch(p);
- nvars_block(p);
}
+ | defs_head
f_arglist
bodystmt
keyword_end
{
- $$ = new_sdef(p, $2, $5, $7, $8);
- SET_LINENO($$, $1);
- local_resume(p, $<nd>6);
+ $$ = $1;
+ defs_setup(p, $$, $2, $3);
nvars_unnest(p);
+ p->in_def--;
p->in_single--;
- p->cmdarg_stack = $<stack>4;
}
| keyword_break
{
@@ -3010,11 +3094,11 @@ method_call : operation paren_args
}
| primary_value call_op paren_args
{
- $$ = new_call(p, $1, intern_lit("call"), $3, $2);
+ $$ = new_call(p, $1, MRB_SYM(call), $3, $2);
}
| primary_value tCOLON2 paren_args
{
- $$ = new_call(p, $1, intern_lit("call"), $3, tCOLON2);
+ $$ = new_call(p, $1, MRB_SYM(call), $3, tCOLON2);
}
| keyword_super paren_args
{
@@ -3026,7 +3110,7 @@ method_call : operation paren_args
}
| primary_value '[' opt_call_args ']'
{
- $$ = new_call(p, $1, intern_lit("[]"), $3, '.');
+ $$ = new_call(p, $1, MRB_QSYM(aref), $3, '.');
}
;
@@ -3399,7 +3483,7 @@ superclass : /* term */
} */
;
-f_arglist : '(' f_args rparen
+f_arglist_paren : '(' f_args rparen
{
$$ = $2;
p->lstate = EXPR_BEG;
@@ -3409,20 +3493,23 @@ f_arglist : '(' f_args rparen
{
#if 1
/* til real keyword args implemented */
- mrb_sym r = mrb_intern_lit(p->mrb, "*");
- mrb_sym b = mrb_intern_lit(p->mrb, "&");
+ mrb_sym r = MRB_QSYM(mul);
+ mrb_sym b = MRB_QSYM(and);
local_add_f(p, r);
$$ = new_args(p, 0, 0, r, 0,
new_args_tail(p, 0, 0, b));
#else
- mrb_sym r = mrb_intern_lit(p->mrb, "*");
- mrb_sym k = mrb_intern_lit(p->mrb, "**");
- mrb_sym b = mrb_intern_lit(p->mrb, "&");
+ mrb_sym r = MRB_QSYM(mul);
+ mrb_sym k = MRB_QSYM(pow);
+ mrb_sym b = MRB_QSYM(and);
local_add_f(p, r); local_add_f(p, k);
$$ = new_args(p, 0, 0, r, 0,
new_args_tail(p, 0, new_kw_rest_args(p, nsym(k)), b));
#endif
}
+ ;
+
+f_arglist : f_arglist_paren
| f_args term
{
$$ = $1;
@@ -3580,7 +3667,7 @@ f_args : f_arg ',' f_optarg ',' f_rest_arg opt_args_tail
}
| /* none */
{
- local_add_f(p, mrb_intern_lit(p->mrb, "&"));
+ local_add_f(p, MRB_QSYM(and));
$$ = new_args(p, 0, 0, 0, 0, 0);
}
;
@@ -3704,7 +3791,7 @@ f_rest_arg : restarg_mark tIDENTIFIER
}
| restarg_mark
{
- local_add_f(p, mrb_intern_lit(p->mrb, "*"));
+ local_add_f(p, MRB_QSYM(mul));
$$ = -1;
}
;
@@ -4961,7 +5048,7 @@ parser_yylex(parser_state *p)
case '*':
if ((c = nextc(p)) == '*') {
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("**");
+ pylval.id = MRB_QSYM(pow);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -4979,7 +5066,7 @@ parser_yylex(parser_state *p)
}
else {
if (c == '=') {
- pylval.id = intern_lit("*");
+ pylval.id = MRB_QSYM(mul);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5095,7 +5182,7 @@ parser_yylex(parser_state *p)
}
if (c == '<') {
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("<<");
+ pylval.id = MRB_QSYM(lshift);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5117,7 +5204,7 @@ parser_yylex(parser_state *p)
}
if (c == '>') {
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit(">>");
+ pylval.id = MRB_QSYM(rshift);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5225,7 +5312,7 @@ parser_yylex(parser_state *p)
if ((c = nextc(p)) == '&') {
p->lstate = EXPR_BEG;
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("&&");
+ pylval.id = MRB_QSYM(andand);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5237,7 +5324,7 @@ parser_yylex(parser_state *p)
return tANDDOT;
}
else if (c == '=') {
- pylval.id = intern_lit("&");
+ pylval.id = MRB_QSYM(and);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5264,7 +5351,7 @@ parser_yylex(parser_state *p)
if ((c = nextc(p)) == '|') {
p->lstate = EXPR_BEG;
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("||");
+ pylval.id = MRB_QSYM(oror);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5272,7 +5359,7 @@ parser_yylex(parser_state *p)
return tOROP;
}
if (c == '=') {
- pylval.id = intern_lit("|");
+ pylval.id = MRB_QSYM(or);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5296,7 +5383,7 @@ parser_yylex(parser_state *p)
return '+';
}
if (c == '=') {
- pylval.id = intern_lit("+");
+ pylval.id = MRB_QSYM(add);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5324,7 +5411,7 @@ parser_yylex(parser_state *p)
return '-';
}
if (c == '=') {
- pylval.id = intern_lit("-");
+ pylval.id = MRB_QSYM(sub);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5574,7 +5661,7 @@ parser_yylex(parser_state *p)
}
tokfix(p);
if (is_float) {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
yywarning_s(p, "floating point numbers are not supported", tok(p));
pylval.nd = new_int(p, "0", 10, 0);
return tINTEGER;
@@ -5644,7 +5731,7 @@ parser_yylex(parser_state *p)
return tREGEXP_BEG;
}
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("/");
+ pylval.id = MRB_QSYM(div);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5663,7 +5750,7 @@ parser_yylex(parser_state *p)
case '^':
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("^");
+ pylval.id = MRB_QSYM(xor);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -5840,7 +5927,7 @@ parser_yylex(parser_state *p)
}
}
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("%");
+ pylval.id = MRB_QSYM(mod);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -6468,7 +6555,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
struct RClass *target = mrb->object_class;
struct RProc *proc;
mrb_value v;
- unsigned int keep = 0;
+ mrb_int keep = 0;
if (!p) {
return mrb_undef_value();
@@ -6488,7 +6575,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
}
else {
if (mrb->exc == NULL) {
- mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
+ mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
}
mrb_parser_free(p);
return mrb_undef_value();
@@ -6498,7 +6585,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
mrb_parser_free(p);
if (proc == NULL) {
if (mrb->exc == NULL) {
- mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
+ mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
}
return mrb_undef_value();
}
diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c
index c570fb1d7d2a53a4939d176af3d72f084f6d333e..b28509d81fa56c4cae870d06e4d14769840f0000 100644
--- a/mrbgems/mruby-compiler/core/y.tab.c
+++ b/mrbgems/mruby-compiler/core/y.tab.c
@@ -328,7 +328,7 @@ local_unnest(parser_state *p)
static mrb_bool
local_var_p(parser_state *p, mrb_sym sym)
{
- struct RProc *u;
+ const struct RProc *u;
node *l = p->locals;
while (l) {
@@ -342,11 +342,13 @@ local_var_p(parser_state *p, mrb_sym sym)
u = p->upper;
while (u && !MRB_PROC_CFUNC_P(u)) {
- struct mrb_irep *ir = u->body.irep;
- uint_fast16_t n = ir->nlocals;
- const struct mrb_locals *v = ir->lv;
- for (; n > 1; n --, v ++) {
- if (v->name == sym) return TRUE;
+ const struct mrb_irep *ir = u->body.irep;
+ const mrb_sym *v = ir->lv;
+ int i;
+
+ if (!v) break;
+ for (i=0; i < ir->nlocals; i++) {
+ if (v[i] == sym) return TRUE;
}
if (MRB_PROC_SCOPE_P(u)) break;
u = u->upper;
@@ -374,14 +376,14 @@ static void
local_add_blk(parser_state *p, mrb_sym blk)
{
/* allocate register for block */
- local_add_f(p, blk ? blk : mrb_intern_lit(p->mrb, "&"));
+ local_add_f(p, blk ? blk : MRB_QSYM(and));
}
static void
local_add_kw(parser_state *p, mrb_sym kwd)
{
/* allocate register for keywords hash */
- local_add_f(p, kwd ? kwd : mrb_intern_lit(p->mrb, "**"));
+ local_add_f(p, kwd ? kwd : MRB_QSYM(pow));
}
static node*
@@ -793,7 +795,19 @@ new_module(parser_state *p, node *m, node *b)
static node*
new_def(parser_state *p, mrb_sym m, node *a, node *b)
{
- return list5((node*)NODE_DEF, nsym(m), locals_node(p), a, b);
+ return list5((node*)NODE_DEF, nsym(m), 0, a, b);
+}
+
+static void
+defn_setup(parser_state *p, node *d, node *a, node *b)
+{
+ node *n = d->cdr->cdr;
+
+ n->car = locals_node(p);
+ p->cmdarg_stack = intn(n->cdr->car);
+ n->cdr->car = a;
+ local_resume(p, n->cdr->cdr->car);
+ n->cdr->cdr->car = b;
}
/* (:sdef obj m lv (arg . body)) */
@@ -801,7 +815,19 @@ static node*
new_sdef(parser_state *p, node *o, mrb_sym m, node *a, node *b)
{
void_expr_error(p, o);
- return list6((node*)NODE_SDEF, o, nsym(m), locals_node(p), a, b);
+ return list6((node*)NODE_SDEF, o, nsym(m), 0, a, b);
+}
+
+static void
+defs_setup(parser_state *p, node *d, node *a, node *b)
+{
+ node *n = d->cdr->cdr->cdr;
+
+ n->car = locals_node(p);
+ p->cmdarg_stack = intn(n->cdr->car);
+ n->cdr->car = a;
+ local_resume(p, n->cdr->cdr->car);
+ n->cdr->cdr->car = b;
}
/* (:arg . sym) */
@@ -995,13 +1021,13 @@ new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
static node*
new_imaginary(parser_state *p, node *imaginary)
{
- return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Complex"), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
+ return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Complex), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
}
static node*
new_rational(parser_state *p, node *rational)
{
- return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Rational"), list1(list1(rational)), 1);
+ return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Rational), list1(list1(rational)), 1);
}
/* (:int . i) */
@@ -1018,7 +1044,7 @@ new_int(parser_state *p, const char *s, int base, int suffix)
return result;
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/* (:float . i) */
static node*
new_float(parser_state *p, const char *s, int suffix)
@@ -1404,7 +1430,7 @@ heredoc_end(parser_state *p)
/* xxx ----------------------------- */
-#line 1408 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 1434 "mrbgems/mruby-compiler/core/y.tab.c"
# ifndef YY_CAST
# ifdef __cplusplus
@@ -1574,7 +1600,7 @@ extern int yydebug;
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{
-#line 1350 "mrbgems/mruby-compiler/core/parse.y"
+#line 1376 "mrbgems/mruby-compiler/core/parse.y"
node *nd;
mrb_sym id;
@@ -1582,7 +1608,7 @@ union YYSTYPE
stack_type stack;
const struct vtable *vars;
-#line 1586 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 1612 "mrbgems/mruby-compiler/core/y.tab.c"
};
typedef union YYSTYPE YYSTYPE;
@@ -1900,16 +1926,16 @@ union yyalloc
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 3
/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 11586
+#define YYLAST 11948
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 147
/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS 176
+#define YYNNTS 177
/* YYNRULES -- Number of rules. */
-#define YYNRULES 594
+#define YYNRULES 603
/* YYNSTATES -- Number of states. */
-#define YYNSTATES 1034
+#define YYNSTATES 1054
#define YYUNDEFTOK 2
#define YYMAXUTOK 375
@@ -1968,66 +1994,67 @@ static const yytype_uint8 yytranslate[] =
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_int16 yyrline[] =
{
- 0, 1508, 1508, 1508, 1519, 1525, 1529, 1534, 1538, 1544,
- 1546, 1545, 1559, 1586, 1592, 1596, 1601, 1605, 1611, 1611,
- 1615, 1619, 1623, 1627, 1631, 1635, 1639, 1644, 1645, 1649,
- 1653, 1657, 1661, 1664, 1668, 1672, 1676, 1680, 1684, 1689,
- 1693, 1700, 1701, 1705, 1709, 1710, 1714, 1718, 1722, 1726,
- 1729, 1738, 1739, 1742, 1743, 1750, 1749, 1764, 1768, 1773,
- 1777, 1782, 1786, 1791, 1795, 1799, 1803, 1807, 1813, 1817,
- 1823, 1824, 1830, 1834, 1838, 1842, 1846, 1850, 1854, 1858,
- 1862, 1866, 1872, 1873, 1879, 1883, 1889, 1893, 1899, 1903,
- 1907, 1911, 1915, 1919, 1925, 1931, 1938, 1942, 1946, 1950,
- 1954, 1958, 1964, 1970, 1975, 1981, 1985, 1988, 1992, 1996,
- 2003, 2004, 2005, 2006, 2011, 2018, 2019, 2022, 2026, 2026,
- 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041,
- 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051,
- 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061,
- 2064, 2064, 2064, 2065, 2065, 2066, 2066, 2066, 2067, 2067,
- 2067, 2067, 2068, 2068, 2068, 2069, 2069, 2069, 2070, 2070,
- 2070, 2070, 2071, 2071, 2071, 2071, 2072, 2072, 2072, 2072,
- 2073, 2073, 2073, 2073, 2074, 2074, 2074, 2074, 2075, 2075,
- 2078, 2082, 2086, 2090, 2094, 2098, 2102, 2107, 2112, 2117,
- 2121, 2125, 2129, 2133, 2137, 2141, 2145, 2149, 2153, 2157,
- 2161, 2165, 2169, 2173, 2177, 2181, 2185, 2189, 2193, 2197,
+ 0, 1534, 1534, 1534, 1545, 1551, 1555, 1560, 1564, 1570,
+ 1572, 1571, 1585, 1612, 1618, 1622, 1627, 1631, 1637, 1637,
+ 1641, 1645, 1649, 1653, 1657, 1661, 1665, 1670, 1671, 1675,
+ 1679, 1683, 1687, 1688, 1691, 1696, 1701, 1705, 1711, 1715,
+ 1719, 1723, 1727, 1731, 1736, 1740, 1747, 1748, 1752, 1756,
+ 1757, 1761, 1765, 1769, 1773, 1777, 1787, 1786, 1801, 1810,
+ 1811, 1814, 1815, 1822, 1821, 1836, 1840, 1845, 1849, 1854,
+ 1858, 1863, 1867, 1871, 1875, 1879, 1885, 1889, 1895, 1896,
+ 1902, 1906, 1910, 1914, 1918, 1922, 1926, 1930, 1934, 1938,
+ 1944, 1945, 1951, 1955, 1961, 1965, 1971, 1975, 1979, 1983,
+ 1987, 1991, 1997, 2003, 2010, 2014, 2018, 2022, 2026, 2030,
+ 2036, 2042, 2047, 2053, 2057, 2060, 2064, 2068, 2075, 2076,
+ 2077, 2078, 2083, 2090, 2091, 2094, 2098, 2098, 2104, 2105,
+ 2106, 2107, 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115,
+ 2116, 2117, 2118, 2119, 2120, 2121, 2122, 2123, 2124, 2125,
+ 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2136, 2136,
+ 2136, 2137, 2137, 2138, 2138, 2138, 2139, 2139, 2139, 2139,
+ 2140, 2140, 2140, 2141, 2141, 2141, 2142, 2142, 2142, 2142,
+ 2143, 2143, 2143, 2143, 2144, 2144, 2144, 2144, 2145, 2145,
+ 2145, 2145, 2146, 2146, 2146, 2146, 2147, 2147, 2150, 2154,
+ 2158, 2162, 2166, 2170, 2174, 2179, 2184, 2189, 2193, 2197,
2201, 2205, 2209, 2213, 2217, 2221, 2225, 2229, 2233, 2237,
- 2241, 2245, 2249, 2255, 2256, 2261, 2265, 2272, 2276, 2284,
- 2288, 2314, 2315, 2318, 2319, 2320, 2325, 2330, 2337, 2343,
- 2348, 2353, 2358, 2365, 2365, 2376, 2382, 2386, 2392, 2393,
- 2396, 2402, 2408, 2413, 2420, 2425, 2430, 2437, 2438, 2439,
- 2440, 2441, 2442, 2443, 2444, 2448, 2453, 2452, 2464, 2468,
- 2463, 2473, 2473, 2477, 2481, 2485, 2489, 2494, 2499, 2503,
- 2507, 2511, 2515, 2519, 2520, 2526, 2532, 2525, 2544, 2552,
- 2560, 2560, 2560, 2567, 2567, 2567, 2574, 2580, 2585, 2587,
- 2584, 2596, 2594, 2612, 2617, 2610, 2634, 2632, 2649, 2653,
- 2648, 2670, 2676, 2669, 2693, 2697, 2701, 2705, 2711, 2718,
- 2719, 2720, 2723, 2724, 2727, 2728, 2736, 2737, 2743, 2747,
- 2750, 2754, 2758, 2762, 2767, 2771, 2775, 2779, 2785, 2784,
- 2794, 2798, 2802, 2806, 2812, 2817, 2822, 2826, 2830, 2834,
- 2838, 2842, 2846, 2850, 2854, 2858, 2862, 2866, 2870, 2874,
- 2878, 2884, 2889, 2896, 2896, 2900, 2905, 2912, 2916, 2922,
- 2923, 2926, 2931, 2934, 2938, 2944, 2948, 2955, 2954, 2969,
- 2979, 2983, 2988, 2995, 2999, 3003, 3007, 3011, 3015, 3019,
- 3023, 3027, 3034, 3033, 3048, 3047, 3063, 3071, 3080, 3083,
- 3090, 3093, 3097, 3098, 3101, 3105, 3108, 3112, 3115, 3116,
- 3117, 3118, 3121, 3122, 3128, 3129, 3130, 3134, 3140, 3141,
- 3147, 3152, 3151, 3162, 3166, 3172, 3176, 3182, 3186, 3192,
- 3195, 3196, 3199, 3205, 3211, 3212, 3215, 3222, 3221, 3235,
- 3239, 3246, 3251, 3258, 3264, 3265, 3266, 3267, 3268, 3272,
- 3278, 3282, 3288, 3289, 3290, 3294, 3300, 3304, 3308, 3312,
- 3316, 3322, 3326, 3332, 3336, 3340, 3344, 3348, 3352, 3360,
- 3367, 3378, 3379, 3383, 3387, 3386, 3402, 3408, 3426, 3432,
- 3438, 3444, 3451, 3456, 3463, 3467, 3473, 3477, 3483, 3484,
- 3487, 3491, 3497, 3501, 3505, 3509, 3515, 3520, 3525, 3529,
- 3533, 3537, 3541, 3545, 3549, 3553, 3557, 3561, 3565, 3569,
- 3573, 3577, 3582, 3588, 3593, 3598, 3603, 3608, 3615, 3619,
- 3626, 3631, 3630, 3642, 3646, 3652, 3660, 3668, 3676, 3680,
- 3686, 3690, 3696, 3697, 3700, 3705, 3712, 3713, 3716, 3722,
- 3726, 3732, 3737, 3737, 3762, 3763, 3769, 3774, 3780, 3781,
- 3784, 3790, 3795, 3805, 3812, 3813, 3814, 3817, 3818, 3819,
- 3820, 3823, 3824, 3825, 3828, 3829, 3832, 3836, 3842, 3843,
- 3849, 3850, 3853, 3854, 3857, 3860, 3861, 3862, 3865, 3866,
- 3867, 3870, 3877, 3878, 3882
+ 2241, 2245, 2249, 2253, 2257, 2261, 2265, 2269, 2273, 2277,
+ 2281, 2285, 2289, 2293, 2297, 2301, 2305, 2309, 2313, 2317,
+ 2321, 2329, 2338, 2347, 2357, 2363, 2364, 2369, 2373, 2380,
+ 2384, 2392, 2396, 2422, 2423, 2426, 2427, 2428, 2433, 2438,
+ 2445, 2451, 2456, 2461, 2466, 2473, 2473, 2484, 2490, 2494,
+ 2500, 2501, 2504, 2510, 2516, 2521, 2528, 2533, 2538, 2545,
+ 2546, 2547, 2548, 2549, 2550, 2551, 2552, 2556, 2561, 2560,
+ 2572, 2576, 2571, 2581, 2581, 2585, 2589, 2593, 2597, 2602,
+ 2607, 2611, 2615, 2619, 2623, 2627, 2628, 2634, 2640, 2633,
+ 2652, 2660, 2668, 2668, 2668, 2675, 2675, 2675, 2682, 2688,
+ 2693, 2695, 2692, 2704, 2702, 2720, 2725, 2718, 2742, 2740,
+ 2756, 2766, 2777, 2781, 2785, 2789, 2795, 2802, 2803, 2804,
+ 2807, 2808, 2811, 2812, 2820, 2821, 2827, 2831, 2834, 2838,
+ 2842, 2846, 2851, 2855, 2859, 2863, 2869, 2868, 2878, 2882,
+ 2886, 2890, 2896, 2901, 2906, 2910, 2914, 2918, 2922, 2926,
+ 2930, 2934, 2938, 2942, 2946, 2950, 2954, 2958, 2962, 2968,
+ 2973, 2980, 2980, 2984, 2989, 2996, 3000, 3006, 3007, 3010,
+ 3015, 3018, 3022, 3028, 3032, 3039, 3038, 3053, 3063, 3067,
+ 3072, 3079, 3083, 3087, 3091, 3095, 3099, 3103, 3107, 3111,
+ 3118, 3117, 3132, 3131, 3147, 3155, 3164, 3167, 3174, 3177,
+ 3181, 3182, 3185, 3189, 3192, 3196, 3199, 3200, 3201, 3202,
+ 3205, 3206, 3212, 3213, 3214, 3218, 3224, 3225, 3231, 3236,
+ 3235, 3246, 3250, 3256, 3260, 3266, 3270, 3276, 3279, 3280,
+ 3283, 3289, 3295, 3296, 3299, 3306, 3305, 3319, 3323, 3330,
+ 3335, 3342, 3348, 3349, 3350, 3351, 3352, 3356, 3362, 3366,
+ 3372, 3373, 3374, 3378, 3384, 3388, 3392, 3396, 3400, 3406,
+ 3410, 3416, 3420, 3424, 3428, 3432, 3436, 3444, 3451, 3462,
+ 3463, 3467, 3471, 3470, 3486, 3492, 3512, 3513, 3519, 3525,
+ 3531, 3538, 3543, 3550, 3554, 3560, 3564, 3570, 3571, 3574,
+ 3578, 3584, 3588, 3592, 3596, 3602, 3607, 3612, 3616, 3620,
+ 3624, 3628, 3632, 3636, 3640, 3644, 3648, 3652, 3656, 3660,
+ 3664, 3669, 3675, 3680, 3685, 3690, 3695, 3702, 3706, 3713,
+ 3718, 3717, 3729, 3733, 3739, 3747, 3755, 3763, 3767, 3773,
+ 3777, 3783, 3784, 3787, 3792, 3799, 3800, 3803, 3809, 3813,
+ 3819, 3824, 3824, 3849, 3850, 3856, 3861, 3867, 3868, 3871,
+ 3877, 3882, 3892, 3899, 3900, 3901, 3904, 3905, 3906, 3907,
+ 3910, 3911, 3912, 3915, 3916, 3919, 3923, 3929, 3930, 3936,
+ 3937, 3940, 3941, 3944, 3947, 3948, 3949, 3952, 3953, 3954,
+ 3957, 3964, 3965, 3969
};
#endif
@@ -2065,33 +2092,33 @@ static const char *const yytname[] =
"'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "']'", "','", "'`'", "'('",
"')'", "';'", "'.'", "'\\n'", "$accept", "program", "$@1",
"top_compstmt", "top_stmts", "top_stmt", "@2", "bodystmt", "compstmt",
- "stmts", "stmt", "$@3", "command_asgn", "command_rhs", "expr",
- "expr_value", "command_call", "block_command", "cmd_brace_block", "$@4",
- "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_list",
- "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
- "undef_list", "$@5", "op", "reswords", "arg", "aref_args", "arg_rhs",
- "paren_args", "opt_paren_args", "opt_call_args", "call_args",
- "command_args", "@6", "block_arg", "opt_block_arg", "comma", "args",
- "mrhs", "primary", "@7", "@8", "$@9", "$@10", "@11", "@12", "$@13",
- "$@14", "$@15", "$@16", "$@17", "$@18", "@19", "@20", "@21", "@22",
- "@23", "@24", "@25", "@26", "primary_value", "then", "do", "if_tail",
- "opt_else", "for_var", "f_margs", "$@27", "block_args_tail",
- "opt_block_args_tail", "block_param", "opt_block_param",
- "block_param_def", "$@28", "opt_bv_decl", "bv_decls", "bvar",
- "f_larglist", "lambda_body", "do_block", "$@29", "block_call",
- "method_call", "brace_block", "@30", "@31", "case_body", "cases",
+ "stmts", "stmt", "$@3", "rassign", "command_asgn", "command_rhs", "expr",
+ "defn_head", "defs_head", "$@4", "expr_value", "command_call",
+ "block_command", "cmd_brace_block", "$@5", "command", "mlhs",
+ "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_list", "mlhs_post",
+ "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym", "undef_list",
+ "$@6", "op", "reswords", "arg", "aref_args", "arg_rhs", "paren_args",
+ "opt_paren_args", "opt_call_args", "call_args", "command_args", "@7",
+ "block_arg", "opt_block_arg", "comma", "args", "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", "$@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", "@32", "xstring",
+ "string_fragment", "string_rep", "string_interp", "@29", "xstring",
"regexp", "heredoc", "heredoc_bodies", "heredoc_body",
- "heredoc_string_rep", "heredoc_string_interp", "@33", "words", "symbol",
+ "heredoc_string_rep", "heredoc_string_interp", "@30", "words", "symbol",
"basic_symbol", "sym", "symbols", "numeric", "variable", "var_lhs",
- "var_ref", "backref", "superclass", "$@34", "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", "@35", "f_arg", "f_opt_asgn", "f_opt",
- "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
+ "var_ref", "backref", "superclass", "$@31", "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", "$@36", "assoc_list", "assocs", "label_tag", "assoc",
+ "singleton", "$@33", "assoc_list", "assocs", "label_tag", "assoc",
"operation", "operation2", "operation3", "dot_or_colon", "call_op",
"call_op2", "opt_terms", "opt_nl", "rparen", "trailer", "term", "nl",
"terms", "none", YY_NULLPTR
@@ -2121,12 +2148,12 @@ static const yytype_int16 yytoknum[] =
};
# endif
-#define YYPACT_NINF (-829)
+#define YYPACT_NINF (-870)
#define yypact_value_is_default(Yyn) \
((Yyn) == YYPACT_NINF)
-#define YYTABLE_NINF (-595)
+#define YYTABLE_NINF (-604)
#define yytable_value_is_error(Yyn) \
((Yyn) == YYTABLE_NINF)
@@ -2135,110 +2162,112 @@ static const yytype_int16 yytoknum[] =
STATE-NUM. */
static const yytype_int16 yypact[] =
{
- -829, 164, 2491, -829, 7022, 8994, 9330, 5100, -829, 8646,
- 8646, -829, -829, 9106, 6520, 4956, 7370, 7370, -829, -829,
- 7370, 2735, 5870, -829, -829, -829, -829, -39, 6520, -829,
- 36, -829, -829, -829, 5240, 5380, -829, -829, 5520, -829,
- -829, -829, -829, -829, -829, -829, 20, 8762, 8762, 129,
- 4227, 1481, 7602, 7950, 6798, -829, 6242, 614, 927, 1024,
- 1126, 839, -829, 410, 8878, 8762, -829, 852, -829, 1251,
- -829, 448, -829, -829, 166, 171, -829, 80, 9218, -829,
- 198, 11318, 299, 402, 21, 59, -829, 354, -829, -829,
- -829, -829, -829, -829, -829, -829, -829, 203, 165, -829,
- 340, 137, -829, -829, -829, -829, -829, 159, 159, 177,
- 72, 552, -829, 8646, 99, 4344, 607, -829, 200, -829,
- 494, -829, -829, 137, -829, -829, -829, -829, -829, -829,
- -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
- -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
- -829, -829, 33, 44, 47, 101, -829, -829, -829, -829,
- -829, -829, 170, 218, 219, 227, -829, 229, -829, -829,
- -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
- -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
- -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
- -829, -829, -829, 240, 3417, 270, 448, 83, 225, 526,
- 61, 247, 86, 83, 8646, 8646, 539, 306, -829, -829,
- 609, 329, 95, 110, -829, -829, -829, -829, -829, -829,
- -829, -829, -829, 6381, -829, -829, 253, -829, -829, -829,
- -829, -829, -829, 852, -829, 264, -829, 386, -829, -829,
- 852, 2601, 8762, 8762, 8762, 8762, -829, 11297, -829, -829,
- 271, 361, 271, -829, -829, -829, 7138, -829, -829, -829,
- 7370, -829, -829, -829, 4956, 8646, -829, -829, 286, 4461,
- -829, 796, 355, 398, 7254, 4227, 302, 852, 1251, 852,
- 323, -829, 7254, 852, 325, 1517, 1517, -829, 11297, 316,
- 1517, -829, 421, 9442, 370, 798, 826, 859, 1597, -829,
- -829, -829, -829, 1166, -829, -829, -829, -829, -829, -829,
- 679, 749, -829, -829, 1186, -829, 1195, -829, 1257, -829,
- 860, 444, 446, -829, -829, -829, -829, 4722, 8646, 8646,
- 8646, 8646, 7254, 8646, 8646, -829, -829, 8066, -829, 4227,
- 6910, 392, 8066, 8762, 8762, 8762, 8762, 8762, 8762, 8762,
- 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762,
- 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762, 9714,
- -829, 7370, -829, 9798, -829, -829, 10974, -829, -829, -829,
- -829, 8878, 8878, -829, 428, -829, 448, -829, 961, -829,
- -829, -829, -829, -829, 9882, 7370, 9966, 3417, 8646, -829,
- -829, -829, -829, 522, 528, 149, -829, 3561, 533, 8762,
- 10050, 7370, 10134, 8762, 8762, 3849, 126, 126, 113, 10218,
- 7370, 10302, -829, 501, -829, 4461, 386, -829, -829, 8182,
- 542, -829, 679, 8762, 11318, 11318, 11318, 8762, 476, -829,
- 7486, -829, 8762, -829, 7718, 852, 425, 852, 271, 271,
- -829, -829, 745, 431, -829, -829, 6520, 3966, 443, 10050,
- 10134, 8762, 1251, 852, -829, -829, 4839, 445, 1251, -829,
- -829, 7834, -829, 852, 7950, -829, -829, -829, 961, 80,
- 9442, -829, 9442, 10386, 7370, 10470, 30, -829, -829, -829,
- -829, -829, -829, -829, -829, -829, -829, -829, -829, 1719,
- -829, 8762, -829, 451, 554, 472, -829, -829, -829, -829,
- -829, 479, 8762, -829, 497, 596, 511, 608, -829, -829,
- 1283, 4461, 679, -829, -829, -829, -829, -829, -829, -829,
- 8762, 8762, -829, -829, -829, -829, -829, -829, -829, -829,
- 153, 8762, -829, 11121, 271, -829, 852, 9442, 532, -829,
- -829, -829, 570, 572, 2302, -829, -829, 976, 180, 355,
- 2331, 2331, 2331, 2331, 1479, 1479, 11455, 11395, 2331, 2331,
- 11378, 11378, 671, 671, 11061, 1479, 1479, 1462, 1462, 1490,
- 175, 175, 355, 355, 355, 2869, 5986, 3137, 6102, -829,
- 159, -829, 550, 437, -829, 563, -829, -829, 5870, -829,
- -829, 2061, 153, 153, -829, 11044, -829, -829, -829, -829,
- -829, 852, 8646, 3417, 736, 813, -829, 159, 560, 159,
- 699, 745, 1650, 6659, -829, 8298, 706, -829, 690, -829,
- 5636, 5753, 605, 268, 276, 706, -829, -829, -829, -829,
- 79, 88, 613, 121, 140, 8646, 6520, 616, 740, 11318,
- 450, -829, 679, 11318, 11318, 679, 8762, 11297, -829, 271,
- 11318, -829, -829, -829, -829, 7486, 7718, -829, -829, -829,
- 623, -829, -829, 136, 1251, 852, 1517, 392, -829, 736,
- 813, 626, 959, 1023, -829, -829, 1123, 622, 77, 11318,
- 768, -829, -829, -829, 201, -829, 1719, -829, 11318, 1719,
- -829, -829, 1907, -829, -829, -829, 637, -829, 355, 355,
- -829, 1719, 3417, -829, -829, 11140, 8414, -829, -829, 9442,
- 7254, 8878, 8762, 10554, 7370, 10638, 70, 8878, 8878, -829,
- 428, 672, 8878, 8878, -829, 428, 59, 166, 3417, 4461,
- 153, -829, 852, 762, -829, -829, -829, 1826, 3417, 852,
- -829, 11121, -829, 689, -829, 4110, 774, -829, 8646, 779,
- -829, 8762, 8762, 358, 8762, 8762, 800, 4605, 4605, 156,
- 126, -829, -829, -829, 8530, 3705, 679, 11318, -829, 271,
- -829, -829, -829, 192, -829, 104, 852, 676, 674, 678,
- 3417, 4461, -829, 766, -829, 472, -829, -829, -829, 684,
- 686, 687, -829, 691, 766, 687, -829, -829, 622, 622,
- 9554, -829, 694, 472, 695, 9554, -829, 698, 701, -829,
- 835, 8762, 11209, -829, -829, 11318, 3003, 3271, 712, 408,
- 432, 8762, 8762, -829, -829, -829, -829, -829, 8878, -829,
- -829, -829, -829, -829, -829, -829, 840, 722, 4461, 3417,
- -829, -829, 852, 852, 845, -829, 1650, 9666, 83, -829,
- -829, 4605, -829, -829, 83, -829, 8762, -829, 855, 856,
- -829, 11318, 193, 7718, -829, 733, -829, 1530, -829, 680,
- 868, 753, -829, 1719, -829, 1907, -829, 1907, -829, 1907,
- -829, -829, 769, 771, 837, 995, 768, -829, -829, 1282,
- -829, 995, 1719, -829, 1907, -829, -829, 11228, 439, 11318,
- 11318, -829, -829, -829, -829, 761, 896, -829, -829, -829,
- 3417, 862, -829, 1028, 826, 859, 3417, -829, 3561, -829,
- -829, 4605, -829, -829, -829, 1585, 1585, 547, -829, 22,
- -829, -829, -829, -829, 687, 778, 687, 687, -829, -829,
- -829, 10722, -829, 472, 768, -829, -829, 780, 792, 793,
- -829, 799, 793, -829, -829, 913, 961, 10806, 7370, 10890,
- 528, 690, 935, 812, 812, 1585, 823, 680, -829, -829,
- 1907, -829, -829, -829, 824, 828, -829, 1719, -829, 1907,
- -829, 1907, -829, 1907, -829, -829, -829, 736, 813, 834,
- 357, 579, -829, -829, -829, 1585, 812, 1585, -829, 687,
- 793, 842, 793, 793, 192, 812, -829, -829, 1907, -829,
- -829, -829, 793, -829
+ -870, 123, 2747, -870, 7459, 9431, 9767, 5537, -870, 9083,
+ 9083, -870, -870, 9543, 6957, 5393, 7807, 7807, -870, -870,
+ 7807, 3172, 6307, -870, -870, -870, -870, 127, 6957, -870,
+ 78, -870, -870, -870, 5677, 5817, -870, -870, 5957, -870,
+ -870, -870, -870, -870, -870, -870, 30, 9199, 9199, 95,
+ 4664, 906, 8039, 8387, 7235, -870, 6679, 1068, 1316, 1360,
+ 1376, 695, -870, 125, 9315, 9199, -870, 1474, -870, 1634,
+ 60, -870, 75, 1663, 1663, -870, -870, 163, 87, -870,
+ 34, 9655, -870, 114, 11676, 197, 488, 260, 39, -870,
+ 322, -870, -870, -870, -870, -870, -870, -870, -870, -870,
+ 38, 204, -870, 241, 22, -870, -870, -870, -870, -870,
+ 94, 94, 155, 275, 998, -870, 9083, 263, 4781, 161,
+ 1663, 1663, -870, 180, -870, 626, -870, -870, 22, -870,
+ -870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
+ -870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
+ -870, -870, -870, -870, -870, -870, -870, 70, 109, 134,
+ 138, -870, -870, -870, -870, -870, -870, 146, 171, 189,
+ 201, -870, 205, -870, -870, -870, -870, -870, -870, -870,
+ -870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
+ -870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
+ -870, -870, -870, -870, -870, -870, -870, -870, 221, 3854,
+ 256, 75, 546, 207, 11757, 662, 102, 252, 250, 546,
+ 9083, 9083, 823, 292, -870, -870, 866, 337, 542, 643,
+ -870, -870, -870, -870, -870, -870, -870, -870, -870, 6818,
+ -870, -870, 236, -870, -870, -870, -870, -870, -870, 1474,
+ -870, 483, -870, 363, -870, -870, 1474, 3038, 9199, 9199,
+ 9199, 9199, -870, 11736, -870, -870, 259, 349, 259, -870,
+ -870, -870, 7575, -870, -870, -870, 7807, -870, -870, -870,
+ 5393, 9083, -870, -870, 272, 4898, -870, 902, 344, 305,
+ 7691, 4664, 279, 1474, 1634, 1474, 310, -870, 7691, 1474,
+ 316, 1341, 1341, -870, 11736, 289, 1341, -870, 391, 9879,
+ 325, 936, 999, 1050, 1903, -870, -870, -870, -870, 1382,
+ -870, -870, -870, -870, -870, -870, 498, 1322, -870, -870,
+ 1398, -870, 1451, -870, 1460, -870, 836, 399, 417, -870,
+ -870, -870, -870, 5159, 9083, 9083, 9083, 9083, 7691, 9543,
+ 9083, 9083, 54, -870, -870, -870, -870, -870, -870, -870,
+ -870, -870, -870, -870, -870, 2024, 378, 3854, 9199, -870,
+ 370, 452, 384, -870, 1474, -870, -870, -870, 386, 9199,
+ -870, 407, 467, 408, 504, -870, 430, 3854, -870, -870,
+ 8503, -870, 4664, 7347, 432, 8503, 9199, 9199, 9199, 9199,
+ 9199, 9199, 9199, 9199, 9199, 9199, 9199, 9199, 9199, 9199,
+ 9199, 9543, 9199, 9199, 9199, 9199, 9199, 9199, 9199, 9199,
+ 9199, 9199, 9199, 1804, -870, 7807, -870, 10151, -870, -870,
+ 11327, -870, -870, -870, -870, 9315, 9315, -870, 459, -870,
+ 75, -870, 1169, -870, -870, -870, -870, -870, -870, 10235,
+ 7807, 10319, 3854, 9083, -870, -870, -870, 555, 561, 295,
+ -870, 3998, 562, 9199, 10403, 7807, 10487, 9199, 9199, 4286,
+ 88, 88, 827, 10571, 7807, 10655, -870, 517, -870, 4898,
+ 363, -870, -870, 8619, 569, -870, 498, 9199, 11757, 11757,
+ 11757, 9199, 710, -870, 7923, -870, 9199, -870, 8155, 1474,
+ 443, 1474, 259, 259, -870, -870, 64, 445, -870, -870,
+ 6957, 4403, 455, 10403, 10487, 9199, 1634, 1474, -870, -870,
+ 5276, 449, 1634, -870, -870, 8271, -870, 1474, 8387, -870,
+ -870, -870, 1169, 34, 9879, -870, 9879, 10739, 7807, 10823,
+ 1771, -870, -870, -870, 1539, 4898, 498, -870, -870, -870,
+ -870, -870, -870, -870, 9199, 9199, -870, -870, -870, -870,
+ -870, -870, -870, -870, -870, -870, -870, -870, 1724, 1474,
+ 1474, 9199, 586, 11757, 139, -870, -870, -870, 145, -870,
+ -870, 1771, -870, 11757, 1771, -870, -870, 1417, -870, -870,
+ 9199, 591, 48, 9199, -870, 11500, 259, -870, 1474, 9879,
+ 478, -870, -870, -870, 581, 515, 2373, -870, -870, 1180,
+ 321, 344, 2795, 2795, 2795, 2795, 1483, 1483, 11817, 2139,
+ 2795, 2795, 2250, 2250, 511, 511, -870, -870, 11475, 1483,
+ 1483, 981, 981, 1377, 178, 178, 344, 344, 344, 3306,
+ 6423, 3574, 6539, -870, 94, -870, 507, 334, -870, 366,
+ -870, -870, 6307, -870, -870, 1624, 48, 48, -870, 2860,
+ -870, -870, -870, -870, -870, 1474, 9083, 3854, 1191, 100,
+ -870, 94, 508, 94, 633, 64, 7096, -870, 8735, 640,
+ -870, 208, -870, 6073, 6190, 521, 351, 439, 640, -870,
+ -870, -870, -870, 1148, 113, 522, 1227, 1261, 9083, 6957,
+ 528, 654, 11757, 601, -870, 498, 11757, 11757, 498, 9199,
+ 11736, -870, 259, 11757, -870, -870, -870, -870, 7923, 8155,
+ -870, -870, -870, 533, -870, -870, 90, 1634, 1474, 1341,
+ 432, -870, 1191, 100, 534, 1209, 1306, 532, 81, -870,
+ 548, -870, 344, 344, -870, 834, 1474, 543, -870, -870,
+ 11397, -870, 631, -870, 384, -870, -870, -870, 554, 556,
+ 558, -870, 559, 631, 558, 11415, -870, -870, 1771, 3854,
+ -870, -870, 11569, 8851, -870, -870, 9879, 7691, 9315, 9199,
+ 10907, 7807, 10991, 61, 9315, 9315, -870, 459, 414, 9315,
+ 9315, -870, 459, 39, 163, 3854, 4898, 48, -870, 1474,
+ 687, -870, -870, -870, -870, 11500, -870, 613, -870, 4547,
+ 698, -870, 9083, 705, -870, 9199, 9199, 441, 9199, 9199,
+ 707, 5042, 5042, 722, 88, -870, -870, -870, 8967, 4142,
+ 498, 11757, -870, 259, -870, -870, -870, 732, 583, 580,
+ 3854, 4898, -870, -870, -870, 587, -870, 1746, 9199, -870,
+ 1771, -870, 1417, -870, 1417, -870, 1417, -870, -870, 9199,
+ -870, 532, 532, 9991, -870, 590, 384, 598, 9991, -870,
+ 600, 604, -870, 734, 9199, 11588, -870, -870, 11757, 3440,
+ 3708, 611, 460, 474, 9199, 9199, -870, -870, -870, -870,
+ -870, 9315, -870, -870, -870, -870, -870, -870, -870, 738,
+ 617, 4898, 3854, -870, -870, 10103, 546, -870, -870, 5042,
+ -870, -870, 546, -870, 9199, -870, 748, 752, -870, 11757,
+ 112, 8155, -870, 1287, 755, 635, 1210, 1210, 1010, 11757,
+ 558, 636, 558, 558, 11757, 658, 663, 735, 1221, 139,
+ -870, -870, 1580, -870, 1221, 1771, -870, 1417, -870, -870,
+ 11657, 475, 11757, 11757, -870, -870, -870, -870, 657, 786,
+ 761, -870, 1272, 999, 1050, 3854, -870, 3998, -870, -870,
+ 5042, -870, -870, -870, -870, 14, -870, -870, -870, -870,
+ 679, 679, 1210, 688, -870, 1417, -870, -870, -870, -870,
+ -870, -870, 11075, -870, 384, 139, -870, -870, 692, 693,
+ 694, -870, 696, 694, -870, -870, 1169, 11159, 7807, 11243,
+ 561, 208, 826, 1287, -870, 1210, 679, 1210, 558, 700,
+ 708, -870, 1771, -870, 1417, -870, 1417, -870, 1417, -870,
+ -870, 1191, 100, 699, 1043, 1087, -870, -870, -870, -870,
+ 679, -870, 694, 712, 694, 694, 732, -870, 1417, -870,
+ -870, -870, 694, -870
};
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -2246,156 +2275,158 @@ static const yytype_int16 yypact[] =
means the default is an error. */
static const yytype_int16 yydefact[] =
{
- 2, 0, 0, 1, 0, 0, 0, 0, 276, 0,
- 0, 300, 303, 0, 0, 580, 324, 325, 326, 327,
- 288, 253, 400, 475, 474, 476, 477, 582, 0, 10,
- 0, 479, 478, 480, 466, 275, 468, 467, 470, 469,
- 462, 463, 424, 425, 481, 482, 274, 0, 0, 0,
- 0, 278, 594, 594, 80, 295, 0, 0, 0, 0,
- 0, 0, 439, 0, 0, 0, 3, 580, 6, 9,
- 27, 32, 44, 52, 51, 0, 68, 0, 72, 82,
- 0, 49, 232, 0, 53, 293, 267, 268, 422, 269,
- 270, 271, 420, 419, 451, 421, 418, 473, 0, 272,
- 273, 253, 5, 8, 324, 325, 288, 594, 400, 0,
- 105, 106, 274, 0, 0, 0, 0, 108, 483, 328,
- 0, 473, 273, 0, 316, 160, 170, 161, 157, 186,
- 187, 188, 189, 168, 183, 176, 166, 165, 181, 164,
- 163, 159, 184, 158, 171, 175, 177, 169, 162, 178,
- 185, 180, 179, 172, 182, 167, 156, 174, 173, 155,
- 153, 154, 150, 151, 152, 110, 112, 111, 145, 146,
- 141, 123, 124, 125, 132, 129, 131, 126, 127, 147,
- 148, 133, 134, 138, 142, 128, 130, 120, 121, 122,
- 135, 136, 137, 139, 140, 143, 144, 149, 552, 318,
- 113, 114, 551, 0, 0, 0, 50, 0, 0, 0,
- 473, 0, 273, 0, 0, 0, 104, 0, 339, 338,
- 0, 0, 473, 273, 179, 172, 182, 167, 150, 151,
- 152, 110, 111, 0, 115, 117, 20, 116, 442, 447,
- 446, 588, 591, 580, 590, 0, 444, 0, 592, 589,
- 581, 564, 0, 0, 0, 0, 248, 260, 66, 252,
- 594, 422, 594, 556, 67, 65, 594, 242, 289, 64,
- 0, 241, 399, 63, 580, 0, 583, 18, 0, 0,
- 209, 0, 210, 285, 0, 0, 0, 580, 15, 580,
- 70, 14, 0, 580, 0, 585, 585, 233, 0, 0,
- 585, 554, 0, 0, 78, 0, 88, 95, 522, 456,
- 455, 457, 458, 0, 454, 453, 437, 431, 430, 433,
- 0, 0, 428, 449, 0, 460, 0, 426, 0, 435,
- 0, 464, 465, 48, 224, 225, 4, 581, 0, 0,
- 0, 0, 0, 0, 0, 387, 389, 0, 84, 0,
- 76, 73, 0, 0, 0, 0, 0, 0, 0, 0,
+ 2, 0, 0, 1, 0, 0, 0, 0, 288, 0,
+ 0, 312, 315, 0, 0, 589, 332, 333, 334, 335,
+ 300, 265, 408, 483, 482, 484, 485, 591, 0, 10,
+ 0, 487, 486, 488, 474, 287, 476, 475, 478, 477,
+ 470, 471, 432, 433, 489, 490, 286, 0, 0, 0,
+ 0, 290, 603, 603, 88, 307, 0, 0, 0, 0,
+ 0, 0, 447, 0, 0, 0, 3, 589, 6, 9,
+ 32, 27, 33, 531, 531, 49, 60, 59, 0, 76,
+ 0, 80, 90, 0, 54, 244, 0, 61, 305, 279,
+ 280, 430, 281, 282, 283, 428, 427, 459, 429, 426,
+ 481, 0, 284, 285, 265, 5, 8, 332, 333, 300,
+ 603, 408, 0, 113, 114, 286, 0, 0, 0, 0,
+ 531, 531, 116, 491, 336, 0, 481, 285, 0, 328,
+ 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, 190,
+ 175, 164, 182, 181, 163, 161, 162, 158, 159, 160,
+ 118, 120, 119, 153, 154, 149, 131, 132, 133, 140,
+ 137, 139, 134, 135, 155, 156, 141, 142, 146, 150,
+ 136, 138, 128, 129, 130, 143, 144, 145, 147, 148,
+ 151, 152, 157, 561, 55, 121, 122, 560, 0, 0,
+ 0, 58, 0, 0, 54, 0, 481, 0, 285, 0,
+ 0, 0, 112, 0, 347, 346, 0, 0, 104, 111,
+ 187, 180, 190, 175, 158, 159, 160, 118, 119, 0,
+ 123, 125, 20, 124, 450, 455, 454, 597, 600, 589,
+ 599, 0, 452, 0, 601, 598, 590, 573, 0, 0,
+ 0, 0, 260, 272, 74, 264, 603, 430, 603, 565,
+ 75, 73, 603, 254, 301, 72, 0, 253, 407, 71,
+ 589, 0, 592, 18, 0, 0, 217, 0, 218, 297,
+ 0, 0, 0, 589, 15, 589, 78, 14, 0, 589,
+ 0, 594, 594, 245, 0, 0, 594, 563, 0, 0,
+ 86, 0, 96, 103, 531, 464, 463, 465, 466, 0,
+ 462, 461, 445, 439, 438, 441, 0, 0, 436, 457,
+ 0, 468, 0, 434, 0, 443, 0, 472, 473, 53,
+ 232, 233, 4, 590, 0, 0, 0, 0, 0, 0,
+ 0, 0, 538, 534, 533, 532, 535, 536, 507, 540,
+ 552, 508, 556, 555, 551, 531, 496, 0, 500, 505,
+ 603, 510, 603, 530, 0, 537, 539, 542, 516, 0,
+ 549, 516, 554, 516, 0, 514, 496, 0, 395, 397,
+ 0, 92, 0, 84, 81, 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,
- 577, 594, 576, 0, 579, 578, 0, 404, 402, 294,
- 423, 0, 0, 393, 57, 292, 313, 105, 106, 107,
- 464, 465, 484, 311, 0, 594, 0, 0, 0, 319,
- 575, 574, 321, 0, 594, 285, 330, 0, 329, 0,
- 0, 594, 0, 0, 0, 0, 0, 0, 285, 0,
- 594, 0, 308, 0, 118, 0, 0, 443, 445, 0,
- 0, 593, 558, 0, 261, 563, 255, 0, 258, 249,
- 0, 257, 0, 250, 0, 580, 0, 580, 594, 594,
- 243, 254, 580, 0, 291, 47, 0, 0, 0, 0,
- 0, 0, 17, 580, 283, 13, 581, 69, 279, 282,
- 286, 587, 234, 586, 587, 236, 287, 555, 94, 86,
- 0, 81, 0, 0, 594, 0, 529, 525, 524, 523,
- 526, 527, 498, 531, 543, 499, 547, 546, 542, 522,
- 296, 491, 496, 594, 501, 594, 521, 384, 528, 530,
- 533, 507, 0, 540, 507, 545, 507, 0, 505, 459,
- 0, 0, 434, 440, 438, 429, 450, 461, 427, 436,
- 0, 0, 7, 21, 22, 23, 24, 25, 45, 46,
- 594, 0, 28, 30, 0, 31, 580, 0, 74, 85,
- 43, 33, 41, 0, 237, 190, 29, 0, 273, 206,
- 214, 219, 220, 221, 216, 218, 228, 229, 222, 223,
- 199, 200, 226, 227, 582, 215, 217, 211, 212, 213,
- 201, 202, 203, 204, 205, 567, 572, 568, 573, 398,
- 253, 396, 0, 567, 569, 568, 570, 397, 594, 567,
- 568, 253, 594, 594, 34, 237, 191, 40, 198, 55,
- 58, 0, 0, 0, 105, 106, 109, 0, 0, 594,
- 0, 580, 522, 0, 277, 594, 594, 410, 594, 331,
- 571, 284, 0, 567, 568, 594, 333, 301, 332, 304,
- 571, 284, 0, 567, 568, 0, 0, 0, 0, 260,
- 0, 307, 559, 561, 560, 0, 0, 262, 256, 594,
- 562, 557, 240, 239, 244, 245, 247, 290, 584, 19,
- 0, 26, 197, 71, 16, 580, 585, 87, 79, 91,
- 93, 0, 90, 92, 489, 535, 0, 582, 0, 490,
- 0, 503, 550, 500, 0, 504, 0, 514, 536, 0,
- 517, 544, 0, 519, 548, 452, 0, 441, 207, 208,
- 375, 373, 0, 372, 371, 266, 0, 83, 77, 0,
- 0, 0, 0, 0, 594, 0, 0, 0, 0, 395,
- 61, 401, 0, 0, 394, 59, 390, 54, 0, 0,
- 594, 314, 0, 0, 401, 317, 553, 522, 0, 0,
- 322, 411, 412, 594, 413, 0, 594, 336, 0, 0,
- 334, 0, 0, 401, 0, 0, 0, 0, 0, 401,
- 0, 119, 448, 306, 0, 0, 259, 263, 251, 594,
- 11, 280, 235, 89, 529, 347, 580, 340, 0, 377,
- 0, 0, 297, 0, 497, 594, 549, 506, 534, 507,
- 507, 507, 541, 507, 529, 507, 432, 370, 582, 582,
- 493, 494, 594, 594, 355, 0, 538, 355, 355, 353,
- 0, 0, 264, 75, 42, 238, 567, 568, 0, 567,
- 568, 0, 0, 39, 195, 38, 196, 62, 0, 36,
- 193, 37, 194, 60, 391, 392, 0, 0, 0, 0,
- 485, 312, 580, 580, 0, 488, 522, 0, 0, 415,
- 337, 0, 12, 417, 0, 298, 0, 299, 0, 0,
- 309, 262, 594, 246, 348, 345, 532, 0, 383, 0,
- 0, 0, 502, 0, 510, 0, 512, 0, 518, 0,
- 515, 520, 0, 0, 0, 492, 0, 351, 352, 355,
- 363, 537, 0, 366, 0, 368, 388, 265, 401, 231,
- 230, 35, 192, 405, 403, 0, 0, 487, 486, 320,
- 0, 0, 414, 0, 96, 103, 0, 416, 0, 302,
- 305, 0, 407, 408, 406, 0, 0, 343, 381, 582,
- 379, 382, 386, 385, 507, 507, 507, 507, 376, 374,
- 285, 0, 495, 594, 0, 354, 361, 355, 355, 355,
- 539, 355, 355, 56, 315, 0, 102, 0, 594, 0,
- 594, 594, 0, 349, 346, 0, 341, 0, 378, 511,
- 0, 508, 513, 516, 571, 284, 350, 0, 358, 0,
- 360, 0, 367, 0, 364, 369, 323, 99, 101, 0,
- 567, 568, 409, 335, 310, 0, 344, 0, 380, 507,
- 355, 355, 355, 355, 97, 342, 509, 359, 0, 356,
- 362, 365, 355, 357
+ 0, 0, 0, 0, 586, 603, 585, 0, 588, 587,
+ 0, 412, 410, 306, 431, 0, 0, 401, 65, 304,
+ 325, 113, 114, 115, 472, 473, 496, 492, 323, 0,
+ 603, 0, 0, 0, 584, 583, 56, 0, 603, 297,
+ 338, 0, 337, 0, 0, 603, 0, 0, 0, 0,
+ 0, 0, 110, 0, 603, 0, 320, 0, 126, 0,
+ 0, 451, 453, 0, 0, 602, 567, 0, 273, 572,
+ 267, 0, 270, 261, 0, 269, 0, 262, 0, 589,
+ 0, 589, 603, 603, 255, 266, 589, 0, 303, 52,
+ 0, 0, 0, 0, 0, 0, 17, 589, 295, 13,
+ 590, 77, 291, 294, 298, 596, 246, 595, 596, 248,
+ 299, 564, 102, 94, 0, 89, 0, 0, 603, 0,
+ 531, 308, 392, 467, 0, 0, 442, 448, 446, 437,
+ 458, 469, 435, 444, 0, 0, 7, 21, 22, 23,
+ 24, 25, 37, 36, 50, 51, 498, 544, 0, 589,
+ 589, 0, 0, 499, 0, 512, 559, 509, 0, 513,
+ 497, 0, 523, 545, 0, 526, 553, 0, 528, 557,
+ 0, 0, 603, 0, 28, 30, 0, 31, 589, 0,
+ 82, 93, 48, 38, 46, 0, 249, 198, 29, 0,
+ 285, 214, 222, 227, 228, 229, 224, 226, 236, 237,
+ 230, 231, 207, 208, 234, 235, 35, 34, 591, 223,
+ 225, 219, 220, 221, 209, 210, 211, 212, 213, 576,
+ 581, 577, 582, 406, 265, 404, 0, 576, 578, 577,
+ 579, 405, 603, 576, 577, 265, 603, 603, 39, 249,
+ 199, 45, 206, 63, 66, 0, 0, 0, 113, 114,
+ 117, 0, 0, 603, 0, 589, 0, 289, 603, 603,
+ 418, 603, 339, 580, 296, 0, 576, 577, 603, 341,
+ 313, 340, 316, 107, 109, 0, 106, 108, 0, 0,
+ 0, 0, 272, 0, 319, 568, 570, 569, 0, 0,
+ 274, 268, 603, 571, 566, 252, 251, 256, 257, 259,
+ 302, 593, 19, 0, 26, 205, 79, 16, 589, 594,
+ 95, 87, 99, 101, 0, 98, 100, 591, 0, 460,
+ 0, 449, 215, 216, 538, 355, 589, 348, 495, 494,
+ 240, 330, 0, 506, 603, 558, 515, 543, 516, 516,
+ 516, 550, 516, 538, 516, 242, 331, 383, 381, 0,
+ 380, 379, 278, 0, 91, 85, 0, 0, 0, 0,
+ 0, 603, 0, 0, 0, 0, 403, 69, 409, 0,
+ 0, 402, 67, 398, 62, 0, 0, 603, 326, 0,
+ 0, 409, 329, 562, 57, 419, 420, 603, 421, 0,
+ 603, 344, 0, 0, 342, 0, 0, 409, 0, 0,
+ 0, 0, 0, 105, 0, 127, 456, 318, 0, 0,
+ 271, 275, 263, 603, 11, 292, 247, 97, 0, 385,
+ 0, 0, 309, 440, 356, 353, 541, 0, 0, 511,
+ 0, 519, 0, 521, 0, 527, 0, 524, 529, 0,
+ 378, 591, 591, 502, 503, 603, 603, 363, 0, 547,
+ 363, 363, 361, 0, 0, 276, 83, 47, 250, 576,
+ 577, 0, 576, 577, 0, 0, 44, 203, 43, 204,
+ 70, 0, 41, 201, 42, 202, 68, 399, 400, 0,
+ 0, 0, 0, 493, 324, 0, 0, 423, 345, 0,
+ 12, 425, 0, 310, 0, 311, 0, 0, 321, 274,
+ 603, 258, 391, 0, 0, 0, 0, 0, 351, 241,
+ 516, 516, 516, 516, 243, 0, 0, 0, 501, 0,
+ 359, 360, 363, 371, 546, 0, 374, 0, 376, 396,
+ 277, 409, 239, 238, 40, 200, 413, 411, 0, 0,
+ 0, 422, 0, 104, 111, 0, 424, 0, 314, 317,
+ 0, 415, 416, 414, 389, 591, 387, 390, 394, 393,
+ 357, 354, 0, 349, 520, 0, 517, 522, 525, 384,
+ 382, 297, 0, 504, 603, 0, 362, 369, 363, 363,
+ 363, 548, 363, 363, 64, 327, 110, 0, 603, 0,
+ 603, 603, 0, 0, 386, 0, 352, 0, 516, 580,
+ 296, 358, 0, 366, 0, 368, 0, 375, 0, 372,
+ 377, 107, 109, 0, 576, 577, 417, 343, 322, 388,
+ 350, 518, 363, 363, 363, 363, 105, 367, 0, 364,
+ 370, 373, 363, 365
};
/* YYPGOTO[NTERM-NUM]. */
static const yytype_int16 yypgoto[] =
{
- -829, -829, -829, 510, -829, 32, -829, -214, 182, -829,
- 28, -829, -155, -302, 867, 1, -16, -829, -536, -829,
- 131, 971, -170, 4, -69, -266, -431, -15, 1295, -48,
- 981, 19, 5, -829, -829, 24, -829, 653, -829, 413,
- 75, -58, -352, 54, 13, -829, -390, -235, -11, 39,
- -303, 89, -829, -829, -829, -829, -829, -829, -829, -829,
- -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
- -829, -829, 8, -206, -382, 7, -568, -829, -829, -829,
- 272, 538, -829, -512, -829, -829, -78, -829, 2, -829,
- -829, 255, -829, -829, -829, -65, -829, -829, -430, -829,
- 14, -829, -829, -829, -829, -829, 154, 58, -196, -829,
- -829, -829, -829, -377, -257, -829, 787, -829, -829, -829,
- -6, -829, -829, -829, 1461, 1552, 1026, 1065, -829, -829,
- 173, 314, 343, 141, -829, -829, -829, 524, -306, 246,
- -307, -801, -716, -519, -829, 474, -664, -627, -828, 142,
- 346, -829, 236, -829, 517, -439, -829, -829, -829, 92,
- 785, -411, 505, -339, -829, -829, -80, -829, 26, -22,
- -152, -254, 788, -12, -33, -2
+ -870, -870, -870, 342, -870, 37, -870, -62, 106, -870,
+ 41, -870, -870, -154, -352, 896, 85, 132, -870, 27,
+ 192, -870, -673, -870, -15, 16, -192, 29, -72, -212,
+ -436, -5, 1770, -82, 849, 13, 4, -870, -870, 24,
+ -870, 1132, -870, 307, 84, -224, -289, 131, 12, -870,
+ -406, -229, -181, 57, -341, 323, -870, -870, -870, -870,
+ -870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
+ -870, -870, 8, -215, -463, -136, -624, -870, -870, -870,
+ 111, 164, -870, -575, -870, -870, -469, -870, -133, -870,
+ -870, 92, -870, -870, -870, -85, -870, -870, -454, -870,
+ -129, -870, -870, -870, -870, -870, 43, 83, -165, -870,
+ -870, -870, -870, -433, -201, -870, 641, -870, -870, -870,
+ 2, -870, -870, -870, 1740, 2183, 886, 1575, -870, -870,
+ 421, 66, 287, 320, -41, -870, -870, -870, 280, -27,
+ 239, -248, -816, -684, -524, -870, 228, -746, -548, -869,
+ -38, 326, -870, -506, -870, 273, -345, -870, -870, -870,
+ 51, 647, -442, 593, -296, -870, -870, -80, -870, 55,
+ -12, 274, -262, 425, -16, -34, -2
};
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int16 yydefgoto[] =
{
- -1, 1, 2, 66, 67, 68, 278, 413, 414, 287,
- 288, 466, 70, 561, 71, 207, 72, 73, 620, 750,
- 74, 75, 289, 76, 77, 78, 491, 79, 208, 117,
- 118, 234, 235, 236, 656, 598, 201, 81, 294, 565,
- 599, 268, 456, 457, 269, 270, 259, 449, 484, 458,
- 555, 82, 204, 292, 685, 293, 308, 698, 214, 777,
- 215, 778, 655, 941, 623, 621, 859, 407, 409, 632,
- 633, 866, 281, 417, 647, 769, 770, 221, 796, 945,
- 965, 910, 818, 722, 723, 819, 798, 949, 950, 510,
- 802, 346, 550, 84, 85, 395, 613, 612, 440, 944,
- 636, 763, 868, 872, 86, 87, 88, 321, 322, 531,
- 89, 90, 91, 532, 244, 245, 246, 435, 92, 93,
- 94, 315, 95, 96, 210, 211, 99, 212, 403, 622,
- 758, 511, 512, 821, 822, 513, 514, 515, 807, 707,
- 759, 518, 519, 520, 696, 521, 522, 523, 826, 827,
- 524, 525, 526, 527, 528, 701, 203, 408, 299, 459,
- 443, 263, 123, 627, 601, 412, 406, 386, 463, 799,
- 464, 482, 248, 249, 250, 291
+ -1, 1, 2, 66, 67, 68, 284, 457, 458, 293,
+ 294, 510, 70, 71, 603, 72, 73, 74, 676, 212,
+ 75, 76, 664, 797, 77, 78, 295, 79, 80, 81,
+ 535, 82, 213, 122, 123, 240, 241, 242, 699, 642,
+ 206, 84, 300, 607, 643, 274, 500, 501, 275, 276,
+ 265, 493, 528, 502, 597, 85, 209, 298, 728, 299,
+ 314, 738, 220, 821, 221, 822, 698, 970, 667, 665,
+ 902, 452, 287, 461, 690, 813, 814, 227, 746, 926,
+ 996, 943, 861, 769, 770, 862, 838, 975, 976, 541,
+ 842, 389, 592, 87, 88, 439, 657, 656, 484, 973,
+ 679, 807, 906, 910, 89, 90, 91, 327, 328, 545,
+ 92, 93, 94, 546, 250, 251, 252, 479, 95, 96,
+ 97, 321, 98, 99, 216, 217, 102, 218, 448, 666,
+ 446, 367, 368, 369, 864, 865, 370, 371, 372, 756,
+ 582, 374, 375, 376, 377, 568, 378, 379, 380, 869,
+ 870, 381, 382, 383, 384, 385, 575, 208, 453, 305,
+ 503, 487, 269, 128, 671, 645, 456, 451, 430, 507,
+ 839, 508, 526, 254, 255, 256, 297
};
/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
@@ -2403,456 +2434,488 @@ static const yytype_int16 yydefgoto[] =
number is the opposite. If YYTABLE_NINF, syntax error. */
static const yytype_int16 yytable[] =
{
- 102, 517, 516, 383, 385, 275, 658, 425, 237, 351,
- 83, 213, 83, 120, 120, 276, 243, 209, 209, 271,
- 389, 220, 237, 209, 209, 209, 199, 453, 209, 602,
- 69, 200, 69, 277, 337, 273, 103, 490, 200, 304,
- 600, 247, 485, 671, 608, 649, 487, 611, 333, 566,
- 297, 301, 200, 628, 290, 260, 260, 825, 83, 260,
- 668, 688, 305, 533, 668, 662, 399, 629, 766, 642,
- 258, 264, 209, 671, 265, 314, 705, 776, 652, 885,
- 200, 600, 812, 608, 970, 387, 305, 694, 951, 614,
- 617, 295, 629, 336, 119, 119, 267, 272, -564, 416,
- 748, 749, 119, 274, -99, 271, 800, 242, 262, 262,
- 384, -472, 262, -101, 394, 473, 324, 326, 328, 330,
- -96, 209, -475, 83, 380, 535, 728, 841, 535, 422,
- 535, 629, 535, -474, 535, -103, -476, 477, -102, -104,
- 431, 479, 691, 119, 296, 300, -98, 256, 256, 695,
- 397, 256, -471, 646, 398, 794, 629, 497, 498, 499,
- 500, -466, 987, 387, 3, -100, 382, 119, 242, 970,
- 261, 261, 279, 501, 261, -466, 393, 424, -475, 556,
- -96, -97, 267, 272, 283, 533, 951, 808, 801, -474,
- -477, 842, -476, 630, 345, 388, 238, 560, 393, 239,
- 240, 470, 697, 516, 847, -103, 261, 261, -564, 853,
- -466, 765, 83, 439, -564, 426, 427, -466, -401, -91,
- 348, -567, 209, 209, 453, 495, 490, 241, -93, 242,
- -568, 986, 286, 720, 489, -88, 560, 560, 858, 238,
- 471, 390, 239, 240, 884, 825, -477, 353, 825, 450,
- -95, 454, 314, -94, 476, -69, 391, 200, 451, -479,
- 451, -90, 483, 483, 460, 671, 812, 483, -102, 436,
- 241, 392, 242, 388, 209, 717, -83, 721, 209, 266,
- -92, -401, 209, 209, 481, 668, 668, 83, 786, 290,
- 347, 490, 83, 83, -471, -401, -89, 286, 833, -103,
- 83, 266, 506, 672, 376, 377, 378, -478, -480, 260,
- 677, 305, 472, 475, 942, -479, -466, 352, -470, 274,
- 478, 683, -96, 402, 461, 415, 516, 507, -401, 410,
- -401, 552, 762, 825, 535, 558, 562, -401, 423, 543,
- 544, 545, 546, -88, 419, 83, 209, 209, 209, 209,
- 83, 209, 209, 290, 432, 209, 626, 83, 305, 774,
- 567, 428, 262, -478, -480, 69, 892, 775, 808, 542,
- 547, 530, -466, -98, -470, 562, 562, 437, 808, 460,
- 239, 240, 838, 907, 908, 411, 554, -98, -328, 209,
- 808, 554, 119, 434, 600, -100, 608, 256, 880, 567,
- 567, 256, -328, 460, 727, 717, 439, 606, 533, 753,
- 606, 448, 637, 209, 42, 83, 209, 43, 442, 460,
- 261, 687, 467, 489, 261, 83, 665, 353, 460, 209,
- 606, 392, 792, 83, 788, 843, 276, -328, 209, 119,
- 849, 851, -68, 83, -328, 474, 606, 675, 676, 876,
- 863, 516, 943, 486, 785, 606, 451, 451, 607, -103,
- 237, 468, 60, 490, 480, 102, 416, 286, 331, 332,
- -98, 679, 671, -98, -98, 83, 488, -97, 660, 756,
- -95, 607, 808, 674, 83, 343, 344, 735, 489, 471,
- 200, 379, 460, 668, 606, 69, 808, 607, 305, 742,
- 305, -98, 209, -98, 684, 380, 607, 101, 830, 101,
- 492, 702, 256, 702, 101, 101, 540, -102, 541, 606,
- 101, 101, 101, 743, 996, 101, 619, -98, 742, 717,
- 848, 286, 559, 791, 856, 261, 256, 634, -94, 83,
- 381, 635, 669, 726, 864, 607, 921, 382, 724, 639,
- 744, -100, 256, 746, 788, 101, -98, 661, -97, 261,
- 516, 256, 736, 238, 529, 305, 239, 240, 673, 101,
- 607, 744, 276, 686, 678, 261, 560, -90, -565, 119,
- 681, 119, 560, 404, 261, -83, 890, 560, 560, -582,
- 448, 700, -582, -582, 241, -100, 242, 380, 794, 638,
- 497, 498, 499, 500, 261, 703, 271, 645, 261, 271,
- 724, 724, 704, 740, 730, 420, 501, 657, 101, 706,
- 101, 745, 242, 752, 747, 256, 1009, 271, -274, 380,
- 209, 83, 405, 764, 767, 261, 767, 709, 261, 382,
- 629, -470, -274, 767, 886, 926, 119, 711, 261, 784,
- 237, 712, 760, 483, 743, -470, 780, 200, 454, 714,
- 489, 781, 936, 209, 421, 400, 401, 451, 938, 257,
- 257, 382, 729, 257, 554, 739, 316, -274, 317, 318,
- 200, 854, -100, 267, -274, 276, 267, 985, -565, 741,
- -470, 731, -100, 560, -565, -100, -100, -470, 429, 754,
- 280, 282, 739, -92, 267, 257, 298, 768, 765, 101,
- 927, 928, 380, 716, 755, 562, 975, 334, 335, 101,
- 101, 562, 845, -100, 765, -100, 562, 562, 319, 320,
- 83, 948, 460, 497, 498, 499, 500, 305, 83, 567,
- 902, 903, 209, 353, 773, 567, 209, 430, 724, 501,
- 567, 567, 779, 782, 382, 783, 83, 83, 834, 606,
- 790, 869, -571, 848, 873, 793, 83, 789, 242, 874,
- 710, 101, 713, 83, 816, 101, 209, 861, 883, 101,
- 101, 867, 343, 344, 101, 83, 83, 451, 871, 101,
- 101, -97, 238, 83, 875, 239, 240, 101, 374, 375,
- 376, 377, 378, 702, 616, 618, 276, 276, 83, 83,
- 607, 534, -89, 317, 318, 877, 887, 888, 119, 803,
- 702, 702, 889, 694, 893, -571, 895, 897, 905, 261,
- 261, 899, 562, 911, 906, 909, 616, 618, 912, -571,
- 502, 914, 101, 101, 101, 101, 101, 101, 101, 101,
- 916, 918, 101, 979, 101, 923, 567, 101, 238, 924,
- 929, 239, 240, 319, 320, 256, 83, 83, 505, 506,
- 939, 940, -571, 946, -571, 933, 206, 206, -567, 83,
- 767, -571, 206, 952, 682, 469, 101, 493, 261, 241,
- 953, 242, 960, 958, 507, 959, 101, 101, 973, 380,
- 329, 380, -284, 317, 318, 444, 445, 446, 334, 119,
- 101, 974, 101, 101, 119, -473, -284, 976, 990, 257,
- 997, 539, 101, 257, 317, 318, 101, 988, 1006, -473,
- 101, 857, 999, 1001, 421, 101, 494, 276, 83, 1003,
- 101, 382, 810, 382, 83, 813, 83, 870, -273, 83,
- 1014, -284, 1015, 319, 320, -568, 119, 828, -284, 878,
- 879, 702, -273, 1017, -473, 238, -567, 882, 239, 240,
- -568, -473, 101, 1024, 319, 320, 460, 680, 637, 767,
- 396, 101, 1028, 891, 218, -567, 209, 124, 1013, 1018,
- 323, 317, 318, 817, 1012, 418, 241, -273, 242, 101,
- 553, 418, 855, 606, -273, 564, 569, 570, 571, 572,
- 573, 574, 575, 576, 577, 578, 579, 580, 581, 582,
- 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
- 593, 594, 438, 202, 257, 820, 101, 261, 441, 930,
- 925, 319, 320, 804, 615, 615, 452, 962, -567, -568,
- -285, 967, 809, 937, 607, 894, 896, 898, 257, 900,
- 0, 901, -567, 0, -285, 733, 0, 100, 0, 100,
- 122, 122, 615, 0, 257, 0, 615, 615, 223, 380,
- 0, 206, 206, 257, 961, 0, 0, 325, 317, 318,
- 0, 0, 659, 0, 0, -567, 663, -567, 380, -285,
- 664, -567, 0, 667, -567, 670, -285, 298, 0, 256,
- 0, 0, -568, 0, 734, 100, 0, 977, 980, 307,
- 981, 382, 0, 982, 615, 441, -568, 101, 101, 955,
- 0, 380, 261, 405, 667, 0, 0, 298, 319, 320,
- 382, 462, 465, 307, 0, 968, 0, 257, 971, 0,
- 844, 846, 0, 0, 0, 850, 852, 0, 0, -568,
- 101, -568, 0, 0, 699, -568, 978, 0, -568, 0,
- 797, 0, 0, 382, 794, 708, 497, 498, 499, 500,
- 100, 0, 0, 811, 844, 846, 815, 850, 852, 327,
- 317, 318, 501, 718, 719, 824, 0, 0, 0, 0,
- 989, 991, 992, 993, 725, 206, 206, 206, 206, 0,
- 548, 549, 0, 0, 648, 648, 503, 806, 0, 0,
- 820, 806, 795, 820, 805, 0, 820, 101, 820, 529,
- 317, 318, 0, 1021, 0, 101, 101, 0, 829, 101,
- 319, 320, 101, 101, 0, 823, 0, 101, 101, 536,
- 317, 318, 0, 101, 101, 0, 0, 0, 537, 317,
- 318, 922, 0, 101, 441, 1026, 0, 0, 0, 100,
- 101, 441, 0, 101, 0, 631, 0, 0, 820, 0,
- 319, 320, 101, 101, 0, 0, 0, 0, 761, 922,
- 101, 338, 339, 340, 341, 342, 0, 80, 0, 80,
- 319, 320, 0, 0, 0, 101, 101, 0, 219, 319,
- 320, 820, 0, 820, 0, 820, 0, 820, 0, 787,
- 538, 317, 318, 0, 0, 0, 0, 0, 667, 298,
- 0, 0, 0, 496, 0, 497, 498, 499, 500, 0,
- 0, 0, 820, 0, 100, 80, 715, 317, 318, 100,
- 100, 501, 0, 101, 502, 0, 0, 100, 0, 0,
- 0, 0, 0, 101, 101, 913, 915, 954, 307, 956,
- 0, 319, 320, 957, 0, 503, 101, 0, 0, 832,
- 0, 504, 505, 506, 615, 835, 969, 257, 972, 0,
- 615, 615, 0, 0, 0, 615, 615, 319, 320, 0,
- 0, 0, 100, 0, 0, 0, 0, 100, 507, 751,
- 80, 508, 0, 0, 100, 307, 0, 568, 0, 983,
- 984, 0, 964, 806, 615, 615, 829, 615, 615, 829,
- 963, 829, 0, 823, 0, 101, 823, 881, 823, 0,
- 0, 101, 0, 101, 0, 0, 101, 966, 418, 0,
- 0, 0, 0, 0, 0, 0, 568, 568, 0, 1016,
- 0, 0, 0, 97, 1019, 97, 121, 121, 121, 0,
- 0, 1020, 100, 1022, 222, 0, 0, 1023, 0, 0,
- 0, 829, 100, 101, 917, 0, 0, 0, 823, 206,
- 100, 1025, 0, 0, 919, 920, 0, 0, 0, 80,
- 100, 615, 1032, 0, 0, 998, 1000, 1002, 0, 1004,
- 1005, 97, 0, 0, 829, 306, 829, 0, 829, 0,
- 829, 823, 206, 823, 0, 823, 0, 823, 0, 615,
- 0, 0, 100, 0, 353, 0, 298, 0, 0, 306,
- 860, 100, 0, 0, 0, 829, 0, 865, 0, 366,
- 367, 353, 823, 0, 98, 307, 98, 307, 1027, 1029,
- 1030, 1031, 353, 0, 0, 0, 366, 367, 648, 0,
- 1033, 0, 0, 0, 80, 0, 97, 366, 367, 80,
- 80, 794, 0, 497, 498, 499, 500, 80, 373, 374,
- 375, 376, 377, 378, -281, 0, 100, -281, -281, 501,
- 0, 0, 98, 371, 372, 373, 374, 375, 376, 377,
- 378, 0, 0, 0, 0, 0, 0, 374, 375, 376,
- 377, 378, 307, 503, -281, -281, 0, -281, 0, 947,
- 238, 257, 80, 239, 240, 206, 794, 80, 497, 498,
- 499, 500, 0, 0, 80, 0, 0, 563, 496, 0,
- 497, 498, 499, 500, 501, 0, 418, 448, 0, 0,
- 0, 241, 418, 242, 0, 97, 501, 98, 0, 502,
- 0, 0, 0, 0, 0, 0, 0, 0, 503, 0,
- 0, 0, 0, 0, 0, 0, 563, 563, 100, 0,
- 503, 0, 0, 0, 0, 0, 504, 505, 506, 0,
- 0, 496, 80, 497, 498, 499, 500, 0, 0, 0,
- 0, 0, 80, 0, 0, 0, 0, 0, 0, 501,
- 80, 0, 502, 507, 0, 0, 508, 0, 0, 0,
- 80, 0, 0, 0, 0, 0, 0, 0, 0, 509,
- 97, 0, 0, 503, 0, 97, 97, 0, 0, 504,
- 505, 506, 0, 97, 0, 0, 98, 0, 0, 0,
- 0, 0, 80, 0, 306, 0, 0, 0, 0, 0,
- 496, 80, 497, 498, 499, 500, 507, 0, 0, 508,
- 0, 0, 0, 0, 0, 0, 0, 100, 501, 0,
- 0, 502, 757, 0, 307, 100, 568, 0, 97, 0,
- 0, 0, 568, 97, 0, 0, 0, 568, 568, 0,
- 97, 306, 503, 100, 100, 0, 0, 0, 504, 505,
- 506, 0, 0, 100, 0, 0, 80, 0, 0, 0,
- 100, 98, 0, 0, 0, 0, 98, 98, 0, 0,
- 0, 0, 100, 100, 98, 507, 0, 0, 508, 0,
- 100, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 100, 100, 0, 97, 0,
- 0, 0, 0, 0, 0, 0, 0, 496, 97, 497,
- 498, 499, 500, 0, 0, 122, 97, 0, 0, 98,
- 122, 0, 0, 0, 98, 501, 97, 0, 502, 0,
- 0, 98, 0, 0, 98, 0, 0, 0, 0, 0,
- 862, 0, 0, 568, 0, 0, 0, 0, 80, 503,
- 0, 0, 0, 100, 100, 504, 505, 506, 97, 0,
- 0, 0, 935, 0, 0, 0, 100, 97, 0, 0,
- 0, 0, 0, 98, 98, 0, 0, 0, 0, 0,
- 0, 306, 507, 306, 0, 508, 0, 0, 814, 98,
- 497, 498, 499, 500, 0, 0, 0, 0, 0, 98,
- 0, 0, 0, 0, 0, 0, 501, 98, 0, 502,
- 0, 0, 0, 0, 0, 0, 0, 98, 0, 0,
- 0, 0, 97, 0, 0, 100, 0, 0, 0, 0,
- 503, 100, 0, 100, 0, 0, 100, 505, 506, 0,
- 0, 0, 0, 0, 0, 0, 0, 80, 306, 98,
- 0, 0, 0, 0, 0, 80, 563, 0, 98, 0,
- 0, 0, 563, 507, 0, 0, 0, 563, 563, 0,
- 0, 0, 0, 80, 80, 0, 0, 0, 0, 0,
- 0, 0, 0, 80, 0, 0, 0, 0, 0, 0,
- 80, -594, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 80, 80, -594, -594, -594, -594, -594, -594,
- 80, -594, 0, 98, 97, 0, 0, -594, -594, 0,
- 0, 0, 0, 0, 0, 80, 80, 0, -594, -594,
- 0, -594, -594, -594, -594, -594, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 105, 262, 262, 433, 469, 262, 427, 429, 692, 394,
+ 86, 282, 86, 125, 125, 281, 243, 215, 215, 277,
+ 204, 226, 868, 215, 215, 215, 701, 579, 215, 224,
+ 243, 205, 283, 343, 279, 443, 761, 219, 205, 497,
+ 529, 106, 249, 69, 531, 69, 373, 373, 431, 310,
+ 303, 307, 205, 705, 608, 810, 714, 757, 86, 267,
+ 267, 845, 311, 267, 820, 431, 542, 268, 268, 320,
+ 253, 268, 215, 266, 266, 759, 1001, 266, 762, 296,
+ 205, 795, 796, 658, 661, 494, 714, 498, 711, 311,
+ 120, 120, 711, 373, 373, 267, 267, 534, 120, 517,
+ 731, 350, 351, 302, 306, 273, 278, 977, 277, 301,
+ 840, 566, 350, 351, 890, 689, 438, 570, 884, 896,
+ 525, -480, 342, 3, 215, 547, 86, 644, 767, -479,
+ 809, 652, 483, 434, 655, 466, 646, 121, 121, 120,
+ 387, 330, 332, 334, 336, 121, 475, 264, 270, -112,
+ 289, 271, 349, 1001, 1013, 673, 292, -104, 432, -483,
+ 248, 672, 549, 775, 272, 549, 120, 549, 644, 549,
+ 652, 549, 768, 567, 391, 432, 685, 244, -96, 673,
+ 245, 246, 885, 337, 338, 695, 121, 387, 437, -296,
+ 752, 388, 841, -479, 273, 278, 868, 977, -482, 868,
+ 598, 244, -296, -296, 245, 246, 390, 514, 247, -77,
+ 248, 358, 437, 121, 285, -483, -296, 86, 673, 444,
+ 445, -104, 901, -484, 292, 812, 809, -485, 215, 215,
+ -91, 539, 247, 395, 248, -487, 272, 533, -296, 361,
+ 362, 602, -577, 673, 983, -296, 362, 470, 471, 734,
+ 396, -296, 320, -101, -482, -577, 339, 262, -296, 520,
+ -486, 262, 871, 205, 495, 363, 495, 527, 527, 280,
+ 504, 363, 527, 248, 497, 830, 868, 714, -488, -484,
+ 215, 602, 602, -485, 215, 547, -336, 373, 215, 215,
+ -474, -487, 737, 86, -478, 435, 971, 280, 86, 86,
+ -336, -573, 761, 447, 480, 572, 86, 420, 421, 422,
+ 454, 459, 711, 711, 441, 267, -486, 311, 442, 267,
+ 296, 718, 719, 757, 534, 591, 463, 268, 124, 124,
+ 757, 516, 436, 266, -488, -336, 124, 806, 373, 522,
+ 876, 468, -336, 467, 931, 741, -474, 472, 519, 428,
+ -478, 86, 215, 215, 215, 215, 86, 226, 215, 215,
+ -111, 918, 476, 424, -474, 562, 455, 670, 576, -111,
+ 576, 557, 558, 559, 560, 86, 478, 124, -474, 549,
+ 556, -103, 42, 483, 69, 43, 515, 534, 600, 561,
+ 674, 512, 935, 936, 120, 86, 515, 292, 215, 492,
+ 86, 311, 544, 609, 124, 426, 486, 505, 511, 849,
+ 262, -573, 436, -474, -110, 773, 396, -573, 757, 226,
+ -474, 296, 518, 504, -110, 789, 530, 626, 791, -76,
+ 60, 793, 886, 215, 120, 262, 999, 892, 894, 1002,
+ -111, 121, 818, 609, 609, -102, 532, 596, 504, 791,
+ 262, 650, 596, -106, 650, 524, 680, 790, 215, 262,
+ 86, 215, 730, 504, 533, 536, 972, 836, 267, 86,
+ -106, 554, 504, 215, -98, 650, 282, 86, 120, 714,
+ 708, 121, 215, 832, 644, -108, 652, 86, 829, 555,
+ 650, 757, 881, 267, 366, 386, 120, 571, 292, 650,
+ 495, 495, 757, 577, 741, 891, -100, 547, 267, 105,
+ 574, 651, 243, 373, 722, 711, 1043, 267, 586, 86,
+ 940, 941, 828, 262, 578, 121, 581, 533, 86, 782,
+ 819, 498, 914, -105, 205, 651, 504, 267, 650, 954,
+ 703, 267, 311, 121, 311, 712, 215, 584, 587, 590,
+ 651, 789, 69, 86, -97, 589, 717, 663, -108, 651,
+ -105, 727, 460, 650, 534, 790, 891, 681, 267, 521,
+ 677, 267, 601, 523, 678, 688, 729, 423, 682, -106,
+ 543, 267, 594, 396, 704, 700, 716, 604, 721, -91,
+ 771, 424, 724, -108, -105, 104, 481, 104, 651, 245,
+ 246, 751, 104, 104, 832, 800, 766, 311, 104, 104,
+ 104, 244, 282, 104, 245, 246, 783, 460, 776, 120,
+ 585, 120, 588, 651, 602, 777, 425, 604, 604, 741,
+ 602, -481, 124, 426, 778, 602, 602, 462, 418, 419,
+ 420, 421, 422, 104, 462, -481, 788, 801, 802, 1021,
+ 277, 740, 921, 277, 771, 771, 787, 104, 809, 244,
+ 817, 823, 245, 246, 792, 826, 121, 794, 121, 827,
+ 834, 277, 124, 837, 215, 86, 808, 811, 248, 811,
+ -481, 485, -96, 847, 120, 843, 811, -481, 566, 804,
+ 247, 965, 248, 799, 850, 527, 852, 967, 854, 856,
+ 205, 243, 904, 825, 533, 905, 215, 873, 897, 104,
+ 495, 104, 909, 673, 244, 449, 124, 245, 246, 1033,
+ 913, 282, 915, 205, 923, 824, 922, 927, 786, 424,
+ 939, 121, -285, 899, 124, 596, 273, 602, 942, 273,
+ 945, 492, 660, 662, 947, 247, -285, 248, -409, 949,
+ 951, 464, 576, 956, 957, 786, 335, 273, -409, 323,
+ 324, 267, 267, 968, 450, 424, 262, 969, 485, 833,
+ 978, 426, 979, 715, 660, 662, 985, 86, 924, 504,
+ 720, -285, 989, -103, 311, 86, 609, 990, -285, 215,
+ 991, 726, 609, 215, 1004, 771, 747, 609, 609, 580,
+ 465, 1005, 104, 86, 86, 907, 650, 426, 911, 325,
+ 326, -409, 760, 104, 104, 764, 1006, 86, 877, 1015,
+ 215, -409, 725, -591, 267, -409, -591, -591, 1017, 86,
+ 86, 495, 1022, 1024, 1026, -409, 1028, 86, 1046, 912,
+ 959, 1038, -576, 748, 749, 282, 282, 755, 86, 86,
+ -577, 755, 1048, 723, 754, 129, 248, 124, -409, 124,
+ -409, 120, -97, 576, 576, 104, 651, -409, -409, 104,
+ -409, 938, 774, 104, 104, 1037, 944, -409, 104, 860,
+ 1039, 1036, 1009, 104, 104, 744, 898, 353, 354, 355,
+ 356, 104, 482, 207, 753, 691, 691, 553, 993, 609,
+ 323, 324, 900, 357, 998, 211, 211, 758, 121, 86,
+ 86, 211, -286, 962, 496, 908, -297, 86, 811, 0,
+ 0, 0, 124, 0, 0, 0, -286, 916, 917, 0,
+ -297, 0, 0, 0, 0, 920, 104, 104, 104, 104,
+ 104, 104, 0, 104, 104, 485, 0, 925, 120, 803,
+ 325, 326, 485, 120, 0, 473, 0, 0, 0, 282,
+ 104, -286, 0, 1014, 267, -297, 0, -102, -286, 424,
+ 604, 0, -297, 86, 844, 86, 604, 888, 86, 0,
+ 104, 604, 604, 104, 0, 104, 0, 0, 104, 0,
+ 120, 513, 576, 262, 0, 121, 867, 851, 853, 855,
+ 121, 857, 835, 858, 474, 424, 504, 958, 680, 811,
+ 0, 426, 440, 0, 0, 966, 215, 0, 104, -293,
+ 846, 0, -293, -293, -574, 537, 0, 0, 104, 104,
+ 0, 0, 0, 650, 946, 948, 0, 121, 0, 424,
+ 465, 872, 0, 104, 0, 104, 104, 426, 866, -293,
+ -293, 267, -293, 396, 104, 863, 0, 0, 104, -106,
+ 0, 744, 104, 353, 354, 355, 356, 104, 409, 410,
+ 0, 1010, 104, 1011, 538, 0, 1012, 0, 930, 357,
+ 932, 426, 0, 604, 933, 0, 0, -478, -481, 0,
+ 798, 887, 889, 651, 0, 0, 893, 895, 0, 124,
+ 0, -478, -481, -108, 104, 0, 997, 417, 418, 419,
+ 420, 421, 422, 104, 0, 0, 211, 211, 0, 0,
+ 0, 0, 887, 889, 0, 893, 895, 0, 462, 0,
+ 322, 104, 323, 324, -574, 0, -478, -481, 104, -285,
+ -574, 214, 214, -478, -481, 0, 0, 214, 263, 263,
+ 982, 0, 263, -285, 980, 981, -106, 0, 0, -106,
+ -106, 0, 1023, 1025, 1027, 0, 1029, 1030, 0, 984,
+ 986, 987, 988, 1000, -580, 1003, 506, 509, 0, 286,
+ 288, 0, 325, 326, 263, 304, 124, -106, -285, -106,
+ 0, 124, 0, 0, 0, -285, 340, 341, 955, 0,
+ -108, 0, 0, -108, -108, 0, 1047, 1049, 1050, 1051,
+ 1016, 0, 755, 1018, 0, 872, 1053, -580, 872, 994,
+ 872, 955, 866, 0, 903, 866, 863, 866, 124, 863,
+ 0, -108, 863, -108, 863, -576, 0, -580, 0, 0,
+ 211, 211, 211, 211, 0, 1040, 564, 565, 214, 691,
+ 1042, -580, 1044, -576, 0, 0, 1045, 1041, -297, 104,
+ 104, 744, 0, 353, 354, 355, 356, 0, 872, 780,
+ 0, 0, -297, 0, 0, 866, 1052, 0, 0, 357,
+ -580, 0, 863, 424, -580, 0, -580, -577, -99, 0,
+ -576, 104, 0, -580, -580, 872, 0, 872, -576, 872,
+ 0, 872, 866, 359, 866, 0, 866, -297, 866, 863,
+ 992, 863, -576, 863, -297, 863, -576, 0, 781, 0,
+ 0, 872, 0, 0, 424, 426, 0, -580, 866, -580,
+ -576, 462, -577, -576, 0, 863, -580, 462, 974, 0,
+ 353, 354, 355, 356, 0, -576, 0, -576, 0, 675,
+ -577, -576, 214, 214, -576, 0, 357, 0, 0, 450,
+ 0, 1007, 104, -576, -577, -576, 426, -98, 0, -576,
+ 104, 104, -576, 0, 104, 424, 0, 104, 104, 329,
+ 323, 324, 104, 104, 548, 0, 323, 324, 104, 104,
+ 488, 489, 490, 340, 0, -577, 0, -577, 0, -577,
+ 0, -100, 104, -577, 263, 104, -577, 0, 263, -577,
+ 1008, 0, 214, 214, 104, 104, 0, 426, 0, 0,
+ 0, 0, 104, 331, 323, 324, 0, 0, 0, 0,
+ 325, 326, 0, 104, 104, 0, 325, 326, 0, 333,
+ 323, 324, -577, 0, -577, 543, 323, 324, -577, 396,
+ 0, -577, 0, 0, 244, 0, 0, 245, 246, 0,
+ 0, 550, 323, 324, 409, 410, 0, 0, 763, 0,
+ 353, 354, 355, 356, 325, 326, 214, 214, 214, 214,
+ 0, 492, 214, 214, 104, 247, 357, 248, 0, 358,
+ 325, 326, 0, 0, 104, 104, 325, 326, 0, 0,
+ 573, 0, 104, 0, 418, 419, 420, 421, 422, 0,
+ 359, 583, 325, 326, 551, 323, 324, 361, 362, 0,
+ 0, 0, 595, 552, 323, 324, 0, 606, 611, 612,
+ 613, 614, 615, 616, 617, 618, 619, 620, 621, 622,
+ 623, 624, 625, 363, 628, 629, 630, 631, 632, 633,
+ 634, 635, 636, 637, 638, 396, 0, 263, 104, 0,
+ 104, 0, 211, 104, 0, 325, 326, 659, 659, 0,
+ 409, 410, 0, 0, 325, 326, 0, 103, 0, 103,
+ 127, 127, 263, 0, 0, 214, 0, 244, 229, 0,
+ 245, 246, 0, 0, 211, 659, 0, 263, 0, 659,
+ 659, 104, 739, 323, 324, 0, 263, 415, 416, 417,
+ 418, 419, 420, 421, 422, 702, 0, 0, 247, 706,
+ 248, 0, 0, 707, -603, 103, 710, 0, 713, 313,
+ 304, 352, 0, 353, 354, 355, 356, -603, -603, -603,
+ -603, -603, -603, 0, -603, 0, 0, 659, 0, 357,
+ -603, -603, 358, 325, 326, 0, 313, 710, 0, 0,
+ 304, -603, -603, 0, -603, -603, -603, -603, -603, 0,
+ 263, 0, 0, 359, 344, 345, 346, 347, 348, 360,
+ 361, 362, 0, 0, 0, 0, 742, 743, 0, 0,
+ 0, 0, 0, 103, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 750, 0, 0, 363, 0, 211, 364,
+ 0, 0, 0, -603, 352, 0, 353, 354, 355, 356,
+ 995, 0, 765, 0, 0, 772, 0, -603, 0, 0,
+ 0, 0, 357, 0, 0, 358, 0, -603, 0, 0,
+ -603, -603, 100, 0, 100, 126, 126, 126, 0, 0,
+ 0, 0, 0, 228, 0, 0, 359, 0, 0, 0,
+ -603, -603, 360, 361, 362, 0, 272, -603, -603, -603,
+ -603, 0, 83, 0, 83, 744, 0, 353, 354, 355,
+ 356, 0, 0, 225, 103, 0, 0, 0, 0, 363,
+ 100, 0, 364, 357, 312, 0, 0, 744, 214, 353,
+ 354, 355, 356, 0, 0, 365, 0, 0, 0, 0,
+ 805, 0, 0, 0, 0, 357, 0, 359, 0, 0,
+ 83, 312, 352, 745, 353, 354, 355, 356, 0, 0,
+ 214, 0, 0, 0, 0, 0, 0, 0, 0, 359,
+ 357, 831, 0, 358, 0, 928, 0, 0, 0, 0,
+ 710, 304, 0, 0, 0, 639, 640, 0, 100, 641,
+ 103, 0, 0, 0, 359, 103, 103, 0, 0, 0,
+ 360, 361, 362, 103, 173, 174, 175, 176, 177, 178,
+ 179, 180, 181, 0, 313, 182, 183, 0, 83, 184,
+ 185, 186, 187, 0, 0, 0, 0, 363, 0, 0,
+ 364, 0, 0, 188, 189, 875, 0, 0, 0, 0,
+ 659, 878, 0, 263, 0, 0, 659, 659, 103, 0,
+ 0, 659, 659, 103, 229, 0, 190, 191, 192, 193,
+ 194, 195, 196, 197, 198, 199, 0, 200, 201, 0,
+ 0, 0, 103, 0, 214, 202, 272, 659, 659, 100,
+ 659, 659, 0, 0, 352, 0, 353, 354, 355, 356,
+ 919, 0, 103, 0, 0, 0, 0, 103, 313, 0,
+ 610, 0, 357, 0, 0, 358, 0, 0, 0, 83,
+ 929, 0, 0, 0, 0, 0, 229, 0, 0, 0,
+ 0, 934, 0, 0, 0, 0, 359, 0, 0, 0,
+ 0, 0, 360, 361, 362, 0, 950, 0, 0, 0,
+ 610, 610, 0, 0, 0, 0, 952, 953, 0, 0,
+ 0, 0, 0, 659, 0, 100, 0, 103, 0, 363,
+ 100, 100, 364, 0, 0, 0, 103, 0, 100, 0,
+ 0, 0, 0, 0, 103, 540, 659, 0, 0, 312,
+ 0, 0, 0, 304, 103, 83, 0, 0, 0, 0,
+ 83, 83, 0, 0, 0, 0, 0, 0, 83, 0,
+ 0, 0, 0, 0, 0, 352, 0, 353, 354, 355,
+ 356, 0, 0, 100, 0, 0, 103, 0, 100, 228,
+ 0, 0, 0, 357, 0, 103, 358, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 100, 569, 313,
+ 0, 313, 0, 83, 0, 0, 0, 359, 83, 563,
+ 103, 0, 0, 360, 361, 362, 0, 100, 0, 0,
+ 0, 0, 100, 312, 0, 0, 0, 83, 0, 0,
+ 263, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 363, 228, 0, 364, 0, 0, 0, 83, 0, 0,
+ 0, 0, 83, 0, 0, 605, 0, 0, 0, 0,
+ 0, 0, 0, 0, 313, 0, 0, 0, 0, 0,
+ 0, 627, 0, 0, 0, 101, 0, 101, 0, 0,
+ 0, 0, 100, 0, 0, 0, 0, 0, 0, 0,
+ 0, 100, 0, 0, 0, 605, 605, 0, 0, 100,
+ 0, 396, 397, 398, 399, 400, 401, 402, 403, 100,
+ 405, 406, 83, 0, 0, 0, 409, 410, 0, 0,
+ 0, 83, 0, 101, 0, 0, 0, 0, 0, 83,
+ 0, 0, 103, 0, 0, 0, 0, 0, 0, 83,
+ 0, 100, 0, 0, 0, 0, 0, 0, 0, 0,
+ 100, 413, 414, 415, 416, 417, 418, 419, 420, 421,
+ 422, 0, 0, 0, 312, 0, 312, 0, 0, 0,
+ 0, 83, 0, 0, 0, 100, 0, 0, 0, 0,
+ 83, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 101, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 83, 0, 0, 0, 0,
+ 0, 0, 396, 397, 398, 399, 400, 401, 402, 403,
+ 404, 405, 406, -604, -604, 0, 0, 409, 410, 312,
+ 0, 0, 0, 0, 103, 0, 0, 0, 0, 0,
+ 0, 313, 103, 610, 0, 0, 0, 0, 0, 610,
+ 0, 0, 0, 0, 610, 610, 0, 0, 0, 0,
+ 103, 103, 413, 414, 415, 416, 417, 418, 419, 420,
+ 421, 422, 0, 0, 103, 0, 0, 0, 0, 0,
+ 0, 0, 101, 0, 0, 0, 103, 103, 0, 0,
+ 0, 0, 0, 0, 103, 0, 0, 100, 0, 0,
+ 0, 0, 0, 0, 0, 103, 103, 779, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 83, 127, 0,
+ 0, 0, 0, 127, 0, 396, 397, 398, 399, 400,
+ 401, 402, 403, 404, 405, 406, 407, 408, 0, 0,
+ 409, 410, 0, 0, 0, 0, 610, 0, 101, 0,
+ 0, 0, 0, 101, 101, 0, 103, 103, 0, 0,
+ 964, 101, 0, 0, 103, 0, 0, 0, 0, 0,
+ 0, 0, 0, 412, 0, 413, 414, 415, 416, 417,
+ 418, 419, 420, 421, 422, 0, 0, 0, 0, 100,
+ 0, 0, 0, -272, 0, 0, 312, 100, 0, 0,
+ 0, 0, 0, 0, 0, 0, 101, 0, 0, 0,
+ 0, 101, 0, 0, 0, 100, 100, 0, 0, 83,
+ 103, 0, 103, 0, 0, 103, 0, 83, 605, 100,
+ 101, 0, 0, 0, 605, 0, 0, 0, 0, 605,
+ 605, 100, 100, 0, 0, 83, 83, 0, 0, 100,
+ 101, 0, 0, 0, 0, 101, 0, 0, 101, 83,
+ 100, 100, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 83, 83, 0, 0, 0, 0, 0, 0, 83,
+ 0, 0, 0, 126, 0, 0, 0, 0, 126, 0,
+ 83, 83, 0, 0, 0, 0, 0, 0, 101, 101,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 563, 0, 0, 0, 0, 0, 0,
- -594, 0, 0, 80, 80, 0, 0, 0, 0, 0,
- 0, 0, 932, 0, -594, 0, 80, 0, 0, 0,
- 0, 0, 0, 0, -594, 98, 0, -594, -594, 0,
- 0, 0, 0, 97, 0, 0, 0, 0, 0, 0,
- 306, 97, 0, 0, 0, 0, 0, -594, -594, 0,
- 0, 0, 0, 266, -594, -594, -594, -594, 0, 97,
- 97, 0, 0, 0, 0, 0, 0, 0, 0, 97,
- 0, 0, 0, 0, 0, 80, 97, 0, 0, 0,
- 0, 80, 0, 80, 0, 0, 80, 0, 97, 97,
- 0, 0, 0, 0, 0, 0, 97, 0, 0, 0,
+ 0, 0, 0, 0, 0, 101, 0, 0, 0, 0,
+ 0, 100, 100, 0, 101, 963, 0, 0, 0, 100,
+ 0, 0, 101, 0, 0, 0, 0, 0, 0, 0,
+ 0, 605, 101, 0, 0, 0, 0, 0, 0, 0,
+ 0, 83, 83, 0, 0, 961, 0, 0, 0, 83,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 97, 97, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 98, 0, 0, 0, 0, 0,
- 0, 121, 98, 98, 0, 0, 121, 0, 0, 98,
- 0, 0, 0, 0, 98, 98, 0, 0, 0, 0,
- 98, 98, 0, 0, 0, 0, 0, 0, 0, 0,
- 98, 0, 0, 0, 0, 0, 0, 98, 0, 97,
- 97, 0, 0, 0, 0, 0, 0, 0, 934, 98,
- 98, 0, 97, 0, 0, 0, 0, 98, 0, 0,
- 0, 0, 0, 0, 0, 0, 732, 0, 0, 0,
- 0, 0, 98, 98, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 353, 354, 355, 356, 357, 358,
- 359, 360, 361, 362, 363, 364, 365, 0, 0, 366,
- 367, 97, 0, 0, 0, 0, 0, 97, 0, 97,
- 98, 0, 97, 353, -595, -595, -595, -595, 358, 359,
- 98, 98, -595, -595, 0, 0, 0, 0, 366, 367,
- 0, 0, 368, 98, 369, 370, 371, 372, 373, 374,
- 375, 376, 377, 378, 0, 0, 0, 0, 0, 0,
- 0, 0, -260, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 369, 370, 371, 372, 373, 374, 375,
- 376, 377, 378, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 101, 0, 0, 0, 0, 0,
+ 0, 0, 0, 101, 0, 100, 0, 100, 0, 0,
+ 100, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 101, 0,
+ 0, 0, 0, 0, 0, 83, 0, 83, 0, 0,
+ 83, 0, 0, 0, 0, 0, 0, -603, 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, 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, 0, 46, 47, 48, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 98, 0, 0, 0, 0, 0, 98, 0,
- 98, -594, 4, 98, 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, 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, 0,
- 46, 47, 48, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 49, 0, 0,
+ 50, 51, 0, 52, 53, 0, 54, 0, 0, 55,
+ 101, 56, 57, 58, 59, 60, 61, 0, 0, 62,
+ -603, 0, 0, -603, -603, 0, 0, 396, -604, -604,
+ -604, -604, 401, 402, 0, 0, -604, -604, 0, 63,
+ 64, 65, 409, 410, 0, 0, 0, 0, 0, 0,
+ 0, -603, 0, -603, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 779, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 413, 414, 415,
+ 416, 417, 418, 419, 420, 421, 422, 0, 0, 0,
+ 0, 0, 396, 397, 398, 399, 400, 401, 402, 403,
+ 404, 405, 406, 407, 408, 0, 0, 409, 410, 0,
+ 0, 0, 101, 0, 0, 0, 0, 0, 0, 0,
+ 101, 101, 0, 0, 0, 0, 0, 101, 0, 0,
+ 0, 0, 101, 101, 0, 0, 0, 0, 101, 101,
+ 412, 0, 413, 414, 415, 416, 417, 418, 419, 420,
+ 421, 422, 101, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 101, 101, 0, 0, 0, 0,
+ 0, 0, 101, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 101, 101, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, -474, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 49, 0, 0, 50, 51, 0, 52, 53, 0,
- 54, 0, 0, 55, 0, 56, 57, 58, 59, 60,
- 61, -466, 0, 62, -594, 0, 0, -594, -594, 0,
- 0, 0, 0, 0, -466, -466, -466, -466, -466, -466,
- 0, -466, 0, 63, 64, 65, 0, 0, -466, -466,
- 0, 0, 0, 0, 0, -594, 0, -594, -466, -466,
- 0, -466, -466, -466, -466, -466, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 442, 0,
+ 0, -474, -474, -474, -474, -474, -474, 0, -474, 0,
+ 0, 0, 0, 0, 0, -474, -474, 0, 0, 0,
+ 0, 0, 0, 0, 101, -474, -474, 0, -474, -474,
+ -474, -474, -474, 0, 101, 101, 0, 0, 0, 0,
+ 0, 0, 101, 0, 0, 486, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, -466, -466, -466, -466, -466, -466, -466,
- -466, -466, -466, -466, -466, -466, 0, 0, -466, -466,
- -466, 0, -466, -466, 0, 0, 0, 0, 0, -466,
- 0, 0, 0, 0, -466, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, -466, 0, 0, -466, -466, 0,
- -466, -466, 0, -466, -466, -466, -466, -466, -466, -466,
- -466, -466, -466, 0, 0, -594, 0, 0, -466, -466,
- -466, -466, 0, 0, -466, -466, -466, -466, -594, -594,
- -594, -594, -594, -594, 0, -594, 0, 0, 0, 0,
- 0, 0, -594, -594, 0, 0, 0, 0, 0, 0,
- 0, 0, -594, -594, 0, -594, -594, -594, -594, -594,
+ -474, -474, -474, -474, -474, -474, -474, -474, -474, -474,
+ -474, -474, -474, 0, 0, -474, -474, -474, 0, -474,
+ -474, 0, 0, 0, 0, 0, -474, 0, 0, 0,
+ 0, -474, 0, 0, 0, 0, 0, 0, 101, 0,
+ 101, -474, 0, 101, -474, -474, 0, -474, -474, 0,
+ -474, -474, -474, -474, -474, -474, -474, -474, -474, -474,
+ 0, 0, -603, 0, 0, -474, -474, -474, -474, 0,
+ 0, -474, -474, -474, -474, -603, -603, -603, -603, -603,
+ -603, 0, -603, 0, 0, 0, 0, 0, 0, -603,
+ -603, 0, 0, 0, 0, 0, 0, 0, 0, -603,
+ -603, 0, -603, -603, -603, -603, -603, 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, 0, 0, 0, -594, -594, -594,
- -594, -594, -594, -594, -594, -594, -594, -594, -594, -594,
- 0, 0, -594, -594, -594, 0, 0, -594, 0, 0,
- 0, 0, 0, -594, 0, 0, 0, 0, -594, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, -594, 0,
- 0, -594, -594, 0, 0, -594, 0, -594, -594, -594,
- -594, -594, -594, -594, -594, -594, -594, 0, 0, -571,
- 0, 0, -594, -594, -594, -594, 0, 266, -594, -594,
- -594, -594, -571, -571, -571, 0, -571, -571, 0, -571,
- 0, 0, 0, 0, 0, -571, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, -571, -571, 0, -571,
- -571, -571, -571, -571, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, -603, -603, -603, -603, -603, -603,
+ -603, -603, -603, -603, -603, -603, -603, 0, 0, -603,
+ -603, -603, 0, 0, -603, 0, 0, 0, 0, 0,
+ -603, 0, 0, 0, 0, -603, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, -603, 0, 0, -603, -603,
+ 0, 0, -603, 0, -603, -603, -603, -603, -603, -603,
+ -603, -603, -603, -603, 0, 0, -580, 0, 0, -603,
+ -603, -603, -603, 0, 272, -603, -603, -603, -603, -580,
+ -580, -580, 0, -580, -580, 0, -580, 0, 0, 0,
+ 0, 0, -580, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, -580, -580, 0, -580, -580, -580, -580,
+ -580, 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, -580, -580,
+ -580, -580, -580, -580, -580, -580, -580, -580, -580, -580,
+ -580, 0, 0, -580, -580, -580, 0, 784, -580, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, -580,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, -580,
+ 0, 0, -580, -580, 0, -107, -580, 0, -580, -580,
+ -580, -580, -580, -580, -580, -580, -580, -580, 0, 0,
+ -580, 0, -580, -580, -580, 0, -99, 0, 0, -580,
+ -580, -580, -580, -580, -580, -580, 0, -580, -580, 0,
+ -580, 0, 0, 0, 0, 0, -580, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, -580, -580, 0,
+ -580, -580, -580, -580, -580, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, -571, -571, -571, -571, -571, -571, -571, -571, -571,
- -571, -571, -571, -571, 0, 0, -571, -571, -571, 0,
- 737, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, -571, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, -571, 0, 0, -571, -571, 0, -99, -571,
- 0, -571, -571, -571, -571, -571, -571, -571, -571, -571,
- -571, 0, 0, -571, 0, -571, -571, -571, 0, -91,
- 0, 0, -571, -571, -571, -571, -571, -571, -571, 0,
- -571, -571, 0, -571, 0, 0, 0, 0, 0, -571,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- -571, -571, 0, -571, -571, -571, -571, -571, 0, 0,
+ 0, 0, -580, -580, -580, -580, -580, -580, -580, -580,
+ -580, -580, -580, -580, -580, 0, 0, -580, -580, -580,
+ 0, 784, -580, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, -580, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, -580, 0, 0, -580, -580, 0, -107,
+ -580, 0, -580, -580, -580, -580, -580, -580, -580, -580,
+ -580, -580, 0, 0, -296, 0, -580, -580, -580, 0,
+ -580, 0, 0, -580, -580, -580, -580, -296, -296, -296,
+ 0, -296, -296, 0, -296, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, -296, -296, 0, -296, -296, -296, -296, -296, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, -571, -571, -571, -571, -571,
- -571, -571, -571, -571, -571, -571, -571, -571, 0, 0,
- -571, -571, -571, 0, 737, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, -571, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, -571, 0, 0, -571,
- -571, 0, -99, -571, 0, -571, -571, -571, -571, -571,
- -571, -571, -571, -571, -571, 0, 0, -284, 0, -571,
- -571, -571, 0, -571, 0, 0, -571, -571, -571, -571,
- -284, -284, -284, 0, -284, -284, 0, -284, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, -284, -284, 0, -284, -284, -284,
- -284, -284, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, -296, -296, -296, -296,
+ -296, -296, -296, -296, -296, -296, -296, -296, -296, 0,
+ 0, -296, -296, -296, 0, 785, -296, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, -296, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, -296, 0, 0,
+ -296, -296, 0, -109, -296, 0, -296, -296, -296, -296,
+ -296, -296, -296, -296, -296, -296, 0, 0, -296, 0,
+ 0, -296, -296, 0, -101, 0, 0, -296, -296, -296,
+ -296, -296, -296, -296, 0, -296, -296, 0, -296, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, -284,
- -284, -284, -284, -284, -284, -284, -284, -284, -284, -284,
- -284, -284, 0, 0, -284, -284, -284, 0, 738, 0,
+ 0, 0, 0, 0, 0, -296, -296, 0, -296, -296,
+ -296, -296, -296, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- -284, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- -284, 0, 0, -284, -284, 0, -101, -284, 0, -284,
- -284, -284, -284, -284, -284, -284, -284, -284, -284, 0,
- 0, -284, 0, 0, -284, -284, 0, -93, 0, 0,
- -284, -284, -284, -284, -284, -284, -284, 0, -284, -284,
- 0, -284, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, -284, -284,
- 0, -284, -284, -284, -284, -284, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ -296, -296, -296, -296, -296, -296, -296, -296, -296, -296,
+ -296, -296, -296, 0, 0, -296, -296, -296, 0, 785,
+ -296, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, -296, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, -296, 0, 0, -296, -296, 0, -109, -296, 0,
+ -296, -296, -296, -296, -296, -296, -296, -296, -296, -296,
+ 0, 0, 0, 0, 0, -296, -296, 0, -296, 0,
+ 0, -296, -296, -296, -296, 290, 0, 5, 6, 7,
+ 8, 9, 10, 11, 12, 13, 14, -603, -603, -603,
+ 0, 0, -603, 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, 0, 40, 41, 42, 0, 0, 43, 0, 0,
+ 44, 45, 0, 46, 47, 48, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, -284, -284, -284, -284, -284, -284, -284,
- -284, -284, -284, -284, -284, -284, 0, 0, -284, -284,
- -284, 0, 738, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, -284, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, -284, 0, 0, -284, -284, 0,
- -101, -284, 0, -284, -284, -284, -284, -284, -284, -284,
- -284, -284, -284, 0, 0, 0, 0, 0, -284, -284,
- 0, -284, 0, 0, -284, -284, -284, -284, 284, 0,
- 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- -594, -594, -594, 0, 0, -594, 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, 0, 40, 41, 42, 0, 0,
- 43, 0, 0, 44, 45, 0, 46, 47, 48, 0,
+ 0, 0, 0, 0, 49, 0, 0, 50, 51, 0,
+ 52, 53, 0, 54, 0, 0, 55, 0, 56, 57,
+ 58, 59, 60, 61, 0, 0, 62, -603, 0, 0,
+ -603, -603, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 63, 64, 65, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, -603, 290,
+ -603, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 0, 0, -603, 0, -603, -603, 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, 0, 40, 41, 42, 0,
+ 0, 43, 0, 0, 44, 45, 0, 46, 47, 48,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 49, 0, 0,
- 50, 51, 0, 52, 53, 0, 54, 0, 0, 55,
- 0, 56, 57, 58, 59, 60, 61, 0, 0, 62,
- -594, 0, 0, -594, -594, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 63,
- 64, 65, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, -594, 284, -594, 5, 6, 7, 8, 9, 10,
- 11, 12, 13, 14, 0, 0, -594, 0, -594, -594,
- 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, 0, 40,
- 41, 42, 0, 0, 43, 0, 0, 44, 45, 0,
- 46, 47, 48, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 49, 0,
+ 0, 50, 51, 0, 52, 53, 0, 54, 0, 0,
+ 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
+ 62, -603, 0, 0, -603, -603, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 49, 0, 0, 50, 51, 0, 52, 53, 0,
- 54, 0, 0, 55, 0, 56, 57, 58, 59, 60,
- 61, 0, 0, 62, -594, 0, 0, -594, -594, 0,
+ 63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, -603, 290, -603, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 0, 0, -603, 0, 0,
+ -603, 15, -603, 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, 0,
+ 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
+ 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 63, 64, 65, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, -594, 284, -594, 5, 6,
- 7, 8, 9, 10, 11, 12, 13, 14, 0, 0,
- -594, 0, 0, -594, 15, -594, 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, 0, 40, 41, 42, 0, 0, 43, 0,
- 0, 44, 45, 0, 46, 47, 48, 0, 0, 0,
+ 0, 0, 49, 0, 0, 50, 51, 0, 52, 53,
+ 0, 54, 0, 0, 55, 0, 56, 57, 58, 59,
+ 60, 61, 0, 0, 62, -603, 0, 0, -603, -603,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 49, 0, 0, 50, 51,
- 0, 52, 53, 0, 54, 0, 0, 55, 0, 56,
- 57, 58, 59, 60, 61, 0, 0, 62, -594, 0,
- 0, -594, -594, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, -594,
- 284, -594, 5, 6, 7, 8, 9, 10, 11, 12,
- 13, 14, 0, 0, -594, 0, 0, -594, 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, 0, 40, 41, 42,
- 0, 0, 43, 0, 0, 44, 45, 0, 46, 47,
- 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
- 0, 0, 50, 51, 0, 52, 53, 0, 54, 0,
- 0, 55, 0, 56, 57, 58, 59, 60, 61, 0,
- 0, 62, -594, 0, 0, -594, -594, 4, 0, 5,
+ 0, 0, 0, 0, 63, 64, 65, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, -603, 290, -603, 5,
6, 7, 8, 9, 10, 11, 12, 13, 14, 0,
- 0, 63, 64, 65, 0, 15, 0, 16, 17, 18,
- 19, 0, 0, -594, 0, -594, 20, 21, 22, 23,
+ 0, -603, 0, 0, -603, 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, 29, 30, 31, 32, 33, 34, 35, 36,
+ 0, 28, 0, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 49, 0, 0, 50,
51, 0, 52, 53, 0, 54, 0, 0, 55, 0,
- 56, 57, 58, 59, 60, 61, 0, 0, 62, -594,
- 0, 0, -594, -594, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
- 65, 0, 0, -594, 0, 0, 0, 0, 0, 0,
- -594, 284, -594, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 14, 0, -594, -594, 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, 35, 36, 37, 38, 39, 0, 40, 41,
- 42, 0, 0, 43, 0, 0, 44, 45, 0, 46,
- 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
+ 56, 57, 58, 59, 60, 61, 0, 0, 62, -603,
+ 0, 0, -603, -603, 4, 0, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 14, 0, 0, 63, 64,
+ 65, 0, 15, 0, 16, 17, 18, 19, 0, 0,
+ -603, 0, -603, 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, 0, 46, 47, 48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 49, 0, 0, 50, 51, 0, 52, 53, 0, 54,
- 0, 0, 55, 0, 56, 57, 58, 59, 60, 61,
- 0, 0, 62, -594, 0, 0, -594, -594, 284, 0,
+ 0, 0, 0, 49, 0, 0, 50, 51, 0, 52,
+ 53, 0, 54, 0, 0, 55, 0, 56, 57, 58,
+ 59, 60, 61, 0, 0, 62, -603, 0, 0, -603,
+ -603, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 63, 64, 65, 0, 0,
+ -603, 0, 0, 0, 0, 0, 0, -603, 290, -603,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 0, 0, 63, 64, 65, 0, 15, 0, 16, 17,
- 18, 19, 0, 0, -594, 0, -594, 20, 21, 22,
+ 0, -603, -603, 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, 35,
36, 37, 38, 39, 0, 40, 41, 42, 0, 0,
43, 0, 0, 44, 45, 0, 46, 47, 48, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 49, 0, 0,
- 285, 51, 0, 52, 53, 0, 54, 0, 0, 55,
+ 50, 51, 0, 52, 53, 0, 54, 0, 0, 55,
0, 56, 57, 58, 59, 60, 61, 0, 0, 62,
- -594, 0, 0, -594, -594, 284, 0, 5, 6, 7,
+ -603, 0, 0, -603, -603, 290, 0, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 0, 0, 63,
64, 65, 0, 15, 0, 16, 17, 18, 19, 0,
- -594, -594, 0, -594, 20, 21, 22, 23, 24, 25,
+ 0, -603, 0, -603, 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, 0,
44, 45, 0, 46, 47, 48, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 49, 0, 0, 50, 51, 0,
+ 0, 0, 0, 0, 49, 0, 0, 291, 51, 0,
52, 53, 0, 54, 0, 0, 55, 0, 56, 57,
- 58, 59, 60, 61, 0, 0, 62, -594, 0, 0,
- -594, -594, 284, 0, 5, 6, 7, 8, 9, 10,
+ 58, 59, 60, 61, 0, 0, 62, -603, 0, 0,
+ -603, -603, 290, 0, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 0, 0, 63, 64, 65, 0,
- 15, 0, 16, 17, 18, 19, 0, -594, -594, 0,
- -594, 20, 21, 22, 23, 24, 25, 26, 0, 0,
+ 15, 0, 16, 17, 18, 19, 0, -603, -603, 0,
+ -603, 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, 0, 44, 45, 0,
@@ -2860,1138 +2923,1174 @@ static const yytype_int16 yytable[] =
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 49, 0, 0, 50, 51, 0, 52, 53, 0,
54, 0, 0, 55, 0, 56, 57, 58, 59, 60,
- 61, 0, 0, 62, -594, 0, 0, -594, -594, 0,
+ 61, 0, 0, 62, -603, 0, 0, -603, -603, 290,
+ 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 0, 0, 63, 64, 65, 0, 15, 0, 16,
+ 17, 18, 19, 0, -603, -603, 0, -603, 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, 0, 44, 45, 0, 46, 47, 48,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 63, 64, 65, 0, 0, -594, 0,
- 0, 0, 0, 0, 0, -594, 284, -594, 5, 6,
- 7, 8, 9, 10, 11, 12, 13, 14, 0, 0,
- -594, 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, 35, 36, 37,
- 38, 39, 0, 40, 41, 42, 0, 0, 43, 0,
- 0, 44, 45, 0, 46, 47, 48, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 49, 0,
+ 0, 50, 51, 0, 52, 53, 0, 54, 0, 0,
+ 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
+ 62, -603, 0, 0, -603, -603, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 49, 0, 0, 50, 51,
- 0, 52, 53, 0, 54, 0, 0, 55, 0, 56,
- 57, 58, 59, 60, 61, 0, 0, 62, -594, 0,
- 0, -594, -594, 0, 0, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 14, 0, 0, 63, 64, 65,
- 0, 15, 0, 16, 17, 18, 19, 0, 0, -594,
- 0, -594, 20, 21, 22, 23, 24, 25, 26, 0,
- 0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
+ 63, 64, 65, 0, 0, -603, 0, 0, 0, 0,
+ 0, 0, -603, 290, -603, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 0, 0, -603, 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, 35, 36, 37, 38, 39, 0,
40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 49, 0, 0, 50, 51, 0, 52, 53,
0, 54, 0, 0, 55, 0, 56, 57, 58, 59,
- 60, 61, 0, 0, 62, 238, 0, 0, 239, 240,
+ 60, 61, 0, 0, 62, -603, 0, 0, -603, -603,
0, 0, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 0, 0, 63, 64, 65, 0, 15, 0,
- 16, 17, 18, 19, 0, 0, 241, 0, 242, 20,
+ 16, 17, 18, 19, 0, 0, -603, 0, -603, 20,
21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
- 0, 0, 0, 0, 28, 0, 30, 31, 32, 33,
+ 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, 0, 46, 47,
48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
0, 0, 50, 51, 0, 52, 53, 0, 54, 0,
0, 55, 0, 56, 57, 58, 59, 60, 61, 0,
- 0, 62, 238, 0, 0, 239, 240, 0, 0, 5,
- 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
+ 0, 62, 244, 0, 0, 245, 246, 0, 0, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 0,
0, 63, 64, 65, 0, 15, 0, 16, 17, 18,
- 19, 0, 0, 241, 0, 242, 20, 21, 22, 23,
+ 19, 0, 0, 247, 0, 248, 20, 21, 22, 23,
24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
- 0, 0, 0, 0, 31, 32, 33, 34, 35, 36,
+ 0, 28, 0, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 205, 0, 0, 115,
- 51, 0, 52, 53, 0, 0, 0, 0, 55, 0,
- 56, 57, 58, 59, 60, 61, 0, 0, 62, 238,
- 0, 0, 239, 240, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
- 65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 241, 0, 242, 125, 126, 127, 128, 129, 130, 131,
- 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
- 142, 143, 144, 145, 146, 147, 148, 0, 0, 0,
- 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
- 0, 0, 0, 0, 0, 159, 160, 161, 162, 163,
- 164, 165, 166, 36, 37, 167, 39, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
- 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
- 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
- 193, 194, 0, 195, 196, 0, 0, 0, 0, 0,
- 0, 197, 198, -564, -564, -564, -564, -564, -564, -564,
- -564, -564, 0, 0, 0, 0, 0, 0, 0, -564,
- 0, -564, -564, -564, -564, 0, -564, 0, 0, 0,
- -564, -564, -564, -564, -564, -564, -564, 0, 0, -564,
- 0, 0, 0, 0, 0, 0, 0, 0, -564, -564,
- -564, -564, -564, -564, -564, -564, -564, 0, -564, -564,
- -564, 0, 0, -564, 0, 0, -564, -564, 0, -564,
- -564, -564, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- -564, 0, 0, -564, -564, 0, -564, -564, 0, -564,
- -564, -564, -564, 0, -564, -564, -564, -564, -564, -564,
- 0, 0, -564, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, -564, -564, -564, 0, -564, 0, 0, 0,
- 0, 0, -564, -566, -566, -566, -566, -566, -566, -566,
- -566, -566, 0, 0, 0, 0, 0, 0, 0, -566,
- 0, -566, -566, -566, -566, 0, -566, 0, 0, 0,
- -566, -566, -566, -566, -566, -566, -566, 0, 0, -566,
- 0, 0, 0, 0, 0, 0, 0, 0, -566, -566,
- -566, -566, -566, -566, -566, -566, -566, 0, -566, -566,
- -566, 0, 0, -566, 0, 0, -566, -566, 0, -566,
- -566, -566, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- -566, 0, 0, -566, -566, 0, -566, -566, 0, -566,
- -566, -566, -566, 0, -566, -566, -566, -566, -566, -566,
- 0, 0, -566, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, -566, -566, -566, 0, -566, 0, 0, 0,
- 0, 0, -566, -565, -565, -565, -565, -565, -565, -565,
- -565, -565, 0, 0, 0, 0, 0, 0, 0, -565,
- 0, -565, -565, -565, -565, 0, -565, 0, 0, 0,
- -565, -565, -565, -565, -565, -565, -565, 0, 0, -565,
- 0, 0, 0, 0, 0, 0, 0, 0, -565, -565,
- -565, -565, -565, -565, -565, -565, -565, 0, -565, -565,
- -565, 0, 0, -565, 0, 0, -565, -565, 0, -565,
- -565, -565, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- -565, 0, 0, -565, -565, 0, -565, -565, 0, -565,
- -565, -565, -565, 0, -565, -565, -565, -565, -565, -565,
- 0, 0, -565, 0, 0, 0, 0, 0, 0, -567,
- -567, -567, -567, -567, -567, -567, -567, -567, 0, 0,
- 0, 0, -565, -565, -565, -567, -565, -567, -567, -567,
- -567, 0, -565, 0, 0, 0, -567, -567, -567, -567,
- -567, -567, -567, 0, 0, -567, 0, 0, 0, 0,
- 0, 0, 0, 0, -567, -567, -567, -567, -567, -567,
- -567, -567, -567, 0, -567, -567, -567, 0, 0, -567,
- 0, 0, -567, -567, 0, -567, -567, -567, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, -567, 771, 0, -567,
- -567, 0, -567, -567, 0, -567, -567, -567, -567, 0,
- -567, -567, -567, -567, -567, -567, 0, 0, -567, 0,
- 0, 0, 0, 0, 0, -99, -568, -568, -568, -568,
- -568, -568, -568, -568, -568, 0, 0, 0, -567, -567,
- -567, 0, -568, 0, -568, -568, -568, -568, -567, 0,
- 0, 0, 0, -568, -568, -568, -568, -568, -568, -568,
- 0, 0, -568, 0, 0, 0, 0, 0, 0, 0,
- 0, -568, -568, -568, -568, -568, -568, -568, -568, -568,
- 0, -568, -568, -568, 0, 0, -568, 0, 0, -568,
- -568, 0, -568, -568, -568, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, -568, 772, 0, -568, -568, 0, -568,
- -568, 0, -568, -568, -568, -568, 0, -568, -568, -568,
- -568, -568, -568, 0, 0, -568, 0, 0, 0, 0,
- 0, 0, -101, -253, -253, -253, -253, -253, -253, -253,
- -253, -253, 0, 0, 0, -568, -568, -568, 0, -253,
- 0, -253, -253, -253, -253, -568, 0, 0, 0, 0,
- -253, -253, -253, -253, -253, -253, -253, 0, 0, -253,
- 0, 0, 0, 0, 0, 0, 0, 0, -253, -253,
- -253, -253, -253, -253, -253, -253, -253, 0, -253, -253,
- -253, 0, 0, -253, 0, 0, -253, -253, 0, -253,
- -253, -253, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- -253, 0, 0, -253, -253, 0, -253, -253, 0, -253,
- -253, -253, -253, 0, -253, -253, -253, -253, -253, -253,
- 0, 0, -253, 0, 0, 0, 0, 0, 0, -569,
- -569, -569, -569, -569, -569, -569, -569, -569, 0, 0,
- 0, 0, -253, -253, -253, -569, 0, -569, -569, -569,
- -569, 0, 266, 0, 0, 0, -569, -569, -569, -569,
- -569, -569, -569, 0, 0, -569, 0, 0, 0, 0,
- 0, 0, 0, 0, -569, -569, -569, -569, -569, -569,
- -569, -569, -569, 0, -569, -569, -569, 0, 0, -569,
- 0, 0, -569, -569, 0, -569, -569, -569, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, -569, 0, 0, -569,
- -569, 0, -569, -569, 0, -569, -569, -569, -569, 0,
- -569, -569, -569, -569, -569, -569, 0, 0, -569, 0,
- 0, 0, 0, 0, 0, -570, -570, -570, -570, -570,
- -570, -570, -570, -570, 0, 0, 0, 0, -569, -569,
- -569, -570, 0, -570, -570, -570, -570, 0, -569, 0,
- 0, 0, -570, -570, -570, -570, -570, -570, -570, 0,
- 0, -570, 0, 0, 0, 0, 0, 0, 0, 0,
- -570, -570, -570, -570, -570, -570, -570, -570, -570, 0,
- -570, -570, -570, 0, 0, -570, 0, 0, -570, -570,
- 0, -570, -570, -570, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, -570, 0, 0, -570, -570, 0, -570, -570,
- 0, -570, -570, -570, -570, 0, -570, -570, -570, -570,
- -570, -570, 0, 0, -570, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 49, 0, 0, 50,
+ 51, 0, 52, 53, 0, 54, 0, 0, 55, 0,
+ 56, 57, 58, 59, 60, 61, 0, 0, 62, 244,
+ 0, 0, 245, 246, 0, 0, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 0, 0, 0, 63, 64,
+ 65, 0, 15, 0, 16, 17, 18, 19, 0, 0,
+ 247, 0, 248, 20, 21, 22, 23, 24, 25, 26,
+ 0, 0, 27, 0, 0, 0, 0, 0, 0, 0,
+ 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 0, 40, 41, 42, 0, 0, 43, 0, 0, 44,
+ 45, 0, 46, 47, 48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, -570, -570, -570, 0, 0, 0,
- 0, 0, 0, 0, -570, 125, 126, 127, 128, 129,
+ 0, 0, 0, 210, 0, 0, 118, 51, 0, 52,
+ 53, 0, 0, 0, 0, 55, 0, 56, 57, 58,
+ 59, 60, 61, 0, 0, 62, 244, 0, 0, 245,
+ 246, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 63, 64, 65, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 247, 0, 248,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
- 140, 141, 142, 143, 144, 145, 146, 147, 148, 0,
- 0, 0, 149, 150, 151, 224, 225, 226, 227, 156,
- 157, 158, 0, 0, 0, 0, 0, 159, 160, 161,
- 228, 229, 230, 231, 166, 309, 310, 232, 311, 0,
- 0, 0, 0, 0, 0, 312, 0, 0, 0, 0,
- 0, 0, 168, 169, 170, 171, 172, 173, 174, 175,
- 176, 0, 0, 177, 178, 0, 0, 179, 180, 181,
- 182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 183, 184, 0, 0, 0, 0, 0, 0, 0,
- 313, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 185, 186, 187, 188, 189, 190,
- 191, 192, 193, 194, 0, 195, 196, 0, 0, 0,
- 0, 0, 0, 197, 125, 126, 127, 128, 129, 130,
- 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
- 141, 142, 143, 144, 145, 146, 147, 148, 0, 0,
- 0, 149, 150, 151, 224, 225, 226, 227, 156, 157,
- 158, 0, 0, 0, 0, 0, 159, 160, 161, 228,
- 229, 230, 231, 166, 309, 310, 232, 311, 0, 0,
- 0, 0, 0, 0, 312, 0, 0, 0, 0, 0,
- 0, 168, 169, 170, 171, 172, 173, 174, 175, 176,
- 0, 0, 177, 178, 0, 0, 179, 180, 181, 182,
+ 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
+ 150, 151, 152, 153, 0, 0, 0, 154, 155, 156,
+ 157, 158, 159, 160, 161, 162, 163, 0, 0, 0,
+ 0, 0, 164, 165, 166, 167, 168, 169, 170, 171,
+ 36, 37, 172, 39, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
+ 176, 177, 178, 179, 180, 181, 0, 0, 182, 183,
+ 0, 0, 184, 185, 186, 187, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 188, 189, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 183, 184, 0, 0, 0, 0, 0, 0, 0, 433,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 190,
+ 191, 192, 193, 194, 195, 196, 197, 198, 199, 0,
+ 200, 201, 0, 0, 0, 0, 0, 0, 202, 203,
+ -573, -573, -573, -573, -573, -573, -573, -573, -573, 0,
+ 0, 0, 0, 0, 0, 0, -573, 0, -573, -573,
+ -573, -573, 0, -573, 0, 0, 0, -573, -573, -573,
+ -573, -573, -573, -573, 0, 0, -573, 0, 0, 0,
+ 0, 0, 0, 0, 0, -573, -573, -573, -573, -573,
+ -573, -573, -573, -573, 0, -573, -573, -573, 0, 0,
+ -573, 0, 0, -573, -573, 0, -573, -573, -573, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 185, 186, 187, 188, 189, 190, 191,
- 192, 193, 194, 0, 195, 196, 0, 0, 0, 0,
- 0, 0, 197, 125, 126, 127, 128, 129, 130, 131,
- 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
- 142, 143, 144, 145, 146, 147, 148, 0, 0, 0,
- 149, 150, 151, 224, 225, 226, 227, 156, 157, 158,
- 0, 0, 0, 0, 0, 159, 160, 161, 228, 229,
- 230, 231, 166, 0, 0, 232, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, -573, 0, 0,
+ -573, -573, 0, -573, -573, 0, -573, -573, -573, -573,
+ 0, -573, -573, -573, -573, -573, -573, 0, 0, -573,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
- 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
- 184, 0, 0, 0, 233, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, -573,
+ -573, -573, 0, -573, 0, 0, 0, 0, 0, -573,
+ -575, -575, -575, -575, -575, -575, -575, -575, -575, 0,
+ 0, 0, 0, 0, 0, 0, -575, 0, -575, -575,
+ -575, -575, 0, -575, 0, 0, 0, -575, -575, -575,
+ -575, -575, -575, -575, 0, 0, -575, 0, 0, 0,
+ 0, 0, 0, 0, 0, -575, -575, -575, -575, -575,
+ -575, -575, -575, -575, 0, -575, -575, -575, 0, 0,
+ -575, 0, 0, -575, -575, 0, -575, -575, -575, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
- 193, 194, 0, 195, 196, 0, 0, 0, 0, 0,
- 0, 197, 125, 126, 127, 128, 129, 130, 131, 132,
- 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
- 143, 144, 145, 146, 147, 148, 0, 0, 0, 149,
- 150, 151, 224, 225, 226, 227, 156, 157, 158, 0,
- 0, 0, 0, 0, 159, 160, 161, 228, 229, 230,
- 231, 166, 0, 0, 232, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 168,
- 169, 170, 171, 172, 173, 174, 175, 176, 0, 0,
- 177, 178, 0, 0, 179, 180, 181, 182, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 183, 184,
+ 0, 0, 0, 0, 0, 0, 0, -575, 0, 0,
+ -575, -575, 0, -575, -575, 0, -575, -575, -575, -575,
+ 0, -575, -575, -575, -575, -575, -575, 0, 0, -575,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, -575,
+ -575, -575, 0, -575, 0, 0, 0, 0, 0, -575,
+ -574, -574, -574, -574, -574, -574, -574, -574, -574, 0,
+ 0, 0, 0, 0, 0, 0, -574, 0, -574, -574,
+ -574, -574, 0, -574, 0, 0, 0, -574, -574, -574,
+ -574, -574, -574, -574, 0, 0, -574, 0, 0, 0,
+ 0, 0, 0, 0, 0, -574, -574, -574, -574, -574,
+ -574, -574, -574, -574, 0, -574, -574, -574, 0, 0,
+ -574, 0, 0, -574, -574, 0, -574, -574, -574, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 185, 186, 187, 188, 189, 190, 191, 192, 193,
- 194, 0, 195, 196, 0, 0, 0, 0, 0, 0,
- 197, 5, 6, 7, 8, 9, 10, 11, 12, 13,
- 0, 0, 0, 0, 0, 0, 0, 15, 0, 104,
- 105, 18, 19, 0, 0, 0, 0, 0, 106, 107,
- 108, 23, 24, 25, 26, 0, 0, 109, 0, 0,
- 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
- 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
- 0, 43, 0, 0, 44, 45, 0, 112, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, -574, 0, 0,
+ -574, -574, 0, -574, -574, 0, -574, -574, -574, -574,
+ 0, -574, -574, -574, -574, -574, -574, 0, 0, -574,
+ 0, 0, 0, 0, 0, 0, -576, -576, -576, -576,
+ -576, -576, -576, -576, -576, 0, 0, 0, 0, -574,
+ -574, -574, -576, -574, -576, -576, -576, -576, 0, -574,
+ 0, 0, 0, -576, -576, -576, -576, -576, -576, -576,
+ 0, 0, -576, 0, 0, 0, 0, 0, 0, 0,
+ 0, -576, -576, -576, -576, -576, -576, -576, -576, -576,
+ 0, -576, -576, -576, 0, 0, -576, 0, 0, -576,
+ -576, 0, -576, -576, -576, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 302, 0,
- 0, 115, 51, 0, 52, 53, 0, 0, 0, 0,
- 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
- 62, 0, 0, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 0, 0, 0, 0, 0, 0, 0, 15,
- 116, 104, 105, 18, 19, 0, 0, 0, 303, 0,
- 106, 107, 108, 23, 24, 25, 26, 0, 0, 109,
- 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
- 33, 34, 35, 36, 37, 38, 39, 0, 40, 41,
- 42, 0, 0, 43, 0, 0, 44, 45, 0, 112,
+ 0, 0, 0, -576, 815, 0, -576, -576, 0, -576,
+ -576, 0, -576, -576, -576, -576, 0, -576, -576, -576,
+ -576, -576, -576, 0, 0, -576, 0, 0, 0, 0,
+ 0, 0, -107, -577, -577, -577, -577, -577, -577, -577,
+ -577, -577, 0, 0, 0, -576, -576, -576, 0, -577,
+ 0, -577, -577, -577, -577, -576, 0, 0, 0, 0,
+ -577, -577, -577, -577, -577, -577, -577, 0, 0, -577,
+ 0, 0, 0, 0, 0, 0, 0, 0, -577, -577,
+ -577, -577, -577, -577, -577, -577, -577, 0, -577, -577,
+ -577, 0, 0, -577, 0, 0, -577, -577, 0, -577,
+ -577, -577, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ -577, 816, 0, -577, -577, 0, -577, -577, 0, -577,
+ -577, -577, -577, 0, -577, -577, -577, -577, -577, -577,
+ 0, 0, -577, 0, 0, 0, 0, 0, 0, -109,
+ -265, -265, -265, -265, -265, -265, -265, -265, -265, 0,
+ 0, 0, -577, -577, -577, 0, -265, 0, -265, -265,
+ -265, -265, -577, 0, 0, 0, 0, -265, -265, -265,
+ -265, -265, -265, -265, 0, 0, -265, 0, 0, 0,
+ 0, 0, 0, 0, 0, -265, -265, -265, -265, -265,
+ -265, -265, -265, -265, 0, -265, -265, -265, 0, 0,
+ -265, 0, 0, -265, -265, 0, -265, -265, -265, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 302, 0, 0, 115, 51, 0, 52, 53, 0, 0,
- 0, 0, 55, 0, 56, 57, 58, 59, 60, 61,
- 0, 0, 62, 0, 0, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 14, 0, 0, 0, 0, 0,
- 0, 15, 116, 16, 17, 18, 19, 0, 0, 0,
- 557, 0, 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,
- 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, -265, 0, 0,
+ -265, -265, 0, -265, -265, 0, -265, -265, -265, -265,
+ 0, -265, -265, -265, -265, -265, -265, 0, 0, -265,
+ 0, 0, 0, 0, 0, 0, -578, -578, -578, -578,
+ -578, -578, -578, -578, -578, 0, 0, 0, 0, -265,
+ -265, -265, -578, 0, -578, -578, -578, -578, 0, 272,
+ 0, 0, 0, -578, -578, -578, -578, -578, -578, -578,
+ 0, 0, -578, 0, 0, 0, 0, 0, 0, 0,
+ 0, -578, -578, -578, -578, -578, -578, -578, -578, -578,
+ 0, -578, -578, -578, 0, 0, -578, 0, 0, -578,
+ -578, 0, -578, -578, -578, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 49, 0, 0, 50, 51, 0, 52, 53,
- 0, 54, 0, 0, 55, 0, 56, 57, 58, 59,
- 60, 61, 0, 0, 62, 0, 0, 0, 0, 0,
- 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
- 0, 0, 0, 0, 63, 64, 65, 15, 0, 16,
- 17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
- 22, 23, 24, 25, 26, 0, 0, 109, 0, 0,
- 0, 0, 0, 0, 0, 0, 31, 32, 33, 251,
- 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
- 0, 43, 0, 0, 44, 45, 0, 46, 47, 48,
+ 0, 0, 0, -578, 0, 0, -578, -578, 0, -578,
+ -578, 0, -578, -578, -578, -578, 0, -578, -578, -578,
+ -578, -578, -578, 0, 0, -578, 0, 0, 0, 0,
+ 0, 0, -579, -579, -579, -579, -579, -579, -579, -579,
+ -579, 0, 0, 0, 0, -578, -578, -578, -579, 0,
+ -579, -579, -579, -579, 0, -578, 0, 0, 0, -579,
+ -579, -579, -579, -579, -579, -579, 0, 0, -579, 0,
+ 0, 0, 0, 0, 0, 0, 0, -579, -579, -579,
+ -579, -579, -579, -579, -579, -579, 0, -579, -579, -579,
+ 0, 0, -579, 0, 0, -579, -579, 0, -579, -579,
+ -579, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, -579,
+ 0, 0, -579, -579, 0, -579, -579, 0, -579, -579,
+ -579, -579, 0, -579, -579, -579, -579, -579, -579, 0,
+ 0, -579, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 455, 0, 0, 0, 0, 0, 205, 0,
- 0, 115, 51, 0, 52, 53, 0, 252, 253, 254,
- 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
- 62, 0, 0, 0, 0, 0, 0, 5, 6, 7,
- 8, 9, 10, 11, 12, 13, 14, 0, 0, 0,
- 63, 255, 65, 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, 0, 40, 41, 42, 0, 0, 43, 0, 0,
- 44, 45, 0, 46, 47, 48, 0, 0, 0, 0,
+ 0, -579, -579, -579, 0, 0, 0, 0, 0, 0,
+ 0, -579, 130, 131, 132, 133, 134, 135, 136, 137,
+ 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
+ 148, 149, 150, 151, 152, 153, 0, 0, 0, 154,
+ 155, 156, 230, 231, 232, 233, 161, 162, 163, 0,
+ 0, 0, 0, 0, 164, 165, 166, 234, 235, 236,
+ 237, 171, 315, 316, 238, 317, 0, 0, 0, 0,
+ 0, 0, 318, 0, 0, 0, 0, 0, 0, 173,
+ 174, 175, 176, 177, 178, 179, 180, 181, 0, 0,
+ 182, 183, 0, 0, 184, 185, 186, 187, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 188, 189,
+ 0, 0, 0, 0, 0, 0, 0, 319, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 49, 0, 0, 50, 51, 0,
- 52, 53, 0, 54, 0, 0, 55, 0, 56, 57,
- 58, 59, 60, 61, 0, 0, 62, 0, 0, 0,
- 0, 0, 0, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 0, 0, 0, 0, 63, 64, 65, 15,
- 0, 16, 17, 18, 19, 0, 0, 0, 0, 0,
- 20, 21, 22, 23, 24, 25, 26, 0, 0, 109,
- 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
- 33, 251, 35, 36, 37, 38, 39, 0, 40, 41,
- 42, 0, 0, 43, 0, 0, 44, 45, 0, 46,
- 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 190, 191, 192, 193, 194, 195, 196, 197, 198,
+ 199, 0, 200, 201, 0, 0, 0, 0, 0, 0,
+ 202, 130, 131, 132, 133, 134, 135, 136, 137, 138,
+ 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
+ 149, 150, 151, 152, 153, 0, 0, 0, 154, 155,
+ 156, 230, 231, 232, 233, 161, 162, 163, 0, 0,
+ 0, 0, 0, 164, 165, 166, 234, 235, 236, 237,
+ 171, 315, 316, 238, 317, 0, 0, 0, 0, 0,
+ 0, 318, 0, 0, 0, 0, 0, 0, 173, 174,
+ 175, 176, 177, 178, 179, 180, 181, 0, 0, 182,
+ 183, 0, 0, 184, 185, 186, 187, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 188, 189, 0,
+ 0, 0, 0, 0, 0, 0, 477, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 205, 0, 0, 115, 51, 0, 52, 53, 0, 252,
- 253, 254, 55, 0, 56, 57, 58, 59, 60, 61,
- 0, 0, 62, 0, 0, 0, 0, 0, 0, 5,
- 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
- 0, 0, 63, 255, 65, 15, 0, 104, 105, 18,
- 19, 0, 0, 0, 0, 0, 106, 107, 108, 23,
- 24, 25, 26, 0, 0, 109, 0, 0, 0, 0,
- 0, 0, 0, 0, 31, 32, 33, 251, 35, 36,
- 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
- 0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
+ 190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
+ 0, 200, 201, 0, 0, 0, 0, 0, 0, 202,
+ 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
+ 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
+ 150, 151, 152, 153, 0, 0, 0, 154, 155, 156,
+ 230, 231, 232, 233, 161, 162, 163, 0, 0, 0,
+ 0, 0, 164, 165, 166, 234, 235, 236, 237, 171,
+ 0, 0, 238, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
+ 176, 177, 178, 179, 180, 181, 0, 0, 182, 183,
+ 0, 0, 184, 185, 186, 187, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 188, 189, 0, 0,
+ 0, 239, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 190,
+ 191, 192, 193, 194, 195, 196, 197, 198, 199, 0,
+ 200, 201, 0, 0, 0, 0, 0, 0, 202, 130,
+ 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
+ 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
+ 151, 152, 153, 0, 0, 0, 154, 155, 156, 230,
+ 231, 232, 233, 161, 162, 163, 0, 0, 0, 0,
+ 0, 164, 165, 166, 234, 235, 236, 237, 171, 0,
+ 0, 238, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 173, 174, 175, 176,
+ 177, 178, 179, 180, 181, 0, 0, 182, 183, 0,
+ 0, 184, 185, 186, 187, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 188, 189, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 205, 0, 0, 115,
- 51, 0, 52, 53, 0, 666, 253, 254, 55, 0,
- 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
- 0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 0, 0, 0, 0, 63, 255,
- 65, 15, 0, 104, 105, 18, 19, 0, 0, 0,
- 0, 0, 106, 107, 108, 23, 24, 25, 26, 0,
- 0, 109, 0, 0, 0, 0, 0, 0, 0, 0,
- 31, 32, 33, 251, 35, 36, 37, 38, 39, 0,
- 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
- 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 190, 191,
+ 192, 193, 194, 195, 196, 197, 198, 199, 0, 200,
+ 201, 0, 0, 0, 0, 0, 0, 202, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 0, 0, 0,
+ 0, 0, 0, 0, 15, 0, 107, 108, 18, 19,
+ 0, 0, 0, 0, 0, 109, 110, 111, 23, 24,
+ 25, 26, 0, 0, 112, 0, 0, 0, 0, 0,
+ 0, 0, 0, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 0, 40, 41, 42, 0, 0, 43, 0,
+ 0, 44, 45, 0, 115, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 205, 0, 0, 115, 51, 0, 52, 53,
- 0, 252, 253, 0, 55, 0, 56, 57, 58, 59,
- 60, 61, 0, 0, 62, 0, 0, 0, 0, 0,
- 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
- 0, 0, 0, 0, 63, 255, 65, 15, 0, 104,
- 105, 18, 19, 0, 0, 0, 0, 0, 106, 107,
- 108, 23, 24, 25, 26, 0, 0, 109, 0, 0,
- 0, 0, 0, 0, 0, 0, 31, 32, 33, 251,
- 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
- 0, 43, 0, 0, 44, 45, 0, 46, 47, 48,
+ 0, 0, 0, 0, 0, 308, 0, 0, 118, 51,
+ 0, 52, 53, 0, 0, 0, 0, 55, 0, 56,
+ 57, 58, 59, 60, 61, 0, 0, 62, 0, 0,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 0,
+ 0, 0, 0, 0, 0, 0, 15, 119, 107, 108,
+ 18, 19, 0, 0, 0, 309, 0, 109, 110, 111,
+ 23, 24, 25, 26, 0, 0, 112, 0, 0, 0,
+ 0, 0, 0, 0, 0, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 0, 40, 41, 42, 0, 0,
+ 43, 0, 0, 44, 45, 0, 115, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 205, 0,
- 0, 115, 51, 0, 52, 53, 0, 0, 253, 254,
- 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
- 62, 0, 0, 0, 0, 0, 0, 5, 6, 7,
- 8, 9, 10, 11, 12, 13, 0, 0, 0, 0,
- 63, 255, 65, 15, 0, 104, 105, 18, 19, 0,
- 0, 0, 0, 0, 106, 107, 108, 23, 24, 25,
- 26, 0, 0, 109, 0, 0, 0, 0, 0, 0,
- 0, 0, 31, 32, 33, 251, 35, 36, 37, 38,
- 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
- 44, 45, 0, 46, 47, 48, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 308, 0, 0,
+ 118, 51, 0, 52, 53, 0, 0, 0, 0, 55,
+ 0, 56, 57, 58, 59, 60, 61, 0, 0, 62,
+ 0, 0, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 14, 0, 0, 0, 0, 0, 0, 15, 119,
+ 16, 17, 18, 19, 0, 0, 0, 599, 0, 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, 0, 46, 47,
+ 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
+ 0, 0, 50, 51, 0, 52, 53, 0, 54, 0,
+ 0, 55, 0, 56, 57, 58, 59, 60, 61, 0,
+ 0, 62, 0, 0, 0, 0, 0, 0, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 0, 0, 0,
+ 0, 63, 64, 65, 15, 0, 16, 17, 18, 19,
+ 0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
+ 25, 26, 0, 0, 112, 0, 0, 0, 0, 0,
+ 0, 0, 0, 31, 32, 33, 257, 35, 36, 37,
+ 38, 39, 0, 40, 41, 42, 0, 0, 43, 0,
+ 0, 44, 45, 0, 46, 47, 48, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 499,
+ 0, 0, 0, 0, 0, 210, 0, 0, 118, 51,
+ 0, 52, 53, 0, 258, 259, 260, 55, 0, 56,
+ 57, 58, 59, 60, 61, 0, 0, 62, 0, 0,
+ 0, 0, 0, 0, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 0, 0, 0, 63, 261, 65,
+ 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, 0, 40,
+ 41, 42, 0, 0, 43, 0, 0, 44, 45, 0,
+ 46, 47, 48, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 205, 0, 0, 115, 51, 0,
- 52, 53, 0, 666, 253, 0, 55, 0, 56, 57,
- 58, 59, 60, 61, 0, 0, 62, 0, 0, 0,
- 0, 0, 0, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 0, 0, 0, 0, 63, 255, 65, 15,
- 0, 104, 105, 18, 19, 0, 0, 0, 0, 0,
- 106, 107, 108, 23, 24, 25, 26, 0, 0, 109,
- 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
- 33, 251, 35, 36, 37, 38, 39, 0, 40, 41,
- 42, 0, 0, 43, 0, 0, 44, 45, 0, 46,
- 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 49, 0, 0, 50, 51, 0, 52, 53, 0,
+ 54, 0, 0, 55, 0, 56, 57, 58, 59, 60,
+ 61, 0, 0, 62, 0, 0, 0, 0, 0, 0,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 0,
+ 0, 0, 0, 63, 64, 65, 15, 0, 16, 17,
+ 18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
+ 23, 24, 25, 26, 0, 0, 112, 0, 0, 0,
+ 0, 0, 0, 0, 0, 31, 32, 33, 257, 35,
+ 36, 37, 38, 39, 0, 40, 41, 42, 0, 0,
+ 43, 0, 0, 44, 45, 0, 46, 47, 48, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 205, 0, 0, 115, 51, 0, 52, 53, 0, 0,
- 253, 0, 55, 0, 56, 57, 58, 59, 60, 61,
- 0, 0, 62, 0, 0, 0, 0, 0, 0, 5,
- 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
- 0, 0, 63, 255, 65, 15, 0, 16, 17, 18,
- 19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
- 24, 25, 26, 0, 0, 109, 0, 0, 0, 0,
- 0, 0, 0, 0, 31, 32, 33, 34, 35, 36,
- 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
- 0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 210, 0, 0,
+ 118, 51, 0, 52, 53, 0, 258, 259, 260, 55,
+ 0, 56, 57, 58, 59, 60, 61, 0, 0, 62,
+ 0, 0, 0, 0, 0, 0, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 0, 0, 0, 0, 63,
+ 261, 65, 15, 0, 107, 108, 18, 19, 0, 0,
+ 0, 0, 0, 109, 110, 111, 23, 24, 25, 26,
+ 0, 0, 112, 0, 0, 0, 0, 0, 0, 0,
+ 0, 31, 32, 33, 257, 35, 36, 37, 38, 39,
+ 0, 40, 41, 42, 0, 0, 43, 0, 0, 44,
+ 45, 0, 46, 47, 48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 205, 0, 0, 115,
- 51, 0, 52, 53, 0, 551, 0, 0, 55, 0,
- 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
- 0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 0, 0, 0, 0, 63, 255,
- 65, 15, 0, 104, 105, 18, 19, 0, 0, 0,
- 0, 0, 106, 107, 108, 23, 24, 25, 26, 0,
- 0, 109, 0, 0, 0, 0, 0, 0, 0, 0,
- 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
- 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
- 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 210, 0, 0, 118, 51, 0, 52,
+ 53, 0, 709, 259, 260, 55, 0, 56, 57, 58,
+ 59, 60, 61, 0, 0, 62, 0, 0, 0, 0,
+ 0, 0, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 0, 0, 0, 0, 63, 261, 65, 15, 0,
+ 107, 108, 18, 19, 0, 0, 0, 0, 0, 109,
+ 110, 111, 23, 24, 25, 26, 0, 0, 112, 0,
+ 0, 0, 0, 0, 0, 0, 0, 31, 32, 33,
+ 257, 35, 36, 37, 38, 39, 0, 40, 41, 42,
+ 0, 0, 43, 0, 0, 44, 45, 0, 46, 47,
+ 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 210,
+ 0, 0, 118, 51, 0, 52, 53, 0, 258, 259,
+ 0, 55, 0, 56, 57, 58, 59, 60, 61, 0,
+ 0, 62, 0, 0, 0, 0, 0, 0, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 0, 0, 0,
+ 0, 63, 261, 65, 15, 0, 107, 108, 18, 19,
+ 0, 0, 0, 0, 0, 109, 110, 111, 23, 24,
+ 25, 26, 0, 0, 112, 0, 0, 0, 0, 0,
+ 0, 0, 0, 31, 32, 33, 257, 35, 36, 37,
+ 38, 39, 0, 40, 41, 42, 0, 0, 43, 0,
+ 0, 44, 45, 0, 46, 47, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 205, 0, 0, 115, 51, 0, 52, 53,
- 0, 252, 0, 0, 55, 0, 56, 57, 58, 59,
- 60, 61, 0, 0, 62, 0, 0, 0, 0, 0,
- 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
- 0, 0, 0, 0, 63, 255, 65, 15, 0, 104,
- 105, 18, 19, 0, 0, 0, 0, 0, 106, 107,
- 108, 23, 24, 25, 26, 0, 0, 109, 0, 0,
- 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
- 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
- 0, 43, 0, 0, 44, 45, 0, 46, 47, 48,
+ 0, 0, 0, 0, 0, 210, 0, 0, 118, 51,
+ 0, 52, 53, 0, 0, 259, 260, 55, 0, 56,
+ 57, 58, 59, 60, 61, 0, 0, 62, 0, 0,
+ 0, 0, 0, 0, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 0, 0, 0, 0, 63, 261, 65,
+ 15, 0, 107, 108, 18, 19, 0, 0, 0, 0,
+ 0, 109, 110, 111, 23, 24, 25, 26, 0, 0,
+ 112, 0, 0, 0, 0, 0, 0, 0, 0, 31,
+ 32, 33, 257, 35, 36, 37, 38, 39, 0, 40,
+ 41, 42, 0, 0, 43, 0, 0, 44, 45, 0,
+ 46, 47, 48, 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, 205, 0,
- 0, 115, 51, 0, 52, 53, 0, 551, 0, 0,
- 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
- 62, 0, 0, 0, 0, 0, 0, 5, 6, 7,
- 8, 9, 10, 11, 12, 13, 0, 0, 0, 0,
- 63, 255, 65, 15, 0, 104, 105, 18, 19, 0,
- 0, 0, 0, 0, 106, 107, 108, 23, 24, 25,
- 26, 0, 0, 109, 0, 0, 0, 0, 0, 0,
- 0, 0, 31, 32, 33, 34, 35, 36, 37, 38,
- 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
- 44, 45, 0, 46, 47, 48, 0, 0, 0, 0,
+ 0, 210, 0, 0, 118, 51, 0, 52, 53, 0,
+ 709, 259, 0, 55, 0, 56, 57, 58, 59, 60,
+ 61, 0, 0, 62, 0, 0, 0, 0, 0, 0,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 0,
+ 0, 0, 0, 63, 261, 65, 15, 0, 107, 108,
+ 18, 19, 0, 0, 0, 0, 0, 109, 110, 111,
+ 23, 24, 25, 26, 0, 0, 112, 0, 0, 0,
+ 0, 0, 0, 0, 0, 31, 32, 33, 257, 35,
+ 36, 37, 38, 39, 0, 40, 41, 42, 0, 0,
+ 43, 0, 0, 44, 45, 0, 46, 47, 48, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 205, 0, 0, 115, 51, 0,
- 52, 53, 0, 831, 0, 0, 55, 0, 56, 57,
- 58, 59, 60, 61, 0, 0, 62, 0, 0, 0,
- 0, 0, 0, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 0, 0, 0, 0, 63, 255, 65, 15,
- 0, 104, 105, 18, 19, 0, 0, 0, 0, 0,
- 106, 107, 108, 23, 24, 25, 26, 0, 0, 109,
- 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
- 33, 34, 35, 36, 37, 38, 39, 0, 40, 41,
- 42, 0, 0, 43, 0, 0, 44, 45, 0, 46,
- 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 210, 0, 0,
+ 118, 51, 0, 52, 53, 0, 0, 259, 0, 55,
+ 0, 56, 57, 58, 59, 60, 61, 0, 0, 62,
+ 0, 0, 0, 0, 0, 0, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 0, 0, 0, 0, 63,
+ 261, 65, 15, 0, 16, 17, 18, 19, 0, 0,
+ 0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
+ 0, 0, 112, 0, 0, 0, 0, 0, 0, 0,
+ 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 0, 40, 41, 42, 0, 0, 43, 0, 0, 44,
+ 45, 0, 46, 47, 48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 205, 0, 0, 115, 51, 0, 52, 53, 0, 666,
- 0, 0, 55, 0, 56, 57, 58, 59, 60, 61,
- 0, 0, 62, 0, 0, 0, 0, 0, 0, 5,
- 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
- 0, 0, 63, 255, 65, 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, 0, 0, 0, 31, 32, 33, 34, 35, 36,
- 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
- 0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
+ 0, 0, 0, 210, 0, 0, 118, 51, 0, 52,
+ 53, 0, 593, 0, 0, 55, 0, 56, 57, 58,
+ 59, 60, 61, 0, 0, 62, 0, 0, 0, 0,
+ 0, 0, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 0, 0, 0, 0, 63, 261, 65, 15, 0,
+ 107, 108, 18, 19, 0, 0, 0, 0, 0, 109,
+ 110, 111, 23, 24, 25, 26, 0, 0, 112, 0,
+ 0, 0, 0, 0, 0, 0, 0, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
+ 0, 0, 43, 0, 0, 44, 45, 0, 46, 47,
+ 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 210,
+ 0, 0, 118, 51, 0, 52, 53, 0, 258, 0,
+ 0, 55, 0, 56, 57, 58, 59, 60, 61, 0,
+ 0, 62, 0, 0, 0, 0, 0, 0, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 0, 0, 0,
+ 0, 63, 261, 65, 15, 0, 107, 108, 18, 19,
+ 0, 0, 0, 0, 0, 109, 110, 111, 23, 24,
+ 25, 26, 0, 0, 112, 0, 0, 0, 0, 0,
+ 0, 0, 0, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 0, 40, 41, 42, 0, 0, 43, 0,
+ 0, 44, 45, 0, 46, 47, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 205, 0, 0, 115,
- 51, 0, 52, 53, 0, 0, 0, 0, 55, 0,
- 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
- 0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 0, 0, 0, 0, 63, 64,
- 65, 15, 0, 104, 105, 18, 19, 0, 0, 0,
- 0, 0, 106, 107, 108, 23, 24, 25, 26, 0,
- 0, 109, 0, 0, 0, 0, 0, 0, 0, 0,
- 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
- 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
- 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 210, 0, 0, 118, 51,
+ 0, 52, 53, 0, 593, 0, 0, 55, 0, 56,
+ 57, 58, 59, 60, 61, 0, 0, 62, 0, 0,
+ 0, 0, 0, 0, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 0, 0, 0, 0, 63, 261, 65,
+ 15, 0, 107, 108, 18, 19, 0, 0, 0, 0,
+ 0, 109, 110, 111, 23, 24, 25, 26, 0, 0,
+ 112, 0, 0, 0, 0, 0, 0, 0, 0, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
+ 41, 42, 0, 0, 43, 0, 0, 44, 45, 0,
+ 46, 47, 48, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 205, 0, 0, 115, 51, 0, 52, 53,
- 0, 0, 0, 0, 55, 0, 56, 57, 58, 59,
- 60, 61, 0, 0, 62, 0, 0, 0, 0, 0,
- 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
- 0, 0, 0, 0, 63, 255, 65, 15, 0, 16,
- 17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
- 22, 23, 24, 25, 26, 0, 0, 109, 0, 0,
- 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
- 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
- 0, 43, 0, 0, 44, 45, 0, 46, 47, 48,
+ 0, 210, 0, 0, 118, 51, 0, 52, 53, 0,
+ 874, 0, 0, 55, 0, 56, 57, 58, 59, 60,
+ 61, 0, 0, 62, 0, 0, 0, 0, 0, 0,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 0,
+ 0, 0, 0, 63, 261, 65, 15, 0, 107, 108,
+ 18, 19, 0, 0, 0, 0, 0, 109, 110, 111,
+ 23, 24, 25, 26, 0, 0, 112, 0, 0, 0,
+ 0, 0, 0, 0, 0, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 0, 40, 41, 42, 0, 0,
+ 43, 0, 0, 44, 45, 0, 46, 47, 48, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 205, 0,
- 0, 115, 51, 0, 52, 53, 0, 0, 0, 0,
- 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
- 62, 0, 0, 0, 0, 0, 0, 5, 6, 7,
- 8, 9, 10, 11, 12, 13, 0, 0, 0, 0,
- 63, 255, 65, 15, 0, 104, 105, 18, 19, 0,
- 0, 0, 0, 0, 106, 107, 108, 23, 24, 25,
- 26, 0, 0, 109, 0, 0, 0, 0, 0, 0,
- 0, 0, 31, 32, 33, 110, 35, 36, 37, 111,
- 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
- 44, 45, 0, 112, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 210, 0, 0,
+ 118, 51, 0, 52, 53, 0, 709, 0, 0, 55,
+ 0, 56, 57, 58, 59, 60, 61, 0, 0, 62,
+ 0, 0, 0, 0, 0, 0, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 0, 0, 0, 0, 63,
+ 261, 65, 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, 0, 0,
+ 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 0, 40, 41, 42, 0, 0, 43, 0, 0, 44,
+ 45, 0, 46, 47, 48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 113, 0, 0, 114, 0, 0, 115, 51, 0,
- 52, 53, 0, 0, 0, 0, 55, 0, 56, 57,
- 58, 59, 60, 61, 0, 0, 62, 0, 0, 5,
- 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
- 0, 0, 0, 0, 0, 15, 116, 104, 105, 18,
- 19, 0, 0, 0, 0, 0, 106, 107, 108, 23,
- 24, 25, 26, 0, 0, 109, 0, 0, 0, 0,
- 0, 0, 0, 0, 31, 32, 33, 34, 35, 36,
- 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
- 0, 0, 44, 45, 0, 216, 0, 0, 0, 0,
+ 0, 0, 0, 210, 0, 0, 118, 51, 0, 52,
+ 53, 0, 0, 0, 0, 55, 0, 56, 57, 58,
+ 59, 60, 61, 0, 0, 62, 0, 0, 0, 0,
+ 0, 0, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 0, 0, 0, 0, 63, 64, 65, 15, 0,
+ 107, 108, 18, 19, 0, 0, 0, 0, 0, 109,
+ 110, 111, 23, 24, 25, 26, 0, 0, 112, 0,
+ 0, 0, 0, 0, 0, 0, 0, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
+ 0, 0, 43, 0, 0, 44, 45, 0, 46, 47,
+ 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 210,
+ 0, 0, 118, 51, 0, 52, 53, 0, 0, 0,
+ 0, 55, 0, 56, 57, 58, 59, 60, 61, 0,
+ 0, 62, 0, 0, 0, 0, 0, 0, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 0, 0, 0,
+ 0, 63, 261, 65, 15, 0, 16, 17, 18, 19,
+ 0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
+ 25, 26, 0, 0, 112, 0, 0, 0, 0, 0,
+ 0, 0, 0, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 0, 40, 41, 42, 0, 0, 43, 0,
+ 0, 44, 45, 0, 46, 47, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 217, 0, 0, 50,
- 51, 0, 52, 53, 0, 54, 0, 0, 55, 0,
- 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
- 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
- 0, 0, 0, 0, 0, 0, 0, 15, 116, 104,
- 105, 18, 19, 0, 0, 0, 0, 0, 106, 107,
- 108, 23, 24, 25, 26, 0, 0, 109, 0, 0,
- 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
- 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
- 0, 43, 0, 0, 44, 45, 0, 112, 0, 0,
+ 0, 0, 0, 0, 0, 210, 0, 0, 118, 51,
+ 0, 52, 53, 0, 0, 0, 0, 55, 0, 56,
+ 57, 58, 59, 60, 61, 0, 0, 62, 0, 0,
+ 0, 0, 0, 0, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 0, 0, 0, 0, 63, 261, 65,
+ 15, 0, 107, 108, 18, 19, 0, 0, 0, 0,
+ 0, 109, 110, 111, 23, 24, 25, 26, 0, 0,
+ 112, 0, 0, 0, 0, 0, 0, 0, 0, 31,
+ 32, 33, 113, 35, 36, 37, 114, 39, 0, 40,
+ 41, 42, 0, 0, 43, 0, 0, 44, 45, 0,
+ 115, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 116, 0,
+ 0, 117, 0, 0, 118, 51, 0, 52, 53, 0,
+ 0, 0, 0, 55, 0, 56, 57, 58, 59, 60,
+ 61, 0, 0, 62, 0, 0, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 0, 0, 0, 0, 0,
+ 0, 0, 15, 119, 107, 108, 18, 19, 0, 0,
+ 0, 0, 0, 109, 110, 111, 23, 24, 25, 26,
+ 0, 0, 112, 0, 0, 0, 0, 0, 0, 0,
+ 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 0, 40, 41, 42, 0, 0, 43, 0, 0, 44,
+ 45, 0, 222, 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, 302, 0,
- 0, 349, 51, 0, 52, 53, 0, 350, 0, 0,
- 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
- 62, 0, 0, 5, 6, 7, 8, 9, 10, 11,
- 12, 13, 0, 0, 0, 0, 0, 0, 0, 15,
- 116, 104, 105, 18, 19, 0, 0, 0, 0, 0,
- 106, 107, 108, 23, 24, 25, 26, 0, 0, 109,
- 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
- 33, 110, 35, 36, 37, 111, 39, 0, 40, 41,
- 42, 0, 0, 43, 0, 0, 44, 45, 0, 112,
+ 0, 0, 0, 223, 0, 0, 50, 51, 0, 52,
+ 53, 0, 54, 0, 0, 55, 0, 56, 57, 58,
+ 59, 60, 61, 0, 0, 62, 0, 0, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 0, 0, 0,
+ 0, 0, 0, 0, 15, 119, 107, 108, 18, 19,
+ 0, 0, 0, 0, 0, 109, 110, 111, 23, 24,
+ 25, 26, 0, 0, 112, 0, 0, 0, 0, 0,
+ 0, 0, 0, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 0, 40, 41, 42, 0, 0, 43, 0,
+ 0, 44, 45, 0, 115, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 308, 0, 0, 392, 51,
+ 0, 52, 53, 0, 393, 0, 0, 55, 0, 56,
+ 57, 58, 59, 60, 61, 0, 0, 62, 0, 0,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 0,
+ 0, 0, 0, 0, 0, 0, 15, 119, 107, 108,
+ 18, 19, 0, 0, 0, 0, 0, 109, 110, 111,
+ 23, 24, 25, 26, 0, 0, 112, 0, 0, 0,
+ 0, 0, 0, 0, 0, 31, 32, 33, 113, 35,
+ 36, 37, 114, 39, 0, 40, 41, 42, 0, 0,
+ 43, 0, 0, 44, 45, 0, 115, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 114, 0, 0, 115, 51, 0, 52, 53, 0, 0,
- 0, 0, 55, 0, 56, 57, 58, 59, 60, 61,
- 0, 0, 62, 0, 0, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 0, 0, 0, 0, 0, 0,
- 0, 15, 116, 104, 105, 18, 19, 0, 0, 0,
- 0, 0, 106, 107, 108, 23, 24, 25, 26, 0,
- 0, 109, 0, 0, 0, 0, 0, 0, 0, 0,
- 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
- 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
- 0, 112, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 117, 0, 0,
+ 118, 51, 0, 52, 53, 0, 0, 0, 0, 55,
+ 0, 56, 57, 58, 59, 60, 61, 0, 0, 62,
+ 0, 0, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 0, 0, 0, 0, 0, 0, 0, 15, 119,
+ 107, 108, 18, 19, 0, 0, 0, 0, 0, 109,
+ 110, 111, 23, 24, 25, 26, 0, 0, 112, 0,
+ 0, 0, 0, 0, 0, 0, 0, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
+ 0, 0, 43, 0, 0, 44, 45, 0, 115, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 302, 0, 0, 349, 51, 0, 52, 53,
- 0, 0, 0, 0, 55, 0, 56, 57, 58, 59,
- 60, 61, 0, 0, 62, 0, 0, 5, 6, 7,
- 8, 9, 10, 11, 12, 13, 0, 0, 0, 0,
- 0, 0, 0, 15, 116, 104, 105, 18, 19, 0,
- 0, 0, 0, 0, 106, 107, 108, 23, 24, 25,
- 26, 0, 0, 109, 0, 0, 0, 0, 0, 0,
- 0, 0, 31, 32, 33, 34, 35, 36, 37, 38,
- 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
- 44, 45, 0, 112, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 308,
+ 0, 0, 392, 51, 0, 52, 53, 0, 0, 0,
+ 0, 55, 0, 56, 57, 58, 59, 60, 61, 0,
+ 0, 62, 0, 0, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 0, 0, 0, 0, 0, 0, 0,
+ 15, 119, 107, 108, 18, 19, 0, 0, 0, 0,
+ 0, 109, 110, 111, 23, 24, 25, 26, 0, 0,
+ 112, 0, 0, 0, 0, 0, 0, 0, 0, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
+ 41, 42, 0, 0, 43, 0, 0, 44, 45, 0,
+ 115, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 904, 0, 0, 115, 51, 0,
- 52, 53, 0, 0, 0, 0, 55, 0, 56, 57,
- 58, 59, 60, 61, 0, 0, 62, 0, 0, 5,
- 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
- 0, 0, 0, 0, 0, 15, 116, 104, 105, 18,
- 19, 0, 0, 0, 0, 0, 106, 107, 108, 23,
- 24, 25, 26, 0, 0, 109, 0, 0, 0, 0,
- 0, 0, 0, 0, 31, 32, 33, 34, 35, 36,
- 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
- 0, 0, 44, 45, 0, 216, 0, 0, 0, 0,
+ 0, 937, 0, 0, 118, 51, 0, 52, 53, 0,
+ 0, 0, 0, 55, 0, 56, 57, 58, 59, 60,
+ 61, 0, 0, 62, 0, 0, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 0, 0, 0, 0, 0,
+ 0, 0, 15, 119, 107, 108, 18, 19, 0, 0,
+ 0, 0, 0, 109, 110, 111, 23, 24, 25, 26,
+ 0, 0, 112, 0, 0, 0, 0, 0, 0, 0,
+ 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 0, 40, 41, 42, 0, 0, 43, 0, 0, 44,
+ 45, 0, 222, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 931, 0, 0, 115,
- 51, 0, 52, 53, 0, 595, 596, 0, 55, 597,
- 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
- 0, 0, 0, 0, 168, 169, 170, 171, 172, 173,
- 174, 175, 176, 0, 0, 177, 178, 0, 116, 179,
- 180, 181, 182, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 183, 184, 0, 0, 0, 0, 0,
+ 0, 0, 0, 960, 0, 0, 118, 51, 0, 52,
+ 53, 0, 647, 648, 0, 55, 649, 56, 57, 58,
+ 59, 60, 61, 0, 0, 62, 0, 0, 0, 0,
+ 0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
+ 0, 0, 182, 183, 0, 119, 184, 185, 186, 187,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 185, 186, 187, 188,
- 189, 190, 191, 192, 193, 194, 0, 195, 196, 603,
- 604, 0, 0, 605, 0, 197, 266, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 168, 169,
- 170, 171, 172, 173, 174, 175, 176, 0, 0, 177,
- 178, 0, 0, 179, 180, 181, 182, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 183, 184, 0,
+ 188, 189, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 190, 191, 192, 193, 194, 195, 196,
+ 197, 198, 199, 0, 200, 201, 668, 640, 0, 0,
+ 669, 0, 202, 272, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 173, 174, 175, 176, 177,
+ 178, 179, 180, 181, 0, 0, 182, 183, 0, 0,
+ 184, 185, 186, 187, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 188, 189, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
- 0, 195, 196, 624, 596, 0, 0, 625, 0, 197,
- 266, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 168, 169, 170, 171, 172, 173, 174, 175,
- 176, 0, 0, 177, 178, 0, 0, 179, 180, 181,
- 182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 183, 184, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 190, 191, 192,
+ 193, 194, 195, 196, 197, 198, 199, 0, 200, 201,
+ 653, 648, 0, 0, 654, 0, 202, 272, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
+ 174, 175, 176, 177, 178, 179, 180, 181, 0, 0,
+ 182, 183, 0, 0, 184, 185, 186, 187, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 188, 189,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 185, 186, 187, 188, 189, 190,
- 191, 192, 193, 194, 0, 195, 196, 609, 604, 0,
- 0, 610, 0, 197, 266, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 168, 169, 170, 171,
- 172, 173, 174, 175, 176, 0, 0, 177, 178, 0,
- 0, 179, 180, 181, 182, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 183, 184, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 185, 186,
- 187, 188, 189, 190, 191, 192, 193, 194, 0, 195,
- 196, 640, 596, 0, 0, 641, 0, 197, 266, 0,
+ 0, 190, 191, 192, 193, 194, 195, 196, 197, 198,
+ 199, 0, 200, 201, 683, 640, 0, 0, 684, 0,
+ 202, 272, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
+ 180, 181, 0, 0, 182, 183, 0, 0, 184, 185,
+ 186, 187, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 188, 189, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
- 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
- 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 190, 191, 192, 193, 194,
+ 195, 196, 197, 198, 199, 0, 200, 201, 686, 648,
+ 0, 0, 687, 0, 202, 272, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
+ 176, 177, 178, 179, 180, 181, 0, 0, 182, 183,
+ 0, 0, 184, 185, 186, 187, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 188, 189, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
- 193, 194, 0, 195, 196, 643, 604, 0, 0, 644,
- 0, 197, 266, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 168, 169, 170, 171, 172, 173,
- 174, 175, 176, 0, 0, 177, 178, 0, 0, 179,
- 180, 181, 182, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 183, 184, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 190,
+ 191, 192, 193, 194, 195, 196, 197, 198, 199, 0,
+ 200, 201, 693, 640, 0, 0, 694, 0, 202, 272,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 185, 186, 187, 188,
- 189, 190, 191, 192, 193, 194, 0, 195, 196, 650,
- 596, 0, 0, 651, 0, 197, 266, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 168, 169,
- 170, 171, 172, 173, 174, 175, 176, 0, 0, 177,
- 178, 0, 0, 179, 180, 181, 182, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 183, 184, 0,
+ 0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
+ 0, 0, 182, 183, 0, 0, 184, 185, 186, 187,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 188, 189, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
- 0, 195, 196, 653, 604, 0, 0, 654, 0, 197,
- 266, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 168, 169, 170, 171, 172, 173, 174, 175,
- 176, 0, 0, 177, 178, 0, 0, 179, 180, 181,
- 182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 183, 184, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 190, 191, 192, 193, 194, 195, 196,
+ 197, 198, 199, 0, 200, 201, 696, 648, 0, 0,
+ 697, 0, 202, 272, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 173, 174, 175, 176, 177,
+ 178, 179, 180, 181, 0, 0, 182, 183, 0, 0,
+ 184, 185, 186, 187, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 188, 189, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 185, 186, 187, 188, 189, 190,
- 191, 192, 193, 194, 0, 195, 196, 689, 596, 0,
- 0, 690, 0, 197, 266, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 168, 169, 170, 171,
- 172, 173, 174, 175, 176, 0, 0, 177, 178, 0,
- 0, 179, 180, 181, 182, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 183, 184, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 190, 191, 192,
+ 193, 194, 195, 196, 197, 198, 199, 0, 200, 201,
+ 732, 640, 0, 0, 733, 0, 202, 272, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
+ 174, 175, 176, 177, 178, 179, 180, 181, 0, 0,
+ 182, 183, 0, 0, 184, 185, 186, 187, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 188, 189,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 185, 186,
- 187, 188, 189, 190, 191, 192, 193, 194, 0, 195,
- 196, 692, 604, 0, 0, 693, 0, 197, 266, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
- 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
- 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 190, 191, 192, 193, 194, 195, 196, 197, 198,
+ 199, 0, 200, 201, 735, 648, 0, 0, 736, 0,
+ 202, 272, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
+ 180, 181, 0, 0, 182, 183, 0, 0, 184, 185,
+ 186, 187, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 188, 189, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
- 193, 194, 0, 195, 196, 836, 596, 0, 0, 837,
- 0, 197, 266, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 168, 169, 170, 171, 172, 173,
- 174, 175, 176, 0, 0, 177, 178, 0, 0, 179,
- 180, 181, 182, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 183, 184, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 190, 191, 192, 193, 194,
+ 195, 196, 197, 198, 199, 0, 200, 201, 879, 640,
+ 0, 0, 880, 0, 202, 272, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
+ 176, 177, 178, 179, 180, 181, 0, 0, 182, 183,
+ 0, 0, 184, 185, 186, 187, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 188, 189, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 185, 186, 187, 188,
- 189, 190, 191, 192, 193, 194, 0, 195, 196, 839,
- 604, 0, 0, 840, 0, 197, 266, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 168, 169,
- 170, 171, 172, 173, 174, 175, 176, 0, 0, 177,
- 178, 0, 0, 179, 180, 181, 182, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 183, 184, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 190,
+ 191, 192, 193, 194, 195, 196, 197, 198, 199, 0,
+ 200, 201, 882, 648, 0, 0, 883, 0, 202, 272,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
+ 0, 0, 182, 183, 0, 0, 184, 185, 186, 187,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
- 0, 195, 196, 994, 596, 0, 0, 995, 0, 197,
- 266, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 168, 169, 170, 171, 172, 173, 174, 175,
- 176, 0, 0, 177, 178, 0, 0, 179, 180, 181,
- 182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 183, 184, 0, 0, 0, 0, 0, 0, 0,
+ 188, 189, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 185, 186, 187, 188, 189, 190,
- 191, 192, 193, 194, 0, 195, 196, 1007, 596, 0,
- 0, 1008, 0, 197, 266, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 168, 169, 170, 171,
- 172, 173, 174, 175, 176, 0, 0, 177, 178, 0,
- 0, 179, 180, 181, 182, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 183, 184, 0, 0, 0,
+ 0, 0, 0, 190, 191, 192, 193, 194, 195, 196,
+ 197, 198, 199, 0, 200, 201, 1019, 640, 0, 0,
+ 1020, 0, 202, 272, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 173, 174, 175, 176, 177,
+ 178, 179, 180, 181, 0, 0, 182, 183, 0, 0,
+ 184, 185, 186, 187, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 188, 189, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 185, 186,
- 187, 188, 189, 190, 191, 192, 193, 194, 0, 195,
- 196, 1010, 604, 0, 0, 1011, 0, 197, 266, 0,
+ 0, 0, 0, 0, 0, 0, 0, 190, 191, 192,
+ 193, 194, 195, 196, 197, 198, 199, 0, 200, 201,
+ 1031, 640, 0, 0, 1032, 0, 202, 272, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
+ 174, 175, 176, 177, 178, 179, 180, 181, 0, 0,
+ 182, 183, 0, 0, 184, 185, 186, 187, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 188, 189,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
- 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
- 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
- 193, 194, 0, 195, 196, 609, 604, 0, 0, 610,
- 0, 197, 266, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 168, 169, 170, 171, 172, 173,
- 174, 175, 176, 0, 0, 177, 178, 0, 0, 179,
- 180, 181, 182, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 183, 184, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 732, 0,
- 0, 0, 0, 0, 0, 0, 185, 186, 187, 188,
- 189, 190, 191, 192, 193, 194, 0, 195, 196, 0,
- 0, 0, 0, 0, 0, 197, 353, 354, 355, 356,
- 357, 358, 359, 360, 361, 362, 363, 364, 365, 0,
- 0, 366, 367, 353, 354, 355, 356, 357, 358, 359,
- 360, 361, 362, 363, 364, 365, 0, 0, 366, 367,
+ 0, 190, 191, 192, 193, 194, 195, 196, 197, 198,
+ 199, 0, 200, 201, 1034, 648, 0, 0, 1035, 0,
+ 202, 272, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
+ 180, 181, 0, 0, 182, 183, 0, 0, 184, 185,
+ 186, 187, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 188, 189, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 368, 0, 369, 370, 371, 372,
- 373, 374, 375, 376, 377, 378, 0, 0, 0, 0,
- 0, 368, 0, 369, 370, 371, 372, 373, 374, 375,
- 376, 377, 378, 353, 354, 355, 356, 357, 358, 359,
- 360, 361, 362, 363, 364, 365, 0, 242, 366, 367,
- 0, 0, 353, 354, 355, 356, 357, 358, 359, 360,
- 361, 362, 363, 364, 365, 0, 0, 366, 367, 0,
+ 0, 0, 0, 0, 0, 190, 191, 192, 193, 194,
+ 195, 196, 197, 198, 199, 0, 200, 201, 653, 648,
+ 0, 0, 654, 0, 202, 272, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
+ 176, 177, 178, 179, 180, 181, 0, 0, 182, 183,
+ 0, 0, 184, 185, 186, 187, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 188, 189, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 368, 0, 369, 370, 371, 372, 373, 374, 375,
- 376, 377, 378, 0, 0, 0, 0, 0, 0, 0,
- 368, -260, 369, 370, 371, 372, 373, 374, 375, 376,
- 377, 378, 0, 0, 0, 0, 0, 0, 0, 0,
- -261, 353, 354, 355, 356, 357, 358, 359, 360, 361,
- 362, 363, 364, 365, 0, 0, 366, 367, 0, 0,
- 353, 354, 355, 356, 357, 358, 359, 360, 361, 362,
- 363, 364, 365, 0, 0, 366, 367, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 368,
- 0, 369, 370, 371, 372, 373, 374, 375, 376, 377,
- 378, 0, 0, 0, 0, 0, 0, 0, 368, -262,
- 369, 370, 371, 372, 373, 374, 375, 376, 377, 378,
- 0, 0, 0, 0, 0, 0, 0, 0, -263, 353,
- 354, 355, 356, 357, 358, 359, 360, 361, 362, 363,
- 364, 365, 0, 0, 366, 367, 0, 0, 0, 447,
- 353, 354, 355, 356, 357, 358, 359, 360, 361, 362,
- 363, 364, 365, 0, 0, 366, 367, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 368, 0, 369,
- 370, 371, 372, 373, 374, 375, 376, 377, 378, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 368, 0,
- 369, 370, 371, 372, 373, 374, 375, 376, 377, 378,
- 353, 354, 355, 356, 357, 358, 359, 360, 361, 362,
- 363, -595, -595, 0, 0, 366, 367, 353, 354, 355,
- 356, 357, 358, 359, 360, 0, 362, 363, 0, 0,
- 0, 0, 366, 367, 0, 0, 0, 0, 0, 0,
+ 0, 848, 0, 0, 0, 0, 0, 0, 0, 190,
+ 191, 192, 193, 194, 195, 196, 197, 198, 199, 859,
+ 200, 201, 0, 0, 0, 0, 0, 0, 202, 396,
+ 397, 398, 399, 400, 401, 402, 403, 404, 405, 406,
+ 407, 408, 0, 0, 409, 410, 0, 396, 397, 398,
+ 399, 400, 401, 402, 403, 404, 405, 406, 407, 408,
+ 0, 0, 409, 410, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 412, 0, 413,
+ 414, 415, 416, 417, 418, 419, 420, 421, 422, 0,
+ 0, 0, 0, 0, 0, 412, 0, 413, 414, 415,
+ 416, 417, 418, 419, 420, 421, 422, 396, 397, 398,
+ 399, 400, 401, 402, 403, 404, 405, 406, 407, 408,
+ 0, 0, 409, 410, 0, 0, 0, 0, 0, 0,
+ 0, 0, 396, 397, 398, 399, 400, 401, 402, 403,
+ 404, 405, 406, 407, 408, 0, 0, 409, 410, 0,
+ 0, 0, 0, 0, 0, 412, 0, 413, 414, 415,
+ 416, 417, 418, 419, 420, 421, 422, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 369, 370, 371, 372, 373, 374, 375, 376, 377, 378,
- 0, 0, 0, 0, 0, 0, 0, 369, 370, 371,
- 372, 373, 374, 375, 376, 377, 378, 353, 354, 355,
- 356, 357, 358, 359, 0, 0, 362, 363, 0, 0,
- 0, 0, 366, 367, 0, 0, 0, 0, 0, 0,
+ 412, 248, 413, 414, 415, 416, 417, 418, 419, 420,
+ 421, 422, 0, 0, 0, 0, 0, 0, 0, 0,
+ -272, 396, 397, 398, 399, 400, 401, 402, 403, 404,
+ 405, 406, 407, 408, 0, 0, 409, 410, 0, 0,
+ 396, 397, 398, 399, 400, 401, 402, 403, 404, 405,
+ 406, 407, 408, 0, 0, 409, 410, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 412,
+ 0, 413, 414, 415, 416, 417, 418, 419, 420, 421,
+ 422, 0, 0, 0, 0, 0, 0, 0, 412, -273,
+ 413, 414, 415, 416, 417, 418, 419, 420, 421, 422,
+ 0, 0, 0, 0, 0, 0, 0, 0, -274, 396,
+ 397, 398, 399, 400, 401, 402, 403, 404, 405, 406,
+ 407, 408, 0, 0, 409, 410, 0, 0, 396, 397,
+ 398, 399, 400, 401, 402, 403, 404, 405, 406, 407,
+ 408, 0, 0, 409, 410, 0, 0, 0, 411, 0,
+ 0, 0, 0, 0, 0, 0, 0, 412, 0, 413,
+ 414, 415, 416, 417, 418, 419, 420, 421, 422, 0,
+ 0, 0, 0, 0, 0, 0, 412, -275, 413, 414,
+ 415, 416, 417, 418, 419, 420, 421, 422, 396, 397,
+ 398, 399, 400, 401, 402, 403, 404, 405, 406, 407,
+ 408, 0, 0, 409, 410, 0, 0, 0, 491, 396,
+ 397, 398, 399, 400, 401, 402, 403, 404, 405, 406,
+ 407, 408, 0, 0, 409, 410, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 412, 0, 413, 414,
+ 415, 416, 417, 418, 419, 420, 421, 422, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 412, 0, 413,
+ 414, 415, 416, 417, 418, 419, 420, 421, 422, 396,
+ 397, 398, 399, 400, 401, 402, 0, 0, 405, 406,
+ 0, 0, 0, 0, 409, 410, 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, 0, 0, 0, 0, 369, 370, 371,
- 372, 373, 374, 375, 376, 377, 378
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 413,
+ 414, 415, 416, 417, 418, 419, 420, 421, 422
};
static const yytype_int16 yycheck[] =
{
- 2, 308, 308, 83, 84, 27, 436, 213, 14, 78,
- 2, 10, 4, 5, 6, 27, 15, 9, 10, 21,
- 85, 13, 28, 15, 16, 17, 7, 262, 20, 381,
- 2, 7, 4, 28, 67, 22, 4, 303, 14, 54,
- 379, 15, 296, 454, 383, 427, 300, 386, 64, 352,
- 52, 53, 28, 405, 50, 16, 17, 721, 50, 20,
- 450, 492, 54, 320, 454, 442, 114, 406, 636, 421,
- 16, 17, 64, 484, 20, 56, 515, 645, 430, 795,
- 56, 420, 709, 422, 912, 26, 78, 57, 889, 391,
- 392, 52, 431, 67, 5, 6, 21, 22, 26, 16,
- 612, 613, 13, 142, 25, 107, 29, 146, 16, 17,
- 89, 91, 20, 25, 101, 285, 58, 59, 60, 61,
- 25, 113, 89, 115, 103, 321, 557, 57, 324, 209,
- 326, 470, 328, 89, 330, 25, 89, 289, 25, 119,
- 220, 293, 494, 54, 52, 53, 25, 16, 17, 119,
- 51, 20, 91, 27, 55, 51, 495, 53, 54, 55,
- 56, 89, 140, 26, 0, 25, 145, 78, 146, 997,
- 16, 17, 136, 69, 20, 103, 101, 91, 145, 349,
- 119, 25, 107, 108, 55, 442, 987, 706, 111, 145,
- 89, 121, 145, 407, 28, 136, 113, 352, 123, 116,
- 117, 281, 509, 509, 740, 119, 52, 53, 136, 745,
- 138, 18, 204, 20, 142, 214, 215, 145, 26, 140,
- 140, 142, 214, 215, 459, 305, 492, 144, 140, 146,
- 142, 947, 50, 80, 303, 140, 391, 392, 750, 113,
- 91, 87, 116, 117, 140, 909, 145, 72, 912, 260,
- 140, 262, 233, 140, 287, 119, 91, 233, 260, 89,
- 262, 140, 295, 296, 266, 676, 893, 300, 119, 243,
- 144, 91, 146, 136, 266, 532, 140, 124, 270, 142,
- 140, 89, 274, 275, 295, 675, 676, 279, 665, 285,
- 119, 557, 284, 285, 91, 103, 140, 115, 729, 119,
- 292, 142, 101, 455, 129, 130, 131, 89, 89, 270,
- 462, 303, 284, 287, 882, 145, 89, 119, 89, 142,
- 292, 473, 119, 123, 270, 55, 632, 126, 136, 89,
- 138, 347, 635, 997, 530, 350, 352, 145, 91, 338,
- 339, 340, 341, 140, 119, 337, 338, 339, 340, 341,
- 342, 343, 344, 349, 25, 347, 404, 349, 350, 91,
- 352, 55, 270, 145, 145, 337, 805, 91, 887, 337,
- 342, 313, 145, 16, 145, 391, 392, 113, 897, 381,
- 116, 117, 734, 822, 823, 145, 347, 119, 89, 381,
- 909, 352, 303, 140, 733, 119, 735, 266, 780, 391,
- 392, 270, 103, 405, 556, 662, 20, 383, 665, 623,
- 386, 140, 414, 405, 60, 407, 408, 63, 57, 421,
- 266, 490, 136, 492, 270, 417, 448, 72, 430, 421,
- 406, 91, 686, 425, 669, 737, 448, 138, 430, 350,
- 742, 743, 119, 435, 145, 143, 422, 458, 459, 91,
- 757, 757, 882, 137, 660, 431, 458, 459, 383, 119,
- 466, 279, 108, 729, 139, 467, 16, 285, 58, 59,
- 113, 466, 883, 116, 117, 467, 55, 119, 439, 631,
- 140, 406, 1001, 457, 476, 37, 38, 567, 557, 91,
- 466, 89, 494, 883, 470, 467, 1015, 422, 490, 91,
- 492, 144, 494, 146, 476, 103, 431, 2, 722, 4,
- 140, 513, 381, 515, 9, 10, 72, 119, 72, 495,
- 15, 16, 17, 91, 963, 20, 98, 119, 91, 786,
- 91, 349, 140, 685, 748, 381, 405, 15, 140, 531,
- 138, 13, 450, 554, 758, 470, 848, 145, 550, 16,
- 608, 119, 421, 611, 789, 50, 119, 15, 119, 405,
- 866, 430, 584, 113, 63, 557, 116, 117, 143, 64,
- 495, 629, 584, 481, 143, 421, 731, 140, 26, 490,
- 137, 492, 737, 89, 430, 140, 800, 742, 743, 113,
- 140, 140, 116, 117, 144, 16, 146, 103, 51, 417,
- 53, 54, 55, 56, 450, 51, 608, 425, 454, 611,
- 612, 613, 140, 600, 44, 89, 69, 435, 113, 140,
- 115, 608, 146, 622, 611, 494, 978, 629, 89, 103,
- 622, 623, 138, 635, 636, 481, 638, 140, 484, 145,
- 979, 89, 103, 645, 796, 859, 557, 51, 494, 660,
- 656, 140, 633, 686, 91, 103, 655, 633, 669, 51,
- 729, 656, 868, 655, 138, 58, 59, 669, 874, 16,
- 17, 145, 140, 20, 635, 600, 62, 138, 64, 65,
- 656, 746, 119, 608, 145, 697, 611, 140, 136, 139,
- 138, 119, 113, 848, 142, 116, 117, 145, 89, 139,
- 47, 48, 627, 140, 629, 52, 53, 17, 18, 204,
- 862, 863, 103, 531, 15, 731, 930, 64, 65, 214,
- 215, 737, 738, 144, 18, 146, 742, 743, 114, 115,
- 722, 51, 734, 53, 54, 55, 56, 729, 730, 731,
- 818, 819, 734, 72, 139, 737, 738, 138, 750, 69,
- 742, 743, 139, 137, 145, 15, 748, 749, 730, 735,
- 137, 763, 26, 91, 766, 139, 758, 675, 146, 768,
- 524, 266, 526, 765, 137, 270, 768, 15, 789, 274,
- 275, 92, 37, 38, 279, 777, 778, 789, 14, 284,
- 285, 119, 113, 785, 15, 116, 117, 292, 127, 128,
- 129, 130, 131, 805, 391, 392, 818, 819, 800, 801,
- 735, 62, 140, 64, 65, 15, 140, 143, 729, 51,
- 822, 823, 144, 57, 140, 89, 140, 140, 820, 675,
- 676, 140, 848, 825, 140, 140, 423, 424, 140, 103,
- 72, 140, 337, 338, 339, 340, 341, 342, 343, 344,
- 15, 139, 347, 933, 349, 15, 848, 352, 113, 137,
- 15, 116, 117, 114, 115, 734, 858, 859, 100, 101,
- 15, 15, 136, 140, 138, 867, 9, 10, 142, 871,
- 882, 145, 15, 15, 471, 89, 381, 89, 734, 144,
- 137, 146, 55, 124, 126, 124, 391, 392, 137, 103,
- 61, 103, 89, 64, 65, 252, 253, 254, 255, 820,
- 405, 15, 407, 408, 825, 89, 103, 55, 140, 266,
- 140, 61, 417, 270, 64, 65, 421, 949, 15, 103,
- 425, 749, 140, 140, 138, 430, 138, 949, 930, 140,
- 435, 145, 706, 145, 936, 709, 938, 765, 89, 941,
- 15, 138, 140, 114, 115, 142, 867, 721, 145, 777,
- 778, 963, 103, 140, 138, 113, 142, 785, 116, 117,
- 142, 145, 467, 139, 114, 115, 978, 467, 980, 981,
- 113, 476, 140, 801, 13, 26, 978, 6, 981, 987,
- 63, 64, 65, 721, 980, 207, 144, 138, 146, 494,
- 347, 213, 747, 979, 145, 352, 353, 354, 355, 356,
- 357, 358, 359, 360, 361, 362, 363, 364, 365, 366,
- 367, 368, 369, 370, 371, 372, 373, 374, 375, 376,
- 377, 378, 245, 7, 381, 721, 531, 883, 250, 866,
- 858, 114, 115, 700, 391, 392, 261, 906, 89, 26,
- 89, 909, 706, 871, 979, 809, 810, 811, 405, 813,
- -1, 815, 103, -1, 103, 89, -1, 2, -1, 4,
- 5, 6, 419, -1, 421, -1, 423, 424, 13, 103,
- -1, 214, 215, 430, 89, -1, -1, 63, 64, 65,
- -1, -1, 439, -1, -1, 136, 443, 138, 103, 138,
- 447, 142, -1, 450, 145, 452, 145, 454, -1, 978,
- -1, -1, 89, -1, 138, 50, -1, 89, 936, 54,
- 938, 145, -1, 941, 471, 337, 103, 622, 623, 893,
- -1, 103, 978, 138, 481, -1, -1, 484, 114, 115,
- 145, 274, 275, 78, -1, 909, -1, 494, 912, -1,
- 737, 738, -1, -1, -1, 742, 743, -1, -1, 136,
- 655, 138, -1, -1, 511, 142, 138, -1, 145, -1,
- 696, -1, -1, 145, 51, 522, 53, 54, 55, 56,
- 115, -1, -1, 709, 771, 772, 712, 774, 775, 63,
- 64, 65, 69, 540, 541, 721, -1, -1, -1, -1,
- 954, 955, 956, 957, 551, 338, 339, 340, 341, -1,
- 343, 344, -1, -1, 426, 427, 93, 700, -1, -1,
- 906, 704, 99, 909, 700, -1, 912, 722, 914, 63,
- 64, 65, -1, 997, -1, 730, 731, -1, 721, 734,
- 114, 115, 737, 738, -1, 721, -1, 742, 743, 63,
- 64, 65, -1, 748, 749, -1, -1, -1, 63, 64,
- 65, 848, -1, 758, 476, 1019, -1, -1, -1, 204,
- 765, 483, -1, 768, -1, 408, -1, -1, 964, -1,
- 114, 115, 777, 778, -1, -1, -1, -1, 635, 876,
- 785, 40, 41, 42, 43, 44, -1, 2, -1, 4,
- 114, 115, -1, -1, -1, 800, 801, -1, 13, 114,
- 115, 997, -1, 999, -1, 1001, -1, 1003, -1, 666,
- 63, 64, 65, -1, -1, -1, -1, -1, 675, 676,
- -1, -1, -1, 51, -1, 53, 54, 55, 56, -1,
- -1, -1, 1028, -1, 279, 50, 63, 64, 65, 284,
- 285, 69, -1, 848, 72, -1, -1, 292, -1, -1,
- -1, -1, -1, 858, 859, 827, 828, 893, 303, 895,
- -1, 114, 115, 899, -1, 93, 871, -1, -1, 726,
- -1, 99, 100, 101, 731, 732, 912, 734, 914, -1,
- 737, 738, -1, -1, -1, 742, 743, 114, 115, -1,
- -1, -1, 337, -1, -1, -1, -1, 342, 126, 621,
- 115, 129, -1, -1, 349, 350, -1, 352, -1, 945,
- 946, -1, 140, 906, 771, 772, 909, 774, 775, 912,
- 906, 914, -1, 909, -1, 930, 912, 784, 914, -1,
- -1, 936, -1, 938, -1, -1, 941, 909, 660, -1,
- -1, -1, -1, -1, -1, -1, 391, 392, -1, 985,
- -1, -1, -1, 2, 990, 4, 5, 6, 7, -1,
- -1, 997, 407, 999, 13, -1, -1, 1003, -1, -1,
- -1, 964, 417, 978, 831, -1, -1, -1, 964, 622,
- 425, 1017, -1, -1, 841, 842, -1, -1, -1, 204,
- 435, 848, 1028, -1, -1, 967, 968, 969, -1, 971,
- 972, 50, -1, -1, 997, 54, 999, -1, 1001, -1,
- 1003, 997, 655, 999, -1, 1001, -1, 1003, -1, 876,
- -1, -1, 467, -1, 72, -1, 883, -1, -1, 78,
- 752, 476, -1, -1, -1, 1028, -1, 759, -1, 87,
- 88, 72, 1028, -1, 2, 490, 4, 492, 1020, 1021,
- 1022, 1023, 72, -1, -1, -1, 87, 88, 780, -1,
- 1032, -1, -1, -1, 279, -1, 115, 87, 88, 284,
- 285, 51, -1, 53, 54, 55, 56, 292, 126, 127,
- 128, 129, 130, 131, 113, -1, 531, 116, 117, 69,
- -1, -1, 50, 124, 125, 126, 127, 128, 129, 130,
- 131, -1, -1, -1, -1, -1, -1, 127, 128, 129,
- 130, 131, 557, 93, 143, 144, -1, 146, -1, 99,
- 113, 978, 337, 116, 117, 768, 51, 342, 53, 54,
- 55, 56, -1, -1, 349, -1, -1, 352, 51, -1,
- 53, 54, 55, 56, 69, -1, 868, 140, -1, -1,
- -1, 144, 874, 146, -1, 204, 69, 115, -1, 72,
- -1, -1, -1, -1, -1, -1, -1, -1, 93, -1,
- -1, -1, -1, -1, -1, -1, 391, 392, 623, -1,
- 93, -1, -1, -1, -1, -1, 99, 100, 101, -1,
- -1, 51, 407, 53, 54, 55, 56, -1, -1, -1,
- -1, -1, 417, -1, -1, -1, -1, -1, -1, 69,
- 425, -1, 72, 126, -1, -1, 129, -1, -1, -1,
- 435, -1, -1, -1, -1, -1, -1, -1, -1, 142,
- 279, -1, -1, 93, -1, 284, 285, -1, -1, 99,
- 100, 101, -1, 292, -1, -1, 204, -1, -1, -1,
- -1, -1, 467, -1, 303, -1, -1, -1, -1, -1,
- 51, 476, 53, 54, 55, 56, 126, -1, -1, 129,
- -1, -1, -1, -1, -1, -1, -1, 722, 69, -1,
- -1, 72, 142, -1, 729, 730, 731, -1, 337, -1,
- -1, -1, 737, 342, -1, -1, -1, 742, 743, -1,
- 349, 350, 93, 748, 749, -1, -1, -1, 99, 100,
- 101, -1, -1, 758, -1, -1, 531, -1, -1, -1,
- 765, 279, -1, -1, -1, -1, 284, 285, -1, -1,
- -1, -1, 777, 778, 292, 126, -1, -1, 129, -1,
- 785, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 800, 801, -1, 407, -1,
- -1, -1, -1, -1, -1, -1, -1, 51, 417, 53,
- 54, 55, 56, -1, -1, 820, 425, -1, -1, 337,
- 825, -1, -1, -1, 342, 69, 435, -1, 72, -1,
- -1, 349, -1, -1, 352, -1, -1, -1, -1, -1,
- 84, -1, -1, 848, -1, -1, -1, -1, 623, 93,
- -1, -1, -1, 858, 859, 99, 100, 101, 467, -1,
- -1, -1, 867, -1, -1, -1, 871, 476, -1, -1,
- -1, -1, -1, 391, 392, -1, -1, -1, -1, -1,
- -1, 490, 126, 492, -1, 129, -1, -1, 51, 407,
- 53, 54, 55, 56, -1, -1, -1, -1, -1, 417,
- -1, -1, -1, -1, -1, -1, 69, 425, -1, 72,
- -1, -1, -1, -1, -1, -1, -1, 435, -1, -1,
- -1, -1, 531, -1, -1, 930, -1, -1, -1, -1,
- 93, 936, -1, 938, -1, -1, 941, 100, 101, -1,
- -1, -1, -1, -1, -1, -1, -1, 722, 557, 467,
- -1, -1, -1, -1, -1, 730, 731, -1, 476, -1,
- -1, -1, 737, 126, -1, -1, -1, 742, 743, -1,
- -1, -1, -1, 748, 749, -1, -1, -1, -1, -1,
- -1, -1, -1, 758, -1, -1, -1, -1, -1, -1,
- 765, 0, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 777, 778, 13, 14, 15, 16, 17, 18,
- 785, 20, -1, 531, 623, -1, -1, 26, 27, -1,
- -1, -1, -1, -1, -1, 800, 801, -1, 37, 38,
- -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
+ 2, 16, 17, 88, 219, 20, 86, 87, 471, 81,
+ 2, 27, 4, 5, 6, 27, 14, 9, 10, 21,
+ 7, 13, 768, 15, 16, 17, 480, 372, 20, 13,
+ 28, 7, 28, 67, 22, 117, 584, 10, 14, 268,
+ 302, 4, 15, 2, 306, 4, 73, 74, 26, 54,
+ 52, 53, 28, 486, 395, 679, 498, 581, 50, 16,
+ 17, 745, 54, 20, 688, 26, 314, 16, 17, 56,
+ 15, 20, 64, 16, 17, 581, 945, 20, 584, 50,
+ 56, 656, 657, 435, 436, 266, 528, 268, 494, 81,
+ 5, 6, 498, 120, 121, 52, 53, 309, 13, 291,
+ 536, 37, 38, 52, 53, 21, 22, 923, 110, 52,
+ 29, 57, 37, 38, 787, 27, 104, 365, 57, 792,
+ 301, 91, 67, 0, 116, 326, 118, 423, 80, 91,
+ 18, 427, 20, 90, 430, 215, 425, 5, 6, 54,
+ 74, 58, 59, 60, 61, 13, 226, 16, 17, 119,
+ 55, 20, 92, 1022, 140, 451, 50, 119, 136, 89,
+ 146, 450, 327, 599, 142, 330, 81, 332, 464, 334,
+ 466, 336, 124, 119, 140, 136, 465, 113, 140, 475,
+ 116, 117, 121, 58, 59, 474, 54, 121, 104, 89,
+ 51, 28, 111, 91, 110, 111, 942, 1013, 89, 945,
+ 392, 113, 89, 103, 116, 117, 119, 287, 144, 119,
+ 146, 72, 128, 81, 136, 145, 103, 209, 514, 58,
+ 59, 119, 797, 89, 118, 17, 18, 89, 220, 221,
+ 140, 311, 144, 119, 146, 89, 142, 309, 138, 100,
+ 101, 395, 142, 539, 928, 145, 101, 220, 221, 538,
+ 72, 138, 239, 140, 145, 142, 64, 272, 145, 293,
+ 89, 276, 768, 239, 266, 126, 268, 301, 302, 142,
+ 272, 126, 306, 146, 503, 708, 1022, 719, 89, 145,
+ 272, 435, 436, 145, 276, 486, 89, 314, 280, 281,
+ 89, 145, 540, 285, 89, 91, 920, 142, 290, 291,
+ 103, 26, 850, 123, 249, 367, 298, 129, 130, 131,
+ 89, 55, 718, 719, 51, 272, 145, 309, 55, 276,
+ 291, 502, 503, 847, 536, 387, 119, 276, 5, 6,
+ 854, 290, 91, 276, 145, 138, 13, 678, 365, 298,
+ 776, 91, 145, 91, 850, 546, 145, 55, 293, 89,
+ 145, 343, 344, 345, 346, 347, 348, 349, 350, 351,
+ 119, 824, 25, 103, 89, 349, 145, 449, 370, 119,
+ 372, 344, 345, 346, 347, 367, 140, 54, 103, 544,
+ 343, 140, 60, 20, 343, 63, 91, 599, 393, 348,
+ 452, 285, 861, 862, 309, 387, 91, 291, 390, 140,
+ 392, 393, 319, 395, 81, 145, 57, 276, 136, 754,
+ 425, 136, 91, 138, 119, 596, 72, 142, 942, 411,
+ 145, 392, 143, 425, 119, 91, 137, 411, 652, 119,
+ 108, 655, 784, 425, 349, 450, 942, 789, 790, 945,
+ 119, 309, 91, 435, 436, 140, 55, 390, 450, 673,
+ 465, 427, 395, 119, 430, 139, 458, 91, 450, 474,
+ 452, 453, 534, 465, 536, 140, 920, 729, 425, 461,
+ 119, 72, 474, 465, 140, 451, 492, 469, 393, 921,
+ 492, 349, 474, 712, 780, 119, 782, 479, 703, 72,
+ 466, 1015, 781, 450, 73, 74, 411, 119, 392, 475,
+ 502, 503, 1026, 51, 705, 91, 140, 708, 465, 511,
+ 140, 427, 510, 540, 510, 921, 1022, 474, 51, 511,
+ 865, 866, 703, 538, 140, 393, 140, 599, 520, 609,
+ 91, 712, 91, 119, 510, 451, 538, 494, 514, 891,
+ 483, 498, 534, 411, 536, 494, 538, 140, 140, 119,
+ 466, 91, 511, 545, 140, 51, 501, 98, 119, 475,
+ 119, 520, 16, 539, 776, 91, 91, 461, 525, 295,
+ 15, 528, 140, 299, 13, 469, 525, 89, 16, 119,
+ 63, 538, 390, 72, 15, 479, 143, 395, 143, 140,
+ 592, 103, 137, 119, 119, 2, 113, 4, 514, 116,
+ 117, 15, 9, 10, 833, 667, 15, 599, 15, 16,
+ 17, 113, 628, 20, 116, 117, 628, 16, 140, 534,
+ 381, 536, 383, 539, 778, 44, 138, 435, 436, 830,
+ 784, 89, 309, 145, 119, 789, 790, 212, 127, 128,
+ 129, 130, 131, 50, 219, 103, 139, 139, 15, 994,
+ 652, 545, 833, 655, 656, 657, 644, 64, 18, 113,
+ 139, 139, 116, 117, 652, 137, 534, 655, 536, 15,
+ 137, 673, 349, 139, 666, 667, 678, 679, 146, 681,
+ 138, 256, 140, 140, 599, 137, 688, 145, 57, 676,
+ 144, 906, 146, 666, 140, 729, 140, 912, 140, 140,
+ 676, 699, 15, 699, 776, 92, 698, 769, 793, 116,
+ 712, 118, 14, 1009, 113, 89, 393, 116, 117, 1008,
+ 15, 737, 15, 699, 144, 698, 143, 140, 644, 103,
+ 140, 599, 89, 795, 411, 678, 652, 891, 140, 655,
+ 140, 140, 435, 436, 140, 144, 103, 146, 26, 15,
+ 139, 89, 754, 15, 137, 671, 61, 673, 26, 64,
+ 65, 718, 719, 15, 138, 103, 781, 15, 343, 718,
+ 15, 145, 137, 499, 467, 468, 140, 769, 840, 781,
+ 506, 138, 124, 140, 776, 777, 778, 124, 145, 781,
+ 55, 517, 784, 785, 137, 797, 568, 789, 790, 374,
+ 138, 15, 209, 795, 796, 807, 782, 145, 810, 114,
+ 115, 89, 584, 220, 221, 587, 55, 809, 777, 140,
+ 812, 89, 515, 113, 781, 103, 116, 117, 140, 821,
+ 822, 833, 140, 140, 140, 103, 140, 829, 139, 812,
+ 902, 15, 142, 569, 570, 861, 862, 574, 840, 841,
+ 142, 578, 140, 511, 574, 6, 146, 534, 136, 536,
+ 138, 776, 140, 865, 866, 272, 782, 145, 136, 276,
+ 138, 863, 598, 280, 281, 1011, 868, 145, 285, 768,
+ 1013, 1010, 962, 290, 291, 51, 794, 53, 54, 55,
+ 56, 298, 251, 7, 574, 470, 471, 61, 939, 891,
+ 64, 65, 796, 69, 942, 9, 10, 581, 776, 901,
+ 902, 15, 89, 905, 267, 809, 89, 909, 920, -1,
+ -1, -1, 599, -1, -1, -1, 103, 821, 822, -1,
+ 103, -1, -1, -1, -1, 829, 343, 344, 345, 346,
+ 347, 348, -1, 350, 351, 520, -1, 841, 863, 675,
+ 114, 115, 527, 868, -1, 89, -1, -1, -1, 975,
+ 367, 138, -1, 975, 921, 138, -1, 140, 145, 103,
+ 778, -1, 145, 965, 140, 967, 784, 785, 970, -1,
+ 387, 789, 790, 390, -1, 392, -1, -1, 395, -1,
+ 905, 89, 994, 1008, -1, 863, 768, 758, 759, 760,
+ 868, 762, 728, 764, 138, 103, 1008, 901, 1010, 1011,
+ -1, 145, 116, -1, -1, 909, 1008, -1, 425, 113,
+ 746, -1, 116, 117, 26, 89, -1, -1, 435, 436,
+ -1, -1, -1, 1009, 870, 871, -1, 905, -1, 103,
+ 138, 768, -1, 450, -1, 452, 453, 145, 768, 143,
+ 144, 1008, 146, 72, 461, 768, -1, -1, 465, 16,
+ -1, 51, 469, 53, 54, 55, 56, 474, 87, 88,
+ -1, 965, 479, 967, 138, -1, 970, -1, 850, 69,
+ 852, 145, -1, 891, 856, -1, -1, 89, 89, -1,
+ 665, 784, 785, 1009, -1, -1, 789, 790, -1, 776,
+ -1, 103, 103, 16, 511, -1, 942, 126, 127, 128,
+ 129, 130, 131, 520, -1, -1, 220, 221, -1, -1,
+ -1, -1, 815, 816, -1, 818, 819, -1, 703, -1,
+ 62, 538, 64, 65, 136, -1, 138, 138, 545, 89,
+ 142, 9, 10, 145, 145, -1, -1, 15, 16, 17,
+ 140, -1, 20, 103, 926, 927, 113, -1, -1, 116,
+ 117, -1, 998, 999, 1000, -1, 1002, 1003, -1, 930,
+ 931, 932, 933, 945, 26, 947, 280, 281, -1, 47,
+ 48, -1, 114, 115, 52, 53, 863, 144, 138, 146,
+ -1, 868, -1, -1, -1, 145, 64, 65, 891, -1,
+ 113, -1, -1, 116, 117, -1, 1042, 1043, 1044, 1045,
+ 982, -1, 939, 985, -1, 942, 1052, 26, 945, 939,
+ 947, 914, 942, -1, 799, 945, 939, 947, 905, 942,
+ -1, 144, 945, 146, 947, 26, -1, 89, -1, -1,
+ 344, 345, 346, 347, -1, 1017, 350, 351, 116, 824,
+ 1022, 103, 1024, 26, -1, -1, 1028, 1018, 89, 666,
+ 667, 51, -1, 53, 54, 55, 56, -1, 995, 89,
+ -1, -1, 103, -1, -1, 995, 1048, -1, -1, 69,
+ 89, -1, 995, 103, 136, -1, 138, 26, 140, -1,
+ 142, 698, -1, 145, 103, 1022, -1, 1024, 89, 1026,
+ -1, 1028, 1022, 93, 1024, -1, 1026, 138, 1028, 1022,
+ 89, 1024, 103, 1026, 145, 1028, 89, -1, 138, -1,
+ -1, 1048, -1, -1, 103, 145, -1, 136, 1048, 138,
+ 103, 906, 26, 142, -1, 1048, 145, 912, 51, -1,
+ 53, 54, 55, 56, -1, 136, -1, 138, -1, 453,
+ 89, 142, 220, 221, 145, -1, 69, -1, -1, 138,
+ -1, 89, 769, 136, 103, 138, 145, 140, -1, 142,
+ 777, 778, 145, -1, 781, 103, -1, 784, 785, 63,
+ 64, 65, 789, 790, 62, -1, 64, 65, 795, 796,
+ 258, 259, 260, 261, -1, 89, -1, 136, -1, 138,
+ -1, 140, 809, 142, 272, 812, 145, -1, 276, 103,
+ 138, -1, 280, 281, 821, 822, -1, 145, -1, -1,
+ -1, -1, 829, 63, 64, 65, -1, -1, -1, -1,
+ 114, 115, -1, 840, 841, -1, 114, 115, -1, 63,
+ 64, 65, 136, -1, 138, 63, 64, 65, 142, 72,
+ -1, 145, -1, -1, 113, -1, -1, 116, 117, -1,
+ -1, 63, 64, 65, 87, 88, -1, -1, 51, -1,
+ 53, 54, 55, 56, 114, 115, 344, 345, 346, 347,
+ -1, 140, 350, 351, 891, 144, 69, 146, -1, 72,
+ 114, 115, -1, -1, 901, 902, 114, 115, -1, -1,
+ 368, -1, 909, -1, 127, 128, 129, 130, 131, -1,
+ 93, 379, 114, 115, 63, 64, 65, 100, 101, -1,
+ -1, -1, 390, 63, 64, 65, -1, 395, 396, 397,
+ 398, 399, 400, 401, 402, 403, 404, 405, 406, 407,
+ 408, 409, 410, 126, 412, 413, 414, 415, 416, 417,
+ 418, 419, 420, 421, 422, 72, -1, 425, 965, -1,
+ 967, -1, 666, 970, -1, 114, 115, 435, 436, -1,
+ 87, 88, -1, -1, 114, 115, -1, 2, -1, 4,
+ 5, 6, 450, -1, -1, 453, -1, 113, 13, -1,
+ 116, 117, -1, -1, 698, 463, -1, 465, -1, 467,
+ 468, 1008, 63, 64, 65, -1, 474, 124, 125, 126,
+ 127, 128, 129, 130, 131, 483, -1, -1, 144, 487,
+ 146, -1, -1, 491, 0, 50, 494, -1, 496, 54,
+ 498, 51, -1, 53, 54, 55, 56, 13, 14, 15,
+ 16, 17, 18, -1, 20, -1, -1, 515, -1, 69,
+ 26, 27, 72, 114, 115, -1, 81, 525, -1, -1,
+ 528, 37, 38, -1, 40, 41, 42, 43, 44, -1,
+ 538, -1, -1, 93, 40, 41, 42, 43, 44, 99,
+ 100, 101, -1, -1, -1, -1, 554, 555, -1, -1,
+ -1, -1, -1, 118, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 571, -1, -1, 126, -1, 812, 129,
+ -1, -1, -1, 89, 51, -1, 53, 54, 55, 56,
+ 140, -1, 590, -1, -1, 593, -1, 103, -1, -1,
+ -1, -1, 69, -1, -1, 72, -1, 113, -1, -1,
+ 116, 117, 2, -1, 4, 5, 6, 7, -1, -1,
+ -1, -1, -1, 13, -1, -1, 93, -1, -1, -1,
+ 136, 137, 99, 100, 101, -1, 142, 143, 144, 145,
+ 146, -1, 2, -1, 4, 51, -1, 53, 54, 55,
+ 56, -1, -1, 13, 209, -1, -1, -1, -1, 126,
+ 50, -1, 129, 69, 54, -1, -1, 51, 666, 53,
+ 54, 55, 56, -1, -1, 142, -1, -1, -1, -1,
+ 678, -1, -1, -1, -1, 69, -1, 93, -1, -1,
+ 50, 81, 51, 99, 53, 54, 55, 56, -1, -1,
+ 698, -1, -1, -1, -1, -1, -1, -1, -1, 93,
+ 69, 709, -1, 72, -1, 99, -1, -1, -1, -1,
+ 718, 719, -1, -1, -1, 51, 52, -1, 118, 55,
+ 285, -1, -1, -1, 93, 290, 291, -1, -1, -1,
+ 99, 100, 101, 298, 70, 71, 72, 73, 74, 75,
+ 76, 77, 78, -1, 309, 81, 82, -1, 118, 85,
+ 86, 87, 88, -1, -1, -1, -1, 126, -1, -1,
+ 129, -1, -1, 99, 100, 773, -1, -1, -1, -1,
+ 778, 779, -1, 781, -1, -1, 784, 785, 343, -1,
+ -1, 789, 790, 348, 349, -1, 122, 123, 124, 125,
+ 126, 127, 128, 129, 130, 131, -1, 133, 134, -1,
+ -1, -1, 367, -1, 812, 141, 142, 815, 816, 209,
+ 818, 819, -1, -1, 51, -1, 53, 54, 55, 56,
+ 828, -1, 387, -1, -1, -1, -1, 392, 393, -1,
+ 395, -1, 69, -1, -1, 72, -1, -1, -1, 209,
+ 848, -1, -1, -1, -1, -1, 411, -1, -1, -1,
+ -1, 859, -1, -1, -1, -1, 93, -1, -1, -1,
+ -1, -1, 99, 100, 101, -1, 874, -1, -1, -1,
+ 435, 436, -1, -1, -1, -1, 884, 885, -1, -1,
+ -1, -1, -1, 891, -1, 285, -1, 452, -1, 126,
+ 290, 291, 129, -1, -1, -1, 461, -1, 298, -1,
+ -1, -1, -1, -1, 469, 142, 914, -1, -1, 309,
+ -1, -1, -1, 921, 479, 285, -1, -1, -1, -1,
+ 290, 291, -1, -1, -1, -1, -1, -1, 298, -1,
+ -1, -1, -1, -1, -1, 51, -1, 53, 54, 55,
+ 56, -1, -1, 343, -1, -1, 511, -1, 348, 349,
+ -1, -1, -1, 69, -1, 520, 72, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 367, 84, 534,
+ -1, 536, -1, 343, -1, -1, -1, 93, 348, 349,
+ 545, -1, -1, 99, 100, 101, -1, 387, -1, -1,
+ -1, -1, 392, 393, -1, -1, -1, 367, -1, -1,
+ 1008, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 126, 411, -1, 129, -1, -1, -1, 387, -1, -1,
+ -1, -1, 392, -1, -1, 395, -1, -1, -1, -1,
+ -1, -1, -1, -1, 599, -1, -1, -1, -1, -1,
+ -1, 411, -1, -1, -1, 2, -1, 4, -1, -1,
+ -1, -1, 452, -1, -1, -1, -1, -1, -1, -1,
+ -1, 461, -1, -1, -1, 435, 436, -1, -1, 469,
+ -1, 72, 73, 74, 75, 76, 77, 78, 79, 479,
+ 81, 82, 452, -1, -1, -1, 87, 88, -1, -1,
+ -1, 461, -1, 50, -1, -1, -1, -1, -1, 469,
+ -1, -1, 667, -1, -1, -1, -1, -1, -1, 479,
+ -1, 511, -1, -1, -1, -1, -1, -1, -1, -1,
+ 520, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+ 131, -1, -1, -1, 534, -1, 536, -1, -1, -1,
+ -1, 511, -1, -1, -1, 545, -1, -1, -1, -1,
+ 520, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 118, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 545, -1, -1, -1, -1,
+ -1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, -1, -1, 87, 88, 599,
+ -1, -1, -1, -1, 769, -1, -1, -1, -1, -1,
+ -1, 776, 777, 778, -1, -1, -1, -1, -1, 784,
+ -1, -1, -1, -1, 789, 790, -1, -1, -1, -1,
+ 795, 796, 122, 123, 124, 125, 126, 127, 128, 129,
+ 130, 131, -1, -1, 809, -1, -1, -1, -1, -1,
+ -1, -1, 209, -1, -1, -1, 821, 822, -1, -1,
+ -1, -1, -1, -1, 829, -1, -1, 667, -1, -1,
+ -1, -1, -1, -1, -1, 840, 841, 44, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 667, 863, -1,
+ -1, -1, -1, 868, -1, 72, 73, 74, 75, 76,
+ 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
+ 87, 88, -1, -1, -1, -1, 891, -1, 285, -1,
+ -1, -1, -1, 290, 291, -1, 901, 902, -1, -1,
+ 905, 298, -1, -1, 909, -1, -1, -1, -1, -1,
+ -1, -1, -1, 120, -1, 122, 123, 124, 125, 126,
+ 127, 128, 129, 130, 131, -1, -1, -1, -1, 769,
+ -1, -1, -1, 140, -1, -1, 776, 777, -1, -1,
+ -1, -1, -1, -1, -1, -1, 343, -1, -1, -1,
+ -1, 348, -1, -1, -1, 795, 796, -1, -1, 769,
+ 965, -1, 967, -1, -1, 970, -1, 777, 778, 809,
+ 367, -1, -1, -1, 784, -1, -1, -1, -1, 789,
+ 790, 821, 822, -1, -1, 795, 796, -1, -1, 829,
+ 387, -1, -1, -1, -1, 392, -1, -1, 395, 809,
+ 840, 841, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 821, 822, -1, -1, -1, -1, -1, -1, 829,
+ -1, -1, -1, 863, -1, -1, -1, -1, 868, -1,
+ 840, 841, -1, -1, -1, -1, -1, -1, 435, 436,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 452, -1, -1, -1, -1,
+ -1, 901, 902, -1, 461, 905, -1, -1, -1, 909,
+ -1, -1, 469, -1, -1, -1, -1, -1, -1, -1,
+ -1, 891, 479, -1, -1, -1, -1, -1, -1, -1,
+ -1, 901, 902, -1, -1, 905, -1, -1, -1, 909,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 511, -1, -1, -1, -1, -1,
+ -1, -1, -1, 520, -1, 965, -1, 967, -1, -1,
+ 970, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 545, -1,
+ -1, -1, -1, -1, -1, 965, -1, 967, -1, -1,
+ 970, -1, -1, -1, -1, -1, -1, 0, 1, -1,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+ -1, -1, -1, -1, -1, -1, 19, -1, 21, 22,
+ 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, 99, -1, -1, 102,
+ 667, 104, 105, 106, 107, 108, 109, -1, -1, 112,
+ 113, -1, -1, 116, 117, -1, -1, 72, 73, 74,
+ 75, 76, 77, 78, -1, -1, 81, 82, -1, 132,
+ 133, 134, 87, 88, -1, -1, -1, -1, -1, -1,
+ -1, 144, -1, 146, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 44, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
+ 125, 126, 127, 128, 129, 130, 131, -1, -1, -1,
+ -1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, -1, -1, 87, 88, -1,
+ -1, -1, 769, -1, -1, -1, -1, -1, -1, -1,
+ 777, 778, -1, -1, -1, -1, -1, 784, -1, -1,
+ -1, -1, 789, 790, -1, -1, -1, -1, 795, 796,
+ 120, -1, 122, 123, 124, 125, 126, 127, 128, 129,
+ 130, 131, 809, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 821, 822, -1, -1, -1, -1,
+ -1, -1, 829, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 840, 841, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 0, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 13, 14, 15, 16, 17, 18, -1, 20, -1,
+ -1, -1, -1, -1, -1, 27, 28, -1, -1, -1,
+ -1, -1, -1, -1, 891, 37, 38, -1, 40, 41,
+ 42, 43, 44, -1, 901, 902, -1, -1, -1, -1,
+ -1, -1, 909, -1, -1, 57, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 848, -1, -1, -1, -1, -1, -1,
- 89, -1, -1, 858, 859, -1, -1, -1, -1, -1,
- -1, -1, 867, -1, 103, -1, 871, -1, -1, -1,
- -1, -1, -1, -1, 113, 623, -1, 116, 117, -1,
- -1, -1, -1, 722, -1, -1, -1, -1, -1, -1,
- 729, 730, -1, -1, -1, -1, -1, 136, 137, -1,
- -1, -1, -1, 142, 143, 144, 145, 146, -1, 748,
- 749, -1, -1, -1, -1, -1, -1, -1, -1, 758,
- -1, -1, -1, -1, -1, 930, 765, -1, -1, -1,
- -1, 936, -1, 938, -1, -1, 941, -1, 777, 778,
- -1, -1, -1, -1, -1, -1, 785, -1, -1, -1,
+ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+ 82, 83, 84, -1, -1, 87, 88, 89, -1, 91,
+ 92, -1, -1, -1, -1, -1, 98, -1, -1, -1,
+ -1, 103, -1, -1, -1, -1, -1, -1, 965, -1,
+ 967, 113, -1, 970, 116, 117, -1, 119, 120, -1,
+ 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
+ -1, -1, 0, -1, -1, 137, 138, 139, 140, -1,
+ -1, 143, 144, 145, 146, 13, 14, 15, 16, 17,
+ 18, -1, 20, -1, -1, -1, -1, -1, -1, 27,
+ 28, -1, -1, -1, -1, -1, -1, -1, -1, 37,
+ 38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 800, 801, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 722, -1, -1, -1, -1, -1,
- -1, 820, 730, 731, -1, -1, 825, -1, -1, 737,
- -1, -1, -1, -1, 742, 743, -1, -1, -1, -1,
- 748, 749, -1, -1, -1, -1, -1, -1, -1, -1,
- 758, -1, -1, -1, -1, -1, -1, 765, -1, 858,
- 859, -1, -1, -1, -1, -1, -1, -1, 867, 777,
- 778, -1, 871, -1, -1, -1, -1, 785, -1, -1,
- -1, -1, -1, -1, -1, -1, 44, -1, -1, -1,
- -1, -1, 800, 801, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, -1, -1, 87,
- 88, 930, -1, -1, -1, -1, -1, 936, -1, 938,
- 848, -1, 941, 72, 73, 74, 75, 76, 77, 78,
- 858, 859, 81, 82, -1, -1, -1, -1, 87, 88,
- -1, -1, 120, 871, 122, 123, 124, 125, 126, 127,
- 128, 129, 130, 131, -1, -1, -1, -1, -1, -1,
- -1, -1, 140, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 122, 123, 124, 125, 126, 127, 128,
- 129, 130, 131, -1, -1, -1, -1, -1, -1, -1,
+ 88, 89, -1, -1, 92, -1, -1, -1, -1, -1,
+ 98, -1, -1, -1, -1, 103, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 113, -1, -1, 116, 117,
+ -1, -1, 120, -1, 122, 123, 124, 125, 126, 127,
+ 128, 129, 130, 131, -1, -1, 0, -1, -1, 137,
+ 138, 139, 140, -1, 142, 143, 144, 145, 146, 13,
+ 14, 15, -1, 17, 18, -1, 20, -1, -1, -1,
+ -1, -1, 26, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
+ 44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 930, -1, -1, -1, -1, -1, 936, -1,
- 938, 0, 1, 941, 3, 4, 5, 6, 7, 8,
- 9, 10, 11, 12, -1, -1, -1, -1, -1, -1,
- 19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
- -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
- 39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
- 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
- 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
- 69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
- 99, -1, -1, 102, -1, 104, 105, 106, 107, 108,
- 109, 0, -1, 112, 113, -1, -1, 116, 117, -1,
- -1, -1, -1, -1, 13, 14, 15, 16, 17, 18,
- -1, 20, -1, 132, 133, 134, -1, -1, 27, 28,
- -1, -1, -1, -1, -1, 144, -1, 146, 37, 38,
- -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 57, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 72, 73, 74, 75, 76, 77, 78,
- 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
- 89, -1, 91, 92, -1, -1, -1, -1, -1, 98,
- -1, -1, -1, -1, 103, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 113, -1, -1, 116, 117, -1,
- 119, 120, -1, 122, 123, 124, 125, 126, 127, 128,
- 129, 130, 131, -1, -1, 0, -1, -1, 137, 138,
- 139, 140, -1, -1, 143, 144, 145, 146, 13, 14,
- 15, 16, 17, 18, -1, 20, -1, -1, -1, -1,
- -1, -1, 27, 28, -1, -1, -1, -1, -1, -1,
- -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
+ -1, -1, -1, -1, -1, -1, -1, -1, 72, 73,
+ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+ 84, -1, -1, 87, 88, 89, -1, 91, 92, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 103,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 113,
+ -1, -1, 116, 117, -1, 119, 120, -1, 122, 123,
+ 124, 125, 126, 127, 128, 129, 130, 131, -1, -1,
+ 0, -1, 136, 137, 138, -1, 140, -1, -1, 143,
+ 144, 145, 146, 13, 14, 15, -1, 17, 18, -1,
+ 20, -1, -1, -1, -1, -1, 26, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
+ 40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 72, 73, 74,
- 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
- -1, -1, 87, 88, 89, -1, -1, 92, -1, -1,
- -1, -1, -1, 98, -1, -1, -1, -1, 103, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 113, -1,
- -1, 116, 117, -1, -1, 120, -1, 122, 123, 124,
- 125, 126, 127, 128, 129, 130, 131, -1, -1, 0,
- -1, -1, 137, 138, 139, 140, -1, 142, 143, 144,
- 145, 146, 13, 14, 15, -1, 17, 18, -1, 20,
- -1, -1, -1, -1, -1, 26, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
- 41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 72, 73, 74, 75, 76, 77, 78, 79, 80,
- 81, 82, 83, 84, -1, -1, 87, 88, 89, -1,
- 91, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 103, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 113, -1, -1, 116, 117, -1, 119, 120,
- -1, 122, 123, 124, 125, 126, 127, 128, 129, 130,
- 131, -1, -1, 0, -1, 136, 137, 138, -1, 140,
- -1, -1, 143, 144, 145, 146, 13, 14, 15, -1,
- 17, 18, -1, 20, -1, -1, -1, -1, -1, 26,
+ -1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, -1, -1, 87, 88, 89,
+ -1, 91, 92, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 103, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 113, -1, -1, 116, 117, -1, 119,
+ 120, -1, 122, 123, 124, 125, 126, 127, 128, 129,
+ 130, 131, -1, -1, 0, -1, 136, 137, 138, -1,
+ 140, -1, -1, 143, 144, 145, 146, 13, 14, 15,
+ -1, 17, 18, -1, 20, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
+ -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 72, 73, 74, 75, 76,
- 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
- 87, 88, 89, -1, 91, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 103, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 113, -1, -1, 116,
- 117, -1, 119, 120, -1, 122, 123, 124, 125, 126,
- 127, 128, 129, 130, 131, -1, -1, 0, -1, 136,
- 137, 138, -1, 140, -1, -1, 143, 144, 145, 146,
- 13, 14, 15, -1, 17, 18, -1, 20, -1, -1,
+ -1, -1, -1, -1, -1, -1, 72, 73, 74, 75,
+ 76, 77, 78, 79, 80, 81, 82, 83, 84, -1,
+ -1, 87, 88, 89, -1, 91, 92, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 103, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 113, -1, -1,
+ 116, 117, -1, 119, 120, -1, 122, 123, 124, 125,
+ 126, 127, 128, 129, 130, 131, -1, -1, 0, -1,
+ -1, 137, 138, -1, 140, -1, -1, 143, 144, 145,
+ 146, 13, 14, 15, -1, 17, 18, -1, 20, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
- 43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
+ 42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 72,
- 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
- 83, 84, -1, -1, 87, 88, 89, -1, 91, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 113, -1, -1, 116, 117, -1, 119, 120, -1, 122,
- 123, 124, 125, 126, 127, 128, 129, 130, 131, -1,
- -1, 0, -1, -1, 137, 138, -1, 140, -1, -1,
- 143, 144, 145, 146, 13, 14, 15, -1, 17, 18,
- -1, 20, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 37, 38,
- -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+ 82, 83, 84, -1, -1, 87, 88, 89, -1, 91,
+ 92, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 103, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 113, -1, -1, 116, 117, -1, 119, 120, -1,
+ 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
+ -1, -1, -1, -1, -1, 137, 138, -1, 140, -1,
+ -1, 143, 144, 145, 146, 1, -1, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ -1, -1, 18, 19, -1, 21, 22, 23, 24, -1,
+ -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
+ 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
+ -1, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
+ 66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 72, 73, 74, 75, 76, 77, 78,
- 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
- 89, -1, 91, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 103, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 113, -1, -1, 116, 117, -1,
- 119, 120, -1, 122, 123, 124, 125, 126, 127, 128,
- 129, 130, 131, -1, -1, -1, -1, -1, 137, 138,
- -1, 140, -1, -1, 143, 144, 145, 146, 1, -1,
- 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
- 13, 14, 15, -1, -1, 18, 19, -1, 21, 22,
- 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
- 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
- -1, -1, 45, -1, 47, 48, 49, 50, 51, 52,
- 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
- 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
+ -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
+ 96, 97, -1, 99, -1, -1, 102, -1, 104, 105,
+ 106, 107, 108, 109, -1, -1, 112, 113, -1, -1,
+ 116, 117, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 132, 133, 134, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 144, 1,
+ 146, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+ 12, -1, -1, 15, -1, 17, 18, 19, -1, 21,
+ 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
+ 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
+ -1, -1, -1, 45, -1, 47, 48, 49, 50, 51,
+ 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
+ -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
- 93, 94, -1, 96, 97, -1, 99, -1, -1, 102,
- -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
- 113, -1, -1, 116, 117, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 132,
- 133, 134, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 144, 1, 146, 3, 4, 5, 6, 7, 8,
- 9, 10, 11, 12, -1, -1, 15, -1, 17, 18,
- 19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
- -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
- 39, -1, -1, -1, -1, -1, 45, -1, 47, 48,
- 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
- 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
- 69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
+ -1, 93, 94, -1, 96, 97, -1, 99, -1, -1,
+ 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
+ 112, 113, -1, -1, 116, 117, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
- 99, -1, -1, 102, -1, 104, 105, 106, 107, 108,
- 109, -1, -1, 112, 113, -1, -1, 116, 117, -1,
+ 132, 133, 134, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 144, 1, 146, 3, 4, 5, 6, 7,
+ 8, 9, 10, 11, 12, -1, -1, 15, -1, -1,
+ 18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
+ -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
+ -1, 39, -1, -1, -1, -1, -1, 45, -1, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
+ 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
+ -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 132, 133, 134, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 144, 1, 146, 3, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, -1, -1,
- 15, -1, -1, 18, 19, 20, 21, 22, 23, 24,
- -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
- 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
- 45, -1, 47, 48, 49, 50, 51, 52, 53, 54,
- 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
- -1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
+ -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
+ -1, 99, -1, -1, 102, -1, 104, 105, 106, 107,
+ 108, 109, -1, -1, 112, 113, -1, -1, 116, 117,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
- -1, 96, 97, -1, 99, -1, -1, 102, -1, 104,
- 105, 106, 107, 108, 109, -1, -1, 112, 113, -1,
- -1, 116, 117, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 132, 133, 134,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 144,
- 1, 146, 3, 4, 5, 6, 7, 8, 9, 10,
- 11, 12, -1, -1, 15, -1, -1, 18, 19, -1,
- 21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
- 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
- -1, -1, -1, -1, 45, -1, 47, 48, 49, 50,
- 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
- -1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
- 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
- -1, -1, 93, 94, -1, 96, 97, -1, 99, -1,
- -1, 102, -1, 104, 105, 106, 107, 108, 109, -1,
- -1, 112, 113, -1, -1, 116, 117, 1, -1, 3,
+ -1, -1, -1, -1, 132, 133, 134, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 144, 1, 146, 3,
4, 5, 6, 7, 8, 9, 10, 11, 12, -1,
- -1, 132, 133, 134, -1, 19, -1, 21, 22, 23,
- 24, -1, -1, 144, -1, 146, 30, 31, 32, 33,
+ -1, 15, -1, -1, 18, 19, -1, 21, 22, 23,
+ 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
- -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+ -1, 45, -1, 47, 48, 49, 50, 51, 52, 53,
54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
-1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
94, -1, 96, 97, -1, 99, -1, -1, 102, -1,
104, 105, 106, 107, 108, 109, -1, -1, 112, 113,
- -1, -1, 116, 117, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 132, 133,
- 134, -1, -1, 137, -1, -1, -1, -1, -1, -1,
- 144, 1, 146, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, 12, -1, 14, 15, -1, -1, -1, 19,
- -1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
- -1, -1, -1, -1, -1, 45, -1, 47, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
- 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
- 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 116, 117, 1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, -1, -1, 132, 133,
+ 134, -1, 19, -1, 21, 22, 23, 24, -1, -1,
+ 144, -1, 146, 30, 31, 32, 33, 34, 35, 36,
+ -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
+ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+ -1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
+ 67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
- -1, -1, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, 113, -1, -1, 116, 117, 1, -1,
+ -1, -1, -1, 90, -1, -1, 93, 94, -1, 96,
+ 97, -1, 99, -1, -1, 102, -1, 104, 105, 106,
+ 107, 108, 109, -1, -1, 112, 113, -1, -1, 116,
+ 117, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 132, 133, 134, -1, -1,
+ 137, -1, -1, -1, -1, -1, -1, 144, 1, 146,
3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
- -1, -1, 132, 133, 134, -1, 19, -1, 21, 22,
- 23, 24, -1, -1, 144, -1, 146, 30, 31, 32,
+ -1, 14, 15, -1, -1, -1, 19, -1, 21, 22,
+ 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
-1, -1, 45, -1, 47, 48, 49, 50, 51, 52,
53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
@@ -4003,7 +4102,7 @@ static const yytype_int16 yycheck[] =
113, -1, -1, 116, 117, 1, -1, 3, 4, 5,
6, 7, 8, 9, 10, 11, 12, -1, -1, 132,
133, 134, -1, 19, -1, 21, 22, 23, 24, -1,
- 143, 144, -1, 146, 30, 31, 32, 33, 34, 35,
+ -1, 144, -1, 146, 30, 31, 32, 33, 34, 35,
36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
-1, 47, 48, 49, 50, 51, 52, 53, 54, 55,
56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
@@ -4023,26 +4122,26 @@ static const yytype_int16 yycheck[] =
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
99, -1, -1, 102, -1, 104, 105, 106, 107, 108,
- 109, -1, -1, 112, 113, -1, -1, 116, 117, -1,
+ 109, -1, -1, 112, 113, -1, -1, 116, 117, 1,
+ -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+ 12, -1, -1, 132, 133, 134, -1, 19, -1, 21,
+ 22, 23, 24, -1, 143, 144, -1, 146, 30, 31,
+ 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
+ -1, -1, -1, 45, -1, 47, 48, 49, 50, 51,
+ 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
+ -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 132, 133, 134, -1, -1, 137, -1,
- -1, -1, -1, -1, -1, 144, 1, 146, 3, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, -1, -1,
- 15, -1, -1, -1, 19, -1, 21, 22, 23, 24,
- -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
- 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
- 45, -1, 47, 48, 49, 50, 51, 52, 53, 54,
- 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
- -1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
+ -1, 93, 94, -1, 96, 97, -1, 99, -1, -1,
+ 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
+ 112, 113, -1, -1, 116, 117, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
- -1, 96, 97, -1, 99, -1, -1, 102, -1, 104,
- 105, 106, 107, 108, 109, -1, -1, 112, 113, -1,
- -1, 116, 117, -1, -1, 3, 4, 5, 6, 7,
- 8, 9, 10, 11, 12, -1, -1, 132, 133, 134,
- -1, 19, -1, 21, 22, 23, 24, -1, -1, 144,
- -1, 146, 30, 31, 32, 33, 34, 35, 36, -1,
- -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
+ 132, 133, 134, -1, -1, 137, -1, -1, -1, -1,
+ -1, -1, 144, 1, 146, 3, 4, 5, 6, 7,
+ 8, 9, 10, 11, 12, -1, -1, 15, -1, -1,
+ -1, 19, -1, 21, 22, 23, 24, -1, -1, -1,
+ -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
+ -1, 39, -1, -1, -1, -1, -1, 45, -1, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
-1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
@@ -4054,7 +4153,7 @@ static const yytype_int16 yycheck[] =
11, 12, -1, -1, 132, 133, 134, -1, 19, -1,
21, 22, 23, 24, -1, -1, 144, -1, 146, 30,
31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
- -1, -1, -1, -1, 45, -1, 47, 48, 49, 50,
+ -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
-1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
@@ -4062,88 +4161,88 @@ static const yytype_int16 yycheck[] =
-1, -1, 93, 94, -1, 96, 97, -1, 99, -1,
-1, 102, -1, 104, 105, 106, 107, 108, 109, -1,
-1, 112, 113, -1, -1, 116, 117, -1, -1, 3,
- 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
+ 4, 5, 6, 7, 8, 9, 10, 11, 12, -1,
-1, 132, 133, 134, -1, 19, -1, 21, 22, 23,
24, -1, -1, 144, -1, 146, 30, 31, 32, 33,
34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
- -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
+ -1, 45, -1, 47, 48, 49, 50, 51, 52, 53,
54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
-1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
- 94, -1, 96, 97, -1, -1, -1, -1, 102, -1,
+ 94, -1, 96, 97, -1, 99, -1, -1, 102, -1,
104, 105, 106, 107, 108, 109, -1, -1, 112, 113,
- -1, -1, 116, 117, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 132, 133,
- 134, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 144, -1, 146, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
- -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
- -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
- 100, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 116, 117, -1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, -1, -1, -1, 132, 133,
+ 134, -1, 19, -1, 21, 22, 23, 24, -1, -1,
+ 144, -1, 146, 30, 31, 32, 33, 34, 35, 36,
+ -1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
+ -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+ -1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
+ 67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
- 130, 131, -1, 133, 134, -1, -1, -1, -1, -1,
- -1, 141, 142, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
- -1, 21, 22, 23, 24, -1, 26, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
- -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
- 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
- 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 90, -1, -1, 93, 94, -1, 96,
+ 97, -1, -1, -1, -1, 102, -1, 104, 105, 106,
+ 107, 108, 109, -1, -1, 112, 113, -1, -1, 116,
+ 117, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 132, 133, 134, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 144, -1, 146,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+ 23, 24, 25, 26, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
+ -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, -1, -1, 81, 82,
+ -1, -1, 85, 86, 87, 88, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 99, 100, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
- 100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, -1,
+ 133, 134, -1, -1, -1, -1, -1, -1, 141, 142,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
+ -1, -1, -1, -1, -1, -1, 19, -1, 21, 22,
+ 23, 24, -1, 26, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 132, 133, 134, -1, 136, -1, -1, -1,
- -1, -1, 142, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
- -1, 21, 22, 23, 24, -1, 26, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
- -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
- 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
- 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, 99, 100, 101, 102,
+ -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
- 100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 132,
+ 133, 134, -1, 136, -1, -1, -1, -1, -1, 142,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
+ -1, -1, -1, -1, -1, -1, 19, -1, 21, 22,
+ 23, 24, -1, 26, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 132, 133, 134, -1, 136, -1, -1, -1,
- -1, -1, 142, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
- -1, 21, 22, 23, 24, -1, 26, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
- -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
- 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
- 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, 99, 100, 101, 102,
+ -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
- 100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
- 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
- -1, -1, 132, 133, 134, 19, 136, 21, 22, 23,
- 24, -1, 142, -1, -1, -1, 30, 31, 32, 33,
- 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
- -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
- 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
- -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 132,
+ 133, 134, -1, 136, -1, -1, -1, -1, -1, 142,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
+ -1, -1, -1, -1, -1, -1, 19, -1, 21, 22,
+ 23, 24, -1, 26, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 90, 91, -1, 93,
- 94, -1, 96, 97, -1, 99, 100, 101, 102, -1,
- 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
- -1, -1, -1, -1, -1, 119, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, -1, -1, -1, 132, 133,
- 134, -1, 19, -1, 21, 22, 23, 24, 142, -1,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, 99, 100, 101, 102,
+ -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
+ -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, -1, -1, -1, -1, 132,
+ 133, 134, 19, 136, 21, 22, 23, 24, -1, 142,
-1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
-1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
-1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
@@ -4162,537 +4261,541 @@ static const yytype_int16 yycheck[] =
60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
+ 90, 91, -1, 93, 94, -1, 96, 97, -1, 99,
100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
- 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
- -1, -1, 132, 133, 134, 19, -1, 21, 22, 23,
- 24, -1, 142, -1, -1, -1, 30, 31, 32, 33,
- 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
- -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
- 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
- -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
- 94, -1, 96, 97, -1, 99, 100, 101, 102, -1,
- 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
- -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
- 8, 9, 10, 11, -1, -1, -1, -1, 132, 133,
- 134, 19, -1, 21, 22, 23, 24, -1, 142, -1,
- -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
- -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
- 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
- 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
- -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
- -1, 99, 100, 101, 102, -1, 104, 105, 106, 107,
- 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 132, 133, 134, -1, -1, -1,
- -1, -1, -1, -1, 142, 3, 4, 5, 6, 7,
- 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
- 18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
- -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
- 38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
- 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
- -1, -1, -1, -1, -1, 63, -1, -1, -1, -1,
- -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
- 78, -1, -1, 81, 82, -1, -1, 85, 86, 87,
- 88, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 99, 100, -1, -1, -1, -1, -1, -1, -1,
- 108, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 122, 123, 124, 125, 126, 127,
- 128, 129, 130, 131, -1, 133, 134, -1, -1, -1,
- -1, -1, -1, 141, 3, 4, 5, 6, 7, 8,
- 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
- 19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
- -1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
- 39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
- 49, 50, 51, 52, 53, 54, 55, 56, -1, -1,
- -1, -1, -1, -1, 63, -1, -1, -1, -1, -1,
- -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
- -1, -1, 81, 82, -1, -1, 85, 86, 87, 88,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 99, 100, -1, -1, -1, -1, -1, -1, -1, 108,
+ -1, -1, 112, -1, -1, -1, -1, -1, -1, 119,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
+ -1, -1, 132, 133, 134, -1, 19, -1, 21, 22,
+ 23, 24, 142, -1, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 122, 123, 124, 125, 126, 127, 128,
- 129, 130, 131, -1, 133, 134, -1, -1, -1, -1,
- -1, -1, 141, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
- -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
- 50, 51, 52, -1, -1, 55, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, 99, 100, 101, 102,
+ -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
+ -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, -1, -1, -1, -1, 132,
+ 133, 134, 19, -1, 21, 22, 23, 24, -1, 142,
+ -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
+ -1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
+ -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+ -1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
+ 67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
- -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
- 100, -1, -1, -1, 104, -1, -1, -1, -1, -1,
+ -1, -1, -1, 90, -1, -1, 93, 94, -1, 96,
+ 97, -1, 99, 100, 101, 102, -1, 104, 105, 106,
+ 107, 108, 109, -1, -1, 112, -1, -1, -1, -1,
+ -1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, -1, -1, -1, -1, 132, 133, 134, 19, -1,
+ 21, 22, 23, 24, -1, 142, -1, -1, -1, 30,
+ 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
+ -1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
+ -1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
+ 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
+ -1, -1, 93, 94, -1, 96, 97, -1, 99, 100,
+ 101, 102, -1, 104, 105, 106, 107, 108, 109, -1,
+ -1, 112, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
- 130, 131, -1, 133, 134, -1, -1, -1, -1, -1,
- -1, 141, 3, 4, 5, 6, 7, 8, 9, 10,
+ -1, 132, 133, 134, -1, -1, -1, -1, -1, -1,
+ -1, 142, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
-1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
- 51, 52, -1, -1, 55, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
+ 51, 52, 53, 54, 55, 56, -1, -1, -1, -1,
+ -1, -1, 63, -1, -1, -1, -1, -1, -1, 70,
71, 72, 73, 74, 75, 76, 77, 78, -1, -1,
81, 82, -1, -1, 85, 86, 87, 88, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 99, 100,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 108, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 122, 123, 124, 125, 126, 127, 128, 129, 130,
131, -1, 133, 134, -1, -1, -1, -1, -1, -1,
141, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- -1, -1, -1, -1, -1, -1, -1, 19, -1, 21,
- 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
- 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
- -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
- 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
- -1, 63, -1, -1, 66, 67, -1, 69, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
- -1, 93, 94, -1, 96, 97, -1, -1, -1, -1,
- 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
- 112, -1, -1, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
- 132, 21, 22, 23, 24, -1, -1, -1, 140, -1,
- 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
- -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
- 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, -1,
- -1, -1, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, -1, -1, 3, 4, 5, 6, 7,
- 8, 9, 10, 11, 12, -1, -1, -1, -1, -1,
- -1, 19, 132, 21, 22, 23, 24, -1, -1, -1,
- 140, -1, 30, 31, 32, 33, 34, 35, 36, -1,
- -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
- 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
- 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
- -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
- -1, 99, -1, -1, 102, -1, 104, 105, 106, 107,
- 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
- -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- -1, -1, -1, -1, 132, 133, 134, 19, -1, 21,
- 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
- 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
- -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
- 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
- -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 84, -1, -1, -1, -1, -1, 90, -1,
- -1, 93, 94, -1, 96, 97, -1, 99, 100, 101,
- 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
- 112, -1, -1, -1, -1, -1, -1, 3, 4, 5,
- 6, 7, 8, 9, 10, 11, 12, -1, -1, -1,
- 132, 133, 134, 19, -1, 21, 22, 23, 24, -1,
- -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
- 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
- -1, 47, 48, 49, 50, 51, 52, 53, 54, 55,
- 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
- 66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
+ 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+ 22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
+ -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
+ 52, 53, 54, 55, 56, -1, -1, -1, -1, -1,
+ -1, 63, -1, -1, -1, -1, -1, -1, 70, 71,
+ 72, 73, 74, 75, 76, 77, 78, -1, -1, 81,
+ 82, -1, -1, 85, 86, 87, 88, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 99, 100, -1,
+ -1, -1, -1, -1, -1, -1, 108, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
- 96, 97, -1, 99, -1, -1, 102, -1, 104, 105,
- 106, 107, 108, 109, -1, -1, 112, -1, -1, -1,
- -1, -1, -1, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, -1, -1, -1, -1, 132, 133, 134, 19,
- -1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
- -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
- 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
- 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
+ 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
+ -1, 133, 134, -1, -1, -1, -1, -1, -1, 141,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+ 23, 24, 25, 26, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
+ -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
+ -1, -1, 55, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, -1, -1, 81, 82,
+ -1, -1, 85, 86, 87, 88, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 99, 100, -1, -1,
+ -1, 104, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, -1,
+ 133, 134, -1, -1, -1, -1, -1, -1, 141, 3,
+ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
+ -1, 45, 46, 47, 48, 49, 50, 51, 52, -1,
+ -1, 55, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
+ 74, 75, 76, 77, 78, -1, -1, 81, 82, -1,
+ -1, 85, 86, 87, 88, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 99, 100, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
- 100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
- 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
- -1, -1, 132, 133, 134, 19, -1, 21, 22, 23,
- 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
- 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
- -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
- 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
- -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 122, 123,
+ 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
+ 134, -1, -1, -1, -1, -1, -1, 141, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
+ -1, -1, -1, -1, 19, -1, 21, 22, 23, 24,
+ -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
+ 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
+ -1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
+ -1, 66, 67, -1, 69, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
- 94, -1, 96, 97, -1, 99, 100, 101, 102, -1,
- 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
- -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
- 8, 9, 10, 11, -1, -1, -1, -1, 132, 133,
- 134, 19, -1, 21, 22, 23, 24, -1, -1, -1,
- -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
- -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
- 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
- 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
- -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
+ -1, 96, 97, -1, -1, -1, -1, 102, -1, 104,
+ 105, 106, 107, 108, 109, -1, -1, 112, -1, -1,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
+ -1, -1, -1, -1, -1, -1, 19, 132, 21, 22,
+ 23, 24, -1, -1, -1, 140, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
- -1, 99, 100, -1, 102, -1, 104, 105, 106, 107,
- 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
- -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- -1, -1, -1, -1, 132, 133, 134, 19, -1, 21,
- 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
- 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
- -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
- 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
- -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, -1, -1, -1, 102,
+ -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
+ -1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, -1, -1, -1, -1, -1, -1, 19, 132,
+ 21, 22, 23, 24, -1, -1, -1, 140, -1, 30,
+ 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
+ -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
+ -1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
+ 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
+ -1, -1, 93, 94, -1, 96, 97, -1, 99, -1,
+ -1, 102, -1, 104, 105, 106, 107, 108, 109, -1,
+ -1, 112, -1, -1, -1, -1, -1, -1, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
+ -1, 132, 133, 134, 19, -1, 21, 22, 23, 24,
+ -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
+ 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
+ -1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
+ -1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 84,
+ -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
+ -1, 96, 97, -1, 99, 100, 101, 102, -1, 104,
+ 105, 106, 107, 108, 109, -1, -1, 112, -1, -1,
+ -1, -1, -1, -1, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, 12, -1, -1, -1, 132, 133, 134,
+ 19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
+ -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
+ 39, -1, -1, -1, -1, -1, 45, -1, 47, 48,
+ 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
+ 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
+ 69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
- -1, 93, 94, -1, 96, 97, -1, -1, 100, 101,
- 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
- 112, -1, -1, -1, -1, -1, -1, 3, 4, 5,
- 6, 7, 8, 9, 10, 11, -1, -1, -1, -1,
- 132, 133, 134, 19, -1, 21, 22, 23, 24, -1,
- -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
- 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
- -1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
- 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
- 66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
+ -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
+ 99, -1, -1, 102, -1, 104, 105, 106, 107, 108,
+ 109, -1, -1, 112, -1, -1, -1, -1, -1, -1,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
+ -1, -1, -1, 132, 133, 134, 19, -1, 21, 22,
+ 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
- 96, 97, -1, 99, 100, -1, 102, -1, 104, 105,
- 106, 107, 108, 109, -1, -1, 112, -1, -1, -1,
- -1, -1, -1, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, -1, -1, -1, -1, 132, 133, 134, 19,
- -1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
- -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
- 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
- 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, 99, 100, 101, 102,
+ -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
+ -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, -1, -1, -1, -1, 132,
+ 133, 134, 19, -1, 21, 22, 23, 24, -1, -1,
+ -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
+ -1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
+ -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+ -1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
+ 67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, -1,
- 100, -1, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
- 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
- -1, -1, 132, 133, 134, 19, -1, 21, 22, 23,
- 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
- 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
- -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
- 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
- -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
+ -1, -1, -1, 90, -1, -1, 93, 94, -1, 96,
+ 97, -1, 99, 100, 101, 102, -1, 104, 105, 106,
+ 107, 108, 109, -1, -1, 112, -1, -1, -1, -1,
+ -1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, -1, -1, -1, -1, 132, 133, 134, 19, -1,
+ 21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
+ 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
+ -1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
+ -1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
+ 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
+ -1, -1, 93, 94, -1, 96, 97, -1, 99, 100,
+ -1, 102, -1, 104, 105, 106, 107, 108, 109, -1,
+ -1, 112, -1, -1, -1, -1, -1, -1, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
+ -1, 132, 133, 134, 19, -1, 21, 22, 23, 24,
+ -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
+ 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
+ -1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
+ -1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
- 94, -1, 96, 97, -1, 99, -1, -1, 102, -1,
- 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
- -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
- 8, 9, 10, 11, -1, -1, -1, -1, 132, 133,
- 134, 19, -1, 21, 22, 23, 24, -1, -1, -1,
- -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
- -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
- 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
- 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
- -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
+ -1, 96, 97, -1, -1, 100, 101, 102, -1, 104,
+ 105, 106, 107, 108, 109, -1, -1, 112, -1, -1,
+ -1, -1, -1, -1, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, -1, -1, -1, -1, 132, 133, 134,
+ 19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
+ -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
+ 39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
+ 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
+ 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
+ 69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
- -1, 99, -1, -1, 102, -1, 104, 105, 106, 107,
- 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
- -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- -1, -1, -1, -1, 132, 133, 134, 19, -1, 21,
- 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
- 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
- -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
- 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
- -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
+ -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
+ 99, 100, -1, 102, -1, 104, 105, 106, 107, 108,
+ 109, -1, -1, 112, -1, -1, -1, -1, -1, -1,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
+ -1, -1, -1, 132, 133, 134, 19, -1, 21, 22,
+ 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
- -1, 93, 94, -1, 96, 97, -1, 99, -1, -1,
- 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
- 112, -1, -1, -1, -1, -1, -1, 3, 4, 5,
- 6, 7, 8, 9, 10, 11, -1, -1, -1, -1,
- 132, 133, 134, 19, -1, 21, 22, 23, 24, -1,
- -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
- 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
- -1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
- 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
- 66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, -1, 100, -1, 102,
+ -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
+ -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, -1, -1, -1, -1, 132,
+ 133, 134, 19, -1, 21, 22, 23, 24, -1, -1,
+ -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
+ -1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
+ -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+ -1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
+ 67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
- 96, 97, -1, 99, -1, -1, 102, -1, 104, 105,
- 106, 107, 108, 109, -1, -1, 112, -1, -1, -1,
- -1, -1, -1, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, -1, -1, -1, -1, 132, 133, 134, 19,
- -1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
- -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
- 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
- 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 90, -1, -1, 93, 94, -1, 96,
+ 97, -1, 99, -1, -1, 102, -1, 104, 105, 106,
+ 107, 108, 109, -1, -1, 112, -1, -1, -1, -1,
+ -1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, -1, -1, -1, -1, 132, 133, 134, 19, -1,
+ 21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
+ 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
+ -1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
+ -1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
+ 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
+ -1, -1, 93, 94, -1, 96, 97, -1, 99, -1,
+ -1, 102, -1, 104, 105, 106, 107, 108, 109, -1,
+ -1, 112, -1, -1, -1, -1, -1, -1, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
+ -1, 132, 133, 134, 19, -1, 21, 22, 23, 24,
+ -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
+ 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
+ -1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
+ -1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
- -1, -1, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
- 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
- -1, -1, 132, 133, 134, 19, -1, 21, 22, 23,
- 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
- 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
- -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
- 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
- -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
+ -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
+ -1, 96, 97, -1, 99, -1, -1, 102, -1, 104,
+ 105, 106, 107, 108, 109, -1, -1, 112, -1, -1,
+ -1, -1, -1, -1, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, -1, -1, -1, -1, 132, 133, 134,
+ 19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
+ -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
+ 39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
+ 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
+ 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
+ 69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
- 94, -1, 96, 97, -1, -1, -1, -1, 102, -1,
- 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
- -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
- 8, 9, 10, 11, -1, -1, -1, -1, 132, 133,
- 134, 19, -1, 21, 22, 23, 24, -1, -1, -1,
- -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
- -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
- 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
- 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
- -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
+ -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
+ 99, -1, -1, 102, -1, 104, 105, 106, 107, 108,
+ 109, -1, -1, 112, -1, -1, -1, -1, -1, -1,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
+ -1, -1, -1, 132, 133, 134, 19, -1, 21, 22,
+ 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
- -1, -1, -1, -1, 102, -1, 104, 105, 106, 107,
- 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
- -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- -1, -1, -1, -1, 132, 133, 134, 19, -1, 21,
- 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
- 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
- -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
- 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
- -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, 99, -1, -1, 102,
+ -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
+ -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, -1, -1, -1, -1, 132,
+ 133, 134, 19, -1, 21, 22, 23, 24, -1, -1,
+ -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
+ -1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
+ -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+ -1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
+ 67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
- -1, 93, 94, -1, 96, 97, -1, -1, -1, -1,
- 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
- 112, -1, -1, -1, -1, -1, -1, 3, 4, 5,
- 6, 7, 8, 9, 10, 11, -1, -1, -1, -1,
- 132, 133, 134, 19, -1, 21, 22, 23, 24, -1,
- -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
- 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
- -1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
- 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
- 66, 67, -1, 69, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 90, -1, -1, 93, 94, -1, 96,
+ 97, -1, -1, -1, -1, 102, -1, 104, 105, 106,
+ 107, 108, 109, -1, -1, 112, -1, -1, -1, -1,
+ -1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, -1, -1, -1, -1, 132, 133, 134, 19, -1,
+ 21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
+ 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
+ -1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
+ -1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
+ 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
+ -1, -1, 93, 94, -1, 96, 97, -1, -1, -1,
+ -1, 102, -1, 104, 105, 106, 107, 108, 109, -1,
+ -1, 112, -1, -1, -1, -1, -1, -1, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
+ -1, 132, 133, 134, 19, -1, 21, 22, 23, 24,
+ -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
+ 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
+ -1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
+ -1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 87, -1, -1, 90, -1, -1, 93, 94, -1,
- 96, 97, -1, -1, -1, -1, 102, -1, 104, 105,
- 106, 107, 108, 109, -1, -1, 112, -1, -1, 3,
- 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
- -1, -1, -1, -1, -1, 19, 132, 21, 22, 23,
- 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
- 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
- -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
- 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
- -1, -1, 66, 67, -1, 69, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
+ -1, 96, 97, -1, -1, -1, -1, 102, -1, 104,
+ 105, 106, 107, 108, 109, -1, -1, 112, -1, -1,
+ -1, -1, -1, -1, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, -1, -1, -1, -1, 132, 133, 134,
+ 19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
+ -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
+ 39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
+ 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
+ 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
+ 69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 87, -1,
+ -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
+ -1, -1, -1, 102, -1, 104, 105, 106, 107, 108,
+ 109, -1, -1, 112, -1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, -1, -1, -1, -1, -1,
+ -1, -1, 19, 132, 21, 22, 23, 24, -1, -1,
+ -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
+ -1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
+ -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+ -1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
+ 67, -1, 69, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
- 94, -1, 96, 97, -1, 99, -1, -1, 102, -1,
- 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
- -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- -1, -1, -1, -1, -1, -1, -1, 19, 132, 21,
- 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
- 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
- -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
- 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
- -1, 63, -1, -1, 66, 67, -1, 69, -1, -1,
+ -1, -1, -1, 90, -1, -1, 93, 94, -1, 96,
+ 97, -1, 99, -1, -1, 102, -1, 104, 105, 106,
+ 107, 108, 109, -1, -1, 112, -1, -1, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
+ -1, -1, -1, -1, 19, 132, 21, 22, 23, 24,
+ -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
+ 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
+ -1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
+ -1, 66, 67, -1, 69, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
- -1, 93, 94, -1, 96, 97, -1, 99, -1, -1,
- 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
- 112, -1, -1, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
- 132, 21, 22, 23, 24, -1, -1, -1, -1, -1,
- 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
- -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
- 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
+ -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
+ -1, 96, 97, -1, 99, -1, -1, 102, -1, 104,
+ 105, 106, 107, 108, 109, -1, -1, 112, -1, -1,
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
+ -1, -1, -1, -1, -1, -1, 19, 132, 21, 22,
+ 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
+ 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
+ -1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
+ 63, -1, -1, 66, 67, -1, 69, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
+ 93, 94, -1, 96, 97, -1, -1, -1, -1, 102,
+ -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
+ -1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, -1, -1, -1, -1, -1, -1, -1, 19, 132,
+ 21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
+ 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
+ -1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
+ -1, -1, 63, -1, -1, 66, 67, -1, 69, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 90, -1, -1, 93, 94, -1, 96, 97, -1, -1,
- -1, -1, 102, -1, 104, 105, 106, 107, 108, 109,
- -1, -1, 112, -1, -1, 3, 4, 5, 6, 7,
- 8, 9, 10, 11, -1, -1, -1, -1, -1, -1,
- -1, 19, 132, 21, 22, 23, 24, -1, -1, -1,
- -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
- -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
- 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
- 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
- -1, 69, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
+ -1, -1, 93, 94, -1, 96, 97, -1, -1, -1,
+ -1, 102, -1, 104, 105, 106, 107, 108, 109, -1,
+ -1, 112, -1, -1, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, -1, -1, -1, -1, -1, -1, -1,
+ 19, 132, 21, 22, 23, 24, -1, -1, -1, -1,
+ -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
+ 39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
+ 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
+ 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
+ 69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
- -1, -1, -1, -1, 102, -1, 104, 105, 106, 107,
- 108, 109, -1, -1, 112, -1, -1, 3, 4, 5,
- 6, 7, 8, 9, 10, 11, -1, -1, -1, -1,
- -1, -1, -1, 19, 132, 21, 22, 23, 24, -1,
- -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
- 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
- -1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
- 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
- 66, 67, -1, 69, -1, -1, -1, -1, -1, -1,
+ -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
+ -1, -1, -1, 102, -1, 104, 105, 106, 107, 108,
+ 109, -1, -1, 112, -1, -1, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, -1, -1, -1, -1, -1,
+ -1, -1, 19, 132, 21, 22, 23, 24, -1, -1,
+ -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
+ -1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
+ -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+ -1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
+ 67, -1, 69, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
- 96, 97, -1, -1, -1, -1, 102, -1, 104, 105,
- 106, 107, 108, 109, -1, -1, 112, -1, -1, 3,
- 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
- -1, -1, -1, -1, -1, 19, 132, 21, 22, 23,
- 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
- 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
- -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
- 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
- -1, -1, 66, 67, -1, 69, -1, -1, -1, -1,
+ -1, -1, -1, 90, -1, -1, 93, 94, -1, 96,
+ 97, -1, 51, 52, -1, 102, 55, 104, 105, 106,
+ 107, 108, 109, -1, -1, 112, -1, -1, -1, -1,
+ -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ -1, -1, 81, 82, -1, 132, 85, 86, 87, 88,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
- 94, -1, 96, 97, -1, 51, 52, -1, 102, 55,
- 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
- -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
- 76, 77, 78, -1, -1, 81, 82, -1, 132, 85,
- 86, 87, 88, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 99, 100, -1, -1, -1, -1, -1,
+ 99, 100, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 122, 123, 124, 125,
- 126, 127, 128, 129, 130, 131, -1, 133, 134, 51,
- 52, -1, -1, 55, -1, 141, 142, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 70, 71,
- 72, 73, 74, 75, 76, 77, 78, -1, -1, 81,
- 82, -1, -1, 85, 86, 87, 88, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 99, 100, -1,
+ -1, -1, -1, 122, 123, 124, 125, 126, 127, 128,
+ 129, 130, 131, -1, 133, 134, 51, 52, -1, -1,
+ 55, -1, 141, 142, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
+ 75, 76, 77, 78, -1, -1, 81, 82, -1, -1,
+ 85, 86, 87, 88, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 99, 100, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
+ 125, 126, 127, 128, 129, 130, 131, -1, 133, 134,
+ 51, 52, -1, -1, 55, -1, 141, 142, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, -1, -1,
+ 81, 82, -1, -1, 85, 86, 87, 88, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 99, 100,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
- -1, 133, 134, 51, 52, -1, -1, 55, -1, 141,
- 142, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
- 78, -1, -1, 81, 82, -1, -1, 85, 86, 87,
- 88, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 99, 100, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 122, 123, 124, 125, 126, 127,
- 128, 129, 130, 131, -1, 133, 134, 51, 52, -1,
- -1, 55, -1, 141, 142, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
- 74, 75, 76, 77, 78, -1, -1, 81, 82, -1,
- -1, 85, 86, 87, 88, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 99, 100, -1, -1, -1,
+ -1, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+ 131, -1, 133, 134, 51, 52, -1, -1, 55, -1,
+ 141, 142, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
+ 77, 78, -1, -1, 81, 82, -1, -1, 85, 86,
+ 87, 88, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 99, 100, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 122, 123,
- 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
- 134, 51, 52, -1, -1, 55, -1, 141, 142, -1,
+ -1, -1, -1, -1, -1, 122, 123, 124, 125, 126,
+ 127, 128, 129, 130, 131, -1, 133, 134, 51, 52,
+ -1, -1, 55, -1, 141, 142, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, -1, -1, 81, 82,
+ -1, -1, 85, 86, 87, 88, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 99, 100, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
- -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
- 100, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, -1,
+ 133, 134, 51, 52, -1, -1, 55, -1, 141, 142,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
- 130, 131, -1, 133, 134, 51, 52, -1, -1, 55,
- -1, 141, 142, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
- 76, 77, 78, -1, -1, 81, 82, -1, -1, 85,
- 86, 87, 88, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 99, 100, -1, -1, -1, -1, -1,
+ -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ -1, -1, 81, 82, -1, -1, 85, 86, 87, 88,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 122, 123, 124, 125,
- 126, 127, 128, 129, 130, 131, -1, 133, 134, 51,
- 52, -1, -1, 55, -1, 141, 142, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 70, 71,
- 72, 73, 74, 75, 76, 77, 78, -1, -1, 81,
- 82, -1, -1, 85, 86, 87, 88, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 99, 100, -1,
+ 99, 100, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 122, 123, 124, 125, 126, 127, 128,
+ 129, 130, 131, -1, 133, 134, 51, 52, -1, -1,
+ 55, -1, 141, 142, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
+ 75, 76, 77, 78, -1, -1, 81, 82, -1, -1,
+ 85, 86, 87, 88, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 99, 100, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
- -1, 133, 134, 51, 52, -1, -1, 55, -1, 141,
- 142, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
- 78, -1, -1, 81, 82, -1, -1, 85, 86, 87,
- 88, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 99, 100, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
+ 125, 126, 127, 128, 129, 130, 131, -1, 133, 134,
+ 51, 52, -1, -1, 55, -1, 141, 142, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, -1, -1,
+ 81, 82, -1, -1, 85, 86, 87, 88, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 99, 100,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 122, 123, 124, 125, 126, 127,
- 128, 129, 130, 131, -1, 133, 134, 51, 52, -1,
- -1, 55, -1, 141, 142, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
- 74, 75, 76, 77, 78, -1, -1, 81, 82, -1,
- -1, 85, 86, 87, 88, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 99, 100, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 122, 123,
- 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
- 134, 51, 52, -1, -1, 55, -1, 141, 142, -1,
+ -1, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+ 131, -1, 133, 134, 51, 52, -1, -1, 55, -1,
+ 141, 142, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
+ 77, 78, -1, -1, 81, 82, -1, -1, 85, 86,
+ 87, 88, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 99, 100, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
- -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
- 100, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 122, 123, 124, 125, 126,
+ 127, 128, 129, 130, 131, -1, 133, 134, 51, 52,
+ -1, -1, 55, -1, 141, 142, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, -1, -1, 81, 82,
+ -1, -1, 85, 86, 87, 88, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 99, 100, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
- 130, 131, -1, 133, 134, 51, 52, -1, -1, 55,
- -1, 141, 142, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
- 76, 77, 78, -1, -1, 81, 82, -1, -1, 85,
- 86, 87, 88, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 99, 100, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, -1,
+ 133, 134, 51, 52, -1, -1, 55, -1, 141, 142,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 122, 123, 124, 125,
- 126, 127, 128, 129, 130, 131, -1, 133, 134, 51,
- 52, -1, -1, 55, -1, 141, 142, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 70, 71,
- 72, 73, 74, 75, 76, 77, 78, -1, -1, 81,
- 82, -1, -1, 85, 86, 87, 88, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 99, 100, -1,
+ -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ -1, -1, 81, 82, -1, -1, 85, 86, 87, 88,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 99, 100, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
- -1, 133, 134, 51, 52, -1, -1, 55, -1, 141,
- 142, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
- 78, -1, -1, 81, 82, -1, -1, 85, 86, 87,
- 88, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 99, 100, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 122, 123, 124, 125, 126, 127, 128,
+ 129, 130, 131, -1, 133, 134, 51, 52, -1, -1,
+ 55, -1, 141, 142, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
+ 75, 76, 77, 78, -1, -1, 81, 82, -1, -1,
+ 85, 86, 87, 88, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 99, 100, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 122, 123, 124, 125, 126, 127,
- 128, 129, 130, 131, -1, 133, 134, 51, 52, -1,
- -1, 55, -1, 141, 142, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
- 74, 75, 76, 77, 78, -1, -1, 81, 82, -1,
- -1, 85, 86, 87, 88, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 99, 100, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
+ 125, 126, 127, 128, 129, 130, 131, -1, 133, 134,
+ 51, 52, -1, -1, 55, -1, 141, 142, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, -1, -1,
+ 81, 82, -1, -1, 85, 86, 87, 88, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 99, 100,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 122, 123,
- 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
- 134, 51, 52, -1, -1, 55, -1, 141, 142, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
- -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
- 100, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+ 131, -1, 133, 134, 51, 52, -1, -1, 55, -1,
+ 141, 142, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
+ 77, 78, -1, -1, 81, 82, -1, -1, 85, 86,
+ 87, 88, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 99, 100, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
- 130, 131, -1, 133, 134, 51, 52, -1, -1, 55,
- -1, 141, 142, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
- 76, 77, 78, -1, -1, 81, 82, -1, -1, 85,
- 86, 87, 88, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 99, 100, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 44, -1,
- -1, -1, -1, -1, -1, -1, 122, 123, 124, 125,
- 126, 127, 128, 129, 130, 131, -1, 133, 134, -1,
- -1, -1, -1, -1, -1, 141, 72, 73, 74, 75,
- 76, 77, 78, 79, 80, 81, 82, 83, 84, -1,
- -1, 87, 88, 72, 73, 74, 75, 76, 77, 78,
- 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
+ -1, -1, -1, -1, -1, 122, 123, 124, 125, 126,
+ 127, 128, 129, 130, 131, -1, 133, 134, 51, 52,
+ -1, -1, 55, -1, 141, 142, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, -1, -1, 81, 82,
+ -1, -1, 85, 86, 87, 88, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 99, 100, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 120, -1, 122, 123, 124, 125,
- 126, 127, 128, 129, 130, 131, -1, -1, -1, -1,
- -1, 120, -1, 122, 123, 124, 125, 126, 127, 128,
- 129, 130, 131, 72, 73, 74, 75, 76, 77, 78,
- 79, 80, 81, 82, 83, 84, -1, 146, 87, 88,
+ -1, 44, -1, -1, -1, -1, -1, -1, -1, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 44,
+ 133, 134, -1, -1, -1, -1, -1, -1, 141, 72,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
+ 83, 84, -1, -1, 87, 88, -1, 72, 73, 74,
+ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
+ -1, -1, 87, 88, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 120, -1, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, -1,
+ -1, -1, -1, -1, -1, 120, -1, 122, 123, 124,
+ 125, 126, 127, 128, 129, 130, 131, 72, 73, 74,
+ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
+ -1, -1, 87, 88, -1, -1, -1, -1, -1, -1,
-1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, -1, -1, 87, 88, -1,
+ -1, -1, -1, -1, -1, 120, -1, 122, 123, 124,
+ 125, 126, 127, 128, 129, 130, 131, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 120, -1, 122, 123, 124, 125, 126, 127, 128,
- 129, 130, 131, -1, -1, -1, -1, -1, -1, -1,
- 120, 140, 122, 123, 124, 125, 126, 127, 128, 129,
+ 120, 146, 122, 123, 124, 125, 126, 127, 128, 129,
130, 131, -1, -1, -1, -1, -1, -1, -1, -1,
140, 72, 73, 74, 75, 76, 77, 78, 79, 80,
81, 82, 83, 84, -1, -1, 87, 88, -1, -1,
@@ -4704,27 +4807,27 @@ static const yytype_int16 yycheck[] =
122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
-1, -1, -1, -1, -1, -1, -1, -1, 140, 72,
73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
- 83, 84, -1, -1, 87, 88, -1, -1, -1, 92,
- 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
- 82, 83, 84, -1, -1, 87, 88, -1, -1, -1,
+ 83, 84, -1, -1, 87, 88, -1, -1, 72, 73,
+ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+ 84, -1, -1, 87, 88, -1, -1, -1, 92, -1,
-1, -1, -1, -1, -1, -1, -1, 120, -1, 122,
123, 124, 125, 126, 127, 128, 129, 130, 131, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 120, -1,
- 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
- 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
- 82, 83, 84, -1, -1, 87, 88, 72, 73, 74,
- 75, 76, 77, 78, 79, -1, 81, 82, -1, -1,
- -1, -1, 87, 88, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
- -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
- 125, 126, 127, 128, 129, 130, 131, 72, 73, 74,
- 75, 76, 77, 78, -1, -1, 81, 82, -1, -1,
- -1, -1, 87, 88, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 120, 140, 122, 123,
+ 124, 125, 126, 127, 128, 129, 130, 131, 72, 73,
+ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+ 84, -1, -1, 87, 88, -1, -1, -1, 92, 72,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
+ 83, 84, -1, -1, 87, 88, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 120, -1, 122, 123,
+ 124, 125, 126, 127, 128, 129, 130, 131, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 120, -1, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 72,
+ 73, 74, 75, 76, 77, 78, -1, -1, 81, 82,
+ -1, -1, -1, -1, 87, 88, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
- 125, 126, 127, 128, 129, 130, 131
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -4738,103 +4841,105 @@ static const yytype_int16 yystos[] =
58, 59, 60, 63, 66, 67, 69, 70, 71, 90,
93, 94, 96, 97, 99, 102, 104, 105, 106, 107,
108, 109, 112, 132, 133, 134, 150, 151, 152, 157,
- 159, 161, 163, 164, 167, 168, 170, 171, 172, 174,
- 175, 184, 198, 219, 240, 241, 251, 252, 253, 257,
- 258, 259, 265, 266, 267, 269, 270, 271, 272, 273,
- 274, 309, 322, 152, 21, 22, 30, 31, 32, 39,
- 51, 55, 69, 87, 90, 93, 132, 176, 177, 198,
- 219, 271, 274, 309, 177, 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, 35, 36, 37, 38, 39, 45,
- 46, 47, 48, 49, 50, 51, 52, 55, 70, 71,
- 72, 73, 74, 75, 76, 77, 78, 81, 82, 85,
- 86, 87, 88, 99, 100, 122, 123, 124, 125, 126,
- 127, 128, 129, 130, 131, 133, 134, 141, 142, 178,
- 182, 183, 273, 303, 199, 90, 161, 162, 175, 219,
- 271, 272, 274, 162, 205, 207, 69, 90, 168, 175,
- 219, 224, 271, 274, 33, 34, 35, 36, 48, 49,
- 50, 51, 55, 104, 178, 179, 180, 267, 113, 116,
- 117, 144, 146, 162, 261, 262, 263, 315, 319, 320,
- 321, 51, 99, 100, 101, 133, 167, 184, 190, 193,
- 196, 253, 306, 308, 190, 190, 142, 187, 188, 191,
- 192, 322, 187, 191, 142, 316, 320, 179, 153, 136,
- 184, 219, 184, 55, 1, 93, 155, 156, 157, 169,
- 170, 322, 200, 202, 185, 196, 306, 322, 184, 305,
- 306, 322, 90, 140, 174, 219, 271, 274, 203, 53,
- 54, 56, 63, 108, 178, 268, 62, 64, 65, 114,
- 115, 254, 255, 63, 254, 63, 254, 63, 254, 61,
- 254, 58, 59, 163, 184, 184, 315, 321, 40, 41,
- 42, 43, 44, 37, 38, 28, 238, 119, 140, 93,
- 99, 171, 119, 72, 73, 74, 75, 76, 77, 78,
- 79, 80, 81, 82, 83, 84, 87, 88, 120, 122,
- 123, 124, 125, 126, 127, 128, 129, 130, 131, 89,
- 103, 138, 145, 313, 89, 313, 314, 26, 136, 242,
- 253, 91, 91, 187, 191, 242, 161, 51, 55, 176,
- 58, 59, 123, 275, 89, 138, 313, 214, 304, 215,
- 89, 145, 312, 154, 155, 55, 16, 220, 319, 119,
- 89, 138, 313, 91, 91, 220, 162, 162, 55, 89,
- 138, 313, 25, 108, 140, 264, 315, 113, 263, 20,
- 245, 319, 57, 307, 184, 184, 184, 92, 140, 194,
- 195, 322, 307, 194, 195, 84, 189, 190, 196, 306,
- 322, 190, 161, 315, 317, 161, 158, 136, 155, 89,
- 313, 91, 157, 169, 143, 315, 321, 317, 157, 317,
- 139, 195, 318, 321, 195, 318, 137, 318, 55, 171,
- 172, 173, 140, 89, 138, 313, 51, 53, 54, 55,
- 56, 69, 72, 93, 99, 100, 101, 126, 129, 142,
- 236, 278, 279, 282, 283, 284, 285, 287, 288, 289,
- 290, 292, 293, 294, 297, 298, 299, 300, 301, 63,
- 254, 256, 260, 261, 62, 255, 63, 63, 63, 61,
- 72, 72, 152, 162, 162, 162, 162, 157, 161, 161,
- 239, 99, 163, 184, 196, 197, 169, 140, 174, 140,
- 159, 160, 163, 175, 184, 186, 197, 219, 274, 184,
- 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
- 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
- 184, 184, 184, 184, 184, 51, 52, 55, 182, 187,
- 310, 311, 189, 51, 52, 55, 182, 187, 310, 51,
- 55, 310, 244, 243, 160, 184, 186, 160, 186, 98,
- 165, 212, 276, 211, 51, 55, 176, 310, 189, 310,
- 154, 161, 216, 217, 15, 13, 247, 322, 155, 16,
- 51, 55, 189, 51, 55, 155, 27, 221, 319, 221,
- 51, 55, 189, 51, 55, 209, 181, 155, 245, 184,
- 196, 15, 260, 184, 184, 316, 99, 184, 193, 306,
- 184, 308, 317, 143, 315, 195, 195, 317, 143, 179,
- 150, 137, 186, 317, 157, 201, 306, 171, 173, 51,
- 55, 189, 51, 55, 57, 119, 291, 287, 204, 184,
- 140, 302, 322, 51, 140, 302, 140, 286, 184, 140,
- 286, 51, 140, 286, 51, 63, 155, 261, 184, 184,
- 80, 124, 230, 231, 322, 184, 195, 317, 173, 140,
- 44, 119, 44, 89, 138, 313, 316, 91, 91, 187,
- 191, 139, 91, 91, 188, 191, 188, 191, 230, 230,
- 166, 319, 162, 154, 139, 15, 317, 142, 277, 287,
- 178, 184, 197, 248, 322, 18, 223, 322, 17, 222,
- 223, 91, 91, 139, 91, 91, 223, 206, 208, 139,
- 162, 179, 137, 15, 195, 220, 260, 184, 194, 306,
- 137, 317, 318, 139, 51, 99, 225, 292, 233, 316,
- 29, 111, 237, 51, 279, 284, 301, 285, 290, 297,
- 299, 292, 294, 299, 51, 292, 137, 227, 229, 232,
- 278, 280, 281, 284, 292, 293, 295, 296, 299, 301,
- 154, 99, 184, 173, 157, 184, 51, 55, 189, 51,
- 55, 57, 121, 160, 186, 163, 186, 165, 91, 160,
- 186, 160, 186, 165, 242, 238, 154, 155, 230, 213,
- 319, 15, 84, 287, 154, 319, 218, 92, 249, 322,
- 155, 14, 250, 322, 162, 15, 91, 15, 155, 155,
- 221, 184, 155, 195, 140, 289, 317, 140, 143, 144,
- 154, 155, 302, 140, 286, 140, 286, 140, 286, 140,
- 286, 286, 233, 233, 90, 219, 140, 302, 302, 140,
- 228, 219, 140, 228, 140, 228, 15, 184, 139, 184,
- 184, 160, 186, 15, 137, 155, 154, 317, 317, 15,
- 277, 90, 175, 219, 271, 274, 220, 155, 220, 15,
- 15, 210, 223, 245, 246, 226, 140, 99, 51, 234,
- 235, 288, 15, 137, 292, 299, 292, 292, 124, 124,
- 55, 89, 280, 284, 140, 227, 228, 296, 299, 292,
- 295, 299, 292, 137, 15, 154, 55, 89, 138, 313,
- 155, 155, 155, 292, 292, 140, 289, 140, 316, 286,
- 140, 286, 286, 286, 51, 55, 302, 140, 228, 140,
- 228, 140, 228, 140, 228, 228, 15, 51, 55, 189,
- 51, 55, 247, 222, 15, 140, 292, 140, 235, 292,
- 292, 299, 292, 292, 139, 292, 286, 228, 140, 228,
- 228, 228, 292, 228
+ 159, 160, 162, 163, 164, 167, 168, 171, 172, 174,
+ 175, 176, 178, 179, 188, 202, 219, 240, 241, 251,
+ 252, 253, 257, 258, 259, 265, 266, 267, 269, 270,
+ 271, 272, 273, 274, 310, 323, 152, 21, 22, 30,
+ 31, 32, 39, 51, 55, 69, 87, 90, 93, 132,
+ 163, 164, 180, 181, 202, 219, 271, 274, 310, 181,
+ 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, 35,
+ 36, 37, 38, 39, 45, 46, 47, 48, 49, 50,
+ 51, 52, 55, 70, 71, 72, 73, 74, 75, 76,
+ 77, 78, 81, 82, 85, 86, 87, 88, 99, 100,
+ 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
+ 133, 134, 141, 142, 182, 186, 187, 273, 304, 203,
+ 90, 162, 166, 179, 188, 219, 271, 272, 274, 166,
+ 209, 211, 69, 90, 172, 179, 219, 224, 271, 274,
+ 33, 34, 35, 36, 48, 49, 50, 51, 55, 104,
+ 182, 183, 184, 267, 113, 116, 117, 144, 146, 166,
+ 261, 262, 263, 316, 320, 321, 322, 51, 99, 100,
+ 101, 133, 171, 188, 194, 197, 200, 253, 307, 309,
+ 194, 194, 142, 191, 192, 195, 196, 323, 191, 195,
+ 142, 317, 321, 183, 153, 136, 188, 219, 188, 55,
+ 1, 93, 155, 156, 157, 173, 174, 323, 204, 206,
+ 189, 200, 307, 323, 188, 306, 307, 323, 90, 140,
+ 178, 219, 271, 274, 207, 53, 54, 56, 63, 108,
+ 182, 268, 62, 64, 65, 114, 115, 254, 255, 63,
+ 254, 63, 254, 63, 254, 61, 254, 58, 59, 167,
+ 188, 188, 316, 322, 40, 41, 42, 43, 44, 92,
+ 37, 38, 51, 53, 54, 55, 56, 69, 72, 93,
+ 99, 100, 101, 126, 129, 142, 277, 278, 279, 280,
+ 283, 284, 285, 286, 288, 289, 290, 291, 293, 294,
+ 295, 298, 299, 300, 301, 302, 277, 278, 28, 238,
+ 119, 140, 93, 99, 175, 119, 72, 73, 74, 75,
+ 76, 77, 78, 79, 80, 81, 82, 83, 84, 87,
+ 88, 92, 120, 122, 123, 124, 125, 126, 127, 128,
+ 129, 130, 131, 89, 103, 138, 145, 314, 89, 314,
+ 315, 26, 136, 242, 253, 91, 91, 191, 195, 242,
+ 162, 51, 55, 180, 58, 59, 277, 123, 275, 89,
+ 138, 314, 218, 305, 89, 145, 313, 154, 155, 55,
+ 16, 220, 320, 119, 89, 138, 314, 91, 91, 220,
+ 166, 166, 55, 89, 138, 314, 25, 108, 140, 264,
+ 316, 113, 263, 20, 245, 320, 57, 308, 188, 188,
+ 188, 92, 140, 198, 199, 323, 308, 198, 199, 84,
+ 193, 194, 200, 307, 323, 194, 162, 316, 318, 162,
+ 158, 136, 155, 89, 314, 91, 157, 173, 143, 316,
+ 322, 318, 157, 318, 139, 199, 319, 322, 199, 319,
+ 137, 319, 55, 175, 176, 177, 140, 89, 138, 314,
+ 142, 236, 288, 63, 254, 256, 260, 261, 62, 255,
+ 63, 63, 63, 61, 72, 72, 152, 166, 166, 166,
+ 166, 157, 172, 179, 162, 162, 57, 119, 292, 84,
+ 288, 119, 154, 188, 140, 303, 323, 51, 140, 303,
+ 320, 140, 287, 188, 140, 287, 51, 140, 287, 51,
+ 119, 154, 239, 99, 167, 188, 200, 201, 173, 140,
+ 178, 140, 160, 161, 167, 179, 188, 190, 201, 219,
+ 274, 188, 188, 188, 188, 188, 188, 188, 188, 188,
+ 188, 188, 188, 188, 188, 188, 172, 179, 188, 188,
+ 188, 188, 188, 188, 188, 188, 188, 188, 188, 51,
+ 52, 55, 186, 191, 311, 312, 193, 51, 52, 55,
+ 186, 191, 311, 51, 55, 311, 244, 243, 161, 188,
+ 190, 161, 190, 98, 169, 216, 276, 215, 51, 55,
+ 180, 311, 193, 311, 154, 162, 165, 15, 13, 247,
+ 323, 155, 16, 51, 55, 193, 51, 55, 155, 27,
+ 221, 320, 221, 51, 55, 193, 51, 55, 213, 185,
+ 155, 245, 188, 200, 15, 260, 188, 188, 317, 99,
+ 188, 197, 307, 188, 309, 318, 143, 316, 199, 199,
+ 318, 143, 183, 150, 137, 190, 318, 157, 205, 307,
+ 175, 177, 51, 55, 193, 51, 55, 288, 208, 63,
+ 155, 261, 188, 188, 51, 99, 225, 293, 318, 318,
+ 188, 15, 51, 280, 285, 302, 286, 291, 298, 300,
+ 293, 295, 300, 51, 293, 188, 15, 80, 124, 230,
+ 231, 323, 188, 199, 318, 177, 140, 44, 119, 44,
+ 89, 138, 314, 317, 91, 91, 191, 195, 139, 91,
+ 91, 192, 195, 192, 195, 230, 230, 170, 320, 166,
+ 154, 139, 15, 318, 182, 188, 201, 248, 323, 18,
+ 223, 323, 17, 222, 223, 91, 91, 139, 91, 91,
+ 223, 210, 212, 139, 166, 183, 137, 15, 199, 220,
+ 260, 188, 198, 307, 137, 318, 319, 139, 233, 317,
+ 29, 111, 237, 137, 140, 290, 318, 140, 44, 303,
+ 140, 287, 140, 287, 140, 287, 140, 287, 287, 44,
+ 227, 229, 232, 279, 281, 282, 285, 293, 294, 296,
+ 297, 300, 302, 154, 99, 188, 177, 157, 188, 51,
+ 55, 193, 51, 55, 57, 121, 161, 190, 167, 190,
+ 169, 91, 161, 190, 161, 190, 169, 242, 238, 154,
+ 155, 230, 217, 320, 15, 92, 249, 323, 155, 14,
+ 250, 323, 166, 15, 91, 15, 155, 155, 221, 188,
+ 155, 199, 143, 144, 154, 155, 226, 140, 99, 188,
+ 293, 300, 293, 293, 188, 233, 233, 90, 219, 140,
+ 303, 303, 140, 228, 219, 140, 228, 140, 228, 15,
+ 188, 139, 188, 188, 161, 190, 15, 137, 155, 154,
+ 90, 179, 219, 271, 274, 220, 155, 220, 15, 15,
+ 214, 223, 245, 246, 51, 234, 235, 289, 15, 137,
+ 293, 293, 140, 290, 287, 140, 287, 287, 287, 124,
+ 124, 55, 89, 281, 285, 140, 227, 228, 297, 300,
+ 293, 296, 300, 293, 137, 15, 55, 89, 138, 314,
+ 155, 155, 155, 140, 317, 140, 293, 140, 293, 51,
+ 55, 303, 140, 228, 140, 228, 140, 228, 140, 228,
+ 228, 51, 55, 193, 51, 55, 247, 222, 15, 235,
+ 293, 287, 293, 300, 293, 293, 139, 228, 140, 228,
+ 228, 228, 293, 228
};
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
@@ -4843,63 +4948,64 @@ static const yytype_int16 yyr1[] =
0, 147, 149, 148, 150, 151, 151, 151, 151, 152,
153, 152, 154, 155, 156, 156, 156, 156, 158, 157,
157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
- 157, 157, 157, 159, 159, 159, 159, 159, 159, 159,
- 159, 160, 160, 160, 161, 161, 161, 161, 161, 161,
- 162, 163, 163, 164, 164, 166, 165, 167, 167, 167,
- 167, 167, 167, 167, 167, 167, 167, 167, 168, 168,
- 169, 169, 170, 170, 170, 170, 170, 170, 170, 170,
- 170, 170, 171, 171, 172, 172, 173, 173, 174, 174,
- 174, 174, 174, 174, 174, 174, 175, 175, 175, 175,
- 175, 175, 175, 175, 175, 176, 176, 177, 177, 177,
- 178, 178, 178, 178, 178, 179, 179, 180, 181, 180,
- 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
- 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
- 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
- 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
- 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
- 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
- 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
- 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
- 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
- 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
- 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
- 184, 184, 184, 185, 185, 185, 185, 186, 186, 187,
- 187, 188, 188, 189, 189, 189, 189, 189, 190, 190,
- 190, 190, 190, 192, 191, 193, 194, 194, 195, 195,
- 196, 196, 196, 196, 197, 197, 197, 198, 198, 198,
- 198, 198, 198, 198, 198, 198, 199, 198, 200, 201,
- 198, 202, 198, 198, 198, 198, 198, 198, 198, 198,
- 198, 198, 198, 198, 198, 203, 204, 198, 198, 198,
- 205, 206, 198, 207, 208, 198, 198, 198, 209, 210,
- 198, 211, 198, 212, 213, 198, 214, 198, 215, 216,
- 198, 217, 218, 198, 198, 198, 198, 198, 219, 220,
- 220, 220, 221, 221, 222, 222, 223, 223, 224, 224,
- 225, 225, 225, 225, 225, 225, 225, 225, 226, 225,
- 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, 277, 278,
- 279, 279, 280, 280, 281, 281, 282, 282, 283, 283,
- 284, 284, 285, 285, 285, 285, 286, 286, 287, 287,
- 287, 287, 287, 287, 287, 287, 287, 287, 287, 287,
- 287, 287, 287, 288, 288, 288, 288, 288, 289, 289,
- 290, 291, 290, 292, 292, 293, 294, 295, 296, 296,
- 297, 297, 298, 298, 299, 299, 300, 300, 301, 302,
- 302, 303, 304, 303, 305, 305, 306, 306, 307, 307,
- 308, 308, 308, 308, 309, 309, 309, 310, 310, 310,
- 310, 311, 311, 311, 312, 312, 313, 313, 314, 314,
- 315, 315, 316, 316, 317, 318, 318, 318, 319, 319,
- 319, 320, 321, 321, 322
+ 157, 157, 157, 157, 159, 159, 159, 159, 160, 160,
+ 160, 160, 160, 160, 160, 160, 161, 161, 161, 162,
+ 162, 162, 162, 162, 162, 163, 165, 164, 166, 167,
+ 167, 168, 168, 170, 169, 171, 171, 171, 171, 171,
+ 171, 171, 171, 171, 171, 171, 172, 172, 173, 173,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 175, 175, 176, 176, 177, 177, 178, 178, 178, 178,
+ 178, 178, 178, 178, 179, 179, 179, 179, 179, 179,
+ 179, 179, 179, 180, 180, 181, 181, 181, 182, 182,
+ 182, 182, 182, 183, 183, 184, 185, 184, 186, 186,
+ 186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
+ 186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
+ 186, 186, 186, 186, 186, 186, 186, 186, 187, 187,
+ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
+ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
+ 187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
+ 187, 187, 187, 187, 187, 187, 187, 187, 188, 188,
+ 188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
+ 188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
+ 188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
+ 188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
+ 188, 188, 188, 188, 188, 189, 189, 189, 189, 190,
+ 190, 191, 191, 192, 192, 193, 193, 193, 193, 193,
+ 194, 194, 194, 194, 194, 196, 195, 197, 198, 198,
+ 199, 199, 200, 200, 200, 200, 201, 201, 201, 202,
+ 202, 202, 202, 202, 202, 202, 202, 202, 203, 202,
+ 204, 205, 202, 206, 202, 202, 202, 202, 202, 202,
+ 202, 202, 202, 202, 202, 202, 202, 207, 208, 202,
+ 202, 202, 209, 210, 202, 211, 212, 202, 202, 202,
+ 213, 214, 202, 215, 202, 216, 217, 202, 218, 202,
+ 202, 202, 202, 202, 202, 202, 219, 220, 220, 220,
+ 221, 221, 222, 222, 223, 223, 224, 224, 225, 225,
+ 225, 225, 225, 225, 225, 225, 226, 225, 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, 279, 280,
+ 280, 281, 281, 282, 282, 283, 283, 284, 284, 285,
+ 285, 286, 286, 286, 286, 287, 287, 288, 288, 288,
+ 288, 288, 288, 288, 288, 288, 288, 288, 288, 288,
+ 288, 288, 289, 289, 289, 289, 289, 290, 290, 291,
+ 292, 291, 293, 293, 294, 295, 296, 297, 297, 298,
+ 298, 299, 299, 300, 300, 301, 301, 302, 303, 303,
+ 304, 305, 304, 306, 306, 307, 307, 308, 308, 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, 320,
+ 321, 322, 322, 323
};
/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
@@ -4908,63 +5014,64 @@ static const yytype_int8 yyr2[] =
0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
0, 5, 4, 2, 1, 1, 3, 2, 0, 4,
2, 3, 3, 3, 3, 3, 4, 1, 3, 3,
- 3, 3, 1, 3, 3, 6, 5, 5, 5, 5,
- 3, 1, 3, 1, 1, 3, 3, 3, 2, 1,
- 1, 1, 1, 1, 4, 0, 5, 2, 3, 4,
- 5, 4, 5, 2, 2, 2, 2, 2, 1, 3,
- 1, 3, 1, 2, 3, 5, 2, 4, 2, 4,
- 1, 3, 1, 3, 2, 3, 1, 2, 1, 4,
- 3, 3, 3, 3, 2, 1, 1, 4, 3, 3,
- 3, 3, 2, 1, 1, 1, 1, 2, 1, 3,
- 1, 1, 1, 1, 1, 1, 1, 1, 0, 4,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 3, 3, 1, 1, 3, 3, 3, 3, 3, 3,
+ 6, 5, 5, 5, 5, 3, 1, 3, 1, 1,
+ 3, 3, 3, 2, 1, 2, 0, 5, 1, 1,
+ 1, 1, 4, 0, 5, 2, 3, 4, 5, 4,
+ 5, 2, 2, 2, 2, 2, 1, 3, 1, 3,
+ 1, 2, 3, 5, 2, 4, 2, 4, 1, 3,
+ 1, 3, 2, 3, 1, 2, 1, 4, 3, 3,
+ 3, 3, 2, 1, 1, 4, 3, 3, 3, 3,
+ 2, 1, 1, 1, 1, 2, 1, 3, 1, 1,
+ 1, 1, 1, 1, 1, 1, 0, 4, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 3, 3, 6, 5, 5, 5, 5, 4, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 4, 4, 2,
- 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 2, 2, 3, 3, 3, 3,
- 6, 6, 1, 1, 2, 4, 2, 1, 3, 3,
- 3, 1, 1, 1, 2, 2, 4, 2, 1, 2,
- 2, 4, 1, 0, 2, 2, 2, 1, 1, 3,
- 1, 2, 3, 4, 3, 4, 2, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 0, 4, 0, 0,
- 5, 0, 3, 3, 3, 2, 3, 3, 1, 2,
- 4, 3, 2, 1, 2, 0, 0, 5, 6, 6,
- 0, 0, 7, 0, 0, 7, 5, 4, 0, 0,
- 9, 0, 6, 0, 0, 8, 0, 5, 0, 0,
- 7, 0, 0, 9, 1, 1, 1, 1, 1, 1,
- 1, 2, 1, 1, 1, 5, 1, 2, 1, 1,
- 1, 4, 6, 3, 5, 2, 4, 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, 1, 0, 0, 4, 3, 3, 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, 2,
- 1, 1, 0, 4, 1, 2, 1, 3, 1, 2,
- 3, 3, 3, 2, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
+ 6, 5, 5, 5, 5, 4, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 4, 4, 2, 2, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 2, 2, 3, 3, 3, 3, 6, 6,
+ 4, 6, 4, 6, 1, 1, 2, 4, 2, 1,
+ 3, 3, 3, 1, 1, 1, 2, 2, 4, 2,
+ 1, 2, 2, 4, 1, 0, 2, 2, 2, 1,
+ 1, 3, 1, 2, 3, 4, 3, 4, 2, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0, 4,
+ 0, 0, 5, 0, 3, 3, 3, 2, 3, 3,
+ 1, 2, 4, 3, 2, 1, 2, 0, 0, 5,
+ 6, 6, 0, 0, 7, 0, 0, 7, 5, 4,
+ 0, 0, 9, 0, 6, 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, 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, 1, 0, 1, 2, 0, 1, 1, 1, 1,
- 1, 1, 1, 2, 0
+ 1, 0, 0, 4, 3, 3, 1, 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, 2, 1,
+ 1, 0, 4, 1, 2, 1, 3, 1, 2, 3,
+ 3, 3, 2, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 0, 1, 2, 0, 1, 1, 1, 1, 1,
+ 1, 1, 2, 0
};
@@ -5666,86 +5773,86 @@ yyreduce:
switch (yyn)
{
case 2:
-#line 1508 "mrbgems/mruby-compiler/core/parse.y"
+#line 1534 "mrbgems/mruby-compiler/core/parse.y"
{
p->lstate = EXPR_BEG;
if (!p->locals) p->locals = cons(0,0);
}
-#line 5675 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5782 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 3:
-#line 1513 "mrbgems/mruby-compiler/core/parse.y"
+#line 1539 "mrbgems/mruby-compiler/core/parse.y"
{
p->tree = new_scope(p, (yyvsp[0].nd));
NODE_LINENO(p->tree, (yyvsp[0].nd));
}
-#line 5684 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5791 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 4:
-#line 1520 "mrbgems/mruby-compiler/core/parse.y"
+#line 1546 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 5692 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5799 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 5:
-#line 1526 "mrbgems/mruby-compiler/core/parse.y"
+#line 1552 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_begin(p, 0);
}
-#line 5700 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5807 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 6:
-#line 1530 "mrbgems/mruby-compiler/core/parse.y"
+#line 1556 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_begin(p, (yyvsp[0].nd));
NODE_LINENO((yyval.nd), (yyvsp[0].nd));
}
-#line 5709 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5816 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 7:
-#line 1535 "mrbgems/mruby-compiler/core/parse.y"
+#line 1561 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd)));
}
-#line 5717 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5824 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 8:
-#line 1539 "mrbgems/mruby-compiler/core/parse.y"
+#line 1565 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_begin(p, 0);
}
-#line 5725 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5832 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 10:
-#line 1546 "mrbgems/mruby-compiler/core/parse.y"
+#line 1572 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = local_switch(p);
nvars_block(p);
}
-#line 5734 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5841 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 11:
-#line 1551 "mrbgems/mruby-compiler/core/parse.y"
+#line 1577 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "BEGIN not supported");
local_resume(p, (yyvsp[-3].nd));
nvars_unnest(p);
(yyval.nd) = 0;
}
-#line 5745 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5852 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 12:
-#line 1563 "mrbgems/mruby-compiler/core/parse.y"
+#line 1589 "mrbgems/mruby-compiler/core/parse.y"
{
if ((yyvsp[-2].nd)) {
(yyval.nd) = new_rescue(p, (yyvsp[-3].nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
@@ -5767,1344 +5874,1462 @@ yyreduce:
}
}
}
-#line 5771 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5878 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 13:
-#line 1587 "mrbgems/mruby-compiler/core/parse.y"
+#line 1613 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 5779 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5886 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 14:
-#line 1593 "mrbgems/mruby-compiler/core/parse.y"
+#line 1619 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_begin(p, 0);
}
-#line 5787 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5894 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 15:
-#line 1597 "mrbgems/mruby-compiler/core/parse.y"
+#line 1623 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_begin(p, (yyvsp[0].nd));
NODE_LINENO((yyval.nd), (yyvsp[0].nd));
}
-#line 5796 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5903 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 16:
-#line 1602 "mrbgems/mruby-compiler/core/parse.y"
+#line 1628 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd)));
}
-#line 5804 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5911 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 17:
-#line 1606 "mrbgems/mruby-compiler/core/parse.y"
+#line 1632 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_begin(p, (yyvsp[0].nd));
}
-#line 5812 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5919 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 18:
-#line 1611 "mrbgems/mruby-compiler/core/parse.y"
+#line 1637 "mrbgems/mruby-compiler/core/parse.y"
{p->lstate = EXPR_FNAME;}
-#line 5818 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5925 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 19:
-#line 1612 "mrbgems/mruby-compiler/core/parse.y"
+#line 1638 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_alias(p, (yyvsp[-2].id), (yyvsp[0].id));
}
-#line 5826 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5933 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 20:
-#line 1616 "mrbgems/mruby-compiler/core/parse.y"
+#line 1642 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 5834 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5941 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 21:
-#line 1620 "mrbgems/mruby-compiler/core/parse.y"
+#line 1646 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_if(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0);
}
-#line 5842 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5949 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 22:
-#line 1624 "mrbgems/mruby-compiler/core/parse.y"
+#line 1650 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_unless(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0);
}
-#line 5850 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5957 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 23:
-#line 1628 "mrbgems/mruby-compiler/core/parse.y"
+#line 1654 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_while(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
}
-#line 5858 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5965 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 24:
-#line 1632 "mrbgems/mruby-compiler/core/parse.y"
+#line 1658 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_until(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
}
-#line 5866 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5973 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 25:
-#line 1636 "mrbgems/mruby-compiler/core/parse.y"
+#line 1662 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 5874 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5981 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 26:
-#line 1640 "mrbgems/mruby-compiler/core/parse.y"
+#line 1666 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "END not supported");
(yyval.nd) = new_postexe(p, (yyvsp[-1].nd));
}
-#line 5883 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5990 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 28:
-#line 1646 "mrbgems/mruby-compiler/core/parse.y"
+#line 1672 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 5891 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5998 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 29:
-#line 1650 "mrbgems/mruby-compiler/core/parse.y"
+#line 1676 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_asgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
}
-#line 5899 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6006 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 30:
-#line 1654 "mrbgems/mruby-compiler/core/parse.y"
+#line 1680 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 5907 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6014 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 31:
-#line 1658 "mrbgems/mruby-compiler/core/parse.y"
+#line 1684 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_masgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
}
-#line 5915 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6022 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 34:
+#line 1692 "mrbgems/mruby-compiler/core/parse.y"
+ {
+ void_expr_error(p, (yyvsp[-2].nd));
+ (yyval.nd) = new_asgn(p, (yyvsp[0].nd), (yyvsp[-2].nd));
+ }
+#line 6031 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 35:
+#line 1697 "mrbgems/mruby-compiler/core/parse.y"
+ {
+ void_expr_error(p, (yyvsp[-2].nd));
+ (yyval.nd) = new_masgn(p, (yyvsp[0].nd), (yyvsp[-2].nd));
+ }
+#line 6040 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 36:
+#line 1702 "mrbgems/mruby-compiler/core/parse.y"
+ {
+ (yyval.nd) = new_asgn(p, (yyvsp[0].nd), (yyvsp[-2].nd));
+ }
+#line 6048 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 37:
+#line 1706 "mrbgems/mruby-compiler/core/parse.y"
+ {
+ (yyval.nd) = new_masgn(p, (yyvsp[0].nd), (yyvsp[-2].nd));
+ }
+#line 6056 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 33:
-#line 1665 "mrbgems/mruby-compiler/core/parse.y"
+ case 38:
+#line 1712 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 5923 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6064 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 34:
-#line 1669 "mrbgems/mruby-compiler/core/parse.y"
+ case 39:
+#line 1716 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
}
-#line 5931 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6072 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 35:
-#line 1673 "mrbgems/mruby-compiler/core/parse.y"
+ case 40:
+#line 1720 "mrbgems/mruby-compiler/core/parse.y"
{
- (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_lit("[]"), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
+ (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), MRB_QSYM(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
}
-#line 5939 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6080 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 36:
-#line 1677 "mrbgems/mruby-compiler/core/parse.y"
+ case 41:
+#line 1724 "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 5947 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6088 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 37:
-#line 1681 "mrbgems/mruby-compiler/core/parse.y"
+ case 42:
+#line 1728 "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 5955 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6096 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 38:
-#line 1685 "mrbgems/mruby-compiler/core/parse.y"
+ case 43:
+#line 1732 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "constant re-assignment");
(yyval.nd) = 0;
}
-#line 5964 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6105 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 39:
-#line 1690 "mrbgems/mruby-compiler/core/parse.y"
+ case 44:
+#line 1737 "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 5972 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6113 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 40:
-#line 1694 "mrbgems/mruby-compiler/core/parse.y"
+ case 45:
+#line 1741 "mrbgems/mruby-compiler/core/parse.y"
{
backref_error(p, (yyvsp[-2].nd));
(yyval.nd) = new_begin(p, 0);
}
-#line 5981 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6122 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 42:
-#line 1702 "mrbgems/mruby-compiler/core/parse.y"
+ case 47:
+#line 1749 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 5989 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6130 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 45:
-#line 1711 "mrbgems/mruby-compiler/core/parse.y"
+ case 50:
+#line 1758 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 5997 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6138 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 46:
-#line 1715 "mrbgems/mruby-compiler/core/parse.y"
+ case 51:
+#line 1762 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 6005 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6146 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 47:
-#line 1719 "mrbgems/mruby-compiler/core/parse.y"
+ case 52:
+#line 1766 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
}
-#line 6013 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6154 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 48:
-#line 1723 "mrbgems/mruby-compiler/core/parse.y"
+ case 53:
+#line 1770 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
}
-#line 6021 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6162 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 50:
-#line 1730 "mrbgems/mruby-compiler/core/parse.y"
+ case 55:
+#line 1778 "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 6173 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 56:
+#line 1787 "mrbgems/mruby-compiler/core/parse.y"
+ {
+ p->lstate = EXPR_FNAME;
+ }
+#line 6181 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 57:
+#line 1791 "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;
+ p->in_def++;
+ p->in_single++;
+ nvars_block(p);
+ p->lstate = EXPR_ENDFN; /* force for args */
+ }
+#line 6194 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 58:
+#line 1802 "mrbgems/mruby-compiler/core/parse.y"
{
if (!(yyvsp[0].nd)) (yyval.nd) = new_nil(p);
else {
(yyval.nd) = (yyvsp[0].nd);
}
}
-#line 6032 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6205 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 54:
-#line 1744 "mrbgems/mruby-compiler/core/parse.y"
+ case 62:
+#line 1816 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
}
-#line 6040 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6213 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 55:
-#line 1750 "mrbgems/mruby-compiler/core/parse.y"
+ case 63:
+#line 1822 "mrbgems/mruby-compiler/core/parse.y"
{
local_nest(p);
nvars_nest(p);
}
-#line 6049 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6222 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 56:
-#line 1757 "mrbgems/mruby-compiler/core/parse.y"
+ case 64:
+#line 1829 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_block(p, (yyvsp[-2].nd), (yyvsp[-1].nd));
local_unnest(p);
nvars_unnest(p);
}
-#line 6059 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6232 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 57:
-#line 1765 "mrbgems/mruby-compiler/core/parse.y"
+ case 65:
+#line 1837 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
}
-#line 6067 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6240 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 58:
-#line 1769 "mrbgems/mruby-compiler/core/parse.y"
+ case 66:
+#line 1841 "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 6076 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6249 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 59:
-#line 1774 "mrbgems/mruby-compiler/core/parse.y"
+ case 67:
+#line 1846 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
}
-#line 6084 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6257 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 60:
-#line 1778 "mrbgems/mruby-compiler/core/parse.y"
+ case 68:
+#line 1850 "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 6093 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6266 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 61:
-#line 1783 "mrbgems/mruby-compiler/core/parse.y"
+ case 69:
+#line 1855 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
}
-#line 6101 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6274 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 62:
-#line 1787 "mrbgems/mruby-compiler/core/parse.y"
+ case 70:
+#line 1859 "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 6110 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6283 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 63:
-#line 1792 "mrbgems/mruby-compiler/core/parse.y"
+ case 71:
+#line 1864 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_super(p, (yyvsp[0].nd));
}
-#line 6118 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6291 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 64:
-#line 1796 "mrbgems/mruby-compiler/core/parse.y"
+ case 72:
+#line 1868 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_yield(p, (yyvsp[0].nd));
}
-#line 6126 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6299 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 65:
-#line 1800 "mrbgems/mruby-compiler/core/parse.y"
+ case 73:
+#line 1872 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_return(p, ret_args(p, (yyvsp[0].nd)));
}
-#line 6134 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6307 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 66:
-#line 1804 "mrbgems/mruby-compiler/core/parse.y"
+ case 74:
+#line 1876 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_break(p, ret_args(p, (yyvsp[0].nd)));
}
-#line 6142 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6315 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 67:
-#line 1808 "mrbgems/mruby-compiler/core/parse.y"
+ case 75:
+#line 1880 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_next(p, ret_args(p, (yyvsp[0].nd)));
}
-#line 6150 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6323 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 68:
-#line 1814 "mrbgems/mruby-compiler/core/parse.y"
+ case 76:
+#line 1886 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 6158 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6331 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 69:
-#line 1818 "mrbgems/mruby-compiler/core/parse.y"
+ case 77:
+#line 1890 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 6166 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6339 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 71:
-#line 1825 "mrbgems/mruby-compiler/core/parse.y"
+ case 79:
+#line 1897 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 6174 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6347 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 72:
-#line 1831 "mrbgems/mruby-compiler/core/parse.y"
+ case 80:
+#line 1903 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
}
-#line 6182 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6355 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 73:
-#line 1835 "mrbgems/mruby-compiler/core/parse.y"
+ case 81:
+#line 1907 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1(push((yyvsp[-1].nd),(yyvsp[0].nd)));
}
-#line 6190 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6363 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 74:
-#line 1839 "mrbgems/mruby-compiler/core/parse.y"
+ case 82:
+#line 1911 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list2((yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 6198 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6371 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 75:
-#line 1843 "mrbgems/mruby-compiler/core/parse.y"
+ case 83:
+#line 1915 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3((yyvsp[-4].nd), (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 6206 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6379 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 76:
-#line 1847 "mrbgems/mruby-compiler/core/parse.y"
+ case 84:
+#line 1919 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list2((yyvsp[-1].nd), new_nil(p));
}
-#line 6214 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6387 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 77:
-#line 1851 "mrbgems/mruby-compiler/core/parse.y"
+ case 85:
+#line 1923 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3((yyvsp[-3].nd), new_nil(p), (yyvsp[0].nd));
}
-#line 6222 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6395 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 78:
-#line 1855 "mrbgems/mruby-compiler/core/parse.y"
+ case 86:
+#line 1927 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list2(0, (yyvsp[0].nd));
}
-#line 6230 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6403 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 79:
-#line 1859 "mrbgems/mruby-compiler/core/parse.y"
+ case 87:
+#line 1931 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3(0, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 6238 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6411 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 80:
-#line 1863 "mrbgems/mruby-compiler/core/parse.y"
+ case 88:
+#line 1935 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list2(0, new_nil(p));
}
-#line 6246 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6419 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 81:
-#line 1867 "mrbgems/mruby-compiler/core/parse.y"
+ case 89:
+#line 1939 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3(0, new_nil(p), (yyvsp[0].nd));
}
-#line 6254 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6427 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 83:
-#line 1874 "mrbgems/mruby-compiler/core/parse.y"
+ case 91:
+#line 1946 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_masgn(p, (yyvsp[-1].nd), NULL);
}
-#line 6262 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6435 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 84:
-#line 1880 "mrbgems/mruby-compiler/core/parse.y"
+ case 92:
+#line 1952 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[-1].nd));
}
-#line 6270 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6443 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 85:
-#line 1884 "mrbgems/mruby-compiler/core/parse.y"
+ case 93:
+#line 1956 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[-1].nd));
}
-#line 6278 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6451 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 86:
-#line 1890 "mrbgems/mruby-compiler/core/parse.y"
+ case 94:
+#line 1962 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
}
-#line 6286 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6459 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 87:
-#line 1894 "mrbgems/mruby-compiler/core/parse.y"
+ case 95:
+#line 1966 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-1].nd), (yyvsp[0].nd));
}
-#line 6294 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6467 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 88:
-#line 1900 "mrbgems/mruby-compiler/core/parse.y"
+ case 96:
+#line 1972 "mrbgems/mruby-compiler/core/parse.y"
{
assignable(p, (yyvsp[0].nd));
}
-#line 6302 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6475 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 89:
-#line 1904 "mrbgems/mruby-compiler/core/parse.y"
+ case 97:
+#line 1976 "mrbgems/mruby-compiler/core/parse.y"
{
- (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_lit("[]"), (yyvsp[-1].nd), '.');
+ (yyval.nd) = new_call(p, (yyvsp[-3].nd), MRB_QSYM(aref), (yyvsp[-1].nd), '.');
}
-#line 6310 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6483 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 90:
-#line 1908 "mrbgems/mruby-compiler/core/parse.y"
+ case 98:
+#line 1980 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
}
-#line 6318 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6491 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 91:
-#line 1912 "mrbgems/mruby-compiler/core/parse.y"
+ case 99:
+#line 1984 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
}
-#line 6326 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6499 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 92:
-#line 1916 "mrbgems/mruby-compiler/core/parse.y"
+ case 100:
+#line 1988 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
}
-#line 6334 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6507 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 93:
-#line 1920 "mrbgems/mruby-compiler/core/parse.y"
+ case 101:
+#line 1992 "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 6344 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6517 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 94:
-#line 1926 "mrbgems/mruby-compiler/core/parse.y"
+ case 102:
+#line 1998 "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 6354 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6527 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 95:
-#line 1932 "mrbgems/mruby-compiler/core/parse.y"
+ case 103:
+#line 2004 "mrbgems/mruby-compiler/core/parse.y"
{
backref_error(p, (yyvsp[0].nd));
(yyval.nd) = 0;
}
-#line 6363 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6536 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 96:
-#line 1939 "mrbgems/mruby-compiler/core/parse.y"
+ case 104:
+#line 2011 "mrbgems/mruby-compiler/core/parse.y"
{
assignable(p, (yyvsp[0].nd));
}
-#line 6371 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6544 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 97:
-#line 1943 "mrbgems/mruby-compiler/core/parse.y"
+ case 105:
+#line 2015 "mrbgems/mruby-compiler/core/parse.y"
{
- (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_lit("[]"), (yyvsp[-1].nd), '.');
+ (yyval.nd) = new_call(p, (yyvsp[-3].nd), MRB_QSYM(aref), (yyvsp[-1].nd), '.');
}
-#line 6379 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6552 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 98:
-#line 1947 "mrbgems/mruby-compiler/core/parse.y"
+ case 106:
+#line 2019 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
}
-#line 6387 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6560 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 99:
-#line 1951 "mrbgems/mruby-compiler/core/parse.y"
+ case 107:
+#line 2023 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
}
-#line 6395 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6568 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 100:
-#line 1955 "mrbgems/mruby-compiler/core/parse.y"
+ case 108:
+#line 2027 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
}
-#line 6403 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6576 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 101:
-#line 1959 "mrbgems/mruby-compiler/core/parse.y"
+ case 109:
+#line 2031 "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 6413 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6586 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 102:
-#line 1965 "mrbgems/mruby-compiler/core/parse.y"
+ case 110:
+#line 2037 "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 6423 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6596 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 103:
-#line 1971 "mrbgems/mruby-compiler/core/parse.y"
+ case 111:
+#line 2043 "mrbgems/mruby-compiler/core/parse.y"
{
backref_error(p, (yyvsp[0].nd));
(yyval.nd) = 0;
}
-#line 6432 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6605 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 104:
-#line 1976 "mrbgems/mruby-compiler/core/parse.y"
+ case 112:
+#line 2048 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "can't assign to numbered parameter");
}
-#line 6440 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6613 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 105:
-#line 1982 "mrbgems/mruby-compiler/core/parse.y"
+ case 113:
+#line 2054 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "class/module name must be CONSTANT");
}
-#line 6448 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6621 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 107:
-#line 1989 "mrbgems/mruby-compiler/core/parse.y"
+ case 115:
+#line 2061 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons((node*)1, nsym((yyvsp[0].id)));
}
-#line 6456 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6629 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 108:
-#line 1993 "mrbgems/mruby-compiler/core/parse.y"
+ case 116:
+#line 2065 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons((node*)0, nsym((yyvsp[0].id)));
}
-#line 6464 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6637 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 109:
-#line 1997 "mrbgems/mruby-compiler/core/parse.y"
+ case 117:
+#line 2069 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[-2].nd));
(yyval.nd) = cons((yyvsp[-2].nd), nsym((yyvsp[0].id)));
}
-#line 6473 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6646 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 113:
-#line 2007 "mrbgems/mruby-compiler/core/parse.y"
+ case 121:
+#line 2079 "mrbgems/mruby-compiler/core/parse.y"
{
p->lstate = EXPR_ENDFN;
(yyval.id) = (yyvsp[0].id);
}
-#line 6482 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6655 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 114:
-#line 2012 "mrbgems/mruby-compiler/core/parse.y"
+ case 122:
+#line 2084 "mrbgems/mruby-compiler/core/parse.y"
{
p->lstate = EXPR_ENDFN;
(yyval.id) = (yyvsp[0].id);
}
-#line 6491 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6664 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 117:
-#line 2023 "mrbgems/mruby-compiler/core/parse.y"
+ case 125:
+#line 2095 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_undef(p, (yyvsp[0].id));
}
-#line 6499 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6672 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 118:
-#line 2026 "mrbgems/mruby-compiler/core/parse.y"
+ case 126:
+#line 2098 "mrbgems/mruby-compiler/core/parse.y"
{p->lstate = EXPR_FNAME;}
-#line 6505 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6678 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 119:
-#line 2027 "mrbgems/mruby-compiler/core/parse.y"
+ case 127:
+#line 2099 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-3].nd), nsym((yyvsp[0].id)));
}
-#line 6513 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 120:
-#line 2032 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("|"); }
-#line 6519 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 121:
-#line 2033 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("^"); }
-#line 6525 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 122:
-#line 2034 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("&"); }
-#line 6531 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 123:
-#line 2035 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("<=>"); }
-#line 6537 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 124:
-#line 2036 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("=="); }
-#line 6543 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 125:
-#line 2037 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("==="); }
-#line 6549 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 126:
-#line 2038 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("=~"); }
-#line 6555 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 127:
-#line 2039 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("!~"); }
-#line 6561 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6686 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 128:
-#line 2040 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit(">"); }
-#line 6567 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2104 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(or); }
+#line 6692 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 129:
-#line 2041 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit(">="); }
-#line 6573 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2105 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(xor); }
+#line 6698 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 130:
-#line 2042 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("<"); }
-#line 6579 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2106 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(and); }
+#line 6704 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 131:
-#line 2043 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("<="); }
-#line 6585 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2107 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(cmp); }
+#line 6710 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 132:
-#line 2044 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("!="); }
-#line 6591 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2108 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(eq); }
+#line 6716 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 133:
-#line 2045 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("<<"); }
-#line 6597 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2109 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(eqq); }
+#line 6722 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 134:
-#line 2046 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit(">>"); }
-#line 6603 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2110 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(match); }
+#line 6728 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 135:
-#line 2047 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("+"); }
-#line 6609 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2111 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(nmatch); }
+#line 6734 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 136:
-#line 2048 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("-"); }
-#line 6615 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2112 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(gt); }
+#line 6740 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 137:
-#line 2049 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("*"); }
-#line 6621 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2113 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(ge); }
+#line 6746 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 138:
-#line 2050 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("*"); }
-#line 6627 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2114 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(lt); }
+#line 6752 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 139:
-#line 2051 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("/"); }
-#line 6633 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2115 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(le); }
+#line 6758 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 140:
-#line 2052 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("%"); }
-#line 6639 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2116 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(neq); }
+#line 6764 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 141:
-#line 2053 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("**"); }
-#line 6645 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2117 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(lshift); }
+#line 6770 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 142:
-#line 2054 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("**"); }
-#line 6651 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2118 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(rshift); }
+#line 6776 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 143:
-#line 2055 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("!"); }
-#line 6657 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2119 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(add); }
+#line 6782 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 144:
-#line 2056 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("~"); }
-#line 6663 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2120 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(sub); }
+#line 6788 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 145:
-#line 2057 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("+@"); }
-#line 6669 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2121 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(mul); }
+#line 6794 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 146:
-#line 2058 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("-@"); }
-#line 6675 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2122 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(mul); }
+#line 6800 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 147:
-#line 2059 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("[]"); }
-#line 6681 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2123 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(div); }
+#line 6806 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 148:
-#line 2060 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("[]="); }
-#line 6687 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2124 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(mod); }
+#line 6812 "mrbgems/mruby-compiler/core/y.tab.c"
break;
case 149:
-#line 2061 "mrbgems/mruby-compiler/core/parse.y"
- { (yyval.id) = intern_lit("`"); }
-#line 6693 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2125 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(pow); }
+#line 6818 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 190:
-#line 2079 "mrbgems/mruby-compiler/core/parse.y"
+ case 150:
+#line 2126 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(pow); }
+#line 6824 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 151:
+#line 2127 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(not); }
+#line 6830 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 152:
+#line 2128 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(neg); }
+#line 6836 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 153:
+#line 2129 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(plus); }
+#line 6842 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 154:
+#line 2130 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(minus); }
+#line 6848 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 155:
+#line 2131 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(aref); }
+#line 6854 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 156:
+#line 2132 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(aset); }
+#line 6860 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 157:
+#line 2133 "mrbgems/mruby-compiler/core/parse.y"
+ { (yyval.id) = MRB_QSYM(tick); }
+#line 6866 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 198:
+#line 2151 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 6701 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6874 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 191:
-#line 2083 "mrbgems/mruby-compiler/core/parse.y"
+ case 199:
+#line 2155 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
}
-#line 6709 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6882 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 192:
-#line 2087 "mrbgems/mruby-compiler/core/parse.y"
+ case 200:
+#line 2159 "mrbgems/mruby-compiler/core/parse.y"
{
- (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_lit("[]"), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
+ (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), MRB_QSYM(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
}
-#line 6717 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6890 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 193:
-#line 2091 "mrbgems/mruby-compiler/core/parse.y"
+ case 201:
+#line 2163 "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 6725 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6898 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 194:
-#line 2095 "mrbgems/mruby-compiler/core/parse.y"
+ case 202:
+#line 2167 "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 6733 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6906 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 195:
-#line 2099 "mrbgems/mruby-compiler/core/parse.y"
+ case 203:
+#line 2171 "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 6741 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6914 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 196:
-#line 2103 "mrbgems/mruby-compiler/core/parse.y"
+ case 204:
+#line 2175 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "constant re-assignment");
(yyval.nd) = new_begin(p, 0);
}
-#line 6750 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6923 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 197:
-#line 2108 "mrbgems/mruby-compiler/core/parse.y"
+ case 205:
+#line 2180 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "constant re-assignment");
(yyval.nd) = new_begin(p, 0);
}
-#line 6759 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6932 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 198:
-#line 2113 "mrbgems/mruby-compiler/core/parse.y"
+ case 206:
+#line 2185 "mrbgems/mruby-compiler/core/parse.y"
{
backref_error(p, (yyvsp[-2].nd));
(yyval.nd) = new_begin(p, 0);
}
-#line 6768 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6941 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 199:
-#line 2118 "mrbgems/mruby-compiler/core/parse.y"
+ case 207:
+#line 2190 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_dot2(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 6776 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6949 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 200:
-#line 2122 "mrbgems/mruby-compiler/core/parse.y"
+ case 208:
+#line 2194 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_dot3(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 6784 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6957 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 201:
-#line 2126 "mrbgems/mruby-compiler/core/parse.y"
+ case 209:
+#line 2198 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "+", (yyvsp[0].nd));
}
-#line 6792 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6965 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 202:
-#line 2130 "mrbgems/mruby-compiler/core/parse.y"
+ case 210:
+#line 2202 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "-", (yyvsp[0].nd));
}
-#line 6800 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6973 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 203:
-#line 2134 "mrbgems/mruby-compiler/core/parse.y"
+ case 211:
+#line 2206 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "*", (yyvsp[0].nd));
}
-#line 6808 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6981 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 204:
-#line 2138 "mrbgems/mruby-compiler/core/parse.y"
+ case 212:
+#line 2210 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "/", (yyvsp[0].nd));
}
-#line 6816 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6989 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 205:
-#line 2142 "mrbgems/mruby-compiler/core/parse.y"
+ case 213:
+#line 2214 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "%", (yyvsp[0].nd));
}
-#line 6824 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6997 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 206:
-#line 2146 "mrbgems/mruby-compiler/core/parse.y"
+ case 214:
+#line 2218 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd));
}
-#line 6832 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7005 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 207:
-#line 2150 "mrbgems/mruby-compiler/core/parse.y"
+ case 215:
+#line 2222 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)), "-@");
}
-#line 6840 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7013 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 208:
-#line 2154 "mrbgems/mruby-compiler/core/parse.y"
+ case 216:
+#line 2226 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)), "-@");
}
-#line 6848 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7021 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 209:
-#line 2158 "mrbgems/mruby-compiler/core/parse.y"
+ case 217:
+#line 2230 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "+@");
}
-#line 6856 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7029 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 210:
-#line 2162 "mrbgems/mruby-compiler/core/parse.y"
+ case 218:
+#line 2234 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "-@");
}
-#line 6864 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7037 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 211:
-#line 2166 "mrbgems/mruby-compiler/core/parse.y"
+ case 219:
+#line 2238 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "|", (yyvsp[0].nd));
}
-#line 6872 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7045 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 212:
-#line 2170 "mrbgems/mruby-compiler/core/parse.y"
+ case 220:
+#line 2242 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "^", (yyvsp[0].nd));
}
-#line 6880 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7053 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 213:
-#line 2174 "mrbgems/mruby-compiler/core/parse.y"
+ case 221:
+#line 2246 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "&", (yyvsp[0].nd));
}
-#line 6888 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7061 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 214:
-#line 2178 "mrbgems/mruby-compiler/core/parse.y"
+ case 222:
+#line 2250 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=>", (yyvsp[0].nd));
}
-#line 6896 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7069 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 215:
-#line 2182 "mrbgems/mruby-compiler/core/parse.y"
+ case 223:
+#line 2254 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">", (yyvsp[0].nd));
}
-#line 6904 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7077 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 216:
-#line 2186 "mrbgems/mruby-compiler/core/parse.y"
+ case 224:
+#line 2258 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">=", (yyvsp[0].nd));
}
-#line 6912 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7085 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 217:
-#line 2190 "mrbgems/mruby-compiler/core/parse.y"
+ case 225:
+#line 2262 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<", (yyvsp[0].nd));
}
-#line 6920 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7093 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 218:
-#line 2194 "mrbgems/mruby-compiler/core/parse.y"
+ case 226:
+#line 2266 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=", (yyvsp[0].nd));
}
-#line 6928 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7101 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 219:
-#line 2198 "mrbgems/mruby-compiler/core/parse.y"
+ case 227:
+#line 2270 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "==", (yyvsp[0].nd));
}
-#line 6936 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7109 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 220:
-#line 2202 "mrbgems/mruby-compiler/core/parse.y"
+ case 228:
+#line 2274 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "===", (yyvsp[0].nd));
}
-#line 6944 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7117 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 221:
-#line 2206 "mrbgems/mruby-compiler/core/parse.y"
+ case 229:
+#line 2278 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!=", (yyvsp[0].nd));
}
-#line 6952 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7125 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 222:
-#line 2210 "mrbgems/mruby-compiler/core/parse.y"
+ case 230:
+#line 2282 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "=~", (yyvsp[0].nd));
}
-#line 6960 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7133 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 223:
-#line 2214 "mrbgems/mruby-compiler/core/parse.y"
+ case 231:
+#line 2286 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!~", (yyvsp[0].nd));
}
-#line 6968 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7141 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 224:
-#line 2218 "mrbgems/mruby-compiler/core/parse.y"
+ case 232:
+#line 2290 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
}
-#line 6976 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7149 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 225:
-#line 2222 "mrbgems/mruby-compiler/core/parse.y"
+ case 233:
+#line 2294 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "~");
}
-#line 6984 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7157 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 226:
-#line 2226 "mrbgems/mruby-compiler/core/parse.y"
+ case 234:
+#line 2298 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<<", (yyvsp[0].nd));
}
-#line 6992 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7165 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 227:
-#line 2230 "mrbgems/mruby-compiler/core/parse.y"
+ case 235:
+#line 2302 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">>", (yyvsp[0].nd));
}
-#line 7000 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7173 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 228:
-#line 2234 "mrbgems/mruby-compiler/core/parse.y"
+ case 236:
+#line 2306 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 7008 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7181 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 229:
-#line 2238 "mrbgems/mruby-compiler/core/parse.y"
+ case 237:
+#line 2310 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 7016 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7189 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 230:
-#line 2242 "mrbgems/mruby-compiler/core/parse.y"
+ case 238:
+#line 2314 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
}
-#line 7024 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7197 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 231:
-#line 2246 "mrbgems/mruby-compiler/core/parse.y"
+ case 239:
+#line 2318 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
}
-#line 7032 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7205 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 232:
-#line 2250 "mrbgems/mruby-compiler/core/parse.y"
+ case 240:
+#line 2322 "mrbgems/mruby-compiler/core/parse.y"
+ {
+ (yyval.nd) = (yyvsp[-3].nd);
+ void_expr_error(p, (yyvsp[0].nd));
+ defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
+ nvars_unnest(p);
+ p->in_def--;
+ }
+#line 7217 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 241:
+#line 2330 "mrbgems/mruby-compiler/core/parse.y"
+ {
+ (yyval.nd) = (yyvsp[-5].nd);
+ void_expr_error(p, (yyvsp[-2].nd));
+ void_expr_error(p, (yyvsp[0].nd));
+ defn_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
+ nvars_unnest(p);
+ p->in_def--;
+ }
+#line 7230 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 242:
+#line 2339 "mrbgems/mruby-compiler/core/parse.y"
+ {
+ (yyval.nd) = (yyvsp[-3].nd);
+ void_expr_error(p, (yyvsp[0].nd));
+ defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
+ nvars_unnest(p);
+ p->in_def--;
+ p->in_single--;
+ }
+#line 7243 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 243:
+#line 2348 "mrbgems/mruby-compiler/core/parse.y"
+ {
+ (yyval.nd) = (yyvsp[-5].nd);
+ void_expr_error(p, (yyvsp[-2].nd));
+ void_expr_error(p, (yyvsp[0].nd));
+ defs_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
+ nvars_unnest(p);
+ p->in_def--;
+ p->in_single--;
+ }
+#line 7257 "mrbgems/mruby-compiler/core/y.tab.c"
+ break;
+
+ case 244:
+#line 2358 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 7040 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7265 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 234:
-#line 2257 "mrbgems/mruby-compiler/core/parse.y"
+ case 246:
+#line 2365 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
}
-#line 7049 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7274 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 235:
-#line 2262 "mrbgems/mruby-compiler/core/parse.y"
+ case 247:
+#line 2370 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd)));
}
-#line 7057 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7282 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 236:
-#line 2266 "mrbgems/mruby-compiler/core/parse.y"
+ case 248:
+#line 2374 "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 7066 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7291 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 237:
-#line 2273 "mrbgems/mruby-compiler/core/parse.y"
+ case 249:
+#line 2381 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 7074 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7299 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 238:
-#line 2277 "mrbgems/mruby-compiler/core/parse.y"
+ case 250:
+#line 2385 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[-2].nd));
void_expr_error(p, (yyvsp[0].nd));
(yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 7084 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7309 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 239:
-#line 2285 "mrbgems/mruby-compiler/core/parse.y"
+ case 251:
+#line 2393 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 7092 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7317 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 240:
-#line 2289 "mrbgems/mruby-compiler/core/parse.y"
+ case 252:
+#line 2397 "mrbgems/mruby-compiler/core/parse.y"
{
#if 1
- mrb_sym r = mrb_intern_lit(p->mrb, "*");
- mrb_sym b = mrb_intern_lit(p->mrb, "&");
+ mrb_sym r = MRB_QSYM(mul);
+ mrb_sym b = MRB_QSYM(and);
if (local_var_p(p, r) && local_var_p(p, b)) {
(yyval.nd) = cons(list1(new_splat(p, new_lvar(p, r))),
new_block_arg(p, new_lvar(p, b)));
}
#else
- mrb_sym r = mrb_intern_lit(p->mrb, "*");
- mrb_sym k = mrb_intern_lit(p->mrb, "**");
- mrb_sym b = mrb_intern_lit(p->mrb, "&");
+ mrb_sym r = MRB_QSYM(mul);
+ mrb_sym k = MRB_QSYM(pow);
+ mrb_sym b = MRB_QSYM(and);
if (local_var_p(p, r) && local_var_p(p, k) && local_var_p(p, b)) {
(yyval.nd) = cons(list2(new_splat(p, new_lvar(p, r)),
new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_lvar(p, k))))),
@@ -7116,373 +7341,373 @@ yyreduce:
(yyval.nd) = 0;
}
}
-#line 7120 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7345 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 245:
-#line 2321 "mrbgems/mruby-compiler/core/parse.y"
+ case 257:
+#line 2429 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons((yyvsp[-1].nd),0);
NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
}
-#line 7129 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7354 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 246:
-#line 2326 "mrbgems/mruby-compiler/core/parse.y"
+ case 258:
+#line 2434 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons(push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd))), 0);
NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
}
-#line 7138 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7363 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 247:
-#line 2331 "mrbgems/mruby-compiler/core/parse.y"
+ case 259:
+#line 2439 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons(list1(new_kw_hash(p, (yyvsp[-1].nd))), 0);
NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
}
-#line 7147 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7372 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 248:
-#line 2338 "mrbgems/mruby-compiler/core/parse.y"
+ case 260:
+#line 2446 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[0].nd));
(yyval.nd) = cons(list1((yyvsp[0].nd)), 0);
NODE_LINENO((yyval.nd), (yyvsp[0].nd));
}
-#line 7157 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7382 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 249:
-#line 2344 "mrbgems/mruby-compiler/core/parse.y"
+ case 261:
+#line 2452 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons((yyvsp[-1].nd), (yyvsp[0].nd));
NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
}
-#line 7166 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7391 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 250:
-#line 2349 "mrbgems/mruby-compiler/core/parse.y"
+ case 262:
+#line 2457 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons(list1(new_kw_hash(p, (yyvsp[-1].nd))), (yyvsp[0].nd));
NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
}
-#line 7175 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7400 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 251:
-#line 2354 "mrbgems/mruby-compiler/core/parse.y"
+ case 263:
+#line 2462 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons(push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd))), (yyvsp[0].nd));
NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
}
-#line 7184 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7409 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 252:
-#line 2359 "mrbgems/mruby-compiler/core/parse.y"
+ case 264:
+#line 2467 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons(0, (yyvsp[0].nd));
NODE_LINENO((yyval.nd), (yyvsp[0].nd));
}
-#line 7193 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7418 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 253:
-#line 2365 "mrbgems/mruby-compiler/core/parse.y"
+ case 265:
+#line 2473 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.stack) = p->cmdarg_stack;
CMDARG_PUSH(1);
}
-#line 7202 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7427 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 254:
-#line 2370 "mrbgems/mruby-compiler/core/parse.y"
+ case 266:
+#line 2478 "mrbgems/mruby-compiler/core/parse.y"
{
p->cmdarg_stack = (yyvsp[-1].stack);
(yyval.nd) = (yyvsp[0].nd);
}
-#line 7211 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7436 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 255:
-#line 2377 "mrbgems/mruby-compiler/core/parse.y"
+ case 267:
+#line 2485 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_block_arg(p, (yyvsp[0].nd));
}
-#line 7219 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7444 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 256:
-#line 2383 "mrbgems/mruby-compiler/core/parse.y"
+ case 268:
+#line 2491 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 7227 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7452 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 257:
-#line 2387 "mrbgems/mruby-compiler/core/parse.y"
+ case 269:
+#line 2495 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = 0;
}
-#line 7235 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7460 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 260:
-#line 2397 "mrbgems/mruby-compiler/core/parse.y"
+ case 272:
+#line 2505 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[0].nd));
(yyval.nd) = cons((yyvsp[0].nd), 0);
NODE_LINENO((yyval.nd), (yyvsp[0].nd));
}
-#line 7245 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7470 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 261:
-#line 2403 "mrbgems/mruby-compiler/core/parse.y"
+ case 273:
+#line 2511 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[0].nd));
(yyval.nd) = cons(new_splat(p, (yyvsp[0].nd)), 0);
NODE_LINENO((yyval.nd), (yyvsp[0].nd));
}
-#line 7255 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7480 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 262:
-#line 2409 "mrbgems/mruby-compiler/core/parse.y"
+ case 274:
+#line 2517 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[0].nd));
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 7264 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7489 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 263:
-#line 2414 "mrbgems/mruby-compiler/core/parse.y"
+ case 275:
+#line 2522 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[0].nd));
(yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
}
-#line 7273 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7498 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 264:
-#line 2421 "mrbgems/mruby-compiler/core/parse.y"
+ case 276:
+#line 2529 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[0].nd));
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 7282 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7507 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 265:
-#line 2426 "mrbgems/mruby-compiler/core/parse.y"
+ case 277:
+#line 2534 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[0].nd));
(yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
}
-#line 7291 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7516 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 266:
-#line 2431 "mrbgems/mruby-compiler/core/parse.y"
+ case 278:
+#line 2539 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[0].nd));
(yyval.nd) = list1(new_splat(p, (yyvsp[0].nd)));
}
-#line 7300 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7525 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 274:
-#line 2445 "mrbgems/mruby-compiler/core/parse.y"
+ case 286:
+#line 2553 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_nvar(p, (yyvsp[0].num));
}
-#line 7308 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7533 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 275:
-#line 2449 "mrbgems/mruby-compiler/core/parse.y"
+ case 287:
+#line 2557 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_fcall(p, (yyvsp[0].id), 0);
}
-#line 7316 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7541 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 276:
-#line 2453 "mrbgems/mruby-compiler/core/parse.y"
+ case 288:
+#line 2561 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.stack) = p->cmdarg_stack;
p->cmdarg_stack = 0;
}
-#line 7325 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7550 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 277:
-#line 2459 "mrbgems/mruby-compiler/core/parse.y"
+ case 289:
+#line 2567 "mrbgems/mruby-compiler/core/parse.y"
{
p->cmdarg_stack = (yyvsp[-2].stack);
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 7334 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7559 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 278:
-#line 2464 "mrbgems/mruby-compiler/core/parse.y"
+ case 290:
+#line 2572 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.stack) = p->cmdarg_stack;
p->cmdarg_stack = 0;
}
-#line 7343 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7568 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 279:
-#line 2468 "mrbgems/mruby-compiler/core/parse.y"
+ case 291:
+#line 2576 "mrbgems/mruby-compiler/core/parse.y"
{p->lstate = EXPR_ENDARG;}
-#line 7349 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7574 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 280:
-#line 2469 "mrbgems/mruby-compiler/core/parse.y"
+ case 292:
+#line 2577 "mrbgems/mruby-compiler/core/parse.y"
{
p->cmdarg_stack = (yyvsp[-3].stack);
(yyval.nd) = (yyvsp[-2].nd);
}
-#line 7358 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7583 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 281:
-#line 2473 "mrbgems/mruby-compiler/core/parse.y"
+ case 293:
+#line 2581 "mrbgems/mruby-compiler/core/parse.y"
{p->lstate = EXPR_ENDARG;}
-#line 7364 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7589 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 282:
-#line 2474 "mrbgems/mruby-compiler/core/parse.y"
+ case 294:
+#line 2582 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_nil(p);
}
-#line 7372 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7597 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 283:
-#line 2478 "mrbgems/mruby-compiler/core/parse.y"
+ case 295:
+#line 2586 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 7380 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7605 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 284:
-#line 2482 "mrbgems/mruby-compiler/core/parse.y"
+ case 296:
+#line 2590 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
}
-#line 7388 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7613 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 285:
-#line 2486 "mrbgems/mruby-compiler/core/parse.y"
+ case 297:
+#line 2594 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_colon3(p, (yyvsp[0].id));
}
-#line 7396 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7621 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 286:
-#line 2490 "mrbgems/mruby-compiler/core/parse.y"
+ case 298:
+#line 2598 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_array(p, (yyvsp[-1].nd));
NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
}
-#line 7405 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7630 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 287:
-#line 2495 "mrbgems/mruby-compiler/core/parse.y"
+ case 299:
+#line 2603 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_hash(p, (yyvsp[-1].nd));
NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
}
-#line 7414 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7639 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 288:
-#line 2500 "mrbgems/mruby-compiler/core/parse.y"
+ case 300:
+#line 2608 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_return(p, 0);
}
-#line 7422 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7647 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 289:
-#line 2504 "mrbgems/mruby-compiler/core/parse.y"
+ case 301:
+#line 2612 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_yield(p, (yyvsp[0].nd));
}
-#line 7430 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7655 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 290:
-#line 2508 "mrbgems/mruby-compiler/core/parse.y"
+ case 302:
+#line 2616 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, cond((yyvsp[-1].nd)), "!");
}
-#line 7438 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7663 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 291:
-#line 2512 "mrbgems/mruby-compiler/core/parse.y"
+ case 303:
+#line 2620 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = call_uni_op(p, new_nil(p), "!");
}
-#line 7446 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7671 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 292:
-#line 2516 "mrbgems/mruby-compiler/core/parse.y"
+ case 304:
+#line 2624 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_fcall(p, (yyvsp[-1].id), cons(0, (yyvsp[0].nd)));
}
-#line 7454 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7679 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 294:
-#line 2521 "mrbgems/mruby-compiler/core/parse.y"
+ case 306:
+#line 2629 "mrbgems/mruby-compiler/core/parse.y"
{
call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 7463 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7688 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 295:
-#line 2526 "mrbgems/mruby-compiler/core/parse.y"
+ case 307:
+#line 2634 "mrbgems/mruby-compiler/core/parse.y"
{
local_nest(p);
(yyval.num) = p->lpar_beg;
p->lpar_beg = ++p->paren_nest;
}
-#line 7473 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7698 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 296:
-#line 2532 "mrbgems/mruby-compiler/core/parse.y"
+ case 308:
+#line 2640 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.stack) = p->cmdarg_stack;
p->cmdarg_stack = 0;
}
-#line 7482 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7707 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 297:
-#line 2537 "mrbgems/mruby-compiler/core/parse.y"
+ case 309:
+#line 2645 "mrbgems/mruby-compiler/core/parse.y"
{
p->lpar_beg = (yyvsp[-3].num);
(yyval.nd) = new_lambda(p, (yyvsp[-2].nd), (yyvsp[0].nd));
@@ -7490,149 +7715,149 @@ yyreduce:
p->cmdarg_stack = (yyvsp[-1].stack);
CMDARG_LEXPOP();
}
-#line 7494 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7719 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 298:
-#line 2548 "mrbgems/mruby-compiler/core/parse.y"
+ case 310:
+#line 2656 "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 7503 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7728 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 299:
-#line 2556 "mrbgems/mruby-compiler/core/parse.y"
+ case 311:
+#line 2664 "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 7512 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7737 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 300:
-#line 2560 "mrbgems/mruby-compiler/core/parse.y"
+ case 312:
+#line 2668 "mrbgems/mruby-compiler/core/parse.y"
{COND_PUSH(1);}
-#line 7518 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7743 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 301:
-#line 2560 "mrbgems/mruby-compiler/core/parse.y"
+ case 313:
+#line 2668 "mrbgems/mruby-compiler/core/parse.y"
{COND_POP();}
-#line 7524 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7749 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 302:
-#line 2563 "mrbgems/mruby-compiler/core/parse.y"
+ case 314:
+#line 2671 "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 7533 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7758 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 303:
-#line 2567 "mrbgems/mruby-compiler/core/parse.y"
+ case 315:
+#line 2675 "mrbgems/mruby-compiler/core/parse.y"
{COND_PUSH(1);}
-#line 7539 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7764 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 304:
-#line 2567 "mrbgems/mruby-compiler/core/parse.y"
+ case 316:
+#line 2675 "mrbgems/mruby-compiler/core/parse.y"
{COND_POP();}
-#line 7545 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7770 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 305:
-#line 2570 "mrbgems/mruby-compiler/core/parse.y"
+ case 317:
+#line 2678 "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 7554 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7779 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 306:
-#line 2577 "mrbgems/mruby-compiler/core/parse.y"
+ case 318:
+#line 2685 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_case(p, (yyvsp[-3].nd), (yyvsp[-1].nd));
}
-#line 7562 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7787 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 307:
-#line 2581 "mrbgems/mruby-compiler/core/parse.y"
+ case 319:
+#line 2689 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_case(p, 0, (yyvsp[-1].nd));
}
-#line 7570 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7795 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 308:
-#line 2585 "mrbgems/mruby-compiler/core/parse.y"
+ case 320:
+#line 2693 "mrbgems/mruby-compiler/core/parse.y"
{COND_PUSH(1);}
-#line 7576 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7801 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 309:
-#line 2587 "mrbgems/mruby-compiler/core/parse.y"
+ case 321:
+#line 2695 "mrbgems/mruby-compiler/core/parse.y"
{COND_POP();}
-#line 7582 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7807 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 310:
-#line 2590 "mrbgems/mruby-compiler/core/parse.y"
+ case 322:
+#line 2698 "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 7591 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7816 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 311:
-#line 2596 "mrbgems/mruby-compiler/core/parse.y"
+ case 323:
+#line 2704 "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 7602 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7827 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 312:
-#line 2604 "mrbgems/mruby-compiler/core/parse.y"
+ case 324:
+#line 2712 "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 7613 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7838 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 313:
-#line 2612 "mrbgems/mruby-compiler/core/parse.y"
+ case 325:
+#line 2720 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.num) = p->in_def;
p->in_def = 0;
}
-#line 7622 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7847 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 314:
-#line 2617 "mrbgems/mruby-compiler/core/parse.y"
+ case 326:
+#line 2725 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons(local_switch(p), nint(p->in_single));
nvars_block(p);
p->in_single = 0;
}
-#line 7632 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7857 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 315:
-#line 2624 "mrbgems/mruby-compiler/core/parse.y"
+ case 327:
+#line 2732 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_sclass(p, (yyvsp[-5].nd), (yyvsp[-1].nd));
SET_LINENO((yyval.nd), (yyvsp[-7].num));
@@ -7641,539 +7866,496 @@ yyreduce:
p->in_def = (yyvsp[-4].num);
p->in_single = intn((yyvsp[-2].nd)->cdr);
}
-#line 7645 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7870 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 316:
-#line 2634 "mrbgems/mruby-compiler/core/parse.y"
+ case 328:
+#line 2742 "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 7656 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7881 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 317:
-#line 2642 "mrbgems/mruby-compiler/core/parse.y"
+ case 329:
+#line 2750 "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 7667 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 318:
-#line 2649 "mrbgems/mruby-compiler/core/parse.y"
- {
- (yyval.stack) = p->cmdarg_stack;
- p->cmdarg_stack = 0;
- }
-#line 7676 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 319:
-#line 2653 "mrbgems/mruby-compiler/core/parse.y"
- {
- p->in_def++;
- (yyval.nd) = local_switch(p);
- nvars_block(p);
- }
-#line 7686 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7892 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 320:
-#line 2661 "mrbgems/mruby-compiler/core/parse.y"
+ case 330:
+#line 2760 "mrbgems/mruby-compiler/core/parse.y"
{
- (yyval.nd) = new_def(p, (yyvsp[-5].id), (yyvsp[-2].nd), (yyvsp[-1].nd));
- SET_LINENO((yyval.nd), (yyvsp[-6].num));
- local_resume(p, (yyvsp[-3].nd));
+ (yyval.nd) = (yyvsp[-3].nd);
+ defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
nvars_unnest(p);
p->in_def--;
- p->cmdarg_stack = (yyvsp[-4].stack);
- }
-#line 7699 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 321:
-#line 2670 "mrbgems/mruby-compiler/core/parse.y"
- {
- p->lstate = EXPR_FNAME;
- (yyval.stack) = p->cmdarg_stack;
- p->cmdarg_stack = 0;
- }
-#line 7709 "mrbgems/mruby-compiler/core/y.tab.c"
- break;
-
- case 322:
-#line 2676 "mrbgems/mruby-compiler/core/parse.y"
- {
- p->in_single++;
- p->lstate = EXPR_ENDFN; /* force for args */
- (yyval.nd) = local_switch(p);
- nvars_block(p);
}
-#line 7720 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7903 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 323:
-#line 2685 "mrbgems/mruby-compiler/core/parse.y"
+ case 331:
+#line 2770 "mrbgems/mruby-compiler/core/parse.y"
{
- (yyval.nd) = new_sdef(p, (yyvsp[-7].nd), (yyvsp[-4].id), (yyvsp[-2].nd), (yyvsp[-1].nd));
- SET_LINENO((yyval.nd), (yyvsp[-8].num));
- local_resume(p, (yyvsp[-3].nd));
+ (yyval.nd) = (yyvsp[-3].nd);
+ defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
nvars_unnest(p);
+ p->in_def--;
p->in_single--;
- p->cmdarg_stack = (yyvsp[-5].stack);
}
-#line 7733 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7915 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 324:
-#line 2694 "mrbgems/mruby-compiler/core/parse.y"
+ case 332:
+#line 2778 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_break(p, 0);
}
-#line 7741 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7923 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 325:
-#line 2698 "mrbgems/mruby-compiler/core/parse.y"
+ case 333:
+#line 2782 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_next(p, 0);
}
-#line 7749 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7931 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 326:
-#line 2702 "mrbgems/mruby-compiler/core/parse.y"
+ case 334:
+#line 2786 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_redo(p);
}
-#line 7757 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7939 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 327:
-#line 2706 "mrbgems/mruby-compiler/core/parse.y"
+ case 335:
+#line 2790 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_retry(p);
}
-#line 7765 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7947 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 328:
-#line 2712 "mrbgems/mruby-compiler/core/parse.y"
+ case 336:
+#line 2796 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
if (!(yyval.nd)) (yyval.nd) = new_nil(p);
}
-#line 7774 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7956 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 335:
-#line 2731 "mrbgems/mruby-compiler/core/parse.y"
+ case 343:
+#line 2815 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_if(p, cond((yyvsp[-3].nd)), (yyvsp[-1].nd), (yyvsp[0].nd));
}
-#line 7782 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7964 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 337:
-#line 2738 "mrbgems/mruby-compiler/core/parse.y"
+ case 345:
+#line 2822 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 7790 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7972 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 338:
-#line 2744 "mrbgems/mruby-compiler/core/parse.y"
+ case 346:
+#line 2828 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1(list1((yyvsp[0].nd)));
}
-#line 7798 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7980 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 340:
-#line 2751 "mrbgems/mruby-compiler/core/parse.y"
+ case 348:
+#line 2835 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3((yyvsp[0].nd),0,0);
}
-#line 7806 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7988 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 341:
-#line 2755 "mrbgems/mruby-compiler/core/parse.y"
+ case 349:
+#line 2839 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3((yyvsp[-3].nd), new_arg(p, (yyvsp[0].id)), 0);
}
-#line 7814 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7996 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 342:
-#line 2759 "mrbgems/mruby-compiler/core/parse.y"
+ case 350:
+#line 2843 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3((yyvsp[-5].nd), new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
}
-#line 7822 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8004 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 343:
-#line 2763 "mrbgems/mruby-compiler/core/parse.y"
+ case 351:
+#line 2847 "mrbgems/mruby-compiler/core/parse.y"
{
local_add_f(p, 0);
(yyval.nd) = list3((yyvsp[-2].nd), (node*)-1, 0);
}
-#line 7831 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8013 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 344:
-#line 2768 "mrbgems/mruby-compiler/core/parse.y"
+ case 352:
+#line 2852 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3((yyvsp[-4].nd), (node*)-1, (yyvsp[0].nd));
}
-#line 7839 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8021 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 345:
-#line 2772 "mrbgems/mruby-compiler/core/parse.y"
+ case 353:
+#line 2856 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3(0, new_arg(p, (yyvsp[0].id)), 0);
}
-#line 7847 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8029 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 346:
-#line 2776 "mrbgems/mruby-compiler/core/parse.y"
+ case 354:
+#line 2860 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3(0, new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
}
-#line 7855 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8037 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 347:
-#line 2780 "mrbgems/mruby-compiler/core/parse.y"
+ case 355:
+#line 2864 "mrbgems/mruby-compiler/core/parse.y"
{
local_add_f(p, 0);
(yyval.nd) = list3(0, (node*)-1, 0);
}
-#line 7864 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8046 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 348:
-#line 2785 "mrbgems/mruby-compiler/core/parse.y"
+ case 356:
+#line 2869 "mrbgems/mruby-compiler/core/parse.y"
{
local_add_f(p, 0);
}
-#line 7872 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8054 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 349:
-#line 2789 "mrbgems/mruby-compiler/core/parse.y"
+ case 357:
+#line 2873 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list3(0, (node*)-1, (yyvsp[0].nd));
}
-#line 7880 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8062 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 350:
-#line 2795 "mrbgems/mruby-compiler/core/parse.y"
+ case 358:
+#line 2879 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
}
-#line 7888 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8070 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 351:
-#line 2799 "mrbgems/mruby-compiler/core/parse.y"
+ case 359:
+#line 2883 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
}
-#line 7896 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8078 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 352:
-#line 2803 "mrbgems/mruby-compiler/core/parse.y"
+ case 360:
+#line 2887 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
}
-#line 7904 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8086 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 353:
-#line 2807 "mrbgems/mruby-compiler/core/parse.y"
+ case 361:
+#line 2891 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
}
-#line 7912 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8094 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 354:
-#line 2813 "mrbgems/mruby-compiler/core/parse.y"
+ case 362:
+#line 2897 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 7920 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8102 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 355:
-#line 2817 "mrbgems/mruby-compiler/core/parse.y"
+ case 363:
+#line 2901 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, 0, 0, 0);
}
-#line 7928 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8110 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 356:
-#line 2823 "mrbgems/mruby-compiler/core/parse.y"
+ case 364:
+#line 2907 "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 7936 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8118 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 357:
-#line 2827 "mrbgems/mruby-compiler/core/parse.y"
+ case 365:
+#line 2911 "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 7944 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8126 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 358:
-#line 2831 "mrbgems/mruby-compiler/core/parse.y"
+ case 366:
+#line 2915 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
}
-#line 7952 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8134 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 359:
-#line 2835 "mrbgems/mruby-compiler/core/parse.y"
+ case 367:
+#line 2919 "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 7960 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8142 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 360:
-#line 2839 "mrbgems/mruby-compiler/core/parse.y"
+ case 368:
+#line 2923 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
}
-#line 7968 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8150 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 361:
-#line 2843 "mrbgems/mruby-compiler/core/parse.y"
+ case 369:
+#line 2927 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, (yyvsp[-2].nd), 0, 0, 0, (yyvsp[0].nd));
}
-#line 7976 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8158 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 362:
-#line 2847 "mrbgems/mruby-compiler/core/parse.y"
+ case 370:
+#line 2931 "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 7984 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8166 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 363:
-#line 2851 "mrbgems/mruby-compiler/core/parse.y"
+ case 371:
+#line 2935 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
}
-#line 7992 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8174 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 364:
-#line 2855 "mrbgems/mruby-compiler/core/parse.y"
+ case 372:
+#line 2939 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
}
-#line 8000 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8182 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 365:
-#line 2859 "mrbgems/mruby-compiler/core/parse.y"
+ case 373:
+#line 2943 "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 8008 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8190 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 366:
-#line 2863 "mrbgems/mruby-compiler/core/parse.y"
+ case 374:
+#line 2947 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
}
-#line 8016 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8198 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 367:
-#line 2867 "mrbgems/mruby-compiler/core/parse.y"
+ case 375:
+#line 2951 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
}
-#line 8024 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8206 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 368:
-#line 2871 "mrbgems/mruby-compiler/core/parse.y"
+ case 376:
+#line 2955 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
}
-#line 8032 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8214 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 369:
-#line 2875 "mrbgems/mruby-compiler/core/parse.y"
+ case 377:
+#line 2959 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
}
-#line 8040 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8222 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 370:
-#line 2879 "mrbgems/mruby-compiler/core/parse.y"
+ case 378:
+#line 2963 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
}
-#line 8048 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8230 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 371:
-#line 2885 "mrbgems/mruby-compiler/core/parse.y"
+ case 379:
+#line 2969 "mrbgems/mruby-compiler/core/parse.y"
{
local_add_blk(p, 0);
(yyval.nd) = 0;
}
-#line 8057 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8239 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 372:
-#line 2890 "mrbgems/mruby-compiler/core/parse.y"
+ case 380:
+#line 2974 "mrbgems/mruby-compiler/core/parse.y"
{
p->cmd_start = TRUE;
(yyval.nd) = (yyvsp[0].nd);
}
-#line 8066 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8248 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 373:
-#line 2896 "mrbgems/mruby-compiler/core/parse.y"
+ case 381:
+#line 2980 "mrbgems/mruby-compiler/core/parse.y"
{local_add_blk(p, 0);}
-#line 8072 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8254 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 374:
-#line 2897 "mrbgems/mruby-compiler/core/parse.y"
+ case 382:
+#line 2981 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = 0;
}
-#line 8080 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8262 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 375:
-#line 2901 "mrbgems/mruby-compiler/core/parse.y"
+ case 383:
+#line 2985 "mrbgems/mruby-compiler/core/parse.y"
{
local_add_blk(p, 0);
(yyval.nd) = 0;
}
-#line 8089 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8271 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 376:
-#line 2906 "mrbgems/mruby-compiler/core/parse.y"
+ case 384:
+#line 2990 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-2].nd);
}
-#line 8097 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8279 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 377:
-#line 2913 "mrbgems/mruby-compiler/core/parse.y"
+ case 385:
+#line 2997 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = 0;
}
-#line 8105 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8287 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 378:
-#line 2917 "mrbgems/mruby-compiler/core/parse.y"
+ case 386:
+#line 3001 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = 0;
}
-#line 8113 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8295 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 381:
-#line 2927 "mrbgems/mruby-compiler/core/parse.y"
+ case 389:
+#line 3011 "mrbgems/mruby-compiler/core/parse.y"
{
local_add_f(p, (yyvsp[0].id));
new_bv(p, (yyvsp[0].id));
}
-#line 8122 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8304 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 383:
-#line 2935 "mrbgems/mruby-compiler/core/parse.y"
+ case 391:
+#line 3019 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-2].nd);
}
-#line 8130 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8312 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 384:
-#line 2939 "mrbgems/mruby-compiler/core/parse.y"
+ case 392:
+#line 3023 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 8138 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8320 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 385:
-#line 2945 "mrbgems/mruby-compiler/core/parse.y"
+ case 393:
+#line 3029 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 8146 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8328 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 386:
-#line 2949 "mrbgems/mruby-compiler/core/parse.y"
+ case 394:
+#line 3033 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 8154 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8336 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 387:
-#line 2955 "mrbgems/mruby-compiler/core/parse.y"
+ case 395:
+#line 3039 "mrbgems/mruby-compiler/core/parse.y"
{
local_nest(p);
nvars_nest(p);
}
-#line 8163 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8345 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 388:
-#line 2962 "mrbgems/mruby-compiler/core/parse.y"
+ case 396:
+#line 3046 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
local_unnest(p);
nvars_unnest(p);
}
-#line 8173 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8355 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 389:
-#line 2970 "mrbgems/mruby-compiler/core/parse.y"
+ case 397:
+#line 3054 "mrbgems/mruby-compiler/core/parse.y"
{
if ((yyvsp[-1].nd)->car == (node*)NODE_YIELD) {
yyerror(p, "block given to yield");
@@ -8183,159 +8365,159 @@ yyreduce:
}
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 8187 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8369 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 390:
-#line 2980 "mrbgems/mruby-compiler/core/parse.y"
+ case 398:
+#line 3064 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
}
-#line 8195 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8377 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 391:
-#line 2984 "mrbgems/mruby-compiler/core/parse.y"
+ case 399:
+#line 3068 "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 8204 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8386 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 392:
-#line 2989 "mrbgems/mruby-compiler/core/parse.y"
+ case 400:
+#line 3073 "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 8213 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8395 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 393:
-#line 2996 "mrbgems/mruby-compiler/core/parse.y"
+ case 401:
+#line 3080 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
}
-#line 8221 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8403 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 394:
-#line 3000 "mrbgems/mruby-compiler/core/parse.y"
+ case 402:
+#line 3084 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
}
-#line 8229 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8411 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 395:
-#line 3004 "mrbgems/mruby-compiler/core/parse.y"
+ case 403:
+#line 3088 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
}
-#line 8237 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8419 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 396:
-#line 3008 "mrbgems/mruby-compiler/core/parse.y"
+ case 404:
+#line 3092 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
}
-#line 8245 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8427 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 397:
-#line 3012 "mrbgems/mruby-compiler/core/parse.y"
+ case 405:
+#line 3096 "mrbgems/mruby-compiler/core/parse.y"
{
- (yyval.nd) = new_call(p, (yyvsp[-2].nd), intern_lit("call"), (yyvsp[0].nd), (yyvsp[-1].num));
+ (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM(call), (yyvsp[0].nd), (yyvsp[-1].num));
}
-#line 8253 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8435 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 398:
-#line 3016 "mrbgems/mruby-compiler/core/parse.y"
+ case 406:
+#line 3100 "mrbgems/mruby-compiler/core/parse.y"
{
- (yyval.nd) = new_call(p, (yyvsp[-2].nd), intern_lit("call"), (yyvsp[0].nd), tCOLON2);
+ (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM(call), (yyvsp[0].nd), tCOLON2);
}
-#line 8261 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8443 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 399:
-#line 3020 "mrbgems/mruby-compiler/core/parse.y"
+ case 407:
+#line 3104 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_super(p, (yyvsp[0].nd));
}
-#line 8269 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8451 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 400:
-#line 3024 "mrbgems/mruby-compiler/core/parse.y"
+ case 408:
+#line 3108 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_zsuper(p);
}
-#line 8277 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8459 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 401:
-#line 3028 "mrbgems/mruby-compiler/core/parse.y"
+ case 409:
+#line 3112 "mrbgems/mruby-compiler/core/parse.y"
{
- (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_lit("[]"), (yyvsp[-1].nd), '.');
+ (yyval.nd) = new_call(p, (yyvsp[-3].nd), MRB_QSYM(aref), (yyvsp[-1].nd), '.');
}
-#line 8285 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8467 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 402:
-#line 3034 "mrbgems/mruby-compiler/core/parse.y"
+ case 410:
+#line 3118 "mrbgems/mruby-compiler/core/parse.y"
{
local_nest(p);
nvars_nest(p);
(yyval.num) = p->lineno;
}
-#line 8295 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8477 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 403:
-#line 3041 "mrbgems/mruby-compiler/core/parse.y"
+ case 411:
+#line 3125 "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 8306 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8488 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 404:
-#line 3048 "mrbgems/mruby-compiler/core/parse.y"
+ case 412:
+#line 3132 "mrbgems/mruby-compiler/core/parse.y"
{
local_nest(p);
nvars_nest(p);
(yyval.num) = p->lineno;
}
-#line 8316 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8498 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 405:
-#line 3055 "mrbgems/mruby-compiler/core/parse.y"
+ case 413:
+#line 3139 "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 8327 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8509 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 406:
-#line 3066 "mrbgems/mruby-compiler/core/parse.y"
+ case 414:
+#line 3150 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = cons(cons((yyvsp[-3].nd), (yyvsp[-1].nd)), (yyvsp[0].nd));
}
-#line 8335 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8517 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 407:
-#line 3072 "mrbgems/mruby-compiler/core/parse.y"
+ case 415:
+#line 3156 "mrbgems/mruby-compiler/core/parse.y"
{
if ((yyvsp[0].nd)) {
(yyval.nd) = cons(cons(0, (yyvsp[0].nd)), 0);
@@ -8344,383 +8526,383 @@ yyreduce:
(yyval.nd) = 0;
}
}
-#line 8348 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8530 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 409:
-#line 3086 "mrbgems/mruby-compiler/core/parse.y"
+ case 417:
+#line 3170 "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 8357 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8539 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 411:
-#line 3094 "mrbgems/mruby-compiler/core/parse.y"
+ case 419:
+#line 3178 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
}
-#line 8365 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8547 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 414:
-#line 3102 "mrbgems/mruby-compiler/core/parse.y"
+ case 422:
+#line 3186 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 8373 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8555 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 416:
-#line 3109 "mrbgems/mruby-compiler/core/parse.y"
+ case 424:
+#line 3193 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 8381 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8563 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 423:
-#line 3123 "mrbgems/mruby-compiler/core/parse.y"
+ case 431:
+#line 3207 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = concat_string(p, (yyvsp[-1].nd), (yyvsp[0].nd));
}
-#line 8389 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8571 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 426:
-#line 3131 "mrbgems/mruby-compiler/core/parse.y"
+ case 434:
+#line 3215 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 8397 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8579 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 427:
-#line 3135 "mrbgems/mruby-compiler/core/parse.y"
+ case 435:
+#line 3219 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_dstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
}
-#line 8405 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8587 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 429:
-#line 3142 "mrbgems/mruby-compiler/core/parse.y"
+ case 437:
+#line 3226 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd));
}
-#line 8413 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8595 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 430:
-#line 3148 "mrbgems/mruby-compiler/core/parse.y"
+ case 438:
+#line 3232 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
}
-#line 8421 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8603 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 431:
-#line 3152 "mrbgems/mruby-compiler/core/parse.y"
+ case 439:
+#line 3236 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = p->lex_strterm;
p->lex_strterm = NULL;
}
-#line 8430 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8612 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 432:
-#line 3158 "mrbgems/mruby-compiler/core/parse.y"
+ case 440:
+#line 3242 "mrbgems/mruby-compiler/core/parse.y"
{
p->lex_strterm = (yyvsp[-2].nd);
(yyval.nd) = list2((yyvsp[-3].nd), (yyvsp[-1].nd));
}
-#line 8439 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8621 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 433:
-#line 3163 "mrbgems/mruby-compiler/core/parse.y"
+ case 441:
+#line 3247 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1(new_literal_delim(p));
}
-#line 8447 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8629 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 434:
-#line 3167 "mrbgems/mruby-compiler/core/parse.y"
+ case 442:
+#line 3251 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1(new_literal_delim(p));
}
-#line 8455 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8637 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 435:
-#line 3173 "mrbgems/mruby-compiler/core/parse.y"
+ case 443:
+#line 3257 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 8463 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8645 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 436:
-#line 3177 "mrbgems/mruby-compiler/core/parse.y"
+ case 444:
+#line 3261 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_dxstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
}
-#line 8471 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8653 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 437:
-#line 3183 "mrbgems/mruby-compiler/core/parse.y"
+ case 445:
+#line 3267 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 8479 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8661 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 438:
-#line 3187 "mrbgems/mruby-compiler/core/parse.y"
+ case 446:
+#line 3271 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_dregx(p, (yyvsp[-1].nd), (yyvsp[0].nd));
}
-#line 8487 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8669 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 442:
-#line 3200 "mrbgems/mruby-compiler/core/parse.y"
+ case 450:
+#line 3284 "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 8497 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8679 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 443:
-#line 3206 "mrbgems/mruby-compiler/core/parse.y"
+ case 451:
+#line 3290 "mrbgems/mruby-compiler/core/parse.y"
{
heredoc_end(p);
}
-#line 8505 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8687 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 446:
-#line 3216 "mrbgems/mruby-compiler/core/parse.y"
+ case 454:
+#line 3300 "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 8515 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8697 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 447:
-#line 3222 "mrbgems/mruby-compiler/core/parse.y"
+ case 455:
+#line 3306 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = p->lex_strterm;
p->lex_strterm = NULL;
}
-#line 8524 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8706 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 448:
-#line 3228 "mrbgems/mruby-compiler/core/parse.y"
+ case 456:
+#line 3312 "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 8534 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8716 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 449:
-#line 3236 "mrbgems/mruby-compiler/core/parse.y"
+ case 457:
+#line 3320 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_words(p, list1((yyvsp[0].nd)));
}
-#line 8542 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8724 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 450:
-#line 3240 "mrbgems/mruby-compiler/core/parse.y"
+ case 458:
+#line 3324 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_words(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
}
-#line 8550 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8732 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 451:
-#line 3247 "mrbgems/mruby-compiler/core/parse.y"
+ case 459:
+#line 3331 "mrbgems/mruby-compiler/core/parse.y"
{
p->lstate = EXPR_ENDARG;
(yyval.nd) = new_sym(p, (yyvsp[0].id));
}
-#line 8559 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8741 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 452:
-#line 3252 "mrbgems/mruby-compiler/core/parse.y"
+ case 460:
+#line 3336 "mrbgems/mruby-compiler/core/parse.y"
{
p->lstate = EXPR_ENDARG;
(yyval.nd) = new_dsym(p, new_dstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd))));
}
-#line 8568 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8750 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 453:
-#line 3259 "mrbgems/mruby-compiler/core/parse.y"
+ case 461:
+#line 3343 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.id) = (yyvsp[0].id);
}
-#line 8576 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8758 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 458:
-#line 3269 "mrbgems/mruby-compiler/core/parse.y"
+ case 466:
+#line 3353 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.id) = new_strsym(p, (yyvsp[0].nd));
}
-#line 8584 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8766 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 459:
-#line 3273 "mrbgems/mruby-compiler/core/parse.y"
+ case 467:
+#line 3357 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.id) = new_strsym(p, (yyvsp[0].nd));
}
-#line 8592 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8774 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 460:
-#line 3279 "mrbgems/mruby-compiler/core/parse.y"
+ case 468:
+#line 3363 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_symbols(p, list1((yyvsp[0].nd)));
}
-#line 8600 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8782 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 461:
-#line 3283 "mrbgems/mruby-compiler/core/parse.y"
+ case 469:
+#line 3367 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_symbols(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
}
-#line 8608 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8790 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 464:
-#line 3291 "mrbgems/mruby-compiler/core/parse.y"
+ case 472:
+#line 3375 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = negate_lit(p, (yyvsp[0].nd));
}
-#line 8616 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8798 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 465:
-#line 3295 "mrbgems/mruby-compiler/core/parse.y"
+ case 473:
+#line 3379 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = negate_lit(p, (yyvsp[0].nd));
}
-#line 8624 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8806 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 466:
-#line 3301 "mrbgems/mruby-compiler/core/parse.y"
+ case 474:
+#line 3385 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_lvar(p, (yyvsp[0].id));
}
-#line 8632 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8814 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 467:
-#line 3305 "mrbgems/mruby-compiler/core/parse.y"
+ case 475:
+#line 3389 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_ivar(p, (yyvsp[0].id));
}
-#line 8640 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8822 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 468:
-#line 3309 "mrbgems/mruby-compiler/core/parse.y"
+ case 476:
+#line 3393 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_gvar(p, (yyvsp[0].id));
}
-#line 8648 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8830 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 469:
-#line 3313 "mrbgems/mruby-compiler/core/parse.y"
+ case 477:
+#line 3397 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_cvar(p, (yyvsp[0].id));
}
-#line 8656 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8838 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 470:
-#line 3317 "mrbgems/mruby-compiler/core/parse.y"
+ case 478:
+#line 3401 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_const(p, (yyvsp[0].id));
}
-#line 8664 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8846 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 471:
-#line 3323 "mrbgems/mruby-compiler/core/parse.y"
+ case 479:
+#line 3407 "mrbgems/mruby-compiler/core/parse.y"
{
assignable(p, (yyvsp[0].nd));
}
-#line 8672 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8854 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 472:
-#line 3327 "mrbgems/mruby-compiler/core/parse.y"
+ case 480:
+#line 3411 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "can't assign to numbered parameter");
}
-#line 8680 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8862 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 473:
-#line 3333 "mrbgems/mruby-compiler/core/parse.y"
+ case 481:
+#line 3417 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = var_reference(p, (yyvsp[0].nd));
}
-#line 8688 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8870 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 474:
-#line 3337 "mrbgems/mruby-compiler/core/parse.y"
+ case 482:
+#line 3421 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_nil(p);
}
-#line 8696 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8878 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 475:
-#line 3341 "mrbgems/mruby-compiler/core/parse.y"
+ case 483:
+#line 3425 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_self(p);
}
-#line 8704 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8886 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 476:
-#line 3345 "mrbgems/mruby-compiler/core/parse.y"
+ case 484:
+#line 3429 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_true(p);
}
-#line 8712 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8894 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 477:
-#line 3349 "mrbgems/mruby-compiler/core/parse.y"
+ case 485:
+#line 3433 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_false(p);
}
-#line 8720 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8902 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 478:
-#line 3353 "mrbgems/mruby-compiler/core/parse.y"
+ case 486:
+#line 3437 "mrbgems/mruby-compiler/core/parse.y"
{
const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
if (!fn) {
@@ -8728,22 +8910,22 @@ yyreduce:
}
(yyval.nd) = new_str(p, fn, strlen(fn));
}
-#line 8732 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8914 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 479:
-#line 3361 "mrbgems/mruby-compiler/core/parse.y"
+ case 487:
+#line 3445 "mrbgems/mruby-compiler/core/parse.y"
{
char buf[16];
dump_int(p->lineno, buf);
(yyval.nd) = new_int(p, buf, 10, 0);
}
-#line 8743 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8925 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 480:
-#line 3368 "mrbgems/mruby-compiler/core/parse.y"
+ case 488:
+#line 3452 "mrbgems/mruby-compiler/core/parse.y"
{
#ifdef MRB_UTF8_STRING
const char *enc = "UTF-8";
@@ -8752,561 +8934,561 @@ yyreduce:
#endif
(yyval.nd) = new_str(p, enc, strlen(enc));
}
-#line 8756 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8938 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 483:
-#line 3383 "mrbgems/mruby-compiler/core/parse.y"
+ case 491:
+#line 3467 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = 0;
}
-#line 8764 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8946 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 484:
-#line 3387 "mrbgems/mruby-compiler/core/parse.y"
+ case 492:
+#line 3471 "mrbgems/mruby-compiler/core/parse.y"
{
p->lstate = EXPR_BEG;
p->cmd_start = TRUE;
}
-#line 8773 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8955 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 485:
-#line 3392 "mrbgems/mruby-compiler/core/parse.y"
+ case 493:
+#line 3476 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 8781 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8963 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 486:
-#line 3403 "mrbgems/mruby-compiler/core/parse.y"
+ case 494:
+#line 3487 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
p->lstate = EXPR_BEG;
p->cmd_start = TRUE;
}
-#line 8791 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8973 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 487:
-#line 3409 "mrbgems/mruby-compiler/core/parse.y"
+ case 495:
+#line 3493 "mrbgems/mruby-compiler/core/parse.y"
{
#if 1
/* til real keyword args implemented */
- mrb_sym r = mrb_intern_lit(p->mrb, "*");
- mrb_sym b = mrb_intern_lit(p->mrb, "&");
+ mrb_sym r = MRB_QSYM(mul);
+ mrb_sym b = MRB_QSYM(and);
local_add_f(p, r);
(yyval.nd) = new_args(p, 0, 0, r, 0,
new_args_tail(p, 0, 0, b));
#else
- mrb_sym r = mrb_intern_lit(p->mrb, "*");
- mrb_sym k = mrb_intern_lit(p->mrb, "**");
- mrb_sym b = mrb_intern_lit(p->mrb, "&");
+ mrb_sym r = MRB_QSYM(mul);
+ mrb_sym k = MRB_QSYM(pow);
+ mrb_sym b = MRB_QSYM(and);
local_add_f(p, r); local_add_f(p, k);
(yyval.nd) = new_args(p, 0, 0, r, 0,
new_args_tail(p, 0, new_kw_rest_args(p, nsym(k)), b));
#endif
}
-#line 8813 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8995 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 488:
-#line 3427 "mrbgems/mruby-compiler/core/parse.y"
+ case 497:
+#line 3514 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 8821 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9003 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 489:
-#line 3433 "mrbgems/mruby-compiler/core/parse.y"
+ case 498:
+#line 3520 "mrbgems/mruby-compiler/core/parse.y"
{
local_nest(p);
}
-#line 8829 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9011 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 490:
-#line 3439 "mrbgems/mruby-compiler/core/parse.y"
+ case 499:
+#line 3526 "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 8839 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9021 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 491:
-#line 3445 "mrbgems/mruby-compiler/core/parse.y"
+ case 500:
+#line 3532 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
local_unnest(p);
}
-#line 8848 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9030 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 492:
-#line 3452 "mrbgems/mruby-compiler/core/parse.y"
+ case 501:
+#line 3539 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p)));
local_unnest(p);
}
-#line 8857 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9039 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 493:
-#line 3457 "mrbgems/mruby-compiler/core/parse.y"
+ case 502:
+#line 3544 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
local_unnest(p);
}
-#line 8866 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9048 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 494:
-#line 3464 "mrbgems/mruby-compiler/core/parse.y"
+ case 503:
+#line 3551 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
}
-#line 8874 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9056 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 495:
-#line 3468 "mrbgems/mruby-compiler/core/parse.y"
+ case 504:
+#line 3555 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 8882 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9064 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 496:
-#line 3474 "mrbgems/mruby-compiler/core/parse.y"
+ case 505:
+#line 3561 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
}
-#line 8890 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9072 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 497:
-#line 3478 "mrbgems/mruby-compiler/core/parse.y"
+ case 506:
+#line 3565 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 8898 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9080 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 500:
-#line 3488 "mrbgems/mruby-compiler/core/parse.y"
+ case 509:
+#line 3575 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_kw_rest_args(p, nsym((yyvsp[0].id)));
}
-#line 8906 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9088 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 501:
-#line 3492 "mrbgems/mruby-compiler/core/parse.y"
+ case 510:
+#line 3579 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_kw_rest_args(p, 0);
}
-#line 8914 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9096 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 502:
-#line 3498 "mrbgems/mruby-compiler/core/parse.y"
+ case 511:
+#line 3585 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
}
-#line 8922 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9104 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 503:
-#line 3502 "mrbgems/mruby-compiler/core/parse.y"
+ case 512:
+#line 3589 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
}
-#line 8930 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9112 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 504:
-#line 3506 "mrbgems/mruby-compiler/core/parse.y"
+ case 513:
+#line 3593 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
}
-#line 8938 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9120 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 505:
-#line 3510 "mrbgems/mruby-compiler/core/parse.y"
+ case 514:
+#line 3597 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
}
-#line 8946 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9128 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 506:
-#line 3516 "mrbgems/mruby-compiler/core/parse.y"
+ case 515:
+#line 3603 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
}
-#line 8954 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9136 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 507:
-#line 3520 "mrbgems/mruby-compiler/core/parse.y"
+ case 516:
+#line 3607 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args_tail(p, 0, 0, 0);
}
-#line 8962 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9144 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 508:
-#line 3526 "mrbgems/mruby-compiler/core/parse.y"
+ case 517:
+#line 3613 "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 8970 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9152 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 509:
-#line 3530 "mrbgems/mruby-compiler/core/parse.y"
+ case 518:
+#line 3617 "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 8978 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9160 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 510:
-#line 3534 "mrbgems/mruby-compiler/core/parse.y"
+ case 519:
+#line 3621 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
}
-#line 8986 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9168 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 511:
-#line 3538 "mrbgems/mruby-compiler/core/parse.y"
+ case 520:
+#line 3625 "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 8994 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9176 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 512:
-#line 3542 "mrbgems/mruby-compiler/core/parse.y"
+ case 521:
+#line 3629 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
}
-#line 9002 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9184 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 513:
-#line 3546 "mrbgems/mruby-compiler/core/parse.y"
+ case 522:
+#line 3633 "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 9010 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9192 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 514:
-#line 3550 "mrbgems/mruby-compiler/core/parse.y"
+ case 523:
+#line 3637 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
}
-#line 9018 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9200 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 515:
-#line 3554 "mrbgems/mruby-compiler/core/parse.y"
+ case 524:
+#line 3641 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
}
-#line 9026 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9208 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 516:
-#line 3558 "mrbgems/mruby-compiler/core/parse.y"
+ case 525:
+#line 3645 "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 9034 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9216 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 517:
-#line 3562 "mrbgems/mruby-compiler/core/parse.y"
+ case 526:
+#line 3649 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
}
-#line 9042 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9224 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 518:
-#line 3566 "mrbgems/mruby-compiler/core/parse.y"
+ case 527:
+#line 3653 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
}
-#line 9050 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9232 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 519:
-#line 3570 "mrbgems/mruby-compiler/core/parse.y"
+ case 528:
+#line 3657 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
}
-#line 9058 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9240 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 520:
-#line 3574 "mrbgems/mruby-compiler/core/parse.y"
+ case 529:
+#line 3661 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
}
-#line 9066 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9248 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 521:
-#line 3578 "mrbgems/mruby-compiler/core/parse.y"
+ case 530:
+#line 3665 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
}
-#line 9074 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9256 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 522:
-#line 3582 "mrbgems/mruby-compiler/core/parse.y"
+ case 531:
+#line 3669 "mrbgems/mruby-compiler/core/parse.y"
{
- local_add_f(p, mrb_intern_lit(p->mrb, "&"));
+ local_add_f(p, MRB_QSYM(and));
(yyval.nd) = new_args(p, 0, 0, 0, 0, 0);
}
-#line 9083 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9265 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 523:
-#line 3589 "mrbgems/mruby-compiler/core/parse.y"
+ case 532:
+#line 3676 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "formal argument cannot be a constant");
(yyval.nd) = 0;
}
-#line 9092 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9274 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 524:
-#line 3594 "mrbgems/mruby-compiler/core/parse.y"
+ case 533:
+#line 3681 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "formal argument cannot be an instance variable");
(yyval.nd) = 0;
}
-#line 9101 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9283 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 525:
-#line 3599 "mrbgems/mruby-compiler/core/parse.y"
+ case 534:
+#line 3686 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "formal argument cannot be a global variable");
(yyval.nd) = 0;
}
-#line 9110 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9292 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 526:
-#line 3604 "mrbgems/mruby-compiler/core/parse.y"
+ case 535:
+#line 3691 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "formal argument cannot be a class variable");
(yyval.nd) = 0;
}
-#line 9119 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9301 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 527:
-#line 3609 "mrbgems/mruby-compiler/core/parse.y"
+ case 536:
+#line 3696 "mrbgems/mruby-compiler/core/parse.y"
{
yyerror(p, "formal argument cannot be a numbered parameter");
(yyval.nd) = 0;
}
-#line 9128 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9310 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 528:
-#line 3616 "mrbgems/mruby-compiler/core/parse.y"
+ case 537:
+#line 3703 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.id) = 0;
}
-#line 9136 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9318 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 529:
-#line 3620 "mrbgems/mruby-compiler/core/parse.y"
+ case 538:
+#line 3707 "mrbgems/mruby-compiler/core/parse.y"
{
local_add_f(p, (yyvsp[0].id));
(yyval.id) = (yyvsp[0].id);
}
-#line 9145 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9327 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 530:
-#line 3627 "mrbgems/mruby-compiler/core/parse.y"
+ case 539:
+#line 3714 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = new_arg(p, (yyvsp[0].id));
}
-#line 9153 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9335 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 531:
-#line 3631 "mrbgems/mruby-compiler/core/parse.y"
+ case 540:
+#line 3718 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = local_switch(p);
}
-#line 9161 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9343 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 532:
-#line 3635 "mrbgems/mruby-compiler/core/parse.y"
+ case 541:
+#line 3722 "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 9171 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9353 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 533:
-#line 3643 "mrbgems/mruby-compiler/core/parse.y"
+ case 542:
+#line 3730 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
}
-#line 9179 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9361 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 534:
-#line 3647 "mrbgems/mruby-compiler/core/parse.y"
+ case 543:
+#line 3734 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 9187 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9369 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 535:
-#line 3653 "mrbgems/mruby-compiler/core/parse.y"
+ case 544:
+#line 3740 "mrbgems/mruby-compiler/core/parse.y"
{
local_add_f(p, (yyvsp[-1].id));
local_nest(p);
(yyval.id) = (yyvsp[-1].id);
}
-#line 9197 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9379 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 536:
-#line 3661 "mrbgems/mruby-compiler/core/parse.y"
+ case 545:
+#line 3748 "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 9207 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9389 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 537:
-#line 3669 "mrbgems/mruby-compiler/core/parse.y"
+ case 546:
+#line 3756 "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 9217 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9399 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 538:
-#line 3677 "mrbgems/mruby-compiler/core/parse.y"
+ case 547:
+#line 3764 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
}
-#line 9225 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9407 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 539:
-#line 3681 "mrbgems/mruby-compiler/core/parse.y"
+ case 548:
+#line 3768 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 9233 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9415 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 540:
-#line 3687 "mrbgems/mruby-compiler/core/parse.y"
+ case 549:
+#line 3774 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
}
-#line 9241 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9423 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 541:
-#line 3691 "mrbgems/mruby-compiler/core/parse.y"
+ case 550:
+#line 3778 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 9249 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9431 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 544:
-#line 3701 "mrbgems/mruby-compiler/core/parse.y"
+ case 553:
+#line 3788 "mrbgems/mruby-compiler/core/parse.y"
{
local_add_f(p, (yyvsp[0].id));
(yyval.id) = (yyvsp[0].id);
}
-#line 9258 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9440 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 545:
-#line 3706 "mrbgems/mruby-compiler/core/parse.y"
+ case 554:
+#line 3793 "mrbgems/mruby-compiler/core/parse.y"
{
- local_add_f(p, mrb_intern_lit(p->mrb, "*"));
+ local_add_f(p, MRB_QSYM(mul));
(yyval.id) = -1;
}
-#line 9267 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9449 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 548:
-#line 3717 "mrbgems/mruby-compiler/core/parse.y"
+ case 557:
+#line 3804 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.id) = (yyvsp[0].id);
}
-#line 9275 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9457 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 549:
-#line 3723 "mrbgems/mruby-compiler/core/parse.y"
+ case 558:
+#line 3810 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.id) = (yyvsp[0].id);
}
-#line 9283 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9465 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 550:
-#line 3727 "mrbgems/mruby-compiler/core/parse.y"
+ case 559:
+#line 3814 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.id) = 0;
}
-#line 9291 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9473 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 551:
-#line 3733 "mrbgems/mruby-compiler/core/parse.y"
+ case 560:
+#line 3820 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[0].nd);
if (!(yyval.nd)) (yyval.nd) = new_nil(p);
}
-#line 9300 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9482 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 552:
-#line 3737 "mrbgems/mruby-compiler/core/parse.y"
+ case 561:
+#line 3824 "mrbgems/mruby-compiler/core/parse.y"
{p->lstate = EXPR_BEG;}
-#line 9306 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9488 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 553:
-#line 3738 "mrbgems/mruby-compiler/core/parse.y"
+ case 562:
+#line 3825 "mrbgems/mruby-compiler/core/parse.y"
{
if ((yyvsp[-1].nd) == 0) {
yyerror(p, "can't define singleton method for ().");
@@ -9329,55 +9511,55 @@ yyreduce:
}
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 9333 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9515 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 555:
-#line 3764 "mrbgems/mruby-compiler/core/parse.y"
+ case 564:
+#line 3851 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = (yyvsp[-1].nd);
}
-#line 9341 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9523 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 556:
-#line 3770 "mrbgems/mruby-compiler/core/parse.y"
+ case 565:
+#line 3857 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = list1((yyvsp[0].nd));
NODE_LINENO((yyval.nd), (yyvsp[0].nd));
}
-#line 9350 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9532 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 557:
-#line 3775 "mrbgems/mruby-compiler/core/parse.y"
+ case 566:
+#line 3862 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
}
-#line 9358 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9540 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 560:
-#line 3785 "mrbgems/mruby-compiler/core/parse.y"
+ case 569:
+#line 3872 "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 9368 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9550 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 561:
-#line 3791 "mrbgems/mruby-compiler/core/parse.y"
+ case 570:
+#line 3878 "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 9377 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9559 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 562:
-#line 3796 "mrbgems/mruby-compiler/core/parse.y"
+ case 571:
+#line 3883 "mrbgems/mruby-compiler/core/parse.y"
{
void_expr_error(p, (yyvsp[0].nd));
if ((yyvsp[-2].nd)->car == (node*)NODE_DSTR) {
@@ -9387,67 +9569,67 @@ yyreduce:
(yyval.nd) = cons(new_sym(p, new_strsym(p, (yyvsp[-2].nd))), (yyvsp[0].nd));
}
}
-#line 9391 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9573 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 563:
-#line 3806 "mrbgems/mruby-compiler/core/parse.y"
+ case 572:
+#line 3893 "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 9400 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9582 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 576:
-#line 3833 "mrbgems/mruby-compiler/core/parse.y"
+ case 585:
+#line 3920 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.num) = '.';
}
-#line 9408 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9590 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 577:
-#line 3837 "mrbgems/mruby-compiler/core/parse.y"
+ case 586:
+#line 3924 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.num) = 0;
}
-#line 9416 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9598 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 579:
-#line 3844 "mrbgems/mruby-compiler/core/parse.y"
+ case 588:
+#line 3931 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.num) = tCOLON2;
}
-#line 9424 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9606 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 588:
-#line 3865 "mrbgems/mruby-compiler/core/parse.y"
+ case 597:
+#line 3952 "mrbgems/mruby-compiler/core/parse.y"
{yyerrok;}
-#line 9430 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9612 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 591:
-#line 3871 "mrbgems/mruby-compiler/core/parse.y"
+ case 600:
+#line 3958 "mrbgems/mruby-compiler/core/parse.y"
{
p->lineno += (yyvsp[0].num);
p->column = 0;
}
-#line 9439 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9621 "mrbgems/mruby-compiler/core/y.tab.c"
break;
- case 594:
-#line 3882 "mrbgems/mruby-compiler/core/parse.y"
+ case 603:
+#line 3969 "mrbgems/mruby-compiler/core/parse.y"
{
(yyval.nd) = 0;
}
-#line 9447 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9629 "mrbgems/mruby-compiler/core/y.tab.c"
break;
-#line 9451 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9633 "mrbgems/mruby-compiler/core/y.tab.c"
default: break;
}
@@ -9679,7 +9861,7 @@ yyreturn:
#endif
return yyresult;
}
-#line 3886 "mrbgems/mruby-compiler/core/parse.y"
+#line 3973 "mrbgems/mruby-compiler/core/parse.y"
#define pylval (*((YYSTYPE*)(p->ylval)))
@@ -10758,7 +10940,7 @@ parser_yylex(parser_state *p)
case '*':
if ((c = nextc(p)) == '*') {
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("**");
+ pylval.id = MRB_QSYM(pow);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -10776,7 +10958,7 @@ parser_yylex(parser_state *p)
}
else {
if (c == '=') {
- pylval.id = intern_lit("*");
+ pylval.id = MRB_QSYM(mul);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -10892,7 +11074,7 @@ parser_yylex(parser_state *p)
}
if (c == '<') {
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("<<");
+ pylval.id = MRB_QSYM(lshift);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -10914,7 +11096,7 @@ parser_yylex(parser_state *p)
}
if (c == '>') {
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit(">>");
+ pylval.id = MRB_QSYM(rshift);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -11022,7 +11204,7 @@ parser_yylex(parser_state *p)
if ((c = nextc(p)) == '&') {
p->lstate = EXPR_BEG;
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("&&");
+ pylval.id = MRB_QSYM(andand);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -11034,7 +11216,7 @@ parser_yylex(parser_state *p)
return tANDDOT;
}
else if (c == '=') {
- pylval.id = intern_lit("&");
+ pylval.id = MRB_QSYM(and);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -11061,7 +11243,7 @@ parser_yylex(parser_state *p)
if ((c = nextc(p)) == '|') {
p->lstate = EXPR_BEG;
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("||");
+ pylval.id = MRB_QSYM(oror);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -11069,7 +11251,7 @@ parser_yylex(parser_state *p)
return tOROP;
}
if (c == '=') {
- pylval.id = intern_lit("|");
+ pylval.id = MRB_QSYM(or);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -11093,7 +11275,7 @@ parser_yylex(parser_state *p)
return '+';
}
if (c == '=') {
- pylval.id = intern_lit("+");
+ pylval.id = MRB_QSYM(add);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -11121,7 +11303,7 @@ parser_yylex(parser_state *p)
return '-';
}
if (c == '=') {
- pylval.id = intern_lit("-");
+ pylval.id = MRB_QSYM(sub);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -11371,7 +11553,7 @@ parser_yylex(parser_state *p)
}
tokfix(p);
if (is_float) {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
yywarning_s(p, "floating point numbers are not supported", tok(p));
pylval.nd = new_int(p, "0", 10, 0);
return tINTEGER;
@@ -11441,7 +11623,7 @@ parser_yylex(parser_state *p)
return tREGEXP_BEG;
}
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("/");
+ pylval.id = MRB_QSYM(div);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -11460,7 +11642,7 @@ parser_yylex(parser_state *p)
case '^':
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("^");
+ pylval.id = MRB_QSYM(xor);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -11637,7 +11819,7 @@ parser_yylex(parser_state *p)
}
}
if ((c = nextc(p)) == '=') {
- pylval.id = intern_lit("%");
+ pylval.id = MRB_QSYM(mod);
p->lstate = EXPR_BEG;
return tOP_ASGN;
}
@@ -12265,7 +12447,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
struct RClass *target = mrb->object_class;
struct RProc *proc;
mrb_value v;
- unsigned int keep = 0;
+ mrb_int keep = 0;
if (!p) {
return mrb_undef_value();
@@ -12285,7 +12467,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
}
else {
if (mrb->exc == NULL) {
- mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
+ mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
}
mrb_parser_free(p);
return mrb_undef_value();
@@ -12295,7 +12477,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
mrb_parser_free(p);
if (proc == NULL) {
if (mrb->exc == NULL) {
- mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
+ mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
}
return mrb_undef_value();
}
diff --git a/mrbgems/mruby-complex/mrblib/complex.rb b/mrbgems/mruby-complex/mrblib/complex.rb
index 74c128a0702ccfce05bb6aa6444e2fd156665471..67f94086584487584441c0a996474c45498d5363 100644
--- a/mrbgems/mruby-complex/mrblib/complex.rb
+++ b/mrbgems/mruby-complex/mrblib/complex.rb
@@ -104,7 +104,7 @@ class Complex < Numeric
alias_method :imag, :imaginary
- [Fixnum, Float].each do |cls|
+ [Integer, Float].each do |cls|
[:+, :-, :*, :/, :==].each do |op|
cls.instance_eval do
original_operator_name = :"__original_operator_#{op}_complex"
diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c
index 0432da63312dba5c1f039bab646c724e7a941702..6b7486ab00d119847db311e755c9e075674a2bd4 100644
--- a/mrbgems/mruby-complex/src/complex.c
+++ b/mrbgems/mruby-complex/src/complex.c
@@ -3,8 +3,8 @@
#include <mruby/numeric.h>
#include <math.h>
-#ifdef MRB_WITHOUT_FLOAT
-# error Complex conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb'
+#ifdef MRB_NO_FLOAT
+# error Complex conflicts with 'MRB_NO_FLOAT' configuration
#endif
struct mrb_complex {
@@ -12,13 +12,13 @@ struct mrb_complex {
mrb_float imaginary;
};
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
#define F(x) x##f
#else
#define F(x) x
#endif
-#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT)
+#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32)
#define COMPLEX_USE_ISTRUCT
/* use TT_ISTRUCT */
@@ -69,7 +69,7 @@ complex_ptr(mrb_state *mrb, mrb_value v)
static mrb_value
complex_new(mrb_state *mrb, mrb_float real, mrb_float imaginary)
{
- struct RClass *c = mrb_class_get(mrb, "Complex");
+ struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Complex));
struct mrb_complex *p;
struct RBasic *comp = complex_alloc(mrb, c, &p);
p->real = real;
@@ -122,7 +122,7 @@ complex_to_i(mrb_state *mrb, mrb_value self)
if (p->imaginary != 0) {
mrb_raisef(mrb, E_RANGE_ERROR, "can't convert %v into Float", self);
}
- return mrb_int_value(mrb, p->real);
+ return mrb_int_value(mrb, (mrb_int)p->real);
}
static mrb_value
@@ -224,7 +224,7 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb)
#ifdef COMPLEX_USE_ISTRUCT
mrb_assert(sizeof(struct mrb_complex) < ISTRUCT_DATA_SIZE);
#endif
- comp = mrb_define_class(mrb, "Complex", mrb_class_get(mrb, "Numeric"));
+ comp = mrb_define_class(mrb, "Complex", mrb_class_get_id(mrb, MRB_SYM(Numeric)));
#ifdef COMPLEX_USE_ISTRUCT
MRB_SET_INSTANCE_TT(comp, MRB_TT_ISTRUCT);
#else
diff --git a/mrbgems/mruby-complex/test/complex.rb b/mrbgems/mruby-complex/test/complex.rb
index d996e8277086eec53444b2e71231b4052f3cd9bf..8f9634048e21cf5fdd33ef159bc3ddce6c4cff19 100644
--- a/mrbgems/mruby-complex/test/complex.rb
+++ b/mrbgems/mruby-complex/test/complex.rb
@@ -56,11 +56,11 @@ end
assert 'Complex#/' do
assert_complex Complex(2, 3) / Complex(2, 3) , (1 + 0i)
assert_complex Complex(900) / Complex(1) , (900 + 0i)
- assert_complex Complex(-2, 9) / Complex(-9, 2), ((36 / 85) - (77i / 85))
- assert_complex Complex(9, 8) / 4 , ((9 / 4) + 2i)
+ assert_complex Complex(-2, 9) / Complex(-9, 2), ((36.0 / 85) - (77i / 85))
+ assert_complex Complex(9, 8) / 4 , ((9.0 / 4) + 2i)
assert_complex Complex(20, 9) / 9.8 , (2.0408163265306123 + 0.9183673469387754i)
if 1e39.infinite? then
- # MRB_USE_FLOAT in effect
+ # MRB_USE_FLOAT32 in effect
ten = 1e21
one = 1e20
else
@@ -80,7 +80,7 @@ assert 'Complex#abs' do
assert_float Complex(-1).abs, 1
assert_float Complex(3.0, -4.0).abs, 5.0
if 1e39.infinite? then
- # MRB_USE_FLOAT in effect
+ # MRB_USE_FLOAT32 in effect
exp = 125
else
exp = 1021
diff --git a/mrbgems/mruby-enumerator/mrblib/enumerator.rb b/mrbgems/mruby-enumerator/mrblib/enumerator.rb
index 5a98dc964c836069e7467d383ba1b89abe8643a9..f007b8553567ea663998a8988251e667688e7431 100644
--- a/mrbgems/mruby-enumerator/mrblib/enumerator.rb
+++ b/mrbgems/mruby-enumerator/mrblib/enumerator.rb
@@ -130,6 +130,7 @@ class Enumerator
@feedvalue = nil
@stop_exc = false
end
+
attr_accessor :obj, :meth, :args
attr_reader :fib
diff --git a/mrbgems/mruby-enumerator/test/enumerator.rb b/mrbgems/mruby-enumerator/test/enumerator.rb
index ecd6c4d658f30467de4aacfb4ca3d9ae63204896..26d5766fc75d90b3359ae5a7aa6d8f7e363d16d5 100644
--- a/mrbgems/mruby-enumerator/test/enumerator.rb
+++ b/mrbgems/mruby-enumerator/test/enumerator.rb
@@ -445,7 +445,7 @@ assert 'modifying existing methods' do
}
end
-assert 'Integral#times' do
+assert 'Integer#times' do
a = 3
b = a.times
c = []
diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c
index af6837b81fd70ed49263251b08964cf4ee0b521b..34a4380609f0e08889b294a2bf2de60bff19e56b 100644
--- a/mrbgems/mruby-eval/src/eval.c
+++ b/mrbgems/mruby-eval/src/eval.c
@@ -20,7 +20,7 @@ create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value bi
struct REnv *e;
mrb_callinfo *ci; /* callinfo of eval caller */
struct RClass *target_class = NULL;
- int bidx;
+ mrb_int bidx;
if (!mrb_nil_p(binding)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "Binding of eval must be nil.");
@@ -179,7 +179,7 @@ void
mrb_mruby_eval_gem_init(mrb_state* mrb)
{
mrb_define_module_function(mrb, mrb->kernel_module, "eval", f_eval, MRB_ARGS_ARG(1, 3));
- mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
+ mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
}
void
diff --git a/mrbgems/mruby-inline-struct/test/inline.c b/mrbgems/mruby-inline-struct/test/inline.c
index 5d307dcabb7b4d77ae12671384fc68b971daa557..6764b1af4803031156686f380c6f3b9a90f52e47 100644
--- a/mrbgems/mruby-inline-struct/test/inline.c
+++ b/mrbgems/mruby-inline-struct/test/inline.c
@@ -10,10 +10,10 @@ istruct_test_initialize(mrb_state *mrb, mrb_value self)
mrb_int size = mrb_istruct_size();
mrb_value object = mrb_get_arg1(mrb);
- if (mrb_fixnum_p(object)) {
+ if (mrb_integer_p(object)) {
strncpy(string, "fixnum", size-1);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
else if (mrb_float_p(object)) {
strncpy(string, "float", size-1);
}
diff --git a/mrbgems/mruby-io/mrblib/file.rb b/mrbgems/mruby-io/mrblib/file.rb
index aa73252e1bbfc6418f7c36a789806fcf211224f8..9398acef67bae909f728d87622ddc5cb378593af 100644
--- a/mrbgems/mruby-io/mrblib/file.rb
+++ b/mrbgems/mruby-io/mrblib/file.rb
@@ -2,7 +2,7 @@ class File < IO
attr_accessor :path
def initialize(fd_or_path, mode = "r", perm = 0666)
- if fd_or_path.kind_of? Fixnum
+ if fd_or_path.kind_of? Integer
super(fd_or_path, mode)
else
@path = fd_or_path
diff --git a/mrbgems/mruby-io/mrblib/io.rb b/mrbgems/mruby-io/mrblib/io.rb
index e597db886251eaa874fa0d6303e8674a3425d503..034f8852954f62afc199b40dc346fe57421f9a57 100644
--- a/mrbgems/mruby-io/mrblib/io.rb
+++ b/mrbgems/mruby-io/mrblib/io.rb
@@ -186,7 +186,7 @@ class IO
def read(length = nil, outbuf = "")
unless length.nil?
- unless length.is_a? Fixnum
+ unless length.is_a? Integer
raise TypeError.new "can't convert #{length.class} into Integer"
end
if length < 0
@@ -229,7 +229,7 @@ class IO
case arg
when String
rs = arg
- when Fixnum
+ when Integer
rs = "\n"
limit = arg
else
diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c
index 53ed4b69db406894f78b2d5f32c96d8c62295096..d272cab7d003d80806759fe9156a46da830d7eb4 100644
--- a/mrbgems/mruby-io/src/file.c
+++ b/mrbgems/mruby-io/src/file.c
@@ -399,7 +399,7 @@ mrb_file_mtime(mrb_state *mrb, mrb_value self)
if (mrb_fstat(fd, &st) == -1)
return mrb_false_value();
- return mrb_fixnum_value((mrb_int)st.st_mtime);
+ return mrb_int_value(mrb, (mrb_int)st.st_mtime);
}
static mrb_value
@@ -448,8 +448,8 @@ mrb_file_size(mrb_state *mrb, mrb_value self)
}
if (st.st_size > MRB_INT_MAX) {
-#ifdef MRB_WITHOUT_FLOAT
- mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_WITHOUT_FLOAT");
+#ifdef MRB_NO_FLOAT
+ mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_NO_FLOAT");
#else
return mrb_float_value(mrb, (mrb_float)st.st_size);
#endif
@@ -614,36 +614,36 @@ mrb_init_file(mrb_state *mrb)
mrb_define_method(mrb, file, "size", mrb_file_size, MRB_ARGS_NONE());
mrb_define_method(mrb, file, "truncate", mrb_file_truncate, MRB_ARGS_REQ(1));
- cnst = mrb_define_module_under(mrb, file, "Constants");
- mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH));
- mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX));
- mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN));
- mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB));
- mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR));
- mrb_define_const(mrb, cnst, "PATH_SEPARATOR", mrb_str_new_cstr(mrb, PATH_SEPARATOR));
+ cnst = mrb_define_module_under_id(mrb, file, MRB_SYM(Constants));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_SH), mrb_fixnum_value(LOCK_SH));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_EX), mrb_fixnum_value(LOCK_EX));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_UN), mrb_fixnum_value(LOCK_UN));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_NB), mrb_fixnum_value(LOCK_NB));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(SEPARATOR), mrb_str_new_cstr(mrb, FILE_SEPARATOR));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(PATH_SEPARATOR), mrb_str_new_cstr(mrb, PATH_SEPARATOR));
#if defined(_WIN32) || defined(_WIN64)
- mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR));
#else
- mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_nil_value());
+ mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_nil_value());
#endif
- mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE));
-
- mrb_define_const(mrb, cnst, "RDONLY", mrb_fixnum_value(MRB_O_RDONLY));
- mrb_define_const(mrb, cnst, "WRONLY", mrb_fixnum_value(MRB_O_WRONLY));
- mrb_define_const(mrb, cnst, "RDWR", mrb_fixnum_value(MRB_O_RDWR));
- mrb_define_const(mrb, cnst, "APPEND", mrb_fixnum_value(MRB_O_APPEND));
- mrb_define_const(mrb, cnst, "CREAT", mrb_fixnum_value(MRB_O_CREAT));
- mrb_define_const(mrb, cnst, "EXCL", mrb_fixnum_value(MRB_O_EXCL));
- mrb_define_const(mrb, cnst, "TRUNC", mrb_fixnum_value(MRB_O_TRUNC));
- mrb_define_const(mrb, cnst, "NONBLOCK", mrb_fixnum_value(MRB_O_NONBLOCK));
- mrb_define_const(mrb, cnst, "NOCTTY", mrb_fixnum_value(MRB_O_NOCTTY));
- mrb_define_const(mrb, cnst, "BINARY", mrb_fixnum_value(MRB_O_BINARY));
- mrb_define_const(mrb, cnst, "SHARE_DELETE", mrb_fixnum_value(MRB_O_SHARE_DELETE));
- mrb_define_const(mrb, cnst, "SYNC", mrb_fixnum_value(MRB_O_SYNC));
- mrb_define_const(mrb, cnst, "DSYNC", mrb_fixnum_value(MRB_O_DSYNC));
- mrb_define_const(mrb, cnst, "RSYNC", mrb_fixnum_value(MRB_O_RSYNC));
- mrb_define_const(mrb, cnst, "NOFOLLOW", mrb_fixnum_value(MRB_O_NOFOLLOW));
- mrb_define_const(mrb, cnst, "NOATIME", mrb_fixnum_value(MRB_O_NOATIME));
- mrb_define_const(mrb, cnst, "DIRECT", mrb_fixnum_value(MRB_O_DIRECT));
- mrb_define_const(mrb, cnst, "TMPFILE", mrb_fixnum_value(MRB_O_TMPFILE));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(NULL), mrb_str_new_cstr(mrb, NULL_FILE));
+
+ mrb_define_const_id(mrb, cnst, MRB_SYM(RDONLY), mrb_fixnum_value(MRB_O_RDONLY));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(WRONLY), mrb_fixnum_value(MRB_O_WRONLY));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(RDWR), mrb_fixnum_value(MRB_O_RDWR));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(APPEND), mrb_fixnum_value(MRB_O_APPEND));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(CREAT), mrb_fixnum_value(MRB_O_CREAT));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(EXCL), mrb_fixnum_value(MRB_O_EXCL));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(TRUNC), mrb_fixnum_value(MRB_O_TRUNC));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(NONBLOCK), mrb_fixnum_value(MRB_O_NONBLOCK));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(NOCTTY), mrb_fixnum_value(MRB_O_NOCTTY));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(BINARY), mrb_fixnum_value(MRB_O_BINARY));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(SHARE_DELETE), mrb_fixnum_value(MRB_O_SHARE_DELETE));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(SYNC), mrb_fixnum_value(MRB_O_SYNC));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(DSYNC), mrb_fixnum_value(MRB_O_DSYNC));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(RSYNC), mrb_fixnum_value(MRB_O_RSYNC));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(NOFOLLOW), mrb_fixnum_value(MRB_O_NOFOLLOW));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(NOATIME), mrb_fixnum_value(MRB_O_NOATIME));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(DIRECT), mrb_fixnum_value(MRB_O_DIRECT));
+ mrb_define_const_id(mrb, cnst, MRB_SYM(TMPFILE), mrb_fixnum_value(MRB_O_TMPFILE));
}
diff --git a/mrbgems/mruby-io/src/file_test.c b/mrbgems/mruby-io/src/file_test.c
index b7a28f4d3dd76776a89cebdb8ec4598b45a12c34..f1762369a903c9e16a3f3aaa1a3cb3175697c386 100644
--- a/mrbgems/mruby-io/src/file_test.c
+++ b/mrbgems/mruby-io/src/file_test.c
@@ -66,11 +66,13 @@ mrb_stat(mrb_state *mrb, mrb_value obj, struct stat *st)
return mrb_stat0(mrb, obj, st, 0);
}
+#ifdef S_ISLNK
static int
mrb_lstat(mrb_state *mrb, mrb_value obj, struct stat *st)
{
return mrb_stat0(mrb, obj, st, 1);
}
+#endif
/*
* Document-method: directory?
@@ -302,7 +304,7 @@ mrb_filetest_s_size(mrb_state *mrb, mrb_value klass)
if (mrb_stat(mrb, obj, &st) < 0)
mrb_sys_fail(mrb, "mrb_stat");
- return mrb_fixnum_value(st.st_size);
+ return mrb_int_value(mrb, st.st_size);
}
/*
@@ -324,7 +326,7 @@ mrb_filetest_s_size_p(mrb_state *mrb, mrb_value klass)
if (st.st_size == 0)
return mrb_nil_value();
- return mrb_fixnum_value(st.st_size);
+ return mrb_int_value(mrb, st.st_size);
}
void
diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c
index 2c9cba84a0dce12829b1a33f925afd0bae6305ba..0fa0f34b1ea5faf6e31657fe24c0d23188be5947 100644
--- a/mrbgems/mruby-io/src/io.c
+++ b/mrbgems/mruby-io/src/io.c
@@ -102,14 +102,14 @@ io_set_process_status(mrb_state *mrb, pid_t pid, int status)
mrb_value v;
c_status = NULL;
- if (mrb_class_defined(mrb, "Process")) {
- c_process = mrb_module_get(mrb, "Process");
- if (mrb_const_defined(mrb, mrb_obj_value(c_process), mrb_intern_cstr(mrb, "Status"))) {
- c_status = mrb_class_get_under(mrb, c_process, "Status");
+ if (mrb_class_defined_id(mrb, MRB_SYM(Process))) {
+ c_process = mrb_module_get_id(mrb, MRB_SYM(Process));
+ if (mrb_const_defined(mrb, mrb_obj_value(c_process), MRB_SYM(Status))) {
+ c_status = mrb_class_get_under_id(mrb, c_process, MRB_SYM(Status));
}
}
if (c_status != NULL) {
- v = mrb_funcall(mrb, mrb_obj_value(c_status), "new", 2, mrb_fixnum_value(pid), mrb_fixnum_value(status));
+ v = mrb_funcall_id(mrb, mrb_obj_value(c_status), MRB_SYM(new), 2, mrb_fixnum_value(pid), mrb_fixnum_value(status));
} else {
v = mrb_fixnum_value(WEXITSTATUS(status));
}
@@ -327,19 +327,16 @@ mrb_io_alloc(mrb_state *mrb)
#endif
static int
-option_to_fd(mrb_state *mrb, mrb_value hash, const char *key)
+option_to_fd(mrb_state *mrb, mrb_value v)
{
- mrb_value opt;
+ if (mrb_undef_p(v)) return -1;
+ if (mrb_nil_p(v)) return -1;
- if (!mrb_hash_p(hash)) return -1;
- opt = mrb_hash_fetch(mrb, hash, mrb_symbol_value(mrb_intern_static(mrb, key, strlen(key))), mrb_nil_value());
- if (mrb_nil_p(opt)) return -1;
-
- switch (mrb_type(opt)) {
+ switch (mrb_type(v)) {
case MRB_TT_DATA: /* IO */
- return mrb_io_fileno(mrb, opt);
- case MRB_TT_FIXNUM:
- return (int)mrb_fixnum(opt);
+ return mrb_io_fileno(mrb, v);
+ case MRB_TT_INTEGER:
+ return (int)mrb_integer(v);
default:
mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action");
break;
@@ -353,8 +350,14 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
{
mrb_value cmd, io;
mrb_value mode = mrb_str_new_cstr(mrb, "r");
- mrb_value opt = mrb_hash_new(mrb);
-
+ mrb_value kv[3];
+ mrb_sym knames[3] = {MRB_SYM(in), MRB_SYM(out), MRB_SYM(err)};
+ const mrb_kwargs kw = {
+ 3, 0,
+ knames,
+ kv,
+ NULL,
+ };
struct mrb_io *fptr;
const char *pname;
int pid = 0, flags;
@@ -366,23 +369,22 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
HANDLE ofd[2];
int doexec;
- int opt_in, opt_out, opt_err;
ifd[0] = INVALID_HANDLE_VALUE;
ifd[1] = INVALID_HANDLE_VALUE;
ofd[0] = INVALID_HANDLE_VALUE;
ofd[1] = INVALID_HANDLE_VALUE;
- mrb_get_args(mrb, "S|oH", &cmd, &mode, &opt);
+ mrb_get_args(mrb, "S|o:", &cmd, &mode, &kw, &kv);
io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
pname = RSTRING_CSTR(mrb, cmd);
flags = mrb_io_mode_to_flags(mrb, mode);
doexec = (strcmp("-", pname) != 0);
- opt_in = option_to_fd(mrb, opt, "in");
- opt_out = option_to_fd(mrb, opt, "out");
- opt_err = option_to_fd(mrb, opt, "err");
+ option_to_fd(mrb, kv[0]);
+ option_to_fd(mrb, kv[1]);
+ option_to_fd(mrb, kv[2]);
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
@@ -458,8 +460,14 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
{
mrb_value cmd, io, result;
mrb_value mode = mrb_str_new_cstr(mrb, "r");
- mrb_value opt = mrb_hash_new(mrb);
-
+ mrb_value kv[3];
+ mrb_sym knames[3] = {MRB_SYM(in), MRB_SYM(out), MRB_SYM(err)};
+ const mrb_kwargs kw = {
+ 3, 0,
+ knames,
+ kv,
+ NULL,
+ };
struct mrb_io *fptr;
const char *pname;
int pid, flags, fd, write_fd = -1;
@@ -469,16 +477,16 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
int saved_errno;
int opt_in, opt_out, opt_err;
- mrb_get_args(mrb, "S|oH", &cmd, &mode, &opt);
+ mrb_get_args(mrb, "S|o:", &cmd, &mode, &kw);
io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
pname = RSTRING_CSTR(mrb, cmd);
flags = mrb_io_mode_to_flags(mrb, mode);
doexec = (strcmp("-", pname) != 0);
- opt_in = option_to_fd(mrb, opt, "in");
- opt_out = option_to_fd(mrb, opt, "out");
- opt_err = option_to_fd(mrb, opt, "err");
+ opt_in = option_to_fd(mrb, kv[0]);
+ opt_out = option_to_fd(mrb, kv[1]);
+ opt_err = option_to_fd(mrb, kv[2]);
if (OPEN_READABLE_P(flags)) {
if (pipe(pr) == -1) {
@@ -973,10 +981,10 @@ mrb_io_sysseek(mrb_state *mrb, mrb_value io)
mrb_sys_fail(mrb, "sysseek");
}
if (pos > MRB_INT_MAX) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
return mrb_float_value(mrb, (mrb_float)pos);
#else
- mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_WITHOUT_FLOAT");
+ mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_NO_FLOAT");
#endif
} else {
return mrb_fixnum_value(pos);
@@ -1076,12 +1084,12 @@ time2timeval(mrb_state *mrb, mrb_value time)
struct timeval t = { 0, 0 };
switch (mrb_type(time)) {
- case MRB_TT_FIXNUM:
- t.tv_sec = (ftime_t)mrb_fixnum(time);
+ case MRB_TT_INTEGER:
+ t.tv_sec = (ftime_t)mrb_integer(time);
t.tv_usec = 0;
break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
t.tv_sec = (ftime_t)mrb_float(time);
t.tv_usec = (fsuseconds_t)((mrb_float(time) - t.tv_sec) * 1000000.0);
diff --git a/mrbgems/mruby-io/test/io.rb b/mrbgems/mruby-io/test/io.rb
index 2088a61e3f46c66d47f5c786a01e2d92d0dc5b1d..76ae13a588b660ddf4b13936d02b71d422296dd5 100644
--- a/mrbgems/mruby-io/test/io.rb
+++ b/mrbgems/mruby-io/test/io.rb
@@ -7,7 +7,7 @@ $cr, $crlf, $cmd = MRubyIOTestUtil.win? ? [1, "\r\n", "cmd /c "] : [0, "\n", ""]
def assert_io_open(meth)
assert "assert_io_open" do
fd = IO.sysopen($mrbtest_io_rfname)
- assert_equal Fixnum, fd.class
+ assert_equal Integer, fd.class
io1 = IO.__send__(meth, fd)
begin
assert_equal IO, io1.class
@@ -27,7 +27,6 @@ def assert_io_open(meth)
assert_raise(RuntimeError) { IO.__send__(meth, 1023) } # For Windows
assert_raise(RuntimeError) { IO.__send__(meth, 1 << 26) }
- assert_raise(RuntimeError) { IO.__send__(meth, 1 << 32) } if (1 << 32).kind_of?(Integer)
end
end
@@ -433,7 +432,7 @@ assert('IO.popen') do
$? = nil
io = IO.popen("#{$cmd}echo mruby-io")
assert_true io.close_on_exec?
- assert_equal Fixnum, io.pid.class
+ assert_equal Integer, io.pid.class
out = io.read
assert_equal out.class, String
diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c
index 1d183aecd17ada0526cdd083939d6a0a6a139408..6e8679f4781e91aa6c4b361562f3f1629b4e8da4 100644
--- a/mrbgems/mruby-kernel-ext/src/kernel.c
+++ b/mrbgems/mruby-kernel-ext/src/kernel.c
@@ -57,7 +57,7 @@ mrb_f_caller(mrb_state *mrb, mrb_value self)
return mrb_ary_new(mrb);
}
- return mrb_funcall(mrb, bt, "[]", 2, mrb_fixnum_value(lev), mrb_fixnum_value(n));
+ return mrb_funcall_id(mrb, bt, MRB_QSYM(aref), 2, mrb_fixnum_value(lev), mrb_fixnum_value(n));
}
/*
@@ -84,7 +84,7 @@ mrb_f_method(mrb_state *mrb, mrb_value self)
* call-seq:
* Integer(arg,base=0) -> integer
*
- * Converts <i>arg</i> to a <code>Fixnum</code>.
+ * Converts <i>arg</i> to a <code>Integer</code>.
* Numeric types are converted directly (with floating point numbers
* being truncated). <i>base</i> (0, or between 2 and 36) is a base for
* integer string representation. If <i>arg</i> is a <code>String</code>,
@@ -112,7 +112,7 @@ mrb_f_integer(mrb_state *mrb, mrb_value self)
return mrb_convert_to_integer(mrb, arg, base);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/*
* call-seq:
* Float(arg) -> float
@@ -151,7 +151,7 @@ mrb_f_string(mrb_state *mrb, mrb_value self)
mrb_value arg = mrb_get_arg1(mrb);
mrb_value tmp;
- tmp = mrb_convert_type(mrb, arg, MRB_TT_STRING, "String", "to_s");
+ tmp = mrb_type_convert(mrb, arg, MRB_TT_STRING, MRB_SYM(to_s));
return tmp;
}
@@ -170,7 +170,7 @@ mrb_f_array(mrb_state *mrb, mrb_value self)
mrb_value arg = mrb_get_arg1(mrb);
mrb_value tmp;
- tmp = mrb_check_convert_type(mrb, arg, MRB_TT_ARRAY, "Array", "to_a");
+ tmp = mrb_type_convert_check(mrb, arg, MRB_TT_ARRAY, MRB_SYM(to_a));
if (mrb_nil_p(tmp)) {
return mrb_ary_new_from_values(mrb, 1, &arg);
}
@@ -212,7 +212,7 @@ mrb_mruby_kernel_ext_gem_init(mrb_state *mrb)
mrb_define_module_function(mrb, krn, "caller", mrb_f_caller, MRB_ARGS_OPT(2));
mrb_define_method(mrb, krn, "__method__", mrb_f_method, MRB_ARGS_NONE());
mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ARG(1,1));
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
mrb_define_module_function(mrb, krn, "Float", mrb_f_float, MRB_ARGS_REQ(1));
#endif
mrb_define_module_function(mrb, krn, "String", mrb_f_string, MRB_ARGS_REQ(1));
diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c
index 88b33771b376e9f834adc6c5ae4a46d5799ac940..f2622109da378f8e6a74f0801814e869cf40500b 100644
--- a/mrbgems/mruby-math/src/math.c
+++ b/mrbgems/mruby-math/src/math.c
@@ -4,8 +4,8 @@
** See Copyright Notice in mruby.h
*/
-#ifdef MRB_WITHOUT_FLOAT
-# error Math conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb'
+#ifdef MRB_NO_FLOAT
+# error Math conflicts with 'MRB_NO_FLOAT' configuration
#endif
#include <mruby.h>
@@ -16,8 +16,8 @@
static void
domain_error(mrb_state *mrb, const char *func)
{
- struct RClass *math = mrb_module_get(mrb, "Math");
- struct RClass *domainerror = mrb_class_get_under(mrb, math, "DomainError");
+ struct RClass *math = mrb_module_get_id(mrb, MRB_SYM(Math));
+ struct RClass *domainerror = mrb_class_get_under_id(mrb, math, MRB_SYM(DomainError));
mrb_raisef(mrb, domainerror, "Numerical argument is out of domain - %s", func);
}
@@ -629,7 +629,7 @@ math_cbrt(mrb_state *mrb, mrb_value obj)
* Math.frexp(numeric) -> [ fraction, exponent ]
*
* Returns a two-element array containing the normalized fraction (a
- * <code>Float</code>) and exponent (a <code>Fixnum</code>) of
+ * <code>Float</code>) and exponent (a <code>Integer</code>) of
* <i>numeric</i>.
*
* fraction, exponent = Math.frexp(1234) #=> [0.6025390625, 11]
@@ -730,18 +730,18 @@ mrb_mruby_math_gem_init(mrb_state* mrb)
struct RClass *mrb_math;
mrb_math = mrb_define_module(mrb, "Math");
- mrb_define_class_under(mrb, mrb_math, "DomainError", mrb->eStandardError_class);
+ mrb_define_class_under_id(mrb, mrb_math, MRB_SYM(DomainError), mrb->eStandardError_class);
#ifdef M_PI
- mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, M_PI));
+ mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, M_PI));
#else
- mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, atan(1.0)*4.0));
+ mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, atan(1.0)*4.0));
#endif
#ifdef M_E
- mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, M_E));
+ mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, M_E));
#else
- mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, exp(1.0)));
+ mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, exp(1.0)));
#endif
mrb_define_module_function(mrb, mrb_math, "sin", math_sin, MRB_ARGS_REQ(1));
diff --git a/mrbgems/mruby-math/test/math.rb b/mrbgems/mruby-math/test/math.rb
index d2790e289cc42358b3d28385b3ad852646b6c1ba..959eef788e2ae57756f825ba9007600b65f3fe13 100644
--- a/mrbgems/mruby-math/test/math.rb
+++ b/mrbgems/mruby-math/test/math.rb
@@ -209,17 +209,18 @@ assert('Math.atan2') do
assert_float(+Math::PI, Math.atan2(+0.0, -0.0))
assert_float(-Math::PI, Math.atan2(-0.0, -0.0))
+ assert_float(0, Math.atan2(0, 1))
+ assert_float(Math::PI / 4, Math.atan2(1, 1))
+ assert_float(Math::PI / 2, Math.atan2(1, 0))
+
inf = Float::INFINITY
+ skip "Math.atan2() return NaN" if Math.atan2(+inf, -inf).nan?
expected = 3.0 * Math::PI / 4.0
assert_float(+expected, Math.atan2(+inf, -inf))
assert_float(-expected, Math.atan2(-inf, -inf))
expected = Math::PI / 4.0
assert_float(+expected, Math.atan2(+inf, +inf))
assert_float(-expected, Math.atan2(-inf, +inf))
-
- assert_float(0, Math.atan2(0, 1))
- assert_float(Math::PI / 4, Math.atan2(1, 1))
- assert_float(Math::PI / 2, Math.atan2(1, 0))
end
assert('Math.ldexp') do
diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c
index 6c0dc5ad37122e39379cd60ab9ef80e036ffbc1c..b421226f9c654322e1407d8ddb6a3da36c89300e 100644
--- a/mrbgems/mruby-metaprog/src/metaprog.c
+++ b/mrbgems/mruby-metaprog/src/metaprog.c
@@ -132,8 +132,8 @@ mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
static mrb_value
mrb_local_variables(mrb_state *mrb, mrb_value self)
{
- struct RProc *proc;
- mrb_irep *irep;
+ const struct RProc *proc;
+ const mrb_irep *irep;
mrb_value vars;
size_t i;
@@ -148,8 +148,8 @@ mrb_local_variables(mrb_state *mrb, mrb_value self)
irep = proc->body.irep;
if (irep->lv) {
for (i = 0; i + 1 < irep->nlocals; ++i) {
- if (irep->lv[i].name) {
- mrb_sym sym = irep->lv[i].name;
+ if (irep->lv[i]) {
+ mrb_sym sym = irep->lv[i];
const char *name = mrb_sym_name(mrb, sym);
switch (name[0]) {
case '*': case '&':
@@ -168,29 +168,50 @@ mrb_local_variables(mrb_state *mrb, mrb_value self)
return mrb_hash_keys(mrb, vars);
}
-KHASH_DECLARE(st, mrb_sym, char, FALSE)
+KHASH_DECLARE(st, mrb_sym, char, FALSE);
+KHASH_DEFINE(st, mrb_sym, char, FALSE, kh_int_hash_func, kh_int_hash_equal);
-static void
-method_entry_loop(mrb_state *mrb, struct RClass *klass, khash_t(st) *set, khash_t(st) *undef)
+union mt_ptr {
+ struct RProc *proc;
+ mrb_func_t func;
+};
+
+struct mt_elem {
+ union mt_ptr ptr;
+ size_t func_p:1;
+ mrb_sym key:sizeof(mrb_sym)*8-1;
+};
+
+struct mt_set {
+ khash_t(st) *set;
+ khash_t(st) *undef;
+};
+
+static int
+method_entry_i(mrb_state *mrb, mrb_sym mid, struct mt_elem *e, void *p)
{
- khint_t i;
+ struct mt_set *s = (struct mt_set*)p;
- khash_t(mt) *h = klass->mt;
- if (!h || kh_size(h) == 0) return;
- for (i=0;i<kh_end(h);i++) {
- if (kh_exist(h, i)) {
- mrb_method_t m = kh_value(h, i);
- if (MRB_METHOD_UNDEF_P(m)) {
- if (undef) {
- kh_put(st, mrb, undef, kh_key(h, i));
- }
- }
- else if (undef == NULL ||
- kh_get(st, mrb, undef, kh_key(h, i)) == kh_end(undef)) {
- kh_put(st, mrb, set, kh_key(h, i));
- }
+ if (e->ptr.proc == 0) {
+ if (s->undef) {
+ kh_put(st, mrb, s->undef, mid);
}
}
+ else if (s->undef == NULL ||
+ kh_get(st, mrb, s->undef, mid) == kh_end(s->undef)) {
+ kh_put(st, mrb, s->set, mid);
+ }
+ return 0;
+}
+
+static void
+method_entry_loop(mrb_state *mrb, struct RClass *klass, khash_t(st) *set, khash_t(st) *undef)
+{
+ struct mt_set s;
+
+ s.set = set;
+ s.undef = undef;
+ mrb_mt_foreach(mrb, klass, method_entry_i, (void*)&s);
}
static mrb_value
@@ -608,28 +629,6 @@ mrb_mod_instance_methods(mrb_state *mrb, mrb_value mod)
return mrb_class_instance_method_list(mrb, recur, c, 0);
}
-static void
-remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
-{
- struct RClass *c = mrb_class_ptr(mod);
- khash_t(mt) *h;
- khiter_t k;
-
- MRB_CLASS_ORIGIN(c);
- h = c->mt;
-
- if (h) {
- k = kh_get(mt, mrb, h, mid);
- if (k != kh_end(h)) {
- kh_del(mt, mrb, h, k);
- mrb_funcall(mrb, mod, "method_removed", 1, mrb_symbol_value(mid));
- return;
- }
- }
-
- mrb_name_error(mrb, mid, "method '%n' not defined in %v", mid, mod);
-}
-
/* 15.2.2.4.41 */
/*
* call-seq:
@@ -644,11 +643,13 @@ mrb_mod_remove_method(mrb_state *mrb, mrb_value mod)
{
mrb_int argc;
mrb_value *argv;
+ struct RClass *c = mrb_class_ptr(mod);
mrb_get_args(mrb, "*", &argv, &argc);
mrb_check_frozen(mrb, mrb_obj_ptr(mod));
while (argc--) {
- remove_method(mrb, mod, mrb_obj_to_sym(mrb, *argv));
+ mrb_remove_method(mrb, c, mrb_obj_to_sym(mrb, *argv));
+ mrb_funcall_id(mrb, mod, MRB_SYM(method_removed), 1, *argv);
argv++;
}
return mod;
@@ -664,7 +665,7 @@ mrb_mod_s_constants(mrb_state *mrb, mrb_value mod)
static mrb_value
mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod)
{
- struct RProc *proc;
+ const struct RProc *proc;
mrb_value ary;
struct RClass *c = NULL;
@@ -684,6 +685,9 @@ mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod)
return ary;
}
+/* implementation of #send method */
+mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+
void
mrb_mruby_metaprog_gem_init(mrb_state* mrb)
{
diff --git a/mrbgems/mruby-metaprog/test/metaprog.rb b/mrbgems/mruby-metaprog/test/metaprog.rb
index 82ba0a3a59d5e38b4f10b455fff99eeaebd2dbee..84f4e00a0f7c62aaab9b39aaf6138fede7966fc8 100644
--- a/mrbgems/mruby-metaprog/test/metaprog.rb
+++ b/mrbgems/mruby-metaprog/test/metaprog.rb
@@ -395,15 +395,15 @@ end
assert('alias_method and remove_method') do
begin
- Fixnum.alias_method :to_s_, :to_s
- Fixnum.remove_method :to_s
+ Integer.alias_method :to_s_, :to_s
+ Integer.remove_method :to_s
assert_nothing_raised do
# segfaults if mrb_cptr is used
1.to_s
end
ensure
- Fixnum.alias_method :to_s, :to_s_
- Fixnum.remove_method :to_s_
+ Integer.alias_method :to_s, :to_s_
+ Integer.remove_method :to_s_
end
end
diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c
index 111b031b9e8457aa71fd511b8d72a1fd38e01212..c6de6a7bd980d3aec872fccf90cccb9ea2104d5a 100644
--- a/mrbgems/mruby-method/src/method.c
+++ b/mrbgems/mruby-method/src/method.c
@@ -29,24 +29,24 @@ static mrb_value
unbound_method_bind(mrb_state *mrb, mrb_value self)
{
struct RObject *me;
- mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
- mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
- mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
- mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
+ mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+ mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+ mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+ mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
mrb_value recv = mrb_get_arg1(mrb);
bind_check(mrb, recv, owner);
- me = method_object_alloc(mrb, mrb_class_get(mrb, "Method"));
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), owner);
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), recv);
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), name);
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), proc);
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), klass);
+ me = method_object_alloc(mrb, mrb_class_get_id(mrb, MRB_SYM(Method)));
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), owner);
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv);
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name);
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), proc);
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), klass);
return mrb_obj_value(me);
}
-#define IV_GET(value, name) mrb_iv_get(mrb, value, mrb_intern_lit(mrb, name))
+#define IV_GET(value, name) mrb_iv_get(mrb, value, name)
static mrb_value
method_eql(mrb_state *mrb, mrb_value self)
{
@@ -61,22 +61,22 @@ method_eql(mrb_state *mrb, mrb_value self)
if (mrb_class(mrb, self) != mrb_class(mrb, other))
return mrb_false_value();
- klass = mrb_class_ptr(IV_GET(self, "_klass"));
- if (klass != mrb_class_ptr(IV_GET(other, "_klass")))
+ klass = mrb_class_ptr(IV_GET(self, MRB_SYM(_klass)));
+ if (klass != mrb_class_ptr(IV_GET(other, MRB_SYM(_klass))))
return mrb_false_value();
- owner = mrb_class_ptr(IV_GET(self, "_owner"));
- if (owner != mrb_class_ptr(IV_GET(other, "_owner")))
+ owner = mrb_class_ptr(IV_GET(self, MRB_SYM(_owner)));
+ if (owner != mrb_class_ptr(IV_GET(other, MRB_SYM(_owner))))
return mrb_false_value();
- receiver = IV_GET(self, "_recv");
- if (!mrb_obj_equal(mrb, receiver, IV_GET(other, "_recv")))
+ receiver = IV_GET(self, MRB_SYM(_recv));
+ if (!mrb_obj_equal(mrb, receiver, IV_GET(other, MRB_SYM(_recv))))
return mrb_false_value();
- orig_proc = IV_GET(self, "_proc");
- other_proc = IV_GET(other, "_proc");
+ orig_proc = IV_GET(self, MRB_SYM(_proc));
+ other_proc = IV_GET(other, MRB_SYM(_proc));
if (mrb_nil_p(orig_proc) && mrb_nil_p(other_proc)) {
- if (mrb_symbol(IV_GET(self, "_name")) == mrb_symbol(IV_GET(other, "_name")))
+ if (mrb_symbol(IV_GET(self, MRB_SYM(_name))) == mrb_symbol(IV_GET(other, MRB_SYM(_name))))
return mrb_true_value();
else
return mrb_false_value();
@@ -118,7 +118,7 @@ mcall(mrb_state *mrb, mrb_value recv, mrb_value proc, mrb_value name, struct RCl
if (mrb_nil_p(proc)) {
mrb_value missing_argv = mrb_ary_new_from_values(mrb, argc, argv);
mrb_ary_unshift(mrb, missing_argv, name);
- ret = mrb_funcall_argv(mrb, recv, mrb_intern_lit(mrb, "method_missing"), argc + 1, RARRAY_PTR(missing_argv));
+ ret = mrb_funcall_argv(mrb, recv, MRB_SYM(method_missing), argc + 1, RARRAY_PTR(missing_argv));
}
else if (!mrb_nil_p(block)) {
/*
@@ -137,10 +137,10 @@ mcall(mrb_state *mrb, mrb_value recv, mrb_value proc, mrb_value name, struct RCl
static mrb_value
method_call(mrb_state *mrb, mrb_value self)
{
- mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
- mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
- mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
- struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner")));
+ mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+ mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+ mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv));
+ struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, MRB_SYM(_owner)));
mrb_int argc;
mrb_value *argv, block;
@@ -151,10 +151,10 @@ method_call(mrb_state *mrb, mrb_value self)
static mrb_value
method_bcall(mrb_state *mrb, mrb_value self)
{
- mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
- mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
- mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
- mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
+ mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+ mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+ mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv));
+ mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
mrb_int argc;
mrb_value *argv, block;
@@ -167,17 +167,17 @@ static mrb_value
method_unbind(mrb_state *mrb, mrb_value self)
{
struct RObject *ume;
- mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
- mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
- mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
- mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
+ mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+ mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+ mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+ mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod"));
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_owner"), owner);
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_recv"), mrb_nil_value());
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_name"), name);
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_proc"), proc);
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_klass"), klass);
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_owner), owner);
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_recv), mrb_nil_value());
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_name), name);
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_proc), proc);
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_klass), klass);
return mrb_obj_value(ume);
}
@@ -196,10 +196,10 @@ method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
static mrb_value
method_super_method(mrb_state *mrb, mrb_value self)
{
- mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
- mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
- mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
- mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+ mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv));
+ mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
+ mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+ mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
struct RClass *super, *rklass;
struct RProc *proc;
struct RObject *me;
@@ -225,11 +225,11 @@ method_super_method(mrb_state *mrb, mrb_value self)
super = super->c;
me = method_object_alloc(mrb, mrb_obj_class(mrb, self));
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(super));
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), recv);
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), name);
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), mrb_obj_value(proc));
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), mrb_obj_value(rklass));
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), mrb_obj_value(super));
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv);
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name);
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), mrb_obj_value(proc));
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), mrb_obj_value(rklass));
return mrb_obj_value(me);
}
@@ -237,7 +237,7 @@ method_super_method(mrb_state *mrb, mrb_value self)
static mrb_value
method_arity(mrb_state *mrb, mrb_value self)
{
- mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+ mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
mrb_int arity = mrb_nil_p(proc) ? -1 : mrb_proc_arity(mrb_proc_ptr(proc));
return mrb_fixnum_value(arity);
}
@@ -245,7 +245,7 @@ method_arity(mrb_state *mrb, mrb_value self)
static mrb_value
method_source_location(mrb_state *mrb, mrb_value self)
{
- mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+ mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
struct RProc *rproc;
struct RClass *orig;
mrb_value ret;
@@ -256,7 +256,7 @@ method_source_location(mrb_state *mrb, mrb_value self)
rproc = mrb_proc_ptr(proc);
orig = rproc->c;
rproc->c = mrb->proc_class;
- ret = mrb_funcall(mrb, proc, "source_location", 0);
+ ret = mrb_funcall_id(mrb, proc, MRB_SYM(source_location), 0);
rproc->c = orig;
return ret;
}
@@ -264,13 +264,13 @@ method_source_location(mrb_state *mrb, mrb_value self)
static mrb_value
method_parameters(mrb_state *mrb, mrb_value self)
{
- mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+ mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
struct RProc *rproc;
struct RClass *orig;
mrb_value ret;
if (mrb_nil_p(proc)) {
- mrb_value rest = mrb_symbol_value(mrb_intern_lit(mrb, "rest"));
+ mrb_value rest = mrb_symbol_value(MRB_SYM(rest));
mrb_value arest = mrb_ary_new_from_values(mrb, 1, &rest);
return mrb_ary_new_from_values(mrb, 1, &arest);
}
@@ -278,7 +278,7 @@ method_parameters(mrb_state *mrb, mrb_value self)
rproc = mrb_proc_ptr(proc);
orig = rproc->c;
rproc->c = mrb->proc_class;
- ret = mrb_funcall(mrb, proc, "parameters", 0);
+ ret = mrb_funcall_id(mrb, proc, MRB_SYM(parameters), 0);
rproc->c = orig;
return ret;
}
@@ -286,9 +286,9 @@ method_parameters(mrb_state *mrb, mrb_value self)
static mrb_value
method_to_s(mrb_state *mrb, mrb_value self)
{
- mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
- mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
- mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+ mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+ mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
+ mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
mrb_value str = mrb_str_new_lit(mrb, "#<");
struct RClass *rklass;
@@ -322,10 +322,10 @@ mrb_search_method_owner(mrb_state *mrb, struct RClass *c, mrb_value obj, mrb_sym
if (unbound) {
goto name_error;
}
- if (!mrb_respond_to(mrb, obj, mrb_intern_lit(mrb, "respond_to_missing?"))) {
+ if (!mrb_respond_to(mrb, obj, MRB_QSYM(respond_to_missing_p))) {
goto name_error;
}
- ret = mrb_funcall(mrb, obj, "respond_to_missing?", 2, mrb_symbol_value(name), mrb_true_value());
+ ret = mrb_funcall_id(mrb, obj, MRB_QSYM(respond_to_missing_p), 2, mrb_symbol_value(name), mrb_true_value());
if (!mrb_test(ret)) {
goto name_error;
}
@@ -354,11 +354,11 @@ mrb_kernel_method(mrb_state *mrb, mrb_value self)
mrb_search_method_owner(mrb, mrb_class(mrb, self), self, name, &owner, &proc, FALSE);
me = method_object_alloc(mrb, mrb_class_get(mrb, "Method"));
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(owner));
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), self);
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), mrb_symbol_value(name));
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), proc ? mrb_obj_value(proc) : mrb_nil_value());
- mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), mrb_obj_value(mrb_class(mrb, self)));
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), mrb_obj_value(owner));
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), self);
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_name), mrb_symbol_value(name));
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), proc ? mrb_obj_value(proc) : mrb_nil_value());
+ mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), mrb_obj_value(mrb_class(mrb, self)));
return mrb_obj_value(me);
}
@@ -376,11 +376,11 @@ mrb_module_instance_method(mrb_state *mrb, mrb_value self)
mrb_search_method_owner(mrb, mrb_class_ptr(self), self, name, &owner, &proc, TRUE);
ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod"));
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(owner));
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_recv"), mrb_nil_value());
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_name"), mrb_symbol_value(name));
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_proc"), proc ? mrb_obj_value(proc) : mrb_nil_value());
- mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_klass"), self);
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_owner), mrb_obj_value(owner));
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_recv), mrb_nil_value());
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_name), mrb_symbol_value(name));
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_proc), proc ? mrb_obj_value(proc) : mrb_nil_value());
+ mrb_obj_iv_set(mrb, ume, MRB_SYM(_klass), self);
return mrb_obj_value(ume);
}
@@ -388,19 +388,19 @@ mrb_module_instance_method(mrb_state *mrb, mrb_value self)
static mrb_value
method_owner(mrb_state *mrb, mrb_value self)
{
- return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
+ return mrb_iv_get(mrb, self, MRB_SYM(_owner));
}
static mrb_value
method_receiver(mrb_state *mrb, mrb_value self)
{
- return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
+ return mrb_iv_get(mrb, self, MRB_SYM(_recv));
}
static mrb_value
method_name(mrb_state *mrb, mrb_value self)
{
- return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+ return mrb_iv_get(mrb, self, MRB_SYM(_name));
}
void
diff --git a/mrbgems/mruby-method/test/method.rb b/mrbgems/mruby-method/test/method.rb
index 641979d716563509954eac9c43f9d6ba0dafed5f..123ae34be925f99d82c13f7a111b069a8df01730 100644
--- a/mrbgems/mruby-method/test/method.rb
+++ b/mrbgems/mruby-method/test/method.rb
@@ -77,7 +77,7 @@ end
assert 'instance' do
assert_kind_of Method, 1.method(:+)
- assert_kind_of UnboundMethod, Fixnum.instance_method(:+)
+ assert_kind_of UnboundMethod, Integer.instance_method(:+)
end
assert 'Method#call' do
@@ -404,9 +404,9 @@ assert 'UnboundMethod#arity' do
end
assert 'UnboundMethod#==' do
- assert_false(Fixnum.instance_method(:+) == Fixnum.instance_method(:-))
- assert_true(Fixnum.instance_method(:+) == Fixnum.instance_method(:+))
- assert_false(Fixnum.instance_method(:+) == Float.instance_method(:+))
+ assert_false(Integer.instance_method(:+) == Integer.instance_method(:-))
+ assert_true(Integer.instance_method(:+) == Integer.instance_method(:+))
+ assert_false(Integer.instance_method(:+) == Float.instance_method(:+))
assert_true(UnboundMethod.instance_method(:==) == UnboundMethod.instance_method(:eql?))
end
diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
index f8aff54bcf59f3ebc300d3503d1f1ab4e6c0be55..e5ec90866261e42a4fee66c197236f6124090c50 100644
--- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c
+++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
@@ -53,24 +53,24 @@ mrb_int_nobits(mrb_state *mrb, mrb_value self)
void
mrb_mruby_numeric_ext_gem_init(mrb_state* mrb)
{
- struct RClass *i = mrb_module_get(mrb, "Integral");
+ struct RClass *i = mrb_class_get(mrb, "Integer");
mrb_define_method(mrb, i, "allbits?", mrb_int_allbits, MRB_ARGS_REQ(1));
mrb_define_method(mrb, i, "anybits?", mrb_int_anybits, MRB_ARGS_REQ(1));
mrb_define_method(mrb, i, "nobits?", mrb_int_nobits, MRB_ARGS_REQ(1));
-#ifndef MRB_WITHOUT_FLOAT
- mrb_define_const(mrb, mrb->float_class, "RADIX", mrb_fixnum_value(MRB_FLT_RADIX));
- mrb_define_const(mrb, mrb->float_class, "MANT_DIG", mrb_fixnum_value(MRB_FLT_MANT_DIG));
- mrb_define_const(mrb, mrb->float_class, "EPSILON", mrb_float_value(mrb, MRB_FLT_EPSILON));
- mrb_define_const(mrb, mrb->float_class, "DIG", mrb_fixnum_value(MRB_FLT_DIG));
- mrb_define_const(mrb, mrb->float_class, "MIN_EXP", mrb_fixnum_value(MRB_FLT_MIN_EXP));
- mrb_define_const(mrb, mrb->float_class, "MIN", mrb_float_value(mrb, MRB_FLT_MIN));
- mrb_define_const(mrb, mrb->float_class, "MIN_10_EXP", mrb_fixnum_value(MRB_FLT_MIN_10_EXP));
- mrb_define_const(mrb, mrb->float_class, "MAX_EXP", mrb_fixnum_value(MRB_FLT_MAX_EXP));
- mrb_define_const(mrb, mrb->float_class, "MAX", mrb_float_value(mrb, MRB_FLT_MAX));
- mrb_define_const(mrb, mrb->float_class, "MAX_10_EXP", mrb_fixnum_value(MRB_FLT_MAX_10_EXP));
-#endif /* MRB_WITHOUT_FLOAT */
+#ifndef MRB_NO_FLOAT
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(RADIX), mrb_fixnum_value(MRB_FLT_RADIX));
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MANT_DIG), mrb_fixnum_value(MRB_FLT_MANT_DIG));
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(EPSILON), mrb_float_value(mrb, MRB_FLT_EPSILON));
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(DIG), mrb_fixnum_value(MRB_FLT_DIG));
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_EXP), mrb_fixnum_value(MRB_FLT_MIN_EXP));
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN), mrb_float_value(mrb, MRB_FLT_MIN));
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_10_EXP), mrb_fixnum_value(MRB_FLT_MIN_10_EXP));
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_EXP), mrb_fixnum_value(MRB_FLT_MAX_EXP));
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX), mrb_float_value(mrb, MRB_FLT_MAX));
+ mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_10_EXP), mrb_fixnum_value(MRB_FLT_MAX_10_EXP));
+#endif /* MRB_NO_FLOAT */
}
void
diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c
index 31bb689f6cfa1096db3d738c3916591a6482c0e7..2d99ce8c23813620daa770f211a77aac2c86bfb7 100644
--- a/mrbgems/mruby-object-ext/src/object.c
+++ b/mrbgems/mruby-object-ext/src/object.c
@@ -17,7 +17,7 @@ nil_to_a(mrb_state *mrb, mrb_value obj)
return mrb_ary_new(mrb);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/*
* call-seq:
* nil.to_f -> 0.0
@@ -115,7 +115,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb)
struct RClass * n = mrb->nil_class;
mrb_define_method(mrb, n, "to_a", nil_to_a, MRB_ARGS_NONE());
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
mrb_define_method(mrb, n, "to_f", nil_to_f, MRB_ARGS_NONE());
#endif
mrb_define_method(mrb, n, "to_h", nil_to_h, MRB_ARGS_NONE());
@@ -123,7 +123,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb)
mrb_define_method(mrb, mrb->kernel_module, "itself", mrb_f_itself, MRB_ARGS_NONE());
- mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
+ mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
}
void
diff --git a/mrbgems/mruby-objectspace/src/mruby_objectspace.c b/mrbgems/mruby-objectspace/src/mruby_objectspace.c
index bded3afa8a01218377c899cd629b6b020472a428..d8013c20f8035284281825932172cd1201a37e6c 100644
--- a/mrbgems/mruby-objectspace/src/mruby_objectspace.c
+++ b/mrbgems/mruby-objectspace/src/mruby_objectspace.c
@@ -71,8 +71,8 @@ os_count_objects(mrb_state *mrb, mrb_value self)
mrb_objspace_each_objects(mrb, os_count_object_type, &obj_count);
- mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "TOTAL")), mrb_fixnum_value(obj_count.total));
- mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "FREE")), mrb_fixnum_value(obj_count.freed));
+ mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(TOTAL)), mrb_fixnum_value(obj_count.total));
+ mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(FREE)), mrb_fixnum_value(obj_count.freed));
for (i = MRB_TT_FALSE; i < MRB_TT_MAXDEFINE; i++) {
mrb_value type;
@@ -81,7 +81,7 @@ os_count_objects(mrb_state *mrb, mrb_value self)
COUNT_TYPE(T_FALSE);
COUNT_TYPE(T_FREE);
COUNT_TYPE(T_TRUE);
- COUNT_TYPE(T_FIXNUM);
+ COUNT_TYPE(T_INTEGER);
COUNT_TYPE(T_SYMBOL);
COUNT_TYPE(T_UNDEF);
COUNT_TYPE(T_FLOAT);
diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c
index 191ab062d6dba3764b74282448cd7f9ea5250953..359c2683c8a1ad4f98ac6b4e84148fbac11f4009 100644
--- a/mrbgems/mruby-os-memsize/src/memsize.c
+++ b/mrbgems/mruby-os-memsize/src/memsize.c
@@ -108,17 +108,6 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj)
if(!MRB_PROC_CFUNC_P(proc)) size += os_memsize_of_irep(mrb, proc->body.irep);
break;
}
- case MRB_TT_DATA:
- size += mrb_objspace_page_slot_size();
- break;
-#ifndef MRB_WITHOUT_FLOAT
- case MRB_TT_FLOAT:
-#ifdef MRB_WORD_BOXING
- size += mrb_objspace_page_slot_size() +
- sizeof(struct RFloat);
-#endif
- break;
-#endif
case MRB_TT_RANGE:
#ifndef MRB_RANGE_EMBED
size += mrb_objspace_page_slot_size() +
@@ -131,22 +120,25 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj)
ptrdiff_t ci_size = f->cxt->ciend - f->cxt->cibase;
size += mrb_objspace_page_slot_size() +
- sizeof(struct RFiber) +
sizeof(struct mrb_context) +
- sizeof(struct RProc *) * f->cxt->esize +
- sizeof(uint16_t *) * f->cxt->rsize +
sizeof(mrb_value) * stack_size +
sizeof(mrb_callinfo) * ci_size;
break;
}
- case MRB_TT_ISTRUCT:
+#ifndef MRB_NO_FLOAT
+ case MRB_TT_FLOAT:
+#endif
+ case MRB_TT_INTEGER:
+ if (mrb_immediate_p(obj))
+ break;
+ case MRB_TT_DATA:
+ case MRB_TT_ISTRUCT:
size += mrb_objspace_page_slot_size();
break;
/* zero heap size types.
* immediate VM stack values, contained within mrb_state, or on C stack */
case MRB_TT_TRUE:
case MRB_TT_FALSE:
- case MRB_TT_FIXNUM:
case MRB_TT_BREAK:
case MRB_TT_CPTR:
case MRB_TT_SYMBOL:
diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c
index e222cd946d6a5592a8c6a6539562d770653e1162..9250e966dd9f75013dfc6700b28bf05657c2007a 100644
--- a/mrbgems/mruby-pack/src/pack.c
+++ b/mrbgems/mruby-pack/src/pack.c
@@ -9,10 +9,10 @@
#include "mruby/numeric.h"
#include "mruby/string.h"
#include "mruby/variable.h"
+#include "mruby/endian.h"
#include <ctype.h>
#include <errno.h>
-#include <limits.h>
#include <string.h>
struct tmpl {
@@ -63,36 +63,6 @@ const static unsigned char base64chars[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static unsigned char base64_dec_tab[128];
-#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER__)
-# define BYTE_ORDER __BYTE_ORDER__
-#endif
-#if !defined(BIG_ENDIAN) && defined(__ORDER_BIG_ENDIAN__)
-# define BIG_ENDIAN __ORDER_BIG_ENDIAN__
-#endif
-#if !defined(LITTLE_ENDIAN) && defined(__ORDER_LITTLE_ENDIAN__)
-# define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__
-#endif
-
-#ifdef BYTE_ORDER
-# if BYTE_ORDER == BIG_ENDIAN
-# define littleendian 0
-# define check_little_endian() (void)0
-# elif BYTE_ORDER == LITTLE_ENDIAN
-# define littleendian 1
-# define check_little_endian() (void)0
-# endif
-#endif
-#ifndef littleendian
-/* can't distinguish endian in compile time */
-static int littleendian = 0;
-static void
-check_little_endian(void)
-{
- unsigned int n = 1;
- littleendian = (*(unsigned char *)&n == 1);
-}
-#endif
-
static unsigned int
hex2int(unsigned char ch)
{
@@ -143,7 +113,7 @@ static int
pack_c(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
{
str = str_len_ensure(mrb, str, sidx + 1);
- RSTRING_PTR(str)[sidx] = (char)mrb_fixnum(o);
+ RSTRING_PTR(str)[sidx] = (char)mrb_integer(o);
return 1;
}
@@ -163,7 +133,7 @@ pack_s(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
uint16_t n;
str = str_len_ensure(mrb, str, sidx + 2);
- n = (uint16_t)mrb_fixnum(o);
+ n = (uint16_t)mrb_integer(o);
if (flags & PACK_FLAG_LITTLEENDIAN) {
RSTRING_PTR(str)[sidx+0] = n % 256;
RSTRING_PTR(str)[sidx+1] = n / 256;
@@ -197,7 +167,7 @@ pack_l(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
uint32_t n;
str = str_len_ensure(mrb, str, sidx + 4);
- n = (uint32_t)mrb_fixnum(o);
+ n = (uint32_t)mrb_integer(o);
if (flags & PACK_FLAG_LITTLEENDIAN) {
RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff);
RSTRING_PTR(str)[sidx+1] = (char)(n >> 8);
@@ -290,7 +260,7 @@ unpack_l(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un
#ifndef MRB_INT64
if (!FIXABLE(sl)) {
i32tostr(msg, sizeof(msg), sl);
- mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg);
+ mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
}
#endif
n = sl;
@@ -298,7 +268,7 @@ unpack_l(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un
#ifndef MRB_INT64
if (!POSFIXABLE(ul)) {
u32tostr(msg, sizeof(msg), ul);
- mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg);
+ mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
}
#endif
n = ul;
@@ -313,7 +283,7 @@ pack_q(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
uint64_t n;
str = str_len_ensure(mrb, str, sidx + 8);
- n = (uint64_t)mrb_fixnum(o);
+ n = (uint64_t)mrb_integer(o);
if (flags & PACK_FLAG_LITTLEENDIAN) {
RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff);
RSTRING_PTR(str)[sidx+1] = (char)(n >> 8);
@@ -411,13 +381,13 @@ unpack_q(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un
int64_t sll = ull;
if (!FIXABLE(sll)) {
i64tostr(msg, sizeof(msg), sll);
- mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg);
+ mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
}
n = (mrb_int)sll;
} else {
if (!POSFIXABLE(ull)) {
u64tostr(msg, sizeof(msg), ull);
- mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg);
+ mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
}
n = (mrb_int)ull;
}
@@ -425,7 +395,7 @@ unpack_q(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un
return 8;
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static int
pack_double(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
{
@@ -560,7 +530,7 @@ pack_utf8(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, long count,
int len = 0;
uint32_t c = 0;
- c = (uint32_t)mrb_fixnum(o);
+ c = (uint32_t)mrb_integer(o);
/* Unicode character */
/* from mruby-compiler gem */
@@ -1248,7 +1218,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary)
if (type == PACK_TYPE_INTEGER) {
o = mrb_to_int(mrb, o);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
else if (type == PACK_TYPE_FLOAT) {
if (!mrb_float_p(o)) {
mrb_float f = mrb_to_flo(mrb, o);
@@ -1284,7 +1254,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary)
case PACK_DIR_STR:
ridx += pack_a(mrb, o, result, ridx, count, flags);
break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case PACK_DIR_DOUBLE:
ridx += pack_double(mrb, o, result, ridx, flags);
break;
@@ -1381,7 +1351,7 @@ pack_unpack(mrb_state *mrb, mrb_value str, int single)
case PACK_DIR_QUAD:
srcidx += unpack_q(mrb, sptr, srclen - srcidx, result, flags);
break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case PACK_DIR_FLOAT:
srcidx += unpack_float(mrb, sptr, srclen - srcidx, result, flags);
break;
@@ -1426,7 +1396,6 @@ mrb_pack_unpack1(mrb_state *mrb, mrb_value str)
void
mrb_mruby_pack_gem_init(mrb_state *mrb)
{
- check_little_endian();
make_base64_dec_tab();
mrb_define_method(mrb, mrb->array_class, "pack", mrb_pack_pack, MRB_ARGS_REQ(1));
diff --git a/mrbgems/mruby-print/src/print.c b/mrbgems/mruby-print/src/print.c
index df153d920be563e5ff298172d421e31d55d2244e..6e91e19416d1b482e00e6ccfd5b9b3c6ed2e523f 100644
--- a/mrbgems/mruby-print/src/print.c
+++ b/mrbgems/mruby-print/src/print.c
@@ -17,22 +17,22 @@
#endif
static void
-printstr(mrb_state *mrb, const char *p, size_t len)
+printstr(mrb_state *mrb, const char *p, mrb_int len)
{
#if defined(_WIN32)
if (isatty(fileno(stdout))) {
DWORD written;
- int wlen = MultiByteToWideChar(CP_UTF8, 0, p, len, NULL, 0);
+ int wlen = MultiByteToWideChar(CP_UTF8, 0, p, (int)len, NULL, 0);
wchar_t* utf16 = (wchar_t*)mrb_malloc(mrb, (wlen+1) * sizeof(wchar_t));
- if (MultiByteToWideChar(CP_UTF8, 0, p, len, utf16, wlen) > 0) {
+ if (MultiByteToWideChar(CP_UTF8, 0, p, (int)len, utf16, wlen) > 0) {
utf16[wlen] = 0;
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE),
- utf16, wlen, &written, NULL);
+ utf16, (DWORD)wlen, &written, NULL);
}
mrb_free(mrb, utf16);
} else
#endif
- fwrite(p, len, 1, stdout);
+ fwrite(p, (size_t)len, 1, stdout);
fflush(stdout);
}
@@ -57,7 +57,7 @@ mrb_print(mrb_state *mrb, mrb_value self)
mrb_get_args(mrb, "*", &argv, &argc);
for (i=0; i<argc; i++) {
- mrb_value s = mrb_str_to_str(mrb, argv[i]);
+ mrb_value s = mrb_obj_as_string(mrb, argv[i]);
printstr(mrb, RSTRING_PTR(s), RSTRING_LEN(s));
}
return mrb_nil_value();
@@ -73,7 +73,7 @@ mrb_puts(mrb_state *mrb, mrb_value self)
mrb_get_args(mrb, "*", &argv, &argc);
for (i=0; i<argc; i++) {
- mrb_value s = mrb_str_to_str(mrb, argv[i]);
+ mrb_value s = mrb_obj_as_string(mrb, argv[i]);
mrb_int len = RSTRING_LEN(s);
printstr(mrb, RSTRING_PTR(s), len);
if (len == 0 || RSTRING_PTR(s)[len-1] != '\n') {
diff --git a/mrbgems/mruby-proc-ext/src/proc.c b/mrbgems/mruby-proc-ext/src/proc.c
index 5343c478f518e2115eeabfeee2e1e288bcee87f6..2f4f77de7d730a997c72ede8f401213daa67dfdd 100644
--- a/mrbgems/mruby-proc-ext/src/proc.c
+++ b/mrbgems/mruby-proc-ext/src/proc.c
@@ -21,7 +21,7 @@ mrb_proc_source_location(mrb_state *mrb, mrb_value self)
return mrb_nil_value();
}
else {
- mrb_irep *irep = p->body.irep;
+ const mrb_irep *irep = p->body.irep;
int32_t line;
const char *filename;
@@ -41,7 +41,7 @@ mrb_proc_inspect(mrb_state *mrb, mrb_value self)
mrb_str_cat_str(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self)));
if (!MRB_PROC_CFUNC_P(p)) {
- mrb_irep *irep = p->body.irep;
+ const mrb_irep *irep = p->body.irep;
const char *filename;
int32_t line;
mrb_str_cat_lit(mrb, str, "@");
@@ -91,21 +91,24 @@ static mrb_value
mrb_proc_parameters(mrb_state *mrb, mrb_value self)
{
struct parameters_type {
- size_t len;
- const char *name;
+ mrb_sym name;
int size;
} *p, parameters_list [] = {
- {sizeof("req") - 1, "req", 0},
- {sizeof("opt") - 1, "opt", 0},
- {sizeof("rest") - 1, "rest", 0},
- {sizeof("req") - 1, "req", 0},
- {sizeof("block") - 1, "block", 0},
- {0, NULL, 0}
+ {MRB_SYM(req), 0},
+ {MRB_SYM(opt), 0},
+ {MRB_SYM(rest), 0},
+ {MRB_SYM(req), 0},
+ {MRB_SYM(keyrest), 0},
+ {MRB_SYM(block), 0},
+ {MRB_SYM(key), 0},
+ {0, 0}
};
const struct RProc *proc = mrb_proc_ptr(self);
const struct mrb_irep *irep = proc->body.irep;
mrb_aspec aspec;
mrb_value parameters;
+ mrb_value krest = mrb_nil_value();
+ mrb_value block = mrb_nil_value();
int i, j;
int max = -1;
@@ -124,10 +127,8 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
}
if (!MRB_PROC_STRICT_P(proc)) {
- parameters_list[0].len = sizeof("opt") - 1;
- parameters_list[0].name = "opt";
- parameters_list[3].len = sizeof("opt") - 1;
- parameters_list[3].name = "opt";
+ parameters_list[0].name = MRB_SYM(opt);
+ parameters_list[3].name = MRB_SYM(opt);
}
aspec = PEEK_W(irep->iseq+1);
@@ -135,21 +136,23 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
parameters_list[1].size = MRB_ASPEC_OPT(aspec);
parameters_list[2].size = MRB_ASPEC_REST(aspec);
parameters_list[3].size = MRB_ASPEC_POST(aspec);
- parameters_list[4].size = MRB_ASPEC_BLOCK(aspec);
+ parameters_list[4].size = MRB_ASPEC_KDICT(aspec);
+ parameters_list[5].size = MRB_ASPEC_BLOCK(aspec);
+ parameters_list[6].size = MRB_ASPEC_KEY(aspec);
parameters = mrb_ary_new_capa(mrb, irep->nlocals-1);
max = irep->nlocals-1;
for (i = 0, p = parameters_list; p->name; p++) {
- mrb_value sname = mrb_symbol_value(mrb_intern_static(mrb, p->name, p->len));
+ mrb_value sname = mrb_symbol_value(p->name);
for (j = 0; j < p->size; i++, j++) {
mrb_value a;
a = mrb_ary_new(mrb);
mrb_ary_push(mrb, a, sname);
- if (i < max && irep->lv[i].name) {
- mrb_sym sym = irep->lv[i].name;
+ if (i < max && irep->lv[i]) {
+ mrb_sym sym = irep->lv[i];
const char *name = mrb_sym_name(mrb, sym);
switch (name[0]) {
case '*': case '&':
@@ -159,9 +162,17 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
break;
}
}
+ if (p->name == MRB_SYM(block)) {
+ block = a; continue;
+ }
+ if (p->name == MRB_SYM(keyrest)) {
+ krest = a; continue;
+ }
mrb_ary_push(mrb, parameters, a);
}
}
+ if (!mrb_nil_p(krest)) mrb_ary_push(mrb, parameters, krest);
+ if (!mrb_nil_p(block)) mrb_ary_push(mrb, parameters, block);
return parameters;
}
diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c
index 10c81b946ce934e7796d9562584e95bbf0a7ffbc..0a5df6bd0db33a76373770de240784ca782b9180 100644
--- a/mrbgems/mruby-random/src/random.c
+++ b/mrbgems/mruby-random/src/random.c
@@ -10,16 +10,40 @@
#include <mruby/data.h>
#include <mruby/array.h>
#include <mruby/istruct.h>
-#if INT32_MAX <= INTPTR_MAX
+
+#include <time.h>
+
+/* Written in 2019 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include <stdint.h>
+
+/* This is xoshiro128++ 1.0, one of our 32-bit all-purpose, rock-solid
+ generators. It has excellent speed, a state size (128 bits) that is
+ large enough for mild parallelism, and it passes all tests we are aware
+ of.
+
+ For generating just single-precision (i.e., 32-bit) floating-point
+ numbers, xoshiro128+ is even faster.
+
+ The state must be seeded so that it is not everywhere zero. */
+
+
+#ifdef MRB_32BIT
# define XORSHIFT96
# define NSEEDS 3
+# define SEEDPOS 2
#else
# define NSEEDS 4
+# define SEEDPOS 0
#endif
#define LASTSEED (NSEEDS-1)
-#include <time.h>
-
typedef struct rand_state {
uint32_t seed[NSEEDS];
} rand_state;
@@ -38,16 +62,23 @@ rand_init(rand_state *t)
static uint32_t
rand_seed(rand_state *t, uint32_t seed)
{
- uint32_t old_seed = t->seed[LASTSEED];
+ uint32_t old_seed = t->seed[SEEDPOS];
rand_init(t);
- t->seed[LASTSEED] = seed;
+ t->seed[SEEDPOS] = seed;
return old_seed;
}
-#ifdef XORSHIFT96
+#ifndef XORSHIFT96
+static inline uint32_t
+rotl(const uint32_t x, int k) {
+ return (x << k) | (x >> (32 - k));
+}
+#endif
+
static uint32_t
rand_uint32(rand_state *state)
{
+#ifdef XORSHIFT96
uint32_t *seed = state->seed;
uint32_t x = seed[0];
uint32_t y = seed[1];
@@ -61,36 +92,29 @@ rand_uint32(rand_state *state)
seed[2] = z;
return z;
-}
-#else /* XORSHIFT96 */
-static uint32_t
-rand_uint32(rand_state *state)
-{
- uint32_t *seed = state->seed;
- uint32_t x = seed[0];
- uint32_t y = seed[1];
- uint32_t z = seed[2];
- uint32_t w = seed[3];
- uint32_t t;
+#else
+ uint32_t *s = state->seed;
+ const uint32_t result = rotl(s[0] + s[3], 7) + s[0];
+ const uint32_t t = s[1] << 9;
- t = x ^ (x << 11);
- x = y; y = z; z = w;
- w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
- seed[0] = x;
- seed[1] = y;
- seed[2] = z;
- seed[3] = w;
+ s[2] ^= s[0];
+ s[3] ^= s[1];
+ s[1] ^= s[2];
+ s[0] ^= s[3];
- return w;
-}
+ s[2] ^= t;
+ s[3] = rotl(s[3], 11);
+
+ return result;
#endif /* XORSHIFT96 */
+ }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static double
rand_real(rand_state *t)
{
uint32_t x = rand_uint32(t);
- return x*(1.0/4294967295.0);
+ return x*(1.0/4294967296.0);
}
#endif
@@ -99,15 +123,15 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max)
{
mrb_value value;
- if (mrb_fixnum(max) == 0) {
-#ifndef MRB_WITHOUT_FLOAT
+ if (mrb_integer(max) == 0) {
+#ifndef MRB_NO_FLOAT
value = mrb_float_value(mrb, rand_real(t));
#else
mrb_raise(mrb, E_ARGUMENT_ERROR, "Float not supported");
#endif
}
else {
- value = mrb_fixnum_value(rand_uint32(t) % mrb_fixnum(max));
+ value = mrb_int_value(mrb, rand_uint32(t) % mrb_integer(max));
}
return value;
@@ -125,7 +149,7 @@ get_opt(mrb_state* mrb)
mrb_int i;
arg = mrb_to_int(mrb, arg);
- i = mrb_fixnum(arg);
+ i = mrb_integer(arg);
if (i < 0) {
arg = mrb_fixnum_value(0 - i);
}
@@ -135,7 +159,7 @@ get_opt(mrb_state* mrb)
static void
random_check(mrb_state *mrb, mrb_value random) {
- struct RClass *c = mrb_class_get(mrb, "Random");
+ struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random));
if (!mrb_obj_is_kind_of(mrb, random, c) || !mrb_istruct_p(random)) {
mrb_raise(mrb, E_TYPE_ERROR, "Random instance required");
}
@@ -144,7 +168,7 @@ random_check(mrb_state *mrb, mrb_value random) {
static mrb_value
random_default(mrb_state *mrb) {
struct RClass *c = mrb_class_get(mrb, "Random");
- mrb_value d = mrb_const_get(mrb, mrb_obj_value(c), mrb_intern_lit(mrb, "DEFAULT"));
+ mrb_value d = mrb_const_get(mrb, mrb_obj_value(c), MRB_SYM(DEFAULT));
if (!mrb_obj_is_kind_of(mrb, d, c)) {
mrb_raise(mrb, E_TYPE_ERROR, "Random::DEFAULT replaced");
}
@@ -167,7 +191,7 @@ random_m_init(mrb_state *mrb, mrb_value self)
rand_init(t);
}
else {
- rand_seed(t, (uint32_t)mrb_fixnum(seed));
+ rand_seed(t, (uint32_t)mrb_integer(seed));
}
return self;
@@ -196,11 +220,11 @@ random_m_srand(mrb_state *mrb, mrb_value self)
seed = (uint32_t)time(NULL) + rand_uint32(t);
}
else {
- seed = (uint32_t)mrb_fixnum(sv);
+ seed = (uint32_t)mrb_integer(sv);
}
old_seed = rand_seed(t, seed);
- return mrb_fixnum_value((mrb_int)old_seed);
+ return mrb_int_value(mrb, (mrb_int)old_seed);
}
/*
@@ -263,7 +287,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
mrb_value *ptr = RARRAY_PTR(ary);
mrb_value tmp;
- j = mrb_fixnum(random_rand(mrb, random, max));
+ j = mrb_integer(random_rand(mrb, random, max));
tmp = ptr[i];
ptr[i] = ptr[j];
@@ -348,16 +372,18 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary)
r = (mrb_int)(rand_uint32(random) % len);
for (j=0; j<i; j++) {
- if (mrb_fixnum(RARRAY_PTR(result)[j]) == r) {
+ if (mrb_integer(RARRAY_PTR(result)[j]) == r) {
goto retry; /* retry if duplicate */
}
}
break;
}
- mrb_ary_push(mrb, result, mrb_fixnum_value(r));
+ mrb_ary_push(mrb, result, mrb_int_value(mrb, r));
}
for (i=0; i<n; i++) {
- mrb_ary_set(mrb, result, i, RARRAY_PTR(ary)[mrb_fixnum(RARRAY_PTR(result)[i])]);
+ mrb_int idx = mrb_integer(RARRAY_PTR(result)[i]);
+ mrb_value elem = RARRAY_PTR(ary)[idx];
+ mrb_ary_set(mrb, result, i, elem);
}
return result;
}
@@ -383,7 +409,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb)
struct RClass *random;
struct RClass *array = mrb->array_class;
- mrb_assert(sizeof(rand_state) <= ISTRUCT_DATA_SIZE);
+ mrb_static_assert1(sizeof(rand_state) <= ISTRUCT_DATA_SIZE);
mrb_define_method(mrb, mrb->kernel_module, "rand", random_f_rand, MRB_ARGS_OPT(1));
mrb_define_method(mrb, mrb->kernel_module, "srand", random_f_srand, MRB_ARGS_OPT(1));
@@ -401,7 +427,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb)
mrb_define_method(mrb, array, "shuffle!", mrb_ary_shuffle_bang, MRB_ARGS_OPT(1));
mrb_define_method(mrb, array, "sample", mrb_ary_sample, MRB_ARGS_OPT(2));
- mrb_const_set(mrb, mrb_obj_value(random), mrb_intern_lit(mrb, "DEFAULT"),
+ mrb_const_set(mrb, mrb_obj_value(random), MRB_SYM(DEFAULT),
mrb_obj_new(mrb, random, 0, NULL));
}
diff --git a/mrbgems/mruby-random/test/random.rb b/mrbgems/mruby-random/test/random.rb
index cf4a5514186c812d11b5980fe5c417afb151ed48..f3067748b6fe03c1cc73c1e649e6e71377e76a14 100644
--- a/mrbgems/mruby-random/test/random.rb
+++ b/mrbgems/mruby-random/test/random.rb
@@ -32,8 +32,8 @@ assert("Random.srand") do
end
assert("return class of Kernel.rand") do
- assert_kind_of(Fixnum, rand(3))
- assert_kind_of(Fixnum, rand(1.5))
+ assert_kind_of(Integer, rand(3))
+ assert_kind_of(Integer, rand(1.5))
assert_kind_of(Float, rand)
assert_kind_of(Float, rand(0.5))
end
diff --git a/mrbgems/mruby-range-ext/mrblib/range.rb b/mrbgems/mruby-range-ext/mrblib/range.rb
index a213beb57be10f353cc2644508f34e853060dd7a..fadddc34390e8b49a8e17d380a342ee660278dfa 100644
--- a/mrbgems/mruby-range-ext/mrblib/range.rb
+++ b/mrbgems/mruby-range-ext/mrblib/range.rb
@@ -33,7 +33,7 @@ class Range
# fast path for numerics
if val.kind_of?(Numeric) && last.kind_of?(Numeric)
- raise TypeError if exclude_end? && !last.kind_of?(Fixnum)
+ raise TypeError if exclude_end? && !last.kind_of?(Integer)
return nil if val > last
return nil if val == last && exclude_end?
diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c
index 2a0b4e97d360939d05c53b562e58ec415830706b..0f2cc6119dbbc4c777f1b14e252a346f24cf1b25 100644
--- a/mrbgems/mruby-range-ext/src/range.c
+++ b/mrbgems/mruby-range-ext/src/range.c
@@ -81,8 +81,8 @@ range_last(mrb_state *mrb, mrb_value range)
return mrb_range_end(mrb, range);
}
- array = mrb_funcall(mrb, range, "to_a", 0);
- return mrb_funcall(mrb, array, "last", 1, mrb_to_int(mrb, num));
+ array = mrb_funcall_id(mrb, range, MRB_SYM(to_a), 0);
+ return mrb_funcall_id(mrb, array, MRB_SYM(last), 1, mrb_to_int(mrb, num));
}
/*
@@ -96,7 +96,7 @@ range_last(mrb_state *mrb, mrb_value range)
* ('a'..'z').size #=> nil
*/
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static mrb_value
range_size(mrb_state *mrb, mrb_value range)
{
@@ -109,8 +109,8 @@ range_size(mrb_state *mrb, mrb_value range)
beg = RANGE_BEG(r);
end = RANGE_END(r);
excl = RANGE_EXCL(r);
- if (mrb_fixnum_p(beg)) {
- beg_f = (mrb_float)mrb_fixnum(beg);
+ if (mrb_integer_p(beg)) {
+ beg_f = (mrb_float)mrb_integer(beg);
}
else if (mrb_float_p(beg)) {
beg_f = mrb_float(beg);
@@ -118,8 +118,8 @@ range_size(mrb_state *mrb, mrb_value range)
else {
num_p = FALSE;
}
- if (mrb_fixnum_p(end)) {
- end_f = (mrb_float)mrb_fixnum(end);
+ if (mrb_integer_p(end)) {
+ end_f = (mrb_float)mrb_integer(end);
}
else if (mrb_float_p(end)) {
end_f = mrb_float(end);
@@ -161,16 +161,16 @@ range_size(mrb_state *mrb, mrb_value range)
end = RANGE_END(r);
excl = RANGE_EXCL(r) ? 0 : 1;
- if (mrb_fixnum_p(beg) && mrb_fixnum_p(end)) {
- mrb_int a = mrb_fixnum(beg);
- mrb_int b = mrb_fixnum(end);
+ if (mrb_integer_p(beg) && mrb_integer_p(end)) {
+ mrb_int a = mrb_integer(beg);
+ mrb_int b = mrb_integer(end);
mrb_int c = b - a + excl;
return mrb_fixnum_value(c);
}
return mrb_nil_value();
}
-#endif /* MRB_WITHOUT_FLOAT */
+#endif /* MRB_NO_FLOAT */
void
mrb_mruby_range_ext_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-rational/mrblib/rational.rb b/mrbgems/mruby-rational/mrblib/rational.rb
index b65f77e2fe9c0b671c04e4245df5ee036394e00d..febabbae77a0fdb653591ea1a48e07dfdb4e9322 100644
--- a/mrbgems/mruby-rational/mrblib/rational.rb
+++ b/mrbgems/mruby-rational/mrblib/rational.rb
@@ -48,11 +48,11 @@ class Rational < Numeric
end
def <=>(rhs)
- if rhs.is_a?(Integral)
+ case rhs
+ when Integer, Float
return numerator <=> rhs if denominator == 1
rhs = Rational(rhs)
end
-
case rhs
when Rational
(numerator * rhs.denominator - denominator * rhs.numerator) <=> 0
@@ -65,14 +65,13 @@ class Rational < Numeric
def ==(rhs)
return true if self.equal?(rhs)
- if rhs.is_a?(Integral) && denominator == 1
- return numerator == rhs
- end
- if rhs.is_a?(Rational)
- numerator * rhs.denominator == denominator * rhs.numerator
- else
- rhs == self
+ case rhs
+ when Integer, Float
+ return numerator == rhs if denominator == 1
+ when Rational
+ return numerator * rhs.denominator == denominator * rhs.numerator
end
+ rhs == self
end
end
@@ -83,16 +82,9 @@ class Numeric
end
module Kernel
- def Rational(numerator, denominator = 1)
- a = numerator
- b = denominator
- a, b = b, a % b until b == 0
- Rational._new(numerator.div(a), denominator.div(a))
- end
-
[:+, :-, :*, :/, :<=>, :==, :<, :<=, :>, :>=].each do |op|
original_operator_name = :"__original_operator_#{op}_rational"
- Fixnum.instance_eval do
+ Integer.instance_eval do
alias_method original_operator_name, op
define_method op do |rhs|
if rhs.is_a? Rational
diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c
index 676a1dc82d9a4c11ee78f3e25b845235fd0eec2a..d5dd7adc45ea60324d25423c7b101e85c4533721 100644
--- a/mrbgems/mruby-rational/src/rational.c
+++ b/mrbgems/mruby-rational/src/rational.c
@@ -60,83 +60,128 @@ static mrb_value
rational_numerator(mrb_state *mrb, mrb_value self)
{
struct mrb_rational *p = rational_ptr(mrb, self);
- return mrb_fixnum_value(p->numerator);
+ return mrb_int_value(mrb, p->numerator);
}
static mrb_value
rational_denominator(mrb_state *mrb, mrb_value self)
{
struct mrb_rational *p = rational_ptr(mrb, self);
- return mrb_fixnum_value(p->denominator);
+ return mrb_int_value(mrb, p->denominator);
}
static mrb_value
rational_new(mrb_state *mrb, mrb_int numerator, mrb_int denominator)
{
- struct RClass *c = mrb_class_get(mrb, "Rational");
+ struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Rational));
struct mrb_rational *p;
struct RBasic *rat = rational_alloc(mrb, c, &p);
+ if (denominator < 0) {
+ numerator *= -1;
+ denominator *= -1;
+ }
p->numerator = numerator;
p->denominator = denominator;
MRB_SET_FROZEN_FLAG(rat);
return mrb_obj_value(rat);
}
+#ifndef MRB_NO_FLOAT
+#include <math.h>
+/* f : number to convert.
+ * num, denom: returned parts of the rational.
+ * md: max denominator value. Note that machine floating point number
+ * has a finite resolution (10e-16 ish for 64 bit double), so specifying
+ * a "best match with minimal error" is often wrong, because one can
+ * always just retrieve the significand and return that divided by
+ * 2**52, which is in a sense accurate, but generally not very useful:
+ * 1.0/7.0 would be "2573485501354569/18014398509481984", for example.
+ */
+#ifdef MRB_INT32
+typedef float rat_float;
+#else
+typedef double rat_float;
+#endif
+static mrb_value
+rational_new_f(mrb_state *mrb, mrb_float f0)
+{
+ rat_float f = (rat_float)f0;
+ mrb_int md = 1000000;
+ /* a: continued fraction coefficients. */
+ mrb_int a, h[3] = { 0, 1, 0 }, k[3] = { 1, 0, 0 };
+ mrb_int x, d;
+ int64_t n = 1;
+ int i, neg = 0;
+
+ if (f < 0) { neg = 1; f = -f; }
+ while (f != floor(f)) { n <<= 1; f *= 2; }
+ d = (mrb_int)f;
+
+ /* continued fraction and check denominator each step */
+ for (i = 0; i < 64; i++) {
+ a = n ? d / n : 0;
+ if (i && !a) break;
+
+ x = d; d = n; n = x % n;
+
+ x = a;
+ if (k[1] * a + k[0] >= md) {
+ x = (md - k[0]) / k[1];
+ if (x * 2 >= a || k[1] >= md)
+ i = 65;
+ else
+ break;
+ }
+
+ h[2] = x * h[1] + h[0]; h[0] = h[1]; h[1] = h[2];
+ k[2] = x * k[1] + k[0]; k[0] = k[1]; k[1] = k[2];
+ }
+ return rational_new(mrb, (neg ? -h[1] : h[1]), k[1]);
+}
+#endif
+
static mrb_value
rational_s_new(mrb_state *mrb, mrb_value self)
{
mrb_int numerator, denominator;
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
mrb_get_args(mrb, "ii", &numerator, &denominator);
#else
-#define DROP_PRECISION(f, num, denom) \
- do { \
- while (f < (mrb_float)MRB_INT_MIN || f > (mrb_float)MRB_INT_MAX) { \
- num /= 2; \
- denom /= 2; \
- } \
- } while (0)
-
- mrb_value numv, denomv;
+ mrb_value numv, denomv;
mrb_get_args(mrb, "oo", &numv, &denomv);
- if (mrb_fixnum_p(numv)) {
- numerator = mrb_fixnum(numv);
+ if (mrb_integer_p(numv)) {
+ numerator = mrb_integer(numv);
- if (mrb_fixnum_p(denomv)) {
- denominator = mrb_fixnum(denomv);
+ if (mrb_integer_p(denomv)) {
+ denominator = mrb_integer(denomv);
}
else {
+ mrb_float numf = (mrb_float)numerator;
mrb_float denomf = mrb_to_flo(mrb, denomv);
- DROP_PRECISION(denomf, numerator, denomf);
- denominator = (mrb_int)denomf;
+ return rational_new_f(mrb, numf/denomf);
}
}
else {
mrb_float numf = mrb_to_flo(mrb, numv);
+ mrb_float denomf;
- if (mrb_fixnum_p(denomv)) {
- denominator = mrb_fixnum(denomv);
+ if (mrb_integer_p(denomv)) {
+ denomf = (mrb_float)mrb_integer(denomv);
}
else {
- mrb_float denomf = mrb_to_flo(mrb, denomv);
-
- DROP_PRECISION(denomf, numf, denomf);
- denominator = (mrb_int)denomf;
+ denomf = mrb_to_flo(mrb, denomv);
}
-
- DROP_PRECISION(numf, numf, denominator);
- numerator = (mrb_int)numf;
+ return rational_new_f(mrb, numf/denomf);
}
#endif
-
return rational_new(mrb, numerator, denominator);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static mrb_value
rational_to_f(mrb_state *mrb, mrb_value self)
{
@@ -154,7 +199,7 @@ rational_to_i(mrb_state *mrb, mrb_value self)
if (p->denominator == 0) {
mrb_raise(mrb, mrb->eStandardError_class, "divided by 0");
}
- return mrb_fixnum_value(p->numerator / p->denominator);
+ return mrb_int_value(mrb, p->numerator / p->denominator);
}
static mrb_value
@@ -176,14 +221,50 @@ rational_negative_p(mrb_state *mrb, mrb_value self)
static mrb_value
fix_to_r(mrb_state *mrb, mrb_value self)
{
- return rational_new(mrb, mrb_fixnum(self), 1);
+ return rational_new(mrb, mrb_integer(self), 1);
+}
+
+static mrb_value
+rational_m_int(mrb_state *mrb, mrb_int n, mrb_int d)
+{
+ mrb_int a, b;
+
+ a = n;
+ b = d;
+ while (b != 0) {
+ mrb_int tmp = b;
+ b = a % b;
+ a = tmp;
+ }
+ return rational_new(mrb, n/a, d/a);
+}
+
+static mrb_value
+rational_m(mrb_state *mrb, mrb_value self)
+{
+#ifdef MRB_NO_FLOAT
+ mrb_int n, d = 1;
+ mrb_get_args(mrb, "i|i", &n, &d);
+ return rational_m_int(mrb, n, d);
+#else
+ mrb_value a, b = mrb_fixnum_value(1);
+ mrb_get_args(mrb, "o|o", &a, &b);
+ if (mrb_integer_p(a) && mrb_integer_p(b)) {
+ return rational_m_int(mrb, mrb_integer(a), mrb_integer(b));
+ }
+ else {
+ mrb_float x = mrb_to_flo(mrb, a);
+ mrb_float y = mrb_to_flo(mrb, b);
+ return rational_new_f(mrb, x/y);
+ }
+#endif
}
void mrb_mruby_rational_gem_init(mrb_state *mrb)
{
struct RClass *rat;
- rat = mrb_define_class(mrb, "Rational", mrb_class_get(mrb, "Numeric"));
+ rat = mrb_define_class_id(mrb, MRB_SYM(Rational), mrb_class_get_id(mrb, MRB_SYM(Numeric)));
#ifdef RATIONAL_USE_ISTRUCT
MRB_SET_INSTANCE_TT(rat, MRB_TT_ISTRUCT);
mrb_assert(sizeof(struct mrb_rational) < ISTRUCT_DATA_SIZE);
@@ -194,13 +275,14 @@ void mrb_mruby_rational_gem_init(mrb_state *mrb)
mrb_define_class_method(mrb, rat, "_new", rational_s_new, MRB_ARGS_REQ(2));
mrb_define_method(mrb, rat, "numerator", rational_numerator, MRB_ARGS_NONE());
mrb_define_method(mrb, rat, "denominator", rational_denominator, MRB_ARGS_NONE());
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
mrb_define_method(mrb, rat, "to_f", rational_to_f, MRB_ARGS_NONE());
#endif
mrb_define_method(mrb, rat, "to_i", rational_to_i, MRB_ARGS_NONE());
mrb_define_method(mrb, rat, "to_r", rational_to_r, MRB_ARGS_NONE());
mrb_define_method(mrb, rat, "negative?", rational_negative_p, MRB_ARGS_NONE());
- mrb_define_method(mrb, mrb->fixnum_class, "to_r", fix_to_r, MRB_ARGS_NONE());
+ mrb_define_method(mrb, mrb->integer_class, "to_r", fix_to_r, MRB_ARGS_NONE());
+ mrb_define_method(mrb, mrb->kernel_module, "Rational", rational_m, MRB_ARGS_ARG(1,1));
}
void
diff --git a/mrbgems/mruby-rational/test/rational.rb b/mrbgems/mruby-rational/test/rational.rb
index a8ebb8ea2e7365c145b9f67992fe73c4253bf512..3fb4e4e8263527ff830d4dcfe82ac2250e327ae8 100644
--- a/mrbgems/mruby-rational/test/rational.rb
+++ b/mrbgems/mruby-rational/test/rational.rb
@@ -143,7 +143,7 @@ assert 'Rational#==, Rational#!=' do
assert_equal_rational(false, 1r, ComplexLikeNumeric.new(2))
end
-assert 'Fixnum#==(Rational), Fixnum#!=(Rational)' do
+assert 'Integer#==(Rational), Integer#!=(Rational)' do
assert_equal_rational(true, 2, Rational(4,2))
assert_equal_rational(true, -2, Rational(-4,2))
assert_equal_rational(true, -2, Rational(4,-2))
@@ -186,7 +186,7 @@ assert 'Rational#<=>' do
assert_raise(NoMethodError) { 1r <=> ComplexLikeNumeric.new(2) }
end
-assert 'Fixnum#<=>(Rational)' do
+assert 'Integer#<=>(Rational)' do
assert_cmp(-1, -2, Rational(-9,5))
assert_cmp(0, 5, 5r)
assert_cmp(1, 3, Rational(8,3))
@@ -210,7 +210,7 @@ assert 'Rational#<' do
assert_raise(ArgumentError) { 1r < "2" }
end
-assert 'Fixnum#<(Rational)' do
+assert 'Integer#<(Rational)' do
assert_not_operator(1, :<, Rational(2,3))
assert_not_operator(2, :<, 2r)
assert_operator(-3, :<, Rational(2,3))
@@ -234,7 +234,7 @@ assert 'Rational#<=' do
assert_raise(ArgumentError) { 1r <= "2" }
end
-assert 'Fixnum#<=(Rational)' do
+assert 'Integer#<=(Rational)' do
assert_not_operator(1, :<=, Rational(2,3))
assert_operator(2, :<=, 2r)
assert_operator(-3, :<=, Rational(2,3))
@@ -258,7 +258,7 @@ assert 'Rational#>' do
assert_raise(ArgumentError) { 1r > "2" }
end
-assert 'Fixnum#>(Rational)' do
+assert 'Integer#>(Rational)' do
assert_operator(1, :>, Rational(2,3))
assert_not_operator(2, :>, 2r)
assert_not_operator(-3, :>, Rational(2,3))
@@ -282,7 +282,7 @@ assert 'Rational#>=' do
assert_raise(ArgumentError) { 1r >= "2" }
end
-assert 'Fixnum#>=(Rational)' do
+assert 'Integer#>=(Rational)' do
assert_operator(1, :>=, Rational(2,3))
assert_operator(2, :>=, 2r)
assert_not_operator(-3, :>=, Rational(2,3))
diff --git a/mrbgems/mruby-sleep/src/mrb_sleep.c b/mrbgems/mruby-sleep/src/mrb_sleep.c
index a653242d15aaf6fe38f15d162d69576fe3f57ca7..7771db56bcd23db452d4c4a9361daadee784e6c3 100644
--- a/mrbgems/mruby-sleep/src/mrb_sleep.c
+++ b/mrbgems/mruby-sleep/src/mrb_sleep.c
@@ -44,7 +44,7 @@ mrb_f_sleep(mrb_state *mrb, mrb_value self)
{
time_t beg = time(0);
time_t end;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
mrb_float sec;
mrb_get_args(mrb, "f", &sec);
diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c
index a819dcb2997220f82bfbbe3a02485f3bfc2f68e9..0afbca521dd7c491bee7173190b2b18b08e4372e 100644
--- a/mrbgems/mruby-socket/src/socket.c
+++ b/mrbgems/mruby-socket/src/socket.c
@@ -53,7 +53,7 @@
#endif
#endif
-#define E_SOCKET_ERROR (mrb_class_get(mrb, "SocketError"))
+#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))
@@ -140,50 +140,50 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass)
if (mrb_string_p(service)) {
servname = RSTRING_CSTR(mrb, service);
- } else if (mrb_fixnum_p(service)) {
+ } else if (mrb_integer_p(service)) {
servname = RSTRING_PTR(mrb_fixnum_to_str(mrb, service, 10));
} else if (mrb_nil_p(service)) {
servname = NULL;
} else {
- mrb_raise(mrb, E_TYPE_ERROR, "service must be String, Fixnum, or nil");
+ mrb_raise(mrb, E_TYPE_ERROR, "service must be String, Integer, or nil");
}
memset(&hints, 0, sizeof(hints));
hints.ai_flags = (int)flags;
- if (mrb_fixnum_p(family)) {
- hints.ai_family = (int)mrb_fixnum(family);
+ if (mrb_integer_p(family)) {
+ hints.ai_family = (int)mrb_integer(family);
}
- if (mrb_fixnum_p(socktype)) {
- hints.ai_socktype = (int)mrb_fixnum(socktype);
+ if (mrb_integer_p(socktype)) {
+ hints.ai_socktype = (int)mrb_integer(socktype);
}
- if (mrb_fixnum_p(protocol)) {
- hints.ai_protocol = (int)mrb_fixnum(protocol);
+ if (mrb_integer_p(protocol)) {
+ hints.ai_protocol = (int)mrb_integer(protocol);
}
- lastai = mrb_cv_get(mrb, klass, mrb_intern_lit(mrb, "_lastai"));
+ lastai = mrb_cv_get(mrb, klass, MRB_SYM(_lastai));
if (mrb_cptr_p(lastai)) {
freeaddrinfo((struct addrinfo*)mrb_cptr(lastai));
- mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
+ mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_nil_value());
}
error = getaddrinfo(hostname, servname, &hints, &res0);
if (error) {
mrb_raisef(mrb, E_SOCKET_ERROR, "getaddrinfo: %s", gai_strerror(error));
}
- mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_cptr_value(mrb, res0));
+ mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_cptr_value(mrb, res0));
for (res = res0; res != NULL; res = res->ai_next) {
sa = mrb_str_new(mrb, (char*)res->ai_addr, res->ai_addrlen);
- ai = mrb_funcall(mrb, klass, "new", 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol));
+ ai = mrb_funcall_id(mrb, klass, MRB_SYM(new), 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol));
mrb_ary_push(mrb, ary, ai);
mrb_gc_arena_restore(mrb, arena_idx);
}
freeaddrinfo(res0);
- mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
+ mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_nil_value());
return ary;
}
@@ -200,7 +200,7 @@ mrb_addrinfo_getnameinfo(mrb_state *mrb, mrb_value self)
host = mrb_str_buf_new(mrb, NI_MAXHOST);
serv = mrb_str_buf_new(mrb, NI_MAXSERV);
- sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr"));
+ sastr = mrb_iv_get(mrb, self, MRB_QSYM(0_sockaddr));
if (!mrb_string_p(sastr)) {
mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr");
}
@@ -222,7 +222,7 @@ mrb_addrinfo_unix_path(mrb_state *mrb, mrb_value self)
{
mrb_value sastr;
- sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr"));
+ sastr = mrb_iv_get(mrb, self, MRB_QSYM(0_sockaddr));
if (((struct sockaddr *)RSTRING_PTR(sastr))->sa_family != AF_UNIX)
mrb_raise(mrb, E_SOCKET_ERROR, "need AF_UNIX address");
if (RSTRING_LEN(sastr) < (mrb_int)offsetof(struct sockaddr_un, sun_path) + 1) {
@@ -269,7 +269,7 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen)
static int
socket_fd(mrb_state *mrb, mrb_value sock)
{
- return (int)mrb_fixnum(mrb_funcall(mrb, sock, "fileno", 0));
+ return (int)mrb_integer(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0));
}
static int
@@ -347,10 +347,10 @@ mrb_basicsocket_getsockopt(mrb_state *mrb, mrb_value self)
optlen = sizeof(opt);
if (getsockopt(s, (int)level, (int)optname, opt, &optlen) == -1)
mrb_sys_fail(mrb, "getsockopt");
- c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Socket")), mrb_intern_lit(mrb, "Option"));
+ c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get_id(mrb, MRB_SYM(Socket))), MRB_SYM(Option));
family = socket_family(s);
data = mrb_str_new(mrb, opt, optlen);
- return mrb_funcall(mrb, c, "new", 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data);
+ return mrb_funcall_id(mrb, c, MRB_SYM(new), 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data);
}
static mrb_value
@@ -449,21 +449,21 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
argc = mrb_get_args(mrb, "o|io", &so, &optname, &optval);
if (argc == 3) {
- if (!mrb_fixnum_p(so)) {
+ if (!mrb_integer_p(so)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "level is not an integer");
}
- level = mrb_fixnum(so);
+ level = mrb_integer(so);
if (mrb_string_p(optval)) {
/* that's good */
} else if (mrb_true_p(optval) || mrb_false_p(optval)) {
mrb_int i = mrb_test(optval) ? 1 : 0;
optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
- } else if (mrb_fixnum_p(optval)) {
+ } else if (mrb_integer_p(optval)) {
if (optname == IP_MULTICAST_TTL || optname == IP_MULTICAST_LOOP) {
- char uc = (char)mrb_fixnum(optval);
+ char uc = (char)mrb_integer(optval);
optval = mrb_str_new(mrb, &uc, sizeof(uc));
} else {
- mrb_int i = mrb_fixnum(optval);
+ mrb_int i = mrb_integer(optval);
optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
}
} else {
@@ -472,9 +472,9 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
} else if (argc == 1) {
if (strcmp(mrb_obj_classname(mrb, so), "Socket::Option") != 0)
mrb_raise(mrb, E_ARGUMENT_ERROR, "not an instance of Socket::Option");
- level = mrb_fixnum(mrb_funcall(mrb, so, "level", 0));
- optname = mrb_fixnum(mrb_funcall(mrb, so, "optname", 0));
- optval = mrb_funcall(mrb, so, "data", 0);
+ level = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(level), 0));
+ optname = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0));
+ optval = mrb_funcall_id(mrb, so, MRB_SYM(data), 0);
} else {
mrb_argnum_error(mrb, argc, 3, 3);
}
@@ -842,7 +842,7 @@ mrb_win32_basicsocket_syswrite(mrb_state *mrb, mrb_value self)
n = send(sd, RSTRING_PTR(str), (int)RSTRING_LEN(str), 0);
if (n == SOCKET_ERROR)
mrb_sys_fail(mrb, "send");
- return mrb_fixnum_value(n);
+ return mrb_int_value(mrb, n);
}
#endif
@@ -862,14 +862,14 @@ mrb_mruby_socket_gem_init(mrb_state* mrb)
#endif
ai = mrb_define_class(mrb, "Addrinfo", mrb->object_class);
- mrb_mod_cv_set(mrb, ai, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
+ mrb_mod_cv_set(mrb, ai, MRB_SYM(_lastai), mrb_nil_value());
mrb_define_class_method(mrb, ai, "getaddrinfo", mrb_addrinfo_getaddrinfo, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(4));
mrb_define_method(mrb, ai, "getnameinfo", mrb_addrinfo_getnameinfo, MRB_ARGS_OPT(1));
#ifndef _WIN32
mrb_define_method(mrb, ai, "unix_path", mrb_addrinfo_unix_path, MRB_ARGS_NONE());
#endif
- io = mrb_class_get(mrb, "IO");
+ io = mrb_class_get_id(mrb, MRB_SYM(IO));
bsock = mrb_define_class(mrb, "BasicSocket", io);
mrb_define_method(mrb, bsock, "_recvfrom", mrb_basicsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
@@ -938,7 +938,7 @@ mrb_mruby_socket_gem_init(mrb_state* mrb)
#define define_const(SYM) \
do { \
- mrb_define_const(mrb, constants, #SYM, mrb_fixnum_value(SYM)); \
+ mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM)); \
} while (0)
#include "const.cstub"
@@ -948,7 +948,7 @@ void
mrb_mruby_socket_gem_final(mrb_state* mrb)
{
mrb_value ai;
- ai = mrb_mod_cv_get(mrb, mrb_class_get(mrb, "Addrinfo"), mrb_intern_lit(mrb, "_lastai"));
+ ai = mrb_mod_cv_get(mrb, mrb_class_get_id(mrb, MRB_SYM(Addrinfo)), MRB_SYM(_lastai));
if (mrb_cptr_p(ai)) {
freeaddrinfo((struct addrinfo*)mrb_cptr(ai));
}
diff --git a/mrbgems/mruby-sprintf/src/kernel.c b/mrbgems/mruby-sprintf/src/kernel.c
deleted file mode 100644
index a0f0a78ba2f97243e36e5683f3e2be5af608f7db..0000000000000000000000000000000000000000
--- a/mrbgems/mruby-sprintf/src/kernel.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
-** kernel.c - Kernel module suppliment
-**
-** See Copyright Notice in mruby.h
-*/
-
-#include <mruby.h>
-
-mrb_value mrb_f_sprintf(mrb_state *mrb, mrb_value obj); /* in sprintf.c */
-
-void
-mrb_mruby_sprintf_gem_init(mrb_state* mrb)
-{
- struct RClass *krn;
-
- if (mrb->kernel_module == NULL) {
- mrb->kernel_module = mrb_define_module(mrb, "Kernel"); /* Might be PARANOID. */
- }
- krn = mrb->kernel_module;
-
- mrb_define_method(mrb, krn, "sprintf", mrb_f_sprintf, MRB_ARGS_REQ(1)|MRB_ARGS_REST());
- mrb_define_method(mrb, krn, "format", mrb_f_sprintf, MRB_ARGS_REQ(1)|MRB_ARGS_REST());
-}
-
-void
-mrb_mruby_sprintf_gem_final(mrb_state* mrb)
-{
- /* nothing to do. */
-}
-
diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c
index bf7a4d72520804d290ad3991abf2320757ada272..3ecf11afb245c5dee14336e5fdf72071fddd6a08 100644
--- a/mrbgems/mruby-sprintf/src/sprintf.c
+++ b/mrbgems/mruby-sprintf/src/sprintf.c
@@ -10,7 +10,7 @@
#include <mruby/string.h>
#include <mruby/hash.h>
#include <mruby/numeric.h>
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#include <math.h>
#endif
#include <ctype.h>
@@ -20,7 +20,7 @@
#define EXTENDSIGN(n, l) (((~0U << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0U << (n)))
mrb_value mrb_str_format(mrb_state *, mrb_int, const mrb_value *, mrb_value);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static void fmt_setup(char*,size_t,int,int,mrb_int,mrb_int);
#endif
@@ -74,7 +74,7 @@ static mrb_value
mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
{
char buf[66], *b = buf + sizeof buf;
- mrb_int num = mrb_fixnum(x);
+ mrb_int num = mrb_integer(x);
uint64_t val = (uint64_t)num;
char d;
@@ -192,20 +192,14 @@ check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len)
#define GETNTHARG(nth) \
((nth >= argc) ? (mrb_raise(mrb, E_ARGUMENT_ERROR, "too few arguments"), mrb_undef_value()) : argv[nth])
-#define GETNAMEARG(id, name, len) (\
+#define CHECKNAMEARG(name, len) (\
check_name_arg(mrb, posarg, name, len),\
- (posarg = -2, mrb_hash_fetch(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value())))
-
-#define GETNUM(n, val) \
- for (; p < end && ISDIGIT(*p); p++) {\
- if (n > (MRB_INT_MAX - (*p - '0'))/10) {\
- mrb_raise(mrb, E_ARGUMENT_ERROR, #val " too big"); \
- } \
- n = 10 * n + (*p - '0'); \
- } \
- if (p >= end) { \
- mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %*[0-9]"); \
- }
+ posarg = -2)
+
+#define GETNUM(n, val) do { \
+ if (!(p = get_num(mrb, p, end, &(n)))) \
+ mrb_raise(mrb, E_ARGUMENT_ERROR, #val " too big 1"); \
+} while(0)
#define GETASTER(num) do { \
mrb_value tmp_v; \
@@ -222,12 +216,32 @@ check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len)
num = mrb_int(mrb, tmp_v); \
} while (0)
-static mrb_value
+static const char *
+get_num(mrb_state *mrb, const char *p, const char *end, mrb_int *valp)
+{
+ mrb_int next_n = *valp;
+ for (; p < end && ISDIGIT(*p); p++) {
+ if (mrb_int_mul_overflow(10, next_n, &next_n)) {
+ return NULL;
+ }
+ if (MRB_INT_MAX - (*p - '0') < next_n) {
+ return NULL;
+ }
+ next_n += *p - '0';
+ }
+ if (p >= end) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %%*[0-9]");
+ }
+ *valp = next_n;
+ return p;
+}
+
+static void
get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
{
mrb_value tmp;
- if (!mrb_undef_p(*hash)) return *hash;
+ if (!mrb_undef_p(*hash)) return;
if (argc != 2) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
}
@@ -235,7 +249,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
if (mrb_nil_p(tmp)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
}
- return (*hash = tmp);
+ *hash = tmp;
}
/*
@@ -499,7 +513,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
* # => "1f"
*/
-mrb_value
+static mrb_value
mrb_f_sprintf(mrb_state *mrb, mrb_value obj)
{
mrb_int argc;
@@ -577,19 +591,19 @@ mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fm
mrb_value str;
mrb_value hash = mrb_undef_value();
-#define CHECK_FOR_WIDTH(f) \
- if ((f) & FWIDTH) { \
- mrb_raise(mrb, E_ARGUMENT_ERROR, "width given twice"); \
- } \
- if ((f) & FPREC0) { \
- mrb_raise(mrb, E_ARGUMENT_ERROR, "width after precision"); \
+#define CHECK_FOR_WIDTH(f) \
+ if ((f) & FWIDTH) { \
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "width given twice"); \
+ } \
+ if ((f) & FPREC0) { \
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "width after precision"); \
}
-#define CHECK_FOR_FLAGS(f) \
- if ((f) & FWIDTH) { \
- mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after width"); \
- } \
- if ((f) & FPREC0) { \
- mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after precision"); \
+#define CHECK_FOR_FLAGS(f) \
+ if ((f) & FWIDTH) { \
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after width"); \
+ } \
+ if ((f) & FPREC0) { \
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after precision"); \
}
++argc;
@@ -676,7 +690,6 @@ retry:
case '{': {
const char *start = p;
char term = (*p == '<') ? '>' : '}';
- mrb_value symname;
for (; p < end && *p != term; )
p++;
@@ -684,10 +697,13 @@ retry:
mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%l after <%n>",
start, p - start + 1, id);
}
- symname = mrb_str_new(mrb, start + 1, p - start - 1);
- id = mrb_intern_str(mrb, symname);
- nextvalue = GETNAMEARG(mrb_symbol_value(id), start, p - start + 1);
- if (mrb_undef_p(nextvalue)) {
+ CHECKNAMEARG(start, p - start + 1);
+ get_hash(mrb, &hash, argc, argv);
+ id = mrb_intern_check(mrb, start + 1, p - start - 1);
+ if (id) {
+ nextvalue = mrb_hash_fetch(mrb, hash, mrb_symbol_value(id), mrb_undef_value());
+ }
+ if (!id || mrb_undef_p(nextvalue)) {
mrb_raisef(mrb, E_KEY_ERROR, "key%l not found", start, p - start + 1);
}
if (term == '}') goto format_s;
@@ -748,8 +764,8 @@ retry:
mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character");
}
}
- else if (mrb_fixnum_p(val)) {
- mrb_int n = mrb_fixnum(val);
+ else if (mrb_integer_p(val)) {
+ mrb_int n = mrb_integer(val);
#ifndef MRB_UTF8_STRING
char buf[1];
@@ -763,7 +779,7 @@ retry:
tmp = mrb_str_new(mrb, buf, 1);
}
else {
- tmp = mrb_funcall(mrb, val, "chr", 0);
+ tmp = mrb_funcall_id(mrb, val, MRB_SYM(chr), 0);
mrb_check_type(mrb, tmp, MRB_TT_STRING);
}
#endif
@@ -863,17 +879,17 @@ retry:
bin_retry:
switch (mrb_type(val)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
val = mrb_flo_to_fixnum(mrb, val);
- if (mrb_fixnum_p(val)) goto bin_retry;
+ if (mrb_integer_p(val)) goto bin_retry;
break;
#endif
case MRB_TT_STRING:
val = mrb_str_to_inum(mrb, val, 0, TRUE);
goto bin_retry;
- case MRB_TT_FIXNUM:
- v = mrb_fixnum(val);
+ case MRB_TT_INTEGER:
+ v = mrb_integer(val);
break;
default:
val = mrb_Integer(mrb, val);
@@ -922,10 +938,10 @@ retry:
s = nbuf;
if (v < 0) {
dots = 1;
- val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
+ val = mrb_fix2binstr(mrb, mrb_int_value(mrb, v), base);
}
else {
- val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
+ val = mrb_fixnum_to_str(mrb, mrb_int_value(mrb, v), base);
}
strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-2);
if (v < 0) {
@@ -1030,7 +1046,7 @@ retry:
}
break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case 'f':
case 'g':
case 'G':
@@ -1131,7 +1147,7 @@ retry:
return result;
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static void
fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec)
{
@@ -1160,3 +1176,16 @@ fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec)
*buf = '\0';
}
#endif
+
+void
+mrb_mruby_sprintf_gem_init(mrb_state *mrb)
+{
+ struct RClass *krn = mrb->kernel_module;
+ mrb_define_module_function(mrb, krn, "sprintf", mrb_f_sprintf, MRB_ARGS_ANY());
+ mrb_define_module_function(mrb, krn, "format", mrb_f_sprintf, MRB_ARGS_ANY());
+}
+
+void
+mrb_mruby_sprintf_gem_final(mrb_state *mrb)
+{
+}
diff --git a/mrbgems/mruby-sprintf/test/sprintf.rb b/mrbgems/mruby-sprintf/test/sprintf.rb
index 0eb51f557a5826db1aeb0704193eca75819b63ea..8f99f9cd0e95ee593912f845d35630003d5ef852 100644
--- a/mrbgems/mruby-sprintf/test/sprintf.rb
+++ b/mrbgems/mruby-sprintf/test/sprintf.rb
@@ -1,5 +1,7 @@
-#assert('Kernel.sprintf') do
-#end
+assert('sprintf invalid') do
+ assert_raise(ArgumentError) { sprintf('%1$*d', 3) }
+ assert_raise(ArgumentError) { sprintf('%1$.*d', 3) }
+end
assert('String#%') do
assert_equal "one=1", "one=%d" % 1
diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c
index ded34a89ef21b657154502631a9a826370b313f9..4b8f99597ee3c217766ca5d5c33db870e0b8c9a3 100644
--- a/mrbgems/mruby-string-ext/src/string.c
+++ b/mrbgems/mruby-string-ext/src/string.c
@@ -12,7 +12,7 @@
#define ENC_COMP_P(enc, enc_lit) \
str_casecmp_p(RSTRING_PTR(enc), RSTRING_LEN(enc), enc_lit, sizeof(enc_lit"")-1)
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
# define mrb_float_p(o) FALSE
#endif
@@ -166,7 +166,7 @@ mrb_str_concat_m(mrb_state *mrb, mrb_value self)
{
mrb_value str = mrb_get_arg1(mrb);
- if (mrb_fixnum_p(str) || mrb_float_p(str))
+ if (mrb_integer_p(str) || mrb_float_p(str))
#ifdef MRB_UTF8_STRING
str = int_chr_utf8(mrb, str);
#else
@@ -1231,7 +1231,7 @@ mrb_mruby_string_ext_gem_init(mrb_state* mrb)
mrb_define_method(mrb, s, "__lines", mrb_str_lines, MRB_ARGS_NONE());
- mrb_define_method(mrb, mrb_module_get(mrb, "Integral"), "chr", mrb_int_chr, MRB_ARGS_OPT(1));
+ mrb_define_method(mrb, mrb_class_get(mrb, "Integer"), "chr", mrb_int_chr, MRB_ARGS_OPT(1));
}
void
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index 7fbf9225f3929b47bd712d66c130635619b3d730..7c6f500904f525d95e58c81b5a1bbfa4f68b3593 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -20,7 +20,7 @@
static struct RClass *
struct_class(mrb_state *mrb)
{
- return mrb_class_get(mrb, "Struct");
+ return mrb_class_get_id(mrb, MRB_SYM(Struct));
}
static inline mrb_value
@@ -42,7 +42,7 @@ struct_ivar_get(mrb_state *mrb, mrb_value cls, mrb_sym id)
static mrb_value
struct_s_members(mrb_state *mrb, struct RClass *klass)
{
- mrb_value members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern_lit(mrb, "__members__"));
+ mrb_value members = struct_ivar_get(mrb, mrb_obj_value(klass), MRB_SYM(__members__));
if (mrb_nil_p(members)) {
mrb_raise(mrb, E_TYPE_ERROR, "uninitialized struct");
@@ -113,7 +113,7 @@ mrb_struct_members(mrb_state *mrb, mrb_value obj)
static mrb_value
mrb_struct_ref(mrb_state *mrb, mrb_value obj)
{
- mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+ mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0));
mrb_value *ptr = RSTRUCT_PTR(obj);
if (!ptr) return mrb_nil_value();
@@ -152,7 +152,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id)
static mrb_value
mrb_struct_set_m(mrb_state *mrb, mrb_value obj)
{
- mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+ mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0));
mrb_value *ptr;
mrb_value val = mrb_get_arg1(mrb);
@@ -214,7 +214,7 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass *kl
}
MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY);
nstr = mrb_obj_value(c);
- mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members);
+ mrb_iv_set(mrb, nstr, MRB_SYM(__members__), members);
mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY());
@@ -310,7 +310,7 @@ num_members(mrb_state *mrb, struct RClass *klass)
{
mrb_value members;
- members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern_lit(mrb, "__members__"));
+ members = struct_ivar_get(mrb, mrb_obj_value(klass), MRB_SYM(__members__));
if (!mrb_array_p(members)) {
mrb_raise(mrb, E_TYPE_ERROR, "broken members");
}
@@ -428,12 +428,8 @@ mrb_struct_aref(mrb_state *mrb, mrb_value s)
mrb_value idx = mrb_get_arg1(mrb);
if (mrb_string_p(idx)) {
- mrb_value sym = mrb_check_intern_str(mrb, idx);
-
- if (mrb_nil_p(sym)) {
- mrb_name_error(mrb, mrb_intern_str(mrb, idx), "no member '%v' in struct", idx);
- }
- idx = sym;
+ mrb_sym sym = mrb_intern_str(mrb, idx);
+ idx = mrb_symbol_value(sym);
}
if (mrb_symbol_p(idx)) {
return struct_aref_sym(mrb, s, mrb_symbol(idx));
@@ -495,12 +491,8 @@ mrb_struct_aset(mrb_state *mrb, mrb_value s)
mrb_get_args(mrb, "oo", &idx, &val);
if (mrb_string_p(idx)) {
- mrb_value sym = mrb_check_intern_str(mrb, idx);
-
- if (mrb_nil_p(sym)) {
- mrb_name_error(mrb, mrb_intern_str(mrb, idx), "no member '%v' in struct", idx);
- }
- idx = sym;
+ mrb_sym sym = mrb_intern_str(mrb, idx);
+ idx = mrb_symbol_value(sym);
}
if (mrb_symbol_p(idx)) {
return mrb_struct_aset_sym(mrb, s, mrb_symbol(idx), val);
@@ -604,8 +596,8 @@ mrb_struct_eql(mrb_state *mrb, mrb_value s)
/*
* call-seq:
- * struct.length -> Fixnum
- * struct.size -> Fixnum
+ * struct.length -> Integer
+ * struct.size -> Integer
*
* Returns number of struct members.
*/
diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c
index a5f72392722cbdd5a71c7e24b5461d664281b0de..f780e7e57ff31735321db04c255841d791af8d8b 100644
--- a/mrbgems/mruby-test/driver.c
+++ b/mrbgems/mruby-test/driver.c
@@ -224,8 +224,8 @@ mrb_init_test_driver(mrb_state *mrb, mrb_bool verbose)
mrb_define_const(mrb, mrbtest, "FIXNUM_MIN", mrb_fixnum_value(MRB_INT_MIN));
mrb_define_const(mrb, mrbtest, "FIXNUM_BIT", mrb_fixnum_value(MRB_INT_BIT));
-#ifndef MRB_WITHOUT_FLOAT
-#ifdef MRB_USE_FLOAT
+#ifndef MRB_NO_FLOAT
+#ifdef MRB_USE_FLOAT32
mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-6));
#else
mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-12));
@@ -252,9 +252,9 @@ mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src)
#define TEST_COUNT_PASS(name) \
do { \
res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$" #name)); \
- if (mrb_fixnum_p(res_src)) { \
+ if (mrb_integer_p(res_src)) { \
mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name)); \
- mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_fixnum(res_dst) + mrb_fixnum(res_src))); \
+ mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_int_value(mrb_dst, mrb_integer(res_dst) + mrb_integer(res_src))); \
} \
} while (FALSE) \
diff --git a/mrbgems/mruby-test/mrbgem.rake b/mrbgems/mruby-test/mrbgem.rake
index ced252ae6a8639249cd8f2c76903c90602f0fa51..0df683f7f489aab32c65448c6982e753dc1c30c5 100644
--- a/mrbgems/mruby-test/mrbgem.rake
+++ b/mrbgems/mruby-test/mrbgem.rake
@@ -28,7 +28,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
file assert_c => [assert_rb, build.mrbcfile] do |t|
mkdir_p File.dirname(t.name)
open(t.name, 'w') do |f|
- mrbc.run f, assert_rb, 'mrbtest_assert_irep'
+ mrbc.run f, assert_rb, 'mrbtest_assert_irep', false
end
end
@@ -58,10 +58,10 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
if test_preload.nil?
f.puts %Q[extern const uint8_t mrbtest_assert_irep[];]
else
- g.build.mrbc.run f, test_preload, "gem_test_irep_#{g.funcname}_preload"
+ g.build.mrbc.run f, test_preload, "gem_test_irep_#{g.funcname}_preload", false
end
g.test_rbfiles.flatten.each_with_index do |rbfile, i|
- g.build.mrbc.run f, rbfile, "gem_test_irep_#{g.funcname}_#{i}"
+ g.build.mrbc.run f, rbfile, "gem_test_irep_#{g.funcname}_#{i}", false
end
f.puts %Q[void mrb_#{g.funcname}_gem_test(mrb_state *mrb);] unless g.test_objs.empty?
dep_list.each do |d|
diff --git a/mrbgems/mruby-test/vformat.c b/mrbgems/mruby-test/vformat.c
index e7ada02da125603373753e34399faaf84085713a..d73e52311e66e58bceca558df963f6391cb8d4e6 100644
--- a/mrbgems/mruby-test/vformat.c
+++ b/mrbgems/mruby-test/vformat.c
@@ -48,7 +48,7 @@ vf_s_format_d(mrb_state *mrb, mrb_value klass)
return mrb_format(mrb, fmt, d);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/* f float */
static mrb_value
vf_s_format_f(mrb_state *mrb, mrb_value klass)
@@ -167,7 +167,7 @@ mrb_init_test_vformat(mrb_state *mrb)
VF_DEFINE_FORMAT_METHOD(c);
VF_DEFINE_FORMAT_METHOD(d);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
VF_DEFINE_FORMAT_METHOD(f);
#endif
VF_DEFINE_FORMAT_METHOD(i);
diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c
index 5fa700848e1273129cec5675a6a2a295c414a254..6fde1b2d1e659d6fb73fc78c1251139a791d7ca6 100644
--- a/mrbgems/mruby-time/src/time.c
+++ b/mrbgems/mruby-time/src/time.c
@@ -4,7 +4,7 @@
** See Copyright Notice in mruby.h
*/
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#include <math.h>
#endif
@@ -30,7 +30,7 @@ double round(double x) {
}
#endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
# if !defined(__MINGW64__) && defined(_WIN32)
# define llround(x) round(x)
# endif
@@ -199,13 +199,13 @@ struct mrb_time {
static const struct mrb_data_type mrb_time_type = { "Time", mrb_free };
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
void mrb_check_num_exact(mrb_state *mrb, mrb_float num);
typedef mrb_float mrb_sec;
#define mrb_sec_value(mrb, sec) mrb_float_value(mrb, sec)
#else
typedef mrb_int mrb_sec;
-#define mrb_sec_value(mrb, sec) mrb_fixnum_value(sec)
+#define mrb_sec_value(mrb, sec) mrb_int_value(mrb, sec)
#endif
#define MRB_TIME_T_UINT (~(time_t)0 > 0)
@@ -218,11 +218,15 @@ typedef mrb_int mrb_sec;
(sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX) \
)
+/* return true if time_t is fit in mrb_int */
static mrb_bool
fixable_time_t_p(time_t v)
{
if (MRB_INT_MIN <= MRB_TIME_MIN && MRB_TIME_MAX <= MRB_INT_MAX) return TRUE;
- return FIXABLE(v);
+ if (v > (time_t)MRB_INT_MAX) return FALSE;
+ if (MRB_TIME_T_UINT) return TRUE;
+ if (MRB_INT_MIN > (mrb_int)v) return FALSE;
+ return TRUE;
}
static time_t
@@ -231,7 +235,7 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec)
time_t t;
switch (mrb_type(obj)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
{
mrb_float f = mrb_float(obj);
@@ -250,14 +254,14 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec)
}
}
break;
-#endif /* MRB_WITHOUT_FLOAT */
+#endif /* MRB_NO_FLOAT */
default:
- case MRB_TT_FIXNUM:
+ case MRB_TT_INTEGER:
{
- mrb_int i = mrb_int(mrb, obj);
+ mrb_int i = mrb_integer(obj);
- if ((MRB_INT_MAX > MRB_TIME_MAX && i > 0 && i > (mrb_int)MRB_TIME_MAX) ||
- (MRB_TIME_MIN > MRB_INT_MIN && MRB_TIME_MIN > i)) {
+ if ((MRB_INT_MAX > MRB_TIME_MAX && i > 0 && (time_t)i > MRB_TIME_MAX) ||
+ (0 > MRB_TIME_MIN && MRB_TIME_MIN > MRB_INT_MIN && MRB_TIME_MIN > i)) {
goto out_of_range;
}
@@ -420,7 +424,7 @@ mrb_time_now(mrb_state *mrb, mrb_value self)
MRB_API mrb_value
mrb_time_at(mrb_state *mrb, time_t sec, time_t usec, enum mrb_timezone zone)
{
- return mrb_time_make_time(mrb, mrb_class_get(mrb, "Time"), sec, usec, zone);
+ return mrb_time_make_time(mrb, mrb_class_get_id(mrb, MRB_SYM(Time)), sec, usec, zone);
}
/* 15.2.19.6.1 */
@@ -572,7 +576,7 @@ mrb_time_minus(mrb_state *mrb, mrb_value self)
tm = time_get_ptr(mrb, self);
tm2 = DATA_CHECK_GET_PTR(mrb, other, &mrb_time_type, struct mrb_time);
if (tm2) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
mrb_float f;
f = (mrb_sec)(tm->sec - tm2->sec)
+ (mrb_sec)(tm->usec - tm2->usec) / 1.0e6;
@@ -581,7 +585,7 @@ mrb_time_minus(mrb_state *mrb, mrb_value self)
mrb_int f;
f = tm->sec - tm2->sec;
if (tm->usec < tm2->usec) f--;
- return mrb_fixnum_value(f);
+ return mrb_int_value(mrb, f);
#endif
}
else {
@@ -843,7 +847,7 @@ mrb_time_sec(mrb_state *mrb, mrb_value self)
return mrb_fixnum_value(tm->datetime.tm_sec);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/* 15.2.19.7.24 */
/* Returns a Float with the time since the epoch in seconds. */
static mrb_value
@@ -864,12 +868,12 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self)
struct mrb_time *tm;
tm = time_get_ptr(mrb, self);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
if (!fixable_time_t_p(tm->sec)) {
return mrb_float_value(mrb, (mrb_float)tm->sec);
}
#endif
- return mrb_fixnum_value((mrb_int)tm->sec);
+ return mrb_int_value(mrb, (mrb_int)tm->sec);
}
/* 15.2.19.7.26 */
@@ -880,11 +884,6 @@ mrb_time_usec(mrb_state *mrb, mrb_value self)
struct mrb_time *tm;
tm = time_get_ptr(mrb, self);
-#ifndef MRB_WITHOUT_FLOAT
- if (!fixable_time_t_p(tm->usec)) {
- return mrb_float_value(mrb, (mrb_float)tm->usec);
- }
-#endif
return mrb_fixnum_value((mrb_int)tm->usec);
}
@@ -995,7 +994,7 @@ mrb_mruby_time_gem_init(mrb_state* mrb)
mrb_define_method(mrb, tc, "sec" , mrb_time_sec, MRB_ARGS_NONE()); /* 15.2.19.7.23 */
mrb_define_method(mrb, tc, "to_i", mrb_time_to_i, MRB_ARGS_NONE()); /* 15.2.19.7.25 */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
mrb_define_method(mrb, tc, "to_f", mrb_time_to_f, MRB_ARGS_NONE()); /* 15.2.19.7.24 */
#endif
mrb_define_method(mrb, tc, "usec", mrb_time_usec, MRB_ARGS_NONE()); /* 15.2.19.7.26 */
diff --git a/mrblib/10error.rb b/mrblib/10error.rb
index 0d9f38d58ac3a630dd25ed52145e427a41e37131..054603514c94845ddf953df3a8579ca96fbcbb93 100644
--- a/mrblib/10error.rb
+++ b/mrblib/10error.rb
@@ -21,6 +21,10 @@ end
class TypeError < StandardError
end
+# ISO 15.2.30
+class ZeroDivisionError < StandardError
+end
+
# ISO 15.2.31
class NameError < StandardError
attr_accessor :name
diff --git a/mrblib/init_mrblib.c b/mrblib/init_mrblib.c
index 4d4bcd25a872ba68603772a62efadb366ddc7ca9..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
--- a/mrblib/init_mrblib.c
+++ b/mrblib/init_mrblib.c
@@ -1,11 +0,0 @@
-#include <mruby.h>
-#include <mruby/irep.h>
-
-extern const uint8_t mrblib_irep[];
-
-void
-mrb_init_mrblib(mrb_state *mrb)
-{
- mrb_load_irep(mrb, mrblib_irep);
-}
-
diff --git a/mrblib/mrblib.rake b/mrblib/mrblib.rake
index 6fba0adc1e88b552f2e71389fea051130dfd8730..724d328fac87b931b3a1d25d1d36ad6f566b75bc 100644
--- a/mrblib/mrblib.rake
+++ b/mrblib/mrblib.rake
@@ -11,8 +11,21 @@ MRuby.each_target do
mkdir_p File.dirname(t.name)
open(t.name, 'w') do |f|
_pp "GEN", "*.rb", "#{t.name.relative_path}"
- f.puts File.read("#{current_dir}/init_mrblib.c")
- mrbc.run f, rbfiles, 'mrblib_irep'
+ f.puts %Q[/*]
+ f.puts %Q[ * This file is loading the mrblib]
+ f.puts %Q[ *]
+ f.puts %Q[ * IMPORTANT:]
+ f.puts %Q[ * This file was generated!]
+ f.puts %Q[ * All manual changes will get lost.]
+ f.puts %Q[ */]
+ mrbc.run f, rbfiles, 'mrblib_proc'
+ f.puts <<INIT_END
+void
+mrb_init_mrblib(mrb_state *mrb)
+{
+ mrb_load_proc(mrb, mrblib_proc);
+}
+INIT_END
end
end
end
diff --git a/mrblib/numeric.rb b/mrblib/numeric.rb
index 5926518d556ee47167348ae20f6a10a1bd59d14c..e28d63324a6a463cbb4235091c1b56e9460c73af 100644
--- a/mrblib/numeric.rb
+++ b/mrblib/numeric.rb
@@ -34,11 +34,11 @@ class Numeric
end
##
-# Integral
+# Integer
#
-# mruby special - module to share methods between Floats and Integers
-# to make them compatible
-module Integral
+# ISO 15.2.8
+##
+class Integer
##
# Calls the given block once for each Integer
# from +self+ downto +num+.
@@ -125,14 +125,7 @@ module Integral
end
self
end
-end
-##
-# Integer
-#
-# ISO 15.2.8
-class Integer
- include Integral
##
# Returns the receiver simply.
#
@@ -161,3 +154,35 @@ class Integer
# ISO 15.2.8.3.26
alias truncate floor
end
+
+class Float
+ ##
+ # Calls the given block from +self+ to +num+
+ # incremented by +step+ (default 1).
+ #
+ def step(num=nil, step=1, &block)
+ raise ArgumentError, "step can't be 0" if step == 0
+ return to_enum(:step, num, step) unless block
+
+ i = self
+ if num == self || step.infinite?
+ block.call(i) if step > 0 && i <= (num||i) || step < 0 && i >= (num||-i)
+ elsif num == nil
+ while true
+ block.call(i)
+ i += step
+ end
+ elsif step > 0
+ while i <= num
+ block.call(i)
+ i += step
+ end
+ else
+ while i >= num
+ block.call(i)
+ i += step
+ end
+ end
+ self
+ end
+end
diff --git a/mrblib/range.rb b/mrblib/range.rb
index 392cc22741e37fa9394f9f88c51520612391d184..9f94f35d10fb624e26edcce6cc99bccbe43422dc 100644
--- a/mrblib/range.rb
+++ b/mrblib/range.rb
@@ -15,7 +15,7 @@ class Range
val = self.first
last = self.last
- if val.kind_of?(Fixnum) && last.kind_of?(Fixnum) # fixnums are special
+ if val.kind_of?(Integer) && last.kind_of?(Integer) # fixnums are special
lim = last
lim += 1 unless exclude_end?
i = val
diff --git a/src/array.c b/src/array.c
index c33641264496337dfca2a46dac0076a41076e5bf..c4bc554efb1fc44afc1e1176e3543278254a8fc4 100644
--- a/src/array.c
+++ b/src/array.c
@@ -508,21 +508,23 @@ mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem)
static mrb_value
mrb_ary_push_m(mrb_state *mrb, mrb_value self)
{
+ mrb_int argc;
mrb_value *argv;
- mrb_int len, len2, alen;
+ mrb_int len, len2;
struct RArray *a;
- mrb_get_args(mrb, "*!", &argv, &alen);
+ argc = mrb_get_argc(mrb);
+ argv = mrb_get_argv(mrb);
a = mrb_ary_ptr(self);
ary_modify(mrb, a);
len = ARY_LEN(a);
- len2 = len + alen;
+ len2 = len + argc;
if (ARY_CAPA(a) < len2) {
ary_expand_capa(mrb, a, len2);
}
- array_copy(ARY_PTR(a)+len, argv, alen);
+ array_copy(ARY_PTR(a)+len, argv, argc);
ARY_SET_LEN(a, len2);
- while (alen--) {
+ while (argc--) {
mrb_field_write_barrier_value(mrb, (struct RBasic*)a, *argv);
argv++;
}
@@ -820,10 +822,10 @@ mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len)
static mrb_int
aget_index(mrb_state *mrb, mrb_value index)
{
- if (mrb_fixnum_p(index)) {
- return mrb_fixnum(index);
+ if (mrb_integer_p(index)) {
+ return mrb_integer(index);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
else if (mrb_float_p(index)) {
return (mrb_int)mrb_float(index);
}
@@ -883,8 +885,8 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self)
else {
return mrb_nil_value();
}
- case MRB_TT_FIXNUM:
- return mrb_ary_ref(mrb, self, mrb_fixnum(index));
+ case MRB_TT_INTEGER:
+ return mrb_ary_ref(mrb, self, mrb_integer(index));
default:
return mrb_ary_ref(mrb, self, aget_index(mrb, index));
}
@@ -1086,11 +1088,11 @@ mrb_ary_splat(mrb_state *mrb, mrb_value v)
return mrb_obj_value(a);
}
- if (!mrb_respond_to(mrb, v, mrb_intern_lit(mrb, "to_a"))) {
+ if (!mrb_respond_to(mrb, v, MRB_SYM(to_a))) {
return mrb_ary_new_from_values(mrb, 1, &v);
}
- ary = mrb_funcall(mrb, v, "to_a", 0);
+ ary = mrb_funcall_id(mrb, v, MRB_SYM(to_a), 0);
if (mrb_nil_p(ary)) {
return mrb_ary_new_from_values(mrb, 1, &v);
}
@@ -1121,8 +1123,14 @@ mrb_ary_clear(mrb_state *mrb, mrb_value self)
else if (!ARY_EMBED_P(a)){
mrb_free(mrb, a->as.heap.ptr);
}
- ARY_SET_EMBED_LEN(a, 0);
-
+ if (MRB_ARY_EMBED_LEN_MAX > 0) {
+ ARY_SET_EMBED_LEN(a, 0);
+ }
+ else {
+ a->as.heap.ptr = NULL;
+ a->as.heap.aux.capa = 0;
+ ARY_SET_LEN(a, 0);
+ }
return self;
}
@@ -1302,31 +1310,42 @@ static const mrb_code each_iseq[] = {
OP_RETURN, 0x0 /* OP_RETURN R3 */
};
+static const mrb_sym each_syms[] = {
+ MRB_SYM(each),
+ MRB_SYM(to_enum),
+ MRB_QSYM(aref),
+ MRB_SYM(call),
+ MRB_SYM(length),
+};
+
+static const mrb_irep each_irep = {
+ 3, /* nlocals */
+ 7, /* nregs */
+ 0, /* clen */
+ MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE, /* flags */
+ each_iseq, /* iseq */
+ NULL, /* pool */
+ each_syms, /* syms */
+ NULL, /* reps */
+ NULL, /* lv */
+ NULL, /* debug_info */
+ sizeof(each_iseq), /* ilen */
+ 0, /* plen */
+ sizeof(each_syms), /* slen */
+ 1, /* rlen */
+ 0, /* refcnt */
+};
+
static void
init_ary_each(mrb_state *mrb, struct RClass *ary)
{
struct RProc *p;
mrb_method_t m;
- mrb_irep *each_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep));
- static const mrb_irep mrb_irep_zero = { 0 };
-
- *each_irep = mrb_irep_zero;
- each_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*5);
- each_irep->syms[0] = mrb_intern_lit(mrb, "each");
- each_irep->syms[1] = mrb_intern_lit(mrb, "to_enum");
- each_irep->syms[2] = mrb_intern_lit(mrb, "[]");
- each_irep->syms[3] = mrb_intern_lit(mrb, "call");
- each_irep->syms[4] = mrb_intern_lit(mrb, "length");
- each_irep->slen = 5;
- each_irep->flags = MRB_ISEQ_NO_FREE;
- each_irep->iseq = each_iseq;
- each_irep->ilen = sizeof(each_iseq);
- each_irep->nregs = 7;
- each_irep->nlocals = 3;
- p = mrb_proc_new(mrb, each_irep);
+
+ p = mrb_proc_new(mrb, &each_irep);
p->flags |= MRB_PROC_SCOPE | MRB_PROC_STRICT;
MRB_METHOD_FROM_PROC(m, p);
- mrb_define_method_raw(mrb, ary, mrb_intern_lit(mrb, "each"), m);
+ mrb_define_method_raw(mrb, ary, MRB_SYM(each), m);
}
void
diff --git a/src/backtrace.c b/src/backtrace.c
index 591f4ea4be6d40c6f241fb4eb5baef573f736aca..bcc188796f1f0fda03c51b1700eaa900cd600e8f 100644
--- a/src/backtrace.c
+++ b/src/backtrace.c
@@ -39,7 +39,7 @@ each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, const mrb_code *pc0, each_backtr
for (i=ciidx; i >= 0; i--) {
struct backtrace_location loc;
mrb_callinfo *ci;
- mrb_irep *irep;
+ const mrb_irep *irep;
const mrb_code *pc;
ci = &mrb->c->cibase[i];
@@ -114,7 +114,7 @@ mrb_print_backtrace(mrb_state *mrb)
return;
}
- backtrace = mrb_obj_iv_get(mrb, mrb->exc, mrb_intern_lit(mrb, "backtrace"));
+ 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);
@@ -171,7 +171,7 @@ packed_backtrace(mrb_state *mrb)
void
mrb_keep_backtrace(mrb_state *mrb, mrb_value exc)
{
- mrb_sym sym = mrb_intern_lit(mrb, "backtrace");
+ mrb_sym sym = MRB_SYM(backtrace);
mrb_value backtrace;
int ai;
@@ -221,7 +221,7 @@ mrb_exc_backtrace(mrb_state *mrb, mrb_value exc)
mrb_sym attr_name;
mrb_value backtrace;
- attr_name = mrb_intern_lit(mrb, "backtrace");
+ attr_name = MRB_SYM(backtrace);
backtrace = mrb_iv_get(mrb, exc, attr_name);
if (mrb_nil_p(backtrace) || mrb_array_p(backtrace)) {
return backtrace;
diff --git a/src/class.c b/src/class.c
index fcbdadea89ceccc756b13123889dee4b1f70dbc9..bbf64e8eafff294c993e231bf27fd80824ed76d3 100644
--- a/src/class.c
+++ b/src/class.c
@@ -18,47 +18,266 @@
#include <mruby/istruct.h>
#include <mruby/opcode.h>
-KHASH_DEFINE(mt, mrb_sym, mrb_method_t, TRUE, kh_int_hash_func, kh_int_hash_equal)
+union mt_ptr {
+ struct RProc *proc;
+ mrb_func_t func;
+};
+
+struct mt_elem {
+ union mt_ptr ptr;
+ size_t func_p:1;
+ mrb_sym key:sizeof(mrb_sym)*8-1;
+};
+
+/* method table structure */
+typedef struct mt_tbl {
+ size_t size;
+ size_t alloc;
+ struct mt_elem *table;
+} mt_tbl;
+
+/* Creates the method table. */
+static mt_tbl*
+mt_new(mrb_state *mrb)
+{
+ mt_tbl *t;
+
+ t = (mt_tbl*)mrb_malloc(mrb, sizeof(mt_tbl));
+ t->size = 0;
+ t->alloc = 0;
+ t->table = NULL;
+
+ return t;
+}
+
+static struct mt_elem *mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, size_t func_p, union mt_ptr ptr);
+
+static void
+mt_rehash(mrb_state *mrb, mt_tbl *t)
+{
+ size_t old_alloc = t->alloc;
+ size_t new_alloc = old_alloc+1;
+ struct mt_elem *old_table = t->table;
+
+ khash_power2(new_alloc);
+ if (old_alloc == new_alloc) return;
+
+ t->alloc = new_alloc;
+ t->size = 0;
+ t->table = (struct mt_elem*)mrb_calloc(mrb, sizeof(struct mt_elem), new_alloc);
+
+ for (size_t i = 0; i < old_alloc; i++) {
+ struct mt_elem *slot = &old_table[i];
+
+ /* key = 0 means empty or deleted */
+ if (slot->key != 0) {
+ mt_put(mrb, t, slot->key, slot->func_p, slot->ptr);
+ }
+ }
+ mrb_free(mrb, old_table);
+}
+
+#define slot_empty_p(slot) ((slot)->key == 0 && (slot)->func_p == 0)
+
+/* Set the value for the symbol in the method table. */
+static struct mt_elem*
+mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, size_t func_p, union mt_ptr ptr)
+{
+ size_t hash, pos, start;
+ struct mt_elem *dslot = NULL;
+
+ if (t->alloc == 0) {
+ mt_rehash(mrb, t);
+ }
+ hash = kh_int_hash_func(mrb, sym);
+ start = pos = hash & (t->alloc-1);
+ for (;;) {
+ struct mt_elem *slot = &t->table[pos];
+
+ if (slot->key == sym) {
+ slot->func_p = func_p;
+ slot->ptr = ptr;
+ return slot;
+ }
+ else if (slot->key == 0) { /* empty or deleted */
+ if (slot->func_p == 0) { /* empty */
+ t->size++;
+ slot->key = sym;
+ slot->func_p = func_p;
+ slot->ptr = ptr;
+ return slot;
+ }
+ else if (!dslot) { /* deleted */
+ dslot = slot;
+ }
+ }
+ pos = (pos+1) & (t->alloc-1);
+ if (pos == start) { /* not found */
+ if (dslot) {
+ t->size++;
+ dslot->key = sym;
+ dslot->func_p = func_p;
+ dslot->ptr = ptr;
+ return dslot;
+ }
+ /* no room */
+ mt_rehash(mrb, t);
+ start = pos = hash & (t->alloc-1);
+ }
+ }
+}
+
+/* Get a value for a symbol from the method table. */
+static struct mt_elem*
+mt_get(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
+{
+ size_t hash, pos, start;
+
+ if (t == NULL) return NULL;
+ if (t->alloc == 0) return NULL;
+ if (t->size == 0) return NULL;
+
+ hash = kh_int_hash_func(mrb, sym);
+ start = pos = hash & (t->alloc-1);
+ for (;;) {
+ struct mt_elem *slot = &t->table[pos];
+
+ if (slot->key == sym) {
+ return slot;
+ }
+ else if (slot_empty_p(slot)) {
+ return NULL;
+ }
+ pos = (pos+1) & (t->alloc-1);
+ if (pos == start) { /* not found */
+ return NULL;
+ }
+ }
+}
+
+/* Deletes the value for the symbol from the method table. */
+static mrb_bool
+mt_del(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
+{
+ size_t hash, pos, start;
+
+ if (t == NULL) return FALSE;
+ if (t->alloc == 0) return FALSE;
+ if (t->size == 0) return FALSE;
+
+ hash = kh_int_hash_func(mrb, sym);
+ start = pos = hash & (t->alloc-1);
+ for (;;) {
+ struct mt_elem *slot = &t->table[pos];
+
+ if (slot->key == sym) {
+ t->size--;
+ slot->key = 0;
+ slot->func_p = 1;
+ return TRUE;
+ }
+ else if (slot_empty_p(slot)) {
+ return FALSE;
+ }
+ pos = (pos+1) & (t->alloc-1);
+ if (pos == start) { /* not found */
+ return FALSE;
+ }
+ }
+}
+
+/* Copy the method table. */
+static struct mt_tbl*
+mt_copy(mrb_state *mrb, mt_tbl *t)
+{
+ mt_tbl *t2;
+ size_t i;
+
+ if (t == NULL) return NULL;
+ if (t->alloc == 0) return NULL;
+ if (t->size == 0) return NULL;
+
+ t2 = mt_new(mrb);
+ for (i=0; i<t->alloc; i++) {
+ struct mt_elem *slot = &t->table[i];
+
+ if (slot->key) {
+ mt_put(mrb, t2, slot->key, slot->func_p, slot->ptr);
+ }
+ }
+ return t2;
+}
+
+/* Free memory of the method table. */
+static void
+mt_free(mrb_state *mrb, mt_tbl *t)
+{
+ mrb_free(mrb, t->table);
+ mrb_free(mrb, t);
+}
+
+MRB_API void
+mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *p)
+{
+ mt_tbl *t = c->mt;
+ size_t i;
+
+ if (t == NULL) return;
+ if (t->alloc == 0) return;
+ if (t->size == 0) return;
+
+ for (i=0; i<t->alloc; i++) {
+ struct mt_elem *slot = &t->table[i];
+
+ if (slot->key) {
+ if (fn(mrb, slot->key, slot, p) != 0)
+ return;
+ }
+ }
+ return;
+}
void
mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
{
- khiter_t k;
- khash_t(mt) *h = c->mt;
+ mt_tbl *t = c->mt;
+ size_t i;
- if (!h) return;
- for (k = kh_begin(h); k != kh_end(h); k++) {
- if (kh_exist(h, k)) {
- mrb_method_t m = kh_value(h, k);
+ if (t == NULL) return;
+ if (t->alloc == 0) return;
+ if (t->size == 0) return;
- if (MRB_METHOD_PROC_P(m)) {
- struct RProc *p = MRB_METHOD_PROC(m);
- mrb_gc_mark(mrb, (struct RBasic*)p);
- }
+ for (i=0; i<t->alloc; i++) {
+ struct mt_elem *slot = &t->table[i];
+
+ if (slot->key && !slot->func_p) { /* Proc pointer */
+ struct RProc *p = slot->ptr.proc;
+ mrb_gc_mark(mrb, (struct RBasic*)p);
}
}
+ return;
}
size_t
mrb_gc_mark_mt_size(mrb_state *mrb, struct RClass *c)
{
- khash_t(mt) *h = c->mt;
+ struct mt_tbl *h = c->mt;
if (!h) return 0;
- return kh_size(h);
+ return h->size;
}
void
mrb_gc_free_mt(mrb_state *mrb, struct RClass *c)
{
- kh_destroy(mt, mrb, c->mt);
+ if (c->mt) mt_free(mrb, c->mt);
}
void
mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb_sym id)
{
mrb_value name;
- mrb_sym nsym = mrb_intern_lit(mrb, "__classname__");
+ mrb_sym nsym = MRB_SYM(__classname__);
if (mrb_obj_iv_defined(mrb, (struct RObject*)c, nsym)) return;
if (outer == NULL || outer == mrb->object_class) {
@@ -68,7 +287,7 @@ mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb
name = mrb_class_path(mrb, outer);
if (mrb_nil_p(name)) { /* unnamed outer class */
if (outer != mrb->object_class && outer != c) {
- mrb_obj_iv_set_force(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"),
+ mrb_obj_iv_set_force(mrb, (struct RObject*)c, MRB_SYM(__outer__),
mrb_obj_value(outer));
}
return;
@@ -107,7 +326,7 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o)
if (o->c->tt == MRB_TT_SCLASS) return;
sc = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_SCLASS, mrb->class_class);
sc->flags |= MRB_FL_CLASS_IS_INHERITED;
- sc->mt = kh_init(mt, mrb);
+ sc->mt = mt_new(mrb);
sc->iv = 0;
if (o->tt == MRB_TT_CLASS) {
c = (struct RClass*)o;
@@ -132,7 +351,7 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o)
o->c = sc;
mrb_field_write_barrier(mrb, (struct RBasic*)o, (struct RBasic*)sc);
mrb_field_write_barrier(mrb, (struct RBasic*)sc, (struct RBasic*)o);
- mrb_obj_iv_set(mrb, (struct RObject*)sc, mrb_intern_lit(mrb, "__attached__"), mrb_obj_value(o));
+ mrb_obj_iv_set(mrb, (struct RObject*)sc, MRB_SYM(__attached__), mrb_obj_value(o));
sc->flags |= o->flags & MRB_FL_OBJ_IS_FROZEN;
}
@@ -229,6 +448,15 @@ mrb_vm_define_module(mrb_state *mrb, mrb_value outer, mrb_sym id)
return define_module(mrb, id, mrb_class_ptr(outer));
}
+MRB_API struct RClass*
+mrb_define_module_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name)
+{
+ struct RClass * c = define_module(mrb, name, outer);
+
+ setup_class(mrb, outer, c, name);
+ return c;
+}
+
MRB_API struct RClass*
mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name)
{
@@ -283,12 +511,10 @@ mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super)
}
static mrb_value mrb_bob_init(mrb_state *mrb, mrb_value);
-#ifdef MRB_METHOD_CACHE
-static void mc_clear_all(mrb_state *mrb);
-static void mc_clear_by_id(mrb_state *mrb, struct RClass*, mrb_sym);
+#ifndef MRB_NO_METHOD_CACHE
+static void mc_clear(mrb_state *mrb);
#else
-#define mc_clear_all(mrb)
-#define mc_clear_by_id(mrb,c,s)
+#define mc_clear(mrb)
#endif
static void
@@ -302,7 +528,7 @@ mrb_class_inherited(mrb_state *mrb, struct RClass *super, struct RClass *klass)
super->flags |= MRB_FL_CLASS_IS_INHERITED;
s = mrb_obj_value(super);
mrb_mc_clear_by_class(mrb, klass);
- mid = mrb_intern_lit(mrb, "inherited");
+ mid = MRB_SYM(inherited);
if (!mrb_func_basic_p(mrb, s, mid, mrb_bob_init)) {
mrb_value c = mrb_obj_value(klass);
mrb_funcall_argv(mrb, s, mid, 1, &c);
@@ -349,21 +575,29 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id
MRB_API mrb_bool
mrb_class_defined(mrb_state *mrb, const char *name)
{
- mrb_value sym = mrb_check_intern_cstr(mrb, name);
- if (mrb_nil_p(sym)) {
- return FALSE;
- }
- return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), mrb_symbol(sym));
+ mrb_sym sym = mrb_intern_check_cstr(mrb, name);
+ if (!sym) return FALSE;
+ return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), sym);
+}
+
+MRB_API mrb_bool
+mrb_class_defined_id(mrb_state *mrb, mrb_sym name)
+{
+ return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), name);
}
MRB_API mrb_bool
mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name)
{
- mrb_value sym = mrb_check_intern_cstr(mrb, name);
- if (mrb_nil_p(sym)) {
- return FALSE;
- }
- return mrb_const_defined_at(mrb, mrb_obj_value(outer), mrb_symbol(sym));
+ mrb_sym sym = mrb_intern_check_cstr(mrb, name);
+ if (!sym) return FALSE;
+ return mrb_const_defined_at(mrb, mrb_obj_value(outer), sym);
+}
+
+MRB_API mrb_bool
+mrb_class_defined_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name)
+{
+ return mrb_const_defined_at(mrb, mrb_obj_value(outer), name);
}
MRB_API struct RClass*
@@ -372,6 +606,12 @@ mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
return class_from_sym(mrb, outer, mrb_intern_cstr(mrb, name));
}
+MRB_API struct RClass*
+mrb_class_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name)
+{
+ return class_from_sym(mrb, outer, name);
+}
+
MRB_API struct RClass*
mrb_class_get(mrb_state *mrb, const char *name)
{
@@ -379,11 +619,16 @@ mrb_class_get(mrb_state *mrb, const char *name)
}
MRB_API struct RClass*
-mrb_exc_get(mrb_state *mrb, const char *name)
+mrb_class_get_id(mrb_state *mrb, mrb_sym name)
+{
+ return mrb_class_get_under_id(mrb, mrb->object_class, name);
+}
+
+MRB_API struct RClass*
+mrb_exc_get_id(mrb_state *mrb, mrb_sym name)
{
struct RClass *exc, *e;
- mrb_value c = mrb_const_get(mrb, mrb_obj_value(mrb->object_class),
- mrb_intern_cstr(mrb, name));
+ mrb_value c = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), name);
if (!mrb_class_p(c)) {
mrb_raise(mrb, mrb->eException_class, "exception corrupted");
@@ -404,12 +649,24 @@ mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
return module_from_sym(mrb, outer, mrb_intern_cstr(mrb, name));
}
+MRB_API struct RClass*
+mrb_module_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name)
+{
+ return module_from_sym(mrb, outer, name);
+}
+
MRB_API struct RClass*
mrb_module_get(mrb_state *mrb, const char *name)
{
return mrb_module_get_under(mrb, mrb->object_class, name);
}
+MRB_API struct RClass*
+mrb_module_get_id(mrb_state *mrb, mrb_sym name)
+{
+ return mrb_module_get_under_id(mrb, mrb->object_class, name);
+}
+
/*!
* Defines a class under the namespace of \a outer.
* \param outer a class which contains the new class.
@@ -427,9 +684,8 @@ mrb_module_get(mrb_state *mrb, const char *name)
* \a super, the function just returns the defined class.
*/
MRB_API struct RClass*
-mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super)
+mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super)
{
- mrb_sym id = mrb_intern_cstr(mrb, name);
struct RClass * c;
#if 0
@@ -437,34 +693,45 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s
mrb_warn(mrb, "no super class for '%C::%n', Object assumed", outer, id);
}
#endif
- c = define_class(mrb, id, super, outer);
- setup_class(mrb, outer, c, id);
+ c = define_class(mrb, name, super, outer);
+ setup_class(mrb, outer, c, name);
return c;
}
+MRB_API struct RClass*
+mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super)
+{
+ return mrb_define_class_under_id(mrb, outer, mrb_intern_cstr(mrb, name), super);
+}
+
MRB_API void
mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_t m)
{
- khash_t(mt) *h;
- khiter_t k;
+ mt_tbl *h;
+ union mt_ptr ptr;
+
MRB_CLASS_ORIGIN(c);
h = c->mt;
-
mrb_check_frozen(mrb, c);
- if (!h) h = c->mt = kh_init(mt, mrb);
- k = kh_put(mt, mrb, h, mid);
- kh_value(h, k) = m;
- if (MRB_METHOD_PROC_P(m) && !MRB_METHOD_UNDEF_P(m)) {
+ if (!h) h = c->mt = mt_new(mrb);
+ if (MRB_METHOD_PROC_P(m)) {
struct RProc *p = MRB_METHOD_PROC(m);
- p->flags |= MRB_PROC_SCOPE;
- p->c = NULL;
- mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)p);
- if (!MRB_PROC_ENV_P(p)) {
- MRB_PROC_SET_TARGET_CLASS(p, c);
+ ptr.proc = p;
+ if (p) {
+ p->flags |= MRB_PROC_SCOPE;
+ p->c = NULL;
+ mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)p);
+ if (!MRB_PROC_ENV_P(p)) {
+ MRB_PROC_SET_TARGET_CLASS(p, c);
+ }
}
}
- mc_clear_by_id(mrb, c, mid);
+ else {
+ ptr.func = MRB_METHOD_FUNC(m);
+ }
+ mt_put(mrb, h, mid, MRB_METHOD_FUNC_P(m), ptr);
+ mc_clear(mrb);
}
MRB_API void
@@ -474,6 +741,9 @@ mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t f
int ai = mrb_gc_arena_save(mrb);
MRB_METHOD_FROM_FUNC(m, func);
+#ifndef MRB_USE_METHOD_T_STRUCT
+ mrb_assert(MRB_METHOD_FUNC(m) == func);
+#endif
if (aspec == MRB_ARGS_NONE()) {
MRB_METHOD_NOARG_SET(m);
}
@@ -588,8 +858,8 @@ void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self);
z: String [const char*] NUL terminated string; z! gives NULL for nil
a: Array [mrb_value*,mrb_int] Receive two arguments; a! gives (NULL,0) for nil
c: Class/Module [strcut RClass*]
- f: Fixnum/Float [mrb_float]
- i: Fixnum/Float [mrb_int]
+ f: Integer/Float [mrb_float]
+ i: Integer/Float [mrb_int]
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
@@ -849,7 +1119,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
}
}
break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case 'f':
{
mrb_float *p;
@@ -867,7 +1137,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
p = va_arg(ap, mrb_int*);
if (i < argc) {
- *p = mrb_fixnum(mrb_to_int(mrb, argv[i++]));
+ *p = mrb_integer(mrb_to_int(mrb, argv[i++]));
}
}
break;
@@ -984,7 +1254,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
else {
uint32_t kwnum = kwargs->num;
uint32_t required = kwargs->required;
- const char *const *kname = kwargs->table;
+ const mrb_sym *kname = kwargs->table;
mrb_value *values = kwargs->values;
uint32_t j;
const uint32_t keyword_max = 40;
@@ -994,16 +1264,16 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
}
for (j = required; j > 0; j --, kname ++, values ++) {
- mrb_value k = mrb_symbol_value(mrb_intern_cstr(mrb, *kname));
+ mrb_value k = mrb_symbol_value(*kname);
if (!mrb_hash_key_p(mrb, ksrc, k)) {
- mrb_raisef(mrb, E_ARGUMENT_ERROR, "missing keyword: %s", *kname);
+ mrb_raisef(mrb, E_ARGUMENT_ERROR, "missing keyword: %n", *kname);
}
*values = mrb_hash_delete_key(mrb, ksrc, k);
mrb_gc_protect(mrb, *values);
}
for (j = kwnum - required; j > 0; j --, kname ++, values ++) {
- mrb_value k = mrb_symbol_value(mrb_intern_cstr(mrb, *kname));
+ mrb_value k = mrb_symbol_value(*kname);
if (mrb_hash_key_p(mrb, ksrc, k)) {
*values = mrb_hash_delete_key(mrb, ksrc, k);
mrb_gc_protect(mrb, *values);
@@ -1057,7 +1327,7 @@ boot_defclass(mrb_state *mrb, struct RClass *super)
else {
c->super = mrb->object_class;
}
- c->mt = kh_init(mt, mrb);
+ c->mt = mt_new(mrb);
return c;
}
@@ -1065,7 +1335,7 @@ static void
boot_initmod(mrb_state *mrb, struct RClass *mod)
{
if (!mod->mt) {
- mod->mt = kh_init(mt, mrb);
+ mod->mt = mt_new(mrb);
}
}
@@ -1129,7 +1399,7 @@ include_module_at(mrb_state *mrb, struct RClass *c, struct RClass *ins_pos, stru
skip:
m = m->super;
}
- mc_clear_all(mrb);
+ mc_clear(mrb);
return 0;
}
@@ -1155,7 +1425,7 @@ mrb_prepend_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
origin->super = c->super;
c->super = origin;
origin->mt = c->mt;
- c->mt = kh_init(mt, mrb);
+ c->mt = mt_new(mrb);
mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)origin);
c->flags |= MRB_FL_CLASS_IS_PREPENDED;
}
@@ -1292,8 +1562,8 @@ mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v)
case MRB_TT_CPTR:
return mrb->object_class;
case MRB_TT_SYMBOL:
- case MRB_TT_FIXNUM:
-#ifndef MRB_WITHOUT_FLOAT
+ case MRB_TT_INTEGER:
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
#endif
return NULL;
@@ -1323,29 +1593,43 @@ mrb_define_singleton_method(mrb_state *mrb, struct RObject *o, const char *name,
mrb_define_method_id(mrb, o->c, mrb_intern_cstr(mrb, name), func, aspec);
}
+MRB_API void
+mrb_define_singleton_method_id(mrb_state *mrb, struct RObject *o, mrb_sym name, mrb_func_t func, mrb_aspec aspec)
+{
+ prepare_singleton_class(mrb, (struct RBasic*)o);
+ mrb_define_method_id(mrb, o->c, name, func, aspec);
+}
+
MRB_API void
mrb_define_class_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
{
mrb_define_singleton_method(mrb, (struct RObject*)c, name, func, aspec);
}
+MRB_API void
+mrb_define_class_method_id(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_func_t func, mrb_aspec aspec)
+{
+ mrb_define_singleton_method_id(mrb, (struct RObject*)c, name, func, aspec);
+}
+
+MRB_API void
+mrb_define_module_function_id(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_func_t func, mrb_aspec aspec)
+{
+ mrb_define_class_method_id(mrb, c, name, func, aspec);
+ mrb_define_method_id(mrb, c, name, func, aspec);
+}
+
MRB_API void
mrb_define_module_function(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
{
- mrb_define_class_method(mrb, c, name, func, aspec);
- mrb_define_method(mrb, c, name, func, aspec);
+ mrb_define_module_function_id(mrb, c, mrb_intern_cstr(mrb, name), func, aspec);
}
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
static void
-mc_clear_all(mrb_state *mrb)
+mc_clear(mrb_state *mrb)
{
- struct mrb_cache_entry *mc = mrb->cache;
- int i;
-
- for (i=0; i<MRB_METHOD_CACHE_SIZE; i++) {
- mc[i].c = 0;
- }
+ memset(mrb->cache, 0, MRB_METHOD_CACHE_SIZE*sizeof(mrb->cache[0]));
}
void
@@ -1355,7 +1639,7 @@ mrb_mc_clear_by_class(mrb_state *mrb, struct RClass *c)
int i;
if (c->flags & MRB_FL_CLASS_IS_INHERITED) {
- mc_clear_all(mrb);
+ mc_clear(mrb);
c->flags &= ~MRB_FL_CLASS_IS_INHERITED;
return;
}
@@ -1363,32 +1647,14 @@ mrb_mc_clear_by_class(mrb_state *mrb, struct RClass *c)
if (mc[i].c == c) mc[i].c = 0;
}
}
-
-static void
-mc_clear_by_id(mrb_state *mrb, struct RClass *c, mrb_sym mid)
-{
- struct mrb_cache_entry *mc = mrb->cache;
- int i;
-
- if (c->flags & MRB_FL_CLASS_IS_INHERITED) {
- mc_clear_all(mrb);
- c->flags &= ~MRB_FL_CLASS_IS_INHERITED;
- return;
- }
- for (i=0; i<MRB_METHOD_CACHE_SIZE; i++) {
- if (mc[i].c == c || mc[i].mid == mid)
- mc[i].c = 0;
- }
-}
#endif
MRB_API mrb_method_t
mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
{
- khiter_t k;
mrb_method_t m;
struct RClass *c = *cp;
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
struct RClass *oc = c;
int h = kh_int_hash_func(mrb, ((intptr_t)oc) ^ mid) & (MRB_METHOD_CACHE_SIZE-1);
struct mrb_cache_entry *mc = &mrb->cache[h];
@@ -1400,15 +1666,20 @@ mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
#endif
while (c) {
- khash_t(mt) *h = c->mt;
+ mt_tbl *h = c->mt;
if (h) {
- k = kh_get(mt, mrb, h, mid);
- if (k != kh_end(h)) {
- m = kh_value(h, k);
- if (MRB_METHOD_UNDEF_P(m)) break;
+ struct mt_elem *e = mt_get(mrb, h, mid);
+ if (e) {
+ if (e->ptr.proc == 0) break;
*cp = c;
-#ifdef MRB_METHOD_CACHE
+ if (e->func_p) {
+ MRB_METHOD_FROM_FUNC(m, e->ptr.func);
+ }
+ else {
+ MRB_METHOD_FROM_PROC(m, e->ptr.proc);
+ }
+#ifndef MRB_NO_METHOD_CACHE
mc->c = oc;
mc->c0 = c;
mc->mid = mid;
@@ -1578,7 +1849,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_intern_lit(mrb, "initialize");
+ init = MRB_SYM(initialize);
if (!mrb_func_basic_p(mrb, obj, init, mrb_bob_init)) {
mrb_funcall_with_block(mrb, obj, init, argc, argv, blk);
}
@@ -1592,7 +1863,7 @@ mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *arg
mrb_sym mid;
obj = mrb_instance_alloc(mrb, mrb_obj_value(c));
- mid = mrb_intern_lit(mrb, "initialize");
+ mid = MRB_SYM(initialize);
if (!mrb_func_basic_p(mrb, obj, mid, mrb_bob_init)) {
mrb_funcall_argv(mrb, obj, mid, argc, argv);
}
@@ -1624,7 +1895,7 @@ mrb_class_new_class(mrb_state *mrb, mrb_value cv)
super = mrb_obj_value(mrb->object_class);
}
new_class = mrb_obj_value(mrb_class_new(mrb, mrb_class_ptr(super)));
- mid = mrb_intern_lit(mrb, "initialize");
+ mid = MRB_SYM(initialize);
if (mrb_func_basic_p(mrb, new_class, mid, mrb_class_initialize)) {
mrb_class_initialize(mrb, new_class);
}
@@ -1722,7 +1993,7 @@ MRB_API mrb_value
mrb_class_path(mrb_state *mrb, struct RClass *c)
{
mrb_value path;
- mrb_sym nsym = mrb_intern_lit(mrb, "__classname__");
+ mrb_sym nsym = MRB_SYM(__classname__);
path = mrb_obj_iv_get(mrb, (struct RObject*)c, nsym);
if (mrb_nil_p(path)) {
@@ -1827,7 +2098,7 @@ mrb_module_new(mrb_state *mrb)
* called with an explicit receiver, as <code>class</code> is also a
* reserved word in Ruby.
*
- * 1.class #=> Fixnum
+ * 1.class #=> Integer
* self.class #=> Object
*/
@@ -1877,6 +2148,12 @@ mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const
mrb_alias_method(mrb, klass, mrb_intern_cstr(mrb, name1), mrb_intern_cstr(mrb, name2));
}
+MRB_API void
+mrb_define_alias_id(mrb_state *mrb, struct RClass *klass, mrb_sym a, mrb_sym b)
+{
+ mrb_alias_method(mrb, klass, a, b);
+}
+
/*
* call-seq:
* mod.to_s -> string
@@ -1891,7 +2168,7 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
{
if (mrb_sclass_p(klass)) {
- mrb_value v = mrb_iv_get(mrb, klass, mrb_intern_lit(mrb, "__attached__"));
+ mrb_value v = mrb_iv_get(mrb, klass, MRB_SYM(__attached__));
mrb_value str = mrb_str_new_lit(mrb, "#<Class:");
if (class_ptr_p(v)) {
@@ -1927,7 +2204,7 @@ undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
mrb_define_method_raw(mrb, c, a, m);
}
-void
+MRB_API void
mrb_undef_method_id(mrb_state *mrb, struct RClass *c, mrb_sym a)
{
if (!mrb_obj_respond_to(mrb, c, a)) {
@@ -1942,12 +2219,30 @@ mrb_undef_method(mrb_state *mrb, struct RClass *c, const char *name)
undef_method(mrb, c, mrb_intern_cstr(mrb, name));
}
+MRB_API void
+mrb_undef_class_method_id(mrb_state *mrb, struct RClass *c, mrb_sym name)
+{
+ mrb_undef_method_id(mrb, mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name);
+}
+
MRB_API void
mrb_undef_class_method(mrb_state *mrb, struct RClass *c, const char *name)
{
mrb_undef_method(mrb, mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name);
}
+MRB_API void
+mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym mid)
+{
+ mt_tbl *h;
+
+ MRB_CLASS_ORIGIN(c);
+ h = c->mt;
+
+ if (h && mt_del(mrb, h, mid)) return;
+ mrb_name_error(mrb, mid, "method '%n' not defined in %C", mid, c);
+}
+
static mrb_value
mrb_mod_undef(mrb_state *mrb, mrb_value mod)
{
@@ -2207,6 +2502,202 @@ mrb_mod_module_function(mrb_state *mrb, mrb_value mod)
return mod;
}
+static struct RClass*
+mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
+{
+ struct RClass *klass = mrb_basic_ptr(obj)->c;
+
+ if (klass->tt != MRB_TT_SCLASS)
+ return klass;
+ else {
+ /* copy singleton(unnamed) class */
+ struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class);
+
+ switch (mrb_type(obj)) {
+ case MRB_TT_CLASS:
+ case MRB_TT_SCLASS:
+ break;
+ default:
+ clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
+ break;
+ }
+ clone->super = klass->super;
+ if (klass->iv) {
+ mrb_iv_copy(mrb, mrb_obj_value(clone), mrb_obj_value(klass));
+ mrb_obj_iv_set(mrb, (struct RObject*)clone, MRB_SYM(__attached__), obj);
+ }
+ if (klass->mt) {
+ clone->mt = mt_copy(mrb, klass->mt);
+ }
+ else {
+ clone->mt = mt_new(mrb);
+ }
+ clone->tt = MRB_TT_SCLASS;
+ return clone;
+ }
+}
+
+static void
+copy_class(mrb_state *mrb, mrb_value dst, mrb_value src)
+{
+ struct RClass *dc = mrb_class_ptr(dst);
+ struct RClass *sc = mrb_class_ptr(src);
+ /* if the origin is not the same as the class, then the origin and
+ the current class need to be copied */
+ if (sc->flags & MRB_FL_CLASS_IS_PREPENDED) {
+ struct RClass *c0 = sc->super;
+ struct RClass *c1 = dc;
+
+ /* copy prepended iclasses */
+ while (!(c0->flags & MRB_FL_CLASS_IS_ORIGIN)) {
+ c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
+ c1 = c1->super;
+ c0 = c0->super;
+ }
+ c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
+ c1->super->flags |= MRB_FL_CLASS_IS_ORIGIN;
+ }
+ if (sc->mt) {
+ dc->mt = mt_copy(mrb, sc->mt);
+ }
+ else {
+ dc->mt = mt_new(mrb);
+ }
+ dc->super = sc->super;
+ MRB_SET_INSTANCE_TT(dc, MRB_INSTANCE_TT(sc));
+}
+
+/* 15.3.1.3.16 */
+static mrb_value
+mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
+{
+ mrb_value orig = mrb_get_arg1(mrb);
+
+ if (mrb_obj_equal(mrb, self, orig)) return self;
+ if ((mrb_type(self) != mrb_type(orig)) || (mrb_obj_class(mrb, self) != mrb_obj_class(mrb, orig))) {
+ mrb_raise(mrb, E_TYPE_ERROR, "initialize_copy should take same class object");
+ }
+ return self;
+}
+
+static void
+init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
+{
+ switch (mrb_type(obj)) {
+ case MRB_TT_ICLASS:
+ copy_class(mrb, dest, obj);
+ return;
+ case MRB_TT_CLASS:
+ case MRB_TT_MODULE:
+ copy_class(mrb, dest, obj);
+ mrb_iv_copy(mrb, dest, obj);
+ mrb_iv_remove(mrb, dest, MRB_SYM(__classname__));
+ break;
+ case MRB_TT_OBJECT:
+ case MRB_TT_SCLASS:
+ case MRB_TT_HASH:
+ case MRB_TT_DATA:
+ case MRB_TT_EXCEPTION:
+ mrb_iv_copy(mrb, dest, obj);
+ break;
+ case MRB_TT_ISTRUCT:
+ mrb_istruct_copy(dest, obj);
+ break;
+
+ default:
+ break;
+ }
+ if (!mrb_func_basic_p(mrb, dest, MRB_SYM(initialize_copy), mrb_obj_init_copy)) {
+ mrb_funcall_id(mrb, dest, MRB_SYM(initialize_copy), 1, obj);
+ }
+}
+
+/* 15.3.1.3.8 */
+/*
+ * call-seq:
+ * obj.clone -> an_object
+ *
+ * Produces a shallow copy of <i>obj</i>---the instance variables of
+ * <i>obj</i> are copied, but not the objects they reference. Copies
+ * the frozen state of <i>obj</i>. See also the discussion
+ * under <code>Object#dup</code>.
+ *
+ * class Klass
+ * attr_accessor :str
+ * end
+ * s1 = Klass.new #=> #<Klass:0x401b3a38>
+ * s1.str = "Hello" #=> "Hello"
+ * s2 = s1.clone #=> #<Klass:0x401b3998 @str="Hello">
+ * s2.str[1,4] = "i" #=> "i"
+ * s1.inspect #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
+ * s2.inspect #=> "#<Klass:0x401b3998 @str=\"Hi\">"
+ *
+ * This method may have class-specific behavior. If so, that
+ * behavior will be documented under the #+initialize_copy+ method of
+ * the class.
+ *
+ * Some Class(True False Nil Symbol Integer Float) Object cannot clone.
+ */
+MRB_API mrb_value
+mrb_obj_clone(mrb_state *mrb, mrb_value self)
+{
+ struct RObject *p;
+ mrb_value clone;
+
+ if (mrb_immediate_p(self)) {
+ return self;
+ }
+ if (mrb_sclass_p(self)) {
+ mrb_raise(mrb, E_TYPE_ERROR, "can't clone singleton class");
+ }
+ p = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self));
+ p->c = mrb_singleton_class_clone(mrb, self);
+ mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)p->c);
+ clone = mrb_obj_value(p);
+ init_copy(mrb, clone, self);
+ p->flags |= mrb_obj_ptr(self)->flags & MRB_FL_OBJ_IS_FROZEN;
+
+ return clone;
+}
+
+/* 15.3.1.3.9 */
+/*
+ * call-seq:
+ * obj.dup -> an_object
+ *
+ * Produces a shallow copy of <i>obj</i>---the instance variables of
+ * <i>obj</i> are copied, but not the objects they reference.
+ * <code>dup</code> copies the frozen state of <i>obj</i>. See also
+ * the discussion under <code>Object#clone</code>. In general,
+ * <code>clone</code> and <code>dup</code> may have different semantics
+ * in descendant classes. While <code>clone</code> is used to duplicate
+ * an object, including its internal state, <code>dup</code> typically
+ * uses the class of the descendant object to create the new instance.
+ *
+ * This method may have class-specific behavior. If so, that
+ * behavior will be documented under the #+initialize_copy+ method of
+ * the class.
+ */
+
+MRB_API mrb_value
+mrb_obj_dup(mrb_state *mrb, mrb_value obj)
+{
+ struct RBasic *p;
+ mrb_value dup;
+
+ if (mrb_immediate_p(obj)) {
+ return obj;
+ }
+ if (mrb_sclass_p(obj)) {
+ mrb_raise(mrb, E_TYPE_ERROR, "can't dup singleton class");
+ }
+ p = mrb_obj_alloc(mrb, mrb_type(obj), mrb_obj_class(mrb, obj));
+ dup = mrb_obj_value(p);
+ init_copy(mrb, dup, obj);
+
+ return dup;
+}
+
/* implementation of __id__ */
mrb_value mrb_obj_id_m(mrb_state *mrb, mrb_value self);
/* implementation of instance_eval */
@@ -2229,29 +2720,27 @@ static const mrb_code new_iseq[] = {
OP_RETURN, 0x0 /* OP_RETURN R0 */
};
+const mrb_sym new_syms[] = { MRB_SYM(allocate), MRB_SYM(initialize) };
+static const mrb_irep new_irep = {
+ 3, 6, 0, MRB_IREP_STATIC,
+ new_iseq, NULL, new_syms, NULL, NULL, NULL,
+ sizeof(new_iseq), 0, 2, 0, 0,
+};
+
static void
init_class_new(mrb_state *mrb, struct RClass *cls)
{
struct RProc *p;
mrb_method_t m;
- mrb_irep *new_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep));
- static const mrb_irep mrb_irep_zero = { 0 };
-
- *new_irep = mrb_irep_zero;
- new_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*2);
- new_irep->syms[0] = mrb_intern_lit(mrb, "allocate");
- new_irep->syms[1] = mrb_intern_lit(mrb, "initialize");
- new_irep->slen = 2;
- new_irep->flags = MRB_ISEQ_NO_FREE;
- new_irep->iseq = new_iseq;
- new_irep->ilen = sizeof(new_iseq);
- new_irep->nregs = 6;
- new_irep->nlocals = 3;
- p = mrb_proc_new(mrb, new_irep);
+
+ p = mrb_proc_new(mrb, &new_irep);
MRB_METHOD_FROM_PROC(m, p);
- mrb_define_method_raw(mrb, cls, mrb_intern_lit(mrb, "new"), m);
+ mrb_define_method_raw(mrb, cls, MRB_SYM(new), m);
}
+/* implementation of #send method */
+mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+
void
mrb_init_class(mrb_state *mrb)
{
@@ -2273,16 +2762,16 @@ mrb_init_class(mrb_state *mrb)
make_metaclass(mrb, cls);
/* name basic classes */
- mrb_define_const(mrb, bob, "BasicObject", mrb_obj_value(bob));
- mrb_define_const(mrb, obj, "Object", mrb_obj_value(obj));
- mrb_define_const(mrb, obj, "Module", mrb_obj_value(mod));
- mrb_define_const(mrb, obj, "Class", mrb_obj_value(cls));
+ mrb_define_const_id(mrb, bob, MRB_SYM(BasicObject), mrb_obj_value(bob));
+ mrb_define_const_id(mrb, obj, MRB_SYM(Object), mrb_obj_value(obj));
+ mrb_define_const_id(mrb, obj, MRB_SYM(Module), mrb_obj_value(mod));
+ mrb_define_const_id(mrb, obj, MRB_SYM(Class), mrb_obj_value(cls));
/* name each classes */
- mrb_class_name_class(mrb, NULL, bob, mrb_intern_lit(mrb, "BasicObject"));
- mrb_class_name_class(mrb, NULL, obj, mrb_intern_lit(mrb, "Object")); /* 15.2.1 */
- mrb_class_name_class(mrb, NULL, mod, mrb_intern_lit(mrb, "Module")); /* 15.2.2 */
- mrb_class_name_class(mrb, NULL, cls, mrb_intern_lit(mrb, "Class")); /* 15.2.3 */
+ mrb_class_name_class(mrb, NULL, bob, MRB_SYM(BasicObject));
+ mrb_class_name_class(mrb, NULL, obj, MRB_SYM(Object)); /* 15.2.1 */
+ mrb_class_name_class(mrb, NULL, mod, MRB_SYM(Module)); /* 15.2.2 */
+ mrb_class_name_class(mrb, NULL, cls, MRB_SYM(Class)); /* 15.2.3 */
mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class); /* 15.2.17 */
MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC);
diff --git a/src/codedump.c b/src/codedump.c
index 649be176b93c12f0bbe324bd26ec401064fb228c..3f0801929a5ea0ae2a7f17777c4c901bdfe1759b 100644
--- a/src/codedump.c
+++ b/src/codedump.c
@@ -4,26 +4,20 @@
#include <mruby/opcode.h>
#include <mruby/string.h>
#include <mruby/proc.h>
+#include <mruby/dump.h>
#ifndef MRB_DISABLE_STDIO
static void
-print_r(mrb_state *mrb, mrb_irep *irep, size_t n)
+print_r(mrb_state *mrb, const mrb_irep *irep, size_t n)
{
- size_t i;
-
if (n == 0) return;
-
- for (i=0; i+1<irep->nlocals; i++) {
- if (irep->lv[i].r == n) {
- mrb_sym sym = irep->lv[i].name;
- printf(" R%d:%s", (int)n, mrb_sym_dump(mrb, sym));
- break;
- }
- }
+ if (n > irep->nlocals) return;
+ if (!irep->lv[n-1]) return;
+ printf(" R%d:%s", (int)n, mrb_sym_dump(mrb, irep->lv[n-1]));
}
static void
-print_lv_a(mrb_state *mrb, mrb_irep *irep, uint16_t a)
+print_lv_a(mrb_state *mrb, const mrb_irep *irep, uint16_t a)
{
if (!irep->lv || a >= irep->nlocals || a == 0) {
printf("\n");
@@ -35,7 +29,7 @@ print_lv_a(mrb_state *mrb, mrb_irep *irep, uint16_t a)
}
static void
-print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b)
+print_lv_ab(mrb_state *mrb, const mrb_irep *irep, uint16_t a, uint16_t b)
{
if (!irep->lv || (a >= irep->nlocals && b >= irep->nlocals) || a+b == 0) {
printf("\n");
@@ -48,7 +42,7 @@ print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b)
}
static void
-print_header(mrb_state *mrb, mrb_irep *irep, ptrdiff_t i)
+print_header(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t i)
{
int32_t line;
@@ -63,10 +57,10 @@ print_header(mrb_state *mrb, mrb_irep *irep, ptrdiff_t i)
printf("%03d ", (int)i);
}
-#define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn
+#define CASE(insn,ops) case insn: FETCH_ ## ops ();
static void
-codedump(mrb_state *mrb, mrb_irep *irep)
+codedump(mrb_state *mrb, const mrb_irep *irep)
{
int ai;
const mrb_code *pc, *pcend;
@@ -82,9 +76,36 @@ codedump(mrb_state *mrb, 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].name);
- int n = irep->lv[i - 1].r ? irep->lv[i - 1].r : i;
- printf(" R%d:%s\n", n, s ? s : "");
+ char const *s = mrb_sym_dump(mrb, irep->lv[i - 1]);
+ printf(" R%d:%s\n", i, s ? s : "");
+ }
+ }
+
+ if (irep->clen > 0) {
+ int i = irep->clen;
+ const struct mrb_irep_catch_handler *e = mrb_irep_catch_handler_table(irep);
+
+ for (; i > 0; i --, e ++) {
+ int begin = bin_to_uint16(e->begin);
+ int end = bin_to_uint16(e->end);
+ int target = bin_to_uint16(e->target);
+ char buf[20];
+ const char *type;
+
+ switch (e->type) {
+ case MRB_CATCH_RESCUE:
+ type = "rescue";
+ break;
+ case MRB_CATCH_ENSURE:
+ type = "ensure";
+ break;
+ default:
+ buf[0] = '\0';
+ snprintf(buf, sizeof(buf), "0x%02x <unknown>", (int)e->type);
+ type = buf;
+ break;
+ }
+ printf("catch type: %-8s begin: %04d end: %04d target: %04d\n", type, begin, end, target);
}
}
@@ -107,159 +128,173 @@ codedump(mrb_state *mrb, mrb_irep *irep)
print_header(mrb, irep, i);
ins = READ_B();
switch (ins) {
- CASE(OP_NOP, Z):
+ CASE(OP_NOP, Z);
printf("OP_NOP\n");
break;
- CASE(OP_MOVE, BB):
+ CASE(OP_MOVE, BB);
printf("OP_MOVE\tR%d\tR%d\t", a, b);
print_lv_ab(mrb, irep, a, b);
break;
- CASE(OP_LOADL, BB):
- {
- mrb_value v = irep->pool[b];
- mrb_value s = mrb_inspect(mrb, v);
- printf("OP_LOADL\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s));
+ CASE(OP_LOADL, BB);
+ switch (irep->pool[b].tt) {
+ case IREP_TT_FLOAT:
+ printf("OP_LOADL\tR%d\tL(%d)\t; %f", a, b, (double)irep->pool[b].u.f);
+ break;
+ case IREP_TT_INT32:
+ printf("OP_LOADL\tR%d\tL(%d)\t; %" PRId32, a, b, irep->pool[b].u.i32);
+ break;
+#ifdef MRB_64BIT
+ case IREP_TT_INT64:
+ printf("OP_LOADL\tR%d\tL(%d)\t; %" PRId64, a, b, irep->pool[b].u.i64);
+ break;
+#endif
+ default:
+ printf("OP_LOADL\tR%d\tL(%d)\t", a, b);
+ break;
}
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADI, BB):
+ CASE(OP_LOADI, BB);
printf("OP_LOADI\tR%d\t%d\t", a, b);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADINEG, BB):
+ CASE(OP_LOADINEG, BB);
printf("OP_LOADI\tR%d\t-%d\t", a, b);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADI16, BS):
+ CASE(OP_LOADI16, BS);
printf("OP_LOADI16\tR%d\t%d\t", a, (int)(int16_t)b);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADI__1, B):
+ CASE(OP_LOADI__1, B);
printf("OP_LOADI__1\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADI_0, B): goto L_LOADI;
- CASE(OP_LOADI_1, B): goto L_LOADI;
- CASE(OP_LOADI_2, B): goto L_LOADI;
- CASE(OP_LOADI_3, B): goto L_LOADI;
- CASE(OP_LOADI_4, B): goto L_LOADI;
- CASE(OP_LOADI_5, B): goto L_LOADI;
- CASE(OP_LOADI_6, B): goto L_LOADI;
- CASE(OP_LOADI_7, B):
+ CASE(OP_LOADI_0, B); goto L_LOADI;
+ CASE(OP_LOADI_1, B); goto L_LOADI;
+ CASE(OP_LOADI_2, B); goto L_LOADI;
+ CASE(OP_LOADI_3, B); goto L_LOADI;
+ CASE(OP_LOADI_4, B); goto L_LOADI;
+ CASE(OP_LOADI_5, B); goto L_LOADI;
+ CASE(OP_LOADI_6, B); goto L_LOADI;
+ CASE(OP_LOADI_7, B);
L_LOADI:
printf("OP_LOADI_%d\tR%d\t\t", ins-(int)OP_LOADI_0, a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADSYM, BB):
+ CASE(OP_LOADSYM, BB);
printf("OP_LOADSYM\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADNIL, B):
+ CASE(OP_LOADNIL, B);
printf("OP_LOADNIL\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADSELF, B):
+ CASE(OP_LOADSELF, B);
printf("OP_LOADSELF\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADT, B):
+ CASE(OP_LOADT, B);
printf("OP_LOADT\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LOADF, B):
+ CASE(OP_LOADF, B);
printf("OP_LOADF\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_GETGV, BB):
+ CASE(OP_GETGV, BB);
printf("OP_GETGV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_SETGV, BB):
- printf("OP_SETGV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
+ CASE(OP_SETGV, BB);
+ printf("OP_SETGV\t;%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_GETSV, BB):
+ CASE(OP_GETSV, BB);
printf("OP_GETSV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_SETSV, BB):
+ CASE(OP_SETSV, BB);
printf("OP_SETSV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_GETCONST, BB):
+ CASE(OP_GETCONST, BB);
printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_SETCONST, BB):
+ CASE(OP_SETCONST, BB);
printf("OP_SETCONST\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_GETMCNST, BB):
+ CASE(OP_GETMCNST, BB);
printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_SETMCNST, BB):
+ CASE(OP_SETMCNST, BB);
printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym_dump(mrb, irep->syms[b]), a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_GETIV, BB):
+ CASE(OP_GETIV, BB);
printf("OP_GETIV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_SETIV, BB):
+ CASE(OP_SETIV, BB);
printf("OP_SETIV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_GETUPVAR, BBB):
+ CASE(OP_GETUPVAR, BBB);
printf("OP_GETUPVAR\tR%d\t%d\t%d", a, b, c);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_SETUPVAR, BBB):
+ CASE(OP_SETUPVAR, BBB);
printf("OP_SETUPVAR\tR%d\t%d\t%d", a, b, c);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_GETCV, BB):
+ CASE(OP_GETCV, BB);
printf("OP_GETCV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_SETCV, BB):
+ CASE(OP_SETCV, BB);
printf("OP_SETCV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_JMP, S):
+ CASE(OP_JMP, S);
printf("OP_JMP\t\t%03d\n", a);
break;
- CASE(OP_JMPIF, BS):
+ CASE(OP_JMPUW, S);
+ printf("OP_JMPUW\t\t%03d\n", a);
+ break;
+ CASE(OP_JMPIF, BS);
printf("OP_JMPIF\tR%d\t%03d\t", a, b);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_JMPNOT, BS):
+ CASE(OP_JMPNOT, BS);
printf("OP_JMPNOT\tR%d\t%03d\t", a, b);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_JMPNIL, BS):
+ CASE(OP_JMPNIL, BS);
printf("OP_JMPNIL\tR%d\t%03d\t", a, b);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_SENDV, BB):
+ CASE(OP_SENDV, BB);
printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
break;
- CASE(OP_SENDVB, BB):
+ CASE(OP_SENDVB, BB);
printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
break;
- CASE(OP_SEND, BBB):
+ CASE(OP_SEND, BBB);
printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
break;
- CASE(OP_SENDB, BBB):
+ CASE(OP_SENDB, BBB);
printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
break;
- CASE(OP_CALL, Z):
+ CASE(OP_CALL, Z);
printf("OP_CALL\n");
break;
- CASE(OP_SUPER, BB):
+ CASE(OP_SUPER, BB);
printf("OP_SUPER\tR%d\t%d\n", a, b);
break;
- CASE(OP_ARGARY, BS):
+ CASE(OP_ARGARY, BS);
printf("OP_ARGARY\tR%d\t%d:%d:%d:%d (%d)", a,
(b>>11)&0x3f,
(b>>10)&0x1,
@@ -268,7 +303,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
(b>>0)&0xf);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_ENTER, W):
+ CASE(OP_ENTER, W);
printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n",
MRB_ASPEC_REQ(a),
MRB_ASPEC_OPT(a),
@@ -278,30 +313,30 @@ codedump(mrb_state *mrb, mrb_irep *irep)
MRB_ASPEC_KDICT(a),
MRB_ASPEC_BLOCK(a));
break;
- CASE(OP_KEY_P, BB):
+ CASE(OP_KEY_P, BB);
printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_KEYEND, Z):
+ CASE(OP_KEYEND, Z);
printf("OP_KEYEND\n");
break;
- CASE(OP_KARG, BB):
+ CASE(OP_KARG, BB);
printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_RETURN, B):
+ CASE(OP_RETURN, B);
printf("OP_RETURN\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_RETURN_BLK, B):
+ CASE(OP_RETURN_BLK, B);
printf("OP_RETURN_BLK\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_BREAK, B):
+ CASE(OP_BREAK, B);
printf("OP_BREAK\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_BLKPUSH, BS):
+ CASE(OP_BLKPUSH, BS);
printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d (%d)", a,
(b>>11)&0x3f,
(b>>10)&0x1,
@@ -310,219 +345,178 @@ codedump(mrb_state *mrb, mrb_irep *irep)
(b>>0)&0xf);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_LAMBDA, BB):
+ CASE(OP_LAMBDA, BB);
printf("OP_LAMBDA\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
break;
- CASE(OP_BLOCK, BB):
+ CASE(OP_BLOCK, BB);
printf("OP_BLOCK\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
break;
- CASE(OP_METHOD, BB):
+ CASE(OP_METHOD, BB);
printf("OP_METHOD\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
break;
- CASE(OP_RANGE_INC, B):
+ CASE(OP_RANGE_INC, B);
printf("OP_RANGE_INC\tR%d\n", a);
break;
- CASE(OP_RANGE_EXC, B):
+ CASE(OP_RANGE_EXC, B);
printf("OP_RANGE_EXC\tR%d\n", a);
break;
- CASE(OP_DEF, BB):
+ CASE(OP_DEF, BB);
printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
break;
- CASE(OP_UNDEF, B):
+ CASE(OP_UNDEF, B);
printf("OP_UNDEF\t:%s\n", mrb_sym_dump(mrb, irep->syms[a]));
break;
- CASE(OP_ALIAS, BB):
+ CASE(OP_ALIAS, BB);
printf("OP_ALIAS\t:%s\t%s\n", mrb_sym_dump(mrb, irep->syms[a]), mrb_sym_dump(mrb, irep->syms[b]));
break;
- CASE(OP_ADD, B):
+ CASE(OP_ADD, B);
printf("OP_ADD\tR%d\t\n", a);
break;
- CASE(OP_ADDI, BB):
+ CASE(OP_ADDI, BB);
printf("OP_ADDI\tR%d\t%d\n", a, b);
break;
- CASE(OP_SUB, B):
+ CASE(OP_SUB, B);
printf("OP_SUB\tR%d\t\n", a);
break;
- CASE(OP_SUBI, BB):
+ CASE(OP_SUBI, BB);
printf("OP_SUBI\tR%d\t%d\n", a, b);
break;
- CASE(OP_MUL, B):
+ CASE(OP_MUL, B);
printf("OP_MUL\tR%d\t\n", a);
break;
- CASE(OP_DIV, B):
+ CASE(OP_DIV, B);
printf("OP_DIV\tR%d\t\n", a);
break;
- CASE(OP_LT, B):
+ CASE(OP_LT, B);
printf("OP_LT\t\tR%d\t\n", a);
break;
- CASE(OP_LE, B):
+ CASE(OP_LE, B);
printf("OP_LE\t\tR%d\t\n", a);
break;
- CASE(OP_GT, B):
+ CASE(OP_GT, B);
printf("OP_GT\t\tR%d\t\n", a);
break;
- CASE(OP_GE, B):
+ CASE(OP_GE, B);
printf("OP_GE\t\tR%d\t\n", a);
break;
- CASE(OP_EQ, B):
+ CASE(OP_EQ, B);
printf("OP_EQ\t\tR%d\t\n", a);
break;
- CASE(OP_ARRAY, BB):
+ CASE(OP_ARRAY, BB);
printf("OP_ARRAY\tR%d\t%d\t", a, b);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_ARRAY2, BBB):
+ CASE(OP_ARRAY2, BBB);
printf("OP_ARRAY\tR%d\tR%d\t%d\t", a, b, c);
print_lv_ab(mrb, irep, a, b);
break;
- CASE(OP_ARYCAT, B):
+ CASE(OP_ARYCAT, B);
printf("OP_ARYCAT\tR%d\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_ARYPUSH, B):
+ CASE(OP_ARYPUSH, B);
printf("OP_ARYPUSH\tR%d\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_ARYDUP, B):
+ CASE(OP_ARYDUP, B);
printf("OP_ARYDUP\tR%d\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_AREF, BBB):
+ CASE(OP_AREF, BBB);
printf("OP_AREF\tR%d\tR%d\t%d", a, b, c);
print_lv_ab(mrb, irep, a, b);
break;
- CASE(OP_ASET, BBB):
+ CASE(OP_ASET, BBB);
printf("OP_ASET\tR%d\tR%d\t%d", a, b, c);
print_lv_ab(mrb, irep, a, b);
break;
- CASE(OP_APOST, BBB):
+ CASE(OP_APOST, BBB);
printf("OP_APOST\tR%d\t%d\t%d", a, b, c);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_INTERN, B):
+ CASE(OP_INTERN, B);
printf("OP_INTERN\tR%d", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_STRING, BB):
- {
- mrb_value v = irep->pool[b];
- mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v)));
- printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s));
+ CASE(OP_STRING, BB);
+ if ((irep->pool[b].tt & IREP_TT_NFLAG) == 0) {
+ printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, irep->pool[b].u.str);
+ }
+ else {
+ printf("OP_STRING\tR%d\tL(%d)\t", a, b);
}
print_lv_a(mrb, irep, a);
break;
- CASE(OP_STRCAT, B):
+ CASE(OP_STRCAT, B);
printf("OP_STRCAT\tR%d\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_HASH, BB):
+ CASE(OP_HASH, BB);
printf("OP_HASH\tR%d\t%d\t", a, b);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_HASHADD, BB):
+ CASE(OP_HASHADD, BB);
printf("OP_HASHADD\tR%d\t%d\t", a, b);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_HASHCAT, B):
+ CASE(OP_HASHCAT, B);
printf("OP_HASHCAT\tR%d\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_OCLASS, B):
+ CASE(OP_OCLASS, B);
printf("OP_OCLASS\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_CLASS, BB):
+ CASE(OP_CLASS, BB);
printf("OP_CLASS\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_MODULE, BB):
+ CASE(OP_MODULE, BB);
printf("OP_MODULE\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
print_lv_a(mrb, irep, a);
break;
- CASE(OP_EXEC, BB):
+ CASE(OP_EXEC, BB);
printf("OP_EXEC\tR%d\tI(%d:%p)", a, b, irep->reps[b]);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_SCLASS, B):
+ CASE(OP_SCLASS, B);
printf("OP_SCLASS\tR%d\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_TCLASS, B):
+ CASE(OP_TCLASS, B);
printf("OP_TCLASS\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_ERR, B):
- {
- mrb_value v = irep->pool[a];
- mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v)));
- printf("OP_ERR\t%s\n", RSTRING_PTR(s));
+ CASE(OP_ERR, B);
+ if ((irep->pool[a].tt & IREP_TT_NFLAG) == 0) {
+ printf("OP_ERR\t%s\n", irep->pool[a].u.str);
+ }
+ else {
+ printf("OP_ERR\tL(%d)\n", a);
}
break;
- CASE(OP_EPUSH, B):
- printf("OP_EPUSH\t\t:I(%d:%p)\n", a, irep->reps[a]);
- break;
- CASE(OP_ONERR, S):
- printf("OP_ONERR\t%03d\n", a);
- break;
- CASE(OP_EXCEPT, B):
+ CASE(OP_EXCEPT, B);
printf("OP_EXCEPT\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_RESCUE, BB):
+ CASE(OP_RESCUE, BB);
printf("OP_RESCUE\tR%d\tR%d", a, b);
print_lv_ab(mrb, irep, a, b);
break;
- CASE(OP_RAISE, B):
- printf("OP_RAISE\tR%d\t\t", a);
+ CASE(OP_RAISEIF, B);
+ printf("OP_RAISEIF\tR%d\t\t", a);
print_lv_a(mrb, irep, a);
break;
- CASE(OP_POPERR, B):
- printf("OP_POPERR\t%d\t\t\n", a);
- break;
- CASE(OP_EPOP, B):
- printf("OP_EPOP\t%d\n", a);
- break;
- CASE(OP_DEBUG, BBB):
+ CASE(OP_DEBUG, BBB);
printf("OP_DEBUG\t%d\t%d\t%d\n", a, b, c);
break;
- CASE(OP_STOP, Z):
+ CASE(OP_STOP, Z);
printf("OP_STOP\n");
break;
- CASE(OP_EXT1, Z):
- ins = READ_B();
- printf("OP_EXT1\n");
- print_header(mrb, irep, pc-irep->iseq-2);
- switch (ins) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); goto L_OP_ ## i;
-#include "mruby/ops.h"
-#undef OPCODE
- }
- break;
- CASE(OP_EXT2, Z):
- ins = READ_B();
- printf("OP_EXT2\n");
- print_header(mrb, irep, pc-irep->iseq-2);
- switch (ins) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); goto L_OP_ ## i;
-#include "mruby/ops.h"
-#undef OPCODE
- }
- break;
- CASE(OP_EXT3, Z):
- ins = READ_B();
- printf("OP_EXT3\n");
- print_header(mrb, irep, pc-irep->iseq-2);
- switch (ins) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); goto L_OP_ ## i;
-#include "mruby/ops.h"
-#undef OPCODE
- }
- break;
-
default:
printf("OP_unknown (0x%x)\n", ins);
break;
@@ -533,7 +527,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
}
static void
-codedump_recur(mrb_state *mrb, mrb_irep *irep)
+codedump_recur(mrb_state *mrb, const mrb_irep *irep)
{
int i;
diff --git a/src/debug.c b/src/debug.c
index 32add68ae040d0c10e83f75f24c3f8137aed469e..dabc5a56d18f0d3a0f031cd20061ee9508959681 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -51,7 +51,7 @@ select_line_type(const uint16_t *lines, size_t lines_len)
}
MRB_API char const*
-mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc)
+mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t pc)
{
if (irep && pc >= 0 && pc < irep->ilen) {
mrb_irep_debug_info_file* f = NULL;
diff --git a/src/dump.c b/src/dump.c
index a6bbe68f30e19d45466a7a8f0d00a5999c9e533e..2bc1b0a533f98cdc01ec065cbcae761138707433 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -13,31 +13,17 @@
#include <mruby/numeric.h>
#include <mruby/debug.h>
-#ifndef MRB_WITHOUT_FLOAT
-#ifdef MRB_USE_FLOAT
-#define MRB_FLOAT_FMT "%.9g"
-#else
+#ifndef MRB_NO_FLOAT
+#include <mruby/endian.h>
#define MRB_FLOAT_FMT "%.17g"
#endif
-#endif
-static size_t get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep);
+static size_t get_irep_record_size_1(mrb_state *mrb, const mrb_irep *irep);
#if UINT32_MAX > SIZE_MAX
# error This code cannot be built on your environment.
#endif
-static size_t
-write_padding(uint8_t *buf)
-{
- const size_t align = MRB_DUMP_ALIGNMENT;
- size_t pad_len = -(intptr_t)buf & (align-1);
- if (pad_len > 0) {
- memset(buf, 0, pad_len);
- }
- return pad_len;
-}
-
static size_t
get_irep_header_size(mrb_state *mrb)
{
@@ -50,7 +36,7 @@ get_irep_header_size(mrb_state *mrb)
}
static ptrdiff_t
-write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
+write_irep_header(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
{
uint8_t *cur = buf;
@@ -64,87 +50,97 @@ write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
static size_t
-get_iseq_block_size(mrb_state *mrb, mrb_irep *irep)
+get_iseq_block_size(mrb_state *mrb, const mrb_irep *irep)
{
size_t size = 0;
- size += sizeof(uint32_t); /* ilen */
- size += sizeof(uint32_t); /* max padding */
- size += sizeof(uint32_t) * irep->ilen; /* iseq(n) */
+ size += sizeof(uint16_t); /* ilen */
+ size += irep->ilen * sizeof(mrb_code); /* iseq(n) */
return size;
}
static ptrdiff_t
-write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf, uint8_t flags)
+write_iseq_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf, uint8_t flags)
{
uint8_t *cur = buf;
- cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */
- cur += write_padding(cur);
+ cur += uint16_to_bin(irep->ilen, cur); /* number of opcode */
memcpy(cur, irep->iseq, irep->ilen * sizeof(mrb_code));
cur += irep->ilen * sizeof(mrb_code);
return cur - buf;
}
-#ifndef MRB_WITHOUT_FLOAT
-static mrb_value
-float_to_str(mrb_state *mrb, mrb_value flt)
+#ifndef MRB_NO_FLOAT
+static void
+dump_float(mrb_state *mrb, uint8_t *buf, mrb_float f)
{
- mrb_float f = mrb_float(flt);
+ /* dump IEEE754 binary in little endian */
+ union {
+ double f;
+ char s[sizeof(double)];
+ } u = {.f = (double)f};
+
+ if (littleendian) {
+ memcpy(buf, u.s, sizeof(double));
+ }
+ else {
+ size_t i;
- if (isinf(f)) {
- return f < 0 ? mrb_str_new_lit(mrb, "I") : mrb_str_new_lit(mrb, "i");
+ for (i=0; i<sizeof(double); i++) {
+ buf[i] = u.s[sizeof(double)-i-1];
+ }
}
- return mrb_float_to_str(mrb, flt, MRB_FLOAT_FMT);
}
#endif
static size_t
-get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
+get_pool_block_size(mrb_state *mrb, const mrb_irep *irep)
{
int pool_no;
size_t size = 0;
- mrb_value str;
- size += sizeof(uint32_t); /* plen */
- size += irep->plen * (sizeof(uint8_t) + sizeof(uint16_t)); /* len(n) */
+ size += sizeof(uint16_t); /* plen */
+ size += irep->plen * sizeof(uint8_t); /* len(n) */
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
int ai = mrb_gc_arena_save(mrb);
- switch (mrb_type(irep->pool[pool_no])) {
- case MRB_TT_FIXNUM:
- str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
+ switch (irep->pool[pool_no].tt) {
+ case IREP_TT_INT64:
+#ifdef MRB_64BIT
{
- mrb_int len = RSTRING_LEN(str);
- mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
- size += (size_t)len;
+ int64_t i = irep->pool[pool_no].u.i64;
+
+ if (i < INT32_MIN || INT32_MAX < i)
+ size += 8;
+ else
+ size += 4;
}
break;
+#else
+ /* fall through */
+#endif
+ case IREP_TT_INT32:
+ size += 4; /* 32bits = 4bytes */
+ break;
-#ifndef MRB_WITHOUT_FLOAT
- case MRB_TT_FLOAT:
- str = float_to_str(mrb, irep->pool[pool_no]);
+ case IREP_TT_FLOAT:
+#ifndef MRB_NO_FLOAT
{
- mrb_int len = RSTRING_LEN(str);
- mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
- size += (size_t)len;
+ size += sizeof(double);
}
- break;
#endif
+ break;
- case MRB_TT_STRING:
+ default: /* packed IREP_TT_STRING */
{
- mrb_int len = RSTRING_LEN(irep->pool[pool_no]);
+ mrb_int len = irep->pool[pool_no].tt >> 1; /* unpack length */
mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
- size += (size_t)len;
+ size += (size_t)len+1;
}
break;
-
- default:
- break;
}
mrb_gc_arena_restore(mrb, ai);
}
@@ -153,52 +149,63 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
}
static ptrdiff_t
-write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
+write_pool_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
{
int pool_no;
uint8_t *cur = buf;
- uint16_t len;
- mrb_value str;
- const char *char_ptr;
+ mrb_int len;
+ const char *ptr;
- cur += uint32_to_bin(irep->plen, cur); /* number of pool */
+ cur += uint16_to_bin(irep->plen, cur); /* number of pool */
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
int ai = mrb_gc_arena_save(mrb);
- switch (mrb_type(irep->pool[pool_no])) {
- case MRB_TT_FIXNUM:
- cur += uint8_to_bin(IREP_TT_FIXNUM, cur); /* data type */
- str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
+ switch (irep->pool[pool_no].tt) {
+#ifdef MRB_64BIT
+ case IREP_TT_INT64:
+ {
+ int64_t i = irep->pool[pool_no].u.i64;
+ if (i < INT32_MIN || INT32_MAX < i) {
+ cur += uint8_to_bin(IREP_TT_INT64, cur); /* data type */
+ cur += uint32_to_bin((uint32_t)((i>>32) & 0xffffffff), cur); /* i64 hi */
+ cur += uint32_to_bin((uint32_t)((i ) & 0xffffffff), cur); /* i64 lo */
+ }
+ else {
+ cur += uint8_to_bin(IREP_TT_INT32, cur); /* data type */
+ cur += uint32_to_bin(irep->pool[pool_no].u.i32, cur); /* i32 */
+ }
+ }
+ break;
+#endif
+ case IREP_TT_INT32:
+ cur += uint8_to_bin(IREP_TT_INT32, cur); /* data type */
+ cur += uint32_to_bin(irep->pool[pool_no].u.i32, cur); /* i32 */
break;
-#ifndef MRB_WITHOUT_FLOAT
- case MRB_TT_FLOAT:
+ case IREP_TT_FLOAT:
cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */
- str = float_to_str(mrb, irep->pool[pool_no]);
- break;
+#ifndef MRB_NO_FLOAT
+ {
+ dump_float(mrb, cur,irep->pool[pool_no].u.f);
+ cur += sizeof(double);
+ }
+#else
+ cur += uint16_to_bin(0, cur); /* zero length */
#endif
-
- case MRB_TT_STRING:
- cur += uint8_to_bin(IREP_TT_STRING, cur); /* data type */
- str = irep->pool[pool_no];
break;
- default:
- continue;
- }
-
- char_ptr = RSTRING_PTR(str);
- {
- mrb_int tlen = RSTRING_LEN(str);
- mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX);
- len = (uint16_t)tlen;
+ default: /* string */
+ cur += uint8_to_bin(IREP_TT_STR, cur); /* data type */
+ ptr = irep->pool[pool_no].u.str;
+ len = irep->pool[pool_no].tt>>2;
+ mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX);
+ cur += uint16_to_bin((uint16_t)len, cur); /* data length */
+ memcpy(cur, ptr, (size_t)len);
+ cur += len;
+ *cur++ = '\0';
+ break;
}
-
- cur += uint16_to_bin(len, cur); /* data length */
- memcpy(cur, char_ptr, (size_t)len);
- cur += len;
-
mrb_gc_arena_restore(mrb, ai);
}
@@ -207,13 +214,13 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
static size_t
-get_syms_block_size(mrb_state *mrb, mrb_irep *irep)
+get_syms_block_size(mrb_state *mrb, const mrb_irep *irep)
{
size_t size = 0;
int sym_no;
mrb_int len;
- size += sizeof(uint32_t); /* slen */
+ size += sizeof(uint16_t); /* slen */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
size += sizeof(uint16_t); /* snl(n) */
if (irep->syms[sym_no] != 0) {
@@ -226,13 +233,13 @@ get_syms_block_size(mrb_state *mrb, mrb_irep *irep)
}
static ptrdiff_t
-write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
+write_syms_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
{
int sym_no;
uint8_t *cur = buf;
const char *name;
- cur += uint32_to_bin(irep->slen, cur); /* number of symbol */
+ cur += uint16_to_bin(irep->slen, cur); /* number of symbol */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
if (irep->syms[sym_no] != 0) {
@@ -255,19 +262,46 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
}
static size_t
-get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep)
+get_catch_table_block_size(mrb_state *mrb, const mrb_irep *irep)
+{
+ size_t size = 0;
+
+ size += sizeof(uint16_t); /* number of catch handler */
+ size += (sizeof(struct mrb_irep_catch_handler)) * irep->clen;
+
+ return size;
+}
+
+static ptrdiff_t
+write_catch_table_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
+{
+ uint8_t *cur = buf;
+ const struct mrb_irep_catch_handler *e = mrb_irep_catch_handler_table(irep);
+ mrb_static_assert1(sizeof(*e) == 7);
+
+ if (e == NULL) return 0;
+ /* irep->clen has already been written before iseq block */
+ memcpy(cur, (const void *)e, sizeof(*e) * irep->clen);
+ cur += sizeof(*e) * irep->clen;
+
+ return cur - buf;
+}
+
+static size_t
+get_irep_record_size_1(mrb_state *mrb, const mrb_irep *irep)
{
size_t size = 0;
size += get_irep_header_size(mrb);
size += get_iseq_block_size(mrb, irep);
+ size += get_catch_table_block_size(mrb, irep);
size += get_pool_block_size(mrb, irep);
size += get_syms_block_size(mrb, irep);
return size;
}
static size_t
-get_irep_record_size(mrb_state *mrb, mrb_irep *irep)
+get_irep_record_size(mrb_state *mrb, const mrb_irep *irep)
{
size_t size = 0;
int irep_no;
@@ -280,7 +314,7 @@ get_irep_record_size(mrb_state *mrb, mrb_irep *irep)
}
static int
-write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags)
+write_irep_record(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags)
{
int i;
uint8_t *src = bin;
@@ -289,13 +323,14 @@ write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_rec
return MRB_DUMP_INVALID_IREP;
}
- *irep_record_size = get_irep_record_size_1(mrb, irep);
- if (*irep_record_size == 0) {
- return MRB_DUMP_GENERAL_FAILURE;
- }
-
bin += write_irep_header(mrb, irep, bin);
+ /*
+ * The catch handler table is after iseq block, but the number of
+ * elements is placed before iseq block.
+ */
+ bin += uint16_to_bin(irep->clen, bin);
bin += write_iseq_block(mrb, irep, bin, flags);
+ bin += write_catch_table_block(mrb, irep, bin);
bin += write_pool_block(mrb, irep, bin);
bin += write_syms_block(mrb, irep, bin);
@@ -341,7 +376,7 @@ write_section_irep_header(mrb_state *mrb, size_t section_size, uint8_t *bin)
}
static int
-write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *len_p, uint8_t flags)
+write_section_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, size_t *len_p, uint8_t flags)
{
int result;
size_t rsize = 0;
@@ -364,7 +399,7 @@ write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *len_p,
}
static size_t
-get_debug_record_size(mrb_state *mrb, mrb_irep *irep)
+get_debug_record_size(mrb_state *mrb, const mrb_irep *irep)
{
size_t ret = 0;
uint16_t f_idx;
@@ -413,11 +448,11 @@ find_filename_index(const mrb_sym *ary, int ary_len, mrb_sym s)
}
static size_t
-get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *lp)
+get_filename_table_size(mrb_state *mrb, const mrb_irep *irep, mrb_sym **fp, uint16_t *lp)
{
mrb_sym *filenames = *fp;
size_t size = 0;
- mrb_irep_debug_info *di = irep->debug_info;
+ const mrb_irep_debug_info *di = irep->debug_info;
int i;
mrb_assert(lp);
@@ -444,7 +479,7 @@ get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *
}
static size_t
-write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
+write_debug_record_1(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
{
uint8_t *cur;
uint16_t f_idx;
@@ -498,7 +533,7 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const
}
static size_t
-write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
+write_debug_record(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
{
size_t size, len;
int irep_no;
@@ -516,7 +551,7 @@ write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const*
}
static int
-write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len)
+write_section_debug(mrb_state *mrb, const mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len)
{
size_t section_size = 0;
const uint8_t *bin = cur;
@@ -566,7 +601,7 @@ create_lv_sym_table(mrb_state *mrb, const mrb_irep *irep, mrb_sym **syms, uint32
}
for (i = 0; i + 1 < irep->nlocals; ++i) {
- mrb_sym const name = irep->lv[i].name;
+ mrb_sym const name = irep->lv[i];
if (name == 0) continue;
if (find_filename_index(*syms, *syms_len, name) != -1) continue;
@@ -609,16 +644,14 @@ write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym c
int i;
for (i = 0; i + 1 < irep->nlocals; ++i) {
- if (irep->lv[i].name == 0) {
+ if (irep->lv[i] == 0) {
cur += uint16_to_bin(RITE_LV_NULL_MARK, cur);
- cur += uint16_to_bin(0, cur);
}
else {
- int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i].name);
+ int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i]);
mrb_assert(sym_idx != -1); /* local variable name must be in syms */
cur += uint16_to_bin(sym_idx, cur);
- cur += uint16_to_bin(irep->lv[i].r, cur);
}
}
@@ -632,12 +665,12 @@ write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym c
}
static size_t
-get_lv_record_size(mrb_state *mrb, mrb_irep *irep)
+get_lv_record_size(mrb_state *mrb, const mrb_irep *irep)
{
size_t ret = 0;
int i;
- ret += (sizeof(uint16_t) + sizeof(uint16_t)) * (irep->nlocals - 1);
+ ret += sizeof(uint16_t) * (irep->nlocals - 1);
for (i = 0; i < irep->rlen; ++i) {
ret += get_lv_record_size(mrb, irep->reps[i]);
@@ -647,7 +680,7 @@ get_lv_record_size(mrb_state *mrb, mrb_irep *irep)
}
static size_t
-get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_t syms_len)
+get_lv_section_size(mrb_state *mrb, const mrb_irep *irep, mrb_sym const *syms, uint32_t syms_len)
{
size_t ret = 0, i;
@@ -665,7 +698,7 @@ get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_
}
static int
-write_section_lv(mrb_state *mrb, mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len)
+write_section_lv(mrb_state *mrb, const mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len)
{
uint8_t *cur = start;
struct rite_section_lv_header *header;
@@ -707,7 +740,8 @@ write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8
uint32_t offset;
memcpy(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident));
- memcpy(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version));
+ memcpy(header->major_version, RITE_BINARY_MAJOR_VER, sizeof(header->major_version));
+ memcpy(header->minor_version, RITE_BINARY_MAJOR_VER, sizeof(header->minor_version));
memcpy(header->compiler_name, RITE_COMPILER_NAME, sizeof(header->compiler_name));
memcpy(header->compiler_version, RITE_COMPILER_VERSION, sizeof(header->compiler_version));
mrb_assert(binary_size <= UINT32_MAX);
@@ -721,7 +755,7 @@ write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8
}
static mrb_bool
-debug_info_defined_p(mrb_irep *irep)
+debug_info_defined_p(const mrb_irep *irep)
{
int i;
@@ -733,7 +767,7 @@ debug_info_defined_p(mrb_irep *irep)
}
static mrb_bool
-lv_defined_p(mrb_irep *irep)
+lv_defined_p(const mrb_irep *irep)
{
int i;
@@ -747,7 +781,7 @@ lv_defined_p(mrb_irep *irep)
}
static int
-dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
+dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
{
int result = MRB_DUMP_GENERAL_FAILURE;
size_t malloc_size;
@@ -835,7 +869,7 @@ error_exit:
}
int
-mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
+mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
{
return dump_irep(mrb, irep, flags, bin, bin_size);
}
@@ -843,7 +877,7 @@ mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size
#ifndef MRB_DISABLE_STDIO
int
-mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE* fp)
+mrb_dump_irep_binary(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE* fp)
{
uint8_t *bin = NULL;
size_t bin_size = 0;
@@ -865,7 +899,7 @@ mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE* fp)
}
int
-mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname)
+mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname)
{
uint8_t *bin = NULL;
size_t bin_size = 0, bin_idx = 0;
@@ -884,15 +918,8 @@ mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, con
"#ifdef __cplusplus\n"
"extern const uint8_t %s[];\n"
"#endif\n"
- "const uint8_t\n"
- "#if defined __GNUC__\n"
- "__attribute__((aligned(%u)))\n"
- "#elif defined _MSC_VER\n"
- "__declspec(align(%u))\n"
- "#endif\n"
- "%s[] = {",
- initname,
- (uint16_t)MRB_DUMP_ALIGNMENT, (uint16_t)MRB_DUMP_ALIGNMENT, initname) < 0) {
+ "const uint8_t %s[] = {",
+ initname, initname) < 0) {
mrb_free(mrb, bin);
return MRB_DUMP_WRITE_FAULT;
}
@@ -918,4 +945,171 @@ mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, con
return result;
}
+static int
+dump_pool(mrb_state *mrb, const mrb_pool_value *p, FILE *fp)
+{
+ if (p->tt & IREP_TT_NFLAG) { /* number */
+ switch (p->tt) {
+#ifdef MRB_64BIT
+ case IREP_TT_INT64:
+ if (p->u.i64 < INT32_MIN || INT32_MAX < p->u.i64) {
+ fprintf(fp, "{IREP_TT_INT64, {.i64=%" PRId64 "}},\n", p->u.i64);
+ }
+ else {
+ fprintf(fp, "{IREP_TT_INT32, {.i32=%" PRId32 "}},\n", (int32_t)p->u.i64);
+ }
+ break;
+#endif
+ case IREP_TT_INT32:
+ fprintf(fp, "{IREP_TT_INT32, {.i32=%" PRId32 "}},\n", p->u.i32);
+ break;
+ case IREP_TT_FLOAT:
+ if (p->u.f == 0) {
+ fprintf(fp, "{IREP_TT_FLOAT, {.f=%#.1f}},\n", p->u.f);
+ }
+ else {
+ fprintf(fp, "{IREP_TT_FLOAT, {.f=" MRB_FLOAT_FMT "}},\n", p->u.f);
+ }
+ break;
+ }
+ }
+ else { /* string */
+ int i, len = p->tt>>2;
+ const char *s = p->u.str;
+ fprintf(fp, "{IREP_TT_STR|(%d<<2), {\"", len);
+ for (i=0; i<len; i++) {
+ fprintf(fp, "\\x%02x", (int)s[i]&0xff);
+ }
+ fputs("\"}},\n", fp);
+ }
+ return MRB_DUMP_OK;
+}
+
+mrb_bool mrb_sym_static_p(mrb_state *mrb, mrb_sym sym);
+
+static int
+dump_sym(mrb_state *mrb, mrb_sym sym, FILE *fp)
+{
+ const char *name;
+ if (sym == 0) return MRB_DUMP_INVALID_ARGUMENT;
+ name = mrb_sym_name(mrb, sym);
+ if (!name) {
+ fprintf(stderr, "undefined symbol (%d) - define presym\n", sym);
+ }
+ if (!mrb_sym_static_p(mrb, sym)) {
+ fprintf(stderr, "no static symbol (%s) - define presym\n", name);
+ }
+ fprintf(fp, "%d /* %s */,", sym, name);
+ return MRB_DUMP_OK;
+}
+
+static int
+dump_irep_struct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *name, int n, int *mp)
+{
+ int i, len;
+ int max = *mp;
+
+ /* dump reps */
+ if (irep->reps) {
+ for (i=0,len=irep->rlen; i<len; i++) {
+ *mp += len;
+ if (dump_irep_struct(mrb, irep->reps[i], flags, fp, name, max+i, mp) != MRB_DUMP_OK)
+ return MRB_DUMP_INVALID_ARGUMENT;
+ }
+ fprintf(fp, "static const mrb_irep *%s_reps_%d[%d] = {\n", name, n, len);
+ for (i=0,len=irep->rlen; i<len; i++) {
+ fprintf(fp, " &%s_irep_%d,\n", name, max+i);
+ }
+ fputs("};\n", fp);
+ }
+ /* dump pool */
+ if (irep->pool) {
+ len=irep->plen;
+ fprintf(fp, "static const mrb_pool_value %s_pool_%d[%d] = {\n", name, n, len);
+ for (i=0; i<len; i++) {
+ if (dump_pool(mrb, &irep->pool[i], fp) != MRB_DUMP_OK)
+ return MRB_DUMP_INVALID_ARGUMENT;
+ }
+ fputs("};\n", fp);
+ }
+ /* dump syms */
+ if (irep->syms) {
+ len=irep->slen;
+ fprintf(fp, "static const mrb_sym %s_syms_%d[%d] = {", name, n, len);
+ for (i=0; i<len; i++) {
+ dump_sym(mrb, irep->syms[i], fp);
+ }
+ fputs("};\n", fp);
+ }
+ /* dump iseq */
+ len=irep->ilen+sizeof(struct mrb_irep_catch_handler)*irep->clen;
+ fprintf(fp, "static const mrb_code %s_iseq_%d[%d] = {", name, n, len);
+ for (i=0; i<len; i++) {
+ if (i%20 == 0) fputs("\n", fp);
+ fprintf(fp, "0x%02x,", irep->iseq[i]);
+ }
+ fputs("};\n", fp);
+ /* dump lv */
+ if (irep->lv) {
+ len=irep->nlocals;
+ fprintf(fp, "static const mrb_sym %s_lv_%d[%d] = {", name, n, len);
+ for (i=0; i+1<len; i++) {
+ fprintf(fp, "%uU, ", irep->lv[i]);
+ }
+ fputs("};\n", fp);
+ }
+ /* dump irep */
+ fprintf(fp, "static const mrb_irep %s_irep_%d = {\n", name, n);
+ fprintf(fp, " %d,%d,%d,\n", irep->nlocals, irep->nregs, irep->clen);
+ fprintf(fp, " MRB_IREP_STATIC,%s_iseq_%d,\n", name, n);
+ if (irep->pool) {
+ fprintf(fp, " %s_pool_%d,", name, n);
+ }
+ else {
+ fputs( " NULL,", fp);
+ }
+ if (irep->syms) {
+ fprintf(fp, "%s_syms_%d,", name, n);
+ }
+ else {
+ fputs( "NULL,", fp);
+ }
+ if (irep->reps) {
+ fprintf(fp, "%s_reps_%d,\n", name, n);
+ }
+ else {
+ fputs( "NULL,\n", fp);
+ }
+ if (irep->lv) {
+ fprintf(fp, " %s_lv_%d,\n", name, n);
+ }
+ else {
+ fputs( " NULL,\t\t\t\t\t/* lv */\n", fp);
+ }
+ fputs( " NULL,\t\t\t\t\t/* debug_info */\n", fp);
+ fprintf(fp, " %d,%d,%d,%d,0\n};\n", irep->ilen, irep->plen, irep->slen, irep->rlen);
+
+ return MRB_DUMP_OK;
+}
+
+int
+mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname)
+{
+ int max = 1;
+ int n;
+
+ if (fp == NULL || initname == NULL || initname[0] == '\0') {
+ return MRB_DUMP_INVALID_ARGUMENT;
+ }
+ if (fprintf(fp, "#include <mruby.h>\n" "#include <mruby/proc.h>\n\n") < 0) {
+ return MRB_DUMP_WRITE_FAULT;
+ }
+ n = dump_irep_struct(mrb, irep, flags, fp, initname, 0, &max);
+ if (n != MRB_DUMP_OK) return n;
+ fprintf(fp, "#ifdef __cplusplus\nextern const struct RProc %s[];\n#endif\n", initname);
+ fprintf(fp, "const struct RProc %s[] = {{\n", initname);
+ fprintf(fp, "NULL,NULL,MRB_TT_PROC,7,0,{&%s_irep_0},NULL,{NULL},\n}};\n", initname);
+ return MRB_DUMP_OK;
+}
+
#endif /* MRB_DISABLE_STDIO */
diff --git a/src/enum.c b/src/enum.c
index d313701889cf08348dde817e311b2c8d6840de89..b9595671508730994b4f354272883aad6b7eb51a 100644
--- a/src/enum.c
+++ b/src/enum.c
@@ -18,7 +18,7 @@ enum_update_hash(mrb_state *mrb, mrb_value self)
mrb_get_args(mrb, "iii", &hash, &index, &hv);
hash ^= ((uint32_t)hv << (index % 16));
- return mrb_fixnum_value(hash);
+ return mrb_int_value(mrb, hash);
}
void
diff --git a/src/error.c b/src/error.c
index 5d17209e5f77d9c0b6b94f7be2f5a62de8de5ec0..b19f0ea431fed6e04d280a80ddaff2634ef2c2a6 100644
--- a/src/error.c
+++ b/src/error.c
@@ -45,7 +45,7 @@ exc_initialize(mrb_state *mrb, mrb_value exc)
mrb_value mesg;
if (mrb_get_args(mrb, "|o", &mesg) == 1) {
- mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), mesg);
+ mrb_iv_set(mrb, exc, MRB_SYM(mesg), mesg);
}
return exc;
}
@@ -74,7 +74,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);
- mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), a);
+ mrb_iv_set(mrb, exc, MRB_SYM(mesg), a);
return exc;
}
@@ -90,7 +90,7 @@ exc_exception(mrb_state *mrb, mrb_value self)
mrb_value
exc_to_s(mrb_state *mrb, mrb_value exc)
{
- mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg"));
+ mrb_value mesg = mrb_attr_get(mrb, exc, MRB_SYM(mesg));
struct RObject *p;
if (!mrb_string_p(mesg)) {
@@ -114,7 +114,7 @@ exc_to_s(mrb_state *mrb, mrb_value exc)
static mrb_value
exc_message(mrb_state *mrb, mrb_value exc)
{
- return mrb_funcall(mrb, exc, "to_s", 0);
+ return mrb_funcall_id(mrb, exc, MRB_SYM(to_s), 0);
}
/*
@@ -130,7 +130,7 @@ exc_message(mrb_state *mrb, mrb_value exc)
mrb_value
mrb_exc_inspect(mrb_state *mrb, mrb_value exc)
{
- mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg"));
+ mrb_value mesg = mrb_attr_get(mrb, exc, MRB_SYM(mesg));
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);
@@ -154,7 +154,7 @@ set_backtrace(mrb_state *mrb, mrb_value exc, mrb_value backtrace)
p++;
}
}
- mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "backtrace"), backtrace);
+ mrb_iv_set(mrb, exc, MRB_SYM(backtrace), backtrace);
}
static mrb_value
@@ -288,7 +288,7 @@ mrb_vformat(mrb_state *mrb, const char *format, va_list ap)
#endif
obj = mrb_fixnum_value(i);
goto L_cat_obj;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case 'f':
obj = mrb_float_value(mrb, (mrb_float)va_arg(ap, double));
goto L_cat_obj;
@@ -474,7 +474,7 @@ mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv)
n = 1;
exception_call:
{
- mrb_sym exc = mrb_intern_lit(mrb, "exception");
+ mrb_sym exc = MRB_SYM(exception);
if (mrb_respond_to(mrb, argv[0], exc)) {
mesg = mrb_funcall_argv(mrb, argv[0], exc, n, argv+1);
}
@@ -622,11 +622,11 @@ mrb_init_exception(mrb_state *mrb)
script_error = mrb_define_class(mrb, "ScriptError", mrb->eException_class); /* 15.2.37 */
mrb_define_class(mrb, "SyntaxError", script_error); /* 15.2.38 */
stack_error = mrb_define_class(mrb, "SystemStackError", exception);
- mrb->stack_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, stack_error, "stack level too deep"));
+ mrb->stack_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, stack_error, "stack level too deep"));
nomem_error = mrb_define_class(mrb, "NoMemoryError", exception);
- mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, nomem_error, "Out of memory"));
+ mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "Out of memory"));
#ifdef MRB_GC_FIXED_ARENA
- mrb->arena_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, nomem_error, "arena overflow error"));
+ mrb->arena_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "arena overflow error"));
#endif
}
diff --git a/src/etc.c b/src/etc.c
index 74b9ab03b623e558b1789dbc7c4c9c53c658ad83..96f95ad5f77241470d2851cb5b03a3860f597ebe 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -8,6 +8,7 @@
#include <mruby/string.h>
#include <mruby/data.h>
#include <mruby/class.h>
+#include <mruby/numeric.h>
MRB_API struct RData*
mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const mrb_data_type *type)
@@ -69,21 +70,11 @@ mrb_obj_to_sym(mrb_state *mrb, mrb_value name)
return 0; /* not reached */
}
-MRB_API mrb_int
-#ifdef MRB_WITHOUT_FLOAT
-mrb_fixnum_id(mrb_int f)
-#else
-mrb_float_id(mrb_float f)
-#endif
+static mrb_int
+make_num_id(const char *p, size_t len)
{
- const char *p = (const char*)&f;
- int len = sizeof(f);
uint32_t id = 0;
-#ifndef MRB_WITHOUT_FLOAT
- /* normalize -0.0 to 0.0 */
- if (f == 0) f = 0.0;
-#endif
while (len--) {
id = id*65599 + *p;
p++;
@@ -93,6 +84,22 @@ mrb_float_id(mrb_float f)
return (mrb_int)id;
}
+MRB_API mrb_int
+mrb_int_id(mrb_int n)
+{
+ return make_num_id((const char*)&n, sizeof(n));
+}
+
+#ifndef MRB_NO_FLOAT
+MRB_API mrb_int
+mrb_float_id(mrb_float f)
+{
+ /* normalize -0.0 to 0.0 */
+ if (f == 0) f = 0.0;
+ return make_num_id((const char*)&f, sizeof(f));
+}
+#endif
+
MRB_API mrb_int
mrb_obj_id(mrb_value obj)
{
@@ -114,11 +121,9 @@ mrb_obj_id(mrb_value obj)
return MakeID(2);
case MRB_TT_SYMBOL:
return MakeID(mrb_symbol(obj));
- case MRB_TT_FIXNUM:
-#ifdef MRB_WITHOUT_FLOAT
- return MakeID(mrb_fixnum_id(mrb_fixnum(obj)));
-#else
- return MakeID2(mrb_float_id((mrb_float)mrb_fixnum(obj)), MRB_TT_FLOAT);
+ case MRB_TT_INTEGER:
+ return MakeID(mrb_int_id(mrb_integer(obj)));
+#ifdef MRB_NO_FLOAT
case MRB_TT_FLOAT:
return MakeID(mrb_float_id(mrb_float(obj)));
#endif
@@ -147,29 +152,32 @@ mrb_obj_id(mrb_value obj)
#ifdef MRB_WORD_BOXING
#define mrb_xxx_boxing_cptr_value mrb_word_boxing_cptr_value
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
MRB_API mrb_value
mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f)
{
- mrb_value v;
+ union mrb_value_ v;
- v.value.p = mrb_obj_alloc(mrb, MRB_TT_FLOAT, mrb->float_class);
- v.value.fp->f = f;
- MRB_SET_FROZEN_FLAG(v.value.bp);
- return v;
+ v.p = mrb_obj_alloc(mrb, MRB_TT_FLOAT, mrb->float_class);
+ v.fp->f = f;
+ MRB_SET_FROZEN_FLAG(v.bp);
+ return v.w;
}
+#endif /* MRB_NO_FLOAT */
MRB_API mrb_value
-mrb_word_boxing_float_pool(mrb_state *mrb, mrb_float f)
+mrb_word_boxing_int_value(mrb_state *mrb, mrb_int n)
{
- struct RFloat *nf = (struct RFloat *)mrb_malloc(mrb, sizeof(struct RFloat));
- nf->tt = MRB_TT_FLOAT;
- nf->c = mrb->float_class;
- nf->f = f;
- MRB_SET_FROZEN_FLAG(nf);
- return mrb_obj_value(nf);
+ if (FIXABLE(n)) return mrb_fixnum_value(n);
+ else {
+ union mrb_value_ v;
+
+ v.p = mrb_obj_alloc(mrb, MRB_TT_INTEGER, mrb->integer_class);
+ v.ip->i = n;
+ MRB_SET_FROZEN_FLAG(v.ip);
+ return v.w;
+ }
}
-#endif /* MRB_WITHOUT_FLOAT */
#endif /* MRB_WORD_BOXING */
#if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT))
diff --git a/src/fmt_fp.c b/src/fmt_fp.c
index 81ace6ec8f80d77d840bd3f401416ef95da94590..2c1e13c3684f9dc4bb46b2d60dd53713aa2f8479 100644
--- a/src/fmt_fp.c
+++ b/src/fmt_fp.c
@@ -1,4 +1,4 @@
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#if defined(MRB_DISABLE_STDIO) || defined(_WIN32) || defined(_WIN64)
/*
diff --git a/src/gc.c b/src/gc.c
index 5531207db2884eb8ec20f6e9e5e41f59a0a23ec7..0f2c3bfab808b86484547c32892f8b16d7c5d0c2 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -6,6 +6,9 @@
#include <string.h>
#include <stdlib.h>
+#ifdef MRB_USE_MALLOC_TRIM
+#include <malloc.h>
+#endif
#include <mruby.h>
#include <mruby/array.h>
#include <mruby/class.h>
@@ -35,6 +38,11 @@
* Gray - Marked, But the child objects are unmarked.
* Black - Marked, the child objects are also marked.
+ Extra color
+
+ * Red - Static (ROM object) no need to be collected.
+ - All child objects should be Red as well.
+
== Two White Types
There're two white color types in a flip-flop fashion: White-A and White-B,
@@ -117,7 +125,7 @@ typedef struct {
struct RException exc;
struct RBreak brk;
#ifdef MRB_WORD_BOXING
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
struct RFloat floatv;
#endif
struct RCptr cptr;
@@ -185,6 +193,7 @@ gettimeofday_time(void)
#define GC_WHITE_A 1
#define GC_WHITE_B (1 << 1)
#define GC_BLACK (1 << 2)
+#define GC_RED 7
#define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
#define GC_COLOR_MASK 7
@@ -194,7 +203,8 @@ gettimeofday_time(void)
#define paint_partial_white(s, o) ((o)->color = (s)->current_white_part)
#define is_gray(o) ((o)->color == GC_GRAY)
#define is_white(o) ((o)->color & GC_WHITES)
-#define is_black(o) ((o)->color & GC_BLACK)
+#define is_black(o) ((o)->color == GC_BLACK)
+#define is_red(o) ((o)->color == GC_RED)
#define flip_white_part(s) ((s)->current_white_part = other_white_part(s))
#define other_white_part(s) ((s)->current_white_part ^ GC_WHITES)
#define is_dead(s, o) (((o)->color & other_white_part(s) & GC_WHITES) || (o)->tt == MRB_TT_FREE)
@@ -581,11 +591,11 @@ add_gray_list(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
gc->gray_list = obj;
}
-static int
+static mrb_int
ci_nregs(mrb_callinfo *ci)
{
- struct RProc *p = ci->proc;
- int n = 0;
+ const struct RProc *p = ci->proc;
+ mrb_int n = 0;
if (!p) {
if (ci->argc < 0) return 3;
@@ -633,7 +643,6 @@ mark_context_stack(mrb_state *mrb, struct mrb_context *c)
static void
mark_context(mrb_state *mrb, struct mrb_context *c)
{
- int i;
mrb_callinfo *ci;
start:
@@ -650,10 +659,6 @@ mark_context(mrb_state *mrb, struct mrb_context *c)
mrb_gc_mark(mrb, (struct RBasic*)ci->target_class);
}
}
- /* mark ensure stack */
- for (i=0; i<c->eidx; i++) {
- mrb_gc_mark(mrb, (struct RBasic*)c->ensure[i]);
- }
/* mark fibers */
mrb_gc_mark(mrb, (struct RBasic*)c->fib);
if (c->prev) {
@@ -765,6 +770,7 @@ mrb_gc_mark(mrb_state *mrb, struct RBasic *obj)
{
if (obj == 0) return;
if (!is_white(obj)) return;
+ if (is_red(obj)) return;
mrb_assert((obj)->tt != MRB_TT_FREE);
add_gray_list(mrb, &mrb->gc, obj);
}
@@ -776,12 +782,12 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end)
switch (obj->tt) {
/* immediate - no mark */
case MRB_TT_TRUE:
- case MRB_TT_FIXNUM:
+ case MRB_TT_INTEGER:
case MRB_TT_SYMBOL:
/* cannot happen */
return;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
#ifdef MRB_WORD_BOXING
break;
@@ -803,12 +809,14 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end)
case MRB_TT_SCLASS:
mrb_gc_free_mt(mrb, (struct RClass*)obj);
mrb_gc_free_iv(mrb, (struct RObject*)obj);
- mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
+ if (!end)
+ mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
break;
case MRB_TT_ICLASS:
if (MRB_FLAG_TEST(obj, MRB_FL_CLASS_IS_ORIGIN))
mrb_gc_free_mt(mrb, (struct RClass*)obj);
- mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
+ if (!end)
+ mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
break;
case MRB_TT_ENV:
{
@@ -868,7 +876,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end)
struct RProc *p = (struct RProc*)obj;
if (!MRB_PROC_CFUNC_P(p) && p->body.irep) {
- mrb_irep *irep = p->body.irep;
+ mrb_irep *irep = (mrb_irep*)p->body.irep;
if (end) {
mrb_irep_cutref(mrb, irep);
}
@@ -924,10 +932,10 @@ root_scan_phase(mrb_state *mrb, mrb_gc *gc)
mrb_gc_mark(mrb, (struct RBasic*)mrb->hash_class);
mrb_gc_mark(mrb, (struct RBasic*)mrb->range_class);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
mrb_gc_mark(mrb, (struct RBasic*)mrb->float_class);
#endif
- mrb_gc_mark(mrb, (struct RBasic*)mrb->fixnum_class);
+ mrb_gc_mark(mrb, (struct RBasic*)mrb->integer_class);
mrb_gc_mark(mrb, (struct RBasic*)mrb->true_class);
mrb_gc_mark(mrb, (struct RBasic*)mrb->false_class);
mrb_gc_mark(mrb, (struct RBasic*)mrb->nil_class);
@@ -1004,9 +1012,6 @@ gc_gray_counts(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
if (c->stbase + i > c->stend) i = c->stend - c->stbase;
children += i;
- /* mark ensure stack */
- children += c->eidx;
-
/* mark closure */
if (c->cibase) {
for (i=0, ci = c->cibase; ci <= c->ci; i++, ci++)
@@ -1317,6 +1322,9 @@ mrb_full_gc(mrb_state *mrb)
gc->full = FALSE;
}
+#ifdef MRB_USE_MALLOC_TRIM
+ malloc_trim(0);
+#endif
GC_TIME_STOP_AND_REPORT;
}
diff --git a/src/hash.c b/src/hash.c
index c891e1b22b7d2e2a22fa2d2ed3e8814c8c1812f8..d67fa625470fa3977286377ba36bb032926bafda 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -11,7 +11,7 @@
#include <mruby/string.h>
#include <mruby/variable.h>
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/* a function to get hash value of a float number */
mrb_int mrb_float_id(mrb_float f);
#endif
@@ -64,16 +64,16 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key)
case MRB_TT_TRUE:
case MRB_TT_FALSE:
case MRB_TT_SYMBOL:
- case MRB_TT_FIXNUM:
-#ifndef MRB_WITHOUT_FLOAT
+ case MRB_TT_INTEGER:
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
#endif
h = (size_t)mrb_obj_id(key);
break;
default:
- hv = mrb_funcall(mrb, key, "hash", 0);
- h = (size_t)tt ^ (size_t)mrb_fixnum(hv);
+ hv = mrb_funcall_id(mrb, key, MRB_SYM(hash), 0);
+ h = (size_t)tt ^ (size_t)mrb_integer(hv);
break;
}
if (index && (index != t->index || capa != index->capa)) {
@@ -95,28 +95,14 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b)
if (!mrb_symbol_p(b)) return FALSE;
return mrb_symbol(a) == mrb_symbol(b);
- case MRB_TT_FIXNUM:
- switch (mrb_type(b)) {
- case MRB_TT_FIXNUM:
- return mrb_fixnum(a) == mrb_fixnum(b);
-#ifndef MRB_WITHOUT_FLOAT
- case MRB_TT_FLOAT:
- return (mrb_float)mrb_fixnum(a) == mrb_float(b);
-#endif
- default:
- return FALSE;
- }
+ case MRB_TT_INTEGER:
+ if (!mrb_integer_p(b)) return FALSE;
+ return mrb_integer(a) == mrb_integer(b);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
- switch (mrb_type(b)) {
- case MRB_TT_FIXNUM:
- return mrb_float(a) == (mrb_float)mrb_fixnum(b);
- case MRB_TT_FLOAT:
- return mrb_float(a) == mrb_float(b);
- default:
- return FALSE;
- }
+ if (!mrb_float_p(b)) return FALSE;
+ return mrb_float(a) == mrb_float(b);
#endif
default:
@@ -589,7 +575,7 @@ ht_free(mrb_state *mrb, htable *t)
mrb_free(mrb, t);
}
-static void mrb_hash_modify(mrb_state *mrb, mrb_value hash);
+static void hash_modify(mrb_state *mrb, mrb_value hash);
static inline mrb_value
ht_key(mrb_state *mrb, mrb_value key)
@@ -683,7 +669,7 @@ mrb_hash_init_copy(mrb_state *mrb, mrb_value self)
vret = mrb_obj_value(copy);
ifnone = RHASH_IFNONE(self);
if (!mrb_nil_p(ifnone)) {
- mrb_iv_set(mrb, vret, mrb_intern_lit(mrb, "ifnone"), ifnone);
+ mrb_iv_set(mrb, vret, MRB_SYM(ifnone), ifnone);
}
return vret;
}
@@ -729,7 +715,7 @@ mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
return val;
}
- mid = mrb_intern_lit(mrb, "default");
+ mid = MRB_SYM(default);
if (mrb_func_basic_p(mrb, hash, mid, mrb_hash_default)) {
return hash_default(mrb, hash, key);
}
@@ -752,7 +738,7 @@ mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def)
MRB_API void
mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val)
{
- mrb_hash_modify(mrb, hash);
+ hash_modify(mrb, hash);
key = KEY(key);
ht_put(mrb, RHASH_TBL(hash), key, val);
@@ -762,7 +748,7 @@ mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val)
}
static void
-mrb_hash_modify(mrb_state *mrb, mrb_value hash)
+hash_modify(mrb_state *mrb, mrb_value hash)
{
mrb_check_frozen(mrb, mrb_hash_ptr(hash));
if (!RHASH_TBL(hash)) {
@@ -814,7 +800,7 @@ mrb_hash_init(mrb_state *mrb, mrb_value hash)
ifnone = mrb_nil_value();
mrb_get_args(mrb, "&|o?", &block, &ifnone, &ifnone_p);
- mrb_hash_modify(mrb, hash);
+ hash_modify(mrb, hash);
if (!mrb_nil_p(block)) {
if (ifnone_p) {
mrb_argnum_error(mrb, 1, 0, 0);
@@ -824,7 +810,7 @@ mrb_hash_init(mrb_state *mrb, mrb_value hash)
}
if (!mrb_nil_p(ifnone)) {
RHASH(hash)->flags |= MRB_HASH_DEFAULT;
- mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
+ mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone);
}
return hash;
}
@@ -856,7 +842,7 @@ hash_default(mrb_state *mrb, mrb_value hash, mrb_value key)
{
if (MRB_RHASH_DEFAULT_P(hash)) {
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
- return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
+ return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, key);
}
else {
return RHASH_IFNONE(hash);
@@ -897,7 +883,7 @@ mrb_hash_default(mrb_state *mrb, mrb_value hash)
if (MRB_RHASH_DEFAULT_P(hash)) {
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
if (!given) return mrb_nil_value();
- return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
+ return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, key);
}
else {
return RHASH_IFNONE(hash);
@@ -932,8 +918,8 @@ mrb_hash_set_default(mrb_state *mrb, mrb_value hash)
{
mrb_value ifnone = mrb_get_arg1(mrb);
- mrb_hash_modify(mrb, hash);
- mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
+ hash_modify(mrb, hash);
+ mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone);
RHASH(hash)->flags &= ~MRB_HASH_PROC_DEFAULT;
if (!mrb_nil_p(ifnone)) {
RHASH(hash)->flags |= MRB_HASH_DEFAULT;
@@ -987,8 +973,8 @@ mrb_hash_set_default_proc(mrb_state *mrb, mrb_value hash)
{
mrb_value ifnone = mrb_get_arg1(mrb);
- mrb_hash_modify(mrb, hash);
- mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
+ hash_modify(mrb, hash);
+ mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone);
if (!mrb_nil_p(ifnone)) {
RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT;
RHASH(hash)->flags |= MRB_HASH_DEFAULT;
@@ -1020,7 +1006,7 @@ mrb_hash_delete(mrb_state *mrb, mrb_value self)
{
mrb_value key = mrb_get_arg1(mrb);
- mrb_hash_modify(mrb, self);
+ hash_modify(mrb, self);
return mrb_hash_delete_key(mrb, self, key);
}
@@ -1070,7 +1056,7 @@ mrb_hash_shift(mrb_state *mrb, mrb_value hash)
{
htable *t = RHASH_TBL(hash);
- mrb_hash_modify(mrb, hash);
+ hash_modify(mrb, hash);
if (t && t->size > 0) {
mrb_value del_key = mrb_nil_value();
mrb_value del_val = mrb_nil_value();
@@ -1083,7 +1069,7 @@ mrb_hash_shift(mrb_state *mrb, mrb_value hash)
if (MRB_RHASH_DEFAULT_P(hash)) {
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
- return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, mrb_nil_value());
+ return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, mrb_nil_value());
}
else {
return RHASH_IFNONE(hash);
@@ -1109,7 +1095,7 @@ mrb_hash_clear(mrb_state *mrb, mrb_value hash)
{
htable *t = RHASH_TBL(hash);
- mrb_hash_modify(mrb, hash);
+ hash_modify(mrb, hash);
if (t) {
ht_free(mrb, t);
RHASH_TBL(hash) = NULL;
@@ -1368,7 +1354,7 @@ mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2)
{
htable *h1, *h2;
- mrb_hash_modify(mrb, hash1);
+ hash_modify(mrb, hash1);
hash2 = mrb_ensure_hash_type(mrb, hash2);
h1 = RHASH_TBL(hash1);
h2 = RHASH_TBL(hash2);
diff --git a/src/kernel.c b/src/kernel.c
index 10ed9f88ebb556f65a3de0b79ff5381a56ed7bc9..c34d0bb6e88afe23c95bebabec9a2a4ac94e3481 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -19,7 +19,7 @@ mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func)
{
struct RClass *c = mrb_class(mrb, obj);
mrb_method_t m = mrb_method_search_vm(mrb, &c, mid);
- struct RProc *p;
+ const struct RProc *p;
if (MRB_METHOD_UNDEF_P(m)) return FALSE;
if (MRB_METHOD_FUNC_P(m))
@@ -33,7 +33,7 @@ mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func)
static mrb_bool
mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj)
{
- return mrb_func_basic_p(mrb, obj, mrb_intern_lit(mrb, "to_s"), mrb_any_to_s);
+ return mrb_func_basic_p(mrb, obj, MRB_SYM(to_s), mrb_any_to_s);
}
/* 15.3.1.3.17 */
@@ -96,7 +96,7 @@ mrb_equal_m(mrb_state *mrb, mrb_value self)
mrb_value
mrb_obj_id_m(mrb_state *mrb, mrb_value self)
{
- return mrb_fixnum_value(mrb_obj_id(self));
+ return mrb_int_value(mrb, mrb_obj_id(self));
}
static int
@@ -143,7 +143,7 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
mrb_value *bp;
int bidx;
struct REnv *e = NULL;
- struct RProc *p;
+ const struct RProc *p;
if (ci <= cibase) {
/* toplevel does not have block */
@@ -209,7 +209,7 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
* called with an explicit receiver, as <code>class</code> is also a
* reserved word in Ruby.
*
- * 1.class #=> Fixnum
+ * 1.class #=> Integer
* self.class #=> Object
*/
static mrb_value
@@ -218,187 +218,6 @@ mrb_obj_class_m(mrb_state *mrb, mrb_value self)
return mrb_obj_value(mrb_obj_class(mrb, self));
}
-static struct RClass*
-mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
-{
- struct RClass *klass = mrb_basic_ptr(obj)->c;
-
- if (klass->tt != MRB_TT_SCLASS)
- return klass;
- else {
- /* copy singleton(unnamed) class */
- struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class);
-
- switch (mrb_type(obj)) {
- case MRB_TT_CLASS:
- case MRB_TT_SCLASS:
- break;
- default:
- clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
- break;
- }
- clone->super = klass->super;
- if (klass->iv) {
- mrb_iv_copy(mrb, mrb_obj_value(clone), mrb_obj_value(klass));
- mrb_obj_iv_set(mrb, (struct RObject*)clone, mrb_intern_lit(mrb, "__attached__"), obj);
- }
- if (klass->mt) {
- clone->mt = kh_copy(mt, mrb, klass->mt);
- }
- else {
- clone->mt = kh_init(mt, mrb);
- }
- clone->tt = MRB_TT_SCLASS;
- return clone;
- }
-}
-
-static void
-copy_class(mrb_state *mrb, mrb_value dst, mrb_value src)
-{
- struct RClass *dc = mrb_class_ptr(dst);
- struct RClass *sc = mrb_class_ptr(src);
- /* if the origin is not the same as the class, then the origin and
- the current class need to be copied */
- if (sc->flags & MRB_FL_CLASS_IS_PREPENDED) {
- struct RClass *c0 = sc->super;
- struct RClass *c1 = dc;
-
- /* copy prepended iclasses */
- while (!(c0->flags & MRB_FL_CLASS_IS_ORIGIN)) {
- c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
- c1 = c1->super;
- c0 = c0->super;
- }
- c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
- c1->super->flags |= MRB_FL_CLASS_IS_ORIGIN;
- }
- if (sc->mt) {
- dc->mt = kh_copy(mt, mrb, sc->mt);
- }
- else {
- dc->mt = kh_init(mt, mrb);
- }
- dc->super = sc->super;
- MRB_SET_INSTANCE_TT(dc, MRB_INSTANCE_TT(sc));
-}
-
-static void
-init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
-{
- switch (mrb_type(obj)) {
- case MRB_TT_ICLASS:
- copy_class(mrb, dest, obj);
- return;
- case MRB_TT_CLASS:
- case MRB_TT_MODULE:
- copy_class(mrb, dest, obj);
- mrb_iv_copy(mrb, dest, obj);
- mrb_iv_remove(mrb, dest, mrb_intern_lit(mrb, "__classname__"));
- break;
- case MRB_TT_OBJECT:
- case MRB_TT_SCLASS:
- case MRB_TT_HASH:
- case MRB_TT_DATA:
- case MRB_TT_EXCEPTION:
- mrb_iv_copy(mrb, dest, obj);
- break;
- case MRB_TT_ISTRUCT:
- mrb_istruct_copy(dest, obj);
- break;
-
- default:
- break;
- }
- mrb_funcall(mrb, dest, "initialize_copy", 1, obj);
-}
-
-/* 15.3.1.3.8 */
-/*
- * call-seq:
- * obj.clone -> an_object
- *
- * Produces a shallow copy of <i>obj</i>---the instance variables of
- * <i>obj</i> are copied, but not the objects they reference. Copies
- * the frozen state of <i>obj</i>. See also the discussion
- * under <code>Object#dup</code>.
- *
- * class Klass
- * attr_accessor :str
- * end
- * s1 = Klass.new #=> #<Klass:0x401b3a38>
- * s1.str = "Hello" #=> "Hello"
- * s2 = s1.clone #=> #<Klass:0x401b3998 @str="Hello">
- * s2.str[1,4] = "i" #=> "i"
- * s1.inspect #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
- * s2.inspect #=> "#<Klass:0x401b3998 @str=\"Hi\">"
- *
- * This method may have class-specific behavior. If so, that
- * behavior will be documented under the #+initialize_copy+ method of
- * the class.
- *
- * Some Class(True False Nil Symbol Fixnum Float) Object cannot clone.
- */
-MRB_API mrb_value
-mrb_obj_clone(mrb_state *mrb, mrb_value self)
-{
- struct RObject *p;
- mrb_value clone;
-
- if (mrb_immediate_p(self)) {
- return self;
- }
- if (mrb_sclass_p(self)) {
- mrb_raise(mrb, E_TYPE_ERROR, "can't clone singleton class");
- }
- p = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self));
- p->c = mrb_singleton_class_clone(mrb, self);
- mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)p->c);
- clone = mrb_obj_value(p);
- init_copy(mrb, clone, self);
- p->flags |= mrb_obj_ptr(self)->flags & MRB_FL_OBJ_IS_FROZEN;
-
- return clone;
-}
-
-/* 15.3.1.3.9 */
-/*
- * call-seq:
- * obj.dup -> an_object
- *
- * Produces a shallow copy of <i>obj</i>---the instance variables of
- * <i>obj</i> are copied, but not the objects they reference.
- * <code>dup</code> copies the frozen state of <i>obj</i>. See also
- * the discussion under <code>Object#clone</code>. In general,
- * <code>clone</code> and <code>dup</code> may have different semantics
- * in descendant classes. While <code>clone</code> is used to duplicate
- * an object, including its internal state, <code>dup</code> typically
- * uses the class of the descendant object to create the new instance.
- *
- * This method may have class-specific behavior. If so, that
- * behavior will be documented under the #+initialize_copy+ method of
- * the class.
- */
-
-MRB_API mrb_value
-mrb_obj_dup(mrb_state *mrb, mrb_value obj)
-{
- struct RBasic *p;
- mrb_value dup;
-
- if (mrb_immediate_p(obj)) {
- return obj;
- }
- if (mrb_sclass_p(obj)) {
- mrb_raise(mrb, E_TYPE_ERROR, "can't dup singleton class");
- }
- p = mrb_obj_alloc(mrb, mrb_type(obj), mrb_obj_class(mrb, obj));
- dup = mrb_obj_value(p);
- init_copy(mrb, dup, obj);
-
- return dup;
-}
-
static mrb_value
mrb_obj_extend(mrb_state *mrb, mrb_int argc, mrb_value *argv, mrb_value obj)
{
@@ -411,8 +230,8 @@ mrb_obj_extend(mrb_state *mrb, mrb_int argc, mrb_value *argv, mrb_value obj)
mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
}
while (argc--) {
- mrb_funcall(mrb, argv[argc], "extend_object", 1, obj);
- mrb_funcall(mrb, argv[argc], "extended", 1, obj);
+ 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;
}
@@ -476,20 +295,20 @@ mrb_obj_frozen(mrb_state *mrb, mrb_value self)
* call-seq:
* obj.hash -> fixnum
*
- * Generates a <code>Fixnum</code> hash value for this object. This
+ * Generates a <code>Integer</code> hash value for this object. This
* function must have the property that <code>a.eql?(b)</code> implies
* <code>a.hash == b.hash</code>. The hash value is used by class
* <code>Hash</code>. Any hash value that exceeds the capacity of a
- * <code>Fixnum</code> will be truncated before being used.
+ * <code>Integer</code> will be truncated before being used.
*/
static mrb_value
mrb_obj_hash(mrb_state *mrb, mrb_value self)
{
- return mrb_fixnum_value(mrb_obj_id(self));
+ return mrb_int_value(mrb, mrb_obj_id(self));
}
/* 15.3.1.3.16 */
-static mrb_value
+mrb_value
mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
{
mrb_value orig = mrb_get_arg1(mrb);
@@ -501,7 +320,6 @@ mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
return self;
}
-
MRB_API mrb_bool
mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c)
{
@@ -564,9 +382,6 @@ mrb_obj_is_kind_of_m(mrb_state *mrb, mrb_value self)
return mrb_bool_value(mrb_obj_is_kind_of(mrb, self, c));
}
-KHASH_DECLARE(st, mrb_sym, char, FALSE)
-KHASH_DEFINE(st, mrb_sym, char, FALSE, kh_int_hash_func, kh_int_hash_equal)
-
/* 15.3.1.3.32 */
/*
* call_seq:
@@ -749,7 +564,7 @@ obj_respond_to(mrb_state *mrb, mrb_value self)
mrb_get_args(mrb, "n|b", &id, &priv);
respond_to_p = basic_obj_respond_to(mrb, self, id, !priv);
if (!respond_to_p) {
- rtm_id = mrb_intern_lit(mrb, "respond_to_missing?");
+ rtm_id = MRB_QSYM(respond_to_missing_p);
if (basic_obj_respond_to(mrb, self, rtm_id, !priv)) {
mrb_value args[2], v;
args[0] = mrb_symbol_value(id);
@@ -766,7 +581,7 @@ mrb_obj_ceqq(mrb_state *mrb, mrb_value self)
{
mrb_value v = mrb_get_arg1(mrb);
mrb_int i, len;
- mrb_sym eqq = mrb_intern_lit(mrb, "===");
+ mrb_sym eqq = MRB_QSYM(eqq);
mrb_value ary;
if (mrb_array_p(self)) {
diff --git a/src/load.c b/src/load.c
index 247d511df0393a910d049032c70efe73eda23043..c1a8c4c87c8b8b3b300067db9b1520e3184a06cd 100644
--- a/src/load.c
+++ b/src/load.c
@@ -15,6 +15,7 @@
#include <mruby/debug.h>
#include <mruby/error.h>
#include <mruby/data.h>
+#include <mruby/endian.h>
#if SIZE_MAX < UINT32_MAX
# error size_t must be at least 32 bits wide
@@ -25,13 +26,6 @@
#define SIZE_ERROR_MUL(nmemb, size) ((size_t)(nmemb) > SIZE_MAX / (size))
-static size_t
-skip_padding(const uint8_t *buf)
-{
- const size_t align = MRB_DUMP_ALIGNMENT;
- return -(intptr_t)buf & (align-1);
-}
-
static size_t
offset_crc_body(void)
{
@@ -39,18 +33,26 @@ offset_crc_body(void)
return ((uint8_t *)header.binary_crc - (uint8_t *)&header) + sizeof(header.binary_crc);
}
-#ifndef MRB_WITHOUT_FLOAT
-double mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck);
-
+#ifndef MRB_NO_FLOAT
static double
-str_to_double(mrb_state *mrb, const char *p, size_t len)
+str_to_double(mrb_state *mrb, const char *p)
{
- /* `i`, `inf`, `infinity` */
- if (len > 0 && p[0] == 'i') return INFINITY;
-
- /* `I`, `-inf`, `-infinity` */
- if (p[0] == 'I' || (len > 1 && p[0] == '-' && p[1] == 'i')) return -INFINITY;
- return mrb_str_len_to_dbl(mrb, p, len, TRUE);
+ /* dump IEEE754 little endian binary */
+ union {
+ char s[sizeof(double)];
+ double f;
+ } u;
+
+ if (littleendian) {
+ memcpy(u.s, p, sizeof(double));
+ }
+ else {
+ size_t i;
+ for (i=0; i<sizeof(double); i++) {
+ u.s[i] = p[sizeof(double)-i-1];
+ }
+ }
+ return u.f;
}
#endif
@@ -73,8 +75,10 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag
uint16_t tt, pool_data_len, snl;
int plen;
struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
- mrb_irep *irep = mrb_add_irep(mrb);
+ mrb_pool_value *pool;
+ mrb_sym *syms;
int ai = mrb_gc_arena_save(mrb);
+ mrb_irep *irep = mrb_add_irep(mrb);
irep_obj->data = irep;
@@ -94,110 +98,137 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag
src += sizeof(uint16_t);
/* Binary Data Section */
- /* ISEQ BLOCK */
- irep->ilen = (uint16_t)bin_to_uint32(src);
- src += sizeof(uint32_t);
- src += skip_padding(src);
+ /* ISEQ BLOCK (and CATCH HANDLER TABLE BLOCK) */
+ irep->clen = bin_to_uint16(src); /* number of catch handler */
+ src += sizeof(uint16_t);
+ irep->ilen = bin_to_uint16(src);
+ src += sizeof(uint16_t);
if (irep->ilen > 0) {
+ size_t data_len = sizeof(mrb_code) * irep->ilen +
+ sizeof(struct mrb_irep_catch_handler) * irep->clen;
+ mrb_static_assert1(sizeof(struct mrb_irep_catch_handler) == 7);
if (SIZE_ERROR_MUL(irep->ilen, sizeof(mrb_code))) {
return NULL;
}
if ((flags & FLAG_SRC_MALLOC) == 0) {
irep->iseq = (mrb_code*)src;
- src += sizeof(mrb_code) * irep->ilen;
irep->flags |= MRB_ISEQ_NO_FREE;
}
else {
- size_t data_len = sizeof(mrb_code) * irep->ilen;
void *buf = mrb_malloc(mrb, data_len);
irep->iseq = (mrb_code *)buf;
memcpy(buf, src, data_len);
- src += data_len;
}
+ src += data_len;
}
/* POOL BLOCK */
- plen = bin_to_uint32(src); /* number of pool */
- src += sizeof(uint32_t);
+ plen = bin_to_uint16(src); /* number of pool */
+ src += sizeof(uint16_t);
if (plen > 0) {
if (SIZE_ERROR_MUL(plen, sizeof(mrb_value))) {
return NULL;
}
- irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen);
+ irep->pool = pool = (mrb_pool_value*)mrb_calloc(mrb, sizeof(mrb_pool_value), plen);
for (i = 0; i < plen; i++) {
- const char *s;
mrb_bool st = (flags & FLAG_SRC_MALLOC)==0;
tt = *src++; /* pool TT */
- pool_data_len = bin_to_uint16(src); /* pool data length */
- src += sizeof(uint16_t);
- s = (const char*)src;
- src += pool_data_len;
switch (tt) { /* pool data */
- case IREP_TT_FIXNUM: {
- mrb_value num = mrb_str_len_to_inum(mrb, s, pool_data_len, 10, FALSE);
-#ifdef MRB_WITHOUT_FLOAT
- irep->pool[i] = num;
+ case IREP_TT_INT32:
+ {
+ mrb_int v = (int32_t)bin_to_uint32(src);
+ src += sizeof(uint32_t);
+#ifdef MRB_64BIT
+ pool[i].tt = IREP_TT_INT64;
+ pool[i].u.i64 = (int64_t)v;
#else
- irep->pool[i] = mrb_float_p(num)? mrb_float_pool(mrb, mrb_float(num)) : num;
+ pool[i].tt = IREP_TT_INT32;
+ pool[i].u.i32 = v;
#endif
}
break;
+ case IREP_TT_INT64:
+#ifdef MRB_64BIT
+ {
+ uint64_t i = bin_to_uint32(src);
+ src += sizeof(uint32_t);
+ i <<= 32;
+ i |= bin_to_uint32(src);
+ src += sizeof(uint32_t);
+ pool[i].u.i64 = (int64_t)i;
+ }
+ break;
+#else
+ return NULL; /* INT64 not supported on MRB_32BIT */
+#endif
-#ifndef MRB_WITHOUT_FLOAT
case IREP_TT_FLOAT:
- irep->pool[i] = mrb_float_pool(mrb, str_to_double(mrb, s, pool_data_len));
+#ifndef MRB_NO_FLOAT
+ pool[i].tt = tt;
+ pool[i].u.f = str_to_double(mrb, (const char*)src);
+ src += sizeof(double);
break;
+#else
+ return NULL; /* MRB_NO_FLOAT */
#endif
- case IREP_TT_STRING:
- irep->pool[i] = mrb_str_pool(mrb, s, pool_data_len, st);
+ case IREP_TT_STR:
+ pool_data_len = bin_to_uint16(src); /* pool data length */
+ src += sizeof(uint16_t);
+ if (st) {
+ pool[i].tt = (pool_data_len<<2) | IREP_TT_SSTR;
+ pool[i].u.str = (const char*)src;
+ }
+ else {
+ char *p;
+ pool[i].tt = (pool_data_len<<2) | IREP_TT_STR;
+ p = (char*)mrb_malloc(mrb, pool_data_len+1);
+ memcpy(p, src, pool_data_len+1);
+ pool[i].u.str = (const char*)p;
+ }
+ src += pool_data_len + 1;
break;
default:
/* should not happen */
- irep->pool[i] = mrb_nil_value();
- break;
+ return NULL;
}
- irep->plen++;
- mrb_gc_arena_restore(mrb, ai);
+ irep->plen = i+1;
}
}
/* SYMS BLOCK */
- irep->slen = (uint16_t)bin_to_uint32(src); /* syms length */
- src += sizeof(uint32_t);
+ irep->slen = bin_to_uint16(src); /* syms length */
+ src += sizeof(uint16_t);
if (irep->slen > 0) {
if (SIZE_ERROR_MUL(irep->slen, sizeof(mrb_sym))) {
return NULL;
}
- irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
+ irep->syms = syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
for (i = 0; i < irep->slen; i++) {
snl = bin_to_uint16(src); /* symbol name length */
src += sizeof(uint16_t);
if (snl == MRB_DUMP_NULL_SYM_LEN) {
- irep->syms[i] = 0;
+ syms[i] = 0;
continue;
}
if (flags & FLAG_SRC_MALLOC) {
- irep->syms[i] = mrb_intern(mrb, (char *)src, snl);
+ syms[i] = mrb_intern(mrb, (char *)src, snl);
}
else {
- irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl);
+ syms[i] = mrb_intern_static(mrb, (char *)src, snl);
}
src += snl + 1;
-
mrb_gc_arena_restore(mrb, ai);
}
}
- irep->reps = (mrb_irep**)mrb_calloc(mrb, irep->rlen, sizeof(mrb_irep*));
-
diff = src - bin;
mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
*len = (size_t)diff;
@@ -213,6 +244,7 @@ read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
int ai = mrb_gc_arena_save(mrb);
mrb_irep *irep = read_irep_record_1(mrb, bin, len, flags);
+ mrb_irep **reps;
int i;
mrb_gc_arena_restore(mrb, ai);
@@ -220,15 +252,17 @@ read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
return NULL;
}
+ reps = (mrb_irep**)mrb_calloc(mrb, irep->rlen, sizeof(mrb_irep*));
+ irep->reps = (const mrb_irep**)reps;
irep_obj->data = irep;
bin += *len;
for (i=0; i<irep->rlen; i++) {
size_t rlen;
- irep->reps[i] = read_irep_record(mrb, bin, &rlen, flags);
+ reps[i] = read_irep_record(mrb, bin, &rlen, flags);
mrb_gc_arena_restore(mrb, ai);
- if (irep->reps[i] == NULL) {
+ if (reps[i] == NULL) {
return NULL;
}
bin += rlen;
@@ -257,25 +291,26 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
size_t record_size;
uint16_t f_idx;
int i;
+ mrb_irep_debug_info *debug;
if (irep->debug_info) { return MRB_DUMP_INVALID_IREP; }
- irep->debug_info = (mrb_irep_debug_info*)mrb_calloc(mrb, 1, sizeof(mrb_irep_debug_info));
- irep->debug_info->pc_count = (uint32_t)irep->ilen;
+ irep->debug_info = debug = (mrb_irep_debug_info*)mrb_calloc(mrb, 1, sizeof(mrb_irep_debug_info));
+ debug->pc_count = (uint32_t)irep->ilen;
record_size = (size_t)bin_to_uint32(bin);
bin += sizeof(uint32_t);
- irep->debug_info->flen = bin_to_uint16(bin);
- irep->debug_info->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*));
+ debug->flen = bin_to_uint16(bin);
+ debug->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*));
bin += sizeof(uint16_t);
- for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
+ for (f_idx = 0; f_idx < debug->flen; ++f_idx) {
mrb_irep_debug_info_file *file;
uint16_t filename_idx;
file = (mrb_irep_debug_info_file *)mrb_calloc(mrb, 1, sizeof(*file));
- irep->debug_info->files[f_idx] = file;
+ debug->files[f_idx] = file;
file->start_pos = bin_to_uint32(bin);
bin += sizeof(uint32_t);
@@ -329,7 +364,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
size_t len;
int ret;
- ret = read_debug_record(mrb, bin, irep->reps[i], &len, filenames, filenames_len);
+ ret = read_debug_record(mrb, bin, (mrb_irep*)irep->reps[i], &len, filenames, filenames_len);
if (ret != MRB_DUMP_OK) return ret;
bin += len;
}
@@ -393,34 +428,31 @@ static int
read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *record_len, mrb_sym const *syms, uint32_t syms_len)
{
const uint8_t *bin = start;
+ mrb_sym *lv;
ptrdiff_t diff;
int i;
- irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1));
+ irep->lv = lv = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (irep->nlocals - 1));
for (i = 0; i + 1< irep->nlocals; ++i) {
uint16_t const sym_idx = bin_to_uint16(bin);
bin += sizeof(uint16_t);
if (sym_idx == RITE_LV_NULL_MARK) {
- irep->lv[i].name = 0;
- irep->lv[i].r = 0;
+ lv[i] = 0;
}
else {
if (sym_idx >= syms_len) {
return MRB_DUMP_GENERAL_FAILURE;
}
- irep->lv[i].name = syms[sym_idx];
-
- irep->lv[i].r = bin_to_uint16(bin);
+ lv[i] = syms[sym_idx];
}
- bin += sizeof(uint16_t);
}
for (i = 0; i < irep->rlen; ++i) {
size_t len;
int ret;
- ret = read_lv_record(mrb, bin, irep->reps[i], &len, syms, syms_len);
+ ret = read_lv_record(mrb, bin, (mrb_irep*)irep->reps[i], &len, syms, syms_len);
if (ret != MRB_DUMP_OK) return ret;
bin += len;
}
@@ -491,7 +523,12 @@ read_binary_header(const uint8_t *bin, size_t bufsize, size_t *bin_size, uint16_
return MRB_DUMP_INVALID_FILE_HEADER;
}
- if (memcmp(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version)) != 0) {
+ /* if major version is different, they are incompatible */
+ if (memcmp(header->major_version, RITE_BINARY_MAJOR_VER, sizeof(header->major_version)) != 0) {
+ return MRB_DUMP_INVALID_FILE_HEADER;
+ }
+ /* if minor version is different, we can accept the older version */
+ if (memcmp(header->minor_version, RITE_BINARY_MINOR_VER, sizeof(header->minor_version)) <= 0) {
return MRB_DUMP_INVALID_FILE_HEADER;
}
@@ -587,7 +624,7 @@ void mrb_exc_set(mrb_state *mrb, mrb_value exc);
static void
irep_error(mrb_state *mrb)
{
- mrb_exc_set(mrb, mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
+ mrb_exc_set(mrb, mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
}
void mrb_codedump_all(mrb_state*, struct RProc*);
@@ -642,6 +679,12 @@ mrb_load_irep_buf(mrb_state *mrb, const void *buf, size_t bufsize)
return mrb_load_irep_buf_cxt(mrb, buf, bufsize, NULL);
}
+MRB_API mrb_value
+mrb_load_proc(mrb_state *mrb, const struct RProc *proc)
+{
+ return mrb_vm_run(mrb, proc, mrb_top_self(mrb), 0);
+}
+
#ifndef MRB_DISABLE_STDIO
mrb_irep*
diff --git a/src/numeric.c b/src/numeric.c
index f4961928bbe61453f91cb19591aef1b568f5971c..e1898301e865a1b29c2750a97cb28a946260c2df 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -1,10 +1,10 @@
/*
-** numeric.c - Numeric, Integer, Float, Fixnum class
+** numeric.c - Numeric, Integer, Float class
**
** See Copyright Notice in mruby.h
*/
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#include <float.h>
#include <math.h>
#endif
@@ -18,8 +18,8 @@
#include <mruby/string.h>
#include <mruby/class.h>
-#ifndef MRB_WITHOUT_FLOAT
-#ifdef MRB_USE_FLOAT
+#ifndef MRB_NO_FLOAT
+#ifdef MRB_USE_FLOAT32
#define trunc(f) truncf(f)
#define floor(f) floorf(f)
#define ceil(f) ceilf(f)
@@ -30,13 +30,13 @@
#endif
#endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
MRB_API mrb_float
mrb_to_flo(mrb_state *mrb, mrb_value val)
{
switch (mrb_type(val)) {
- case MRB_TT_FIXNUM:
- return (mrb_float)mrb_fixnum(val);
+ case MRB_TT_INTEGER:
+ return (mrb_float)mrb_integer(val);
case MRB_TT_FLOAT:
break;
default:
@@ -44,15 +44,6 @@ mrb_to_flo(mrb_state *mrb, mrb_value val)
}
return mrb_float(val);
}
-
-MRB_API mrb_value
-mrb_int_value(mrb_state *mrb, mrb_float f)
-{
- if (FIXABLE_FLOAT(f)) {
- return mrb_fixnum_value((mrb_int)f);
- }
- return mrb_float_value(mrb, f);
-}
#endif
/*
@@ -65,80 +56,125 @@ mrb_int_value(mrb_state *mrb, mrb_float f)
* 2.0**3 #=> 8.0
*/
static mrb_value
-integral_pow(mrb_state *mrb, mrb_value x)
+int_pow(mrb_state *mrb, mrb_value x)
{
- mrb_value y = mrb_get_arg1(mrb);
-#ifndef MRB_WITHOUT_FLOAT
- mrb_float d;
-#endif
+ mrb_int base = mrb_int(mrb, x);
+ mrb_int exp;
+#ifndef MRB_NO_FLOAT
+ mrb_value y;
+ mrb_float z;
- if (mrb_fixnum_p(x) && mrb_fixnum_p(y)) {
- /* try ipow() */
- mrb_int base = mrb_fixnum(x);
- mrb_int exp = mrb_fixnum(y);
- mrb_int result = 1;
-
- if (exp < 0)
-#ifdef MRB_WITHOUT_FLOAT
- return mrb_fixnum_value(0);
+ mrb_get_args(mrb, "o", &y);
+ if (!mrb_integer_p(y)) {
+ mrb_get_args(mrb, "f", &z);
+ z = pow((mrb_float)base, z);
+ return mrb_float_value(mrb, z);
+ }
+ else {
+ mrb_get_args(mrb, "i", &exp);
+ z = pow((double)base, (double)exp);
+ if (exp < 0 || z < (mrb_float)MRB_INT_MIN || (mrb_float)MRB_INT_MAX < z) {
+ return mrb_float_value(mrb, z);
+ }
+ }
+ return mrb_int_value(mrb, (mrb_int)z);
#else
- goto float_pow;
-#endif
- for (;;) {
- if (exp & 1) {
- if (mrb_int_mul_overflow(result, base, &result)) {
-#ifndef MRB_WITHOUT_FLOAT
- goto float_pow;
-#endif
- }
- }
- exp >>= 1;
- if (exp == 0) break;
- if (mrb_int_mul_overflow(base, base, &base)) {
-#ifndef MRB_WITHOUT_FLOAT
- goto float_pow;
-#endif
+ mrb_int result = 1;
+
+ mrb_get_args(mrb, "i", &exp);
+ if (exp < 0) {
+ return mrb_fixnum_value(0);
+ }
+ for (;;) {
+ if (exp & 1) {
+ if (mrb_int_mul_overflow(result, base, &result)) {
+ mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division");
}
}
- return mrb_fixnum_value(result);
+ exp >>= 1;
+ if (exp == 0) break;
+ if (mrb_int_mul_overflow(base, base, &base)) {
+ mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division");
+ }
}
-#ifdef MRB_WITHOUT_FLOAT
- mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
-#else
- float_pow:
- d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y));
- return mrb_float_value(mrb, d);
+ return mrb_int_value(mrb, result);
#endif
}
-static mrb_value
-integral_idiv(mrb_state *mrb, mrb_value x)
-{
-#ifdef MRB_WITHOUT_FLOAT
- mrb_value y = mrb_get_arg1(mrb);
- if (!mrb_fixnum_p(y)) {
- mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
+mrb_int
+mrb_num_div_int(mrb_state *mrb, mrb_int x, mrb_int y)
+{
+ if (y == 0) {
+ mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");
}
- return mrb_fixnum_value(mrb_fixnum(x) / mrb_fixnum(y));
-#else
- mrb_float y;
+ else if(x == MRB_INT_MIN && y == -1) {
+ mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division");
+ }
+ else {
+ mrb_int div, mod;
- mrb_get_args(mrb, "f", &y);
- return mrb_int_value(mrb, mrb_to_flo(mrb, x) / y);
-#endif
+ if (y < 0) {
+ if (x < 0)
+ div = -x / -y;
+ else
+ div = - (x / -y);
+ }
+ else {
+ if (x < 0)
+ div = - (-x / y);
+ else
+ div = x / y;
+ }
+ mod = x - div * y;
+ if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) {
+ div -= 1;
+ }
+ return div;
+ }
+ /* not reached */
+ return 0;
}
/* 15.2.8.3.4 */
/* 15.2.9.3.4 */
/*
* call-seq:
- * num / other -> num
+ * int / other -> int
*
* Performs division: the class of the resulting object depends on
* the class of <code>num</code> and on the magnitude of the
* result.
*/
+static mrb_value
+int_div(mrb_state *mrb, mrb_value xv)
+{
+#ifndef MRB_NO_FLOAT
+ mrb_value yv;
+
+ mrb_get_args(mrb, "o", &yv);
+ if (mrb_float_p(yv)) {
+ double d = mrb_integer(xv)/mrb_float(yv);
+#ifdef MRB_INT32
+ if (MRB_INT_MIN <= d && d <= MRB_INT_MAX)
+ return mrb_int_value(mrb, (mrb_int)d);
+ return mrb_float_value(mrb, d);
+#else
+ return mrb_int_value(mrb, (mrb_int)d);
+#endif
+ }
+ else
+#endif
+ {
+ mrb_int y;
+
+ mrb_get_args(mrb, "i", &y);
+ if (y == 0) {
+ mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero");
+ }
+ return mrb_int_value(mrb, mrb_integer(xv) / y);
+ }
+}
/* 15.2.9.3.19(x) */
/*
@@ -149,42 +185,32 @@ integral_idiv(mrb_state *mrb, mrb_value x)
*/
static mrb_value
-integral_div(mrb_state *mrb, mrb_value xv)
+int_quo(mrb_state *mrb, mrb_value xv)
{
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
mrb_int y;
mrb_get_args(mrb, "i", &y);
if (y == 0) {
- mrb_raise(mrb, E_RUNTIME_ERROR, "devided by zero");
+ mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero");
}
return mrb_fixnum_value(mrb_fixnum(xv) / y);
#else
- mrb_float x, y;
+ mrb_float y;
mrb_get_args(mrb, "f", &y);
- x = mrb_to_flo(mrb, xv);
- if (y == 0) {
- if (x < 0)
- y = -INFINITY;
- else if (x > 0)
- y = INFINITY;
- else /* if (x == 0) */
- y = NAN;
- return mrb_float_value(mrb, y);
- }
- return mrb_float_value(mrb, x / y);
+ return mrb_float_value(mrb, (mrb_float)mrb_integer(xv) / y);
#endif
}
static mrb_value
-integral_coerce_step_counter(mrb_state *mrb, mrb_value self)
+coerce_step_counter(mrb_state *mrb, mrb_value self)
{
mrb_value num, step;
mrb_get_args(mrb, "oo", &num, &step);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
if (mrb_float_p(self) || mrb_float_p(num) || mrb_float_p(step)) {
return mrb_Float(mrb, self);
}
@@ -193,7 +219,7 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self)
return self;
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/********************************************************************
*
* Document-class: Float
@@ -203,19 +229,59 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self)
* representation.
*/
-/* 15.2.9.3.16(x) */
-/*
- * call-seq:
- * flt.to_s -> string
- *
- * Returns a string containing a representation of self. As well as a
- * fixed or exponential form of the number, the call may return
- * "<code>NaN</code>", "<code>Infinity</code>", and
- * "<code>-Infinity</code>".
- */
+static mrb_value
+flo_pow(mrb_state *mrb, mrb_value x)
+{
+ mrb_value y = mrb_get_arg1(mrb);
+ mrb_float d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y));
+ return mrb_float_value(mrb, d);
+}
static mrb_value
-flo_to_s(mrb_state *mrb, mrb_value flt)
+flo_idiv(mrb_state *mrb, mrb_value x)
+{
+ mrb_float y;
+
+ mrb_get_args(mrb, "f", &y);
+ y = mrb_to_flo(mrb, x) / y;
+#ifdef MRB_INT32
+ if (MRB_INT_MIN <= y && y <= MRB_INT_MAX)
+ return mrb_int_value(mrb, (mrb_int)y);
+ return mrb_float_value(mrb, y);
+#else
+ return mrb_int_value(mrb, (mrb_int)y);
+#endif
+}
+
+mrb_float
+mrb_num_div_flo(mrb_state *mrb, mrb_float x, mrb_float y)
+{
+ mrb_float f;
+
+ if (y == 0) {
+ if (x > 0) f = INFINITY;
+ else if (x < 0) f = -INFINITY;
+ else /* if (x == 0) */ f = NAN;
+ }
+ else {
+ f = x / y;
+ }
+ return f;
+}
+
+static mrb_value
+flo_div(mrb_state *mrb, mrb_value xv)
+{
+ mrb_float x, y;
+
+ x = mrb_float(xv);
+ mrb_get_args(mrb, "f", &y);
+ x = mrb_num_div_flo(mrb, x, y);
+ return mrb_float_value(mrb, x);
+}
+
+static mrb_value
+flo_to_str(mrb_state *mrb, mrb_value flt, mrb_bool add_dot_zero)
{
mrb_float f = mrb_float(flt);
mrb_value str;
@@ -258,6 +324,9 @@ flo_to_s(mrb_state *mrb, mrb_value flt)
str = mrb_float_to_str(mrb, flt, fmt);
goto insert_dot_zero;
}
+ else if (add_dot_zero) {
+ mrb_str_cat(mrb, str, ".0", 2);
+ }
goto exit;
}
@@ -267,6 +336,49 @@ flo_to_s(mrb_state *mrb, mrb_value flt)
return str;
}
+/* 15.2.9.3.16(x) */
+/*
+ * call-seq:
+ * flt.to_s -> string
+ *
+ * Returns a string containing a representation of self. As well as a
+ * fixed or exponential form of the number, the call may return
+ * "<code>NaN</code>", "<code>Infinity</code>", and
+ * "<code>-Infinity</code>".
+ *
+ * Trailing <code>.0</code> is removed.
+ *
+ * 3.0.to_s #=> 3
+ * 3.25.to_s #=> 3.25
+ */
+
+static mrb_value
+flo_to_s(mrb_state *mrb, mrb_value flt)
+{
+ return flo_to_str(mrb, flt, FALSE);
+}
+
+/*
+ * call-seq:
+ * flt.inspect -> string
+ *
+ * Returns a string containing a representation of self. As well as a
+ * fixed or exponential form of the number, the call may return
+ * "<code>NaN</code>", "<code>Infinity</code>", and
+ * "<code>-Infinity</code>".
+ *
+ * Trailing <code>.0</code> is added.
+ *
+ * 3.0.to_s #=> 3.0
+ * 3.25.to_s #=> 3.25
+ */
+
+static mrb_value
+flo_inspect(mrb_state *mrb, mrb_value flt)
+{
+ return flo_to_str(mrb, flt, TRUE);
+}
+
/* 15.2.9.3.2 */
/*
* call-seq:
@@ -378,15 +490,15 @@ flo_mod(mrb_state *mrb, mrb_value x)
* (1.0).eql?(1.0) #=> true
*/
static mrb_value
-fix_eql(mrb_state *mrb, mrb_value x)
+int_eql(mrb_state *mrb, mrb_value x)
{
mrb_value y = mrb_get_arg1(mrb);
- if (!mrb_fixnum_p(y)) return mrb_false_value();
- return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y));
+ if (!mrb_integer_p(y)) return mrb_false_value();
+ return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static mrb_value
flo_eql(mrb_state *mrb, mrb_value x)
{
@@ -415,8 +527,8 @@ flo_eq(mrb_state *mrb, mrb_value x)
mrb_value y = mrb_get_arg1(mrb);
switch (mrb_type(y)) {
- case MRB_TT_FIXNUM:
- return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_fixnum(y));
+ case MRB_TT_INTEGER:
+ return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_integer(y));
case MRB_TT_FLOAT:
return mrb_bool_value(mrb_float(x) == mrb_float(y));
default:
@@ -428,8 +540,8 @@ static int64_t
value_int64(mrb_state *mrb, mrb_value x)
{
switch (mrb_type(x)) {
- case MRB_TT_FIXNUM:
- return (int64_t)mrb_fixnum(x);
+ case MRB_TT_INTEGER:
+ return (int64_t)mrb_integer(x);
case MRB_TT_FLOAT:
return (int64_t)mrb_float(x);
default:
@@ -525,7 +637,7 @@ flo_shift(mrb_state *mrb, mrb_value x, mrb_int width)
val *= 2;
}
}
- return mrb_int_value(mrb, val);
+ return mrb_int_value(mrb, (mrb_int)val);
}
static mrb_value
@@ -631,7 +743,7 @@ flo_floor(mrb_state *mrb, mrb_value num)
mrb_float f = floor(mrb_float(num));
mrb_check_num_exact(mrb, f);
- return mrb_int_value(mrb, f);
+ return mrb_int_value(mrb, (mrb_int)f);
}
/* 15.2.9.3.8 */
@@ -654,7 +766,7 @@ flo_ceil(mrb_state *mrb, mrb_value num)
mrb_float f = ceil(mrb_float(num));
mrb_check_num_exact(mrb, f);
- return mrb_int_value(mrb, f);
+ return mrb_int_value(mrb, (mrb_int)f);
}
/* 15.2.9.3.12 */
@@ -736,7 +848,7 @@ flo_round(mrb_state *mrb, mrb_value num)
if (!isfinite(number)) return num;
return mrb_float_value(mrb, number);
}
- return mrb_int_value(mrb, number);
+ return mrb_int_value(mrb, (mrb_int)number);
}
/* 15.2.9.3.14 */
@@ -758,7 +870,7 @@ flo_truncate(mrb_state *mrb, mrb_value num)
if (f < 0.0) f = ceil(f);
mrb_check_num_exact(mrb, f);
- return mrb_int_value(mrb, f);
+ return mrb_int_value(mrb, (mrb_int)f);
}
static mrb_value
@@ -771,8 +883,7 @@ flo_nan_p(mrb_state *mrb, mrb_value num)
/*
* Document-class: Integer
*
- * <code>Integer</code> is the basis for the two concrete classes that
- * hold whole numbers, <code>Bignum</code> and <code>Fixnum</code>.
+ * <code>Integer</code> is hold whole numbers.
*
*/
@@ -796,20 +907,20 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
{
mrb_int a;
- a = mrb_fixnum(x);
- if (mrb_fixnum_p(y)) {
+ a = mrb_integer(x);
+ if (mrb_integer_p(y)) {
mrb_int b, c;
if (a == 0) return x;
- b = mrb_fixnum(y);
+ b = mrb_integer(y);
if (mrb_int_mul_overflow(a, b, &c)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b);
#endif
}
return mrb_fixnum_value(c);
}
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
#else
return mrb_float_value(mrb, (mrb_float)a * mrb_to_flo(mrb, y));
@@ -819,10 +930,10 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
MRB_API mrb_value
mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y)
{
- if (mrb_fixnum_p(x)) {
+ if (mrb_integer_p(x)) {
return fixnum_mul(mrb, x, y);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
if (mrb_float_p(x)) {
return mrb_float_value(mrb, mrb_float(x) * mrb_to_flo(mrb, y));
}
@@ -842,7 +953,7 @@ mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y)
*/
static mrb_value
-fix_mul(mrb_state *mrb, mrb_value x)
+int_mul(mrb_state *mrb, mrb_value x)
{
mrb_value y = mrb_get_arg1(mrb);
@@ -888,29 +999,22 @@ fixdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp)
*/
static mrb_value
-fix_mod(mrb_state *mrb, mrb_value x)
+int_mod(mrb_state *mrb, mrb_value x)
{
mrb_value y = mrb_get_arg1(mrb);
mrb_int a, b;
- a = mrb_fixnum(x);
- if (mrb_fixnum_p(y) && a != MRB_INT_MIN && (b=mrb_fixnum(y)) != MRB_INT_MIN) {
+ a = mrb_integer(x);
+ if (mrb_integer_p(y) && a != MRB_INT_MIN && (b=mrb_integer(y)) != MRB_INT_MIN) {
mrb_int mod;
if (b == 0) {
-#ifdef MRB_WITHOUT_FLOAT
- /* ZeroDivisionError */
- return mrb_fixnum_value(0);
-#else
- if (a > 0) return mrb_float_value(mrb, INFINITY);
- if (a < 0) return mrb_float_value(mrb, INFINITY);
- return mrb_float_value(mrb, NAN);
-#endif
+ mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");
}
fixdivmod(mrb, a, b, NULL, &mod);
return mrb_fixnum_value(mod);
}
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
#else
else {
@@ -929,42 +1033,35 @@ fix_mod(mrb_state *mrb, mrb_value x)
* See <code>Numeric#divmod</code>.
*/
static mrb_value
-fix_divmod(mrb_state *mrb, mrb_value x)
+int_divmod(mrb_state *mrb, mrb_value x)
{
mrb_value y = mrb_get_arg1(mrb);
- if (mrb_fixnum_p(y)) {
+ if (mrb_integer_p(y)) {
mrb_int div, mod;
- if (mrb_fixnum(y) == 0) {
-#ifdef MRB_WITHOUT_FLOAT
- return mrb_assoc_new(mrb, mrb_fixnum_value(0), mrb_fixnum_value(0));
-#else
- return mrb_assoc_new(mrb, ((mrb_fixnum(x) == 0) ?
- mrb_float_value(mrb, NAN):
- mrb_float_value(mrb, INFINITY)),
- mrb_float_value(mrb, NAN));
-#endif
+ if (mrb_integer(y) == 0) {
+ mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");
}
- fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod);
- return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod));
+ fixdivmod(mrb, mrb_integer(x), mrb_integer(y), &div, &mod);
+ return mrb_assoc_new(mrb, mrb_int_value(mrb, div), mrb_int_value(mrb, mod));
}
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
#else
else {
mrb_float div, mod;
mrb_value a, b;
- flodivmod(mrb, (mrb_float)mrb_fixnum(x), mrb_to_flo(mrb, y), &div, &mod);
- a = mrb_int_value(mrb, div);
+ flodivmod(mrb, (mrb_float)mrb_integer(x), mrb_to_flo(mrb, y), &div, &mod);
+ a = mrb_int_value(mrb, (mrb_int)div);
b = mrb_float_value(mrb, mod);
return mrb_assoc_new(mrb, a, b);
}
#endif
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static mrb_value
flo_divmod(mrb_state *mrb, mrb_value x)
{
@@ -973,7 +1070,7 @@ flo_divmod(mrb_state *mrb, mrb_value x)
mrb_value a, b;
flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), &div, &mod);
- a = mrb_int_value(mrb, div);
+ a = mrb_int_value(mrb, (mrb_int)div);
b = mrb_float_value(mrb, mod);
return mrb_assoc_new(mrb, a, b);
}
@@ -992,16 +1089,16 @@ flo_divmod(mrb_state *mrb, mrb_value x)
*/
static mrb_value
-fix_equal(mrb_state *mrb, mrb_value x)
+int_equal(mrb_state *mrb, mrb_value x)
{
mrb_value y = mrb_get_arg1(mrb);
switch (mrb_type(y)) {
- case MRB_TT_FIXNUM:
- return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y));
-#ifndef MRB_WITHOUT_FLOAT
+ case MRB_TT_INTEGER:
+ return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
- return mrb_bool_value((mrb_float)mrb_fixnum(x) == mrb_float(y));
+ return mrb_bool_value((mrb_float)mrb_integer(x) == mrb_float(y));
#endif
default:
return mrb_false_value();
@@ -1020,24 +1117,24 @@ fix_equal(mrb_state *mrb, mrb_value x)
*/
static mrb_value
-fix_rev(mrb_state *mrb, mrb_value num)
+int_rev(mrb_state *mrb, mrb_value num)
{
- mrb_int val = mrb_fixnum(num);
+ mrb_int val = mrb_integer(num);
- return mrb_fixnum_value(~val);
+ return mrb_int_value(mrb, ~val);
}
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
#define bit_op(x,y,op1,op2) do {\
- return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\
+ return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y)));\
} while(0)
#else
static mrb_value flo_and(mrb_state *mrb, mrb_value x);
static mrb_value flo_or(mrb_state *mrb, mrb_value x);
static mrb_value flo_xor(mrb_state *mrb, mrb_value x);
#define bit_op(x,y,op1,op2) do {\
- if (mrb_fixnum_p(y)) return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\
- return flo_ ## op1(mrb, mrb_float_value(mrb, (mrb_float)mrb_fixnum(x)));\
+ if (mrb_integer_p(y)) return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y))); \
+ return flo_ ## op1(mrb, mrb_float_value(mrb, (mrb_float)mrb_integer(x)));\
} while(0)
#endif
@@ -1050,7 +1147,7 @@ static mrb_value flo_xor(mrb_state *mrb, mrb_value x);
*/
static mrb_value
-fix_and(mrb_state *mrb, mrb_value x)
+int_and(mrb_state *mrb, mrb_value x)
{
mrb_value y = mrb_get_arg1(mrb);
@@ -1066,7 +1163,7 @@ fix_and(mrb_state *mrb, mrb_value x)
*/
static mrb_value
-fix_or(mrb_state *mrb, mrb_value x)
+int_or(mrb_state *mrb, mrb_value x)
{
mrb_value y = mrb_get_arg1(mrb);
@@ -1082,7 +1179,7 @@ fix_or(mrb_state *mrb, mrb_value x)
*/
static mrb_value
-fix_xor(mrb_state *mrb, mrb_value x)
+int_xor(mrb_state *mrb, mrb_value x)
{
mrb_value y = mrb_get_arg1(mrb);
@@ -1095,7 +1192,7 @@ static mrb_value
lshift(mrb_state *mrb, mrb_int val, mrb_int width)
{
if (width < 0) { /* mrb_int overflow */
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
return mrb_fixnum_value(0);
#else
return mrb_float_value(mrb, INFINITY);
@@ -1104,27 +1201,27 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width)
if (val > 0) {
if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
(val > (MRB_INT_MAX >> width))) {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
return mrb_fixnum_value(-1);
#else
goto bit_overflow;
#endif
}
- return mrb_fixnum_value(val << width);
+ return mrb_int_value(mrb, val << width);
}
else {
if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
(val <= (MRB_INT_MIN >> width))) {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
return mrb_fixnum_value(0);
#else
goto bit_overflow;
#endif
}
- return mrb_fixnum_value(val * ((mrb_int)1 << width));
+ return mrb_int_value(mrb, (val * ((mrb_int)1 << width)));
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
bit_overflow:
{
mrb_float f = (mrb_float)val;
@@ -1137,7 +1234,7 @@ bit_overflow:
}
static mrb_value
-rshift(mrb_int val, mrb_int width)
+rshift(mrb_state *mrb, mrb_int val, mrb_int width)
{
if (width < 0) { /* mrb_int overflow */
return mrb_fixnum_value(0);
@@ -1148,7 +1245,7 @@ rshift(mrb_int val, mrb_int width)
}
return mrb_fixnum_value(0);
}
- return mrb_fixnum_value(val >> width);
+ return mrb_int_value(mrb, val >> width);
}
/* 15.2.8.3.12 */
@@ -1160,7 +1257,7 @@ rshift(mrb_int val, mrb_int width)
*/
static mrb_value
-fix_lshift(mrb_state *mrb, mrb_value x)
+int_lshift(mrb_state *mrb, mrb_value x)
{
mrb_int width, val;
@@ -1168,10 +1265,10 @@ fix_lshift(mrb_state *mrb, mrb_value x)
if (width == 0) {
return x;
}
- val = mrb_fixnum(x);
+ val = mrb_integer(x);
if (val == 0) return x;
if (width < 0) {
- return rshift(val, -width);
+ return rshift(mrb, val, -width);
}
return lshift(mrb, val, width);
}
@@ -1185,7 +1282,7 @@ fix_lshift(mrb_state *mrb, mrb_value x)
*/
static mrb_value
-fix_rshift(mrb_state *mrb, mrb_value x)
+int_rshift(mrb_state *mrb, mrb_value x)
{
mrb_int width, val;
@@ -1193,12 +1290,12 @@ fix_rshift(mrb_state *mrb, mrb_value x)
if (width == 0) {
return x;
}
- val = mrb_fixnum(x);
+ val = mrb_integer(x);
if (val == 0) return x;
if (width < 0) {
return lshift(mrb, val, -width);
}
- return rshift(val, width);
+ return rshift(mrb, val, width);
}
/* 15.2.8.3.23 */
@@ -1210,11 +1307,11 @@ fix_rshift(mrb_state *mrb, mrb_value x)
*
*/
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static mrb_value
-fix_to_f(mrb_state *mrb, mrb_value num)
+int_to_f(mrb_state *mrb, mrb_value num)
{
- return mrb_float_value(mrb, (mrb_float)mrb_fixnum(num));
+ return mrb_float_value(mrb, (mrb_float)mrb_integer(num));
}
/*
@@ -1251,7 +1348,7 @@ mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x)
mrb_raisef(mrb, E_RANGE_ERROR, "number (%v) too big for integer", x);
}
}
- return mrb_fixnum_value(z);
+ return mrb_int_value(mrb, z);
}
#endif
@@ -1260,20 +1357,20 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y)
{
mrb_int a;
- a = mrb_fixnum(x);
- if (mrb_fixnum_p(y)) {
+ a = mrb_integer(x);
+ if (mrb_integer_p(y)) {
mrb_int b, c;
if (a == 0) return y;
- b = mrb_fixnum(y);
+ b = mrb_integer(y);
if (mrb_int_add_overflow(a, b, &c)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
return mrb_float_value(mrb, (mrb_float)a + (mrb_float)b);
#endif
}
- return mrb_fixnum_value(c);
+ return mrb_int_value(mrb, c);
}
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
#else
return mrb_float_value(mrb, (mrb_float)a + mrb_to_flo(mrb, y));
@@ -1283,10 +1380,10 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y)
MRB_API mrb_value
mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y)
{
- if (mrb_fixnum_p(x)) {
+ if (mrb_integer_p(x)) {
return fixnum_plus(mrb, x, y);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
if (mrb_float_p(x)) {
return mrb_float_value(mrb, mrb_float(x) + mrb_to_flo(mrb, y));
}
@@ -1305,7 +1402,7 @@ mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y)
* result.
*/
static mrb_value
-fix_plus(mrb_state *mrb, mrb_value self)
+int_plus(mrb_state *mrb, mrb_value self)
{
mrb_value other = mrb_get_arg1(mrb);
@@ -1317,19 +1414,19 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y)
{
mrb_int a;
- a = mrb_fixnum(x);
- if (mrb_fixnum_p(y)) {
+ a = mrb_integer(x);
+ if (mrb_integer_p(y)) {
mrb_int b, c;
- b = mrb_fixnum(y);
+ b = mrb_integer(y);
if (mrb_int_sub_overflow(a, b, &c)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
return mrb_float_value(mrb, (mrb_float)a - (mrb_float)b);
#endif
}
- return mrb_fixnum_value(c);
+ return mrb_int_value(mrb, c);
}
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
#else
return mrb_float_value(mrb, (mrb_float)a - mrb_to_flo(mrb, y));
@@ -1339,10 +1436,10 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y)
MRB_API mrb_value
mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y)
{
- if (mrb_fixnum_p(x)) {
+ if (mrb_integer_p(x)) {
return fixnum_minus(mrb, x, y);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
if (mrb_float_p(x)) {
return mrb_float_value(mrb, mrb_float(x) - mrb_to_flo(mrb, y));
}
@@ -1362,7 +1459,7 @@ mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y)
* result.
*/
static mrb_value
-fix_minus(mrb_state *mrb, mrb_value self)
+int_minus(mrb_state *mrb, mrb_value self)
{
mrb_value other = mrb_get_arg1(mrb);
@@ -1375,7 +1472,7 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base)
{
char buf[MRB_INT_BIT+1];
char *b = buf + sizeof buf;
- mrb_int val = mrb_fixnum(x);
+ mrb_int val = mrb_integer(x);
mrb_value str;
if (base < 2 || 36 < base) {
@@ -1419,7 +1516,7 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base)
*
*/
static mrb_value
-fix_to_s(mrb_state *mrb, mrb_value self)
+int_to_s(mrb_state *mrb, mrb_value self)
{
mrb_int base = 10;
@@ -1431,26 +1528,26 @@ fix_to_s(mrb_state *mrb, mrb_value self)
static mrb_int
cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2)
{
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
mrb_int x, y;
#else
mrb_float x, y;
#endif
-#ifdef MRB_WITHOUT_FLOAT
- x = mrb_fixnum(v1);
+#ifdef MRB_NO_FLOAT
+ x = mrb_integer(v1);
#else
x = mrb_to_flo(mrb, v1);
#endif
switch (mrb_type(v2)) {
- case MRB_TT_FIXNUM:
-#ifdef MRB_WITHOUT_FLOAT
- y = mrb_fixnum(v2);
+ case MRB_TT_INTEGER:
+#ifdef MRB_NO_FLOAT
+ y = mrb_integer(v2);
#else
- y = (mrb_float)mrb_fixnum(v2);
+ y = (mrb_float)mrb_integer(v2);
#endif
break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
y = mrb_float(v2);
break;
@@ -1480,7 +1577,7 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2)
* not comparable, it returns nil instead of raising an exception.
*/
static mrb_value
-integral_cmp(mrb_state *mrb, mrb_value self)
+num_cmp(mrb_state *mrb, mrb_value self)
{
mrb_value other = mrb_get_arg1(mrb);
mrb_int n;
@@ -1497,7 +1594,7 @@ cmperr(mrb_state *mrb, mrb_value v1, mrb_value v2)
}
static mrb_value
-integral_lt(mrb_state *mrb, mrb_value self)
+num_lt(mrb_state *mrb, mrb_value self)
{
mrb_value other = mrb_get_arg1(mrb);
mrb_int n;
@@ -1509,7 +1606,7 @@ integral_lt(mrb_state *mrb, mrb_value self)
}
static mrb_value
-integral_le(mrb_state *mrb, mrb_value self)
+num_le(mrb_state *mrb, mrb_value self)
{
mrb_value other = mrb_get_arg1(mrb);
mrb_int n;
@@ -1521,7 +1618,7 @@ integral_le(mrb_state *mrb, mrb_value self)
}
static mrb_value
-integral_gt(mrb_state *mrb, mrb_value self)
+num_gt(mrb_state *mrb, mrb_value self)
{
mrb_value other = mrb_get_arg1(mrb);
mrb_int n;
@@ -1533,7 +1630,7 @@ integral_gt(mrb_state *mrb, mrb_value self)
}
static mrb_value
-integral_ge(mrb_state *mrb, mrb_value self)
+num_ge(mrb_state *mrb, mrb_value self)
{
mrb_value other = mrb_get_arg1(mrb);
mrb_int n;
@@ -1550,7 +1647,7 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
mrb_value v;
switch (mrb_type(obj1)) {
- case MRB_TT_FIXNUM:
+ case MRB_TT_INTEGER:
case MRB_TT_FLOAT:
return cmpnum(mrb, obj1, obj2);
case MRB_TT_STRING:
@@ -1558,10 +1655,10 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
return -2;
return mrb_str_cmp(mrb, obj1, obj2);
default:
- v = mrb_funcall(mrb, obj1, "<=>", 1, obj2);
- if (mrb_nil_p(v) || !mrb_fixnum_p(v))
+ v = mrb_funcall_id(mrb, obj1, MRB_SYM(cmp), 1, obj2);
+ if (mrb_nil_p(v) || !mrb_integer_p(v))
return -2;
- return mrb_fixnum(v);
+ return mrb_integer(v);
}
}
@@ -1585,7 +1682,7 @@ num_infinite_p(mrb_state *mrb, mrb_value self)
* Returns a new float which is the sum of <code>float</code>
* and <code>other</code>.
*/
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
static mrb_value
flo_plus(mrb_state *mrb, mrb_value x)
{
@@ -1599,72 +1696,81 @@ flo_plus(mrb_state *mrb, mrb_value x)
void
mrb_init_numeric(mrb_state *mrb)
{
- struct RClass *numeric, *integer, *fixnum, *integral;
-#ifndef MRB_WITHOUT_FLOAT
+ struct RClass *numeric, *integer;
+#ifndef MRB_NO_FLOAT
struct RClass *fl;
#endif
- integral = mrb_define_module(mrb, "Integral");
- mrb_define_method(mrb, integral,"**", integral_pow, MRB_ARGS_REQ(1));
- mrb_define_method(mrb, integral,"/", integral_div, MRB_ARGS_REQ(1)); /* 15.2.{8,9}.3.6 */
- mrb_define_method(mrb, integral,"quo", integral_div, MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
- mrb_define_method(mrb, integral,"div", integral_idiv, MRB_ARGS_REQ(1));
- mrb_define_method(mrb, integral,"<=>", integral_cmp, MRB_ARGS_REQ(1)); /* 15.2.{8,9}.3.1 */
- mrb_define_method(mrb, integral,"<", integral_lt, MRB_ARGS_REQ(1));
- mrb_define_method(mrb, integral,"<=", integral_le, MRB_ARGS_REQ(1));
- mrb_define_method(mrb, integral,">", integral_gt, MRB_ARGS_REQ(1));
- mrb_define_method(mrb, integral,">=", integral_ge, MRB_ARGS_REQ(1));
- mrb_define_method(mrb, integral,"__coerce_step_counter", integral_coerce_step_counter, MRB_ARGS_REQ(2));
-
/* Numeric Class */
numeric = mrb_define_class(mrb, "Numeric", mrb->object_class); /* 15.2.7 */
mrb_define_method(mrb, numeric, "finite?", num_finite_p, MRB_ARGS_NONE());
mrb_define_method(mrb, numeric, "infinite?",num_infinite_p, MRB_ARGS_NONE());
/* Integer Class */
- integer = mrb_define_class(mrb, "Integer", numeric); /* 15.2.8 */
- MRB_SET_INSTANCE_TT(integer, MRB_TT_FIXNUM);
+ mrb->integer_class = integer = mrb_define_class(mrb, "Integer", numeric); /* 15.2.8 */
+ MRB_SET_INSTANCE_TT(integer, MRB_TT_INTEGER);
mrb_undef_class_method(mrb, integer, "new");
+ mrb_define_method(mrb, integer, "**", int_pow, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, integer, "/", int_div, MRB_ARGS_REQ(1)); /* 15.2.8.3.6 */
+ mrb_define_method(mrb, integer, "quo", int_quo, MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
+ mrb_define_method(mrb, integer, "div", int_div, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, integer, "<=>", num_cmp, MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */
+ mrb_define_method(mrb, integer, "<", num_lt, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, integer, "<=", num_le, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, integer, ">", num_gt, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, integer, ">=", num_ge, MRB_ARGS_REQ(1));
+
mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.24 */
mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE());
-#ifndef MRB_WITHOUT_FLOAT
- mrb_define_method(mrb, integer, "ceil", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.8 (x) */
- mrb_define_method(mrb, integer, "floor", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.10 (x) */
- mrb_define_method(mrb, integer, "round", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.12 (x) */
- mrb_define_method(mrb, integer, "truncate", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.15 (x) */
+#ifndef MRB_NO_FLOAT
+ mrb_define_method(mrb, integer, "ceil", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.14 */
+ mrb_define_method(mrb, integer, "floor", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.17 */
+ mrb_define_method(mrb, integer, "round", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.20 */
+ mrb_define_method(mrb, integer, "truncate", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.26 */
#endif
- /* Fixnum Class */
- mrb->fixnum_class = fixnum = mrb_define_class(mrb, "Fixnum", integer);
- mrb_define_method(mrb, fixnum, "+", fix_plus, MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */
- mrb_define_method(mrb, fixnum, "-", fix_minus, MRB_ARGS_REQ(1)); /* 15.2.8.3.2 */
- mrb_define_method(mrb, fixnum, "*", fix_mul, MRB_ARGS_REQ(1)); /* 15.2.8.3.3 */
- mrb_define_method(mrb, fixnum, "%", fix_mod, MRB_ARGS_REQ(1)); /* 15.2.8.3.5 */
- mrb_define_method(mrb, fixnum, "==", fix_equal, MRB_ARGS_REQ(1)); /* 15.2.8.3.7 */
- mrb_define_method(mrb, fixnum, "~", fix_rev, MRB_ARGS_NONE()); /* 15.2.8.3.8 */
- mrb_define_method(mrb, fixnum, "&", fix_and, MRB_ARGS_REQ(1)); /* 15.2.8.3.9 */
- mrb_define_method(mrb, fixnum, "|", fix_or, MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
- mrb_define_method(mrb, fixnum, "^", fix_xor, MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
- mrb_define_method(mrb, fixnum, "<<", fix_lshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
- mrb_define_method(mrb, fixnum, ">>", fix_rshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
- mrb_define_method(mrb, fixnum, "eql?", fix_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
-#ifndef MRB_WITHOUT_FLOAT
- mrb_define_method(mrb, fixnum, "to_f", fix_to_f, MRB_ARGS_NONE()); /* 15.2.8.3.23 */
+ mrb_define_method(mrb, integer, "+", int_plus, MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */
+ mrb_define_method(mrb, integer, "-", int_minus, MRB_ARGS_REQ(1)); /* 15.2.8.3.2 */
+ mrb_define_method(mrb, integer, "*", int_mul, MRB_ARGS_REQ(1)); /* 15.2.8.3.3 */
+ mrb_define_method(mrb, integer, "%", int_mod, MRB_ARGS_REQ(1)); /* 15.2.8.3.5 */
+ mrb_define_method(mrb, integer, "==", int_equal, MRB_ARGS_REQ(1)); /* 15.2.8.3.7 */
+ mrb_define_method(mrb, integer, "~", int_rev, MRB_ARGS_NONE()); /* 15.2.8.3.8 */
+ mrb_define_method(mrb, integer, "&", int_and, MRB_ARGS_REQ(1)); /* 15.2.8.3.9 */
+ mrb_define_method(mrb, integer, "|", int_or, MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
+ mrb_define_method(mrb, integer, "^", int_xor, MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
+ mrb_define_method(mrb, integer, "<<", int_lshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
+ mrb_define_method(mrb, integer, ">>", int_rshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
+ mrb_define_method(mrb, integer, "eql?", int_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
+#ifndef MRB_NO_FLOAT
+ mrb_define_method(mrb, integer, "to_f", int_to_f, MRB_ARGS_NONE()); /* 15.2.8.3.23 */
#endif
- mrb_define_method(mrb, fixnum, "to_s", fix_to_s, MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */
- mrb_define_method(mrb, fixnum, "inspect", fix_to_s, MRB_ARGS_OPT(1));
- mrb_define_method(mrb, fixnum, "divmod", fix_divmod, MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
+ mrb_define_method(mrb, integer, "to_s", int_to_s, MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */
+ mrb_define_method(mrb, integer, "inspect", int_to_s, MRB_ARGS_OPT(1));
+ mrb_define_method(mrb, integer, "divmod", int_divmod, MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
+ mrb_define_method(mrb, integer, "__coerce_step_counter", coerce_step_counter, MRB_ARGS_REQ(2));
-#ifndef MRB_WITHOUT_FLOAT
+ /* Fixnum Class for compatibility */
+ mrb_define_const(mrb, mrb->object_class, "Fixnum", mrb_obj_value(integer));
+
+#ifndef MRB_NO_FLOAT
/* Float Class */
mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric); /* 15.2.9 */
MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT);
mrb_undef_class_method(mrb, fl, "new");
- mrb_define_method(mrb, fl, "+", flo_plus, MRB_ARGS_REQ(1)); /* 15.2.9.3.1 */
- mrb_define_method(mrb, fl, "-", flo_minus, MRB_ARGS_REQ(1)); /* 15.2.9.3.2 */
- mrb_define_method(mrb, fl, "*", flo_mul, MRB_ARGS_REQ(1)); /* 15.2.9.3.3 */
- mrb_define_method(mrb, fl, "%", flo_mod, MRB_ARGS_REQ(1)); /* 15.2.9.3.5 */
- mrb_define_method(mrb, fl, "==", flo_eq, MRB_ARGS_REQ(1)); /* 15.2.9.3.7 */
+ mrb_define_method(mrb, fl, "**", flo_pow, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, fl, "/", flo_div, MRB_ARGS_REQ(1)); /* 15.2.9.3.6 */
+ mrb_define_method(mrb, fl, "quo", flo_div, MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
+ mrb_define_method(mrb, fl, "div", flo_idiv, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, fl, "+", flo_plus, MRB_ARGS_REQ(1)); /* 15.2.9.3.3 */
+ mrb_define_method(mrb, fl, "-", flo_minus, MRB_ARGS_REQ(1)); /* 15.2.9.3.4 */
+ mrb_define_method(mrb, fl, "*", flo_mul, MRB_ARGS_REQ(1)); /* 15.2.9.3.5 */
+ mrb_define_method(mrb, fl, "%", flo_mod, MRB_ARGS_REQ(1)); /* 15.2.9.3.7 */
+ mrb_define_method(mrb, fl, "<=>", num_cmp, MRB_ARGS_REQ(1)); /* 15.2.9.3.1 */
+ mrb_define_method(mrb, fl, "<", num_lt, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, fl, "<=", num_le, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, fl, ">", num_gt, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, fl, ">=", num_ge, MRB_ARGS_REQ(1));
+ mrb_define_method(mrb, fl, "==", flo_eq, MRB_ARGS_REQ(1)); /* 15.2.9.3.2 */
mrb_define_method(mrb, fl, "~", flo_rev, MRB_ARGS_NONE());
mrb_define_method(mrb, fl, "&", flo_and, MRB_ARGS_REQ(1));
mrb_define_method(mrb, fl, "|", flo_or, MRB_ARGS_REQ(1));
@@ -1684,16 +1790,14 @@ mrb_init_numeric(mrb_state *mrb)
mrb_define_method(mrb, fl, "eql?", flo_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
mrb_define_method(mrb, fl, "to_s", flo_to_s, MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
- mrb_define_method(mrb, fl, "inspect", flo_to_s, MRB_ARGS_NONE());
+ mrb_define_method(mrb, fl, "inspect", flo_inspect, MRB_ARGS_NONE());
mrb_define_method(mrb, fl, "nan?", flo_nan_p, MRB_ARGS_NONE());
#ifdef INFINITY
- mrb_define_const(mrb, fl, "INFINITY", mrb_float_value(mrb, INFINITY));
+ mrb_define_const_id(mrb, fl, MRB_SYM(INFINITY), mrb_float_value(mrb, INFINITY));
#endif
#ifdef NAN
- mrb_define_const(mrb, fl, "NAN", mrb_float_value(mrb, NAN));
+ mrb_define_const_id(mrb, fl, MRB_SYM(NAN), mrb_float_value(mrb, NAN));
#endif
-
- mrb_include_module(mrb, fl, integral);
#endif
}
diff --git a/src/object.c b/src/object.c
index 7257f402d775784be4e14a2867397245abf1b668..aaab4022dd4f48e6dd9dc65a744cc6a1d324a9ef 100644
--- a/src/object.c
+++ b/src/object.c
@@ -19,12 +19,12 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
return TRUE;
case MRB_TT_FALSE:
- case MRB_TT_FIXNUM:
- return (mrb_fixnum(v1) == mrb_fixnum(v2));
+ case MRB_TT_INTEGER:
+ return (mrb_integer(v1) == mrb_integer(v2));
case MRB_TT_SYMBOL:
return (mrb_symbol(v1) == mrb_symbol(v2));
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
return (mrb_float(v1) == mrb_float(v2));
#endif
@@ -47,18 +47,18 @@ mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
mrb_value result;
if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/* value mixing with integer and float */
- if (mrb_fixnum_p(obj1)) {
- if (mrb_float_p(obj2) && (mrb_float)mrb_fixnum(obj1) == mrb_float(obj2))
+ if (mrb_integer_p(obj1)) {
+ if (mrb_float_p(obj2) && (mrb_float)mrb_integer(obj1) == mrb_float(obj2))
return TRUE;
}
else if (mrb_float_p(obj1)) {
- if (mrb_fixnum_p(obj2) && mrb_float(obj1) == (mrb_float)mrb_fixnum(obj2))
+ if (mrb_integer_p(obj2) && mrb_float(obj1) == (mrb_float)mrb_integer(obj2))
return TRUE;
}
#endif
- result = mrb_funcall(mrb, obj1, "==", 1, obj2);
+ result = mrb_funcall_id(mrb, obj1, MRB_QSYM(eq), 1, obj2);
if (mrb_test(result)) return TRUE;
return FALSE;
}
@@ -94,7 +94,7 @@ mrb_true(mrb_state *mrb, mrb_value obj)
static mrb_value
nil_to_s(mrb_state *mrb, mrb_value obj)
{
- mrb_value str = mrb_str_new_frozen(mrb, 0, 0);
+ mrb_value str = mrb_str_new_frozen(mrb, NULL, 0);
RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
return str;
}
@@ -315,110 +315,115 @@ mrb_init_object(mrb_state *mrb)
mrb_define_method(mrb, f, "inspect", false_to_s, MRB_ARGS_NONE());
}
-static mrb_value
-convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *method, mrb_bool raise)
+static const struct types {
+ const enum mrb_vtype type;
+ const char *name;
+} builtin_types[] = {
+/* {MRB_TT_NIL, "nil"}, */
+ {MRB_TT_FALSE, "false"},
+ {MRB_TT_TRUE, "true"},
+ {MRB_TT_INTEGER,"Integer"},
+ {MRB_TT_SYMBOL, "Symbol"}, /* :symbol */
+ {MRB_TT_MODULE, "Module"},
+ {MRB_TT_OBJECT, "Object"},
+ {MRB_TT_CLASS, "Class"},
+ {MRB_TT_ICLASS, "iClass"}, /* internal use: mixed-in module holder */
+ {MRB_TT_SCLASS, "SClass"},
+ {MRB_TT_PROC, "Proc"},
+#ifndef MRB_NO_FLOAT
+ {MRB_TT_FLOAT, "Float"},
+#endif
+ {MRB_TT_ARRAY, "Array"},
+ {MRB_TT_HASH, "Hash"},
+ {MRB_TT_STRING, "String"},
+ {MRB_TT_RANGE, "Range"},
+/* {MRB_TT_BIGNUM, "Bignum"}, */
+ {MRB_TT_DATA, "Data"}, /* internal use: wrapped C pointers */
+/* {MRB_TT_UNDEF, "undef"}, */ /* internal use: #undef; should not happen */
+ {MRB_TT_MAXDEFINE, 0}
+};
+
+static const char*
+type_name(enum mrb_vtype t)
{
- mrb_sym m = 0;
+ const struct types *type = builtin_types;
+
+ while (type->type < MRB_TT_MAXDEFINE) {
+ if (type->type == t) return type->name;
+ type++;
+ }
+ return NULL;
+}
- m = mrb_intern_cstr(mrb, method);
- if (!mrb_respond_to(mrb, val, m)) {
+static mrb_value
+convert_type(mrb_state *mrb, mrb_value val, const char *tname, mrb_sym method, mrb_bool raise)
+{
+ if (!mrb_respond_to(mrb, val, method)) {
if (raise) {
- mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into %s", val, tname);
+ if (tname) mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into %s", val, tname);
+ mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y", val);
}
return mrb_nil_value();
}
- return mrb_funcall_argv(mrb, val, m, 0, 0);
+ return mrb_funcall_argv(mrb, val, method, 0, 0);
}
MRB_API mrb_value
-mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method)
+mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method)
{
mrb_value v;
+ const char *tname;
if (mrb_type(val) == type) return val;
+ tname = type_name(type);
v = convert_type(mrb, val, tname, method, TRUE);
if (mrb_type(v) != type) {
if (type == MRB_TT_STRING) return mrb_any_to_s(mrb, val);
- mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be converted to %s by #%s", val, tname, method);
+ mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be converted to %s by #%n", val, tname, method);
}
return v;
}
MRB_API mrb_value
-mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method)
+mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method)
{
mrb_value v;
if (mrb_type(val) == type && type != MRB_TT_DATA && type != MRB_TT_ISTRUCT) return val;
- v = convert_type(mrb, val, tname, method, FALSE);
+ v = convert_type(mrb, val, type_name(type), method, FALSE);
if (mrb_nil_p(v) || mrb_type(v) != type) return mrb_nil_value();
return v;
}
-static const struct types {
- unsigned char type;
- const char *name;
-} builtin_types[] = {
-/* {MRB_TT_NIL, "nil"}, */
- {MRB_TT_FALSE, "false"},
- {MRB_TT_TRUE, "true"},
- {MRB_TT_FIXNUM, "Fixnum"},
- {MRB_TT_SYMBOL, "Symbol"}, /* :symbol */
- {MRB_TT_MODULE, "Module"},
- {MRB_TT_OBJECT, "Object"},
- {MRB_TT_CLASS, "Class"},
- {MRB_TT_ICLASS, "iClass"}, /* internal use: mixed-in module holder */
- {MRB_TT_SCLASS, "SClass"},
- {MRB_TT_PROC, "Proc"},
-#ifndef MRB_WITHOUT_FLOAT
- {MRB_TT_FLOAT, "Float"},
-#endif
- {MRB_TT_ARRAY, "Array"},
- {MRB_TT_HASH, "Hash"},
- {MRB_TT_STRING, "String"},
- {MRB_TT_RANGE, "Range"},
-/* {MRB_TT_BIGNUM, "Bignum"}, */
- {MRB_TT_DATA, "Data"}, /* internal use: wrapped C pointers */
-/* {MRB_TT_VARMAP, "Varmap"}, */ /* internal use: dynamic variables */
-/* {MRB_TT_NODE, "Node"}, */ /* internal use: syntax tree node */
-/* {MRB_TT_UNDEF, "undef"}, */ /* internal use: #undef; should not happen */
- {MRB_TT_MAXDEFINE, 0}
-};
-
MRB_API void
mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
{
- const struct types *type = builtin_types;
- enum mrb_vtype xt;
-
- xt = mrb_type(x);
- if ((xt != t) || (xt == MRB_TT_DATA) || (xt == MRB_TT_ISTRUCT)) {
- while (type->type < MRB_TT_MAXDEFINE) {
- if (type->type == t) {
- const char *etype;
-
- if (mrb_nil_p(x)) {
- etype = "nil";
- }
- else if (mrb_fixnum_p(x)) {
- etype = "Fixnum";
- }
- else if (mrb_symbol_p(x)) {
- etype = "Symbol";
- }
- else if (mrb_immediate_p(x)) {
- etype = RSTRING_PTR(mrb_obj_as_string(mrb, x));
- }
- else {
- etype = mrb_obj_classname(mrb, x);
- }
- mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
- etype, type->name);
- }
- type++;
- }
- mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %d (%d given)", t, mrb_type(x));
+ enum mrb_vtype xt = mrb_type(x);
+ const char *tname, *ename;
+
+ if (t == xt) return;
+
+ tname = type_name(t);
+ if (mrb_nil_p(x)) {
+ ename = "nil";
+ }
+ else if (mrb_integer_p(x)) {
+ ename = "Fixnum";
+ }
+ else if (mrb_symbol_p(x)) {
+ ename = "Symbol";
+ }
+ else if (mrb_immediate_p(x)) {
+ ename = RSTRING_PTR(mrb_obj_as_string(mrb, x));
+ }
+ else {
+ ename = mrb_obj_classname(mrb, x);
+ }
+ if (tname) {
+ mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
+ ename, tname);
}
+ mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %d (%s given)", t, ename);
}
/* 15.3.1.3.46 */
@@ -504,8 +509,8 @@ MRB_API mrb_value
mrb_to_int(mrb_state *mrb, mrb_value val)
{
- if (!mrb_fixnum_p(val)) {
-#ifndef MRB_WITHOUT_FLOAT
+ if (!mrb_integer_p(val)) {
+#ifndef MRB_NO_FLOAT
if (mrb_float_p(val)) {
return mrb_flo_to_fixnum(mrb, val);
}
@@ -525,13 +530,13 @@ mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base)
mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Integer");
}
switch (mrb_type(val)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
if (base != 0) goto arg_error;
return mrb_flo_to_fixnum(mrb, val);
#endif
- case MRB_TT_FIXNUM:
+ case MRB_TT_INTEGER:
if (base != 0) goto arg_error;
return val;
@@ -561,7 +566,7 @@ mrb_Integer(mrb_state *mrb, mrb_value val)
return mrb_convert_to_integer(mrb, val, 0);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
MRB_API mrb_value
mrb_Float(mrb_state *mrb, mrb_value val)
{
@@ -569,8 +574,8 @@ mrb_Float(mrb_state *mrb, mrb_value val)
mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Float");
}
switch (mrb_type(val)) {
- case MRB_TT_FIXNUM:
- return mrb_float_value(mrb, (mrb_float)mrb_fixnum(val));
+ case MRB_TT_INTEGER:
+ return mrb_float_value(mrb, (mrb_float)mrb_integer(val));
case MRB_TT_FLOAT:
return val;
@@ -579,7 +584,7 @@ mrb_Float(mrb_state *mrb, mrb_value val)
return mrb_float_value(mrb, mrb_str_to_dbl(mrb, val, TRUE));
default:
- return mrb_convert_type(mrb, val, MRB_TT_FLOAT, "Float", "to_f");
+ return mrb_type_convert(mrb, val, MRB_TT_FLOAT, MRB_SYM(to_f));
}
}
#endif
@@ -648,12 +653,12 @@ 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(mrb, obj, "inspect", 0));
+ return mrb_obj_as_string(mrb, mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0));
}
MRB_API mrb_bool
mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
{
if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
- return mrb_test(mrb_funcall(mrb, obj1, "eql?", 1, obj2));
+ return mrb_test(mrb_funcall_id(mrb, obj1, MRB_QSYM(eql_p), 1, obj2));
}
diff --git a/src/print.c b/src/print.c
index a75814d81b4bf52514046e1ccba09c0cda17155b..6bf7da6a58a50adf9a1745cc0dd01a11031e77b6 100644
--- a/src/print.c
+++ b/src/print.c
@@ -60,11 +60,11 @@ mrb_print_error(mrb_state *mrb)
MRB_API void
mrb_show_version(mrb_state *mrb)
{
- printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_DESCRIPTION")), stdout);
+ printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(MRUBY_DESCRIPTION)), stdout);
}
MRB_API void
mrb_show_copyright(mrb_state *mrb)
{
- printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_COPYRIGHT")), stdout);
+ printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(MRUBY_COPYRIGHT)), stdout);
}
diff --git a/src/proc.c b/src/proc.c
index c00b09acf8536827c7a4f4cb75a7758563049a2c..b971b65205c5991dc4b718bba16b3f75fd734e36 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -14,8 +14,26 @@ static const mrb_code call_iseq[] = {
OP_CALL,
};
+static const mrb_irep call_irep = {
+ 0, /* nlocals */
+ 2, /* nregs */
+ 0, /* clen */
+ MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE, /* flags */
+ call_iseq, /* iseq */
+ NULL, /* pool */
+ NULL, /* syms */
+ NULL, /* reps */
+ NULL, /* lv */
+ NULL, /* debug_info */
+ 1, /* ilen */
+ 0, /* plen */
+ 0, /* slen */
+ 1, /* rlen */
+ 0, /* refcnt */
+};
+
struct RProc*
-mrb_proc_new(mrb_state *mrb, mrb_irep *irep)
+mrb_proc_new(mrb_state *mrb, const mrb_irep *irep)
{
struct RProc *p;
mrb_callinfo *ci = mrb->c->ci;
@@ -34,7 +52,7 @@ mrb_proc_new(mrb_state *mrb, mrb_irep *irep)
p->e.target_class = tc;
}
p->body.irep = irep;
- mrb_irep_incref(mrb, irep);
+ mrb_irep_incref(mrb, (mrb_irep*)irep);
return p;
}
@@ -44,7 +62,7 @@ env_new(mrb_state *mrb, mrb_int nlocals)
{
struct REnv *e;
mrb_callinfo *ci = mrb->c->ci;
- int bidx;
+ mrb_int bidx;
e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, NULL);
MRB_ENV_SET_LEN(e, nlocals);
@@ -63,7 +81,7 @@ static void
closure_setup(mrb_state *mrb, struct RProc *p)
{
mrb_callinfo *ci = mrb->c->ci;
- struct RProc *up = p->upper;
+ const struct RProc *up = p->upper;
struct REnv *e = NULL;
if (ci && ci->env) {
@@ -90,7 +108,7 @@ closure_setup(mrb_state *mrb, struct RProc *p)
}
struct RProc*
-mrb_closure_new(mrb_state *mrb, mrb_irep *irep)
+mrb_closure_new(mrb_state *mrb, const mrb_irep *irep)
{
struct RProc *p = mrb_proc_new(mrb, irep);
@@ -153,7 +171,7 @@ mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals)
MRB_API mrb_value
mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx)
{
- struct RProc *p = mrb->c->ci->proc;
+ const struct RProc *p = mrb->c->ci->proc;
struct REnv *e;
if (!p || !MRB_PROC_CFUNC_P(p)) {
@@ -181,7 +199,7 @@ mrb_proc_copy(struct RProc *a, struct RProc *b)
a->flags = b->flags;
a->body = b->body;
if (!MRB_PROC_CFUNC_P(a) && a->body.irep) {
- a->body.irep->refcnt++;
+ mrb_irep_incref(NULL, (mrb_irep*)a->body.irep);
}
a->upper = b->upper;
a->e.env = b->e.env;
@@ -200,7 +218,7 @@ mrb_proc_s_new(mrb_state *mrb, mrb_value proc_class)
p = (struct RProc *)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb_class_ptr(proc_class));
mrb_proc_copy(p, mrb_proc_ptr(blk));
proc = mrb_obj_value(p);
- mrb_funcall_with_block(mrb, proc, mrb_intern_lit(mrb, "initialize"), 0, NULL, proc);
+ mrb_funcall_with_block(mrb, proc, MRB_SYM(initialize), 0, NULL, proc);
if (!MRB_PROC_STRICT_P(p) &&
mrb->c->ci > mrb->c->cibase && MRB_PROC_ENV(p) == mrb->c->ci[-1].env) {
p->flags |= MRB_PROC_ORPHAN;
@@ -224,7 +242,7 @@ mrb_proc_init_copy(mrb_state *mrb, mrb_value self)
static mrb_value
proc_arity(mrb_state *mrb, mrb_value self)
{
- return mrb_fixnum_value(mrb_proc_arity(mrb_proc_ptr(self)));
+ return mrb_int_value(mrb, mrb_proc_arity(mrb_proc_ptr(self)));
}
/* 15.3.1.2.6 */
@@ -262,7 +280,7 @@ proc_lambda(mrb_state *mrb, mrb_value self)
mrb_int
mrb_proc_arity(const struct RProc *p)
{
- struct mrb_irep *irep;
+ const mrb_irep *irep;
const mrb_code *pc;
mrb_aspec aspec;
int ma, op, ra, pa, arity;
@@ -293,40 +311,20 @@ mrb_proc_arity(const struct RProc *p)
return arity;
}
-static void
-tempirep_free(mrb_state *mrb, void *p)
-{
- if (p) mrb_irep_free(mrb, (mrb_irep *)p);
-}
-
-static const mrb_data_type tempirep_type = { "temporary irep", tempirep_free };
-
void
mrb_init_proc(mrb_state *mrb)
{
struct RProc *p;
mrb_method_t m;
- struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
- mrb_irep *call_irep;
- static const mrb_irep mrb_irep_zero = { 0 };
-
- call_irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep));
- irep_obj->data = call_irep;
- *call_irep = mrb_irep_zero;
- call_irep->flags = MRB_ISEQ_NO_FREE;
- call_irep->iseq = call_iseq;
- call_irep->ilen = 1;
- call_irep->nregs = 2; /* receiver and block */
mrb_define_class_method(mrb, mrb->proc_class, "new", mrb_proc_s_new, MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
mrb_define_method(mrb, mrb->proc_class, "initialize_copy", mrb_proc_init_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->proc_class, "arity", proc_arity, MRB_ARGS_NONE());
- p = mrb_proc_new(mrb, call_irep);
- irep_obj->data = NULL;
+ p = mrb_proc_new(mrb, &call_irep);
MRB_METHOD_FROM_PROC(m, p);
- mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "call"), m);
- mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "[]"), m);
+ mrb_define_method_raw(mrb, mrb->proc_class, MRB_SYM(call), m);
+ mrb_define_method_raw(mrb, mrb->proc_class, MRB_QSYM(aref), m);
mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.2.6 */
mrb_define_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.3.27 */
diff --git a/src/range.c b/src/range.c
index 0b4e6dbcab238aea31570510d48131d9a04595d9..c06a8a00ba5cb77a64545a2edc8c052b0b3ef96e 100644
--- a/src/range.c
+++ b/src/range.c
@@ -23,11 +23,11 @@ r_check(mrb_state *mrb, mrb_value a, mrb_value b)
ta = mrb_type(a);
tb = mrb_type(b);
-#ifdef MRB_WITHOUT_FLOAT
- if (ta == MRB_TT_FIXNUM && tb == MRB_TT_FIXNUM ) {
+#ifdef MRB_NO_FLOAT
+ if (ta == MRB_TT_INTEGER && tb == MRB_TT_INTEGER ) {
#else
- if ((ta == MRB_TT_FIXNUM || ta == MRB_TT_FLOAT) &&
- (tb == MRB_TT_FIXNUM || tb == MRB_TT_FLOAT)) {
+ if ((ta == MRB_TT_INTEGER || ta == MRB_TT_FLOAT) &&
+ (tb == MRB_TT_INTEGER || tb == MRB_TT_FLOAT)) {
#endif
return;
}
@@ -78,7 +78,7 @@ range_ptr_init(mrb_state *mrb, struct RRange *r, mrb_value beg, mrb_value end, m
if (r) {
if (RANGE_INITIALIZED_P(r)) {
/* Ranges are immutable, so that they should be initialized only once. */
- mrb_name_error(mrb, mrb_intern_lit(mrb, "initialize"), "'initialize' called twice");
+ mrb_name_error(mrb, MRB_SYM(initialize), "'initialize' called twice");
}
else {
range_ptr_alloc_edges(mrb, r);
@@ -328,8 +328,8 @@ mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, con
result = mrb_ary_new(mrb);
for (i = 0; i < argc; ++i) {
- if (mrb_fixnum_p(argv[i])) {
- mrb_ary_push(mrb, result, func(mrb, obj, mrb_fixnum(argv[i])));
+ if (mrb_integer_p(argv[i])) {
+ mrb_ary_push(mrb, result, func(mrb, obj, mrb_integer(argv[i])));
}
else if (mrb_range_beg_len(mrb, argv[i], &beg, &len, olen, FALSE) == MRB_RANGE_OK) {
mrb_int const end = olen < beg + len ? olen : beg + len;
diff --git a/src/state.c b/src/state.c
index 790f7ca138c7984ff3275844a1e6bd5f63d3ab0e..1f85448a1e01a662b576f82fc72e0d265bf2e758 100644
--- a/src/state.c
+++ b/src/state.c
@@ -107,12 +107,14 @@ void mrb_free_symtbl(mrb_state *mrb);
void
mrb_irep_incref(mrb_state *mrb, mrb_irep *irep)
{
+ if (irep->flags & MRB_IREP_NO_FREE) return;
irep->refcnt++;
}
void
mrb_irep_decref(mrb_state *mrb, mrb_irep *irep)
{
+ if (irep->flags & MRB_IREP_NO_FREE) return;
irep->refcnt--;
if (irep->refcnt == 0) {
mrb_irep_free(mrb, irep);
@@ -122,12 +124,14 @@ mrb_irep_decref(mrb_state *mrb, mrb_irep *irep)
void
mrb_irep_cutref(mrb_state *mrb, mrb_irep *irep)
{
- mrb_irep *tmp;
+ mrb_irep **reps;
int i;
+ if (irep->flags & MRB_IREP_NO_FREE) return;
+ reps = (mrb_irep**)irep->reps;
for (i=0; i<irep->rlen; i++) {
- tmp = irep->reps[i];
- irep->reps[i] = NULL;
+ mrb_irep *tmp = reps[i];
+ reps[i] = NULL;
if (tmp) mrb_irep_decref(mrb, tmp);
}
}
@@ -137,29 +141,26 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
{
int i;
+ if (irep->flags & MRB_IREP_NO_FREE) return;
if (!(irep->flags & MRB_ISEQ_NO_FREE))
mrb_free(mrb, (void*)irep->iseq);
- if (irep->pool) for (i=0; i<irep->plen; i++) {
- if (mrb_string_p(irep->pool[i])) {
- mrb_gc_free_str(mrb, RSTRING(irep->pool[i]));
- mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
+ if (irep->pool) {
+ for (i=0; i<irep->plen; i++) {
+ if ((irep->pool[i].tt & 3) == IREP_TT_STR) {
+ mrb_free(mrb, (void*)irep->pool[i].u.str);
+ }
}
-#if defined(MRB_WORD_BOXING) && !defined(MRB_WITHOUT_FLOAT)
- else if (mrb_float_p(irep->pool[i])) {
- mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
- }
-#endif
+ mrb_free(mrb, (void*)irep->pool);
}
- mrb_free(mrb, irep->pool);
- mrb_free(mrb, irep->syms);
+ mrb_free(mrb, (void*)irep->syms);
if (irep->reps) {
for (i=0; i<irep->rlen; i++) {
if (irep->reps[i])
- mrb_irep_decref(mrb, irep->reps[i]);
+ mrb_irep_decref(mrb, (mrb_irep*)irep->reps[i]);
}
+ mrb_free(mrb, (void*)irep->reps);
}
- mrb_free(mrb, irep->reps);
- mrb_free(mrb, irep->lv);
+ mrb_free(mrb, (void*)irep->lv);
mrb_debug_info_free(mrb, irep->debug_info);
mrb_free(mrb, irep);
}
@@ -170,8 +171,6 @@ mrb_free_context(mrb_state *mrb, struct mrb_context *c)
if (!c) return;
mrb_free(mrb, c->stbase);
mrb_free(mrb, c->cibase);
- mrb_free(mrb, c->rescue);
- mrb_free(mrb, c->ensure);
mrb_free(mrb, c);
}
diff --git a/src/string.c b/src/string.c
index c83e791b6add18ba05c2f68bab9c0696f9a46843..f271452963a16a2c75c16d7547964aaa6bc93ce3 100644
--- a/src/string.c
+++ b/src/string.c
@@ -8,7 +8,7 @@
# define _CRT_NONSTDC_NO_DEPRECATE
#endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#include <float.h>
#include <math.h>
#endif
@@ -583,9 +583,6 @@ str_share(mrb_state *mrb, struct RString *orig, struct RString *s)
else if (RSTR_FSHARED_P(orig)) {
str_init_fshared(orig, s, orig->as.heap.aux.fshared);
}
- else if (mrb_frozen_p(orig) && !RSTR_POOL_P(orig)) {
- str_init_fshared(orig, s, orig);
- }
else {
if (orig->as.heap.aux.capa > orig->as.heap.len) {
orig->as.heap.ptr = (char *)mrb_realloc(mrb, orig->as.heap.ptr, len+1);
@@ -596,29 +593,6 @@ str_share(mrb_state *mrb, struct RString *orig, struct RString *s)
}
}
-mrb_value
-mrb_str_pool(mrb_state *mrb, const char *p, mrb_int len, mrb_bool nofree)
-{
- struct RString *s = (struct RString *)mrb_malloc(mrb, sizeof(struct RString));
-
- s->tt = MRB_TT_STRING;
- s->c = mrb->string_class;
- s->flags = 0;
-
- if (RSTR_EMBEDDABLE_P(len)) {
- str_init_embed(s, p, len);
- }
- else if (nofree) {
- str_init_nofree(s, p, len);
- }
- else {
- str_init_normal(mrb, s, p, len);
- }
- RSTR_SET_POOL_FLAG(s);
- MRB_SET_FROZEN_FLAG(s);
- return mrb_obj_value(s);
-}
-
mrb_value
mrb_str_byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)
{
@@ -898,7 +872,7 @@ mrb_str_to_cstr(mrb_state *mrb, mrb_value str0)
MRB_API void
mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
{
- other = mrb_str_to_str(mrb, other);
+ other = mrb_obj_as_string(mrb, other);
mrb_str_cat_str(mrb, self, other);
}
@@ -1111,30 +1085,11 @@ mrb_str_equal_m(mrb_state *mrb, mrb_value str1)
}
/* ---------------------------------- */
-MRB_API mrb_value
-mrb_str_to_str(mrb_state *mrb, mrb_value str)
-{
- switch (mrb_type(str)) {
- case MRB_TT_STRING:
- return str;
- case MRB_TT_SYMBOL:
- return mrb_sym_str(mrb, mrb_symbol(str));
- case MRB_TT_FIXNUM:
- return mrb_fixnum_to_str(mrb, str, 10);
- case MRB_TT_SCLASS:
- case MRB_TT_CLASS:
- case MRB_TT_MODULE:
- return mrb_mod_to_s(mrb, str);
- default:
- return mrb_convert_type(mrb, str, MRB_TT_STRING, "String", "to_s");
- }
-}
-
/* obslete: use RSTRING_PTR() */
MRB_API const char*
mrb_string_value_ptr(mrb_state *mrb, mrb_value str)
{
- str = mrb_str_to_str(mrb, str);
+ str = mrb_obj_as_string(mrb, str);
return RSTRING_PTR(str);
}
@@ -1180,8 +1135,8 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen,
}
else {
switch (mrb_type(indx)) {
- case MRB_TT_FIXNUM:
- *beg = mrb_fixnum(indx);
+ case MRB_TT_INTEGER:
+ *beg = mrb_integer(indx);
*len = 1;
return STR_CHAR_RANGE;
@@ -1196,8 +1151,8 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen,
default:
indx = mrb_to_int(mrb, indx);
- if (mrb_fixnum_p(indx)) {
- *beg = mrb_fixnum(indx);
+ if (mrb_integer_p(indx)) {
+ *beg = mrb_integer(indx);
*len = 1;
return STR_CHAR_RANGE;
}
@@ -1212,7 +1167,7 @@ range_arg:
break;
}
- mrb_raise(mrb, E_TYPE_ERROR, "can't convert to Fixnum");
+ mrb_raise(mrb, E_TYPE_ERROR, "can't convert to Integer");
}
}
return STR_OUT_OF_RANGE;
@@ -1256,8 +1211,8 @@ mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen)
* str.slice(range) => new_str or nil
* str.slice(other_str) => new_str or nil
*
- * Element Reference---If passed a single <code>Fixnum</code>, returns the code
- * of the character at that position. If passed two <code>Fixnum</code>
+ * Element Reference---If passed a single <code>Integer</code>, returns the code
+ * of the character at that position. If passed two <code>Integer</code>
* objects, returns a substring starting at the offset given by the first, and
* a length given by the second. If given a range, a substring containing
* characters at offsets given by the range is returned. In all three cases, if
@@ -1963,7 +1918,20 @@ mrb_str_intern(mrb_state *mrb, mrb_value self)
MRB_API mrb_value
mrb_obj_as_string(mrb_state *mrb, mrb_value obj)
{
- return mrb_str_to_str(mrb, obj);
+ switch (mrb_type(obj)) {
+ case MRB_TT_STRING:
+ return obj;
+ case MRB_TT_SYMBOL:
+ return mrb_sym_str(mrb, mrb_symbol(obj));
+ case MRB_TT_INTEGER:
+ return mrb_fixnum_to_str(mrb, obj, 10);
+ case MRB_TT_SCLASS:
+ case MRB_TT_CLASS:
+ case MRB_TT_MODULE:
+ return mrb_mod_to_s(mrb, obj);
+ default:
+ return mrb_type_convert(mrb, obj, MRB_TT_STRING, MRB_SYM(to_s));
+ }
}
MRB_API mrb_value
@@ -2391,7 +2359,7 @@ mrb_str_len_to_inum(mrb_state *mrb, const char *str, size_t len, mrb_int base, i
n *= base;
n += c;
if (n > (uint64_t)MRB_INT_MAX + (sign ? 0 : 1)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
if (base == 10) {
return mrb_float_value(mrb, mrb_str_to_dbl(mrb, mrb_str_new(mrb, str, len), badcheck));
}
@@ -2502,7 +2470,7 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self)
return mrb_str_to_inum(mrb, self, base, FALSE);
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
double
mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck)
{
@@ -2524,8 +2492,8 @@ mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck)
if (!badcheck) return 0.0;
x = mrb_str_len_to_inum(mrb, p, pend-p, 0, badcheck);
- if (mrb_fixnum_p(x))
- d = (double)mrb_fixnum(x);
+ if (mrb_integer_p(x))
+ d = (double)mrb_integer(x);
else /* if (mrb_float_p(x)) */
d = mrb_float(x);
return d;
@@ -2900,7 +2868,7 @@ mrb_str_byteslice(mrb_state *mrb, mrb_value str)
}
}
else {
- beg = mrb_fixnum(mrb_to_int(mrb, a1));
+ beg = mrb_integer(mrb_to_int(mrb, a1));
len = 1;
empty = FALSE;
}
@@ -2963,7 +2931,7 @@ mrb_init_string(mrb_state *mrb)
mrb_define_method(mrb, s, "slice", mrb_str_aref_m, MRB_ARGS_ANY()); /* 15.2.10.5.34 */
mrb_define_method(mrb, s, "split", mrb_str_split_m, MRB_ARGS_ANY()); /* 15.2.10.5.35 */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
mrb_define_method(mrb, s, "to_f", mrb_str_to_f, MRB_ARGS_NONE()); /* 15.2.10.5.38 */
#endif
mrb_define_method(mrb, s, "to_i", mrb_str_to_i, MRB_ARGS_ANY()); /* 15.2.10.5.39 */
@@ -2980,7 +2948,7 @@ mrb_init_string(mrb_state *mrb)
mrb_define_method(mrb, s, "byteslice", mrb_str_byteslice, MRB_ARGS_ARG(1,1));
}
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
/*
* Source code for the "strtod" library procedure.
*
diff --git a/src/symbol.c b/src/symbol.c
index 99284879797cd05c010051e138312400eec6fbe3..add093d14805e53dbe80c07219d2bbe454482b70 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -12,6 +12,59 @@
#include <mruby/dump.h>
#include <mruby/class.h>
+#undef MRB_PRESYM_MAX
+#undef MRB_PRESYM_CSYM
+#undef MRB_PRESYM_QSYM
+#undef MRB_PRESYM_SYM
+#define MRB_PRESYM_CSYM(sym, num) {#sym,sizeof(#sym)-1},
+#define MRB_PRESYM_QSYM(str, name, num) {str,sizeof(str)-1},
+#define MRB_PRESYM_SYM(str, num) {str,sizeof(str)-1},
+
+static const struct {
+ const char *name;
+ uint16_t len;
+} presym_table[] = {
+#include <../build/presym.inc>
+ {0,0}
+};
+
+static mrb_sym
+presym_find(const char *name, size_t len)
+{
+ int start = 0;
+ int end = MRB_PRESYM_MAX-1;
+
+ while (start<=end) {
+ int mid = (start+end)/2;
+ size_t plen = presym_table[mid].len;
+ size_t tlen = (plen > len) ? len : plen;
+ int cmp;
+
+ cmp = memcmp(name, presym_table[mid].name, tlen);
+ if (cmp == 0) {
+ if (len > plen) cmp = 1;
+ else if (len < plen) cmp = -1;
+ }
+
+ if (cmp == 0) {
+ return mid+1;
+ } else if (cmp > 0) {
+ start = mid+1;
+ } else {
+ end = mid-1;
+ }
+ }
+ return 0;
+}
+
+static const char*
+presym_sym2name(mrb_sym sym, mrb_int *lenp)
+{
+ if (sym > MRB_PRESYM_MAX) return NULL;
+ if (lenp) *lenp = presym_table[sym-1].len;
+ return presym_table[sym-1].name;
+}
+
/* ------------------------------------------------------ */
typedef struct symbol_name {
mrb_bool lit : 1;
@@ -20,20 +73,15 @@ typedef struct symbol_name {
const char *name;
} symbol_name;
-#define SYMBOL_INLINE_BIT_POS 1
-#define SYMBOL_INLINE_LOWER_BIT_POS 2
-#define SYMBOL_INLINE (1 << (SYMBOL_INLINE_BIT_POS - 1))
-#define SYMBOL_INLINE_LOWER (1 << (SYMBOL_INLINE_LOWER_BIT_POS - 1))
-#define SYMBOL_NORMAL_SHIFT SYMBOL_INLINE_BIT_POS
-#define SYMBOL_INLINE_SHIFT SYMBOL_INLINE_LOWER_BIT_POS
#ifdef MRB_ENABLE_ALL_SYMBOLS
+#define SYMBOL_SHIFT 0
# define SYMBOL_INLINE_P(sym) FALSE
-# define SYMBOL_INLINE_LOWER_P(sym) FALSE
# define sym_inline_pack(name, len) 0
# define sym_inline_unpack(sym, buf, lenp) NULL
#else
+#define SYMBOL_INLINE 1
+#define SYMBOL_SHIFT 1
# define SYMBOL_INLINE_P(sym) ((sym) & SYMBOL_INLINE)
-# define SYMBOL_INLINE_LOWER_P(sym) ((sym) & SYMBOL_INLINE_LOWER)
#endif
static void
@@ -50,16 +98,14 @@ static const char pack_table[] = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRS
static mrb_sym
sym_inline_pack(const char *name, size_t len)
{
- const size_t lower_length_max = (MRB_SYMBOL_BIT - 2) / 5;
- const size_t mix_length_max = (MRB_SYMBOL_BIT - 2) / 6;
+ const size_t pack_length_max = (MRB_SYMBOL_BIT - 2) / 6;
char c;
const char *p;
size_t i;
mrb_sym sym = 0;
- mrb_bool lower = TRUE;
- if (len > lower_length_max) return 0; /* too long */
+ if (len > pack_length_max) return 0; /* too long */
for (i=0; i<len; i++) {
uint32_t bits;
@@ -68,36 +114,21 @@ sym_inline_pack(const char *name, size_t len)
p = strchr(pack_table, (int)c);
if (p == 0) return 0; /* non alnum char */
bits = (uint32_t)(p - pack_table)+1;
- if (bits > 27) lower = FALSE;
- if (i >= mix_length_max) break;
- sym |= bits<<(i*6+SYMBOL_INLINE_SHIFT);
+ if (i >= pack_length_max) break;
+ sym |= bits<<(i*6+SYMBOL_SHIFT);
}
- if (lower) {
- sym = 0;
- for (i=0; i<len; i++) {
- uint32_t bits;
-
- c = name[i];
- p = strchr(pack_table, (int)c);
- bits = (uint32_t)(p - pack_table)+1;
- sym |= bits<<(i*5+SYMBOL_INLINE_SHIFT);
- }
- return sym | SYMBOL_INLINE | SYMBOL_INLINE_LOWER;
- }
- if (len > mix_length_max) return 0;
return sym | SYMBOL_INLINE;
}
static const char*
sym_inline_unpack(mrb_sym sym, char *buf, mrb_int *lenp)
{
- int bit_per_char = SYMBOL_INLINE_LOWER_P(sym) ? 5 : 6;
int i;
mrb_assert(SYMBOL_INLINE_P(sym));
- for (i=0; i<30/bit_per_char; i++) {
- uint32_t bits = sym>>(i*bit_per_char+SYMBOL_INLINE_SHIFT) & ((1<<bit_per_char)-1);
+ for (i=0; i<5; i++) {
+ uint32_t bits = sym>>(i*6+SYMBOL_SHIFT) & ((1<<6)-1);
if (bits == 0) break;
buf[i] = pack_table[bits-1];;
}
@@ -130,6 +161,10 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp)
symbol_name *sname;
uint8_t hash;
+ /* presym */
+ i = presym_find(name, len);
+ if (i > 0) return i<<SYMBOL_SHIFT;
+
/* inline symbol */
i = sym_inline_pack(name, len);
if (i > 0) return i;
@@ -142,14 +177,14 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp)
do {
sname = &mrb->symtbl[i];
if (sname->len == len && memcmp(sname->name, name, len) == 0) {
- return i<<SYMBOL_NORMAL_SHIFT;
+ return (i+MRB_PRESYM_MAX)<<SYMBOL_SHIFT;
}
if (sname->prev == 0xff) {
i -= 0xff;
sname = &mrb->symtbl[i];
while (mrb->symtbl < sname) {
if (sname->len == len && memcmp(sname->name, name, len) == 0) {
- return (mrb_sym)(sname - mrb->symtbl)<<SYMBOL_NORMAL_SHIFT;
+ return (mrb_sym)(sname - mrb->symtbl)<<SYMBOL_SHIFT;
}
sname--;
}
@@ -205,7 +240,7 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit)
}
mrb->symhash[hash] = mrb->symidx = sym;
- return sym<<SYMBOL_NORMAL_SHIFT;
+ return (sym+MRB_PRESYM_MAX)<<SYMBOL_SHIFT;
}
MRB_API mrb_sym
@@ -232,27 +267,51 @@ mrb_intern_str(mrb_state *mrb, mrb_value str)
return mrb_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
}
-MRB_API mrb_value
-mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
+MRB_API mrb_sym
+mrb_intern_check(mrb_state *mrb, const char *name, size_t len)
{
mrb_sym sym;
sym_validate_len(mrb, len);
sym = find_symbol(mrb, name, len, NULL);
- if (sym > 0) return mrb_symbol_value(sym);
- return mrb_nil_value();
+ if (sym > 0) return sym;
+ return 0;
+}
+
+MRB_API mrb_value
+mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
+{
+ mrb_sym sym = mrb_intern_check(mrb, name, len);
+ if (sym == 0) return mrb_nil_value();
+ return mrb_symbol_value(sym);
+}
+
+MRB_API mrb_sym
+mrb_intern_check_cstr(mrb_state *mrb, const char *name)
+{
+ return mrb_intern_check(mrb, name, strlen(name));
}
MRB_API mrb_value
mrb_check_intern_cstr(mrb_state *mrb, const char *name)
{
- return mrb_check_intern(mrb, name, strlen(name));
+ mrb_sym sym = mrb_intern_check_cstr(mrb, name);
+ if (sym == 0) return mrb_nil_value();
+ return mrb_symbol_value(sym);
+}
+
+MRB_API mrb_sym
+mrb_intern_check_str(mrb_state *mrb, mrb_value str)
+{
+ return mrb_intern_check(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
}
MRB_API mrb_value
mrb_check_intern_str(mrb_state *mrb, mrb_value str)
{
- return mrb_check_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
+ mrb_sym sym = mrb_intern_check_str(mrb, str);
+ if (sym == 0) return mrb_nil_value();
+ return mrb_symbol_value(sym);
}
static const char*
@@ -260,7 +319,13 @@ sym2name_len(mrb_state *mrb, mrb_sym sym, char *buf, mrb_int *lenp)
{
if (SYMBOL_INLINE_P(sym)) return sym_inline_unpack(sym, buf, lenp);
- sym >>= SYMBOL_NORMAL_SHIFT;
+ sym >>= SYMBOL_SHIFT;
+ {
+ const char *name = presym_sym2name(sym, lenp);
+ if (name) return name;
+ }
+ sym -= MRB_PRESYM_MAX;
+
if (sym == 0 || mrb->symidx < sym) {
if (lenp) *lenp = 0;
return NULL;
@@ -276,6 +341,15 @@ mrb_sym_name_len(mrb_state *mrb, mrb_sym sym, mrb_int *lenp)
return sym2name_len(mrb, sym, mrb->symbuf, lenp);
}
+mrb_bool
+mrb_sym_static_p(mrb_state *mrb, mrb_sym sym)
+{
+ if (SYMBOL_INLINE_P(sym)) return TRUE;
+ sym >>= SYMBOL_SHIFT;
+ if (sym > MRB_PRESYM_MAX) return FALSE;
+ return TRUE;
+}
+
void
mrb_free_symtbl(mrb_state *mrb)
{
@@ -497,7 +571,7 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
char *sp;
name = mrb_sym_name_len(mrb, id, &len);
- str = mrb_str_new(mrb, 0, len+1);
+ str = mrb_str_new(mrb, NULL, len+1);
sp = RSTRING_PTR(str);
sp[0] = ':';
memcpy(sp+1, name, len);
diff --git a/src/value_array.h b/src/value_array.h
index bc5f28b0637439f55ce69e0bf1da017207fb0a14..6089b8aa0f0751d8620b2c9d2fcf8070e8ad8a51 100644
--- a/src/value_array.h
+++ b/src/value_array.h
@@ -6,6 +6,7 @@
static inline void
value_move(mrb_value *s1, const mrb_value *s2, size_t n)
{
+ if (n == 0) return;
if (s1 > s2 && s1 < s2 + n)
{
s1 += n;
diff --git a/src/variable.c b/src/variable.c
index c36fea6e33c76e2ce8ba3a113813f8985cda854e..f1375fd4d2a399c650e8a012ff81ef5dbf6a7b6c 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -11,21 +11,16 @@
#include <mruby/string.h>
#include <mruby/variable.h>
-#ifndef MRB_IV_SEGMENT_SIZE
-#define MRB_IV_SEGMENT_SIZE 4
-#endif
-
-typedef struct segment {
- mrb_sym key[MRB_IV_SEGMENT_SIZE];
- mrb_value val[MRB_IV_SEGMENT_SIZE];
- struct segment *next;
-} segment;
+struct iv_elem {
+ mrb_sym key;
+ mrb_value val;
+};
/* Instance variable table structure */
typedef struct iv_tbl {
- segment *rootseg;
size_t size;
- size_t last_len;
+ size_t alloc;
+ struct iv_elem *table;
} iv_tbl;
/* Creates the instance variable table. */
@@ -36,67 +31,82 @@ iv_new(mrb_state *mrb)
t = (iv_tbl*)mrb_malloc(mrb, sizeof(iv_tbl));
t->size = 0;
- t->rootseg = NULL;
- t->last_len = 0;
+ t->alloc = 0;
+ t->table = NULL;
return t;
}
+static void iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val);
+
+static void
+iv_rehash(mrb_state *mrb, iv_tbl *t)
+{
+ size_t old_alloc = t->alloc;
+ size_t new_alloc = old_alloc+1;
+ struct iv_elem *old_table = t->table;
+
+ khash_power2(new_alloc);
+ if (old_alloc == new_alloc) return;
+
+ t->alloc = new_alloc;
+ t->size = 0;
+ t->table = (struct iv_elem*)mrb_calloc(mrb, sizeof(struct iv_elem), new_alloc);
+
+ for (size_t i = 0; i < old_alloc; i++) {
+ struct iv_elem *slot = &old_table[i];
+
+ /* key = 0 means empty; val = undef means deleted */
+ if (slot->key != 0 && !mrb_undef_p(slot->val)) {
+ iv_put(mrb, t, slot->key, slot->val);
+ }
+ }
+ mrb_free(mrb, old_table);
+}
+
+#define slot_empty_p(slot) ((slot)->key == 0 && !mrb_undef_p((slot)->val))
+
/* Set the value for the symbol in the instance variable table. */
static void
iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
{
- segment *seg;
- segment *prev = NULL;
- segment *matched_seg = NULL;
- size_t matched_idx = 0;
- size_t i;
+ size_t hash, pos, start;
+ struct iv_elem *dslot = NULL;
if (t == NULL) return;
- seg = t->rootseg;
- while (seg) {
- for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
- mrb_sym key = seg->key[i];
- /* Found room in last segment after last_len */
- if (!seg->next && i >= t->last_len) {
- seg->key[i] = sym;
- seg->val[i] = val;
- t->last_len = i+1;
+ if (t->alloc == 0) {
+ iv_rehash(mrb, t);
+ }
+ hash = kh_int_hash_func(mrb, sym);
+ start = pos = hash & (t->alloc-1);
+ for (;;) {
+ struct iv_elem *slot = &t->table[pos];
+
+ if (slot->key == sym) {
+ slot->val = val;
+ return;
+ }
+ else if (slot_empty_p(slot)) {
+ t->size++;
+ slot->key = sym;
+ slot->val = val;
+ return;
+ }
+ else if (!dslot && mrb_undef_p(slot->val)) { /* deleted */
+ dslot = slot;
+ }
+ pos = (pos+1) & (t->alloc-1);
+ if (pos == start) { /* not found */
+ if (dslot) {
t->size++;
+ dslot->key = sym;
+ dslot->val = val;
return;
}
- if (!matched_seg && key == 0) {
- matched_seg = seg;
- matched_idx = i;
- }
- else if (key == sym) {
- seg->val[i] = val;
- return;
- }
+ /* no room */
+ iv_rehash(mrb, t);
+ start = pos = hash & (t->alloc-1);
}
- prev = seg;
- seg = seg->next;
- }
-
- /* Not found */
- if (matched_seg) {
- matched_seg->key[matched_idx] = sym;
- matched_seg->val[matched_idx] = val;
- t->size++;
- return;
- }
-
- seg = (segment*)mrb_malloc(mrb, sizeof(segment));
- seg->next = NULL;
- seg->key[0] = sym;
- seg->val[0] = val;
- t->last_len = 1;
- t->size++;
- if (prev) {
- prev->next = seg;
- }
- else {
- t->rootseg = seg;
}
}
@@ -104,80 +114,81 @@ iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
static mrb_bool
iv_get(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
{
- segment *seg;
- size_t i;
+ size_t hash, pos, start;
if (t == NULL) return FALSE;
- seg = t->rootseg;
- while (seg) {
- for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
- mrb_sym key = seg->key[i];
+ if (t->alloc == 0) return FALSE;
+ if (t->size == 0) return FALSE;
- if (!seg->next && i >= t->last_len) {
- return FALSE;
- }
- if (key == sym) {
- if (vp) *vp = seg->val[i];
- return TRUE;
- }
+ hash = kh_int_hash_func(mrb, sym);
+ start = pos = hash & (t->alloc-1);
+ for (;;) {
+ struct iv_elem *slot = &t->table[pos];
+
+ if (slot->key == sym) {
+ if (vp) *vp = slot->val;
+ return TRUE;
+ }
+ else if (slot_empty_p(slot)) {
+ return FALSE;
+ }
+ pos = (pos+1) & (t->alloc-1);
+ if (pos == start) { /* not found */
+ return FALSE;
}
- seg = seg->next;
}
- return FALSE;
}
/* Deletes the value for the symbol from the instance variable table. */
static mrb_bool
iv_del(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
{
- segment *seg;
- size_t i;
+ size_t hash, pos, start;
if (t == NULL) return FALSE;
- seg = t->rootseg;
- while (seg) {
- for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
- mrb_sym key = seg->key[i];
+ if (t->alloc == 0) return FALSE;
+ if (t->size == 0) return FALSE;
- if (!seg->next && i >= t->last_len) {
- return FALSE;
- }
- if (key == sym) {
- t->size--;
- seg->key[i] = 0;
- if (vp) *vp = seg->val[i];
- return TRUE;
- }
+ hash = kh_int_hash_func(mrb, sym);
+ start = pos = hash & (t->alloc-1);
+ for (;;) {
+ struct iv_elem *slot = &t->table[pos];
+
+ if (slot->key == sym) {
+ if (vp) *vp = slot->val;
+ t->size--;
+ slot->key = 0;
+ slot->val = mrb_undef_value();
+ return TRUE;
+ }
+ else if (slot_empty_p(slot)) {
+ return FALSE;
+ }
+ pos = (pos+1) & (t->alloc-1);
+ if (pos == start) { /* not found */
+ return FALSE;
}
- seg = seg->next;
}
- return FALSE;
}
/* Iterates over the instance variable table. */
static void
iv_foreach(mrb_state *mrb, iv_tbl *t, mrb_iv_foreach_func *func, void *p)
{
- segment *seg;
size_t i;
if (t == NULL) return;
- seg = t->rootseg;
- while (seg) {
- for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
- mrb_sym key = seg->key[i];
+ if (t->alloc == 0) return;
+ if (t->size == 0) return;
- /* no value in last segment after last_len */
- if (!seg->next && i >= t->last_len) {
+ for (i=0; i<t->alloc; i++) {
+ struct iv_elem *slot = &t->table[i];
+
+ if (slot->key && !mrb_undef_p(slot->val)) {
+ if ((*func)(mrb, slot->key, slot->val, p) != 0) {
return;
}
- if (key != 0) {
- if ((*func)(mrb, key, seg->val[i], p) != 0) {
- return;
- }
- }
}
- seg = seg->next;
}
return;
}
@@ -186,47 +197,28 @@ iv_foreach(mrb_state *mrb, iv_tbl *t, mrb_iv_foreach_func *func, void *p)
static size_t
iv_size(mrb_state *mrb, iv_tbl *t)
{
- segment *seg;
- size_t size = 0;
-
if (t == NULL) return 0;
- if (t->size > 0) return t->size;
- seg = t->rootseg;
- while (seg) {
- if (seg->next == NULL) {
- size += t->last_len;
- return size;
- }
- seg = seg->next;
- size += MRB_IV_SEGMENT_SIZE;
- }
- /* empty iv_tbl */
- return 0;
+ return t->size;
}
/* Copy the instance variable table. */
static iv_tbl*
iv_copy(mrb_state *mrb, iv_tbl *t)
{
- segment *seg;
iv_tbl *t2;
-
size_t i;
- seg = t->rootseg;
- t2 = iv_new(mrb);
+ if (t == NULL) return NULL;
+ if (t->alloc == 0) return NULL;
+ if (t->size == 0) return NULL;
- while (seg != NULL) {
- for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
- mrb_sym key = seg->key[i];
- mrb_value val = seg->val[i];
+ t2 = iv_new(mrb);
+ for (i=0; i<t->alloc; i++) {
+ struct iv_elem *slot = &t->table[i];
- if ((seg->next == NULL) && (i >= t->last_len)) {
- return t2;
- }
- iv_put(mrb, t2, key, val);
+ if (slot->key && !mrb_undef_p(slot->val)) {
+ iv_put(mrb, t2, slot->key, slot->val);
}
- seg = seg->next;
}
return t2;
}
@@ -235,14 +227,7 @@ iv_copy(mrb_state *mrb, iv_tbl *t)
static void
iv_free(mrb_state *mrb, iv_tbl *t)
{
- segment *seg;
-
- seg = t->rootseg;
- while (seg) {
- segment *p = seg;
- seg = seg->next;
- mrb_free(mrb, p);
- }
+ mrb_free(mrb, t->table);
mrb_free(mrb, t);
}
@@ -379,11 +364,11 @@ assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
if (namespace_p(obj->tt) && namespace_p(mrb_type(v))) {
struct RObject *c = mrb_obj_ptr(v);
if (obj != c && ISUPPER(mrb_sym_name_len(mrb, sym, NULL)[0])) {
- mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__");
+ mrb_sym id_classname = MRB_SYM(__classname__);
mrb_value o = mrb_obj_iv_get(mrb, c, id_classname);
if (mrb_nil_p(o)) {
- mrb_sym id_outer = mrb_intern_lit(mrb, "__outer__");
+ mrb_sym id_outer = MRB_SYM(__outer__);
o = mrb_obj_iv_get(mrb, c, id_outer);
if (mrb_nil_p(o)) {
@@ -643,8 +628,7 @@ mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym)
if (cls && cls->tt == MRB_TT_SCLASS) {
mrb_value klass;
- klass = mrb_obj_iv_get(mrb, (struct RObject *)cls,
- mrb_intern_lit(mrb, "__attached__"));
+ klass = mrb_obj_iv_get(mrb, (struct RObject *)cls, MRB_SYM(__attached__));
c = mrb_class_ptr(klass);
if (c->tt == MRB_TT_CLASS || c->tt == MRB_TT_MODULE) {
given = FALSE;
@@ -688,8 +672,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
if (cls && cls->tt == MRB_TT_SCLASS) {
mrb_value klass;
- klass = mrb_obj_iv_get(mrb, (struct RObject*)cls,
- mrb_intern_lit(mrb, "__attached__"));
+ klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, MRB_SYM(__attached__));
switch (mrb_type(klass)) {
case MRB_TT_CLASS:
case MRB_TT_MODULE:
@@ -743,11 +726,11 @@ mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
{
struct RClass *c;
- struct RProc *p = mrb->c->ci->proc;
+ const struct RProc *p = mrb->c->ci->proc;
for (;;) {
c = MRB_PROC_TARGET_CLASS(p);
- if (c->tt != MRB_TT_SCLASS) break;
+ if (c && c->tt != MRB_TT_SCLASS) break;
p = p->upper;
}
return mrb_mod_cv_get(mrb, c, sym);
@@ -757,11 +740,11 @@ void
mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
{
struct RClass *c;
- struct RProc *p = mrb->c->ci->proc;
+ const struct RProc *p = mrb->c->ci->proc;
for (;;) {
c = MRB_PROC_TARGET_CLASS(p);
- if (c->tt != MRB_TT_SCLASS) break;
+ if (c && c->tt != MRB_TT_SCLASS) break;
p = p->upper;
}
mrb_mod_cv_set(mrb, c, sym, v);
@@ -803,7 +786,7 @@ L_RETRY:
goto L_RETRY;
}
name = mrb_symbol_value(sym);
- return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern_lit(mrb, "const_missing"), 1, &name);
+ return mrb_funcall_argv(mrb, mrb_obj_value(base), MRB_SYM(const_missing), 1, &name);
}
MRB_API mrb_value
@@ -819,9 +802,10 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
struct RClass *c;
struct RClass *c2;
mrb_value v;
- struct RProc *proc;
+ const struct RProc *proc;
c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+ if (!c) c = mrb->object_class;
if (iv_get(mrb, c->iv, sym, &v)) {
return v;
}
@@ -829,7 +813,7 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
while (c2 && c2->tt == MRB_TT_SCLASS) {
mrb_value klass;
- if (!iv_get(mrb, c2->iv, mrb_intern_lit(mrb, "__attached__"), &klass)) {
+ if (!iv_get(mrb, c2->iv, MRB_SYM(__attached__), &klass)) {
c2 = NULL;
break;
}
@@ -864,6 +848,7 @@ mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
struct RClass *c;
c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+ if (!c) c = mrb->object_class;
mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v);
}
@@ -874,6 +859,12 @@ mrb_const_remove(mrb_state *mrb, mrb_value mod, mrb_sym sym)
mrb_iv_remove(mrb, mod, sym);
}
+MRB_API void
+mrb_define_const_id(mrb_state *mrb, struct RClass *mod, mrb_sym name, mrb_value v)
+{
+ mrb_obj_iv_set(mrb, (struct RObject*)mod, name, v);
+}
+
MRB_API void
mrb_define_const(mrb_state *mrb, struct RClass *mod, const char *name, mrb_value v)
{
@@ -1070,7 +1061,7 @@ outer_class(mrb_state *mrb, struct RClass *c)
{
mrb_value ov;
- ov = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"));
+ ov = mrb_obj_iv_get(mrb, (struct RObject*)c, MRB_SYM(__outer__));
if (mrb_nil_p(ov)) return NULL;
switch (mrb_type(ov)) {
case MRB_TT_CLASS:
@@ -1120,8 +1111,8 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
str = mrb_sym_name_len(mrb, name, &len);
mrb_str_cat(mrb, path, str, len);
if (RSTRING_PTR(path)[0] != '#') {
- iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
- iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
+ iv_del(mrb, c->iv, MRB_SYM(__outer__), NULL);
+ iv_put(mrb, c->iv, MRB_SYM(__classname__), path);
mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
path = mrb_str_dup(mrb, path);
}
@@ -1131,16 +1122,9 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
size_t
mrb_obj_iv_tbl_memsize(mrb_state* mrb, mrb_value obj)
{
- size_t nseg = 0;
- segment *seg;
-
- if (mrb_obj_ptr(obj)->iv == NULL) return 0;
- seg = mrb_obj_ptr(obj)->iv->rootseg;
- while (seg) {
- nseg++;
- seg = seg->next;
- }
- return sizeof(iv_tbl) + sizeof(segment)*nseg;
+ iv_tbl *t = mrb_obj_ptr(obj)->iv;
+ if (t == NULL) return 0;
+ return sizeof(iv_tbl) + t->alloc*sizeof(struct iv_elem);
}
#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
diff --git a/src/vm.c b/src/vm.c
index cc9a187b7148ac78b2fb0675cb65e6242205e10d..d1f4660be0259b5f8478d8d1537bb9732df2dd79 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -6,7 +6,7 @@
#include <stddef.h>
#include <stdarg.h>
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
#include <math.h>
#endif
#include <mruby.h>
@@ -23,6 +23,7 @@
#include <mruby/opcode.h>
#include "value_array.h"
#include <mruby/throw.h>
+#include <mruby/dump.h>
#ifdef MRB_DISABLE_STDIO
#if defined(__cplusplus)
@@ -222,9 +223,9 @@ mrb_stack_extend(mrb_state *mrb, mrb_int room)
}
static inline struct REnv*
-uvenv(mrb_state *mrb, int up)
+uvenv(mrb_state *mrb, mrb_int up)
{
- struct RProc *proc = mrb->c->ci->proc;
+ const struct RProc *proc = mrb->c->ci->proc;
struct REnv *e;
while (up--) {
@@ -247,8 +248,8 @@ uvenv(mrb_state *mrb, int up)
return NULL;
}
-static inline struct RProc*
-top_proc(mrb_state *mrb, struct RProc *proc)
+static inline const struct RProc*
+top_proc(mrb_state *mrb, const struct RProc *proc)
{
while (proc->upper) {
if (MRB_PROC_SCOPE_P(proc) || MRB_PROC_STRICT_P(proc))
@@ -263,8 +264,8 @@ top_proc(mrb_state *mrb, struct RProc *proc)
#define CI_ACC_RESUMED -3
static inline mrb_callinfo*
-cipush(mrb_state *mrb, const mrb_code *pc, int push_stacks, int acc,
- struct RClass *target_class, struct RProc *proc, mrb_sym mid, int argc)
+cipush(mrb_state *mrb, const mrb_code *pc, mrb_int push_stacks, mrb_int acc,
+ struct RClass *target_class, const struct RProc *proc, mrb_sym mid, mrb_int argc)
{
struct mrb_context *c = mrb->c;
mrb_callinfo *ci = c->ci;
@@ -280,8 +281,6 @@ cipush(mrb_state *mrb, const mrb_code *pc, int push_stacks, int acc,
ci->mid = mid;
ci->proc = proc;
ci->stackent = c->stack;
- ci->epos = c->eidx;
- ci->ridx = ci[-1].ridx;
ci->pc = pc;
ci->argc = argc;
ci->acc = acc;
@@ -327,55 +326,7 @@ cipop(mrb_state *mrb)
}
void mrb_exc_set(mrb_state *mrb, mrb_value exc);
-static mrb_value mrb_run(mrb_state *mrb, struct RProc* proc, mrb_value self);
-
-static void
-ecall(mrb_state *mrb)
-{
- struct RProc *p;
- struct mrb_context *c = mrb->c;
- mrb_callinfo *ci = c->ci;
- struct RObject *exc;
- struct REnv *env;
- ptrdiff_t cioff;
- int ai = mrb_gc_arena_save(mrb);
- uint16_t i;
- int nregs;
-
- if (c->eidx == 0) return;
- i = --c->eidx;
-
- /* restrict total call depth of ecall() */
- if (++mrb->ecall_nest > MRB_ECALL_DEPTH_MAX) {
- mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
- }
- p = c->ensure[i];
- if (!p) return;
- mrb_assert(!MRB_PROC_CFUNC_P(p));
- c->ensure[i] = NULL;
- nregs = p->upper->body.irep->nregs;
- if (ci->proc && !MRB_PROC_CFUNC_P(ci->proc) &&
- ci->proc->body.irep->nregs > nregs) {
- nregs = ci->proc->body.irep->nregs;
- }
- cioff = ci - c->cibase;
- ci = cipush(mrb, NULL, nregs, CI_ACC_SKIP, MRB_PROC_TARGET_CLASS(p), p, ci->mid, 0);
- env = MRB_PROC_ENV(p);
- mrb_assert(env);
- exc = mrb->exc; mrb->exc = 0;
- if (exc) {
- mrb_gc_protect(mrb, mrb_obj_value(exc));
- }
- if (mrb->c->fib) {
- mrb_gc_protect(mrb, mrb_obj_value(mrb->c->fib));
- }
- mrb_run(mrb, p, env->stack[0]);
- mrb->c = c;
- c->ci = c->cibase + cioff;
- if (!mrb->exc) mrb->exc = exc;
- mrb_gc_arena_restore(mrb, ai);
- mrb->ecall_nest--;
-}
+static mrb_value mrb_run(mrb_state *mrb, const struct RProc* proc, mrb_value self);
#ifndef MRB_FUNCALL_ARGC_MAX
#define MRB_FUNCALL_ARGC_MAX 16
@@ -401,11 +352,30 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...)
return mrb_funcall_argv(mrb, self, mid, argc, argv);
}
-static int
+MRB_API mrb_value
+mrb_funcall_id(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, ...)
+{
+ mrb_value argv[MRB_FUNCALL_ARGC_MAX];
+ va_list ap;
+ mrb_int i;
+
+ if (argc > MRB_FUNCALL_ARGC_MAX) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=" MRB_STRINGIZE(MRB_FUNCALL_ARGC_MAX) ")");
+ }
+
+ va_start(ap, argc);
+ for (i = 0; i < argc; i++) {
+ argv[i] = va_arg(ap, mrb_value);
+ }
+ va_end(ap);
+ return mrb_funcall_argv(mrb, self, mid, argc, argv);
+}
+
+static mrb_int
ci_nregs(mrb_callinfo *ci)
{
- struct RProc *p;
- int n = 0;
+ const struct RProc *p;
+ mrb_int n = 0;
if (!ci) return 3;
p = ci->proc;
@@ -455,7 +425,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
mrb_method_t m;
struct RClass *c;
mrb_callinfo *ci;
- int n = ci_nregs(mrb->c->ci);
+ mrb_int n = ci_nregs(mrb->c->ci);
ptrdiff_t voff = -1;
if (!mrb->c->stack) {
@@ -467,7 +437,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
c = mrb_class(mrb, self);
m = mrb_method_search_vm(mrb, &c, mid);
if (MRB_METHOD_UNDEF_P(m)) {
- mrb_sym missing = mrb_intern_lit(mrb, "method_missing");
+ mrb_sym missing = MRB_SYM(method_missing);
mrb_value args = mrb_ary_new_from_values(mrb, argc, argv);
m = mrb_method_search_vm(mrb, &c, missing);
if (MRB_METHOD_UNDEF_P(m)) {
@@ -536,7 +506,7 @@ mrb_value
mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p)
{
mrb_callinfo *ci = mrb->c->ci;
- int keep, nregs;
+ mrb_int keep, nregs;
mrb->c->stack[0] = self;
ci->proc = p;
@@ -721,7 +691,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value
mrb_sym mid = mrb->c->ci->mid;
mrb_callinfo *ci;
mrb_value val;
- int n;
+ mrb_int n;
if (mrb_nil_p(b)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
@@ -802,17 +772,56 @@ mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const
}
static struct RBreak*
-break_new(mrb_state *mrb, struct RProc *p, mrb_value val)
+break_new(mrb_state *mrb, uint32_t tag, const struct RProc *p, mrb_value val)
{
struct RBreak *brk;
brk = (struct RBreak*)mrb_obj_alloc(mrb, MRB_TT_BREAK, NULL);
mrb_break_proc_set(brk, p);
mrb_break_value_set(brk, val);
+ mrb_break_tag_set(brk, tag);
return brk;
}
+#define MRB_CATCH_FILTER_RESCUE (UINT32_C(1) << MRB_CATCH_RESCUE)
+#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
+#define MRB_CATCH_FILTER_ALL (MRB_CATCH_FILTER_RESCUE | MRB_CATCH_FILTER_ENSURE)
+
+static const struct mrb_irep_catch_handler *
+catch_handler_find(mrb_state *mrb, mrb_callinfo *ci, const mrb_code *pc, uint32_t filter)
+{
+ const mrb_irep *irep;
+ ptrdiff_t xpc;
+ size_t cnt;
+ const struct mrb_irep_catch_handler *e;
+
+/* The comparison operators use `>` and `<=` because pc already points to the next instruction */
+#define catch_cover_p(pc, beg, end) ((pc) > (beg) && (pc) <= (end))
+
+ if (ci->proc == NULL || MRB_PROC_CFUNC_P(ci->proc)) return NULL;
+ irep = ci->proc->body.irep;
+ if (irep->clen < 1) return NULL;
+ xpc = pc - irep->iseq;
+ /* If it retry at the top level, pc will be 0, so check with -1 as the start position */
+ mrb_assert(catch_cover_p(xpc, -1, irep->ilen));
+ if (!catch_cover_p(xpc, -1, irep->ilen)) return NULL;
+
+ /* Currently uses a simple linear search to avoid processing complexity. */
+ cnt = irep->clen;
+ e = mrb_irep_catch_handler_table(irep) + cnt - 1;
+ for (; cnt > 0; cnt --, e --) {
+ if (((UINT32_C(1) << e->type) & filter) &&
+ catch_cover_p(xpc, bin_to_uint16(e->begin), bin_to_uint16(e->end))) {
+ return e;
+ }
+ }
+
+#undef catch_cover_p
+
+ return NULL;
+}
+
typedef enum {
LOCALJUMP_ERROR_RETURN = 0,
LOCALJUMP_ERROR_BREAK = 1,
@@ -859,6 +868,70 @@ argnum_error(mrb_state *mrb, mrb_int num)
mrb_exc_set(mrb, exc);
}
+static mrb_bool
+break_tag_p(struct RBreak *brk, uint32_t tag)
+{
+ return (brk != NULL && brk->tt == MRB_TT_BREAK) ? TRUE : FALSE;
+}
+
+static void
+prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb_value val)
+{
+ if (break_tag_p((struct RBreak*)mrb->exc, tag)) {
+ mrb_break_tag_set((struct RBreak*)mrb->exc, tag);
+ }
+ else {
+ mrb->exc = (struct RObject*)break_new(mrb, tag, proc, val);
+ }
+}
+
+#define THROW_TAGGED_BREAK(mrb, tag, proc, val) \
+ do { \
+ prepare_tagged_break(mrb, tag, proc, val); \
+ goto L_CATCH_TAGGED_BREAK; \
+ } while (0)
+
+#define UNWIND_ENSURE(mrb, ci, pc, tag, proc, val) \
+ do { \
+ ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \
+ if (ch) { \
+ THROW_TAGGED_BREAK(mrb, tag, proc, val); \
+ } \
+ } while (0)
+
+/*
+ * CHECKPOINT_RESTORE(tag) {
+ * This part is executed when jumping by the same "tag" of RBreak (it is not executed the first time).
+ * Write the code required (initialization of variables, etc.) for the subsequent processing.
+ * }
+ * CHECKPOINT_MAIN(tag) {
+ * This part is always executed.
+ * }
+ * CHECKPOINT_END(tag);
+ *
+ * ...
+ *
+ * // Jump to CHECKPOINT_RESTORE with the same "tag".
+ * goto CHECKPOINT_LABEL_MAKE(tag);
+ */
+
+#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
+
+#define CHECKPOINT_RESTORE(tag) \
+ do { \
+ if (FALSE) { \
+ CHECKPOINT_LABEL_MAKE(tag): \
+ do {
+
+#define CHECKPOINT_MAIN(tag) \
+ } while (0); \
+ } \
+ do {
+
+#define CHECKPOINT_END(tag) \
+ } while (0); \
+ } while (0)
+
#define ERR_PC_SET(mrb) mrb->c->ci->err = pc0;
#define ERR_PC_CLR(mrb) mrb->c->ci->err = 0;
#ifdef MRB_ENABLE_DEBUG_HOOK
@@ -882,15 +955,15 @@ argnum_error(mrb_state *mrb, mrb_int num)
#ifndef DIRECT_THREADED
#define INIT_DISPATCH for (;;) { insn = BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); switch (insn) {
-#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops ();; L_ ## insn ## _BODY:
-#define NEXT break
+#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops (); pc_save = pc;
+#define NEXT goto L_END_DISPATCH
#define JUMP NEXT
-#define END_DISPATCH }}
+#define END_DISPATCH L_END_DISPATCH:;}}
#else
#define INIT_DISPATCH JUMP; return mrb_nil_value();
-#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops (); L_ ## insn ## _BODY:
+#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops (); pc_save = pc;
#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
#define JUMP NEXT
@@ -899,13 +972,13 @@ argnum_error(mrb_state *mrb, mrb_int num)
#endif
MRB_API mrb_value
-mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
+mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep)
{
- mrb_irep *irep = proc->body.irep;
+ const mrb_irep *irep = proc->body.irep;
mrb_value result;
struct mrb_context *c = mrb->c;
ptrdiff_t cioff = c->ci - c->cibase;
- unsigned int nregs = irep->nregs;
+ mrb_int nregs = irep->nregs;
if (!c->stack) {
stack_init(mrb);
@@ -932,7 +1005,7 @@ static mrb_bool
check_target_class(mrb_state *mrb)
{
if (!mrb->c->ci->target_class) {
- mrb_value exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR, "no target class or module");
+ mrb_value exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR, "no target class or module");
mrb_exc_set(mrb, exc);
return FALSE;
}
@@ -942,13 +1015,14 @@ check_target_class(mrb_state *mrb)
void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self);
MRB_API mrb_value
-mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *pc)
+mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *pc)
{
/* mrb_assert(MRB_PROC_CFUNC_P(proc)) */
const mrb_code *pc0 = pc;
- mrb_irep *irep = proc->body.irep;
- mrb_value *pool = irep->pool;
- mrb_sym *syms = irep->syms;
+ const mrb_code *volatile pc_save = pc;
+ const mrb_irep *irep = proc->body.irep;
+ const mrb_pool_value *pool = irep->pool;
+ const mrb_sym *syms = irep->syms;
mrb_code insn;
int ai = mrb_gc_arena_save(mrb);
struct mrb_jmpbuf *prev_jmp = mrb->jmp;
@@ -957,6 +1031,7 @@ mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *pc)
uint16_t b;
uint8_t c;
mrb_sym mid;
+ const struct mrb_irep_catch_handler *ch;
#ifdef DIRECT_THREADED
static void *optable[] = {
@@ -994,27 +1069,47 @@ RETRY_TRY_BLOCK:
}
CASE(OP_LOADL, BB) {
-#ifdef MRB_WORD_BOXING
- mrb_value val = pool[b];
-#ifndef MRB_WITHOUT_FLOAT
- if (mrb_float_p(val)) {
- val = mrb_float_value(mrb, mrb_float(val));
- }
-#endif
- regs[a] = val;
+ switch (pool[b].tt) { /* number */
+ case IREP_TT_INT32:
+ regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i32);
+ break;
+ case IREP_TT_INT64:
+#if defined(MRB_INT64)
+ regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64);
+ break;
#else
- regs[a] = pool[b];
+#if defined(MRB_64BIT)
+ if (INT32_MIN <= pool[b].u.i64 && pool[b].u.i64 <= INT32_MAX) {
+ regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64);
+ break;
+ }
#endif
+ {
+ mrb_value exc = mrb_exc_new_lit(mrb, E_RUNTIME_ERROR, "integer overflow");
+ mrb_exc_set(mrb, exc);
+ }
+ goto L_RAISE;
+#endif
+#ifndef MRB_NO_FLOAT
+ case IREP_TT_FLOAT:
+ regs[a] = mrb_float_value(mrb, pool[b].u.f);
+ break;
+#endif
+ default:
+ /* should not happen (tt:string) */
+ regs[a] = mrb_nil_value();
+ break;
+ }
NEXT;
}
CASE(OP_LOADI, BB) {
- SET_INT_VALUE(regs[a], b);
+ SET_FIXNUM_VALUE(regs[a], b);
NEXT;
}
CASE(OP_LOADINEG, BB) {
- SET_INT_VALUE(regs[a], -b);
+ SET_FIXNUM_VALUE(regs[a], -b);
NEXT;
}
@@ -1028,12 +1123,12 @@ RETRY_TRY_BLOCK:
CASE(OP_LOADI_6,B) goto L_LOADI;
CASE(OP_LOADI_7, B) {
L_LOADI:
- SET_INT_VALUE(regs[a], (mrb_int)insn - (mrb_int)OP_LOADI_0);
+ SET_FIXNUM_VALUE(regs[a], (mrb_int)insn - (mrb_int)OP_LOADI_0);
NEXT;
}
CASE(OP_LOADI16, BS) {
- SET_INT_VALUE(regs[a], (mrb_int)(int16_t)b);
+ SET_FIXNUM_VALUE(regs[a], (mrb_int)(int16_t)b);
NEXT;
}
@@ -1192,32 +1287,49 @@ RETRY_TRY_BLOCK:
NEXT;
}
- CASE(OP_ONERR, S) {
- /* check rescue stack */
- if (mrb->c->ci->ridx == UINT16_MAX-1) {
- mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "too many nested rescues");
- mrb_exc_set(mrb, exc);
- goto L_RAISE;
+ CASE(OP_JMPUW, S) {
+ CHECKPOINT_RESTORE(RBREAK_TAG_JUMP) {
+ struct RBreak *brk = (struct RBreak*)mrb->exc;
+ mrb_value target = mrb_break_value_get(brk);
+ mrb_assert(mrb_integer_p(target));
+ a = (uint32_t)mrb_integer(target);
+ mrb_assert(a >= 0 && a < irep->ilen);
}
- /* expand rescue stack */
- if (mrb->c->rsize <= mrb->c->ci->ridx) {
- if (mrb->c->rsize == 0) mrb->c->rsize = RESCUE_STACK_INIT_SIZE;
- else {
- mrb->c->rsize *= 2;
- if (mrb->c->rsize <= mrb->c->ci->ridx) {
- mrb->c->rsize = UINT16_MAX;
+ CHECKPOINT_MAIN(RBREAK_TAG_JUMP) {
+ ch = catch_handler_find(mrb, mrb->c->ci, pc, MRB_CATCH_FILTER_ENSURE);
+ if (ch) {
+ /* avoiding a jump from a catch handler into the same handler */
+ if (a < bin_to_uint16(ch->begin) || a >= bin_to_uint16(ch->end)) {
+ THROW_TAGGED_BREAK(mrb, RBREAK_TAG_JUMP, proc, mrb_fixnum_value(a));
}
}
- mrb->c->rescue = (uint16_t*)mrb_realloc(mrb, mrb->c->rescue, sizeof(uint16_t)*mrb->c->rsize);
}
- /* push rescue stack */
- mrb->c->rescue[mrb->c->ci->ridx++] = a;
- NEXT;
+ CHECKPOINT_END(RBREAK_TAG_JUMP);
+
+ mrb->exc = NULL; /* clear break object */
+ pc = irep->iseq + a;
+ JUMP;
}
CASE(OP_EXCEPT, B) {
- mrb_value exc = mrb_obj_value(mrb->exc);
- mrb->exc = 0;
+ mrb_value exc;
+
+ if (mrb->exc == NULL) {
+ exc = mrb_nil_value();
+ }
+ else {
+ switch (mrb->exc->tt) {
+ case MRB_TT_BREAK:
+ case MRB_TT_EXCEPTION:
+ exc = mrb_obj_value(mrb->exc);
+ break;
+ default:
+ mrb_assert(!"bad mrb_type");
+ exc = mrb_nil_value();
+ break;
+ }
+ mrb->exc = NULL;
+ }
regs[a] = exc;
NEXT;
}
@@ -1234,7 +1346,7 @@ RETRY_TRY_BLOCK:
{
mrb_value exc;
- exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR,
+ exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR,
"class or module required for rescue clause");
mrb_exc_set(mrb, exc);
goto L_RAISE;
@@ -1245,74 +1357,19 @@ RETRY_TRY_BLOCK:
NEXT;
}
- CASE(OP_POPERR, B) {
- mrb->c->ci->ridx -= a;
- NEXT;
- }
-
- CASE(OP_RAISE, B) {
- mrb_exc_set(mrb, regs[a]);
- goto L_RAISE;
- }
-
- CASE(OP_EPUSH, B) {
- struct RProc *p;
-
- p = mrb_closure_new(mrb, irep->reps[a]);
- /* check ensure stack */
- if (mrb->c->eidx == UINT16_MAX-1) {
- mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "too many nested ensures");
- mrb_exc_set(mrb, exc);
- goto L_RAISE;
+ CASE(OP_RAISEIF, B) {
+ mrb_value exc = regs[a];
+ if (mrb_break_p(exc)) {
+ mrb->exc = mrb_obj_ptr(exc);
+ goto L_BREAK;
}
- /* expand ensure stack */
- if (mrb->c->esize <= mrb->c->eidx+1) {
- if (mrb->c->esize == 0) mrb->c->esize = ENSURE_STACK_INIT_SIZE;
- else {
- mrb->c->esize *= 2;
- if (mrb->c->esize <= mrb->c->eidx) {
- mrb->c->esize = UINT16_MAX;
- }
- }
- mrb->c->ensure = (struct RProc**)mrb_realloc(mrb, mrb->c->ensure, sizeof(struct RProc*)*mrb->c->esize);
+ mrb_exc_set(mrb, exc);
+ if (mrb->exc) {
+ goto L_RAISE;
}
- /* push ensure stack */
- mrb->c->ensure[mrb->c->eidx++] = p;
- mrb->c->ensure[mrb->c->eidx] = NULL;
- mrb_gc_arena_restore(mrb, ai);
NEXT;
}
- CASE(OP_EPOP, B) {
- mrb_callinfo *ci = mrb->c->ci;
- unsigned int n, epos = ci->epos;
- mrb_value self = regs[0];
- struct RClass *target_class = ci->target_class;
-
- if (mrb->c->eidx <= epos) {
- NEXT;
- }
-
- if (a > (int)mrb->c->eidx - epos)
- a = mrb->c->eidx - epos;
- for (n=0; n<a; n++) {
- int nregs = irep->nregs;
-
- proc = mrb->c->ensure[epos+n];
- mrb->c->ensure[epos+n] = NULL;
- if (proc == NULL) continue;
- irep = proc->body.irep;
- ci = cipush(mrb, pc, nregs, nregs, target_class, proc, ci->mid, 0);
- mrb_stack_extend(mrb, irep->nregs);
- regs[0] = self;
- pc = irep->iseq;
- }
- pool = irep->pool;
- syms = irep->syms;
- mrb->c->eidx = epos;
- JUMP;
- }
-
CASE(OP_SENDV, BB) {
c = CALL_MAXARGS;
goto L_SEND;
@@ -1344,8 +1401,8 @@ RETRY_TRY_BLOCK:
mid = syms[b];
L_SENDB_SYM:
{
- int argc = (c == CALL_MAXARGS) ? -1 : c;
- int bidx = (argc < 0) ? a+2 : a+c+1;
+ mrb_int argc = (c == CALL_MAXARGS) ? -1 : c;
+ mrb_int bidx = (argc < 0) ? a+2 : a+c+1;
mrb_method_t m;
struct RClass *cls;
mrb_callinfo *ci = mrb->c->ci;
@@ -1356,15 +1413,15 @@ RETRY_TRY_BLOCK:
recv = regs[a];
blk = regs[bidx];
if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) {
- blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, "Proc", "to_proc");
- /* The stack might have been reallocated during mrb_convert_type(),
+ blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc));
+ /* The stack might have been reallocated during mrb_type_convert(),
see #3622 */
regs[bidx] = blk;
}
cls = mrb_class(mrb, recv);
m = mrb_method_search_vm(mrb, &cls, mid);
if (MRB_METHOD_UNDEF_P(m)) {
- mrb_sym missing = mrb_intern_lit(mrb, "method_missing");
+ mrb_sym missing = MRB_SYM(method_missing);
m = mrb_method_search_vm(mrb, &cls, missing);
if (MRB_METHOD_UNDEF_P(m) || (missing == mrb->c->ci->mid && mrb_obj_eq(mrb, regs[0], recv))) {
mrb_value args = (argc < 0) ? regs[a+1] : mrb_ary_new_from_values(mrb, c, regs+a+1);
@@ -1479,7 +1536,7 @@ RETRY_TRY_BLOCK:
mrb->c->stack[0] = mrb_nil_value();
a = 0;
c = OP_R_NORMAL;
- goto L_OP_RETURN_BODY;
+ goto L_RETURN;
}
pool = irep->pool;
syms = irep->syms;
@@ -1501,13 +1558,13 @@ RETRY_TRY_BLOCK:
}
CASE(OP_SUPER, BB) {
- int argc = (b == CALL_MAXARGS) ? -1 : b;
+ mrb_int argc = (b == CALL_MAXARGS) ? -1 : b;
int bidx = (argc < 0) ? a+2 : a+b+1;
mrb_method_t m;
struct RClass *cls;
mrb_callinfo *ci = mrb->c->ci;
mrb_value recv, blk;
- struct RProc *p = ci->proc;
+ const struct RProc *p = ci->proc;
mrb_sym mid = ci->mid;
struct RClass* target_class = MRB_PROC_TARGET_CLASS(p);
@@ -1517,37 +1574,37 @@ RETRY_TRY_BLOCK:
mrb_assert(bidx < irep->nregs);
if (mid == 0 || !target_class) {
- mrb_value exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
+ mrb_value exc = mrb_exc_new_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
mrb_exc_set(mrb, exc);
goto L_RAISE;
}
if (target_class->tt == MRB_TT_MODULE) {
target_class = ci->target_class;
if (target_class->tt != MRB_TT_ICLASS) {
- mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "superclass info lost [mruby limitations]");
+ mrb_value exc = mrb_exc_new_lit(mrb, E_RUNTIME_ERROR, "superclass info lost [mruby limitations]");
mrb_exc_set(mrb, exc);
goto L_RAISE;
}
}
recv = regs[0];
if (!mrb_obj_is_kind_of(mrb, recv, target_class)) {
- mrb_value exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR,
+ mrb_value exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR,
"self has wrong type to call super in this context");
mrb_exc_set(mrb, exc);
goto L_RAISE;
}
blk = regs[bidx];
if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) {
- blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, "Proc", "to_proc");
+ blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc));
/* The stack or ci stack might have been reallocated during
- mrb_convert_type(), see #3622 and #3784 */
+ mrb_type_convert(), see #3622 and #3784 */
regs[bidx] = blk;
ci = mrb->c->ci;
}
cls = target_class->super;
m = mrb_method_search_vm(mrb, &cls, mid);
if (MRB_METHOD_UNDEF_P(m)) {
- mrb_sym missing = mrb_intern_lit(mrb, "method_missing");
+ mrb_sym missing = MRB_SYM(method_missing);
if (mid != missing) {
cls = mrb_class(mrb, recv);
@@ -1586,6 +1643,7 @@ RETRY_TRY_BLOCK:
mrb_gc_arena_restore(mrb, ai);
if (mrb->exc) goto L_RAISE;
ci = mrb->c->ci;
+ mrb_assert(!mrb_break_p(v));
if (!ci->target_class) { /* return from context modifying method (resume/yield) */
if (ci->acc == CI_ACC_RESUMED) {
mrb->jmp = prev_jmp;
@@ -1620,18 +1678,18 @@ RETRY_TRY_BLOCK:
}
CASE(OP_ARGARY, BS) {
- int m1 = (b>>11)&0x3f;
- int r = (b>>10)&0x1;
- int m2 = (b>>5)&0x1f;
- int kd = (b>>4)&0x1;
- int lv = (b>>0)&0xf;
+ mrb_int m1 = (b>>11)&0x3f;
+ mrb_int r = (b>>10)&0x1;
+ mrb_int m2 = (b>>5)&0x1f;
+ mrb_int kd = (b>>4)&0x1;
+ mrb_int lv = (b>>0)&0xf;
mrb_value *stack;
if (mrb->c->ci->mid == 0 || mrb->c->ci->target_class == NULL) {
mrb_value exc;
L_NOSUPER:
- exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
+ exc = mrb_exc_new_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
mrb_exc_set(mrb, exc);
goto L_RAISE;
}
@@ -1649,13 +1707,13 @@ RETRY_TRY_BLOCK:
else {
mrb_value *pp = NULL;
struct RArray *rest;
- int len = 0;
+ mrb_int len = 0;
if (mrb_array_p(stack[m1])) {
struct RArray *ary = mrb_ary_ptr(stack[m1]);
pp = ARY_PTR(ary);
- len = (int)ARY_LEN(ary);
+ len = ARY_LEN(ary);
}
regs[a] = mrb_ary_new_capa(mrb, m1+len+m2+kd);
rest = mrb_ary_ptr(regs[a]);
@@ -1679,22 +1737,22 @@ RETRY_TRY_BLOCK:
}
CASE(OP_ENTER, W) {
- int m1 = MRB_ASPEC_REQ(a);
- int o = MRB_ASPEC_OPT(a);
- int r = MRB_ASPEC_REST(a);
- int m2 = MRB_ASPEC_POST(a);
- int kd = (MRB_ASPEC_KEY(a) > 0 || MRB_ASPEC_KDICT(a))? 1 : 0;
+ mrb_int m1 = MRB_ASPEC_REQ(a);
+ mrb_int o = MRB_ASPEC_OPT(a);
+ mrb_int r = MRB_ASPEC_REST(a);
+ mrb_int m2 = MRB_ASPEC_POST(a);
+ mrb_int kd = (MRB_ASPEC_KEY(a) > 0 || MRB_ASPEC_KDICT(a))? 1 : 0;
/* unused
int b = MRB_ASPEC_BLOCK(a);
*/
- int argc = mrb->c->ci->argc;
+ mrb_int argc = mrb->c->ci->argc;
mrb_value *argv = regs+1;
mrb_value * const argv0 = argv;
- int const len = m1 + o + r + m2;
- int const blk_pos = len + kd + 1;
+ mrb_int const len = m1 + o + r + m2;
+ mrb_int const blk_pos = len + kd + 1;
mrb_value *blk = &argv[argc < 0 ? 1 : argc];
- mrb_value kdict;
- int kargs = kd;
+ mrb_value kdict = mrb_nil_value();
+ mrb_int kargs = kd;
/* arguments is passed with Array */
if (argc < 0) {
@@ -1746,7 +1804,7 @@ RETRY_TRY_BLOCK:
/* no rest arguments */
if (argc-kargs < len) {
- int mlen = m2;
+ mrb_int mlen = m2;
if (argc < m1+m2) {
mlen = m1 < argc ? argc - m1 : 0;
}
@@ -1754,7 +1812,7 @@ RETRY_TRY_BLOCK:
if (kd) regs[len + 1] = kdict;
/* copy mandatory and optional arguments */
- if (argv0 != argv) {
+ if (argv0 != argv && argv) {
value_move(®s[1], argv, argc-mlen); /* m1 + o */
}
if (argc < m1) {
@@ -1776,7 +1834,7 @@ RETRY_TRY_BLOCK:
pc += (argc - kargs - m1 - m2)*3;
}
else {
- int rnum = 0;
+ mrb_int rnum = 0;
if (argv0 != argv) {
regs[blk_pos] = *blk; /* move block */
if (kd) regs[len + 1] = kdict;
@@ -1862,13 +1920,7 @@ RETRY_TRY_BLOCK:
c = OP_R_NORMAL;
L_RETURN:
{
- mrb_callinfo *ci;
-
-#define ecall_adjust() do {\
- ptrdiff_t cioff = ci - mrb->c->cibase;\
- ecall(mrb);\
- ci = mrb->c->cibase + cioff;\
-} while (0)
+ mrb_callinfo *ci;
ci = mrb->c->ci;
if (ci->mid) {
@@ -1896,17 +1948,20 @@ RETRY_TRY_BLOCK:
L_RAISE:
ci0 = ci = mrb->c->ci;
if (ci == mrb->c->cibase) {
- if (ci->ridx == 0) goto L_FTOP;
- goto L_RESCUE;
+ ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL);
+ if (ch == NULL) goto L_FTOP;
+ goto L_CATCH;
}
- while (ci[0].ridx == ci[-1].ridx) {
+ while ((ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL)) == NULL) {
ci = cipop(mrb);
if (ci[1].acc == CI_ACC_SKIP && prev_jmp) {
mrb->jmp = prev_jmp;
MRB_THROW(prev_jmp);
}
+ pc = ci[1].pc;
if (ci == mrb->c->cibase) {
- if (ci->ridx == 0) {
+ ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL);
+ if (ch == NULL) {
L_FTOP: /* fiber top */
if (mrb->c == mrb->root_c) {
mrb->c->stack = mrb->c->stbase;
@@ -1915,9 +1970,6 @@ RETRY_TRY_BLOCK:
else {
struct mrb_context *c = mrb->c;
- while (c->eidx > ci->epos) {
- ecall_adjust();
- }
c->status = MRB_FIBER_TERMINATED;
mrb->c = c->prev;
c->prev = NULL;
@@ -1926,15 +1978,13 @@ RETRY_TRY_BLOCK:
}
break;
}
- /* call ensure only when we skip this callinfo */
- if (ci[0].ridx == ci[-1].ridx) {
- while (mrb->c->eidx > ci->epos) {
- ecall_adjust();
- }
- }
}
- L_RESCUE:
- if (ci->ridx == 0) goto L_STOP;
+ L_CATCH:
+ if (ch == NULL) goto L_STOP;
+ if (FALSE) {
+ L_CATCH_TAGGED_BREAK: /* from THROW_TAGGED_BREAK() or UNWIND_ENSURE() */
+ ci = ci0 = mrb->c->ci;
+ }
proc = ci->proc;
irep = proc->body.irep;
pool = irep->pool;
@@ -1943,12 +1993,11 @@ RETRY_TRY_BLOCK:
mrb->c->stack = ci[1].stackent;
}
mrb_stack_extend(mrb, irep->nregs);
- pc = irep->iseq+mrb->c->rescue[--ci->ridx];
+ pc = irep->iseq + bin_to_uint16(ch->target);
}
else {
- int acc;
+ mrb_int acc;
mrb_value v;
- struct RProc *dst;
ci = mrb->c->ci;
v = regs[a];
@@ -1957,7 +2006,9 @@ RETRY_TRY_BLOCK:
case OP_R_RETURN:
/* Fall through to OP_R_NORMAL otherwise */
if (ci->acc >=0 && MRB_PROC_ENV_P(proc) && !MRB_PROC_STRICT_P(proc)) {
- mrb_callinfo *cibase = mrb->c->cibase;
+ const struct RProc *dst;
+ mrb_callinfo *cibase;
+ cibase = mrb->c->cibase;
dst = top_proc(mrb, proc);
if (MRB_PROC_ENV_P(dst)) {
@@ -1968,37 +2019,58 @@ RETRY_TRY_BLOCK:
goto L_RAISE;
}
}
+ /* check jump destination */
while (cibase <= ci && ci->proc != dst) {
- if (ci->acc < 0) {
+ if (ci->acc < 0) { /* jump cross C boudary */
localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
goto L_RAISE;
}
ci--;
}
- if (ci <= cibase) {
+ if (ci <= cibase) { /* no jump destination */
localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
goto L_RAISE;
}
+ ci = mrb->c->ci;
+ while (cibase <= ci && ci->proc != dst) {
+ CHECKPOINT_RESTORE(RBREAK_TAG_RETURN_BLOCK) {
+ cibase = mrb->c->cibase;
+ dst = top_proc(mrb, proc);
+ }
+ CHECKPOINT_MAIN(RBREAK_TAG_RETURN_BLOCK) {
+ UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN_BLOCK, proc, v);
+ }
+ CHECKPOINT_END(RBREAK_TAG_RETURN_BLOCK);
+ pc = ci->pc;
+ ci = cipop(mrb);
+ }
+ proc = ci->proc;
+ mrb->exc = NULL; /* clear break object */
break;
}
/* fallthrough */
case OP_R_NORMAL:
NORMAL_RETURN:
if (ci == mrb->c->cibase) {
- struct mrb_context *c = mrb->c;
+ struct mrb_context *c;
+ c = mrb->c;
if (!c->prev) { /* toplevel return */
regs[irep->nlocals] = v;
- goto L_STOP;
+ goto CHECKPOINT_LABEL_MAKE(RBREAK_TAG_STOP);
}
if (c->prev->ci == c->prev->cibase) {
- mrb_value exc = mrb_exc_new_str_lit(mrb, E_FIBER_ERROR, "double resume");
+ mrb_value exc = mrb_exc_new_lit(mrb, E_FIBER_ERROR, "double resume");
mrb_exc_set(mrb, exc);
goto L_RAISE;
}
- while (c->eidx > 0) {
- ecall(mrb);
+ CHECKPOINT_RESTORE(RBREAK_TAG_RETURN_TOPLEVEL) {
+ c = mrb->c;
+ }
+ CHECKPOINT_MAIN(RBREAK_TAG_RETURN_TOPLEVEL) {
+ UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN_TOPLEVEL, proc, v);
}
+ CHECKPOINT_END(RBREAK_TAG_RETURN_TOPLEVEL);
/* automatic yield at the end */
c->status = MRB_FIBER_TERMINATED;
mrb->c = c->prev;
@@ -2006,6 +2078,14 @@ RETRY_TRY_BLOCK:
mrb->c->status = MRB_FIBER_RUNNING;
ci = mrb->c->ci;
}
+ CHECKPOINT_RESTORE(RBREAK_TAG_RETURN) {
+ /* do nothing */
+ }
+ CHECKPOINT_MAIN(RBREAK_TAG_RETURN) {
+ UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN, proc, v);
+ }
+ CHECKPOINT_END(RBREAK_TAG_RETURN);
+ mrb->exc = NULL; /* clear break object */
break;
case OP_R_BREAK:
if (MRB_PROC_STRICT_P(proc)) goto NORMAL_RETURN;
@@ -2013,7 +2093,7 @@ RETRY_TRY_BLOCK:
mrb_value exc;
L_BREAK_ERROR:
- exc = mrb_exc_new_str_lit(mrb, E_LOCALJUMP_ERROR,
+ exc = mrb_exc_new_lit(mrb, E_LOCALJUMP_ERROR,
"break from proc-closure");
mrb_exc_set(mrb, exc);
goto L_RAISE;
@@ -2028,9 +2108,13 @@ RETRY_TRY_BLOCK:
goto L_BREAK_ERROR;
}
}
- while (mrb->c->eidx > mrb->c->ci->epos) {
- ecall_adjust();
+ CHECKPOINT_RESTORE(RBREAK_TAG_BREAK) {
+ /* do nothing */
+ }
+ CHECKPOINT_MAIN(RBREAK_TAG_BREAK) {
+ UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK, proc, v);
}
+ CHECKPOINT_END(RBREAK_TAG_BREAK);
/* break from fiber block */
if (ci == mrb->c->cibase && ci->pc) {
struct mrb_context *c = mrb->c;
@@ -2040,45 +2124,64 @@ RETRY_TRY_BLOCK:
ci = mrb->c->ci;
}
if (ci->acc < 0) {
+ ci = cipop(mrb);
mrb_gc_arena_restore(mrb, ai);
mrb->c->vmexec = FALSE;
- mrb->exc = (struct RObject*)break_new(mrb, proc, v);
+ mrb->exc = (struct RObject*)break_new(mrb, RBREAK_TAG_BREAK, proc, v);
mrb->jmp = prev_jmp;
MRB_THROW(prev_jmp);
}
if (FALSE) {
+ struct RBreak *brk;
+
L_BREAK:
- v = mrb_break_value_get((struct RBreak*)mrb->exc);
- proc = mrb_break_proc_get((struct RBreak*)mrb->exc);
- mrb->exc = NULL;
+ brk = (struct RBreak*)mrb->exc;
+ proc = mrb_break_proc_get(brk);
+ v = mrb_break_value_get(brk);
ci = mrb->c->ci;
+
+ switch (mrb_break_tag_get(brk)) {
+#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
+ RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
+#undef DISPATCH_CHECKPOINTS
+ default:
+ mrb_assert(!"wrong break tag");
+ }
}
mrb->c->stack = ci->stackent;
- proc = proc->upper;
- while (mrb->c->cibase < ci && ci[-1].proc != proc) {
+ while (mrb->c->cibase < ci && ci[-1].proc != proc->upper) {
if (ci[-1].acc == CI_ACC_SKIP) {
- while (ci < mrb->c->ci) {
- cipop(mrb);
- }
goto L_BREAK_ERROR;
}
- ci--;
+ CHECKPOINT_RESTORE(RBREAK_TAG_BREAK_UPPER) {
+ /* do nothing */
+ }
+ CHECKPOINT_MAIN(RBREAK_TAG_BREAK_UPPER) {
+ UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK_UPPER, proc, v);
+ }
+ CHECKPOINT_END(RBREAK_TAG_BREAK_UPPER);
+ pc = ci->pc;
+ ci = cipop(mrb);
+ }
+ CHECKPOINT_RESTORE(RBREAK_TAG_BREAK_INTARGET) {
+ /* do nothing */
}
+ CHECKPOINT_MAIN(RBREAK_TAG_BREAK_INTARGET) {
+ UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK_INTARGET, proc, v);
+ }
+ CHECKPOINT_END(RBREAK_TAG_BREAK_INTARGET);
if (ci == mrb->c->cibase) {
goto L_BREAK_ERROR;
}
+ mrb->exc = NULL; /* clear break object */
break;
default:
/* cannot happen */
break;
}
- while (ci < mrb->c->ci) {
- cipop(mrb);
- }
- ci[0].ridx = ci[-1].ridx;
- while (mrb->c->eidx > ci->epos) {
- ecall_adjust();
- }
+ mrb_assert(ci == mrb->c->ci);
+ mrb_assert(mrb->exc == NULL);
+
if (mrb->c->vmexec && !ci->target_class) {
mrb_gc_arena_restore(mrb, ai);
mrb->c->vmexec = FALSE;
@@ -2142,23 +2245,23 @@ RETRY_TRY_BLOCK:
OP_MATH_CASE_STRING_##op_name(); \
default: \
c = 1; \
- mid = mrb_intern_lit(mrb, MRB_STRINGIZE(OP_MATH_OP_##op_name)); \
+ mid = MRB_QSYM(op_name); \
goto L_SEND_SYM; \
} \
NEXT;
#define OP_MATH_CASE_FIXNUM(op_name) \
- case TYPES2(MRB_TT_FIXNUM, MRB_TT_FIXNUM): \
+ case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER): \
{ \
- mrb_int x = mrb_fixnum(regs[a]), y = mrb_fixnum(regs[a+1]), z; \
+ mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z; \
if (mrb_int_##op_name##_overflow(x, y, &z)) \
OP_MATH_OVERFLOW_INT(op_name, x, y, z); \
else \
- SET_INT_VALUE(regs[a], z); \
+ SET_INT_VALUE(mrb,regs[a], z); \
} \
break
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
#define OP_MATH_CASE_FLOAT(op_name, t1, t2) (void)0
-#define OP_MATH_OVERFLOW_INT(op_name, x, y, z) SET_INT_VALUE(regs[a], z)
+#define OP_MATH_OVERFLOW_INT(op_name, x, y, z) SET_INT_VALUE(mrb,regs[a], z)
#else
#define OP_MATH_CASE_FLOAT(op_name, t1, t2) \
case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2): \
@@ -2180,7 +2283,7 @@ RETRY_TRY_BLOCK:
#define OP_MATH_OP_add +
#define OP_MATH_OP_sub -
#define OP_MATH_OP_mul *
-#define OP_MATH_TT_fixnum MRB_TT_FIXNUM
+#define OP_MATH_TT_fixnum MRB_TT_INTEGER
#define OP_MATH_TT_float MRB_TT_FLOAT
CASE(OP_ADD, B) {
@@ -2196,31 +2299,30 @@ RETRY_TRY_BLOCK:
}
CASE(OP_DIV, B) {
-#ifndef MRB_WITHOUT_FLOAT
- double x, y, f;
+ mrb_int mrb_num_div_int(mrb_state *mrb, mrb_int x, mrb_int y);
+#ifndef MRB_NO_FLOAT
+ mrb_float mrb_num_div_flo(mrb_state *mrb, mrb_float x, mrb_float y);
+ mrb_float x, y, f;
#endif
/* need to check if op is overridden */
switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
- case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
-#ifdef MRB_WITHOUT_FLOAT
+ case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):
{
- mrb_int x = mrb_fixnum(regs[a]);
- mrb_int y = mrb_fixnum(regs[a+1]);
- SET_INT_VALUE(regs[a], y ? x / y : 0);
+ mrb_int x = mrb_integer(regs[a]);
+ mrb_int y = mrb_integer(regs[a+1]);
+ mrb_int div = mrb_num_div_int(mrb, x, y);
+ SET_INT_VALUE(mrb, regs[a], div);
}
- break;
-#else
- x = (mrb_float)mrb_fixnum(regs[a]);
- y = (mrb_float)mrb_fixnum(regs[a+1]);
- break;
- case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):
- x = (mrb_float)mrb_fixnum(regs[a]);
+ NEXT;
+#ifndef MRB_NO_FLOAT
+ case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):
+ x = (mrb_float)mrb_integer(regs[a]);
y = mrb_float(regs[a+1]);
break;
- case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):
+ case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):
x = mrb_float(regs[a]);
- y = (mrb_float)mrb_fixnum(regs[a+1]);
+ y = (mrb_float)mrb_integer(regs[a+1]);
break;
case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):
x = mrb_float(regs[a]);
@@ -2229,19 +2331,12 @@ RETRY_TRY_BLOCK:
#endif
default:
c = 1;
- mid = mrb_intern_lit(mrb, "/");
+ mid = MRB_QSYM(div);
goto L_SEND_SYM;
}
-#ifndef MRB_WITHOUT_FLOAT
- if (y == 0) {
- if (x > 0) f = INFINITY;
- else if (x < 0) f = -INFINITY;
- else /* if (x == 0) */ f = NAN;
- }
- else {
- f = x / y;
- }
+#ifndef MRB_NO_FLOAT
+ f = mrb_num_div_flo(mrb, x, y);
SET_FLOAT_VALUE(mrb, regs[a], f);
#endif
NEXT;
@@ -2253,23 +2348,23 @@ RETRY_TRY_BLOCK:
OP_MATHI_CASE_FIXNUM(op_name); \
OP_MATHI_CASE_FLOAT(op_name); \
default: \
- SET_INT_VALUE(regs[a+1], b); \
+ SET_INT_VALUE(mrb,regs[a+1], b); \
c = 1; \
- mid = mrb_intern_lit(mrb, MRB_STRINGIZE(OP_MATH_OP_##op_name)); \
+ mid = MRB_QSYM(op_name); \
goto L_SEND_SYM; \
} \
NEXT;
#define OP_MATHI_CASE_FIXNUM(op_name) \
- case MRB_TT_FIXNUM: \
+ case MRB_TT_INTEGER: \
{ \
- mrb_int x = mrb_fixnum(regs[a]), y = (mrb_int)b, z; \
+ mrb_int x = mrb_integer(regs[a]), y = (mrb_int)b, z; \
if (mrb_int_##op_name##_overflow(x, y, &z)) \
OP_MATH_OVERFLOW_INT(op_name, x, y, z); \
else \
- SET_INT_VALUE(regs[a], z); \
+ SET_INT_VALUE(mrb,regs[a], z); \
} \
break
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
#define OP_MATHI_CASE_FLOAT(op_name) (void)0
#else
#define OP_MATHI_CASE_FLOAT(op_name) \
@@ -2291,17 +2386,17 @@ RETRY_TRY_BLOCK:
#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
-#ifdef MRB_WITHOUT_FLOAT
-#define OP_CMP(op) do {\
+#ifdef MRB_NO_FLOAT
+#define OP_CMP(op,sym) do {\
int result;\
/* need to check if - is overridden */\
switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
- case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\
+ case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
result = OP_CMP_BODY(op,mrb_fixnum,mrb_fixnum);\
break;\
default:\
c = 1;\
- mid = mrb_intern_lit(mrb, # op);\
+ mid = MRB_QSYM(sym);\
goto L_SEND_SYM;\
}\
if (result) {\
@@ -2312,17 +2407,17 @@ RETRY_TRY_BLOCK:
}\
} while(0)
#else
-#define OP_CMP(op) do {\
+#define OP_CMP(op, sym) do {\
int result;\
/* need to check if - is overridden */\
switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
- case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\
+ case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
result = OP_CMP_BODY(op,mrb_fixnum,mrb_fixnum);\
break;\
- case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):\
+ case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\
result = OP_CMP_BODY(op,mrb_fixnum,mrb_float);\
break;\
- case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):\
+ case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\
result = OP_CMP_BODY(op,mrb_float,mrb_fixnum);\
break;\
case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\
@@ -2330,7 +2425,7 @@ RETRY_TRY_BLOCK:
break;\
default:\
c = 1;\
- mid = mrb_intern_lit(mrb, # op);\
+ mid = MRB_QSYM(sym);\
goto L_SEND_SYM;\
}\
if (result) {\
@@ -2347,28 +2442,28 @@ RETRY_TRY_BLOCK:
SET_TRUE_VALUE(regs[a]);
}
else {
- OP_CMP(==);
+ OP_CMP(==,eq);
}
NEXT;
}
CASE(OP_LT, B) {
- OP_CMP(<);
+ OP_CMP(<,lt);
NEXT;
}
CASE(OP_LE, B) {
- OP_CMP(<=);
+ OP_CMP(<=,le);
NEXT;
}
CASE(OP_GT, B) {
- OP_CMP(>);
+ OP_CMP(>,gt);
NEXT;
}
CASE(OP_GE, B) {
- OP_CMP(>=);
+ OP_CMP(>=,ge);
NEXT;
}
@@ -2480,9 +2575,13 @@ RETRY_TRY_BLOCK:
}
CASE(OP_STRING, BB) {
- mrb_value str = mrb_str_dup(mrb, pool[b]);
-
- regs[a] = str;
+ size_t len = pool[b].tt >> 2;
+ if (pool[b].tt & IREP_TT_SFLAG) {
+ regs[a] = mrb_str_new_static(mrb, pool[b].u.str, len);
+ }
+ else {
+ regs[a] = mrb_str_new(mrb, pool[b].u.str, len);
+ }
mrb_gc_arena_restore(mrb, ai);
NEXT;
}
@@ -2530,7 +2629,7 @@ RETRY_TRY_BLOCK:
L_MAKE_LAMBDA:
{
struct RProc *p;
- mrb_irep *nirep = irep->reps[b];
+ const mrb_irep *nirep = irep->reps[b];
if (c & OP_L_CAPTURE) {
p = mrb_closure_new(mrb, nirep);
@@ -2581,6 +2680,7 @@ RETRY_TRY_BLOCK:
super = regs[a+1];
if (mrb_nil_p(base)) {
baseclass = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+ if (!baseclass) baseclass = mrb->object_class;
base = mrb_obj_value(baseclass);
}
c = mrb_vm_define_class(mrb, base, super, id);
@@ -2597,6 +2697,7 @@ RETRY_TRY_BLOCK:
base = regs[a];
if (mrb_nil_p(base)) {
baseclass = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+ if (!baseclass) baseclass = mrb->object_class;
base = mrb_obj_value(baseclass);
}
cls = mrb_vm_define_module(mrb, base, id);
@@ -2608,7 +2709,7 @@ RETRY_TRY_BLOCK:
CASE(OP_EXEC, BB) {
mrb_value recv = regs[a];
struct RProc *p;
- mrb_irep *nirep = irep->reps[b];
+ const mrb_irep *nirep = irep->reps[b];
/* prepare closure */
p = mrb_proc_new(mrb, nirep);
@@ -2684,56 +2785,30 @@ RETRY_TRY_BLOCK:
}
CASE(OP_ERR, B) {
- mrb_value msg = mrb_str_dup(mrb, pool[a]);
+ size_t len = pool[a].tt >> 2;
mrb_value exc;
- exc = mrb_exc_new_str(mrb, E_LOCALJUMP_ERROR, msg);
+ mrb_assert((pool[a].tt&IREP_TT_NFLAG)==0);
+ exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, pool[a].u.str, len);
ERR_PC_SET(mrb);
mrb_exc_set(mrb, exc);
goto L_RAISE;
}
- CASE(OP_EXT1, Z) {
- insn = READ_B();
- switch (insn) {
-#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); goto L_OP_ ## insn ## _BODY;
-#include "mruby/ops.h"
-#undef OPCODE
- }
- pc--;
- NEXT;
- }
- CASE(OP_EXT2, Z) {
- insn = READ_B();
- switch (insn) {
-#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); goto L_OP_ ## insn ## _BODY;
-#include "mruby/ops.h"
-#undef OPCODE
- }
- pc--;
- NEXT;
- }
- CASE(OP_EXT3, Z) {
- uint8_t insn = READ_B();
- switch (insn) {
-#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); goto L_OP_ ## insn ## _BODY;
-#include "mruby/ops.h"
-#undef OPCODE
- }
- pc--;
- NEXT;
- }
-
CASE(OP_STOP, Z) {
/* stop VM */
- L_STOP:
- while (mrb->c->eidx > 0) {
- ecall(mrb);
+ CHECKPOINT_RESTORE(RBREAK_TAG_STOP) {
+ /* do nothing */
+ }
+ CHECKPOINT_MAIN(RBREAK_TAG_STOP) {
+ UNWIND_ENSURE(mrb, mrb->c->ci, pc, RBREAK_TAG_STOP, proc, mrb_nil_value());
}
- mrb->c->cibase->ridx = 0;
+ CHECKPOINT_END(RBREAK_TAG_STOP);
+ L_STOP:
ERR_PC_CLR(mrb);
mrb->jmp = prev_jmp;
if (mrb->exc) {
+ mrb_assert(mrb->exc->tt == MRB_TT_EXCEPTION);
return mrb_obj_value(mrb->exc);
}
return regs[irep->nlocals];
@@ -2743,14 +2818,19 @@ RETRY_TRY_BLOCK:
#undef regs
}
MRB_CATCH(&c_jmp) {
+ mrb_callinfo *ci = mrb->c->ci;
+ while (ci > mrb->c->cibase && ci->acc == CI_ACC_DIRECT) {
+ ci = cipop(mrb);
+ }
exc_catched = TRUE;
+ pc = pc_save;
goto RETRY_TRY_BLOCK;
}
MRB_END_EXC(&c_jmp);
}
static mrb_value
-mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
+mrb_run(mrb_state *mrb, const struct RProc *proc, mrb_value self)
{
if (mrb->c->ci->argc < 0) {
return mrb_vm_run(mrb, proc, self, 3); /* receiver, args and block) */
@@ -2761,7 +2841,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
MRB_API mrb_value
-mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
+mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep)
{
mrb_value v;
diff --git a/examples/targets/build_config_ArduinoDue.rb b/target/ArduinoDue.rb
similarity index 91%
rename from examples/targets/build_config_ArduinoDue.rb
rename to target/ArduinoDue.rb
index 09646a70007cb079c8ece081fcfe192af50983ec..5859f8508c207b08081a63249fc13873503ccbfa 100644
--- a/examples/targets/build_config_ArduinoDue.rb
+++ b/target/ArduinoDue.rb
@@ -1,19 +1,3 @@
-MRuby::Build.new do |conf|
-
- # Gets set by the VS command prompts.
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
- enable_debug
-
- # include the default GEMs
- conf.gembox 'default'
-
-end
-
# Cross Compiling configuration for Arduino Due
# http://arduino.cc/en/Main/ArduinoBoardDue
#
diff --git a/examples/targets/build_config_IntelEdison.rb b/target/IntelEdison.rb
similarity index 100%
rename from examples/targets/build_config_IntelEdison.rb
rename to target/IntelEdison.rb
diff --git a/examples/targets/build_config_IntelGalileo.rb b/target/IntelGalileo.rb
similarity index 92%
rename from examples/targets/build_config_IntelGalileo.rb
rename to target/IntelGalileo.rb
index 42f39c456d98494e9a339b228a5174b127f5d598..e996efa5bbc5ca8c9654e681f399a04cc357c9af 100644
--- a/examples/targets/build_config_IntelGalileo.rb
+++ b/target/IntelGalileo.rb
@@ -1,20 +1,3 @@
-MRuby::Build.new do |conf|
-
- # Gets set by the VS command prompts.
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
- enable_debug
-
- # include the default GEMs
- conf.gembox 'default'
-
-end
-
-
# Cross Compiling configuration for Intel Galileo on Arduino environment
# http://arduino.cc/en/ArduinoCertified/IntelGalileo
#
diff --git a/examples/targets/build_config_RX630.rb b/target/RX630.rb
similarity index 85%
rename from examples/targets/build_config_RX630.rb
rename to target/RX630.rb
index 8b1bbb42f043a1400ec1ae2060d769bca50e4ddc..01c883958b4a9b65dca1e2efffd3080aa7fd481a 100644
--- a/examples/targets/build_config_RX630.rb
+++ b/target/RX630.rb
@@ -1,19 +1,3 @@
-MRuby::Build.new do |conf|
-
- # Gets set by the VS command prompts.
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
- enable_debug
-
- # include the default GEMs
- conf.gembox 'default'
-
-end
-
# Cross Compiling configuration for RX630
# http://gadget.renesas.com/
#
@@ -30,7 +14,7 @@ MRuby::CrossBuild.new("RX630") do |conf|
cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
#configuration for low memory environment
- cc.defines << %w(MRB_USE_FLOAT)
+ cc.defines << %w(MRB_USE_FLOAT32)
cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
cc.defines << %w(KHASH_DEFAULT_SIZE=8)
cc.defines << %w(MRB_STR_BUF_MIN_SIZE=20)
diff --git a/target/android_arm64-v8a.rb b/target/android_arm64-v8a.rb
new file mode 100644
index 0000000000000000000000000000000000000000..7fab2f0639d5db8250ec947d0eda94f96c209247
--- /dev/null
+++ b/target/android_arm64-v8a.rb
@@ -0,0 +1,11 @@
+# Requires Android NDK r13 or later.
+MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
+ params = {
+ :arch => 'arm64-v8a',
+ :platform => 'android-24',
+ :toolchain => :clang,
+ }
+ toolchain :android, params
+
+ conf.gembox 'default'
+end
diff --git a/target/android_armeabi.rb b/target/android_armeabi.rb
new file mode 100644
index 0000000000000000000000000000000000000000..41a657c3bb8e47c107f52eed591bf13763784191
--- /dev/null
+++ b/target/android_armeabi.rb
@@ -0,0 +1,11 @@
+# Requires Android NDK r13 or later.
+MRuby::CrossBuild.new('android-armeabi') do |conf|
+ params = {
+ :arch => 'armeabi',
+ :platform => 'android-24',
+ :toolchain => :clang,
+ }
+ toolchain :android, params
+
+ conf.gembox 'default'
+end
diff --git a/examples/targets/build_config_android_armeabi_v7a_neon_hard.rb b/target/android_armeabi_v7a_neon_hard.rb
similarity index 54%
rename from examples/targets/build_config_android_armeabi_v7a_neon_hard.rb
rename to target/android_armeabi_v7a_neon_hard.rb
index 3788bba7f69f643a9c9f7733e7089cd25ee82021..6129b238e5c477e08c9a9e3f7d81a3edc73a4265 100644
--- a/examples/targets/build_config_android_armeabi_v7a_neon_hard.rb
+++ b/target/android_armeabi_v7a_neon_hard.rb
@@ -1,18 +1,3 @@
-MRuby::Build.new do |conf|
-
- # Gets set by the VS command prompts.
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
- enable_debug
-
- # include the default GEMs
- conf.gembox 'default'
-end
-
# Requires Android NDK r13 or later.
MRuby::CrossBuild.new('android-armeabi-v7a-neon-hard') do |conf|
params = {
diff --git a/target/appveyor.rb b/target/appveyor.rb
new file mode 100644
index 0000000000000000000000000000000000000000..e084a6a36e3315792e7188c8239419a6debf9cb4
--- /dev/null
+++ b/target/appveyor.rb
@@ -0,0 +1,18 @@
+def setup_option(conf)
+ conf.cc.flags[0].delete("/Zi") unless ENV['CFLAGS']
+ conf.cxx.flags[0].delete("/Zi") unless ENV['CFLAGS'] || ENV['CXXFLAGS']
+ conf.linker.flags << "/DEBUG:NONE" unless ENV['LDFLAGS']
+end
+
+MRuby::Build.new do |conf|
+ toolchain :visualcpp
+
+ # include all core GEMs
+ conf.gembox 'full-core'
+ conf.compilers.each do |c|
+ c.defines += %w(MRB_GC_FIXED_ARENA)
+ end
+ setup_option(conf)
+ conf.enable_bintest
+ conf.enable_test
+end
diff --git a/target/bench.rb b/target/bench.rb
new file mode 100644
index 0000000000000000000000000000000000000000..30ec56ad3ce24961b7cde6cf74da1a301da89bd5
--- /dev/null
+++ b/target/bench.rb
@@ -0,0 +1,11 @@
+MRuby::Build.new('bench') do |conf|
+ # Gets set by the VS command prompts.
+ if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+ toolchain :visualcpp
+ else
+ toolchain :gcc
+ conf.cc.flags << '-O3'
+ end
+
+ conf.gembox 'default'
+end
diff --git a/benchmark/build_config_boxing.rb b/target/boxing.rb
similarity index 68%
rename from benchmark/build_config_boxing.rb
rename to target/boxing.rb
index b478c9005c9761ebea84a0917f468d81185788bd..97c8e8ca9d0f9d5f551164695b1e6bce5920c588 100644
--- a/benchmark/build_config_boxing.rb
+++ b/target/boxing.rb
@@ -1,11 +1,11 @@
-MRuby::Build.new do |conf|
- toolchain :gcc
-end
-
-MRuby::Build.new('no_boxing') do |conf|
+MRuby::Build.new('no-boxing') do |conf|
toolchain :gcc
conf.gembox 'default'
+ conf.compilers.each do |c|
+ c.defines += %w(MRB_NO_BOXING)
+ end
+ conf.enable_test
end
MRuby::Build.new('word_boxing') do |conf|
@@ -15,6 +15,7 @@ MRuby::Build.new('word_boxing') do |conf|
conf.compilers.each do |c|
c.defines += %w(MRB_WORD_BOXING)
end
+ conf.enable_test
end
MRuby::Build.new('nan_boxing') do |conf|
@@ -24,5 +25,5 @@ MRuby::Build.new('nan_boxing') do |conf|
conf.compilers.each do |c|
c.defines += %w(MRB_NAN_BOXING)
end
+ conf.enable_test
end
-
diff --git a/examples/targets/build_config_chipKITMax32.rb b/target/chipKITMax32.rb
similarity index 90%
rename from examples/targets/build_config_chipKITMax32.rb
rename to target/chipKITMax32.rb
index 8617d8d10fc9d7016c5fc1c787a1f28f3bca1b26..bbee221f51557c66e1811ecec431eb6608b683cf 100644
--- a/examples/targets/build_config_chipKITMax32.rb
+++ b/target/chipKITMax32.rb
@@ -1,19 +1,3 @@
-MRuby::Build.new do |conf|
-
- # Gets set by the VS command prompts.
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
- enable_debug
-
- # include the default GEMs
- conf.gembox 'default'
-
-end
-
# Cross Compiling configuration for Digilent chipKIT Max32
# http://www.digilentinc.com/Products/Detail.cfm?Prod=CHIPKIT-MAX32
#
diff --git a/target/clang-asan.rb b/target/clang-asan.rb
new file mode 100644
index 0000000000000000000000000000000000000000..e693332c2979a611ff03f84e1eb1335e6fb91a6d
--- /dev/null
+++ b/target/clang-asan.rb
@@ -0,0 +1,21 @@
+MRuby::Build.new do |conf|
+ toolchain :clang
+ # include the GEM box
+ conf.gembox 'default'
+
+ # C compiler settings
+ conf.cc do |cc|
+ cc.flags << "-fsanitize=address,undefined"
+ cc.include_paths = ["#{root}/include"]
+ end
+
+ # Linker settings
+ conf.linker do |linker|
+ linker.flags << "-fsanitize=address,undefined"
+ end
+
+ # Turn on `enable_debug` for better debugging
+ enable_debug
+ conf.enable_bintest
+ conf.enable_test
+end
diff --git a/target/cross-32bit.rb b/target/cross-32bit.rb
new file mode 100644
index 0000000000000000000000000000000000000000..82d5d023f0a235e362a90813ca934484ffc634a4
--- /dev/null
+++ b/target/cross-32bit.rb
@@ -0,0 +1,14 @@
+# Define cross build settings
+MRuby::CrossBuild.new('cross-32bit') do |conf|
+ toolchain :gcc
+
+ conf.cc.flags << "-m32"
+ conf.linker.flags << "-m32"
+
+ # conf.build_mrbtest_lib_only
+
+ conf.gem :core => "mruby-bin-mruby"
+ conf.gem "#{MRUBY_ROOT}/examples/mrbgems/c_and_ruby_extension_example"
+
+ conf.test_runner.command = 'env'
+end
diff --git a/examples/targets/build_config_dreamcast_shelf.rb b/target/dreamcast_shelf.rb
similarity index 93%
rename from examples/targets/build_config_dreamcast_shelf.rb
rename to target/dreamcast_shelf.rb
index 85b2ff20df91775ba0f223baedcb0335a95fc55d..3ae53184d7d78e7a8476c4cc68f56bf646b16a73 100644
--- a/examples/targets/build_config_dreamcast_shelf.rb
+++ b/target/dreamcast_shelf.rb
@@ -1,17 +1,3 @@
-MRuby::Build.new do |conf|
- # Gets set by the VS command prompts
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
- enable_debug
-
- # Include the default GEMs
- conf.gembox 'default'
-end
-
# Cross Compiling configuration for the Sega Dreamcast
# This configuration requires KallistiOS (KOS)
# https://dreamcast.wiki
diff --git a/target/host-cxx.rb b/target/host-cxx.rb
new file mode 100644
index 0000000000000000000000000000000000000000..ae05e63c2dfc51e735d723cdf730475c9e3efa0c
--- /dev/null
+++ b/target/host-cxx.rb
@@ -0,0 +1,13 @@
+MRuby::Build.new do |conf|
+ toolchain :gcc
+
+ enable_debug
+ # include the default GEMs
+ conf.gembox 'full-core'
+
+ # C compiler settings
+ conf.cc.defines = %w(MRB_ENABLE_DEBUG_HOOK)
+ conf.enable_debug
+ conf.enable_cxx_abi
+ conf.enable_test
+end
diff --git a/target/host-debug.rb b/target/host-debug.rb
new file mode 100644
index 0000000000000000000000000000000000000000..ad41060655357603744b9747eccec0fa257058ec
--- /dev/null
+++ b/target/host-debug.rb
@@ -0,0 +1,26 @@
+MRuby::Build.new('host') do |conf|
+ # load specific toolchain settings
+
+ # Gets set by the VS command prompts.
+ if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+ toolchain :visualcpp
+ else
+ toolchain :gcc
+ end
+
+ enable_debug
+
+ # include the default GEMs
+ conf.gembox 'full-core'
+
+ # C compiler settings
+ conf.cc.defines = %w(MRB_ENABLE_DEBUG_HOOK MRB_NO_BOXING)
+
+ # Generate mruby debugger command (require mruby-eval)
+ conf.gem :core => "mruby-bin-debugger"
+
+ # test
+ enable_test
+ # bintest
+ enable_bintest
+end
diff --git a/target/host-gprof.rb b/target/host-gprof.rb
new file mode 100644
index 0000000000000000000000000000000000000000..31b952920933db338d391814c392f00c91046ab0
--- /dev/null
+++ b/target/host-gprof.rb
@@ -0,0 +1,14 @@
+MRuby::Build.new do |conf|
+ # load specific toolchain settings
+ toolchain :gcc
+
+ # include the GEM box
+ conf.gembox 'full-core'
+
+ conf.cc.flags << '-pg'
+ conf.linker.flags << '-pg'
+
+ # Turn on `enable_debug` for better debugging
+ enable_debug
+ conf.enable_test
+end
diff --git a/target/host-m32.rb b/target/host-m32.rb
new file mode 100644
index 0000000000000000000000000000000000000000..39b2c952fea18c2570655f0f5744c081ac6e885e
--- /dev/null
+++ b/target/host-m32.rb
@@ -0,0 +1,15 @@
+MRuby::Build.new do |conf|
+ # load specific toolchain settings
+ toolchain :gcc
+
+ # include the GEM box
+ conf.gembox 'full-core'
+
+ conf.cc.flags << '-m32'
+ conf.linker.flags << '-m32'
+
+ # Turn on `enable_debug` for better debugging
+ enable_debug
+ conf.enable_test
+ conf.enable_bintest
+end
diff --git a/target/host-shared.rb b/target/host-shared.rb
new file mode 100644
index 0000000000000000000000000000000000000000..8b50288371af5f7f163dc3485d6cfd75a17be61a
--- /dev/null
+++ b/target/host-shared.rb
@@ -0,0 +1,36 @@
+MRuby::Build.new do |conf|
+ # load specific toolchain settings
+
+ # Gets set by the VS command prompts.
+ if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+ toolchain :visualcpp
+ else
+ toolchain :gcc
+ end
+
+ # include the GEM box
+ conf.gembox 'default'
+
+ # C compiler settings
+ conf.cc do |cc|
+ cc.flags = '-fPIC'
+ end
+
+ conf.archiver do |archiver|
+ archiver.command = 'gcc'
+ archiver.archive_options = '-shared -o %{outfile} %{objs}'
+ end
+
+ # file extensions
+ conf.exts do |exts|
+ exts.library = '.so'
+ end
+
+ # file separetor
+ # conf.file_separator = '/'
+
+ # Turn on `enable_debug` for better debugging
+ enable_debug
+ conf.enable_bintest
+ conf.enable_test
+end
diff --git a/build_config.rb b/target/host.rb
similarity index 64%
rename from build_config.rb
rename to target/host.rb
index 254a28ce01eeb54adf003ae2e8faed5d5bcbb21e..eb6e3c15fd706510295624615eb1a69fd0b52164 100644
--- a/build_config.rb
+++ b/target/host.rb
@@ -8,9 +8,6 @@ MRuby::Build.new do |conf|
toolchain :gcc
end
- # Turn on `enable_debug` for better debugging
- # enable_debug
-
# Use mrbgems
# conf.gem 'examples/mrbgems/ruby_extension_example'
# conf.gem 'examples/mrbgems/c_extension_example' do |g|
@@ -22,8 +19,9 @@ MRuby::Build.new do |conf|
# conf.gem :github => 'mattn/mruby-onig-regexp'
# conf.gem :git => 'git@github.com:mattn/mruby-onig-regexp.git', :branch => 'master', :options => '-v'
- # include the default GEMs
- conf.gembox 'default'
+ # include the GEM box
+ conf.gembox 'full-core'
+
# C compiler settings
# conf.cc do |cc|
# cc.command = ENV['CC'] || 'gcc'
@@ -81,72 +79,8 @@ MRuby::Build.new do |conf|
# file separetor
# conf.file_separator = '/'
- # bintest
- # conf.enable_bintest
-end
-
-MRuby::Build.new('host-debug') do |conf|
- # load specific toolchain settings
-
- # Gets set by the VS command prompts.
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
- enable_debug
-
- # include the default GEMs
- conf.gembox 'default'
-
- # C compiler settings
- conf.cc.defines = %w(MRB_ENABLE_DEBUG_HOOK)
-
- # Generate mruby debugger command (require mruby-eval)
- conf.gem :core => "mruby-bin-debugger"
-
- # bintest
- # conf.enable_bintest
-end
-
-MRuby::Build.new('test') do |conf|
- # Gets set by the VS command prompts.
- if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
- toolchain :visualcpp
- else
- toolchain :gcc
- end
-
+ # Turn on `enable_debug` for better debugging
enable_debug
conf.enable_bintest
conf.enable_test
-
- conf.gembox 'default'
end
-
-#MRuby::Build.new('bench') do |conf|
-# # Gets set by the VS command prompts.
-# if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-# toolchain :visualcpp
-# else
-# toolchain :gcc
-# conf.cc.flags << '-O3'
-# end
-#
-# conf.gembox 'default'
-#end
-
-# Define cross build settings
-# MRuby::CrossBuild.new('32bit') do |conf|
-# toolchain :gcc
-#
-# conf.cc.flags << "-m32"
-# conf.linker.flags << "-m32"
-#
-# conf.build_mrbtest_lib_only
-#
-# conf.gem 'examples/mrbgems/c_and_ruby_extension_example'
-#
-# conf.test_runner.command = 'env'
-# end
diff --git a/travis_config.rb b/target/travis.rb
similarity index 88%
rename from travis_config.rb
rename to target/travis.rb
index f4bef0a523797adf2065aaeae8ff23b22c31fa76..58a739ce6b02df37304370775a7c2d67f38a1710 100644
--- a/travis_config.rb
+++ b/target/travis.rb
@@ -5,7 +5,7 @@ MRuby::Build.new('full-debug') do |conf|
# include all core GEMs
conf.gembox 'full-core'
conf.cc.flags += %w(-Werror=declaration-after-statement)
- conf.cc.defines += %w(MRB_GC_STRESS MRB_METHOD_CACHE MRB_ENABLE_DEBUG_HOOK)
+ conf.cc.defines += %w(MRB_GC_STRESS MRB_ENABLE_DEBUG_HOOK)
conf.enable_test
end
@@ -31,7 +31,6 @@ MRuby::Build.new('cxx_abi') do |conf|
conf.compilers.each do |c|
c.defines += %w(MRB_GC_FIXED_ARENA)
end
- conf.enable_bintest
conf.enable_test
enable_cxx_abi
diff --git a/tasks/benchmark.rake b/tasks/benchmark.rake
index 6352f5c1799b1a9b787158a29622757f57aa8f9a..661fd2ada60b728d9b6905d620921f194e361d6b 100644
--- a/tasks/benchmark.rake
+++ b/tasks/benchmark.rake
@@ -9,11 +9,7 @@ def bm_files
end
def build_config_name
- if ENV['MRUBY_CONFIG']
- File.basename(ENV['MRUBY_CONFIG'], '.rb').gsub('build_config_', '')
- else
- "build"
- end
+ MRUBY_TARGET
end
def plot_file
diff --git a/tasks/gitlab.rake b/tasks/gitlab.rake
index 377b1cc9d50fe3c427b0dc36faf6e8ea8e75bec9..5c7b3d8c5dda8690d01c23448990775545d830e9 100644
--- a/tasks/gitlab.rake
+++ b/tasks/gitlab.rake
@@ -62,10 +62,10 @@ task :gitlab_config do
configs = []
[true, false].each do |mode_32|
- ['', 'MRB_USE_FLOAT'].each do |float_conf|
+ ['', 'MRB_USE_FLOAT32'].each do |float_conf|
['', 'MRB_NAN_BOXING', 'MRB_WORD_BOXING'].each do |boxing_conf|
['', 'MRB_UTF8_STRING'].each do |utf8_conf|
- next if (float_conf == 'MRB_USE_FLOAT') && (boxing_conf == 'MRB_NAN_BOXING')
+ next if (float_conf == 'MRB_USE_FLOAT32') && (boxing_conf == 'MRB_NAN_BOXING')
next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_NAN_BOXING')
next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_WORD_BOXING') && mode_32
env = [float_conf, int_conf, boxing_conf, utf8_conf].map do |conf|
diff --git a/tasks/libmruby.rake b/tasks/libmruby.rake
index 17f8534e2f3fcaad1ae2296557461ea951d8f2b7..e302ca02ba6f47d6fe798f1c26e9aa5d0ac5a1e0 100644
--- a/tasks/libmruby.rake
+++ b/tasks/libmruby.rake
@@ -21,5 +21,4 @@ MRuby.each_target do
f.puts "MRUBY_LIBMRUBY_PATH = #{libmruby_static}"
end
end
- task :all => "#{build_dir}/lib/libmruby.flags.mak"
end
diff --git a/test/t/array.rb b/test/t/array.rb
index eec31d7513379aa6b8714ed663d155d5b58a8c13..2982cab01390c1cef96615b154f382ac1b8bdec4 100644
--- a/test/t/array.rb
+++ b/test/t/array.rb
@@ -372,8 +372,7 @@ end
assert('Array#hash', '15.2.12.5.35') do
a = [ 1, 2, 3 ]
- #assert_true(a.hash.is_a? Integer)
- assert_true(a.hash.is_a? Integral) # mruby special
+ assert_true(a.hash.is_a? Integer)
assert_equal([1,2].hash, [1,2].hash)
end
diff --git a/test/t/bs_literal.rb b/test/t/bs_literal.rb
index c6c38140ba25b53d5ca3c7d6d8b8ddb04a4da72f..d60957f0b1c9eb226e1ee1bfa483eeba1afea7a5 100644
--- a/test/t/bs_literal.rb
+++ b/test/t/bs_literal.rb
@@ -34,5 +34,5 @@ assert('BS Literal 8') do
end
assert('BS Literal 9') do
- assert_equal Fixnum, 1234.class
+ assert_equal Integer, 1234.class
end
diff --git a/test/t/float.rb b/test/t/float.rb
index dc989636fcec02d6dd9071ebc00520854470ea1a..e2a8a50886a07b27e43af12b5e563d4b61722fe7 100644
--- a/test/t/float.rb
+++ b/test/t/float.rb
@@ -207,7 +207,7 @@ assert('Float#>>') do
end
assert('Float#to_s') do
- uses_float = 4e38.infinite? # enable MRB_USE_FLOAT?
+ uses_float = 4e38.infinite? # enable MRB_USE_FLOAT32?
assert_equal("Infinity", Float::INFINITY.to_s)
assert_equal("-Infinity", (-Float::INFINITY).to_s)
@@ -239,6 +239,11 @@ assert('Float#to_s') do
end
end
+assert('Float#inspect') do
+ assert_equal("-3.25", -3.25.inspect)
+ assert_equal("50.0", 50.0.inspect)
+end
+
assert('Float#eql?') do
assert_operator(5.0, :eql?, 5.0)
assert_not_operator(5.0, :eql?, 5)
diff --git a/test/t/integer.rb b/test/t/integer.rb
index f9c44a64f6564922b9bf80d8b19a3462175e9436..5204eb91b4267147cf2a1bd4d1eb5057d56cffe7 100644
--- a/test/t/integer.rb
+++ b/test/t/integer.rb
@@ -14,16 +14,6 @@ assert('Integer#+', '15.2.8.3.1') do
assert_raise(TypeError){ 0+nil }
assert_raise(TypeError){ 1+nil }
-
- c = Mrbtest::FIXNUM_MAX + 1
- d = Mrbtest::FIXNUM_MAX.__send__(:+, 1)
-
- skip unless Object.const_defined?(:Float)
- e = Mrbtest::FIXNUM_MAX + 1.0
- assert_equal Float, c.class
- assert_equal Float, d.class
- assert_float e, c
- assert_float e, d
end
assert('Integer#-', '15.2.8.3.2') do
@@ -32,37 +22,17 @@ assert('Integer#-', '15.2.8.3.2') do
assert_equal 1, a
assert_equal 1.0, b if Object.const_defined?(:Float)
-
- c = Mrbtest::FIXNUM_MIN - 1
- d = Mrbtest::FIXNUM_MIN.__send__(:-, 1)
-
- skip unless Object.const_defined?(:Float)
- e = Mrbtest::FIXNUM_MIN - 1.0
- assert_equal Float, c.class
- assert_equal Float, d.class
- assert_float e, c
- assert_float e, d
end
assert('Integer#*', '15.2.8.3.3') do
a = 1*1
- b = 1*1.0 if Object.const_defined?(:Float)
-
assert_equal 1, a
- assert_equal 1.0, b if Object.const_defined?(:Float)
-
+ if Object.const_defined?(:Float)
+ b = 1*1.0
+ assert_equal 1.0, b
+ end
assert_raise(TypeError){ 0*nil }
assert_raise(TypeError){ 1*nil }
-
- c = Mrbtest::FIXNUM_MAX * 2
- d = Mrbtest::FIXNUM_MAX.__send__(:*, 2)
-
- skip unless Object.const_defined?(:Float)
- e = Mrbtest::FIXNUM_MAX * 2.0
- assert_equal Float, c.class
- assert_equal Float, d.class
- assert_float e, c
- assert_float e, d
end
assert('Integer#/', '15.2.8.3.4') do
@@ -156,7 +126,7 @@ assert('Integer#<<', '15.2.8.3.12') do
skip unless Object.const_defined?(:Float)
- # Overflow to Fixnum
+ # Overflow to Integer
assert_float 9223372036854775808.0, 1 << 63
assert_float(-13835058055282163712.0, -3 << 62)
end
diff --git a/test/t/kernel.rb b/test/t/kernel.rb
index 6061501474d1b69f4e23f07a4d825aeb79767710..cab1ddd3d7e078e14313975bfea2a5aae3a21531 100644
--- a/test/t/kernel.rb
+++ b/test/t/kernel.rb
@@ -76,7 +76,7 @@ assert('Kernel.raise', '15.3.1.2.12') do
end
assert('Kernel#__id__', '15.3.1.3.3') do
- assert_equal Fixnum, __id__.class
+ assert_equal Integer, __id__.class
end
assert('Kernel#__send__', '15.3.1.3.4') do
diff --git a/test/t/module.rb b/test/t/module.rb
index 12b7f1344b552570eb1f1f713965af59533c473e..2957dec52d2ac1e14dd9db547dd43498eb61d8b7 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -593,7 +593,7 @@ end
# to_f / other
# end
# end
- # Fixnum.send(:prepend, M)
+ # Integer.send(:prepend, M)
# assert_equal(0.5, 1 / 2, "#{bug7983}")
# }
# assert_equal(0, 1 / 2)
diff --git a/test/t/numeric.rb b/test/t/numeric.rb
index af44a2e1a387f5f8564b0091a0d383ed3014391b..8baf6c883b502073a4e3d8f57f0c88cd13dbb250 100644
--- a/test/t/numeric.rb
+++ b/test/t/numeric.rb
@@ -36,7 +36,7 @@ assert('Numeric#/', '15.2.8.3.4') do
n = Class.new(Numeric){ def /(x); 15.1;end }.new
assert_equal(2, 10/5)
- assert_equal(0.0625, 1/16)
+ assert_equal(0, 1/16)
assert_equal(15.1, n/10)
assert_raise(TypeError){ 1/n }
assert_raise(TypeError){ 1/nil }
diff --git a/test/t/superclass.rb b/test/t/superclass.rb
index 10b6438d376e4d3faaff3b59fb22c54c9051d13f..f213b124712daf841ecce17e1c8ecb57c9fa27e1 100644
--- a/test/t/superclass.rb
+++ b/test/t/superclass.rb
@@ -25,20 +25,20 @@
[:ArgumentError, :StandardError, '15.2.24.2'],
# [:LocalJumpError, :StandardError, '15.2.25.2'],
[:LocalJumpError, :ScriptError, '15.2.25.2'], # mruby specific
- [:RangeError, :StandardError, '12.2.26.2'],
- [:RegexpError, :StandardError, '12.2.27.2'],
- [:RuntimeError, :StandardError, '12.2.28.2'],
- [:TypeError, :StandardError, '12.2.29.2'],
-# [:ZeroDivisionError, :StandardError, '12.2.30.2'], # No ZeroDivisionError in mruby
+ [:RangeError, :StandardError, '15.2.26.2'],
+ [:RegexpError, :StandardError, '15.2.27.2'],
+ [:RuntimeError, :StandardError, '15.2.28.2'],
+ [:TypeError, :StandardError, '15.2.29.2'],
+ [:ZeroDivisionError, :StandardError, '15.2.30.2'],
[:NameError, :StandardError, '15.2.31.2'],
[:NoMethodError, :NameError, '15.2.32.2'],
[:IndexError, :StandardError, '15.2.33.2'],
-# [:IOError, :StandardError, '12.2.34.2'],
-# [:EOFError, :IOError, '12.2.35.2'],
+# [:IOError, :StandardError, '15.2.34.2'],
+# [:EOFError, :IOError, '15.2.35.2'],
# [:SystemCallError, :StandardError, '15.2.36.2'],
- [:ScriptError, :Exception, '12.2.37.2'],
- [:SyntaxError, :ScriptError, '12.2.38.2'],
-# [:LoadError, :ScriptError, '12.2.39,2'],
+ [:ScriptError, :Exception, '15.2.37.2'],
+ [:SyntaxError, :ScriptError, '15.2.38.2'],
+# [:LoadError, :ScriptError, '15.2.39,2'],
].each do |cls, super_cls, iso|
assert "Direct superclass of #{cls}", iso do
skip "#{cls} isn't defined" unless Object.const_defined? cls
diff --git a/test/t/syntax.rb b/test/t/syntax.rb
index 436c06601dfeabc956efd4399700ab4ef7ec4399..a52e0dcea745ff0660715eed45785bd5589350eb 100644
--- a/test/t/syntax.rb
+++ b/test/t/syntax.rb
@@ -345,6 +345,15 @@ assert('splat object in assignment') do
assert_equal [2], (a = *o)
end
+assert('right-ward assignment') do
+ 1 => a
+ assert_equal(1, a)
+ 13.divmod(5) => a,b
+ assert_equal([2,3], [a, b])
+ 13.divmod(5) => a,b => c, d
+ assert_equal([2,3,2,3], [a, b, c, d])
+end
+
assert('splat object in case statement') do
o = Object.new
def o.to_a
diff --git a/test/t/vformat.rb b/test/t/vformat.rb
index df6950ee64d21f8dda3afd4673c0d1198c4a5647..f645351ee757da6f5049c7ade4f8d7f0d93b51d6 100644
--- a/test/t/vformat.rb
+++ b/test/t/vformat.rb
@@ -17,7 +17,7 @@ assert('mrb_vformat') do
assert_equal '`t`: NilClass', vf.v('`t`: %t', nil)
assert_equal '`t`: FalseClass', vf.v('`t`: %t', false)
assert_equal '`t`: TrueClass', vf.v('`t`: %t', true)
- assert_equal '`t`: Fixnum', vf.v('`t`: %t', 0)
+ assert_equal '`t`: Integer', vf.v('`t`: %t', 0)
assert_equal '`t`: Hash', vf.v('`t`: %t', {k: "value"})
assert_match '#<Class:#<Class:#<Hash:0x*>>>', vf.v('%t', sclass({}))
assert_equal 'string and length', vf.l('string %l length', 'andante', 3)
@@ -29,13 +29,13 @@ assert('mrb_vformat') do
assert_equal '`T`: NilClass', vf.v('`T`: %T', nil)
assert_equal '`T`: FalseClass', vf.v('`T`: %T', false)
assert_equal '`T`: TrueClass', vf.v('`T`: %T', true)
- assert_equal '`T`: Fixnum', vf.v('`T`: %T', 0)
+ assert_equal '`T`: Integer', vf.v('`T`: %T', 0)
assert_equal '`T`: Hash', vf.v('`T`: %T', {k: "value"})
assert_match 'Class', vf.v('%T', sclass({}))
assert_equal '`Y`: nil', vf.v('`Y`: %Y', nil)
assert_equal '`Y`: false', vf.v('`Y`: %Y', false)
assert_equal '`Y`: true', vf.v('`Y`: %Y', true)
- assert_equal '`Y`: Fixnum', vf.v('`Y`: %Y', 0)
+ assert_equal '`Y`: Integer', vf.v('`Y`: %Y', 0)
assert_equal '`Y`: Hash', vf.v('`Y`: %Y', {k: "value"})
assert_equal 'Class', vf.v('%Y', sclass({}))
assert_match '#<Class:#<String:0x*>>', vf.v('%v', sclass(""))