diff options
148 files changed, 9358 insertions, 7799 deletions
diff --git a/.editorconfig b/.editorconfig index 705b1f022..70cc78f0b 100644 --- a/.editorconfig +++ b/.editorconfig @@ -6,38 +6,38 @@ root = true [*] -indent_style = tab -indent_size = 8 -tab_width = 8 -end_of_line = lf charset = utf-8 +end_of_line = lf +indent_size = 8 +indent_style = tab insert_final_newline = true +tab_width = 8 [{Makefile,Makefile.*,makefile,*.mk}] trim_trailing_whitespace = true #max_line_length = 80 [*.{c,cc,C,cxx,cpp,h,hh,H,hxx,hpp,inc,y}] -indent_style = space indent_size = 2 +indent_style = space trim_trailing_whitespace = true #max_line_length = 120 [{*.rb,Rakefile,rakefile,*.rake,*.gemspec,*.gembox}] -indent_style = space indent_size = 2 +indent_style = space trim_trailing_whitespace = true #max_line_length = 120 [*.bat] -end_of_line = crlf charset = latin1 +end_of_line = crlf #max_line_length = 80 [*.{yaml,yml}] -indent_style = space indent_size = 2 +indent_style = space [*.md] -indent_style = space indent_size = 2 +indent_style = space diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs new file mode 100644 index 000000000..3dab080a9 --- /dev/null +++ b/.git-blame-ignore-revs @@ -0,0 +1,4 @@ +# Extend the tab with 8 whitespace +6fc5dc986a5ffc1a74c63ad0617ea1dcc10d3cdd +# reformatted doc/opcode.md +61e8a540869c57ebddac53cf9d243db407d57fff diff --git a/.github/linters/.markdown-lint.yml b/.github/linters/.markdown-lint.yml index 671046203..a1023acbd 100644 --- a/.github/linters/.markdown-lint.yml +++ b/.github/linters/.markdown-lint.yml @@ -1,13 +1,26 @@ +# https://github.com/DavidAnson/markdownlint#rules--aliases +# markdownlint -c .github/linters/.markdown-lint.yml . + +# MD001 heading-increment/header-increment - Heading levels should only increment by one level at a time MD001: false -MD003: false -MD005: false -MD007: false + +# MD010 no-hard-tabs - Hard tabs MD010: false -MD011: false + +# MD013 line-length - Line length MD013: false + +# MD014 commands-show-output - Dollar signs used before commands without showing output MD014: false + +# MD024 no-duplicate-heading/no-duplicate-header - Multiple headings with the same content MD024: false + +# MD025 single-title/single-h1 - Multiple top-level headings in the same document MD025: false + +# MD026 no-trailing-punctuation - Trailing punctuation in heading MD026: false + +# MD040 fenced-code-language - Fenced code blocks should have a language specified MD040: false -MD046: false diff --git a/.github/linters/.yaml-lint.yml b/.github/linters/.yaml-lint.yml index 88f3b4eb9..be4c88798 100644 --- a/.github/linters/.yaml-lint.yml +++ b/.github/linters/.yaml-lint.yml @@ -1,5 +1,6 @@ --- - +# https://yamllint.readthedocs.io/en/stable/ +# yamllint --strict -c .github/linters/.yaml-lint.yml . extends: default rules: diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 93e759c3e..6ee80eefd 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -10,7 +10,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: gcc steps: - - uses: actions/checkout@v2 + - uses: actions/[email protected] - name: Ruby version run: ruby -v - name: Compiler version @@ -25,7 +25,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: clang steps: - - uses: actions/checkout@v2 + - uses: actions/[email protected] - name: Ruby version run: ruby -v - name: Compiler version @@ -40,7 +40,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: gcc steps: - - uses: actions/checkout@v2 + - uses: actions/[email protected] - name: Ruby version run: ruby -v - name: Compiler version @@ -55,7 +55,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: clang steps: - - uses: actions/checkout@v2 + - uses: actions/[email protected] - name: Ruby version run: ruby -v - name: Compiler version @@ -70,7 +70,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: clang steps: - - uses: actions/checkout@v2 + - uses: actions/[email protected] - name: Ruby version run: ruby -v - name: Compiler version @@ -85,7 +85,7 @@ jobs: MRUBY_CONFIG: ci/gcc-clang CC: gcc steps: - - uses: actions/checkout@v2 + - uses: actions/[email protected] - name: Ruby version run: ruby -v - name: Compiler version @@ -105,8 +105,8 @@ jobs: package-dir: C:\cygwin-package cache-version: v1 steps: - - uses: actions/checkout@v2 - - uses: actions/[email protected] + - uses: actions/[email protected] + - uses: actions/[email protected] with: path: ${{ env.package-dir }} key: ${{ runner.os }}-cygwin-${{ env.cache-version }} @@ -145,7 +145,7 @@ jobs: env: MRUBY_CONFIG: ci/msvc steps: - - uses: actions/checkout@v2 + - uses: actions/[email protected] - name: Ruby version run: ruby -v - name: Build and test diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index 75f80a558..4b0be0ed0 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -13,7 +13,7 @@ jobs: steps: - name: Checkout repository - uses: actions/checkout@v2 + uses: actions/[email protected] with: # We must fetch at least the immediate parents so that if this is # a pull request then we can checkout the head. diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index f949c5bbc..3e89c0328 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -4,29 +4,29 @@ on: [pull_request] jobs: misspell: - name: Check Spelling + name: Check spelling with misspell runs-on: ubuntu-latest steps: - name: Check Out - uses: actions/checkout@v2 + uses: actions/[email protected] - name: Install - run: | - wget -O - -q https://git.io/misspell | sh -s -- -b . + run: wget -O - -q https://git.io/misspell | sh -s -- -b . - name: Misspell - run: | - git ls-files --empty-directory | xargs ./misspell -error - merge-conflict: - name: Merge Conflict + run: git ls-files --empty-directory | xargs ./misspell -error + pre-commit: + name: Run pre-commit runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/[email protected] - name: Check merge conflict run: | - grep "^<<<<<<< HEAD" $(git ls-files | xargs) && exit 1 || true - trailing-whitespace: - name: Trailing whitespace - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - - name: Check for trailing whitespace - run: "! git grep -EIn $'[ \t]+$'" + python -m pip install --upgrade pip + pip install pre-commit + - name: Set PY + run: echo "PY=$(python -VV | sha256sum | cut -d' ' -f1)" >> $GITHUB_ENV + - uses: actions/cache@v1 + with: + path: ~/.cache/pre-commit + key: pre-commit|${{ env.PY }}|${{ hashFiles('.pre-commit-config.yaml') }} + - name: Run pre-commit + run: pre-commit run --all-files diff --git a/.github/workflows/oss-fuzz.yml b/.github/workflows/oss-fuzz.yml index e693b913d..739e4afad 100644 --- a/.github/workflows/oss-fuzz.yml +++ b/.github/workflows/oss-fuzz.yml @@ -16,7 +16,7 @@ jobs: fuzz-seconds: 600 dry-run: false - name: Upload Crash - uses: actions/[email protected] + uses: actions/[email protected] if: failure() with: name: artifacts diff --git a/.github/workflows/linter.yml b/.github/workflows/super-linter.yml index 306060c3f..7265d6270 100644 --- a/.github/workflows/linter.yml +++ b/.github/workflows/super-linter.yml @@ -1,4 +1,4 @@ -name: Lint Code Base +name: Super Linter on: push: @@ -12,14 +12,12 @@ jobs: name: Lint Code Base runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 - - uses: github/super-linter@v3 + - uses: actions/[email protected] + - uses: github/[email protected] env: ERROR_ON_MISSING_EXEC_BIT: true VALIDATE_BASH: true # VALIDATE_BASH_EXEC: true # VALIDATE_EDITORCONFIG: true - VALIDATE_MARKDOWN: true # VALIDATE_SHELL_SHFMT: true - VALIDATE_YAML: true GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 46abd0675..6aaf2a261 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -10,15 +10,19 @@ repos: - id: identity - id: check-hooks-apply - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v3.4.0 + rev: v4.0.1 hooks: - id: check-added-large-files - id: check-case-conflict - id: check-executables-have-shebangs exclude: ^test/t/lang\.rb$ - id: check-merge-conflict + - id: check-vcs-permalinks - id: check-yaml + - id: detect-private-key - id: end-of-file-fixer + - id: file-contents-sorter + files: ^codespell\.txt$ - id: fix-byte-order-marker - id: mixed-line-ending - id: trailing-whitespace @@ -27,16 +31,28 @@ repos: # hooks: # - id: forbid-tabs # - id: remove-tabs + - repo: https://github.com/codespell-project/codespell + rev: v2.1.0 + hooks: + - id: codespell + name: Run codespell + description: Check spelling with codespell + entry: codespell --ignore-words=codespell.txt - repo: https://github.com/igorshubovych/markdownlint-cli - rev: v0.27.1 + rev: v0.28.1 hooks: - id: markdownlint name: Run markdownlint + description: Checks the style of Markdown files entry: markdownlint -c .github/linters/.markdown-lint.yml . + types: [markdown] + files: \.(md|mdown|markdown)$ - repo: https://github.com/adrienverge/yamllint - rev: v1.26.1 + rev: v1.26.3 hooks: - id: yamllint - name: Check YAML files with yamllint - entry: yamllint --strict -c .github/linters/.yaml-lint.yml . + name: Run yamllint + description: Check YAML files with yamllint + entry: yamllint --strict -c .github/linters/.yaml-lint.yml types: [yaml] + files: \.(yaml|yml)$ @@ -1,16 +1,16 @@ # Authors of mruby (mruby developers) -## The List of Contributors sorted by number of commits (as of 2021-04-12 ff2ffe3) +## The List of Contributors sorted by number of commits (as of 2021-09-16 8619ba6) - 7340 Yukihiro "Matz" Matsumoto (@matz)* - 576 KOBAYASHI Shuji (@shuujii) + 7663 Yukihiro "Matz" Matsumoto (@matz)* + 586 KOBAYASHI Shuji (@shuujii) 376 Daniel Bovensiepen (@bovi) 344 Takeshi Watanabe (@take-cheeze)* 334 Masaki Muranaka (@monaka) + 308 dearblue (@dearblue)* 298 Tomoyuki Sahara (@tsahara)* - 276 dearblue (@dearblue)* 234 Jun Hiroe (@suzukaze) - 217 Cremno (@cremno)* + 219 Cremno (@cremno)* 208 Yuki Kurihara (@ksss)+ 148 Yasuhiro Matsumoto (@mattn)* 113 Carson McDonald (@carsonmcdonald) @@ -25,6 +25,7 @@ 59 Kurebayashi, Takahiro (@crimsonwoods)* 56 h2so5 (@h2so5) 52 Ralph Desir (@Mav7)* + 45 John Bampton (@jbampton) 45 Rory O'Connell (@RoryO)* 43 Yuichiro Kaneko (@yui-knk)+ 42 fleuria (@flaneur2020) @@ -35,22 +36,21 @@ 31 MATSUMOTO Ryosuke (@matsumotory)* 30 Nobuyoshi Nakada (@nobu) 28 Masayoshi Takahashi (@takahashim)+ - 26 John Bampton (@jbampton) 24 Julian Aron Prenner (@furunkel)* 24 Ryan Scott (@ryan-scott-dev)* 22 Clayton Smith (@clayton-shopify) 22 Zachary Scott (@zzak)* + 22 mirichi (@mirichi) 21 Jared Breeden (@jbreeden)* - 20 mirichi (@mirichi) + 20 Uchio Kondo (@udzura)* 19 Bouke van der Bijl (@bouk) 19 Felix Jones (@felixjones)* 19 Hidetaka Takano (@TJ-Hidetaka-Takano) - 19 Uchio Kondo (@udzura)* 19 go kikuta (@gkta)* 18 Corey Powell (@IceDragon200) 18 Jon Maken (@jonforums)+ 18 Mitchell Blank Jr (@mitchblank)* - 16 Ryan Lopopolo (@lopopolo) + 17 Ryan Lopopolo (@lopopolo) 16 bggd (@bggd) 16 kano4 (@kano4) 14 Blaž Hrastnik (@archseer)* @@ -107,6 +107,7 @@ 5 Yurie Yamane (@yurie)+ 5 dreamedge (@dreamedge) 5 nkshigeru (@nkshigeru) + 4 Dante Catalfamo (@dantecatalfamo) 4 Goro Kikuchi (@gorogit) 4 Herwin Weststrate (@herwinw) 4 Jon Moss (@maclover7) @@ -122,7 +123,7 @@ 4 kurodash (@kurodash)* 4 masahino (@masahino) 4 wanabe (@wanabe)* - 4 xuejianqing (@zhihuikeji) + 4 xuejianqing (@joans321) 3 Anton Davydov (@davydovanton) 3 Carlo Prelz (@asfluido)* 3 David Turnbull (@AE9RB) @@ -131,8 +132,8 @@ 3 J. Mutua (@katmutua)+ 3 Jan Berdajs (@mrbrdo) 3 Joseph McCullough (@joequery) + 3 Mark McCurry (@fundamental) 3 Nobuhiro Iwamatsu (@iwamatsu) - 3 Mark McCurry (@fundamental) 3 Per Lundberg (@perlun)* 3 Rob Fors (@robfors)* 3 Rodrigo Malizia (@rmalizia44)+ @@ -238,6 +239,7 @@ 1 Megumi Tomita (@tomykaira)+ 1 Mitchell Hashimoto (@mitchellh) 1 Mitsutaka Mimura (@takkanm) + 1 Nathan Ladd (@ntl) 1 Nicholas (@knf) 1 Nozomi SATO (@nozomiS) 1 Okumura Takahiro (@hfm) @@ -255,6 +257,7 @@ 1 Sayed Abdelhaleem (@visualsayed) 1 Shugo Maeda (@shugo) 1 Sorah Fukumori (@sorah) + 1 Stuart Hinson (@stuarth) 1 Takuma Kume (@takumakume)+ 1 Thomas Schmidt (@digitaltom) 1 Timo Schilling (@timoschilling) @@ -286,6 +289,12 @@ `*` - Entries unified according to names and addresses `+` - Entries with names different from commits +## Contributors without named commits + + Yuichi Osawa (Mitsubishi Electric Micro-Computer Application Software) + Shota Nakano (Manycolors) + Bjorn De Meyer + ## Corporate contributors Ministry of Economy, Trade and Industry, Japan @@ -297,9 +306,3 @@ Specified non-profit organization mruby Forum Mitsubishi Electric Micro-Computer Application Software Co.,Ltd. Manycolors, Inc. - -## Contributors without named commits - - Yuichi Osawa (Mitsubishi Electric Micro-Computer Application Software) - Shota Nakano (Manycolors) - Bjorn De Meyer diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index ebc9c2239..516be1e3c 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -10,7 +10,7 @@ things in mind before submitting your pull request: * Work on the latest possible state of **mruby/master** * Create a branch which is dedicated to your change -* Test your changes before creating a pull request (```rake test```) +* Test your changes before creating a pull request (`rake test`) * If possible write a test case which confirms your change * Don't mix several features or bug-fixes in one pull request * Create a meaningful commit message @@ -18,15 +18,15 @@ things in mind before submitting your pull request: * Use mrbgem to provide non ISO features (classes, modules and methods) unless you have a special reason to implement them in the core -## Pre-commit +## pre-commit -A framework for managing and maintaining multi-language pre-commit hooks. -Pre-commit can be [installed](https://pre-commit.com/#installation) with `pip`, `curl`, `brew` or `conda`. +A framework for managing and maintaining multi-language `pre-commit` hooks. +`pre-commit` can be [installed](https://pre-commit.com/#installation) with `pip`, `curl`, `brew` or `conda`. -You need to first install pre-commit and then install the pre-commit hooks with `pre-commit install`. -Now pre-commit will run automatically on git commit! +You need to first install `pre-commit` and then install the `pre-commit` hooks with `pre-commit install`. +Now `pre-commit` will run automatically on git commit! -It's usually a good idea to run the hooks against all the files when adding new hooks (usually pre-commit will only run on the changed files during git hooks). +It's usually a good idea to run the hooks against all the files when adding new hooks (usually `pre-commit` will only run on the changed files during git hooks). Use `pre-commit run --all-files` to check all files. To run a single hook use `pre-commit run --all-files <hook_id>` @@ -37,6 +37,22 @@ To update use `pre-commit autoupdate` * [Usage](https://pre-commit.com/#usage) * [pre-commit-autoupdate](https://pre-commit.com/#pre-commit-autoupdate) +## Spell Checking + +We are running [misspell](https://github.com/client9/misspell) which is mainly written in +[Golang](https://golang.org/) to check spelling with [GitHub Actions](.github/workflows/lint.yml). +Correct commonly misspelled English words quickly with `misspell`. You can run `misspell` locally +against all files with: + +```bash +find . -type f | xargs ./misspell -error +``` + +Notable `misspell` help options or flags are: + +* `-i` string: ignore the following corrections, comma separated +* `-w`: Overwrite file with corrections (default is just to display) + ## Coding conventions How to style your C and Ruby code which you want to submit. @@ -67,13 +83,13 @@ on-demand. #### Insert a break after the function return value: - ```C - int - main(void) - { - ... - } - ``` +```c +int +main(void) +{ + ... +} +``` ### Ruby code diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 000000000..2f0ae5b28 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,18 @@ +# Security Policy + +## Reporting a Vulnerability + +If you have any security concern, contact <[email protected]>. + +## Scope + +We consider following issues as vulnerabilities: + +* Remote code execution +* Crash caused by a valid Ruby script + +We *don't* consider following issues as vulnerabilities: + +* Runtime C undefined behavior (including integer overflow) +* Crash caused by misused API +* Crash caused by tweaked compiled binary @@ -1,17 +1,14 @@ -Thing to Do in the future -=== +# Thing to Do in the future # After mruby 3.0 -* replace `fp_fmt.c` by `float_format` (<https://github.com/dhylands/format-float.git>) * multi-precision integer -* WORD_BOXING: Pack some floats in `mrb_value` * NAN_BOXING: Allow `MRB_INT64` along with NaN boxing -* keyword arguments à la Ruby3.0 (using `OP_SENDVK`) -* parser and code generator independent from `mrb_state` (mmruby?) +* keyword arguments à la Ruby3.0 (update `OP_SEND`) +* parser and code generator independent from `mrb_state` (picoruby?) +* variable sized AST node # Things to do (Things that are not done yet) * `begin ... end while cond` to behave as CRuby * special variables ($1,$2..) -* super in aliased methods diff --git a/benchmark/build_config_cc.rb b/benchmark/build_config_cc.rb deleted file mode 100644 index 56d725bc7..000000000 --- a/benchmark/build_config_cc.rb +++ /dev/null @@ -1,13 +0,0 @@ -MRuby::Build.new do |conf| - toolchain :gcc -end - -MRuby::Build.new('gcc') do |conf| - toolchain :gcc - conf.gembox 'default' -end - -MRuby::Build.new('clang') do |conf| - toolchain :clang - conf.gembox 'default' -end diff --git a/build_config/IntelGalileo.rb b/build_config/IntelGalileo.rb index d28986e36..f1f39e5dc 100644 --- a/build_config/IntelGalileo.rb +++ b/build_config/IntelGalileo.rb @@ -74,7 +74,7 @@ MRuby::CrossBuild.new("Galileo") do |conf| conf.gem :core => "mruby-fiber" conf.gem :core => "mruby-toplevel-ext" - #lightweigh regular expression + #lightweight regular expression conf.gem :github => "masamitsu-murase/mruby-hs-regexp", :branch => "master" #Arduino API diff --git a/build_config/android_arm64-v8a.rb b/build_config/android_arm64_v8a.rb index 7fab2f063..7fab2f063 100644 --- a/build_config/android_arm64-v8a.rb +++ b/build_config/android_arm64_v8a.rb diff --git a/build_config/ci/gcc-clang.rb b/build_config/ci/gcc-clang.rb index aa4a1a87d..eeaab5d0f 100644 --- a/build_config/ci/gcc-clang.rb +++ b/build_config/ci/gcc-clang.rb @@ -6,7 +6,7 @@ MRuby::Build.new('full-debug') do |conf| # include all core GEMs conf.gembox 'full-core' - conf.cc.defines += %w(MRB_GC_STRESS MRB_USE_DEBUG_HOOK) + conf.cc.defines += %w(MRB_GC_STRESS MRB_USE_DEBUG_HOOK MRB_UTF8_STRING) conf.enable_test end @@ -18,7 +18,7 @@ MRuby::Build.new do |conf| conf.gembox 'full-core' conf.gem :core => 'mruby-bin-debugger' conf.compilers.each do |c| - c.defines += %w(MRB_GC_FIXED_ARENA) + c.defines += %w(MRB_GC_FIXED_ARENA MRB_UTF8_STRING) end conf.enable_bintest conf.enable_test @@ -28,9 +28,9 @@ MRuby::Build.new('cxx_abi') do |conf| conf.toolchain conf.gembox 'full-core' - conf.cc.flags += %w(-fpermissive) + conf.cc.flags += %w(-fpermissive -std=gnu++03) conf.compilers.each do |c| - c.defines += %w(MRB_GC_FIXED_ARENA) + c.defines += %w(MRB_GC_FIXED_ARENA MRB_UTF8_STRING) end conf.enable_test diff --git a/build_config/dreamcast_shelf.rb b/build_config/dreamcast_shelf.rb index ee9b260a5..092fde0d0 100644 --- a/build_config/dreamcast_shelf.rb +++ b/build_config/dreamcast_shelf.rb @@ -74,7 +74,6 @@ MRuby::CrossBuild.new("dreamcast") do |conf| conf.gem :core => "mruby-array-ext" conf.gem :core => "mruby-binding" - conf.gem :core => "mruby-binding-core" conf.gem :core => "mruby-catch" conf.gem :core => "mruby-class-ext" conf.gem :core => "mruby-cmath" @@ -90,7 +89,6 @@ MRuby::CrossBuild.new("dreamcast") do |conf| conf.gem :core => "mruby-exit" conf.gem :core => "mruby-fiber" conf.gem :core => "mruby-hash-ext" - conf.gem :core => "mruby-inline-struct" # conf.gem :core => "mruby-io" conf.gem :core => "mruby-kernel-ext" conf.gem :core => "mruby-math" diff --git a/build_config/no-float.rb b/build_config/host-nofloat.rb index 977bf4e12..977bf4e12 100644 --- a/build_config/no-float.rb +++ b/build_config/host-nofloat.rb diff --git a/build_config/serenity.rb b/build_config/serenity.rb new file mode 100644 index 000000000..6704d2673 --- /dev/null +++ b/build_config/serenity.rb @@ -0,0 +1,26 @@ +# Cross compiling configuration for SerenityOS +# Graphical Unix-like operating system for x86 computers. +# https://github.com/SerenityOS/serenity +# +# Should be built using the SerenityOS Ports system +# https://github.com/SerenityOS/serenity/tree/master/Ports +# +# As of 2021/08/20, SERENITY_ARCH is defined in the SerenityOS Ports +# build script to always be either "i686" or "x86_64" + +MRuby::CrossBuild.new('serenity') do |conf| + conf.toolchain :gcc + + conf.archiver.command = "#{ENV['SERENITY_ARCH']}-pc-serenity-ar" + conf.linker.command = "#{ENV['SERENITY_ARCH']}-pc-serenity-g++" + + conf.cxx.command = "#{ENV['SERENITY_ARCH']}-pc-serenity-g++" + conf.cxx.defines << (ENV['SERENITY_ARCH'].include?('64') ? 'MRB_64BIT' : 'MRB_32BIT') + + conf.cc.command = "#{ENV['SERENITY_ARCH']}-pc-serenity-gcc" + conf.cc.defines << (ENV['SERENITY_ARCH'].include?('64') ? 'MRB_64BIT' : 'MRB_32BIT') + + conf.gembox 'full-core' + + conf.test_runner.command = 'env' +end diff --git a/codespell.txt b/codespell.txt new file mode 100644 index 000000000..dcc0ddb43 --- /dev/null +++ b/codespell.txt @@ -0,0 +1,17 @@ +ans +ba +creat +delet +disabl +filetest +fo +hel +hist +ist +methid +nd +quitt +remore +runn +sting +upto diff --git a/doc/guides/compile.md b/doc/guides/compile.md index 7156b2b68..2923a2676 100644 --- a/doc/guides/compile.md +++ b/doc/guides/compile.md @@ -138,18 +138,18 @@ C Compiler has header searcher to detect installed library. If you need an include path of header file use `search_header_path`: ```ruby -# Searches ```iconv.h```. +# Searches `iconv.h`. # If found it will return include path of the header file. -# Otherwise it will return nil . +# Otherwise it will return nil. fail 'iconv.h not found' unless conf.cc.search_header_path 'iconv.h' ``` If you need a full file name of header file use `search_header`: ```ruby -# Searches ```iconv.h```. +# Searches `iconv.h`. # If found it will return full path of the header file. -# Otherwise it will return nil . +# Otherwise it will return nil. iconv_h = conf.cc.search_header 'iconv.h' print "iconv.h found: #{iconv_h}\n" ``` @@ -333,9 +333,9 @@ conf.enable_debug When debugging mode is enabled * Macro `MRB_DEBUG` would be defined. - * Which means `mrb_assert()` macro is enabled. + * Which means `mrb_assert()` macro is enabled. * Debug information of irep would be generated by `mrbc`. - * Because `-g` flag would be added to `mrbc` runner. + * Because `-g` flag would be added to `mrbc` runner. * You can have better backtrace of mruby scripts with this. ## Cross-Compilation @@ -379,23 +379,25 @@ end During the build process the directory `build` will be created in the root directory. The structure of this directory will look like this: - +- build - | - +- host - | - +- LEGAL <- License description - | - +- bin <- Binaries (mirb, mrbc and mruby) - | - +- lib <- Libraries (libmruby.a and libmruby_core.a) - | - +- mrbc <- Minimal mrbc place - | - +- mrbgems <- Compilation result from mrbgems - | - +- mrblib <- Compilation result from mrblib - | - +- src <- Compilation result from C sources +``` ++- build + | + +- host + | + +- LEGAL <- License description + | + +- bin <- Binaries (mirb, mrbc and mruby) + | + +- lib <- Libraries (libmruby.a and libmruby_core.a) + | + +- mrbc <- Minimal mrbc place + | + +- mrbgems <- Compilation result from mrbgems + | + +- mrblib <- Compilation result from mrblib + | + +- src <- Compilation result from C sources +``` The compilation workflow will look like this: @@ -425,31 +427,33 @@ The compilation workflow will look like this: In case of a cross-compilation to `i386` the `build` directory structure looks like this: - +- build - | - +- host - | | - | +- bin <- Native Binaries - | | - | +- lib <- Native Libraries - | | - | +- mrbgems - | | - | +- src - | - +- i386 - | - +- bin <- Cross-compiled Binaries - | - +- include <- Header Directory - | - +- lib <- Cross-compiled Libraries - | - +- mrbgems - | - +- mrblib - | - +- src +``` ++- build + | + +- host + | | + | +- bin <- Native Binaries + | | + | +- lib <- Native Libraries + | | + | +- mrbgems + | | + | +- src + | + +- i386 + | + +- bin <- Cross-compiled Binaries + | + +- include <- Header Directory + | + +- lib <- Cross-compiled Libraries + | + +- mrbgems + | + +- mrblib + | + +- src +``` An extra directory is created for the target platform. In case you compile for `i386` a directory called `i386` is created under the diff --git a/doc/guides/mrbconf.md b/doc/guides/mrbconf.md index b5bc8c85c..e71346ae6 100644 --- a/doc/guides/mrbconf.md +++ b/doc/guides/mrbconf.md @@ -151,17 +151,18 @@ largest value of required alignment. ## Reduce heap memory configuration -`MRB_USE_LINK_TIME_RO_DATA_P` +`MRB_USE_ETEXT_RO_DATA_P` -* Only available on ELF platforms. -* If you specify the address of a read-only section when creating a symbol or string, that string will be used as it is. -* Heap memory can be saved. -* Uses `__ehdr_start` and `__init_array_start`. -* It must be `__ehdr_start < data_addr < __init_array_start`. +* Use `etext` and `edata` section addresses defined by the linker to detect read-only data. +* Those addresses are widely available, but not portable, nor standardized. +* This macro is defined by default on User-mode Linux. + +`MRB_NO_DEFAULT_RO_DATA_P` + +* Define this macro when the default `mrb_ro_data_p()` does not work for any reason. `MRB_USE_CUSTOM_RO_DATA_P` -* Takes precedence over `MRB_USE_LINK_TIME_RO_DATA_P`. * Please try if `MRB_USE_LINK_TIME_RO_DATA_P` is not available. * The `mrb_ro_data_p()` function is implemented by the user in an arbitrary file. * The prototype declaration is `mrb_bool mrb_ro_data_p(const char *ptr)`. diff --git a/doc/guides/mrbgems.md b/doc/guides/mrbgems.md index d4160ebc8..c08a09f4e 100644 --- a/doc/guides/mrbgems.md +++ b/doc/guides/mrbgems.md @@ -55,8 +55,8 @@ conf.gem mgem: 'mruby-redis', checksum_hash: '3446d19fc4a3f9697b5ddbf2a904f301c4 If there are missing dependencies, mrbgem dependencies solver will reference mrbgem from the core or mgem-list. -To pull all gems from remote GIT repository on build, call ```rake -p```, -or ```rake --pull-gems```. +To pull all gems from remote GIT repository on build, call `rake -p`, +or `rake --pull-gems`. NOTE: `:bitbucket` option supports only git. Hg is unsupported in this version. @@ -111,21 +111,21 @@ contains every gem found in the `mrbgems` directory. The maximal GEM structure looks like this: ``` -+- GEM_NAME <- Name of GEM - | - +- README.md <- Readme for GEM - | - +- mrbgem.rake <- GEM Specification - | - +- include/ <- Header for Ruby extension (will exported) - | - +- mrblib/ <- Source for Ruby extension - | - +- src/ <- Source for C extension - | - +- tools/ <- Source for Executable (in C) - | - +- test/ <- Test code (Ruby) ++- GEM_NAME <- Name of GEM + | + +- README.md <- Readme for GEM + | + +- mrbgem.rake <- GEM Specification + | + +- include/ <- Header for Ruby extension (will exported) + | + +- mrblib/ <- Source for Ruby extension + | + +- src/ <- Source for C extension + | + +- tools/ <- Source for Executable (in C) + | + +- test/ <- Test code (Ruby) ``` The folder `mrblib` contains pure Ruby files to extend mruby. The folder `src` @@ -200,8 +200,8 @@ Version requirement supports following operators: * '>=': is equal or greater * '<=': is equal or lesser * '~>': is equal or greater and is lesser than the next major version - * example 1: '~> 2.2.2' means '>= 2.2.2' and '< 2.3.0' - * example 2: '~> 2.2' means '>= 2.2.0' and '< 3.0.0' + * example 1: '~> 2.2.2' means '>= 2.2.2' and '< 2.3.0' + * example 2: '~> 2.2' means '>= 2.2.0' and '< 3.0.0' When more than one version requirements is passed, the dependency must satisfy all of it. @@ -215,7 +215,7 @@ use `MRuby::Build#gem` in the build configuration to override default gem. If you have conflicting GEMs use the following method: * `spec.add_conflict(gem, *requirements)` - * The `requirements` argument is same as in `add_dependency` method. + * The `requirements` argument is same as in `add_dependency` method. like following code: @@ -273,7 +273,7 @@ mrbgems expects that you have implemented a C method called by the name of your GEM. If you call your GEM `c_extension_example`, your initialisation method could look like this: -```C +```c void mrb_c_extension_example_gem_init(mrb_state* mrb) { struct RClass *class_cextension = mrb_define_module(mrb, "CExtension"); @@ -288,7 +288,7 @@ mrbgems expects that you have implemented a C method called by the name of your GEM. If you call your GEM `c_extension_example`, your finalizer method could look like this: -```C +```c void mrb_c_extension_example_gem_final(mrb_state* mrb) { free(someone); @@ -297,19 +297,21 @@ mrb_c_extension_example_gem_final(mrb_state* mrb) { ### Example - +- c_extension_example/ - | - +- README.md (Optional) - | - +- src/ - | | - | +- example.c <- C extension source - | - +- test/ - | | - | +- example.rb <- Test code for C extension - | - +- mrbgem.rake <- GEM specification +``` ++- c_extension_example/ + | + +- README.md (Optional) + | + +- src/ + | | + | +- example.c <- C extension source + | + +- test/ + | | + | +- example.rb <- Test code for C extension + | + +- mrbgem.rake <- GEM specification +``` ## Ruby Extension @@ -323,19 +325,21 @@ none ### Example - +- ruby_extension_example/ - | - +- README.md (Optional) - | - +- mrblib/ - | | - | +- example.rb <- Ruby extension source - | - +- test/ - | | - | +- example.rb <- Test code for Ruby extension - | - +- mrbgem.rake <- GEM specification +``` ++- ruby_extension_example/ + | + +- README.md (Optional) + | + +- mrblib/ + | | + | +- example.rb <- Ruby extension source + | + +- test/ + | | + | +- example.rb <- Test code for Ruby extension + | + +- mrbgem.rake <- GEM specification +``` ## C and Ruby Extension @@ -353,23 +357,25 @@ See C and Ruby example. ### Example - +- c_and_ruby_extension_example/ - | - +- README.md (Optional) - | - +- mrblib/ - | | - | +- example.rb <- Ruby extension source - | - +- src/ - | | - | +- example.c <- C extension source - | - +- test/ - | | - | +- example.rb <- Test code for C and Ruby extension - | - +- mrbgem.rake <- GEM specification +``` ++- c_and_ruby_extension_example/ + | + +- README.md (Optional) + | + +- mrblib/ + | | + | +- example.rb <- Ruby extension source + | + +- src/ + | | + | +- example.c <- C extension source + | + +- test/ + | | + | +- example.rb <- Test code for C and Ruby extension + | + +- mrbgem.rake <- GEM specification +``` ## Binary gems @@ -389,23 +395,23 @@ binary gems, to separate normal gems and binary gems. ### Example ``` - +- mruby-bin-example/ ++- mruby-bin-example/ | - +- README.md (Optional) + +- README.md (Optional) | +- bintest/ - | | - | +- example.rb <- Test code for binary gem + | | + | +- example.rb <- Test code for binary gem | - +- mrbgem.rake <- Gem specification + +- mrbgem.rake <- Gem specification | - +- mrblib/ <- Source for Ruby extension (Optional) + +- mrblib/ <- Source for Ruby extension (Optional) | - +- src/ <- Source for C extension (Optional) + +- src/ <- Source for C extension (Optional) | +- tools/ - | - +- example/ <- Executable name directory - | - +- example.c <- Source for Executable (includes main) + | + +- example/ <- Executable name directory + | + +- example.c <- Source for Executable (includes main) ``` diff --git a/doc/guides/symbol.md b/doc/guides/symbol.md index e9e72a6d3..8f90ce59f 100644 --- a/doc/guides/symbol.md +++ b/doc/guides/symbol.md @@ -4,7 +4,7 @@ Symbols in `mruby` C source code is represented by `mrb_sym` which is alias of `uint32_t`. Lower 30 bits are used for symbols so that higher 2 bits can be used as flags, e.g. `struct mt_elem` in `class.c`. -```C +```c struct mt_elem { union mt_ptr ptr; size_t func_p:1; @@ -57,13 +57,13 @@ To save RAM, `mruby` can use compile-time allocation of some symbols. You can use following macros to get preallocated symbols by including `mruby/presym.h` header. - * `MRB_SYM(xor)` //=> xor (Word characters) - * `MRB_SYM_B(xor)` //=> xor! (Method with Bang) - * `MRB_SYM_Q(xor)` //=> xor? (Method with Question mark) - * `MRB_SYM_E(xor)` //=> xor= (Method with Equal) - * `MRB_CVSYM(xor)` //=> @@xor (Class Variable) - * `MRB_IVSYM(xor)` //=> @xor (Instance Variable) - * `MRB_OPSYM(xor)` //=> ^ (Operator) +* `MRB_SYM(xor)` //=> xor (Word characters) +* `MRB_SYM_B(xor)` //=> xor! (Method with Bang) +* `MRB_SYM_Q(xor)` //=> xor? (Method with Question mark) +* `MRB_SYM_E(xor)` //=> xor= (Method with Equal) +* `MRB_CVSYM(xor)` //=> @@xor (Class Variable) +* `MRB_IVSYM(xor)` //=> @xor (Instance Variable) +* `MRB_OPSYM(xor)` //=> ^ (Operator) For `MRB_OPSYM()`, specify the names corresponding to operators (see `MRuby::Presym::OPERATORS` in `lib/mruby/presym.rb` for the names that diff --git a/doc/limitations.md b/doc/limitations.md index d903d528c..265e4a2d4 100644 --- a/doc/limitations.md +++ b/doc/limitations.md @@ -13,28 +13,6 @@ This document is collecting these limitations. This document does not contain a complete list of limitations. Please help to improve it by submitting your findings. -## `Array` passed to `puts` - -Passing an Array to `puts` results in different output. - -```ruby -puts [1,2,3] -``` - -#### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)] - -``` -1 -2 -3 -``` - -#### mruby [3.0.0 (2021-03-05)] - -``` -[1, 2, 3] -``` - ## `Kernel.raise` in rescue clause `Kernel.raise` without arguments does not raise the current exception within @@ -54,7 +32,7 @@ end #### mruby [3.0.0 (2021-03-05)] -No exception is raised. Instead, you have to do: +`RuntimeError` is raised instead of `ZeroDivisionError`. To re-raise the exception, you have to do: ```ruby begin @@ -77,7 +55,7 @@ To reduce memory consumption `Array` does not support instance variables. ```ruby class Liste < Array def initialize(str = nil) - @feld = str + @field = str end end diff --git a/doc/mruby3.md b/doc/mruby3.md index d5218428e..a64e3c73e 100644 --- a/doc/mruby3.md +++ b/doc/mruby3.md @@ -1,5 +1,4 @@ -User visible changes in `mruby3` -=== +# User visible changes in `mruby3` # Build System @@ -77,8 +76,9 @@ to be default `mrb_value` representation. Now the default is 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. +platforms. Inlined integer size is 31 bits, so some `mrb_int` +values does not fit in `mrb_value`. Those integers are allocated +in the object heap as `struct RInteger`. ## `MRB_NAN_BOXING` @@ -111,14 +111,9 @@ $ bin/mruby -r lib1.rb -r lib2.rb < app.mrb `mruby3` introduces a few new instructions. -Instructions that access pool[i]/syms[i] where i>255. - -* `OP_LOADL16` -* `OP_STRING16` -* `OP_LOADSYM16` - -Instructions that load a 32-bit integer. +Instructions that load a 16/32-bit integer. +* `OP_LOADI16` * `OP_LOADI32` Instruction that unwinds jump table for rescue/ensure. diff --git a/doc/opcode.md b/doc/opcode.md index 3ad09919c..953e9aeae 100644 --- a/doc/opcode.md +++ b/doc/opcode.md @@ -22,114 +22,110 @@ sign) of operands. ## table.1 Instruction Table -| Instruction Name | Operand type | Semantics | -|------------------|--------------|--------------------------------------------------------| -| OP_NOP | - | no operation | -| OP_MOVE | BB | R(a) = R(b) | -| OP_LOADL | BB | R(a) = Pool(b) | -| OP_LOADL16 | BS | R(a) = Pool(b) | -| OP_LOADI | BB | R(a) = mrb_int(b) | -| OP_LOADINEG | BB | R(a) = mrb_int(-b) | -| OP_LOADI__1 | B | R(a) = mrb_int(-1) | -| OP_LOADI_0 | B | R(a) = mrb_int(0) | -| OP_LOADI_1 | B | R(a) = mrb_int(1) | -| OP_LOADI_2 | B | R(a) = mrb_int(2) | -| OP_LOADI_3 | B | R(a) = mrb_int(3) | -| OP_LOADI_4 | B | R(a) = mrb_int(4) | -| OP_LOADI_5 | B | R(a) = mrb_int(5) | -| OP_LOADI_6 | B | R(a) = mrb_int(6) | -| OP_LOADI_7 | B | R(a) = mrb_int(7) | -| OP_LOADI16 | BS | R(a) = mrb_int(b) | -| OP_LOADI32 | BSS | R(a) = mrb_int((b<<16)+c) | -| OP_LOADSYM | BB | R(a) = Syms(b) | -| OP_LOADSYM16 | BS | R(a) = Syms(b) | -| OP_LOADNIL | B | R(a) = nil | -| OP_LOADSELF | B | R(a) = self | -| OP_LOADT | B | R(a) = true | -| OP_LOADF | B | R(a) = false | -| OP_GETGV | BB | R(a) = getglobal(Syms(b)) | -| OP_SETGV | BB | setglobal(Syms(b), R(a)) | -| OP_GETSV | BB | R(a) = Special[Syms(b)] | -| OP_SETSV | BB | Special[Syms(b)] = R(a) | -| OP_GETIV | BB | R(a) = ivget(Syms(b)) | -| OP_SETIV | BB | ivset(Syms(b),R(a)) | -| OP_GETCV | BB | R(a) = cvget(Syms(b)) | -| OP_SETCV | BB | cvset(Syms(b),R(a)) | -| OP_GETCONST | BB | R(a) = constget(Syms(b)) | -| OP_SETCONST | BB | constset(Syms(b),R(a)) | -| OP_GETMCNST | BB | R(a) = R(a)::Syms(b) | -| OP_SETMCNST | BB | R(a+1)::Syms(b) = R(a) | -| OP_GETUPVAR | BBB | R(a) = uvget(b,c) | -| OP_SETUPVAR | BBB | uvset(b,c,R(a)) | -| OP_JMP | S | pc+=a | -| OP_JMPIF | BS | if R(a) pc+=b | -| OP_JMPNOT | BS | if !R(a) pc+=b | -| OP_JMPNIL | BS | if R(a)==nil pc+=b | -| OP_JMPUW | S | unwind_and_jump_to(a) | -| OP_EXCEPT | B | R(a) = exc | -| OP_RESCUE | BB | R(b) = R(a).isa?(R(b)) | -| OP_RAISEIF | B | raise(R(a)) if R(a) | -| OP_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_SENDVK | BB | R(a) = call(R(a),Syms(b),*R(a+1),**(a+2),&R(a+3)) | -| 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_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_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_STRING16 | BS | 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*2-1)) | -| OP_HASHADD | BB | R(a) = hash_push(R(a),R(a+1)..R(a+b*2)) | -| OP_HASHCAT | B | R(a) = hash_cat(R(a),R(a+1)) | -| OP_LAMBDA | BB | R(a) = lambda(SEQ[b],OP_L_LAMBDA) | -| OP_LAMBDA16 | BS | R(a) = lambda(SEQ[b],OP_L_LAMBDA) | -| OP_BLOCK | BB | R(a) = lambda(SEQ[b],OP_L_BLOCK) | -| OP_BLOCK16 | BS | R(a) = lambda(SEQ[b],OP_L_BLOCK) | -| OP_METHOD | BB | R(a) = lambda(SEQ[b],OP_L_METHOD) | -| OP_METHOD16 | BS | 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_EXEC16 | BS | 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 | -|------------------|--------------|--------------------------------------------------------| +| Instruction Name | Operand type | Semantics | +|------------------|--------------|----------------------------------------------------------| +| `OP_NOP` | `-` | `no operation` | +| `OP_MOVE` | `BB` | `R(a) = R(b)` | +| `OP_LOADL` | `BB` | `R(a) = Pool(b)` | +| `OP_LOADI` | `BB` | `R(a) = mrb_int(b)` | +| `OP_LOADINEG` | `BB` | `R(a) = mrb_int(-b)` | +| `OP_LOADI__1` | `B` | `R(a) = mrb_int(-1)` | +| `OP_LOADI_0` | `B` | `R(a) = mrb_int(0)` | +| `OP_LOADI_1` | `B` | `R(a) = mrb_int(1)` | +| `OP_LOADI_2` | `B` | `R(a) = mrb_int(2)` | +| `OP_LOADI_3` | `B` | `R(a) = mrb_int(3)` | +| `OP_LOADI_4` | `B` | `R(a) = mrb_int(4)` | +| `OP_LOADI_5` | `B` | `R(a) = mrb_int(5)` | +| `OP_LOADI_6` | `B` | `R(a) = mrb_int(6)` | +| `OP_LOADI_7` | `B` | `R(a) = mrb_int(7)` | +| `OP_LOADI16` | `BS` | `R(a) = mrb_int(b)` | +| `OP_LOADI32` | `BSS` | `R(a) = mrb_int((b<<16)+c)` | +| `OP_LOADSYM` | `BB` | `R(a) = Syms(b)` | +| `OP_LOADNIL` | `B` | `R(a) = nil` | +| `OP_LOADSELF` | `B` | `R(a) = self` | +| `OP_LOADT` | `B` | `R(a) = true` | +| `OP_LOADF` | `B` | `R(a) = false` | +| `OP_GETGV` | `BB` | `R(a) = getglobal(Syms(b))` | +| `OP_SETGV` | `BB` | `setglobal(Syms(b), R(a))` | +| `OP_GETSV` | `BB` | `R(a) = Special[Syms(b)]` | +| `OP_SETSV` | `BB` | `Special[Syms(b)] = R(a)` | +| `OP_GETIV` | `BB` | `R(a) = ivget(Syms(b))` | +| `OP_SETIV` | `BB` | `ivset(Syms(b),R(a))` | +| `OP_GETCV` | `BB` | `R(a) = cvget(Syms(b))` | +| `OP_SETCV` | `BB` | `cvset(Syms(b),R(a))` | +| `OP_GETCONST` | `BB` | `R(a) = constget(Syms(b))` | +| `OP_SETCONST` | `BB` | `constset(Syms(b),R(a))` | +| `OP_GETMCNST` | `BB` | `R(a) = R(a)::Syms(b)` | +| `OP_SETMCNST` | `BB` | `R(a+1)::Syms(b) = R(a)` | +| `OP_GETUPVAR` | `BBB` | `R(a) = uvget(b,c)` | +| `OP_SETUPVAR` | `BBB` | `uvset(b,c,R(a))` | +| `OP_JMP` | `S` | `pc+=a` | +| `OP_JMPIF` | `BS` | `if R(a) pc+=b` | +| `OP_JMPNOT` | `BS` | `if !R(a) pc+=b` | +| `OP_JMPNIL` | `BS` | `if R(a)==nil pc+=b` | +| `OP_JMPUW` | `S` | `unwind_and_jump_to(a)` | +| `OP_EXCEPT` | `B` | `R(a) = exc` | +| `OP_RESCUE` | `BB` | `R(b) = R(a).isa?(R(b))` | +| `OP_RAISEIF` | `B` | `raise(R(a)) if R(a)` | +| `OP_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_SENDVK` | `BB` | `R(a) = call(R(a),Syms(b),*R(a+1),**(a+2),&R(a+3))` | +| `OP_CALL` | `-` | `R(0) = self.call(frame.argc, frame.argv)` | +| `OP_SUPER` | `BB` | `R(a) = super(R(a+1),... ,R(a+b+1))` | +| `OP_ARGARY` | `BS` | `R(a) = argument array (16=m5:r1:m5:d1:lv4)` | +| `OP_ENTER` | `W` | `arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1)` | +| `OP_KEY_P` | `BB` | `R(a) = kdict.key?(Syms(b))` | +| `OP_KEYEND` | `-` | `raise unless kdict.empty?` | +| `OP_KARG` | `BB` | `R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))` | +| `OP_RETURN` | `B` | `return R(a) (normal)` | +| `OP_RETURN_BLK` | `B` | `return R(a) (in-block return)` | +| `OP_BREAK` | `B` | `break R(a)` | +| `OP_BLKPUSH` | `BS` | `R(a) = block (16=m5:r1:m5:d1:lv4)` | +| `OP_ADD` | `B` | `R(a) = R(a)+R(a+1)` | +| `OP_ADDI` | `BB` | `R(a) = R(a)+mrb_int(b)` | +| `OP_SUB` | `B` | `R(a) = R(a)-R(a+1)` | +| `OP_SUBI` | `BB` | `R(a) = R(a)-mrb_int(b)` | +| `OP_MUL` | `B` | `R(a) = R(a)*R(a+1)` | +| `OP_DIV` | `B` | `R(a) = R(a)/R(a+1)` | +| `OP_EQ` | `B` | `R(a) = R(a)==R(a+1)` | +| `OP_LT` | `B` | `R(a) = R(a)<R(a+1)` | +| `OP_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` | `BB` | `ary_push(R(a),R(a+1)..R(a+b))` | +| `OP_ARYDUP` | `B` | `R(a) = ary_dup(R(a))` | +| `OP_AREF` | `BBB` | `R(a) = R(b)[c]` | +| `OP_ASET` | `BBB` | `R(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(Pool(b))` | +| `OP_STRCAT` | `B` | `str_cat(R(a),R(a+1))` | +| `OP_HASH` | `BB` | `R(a) = hash_new(R(a),R(a+1)..R(a+b*2-1))` | +| `OP_HASHADD` | `BB` | `hash_push(R(a),R(a+1)..R(a+b*2))` | +| `OP_HASHCAT` | `B` | `R(a) = hash_cat(R(a),R(a+1))` | +| `OP_LAMBDA` | `BB` | `R(a) = lambda(Irep(b),OP_L_LAMBDA)` | +| `OP_BLOCK` | `BB` | `R(a) = lambda(Irep(b),OP_L_BLOCK)` | +| `OP_METHOD` | `BB` | `R(a) = lambda(Irep(b),OP_L_METHOD)` | +| `OP_RANGE_INC` | `B` | `R(a) = range_new(R(a),R(a+1),FALSE)` | +| `OP_RANGE_EXC` | `B` | `R(a) = range_new(R(a),R(a+1),TRUE)` | +| `OP_OCLASS` | `B` | `R(a) = ::Object` | +| `OP_CLASS` | `BB` | `R(a) = newclass(R(a),Syms(b),R(a+1))` | +| `OP_MODULE` | `BB` | `R(a) = newmodule(R(a),Syms(b))` | +| `OP_EXEC` | `BB` | `R(a) = blockexec(R(a),Irep[b])` | +| `OP_DEF` | `BB` | `R(a).newmethod(Syms(b),R(a+1)); R(a) = Syms(b)` | +| `OP_ALIAS` | `BB` | `alias_method(target_class,Syms(a),Syms(b))` | +| `OP_UNDEF` | `B` | `undef_method(target_class,Syms(a))` | +| `OP_SCLASS` | `B` | `R(a) = R(a).singleton_class` | +| `OP_TCLASS` | `B` | `R(a) = target_class` | +| `OP_DEBUG` | `BBB` | `print a,b,c` | +| `OP_ERR` | `B` | `raise(LocalJumpError, Pool(a))` | +| `OP_EXT1` | `-` | `make 1st operand 16bit` | +| `OP_EXT2` | `-` | `make 2nd operand 16bit` | +| `OP_EXT3` | `-` | `make 1st and 2nd operands 16bit` | +| `OP_STOP` | `-` | `stop VM` | +|------------------|--------------|----------------------------------------------------------| diff --git a/examples/mrbgems/c_and_ruby_extension_example/src/example.c b/examples/mrbgems/c_and_ruby_extension_example/src/example.c index 1fdb1078d..f1d7971c2 100644 --- a/examples/mrbgems/c_and_ruby_extension_example/src/example.c +++ b/examples/mrbgems/c_and_ruby_extension_example/src/example.c @@ -5,9 +5,8 @@ static mrb_value mrb_c_method(mrb_state *mrb, mrb_value self) { - mrb_value self_str = mrb_str_to_str(mrb, self); - - printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self_str)); + mrb_ensure_string_type(mrb, self); + printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self)); return self; } diff --git a/examples/mrbgems/c_extension_example/src/example.c b/examples/mrbgems/c_extension_example/src/example.c index 727c7c698..fe872c933 100644 --- a/examples/mrbgems/c_extension_example/src/example.c +++ b/examples/mrbgems/c_extension_example/src/example.c @@ -5,9 +5,8 @@ static mrb_value mrb_c_method(mrb_state *mrb, mrb_value self) { - mrb_value self_str = mrb_str_to_str(mrb, self); - - printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self_str)); + mrb_ensure_string_type(mrb, self); + printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self)); return self; } diff --git a/include/mrbconf.h b/include/mrbconf.h index d4da81bfc..e11a55e8c 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -7,9 +7,6 @@ #ifndef MRUBYCONF_H #define MRUBYCONF_H -#include <limits.h> -#include <stdint.h> - /* architecture selection: */ /* specify -DMRB_32BIT or -DMRB_64BIT to override */ #if !defined(MRB_32BIT) && !defined(MRB_64BIT) @@ -82,6 +79,9 @@ # define MRB_WORD_BOXING #endif +/* if defined mruby allocates Float objects in the heap to keep full precision if needed */ +//#define MRB_WORDBOX_NO_FLOAT_TRUNCATE + /* add -DMRB_INT32 to use 32bit integer for mrb_int; conflict with MRB_INT64; Default for 32-bit CPU mode. */ //#define MRB_INT32 @@ -113,11 +113,17 @@ /* number of object per heap page */ //#define MRB_HEAP_PAGE_SIZE 1024 -/* if __ehdr_start is available, mruby can reduce memory used by symbols */ -//#define MRB_USE_LINK_TIME_RO_DATA_P +/* define if your platform does not support etext, edata */ +//#define MRB_NO_DEFAULT_RO_DATA_P + +/* define if your platform supports etext, edata */ +//#define MRB_USE_RO_DATA_P_ETEXT +/* use MRB_USE_ETEXT_RO_DATA_P by default on Linux */ +#if (defined(__linux__) && !defined(__KERNEL__)) +#define MRB_USE_ETEXT_RO_DATA_P +#endif -/* if MRB_USE_LINK_TIME_RO_DATA_P does not work, - you can try mrb_ro_data_p() that you have implemented yourself in any file; +/* you can provide and use mrb_ro_data_p() for your platform. prototype is `mrb_bool mrb_ro_data_p(const char *ptr)` */ //#define MRB_USE_CUSTOM_RO_DATA_P @@ -181,14 +187,6 @@ # include <stdio.h> #endif -#ifndef FALSE -# define FALSE 0 -#endif - -#ifndef TRUE -# define TRUE 1 -#endif - /* ** mruby tuning profiles **/ diff --git a/include/mruby.h b/include/mruby.h index d421dc58c..d82cff581 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -44,6 +44,9 @@ #include <limits.h> #ifdef __cplusplus +#ifndef UINTPTR_MAX +#error Must be placed `#include <mruby.h>` before `#include <stdint.h>` +#endif #ifndef SIZE_MAX #ifdef __SIZE_MAX__ #define SIZE_MAX __SIZE_MAX__ @@ -96,6 +99,7 @@ #include <mruby/version.h> #ifndef MRB_NO_FLOAT +#include <math.h> #include <float.h> #ifndef FLT_EPSILON #define FLT_EPSILON (1.19209290e-07f) @@ -150,8 +154,8 @@ typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud); typedef struct { mrb_sym mid; + uint8_t cci; /* called from C function */ int16_t argc; - int16_t acc; const struct RProc *proc; mrb_value *stack; const mrb_code *pc; /* current address on iseq of this proc */ @@ -265,7 +269,9 @@ typedef struct mrb_state { #endif mrb_sym symidx; - struct symbol_name *symtbl; /* symbol table */ + const char **symtbl; + uint8_t *symlink; + uint8_t *symflags; mrb_sym symhash[256]; size_t symcapa; #ifndef MRB_USE_ALL_SYMBOLS @@ -886,19 +892,20 @@ MRB_API struct RClass* mrb_define_module_under_id(mrb_state *mrb, struct RClass * | char | Ruby type | C types | Notes | * |:----:|----------------|-------------------|----------------------------------------------------| * | `o` | {Object} | {mrb_value} | Could be used to retrieve any type of argument | - * | `C` | {Class}/{Module} | {mrb_value} | | + * | `C` | {Class}/{Module} | {mrb_value} | when `!` follows, the value may be `nil` | * | `S` | {String} | {mrb_value} | when `!` follows, the value may be `nil` | * | `A` | {Array} | {mrb_value} | when `!` follows, the value may be `nil` | * | `H` | {Hash} | {mrb_value} | when `!` follows, the value may be `nil` | * | `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} | const {mrb_value} *, {mrb_int} | Receive two arguments; `a!` gives (`NULL`,`0`) for `nil` | + * | `c` | {Class}/{Module} | strcut RClass * | `c!` gives `NULL` for `nil` | * | `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` | - * | `I` | inline struct | void * | | + * | `I` | inline struct | void *, struct RClass | `I!` gives `NULL` for `nil` | * | `&` | block | {mrb_value} | &! raises exception if no block given. | * | `*` | rest arguments | const {mrb_value} *, {mrb_int} | Receive the rest of arguments as an array; `*!` avoid copy of the stack. | * | <code>\|</code> | optional | | After this spec following specs would be optional. | @@ -906,6 +913,13 @@ MRB_API struct RClass* mrb_define_module_under_id(mrb_state *mrb, struct RClass * | `:` | keyword args | {mrb_kwargs} const | Get keyword arguments. @see mrb_kwargs | * * @see mrb_get_args + * + * Immediately after format specifiers it can add format modifiers: + * + * | char | Notes | + * |:----:|-----------------------------------------------------------------------------------------| + * | `!` | Switch to the alternate mode; The behaviour changes depending on the format specifier | + * | `+` | Request a not frozen object; However, except nil value | */ typedef const char *mrb_args_format; @@ -1004,6 +1018,11 @@ MRB_API const mrb_value *mrb_get_argv(mrb_state *mrb); */ MRB_API mrb_value mrb_get_arg1(mrb_state *mrb); +/** + * Check if a block argument is given from mrb_state. + */ +MRB_API mrb_bool mrb_block_given_p(mrb_state *mrb); + /* `strlen` for character string literals (use with caution or `strlen` instead) Adjacent string literals are concatenated in C/C++ in translation phase 6. If `lit` is not one, the compiler will report a syntax error: @@ -1126,6 +1145,17 @@ MRB_API void *mrb_malloc_simple(mrb_state*, size_t); /* return NULL if no memor MRB_API struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*); MRB_API void mrb_free(mrb_state*, void*); +/** + * Allocates a Ruby object that matches the constant literal defined in + * `enum mrb_vtype` and returns a pointer to the corresponding C type. + * + * @param mrb The current mruby state + * @param tt The constant literal of `enum mrb_vtype` + * @param klass A Class object + * @return Reference to the newly created object + */ +#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass)) + MRB_API mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len); /** @@ -1219,10 +1249,8 @@ MRB_API mrb_sym mrb_obj_to_sym(mrb_state *mrb, mrb_value name); MRB_API mrb_bool mrb_obj_eq(mrb_state *mrb, mrb_value a, mrb_value b); 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_NO_FLOAT -MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val); +MRB_API mrb_value mrb_to_float(mrb_state *mrb, mrb_value val); #endif MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj); MRB_API mrb_bool mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2); @@ -1339,10 +1367,23 @@ MRB_API void mrb_gc_register(mrb_state *mrb, mrb_value obj); /* mrb_gc_unregister() removes the object from GC root. */ 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_integer(mrb_to_int(mrb, val)) +/* type conversion/check functions */ +MRB_API mrb_value mrb_ensure_array_type(mrb_state *mrb, mrb_value self); +MRB_API mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self); +MRB_API mrb_value mrb_ensure_hash_type(mrb_state *mrb, mrb_value hash); +MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash); +MRB_API mrb_value mrb_ensure_string_type(mrb_state *mrb, mrb_value str); +MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str); +/* obsolete: use mrb_ensure_string_type() instead */ +#define mrb_string_type(mrb, str) mrb_ensure_string_type(mrb,str) +#define mrb_to_str(mrb, str) mrb_ensure_string_type(mrb,str) +/* obsolete: use mrb_obj_as_string() instead */ +#define mrb_str_to_str(mrb, str) mrb_obj_as_string(mrb, str) +MRB_API mrb_value mrb_to_integer(mrb_state *mrb, mrb_value val); +#define mrb_to_int(mrb, val) mrb_to_integer(mrb, val) +#define mrb_as_int(mrb, val) mrb_integer(mrb_to_integer(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); MRB_INLINE void mrb_check_frozen(mrb_state *mrb, void *o) @@ -1361,6 +1402,8 @@ MRB_API mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid); MRB_API mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c); MRB_API mrb_bool mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func); +/* obsolete function(s); will be removed */ +#define mrb_int(mrb, val) mrb_as_int(mrb, val) /** * Resume a Fiber diff --git a/include/mruby/array.h b/include/mruby/array.h index 16f78f773..8bb652472 100644 --- a/include/mruby/array.h +++ b/include/mruby/array.h @@ -14,15 +14,17 @@ */ MRB_BEGIN_DECL - typedef struct mrb_shared_array { int refcnt; mrb_ssize len; mrb_value *ptr; } mrb_shared_array; -#if defined(MRB_32BIT) && defined(MRB_NO_BOXING) && !defined(MRB_USE_FLOAT32) +#if defined(MRB_32BIT) && defined(MRB_NO_BOXING) && !defined(MRB_USE_FLOAT32) && !defined(MRB_ARY_NO_EMBED) # define MRB_ARY_NO_EMBED +#endif + +#ifdef 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))) @@ -177,20 +179,6 @@ MRB_API void mrb_ary_push(mrb_state *mrb, mrb_value array, mrb_value value); MRB_API mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary); /* - * Returns a reference to an element of the array on the given index. - * - * Equivalent to: - * - * ary[n] - * - * @param mrb The mruby state reference. - * @param ary The target array. - * @param n The array index being referenced - * @return The referenced value. - */ -MRB_API mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n); - -/* * Sets a value on an array at the given index * * Equivalent to: @@ -200,7 +188,7 @@ MRB_API mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n); * @param mrb The mruby state reference. * @param ary The target array. * @param n The array index being referenced. - * @param val The value being setted. + * @param val The value being set. */ MRB_API void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val); @@ -216,8 +204,6 @@ MRB_API void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val * @param other The array to replace it with. */ MRB_API void mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other); -MRB_API mrb_value mrb_ensure_array_type(mrb_state *mrb, mrb_value self); -MRB_API mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self); /* * Unshift an element into the array @@ -243,6 +229,7 @@ MRB_API mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item * @param offset The element position (negative counts from the tail). */ MRB_API mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset); +#define mrb_ary_ref(mrb, ary, n) mrb_ary_entry(ary, n) /* * Replace subsequence of an array. diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h index 05f1d953c..90866ab55 100644 --- a/include/mruby/boxing_nan.h +++ b/include/mruby/boxing_nan.h @@ -41,14 +41,14 @@ union mrb_value_ { uint64_t u; #ifdef MRB_64BIT void *p; -# define BOXNAN_IMMEDIATE_VALUE uint32_t i +# define NANBOX_IMMEDIATE_VALUE uint32_t i #else -# define BOXNAN_IMMEDIATE_VALUE union { uint32_t i; void *p; } +# define NANBOX_IMMEDIATE_VALUE union { uint32_t i; void *p; } #endif struct { MRB_ENDIAN_LOHI( uint32_t ttt; - ,BOXNAN_IMMEDIATE_VALUE; + ,NANBOX_IMMEDIATE_VALUE; ) }; mrb_value value; @@ -74,14 +74,14 @@ mrb_val_union(mrb_value v) #ifdef MRB_64BIT #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) +#define NANBOX_SHIFT_LONG_POINTER(v) (((uintptr_t)(v)>>34)&0x3fff) #else #define mrb_ptr(o) ((void*)mrb_val_union(o).i) #define mrb_cptr(o) mrb_ptr(o) -#define BOXNAN_SHIFT_LONG_POINTER(v) 0 +#define NANBOX_SHIFT_LONG_POINTER(v) 0 #endif -#define BOXNAN_SET_VALUE(o, tt, attr, v) do { \ +#define NANBOX_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);\ @@ -89,14 +89,14 @@ mrb_val_union(mrb_value v) } while (0) #ifdef MRB_64BIT -#define BOXNAN_SET_OBJ_VALUE(o, tt, v) do {\ +#define NANBOX_SET_OBJ_VALUE(o, tt, v) do {\ 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));\ + mrb_value_union_variable.ttt = (0xfff00000|(((tt)+1)<<14)|NANBOX_SHIFT_LONG_POINTER(v));\ o = mrb_value_union_variable.value;\ } while (0) #else -#define BOXNAN_SET_OBJ_VALUE(o, tt, v) BOXNAN_SET_VALUE(o, tt, i, (uint32_t)v) +#define NANBOX_SET_OBJ_VALUE(o, tt, v) NANBOX_SET_VALUE(o, tt, i, (uint32_t)v) #endif #define SET_FLOAT_VALUE(mrb,r,v) do { \ @@ -111,20 +111,20 @@ mrb_val_union(mrb_value v) r = mrb_value_union_variable.value; \ } while(0) -#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)) +#define SET_NIL_VALUE(r) NANBOX_SET_VALUE(r, MRB_TT_FALSE, i, 0) +#define SET_FALSE_VALUE(r) NANBOX_SET_VALUE(r, MRB_TT_FALSE, i, 1) +#define SET_TRUE_VALUE(r) NANBOX_SET_VALUE(r, MRB_TT_TRUE, i, 1) +#define SET_BOOL_VALUE(r,b) NANBOX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, i, 1) +#define SET_INT_VALUE(mrb, r,n) NANBOX_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n)) +#define SET_FIXNUM_VALUE(r,n) NANBOX_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n)) +#define SET_SYM_VALUE(r,v) NANBOX_SET_VALUE(r, MRB_TT_SYMBOL, i, (uint32_t)(v)) +#define SET_OBJ_VALUE(r,v) NANBOX_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, p, v) +#define SET_CPTR_VALUE(mrb,r,v) NANBOX_SET_VALUE(r, MRB_TT_CPTR, p, v) #endif -#define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, i, 0) +#define SET_UNDEF_VALUE(r) NANBOX_SET_VALUE(r, MRB_TT_UNDEF, i, 0) #endif /* MRUBY_BOXING_NAN_H */ diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h index beab8681e..89c6f6f2d 100644 --- a/include/mruby/boxing_word.h +++ b/include/mruby/boxing_word.h @@ -7,7 +7,11 @@ #ifndef MRUBY_BOXING_WORD_H #define MRUBY_BOXING_WORD_H -#ifndef MRB_NO_FLOAT +#if defined(MRB_32BIT) && !defined(MRB_USE_FLOAT32) +# define MRB_WORDBOX_NO_FLOAT_TRUNCATE +#endif + +#if !defined(MRB_NO_FLOAT) && defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE) struct RFloat { MRB_OBJECT_HEADER; mrb_float f; @@ -29,9 +33,9 @@ enum mrb_special_consts { #if defined(MRB_64BIT) && defined(MRB_INT32) #define MRB_FIXNUM_SHIFT 0 #else -#define MRB_FIXNUM_SHIFT BOXWORD_FIXNUM_SHIFT +#define MRB_FIXNUM_SHIFT WORDBOX_FIXNUM_SHIFT #endif -#define MRB_SYMBOL_SHIFT BOXWORD_SYMBOL_SHIFT +#define MRB_SYMBOL_SHIFT WORDBOX_SYMBOL_SHIFT #if defined(MRB_64BIT) && defined(MRB_INT64) # define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT) @@ -41,36 +45,69 @@ enum mrb_special_consts { # define MRB_FIXNUM_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT) #endif -#define BOXWORD_FIXNUM_BIT_POS 1 -#define BOXWORD_SYMBOL_BIT_POS 2 -#define BOXWORD_FIXNUM_SHIFT BOXWORD_FIXNUM_BIT_POS -#ifdef MRB_64BIT -#define BOXWORD_SYMBOL_SHIFT 0 +#define WORDBOX_FIXNUM_BIT_POS 1 +#define WORDBOX_FIXNUM_SHIFT WORDBOX_FIXNUM_BIT_POS +#define WORDBOX_FIXNUM_FLAG (1 << (WORDBOX_FIXNUM_BIT_POS - 1)) +#define WORDBOX_FIXNUM_MASK ((1 << WORDBOX_FIXNUM_BIT_POS) - 1) + +#if defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE) +/* floats are allocated in heaps */ +#define WORDBOX_SYMBOL_BIT_POS 2 +#define WORDBOX_SYMBOL_SHIFT WORDBOX_SYMBOL_BIT_POS +#define WORDBOX_SYMBOL_FLAG (1 << (WORDBOX_SYMBOL_BIT_POS - 1)) +#define WORDBOX_SYMBOL_MASK ((1 << WORDBOX_SYMBOL_BIT_POS) - 1) #else -#define BOXWORD_SYMBOL_SHIFT BOXWORD_SYMBOL_BIT_POS +#define WORDBOX_FLOAT_FLAG 2 +#define WORDBOX_FLOAT_MASK 3 +#if defined(MRB_64BIT) +#define WORDBOX_SYMBOL_SHIFT 32 +#else /* MRB_32BIT */ +#define WORDBOX_SYMBOL_SHIFT 5 #endif -#define BOXWORD_FIXNUM_FLAG (1 << (BOXWORD_FIXNUM_BIT_POS - 1)) -#define BOXWORD_SYMBOL_FLAG (1 << (BOXWORD_SYMBOL_BIT_POS - 1)) -#define BOXWORD_FIXNUM_MASK ((1 << BOXWORD_FIXNUM_BIT_POS) - 1) -#define BOXWORD_SYMBOL_MASK ((1 << BOXWORD_SYMBOL_BIT_POS) - 1) -#define BOXWORD_IMMEDIATE_MASK 0x07 - -#define BOXWORD_SET_SHIFT_VALUE(o,n,v) \ - ((o).w = (((uintptr_t)(v)) << BOXWORD_##n##_SHIFT) | BOXWORD_##n##_FLAG) -#define BOXWORD_SHIFT_VALUE_P(o,n) \ - (((o).w & BOXWORD_##n##_MASK) == BOXWORD_##n##_FLAG) -#define BOXWORD_OBJ_TYPE_P(o,n) \ +#define WORDBOX_SYMBOL_FLAG 0x1c +#define WORDBOX_SYMBOL_MASK 0x1f +#endif + +#define WORDBOX_IMMEDIATE_MASK 0x07 + +#define WORDBOX_SET_SHIFT_VALUE(o,n,v) \ + ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG) +#define WORDBOX_SHIFT_VALUE_P(o,n) \ + (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG) +#define WORDBOX_OBJ_TYPE_P(o,n) \ (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n) /* * mrb_value representation: * + * 64bit word with inline float: + * nil : ...0000 0000 (all bits are 0) + * false : ...0000 0100 (mrb_fixnum(v) != 0) + * true : ...0000 1100 + * undef : ...0001 0100 + * symbol: ...0001 1100 (use only upper 32-bit as symbol value with MRB_64BIT) + * fixnum: ...IIII III1 + * float : ...FFFF FF10 (51 bit significands; require MRB_64BIT) + * object: ...PPPP P000 + * + * 32bit word with inline float: + * nil : ...0000 0000 (all bits are 0) + * false : ...0000 0100 (mrb_fixnum(v) != 0) + * true : ...0000 1100 + * undef : ...0001 0100 + * symbol: ...SSS1 1100 (use only upper 32-bit as symbol value with MRB_64BIT) + * symbol: ...SSS1 0100 (symbol occupies 20bits) + * fixnum: ...IIII III1 + * float : ...FFFF FF10 (22 bit significands; require MRB_64BIT) + * object: ...PPPP P000 + * + * and word boxing without inline float: * nil : ...0000 0000 (all bits are 0) * false : ...0000 0100 (mrb_fixnum(v) != 0) * true : ...0000 1100 * undef : ...0001 0100 * fixnum: ...IIII III1 - * symbol: ...SSSS SS10 (use only upper 32-bit as symbol value on 64-bit CPU) + * symbol: ...SSSS SS10 * object: ...PPPP P000 (any bits are 1) */ typedef struct mrb_value { @@ -79,19 +116,14 @@ typedef struct 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 flag; - ) - } sym; -#endif struct RBasic *bp; #ifndef MRB_NO_FLOAT +#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE + mrb_float f; +#else struct RFloat *fp; #endif +#endif struct RInteger *ip; struct RCptr *vp; uintptr_t w; @@ -114,59 +146,60 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #endif MRB_API mrb_value mrb_word_boxing_int_value(struct mrb_state*, mrb_int); -#define mrb_immediate_p(o) ((o).w & BOXWORD_IMMEDIATE_MASK || (o).w == MRB_Qnil) +#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil) #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 +#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE +MRB_API mrb_float mrb_word_boxing_value_float(mrb_value v); +#define mrb_float(o) mrb_word_boxing_value_float(o) +#else +#define mrb_float(o) mrb_val_union(o).fp->f +#endif #endif -#define mrb_fixnum(o) (mrb_int)(((intptr_t)(o).w) >> BOXWORD_FIXNUM_SHIFT) +#define mrb_fixnum(o) (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT) MRB_INLINE mrb_int mrb_integer_func(mrb_value o) { if (mrb_immediate_p(o)) return mrb_fixnum(o); return mrb_val_union(o).ip->i; } #define mrb_integer(o) mrb_integer_func(o) -#ifdef MRB_64BIT -#define mrb_symbol(o) mrb_val_union(o).sym.sym -#else -#define mrb_symbol(o) (mrb_sym)(((o).w) >> BOXWORD_SYMBOL_SHIFT) -#endif +#define mrb_symbol(o) (mrb_sym)(((o).w) >> WORDBOX_SYMBOL_SHIFT) #define mrb_bool(o) (((o).w & ~(uintptr_t)MRB_Qfalse) != 0) -#define mrb_fixnum_p(o) BOXWORD_SHIFT_VALUE_P(o, FIXNUM) -#define mrb_integer_p(o) (BOXWORD_SHIFT_VALUE_P(o, FIXNUM)||BOXWORD_OBJ_TYPE_P(o, INTEGER)) -#ifdef MRB_64BIT -#define mrb_symbol_p(o) (mrb_val_union(o).sym.flag == BOXWORD_SYMBOL_FLAG) -#else -#define mrb_symbol_p(o) BOXWORD_SHIFT_VALUE_P(o, SYMBOL) -#endif +#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM) +#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER)) +#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL) #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_NO_FLOAT -#define mrb_float_p(o) BOXWORD_OBJ_TYPE_P(o, FLOAT) +#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE +#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT) +#else +#define mrb_float_p(o) WORDBOX_OBJ_TYPE_P(o, FLOAT) +#endif #endif -#define mrb_array_p(o) BOXWORD_OBJ_TYPE_P(o, ARRAY) -#define mrb_string_p(o) BOXWORD_OBJ_TYPE_P(o, STRING) -#define mrb_hash_p(o) BOXWORD_OBJ_TYPE_P(o, HASH) -#define mrb_cptr_p(o) BOXWORD_OBJ_TYPE_P(o, CPTR) -#define mrb_exception_p(o) BOXWORD_OBJ_TYPE_P(o, EXCEPTION) -#define mrb_free_p(o) BOXWORD_OBJ_TYPE_P(o, FREE) -#define mrb_object_p(o) BOXWORD_OBJ_TYPE_P(o, OBJECT) -#define mrb_class_p(o) BOXWORD_OBJ_TYPE_P(o, CLASS) -#define mrb_module_p(o) BOXWORD_OBJ_TYPE_P(o, MODULE) -#define mrb_iclass_p(o) BOXWORD_OBJ_TYPE_P(o, ICLASS) -#define mrb_sclass_p(o) BOXWORD_OBJ_TYPE_P(o, SCLASS) -#define mrb_proc_p(o) BOXWORD_OBJ_TYPE_P(o, PROC) -#define mrb_range_p(o) BOXWORD_OBJ_TYPE_P(o, RANGE) -#define mrb_env_p(o) BOXWORD_OBJ_TYPE_P(o, ENV) -#define mrb_data_p(o) BOXWORD_OBJ_TYPE_P(o, DATA) -#define mrb_fiber_p(o) BOXWORD_OBJ_TYPE_P(o, FIBER) -#define mrb_istruct_p(o) BOXWORD_OBJ_TYPE_P(o, ISTRUCT) -#define mrb_break_p(o) BOXWORD_OBJ_TYPE_P(o, BREAK) +#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY) +#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING) +#define mrb_hash_p(o) WORDBOX_OBJ_TYPE_P(o, HASH) +#define mrb_cptr_p(o) WORDBOX_OBJ_TYPE_P(o, CPTR) +#define mrb_exception_p(o) WORDBOX_OBJ_TYPE_P(o, EXCEPTION) +#define mrb_free_p(o) WORDBOX_OBJ_TYPE_P(o, FREE) +#define mrb_object_p(o) WORDBOX_OBJ_TYPE_P(o, OBJECT) +#define mrb_class_p(o) WORDBOX_OBJ_TYPE_P(o, CLASS) +#define mrb_module_p(o) WORDBOX_OBJ_TYPE_P(o, MODULE) +#define mrb_iclass_p(o) WORDBOX_OBJ_TYPE_P(o, ICLASS) +#define mrb_sclass_p(o) WORDBOX_OBJ_TYPE_P(o, SCLASS) +#define mrb_proc_p(o) WORDBOX_OBJ_TYPE_P(o, PROC) +#define mrb_range_p(o) WORDBOX_OBJ_TYPE_P(o, RANGE) +#define mrb_env_p(o) WORDBOX_OBJ_TYPE_P(o, ENV) +#define mrb_data_p(o) WORDBOX_OBJ_TYPE_P(o, DATA) +#define mrb_fiber_p(o) WORDBOX_OBJ_TYPE_P(o, FIBER) +#define mrb_istruct_p(o) WORDBOX_OBJ_TYPE_P(o, ISTRUCT) +#define mrb_break_p(o) WORDBOX_OBJ_TYPE_P(o, BREAK) #ifndef MRB_NO_FLOAT #define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v)) @@ -178,17 +211,8 @@ mrb_integer_func(mrb_value o) { #define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue) #define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r)) #define SET_INT_VALUE(mrb,r,n) ((r) = mrb_word_boxing_int_value(mrb, n)) -#define SET_FIXNUM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n) -#ifdef MRB_64BIT -#define SET_SYM_VALUE(r,v) do {\ - union mrb_value_ mrb_value_union_variable;\ - mrb_value_union_variable.sym.sym = v;\ - mrb_value_union_variable.sym.flag = BOXWORD_SYMBOL_FLAG;\ - (r) = mrb_value_union_variable.value;\ -} while (0) -#else -#define SET_SYM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, SYMBOL, n) -#endif +#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n) +#define SET_SYM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, SYMBOL, n) #define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v)) MRB_INLINE enum mrb_vtype @@ -199,6 +223,9 @@ mrb_type(mrb_value o) mrb_fixnum_p(o) ? MRB_TT_INTEGER : mrb_symbol_p(o) ? MRB_TT_SYMBOL : mrb_undef_p(o) ? MRB_TT_UNDEF : +#ifndef MRB_NO_FLOAT + mrb_float_p(o) ? MRB_TT_FLOAT : +#endif mrb_val_union(o).bp->tt; } diff --git a/include/mruby/compile.h b/include/mruby/compile.h index 8159cd696..6732625c1 100644 --- a/include/mruby/compile.h +++ b/include/mruby/compile.h @@ -16,8 +16,6 @@ MRB_BEGIN_DECL #include <mruby.h> -struct mrb_jmpbuf; - struct mrb_parser_state; /* load context */ typedef struct mrbc_context { @@ -165,7 +163,6 @@ struct mrb_parser_state { uint16_t filename_table_length; uint16_t current_filename_index; - struct mrb_jmpbuf* jmp; mrb_ast_node *nvars; }; diff --git a/include/mruby/debug.h b/include/mruby/debug.h index 2062a9308..7319ccb3f 100644 --- a/include/mruby/debug.h +++ b/include/mruby/debug.h @@ -16,7 +16,8 @@ MRB_BEGIN_DECL typedef enum mrb_debug_line_type { mrb_debug_line_ary = 0, - mrb_debug_line_flat_map = 1 + mrb_debug_line_flat_map, + mrb_debug_line_packed_map } mrb_debug_line_type; typedef struct mrb_irep_debug_info_line { @@ -31,8 +32,9 @@ typedef struct mrb_irep_debug_info_file { mrb_debug_line_type line_type; union { void *ptr; - mrb_irep_debug_info_line *flat_map; uint16_t *ary; + mrb_irep_debug_info_line *flat_map; + uint8_t *packed_map; } lines; } mrb_irep_debug_info_file; diff --git a/include/mruby/hash.h b/include/mruby/hash.h index 749ea3869..1b37a12d4 100644 --- a/include/mruby/hash.h +++ b/include/mruby/hash.h @@ -37,8 +37,6 @@ struct RHash { size_t mrb_hash_memsize(mrb_value obj); MRB_API mrb_value mrb_hash_new_capa(mrb_state *mrb, mrb_int capa); -MRB_API mrb_value mrb_ensure_hash_type(mrb_state *mrb, mrb_value hash); -MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash); /* * Initializes a new hash. diff --git a/include/mruby/irep.h b/include/mruby/irep.h index 6a3b4bd10..2a0e261d1 100644 --- a/include/mruby/irep.h +++ b/include/mruby/irep.h @@ -122,7 +122,8 @@ struct mrb_insn_data { uint8_t insn; uint16_t a; uint16_t b; - uint16_t c; + uint8_t c; + const mrb_code *addr; }; struct mrb_insn_data mrb_decode_insn(const mrb_code *pc); diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index fc6cacfda..4b14588ac 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -30,21 +30,19 @@ MRB_BEGIN_DECL #endif #endif -#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_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); -#endif - MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y); MRB_API mrb_value mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y); MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y); +MRB_API mrb_value mrb_integer_to_str(mrb_state *mrb, mrb_value x, mrb_int base); +MRB_API char *mrb_int_to_cstr(char *buf, size_t len, mrb_int n, mrb_int base); + +/* internal function(s) */ +mrb_int mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y); + +/* obsolete function(s); will be removed */ +#define mrb_fixnum_to_str(mrb, x, base) mrb_integer_to_str(mrb, x, base) + #ifndef __has_builtin #define __has_builtin(x) 0 #endif @@ -135,8 +133,6 @@ mrb_int_mul_overflow(mrb_int a, mrb_int b, mrb_int *c) #endif #ifndef MRB_NO_FLOAT -# include <stdint.h> -# include <float.h> # define MRB_FLT_RADIX FLT_RADIX @@ -162,6 +158,19 @@ mrb_int_mul_overflow(mrb_int a, mrb_int b, mrb_int *c) # define MRB_FLT_MAX DBL_MAX # define MRB_FLT_MAX_10_EXP DBL_MAX_10_EXP # endif /* MRB_USE_FLOAT32 */ + +MRB_API mrb_value mrb_float_to_integer(mrb_state *mrb, mrb_value val); +MRB_API mrb_float mrb_as_float(mrb_state *mrb, mrb_value x); + +/* internal functions */ +mrb_float mrb_div_float(mrb_float x, mrb_float y); +mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt); +int mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, char sign); + +/* obsolete functions; will be removed */ +#define mrb_flo_to_fixnum(mrb, val) mrb_float_to_integer(mrb, val) +#define mrb_to_flo(mrb, x) mrb_as_float(mrb, x) + #endif /* MRB_NO_FLOAT */ MRB_END_DECL diff --git a/include/mruby/opcode.h b/include/mruby/opcode.h index 987c5ad8f..249598161 100644 --- a/include/mruby/opcode.h +++ b/include/mruby/opcode.h @@ -40,4 +40,34 @@ 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_BSS_1() do {a=READ_S(); b=READ_S();c=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_BSS_2() FETCH_BSS() +#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_BSS_3() FETCH_BSS_1() +#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 d5d8fb077..9b9fefeb0 100644 --- a/include/mruby/ops.h +++ b/include/mruby/ops.h @@ -15,7 +15,6 @@ operation code operands semantics OPCODE(NOP, Z) /* no operation */ OPCODE(MOVE, BB) /* R(a) = R(b) */ OPCODE(LOADL, BB) /* R(a) = Pool(b) */ -OPCODE(LOADL16, BS) /* R(a) = Pool(b) */ OPCODE(LOADI, BB) /* R(a) = mrb_int(b) */ OPCODE(LOADINEG, BB) /* R(a) = mrb_int(-b) */ OPCODE(LOADI__1, B) /* R(a) = mrb_int(-1) */ @@ -30,7 +29,6 @@ OPCODE(LOADI_7, B) /* R(a) = mrb_int(7) */ OPCODE(LOADI16, BS) /* R(a) = mrb_int(b) */ OPCODE(LOADI32, BSS) /* R(a) = mrb_int((b<<16)+c) */ OPCODE(LOADSYM, BB) /* R(a) = Syms(b) */ -OPCODE(LOADSYM16, BS) /* R(a) = Syms(b) */ OPCODE(LOADNIL, B) /* R(a) = nil */ OPCODE(LOADSELF, B) /* R(a) = self */ OPCODE(LOADT, B) /* R(a) = true */ @@ -87,36 +85,35 @@ OPCODE(GE, B) /* R(a) = R(a)>=R(a+1) */ OPCODE(ARRAY, BB) /* R(a) = ary_new(R(a),R(a+1)..R(a+b)) */ OPCODE(ARRAY2, BBB) /* R(a) = ary_new(R(b),R(b+1)..R(b+c)) */ OPCODE(ARYCAT, B) /* ary_cat(R(a),R(a+1)) */ -OPCODE(ARYPUSH, B) /* ary_push(R(a),R(a+1)) */ +OPCODE(ARYPUSH, BB) /* ary_push(R(a),R(a+1)..R(a+b)) */ OPCODE(ARYDUP, B) /* R(a) = ary_dup(R(a)) */ OPCODE(AREF, BBB) /* R(a) = R(b)[c] */ OPCODE(ASET, BBB) /* R(a)[c] = R(b) */ OPCODE(APOST, BBB) /* *R(a),R(a+1)..R(a+c) = R(a)[b..] */ OPCODE(INTERN, B) /* R(a) = intern(R(a)) */ -OPCODE(STRING, BB) /* R(a) = str_dup(Lit(b)) */ -OPCODE(STRING16, BS) /* R(a) = str_dup(Lit(b)) */ +OPCODE(SYMBOL, BB) /* R(a) = intern(Pool(b)) */ +OPCODE(STRING, BB) /* R(a) = str_dup(Pool(b)) */ OPCODE(STRCAT, B) /* str_cat(R(a),R(a+1)) */ OPCODE(HASH, BB) /* R(a) = hash_new(R(a),R(a+1)..R(a+b*2-1)) */ -OPCODE(HASHADD, BB) /* R(a) = hash_push(R(a),R(a+1)..R(a+b*2)) */ +OPCODE(HASHADD, BB) /* hash_push(R(a),R(a+1)..R(a+b*2)) */ OPCODE(HASHCAT, B) /* R(a) = hash_cat(R(a),R(a+1)) */ -OPCODE(LAMBDA, BB) /* R(a) = lambda(SEQ[b],L_LAMBDA) */ -OPCODE(LAMBDA16, BS) /* R(a) = lambda(SEQ[b],L_LAMBDA) */ -OPCODE(BLOCK, BB) /* R(a) = lambda(SEQ[b],L_BLOCK) */ -OPCODE(BLOCK16, BS) /* R(a) = lambda(SEQ[b],L_BLOCK) */ -OPCODE(METHOD, BB) /* R(a) = lambda(SEQ[b],L_METHOD) */ -OPCODE(METHOD16, BS) /* R(a) = lambda(SEQ[b],L_METHOD) */ +OPCODE(LAMBDA, BB) /* R(a) = lambda(Irep(b),L_LAMBDA) */ +OPCODE(BLOCK, BB) /* R(a) = lambda(Irep(b),L_BLOCK) */ +OPCODE(METHOD, BB) /* R(a) = lambda(Irep(b),L_METHOD) */ OPCODE(RANGE_INC, B) /* R(a) = range_new(R(a),R(a+1),FALSE) */ OPCODE(RANGE_EXC, B) /* R(a) = range_new(R(a),R(a+1),TRUE) */ OPCODE(OCLASS, B) /* R(a) = ::Object */ OPCODE(CLASS, BB) /* R(a) = newclass(R(a),Syms(b),R(a+1)) */ OPCODE(MODULE, BB) /* R(a) = newmodule(R(a),Syms(b)) */ -OPCODE(EXEC, BB) /* R(a) = blockexec(R(a),SEQ[b]) */ -OPCODE(EXEC16, BS) /* R(a) = blockexec(R(a),SEQ[b]) */ -OPCODE(DEF, BB) /* R(a).newmethod(Syms(b),R(a+1)) */ +OPCODE(EXEC, BB) /* R(a) = blockexec(R(a),Irep(b)) */ +OPCODE(DEF, BB) /* R(a).newmethod(Syms(b),R(a+1)); R(a) = Syms(b) */ OPCODE(ALIAS, BB) /* alias_method(target_class,Syms(a),Syms(b)) */ OPCODE(UNDEF, B) /* undef_method(target_class,Syms(a)) */ 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(ERR, B) /* raise(LocalJumpError, Pool(a)) */ +OPCODE(EXT1, Z) /* make 1st operand (a) 16bit */ +OPCODE(EXT2, Z) /* make 2nd operand (b) 16bit */ +OPCODE(EXT3, Z) /* make 1st and 2nd operands 16bit */ OPCODE(STOP, Z) /* stop VM */ diff --git a/include/mruby/string.h b/include/mruby/string.h index 4410accd5..b296832af 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -324,20 +324,6 @@ MRB_API mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len); */ MRB_API mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len); -/** - * Returns a Ruby string type. - * - * - * @param mrb The current mruby state. - * @param str Ruby string. - * @return [mrb_value] A Ruby string. - */ -MRB_API mrb_value mrb_ensure_string_type(mrb_state *mrb, mrb_value str); -MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str); -/* obsolete: use mrb_ensure_string_type() instead */ -MRB_API mrb_value mrb_string_type(mrb_state *mrb, mrb_value str); - - MRB_API mrb_value mrb_str_new_capa(mrb_state *mrb, size_t capa); #define mrb_str_buf_new(mrb, capa) mrb_str_new_capa(mrb, (capa)) @@ -369,17 +355,10 @@ MRB_API mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str); */ MRB_API mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self); -MRB_API mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck); -MRB_API mrb_value mrb_cstr_to_inum(mrb_state *mrb, const char *s, mrb_int base, mrb_bool badcheck); +MRB_API mrb_value mrb_str_to_integer(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck); +/* obsolete: use mrb_str_to_integer() */ +#define mrb_str_to_inum(mrb, str, base, badcheck) mrb_str_to_integer(mrb, str, base, badcheck) MRB_API double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck); -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. - */ -#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. diff --git a/include/mruby/value.h b/include/mruby/value.h index 39c01509d..ad439334b 100644 --- a/include/mruby/value.h +++ b/include/mruby/value.h @@ -31,7 +31,30 @@ typedef uint32_t mrb_sym; * Not to be confused with Ruby's boolean classes, which can be * obtained using mrb_false_value() and mrb_true_value() */ +#if defined(__cplusplus) || (defined(__bool_true_false_are_defined) && __bool_true_false_are_defined) +typedef bool mrb_bool; + +# ifndef FALSE +# define FALSE false +# endif +# ifndef TRUE +# define TRUE true +# endif +#else +# if __STDC_VERSION__ >= 199901L +typedef _Bool mrb_bool; +# else typedef uint8_t mrb_bool; +# endif + +# ifndef FALSE +# define FALSE 0 +# endif +# ifndef TRUE +# define TRUE 1 +# endif +#endif + struct mrb_state; #if defined _MSC_VER && _MSC_VER < 1800 @@ -77,6 +100,7 @@ struct mrb_state; # define MRB_ENDIAN_LOHI(a,b) b a #endif +MRB_API mrb_int mrb_int_read(const char *p, const char *e, char **endp); #ifndef MRB_NO_FLOAT MRB_API double mrb_float_read(const char*, char**); #ifdef MRB_USE_FLOAT32 @@ -87,13 +111,11 @@ MRB_API double mrb_float_read(const char*, char**); #endif #if defined _MSC_VER && _MSC_VER < 1900 -# include <stdarg.h> MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list arg); 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_NO_FLOAT -# include <float.h> # define isfinite(n) _finite(n) # define isnan _isnan # define isinf(n) (!_finite(n) && !_isnan(n)) @@ -104,36 +126,49 @@ static const unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000; # endif #endif +#define MRB_VTYPE_FOREACH(f) \ + /* mrb_vtype */ /* c type */ /* ruby class */ \ + f(MRB_TT_FALSE, void, "false") \ + f(MRB_TT_TRUE, void, "true") \ + f(MRB_TT_SYMBOL, void, "Symbol") \ + f(MRB_TT_UNDEF, void, "undefined") \ + f(MRB_TT_FREE, void, "free") \ + f(MRB_TT_FLOAT, struct RFloat, "Float") \ + f(MRB_TT_INTEGER, struct RInteger, "Integer") \ + f(MRB_TT_CPTR, struct RCptr, "cptr") \ + f(MRB_TT_OBJECT, struct RObject, "Object") \ + f(MRB_TT_CLASS, struct RClass, "Class") \ + f(MRB_TT_MODULE, struct RClass, "Module") \ + f(MRB_TT_ICLASS, struct RClass, "iClass") \ + f(MRB_TT_SCLASS, struct RClass, "SClass") \ + f(MRB_TT_PROC, struct RProc, "Proc") \ + f(MRB_TT_ARRAY, struct RArray, "Array") \ + f(MRB_TT_HASH, struct RHash, "Hash") \ + f(MRB_TT_STRING, struct RString, "String") \ + f(MRB_TT_RANGE, struct RRange, "Range") \ + f(MRB_TT_EXCEPTION, struct RException, "Exception") \ + f(MRB_TT_ENV, struct REnv, "env") \ + f(MRB_TT_DATA, struct RData, "Data") \ + f(MRB_TT_FIBER, struct RFiber, "Fiber") \ + f(MRB_TT_STRUCT, struct RArray, "Struct") \ + f(MRB_TT_ISTRUCT, struct RIStruct, "istruct") \ + f(MRB_TT_BREAK, struct RBreak, "break") \ + f(MRB_TT_COMPLEX, struct RComplex, "Complex") \ + f(MRB_TT_RATIONAL, struct RRational, "Rational") + enum mrb_vtype { - MRB_TT_FALSE = 0, - MRB_TT_TRUE, - MRB_TT_SYMBOL, - MRB_TT_UNDEF, - MRB_TT_FREE, - MRB_TT_FLOAT, - MRB_TT_INTEGER, - MRB_TT_CPTR, - MRB_TT_OBJECT, - MRB_TT_CLASS, - MRB_TT_MODULE, - MRB_TT_ICLASS, - MRB_TT_SCLASS, - MRB_TT_PROC, - MRB_TT_ARRAY, - MRB_TT_HASH, - MRB_TT_STRING, - MRB_TT_RANGE, - MRB_TT_EXCEPTION, - MRB_TT_ENV, - MRB_TT_DATA, - MRB_TT_FIBER, - MRB_TT_ISTRUCT, - MRB_TT_BREAK, - MRB_TT_COMPLEX, - MRB_TT_RATIONAL, +#define MRB_VTYPE_DEFINE(tt, type, name) tt, + MRB_VTYPE_FOREACH(MRB_VTYPE_DEFINE) +#undef MRB_VTYPE_DEFINE MRB_TT_MAXDEFINE }; +#define MRB_VTYPE_TYPEOF(tt) MRB_TYPEOF_##tt + +#define MRB_VTYPE_TYPEDEF(tt, type, name) typedef type MRB_VTYPE_TYPEOF(tt); +MRB_VTYPE_FOREACH(MRB_VTYPE_TYPEDEF) +#undef MRB_VTYPE_TYPEDEF + /* for compatibility */ #define MRB_TT_FIXNUM MRB_TT_INTEGER @@ -374,26 +409,29 @@ mrb_undef_value(void) return v; } -#if defined(MRB_USE_ETEXT_EDATA) && !defined(MRB_USE_LINK_TIME_RO_DATA_P) -# ifdef __GNUC__ -# warning MRB_USE_ETEXT_EDATA is deprecated. Define MRB_USE_LINK_TIME_RO_DATA_P instead. -# endif -# define MRB_USE_LINK_TIME_RO_DATA_P -#endif - #if defined(MRB_USE_CUSTOM_RO_DATA_P) /* If you define `MRB_USE_CUSTOM_RO_DATA_P`, you must implement `mrb_ro_data_p()`. */ mrb_bool mrb_ro_data_p(const char *p); -#elif defined(MRB_USE_LINK_TIME_RO_DATA_P) -extern char __ehdr_start[]; -extern char __init_array_start[]; - +#elif !defined(MRB_NO_DEFAULT_RO_DATA_P) +#if defined(MRB_USE_ETEXT_RO_DATA_P) +#define MRB_LINK_TIME_RO_DATA_P +extern char etext, edata; static inline mrb_bool mrb_ro_data_p(const char *p) { - return __ehdr_start < p && p < __init_array_start; + return &etext < p && p < &edata; } -#else +#elif defined(__APPLE__) +#define MRB_LINK_TIME_RO_DATA_P +#include <mach-o/getsect.h> +static inline mrb_bool +mrb_ro_data_p(const char *p) +{ + return (char*)get_etext() < p && p < (char*)get_edata(); +} +#endif /* Linux or macOS */ +#endif /* MRB_NO_DEFAULT_RO_DATA_P */ +#ifndef MRB_LINK_TIME_RO_DATA_P # define mrb_ro_data_p(p) FALSE #endif diff --git a/lib/mruby/gem.rb b/lib/mruby/gem.rb index 716f21286..fa0bb3a49 100644 --- a/lib/mruby/gem.rb +++ b/lib/mruby/gem.rb @@ -253,7 +253,7 @@ module MRuby f.puts %Q[#include <mruby.h>] else f.puts %Q[#include <stdlib.h>] - unless build.presym_enabled? + unless cdump? f.puts %Q[#include <mruby.h>] f.puts %Q[#include <mruby/proc.h>] end diff --git a/lib/mruby/presym.rb b/lib/mruby/presym.rb index 6a68cf65c..016c2b20e 100644 --- a/lib/mruby/presym.rb +++ b/lib/mruby/presym.rb @@ -99,7 +99,7 @@ module MRuby end def list_path - @list_pat ||= "#{@build.build_dir}/presym".freeze + @list_path ||= "#{@build.build_dir}/presym".freeze end def header_dir; diff --git a/lib/mruby/source.rb b/lib/mruby/source.rb index a305c7b04..ce9e558dc 100644 --- a/lib/mruby/source.rb +++ b/lib/mruby/source.rb @@ -2,7 +2,7 @@ require "pathname" module MRuby module Source - # MRuby's source root directory + # mruby's source root directory ROOT = Pathname.new(File.expand_path('../../../',__FILE__)) # Reads a constant defined at version.h @@ -1,2 +1,2 @@ -#! /usr/bin/env ruby +#!/usr/bin/env ruby exec "rake", *ARGV diff --git a/mrbgems/mruby-array-ext/mrblib/array.rb b/mrbgems/mruby-array-ext/mrblib/array.rb index ecd09aa6e..7520b932f 100644 --- a/mrbgems/mruby-array-ext/mrblib/array.rb +++ b/mrbgems/mruby-array-ext/mrblib/array.rb @@ -150,7 +150,7 @@ class Array # [ 1, 1, 3, 5 ] & [ 1, 2, 3 ] #=> [ 1, 3 ] # def &(elem) - raise TypeError, "can't convert #{elem.class} into Array" unless elem.class == Array + raise TypeError, "cannot convert #{elem.class} into Array" unless elem.class == Array hash = {} array = [] @@ -204,7 +204,7 @@ class Array # a.intersect?(b) #=> true # a.intersect?(c) #=> false def intersect?(ary) - raise TypeError, "can't convert #{ary.class} into Array" unless ary.class == Array + raise TypeError, "cannot convert #{ary.class} into Array" unless ary.class == Array hash = {} if self.length > ary.length @@ -294,41 +294,6 @@ class Array end end - ## - # call-seq: - # ary.compact -> new_ary - # - # Returns a copy of +self+ with all +nil+ elements removed. - # - # [ "a", nil, "b", nil, "c", nil ].compact - # #=> [ "a", "b", "c" ] - # - def compact - result = self.dup - result.compact! - result - end - - ## - # call-seq: - # ary.compact! -> ary or nil - # - # Removes +nil+ elements from the array. - # Returns +nil+ if no changes were made, otherwise returns - # <i>ary</i>. - # - # [ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ] - # [ "a", "b", "c" ].compact! #=> nil - # - def compact! - result = self.select { |e| !e.nil? } - if result.size == self.size - nil - else - self.replace(result) - end - end - # for efficiency def reverse_each(&block) return to_enum :reverse_each unless block @@ -421,7 +386,6 @@ class Array end beg = len = 0 - ary = [] if block if arg0.nil? && arg1.nil? && arg2.nil? # ary.fill { |index| block } -> ary @@ -485,57 +449,6 @@ class Array ## # call-seq: - # ary.rotate(count=1) -> new_ary - # - # Returns a new array by rotating +self+ so that the element at +count+ is - # the first element of the new array. - # - # If +count+ is negative then it rotates in the opposite direction, starting - # from the end of +self+ where +-1+ is the last element. - # - # a = [ "a", "b", "c", "d" ] - # a.rotate #=> ["b", "c", "d", "a"] - # a #=> ["a", "b", "c", "d"] - # a.rotate(2) #=> ["c", "d", "a", "b"] - # a.rotate(-3) #=> ["b", "c", "d", "a"] - - def rotate(count=1) - ary = [] - len = self.length - - if len > 0 - idx = (count < 0) ? (len - (~count % len) - 1) : (count % len) # rotate count - len.times do - ary << self[idx] - idx += 1 - idx = 0 if idx > len-1 - end - end - ary - end - - ## - # call-seq: - # ary.rotate!(count=1) -> ary - # - # Rotates +self+ in place so that the element at +count+ comes first, and - # returns +self+. - # - # If +count+ is negative then it rotates in the opposite direction, starting - # from the end of the array where +-1+ is the last element. - # - # a = [ "a", "b", "c", "d" ] - # a.rotate! #=> ["b", "c", "d", "a"] - # a #=> ["b", "c", "d", "a"] - # a.rotate!(2) #=> ["d", "a", "b", "c"] - # a.rotate!(-3) #=> ["a", "b", "c", "d"] - - def rotate!(count=1) - self.replace(self.rotate(count)) - end - - ## - # call-seq: # ary.delete_if { |item| block } -> ary # ary.delete_if -> Enumerator # @@ -746,7 +659,6 @@ class Array return to_enum :keep_if unless block idx = 0 - len = self.size while idx < self.size do if block.call(self[idx]) idx += 1 @@ -961,7 +873,7 @@ class Array # ary.to_h -> Hash # ary.to_h{|item| ... } -> Hash # - # Returns the result of interpreting <i>aray</i> as an array of + # Returns the result of interpreting <i>array</i> as an array of # <tt>[key, value]</tt> pairs. If a block is given, it should # return <tt>[key, value]</tt> pairs to construct a hash. # diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c index 8df9d7f30..d97778642 100644 --- a/mrbgems/mruby-array-ext/src/array.c +++ b/mrbgems/mruby-array-ext/src/array.c @@ -95,6 +95,12 @@ mrb_ary_at(mrb_state *mrb, mrb_value ary) } static mrb_value +ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n) +{ + return mrb_ary_entry(ary, n); +} + +static mrb_value mrb_ary_values_at(mrb_state *mrb, mrb_value self) { mrb_int argc; @@ -102,10 +108,9 @@ mrb_ary_values_at(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "*", &argv, &argc); - return mrb_get_values_at(mrb, self, RARRAY_LEN(self), argc, argv, mrb_ary_ref); + return mrb_get_values_at(mrb, self, RARRAY_LEN(self), argc, argv, ary_ref); } - /* * call-seq: * ary.slice!(index) -> obj or nil @@ -183,6 +188,168 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self) return ary; } +/* + * call-seq: + * ary.compact -> new_ary + * + * Returns a copy of +self+ with all +nil+ elements removed. + * + * [ "a", nil, "b", nil, "c", nil ].compact + * #=> [ "a", "b", "c" ] + */ + +static mrb_value +mrb_ary_compact(mrb_state *mrb, mrb_value self) +{ + mrb_value ary = mrb_ary_new(mrb); + mrb_int len = RARRAY_LEN(self); + mrb_value *p = RARRAY_PTR(self); + + for (mrb_int i = 0; i < len; ++i) { + if (!mrb_nil_p(p[i])) { + mrb_ary_push(mrb, ary, p[i]); + } + } + return ary; +} + +/* + * call-seq: + * ary.compact! -> ary or nil + * + * Removes +nil+ elements from the array. + * Returns +nil+ if no changes were made, otherwise returns + * <i>ary</i>. + * + * [ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ] + * [ "a", "b", "c" ].compact! #=> nil + */ +static mrb_value +mrb_ary_compact_bang(mrb_state *mrb, mrb_value self) +{ + struct RArray *a = mrb_ary_ptr(self); + mrb_int i, j = 0; + mrb_int len = ARY_LEN(a); + mrb_value *p = ARY_PTR(a); + + mrb_ary_modify(mrb, a); + for (i = 0; i < len; ++i) { + if (!mrb_nil_p(p[i])) { + if (i != j) p[j] = p[i]; + j++; + } + } + if (i == j) return mrb_nil_value(); + if (j < len) ARY_SET_LEN(RARRAY(self), j); + return self; +} + + +/* + * call-seq: + * ary.rotate(count=1) -> new_ary + * + * Returns a new array by rotating +self+ so that the element at +count+ is + * the first element of the new array. + * + * If +count+ is negative then it rotates in the opposite direction, starting + * from the end of +self+ where +-1+ is the last element. + * + * a = [ "a", "b", "c", "d" ] + * a.rotate #=> ["b", "c", "d", "a"] + * a #=> ["a", "b", "c", "d"] + * a.rotate(2) #=> ["c", "d", "a", "b"] + * a.rotate(-3) #=> ["b", "c", "d", "a"] + */ +static mrb_value +mrb_ary_rotate(mrb_state *mrb, mrb_value self) +{ + mrb_value ary = mrb_ary_new(mrb); + mrb_int len = RARRAY_LEN(self); + mrb_value *p = RARRAY_PTR(self); + mrb_int count=1, idx; + + mrb_get_args(mrb, "|i", &count); + if (len <= 0) return ary; + if (count < 0) { + idx = len - (~count % len) - 1; + } + else { + idx = count % len; + } + for (mrb_int i = 0; i<len; i++) { + mrb_ary_push(mrb, ary, p[idx++]); + if (idx == len) idx = 0; + } + return ary; +} + +static void +rev(mrb_value *p, mrb_int beg, mrb_int end) +{ + for (mrb_int i=beg,j=end-1; i<j; i++,j--) { + mrb_value v = p[i]; + p[i] = p[j]; + p[j] = v; + } +} + +/* + * call-seq: + * ary.rotate!(count=1) -> ary + * + * Rotates +self+ in place so that the element at +count+ comes first, and + * returns +self+. + * + * If +count+ is negative then it rotates in the opposite direction, starting + * from the end of the array where +-1+ is the last element. + * + * a = [ "a", "b", "c", "d" ] + * a.rotate! #=> ["b", "c", "d", "a"] + * a #=> ["b", "c", "d", "a"] + * a.rotate!(2) #=> ["d", "a", "b", "c"] + * a.rotate!(-3) #=> ["a", "b", "c", "d"] + */ +static mrb_value +mrb_ary_rotate_bang(mrb_state *mrb, mrb_value self) +{ + struct RArray *a = mrb_ary_ptr(self); + mrb_int len = ARY_LEN(a); + mrb_value *p = ARY_PTR(a); + mrb_int count=1, idx; + + mrb_get_args(mrb, "|i", &count); + mrb_ary_modify(mrb, a); + if (len == 0 || count == 0) return self; + if (count == 1) { + mrb_value v = p[0]; + for (mrb_int i=1; i<len; i++) { + p[i-1] = p[i]; + } + p[len-1] = v; + return self; + } + if (count < 0) { + idx = len - (~count % len) - 1; + } + else { + idx = count % len; + } + /* e.g. [1,2,3,4,5].rotate!(2) -> [3,4,5,1,2] */ + /* first, reverse the whole array */ + /* [1,2,3,4,5] -> [5,4,3,2,1] */ + rev(p, 0, len); + /* then, re-reverse part before idx */ + /* [5,4,3,2,1] -> [3,4,5,2,1] */ + /* ^idx ~~~~~ */ + rev(p, 0, len-idx); + /* finally, re-reverse part after idx */ + /* [3,4,5,2,1] -> [3,4,5,1,2] */ + /* ^idx ~~~ */ + rev(p, len-idx, len); + return self; +} + void mrb_mruby_array_ext_gem_init(mrb_state* mrb) { @@ -192,7 +359,11 @@ mrb_mruby_array_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, a, "at", mrb_ary_at, MRB_ARGS_REQ(1)); mrb_define_method(mrb, a, "rassoc", mrb_ary_rassoc, MRB_ARGS_REQ(1)); mrb_define_method(mrb, a, "values_at", mrb_ary_values_at, MRB_ARGS_ANY()); - mrb_define_method(mrb, a, "slice!", mrb_ary_slice_bang, MRB_ARGS_ARG(1,1)); + mrb_define_method(mrb, a, "slice!", mrb_ary_slice_bang, MRB_ARGS_ARG(1,1)); + mrb_define_method(mrb, a, "compact", mrb_ary_compact, MRB_ARGS_NONE()); + mrb_define_method(mrb, a, "compact!", mrb_ary_compact_bang, MRB_ARGS_NONE()); + mrb_define_method(mrb, a, "rotate", mrb_ary_rotate, MRB_ARGS_OPT(1)); + mrb_define_method(mrb, a, "rotate!", mrb_ary_rotate_bang, MRB_ARGS_OPT(1)); } void diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c index 4d139aa76..55c6cd125 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c @@ -14,30 +14,49 @@ #include <mruby/variable.h> #include "mrdberror.h" #include "apibreak.h" +#include "apistring.h" #define MAX_BREAKPOINTNO (MAX_BREAKPOINT * 1024) #define MRB_DEBUG_BP_FILE_OK (0x0001) #define MRB_DEBUG_BP_LINENO_OK (0x0002) +uint32_t mrb_packed_int_decode(uint8_t *p, uint8_t **newpos); + static uint16_t check_lineno(mrb_irep_debug_info_file *info_file, uint16_t lineno) { uint32_t count = info_file->line_entry_count; uint16_t l_idx; - if (info_file->line_type == mrb_debug_line_ary) { + switch (info_file->line_type) { + case mrb_debug_line_ary: for (l_idx = 0; l_idx < count; ++l_idx) { if (lineno == info_file->lines.ary[l_idx]) { return lineno; } } - } - else { + break; + + case mrb_debug_line_flat_map: for (l_idx = 0; l_idx < count; ++l_idx) { if (lineno == info_file->lines.flat_map[l_idx].line) { return lineno; } } + break; + + case mrb_debug_line_packed_map: + { + uint8_t *p = info_file->lines.packed_map; + uint8_t *pend = p + count; + uint32_t line = 0; + while (p < pend) { + mrb_packed_int_decode(p, &p); + line += mrb_packed_int_decode(p, &p); + if (line == lineno) return lineno; + } + } + break; } return 0; @@ -173,7 +192,6 @@ mrb_debug_set_break_line(mrb_state *mrb, mrb_debug_context *dbg, const char *fil int32_t index; char* set_file; uint16_t result; - size_t len; if ((mrb == NULL)||(dbg == NULL)||(file == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; @@ -187,7 +205,7 @@ mrb_debug_set_break_line(mrb_state *mrb, mrb_debug_context *dbg, const char *fil return MRB_DEBUG_BREAK_NO_OVER; } - /* file and lineno check (line type mrb_debug_line_ary only.) */ + /* file and lineno check. */ result = check_file_lineno(mrb, dbg->root_irep, file, lineno); if (result == 0) { return MRB_DEBUG_BREAK_INVALID_FILE; @@ -196,8 +214,7 @@ mrb_debug_set_break_line(mrb_state *mrb, mrb_debug_context *dbg, const char *fil return MRB_DEBUG_BREAK_INVALID_LINENO; } - len = strlen(file) + 1; - set_file = (char*)mrb_malloc(mrb, len); + set_file = mrdb_strdup(mrb, file); index = dbg->bpnum; dbg->bp[index].bpno = dbg->next_bpno; @@ -207,8 +224,6 @@ mrb_debug_set_break_line(mrb_state *mrb, mrb_debug_context *dbg, const char *fil dbg->bp[index].point.linepoint.lineno = lineno; dbg->bpnum++; - strncpy(set_file, file, len); - dbg->bp[index].point.linepoint.file = set_file; return dbg->bp[index].bpno; @@ -220,7 +235,6 @@ mrb_debug_set_break_method(mrb_state *mrb, mrb_debug_context *dbg, const char *c int32_t index; char* set_class; char* set_method; - size_t len; if ((mrb == NULL) || (dbg == NULL) || (method_name == NULL)) { return MRB_DEBUG_INVALID_ARGUMENT; @@ -235,18 +249,16 @@ mrb_debug_set_break_method(mrb_state *mrb, mrb_debug_context *dbg, const char *c } if (class_name != NULL) { - len = strlen(class_name) + 1; - set_class = (char*)mrb_malloc(mrb, len); - strncpy(set_class, class_name, len); + set_class = mrdb_strdup(mrb, class_name); } else { set_class = NULL; } - len = strlen(method_name) + 1; - set_method = (char*)mrb_malloc(mrb, len); - - strncpy(set_method, method_name, len); + set_method = mrdb_strdup(mrb, method_name); + if (set_method == NULL) { + mrb_free(mrb, set_class); + } index = dbg->bpnum; dbg->bp[index].bpno = dbg->next_bpno; @@ -332,10 +344,10 @@ mrb_debug_delete_break(mrb_state *mrb, mrb_debug_context *dbg, uint32_t bpno) for(i = index ; i < dbg->bpnum; i++) { if ((i + 1) == dbg->bpnum) { - memset(&dbg->bp[i], 0, sizeof(mrb_debug_breakpoint)); + dbg->bp[i] = (mrb_debug_breakpoint){0}; } else { - memcpy(&dbg->bp[i], &dbg->bp[i + 1], sizeof(mrb_debug_breakpoint)); + dbg->bp[i] = dbg->bp[i + 1]; } } diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c index 66ddfa783..27db02b48 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c @@ -3,12 +3,12 @@ */ #include <ctype.h> -#include <stdlib.h> #include <string.h> #include "mrdb.h" #include "mrdberror.h" #include "apilist.h" +#include "apistring.h" #include <mruby/compile.h> #include <mruby/irep.h> #include <mruby/debug.h> @@ -65,7 +65,6 @@ dirname(mrb_state *mrb, const char *path) { size_t len; const char *p; - char *dir; if (path == NULL) { return NULL; @@ -74,11 +73,7 @@ dirname(mrb_state *mrb, const char *path) p = strrchr(path, '/'); len = p != NULL ? (size_t)(p - path) : strlen(path); - dir = (char*)mrb_malloc(mrb, len + 1); - strncpy(dir, path, len); - dir[len] = '\0'; - - return dir; + return mrdb_strndup(mrb, path, len); } static source_file* @@ -97,8 +92,11 @@ source_file_new(mrb_state *mrb, mrb_debug_context *dbg, char *filename) } file->lineno = 1; - file->path = (char*)mrb_malloc(mrb, strlen(filename) + 1); - strcpy(file->path, filename); + file->path = mrdb_strdup(mrb, filename); + if (file->path == NULL) { + source_file_free(mrb, file); + return NULL; + } return file; } diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apistring.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apistring.c new file mode 100644 index 000000000..a7b320ade --- /dev/null +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apistring.c @@ -0,0 +1,34 @@ +/* +** apistring.c +** +*/ + +#include <string.h> +#include "apistring.h" + +static size_t +mrb_debug_strnlen(const char *s, size_t maxlen) +{ + const char *p = (const char*)memchr(s, '\0', maxlen); + return p != NULL ? (size_t)(p - s) : maxlen; +} + +char* +mrdb_strndup(mrb_state *mrb, const char *s, size_t size) +{ + size_t l = mrb_debug_strnlen(s, size); + char *d = (char*)mrb_malloc_simple(mrb, l + 1); + if (d != NULL) { + memcpy(d, s, l); + d[l] = '\0'; + } + return d; +} + +char* +mrdb_strdup(mrb_state *mrb, const char *s) +{ + size_t z = strlen(s) + 1; + char *d = (char*)mrb_malloc_simple(mrb, z); + return d != NULL ? (char*)memcpy(d, s, z) : NULL; +} diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apistring.h b/mrbgems/mruby-bin-debugger/tools/mrdb/apistring.h new file mode 100644 index 000000000..33737e7fd --- /dev/null +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apistring.h @@ -0,0 +1,14 @@ +/* + * apistring.h + */ + +#ifndef APISTRING_H_ +#define APISTRING_H_ + +#include "mruby.h" + +/* both functions return a null pointer on failure */ +char *mrdb_strndup(mrb_state *mrb, const char *s, size_t size); +char *mrdb_strdup(mrb_state *mrb, const char *s); + +#endif /* APISTRING_H_ */ diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c index a05ff9415..0714f3f21 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c @@ -8,6 +8,7 @@ #include <string.h> #include "apilist.h" +#include "apistring.h" #include <mruby/compile.h> typedef struct help_msg { @@ -140,7 +141,8 @@ static listcmd_parser_state* listcmd_parser_state_new(mrb_state *mrb) { listcmd_parser_state *st = (listcmd_parser_state*)mrb_malloc(mrb, sizeof(listcmd_parser_state)); - memset(st, 0, sizeof(listcmd_parser_state)); + static const listcmd_parser_state st_zero = {0}; + *st = st_zero; return st; } @@ -232,10 +234,7 @@ parse_filename(mrb_state *mrb, char **sp, listcmd_parser_state *st) len = strlen(*sp); } - if (len > 0) { - st->filename = (char*)mrb_malloc(mrb, len + 1); - strncpy(st->filename, *sp, len); - st->filename[len] = '\0'; + if (len > 0 && (st->filename = mrdb_strndup(mrb, *sp, len)) != NULL) { *sp += len; return TRUE; } diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c index 009cd955c..ee2ae0aca 100644 --- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c +++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c @@ -186,9 +186,9 @@ static mrb_debug_context* mrb_debug_context_new(mrb_state *mrb) { mrb_debug_context *dbg = (mrb_debug_context*)mrb_malloc(mrb, sizeof(mrb_debug_context)); + static const mrb_debug_context dbg_zero = {0}; - memset(dbg, 0, sizeof(mrb_debug_context)); - + *dbg = dbg_zero; dbg->xm = DBG_INIT; dbg->xphase = DBG_PHASE_BEFORE_RUN; dbg->next_bpno = 1; @@ -225,9 +225,9 @@ static mrdb_state* mrdb_state_new(mrb_state *mrb) { mrdb_state *mrdb = (mrdb_state*)mrb_malloc(mrb, sizeof(mrdb_state)); + static const mrdb_state mrdb_zero = {0}; - memset(mrdb, 0, sizeof(mrdb_state)); - + *mrdb = mrdb_zero; mrdb->dbg = mrb_debug_context_get(mrb); mrdb->command = (char*)mrb_malloc(mrb, MAX_COMMAND_LINE+1); mrdb->print_no = 1; @@ -574,7 +574,7 @@ mrb_code_fetch_hook(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mr switch (dbg->xm) { case DBG_STEP: - if (!file || (dbg->prvfile == file && dbg->prvline == line)) { + if (*pc != OP_JMP && (!file || (dbg->prvfile == file && dbg->prvline == line))) { return; } dbg->method_bpno = 0; diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c index 464df1c24..db92d7266 100644 --- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c +++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c @@ -134,7 +134,7 @@ p(mrb_state *mrb, mrb_value obj, int prompt) } /* Guess if the user might want to enter more - * or if he wants an evaluation of his code now */ + * or if they wants an evaluation of their code now */ static mrb_bool is_code_block_open(struct mrb_parser_state *parser) { diff --git a/mrbgems/mruby-binding-core/src/binding-core.c b/mrbgems/mruby-binding-core/src/binding-core.c index 1454f5945..5e104e720 100644 --- a/mrbgems/mruby-binding-core/src/binding-core.c +++ b/mrbgems/mruby-binding-core/src/binding-core.c @@ -24,16 +24,16 @@ binding_extract_pc(mrb_state *mrb, mrb_value binding) } } -static const struct RProc * -binding_extract_proc(mrb_state *mrb, mrb_value binding) +const struct RProc * +mrb_binding_extract_proc(mrb_state *mrb, mrb_value binding) { mrb_value obj = mrb_iv_get(mrb, binding, MRB_SYM(proc)); mrb_check_type(mrb, obj, MRB_TT_PROC); return mrb_proc_ptr(obj); } -static struct REnv * -binding_extract_env(mrb_state *mrb, mrb_value binding) +struct REnv * +mrb_binding_extract_env(mrb_state *mrb, mrb_value binding) { mrb_value obj = mrb_iv_get(mrb, binding, MRB_SYM(env)); if (mrb_nil_p(obj)) { @@ -108,8 +108,8 @@ binding_local_variable_defined_p(mrb_state *mrb, mrb_value self) mrb_sym varname; mrb_get_args(mrb, "n", &varname); - const struct RProc *proc = binding_extract_proc(mrb, self); - struct REnv *env = binding_extract_env(mrb, self); + const struct RProc *proc = mrb_binding_extract_proc(mrb, self); + struct REnv *env = mrb_binding_extract_env(mrb, self); mrb_value *e = binding_local_variable_search(mrb, proc, env, varname); if (e) { return mrb_true_value(); @@ -129,8 +129,8 @@ binding_local_variable_get(mrb_state *mrb, mrb_value self) mrb_sym varname; mrb_get_args(mrb, "n", &varname); - const struct RProc *proc = binding_extract_proc(mrb, self); - struct REnv *env = binding_extract_env(mrb, self); + const struct RProc *proc = mrb_binding_extract_proc(mrb, self); + struct REnv *env = mrb_binding_extract_env(mrb, self); mrb_value *e = binding_local_variable_search(mrb, proc, env, varname); if (!e) { mrb_raisef(mrb, E_NAME_ERROR, "local variable %!n is not defined", varname); @@ -146,11 +146,14 @@ binding_local_variable_set(mrb_state *mrb, mrb_value self) mrb_value obj; mrb_get_args(mrb, "no", &varname, &obj); - const struct RProc *proc = binding_extract_proc(mrb, self); - struct REnv *env = binding_extract_env(mrb, self); + const struct RProc *proc = mrb_binding_extract_proc(mrb, self); + struct REnv *env = mrb_binding_extract_env(mrb, self); mrb_value *e = binding_local_variable_search(mrb, proc, env, varname); if (e) { *e = obj; + if (!mrb_immediate_p(obj)) { + mrb_field_write_barrier(mrb, (struct RBasic*)env, (struct RBasic*)mrb_obj_ptr(obj)); + } } else { mrb_proc_merge_lvar(mrb, (mrb_irep*)proc->body.irep, env, 1, &varname, &obj); @@ -184,7 +187,7 @@ binding_source_location(mrb_state *mrb, mrb_value self) } mrb_value srcloc; - const struct RProc *proc = binding_extract_proc(mrb, self); + const struct RProc *proc = mrb_binding_extract_proc(mrb, self); if (!proc || MRB_PROC_CFUNC_P(proc) || !proc->upper || MRB_PROC_CFUNC_P(proc->upper)) { srcloc = mrb_nil_value(); @@ -217,7 +220,7 @@ binding_source_location(mrb_state *mrb, mrb_value self) mrb_value mrb_binding_alloc(mrb_state *mrb) { - struct RObject *obj = (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mrb_class_get_id(mrb, MRB_SYM(Binding))); + struct RObject *obj = MRB_OBJ_ALLOC(mrb, MRB_TT_OBJECT, mrb_class_get_id(mrb, MRB_SYM(Binding))); return mrb_obj_value(obj); } @@ -231,7 +234,7 @@ mrb_binding_wrap_lvspace(mrb_state *mrb, const struct RProc *proc, struct REnv * static const mrb_code iseq_dummy[] = { OP_RETURN, 0 }; - struct RProc *lvspace = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class); + struct RProc *lvspace = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class); mrb_irep *irep = mrb_add_irep(mrb); irep->flags = MRB_ISEQ_NO_FREE; irep->iseq = iseq_dummy; @@ -246,7 +249,7 @@ mrb_binding_wrap_lvspace(mrb_state *mrb, const struct RProc *proc, struct REnv * lvspace->flags |= MRB_PROC_ENVSET; } - *envp = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, NULL); + *envp = MRB_OBJ_ALLOC(mrb, MRB_TT_ENV, NULL); (*envp)->stack = (mrb_value*)mrb_calloc(mrb, 1, sizeof(mrb_value)); (*envp)->stack[0] = lvspace->e.env ? lvspace->e.env->stack[0] : mrb_nil_value(); (*envp)->cxt = lvspace->e.env ? lvspace->e.env->cxt : mrb->c; diff --git a/mrbgems/mruby-binding/mrblib/binding.rb b/mrbgems/mruby-binding/mrblib/binding.rb deleted file mode 100644 index b07480db1..000000000 --- a/mrbgems/mruby-binding/mrblib/binding.rb +++ /dev/null @@ -1,5 +0,0 @@ -class Binding - def eval(expr, *args) - Kernel.eval(expr, self, *args) - end -end diff --git a/mrbgems/mruby-binding/src/binding.c b/mrbgems/mruby-binding/src/binding.c new file mode 100644 index 000000000..67692e2b9 --- /dev/null +++ b/mrbgems/mruby-binding/src/binding.c @@ -0,0 +1,173 @@ +#include <mruby.h> +#include <mruby/array.h> +#include <mruby/class.h> +#include <mruby/compile.h> +#include <mruby/error.h> +#include <mruby/proc.h> +#include <mruby/presym.h> +#include <mruby/string.h> + +mrb_noreturn void mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args); +void mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, const mrb_sym *lv, const mrb_value *stack); +mrb_value mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p); +const struct RProc *mrb_binding_extract_proc(mrb_state *mrb, mrb_value binding); +struct REnv *mrb_binding_extract_env(mrb_state *mrb, mrb_value binding); +typedef mrb_bool mrb_parser_foreach_top_variable_func(mrb_state *mrb, mrb_sym sym, void *user); +void mrb_parser_foreach_top_variable(mrb_state *mrb, struct mrb_parser_state *p, mrb_parser_foreach_top_variable_func *func, void *user); + +static void +insert_args(mrb_state *mrb, size_t offset, mrb_value obj) +{ + mrb_callinfo *ci = mrb->c->ci; + mrb_value *argp = ci->stack + 1 /* recv */; + + if (ci->argc < 0) { + mrb_ary_splice(mrb, *argp, offset, 0, obj); + } + else { + argp += offset; + mrb_stack_extend(mrb, ci->argc + offset + 2 /* recv + block */); + memmove(argp + 1 /* obj */, argp, sizeof(mrb_value) * (ci->argc - offset + 1 /* block */)); + *argp = obj; + ci->argc++; + } +} + +static void +binding_eval_error_check(mrb_state *mrb, struct mrb_parser_state *p, const char *file) +{ + if (!p) { + mrb_raise(mrb, E_RUNTIME_ERROR, "Failed to create parser state (out of memory)"); + } + + if (0 < p->nerr) { + mrb_value str; + + if (file) { + str = mrb_format(mrb, "file %s line %d: %s", + file, + p->error_buffer[0].lineno, + p->error_buffer[0].message); + } + else { + str = mrb_format(mrb, "line %d: %s", + p->error_buffer[0].lineno, + p->error_buffer[0].message); + } + mrb_exc_raise(mrb, mrb_exc_new_str(mrb, E_SYNTAX_ERROR, str)); + } +} + +#define LV_BUFFERS 8 + +struct expand_lvspace { + mrb_irep *irep; + struct REnv *env; + size_t numvar; + mrb_sym syms[LV_BUFFERS]; +}; + +static mrb_bool +expand_lvspace(mrb_state *mrb, mrb_sym sym, void *user) +{ + struct expand_lvspace *p = (struct expand_lvspace*)user; + mrb_int symlen; + const char *symname = mrb_sym_name_len(mrb, sym, &symlen); + + if (symname && symlen > 0) { + if (symname[0] != '&' && symname[0] != '*') { + p->syms[p->numvar++] = sym; + if (p->numvar >= LV_BUFFERS) { + mrb_proc_merge_lvar(mrb, p->irep, p->env, p->numvar, p->syms, NULL); + p->numvar = 0; + } + } + } + + return TRUE; +} + +struct binding_eval_prepare_body { + mrb_value binding; + const char *file; + const char *expr; + mrb_int exprlen; + mrbc_context *mrbc; + struct mrb_parser_state *pstate; +}; + +static mrb_value +binding_eval_prepare_body(mrb_state *mrb, void *opaque) +{ + struct binding_eval_prepare_body *p = (struct binding_eval_prepare_body*)opaque; + + const struct RProc *proc = mrb_binding_extract_proc(mrb, p->binding); + mrb_assert(!MRB_PROC_CFUNC_P(proc)); + + p->mrbc = mrbc_context_new(mrb); + mrbc_filename(mrb, p->mrbc, p->file ? p->file : "(eval)"); + p->mrbc->upper = proc; + p->mrbc->capture_errors = TRUE; + p->pstate = mrb_parse_nstring(mrb, p->expr, p->exprlen, p->mrbc); + binding_eval_error_check(mrb, p->pstate, p->file); + + struct expand_lvspace args = { + (mrb_irep*)proc->body.irep, + mrb_binding_extract_env(mrb, p->binding), + 0, + { 0 } + }; + mrb_parser_foreach_top_variable(mrb, p->pstate, expand_lvspace, &args); + if (args.numvar > 0) { + mrb_proc_merge_lvar(mrb, args.irep, args.env, args.numvar, args.syms, NULL); + } + + return mrb_nil_value(); +} + +static void +binding_eval_prepare(mrb_state *mrb, mrb_value binding) +{ + struct binding_eval_prepare_body d = { binding, NULL, NULL, 0, NULL, NULL }; + mrb_int argc; + mrb_value *argv; + mrb_get_args(mrb, "s|z*!", &d.expr, &d.exprlen, &d.file, &argv, &argc); + + mrb_bool error; + mrb_value ret = mrb_protect_error(mrb, binding_eval_prepare_body, &d, &error); + if (d.pstate) mrb_parser_free(d.pstate); + if (d.mrbc) mrbc_context_free(mrb, d.mrbc); + if (error) mrb_exc_raise(mrb, ret); +} + +static mrb_value +mrb_binding_eval(mrb_state *mrb, mrb_value binding) +{ + binding_eval_prepare(mrb, binding); + + struct RClass *c = mrb->kernel_module; + mrb_method_t m = mrb_method_search_vm(mrb, &c, MRB_SYM(eval)); + if (MRB_METHOD_UNDEF_P(m)) { + int argc = mrb->c->ci->argc; + mrb_value *argv = mrb->c->ci->stack + 1; + mrb_value args = (argc < 0) ? argv[0] : mrb_ary_new_from_values(mrb, argc, argv); + mrb_method_missing(mrb, MRB_SYM(eval), binding, args); + } + + insert_args(mrb, 1, binding); + struct RProc *proc = MRB_METHOD_PROC_P(m) ? MRB_METHOD_PROC(m) : mrb_proc_new_cfunc(mrb, MRB_METHOD_FUNC(m)); + mrb->c->ci->u.target_class = c; + return mrb_exec_irep(mrb, binding, proc); +} + +void +mrb_mruby_binding_gem_init(mrb_state *mrb) +{ + struct RClass *binding = mrb_class_get_id(mrb, MRB_SYM(Binding)); + mrb_define_method(mrb, binding, "eval", mrb_binding_eval, MRB_ARGS_ANY()); +} + +void +mrb_mruby_binding_gem_final(mrb_state *mrb) +{ +} diff --git a/mrbgems/mruby-binding/test/binding.rb b/mrbgems/mruby-binding/test/binding.rb index 7dd3fd1dd..bfae84c59 100644 --- a/mrbgems/mruby-binding/test/binding.rb +++ b/mrbgems/mruby-binding/test/binding.rb @@ -43,13 +43,6 @@ assert("Binding#local_variable_get") do } end -assert("Binding#source_location") do - skip unless -> {}.source_location - - bind, source_location = binding, [__FILE__, __LINE__] - assert_equal source_location, bind.source_location -end - assert "Kernel#binding and .eval from C" do bind = binding_in_c assert_equal 5, bind.eval("2 + 3") @@ -68,3 +61,10 @@ assert "Binding#eval with Binding.new via Method" do assert_true true end + +assert "access local variables into procs" do + bx = binding + block = bx.eval("a = 1; proc { a }") + bx.eval("a = 2") + assert_equal 2, block.call +end diff --git a/mrbgems/mruby-catch/src/catch.c b/mrbgems/mruby-catch/src/catch.c index d54c49dfe..048a44738 100644 --- a/mrbgems/mruby-catch/src/catch.c +++ b/mrbgems/mruby-catch/src/catch.c @@ -92,7 +92,7 @@ mrb_f_throw(mrb_state *mrb, mrb_value self) const mrb_callinfo *ci = find_catcher(mrb, tag); if (ci) { - struct RBreak *b = (struct RBreak *)mrb_obj_alloc(mrb, MRB_TT_BREAK, NULL); + struct RBreak *b = MRB_OBJ_ALLOC(mrb, MRB_TT_BREAK, NULL); mrb_break_value_set(b, obj); mrb_break_proc_set(b, ci[2].proc); /* Back to the closure in `catch` method */ mrb_exc_raise(mrb, mrb_obj_value(b)); diff --git a/mrbgems/mruby-class-ext/src/class.c b/mrbgems/mruby-class-ext/src/class.c index 39c16fc48..290ddf4b3 100644 --- a/mrbgems/mruby-class-ext/src/class.c +++ b/mrbgems/mruby-class-ext/src/class.c @@ -49,7 +49,7 @@ mrb_mod_module_exec(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "*&!", &argv, &argc, &blk); c = mrb_class_ptr(self); - if (mrb->c->ci->acc < 0) { + if (mrb->c->ci->cci > 0) { return mrb_yield_with_class(mrb, blk, argc, argv, self, c); } mrb_vm_ci_target_class_set(mrb->c->ci, c); diff --git a/mrbgems/mruby-cmath/src/cmath.c b/mrbgems/mruby-cmath/src/cmath.c index 03b181840..8b0c4d04a 100644 --- a/mrbgems/mruby-cmath/src/cmath.c +++ b/mrbgems/mruby-cmath/src/cmath.c @@ -15,7 +15,6 @@ # error CMath conflicts with 'MRB_NO_FLOAT' configuration #endif -#include <math.h> #include <complex.h> mrb_value mrb_complex_new(mrb_state *mrb, mrb_float real, mrb_float imag); diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 12f7c3b3f..42c93debf 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -4,10 +4,6 @@ ** See Copyright Notice in mruby.h */ -#include <ctype.h> -#include <stdlib.h> -#include <string.h> -#include <math.h> #include <mruby.h> #include <mruby/compile.h> #include <mruby/proc.h> @@ -20,6 +16,8 @@ #include <mruby/opcode.h> #include <mruby/re.h> #include <mruby/throw.h> +#include <ctype.h> +#include <string.h> #ifndef MRB_CODEGEN_LEVEL_MAX #define MRB_CODEGEN_LEVEL_MAX 1024 @@ -40,15 +38,16 @@ enum looptype { struct loopinfo { enum looptype type; - uint32_t pc0, pc1, pc2, pc3; - int acc; + uint32_t pc0; /* `next` destination */ + uint32_t pc1; /* `redo` destination */ + uint32_t pc2; /* `break` destination */ + int reg; /* destination register */ struct loopinfo *prev; }; typedef struct scope { mrb_state *mrb; mrb_pool *mpool; - struct mrb_jmpbuf jmp; struct scope *prev; @@ -147,7 +146,7 @@ codegen_error(codegen_scope *s, const char *message) fprintf(stderr, "%s\n", message); } #endif - MRB_THROW(&s->jmp); + MRB_THROW(s->mrb->jmp); } static void* @@ -237,7 +236,9 @@ genop_1(codegen_scope *s, mrb_code i, uint16_t a) { s->lastpc = s->pc; if (a > 0xff) { - codegen_error(s, "too big operand"); + gen_B(s, OP_EXT1); + gen_B(s, i); + gen_S(s, a); } else { gen_B(s, i); @@ -249,30 +250,24 @@ 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) { - codegen_error(s, "too big operand"); - } - else { + if (a > 0xff && b > 0xff) { + gen_B(s, OP_EXT3); gen_B(s, i); - gen_B(s, (uint8_t)a); - gen_B(s, (uint8_t)b); - } -} - -/* similar to `genop_2` but generate `genop_2S` with `i+1` */ -/* works for OP_LOADL, OP_LOADSYM, OP_STRING */ -static void -genop_bs(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b) -{ - s->lastpc = s->pc; - if (a > 0xff || b > 0xffff) { - codegen_error(s, "too big operand"); + gen_S(s, a); + gen_S(s, b); } - if (b > 0xff) { - gen_B(s, i+1); + 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); + } else { gen_B(s, i); gen_B(s, (uint8_t)a); @@ -331,6 +326,8 @@ struct mrb_insn_data mrb_decode_insn(const mrb_code *pc) { struct mrb_insn_data data = { 0 }; + if (pc == 0) return data; + data.addr = pc; mrb_code insn = READ_B(); uint16_t a = 0; uint16_t b = 0; @@ -341,6 +338,32 @@ 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; } @@ -351,13 +374,101 @@ mrb_decode_insn(const mrb_code *pc) return data; } +#undef OPCODE +#define Z 1 +#define S 3 +#define W 4 +#define OPCODE(_,x) x, +/* instruction sizes */ +static uint8_t mrb_insn_size[] = { +#define B 2 +#define BB 3 +#define BBB 4 +#define BS 4 +#define BSS 6 +#include "mruby/ops.h" +#undef B +#undef BB +#undef BBB +#undef BS +#undef BSS +}; +/* EXT1 instruction sizes */ +static uint8_t mrb_insn_size1[] = { +#define B 3 +#define BB 4 +#define BBB 5 +#define BS 5 +#define BSS 7 +#include "mruby/ops.h" +#undef B +#undef BS +#undef BSS +}; +/* EXT2 instruction sizes */ +static uint8_t mrb_insn_size2[] = { +#define B 2 +#define BS 4 +#define BSS 6 +#include "mruby/ops.h" +#undef B +#undef BB +#undef BBB +#undef BS +#undef BSS +}; +/* EXT3 instruction sizes */ +#define B 3 +#define BB 5 +#define BBB 6 +#define BS 5 +#define BSS 7 +static uint8_t mrb_insn_size3[] = { +#include "mruby/ops.h" +}; +#undef B +#undef BB +#undef BBB +#undef BS +#undef BSS +#undef OPCODE + +static const mrb_code* +mrb_prev_pc(codegen_scope *s, const mrb_code *pc) +{ + const mrb_code *prev_pc = NULL; + const mrb_code *i = s->iseq; + + while (i<pc) { + uint8_t insn = i[0]; + prev_pc = i; + switch (insn) { + case OP_EXT1: + i += mrb_insn_size1[i[1]] + 1; + break; + case OP_EXT2: + i += mrb_insn_size2[i[1]] + 1; + break; + case OP_EXT3: + i += mrb_insn_size3[i[1]] + 1; + break; + default: + i += mrb_insn_size[insn]; + break; + } + } + return prev_pc; +} + +#define pc_addr(s) &((s)->iseq[(s)->pc]) +#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq) +#define rewind_pc(s) s->pc = s->lastpc + static struct mrb_insn_data mrb_last_insn(codegen_scope *s) { - if (s->pc == s->lastpc) { - struct mrb_insn_data data; - - data.insn = OP_NOP; + if (s->pc == 0) { + struct mrb_insn_data data = { OP_NOP, 0 }; return data; } return mrb_decode_insn(&s->iseq[s->lastpc]); @@ -376,17 +487,15 @@ gen_jmpdst(codegen_scope *s, uint32_t pc) { if (pc == JMPLINK_START) { - gen_S(s, 0); + pc = 0; } - else { - uint32_t pos2 = s->pc+2; - int32_t off = pc - pos2; + uint32_t pos2 = s->pc+2; + int32_t off = pc - pos2; - if (off > INT16_MAX || INT16_MIN > off) { - codegen_error(s, "too big jump offset"); - } - gen_S(s, (uint16_t)off); + if (off > INT16_MAX || INT16_MIN > off) { + codegen_error(s, "too big jump offset"); } + gen_S(s, (uint16_t)off); } static uint32_t @@ -394,8 +503,7 @@ genjmp(codegen_scope *s, mrb_code i, uint32_t pc) { uint32_t pos; - s->lastpc = s->pc; - gen_B(s, i); + genop_0(s, i); pos = s->pc; gen_jmpdst(s, pc); return pos; @@ -411,36 +519,64 @@ genjmp2(codegen_scope *s, mrb_code i, uint16_t a, uint32_t pc, int val) if (!no_peephole(s) && !val) { struct mrb_insn_data data = mrb_last_insn(s); - if (data.insn == OP_MOVE && data.a == a) { - s->pc = s->lastpc; - a = data.b; + switch (data.insn) { + case OP_MOVE: + if (data.a == a && data.a > s->nlocals) { + rewind_pc(s); + a = data.b; + } + break; + case OP_LOADNIL: + case OP_LOADF: + if (data.a == a || data.a > s->nlocals) { + s->pc = addr_pc(s, data.addr); + if (i == OP_JMPNOT || (i == OP_JMPNIL && data.insn == OP_LOADNIL)) { + return genjmp(s, OP_JMP, pc); + } + else { /* OP_JMPIF */ + return JMPLINK_START; + } + } + break; + case OP_LOADT: case OP_LOADI: case OP_LOADINEG: case OP_LOADI__1: + case OP_LOADI_0: case OP_LOADI_1: case OP_LOADI_2: case OP_LOADI_3: + case OP_LOADI_4: case OP_LOADI_5: case OP_LOADI_6: case OP_LOADI_7: + if (data.a == a || data.a > s->nlocals) { + s->pc = addr_pc(s, data.addr); + if (i == OP_JMPIF) { + return genjmp(s, OP_JMP, pc); + } + else { /* OP_JMPNOT and OP_JMPNIL */ + return JMPLINK_START; + } + } + break; } } - s->lastpc = s->pc; if (a > 0xff) { - codegen_error(s, "too big operand"); - pos = 0; + gen_B(s, OP_EXT1); + genop_0(s, i); + gen_S(s, a); } else { - gen_B(s, i); + genop_0(s, i); gen_B(s, (uint8_t)a); - pos = s->pc; - gen_jmpdst(s, pc); } + pos = s->pc; + gen_jmpdst(s, pc); return pos; } #define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val) +static mrb_bool get_int_operand(codegen_scope *s, struct mrb_insn_data *data, mrb_int *ns); +static void gen_int(codegen_scope *s, uint16_t dst, mrb_int i); + static void gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep) { - if (no_peephole(s)) { - normal: - genop_2(s, OP_MOVE, dst, src); - return; - } + if (nopeep || no_peephole(s)) goto normal; else { struct mrb_insn_data data = mrb_last_insn(s); @@ -454,25 +590,100 @@ gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep) case OP_LOADI__1: case OP_LOADI_0: case OP_LOADI_1: case OP_LOADI_2: case OP_LOADI_3: case OP_LOADI_4: case OP_LOADI_5: case OP_LOADI_6: case OP_LOADI_7: - if (nopeep || data.a != src || data.a < s->nlocals) goto normal; - s->pc = s->lastpc; + if (data.a != src || data.a < s->nlocals) goto normal; + rewind_pc(s); genop_1(s, data.insn, dst); - break; + return; case OP_LOADI: case OP_LOADINEG: case OP_LOADL: case OP_LOADSYM: - case OP_LOADL16: case OP_LOADSYM16: case OP_GETGV: case OP_GETSV: case OP_GETIV: case OP_GETCV: - case OP_GETCONST: case OP_STRING: case OP_STRING16: + case OP_GETCONST: case OP_STRING: case OP_LAMBDA: case OP_BLOCK: case OP_METHOD: case OP_BLKPUSH: - case OP_LAMBDA16: case OP_BLOCK16: case OP_METHOD16: - if (nopeep || data.a != src || data.a < s->nlocals) goto normal; - s->pc = s->lastpc; + if (data.a != src || data.a < s->nlocals) goto normal; + rewind_pc(s); genop_2(s, data.insn, dst, data.b); - break; + return; + case OP_LOADI16: + if (data.a != src || data.a < s->nlocals) goto normal; + rewind_pc(s); + genop_2S(s, data.insn, dst, data.b); + return; + case OP_LOADI32: + if (data.a != src || data.a < s->nlocals) goto normal; + else { + uint32_t i = (uint32_t)data.b<<16|data.c; + rewind_pc(s); + genop_2SS(s, data.insn, dst, i); + } + return; + case OP_GETUPVAR: + if (data.a != src || data.a < s->nlocals) goto normal; + rewind_pc(s); + genop_3(s, data.insn, dst, data.b, data.c); + return; + case OP_ADDI: case OP_SUBI: + if (addr_pc(s, data.addr) == s->lastlabel || data.a != src || data.a < s->nlocals) goto normal; + else { + struct mrb_insn_data data0 = mrb_decode_insn(mrb_prev_pc(s, data.addr)); + if (data0.insn != OP_MOVE || data0.a != data.a || data0.b != dst) goto normal; + s->pc = addr_pc(s, data0.addr); + if (addr_pc(s, data0.addr) != s->lastlabel) { + /* constant folding */ + data0 = mrb_decode_insn(mrb_prev_pc(s, data0.addr)); + mrb_int n; + if (data0.a == dst && get_int_operand(s, &data0, &n)) { + if ((data.insn == OP_ADDI && !mrb_int_add_overflow(n, data.b, &n)) || + (data.insn == OP_SUBI && !mrb_int_sub_overflow(n, data.b, &n))) { + s->pc = addr_pc(s, data0.addr); + gen_int(s, dst, n); + return; + } + } + } + } + genop_2(s, data.insn, dst, data.b); + return; default: - goto normal; + break; + } + } + normal: + genop_2(s, OP_MOVE, dst, src); + return; +} + +static int search_upvar(codegen_scope *s, mrb_sym id, int *idx); + +static void +gen_getupvar(codegen_scope *s, uint16_t dst, mrb_sym id) +{ + int idx; + int lv = search_upvar(s, id, &idx); + + if (!no_peephole(s)) { + struct mrb_insn_data data = mrb_last_insn(s); + if (data.insn == OP_SETUPVAR && data.a == dst && data.b == idx && data.c == lv) { + /* skip GETUPVAR right after SETUPVAR */ + return; + } + } + genop_3(s, OP_GETUPVAR, dst, idx, lv); +} + +static void +gen_setupvar(codegen_scope *s, uint16_t dst, mrb_sym id) +{ + int idx; + int lv = search_upvar(s, id, &idx); + + if (!no_peephole(s)) { + struct mrb_insn_data data = mrb_last_insn(s); + if (data.insn == OP_MOVE && data.a == dst) { + dst = data.b; + rewind_pc(s); } } + genop_3(s, OP_SETUPVAR, dst, idx, lv); } static void @@ -485,7 +696,7 @@ gen_return(codegen_scope *s, uint8_t op, uint16_t src) struct mrb_insn_data data = mrb_last_insn(s); if (data.insn == OP_MOVE && src == data.a) { - s->pc = s->lastpc; + rewind_pc(s); genop_1(s, op, data.b); } else if (data.insn != OP_RETURN) { @@ -494,6 +705,55 @@ gen_return(codegen_scope *s, uint8_t op, uint16_t src) } } +static mrb_bool +get_int_operand(codegen_scope *s, struct mrb_insn_data *data, mrb_int *n) +{ + switch (data->insn) { + case OP_LOADI__1: + *n = -1; + return TRUE; + + case OP_LOADINEG: + *n = -data->b; + return TRUE; + + case OP_LOADI_0: case OP_LOADI_1: case OP_LOADI_2: case OP_LOADI_3: + case OP_LOADI_4: case OP_LOADI_5: case OP_LOADI_6: case OP_LOADI_7: + *n = data->insn - OP_LOADI_0; + return TRUE; + + case OP_LOADI: + case OP_LOADI16: + *n = data->b; + return TRUE; + + case OP_LOADI32: + *n = (mrb_int)((uint32_t)data->b<<16)+data->c; + return TRUE; + + case OP_LOADL: + { + mrb_pool_value *pv = &s->pool[data->b]; + + if (pv->tt == IREP_TT_INT32) { + *n = (mrb_int)pv->u.i32; + } +#ifdef MRB_INT64 + else if (pv->tt == IREP_TT_INT64) { + *n = (mrb_int)pv->u.i64; + } +#endif + else { + return FALSE; + } + } + return TRUE; + + default: + return FALSE; + } +} + static void gen_addsub(codegen_scope *s, uint8_t op, uint16_t dst) { @@ -504,31 +764,119 @@ gen_addsub(codegen_scope *s, uint8_t op, uint16_t dst) } else { struct mrb_insn_data data = mrb_last_insn(s); + mrb_int n; - switch (data.insn) { - case OP_LOADI__1: - if (op == OP_ADD) op = OP_SUB; - else op = OP_ADD; - data.b = 1; - goto replace; - case OP_LOADI_0: case OP_LOADI_1: case OP_LOADI_2: case OP_LOADI_3: - case OP_LOADI_4: case OP_LOADI_5: case OP_LOADI_6: case OP_LOADI_7: - data.b = data.insn - OP_LOADI_0; - /* fall through */ - case OP_LOADI: - replace: - if (data.b >= 128) goto normal; - s->pc = s->lastpc; + if (!get_int_operand(s, &data, &n)) { + /* not integer immediate */ + goto normal; + } + struct mrb_insn_data data0 = mrb_decode_insn(mrb_prev_pc(s, data.addr)); + mrb_int n0; + if (addr_pc(s, data.addr) == s->lastlabel || !get_int_operand(s, &data0, &n0)) { + /* OP_ADDI/OP_SUBI takes upto 16bits */ + if (n > INT16_MAX) goto normal; + rewind_pc(s); if (op == OP_ADD) { - genop_2(s, OP_ADDI, dst, (uint8_t)data.b); + genop_2(s, OP_ADDI, dst, (uint16_t)n); } else { - genop_2(s, OP_SUBI, dst, (uint8_t)data.b); + genop_2(s, OP_SUBI, dst, (uint16_t)n); } - break; - default: + return; + } + if (op == OP_ADD) { + if (mrb_int_add_overflow(n0, n, &n)) goto normal; + } + else { /* OP_SUB */ + if (mrb_int_sub_overflow(n0, n, &n)) goto normal; + } + s->pc = addr_pc(s, data0.addr); + gen_int(s, dst, n); + } +} + +static void +gen_muldiv(codegen_scope *s, uint8_t op, uint16_t dst) +{ + if (no_peephole(s)) { + normal: + genop_1(s, op, dst); + return; + } + else { + struct mrb_insn_data data = mrb_last_insn(s); + mrb_int n, n0; + if (addr_pc(s, data.addr) == s->lastlabel || !get_int_operand(s, &data, &n)) { + /* not integer immediate */ goto normal; } + struct mrb_insn_data data0 = mrb_decode_insn(mrb_prev_pc(s, data.addr)); + if (!get_int_operand(s, &data0, &n0) || n == 0) { + goto normal; + } + if (op == OP_MUL) { + if (mrb_int_mul_overflow(n0, n, &n)) goto normal; + } + else { /* OP_DIV */ + if (n0 == MRB_INT_MIN && n == -1) goto normal; + n = n0 / n; + } + s->pc = addr_pc(s, data0.addr); + gen_int(s, dst, n); + } +} + +mrb_bool mrb_num_shift(mrb_state *mrb, mrb_int val, mrb_int width, mrb_int *num); + +static mrb_bool +gen_binop(codegen_scope *s, mrb_sym op, uint16_t dst) +{ + if (no_peephole(s)) return FALSE; + else { + struct mrb_insn_data data = mrb_last_insn(s); + mrb_int n, n0; + if (addr_pc(s, data.addr) == s->lastlabel || !get_int_operand(s, &data, &n)) { + /* not integer immediate */ + return FALSE; + } + struct mrb_insn_data data0 = mrb_decode_insn(mrb_prev_pc(s, data.addr)); + if (!get_int_operand(s, &data0, &n0)) { + return FALSE; + } + if (op == MRB_OPSYM_2(s->mrb, lshift)) { + if (!mrb_num_shift(s->mrb, n0, n, &n)) return FALSE; + } + else if (op == MRB_OPSYM_2(s->mrb, rshift)) { + if (n == MRB_INT_MIN) return FALSE; + if (!mrb_num_shift(s->mrb, n0, -n, &n)) return FALSE; + } + else if (op == MRB_OPSYM_2(s->mrb, mod) && n != 0) { + if (n0 == MRB_INT_MIN && n == -1) { + n = 0; + } + else { + mrb_int n1 = n0 % n; + if ((n0 < 0) != (n < 0) && n1 != 0) { + n1 += n; + } + n = n1; + } + } + else if (op == MRB_OPSYM_2(s->mrb, and)) { + n = n0 & n; + } + else if (op == MRB_OPSYM_2(s->mrb, or)) { + n = n0 | n; + } + else if (op == MRB_OPSYM_2(s->mrb, xor)) { + n = n0 ^ n; + } + else { + return FALSE; + } + s->pc = addr_pc(s, data0.addr); + gen_int(s, dst, n); + return TRUE; } } @@ -751,6 +1099,66 @@ new_sym(codegen_scope *s, mrb_sym sym) return s->irep->slen++; } +static void +gen_setxv(codegen_scope *s, uint8_t op, uint16_t dst, mrb_sym sym, int val) +{ + int idx = new_sym(s, sym); + if (!val && !no_peephole(s)) { + struct mrb_insn_data data = mrb_last_insn(s); + if (data.insn == OP_MOVE && data.a == dst) { + dst = data.b; + rewind_pc(s); + } + } + genop_2(s, op, dst, idx); +} + +static void +gen_int(codegen_scope *s, uint16_t dst, mrb_int i) +{ + if (i < 0) { + if (i == -1) genop_1(s, OP_LOADI__1, dst); + else if (i >= -0xff) genop_2(s, OP_LOADINEG, dst, (uint16_t)-i); + else if (i >= INT16_MIN) genop_2S(s, OP_LOADI16, dst, (uint16_t)i); + else if (i >= INT32_MIN) genop_2SS(s, OP_LOADI32, dst, (uint32_t)i); + else goto int_lit; + } + else if (i < 8) genop_1(s, OP_LOADI_0 + (uint8_t)i, dst); + else if (i <= 0xff) genop_2(s, OP_LOADI, dst, (uint16_t)i); + else if (i <= INT16_MAX) genop_2S(s, OP_LOADI16, dst, (uint16_t)i); + else if (i <= INT32_MAX) genop_2SS(s, OP_LOADI32, dst, (uint32_t)i); + else { + int_lit: + genop_2(s, OP_LOADL, dst, new_lit(s, mrb_int_value(s->mrb, i))); + } +} + +static mrb_bool +gen_uniop(codegen_scope *s, mrb_sym sym, uint16_t dst) +{ + if (no_peephole(s)) return FALSE; + struct mrb_insn_data data = mrb_last_insn(s); + mrb_int n; + + if (!get_int_operand(s, &data, &n)) return FALSE; + if (sym == MRB_OPSYM_2(s->mrb, plus)) { + /* unary plus does nothing */ + } + else if (sym == MRB_OPSYM_2(s->mrb, minus)) { + if (n == MRB_INT_MIN) return FALSE; + n = -n; + } + else if (sym == MRB_OPSYM_2(s->mrb, neg)) { + n = ~n; + } + else { + return FALSE; + } + s->pc = addr_pc(s, data.addr); + gen_int(s, dst, n); + return TRUE; +} + static int node_len(node *tree) { @@ -807,10 +1215,12 @@ search_upvar(codegen_scope *s, mrb_sym id, int *idx) int i; const mrb_sym *v = ir->lv; - for (i=1; n > 1; n--, v++, i++) { - if (*v == id) { - *idx = i; - return lv - 1; + if (v) { + for (i=1; n > 1; n--, v++, i++) { + if (*v == id) { + *idx = i; + return lv - 1; + } } } if (MRB_PROC_SCOPE_P(u)) break; @@ -848,7 +1258,7 @@ for_body(codegen_scope *s, node *tree) } /* construct loop */ lp = loop_push(s, LOOP_FOR); - lp->pc2 = new_label(s); + lp->pc1 = new_label(s); /* loop body */ codegen(s, tree->cdr->cdr->car, VAL); @@ -883,8 +1293,8 @@ lambda_body(codegen_scope *s, node *tree, int blk) } else { mrb_aspec a; - int ma, oa, ra, pa, ka, kd, ba; - int pos, i; + int ma, oa, ra, pa, ka, kd, ba, i; + uint32_t pos; node *opt; node *margs, *pargs; node *tail; @@ -945,8 +1355,7 @@ lambda_body(codegen_scope *s, node *tree, int blk) gen_move(s, idx, cursp(), 0); } else { - int lv = search_upvar(s, id, &idx); - genop_3(s, OP_GETUPVAR, cursp(), idx, lv); + gen_getupvar(s, cursp(), id); } i++; opt = opt->cdr; @@ -984,8 +1393,7 @@ lambda_body(codegen_scope *s, node *tree, int blk) gen_move(s, idx, cursp(), 0); } else { - int lv = search_upvar(s, kwd_sym, &idx); - genop_3(s, OP_GETUPVAR, cursp(), idx, lv); + gen_getupvar(s, cursp(), kwd_sym); } jmp_def_set = genjmp_0(s, OP_JMP); dispatch(s, jmpif_key_p); @@ -1092,68 +1500,70 @@ attrsym(codegen_scope *s, mrb_sym a) } #define CALL_MAXARGS 127 +#define GEN_LIT_ARY_MAX 64 +#define GEN_VAL_STACK_MAX 99 static int -gen_values(codegen_scope *s, node *t, int val, int extra) +gen_values(codegen_scope *s, node *t, int val, int extra, int limit) { int n = 0; - int is_splat; + int first = 1; + int slimit = GEN_VAL_STACK_MAX; + + if (limit == 0) limit = GEN_LIT_ARY_MAX; + if (cursp() >= slimit) slimit = INT16_MAX; + + if (!val) { + while (t) { + codegen(s, t->car, NOVAL); + n++; + t = t->cdr; + } + return n; + } while (t) { - is_splat = nint(t->car->car) == NODE_SPLAT; /* splat mode */ - if ( - n+extra >= CALL_MAXARGS - 1 /* need to subtract one because vm.c expects an array if n == CALL_MAXARGS */ - || is_splat) { - if (val) { - if (is_splat && n == 0 && nint(t->car->cdr->car) == NODE_ARRAY) { - codegen(s, t->car->cdr, VAL); - pop(); + int is_splat = nint(t->car->car) == NODE_SPLAT; + + if (is_splat || n+extra >= limit-1 || cursp() >= slimit) { /* flush stack */ + pop_n(n); + if (first) { + if (n == 0) { + genop_1(s, OP_LOADNIL, cursp()); } else { - pop_n(n); - if (n == 0 && is_splat) { - genop_1(s, OP_LOADNIL, cursp()); - } - else { - genop_2(s, OP_ARRAY, cursp(), n); - } - push(); - codegen(s, t->car, VAL); - pop(); pop(); - if (is_splat) { - genop_1(s, OP_ARYCAT, cursp()); - } - else { - genop_1(s, OP_ARYPUSH, cursp()); - } - } - t = t->cdr; - while (t) { - push(); - codegen(s, t->car, VAL); - pop(); pop(); - if (nint(t->car->car) == NODE_SPLAT) { - genop_1(s, OP_ARYCAT, cursp()); - } - else { - genop_1(s, OP_ARYPUSH, cursp()); - } - t = t->cdr; + genop_2(s, OP_ARRAY, cursp(), n); } + push(); + first = 0; + limit = GEN_LIT_ARY_MAX; } - else { - while (t) { - codegen(s, t->car, NOVAL); - t = t->cdr; - } + else if (n > 0) { + pop(); + genop_2(s, OP_ARYPUSH, cursp(), n); + push(); } - return -1; + n = 0; } - /* normal (no splat) mode */ codegen(s, t->car, val); - n++; + if (is_splat) { + pop(); pop(); + genop_1(s, OP_ARYCAT, cursp()); + push(); + } + else { + n++; + } t = t->cdr; } + if (!first) { + pop(); + if (n > 0) { + pop_n(n); + genop_2(s, OP_ARYPUSH, cursp(), n); + } + return -1; /* variable length */ + } return n; } @@ -1172,7 +1582,7 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe) } tree = tree->cdr->cdr->car; if (tree) { - n = gen_values(s, tree->car, VAL, sp?1:0); + n = gen_values(s, tree->car, VAL, sp?1:0, 14); if (n < 0) { n = noop = sendv = 1; push(); @@ -1182,7 +1592,7 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe) if (sendv) { gen_move(s, cursp(), sp, 0); pop(); - genop_1(s, OP_ARYPUSH, cursp()); + genop_2(s, OP_ARYPUSH, cursp(), 1); push(); } else { @@ -1199,46 +1609,47 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe) } push();pop(); pop_n(n+1); - { - mrb_int symlen; - const char *symname = mrb_sym_name_len(s->mrb, sym, &symlen); + if (!noop && sym == MRB_OPSYM_2(s->mrb, add) && n == 1) { + gen_addsub(s, OP_ADD, cursp()); + } + else if (!noop && sym == MRB_OPSYM_2(s->mrb, sub) && n == 1) { + gen_addsub(s, OP_SUB, cursp()); + } + else if (!noop && sym == MRB_OPSYM_2(s->mrb, mul) && n == 1) { + gen_muldiv(s, OP_MUL, cursp()); + } + else if (!noop && sym == MRB_OPSYM_2(s->mrb, div) && n == 1) { + gen_muldiv(s, OP_DIV, cursp()); + } + else if (!noop && sym == MRB_OPSYM_2(s->mrb, lt) && n == 1) { + genop_1(s, OP_LT, cursp()); + } + else if (!noop && sym == MRB_OPSYM_2(s->mrb, le) && n == 1) { + genop_1(s, OP_LE, cursp()); + } + else if (!noop && sym == MRB_OPSYM_2(s->mrb, gt) && n == 1) { + genop_1(s, OP_GT, cursp()); + } + else if (!noop && sym == MRB_OPSYM_2(s->mrb, ge) && n == 1) { + genop_1(s, OP_GE, cursp()); + } + else if (!noop && sym == MRB_OPSYM_2(s->mrb, eq) && n == 1) { + genop_1(s, OP_EQ, cursp()); + } + else if (!noop && n == 0 && gen_uniop(s, sym, cursp())) { + /* constant folding succeeded */ + } + else if (!noop && n == 1 && gen_binop(s, sym, cursp())) { + /* constant folding succeeded */ + } + else { + int idx = new_sym(s, sym); - if (!noop && symlen == 1 && symname[0] == '+' && n == 1) { - gen_addsub(s, OP_ADD, cursp()); - } - else if (!noop && symlen == 1 && symname[0] == '-' && n == 1) { - gen_addsub(s, OP_SUB, cursp()); - } - else if (!noop && symlen == 1 && symname[0] == '*' && n == 1) { - genop_1(s, OP_MUL, cursp()); - } - else if (!noop && symlen == 1 && symname[0] == '/' && n == 1) { - genop_1(s, OP_DIV, cursp()); - } - else if (!noop && symlen == 1 && symname[0] == '<' && n == 1) { - genop_1(s, OP_LT, cursp()); - } - else if (!noop && symlen == 2 && symname[0] == '<' && symname[1] == '=' && n == 1) { - genop_1(s, OP_LE, cursp()); - } - else if (!noop && symlen == 1 && symname[0] == '>' && n == 1) { - genop_1(s, OP_GT, cursp()); - } - else if (!noop && symlen == 2 && symname[0] == '>' && symname[1] == '=' && n == 1) { - genop_1(s, OP_GE, cursp()); - } - else if (!noop && symlen == 2 && symname[0] == '=' && symname[1] == '=' && n == 1) { - genop_1(s, OP_EQ, cursp()); + if (sendv) { + genop_2(s, blk ? OP_SENDVB : OP_SENDV, cursp(), idx); } else { - int idx = new_sym(s, sym); - - if (sendv) { - genop_2(s, blk ? OP_SENDVB : OP_SENDV, cursp(), idx); - } - else { - genop_3(s, blk ? OP_SENDB : OP_SEND, cursp(), idx, n); - } + genop_3(s, blk ? OP_SENDB : OP_SEND, cursp(), idx, n); } } if (safe) { @@ -1258,8 +1669,7 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val) tree = tree->cdr; switch (type) { case NODE_GVAR: - idx = new_sym(s, nsym(tree)); - genop_2(s, OP_SETGV, sp, idx); + gen_setxv(s, OP_SETGV, sp, nsym(tree), val); break; case NODE_ARG: case NODE_LVAR: @@ -1271,8 +1681,7 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val) break; } else { /* upvar */ - int lv = search_upvar(s, nsym(tree), &idx); - genop_3(s, OP_SETUPVAR, sp, idx, lv); + gen_setupvar(s, sp, nsym(tree)); } break; case NODE_NVAR: @@ -1280,16 +1689,13 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val) codegen_error(s, "Can't assign to numbered parameter"); break; case NODE_IVAR: - idx = new_sym(s, nsym(tree)); - genop_2(s, OP_SETIV, sp, idx); + gen_setxv(s, OP_SETIV, sp, nsym(tree), val); break; case NODE_CVAR: - idx = new_sym(s, nsym(tree)); - genop_2(s, OP_SETCV, sp, idx); + gen_setxv(s, OP_SETCV, sp, nsym(tree), val); break; case NODE_CONST: - idx = new_sym(s, nsym(tree)); - genop_2(s, OP_SETCONST, sp, idx); + gen_setxv(s, OP_SETCONST, sp, nsym(tree), val); break; case NODE_COLON2: gen_move(s, cursp(), sp, 0); @@ -1320,9 +1726,7 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val) break; default: -#ifndef MRB_NO_STDIO - fprintf(stderr, "unknown lhs %d\n", type); -#endif + codegen_error(s, "unknown lhs"); break; } if (val) push(); @@ -1383,6 +1787,16 @@ static void gen_intern(codegen_scope *s) { pop(); + if (!no_peephole(s)) { + struct mrb_insn_data data = mrb_last_insn(s); + + if (data.insn == OP_STRING && data.a == cursp()) { + rewind_pc(s); + genop_2(s, OP_SYMBOL, data.a, data.b); + push(); + return; + } + } genop_1(s, OP_INTERN, cursp()); push(); } @@ -1391,7 +1805,7 @@ static void gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val) { if (val) { - int i = 0, j = 0; + int i = 0, j = 0, gen = 0; while (tree) { switch (nint(tree->car->car)) { @@ -1419,6 +1833,19 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val) push(); j--; } + if (i > GEN_LIT_ARY_MAX) { + pop_n(i); + if (gen) { + pop(); + genop_2(s, OP_ARYPUSH, cursp(), i); + } + else { + genop_2(s, OP_ARRAY, cursp(), i); + gen = 1; + } + push(); + i = 0; + } tree = tree->cdr; } if (j > 0) { @@ -1427,7 +1854,13 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val) gen_intern(s); } pop_n(i); - genop_2(s, OP_ARRAY, cursp(), i); + if (gen) { + pop(); + genop_2(s, OP_ARYPUSH, cursp(), i); + } + else { + genop_2(s, OP_ARRAY, cursp(), i); + } push(); } else { @@ -1450,45 +1883,48 @@ raise_error(codegen_scope *s, const char *msg) } static mrb_int -readint_mrb_int(codegen_scope *s, const char *p, int base, mrb_bool neg, mrb_bool *overflow) +readint(codegen_scope *s, const char *p, int base, mrb_bool neg, mrb_bool *overflow) { const char *e = p + strlen(p); mrb_int result = 0; - int n; - mrb_assert(base >= 2 && base <= 36); + mrb_assert(base >= 2 && base <= 16); if (*p == '+') p++; while (p < e) { + int n; char c = *p; - c = tolower((unsigned char)c); - for (n=0; n<base; n++) { - if (mrb_digitmap[n] == c) { - break; - } - } - if (n == base) { + switch (c) { + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + n = c - '0'; break; + case '8': case '9': + n = c - '0'; break; + case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': + n = c - 'a' + 10; break; + case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': + n = c - 'A' + 10; break; + default: codegen_error(s, "malformed readint input"); - } - - if (neg) { - if ((MRB_INT_MIN + n)/base > result) { - *overflow = TRUE; - return 0; - } - result *= base; - result -= n; - } - else { - if ((MRB_INT_MAX - n)/base < result) { - *overflow = TRUE; - return 0; - } - result *= base; - result += n; - } + *overflow = TRUE; + /* not reached */ + return result; + } + if (mrb_int_mul_overflow(result, base, &result)) { + overflow: + *overflow = TRUE; + return 0; + } + mrb_uint tmp = ((mrb_uint)result)+n; + if (neg && tmp == (mrb_uint)MRB_INT_MAX+1) { + *overflow = FALSE; + return MRB_INT_MIN; + } + if (tmp > MRB_INT_MAX) goto overflow; + result = (mrb_int)tmp; p++; } *overflow = FALSE; + if (neg) return -result; return result; } @@ -1506,6 +1942,32 @@ gen_retval(codegen_scope *s, node *tree) } } +static mrb_bool +true_always(node *tree) +{ + switch (nint(tree->car)) { + case NODE_TRUE: + case NODE_INT: + case NODE_STR: + case NODE_SYM: + return TRUE; + default: + return FALSE; + } +} + +static mrb_bool +false_always(node *tree) +{ + switch (nint(tree->car)) { + case NODE_FALSE: + case NODE_NIL: + return TRUE; + default: + return FALSE; + } +} + static void codegen(codegen_scope *s, node *tree, int val) { @@ -1673,7 +2135,7 @@ codegen(codegen_scope *s, node *tree, int val) if (val) { int idx = lambda_body(s, tree, 1); - genop_bs(s, OP_LAMBDA, cursp(), idx); + genop_2(s, OP_LAMBDA, cursp(), idx); push(); } break; @@ -1682,41 +2144,37 @@ codegen(codegen_scope *s, node *tree, int val) if (val) { int idx = lambda_body(s, tree, 1); - genop_bs(s, OP_BLOCK, cursp(), idx); + genop_2(s, OP_BLOCK, cursp(), idx); push(); } break; case NODE_IF: { - int pos1, pos2, nil_p = FALSE; + uint32_t pos1, pos2; + mrb_bool nil_p = FALSE; node *elsepart = tree->cdr->cdr->car; if (!tree->car) { codegen(s, elsepart, val); goto exit; } - switch (nint(tree->car->car)) { - case NODE_TRUE: - case NODE_INT: - case NODE_STR: + if (true_always(tree->car)) { codegen(s, tree->cdr->car, val); goto exit; - case NODE_FALSE: - case NODE_NIL: + } + if (false_always(tree->car)) { codegen(s, elsepart, val); goto exit; - case NODE_CALL: - { - node *n = tree->car->cdr; - mrb_sym mid = nsym(n->cdr->car); - mrb_sym mnil = MRB_SYM_Q_2(s->mrb, nil); - if (mid == mnil && n->cdr->cdr->car == NULL) { - nil_p = TRUE; - codegen(s, n->car, VAL); - } + } + if (nint(tree->car->car) == NODE_CALL) { + node *n = tree->car->cdr; + mrb_sym mid = nsym(n->cdr->car); + mrb_sym sym_nil_p = MRB_SYM_Q_2(s->mrb, nil); + if (mid == sym_nil_p && n->cdr->cdr->car == NULL) { + nil_p = TRUE; + codegen(s, n->car, VAL); } - break; } if (!nil_p) { codegen(s, tree->car, VAL); @@ -1764,8 +2222,16 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_AND: { - int pos; + uint32_t pos; + if (true_always(tree->car)) { + codegen(s, tree->cdr, val); + goto exit; + } + if (false_always(tree->car)) { + codegen(s, tree->car, val); + goto exit; + } codegen(s, tree->car, VAL); pop(); pos = genjmp2_0(s, OP_JMPNOT, cursp(), val); @@ -1776,8 +2242,16 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_OR: { - int pos; + uint32_t pos; + if (true_always(tree->car)) { + codegen(s, tree->car, val); + goto exit; + } + if (false_always(tree->car)) { + codegen(s, tree->cdr, val); + goto exit; + } codegen(s, tree->car, VAL); pop(); pos = genjmp2_0(s, OP_JMPIF, cursp(), val); @@ -1787,35 +2261,44 @@ codegen(codegen_scope *s, node *tree, int val) break; case NODE_WHILE: - { - struct loopinfo *lp = loop_push(s, LOOP_NORMAL); - - lp->pc0 = new_label(s); - lp->pc1 = genjmp_0(s, OP_JMP); - lp->pc2 = new_label(s); - codegen(s, tree->cdr, NOVAL); - dispatch(s, lp->pc1); - codegen(s, tree->car, VAL); - pop(); - genjmp2(s, OP_JMPIF, cursp(), lp->pc2, NOVAL); - - loop_pop(s, val); - } - break; - case NODE_UNTIL: { + if (true_always(tree->car)) { + if (nt == NODE_UNTIL) { + if (val) { + genop_1(s, OP_LOADNIL, cursp()); + push(); + } + goto exit; + } + } + else if (false_always(tree->car)) { + if (nt == NODE_WHILE) { + if (val) { + genop_1(s, OP_LOADNIL, cursp()); + push(); + } + goto exit; + } + } + + uint32_t pos = JMPLINK_START; struct loopinfo *lp = loop_push(s, LOOP_NORMAL); + if (!val) lp->reg = -1; lp->pc0 = new_label(s); - lp->pc1 = genjmp_0(s, OP_JMP); - lp->pc2 = new_label(s); - codegen(s, tree->cdr, NOVAL); - dispatch(s, lp->pc1); codegen(s, tree->car, VAL); pop(); - genjmp2(s, OP_JMPNOT, cursp(), lp->pc2, NOVAL); - + if (nt == NODE_WHILE) { + pos = genjmp2_0(s, OP_JMPNOT, cursp(), NOVAL); + } + else { + pos = genjmp2_0(s, OP_JMPIF, cursp(), NOVAL); + } + lp->pc1 = new_label(s); + codegen(s, tree->cdr, NOVAL); + genjmp(s, OP_JMP, lp->pc0); + dispatch(s, pos); loop_pop(s, val); } break; @@ -1948,15 +2431,12 @@ codegen(codegen_scope *s, node *tree, int val) { int n; - n = gen_values(s, tree, val, 0); - if (n >= 0) { - if (val) { + n = gen_values(s, tree, val, 0, 0); + if (val) { + if (n >= 0) { pop_n(n); genop_2(s, OP_ARRAY, cursp(), n); - push(); } - } - else if (val) { push(); } } @@ -1967,7 +2447,9 @@ codegen(codegen_scope *s, node *tree, int val) { int len = 0; mrb_bool update = FALSE; + int slimit = GEN_VAL_STACK_MAX; + if (cursp() >= GEN_LIT_ARY_MAX) slimit = INT16_MAX; while (tree) { if (nint(tree->car->car->car) == NODE_KW_REST_ARGS) { if (len > 0) { @@ -1996,7 +2478,7 @@ codegen(codegen_scope *s, node *tree, int val) len++; } tree = tree->cdr; - if (val && cursp() > 127) { + if (val && cursp() >= slimit) { pop_n(len*2); if (!update) { genop_2(s, OP_HASH, cursp(), len); @@ -2156,7 +2638,7 @@ codegen(codegen_scope *s, node *tree, int val) idx = new_sym(s, nsym(n->cdr->car)); base = cursp()-1; if (n->cdr->cdr->car) { - nargs = gen_values(s, n->cdr->cdr->car->car, VAL, 1); + nargs = gen_values(s, n->cdr->cdr->car->car, VAL, 1, 14); if (nargs >= 0) { callargs = nargs; } @@ -2181,7 +2663,7 @@ codegen(codegen_scope *s, node *tree, int val) if (len == 2 && ((name[0] == '|' && name[1] == '|') || (name[0] == '&' && name[1] == '&'))) { - int pos; + uint32_t pos; pop(); if (val) { @@ -2201,7 +2683,7 @@ codegen(codegen_scope *s, node *tree, int val) if (nint(tree->car->car) == NODE_CALL) { if (callargs == CALL_MAXARGS) { pop(); - genop_1(s, OP_ARYPUSH, cursp()); + genop_2(s, OP_ARYPUSH, cursp(), 1); } else { pop_n(callargs); @@ -2258,7 +2740,7 @@ codegen(codegen_scope *s, node *tree, int val) } if (callargs == CALL_MAXARGS) { pop(); - genop_1(s, OP_ARYPUSH, cursp()); + genop_2(s, OP_ARYPUSH, cursp(), 1); } else { pop_n(callargs); @@ -2289,7 +2771,7 @@ codegen(codegen_scope *s, node *tree, int val) if (tree) { node *args = tree->car; if (args) { - n = gen_values(s, args, VAL, 0); + n = gen_values(s, args, VAL, 0, 14); if (n < 0) { n = noop = sendv = 1; push(); @@ -2370,7 +2852,7 @@ codegen(codegen_scope *s, node *tree, int val) if (ainfo < 0) codegen_error(s, "invalid yield (SyntaxError)"); push(); if (tree) { - n = gen_values(s, tree, VAL, 0); + n = gen_values(s, tree, VAL, 0, 14); if (n < 0) { n = sendv = 1; push(); @@ -2416,7 +2898,7 @@ codegen(codegen_scope *s, node *tree, int val) raise_error(s, "unexpected redo"); } else { - genjmp(s, OP_JMPUW, s->loop->pc2); + genjmp(s, OP_JMPUW, s->loop->pc1); } if (val) push(); break; @@ -2447,8 +2929,7 @@ codegen(codegen_scope *s, node *tree, int val) gen_move(s, cursp(), idx, val); } else { - int lv = search_upvar(s, nsym(tree), &idx); - genop_3(s, OP_GETUPVAR, cursp(), idx, lv); + gen_getupvar(s, cursp(), nsym(tree)); } push(); } @@ -2538,29 +3019,13 @@ codegen(codegen_scope *s, node *tree, int val) mrb_int i; mrb_bool overflow; - i = readint_mrb_int(s, p, base, FALSE, &overflow); + i = readint(s, p, base, FALSE, &overflow); if (overflow) { int off = new_litbn(s, p, base, FALSE); - genop_bs(s, OP_LOADL, cursp(), off); + genop_2(s, OP_LOADL, cursp(), off); } else { - if (i < 0) { - if (i == -1) genop_1(s, OP_LOADI__1, cursp()); - else if (i >= -0xff) genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i); - else if (i >= INT16_MIN) genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i); - else if (i >= INT32_MIN) genop_2SS(s, OP_LOADI32, cursp(), (uint32_t)i); - else goto lit_int; - } - else if (i < 8) genop_1(s, OP_LOADI_0 + (uint8_t)i, cursp()); - else if (i <= 0xff) genop_2(s, OP_LOADI, cursp(), (uint16_t)i); - else if (i <= INT16_MAX) genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i); - else if (i <= INT32_MAX) genop_2SS(s, OP_LOADI32, cursp(), (uint32_t)i); - else { - int off; - lit_int: - off = new_lit(s, mrb_int_value(s->mrb, i)); - genop_bs(s, OP_LOADL, cursp(), off); - } + gen_int(s, cursp(), i); } push(); } @@ -2573,7 +3038,7 @@ codegen(codegen_scope *s, node *tree, int val) mrb_float f = mrb_float_read(p, NULL); int off = new_lit(s, mrb_float_value(s->mrb, f)); - genop_bs(s, OP_LOADL, cursp(), off); + genop_2(s, OP_LOADL, cursp(), off); push(); } break; @@ -2590,7 +3055,7 @@ codegen(codegen_scope *s, node *tree, int val) mrb_float f = mrb_float_read(p, NULL); int off = new_lit(s, mrb_float_value(s->mrb, -f)); - genop_bs(s, OP_LOADL, cursp(), off); + genop_2(s, OP_LOADL, cursp(), off); push(); } break; @@ -2603,26 +3068,13 @@ codegen(codegen_scope *s, node *tree, int val) mrb_int i; mrb_bool overflow; - i = readint_mrb_int(s, p, base, TRUE, &overflow); + i = readint(s, p, base, TRUE, &overflow); if (overflow) { int off = new_litbn(s, p, base, TRUE); - genop_bs(s, OP_LOADL, cursp(), off); + genop_2(s, OP_LOADL, cursp(), off); } else { - if (i == -1) genop_1(s, OP_LOADI__1, cursp()); - else if (i >= -0xff) { - genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i); - } - else if (i >= INT16_MIN) { - genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i); - } - else if (i >= INT32_MIN) { - genop_2SS(s, OP_LOADI32, cursp(), (uint32_t)i); - } - else { - int off = new_lit(s, mrb_int_value(s->mrb, i)); - genop_bs(s, OP_LOADL, cursp(), off); - } + gen_int(s, cursp(), i); } push(); } @@ -2630,10 +3082,13 @@ codegen(codegen_scope *s, node *tree, int val) default: if (val) { - int sym = new_sym(s, MRB_OPSYM_2(s->mrb, minus)); codegen(s, tree, VAL); pop(); - genop_3(s, OP_SEND, cursp(), sym, 0); + push_n(2);pop_n(2); /* space for receiver&block */ + mrb_sym minus = MRB_OPSYM_2(s->mrb, minus); + if (!gen_uniop(s, minus, cursp())) { + genop_3(s, OP_SEND, cursp(), new_sym(s, minus), 0); + } push(); } else { @@ -2652,7 +3107,7 @@ codegen(codegen_scope *s, node *tree, int val) int off = new_lit(s, mrb_str_new(s->mrb, p, len)); mrb_gc_arena_restore(s->mrb, ai); - genop_bs(s, OP_STRING, cursp(), off); + genop_2(s, OP_STRING, cursp(), off); push(); } break; @@ -2739,7 +3194,7 @@ codegen(codegen_scope *s, node *tree, int val) genop_1(s, OP_LOADSELF, cursp()); push(); - genop_bs(s, OP_STRING, cursp(), off); + genop_2(s, OP_STRING, cursp(), off); push(); push(); pop_n(3); sym = new_sym(s, MRB_OPSYM_2(s->mrb, tick)); /* ` */ @@ -2762,12 +3217,12 @@ codegen(codegen_scope *s, node *tree, int val) genop_1(s, OP_OCLASS, cursp()); genop_2(s, OP_GETMCNST, cursp(), sym); push(); - genop_bs(s, OP_STRING, cursp(), off); + genop_2(s, OP_STRING, cursp(), off); push(); if (p2 || p3) { if (p2) { /* opt */ off = new_lit(s, mrb_str_new_cstr(s->mrb, p2)); - genop_bs(s, OP_STRING, cursp(), off); + genop_2(s, OP_STRING, cursp(), off); } else { genop_1(s, OP_LOADNIL, cursp()); @@ -2776,7 +3231,7 @@ codegen(codegen_scope *s, node *tree, int val) argc++; if (p3) { /* enc */ off = new_lit(s, mrb_str_new(s->mrb, p3, 1)); - genop_bs(s, OP_STRING, cursp(), off); + genop_2(s, OP_STRING, cursp(), off); push(); argc++; } @@ -2816,7 +3271,7 @@ codegen(codegen_scope *s, node *tree, int val) p = (char*)n->car; off = new_lit(s, mrb_str_new_cstr(s->mrb, p)); codegen(s, tree->car, VAL); - genop_bs(s, OP_STRING, cursp(), off); + genop_2(s, OP_STRING, cursp(), off); pop(); genop_1(s, OP_STRCAT, cursp()); push(); @@ -2824,14 +3279,14 @@ codegen(codegen_scope *s, node *tree, int val) if (n->cdr->car) { /* opt */ char *p2 = (char*)n->cdr->car; off = new_lit(s, mrb_str_new_cstr(s->mrb, p2)); - genop_bs(s, OP_STRING, cursp(), off); + genop_2(s, OP_STRING, cursp(), off); push(); argc++; } if (n->cdr->cdr) { /* enc */ char *p2 = (char*)n->cdr->cdr; off = new_lit(s, mrb_str_new_cstr(s->mrb, p2)); - genop_bs(s, OP_STRING, cursp(), off); + genop_2(s, OP_STRING, cursp(), off); push(); argc++; } @@ -2858,7 +3313,7 @@ codegen(codegen_scope *s, node *tree, int val) if (val) { int sym = new_sym(s, nsym(tree)); - genop_bs(s, OP_LOADSYM, cursp(), sym); + genop_2(s, OP_LOADSYM, cursp(), sym); push(); } break; @@ -2959,7 +3414,7 @@ codegen(codegen_scope *s, node *tree, int val) } else { idx = scope_body(s, body, val); - genop_bs(s, OP_EXEC, cursp(), idx); + genop_2(s, OP_EXEC, cursp(), idx); } if (val) { push(); @@ -2991,7 +3446,7 @@ codegen(codegen_scope *s, node *tree, int val) } else { idx = scope_body(s, tree->cdr->car, val); - genop_bs(s, OP_EXEC, cursp(), idx); + genop_2(s, OP_EXEC, cursp(), idx); } if (val) { push(); @@ -3012,7 +3467,7 @@ codegen(codegen_scope *s, node *tree, int val) } else { idx = scope_body(s, tree->cdr->car, val); - genop_bs(s, OP_EXEC, cursp(), idx); + genop_2(s, OP_EXEC, cursp(), idx); } if (val) { push(); @@ -3027,14 +3482,11 @@ codegen(codegen_scope *s, node *tree, int val) genop_1(s, OP_TCLASS, cursp()); push(); - genop_bs(s, OP_METHOD, cursp(), idx); + genop_2(s, OP_METHOD, cursp(), idx); push(); pop(); pop(); genop_2(s, OP_DEF, cursp(), sym); - if (val) { - genop_bs(s, OP_LOADSYM, cursp(), sym); - push(); - } + if (val) push(); } break; @@ -3048,13 +3500,10 @@ codegen(codegen_scope *s, node *tree, int val) pop(); genop_1(s, OP_SCLASS, cursp()); push(); - genop_bs(s, OP_METHOD, cursp(), idx); + genop_2(s, OP_METHOD, cursp(), idx); pop(); genop_2(s, OP_DEF, cursp(), sym); - if (val) { - genop_bs(s, OP_LOADSYM, cursp(), sym); - push(); - } + if (val) push(); } break; @@ -3214,9 +3663,9 @@ loop_push(codegen_scope *s, enum looptype t) struct loopinfo *p = (struct loopinfo *)codegen_palloc(s, sizeof(struct loopinfo)); p->type = t; - p->pc0 = p->pc1 = p->pc2 = p->pc3 = JMPLINK_START; + p->pc0 = p->pc1 = p->pc2 = JMPLINK_START; p->prev = s->loop; - p->acc = cursp(); + p->reg = cursp(); s->loop = p; return p; @@ -3232,11 +3681,16 @@ loop_break(codegen_scope *s, node *tree) else { struct loopinfo *loop; - if (tree) { - gen_retval(s, tree); - } loop = s->loop; + if (tree) { + if (loop->reg < 0) { + codegen(s, tree, NOVAL); + } + else { + gen_retval(s, tree); + } + } while (loop) { if (loop->type == LOOP_BEGIN) { loop = loop->prev; @@ -3256,11 +3710,16 @@ loop_break(codegen_scope *s, node *tree) if (loop->type == LOOP_NORMAL) { int tmp; - if (tree) { - gen_move(s, loop->acc, cursp(), 0); + if (loop->reg >= 0) { + if (tree) { + gen_move(s, loop->reg, cursp(), 0); + } + else { + genop_1(s, OP_LOADNIL, loop->reg); + } } - tmp = genjmp(s, OP_JMPUW, loop->pc3); - loop->pc3 = tmp; + tmp = genjmp(s, OP_JMPUW, loop->pc2); + loop->pc2 = tmp; } else { if (!tree) { @@ -3277,7 +3736,7 @@ loop_pop(codegen_scope *s, int val) if (val) { genop_1(s, OP_LOADNIL, cursp()); } - dispatch_linked(s, s->loop->pc3); + dispatch_linked(s, s->loop->pc2); s->loop = s->loop->prev; if (val) push(); } @@ -3308,16 +3767,18 @@ static struct RProc* generate_code(mrb_state *mrb, parser_state *p, int val) { codegen_scope *scope = scope_new(mrb, 0, 0); - struct RProc *proc; struct mrb_jmpbuf *prev_jmp = mrb->jmp; + struct mrb_jmpbuf jmpbuf; + struct RProc *proc; + + mrb->jmp = &jmpbuf; scope->mrb = mrb; scope->parser = p; scope->filename_sym = p->filename_sym; scope->filename_index = p->current_filename_index; - MRB_TRY(&scope->jmp) { - mrb->jmp = &scope->jmp; + MRB_TRY(mrb->jmp) { /* prepare irep */ codegen(scope, p->tree, val); proc = mrb_proc_new(mrb, scope->irep); @@ -3330,13 +3791,13 @@ generate_code(mrb_state *mrb, parser_state *p, int val) mrb->jmp = prev_jmp; return proc; } - MRB_CATCH(&scope->jmp) { + MRB_CATCH(mrb->jmp) { mrb_irep_decref(mrb, scope->irep); mrb_pool_close(scope->mpool); mrb->jmp = prev_jmp; return NULL; } - MRB_END_EXC(&scope->jmp); + MRB_END_EXC(mrb->jmp); } MRB_API struct RProc* @@ -3360,26 +3821,3 @@ mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep) mrb_irep_remove_lv(mrb, (mrb_irep*)irep->reps[i]); } } - -#undef OPCODE -#define Z 1 -#define S 3 -#define W 4 -/* instruction sizes */ -uint8_t mrb_insn_size[] = { -#define B 2 -#define BB 3 -#define BBB 4 -#define BS 4 -#define BSS 6 -#define SB 4 -#define OPCODE(_,x) x, -#include "mruby/ops.h" -#undef OPCODE -#undef B -#undef BB -#undef BS -#undef BSS -#undef SB -#undef BBB -}; diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index 2c2bff714..60cfeadae 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -13,7 +13,6 @@ #include <ctype.h> #include <errno.h> -#include <stdlib.h> #include <string.h> #include <mruby.h> #include <mruby/compile.h> @@ -34,7 +33,6 @@ typedef struct mrb_parser_heredoc_info parser_heredoc_info; static int yyparse(parser_state *p); static int yylex(void *lval, parser_state *p); static void yyerror(parser_state *p, const char *s); -static void yywarn(parser_state *p, const char *s); static void yywarning(parser_state *p, const char *s); static void backref_error(parser_state *p, node *n); static void void_expr_error(parser_state *p, node *n); @@ -106,7 +104,7 @@ parser_palloc(parser_state *p, size_t size) void *m = mrb_pool_alloc(p->pool, size); if (!m) { - MRB_THROW(p->jmp); + MRB_THROW(p->mrb->jmp); } return m; } @@ -286,9 +284,10 @@ local_var_p(parser_state *p, mrb_sym sym) const mrb_sym *v = ir->lv; int i; - if (!v) break; - for (i=0; i+1 < ir->nlocals; i++) { - if (v[i] == sym) return TRUE; + if (v) { + for (i=0; i+1 < ir->nlocals; i++) { + if (v[i] == sym) return TRUE; + } } if (MRB_PROC_SCOPE_P(u)) break; u = u->upper; @@ -1247,7 +1246,7 @@ call_with_block(parser_state *p, node *a, node *b) } static node* -negate_lit(parser_state *p, node *n) +new_negate(parser_state *p, node *n) { return cons((node*)NODE_NEGATE, n); } @@ -1293,6 +1292,24 @@ var_reference(parser_state *p, node *lhs) return lhs; } +static node* +label_reference(parser_state *p, mrb_sym sym) +{ + const char *name = mrb_sym_name(p->mrb, sym); + node *n; + + if (local_var_p(p, sym)) { + n = new_lvar(p, sym); + } + else if (ISUPPER(name[0])) { + n = new_const(p, sym); + } + else { + n = new_fcall(p, sym, 0); + } + return n; +} + typedef enum mrb_string_type string_type; static node* @@ -1623,7 +1640,7 @@ bodystmt : compstmt NODE_LINENO($$, $1); } else if ($3) { - yywarn(p, "else without rescue is useless"); + yywarning(p, "else without rescue is useless"); $$ = push($1, $3); } else { @@ -1754,6 +1771,44 @@ command_asgn : lhs '=' command_rhs { $$ = new_op_asgn(p, new_call(p, $1, $3, 0, tCOLON2), $4, $5); } + | defn_head f_opt_arglist_paren '=' command + { + $$ = $1; + endless_method_name(p, $1); + void_expr_error(p, $4); + defn_setup(p, $$, $2, $4); + nvars_unnest(p); + p->in_def--; + } + | defn_head f_opt_arglist_paren '=' command modifier_rescue arg + { + $$ = $1; + endless_method_name(p, $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_opt_arglist_paren '=' command + { + $$ = $1; + void_expr_error(p, $4); + defs_setup(p, $$, $2, $4); + nvars_unnest(p); + p->in_def--; + p->in_single--; + } + | defs_head f_opt_arglist_paren '=' command 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--; + } | backref tOP_ASGN command_rhs { backref_error(p, $1); @@ -2253,11 +2308,11 @@ arg : lhs '=' arg_rhs } | tUMINUS_NUM tINTEGER tPOW arg { - $$ = call_uni_op(p, call_bin_op(p, $2, "**", $4), "-@"); + $$ = new_negate(p, call_bin_op(p, $2, "**", $4)); } | tUMINUS_NUM tFLOAT tPOW arg { - $$ = call_uni_op(p, call_bin_op(p, $2, "**", $4), "-@"); + $$ = new_negate(p, call_bin_op(p, $2, "**", $4)); } | tUPLUS arg { @@ -2265,7 +2320,7 @@ arg : lhs '=' arg_rhs } | tUMINUS arg { - $$ = call_uni_op(p, $2, "-@"); + $$ = new_negate(p, $2); } | arg '|' arg { @@ -2370,7 +2425,7 @@ arg : lhs '=' arg_rhs nvars_unnest(p); p->in_def--; } - | defs_head f_arglist_paren '=' arg + | defs_head f_opt_arglist_paren '=' arg { $$ = $1; void_expr_error(p, $4); @@ -2379,7 +2434,7 @@ arg : lhs '=' arg_rhs p->in_def--; p->in_single--; } - | defs_head f_arglist_paren '=' arg modifier_rescue arg + | defs_head f_opt_arglist_paren '=' arg modifier_rescue arg { $$ = $1; void_expr_error(p, $4); @@ -2548,8 +2603,7 @@ opt_block_arg : comma block_arg } ; -comma : ',' - | ',' opt_nl heredoc_bodies +comma : ',' opt_nl ; args : arg @@ -3268,7 +3322,14 @@ string_fragment : tCHAR } | tSTRING_BEG string_rep tSTRING { - $$ = new_dstr(p, push($2, $3)); + node *n = $2; + if (intn($3->cdr->cdr) > 0) { + n = push(n, $3); + } + else { + cons_free($3); + } + $$ = new_dstr(p, n); } ; @@ -3310,7 +3371,14 @@ xstring : tXSTRING_BEG tXSTRING } | tXSTRING_BEG string_rep tXSTRING { - $$ = new_dxstr(p, push($2, $3)); + node *n = $2; + if (intn($3->cdr->cdr) > 0) { + n = push(n, $3); + } + else { + cons_free($3); + } + $$ = new_dxstr(p, n); } ; @@ -3373,7 +3441,14 @@ words : tWORDS_BEG tSTRING } | tWORDS_BEG string_rep tSTRING { - $$ = new_words(p, push($2, $3)); + node *n = $2; + if (intn($3->cdr->cdr) > 0) { + n = push(n, $3); + } + else { + cons_free($3); + } + $$ = new_words(p, n); } ; @@ -3385,8 +3460,15 @@ symbol : basic_symbol } | tSYMBEG tSTRING_BEG string_rep tSTRING { + node *n = $3; p->lstate = EXPR_ENDARG; - $$ = new_dsym(p, new_dstr(p, push($3, $4))); + if (intn($4->cdr->cdr) > 0) { + n = push(n, $4); + } + else { + cons_free($4); + } + $$ = new_dsym(p, new_dstr(p, n)); } ; @@ -3416,7 +3498,11 @@ symbols : tSYMBOLS_BEG tSTRING } | tSYMBOLS_BEG string_rep tSTRING { - $$ = new_symbols(p, push($2, $3)); + node *n = $2; + if (intn($3->cdr->cdr) > 0) { + n = push(n, $3); + } + $$ = new_symbols(p, n); } ; @@ -3424,11 +3510,11 @@ numeric : tINTEGER | tFLOAT | tUMINUS_NUM tINTEGER %prec tLOWEST { - $$ = negate_lit(p, $2); + $$ = new_negate(p, $2); } | tUMINUS_NUM tFLOAT %prec tLOWEST { - $$ = negate_lit(p, $2); + $$ = new_negate(p, $2); } ; @@ -3501,12 +3587,7 @@ var_ref : variable } | keyword__ENCODING__ { -#ifdef MRB_UTF8_STRING - const char *enc = "UTF-8"; -#else - const char *enc = "ASCII-8BIT"; -#endif - $$ = new_str(p, enc, strlen(enc)); + $$ = new_fcall(p, MRB_SYM_2(p->mrb, __ENCODING__), 0); } ; @@ -3938,22 +4019,22 @@ assocs : assoc } ; -label_tag : tLABEL_TAG - | tLABEL_TAG heredoc_bodies - ; - assoc : arg tASSOC arg { void_expr_error(p, $1); void_expr_error(p, $3); $$ = cons($1, $3); } - | tIDENTIFIER label_tag arg + | tIDENTIFIER tLABEL_TAG arg { void_expr_error(p, $3); $$ = cons(new_sym(p, $1), $3); } - | string_fragment label_tag arg + | tIDENTIFIER tLABEL_TAG + { + $$ = cons(new_sym(p, $1), label_reference(p, $1)); + } + | string_fragment tLABEL_TAG arg { void_expr_error(p, $3); if (typen($1->car) == NODE_DSTR) { @@ -4012,7 +4093,7 @@ opt_terms : /* none */ ; opt_nl : /* none */ - | nl + | opt_nl nl ; rparen : opt_terms ')' @@ -4025,7 +4106,6 @@ trailer : /* none */ term : ';' {yyerrok;} | nl - | heredoc_body ; nl : '\n' @@ -4033,6 +4113,7 @@ nl : '\n' p->lineno += $<num>1; p->column = 0; } + | heredoc_body ; terms : term @@ -4087,7 +4168,7 @@ yyerror_c(parser_state *p, const char *msg, char c) } static void -yywarn(parser_state *p, const char *s) +yywarning(parser_state *p, const char *s) { char* c; size_t n; @@ -4115,12 +4196,6 @@ yywarn(parser_state *p, const char *s) } static void -yywarning(parser_state *p, const char *s) -{ - yywarn(p, s); -} - -static void yywarning_s(parser_state *p, const char *msg, const char *s) { char buf[256]; @@ -6225,10 +6300,10 @@ parser_yylex(parser_state *p) if (last_state == EXPR_FNAME) goto gvar; tokfix(p); { - unsigned long n = strtoul(tok(p), NULL, 10); - if (n > INT_MAX) { - yyerror(p, "capture group index must be <= " MRB_STRINGIZE(INT_MAX)); - return 0; + mrb_int n = mrb_int_read(tok(p), NULL, NULL); + if (n > INT32_MAX) { + yywarning(p, "capture group index too big; always nil"); + return keyword_nil; } pylval.nd = new_nth_ref(p, (int)n); } @@ -6513,6 +6588,7 @@ parser_update_cxt(parser_state *p, mrbc_context *cxt) int i = 0; if (!cxt) return; + if (!p->tree) return; if (intn(p->tree->car) != NODE_SCOPE) return; n0 = n = p->tree->cdr->car; while (n) { @@ -6533,53 +6609,39 @@ MRB_API void mrb_parser_parse(parser_state *p, mrbc_context *c) { struct mrb_jmpbuf buf1; - p->jmp = &buf1; + struct mrb_jmpbuf *prev = p->mrb->jmp; + p->mrb->jmp = &buf1; - MRB_TRY(p->jmp) { + MRB_TRY(p->mrb->jmp) { int n = 1; p->cmd_start = TRUE; p->in_def = p->in_single = 0; p->nerr = p->nwarn = 0; p->lex_strterm = NULL; - parser_init_cxt(p, c); - if (p->mrb->jmp) { - n = yyparse(p); - } - else { - struct mrb_jmpbuf buf2; - - p->mrb->jmp = &buf2; - MRB_TRY(p->mrb->jmp) { - n = yyparse(p); - } - MRB_CATCH(p->mrb->jmp) { - p->nerr++; - } - MRB_END_EXC(p->mrb->jmp); - p->mrb->jmp = 0; - } + n = yyparse(p); if (n != 0 || p->nerr > 0) { p->tree = 0; + p->mrb->jmp = prev; return; } - if (!p->tree) { - p->tree = new_nil(p); - } parser_update_cxt(p, c); if (c && c->dump_result) { mrb_parser_dump(p->mrb, p->tree, 0); } } - MRB_CATCH(p->jmp) { - yyerror(p, "memory allocation error"); + MRB_CATCH(p->mrb->jmp) { p->nerr++; - p->tree = 0; - return; + if (p->mrb->exc == NULL) { + yyerror(p, "memory allocation error"); + p->nerr++; + p->tree = 0; + } } MRB_END_EXC(p->jmp); + p->mrb->jmp = prev; } MRB_API parser_state* @@ -7720,3 +7782,19 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) } #endif } + +typedef mrb_bool mrb_parser_foreach_top_variable_func(mrb_state *mrb, mrb_sym sym, void *user); +void mrb_parser_foreach_top_variable(mrb_state *mrb, struct mrb_parser_state *p, mrb_parser_foreach_top_variable_func *func, void *user); + +void +mrb_parser_foreach_top_variable(mrb_state *mrb, struct mrb_parser_state *p, mrb_parser_foreach_top_variable_func *func, void *user) +{ + const mrb_ast_node *n = p->tree; + if ((intptr_t)n->car == NODE_SCOPE) { + n = n->cdr->car; + for (; n; n = n->cdr) { + mrb_sym sym = sym(n->car); + if (sym && !func(mrb, sym, user)) break; + } + } +} diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 137e4d4cf..4fa1b4678 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -76,7 +76,6 @@ #include <ctype.h> #include <errno.h> -#include <stdlib.h> #include <string.h> #include <mruby.h> #include <mruby/compile.h> @@ -97,7 +96,6 @@ typedef struct mrb_parser_heredoc_info parser_heredoc_info; static int yyparse(parser_state *p); static int yylex(void *lval, parser_state *p); static void yyerror(parser_state *p, const char *s); -static void yywarn(parser_state *p, const char *s); static void yywarning(parser_state *p, const char *s); static void backref_error(parser_state *p, node *n); static void void_expr_error(parser_state *p, node *n); @@ -169,7 +167,7 @@ parser_palloc(parser_state *p, size_t size) void *m = mrb_pool_alloc(p->pool, size); if (!m) { - MRB_THROW(p->jmp); + MRB_THROW(p->mrb->jmp); } return m; } @@ -349,9 +347,10 @@ local_var_p(parser_state *p, mrb_sym sym) const mrb_sym *v = ir->lv; int i; - if (!v) break; - for (i=0; i+1 < ir->nlocals; i++) { - if (v[i] == sym) return TRUE; + if (v) { + for (i=0; i+1 < ir->nlocals; i++) { + if (v[i] == sym) return TRUE; + } } if (MRB_PROC_SCOPE_P(u)) break; u = u->upper; @@ -1310,7 +1309,7 @@ call_with_block(parser_state *p, node *a, node *b) } static node* -negate_lit(parser_state *p, node *n) +new_negate(parser_state *p, node *n) { return cons((node*)NODE_NEGATE, n); } @@ -1356,6 +1355,24 @@ var_reference(parser_state *p, node *lhs) return lhs; } +static node* +label_reference(parser_state *p, mrb_sym sym) +{ + const char *name = mrb_sym_name(p->mrb, sym); + node *n; + + if (local_var_p(p, sym)) { + n = new_lvar(p, sym); + } + else if (ISUPPER(name[0])) { + n = new_const(p, sym); + } + else { + n = new_fcall(p, sym, 0); + } + return n; +} + typedef enum mrb_string_type string_type; static node* @@ -1448,7 +1465,7 @@ heredoc_end(parser_state *p) /* xxx ----------------------------- */ -#line 1452 "mrbgems/mruby-compiler/core/y.tab.c" +#line 1469 "mrbgems/mruby-compiler/core/y.tab.c" # ifndef YY_CAST # ifdef __cplusplus @@ -1620,7 +1637,7 @@ extern int yydebug; #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED union YYSTYPE { -#line 1394 "mrbgems/mruby-compiler/core/parse.y" +#line 1411 "mrbgems/mruby-compiler/core/parse.y" node *nd; mrb_sym id; @@ -1628,7 +1645,7 @@ union YYSTYPE stack_type stack; const struct vtable *vars; -#line 1632 "mrbgems/mruby-compiler/core/y.tab.c" +#line 1649 "mrbgems/mruby-compiler/core/y.tab.c" }; typedef union YYSTYPE YYSTYPE; @@ -1946,16 +1963,16 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 3 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 12611 +#define YYLAST 12926 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 149 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 177 +#define YYNNTS 176 /* YYNRULES -- Number of rules. */ -#define YYNRULES 607 +#define YYNRULES 609 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 1063 +#define YYNSTATES 1072 #define YYUNDEFTOK 2 #define YYMAXUTOK 377 @@ -2014,67 +2031,67 @@ static const yytype_uint8 yytranslate[] = /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_int16 yyrline[] = { - 0, 1565, 1565, 1565, 1576, 1582, 1586, 1591, 1595, 1601, - 1603, 1602, 1616, 1643, 1649, 1653, 1658, 1662, 1668, 1668, - 1672, 1676, 1680, 1684, 1688, 1692, 1696, 1701, 1702, 1706, - 1710, 1714, 1718, 1725, 1728, 1732, 1736, 1740, 1744, 1748, - 1753, 1757, 1764, 1765, 1769, 1773, 1774, 1778, 1782, 1786, - 1790, 1794, 1804, 1803, 1818, 1827, 1828, 1831, 1832, 1839, - 1838, 1853, 1857, 1862, 1866, 1871, 1875, 1880, 1884, 1888, - 1892, 1896, 1902, 1906, 1912, 1913, 1919, 1923, 1927, 1931, - 1935, 1939, 1943, 1947, 1951, 1955, 1961, 1962, 1968, 1972, - 1978, 1982, 1988, 1992, 1996, 2000, 2004, 2008, 2014, 2020, - 2027, 2031, 2035, 2039, 2043, 2047, 2053, 2059, 2064, 2070, - 2074, 2077, 2081, 2085, 2092, 2093, 2094, 2095, 2100, 2107, - 2108, 2111, 2115, 2115, 2121, 2122, 2123, 2124, 2125, 2126, - 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, - 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, - 2147, 2148, 2149, 2150, 2153, 2153, 2153, 2154, 2154, 2155, - 2155, 2155, 2156, 2156, 2156, 2156, 2157, 2157, 2157, 2158, - 2158, 2158, 2159, 2159, 2159, 2159, 2160, 2160, 2160, 2160, - 2161, 2161, 2161, 2161, 2162, 2162, 2162, 2162, 2163, 2163, - 2163, 2163, 2164, 2164, 2167, 2171, 2175, 2179, 2183, 2187, - 2191, 2196, 2201, 2206, 2210, 2214, 2218, 2222, 2226, 2230, - 2234, 2238, 2242, 2246, 2250, 2254, 2258, 2262, 2266, 2270, - 2274, 2278, 2282, 2286, 2290, 2294, 2298, 2302, 2306, 2310, - 2314, 2318, 2322, 2326, 2330, 2334, 2338, 2342, 2346, 2350, - 2354, 2363, 2373, 2382, 2392, 2398, 2399, 2404, 2408, 2415, - 2419, 2427, 2431, 2447, 2473, 2474, 2477, 2478, 2479, 2484, - 2489, 2496, 2502, 2507, 2512, 2517, 2524, 2524, 2535, 2541, - 2545, 2551, 2552, 2555, 2561, 2567, 2572, 2579, 2584, 2589, - 2596, 2597, 2598, 2599, 2600, 2601, 2602, 2603, 2607, 2612, - 2611, 2623, 2627, 2622, 2632, 2632, 2636, 2640, 2644, 2648, - 2653, 2658, 2662, 2666, 2670, 2674, 2678, 2679, 2685, 2691, - 2684, 2703, 2711, 2719, 2719, 2719, 2726, 2726, 2726, 2733, - 2739, 2744, 2746, 2743, 2755, 2753, 2771, 2776, 2769, 2793, - 2791, 2807, 2817, 2828, 2832, 2836, 2840, 2846, 2853, 2854, - 2855, 2858, 2859, 2862, 2863, 2871, 2872, 2878, 2882, 2885, - 2889, 2893, 2897, 2902, 2906, 2910, 2914, 2920, 2919, 2929, - 2933, 2937, 2941, 2947, 2952, 2957, 2961, 2965, 2969, 2973, - 2977, 2981, 2985, 2989, 2993, 2997, 3001, 3005, 3009, 3013, - 3019, 3024, 3031, 3031, 3035, 3040, 3047, 3051, 3057, 3058, - 3061, 3066, 3069, 3073, 3079, 3083, 3090, 3089, 3104, 3114, - 3118, 3123, 3130, 3134, 3138, 3142, 3146, 3150, 3154, 3158, - 3162, 3169, 3168, 3183, 3182, 3198, 3206, 3215, 3218, 3225, - 3228, 3232, 3233, 3236, 3240, 3243, 3247, 3250, 3251, 3252, - 3253, 3256, 3257, 3263, 3264, 3265, 3269, 3275, 3276, 3282, - 3287, 3286, 3297, 3301, 3307, 3311, 3317, 3321, 3327, 3330, - 3331, 3334, 3340, 3346, 3347, 3350, 3357, 3356, 3370, 3374, - 3381, 3386, 3393, 3399, 3400, 3401, 3402, 3403, 3407, 3413, - 3417, 3423, 3424, 3425, 3429, 3435, 3439, 3443, 3447, 3451, - 3457, 3461, 3467, 3471, 3475, 3479, 3483, 3487, 3495, 3502, - 3513, 3514, 3518, 3522, 3521, 3538, 3539, 3542, 3548, 3566, - 3586, 3587, 3593, 3599, 3605, 3612, 3617, 3624, 3628, 3634, - 3638, 3644, 3645, 3648, 3652, 3658, 3662, 3666, 3670, 3676, - 3681, 3686, 3690, 3694, 3698, 3702, 3706, 3710, 3714, 3718, - 3722, 3726, 3730, 3734, 3738, 3743, 3749, 3754, 3759, 3764, - 3769, 3776, 3780, 3787, 3792, 3791, 3803, 3807, 3813, 3821, - 3829, 3837, 3841, 3847, 3851, 3857, 3858, 3861, 3866, 3873, - 3874, 3877, 3883, 3887, 3893, 3898, 3898, 3923, 3924, 3930, - 3935, 3941, 3942, 3945, 3951, 3956, 3966, 3973, 3974, 3975, - 3978, 3979, 3980, 3981, 3984, 3985, 3986, 3989, 3990, 3993, - 3997, 4003, 4004, 4010, 4011, 4014, 4015, 4018, 4021, 4022, - 4023, 4026, 4027, 4028, 4031, 4038, 4039, 4043 + 0, 1582, 1582, 1582, 1593, 1599, 1603, 1608, 1612, 1618, + 1620, 1619, 1633, 1660, 1666, 1670, 1675, 1679, 1685, 1685, + 1689, 1693, 1697, 1701, 1705, 1709, 1713, 1718, 1719, 1723, + 1727, 1731, 1735, 1742, 1745, 1749, 1753, 1757, 1761, 1765, + 1770, 1774, 1783, 1793, 1802, 1812, 1819, 1820, 1824, 1828, + 1829, 1833, 1837, 1841, 1845, 1849, 1859, 1858, 1873, 1882, + 1883, 1886, 1887, 1894, 1893, 1908, 1912, 1917, 1921, 1926, + 1930, 1935, 1939, 1943, 1947, 1951, 1957, 1961, 1967, 1968, + 1974, 1978, 1982, 1986, 1990, 1994, 1998, 2002, 2006, 2010, + 2016, 2017, 2023, 2027, 2033, 2037, 2043, 2047, 2051, 2055, + 2059, 2063, 2069, 2075, 2082, 2086, 2090, 2094, 2098, 2102, + 2108, 2114, 2119, 2125, 2129, 2132, 2136, 2140, 2147, 2148, + 2149, 2150, 2155, 2162, 2163, 2166, 2170, 2170, 2176, 2177, + 2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, + 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, + 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205, 2208, 2208, + 2208, 2209, 2209, 2210, 2210, 2210, 2211, 2211, 2211, 2211, + 2212, 2212, 2212, 2213, 2213, 2213, 2214, 2214, 2214, 2214, + 2215, 2215, 2215, 2215, 2216, 2216, 2216, 2216, 2217, 2217, + 2217, 2217, 2218, 2218, 2218, 2218, 2219, 2219, 2222, 2226, + 2230, 2234, 2238, 2242, 2246, 2251, 2256, 2261, 2265, 2269, + 2273, 2277, 2281, 2285, 2289, 2293, 2297, 2301, 2305, 2309, + 2313, 2317, 2321, 2325, 2329, 2333, 2337, 2341, 2345, 2349, + 2353, 2357, 2361, 2365, 2369, 2373, 2377, 2381, 2385, 2389, + 2393, 2397, 2401, 2405, 2409, 2418, 2428, 2437, 2447, 2453, + 2454, 2459, 2463, 2470, 2474, 2482, 2486, 2502, 2528, 2529, + 2532, 2533, 2534, 2539, 2544, 2551, 2557, 2562, 2567, 2572, + 2579, 2579, 2590, 2596, 2600, 2606, 2609, 2615, 2621, 2626, + 2633, 2638, 2643, 2650, 2651, 2652, 2653, 2654, 2655, 2656, + 2657, 2661, 2666, 2665, 2677, 2681, 2676, 2686, 2686, 2690, + 2694, 2698, 2702, 2707, 2712, 2716, 2720, 2724, 2728, 2732, + 2733, 2739, 2745, 2738, 2757, 2765, 2773, 2773, 2773, 2780, + 2780, 2780, 2787, 2793, 2798, 2800, 2797, 2809, 2807, 2825, + 2830, 2823, 2847, 2845, 2861, 2871, 2882, 2886, 2890, 2894, + 2900, 2907, 2908, 2909, 2912, 2913, 2916, 2917, 2925, 2926, + 2932, 2936, 2939, 2943, 2947, 2951, 2956, 2960, 2964, 2968, + 2974, 2973, 2983, 2987, 2991, 2995, 3001, 3006, 3011, 3015, + 3019, 3023, 3027, 3031, 3035, 3039, 3043, 3047, 3051, 3055, + 3059, 3063, 3067, 3073, 3078, 3085, 3085, 3089, 3094, 3101, + 3105, 3111, 3112, 3115, 3120, 3123, 3127, 3133, 3137, 3144, + 3143, 3158, 3168, 3172, 3177, 3184, 3188, 3192, 3196, 3200, + 3204, 3208, 3212, 3216, 3223, 3222, 3237, 3236, 3252, 3260, + 3269, 3272, 3279, 3282, 3286, 3287, 3290, 3294, 3297, 3301, + 3304, 3305, 3306, 3307, 3310, 3311, 3317, 3318, 3319, 3323, + 3336, 3337, 3343, 3348, 3347, 3358, 3362, 3368, 3372, 3385, + 3389, 3395, 3398, 3399, 3402, 3408, 3414, 3415, 3418, 3425, + 3424, 3438, 3442, 3456, 3461, 3475, 3481, 3482, 3483, 3484, + 3485, 3489, 3495, 3499, 3509, 3510, 3511, 3515, 3521, 3525, + 3529, 3533, 3537, 3543, 3547, 3553, 3557, 3561, 3565, 3569, + 3573, 3581, 3588, 3594, 3595, 3599, 3603, 3602, 3619, 3620, + 3623, 3629, 3647, 3667, 3668, 3674, 3680, 3686, 3693, 3698, + 3705, 3709, 3715, 3719, 3725, 3726, 3729, 3733, 3739, 3743, + 3747, 3751, 3757, 3762, 3767, 3771, 3775, 3779, 3783, 3787, + 3791, 3795, 3799, 3803, 3807, 3811, 3815, 3819, 3824, 3830, + 3835, 3840, 3845, 3850, 3857, 3861, 3868, 3873, 3872, 3884, + 3888, 3894, 3902, 3910, 3918, 3922, 3928, 3932, 3938, 3939, + 3942, 3947, 3954, 3955, 3958, 3964, 3968, 3974, 3979, 3979, + 4004, 4005, 4011, 4016, 4022, 4028, 4033, 4037, 4047, 4054, + 4055, 4056, 4059, 4060, 4061, 4062, 4065, 4066, 4067, 4070, + 4071, 4074, 4078, 4084, 4085, 4091, 4092, 4095, 4096, 4099, + 4102, 4103, 4104, 4107, 4108, 4111, 4116, 4119, 4120, 4124 }; #endif @@ -2141,9 +2158,9 @@ static const char *const yytname[] = "f_arg_item", "@32", "f_arg", "f_opt_asgn", "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark", "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg", "singleton", "$@33", - "assoc_list", "assocs", "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 + "assoc_list", "assocs", "assoc", "operation", "operation2", "operation3", + "dot_or_colon", "call_op", "call_op2", "opt_terms", "opt_nl", "rparen", + "trailer", "term", "nl", "terms", "none", YY_NULLPTR }; #endif @@ -2170,12 +2187,12 @@ static const yytype_int16 yytoknum[] = }; # endif -#define YYPACT_NINF (-848) +#define YYPACT_NINF (-862) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-608) +#define YYTABLE_NINF (-610) #define yytable_value_is_error(Yyn) \ ((Yyn) == YYTABLE_NINF) @@ -2184,113 +2201,114 @@ static const yytype_int16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - -848, 137, 2991, -848, 7860, 9984, 10326, 6168, -848, 9630, - 9630, -848, -848, 10098, 7350, 5903, 8096, 8096, -848, -848, - 8096, 3648, 3240, -848, -848, -848, -848, 97, 7350, -848, - 49, -848, -848, -848, 6310, 3104, -848, -848, 6452, -848, - -848, -848, -848, -848, -848, -848, 51, 9748, 9748, 9748, - 9748, 168, 5162, 891, 8568, 8922, 7632, -848, 7068, 1196, - 473, 810, 1387, 1396, -848, 273, 9866, 9748, -848, 1021, - -848, 1343, -848, 279, 1637, 1722, -848, -848, 130, 112, - -848, 121, 10212, -848, 152, 12292, 671, 677, 36, 82, - -848, 321, -848, -848, -848, -848, -848, -848, -848, -848, - -848, 46, 187, -848, 200, 71, -848, -848, -848, -848, - -848, 181, 181, 207, 689, 917, -848, 9630, 283, 5281, - 352, 1722, 1722, -848, 174, -848, 806, -848, -848, 71, - -848, -848, -848, -848, -848, -848, -848, -848, -848, -848, - -848, -848, -848, -848, -848, -848, -848, -848, -848, -848, - -848, -848, -848, -848, -848, -848, -848, -848, 24, 103, - 146, 166, -848, -848, -848, -848, -848, -848, 179, 182, - 197, 225, -848, 228, -848, -848, -848, -848, -848, -848, - -848, -848, -848, -848, -848, -848, -848, -848, -848, -848, - -848, -848, -848, -848, -848, -848, -848, -848, -848, -848, - -848, -848, -848, -848, -848, -848, -848, -848, -848, 233, - 4340, 341, 279, 680, 277, 12416, 843, 52, 309, 76, - 680, 9630, 9630, 883, 348, -848, -848, 1109, 381, 98, - 107, -848, -848, -848, -848, -848, -848, -848, -848, -848, - 7209, -848, -848, 278, -848, -848, -848, -848, -848, -848, - 1021, -848, 338, -848, 402, -848, -848, 1021, 3376, 9748, - 9748, 9748, 9748, -848, 12354, -848, -848, 292, 379, 292, - -848, -848, -848, 8214, -848, -848, -848, 8096, -848, -848, - -848, 5903, 9630, -848, -848, 317, 5400, -848, 1118, 368, - 12478, 12478, 203, 7978, 5162, 343, 1021, 1343, 1021, 380, - -848, 7978, 1021, 359, 1352, 1352, -848, 12354, 364, 1352, - -848, 461, 10440, 383, 1158, 1213, 1216, 1732, -848, -848, - -848, -848, 1421, -848, -848, -848, -848, -848, -848, 518, - 1507, -848, -848, 499, -848, 880, -848, 1513, -848, 1528, - 430, 441, -848, -848, -848, -848, 5665, 9630, 9630, 9630, - 9630, 7978, 9630, 9630, 155, -848, -848, -848, -848, -848, - -848, -848, -848, -848, -848, -848, -848, 1378, 431, 444, - 4340, 9748, -848, 409, 524, 446, -848, 1021, -848, -848, - -848, 475, 9748, -848, 480, 556, 481, 576, -848, -848, - 511, 4340, -848, -848, 9040, -848, 5162, 7746, 492, 9040, - 9748, 9748, 9748, 9748, 9748, 9748, 9748, 9748, 9748, 9748, - 9748, 9748, 9748, 9748, 588, 9748, 9748, 9748, 9748, 9748, - 9748, 9748, 9748, 9748, 9748, 9748, 9748, 1200, -848, 8096, - -848, 2511, -848, -848, 11750, -848, -848, -848, -848, 9866, - 9866, -848, 542, -848, 279, -848, 1218, -848, -848, -848, - -848, -848, -848, 2629, 8096, 10718, 4340, 9630, -848, -848, - -848, 627, 630, 218, -848, 4486, 629, 9748, 10804, 8096, - 10890, 9748, 9748, 4778, 106, 106, 122, 10976, 8096, 11062, - -848, 583, -848, 5400, 402, -848, -848, 9158, 645, -848, - 518, 9748, 12416, 12416, 12416, 9748, 374, -848, 8332, -848, - 9748, -848, 8686, 6022, 520, 1021, 292, 292, -848, -848, - 1016, 526, -848, -848, 7350, 4897, 534, 10804, 10890, 9748, - 1343, 1021, -848, -848, 5784, 541, 1343, -848, -848, 8804, - -848, 1021, 8922, -848, -848, -848, 1218, 121, 10440, -848, - 10440, 11148, 8096, 11234, 2150, -848, -848, -848, 1539, 5400, - 518, -848, -848, -848, -848, -848, -848, -848, 9748, 9748, - -848, -848, -848, -848, -848, -848, -848, -848, -848, -848, - 1672, 1021, 1021, 545, 9748, 661, 12416, 78, -848, -848, - -848, 47, -848, -848, 2150, -848, 12416, 2150, -848, -848, - 1545, -848, -848, 9748, 673, 38, 9748, -848, 12008, 292, - -848, 1021, 10440, 549, -848, -848, -848, 648, 572, 1998, - -848, -848, 1267, 219, 2194, 2194, 2194, 2194, 2128, 2128, - 2694, 2786, 2194, 2194, 12478, 12478, 465, 465, -848, 368, - 11946, 2128, 2128, 1923, 1923, 1531, 674, 674, 368, 368, - 368, 3784, 6808, 4056, 6926, -848, 181, -848, 554, 292, - 258, -848, 507, -848, -848, 3512, -848, -848, 2370, 38, - 38, -848, 2848, -848, -848, -848, -848, -848, 1021, 9630, - 4340, 1033, 515, -848, 181, 557, 181, 685, 1016, 7491, - -848, 9276, 683, -848, 425, -848, 6570, 6689, 563, 295, - 296, 683, -848, -848, -848, -848, 66, 115, 567, 126, - 128, 9630, 7350, 571, 706, 12416, 80, -848, 518, 12416, - 12416, 518, 9748, 12354, -848, 292, 12416, -848, -848, -848, - -848, 8450, 8686, -848, -848, -848, 585, -848, -848, 170, - 1343, 1021, 1352, 492, -848, 1033, 515, 586, 1058, 1092, - 581, 89, -848, 591, -848, 368, 368, -848, 1286, 1021, - 592, -848, -848, 1886, 11822, -848, 676, -848, 446, -848, - -848, -848, 593, 595, 596, -848, 612, 676, 596, 11884, - -848, -848, 2150, 4340, -848, -848, 12079, 9394, -848, -848, - 10440, 7978, 9866, 9748, 11320, 8096, 11406, 55, 9866, 9866, - -848, 542, 509, 8332, 9866, 9866, -848, 542, 82, 130, - 4340, 5400, 38, -848, 1021, 740, -848, -848, -848, -848, - 12008, -848, 665, -848, 5043, 745, -848, 9630, 750, -848, - 9748, 9748, 298, 9748, 9748, 753, 5546, 5546, 140, 106, - -848, -848, -848, 9512, 4632, 518, 12416, -848, 6022, 292, - -848, -848, -848, 1095, 615, 625, 4340, 5400, -848, -848, - -848, 631, -848, 1803, 1021, 9748, -848, 2150, -848, 1545, - -848, 1545, -848, 1545, -848, -848, 9748, -848, 581, 581, - 10554, -848, 635, 446, 638, 10554, -848, 643, 649, -848, - 757, 9748, 12150, -848, -848, 12416, 3920, 4192, 651, 305, - 449, 9748, 9748, -848, -848, -848, -848, -848, 9866, -848, - -848, -848, -848, -848, -848, -848, 789, 684, 5400, 4340, - -848, -848, 10668, 680, -848, -848, 5546, -848, -848, 680, - -848, 9748, -848, 797, 825, -848, 12416, 365, -848, 8686, - -848, 1320, 826, 710, 1836, 1836, 1295, -848, 12416, 596, - 704, 596, 596, 12416, 724, 727, 801, 1322, 78, -848, - -848, 1742, -848, 1322, 2150, -848, 1545, -848, -848, 12221, - 464, 12416, 12416, -848, -848, -848, -848, 718, 844, 805, - -848, 1335, 1213, 1216, 4340, -848, 4486, -848, -848, 5546, - -848, -848, -848, -848, 12, -848, -848, -848, -848, 721, - 721, 1836, 726, -848, 1545, -848, -848, -848, -848, -848, - -848, 11492, -848, 446, 78, -848, -848, 731, 735, 739, - -848, 742, 739, -848, -848, 1218, 11578, 8096, 11664, 630, - 425, 851, 1320, -848, 1836, 721, 1836, 596, 741, 744, - -848, 2150, -848, 1545, -848, 1545, -848, 1545, -848, -848, - 1033, 515, 748, 746, 804, -848, -848, -848, -848, 721, - -848, 739, 751, 739, 739, 1095, -848, 1545, -848, -848, - -848, 739, -848 + -862, 113, 3344, -862, 8328, 10452, 10794, 6636, -862, 10098, + 10098, -862, -862, 10566, 7818, 6252, 8564, 8564, -862, -862, + 8564, 3997, 3582, -862, -862, -862, -862, 10, 7818, -862, + 20, -862, -862, -862, 6778, 3179, -862, -862, 6920, -862, + -862, -862, -862, -862, -862, -862, 292, 10216, 10216, 10216, + 10216, 114, 5511, 1275, 9036, 9390, 8100, -862, 7536, 628, + 100, 502, 965, 992, -862, 487, 10334, 10216, -862, 756, + -862, 1407, -862, 364, 1613, 1613, -862, -862, 155, 65, + -862, 67, 10680, -862, 115, 12651, 82, 154, 137, 88, + -862, 103, -862, -862, -862, -862, -862, -862, -862, -862, + -862, 81, 142, -862, 277, 97, -862, -862, -862, -862, + -862, 107, 107, 10, 618, 1033, -862, 10098, 148, 5630, + 567, 1261, 1261, -862, 145, -862, 206, -862, -862, 97, + -862, -862, -862, -862, -862, -862, -862, -862, -862, -862, + -862, -862, -862, -862, -862, -862, -862, -862, -862, -862, + -862, -862, -862, -862, -862, -862, -862, -862, 54, 106, + 110, 158, -862, -862, -862, -862, -862, -862, 173, 192, + 216, 219, -862, 238, -862, -862, -862, -862, -862, -862, + -862, -862, -862, -862, -862, -862, -862, -862, -862, -862, + -862, -862, -862, -862, -862, -862, -862, -862, -862, -862, + -862, -862, -862, -862, -862, -862, -862, -862, -862, 280, + 4689, 224, 364, 1613, 1613, 810, 160, 12775, 377, 320, + 193, 331, 810, 10098, 10098, 644, 235, -862, -862, 645, + 275, 86, 116, -862, -862, -862, -862, -862, -862, -862, + -862, -862, 7677, -862, -862, 162, -862, -862, -862, -862, + -862, -862, 756, -862, 557, -862, 287, -862, -862, 756, + 3725, 10216, 10216, 10216, 10216, -862, 12713, -862, -862, 180, + 258, 180, -862, -862, -862, 8682, -862, -862, -862, 8564, + -862, -862, -862, 6252, 6490, -862, 186, 5749, -862, 678, + 225, 2722, 2722, 288, 8446, 5511, 198, 756, 1407, 756, + 267, -862, 8446, 756, 251, 1367, 1367, -862, 12713, 256, + 1367, -862, 342, 10908, 257, 768, 926, 1070, 1707, -862, + -862, -862, -862, 1192, -862, -862, -862, -862, -862, -862, + 570, 1262, -862, -862, 326, -862, 663, -862, 1270, -862, + 1280, 313, 324, -862, -862, -862, -862, 6014, 10098, 10098, + 10098, 10098, 8446, 10098, 10098, 63, -862, -862, -862, -862, + -862, -862, -862, -862, -862, -862, -862, -862, 2066, 318, + 337, 4689, 10216, -862, 308, 409, 336, -862, 756, -862, + -862, -862, 339, 10216, -862, 341, 453, 367, 462, -862, + -862, 399, 4689, -862, -862, 9508, -862, 5511, 8214, 380, + 9508, 10216, 10216, 10216, 10216, 10216, 10216, 10216, 10216, 10216, + 10216, 10216, 10216, 10216, 10216, 479, 10216, 10216, 10216, 10216, + 10216, 10216, 10216, 10216, 10216, 10216, 10216, 10216, 11186, -862, + 8564, -862, 11272, -862, -862, 12476, -862, -862, -862, -862, + 10334, 10334, -862, 438, -862, 364, -862, 1071, -862, -862, + -862, -862, -862, -862, 11358, 8564, 11444, 4689, 10098, -862, + -862, -862, 532, 550, 382, 456, 460, -862, 4835, 578, + 10216, 11530, 8564, 11616, 10216, 10216, 5127, 73, 73, 124, + 11702, 8564, 11788, -862, 535, -862, 5749, 287, -862, -862, + 9626, 585, -862, 10216, 12775, 12775, 12775, 10216, -862, -862, + 8800, -862, 10216, -862, 9154, 6371, 470, 756, 180, 180, + -862, -862, 1006, 472, -862, -862, -862, 7818, 5246, 464, + 11530, 11616, 10216, 1407, 756, -862, -862, 6133, 489, 1407, + -862, -862, 9272, -862, 756, 9390, -862, -862, -862, 1071, + 67, 10908, -862, 10908, 11874, 8564, 11960, 1470, -862, -862, + -862, 1285, 5749, 570, -862, -862, -862, -862, -862, -862, + -862, 10216, 10216, -862, -862, -862, -862, -862, -862, -862, + -862, -862, -862, 1586, 756, 756, 500, 10334, 633, 12775, + 92, -862, -862, -862, 47, -862, -862, 1470, -862, 12775, + 1470, -862, -862, 1815, -862, -862, 10334, 638, 56, 10216, + -862, 2992, 180, -862, 756, 10908, 526, -862, -862, -862, + 626, 553, 1418, -862, -862, 1092, 407, 3503, 3503, 3503, + 3503, 1726, 1726, 12793, 2453, 3503, 3503, 2722, 2722, 918, + 918, -862, 225, 12775, 1726, 1726, 1345, 1345, 1622, 314, + 314, 225, 225, 225, 4133, 7276, 4405, 7394, -862, 107, + -862, 538, 180, 343, -862, 413, -862, -862, 3861, -862, + -862, 1934, 56, 56, -862, 2201, -862, -862, -862, -862, + -862, 756, 10098, 4689, 1091, 634, -862, 107, 543, 107, + 683, 1006, 7959, -862, 9744, 682, -862, 10216, 10216, 619, + -862, 7038, 7157, 562, 458, 465, 682, -862, -862, -862, + -862, 62, 112, 568, 130, 134, 10098, 7818, 576, 701, + 12775, 774, -862, 12775, 12775, 493, 10216, 12713, -862, 180, + 12775, -862, -862, -862, -862, 8918, 9154, -862, -862, -862, + 582, -862, -862, 55, 1407, 756, 1367, 380, -862, 1091, + 634, 581, 1159, 1160, -862, 72, -862, 593, -862, 225, + 225, -862, 1007, 756, 606, -862, -862, 2252, 708, 2789, + -862, 703, -862, 336, -862, -862, -862, 624, 625, 627, + -862, 635, 703, 627, 744, 2908, -862, -862, 1470, 4689, + -862, -862, 3393, 9862, -862, -862, 10908, 8446, 10334, 10216, + 12046, 8564, 12132, 217, 10334, 10334, -862, 438, 433, 8800, + 10334, 10334, -862, 438, 88, 155, 4689, 5749, 56, -862, + 756, 778, -862, -862, -862, -862, 2992, -862, 704, -862, + 5392, 787, -862, 10098, 789, -862, 10216, 10216, 476, 10216, + 10216, 795, 5895, 5895, 135, 73, -862, -862, -862, 9980, + 4981, 12775, -862, 6371, 180, -862, -862, -862, 1173, 667, + 1415, 4689, 5749, -862, -862, -862, 671, -862, 1596, 756, + 10216, 10216, -862, 1470, -862, 1815, -862, 1815, -862, 1815, + -862, -862, 10216, 10216, -862, -862, -862, 11022, -862, 681, + 336, 688, 11022, -862, 692, 696, -862, 828, 10216, 12509, + -862, -862, 12775, 4269, 4541, 705, 517, 528, 10216, 10216, + -862, -862, -862, -862, -862, 10334, -862, -862, -862, -862, + -862, -862, -862, 829, 711, 5749, 4689, -862, -862, 11136, + 810, -862, -862, 5895, -862, -862, 810, -862, 10216, -862, + 836, 840, -862, 12775, 244, -862, 9154, -862, 1385, 842, + 723, 1676, 1676, 1081, -862, 12775, 12775, 627, 721, 627, + 627, 12775, 12775, 740, 741, 821, 1093, 92, -862, -862, + 1793, -862, 1093, 1470, -862, 1815, -862, -862, 12580, 575, + 12775, 12775, -862, -862, -862, -862, 742, 864, 827, -862, + 1136, 926, 1070, 4689, -862, 4835, -862, -862, 5895, -862, + -862, -862, -862, 746, -862, -862, -862, -862, 752, 752, + 1676, 755, -862, 1815, -862, -862, -862, -862, -862, -862, + 12218, -862, 336, 92, -862, -862, 761, 763, 769, -862, + 779, 769, -862, -862, 1071, 12304, 8564, 12390, 550, 619, + 868, 1385, 493, 1676, 752, 1676, 627, 766, 782, -862, + 1470, -862, 1815, -862, 1815, -862, 1815, -862, -862, 1091, + 634, 745, 853, 995, -862, -862, -862, -862, 752, -862, + 769, 788, 769, 769, 1173, -862, 1815, -862, -862, -862, + 769, -862 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -2298,159 +2316,160 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_int16 yydefact[] = { - 2, 0, 0, 1, 0, 0, 0, 0, 289, 0, - 0, 313, 316, 0, 0, 593, 333, 334, 335, 336, - 301, 266, 266, 484, 483, 485, 486, 595, 0, 10, - 0, 488, 487, 489, 475, 579, 477, 476, 479, 478, - 471, 472, 433, 434, 490, 491, 287, 0, 0, 0, - 0, 0, 0, 291, 607, 607, 84, 308, 0, 0, - 0, 0, 0, 0, 448, 0, 0, 0, 3, 593, - 6, 9, 27, 33, 535, 535, 45, 56, 55, 0, - 72, 0, 76, 86, 0, 50, 244, 0, 57, 306, - 280, 281, 431, 282, 283, 284, 429, 428, 460, 430, - 427, 482, 0, 285, 286, 266, 5, 8, 333, 334, - 301, 607, 409, 0, 109, 110, 287, 0, 0, 0, - 0, 535, 535, 112, 492, 337, 0, 482, 286, 0, - 329, 164, 174, 165, 161, 190, 191, 192, 193, 172, - 187, 180, 170, 169, 185, 168, 167, 163, 188, 162, - 175, 179, 181, 173, 166, 182, 189, 184, 183, 176, - 186, 171, 160, 178, 177, 159, 157, 158, 154, 155, - 156, 114, 116, 115, 149, 150, 127, 128, 129, 136, - 133, 135, 130, 131, 151, 152, 137, 138, 142, 145, - 146, 132, 134, 124, 125, 126, 139, 140, 141, 143, - 144, 147, 148, 153, 565, 51, 117, 118, 564, 0, - 0, 0, 54, 0, 0, 50, 0, 482, 0, 286, - 0, 0, 0, 108, 0, 348, 347, 0, 0, 482, - 286, 183, 176, 186, 171, 154, 155, 156, 114, 115, - 0, 119, 121, 20, 120, 451, 456, 455, 601, 604, - 593, 603, 0, 453, 0, 605, 602, 594, 577, 0, - 0, 0, 0, 261, 273, 70, 265, 607, 431, 607, - 569, 71, 69, 607, 255, 302, 68, 0, 254, 408, - 67, 593, 0, 596, 18, 0, 0, 217, 0, 218, - 205, 208, 298, 0, 0, 0, 593, 15, 593, 74, - 14, 0, 593, 0, 598, 598, 245, 0, 0, 598, - 567, 0, 0, 82, 0, 92, 99, 535, 465, 464, - 466, 467, 0, 463, 462, 435, 440, 439, 442, 0, - 0, 437, 444, 0, 446, 0, 458, 0, 469, 0, - 473, 474, 49, 232, 233, 4, 594, 0, 0, 0, - 0, 0, 0, 0, 542, 538, 537, 536, 539, 540, - 544, 556, 511, 512, 560, 559, 555, 535, 0, 500, - 0, 504, 509, 607, 514, 607, 534, 0, 541, 543, - 546, 520, 0, 553, 520, 558, 520, 0, 518, 496, - 500, 0, 396, 398, 0, 88, 0, 80, 77, 0, + 2, 0, 0, 1, 0, 0, 0, 0, 292, 0, + 0, 316, 319, 0, 0, 595, 336, 337, 338, 339, + 304, 270, 270, 487, 486, 488, 489, 597, 0, 10, + 0, 491, 490, 492, 478, 581, 480, 479, 482, 481, + 474, 475, 436, 437, 493, 494, 290, 0, 0, 0, + 0, 0, 0, 294, 609, 609, 88, 311, 0, 0, + 0, 0, 0, 0, 451, 0, 0, 0, 3, 595, + 6, 9, 27, 33, 538, 538, 49, 60, 59, 0, + 76, 0, 80, 90, 0, 54, 248, 0, 61, 309, + 283, 284, 434, 285, 286, 287, 432, 431, 463, 433, + 430, 485, 0, 288, 289, 270, 5, 8, 336, 337, + 304, 609, 412, 0, 113, 114, 290, 0, 0, 0, + 0, 538, 538, 116, 495, 340, 0, 485, 289, 0, + 332, 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, 131, 132, 133, 140, + 137, 139, 134, 135, 155, 156, 141, 142, 146, 149, + 150, 136, 138, 128, 129, 130, 143, 144, 145, 147, + 148, 151, 152, 157, 568, 55, 121, 122, 567, 0, + 0, 0, 58, 538, 538, 0, 0, 54, 0, 485, + 0, 289, 0, 0, 0, 112, 0, 351, 350, 0, + 0, 485, 289, 187, 180, 190, 175, 158, 159, 160, + 118, 119, 0, 123, 125, 20, 124, 454, 459, 458, + 603, 605, 595, 606, 0, 456, 0, 607, 604, 596, + 579, 0, 0, 0, 0, 265, 276, 74, 269, 609, + 434, 609, 572, 75, 73, 609, 259, 305, 72, 0, + 258, 411, 71, 595, 0, 18, 0, 0, 221, 0, + 222, 209, 212, 301, 0, 0, 0, 595, 15, 595, + 78, 14, 0, 595, 0, 600, 600, 249, 0, 0, + 600, 570, 0, 0, 86, 0, 96, 103, 538, 468, + 467, 469, 470, 0, 466, 465, 438, 443, 442, 445, + 0, 0, 440, 447, 0, 449, 0, 461, 0, 472, + 0, 476, 477, 53, 236, 237, 4, 596, 0, 0, + 0, 0, 0, 0, 0, 545, 541, 540, 539, 542, + 543, 547, 559, 514, 515, 563, 562, 558, 538, 0, + 503, 0, 507, 512, 609, 517, 609, 537, 0, 544, + 546, 549, 523, 0, 556, 523, 561, 523, 0, 521, + 499, 0, 0, 399, 401, 0, 92, 0, 84, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 204, 207, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 590, 607, - 589, 0, 592, 591, 0, 413, 411, 307, 432, 0, - 0, 402, 61, 305, 326, 109, 110, 111, 473, 474, - 500, 493, 324, 0, 607, 0, 0, 0, 588, 587, - 52, 0, 607, 298, 339, 0, 338, 0, 0, 607, - 0, 0, 0, 0, 0, 0, 298, 0, 607, 0, - 321, 0, 122, 0, 0, 452, 454, 0, 0, 606, - 571, 0, 274, 576, 268, 0, 271, 262, 0, 270, - 0, 263, 0, 593, 0, 593, 607, 607, 256, 267, - 593, 0, 304, 48, 0, 0, 0, 0, 0, 0, - 17, 593, 296, 13, 594, 73, 292, 295, 299, 600, - 246, 599, 600, 248, 300, 568, 98, 90, 0, 85, - 0, 0, 607, 0, 535, 309, 393, 468, 0, 0, - 443, 449, 436, 438, 445, 447, 459, 470, 0, 0, - 7, 21, 22, 23, 24, 25, 46, 47, 502, 548, - 0, 593, 593, 520, 0, 0, 503, 0, 516, 563, - 513, 0, 517, 501, 0, 527, 549, 0, 530, 557, - 0, 532, 561, 0, 0, 607, 0, 28, 30, 0, - 31, 593, 0, 78, 89, 44, 34, 42, 0, 249, - 194, 29, 0, 286, 222, 227, 228, 229, 224, 226, - 236, 237, 230, 231, 203, 206, 234, 235, 32, 214, - 595, 223, 225, 219, 220, 221, 209, 210, 211, 212, - 213, 580, 585, 581, 586, 407, 266, 405, 0, 607, - 580, 582, 581, 583, 406, 266, 580, 581, 266, 607, - 607, 35, 249, 195, 41, 202, 59, 62, 0, 0, - 0, 109, 110, 113, 0, 0, 607, 0, 593, 0, - 290, 607, 607, 419, 607, 340, 584, 297, 0, 580, - 581, 607, 342, 314, 341, 317, 584, 297, 0, 580, - 581, 0, 0, 0, 0, 273, 0, 320, 572, 574, - 573, 0, 0, 275, 269, 607, 575, 570, 253, 251, - 257, 258, 260, 303, 597, 19, 0, 26, 201, 75, - 16, 593, 598, 91, 83, 95, 97, 0, 94, 96, - 595, 0, 461, 0, 450, 215, 216, 542, 356, 593, - 349, 499, 497, 0, 240, 331, 0, 510, 607, 562, - 519, 547, 520, 520, 520, 554, 520, 542, 520, 242, - 332, 384, 382, 0, 381, 380, 279, 0, 87, 81, - 0, 0, 0, 0, 0, 607, 0, 0, 0, 0, - 404, 65, 410, 258, 0, 0, 403, 63, 399, 58, - 0, 0, 607, 327, 0, 0, 410, 330, 566, 53, - 420, 421, 607, 422, 0, 607, 345, 0, 0, 343, - 0, 0, 410, 0, 0, 0, 0, 0, 410, 0, - 123, 457, 319, 0, 0, 272, 276, 264, 593, 607, - 11, 293, 247, 93, 0, 386, 0, 0, 310, 441, - 357, 354, 545, 0, 593, 0, 515, 0, 523, 0, - 525, 0, 531, 0, 528, 533, 0, 379, 595, 595, - 506, 507, 607, 607, 364, 0, 551, 364, 364, 362, - 0, 0, 277, 79, 43, 250, 580, 581, 0, 580, - 581, 0, 0, 40, 199, 39, 200, 66, 0, 37, - 197, 38, 198, 64, 400, 401, 0, 0, 0, 0, - 494, 325, 0, 0, 424, 346, 0, 12, 426, 0, - 311, 0, 312, 0, 0, 322, 275, 607, 252, 259, - 392, 0, 0, 0, 0, 0, 352, 498, 241, 520, - 520, 520, 520, 243, 0, 0, 0, 505, 0, 360, - 361, 364, 372, 550, 0, 375, 0, 377, 397, 278, - 410, 239, 238, 36, 196, 414, 412, 0, 0, 0, - 423, 0, 100, 107, 0, 425, 0, 315, 318, 0, - 416, 417, 415, 390, 595, 388, 391, 395, 394, 358, - 355, 0, 350, 524, 0, 521, 526, 529, 385, 383, - 298, 0, 508, 607, 0, 363, 370, 364, 364, 364, - 552, 364, 364, 60, 328, 106, 0, 607, 0, 607, - 607, 0, 0, 387, 0, 353, 0, 520, 584, 297, - 359, 0, 367, 0, 369, 0, 376, 0, 373, 378, - 103, 105, 0, 580, 581, 418, 344, 323, 389, 351, - 522, 364, 364, 364, 364, 101, 368, 0, 365, 371, - 374, 364, 366 + 0, 208, 211, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 592, + 609, 591, 0, 594, 593, 0, 416, 414, 310, 435, + 0, 0, 405, 65, 308, 329, 113, 114, 115, 476, + 477, 503, 496, 327, 0, 609, 0, 0, 0, 590, + 589, 56, 0, 609, 301, 0, 0, 342, 0, 341, + 0, 0, 609, 0, 0, 0, 0, 0, 0, 301, + 0, 609, 0, 324, 0, 126, 0, 0, 455, 457, + 0, 0, 608, 576, 277, 578, 272, 0, 597, 266, + 0, 274, 0, 267, 0, 595, 0, 595, 609, 609, + 260, 271, 595, 0, 307, 52, 598, 0, 0, 0, + 0, 0, 0, 17, 595, 299, 13, 596, 77, 295, + 298, 302, 602, 250, 601, 602, 252, 303, 571, 102, + 94, 0, 89, 0, 0, 609, 0, 538, 312, 396, + 471, 0, 0, 446, 452, 439, 441, 448, 450, 462, + 473, 0, 0, 7, 21, 22, 23, 24, 25, 50, + 51, 505, 551, 0, 595, 595, 523, 0, 0, 506, + 0, 519, 566, 516, 0, 520, 504, 0, 530, 552, + 0, 533, 560, 0, 535, 564, 0, 0, 609, 0, + 28, 30, 0, 31, 595, 0, 82, 93, 48, 34, + 46, 0, 253, 198, 29, 0, 289, 226, 231, 232, + 233, 228, 230, 240, 241, 234, 235, 207, 210, 238, + 239, 32, 218, 597, 227, 229, 223, 224, 225, 213, + 214, 215, 216, 217, 582, 587, 583, 588, 410, 270, + 408, 0, 609, 582, 584, 583, 585, 409, 270, 582, + 583, 270, 609, 609, 35, 253, 199, 45, 206, 63, + 66, 0, 0, 0, 113, 114, 117, 0, 0, 609, + 0, 595, 0, 293, 609, 609, 422, 0, 0, 609, + 343, 586, 300, 0, 582, 583, 609, 345, 317, 344, + 320, 586, 300, 0, 582, 583, 0, 0, 0, 0, + 276, 0, 323, 575, 574, 275, 0, 278, 273, 609, + 577, 573, 257, 255, 261, 262, 264, 306, 599, 19, + 0, 26, 205, 79, 16, 595, 600, 95, 87, 99, + 101, 0, 98, 100, 597, 0, 464, 0, 453, 219, + 220, 545, 359, 595, 352, 502, 500, 0, 41, 244, + 334, 0, 513, 609, 565, 522, 550, 523, 523, 523, + 557, 523, 545, 523, 43, 246, 335, 387, 385, 0, + 384, 383, 282, 0, 91, 85, 0, 0, 0, 0, + 0, 609, 0, 0, 0, 0, 407, 69, 413, 262, + 0, 0, 406, 67, 402, 62, 0, 0, 609, 330, + 0, 0, 413, 333, 569, 57, 423, 424, 609, 425, + 0, 609, 348, 0, 0, 346, 0, 0, 413, 0, + 0, 0, 0, 0, 413, 0, 127, 460, 322, 0, + 0, 279, 268, 595, 609, 11, 296, 251, 97, 0, + 389, 0, 0, 313, 444, 360, 357, 548, 0, 595, + 0, 0, 518, 0, 526, 0, 528, 0, 534, 0, + 531, 536, 0, 0, 382, 597, 597, 509, 510, 609, + 609, 367, 0, 554, 367, 367, 365, 0, 0, 280, + 83, 47, 254, 582, 583, 0, 582, 583, 0, 0, + 40, 203, 39, 204, 70, 0, 37, 201, 38, 202, + 68, 403, 404, 0, 0, 0, 0, 497, 328, 0, + 0, 427, 349, 0, 12, 429, 0, 314, 0, 315, + 0, 0, 325, 278, 609, 256, 263, 395, 0, 0, + 0, 0, 0, 355, 501, 42, 245, 523, 523, 523, + 523, 44, 247, 0, 0, 0, 508, 0, 363, 364, + 367, 375, 553, 0, 378, 0, 380, 400, 281, 413, + 243, 242, 36, 200, 417, 415, 0, 0, 0, 426, + 0, 104, 111, 0, 428, 0, 318, 321, 0, 419, + 420, 418, 393, 597, 391, 394, 398, 397, 361, 358, + 0, 353, 527, 0, 524, 529, 532, 388, 386, 301, + 0, 511, 609, 0, 366, 373, 367, 367, 367, 555, + 367, 367, 64, 331, 110, 0, 609, 0, 609, 609, + 0, 0, 390, 0, 356, 0, 523, 586, 300, 362, + 0, 370, 0, 372, 0, 379, 0, 376, 381, 107, + 109, 0, 582, 583, 421, 347, 326, 392, 354, 525, + 367, 367, 367, 367, 105, 371, 0, 368, 374, 377, + 367, 369 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -848, -848, -848, 382, -848, 28, -848, -255, 267, -848, - 120, -848, -31, -208, 229, 64, 100, -848, 83, -46, - -848, -605, -848, 30, 886, -183, -19, -66, -274, -472, - -45, 1894, -87, 898, 20, 14, -848, -848, 15, -848, - 1140, -848, 707, 65, -55, -403, 72, 26, -848, -298, - -233, 280, 375, -340, 129, -848, -848, -848, -848, -848, - -848, -848, -848, -848, -848, -848, -848, -848, -848, -848, - -848, 8, -216, -467, -115, -563, -848, -848, -848, 136, - 91, -848, -565, -848, -848, -424, -848, -110, -848, -848, - 114, -848, -848, -848, -86, -848, -848, -469, -848, -104, - -848, -848, -848, -848, -848, -15, 21, -178, -848, -848, - -848, -848, -405, -273, -848, 669, -848, -848, -848, 16, - -848, -848, -848, 1698, 2055, 921, 1364, -848, -848, -848, - 405, 74, -668, 354, -16, -848, -848, -848, 73, -20, - -195, -246, -815, -685, -526, -848, 135, -735, -520, -847, - -11, -505, -848, -439, -848, 262, -318, -848, -848, -848, - 45, 667, -422, 609, -265, -848, -848, -53, -848, 34, - -18, 366, -264, 601, -21, -62, -2 + -862, -862, -862, 419, -862, 28, -862, -277, 32, -862, + 74, -862, -195, -390, 422, 1715, 1901, -862, 1, -58, + -862, -635, -862, 14, 927, -207, -30, -53, -275, -506, + -12, 985, -38, 933, 13, -21, -862, -862, 19, -862, + 1204, -862, 149, 41, -202, -374, 66, 5, -862, -392, + -262, -131, 161, -361, 35, -862, -862, -862, -862, -862, + -862, -862, -862, -862, -862, -862, -862, -862, -862, -862, + -862, 8, -179, -442, -88, -590, -862, -862, -862, 164, + 85, -862, -558, -862, -862, -218, -862, -86, -862, -862, + 141, -862, -862, -862, -85, -862, -862, -472, -862, -77, + -862, -862, -862, -862, -862, 38, 71, -210, -862, -862, + -862, -862, -862, -245, -862, 698, -862, -862, -862, 31, + -862, -862, -862, 2358, 2761, 946, 2172, -862, -862, 0, + 590, -6, 76, 397, 24, -862, -862, -862, 329, -445, + -14, -229, -842, -706, -60, -862, 227, -711, -525, -861, + -3, -517, -862, 75, -862, 202, -308, -862, -862, -862, + 102, -438, 612, -157, -862, -862, -82, -862, 34, -26, + 344, -249, -180, -281, -67, -2 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 1, 2, 68, 69, 70, 285, 461, 462, 296, - 297, 514, 72, 606, 73, 74, 75, 679, 213, 76, - 77, 667, 802, 78, 79, 298, 80, 81, 82, 539, - 83, 214, 123, 124, 241, 242, 243, 702, 644, 207, - 85, 303, 610, 645, 275, 504, 505, 276, 277, 266, - 497, 532, 649, 600, 86, 210, 301, 731, 302, 317, - 741, 221, 826, 222, 827, 701, 979, 670, 668, 909, - 456, 288, 465, 693, 818, 819, 228, 749, 934, 1005, - 952, 868, 773, 774, 869, 844, 984, 985, 545, 848, - 393, 595, 88, 89, 443, 660, 659, 488, 982, 682, - 812, 913, 917, 90, 91, 92, 330, 331, 549, 93, - 94, 95, 550, 251, 252, 253, 483, 96, 97, 98, - 324, 99, 100, 217, 218, 103, 219, 452, 669, 368, - 450, 370, 371, 372, 871, 872, 373, 374, 375, 760, - 585, 377, 378, 379, 380, 570, 381, 382, 383, 876, - 877, 384, 385, 386, 387, 388, 578, 209, 457, 308, - 507, 491, 270, 129, 674, 647, 460, 455, 434, 511, - 845, 512, 530, 255, 256, 257, 300 + -1, 1, 2, 68, 69, 70, 286, 462, 463, 297, + 298, 517, 72, 609, 73, 213, 214, 682, 215, 76, + 77, 670, 808, 78, 79, 299, 80, 81, 82, 542, + 83, 216, 123, 124, 243, 244, 245, 707, 647, 207, + 85, 304, 613, 648, 277, 506, 507, 278, 279, 268, + 499, 535, 652, 603, 86, 210, 302, 735, 303, 318, + 745, 223, 832, 224, 833, 706, 988, 673, 671, 916, + 457, 289, 468, 698, 824, 825, 230, 753, 941, 1014, + 961, 875, 779, 780, 876, 849, 993, 994, 548, 853, + 394, 598, 88, 89, 444, 663, 662, 491, 991, 685, + 818, 920, 924, 90, 91, 92, 331, 332, 552, 93, + 94, 95, 553, 253, 254, 255, 486, 96, 97, 98, + 325, 99, 100, 219, 220, 103, 221, 453, 672, 369, + 370, 371, 372, 373, 878, 879, 374, 375, 376, 377, + 588, 378, 379, 380, 381, 573, 382, 383, 384, 883, + 884, 385, 386, 387, 388, 389, 581, 209, 458, 309, + 509, 272, 129, 677, 650, 461, 456, 435, 513, 850, + 514, 533, 257, 258, 259, 301 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -2458,549 +2477,572 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 106, 268, 268, 437, 473, 268, 283, 346, 695, 282, - 87, 313, 87, 126, 126, 704, 398, 216, 216, 278, - 342, 227, 206, 216, 216, 216, 648, 205, 216, 206, - 244, 447, 107, 299, 431, 433, 501, 875, 538, 268, - 268, 533, 284, 206, 244, 535, 263, 263, 280, 254, - 263, 675, 306, 310, 376, 376, 551, 582, 761, 611, - 87, 269, 269, 851, 314, 269, 688, 765, 734, 121, - 121, 546, 389, 206, 216, 698, 438, 121, 323, 762, - 717, 333, 335, 337, 339, 708, 274, 279, 265, 271, - 314, -103, 272, 220, 800, 801, 464, 435, 250, 305, - 309, 376, 376, 345, 870, 122, 122, 1010, 435, 278, - 717, 521, 891, 122, -484, 575, 986, 771, 846, 815, - 121, 572, 71, -100, 71, 216, 432, 87, 825, 756, - 779, 442, -107, 692, 125, 125, 594, 3, -480, 737, - -105, 428, 125, -481, -480, 763, 121, -106, 766, 391, - 364, -102, 553, -104, 1022, 553, 122, 553, 392, 553, - 249, 553, 646, 470, 772, -101, 655, -100, 472, 658, - 441, -484, -108, -100, 479, 365, 274, 279, 892, 362, - 363, 364, 122, 430, 1010, 125, 897, 286, -92, 588, - 676, 591, 903, -483, 441, 245, 391, -107, 246, 247, - 714, 677, 847, 646, 714, 655, 365, 986, -95, 436, - -580, 125, 568, 601, 676, 273, 875, 551, 87, 875, - 436, 245, 496, 292, 246, 247, 248, 761, 249, 216, - 216, 661, 664, 394, 524, 518, -485, 908, 212, 212, - -92, 281, 531, 531, 212, 249, 537, 531, 762, -99, - -483, 992, 248, 676, 249, 206, -486, -97, 268, -581, - 323, 543, 268, 395, -98, 499, 538, 499, -94, -488, - -96, 508, -487, 399, 501, 299, 569, 744, 676, 439, - 870, 216, -93, 870, 484, 216, 870, -489, 870, 216, - 216, -73, 440, -485, 87, 519, 875, 376, 740, 451, - 717, 87, 87, 263, 474, 475, 835, 263, 883, 87, - 519, 440, -87, -486, 763, -475, 352, 353, -479, 295, - 314, -107, 269, 458, -106, 273, -488, 761, 538, -487, - 523, 340, 341, 878, 445, 761, 870, 765, 446, -106, - -107, 811, -99, 548, -489, -98, 444, 376, 597, 509, - 794, 281, 603, 607, 87, 216, 216, 216, 216, 87, - 216, 216, 925, 870, 980, 870, 673, 870, 605, 870, - 553, 579, -475, 579, 560, -479, 121, 299, 87, -102, - 459, 42, 888, 814, 43, 487, 295, 823, 824, 870, - 921, 267, 267, 607, 607, 267, 463, 794, 467, 87, - -94, 471, 216, 476, 87, 314, 480, 612, 605, 605, - 448, 449, 122, 520, 268, 805, -102, -104, 940, -101, - 482, 526, 487, 714, 714, 761, -102, 508, 59, 304, - 561, 562, 563, 564, 496, 744, 490, 216, 551, 268, - 856, 125, 817, 814, 944, 945, 653, 612, 612, 653, - 212, 212, 508, 485, 268, 515, 246, 247, 981, 263, - 683, 121, 216, 268, 87, 216, 71, 508, 842, 415, - 653, 565, 733, 87, 537, 283, 508, 216, 711, 369, - 390, 87, 837, 268, 263, 653, 216, 268, 522, -595, - 834, 87, -595, -595, 653, 714, 654, 122, 761, 263, - 528, -72, 573, 534, 499, 499, 538, 717, 263, 761, - 510, 513, 1008, 106, 268, 1011, 536, 268, 880, 646, - 654, 655, 249, 87, 376, 540, 125, 268, 725, 206, - 244, 558, 87, 653, 332, 654, 537, 326, 327, 720, - 508, 795, 559, 715, 654, 906, 314, 498, 314, 502, - 216, 577, 574, 516, 949, 950, 898, 87, 653, 786, - 554, 295, 744, 326, 327, -495, 415, 858, 860, 862, - -104, 864, 263, 865, 732, 580, 212, 212, 212, 212, - 893, 566, 567, 654, 529, -101, 899, 901, 581, 328, - 329, 932, 1052, 775, 422, 423, 424, 425, 426, 795, - 796, 898, 121, 798, 121, -297, 837, 589, 654, 283, - 314, 105, 787, 105, 1042, 328, 329, 584, 105, 105, - -297, 796, 587, 590, 105, 105, 105, 592, -104, 105, - -101, 714, 593, 245, 604, 71, 246, 247, 122, 628, - 122, 666, 680, 681, 730, 685, 547, 499, 506, -96, - 758, -93, 267, 278, 968, -297, 278, 775, 775, -581, - 707, 105, -297, 295, 525, 719, 121, 125, 527, 125, - 531, 724, 791, 727, 278, 105, 755, 216, 87, 813, - 816, 797, 816, -87, 799, 1030, 678, 753, 770, 816, - 963, 780, 781, 782, 206, 792, 464, 974, 806, 809, - 807, 814, 122, 976, 822, 750, 268, 268, 828, 216, - 831, 790, 904, 499, 537, -577, 830, 206, 244, 283, - 274, 832, 764, 274, 840, 768, 105, 843, 105, 249, - 849, 125, 684, 568, 853, 857, 607, 859, 861, 790, - 691, 274, 607, 895, 993, 995, 996, 997, 607, 607, - 703, 605, 804, 676, 863, 911, 579, 605, 912, 916, - 930, -337, -102, 605, 605, 920, 839, 427, 922, 599, - 268, 931, 958, 935, 599, 415, -337, 948, 268, -475, - 951, 87, 428, 508, 829, 954, 721, 722, 314, 87, - 612, 956, 960, 216, -475, 245, 612, 216, 246, 247, - 775, 653, 612, 612, 965, 424, 425, 426, 87, 87, - 914, -337, 977, 918, 466, 263, 743, 429, -337, 105, - -104, 466, 87, 966, 430, 216, 248, -577, 249, -475, - 105, 105, 1050, -577, 87, 87, -475, 499, 839, 759, - 978, 987, 87, 759, 121, 873, 994, 283, 283, 988, - 998, 654, 607, 999, 87, 87, 1000, 1013, 489, 1014, - 1015, -102, 706, 1024, -102, -102, 1047, 605, 1026, 718, - 579, 579, 334, 1031, 326, 327, 723, 1033, 947, 777, - 122, 1035, 105, 953, 1037, -580, 105, 729, -581, 1055, - 105, 105, -102, 1057, -102, 105, 453, 726, 212, 225, - 919, 884, 105, 105, 130, 1046, 612, 874, 867, 125, - 105, 428, 1048, 905, 268, 1045, 87, 87, 1018, -104, - 971, 486, -104, -104, 87, 816, 328, 329, 208, 793, - 212, 757, 1002, 468, 121, 500, 0, 751, 752, 121, - 1007, 0, 555, -578, 326, 327, 454, 489, 428, 0, - -104, 0, -104, 430, 0, 105, 105, 105, 105, 105, - 105, 105, 105, 283, 0, 0, 1023, 778, 955, 957, - 122, 0, 0, -287, 0, 122, 121, 0, 583, 105, - 0, 0, 87, 469, 87, 0, 833, 87, -287, 0, - 430, 0, 939, 0, 941, 502, 328, 329, 942, 125, - 105, 579, 268, 105, 125, 105, -294, -479, 105, -294, - -294, 0, 122, 0, 0, 508, 0, 683, 816, 0, - 0, 1003, -479, -287, 873, 216, 0, 873, 0, 873, - -287, 0, 0, 653, 879, 0, -294, -294, 105, -294, - 0, 125, 1006, 0, 808, 0, 212, 263, 105, 105, - 0, 0, 0, 352, 353, -578, 599, -479, 0, -584, - 0, -578, 0, 105, -479, 105, 105, 0, 907, 989, - 990, 0, 0, 0, 105, 694, 694, 873, 105, 0, - 0, 915, 105, 654, -580, 0, 0, 105, 0, 1009, - 0, 1012, 105, 923, 924, 0, 0, 841, 1032, 1034, - 1036, 927, 1038, 1039, 873, 0, 873, 0, 873, 0, - 873, 0, 0, 0, 933, 852, 0, 0, -581, 929, - 0, -410, 0, -584, 105, 489, 1025, 0, 0, 1027, - 873, 245, 489, 105, 246, 247, 245, 0, -584, 246, - 247, 0, 1056, 1058, 1059, 1060, 663, 665, -580, 215, - 215, 105, 1062, 0, 0, 215, 264, 264, 105, 0, - 264, 1049, 248, -580, 249, 0, 1051, 248, 1053, 249, - 0, -584, 1054, -584, 0, 967, 0, -580, 663, 665, - -584, 0, -581, 975, 0, -410, 0, 287, 289, 290, - 291, 0, 1061, 0, 264, 307, -580, -581, -580, 477, - -410, 0, -580, 0, 928, -580, 343, 344, 517, 0, - 759, 0, 0, 879, 428, 0, 879, 0, 879, 0, - 937, 0, 0, 428, 0, 0, 728, 0, 0, 0, - -581, 0, -581, -410, 0, -410, -581, 0, 0, -581, - 0, 1019, -410, 1020, 0, 0, 1021, 0, 541, 478, - 0, 641, 642, 0, 0, 643, 430, 215, 469, 325, - 326, 327, 0, 428, 0, 430, 879, 0, 0, 803, - 174, 175, 176, 177, 178, 179, 180, 181, 105, 105, - 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, - 0, 0, 0, 879, 0, 879, 0, 879, 542, 879, - 188, 189, 190, -482, 0, 430, -286, 466, -298, 0, - 105, 0, 328, 329, 0, 0, 0, 0, -482, 879, - 0, -286, 0, -298, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 0, 201, 202, 747, 0, 355, - 356, 357, 358, 203, 273, 0, 747, 0, 355, 356, - 357, 358, 0, -482, 0, 359, -286, 784, -298, 0, - -482, 215, 215, -286, 359, -298, 104, 0, 104, 128, - 128, 983, 428, 355, 356, 357, 358, 230, 0, 0, - 0, 0, 105, 347, 348, 349, 350, 351, 0, 359, - 105, 105, 0, 0, 105, 0, 0, 105, 105, 492, - 493, 494, 343, 105, 105, 910, 0, 785, 0, 105, - 105, 0, 1001, 264, 430, 0, 104, 264, 0, 0, - 316, 215, 215, 105, 0, 1016, 105, 428, 850, 354, - 694, 355, 356, 357, 358, 105, 105, 991, 0, 0, - 428, 0, 0, 105, 0, 0, 316, 359, 0, 0, - 336, 326, 327, 0, 0, 105, 105, 0, 0, 338, - 326, 327, 454, 571, 0, 0, 0, 245, 0, 430, - 246, 247, 360, 0, 0, 1017, 0, 0, 361, 362, - 363, 364, 430, 104, 547, 326, 327, 215, 215, 215, - 215, 0, 215, 215, 496, 894, 896, 0, 248, 0, - 249, 900, 902, 328, 329, 0, 365, 105, 0, 366, - 0, 576, 328, 329, 466, 0, 0, 105, 105, 0, - 466, 0, 586, 0, 0, 105, 0, 894, 896, 0, - 900, 902, 0, 0, 598, 0, 0, 328, 329, 609, - 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, - 624, 625, 626, 627, 0, 629, 630, 631, 632, 633, - 634, 635, 636, 637, 638, 639, 640, 0, 0, 264, - 552, 326, 327, 0, 104, 0, 556, 326, 327, 662, - 662, 0, 0, 105, 0, 105, 0, 0, 105, 0, - 0, 557, 326, 327, 264, 0, 767, 215, 355, 356, - 357, 358, 742, 326, 327, 964, 0, 662, 0, 264, - 0, 662, 662, 0, 359, 0, 0, 0, 264, 412, - 413, 0, 0, 328, 329, 0, 105, 705, 964, 328, - 329, 709, 415, 0, 0, 710, 0, 0, 713, 360, - 716, 0, 307, 291, 328, 329, 362, 363, 364, 0, - 104, 0, 0, 0, 0, 328, 329, 104, 104, 662, - 422, 423, 424, 425, 426, 104, 0, 0, 0, 713, - 0, 0, 307, 365, 0, 0, 316, 0, 0, 0, - 0, 0, 264, 0, 0, 0, 0, 0, 354, 0, - 355, 356, 357, 358, 0, 0, 0, 0, 745, 746, - 101, 0, 101, 127, 127, 127, 359, 0, 0, 0, - 104, 229, 0, 0, 754, 104, 0, 0, 0, 0, - 0, 0, 0, 747, 0, 355, 356, 357, 358, 0, - 0, 360, 0, 769, 104, 0, 776, 361, 362, 363, - 364, 359, 0, 0, 0, 0, 0, 0, 0, 0, - 101, 0, 0, 0, 315, 104, 0, 0, -607, 0, - 104, 316, 0, 613, 0, 365, 360, 0, 366, 0, - 0, 0, 748, 354, 0, 355, 356, 357, 358, 0, - 315, 367, 0, 354, 0, 355, 356, 357, 358, 0, - 0, 359, 0, 354, 0, 355, 356, 357, 358, 0, - 0, 359, 0, 613, 613, 0, 0, 0, 0, 215, - 0, 359, 0, 0, 0, 0, 360, 101, 0, 0, - 104, 810, 361, 362, 363, 364, 360, 0, 0, 104, - 0, 0, 361, 362, 363, 364, 360, 104, 0, 0, - 0, 215, 361, 362, 363, 364, 0, 104, 0, 0, - 365, 0, 836, 366, 747, 0, 355, 356, 357, 358, - 365, 713, 307, 366, 0, 0, 367, 0, 0, 0, - 365, 0, 359, 366, 0, 0, 544, 0, 0, 104, - 0, 0, 0, 0, 1004, 0, 0, 747, 104, 355, - 356, 357, 358, 0, 0, 0, 84, 360, 84, 0, - 0, 0, 316, 936, 316, 359, 0, 226, 101, 0, - 0, 0, 0, 104, 0, 0, 0, 882, 0, 0, - 0, 0, 662, 885, 0, 264, 0, 0, 662, 662, - 360, 0, 0, 713, 662, 662, 0, 354, 0, 355, - 356, 357, 358, 0, 0, 0, 84, 0, 0, 0, - 0, 0, 0, 0, 0, 359, 0, 215, 0, 0, - 662, 662, 0, 662, 662, 0, 316, 0, 0, 0, - 0, 854, 0, 926, 0, 0, 0, 0, 291, 0, - 360, 0, 0, 0, 101, 0, 361, 362, 363, 364, - 0, 101, 101, 0, 0, 938, 0, 0, 0, 101, - 0, 0, 0, 0, 0, 0, 943, 0, 0, 0, - 315, 412, 413, 84, 365, 0, 0, 366, 0, 0, - 0, 959, 0, 0, 415, 0, 0, 0, 0, 0, - 0, 961, 962, 0, 104, 0, 0, 0, 662, 0, - 0, 0, 783, 0, 101, 0, 0, 0, 0, 101, - 0, 421, 422, 423, 424, 425, 426, 102, 0, 102, - 0, 662, 0, 0, 0, 0, 0, 0, 101, 307, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 0, 0, 0, 0, 412, 413, 0, 101, - 0, 0, 0, 0, 101, 315, 0, 0, 0, 415, - 0, 0, 0, 0, 84, 0, 0, 102, 0, 0, + 106, 284, 347, 516, 438, 432, 434, 285, 343, 503, + 87, 222, 87, 126, 126, 709, 252, 218, 218, 280, + 205, 229, 300, 218, 218, 218, 206, 282, 218, 399, + 265, 265, 107, 206, 265, 469, 700, 738, 541, 614, + 125, 125, 469, 476, 314, 246, 856, 206, 125, 256, + 664, 667, 307, 311, 270, 270, 651, 536, 270, 246, + 87, 538, 276, 281, 315, 770, 721, 882, 585, 392, + 767, 324, 390, 390, 218, 391, 71, 206, 71, 492, + 448, 678, 267, 273, 296, 554, 274, -107, 524, 549, + 315, 125, 270, 270, 578, 821, 995, 721, 693, 785, + 697, 851, 1019, 346, 806, 807, 831, 703, 718, 280, + 443, -104, 718, 3, 436, 597, 392, 125, 271, 271, + 571, 556, 271, 436, 556, 218, 556, 87, 556, 439, + 556, 334, 336, 338, 340, 777, 473, -109, 500, 575, + 504, -111, 765, 761, -487, 765, 442, 482, 765, -110, + 365, 296, 276, 281, 283, -106, 306, 310, 287, -108, + -105, 333, 904, 42, 327, 328, 43, 492, 910, 293, + 442, 741, -340, -483, 532, 366, -77, 269, 269, 1019, + 680, 269, 778, 393, 572, 852, 395, -340, 247, 995, + 604, 248, 249, 363, 364, 365, -486, -91, 586, 446, + -488, -487, -104, 447, -99, 608, -582, 521, 392, 396, + 59, 390, 390, 465, 466, 305, 329, 330, 87, 250, + 366, 251, -340, -96, 477, 478, 437, 433, -96, -340, + 527, 218, 218, 546, 440, 437, 400, 1001, 534, 534, + 767, 275, 429, 534, 428, 608, 608, 503, -489, 882, + 915, 275, 882, -486, -101, 324, -583, -488, -103, 429, + 540, 206, 820, -491, 490, 300, -102, 501, 541, 501, + 452, 649, -98, 510, 898, 658, -100, -97, 661, 464, + 890, 470, -490, 218, 431, 474, 487, 218, 721, 265, + 479, 218, 218, 265, 430, 87, 454, 699, 699, 679, + 483, 431, 87, 87, 485, -489, -492, 490, 748, -478, + 87, 429, 765, 270, 649, 502, 658, 270, 744, 519, + -491, 315, 498, 817, 518, 679, 416, 296, -482, 882, + 541, 526, 247, 718, 718, 248, 249, 600, 770, -490, + 899, 556, 610, 525, 989, 511, 455, 492, 125, 564, + 565, 566, 567, 431, 492, 87, 218, 218, 218, 218, + 87, 218, 218, -492, 679, 251, -478, 300, 523, 441, + 459, 591, 582, 594, 582, 563, 529, 725, 726, 87, + 522, 271, 610, 610, -484, -482, 606, 557, -76, 679, + 327, 328, 531, 932, 551, 537, 811, 539, -111, 543, + 87, 353, 354, 218, 900, 87, 315, 718, 615, -110, + 906, 908, -483, -112, 561, 416, 676, 895, 765, -103, + 765, 71, 765, 475, 765, 562, 568, 460, 510, 296, + -102, 212, 212, 125, 516, 800, 508, 212, 218, 577, + 269, -104, 329, 330, 265, 425, 426, 427, 615, 615, + 580, 656, -111, 510, 656, 862, 802, 842, -498, 804, + 583, 686, 990, 218, -106, 87, 218, 471, 270, 265, + 510, 783, 715, 657, 522, 656, 87, 802, 584, 510, + 218, 587, 429, 590, 87, -98, 265, 847, 737, 218, + 540, 809, 656, 270, 87, 265, 729, 657, 721, 441, + 689, 656, 887, -110, 592, 801, 501, 501, 696, 593, + 270, 541, 516, 595, 657, 972, 106, 472, 708, 270, + 596, 799, 607, 657, 431, 905, 87, 766, -111, 913, + 631, 469, 840, 792, -108, 87, 206, 669, 270, 445, + 656, 724, 270, 510, 718, 341, 342, 683, 246, 315, + 829, 315, 540, 218, -105, -100, 602, 830, 765, 265, + 87, 602, 657, 684, 335, 656, 327, 328, 928, 516, + 270, 958, 959, 270, 939, -97, 125, 687, 125, -106, + 839, 688, 842, 270, 747, 218, -108, 657, 504, 666, + 668, 758, 71, 608, 690, 576, 781, -105, 550, 608, + 712, 734, 719, 731, 218, 608, 608, 793, 247, 800, + 774, 248, 249, 315, 105, 723, 105, 728, 329, 330, + 801, 105, 105, 666, 668, 449, 450, 105, 105, 105, + 917, -91, 105, 649, 736, 658, 823, 820, -106, 977, + 125, 251, 757, 528, -579, 212, 212, 530, 760, -108, + 501, 711, 1051, 776, 797, 699, 280, 953, 954, 280, + 781, 781, 768, 803, 105, 771, 805, 905, 786, 534, + 787, 732, 488, 810, 788, 248, 249, 280, 105, 798, + 218, 87, 819, 822, 812, 247, 836, 822, 248, 249, + 796, 326, 327, 328, 822, 815, -105, 766, 813, 276, + 820, 206, 276, 828, 1039, 512, 515, 835, -478, 834, + 608, 451, 451, 936, 218, 837, 838, 501, 796, 911, + 276, 845, 848, -478, -300, 558, 206, 327, 328, 105, + 610, 105, 854, 540, -290, 480, 610, 902, 246, -300, + 469, 983, 610, 610, 329, 330, 469, 985, 858, -290, + 429, 516, 860, 864, 866, 868, -579, 870, -478, 871, + 571, 582, -579, 270, 270, -478, 863, 865, 520, 867, + 212, 212, 212, 212, -300, 569, 570, 869, -583, 329, + 330, -300, 764, 429, -290, 481, 764, 87, 872, 510, + 467, -290, 431, 918, 315, 87, 615, 919, 766, 218, + 754, 923, 615, 218, 927, 265, 781, 766, 615, 615, + 929, 656, 937, 942, 87, 87, 921, 769, 472, 925, + 773, 125, 105, 957, 926, 431, 467, 844, 87, 270, + 960, 218, 768, 657, 963, 105, 105, 270, 965, 914, + 87, 87, 501, 967, 974, 602, 969, 610, 87, 722, + 975, 986, 922, 885, 877, 987, 727, 996, 544, 87, + 87, 891, 997, 1003, 930, 931, 1007, 1008, 733, -106, + 679, 247, 934, 429, 248, 249, 1009, 582, 582, 1023, + 681, 1022, 1024, 1056, 940, 956, 1064, 105, 1031, 247, + 962, 105, 248, 249, 1033, 105, 105, 1035, 1027, 105, + 766, 844, 250, 1040, 251, 1042, 105, 105, 545, 763, + -582, 1044, 125, 615, 105, 431, 498, 125, 755, 756, + 250, 1046, 251, 87, 87, 247, -583, 980, 248, 249, + 1066, 87, 822, 1002, 1004, 1005, 1006, 730, 948, 130, + 227, 1055, 874, 901, 903, 1057, 912, 976, 784, 907, + 909, 1054, 489, 208, 125, 984, 250, 1016, 251, 105, + 105, 105, 105, 105, 105, 105, 105, 1032, -106, 964, + 966, -106, -106, 766, 270, 901, 903, 762, 907, 909, + 886, 1011, 0, 105, 766, 0, 0, 84, 0, 84, + 0, 87, 0, 87, 0, 0, 87, 0, 228, -106, + 0, -106, 0, 0, 105, 881, 0, 105, 0, 105, + 582, -108, 105, 0, 0, 1028, -485, 1029, 0, 416, + 1030, 0, 1059, 0, 510, 814, 686, 822, 337, 327, + 328, -485, 0, 877, 218, 1017, 877, 84, 1020, 877, + 265, 877, 105, 353, 354, 1015, 656, 423, 424, 425, + 426, 427, 105, 105, 973, 339, 327, 328, 751, -580, + 356, 357, 358, 359, 270, 0, -485, 105, 657, 105, + 105, 0, 0, -485, 0, 0, 360, 973, 0, 846, + 105, 329, 330, 0, 105, 0, 0, 0, 105, 877, + 947, 0, 949, 105, 212, 0, 950, 857, 105, 0, + 0, 1041, 1043, 1045, 84, 1047, 1048, 880, 329, 330, + -108, 0, 0, -108, -108, 1061, 877, -586, 877, 0, + 877, 247, 877, -482, 248, 249, 0, 0, 212, 0, + 105, 0, 751, 0, 356, 357, 358, 359, -482, 105, + 0, -108, 877, -108, 0, 1065, 1067, 1068, 1069, 855, + 360, 0, 250, 0, 251, 1071, 0, 105, 0, 764, + -289, -301, 886, 0, 105, 886, 0, 886, 998, 999, + 0, -580, 0, -482, 0, -289, -301, -580, 0, 0, + -482, -586, 790, 1010, 0, -582, -583, 935, 0, 105, + 1018, 0, 1021, 0, 0, 84, -586, 429, 429, -413, + 0, 0, 0, 944, 0, 0, 0, 0, 105, 0, + -289, -301, 0, 217, 217, 886, 0, -289, -301, 217, + 266, 266, 0, 1000, 266, 0, 1025, 1034, 0, -586, + 1036, -586, 791, 455, 0, -582, 0, 0, -586, 431, + 431, 429, 886, 0, 886, 212, 886, 0, 886, -582, + -583, 288, 290, 291, 292, 550, 327, 328, 266, 308, + 0, 0, 1058, -413, -582, -583, 0, 1060, 886, 1062, + 344, 345, 84, 1063, 0, 0, 1026, 0, -413, 84, + 84, 0, 0, 431, 105, 105, 1012, 84, 0, 880, + 0, 0, 880, 1070, 880, 0, 0, -582, -583, -582, + -583, 0, 0, -582, -583, 0, -582, -583, 329, 330, + 0, -413, 355, -413, 356, 357, 358, 359, 105, 0, + -413, 217, 0, 0, 0, 555, 327, 328, 0, 0, + 360, 0, 84, 559, 327, 328, 0, 84, 0, 0, + 0, 0, 880, 560, 327, 328, 0, 0, 746, 327, + 328, 0, 0, 0, 0, 361, 84, 0, 0, 0, + 0, 362, 363, 364, 365, 0, 0, 0, 0, 880, + 0, 880, 0, 880, 0, 880, 0, 84, 329, 330, + 0, 0, 84, 0, 0, 611, 329, 330, 0, 366, + -297, 105, 367, -297, -297, 880, 329, 330, 0, 105, + 105, 329, 330, 105, 0, 368, 105, 105, 0, 0, + 0, 0, 105, 105, 0, 0, 0, 0, 105, 105, + -297, -297, 0, -297, 0, 611, 611, 217, 217, 0, + 0, 0, 105, 413, 414, 105, 992, 0, 356, 357, + 358, 359, 84, 0, 105, 105, 416, 348, 349, 350, + 351, 352, 105, 84, 360, 0, 0, 0, 0, 0, + 0, 84, 789, 105, 105, 494, 495, 496, 344, 0, + 0, 84, 0, 422, 423, 424, 425, 426, 427, 266, + 0, 0, 247, 266, 0, 248, 249, 217, 217, 0, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 0, 84, 0, 0, 413, 414, 0, 498, + 0, 0, 84, 250, 0, 251, 0, 105, 0, 416, + 0, 355, 0, 356, 357, 358, 359, 105, 105, 0, + 247, 0, 0, 248, 249, 105, 0, 84, 0, 360, + 417, 0, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 217, 217, 217, 217, 0, 217, 217, 0, + -276, 938, 0, 251, 361, 0, 0, 0, 0, 0, + 362, 363, 364, 365, 0, 0, 579, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 589, 0, 0, + 0, 0, 0, 0, 0, 105, 0, 105, 366, 601, + 105, 367, 0, 0, 612, 617, 618, 619, 620, 621, + 622, 623, 624, 625, 626, 627, 628, 629, 630, 0, + 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, + 642, 643, 0, 0, 266, 0, 0, 751, 105, 356, + 357, 358, 359, 0, 665, 665, 0, 751, 0, 356, + 357, 358, 359, 0, 0, 360, 0, 0, 84, 266, + 0, 0, 217, 0, 355, 360, 356, 357, 358, 359, + 0, 0, 0, 0, 665, 0, 266, 0, 665, 665, + 361, 0, 360, 0, 0, 266, 752, 0, 0, 0, + 361, 0, 0, 0, 710, 0, 943, 713, 0, 0, + 0, 714, 0, 0, 717, 0, 720, 361, 308, 292, + 413, 414, 0, 362, 363, 364, 365, 74, 0, 74, + 121, 121, 0, 416, 0, 0, 665, 751, 121, 356, + 357, 358, 359, 0, -609, 0, 717, 0, 0, 308, + 0, 366, 0, 0, 367, 360, 0, 0, 0, 266, + 0, 423, 424, 425, 426, 427, 0, 368, 355, 0, + 356, 357, 358, 359, 84, 749, 750, 74, 0, 0, + 361, 121, 84, 611, 0, 0, 360, 0, 0, 611, + 0, 759, 0, 0, 0, 611, 611, 0, 0, 0, + 0, 84, 84, 0, 0, 0, 0, 121, 0, 0, + 775, 361, 0, 782, 0, 84, 0, 362, 363, 364, + 365, 0, 0, 0, 413, 414, 0, 84, 84, 0, + 0, 0, 0, 0, 0, 84, 0, 416, 0, 0, + 0, 0, 0, 0, 74, 366, 84, 84, 367, 0, + 0, 0, 0, 0, 355, 0, 356, 357, 358, 359, + 0, 547, 420, 421, 422, 423, 424, 425, 426, 427, + 0, 0, 360, 0, 0, 0, 772, 0, 356, 357, + 358, 359, 0, 0, 0, 0, 217, 0, 0, 0, + 0, 0, 0, 0, 360, 0, 0, 361, 816, 0, + 611, 759, 775, 362, 363, 364, 365, 0, 0, 0, + 84, 84, 0, 75, 979, 75, 122, 122, 84, 361, + 217, 0, 0, 0, 122, 0, 363, 364, 365, 0, + 841, 366, 0, 0, 367, 74, 0, 0, 0, 717, + 308, 0, 0, 0, -609, 1013, 0, 0, 0, 0, + 0, 0, 0, 366, 0, 0, 0, -609, -609, -609, + -609, -609, -609, 75, -609, 0, 0, 122, 0, 0, + -609, -609, 0, 0, 0, 0, 0, 0, 84, 0, + 84, -609, -609, 84, -609, -609, -609, -609, -609, 0, + 0, 0, 0, 122, 0, 0, 0, 889, 0, 0, + 0, 0, 665, 892, 0, 266, 0, 0, 665, 665, + 0, 0, 74, 717, 665, 665, 0, 0, 0, 74, + 74, 0, 0, 0, 0, 0, 0, 74, 0, 0, + 75, 0, 0, 0, -609, 0, 0, 217, 121, 0, + 665, 665, 0, 665, 665, 0, 0, 0, 0, -609, + 0, 0, 0, 933, 0, 0, 0, 292, 0, -609, + 0, 0, -609, -609, 0, 0, 0, 0, 0, 0, + 0, 0, 74, 0, 945, 946, 0, 74, 0, 0, + 0, 0, -609, -609, 0, 0, 951, 952, 275, -609, + -609, -609, -609, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 968, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 970, 971, 0, 0, 0, 74, 0, 665, + 0, 75, 74, 121, 0, 74, 0, 355, 0, 356, + 357, 358, 359, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 665, 0, 0, 360, 0, 0, 0, 0, + 308, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 574, 0, 0, 0, 74, 74, 0, 0, 0, + 361, 0, 0, 0, 0, 0, 362, 363, 364, 365, + 0, 0, 74, 0, 104, 0, 104, 128, 128, 0, + 0, 0, 0, 74, 0, 232, 0, 0, 75, 0, + 0, 74, 0, 0, 366, 75, 75, 367, 0, 0, + 0, 74, 0, 75, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 122, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 104, 0, 0, 0, 317, 0, + 266, 0, 0, 74, 0, 0, 0, 0, 0, 0, + 0, 0, 74, 0, 0, 789, 0, 0, 75, 0, + 0, 0, 0, 75, 317, 0, 121, 0, 121, 0, + 0, 0, 0, 0, 0, 0, 0, 74, 0, 0, + 0, 0, 75, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 0, 0, 0, 0, 413, + 414, 104, 0, 75, 0, 0, 0, 0, 75, 122, + 0, 75, 416, 355, 0, 356, 357, 358, 359, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 416, 0, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 0, 0, 0, 0, 0, 104, 0, 0, - -273, 0, 0, 0, 316, 104, 613, 0, 0, 0, - 0, 0, 613, 0, 101, 0, 0, 264, 613, 613, - 0, 0, 0, 101, 104, 104, 0, 0, 0, 0, - 0, 101, 0, 0, 102, 0, 0, 0, 104, 0, - 84, 101, 0, 0, 0, 0, 0, 84, 84, 0, - 104, 104, 0, 0, 0, 84, 0, 0, 104, 0, - 0, 354, 0, 355, 356, 357, 358, 0, 0, 0, - 104, 104, 0, 101, 0, 0, 412, 413, 0, 359, - 0, 0, 101, 0, 0, 0, 0, 0, 0, 415, - 0, 0, 0, 0, 128, 0, 315, 0, 315, 128, - 84, 0, 0, 0, 360, 84, 0, 101, 0, 0, - 361, 362, 363, 364, 419, 420, 421, 422, 423, 424, - 425, 426, 613, 0, 84, 102, -608, -608, -608, -608, - 404, 405, 104, 104, -608, -608, 973, 0, 365, 0, - 104, 366, 412, 413, 0, 84, 0, 0, 0, 0, - 84, 0, 0, 608, 0, 415, 0, 0, 0, 0, - 315, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 0, 0, - 0, 0, 0, 608, 608, 0, 0, 0, 104, 0, - 104, 102, 0, 104, 0, 0, 0, 0, 102, 102, - 84, 0, 0, 0, 0, 0, 102, 0, 0, 84, - 0, 0, 0, 0, 0, 0, 0, 84, 101, 0, - -607, 0, 0, 0, 0, 0, 0, 84, 0, 0, - 0, 0, 0, -607, -607, -607, -607, -607, -607, 0, - -607, 0, 0, 0, 0, 0, -607, -607, 0, 0, - 0, 102, 0, 0, 0, 0, 102, -607, -607, 84, - -607, -607, -607, -607, -607, 0, 0, 0, 84, 0, - 0, 0, 0, 0, 0, 102, 0, 0, 0, 0, + 121, 360, 0, 417, 0, 418, 419, 420, 421, 422, + 423, 424, 425, 426, 427, 0, 0, 859, 0, 0, + 0, 75, 75, 0, 0, 0, 361, 0, 0, 0, + 0, 0, 362, 363, 364, 365, 0, 0, 75, 0, + 101, 0, 101, 127, 127, 127, 0, 0, 0, 75, + 0, 231, 0, 0, 0, 0, 0, 75, 0, 0, + 366, 0, 104, 367, 0, 0, 0, 75, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 84, 0, 0, 102, 0, 0, 0, - 0, 102, 0, 0, 102, 0, 0, 0, 0, 0, - -607, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 101, 0, 0, 0, -607, 0, 0, 315, 101, - 0, 0, 0, 0, 0, -607, 0, 0, -607, -607, - 0, 0, 0, 0, 102, 102, 0, 0, 101, 101, - 0, 0, 0, 0, 0, 0, 0, 0, -607, -607, - 0, 102, 101, 0, 273, -607, -607, -607, -607, 0, - 102, 0, 0, 0, 101, 101, 0, 0, 102, 0, - 0, 0, 101, 0, 0, 0, 0, 0, 102, 0, - 0, 0, 0, 0, 101, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 650, 651, 84, 0, 652, 0, 127, 0, - 102, 0, 0, 127, 0, 0, 0, 0, 0, 102, - 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, - 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, - 187, 0, 0, 0, 102, 0, 101, 101, 0, 0, - 972, 188, 189, 190, 101, 0, 0, 0, 0, 0, + 101, 0, 0, 0, 316, 0, 0, 0, 0, 75, + 0, 0, 0, 0, 0, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 0, 201, 202, 0, 0, - 0, 0, 0, 0, 203, 273, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, - 0, 0, 101, 0, 101, 84, 608, 101, 0, 0, - 671, 642, 608, 0, 672, 0, 0, 0, 608, 608, - 0, 0, 0, 0, 84, 84, 0, 0, 0, 174, - 175, 176, 177, 178, 179, 180, 181, 0, 84, 182, - 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, - 84, 84, 0, 0, 0, 102, 0, 0, 84, 188, - 189, 190, 0, 0, 0, 0, 0, 0, 0, 0, - 84, 84, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 0, 201, 202, 400, 401, 402, 403, - 404, 405, 203, 273, 408, 409, 0, 0, 0, 0, - 0, 0, 412, 413, 0, 0, 0, 0, 0, 0, - 0, 0, 608, 0, 0, 415, 0, 0, 0, 0, - 0, 0, 84, 84, 0, 0, 970, 0, 0, 0, - 84, 0, 0, 0, 0, 0, 0, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 102, 0, - 0, 0, 0, 0, 0, 0, 102, 102, 0, 0, - 0, 0, 0, 102, 0, 0, 0, 0, 0, 102, - 102, 0, 0, 0, 0, 102, 102, 0, 400, 401, - 402, 403, 404, 405, 406, 0, 408, 409, 84, 102, - 84, 0, 0, 84, 412, 413, 0, 0, 0, 0, - 0, 102, 102, 0, 0, 0, 0, 415, 0, 102, - 0, 0, 783, 0, 0, 0, 0, 0, 0, 0, - 0, 102, 102, 0, 0, 0, 0, 0, 0, 0, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 0, 0, 0, 0, 412, 413, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 415, - 0, 0, 0, 102, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 102, 102, 0, 0, 0, 0, 0, - 416, 102, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -607, 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, 102, - 27, 102, 0, 0, 102, 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, 49, 50, 0, 0, 0, - 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, - 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, - 0, 61, 62, 63, -288, 64, -607, 0, 0, -607, - -607, 0, 0, 0, 0, 0, 0, -288, -288, -288, - -288, -288, -288, 0, -288, 65, 66, 67, 0, 0, - 0, -288, -288, -288, 0, 0, 0, -607, 0, -607, - 0, -288, -288, 0, -288, -288, -288, -288, -288, 0, + 316, 0, 122, 0, 122, 0, 0, 0, 0, 0, + 0, 0, 0, 75, 0, 0, 0, 0, 0, 104, + 0, 0, 0, 0, 0, 0, 104, 104, 0, 0, + 0, 0, 0, 0, 104, 0, 0, 101, 0, 0, + 0, 0, 0, 0, 0, 317, 0, 0, 0, 0, + 0, 0, 0, 0, 74, 0, 0, 0, 0, 0, + 0, 121, 74, 74, 0, 0, 122, 0, 0, 74, + 0, 0, 0, 0, 0, 74, 74, 0, 0, 104, + 0, 74, 74, 0, 104, 401, 402, 403, 404, 405, + 406, 407, 0, 409, 410, 74, 0, 0, 0, 0, + 0, 413, 414, 104, 0, 0, 0, 74, 74, 0, + 0, 0, 0, 0, 416, 74, 0, 0, 0, 0, + 0, 0, 0, 0, 104, 0, 74, 74, 101, 104, + 317, 0, 616, 0, 75, 0, 0, 418, 419, 420, + 421, 422, 423, 424, 425, 426, 427, 0, 0, 0, + 0, 0, 121, 0, 0, 0, 0, 121, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -288, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -288, -288, -288, -288, - -288, -288, -288, -288, -288, -288, -288, -288, 0, 0, - 0, 0, -288, -288, -288, 0, 0, -288, 0, 0, - 0, 0, 0, -288, 0, -288, 0, 0, 0, -288, - 0, 0, 0, 0, 0, 0, 0, -288, 0, -288, - 0, 0, -288, -288, 0, 0, -288, -288, -288, -288, - -288, -288, -288, -288, -288, -288, -288, -288, 0, 0, - -409, 0, 0, -288, -288, -288, -288, 0, 0, -288, - -288, -288, -288, -409, -409, -409, -409, -409, -409, 0, - -409, 0, 0, 0, 0, 0, -409, -409, -409, 0, - 0, 0, 0, 0, 0, 0, 0, -409, -409, 0, - -409, -409, -409, -409, -409, 0, 0, 0, 0, 0, + 0, 0, 616, 616, 0, 0, 0, 0, 0, 0, + 74, 0, 0, 0, 0, 0, 0, 0, 0, 104, + 74, 74, 0, 0, 121, 0, 0, 0, 74, 0, + 104, 0, 0, 0, 0, 101, 0, 0, 104, 0, + 0, 0, 101, 101, 0, 0, 0, 0, 104, 0, + 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 316, 0, 0, 0, 0, 0, 0, 0, 0, + 75, 0, 0, 0, 0, 0, 0, 122, 75, 75, + 104, 0, 0, 0, 0, 75, 0, 0, 74, 104, + 74, 75, 75, 74, 0, 101, 0, 75, 75, 0, + 101, 0, 0, 317, 0, 317, 0, 0, 0, 0, + 0, 75, 0, 0, 104, 0, 0, 0, 0, 101, + 0, 0, 0, 75, 75, 0, 0, 0, 0, 0, + 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, + 101, 0, 75, 75, 0, 101, 316, 0, 0, 0, + 0, 0, 0, 102, 0, 102, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 317, 122, 0, + 0, 0, 0, 122, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, -610, -610, 75, 0, 0, 0, + 413, 414, 0, 102, 0, 101, 75, 75, 0, 0, + 122, 0, 0, 416, 75, 0, 101, 0, 0, 0, + 0, 0, 0, 861, 101, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 101, 104, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 0, 0, 0, 0, + 0, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 0, 0, 0, 101, 413, 414, 0, + 102, 0, 0, 0, 75, 101, 75, 0, 0, 75, + 416, 0, 0, 0, 0, 0, 0, 0, 0, 316, + 0, 316, 0, 0, 0, 0, 0, 0, 0, 0, + 101, 417, 0, 418, 419, 420, 421, 422, 423, 424, + 425, 426, 427, 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, -409, -409, -409, -409, -409, -409, -409, -409, - -409, -409, -409, -409, 0, 0, 0, 0, -409, -409, - -409, 0, 0, -409, 0, 0, 0, 0, 0, -409, - 0, -409, 0, 0, 0, -409, 0, 0, 0, 0, - 0, 0, 0, 0, 0, -409, 0, 0, -409, -409, - 0, 0, -409, 0, -409, -409, -409, -409, -409, -409, - -409, -409, -409, -409, 0, 0, -475, 0, -409, -409, - -409, -409, -409, 0, 273, -409, -409, -409, -409, -475, - -475, -475, -475, -475, -475, 0, -475, 0, 0, 0, - 0, 0, 0, -475, -475, 0, 0, 0, 0, 0, - 0, 0, 0, -475, -475, 0, -475, -475, -475, -475, - -475, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 490, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -475, -475, - -475, -475, -475, -475, -475, -475, -475, -475, -475, -475, - 0, 0, 0, 0, -475, -475, -475, 0, -475, -475, - 0, 0, 0, 0, 0, -475, 0, -475, 0, 0, - 0, -475, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -475, 0, 0, -475, -475, 0, -475, -475, 0, - -475, -475, -475, -475, -475, -475, -475, -475, -475, -475, - 0, 0, -607, 0, 0, -475, -475, -475, -475, 0, - 0, -475, -475, -475, -475, -607, -607, -607, -607, -607, - -607, 0, -607, 0, 0, 0, 0, 0, -607, -607, - -607, 0, 0, 0, 0, 0, 0, 0, 0, -607, - -607, 0, -607, -607, -607, -607, -607, 0, 0, 0, + 0, 104, 873, 0, 0, 0, 0, 0, 317, 104, + 616, 0, 0, 316, 0, 0, 616, 0, 0, 0, + 0, 102, 616, 616, 0, 0, 0, 0, 104, 104, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 104, 0, 0, 0, 413, 414, 0, 0, + 0, 0, 0, 0, 104, 104, 0, 0, 0, 416, + 0, 0, 104, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 104, 104, 0, 0, 0, 0, 0, + 417, 101, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 0, 0, 0, 0, 0, 0, 102, 128, + 0, 0, 0, 0, 128, 102, 102, 0, 0, 0, + 0, 0, 0, 102, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 0, 616, 0, 0, + 413, 414, 0, 0, 0, 0, 0, 104, 104, 0, + 0, 982, 0, 416, 0, 104, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 102, 0, + 0, 0, 0, 102, 417, 0, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 0, 0, 0, 0, + 0, 0, 102, 0, -276, 0, 0, 101, 0, 0, + 0, 0, 0, 0, 316, 101, 0, 0, 0, 0, + 0, 0, 0, 102, 0, 104, 0, 104, 102, 0, + 104, 102, 0, 0, 101, 101, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 101, -291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 101, 101, -291, -291, -291, -291, -291, -291, 101, -291, + 0, 102, 102, 0, 0, 0, -291, -291, -291, 101, + 101, 0, 0, 0, 0, 0, -291, -291, 102, -291, + -291, -291, -291, -291, 0, 0, 0, 0, 0, 102, + 0, 0, 0, 0, 0, 127, -291, 102, 0, 0, + 127, 0, 0, 0, 0, 0, 0, 102, 0, 0, + 0, -291, -291, -291, -291, -291, -291, -291, -291, -291, + -291, -291, -291, 0, 0, 0, 0, -291, -291, -291, + 0, 0, -291, 101, 101, 0, 0, 981, -291, 102, + -291, 101, 0, 0, -291, 0, 0, 0, 102, 0, + 0, 0, -291, 0, -291, 0, 0, -291, -291, 0, + 0, -291, -291, -291, -291, -291, -291, -291, -291, -291, + -291, -291, -291, 102, 0, 0, 0, 0, -291, -291, + -291, -291, 0, 0, -291, -291, -291, -291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, -607, -607, -607, -607, -607, -607, - -607, -607, -607, -607, -607, -607, 0, 0, 0, 0, - -607, -607, -607, 0, 0, -607, 0, 0, 0, 0, - 0, -607, 0, -607, 0, 0, 0, -607, 0, 0, - 0, 0, 0, 0, 0, 0, 0, -607, 0, 0, - -607, -607, 0, 0, -607, 0, -607, -607, -607, -607, - -607, -607, -607, -607, -607, -607, 0, 0, -607, 0, - -607, -607, -607, -607, -607, 0, 273, -607, -607, -607, - -607, -607, -607, -607, -607, -607, -607, 0, -607, 0, - 0, 0, 0, 0, 0, -607, -607, 0, 0, 0, - 0, 0, 0, 0, 0, -607, -607, 0, -607, -607, - -607, -607, -607, 0, 0, 0, 0, 0, 0, 0, + 0, 101, 0, 101, -609, 4, 101, 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, 49, 50, + 0, 0, 0, 0, 102, 51, 0, 0, 52, 53, + 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, + 58, 59, 60, 0, 61, 62, 63, 0, 64, -609, + 0, 0, -609, -609, 0, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 0, 65, 66, + 67, 413, 414, 0, 0, 0, 0, 0, 0, 0, + -609, 0, -609, 0, 416, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 418, 419, 420, + 421, 422, 423, 424, 425, 426, 427, 0, 0, 0, + 0, 0, 0, 0, 0, -277, 0, 0, 0, 0, + 102, 0, 0, 0, 0, 0, 0, 0, 102, 102, + 0, 0, 0, 0, 0, 102, 0, 0, 0, 0, + 0, 102, 102, 0, 0, 0, 0, 102, 102, 0, + 0, 0, 0, 0, 0, -610, -610, -610, -610, 405, + 406, 102, -412, -610, -610, 0, 0, 0, 0, 0, + 0, 413, 414, 102, 102, -412, -412, -412, -412, -412, + -412, 102, -412, 0, 416, 0, 0, 0, -412, -412, + -412, 0, 102, 102, 0, 0, 0, 0, 0, -412, + -412, 0, -412, -412, -412, -412, -412, 418, 419, 420, + 421, 422, 423, 424, 425, 426, 427, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - -607, -607, -607, -607, -607, -607, -607, -607, -607, -607, - -607, -607, 0, 0, 0, 0, -607, -607, -607, 0, - 0, -607, 0, 0, 0, 0, 0, -607, 0, -607, - 0, 0, 0, -607, 0, 0, 0, 0, 0, 0, - 0, 0, 0, -607, 0, 0, -607, -607, 0, 0, - -607, 0, -607, -607, -607, -607, -607, -607, -607, -607, - -607, -607, 0, 0, -584, 0, 0, -607, -607, -607, - -607, 0, 273, -607, -607, -607, -607, -584, -584, -584, - 0, -584, -584, 0, -584, 0, 0, 0, 0, 0, - -584, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -584, -584, 0, -584, -584, -584, -584, -584, 0, + 0, 0, 0, 0, -412, -412, -412, -412, -412, -412, + -412, -412, -412, -412, -412, -412, 102, 0, 0, 0, + -412, -412, -412, 0, 0, -412, 102, 102, 0, 0, + 0, -412, 0, -412, 102, 0, 0, -412, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -412, 0, 0, + -412, -412, 0, 0, -412, 0, -412, -412, -412, -412, + -412, -412, -412, -412, -412, -412, 0, 0, 0, 0, + -412, -412, -412, -412, -412, -478, 275, -412, -412, -412, + -412, 0, 0, 0, 0, 0, 0, 0, -478, -478, + -478, -478, -478, -478, 102, -478, 102, 0, 0, 102, + 0, 0, -478, -478, 0, 0, 0, 0, 0, 0, + 0, 0, -478, -478, 0, -478, -478, -478, -478, -478, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 493, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -478, -478, -478, + -478, -478, -478, -478, -478, -478, -478, -478, -478, 0, + 0, 0, 0, -478, -478, -478, 0, -478, -478, 0, + 0, 0, 0, 0, -478, 0, -478, 0, 0, 0, + -478, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -478, 0, 0, -478, -478, 0, -478, -478, 0, -478, + -478, -478, -478, -478, -478, -478, -478, -478, -478, 0, + 0, -609, 0, 0, -478, -478, -478, -478, 0, 0, + -478, -478, -478, -478, -609, -609, -609, -609, -609, -609, + 0, -609, 0, 0, 0, 0, 0, -609, -609, -609, + 0, 0, 0, 0, 0, 0, 0, 0, -609, -609, + 0, -609, -609, -609, -609, -609, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -584, -584, -584, -584, - -584, -584, -584, -584, -584, -584, -584, -584, 0, 0, - 0, 0, -584, -584, -584, 0, 788, -584, 0, 0, - 0, 0, 0, 0, 0, -584, 0, 0, 0, -584, - 0, 0, 0, 0, 0, 0, 0, 0, 0, -584, - 0, 0, -584, -584, 0, -103, -584, 0, -584, -584, - -584, -584, -584, -584, -584, -584, -584, -584, 0, 0, - -584, 0, -584, -584, -584, 0, -95, 0, 0, -584, - -584, -584, -584, -584, -584, -584, 0, -584, -584, 0, - -584, 0, 0, 0, 0, 0, -584, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, -584, -584, 0, - -584, -584, -584, -584, -584, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, -609, -609, -609, -609, -609, -609, -609, + -609, -609, -609, -609, -609, 0, 0, 0, 0, -609, + -609, -609, 0, 0, -609, 0, 0, 0, 0, 0, + -609, 0, -609, 0, 0, 0, -609, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -609, 0, 0, -609, + -609, 0, 0, -609, 0, -609, -609, -609, -609, -609, + -609, -609, -609, -609, -609, 0, 0, -609, 0, -609, + -609, -609, -609, -609, 0, 275, -609, -609, -609, -609, + -609, -609, -609, -609, -609, -609, 0, -609, 0, 0, + 0, 0, 0, 0, -609, -609, 0, 0, 0, 0, + 0, 0, 0, 0, -609, -609, 0, -609, -609, -609, + -609, -609, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, -584, -584, -584, -584, -584, -584, -584, -584, - -584, -584, -584, -584, 0, 0, 0, 0, -584, -584, - -584, 0, 788, -584, 0, 0, 0, 0, 0, 0, - 0, -584, 0, 0, 0, -584, 0, 0, 0, 0, - 0, 0, 0, 0, 0, -584, 0, 0, -584, -584, - 0, -103, -584, 0, -584, -584, -584, -584, -584, -584, - -584, -584, -584, -584, 0, 0, -297, 0, -584, -584, - -584, 0, -584, 0, 0, -584, -584, -584, -584, -297, - -297, -297, 0, -297, -297, 0, -297, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -609, + -609, -609, -609, -609, -609, -609, -609, -609, -609, -609, + -609, 0, 0, 0, 0, -609, -609, -609, 0, 0, + -609, 0, 0, 0, 0, 0, -609, 0, -609, 0, + 0, 0, -609, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -609, 0, 0, -609, -609, 0, 0, -609, + 0, -609, -609, -609, -609, -609, -609, -609, -609, -609, + -609, 0, 0, -586, 0, 0, -609, -609, -609, -609, + 0, 275, -609, -609, -609, -609, -586, -586, -586, 0, + -586, -586, 0, -586, 0, 0, 0, 0, 0, -586, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, -297, -297, 0, -297, -297, -297, -297, - -297, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -586, -586, 0, -586, -586, -586, -586, -586, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -297, -297, - -297, -297, -297, -297, -297, -297, -297, -297, -297, -297, - 0, 0, 0, 0, -297, -297, -297, 0, 789, -297, - 0, 0, 0, 0, 0, 0, 0, -297, 0, 0, - 0, -297, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -297, 0, 0, -297, -297, 0, -105, -297, 0, - -297, -297, -297, -297, -297, -297, -297, -297, -297, -297, - 0, 0, -297, 0, 0, -297, -297, 0, -97, 0, - 0, -297, -297, -297, -297, -297, -297, -297, 0, -297, - -297, 0, -297, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, -297, - -297, 0, -297, -297, -297, -297, -297, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -586, -586, -586, -586, -586, + -586, -586, -586, -586, -586, -586, -586, 0, 0, 0, + 0, -586, -586, -586, 0, 794, -586, 0, 0, 0, + 0, 0, 0, 0, -586, 0, 0, 0, -586, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -586, 0, + 0, -586, -586, 0, -107, -586, 0, -586, -586, -586, + -586, -586, -586, -586, -586, -586, -586, 0, 0, -586, + 0, -586, -586, -586, 0, -99, 0, 0, -586, -586, + -586, -586, -586, -586, -586, 0, -586, -586, 0, -586, + 0, 0, 0, 0, 0, -586, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -586, -586, 0, -586, + -586, -586, -586, -586, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, -297, -297, -297, -297, -297, -297, - -297, -297, -297, -297, -297, -297, 0, 0, 0, 0, - -297, -297, -297, 0, 789, -297, 0, 0, 0, 0, - 0, 0, 0, -297, 0, 0, 0, -297, 0, 0, - 0, 0, 0, 0, 0, 0, 0, -297, 0, 0, - -297, -297, 0, -105, -297, 0, -297, -297, -297, -297, - -297, -297, -297, -297, -297, -297, 0, 0, 0, 0, - 0, -297, -297, 0, -297, 0, 0, -297, -297, -297, - -297, 293, 0, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, -607, -607, -607, 0, 0, -607, 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, 49, 50, 0, 0, 0, 0, - 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, - 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, - 61, 62, 63, 0, 64, -607, 0, 0, -607, -607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 65, 66, 67, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -607, 293, -607, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, - 0, -607, 0, -607, -607, 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, -586, -586, -586, -586, -586, -586, -586, -586, -586, + -586, -586, -586, 0, 0, 0, 0, -586, -586, -586, + 0, 794, -586, 0, 0, 0, 0, 0, 0, 0, + -586, 0, 0, 0, -586, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -586, 0, 0, -586, -586, 0, + -107, -586, 0, -586, -586, -586, -586, -586, -586, -586, + -586, -586, -586, 0, 0, -300, 0, -586, -586, -586, + 0, -586, 0, 0, -586, -586, -586, -586, -300, -300, + -300, 0, -300, -300, 0, -300, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, - 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, - 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, - 64, -607, 0, 0, -607, -607, 0, 0, 0, 0, + 0, 0, -300, -300, 0, -300, -300, -300, -300, -300, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 65, 66, 67, 0, 0, 0, 0, 0, 0, 0, - 0, 0, -607, 293, -607, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 0, 0, -607, 0, 0, - -607, 15, -607, 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, 49, 50, 0, 0, - 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, - 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, - 60, 0, 61, 62, 63, 0, 64, -607, 0, 0, - -607, -607, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 65, 66, 67, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -607, 293, - -607, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 0, 0, -607, 0, 0, -607, 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, 49, 50, 0, 0, 0, 0, 0, 51, - 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, - 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, - 63, 0, 64, -607, 0, 0, -607, -607, 4, 0, + 0, 0, 0, 0, 0, 0, 0, -300, -300, -300, + -300, -300, -300, -300, -300, -300, -300, -300, -300, 0, + 0, 0, 0, -300, -300, -300, 0, 795, -300, 0, + 0, 0, 0, 0, 0, 0, -300, 0, 0, 0, + -300, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -300, 0, 0, -300, -300, 0, -109, -300, 0, -300, + -300, -300, -300, -300, -300, -300, -300, -300, -300, 0, + 0, -300, 0, 0, -300, -300, 0, -101, 0, 0, + -300, -300, -300, -300, -300, -300, -300, 0, -300, -300, + 0, -300, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -300, -300, + 0, -300, -300, -300, -300, -300, 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, -300, -300, -300, -300, -300, -300, -300, + -300, -300, -300, -300, -300, 0, 0, 0, 0, -300, + -300, -300, 0, 795, -300, 0, 0, 0, 0, 0, + 0, 0, -300, 0, 0, 0, -300, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -300, 0, 0, -300, + -300, 0, -109, -300, 0, -300, -300, -300, -300, -300, + -300, -300, -300, -300, -300, 0, 0, 0, 0, 0, + -300, -300, 0, -300, 0, 0, -300, -300, -300, -300, + 294, 0, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, -609, -609, -609, 0, 0, -609, 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, 49, 50, 0, 0, 0, 0, 0, + 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, + 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, + 62, 63, 0, 64, -609, 0, 0, -609, -609, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 65, 66, 67, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -609, 294, -609, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, + -609, 0, -609, -609, 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, 49, + 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, + 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, + 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, + -609, 0, 0, -609, -609, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, + 66, 67, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -609, 294, -609, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 0, 0, -609, 0, 0, -609, + 15, -609, 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, 49, 50, 0, 0, 0, + 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, + 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, + 0, 61, 62, 63, 0, 64, -609, 0, 0, -609, + -609, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 65, 66, 67, 0, 0, + 0, 0, 0, 0, 0, 0, 0, -609, 294, -609, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 0, 0, 65, 66, 67, 0, 15, 0, 16, 17, - 18, 19, 0, 0, -607, 0, -607, 20, 21, 22, + 0, 0, -609, 0, 0, -609, 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, + 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, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, - 0, 64, -607, 0, 0, -607, -607, 0, 0, 0, + 0, 64, -609, 0, 0, -609, -609, 4, 0, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, + 0, 65, 66, 67, 0, 15, 0, 16, 17, 18, + 19, 0, 0, -609, 0, -609, 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, 65, 66, 67, 0, 0, -607, 0, 0, 0, - 0, 0, 0, -607, 293, -607, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 0, -607, -607, 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, 49, 50, 0, - 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, - 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, - 59, 60, 0, 61, 62, 63, 0, 64, -607, 0, - 0, -607, -607, 293, 0, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, - 0, 15, 0, 16, 17, 18, 19, 0, 0, -607, - 0, -607, 20, 21, 22, 23, 24, 25, 26, 0, + 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, + 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, + 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, + 64, -609, 0, 0, -609, -609, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 65, 66, 67, 0, 0, -609, 0, 0, 0, 0, + 0, 0, -609, 294, -609, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 0, -609, -609, 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, 49, 50, 0, 0, - 0, 0, 0, 51, 0, 0, 294, 53, 0, 54, + 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, - 60, 0, 61, 62, 63, 0, 64, -607, 0, 0, - -607, -607, 293, 0, 5, 6, 7, 8, 9, 10, + 60, 0, 61, 62, 63, 0, 64, -609, 0, 0, + -609, -609, 294, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, 0, - 15, 0, 16, 17, 18, 19, 0, -607, -607, 0, - -607, 20, 21, 22, 23, 24, 25, 26, 0, 0, + 15, 0, 16, 17, 18, 19, 0, 0, -609, 0, + -609, 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, 49, 50, 0, 0, 0, - 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, + 0, 0, 51, 0, 0, 295, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, - 0, 61, 62, 63, 0, 64, -607, 0, 0, -607, - -607, 293, 0, 5, 6, 7, 8, 9, 10, 11, + 0, 61, 62, 63, 0, 64, -609, 0, 0, -609, + -609, 294, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, 0, 15, - 0, 16, 17, 18, 19, 0, -607, -607, 0, -607, + 0, 16, 17, 18, 19, 0, -609, -609, 0, -609, 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, @@ -3009,258 +3051,270 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, - 61, 62, 63, 0, 64, -607, 0, 0, -607, -607, + 61, 62, 63, 0, 64, -609, 0, 0, -609, -609, + 294, 0, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 0, 0, 65, 66, 67, 0, 15, 0, + 16, 17, 18, 19, 0, -609, -609, 0, -609, 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, 49, 50, 0, 0, 0, 0, 0, + 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, + 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, + 62, 63, 0, 64, -609, 0, 0, -609, -609, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 65, 66, 67, 0, 0, -607, - 0, 0, 0, 0, 0, 0, -607, 293, -607, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, - 0, -607, 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, - 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, - 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, - 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, - 64, -607, 0, 0, -607, -607, 0, 0, 5, 6, + 0, 0, 0, 65, 66, 67, 0, 0, -609, 0, + 0, 0, 0, 0, 0, -609, 294, -609, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, - 65, 66, 67, 0, 15, 0, 16, 17, 18, 19, - 0, 0, -607, 0, -607, 20, 21, 22, 23, 24, + -609, 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, + 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, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, - 245, 0, 0, 246, 247, 0, 0, 5, 6, 7, + -609, 0, 0, -609, -609, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, 0, 15, 0, 16, 17, 18, 19, 0, - 0, 248, 0, 249, 20, 21, 22, 23, 24, 25, + 0, -609, 0, -609, 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, + 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, 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, - 58, 59, 60, 0, 61, 62, 63, 0, 64, 245, - 0, 0, 246, 247, 0, 0, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 0, 0, 0, 65, 66, + 58, 59, 60, 0, 61, 62, 63, 0, 64, 247, + 0, 0, 248, 249, 0, 0, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 0, 0, 65, 66, 67, 0, 15, 0, 16, 17, 18, 19, 0, 0, - 248, 0, 249, 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, + 250, 0, 251, 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, 49, 50, 0, - 0, 0, 0, 0, 211, 0, 0, 119, 53, 0, - 54, 55, 0, 0, 0, 0, 0, 57, 0, 58, - 59, 60, 0, 61, 62, 63, 0, 64, 245, 0, - 0, 246, 247, 0, 0, 5, 6, 7, 8, 9, + 0, 0, 0, 0, 51, 0, 0, 52, 53, 0, + 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, + 59, 60, 0, 61, 62, 63, 0, 64, 247, 0, + 0, 248, 249, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 65, 66, 67, - 0, 15, 0, 108, 109, 18, 19, 0, 0, 248, - 0, 249, 110, 111, 112, 23, 24, 25, 26, 0, - 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 16, 17, 18, 19, 0, 0, 250, + 0, 251, 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, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, 0, 54, 55, 0, 0, 0, 0, 0, 57, 0, 58, 59, - 60, 0, 61, 62, 63, 0, 64, 245, 0, 0, - 246, 247, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 65, 262, 67, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 248, 0, - 249, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 0, 0, 0, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 0, 0, - 0, 0, 0, 165, 166, 167, 168, 169, 170, 171, - 172, 36, 37, 173, 39, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, - 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, - 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 188, 189, - 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 60, 0, 61, 62, 63, 0, 64, 247, 0, 0, + 248, 249, 0, 0, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 0, 0, 0, 65, 66, 67, 0, + 15, 0, 108, 109, 18, 19, 0, 0, 250, 0, + 251, 110, 111, 112, 23, 24, 25, 26, 0, 0, + 113, 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, 49, 50, 0, 0, 0, + 0, 0, 211, 0, 0, 119, 53, 0, 54, 55, + 0, 0, 0, 0, 0, 57, 0, 58, 59, 60, + 0, 61, 62, 63, 0, 64, 247, 0, 0, 248, + 249, 0, 0, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 0, 0, 0, 65, 264, 67, 0, 15, + 0, 16, 17, 18, 19, 0, 0, 250, 0, 251, + 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, 49, 50, 0, 0, 0, 0, + 0, 211, 0, 0, 119, 53, 0, 54, 55, 0, + 0, 0, 0, 0, 57, 0, 58, 59, 60, 0, + 61, 62, 63, 0, 64, 247, 0, 0, 248, 249, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 0, 201, 202, 0, 0, 0, 0, 0, - 0, 203, 204, -577, -577, -577, -577, -577, -577, -577, - -577, -577, 0, 0, 0, 0, 0, 0, 0, -577, - 0, -577, -577, -577, -577, 0, -577, 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, -577, -577, 0, 0, 0, 0, - 0, -577, 0, 0, -577, -577, 0, -577, -577, 0, - -577, 0, -577, -577, -577, 0, -577, -577, -577, 0, - -577, -577, -577, 0, -577, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 65, 66, 67, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 251, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 0, 0, 0, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 0, 0, 0, 0, + 0, 165, 166, 167, 168, 169, 170, 171, 172, 36, + 37, 173, 39, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, + 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, + 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 188, 189, 190, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 0, 201, 202, 0, 0, 0, 0, 0, 0, 203, + 204, -579, -579, -579, -579, -579, -579, -579, -579, -579, + 0, 0, 0, 0, 0, 0, 0, -579, 0, -579, + -579, -579, -579, 0, -579, 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, -577, -577, -577, 0, -577, 0, - 0, 0, 0, 0, -577, -578, -578, -578, -578, -578, - -578, -578, -578, -578, 0, 0, 0, 0, 0, 0, - 0, -578, 0, -578, -578, -578, -578, 0, -578, 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, -578, -578, 0, 0, - 0, 0, 0, -578, 0, 0, -578, -578, 0, -578, - -578, 0, -578, 0, -578, -578, -578, 0, -578, -578, - -578, 0, -578, -578, -578, 0, -578, 0, 0, 0, - 0, 0, 0, -580, -580, -580, -580, -580, -580, -580, - -580, -580, 0, 0, 0, 0, -578, -578, -578, -580, - -578, -580, -580, -580, -580, 0, -578, 0, 0, 0, + 0, 0, -579, -579, 0, 0, 0, 0, 0, -579, + 0, 0, -579, -579, 0, -579, -579, 0, -579, 0, + -579, -579, -579, 0, -579, -579, -579, 0, -579, -579, + -579, 0, -579, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, -579, -579, -579, 0, -579, 0, 0, 0, + 0, 0, -579, -580, -580, -580, -580, -580, -580, -580, + -580, -580, 0, 0, 0, 0, 0, 0, 0, -580, + 0, -580, -580, -580, -580, 0, -580, 0, 0, 0, -580, -580, -580, -580, -580, -580, -580, 0, 0, -580, 0, 0, 0, 0, 0, 0, 0, 0, -580, -580, -580, -580, -580, -580, -580, -580, -580, 0, -580, -580, -580, 0, 0, -580, 0, 0, -580, -580, 0, -580, -580, -580, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -580, -580, 0, 0, 0, 0, - 0, -580, 820, 0, -580, -580, 0, -580, -580, 0, + 0, -580, 0, 0, -580, -580, 0, -580, -580, 0, -580, 0, -580, -580, -580, 0, -580, -580, -580, 0, -580, -580, -580, 0, -580, 0, 0, 0, 0, 0, - 0, -103, -581, -581, -581, -581, -581, -581, -581, -581, - -581, 0, 0, 0, -580, -580, -580, 0, -581, 0, - -581, -581, -581, -581, -580, 0, 0, 0, 0, -581, - -581, -581, -581, -581, -581, -581, 0, 0, -581, 0, - 0, 0, 0, 0, 0, 0, 0, -581, -581, -581, - -581, -581, -581, -581, -581, -581, 0, -581, -581, -581, - 0, 0, -581, 0, 0, -581, -581, 0, -581, -581, - -581, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, -581, -581, 0, 0, 0, 0, 0, - -581, 821, 0, -581, -581, 0, -581, -581, 0, -581, - 0, -581, -581, -581, 0, -581, -581, -581, 0, -581, - -581, -581, 0, -581, 0, 0, 0, 0, 0, 0, - -105, -582, -582, -582, -582, -582, -582, -582, -582, -582, - 0, 0, 0, -581, -581, -581, 0, -582, 0, -582, - -582, -582, -582, -581, 0, 0, 0, 0, -582, -582, + 0, -582, -582, -582, -582, -582, -582, -582, -582, -582, + 0, 0, 0, 0, -580, -580, -580, -582, -580, -582, + -582, -582, -582, 0, -580, 0, 0, 0, -582, -582, -582, -582, -582, -582, -582, 0, 0, -582, 0, 0, 0, 0, 0, 0, 0, 0, -582, -582, -582, -582, -582, -582, -582, -582, -582, 0, -582, -582, -582, 0, 0, -582, 0, 0, -582, -582, 0, -582, -582, -582, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -582, -582, 0, 0, 0, 0, 0, -582, - 0, 0, -582, -582, 0, -582, -582, 0, -582, 0, + 826, 0, -582, -582, 0, -582, -582, 0, -582, 0, -582, -582, -582, 0, -582, -582, -582, 0, -582, -582, - -582, 0, -582, 0, 0, 0, 0, 0, 0, -583, - -583, -583, -583, -583, -583, -583, -583, -583, 0, 0, - 0, 0, -582, -582, -582, -583, 0, -583, -583, -583, - -583, 0, -582, 0, 0, 0, -583, -583, -583, -583, - -583, -583, -583, 0, 0, -583, 0, 0, 0, 0, - 0, 0, 0, 0, -583, -583, -583, -583, -583, -583, - -583, -583, -583, 0, -583, -583, -583, 0, 0, -583, - 0, 0, -583, -583, 0, -583, -583, -583, 0, 0, + -582, 0, -582, 0, 0, 0, 0, 0, 0, -107, + -583, -583, -583, -583, -583, -583, -583, -583, -583, 0, + 0, 0, -582, -582, -582, 0, -583, 0, -583, -583, + -583, -583, -582, 0, 0, 0, 0, -583, -583, -583, + -583, -583, -583, -583, 0, 0, -583, 0, 0, 0, + 0, 0, 0, 0, 0, -583, -583, -583, -583, -583, + -583, -583, -583, -583, 0, -583, -583, -583, 0, 0, + -583, 0, 0, -583, -583, 0, -583, -583, -583, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -583, -583, 0, 0, 0, 0, 0, -583, 827, + 0, -583, -583, 0, -583, -583, 0, -583, 0, -583, + -583, -583, 0, -583, -583, -583, 0, -583, -583, -583, + 0, -583, 0, 0, 0, 0, 0, 0, -109, -584, + -584, -584, -584, -584, -584, -584, -584, -584, 0, 0, + 0, -583, -583, -583, 0, -584, 0, -584, -584, -584, + -584, -583, 0, 0, 0, 0, -584, -584, -584, -584, + -584, -584, -584, 0, 0, -584, 0, 0, 0, 0, + 0, 0, 0, 0, -584, -584, -584, -584, -584, -584, + -584, -584, -584, 0, -584, -584, -584, 0, 0, -584, + 0, 0, -584, -584, 0, -584, -584, -584, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - -583, -583, 0, 0, 0, 0, 0, -583, 0, 0, - -583, -583, 0, -583, -583, 0, -583, 0, -583, -583, - -583, 0, -583, -583, -583, 0, -583, -583, -583, 0, - -583, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -584, -584, 0, 0, 0, 0, 0, -584, 0, 0, + -584, -584, 0, -584, -584, 0, -584, 0, -584, -584, + -584, 0, -584, -584, -584, 0, -584, -584, -584, 0, + -584, 0, 0, 0, 0, 0, 0, -585, -585, -585, + -585, -585, -585, -585, -585, -585, 0, 0, 0, 0, + -584, -584, -584, -585, 0, -585, -585, -585, -585, 0, + -584, 0, 0, 0, -585, -585, -585, -585, -585, -585, + -585, 0, 0, -585, 0, 0, 0, 0, 0, 0, + 0, 0, -585, -585, -585, -585, -585, -585, -585, -585, + -585, 0, -585, -585, -585, 0, 0, -585, 0, 0, + -585, -585, 0, -585, -585, -585, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -585, -585, + 0, 0, 0, 0, 0, -585, 0, 0, -585, -585, + 0, -585, -585, 0, -585, 0, -585, -585, -585, 0, + -585, -585, -585, 0, -585, -585, -585, 0, -585, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - -583, -583, -583, 0, 0, 0, 0, 0, 0, 0, - -583, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 0, 0, 0, 0, 0, 0, 0, 0, -585, -585, + -585, 0, 0, 0, 0, 0, 0, 0, -585, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 0, 0, 0, 155, 156, 157, 233, + 234, 235, 236, 162, 163, 164, 0, 0, 0, 0, + 0, 165, 166, 167, 237, 238, 239, 240, 172, 319, + 320, 241, 321, 0, 0, 0, 0, 0, 0, 322, + 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, + 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, + 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 188, 189, 190, 0, + 0, 0, 0, 323, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 0, 201, 202, 0, 0, 0, 0, 0, 0, 203, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 0, 0, 0, 155, 156, 157, + 233, 234, 235, 236, 162, 163, 164, 0, 0, 0, + 0, 0, 165, 166, 167, 237, 238, 239, 240, 172, + 319, 320, 241, 321, 0, 0, 0, 0, 0, 0, + 322, 0, 0, 0, 0, 0, 0, 174, 175, 176, + 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, + 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 188, 189, 190, + 0, 0, 0, 0, 484, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 0, 201, 202, 0, 0, 0, 0, 0, 0, + 203, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 0, 0, 0, 155, 156, - 157, 231, 232, 233, 234, 162, 163, 164, 0, 0, - 0, 0, 0, 165, 166, 167, 235, 236, 237, 238, - 172, 318, 319, 239, 320, 0, 0, 0, 0, 0, - 0, 321, 0, 0, 0, 0, 0, 0, 174, 175, + 157, 233, 234, 235, 236, 162, 163, 164, 0, 0, + 0, 0, 0, 165, 166, 167, 237, 238, 239, 240, + 172, 0, 0, 241, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 188, 189, - 190, 0, 0, 0, 0, 322, 0, 0, 0, 0, + 190, 0, 0, 0, 242, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 0, 201, 202, 0, 0, 0, 0, 0, 0, 203, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 0, 0, 0, 155, - 156, 157, 231, 232, 233, 234, 162, 163, 164, 0, - 0, 0, 0, 0, 165, 166, 167, 235, 236, 237, - 238, 172, 318, 319, 239, 320, 0, 0, 0, 0, - 0, 0, 321, 0, 0, 0, 0, 0, 0, 174, + 156, 157, 233, 234, 235, 236, 162, 163, 164, 0, + 0, 0, 0, 0, 165, 166, 167, 237, 238, 239, + 240, 172, 0, 0, 241, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 188, - 189, 190, 0, 0, 0, 0, 481, 0, 0, 0, + 189, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 0, 201, 202, 0, 0, 0, 0, - 0, 0, 203, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 0, 0, 0, - 155, 156, 157, 231, 232, 233, 234, 162, 163, 164, - 0, 0, 0, 0, 0, 165, 166, 167, 235, 236, - 237, 238, 172, 0, 0, 239, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, - 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 188, 189, 190, 0, 0, 0, 240, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 0, 201, 202, 0, 0, 0, - 0, 0, 0, 203, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 0, 0, - 0, 155, 156, 157, 231, 232, 233, 234, 162, 163, - 164, 0, 0, 0, 0, 0, 165, 166, 167, 235, - 236, 237, 238, 172, 0, 0, 239, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, - 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, - 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 188, 189, 190, 0, 0, 0, 0, 0, 0, + 0, 0, 203, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, + 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, + 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, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 0, 201, 202, 0, 0, - 0, 0, 0, 0, 203, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, - 0, 15, 0, 108, 109, 18, 19, 0, 0, 0, - 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, - 0, 113, 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, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 311, 0, 0, 119, 53, 0, 54, - 55, 0, 0, 0, 0, 0, 57, 0, 58, 59, - 60, 0, 61, 62, 63, 0, 64, 0, 0, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, - 0, 0, 0, 0, 0, 15, 120, 108, 109, 18, - 19, 0, 0, 0, 312, 0, 110, 111, 112, 23, - 24, 25, 26, 0, 0, 113, 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, 116, 0, 0, 0, 0, + 0, 312, 0, 0, 119, 53, 0, 54, 55, 0, + 0, 0, 0, 0, 57, 0, 58, 59, 60, 0, + 61, 62, 63, 0, 64, 0, 0, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, + 0, 0, 0, 15, 120, 108, 109, 18, 19, 0, + 0, 0, 313, 0, 110, 111, 112, 23, 24, 25, + 26, 0, 0, 113, 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, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 311, 0, 0, - 119, 53, 0, 54, 55, 0, 0, 0, 0, 0, - 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, - 64, 0, 0, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 0, 0, 0, 0, 0, 0, 15, - 120, 16, 17, 18, 19, 0, 0, 0, 602, 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, 49, 50, 0, 0, 0, 0, - 0, 51, 0, 0, 52, 53, 0, 54, 55, 0, - 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, - 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 312, 0, 0, 119, 53, + 0, 54, 55, 0, 0, 0, 0, 0, 57, 0, + 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 0, 0, 0, 65, 66, 67, 15, 0, 16, - 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, + 14, 0, 0, 0, 0, 0, 0, 15, 120, 16, + 17, 18, 19, 0, 0, 0, 605, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, 0, 0, - 0, 0, 0, 28, 0, 30, 31, 32, 33, 34, + 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, @@ -3268,126 +3322,126 @@ static const yytype_int16 yytable[] = 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 0, 65, 66, 67, 15, 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, - 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, - 0, 0, 0, 0, 31, 32, 33, 258, 35, 36, + 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, - 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, - 119, 53, 0, 54, 55, 0, 259, 0, 260, 261, + 49, 50, 0, 0, 0, 0, 0, 51, 0, 0, + 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, - 65, 262, 67, 15, 0, 16, 17, 18, 19, 0, + 65, 66, 67, 15, 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, - 0, 0, 31, 32, 33, 258, 35, 36, 37, 38, + 0, 0, 31, 32, 33, 260, 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, 49, 503, + 0, 0, 0, 0, 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, - 0, 54, 55, 0, 259, 0, 260, 261, 57, 0, + 0, 54, 55, 0, 261, 0, 262, 263, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 0, 0, 0, 0, 65, 262, - 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, - 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, + 10, 11, 12, 13, 0, 0, 0, 0, 65, 264, + 67, 15, 0, 16, 17, 18, 19, 0, 0, 0, + 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, - 31, 32, 33, 258, 35, 36, 37, 38, 39, 0, + 31, 32, 33, 260, 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, 49, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 49, 505, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, 0, 54, - 55, 0, 712, 0, 260, 261, 57, 0, 58, 59, + 55, 0, 261, 0, 262, 263, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 0, 0, 0, 0, 65, 262, 67, 15, + 12, 13, 0, 0, 0, 0, 65, 264, 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 31, 32, - 33, 258, 35, 36, 37, 38, 39, 0, 40, 41, + 33, 260, 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, 49, 838, 0, 0, 0, 0, + 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, 0, 54, 55, 0, - 712, 0, 260, 261, 57, 0, 58, 59, 60, 0, + 716, 0, 262, 263, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 0, 0, 0, 0, 65, 262, 67, 15, 0, 108, + 0, 0, 0, 0, 65, 264, 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, - 0, 0, 0, 0, 0, 0, 31, 32, 33, 258, + 0, 0, 0, 0, 0, 0, 31, 32, 33, 260, 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, 49, 50, 0, 0, 0, 0, 0, 211, - 0, 0, 119, 53, 0, 54, 55, 0, 259, 0, - 260, 0, 57, 0, 58, 59, 60, 0, 61, 62, + 0, 0, 49, 843, 0, 0, 0, 0, 0, 211, + 0, 0, 119, 53, 0, 54, 55, 0, 716, 0, + 262, 263, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, - 0, 0, 65, 262, 67, 15, 0, 108, 109, 18, + 0, 0, 65, 264, 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, - 0, 0, 0, 0, 31, 32, 33, 258, 35, 36, + 0, 0, 0, 0, 31, 32, 33, 260, 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, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, - 119, 53, 0, 54, 55, 0, 0, 0, 260, 261, + 119, 53, 0, 54, 55, 0, 261, 0, 262, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, - 65, 262, 67, 15, 0, 108, 109, 18, 19, 0, + 65, 264, 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, - 0, 0, 31, 32, 33, 258, 35, 36, 37, 38, + 0, 0, 31, 32, 33, 260, 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, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, - 0, 54, 55, 0, 712, 0, 260, 0, 57, 0, + 0, 54, 55, 0, 0, 0, 262, 263, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 0, 0, 0, 0, 65, 262, + 10, 11, 12, 13, 0, 0, 0, 0, 65, 264, 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, - 31, 32, 33, 258, 35, 36, 37, 38, 39, 0, + 31, 32, 33, 260, 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, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, 0, 54, - 55, 0, 0, 0, 260, 0, 57, 0, 58, 59, + 55, 0, 716, 0, 262, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 0, 0, 0, 0, 65, 262, 67, 15, - 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, - 20, 21, 22, 23, 24, 25, 26, 0, 0, 113, + 12, 13, 0, 0, 0, 0, 65, 264, 67, 15, + 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, + 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 0, 40, 41, + 33, 260, 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, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, 0, 54, 55, 0, - 596, 0, 0, 0, 57, 0, 58, 59, 60, 0, + 0, 0, 262, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 0, 0, 0, 0, 65, 262, 67, 15, 0, 108, - 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, - 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, + 0, 0, 0, 0, 65, 264, 67, 15, 0, 16, + 17, 18, 19, 0, 0, 0, 0, 0, 20, 21, + 22, 23, 24, 25, 26, 0, 0, 113, 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, 49, 50, 0, 0, 0, 0, 0, 211, - 0, 0, 119, 53, 0, 54, 55, 0, 259, 0, + 0, 0, 119, 53, 0, 54, 55, 0, 599, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, - 0, 0, 65, 262, 67, 15, 0, 108, 109, 18, + 0, 0, 65, 264, 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 31, 32, 33, 34, 35, 36, @@ -3395,11 +3449,11 @@ static const yytype_int16 yytable[] = 0, 0, 44, 45, 0, 46, 47, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, - 119, 53, 0, 54, 55, 0, 596, 0, 0, 0, + 119, 53, 0, 54, 55, 0, 261, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, - 65, 262, 67, 15, 0, 108, 109, 18, 19, 0, + 65, 264, 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 31, 32, 33, 34, 35, 36, 37, 38, @@ -3407,10 +3461,10 @@ static const yytype_int16 yytable[] = 44, 45, 0, 46, 47, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, - 0, 54, 55, 0, 881, 0, 0, 0, 57, 0, + 0, 54, 55, 0, 599, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 0, 0, 0, 0, 65, 262, + 10, 11, 12, 13, 0, 0, 0, 0, 65, 264, 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, @@ -3419,24 +3473,24 @@ static const yytype_int16 yytable[] = 0, 46, 47, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, 0, 54, - 55, 0, 712, 0, 0, 0, 57, 0, 58, 59, + 55, 0, 888, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 0, 0, 0, 0, 65, 262, 67, 15, - 0, 16, 17, 18, 19, 0, 0, 0, 0, 0, - 20, 21, 22, 23, 24, 25, 26, 0, 0, 27, + 12, 13, 0, 0, 0, 0, 65, 264, 67, 15, + 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, + 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 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, 49, 50, 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, 0, 54, 55, 0, - 0, 0, 0, 0, 57, 0, 58, 59, 60, 0, + 716, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 0, 0, 0, 0, 65, 66, 67, 15, 0, 108, - 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, - 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, + 0, 0, 0, 0, 65, 264, 67, 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, @@ -3446,8 +3500,8 @@ static const yytype_int16 yytable[] = 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, - 0, 0, 65, 262, 67, 15, 0, 16, 17, 18, - 19, 0, 0, 0, 0, 0, 20, 21, 22, 23, + 0, 0, 65, 66, 67, 15, 0, 108, 109, 18, + 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0, 40, 41, 42, 0, 0, 43, @@ -3458,49 +3512,38 @@ static const yytype_int16 yytable[] = 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, - 65, 262, 67, 15, 0, 108, 109, 18, 19, 0, - 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, + 65, 264, 67, 15, 0, 16, 17, 18, 19, 0, + 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, - 0, 0, 31, 32, 33, 114, 35, 36, 37, 115, + 0, 0, 31, 32, 33, 34, 35, 36, 37, 38, 39, 0, 40, 41, 42, 0, 0, 43, 0, 0, - 44, 45, 0, 116, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 117, 0, 0, 118, 0, 0, 119, 53, + 44, 45, 0, 46, 47, 48, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 49, 50, + 0, 0, 0, 0, 0, 211, 0, 0, 119, 53, 0, 54, 55, 0, 0, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, - 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 0, 0, 0, 0, 0, 0, 0, 15, 120, 108, - 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, - 112, 23, 24, 25, 26, 0, 0, 113, 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, 223, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, - 0, 0, 52, 53, 0, 54, 55, 0, 56, 0, - 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, - 63, 0, 64, 0, 0, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, - 0, 15, 120, 108, 109, 18, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 0, 0, 0, 0, 65, 264, + 67, 15, 0, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 0, + 31, 32, 33, 114, 35, 36, 37, 115, 39, 0, 40, 41, 42, 0, 0, 43, 0, 0, 44, 45, 0, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 311, 0, 0, 396, 53, 0, 54, - 55, 0, 397, 0, 0, 0, 57, 0, 58, 59, + 117, 0, 0, 118, 0, 0, 119, 53, 0, 54, + 55, 0, 0, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 15, 120, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, - 0, 0, 0, 0, 31, 32, 33, 114, 35, 36, - 37, 115, 39, 0, 40, 41, 42, 0, 0, 43, - 0, 0, 44, 45, 0, 116, 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, 225, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 0, 0, - 119, 53, 0, 54, 55, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 226, 0, 0, + 52, 53, 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 15, @@ -3511,18 +3554,18 @@ static const yytype_int16 yytable[] = 42, 0, 0, 43, 0, 0, 44, 45, 0, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 311, 0, 0, 396, 53, 0, 54, 55, 0, - 0, 0, 0, 0, 57, 0, 58, 59, 60, 0, + 0, 312, 0, 0, 397, 53, 0, 54, 55, 0, + 398, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 15, 120, 108, 109, 18, 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, 0, 113, 0, 0, 0, 0, 0, 0, - 0, 0, 31, 32, 33, 34, 35, 36, 37, 38, + 0, 0, 31, 32, 33, 114, 35, 36, 37, 115, 39, 0, 40, 41, 42, 0, 0, 43, 0, 0, 44, 45, 0, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 946, 0, 0, 119, 53, + 0, 0, 0, 0, 0, 118, 0, 0, 119, 53, 0, 54, 55, 0, 0, 0, 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, 63, 0, 64, 0, 0, 5, 6, 7, 8, 9, 10, 11, 12, 13, @@ -3531,20 +3574,60 @@ static const yytype_int16 yytable[] = 112, 23, 24, 25, 26, 0, 0, 113, 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, 223, 0, 0, + 0, 43, 0, 0, 44, 45, 0, 116, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 312, + 0, 0, 397, 53, 0, 54, 55, 0, 0, 0, + 0, 0, 57, 0, 58, 59, 60, 0, 61, 62, + 63, 0, 64, 0, 0, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, + 0, 15, 120, 108, 109, 18, 19, 0, 0, 0, + 0, 0, 110, 111, 112, 23, 24, 25, 26, 0, + 0, 113, 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, 116, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 955, 0, 0, 119, 53, 0, 54, + 55, 0, 0, 0, 0, 0, 57, 0, 58, 59, + 60, 0, 61, 62, 63, 0, 64, 0, 0, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, + 0, 0, 0, 0, 0, 15, 120, 108, 109, 18, + 19, 0, 0, 0, 0, 0, 110, 111, 112, 23, + 24, 25, 26, 0, 0, 113, 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, 225, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 978, 0, 0, + 119, 53, 0, 54, 55, 0, 0, 644, 645, 0, + 57, 646, 58, 59, 60, 0, 61, 62, 63, 0, + 64, 0, 0, 0, 0, 0, 174, 175, 176, 177, + 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, + 120, 0, 184, 185, 186, 187, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 188, 189, 190, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 0, 201, 202, 653, 654, 0, 0, 655, 0, 203, + 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, + 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, + 186, 187, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 188, 189, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, - 0, 0, 119, 53, 0, 54, 55, 0, 0, 656, - 651, 0, 57, 657, 58, 59, 60, 0, 61, 62, - 63, 0, 64, 0, 0, 0, 0, 0, 174, 175, + 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 0, 201, 202, 674, + 645, 0, 0, 675, 0, 203, 275, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, - 0, 0, 120, 0, 184, 185, 186, 187, 0, 0, + 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 188, 189, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 0, 201, 202, 686, 642, 0, 0, 687, - 0, 203, 273, 0, 0, 0, 0, 0, 0, 0, + 199, 200, 0, 201, 202, 659, 654, 0, 0, 660, + 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, 0, 0, @@ -3552,7 +3635,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 0, 201, - 202, 689, 651, 0, 0, 690, 0, 203, 273, 0, + 202, 691, 645, 0, 0, 692, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, @@ -3560,8 +3643,8 @@ static const yytype_int16 yytable[] = 188, 189, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 0, 201, 202, 696, 642, 0, - 0, 697, 0, 203, 273, 0, 0, 0, 0, 0, + 197, 198, 199, 200, 0, 201, 202, 694, 654, 0, + 0, 695, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, @@ -3569,16 +3652,16 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 0, 201, 202, 699, 651, 0, 0, 700, 0, 203, - 273, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 201, 202, 701, 645, 0, 0, 702, 0, 203, + 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 188, 189, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 0, 201, 202, 735, - 642, 0, 0, 736, 0, 203, 273, 0, 0, 0, + 195, 196, 197, 198, 199, 200, 0, 201, 202, 704, + 654, 0, 0, 705, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, @@ -3586,8 +3669,8 @@ static const yytype_int16 yytable[] = 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 0, 201, 202, 738, 651, 0, 0, 739, - 0, 203, 273, 0, 0, 0, 0, 0, 0, 0, + 199, 200, 0, 201, 202, 739, 645, 0, 0, 740, + 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, 0, 0, @@ -3595,7 +3678,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 0, 201, - 202, 886, 642, 0, 0, 887, 0, 203, 273, 0, + 202, 742, 654, 0, 0, 743, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, @@ -3603,8 +3686,8 @@ static const yytype_int16 yytable[] = 188, 189, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 0, 201, 202, 889, 651, 0, - 0, 890, 0, 203, 273, 0, 0, 0, 0, 0, + 197, 198, 199, 200, 0, 201, 202, 893, 645, 0, + 0, 894, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, @@ -3612,16 +3695,16 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 0, 201, 202, 1028, 642, 0, 0, 1029, 0, 203, - 273, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 201, 202, 896, 654, 0, 0, 897, 0, 203, + 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 188, 189, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 0, 201, 202, 1040, - 642, 0, 0, 1041, 0, 203, 273, 0, 0, 0, + 195, 196, 197, 198, 199, 200, 0, 201, 202, 1037, + 645, 0, 0, 1038, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, @@ -3629,8 +3712,8 @@ static const yytype_int16 yytable[] = 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 0, 201, 202, 1043, 651, 0, 0, 1044, - 0, 203, 273, 0, 0, 0, 0, 0, 0, 0, + 199, 200, 0, 201, 202, 1049, 645, 0, 0, 1050, + 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, 0, 0, @@ -3638,612 +3721,602 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 0, 201, - 202, 656, 651, 0, 0, 657, 0, 203, 273, 0, + 202, 1052, 654, 0, 0, 1053, 0, 203, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 188, 189, 190, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 855, 0, 0, 0, - 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 0, 201, 202, 0, 0, 0, - 0, 0, 0, 203, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 0, 0, 0, 0, - 412, 413, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 415, 0, 0, 0, 0, 866, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 416, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 426, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 0, 0, - 0, 0, 412, 413, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 415, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 416, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 0, 0, 0, 0, 412, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 415, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 416, 0, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 0, 0, 249, 0, 412, 413, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 415, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 416, 0, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 0, 0, 0, 0, 0, 0, 0, 0, - -273, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 0, 0, 0, 0, 412, 413, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 415, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 416, 0, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 0, 0, 0, 0, 0, 0, 0, - 0, -274, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 0, 0, 0, 0, 412, 413, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 415, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 416, 0, 417, 418, 419, 420, 421, 422, - 423, 424, 425, 426, 0, 0, 0, 0, 0, 0, - 0, 0, -275, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 0, 0, 0, 0, 412, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 415, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 416, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 426, 0, 0, 0, 0, 0, - 0, 0, 0, -276, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 0, 0, 0, 0, - 412, 413, 0, 0, 0, 414, 0, 0, 0, 0, - 0, 0, 0, 415, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 0, 201, 202, 659, 654, 0, + 0, 660, 0, 203, 275, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 174, 175, 176, 177, + 178, 179, 180, 181, 0, 0, 182, 183, 0, 0, + 0, 0, 184, 185, 186, 187, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 188, 189, 190, 0, + 0, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 0, 0, 0, 0, 413, 414, 0, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 416, 201, 202, 0, 0, 0, 0, 0, 0, 203, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 416, 0, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 426, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 0, 0, - 0, 0, 412, 413, 0, 0, 0, 495, 0, 0, - 0, 0, 0, 0, 0, 415, 0, 0, 0, 0, + 0, 417, 0, 418, 419, 420, 421, 422, 423, 424, + 425, 426, 427, 0, 0, 0, 0, 0, 0, 0, + 0, -278, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 0, 0, 0, 0, 413, 414, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 416, 0, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 0, 0, 0, 0, 412, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 415, 0, 0, + 0, 416, 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, 416, 0, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - -608, -608, 0, 0, 0, 0, 412, 413, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 415, + 0, 0, 417, 0, 418, 419, 420, 421, 422, 423, + 424, 425, 426, 427, 0, 0, 0, 0, 0, 0, + 0, 0, -279, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 0, 0, 0, 0, 413, + 414, 0, 0, 0, 415, 0, 0, 0, 0, 0, + 0, 0, 416, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 418, 419, 420, 421, 422, + 423, 424, 425, 426, 427, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 0, 0, 0, + 0, 413, 414, 0, 0, 0, 497, 0, 0, 0, + 0, 0, 0, 0, 416, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426 + 0, 0, 0, 0, 0, 417, 0, 418, 419, 420, + 421, 422, 423, 424, 425, 426, 427, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 0, + 0, 0, 0, 413, 414, 401, 402, 403, 404, 405, + 406, 0, 0, 409, 410, 0, 416, 0, 0, 0, + 0, 413, 414, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 416, 0, 0, 417, 0, 418, + 419, 420, 421, 422, 423, 424, 425, 426, 427, 0, + 0, 0, 0, 0, 0, 0, 0, 418, 419, 420, + 421, 422, 423, 424, 425, 426, 427 }; static const yytype_int16 yycheck[] = { - 2, 16, 17, 89, 220, 20, 27, 69, 475, 27, - 2, 56, 4, 5, 6, 484, 82, 9, 10, 21, - 66, 13, 7, 15, 16, 17, 429, 7, 20, 14, - 14, 118, 4, 52, 87, 88, 269, 772, 312, 54, - 55, 305, 28, 28, 28, 309, 16, 17, 22, 15, - 20, 454, 54, 55, 74, 75, 329, 375, 584, 399, - 52, 16, 17, 748, 56, 20, 469, 587, 540, 5, - 6, 317, 74, 58, 66, 478, 91, 13, 58, 584, - 502, 60, 61, 62, 63, 490, 21, 22, 16, 17, - 82, 25, 20, 10, 659, 660, 16, 26, 15, 54, - 55, 121, 122, 69, 772, 5, 6, 954, 26, 111, - 532, 294, 57, 13, 90, 370, 931, 79, 29, 682, - 56, 367, 2, 25, 4, 117, 90, 119, 691, 51, - 602, 105, 25, 27, 5, 6, 391, 0, 92, 542, - 25, 105, 13, 92, 92, 584, 82, 25, 587, 75, - 103, 25, 330, 25, 142, 333, 56, 335, 28, 337, - 148, 339, 427, 216, 126, 25, 431, 121, 92, 434, - 105, 147, 121, 121, 227, 128, 111, 112, 123, 101, - 102, 103, 82, 147, 1031, 56, 791, 138, 142, 384, - 455, 386, 797, 90, 129, 115, 122, 121, 118, 119, - 498, 456, 113, 468, 502, 470, 128, 1022, 142, 138, - 144, 82, 57, 396, 479, 144, 951, 490, 210, 954, - 138, 115, 142, 55, 118, 119, 146, 753, 148, 221, - 222, 439, 440, 121, 296, 288, 90, 802, 9, 10, - 142, 144, 304, 305, 15, 148, 312, 309, 753, 142, - 147, 936, 146, 518, 148, 240, 90, 142, 273, 144, - 240, 314, 277, 142, 142, 267, 540, 269, 142, 90, - 142, 273, 90, 121, 507, 294, 121, 550, 543, 92, - 948, 273, 142, 951, 250, 277, 954, 90, 956, 281, - 282, 121, 92, 147, 286, 92, 1031, 317, 544, 125, - 722, 293, 294, 273, 221, 222, 711, 277, 780, 301, - 92, 92, 142, 147, 753, 90, 37, 38, 90, 52, - 312, 121, 277, 90, 121, 144, 147, 853, 602, 147, - 296, 58, 59, 772, 51, 861, 1004, 857, 55, 121, - 121, 681, 142, 322, 147, 142, 117, 367, 394, 277, - 92, 144, 397, 399, 346, 347, 348, 349, 350, 351, - 352, 353, 829, 1031, 927, 1033, 453, 1035, 399, 1037, - 548, 373, 147, 375, 346, 147, 312, 396, 370, 121, - 147, 60, 785, 18, 63, 20, 119, 92, 92, 1057, - 92, 16, 17, 439, 440, 20, 55, 92, 121, 391, - 142, 92, 394, 55, 396, 397, 25, 399, 439, 440, - 58, 59, 312, 293, 429, 670, 121, 121, 857, 121, - 142, 301, 20, 721, 722, 951, 121, 429, 107, 54, - 347, 348, 349, 350, 142, 708, 57, 429, 711, 454, - 758, 312, 17, 18, 868, 869, 431, 439, 440, 434, - 221, 222, 454, 115, 469, 138, 118, 119, 927, 429, - 462, 397, 454, 478, 456, 457, 346, 469, 732, 101, - 455, 351, 538, 465, 540, 496, 478, 469, 496, 74, - 75, 473, 715, 498, 454, 470, 478, 502, 145, 115, - 706, 483, 118, 119, 479, 793, 431, 397, 1024, 469, - 141, 121, 367, 139, 506, 507, 780, 929, 478, 1035, - 281, 282, 951, 515, 529, 954, 55, 532, 773, 784, - 455, 786, 148, 515, 544, 142, 397, 542, 514, 514, - 514, 101, 524, 518, 61, 470, 602, 64, 65, 505, - 542, 92, 101, 498, 479, 800, 538, 267, 540, 269, - 542, 142, 121, 286, 872, 873, 92, 549, 543, 612, - 61, 294, 835, 64, 65, 121, 101, 762, 763, 764, - 121, 766, 542, 768, 529, 51, 347, 348, 349, 350, - 788, 352, 353, 518, 304, 121, 794, 795, 142, 116, - 117, 846, 1031, 595, 129, 130, 131, 132, 133, 92, - 655, 92, 538, 658, 540, 90, 839, 51, 543, 630, - 602, 2, 630, 4, 1017, 116, 117, 142, 9, 10, - 105, 676, 142, 142, 15, 16, 17, 51, 121, 20, - 121, 929, 121, 115, 142, 515, 118, 119, 538, 51, - 540, 99, 15, 13, 524, 16, 63, 649, 273, 142, - 577, 142, 277, 655, 909, 140, 658, 659, 660, 144, - 15, 52, 147, 396, 298, 145, 602, 538, 302, 540, - 732, 145, 646, 139, 676, 66, 15, 669, 670, 681, - 682, 655, 684, 142, 658, 1003, 457, 142, 15, 691, - 898, 142, 44, 121, 679, 141, 16, 913, 141, 679, - 15, 18, 602, 919, 141, 570, 721, 722, 141, 701, - 139, 646, 798, 715, 780, 26, 702, 702, 702, 740, - 655, 15, 587, 658, 139, 590, 117, 141, 119, 148, - 139, 602, 465, 57, 142, 142, 782, 142, 142, 674, - 473, 676, 788, 789, 939, 940, 941, 942, 794, 795, - 483, 782, 669, 1018, 142, 15, 758, 788, 93, 14, - 145, 90, 16, 794, 795, 15, 721, 90, 15, 394, - 785, 146, 15, 142, 399, 101, 105, 142, 793, 90, - 142, 773, 105, 785, 701, 142, 506, 507, 780, 781, - 782, 142, 141, 785, 105, 115, 788, 789, 118, 119, - 802, 786, 794, 795, 15, 131, 132, 133, 800, 801, - 812, 140, 15, 815, 213, 785, 549, 140, 147, 210, - 16, 220, 814, 139, 147, 817, 146, 138, 148, 140, - 221, 222, 1027, 144, 826, 827, 147, 839, 793, 577, - 15, 15, 834, 581, 780, 772, 142, 868, 869, 139, - 126, 786, 898, 126, 846, 847, 55, 139, 257, 15, - 55, 115, 487, 142, 118, 119, 15, 898, 142, 503, - 872, 873, 62, 142, 64, 65, 510, 142, 870, 599, - 780, 142, 273, 875, 142, 144, 277, 521, 144, 141, - 281, 282, 146, 142, 148, 286, 90, 515, 669, 13, - 817, 781, 293, 294, 6, 1020, 898, 772, 772, 780, - 301, 105, 1022, 799, 929, 1019, 908, 909, 971, 115, - 912, 252, 118, 119, 916, 927, 116, 117, 7, 649, - 701, 577, 948, 90, 870, 268, -1, 571, 572, 875, - 951, -1, 62, 26, 64, 65, 140, 346, 105, -1, - 146, -1, 148, 147, -1, 346, 347, 348, 349, 350, - 351, 352, 353, 984, -1, -1, 984, 601, 877, 878, - 870, -1, -1, 90, -1, 875, 912, -1, 377, 370, - -1, -1, 974, 140, 976, -1, 706, 979, 105, -1, - 147, -1, 857, -1, 859, 715, 116, 117, 863, 870, - 391, 1003, 1017, 394, 875, 396, 115, 90, 399, 118, - 119, -1, 912, -1, -1, 1017, -1, 1019, 1020, -1, - -1, 948, 105, 140, 951, 1017, -1, 954, -1, 956, - 147, -1, -1, 1018, 772, -1, 145, 146, 429, 148, - -1, 912, 951, -1, 678, -1, 817, 1017, 439, 440, - -1, -1, -1, 37, 38, 138, 681, 140, -1, 26, - -1, 144, -1, 454, 147, 456, 457, -1, 801, 934, - 935, -1, -1, -1, 465, 474, 475, 1004, 469, -1, - -1, 814, 473, 1018, 26, -1, -1, 478, -1, 954, - -1, 956, 483, 826, 827, -1, -1, 731, 1007, 1008, - 1009, 834, 1011, 1012, 1031, -1, 1033, -1, 1035, -1, - 1037, -1, -1, -1, 847, 749, -1, -1, 26, 839, - -1, 26, -1, 90, 515, 524, 991, -1, -1, 994, - 1057, 115, 531, 524, 118, 119, 115, -1, 105, 118, - 119, -1, 1051, 1052, 1053, 1054, 439, 440, 90, 9, - 10, 542, 1061, -1, -1, 15, 16, 17, 549, -1, - 20, 1026, 146, 105, 148, -1, 1031, 146, 1033, 148, - -1, 138, 1037, 140, -1, 908, -1, 144, 471, 472, - 147, -1, 90, 916, -1, 90, -1, 47, 48, 49, - 50, -1, 1057, -1, 54, 55, 138, 105, 140, 90, - 105, -1, 144, -1, 838, 147, 66, 67, 90, -1, - 948, -1, -1, 951, 105, -1, 954, -1, 956, -1, - 854, -1, -1, 105, -1, -1, 519, -1, -1, -1, - 138, -1, 140, 138, -1, 140, 144, -1, -1, 147, - -1, 974, 147, 976, -1, -1, 979, -1, 90, 140, - -1, 51, 52, -1, -1, 55, 147, 117, 140, 63, - 64, 65, -1, 105, -1, 147, 1004, -1, -1, 668, - 70, 71, 72, 73, 74, 75, 76, 77, 669, 670, - 80, 81, -1, -1, -1, -1, 86, 87, 88, 89, - -1, -1, -1, 1031, -1, 1033, -1, 1035, 140, 1037, - 100, 101, 102, 90, -1, 147, 90, 706, 90, -1, - 701, -1, 116, 117, -1, -1, -1, -1, 105, 1057, - -1, 105, -1, 105, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, -1, 135, 136, 51, -1, 53, - 54, 55, 56, 143, 144, -1, 51, -1, 53, 54, - 55, 56, -1, 140, -1, 69, 140, 90, 140, -1, - 147, 221, 222, 147, 69, 147, 2, -1, 4, 5, - 6, 51, 105, 53, 54, 55, 56, 13, -1, -1, - -1, -1, 773, 40, 41, 42, 43, 44, -1, 69, - 781, 782, -1, -1, 785, -1, -1, 788, 789, 259, - 260, 261, 262, 794, 795, 804, -1, 140, -1, 800, - 801, -1, 90, 273, 147, -1, 52, 277, -1, -1, - 56, 281, 282, 814, -1, 90, 817, 105, 142, 51, - 829, 53, 54, 55, 56, 826, 827, 142, -1, -1, - 105, -1, -1, 834, -1, -1, 82, 69, -1, -1, - 63, 64, 65, -1, -1, 846, 847, -1, -1, 63, - 64, 65, 140, 85, -1, -1, -1, 115, -1, 147, - 118, 119, 94, -1, -1, 140, -1, -1, 100, 101, - 102, 103, 147, 119, 63, 64, 65, 347, 348, 349, - 350, -1, 352, 353, 142, 788, 789, -1, 146, -1, - 148, 794, 795, 116, 117, -1, 128, 898, -1, 131, - -1, 371, 116, 117, 913, -1, -1, 908, 909, -1, - 919, -1, 382, -1, -1, 916, -1, 820, 821, -1, - 823, 824, -1, -1, 394, -1, -1, 116, 117, 399, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, -1, 415, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, -1, -1, 429, - 63, 64, 65, -1, 210, -1, 63, 64, 65, 439, - 440, -1, -1, 974, -1, 976, -1, -1, 979, -1, - -1, 63, 64, 65, 454, -1, 51, 457, 53, 54, - 55, 56, 63, 64, 65, 898, -1, 467, -1, 469, - -1, 471, 472, -1, 69, -1, -1, -1, 478, 88, - 89, -1, -1, 116, 117, -1, 1017, 487, 921, 116, - 117, 491, 101, -1, -1, 495, -1, -1, 498, 94, - 500, -1, 502, 503, 116, 117, 101, 102, 103, -1, - 286, -1, -1, -1, -1, 116, 117, 293, 294, 519, - 129, 130, 131, 132, 133, 301, -1, -1, -1, 529, - -1, -1, 532, 128, -1, -1, 312, -1, -1, -1, - -1, -1, 542, -1, -1, -1, -1, -1, 51, -1, - 53, 54, 55, 56, -1, -1, -1, -1, 558, 559, - 2, -1, 4, 5, 6, 7, 69, -1, -1, -1, - 346, 13, -1, -1, 574, 351, -1, -1, -1, -1, - -1, -1, -1, 51, -1, 53, 54, 55, 56, -1, - -1, 94, -1, 593, 370, -1, 596, 100, 101, 102, - 103, 69, -1, -1, -1, -1, -1, -1, -1, -1, - 52, -1, -1, -1, 56, 391, -1, -1, 121, -1, - 396, 397, -1, 399, -1, 128, 94, -1, 131, -1, - -1, -1, 100, 51, -1, 53, 54, 55, 56, -1, - 82, 144, -1, 51, -1, 53, 54, 55, 56, -1, - -1, 69, -1, 51, -1, 53, 54, 55, 56, -1, - -1, 69, -1, 439, 440, -1, -1, -1, -1, 669, - -1, 69, -1, -1, -1, -1, 94, 119, -1, -1, - 456, 681, 100, 101, 102, 103, 94, -1, -1, 465, - -1, -1, 100, 101, 102, 103, 94, 473, -1, -1, - -1, 701, 100, 101, 102, 103, -1, 483, -1, -1, - 128, -1, 712, 131, 51, -1, 53, 54, 55, 56, - 128, 721, 722, 131, -1, -1, 144, -1, -1, -1, - 128, -1, 69, 131, -1, -1, 144, -1, -1, 515, - -1, -1, -1, -1, 142, -1, -1, 51, 524, 53, - 54, 55, 56, -1, -1, -1, 2, 94, 4, -1, - -1, -1, 538, 100, 540, 69, -1, 13, 210, -1, - -1, -1, -1, 549, -1, -1, -1, 777, -1, -1, - -1, -1, 782, 783, -1, 785, -1, -1, 788, 789, - 94, -1, -1, 793, 794, 795, -1, 51, -1, 53, - 54, 55, 56, -1, -1, -1, 52, -1, -1, -1, - -1, -1, -1, -1, -1, 69, -1, 817, -1, -1, - 820, 821, -1, 823, 824, -1, 602, -1, -1, -1, - -1, 85, -1, 833, -1, -1, -1, -1, 838, -1, - 94, -1, -1, -1, 286, -1, 100, 101, 102, 103, - -1, 293, 294, -1, -1, 855, -1, -1, -1, 301, - -1, -1, -1, -1, -1, -1, 866, -1, -1, -1, - 312, 88, 89, 119, 128, -1, -1, 131, -1, -1, - -1, 881, -1, -1, 101, -1, -1, -1, -1, -1, - -1, 891, 892, -1, 670, -1, -1, -1, 898, -1, - -1, -1, 44, -1, 346, -1, -1, -1, -1, 351, - -1, 128, 129, 130, 131, 132, 133, 2, -1, 4, - -1, 921, -1, -1, -1, -1, -1, -1, 370, 929, + 2, 27, 69, 284, 89, 87, 88, 28, 66, 271, + 2, 10, 4, 5, 6, 487, 15, 9, 10, 21, + 7, 13, 52, 15, 16, 17, 7, 22, 20, 82, + 16, 17, 4, 14, 20, 215, 478, 543, 313, 400, + 5, 6, 222, 222, 56, 14, 752, 28, 13, 15, + 440, 441, 54, 55, 16, 17, 430, 306, 20, 28, + 52, 310, 21, 22, 56, 590, 504, 778, 376, 75, + 587, 58, 74, 75, 66, 75, 2, 58, 4, 259, + 118, 455, 16, 17, 52, 330, 20, 25, 295, 318, + 82, 56, 54, 55, 371, 685, 938, 535, 472, 605, + 27, 29, 963, 69, 662, 663, 696, 481, 500, 111, + 105, 25, 504, 0, 26, 392, 122, 82, 16, 17, + 57, 331, 20, 26, 334, 117, 336, 119, 338, 91, + 340, 60, 61, 62, 63, 79, 218, 25, 269, 368, + 271, 25, 587, 51, 90, 590, 105, 229, 593, 25, + 103, 119, 111, 112, 144, 25, 54, 55, 138, 25, + 25, 61, 797, 60, 64, 65, 63, 347, 803, 55, + 129, 545, 90, 92, 305, 128, 121, 16, 17, 1040, + 457, 20, 126, 28, 121, 113, 121, 105, 115, 1031, + 397, 118, 119, 101, 102, 103, 90, 142, 378, 51, + 90, 147, 121, 55, 142, 400, 144, 289, 214, 142, + 107, 213, 214, 213, 214, 54, 116, 117, 210, 146, + 128, 148, 140, 142, 223, 224, 138, 90, 142, 147, + 297, 223, 224, 315, 92, 138, 121, 943, 305, 306, + 757, 144, 105, 310, 90, 440, 441, 509, 90, 960, + 808, 144, 963, 147, 142, 242, 144, 147, 142, 105, + 313, 242, 18, 90, 20, 295, 142, 269, 543, 271, + 125, 428, 142, 275, 57, 432, 142, 142, 435, 55, + 786, 121, 90, 275, 147, 92, 252, 279, 726, 275, + 55, 283, 284, 279, 140, 287, 90, 477, 478, 456, + 25, 147, 294, 295, 142, 147, 90, 20, 553, 90, + 302, 105, 757, 275, 471, 57, 473, 279, 547, 287, + 147, 313, 142, 684, 138, 482, 101, 295, 90, 1040, + 605, 297, 115, 725, 726, 118, 119, 395, 863, 147, + 123, 551, 400, 145, 934, 279, 140, 527, 313, 348, + 349, 350, 351, 147, 534, 347, 348, 349, 350, 351, + 352, 353, 354, 147, 521, 148, 147, 397, 294, 92, + 90, 385, 374, 387, 376, 347, 302, 508, 509, 371, + 92, 279, 440, 441, 92, 147, 398, 61, 121, 546, + 64, 65, 141, 835, 323, 139, 673, 55, 121, 142, + 392, 37, 38, 395, 794, 397, 398, 799, 400, 121, + 800, 801, 92, 121, 101, 101, 454, 791, 863, 142, + 865, 347, 867, 92, 869, 101, 352, 147, 430, 397, + 142, 9, 10, 398, 715, 92, 275, 15, 430, 121, + 279, 121, 116, 117, 430, 131, 132, 133, 440, 441, + 142, 432, 121, 455, 435, 763, 658, 719, 121, 661, + 51, 463, 934, 455, 121, 457, 458, 90, 430, 455, + 472, 602, 498, 432, 92, 456, 468, 679, 142, 481, + 472, 142, 105, 142, 476, 142, 472, 736, 541, 481, + 543, 671, 473, 455, 486, 481, 517, 456, 936, 92, + 468, 482, 779, 121, 51, 92, 508, 509, 476, 142, + 472, 786, 793, 51, 473, 905, 518, 140, 486, 481, + 121, 652, 142, 482, 147, 92, 518, 587, 121, 806, + 51, 711, 711, 615, 121, 527, 517, 99, 500, 117, + 521, 507, 504, 545, 936, 58, 59, 15, 517, 541, + 92, 543, 605, 545, 121, 142, 395, 92, 1003, 545, + 552, 400, 521, 13, 62, 546, 64, 65, 92, 850, + 532, 879, 880, 535, 851, 142, 541, 121, 543, 121, + 711, 121, 844, 545, 552, 577, 121, 546, 719, 440, + 441, 577, 518, 788, 16, 368, 598, 121, 63, 794, + 15, 527, 500, 139, 596, 800, 801, 633, 115, 92, + 596, 118, 119, 605, 2, 145, 4, 145, 116, 117, + 92, 9, 10, 474, 475, 58, 59, 15, 16, 17, + 810, 142, 20, 790, 532, 792, 17, 18, 121, 916, + 605, 148, 142, 299, 26, 223, 224, 303, 15, 121, + 652, 490, 1026, 15, 649, 835, 658, 875, 876, 661, + 662, 663, 587, 658, 52, 590, 661, 92, 142, 736, + 44, 522, 115, 672, 121, 118, 119, 679, 66, 141, + 672, 673, 684, 685, 141, 115, 707, 689, 118, 119, + 649, 63, 64, 65, 696, 682, 121, 757, 15, 658, + 18, 682, 661, 141, 1012, 283, 284, 706, 90, 141, + 905, 121, 122, 844, 706, 139, 15, 719, 677, 804, + 679, 139, 141, 105, 90, 62, 707, 64, 65, 117, + 788, 119, 139, 786, 90, 90, 794, 795, 707, 105, + 920, 920, 800, 801, 116, 117, 926, 926, 142, 105, + 105, 1032, 44, 767, 768, 769, 138, 771, 140, 773, + 57, 763, 144, 725, 726, 147, 142, 142, 90, 142, + 348, 349, 350, 351, 140, 353, 354, 142, 144, 116, + 117, 147, 580, 105, 140, 140, 584, 779, 44, 791, + 16, 147, 147, 15, 786, 787, 788, 93, 858, 791, + 573, 14, 794, 795, 15, 791, 808, 867, 800, 801, + 15, 792, 145, 142, 806, 807, 818, 590, 140, 821, + 593, 786, 210, 142, 823, 147, 16, 725, 820, 791, + 142, 823, 757, 792, 142, 223, 224, 799, 142, 807, + 832, 833, 844, 15, 15, 684, 141, 905, 840, 505, + 139, 15, 820, 778, 778, 15, 512, 15, 90, 851, + 852, 787, 139, 142, 832, 833, 126, 126, 524, 16, + 1027, 115, 840, 105, 118, 119, 55, 879, 880, 15, + 458, 139, 55, 15, 852, 877, 141, 275, 142, 115, + 882, 279, 118, 119, 142, 283, 284, 142, 980, 287, + 960, 799, 146, 142, 148, 142, 294, 295, 140, 580, + 144, 142, 877, 905, 302, 147, 142, 882, 574, 575, + 146, 142, 148, 915, 916, 115, 144, 919, 118, 119, + 142, 923, 934, 947, 948, 949, 950, 518, 863, 6, + 13, 1029, 778, 794, 795, 1031, 805, 915, 604, 800, + 801, 1028, 254, 7, 919, 923, 146, 960, 148, 347, + 348, 349, 350, 351, 352, 353, 354, 993, 115, 884, + 885, 118, 119, 1033, 936, 826, 827, 580, 829, 830, + 778, 957, -1, 371, 1044, -1, -1, 2, -1, 4, + -1, 983, -1, 985, -1, -1, 988, -1, 13, 146, + -1, 148, -1, -1, 392, 778, -1, 395, -1, 397, + 1012, 16, 400, -1, -1, 983, 90, 985, -1, 101, + 988, -1, 1036, -1, 1026, 681, 1028, 1029, 63, 64, + 65, 105, -1, 957, 1026, 960, 960, 52, 963, 963, + 1026, 965, 430, 37, 38, 960, 1027, 129, 130, 131, + 132, 133, 440, 441, 905, 63, 64, 65, 51, 26, + 53, 54, 55, 56, 1026, -1, 140, 455, 1027, 457, + 458, -1, -1, 147, -1, -1, 69, 928, -1, 735, + 468, 116, 117, -1, 472, -1, -1, -1, 476, 1013, + 863, -1, 865, 481, 672, -1, 869, 753, 486, -1, + -1, 1016, 1017, 1018, 119, 1020, 1021, 778, 116, 117, + 115, -1, -1, 118, 119, 1040, 1040, 26, 1042, -1, + 1044, 115, 1046, 90, 118, 119, -1, -1, 706, -1, + 518, -1, 51, -1, 53, 54, 55, 56, 105, 527, + -1, 146, 1066, 148, -1, 1060, 1061, 1062, 1063, 142, + 69, -1, 146, -1, 148, 1070, -1, 545, -1, 957, + 90, 90, 960, -1, 552, 963, -1, 965, 941, 942, + -1, 138, -1, 140, -1, 105, 105, 144, -1, -1, + 147, 90, 90, 90, -1, 26, 26, 843, -1, 577, + 963, -1, 965, -1, -1, 210, 105, 105, 105, 26, + -1, -1, -1, 859, -1, -1, -1, -1, 596, -1, + 140, 140, -1, 9, 10, 1013, -1, 147, 147, 15, + 16, 17, -1, 142, 20, -1, 90, 1000, -1, 138, + 1003, 140, 140, 140, -1, 144, -1, -1, 147, 147, + 147, 105, 1040, -1, 1042, 823, 1044, -1, 1046, 90, + 90, 47, 48, 49, 50, 63, 64, 65, 54, 55, + -1, -1, 1035, 90, 105, 105, -1, 1040, 1066, 1042, + 66, 67, 287, 1046, -1, -1, 140, -1, 105, 294, + 295, -1, -1, 147, 672, 673, 957, 302, -1, 960, + -1, -1, 963, 1066, 965, -1, -1, 138, 138, 140, + 140, -1, -1, 144, 144, -1, 147, 147, 116, 117, + -1, 138, 51, 140, 53, 54, 55, 56, 706, -1, + 147, 117, -1, -1, -1, 63, 64, 65, -1, -1, + 69, -1, 347, 63, 64, 65, -1, 352, -1, -1, + -1, -1, 1013, 63, 64, 65, -1, -1, 63, 64, + 65, -1, -1, -1, -1, 94, 371, -1, -1, -1, + -1, 100, 101, 102, 103, -1, -1, -1, -1, 1040, + -1, 1042, -1, 1044, -1, 1046, -1, 392, 116, 117, + -1, -1, 397, -1, -1, 400, 116, 117, -1, 128, + 115, 779, 131, 118, 119, 1066, 116, 117, -1, 787, + 788, 116, 117, 791, -1, 144, 794, 795, -1, -1, + -1, -1, 800, 801, -1, -1, -1, -1, 806, 807, + 145, 146, -1, 148, -1, 440, 441, 223, 224, -1, + -1, -1, 820, 88, 89, 823, 51, -1, 53, 54, + 55, 56, 457, -1, 832, 833, 101, 40, 41, 42, + 43, 44, 840, 468, 69, -1, -1, -1, -1, -1, + -1, 476, 44, 851, 852, 261, 262, 263, 264, -1, + -1, 486, -1, 128, 129, 130, 131, 132, 133, 275, + -1, -1, 115, 279, -1, 118, 119, 283, 284, -1, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, -1, -1, -1, -1, 88, 89, -1, 391, - -1, -1, -1, -1, 396, 397, -1, -1, -1, 101, - -1, -1, -1, -1, 210, -1, -1, 52, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 82, 83, -1, 518, -1, -1, 88, 89, -1, 142, + -1, -1, 527, 146, -1, 148, -1, 905, -1, 101, + -1, 51, -1, 53, 54, 55, 56, 915, 916, -1, + 115, -1, -1, 118, 119, 923, -1, 552, -1, 69, 122, -1, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, -1, -1, -1, -1, -1, 773, -1, -1, - 142, -1, -1, -1, 780, 781, 782, -1, -1, -1, - -1, -1, 788, -1, 456, -1, -1, 1017, 794, 795, - -1, -1, -1, 465, 800, 801, -1, -1, -1, -1, - -1, 473, -1, -1, 119, -1, -1, -1, 814, -1, - 286, 483, -1, -1, -1, -1, -1, 293, 294, -1, - 826, 827, -1, -1, -1, 301, -1, -1, 834, -1, - -1, 51, -1, 53, 54, 55, 56, -1, -1, -1, - 846, 847, -1, 515, -1, -1, 88, 89, -1, 69, - -1, -1, 524, -1, -1, -1, -1, -1, -1, 101, - -1, -1, -1, -1, 870, -1, 538, -1, 540, 875, - 346, -1, -1, -1, 94, 351, -1, 549, -1, -1, - 100, 101, 102, 103, 126, 127, 128, 129, 130, 131, - 132, 133, 898, -1, 370, 210, 72, 73, 74, 75, - 76, 77, 908, 909, 80, 81, 912, -1, 128, -1, - 916, 131, 88, 89, -1, 391, -1, -1, -1, -1, - 396, -1, -1, 399, -1, 101, -1, -1, -1, -1, - 602, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, -1, -1, - -1, -1, -1, 439, 440, -1, -1, -1, 974, -1, - 976, 286, -1, 979, -1, -1, -1, -1, 293, 294, - 456, -1, -1, -1, -1, -1, 301, -1, -1, 465, - -1, -1, -1, -1, -1, -1, -1, 473, 670, -1, - 0, -1, -1, -1, -1, -1, -1, 483, -1, -1, - -1, -1, -1, 13, 14, 15, 16, 17, 18, -1, - 20, -1, -1, -1, -1, -1, 26, 27, -1, -1, - -1, 346, -1, -1, -1, -1, 351, 37, 38, 515, - 40, 41, 42, 43, 44, -1, -1, -1, 524, -1, - -1, -1, -1, -1, -1, 370, -1, -1, -1, -1, + 132, 133, 348, 349, 350, 351, -1, 353, 354, -1, + 142, 146, -1, 148, 94, -1, -1, -1, -1, -1, + 100, 101, 102, 103, -1, -1, 372, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 383, -1, -1, + -1, -1, -1, -1, -1, 983, -1, 985, 128, 395, + 988, 131, -1, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, -1, -1, 430, -1, -1, 51, 1026, 53, + 54, 55, 56, -1, 440, 441, -1, 51, -1, 53, + 54, 55, 56, -1, -1, 69, -1, -1, 673, 455, + -1, -1, 458, -1, 51, 69, 53, 54, 55, 56, + -1, -1, -1, -1, 470, -1, 472, -1, 474, 475, + 94, -1, 69, -1, -1, 481, 100, -1, -1, -1, + 94, -1, -1, -1, 490, -1, 100, 493, -1, -1, + -1, 497, -1, -1, 500, -1, 502, 94, 504, 505, + 88, 89, -1, 100, 101, 102, 103, 2, -1, 4, + 5, 6, -1, 101, -1, -1, 522, 51, 13, 53, + 54, 55, 56, -1, 121, -1, 532, -1, -1, 535, + -1, 128, -1, -1, 131, 69, -1, -1, -1, 545, + -1, 129, 130, 131, 132, 133, -1, 144, 51, -1, + 53, 54, 55, 56, 779, 561, 562, 52, -1, -1, + 94, 56, 787, 788, -1, -1, 69, -1, -1, 794, + -1, 577, -1, -1, -1, 800, 801, -1, -1, -1, + -1, 806, 807, -1, -1, -1, -1, 82, -1, -1, + 596, 94, -1, 599, -1, 820, -1, 100, 101, 102, + 103, -1, -1, -1, 88, 89, -1, 832, 833, -1, + -1, -1, -1, -1, -1, 840, -1, 101, -1, -1, + -1, -1, -1, -1, 119, 128, 851, 852, 131, -1, + -1, -1, -1, -1, 51, -1, 53, 54, 55, 56, + -1, 144, 126, 127, 128, 129, 130, 131, 132, 133, + -1, -1, 69, -1, -1, -1, 51, -1, 53, 54, + 55, 56, -1, -1, -1, -1, 672, -1, -1, -1, + -1, -1, -1, -1, 69, -1, -1, 94, 684, -1, + 905, 687, 688, 100, 101, 102, 103, -1, -1, -1, + 915, 916, -1, 2, 919, 4, 5, 6, 923, 94, + 706, -1, -1, -1, 13, -1, 101, 102, 103, -1, + 716, 128, -1, -1, 131, 210, -1, -1, -1, 725, + 726, -1, -1, -1, 0, 142, -1, -1, -1, -1, + -1, -1, -1, 128, -1, -1, -1, 13, 14, 15, + 16, 17, 18, 52, 20, -1, -1, 56, -1, -1, + 26, 27, -1, -1, -1, -1, -1, -1, 983, -1, + 985, 37, 38, 988, 40, 41, 42, 43, 44, -1, + -1, -1, -1, 82, -1, -1, -1, 783, -1, -1, + -1, -1, 788, 789, -1, 791, -1, -1, 794, 795, + -1, -1, 287, 799, 800, 801, -1, -1, -1, 294, + 295, -1, -1, -1, -1, -1, -1, 302, -1, -1, + 119, -1, -1, -1, 90, -1, -1, 823, 313, -1, + 826, 827, -1, 829, 830, -1, -1, -1, -1, 105, + -1, -1, -1, 839, -1, -1, -1, 843, -1, 115, + -1, -1, 118, 119, -1, -1, -1, -1, -1, -1, + -1, -1, 347, -1, 860, 861, -1, 352, -1, -1, + -1, -1, 138, 139, -1, -1, 872, 873, 144, 145, + 146, 147, 148, -1, -1, -1, 371, -1, -1, -1, + -1, -1, 888, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 898, 899, -1, -1, -1, 392, -1, 905, + -1, 210, 397, 398, -1, 400, -1, 51, -1, 53, + 54, 55, 56, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 928, -1, -1, 69, -1, -1, -1, -1, + 936, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 85, -1, -1, -1, 440, 441, -1, -1, -1, + 94, -1, -1, -1, -1, -1, 100, 101, 102, 103, + -1, -1, 457, -1, 2, -1, 4, 5, 6, -1, + -1, -1, -1, 468, -1, 13, -1, -1, 287, -1, + -1, 476, -1, -1, 128, 294, 295, 131, -1, -1, + -1, 486, -1, 302, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 313, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 52, -1, -1, -1, 56, -1, + 1026, -1, -1, 518, -1, -1, -1, -1, -1, -1, + -1, -1, 527, -1, -1, 44, -1, -1, 347, -1, + -1, -1, -1, 352, 82, -1, 541, -1, 543, -1, + -1, -1, -1, -1, -1, -1, -1, 552, -1, -1, + -1, -1, 371, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, -1, -1, -1, -1, 88, + 89, 119, -1, 392, -1, -1, -1, -1, 397, 398, + -1, 400, 101, 51, -1, 53, 54, 55, 56, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 549, -1, -1, 391, -1, -1, -1, - -1, 396, -1, -1, 399, -1, -1, -1, -1, -1, - 90, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 773, -1, -1, -1, 105, -1, -1, 780, 781, - -1, -1, -1, -1, -1, 115, -1, -1, 118, 119, - -1, -1, -1, -1, 439, 440, -1, -1, 800, 801, - -1, -1, -1, -1, -1, -1, -1, -1, 138, 139, - -1, 456, 814, -1, 144, 145, 146, 147, 148, -1, - 465, -1, -1, -1, 826, 827, -1, -1, 473, -1, - -1, -1, 834, -1, -1, -1, -1, -1, 483, -1, - -1, -1, -1, -1, 846, 847, -1, -1, -1, -1, + 605, 69, -1, 122, -1, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, -1, -1, 85, -1, -1, + -1, 440, 441, -1, -1, -1, 94, -1, -1, -1, + -1, -1, 100, 101, 102, 103, -1, -1, 457, -1, + 2, -1, 4, 5, 6, 7, -1, -1, -1, 468, + -1, 13, -1, -1, -1, -1, -1, 476, -1, -1, + 128, -1, 210, 131, -1, -1, -1, 486, 673, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 51, 52, 670, -1, 55, -1, 870, -1, - 515, -1, -1, 875, -1, -1, -1, -1, -1, 524, - -1, 70, 71, 72, 73, 74, 75, 76, 77, -1, - -1, 80, 81, -1, -1, -1, -1, 86, 87, 88, - 89, -1, -1, -1, 549, -1, 908, 909, -1, -1, - 912, 100, 101, 102, 916, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, -1, 135, 136, -1, -1, - -1, -1, -1, -1, 143, 144, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 773, -1, -1, - -1, -1, 974, -1, 976, 781, 782, 979, -1, -1, - 51, 52, 788, -1, 55, -1, -1, -1, 794, 795, - -1, -1, -1, -1, 800, 801, -1, -1, -1, 70, - 71, 72, 73, 74, 75, 76, 77, -1, 814, 80, - 81, -1, -1, -1, -1, 86, 87, 88, 89, -1, - 826, 827, -1, -1, -1, 670, -1, -1, 834, 100, - 101, 102, -1, -1, -1, -1, -1, -1, -1, -1, - 846, 847, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, -1, 135, 136, 72, 73, 74, 75, - 76, 77, 143, 144, 80, 81, -1, -1, -1, -1, - -1, -1, 88, 89, -1, -1, -1, -1, -1, -1, - -1, -1, 898, -1, -1, 101, -1, -1, -1, -1, - -1, -1, 908, 909, -1, -1, 912, -1, -1, -1, - 916, -1, -1, -1, -1, -1, -1, -1, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 773, -1, - -1, -1, -1, -1, -1, -1, 781, 782, -1, -1, - -1, -1, -1, 788, -1, -1, -1, -1, -1, 794, - 795, -1, -1, -1, -1, 800, 801, -1, 72, 73, - 74, 75, 76, 77, 78, -1, 80, 81, 974, 814, - 976, -1, -1, 979, 88, 89, -1, -1, -1, -1, - -1, 826, 827, -1, -1, -1, -1, 101, -1, 834, - -1, -1, 44, -1, -1, -1, -1, -1, -1, -1, - -1, 846, 847, -1, -1, -1, -1, -1, -1, -1, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, -1, -1, -1, -1, 88, 89, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, - -1, -1, -1, 898, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 908, 909, -1, -1, -1, -1, -1, - 122, 916, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, -1, -1, -1, -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, 974, - 39, 976, -1, -1, 979, -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, 84, 85, -1, -1, -1, - -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, - -1, 100, -1, -1, -1, 104, -1, 106, 107, 108, - -1, 110, 111, 112, 0, 114, 115, -1, -1, 118, - 119, -1, -1, -1, -1, -1, -1, 13, 14, 15, - 16, 17, 18, -1, 20, 134, 135, 136, -1, -1, - -1, 27, 28, 29, -1, -1, -1, 146, -1, 148, - -1, 37, 38, -1, 40, 41, 42, 43, 44, -1, + 52, -1, -1, -1, 56, -1, -1, -1, -1, 518, + -1, -1, -1, -1, -1, -1, -1, -1, 527, -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, -1, -1, - -1, -1, 88, 89, 90, -1, -1, 93, -1, -1, - -1, -1, -1, 99, -1, 101, -1, -1, -1, 105, - -1, -1, -1, -1, -1, -1, -1, 113, -1, 115, - -1, -1, 118, 119, -1, -1, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, -1, -1, - 0, -1, -1, 139, 140, 141, 142, -1, -1, 145, - 146, 147, 148, 13, 14, 15, 16, 17, 18, -1, - 20, -1, -1, -1, -1, -1, 26, 27, 28, -1, - -1, -1, -1, -1, -1, -1, -1, 37, 38, -1, - 40, 41, 42, 43, 44, -1, -1, -1, -1, -1, + 82, -1, 541, -1, 543, -1, -1, -1, -1, -1, + -1, -1, -1, 552, -1, -1, -1, -1, -1, 287, + -1, -1, -1, -1, -1, -1, 294, 295, -1, -1, + -1, -1, -1, -1, 302, -1, -1, 119, -1, -1, + -1, -1, -1, -1, -1, 313, -1, -1, -1, -1, + -1, -1, -1, -1, 779, -1, -1, -1, -1, -1, + -1, 786, 787, 788, -1, -1, 605, -1, -1, 794, + -1, -1, -1, -1, -1, 800, 801, -1, -1, 347, + -1, 806, 807, -1, 352, 72, 73, 74, 75, 76, + 77, 78, -1, 80, 81, 820, -1, -1, -1, -1, + -1, 88, 89, 371, -1, -1, -1, 832, 833, -1, + -1, -1, -1, -1, 101, 840, -1, -1, -1, -1, + -1, -1, -1, -1, 392, -1, 851, 852, 210, 397, + 398, -1, 400, -1, 673, -1, -1, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, -1, -1, -1, + -1, -1, 877, -1, -1, -1, -1, 882, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 440, 441, -1, -1, -1, -1, -1, -1, + 905, -1, -1, -1, -1, -1, -1, -1, -1, 457, + 915, 916, -1, -1, 919, -1, -1, -1, 923, -1, + 468, -1, -1, -1, -1, 287, -1, -1, 476, -1, + -1, -1, 294, 295, -1, -1, -1, -1, 486, -1, + 302, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 313, -1, -1, -1, -1, -1, -1, -1, -1, + 779, -1, -1, -1, -1, -1, -1, 786, 787, 788, + 518, -1, -1, -1, -1, 794, -1, -1, 983, 527, + 985, 800, 801, 988, -1, 347, -1, 806, 807, -1, + 352, -1, -1, 541, -1, 543, -1, -1, -1, -1, + -1, 820, -1, -1, 552, -1, -1, -1, -1, 371, + -1, -1, -1, 832, 833, -1, -1, -1, -1, -1, + -1, 840, -1, -1, -1, -1, -1, -1, -1, -1, + 392, -1, 851, 852, -1, 397, 398, -1, -1, -1, + -1, -1, -1, 2, -1, 4, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 605, 877, -1, + -1, -1, -1, 882, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 905, -1, -1, -1, + 88, 89, -1, 52, -1, 457, 915, 916, -1, -1, + 919, -1, -1, 101, 923, -1, 468, -1, -1, -1, + -1, -1, -1, 44, 476, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 486, 673, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, -1, -1, -1, -1, + -1, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, -1, -1, -1, 518, 88, 89, -1, + 119, -1, -1, -1, 983, 527, 985, -1, -1, 988, + 101, -1, -1, -1, -1, -1, -1, -1, -1, 541, + -1, 543, -1, -1, -1, -1, -1, -1, -1, -1, + 552, 122, -1, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, -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, -1, -1, -1, -1, 88, 89, - 90, -1, -1, 93, -1, -1, -1, -1, -1, 99, - -1, 101, -1, -1, -1, 105, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 115, -1, -1, 118, 119, - -1, -1, 122, -1, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, -1, -1, 0, -1, 138, 139, - 140, 141, 142, -1, 144, 145, 146, 147, 148, 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, 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, - -1, -1, -1, -1, 88, 89, 90, -1, 92, 93, - -1, -1, -1, -1, -1, 99, -1, 101, -1, -1, - -1, 105, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 115, -1, -1, 118, 119, -1, 121, 122, -1, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - -1, -1, 0, -1, -1, 139, 140, 141, 142, -1, - -1, 145, 146, 147, 148, 13, 14, 15, 16, 17, - 18, -1, 20, -1, -1, -1, -1, -1, 26, 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, 779, 44, -1, -1, -1, -1, -1, 786, 787, + 788, -1, -1, 605, -1, -1, 794, -1, -1, -1, + -1, 210, 800, 801, -1, -1, -1, -1, 806, 807, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 820, -1, -1, -1, 88, 89, -1, -1, + -1, -1, -1, -1, 832, 833, -1, -1, -1, 101, + -1, -1, 840, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 851, 852, -1, -1, -1, -1, -1, + 122, 673, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, -1, -1, -1, -1, -1, -1, 287, 877, + -1, -1, -1, -1, 882, 294, 295, -1, -1, -1, + -1, -1, -1, 302, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, -1, 905, -1, -1, + 88, 89, -1, -1, -1, -1, -1, 915, 916, -1, + -1, 919, -1, 101, -1, 923, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 347, -1, + -1, -1, -1, 352, 122, -1, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, -1, -1, -1, -1, + -1, -1, 371, -1, 142, -1, -1, 779, -1, -1, + -1, -1, -1, -1, 786, 787, -1, -1, -1, -1, + -1, -1, -1, 392, -1, 983, -1, 985, 397, -1, + 988, 400, -1, -1, 806, 807, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 820, 0, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 832, 833, 13, 14, 15, 16, 17, 18, 840, 20, + -1, 440, 441, -1, -1, -1, 27, 28, 29, 851, + 852, -1, -1, -1, -1, -1, 37, 38, 457, 40, + 41, 42, 43, 44, -1, -1, -1, -1, -1, 468, + -1, -1, -1, -1, -1, 877, 57, 476, -1, -1, + 882, -1, -1, -1, -1, -1, -1, 486, -1, -1, + -1, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, -1, -1, -1, -1, 88, 89, 90, + -1, -1, 93, 915, 916, -1, -1, 919, 99, 518, + 101, 923, -1, -1, 105, -1, -1, -1, 527, -1, + -1, -1, 113, -1, 115, -1, -1, 118, 119, -1, + -1, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 552, -1, -1, -1, -1, 139, 140, + 141, 142, -1, -1, 145, 146, 147, 148, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 983, -1, 985, 0, 1, 988, 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, 84, 85, + -1, -1, -1, -1, 673, 91, -1, -1, 94, 95, + -1, 97, 98, -1, 100, -1, -1, -1, 104, -1, + 106, 107, 108, -1, 110, 111, 112, -1, 114, 115, + -1, -1, 118, 119, -1, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, -1, 134, 135, + 136, 88, 89, -1, -1, -1, -1, -1, -1, -1, + 146, -1, 148, -1, 101, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 122, -1, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, -1, -1, -1, + -1, -1, -1, -1, -1, 142, -1, -1, -1, -1, + 779, -1, -1, -1, -1, -1, -1, -1, 787, 788, + -1, -1, -1, -1, -1, 794, -1, -1, -1, -1, + -1, 800, 801, -1, -1, -1, -1, 806, 807, -1, + -1, -1, -1, -1, -1, 72, 73, 74, 75, 76, + 77, 820, 0, 80, 81, -1, -1, -1, -1, -1, + -1, 88, 89, 832, 833, 13, 14, 15, 16, 17, + 18, 840, 20, -1, 101, -1, -1, -1, 26, 27, + 28, -1, 851, 852, -1, -1, -1, -1, -1, 37, + 38, -1, 40, 41, 42, 43, 44, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, -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, -1, -1, -1, -1, - 88, 89, 90, -1, -1, 93, -1, -1, -1, -1, - -1, 99, -1, 101, -1, -1, -1, 105, -1, -1, + 78, 79, 80, 81, 82, 83, 905, -1, -1, -1, + 88, 89, 90, -1, -1, 93, 915, 916, -1, -1, + -1, 99, -1, 101, 923, -1, -1, 105, -1, -1, -1, -1, -1, -1, -1, -1, -1, 115, -1, -1, 118, 119, -1, -1, 122, -1, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, -1, -1, 0, -1, - 138, 139, 140, 141, 142, -1, 144, 145, 146, 147, - 148, 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, + 128, 129, 130, 131, 132, 133, -1, -1, -1, -1, + 138, 139, 140, 141, 142, 0, 144, 145, 146, 147, + 148, -1, -1, -1, -1, -1, -1, -1, 13, 14, + 15, 16, 17, 18, 983, 20, 985, -1, -1, 988, + -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, 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, -1, + -1, -1, -1, 88, 89, 90, -1, 92, 93, -1, + -1, -1, -1, -1, 99, -1, 101, -1, -1, -1, + 105, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 115, -1, -1, 118, 119, -1, 121, 122, -1, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, -1, + -1, 0, -1, -1, 139, 140, 141, 142, -1, -1, + 145, 146, 147, 148, 13, 14, 15, 16, 17, 18, + -1, 20, -1, -1, -1, -1, -1, 26, 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, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, -1, -1, -1, -1, 88, 89, 90, -1, - -1, 93, -1, -1, -1, -1, -1, 99, -1, 101, - -1, -1, -1, 105, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 115, -1, -1, 118, 119, -1, -1, - 122, -1, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, -1, -1, 0, -1, -1, 139, 140, 141, - 142, -1, 144, 145, 146, 147, 148, 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, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, -1, -1, -1, -1, 88, + 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + 99, -1, 101, -1, -1, -1, 105, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 115, -1, -1, 118, + 119, -1, -1, 122, -1, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, -1, -1, 0, -1, 138, + 139, 140, 141, 142, -1, 144, 145, 146, 147, 148, + 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, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, -1, -1, - -1, -1, 88, 89, 90, -1, 92, 93, -1, -1, - -1, -1, -1, -1, -1, 101, -1, -1, -1, 105, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 115, - -1, -1, 118, 119, -1, 121, 122, -1, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, -1, -1, - 0, -1, 138, 139, 140, -1, 142, -1, -1, 145, - 146, 147, 148, 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, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, -1, -1, -1, -1, 88, 89, 90, -1, -1, + 93, -1, -1, -1, -1, -1, 99, -1, 101, -1, + -1, -1, 105, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 115, -1, -1, 118, 119, -1, -1, 122, + -1, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, -1, -1, 0, -1, -1, 139, 140, 141, 142, + -1, 144, 145, 146, 147, 148, 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, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, -1, -1, -1, -1, 88, 89, - 90, -1, 92, 93, -1, -1, -1, -1, -1, -1, - -1, 101, -1, -1, -1, 105, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 115, -1, -1, 118, 119, - -1, 121, 122, -1, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, -1, -1, 0, -1, 138, 139, - 140, -1, 142, -1, -1, 145, 146, 147, 148, 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, -1, -1, -1, + -1, 88, 89, 90, -1, 92, 93, -1, -1, -1, + -1, -1, -1, -1, 101, -1, -1, -1, 105, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 115, -1, + -1, 118, 119, -1, 121, 122, -1, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, -1, -1, 0, + -1, 138, 139, 140, -1, 142, -1, -1, 145, 146, + 147, 148, 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, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - -1, -1, -1, -1, 88, 89, 90, -1, 92, 93, - -1, -1, -1, -1, -1, -1, -1, 101, -1, -1, - -1, 105, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 115, -1, -1, 118, 119, -1, 121, 122, -1, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - -1, -1, 0, -1, -1, 139, 140, -1, 142, -1, - -1, 145, 146, 147, 148, 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, -1, -1, -1, -1, 88, 89, 90, + -1, 92, 93, -1, -1, -1, -1, -1, -1, -1, + 101, -1, -1, -1, 105, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 115, -1, -1, 118, 119, -1, + 121, 122, -1, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, -1, -1, 0, -1, 138, 139, 140, + -1, 142, -1, -1, 145, 146, 147, 148, 13, 14, + 15, -1, 17, 18, -1, 20, -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, -1, -1, -1, -1, - 88, 89, 90, -1, 92, 93, -1, -1, -1, -1, - -1, -1, -1, 101, -1, -1, -1, 105, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 115, -1, -1, - 118, 119, -1, 121, 122, -1, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, -1, -1, -1, -1, - -1, 139, 140, -1, 142, -1, -1, 145, 146, 147, - 148, 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, 84, 85, -1, -1, -1, -1, - -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, - 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, - 110, 111, 112, -1, 114, 115, -1, -1, 118, 119, + -1, -1, 37, 38, -1, 40, 41, 42, 43, 44, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 134, 135, 136, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 146, 1, 148, 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, - 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, - 94, 95, -1, 97, 98, -1, 100, -1, -1, -1, - 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, - 114, 115, -1, -1, 118, 119, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, -1, + -1, -1, -1, 88, 89, 90, -1, 92, 93, -1, + -1, -1, -1, -1, -1, -1, 101, -1, -1, -1, + 105, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 115, -1, -1, 118, 119, -1, 121, 122, -1, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, -1, + -1, 0, -1, -1, 139, 140, -1, 142, -1, -1, + 145, 146, 147, 148, 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, - 134, 135, 136, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 146, 1, 148, 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, 84, 85, -1, -1, - -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, - 98, -1, 100, -1, -1, -1, 104, -1, 106, 107, - 108, -1, 110, 111, 112, -1, 114, 115, -1, -1, - 118, 119, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 134, 135, 136, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 146, 1, - 148, 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, 84, 85, -1, -1, -1, -1, -1, 91, - -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, - -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, - 112, -1, 114, 115, -1, -1, 118, 119, 1, -1, + -1, -1, -1, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, -1, -1, -1, -1, 88, + 89, 90, -1, 92, 93, -1, -1, -1, -1, -1, + -1, -1, 101, -1, -1, -1, 105, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 115, -1, -1, 118, + 119, -1, 121, 122, -1, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, -1, -1, -1, -1, -1, + 139, 140, -1, 142, -1, -1, 145, 146, 147, 148, + 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, 84, 85, -1, -1, -1, -1, -1, + 91, -1, -1, 94, 95, -1, 97, 98, -1, 100, + -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, + 111, 112, -1, 114, 115, -1, -1, 118, 119, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 134, 135, 136, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 146, 1, 148, 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, 84, + 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, + 95, -1, 97, 98, -1, 100, -1, -1, -1, 104, + -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, + 115, -1, -1, 118, 119, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 134, + 135, 136, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 146, 1, 148, 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, 84, 85, -1, -1, -1, + -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, + -1, 100, -1, -1, -1, 104, -1, 106, 107, 108, + -1, 110, 111, 112, -1, 114, 115, -1, -1, 118, + 119, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 134, 135, 136, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 146, 1, 148, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - -1, -1, 134, 135, 136, -1, 19, -1, 21, 22, - 23, 24, -1, -1, 146, -1, 148, 30, 31, 32, + -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, 46, 47, 48, 49, 50, 51, 52, + -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, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, - -1, 114, 115, -1, -1, 118, 119, -1, -1, -1, + -1, 114, 115, -1, -1, 118, 119, 1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, + -1, 134, 135, 136, -1, 19, -1, 21, 22, 23, + 24, -1, -1, 146, -1, 148, 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, 134, 135, 136, -1, -1, 139, -1, -1, -1, - -1, -1, -1, 146, 1, 148, 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, -1, -1, 84, 85, -1, - -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, - 97, 98, -1, 100, -1, -1, -1, 104, -1, 106, - 107, 108, -1, 110, 111, 112, -1, 114, 115, -1, - -1, 118, 119, 1, -1, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, -1, -1, 134, 135, 136, - -1, 19, -1, 21, 22, 23, 24, -1, -1, 146, - -1, 148, 30, 31, 32, 33, 34, 35, 36, -1, + 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, + 94, 95, -1, 97, 98, -1, 100, -1, -1, -1, + 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, + 114, 115, -1, -1, 118, 119, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 134, 135, 136, -1, -1, 139, -1, -1, -1, -1, + -1, -1, 146, 1, 148, 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, @@ -4254,7 +4327,7 @@ static const yytype_int16 yycheck[] = 108, -1, 110, 111, 112, -1, 114, 115, -1, -1, 118, 119, 1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, 134, 135, 136, -1, - 19, -1, 21, 22, 23, 24, -1, 145, 146, -1, + 19, -1, 21, 22, 23, 24, -1, -1, 146, -1, 148, 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, @@ -4276,26 +4349,26 @@ static const yytype_int16 yycheck[] = -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, 115, -1, -1, 118, 119, + 1, -1, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, -1, -1, 134, 135, 136, -1, 19, -1, + 21, 22, 23, 24, -1, 145, 146, -1, 148, 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, 84, 85, -1, -1, -1, -1, -1, + 91, -1, -1, 94, 95, -1, 97, 98, -1, 100, + -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, + 111, 112, -1, 114, 115, -1, -1, 118, 119, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 134, 135, 136, -1, -1, 139, - -1, -1, -1, -1, -1, -1, 146, 1, 148, 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, -1, - 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, - 94, 95, -1, 97, 98, -1, 100, -1, -1, -1, - 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, - 114, 115, -1, -1, 118, 119, -1, -1, 3, 4, + -1, -1, -1, 134, 135, 136, -1, -1, 139, -1, + -1, -1, -1, -1, -1, 146, 1, 148, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, - 134, 135, 136, -1, 19, -1, 21, 22, 23, 24, - -1, -1, 146, -1, 148, 30, 31, 32, 33, 34, + 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, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 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, 84, @@ -4307,7 +4380,7 @@ static const yytype_int16 yycheck[] = 135, 136, -1, 19, -1, 21, 22, 23, 24, -1, -1, 146, -1, 148, 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, + 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, 84, 85, @@ -4315,16 +4388,16 @@ static const yytype_int16 yycheck[] = -1, 97, 98, -1, 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, 115, -1, -1, 118, 119, -1, -1, 3, 4, 5, 6, - 7, 8, 9, 10, 11, -1, -1, -1, 134, 135, + 7, 8, 9, 10, 11, 12, -1, -1, 134, 135, 136, -1, 19, -1, 21, 22, 23, 24, -1, -1, 146, -1, 148, 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, -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, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, - 97, 98, -1, -1, -1, -1, -1, 104, -1, 106, + 97, 98, -1, 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, 115, -1, -1, 118, 119, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, 134, 135, 136, @@ -4338,26 +4411,21 @@ static const yytype_int16 yycheck[] = -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, -1, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, 115, -1, -1, - 118, 119, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 134, 135, 136, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 146, -1, - 148, 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, -1, -1, 80, 81, - -1, -1, -1, -1, 86, 87, 88, 89, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 100, 101, - 102, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, -1, 135, 136, -1, -1, -1, -1, -1, - -1, 143, 144, 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, + 118, 119, -1, -1, 3, 4, 5, 6, 7, 8, + 9, 10, 11, -1, -1, -1, 134, 135, 136, -1, + 19, -1, 21, 22, 23, 24, -1, -1, 146, -1, + 148, 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, 85, -1, -1, -1, + -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, + -1, -1, -1, -1, -1, 104, -1, 106, 107, 108, + -1, 110, 111, 112, -1, 114, 115, -1, -1, 118, + 119, -1, -1, 3, 4, 5, 6, 7, 8, 9, + 10, 11, -1, -1, -1, 134, 135, 136, -1, 19, + -1, 21, 22, 23, 24, -1, -1, 146, -1, 148, 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, @@ -4365,61 +4433,78 @@ static const yytype_int16 yycheck[] = 70, 71, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, - 100, -1, 102, 103, 104, -1, 106, 107, 108, -1, - 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 104, -1, 106, 107, 108, -1, + 110, 111, 112, -1, 114, 115, -1, -1, 118, 119, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 134, 135, 136, -1, 138, -1, - -1, -1, -1, -1, 144, 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, 84, 85, -1, -1, - -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, - 98, -1, 100, -1, 102, 103, 104, -1, 106, 107, - 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, - -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, - 10, 11, -1, -1, -1, -1, 134, 135, 136, 19, - 138, 21, 22, 23, 24, -1, 144, -1, -1, -1, + -1, -1, -1, -1, 134, 135, 136, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 148, 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, -1, -1, 80, 81, -1, -1, + -1, -1, 86, 87, 88, 89, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 100, 101, 102, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + -1, 135, 136, -1, -1, -1, -1, -1, -1, 143, + 144, 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, 84, 85, -1, -1, -1, -1, -1, 91, + -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, + 102, 103, 104, -1, 106, 107, 108, -1, 110, 111, + 112, -1, 114, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 134, 135, 136, -1, 138, -1, -1, -1, + -1, -1, 144, 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, 84, 85, -1, -1, -1, -1, - -1, 91, 92, -1, 94, 95, -1, 97, 98, -1, + -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, 102, 103, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, - -1, 121, 3, 4, 5, 6, 7, 8, 9, 10, - 11, -1, -1, -1, 134, 135, 136, -1, 19, -1, - 21, 22, 23, 24, 144, -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, 85, -1, -1, -1, -1, -1, - 91, 92, -1, 94, 95, -1, 97, 98, -1, 100, - -1, 102, 103, 104, -1, 106, 107, 108, -1, 110, - 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, - 121, 3, 4, 5, 6, 7, 8, 9, 10, 11, - -1, -1, -1, 134, 135, 136, -1, 19, -1, 21, - 22, 23, 24, 144, -1, -1, -1, -1, 30, 31, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + -1, -1, -1, -1, 134, 135, 136, 19, 138, 21, + 22, 23, 24, -1, 144, -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, 85, -1, -1, -1, -1, -1, 91, - -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, + 92, -1, 94, 95, -1, 97, 98, -1, 100, -1, 102, 103, 104, -1, 106, 107, 108, -1, 110, 111, - 112, -1, 114, -1, -1, -1, -1, -1, -1, 3, + 112, -1, 114, -1, -1, -1, -1, -1, -1, 121, + 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, + -1, -1, 134, 135, 136, -1, 19, -1, 21, 22, + 23, 24, 144, -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, 85, -1, -1, -1, -1, -1, 91, 92, + -1, 94, 95, -1, 97, 98, -1, 100, -1, 102, + 103, 104, -1, 106, 107, 108, -1, 110, 111, 112, + -1, 114, -1, -1, -1, -1, -1, -1, 121, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, - -1, -1, 134, 135, 136, 19, -1, 21, 22, 23, - 24, -1, 144, -1, -1, -1, 30, 31, 32, 33, + -1, 134, 135, 136, -1, 19, -1, 21, 22, 23, + 24, 144, -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, @@ -4428,20 +4513,60 @@ static const yytype_int16 yycheck[] = 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, 102, 103, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, - 114, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 114, -1, -1, -1, -1, -1, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, + 134, 135, 136, 19, -1, 21, 22, 23, 24, -1, + 144, -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, 85, + -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, + -1, 97, 98, -1, 100, -1, 102, 103, 104, -1, + 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 134, 135, 136, -1, -1, -1, -1, -1, -1, -1, - 144, 3, 4, 5, 6, 7, 8, 9, 10, 11, + -1, -1, -1, -1, -1, -1, -1, -1, 134, 135, + 136, -1, -1, -1, -1, -1, -1, -1, 144, 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, -1, -1, 80, 81, -1, -1, + -1, -1, 86, 87, 88, 89, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 100, 101, 102, -1, + -1, -1, -1, 107, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + -1, 135, 136, -1, -1, -1, -1, -1, -1, 143, + 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, -1, -1, 80, 81, -1, + -1, -1, -1, 86, 87, 88, 89, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 100, 101, 102, + -1, -1, -1, -1, 107, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, -1, 135, 136, -1, -1, -1, -1, -1, -1, + 143, 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, + 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, -1, -1, 80, 81, -1, -1, -1, -1, 86, 87, 88, 89, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 100, 101, - 102, -1, -1, -1, -1, 107, -1, -1, -1, -1, + 102, -1, -1, -1, 106, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, -1, 135, 136, -1, -1, -1, -1, -1, @@ -4450,83 +4575,43 @@ static const yytype_int16 yycheck[] = 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, + 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, -1, -1, 80, 81, -1, -1, -1, -1, 86, 87, 88, 89, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 100, - 101, 102, -1, -1, -1, -1, 107, -1, -1, -1, + 101, 102, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, -1, 135, 136, -1, -1, -1, -1, -1, -1, 143, 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, -1, -1, - 80, 81, -1, -1, -1, -1, 86, 87, 88, 89, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 100, 101, 102, -1, -1, -1, 106, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, -1, 135, 136, -1, -1, -1, - -1, -1, -1, 143, 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, -1, - -1, 80, 81, -1, -1, -1, -1, 86, 87, 88, - 89, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 100, 101, 102, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, -1, 135, 136, -1, -1, - -1, -1, -1, -1, 143, 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, 91, -1, -1, 94, 95, -1, 97, - 98, -1, -1, -1, -1, -1, 104, -1, 106, 107, - 108, -1, 110, 111, 112, -1, 114, -1, -1, 3, - 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, - -1, -1, -1, -1, -1, 19, 134, 21, 22, 23, - 24, -1, -1, -1, 142, -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, 91, -1, -1, - 94, 95, -1, 97, 98, -1, -1, -1, -1, -1, - 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, - 114, -1, -1, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, -1, -1, -1, -1, -1, -1, 19, - 134, 21, 22, 23, 24, -1, -1, -1, 142, -1, + 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, 45, 46, 47, 48, 49, + -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, 85, -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, 91, -1, -1, 94, 95, -1, 97, 98, -1, - 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, - 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 104, -1, 106, 107, 108, -1, + 110, 111, 112, -1, 114, -1, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, + -1, -1, -1, 19, 134, 21, 22, 23, 24, -1, + -1, -1, 142, -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, 91, -1, -1, 94, 95, + -1, 97, 98, -1, -1, -1, -1, -1, 104, -1, + 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, -1, -1, -1, 134, 135, 136, 19, -1, 21, - 22, 23, 24, -1, -1, -1, -1, -1, 30, 31, + 12, -1, -1, -1, -1, -1, -1, 19, 134, 21, + 22, 23, 24, -1, -1, -1, 142, -1, 30, 31, 32, 33, 34, 35, 36, -1, -1, 39, -1, -1, - -1, -1, -1, 45, -1, 47, 48, 49, 50, 51, + -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, @@ -4534,16 +4619,16 @@ static const yytype_int16 yycheck[] = -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, 3, - 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, + 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, 134, 135, 136, 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, + -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, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, - 94, 95, -1, 97, 98, -1, 100, -1, 102, 103, + 94, 95, -1, 97, 98, -1, 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, @@ -4591,7 +4676,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, - 102, -1, 104, -1, 106, 107, 108, -1, 110, 111, + 102, 103, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, 134, 135, 136, 19, -1, 21, 22, 23, @@ -4602,7 +4687,7 @@ static const yytype_int16 yycheck[] = -1, -1, 66, 67, -1, 69, 70, 71, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, - 94, 95, -1, 97, 98, -1, -1, -1, 102, 103, + 94, 95, -1, 97, 98, -1, 100, -1, 102, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, @@ -4614,7 +4699,7 @@ static const yytype_int16 yycheck[] = 66, 67, -1, 69, 70, 71, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, - -1, 97, 98, -1, 100, -1, 102, -1, 104, -1, + -1, 97, 98, -1, -1, -1, 102, 103, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, 134, 135, @@ -4626,7 +4711,7 @@ static const yytype_int16 yycheck[] = -1, 69, 70, 71, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, - 98, -1, -1, -1, 102, -1, 104, -1, 106, 107, + 98, -1, 100, -1, 102, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, 134, 135, 136, 19, @@ -4638,7 +4723,7 @@ static const yytype_int16 yycheck[] = 70, 71, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, - 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, + -1, -1, 102, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, 134, 135, 136, 19, -1, 21, @@ -4697,7 +4782,7 @@ static const yytype_int16 yycheck[] = 70, 71, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 84, 85, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, - -1, -1, -1, -1, 104, -1, 106, 107, 108, -1, + 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, 134, 135, 136, 19, -1, 21, @@ -4729,33 +4814,22 @@ static const yytype_int16 yycheck[] = 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, 88, -1, -1, 91, -1, -1, 94, 95, + 66, 67, -1, 69, 70, 71, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 84, 85, + -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, -1, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, - -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, - -1, -1, -1, -1, -1, -1, -1, 19, 134, 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, 91, - -1, -1, 94, 95, -1, 97, 98, -1, 100, -1, - -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, - 112, -1, 114, -1, -1, 3, 4, 5, 6, 7, - 8, 9, 10, 11, -1, -1, -1, -1, -1, -1, - -1, 19, 134, 21, 22, 23, 24, -1, -1, -1, + -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, + 8, 9, 10, 11, -1, -1, -1, -1, 134, 135, + 136, 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, 91, -1, -1, 94, 95, -1, 97, - 98, -1, 100, -1, -1, -1, 104, -1, 106, 107, + 88, -1, -1, 91, -1, -1, 94, 95, -1, 97, + 98, -1, -1, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1, 19, 134, 21, 22, 23, @@ -4766,7 +4840,7 @@ static const yytype_int16 yycheck[] = -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, 91, -1, -1, - 94, 95, -1, 97, 98, -1, -1, -1, -1, -1, + 94, 95, -1, 97, 98, -1, 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1, 19, @@ -4778,7 +4852,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, 94, 95, -1, 97, 98, -1, - -1, -1, -1, -1, 104, -1, 106, 107, 108, -1, + 100, -1, -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, 112, -1, 114, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1, 19, 134, 21, 22, 23, 24, -1, @@ -4800,11 +4874,51 @@ static const yytype_int16 yycheck[] = -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, 91, - -1, -1, 94, 95, -1, 97, 98, -1, -1, 51, - 52, -1, 104, 55, 106, 107, 108, -1, 110, 111, - 112, -1, 114, -1, -1, -1, -1, -1, 70, 71, + -1, -1, 94, 95, -1, 97, 98, -1, -1, -1, + -1, -1, 104, -1, 106, 107, 108, -1, 110, 111, + 112, -1, 114, -1, -1, 3, 4, 5, 6, 7, + 8, 9, 10, 11, -1, -1, -1, -1, -1, -1, + -1, 19, 134, 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, 91, -1, -1, 94, 95, -1, 97, + 98, -1, -1, -1, -1, -1, 104, -1, 106, 107, + 108, -1, 110, 111, 112, -1, 114, -1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, -1, -1, + -1, -1, -1, -1, -1, 19, 134, 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, 91, -1, -1, + 94, 95, -1, 97, 98, -1, -1, 51, 52, -1, + 104, 55, 106, 107, 108, -1, 110, 111, 112, -1, + 114, -1, -1, -1, -1, -1, 70, 71, 72, 73, + 74, 75, 76, 77, -1, -1, 80, 81, -1, -1, + 134, -1, 86, 87, 88, 89, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 100, 101, 102, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + -1, 135, 136, 51, 52, -1, -1, 55, -1, 143, + 144, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 70, 71, 72, 73, 74, 75, 76, 77, + -1, -1, 80, 81, -1, -1, -1, -1, 86, 87, + 88, 89, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 100, 101, 102, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, -1, 135, 136, 51, + 52, -1, -1, 55, -1, 143, 144, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, 73, 74, 75, 76, 77, -1, -1, 80, 81, - -1, -1, 134, -1, 86, 87, 88, 89, -1, -1, + -1, -1, -1, -1, 86, 87, 88, 89, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 100, 101, 102, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, @@ -4910,39 +5024,18 @@ static const yytype_int16 yycheck[] = 80, 81, -1, -1, -1, -1, 86, 87, 88, 89, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 100, 101, 102, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 44, -1, -1, -1, - -1, -1, -1, -1, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, -1, 135, 136, -1, -1, -1, - -1, -1, -1, 143, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, -1, -1, -1, -1, - 88, 89, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 101, -1, -1, -1, -1, 44, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 122, -1, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, -1, -1, - -1, -1, 88, 89, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 101, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 122, -1, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - -1, -1, -1, -1, 88, 89, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 101, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 122, -1, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, -1, -1, 148, -1, 88, 89, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 122, -1, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, -1, -1, -1, -1, -1, -1, -1, -1, - 142, 72, 73, 74, 75, 76, 77, 78, 79, 80, + -1, -1, -1, -1, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, -1, 135, 136, 51, 52, -1, + -1, 55, -1, 143, 144, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 70, 71, 72, 73, + 74, 75, 76, 77, -1, -1, 80, 81, -1, -1, + -1, -1, 86, 87, 88, 89, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 100, 101, 102, -1, + -1, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, -1, -1, -1, -1, 88, 89, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 101, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 101, 135, 136, -1, -1, -1, -1, -1, -1, 143, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 122, -1, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, -1, -1, -1, -1, -1, -1, -1, @@ -4955,37 +5048,25 @@ static const yytype_int16 yycheck[] = 130, 131, 132, 133, -1, -1, -1, -1, -1, -1, -1, -1, 142, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, -1, -1, -1, -1, 88, - 89, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 89, -1, -1, -1, 93, -1, -1, -1, -1, -1, -1, -1, 101, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 122, -1, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, -1, -1, -1, -1, -1, - -1, -1, -1, 142, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, -1, -1, -1, -1, - 88, 89, -1, -1, -1, 93, -1, -1, -1, -1, - -1, -1, -1, 101, -1, -1, -1, -1, -1, -1, + 129, 130, 131, 132, 133, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, -1, -1, -1, + -1, 88, 89, -1, -1, -1, 93, -1, -1, -1, + -1, -1, -1, -1, 101, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 122, -1, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, -1, -1, - -1, -1, 88, 89, -1, -1, -1, 93, -1, -1, - -1, -1, -1, -1, -1, 101, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 122, -1, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - -1, -1, -1, -1, 88, 89, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 101, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 122, -1, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, -1, -1, -1, -1, 88, 89, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133 + -1, -1, -1, -1, -1, 122, -1, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, -1, + -1, -1, -1, 88, 89, 72, 73, 74, 75, 76, + 77, -1, -1, 80, 81, -1, 101, -1, -1, -1, + -1, 88, 89, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 101, -1, -1, 122, -1, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, -1, + -1, -1, -1, -1, -1, -1, -1, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing @@ -5002,9 +5083,9 @@ static const yytype_int16 yystos[] = 154, 159, 161, 163, 164, 165, 168, 169, 172, 173, 175, 176, 177, 179, 180, 189, 203, 220, 241, 242, 252, 253, 254, 258, 259, 260, 266, 267, 268, 270, - 271, 272, 273, 274, 275, 312, 325, 154, 21, 22, + 271, 272, 273, 274, 275, 311, 324, 154, 21, 22, 30, 31, 32, 39, 51, 55, 69, 88, 91, 94, - 134, 164, 165, 181, 182, 203, 220, 272, 275, 312, + 134, 164, 165, 181, 182, 203, 220, 272, 275, 311, 182, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 30, 31, 32, 33, 34, @@ -5013,92 +5094,93 @@ static const yytype_int16 yystos[] = 76, 77, 80, 81, 86, 87, 88, 89, 100, 101, 102, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 135, 136, 143, 144, 183, 187, 188, 274, 306, - 204, 91, 163, 167, 180, 189, 220, 272, 273, 275, - 167, 210, 212, 69, 91, 173, 180, 220, 225, 272, - 275, 33, 34, 35, 36, 48, 49, 50, 51, 55, - 106, 183, 184, 185, 268, 115, 118, 119, 146, 148, - 167, 262, 263, 264, 318, 322, 323, 324, 51, 100, - 102, 103, 135, 172, 189, 195, 198, 201, 254, 309, - 311, 195, 195, 144, 192, 193, 196, 197, 325, 192, - 196, 144, 319, 323, 184, 155, 138, 189, 220, 189, - 189, 189, 55, 1, 94, 157, 158, 159, 174, 175, - 325, 205, 207, 190, 201, 309, 325, 189, 308, 309, - 325, 91, 142, 179, 220, 272, 275, 208, 53, 54, - 56, 63, 107, 183, 269, 63, 64, 65, 116, 117, - 255, 256, 61, 255, 62, 255, 63, 255, 63, 255, - 58, 59, 168, 189, 189, 318, 324, 40, 41, 42, - 43, 44, 37, 38, 51, 53, 54, 55, 56, 69, - 94, 100, 101, 102, 103, 128, 131, 144, 278, 279, - 280, 281, 282, 285, 286, 287, 288, 290, 291, 292, - 293, 295, 296, 297, 300, 301, 302, 303, 304, 325, - 279, 280, 28, 239, 121, 142, 94, 100, 176, 121, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 88, 89, 93, 101, 122, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 90, 105, 140, - 147, 316, 90, 316, 317, 26, 138, 243, 254, 92, - 92, 192, 196, 243, 163, 51, 55, 181, 58, 59, - 279, 125, 276, 90, 140, 316, 219, 307, 90, 147, - 315, 156, 157, 55, 16, 221, 322, 121, 90, 140, - 316, 92, 92, 221, 167, 167, 55, 90, 140, 316, - 25, 107, 142, 265, 318, 115, 264, 20, 246, 322, - 57, 310, 189, 189, 189, 93, 142, 199, 200, 325, - 310, 199, 200, 85, 194, 195, 201, 309, 325, 195, - 163, 318, 320, 163, 160, 138, 157, 90, 316, 92, - 159, 174, 145, 318, 324, 320, 159, 320, 141, 200, - 321, 324, 200, 321, 139, 321, 55, 176, 177, 178, - 142, 90, 140, 316, 144, 237, 290, 63, 255, 257, - 261, 262, 63, 256, 61, 62, 63, 63, 101, 101, - 154, 167, 167, 167, 167, 159, 163, 163, 57, 121, - 294, 85, 290, 295, 121, 156, 189, 142, 305, 325, - 51, 142, 305, 322, 142, 289, 189, 142, 289, 51, - 142, 289, 51, 121, 156, 240, 100, 168, 189, 201, - 202, 174, 142, 179, 142, 161, 162, 168, 180, 189, - 191, 202, 220, 275, 189, 189, 189, 189, 189, 189, - 189, 189, 189, 189, 189, 189, 189, 189, 51, 189, + 204, 91, 163, 164, 165, 167, 180, 189, 220, 272, + 273, 275, 167, 210, 212, 69, 91, 173, 180, 220, + 225, 272, 275, 33, 34, 35, 36, 48, 49, 50, + 51, 55, 106, 183, 184, 185, 268, 115, 118, 119, + 146, 148, 167, 262, 263, 264, 317, 321, 322, 323, + 51, 100, 102, 103, 135, 172, 189, 195, 198, 201, + 254, 309, 310, 195, 195, 144, 192, 193, 196, 197, + 324, 192, 196, 144, 318, 184, 155, 138, 189, 220, + 189, 189, 189, 55, 1, 94, 157, 158, 159, 174, + 175, 324, 205, 207, 190, 201, 309, 324, 189, 308, + 309, 324, 91, 142, 179, 220, 272, 275, 208, 53, + 54, 56, 63, 107, 183, 269, 63, 64, 65, 116, + 117, 255, 256, 61, 255, 62, 255, 63, 255, 63, + 255, 58, 59, 168, 189, 189, 317, 323, 40, 41, + 42, 43, 44, 37, 38, 51, 53, 54, 55, 56, + 69, 94, 100, 101, 102, 103, 128, 131, 144, 278, + 279, 280, 281, 282, 285, 286, 287, 288, 290, 291, + 292, 293, 295, 296, 297, 300, 301, 302, 303, 304, + 324, 278, 280, 28, 239, 121, 142, 94, 100, 176, + 121, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 88, 89, 93, 101, 122, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 90, 105, + 140, 147, 315, 90, 315, 316, 26, 138, 243, 254, + 92, 92, 192, 196, 243, 163, 51, 55, 181, 58, + 59, 279, 125, 276, 90, 140, 315, 219, 307, 90, + 147, 314, 156, 157, 55, 278, 278, 16, 221, 321, + 121, 90, 140, 315, 92, 92, 221, 167, 167, 55, + 90, 140, 315, 25, 107, 142, 265, 317, 115, 264, + 20, 246, 321, 57, 189, 189, 189, 93, 142, 199, + 200, 324, 57, 199, 200, 85, 194, 195, 201, 309, + 324, 195, 163, 317, 319, 163, 322, 160, 138, 157, + 90, 315, 92, 159, 174, 145, 317, 323, 319, 159, + 319, 141, 200, 320, 323, 200, 320, 139, 320, 55, + 176, 177, 178, 142, 90, 140, 315, 144, 237, 290, + 63, 255, 257, 261, 262, 63, 256, 61, 62, 63, + 63, 101, 101, 154, 167, 167, 167, 167, 159, 163, + 163, 57, 121, 294, 85, 290, 295, 121, 156, 189, + 142, 305, 324, 51, 142, 305, 321, 142, 289, 189, + 142, 289, 51, 142, 289, 51, 121, 156, 240, 100, + 168, 189, 201, 202, 174, 142, 179, 142, 161, 162, + 168, 180, 189, 191, 202, 220, 275, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, - 189, 51, 52, 55, 187, 192, 313, 314, 194, 201, - 51, 52, 55, 187, 192, 313, 51, 55, 313, 245, - 244, 162, 189, 191, 162, 191, 99, 170, 217, 277, - 216, 51, 55, 181, 313, 194, 313, 156, 163, 166, - 15, 13, 248, 325, 157, 16, 51, 55, 194, 51, - 55, 157, 27, 222, 322, 222, 51, 55, 194, 51, - 55, 214, 186, 157, 246, 189, 201, 15, 261, 189, - 189, 319, 100, 189, 198, 309, 189, 311, 320, 145, - 318, 200, 200, 320, 145, 184, 152, 139, 191, 320, - 159, 206, 309, 176, 178, 51, 55, 194, 51, 55, - 290, 209, 63, 157, 262, 189, 189, 51, 100, 226, - 295, 320, 320, 142, 189, 15, 51, 282, 287, 304, - 288, 293, 300, 302, 295, 297, 302, 51, 295, 189, - 15, 79, 126, 231, 232, 325, 189, 200, 320, 178, - 142, 44, 121, 44, 90, 140, 316, 319, 92, 92, - 192, 196, 141, 200, 92, 92, 193, 196, 193, 196, - 231, 231, 171, 322, 167, 156, 141, 15, 320, 183, - 189, 202, 249, 325, 18, 224, 325, 17, 223, 224, - 92, 92, 141, 92, 92, 224, 211, 213, 141, 167, - 184, 139, 15, 200, 221, 261, 189, 199, 85, 309, - 139, 320, 321, 141, 234, 319, 29, 113, 238, 139, - 142, 292, 320, 142, 85, 44, 305, 142, 289, 142, - 289, 142, 289, 142, 289, 289, 44, 228, 230, 233, - 281, 283, 284, 287, 295, 296, 298, 299, 302, 304, - 156, 100, 189, 178, 159, 189, 51, 55, 194, 51, - 55, 57, 123, 162, 191, 168, 191, 170, 92, 162, - 191, 162, 191, 170, 243, 239, 156, 157, 231, 218, - 322, 15, 93, 250, 325, 157, 14, 251, 325, 167, - 15, 92, 15, 157, 157, 222, 189, 157, 320, 200, - 145, 146, 156, 157, 227, 142, 100, 320, 189, 295, - 302, 295, 295, 189, 234, 234, 91, 220, 142, 305, - 305, 142, 229, 220, 142, 229, 142, 229, 15, 189, - 141, 189, 189, 162, 191, 15, 139, 157, 156, 91, - 180, 220, 272, 275, 221, 157, 221, 15, 15, 215, - 224, 246, 247, 51, 235, 236, 291, 15, 139, 295, - 295, 142, 292, 289, 142, 289, 289, 289, 126, 126, - 55, 90, 283, 287, 142, 228, 229, 299, 302, 295, - 298, 302, 295, 139, 15, 55, 90, 140, 316, 157, - 157, 157, 142, 319, 142, 295, 142, 295, 51, 55, - 305, 142, 229, 142, 229, 142, 229, 142, 229, 229, - 51, 55, 194, 51, 55, 248, 223, 15, 236, 295, - 289, 295, 302, 295, 295, 141, 229, 142, 229, 229, - 229, 295, 229 + 189, 51, 189, 189, 189, 189, 189, 189, 189, 189, + 189, 189, 189, 189, 51, 52, 55, 187, 192, 312, + 313, 194, 201, 51, 52, 55, 187, 192, 312, 51, + 55, 312, 245, 244, 162, 189, 191, 162, 191, 99, + 170, 217, 277, 216, 51, 55, 181, 312, 194, 312, + 156, 163, 166, 15, 13, 248, 324, 121, 121, 157, + 16, 51, 55, 194, 51, 55, 157, 27, 222, 321, + 222, 51, 55, 194, 51, 55, 214, 186, 157, 246, + 189, 201, 15, 189, 189, 318, 100, 189, 198, 309, + 189, 310, 319, 145, 317, 200, 200, 319, 145, 184, + 152, 139, 191, 319, 159, 206, 309, 176, 178, 51, + 55, 194, 51, 55, 290, 209, 63, 157, 262, 189, + 189, 51, 100, 226, 295, 319, 319, 142, 172, 189, + 15, 51, 282, 287, 304, 288, 293, 300, 302, 295, + 297, 302, 51, 295, 172, 189, 15, 79, 126, 231, + 232, 324, 189, 200, 319, 178, 142, 44, 121, 44, + 90, 140, 315, 318, 92, 92, 192, 196, 141, 200, + 92, 92, 193, 196, 193, 196, 231, 231, 171, 321, + 167, 156, 141, 15, 319, 183, 189, 202, 249, 324, + 18, 224, 324, 17, 223, 224, 92, 92, 141, 92, + 92, 224, 211, 213, 141, 167, 184, 139, 15, 200, + 221, 189, 199, 85, 309, 139, 319, 320, 141, 234, + 318, 29, 113, 238, 139, 142, 292, 319, 142, 85, + 44, 44, 305, 142, 289, 142, 289, 142, 289, 142, + 289, 289, 44, 44, 228, 230, 233, 281, 283, 284, + 287, 295, 296, 298, 299, 302, 304, 156, 100, 189, + 178, 159, 189, 51, 55, 194, 51, 55, 57, 123, + 162, 191, 168, 191, 170, 92, 162, 191, 162, 191, + 170, 243, 239, 156, 157, 231, 218, 321, 15, 93, + 250, 324, 157, 14, 251, 324, 167, 15, 92, 15, + 157, 157, 222, 189, 157, 319, 200, 145, 146, 156, + 157, 227, 142, 100, 319, 189, 189, 295, 302, 295, + 295, 189, 189, 234, 234, 91, 220, 142, 305, 305, + 142, 229, 220, 142, 229, 142, 229, 15, 189, 141, + 189, 189, 162, 191, 15, 139, 157, 156, 91, 180, + 220, 272, 275, 221, 157, 221, 15, 15, 215, 224, + 246, 247, 51, 235, 236, 291, 15, 139, 295, 295, + 142, 292, 289, 142, 289, 289, 289, 126, 126, 55, + 90, 283, 287, 142, 228, 229, 299, 302, 295, 298, + 302, 295, 139, 15, 55, 90, 140, 315, 157, 157, + 157, 142, 318, 142, 295, 142, 295, 51, 55, 305, + 142, 229, 142, 229, 142, 229, 142, 229, 229, 51, + 55, 194, 51, 55, 248, 223, 15, 236, 295, 289, + 295, 302, 295, 295, 141, 229, 142, 229, 229, 229, + 295, 229 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ @@ -5108,63 +5190,63 @@ static const yytype_int16 yyr1[] = 155, 154, 156, 157, 158, 158, 158, 158, 160, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 161, 161, 161, 161, 161, 161, - 161, 161, 162, 162, 162, 163, 163, 163, 163, 163, - 163, 164, 166, 165, 167, 168, 168, 169, 169, 171, - 170, 172, 172, 172, 172, 172, 172, 172, 172, 172, - 172, 172, 173, 173, 174, 174, 175, 175, 175, 175, - 175, 175, 175, 175, 175, 175, 176, 176, 177, 177, - 178, 178, 179, 179, 179, 179, 179, 179, 179, 179, - 180, 180, 180, 180, 180, 180, 180, 180, 180, 181, - 181, 182, 182, 182, 183, 183, 183, 183, 183, 184, - 184, 185, 186, 185, 187, 187, 187, 187, 187, 187, + 161, 161, 161, 161, 161, 161, 162, 162, 162, 163, + 163, 163, 163, 163, 163, 164, 166, 165, 167, 168, + 168, 169, 169, 171, 170, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 173, 173, 174, 174, + 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, + 176, 176, 177, 177, 178, 178, 179, 179, 179, 179, + 179, 179, 179, 179, 180, 180, 180, 180, 180, 180, + 180, 180, 180, 181, 181, 182, 182, 182, 183, 183, + 183, 183, 183, 184, 184, 185, 186, 185, 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, + 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, 189, 189, 189, 189, 189, 189, + 188, 188, 188, 188, 188, 188, 188, 188, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, - 189, 189, 189, 189, 189, 190, 190, 190, 190, 191, - 191, 192, 192, 192, 193, 193, 194, 194, 194, 194, - 194, 195, 195, 195, 195, 195, 197, 196, 198, 199, - 199, 200, 200, 201, 201, 201, 201, 202, 202, 202, - 203, 203, 203, 203, 203, 203, 203, 203, 203, 204, - 203, 205, 206, 203, 207, 203, 203, 203, 203, 203, - 203, 203, 203, 203, 203, 203, 203, 203, 208, 209, - 203, 203, 203, 210, 211, 203, 212, 213, 203, 203, - 203, 214, 215, 203, 216, 203, 217, 218, 203, 219, - 203, 203, 203, 203, 203, 203, 203, 220, 221, 221, - 221, 222, 222, 223, 223, 224, 224, 225, 225, 226, - 226, 226, 226, 226, 226, 226, 226, 227, 226, 228, - 228, 228, 228, 229, 229, 230, 230, 230, 230, 230, + 189, 189, 189, 189, 189, 189, 189, 189, 189, 190, + 190, 190, 190, 191, 191, 192, 192, 192, 193, 193, + 194, 194, 194, 194, 194, 195, 195, 195, 195, 195, + 197, 196, 198, 199, 199, 200, 201, 201, 201, 201, + 202, 202, 202, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 204, 203, 205, 206, 203, 207, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 208, 209, 203, 203, 203, 210, 211, 203, 212, + 213, 203, 203, 203, 214, 215, 203, 216, 203, 217, + 218, 203, 219, 203, 203, 203, 203, 203, 203, 203, + 220, 221, 221, 221, 222, 222, 223, 223, 224, 224, + 225, 225, 226, 226, 226, 226, 226, 226, 226, 226, + 227, 226, 228, 228, 228, 228, 229, 229, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, - 231, 231, 233, 232, 232, 232, 234, 234, 235, 235, - 236, 236, 237, 237, 238, 238, 240, 239, 241, 241, - 241, 241, 242, 242, 242, 242, 242, 242, 242, 242, - 242, 244, 243, 245, 243, 246, 247, 247, 248, 248, - 249, 249, 249, 250, 250, 251, 251, 252, 252, 252, - 252, 253, 253, 254, 254, 254, 254, 255, 255, 256, - 257, 256, 256, 256, 258, 258, 259, 259, 260, 261, - 261, 262, 262, 263, 263, 264, 265, 264, 266, 266, - 267, 267, 268, 269, 269, 269, 269, 269, 269, 270, - 270, 271, 271, 271, 271, 272, 272, 272, 272, 272, - 273, 273, 274, 274, 274, 274, 274, 274, 274, 274, - 275, 275, 276, 277, 276, 278, 278, 279, 279, 279, - 280, 280, 281, 282, 282, 283, 283, 284, 284, 285, - 285, 286, 286, 287, 287, 288, 288, 288, 288, 289, - 289, 290, 290, 290, 290, 290, 290, 290, 290, 290, - 290, 290, 290, 290, 290, 290, 291, 291, 291, 291, - 291, 292, 292, 293, 294, 293, 295, 295, 296, 297, - 298, 299, 299, 300, 300, 301, 301, 302, 302, 303, - 303, 304, 305, 305, 306, 307, 306, 308, 308, 309, - 309, 310, 310, 311, 311, 311, 311, 312, 312, 312, - 313, 313, 313, 313, 314, 314, 314, 315, 315, 316, - 316, 317, 317, 318, 318, 319, 319, 320, 321, 321, - 321, 322, 322, 322, 323, 324, 324, 325 + 230, 230, 230, 231, 231, 233, 232, 232, 232, 234, + 234, 235, 235, 236, 236, 237, 237, 238, 238, 240, + 239, 241, 241, 241, 241, 242, 242, 242, 242, 242, + 242, 242, 242, 242, 244, 243, 245, 243, 246, 247, + 247, 248, 248, 249, 249, 249, 250, 250, 251, 251, + 252, 252, 252, 252, 253, 253, 254, 254, 254, 254, + 255, 255, 256, 257, 256, 256, 256, 258, 258, 259, + 259, 260, 261, 261, 262, 262, 263, 263, 264, 265, + 264, 266, 266, 267, 267, 268, 269, 269, 269, 269, + 269, 269, 270, 270, 271, 271, 271, 271, 272, 272, + 272, 272, 272, 273, 273, 274, 274, 274, 274, 274, + 274, 274, 274, 275, 275, 276, 277, 276, 278, 278, + 279, 279, 279, 280, 280, 281, 282, 282, 283, 283, + 284, 284, 285, 285, 286, 286, 287, 287, 288, 288, + 288, 288, 289, 289, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 291, + 291, 291, 291, 291, 292, 292, 293, 294, 293, 295, + 295, 296, 297, 298, 299, 299, 300, 300, 301, 301, + 302, 302, 303, 303, 304, 305, 305, 306, 307, 306, + 308, 308, 309, 309, 310, 310, 310, 310, 310, 311, + 311, 311, 312, 312, 312, 312, 313, 313, 313, 314, + 314, 315, 315, 316, 316, 317, 317, 318, 318, 319, + 320, 320, 320, 321, 321, 322, 322, 323, 323, 324 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ @@ -5174,63 +5256,63 @@ static const yytype_int8 yyr2[] = 0, 5, 4, 2, 1, 1, 3, 2, 0, 4, 2, 3, 3, 3, 3, 3, 4, 1, 3, 3, 3, 3, 3, 1, 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, + 5, 4, 6, 4, 6, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 3, 3, 6, 5, 5, 5, - 5, 4, 3, 3, 2, 2, 3, 2, 2, 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, 5, 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, 3, 3, + 6, 5, 5, 5, 5, 4, 3, 3, 2, 2, + 3, 2, 2, 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, 5, 3, 1, 1, + 1, 2, 2, 4, 2, 1, 2, 2, 4, 1, + 0, 2, 2, 2, 1, 2, 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, 0, 0, 4, 1, 1, 3, 5, 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, 0, 0, 4, 1, 1, + 3, 5, 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, 3, 3, 2, 3, 2, 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, 1, 1, 1, 1, 0, 1, 0, 2, 2, + 0, 1, 1, 1, 1, 1, 1, 1, 2, 0 }; @@ -5932,93 +6014,93 @@ yyreduce: switch (yyn) { case 2: -#line 1565 "mrbgems/mruby-compiler/core/parse.y" +#line 1582 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_BEG; if (!p->locals) p->locals = cons(0,0); } -#line 5941 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6023 "mrbgems/mruby-compiler/core/y.tab.c" break; case 3: -#line 1570 "mrbgems/mruby-compiler/core/parse.y" +#line 1587 "mrbgems/mruby-compiler/core/parse.y" { p->tree = new_scope(p, (yyvsp[0].nd)); NODE_LINENO(p->tree, (yyvsp[0].nd)); } -#line 5950 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6032 "mrbgems/mruby-compiler/core/y.tab.c" break; case 4: -#line 1577 "mrbgems/mruby-compiler/core/parse.y" +#line 1594 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 5958 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6040 "mrbgems/mruby-compiler/core/y.tab.c" break; case 5: -#line 1583 "mrbgems/mruby-compiler/core/parse.y" +#line 1600 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, 0); } -#line 5966 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6048 "mrbgems/mruby-compiler/core/y.tab.c" break; case 6: -#line 1587 "mrbgems/mruby-compiler/core/parse.y" +#line 1604 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 5975 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6057 "mrbgems/mruby-compiler/core/y.tab.c" break; case 7: -#line 1592 "mrbgems/mruby-compiler/core/parse.y" +#line 1609 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd))); } -#line 5983 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6065 "mrbgems/mruby-compiler/core/y.tab.c" break; case 8: -#line 1596 "mrbgems/mruby-compiler/core/parse.y" +#line 1613 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, 0); } -#line 5991 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6073 "mrbgems/mruby-compiler/core/y.tab.c" break; case 10: -#line 1603 "mrbgems/mruby-compiler/core/parse.y" +#line 1620 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = local_switch(p); nvars_block(p); } -#line 6000 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6082 "mrbgems/mruby-compiler/core/y.tab.c" break; case 11: -#line 1608 "mrbgems/mruby-compiler/core/parse.y" +#line 1625 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "BEGIN not supported"); local_resume(p, (yyvsp[-3].nd)); nvars_unnest(p); (yyval.nd) = 0; } -#line 6011 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6093 "mrbgems/mruby-compiler/core/y.tab.c" break; case 12: -#line 1620 "mrbgems/mruby-compiler/core/parse.y" +#line 1637 "mrbgems/mruby-compiler/core/parse.y" { if ((yyvsp[-2].nd)) { (yyval.nd) = new_rescue(p, (yyvsp[-3].nd), (yyvsp[-2].nd), (yyvsp[-1].nd)); NODE_LINENO((yyval.nd), (yyvsp[-3].nd)); } else if ((yyvsp[-1].nd)) { - yywarn(p, "else without rescue is useless"); + yywarning(p, "else without rescue is useless"); (yyval.nd) = push((yyvsp[-3].nd), (yyvsp[-1].nd)); } else { @@ -6033,291 +6115,345 @@ yyreduce: } } } -#line 6037 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6119 "mrbgems/mruby-compiler/core/y.tab.c" break; case 13: -#line 1644 "mrbgems/mruby-compiler/core/parse.y" +#line 1661 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 6045 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6127 "mrbgems/mruby-compiler/core/y.tab.c" break; case 14: -#line 1650 "mrbgems/mruby-compiler/core/parse.y" +#line 1667 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, 0); } -#line 6053 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6135 "mrbgems/mruby-compiler/core/y.tab.c" break; case 15: -#line 1654 "mrbgems/mruby-compiler/core/parse.y" +#line 1671 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 6062 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6144 "mrbgems/mruby-compiler/core/y.tab.c" break; case 16: -#line 1659 "mrbgems/mruby-compiler/core/parse.y" +#line 1676 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd))); } -#line 6070 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6152 "mrbgems/mruby-compiler/core/y.tab.c" break; case 17: -#line 1663 "mrbgems/mruby-compiler/core/parse.y" +#line 1680 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_begin(p, (yyvsp[0].nd)); } -#line 6078 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6160 "mrbgems/mruby-compiler/core/y.tab.c" break; case 18: -#line 1668 "mrbgems/mruby-compiler/core/parse.y" +#line 1685 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_FNAME;} -#line 6084 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6166 "mrbgems/mruby-compiler/core/y.tab.c" break; case 19: -#line 1669 "mrbgems/mruby-compiler/core/parse.y" +#line 1686 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_alias(p, (yyvsp[-2].id), (yyvsp[0].id)); } -#line 6092 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6174 "mrbgems/mruby-compiler/core/y.tab.c" break; case 20: -#line 1673 "mrbgems/mruby-compiler/core/parse.y" +#line 1690 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 6100 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6182 "mrbgems/mruby-compiler/core/y.tab.c" break; case 21: -#line 1677 "mrbgems/mruby-compiler/core/parse.y" +#line 1694 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_if(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0); } -#line 6108 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6190 "mrbgems/mruby-compiler/core/y.tab.c" break; case 22: -#line 1681 "mrbgems/mruby-compiler/core/parse.y" +#line 1698 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_unless(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0); } -#line 6116 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6198 "mrbgems/mruby-compiler/core/y.tab.c" break; case 23: -#line 1685 "mrbgems/mruby-compiler/core/parse.y" +#line 1702 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_while(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd)); } -#line 6124 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6206 "mrbgems/mruby-compiler/core/y.tab.c" break; case 24: -#line 1689 "mrbgems/mruby-compiler/core/parse.y" +#line 1706 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_until(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd)); } -#line 6132 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6214 "mrbgems/mruby-compiler/core/y.tab.c" break; case 25: -#line 1693 "mrbgems/mruby-compiler/core/parse.y" +#line 1710 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6140 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6222 "mrbgems/mruby-compiler/core/y.tab.c" break; case 26: -#line 1697 "mrbgems/mruby-compiler/core/parse.y" +#line 1714 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "END not supported"); (yyval.nd) = new_postexe(p, (yyvsp[-1].nd)); } -#line 6149 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6231 "mrbgems/mruby-compiler/core/y.tab.c" break; case 28: -#line 1703 "mrbgems/mruby-compiler/core/parse.y" +#line 1720 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6157 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6239 "mrbgems/mruby-compiler/core/y.tab.c" break; case 29: -#line 1707 "mrbgems/mruby-compiler/core/parse.y" +#line 1724 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd))); } -#line 6165 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6247 "mrbgems/mruby-compiler/core/y.tab.c" break; case 30: -#line 1711 "mrbgems/mruby-compiler/core/parse.y" +#line 1728 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6173 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6255 "mrbgems/mruby-compiler/core/y.tab.c" break; case 31: -#line 1715 "mrbgems/mruby-compiler/core/parse.y" +#line 1732 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd))); } -#line 6181 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6263 "mrbgems/mruby-compiler/core/y.tab.c" break; case 32: -#line 1719 "mrbgems/mruby-compiler/core/parse.y" +#line 1736 "mrbgems/mruby-compiler/core/parse.y" { node *lhs = new_lvar(p, (yyvsp[0].id)); void_expr_error(p, (yyvsp[-2].nd)); assignable(p, lhs); (yyval.nd) = new_asgn(p, lhs, (yyvsp[-2].nd)); } -#line 6192 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6274 "mrbgems/mruby-compiler/core/y.tab.c" break; case 34: -#line 1729 "mrbgems/mruby-compiler/core/parse.y" +#line 1746 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6200 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6282 "mrbgems/mruby-compiler/core/y.tab.c" break; case 35: -#line 1733 "mrbgems/mruby-compiler/core/parse.y" +#line 1750 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 6208 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6290 "mrbgems/mruby-compiler/core/y.tab.c" break; case 36: -#line 1737 "mrbgems/mruby-compiler/core/parse.y" +#line 1754 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_op(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 6216 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6298 "mrbgems/mruby-compiler/core/y.tab.c" break; case 37: -#line 1741 "mrbgems/mruby-compiler/core/parse.y" +#line 1758 "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 6224 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6306 "mrbgems/mruby-compiler/core/y.tab.c" break; case 38: -#line 1745 "mrbgems/mruby-compiler/core/parse.y" +#line 1762 "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 6232 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6314 "mrbgems/mruby-compiler/core/y.tab.c" break; case 39: -#line 1749 "mrbgems/mruby-compiler/core/parse.y" +#line 1766 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "constant re-assignment"); (yyval.nd) = 0; } -#line 6241 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6323 "mrbgems/mruby-compiler/core/y.tab.c" break; case 40: -#line 1754 "mrbgems/mruby-compiler/core/parse.y" +#line 1771 "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 6249 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6331 "mrbgems/mruby-compiler/core/y.tab.c" break; case 41: -#line 1758 "mrbgems/mruby-compiler/core/parse.y" +#line 1775 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = (yyvsp[-3].nd); + endless_method_name(p, (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 6344 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 42: +#line 1784 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = (yyvsp[-5].nd); + endless_method_name(p, (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 6358 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 43: +#line 1794 "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 6371 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 44: +#line 1803 "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 6385 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 45: +#line 1813 "mrbgems/mruby-compiler/core/parse.y" { backref_error(p, (yyvsp[-2].nd)); (yyval.nd) = new_begin(p, 0); } -#line 6258 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6394 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 43: -#line 1766 "mrbgems/mruby-compiler/core/parse.y" + case 47: +#line 1821 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6266 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6402 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 46: -#line 1775 "mrbgems/mruby-compiler/core/parse.y" + case 50: +#line 1830 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6274 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6410 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 47: -#line 1779 "mrbgems/mruby-compiler/core/parse.y" + case 51: +#line 1834 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6282 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6418 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 48: -#line 1783 "mrbgems/mruby-compiler/core/parse.y" + case 52: +#line 1838 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!"); } -#line 6290 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6426 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 49: -#line 1787 "mrbgems/mruby-compiler/core/parse.y" + case 53: +#line 1842 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!"); } -#line 6298 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6434 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 51: -#line 1795 "mrbgems/mruby-compiler/core/parse.y" + case 55: +#line 1850 "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 6309 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6445 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 52: -#line 1804 "mrbgems/mruby-compiler/core/parse.y" + case 56: +#line 1859 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_FNAME; } -#line 6317 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6453 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 53: -#line 1808 "mrbgems/mruby-compiler/core/parse.y" + case 57: +#line 1863 "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; @@ -6326,1054 +6462,1054 @@ yyreduce: nvars_block(p); p->lstate = EXPR_ENDFN; /* force for args */ } -#line 6330 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6466 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 54: -#line 1819 "mrbgems/mruby-compiler/core/parse.y" + case 58: +#line 1874 "mrbgems/mruby-compiler/core/parse.y" { if (!(yyvsp[0].nd)) (yyval.nd) = new_nil(p); else { (yyval.nd) = (yyvsp[0].nd); } } -#line 6341 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6477 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 58: -#line 1833 "mrbgems/mruby-compiler/core/parse.y" + case 62: +#line 1888 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 6349 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6485 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 59: -#line 1839 "mrbgems/mruby-compiler/core/parse.y" + case 63: +#line 1894 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); } -#line 6358 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6494 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 60: -#line 1846 "mrbgems/mruby-compiler/core/parse.y" + case 64: +#line 1901 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block(p, (yyvsp[-2].nd), (yyvsp[-1].nd)); local_unnest(p); nvars_unnest(p); } -#line 6368 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6504 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 61: -#line 1854 "mrbgems/mruby-compiler/core/parse.y" + case 65: +#line 1909 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 6376 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6512 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 62: -#line 1858 "mrbgems/mruby-compiler/core/parse.y" + case 66: +#line 1913 "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 6385 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6521 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 63: -#line 1863 "mrbgems/mruby-compiler/core/parse.y" + case 67: +#line 1918 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 6393 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6529 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 64: -#line 1867 "mrbgems/mruby-compiler/core/parse.y" + case 68: +#line 1922 "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 6402 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6538 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 65: -#line 1872 "mrbgems/mruby-compiler/core/parse.y" + case 69: +#line 1927 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2); } -#line 6410 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6546 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 66: -#line 1876 "mrbgems/mruby-compiler/core/parse.y" + case 70: +#line 1931 "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 6419 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6555 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 67: -#line 1881 "mrbgems/mruby-compiler/core/parse.y" + case 71: +#line 1936 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_super(p, (yyvsp[0].nd)); } -#line 6427 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6563 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 68: -#line 1885 "mrbgems/mruby-compiler/core/parse.y" + case 72: +#line 1940 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_yield(p, (yyvsp[0].nd)); } -#line 6435 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6571 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 69: -#line 1889 "mrbgems/mruby-compiler/core/parse.y" + case 73: +#line 1944 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_return(p, ret_args(p, (yyvsp[0].nd))); } -#line 6443 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6579 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 70: -#line 1893 "mrbgems/mruby-compiler/core/parse.y" + case 74: +#line 1948 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_break(p, ret_args(p, (yyvsp[0].nd))); } -#line 6451 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6587 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 71: -#line 1897 "mrbgems/mruby-compiler/core/parse.y" + case 75: +#line 1952 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_next(p, ret_args(p, (yyvsp[0].nd))); } -#line 6459 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6595 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 72: -#line 1903 "mrbgems/mruby-compiler/core/parse.y" + case 76: +#line 1958 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 6467 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6603 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 73: -#line 1907 "mrbgems/mruby-compiler/core/parse.y" + case 77: +#line 1962 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 6475 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6611 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 75: -#line 1914 "mrbgems/mruby-compiler/core/parse.y" + case 79: +#line 1969 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 6483 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6619 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 76: -#line 1920 "mrbgems/mruby-compiler/core/parse.y" + case 80: +#line 1975 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 6491 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6627 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 77: -#line 1924 "mrbgems/mruby-compiler/core/parse.y" + case 81: +#line 1979 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(push((yyvsp[-1].nd),(yyvsp[0].nd))); } -#line 6499 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6635 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 78: -#line 1928 "mrbgems/mruby-compiler/core/parse.y" + case 82: +#line 1983 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list2((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6507 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6643 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 79: -#line 1932 "mrbgems/mruby-compiler/core/parse.y" + case 83: +#line 1987 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-4].nd), (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6515 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6651 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 80: -#line 1936 "mrbgems/mruby-compiler/core/parse.y" + case 84: +#line 1991 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list2((yyvsp[-1].nd), new_nil(p)); } -#line 6523 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6659 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 81: -#line 1940 "mrbgems/mruby-compiler/core/parse.y" + case 85: +#line 1995 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-3].nd), new_nil(p), (yyvsp[0].nd)); } -#line 6531 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6667 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 82: -#line 1944 "mrbgems/mruby-compiler/core/parse.y" + case 86: +#line 1999 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list2(0, (yyvsp[0].nd)); } -#line 6539 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6675 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 83: -#line 1948 "mrbgems/mruby-compiler/core/parse.y" + case 87: +#line 2003 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 6547 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6683 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 84: -#line 1952 "mrbgems/mruby-compiler/core/parse.y" + case 88: +#line 2007 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list2(0, new_nil(p)); } -#line 6555 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6691 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 85: -#line 1956 "mrbgems/mruby-compiler/core/parse.y" + case 89: +#line 2011 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, new_nil(p), (yyvsp[0].nd)); } -#line 6563 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6699 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 87: -#line 1963 "mrbgems/mruby-compiler/core/parse.y" + case 91: +#line 2018 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_masgn(p, (yyvsp[-1].nd), NULL); } -#line 6571 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6707 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 88: -#line 1969 "mrbgems/mruby-compiler/core/parse.y" + case 92: +#line 2024 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[-1].nd)); } -#line 6579 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6715 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 89: -#line 1973 "mrbgems/mruby-compiler/core/parse.y" + case 93: +#line 2028 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[-1].nd)); } -#line 6587 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6723 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 90: -#line 1979 "mrbgems/mruby-compiler/core/parse.y" + case 94: +#line 2034 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 6595 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6731 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 91: -#line 1983 "mrbgems/mruby-compiler/core/parse.y" + case 95: +#line 2038 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 6603 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6739 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 92: -#line 1989 "mrbgems/mruby-compiler/core/parse.y" + case 96: +#line 2044 "mrbgems/mruby-compiler/core/parse.y" { assignable(p, (yyvsp[0].nd)); } -#line 6611 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6747 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 93: -#line 1993 "mrbgems/mruby-compiler/core/parse.y" + case 97: +#line 2048 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.'); } -#line 6619 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6755 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 94: -#line 1997 "mrbgems/mruby-compiler/core/parse.y" + case 98: +#line 2052 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num)); } -#line 6627 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6763 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 95: -#line 2001 "mrbgems/mruby-compiler/core/parse.y" + case 99: +#line 2056 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2); } -#line 6635 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6771 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 96: -#line 2005 "mrbgems/mruby-compiler/core/parse.y" + case 100: +#line 2060 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num)); } -#line 6643 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6779 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 97: -#line 2009 "mrbgems/mruby-compiler/core/parse.y" + case 101: +#line 2064 "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 6653 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6789 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 98: -#line 2015 "mrbgems/mruby-compiler/core/parse.y" + case 102: +#line 2070 "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 6663 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6799 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 99: -#line 2021 "mrbgems/mruby-compiler/core/parse.y" + case 103: +#line 2076 "mrbgems/mruby-compiler/core/parse.y" { backref_error(p, (yyvsp[0].nd)); (yyval.nd) = 0; } -#line 6672 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6808 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 100: -#line 2028 "mrbgems/mruby-compiler/core/parse.y" + case 104: +#line 2083 "mrbgems/mruby-compiler/core/parse.y" { assignable(p, (yyvsp[0].nd)); } -#line 6680 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6816 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 101: -#line 2032 "mrbgems/mruby-compiler/core/parse.y" + case 105: +#line 2087 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.'); } -#line 6688 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6824 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 102: -#line 2036 "mrbgems/mruby-compiler/core/parse.y" + case 106: +#line 2091 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num)); } -#line 6696 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6832 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 103: -#line 2040 "mrbgems/mruby-compiler/core/parse.y" + case 107: +#line 2095 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2); } -#line 6704 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6840 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 104: -#line 2044 "mrbgems/mruby-compiler/core/parse.y" + case 108: +#line 2099 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num)); } -#line 6712 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6848 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 105: -#line 2048 "mrbgems/mruby-compiler/core/parse.y" + case 109: +#line 2103 "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 6722 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6858 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 106: -#line 2054 "mrbgems/mruby-compiler/core/parse.y" + case 110: +#line 2109 "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 6732 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6868 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 107: -#line 2060 "mrbgems/mruby-compiler/core/parse.y" + case 111: +#line 2115 "mrbgems/mruby-compiler/core/parse.y" { backref_error(p, (yyvsp[0].nd)); (yyval.nd) = 0; } -#line 6741 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6877 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 108: -#line 2065 "mrbgems/mruby-compiler/core/parse.y" + case 112: +#line 2120 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "can't assign to numbered parameter"); } -#line 6749 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6885 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 109: -#line 2071 "mrbgems/mruby-compiler/core/parse.y" + case 113: +#line 2126 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "class/module name must be CONSTANT"); } -#line 6757 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6893 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 111: -#line 2078 "mrbgems/mruby-compiler/core/parse.y" + case 115: +#line 2133 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(nint(1), nsym((yyvsp[0].id))); } -#line 6765 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6901 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 112: -#line 2082 "mrbgems/mruby-compiler/core/parse.y" + case 116: +#line 2137 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(nint(0), nsym((yyvsp[0].id))); } -#line 6773 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6909 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 113: -#line 2086 "mrbgems/mruby-compiler/core/parse.y" + case 117: +#line 2141 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[-2].nd)); (yyval.nd) = cons((yyvsp[-2].nd), nsym((yyvsp[0].id))); } -#line 6782 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6918 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 117: -#line 2096 "mrbgems/mruby-compiler/core/parse.y" + case 121: +#line 2151 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_ENDFN; (yyval.id) = (yyvsp[0].id); } -#line 6791 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6927 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 118: -#line 2101 "mrbgems/mruby-compiler/core/parse.y" + case 122: +#line 2156 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_ENDFN; (yyval.id) = (yyvsp[0].id); } -#line 6800 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6936 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 121: -#line 2112 "mrbgems/mruby-compiler/core/parse.y" + case 125: +#line 2167 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_undef(p, (yyvsp[0].id)); } -#line 6808 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6944 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 122: -#line 2115 "mrbgems/mruby-compiler/core/parse.y" + case 126: +#line 2170 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_FNAME;} -#line 6814 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6950 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 123: -#line 2116 "mrbgems/mruby-compiler/core/parse.y" + case 127: +#line 2171 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-3].nd), nsym((yyvsp[0].id))); } -#line 6822 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6958 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 124: -#line 2121 "mrbgems/mruby-compiler/core/parse.y" + case 128: +#line 2176 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(or); } -#line 6828 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6964 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 125: -#line 2122 "mrbgems/mruby-compiler/core/parse.y" + case 129: +#line 2177 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(xor); } -#line 6834 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6970 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 126: -#line 2123 "mrbgems/mruby-compiler/core/parse.y" + case 130: +#line 2178 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(and); } -#line 6840 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6976 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 127: -#line 2124 "mrbgems/mruby-compiler/core/parse.y" + case 131: +#line 2179 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(cmp); } -#line 6846 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6982 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 128: -#line 2125 "mrbgems/mruby-compiler/core/parse.y" + case 132: +#line 2180 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(eq); } -#line 6852 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6988 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 129: -#line 2126 "mrbgems/mruby-compiler/core/parse.y" + case 133: +#line 2181 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(eqq); } -#line 6858 "mrbgems/mruby-compiler/core/y.tab.c" +#line 6994 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 130: -#line 2127 "mrbgems/mruby-compiler/core/parse.y" + case 134: +#line 2182 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(match); } -#line 6864 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7000 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 131: -#line 2128 "mrbgems/mruby-compiler/core/parse.y" + case 135: +#line 2183 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(nmatch); } -#line 6870 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7006 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 132: -#line 2129 "mrbgems/mruby-compiler/core/parse.y" + case 136: +#line 2184 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(gt); } -#line 6876 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7012 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 133: -#line 2130 "mrbgems/mruby-compiler/core/parse.y" + case 137: +#line 2185 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(ge); } -#line 6882 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7018 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 134: -#line 2131 "mrbgems/mruby-compiler/core/parse.y" + case 138: +#line 2186 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(lt); } -#line 6888 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7024 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 135: -#line 2132 "mrbgems/mruby-compiler/core/parse.y" + case 139: +#line 2187 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(le); } -#line 6894 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7030 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 136: -#line 2133 "mrbgems/mruby-compiler/core/parse.y" + case 140: +#line 2188 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(neq); } -#line 6900 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7036 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 137: -#line 2134 "mrbgems/mruby-compiler/core/parse.y" + case 141: +#line 2189 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(lshift); } -#line 6906 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7042 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 138: -#line 2135 "mrbgems/mruby-compiler/core/parse.y" + case 142: +#line 2190 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(rshift); } -#line 6912 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7048 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 139: -#line 2136 "mrbgems/mruby-compiler/core/parse.y" + case 143: +#line 2191 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(add); } -#line 6918 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7054 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 140: -#line 2137 "mrbgems/mruby-compiler/core/parse.y" + case 144: +#line 2192 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(sub); } -#line 6924 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7060 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 141: -#line 2138 "mrbgems/mruby-compiler/core/parse.y" + case 145: +#line 2193 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(mul); } -#line 6930 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7066 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 142: -#line 2139 "mrbgems/mruby-compiler/core/parse.y" + case 146: +#line 2194 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(mul); } -#line 6936 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7072 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 143: -#line 2140 "mrbgems/mruby-compiler/core/parse.y" + case 147: +#line 2195 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(div); } -#line 6942 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7078 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 144: -#line 2141 "mrbgems/mruby-compiler/core/parse.y" + case 148: +#line 2196 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(mod); } -#line 6948 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7084 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 145: -#line 2142 "mrbgems/mruby-compiler/core/parse.y" + case 149: +#line 2197 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(pow); } -#line 6954 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7090 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 146: -#line 2143 "mrbgems/mruby-compiler/core/parse.y" + case 150: +#line 2198 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(pow); } -#line 6960 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7096 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 147: -#line 2144 "mrbgems/mruby-compiler/core/parse.y" + case 151: +#line 2199 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(not); } -#line 6966 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7102 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 148: -#line 2145 "mrbgems/mruby-compiler/core/parse.y" + case 152: +#line 2200 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(neg); } -#line 6972 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7108 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 149: -#line 2146 "mrbgems/mruby-compiler/core/parse.y" + case 153: +#line 2201 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(plus); } -#line 6978 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7114 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 150: -#line 2147 "mrbgems/mruby-compiler/core/parse.y" + case 154: +#line 2202 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(minus); } -#line 6984 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7120 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 151: -#line 2148 "mrbgems/mruby-compiler/core/parse.y" + case 155: +#line 2203 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(aref); } -#line 6990 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7126 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 152: -#line 2149 "mrbgems/mruby-compiler/core/parse.y" + case 156: +#line 2204 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(aset); } -#line 6996 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7132 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 153: -#line 2150 "mrbgems/mruby-compiler/core/parse.y" + case 157: +#line 2205 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = intern_op(tick); } -#line 7002 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7138 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 194: -#line 2168 "mrbgems/mruby-compiler/core/parse.y" + case 198: +#line 2223 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7010 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7146 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 195: -#line 2172 "mrbgems/mruby-compiler/core/parse.y" + case 199: +#line 2227 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 7018 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7154 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 196: -#line 2176 "mrbgems/mruby-compiler/core/parse.y" + case 200: +#line 2231 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_op(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 7026 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7162 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 197: -#line 2180 "mrbgems/mruby-compiler/core/parse.y" + case 201: +#line 2235 "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 7034 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7170 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 198: -#line 2184 "mrbgems/mruby-compiler/core/parse.y" + case 202: +#line 2239 "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 7042 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7178 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 199: -#line 2188 "mrbgems/mruby-compiler/core/parse.y" + case 203: +#line 2243 "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 7050 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7186 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 200: -#line 2192 "mrbgems/mruby-compiler/core/parse.y" + case 204: +#line 2247 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "constant re-assignment"); (yyval.nd) = new_begin(p, 0); } -#line 7059 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7195 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 201: -#line 2197 "mrbgems/mruby-compiler/core/parse.y" + case 205: +#line 2252 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "constant re-assignment"); (yyval.nd) = new_begin(p, 0); } -#line 7068 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7204 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 202: -#line 2202 "mrbgems/mruby-compiler/core/parse.y" + case 206: +#line 2257 "mrbgems/mruby-compiler/core/parse.y" { backref_error(p, (yyvsp[-2].nd)); (yyval.nd) = new_begin(p, 0); } -#line 7077 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7213 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 203: -#line 2207 "mrbgems/mruby-compiler/core/parse.y" + case 207: +#line 2262 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot2(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7085 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7221 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 204: -#line 2211 "mrbgems/mruby-compiler/core/parse.y" + case 208: +#line 2266 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot2(p, (yyvsp[-1].nd), new_nil(p)); } -#line 7093 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7229 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 205: -#line 2215 "mrbgems/mruby-compiler/core/parse.y" + case 209: +#line 2270 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot2(p, new_nil(p), (yyvsp[0].nd)); } -#line 7101 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7237 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 206: -#line 2219 "mrbgems/mruby-compiler/core/parse.y" + case 210: +#line 2274 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot3(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7109 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7245 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 207: -#line 2223 "mrbgems/mruby-compiler/core/parse.y" + case 211: +#line 2278 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot3(p, (yyvsp[-1].nd), new_nil(p)); } -#line 7117 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7253 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 208: -#line 2227 "mrbgems/mruby-compiler/core/parse.y" + case 212: +#line 2282 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dot3(p, new_nil(p), (yyvsp[0].nd)); } -#line 7125 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7261 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 209: -#line 2231 "mrbgems/mruby-compiler/core/parse.y" + case 213: +#line 2286 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "+", (yyvsp[0].nd)); } -#line 7133 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7269 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 210: -#line 2235 "mrbgems/mruby-compiler/core/parse.y" + case 214: +#line 2290 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "-", (yyvsp[0].nd)); } -#line 7141 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7277 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 211: -#line 2239 "mrbgems/mruby-compiler/core/parse.y" + case 215: +#line 2294 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "*", (yyvsp[0].nd)); } -#line 7149 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7285 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 212: -#line 2243 "mrbgems/mruby-compiler/core/parse.y" + case 216: +#line 2298 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "/", (yyvsp[0].nd)); } -#line 7157 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7293 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 213: -#line 2247 "mrbgems/mruby-compiler/core/parse.y" + case 217: +#line 2302 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "%", (yyvsp[0].nd)); } -#line 7165 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7301 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 214: -#line 2251 "mrbgems/mruby-compiler/core/parse.y" + case 218: +#line 2306 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)); } -#line 7173 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7309 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 215: -#line 2255 "mrbgems/mruby-compiler/core/parse.y" + case 219: +#line 2310 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)), "-@"); + (yyval.nd) = new_negate(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd))); } -#line 7181 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7317 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 216: -#line 2259 "mrbgems/mruby-compiler/core/parse.y" + case 220: +#line 2314 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)), "-@"); + (yyval.nd) = new_negate(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd))); } -#line 7189 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7325 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 217: -#line 2263 "mrbgems/mruby-compiler/core/parse.y" + case 221: +#line 2318 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "+@"); } -#line 7197 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7333 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 218: -#line 2267 "mrbgems/mruby-compiler/core/parse.y" + case 222: +#line 2322 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "-@"); + (yyval.nd) = new_negate(p, (yyvsp[0].nd)); } -#line 7205 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7341 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 219: -#line 2271 "mrbgems/mruby-compiler/core/parse.y" + case 223: +#line 2326 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "|", (yyvsp[0].nd)); } -#line 7213 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7349 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 220: -#line 2275 "mrbgems/mruby-compiler/core/parse.y" + case 224: +#line 2330 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "^", (yyvsp[0].nd)); } -#line 7221 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7357 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 221: -#line 2279 "mrbgems/mruby-compiler/core/parse.y" + case 225: +#line 2334 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "&", (yyvsp[0].nd)); } -#line 7229 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7365 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 222: -#line 2283 "mrbgems/mruby-compiler/core/parse.y" + case 226: +#line 2338 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=>", (yyvsp[0].nd)); } -#line 7237 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7373 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 223: -#line 2287 "mrbgems/mruby-compiler/core/parse.y" + case 227: +#line 2342 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">", (yyvsp[0].nd)); } -#line 7245 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7381 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 224: -#line 2291 "mrbgems/mruby-compiler/core/parse.y" + case 228: +#line 2346 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">=", (yyvsp[0].nd)); } -#line 7253 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7389 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 225: -#line 2295 "mrbgems/mruby-compiler/core/parse.y" + case 229: +#line 2350 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<", (yyvsp[0].nd)); } -#line 7261 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7397 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 226: -#line 2299 "mrbgems/mruby-compiler/core/parse.y" + case 230: +#line 2354 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=", (yyvsp[0].nd)); } -#line 7269 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7405 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 227: -#line 2303 "mrbgems/mruby-compiler/core/parse.y" + case 231: +#line 2358 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "==", (yyvsp[0].nd)); } -#line 7277 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7413 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 228: -#line 2307 "mrbgems/mruby-compiler/core/parse.y" + case 232: +#line 2362 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "===", (yyvsp[0].nd)); } -#line 7285 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7421 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 229: -#line 2311 "mrbgems/mruby-compiler/core/parse.y" + case 233: +#line 2366 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!=", (yyvsp[0].nd)); } -#line 7293 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7429 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 230: -#line 2315 "mrbgems/mruby-compiler/core/parse.y" + case 234: +#line 2370 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "=~", (yyvsp[0].nd)); } -#line 7301 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7437 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 231: -#line 2319 "mrbgems/mruby-compiler/core/parse.y" + case 235: +#line 2374 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!~", (yyvsp[0].nd)); } -#line 7309 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7445 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 232: -#line 2323 "mrbgems/mruby-compiler/core/parse.y" + case 236: +#line 2378 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!"); } -#line 7317 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7453 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 233: -#line 2327 "mrbgems/mruby-compiler/core/parse.y" + case 237: +#line 2382 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "~"); } -#line 7325 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7461 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 234: -#line 2331 "mrbgems/mruby-compiler/core/parse.y" + case 238: +#line 2386 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<<", (yyvsp[0].nd)); } -#line 7333 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7469 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 235: -#line 2335 "mrbgems/mruby-compiler/core/parse.y" + case 239: +#line 2390 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">>", (yyvsp[0].nd)); } -#line 7341 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7477 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 236: -#line 2339 "mrbgems/mruby-compiler/core/parse.y" + case 240: +#line 2394 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7349 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7485 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 237: -#line 2343 "mrbgems/mruby-compiler/core/parse.y" + case 241: +#line 2398 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7357 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7493 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 238: -#line 2347 "mrbgems/mruby-compiler/core/parse.y" + case 242: +#line 2402 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd)); } -#line 7365 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7501 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 239: -#line 2351 "mrbgems/mruby-compiler/core/parse.y" + case 243: +#line 2406 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd)); } -#line 7373 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7509 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 240: -#line 2355 "mrbgems/mruby-compiler/core/parse.y" + case 244: +#line 2410 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); endless_method_name(p, (yyvsp[-3].nd)); @@ -7382,11 +7518,11 @@ yyreduce: nvars_unnest(p); p->in_def--; } -#line 7386 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7522 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 241: -#line 2364 "mrbgems/mruby-compiler/core/parse.y" + case 245: +#line 2419 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-5].nd); endless_method_name(p, (yyvsp[-5].nd)); @@ -7396,11 +7532,11 @@ yyreduce: nvars_unnest(p); p->in_def--; } -#line 7400 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7536 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 242: -#line 2374 "mrbgems/mruby-compiler/core/parse.y" + case 246: +#line 2429 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); void_expr_error(p, (yyvsp[0].nd)); @@ -7409,11 +7545,11 @@ yyreduce: p->in_def--; p->in_single--; } -#line 7413 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7549 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 243: -#line 2383 "mrbgems/mruby-compiler/core/parse.y" + case 247: +#line 2438 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-5].nd); void_expr_error(p, (yyvsp[-2].nd)); @@ -7423,71 +7559,71 @@ yyreduce: p->in_def--; p->in_single--; } -#line 7427 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7563 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 244: -#line 2393 "mrbgems/mruby-compiler/core/parse.y" + case 248: +#line 2448 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 7435 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7571 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 246: -#line 2400 "mrbgems/mruby-compiler/core/parse.y" + case 250: +#line 2455 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7444 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7580 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 247: -#line 2405 "mrbgems/mruby-compiler/core/parse.y" + case 251: +#line 2460 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd))); } -#line 7452 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7588 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 248: -#line 2409 "mrbgems/mruby-compiler/core/parse.y" + case 252: +#line 2464 "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 7461 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7597 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 249: -#line 2416 "mrbgems/mruby-compiler/core/parse.y" + case 253: +#line 2471 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 7469 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7605 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 250: -#line 2420 "mrbgems/mruby-compiler/core/parse.y" + case 254: +#line 2475 "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 7479 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7615 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 251: -#line 2428 "mrbgems/mruby-compiler/core/parse.y" + case 255: +#line 2483 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 7487 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7623 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 252: -#line 2432 "mrbgems/mruby-compiler/core/parse.y" + case 256: +#line 2487 "mrbgems/mruby-compiler/core/parse.y" { #if 1 mrb_sym r = intern_op(mul); @@ -7503,11 +7639,11 @@ yyreduce: new_block_arg(p, new_lvar(p, b))); #endif } -#line 7507 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7643 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 253: -#line 2448 "mrbgems/mruby-compiler/core/parse.y" + case 257: +#line 2503 "mrbgems/mruby-compiler/core/parse.y" { #if 1 mrb_sym r = intern_op(mul); @@ -7531,373 +7667,373 @@ yyreduce: (yyval.nd) = 0; } } -#line 7535 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7671 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 258: -#line 2480 "mrbgems/mruby-compiler/core/parse.y" + case 262: +#line 2535 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons((yyvsp[-1].nd),0); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7544 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7680 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 259: -#line 2485 "mrbgems/mruby-compiler/core/parse.y" + case 263: +#line 2540 "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 7553 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7689 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 260: -#line 2490 "mrbgems/mruby-compiler/core/parse.y" + case 264: +#line 2545 "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 7562 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7698 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 261: -#line 2497 "mrbgems/mruby-compiler/core/parse.y" + case 265: +#line 2552 "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 7572 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7708 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 262: -#line 2503 "mrbgems/mruby-compiler/core/parse.y" + case 266: +#line 2558 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons((yyvsp[-1].nd), (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7581 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7717 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 263: -#line 2508 "mrbgems/mruby-compiler/core/parse.y" + case 267: +#line 2563 "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 7590 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7726 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 264: -#line 2513 "mrbgems/mruby-compiler/core/parse.y" + case 268: +#line 2568 "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 7599 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7735 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 265: -#line 2518 "mrbgems/mruby-compiler/core/parse.y" + case 269: +#line 2573 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(0, (yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 7608 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7744 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 266: -#line 2524 "mrbgems/mruby-compiler/core/parse.y" + case 270: +#line 2579 "mrbgems/mruby-compiler/core/parse.y" { (yyval.stack) = p->cmdarg_stack; CMDARG_PUSH(1); } -#line 7617 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7753 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 267: -#line 2529 "mrbgems/mruby-compiler/core/parse.y" + case 271: +#line 2584 "mrbgems/mruby-compiler/core/parse.y" { p->cmdarg_stack = (yyvsp[-1].stack); (yyval.nd) = (yyvsp[0].nd); } -#line 7626 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7762 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 268: -#line 2536 "mrbgems/mruby-compiler/core/parse.y" + case 272: +#line 2591 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block_arg(p, (yyvsp[0].nd)); } -#line 7634 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7770 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 269: -#line 2542 "mrbgems/mruby-compiler/core/parse.y" + case 273: +#line 2597 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 7642 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7778 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 270: -#line 2546 "mrbgems/mruby-compiler/core/parse.y" + case 274: +#line 2601 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 7650 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7786 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 273: -#line 2556 "mrbgems/mruby-compiler/core/parse.y" + case 276: +#line 2610 "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 7660 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7796 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 274: -#line 2562 "mrbgems/mruby-compiler/core/parse.y" + case 277: +#line 2616 "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 7670 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7806 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 275: -#line 2568 "mrbgems/mruby-compiler/core/parse.y" + case 278: +#line 2622 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7679 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7815 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 276: -#line 2573 "mrbgems/mruby-compiler/core/parse.y" + case 279: +#line 2627 "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 7688 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7824 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 277: -#line 2580 "mrbgems/mruby-compiler/core/parse.y" + case 280: +#line 2634 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 7697 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7833 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 278: -#line 2585 "mrbgems/mruby-compiler/core/parse.y" + case 281: +#line 2639 "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 7706 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7842 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 279: -#line 2590 "mrbgems/mruby-compiler/core/parse.y" + case 282: +#line 2644 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); (yyval.nd) = list1(new_splat(p, (yyvsp[0].nd))); } -#line 7715 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7851 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 287: -#line 2604 "mrbgems/mruby-compiler/core/parse.y" + case 290: +#line 2658 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_nvar(p, (yyvsp[0].num)); } -#line 7723 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7859 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 288: -#line 2608 "mrbgems/mruby-compiler/core/parse.y" + case 291: +#line 2662 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, (yyvsp[0].id), 0); } -#line 7731 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7867 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 289: -#line 2612 "mrbgems/mruby-compiler/core/parse.y" + case 292: +#line 2666 "mrbgems/mruby-compiler/core/parse.y" { (yyval.stack) = p->cmdarg_stack; p->cmdarg_stack = 0; } -#line 7740 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7876 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 290: -#line 2618 "mrbgems/mruby-compiler/core/parse.y" + case 293: +#line 2672 "mrbgems/mruby-compiler/core/parse.y" { p->cmdarg_stack = (yyvsp[-2].stack); (yyval.nd) = (yyvsp[-1].nd); } -#line 7749 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7885 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 291: -#line 2623 "mrbgems/mruby-compiler/core/parse.y" + case 294: +#line 2677 "mrbgems/mruby-compiler/core/parse.y" { (yyval.stack) = p->cmdarg_stack; p->cmdarg_stack = 0; } -#line 7758 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7894 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 292: -#line 2627 "mrbgems/mruby-compiler/core/parse.y" + case 295: +#line 2681 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_ENDARG;} -#line 7764 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7900 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 293: -#line 2628 "mrbgems/mruby-compiler/core/parse.y" + case 296: +#line 2682 "mrbgems/mruby-compiler/core/parse.y" { p->cmdarg_stack = (yyvsp[-3].stack); (yyval.nd) = (yyvsp[-2].nd); } -#line 7773 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7909 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 294: -#line 2632 "mrbgems/mruby-compiler/core/parse.y" + case 297: +#line 2686 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_ENDARG;} -#line 7779 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7915 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 295: -#line 2633 "mrbgems/mruby-compiler/core/parse.y" + case 298: +#line 2687 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_nil(p); } -#line 7787 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7923 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 296: -#line 2637 "mrbgems/mruby-compiler/core/parse.y" + case 299: +#line 2691 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 7795 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7931 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 297: -#line 2641 "mrbgems/mruby-compiler/core/parse.y" + case 300: +#line 2695 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id)); } -#line 7803 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7939 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 298: -#line 2645 "mrbgems/mruby-compiler/core/parse.y" + case 301: +#line 2699 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_colon3(p, (yyvsp[0].id)); } -#line 7811 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7947 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 299: -#line 2649 "mrbgems/mruby-compiler/core/parse.y" + case 302: +#line 2703 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_array(p, (yyvsp[-1].nd)); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7820 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7956 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 300: -#line 2654 "mrbgems/mruby-compiler/core/parse.y" + case 303: +#line 2708 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_hash(p, (yyvsp[-1].nd)); NODE_LINENO((yyval.nd), (yyvsp[-1].nd)); } -#line 7829 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7965 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 301: -#line 2659 "mrbgems/mruby-compiler/core/parse.y" + case 304: +#line 2713 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_return(p, 0); } -#line 7837 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7973 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 302: -#line 2663 "mrbgems/mruby-compiler/core/parse.y" + case 305: +#line 2717 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_yield(p, (yyvsp[0].nd)); } -#line 7845 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7981 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 303: -#line 2667 "mrbgems/mruby-compiler/core/parse.y" + case 306: +#line 2721 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, cond((yyvsp[-1].nd)), "!"); } -#line 7853 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7989 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 304: -#line 2671 "mrbgems/mruby-compiler/core/parse.y" + case 307: +#line 2725 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = call_uni_op(p, new_nil(p), "!"); } -#line 7861 "mrbgems/mruby-compiler/core/y.tab.c" +#line 7997 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 305: -#line 2675 "mrbgems/mruby-compiler/core/parse.y" + case 308: +#line 2729 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, (yyvsp[-1].id), cons(0, (yyvsp[0].nd))); } -#line 7869 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8005 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 307: -#line 2680 "mrbgems/mruby-compiler/core/parse.y" + case 310: +#line 2734 "mrbgems/mruby-compiler/core/parse.y" { call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd)); (yyval.nd) = (yyvsp[-1].nd); } -#line 7878 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8014 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 308: -#line 2685 "mrbgems/mruby-compiler/core/parse.y" + case 311: +#line 2739 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); (yyval.num) = p->lpar_beg; p->lpar_beg = ++p->paren_nest; } -#line 7888 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8024 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 309: -#line 2691 "mrbgems/mruby-compiler/core/parse.y" + case 312: +#line 2745 "mrbgems/mruby-compiler/core/parse.y" { (yyval.stack) = p->cmdarg_stack; p->cmdarg_stack = 0; } -#line 7897 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8033 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 310: -#line 2696 "mrbgems/mruby-compiler/core/parse.y" + case 313: +#line 2750 "mrbgems/mruby-compiler/core/parse.y" { p->lpar_beg = (yyvsp[-3].num); (yyval.nd) = new_lambda(p, (yyvsp[-2].nd), (yyvsp[0].nd)); @@ -7905,149 +8041,149 @@ yyreduce: p->cmdarg_stack = (yyvsp[-1].stack); CMDARG_LEXPOP(); } -#line 7909 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8045 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 311: -#line 2707 "mrbgems/mruby-compiler/core/parse.y" + case 314: +#line 2761 "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 7918 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8054 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 312: -#line 2715 "mrbgems/mruby-compiler/core/parse.y" + case 315: +#line 2769 "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 7927 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8063 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 313: -#line 2719 "mrbgems/mruby-compiler/core/parse.y" + case 316: +#line 2773 "mrbgems/mruby-compiler/core/parse.y" {COND_PUSH(1);} -#line 7933 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8069 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 314: -#line 2719 "mrbgems/mruby-compiler/core/parse.y" + case 317: +#line 2773 "mrbgems/mruby-compiler/core/parse.y" {COND_POP();} -#line 7939 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8075 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 315: -#line 2722 "mrbgems/mruby-compiler/core/parse.y" + case 318: +#line 2776 "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 7948 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8084 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 316: -#line 2726 "mrbgems/mruby-compiler/core/parse.y" + case 319: +#line 2780 "mrbgems/mruby-compiler/core/parse.y" {COND_PUSH(1);} -#line 7954 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8090 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 317: -#line 2726 "mrbgems/mruby-compiler/core/parse.y" + case 320: +#line 2780 "mrbgems/mruby-compiler/core/parse.y" {COND_POP();} -#line 7960 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8096 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 318: -#line 2729 "mrbgems/mruby-compiler/core/parse.y" + case 321: +#line 2783 "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 7969 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8105 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 319: -#line 2736 "mrbgems/mruby-compiler/core/parse.y" + case 322: +#line 2790 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_case(p, (yyvsp[-3].nd), (yyvsp[-1].nd)); } -#line 7977 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8113 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 320: -#line 2740 "mrbgems/mruby-compiler/core/parse.y" + case 323: +#line 2794 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_case(p, 0, (yyvsp[-1].nd)); } -#line 7985 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8121 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 321: -#line 2744 "mrbgems/mruby-compiler/core/parse.y" + case 324: +#line 2798 "mrbgems/mruby-compiler/core/parse.y" {COND_PUSH(1);} -#line 7991 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8127 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 322: -#line 2746 "mrbgems/mruby-compiler/core/parse.y" + case 325: +#line 2800 "mrbgems/mruby-compiler/core/parse.y" {COND_POP();} -#line 7997 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8133 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 323: -#line 2749 "mrbgems/mruby-compiler/core/parse.y" + case 326: +#line 2803 "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 8006 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8142 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 324: -#line 2755 "mrbgems/mruby-compiler/core/parse.y" + case 327: +#line 2809 "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 8017 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8153 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 325: -#line 2763 "mrbgems/mruby-compiler/core/parse.y" + case 328: +#line 2817 "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 8028 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8164 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 326: -#line 2771 "mrbgems/mruby-compiler/core/parse.y" + case 329: +#line 2825 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = p->in_def; p->in_def = 0; } -#line 8037 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8173 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 327: -#line 2776 "mrbgems/mruby-compiler/core/parse.y" + case 330: +#line 2830 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(local_switch(p), nint(p->in_single)); nvars_block(p); p->in_single = 0; } -#line 8047 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8183 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 328: -#line 2783 "mrbgems/mruby-compiler/core/parse.y" + case 331: +#line 2837 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_sclass(p, (yyvsp[-5].nd), (yyvsp[-1].nd)); SET_LINENO((yyval.nd), (yyvsp[-7].num)); @@ -8056,44 +8192,44 @@ yyreduce: p->in_def = (yyvsp[-4].num); p->in_single = intn((yyvsp[-2].nd)->cdr); } -#line 8060 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8196 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 329: -#line 2793 "mrbgems/mruby-compiler/core/parse.y" + case 332: +#line 2847 "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 8071 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8207 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 330: -#line 2801 "mrbgems/mruby-compiler/core/parse.y" + case 333: +#line 2855 "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 8082 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8218 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 331: -#line 2811 "mrbgems/mruby-compiler/core/parse.y" + case 334: +#line 2865 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd)); nvars_unnest(p); p->in_def--; } -#line 8093 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8229 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 332: -#line 2821 "mrbgems/mruby-compiler/core/parse.y" + case 335: +#line 2875 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-3].nd); defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd)); @@ -8101,451 +8237,451 @@ yyreduce: p->in_def--; p->in_single--; } -#line 8105 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8241 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 333: -#line 2829 "mrbgems/mruby-compiler/core/parse.y" + case 336: +#line 2883 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_break(p, 0); } -#line 8113 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8249 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 334: -#line 2833 "mrbgems/mruby-compiler/core/parse.y" + case 337: +#line 2887 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_next(p, 0); } -#line 8121 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8257 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 335: -#line 2837 "mrbgems/mruby-compiler/core/parse.y" + case 338: +#line 2891 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_redo(p); } -#line 8129 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8265 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 336: -#line 2841 "mrbgems/mruby-compiler/core/parse.y" + case 339: +#line 2895 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_retry(p); } -#line 8137 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8273 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 337: -#line 2847 "mrbgems/mruby-compiler/core/parse.y" + case 340: +#line 2901 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); if (!(yyval.nd)) (yyval.nd) = new_nil(p); } -#line 8146 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8282 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 344: -#line 2866 "mrbgems/mruby-compiler/core/parse.y" + case 347: +#line 2920 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_if(p, cond((yyvsp[-3].nd)), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8154 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8290 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 346: -#line 2873 "mrbgems/mruby-compiler/core/parse.y" + case 349: +#line 2927 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8162 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8298 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 347: -#line 2879 "mrbgems/mruby-compiler/core/parse.y" + case 350: +#line 2933 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(list1((yyvsp[0].nd))); } -#line 8170 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8306 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 349: -#line 2886 "mrbgems/mruby-compiler/core/parse.y" + case 352: +#line 2940 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[0].nd),0,0); } -#line 8178 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8314 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 350: -#line 2890 "mrbgems/mruby-compiler/core/parse.y" + case 353: +#line 2944 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-3].nd), new_arg(p, (yyvsp[0].id)), 0); } -#line 8186 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8322 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 351: -#line 2894 "mrbgems/mruby-compiler/core/parse.y" + case 354: +#line 2948 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-5].nd), new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd)); } -#line 8194 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8330 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 352: -#line 2898 "mrbgems/mruby-compiler/core/parse.y" + case 355: +#line 2952 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, 0); (yyval.nd) = list3((yyvsp[-2].nd), nint(-1), 0); } -#line 8203 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8339 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 353: -#line 2903 "mrbgems/mruby-compiler/core/parse.y" + case 356: +#line 2957 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3((yyvsp[-4].nd), nint(-1), (yyvsp[0].nd)); } -#line 8211 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8347 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 354: -#line 2907 "mrbgems/mruby-compiler/core/parse.y" + case 357: +#line 2961 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, new_arg(p, (yyvsp[0].id)), 0); } -#line 8219 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8355 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 355: -#line 2911 "mrbgems/mruby-compiler/core/parse.y" + case 358: +#line 2965 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd)); } -#line 8227 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8363 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 356: -#line 2915 "mrbgems/mruby-compiler/core/parse.y" + case 359: +#line 2969 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, 0); (yyval.nd) = list3(0, nint(-1), 0); } -#line 8236 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8372 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 357: -#line 2920 "mrbgems/mruby-compiler/core/parse.y" + case 360: +#line 2974 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, 0); } -#line 8244 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8380 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 358: -#line 2924 "mrbgems/mruby-compiler/core/parse.y" + case 361: +#line 2978 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list3(0, nint(-1), (yyvsp[0].nd)); } -#line 8252 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8388 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 359: -#line 2930 "mrbgems/mruby-compiler/core/parse.y" + case 362: +#line 2984 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 8260 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8396 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 360: -#line 2934 "mrbgems/mruby-compiler/core/parse.y" + case 363: +#line 2988 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id)); } -#line 8268 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8404 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 361: -#line 2938 "mrbgems/mruby-compiler/core/parse.y" + case 364: +#line 2992 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 8276 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8412 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 362: -#line 2942 "mrbgems/mruby-compiler/core/parse.y" + case 365: +#line 2996 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id)); } -#line 8284 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8420 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 363: -#line 2948 "mrbgems/mruby-compiler/core/parse.y" + case 366: +#line 3002 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8292 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8428 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 364: -#line 2952 "mrbgems/mruby-compiler/core/parse.y" + case 367: +#line 3006 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, 0, 0); } -#line 8300 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8436 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 365: -#line 2958 "mrbgems/mruby-compiler/core/parse.y" + case 368: +#line 3012 "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 8308 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8444 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 366: -#line 2962 "mrbgems/mruby-compiler/core/parse.y" + case 369: +#line 3016 "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 8316 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8452 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 367: -#line 2966 "mrbgems/mruby-compiler/core/parse.y" + case 370: +#line 3020 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 8324 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8460 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 368: -#line 2970 "mrbgems/mruby-compiler/core/parse.y" + case 371: +#line 3024 "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 8332 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8468 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 369: -#line 2974 "mrbgems/mruby-compiler/core/parse.y" + case 372: +#line 3028 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8340 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8476 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 370: -#line 2978 "mrbgems/mruby-compiler/core/parse.y" + case 373: +#line 3032 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-2].nd), 0, 0, 0, (yyvsp[0].nd)); } -#line 8348 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8484 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 371: -#line 2982 "mrbgems/mruby-compiler/core/parse.y" + case 374: +#line 3036 "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 8356 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8492 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 372: -#line 2986 "mrbgems/mruby-compiler/core/parse.y" + case 375: +#line 3040 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd)); } -#line 8364 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8500 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 373: -#line 2990 "mrbgems/mruby-compiler/core/parse.y" + case 376: +#line 3044 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8372 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8508 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 374: -#line 2994 "mrbgems/mruby-compiler/core/parse.y" + case 377: +#line 3048 "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 8380 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8516 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 375: -#line 2998 "mrbgems/mruby-compiler/core/parse.y" + case 378: +#line 3052 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 8388 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8524 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 376: -#line 3002 "mrbgems/mruby-compiler/core/parse.y" + case 379: +#line 3056 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8396 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8532 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 377: -#line 3006 "mrbgems/mruby-compiler/core/parse.y" + case 380: +#line 3060 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 8404 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8540 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 378: -#line 3010 "mrbgems/mruby-compiler/core/parse.y" + case 381: +#line 3064 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8412 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8548 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 379: -#line 3014 "mrbgems/mruby-compiler/core/parse.y" + case 382: +#line 3068 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd)); } -#line 8420 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8556 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 380: -#line 3020 "mrbgems/mruby-compiler/core/parse.y" + case 383: +#line 3074 "mrbgems/mruby-compiler/core/parse.y" { local_add_blk(p, 0); (yyval.nd) = 0; } -#line 8429 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8565 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 381: -#line 3025 "mrbgems/mruby-compiler/core/parse.y" + case 384: +#line 3079 "mrbgems/mruby-compiler/core/parse.y" { p->cmd_start = TRUE; (yyval.nd) = (yyvsp[0].nd); } -#line 8438 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8574 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 382: -#line 3031 "mrbgems/mruby-compiler/core/parse.y" + case 385: +#line 3085 "mrbgems/mruby-compiler/core/parse.y" {local_add_blk(p, 0);} -#line 8444 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8580 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 383: -#line 3032 "mrbgems/mruby-compiler/core/parse.y" + case 386: +#line 3086 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 8452 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8588 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 384: -#line 3036 "mrbgems/mruby-compiler/core/parse.y" + case 387: +#line 3090 "mrbgems/mruby-compiler/core/parse.y" { local_add_blk(p, 0); (yyval.nd) = 0; } -#line 8461 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8597 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 385: -#line 3041 "mrbgems/mruby-compiler/core/parse.y" + case 388: +#line 3095 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-2].nd); } -#line 8469 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8605 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 386: -#line 3048 "mrbgems/mruby-compiler/core/parse.y" + case 389: +#line 3102 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 8477 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8613 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 387: -#line 3052 "mrbgems/mruby-compiler/core/parse.y" + case 390: +#line 3106 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 8485 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8621 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 390: -#line 3062 "mrbgems/mruby-compiler/core/parse.y" + case 393: +#line 3116 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[0].id)); new_bv(p, (yyvsp[0].id)); } -#line 8494 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8630 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 392: -#line 3070 "mrbgems/mruby-compiler/core/parse.y" + case 395: +#line 3124 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-2].nd); } -#line 8502 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8638 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 393: -#line 3074 "mrbgems/mruby-compiler/core/parse.y" + case 396: +#line 3128 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8510 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8646 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 394: -#line 3080 "mrbgems/mruby-compiler/core/parse.y" + case 397: +#line 3134 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 8518 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8654 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 395: -#line 3084 "mrbgems/mruby-compiler/core/parse.y" + case 398: +#line 3138 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 8526 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8662 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 396: -#line 3090 "mrbgems/mruby-compiler/core/parse.y" + case 399: +#line 3144 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); } -#line 8535 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8671 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 397: -#line 3097 "mrbgems/mruby-compiler/core/parse.y" + case 400: +#line 3151 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd)); local_unnest(p); nvars_unnest(p); } -#line 8545 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8681 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 398: -#line 3105 "mrbgems/mruby-compiler/core/parse.y" + case 401: +#line 3159 "mrbgems/mruby-compiler/core/parse.y" { if (typen((yyvsp[-1].nd)->car) == NODE_YIELD) { yyerror(p, "block given to yield"); @@ -8555,159 +8691,159 @@ yyreduce: } (yyval.nd) = (yyvsp[-1].nd); } -#line 8559 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8695 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 399: -#line 3115 "mrbgems/mruby-compiler/core/parse.y" + case 402: +#line 3169 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 8567 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8703 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 400: -#line 3119 "mrbgems/mruby-compiler/core/parse.y" + case 403: +#line 3173 "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 8576 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8712 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 401: -#line 3124 "mrbgems/mruby-compiler/core/parse.y" + case 404: +#line 3178 "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 8585 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8721 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 402: -#line 3131 "mrbgems/mruby-compiler/core/parse.y" + case 405: +#line 3185 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd)); } -#line 8593 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8729 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 403: -#line 3135 "mrbgems/mruby-compiler/core/parse.y" + case 406: +#line 3189 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num)); } -#line 8601 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8737 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 404: -#line 3139 "mrbgems/mruby-compiler/core/parse.y" + case 407: +#line 3193 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2); } -#line 8609 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8745 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 405: -#line 3143 "mrbgems/mruby-compiler/core/parse.y" + case 408: +#line 3197 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2); } -#line 8617 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8753 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 406: -#line 3147 "mrbgems/mruby-compiler/core/parse.y" + case 409: +#line 3201 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), (yyvsp[-1].num)); } -#line 8625 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8761 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 407: -#line 3151 "mrbgems/mruby-compiler/core/parse.y" + case 410: +#line 3205 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), tCOLON2); } -#line 8633 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8769 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 408: -#line 3155 "mrbgems/mruby-compiler/core/parse.y" + case 411: +#line 3209 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_super(p, (yyvsp[0].nd)); } -#line 8641 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8777 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 409: -#line 3159 "mrbgems/mruby-compiler/core/parse.y" + case 412: +#line 3213 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_zsuper(p); } -#line 8649 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8785 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 410: -#line 3163 "mrbgems/mruby-compiler/core/parse.y" + case 413: +#line 3217 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.'); } -#line 8657 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8793 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 411: -#line 3169 "mrbgems/mruby-compiler/core/parse.y" + case 414: +#line 3223 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); (yyval.num) = p->lineno; } -#line 8667 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8803 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 412: -#line 3176 "mrbgems/mruby-compiler/core/parse.y" + case 415: +#line 3230 "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 8678 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8814 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 413: -#line 3183 "mrbgems/mruby-compiler/core/parse.y" + case 416: +#line 3237 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); nvars_nest(p); (yyval.num) = p->lineno; } -#line 8688 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8824 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 414: -#line 3190 "mrbgems/mruby-compiler/core/parse.y" + case 417: +#line 3244 "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 8699 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8835 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 415: -#line 3201 "mrbgems/mruby-compiler/core/parse.y" + case 418: +#line 3255 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = cons(cons((yyvsp[-3].nd), (yyvsp[-1].nd)), (yyvsp[0].nd)); } -#line 8707 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8843 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 416: -#line 3207 "mrbgems/mruby-compiler/core/parse.y" + case 419: +#line 3261 "mrbgems/mruby-compiler/core/parse.y" { if ((yyvsp[0].nd)) { (yyval.nd) = cons(cons(0, (yyvsp[0].nd)), 0); @@ -8716,383 +8852,415 @@ yyreduce: (yyval.nd) = 0; } } -#line 8720 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8856 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 418: -#line 3221 "mrbgems/mruby-compiler/core/parse.y" + case 421: +#line 3275 "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 8729 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8865 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 420: -#line 3229 "mrbgems/mruby-compiler/core/parse.y" + case 423: +#line 3283 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 8737 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8873 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 423: -#line 3237 "mrbgems/mruby-compiler/core/parse.y" + case 426: +#line 3291 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8745 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8881 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 425: -#line 3244 "mrbgems/mruby-compiler/core/parse.y" + case 428: +#line 3298 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8753 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8889 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 432: -#line 3258 "mrbgems/mruby-compiler/core/parse.y" + case 435: +#line 3312 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = concat_string(p, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8761 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8897 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 435: -#line 3266 "mrbgems/mruby-compiler/core/parse.y" + case 438: +#line 3320 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8769 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8905 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 436: -#line 3270 "mrbgems/mruby-compiler/core/parse.y" + case 439: +#line 3324 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_dstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd))); + node *n = (yyvsp[-1].nd); + if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { + n = push(n, (yyvsp[0].nd)); + } + else { + cons_free((yyvsp[0].nd)); + } + (yyval.nd) = new_dstr(p, n); } -#line 8777 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8920 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 438: -#line 3277 "mrbgems/mruby-compiler/core/parse.y" + case 441: +#line 3338 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8785 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8928 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 439: -#line 3283 "mrbgems/mruby-compiler/core/parse.y" + case 442: +#line 3344 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 8793 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8936 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 440: -#line 3287 "mrbgems/mruby-compiler/core/parse.y" + case 443: +#line 3348 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = p->lex_strterm; p->lex_strterm = NULL; } -#line 8802 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8945 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 441: -#line 3293 "mrbgems/mruby-compiler/core/parse.y" + case 444: +#line 3354 "mrbgems/mruby-compiler/core/parse.y" { p->lex_strterm = (yyvsp[-2].nd); (yyval.nd) = list2((yyvsp[-3].nd), (yyvsp[-1].nd)); } -#line 8811 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8954 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 442: -#line 3298 "mrbgems/mruby-compiler/core/parse.y" + case 445: +#line 3359 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(new_literal_delim(p)); } -#line 8819 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8962 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 443: -#line 3302 "mrbgems/mruby-compiler/core/parse.y" + case 446: +#line 3363 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1(new_literal_delim(p)); } -#line 8827 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8970 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 444: -#line 3308 "mrbgems/mruby-compiler/core/parse.y" + case 447: +#line 3369 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8835 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8978 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 445: -#line 3312 "mrbgems/mruby-compiler/core/parse.y" + case 448: +#line 3373 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_dxstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd))); + node *n = (yyvsp[-1].nd); + if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { + n = push(n, (yyvsp[0].nd)); + } + else { + cons_free((yyvsp[0].nd)); + } + (yyval.nd) = new_dxstr(p, n); } -#line 8843 "mrbgems/mruby-compiler/core/y.tab.c" +#line 8993 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 446: -#line 3318 "mrbgems/mruby-compiler/core/parse.y" + case 449: +#line 3386 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 8851 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9001 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 447: -#line 3322 "mrbgems/mruby-compiler/core/parse.y" + case 450: +#line 3390 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_dregx(p, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 8859 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9009 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 451: -#line 3335 "mrbgems/mruby-compiler/core/parse.y" + case 454: +#line 3403 "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 8869 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9019 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 452: -#line 3341 "mrbgems/mruby-compiler/core/parse.y" + case 455: +#line 3409 "mrbgems/mruby-compiler/core/parse.y" { heredoc_end(p); } -#line 8877 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9027 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 455: -#line 3351 "mrbgems/mruby-compiler/core/parse.y" + case 458: +#line 3419 "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 8887 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9037 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 456: -#line 3357 "mrbgems/mruby-compiler/core/parse.y" + case 459: +#line 3425 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = p->lex_strterm; p->lex_strterm = NULL; } -#line 8896 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9046 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 457: -#line 3363 "mrbgems/mruby-compiler/core/parse.y" + case 460: +#line 3431 "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 8906 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9056 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 458: -#line 3371 "mrbgems/mruby-compiler/core/parse.y" + case 461: +#line 3439 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_words(p, list1((yyvsp[0].nd))); } -#line 8914 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9064 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 459: -#line 3375 "mrbgems/mruby-compiler/core/parse.y" + case 462: +#line 3443 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_words(p, push((yyvsp[-1].nd), (yyvsp[0].nd))); + node *n = (yyvsp[-1].nd); + if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { + n = push(n, (yyvsp[0].nd)); + } + else { + cons_free((yyvsp[0].nd)); + } + (yyval.nd) = new_words(p, n); } -#line 8922 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9079 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 460: -#line 3382 "mrbgems/mruby-compiler/core/parse.y" + case 463: +#line 3457 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_ENDARG; (yyval.nd) = new_sym(p, (yyvsp[0].id)); } -#line 8931 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9088 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 461: -#line 3387 "mrbgems/mruby-compiler/core/parse.y" + case 464: +#line 3462 "mrbgems/mruby-compiler/core/parse.y" { + node *n = (yyvsp[-1].nd); p->lstate = EXPR_ENDARG; - (yyval.nd) = new_dsym(p, new_dstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd)))); + if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { + n = push(n, (yyvsp[0].nd)); + } + else { + cons_free((yyvsp[0].nd)); + } + (yyval.nd) = new_dsym(p, new_dstr(p, n)); } -#line 8940 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9104 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 462: -#line 3394 "mrbgems/mruby-compiler/core/parse.y" + case 465: +#line 3476 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = (yyvsp[0].id); } -#line 8948 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9112 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 467: -#line 3404 "mrbgems/mruby-compiler/core/parse.y" + case 470: +#line 3486 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = new_strsym(p, (yyvsp[0].nd)); } -#line 8956 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9120 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 468: -#line 3408 "mrbgems/mruby-compiler/core/parse.y" + case 471: +#line 3490 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = new_strsym(p, (yyvsp[0].nd)); } -#line 8964 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9128 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 469: -#line 3414 "mrbgems/mruby-compiler/core/parse.y" + case 472: +#line 3496 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_symbols(p, list1((yyvsp[0].nd))); } -#line 8972 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9136 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 470: -#line 3418 "mrbgems/mruby-compiler/core/parse.y" + case 473: +#line 3500 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = new_symbols(p, push((yyvsp[-1].nd), (yyvsp[0].nd))); + node *n = (yyvsp[-1].nd); + if (intn((yyvsp[0].nd)->cdr->cdr) > 0) { + n = push(n, (yyvsp[0].nd)); + } + (yyval.nd) = new_symbols(p, n); } -#line 8980 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9148 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 473: -#line 3426 "mrbgems/mruby-compiler/core/parse.y" + case 476: +#line 3512 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = negate_lit(p, (yyvsp[0].nd)); + (yyval.nd) = new_negate(p, (yyvsp[0].nd)); } -#line 8988 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9156 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 474: -#line 3430 "mrbgems/mruby-compiler/core/parse.y" + case 477: +#line 3516 "mrbgems/mruby-compiler/core/parse.y" { - (yyval.nd) = negate_lit(p, (yyvsp[0].nd)); + (yyval.nd) = new_negate(p, (yyvsp[0].nd)); } -#line 8996 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9164 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 475: -#line 3436 "mrbgems/mruby-compiler/core/parse.y" + case 478: +#line 3522 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_lvar(p, (yyvsp[0].id)); } -#line 9004 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9172 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 476: -#line 3440 "mrbgems/mruby-compiler/core/parse.y" + case 479: +#line 3526 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_ivar(p, (yyvsp[0].id)); } -#line 9012 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9180 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 477: -#line 3444 "mrbgems/mruby-compiler/core/parse.y" + case 480: +#line 3530 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_gvar(p, (yyvsp[0].id)); } -#line 9020 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9188 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 478: -#line 3448 "mrbgems/mruby-compiler/core/parse.y" + case 481: +#line 3534 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_cvar(p, (yyvsp[0].id)); } -#line 9028 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9196 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 479: -#line 3452 "mrbgems/mruby-compiler/core/parse.y" + case 482: +#line 3538 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_const(p, (yyvsp[0].id)); } -#line 9036 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9204 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 480: -#line 3458 "mrbgems/mruby-compiler/core/parse.y" + case 483: +#line 3544 "mrbgems/mruby-compiler/core/parse.y" { assignable(p, (yyvsp[0].nd)); } -#line 9044 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9212 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 481: -#line 3462 "mrbgems/mruby-compiler/core/parse.y" + case 484: +#line 3548 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "can't assign to numbered parameter"); } -#line 9052 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9220 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 482: -#line 3468 "mrbgems/mruby-compiler/core/parse.y" + case 485: +#line 3554 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = var_reference(p, (yyvsp[0].nd)); } -#line 9060 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9228 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 483: -#line 3472 "mrbgems/mruby-compiler/core/parse.y" + case 486: +#line 3558 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_nil(p); } -#line 9068 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9236 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 484: -#line 3476 "mrbgems/mruby-compiler/core/parse.y" + case 487: +#line 3562 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_self(p); } -#line 9076 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9244 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 485: -#line 3480 "mrbgems/mruby-compiler/core/parse.y" + case 488: +#line 3566 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_true(p); } -#line 9084 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9252 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 486: -#line 3484 "mrbgems/mruby-compiler/core/parse.y" + case 489: +#line 3570 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_false(p); } -#line 9092 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9260 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 487: -#line 3488 "mrbgems/mruby-compiler/core/parse.y" + case 490: +#line 3574 "mrbgems/mruby-compiler/core/parse.y" { const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL); if (!fn) { @@ -9100,70 +9268,65 @@ yyreduce: } (yyval.nd) = new_str(p, fn, strlen(fn)); } -#line 9104 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9272 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 488: -#line 3496 "mrbgems/mruby-compiler/core/parse.y" + case 491: +#line 3582 "mrbgems/mruby-compiler/core/parse.y" { char buf[16]; dump_int(p->lineno, buf); (yyval.nd) = new_int(p, buf, 10, 0); } -#line 9115 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9283 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 489: -#line 3503 "mrbgems/mruby-compiler/core/parse.y" + case 492: +#line 3589 "mrbgems/mruby-compiler/core/parse.y" { -#ifdef MRB_UTF8_STRING - const char *enc = "UTF-8"; -#else - const char *enc = "ASCII-8BIT"; -#endif - (yyval.nd) = new_str(p, enc, strlen(enc)); + (yyval.nd) = new_fcall(p, MRB_SYM_2(p->mrb, __ENCODING__), 0); } -#line 9128 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9291 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 492: -#line 3518 "mrbgems/mruby-compiler/core/parse.y" + case 495: +#line 3599 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 9136 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9299 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 493: -#line 3522 "mrbgems/mruby-compiler/core/parse.y" + case 496: +#line 3603 "mrbgems/mruby-compiler/core/parse.y" { p->lstate = EXPR_BEG; p->cmd_start = TRUE; } -#line 9145 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9308 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 494: -#line 3527 "mrbgems/mruby-compiler/core/parse.y" + case 497: +#line 3608 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 9153 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9316 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 497: -#line 3543 "mrbgems/mruby-compiler/core/parse.y" + case 500: +#line 3624 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); p->lstate = EXPR_BEG; p->cmd_start = TRUE; } -#line 9163 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9326 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 498: -#line 3549 "mrbgems/mruby-compiler/core/parse.y" + case 501: +#line 3630 "mrbgems/mruby-compiler/core/parse.y" { #if 1 /* til real keyword args implemented */ @@ -9181,11 +9344,11 @@ yyreduce: new_args_tail(p, 0, new_kw_rest_args(p, nsym(k)), b)); #endif } -#line 9185 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9348 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 499: -#line 3567 "mrbgems/mruby-compiler/core/parse.y" + case 502: +#line 3648 "mrbgems/mruby-compiler/core/parse.y" { #if 1 /* til real keyword args implemented */ @@ -9203,504 +9366,504 @@ yyreduce: new_args_tail(p, 0, new_kw_rest_args(p, nsym(k)), b)); #endif } -#line 9207 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9370 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 501: -#line 3588 "mrbgems/mruby-compiler/core/parse.y" + case 504: +#line 3669 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 9215 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9378 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 502: -#line 3594 "mrbgems/mruby-compiler/core/parse.y" + case 505: +#line 3675 "mrbgems/mruby-compiler/core/parse.y" { local_nest(p); } -#line 9223 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9386 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 503: -#line 3600 "mrbgems/mruby-compiler/core/parse.y" + case 506: +#line 3681 "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 9233 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9396 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 504: -#line 3606 "mrbgems/mruby-compiler/core/parse.y" + case 507: +#line 3687 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0); local_unnest(p); } -#line 9242 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9405 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 505: -#line 3613 "mrbgems/mruby-compiler/core/parse.y" + case 508: +#line 3694 "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 9251 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9414 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 506: -#line 3618 "mrbgems/mruby-compiler/core/parse.y" + case 509: +#line 3699 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0); local_unnest(p); } -#line 9260 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9423 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 507: -#line 3625 "mrbgems/mruby-compiler/core/parse.y" + case 510: +#line 3706 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9268 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9431 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 508: -#line 3629 "mrbgems/mruby-compiler/core/parse.y" + case 511: +#line 3710 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9276 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9439 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 509: -#line 3635 "mrbgems/mruby-compiler/core/parse.y" + case 512: +#line 3716 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9284 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9447 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 510: -#line 3639 "mrbgems/mruby-compiler/core/parse.y" + case 513: +#line 3720 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9292 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9455 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 513: -#line 3649 "mrbgems/mruby-compiler/core/parse.y" + case 516: +#line 3730 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_kw_rest_args(p, nsym((yyvsp[0].id))); } -#line 9300 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9463 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 514: -#line 3653 "mrbgems/mruby-compiler/core/parse.y" + case 517: +#line 3734 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_kw_rest_args(p, 0); } -#line 9308 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9471 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 515: -#line 3659 "mrbgems/mruby-compiler/core/parse.y" + case 518: +#line 3740 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 9316 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9479 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 516: -#line 3663 "mrbgems/mruby-compiler/core/parse.y" + case 519: +#line 3744 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id)); } -#line 9324 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9487 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 517: -#line 3667 "mrbgems/mruby-compiler/core/parse.y" + case 520: +#line 3748 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id)); } -#line 9332 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9495 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 518: -#line 3671 "mrbgems/mruby-compiler/core/parse.y" + case 521: +#line 3752 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id)); } -#line 9340 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9503 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 519: -#line 3677 "mrbgems/mruby-compiler/core/parse.y" + case 522: +#line 3758 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); } -#line 9348 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9511 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 520: -#line 3681 "mrbgems/mruby-compiler/core/parse.y" + case 523: +#line 3762 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args_tail(p, 0, 0, 0); } -#line 9356 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9519 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 521: -#line 3687 "mrbgems/mruby-compiler/core/parse.y" + case 524: +#line 3768 "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 9364 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9527 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 522: -#line 3691 "mrbgems/mruby-compiler/core/parse.y" + case 525: +#line 3772 "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 9372 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9535 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 523: -#line 3695 "mrbgems/mruby-compiler/core/parse.y" + case 526: +#line 3776 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 9380 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9543 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 524: -#line 3699 "mrbgems/mruby-compiler/core/parse.y" + case 527: +#line 3780 "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 9388 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9551 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 525: -#line 3703 "mrbgems/mruby-compiler/core/parse.y" + case 528: +#line 3784 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9396 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9559 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 526: -#line 3707 "mrbgems/mruby-compiler/core/parse.y" + case 529: +#line 3788 "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 9404 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9567 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 527: -#line 3711 "mrbgems/mruby-compiler/core/parse.y" + case 530: +#line 3792 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd)); } -#line 9412 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9575 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 528: -#line 3715 "mrbgems/mruby-compiler/core/parse.y" + case 531: +#line 3796 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9420 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9583 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 529: -#line 3719 "mrbgems/mruby-compiler/core/parse.y" + case 532: +#line 3800 "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 9428 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9591 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 530: -#line 3723 "mrbgems/mruby-compiler/core/parse.y" + case 533: +#line 3804 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd)); } -#line 9436 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9599 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 531: -#line 3727 "mrbgems/mruby-compiler/core/parse.y" + case 534: +#line 3808 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9444 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9607 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 532: -#line 3731 "mrbgems/mruby-compiler/core/parse.y" + case 535: +#line 3812 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd)); } -#line 9452 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9615 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 533: -#line 3735 "mrbgems/mruby-compiler/core/parse.y" + case 536: +#line 3816 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd)); } -#line 9460 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9623 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 534: -#line 3739 "mrbgems/mruby-compiler/core/parse.y" + case 537: +#line 3820 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd)); } -#line 9468 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9631 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 535: -#line 3743 "mrbgems/mruby-compiler/core/parse.y" + case 538: +#line 3824 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, intern_op(and)); (yyval.nd) = new_args(p, 0, 0, 0, 0, 0); } -#line 9477 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9640 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 536: -#line 3750 "mrbgems/mruby-compiler/core/parse.y" + case 539: +#line 3831 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a constant"); (yyval.nd) = 0; } -#line 9486 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9649 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 537: -#line 3755 "mrbgems/mruby-compiler/core/parse.y" + case 540: +#line 3836 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be an instance variable"); (yyval.nd) = 0; } -#line 9495 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9658 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 538: -#line 3760 "mrbgems/mruby-compiler/core/parse.y" + case 541: +#line 3841 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a global variable"); (yyval.nd) = 0; } -#line 9504 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9667 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 539: -#line 3765 "mrbgems/mruby-compiler/core/parse.y" + case 542: +#line 3846 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a class variable"); (yyval.nd) = 0; } -#line 9513 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9676 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 540: -#line 3770 "mrbgems/mruby-compiler/core/parse.y" + case 543: +#line 3851 "mrbgems/mruby-compiler/core/parse.y" { yyerror(p, "formal argument cannot be a numbered parameter"); (yyval.nd) = 0; } -#line 9522 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9685 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 541: -#line 3777 "mrbgems/mruby-compiler/core/parse.y" + case 544: +#line 3858 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = 0; } -#line 9530 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9693 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 542: -#line 3781 "mrbgems/mruby-compiler/core/parse.y" + case 545: +#line 3862 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[0].id)); (yyval.id) = (yyvsp[0].id); } -#line 9539 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9702 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 543: -#line 3788 "mrbgems/mruby-compiler/core/parse.y" + case 546: +#line 3869 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = new_arg(p, (yyvsp[0].id)); } -#line 9547 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9710 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 544: -#line 3792 "mrbgems/mruby-compiler/core/parse.y" + case 547: +#line 3873 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = local_switch(p); } -#line 9555 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9718 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 545: -#line 3796 "mrbgems/mruby-compiler/core/parse.y" + case 548: +#line 3877 "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 9565 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9728 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 546: -#line 3804 "mrbgems/mruby-compiler/core/parse.y" + case 549: +#line 3885 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9573 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9736 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 547: -#line 3808 "mrbgems/mruby-compiler/core/parse.y" + case 550: +#line 3889 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9581 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9744 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 548: -#line 3814 "mrbgems/mruby-compiler/core/parse.y" + case 551: +#line 3895 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[-1].id)); local_nest(p); (yyval.id) = (yyvsp[-1].id); } -#line 9591 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9754 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 549: -#line 3822 "mrbgems/mruby-compiler/core/parse.y" + case 552: +#line 3903 "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 9601 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9764 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 550: -#line 3830 "mrbgems/mruby-compiler/core/parse.y" + case 553: +#line 3911 "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 9611 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9774 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 551: -#line 3838 "mrbgems/mruby-compiler/core/parse.y" + case 554: +#line 3919 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9619 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9782 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 552: -#line 3842 "mrbgems/mruby-compiler/core/parse.y" + case 555: +#line 3923 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9627 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9790 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 553: -#line 3848 "mrbgems/mruby-compiler/core/parse.y" + case 556: +#line 3929 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); } -#line 9635 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9798 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 554: -#line 3852 "mrbgems/mruby-compiler/core/parse.y" + case 557: +#line 3933 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9643 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9806 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 557: -#line 3862 "mrbgems/mruby-compiler/core/parse.y" + case 560: +#line 3943 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, (yyvsp[0].id)); (yyval.id) = (yyvsp[0].id); } -#line 9652 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9815 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 558: -#line 3867 "mrbgems/mruby-compiler/core/parse.y" + case 561: +#line 3948 "mrbgems/mruby-compiler/core/parse.y" { local_add_f(p, intern_op(mul)); (yyval.id) = -1; } -#line 9661 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9824 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 561: -#line 3878 "mrbgems/mruby-compiler/core/parse.y" + case 564: +#line 3959 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = (yyvsp[0].id); } -#line 9669 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9832 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 562: -#line 3884 "mrbgems/mruby-compiler/core/parse.y" + case 565: +#line 3965 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = (yyvsp[0].id); } -#line 9677 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9840 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 563: -#line 3888 "mrbgems/mruby-compiler/core/parse.y" + case 566: +#line 3969 "mrbgems/mruby-compiler/core/parse.y" { (yyval.id) = 0; } -#line 9685 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9848 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 564: -#line 3894 "mrbgems/mruby-compiler/core/parse.y" + case 567: +#line 3975 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[0].nd); if (!(yyval.nd)) (yyval.nd) = new_nil(p); } -#line 9694 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9857 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 565: -#line 3898 "mrbgems/mruby-compiler/core/parse.y" + case 568: +#line 3979 "mrbgems/mruby-compiler/core/parse.y" {p->lstate = EXPR_BEG;} -#line 9700 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9863 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 566: -#line 3899 "mrbgems/mruby-compiler/core/parse.y" + case 569: +#line 3980 "mrbgems/mruby-compiler/core/parse.y" { if ((yyvsp[-1].nd) == 0) { yyerror(p, "can't define singleton method for ()."); @@ -9723,55 +9886,63 @@ yyreduce: } (yyval.nd) = (yyvsp[-1].nd); } -#line 9727 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9890 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 568: -#line 3925 "mrbgems/mruby-compiler/core/parse.y" + case 571: +#line 4006 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = (yyvsp[-1].nd); } -#line 9735 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9898 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 569: -#line 3931 "mrbgems/mruby-compiler/core/parse.y" + case 572: +#line 4012 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = list1((yyvsp[0].nd)); NODE_LINENO((yyval.nd), (yyvsp[0].nd)); } -#line 9744 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9907 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 570: -#line 3936 "mrbgems/mruby-compiler/core/parse.y" + case 573: +#line 4017 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd)); } -#line 9752 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9915 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 573: -#line 3946 "mrbgems/mruby-compiler/core/parse.y" + case 574: +#line 4023 "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 9762 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9925 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 574: -#line 3952 "mrbgems/mruby-compiler/core/parse.y" + case 575: +#line 4029 "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 9771 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9934 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 575: -#line 3957 "mrbgems/mruby-compiler/core/parse.y" + case 576: +#line 4034 "mrbgems/mruby-compiler/core/parse.y" + { + (yyval.nd) = cons(new_sym(p, (yyvsp[-1].id)), label_reference(p, (yyvsp[-1].id))); + } +#line 9942 "mrbgems/mruby-compiler/core/y.tab.c" + break; + + case 577: +#line 4038 "mrbgems/mruby-compiler/core/parse.y" { void_expr_error(p, (yyvsp[0].nd)); if (typen((yyvsp[-2].nd)->car) == NODE_DSTR) { @@ -9781,67 +9952,67 @@ yyreduce: (yyval.nd) = cons(new_sym(p, new_strsym(p, (yyvsp[-2].nd))), (yyvsp[0].nd)); } } -#line 9785 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9956 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 576: -#line 3967 "mrbgems/mruby-compiler/core/parse.y" + case 578: +#line 4048 "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 9794 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9965 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 589: -#line 3994 "mrbgems/mruby-compiler/core/parse.y" + case 591: +#line 4075 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = '.'; } -#line 9802 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9973 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 590: -#line 3998 "mrbgems/mruby-compiler/core/parse.y" + case 592: +#line 4079 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = 0; } -#line 9810 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9981 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 592: -#line 4005 "mrbgems/mruby-compiler/core/parse.y" + case 594: +#line 4086 "mrbgems/mruby-compiler/core/parse.y" { (yyval.num) = tCOLON2; } -#line 9818 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9989 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 601: -#line 4026 "mrbgems/mruby-compiler/core/parse.y" + case 603: +#line 4107 "mrbgems/mruby-compiler/core/parse.y" {yyerrok;} -#line 9824 "mrbgems/mruby-compiler/core/y.tab.c" +#line 9995 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 604: -#line 4032 "mrbgems/mruby-compiler/core/parse.y" + case 605: +#line 4112 "mrbgems/mruby-compiler/core/parse.y" { p->lineno += (yyvsp[0].num); p->column = 0; } -#line 9833 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10004 "mrbgems/mruby-compiler/core/y.tab.c" break; - case 607: -#line 4043 "mrbgems/mruby-compiler/core/parse.y" + case 609: +#line 4124 "mrbgems/mruby-compiler/core/parse.y" { (yyval.nd) = 0; } -#line 9841 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10012 "mrbgems/mruby-compiler/core/y.tab.c" break; -#line 9845 "mrbgems/mruby-compiler/core/y.tab.c" +#line 10016 "mrbgems/mruby-compiler/core/y.tab.c" default: break; } @@ -10073,7 +10244,7 @@ yyreturn: #endif return yyresult; } -#line 4047 "mrbgems/mruby-compiler/core/parse.y" +#line 4128 "mrbgems/mruby-compiler/core/parse.y" #define pylval (*((YYSTYPE*)(p->ylval))) @@ -10117,7 +10288,7 @@ yyerror_c(parser_state *p, const char *msg, char c) } static void -yywarn(parser_state *p, const char *s) +yywarning(parser_state *p, const char *s) { char* c; size_t n; @@ -10145,12 +10316,6 @@ yywarn(parser_state *p, const char *s) } static void -yywarning(parser_state *p, const char *s) -{ - yywarn(p, s); -} - -static void yywarning_s(parser_state *p, const char *msg, const char *s) { char buf[256]; @@ -12255,10 +12420,10 @@ parser_yylex(parser_state *p) if (last_state == EXPR_FNAME) goto gvar; tokfix(p); { - unsigned long n = strtoul(tok(p), NULL, 10); - if (n > INT_MAX) { - yyerror(p, "capture group index must be <= " MRB_STRINGIZE(INT_MAX)); - return 0; + mrb_int n = mrb_int_read(tok(p), NULL, NULL); + if (n > INT32_MAX) { + yywarning(p, "capture group index too big; always nil"); + return keyword_nil; } pylval.nd = new_nth_ref(p, (int)n); } @@ -12543,6 +12708,7 @@ parser_update_cxt(parser_state *p, mrbc_context *cxt) int i = 0; if (!cxt) return; + if (!p->tree) return; if (intn(p->tree->car) != NODE_SCOPE) return; n0 = n = p->tree->cdr->car; while (n) { @@ -12563,53 +12729,39 @@ MRB_API void mrb_parser_parse(parser_state *p, mrbc_context *c) { struct mrb_jmpbuf buf1; - p->jmp = &buf1; + struct mrb_jmpbuf *prev = p->mrb->jmp; + p->mrb->jmp = &buf1; - MRB_TRY(p->jmp) { + MRB_TRY(p->mrb->jmp) { int n = 1; p->cmd_start = TRUE; p->in_def = p->in_single = 0; p->nerr = p->nwarn = 0; p->lex_strterm = NULL; - parser_init_cxt(p, c); - if (p->mrb->jmp) { - n = yyparse(p); - } - else { - struct mrb_jmpbuf buf2; - - p->mrb->jmp = &buf2; - MRB_TRY(p->mrb->jmp) { - n = yyparse(p); - } - MRB_CATCH(p->mrb->jmp) { - p->nerr++; - } - MRB_END_EXC(p->mrb->jmp); - p->mrb->jmp = 0; - } + n = yyparse(p); if (n != 0 || p->nerr > 0) { p->tree = 0; + p->mrb->jmp = prev; return; } - if (!p->tree) { - p->tree = new_nil(p); - } parser_update_cxt(p, c); if (c && c->dump_result) { mrb_parser_dump(p->mrb, p->tree, 0); } } - MRB_CATCH(p->jmp) { - yyerror(p, "memory allocation error"); + MRB_CATCH(p->mrb->jmp) { p->nerr++; - p->tree = 0; - return; + if (p->mrb->exc == NULL) { + yyerror(p, "memory allocation error"); + p->nerr++; + p->tree = 0; + } } MRB_END_EXC(p->jmp); + p->mrb->jmp = prev; } MRB_API parser_state* @@ -13750,3 +13902,19 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset) } #endif } + +typedef mrb_bool mrb_parser_foreach_top_variable_func(mrb_state *mrb, mrb_sym sym, void *user); +void mrb_parser_foreach_top_variable(mrb_state *mrb, struct mrb_parser_state *p, mrb_parser_foreach_top_variable_func *func, void *user); + +void +mrb_parser_foreach_top_variable(mrb_state *mrb, struct mrb_parser_state *p, mrb_parser_foreach_top_variable_func *func, void *user) +{ + const mrb_ast_node *n = p->tree; + if ((intptr_t)n->car == NODE_SCOPE) { + n = n->cdr->car; + for (; n; n = n->cdr) { + mrb_sym sym = sym(n->car); + if (sym && !func(mrb, sym, user)) break; + } + } +} diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index fe66e0e37..66176c3c1 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -2,7 +2,6 @@ #include <mruby/class.h> #include <mruby/numeric.h> #include <mruby/presym.h> -#include <math.h> #ifdef MRB_NO_FLOAT # error Complex conflicts with 'MRB_NO_FLOAT' configuration @@ -50,7 +49,7 @@ static struct RBasic* complex_alloc(mrb_state *mrb, struct RClass *c, struct mrb_complex **p) { struct RComplex *s; - s = (struct RComplex*)mrb_obj_alloc(mrb, MRB_TT_COMPLEX, c); + s = MRB_OBJ_ALLOC(mrb, MRB_TT_COMPLEX, c); #ifdef COMPLEX_INLINE *p = &s->r; #else @@ -184,7 +183,7 @@ complex_add(mrb_state *mrb, mrb_value x) default: { - mrb_float z = mrb_to_flo(mrb, y); + mrb_float z = mrb_as_float(mrb, y); return mrb_complex_new(mrb, p1->real+z, p1->imaginary); } } @@ -205,7 +204,7 @@ complex_sub(mrb_state *mrb, mrb_value x) default: { - mrb_float z = mrb_to_flo(mrb, y); + mrb_float z = mrb_as_float(mrb, y); return mrb_complex_new(mrb, p1->real-z, p1->imaginary); } } @@ -227,16 +226,12 @@ complex_mul(mrb_state *mrb, mrb_value x) default: { - mrb_float z = mrb_to_flo(mrb, y); + mrb_float z = mrb_as_float(mrb, y); return mrb_complex_new(mrb, p1->real*z, p1->imaginary*z); } } } -#ifndef MRB_NO_FLOAT -mrb_float mrb_div_flo(mrb_float, mrb_float); -#endif - /* Arithmetic on (significand, exponent) pairs avoids premature overflow in complex division */ struct float_pair { @@ -273,7 +268,7 @@ static void div_pair(struct float_pair *q, struct float_pair const *a, struct float_pair const *b) { - q->s = mrb_div_flo(a->s, b->s); + q->s = mrb_div_float(a->s, b->s); q->x = a->x - b->x; } @@ -285,8 +280,8 @@ complex_div(mrb_state *mrb, mrb_value self) a = complex_ptr(mrb, self); if (mrb_type(rhs) != MRB_TT_COMPLEX) { - mrb_float f = mrb_to_flo(mrb, rhs); - return complex_new(mrb, mrb_div_flo(a->real, f), mrb_div_flo(a->imaginary, f)); + mrb_float f = mrb_as_float(mrb, rhs); + return complex_new(mrb, mrb_div_float(a->real, f), mrb_div_float(a->imaginary, f)); } struct float_pair ar, ai, br, bi; @@ -356,7 +351,7 @@ cpx_int_div(mrb_state *mrb, mrb_value x) x = complex_new(mrb, (mrb_float)a, 0); return complex_div(mrb, x); default: - return mrb_float_value(mrb, mrb_div_flo((mrb_float)a, mrb_to_flo(mrb, y))); + return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); } } @@ -381,7 +376,7 @@ cpx_int_quo(mrb_state *mrb, mrb_value x) x = complex_new(mrb, (mrb_float)a, 0); return complex_div(mrb, x); default: - return mrb_float_value(mrb, mrb_div_flo((mrb_float)a, mrb_to_flo(mrb, y))); + return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); } } @@ -395,10 +390,10 @@ cpx_flo_div(mrb_state *mrb, mrb_value x) case MRB_TT_COMPLEX: return complex_div(mrb, complex_new(mrb, a, 0)); case MRB_TT_FLOAT: - a = mrb_div_flo(a, mrb_float(y)); + a = mrb_div_float(a, mrb_float(y)); return mrb_float_value(mrb, a); default: - a = mrb_div_flo(a, mrb_to_flo(mrb, y)); + a = mrb_div_float(a, mrb_as_float(mrb, y)); return mrb_float_value(mrb, a); } } @@ -429,10 +424,10 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb) mrb_define_method(mrb, comp, "/", complex_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, comp, "quo", complex_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, comp, "==", complex_eq, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, mrb->integer_class, "/", cpx_int_div, MRB_ARGS_REQ(1)); /* overrride */ - mrb_define_method(mrb, mrb->integer_class, "quo", cpx_int_quo, MRB_ARGS_REQ(1)); /* overrride */ - mrb_define_method(mrb, mrb->float_class, "/", cpx_flo_div, MRB_ARGS_REQ(1)); /* overrride */ - mrb_define_method(mrb, mrb->float_class, "quo", cpx_flo_div, MRB_ARGS_REQ(1)); /* overrride */ + mrb_define_method(mrb, mrb->integer_class, "/", cpx_int_div, MRB_ARGS_REQ(1)); /* override */ + mrb_define_method(mrb, mrb->integer_class, "quo", cpx_int_quo, MRB_ARGS_REQ(1)); /* override */ + mrb_define_method(mrb, mrb->float_class, "/", cpx_flo_div, MRB_ARGS_REQ(1)); /* override */ + mrb_define_method(mrb, mrb->float_class, "quo", cpx_flo_div, MRB_ARGS_REQ(1)); /* override */ } void diff --git a/mrbgems/mruby-enumerator/mrblib/enumerator.rb b/mrbgems/mruby-enumerator/mrblib/enumerator.rb index f007b8553..5856eb653 100644 --- a/mrbgems/mruby-enumerator/mrblib/enumerator.rb +++ b/mrbgems/mruby-enumerator/mrblib/enumerator.rb @@ -631,7 +631,7 @@ module Kernel # def repeat(n) # raise ArgumentError, "#{n} is negative!" if n < 0 # unless block_given? - # return to_enum(__method__, n) # __method__ is :repeat here + # return to_enum(__callee__, n) do # __callee__ is :repeat here # end # each do |*val| # n.times { yield *val } diff --git a/mrbgems/mruby-error/src/exception.c b/mrbgems/mruby-error/src/exception.c index ca26b8819..ffa7d53bf 100644 --- a/mrbgems/mruby-error/src/exception.c +++ b/mrbgems/mruby-error/src/exception.c @@ -31,7 +31,7 @@ mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t ensure, mrb_gc_arena_restore(mrb, ai); mrb_gc_protect(mrb, result); if (error) { - mrb_exc_raise(mrb, result); /* rethrow catched exceptions */ + mrb_exc_raise(mrb, result); /* rethrow caught exceptions */ } return result; } diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c index 508f5ffcb..c21284bdd 100644 --- a/mrbgems/mruby-eval/src/eval.c +++ b/mrbgems/mruby-eval/src/eval.c @@ -9,10 +9,10 @@ #include <mruby/variable.h> struct REnv *mrb_env_new(mrb_state *mrb, struct mrb_context *c, mrb_callinfo *ci, int nstacks, mrb_value *stack, struct RClass *tc); -mrb_value mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p, mrb_func_t posthook); +mrb_value mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p); mrb_value mrb_obj_instance_eval(mrb_state *mrb, mrb_value self); +mrb_value mrb_mod_module_eval(mrb_state*, mrb_value); void mrb_codedump_all(mrb_state*, struct RProc*); -void mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, const mrb_sym *lv, const mrb_value *stack); static struct RProc* create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value binding, const char *file, mrb_int line) @@ -52,10 +52,19 @@ create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value bi e = NULL; } + if (file) { + if (strlen(file) >= UINT16_MAX) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "filename too long"); + } + } + else { + file = "(eval)"; + } + cxt = mrbc_context_new(mrb); cxt->lineno = (uint16_t)line; - mrbc_filename(mrb, cxt, file ? file : "(eval)"); + mrbc_filename(mrb, cxt, file); cxt->capture_errors = TRUE; cxt->no_optimize = TRUE; cxt->upper = scope && MRB_PROC_CFUNC_P(scope) ? NULL : scope; @@ -64,6 +73,7 @@ create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value bi /* only occur when memory ran out */ if (!p) { + mrbc_context_free(mrb, cxt); mrb_raise(mrb, E_RUNTIME_ERROR, "Failed to create parser state (out of memory)"); } @@ -71,6 +81,11 @@ create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value bi /* parse error */ mrb_value str; + mrbc_context_free(mrb, cxt); + if (!p->error_buffer[0].message) { + mrb_parser_free(p); + mrb_raise(mrb, E_SYNTAX_ERROR, "compile error"); + } if (file) { str = mrb_format(mrb, "file %s line %d: %s", file, @@ -83,7 +98,6 @@ create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value bi p->error_buffer[0].message); } mrb_parser_free(p); - mrbc_context_free(mrb, cxt); mrb_exc_raise(mrb, mrb_exc_new_str(mrb, E_SYNTAX_ERROR, str)); } @@ -127,44 +141,13 @@ create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value bi } static mrb_value -exec_irep(mrb_state *mrb, mrb_value self, struct RProc *proc, mrb_func_t posthook) +exec_irep(mrb_state *mrb, mrb_value self, struct RProc *proc) { /* no argument passed from eval() */ mrb->c->ci->argc = 0; /* clear block */ mrb->c->ci->stack[1] = mrb_nil_value(); - return mrb_exec_irep(mrb, self, proc, posthook); -} - -static void -eval_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, const mrb_sym *lv, const mrb_value *stack) -{ - mrb_assert(mrb->c->stend >= stack + num); - mrb_proc_merge_lvar(mrb, irep, env, num, lv, stack); -} - -static mrb_value -eval_merge_lvar_hook(mrb_state *mrb, mrb_value dummy_self) -{ - const mrb_callinfo *orig_ci = &mrb->c->ci[1]; - const struct RProc *orig_proc = orig_ci->proc; - const mrb_irep *orig_irep = orig_proc->body.irep; - int orig_nlocals = orig_irep->nlocals; - - if (orig_nlocals > 1) { - struct RProc *proc = (struct RProc *)orig_proc->upper; - struct REnv *env = MRB_PROC_ENV(orig_proc); - eval_merge_lvar(mrb, (mrb_irep *)proc->body.irep, env, - orig_nlocals - 1, orig_irep->lv, - mrb->c->ci->stack + 3 /* hook proc + exc + ret val */); - } - - mrb_value exc = mrb->c->ci->stack[1]; - if (!mrb_nil_p(exc)) { - mrb_exc_raise(mrb, exc); - } - - return mrb->c->ci->stack[2]; + return mrb_exec_irep(mrb, self, proc); } static mrb_value @@ -176,30 +159,21 @@ f_eval(mrb_state *mrb, mrb_value self) const char *file = NULL; mrb_int line = 1; struct RProc *proc; - mrb_func_t posthook = NULL; mrb_get_args(mrb, "s|ozi", &s, &len, &binding, &file, &line); proc = create_proc_from_string(mrb, s, len, binding, file, line); if (!mrb_nil_p(binding)) { self = mrb_iv_get(mrb, binding, MRB_SYM(recv)); - if (mrb_env_p(mrb_iv_get(mrb, binding, MRB_SYM(env)))) { - posthook = eval_merge_lvar_hook; - } } mrb_assert(!MRB_PROC_CFUNC_P(proc)); - return exec_irep(mrb, self, proc, posthook); + return exec_irep(mrb, self, proc); } static mrb_value f_instance_eval(mrb_state *mrb, mrb_value self) { - mrb_value b; - mrb_int argc; const mrb_value *argv; - - mrb_get_args(mrb, "*!&", &argv, &argc, &b); - - if (mrb_nil_p(b)) { + if (!mrb_block_given_p(mrb)) { const char *s; mrb_int len; const char *file = NULL; @@ -213,19 +187,44 @@ f_instance_eval(mrb_state *mrb, mrb_value self) MRB_PROC_SET_TARGET_CLASS(proc, mrb_class_ptr(cv)); mrb_assert(!MRB_PROC_CFUNC_P(proc)); mrb_vm_ci_target_class_set(mrb->c->ci, mrb_class_ptr(cv)); - return exec_irep(mrb, self, proc, NULL); + return exec_irep(mrb, self, proc); } else { - mrb_get_args(mrb, "&", &b); + mrb_get_args(mrb, ""); return mrb_obj_instance_eval(mrb, self); } } +static mrb_value +f_class_eval(mrb_state *mrb, mrb_value self) +{ + if (!mrb_block_given_p(mrb)) { + const char *s; + mrb_int len; + const char *file = NULL; + mrb_int line = 1; + struct RProc *proc; + + mrb_get_args(mrb, "s|zi", &s, &len, &file, &line); + proc = create_proc_from_string(mrb, s, len, mrb_nil_value(), file, line); + MRB_PROC_SET_TARGET_CLASS(proc, mrb_class_ptr(self)); + mrb_assert(!MRB_PROC_CFUNC_P(proc)); + mrb_vm_ci_target_class_set(mrb->c->ci, mrb_class_ptr(self)); + return exec_irep(mrb, self, proc); + } + else { + mrb_get_args(mrb, ""); + return mrb_mod_module_eval(mrb, self); + } +} + 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_id(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), MRB_SYM(instance_eval), f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK()); + mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(module_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK()); + mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(class_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK()); } void diff --git a/mrbgems/mruby-eval/test/eval.rb b/mrbgems/mruby-eval/test/eval.rb index e95171223..7e28ade07 100644 --- a/mrbgems/mruby-eval/test/eval.rb +++ b/mrbgems/mruby-eval/test/eval.rb @@ -151,3 +151,14 @@ assert('Access numbered parameter from eval') do hoge.fuga(3) { _1 + eval("_1") } } end + +assert('Module#class_eval with string') do + c = Class.new + c.class_eval "def foo() 42; end" + cc = c.new + assert_true cc.respond_to?(:foo) + assert_equal 42, c.new.foo + + b = c.class_eval("class A; def a; 55; end; end; class B; def b; A; end; end; B") + assert_equal 55, b.new.b.new.a +end diff --git a/mrbgems/mruby-fiber/src/fiber.c b/mrbgems/mruby-fiber/src/fiber.c index 5f45bf04f..141dcc2ed 100644 --- a/mrbgems/mruby-fiber/src/fiber.c +++ b/mrbgems/mruby-fiber/src/fiber.c @@ -7,7 +7,8 @@ #define FIBER_STACK_INIT_SIZE 64 #define FIBER_CI_INIT_SIZE 8 -#define CI_ACC_RESUMED -3 +/* copied from vm.c */ +#define CINFO_RESUMED 3 /* * call-seq: @@ -94,7 +95,6 @@ fiber_init(mrb_state *mrb, mrb_value self) c->stbase = (mrb_value *)mrb_malloc(mrb, slen*sizeof(mrb_value)); c->stend = c->stbase + slen; -#ifdef MRB_NAN_BOXING { mrb_value *p = c->stbase; mrb_value *pend = c->stend; @@ -104,9 +104,6 @@ fiber_init(mrb_state *mrb, mrb_value self) p++; } } -#else - memset(c->stbase, 0, slen * sizeof(mrb_value)); -#endif /* copy receiver from a block */ c->stbase[0] = mrb->c->ci->stack[0]; @@ -160,7 +157,7 @@ fiber_check_cfunc(mrb_state *mrb, struct mrb_context *c) mrb_callinfo *ci; for (ci = c->ci; ci >= c->cibase; ci--) { - if (ci->acc < 0) { + if (ci->cci > 0) { mrb_raise(mrb, E_FIBER_ERROR, "can't cross C function boundary"); } } @@ -226,7 +223,7 @@ fiber_switch(mrb_state *mrb, mrb_value self, mrb_int len, const mrb_value *a, mr else { value = fiber_result(mrb, a, len); if (vmexec) { - c->ci->stack[c->ci[1].acc] = value; + c->ci[1].stack[0] = value; } } @@ -264,7 +261,7 @@ fiber_resume(mrb_state *mrb, mrb_value self) mrb_bool vmexec = FALSE; mrb_get_args(mrb, "*!", &a, &len); - if (mrb->c->ci->acc < 0) { + if (mrb->c->ci->cci > 0) { vmexec = TRUE; } return fiber_switch(mrb, self, len, a, TRUE, vmexec); @@ -357,7 +354,7 @@ mrb_fiber_yield(mrb_state *mrb, mrb_int len, const mrb_value *a) c->prev = NULL; if (c->vmexec) { c->vmexec = FALSE; - mrb->c->ci->acc = CI_ACC_RESUMED; + mrb->c->ci->cci = CINFO_RESUMED; c->ci--; /* pop callinfo for yield */ } MARK_CONTEXT_MODIFY(mrb->c); @@ -397,7 +394,7 @@ static mrb_value fiber_current(mrb_state *mrb, mrb_value self) { if (!mrb->c->fib) { - struct RFiber *f = (struct RFiber*)mrb_obj_alloc(mrb, MRB_TT_FIBER, mrb_class_ptr(self)); + struct RFiber *f = MRB_OBJ_ALLOC(mrb, MRB_TT_FIBER, mrb_class_ptr(self)); f->cxt = mrb->c; mrb->c->fib = f; diff --git a/mrbgems/mruby-hash-ext/mrblib/hash.rb b/mrbgems/mruby-hash-ext/mrblib/hash.rb index 33e2dcb9f..5775913c3 100644 --- a/mrbgems/mruby-hash-ext/mrblib/hash.rb +++ b/mrbgems/mruby-hash-ext/mrblib/hash.rb @@ -116,7 +116,6 @@ class Hash nk.each {|k| h[k] = self[k] } - h self.replace(h) end @@ -256,7 +255,6 @@ class Hash def keep_if(&block) return to_enum :keep_if unless block - keys = [] self.each do |k, v| unless block.call([k, v]) self.delete(k) diff --git a/mrbgems/mruby-io/README.md b/mrbgems/mruby-io/README.md index a518e6169..c07a6e89b 100644 --- a/mrbgems/mruby-io/README.md +++ b/mrbgems/mruby-io/README.md @@ -1,5 +1,4 @@ -mruby-io -======== +# mruby-io `IO` and `File` classes for mruby diff --git a/mrbgems/mruby-io/mrblib/io.rb b/mrbgems/mruby-io/mrblib/io.rb index 645733226..006578222 100644 --- a/mrbgems/mruby-io/mrblib/io.rb +++ b/mrbgems/mruby-io/mrblib/io.rb @@ -209,7 +209,7 @@ class IO end array = [] - while 1 + while true begin _read_buf rescue EOFError @@ -256,7 +256,7 @@ class IO end array = [] - while 1 + while true begin _read_buf rescue EOFError diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c index 03a6a070d..fe7861798 100644 --- a/mrbgems/mruby-io/src/file.c +++ b/mrbgems/mruby-io/src/file.c @@ -14,7 +14,6 @@ #include <sys/stat.h> #include <fcntl.h> -#include <limits.h> #include <errno.h> #include <stdlib.h> @@ -89,7 +88,7 @@ flock(int fd, int operation) { DWORD flags; flags = ((operation & LOCK_NB) ? LOCKFILE_FAIL_IMMEDIATELY : 0) | ((operation & LOCK_SH) ? LOCKFILE_EXCLUSIVE_LOCK : 0); - memset(&ov, 0, sizeof(ov)); + ov = (OVERLAPPED){0}; return LockFileEx(h, flags, 0, 0xffffffff, 0xffffffff, &ov) ? 0 : -1; } #endif @@ -117,14 +116,14 @@ static mrb_value mrb_file_s_unlink(mrb_state *mrb, mrb_value obj) { const mrb_value *argv; - mrb_value pathv; mrb_int argc, i; char *path; mrb_get_args(mrb, "*", &argv, &argc); for (i = 0; i < argc; i++) { const char *utf8_path; - pathv = mrb_ensure_string_type(mrb, argv[i]); + mrb_value pathv = argv[i]; + mrb_ensure_string_type(mrb, pathv); utf8_path = RSTRING_CSTR(mrb, pathv); path = mrb_locale_from_utf8(utf8_path, -1); if (UNLINK(path) < 0) { @@ -497,7 +496,7 @@ mrb_file_truncate(mrb_state *mrb, mrb_value self) mrb_value lenv = mrb_get_arg1(mrb); fd = mrb_io_fileno(mrb, self); - length = mrb_int(mrb, lenv); + length = mrb_as_int(mrb, lenv); if (mrb_ftruncate(fd, length) != 0) { mrb_raise(mrb, E_IO_ERROR, "ftruncate failed"); } diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 234d7b1fc..0c79660a8 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -169,7 +169,7 @@ mrb_io_mode_to_flags(mrb_state *mrb, mrb_value mode) } else { int flags = 0; - mrb_int flags0 = mrb_int(mrb, mode); + mrb_int flags0 = mrb_as_int(mrb, mode); switch (flags0 & MRB_O_ACCMODE) { case MRB_O_RDONLY: @@ -1415,7 +1415,7 @@ mrb_io_sync(mrb_state *mrb, mrb_value self) static off_t value2off(mrb_state *mrb, mrb_value offv) { - return (off_t)mrb_int(mrb, offv); + return (off_t)mrb_as_int(mrb, offv); } /* diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index 7afa6fa5f..5b3dd6b35 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -3,70 +3,73 @@ #include <mruby/array.h> #include <mruby/hash.h> #include <mruby/range.h> +#include <mruby/string.h> +#include <mruby/numeric.h> +#include <mruby/proc.h> #include <mruby/presym.h> static mrb_value mrb_f_caller(mrb_state *mrb, mrb_value self) { - mrb_value bt, v, length; + mrb_value bt, v; mrb_int bt_len, argc, lev, n; + argc = mrb_get_args(mrb, "|oi", &v, &n); + bt = mrb_get_backtrace(mrb); bt_len = RARRAY_LEN(bt); - argc = mrb_get_args(mrb, "|oo", &v, &length); switch (argc) { - case 0: - lev = 1; - n = bt_len - lev; - break; - case 1: - if (mrb_range_p(v)) { - mrb_int beg, len; - if (mrb_range_beg_len(mrb, v, &beg, &len, bt_len, TRUE) == MRB_RANGE_OK) { - lev = beg; - n = len; - } - else { - return mrb_nil_value(); - } + case 0: + lev = 1; + n = bt_len - 1; + break; + case 1: + if (mrb_range_p(v)) { + mrb_int beg, len; + if (mrb_range_beg_len(mrb, v, &beg, &len, bt_len, TRUE) == MRB_RANGE_OK) { + lev = beg; + n = len; } else { - lev = mrb_int(mrb, v); - if (lev < 0) { - mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative level (%v)", v); - } - n = bt_len - lev; + return mrb_nil_value(); } - break; - case 2: - lev = mrb_int(mrb, v); - n = mrb_int(mrb, length); + } + else { + lev = mrb_as_int(mrb, v); if (lev < 0) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative level (%v)", v); } - if (n < 0) { - mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative size (%v)", length); - } - break; - default: - lev = n = 0; - break; + n = bt_len - lev; + } + break; + case 2: + lev = mrb_as_int(mrb, v); + break; + default: + /* not reached */ + lev = n = 0; + break; } - - if (n == 0) { + if (lev >= bt_len) return mrb_nil_value(); + if (lev < 0) { + mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative level (%v)", v); + } + if (n < 0) { + mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative size (%d)", n); + } + if (n == 0 || bt_len <= lev) { return mrb_ary_new(mrb); } - - return mrb_funcall_id(mrb, bt, MRB_OPSYM(aref), 2, mrb_fixnum_value(lev), mrb_fixnum_value(n)); + if (bt_len <= n + lev) n = bt_len - lev - 1; + return mrb_ary_new_from_values(mrb, n, RARRAY_PTR(bt)+lev+1); } /* * call-seq: * __method__ -> symbol * - * Returns the name at the definition of the current method as a - * Symbol. + * Returns the called name of the current method as a Symbol. * If called outside of a method, it returns <code>nil</code>. * */ @@ -75,6 +78,27 @@ mrb_f_method(mrb_state *mrb, mrb_value self) { mrb_callinfo *ci = mrb->c->ci; ci--; + if (ci->proc->e.env->tt == MRB_TT_ENV && ci->proc->e.env->mid) + return mrb_symbol_value(ci->proc->e.env->mid); + else if (ci->mid) + return mrb_symbol_value(ci->mid); + else + return mrb_nil_value(); +} + +/* + * call-seq: + * __callee__ -> symbol + * + * Returns the called name of the current method as a Symbol. + * If called outside of a method, it returns <code>nil</code>. + * + */ +static mrb_value +mrb_f_callee(mrb_state *mrb, mrb_value self) +{ + mrb_callinfo *ci = mrb->c->ci; + ci--; if (ci->mid) return mrb_symbol_value(ci->mid); else @@ -106,11 +130,43 @@ mrb_f_method(mrb_state *mrb, mrb_value self) static mrb_value mrb_f_integer(mrb_state *mrb, mrb_value self) { - mrb_value arg; + mrb_value val, tmp; mrb_int base = 0; - mrb_get_args(mrb, "o|i", &arg, &base); - return mrb_convert_to_integer(mrb, arg, base); + mrb_get_args(mrb, "o|i", &val, &base); + if (mrb_nil_p(val)) { + if (base != 0) goto arg_error; + mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Integer"); + } + switch (mrb_type(val)) { +#ifndef MRB_NO_FLOAT + case MRB_TT_FLOAT: + if (base != 0) goto arg_error; + return mrb_float_to_integer(mrb, val); +#endif + + case MRB_TT_INTEGER: + if (base != 0) goto arg_error; + return val; + + case MRB_TT_STRING: + string_conv: + return mrb_str_to_integer(mrb, val, base, TRUE); + + default: + break; + } + if (base != 0) { + tmp = mrb_obj_as_string(mrb, val); + if (mrb_string_p(tmp)) { + val = tmp; + goto string_conv; + } +arg_error: + mrb_raise(mrb, E_ARGUMENT_ERROR, "base specified for non string value"); + } + /* to raise TypeError */ + return mrb_to_integer(mrb, val); } #ifndef MRB_NO_FLOAT @@ -131,7 +187,7 @@ mrb_f_float(mrb_state *mrb, mrb_value self) { mrb_value arg = mrb_get_arg1(mrb); - return mrb_Float(mrb, arg); + return mrb_to_float(mrb, arg); } #endif @@ -201,7 +257,8 @@ mrb_f_hash(mrb_state *mrb, mrb_value self) if (mrb_nil_p(arg) || (mrb_array_p(arg) && RARRAY_LEN(arg) == 0)) { return mrb_hash_new(mrb); } - return mrb_ensure_hash_type(mrb, arg); + mrb_ensure_hash_type(mrb, arg); + return arg; } void @@ -212,6 +269,7 @@ mrb_mruby_kernel_ext_gem_init(mrb_state *mrb) mrb_define_module_function(mrb, krn, "fail", mrb_f_raise, MRB_ARGS_OPT(2)); 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_method(mrb, krn, "__callee__", mrb_f_callee, MRB_ARGS_NONE()); mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ARG(1,1)); #ifndef MRB_NO_FLOAT mrb_define_module_function(mrb, krn, "Float", mrb_f_float, MRB_ARGS_REQ(1)); diff --git a/mrbgems/mruby-kernel-ext/test/kernel.rb b/mrbgems/mruby-kernel-ext/test/kernel.rb index fc4402b3d..e5876f976 100644 --- a/mrbgems/mruby-kernel-ext/test/kernel.rb +++ b/mrbgems/mruby-kernel-ext/test/kernel.rb @@ -38,17 +38,29 @@ assert('Kernel.caller, Kernel#caller') do end assert('Kernel#__method__') do - assert_equal(:m, Class.new {def m; __method__; end}.new.m) - assert_equal(:m, Class.new {define_method(:m) {__method__}}.new.m) c = Class.new do - [:m1, :m2].each do |m| - define_method(m) do - __method__ - end - end + def m1; __method__ end + define_method(:m2) {__method__} + alias m3 m1 + alias_method :m4, :m2 + end + assert_equal(:m1, c.new.m1) + assert_equal(:m2, c.new.m2) + assert_equal(:m1, c.new.m3) + assert_equal(:m2, c.new.m4) +end + +assert('Kernel#__callee__') do + c = Class.new do + def m1; __callee__ end + define_method(:m2) {__callee__} + alias m3 m1 + alias_method :m4, :m2 end assert_equal(:m1, c.new.m1) assert_equal(:m2, c.new.m2) + assert_equal(:m3, c.new.m3) + assert_equal(:m4, c.new.m4) end assert('Kernel#Integer') do diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c index 0b85b1763..79fdb7c6f 100644 --- a/mrbgems/mruby-math/src/math.c +++ b/mrbgems/mruby-math/src/math.c @@ -12,7 +12,6 @@ #include <mruby/array.h> #include <mruby/presym.h> -#include <math.h> static void domain_error(mrb_state *mrb, const char *func) @@ -25,8 +24,6 @@ domain_error(mrb_state *mrb, const char *func) /* math functions not provided by Microsoft Visual C++ 2012 or older */ #if defined _MSC_VER && _MSC_VER <= 1700 -#include <float.h> - double asinh(double x) { diff --git a/mrbgems/mruby-metaprog/test/metaprog.rb b/mrbgems/mruby-metaprog/test/metaprog.rb index d63913020..4d2651702 100644 --- a/mrbgems/mruby-metaprog/test/metaprog.rb +++ b/mrbgems/mruby-metaprog/test/metaprog.rb @@ -104,6 +104,17 @@ assert('Kernel#global_variables', '15.3.1.3.14') do assert_equal(1, variables2.size - variables1.size) end +assert('Kernel#local_variables', '15.3.1.3.28') do + assert_equal Array, local_variables.class + + def local_var_list + a = "hello" + local_variables + end + + assert_equal [:a], local_var_list +end + assert('Kernel.local_variables', '15.3.1.2.7') do a, b = 0, 1 a += b diff --git a/mrbgems/mruby-method/README.md b/mrbgems/mruby-method/README.md index f299718df..41130bb82 100644 --- a/mrbgems/mruby-method/README.md +++ b/mrbgems/mruby-method/README.md @@ -1,5 +1,4 @@ -mruby-method -=== +# mruby-method An implementation of class **Method** and **UnboundMethod** for mruby diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c index 02eddda9c..02131050d 100644 --- a/mrbgems/mruby-method/src/method.c +++ b/mrbgems/mruby-method/src/method.c @@ -7,7 +7,7 @@ #include "mruby/presym.h" mrb_noreturn void mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args); -mrb_value mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p, mrb_func_t posthook); +mrb_value mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p); static mrb_value args_shift(mrb_state *mrb) @@ -81,7 +81,7 @@ method_missing_prepare(mrb_state *mrb, mrb_sym *mid, mrb_value recv, struct RCla static struct RObject * method_object_alloc(mrb_state *mrb, struct RClass *mclass) { - return (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mclass); + return MRB_OBJ_ALLOC(mrb, MRB_TT_OBJECT, mclass); } static struct RProc* @@ -242,7 +242,7 @@ mcall(mrb_state *mrb, mrb_value self, mrb_value recv) mrb->c->ci->mid = mid; mrb->c->ci->u.target_class = tc; - return mrb_exec_irep(mrb, recv, proc, NULL); + return mrb_exec_irep(mrb, recv, proc); } static mrb_value diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index dbc7f39d9..2f2a6c755 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -1,4 +1,3 @@ -#include <limits.h> #include <mruby.h> #include <mruby/numeric.h> #include <mruby/presym.h> @@ -10,12 +9,12 @@ * Returns +true+ if all bits of <code>+int+ & +mask+</code> are 1. */ static mrb_value -mrb_int_allbits(mrb_state *mrb, mrb_value self) +int_allbits(mrb_state *mrb, mrb_value self) { mrb_int n, m; mrb_get_args(mrb, "i", &m); - n = mrb_int(mrb, self); + n = mrb_integer(self); return mrb_bool_value((n & m) == m); } @@ -26,12 +25,12 @@ mrb_int_allbits(mrb_state *mrb, mrb_value self) * Returns +true+ if any bits of <code>+int+ & +mask+</code> are 1. */ static mrb_value -mrb_int_anybits(mrb_state *mrb, mrb_value self) +int_anybits(mrb_state *mrb, mrb_value self) { mrb_int n, m; mrb_get_args(mrb, "i", &m); - n = mrb_int(mrb, self); + n = mrb_integer(self); return mrb_bool_value((n & m) != 0); } @@ -42,25 +41,85 @@ mrb_int_anybits(mrb_state *mrb, mrb_value self) * Returns +true+ if no bits of <code>+int+ & +mask+</code> are 1. */ static mrb_value -mrb_int_nobits(mrb_state *mrb, mrb_value self) +int_nobits(mrb_state *mrb, mrb_value self) { mrb_int n, m; mrb_get_args(mrb, "i", &m); - n = mrb_int(mrb, self); + n = mrb_integer(self); return mrb_bool_value((n & m) == 0); } +static void +zerodiv(mrb_state *mrb) +{ + mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); +} + +/* + * call-seq: + * num.remainder(numeric) -> real + * + * <code>x.remainder(y)</code> means <code>x-y*(x/y).truncate</code>. + * + * See Numeric#divmod. + */ +static mrb_value +int_remainder(mrb_state *mrb, mrb_value x) +{ + mrb_value y = mrb_get_arg1(mrb); + mrb_int a, b; + + a = mrb_integer(x); + if (mrb_integer_p(y)) { + b = mrb_integer(y); + if (b == 0) zerodiv(mrb); + if (a == MRB_INT_MIN && b == -1) return mrb_fixnum_value(0); + return mrb_int_value(mrb, a % b); + } +#ifdef MRB_NO_FLOAT + mrb_raise(mrb, E_TYPE_ERROR, "non integer remainder"); +#else + mrb_float n = (mrb_float)a; + mrb_float m = mrb_as_float(mrb, y); + + if (isinf(m)) return mrb_float_value(mrb, n); + return mrb_float_value(mrb, n-m*trunc(n/m)); +#endif +} + +#ifndef MRB_NO_FLOAT +static mrb_value +flo_remainder(mrb_state *mrb, mrb_value self) +{ + mrb_float a, b; + + a = mrb_float(self); + mrb_get_args(mrb, "f", &b); + if (b == 0) zerodiv(mrb); + if (isinf(b)) return mrb_float_value(mrb, a); + return mrb_float_value(mrb, a-b*trunc(a/b)); +} +#endif + void mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) { 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)); + mrb_define_method(mrb, i, "allbits?", int_allbits, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, i, "anybits?", int_anybits, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, i, "nobits?", int_nobits, MRB_ARGS_REQ(1)); + + mrb_define_alias(mrb, i, "modulo", "%"); + mrb_define_method(mrb, i, "remainder", int_remainder, MRB_ARGS_REQ(1)); #ifndef MRB_NO_FLOAT + struct RClass *f = mrb_class_get(mrb, "Float"); + + mrb_define_alias(mrb, f, "modulo", "%"); + mrb_define_method(mrb, f, "remainder", flo_remainder, MRB_ARGS_REQ(1)); + 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)); diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c index a65feea6d..69f1763ce 100644 --- a/mrbgems/mruby-object-ext/src/object.c +++ b/mrbgems/mruby-object-ext/src/object.c @@ -103,7 +103,7 @@ mrb_obj_instance_exec(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "*&!", &argv, &argc, &blk); c = mrb_singleton_class_ptr(mrb, self); - if (mrb->c->ci->acc < 0) { + if (mrb->c->ci->cci > 0) { return mrb_yield_with_class(mrb, blk, argc, argv, self, c); } mrb_vm_ci_target_class_set(mrb->c->ci, c); diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c index 9947512cf..b6a25a204 100644 --- a/mrbgems/mruby-os-memsize/src/memsize.c +++ b/mrbgems/mruby-os-memsize/src/memsize.c @@ -88,6 +88,7 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj) mrb_hash_memsize(obj); break; } + case MRB_TT_STRUCT: case MRB_TT_ARRAY: { mrb_int len = RARRAY_LEN(obj); /* Arrays that do not fit within an RArray perform a heap allocation diff --git a/mrbgems/mruby-pack/README.md b/mrbgems/mruby-pack/README.md index efa51cc1b..712cf8e1c 100644 --- a/mrbgems/mruby-pack/README.md +++ b/mrbgems/mruby-pack/README.md @@ -1,5 +1,4 @@ -mruby-pack (pack / unpack) -========= +# mruby-pack (pack / unpack) mruby-pack provides `Array#pack` and `String#unpack` for mruby. @@ -8,41 +7,41 @@ mruby-pack provides `Array#pack` and `String#unpack` for mruby. Add the line below into your build configuration: ``` - conf.gem :github => 'iij/mruby-pack' + conf.gem :core => 'mruby-pack' ``` There is no dependency on other mrbgems. ## Supported template string - - A : arbitrary binary string (space padded, count is width) - - a : arbitrary binary string (null padded, count is width) - - C : 8-bit unsigned (unsigned char) - - c : 8-bit signed (signed char) - - D, d: 64-bit float, native format - - E : 64-bit float, little endian byte order - - e : 32-bit float, little endian byte order - - F, f: 32-bit float, native format - - G : 64-bit float, network (big-endian) byte order - - g : 32-bit float, network (big-endian) byte order - - H : hex string (high nibble first) - - h : hex string (low nibble first) - - I : unsigned integer, native endian (`unsigned int` in C) - - i : signed integer, native endian (`int` in C) - - L : 32-bit unsigned, native endian (`uint32_t`) - - l : 32-bit signed, native endian (`int32_t`) - - m : base64 encoded string (see RFC 2045, count is width) - - N : 32-bit unsigned, network (big-endian) byte order - - n : 16-bit unsigned, network (big-endian) byte order - - Q : 64-bit unsigned, native endian (`uint64_t`) - - q : 64-bit signed, native endian (`int64_t`) - - S : 16-bit unsigned, native endian (`uint16_t`) - - s : 16-bit signed, native endian (`int16_t`) - - U : UTF-8 character - - V : 32-bit unsigned, VAX (little-endian) byte order - - v : 16-bit unsigned, VAX (little-endian) byte order - - x : null byte - - Z : same as "a", except that null is added with * +- A : arbitrary binary string (space padded, count is width) +- a : arbitrary binary string (null padded, count is width) +- C : 8-bit unsigned (unsigned char) +- c : 8-bit signed (signed char) +- D, d: 64-bit float, native format +- E : 64-bit float, little endian byte order +- e : 32-bit float, little endian byte order +- F, f: 32-bit float, native format +- G : 64-bit float, network (big-endian) byte order +- g : 32-bit float, network (big-endian) byte order +- H : hex string (high nibble first) +- h : hex string (low nibble first) +- I : unsigned integer, native endian (`unsigned int` in C) +- i : signed integer, native endian (`int` in C) +- L : 32-bit unsigned, native endian (`uint32_t`) +- l : 32-bit signed, native endian (`int32_t`) +- m : base64 encoded string (see RFC 2045, count is width) +- N : 32-bit unsigned, network (big-endian) byte order +- n : 16-bit unsigned, network (big-endian) byte order +- Q : 64-bit unsigned, native endian (`uint64_t`) +- q : 64-bit signed, native endian (`int64_t`) +- S : 16-bit unsigned, native endian (`uint16_t`) +- s : 16-bit signed, native endian (`int16_t`) +- U : UTF-8 character +- V : 32-bit unsigned, VAX (little-endian) byte order +- v : 16-bit unsigned, VAX (little-endian) byte order +- x : null byte +- Z : same as "a", except that null is added with * ## License diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index e52171d6b..f0d4b8d9e 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -18,18 +18,23 @@ #define INT_OVERFLOW_P(n) ((n) < MRB_INT_MIN || (n) > MRB_INT_MAX) #define UINT_OVERFLOW_P(n) ((n) > MRB_INT_MAX) +#ifndef EOF +# define EOF (-1) /* for MRB_NO_STDIO */ +#endif + struct tmpl { mrb_value str; int idx; }; -enum { +enum pack_dir { PACK_DIR_CHAR, /* C */ PACK_DIR_SHORT, /* S */ PACK_DIR_LONG, /* L */ PACK_DIR_QUAD, /* Q */ //PACK_DIR_INT, /* i */ //PACK_DIR_VAX, + PACK_DIR_BER, /* w */ PACK_DIR_UTF8, /* U */ //PACK_DIR_BER, PACK_DIR_DOUBLE, /* E */ @@ -37,30 +42,33 @@ enum { PACK_DIR_STR, /* A */ PACK_DIR_HEX, /* h */ PACK_DIR_BASE64, /* m */ + PACK_DIR_QENC, /* M */ PACK_DIR_NUL, /* x */ + PACK_DIR_BACK, /* X */ + PACK_DIR_ABS, /* @ */ PACK_DIR_INVALID }; -enum { +enum pack_type { PACK_TYPE_INTEGER, PACK_TYPE_FLOAT, PACK_TYPE_STRING, PACK_TYPE_NONE }; -#define PACK_FLAG_s 0x00000001 /* native size ("_" "!") */ -#define PACK_FLAG_a 0x00000002 /* null padding ("a") */ -#define PACK_FLAG_Z 0x00000004 /* append nul char ("z") */ -#define PACK_FLAG_SIGNED 0x00000008 /* native size ("_" "!") */ -#define PACK_FLAG_GT 0x00000010 /* big endian (">") */ -#define PACK_FLAG_LT 0x00000020 /* little endian ("<") */ -#define PACK_FLAG_WIDTH 0x00000040 /* "count" is "width" */ -#define PACK_FLAG_LSB 0x00000080 /* LSB / low nibble first */ -#define PACK_FLAG_COUNT2 0x00000100 /* "count" is special... */ -#define PACK_FLAG_LITTLEENDIAN 0x00000200 /* little endian actually */ +#define PACK_FLAG_s 0x00000001 /* native size ("_" "!") */ +#define PACK_FLAG_a 0x00000002 /* null padding ("a") */ +#define PACK_FLAG_Z 0x00000004 /* append nul char ("z") */ +#define PACK_FLAG_SIGNED 0x00000008 /* native size ("_" "!") */ +#define PACK_FLAG_GT 0x00000010 /* big endian (">") */ +#define PACK_FLAG_LT 0x00000020 /* little endian ("<") */ +#define PACK_FLAG_WIDTH 0x00000040 /* "count" is "width" */ +#define PACK_FLAG_LSB 0x00000080 /* LSB / low nibble first */ +#define PACK_FLAG_COUNT2 0x00000100 /* "count" is special... */ +#define PACK_FLAG_LITTLEENDIAN 0x00000200 /* little endian actually */ -#define PACK_BASE64_IGNORE 0xff -#define PACK_BASE64_PADDING 0xfe +#define PACK_BASE64_IGNORE 0xff +#define PACK_BASE64_PADDING 0xfe const static unsigned char base64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; @@ -76,7 +84,7 @@ hex2int(unsigned char ch) else if (ch >= 'a' && ch <= 'f') return 10 + (ch - 'a'); else - return 0; + return -1; } static void @@ -113,7 +121,7 @@ str_len_ensure(mrb_state *mrb, mrb_value str, mrb_int len) static int -pack_c(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) +pack_char(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_integer(o); @@ -121,7 +129,7 @@ pack_c(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl } static int -unpack_c(mrb_state *mrb, const void *src, int srclen, mrb_value ary, unsigned int flags) +unpack_char(mrb_state *mrb, const void *src, int srclen, mrb_value ary, unsigned int flags) { if (flags & PACK_FLAG_SIGNED) mrb_ary_push(mrb, ary, mrb_fixnum_value(*(signed char *)src)); @@ -131,7 +139,7 @@ unpack_c(mrb_state *mrb, const void *src, int srclen, mrb_value ary, unsigned in } static int -pack_s(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) +pack_short(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) { uint16_t n; @@ -148,7 +156,7 @@ pack_s(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl } static int -unpack_s(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, unsigned int flags) +unpack_short(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, unsigned int flags) { int n; @@ -165,7 +173,7 @@ unpack_s(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un } static int -pack_l(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) +pack_long(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) { uint32_t n; @@ -219,7 +227,7 @@ u32tostr(char *buf, size_t len, uint32_t n) #endif /* MRB_INT64 */ static int -unpack_l(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, unsigned int flags) +unpack_long(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, unsigned int flags) { #ifndef MRB_INT64 char msg[60]; @@ -254,7 +262,7 @@ unpack_l(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un } static int -pack_q(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) +pack_quad(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) { uint64_t n; @@ -336,7 +344,7 @@ i64tostr(char *buf, size_t len, int64_t n) #endif /* MRB_INT64 */ static int -unpack_q(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, unsigned int flags) +unpack_quad(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, unsigned int flags) { char msg[60]; uint64_t ull; @@ -375,6 +383,46 @@ unpack_q(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un return 8; } +static int +pack_BER(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) +{ + mrb_int n = mrb_integer(o); + size_t i; + char *p; + + if (n < 0) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "can't compress negative numbers"); + } + for (i=1; i<sizeof(mrb_int)+1; i++) { + mrb_int mask = ~((1L<<(7*i))-1); + if ((n & mask) == 0) break; + } + str = str_len_ensure(mrb, str, sidx + i); + p = RSTRING_PTR(str)+sidx; + for (size_t j=i; j>0; p++,j--) { + mrb_int x = (n>>(7*(j-1)))&0x7f; + *p = (char)x; + if (j > 1) *p |= 0x80; + } + return i; +} + +static int +unpack_BER(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, unsigned int flags) +{ + mrb_int i, n = 0; + const unsigned char *p = src; + const unsigned char *e = p + srclen; + + for (i=1; p<e; p++,i++) { + n <<= 7; + n |= *p & 0x7f; + if ((*p & 0x80) == 0) break; + } + mrb_ary_push(mrb, ary, mrb_int_value(mrb, n)); + return i; +} + #ifndef MRB_NO_FLOAT static int pack_double(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) @@ -504,7 +552,7 @@ unpack_float(mrb_state *mrb, const unsigned char * src, int srclen, mrb_value ar #endif static int -pack_utf8(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, long count, unsigned int flags) +pack_utf8(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, int count, unsigned int flags) { char utf8[4]; int len = 0; @@ -621,7 +669,7 @@ unpack_utf8(mrb_state *mrb, const unsigned char * src, int srclen, mrb_value ary } static int -pack_a(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, unsigned int flags) +pack_str(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count, unsigned int flags) { mrb_int copylen, slen, padlen; char *dptr, *dptr0, pad, *sptr; @@ -659,7 +707,7 @@ pack_a(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, u } static int -unpack_a(mrb_state *mrb, const void *src, int slen, mrb_value ary, long count, unsigned int flags) +unpack_str(mrb_state *mrb, const void *src, int slen, mrb_value ary, int count, unsigned int flags) { mrb_value dst; const char *cp, *sptr; @@ -693,7 +741,7 @@ unpack_a(mrb_state *mrb, const void *src, int slen, mrb_value ary, long count, u static int -pack_h(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, unsigned int flags) +pack_hex(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count, unsigned int flags) { unsigned int a, ashift, b, bshift; long slen; @@ -724,10 +772,12 @@ pack_h(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, u a = b = 0; if (slen > 0) { a = hex2int(*sptr++); + if (a < 0) break; slen--; } if (slen > 0) { b = hex2int(*sptr++); + if (b < 0) break; slen--; } *dptr++ = (a << ashift) + (b << bshift); @@ -737,7 +787,7 @@ pack_h(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, u } static int -unpack_h(mrb_state *mrb, const void *src, int slen, mrb_value ary, int count, unsigned int flags) +unpack_hex(mrb_state *mrb, const void *src, int slen, mrb_value ary, int count, unsigned int flags) { mrb_value dst; int a, ashift, b, bshift; @@ -783,9 +833,8 @@ unpack_h(mrb_state *mrb, const void *src, int slen, mrb_value ary, int count, un return (int)(sptr - sptr0); } - static int -pack_m(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, unsigned int flags) +pack_base64(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count) { mrb_int dstlen; unsigned long l; @@ -851,7 +900,7 @@ pack_m(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, u } static int -unpack_m(mrb_state *mrb, const void *src, int slen, mrb_value ary, unsigned int flags) +unpack_base64(mrb_state *mrb, const void *src, int slen, mrb_value ary) { mrb_value dst; int dlen; @@ -874,13 +923,13 @@ unpack_m(mrb_state *mrb, const void *src, int slen, mrb_value ary, unsigned int if (slen-- == 0) goto done; c = *sptr++; - if (c >= sizeof(base64_dec_tab)) - continue; - ch[i] = base64_dec_tab[c]; - if (ch[i] == PACK_BASE64_PADDING) { - ch[i] = 0; - padding++; - } + if (c >= sizeof(base64_dec_tab)) + continue; + ch[i] = base64_dec_tab[c]; + if (ch[i] == PACK_BASE64_PADDING) { + ch[i] = 0; + padding++; + } } while (c >= sizeof(base64_dec_tab) || ch[i] == PACK_BASE64_IGNORE); } @@ -907,25 +956,117 @@ done: } static int -pack_x(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, long count, unsigned int flags) +pack_qenc(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count) +{ + static const char hex_table[] = "0123456789ABCDEF"; + char buff[1024]; + char *s = RSTRING_PTR(src); + char *send = s + RSTRING_LEN(src); + int i = 0, n = 0, prev = EOF; + int dlen = 0; + + if (count <= 1) count = 72; + while (s < send) { + if ((*s > 126) || + (*s < 32 && *s != '\n' && *s != '\t') || + (*s == '=')) { + buff[i++] = '='; + buff[i++] = hex_table[(*s & 0xf0) >> 4]; + buff[i++] = hex_table[*s & 0x0f]; + n += 3; + prev = EOF; + } + else if (*s == '\n') { + if (prev == ' ' || prev == '\t') { + buff[i++] = '='; + buff[i++] = *s; + } + buff[i++] = *s; + n = 0; + prev = *s; + } + else { + buff[i++] = *s; + n++; + prev = *s; + } + if (n > count) { + buff[i++] = '='; + buff[i++] = '\n'; + n = 0; + prev = '\n'; + } + if (i > 1024 - 5) { + str_len_ensure(mrb, dst, didx+dlen+i); + memcpy(RSTRING_PTR(dst)+didx+dlen, buff, i); + dlen += i; + i = 0; + } + s++; + } + if (n > 0) { + buff[i++] = '='; + buff[i++] = '\n'; + } + if (i > 0) { + str_len_ensure(mrb, dst, didx+dlen+i); + memcpy(RSTRING_PTR(dst)+didx+dlen, buff, i); + dlen += i; + } + return dlen; +} + +static int +unpack_qenc(mrb_state *mrb, const void *src, int slen, mrb_value ary) +{ + mrb_value buf = mrb_str_new(mrb, 0, slen); + const char *s = (const char*)src, *ss = s; + const char *send = s + slen; + char *ptr = RSTRING_PTR(buf); + int c1, c2; + + while (s < send) { + if (*s == '=') { + if (++s == send) break; + if (s+1 < send && *s == '\r' && *(s+1) == '\n') + s++; + if (*s != '\n') { + if ((c1 = hex2int(*s)) == -1) break; + if (++s == send) break; + if ((c2 = hex2int(*s)) == -1) break; + *ptr++ = (char)(c1 << 4 | c2); + } + } + else { + *ptr++ = *s; + } + s++; + ss = s; + } + buf = mrb_str_resize(mrb, buf, (mrb_int)(ptr - RSTRING_PTR(buf))); + mrb_str_cat(mrb, buf, ss, send-ss); + mrb_ary_push(mrb, ary, buf); + return slen; +} + +static int +pack_nul(mrb_state *mrb, mrb_value dst, mrb_int didx, int count) { long i; - if (count < 0) return 0; dst = str_len_ensure(mrb, dst, didx + count); for (i = 0; i < count; i++) { RSTRING_PTR(dst)[didx + i] = '\0'; } return count; } -static int -unpack_x(mrb_state *mrb, const void *src, int slen, mrb_value ary, int count, unsigned int flags) + +static void +check_x(mrb_state *mrb, int a, int count, char c) { - if (count < 0) return slen; - if (slen < count) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "x outside of string"); + if (a < count) { + mrb_raisef(mrb, E_ARGUMENT_ERROR, "%c outside of string", c); } - return count; } static void @@ -942,10 +1083,12 @@ has_tmpl(const struct tmpl *tmpl) } static void -read_tmpl(mrb_state *mrb, struct tmpl *tmpl, int *dirp, int *typep, int *sizep, int *countp, unsigned int *flagsp) +read_tmpl(mrb_state *mrb, struct tmpl *tmpl, enum pack_dir *dirp, enum pack_type *typep, int *sizep, int *countp, unsigned int *flagsp) { mrb_int t, tlen; - int ch, dir, type, size = 0; + int ch, size = 0; + enum pack_dir dir; + enum pack_type type; int count = 1; unsigned int flags = 0; const char *tptr; @@ -1052,11 +1195,21 @@ alias: size = 4; flags |= PACK_FLAG_SIGNED; break; + case 'w': + dir = PACK_DIR_BER; + type = PACK_TYPE_INTEGER; + flags |= PACK_FLAG_SIGNED; + break; case 'm': dir = PACK_DIR_BASE64; type = PACK_TYPE_STRING; flags |= PACK_FLAG_WIDTH | PACK_FLAG_COUNT2; break; + case 'M': + dir = PACK_DIR_QENC; + type = PACK_TYPE_STRING; + flags |= PACK_FLAG_WIDTH | PACK_FLAG_COUNT2; + break; case 'N': /* = "L>" */ dir = PACK_DIR_LONG; type = PACK_TYPE_INTEGER; @@ -1111,11 +1264,23 @@ alias: dir = PACK_DIR_NUL; type = PACK_TYPE_NONE; break; + case 'X': + dir = PACK_DIR_BACK; + type = PACK_TYPE_NONE; + break; + case '@': + dir = PACK_DIR_ABS; + type = PACK_TYPE_NONE; + break; case 'Z': dir = PACK_DIR_STR; type = PACK_TYPE_STRING; flags |= PACK_FLAG_WIDTH | PACK_FLAG_COUNT2 | PACK_FLAG_Z; break; + case 'p': case 'P': + case '%': + mrb_raisef(mrb, E_ARGUMENT_ERROR, "%c is not supported", (char)t); + break; default: dir = PACK_DIR_INVALID; type = PACK_TYPE_NONE; @@ -1124,19 +1289,21 @@ alias: /* read suffix [0-9*_!<>] */ while (tmpl->idx < tlen) { - ch = tptr[tmpl->idx++]; + ch = tptr[tmpl->idx]; if (ISDIGIT(ch)) { - count = ch - '0'; - while (tmpl->idx < tlen && ISDIGIT(tptr[tmpl->idx])) { - int ch = tptr[tmpl->idx++] - '0'; - if (count+ch > INT_MAX/10) { - mrb_raise(mrb, E_RUNTIME_ERROR, "too big template length"); - } - count = count * 10 + ch; + char *e; + mrb_int n = mrb_int_read(tptr+tmpl->idx, tptr+tlen, &e); + if (e == NULL || n > INT_MAX) { + mrb_raise(mrb, E_RUNTIME_ERROR, "too big template length"); } - continue; /* special case */ + count = (int)n; + tmpl->idx = e - tptr; + continue; } else if (ch == '*') { - count = -1; + if (type == PACK_TYPE_NONE) + count = 0; + else + count = -1; } else if (ch == '_' || ch == '!' || ch == '<' || ch == '>') { if (strchr("sSiIlLqQ", (int)t) == NULL) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "'%c' allowed only after types sSiIlLqQ", ch); @@ -1148,10 +1315,11 @@ alias: } else if (ch == '>') { flags |= PACK_FLAG_GT; } - } else { - tmpl->idx--; + } + else { break; } + tmpl->idx++; } if ((flags & PACK_FLAG_LT) || (!(flags & PACK_FLAG_GT) && littleendian)) { @@ -1173,7 +1341,9 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) struct tmpl tmpl; int count; unsigned int flags; - int dir, ridx, size, type; + enum pack_dir dir; + enum pack_type type; + int ridx, size; prepare_tmpl(mrb, &tmpl); @@ -1186,8 +1356,22 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) if (dir == PACK_DIR_INVALID) continue; else if (dir == PACK_DIR_NUL) { - ridx += pack_x(mrb, mrb_nil_value(), result, ridx, count, flags); - if (ridx < 0) goto overflow; + grow: + if (ridx > INT_MAX - count) goto overflow; + ridx += pack_nul(mrb, result, ridx, count); + continue; + } + else if (dir == PACK_DIR_BACK) { + check_x(mrb, ridx, count, 'X'); + ridx -= count; + continue; + } + else if (dir == PACK_DIR_ABS) { + count -= ridx; + if (count > 0) goto grow; + count = -count; + check_x(mrb, ridx, count, '@'); + ridx -= count; continue; } @@ -1200,12 +1384,12 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) o = mrb_ary_ref(mrb, ary, aidx); if (type == PACK_TYPE_INTEGER) { - o = mrb_to_int(mrb, o); + o = mrb_to_integer(mrb, o); } #ifndef MRB_NO_FLOAT else if (type == PACK_TYPE_FLOAT) { if (!mrb_float_p(o)) { - mrb_float f = mrb_to_flo(mrb, o); + mrb_float f = mrb_as_float(mrb, o); o = mrb_float_value(mrb, f); } } @@ -1218,25 +1402,31 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) switch (dir) { case PACK_DIR_CHAR: - ridx += pack_c(mrb, o, result, ridx, flags); + ridx += pack_char(mrb, o, result, ridx, flags); break; case PACK_DIR_SHORT: - ridx += pack_s(mrb, o, result, ridx, flags); + ridx += pack_short(mrb, o, result, ridx, flags); break; case PACK_DIR_LONG: - ridx += pack_l(mrb, o, result, ridx, flags); + ridx += pack_long(mrb, o, result, ridx, flags); break; case PACK_DIR_QUAD: - ridx += pack_q(mrb, o, result, ridx, flags); + ridx += pack_quad(mrb, o, result, ridx, flags); + break; + case PACK_DIR_BER: + ridx += pack_BER(mrb, o, result, ridx, flags); break; case PACK_DIR_BASE64: - ridx += pack_m(mrb, o, result, ridx, count, flags); + ridx += pack_base64(mrb, o, result, ridx, count); + break; + case PACK_DIR_QENC: + ridx += pack_qenc(mrb, o, result, ridx, count); break; case PACK_DIR_HEX: - ridx += pack_h(mrb, o, result, ridx, count, flags); + ridx += pack_hex(mrb, o, result, ridx, count, flags); break; case PACK_DIR_STR: - ridx += pack_a(mrb, o, result, ridx, count, flags); + ridx += pack_str(mrb, o, result, ridx, count, flags); break; #ifndef MRB_NO_FLOAT case PACK_DIR_DOUBLE: @@ -1252,7 +1442,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) default: break; } - if (dir == PACK_DIR_STR || dir == PACK_DIR_BASE64 || dir == PACK_DIR_HEX) { + if (flags & PACK_FLAG_COUNT2) { /* always consumes 1 entry */ aidx++; break; @@ -1278,7 +1468,9 @@ pack_unpack(mrb_state *mrb, mrb_value str, int single) struct tmpl tmpl; int count; unsigned int flags; - int dir, size, type; + enum pack_dir dir; + enum pack_type type; + int size; int srcidx, srclen; const unsigned char *sptr; @@ -1294,24 +1486,39 @@ pack_unpack(mrb_state *mrb, mrb_value str, int single) if (dir == PACK_DIR_INVALID) continue; else if (dir == PACK_DIR_NUL) { - srcidx += unpack_x(mrb, sptr, srclen - srcidx, result, count, flags); + check_x(mrb, srclen-srcidx, count, 'x'); + srcidx += count; + continue; + } + else if (dir == PACK_DIR_BACK) { + check_x(mrb, srcidx, count, 'X'); + srcidx -= count; + continue; + } + else if (dir == PACK_DIR_ABS) { + check_x(mrb, srclen, count, '@'); + srcidx = count; continue; } - if (flags & PACK_FLAG_COUNT2) { - sptr = (const unsigned char *)RSTRING_PTR(str) + srcidx; - switch (dir) { - case PACK_DIR_HEX: - srcidx += unpack_h(mrb, sptr, srclen - srcidx, result, count, flags); - break; - case PACK_DIR_STR: - srcidx += unpack_a(mrb, sptr, srclen - srcidx, result, count, flags); - break; - case PACK_DIR_BASE64: - srcidx += unpack_m(mrb, sptr, srclen - srcidx, result, flags); - break; - } + /* PACK_FLAG_COUNT2 directions */ + sptr = (const unsigned char *)RSTRING_PTR(str) + srcidx; + switch (dir) { + case PACK_DIR_HEX: + srcidx += unpack_hex(mrb, sptr, srclen - srcidx, result, count, flags); + continue; + case PACK_DIR_STR: + srcidx += unpack_str(mrb, sptr, srclen - srcidx, result, count, flags); continue; + case PACK_DIR_BASE64: + srcidx += unpack_base64(mrb, sptr, srclen - srcidx, result); + continue; + break; + case PACK_DIR_QENC: + srcidx += unpack_qenc(mrb, sptr, srclen - srcidx, result); + continue; + default: + break; } while (count != 0) { @@ -1325,16 +1532,19 @@ pack_unpack(mrb_state *mrb, mrb_value str, int single) sptr = (const unsigned char*)RSTRING_PTR(str) + srcidx; switch (dir) { case PACK_DIR_CHAR: - srcidx += unpack_c(mrb, sptr, srclen - srcidx, result, flags); + srcidx += unpack_char(mrb, sptr, srclen - srcidx, result, flags); break; case PACK_DIR_SHORT: - srcidx += unpack_s(mrb, sptr, srclen - srcidx, result, flags); + srcidx += unpack_short(mrb, sptr, srclen - srcidx, result, flags); break; case PACK_DIR_LONG: - srcidx += unpack_l(mrb, sptr, srclen - srcidx, result, flags); + srcidx += unpack_long(mrb, sptr, srclen - srcidx, result, flags); break; case PACK_DIR_QUAD: - srcidx += unpack_q(mrb, sptr, srclen - srcidx, result, flags); + srcidx += unpack_quad(mrb, sptr, srclen - srcidx, result, flags); + break; + case PACK_DIR_BER: + srcidx += unpack_BER(mrb, sptr, srclen - srcidx, result, flags); break; #ifndef MRB_NO_FLOAT case PACK_DIR_FLOAT: diff --git a/mrbgems/mruby-pack/test/pack.rb b/mrbgems/mruby-pack/test/pack.rb index a248174a5..16db6607b 100644 --- a/mrbgems/mruby-pack/test/pack.rb +++ b/mrbgems/mruby-pack/test/pack.rb @@ -10,78 +10,59 @@ def assert_pack tmpl, packed, unpacked end # pack & unpack 'm' (base64) -assert('[""].pack("m")') do +assert('pack("m")') do assert_pack "m", "", [""] -end - -assert('["\0"].pack("m")') do assert_pack "m", "AA==\n", ["\0"] -end - -assert('["\0\0"].pack("m")') do assert_pack "m", "AAA=\n", ["\0\0"] -end - -assert('["\0\0\0"].pack("m")') do assert_pack "m", "AAAA\n", ["\0\0\0"] -end - -assert('["abc..xyzABC..XYZ"].pack("m")') do assert_pack "m", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n", ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"] -end -assert('"YWJ...".unpack("m") should "abc..xyzABC..XYZ"') do ary = ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"] assert_equal ary, "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n".unpack("m") assert_equal ary, "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==\n".unpack("m") -end -assert('["A", "B"].pack') do assert_equal "QQ==\n", ["A", "B"].pack("m50") assert_equal ["A"], "QQ==\n".unpack("m50") assert_equal "QQ==Qg==", ["A", "B"].pack("m0 m0") assert_equal ["A", "B"], "QQ==Qg==".unpack("m10 m10") + assert_pack "m0", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==", ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"] end -assert('["abc..xyzABC..XYZ"].pack("m0")') do - assert_pack "m0", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==", ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"] +# pack & unpack 'M' (Quoted-printable) +assert('pack("M")') do + assert_pack "M", "123=\n", ["123"] + assert_pack "M", "=3D\n", ["=\n"] + assert_pack "M", "=E3=81=82=\n", ["あ"] + + assert_equal ["123"], "123=\n".unpack("M") + assert_equal ["=\n"], "=3D\n".unpack("M") + assert_equal ["あ"], "=E3=81=82=\n".unpack("M") end # pack & unpack 'H' -assert('["3031"].pack("H*")') do +assert('pack("H")') do assert_pack "H*", "01", ["3031"] -end - -assert('["10"].pack("H*")') do assert_pack "H*", "\020", ["10"] end -assert('[0,1,127,128,255].pack("C*")') do +assert('pack("C")') do assert_pack "C*", "\x00\x01\x7F\x80\xFF", [0, 1, 127, 128, 255] end -# pack "a" -assert('["abc"].pack("a")') do +assert('pack("a")') do assert_equal "a", ["abc"].pack("a") assert_equal "abc", ["abc"].pack("a*") assert_equal "abc\0", ["abc"].pack("a4") -end -# upack "a" -assert('["abc"].pack("a")') do assert_equal ["abc\0"], "abc\0".unpack("a4") assert_equal ["abc "], "abc ".unpack("a4") end -# pack "A" -assert('["abc"].pack("A")') do +assert('pack("A")') do assert_equal "a", ["abc"].pack("A") assert_equal "abc", ["abc"].pack("A*") assert_equal "abc ", ["abc"].pack("A4") -end -# upack "A" -assert('["abc"].pack("A")') do assert_equal ["abc"], "abc\0".unpack("A4") assert_equal ["abc"], "abc ".unpack("A4") end @@ -143,6 +124,12 @@ assert 'pack/unpack "I"' do assert_pack 'I', str, [12345] end +assert 'pack/unpack "w"' do + for x in [0,1,127,128,16383,16384,65535,65536] + assert_equal [x], [x].pack("w").unpack("w") + end +end + assert 'pack/unpack "U"' do assert_equal [], "".unpack("U") assert_equal [], "".unpack("U*") diff --git a/mrbgems/mruby-print/src/print.c b/mrbgems/mruby-print/src/print.c index c98bfb7bf..789808deb 100644 --- a/mrbgems/mruby-print/src/print.c +++ b/mrbgems/mruby-print/src/print.c @@ -6,7 +6,6 @@ #include <mruby/string.h> #include <string.h> -#include <stdlib.h> #if defined(_WIN32) # include <windows.h> # include <io.h> diff --git a/mrbgems/mruby-proc-binding/src/proc-binding.c b/mrbgems/mruby-proc-binding/src/proc-binding.c index 82d9d1d51..d176034d2 100644 --- a/mrbgems/mruby-proc-binding/src/proc-binding.c +++ b/mrbgems/mruby-proc-binding/src/proc-binding.c @@ -3,8 +3,6 @@ #include <mruby/proc.h> #include <mruby/variable.h> -void mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, const mrb_sym *lv, const mrb_value *stack); - /* provided by mruby-proc-ext */ mrb_value mrb_proc_source_location(mrb_state *mrb, struct RProc *p); diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index 9712fbd7e..027e7ce0b 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -22,8 +22,6 @@ worldwide. This software is distributed without any warranty. See <https://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 @@ -60,12 +58,17 @@ rand_init(rand_state *t) #endif } +static uint32_t rand_uint32(rand_state *state); + static uint32_t rand_seed(rand_state *t, uint32_t seed) { uint32_t old_seed = t->seed[SEEDPOS]; rand_init(t); t->seed[SEEDPOS] = seed; + for (int i = 0; i < 10; i++) { + rand_uint32(t); + } return old_seed; } @@ -151,14 +154,6 @@ get_opt(mrb_state* mrb) return arg; } -static void -random_check(mrb_state *mrb, mrb_value 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"); - } -} - static mrb_value random_default(mrb_state *mrb) { struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random)); @@ -229,47 +224,13 @@ static mrb_value mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary) { mrb_int i, max; - mrb_value r = mrb_nil_value(); rand_state *random; - /* - * MSC compiler bug generating invalid instructions with optimization - * enabled. MSC errantly uses a hardcoded value with optimizations on - * when using a fixed value from a union. - * Creating a temp volatile variable and reassigning back to the original - * value tricks the compiler to not perform this optimization; - */ -#if defined _MSC_VER && _MSC_VER >= 1923 - /* C++ will not cast away volatile easily, so we cannot do something like - * volatile mrb_value rr = r; r = (mrb_value)rr; with C++. - * That cast does work with C. - * We also have to trick the compiler to not optimize away the const_cast entirely - * by creating and manipulating an intermediate volatile pointer. - */ - volatile mrb_value *v_r; - volatile mrb_int ii; - mrb_value *p_r; - v_r = &r; - ii = 2; - v_r = v_r + 2; -#if defined __cplusplus - p_r = const_cast<mrb_value*>(v_r - ii); -#else - p_r = (mrb_value*)v_r - ii; -#endif - r = *p_r; -#endif - if (RARRAY_LEN(ary) > 1) { - mrb_get_args(mrb, "|o", &r); - - if (mrb_nil_p(r)) { + struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random)); + if (mrb_get_args(mrb, "|I", &random, c) == 0) { random = random_default_state(mrb); } - else { - random_check(mrb, r); - random = random_ptr(r); - } mrb_ary_modify(mrb, mrb_ary_ptr(ary)); max = RARRAY_LEN(ary); for (i = RARRAY_LEN(ary) - 1; i > 0; i--) { @@ -324,18 +285,13 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary) { mrb_int n = 0; mrb_bool given; - mrb_value r = mrb_nil_value(); rand_state *random; mrb_int len; + struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random)); - mrb_get_args(mrb, "|i?o", &n, &given, &r); - if (mrb_nil_p(r)) { + if (mrb_get_args(mrb, "|i?I", &n, &given, &random, c) < 2) { random = random_default_state(mrb); } - else { - random_check(mrb, r); - random = random_ptr(r); - } len = RARRAY_LEN(ary); if (!given) { /* pick one element */ switch (len) { diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c index 7b919eb90..633c97b73 100644 --- a/mrbgems/mruby-range-ext/src/range.c +++ b/mrbgems/mruby-range-ext/src/range.c @@ -1,6 +1,5 @@ #include <mruby.h> #include <mruby/range.h> -#include <math.h> static mrb_bool r_le(mrb_state *mrb, mrb_value a, mrb_value b) @@ -81,7 +80,7 @@ range_size(mrb_state *mrb, mrb_value range) beg = RANGE_BEG(r); end = RANGE_END(r); - if ((mrb_fixnum_p(beg) || mrb_float_p(beg)) && mrb_nil_p(end)) { + if ((mrb_integer_p(beg) || mrb_float_p(beg)) && mrb_nil_p(end)) { return mrb_float_value(mrb, INFINITY); } @@ -136,7 +135,7 @@ range_size(mrb_state *mrb, mrb_value range) beg = RANGE_BEG(r); end = RANGE_END(r); - if (mrb_fixnum_p(beg) && mrb_nil_p(end)) { + if (mrb_integer_p(beg) && mrb_nil_p(end)) { return mrb_nil_value(); } @@ -147,7 +146,7 @@ range_size(mrb_state *mrb, mrb_value range) mrb_int b = mrb_integer(end); mrb_int c = b - a + excl; - return mrb_fixnum_value(c); + return mrb_int_value(mrb, c); } return mrb_nil_value(); } diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index 2dfabe504..dacce53eb 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -37,7 +37,7 @@ static struct RBasic* rational_alloc(mrb_state *mrb, struct RClass *c, struct mrb_rational **p) { struct RRational *s; - s = (struct RRational*)mrb_obj_alloc(mrb, MRB_TT_RATIONAL, c); + s = MRB_OBJ_ALLOC(mrb, MRB_TT_RATIONAL, c); #ifdef RATIONAL_INLINE *p = &s->r; #else @@ -155,7 +155,6 @@ rational_new_i(mrb_state *mrb, mrb_int n, mrb_int d) } #ifndef MRB_NO_FLOAT -#include <math.h> #if defined(MRB_INT32) || defined(MRB_USE_FLOAT32) #define frexp_rat(x,exp) frexpf((float)x, exp) @@ -255,20 +254,20 @@ rational_s_new(mrb_state *mrb, mrb_value self) } else { mrb_float numf = (mrb_float)numerator; - mrb_float denomf = mrb_to_flo(mrb, denomv); + mrb_float denomf = mrb_as_float(mrb, denomv); return rational_new_f(mrb, numf/denomf); } } else { - mrb_float numf = mrb_to_flo(mrb, numv); + mrb_float numf = mrb_as_float(mrb, numv); mrb_float denomf; if (mrb_integer_p(denomv)) { denomf = (mrb_float)mrb_integer(denomv); } else { - denomf = mrb_to_flo(mrb, denomv); + denomf = mrb_as_float(mrb, denomv); } return rational_new_f(mrb, numf/denomf); } @@ -278,7 +277,7 @@ rational_s_new(mrb_state *mrb, mrb_value self) #ifndef MRB_NO_FLOAT static mrb_float -rat_to_flo(struct mrb_rational *p) +rat_float(struct mrb_rational *p) { mrb_float f; @@ -296,7 +295,7 @@ static mrb_value rational_to_f(mrb_state *mrb, mrb_value self) { struct mrb_rational *p = rational_ptr(mrb, self); - return mrb_float_value(mrb, rat_to_flo(p)); + return mrb_float_value(mrb, rat_float(p)); } #endif @@ -346,8 +345,8 @@ rational_m(mrb_state *mrb, mrb_value self) return rational_new_i(mrb, mrb_integer(a), mrb_integer(b)); } else { - mrb_float x = mrb_to_flo(mrb, a); - mrb_float y = mrb_to_flo(mrb, b); + mrb_float x = mrb_as_float(mrb, a); + mrb_float y = mrb_as_float(mrb, b); return rational_new_f(mrb, x/y); } #endif @@ -436,7 +435,7 @@ rational_cmp(mrb_state *mrb, mrb_value x) #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: { - mrb_float a = rat_to_flo(p1), b = mrb_to_flo(mrb, y); + mrb_float a = rat_float(p1), b = mrb_as_float(mrb, y); if (a > b) return mrb_fixnum_value(1); else if (a < b) @@ -458,7 +457,7 @@ rational_cmp(mrb_state *mrb, mrb_value x) #endif #ifdef MRB_USE_COMPLEX case MRB_TT_COMPLEX: - x = mrb_complex_new(mrb, rat_to_flo(p1), 0); + x = mrb_complex_new(mrb, rat_float(p1), 0); return mrb_funcall_id(mrb, x, MRB_OPSYM(cmp), 1, y); #endif default: @@ -480,10 +479,6 @@ rational_minus(mrb_state *mrb, mrb_value x) return rational_new(mrb, -n, p->denominator); } -#ifndef MRB_NO_FLOAT -mrb_float mrb_div_flo(mrb_float, mrb_float); -#endif - static mrb_value rational_add(mrb_state *mrb, mrb_value x) { @@ -514,7 +509,7 @@ rational_add(mrb_state *mrb, mrb_value x) case MRB_TT_FLOAT: { mrb_float z = p1->numerator + mrb_float(y) * p1->denominator; - return mrb_float_value(mrb, mrb_div_flo(z, (mrb_float)p1->denominator)); + return mrb_float_value(mrb, mrb_div_float(z, (mrb_float)p1->denominator)); } #endif @@ -551,7 +546,7 @@ rational_sub(mrb_state *mrb, mrb_value x) #if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - x = mrb_complex_new(mrb, rat_to_flo(p1), 0); + x = mrb_complex_new(mrb, rat_float(p1), 0); return mrb_funcall_id(mrb, x, MRB_OPSYM(sub), 1, y); #endif @@ -559,8 +554,8 @@ rational_sub(mrb_state *mrb, mrb_value x) case MRB_TT_FLOAT: default: { - mrb_float z = p1->numerator - mrb_to_flo(mrb, y) * p1->denominator; - return mrb_float_value(mrb, mrb_div_flo(z, (mrb_float)p1->denominator)); + mrb_float z = p1->numerator - mrb_as_float(mrb, y) * p1->denominator; + return mrb_float_value(mrb, mrb_div_float(z, (mrb_float)p1->denominator)); } #else default: @@ -596,7 +591,7 @@ rational_mul(mrb_state *mrb, mrb_value x) case MRB_TT_FLOAT: { mrb_float z = p1->numerator * mrb_float(y); - return mrb_float_value(mrb, mrb_div_flo(z, (mrb_float)p1->denominator)); + return mrb_float_value(mrb, mrb_div_float(z, (mrb_float)p1->denominator)); } #endif @@ -630,7 +625,7 @@ mrb_rational_div(mrb_state *mrb, mrb_value x) #if defined(MRB_USE_COMPLEX) case MRB_TT_COMPLEX: - x = mrb_complex_new(mrb, rat_to_flo(p1), 0); + x = mrb_complex_new(mrb, rat_float(p1), 0); return mrb_funcall_id(mrb, x, MRB_OPSYM(div), 1, y); #endif @@ -638,8 +633,8 @@ mrb_rational_div(mrb_state *mrb, mrb_value x) #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: { - mrb_float z = mrb_div_flo((mrb_float)p1->numerator, mrb_to_flo(mrb, y)); - return mrb_float_value(mrb, mrb_div_flo(z, (mrb_float)p1->denominator)); + mrb_float z = mrb_div_float((mrb_float)p1->numerator, mrb_as_float(mrb, y)); + return mrb_float_value(mrb, mrb_div_float(z, (mrb_float)p1->denominator)); } #else mrb_raise(mrb, E_TYPE_ERROR, "non integer division"); @@ -656,7 +651,7 @@ mrb_int mrb_div_int(mrb_state *, mrb_int, mrb_int); * redefine Integer#/ */ static mrb_value -rat_int_div(mrb_state *mrb, mrb_value x) +rational_int_div(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); mrb_int a = mrb_integer(x); @@ -673,7 +668,7 @@ rat_int_div(mrb_state *mrb, mrb_value x) case MRB_TT_FLOAT: mrb_raise(mrb, E_TYPE_ERROR, "non integer multiplication"); #else - return mrb_float_value(mrb, mrb_div_flo((mrb_float)a, mrb_to_flo(mrb, y))); + return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); #endif } } @@ -684,7 +679,7 @@ rat_int_div(mrb_state *mrb, mrb_value x) */ static mrb_value -rat_int_quo(mrb_state *mrb, mrb_value x) +rational_int_quo(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); mrb_int a = mrb_integer(x); @@ -700,7 +695,7 @@ rat_int_quo(mrb_state *mrb, mrb_value x) #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non integer multiplication"); #else - return mrb_float_value(mrb, mrb_div_flo((mrb_float)a, mrb_to_flo(mrb, y))); + return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); #endif } } @@ -732,8 +727,8 @@ void mrb_mruby_rational_gem_init(mrb_state *mrb) mrb_define_method(mrb, rat, "quo", rational_div, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb->integer_class, "to_r", fix_to_r, MRB_ARGS_NONE()); #ifndef MRB_USE_COMPLEX - mrb_define_method(mrb, mrb->integer_class, "/", rat_int_div, MRB_ARGS_REQ(1)); /* overrride */ - mrb_define_method(mrb, mrb->integer_class, "quo", rat_int_quo, MRB_ARGS_REQ(1)); /* overrride */ + mrb_define_method(mrb, mrb->integer_class, "/", rational_int_div, MRB_ARGS_REQ(1)); /* override */ + mrb_define_method(mrb, mrb->integer_class, "quo", rational_int_quo, MRB_ARGS_REQ(1)); /* override */ #endif mrb_define_method(mrb, mrb->kernel_module, "Rational", rational_m, MRB_ARGS_ARG(1,1)); } diff --git a/mrbgems/mruby-sleep/mrbgem.rake b/mrbgems/mruby-sleep/mrbgem.rake index 7a303b81c..024106a48 100644 --- a/mrbgems/mruby-sleep/mrbgem.rake +++ b/mrbgems/mruby-sleep/mrbgem.rake @@ -1,5 +1,5 @@ MRuby::Gem::Specification.new('mruby-sleep') do |spec| spec.license = 'MIT' spec.authors = ['MATSUMOTO Ryosuke', 'mruby developers'] - spec.version = '0.0.1' + spec.summary = 'Kernel#sleep and Kernel#usleep' end diff --git a/mrbgems/mruby-socket/README.md b/mrbgems/mruby-socket/README.md index b727dc982..8084cdb70 100644 --- a/mrbgems/mruby-socket/README.md +++ b/mrbgems/mruby-socket/README.md @@ -1,5 +1,4 @@ -mruby-socket -============ +# mruby-socket "mruby-socket" mrbgem provides BSD socket interface for mruby. API is compatible with CRuby's "socket" library. diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index 28418fa12..027404459 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -31,7 +31,6 @@ typedef size_t fsize_t; #endif -#include <stddef.h> #include <string.h> #include "mruby.h" @@ -65,52 +64,52 @@ #ifdef _WIN32 static const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt) { - if (af == AF_INET) - { - struct sockaddr_in in; - memset(&in, 0, sizeof(in)); - in.sin_family = AF_INET; - memcpy(&in.sin_addr, src, sizeof(struct in_addr)); - getnameinfo((struct sockaddr *)&in, sizeof(struct - sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST); - return dst; - } - else if (af == AF_INET6) - { - struct sockaddr_in6 in; - memset(&in, 0, sizeof(in)); - in.sin6_family = AF_INET6; - memcpy(&in.sin6_addr, src, sizeof(struct in_addr6)); - getnameinfo((struct sockaddr *)&in, sizeof(struct - sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST); - return dst; - } - return NULL; + if (af == AF_INET) + { + struct sockaddr_in in = {0}; + + in.sin_family = AF_INET; + memcpy(&in.sin_addr, src, sizeof(struct in_addr)); + getnameinfo((struct sockaddr *)&in, sizeof(struct + sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST); + return dst; + } + else if (af == AF_INET6) + { + struct sockaddr_in6 in = {0}; + + in.sin6_family = AF_INET6; + memcpy(&in.sin6_addr, src, sizeof(struct in_addr6)); + getnameinfo((struct sockaddr *)&in, sizeof(struct + sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST); + return dst; + } + return NULL; } static int inet_pton(int af, const char *src, void *dst) { - struct addrinfo hints, *res, *ressave; + struct addrinfo hints = {0}; + struct addrinfo *res, *ressave; - memset(&hints, 0, sizeof(struct addrinfo)); - hints.ai_family = af; + hints.ai_family = af; - if (getaddrinfo(src, NULL, &hints, &res) != 0) - { - printf("Couldn't resolve host %s\n", src); - return -1; - } + if (getaddrinfo(src, NULL, &hints, &res) != 0) + { + printf("Couldn't resolve host %s\n", src); + return -1; + } - ressave = res; + ressave = res; - while (res) - { - memcpy(dst, res->ai_addr, res->ai_addrlen); - res = res->ai_next; - } + while (res) + { + memcpy(dst, res->ai_addr, res->ai_addrlen); + res = res->ai_next; + } - freeaddrinfo(ressave); - return 0; + freeaddrinfo(ressave); + return 0; } #endif @@ -118,7 +117,7 @@ static int inet_pton(int af, const char *src, void *dst) static mrb_value mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass) { - struct addrinfo hints, *res0, *res; + struct addrinfo hints = {0}, *res0, *res; mrb_value ai, ary, family, lastai, nodename, protocol, sa, service, socktype; mrb_int flags; int arena_idx, error; @@ -142,14 +141,13 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass) if (mrb_string_p(service)) { servname = RSTRING_CSTR(mrb, service); } else if (mrb_integer_p(service)) { - servname = RSTRING_PTR(mrb_fixnum_to_str(mrb, service, 10)); + servname = RSTRING_PTR(mrb_integer_to_str(mrb, service, 10)); } else if (mrb_nil_p(service)) { servname = NULL; } else { 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_integer_p(family)) { @@ -574,7 +572,7 @@ mrb_ipsocket_recvfrom(mrb_state *mrb, mrb_value self) buf = mrb_str_new_capa(mrb, maxlen); socklen = sizeof(ss); n = recvfrom(fd, RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags, - (struct sockaddr *)&ss, &socklen); + (struct sockaddr *)&ss, &socklen); if (n == -1) { mrb_sys_fail(mrb, "recvfrom"); } @@ -938,8 +936,8 @@ mrb_mruby_socket_gem_init(mrb_state* mrb) constants = mrb_define_module_under(mrb, sock, "Constants"); #define define_const(SYM) \ - do { \ - mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM)); \ + do { \ + mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM)); \ } while (0) #include "const.cstub" diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 839ee4dc4..8de3a4541 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -5,15 +5,11 @@ */ #include <mruby.h> -#include <limits.h> -#include <string.h> #include <mruby/string.h> #include <mruby/hash.h> #include <mruby/numeric.h> #include <mruby/presym.h> -#ifndef MRB_NO_FLOAT -#include <math.h> -#endif +#include <string.h> #include <ctype.h> #define BIT_DIGITS(N) (((N)*146)/485 + 1) /* log2(10) =~ 146/485 */ @@ -21,9 +17,6 @@ #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_NO_FLOAT -static void fmt_setup(char*,size_t,int,int,mrb_int,mrb_int); -#endif static char* remove_sign_bits(char *str, int base) @@ -71,35 +64,24 @@ sign_bits(int base, const char *p) return c; } -static mrb_value -mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) +static char * +mrb_uint_to_cstr(char *buf, size_t len, mrb_int num, int base) { - char buf[66], *b = buf + sizeof buf; - mrb_int num = mrb_integer(x); - const int mask = base -1; + char *b = buf + len - 1; + const int mask = base-1; int shift; -#ifdef MRB_INT64 - uint64_t val = (uint64_t)num; -#else - uint32_t val = (uint32_t)num; -#endif + mrb_uint val = (uint64_t)num; char d; - switch (base) { - case 2: - shift = 1; - break; - case 8: - shift = 3; - break; - case 16: - shift = 4; - break; - default: - mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base); - } if (num == 0) { - return mrb_str_new_lit(mrb, "0"); + buf[0] = '0'; buf[1] = '\0'; + return buf; + } + switch (base) { + case 16: d = 'f'; shift = 4; break; + case 8: d = '7'; shift = 3; break; + case 2: d = '1'; shift = 1; break; + default: return NULL; } *--b = '\0'; do { @@ -108,19 +90,12 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) if (num < 0) { b = remove_sign_bits(b, base); - switch (base) { - case 16: d = 'f'; break; - case 8: d = '7'; break; - case 2: d = '1'; break; - default: d = 0; break; - } - if (d && *b != d) { *--b = d; } } - return mrb_str_new_cstr(mrb, b); + return b; } #define FNONE 0 @@ -133,7 +108,52 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) #define FPREC 64 #define FPREC0 128 -#define CHECK(l) do {\ +#ifndef MRB_NO_FLOAT +static int +fmt_float(char *buf, size_t buf_size, char fmt, int flags, mrb_int width, int prec, mrb_float f) +{ + char sign = '\0'; + int left_align = 0; + int zero_pad = 0; + + if (flags & FSHARP) fmt |= 0x80; + if (flags & FPLUS) sign = '+'; + if (flags & FMINUS) left_align = 1; + if (flags & FZERO) zero_pad = 1; + if (flags & FSPACE) sign = ' '; + + int len = mrb_format_float(f, buf, buf_size, fmt, prec, sign); + + // buf[0] < '0' returns true if the first character is space, + or - + // buf[1] < '9' matches a digit, and doesn't match when we get back +nan or +inf + if (buf[0] < '0' && buf[1] <= '9' && zero_pad) { + buf++; + width--; + len--; + } + if (*buf < '0' || *buf >= '9') { + // For inf or nan, we don't want to zero pad. + zero_pad = 0; + } + if (len >= width) { + return len; + } + buf[width] = '\0'; + if (left_align) { + memset(&buf[len], ' ', width - len); + return width; + } + memmove(&buf[width - len], buf, len); + if (zero_pad) { + memset(buf, '0', width - len); + } else { + memset(buf, ' ', width - len); + } + return width; +} +#endif + +#define CHECK(l) do { \ while ((l) >= bsiz - blen) {\ if (bsiz > MRB_INT_MAX/2) mrb_raise(mrb, E_ARGUMENT_ERROR, "too big specifier"); \ bsiz*=2;\ @@ -221,7 +241,6 @@ check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len) #define GETASTER(num) do { \ mrb_value tmp_v; \ t = p++; \ - n = 0; \ GETNUM(n, val); \ if (*p == '$') { \ tmp_v = GETPOSARG(n); \ @@ -230,27 +249,17 @@ check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len) tmp_v = GETNEXTARG(); \ p = t; \ } \ - num = mrb_int(mrb, tmp_v); \ + num = mrb_as_int(mrb, tmp_v); \ } while (0) static const char * -get_num(mrb_state *mrb, const char *p, const char *end, mrb_int *valp) +get_num(mrb_state *mrb, const char *p, const char *end, 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; + char *e; + mrb_int n = mrb_int_read(p, end, &e); + if (e == NULL || n > INT_MAX) return NULL; + *valp = (int)n; + return e; } static void @@ -326,10 +335,6 @@ get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv) * | equal to the precision, or in dd.dddd form otherwise. * | The precision specifies the number of significant digits. * G | Equivalent to 'g', but use an uppercase 'E' in exponent form. - * a | Convert floating-point argument as [-]0xh.hhhhp[+-]dd, - * | which is consisted from optional sign, "0x", fraction part - * | as hexadecimal, "p", and exponential part as decimal. - * A | Equivalent to 'a', but use uppercase 'X' and 'P'. * * Field | Other Format * ------+-------------------------------------------------------------- @@ -364,7 +369,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv) * | | For the conversions 'x', 'X', 'b' and 'B' * | | on non-zero, prefix the result with "0x", * | | "0X", "0b" and "0B", respectively. - * | | For 'a', 'A', 'e', 'E', 'f', 'g', and 'G', + * | | For 'e', 'E', 'f', 'g', and 'G', * | | force a decimal point to be added, * | | even if no digits follow. * | | For 'g' and 'G', do not remove trailing zeros. @@ -547,50 +552,6 @@ mrb_f_sprintf(mrb_state *mrb, mrb_value obj) } } -static int -mrb_int2str(char *buf, size_t len, mrb_int n) -{ -#ifdef MRB_NO_STDIO - char *bufend = buf + len; - char *p = bufend - 1; - - if (len < 1) return -1; - - *p -- = '\0'; - len --; - - if (n < 0) { - if (len < 1) return -1; - - *p -- = '-'; - len --; - n = -n; - } - - if (n > 0) { - for (; n > 0; len --, n /= 10) { - if (len < 1) return -1; - - *p -- = '0' + (n % 10); - } - p ++; - } - else if (len > 0) { - *p = '0'; - len --; - } - else { - return -1; - } - - memmove(buf, p, bufend - p); - - return bufend - p - 1; -#else - return snprintf(buf, len, "%" MRB_PRId, n); -#endif /* MRB_NO_STDIO */ -} - mrb_value mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fmt) { @@ -599,9 +560,9 @@ mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fm mrb_int blen; mrb_int bsiz; mrb_value result; - mrb_int n; - mrb_int width; - mrb_int prec; + int n; + int width; + int prec; int nextarg = 1; int posarg = 0; mrb_value nextvalue; @@ -625,7 +586,7 @@ mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fm ++argc; --argv; - mrb_to_str(mrb, fmt); + mrb_ensure_string_type(mrb, fmt); p = RSTRING_PTR(fmt); end = p + RSTRING_LEN(fmt); blen = 0; @@ -688,7 +649,6 @@ retry: case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': - n = 0; GETNUM(n, width); if (*p == '$') { if (!mrb_undef_p(nextvalue)) { @@ -732,6 +692,9 @@ retry: CHECK_FOR_WIDTH(flags); flags |= FWIDTH; GETASTER(width); + if (width > INT16_MAX || INT16_MIN > width) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "width too big"); + } if (width < 0) { flags |= FMINUS; width = -width; @@ -745,7 +708,6 @@ retry: } flags |= FPREC|FPREC0; - prec = 0; p++; if (*p == '*') { GETASTER(prec); @@ -755,7 +717,6 @@ retry: p++; goto retry; } - GETNUM(prec, precision); goto retry; @@ -898,19 +859,18 @@ retry: switch (mrb_type(val)) { #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: - val = mrb_flo_to_fixnum(mrb, val); - if (mrb_integer_p(val)) goto bin_retry; - break; + val = mrb_float_to_integer(mrb, val); + goto bin_retry; #endif case MRB_TT_STRING: - val = mrb_str_to_inum(mrb, val, 0, TRUE); + val = mrb_str_to_integer(mrb, val, 0, TRUE); goto bin_retry; case MRB_TT_INTEGER: v = mrb_integer(val); break; default: - val = mrb_Integer(mrb, val); - goto bin_retry; + v = mrb_as_int(mrb, val); + break; } switch (*p) { @@ -946,21 +906,15 @@ retry: sc = '-'; width--; } - mrb_assert(base == 10); - mrb_int2str(nbuf, sizeof(nbuf)-1, v); - s = nbuf; + s = mrb_int_to_cstr(nbuf, sizeof(nbuf), v, base); if (v < 0) s++; /* skip minus sign */ } else { - s = nbuf; + /* print as unsigned */ + s = mrb_uint_to_cstr(nbuf, sizeof(nbuf), v, base); if (v < 0) { dots = 1; - val = mrb_fix2binstr(mrb, mrb_int_value(mrb, v), base); } - else { - val = mrb_fixnum_to_str(mrb, mrb_int_value(mrb, v), base); - } - strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-2); } { size_t size; @@ -1053,15 +1007,12 @@ retry: case 'g': case 'G': case 'e': - case 'E': - case 'a': - case 'A': { + case 'E': { mrb_value val = GETARG(); double fval; mrb_int need = 6; - char fbuf[64]; - fval = mrb_float(mrb_Float(mrb, val)); + fval = mrb_as_float(mrb, val); if (!isfinite(fval)) { const char *expr; const mrb_int elen = 3; @@ -1108,7 +1059,7 @@ retry: need = BIT_DIGITS(i); } if (need > MRB_INT_MAX - ((flags&FPREC) ? prec : 6)) { - too_big_width: + too_big_width_prec: mrb_raise(mrb, E_ARGUMENT_ERROR, (width > prec ? "width too big" : "prec too big")); } @@ -1116,13 +1067,12 @@ retry: if ((flags&FWIDTH) && need < width) need = width; if (need > MRB_INT_MAX - 20) { - goto too_big_width; + goto too_big_width_prec; } need += 20; CHECK(need); - fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec); - n = mrb_float_to_cstr(mrb, &buf[blen], need, fbuf, fval); + n = fmt_float(&buf[blen], need, *p, flags, width, prec, fval); if (n < 0 || n >= need) { mrb_raise(mrb, E_RUNTIME_ERROR, "formatting error"); } @@ -1149,35 +1099,6 @@ retry: return result; } -#ifndef MRB_NO_FLOAT -static void -fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec) -{ - char *end = buf + size; - int n; - - *buf++ = '%'; - if (flags & FSHARP) *buf++ = '#'; - if (flags & FPLUS) *buf++ = '+'; - if (flags & FMINUS) *buf++ = '-'; - if (flags & FZERO) *buf++ = '0'; - if (flags & FSPACE) *buf++ = ' '; - - if (flags & FWIDTH) { - n = mrb_int2str(buf, end - buf, width); - buf += n; - } - - if (flags & FPREC) { - *buf ++ = '.'; - n = mrb_int2str(buf, end - buf, prec); - buf += n; - } - - *buf++ = c; - *buf = '\0'; -} -#endif void mrb_mruby_sprintf_gem_init(mrb_state *mrb) diff --git a/mrbgems/mruby-sprintf/test/sprintf.rb b/mrbgems/mruby-sprintf/test/sprintf.rb index 0a8166bae..aedc2787a 100644 --- a/mrbgems/mruby-sprintf/test/sprintf.rb +++ b/mrbgems/mruby-sprintf/test/sprintf.rb @@ -10,11 +10,11 @@ assert('String#%') do assert_equal 15, ("%b" % (1<<14)).size skip unless Object.const_defined?(:Float) assert_equal "1.0", "%3.1f" % 1.01 - assert_equal " 1234567.12", "% 4.2f" % 1234567.123456789 - assert_equal "1234567.12", "%-4.2f" % 1234567.123456789 - assert_equal "+1234567.12", "%+4.2f" % 1234567.123456789 - assert_equal "1234567.12", "%04.2f" % 1234567.123456789 - assert_equal "00000000001234567.12", "%020.2f" % 1234567.123456789 + assert_equal " 12345.12", "% 4.2f" % 12345.1234 + assert_equal "12345.12", "%-4.2f" % 12345.12345 + assert_equal "+12345.12", "%+4.2f" % 12345.1234 + assert_equal "12345.12", "%04.2f" % 12345.12345 + assert_equal "0012345.12", "%010.2f" % 12345.1234 end assert('String#% with inf') do diff --git a/mrbgems/mruby-string-ext/mrblib/string.rb b/mrbgems/mruby-string-ext/mrblib/string.rb index ff113dd95..d485c51ef 100644 --- a/mrbgems/mruby-string-ext/mrblib/string.rb +++ b/mrbgems/mruby-string-ext/mrblib/string.rb @@ -111,36 +111,6 @@ class String (s == self) ? nil : self.replace(s) end - ## - # call-seq: - # str.casecmp(other_str) -> -1, 0, +1 or nil - # - # Case-insensitive version of <code>String#<=></code>. - # - # "abcdef".casecmp("abcde") #=> 1 - # "aBcDeF".casecmp("abcdef") #=> 0 - # "abcdef".casecmp("abcdefg") #=> -1 - # "abcdef".casecmp("ABCDEF") #=> 0 - # - def casecmp(str) - self.downcase <=> str.__to_str.downcase - rescue NoMethodError - nil - end - - ## - # call-seq: - # str.casecmp?(other) -> true, false, or nil - # - # Returns true if str and other_str are equal after case folding, - # false if they are not equal, and nil if other_str is not a string. - - def casecmp?(str) - c = self.casecmp(str) - return nil if c.nil? - return c == 0 - end - def partition(sep) raise TypeError, "type mismatch: #{sep.class} given" unless sep.is_a? String n = index(sep) @@ -344,8 +314,6 @@ class String end def codepoints(&block) - len = self.size - if block_given? self.split('').each do|x| block.call(x.ord) @@ -459,14 +427,14 @@ class String break if exclusive and n == 0 yield bs break if n == 0 + bsiz = bs.size + break if bsiz > max.size || bsiz == 0 bs = bs.succ end self end def __upto_endless(&block) - return to_enum(:__upto_endless) unless block - len = self.length # both edges are all digits bi = self.to_i(10) diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c index 09cbf7995..e3dabcc18 100644 --- a/mrbgems/mruby-string-ext/src/string.c +++ b/mrbgems/mruby-string-ext/src/string.c @@ -35,7 +35,7 @@ str_casecmp_p(const char *s1, mrb_int len1, const char *s2, mrb_int len2) static mrb_value int_chr_binary(mrb_state *mrb, mrb_value num) { - mrb_int cp = mrb_int(mrb, num); + mrb_int cp = mrb_as_int(mrb, num); char c; mrb_value str; @@ -195,14 +195,14 @@ static mrb_value mrb_str_start_with(mrb_state *mrb, mrb_value self) { const mrb_value *argv; - mrb_value sub; mrb_int argc, i; mrb_get_args(mrb, "*", &argv, &argc); for (i = 0; i < argc; i++) { size_t len_l, len_r; int ai = mrb_gc_arena_save(mrb); - sub = mrb_ensure_string_type(mrb, argv[i]); + mrb_value sub = argv[i]; + mrb_ensure_string_type(mrb, sub); mrb_gc_arena_restore(mrb, ai); len_l = RSTRING_LEN(self); len_r = RSTRING_LEN(sub); @@ -225,14 +225,14 @@ static mrb_value mrb_str_end_with(mrb_state *mrb, mrb_value self) { const mrb_value *argv; - mrb_value sub; mrb_int argc, i; mrb_get_args(mrb, "*", &argv, &argc); for (i = 0; i < argc; i++) { size_t len_l, len_r; int ai = mrb_gc_arena_save(mrb); - sub = mrb_ensure_string_type(mrb, argv[i]); + mrb_value sub = argv[i]; + mrb_ensure_string_type(mrb, sub); mrb_gc_arena_restore(mrb, ai); len_l = RSTRING_LEN(self); len_r = RSTRING_LEN(sub); @@ -262,7 +262,7 @@ enum tr_pattern_type { <range> ::= <ch> '-' <ch> */ struct tr_pattern { - uint8_t type; // 1:in-order, 2:range + uint8_t type; // 1:in-order, 2:range mrb_bool flag_reverse : 1; mrb_bool flag_on_heap : 1; uint16_t n; @@ -329,9 +329,9 @@ tr_parse_pattern(mrb_state *mrb, struct tr_pattern *ret, const mrb_value v_patte mrb_int len; while (i < pattern_length) { - if ((i+2) < pattern_length && pattern[i] != '\\' && pattern[i+1] == '-') + if ((i+2) < pattern_length && pattern[i] != '\\' && pattern[i+1] == '-') break; - i++; + i++; } len = i - start_pos; @@ -375,7 +375,7 @@ tr_find_character(const struct tr_pattern *pat, const char *pat_str, int ch) if (pat->type == TR_IN_ORDER) { int i; for (i = 0; i < pat->n; i++) { - if (pat_str[pat->val.start_pos + i] == ch) ret = n_sum + i; + if (pat_str[pat->val.start_pos + i] == ch) ret = n_sum + i; } } else if (pat->type == TR_RANGE) { @@ -509,7 +509,7 @@ str_tr(mrb_state *mrb, mrb_value str, mrb_value p1, mrb_value p2, mrb_bool squee if (n >= 0) { flag_changed = TRUE; if (rep == NULL) { - j--; + j--; } else { mrb_int c = tr_get_character(rep, RSTRING_PTR(p2), n); @@ -521,8 +521,8 @@ str_tr(mrb_state *mrb, mrb_value str, mrb_value p1, mrb_value p2, mrb_bool squee if (c > 0x80) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "character (%i) out of range", c); } - lastch = c; - s[i] = (char)c; + lastch = c; + s[i] = (char)c; } } } @@ -835,13 +835,13 @@ mrb_str_count(mrb_state *mrb, mrb_value str) static mrb_value mrb_str_hex(mrb_state *mrb, mrb_value self) { - return mrb_str_to_inum(mrb, self, 16, FALSE); + return mrb_str_to_integer(mrb, self, 16, FALSE); } static mrb_value mrb_str_oct(mrb_state *mrb, mrb_value self) { - return mrb_str_to_inum(mrb, self, 8, FALSE); + return mrb_str_to_integer(mrb, self, 8, FALSE); } /* @@ -1174,6 +1174,60 @@ mrb_str_del_suffix(mrb_state *mrb, mrb_value self) return mrb_str_substr(mrb, self, 0, slen-plen); } +#define lesser(a,b) (((a)>(b))?(b):(a)) + +/* + * call-seq: + * str.casecmp(other_str) -> -1, 0, +1 or nil + * + * Case-insensitive version of <code>String#<=></code>. + * + * "abcdef".casecmp("abcde") #=> 1 + * "aBcDeF".casecmp("abcdef") #=> 0 + * "abcdef".casecmp("abcdefg") #=> -1 + * "abcdef".casecmp("ABCDEF") #=> 0 + */ +static mrb_value +mrb_str_casecmp(mrb_state *mrb, mrb_value self) +{ + mrb_value str; + + mrb_get_args(mrb, "o", &str); + if (!mrb_string_p(str)) return mrb_nil_value(); + + struct RString *s1 = mrb_str_ptr(self); + struct RString *s2 = mrb_str_ptr(str); + mrb_int len = lesser(RSTR_LEN(s1), RSTR_LEN(s2)); + char *p1 = RSTR_PTR(s1); + char *p2 = RSTR_PTR(s2); + + for (mrb_int i=0; i<len; i++) { + int c1 = p1[i], c2 = p2[i]; + if (ISASCII(c1) && ISUPPER(c1)) c1 = TOLOWER(c1); + if (ISASCII(c2) && ISUPPER(c2)) c2 = TOLOWER(c2); + if (c1 > c2) return mrb_fixnum_value(1); + if (c1 < c2) return mrb_fixnum_value(-1); + } + if (RSTR_LEN(s1) == RSTR_LEN(s2)) return mrb_fixnum_value(0); + if (RSTR_LEN(s1) > RSTR_LEN(s2)) return mrb_fixnum_value(1); + return mrb_fixnum_value(-1); +} + +/* + * call-seq: + * str.casecmp?(other) -> true, false, or nil + * + * Returns true if str and other_str are equal after case folding, + * false if they are not equal, and nil if other is not a string. + */ +static mrb_value +mrb_str_casecmp_p(mrb_state *mrb, mrb_value self) +{ + mrb_value c = mrb_str_casecmp(mrb, self); + if (mrb_nil_p(c)) return c; + return mrb_bool_value(mrb_fixnum(c) == 0); +} + static mrb_value mrb_str_lines(mrb_state *mrb, mrb_value self) { @@ -1184,6 +1238,7 @@ mrb_str_lines(mrb_state *mrb, mrb_value self) char *p = b, *t; char *e = b + RSTRING_LEN(self); + mrb->c->ci->mid = 0; result = mrb_ary_new(mrb); ai = mrb_gc_arena_save(mrb); while (p < e) { @@ -1230,6 +1285,8 @@ mrb_mruby_string_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, s, "delete_prefix", mrb_str_del_prefix, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "delete_suffix!", mrb_str_del_suffix_bang, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "delete_suffix", mrb_str_del_suffix, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, s, "casecmp", mrb_str_casecmp, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, s, "casecmp?", mrb_str_casecmp_p, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "__lines", mrb_str_lines, MRB_ARGS_NONE()); diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index 54afefd74..2d864bdaf 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -18,6 +18,8 @@ #define RSTRUCT_LEN(st) RARRAY_LEN(st) #define RSTRUCT_PTR(st) RARRAY_PTR(st) +#define mrb_struct_p(o) (mrb_type(o) == MRB_TT_STRUCT) + static struct RClass * struct_class(mrb_state *mrb) { @@ -58,18 +60,13 @@ static mrb_value struct_members(mrb_state *mrb, mrb_value s) { mrb_value members = struct_s_members(mrb, mrb_obj_class(mrb, s)); - if (!mrb_array_p(s)) { + if (!mrb_struct_p(s) || RSTRUCT_LEN(s) == 0) { mrb_raise(mrb, E_TYPE_ERROR, "corrupted struct"); } if (RSTRUCT_LEN(s) != RARRAY_LEN(members)) { - if (RSTRUCT_LEN(s) == 0) { /* probably uninitialized */ - mrb_ary_resize(mrb, s, RARRAY_LEN(members)); - } - else { - mrb_raisef(mrb, E_TYPE_ERROR, - "struct size differs (%i required %i given)", - RARRAY_LEN(members), RSTRUCT_LEN(s)); - } + mrb_raisef(mrb, E_TYPE_ERROR, + "struct size differs (%i required %i given)", + RARRAY_LEN(members), RSTRUCT_LEN(s)); } return members; } @@ -202,7 +199,7 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass *kl } else { /* old style: should we warn? */ - mrb_to_str(mrb, name); + mrb_ensure_string_type(mrb, name); id = mrb_obj_to_sym(mrb, name); if (!mrb_const_name_p(mrb, RSTRING_PTR(name), RSTRING_LEN(name))) { mrb_name_error(mrb, id, "identifier %v needs to be constant", name); @@ -213,7 +210,7 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass *kl } c = mrb_define_class_under(mrb, klass, RSTRING_PTR(name), klass); } - MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY); + MRB_SET_INSTANCE_TT(c, MRB_TT_STRUCT); nstr = mrb_obj_value(c); mrb_iv_set(mrb, nstr, MRB_SYM(__members__), members); @@ -362,7 +359,7 @@ mrb_struct_init_copy(mrb_state *mrb, mrb_value copy) if (!mrb_obj_is_instance_of(mrb, s, mrb_obj_class(mrb, copy))) { mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class"); } - if (!mrb_array_p(s)) { + if (!mrb_struct_p(s)) { mrb_raise(mrb, E_TYPE_ERROR, "corrupted struct"); } mrb_ary_replace(mrb, copy, s); @@ -435,7 +432,7 @@ mrb_struct_aref(mrb_state *mrb, mrb_value s) if (mrb_symbol_p(idx)) { return struct_aref_sym(mrb, s, mrb_symbol(idx)); } - return struct_aref_int(mrb, s, mrb_int(mrb, idx)); + return struct_aref_int(mrb, s, mrb_as_int(mrb, idx)); } static mrb_value @@ -499,7 +496,7 @@ mrb_struct_aset(mrb_state *mrb, mrb_value s) return mrb_struct_aset_sym(mrb, s, mrb_symbol(idx), val); } - i = mrb_int(mrb, idx); + i = mrb_as_int(mrb, idx); if (i < 0) i = RSTRUCT_LEN(s) + i; if (i < 0) { mrb_raisef(mrb, E_INDEX_ERROR, diff --git a/mrbgems/mruby-test-inline-struct/test/inline.c b/mrbgems/mruby-test-inline-struct/test/inline.c index 7a91f5ec3..7537bffc6 100644 --- a/mrbgems/mruby-test-inline-struct/test/inline.c +++ b/mrbgems/mruby-test-inline-struct/test/inline.c @@ -57,7 +57,8 @@ static mrb_value istruct_test_test_receive_direct(mrb_state *mrb, mrb_value self) { char *ptr; - mrb_get_args(mrb, "I", &ptr); + struct RClass *klass = mrb_class_get(mrb, "InlineStructTest"); + mrb_get_args(mrb, "I", &ptr, klass); return mrb_bool_value(ptr[0] == 's'); } diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c index 958e87dd1..21e272536 100644 --- a/mrbgems/mruby-test/driver.c +++ b/mrbgems/mruby-test/driver.c @@ -220,14 +220,14 @@ mrb_init_test_driver(mrb_state *mrb, mrb_bool verbose) mrbtest = mrb_define_module(mrb, "Mrbtest"); - mrb_define_const(mrb, mrbtest, "FIXNUM_MAX", mrb_fixnum_value(MRB_INT_MAX)); - 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_NO_FLOAT #ifdef MRB_USE_FLOAT32 +#ifdef MRB_WORDBOX_NO_FLOAT_TRUNCATE mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-5)); #else + mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-4)); +#endif +#else mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-10)); #endif #endif diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 2a5e9dd6b..6b9762acf 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -4,10 +4,6 @@ ** See Copyright Notice in mruby.h */ -#ifndef MRB_NO_FLOAT -#include <math.h> -#endif - #include <mruby.h> #include <mruby/class.h> #include <mruby/data.h> @@ -20,6 +16,7 @@ #include <string.h> #endif + #include <stdlib.h> #ifndef _WIN32 #include <unistd.h> @@ -85,8 +82,12 @@ double round(double x) { /** end of Time class configuration */ -#ifndef NO_GETTIMEOFDAY -# ifdef _WIN32 +#if (defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0) && defined(CLOCK_REALTIME) +# define USE_CLOCK_GETTIME +#endif + +#if !defined(NO_GETTIMEOFDAY) +# if defined(_WIN32) && !defined(USE_CLOCK_GETTIME) # define WIN32_LEAN_AND_MEAN /* don't include winsock.h */ # include <windows.h> # define gettimeofday my_gettimeofday @@ -177,17 +178,6 @@ timegm(struct tm *tm) * second level. Also, there are only 2 timezones, namely UTC and LOCAL. */ -typedef struct mrb_timezone_name { - const char name[8]; - size_t len; -} mrb_timezone_name; - -static const mrb_timezone_name timezone_names[] = { - { "none", sizeof("none") - 1 }, - { "UTC", sizeof("UTC") - 1 }, - { "LOCAL", sizeof("LOCAL") - 1 }, -}; - #ifndef MRB_NO_STDIO static const char mon_names[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", @@ -389,7 +379,7 @@ current_mrb_time(mrb_state *mrb) sec = ts.tv_sec; usec = ts.tv_nsec / 1000; } -#elif (defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0) && defined(CLOCK_REALTIME) +#elif defined(USE_CLOCK_GETTIME) { struct timespec ts; clock_gettime(CLOCK_REALTIME, &ts); @@ -690,19 +680,35 @@ mrb_time_year(mrb_state *mrb, mrb_value self) return mrb_fixnum_value(tm->datetime.tm_year + 1900); } +static size_t +time_zonename(mrb_state *mrb, struct mrb_time *tm, char *buf, size_t len) +{ +#if defined(_MSC_VER) && _MSC_VER < 1900 || defined(__MINGW64__) || defined(__MINGW32__) + struct tm datetime = {0}; + time_t utc_sec = timegm(&tm->datetime); + int offset = abs((int)(utc_sec - tm->sec) / 60); + datetime.tm_year = 100; + datetime.tm_hour = offset / 60; + datetime.tm_min = offset % 60; + buf[0] = utc_sec < tm->sec ? '-' : '+'; + return strftime(buf+1, len-1, "%H%M", &datetime) + 1; +#else + return strftime(buf, len, "%z", &tm->datetime); +#endif +} + /* 15.2.19.7.33 */ /* Returns name of time's timezone. */ static mrb_value mrb_time_zone(mrb_state *mrb, mrb_value self) { - struct mrb_time *tm; - - tm = time_get_ptr(mrb, self); - if (tm->timezone <= MRB_TIMEZONE_NONE) return mrb_nil_value(); - if (tm->timezone >= MRB_TIMEZONE_LAST) return mrb_nil_value(); - return mrb_str_new_static(mrb, - timezone_names[tm->timezone].name, - timezone_names[tm->timezone].len); + struct mrb_time *tm = time_get_ptr(mrb, self); + if (tm->timezone == MRB_TIMEZONE_UTC) { + return mrb_str_new_lit(mrb, "UTC"); + } + char buf[64]; + size_t len = time_zonename(mrb, tm, buf, sizeof(buf)); + return mrb_str_new(mrb, buf, len); } /* 15.2.19.7.4 */ @@ -886,7 +892,7 @@ mrb_time_min(mrb_state *mrb, mrb_value self) return mrb_fixnum_value(tm->datetime.tm_min); } -/* 15.2.19.7.21 and 15.2.19.7.22 */ +/* 15.2.19.7.21 (mon) and 15.2.19.7.22 (month) */ /* Returns month of time. */ static mrb_value mrb_time_mon(mrb_state *mrb, mrb_value self) @@ -938,7 +944,7 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self) } /* 15.2.19.7.26 */ -/* Returns an Integer with the time since the epoch in microseconds. */ +/* Returns the number of microseconds for time. */ static mrb_value mrb_time_usec(mrb_state *mrb, mrb_value self) { @@ -972,44 +978,20 @@ mrb_time_utc_p(mrb_state *mrb, mrb_value self) return mrb_bool_value(tm->timezone == MRB_TIMEZONE_UTC); } -static size_t -time_to_s_utc(mrb_state *mrb, struct mrb_time *tm, char *buf, size_t buf_len) -{ - return strftime(buf, buf_len, TO_S_FMT "UTC", &tm->datetime); -} - -static size_t -time_to_s_local(mrb_state *mrb, struct mrb_time *tm, char *buf, size_t buf_len) -{ -#if defined(_MSC_VER) && _MSC_VER < 1900 || defined(__MINGW64__) || defined(__MINGW32__) - struct tm datetime = {0}; - time_t utc_sec = timegm(&tm->datetime); - size_t len; - int offset; - - if (utc_sec == (time_t)-1) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "Not a valid time"); - } - offset = abs((int)(utc_sec - tm->sec) / 60); - datetime.tm_year = 100; - datetime.tm_hour = offset / 60; - datetime.tm_min = offset % 60; - len = strftime(buf, buf_len, TO_S_FMT, &tm->datetime); - buf[len++] = utc_sec < tm->sec ? '-' : '+'; - - return len + strftime(buf + len, buf_len - len, "%H%M", &datetime); -#else - return strftime(buf, buf_len, TO_S_FMT "%z", &tm->datetime); -#endif -} - static mrb_value mrb_time_to_s(mrb_state *mrb, mrb_value self) { - char buf[64]; struct mrb_time *tm = time_get_ptr(mrb, self); - mrb_bool utc = tm->timezone == MRB_TIMEZONE_UTC; - size_t len = (utc ? time_to_s_utc : time_to_s_local)(mrb, tm, buf, sizeof(buf)); + char buf[64]; + size_t len; + + if (tm->timezone == MRB_TIMEZONE_UTC) { + len = strftime(buf, sizeof(buf), TO_S_FMT "UTC", &tm->datetime); + } + else { + len = strftime(buf, sizeof(buf), TO_S_FMT, &tm->datetime); + len += time_zonename(mrb, tm, buf+len, sizeof(buf)-len); + } mrb_value str = mrb_str_new(mrb, buf, len); RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); return str; diff --git a/mrbgems/mruby-toplevel-ext/mrblib/toplevel.rb b/mrbgems/mruby-toplevel-ext/mrblib/toplevel.rb index 774562398..664008d1c 100644 --- a/mrbgems/mruby-toplevel-ext/mrblib/toplevel.rb +++ b/mrbgems/mruby-toplevel-ext/mrblib/toplevel.rb @@ -1,5 +1,5 @@ -def self.include (*modules) +def self.include(*modules) self.class.include(*modules) end diff --git a/mrblib/10error.rb b/mrblib/10error.rb index 054603514..aa9da91bb 100644 --- a/mrblib/10error.rb +++ b/mrblib/10error.rb @@ -2,8 +2,8 @@ class ArgumentError < StandardError end -# ISO 15.2.25 says "LocalJumpError < StandardError" -class LocalJumpError < ScriptError +# ISO 15.2.25 +class LocalJumpError < StandardError end # ISO 15.2.26 diff --git a/mrblib/array.rb b/mrblib/array.rb index 18b729128..6b4f74b96 100644 --- a/mrblib/array.rb +++ b/mrblib/array.rb @@ -4,7 +4,6 @@ # # ISO 15.2.12 class Array - ## # Calls the given block for each element of +self+ # and pass the respective element. @@ -193,13 +192,6 @@ class Array return block.call if ret.nil? && block ret end -end - -## -# Array is enumerable -class Array - # ISO 15.2.12.3 - include Enumerable ## # Sort all elements and replace +self+ with these @@ -276,4 +268,10 @@ class Array def to_a self end + alias entries to_a + + ## + # Array is enumerable + # ISO 15.2.12.3 + include Enumerable end diff --git a/mrblib/hash.rb b/mrblib/hash.rb index 085536c6c..ac70f4c70 100644 --- a/mrblib/hash.rb +++ b/mrblib/hash.rb @@ -4,6 +4,12 @@ # ISO 15.2.13 class Hash ## + # Hash is enumerable + # + # ISO 15.2.13.3 + include Enumerable + + ## # Equality---Two hashes are equal if they each contain the same number # of keys and if each key-value pair is equal to (according to # <code>Object#==</code>) the corresponding elements in the other @@ -297,11 +303,3 @@ class Hash h end end - -## -# Hash is enumerable -# -# ISO 15.2.13.3 -class Hash - include Enumerable -end diff --git a/mrblib/range.rb b/mrblib/range.rb index 36886d50c..4a8e10f30 100644 --- a/mrblib/range.rb +++ b/mrblib/range.rb @@ -3,6 +3,11 @@ # # ISO 15.2.14 class Range + ## + # Range is enumerable + # + # ISO 15.2.14.3 + include Enumerable ## # Calls the given block for each element of +self+ @@ -15,7 +20,7 @@ class Range val = self.begin last = self.end - if val.kind_of?(Fixnum) && last.nil? + if val.kind_of?(Integer) && last.nil? i = val while true block.call(i) @@ -32,7 +37,7 @@ class Range end end - if val.kind_of?(Integer) && last.kind_of?(Integer) # fixnums are special + if val.kind_of?(Integer) && last.kind_of?(Integer) # integers are special lim = last lim += 1 unless exclude_end? i = val @@ -74,16 +79,19 @@ class Range h end + ## + # call-seq: + # rng.to_a -> array + # rng.entries -> array + # + # Returns an array containing the items in the range. + # + # (1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7] + # (1..).to_a #=> RangeError: cannot convert endless range to an array def to_a - raise RangeError, "cannot convert endless range to an array" if self.last.nil? + a = __num_to_a + return a if a super end -end - -## -# Range is enumerable -# -# ISO 15.2.14.3 -class Range - include Enumerable + alias entries to_a end diff --git a/mrblib/string.rb b/mrblib/string.rb index 675026e73..2b3178688 100644 --- a/mrblib/string.rb +++ b/mrblib/string.rb @@ -42,32 +42,6 @@ class String self end - # private method for gsub/sub - def __sub_replace(pre, m, post) - s = "" - i = 0 - while j = index("\\", i) - break if j == length-1 - t = case self[j+1] - when "\\" - "\\" - when "`" - pre - when "&", "0" - m - when "'" - post - when "1", "2", "3", "4", "5", "6", "7", "8", "9" - "" - else - self[j, 2] - end - s += self[i, j-i] + t - i = j + 2 - end - s + self[i, length-i] - end - ## # Replace all matches of +pattern+ with +replacement+. # Call block (if given) for each match and replace @@ -84,9 +58,6 @@ class String if args.length == 2 && block block = nil end - if !replace.nil? || !block - replace.__to_str - end offset = 0 result = [] while found = index(pattern, offset) @@ -95,7 +66,7 @@ class String result << if block block.call(pattern).to_s else - replace.__sub_replace(self[0, found], pattern, self[offset..-1] || "") + self.__sub_replace(replace, pattern, found) end if plen == 0 result << self[offset, 1] @@ -144,25 +115,20 @@ class String end pattern, replace = *args - pattern.__to_str if args.length == 2 && block block = nil end - unless block - replace.__to_str - end result = [] - this = dup found = index(pattern) - return this unless found - result << this[0, found] + return self.dup unless found + result << self[0, found] offset = found + pattern.length result << if block block.call(pattern).to_s else - replace.__sub_replace(this[0, found], pattern, this[offset..-1] || "") + self.__sub_replace(replace, pattern, found) end - result << this[offset..-1] if offset < length + result << self[offset..-1] if offset < length result.join end diff --git a/src/array.c b/src/array.c index e83f7e2d8..c100591eb 100644 --- a/src/array.c +++ b/src/array.c @@ -29,7 +29,7 @@ ary_new_capa(mrb_state *mrb, mrb_int capa) } blen = capa * sizeof(mrb_value); - a = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class); + a = MRB_OBJ_ALLOC(mrb, MRB_TT_ARRAY, mrb->array_class); if (capa <= MRB_ARY_EMBED_LEN_MAX) { ARY_SET_EMBED_LEN(a, 0); } @@ -578,7 +578,7 @@ mrb_ary_shift(mrb_state *mrb, mrb_value self) return val; } -MRB_API mrb_value +static mrb_value mrb_ary_shift_m(mrb_state *mrb, mrb_value self) { struct RArray *a = mrb_ary_ptr(self); @@ -591,6 +591,7 @@ mrb_ary_shift_m(mrb_state *mrb, mrb_value self) }; ary_modify_check(mrb, a); if (len == 0 || n == 0) return mrb_ary_new(mrb); + if (n < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "negative array shift"); if (n > len) n = len; val = mrb_ary_new_from_values(mrb, n, ARY_PTR(a)); if (ARY_SHARED_P(a)) { @@ -693,19 +694,6 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self) return self; } -MRB_API mrb_value -mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n) -{ - struct RArray *a = mrb_ary_ptr(ary); - mrb_int len = ARY_LEN(a); - - /* range check */ - if (n < 0) n += len; - if (n < 0 || len <= n) return mrb_nil_value(); - - return ARY_PTR(a)[n]; -} - MRB_API void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) { @@ -754,13 +742,16 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val /* range check */ if (head < 0) { head += alen; - if (head < 0) { - mrb_raise(mrb, E_INDEX_ERROR, "index is out of array"); - } + if (head < 0) goto out_of_range; + } + if (head > ARY_MAX_SIZE - len) { + out_of_range: + mrb_raisef(mrb, E_INDEX_ERROR, "index %i is out of array", head); } tail = head + len; if (alen < len || alen < tail) { len = alen - head; + tail = head + len; } /* size check */ @@ -786,12 +777,10 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val argv = &rpl; } if (head >= alen) { - if (head > ARY_MAX_SIZE - argc) { - mrb_raisef(mrb, E_INDEX_ERROR, "index %i too big", head); - } + if (head > ARY_MAX_SIZE - argc) goto out_of_range; len = head + argc; if (len > ARY_CAPA(a)) { - ary_expand_capa(mrb, a, head + argc); + ary_expand_capa(mrb, a, len); } ary_fill_with_nil(ARY_PTR(a) + alen, head - alen); if (argc > 0) { @@ -803,7 +792,8 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val mrb_int newlen; if (alen - len > ARY_MAX_SIZE - argc) { - mrb_raisef(mrb, E_INDEX_ERROR, "index %i too big", alen + argc - len); + head = alen + argc - len; + goto out_of_range; } newlen = alen + argc - len; if (newlen > ARY_CAPA(a)) { @@ -812,7 +802,6 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val if (len != argc) { mrb_value *ptr = ARY_PTR(a); - tail = head + len; value_move(ptr + head + argc, ptr + tail, alen - tail); ARY_SET_LEN(a, newlen); } @@ -843,7 +832,7 @@ ary_subseq(mrb_state *mrb, struct RArray *a, mrb_int beg, mrb_int len) return mrb_ary_new_from_values(mrb, len, ARY_PTR(a)+beg); } ary_make_shared(mrb, a); - b = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class); + b = MRB_OBJ_ALLOC(mrb, MRB_TT_ARRAY, mrb->array_class); b->as.heap.ptr = a->as.heap.ptr + beg; b->as.heap.len = len; b->as.heap.aux.shared = a->as.heap.aux.shared; @@ -1095,7 +1084,7 @@ mrb_ary_index_m(mrb_state *mrb, mrb_value self) for (i = 0; i < RARRAY_LEN(self); i++) { if (mrb_equal(mrb, RARRAY_PTR(self)[i], obj)) { - return mrb_fixnum_value(i); + return mrb_int_value(mrb, i); } } return mrb_nil_value(); @@ -1109,7 +1098,7 @@ mrb_ary_rindex_m(mrb_state *mrb, mrb_value self) for (i = RARRAY_LEN(self) - 1; i >= 0; i--) { if (mrb_equal(mrb, RARRAY_PTR(self)[i], obj)) { - return mrb_fixnum_value(i); + return mrb_int_value(mrb, i); } if (i > (len = RARRAY_LEN(self))) { i = len; @@ -1148,7 +1137,7 @@ mrb_ary_size(mrb_state *mrb, mrb_value self) { struct RArray *a = mrb_ary_ptr(self); - return mrb_fixnum_value(ARY_LEN(a)); + return mrb_int_value(mrb, ARY_LEN(a)); } MRB_API mrb_value @@ -1190,15 +1179,16 @@ mrb_ary_empty_p(mrb_state *mrb, mrb_value self) } MRB_API mrb_value -mrb_ary_entry(mrb_value ary, mrb_int offset) +mrb_ary_entry(mrb_value ary, mrb_int n) { - if (offset < 0) { - offset += RARRAY_LEN(ary); - } - if (offset < 0 || RARRAY_LEN(ary) <= offset) { - return mrb_nil_value(); - } - return RARRAY_PTR(ary)[offset]; + struct RArray *a = mrb_ary_ptr(ary); + mrb_int len = ARY_LEN(a); + + /* range check */ + if (n < 0) n += len; + if (n < 0 || len <= n) return mrb_nil_value(); + + return ARY_PTR(a)[n]; } static mrb_value @@ -1292,6 +1282,7 @@ mrb_ary_eq(mrb_state *mrb, mrb_value ary1) { mrb_value ary2 = mrb_get_arg1(mrb); + mrb->c->ci->mid = 0; if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value(); if (!mrb_array_p(ary2)) { return mrb_false_value(); @@ -1306,6 +1297,7 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1) { mrb_value ary2 = mrb_get_arg1(mrb); + mrb->c->ci->mid = 0; if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_fixnum_value(0); if (!mrb_array_p(ary2)) { return mrb_nil_value(); diff --git a/src/backtrace.c b/src/backtrace.c index 6e7e66f8c..d6648cc43 100644 --- a/src/backtrace.c +++ b/src/backtrace.c @@ -32,44 +32,64 @@ mrb_value mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace); static void each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, each_backtrace_func func, void *data) { - ptrdiff_t i; - int n = 0; - if (ciidx >= mrb->c->ciend - mrb->c->cibase) ciidx = 10; /* ciidx is broken... */ - for (i=ciidx; i >= 0; i--) { + for (ptrdiff_t i=ciidx; i >= 0; i--) { struct backtrace_location loc; mrb_callinfo *ci; - const mrb_irep *irep; + const mrb_irep *irep = 0; const mrb_code *pc; uint32_t idx; ci = &mrb->c->cibase[i]; - if (!ci->proc) continue; - if (MRB_PROC_CFUNC_P(ci->proc)) continue; - - irep = ci->proc->body.irep; - if (!irep) continue; - - if (mrb->c->cibase[i].pc) { - pc = &mrb->c->cibase[i].pc[-1]; + if (!ci->proc || MRB_PROC_CFUNC_P(ci->proc)) { + if (!ci->mid) continue; + loc.lineno = -1; + idx = 0; } else { - continue; + irep = ci->proc->body.irep; + if (!irep) continue; + if (mrb->c->cibase[i].pc) { + pc = &mrb->c->cibase[i].pc[-1]; + } + else { + continue; + } + idx = (uint32_t)(pc - irep->iseq); + loc.lineno = mrb_debug_get_line(mrb, irep, idx); + } + loc.method_id = ci->mid; + if (loc.lineno == -1) { + for (ptrdiff_t j=i-1; j >= 0; j--) { + ci = &mrb->c->cibase[j]; + + if (!ci->proc) continue; + if (MRB_PROC_CFUNC_P(ci->proc)) continue; + + irep = ci->proc->body.irep; + if (!irep) continue; + + if (mrb->c->cibase[j].pc) { + pc = &mrb->c->cibase[j].pc[-1]; + } + else { + continue; + } + + idx = (uint32_t)(pc - irep->iseq); + loc.lineno = mrb_debug_get_line(mrb, irep, idx); + if (loc.lineno > 0) break; + } } - - idx = (uint32_t)(pc - irep->iseq); - loc.lineno = mrb_debug_get_line(mrb, irep, idx); - if (n++ == 0 && loc.lineno == -1 && ci->acc < 0) continue; loc.filename = mrb_debug_get_filename(mrb, irep, idx); if (!loc.filename) { loc.filename = "(unknown)"; } - loc.method_id = ci->mid; func(mrb, &loc, data); } } @@ -82,22 +102,24 @@ print_backtrace(mrb_state *mrb, struct RObject *exc, mrb_value backtrace) mrb_int i; mrb_int n = RARRAY_LEN(backtrace); mrb_value *loc, mesg; - FILE *stream = stderr; if (n != 0) { - fprintf(stream, "trace (most recent call last):\n"); + if (n > 1) { + fprintf(stderr, "trace (most recent call last):\n"); + } for (i=n-1,loc=&RARRAY_PTR(backtrace)[i]; i>0; i--,loc--) { if (mrb_string_p(*loc)) { - fprintf(stream, "\t[%d] %.*s\n", + fprintf(stderr, "\t[%d] %.*s\n", (int)i, (int)RSTRING_LEN(*loc), RSTRING_PTR(*loc)); } } if (mrb_string_p(*loc)) { - fprintf(stream, "%.*s: ", (int)RSTRING_LEN(*loc), RSTRING_PTR(*loc)); + fprintf(stderr, "%.*s: ", (int)RSTRING_LEN(*loc), RSTRING_PTR(*loc)); } } mesg = mrb_exc_inspect(mrb, mrb_obj_value(exc)); - fprintf(stream, "%.*s\n", (int)RSTRING_LEN(mesg), RSTRING_PTR(mesg)); + fwrite(RSTRING_PTR(mesg), RSTRING_LEN(mesg), 1, stderr); + fputc('\n', stderr); } /* mrb_print_backtrace diff --git a/src/cdump.c b/src/cdump.c new file mode 100644 index 000000000..ecc27d9a1 --- /dev/null +++ b/src/cdump.c @@ -0,0 +1,468 @@ +/* +** dump.c - mruby binary dumper (mrbc binary format) +** +** See Copyright Notice in mruby.h +*/ + +#include <mruby.h> +#include <mruby/string.h> +#include <mruby/dump.h> +#include <mruby/irep.h> +#include <mruby/debug.h> + +#include <string.h> + +#ifndef MRB_NO_STDIO + +#ifndef MRB_NO_FLOAT +#include <mruby/endian.h> +#define MRB_FLOAT_FMT "%.17g" +#endif + +static int +cdump_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: +#ifndef MRB_NO_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); + } +#endif + break; + case IREP_TT_BIGINT: + { + const char *s = p->u.str; + int len = s[0]+2; + fputs("{IREP_TT_BIGINT, {\"", fp); + for (int i=0; i<len; i++) { + fprintf(fp, "\\x%02x", (int)s[i]&0xff); + } + fputs("\"}},\n", fp); + } + 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; +} + +static mrb_bool +sym_name_word_p(const char *name, mrb_int len) +{ + if (len == 0) return FALSE; + if (name[0] != '_' && !ISALPHA(name[0])) return FALSE; + for (int i = 1; i < len; i++) { + if (name[i] != '_' && !ISALNUM(name[i])) return FALSE; + } + return TRUE; +} + +static mrb_bool +sym_name_with_equal_p(const char *name, mrb_int len) +{ + return len >= 2 && name[len-1] == '=' && sym_name_word_p(name, len-1); +} + +static mrb_bool +sym_name_with_question_mark_p(const char *name, mrb_int len) +{ + return len >= 2 && name[len-1] == '?' && sym_name_word_p(name, len-1); +} + +static mrb_bool +sym_name_with_bang_p(const char *name, mrb_int len) +{ + return len >= 2 && name[len-1] == '!' && sym_name_word_p(name, len-1); +} + +static mrb_bool +sym_name_ivar_p(const char *name, mrb_int len) +{ + return len >= 2 && name[0] == '@' && sym_name_word_p(name+1, len-1); +} + +static mrb_bool +sym_name_cvar_p(const char *name, mrb_int len) +{ + return len >= 3 && name[0] == '@' && sym_name_ivar_p(name+1, len-1); +} + +#define OPERATOR_SYMBOL(sym_name, name) {name, sym_name, sizeof(sym_name)-1} +struct operator_symbol { + const char *name; + const char *sym_name; + uint16_t sym_name_len; +}; +static const struct operator_symbol operator_table[] = { + OPERATOR_SYMBOL("!", "not"), + OPERATOR_SYMBOL("%", "mod"), + OPERATOR_SYMBOL("&", "and"), + OPERATOR_SYMBOL("*", "mul"), + OPERATOR_SYMBOL("+", "add"), + OPERATOR_SYMBOL("-", "sub"), + OPERATOR_SYMBOL("/", "div"), + OPERATOR_SYMBOL("<", "lt"), + OPERATOR_SYMBOL(">", "gt"), + OPERATOR_SYMBOL("^", "xor"), + OPERATOR_SYMBOL("`", "tick"), + OPERATOR_SYMBOL("|", "or"), + OPERATOR_SYMBOL("~", "neg"), + OPERATOR_SYMBOL("!=", "neq"), + OPERATOR_SYMBOL("!~", "nmatch"), + OPERATOR_SYMBOL("&&", "andand"), + OPERATOR_SYMBOL("**", "pow"), + OPERATOR_SYMBOL("+@", "plus"), + OPERATOR_SYMBOL("-@", "minus"), + OPERATOR_SYMBOL("<<", "lshift"), + OPERATOR_SYMBOL("<=", "le"), + OPERATOR_SYMBOL("==", "eq"), + OPERATOR_SYMBOL("=~", "match"), + OPERATOR_SYMBOL(">=", "ge"), + OPERATOR_SYMBOL(">>", "rshift"), + OPERATOR_SYMBOL("[]", "aref"), + OPERATOR_SYMBOL("||", "oror"), + OPERATOR_SYMBOL("<=>", "cmp"), + OPERATOR_SYMBOL("===", "eqq"), + OPERATOR_SYMBOL("[]=", "aset"), +}; + +static const char* +sym_operator_name(const char *sym_name, mrb_int len) +{ + mrb_sym table_size = sizeof(operator_table)/sizeof(struct operator_symbol); + if (operator_table[table_size-1].sym_name_len < len) return NULL; + + mrb_sym start, idx; + int cmp; + const struct operator_symbol *op_sym; + for (start = 0; table_size != 0; table_size/=2) { + idx = start+table_size/2; + op_sym = &operator_table[idx]; + cmp = (int)len-(int)op_sym->sym_name_len; + if (cmp == 0) { + cmp = memcmp(sym_name, op_sym->sym_name, len); + if (cmp == 0) return op_sym->name; + } + if (0 < cmp) { + start = ++idx; + --table_size; + } + } + return NULL; +} + +static const char* +sym_var_name(mrb_state *mrb, const char *initname, const char *key, int n) +{ + char buf[32]; + mrb_value s = mrb_str_new_cstr(mrb, initname); + mrb_str_cat_lit(mrb, s, "_"); + mrb_str_cat_cstr(mrb, s, key); + mrb_str_cat_lit(mrb, s, "_"); + snprintf(buf, sizeof(buf), "%d", n); + mrb_str_cat_cstr(mrb, s, buf); + return RSTRING_PTR(s); +} + +static int +cdump_sym(mrb_state *mrb, mrb_sym sym, const char *var_name, int idx, mrb_value init_syms_code, FILE *fp) +{ + if (sym == 0) return MRB_DUMP_INVALID_ARGUMENT; + + mrb_int len; + const char *name = mrb_sym_name_len(mrb, sym, &len), *op_name; + if (!name) return MRB_DUMP_INVALID_ARGUMENT; + if (sym_name_word_p(name, len)) { + fprintf(fp, "MRB_SYM(%s)", name); + } + else if (sym_name_with_equal_p(name, len)) { + fprintf(fp, "MRB_SYM_E(%.*s)", (int)(len-1), name); + } + else if (sym_name_with_question_mark_p(name, len)) { + fprintf(fp, "MRB_SYM_Q(%.*s)", (int)(len-1), name); + } + else if (sym_name_with_bang_p(name, len)) { + fprintf(fp, "MRB_SYM_B(%.*s)", (int)(len-1), name); + } + else if (sym_name_ivar_p(name, len)) { + fprintf(fp, "MRB_IVSYM(%s)", name+1); + } + else if (sym_name_cvar_p(name, len)) { + fprintf(fp, "MRB_CVSYM(%s)", name+2); + } + else if ((op_name = sym_operator_name(name, len))) { + fprintf(fp, "MRB_OPSYM(%s)", op_name); + } + else { + char buf[32]; + mrb_value name_obj = mrb_str_new(mrb, name, len); + mrb_str_cat_lit(mrb, init_syms_code, " "); + mrb_str_cat_cstr(mrb, init_syms_code, var_name); + snprintf(buf, sizeof(buf), "[%d] = ", idx); + mrb_str_cat_cstr(mrb, init_syms_code, buf); + mrb_str_cat_lit(mrb, init_syms_code, "mrb_intern_lit(mrb, "); + mrb_str_cat_str(mrb, init_syms_code, mrb_str_dump(mrb, name_obj)); + mrb_str_cat_lit(mrb, init_syms_code, ");\n"); + fputs("0", fp); + } + fputs(", ", fp); + return MRB_DUMP_OK; +} + +static int +cdump_syms(mrb_state *mrb, const char *name, const char *key, int n, int syms_len, const mrb_sym *syms, mrb_value init_syms_code, FILE *fp) +{ + int ai = mrb_gc_arena_save(mrb); + mrb_int code_len = RSTRING_LEN(init_syms_code); + const char *var_name = sym_var_name(mrb, name, key, n); + fprintf(fp, "mrb_DEFINE_SYMS_VAR(%s, %d, (", var_name, syms_len); + for (int i=0; i<syms_len; i++) { + cdump_sym(mrb, syms[i], var_name, i, init_syms_code, fp); + } + fputs("), ", fp); + if (code_len == RSTRING_LEN(init_syms_code)) fputs("const", fp); + fputs(");\n", fp); + mrb_gc_arena_restore(mrb, ai); + return MRB_DUMP_OK; +} + +//Handle the simple/common case of debug_info: +// - 1 file associated with a single irep +// - mrb_debug_line_ary format only +static int +simple_debug_info(mrb_irep_debug_info *info) +{ + if (!info || info->flen != 1) { + return 0; + } + return 1; +} + +//Adds debug information to c-structs and +//adds filenames in init_syms_code block +static int +cdump_debug(mrb_state *mrb, const char *name, int n, mrb_irep_debug_info *info, + mrb_value init_syms_code, FILE *fp) +{ + char buffer[256]; + const char *filename; + mrb_int file_len; + int len, i; + const char *line_type = "mrb_debug_line_ary"; + + if (!simple_debug_info(info)) + return MRB_DUMP_INVALID_IREP; + + len = info->files[0]->line_entry_count; + + filename = mrb_sym_name_len(mrb, info->files[0]->filename_sym, &file_len); + snprintf(buffer, sizeof(buffer), " %s_debug_file_%d.filename_sym = mrb_intern_lit(mrb,\"", + name, n); + mrb_str_cat_cstr(mrb, init_syms_code, buffer); + mrb_str_cat_cstr(mrb, init_syms_code, filename); + mrb_str_cat_cstr(mrb, init_syms_code, "\");\n"); + + switch (info->files[0]->line_type) { + case mrb_debug_line_ary: + fprintf(fp, "static uint16_t %s_debug_lines_%d[%d] = {", name, n, len); + for (i=0; i<len; i++) { + if (i%10 == 0) fputs("\n", fp); + fprintf(fp, "0x%04x,", info->files[0]->lines.ary[i]); + } + fputs("};\n", fp); + break; + + case mrb_debug_line_flat_map: + line_type = "mrb_debug_line_flat_map"; + fprintf(fp, "static struct mrb_irep_debug_info_line %s_debug_lines_%d[%d] = {", name, n, len); + for (i=0; i<len; i++) { + mrb_irep_debug_info_line *fmap = &info->files[0]->lines.flat_map[i]; + fprintf(fp, "\t{.start_pos=0x%04x,.line=%d},\n", fmap->start_pos, fmap->line); + } + fputs("};\n", fp); + break; + + case mrb_debug_line_packed_map: + line_type = "mrb_debug_line_packed_map"; + fprintf(fp, "static char %s_debug_lines_%d[] = \"", name, n); + uint8_t *pmap = info->files[0]->lines.packed_map; + for (i=0; i<len; i++) { + fprintf(fp, "\\x%02x", pmap[i]&0xff); + } + fputs("\";\n", fp); + break; + } + fprintf(fp, "static mrb_irep_debug_info_file %s_debug_file_%d = {\n", name, n); + fprintf(fp, "%d, %d, %d, %s, {%s_debug_lines_%d}};\n", + info->files[0]->start_pos, + info->files[0]->filename_sym, + info->files[0]->line_entry_count, + line_type, + name,n); + fprintf(fp, "static mrb_irep_debug_info_file *%s_debug_file_%d_ = &%s_debug_file_%d;\n", name, n, name, n); + + fprintf(fp, "static mrb_irep_debug_info %s_debug_%d = {\n", name, n); + fprintf(fp, "%d, %d, &%s_debug_file_%d_};\n", info->pc_count, info->flen, name, n); + + return MRB_DUMP_OK; +} + +static int +cdump_irep_struct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *name, int n, mrb_value init_syms_code, int *mp) +{ + int i, len; + int max = *mp; + int debug_available = 0; + + /* dump reps */ + if (irep->reps) { + for (i=0,len=irep->rlen; i<len; i++) { + *mp += len; + if (cdump_irep_struct(mrb, irep->reps[i], flags, fp, name, max+i, init_syms_code, 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 (cdump_pool(mrb, &irep->pool[i], fp) != MRB_DUMP_OK) + return MRB_DUMP_INVALID_ARGUMENT; + } + fputs("};\n", fp); + } + /* dump syms */ + if (irep->syms) { + cdump_syms(mrb, name, "syms", n, irep->slen, irep->syms, init_syms_code, 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) { + cdump_syms(mrb, name, "lv", n, irep->nlocals-1, irep->lv, init_syms_code, fp); + } + /* dump debug */ + if (flags & MRB_DUMP_DEBUG_INFO) { + if(cdump_debug(mrb, name, n, irep->debug_info, + init_syms_code, fp) == MRB_DUMP_OK) { + debug_available = 1; + } + } + + + /* 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); + } + if(debug_available) { + fprintf(fp, " &%s_debug_%d,\n", name, n); + } + else { + 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) +{ + if (fp == NULL || initname == NULL || initname[0] == '\0') { + return MRB_DUMP_INVALID_ARGUMENT; + } + if (fprintf(fp, "#include <mruby.h>\n" + "#include <mruby/irep.h>\n" + "#include <mruby/debug.h>\n" + "#include <mruby/proc.h>\n" + "#include <mruby/presym.h>\n" + "\n") < 0) { + return MRB_DUMP_WRITE_FAULT; + } + fputs("#define mrb_BRACED(...) {__VA_ARGS__}\n", fp); + fputs("#define mrb_DEFINE_SYMS_VAR(name, len, syms, qualifier) \\\n", fp); + fputs(" static qualifier mrb_sym name[len] = mrb_BRACED syms\n", fp); + fputs("\n", fp); + mrb_value init_syms_code = mrb_str_new_capa(mrb, 0); + int max = 1; + int n = cdump_irep_struct(mrb, irep, flags, fp, initname, 0, init_syms_code, &max); + if (n != MRB_DUMP_OK) return n; + fprintf(fp, + "%s\n" + "const struct RProc %s[] = {{\n", + (flags & MRB_DUMP_STATIC) ? "static" + : "#ifdef __cplusplus\n" + "extern\n" + "#endif", + initname); + fprintf(fp, "NULL,NULL,MRB_TT_PROC,MRB_GC_RED,0,{&%s_irep_0},NULL,{NULL},\n}};\n", initname); + fputs("static void\n", fp); + fprintf(fp, "%s_init_syms(mrb_state *mrb)\n", initname); + fputs("{\n", fp); + fputs(RSTRING_PTR(init_syms_code), fp); + fputs("}\n", fp); + return MRB_DUMP_OK; +} +#endif diff --git a/src/class.c b/src/class.c index dfd25b371..fdf63794b 100644 --- a/src/class.c +++ b/src/class.c @@ -4,7 +4,6 @@ ** See Copyright Notice in mruby.h */ -#include <stdarg.h> #include <mruby.h> #include <mruby/array.h> #include <mruby/hash.h> @@ -341,7 +340,7 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o) struct RClass *sc, *c; if (o->c->tt == MRB_TT_SCLASS) return; - sc = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_SCLASS, mrb->class_class); + sc = MRB_OBJ_ALLOC(mrb, MRB_TT_SCLASS, mrb->class_class); sc->flags |= MRB_FL_CLASS_IS_INHERITED; sc->mt = mt_new(mrb); sc->iv = 0; @@ -800,18 +799,12 @@ mrb_notimplement_m(mrb_state *mrb, mrb_value self) return mrb_nil_value(); } -static mrb_value -to_ary(mrb_state *mrb, mrb_value val) -{ - mrb_check_type(mrb, val, MRB_TT_ARRAY); - return val; -} - -static mrb_value -to_hash(mrb_state *mrb, mrb_value val) +static void +ensure_class_type(mrb_state *mrb, mrb_value val) { - mrb_check_type(mrb, val, MRB_TT_HASH); - return val; + if (!class_ptr_p(val)) { + mrb_raisef(mrb, E_TYPE_ERROR, "%v is not class/module", val); + } } #define to_sym(mrb, ss) mrb_obj_to_sym(mrb, ss) @@ -859,6 +852,17 @@ mrb_get_arg1(mrb_state *mrb) return array_argv[0]; } +MRB_API mrb_bool +mrb_block_given_p(mrb_state *mrb) +{ + const mrb_callinfo *ci = mrb->c->ci; + int argc = ci->argc; + int idx = (argc < 0) ? 2 : argc + 1; + mrb_value b = ci->stack[idx]; + + return !mrb_nil_p(b); +} + void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self); /* @@ -873,52 +877,57 @@ void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self); string mruby type C type note ---------------------------------------------------------------------------------------------- o: Object [mrb_value] - C: Class/Module [mrb_value] + C: Class/Module [mrb_value] when ! follows, the value may be nil S: String [mrb_value] when ! follows, the value may be nil A: Array [mrb_value] when ! follows, the value may be nil H: Hash [mrb_value] when ! follows, the value may be nil s: String [const char*,mrb_int] Receive two arguments; s! gives (NULL,0) for nil z: String [const char*] NUL terminated string; z! gives NULL for nil a: Array [const mrb_value*,mrb_int] Receive two arguments; a! gives (NULL,0) for nil - c: Class/Module [strcut RClass*] + c: Class/Module [strcut RClass*] c! gives NULL for nil 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 - I: inline struct [void*] + I: inline struct [void*,struct RClass] I! gives NULL for nil &: block [mrb_value] &! raises exception if no block given *: rest argument [const mrb_value*,mrb_int] The rest of the arguments as an array; *! avoid copy of the stack |: optional Following arguments are optional ?: optional given [mrb_bool] true if preceding argument (optional) is given ':': keyword args [mrb_kwargs const] Get keyword arguments + + format modifiers: + + string note + ---------------------------------------------------------------------------------------------- + !: Switch to the alternate mode; The behaviour changes depending on the specifier + +: Request a not frozen object; However, except nil value */ MRB_API mrb_int mrb_get_args(mrb_state *mrb, const char *format, ...) { const char *fmt = format; char c; - mrb_int i = 0; + int i = 0; va_list ap; - mrb_int argc = mrb->c->ci->argc; - mrb_value *array_argv = mrb->c->ci->stack+1; + int argc = mrb->c->ci->argc; + const mrb_value *argv = mrb->c->ci->stack+1; mrb_bool argv_on_stack = argc >= 0; mrb_bool opt = FALSE; mrb_bool opt_skip = TRUE; - mrb_bool given = TRUE; + const mrb_value *pickarg = NULL; /* arguments currently being processed */ mrb_value kdict; mrb_bool reqkarg = FALSE; int argc_min = 0, argc_max = 0; if (!argv_on_stack) { - struct RArray *a = mrb_ary_ptr(*array_argv); - array_argv = ARY_PTR(a); + struct RArray *a = mrb_ary_ptr(*argv); + argv = ARY_PTR(a); argc = ARY_LEN(a); } va_start(ap, format); -#define ARGV array_argv - while ((c = *fmt++)) { switch (c) { case '|': @@ -930,6 +939,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) if (!reqkarg) reqkarg = strchr(fmt, ':') ? TRUE : FALSE; goto check_exit; case '!': + case '+': break; case ':': reqkarg = TRUE; @@ -945,9 +955,9 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } check_exit: - if (reqkarg && argc > argc_min && mrb_hash_p(kdict = ARGV[argc - 1])) { + if (reqkarg && argc > argc_min && mrb_hash_p(kdict = argv[argc - 1])) { mrb_hash_check_kdict(mrb, kdict); - argc --; + argc--; } else { kdict = mrb_nil_value(); @@ -956,16 +966,45 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) opt = FALSE; i = 0; while ((c = *format++)) { - mrb_value *argv = ARGV; - mrb_bool altmode; + mrb_bool altmode = FALSE; + mrb_bool needmodify = FALSE; + + for (; *format; format++) { + switch (*format) { + case '!': + if (altmode) goto modifier_exit; /* not accept for multiple '!' */ + altmode = TRUE; + break; + case '+': + if (needmodify) goto modifier_exit; /* not accept for multiple '+' */ + needmodify = TRUE; + break; + default: + goto modifier_exit; + } + } + modifier_exit: switch (c) { case '|': case '*': case '&': case '?': case ':': + if (needmodify) { + bad_needmodify: + mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong `%c+` modified specifer`", c); + } break; default: - if (argc <= i) { + if (i < argc) { + pickarg = &argv[i++]; + if (needmodify && !mrb_nil_p(*pickarg)) { + if (mrb_immediate_p(*pickarg)) { + mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %t", *pickarg); + } + mrb_check_frozen(mrb, mrb_obj_ptr(*pickarg)); + } + } + else { if (opt) { - given = FALSE; + pickarg = NULL; } else { mrb_argnum_error(mrb, argc, argc_min, argc_max); @@ -974,38 +1013,26 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) break; } - if (*format == '!') { - format ++; - altmode = TRUE; - } - else { - altmode = FALSE; - } - switch (c) { case 'o': - { - mrb_value *p; - - p = va_arg(ap, mrb_value*); - if (i < argc) { - *p = argv[i++]; - } - } - break; case 'C': + case 'S': + case 'A': + case 'H': { mrb_value *p; p = va_arg(ap, mrb_value*); - if (i < argc) { - mrb_value ss; - - ss = argv[i++]; - if (!class_ptr_p(ss)) { - mrb_raisef(mrb, E_TYPE_ERROR, "%v is not class/module", ss); + if (pickarg) { + if (!(altmode && mrb_nil_p(*pickarg))) { + switch (c) { + case 'C': ensure_class_type(mrb, *pickarg); break; + case 'S': mrb_ensure_string_type(mrb, *pickarg); break; + case 'A': mrb_ensure_array_type(mrb, *pickarg); break; + case 'H': mrb_ensure_hash_type(mrb, *pickarg); break; + } } - *p = ss; + *p = *pickarg; } } break; @@ -1014,114 +1041,72 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) struct RClass **p; p = va_arg(ap, struct RClass**); - if (i < argc) { - mrb_value ss; - - ss = argv[i++]; - if (!class_ptr_p(ss)) { - mrb_raisef(mrb, E_TYPE_ERROR, "%v is not class/module", ss); - } - *p = mrb_class_ptr(ss); - } - } - break; - case 'S': - { - mrb_value *p; - - p = va_arg(ap, mrb_value*); - if (i < argc) { - *p = argv[i++]; - if (!(altmode && mrb_nil_p(*p))) { - mrb_to_str(mrb, *p); + if (pickarg) { + if (altmode && mrb_nil_p(*pickarg)) { + *p = NULL; } - } - } - break; - case 'A': - { - mrb_value *p; - - p = va_arg(ap, mrb_value*); - if (i < argc) { - *p = argv[i++]; - if (!(altmode && mrb_nil_p(*p))) { - *p = to_ary(mrb, *p); - } - } - } - break; - case 'H': - { - mrb_value *p; - - p = va_arg(ap, mrb_value*); - if (i < argc) { - *p = argv[i++]; - if (!(altmode && mrb_nil_p(*p))) { - *p = to_hash(mrb, *p); + else { + ensure_class_type(mrb, *pickarg); + *p = mrb_class_ptr(*pickarg); } } } break; case 's': { - mrb_value ss; const char **ps = 0; mrb_int *pl = 0; ps = va_arg(ap, const char**); pl = va_arg(ap, mrb_int*); - if (i < argc) { - ss = argv[i++]; - if (altmode && mrb_nil_p(ss)) { + if (needmodify) goto bad_needmodify; + if (pickarg) { + if (altmode && mrb_nil_p(*pickarg)) { *ps = NULL; *pl = 0; } else { - mrb_to_str(mrb, ss); - *ps = RSTRING_PTR(ss); - *pl = RSTRING_LEN(ss); + mrb_ensure_string_type(mrb, *pickarg); + *ps = RSTRING_PTR(*pickarg); + *pl = RSTRING_LEN(*pickarg); } } } break; case 'z': { - mrb_value ss; const char **ps; ps = va_arg(ap, const char**); - if (i < argc) { - ss = argv[i++]; - if (altmode && mrb_nil_p(ss)) { + if (needmodify) goto bad_needmodify; + if (pickarg) { + if (altmode && mrb_nil_p(*pickarg)) { *ps = NULL; } else { - mrb_to_str(mrb, ss); - *ps = RSTRING_CSTR(mrb, ss); + mrb_ensure_string_type(mrb, *pickarg); + *ps = RSTRING_CSTR(mrb, *pickarg); } } } break; case 'a': { - mrb_value aa; struct RArray *a; const mrb_value **pb; mrb_int *pl; pb = va_arg(ap, const mrb_value**); pl = va_arg(ap, mrb_int*); - if (i < argc) { - aa = argv[i++]; - if (altmode && mrb_nil_p(aa)) { + if (needmodify) goto bad_needmodify; + if (pickarg) { + if (altmode && mrb_nil_p(*pickarg)) { *pb = 0; *pl = 0; } else { - aa = to_ary(mrb, aa); - a = mrb_ary_ptr(aa); + mrb_ensure_array_type(mrb, *pickarg); + a = mrb_ary_ptr(*pickarg); *pb = ARY_PTR(a); *pl = ARY_LEN(a); } @@ -1131,16 +1116,23 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) case 'I': { void* *p; - mrb_value ss; + struct RClass *klass; p = va_arg(ap, void**); - if (i < argc) { - ss = argv[i++]; - if (!mrb_istruct_p(ss)) - { - mrb_raisef(mrb, E_TYPE_ERROR, "%v is not inline struct", ss); + klass = va_arg(ap, struct RClass*); + if (pickarg) { + if (altmode && mrb_nil_p(*pickarg)) { + *p = NULL; + } + else { + if (!mrb_obj_is_kind_of(mrb, *pickarg, klass)) { + mrb_raisef(mrb, E_TYPE_ERROR, "%v is not a %C", *pickarg, klass); + } + if (!mrb_istruct_p(*pickarg)) { + mrb_raisef(mrb, E_TYPE_ERROR, "%v is not inline struct", *pickarg); + } + *p = mrb_istruct_ptr(*pickarg); } - *p = mrb_istruct_ptr(ss); } } break; @@ -1150,8 +1142,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_float *p; p = va_arg(ap, mrb_float*); - if (i < argc) { - *p = mrb_to_flo(mrb, argv[i++]); + if (pickarg) { + *p = mrb_as_float(mrb, *pickarg); } } break; @@ -1161,8 +1153,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_int *p; p = va_arg(ap, mrb_int*); - if (i < argc) { - *p = mrb_integer(mrb_to_int(mrb, argv[i++])); + if (pickarg) { + *p = mrb_as_int(mrb, *pickarg); } } break; @@ -1170,9 +1162,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) { mrb_bool *boolp = va_arg(ap, mrb_bool*); - if (i < argc) { - mrb_value b = argv[i++]; - *boolp = mrb_test(b); + if (pickarg) { + *boolp = mrb_test(*pickarg); } } break; @@ -1181,11 +1172,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_sym *symp; symp = va_arg(ap, mrb_sym*); - if (i < argc) { - mrb_value ss; - - ss = argv[i++]; - *symp = to_sym(mrb, ss); + if (pickarg) { + *symp = to_sym(mrb, *pickarg); } } break; @@ -1196,13 +1184,12 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) datap = va_arg(ap, void**); type = va_arg(ap, struct mrb_data_type const*); - if (i < argc) { - mrb_value dd = argv[i++]; - if (altmode && mrb_nil_p(dd)) { + if (pickarg) { + if (altmode && mrb_nil_p(*pickarg)) { *datap = 0; } else { - *datap = mrb_data_get_ptr(mrb, dd, type); + *datap = mrb_data_get_ptr(mrb, *pickarg, type); } } } @@ -1234,7 +1221,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_bool *p; p = va_arg(ap, mrb_bool*); - *p = given; + *p = pickarg ? TRUE : FALSE; } break; @@ -1288,7 +1275,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_raise(mrb, E_ARGUMENT_ERROR, "keyword number is too large"); } - for (j = required; j > 0; j --, kname ++, values ++) { + for (j = required; j > 0; j--, kname++, values++) { mrb_value k = mrb_symbol_value(*kname); if (!mrb_hash_key_p(mrb, ksrc, k)) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "missing keyword: %n", *kname); @@ -1297,7 +1284,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_gc_protect(mrb, *values); } - for (j = kwnum - required; j > 0; j --, kname ++, values ++) { + for (j = kwnum - required; j > 0; j--, kname++, values++) { mrb_value k = mrb_symbol_value(*kname); if (mrb_hash_key_p(mrb, ksrc, k)) { *values = mrb_hash_delete_key(mrb, ksrc, k); @@ -1328,8 +1315,6 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } } -#undef ARGV - if (!c && argc > i) { mrb_argnum_error(mrb, argc, argc_min, argc_max); } @@ -1344,7 +1329,7 @@ boot_defclass(mrb_state *mrb, struct RClass *super) { struct RClass *c; - c = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_CLASS, mrb->class_class); + c = MRB_OBJ_ALLOC(mrb, MRB_TT_CLASS, mrb->class_class); if (super) { c->super = super; mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)super); @@ -1367,7 +1352,7 @@ boot_initmod(mrb_state *mrb, struct RClass *mod) static struct RClass* include_class_new(mrb_state *mrb, struct RClass *m, struct RClass *super) { - struct RClass *ic = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, mrb->class_class); + struct RClass *ic = MRB_OBJ_ALLOC(mrb, MRB_TT_ICLASS, mrb->class_class); if (m->tt == MRB_TT_ICLASS) { m = m->c; } @@ -1435,7 +1420,7 @@ fix_include_module(mrb_state *mrb, struct RBasic *obj, void *data) { struct RClass **m = (struct RClass**)data; - if (obj->tt == MRB_TT_ICLASS && obj->c == m[0] && (obj->flags & MRB_FL_CLASS_IS_ORIGIN) == 0) { + if (obj->tt == MRB_TT_ICLASS && obj->c == m[0] && !MRB_FLAG_TEST(obj, MRB_FL_CLASS_IS_ORIGIN)) { struct RClass *ic = (struct RClass*)obj; include_module_at(mrb, ic, ic, m[1], 1); } @@ -1498,7 +1483,7 @@ mrb_prepend_module(mrb_state *mrb, struct RClass *c, struct RClass *m) else { c0 = c; } - origin = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, c0); + origin = MRB_OBJ_ALLOC(mrb, MRB_TT_ICLASS, c0); origin->flags |= MRB_FL_CLASS_IS_ORIGIN | MRB_FL_CLASS_IS_INHERITED; origin->super = c->super; c->super = origin; @@ -1713,7 +1698,11 @@ mrb_define_module_function(mrb_state *mrb, struct RClass *c, const char *name, m static void mc_clear(mrb_state *mrb) { - memset(mrb->cache, 0, MRB_METHOD_CACHE_SIZE*sizeof(mrb->cache[0])); + static const struct mrb_cache_entry ce_zero ={0}; + + for (int i=0; i<MRB_METHOD_CACHE_SIZE; i++) { + mrb->cache[i] = ce_zero; + } } void @@ -2169,7 +2158,7 @@ mrb_class_new(mrb_state *mrb, struct RClass *super) MRB_API struct RClass* mrb_module_new(mrb_state *mrb) { - struct RClass *m = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_MODULE, mrb->module_class); + struct RClass *m = MRB_OBJ_ALLOC(mrb, MRB_TT_MODULE, mrb->module_class); boot_initmod(mrb, m); return m; } @@ -2197,6 +2186,7 @@ mrb_obj_class(mrb_state *mrb, mrb_value obj) MRB_API void mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b) { + if (a == b) return; mrb_method_t m = mrb_method_search(mrb, c, b); if (!MRB_METHOD_CFUNC_P(m)) { @@ -2207,7 +2197,7 @@ mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b) } else if (p->color != MRB_GC_RED) { struct RClass *tc = MRB_PROC_TARGET_CLASS(p); - struct REnv *e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, NULL); + struct REnv *e = MRB_OBJ_ALLOC(mrb, MRB_TT_ENV, NULL); e->mid = b; if (tc) { @@ -2216,6 +2206,7 @@ mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b) } p->e.env = e; p->flags |= MRB_PROC_ENVSET; + mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e); } } mrb_define_method_raw(mrb, c, a, m); @@ -2269,6 +2260,8 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass) } } +void mrb_method_added(mrb_state *mrb, struct RClass *c, mrb_sym mid); + static mrb_value mrb_mod_alias(mrb_state *mrb, mrb_value mod) { @@ -2277,6 +2270,7 @@ mrb_mod_alias(mrb_state *mrb, mrb_value mod) mrb_get_args(mrb, "nn", &new_name, &old_name); mrb_alias_method(mrb, c, new_name, old_name); + mrb_method_added(mrb, c, new_name); return mod; } @@ -2389,7 +2383,7 @@ mrb_mod_const_get(mrb_state *mrb, mrb_value mod) } /* const get with class path string */ - path = mrb_ensure_string_type(mrb, path); + mrb_ensure_string_type(mrb, path); ptr = RSTRING_PTR(path); len = RSTRING_LEN(path); off = 0; @@ -2445,6 +2439,7 @@ mrb_mod_const_missing(mrb_state *mrb, mrb_value mod) mrb_sym sym; mrb_get_args(mrb, "n", &sym); + mrb->c->ci->mid = 0; if (mrb_class_real(mrb_class_ptr(mod)) != mrb->object_class) { mrb_name_error(mrb, sym, "uninitialized constant %v::%n", mod, sym); @@ -2492,6 +2487,22 @@ mrb_mod_method_defined(mrb_state *mrb, mrb_value mod) return mrb_bool_value(mrb_obj_respond_to(mrb, mrb_class_ptr(mod), id)); } +void +mrb_method_added(mrb_state *mrb, struct RClass *c, mrb_sym mid) +{ + mrb_sym added; + mrb_value recv = mrb_obj_value(c); + + if (c->tt == MRB_TT_SCLASS) { + added = MRB_SYM(singleton_method_added); + recv = mrb_iv_get(mrb, recv, MRB_SYM(__attached__)); + } + else { + added = MRB_SYM(method_added); + } + mrb_funcall_id(mrb, recv, added, 1, mrb_symbol_value(mid)); +} + mrb_value mrb_mod_define_method_m(mrb_state *mrb, struct RClass *c) { @@ -2516,11 +2527,12 @@ mrb_mod_define_method_m(mrb_state *mrb, struct RClass *c) if (mrb_nil_p(blk)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given"); } - p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class); + p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class); mrb_proc_copy(p, mrb_proc_ptr(blk)); p->flags |= MRB_PROC_STRICT; MRB_METHOD_FROM_PROC(m, p); mrb_define_method_raw(mrb, c, mid, m); + mrb_method_added(mrb, c, mid); return mrb_symbol_value(mid); } @@ -2879,6 +2891,7 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, bob, "__send__", mrb_f_send, MRB_ARGS_REQ(1)|MRB_ARGS_REST()|MRB_ARGS_BLOCK()); /* 15.3.1.3.5 */ mrb_define_method(mrb, bob, "equal?", mrb_obj_equal_m, MRB_ARGS_REQ(1)); /* 15.3.1.3.11 */ mrb_define_method(mrb, bob, "instance_eval", mrb_obj_instance_eval, MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK()); /* 15.3.1.3.18 */ + mrb_define_method(mrb, bob, "singleton_method_added", mrb_bob_init, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, cls, "new", mrb_class_new_class, MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK()); mrb_define_method(mrb, cls, "allocate", mrb_instance_alloc, MRB_ARGS_NONE()); @@ -2919,13 +2932,14 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, mod, "define_method", mod_define_method, MRB_ARGS_ARG(1,1)); mrb_define_method(mrb, mod, "===", mrb_mod_eqq, MRB_ARGS_REQ(1)); /* 15.2.2.4.7 */ mrb_define_method(mrb, mod, "dup", mrb_mod_dup, MRB_ARGS_NONE()); + mrb_define_method(mrb, bob, "method_added", mrb_bob_init, MRB_ARGS_REQ(1)); mrb_undef_method(mrb, cls, "append_features"); mrb_undef_method(mrb, cls, "prepend_features"); mrb_undef_method(mrb, cls, "extend_object"); mrb_undef_method(mrb, cls, "module_function"); - mrb->top_self = (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mrb->object_class); + mrb->top_self = MRB_OBJ_ALLOC(mrb, MRB_TT_OBJECT, mrb->object_class); mrb_define_singleton_method(mrb, mrb->top_self, "inspect", inspect_main, MRB_ARGS_NONE()); mrb_define_singleton_method(mrb, mrb->top_self, "to_s", inspect_main, MRB_ARGS_NONE()); mrb_define_singleton_method(mrb, mrb->top_self, "define_method", top_define_method, MRB_ARGS_ARG(1,1)); diff --git a/src/codedump.c b/src/codedump.c index f382bb7eb..431771ca9 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -57,7 +57,7 @@ print_header(mrb_state *mrb, const mrb_irep *irep, uint32_t i) printf("%03d ", (int)i); } -#define CASE(insn,ops) case insn: FETCH_ ## ops (); +#define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn static void codedump(mrb_state *mrb, const mrb_irep *irep) @@ -68,7 +68,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) const char *file = NULL, *next_file; if (!irep) return; - printf("irep %p nregs=%d nlocals=%d pools=%d syms=%d reps=%d iseq=%d\n", (void*)irep, + printf("irep %p nregs=%d nlocals=%d pools=%d syms=%d reps=%d ilen=%d\n", (void*)irep, irep->nregs, irep->nlocals, (int)irep->plen, (int)irep->slen, (int)irep->rlen, (int)irep->ilen); if (irep->lv) { @@ -128,23 +128,21 @@ codedump(mrb_state *mrb, const mrb_irep *irep) print_header(mrb, irep, (uint32_t)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_LOADL16, BS); - goto op_loadl; - CASE(OP_LOADL, BB); - op_loadl: + + CASE(OP_LOADL, BB): switch (irep->pool[b].tt) { - case IREP_TT_FLOAT: #ifndef MRB_NO_FLOAT + case IREP_TT_FLOAT: printf("OP_LOADL\tR%d\tL(%d)\t; %f", a, b, (double)irep->pool[b].u.f); -#endif break; +#endif case IREP_TT_INT32: printf("OP_LOADL\tR%d\tL(%d)\t; %" PRId32, a, b, irep->pool[b].u.i32); break; @@ -159,160 +157,160 @@ codedump(mrb_state *mrb, const mrb_irep *irep) } print_lv_a(mrb, irep, a); break; - CASE(OP_LOADI, BB); + CASE(OP_LOADI, BB): printf("OP_LOADI\tR%d\t%d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADINEG, BB); + CASE(OP_LOADINEG, BB): printf("OP_LOADI\tR%d\t-%d\t", a, b); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADI16, BS); + CASE(OP_LOADI16, BS): printf("OP_LOADI16\tR%d\t%d\t", a, (int)(int16_t)b); print_lv_a(mrb, irep, a); break; - CASE(OP_LOADI32, BSS); + CASE(OP_LOADI32, BSS): printf("OP_LOADI32\tR%d\t%d\t", a, (int32_t)(((uint32_t)b<<16)+c)); 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_LOADSYM16, BS); - goto op_loadsym; - CASE(OP_LOADSYM, BB); - op_loadsym: + 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); - printf("OP_GETGV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b])); + CASE(OP_GETGV, BB): + printf("OP_GETGV\tR%d\t%s\t", 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\t", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; - CASE(OP_GETSV, BB); - printf("OP_GETSV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b])); + CASE(OP_GETSV, BB): + printf("OP_GETSV\tR%d\t%s\t", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; - CASE(OP_SETSV, BB); - printf("OP_SETSV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a); + CASE(OP_SETSV, BB): + printf("OP_SETSV\t%s\tR%d\t", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; - CASE(OP_GETCONST, BB); - printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b])); + CASE(OP_GETCONST, BB): + printf("OP_GETCONST\tR%d\t%s\t", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; - CASE(OP_SETCONST, BB); - printf("OP_SETCONST\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a); + CASE(OP_SETCONST, BB): + printf("OP_SETCONST\t%s\tR%d\t", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; - CASE(OP_GETMCNST, BB); - printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym_dump(mrb, irep->syms[b])); + CASE(OP_GETMCNST, BB): + printf("OP_GETMCNST\tR%d\tR%d::%s\t", a, a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; - CASE(OP_SETMCNST, BB); - printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym_dump(mrb, irep->syms[b]), a); + CASE(OP_SETMCNST, BB): + printf("OP_SETMCNST\tR%d::%s\tR%d\t", a+1, mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; - CASE(OP_GETIV, BB); - printf("OP_GETIV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b])); + CASE(OP_GETIV, BB): + printf("OP_GETIV\tR%d\t%s\t", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; - CASE(OP_SETIV, BB); - printf("OP_SETIV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a); + CASE(OP_SETIV, BB): + printf("OP_SETIV\t%s\tR%d\t", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; - CASE(OP_GETUPVAR, BBB); - printf("OP_GETUPVAR\tR%d\t%d\t%d", a, b, c); + CASE(OP_GETUPVAR, BBB): + printf("OP_GETUPVAR\tR%d\t%d\t%d\t", a, b, c); print_lv_a(mrb, irep, a); break; - CASE(OP_SETUPVAR, BBB); - printf("OP_SETUPVAR\tR%d\t%d\t%d", a, b, c); + CASE(OP_SETUPVAR, BBB): + printf("OP_SETUPVAR\tR%d\t%d\t%d\t", a, b, c); print_lv_a(mrb, irep, a); break; - CASE(OP_GETCV, BB); - printf("OP_GETCV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b])); + CASE(OP_GETCV, BB): + printf("OP_GETCV\tR%d\t%s\t", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; - CASE(OP_SETCV, BB); - printf("OP_SETCV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a); + CASE(OP_SETCV, BB): + printf("OP_SETCV\t%s\tR%d\t", mrb_sym_dump(mrb, irep->syms[b]), a); print_lv_a(mrb, irep, a); break; - CASE(OP_JMP, S); + CASE(OP_JMP, S): i = pc - irep->iseq; printf("OP_JMP\t\t%03d\n", (int)i+(int16_t)a); break; - CASE(OP_JMPUW, S); + CASE(OP_JMPUW, S): i = pc - irep->iseq; printf("OP_JMPUW\t\t%03d\n", (int)i+(int16_t)a); break; - CASE(OP_JMPIF, BS); + CASE(OP_JMPIF, BS): i = pc - irep->iseq; printf("OP_JMPIF\tR%d\t%03d\t", a, (int)i+(int16_t)b); print_lv_a(mrb, irep, a); break; - CASE(OP_JMPNOT, BS); + CASE(OP_JMPNOT, BS): i = pc - irep->iseq; printf("OP_JMPNOT\tR%d\t%03d\t", a, (int)i+(int16_t)b); print_lv_a(mrb, irep, a); break; - CASE(OP_JMPNIL, BS); + CASE(OP_JMPNIL, BS): i = pc - irep->iseq; printf("OP_JMPNIL\tR%d\t%03d\t", a, (int)i+(int16_t)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_SENDVK, BB): + printf("OP_SENDVK\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b])); + break; + 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); - printf("OP_ARGARY\tR%d\t%d:%d:%d:%d (%d)", a, + CASE(OP_ARGARY, BS): + printf("OP_ARGARY\tR%d\t%d:%d:%d:%d (%d)\t", a, (b>>11)&0x3f, (b>>10)&0x1, (b>>5)&0x1f, @@ -320,7 +318,7 @@ codedump(mrb_state *mrb, const mrb_irep *irep) (b>>0)&0xf); print_lv_a(mrb, irep, a); break; - CASE(OP_ENTER, W); + CASE(OP_ENTER, W): printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n", MRB_ASPEC_REQ(a), MRB_ASPEC_OPT(a), @@ -330,31 +328,31 @@ codedump(mrb_state *mrb, const mrb_irep *irep) MRB_ASPEC_KDICT(a), MRB_ASPEC_BLOCK(a)); break; - CASE(OP_KEY_P, BB); + CASE(OP_KEY_P, BB): printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; - CASE(OP_KEYEND, Z); + CASE(OP_KEYEND, Z): printf("OP_KEYEND\n"); break; - CASE(OP_KARG, BB); + CASE(OP_KARG, BB): printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b])); print_lv_a(mrb, irep, a); break; - CASE(OP_RETURN, B); + CASE(OP_RETURN, B): printf("OP_RETURN\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_RETURN_BLK, B); + CASE(OP_RETURN_BLK, B): printf("OP_RETURN_BLK\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_BREAK, B); + CASE(OP_BREAK, B): printf("OP_BREAK\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_BLKPUSH, BS); - printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d (%d)", a, + CASE(OP_BLKPUSH, BS): + printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d (%d)\t", a, (b>>11)&0x3f, (b>>10)&0x1, (b>>5)&0x1f, @@ -362,112 +360,108 @@ codedump(mrb_state *mrb, const mrb_irep *irep) (b>>0)&0xf); print_lv_a(mrb, irep, a); break; - CASE(OP_LAMBDA, BB); - printf("OP_LAMBDA\tR%d\tI(%d:%p)\n", a, b, (void*)irep->reps[b]); - break; - CASE(OP_BLOCK, BB); - printf("OP_BLOCK\tR%d\tI(%d:%p)\n", a, b, (void*)irep->reps[b]); - break; - CASE(OP_METHOD, BB); - printf("OP_METHOD\tR%d\tI(%d:%p)\n", a, b, (void*)irep->reps[b]); - break; - CASE(OP_LAMBDA16, BS); + CASE(OP_LAMBDA, BB): printf("OP_LAMBDA\tR%d\tI(%d:%p)\n", a, b, (void*)irep->reps[b]); break; - CASE(OP_BLOCK16, BS); + CASE(OP_BLOCK, BB): printf("OP_BLOCK\tR%d\tI(%d:%p)\n", a, b, (void*)irep->reps[b]); break; - CASE(OP_METHOD16, BS); + CASE(OP_METHOD, BB): printf("OP_METHOD\tR%d\tI(%d:%p)\n", a, b, (void*)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\tR%d\n", a, a+1); break; - CASE(OP_ADDI, BB); - printf("OP_ADDI\tR%d\t%d\n", a, b); + CASE(OP_ADDI, BB): + printf("OP_ADDI\tR%d\t%d\t", a, b); + print_lv_a(mrb, irep, a); break; - CASE(OP_SUB, B); + CASE(OP_SUB, B): printf("OP_SUB\tR%d\tR%d\n", a, a+1); break; - CASE(OP_SUBI, BB); - printf("OP_SUBI\tR%d\t%d\n", a, b); + CASE(OP_SUBI, BB): + printf("OP_SUBI\tR%d\t%d\t", a, b); + print_lv_a(mrb, irep, a); break; - CASE(OP_MUL, B); + CASE(OP_MUL, B): printf("OP_MUL\tR%d\tR%d\n", a, a+1); break; - CASE(OP_DIV, B); + CASE(OP_DIV, B): printf("OP_DIV\tR%d\tR%d\n", a, a+1); break; - CASE(OP_LT, B); + CASE(OP_LT, B): printf("OP_LT\t\tR%d\tR%d\n", a, a+1); break; - CASE(OP_LE, B); + CASE(OP_LE, B): printf("OP_LE\t\tR%d\tR%d\n", a, a+1); break; - CASE(OP_GT, B); + CASE(OP_GT, B): printf("OP_GT\t\tR%d\tR%d\n", a, a+1); break; - CASE(OP_GE, B); + CASE(OP_GE, B): printf("OP_GE\t\tR%d\tR%d\n", a, a+1); break; - CASE(OP_EQ, B); + CASE(OP_EQ, B): printf("OP_EQ\t\tR%d\tR%d\n", a, a+1); 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); - printf("OP_ARYCAT\tR%d\t", a); + CASE(OP_ARYCAT, B): + printf("OP_ARYCAT\tR%d\tR%d\t", a, a+1); print_lv_a(mrb, irep, a); break; - CASE(OP_ARYPUSH, B); - printf("OP_ARYPUSH\tR%d\t", a); + CASE(OP_ARYPUSH, BB): + printf("OP_ARYPUSH\tR%d\t%d\t", a, b); 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); - printf("OP_INTERN\tR%d", a); + CASE(OP_INTERN, B): + printf("OP_INTERN\tR%d\t\t", a); + print_lv_a(mrb, irep, a); + break; + CASE(OP_SYMBOL, BB): + mrb_assert((irep->pool[b].tt&IREP_TT_NFLAG)==0); + printf("OP_SYMBOL\tR%d\tL(%d)\t; %s", a, b, irep->pool[b].u.str); print_lv_a(mrb, irep, a); break; - CASE(OP_STRING16, BS); - goto op_string; - CASE(OP_STRING, BB); - op_string: + CASE(OP_STRING, BB): + mrb_assert((irep->pool[b].tt&IREP_TT_NFLAG)==0); 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); } @@ -476,48 +470,48 @@ codedump(mrb_state *mrb, const mrb_irep *irep) } print_lv_a(mrb, irep, a); break; - CASE(OP_STRCAT, B); - printf("OP_STRCAT\tR%d\t", a); + CASE(OP_STRCAT, B): + printf("OP_STRCAT\tR%d\tR%d\n", a, a+1); 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, (void*)irep->reps[b]); print_lv_a(mrb, irep, a); break; - CASE(OP_SCLASS, B); + CASE(OP_SCLASS, B): printf("OP_SCLASS\tR%d\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_TCLASS, B); + CASE(OP_TCLASS, B): printf("OP_TCLASS\tR%d\t\t", a); print_lv_a(mrb, irep, a); break; - CASE(OP_ERR, B); + CASE(OP_ERR, B): if ((irep->pool[a].tt & IREP_TT_NFLAG) == 0) { printf("OP_ERR\t%s\n", irep->pool[a].u.str); } @@ -525,27 +519,52 @@ codedump(mrb_state *mrb, const mrb_irep *irep) printf("OP_ERR\tL(%d)\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_RAISEIF, B); + CASE(OP_RAISEIF, B): printf("OP_RAISEIF\tR%d\t\t", a); print_lv_a(mrb, irep, 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(); + 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(); + 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(); + switch (ins) { +#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); goto L_OP_ ## i; +#include "mruby/ops.h" +#undef OPCODE + } + break; + default: printf("OP_unknown (0x%x)\n", ins); break; diff --git a/src/debug.c b/src/debug.c index c03c91cf5..e570e8068 100644 --- a/src/debug.c +++ b/src/debug.c @@ -35,19 +35,46 @@ get_file(mrb_irep_debug_info *info, uint32_t pc) return *ret; } -static mrb_debug_line_type -select_line_type(const uint16_t *lines, size_t lines_len) +size_t +mrb_packed_int_len(uint32_t num) { - size_t line_count = 0; - int prev_line = -1; - size_t i; - for (i = 0; i < lines_len; ++i) { - if (lines[i] != prev_line) { - ++line_count; - } - } - return (sizeof(uint16_t) * lines_len) <= (sizeof(mrb_irep_debug_info_line) * line_count) - ? mrb_debug_line_ary : mrb_debug_line_flat_map; + size_t llen = 0; + + do { + llen++; + } while (num >>= 7); + return llen; +} + +size_t +mrb_packed_int_encode(uint32_t num, uint8_t *p, uint8_t *pend) +{ + size_t llen = 0; + + do { + uint8_t byte = num & 0x7f; + num >>= 7; + if (num != 0) byte |= 0x80; + if (p < pend) *p++ = byte; + llen++; + } while (num != 0); + + return llen; +} + +uint32_t +mrb_packed_int_decode(uint8_t *p, uint8_t **newpos) +{ + size_t i = 0, shift = 0; + uint32_t n = 0; + + do { + n |= ((uint32_t)(p[i] & 0x7f)) << shift; + i++; + shift += 7; + } while (shift < sizeof(uint32_t) * 8 && (p[i - 1] & 0x80)); + if (newpos) *newpos = p + i; + return n; } MRB_API char const* @@ -102,6 +129,19 @@ mrb_debug_get_line(mrb_state *mrb, const mrb_irep *irep, uint32_t pc) return ret->line; } + + case mrb_debug_line_packed_map: { + uint8_t *p = f->lines.packed_map; + uint8_t *pend = p + f->line_entry_count; + uint32_t pos = 0, line = 0, line_diff; + while (p < pend) { + pos += mrb_packed_int_decode(p, &p); + line_diff = mrb_packed_int_decode(p, &p); + if (pc < pos) break; + line += line_diff; + } + return line; + } } } } @@ -144,10 +184,7 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *d, } f = (mrb_irep_debug_info_file*)mrb_malloc(mrb, sizeof(*f)); - d->files = (mrb_irep_debug_info_file**)( - d->files - ? mrb_realloc(mrb, d->files, sizeof(mrb_irep_debug_info_file*) * (d->flen + 1)) - : mrb_malloc(mrb, sizeof(mrb_irep_debug_info_file*))); + d->files = (mrb_irep_debug_info_file**)mrb_realloc(mrb, d->files, sizeof(mrb_irep_debug_info_file*) * (d->flen + 1)); d->files[d->flen++] = f; file_pc_count = end_pos - start_pos; @@ -157,42 +194,32 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *d, fn_len = strlen(filename); f->filename_sym = mrb_intern(mrb, filename, fn_len); - - f->line_type = select_line_type(lines + start_pos, end_pos - start_pos); + f->line_type = mrb_debug_line_packed_map; f->lines.ptr = NULL; - switch (f->line_type) { - case mrb_debug_line_ary: - f->line_entry_count = file_pc_count; - f->lines.ary = (uint16_t*)mrb_malloc(mrb, sizeof(uint16_t) * file_pc_count); - for (i = 0; i < file_pc_count; ++i) { - f->lines.ary[i] = lines[start_pos + i]; - } - break; - - case mrb_debug_line_flat_map: { - uint16_t prev_line = 0; - mrb_irep_debug_info_line m; - f->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info_line) * 1); - f->line_entry_count = 0; - for (i = 0; i < file_pc_count; ++i) { - if (lines[start_pos + i] == prev_line) { continue; } - - f->lines.flat_map = (mrb_irep_debug_info_line*)mrb_realloc( - mrb, f->lines.flat_map, - sizeof(mrb_irep_debug_info_line) * (f->line_entry_count + 1)); - m.start_pos = start_pos + i; - m.line = lines[start_pos + i]; - f->lines.flat_map[f->line_entry_count] = m; - - /* update */ - ++f->line_entry_count; - prev_line = lines[start_pos + i]; - } - } break; - - default: mrb_assert(0); break; + uint16_t prev_line = 0; + uint32_t prev_pc = 0; + size_t packed_size = 0; + uint8_t *p, *pend; + + for (i = 0; i < file_pc_count; ++i) { + if (lines[start_pos + i] == prev_line) continue; + packed_size += mrb_packed_int_len(start_pos+i-prev_pc); + prev_pc = start_pos+i; + packed_size += mrb_packed_int_len(lines[start_pos+i]-prev_line); + prev_line = lines[start_pos + i]; + } + p = f->lines.packed_map = (uint8_t*)mrb_malloc(mrb, packed_size); + pend = p + packed_size; + prev_line = 0; prev_pc = 0; + for (i = 0; i < file_pc_count; ++i) { + if (lines[start_pos + i] == prev_line) continue; + p += mrb_packed_int_encode(start_pos+i-prev_pc, p, pend); + prev_pc = start_pos + i; + p += mrb_packed_int_encode(lines[start_pos + i]-prev_line, p, pend); + prev_line = lines[start_pos + i]; } + f->line_entry_count = (uint32_t)packed_size; return f; } diff --git a/src/dump.c b/src/dump.c index 91edf17d3..4327cb375 100644 --- a/src/dump.c +++ b/src/dump.c @@ -1,20 +1,18 @@ /* -** dump.c - mruby binary dumper (mrbc binary format) +** cdump.c - mruby binary dumper (in C) ** ** See Copyright Notice in mruby.h */ -#include <string.h> -#include <limits.h> -#include <math.h> +#include <mruby.h> #include <mruby/dump.h> #include <mruby/string.h> #include <mruby/irep.h> #include <mruby/debug.h> +#include <string.h> #ifndef MRB_NO_FLOAT #include <mruby/endian.h> -#define MRB_FLOAT_FMT "%.17g" #endif static size_t get_irep_record_size_1(mrb_state *mrb, const mrb_irep *irep); @@ -414,6 +412,10 @@ get_debug_record_size(mrb_state *mrb, const mrb_irep *irep) ret += (sizeof(uint32_t) + sizeof(uint16_t)) * (size_t)(file->line_entry_count); break; + case mrb_debug_line_packed_map: + ret += (size_t)(file->line_entry_count); + break; + default: mrb_assert(0); break; } } @@ -508,6 +510,11 @@ write_debug_record_1(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, mrb_sym } } break; + case mrb_debug_line_packed_map: { + memcpy(cur, file->lines.packed_map, file->line_entry_count); + cur += file->line_entry_count; + } break; + default: mrb_assert(0); break; } } @@ -929,428 +936,4 @@ mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *f 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: -#ifndef MRB_NO_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); - } -#endif - break; - case IREP_TT_BIGINT: - { - const char *s = p->u.str; - int len = s[0]+2; - fputs("{IREP_TT_BIGINT, {\"", fp); - for (int i=0; i<len; i++) { - fprintf(fp, "\\x%02x", (int)s[i]&0xff); - } - fputs("\"}},\n", fp); - } - 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; -} - -static mrb_bool -sym_name_word_p(const char *name, mrb_int len) -{ - if (len == 0) return FALSE; - if (name[0] != '_' && !ISALPHA(name[0])) return FALSE; - for (int i = 1; i < len; i++) { - if (name[i] != '_' && !ISALNUM(name[i])) return FALSE; - } - return TRUE; -} - -static mrb_bool -sym_name_with_equal_p(const char *name, mrb_int len) -{ - return len >= 2 && name[len-1] == '=' && sym_name_word_p(name, len-1); -} - -static mrb_bool -sym_name_with_question_mark_p(const char *name, mrb_int len) -{ - return len >= 2 && name[len-1] == '?' && sym_name_word_p(name, len-1); -} - -static mrb_bool -sym_name_with_bang_p(const char *name, mrb_int len) -{ - return len >= 2 && name[len-1] == '!' && sym_name_word_p(name, len-1); -} - -static mrb_bool -sym_name_ivar_p(const char *name, mrb_int len) -{ - return len >= 2 && name[0] == '@' && sym_name_word_p(name+1, len-1); -} - -static mrb_bool -sym_name_cvar_p(const char *name, mrb_int len) -{ - return len >= 3 && name[0] == '@' && sym_name_ivar_p(name+1, len-1); -} - -#define OPERATOR_SYMBOL(sym_name, name) {name, sym_name, sizeof(sym_name)-1} -struct operator_symbol { - const char *name; - const char *sym_name; - uint16_t sym_name_len; -}; -static const struct operator_symbol operator_table[] = { - OPERATOR_SYMBOL("!", "not"), - OPERATOR_SYMBOL("%", "mod"), - OPERATOR_SYMBOL("&", "and"), - OPERATOR_SYMBOL("*", "mul"), - OPERATOR_SYMBOL("+", "add"), - OPERATOR_SYMBOL("-", "sub"), - OPERATOR_SYMBOL("/", "div"), - OPERATOR_SYMBOL("<", "lt"), - OPERATOR_SYMBOL(">", "gt"), - OPERATOR_SYMBOL("^", "xor"), - OPERATOR_SYMBOL("`", "tick"), - OPERATOR_SYMBOL("|", "or"), - OPERATOR_SYMBOL("~", "neg"), - OPERATOR_SYMBOL("!=", "neq"), - OPERATOR_SYMBOL("!~", "nmatch"), - OPERATOR_SYMBOL("&&", "andand"), - OPERATOR_SYMBOL("**", "pow"), - OPERATOR_SYMBOL("+@", "plus"), - OPERATOR_SYMBOL("-@", "minus"), - OPERATOR_SYMBOL("<<", "lshift"), - OPERATOR_SYMBOL("<=", "le"), - OPERATOR_SYMBOL("==", "eq"), - OPERATOR_SYMBOL("=~", "match"), - OPERATOR_SYMBOL(">=", "ge"), - OPERATOR_SYMBOL(">>", "rshift"), - OPERATOR_SYMBOL("[]", "aref"), - OPERATOR_SYMBOL("||", "oror"), - OPERATOR_SYMBOL("<=>", "cmp"), - OPERATOR_SYMBOL("===", "eqq"), - OPERATOR_SYMBOL("[]=", "aset"), -}; - -static const char* -sym_operator_name(const char *sym_name, mrb_int len) -{ - mrb_sym table_size = sizeof(operator_table)/sizeof(struct operator_symbol); - if (operator_table[table_size-1].sym_name_len < len) return NULL; - - mrb_sym start, idx; - int cmp; - const struct operator_symbol *op_sym; - for (start = 0; table_size != 0; table_size/=2) { - idx = start+table_size/2; - op_sym = &operator_table[idx]; - cmp = (int)len-(int)op_sym->sym_name_len; - if (cmp == 0) { - cmp = memcmp(sym_name, op_sym->sym_name, len); - if (cmp == 0) return op_sym->name; - } - if (0 < cmp) { - start = ++idx; - --table_size; - } - } - return NULL; -} - -static const char* -sym_var_name(mrb_state *mrb, const char *initname, const char *key, int n) -{ - char buf[32]; - mrb_value s = mrb_str_new_cstr(mrb, initname); - mrb_str_cat_lit(mrb, s, "_"); - mrb_str_cat_cstr(mrb, s, key); - mrb_str_cat_lit(mrb, s, "_"); - snprintf(buf, sizeof(buf), "%d", n); - mrb_str_cat_cstr(mrb, s, buf); - return RSTRING_PTR(s); -} - -static int -dump_sym(mrb_state *mrb, mrb_sym sym, const char *var_name, int idx, mrb_value init_syms_code, FILE *fp) -{ - if (sym == 0) return MRB_DUMP_INVALID_ARGUMENT; - - mrb_int len; - const char *name = mrb_sym_name_len(mrb, sym, &len), *op_name; - if (!name) return MRB_DUMP_INVALID_ARGUMENT; - if (sym_name_word_p(name, len)) { - fprintf(fp, "MRB_SYM(%s)", name); - } - else if (sym_name_with_equal_p(name, len)) { - fprintf(fp, "MRB_SYM_E(%.*s)", (int)(len-1), name); - } - else if (sym_name_with_question_mark_p(name, len)) { - fprintf(fp, "MRB_SYM_Q(%.*s)", (int)(len-1), name); - } - else if (sym_name_with_bang_p(name, len)) { - fprintf(fp, "MRB_SYM_B(%.*s)", (int)(len-1), name); - } - else if (sym_name_ivar_p(name, len)) { - fprintf(fp, "MRB_IVSYM(%s)", name+1); - } - else if (sym_name_cvar_p(name, len)) { - fprintf(fp, "MRB_CVSYM(%s)", name+2); - } - else if ((op_name = sym_operator_name(name, len))) { - fprintf(fp, "MRB_OPSYM(%s)", op_name); - } - else { - char buf[32]; - mrb_value name_obj = mrb_str_new(mrb, name, len); - mrb_str_cat_lit(mrb, init_syms_code, " "); - mrb_str_cat_cstr(mrb, init_syms_code, var_name); - snprintf(buf, sizeof(buf), "[%d] = ", idx); - mrb_str_cat_cstr(mrb, init_syms_code, buf); - mrb_str_cat_lit(mrb, init_syms_code, "mrb_intern_lit(mrb, "); - mrb_str_cat_str(mrb, init_syms_code, mrb_str_dump(mrb, name_obj)); - mrb_str_cat_lit(mrb, init_syms_code, ");\n"); - fputs("0", fp); - } - fputs(", ", fp); - return MRB_DUMP_OK; -} - -static int -dump_syms(mrb_state *mrb, const char *name, const char *key, int n, int syms_len, const mrb_sym *syms, mrb_value init_syms_code, FILE *fp) -{ - int ai = mrb_gc_arena_save(mrb); - mrb_int code_len = RSTRING_LEN(init_syms_code); - const char *var_name = sym_var_name(mrb, name, key, n); - fprintf(fp, "mrb_DEFINE_SYMS_VAR(%s, %d, (", var_name, syms_len); - for (int i=0; i<syms_len; i++) { - dump_sym(mrb, syms[i], var_name, i, init_syms_code, fp); - } - fputs("), ", fp); - if (code_len == RSTRING_LEN(init_syms_code)) fputs("const", fp); - fputs(");\n", fp); - mrb_gc_arena_restore(mrb, ai); - return MRB_DUMP_OK; -} - -//Handle the simple/common case of debug_info: -// - 1 file associated with a single irep -// - mrb_debug_line_ary format only -static int -simple_debug_info(mrb_irep_debug_info *info) -{ - if (!info || - info->flen != 1 || - info->files[0]->line_type != mrb_debug_line_ary) { - return 0; - } - return 1; -} - -//Adds debug information to c-structs and -//adds filenames in init_syms_code block -static int -dump_debug(mrb_state *mrb, const char *name, int n, mrb_irep_debug_info *info, - mrb_value init_syms_code, FILE *fp) -{ - char buffer[256]; - const char *filename; - mrb_int file_len; - int len, i; - - if (!simple_debug_info(info)) - return MRB_DUMP_INVALID_IREP; - - len = info->files[0]->line_entry_count; - - filename = mrb_sym_name_len(mrb, info->files[0]->filename_sym, &file_len); - snprintf(buffer, sizeof(buffer), " %s_debug_file_%d.filename_sym = mrb_intern_lit(mrb,\"", - name, n); - mrb_str_cat_cstr(mrb, init_syms_code, buffer); - mrb_str_cat_cstr(mrb, init_syms_code, filename); - mrb_str_cat_cstr(mrb, init_syms_code, "\");\n"); - - fprintf(fp, "static uint16_t %s_debug_lines_%d[%d] = {", name, n, len); - for (i=0; i<len; i++) { - if (i%10 == 0) fputs("\n", fp); - fprintf(fp, "0x%04x,", info->files[0]->lines.ary[i]); - } - fputs("};\n", fp); - - fprintf(fp, "static mrb_irep_debug_info_file %s_debug_file_%d = {\n", name, n); - fprintf(fp, "%d, %d, %d, mrb_debug_line_ary, {%s_debug_lines_%d}};\n", - info->files[0]->start_pos, - info->files[0]->filename_sym, - info->files[0]->line_entry_count, - name,n); - fprintf(fp, "static mrb_irep_debug_info_file *%s_debug_file_%d_ = &%s_debug_file_%d;\n", name, n, name, n); - - fprintf(fp, "static mrb_irep_debug_info %s_debug_%d = {\n", name, n); - fprintf(fp, "%d, %d, &%s_debug_file_%d_};\n", info->pc_count, info->flen, name, n); - - 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, mrb_value init_syms_code, int *mp) -{ - int i, len; - int max = *mp; - int debug_available = 0; - - /* 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, init_syms_code, 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) { - dump_syms(mrb, name, "syms", n, irep->slen, irep->syms, init_syms_code, 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) { - dump_syms(mrb, name, "lv", n, irep->nlocals-1, irep->lv, init_syms_code, fp); - } - /* dump debug */ - if (flags & MRB_DUMP_DEBUG_INFO) { - if(dump_debug(mrb, name, n, irep->debug_info, - init_syms_code, fp) == MRB_DUMP_OK) { - debug_available = 1; - } - } - - - /* 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); - } - if(debug_available) { - fprintf(fp, " &%s_debug_%d,\n", name, n); - } - else { - 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) -{ - if (fp == NULL || initname == NULL || initname[0] == '\0') { - return MRB_DUMP_INVALID_ARGUMENT; - } - if (fprintf(fp, "#include <mruby.h>\n" - "#include <mruby/irep.h>\n" - "#include <mruby/debug.h>\n" - "#include <mruby/proc.h>\n" - "#include <mruby/presym.h>\n" - "\n") < 0) { - return MRB_DUMP_WRITE_FAULT; - } - fputs("#define mrb_BRACED(...) {__VA_ARGS__}\n", fp); - fputs("#define mrb_DEFINE_SYMS_VAR(name, len, syms, qualifier) \\\n", fp); - fputs(" static qualifier mrb_sym name[len] = mrb_BRACED syms\n", fp); - fputs("\n", fp); - mrb_value init_syms_code = mrb_str_new_capa(mrb, 0); - int max = 1; - int n = dump_irep_struct(mrb, irep, flags, fp, initname, 0, init_syms_code, &max); - if (n != MRB_DUMP_OK) return n; - fprintf(fp, - "%s\n" - "const struct RProc %s[] = {{\n", - (flags & MRB_DUMP_STATIC) ? "static" - : "#ifdef __cplusplus\n" - "extern\n" - "#endif", - initname); - fprintf(fp, "NULL,NULL,MRB_TT_PROC,MRB_GC_RED,0,{&%s_irep_0},NULL,{NULL},\n}};\n", initname); - fputs("static void\n", fp); - fprintf(fp, "%s_init_syms(mrb_state *mrb)\n", initname); - fputs("{\n", fp); - fputs(RSTRING_PTR(init_syms_code), fp); - fputs("}\n", fp); - return MRB_DUMP_OK; -} - #endif /* MRB_NO_STDIO */ diff --git a/src/error.c b/src/error.c index 5d9b367bd..5ceff2436 100644 --- a/src/error.c +++ b/src/error.c @@ -5,7 +5,6 @@ */ #include <errno.h> -#include <stdarg.h> #include <stdlib.h> #include <mruby.h> #include <mruby/array.h> @@ -19,17 +18,20 @@ #include <mruby/presym.h> MRB_API mrb_value -mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, size_t len) +mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str) { - mrb_value arg = mrb_str_new(mrb, ptr, len); - return mrb_obj_new(mrb, c, 1, &arg); + mrb_ensure_string_type(mrb, str); + + struct RBasic* e = mrb_obj_alloc(mrb, MRB_TT_EXCEPTION, c); + mrb_value exc = mrb_obj_value(e); + mrb_iv_set(mrb, exc, MRB_SYM(mesg), str); + return exc; } MRB_API mrb_value -mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str) +mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, size_t len) { - mrb_to_str(mrb, str); - return mrb_obj_new(mrb, c, 1, &str); + return mrb_exc_new_str(mrb, c, mrb_str_new(mrb, ptr, len)); } /* @@ -287,7 +289,7 @@ mrb_vformat(mrb_state *mrb, const char *format, va_list ap) #else i = *p == 'd' ? (mrb_int)va_arg(ap, int) : va_arg(ap, mrb_int); #endif - obj = mrb_fixnum_value(i); + obj = mrb_int_value(mrb, i); goto L_cat_obj; #ifndef MRB_NO_FLOAT case 'f': @@ -302,6 +304,7 @@ mrb_vformat(mrb_state *mrb, const char *format, va_list ap) obj = mrb_str_new(mrb, chars, len); goto L_cat_obj; } + L_cat_plain: mrb_str_cat(mrb, result, b, e - b - 1); mrb_str_cat(mrb, result, chars, len); b = ++p; @@ -325,10 +328,15 @@ mrb_vformat(mrb_state *mrb, const char *format, va_list ap) obj = va_arg(ap, mrb_value); L_cat_obj: str = (inspect ? mrb_inspect : mrb_obj_as_string)(mrb, obj); - chars = RSTRING_PTR(str); - len = RSTRING_LEN(str); - inspect = FALSE; - goto L_cat; + if (mrb_type(str) != MRB_TT_STRING) { + chars = "void (no string conversion)"; + len = strlen(chars); + } + else { + chars = RSTRING_PTR(str); + len = RSTRING_LEN(str); + } + goto L_cat_plain; case 'C': cls = va_arg(ap, struct RClass*); L_cat_class: @@ -352,7 +360,7 @@ mrb_vformat(mrb_state *mrb, const char *format, va_list ap) L_cat_current: chars = p; len = 1; - goto L_cat; + goto L_cat_plain; default: mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p); } @@ -381,41 +389,37 @@ mrb_format(mrb_state *mrb, const char *format, ...) return str; } -static mrb_noreturn void -raise_va(mrb_state *mrb, struct RClass *c, const char *fmt, va_list ap, int argc, mrb_value *argv) +static mrb_value +error_va(mrb_state *mrb, struct RClass *c, const char *fmt, va_list ap) { - mrb_value mesg; - - mesg = mrb_vformat(mrb, fmt, ap); - if (argv == NULL) { - argv = &mesg; - } - else { - argv[0] = mesg; - } - mrb_exc_raise(mrb, mrb_obj_new(mrb, c, argc+1, argv)); + mrb_value mesg = mrb_vformat(mrb, fmt, ap); + return mrb_exc_new_str(mrb, c, mesg); } MRB_API mrb_noreturn void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...) { - va_list args; + va_list ap; + mrb_value exc; - va_start(args, fmt); - raise_va(mrb, c, fmt, args, 0, NULL); - va_end(args); + va_start(ap, fmt); + exc = error_va(mrb, c, fmt, ap); + va_end(ap); + + mrb_exc_raise(mrb, exc); } MRB_API mrb_noreturn void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...) { - mrb_value argv[2]; - va_list args; + va_list ap; + mrb_value exc; - va_start(args, fmt); - argv[1] = mrb_symbol_value(id); - raise_va(mrb, E_NAME_ERROR, fmt, args, 1, argv); - va_end(args); + va_start(ap, fmt); + exc = error_va(mrb, E_NAME_ERROR, fmt, ap); + va_end(ap); + mrb_iv_set(mrb, exc, MRB_IVSYM(name), mrb_symbol_value(id)); + mrb_exc_raise(mrb, exc); } MRB_API void @@ -524,16 +528,14 @@ mrb_sys_fail(mrb_state *mrb, const char *mesg) MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, char const* fmt, ...) { - mrb_value exc; - mrb_value argv[3]; va_list ap; + mrb_value exc; va_start(ap, fmt); - argv[0] = mrb_vformat(mrb, fmt, ap); - argv[1] = mrb_symbol_value(id); - argv[2] = args; + exc = error_va(mrb, E_NOMETHOD_ERROR, fmt, ap); va_end(ap); - exc = mrb_obj_new(mrb, E_NOMETHOD_ERROR, 3, argv); + mrb_iv_set(mrb, exc, MRB_IVSYM(name), mrb_symbol_value(id)); + mrb_iv_set(mrb, exc, MRB_IVSYM(args), args); mrb_exc_raise(mrb, exc); } @@ -15,7 +15,7 @@ mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const mrb { struct RData *data; - data = (struct RData*)mrb_obj_alloc(mrb, MRB_TT_DATA, klass); + data = MRB_OBJ_ALLOC(mrb, MRB_TT_DATA, klass); data->data = ptr; data->type = type; @@ -158,11 +158,35 @@ mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f) { union mrb_value_ v; +#ifdef MRB_WORDBOX_NO_FLOAT_TRUNCATE v.p = mrb_obj_alloc(mrb, MRB_TT_FLOAT, mrb->float_class); v.fp->f = f; MRB_SET_FROZEN_FLAG(v.bp); +#elif defined(MRB_64BIT) && defined(MRB_USE_FLOAT32) + v.w = 0; + v.f = f; + v.w = ((v.w<<2) & ~3) | 2; +#else + v.f = f; + v.w = (v.w & ~3) | 2; +#endif return v.value; } + + +#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE +MRB_API mrb_float +mrb_word_boxing_value_float(mrb_value v) +{ + union mrb_value_ u; + u.value = v; + u.w = u.w & ~3; +#if defined(MRB_64BIT) && defined(MRB_USE_FLOAT32) + u.w >>= 2; +#endif + return u.f; +} +#endif #endif /* MRB_NO_FLOAT */ MRB_API mrb_value @@ -185,7 +209,7 @@ MRB_API mrb_value mrb_xxx_boxing_cptr_value(mrb_state *mrb, void *p) { mrb_value v; - struct RCptr *cptr = (struct RCptr*)mrb_obj_alloc(mrb, MRB_TT_CPTR, mrb->object_class); + struct RCptr *cptr = MRB_OBJ_ALLOC(mrb, MRB_TT_CPTR, mrb->object_class); SET_OBJ_VALUE(v, cptr); cptr->p = p; diff --git a/src/fmt_fp.c b/src/fmt_fp.c index d3fe97ce3..bcb9ccc24 100644 --- a/src/fmt_fp.c +++ b/src/fmt_fp.c @@ -1,463 +1,363 @@ #include <mruby.h> -#if !defined(MRB_NO_FLOAT) -#if defined(MRB_NO_STDIO) || defined(_WIN32) || defined(_WIN64) -/* - -Most code in this file originates from musl (src/stdio/vfprintf.c) -which, just like mruby itself, is licensed under the MIT license. - -Copyright (c) 2005-2014 Rich Felker, et al. - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -*/ - -#include <limits.h> #include <string.h> -#include <math.h> -#include <float.h> -#include <ctype.h> -#include <mruby/string.h> +#ifndef MRB_NO_FLOAT +/*********************************************************************** -struct fmt_args; + Routine for converting a single-precision + floating point number into a string. -typedef void output_func(struct fmt_args *f, const char *s, size_t l); + The code in this function was inspired from Fred Bayer's pdouble.c. + Since pdouble.c was released as Public Domain, I'm releasing this + code as public domain as well. -struct fmt_args { - mrb_state *mrb; - output_func *output; - void *opaque; -}; + Dave Hylands -struct mrb_cstr { - char *buf; - size_t len; -}; + The original code can be found in https://github.com/dhylands/format-float +***********************************************************************/ -#define MAX(a,b) ((a)>(b) ? (a) : (b)) -#define MIN(a,b) ((a)<(b) ? (a) : (b)) +/*********************************************************************** -/* Convenient bit representation for modifier flags, which all fall - * within 31 codepoints of the space character. */ + I modified the routine for mruby: -#define ALT_FORM (1U<<('#'-' ')) -#define ZERO_PAD (1U<<('0'-' ')) -#define LEFT_ADJ (1U<<('-'-' ')) -#define PAD_POS (1U<<(' '-' ')) -#define MARK_POS (1U<<('+'-' ')) + * support `double` + * support `#` (alt_form) modifier -#define FLAGMASK (ALT_FORM|ZERO_PAD|LEFT_ADJ|PAD_POS|MARK_POS) + My modifications in this file are also placed in the public domain. -static output_func strcat_value; -static output_func strcat_cstr; + Matz (Yukihiro Matsumoto) -static void -strcat_value(struct fmt_args *f, const char *s, size_t l) -{ - mrb_value str = *(mrb_value*)f->opaque; - mrb_str_cat(f->mrb, str, s, l); -} +***********************************************************************/ -static void -strcat_cstr(struct fmt_args *f, const char *s, size_t l) -{ - struct mrb_cstr *cstr = (struct mrb_cstr*)f->opaque; +#include <math.h> - if (l > cstr->len) { - mrb_state *mrb = f->mrb; +#ifdef MRB_USE_FLOAT32 - mrb_raise(mrb, E_ARGUMENT_ERROR, "string buffer too small"); - } +// 1 sign bit, 8 exponent bits, and 23 mantissa bits. +// exponent values 0 and 255 are reserved, exponent can be 1 to 254. +// exponent is stored with a bias of 127. +// The min and max floats are on the order of 1x10^37 and 1x10^-37 - memcpy(cstr->buf, s, l); +#define FLT_DECEXP 32 +#define FLT_ROUND_TO_ONE 0.9999995F +#define FLT_MIN_BUF_SIZE 6 // -9e+99 - cstr->buf += l; - cstr->len -= l; -} +#else -static void -out(struct fmt_args *f, const char *s, size_t l) -{ - f->output(f, s, l); -} +// 1 sign bit, 11 exponent bits, and 52 mantissa bits. -#define PAD_SIZE 256 -static void -pad(struct fmt_args *f, char c, ptrdiff_t w, ptrdiff_t l, uint32_t fl) -{ - char pad[PAD_SIZE]; - if (fl & (LEFT_ADJ | ZERO_PAD) || l >= w) return; - l = w - l; - memset(pad, c, l>PAD_SIZE ? PAD_SIZE : l); - for (; l >= PAD_SIZE; l -= PAD_SIZE) - out(f, pad, PAD_SIZE); - out(f, pad, l); -} +#define FLT_DECEXP 256 +#define FLT_ROUND_TO_ONE 0.999999999995 +#define FLT_MIN_BUF_SIZE 7 // -9e+199 -static const char xdigits[16] = { - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' -}; +#endif /* MRB_USE_FLOAT32 */ -static char* -fmt_u(uint32_t x, char *s) -{ - for (; x; x /= 10) *--s = '0' + x % 10; - return s; -} - -/* Do not override this check. The floating-point printing code below - * depends on the float.h constants being right. If they are wrong, it - * may overflow the stack. */ -#if LDBL_MANT_DIG == 53 -typedef char compiler_defines_long_double_incorrectly[9-(int)sizeof(long double)]; +static const mrb_float g_pos_pow[] = { +#ifndef MRB_USE_FLOAT32 + 1e256, 1e128, 1e64, #endif + 1e32, 1e16, 1e8, 1e4, 1e2, 1e1 +}; +static const mrb_float g_neg_pow[] = { +#ifndef MRB_USE_FLOAT32 + 1e-256, 1e-128, 1e-64, +#endif + 1e-32, 1e-16, 1e-8, 1e-4, 1e-2, 1e-1 +}; -static int -fmt_fp(struct fmt_args *f, long double y, ptrdiff_t w, ptrdiff_t p, uint32_t fl, int t) -{ - uint32_t big[(LDBL_MANT_DIG+28)/29 + 1 // mantissa expansion - + (LDBL_MAX_EXP+LDBL_MANT_DIG+28+8)/9]; // exponent expansion - uint32_t *a, *d, *r, *z; - uint32_t i; - int e2=0, e, j; - ptrdiff_t l; - char buf[9+LDBL_MANT_DIG/4], *s; - const char *prefix="-0X+0X 0X-0x+0x 0x"; - ptrdiff_t pl; - char ebuf0[3*sizeof(int)], *ebuf=&ebuf0[3*sizeof(int)], *estr; - - pl=1; - if (signbit(y)) { - y=-y; - } else if (fl & MARK_POS) { - prefix+=3; - } else if (fl & PAD_POS) { - prefix+=6; - } else prefix++, pl=0; - - if (!isfinite(y)) { - const char *ss = (t&32)?"inf":"INF"; - if (y!=y) ss=(t&32)?"nan":"NAN"; - pad(f, ' ', w, 3+pl, fl&~ZERO_PAD); - out(f, prefix, pl); - out(f, ss, 3); - pad(f, ' ', w, 3+pl, fl^LEFT_ADJ); - return (int)MAX(w, 3+pl); +/* + * mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, char sign) + * + * fmt: should be one of 'e', 'E', 'f', 'F', 'g', or 'G'. (|0x80 for '#') + * prec: is the precision (as specified in printf) + * sign: should be '\0', '+', or ' ' ('\0' is the normal one - only print + * a sign if ```f``` is negative. Anything else is printed as the + * sign character for positive numbers. + */ + +int +mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, char sign) { + char *s = buf; + int buf_remaining = buf_size - 1; + int alt_form = 0; + + if ((uint8_t)fmt & 0x80) { + fmt &= 0x7f; /* turn off alt_form flag */ + alt_form = 1; } + if (buf_size <= FLT_MIN_BUF_SIZE) { + // Smallest exp notion is -9e+99 (-9e+199) which is 6 (7) chars plus terminating + // null. - y = frexp((double)y, &e2) * 2; - if (y) e2--; - - if ((t|32)=='a') { - long double round = 8.0; - ptrdiff_t re; - - if (t&32) prefix += 9; - pl += 2; + if (buf_size >= 2) { + *s++ = '?'; + } + if (buf_size >= 1) { + *s++ = '\0'; + } + return buf_size >= 2; + } + if (signbit(f)) { + *s++ = '-'; + f = -f; + } else if (sign) { + *s++ = sign; + } + buf_remaining -= (s - buf); // Adjust for sign + + { + char uc = fmt & 0x20; + if (isinf(f)) { + *s++ = 'I' ^ uc; + *s++ = 'N' ^ uc; + *s++ = 'F' ^ uc; + goto ret; + } else if (isnan(f)) { + *s++ = 'N' ^ uc; + *s++ = 'A' ^ uc; + *s++ = 'N' ^ uc; + ret: + *s = '\0'; + return s - buf; + } + } - if (p<0 || p>=LDBL_MANT_DIG/4-1) re=0; - else re=LDBL_MANT_DIG/4-1-p; + if (prec < 0) { + prec = 6; + } + char e_char = 'E' | (fmt & 0x20); // e_char will match case of fmt + fmt |= 0x20; // Force fmt to be lowercase + char org_fmt = fmt; + if (fmt == 'g' && prec == 0) { + prec = 1; + } + int e, e1; + int dec = 0; + char e_sign = '\0'; + int num_digits = 0; + const mrb_float *pos_pow = g_pos_pow; + const mrb_float *neg_pow = g_neg_pow; + + if (f == 0.0) { + e = 0; + if (fmt == 'e') { + e_sign = '+'; + } else if (fmt == 'f') { + num_digits = prec + 1; + } + } else if (f < 1.0) { // f < 1.0 + char first_dig = '0'; + if (f >= FLT_ROUND_TO_ONE) { + first_dig = '1'; + } - if (re) { - while (re--) round*=16; - if (*prefix=='-') { - y=-y; - y-=round; - y+=round; - y=-y; + // Build negative exponent + for (e = 0, e1 = FLT_DECEXP; e1; e1 >>= 1, pos_pow++, neg_pow++) { + if (*neg_pow > f) { + e += e1; + f *= *pos_pow; } - else { - y+=round; - y-=round; + } + char e_sign_char = '-'; + if (f < 1.0) { + if (f >= FLT_ROUND_TO_ONE) { + f = 1.0; + if (e == 0) { + e_sign_char = '+'; + } + } else { + e++; + f *= 10.0; } } - estr=fmt_u(e2<0 ? -e2 : e2, ebuf); - if (estr==ebuf) *--estr='0'; - *--estr = (e2<0 ? '-' : '+'); - *--estr = t+('p'-'a'); - - s=buf; - do { - int x=(int)y; - *s++=xdigits[x]|(t&32); - y=16*(y-x); - if (s-buf==1 && (y||p>0||(fl&ALT_FORM))) *s++='.'; - } while (y); - - if (p && s-buf-2 < p) - l = (p+2) + (ebuf-estr); - else - l = (s-buf) + (ebuf-estr); - - pad(f, ' ', w, pl+l, fl); - out(f, prefix, pl); - pad(f, '0', w, pl+l, fl^ZERO_PAD); - out(f, buf, s-buf); - pad(f, '0', l-(ebuf-estr)-(s-buf), 0, 0); - out(f, estr, ebuf-estr); - pad(f, ' ', w, pl+l, fl^LEFT_ADJ); - return (int)MAX(w, pl+l); - } - if (p<0) p=6; - - if (y) y *= 268435456.0, e2-=28; + // If the user specified 'g' format, and e is <= 4, then we'll switch + // to the fixed format ('f') - if (e2<0) a=r=z=big; - else a=r=z=big+sizeof(big)/sizeof(*big) - LDBL_MANT_DIG - 1; + if (fmt == 'f' || (fmt == 'g' && e <= 4)) { + fmt = 'f'; + dec = -1; + *s++ = first_dig; - do { - *z = (uint32_t)y; - y = 1000000000*(y-*z++); - } while (y); - - while (e2>0) { - uint32_t carry=0; - int sh=MIN(29,e2); - for (d=z-1; d>=a; d--) { - uint64_t x = ((uint64_t)*d<<sh)+carry; - *d = x % 1000000000; - carry = (uint32_t)(x / 1000000000); + if (org_fmt == 'g') { + prec += (e - 1); + } + // truncate precision to prevent buffer overflow + if (prec + 2 > buf_remaining) { + prec = buf_remaining - 2; + } + num_digits = prec; + if (num_digits || alt_form) { + *s++ = '.'; + while (--e && num_digits) { + *s++ = '0'; + num_digits--; + } + } + } else { + // For e & g formats, we'll be printing the exponent, so set the + // sign. + e_sign = e_sign_char; + dec = 0; + + if (prec > (buf_remaining - FLT_MIN_BUF_SIZE)) { + prec = buf_remaining - FLT_MIN_BUF_SIZE; + if (fmt == 'g') { + prec++; + } + } } - if (carry) *--a = carry; - while (z>a && !z[-1]) z--; - e2-=sh; - } - while (e2<0) { - uint32_t carry=0, *b; - int sh=MIN(9,-e2), need=1+((int)p+LDBL_MANT_DIG/3+8)/9; - for (d=a; d<z; d++) { - uint32_t rm = *d & ((1<<sh)-1); - *d = (*d>>sh) + carry; - carry = (1000000000>>sh) * rm; + } else { + // Build positive exponent + for (e = 0, e1 = FLT_DECEXP; e1; e1 >>= 1, pos_pow++, neg_pow++) { + if (*pos_pow <= f) { + e += e1; + f *= *neg_pow; + } } - if (!*a) a++; - if (carry) *z++ = carry; - /* Avoid (slow!) computation past requested precision */ - b = (t|32)=='f' ? r : a; - if (z-b > need) z = b+need; - e2+=sh; - } - if (a<z) for (i=10, e=9*(int)(r-a); *a>=i; i*=10, e++); - else e=0; - - /* Perform rounding: j is precision after the radix (possibly neg) */ - j = (int)p - ((t|32)!='f')*e - ((t|32)=='g' && p); - if (j < 9*(z-r-1)) { - uint32_t x; - /* We avoid C's broken division of negative numbers */ - d = r + 1 + ((j+9*LDBL_MAX_EXP)/9 - LDBL_MAX_EXP); - j += 9*LDBL_MAX_EXP; - j %= 9; - for (i=10, j++; j<9; i*=10, j++); - x = *d % i; - /* Are there any significant digits past j? */ - if (x || d+1!=z) { - long double round = 2/LDBL_EPSILON; - long double small; - if (*d/i & 1) round += 2; - if (x<i/2) small=0.5; - else if (x==i/2 && d+1==z) small=1.0; - else small=1.5; - if (pl && *prefix=='-') round*=-1, small*=-1; - *d -= x; - /* Decide whether to round by probing round+small */ - if (round+small != round) { - *d = *d + i; - while (*d > 999999999) { - *d--=0; - if (d<a) *--a=0; - (*d)++; + // If the user specified fixed format (fmt == 'f') and e makes the + // number too big to fit into the available buffer, then we'll + // switch to the 'e' format. + + if (fmt == 'f') { + if (e >= buf_remaining) { + fmt = 'e'; + } else if ((e + prec + 2) > buf_remaining) { + prec = buf_remaining - e - 2; + if (prec < 0) { + // This means no decimal point, so we can add one back + // for the decimal. + prec++; } - for (i=10, e=9*(int)(r-a); *a>=i; i*=10, e++); } } - if (z>d+1) z=d+1; - } - for (; z>a && !z[-1]; z--); - - if ((t|32)=='g') { - if (!p) p++; - if (p>e && e>=-4) { - t--; - p-=e+1; - } - else { - t-=2; - p--; - } - if (!(fl&ALT_FORM)) { - /* Count trailing zeros in last place */ - if (z>a && z[-1]) for (i=10, j=0; z[-1]%i==0; i*=10, j++); - else j=9; - if ((t|32)=='f') - p = MIN(p,MAX(0,9*(z-r-1)-j)); - else - p = MIN(p,MAX(0,9*(z-r-1)+e-j)); + if (fmt == 'e' && prec > (buf_remaining - 6)) { + prec = buf_remaining - 6; } - } - l = 1 + p + (p || (fl&ALT_FORM)); - if ((t|32)=='f') { - if (e>0) l+=e; - } - else { - estr=fmt_u(e<0 ? -e : e, ebuf); - while(ebuf-estr<2) *--estr='0'; - *--estr = (e<0 ? '-' : '+'); - *--estr = t; - l += ebuf-estr; - } + // If the user specified 'g' format, and e is < prec, then we'll switch + // to the fixed format. - pad(f, ' ', w, pl+l, fl); - out(f, prefix, pl); - pad(f, '0', w, pl+l, fl^ZERO_PAD); - - if ((t|32)=='f') { - if (a>r) a=r; - for (d=a; d<=r; d++) { - char *ss = fmt_u(*d, buf+9); - if (d!=a) while (ss>buf) *--ss='0'; - else if (ss==buf+9) *--ss='0'; - out(f, ss, buf+9-ss); + if (fmt == 'g' && e < prec) { + fmt = 'f'; + prec -= (e + 1); } - if (p || (fl&ALT_FORM)) out(f, ".", 1); - for (; d<z && p>0; d++, p-=9) { - char *ss = fmt_u(*d, buf+9); - while (ss>buf) *--ss='0'; - out(f, ss, MIN(9,p)); + if (fmt == 'f') { + dec = e; + num_digits = prec + e + 1; + } else { + e_sign = '+'; } - pad(f, '0', p+9, 9, 0); } - else { - if (z<=a) z=a+1; - for (d=a; d<z && p>=0; d++) { - char *ss = fmt_u(*d, buf+9); - if (ss==buf+9) *--ss='0'; - if (d!=a) while (ss>buf) *--ss='0'; - else { - out(f, ss++, 1); - if (p>0||(fl&ALT_FORM)) out(f, ".", 1); - } - out(f, ss, MIN(buf+9-ss, p)); - p -= (int)(buf+9-ss); - } - pad(f, '0', p+18, 18, 0); - out(f, estr, ebuf-estr); + if (prec < 0) { + // This can happen when the prec is trimmed to prevent buffer overflow + prec = 0; } - pad(f, ' ', w, pl+l, fl^LEFT_ADJ); - - return (int)MAX(w, pl+l); -} - -static int -fmt_core(struct fmt_args *f, const char *fmt, mrb_float flo) -{ - ptrdiff_t w, p; - uint32_t fl; - - if (*fmt != '%') { - return -1; - } - ++fmt; - - /* Read modifier flags */ - for (fl=0; (unsigned)*fmt-' '<32 && (FLAGMASK&(1U<<(*fmt-' '))); fmt++) - fl |= 1U<<(*fmt-' '); - - /* - and 0 flags are mutually exclusive */ - if (fl & LEFT_ADJ) fl &= ~ZERO_PAD; - - for (w = 0; ISDIGIT(*fmt); ++fmt) { - w = 10 * w + (*fmt - '0'); + // We now have f as a floating point number between >= 1 and < 10 + // (or equal to zero), and e contains the absolute value of the power of + // 10 exponent. and (dec + 1) == the number of dgits before the decimal. + + // For e, prec is # digits after the decimal + // For f, prec is # digits after the decimal + // For g, prec is the max number of significant digits + // + // For e & g there will be a single digit before the decimal + // for f there will be e digits before the decimal + + if (fmt == 'e') { + num_digits = prec + 1; + } else if (fmt == 'g') { + if (prec == 0) { + prec = 1; + } + num_digits = prec; } - if (*fmt == '.') { - ++fmt; - for (p = 0; ISDIGIT(*fmt); ++fmt) { - p = 10 * p + (*fmt - '0'); + // Print the digits of the mantissa + for (int i = 0; i < num_digits; ++i, --dec) { + int8_t d = (int8_t)((int)f)%10; + *s++ = '0' + d; + if (dec == 0 && (prec > 0 || alt_form)) { + *s++ = '.'; } - } - else { - p = -1; + f -= (mrb_float)d; + f *= 10.0; } - switch (*fmt) { - case 'e': case 'f': case 'g': case 'a': - case 'E': case 'F': case 'G': case 'A': - return fmt_fp(f, flo, w, p, fl, *fmt); - default: - return -1; + // Round + if (f >= 5.0) { + char *rs = s; + rs--; + while (1) { + if (*rs == '.') { + rs--; + continue; + } + if (*rs < '0' || *rs > '9') { + // + or - + rs++; // So we sit on the digit to the right of the sign + break; + } + if (*rs < '9') { + (*rs)++; + break; + } + *rs = '0'; + if (rs == buf) { + break; + } + rs--; + } + if (*rs == '0') { + // We need to insert a 1 + if (rs[1] == '.' && fmt != 'f') { + // We're going to round 9.99 to 10.00 + // Move the decimal point + rs[0] = '.'; + rs[1] = '0'; + if (e_sign == '-') { + e--; + } else { + e++; + } + } + s++; + char *ss = s; + while (ss > rs) { + *ss = ss[-1]; + ss--; + } + *rs = '1'; + if (f < 1.0 && fmt == 'f') { + // We rounded up to 1.0 + prec--; + } + } } -} -MRB_API mrb_value -mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt) -{ - struct fmt_args f; - mrb_value str = mrb_str_new_capa(mrb, 24); - - f.mrb = mrb; - f.output = strcat_value; - f.opaque = (void*)&str; - if (fmt_core(&f, fmt, mrb_float(flo)) < 0) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format string"); + if (org_fmt == 'g' && prec > 0 && !alt_form) { + // Remove trailing zeros and a trailing decimal point + while (s[-1] == '0') { + s--; + } + if (s[-1] == '.') { + s--; + } } - return str; -} - -MRB_API int -mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float fval) -{ - struct fmt_args f; - struct mrb_cstr cstr; - - cstr.buf = buf; - cstr.len = len - 1; /* reserve NUL terminator */ - f.mrb = mrb; - f.output = strcat_cstr; - f.opaque = (void*)&cstr; - if (fmt_core(&f, fmt, fval) < 0) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format string"); + // Append the exponent + if (e_sign) { + *s++ = e_char; + *s++ = e_sign; + if (e >= 100) { + *s++ = '0' + (e / 100); + e %= 100; + } + *s++ = '0' + (e / 10); + *s++ = '0' + (e % 10); } - *cstr.buf = '\0'; - return (int)(cstr.buf - buf); -} -#else /* MRB_NO_STDIO || _WIN32 || _WIN64 */ -#include <stdio.h> - -MRB_API mrb_value -mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt) -{ - char buf[25]; - - snprintf(buf, sizeof(buf), fmt, mrb_float(flo)); - return mrb_str_new_cstr(mrb, buf); -} + *s = '\0'; -MRB_API int -mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float fval) -{ - return snprintf(buf, len, fmt, fval); + return s - buf; } -#endif /* MRB_NO_STDIO || _WIN32 || _WIN64 */ #endif @@ -5,7 +5,6 @@ */ #include <string.h> -#include <stdlib.h> #ifdef MRB_USE_MALLOC_TRIM #include <malloc.h> #endif @@ -24,6 +23,10 @@ #include <mruby/throw.h> #include <mruby/presym.h> +#ifdef MRB_GC_STRESS +#include <stdlib.h> +#endif + /* = Tri-color Incremental Garbage Collection @@ -131,12 +134,6 @@ typedef struct { struct RFiber fiber; struct RException exc; struct RBreak brk; -#ifdef MRB_WORD_BOXING -#ifndef MRB_NO_FLOAT - struct RFloat floatv; -#endif - struct RCptr cptr; -#endif } as; } RVALUE; @@ -295,7 +292,7 @@ MRB_API void* mrb_alloca(mrb_state *mrb, size_t size) { struct RString *s; - s = (struct RString*)mrb_obj_alloc(mrb, MRB_TT_STRING, mrb->string_class); + s = MRB_OBJ_ALLOC(mrb, MRB_TT_STRING, mrb->string_class); return s->as.heap.ptr = (char*)mrb_malloc(mrb, size); } @@ -745,6 +742,7 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) } break; + case MRB_TT_STRUCT: case MRB_TT_ARRAY: { struct RArray *a = (struct RArray*)obj; @@ -860,6 +858,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end) } break; + case MRB_TT_STRUCT: case MRB_TT_ARRAY: if (ARY_SHARED_P(obj)) mrb_ary_decref(mrb, ((struct RArray*)obj)->as.heap.aux.shared); @@ -1044,6 +1043,7 @@ gc_gray_counts(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj) } break; + case MRB_TT_STRUCT: case MRB_TT_ARRAY: { struct RArray *a = (struct RArray*)obj; @@ -1468,7 +1468,7 @@ gc_disable(mrb_state *mrb, mrb_value obj) /* * call-seq: - * GC.interval_ratio -> fixnum + * GC.interval_ratio -> int * * Returns ratio of GC interval. Default value is 200(%). * @@ -1477,12 +1477,12 @@ gc_disable(mrb_state *mrb, mrb_value obj) static mrb_value gc_interval_ratio_get(mrb_state *mrb, mrb_value obj) { - return mrb_fixnum_value(mrb->gc.interval_ratio); + return mrb_int_value(mrb, mrb->gc.interval_ratio); } /* * call-seq: - * GC.interval_ratio = fixnum -> nil + * GC.interval_ratio = int -> nil * * Updates ratio of GC interval. Default value is 200(%). * GC start as soon as after end all step of GC if you set 100(%). @@ -1501,7 +1501,7 @@ gc_interval_ratio_set(mrb_state *mrb, mrb_value obj) /* * call-seq: - * GC.step_ratio -> fixnum + * GC.step_ratio -> int * * Returns step span ratio of Incremental GC. Default value is 200(%). * @@ -1510,12 +1510,12 @@ gc_interval_ratio_set(mrb_state *mrb, mrb_value obj) static mrb_value gc_step_ratio_get(mrb_state *mrb, mrb_value obj) { - return mrb_fixnum_value(mrb->gc.step_ratio); + return mrb_int_value(mrb, mrb->gc.step_ratio); } /* * call-seq: - * GC.step_ratio = fixnum -> nil + * GC.step_ratio = int -> nil * * Updates step span ratio of Incremental GC. Default value is 200(%). * 1 step of incrementalGC becomes long if a rate is big. diff --git a/src/hash.c b/src/hash.c index 3b5d17761..918722a2b 100644 --- a/src/hash.c +++ b/src/hash.c @@ -970,7 +970,7 @@ h_key_for(mrb_state *mrb, mrb_value key) static struct RHash* h_alloc(mrb_state *mrb) { - return (struct RHash*)mrb_obj_alloc(mrb, MRB_TT_HASH, mrb->hash_class); + return MRB_OBJ_ALLOC(mrb, MRB_TT_HASH, mrb->hash_class); } static void @@ -1482,6 +1482,7 @@ static mrb_value mrb_hash_delete(mrb_state *mrb, mrb_value self) { mrb_value key = mrb_get_arg1(mrb); + mrb->c->ci->mid = 0; return mrb_hash_delete_key(mrb, self, key); } diff --git a/src/kernel.c b/src/kernel.c index 25aa41baf..f8ef1bfe1 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -84,8 +84,8 @@ mrb_equal_m(mrb_state *mrb, mrb_value self) * Document-method: object_id * * call-seq: - * obj.__id__ -> fixnum - * obj.object_id -> fixnum + * obj.__id__ -> int + * obj.object_id -> int * * Returns an integer identifier for <i>obj</i>. The same number will * be returned on all calls to <code>id</code> for a given object, and @@ -293,7 +293,7 @@ mrb_obj_frozen(mrb_state *mrb, mrb_value self) /* 15.3.1.3.15 */ /* * call-seq: - * obj.hash -> fixnum + * obj.hash -> int * * Generates a <code>Integer</code> hash value for this object. This * function must have the property that <code>a.eql?(b)</code> implies @@ -423,8 +423,8 @@ mrb_f_raise(mrb_state *mrb, mrb_value self) mrb_value a[2], exc; mrb_int argc; - argc = mrb_get_args(mrb, "|oo", &a[0], &a[1]); + mrb->c->ci->mid = 0; switch (argc) { case 0: mrb_raise(mrb, E_RUNTIME_ERROR, ""); @@ -510,7 +510,7 @@ mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args) * # ... * end * def method_missing(methId) - * str = methId.id2name + * str = methId.to_s * romanToInt(str) * end * end @@ -527,6 +527,7 @@ mrb_obj_missing(mrb_state *mrb, mrb_value mod) const mrb_value *a; mrb_int alen; + mrb->c->ci->mid = 0; mrb_get_args(mrb, "n*!", &name, &a, &alen); mrb_method_missing(mrb, name, mod, mrb_ary_new_from_values(mrb, alen, a)); /* not reached */ @@ -584,6 +585,7 @@ mrb_obj_ceqq(mrb_state *mrb, mrb_value self) mrb_sym eqq = MRB_OPSYM(eqq); mrb_value ary; + mrb->c->ci->mid = 0; if (mrb_array_p(self)) { ary = self; } @@ -610,6 +612,17 @@ mrb_obj_ceqq(mrb_state *mrb, mrb_value self) return mrb_false_value(); } +static mrb_value +mrb_encoding(mrb_state *mrb, mrb_value self) +{ + mrb_get_args(mrb, ""); +#ifdef MRB_UTF8_STRING + return mrb_str_new_lit(mrb, "UTF-8"); +#else + return mrb_str_new_lit(mrb, "ASCII-8BIT"); +#endif +} + mrb_value mrb_obj_equal_m(mrb_state *mrb, mrb_value); void @@ -649,8 +662,8 @@ mrb_init_kernel(mrb_state *mrb) mrb_define_method(mrb, krn, "respond_to?", obj_respond_to, MRB_ARGS_ARG(1,1)); /* 15.3.1.3.43 */ mrb_define_method(mrb, krn, "to_s", mrb_any_to_s, MRB_ARGS_NONE()); /* 15.3.1.3.46 */ mrb_define_method(mrb, krn, "__case_eqq", mrb_obj_ceqq, MRB_ARGS_REQ(1)); /* internal */ - mrb_define_method(mrb, krn, "__to_int", mrb_to_int, MRB_ARGS_NONE()); /* internal */ - mrb_define_method(mrb, krn, "__to_str", mrb_to_str, MRB_ARGS_NONE()); /* internal */ + mrb_define_method(mrb, krn, "__to_int", mrb_to_integer, MRB_ARGS_NONE()); /* internal */ + mrb_define_method(mrb, krn, "__ENCODING__", mrb_encoding, MRB_ARGS_NONE()); mrb_include_module(mrb, mrb->object_class, mrb->kernel_module); } diff --git a/src/load.c b/src/load.c index f370dc67e..256dd58fd 100644 --- a/src/load.c +++ b/src/load.c @@ -4,10 +4,7 @@ ** See Copyright Notice in mruby.h */ -#include <limits.h> -#include <stdlib.h> -#include <string.h> -#include <math.h> +#include <mruby.h> #include <mruby/dump.h> #include <mruby/irep.h> #include <mruby/proc.h> @@ -16,6 +13,7 @@ #include <mruby/error.h> #include <mruby/data.h> #include <mruby/endian.h> +#include <string.h> #if SIZE_MAX < UINT32_MAX # error size_t must be at least 32 bits wide @@ -60,8 +58,6 @@ str_to_double(mrb_state *mrb, const char *p) } #endif -mrb_value mrb_str_len_to_inum(mrb_state *mrb, const char *str, size_t len, mrb_int base, int badcheck); - static mrb_bool read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags, mrb_irep **irepp) { @@ -146,7 +142,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag } break; case IREP_TT_INT64: -#ifdef MRB_64BIT +#ifdef MRB_INT64 { uint64_t i64 = bin_to_uint32(src); src += sizeof(uint32_t); @@ -158,7 +154,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag } break; #else - return FALSE; /* INT64 not supported on MRB_32BIT */ + return FALSE; #endif case IREP_TT_BIGINT: @@ -364,6 +360,12 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t * } } break; + case mrb_debug_line_packed_map: { + file->lines.packed_map = (uint8_t*)mrb_calloc(mrb, 1, (size_t)file->line_entry_count); + memcpy(file->lines.packed_map, bin, file->line_entry_count); + bin += file->line_entry_count; + } break; + default: return MRB_DUMP_GENERAL_FAILURE; } } @@ -604,11 +606,7 @@ read_irep(mrb_state *mrb, const uint8_t *bin, size_t bufsize, uint8_t flags) static struct RProc* mrb_proc_read_irep(mrb_state *mrb, const uint8_t *bin) { -#if defined(MRB_USE_LINK_TIME_RO_DATA_P) || defined(MRB_USE_CUSTOM_RO_DATA_P) uint8_t flags = mrb_ro_data_p((char*)bin) ? FLAG_SRC_STATIC : FLAG_SRC_MALLOC; -#else - uint8_t flags = FLAG_SRC_STATIC; -#endif return read_irep(mrb, bin, (size_t)-1, flags); } @@ -679,7 +677,7 @@ mrb_load_irep_buf(mrb_state *mrb, const void *buf, size_t bufsize) 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); + return mrb_top_run(mrb, proc, mrb_top_self(mrb), 0); } #ifndef MRB_NO_STDIO diff --git a/src/numeric.c b/src/numeric.c index fe1a18f04..fd9f5ce2c 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -4,36 +4,25 @@ ** See Copyright Notice in mruby.h */ -#ifndef MRB_NO_FLOAT -#include <float.h> -#include <math.h> -#endif -#include <limits.h> -#include <stdlib.h> -#include <string.h> - #include <mruby.h> #include <mruby/array.h> #include <mruby/numeric.h> #include <mruby/string.h> #include <mruby/class.h> #include <mruby/presym.h> +#include <string.h> #ifndef MRB_NO_FLOAT #ifdef MRB_USE_FLOAT32 #define trunc(f) truncf(f) -#define floor(f) floorf(f) -#define ceil(f) ceilf(f) #define fmod(x,y) fmodf(x,y) -#define FLO_TO_STR_PREC 8 #else -#define FLO_TO_STR_PREC 16 #endif #endif #ifndef MRB_NO_FLOAT MRB_API mrb_float -mrb_to_flo(mrb_state *mrb, mrb_value val) +mrb_as_float(mrb_state *mrb, mrb_value val) { switch (mrb_type(val)) { case MRB_TT_INTEGER: @@ -137,10 +126,6 @@ mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y) return 0; } -#ifndef MRB_NO_FLOAT -mrb_float mrb_div_flo(mrb_float x, mrb_float y); -#endif - /* 15.2.8.3.4 */ /* 15.2.9.3.4 */ /* @@ -164,7 +149,7 @@ int_div(mrb_state *mrb, mrb_value x) #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non integer division"); #else - return mrb_float_value(mrb, mrb_div_flo((mrb_float)a, mrb_to_flo(mrb, y))); + return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y))); #endif } @@ -191,7 +176,7 @@ int_idiv(mrb_state *mrb, mrb_value x) if (y == 0) { int_zerodiv(mrb); } - return mrb_fixnum_value(mrb_integer(x) / y); + return mrb_int_value(mrb, mrb_integer(x) / y); } static mrb_value @@ -218,8 +203,9 @@ coerce_step_counter(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "oo", &num, &step); #ifndef MRB_NO_FLOAT - if (mrb_float_p(self) || mrb_float_p(num) || mrb_float_p(step)) { - return mrb_Float(mrb, self); + mrb->c->ci->mid = 0; + if (mrb_float_p(num) || mrb_float_p(step)) { + return mrb_to_float(mrb, self); } #endif @@ -240,7 +226,7 @@ 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)); + mrb_float d = pow(mrb_as_float(mrb, x), mrb_as_float(mrb, y)); return mrb_float_value(mrb, d); } @@ -255,7 +241,7 @@ flo_idiv(mrb_state *mrb, mrb_value xv) } mrb_float -mrb_div_flo(mrb_float x, mrb_float y) +mrb_div_float(mrb_float x, mrb_float y) { if (y != 0.0) { return x / y; @@ -275,14 +261,39 @@ flo_div(mrb_state *mrb, mrb_value x) mrb_float a = mrb_float(x); if (mrb_float_p(y)) { - a = mrb_div_flo(a, mrb_float(y)); + a = mrb_div_float(a, mrb_float(y)); } else { - a = mrb_div_flo(a, mrb_to_flo(mrb, y)); + a = mrb_div_float(a, mrb_as_float(mrb, y)); } return mrb_float_value(mrb, a); } +/* the argument `fmt` is no longer used; you can pass `NULL` */ +mrb_value +mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt) +{ + char buf[25]; +#ifdef MRB_USE_FLOAT32 + const int prec = 7; +#else + const int prec = 15; +#endif + + mrb_format_float(mrb_float(flo), buf, sizeof(buf), 'g', prec, '\0'); + for (char *p = buf; *p; p++) { + if (*p == '.') goto exit; + if (*p == 'e') { + memmove(p+2, p, strlen(p)+1); + memcpy(p, ".0", 2); + goto exit; + } + } + strcat(buf, ".0"); + exit: + return mrb_str_new_cstr(mrb, buf); +} + /* 15.2.9.3.16(x) */ /* * call-seq: @@ -307,49 +318,14 @@ flo_to_s(mrb_state *mrb, mrb_value flt) if (isinf(f)) { str = f < 0 ? mrb_str_new_lit(mrb, "-Infinity") : mrb_str_new_lit(mrb, "Infinity"); - goto exit; } else if (isnan(f)) { str = mrb_str_new_lit(mrb, "NaN"); - goto exit; } else { - char fmt[] = "%." MRB_STRINGIZE(FLO_TO_STR_PREC) "g"; - mrb_int len; - char *begp, *p, *endp; - - str = mrb_float_to_str(mrb, flt, fmt); - - insert_dot_zero: - begp = RSTRING_PTR(str); - len = RSTRING_LEN(str); - for (p = begp, endp = p + len; p < endp; ++p) { - if (*p == '.') { - goto exit; - } - else if (*p == 'e') { - ptrdiff_t e_pos = p - begp; - mrb_str_cat(mrb, str, ".0", 2); - p = RSTRING_PTR(str) + e_pos; - memmove(p + 2, p, len - e_pos); - memcpy(p, ".0", 2); - goto exit; - } - } - - if (FLO_TO_STR_PREC + (begp[0] == '-') <= len) { - --fmt[sizeof(fmt) - 3]; /* %.16g(%.8g) -> %.15g(%.7g) */ - str = mrb_float_to_str(mrb, flt, fmt); - goto insert_dot_zero; - } - else { - mrb_str_cat(mrb, str, ".0", 2); - } - - goto exit; + str = mrb_float_to_str(mrb, flt, NULL); } - exit: RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); return str; } @@ -376,7 +352,7 @@ flo_add(mrb_state *mrb, mrb_value x) return mrb_funcall_id(mrb, y, MRB_OPSYM(add), 1, x); #endif default: - return mrb_float_value(mrb, a + mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, a + mrb_as_float(mrb, y)); } } @@ -404,7 +380,7 @@ flo_sub(mrb_state *mrb, mrb_value x) return mrb_funcall_id(mrb, x, MRB_OPSYM(minus), 0); #endif default: - return mrb_float_value(mrb, a - mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, a - mrb_as_float(mrb, y)); } } @@ -431,7 +407,7 @@ flo_mul(mrb_state *mrb, mrb_value x) return mrb_funcall_id(mrb, y, MRB_OPSYM(mul), 1, x); #endif default: - return mrb_float_value(mrb, a * mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, a * mrb_as_float(mrb, y)); } } @@ -490,7 +466,7 @@ flo_mod(mrb_state *mrb, mrb_value x) mrb_value y = mrb_get_arg1(mrb); mrb_float mod; - flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), 0, &mod); + flodivmod(mrb, mrb_float(x), mrb_as_float(mrb, y), 0, &mod); return mrb_float_value(mrb, mod); } #endif @@ -551,7 +527,7 @@ flo_eq(mrb_state *mrb, mrb_value x) return mrb_bool_value(mrb_float(x) == mrb_float(y)); #ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: - return mrb_bool_value(mrb_float(x) == mrb_to_flo(mrb, y)); + return mrb_bool_value(mrb_float(x) == mrb_as_float(mrb, y)); #endif #ifdef MRB_USE_COMPLEX case MRB_TT_COMPLEX: @@ -761,49 +737,127 @@ mrb_check_num_exact(mrb_state *mrb, mrb_float num) } } +static mrb_value +flo_ceil_floor(mrb_state *mrb, mrb_value num, double (*func)(double)) +{ + mrb_float f = mrb_float(num); + mrb_int ndigits = 0; +#ifdef MRB_USE_FLOAT32 + const int fprec = 7; +#else + const int fprec = 15; +#endif + + mrb_get_args(mrb, "|i", &ndigits); + if (f == 0.0) { + return ndigits > 0 ? mrb_float_value(mrb, f) : mrb_fixnum_value(0); + } + if (ndigits > 0) { + if (ndigits > fprec) return num; + mrb_float d = pow(10, ndigits); + f = func(f * d) / d; + return mrb_float_value(mrb, f); + } + if (ndigits < 0) { + mrb_float d = pow(10, -ndigits); + f = func(f / d) * d; + } + else { /* ndigits == 0 */ + f = func(f); + } + mrb_check_num_exact(mrb, f); + return mrb_int_value(mrb, (mrb_int)f); +} + /* 15.2.9.3.10 */ /* * call-seq: - * flt.floor -> integer + * float.floor([ndigits]) -> integer or float * - * Returns the largest integer less than or equal to <i>flt</i>. + * Returns the largest number less than or equal to +float+ with + * a precision of +ndigits+ decimal digits (default: 0). + * + * When the precision is negative, the returned value is an integer + * with at least <code>ndigits.abs</code> trailing zeros. + * + * Returns a floating point number when +ndigits+ is positive, + * otherwise returns an integer. * * 1.2.floor #=> 1 * 2.0.floor #=> 2 * (-1.2).floor #=> -2 * (-2.0).floor #=> -2 + * + * 1.234567.floor(2) #=> 1.23 + * 1.234567.floor(3) #=> 1.234 + * 1.234567.floor(4) #=> 1.2345 + * 1.234567.floor(5) #=> 1.23456 + * + * 34567.89.floor(-5) #=> 0 + * 34567.89.floor(-4) #=> 30000 + * 34567.89.floor(-3) #=> 34000 + * 34567.89.floor(-2) #=> 34500 + * 34567.89.floor(-1) #=> 34560 + * 34567.89.floor(0) #=> 34567 + * 34567.89.floor(1) #=> 34567.8 + * 34567.89.floor(2) #=> 34567.89 + * 34567.89.floor(3) #=> 34567.89 + * + * Note that the limited precision of floating point arithmetic + * might lead to surprising results: + * + * (0.3 / 0.1).floor #=> 2 (!) */ - static mrb_value 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, (mrb_int)f); + return flo_ceil_floor(mrb, num, floor); } /* 15.2.9.3.8 */ /* * call-seq: - * flt.ceil -> integer + * float.ceil([ndigits]) -> integer or float + * + * Returns the smallest number greater than or equal to +float+ with + * a precision of +ndigits+ decimal digits (default: 0). + * + * When the precision is negative, the returned value is an integer + * with at least <code>ndigits.abs</code> trailing zeros. * - * Returns the smallest <code>Integer</code> greater than or equal to - * <i>flt</i>. + * Returns a floating point number when +ndigits+ is positive, + * otherwise returns an integer. * * 1.2.ceil #=> 2 * 2.0.ceil #=> 2 * (-1.2).ceil #=> -1 * (-2.0).ceil #=> -2 + * + * 1.234567.ceil(2) #=> 1.24 + * 1.234567.ceil(3) #=> 1.235 + * 1.234567.ceil(4) #=> 1.2346 + * 1.234567.ceil(5) #=> 1.23457 + * + * 34567.89.ceil(-5) #=> 100000 + * 34567.89.ceil(-4) #=> 40000 + * 34567.89.ceil(-3) #=> 35000 + * 34567.89.ceil(-2) #=> 34600 + * 34567.89.ceil(-1) #=> 34570 + * 34567.89.ceil(0) #=> 34568 + * 34567.89.ceil(1) #=> 34567.9 + * 34567.89.ceil(2) #=> 34567.89 + * 34567.89.ceil(3) #=> 34567.89 + * + * Note that the limited precision of floating point arithmetic + * might lead to surprising results: + * + * (2.1 / 0.7).ceil #=> 4 (!) */ static mrb_value 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, (mrb_int)f); + return flo_ceil_floor(mrb, num, ceil); } /* 15.2.9.3.12 */ @@ -853,6 +907,7 @@ flo_round(mrb_state *mrb, mrb_value num) mrb_check_num_exact(mrb, number); f = 1.0; + if (ndigits < -DBL_DIG-2) return mrb_fixnum_value(0); i = ndigits >= 0 ? ndigits : -ndigits; if (ndigits > DBL_DIG+2) return num; while (--i >= 0) @@ -891,6 +946,18 @@ flo_round(mrb_state *mrb, mrb_value num) } /* 15.2.9.3.14 */ +static mrb_value +flo_to_i(mrb_state *mrb, mrb_value num) +{ + mrb_float f = mrb_float(num); + + if (f > 0.0) f = floor(f); + if (f < 0.0) f = ceil(f); + + mrb_check_num_exact(mrb, f); + return mrb_int_value(mrb, (mrb_int)f); +} + /* 15.2.9.3.15 */ /* * call-seq: @@ -903,13 +970,8 @@ flo_round(mrb_state *mrb, mrb_value num) static mrb_value flo_truncate(mrb_state *mrb, mrb_value num) { - mrb_float f = mrb_float(num); - - if (f > 0.0) f = floor(f); - if (f < 0.0) f = ceil(f); - - mrb_check_num_exact(mrb, f); - return mrb_int_value(mrb, (mrb_int)f); + if (signbit(mrb_float(num))) return flo_ceil(mrb, num); + return flo_floor(mrb, num); } static mrb_value @@ -917,6 +979,15 @@ flo_nan_p(mrb_state *mrb, mrb_value num) { return mrb_bool_value(isnan(mrb_float(num))); } + +static mrb_value +flo_abs(mrb_state *mrb, mrb_value num) +{ + mrb_float f = mrb_float(num); + + if (signbit(f)) return mrb_float_value(mrb, -f); + return num; +} #endif /* @@ -967,7 +1038,7 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y) #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non integer multiplication"); #else - return mrb_float_value(mrb, (mrb_float)a * mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, (mrb_float)a * mrb_as_float(mrb, y)); #endif } } @@ -980,7 +1051,7 @@ mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) } #ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { - return mrb_float_value(mrb, mrb_float(x) * mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, mrb_float(x) * mrb_as_float(mrb, y)); } #endif #if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) @@ -999,7 +1070,7 @@ mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) /* 15.2.8.3.3 */ /* * call-seq: - * fix * numeric -> numeric_result + * int * numeric -> numeric_result * * Performs multiplication: the class of the resulting object depends on * the class of <code>numeric</code> and on the magnitude of the @@ -1015,7 +1086,7 @@ int_mul(mrb_state *mrb, mrb_value x) } static void -fixdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp) +intdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp) { if (y == 0) { int_zerodiv(mrb); @@ -1039,10 +1110,9 @@ fixdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp) /* 15.2.8.3.5 */ /* * call-seq: - * fix % other -> real - * fix.modulo(other) -> real + * int % other -> real * - * Returns <code>fix</code> modulo <code>other</code>. + * Returns <code>int</code> modulo <code>other</code>. * See <code>numeric.divmod</code> for more information. */ @@ -1053,27 +1123,29 @@ int_mod(mrb_state *mrb, mrb_value x) mrb_int a, b; a = mrb_integer(x); - if (mrb_integer_p(y) && a != MRB_INT_MIN && (b=mrb_integer(y)) != MRB_INT_MIN) { - mrb_int mod; - - fixdivmod(mrb, a, b, NULL, &mod); - return mrb_fixnum_value(mod); + if (mrb_integer_p(y)) { + b = mrb_integer(y); + if (b == 0) int_zerodiv(mrb); + if (a == MRB_INT_MIN && b == -1) return mrb_fixnum_value(0); + mrb_int mod = a % b; + if ((a < 0) != (b < 0) && mod != 0) { + mod += b; + } + return mrb_int_value(mrb, mod); } #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non integer modulo"); #else - else { - mrb_float mod; + mrb_float mod; - flodivmod(mrb, (mrb_float)a, mrb_to_flo(mrb, y), NULL, &mod); - return mrb_float_value(mrb, mod); - } + flodivmod(mrb, (mrb_float)a, mrb_as_float(mrb, y), NULL, &mod); + return mrb_float_value(mrb, mod); #endif } /* * call-seq: - * fix.divmod(numeric) -> array + * int.divmod(numeric) -> array * * See <code>Numeric#divmod</code>. */ @@ -1085,7 +1157,7 @@ int_divmod(mrb_state *mrb, mrb_value x) if (mrb_integer_p(y)) { mrb_int div, mod; - fixdivmod(mrb, mrb_integer(x), mrb_integer(y), &div, &mod); + intdivmod(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_NO_FLOAT @@ -1095,7 +1167,7 @@ int_divmod(mrb_state *mrb, mrb_value x) mrb_float div, mod; mrb_value a, b; - flodivmod(mrb, (mrb_float)mrb_integer(x), mrb_to_flo(mrb, y), &div, &mod); + flodivmod(mrb, (mrb_float)mrb_integer(x), mrb_as_float(mrb, y), &div, &mod); a = mrb_int_value(mrb, (mrb_int)div); b = mrb_float_value(mrb, mod); return mrb_assoc_new(mrb, a, b); @@ -1111,7 +1183,7 @@ flo_divmod(mrb_state *mrb, mrb_value x) mrb_float div, mod; mrb_value a, b; - flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), &div, &mod); + flodivmod(mrb, mrb_float(x), mrb_as_float(mrb, y), &div, &mod); if (!FIXABLE_FLOAT(div)) a = mrb_float_value(mrb, div); else @@ -1124,9 +1196,9 @@ flo_divmod(mrb_state *mrb, mrb_value x) /* 15.2.8.3.7 */ /* * call-seq: - * fix == other -> true or false + * int == other -> true or false * - * Return <code>true</code> if <code>fix</code> equals <code>other</code> + * Return <code>true</code> if <code>int</code> equals <code>other</code> * numerically. * * 1 == 2 #=> false @@ -1161,7 +1233,7 @@ int_equal(mrb_state *mrb, mrb_value x) /* 15.2.8.3.8 */ /* * call-seq: - * ~fix -> integer + * ~int -> integer * * One's complement: returns a number where each bit is flipped. * ex.0---00001 (1)-> 1---11110 (-2) @@ -1194,7 +1266,7 @@ static mrb_value flo_xor(mrb_state *mrb, mrb_value x); /* 15.2.8.3.9 */ /* * call-seq: - * fix & integer -> integer_result + * int & integer -> integer_result * * Bitwise AND. */ @@ -1210,7 +1282,7 @@ int_and(mrb_state *mrb, mrb_value x) /* 15.2.8.3.10 */ /* * call-seq: - * fix | integer -> integer_result + * int | integer -> integer_result * * Bitwise OR. */ @@ -1226,7 +1298,7 @@ int_or(mrb_state *mrb, mrb_value x) /* 15.2.8.3.11 */ /* * call-seq: - * fix ^ integer -> integer_result + * int ^ integer -> integer_result * * Bitwise EXCLUSIVE OR. */ @@ -1241,45 +1313,48 @@ int_xor(mrb_state *mrb, mrb_value x) #define NUMERIC_SHIFT_WIDTH_MAX (MRB_INT_BIT-1) -static mrb_value -lshift(mrb_state *mrb, mrb_int val, mrb_int width) +mrb_bool +mrb_num_shift(mrb_state *mrb, mrb_int val, mrb_int width, mrb_int *num) { - mrb_assert(width >= 0); - if (val > 0) { + if (width < 0) { /* rshift */ + if (width == MRB_INT_MIN || -width >= NUMERIC_SHIFT_WIDTH_MAX) { + if (val < 0) { + *num = -1; + } + else { + *num = 0; + } + } + else { + *num = val >> -width; + } + } + else if (val > 0) { if ((width > NUMERIC_SHIFT_WIDTH_MAX) || (val > (MRB_INT_MAX >> width))) { - int_overflow(mrb, "bit shift"); + return FALSE; } - return mrb_int_value(mrb, val << width); + *num = val << width; } else { if ((width > NUMERIC_SHIFT_WIDTH_MAX) || - (val <= (MRB_INT_MIN >> width))) { - int_overflow(mrb, "bit shift"); + (val < (MRB_INT_MIN >> width))) { + return FALSE; } - return mrb_int_value(mrb, (val * ((mrb_int)1 << width))); + if (width == NUMERIC_SHIFT_WIDTH_MAX) + *num = MRB_INT_MIN; + else + *num = val * ((mrb_int)1 << width); } -} - -static mrb_value -rshift(mrb_state *mrb, mrb_int val, mrb_int width) -{ - mrb_assert(width >= 0); - if (width >= NUMERIC_SHIFT_WIDTH_MAX) { - if (val < 0) { - return mrb_fixnum_value(-1); - } - return mrb_fixnum_value(0); - } - return mrb_int_value(mrb, val >> width); + return TRUE; } /* 15.2.8.3.12 */ /* * call-seq: - * fix << count -> integer or float + * int << count -> integer or float * - * Shifts _fix_ left _count_ positions (right if _count_ is negative). + * Shifts _int_ left _count_ positions (right if _count_ is negative). */ static mrb_value @@ -1293,19 +1368,18 @@ int_lshift(mrb_state *mrb, mrb_value x) } val = mrb_integer(x); if (val == 0) return x; - if (width < 0) { - if (width == MRB_INT_MIN) return rshift(mrb, val, MRB_INT_BIT); - return rshift(mrb, val, -width); + if (!mrb_num_shift(mrb, val, width, &val)) { + int_overflow(mrb, "bit shift"); } - return lshift(mrb, val, width); + return mrb_int_value(mrb, val); } /* 15.2.8.3.13 */ /* * call-seq: - * fix >> count -> integer or float + * int >> count -> integer or float * - * Shifts _fix_ right _count_ positions (left if _count_ is negative). + * Shifts _int_ right _count_ positions (left if _count_ is negative). */ static mrb_value @@ -1319,19 +1393,19 @@ int_rshift(mrb_state *mrb, mrb_value x) } val = mrb_integer(x); if (val == 0) return x; - if (width < 0) { - if (width == MRB_INT_MIN) int_overflow(mrb, "bit shift"); - return lshift(mrb, val, -width); + if (width == MRB_INT_MIN) int_overflow(mrb, "bit shift"); + if (!mrb_num_shift(mrb, val, -width, &val)) { + int_overflow(mrb, "bit shift"); } - return rshift(mrb, val, width); + return mrb_int_value(mrb, val); } /* 15.2.8.3.23 */ /* * call-seq: - * fix.to_f -> float + * int.to_f -> float * - * Converts <i>fix</i> to a <code>Float</code>. + * Converts <i>int</i> to a <code>Float</code>. * */ @@ -1357,13 +1431,12 @@ int_to_f(mrb_state *mrb, mrb_value num) */ /* ------------------------------------------------------------------------*/ MRB_API mrb_value -mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x) +mrb_float_to_integer(mrb_state *mrb, mrb_value x) { mrb_int z = 0; if (!mrb_float_p(x)) { mrb_raise(mrb, E_TYPE_ERROR, "non float value"); - z = 0; /* not reached. just suppress warnings. */ } else { mrb_float d = mrb_float(x); @@ -1406,7 +1479,7 @@ int_plus(mrb_state *mrb, mrb_value x, mrb_value y) #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non integer addition"); #else - return mrb_float_value(mrb, (mrb_float)a + mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, (mrb_float)a + mrb_as_float(mrb, y)); #endif } } @@ -1419,7 +1492,7 @@ mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) } #ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { - return mrb_float_value(mrb, mrb_float(x) + mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, mrb_float(x) + mrb_as_float(mrb, y)); } #endif #if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) @@ -1438,7 +1511,7 @@ mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) /* 15.2.8.3.1 */ /* * call-seq: - * fix + numeric -> numeric_result + * int + numeric -> numeric_result * * Performs addition: the class of the resulting object depends on * the class of <code>numeric</code> and on the magnitude of the @@ -1478,7 +1551,7 @@ int_minus(mrb_state *mrb, mrb_value x, mrb_value y) #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non integer subtraction"); #else - return mrb_float_value(mrb, (mrb_float)a - mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, (mrb_float)a - mrb_as_float(mrb, y)); #endif } } @@ -1491,7 +1564,7 @@ mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) } #ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { - return mrb_float_value(mrb, mrb_float(x) - mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, mrb_float(x) - mrb_as_float(mrb, y)); } #endif #if defined(MRB_USE_RATIONAL) || defined(MRB_USE_COMPLEX) @@ -1511,7 +1584,7 @@ mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) /* 15.2.8.3.16 */ /* * call-seq: - * fix - numeric -> numeric_result + * int - numeric -> numeric_result * * Performs subtraction: the class of the resulting object depends on * the class of <code>numeric</code> and on the magnitude of the @@ -1525,35 +1598,51 @@ int_sub(mrb_state *mrb, mrb_value self) return int_minus(mrb, self, other); } - -MRB_API mrb_value -mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base) +MRB_API char* +mrb_int_to_cstr(char *buf, size_t len, mrb_int n, mrb_int base) { - char buf[MRB_INT_BIT+1]; - char *b = buf + sizeof buf; - mrb_int val = mrb_integer(x); - mrb_value str; + char *bufend = buf + len; + char *b = bufend-1; - if (base < 2 || 36 < base) { - mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %i", base); - } + if (base < 2 || 36 < base) return NULL; + if (len < 2) return NULL; - if (val == 0) { - *--b = '0'; + if (n == 0) { + buf[0] = '0'; + buf[1] = '\0'; + return buf; } - else if (val < 0) { + + *b = '\0'; + if (n < 0) { do { - *--b = mrb_digitmap[-(val % base)]; - } while (val /= base); - *--b = '-'; + if (b-- == buf) return NULL; + *b = mrb_digitmap[-(n % base)]; + } while (n /= base); + if (b-- == buf) return NULL; + *b = '-'; } else { do { - *--b = mrb_digitmap[(int)(val % base)]; - } while (val /= base); + if (b-- == buf) return NULL; + *b = mrb_digitmap[(int)(n % base)]; + } while (n /= base); } + return b; +} - str = mrb_str_new(mrb, b, buf + sizeof(buf) - b); +MRB_API mrb_value +mrb_integer_to_str(mrb_state *mrb, mrb_value x, mrb_int base) +{ + char buf[MRB_INT_BIT+1]; + mrb_int val = mrb_integer(x); + + if (base < 2 || 36 < base) { + mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %i", base); + } + const char *p = mrb_int_to_cstr(buf, sizeof(buf), val, base); + mrb_assert(p != NULL); + mrb_value str = mrb_str_new_cstr(mrb, p); RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); return str; } @@ -1561,9 +1650,9 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base) /* 15.2.8.3.25 */ /* * call-seq: - * fix.to_s(base=10) -> string + * int.to_s(base=10) -> string * - * Returns a string containing the representation of <i>fix</i> radix + * Returns a string containing the representation of <i>int</i> radix * <i>base</i> (between 2 and 36). * * 12345.to_s #=> "12345" @@ -1580,7 +1669,7 @@ int_to_s(mrb_state *mrb, mrb_value self) mrb_int base = 10; mrb_get_args(mrb, "|i", &base); - return mrb_fixnum_to_str(mrb, self, base); + return mrb_integer_to_str(mrb, self, base); } /* compare two numbers: (1:0:-1; -2 for error) */ @@ -1596,7 +1685,7 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) #ifdef MRB_NO_FLOAT x = mrb_integer(v1); #else - x = mrb_to_flo(mrb, v1); + x = mrb_as_float(mrb, v1); #endif switch (mrb_type(v2)) { case MRB_TT_INTEGER: @@ -1612,7 +1701,7 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) break; #ifdef MRB_USE_RATIONAL case MRB_TT_RATIONAL: - y = mrb_to_flo(mrb, v2); + y = mrb_as_float(mrb, v2); break; #endif #endif @@ -1635,7 +1724,7 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) * < => -1 * = => 0 * > => +1 - * Comparison---Returns -1, 0, or +1 depending on whether <i>fix</i> is + * Comparison---Returns -1, 0, or +1 depending on whether <i>int</i> is * less than, equal to, or greater than <i>numeric</i>. This is the * basis for the tests in <code>Comparable</code>. When the operands are * not comparable, it returns nil instead of raising an exception. @@ -1817,21 +1906,21 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, fl, "^", flo_xor, MRB_ARGS_REQ(1)); mrb_define_method(mrb, fl, ">>", flo_rshift, MRB_ARGS_REQ(1)); mrb_define_method(mrb, fl, "<<", flo_lshift, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, fl, "ceil", flo_ceil, MRB_ARGS_NONE()); /* 15.2.9.3.8 */ + mrb_define_method(mrb, fl, "ceil", flo_ceil, MRB_ARGS_OPT(1)); /* 15.2.9.3.8 */ mrb_define_method(mrb, fl, "finite?", flo_finite_p, MRB_ARGS_NONE()); /* 15.2.9.3.9 */ - mrb_define_method(mrb, fl, "floor", flo_floor, MRB_ARGS_NONE()); /* 15.2.9.3.10 */ + mrb_define_method(mrb, fl, "floor", flo_floor, MRB_ARGS_OPT(1)); /* 15.2.9.3.10 */ mrb_define_method(mrb, fl, "infinite?", flo_infinite_p, MRB_ARGS_NONE()); /* 15.2.9.3.11 */ mrb_define_method(mrb, fl, "round", flo_round, MRB_ARGS_OPT(1)); /* 15.2.9.3.12 */ mrb_define_method(mrb, fl, "to_f", flo_to_f, MRB_ARGS_NONE()); /* 15.2.9.3.13 */ - mrb_define_method(mrb, fl, "to_i", flo_truncate, MRB_ARGS_NONE()); /* 15.2.9.3.14 */ - mrb_define_method(mrb, fl, "to_int", flo_truncate, MRB_ARGS_NONE()); - mrb_define_method(mrb, fl, "truncate", flo_truncate, MRB_ARGS_NONE()); /* 15.2.9.3.15 */ + mrb_define_method(mrb, fl, "to_i", flo_to_i, MRB_ARGS_NONE()); /* 15.2.9.3.14 */ + mrb_define_method(mrb, fl, "truncate", flo_truncate, MRB_ARGS_OPT(1)); /* 15.2.9.3.15 */ mrb_define_method(mrb, fl, "divmod", flo_divmod, MRB_ARGS_REQ(1)); 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, "nan?", flo_nan_p, MRB_ARGS_NONE()); + mrb_define_method(mrb, fl, "abs", flo_abs, MRB_ARGS_NONE()); /* 15.2.7.4.3 */ #ifdef INFINITY mrb_define_const_id(mrb, fl, MRB_SYM(INFINITY), mrb_float_value(mrb, INFINITY)); diff --git a/src/object.c b/src/object.c index a44eab4bb..b3c9973bf 100644 --- a/src/object.c +++ b/src/object.c @@ -316,44 +316,15 @@ mrb_init_object(mrb_state *mrb) mrb_define_method(mrb, f, "inspect", false_to_s, MRB_ARGS_NONE()); } -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) { - const struct types *type = builtin_types; - - while (type->type < MRB_TT_MAXDEFINE) { - if (type->type == t) return type->name; - type++; + switch (t) { +#define MRB_VTYPE_NAME(tt, type, name) case tt: return name; + MRB_VTYPE_FOREACH(MRB_VTYPE_NAME) +#undef MRB_VTYPE_NAME + default: return NULL; } - return NULL; } static mrb_value @@ -409,7 +380,7 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t) ename = "nil"; } else if (mrb_integer_p(x)) { - ename = "Fixnum"; + ename = "Integer"; } else if (mrb_symbol_p(x)) { ename = "Symbol"; @@ -507,13 +478,13 @@ mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c) } MRB_API mrb_value -mrb_to_int(mrb_state *mrb, mrb_value val) +mrb_to_integer(mrb_state *mrb, mrb_value val) { if (!mrb_integer_p(val)) { #ifndef MRB_NO_FLOAT if (mrb_float_p(val)) { - return mrb_flo_to_fixnum(mrb, val); + return mrb_float_to_integer(mrb, val); } #endif if (mrb_string_p(val)) { @@ -524,55 +495,9 @@ mrb_to_int(mrb_state *mrb, mrb_value val) return val; } -MRB_API mrb_value -mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base) -{ - mrb_value tmp; - - if (mrb_nil_p(val)) { - if (base != 0) goto arg_error; - mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Integer"); - } - switch (mrb_type(val)) { -#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_INTEGER: - if (base != 0) goto arg_error; - return val; - - case MRB_TT_STRING: - string_conv: - return mrb_str_to_inum(mrb, val, base, TRUE); - - default: - break; - } - if (base != 0) { - tmp = mrb_check_string_type(mrb, val); - if (!mrb_nil_p(tmp)) { - val = tmp; - goto string_conv; - } -arg_error: - mrb_raise(mrb, E_ARGUMENT_ERROR, "base specified for non string value"); - } - /* to raise TypeError */ - return mrb_to_int(mrb, val); -} - -MRB_API mrb_value -mrb_Integer(mrb_state *mrb, mrb_value val) -{ - return mrb_convert_to_integer(mrb, val, 0); -} - #ifndef MRB_NO_FLOAT MRB_API mrb_value -mrb_Float(mrb_state *mrb, mrb_value val) +mrb_to_float(mrb_state *mrb, mrb_value val) { if (mrb_nil_p(val)) { mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Float"); @@ -594,19 +519,6 @@ mrb_Float(mrb_state *mrb, mrb_value val) #endif MRB_API mrb_value -mrb_to_str(mrb_state *mrb, mrb_value val) -{ - return mrb_ensure_string_type(mrb, val); -} - -/* obsolete: use mrb_ensure_string_type() instead */ -MRB_API mrb_value -mrb_string_type(mrb_state *mrb, mrb_value str) -{ - return mrb_ensure_string_type(mrb, str); -} - -MRB_API mrb_value mrb_ensure_string_type(mrb_state *mrb, mrb_value str) { if (!mrb_string_p(str)) { diff --git a/src/proc.c b/src/proc.c index 78ce0e791..d48145f13 100644 --- a/src/proc.c +++ b/src/proc.c @@ -46,7 +46,7 @@ mrb_proc_new(mrb_state *mrb, const mrb_irep *irep) struct RProc *p; mrb_callinfo *ci = mrb->c->ci; - p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class); + p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class); if (ci) { struct RClass *tc = NULL; @@ -81,7 +81,8 @@ mrb_env_new(mrb_state *mrb, struct mrb_context *c, mrb_callinfo *ci, int nstacks struct REnv *e; mrb_int bidx; - e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, tc); + e = MRB_OBJ_ALLOC(mrb, MRB_TT_ENV, NULL); + e->c = tc; MRB_ENV_SET_LEN(e, nstacks); bidx = ci->argc; if (bidx < 0) bidx = 2; @@ -105,7 +106,7 @@ closure_setup(mrb_state *mrb, struct RProc *p) /* do nothing, because e is assigned already */ } else if (up) { - struct RClass *tc = MRB_PROC_TARGET_CLASS(p); + struct RClass *tc = ci->u.target_class; e = mrb_env_new(mrb, mrb->c, ci, up->body.irep->nlocals, ci->stack, tc); ci->u.env = e; @@ -134,7 +135,7 @@ mrb_proc_new_cfunc(mrb_state *mrb, mrb_func_t func) { struct RProc *p; - p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class); + p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class); p->body.func = func; p->flags |= MRB_PROC_CFUNC_FL; p->upper = 0; @@ -224,7 +225,7 @@ mrb_proc_s_new(mrb_state *mrb, mrb_value proc_class) /* Calling Proc.new without a block is not implemented yet */ mrb_get_args(mrb, "&!", &blk); - p = (struct RProc *)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb_class_ptr(proc_class)); + p = 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_SYM(initialize), 0, NULL, proc); @@ -278,7 +279,7 @@ proc_lambda(mrb_state *mrb, mrb_value self) } p = mrb_proc_ptr(blk); if (!MRB_PROC_STRICT_P(p)) { - struct RProc *p2 = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, p->c); + struct RProc *p2 = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, p->c); mrb_proc_copy(p2, p); p2->flags |= MRB_PROC_STRICT; return mrb_obj_value(p2); @@ -417,7 +418,19 @@ mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, c mrb_sym *destlv = (mrb_sym*)irep->lv + irep->nlocals - 1 /* self */; mrb_value *destst = env->stack + irep->nlocals; memmove(destlv, lv, sizeof(mrb_sym) * num); - memmove(destst, stack, sizeof(mrb_value) * num); + if (stack) { + memmove(destst, stack, sizeof(mrb_value) * num); + for (int i = 0; i < num; i++) { + if (!mrb_immediate_p(stack[i])) { + mrb_field_write_barrier(mrb, (struct RBasic*)env, (struct RBasic*)mrb_obj_ptr(stack[i])); + } + } + } + else { + for (int i = num; i > 0; i--, destst++) { + *destst = mrb_nil_value(); + } + } irep->nlocals += num; irep->nregs = irep->nlocals; MRB_ENV_SET_LEN(env, irep->nlocals); diff --git a/src/range.c b/src/range.c index cb60bb63c..7507173b6 100644 --- a/src/range.c +++ b/src/range.c @@ -9,11 +9,12 @@ #include <mruby/range.h> #include <mruby/string.h> #include <mruby/array.h> +#include <mruby/numeric.h> #include <mruby/presym.h> -#define RANGE_INITIALIZED_MASK 1 -#define RANGE_INITIALIZED(p) ((p)->flags |= RANGE_INITIALIZED_MASK) -#define RANGE_INITIALIZED_P(p) ((p)->flags & RANGE_INITIALIZED_MASK) +#define RANGE_INITIALIZED_FLAG 1 +#define RANGE_INITIALIZED(p) ((p)->flags |= RANGE_INITIALIZED_FLAG) +#define RANGE_INITIALIZED_P(p) ((p)->flags & RANGE_INITIALIZED_FLAG) static void r_check(mrb_state *mrb, mrb_value a, mrb_value b) @@ -25,13 +26,13 @@ r_check(mrb_state *mrb, mrb_value a, mrb_value b) ta = mrb_type(a); tb = mrb_type(b); #ifdef MRB_NO_FLOAT - if (ta == MRB_TT_INTEGER && tb == MRB_TT_INTEGER ) { + if (ta == MRB_TT_INTEGER && tb == MRB_TT_INTEGER ) return; #else if ((ta == MRB_TT_INTEGER || ta == MRB_TT_FLOAT) && (tb == MRB_TT_INTEGER || tb == MRB_TT_FLOAT)) { -#endif return; } +#endif if (mrb_nil_p(a) || mrb_nil_p(b)) return; @@ -88,7 +89,7 @@ range_ptr_init(mrb_state *mrb, struct RRange *r, mrb_value beg, mrb_value end, m } } else { - r = (struct RRange*)mrb_obj_alloc(mrb, MRB_TT_RANGE, mrb->range_class); + r = MRB_OBJ_ALLOC(mrb, MRB_TT_RANGE, mrb->range_class); range_ptr_alloc_edges(mrb, r); } @@ -342,6 +343,59 @@ range_initialize_copy(mrb_state *mrb, mrb_value copy) return copy; } +static mrb_value +range_num_to_a(mrb_state *mrb, mrb_value range) +{ + struct RRange *r = mrb_range_ptr(mrb, range); + mrb_value beg = RANGE_BEG(r); + mrb_value end = RANGE_END(r); + mrb_value ary; + + mrb->c->ci->mid = 0; + if (mrb_nil_p(end)) { + mrb_raise(mrb, E_RANGE_ERROR, "cannot convert endless range to an array"); + } + if (mrb_integer_p(beg)) { + if (mrb_integer_p(end)) { + mrb_int a = mrb_integer(beg); + mrb_int b = mrb_integer(end); + mrb_int len; + + if (mrb_int_sub_overflow(b, a, &len)) { + mrb_raise(mrb, E_RANGE_ERROR, "integer range too long"); + } + if (!RANGE_EXCL(r)) len++; + ary = mrb_ary_new_capa(mrb, len); + for (mrb_int i=0; i<len; i++) { + mrb_ary_push(mrb, ary, mrb_int_value(mrb, a+i)); + } + return ary; + } +#ifndef MRB_NO_FLOAT + if (mrb_float_p(end)) { + mrb_float a = (mrb_float)mrb_integer(beg); + mrb_float b = mrb_float(end); + + ary = mrb_ary_new_capa(mrb, (mrb_int)(b - a) + 1); + if (RANGE_EXCL(r)) { + while (a < b) { + mrb_ary_push(mrb, ary, mrb_int_value(mrb, (mrb_int)a)); + a += 1.0; + } + } + else { + while (a <= b) { + mrb_ary_push(mrb, ary, mrb_int_value(mrb, (mrb_int)a)); + a += 1.0; + } + } + return ary; + } +#endif + } + return mrb_nil_value(); +} + mrb_value mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, const mrb_value *argv, mrb_value (*func)(mrb_state*, mrb_value, mrb_int)) { @@ -409,8 +463,8 @@ mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, if (!mrb_range_p(range)) return MRB_RANGE_TYPE_MISMATCH; r = mrb_range_ptr(mrb, range); - beg = mrb_nil_p(RANGE_BEG(r)) ? 0 : mrb_int(mrb, RANGE_BEG(r)); - end = mrb_nil_p(RANGE_END(r)) ? -1 : mrb_int(mrb, RANGE_END(r)); + beg = mrb_nil_p(RANGE_BEG(r)) ? 0 : mrb_as_int(mrb, RANGE_BEG(r)); + end = mrb_nil_p(RANGE_END(r)) ? -1 : mrb_as_int(mrb, RANGE_END(r)); excl = mrb_nil_p(RANGE_END(r)) ? 0 : RANGE_EXCL(r); if (beg < 0) { @@ -456,4 +510,5 @@ mrb_init_range(mrb_state *mrb) mrb_define_method(mrb, r, "inspect", range_inspect, MRB_ARGS_NONE()); /* 15.2.14.4.13(x) */ mrb_define_method(mrb, r, "eql?", range_eql, MRB_ARGS_REQ(1)); /* 15.2.14.4.14(x) */ mrb_define_method(mrb, r, "initialize_copy", range_initialize_copy, MRB_ARGS_REQ(1)); /* 15.2.14.4.15(x) */ + mrb_define_method(mrb, r, "__num_to_a", range_num_to_a, MRB_ARGS_NONE()); } diff --git a/src/readflt.c b/src/readflt.c new file mode 100644 index 000000000..b320a43c1 --- /dev/null +++ b/src/readflt.c @@ -0,0 +1,119 @@ +#include <mruby.h> + +#ifndef MRB_NO_FLOAT +/* + * strtod implementation. + * author: Yasuhiro Matsumoto (@mattn) + * license: public domain + */ + +/* +The original code can be found in https://github.com/mattn/strtod + +I modified the routine for mruby: + + * renamed the function `vim_strtod` -> `mrb_float_read` + * simplified the code + +My modifications in this file are also placed in the public domain. + +Matz (Yukihiro Matsumoto) +*/ + +#include <string.h> +#include <math.h> +#include <errno.h> + +MRB_API double +mrb_float_read(const char *str, char **end) +{ + double d = 0.0; + int sign; + int n = 0; + const char *p, *a; + + a = p = str; + while (ISSPACE(*p)) + ++p; + + /* decimal part */ + sign = 1; + if (*p == '-') { + sign = -1; + ++p; + } else if (*p == '+') + ++p; + if (ISDIGIT(*p)) { + d = (double)(*p++ - '0'); + while (*p && ISDIGIT(*p)) { + d = d * 10.0 + (double)(*p - '0'); + ++p; + ++n; + } + a = p; + } else if (*p != '.') + goto done; + d *= sign; + + /* fraction part */ + if (*p == '.') { + double f = 0.0; + double base = 0.1; + ++p; + + if (ISDIGIT(*p)) + { + while (*p && ISDIGIT(*p)) { + f += base * (*p - '0') ; + base /= 10.0; + ++p; + ++n; + } + } + d += f * sign; + a = p; + } + + /* exponential part */ + if ((*p == 'E') || (*p == 'e')) { + int e = 0; + ++p; + + sign = 1; + if (*p == '-') { + sign = -1; + ++p; + } else if (*p == '+') + ++p; + + if (ISDIGIT(*p)) { + while (*p == '0') + ++p; + if (*p == '\0') --p; + e = (int)(*p++ - '0'); + for (; *p && ISDIGIT(*p); p++) { + if (e < 10000) + e = e * 10 + (*p - '0'); + } + e *= sign; + } + else if (!ISDIGIT(*(a-1))) { + a = str; + goto done; + } + else if (*p == 0) + goto done; + d *= pow(10.0, (double) e); + a = p; + } + else if (p > str && !ISDIGIT(*(p-1))) { + a = str; + goto done; + } + +done: + if (end) + *end = (char*)a; + return d; +} +#endif diff --git a/src/readint.c b/src/readint.c new file mode 100644 index 000000000..5fae222c2 --- /dev/null +++ b/src/readint.c @@ -0,0 +1,30 @@ +#include <mruby.h> +#include <mruby/numeric.h> +#include <errno.h> + +/* mrb_int_read(): read mrb_int from a string (base 10 only) */ +/* const char *p - string to read */ +/* const char *e - end of string */ +/* char **endp - end of parsed integer */ + +/* if integer overflows, errno will be set to ERANGE */ +/* also endp will be set to NULL on overflow */ +MRB_API mrb_int +mrb_int_read(const char *p, const char *e, char **endp) +{ + mrb_int n = 0; + int ch; + + while ((e == NULL || p < e) && ISDIGIT(*p)) { + ch = *p - '0'; + if (mrb_int_mul_overflow(n, 10, &n) || + mrb_int_add_overflow(n, ch, &n)) { + if (endp) *endp = NULL; + errno = ERANGE; + return MRB_INT_MAX; + } + p++; + } + if (endp) *endp = (char*)p; + return n; +} diff --git a/src/string.c b/src/string.c index e440bff8c..ac0f4a920 100644 --- a/src/string.c +++ b/src/string.c @@ -8,14 +8,6 @@ # define _CRT_NONSTDC_NO_DEPRECATE #endif -#ifndef MRB_NO_FLOAT -#include <float.h> -#include <math.h> -#endif -#include <limits.h> -#include <stddef.h> -#include <stdlib.h> -#include <string.h> #include <mruby.h> #include <mruby/array.h> #include <mruby/class.h> @@ -23,6 +15,7 @@ #include <mruby/string.h> #include <mruby/numeric.h> #include <mruby/presym.h> +#include <string.h> typedef struct mrb_shared_string { int refcnt; @@ -32,7 +25,7 @@ typedef struct mrb_shared_string { const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz"; -#define mrb_obj_alloc_string(mrb) ((struct RString*)mrb_obj_alloc((mrb), MRB_TT_STRING, (mrb)->string_class)) +#define mrb_obj_alloc_string(mrb) MRB_OBJ_ALLOC((mrb), MRB_TT_STRING, (mrb)->string_class) static struct RString* str_init_normal_capa(mrb_state *mrb, struct RString *s, @@ -244,7 +237,7 @@ str_modify_keep_ascii(mrb_state *mrb, struct RString *s) static void check_null_byte(mrb_state *mrb, mrb_value str) { - mrb_to_str(mrb, str); + mrb_ensure_string_type(mrb, str); if (memchr(RSTRING_PTR(str), '\0', RSTRING_LEN(str))) { mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte"); } @@ -839,8 +832,15 @@ mrb_str_to_cstr(mrb_state *mrb, mrb_value str0) { struct RString *s; + const char *p = RSTRING_PTR(str0); + size_t len = RSTRING_LEN(str0); check_null_byte(mrb, str0); - s = str_new(mrb, RSTRING_PTR(str0), RSTRING_LEN(str0)); + if (RSTR_EMBEDDABLE_P(len)) { + s = str_init_embed(mrb_obj_alloc_string(mrb), p, len); + } + else { + s = str_init_normal(mrb, mrb_obj_alloc_string(mrb), p, len); + } return RSTR_PTR(s); } @@ -897,14 +897,14 @@ static mrb_value mrb_str_size(mrb_state *mrb, mrb_value self) { mrb_int len = RSTRING_CHAR_LEN(self); - return mrb_fixnum_value(len); + return mrb_int_value(mrb, len); } static mrb_value mrb_str_bytesize(mrb_state *mrb, mrb_value self) { mrb_int len = RSTRING_LEN(self); - return mrb_fixnum_value(len); + return mrb_int_value(mrb, len); } /* 15.2.10.5.1 */ @@ -1018,7 +1018,7 @@ mrb_str_cmp_m(mrb_state *mrb, mrb_value str1) else { result = mrb_str_cmp(mrb, str1, str2); } - return mrb_fixnum_value(result); + return mrb_int_value(mrb, result); } static mrb_bool @@ -1071,7 +1071,7 @@ mrb_string_value_ptr(mrb_state *mrb, mrb_value str) MRB_API mrb_int mrb_string_value_len(mrb_state *mrb, mrb_value ptr) { - mrb_to_str(mrb, ptr); + mrb_ensure_string_type(mrb, ptr); return RSTRING_LEN(ptr); } @@ -1102,8 +1102,8 @@ static enum str_convert_range str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen, mrb_int *beg, mrb_int *len) { if (!mrb_undef_p(alen)) { - *beg = mrb_int(mrb, indx); - *len = mrb_int(mrb, alen); + *beg = mrb_as_int(mrb, indx); + *len = mrb_as_int(mrb, alen); return STR_CHAR_RANGE; } else { @@ -1123,7 +1123,7 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen, goto range_arg; default: - indx = mrb_to_int(mrb, indx); + indx = mrb_to_integer(mrb, indx); if (mrb_integer_p(indx)) { *beg = mrb_integer(indx); *len = 1; @@ -1175,14 +1175,14 @@ mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen) /* 15.2.10.5.34 */ /* * call-seq: - * str[fixnum] => fixnum or nil - * str[fixnum, fixnum] => new_str or nil - * str[range] => new_str or nil - * str[other_str] => new_str or nil - * str.slice(fixnum) => fixnum or nil - * str.slice(fixnum, fixnum) => new_str or nil - * str.slice(range) => new_str or nil - * str.slice(other_str) => new_str or nil + * str[int] => int or nil + * str[int, int] => new_str or nil + * str[range] => new_str or nil + * str[other_str] => new_str or nil + * str.slice(int) => int or nil + * str.slice(int, int) => new_str or nil + * str.slice(range) => new_str or nil + * str.slice(other_str) => new_str or nil * * Element Reference---If passed a single <code>Integer</code>, returns the code * of the character at that position. If passed two <code>Integer</code> @@ -1239,13 +1239,11 @@ str_replace_partial(mrb_state *mrb, mrb_value src, mrb_int pos, mrb_int end, mrb if (end > len) { end = len; } if (pos < 0 || pos > len) { - str_out_of_index(mrb, mrb_fixnum_value(pos)); + str_out_of_index(mrb, mrb_int_value(mrb, pos)); } replen = (mrb_nil_p(rep) ? 0 : RSTRING_LEN(rep)); - newlen = replen + (len - (end - pos)); - - if (newlen >= MRB_SSIZE_MAX || newlen < replen /* overflowed */) { + if (mrb_int_add_overflow(replen, len - (end - pos), &newlen) || newlen >= MRB_SSIZE_MAX) { mrb_raise(mrb, E_RUNTIME_ERROR, "string size too big"); } @@ -1358,8 +1356,7 @@ mrb_str_aset(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen, mrb_ { mrb_int beg, len, charlen; - mrb_to_str(mrb, replace); - + mrb_ensure_string_type(mrb, replace); switch (str_convert_range(mrb, str, indx, alen, &beg, &len)) { case STR_OUT_OF_RANGE: default: @@ -1376,14 +1373,17 @@ mrb_str_aset(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen, mrb_ str_range_to_bytes(str, &beg, &len); /* fall through */ case STR_BYTE_RANGE_CORRECTED: - str_replace_partial(mrb, str, beg, beg + len, replace); + if (mrb_int_add_overflow(beg, len, &len)) { + mrb_raise(mrb, E_RUNTIME_ERROR, "string index too big"); + } + str_replace_partial(mrb, str, beg, len, replace); } } /* * call-seq: - * str[fixnum] = replace - * str[fixnum, fixnum] = replace + * str[int] = replace + * str[int, int] = replace * str[range] = replace * str[other_str] = replace * @@ -1754,7 +1754,7 @@ mrb_str_hash(mrb_state *mrb, mrb_value str) /* 15.2.10.5.20 */ /* * call-seq: - * str.hash => fixnum + * str.hash => int * * Return a hash based on the string's length and content. */ @@ -1762,14 +1762,14 @@ static mrb_value mrb_str_hash_m(mrb_state *mrb, mrb_value self) { mrb_int key = mrb_str_hash(mrb, self); - return mrb_fixnum_value(key); + return mrb_int_value(mrb, key); } /* 15.2.10.5.21 */ /* * call-seq: * str.include? other_str => true or false - * str.include? fixnum => true or false + * str.include? int => true or false * * Returns <code>true</code> if <i>str</i> contains the given string or * character. @@ -1792,7 +1792,7 @@ mrb_str_include(mrb_state *mrb, mrb_value self) /* 15.2.10.5.22 */ /* * call-seq: - * str.index(substring [, offset]) => fixnum or nil + * str.index(substring [, offset]) => int or nil * * Returns the index of the first occurrence of the given * <i>substring</i>. Returns <code>nil</code> if not found. @@ -1824,7 +1824,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) if (pos == -1) return mrb_nil_value(); BYTES_ALIGN_CHECK(pos); - return mrb_fixnum_value(pos); + return mrb_int_value(mrb, pos); } /* 15.2.10.5.24 */ @@ -1873,7 +1873,7 @@ mrb_str_init(mrb_state *mrb, mrb_value self) * str.to_sym => symbol * * Returns the <code>Symbol</code> corresponding to <i>str</i>, creating the - * symbol if it did not previously exist. See <code>Symbol#id2name</code>. + * symbol if it did not previously exist. * * "Koala".intern #=> :Koala * s = 'cat'.to_sym #=> :cat @@ -1901,7 +1901,7 @@ mrb_obj_as_string(mrb_state *mrb, mrb_value 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); + return mrb_integer_to_str(mrb, obj, 10); case MRB_TT_SCLASS: case MRB_TT_CLASS: case MRB_TT_MODULE: @@ -2018,7 +2018,7 @@ mrb_str_reverse(mrb_state *mrb, mrb_value str) /* 15.2.10.5.31 */ /* * call-seq: - * str.rindex(substring [, offset]) => fixnum or nil + * str.rindex(substring [, offset]) => int or nil * * Returns the index of the last occurrence of the given <i>substring</i>. * Returns <code>nil</code> if not found. If the second parameter is @@ -2053,7 +2053,7 @@ mrb_str_rindex(mrb_state *mrb, mrb_value str) if (pos >= 0) { pos = bytes2chars(RSTRING_PTR(str), RSTRING_LEN(str), pos); BYTES_ALIGN_CHECK(pos); - return mrb_fixnum_value(pos); + return mrb_int_value(mrb, pos); } return mrb_nil_value(); } @@ -2199,8 +2199,8 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) return result; } -mrb_value -mrb_str_len_to_inum(mrb_state *mrb, const char *str, size_t len, mrb_int base, int badcheck) +static mrb_value +mrb_str_len_to_integer(mrb_state *mrb, const char *str, size_t len, mrb_int base, int badcheck) { const char *p = str; const char *pend = str + len; @@ -2363,12 +2363,6 @@ mrb_str_len_to_inum(mrb_state *mrb, const char *str, size_t len, mrb_int base, i return mrb_fixnum_value(0); } -MRB_API mrb_value -mrb_cstr_to_inum(mrb_state *mrb, const char *str, mrb_int base, mrb_bool badcheck) -{ - return mrb_str_len_to_inum(mrb, str, strlen(str), base, badcheck); -} - /* obslete: use RSTRING_CSTR() or mrb_string_cstr() */ MRB_API const char* mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr) @@ -2401,15 +2395,15 @@ mrb_string_cstr(mrb_state *mrb, mrb_value str) } MRB_API mrb_value -mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck) +mrb_str_to_integer(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck) { const char *s; mrb_int len; - mrb_to_str(mrb, str); + mrb_ensure_string_type(mrb, str); s = RSTRING_PTR(str); len = RSTRING_LEN(str); - return mrb_str_len_to_inum(mrb, s, len, base, badcheck); + return mrb_str_len_to_integer(mrb, s, len, base, badcheck); } /* 15.2.10.5.38 */ @@ -2439,14 +2433,14 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self) mrb_int base = 10; mrb_get_args(mrb, "|i", &base); - if (base < 0) { + if (base < 0 || 36 < base) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %i", base); } - return mrb_str_to_inum(mrb, self, base, FALSE); + return mrb_str_to_integer(mrb, self, base, FALSE); } #ifndef MRB_NO_FLOAT -double +static double mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck) { char buf[DBL_DIG * 4 + 20]; @@ -2466,7 +2460,7 @@ mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck) mrb_value x; if (!badcheck) return 0.0; - x = mrb_str_len_to_inum(mrb, p, pend-p, 0, badcheck); + x = mrb_str_len_to_integer(mrb, p, pend-p, 0, badcheck); if (mrb_integer_p(x)) d = (double)mrb_integer(x); else /* if (mrb_float_p(x)) */ @@ -2536,12 +2530,6 @@ bad: } MRB_API double -mrb_cstr_to_dbl(mrb_state *mrb, const char *s, mrb_bool badcheck) -{ - return mrb_str_len_to_dbl(mrb, s, strlen(s), badcheck); -} - -MRB_API double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck) { return mrb_str_len_to_dbl(mrb, RSTRING_PTR(str), RSTRING_LEN(str), badcheck); @@ -2711,7 +2699,7 @@ mrb_str_cat_str(mrb_state *mrb, mrb_value str, mrb_value str2) MRB_API mrb_value mrb_str_append(mrb_state *mrb, mrb_value str1, mrb_value str2) { - mrb_to_str(mrb, str2); + mrb_ensure_string_type(mrb, str2); return mrb_str_cat_str(mrb, str1, str2); } @@ -2734,7 +2722,7 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) /* * call-seq: - * str.bytes -> array of fixnums + * str.bytes -> array of int * * Returns an array of bytes in _str_. * @@ -2843,7 +2831,7 @@ mrb_str_byteslice(mrb_state *mrb, mrb_value str) } } else { - beg = mrb_integer(mrb_to_int(mrb, a1)); + beg = mrb_integer(mrb_to_integer(mrb, a1)); len = 1; empty = FALSE; } @@ -2860,6 +2848,51 @@ mrb_str_byteslice(mrb_state *mrb, mrb_value str) } } +static mrb_value +sub_replace(mrb_state *mrb, mrb_value self) +{ + char *p, *match; + mrb_int plen, mlen; + mrb_int found, offset; + mrb_value result; + + mrb_get_args(mrb, "ssi", &p, &plen, &match, &mlen, &found); + result = mrb_str_new(mrb, 0, 0); + for (mrb_int i=0; i<plen; i++) { + if (p[i] != '\\' || i+1==plen) { + mrb_str_cat(mrb, result, p+i, 1); + continue; + } + i++; + switch (p[i]) { + case '\\': + mrb_str_cat(mrb, result, "\\", 1); + break; + case '`': + mrb_str_cat(mrb, result, RSTRING_PTR(self), chars2bytes(self, 0, found)); + break; + case '&': case '0': + mrb_str_cat(mrb, result, match, mlen); + break; + case '\'': + offset = chars2bytes(self, 0, found) + mlen; + if (RSTRING_LEN(self) > offset) { + mrb_str_cat(mrb, result, RSTRING_PTR(self)+offset, RSTRING_LEN(self)-offset); + } + break; + case '1': case '2': case '3': + case '4': case '5': case '6': + case '7': case '8': case '9': + /* ignore sub-group match (no Regexp supported) */ + break; + default: + mrb_str_cat(mrb, result, &p[i-1], 2); + break; + } + } + return result; +} + /* ---------------------------*/ void mrb_init_string(mrb_state *mrb) @@ -2921,251 +2954,6 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "getbyte", mrb_str_getbyte, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "setbyte", mrb_str_setbyte, MRB_ARGS_REQ(2)); mrb_define_method(mrb, s, "byteslice", mrb_str_byteslice, MRB_ARGS_ARG(1,1)); -} - -#ifndef MRB_NO_FLOAT -/* - * Source code for the "strtod" library procedure. - * - * Copyright (c) 1988-1993 The Regents of the University of California. - * Copyright (c) 1994 Sun Microsystems, Inc. - * - * Permission to use, copy, modify, and distribute this - * software and its documentation for any purpose and without - * fee is hereby granted, provided that the above copyright - * notice appear in all copies. The University of California - * makes no representations about the suitability of this - * software for any purpose. It is provided "as is" without - * express or implied warranty. - * - * RCS: @(#) $Id: strtod.c 11708 2007-02-12 23:01:19Z shyouhei $ - */ - -#include <ctype.h> -#include <errno.h> - -static const int maxExponent = 511; /* Largest possible base 10 exponent. Any - * exponent larger than this will already - * produce underflow or overflow, so there's - * no need to worry about additional digits. - */ -static const double powersOf10[] = {/* Table giving binary powers of 10. Entry */ - 10., /* is 10^2^i. Used to convert decimal */ - 100., /* exponents into floating-point numbers. */ - 1.0e4, - 1.0e8, - 1.0e16, - 1.0e32, - 1.0e64, - 1.0e128, - 1.0e256 -}; - -MRB_API double -mrb_float_read(const char *string, char **endPtr) -/* const char *string; A decimal ASCII floating-point number, - * optionally preceded by white space. - * Must have form "-I.FE-X", where I is the - * integer part of the mantissa, F is the - * fractional part of the mantissa, and X - * is the exponent. Either of the signs - * may be "+", "-", or omitted. Either I - * or F may be omitted, or both. The decimal - * point isn't necessary unless F is present. - * The "E" may actually be an "e". E and X - * may both be omitted (but not just one). - */ -/* char **endPtr; If non-NULL, store terminating character's - * address here. */ -{ - int sign, expSign = FALSE; - double fraction, dblExp; - const double *d; - const char *p; - int c; - int exp = 0; /* Exponent read from "EX" field. */ - int fracExp = 0; /* Exponent that derives from the fractional - * part. Under normal circumstances, it is - * the negative of the number of digits in F. - * However, if I is very long, the last digits - * of I get dropped (otherwise a long I with a - * large negative exponent could cause an - * unnecessary overflow on I alone). In this - * case, fracExp is incremented one for each - * dropped digit. */ - int mantSize; /* Number of digits in mantissa. */ - int decPt; /* Number of mantissa digits BEFORE decimal - * point. */ - const char *pExp; /* Temporarily holds location of exponent - * in string. */ - - /* - * Strip off leading blanks and check for a sign. - */ - - p = string; - while (ISSPACE(*p)) { - p += 1; - } - if (*p == '-') { - sign = TRUE; - p += 1; - } - else { - if (*p == '+') { - p += 1; - } - sign = FALSE; - } - - /* - * Count the number of digits in the mantissa (including the decimal - * point), and also locate the decimal point. - */ - - decPt = -1; - for (mantSize = 0; ; mantSize += 1) - { - c = *p; - if (!ISDIGIT(c)) { - if ((c != '.') || (decPt >= 0)) { - break; - } - decPt = mantSize; - } - p += 1; - } - - /* - * Now suck up the digits in the mantissa. Use two integers to - * collect 9 digits each (this is faster than using floating-point). - * If the mantissa has more than 18 digits, ignore the extras, since - * they can't affect the value anyway. - */ - - pExp = p; - p -= mantSize; - if (decPt < 0) { - decPt = mantSize; - } - else { - mantSize -= 1; /* One of the digits was the point. */ - } - if (mantSize > 18) { - if (decPt - 18 > 29999) { - fracExp = 29999; - } - else { - fracExp = decPt - 18; - } - mantSize = 18; - } - else { - fracExp = decPt - mantSize; - } - if (mantSize == 0) { - fraction = 0.0; - p = string; - goto done; - } - else { - int frac1, frac2; - frac1 = 0; - for ( ; mantSize > 9; mantSize -= 1) - { - c = *p; - p += 1; - if (c == '.') { - c = *p; - p += 1; - } - frac1 = 10*frac1 + (c - '0'); - } - frac2 = 0; - for (; mantSize > 0; mantSize -= 1) - { - c = *p; - p += 1; - if (c == '.') { - c = *p; - p += 1; - } - frac2 = 10*frac2 + (c - '0'); - } - fraction = (1.0e9 * frac1) + frac2; - } - - /* - * Skim off the exponent. - */ - p = pExp; - if ((*p == 'E') || (*p == 'e')) { - p += 1; - if (*p == '-') { - expSign = TRUE; - p += 1; - } - else { - if (*p == '+') { - p += 1; - } - expSign = FALSE; - } - while (ISDIGIT(*p)) { - exp = exp * 10 + (*p - '0'); - if (exp > 19999) { - exp = 19999; - } - p += 1; - } - } - if (expSign) { - exp = fracExp - exp; - } - else { - exp = fracExp + exp; - } - - /* - * Generate a floating-point number that represents the exponent. - * Do this by processing the exponent one bit at a time to combine - * many powers of 2 of 10. Then combine the exponent with the - * fraction. - */ - - if (exp < 0) { - expSign = TRUE; - exp = -exp; - } - else { - expSign = FALSE; - } - if (exp > maxExponent) { - exp = maxExponent; - errno = ERANGE; - } - dblExp = 1.0; - for (d = powersOf10; exp != 0; exp >>= 1, d += 1) { - if (exp & 01) { - dblExp *= *d; - } - } - if (expSign) { - fraction /= dblExp; - } - else { - fraction *= dblExp; - } - -done: - if (endPtr != NULL) { - *endPtr = (char *) p; - } - - if (sign) { - return -fraction; - } - return fraction; + mrb_define_method(mrb, s, "__sub_replace", sub_replace, MRB_ARGS_REQ(3)); /* internal */ } -#endif diff --git a/src/symbol.c b/src/symbol.c index 3cd925d99..cc8986eaa 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -4,7 +4,6 @@ ** See Copyright Notice in mruby.h */ -#include <limits.h> #include <string.h> #include <mruby.h> #include <mruby/khash.h> @@ -54,13 +53,6 @@ presym_sym2name(mrb_sym sym, mrb_int *lenp) #endif /* MRB_NO_PRESYM */ /* ------------------------------------------------------ */ -typedef struct symbol_name { - mrb_bool lit : 1; - uint8_t prev; - uint16_t len; - const char *name; -} symbol_name; - static void sym_validate_len(mrb_state *mrb, size_t len) { @@ -81,7 +73,11 @@ static const char pack_table[] = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRS static mrb_sym sym_inline_pack(const char *name, size_t len) { +#if defined(MRB_WORD_BOXING) && defined(MRB_32BIT) && !defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE) + const size_t pack_length_max = 4; +#else const size_t pack_length_max = 5; +#endif char c; const char *p; @@ -138,11 +134,38 @@ symhash(const char *key, size_t len) return hash & 0xff; } +size_t mrb_packed_int_len(uint32_t num); +size_t mrb_packed_int_encode(uint32_t num, uint8_t *p, uint8_t *pend); +uint32_t mrb_packed_int_decode(uint8_t *p, uint8_t **newpos); + +#define sym_lit_p(mrb, i) (mrb->symflags[i>>3]&(1<<(i&7))) +#define sym_lit_set(mrb, i) mrb->symflags[i>>3]|=(1<<(i&7)) +#define sym_flags_clear(mrb, i) mrb->symflags[i>>3]&=~(1<<(i&7)) +#define sym_len(mrb, i) (size_t)(sym_lit_p(mrb, i)?strlen(mrb->symtbl[i]):mrb_packed_int_decode(mrb->symtbl[i],NULL)) + +static mrb_bool +sym_check(mrb_state *mrb, const char *name, size_t len, mrb_sym i) +{ + const char *symname = mrb->symtbl[i]; + size_t symlen; + + if (sym_lit_p(mrb, i)) { + symlen = strlen(symname); + } + else { + /* length in BER */ + symlen = mrb_packed_int_decode((uint8_t*)symname, (uint8_t**)&symname); + } + if (len == symlen && memcmp(symname, name, len) == 0) { + return TRUE; + } + return FALSE; +} + static mrb_sym find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp) { mrb_sym i; - symbol_name *sname; uint8_t hash; #ifndef MRB_NO_PRESYM @@ -160,24 +183,24 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp) i = mrb->symhash[hash]; if (i == 0) return 0; - do { - sname = &mrb->symtbl[i]; - if (sname->len == len && memcmp(sname->name, name, len) == 0) { + for (;;) { + if (sym_check(mrb, name, len, i)) { return (i+MRB_PRESYM_MAX); } - if (sname->prev == 0xff) { + uint8_t diff = mrb->symlink[i]; + if (diff == 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)+MRB_PRESYM_MAX); + while (i > 0) { + if (sym_check(mrb, name, len, i)) { + return (i+MRB_PRESYM_MAX); } - sname--; + i--; } return 0; } - i -= sname->prev; - } while (sname->prev > 0); + if (diff == 0) return 0; + i -= diff; + } return 0; } @@ -185,7 +208,6 @@ static mrb_sym sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit) { mrb_sym sym; - symbol_name *sname; uint8_t hash; sym_validate_len(mrb, len); @@ -194,35 +216,38 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit) /* registering a new symbol */ sym = mrb->symidx + 1; - if (mrb->symcapa < sym) { + if (mrb->symcapa <= sym) { size_t symcapa = mrb->symcapa; if (symcapa == 0) symcapa = 100; else symcapa = (size_t)(symcapa * 6 / 5); - mrb->symtbl = (symbol_name*)mrb_realloc(mrb, mrb->symtbl, sizeof(symbol_name)*(symcapa+1)); + mrb->symtbl = (const char**)mrb_realloc(mrb, mrb->symtbl, sizeof(char*)*symcapa); + mrb->symflags = (uint8_t*)mrb_realloc(mrb, mrb->symflags, symcapa/8+1); + memset(mrb->symflags+mrb->symcapa/8+1, 0, (symcapa-mrb->symcapa)/8); + mrb->symlink = (uint8_t*)mrb_realloc(mrb, mrb->symlink, symcapa); mrb->symcapa = symcapa; } - sname = &mrb->symtbl[sym]; - sname->len = (uint16_t)len; - if (lit || mrb_ro_data_p(name)) { - sname->name = name; - sname->lit = TRUE; + sym_flags_clear(mrb, sym); + if ((lit || mrb_ro_data_p(name)) && strlen(name) == len) { + sym_lit_set(mrb, sym); + mrb->symtbl[sym] = name; } else { - char *p = (char *)mrb_malloc(mrb, len+1); - memcpy(p, name, len); - p[len] = 0; - sname->name = (const char*)p; - sname->lit = FALSE; + int ilen = mrb_packed_int_len(len); + char *p = (char *)mrb_malloc(mrb, len+ilen+1); + mrb_packed_int_encode(len, (uint8_t*)p, (uint8_t*)p+ilen); + memcpy(p+ilen, name, len); + p[ilen+len] = 0; + mrb->symtbl[sym] = p; } if (mrb->symhash[hash]) { mrb_sym i = sym - mrb->symhash[hash]; if (i > 0xff) - sname->prev = 0xff; + mrb->symlink[sym] = 0xff; else - sname->prev = i; + mrb->symlink[sym] = i; } else { - sname->prev = 0; + mrb->symlink[sym] = 0; } mrb->symhash[hash] = mrb->symidx = sym; @@ -320,8 +345,15 @@ sym2name_len(mrb_state *mrb, mrb_sym sym, char *buf, mrb_int *lenp) return NULL; } - if (lenp) *lenp = mrb->symtbl[sym].len; - return mrb->symtbl[sym].name; + const char *symname = mrb->symtbl[sym]; + if (!sym_lit_p(mrb, sym)) { + size_t len = mrb_packed_int_decode((uint8_t*)symname, (uint8_t**)&symname); + if (lenp) *lenp = (mrb_int)len; + } + else if (lenp) { + *lenp = (mrb_int)strlen(symname); + } + return symname; } MRB_API const char* @@ -334,25 +366,19 @@ mrb_sym_name_len(mrb_state *mrb, mrb_sym sym, mrb_int *lenp) #endif } -mrb_bool -mrb_sym_static_p(mrb_state *mrb, mrb_sym sym) -{ - if (SYMBOL_INLINE_P(sym)) return TRUE; - if (sym > MRB_PRESYM_MAX) return FALSE; - return TRUE; -} - void mrb_free_symtbl(mrb_state *mrb) { mrb_sym i, lim; for (i=1, lim=mrb->symidx+1; i<lim; i++) { - if (!mrb->symtbl[i].lit) { - mrb_free(mrb, (char*)mrb->symtbl[i].name); + if (!sym_lit_p(mrb, i)) { + mrb_free(mrb, (char*)mrb->symtbl[i]); } } mrb_free(mrb, mrb->symtbl); + mrb_free(mrb, mrb->symlink); + mrb_free(mrb, mrb->symflags); } void @@ -397,12 +423,11 @@ mrb_init_symtbl(mrb_state *mrb) /* 15.2.11.3.3 */ /* * call-seq: - * sym.id2name -> string * sym.to_s -> string * * Returns the name or string corresponding to <i>sym</i>. * - * :fred.id2name #=> "fred" + * :fred.to_s #=> "fred" */ static mrb_value sym_to_s(mrb_state *mrb, mrb_value sym) @@ -410,6 +435,30 @@ sym_to_s(mrb_state *mrb, mrb_value sym) return mrb_sym_str(mrb, mrb_symbol(sym)); } +/* + * call-seq: + * sym.name -> string + * + * Returns the name or string corresponding to <i>sym</i>. Unlike #to_s, the + * returned string is frozen. + * + * :fred.name #=> "fred" + * :fred.name.frozen? #=> true + */ +static mrb_value +sym_name(mrb_state *mrb, mrb_value vsym) +{ + mrb_sym sym = mrb_symbol(vsym); + mrb_int len; + const char *name = mrb_sym_name_len(mrb, sym, &len); + + mrb_assert(name != NULL); + if (SYMBOL_INLINE_P(sym)) { + return mrb_str_new_frozen(mrb, name, len); + } + return mrb_str_new_static_frozen(mrb, name, len); +} + /* 15.2.11.3.4 */ /* * call-seq: @@ -596,7 +645,7 @@ mrb_sym_str(mrb_state *mrb, mrb_sym sym) } static const char* -sym_name(mrb_state *mrb, mrb_sym sym, mrb_bool dump) +sym_cstr(mrb_state *mrb, mrb_sym sym, mrb_bool dump) { mrb_int len; const char *name = mrb_sym_name_len(mrb, sym, &len); @@ -615,13 +664,13 @@ sym_name(mrb_state *mrb, mrb_sym sym, mrb_bool dump) MRB_API const char* mrb_sym_name(mrb_state *mrb, mrb_sym sym) { - return sym_name(mrb, sym, FALSE); + return sym_cstr(mrb, sym, FALSE); } MRB_API const char* mrb_sym_dump(mrb_state *mrb, mrb_sym sym) { - return sym_name(mrb, sym, TRUE); + return sym_cstr(mrb, sym, TRUE); } #define lesser(a,b) (((a)>(b))?(b):(a)) @@ -665,8 +714,8 @@ mrb_init_symbol(mrb_state *mrb) MRB_SET_INSTANCE_TT(sym, MRB_TT_SYMBOL); mrb_undef_class_method(mrb, sym, "new"); - mrb_define_method(mrb, sym, "id2name", sym_to_s, MRB_ARGS_NONE()); /* 15.2.11.3.2 */ mrb_define_method(mrb, sym, "to_s", sym_to_s, MRB_ARGS_NONE()); /* 15.2.11.3.3 */ + mrb_define_method(mrb, sym, "name", sym_name, MRB_ARGS_NONE()); mrb_define_method(mrb, sym, "to_sym", sym_to_sym, MRB_ARGS_NONE()); /* 15.2.11.3.4 */ mrb_define_method(mrb, sym, "inspect", sym_inspect, MRB_ARGS_NONE()); /* 15.2.11.3.5(x) */ mrb_define_method(mrb, sym, "<=>", sym_cmp, MRB_ARGS_REQ(1)); diff --git a/src/variable.c b/src/variable.c index 646353bfd..d89295229 100644 --- a/src/variable.c +++ b/src/variable.c @@ -766,16 +766,17 @@ mod_const_check(mrb_state *mrb, mrb_value mod) } static mrb_value -const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym) +const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym, mrb_bool skip) { struct RClass *c = base; mrb_value v; mrb_bool retry = FALSE; mrb_value name; + if (skip) c = c->super; L_RETRY: while (c) { - if (c->iv) { + if (!MRB_FLAG_TEST(c, MRB_FL_CLASS_IS_PREPENDED) && c->iv) { if (iv_get(mrb, c->iv, sym, &v)) return v; } @@ -794,7 +795,7 @@ MRB_API mrb_value mrb_const_get(mrb_state *mrb, mrb_value mod, mrb_sym sym) { mod_const_check(mrb, mod); - return const_get(mrb, mrb_class_ptr(mod), sym); + return const_get(mrb, mrb_class_ptr(mod), sym, FALSE); } mrb_value @@ -803,9 +804,9 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) struct RClass *c; struct RClass *c2; mrb_value v; - const struct RProc *proc; + const struct RProc *proc = mrb->c->ci->proc; - c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc); + c = MRB_PROC_TARGET_CLASS(proc); if (!c) c = mrb->object_class; if (iv_get(mrb, c->iv, sym, &v)) { return v; @@ -821,8 +822,7 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) c2 = mrb_class_ptr(klass); } if (c2 && (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE)) c = c2; - mrb_assert(!MRB_PROC_CFUNC_P(mrb->c->ci->proc)); - proc = mrb->c->ci->proc; + proc = proc->upper; while (proc) { c2 = MRB_PROC_TARGET_CLASS(proc); if (c2 && iv_get(mrb, c2->iv, sym, &v)) { @@ -830,7 +830,7 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym) } proc = proc->upper; } - return const_get(mrb, c, sym); + return const_get(mrb, c, sym, TRUE); } MRB_API void @@ -4,11 +4,6 @@ ** See Copyright Notice in mruby.h */ -#include <stddef.h> -#include <stdarg.h> -#ifndef MRB_NO_FLOAT -#include <math.h> -#endif #include <mruby.h> #include <mruby/array.h> #include <mruby/class.h> @@ -91,14 +86,10 @@ void mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value static inline void stack_clear(mrb_value *from, size_t count) { -#ifdef MRB_NAN_BOXING while (count-- > 0) { SET_NIL_VALUE(*from); from++; } -#else - memset(from, 0, sizeof(mrb_value)*count); -#endif } static inline void @@ -245,12 +236,13 @@ top_proc(mrb_state *mrb, const struct RProc *proc) return proc; } -#define CI_ACC_SKIP -1 -#define CI_ACC_DIRECT -2 -#define CI_ACC_RESUMED -3 +#define CINFO_NONE 0 +#define CINFO_SKIP 1 +#define CINFO_DIRECT 2 +#define CINFO_RESUMED 3 static inline mrb_callinfo* -cipush(mrb_state *mrb, mrb_int push_stacks, mrb_int acc, +cipush(mrb_state *mrb, mrb_int push_stacks, uint8_t cci, struct RClass *target_class, const struct RProc *proc, mrb_sym mid, mrb_int argc) { struct mrb_context *c = mrb->c; @@ -268,7 +260,7 @@ cipush(mrb_state *mrb, mrb_int push_stacks, mrb_int acc, mrb_vm_ci_proc_set(ci, proc); ci->stack = ci[-1].stack + push_stacks; ci->argc = (int16_t)argc; - ci->acc = (int16_t)acc; + ci->cci = cci; ci->u.target_class = target_class; return ci; @@ -314,7 +306,7 @@ mrb_protect_error(mrb_state *mrb, mrb_protect_error_func *body, void *userdata, mrb_value result = mrb_nil_value(); int ai = mrb_gc_arena_save(mrb); const struct mrb_context *c = mrb->c; - int ci_index = c->ci - c->cibase; + ptrdiff_t ci_index = c->ci - c->cibase; if (error) { *error = FALSE; } @@ -335,9 +327,9 @@ mrb_protect_error(mrb_state *mrb, mrb_protect_error_func *body, void *userdata, } else { // It was probably switched by mrb_fiber_resume(). - // Simply destroy all successive CI_ACC_DIRECTs once the fiber has been switched. + // Simply destroy all successive CINFO_DIRECTs once the fiber has been switched. c = mrb->c; - while (c->ci > c->cibase && c->ci->acc == CI_ACC_DIRECT) { + while (c->ci > c->cibase && c->ci->cci == CINFO_DIRECT) { cipop(mrb); } } @@ -506,12 +498,12 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc mrb->c->ci->stack[argc+1] = blk; if (MRB_METHOD_CFUNC_P(m)) { - ci->acc = CI_ACC_DIRECT; + ci->cci = CINFO_DIRECT; val = MRB_METHOD_CFUNC(m)(mrb, self); cipop(mrb); } else { - ci->acc = CI_ACC_SKIP; + ci->cci = CINFO_SKIP; val = mrb_run(mrb, MRB_METHOD_PROC(m), self); } } @@ -526,68 +518,8 @@ mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, cons return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value()); } -#define DECOMPOSE32(n) (((n) >> 24) & 0xff), (((n) >> 16) & 0xff), (((n) >> 8) & 0xff), (((n) >> 0) & 0xff) -#define CATCH_HANDLER_MAKE_BYTECODE(t, b, e, j) t, DECOMPOSE32(b), DECOMPOSE32(e), DECOMPOSE32(j) -#define CATCH_HANDLER_NUM_TO_BYTE(n) ((n) * sizeof(struct mrb_irep_catch_handler)) - -static void -exec_irep_prepare_posthook(mrb_state *mrb, mrb_callinfo *ci, int nregs, mrb_func_t posthook) -{ - /* - * stack: [proc, errinfo, return value by called proc] - * - * begin - * OP_NOP # A dummy instruction built in to make the catch handler react. - * ensure - * OP_EXCEPT R1 # Save the exception object. - * OP_CALL # Call a C function for the hook. - * # The stack is kept as it is in the called proc. - * # The exception will be rethrown within the hook function. - * end - */ - static const mrb_code hook_iseq[] = { - OP_NOP, - OP_EXCEPT, 1, - OP_CALL, - CATCH_HANDLER_MAKE_BYTECODE(MRB_CATCH_ENSURE, 0, 1, 1), - }; - static const mrb_irep hook_irep = { - 1, 3, 1, MRB_IREP_STATIC, hook_iseq, - NULL, NULL, NULL, NULL, NULL, - sizeof(hook_iseq) / sizeof(hook_iseq[0]) - CATCH_HANDLER_NUM_TO_BYTE(1), - 0, 0, 0, 0 - }; - static const struct RProc hook_caller = { - NULL, NULL, MRB_TT_PROC, MRB_GC_RED, MRB_FL_OBJ_IS_FROZEN, { &hook_irep }, NULL, { NULL } - }; - - struct RProc *hook = mrb_proc_new_cfunc(mrb, posthook); - int acc = 2; - memmove(ci->stack + acc, ci->stack, sizeof(mrb_value) * nregs); - ci->stack[0] = mrb_obj_value(hook); - ci->stack[1] = mrb_nil_value(); - mrb_callinfo hook_ci = { 0, 0, ci->acc, &hook_caller, ci->stack, &hook_iseq[1], { NULL } }; - ci = cipush(mrb, acc, acc, NULL, ci[0].proc, ci[0].mid, ci[0].argc); - ci->u.env = ci[-1].u.env; - ci[-1] = hook_ci; -} - -/* - * If `posthook` is given, `posthook` will be called even if an - * exception or global jump occurs in `p`. Exception or global jump objects - * are stored in `mrb->c->stack[1]` and should be rethrown in `posthook`. - * - * if (!mrb_nil_p(mrb->c->stack[1])) { - * mrb_exc_raise(mrb, mrb->c->stack[1]); - * } - * - * If you want to return the return value by `proc` as it is, please do - * `return mrb->c->stack[2]`. - * - * However, if `proc` is a C function, it will be ignored. - */ static mrb_value -exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p, mrb_func_t posthook) +exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p) { mrb_callinfo *ci = mrb->c->ci; int keep, nregs; @@ -600,17 +532,12 @@ exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p, mrb_func_t posthook) nregs = p->body.irep->nregs; if (ci->argc < 0) keep = 3; else keep = ci->argc + 2; - int extra = posthook ? (2 /* hook proc + errinfo */) : 0; if (nregs < keep) { - mrb_stack_extend(mrb, keep + extra); + mrb_stack_extend(mrb, keep); } else { - mrb_stack_extend(mrb, nregs + extra); - stack_clear(ci->stack+keep, nregs-keep + extra); - } - - if (posthook) { - exec_irep_prepare_posthook(mrb, ci, (nregs < keep ? keep : nregs), posthook); + mrb_stack_extend(mrb, nregs); + stack_clear(ci->stack+keep, nregs-keep); } cipush(mrb, 0, 0, NULL, NULL, 0, 0); @@ -619,16 +546,16 @@ exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p, mrb_func_t posthook) } mrb_value -mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p, mrb_func_t posthook) +mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p) { mrb_callinfo *ci = mrb->c->ci; - if (ci->acc >= 0) { - return exec_irep(mrb, self, p, posthook); + if (ci->cci == CINFO_NONE) { + return exec_irep(mrb, self, p); } else { mrb_value ret; if (MRB_PROC_CFUNC_P(p)) { - cipush(mrb, 0, CI_ACC_DIRECT, mrb_vm_ci_target_class(ci), p, ci->mid, ci->argc); + cipush(mrb, 0, CINFO_DIRECT, mrb_vm_ci_target_class(ci), p, ci->mid, ci->argc); ret = MRB_PROC_CFUNC(p)(mrb, self); cipop(mrb); } @@ -675,7 +602,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "n*&", &name, &argv, &argc, &block); ci = mrb->c->ci; - if (ci->acc < 0) { + if (ci->cci > CINFO_NONE) { funcall: return mrb_funcall_with_block(mrb, self, name, argc, argv, block); } @@ -706,7 +633,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self) } return MRB_METHOD_CFUNC(m)(mrb, self); } - return exec_irep(mrb, self, MRB_METHOD_PROC(m), NULL); + return exec_irep(mrb, self, MRB_METHOD_PROC(m)); } static mrb_value @@ -720,7 +647,7 @@ eval_under(mrb_state *mrb, mrb_value self, mrb_value blk, struct RClass *c) mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given"); } ci = mrb->c->ci; - if (ci->acc == CI_ACC_DIRECT) { + if (ci->cci == CINFO_DIRECT) { return mrb_yield_with_class(mrb, blk, 1, &self, self, c); } ci->u.target_class = c; @@ -792,21 +719,11 @@ mrb_value mrb_obj_instance_eval(mrb_state *mrb, mrb_value self) { mrb_value a, b; - struct RClass *c; if (mrb_get_args(mrb, "|S&", &a, &b) == 1) { mrb_raise(mrb, E_NOTIMP_ERROR, "instance_eval with string not implemented"); } - switch (mrb_type(self)) { - case MRB_TT_MODULE: - case MRB_TT_CLASS: - case MRB_TT_ICLASS: - c = mrb_class_ptr(self); - break; - default: - c = mrb_singleton_class_ptr(mrb, self); - } - return eval_under(mrb, self, b, c); + return eval_under(mrb, self, b, mrb_singleton_class_ptr(mrb, self)); } MRB_API mrb_value @@ -827,7 +744,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err)); } p = mrb_proc_ptr(b); - ci = cipush(mrb, n, CI_ACC_SKIP, c, p, mid, 0 /* dummy */); + ci = cipush(mrb, n, CINFO_SKIP, c, p, mid, 0 /* dummy */); if (argc >= CALL_MAXARGS) { ci->argc = -1; n = 3; @@ -848,7 +765,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value mrb->c->ci->stack[argc+1] = mrb_nil_value(); if (MRB_PROC_CFUNC_P(p)) { - ci->acc = CI_ACC_DIRECT; + ci->cci = CINFO_DIRECT; val = MRB_PROC_CFUNC(p)(mrb, self); cipop(mrb); } @@ -894,7 +811,7 @@ mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const mrb->c->ci->stack[1] = mrb_ary_new_from_values(mrb, argc, argv); mrb->c->ci->stack[2] = mrb_nil_value(); ci->argc = -1; - return exec_irep(mrb, self, p, NULL); + return exec_irep(mrb, self, p); } static struct RBreak* @@ -902,7 +819,7 @@ 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); + brk = 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); @@ -1079,7 +996,7 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb #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: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; +#define CASE(insn,ops) case insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY: #define NEXT goto L_END_DISPATCH #define JUMP NEXT #define END_DISPATCH L_END_DISPATCH:;}} @@ -1087,7 +1004,7 @@ prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb #else #define INIT_DISPATCH JUMP; return mrb_nil_value(); -#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; +#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY: #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn] #define JUMP NEXT @@ -1125,19 +1042,27 @@ mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int sta return result; } -static mrb_bool +static struct RClass* check_target_class(mrb_state *mrb) { - if (!mrb_vm_ci_target_class(mrb->c->ci)) { + struct RClass *target = mrb_vm_ci_target_class(mrb->c->ci); + if (!target) { mrb_value exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR, "no target class or module"); mrb_exc_set(mrb, exc); - return FALSE; } - return TRUE; + return target; +} + +mrb_value +get_send_args(mrb_state *mrb, mrb_int argc, mrb_value *regs) +{ + if (argc < 0) return regs[0]; + return mrb_ary_new_from_values(mrb, argc, regs); } mrb_value mrb_obj_missing(mrb_state *mrb, mrb_value mod); void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self); +void mrb_method_added(mrb_state *mrb, struct RClass *c, mrb_sym mid); MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *pc) @@ -1191,11 +1116,7 @@ RETRY_TRY_BLOCK: NEXT; } - CASE(OP_LOADL16, BS) { - goto op_loadl; - } CASE(OP_LOADL, BB) { - op_loadl: switch (pool[b].tt) { /* number */ case IREP_TT_INT32: regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i32); @@ -1267,11 +1188,6 @@ RETRY_TRY_BLOCK: NEXT; } - CASE(OP_LOADSYM16, BS) { - SET_SYM_VALUE(regs[a], syms[b]); - NEXT; - } - CASE(OP_LOADNIL, B) { SET_NIL_VALUE(regs[a]); NEXT; @@ -1552,11 +1468,18 @@ RETRY_TRY_BLOCK: m = mrb_method_search_vm(mrb, &cls, mid); if (MRB_METHOD_UNDEF_P(m)) { 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); + mrb_value args; + + if (mrb_func_basic_p(mrb, recv, missing, mrb_obj_missing)) { + method_missing: + args = get_send_args(mrb, argc, regs+a+1); mrb_method_missing(mrb, mid, recv, args); } + if (mid != missing) { + cls = mrb_class(mrb, recv); + } + m = mrb_method_search_vm(mrb, &cls, missing); + if (MRB_METHOD_UNDEF_P(m)) goto method_missing; /* just in case */ if (argc >= 0) { if (a+2 >= irep->nregs) { mrb_stack_extend(mrb, a+3); @@ -1570,7 +1493,7 @@ RETRY_TRY_BLOCK: } /* push callinfo */ - ci = cipush(mrb, a, a, cls, NULL, mid, argc); + ci = cipush(mrb, a, 0, cls, NULL, mid, argc); if (MRB_METHOD_CFUNC_P(m)) { if (MRB_METHOD_PROC_P(m)) { @@ -1598,7 +1521,7 @@ RETRY_TRY_BLOCK: } } if (!ci->u.target_class) { /* return from context modifying method (resume/yield) */ - if (ci->acc == CI_ACC_RESUMED) { + if (ci->cci == CINFO_RESUMED) { mrb->jmp = prev_jmp; return recv; } @@ -1614,7 +1537,6 @@ RETRY_TRY_BLOCK: /* pop stackpos */ ci = cipop(mrb); pc = ci->pc; - JUMP; } else { /* setup environment for calling method */ @@ -1624,9 +1546,9 @@ RETRY_TRY_BLOCK: syms = irep->syms; mrb_stack_extend(mrb, (argc < 0 && irep->nregs < 3) ? 3 : irep->nregs); pc = irep->iseq; - JUMP; } } + JUMP; CASE(OP_CALL, Z) { mrb_callinfo *ci; @@ -1650,7 +1572,7 @@ RETRY_TRY_BLOCK: /* pop stackpos */ ci = cipop(mrb); pc = ci->pc; - regs[ci[1].acc] = recv; + ci[1].stack[0] = recv; irep = mrb->c->ci->proc->body.irep; pool = irep->pool; syms = irep->syms; @@ -1664,7 +1586,7 @@ RETRY_TRY_BLOCK: mrb->c->ci->stack[0] = mrb_nil_value(); a = 0; c = OP_R_NORMAL; - goto L_RETURN; + goto L_OP_RETURN_BODY; } pool = irep->pool; syms = irep->syms; @@ -1712,13 +1634,12 @@ RETRY_TRY_BLOCK: else if (target_class->tt == MRB_TT_MODULE) { target_class = mrb_vm_ci_target_class(ci); if (target_class->tt != MRB_TT_ICLASS) { - mrb_value exc = mrb_exc_new_lit(mrb, E_RUNTIME_ERROR, "superclass info lost [mruby limitations]"); - mrb_exc_set(mrb, exc); - goto L_RAISE; + goto super_typeerror; } } recv = regs[0]; if (!mrb_obj_is_kind_of(mrb, recv, target_class)) { + super_typeerror: ; 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); @@ -1736,20 +1657,18 @@ RETRY_TRY_BLOCK: m = mrb_method_search_vm(mrb, &cls, mid); if (MRB_METHOD_UNDEF_P(m)) { mrb_sym missing = MRB_SYM(method_missing); + mrb_value args; if (mrb_func_basic_p(mrb, recv, missing, mrb_obj_missing)) { - mrb_value args = (argc < 0) ? regs[a+1] : mrb_ary_new_from_values(mrb, b, regs+a+1); + super_missing: + args = get_send_args(mrb, argc, regs+a+1); mrb_no_method_error(mrb, mid, args, "no superclass method '%n'", mid); } if (mid != missing) { cls = mrb_class(mrb, recv); } m = mrb_method_search_vm(mrb, &cls, missing); - if (MRB_METHOD_UNDEF_P(m)) { /* just in case */ - mrb_value args = (argc < 0) ? regs[a+1] : mrb_ary_new_from_values(mrb, b, regs+a+1); - mrb_method_missing(mrb, missing, recv, args); - } - mid = missing; + if (MRB_METHOD_UNDEF_P(m)) goto super_missing; /* just in case */ if (argc >= 0) { if (a+2 >= irep->nregs) { mrb_stack_extend(mrb, a+3); @@ -1758,7 +1677,8 @@ RETRY_TRY_BLOCK: regs[a+2] = blk; argc = -1; } - mrb_ary_unshift(mrb, regs[a+1], mrb_symbol_value(ci->mid)); + mrb_ary_unshift(mrb, regs[a+1], mrb_symbol_value(mid)); + mid = missing; } /* push callinfo */ @@ -1779,7 +1699,7 @@ RETRY_TRY_BLOCK: ci = mrb->c->ci; mrb_assert(!mrb_break_p(v)); if (!mrb_vm_ci_target_class(ci)) { /* return from context modifying method (resume/yield) */ - if (ci->acc == CI_ACC_RESUMED) { + if (ci->cci == CINFO_RESUMED) { mrb->jmp = prev_jmp; return v; } @@ -1797,9 +1717,6 @@ RETRY_TRY_BLOCK: JUMP; } else { - /* fill callinfo */ - ci->acc = a; - /* setup environment for calling method */ mrb_vm_ci_proc_set(ci, (proc = MRB_METHOD_PROC(m))); irep = proc->body.irep; @@ -2086,7 +2003,7 @@ RETRY_TRY_BLOCK: } 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) { + if (ci[1].cci == CINFO_SKIP && prev_jmp) { mrb->jmp = prev_jmp; MRB_THROW(prev_jmp); } @@ -2134,7 +2051,7 @@ RETRY_TRY_BLOCK: switch (c) { 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)) { + if (ci->cci == CINFO_NONE && MRB_PROC_ENV_P(proc) && !MRB_PROC_STRICT_P(proc)) { const struct RProc *dst; mrb_callinfo *cibase; cibase = mrb->c->cibase; @@ -2150,7 +2067,7 @@ RETRY_TRY_BLOCK: } /* check jump destination */ while (cibase <= ci && ci->proc != dst) { - if (ci->acc < 0) { /* jump cross C boudary */ + if (ci->cci > CINFO_NONE) { /* jump cross C boundary */ localjump_error(mrb, LOCALJUMP_ERROR_RETURN); goto L_RAISE; } @@ -2258,7 +2175,7 @@ RETRY_TRY_BLOCK: c->prev = NULL; ci = mrb->c->ci; } - if (ci->acc < 0) { + if (ci->cci > CINFO_NONE) { ci = cipop(mrb); mrb_gc_arena_restore(mrb, ai); mrb->c->vmexec = FALSE; @@ -2284,7 +2201,7 @@ RETRY_TRY_BLOCK: } } while (mrb->c->cibase < ci && ci[-1].proc != proc->upper) { - if (ci[-1].acc == CI_ACC_SKIP) { + if (ci[-1].cci == CINFO_SKIP) { goto L_BREAK_ERROR; } CHECKPOINT_RESTORE(RBREAK_TAG_BREAK_UPPER) { @@ -2322,21 +2239,21 @@ RETRY_TRY_BLOCK: mrb->jmp = prev_jmp; return v; } - acc = ci->acc; + acc = ci->cci; ci = cipop(mrb); - if (acc == CI_ACC_SKIP || acc == CI_ACC_DIRECT) { + if (acc == CINFO_SKIP || acc == CINFO_DIRECT) { mrb_gc_arena_restore(mrb, ai); mrb->jmp = prev_jmp; return v; } - pc = ci[0].pc; + pc = ci->pc; DEBUG(fprintf(stderr, "from :%s\n", mrb_sym_name(mrb, ci->mid))); - proc = mrb->c->ci->proc; + proc = ci->proc; irep = proc->body.irep; pool = irep->pool; syms = irep->syms; - regs[acc] = v; + ci[1].stack[0] = v; mrb_gc_arena_restore(mrb, ai); } JUMP; @@ -2440,9 +2357,7 @@ RETRY_TRY_BLOCK: CASE(OP_DIV, B) { #ifndef MRB_NO_FLOAT mrb_float x, y, f; - mrb_float mrb_div_flo(mrb_float x, mrb_float y); #endif - mrb_int mrb_div_int(mrb_state *mrb, mrb_int x, mrb_int y); /* need to check if op is overridden */ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) { @@ -2475,7 +2390,7 @@ RETRY_TRY_BLOCK: } #ifndef MRB_NO_FLOAT - f = mrb_div_flo(x, y); + f = mrb_div_float(x, y); SET_FLOAT_VALUE(mrb, regs[a], f); #endif NEXT; @@ -2625,14 +2540,18 @@ RETRY_TRY_BLOCK: regs[a] = splat; } else { + mrb_assert(mrb_type(regs[a]) == MRB_TT_ARRAY); mrb_ary_concat(mrb, regs[a], splat); } mrb_gc_arena_restore(mrb, ai); NEXT; } - CASE(OP_ARYPUSH, B) { - mrb_ary_push(mrb, regs[a], regs[a+1]); + CASE(OP_ARYPUSH, BB) { + mrb_assert(mrb_type(regs[a]) == MRB_TT_ARRAY); + for (mrb_int i=0; i<b; i++) { + mrb_ary_push(mrb, regs[a], regs[a+i+1]); + } NEXT; } @@ -2667,6 +2586,7 @@ RETRY_TRY_BLOCK: } CASE(OP_ASET, BBB) { + mrb_assert(mrb_type(regs[a]) == MRB_TT_ARRAY); mrb_ary_set(mrb, regs[b], c, regs[a]); NEXT; } @@ -2709,16 +2629,29 @@ RETRY_TRY_BLOCK: mrb_sym sym = mrb_intern_str(mrb, regs[a]); regs[a] = mrb_symbol_value(sym); - mrb_gc_arena_restore(mrb, ai); NEXT; } - CASE(OP_STRING16, BS) { - goto op_string; + CASE(OP_SYMBOL, BB) { + size_t len; + mrb_sym sym; + + mrb_assert((pool[b].tt&IREP_TT_NFLAG)==0); + len = pool[b].tt >> 2; + if (pool[b].tt & IREP_TT_SFLAG) { + sym = mrb_intern_static(mrb, pool[b].u.str, len); + } + else { + sym = mrb_intern(mrb, pool[b].u.str, len); + } + regs[a] = mrb_symbol_value(sym); + NEXT; } + CASE(OP_STRING, BB) { size_t len; - op_string: + + mrb_assert((pool[b].tt&IREP_TT_NFLAG)==0); len = pool[b].tt >> 2; if (pool[b].tt & IREP_TT_SFLAG) { regs[a] = mrb_str_new_static(mrb, pool[b].u.str, len); @@ -2753,7 +2686,8 @@ RETRY_TRY_BLOCK: int i; int lim = a+b*2+1; - hash = mrb_ensure_hash_type(mrb, regs[a]); + hash = regs[a]; + mrb_ensure_hash_type(mrb, hash); for (i=a+1; i<lim; i+=2) { mrb_hash_set(mrb, hash, regs[i], regs[i+1]); } @@ -2761,8 +2695,9 @@ RETRY_TRY_BLOCK: NEXT; } CASE(OP_HASHCAT, B) { - mrb_value hash = mrb_ensure_hash_type(mrb, regs[a]); + mrb_value hash = regs[a]; + mrb_ensure_hash_type(mrb, hash); mrb_hash_merge(mrb, hash, regs[a+1]); mrb_gc_arena_restore(mrb, ai); NEXT; @@ -2795,18 +2730,6 @@ RETRY_TRY_BLOCK: c = OP_L_METHOD; goto L_MAKE_LAMBDA; } - CASE(OP_LAMBDA16, BS) { - c = OP_L_LAMBDA; - goto L_MAKE_LAMBDA; - } - CASE(OP_BLOCK16, BS) { - c = OP_L_BLOCK; - goto L_MAKE_LAMBDA; - } - CASE(OP_METHOD16, BS) { - c = OP_L_METHOD; - goto L_MAKE_LAMBDA; - } CASE(OP_RANGE_INC, B) { mrb_value val = mrb_range_new(mrb, regs[a], regs[a+1], FALSE); @@ -2862,10 +2785,7 @@ RETRY_TRY_BLOCK: NEXT; } - CASE(OP_EXEC16, BS) - goto L_EXEC; CASE(OP_EXEC, BB) - L_EXEC: { mrb_value recv = regs[a]; struct RProc *p; @@ -2879,7 +2799,7 @@ RETRY_TRY_BLOCK: p->flags |= MRB_PROC_SCOPE; /* prepare call stack */ - cipush(mrb, a, a, mrb_class_ptr(recv), p, 0, 0); + cipush(mrb, a, 0, mrb_class_ptr(recv), p, 0, 0); irep = p->body.irep; pool = irep->pool; @@ -2894,10 +2814,13 @@ RETRY_TRY_BLOCK: struct RClass *target = mrb_class_ptr(regs[a]); struct RProc *p = mrb_proc_ptr(regs[a+1]); mrb_method_t m; + mrb_sym mid = syms[b]; MRB_METHOD_FROM_PROC(m, p); - mrb_define_method_raw(mrb, target, syms[b], m); + mrb_define_method_raw(mrb, target, mid, m); + mrb_method_added(mrb, target, mid); mrb_gc_arena_restore(mrb, ai); + regs[a] = mrb_symbol_value(mid); NEXT; } @@ -2908,24 +2831,24 @@ RETRY_TRY_BLOCK: } CASE(OP_TCLASS, B) { - if (!check_target_class(mrb)) goto L_RAISE; - regs[a] = mrb_obj_value(mrb_vm_ci_target_class(mrb->c->ci)); + struct RClass *target = check_target_class(mrb); + if (!target) goto L_RAISE; + regs[a] = mrb_obj_value(target); NEXT; } CASE(OP_ALIAS, BB) { - struct RClass *target; + struct RClass *target = check_target_class(mrb); - if (!check_target_class(mrb)) goto L_RAISE; - target = mrb_vm_ci_target_class(mrb->c->ci); + if (!target) goto L_RAISE; mrb_alias_method(mrb, target, syms[a], syms[b]); + mrb_method_added(mrb, target, syms[a]); NEXT; } CASE(OP_UNDEF, B) { - struct RClass *target; + struct RClass *target = check_target_class(mrb); - if (!check_target_class(mrb)) goto L_RAISE; - target = mrb_vm_ci_target_class(mrb->c->ci); + if (!target) goto L_RAISE; mrb_undef_method_id(mrb, target, syms[a]); NEXT; } @@ -2958,6 +2881,37 @@ RETRY_TRY_BLOCK: NEXT; } + CASE(OP_EXT1, Z) { + insn = READ_B(); + switch (insn) { +#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; 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(); mrb->c->ci->pc = pc; 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(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY; +#include "mruby/ops.h" +#undef OPCODE + } + pc--; + NEXT; + } + CASE(OP_STOP, Z) { /* stop VM */ CHECKPOINT_RESTORE(RBREAK_TAG_STOP) { @@ -2981,7 +2935,7 @@ RETRY_TRY_BLOCK: } MRB_CATCH(&c_jmp) { mrb_callinfo *ci = mrb->c->ci; - while (ci > mrb->c->cibase && ci->acc == CI_ACC_DIRECT) { + while (ci > mrb->c->cibase && ci->cci == CINFO_DIRECT) { ci = cipop(mrb); } exc_catched = TRUE; @@ -3014,7 +2968,7 @@ mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int st mrb_vm_ci_env_set(mrb->c->ci, NULL); return mrb_vm_run(mrb, proc, self, stack_keep); } - cipush(mrb, 0, CI_ACC_SKIP, mrb->object_class, NULL, 0, 0); + cipush(mrb, 0, CINFO_SKIP, mrb->object_class, NULL, 0, 0); v = mrb_vm_run(mrb, proc, self, stack_keep); return v; diff --git a/tasks/doc.rake b/tasks/doc.rake index 8013ed038..8a9108f1a 100644 --- a/tasks/doc.rake +++ b/tasks/doc.rake @@ -18,7 +18,10 @@ namespace :doc do sh "doxygen Doxyfile" rescue puts "ERROR: To generate C API documents, you need Doxygen." + puts "On Debian-based systems:" puts " $ sudo apt-get install doxygen" + puts "On RHEL-based systems:" + puts " $ sudo dnf install doxygen" end end diff --git a/tasks/libmruby.rake b/tasks/libmruby.rake index 9a7a57ff7..1fb3cbc31 100644 --- a/tasks/libmruby.rake +++ b/tasks/libmruby.rake @@ -14,7 +14,8 @@ MRuby.each_target do file "#{build_dir}/lib/libmruby.flags.mak" => [__FILE__, libmruby_static] do |t| mkdir_p File.dirname t.name open(t.name, 'w') do |f| - f.puts "MRUBY_CFLAGS = #{cc.all_flags}" + gemincs = gems.map { |g| g.export_include_paths.map { |n| g.filename(n) } }.flatten.uniq + f.puts "MRUBY_CFLAGS = #{cc.all_flags([], gemincs)}" f.puts "MRUBY_CC = #{cc.command}" f.puts "MRUBY_LD = #{linker.command}" diff --git a/test/t/bs_block.rb b/test/t/bs_block.rb index 995e52559..f4e4da375 100644 --- a/test/t/bs_block.rb +++ b/test/t/bs_block.rb @@ -520,3 +520,15 @@ assert('BS Block 38') do assert_equal [1,2,3,4,5], iter{|a,b,c=:c,d,e| [a,b,c,d,e]} end + +assert('BS Block 39') do + def iter + yield 1 + end + + assert_equal([1, 2, nil]) do + iter{|a, b=2, c| + [a, b, c] + } + end +end diff --git a/test/t/class.rb b/test/t/class.rb index e2839111c..1b4b84890 100644 --- a/test/t/class.rb +++ b/test/t/class.rb @@ -375,6 +375,20 @@ assert('clone Class') do assert_true(Foo.clone.new.func) end +assert('class definition in singleton class') do + class AClassS + class << self + class BClass + end + + def iclass + BClass + end + end + end + assert_equal(Class, AClassS.iclass.class) +end + assert('class variable and class << self style class method') do class ClassVariableTest @@class_variable = "value" diff --git a/test/t/float.rb b/test/t/float.rb index f6f6d01dd..e4c25b34e 100644 --- a/test/t/float.rb +++ b/test/t/float.rb @@ -277,8 +277,6 @@ assert('Float#to_s') do assert_equal("-1.0e-10", -0.0000000001.to_s) assert_equal("1.0e+20", 1e20.to_s) assert_equal("-1.0e+20", -1e20.to_s) - assert_equal("1.0e+16", 10000000000000000.0.to_s) - assert_equal("-1.0e+16", -10000000000000000.0.to_s) assert_equal("100000.0", 100000.0.to_s) assert_equal("-100000.0", -100000.0.to_s) if uses_float @@ -305,4 +303,16 @@ assert('Float#eql?') do assert_not_operator(5.0, :eql?, "5.0") end +assert('Float#abs') do + f = 1.0 + assert_equal(1.0, f.abs) + f = -1.0 + assert_equal(1.0, f.abs) + f = 0.0 + assert_equal(0.0, f.abs) + # abs(negative zero) should be positive zero + f = -0.0 + assert_equal(0.0, f.abs) +end + end # const_defined?(:Float) diff --git a/test/t/hash.rb b/test/t/hash.rb index 9bc2668ae..1b4db056e 100644 --- a/test/t/hash.rb +++ b/test/t/hash.rb @@ -1006,3 +1006,9 @@ assert('#== receiver should be specified value') do %i[has_value? value?].each{|m| assert_nothing_raised{h.__send__(m, v1)}} end end + +assert('test value ommision') do + x = 1 + y = 2 + assert_equal({x:1, y:2}, {x:, y:}) +end diff --git a/test/t/methods.rb b/test/t/methods.rb index f9c25dc33..9005d7976 100644 --- a/test/t/methods.rb +++ b/test/t/methods.rb @@ -107,3 +107,32 @@ assert('The undef statement (method undefined)', '13.3.7 a) 5)') do undef :non_existing_method end end + +assert('method_added hook') do + c = Class.new do + # method to retrieve @name + def self.name; @name; end + # hook method on method definition + def self.method_added(name) @name = name; end + # method definition + def foo; end + end + assert_equal(:foo, c.name) + c.define_method(:bar){} + assert_equal(:bar, c.name) +end + +assert('singleton_method_added hook') do + a = Object.new + # method to retrieve @name + def a.name; @name; end + # hook method on singleton method definition + def a.singleton_method_added(name) @name = name; end + # singleton method definition + def a.foo; end + assert_equal(:foo, a.name) + class <<a + def bar; end + end + assert_equal(:bar, a.name) +end diff --git a/test/t/superclass.rb b/test/t/superclass.rb index f213b1247..81630192d 100644 --- a/test/t/superclass.rb +++ b/test/t/superclass.rb @@ -23,8 +23,7 @@ [:Exception, :Object, '15.2.22.2'], [:StandardError, :Exception, '15.2.23.2'], [:ArgumentError, :StandardError, '15.2.24.2'], - # [:LocalJumpError, :StandardError, '15.2.25.2'], - [:LocalJumpError, :ScriptError, '15.2.25.2'], # mruby specific + [:LocalJumpError, :StandardError, '15.2.25.2'], [:RangeError, :StandardError, '15.2.26.2'], [:RegexpError, :StandardError, '15.2.27.2'], [:RuntimeError, :StandardError, '15.2.28.2'], diff --git a/test/t/symbol.rb b/test/t/symbol.rb index 5c674a9cb..4cb210757 100644 --- a/test/t/symbol.rb +++ b/test/t/symbol.rb @@ -17,10 +17,6 @@ assert('Symbol#===', '15.2.11.3.1') do assert_false :abc === :cba end -assert('Symbol#id2name', '15.2.11.3.2') do - assert_equal 'abc', :abc.id2name -end - assert('Symbol#to_s', '15.2.11.3.3') do assert_equal 'abc', :abc.to_s end diff --git a/test/t/syntax.rb b/test/t/syntax.rb index b3ee2d438..515c8f361 100644 --- a/test/t/syntax.rb +++ b/test/t/syntax.rb @@ -48,7 +48,32 @@ assert('yield', '11.3.5') do end end -assert('redo in a for loop (#3275)') do +assert('break', '11.5.2.4.3') do + n = 0 + a = [] + while true + n += 1 + a.push(n) + if n > 3 + break + end + end + + assert_equal [1,2,3,4], a + + n = 0 + a = [] + 6.times do + n += 1 + a.push(n) + if n > 3 + break + end + end + assert_equal [1,2,3,4], a +end + +assert('redo', '11.5.2.4.5') do sum = 0 for i in 1..10 sum += i @@ -59,6 +84,17 @@ assert('redo in a for loop (#3275)') do end assert_equal 220, sum + + n = 0 + a = [] + 3.times do + n += 1 + if n == 2 + redo + end + a.push(n) + end + assert_equal [1,3,4], a end assert('Abbreviated variable assignment', '11.4.2.3.2') do @@ -188,6 +224,18 @@ assert('Abbreviated variable assignment as returns') do assert_equal 1, Syntax4AbbrVarAsgnAsReturns::A.new.b end +assert('Abbreviated variable assignment of object attribute') do + module Syntax4AbbrVarAsgnObjectAttr + class A + attr_accessor :c + def b + self.c ||= 1 + end + end + end + assert_equal 1, Syntax4AbbrVarAsgnObjectAttr::A.new.b +end + assert('Splat and multiple assignment') do *a = *[1,2,3] b, *c = *[7,8,9] @@ -706,3 +754,29 @@ assert('argument forwarding') do o.a(1,2,3){} o.b(1,2,3){} end + +assert('endless def') do + c = Class.new { + def m1 = 42 + def m2() = 42 + def m3(x) = x+1 + def self.s1 = 42 + def self.s2() = 42 + def self.s3(x) = x + 1 + def cm1 = m3 42 + def cm2() = m3 42 + def cm3(x) = m3 x+1 + def self.cs1 = s3 42 + def self.cs2() = s3 42 + def self.cs3(x) = s3 x + 1 + } + o = c.new + assert_equal(42, o.m1) + assert_equal(43, o.m3(o.m2)) + assert_equal(42, c.s1) + assert_equal(43, c.s3(c.s2)) + assert_equal(43, o.cm1) + assert_equal(45, o.cm3(o.cm2)) + assert_equal(43, c.cs1) + assert_equal(45, c.cs3(c.cs2)) +end diff --git a/test/t/unicode.rb b/test/t/unicode.rb index 8622ae08a..c8602da5a 100644 --- a/test/t/unicode.rb +++ b/test/t/unicode.rb @@ -1,15 +1,15 @@ # Test of the \u notation assert('bare \u notation test') do - # Mininum and maximum one byte characters + # Minimum and maximum one byte characters assert_equal("\x00", "\u0000") assert_equal("\x7F", "\u007F") - # Mininum and maximum two byte characters + # Minimum and maximum two byte characters assert_equal("\xC2\x80", "\u0080") assert_equal("\xDF\xBF", "\u07FF") - # Mininum and maximum three byte characters + # Minimum and maximum three byte characters assert_equal("\xE0\xA0\x80", "\u0800") assert_equal("\xEF\xBF\xBF", "\uFFFF") @@ -17,19 +17,19 @@ assert('bare \u notation test') do end assert('braced \u notation test') do - # Mininum and maximum one byte characters + # Minimum and maximum one byte characters assert_equal("\x00", "\u{0000}") assert_equal("\x7F", "\u{007F}") - # Mininum and maximum two byte characters + # Minimum and maximum two byte characters assert_equal("\xC2\x80", "\u{0080}") assert_equal("\xDF\xBF", "\u{07FF}") - # Mininum and maximum three byte characters + # Minimum and maximum three byte characters assert_equal("\xE0\xA0\x80", "\u{0800}") assert_equal("\xEF\xBF\xBF", "\u{FFFF}") - # Mininum and maximum four byte characters + # Minimum and maximum four byte characters assert_equal("\xF0\x90\x80\x80", "\u{10000}") assert_equal("\xF4\x8F\xBF\xBF", "\u{10FFFF}") end |