Update version to 3.1.0RC2.

Need to declare unnamed parameter when argument decomposition used.

.editorconfig

@@ -0,0 +1,43 @@
+# About this file, see:
+#   Website: https://editorconfig.org/
+#   For Emacs users: https://github.com/editorconfig/editorconfig-emacs
+#   For Vim users: https://github.com/editorconfig/editorconfig-vim
+
+root = true
+
+[*]
+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_size = 2
+indent_style = space
+trim_trailing_whitespace = true
+#max_line_length = 120
+
+[{*.rb,Rakefile,rakefile,*.rake,*.gemspec,*.gembox}]
+indent_size = 2
+indent_style = space
+trim_trailing_whitespace = true
+#max_line_length = 120
+
+[*.bat]
+charset = latin1
+end_of_line = crlf
+#max_line_length = 80
+
+[*.{yaml,yml}]
+indent_size = 2
+indent_style = space
+
+[*.md]
+indent_size = 2
+indent_style = space

.git-blame-ignore-revs

@@ -0,0 +1,4 @@
+# Extend the tab with 8 whitespace
+6fc5dc986a5ffc1a74c63ad0617ea1dcc10d3cdd
+# reformatted doc/opcode.md
+61e8a540869c57ebddac53cf9d243db407d57fff

.github/dependabot.yml

@@ -0,0 +1,10 @@
+# Basic set up
+
+version: 2
+updates:
+
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/linters/.ecrc

@@ -0,0 +1,12 @@
+{
+    "verbose": false,
+    "ignore_defaults": false,
+    "exclude": ["oss-fuzz/", "src/"],
+    "disable": {
+        "end_of_line": false,
+        "trim_trailing_whitespace": false,
+        "insert_final_newline": false,
+        "indent_size": true,
+        "indent_style": true
+   }
+}

.github/linters/.markdown-lint.yml

@@ -0,0 +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
+
+# MD010 no-hard-tabs - Hard tabs
+MD010: 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

.github/linters/.yaml-lint.yml

@@ -0,0 +1,9 @@
+---
+# https://yamllint.readthedocs.io/en/stable/
+# yamllint --strict -c .github/linters/.yaml-lint.yml .
+extends: default
+
+rules:
+  document-start: disable
+  line-length: disable
+  truthy: false

.github/workflows/build.yml

@@ -0,0 +1,155 @@
+name: Build & Test
+
+on: [push, pull_request]
+
+jobs:
+  Ubuntu-1804-gcc:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 10
+    env:
+      MRUBY_CONFIG: ci/gcc-clang
+      CC: gcc
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - name: Ruby version
+        run: ruby -v
+      - name: Compiler version
+        run: ${{ env.CC }} --version
+      - name: Build and test
+        run: rake -m test:build && rake test:run
+
+  Ubuntu-1804-clang:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 10
+    env:
+      MRUBY_CONFIG: ci/gcc-clang
+      CC: clang
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - name: Ruby version
+        run: ruby -v
+      - name: Compiler version
+        run: ${{ env.CC }} --version
+      - name: Build and test
+        run: rake -m test:build && rake test:run
+
+  Ubuntu-2004-gcc:
+    runs-on: ubuntu-20.04
+    timeout-minutes: 10
+    env:
+      MRUBY_CONFIG: ci/gcc-clang
+      CC: gcc
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - name: Ruby version
+        run: ruby -v
+      - name: Compiler version
+        run: ${{ env.CC }} --version
+      - name: Build and test
+        run: rake -m test:build && rake test:run
+
+  Ubuntu-2004-clang:
+    runs-on: ubuntu-20.04
+    timeout-minutes: 10
+    env:
+      MRUBY_CONFIG: ci/gcc-clang
+      CC: clang
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - name: Ruby version
+        run: ruby -v
+      - name: Compiler version
+        run: ${{ env.CC }} --version
+      - name: Build and test
+        run: rake -m test:build && rake test:run
+
+  macOS:
+    runs-on: macos-latest
+    timeout-minutes: 10
+    env:
+      MRUBY_CONFIG: ci/gcc-clang
+      CC: clang
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - name: Ruby version
+        run: ruby -v
+      - name: Compiler version
+        run: ${{ env.CC }} --version
+      - name: Build and test
+        run: rake -m test:build && rake test:run
+
+  Windows-MinGW:
+    runs-on: windows-latest
+    timeout-minutes: 10
+    env:
+      MRUBY_CONFIG: ci/gcc-clang
+      CC: gcc
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - name: Ruby version
+        run: ruby -v
+      - name: Compiler version
+        run: ${{ env.CC }} --version
+      - name: Build and test
+        run: rake -m test:build && rake test:run
+
+  Windows-Cygwin:
+    runs-on: windows-latest
+    timeout-minutes: 15
+    env:
+      ACTIONS_ALLOW_UNSECURE_COMMANDS: true
+      MRUBY_CONFIG: ci/gcc-clang
+      CC: gcc
+      installer-path: '%TMP%\cygwin-setup.exe'
+      cygwin-root: C:\cygwin
+      package-dir: C:\cygwin-package
+      cache-version: v1
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - uses: actions/cache@v2.1.7
+        with:
+          path: ${{ env.package-dir }}
+          key: ${{ runner.os }}-cygwin-${{ env.cache-version }}
+      - name: Download Cygwin installer
+        shell: cmd
+        run: >
+          bitsadmin /transfer download /priority foreground
+          https://cygwin.com/setup-x86_64.exe ${{ env.installer-path }}
+      - name: Install Cygwin
+        shell: cmd
+        run: >
+          ${{ env.installer-path }}
+          --quiet-mode --no-shortcuts --no-startmenu --no-desktop --no-admin
+          --only-site --site http://mirrors.kernel.org/sourceware/cygwin/
+          --root ${{ env.cygwin-root }}
+          --local-package-dir ${{ env.package-dir }}
+          --packages gcc-core,gcc-g++,ruby
+      - name: Set PATH for Cygwin
+        run: |
+          echo '::set-env name=PATH::${{ env.cygwin-root }}\bin;${{ env.cygwin-root }}\usr\bin'
+      - name: Ruby version
+        shell: cmd
+        run: ruby -v
+      - name: Compiler version
+        run: ${{ env.CC }} --version
+      - name: Build and test
+        shell: cmd
+        run: ruby /usr/bin/rake -m test:build && ruby /usr/bin/rake test:run
+      - name: Set PATH for cache archiving (tar)
+        # set Windows path so that Cygwin tar is not used for cache archiving
+        run: echo '::set-env name=PATH::C:\windows\System32'
+
+  Windows-VC:
+    runs-on: windows-latest
+    timeout-minutes: 10
+    env:
+      MRUBY_CONFIG: ci/msvc
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - name: Ruby version
+        run: ruby -v
+      - name: Build and test
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          rake -m test:build && rake test:run

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,46 @@
+name: "Code scanning - action"
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 19 * * 4'
+
+jobs:
+  CodeQL-Build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2.4.0
+        with:
+          # We must fetch at least the immediate parents so that if this is
+          # a pull request then we can checkout the head.
+          fetch-depth: 2
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v1
+        # Override language selection by uncommenting this and choosing your languages
+        # with:
+        #   languages: go, javascript, csharp, python, cpp, java
+
+      # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+      # If this step fails, then you should remove it and run the build manually (see below)
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v1
+
+      # ℹ️ Command-line programs to run using the OS shell.
+      # 📚 https://git.io/JvXDl
+
+      # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+      #    and modify them (or add more) to build your code if your project
+      #    uses a compiled language
+
+      # - run: |
+      #    make bootstrap
+      #    make release
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v1

.github/workflows/lint.yml

@@ -0,0 +1,32 @@
+name: Lint
+
+on: [pull_request]
+
+jobs:
+  misspell:
+    name: Check spelling with misspell
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out
+        uses: actions/checkout@v2.4.0
+      - name: Install
+        run: wget -O - -q https://git.io/misspell | sh -s -- -b .
+      - name: Misspell
+        run: git ls-files --empty-directory | xargs ./misspell -error
+  pre-commit:
+    name: Run pre-commit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - name: Check merge conflict
+        run: |
+          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@v2.1.7
+        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

.github/workflows/oss-fuzz.yml

@@ -0,0 +1,23 @@
+name: CIFuzz
+on: [pull_request]
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Build Fuzzers
+        uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+        with:
+          oss-fuzz-project-name: 'mruby'
+          dry-run: false
+      - name: Run Fuzzers
+        uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+        with:
+          oss-fuzz-project-name: 'mruby'
+          fuzz-seconds: 600
+          dry-run: false
+      - name: Upload Crash
+        uses: actions/upload-artifact@v2.3.1
+        if: failure()
+        with:
+          name: artifacts
+          path: ./out/artifacts

.github/workflows/super-linter.yml

@@ -0,0 +1,23 @@
+name: Super Linter
+
+on:
+  push:
+    branches-ignore: [master]
+    # Remove the line above to run when pushing to master
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    name: Lint Code Base
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - uses: github/super-linter@v4.8.5
+        env:
+          ERROR_ON_MISSING_EXEC_BIT: true
+          VALIDATE_BASH: true
+          # VALIDATE_BASH_EXEC: true
+          # VALIDATE_EDITORCONFIG: true
+          # VALIDATE_SHELL_SHFMT: true
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,13 +1,13 @@
-# /
+*.lock
 *.bak
+*.bc
 *.d
+*.i
 *.o
-/benchmark/**/*.dat
-/benchmark/*.pdf
-/benchmark/*.png
 *.orig
 *.pdb
 *.rej
+*.s
 *.sav
 *.swp
 *.tmp
@@ -16,13 +16,22 @@
 .ccmalloc
 .svn
 .vscode
-/.git
+.yardoc
+.ccls*
+compile_flags.txt
+compile_commands.json
 cscope.files
 cscope.out
 tags
-/src/y.tab.c
+
+/.git
 /bin
 /build
 /mruby-source-*.gem
-doc/api
-.yardoc
+
+/benchmark/**/*.dat
+/benchmark/*.pdf
+/benchmark/*.png
+
+/doc/api
+/doc/capi

.pre-commit-config.yaml

@@ -0,0 +1,58 @@
+---
+default_stages: [commit, push]
+default_language_version:
+  # force all unspecified Python hooks to run python3
+  python: python3
+minimum_pre_commit_version: "1.20.0"
+repos:
+  - repo: meta
+    hooks:
+      - id: identity
+      - id: check-hooks-apply
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.1.0
+    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
+  # - repo: git://github.com/Lucas-C/pre-commit-hooks
+  #  rev: v1.1.9
+  #  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.30.0
+    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.3
+    hooks:
+      - id: yamllint
+        name: Run yamllint
+        description: Check YAML files with yamllint
+        entry: yamllint --strict -c .github/linters/.yaml-lint.yml
+        types: [yaml]
+        files: \.(yaml|yml)$

.travis.yml

@@ -1,19 +1,11 @@
 language: c
 
-sudo: false
-
-matrix:
-  include:
-    - os: linux
-      sudo: false
-    - os: osx
-      osx_image: xcode7.1
-
-addons:
-  apt:
-    packages:
-      - gperf
+jobs:
+  - os: linux
+  - os: osx
 
 env:
-  - MRUBY_CONFIG=travis_config.rb
-script: "./minirake -j4 all test"
+  - MRUBY_CONFIG=ci/gcc-clang
+
+script:
+  - rake -m test:build && rake test:run

.yardopts

@@ -12,6 +12,6 @@ mrbgems/*/mrblib/**/*.rb
 mrbgems/*/include/**/*.h
 -
 AUTHORS
-MITL
+LICENSE
 CONTRIBUTING.md
 doc/guides/*.md

AUTHORS

@@ -1,40 +1,310 @@
-Original Authors "mruby developers" are:
-   Yukihiro Matsumoto
+# Authors of mruby (mruby developers)
+
+## The List of Contributors sorted by number of commits (as of 2022-01-10 69b1667)
+
+   7956 Yukihiro "Matz" Matsumoto (@matz)*
+    586 KOBAYASHI Shuji (@shuujii)
+    376 Daniel Bovensiepen (@bovi)
+    346 Takeshi Watanabe (@take-cheeze)*
+    342 dearblue (@dearblue)*
+    334 Masaki Muranaka (@monaka)
+    298 Tomoyuki Sahara (@tsahara)*
+    234 Jun Hiroe (@suzukaze)
+    219 Cremno (@cremno)*
+    208 Yuki Kurihara (@ksss)+
+    148 Yasuhiro Matsumoto (@mattn)*
+    113 Carson McDonald (@carsonmcdonald)
+    103 Tomasz Dąbrowski (@dabroz)*
+     84 skandhas (@skandhas)
+     80 Masamitsu MURASE (@masamitsu-murase)
+     74 Yuichiro MASUI (@masuidrive)
+     71 Tatsuhiko Kubo (@cubicdaiya)*
+     68 Hiroshi Mimaki (@mimaki)*
+     63 Akira Yumiyama (@akiray03)*
+     62 Paolo Bosetti (@pbosetti)*
+     59 Kurebayashi, Takahiro (@crimsonwoods)*
+     56 h2so5 (@h2so5)
+     52 Ralph Desir (@Mav7)*
+     49 John Bampton (@jbampton)
+     45 Rory O'Connell (@RoryO)*
+     43 Yuichiro Kaneko (@yui-knk)+
+     42 fleuria (@flaneur2020)
+     40 Christopher Aue (@christopheraue)
+     40 Seba Gamboa (@sagmor)
+     38 Koji Yoshioka (@kyab)*+
+     38 Kouhei Sutou (@kou)*
+     31 MATSUMOTO Ryosuke (@matsumotory)*
+     30 Nobuyoshi Nakada (@nobu)
+     28 Masayoshi Takahashi (@takahashim)+
+     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 Uchio Kondo (@udzura)*
+     19 Bouke van der Bijl (@bouk)
+     19 Felix Jones (@felixjones)*
+     19 Hidetaka Takano (@TJ-Hidetaka-Takano)
+     19 go kikuta (@gkta)*
+     18 Corey Powell (@IceDragon200)
+     18 Jon Maken (@jonforums)+
+     18 Mitchell Blank Jr (@mitchblank)*
+     17 Ryan Lopopolo (@lopopolo)
+     16 bggd (@bggd)
+     16 kano4 (@kano4)
+     14 Blaž Hrastnik (@archseer)*
+     14 Jose Narvaez (@goyox86)
+     14 Kazuki Tsujimoto (@k-tsj)
+     14 Tadashi FUKUZAWA (@FUKUZAWA-Tadashi)+
+     13 Patrick Hogan (@pbhogan)
+     12 Akira Kuroda (@akuroda)
+     12 Kouki Ooyatsu (kaishuu0123)*
+     12 NAKAMURA Usaku (@unak)*
+     12 RIZAL Reckordp (@Reckordp)+
+     12 Takashi Sawanaka (@sdottaka)*
+     12 Ukrainskiy Sergey (@ukrainskiysergey)
+     12 Xuejie "Rafael" Xiao (@xxuejie)*
+     11 Julien Ammous (@schmurfy)
+     11 Seeker (@SeekingMeaning)
+     11 YAMAMOTO Masaya (pandax381)
+     11 takkaw (@takkaw)
+     10 Kazuho Oku (@kazuho)
+     10 Miura Hideki (@miura1729)
+     10 Narihiro Nakamura (@authorNari)
+     10 Ray Chason (@chasonr)*
+     10 Yuichi Nishiwaki (@nyuichi)
+      9 Akira Mitsui (@murasesyuka)*
+      9 Frank Celler (@fceller)
+      9 Tatsuya Matsumoto (@tmash06)*
+      8 Takashi Sogabe (@sogabe)
+      7 Bhargava Shastry (@bshastry)*
+      7 Kouichi Nakanishi (@keizo042)
+      7 Rubyist (@expeditiousRubyist)
+      7 Simon Génier (@simon-shopify)
+      7 Terence Lee (@hone)
+      7 Wataru Ashihara (@wataash)*
+      7 roco (@rystyle)*
+      6 Akito Mochizuki (@ak-mochi)
+      6 Beoran (@beoran)
+      6 David Siaw (@davidsiaw)*
+      6 Frederick John Milens III (@fjmilens3)
+      6 Hiro Asari (@BanzaiMan)
+      6 INOUE Yasuyuki (@yasuyuki)
+      6 Junji Sawada (@junjis0203)
+      6 Kenji Okimoto (@okkez)+
+      6 Selman ULUG (@selman)
+      6 Yusuke Endoh (@mame)*
+      5 Davide D'Agostino (@DAddYE)
+      5 Eric Hodel (@drbrain)
+      5 Hendrik (@Asmod4n)
+      5 Ichito Nagata (@i110)
+      5 Keita Obo (@ktaobo)*
+      5 Max Anselm (@silverhammermba)
+      5 SiZiOUS (@sizious)
+      5 Syohei YOSHIDA (@syohex)
+      5 TOMITA Masahiro (@tmtm)
+      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)
+      4 Ken Muramatsu (@ken-mu)+
+      4 Kohei Suzuki (@eagletmt)
+      4 Li Yazhou (@flaneur2020)
+      4 Marcus Stollsteimer (@stomar)
+      4 NARUSE, Yui (@nurse)
+      4 Ravil Bayramgalin (@brainopia)*+
+      4 Satoshi Odawara (@SatoshiOdawara)
+      4 Yuhei Okazaki (@Yuuhei-Okazaki)*
+      4 Yuji Yamano (@yyamano)
+      4 kurodash (@kurodash)*
+      4 masahino (@masahino)
+      4 wanabe (@wanabe)*
+      4 xuejianqing (@joans321)
+      3 Anton Davydov (@davydovanton)
+      3 Carlo Prelz (@asfluido)*
+      3 David Turnbull (@AE9RB)
+      3 Franck Verrot (@franckverrot)
+      3 Horimoto Yasuhiro (@komainu8)
+      3 J. Mutua (@katmutua)+
+      3 Jan Berdajs (@mrbrdo)
+      3 Joseph McCullough (@joequery)
+      3 Mark McCurry (@fundamental)
+      3 Nobuhiro Iwamatsu (@iwamatsu)
+      3 Per Lundberg (@perlun)*
+      3 Rob Fors (@robfors)*
+      3 Rodrigo Malizia (@rmalizia44)+
+      3 Sebastián Katzer (@katzer)*
+      3 Shouji Kuboyama (@Shokuji)*
+      3 Shuta Kimura (@kimushu)+
+      3 TERAJIMA, Motoyuki (@trmmy)
+      3 Takashi Kokubun (@k0kubun)
+      3 Tatsuhiro Tsujikawa (@tatsuhiro-t)
+      3 Thiago Scalone (@scalone)
+      3 Vladimir Dementyev (@palkan)*
+      3 William Light (@wrl)
+      3 bamchoh (@bamchoh)
+      3 sasaki takeru (@takeru)
+      2 Akira Moroo (@retrage)
+      2 Artur K (@nemerle)
+      2 Christian Mauceri (@mauceri)
+      2 Craig Lehmann (@craiglrock)*
+      2 Dominic Sisneros (@dsisnero)*
+      2 Dusan D. Majkic (@dmajkic)
+      2 Emiliano Lesende (@3miliano)
+      2 Francois Chagnon (@EiNSTeiN-)*
+      2 Gilad Zohari (@gzohari)
+      2 Go Saito (@govm)
+      2 HASUMI Hitoshi (@hasumikin)
+      2 Hirohito Higashi (@HirohitoHigashi)
+      2 Hiroyuki Iwatsuki (@iwadon)
+      2 Huei-Horng Yo (@hiroshiyui)
+      2 Jonas Kulla (@Ancurio)
+      2 Jun Takeda (@takjn)
+      2 Kazuaki Tanaka (@kaz0505)
+      2 Kazuhiko Yamashita (@pyama86)+
+      2 Kazuhiro Sera (@seratch)
+      2 Kuroda Daisuke (@dycoon)+
+      2 Lanza (@LanzaSchneider)
+      2 Lothar Scholz (@llothar)
+      2 Lukas Joeressen (@kext)
+      2 Masahiro Wakame (@vvkame)+
+      2 Minao Yamamoto (@tarosay)+
+      2 Nihad Abbasov (@NARKOZ)
+      2 Robert Mosolgo (@rmosolgo)
+      2 Russel Hunter Yukawa (@rhykw)+
+      2 Ryunosuke SATO (@tricknotes)
+      2 Santa Zhang (@santazhang)
+      2 Satoru Naba (@snaba)+
+      2 Serg Podtynnyi (@shtirlic)
+      2 Shannen Saez (@shancat)
+      2 SouthWolf (@southwolf)
+      2 TJ Singleton (@tjsingleton)
+      2 Taiyo Mizuhashi (@taiyoslime)+
+      2 Tomás Pollak (@tomas)*
+      2 Yutaka HARA (@yhara)*+
+      2 Zhang Xiaohui (@hifoolno)
+      2 icm7216 (@icm7216)
+      2 windwiny (@windwiny)
+      1 A-Sat (@asatou)+
+      1 Abinoam Praxedes Marques Junior (@abinoam)
+      1 Alex Wang (@nanamiwang)+
+      1 Andrew Nordman (@cadwallion)
+      1 Atsushi Morimoto (@mynz)
+      1 Ben A Morgan (@BenMorganIO)
+      1 Benoit Daloze (@eregon)
+      1 Chris Reuter (@suetanvil)
+      1 Daehyub Kim (@lateau)
+      1 Daniel Varga (@vargad)
+      1 Edgar Boda-Majer (@eboda)
+      1 Fangrui Song (@MaskRay)
+      1 Flavio Medeiros (@flaviommedeiros)
+      1 Francis Bogsanyi (@fbogsany)
+      1 Guo Xiao (@guoxiao)
+      1 Gwen Boatrite (@boatrit)
+      1 HAYASHI Kentaro (@kenhys)
+      1 Hiroki Mori (@yamori813)+
+      1 Hiromasa Ishii (@Hir0)+
+      1 Hiroyuki Matsuzaki (@Hiroyuki-Matsuzaki)
+      1 Hugo Logmans (@hlogmans)
+      1 Jack Danger Canty (@JackDanger)
+      1 Jeff Federman (@jefffederman)
+      1 Jeffrey Crowell (@crowell)
+      1 Jeremy Ong (@jeremyong)
+      1 Jiro Nishiguchi (@spiritloose)
+      1 Joachim Baran (@indiedotkim)
+      1 Joe Kutner (@jkutner)
+      1 Jun Aruga (@junaruga)
+      1 Junichi Kajiwara (@kjunichi)
+      1 Jurriaan Pruis (@jurriaan)
+      1 Katsuhiko Kageyama (@kishima)+
+      1 Katsuyoshi Ito (@katsuyoshi)
+      1 Kazuhiro NISHIYAMA (@znz)
+      1 Kei Sawada (@remore)
+      1 Kim H Madsen (@kimhmadsen)
+      1 Konstantin Haase (@rkh)
+      1 Leo Neat (@Leo-Neat)
+      1 Lian Cheng (@liancheng)
+      1 Luis Lavena (@luislavena)
+      1 Lukas Elmer (@lukaselmer)
+      1 Lukas Stabe (@Ahti)
+      1 M.Naruoka (@fenrir-naru)
+      1 Mark Delk (@jethrodaniel)
+      1 Martin Bosslet (@emboss)+
+      1 Masahiko Sawada (@MasahikoSawada)
+      1 Matt Aimonetti (@mattetti)
+      1 Maxim Abramchuk (@MaximAbramchuck)
+      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)
+      1 Patrick Ellis (@pje)
+      1 Patrick Pokatilo (@SHyx0rmZ)
+      1 Pavel Evstigneev (@Paxa)+
+      1 Prayag Verma (@pra85)
+      1 Ranmocy (@ranmocy)
+      1 Robert McNally (@wolfmcnally)
+      1 Robert Rowe (@CaptainJet)
+      1 Ryan Scott Lewis (@RyanScottLewis)
+      1 Ryo Okubo (@syucream)
+      1 Santiago Rodriguez (@sanrodari)
+      1 Satoh, Hiroh (@cho45)+
+      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)
+      1 Tom Black (@blacktm)
+      1 Utkarsh Kukreti (@utkarshkukreti)
+      1 W (@graywolf)
+      1 Wuffers Lightwolf (@w-x-l)
+      1 YAMAMOTO Yuji (@igrep)
+      1 Yevhen Viktorov (@yevgenko)
+      1 Yoji SHIDARA (@darashi)
+      1 Yoshiori SHOJI (@yoshiori)
+      1 Yukang (@chenyukang)
+      1 Yurii Nakonechnyi (@inobelar)
+      1 Yusuke Suzuki (@Constellation)+
+      1 Yusuke Tanaka (@csouls)
+      1 arton (@arton)
+      1 duangsuse (@duangsuse)
+      1 fl0l0u (@fl0l0u)
+      1 hhc0null (@hhc0null)
+      1 iTitou (@titouanc)
+      1 javier ramírez (@javier)
+      1 liyuray (@liyuray)
+      1 lucas dicioccio (@lucasdicioccio)
+      1 n4o847 (@n4o847)
+      1 robert (@R-obert)
+      1 sbsoftware (@sbsoftware)
+      1 ssmallkirby (@smallkirby)
+      1 taku toyama (@tsuichu)
+
+`*` - 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
+   Kyushu Bureau of Economy, Trade and Industry
    SCSK KYUSHU CORPORATION
    Kyushu Institute of Technology
    Network Applied Communication Laboratory, Inc.
-   Daniel Bovensiepen
-   Jon Maken
-   Bjorn De Meyer
-   Yuichiro MASUI
-   Masamitsu MURASE
-   Masaki Muranaka
    Internet Initiative Japan Inc.
-   Tadashi FUKUZAWA
-   MATSUMOTO Ryosuke
-   Yasuhiro Matsumoto
-   Koji Yoshioka
-   Jun Hiroe
-   Narihiro Nakamura
-   Yuichi Nishiwaki
-   Tatsuhiko Kubo
-   Takeshi Watanabe
-   Yuki Kurihara
-   specified non-profit corporation mruby Forum
-   Kazuaki Tanaka
-   Hiromasa Ishii
-   Hiroshi Mimaki
-   Satoshi Odawara
+   Specified non-profit organization mruby Forum
    Mitsubishi Electric Micro-Computer Application Software Co.,Ltd.
-   Ralph Desir(Mav7)
-   Hiroyuki Matsuzaki
-   Yuhei Okazaki
    Manycolors, Inc.
-   Shota Nakano
-   Yuichi Osawa
-   Terence Lee
-   Zachary Scott
-   Tomasz Dąbrowski
-   Christopher Aue
-   Masahiro Wakame
-   YAMAMOTO Masaya

CODEOWNERS

@@ -0,0 +1 @@
+*   @matz

CONTRIBUTING.md

@@ -1,6 +1,7 @@
 # How to contribute
 
 mruby is an open-source project which is looking forward to each contribution.
+Contributors agree to license their contribution(s) under MIT license.
 
 ## Your Pull Request
 
@@ -9,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 (```./minirake 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
@@ -17,6 +18,41 @@ 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
+
+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!
+
+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>`
+
+To update use `pre-commit autoupdate`
+
+* [Quick start](https://pre-commit.com/#quick-start)
+* [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.
@@ -31,11 +67,13 @@ C code:
 
 mruby should be highly portable to other systems and compilers. For this it is
 recommended to keep your code as close as possible to the C99 standard
-(http://www.open-std.org/jtc1/sc22/WG14/www/docs/n1256.pdf).
+(<http://www.open-std.org/jtc1/sc22/WG14/www/docs/n1256.pdf>).
 
-Although we target C99, Visual C++ is also an important target for mruby. For
-this reason a declaration of a local variable has to be at the beginning of a
-scope block.
+Visual C++ is also an important target for mruby (supported version is 2013 or
+later). For this reason features that are not supported by Visual C++ may not
+be used (e.g. `%z` of `strftime()`).
+
+NOTE: Old GCC requires `-std=gnu99` option to enable C99 support.
 
 #### Reduce library dependencies to a minimum
 
@@ -43,19 +81,15 @@ The dependencies to libraries should be kept to an absolute minimum. This
 increases the portability but makes it also easier to cut away parts of mruby
 on-demand.
 
-#### Don't use C++ style comments
+#### Insert a break after the function return value:
 
-    /* This is the preferred comment style */
-
-Use C++ style comments only for temporary comment e.g. commenting out some code lines.
-
-#### Insert a break after the method return value:
-
-    int
-    main(void)
-    {
-      ...
-    }
+```c
+int
+main(void)
+{
+  ...
+}
+```
 
 ### Ruby code
 
@@ -65,4 +99,5 @@ language itself. Please note the following hints for your Ruby code:
 #### Comply with the Ruby standard (ISO/IEC 30170:2012)
 
 mruby is currently targeting to execute Ruby code which complies to ISO/IEC
-30170:2012 (http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579).
+30170:2012 (<https://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579>),
+unless there's a clear reason, e.g. the latest Ruby has changed behavior from ISO.

LEGAL

@@ -2,5 +2,4 @@ LEGAL NOTICE INFORMATION
 ------------------------
 
 All the files in this distribution are covered under the MIT license
-(see the file MITL) except some files mentioned below:
-
+(see the file LICENSE) except some files mentioned below:

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018 mruby developers
+Copyright (c) 2010-2021 mruby developers
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),
@@ -17,4 +17,3 @@ 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.
-

Makefile

@@ -1,8 +1,6 @@
-# mruby is using Rake (http://rake.rubyforge.org) as a build tool.
-# We provide a minimalistic version called minirake inside of our
-# codebase.
+# mruby is using Rake (https://ruby.github.io/rake/) as a build tool.
 
-RAKE = ruby ./minirake
+RAKE = rake
 
 all :
 	$(RAKE)

NEWS

@@ -9,5 +9,3 @@ with all sufficient information, see the ChangeLog file.
 
 
 ** Information about first release v1.0.0
-
-

README.md

@@ -1,12 +1,15 @@
+# mruby
+
 [![Build Status][build-status-img]][travis-ci]
+[![GitHub Super-Linter](https://github.com/mruby/mruby/workflows/Lint%20Code%20Base/badge.svg)](https://github.com/marketplace/actions/super-linter)
 
 ## What is mruby
 
 mruby is the lightweight implementation of the Ruby language complying to (part
-of) the [ISO standard][ISO-standard]. Its syntax is Ruby 1.9 compatible.
+of) the [ISO standard][ISO-standard]. Its syntax is Ruby 2.x compatible.
 
 mruby can be linked and embedded within your application.  We provide the
-interpreter program "mruby" and the interactive mruby shell "mirb" as examples.
+interpreter program "mruby", and the interactive mruby shell "mirb" as examples.
 You can also compile Ruby programs into compiled byte code using the mruby
 compiler "mrbc".  All those tools reside in the "bin" directory.  "mrbc" is
 also able to generate compiled byte code in a C source file, see the "mrbtest"
@@ -17,49 +20,58 @@ of the Ministry of Economy, Trade and Industry of Japan.
 
 ## How to get mruby
 
-The stable version 2.0.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/2.0.0.zip](https://github.com/mruby/mruby/archive/2.0.0.zip)
+The release candidate version 3.1.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/3.1.0-rc2.zip](https://github.com/mruby/mruby/archive/3.1.0-rc2.zip)
 
 The latest development version of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/zipball/master](https://github.com/mruby/mruby/zipball/master)
 
 The trunk of the mruby source tree can be checked out with the
 following command:
 
-    $ git clone https://github.com/mruby/mruby.git
+```
+$ git clone https://github.com/mruby/mruby.git
+```
 
 You can also install and compile mruby using [ruby-install](https://github.com/postmodern/ruby-install), [ruby-build](https://github.com/rbenv/ruby-build) or [rvm](https://github.com/rvm/rvm).
 
 ## mruby home-page
 
-The URL of the mruby home-page is: [http://www.mruby.org](http://www.mruby.org).
+The URL of the mruby home-page is: <https://mruby.org>.
 
 ## Mailing list
 
-We don't have a mailing list, but you can use [GitHub issues](https://github.com/mruby/mruby).
+We don't have a mailing list, but you can use [GitHub issues](https://github.com/mruby/mruby/issues).
 
-## How to compile and install (mruby and gems)
+## How to compile, test, and install (mruby and gems)
 
-See the [doc/guides/compile.md](doc/guides/compile.md) file.
+See the [compile.md](doc/guides/compile.md) file.
 
-## Running Tests
+## Building documentation
 
-To run the tests, execute the following from the project's root directory.
+There are two sets of documentation in mruby: the mruby API (generated by yard) and C API (Doxygen)
 
-    $ make test
+To build both of them, simply go
 
-Or
+```
+rake doc
+```
 
-    $ ruby ./minirake test
+You can also view them in your browser
+
+```
+rake view_api
+rake view_capi
+```
 
 ## How to customize mruby (mrbgems)
 
 mruby contains a package manager called *mrbgems*. To create extensions
 in C and/or Ruby you should create a *GEM*. For a documentation of how to
-use mrbgems consult the file [doc/guides/mrbgems.md](doc/guides/mrbgems.md). For example code of
-how to use mrbgems look into the folder *examples/mrbgems/*.
+use mrbgems consult the file [mrbgems.md](doc/guides/mrbgems.md).
+For example code of how to use mrbgems look into the folder *examples/mrbgems/*.
 
 ## License
 
-mruby is released under the [MIT License](MITL).
+mruby is released under the [MIT License](LICENSE).
 
 ## Note for License
 
@@ -73,7 +85,7 @@ In the future, mruby might ask you to distribute your new code
 (that you will commit,) under the MIT License as a member of
 "mruby developers" but contributors will keep their copyright.
 (We did not intend for contributors to transfer or waive their copyrights,
-Actual copyright holder name (contributors) will be listed in the AUTHORS
+actual copyright holder name (contributors) will be listed in the [AUTHORS](AUTHORS)
 file.)
 
 Please ask us if you want to distribute your code under another license.
@@ -81,12 +93,10 @@ Please ask us if you want to distribute your code under another license.
 ## How to Contribute
 
 See the [contribution guidelines][contribution-guidelines], and then send a pull
-request to <http://github.com/mruby/mruby>.  We consider you have granted
-non-exclusive right to your contributed code under MIT license.  If you want to
-be named as one of mruby developers, please include an update to the AUTHORS
-file in your pull request.
+request to <https://github.com/mruby/mruby>.  We consider you have granted
+non-exclusive right to your contributed code under MIT license.
 
-[ISO-standard]: http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579
+[ISO-standard]: https://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579
 [build-status-img]: https://travis-ci.org/mruby/mruby.svg?branch=master
-[contribution-guidelines]: CONTRIBUTING.md
+[contribution-guidelines]: https://github.com/mruby/mruby/blob/master/CONTRIBUTING.md
 [travis-ci]: https://travis-ci.org/mruby/mruby

Rakefile

@@ -5,15 +5,16 @@ MRUBY_ROOT = File.dirname(File.expand_path(__FILE__))
 MRUBY_BUILD_HOST_IS_CYGWIN = RUBY_PLATFORM.include?('cygwin')
 MRUBY_BUILD_HOST_IS_OPENBSD = RUBY_PLATFORM.include?('openbsd')
 
+Rake.verbose(false) if Rake.verbose == Rake::DSL::DEFAULT
+
 $LOAD_PATH << File.join(MRUBY_ROOT, "lib")
 
 # load build systems
-require "mruby-core-ext"
+require "mruby/core_ext"
 require "mruby/build"
-require "mruby/gem"
 
 # load configuration file
-MRUBY_CONFIG = (ENV['MRUBY_CONFIG'] && ENV['MRUBY_CONFIG'] != '') ? ENV['MRUBY_CONFIG'] : "#{MRUBY_ROOT}/build_config.rb"
+MRUBY_CONFIG = MRuby::Build.mruby_config_path
 load MRUBY_CONFIG
 
 # load basic rules
@@ -22,142 +23,47 @@ MRuby.each_target do |build|
 end
 
 # load custom rules
-load "#{MRUBY_ROOT}/src/mruby_core.rake"
-load "#{MRUBY_ROOT}/mrblib/mrblib.rake"
-
+load "#{MRUBY_ROOT}/tasks/core.rake"
+load "#{MRUBY_ROOT}/tasks/mrblib.rake"
 load "#{MRUBY_ROOT}/tasks/mrbgems.rake"
 load "#{MRUBY_ROOT}/tasks/libmruby.rake"
-
+load "#{MRUBY_ROOT}/tasks/bin.rake"
+load "#{MRUBY_ROOT}/tasks/presym.rake"
+load "#{MRUBY_ROOT}/tasks/test.rake"
 load "#{MRUBY_ROOT}/tasks/benchmark.rake"
-
-load "#{MRUBY_ROOT}/tasks/gitlab.rake"
+load "#{MRUBY_ROOT}/tasks/doc.rake"
 
 ##############################
 # generic build targets, rules
 task :default => :all
 
-bin_path = ENV['INSTALL_DIR'] || "#{MRUBY_ROOT}/bin"
-FileUtils.mkdir_p bin_path, { :verbose => $verbose }
-
-depfiles = MRuby.targets['host'].bins.map do |bin|
-  install_path = MRuby.targets['host'].exefile("#{bin_path}/#{bin}")
-  source_path = MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/#{bin}")
-
-  file install_path => source_path do |t|
-    FileUtils.rm_f t.name, { :verbose => $verbose }
-    FileUtils.cp t.prerequisites.first, t.name, { :verbose => $verbose }
-  end
-
-  install_path
-end
-
-MRuby.each_target do |target|
-  gems.map do |gem|
-    current_dir = gem.dir.relative_path_from(Dir.pwd)
-    relative_from_root = gem.dir.relative_path_from(MRUBY_ROOT)
-    current_build_dir = File.expand_path "#{build_dir}/#{relative_from_root}"
-
-    if current_build_dir !~ /^#{build_dir}/
-      current_build_dir = "#{build_dir}/mrbgems/#{gem.name}"
-    end
-
-    gem.bins.each do |bin|
-      exec = exefile("#{build_dir}/bin/#{bin}")
-      objs = Dir.glob("#{current_dir}/tools/#{bin}/*.{c,cpp,cxx,cc}").map { |f| objfile(f.pathmap("#{current_build_dir}/tools/#{bin}/%n")) }
-
-      file exec => objs + target.libraries do |t|
-        gem_flags = gems.map { |g| g.linker.flags }
-        gem_flags_before_libraries = gems.map { |g| g.linker.flags_before_libraries }
-        gem_flags_after_libraries = gems.map { |g| g.linker.flags_after_libraries }
-        gem_libraries = gems.map { |g| g.linker.libraries }
-        gem_library_paths = gems.map { |g| g.linker.library_paths }
-        linker.run t.name, t.prerequisites, gem_libraries, gem_library_paths, gem_flags, gem_flags_before_libraries, gem_flags_after_libraries
-      end
-
-      if target == MRuby.targets['host']
-        install_path = MRuby.targets['host'].exefile("#{bin_path}/#{bin}")
-
-        file install_path => exec do |t|
-          FileUtils.rm_f t.name, { :verbose => $verbose }
-          FileUtils.cp t.prerequisites.first, t.name, { :verbose => $verbose }
-        end
-        depfiles += [ install_path ]
-      elsif target == MRuby.targets['host-debug']
-        unless MRuby.targets['host'].gems.map {|g| g.bins}.include?([bin])
-          install_path = MRuby.targets['host-debug'].exefile("#{bin_path}/#{bin}")
-
-          file install_path => exec do |t|
-            FileUtils.rm_f t.name, { :verbose => $verbose }
-            FileUtils.cp t.prerequisites.first, t.name, { :verbose => $verbose }
-          end
-          depfiles += [ install_path ]
-        end
-      else
-        depfiles += [ exec ]
-      end
-    end
-  end
-end
-
-depfiles += MRuby.targets.map { |n, t|
-  t.libraries
-}.flatten
-
-depfiles += MRuby.targets.reject { |n, t| n == 'host' }.map { |n, t|
-  t.bins.map { |bin| t.exefile("#{t.build_dir}/bin/#{bin}") }
-}.flatten
-
 desc "build all targets, install (locally) in-repo"
-task :all => depfiles do
+task :all => :gensym do
+  Rake::Task[:build].invoke
   puts
   puts "Build summary:"
   puts
-  MRuby.each_target do
-    print_build_summary
+  MRuby.each_target do |build|
+    build.print_build_summary
   end
+  MRuby::Lockfile.write
 end
 
-desc "run all mruby tests"
-MRuby.each_target do
-  next unless test_enabled?
-
-  t = :"test_#{self.name}"
-  task t => ["all"] do
-    run_test
-  end
-  task :test => t
-
-  next unless bintest_enabled?
-  t = :"bintest_#{self.name}"
-  task t => ["all"] do
-    run_bintest
-  end
-  task :test => t
-end
+task :build => MRuby.targets.flat_map{|_, build| build.products}
 
 desc "clean all built and in-repo installed artifacts"
 task :clean do
-  MRuby.each_target do |t|
-    FileUtils.rm_rf t.build_dir, { :verbose => $verbose }
+  MRuby.each_target do |build|
+    rm_rf build.build_dir
+    rm_f build.products
   end
-  FileUtils.rm_f depfiles, { :verbose => $verbose }
   puts "Cleaned up target build folder"
 end
 
 desc "clean everything!"
-task :deep_clean => ["clean"] do
-  MRuby.each_target do |t|
-    FileUtils.rm_rf t.gem_clone_dir, { :verbose => $verbose }
+task :deep_clean => %w[clean doc:clean] do
+  MRuby.each_target do |build|
+    rm_rf build.gem_clone_dir
   end
   puts "Cleaned up mrbgems build folder"
 end
-
-desc 'generate document'
-task :doc do
-  begin
-    sh "mrbdoc"
-  rescue
-    puts "ERROR: To generate documents, you should install yard-mruby gem."
-    puts "  $ gem install yard-mruby"
-  end
-end

SECURITY.md

@@ -0,0 +1,18 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+If you have any security concern, contact <matz@ruby.or.jp>.
+
+## 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

TODO

@@ -1,10 +0,0 @@
-Things to do (Things that are not done yet)
-
-* special variables ($1,$2..)
-* super in aliased methods
-* multi-assignment decomposing
-* keyword arguments in def statement
-
-Things to improve (Done but things to fix)
-
-* Make additions as they are noticed.

TODO.md

@@ -0,0 +1,14 @@
+# Thing to Do in the future
+
+# After mruby 3.1
+
+* multi-precision integer
+* parser and code generator independent from `mrb_state` (picoruby?)
+* variable sized AST node
+* iv/hash entry cache
+* more peephole optimization (if possible)
+
+# Things to do (Things we need to consider)
+
+* `begin ... end while cond` to behave as CRuby
+* special variables ($1,$2..)

appveyor.yml

@@ -1,38 +1,45 @@
 version: "{build}"
 
-os: Visual Studio 2015
-
-clone_depth: 50
-
-
-cache:
-  - win_flex_bison-2.5.10.zip
-
+shallow_clone: true
 
 environment:
   matrix:
-    # Visual Studio 2015 64bit
-    - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
-      machine: amd64
+    - job_name: Visual Studio 2019 64bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat
+      appveyor_build_worker_image: Visual Studio 2019
 
-    # Visual Studio 2013 64bit
-    - visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat
-      machine: amd64
+    - job_name: Visual Studio 2019 32bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars32.bat
+      appveyor_build_worker_image: Visual Studio 2019
 
+    - job_name: Visual Studio 2017 64bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat
+      appveyor_build_worker_image: Visual Studio 2017
+
+    - job_name: Visual Studio 2017 32bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars32.bat
+      appveyor_build_worker_image: Visual Studio 2017
+
+    - job_name: Visual Studio 2015 64bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
+      appveyor_build_worker_image: Visual Studio 2015
+      machine: x86_amd64
+
+    - job_name: Visual Studio 2015 32bit
+      visualcpp: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat
+      appveyor_build_worker_image: Visual Studio 2015
+      machine: x86
 
 init:
   - call "%visualcpp%" %machine%
-  # For using Rubyinstaller's Ruby 2.4 64bit
-  - set PATH=C:\Ruby24-x64\bin;%PATH%
+  # For using RubyInstaller's Ruby 2.6 64bit
+  # 2.6 is the highest supported Ruby version across all historical
+  # Visual Studio AppVeyor images. Ruby 2.7 is only on the 2019 image.
+  - set PATH=C:\Ruby26-x64\bin;%PATH%
   - ruby --version
 
 
-install:
-  - if not exist win_flex_bison-2.5.10.zip appveyor DownloadFile "https://github.com/lexxmark/winflexbison/releases/download/v.2.5.10/win_flex_bison-2.5.10.zip"
-  - 7z x -y -owin_flex_bison win_flex_bison-2.5.10.zip > nul
-
-
 build_script:
-  - set YACC=.\win_flex_bison\win_bison.exe
-  - set MRUBY_CONFIG=appveyor_config.rb
-  - ruby .\minirake test all
+  - set MRUBY_CONFIG=ci/msvc
+  - rake -m test:build
+  - rake test:run

appveyor_config.rb

@@ -1,50 +0,0 @@
-MRuby::Build.new('debug') do |conf|
-  toolchain :visualcpp
-  enable_debug
-
-  # include all core GEMs
-  conf.gembox 'full-core'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_STRESS MRB_GC_FIXED_ARENA MRB_METHOD_CACHE)
-  end
-
-  build_mrbc_exec
-end
-
-MRuby::Build.new('full-debug') do |conf|
-  toolchain :visualcpp
-  enable_debug
-
-  # include all core GEMs
-  conf.gembox 'full-core'
-  conf.cc.defines = %w(MRB_ENABLE_DEBUG_HOOK)
-
-  conf.enable_test
-end
-
-MRuby::Build.new do |conf|
-  toolchain :visualcpp
-
-  # include all core GEMs
-  conf.gembox 'full-core'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_FIXED_ARENA)
-  end
-  conf.enable_bintest
-  conf.enable_test
-end
-
-MRuby::Build.new('cxx_abi') do |conf|
-  toolchain :visualcpp
-
-  conf.gembox 'full-core'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_FIXED_ARENA)
-  end
-  conf.enable_bintest
-  conf.enable_test
-
-  enable_cxx_abi
-
-  build_mrbc_exec
-end

benchmark/bm_ao_render.rb

@@ -1,29 +1,29 @@
 # AO render benchmark
-# Original program (C) Syoyo Fujita in Javascript (and other languages)
+# Original program (C) Syoyo Fujita in JavaScript (and other languages)
 #      https://code.google.com/p/aobench/
 # Ruby(yarv2llvm) version by Hideki Miura
 # mruby version by Hideki Miura
 #
 
-IMAGE_WIDTH = 64
-IMAGE_HEIGHT = 64
+IMAGE_WIDTH = Integer(ARGV[0] || 64)
+IMAGE_HEIGHT = IMAGE_WIDTH
 NSUBSAMPLES = 2
 NAO_SAMPLES = 8
 
 module Rand
   # Use xorshift
-  @@x = 123456789
-  @@y = 362436069
-  @@z = 521288629
-  @@w = 88675123
+  @x = 123456789
+  @y = 362436069
+  @z = 521288629
+  @w = 88675123
   BNUM = 1 << 29
   BNUMF = BNUM.to_f
   def self.rand
-    x = @@x
+    x = @x
     t = x ^ ((x & 0xfffff) << 11)
-    w = @@w
-    @@x, @@y, @@z = @@y, @@z, w
-    w = @@w = (w ^ (w >> 19) ^ (t ^ (t >> 8)))
+    w = @w
+    @x, @y, @z = @y, @z, w
+    w = @w = (w ^ (w >> 19) ^ (t ^ (t >> 8)))
     (w % BNUM) / BNUMF
   end
 end
@@ -260,7 +260,7 @@ class Scene
       w.times do |x|
         rad = Vec.new(0.0, 0.0, 0.0)
 
-        # Subsmpling
+        # Subsampling
         nsubsamples.times do |v|
           nsubsamples.times do |u|
             cnt = cnt + 1

benchmark/bm_app_lc_fizzbuzz.rb

@@ -48,5 +48,4 @@ answer = to_array(solution).map do |p|
   to_string(p)
 end
 
-answer_str = answer.to_a
-# puts answer_str
+# puts answer

benchmark/bm_so_lists.rb

@@ -1,4 +1,4 @@
-#from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
+# from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
 
 NUM = 300
 SIZE = 10000

benchmark/build_config_boxing.rb

@@ -1,28 +0,0 @@
-MRuby::Build.new do |conf|
-  toolchain :gcc
-end
-
-MRuby::Build.new('no_boxing') do |conf|
-  toolchain :gcc
-
-  conf.gembox 'default'
-end
-
-MRuby::Build.new('word_boxing') do |conf|
-  toolchain :gcc
-
-  conf.gembox 'default'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_WORD_BOXING)
-  end
-end
-
-MRuby::Build.new('nan_boxing') do |conf|
-  toolchain :gcc
-
-  conf.gembox 'default'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_NAN_BOXING)
-  end
-end
-

benchmark/build_config_cc.rb

@@ -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

build_config.rb

@@ -1,152 +1,9 @@
-MRuby::Build.new do |conf|
-  # load specific toolchain settings
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  # Turn on `enable_debug` for better debugging
-  # enable_debug
-
-  # Use mrbgems
-  # conf.gem 'examples/mrbgems/ruby_extension_example'
-  # conf.gem 'examples/mrbgems/c_extension_example' do |g|
-  #   g.cc.flags << '-g' # append cflags in this gem
-  # end
-  # conf.gem 'examples/mrbgems/c_and_ruby_extension_example'
-  # conf.gem :core => 'mruby-eval'
-  # conf.gem :mgem => 'mruby-io'
-  # conf.gem :github => 'iij/mruby-io'
-  # conf.gem :git => 'git@github.com:iij/mruby-io.git', :branch => 'master', :options => '-v'
-
-  # include the default GEMs
-  conf.gembox 'default'
-  # C compiler settings
-  # conf.cc do |cc|
-  #   cc.command = ENV['CC'] || 'gcc'
-  #   cc.flags = [ENV['CFLAGS'] || %w()]
-  #   cc.include_paths = ["#{root}/include"]
-  #   cc.defines = %w(DISABLE_GEMS)
-  #   cc.option_include_path = '-I%s'
-  #   cc.option_define = '-D%s'
-  #   cc.compile_options = "%{flags} -MMD -o %{outfile} -c %{infile}"
-  # end
-
-  # mrbc settings
-  # conf.mrbc do |mrbc|
-  #   mrbc.compile_options = "-g -B%{funcname} -o-" # The -g option is required for line numbers
-  # end
-
-  # Linker settings
-  # conf.linker do |linker|
-  #   linker.command = ENV['LD'] || 'gcc'
-  #   linker.flags = [ENV['LDFLAGS'] || []]
-  #   linker.flags_before_libraries = []
-  #   linker.libraries = %w()
-  #   linker.flags_after_libraries = []
-  #   linker.library_paths = []
-  #   linker.option_library = '-l%s'
-  #   linker.option_library_path = '-L%s'
-  #   linker.link_options = "%{flags} -o %{outfile} %{objs} %{libs}"
-  # end
-
-  # Archiver settings
-  # conf.archiver do |archiver|
-  #   archiver.command = ENV['AR'] || 'ar'
-  #   archiver.archive_options = 'rs %{outfile} %{objs}'
-  # end
-
-  # Parser generator settings
-  # conf.yacc do |yacc|
-  #   yacc.command = ENV['YACC'] || 'bison'
-  #   yacc.compile_options = '-o %{outfile} %{infile}'
-  # end
-
-  # gperf settings
-  # conf.gperf do |gperf|
-  #   gperf.command = 'gperf'
-  #   gperf.compile_options = '-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" %{infile} > %{outfile}'
-  # end
-
-  # file extensions
-  # conf.exts do |exts|
-  #   exts.object = '.o'
-  #   exts.executable = '' # '.exe' if Windows
-  #   exts.library = '.a'
-  # end
-
-  # file separetor
-  # conf.file_separator = '/'
-
-  # bintest
-  # conf.enable_bintest
-end
-
-MRuby::Build.new('host-debug') do |conf|
-  # load specific toolchain settings
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-  # C compiler settings
-  conf.cc.defines = %w(MRB_ENABLE_DEBUG_HOOK)
-
-  # Generate mruby debugger command (require mruby-eval)
-  conf.gem :core => "mruby-bin-debugger"
-
-  # bintest
-  # conf.enable_bintest
-end
-
-MRuby::Build.new('test') do |conf|
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-  conf.enable_bintest
-  conf.enable_test
-
-  conf.gembox 'default'
-end
-
-#MRuby::Build.new('bench') do |conf|
-#  # Gets set by the VS command prompts.
-#  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-#    toolchain :visualcpp
-#  else
-#    toolchain :gcc
-#    conf.cc.flags << '-O3'
-#  end
+# The default build configuration file was moved to `build_config/default.rb`.
 #
-#  conf.gembox 'default'
-#end
-
-# Define cross build settings
-# MRuby::CrossBuild.new('32bit') do |conf|
-#   toolchain :gcc
-#
-#   conf.cc.flags << "-m32"
-#   conf.linker.flags << "-m32"
-#
-#   conf.build_mrbtest_lib_only
-#
-#   conf.gem 'examples/mrbgems/c_and_ruby_extension_example'
-#
-#   conf.test_runner.command = 'env'
-# end
+# Recommended way to customize the build configuration is:
+#  * copy `default.rb` (or any config file) to a new file (e.g. `myconfig.rb`)
+#  * edit `myconfig.rb`.
+#  * `rake MRUBY_CONFIG=/path/to/myconfig.rb` to compile and test.
+#  * or `rake MRUBY_CONFIG=myconfig` if your configuration file is in the `build_config` directory.
+#  * (optional) submit your configuration as a pull-request if it's useful for others
+raise "The default configuration was moved to `build_config/default.rb`"

build_config/ArduinoDue.rb

@@ -1,21 +1,5 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-end
-
 # Cross Compiling configuration for Arduino Due
-# http://arduino.cc/en/Main/ArduinoBoardDue
+# https://arduino.cc/en/Main/ArduinoBoardDue
 #
 # Requires Arduino IDE >= 1.5
 MRuby::CrossBuild.new("ArduinoDue") do |conf|
@@ -27,7 +11,7 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|
   # ARDUINO_PATH = '/Applications/Arduino.app/Contents/Java'
   # GNU Linux
   ARDUINO_PATH = '/opt/arduino'
-   # Arduino IDE <= 1.5.6
+  # Arduino IDE <= 1.5.6
   BIN_PATH = "#{ARDUINO_PATH}/hardware/tools/g++_arm_none_eabi/bin"
   # Arduino IDE >= 1.5.7
   # BIN_PATH = "#{ARDUINO_PATH}/hardware/tools/gcc-arm-none-eabi-4.8.3-2014q1/bin"
@@ -42,14 +26,13 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|
     cc.flags = %w(-g -Os -w -ffunction-sections -fdata-sections -nostdlib --param max-inline-insns-single=500
                 -Dprintf=iprintf -mcpu=cortex-m3 -DF_CPU=84000000L -DARDUINO=156 -DARDUINO_SAM_DUE -DARDUINO_ARCH_SAM
                 -D__SAM3X8E__ -mthumb -DUSB_PID=0x003e -DUSB_VID=0x2341 -DUSBCON -DUSB_MANUFACTURER="Unknown" -DUSB_PRODUCT="Arduino Due")
-    cc.compile_options = "%{flags} -o %{outfile} -c %{infile}"
+    cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
 
     #configuration for low memory environment
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
     cc.defines << %w(KHASH_DEFAULT_SIZE=8)
-    cc.defines << %w(MRB_STR_BUF_MIN_SIZE=20)
     cc.defines << %w(MRB_GC_STRESS)
-    #cc.defines << %w(MRB_DISABLE_STDIO) #if you dont need stdio.
+    #cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
     #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
   end
 
@@ -64,7 +47,7 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|
 
   conf.archiver do |archiver|
     archiver.command = "#{BIN_PATH}/arm-none-eabi-ar"
-    archiver.archive_options = 'rcs %{outfile} %{objs}'
+    archiver.archive_options = 'rcs "%{outfile}" %{objs}'
   end
 
   #no executables

build_config/IntelEdison.rb

@@ -5,7 +5,7 @@
 MRuby::Build.new do |conf|
   toolchain :gcc
   conf.gembox 'default'
-  conf.cc.defines = %w(ENABLE_READLINE)
+  conf.cc.defines = %w(MRB_USE_READLINE)
   conf.gembox 'default'
 
   #lightweight regular expression
@@ -21,7 +21,7 @@ MRuby::CrossBuild.new('core2-32-poky-linux') do |conf|
   #
   POKY_EDISON_PATH = '/opt/poky-edison/1.7.2'
 
-  POKY_EDISON_SYSROOT =  "#{POKY_EDISON_PATH}/sysroots/core2-32-poky-linux"
+  POKY_EDISON_SYSROOT  = "#{POKY_EDISON_PATH}/sysroots/core2-32-poky-linux"
   POKY_EDISON_X86_PATH = "#{POKY_EDISON_PATH}/sysroots/i386-pokysdk-darwin"
   POKY_EDISON_BIN_PATH = "#{POKY_EDISON_X86_PATH}/usr/bin/i586-poky-linux"
 
@@ -32,8 +32,8 @@ MRuby::CrossBuild.new('core2-32-poky-linux') do |conf|
     cc.flags = %w(-m32 -march=core2 -mtune=core2 -msse3 -mfpmath=sse -mstackrealign -fno-omit-frame-pointer)
     cc.flags << %w(-O2 -pipe -g -feliminate-unused-debug-types)
     cc.flags << "--sysroot=#{POKY_EDISON_SYSROOT}"
-    cc.compile_options = "%{flags} -o %{outfile} -c %{infile}"
-    cc.defines = %w(ENABLE_READLINE)
+    cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
+    cc.defines = %w(MRB_USE_READLINE)
   end
 
   conf.cxx do |cxx|
@@ -47,7 +47,7 @@ MRuby::CrossBuild.new('core2-32-poky-linux') do |conf|
 
   conf.archiver do |archiver|
     archiver.command = "#{POKY_EDISON_BIN_PATH}/i586-poky-linux-ar"
-    archiver.archive_options = 'rcs %{outfile} %{objs}'
+    archiver.archive_options = 'rcs "%{outfile}" %{objs}'
   end
 
   conf.linker do |linker|

build_config/IntelGalileo.rb

@@ -1,22 +1,5 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-end
-
-
 # Cross Compiling configuration for Intel Galileo on Arduino environment
-# http://arduino.cc/en/ArduinoCertified/IntelGalileo
+# https://arduino.cc/en/ArduinoCertified/IntelGalileo
 #
 # Requires Arduino IDE for Intel Galileo
 MRuby::CrossBuild.new("Galileo") do |conf|
@@ -39,7 +22,7 @@ MRuby::CrossBuild.new("Galileo") do |conf|
     cc.flags = %w(-m32 -march=i586 -c -g -Os -w
               -ffunction-sections -fdata-sections -MMD -DARDUINO=153)
     cc.flags << "--sysroot=#{GALILEO_SYSROOT}"
-    cc.compile_options = "%{flags} -o %{outfile} -c %{infile}"
+    cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
   end
 
   conf.cxx do |cxx|
@@ -54,7 +37,7 @@ MRuby::CrossBuild.new("Galileo") do |conf|
 
   conf.archiver do |archiver|
     archiver.command = "#{GALILEO_BIN_PATH}/i586-poky-linux-uclibc-ar"
-    archiver.archive_options = 'rcs %{outfile} %{objs}'
+    archiver.archive_options = 'rcs "%{outfile}" %{objs}'
   end
 
   conf.linker do |linker|
@@ -91,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

build_config/RX630.rb

@@ -1,19 +1,3 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-end
-
 # Cross Compiling configuration for RX630
 # http://gadget.renesas.com/
 #
@@ -27,15 +11,14 @@ MRuby::CrossBuild.new("RX630") do |conf|
   conf.cc do |cc|
     cc.command = "#{BIN_PATH}/rx-elf-gcc"
     cc.flags = "-Wall -g -O2 -flto -mcpu=rx600 -m64bit-doubles"
-    cc.compile_options = "%{flags} -o %{outfile} -c %{infile}"
+    cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
 
     #configuration for low memory environment
-    cc.defines << %w(MRB_USE_FLOAT)
+    cc.defines << %w(MRB_USE_FLOAT32)
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
     cc.defines << %w(KHASH_DEFAULT_SIZE=8)
-    cc.defines << %w(MRB_STR_BUF_MIN_SIZE=20)
     cc.defines << %w(MRB_GC_STRESS)
-    cc.defines << %w(MRB_DISABLE_STDIO) #if you dont need stdio.
+    cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
     #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
   end
 
@@ -53,7 +36,7 @@ MRuby::CrossBuild.new("RX630") do |conf|
 
   conf.archiver do |archiver|
     archiver.command = "#{BIN_PATH}/rx-elf-ar"
-    archiver.archive_options = 'rcs %{outfile} %{objs}'
+    archiver.archive_options = 'rcs "%{outfile}" %{objs}'
   end
 
   #no executables

build_config/android_arm64_v8a.rb

@@ -0,0 +1,11 @@
+# Requires Android NDK r13 or later.
+MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
+  params = {
+    :arch => 'arm64-v8a',
+    :platform => 'android-24',
+    :toolchain => :clang,
+  }
+  toolchain :android, params
+
+  conf.gembox 'default'
+end

build_config/android_armeabi.rb

@@ -0,0 +1,11 @@
+# Requires Android NDK r13 or later.
+MRuby::CrossBuild.new('android-armeabi') do |conf|
+  params = {
+    :arch => 'armeabi',
+    :platform => 'android-24',
+    :toolchain => :clang,
+  }
+  toolchain :android, params
+
+  conf.gembox 'default'
+end

build_config/android_armeabi_v7a_neon_hard.rb

@@ -1,18 +1,3 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-end
-
 # Requires Android NDK r13 or later.
 MRuby::CrossBuild.new('android-armeabi-v7a-neon-hard') do |conf|
   params = {

build_config/bench.rb

@@ -0,0 +1,11 @@
+MRuby::Build.new('bench') do |conf|
+  # Gets set by the VS command prompts.
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+    conf.cc.flags << '-O3'
+  end
+
+  conf.gembox 'default'
+end

build_config/boxing.rb

@@ -0,0 +1,19 @@
+boxings = %w[no word nan]
+bits = [64, 32]
+ints = [64, 32]
+
+boxings.product(bits, ints) do |boxing, bit, int|
+  MRuby::Build.new("boxing-#{boxing}-m#{bit}-i#{int}") do |conf|
+    conf.toolchain :gcc
+    conf.gembox 'default'
+    conf.compilers.each do |c|
+      c.defines << "MRB_#{boxing.upcase}_BOXING"
+      c.defines << "MRB_INT#{int}"
+      c.flags << "-m#{bit}"
+    end
+    conf.linker.flags << "-m#{bit}"
+    conf.enable_debug
+    conf.enable_test
+    conf.enable_bintest
+  end
+end

build_config/chipKITMax32.rb

@@ -1,21 +1,5 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-end
-
 # Cross Compiling configuration for Digilent chipKIT Max32
-# http://www.digilentinc.com/Products/Detail.cfm?Prod=CHIPKIT-MAX32
+# https://www.digilentinc.com/Products/Detail.cfm?Prod=CHIPKIT-MAX32
 #
 # Requires MPIDE (https://github.com/chipKIT32/chipKIT32-MAX)
 #
@@ -39,14 +23,13 @@ MRuby::CrossBuild.new("chipKITMax32") do |conf|
     cc.flags = %w(-O2 -mno-smart-io -w -ffunction-sections -fdata-sections -g -mdebugger -Wcast-align
                 -fno-short-double -mprocessor=32MX795F512L -DF_CPU=80000000L -DARDUINO=23 -D_BOARD_MEGA_
                 -DMPIDEVER=0x01000202 -DMPIDE=23)
-    cc.compile_options = "%{flags} -o %{outfile} -c %{infile}"
+    cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
 
     #configuration for low memory environment
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
     cc.defines << %w(KHASH_DEFAULT_SIZE=8)
-    cc.defines << %w(MRB_STR_BUF_MIN_SIZE=20)
     cc.defines << %w(MRB_GC_STRESS)
-    #cc.defines << %w(MRB_DISABLE_STDIO) #if you dont need stdio.
+    #cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
     #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
   end
 
@@ -60,7 +43,7 @@ MRuby::CrossBuild.new("chipKITMax32") do |conf|
 
   conf.archiver do |archiver|
     archiver.command = "#{PIC32_PATH}/compiler/pic32-tools/bin/pic32-ar"
-    archiver.archive_options = 'rcs %{outfile} %{objs}'
+    archiver.archive_options = 'rcs "%{outfile}" %{objs}'
   end
 
   #no executables

build_config/ci/gcc-clang.rb

@@ -0,0 +1,40 @@
+STDOUT.sync = STDERR.sync = true unless Rake.application.options.always_multitask
+
+MRuby::Build.new('full-debug') do |conf|
+  conf.toolchain
+  conf.enable_debug
+
+  # include all core GEMs
+  conf.gembox 'full-core'
+  conf.cc.defines += %w(MRB_GC_STRESS MRB_USE_DEBUG_HOOK MRB_UTF8_STRING)
+
+  conf.enable_test
+end
+
+MRuby::Build.new do |conf|
+  conf.toolchain
+
+  # include all core GEMs
+  conf.gembox 'full-core'
+  conf.gem :core => 'mruby-bin-debugger'
+  conf.compilers.each do |c|
+    c.defines += %w(MRB_GC_FIXED_ARENA MRB_UTF8_STRING)
+  end
+  conf.enable_bintest
+  conf.enable_test
+end
+
+MRuby::Build.new('cxx_abi') do |conf|
+  conf.toolchain
+
+  conf.gembox 'full-core'
+  conf.cc.flags += %w(-fpermissive -std=gnu++03)
+  conf.compilers.each do |c|
+    c.defines += %w(MRB_GC_FIXED_ARENA MRB_UTF8_STRING)
+  end
+  conf.enable_test
+
+  conf.enable_cxx_abi
+
+  conf.build_mrbc_exec
+end

build_config/ci/msvc.rb

@@ -0,0 +1,20 @@
+STDOUT.sync = STDERR.sync = true unless Rake.application.options.always_multitask
+
+def setup_option(conf)
+  conf.cc.compile_options.sub!(%r{/Zi }, "") unless ENV['CFLAGS']
+  conf.cxx.compile_options.sub!(%r{/Zi }, "") unless ENV['CFLAGS'] || ENV['CXXFLAGS']
+  conf.linker.flags << "/DEBUG:NONE" unless ENV['LDFLAGS']
+end
+
+MRuby::Build.new do |conf|
+  conf.toolchain :visualcpp
+
+  # include all core GEMs
+  conf.gembox 'full-core'
+  conf.compilers.each do |c|
+    c.defines += %w(MRB_GC_FIXED_ARENA)
+  end
+  setup_option(conf)
+  conf.enable_bintest
+  conf.enable_test
+end

build_config/clang-asan.rb

@@ -0,0 +1,11 @@
+MRuby::Build.new do |conf|
+  conf.toolchain :clang
+  # include the GEM box
+  conf.gembox 'full-core'
+
+  # Turn on `enable_debug` for better debugging
+  conf.enable_sanitizer "address,undefined"
+  conf.enable_debug
+  conf.enable_bintest
+  conf.enable_test
+end

build_config/cross-32bit.rb

@@ -0,0 +1,14 @@
+# Define cross build settings
+MRuby::CrossBuild.new('cross-32bit') do |conf|
+  conf.toolchain :gcc
+
+  conf.cc.flags << "-m32"
+  conf.linker.flags << "-m32"
+
+  # conf.build_mrbtest_lib_only
+
+  conf.gem :core => "mruby-bin-mruby"
+  conf.gem "#{MRUBY_ROOT}/examples/mrbgems/c_and_ruby_extension_example"
+
+  conf.test_runner.command = 'env'
+end

build_config/cross-mingw-winetest.rb

@@ -0,0 +1,91 @@
+
+# Cross-compile using MinGW and test using Wine.
+#
+# Steps:
+#
+#   1. Install MinGW; 64-bit target seems to work best.
+#
+#   2. Install Wine.
+#
+#   3. Run command:
+#
+#           wine cmd /c echo "Hello world"'
+#
+#      This will confirm that Wine works and will trigger standard
+#      Wine setup, which is slow.
+#
+#   4. Confirm that drive 'z:' is mapped to your root filesystem.
+#      (This is supposed to be a default but it helps to
+#      double-check.)  To confirm, run:
+#
+#           wine cmd /c dir 'z:\\'
+#
+#      This should give you a DOS-style equivalent of 'ls /'.  If not,
+#      you'll need to fix that with winecfg or by adding a symlink to
+#      '~/.wine/dosdevices'.
+#
+#   5. You will likely need to tweak the settings below to work with
+#      your configuration unless it is exactly like one of the platforms
+#      I've tested on (Ubuntu 20.04 or macOS using brew.)
+#
+#   6. Run the build command:
+#
+#           MRUBY_CONFIG=build_config/cross-mingw-winetest.rb rake test
+#
+#      If all goes well, you should now have Windows executables and a
+#      set of passing tests.
+#
+#
+#  Caveats:
+#
+#    1. This works by using a helper script that rewrites test output
+#       to make it look *nix-like and then handing it back to the test
+#       cases.  Some of the existing tests were (slightly) modified to
+#       make this easier but only for the 'full-core' gembox.  Other
+#       gems' bintests may or may not work with the helper script and
+#       may or may not be fixable by extending the script.
+#
+#   2.  MinGW and Wine are both complex and not very consistent so you
+#       will likely need to do some fiddling to get things to work.
+#
+#   3.  This script assumes you are running it on a *nix-style OS.
+#
+#   4.  I recommend building 64-bit targets only.  Building a 32-bit
+#       Windows binary with i686-w64-mingw32 seems to work (at least,
+#       it did for me) but the resulting executable failed a number of
+#       unit tests due to small errors in some floating point
+#       operations.  It's unclear if this indicates more serious problems.
+#
+
+
+MRuby::CrossBuild.new("cross-mingw-winetest") do |conf|
+  conf.toolchain :gcc
+
+  conf.host_target = "x86_64-w64-mingw32"
+
+  # Ubuntu 20
+  conf.cc.command = "#{conf.host_target}-gcc-posix"
+
+  # macOS+Wine from brew
+  #conf.cc.command = "#{conf.host_target}-gcc"
+
+  conf.linker.command = conf.cc.command
+  conf.archiver.command = "#{conf.host_target}-gcc-ar"
+  conf.exts.executable = ".exe"
+
+  # By default, we compile as static as possible to remove runtime
+  # MinGW dependencies; they are probably fixable but it gets
+  # complicated.
+  conf.cc.flags = ['-static']
+  conf.linker.flags += ['-static']
+
+  conf.test_runner do |t|
+    thisdir = File.absolute_path( File.dirname(__FILE__) )
+    t.command = File.join(thisdir, * %w{ helpers wine_runner.rb})
+  end
+
+  conf.gembox "full-core"
+
+  conf.enable_bintest
+  conf.enable_test
+end

build_config/cross-mingw.rb

@@ -0,0 +1,14 @@
+#
+# Ubuntu 20.04 requires at least `gcc-mingw-w64-x86-64` package as a
+# cross compiler.
+#
+
+MRuby::CrossBuild.new("cross-mingw") do |conf|
+  conf.toolchain :gcc
+  conf.host_target = "x86_64-w64-mingw32"  # required for `for_windows?` used by `mruby-socket` gem
+  conf.cc.command = "#{conf.host_target}-gcc-posix"
+  conf.linker.command = conf.cc.command
+  conf.archiver.command = "#{conf.host_target}-gcc-ar"
+  conf.exts.executable = ".exe"
+  conf.gembox "default"
+end

build_config/default.rb

@@ -0,0 +1,80 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  conf.toolchain
+
+  # Use mrbgems
+  # conf.gem 'examples/mrbgems/ruby_extension_example'
+  # conf.gem 'examples/mrbgems/c_extension_example' do |g|
+  #   g.cc.flags << '-g' # append cflags in this gem
+  # end
+  # conf.gem 'examples/mrbgems/c_and_ruby_extension_example'
+  # conf.gem :core => 'mruby-eval'
+  # conf.gem :mgem => 'mruby-onig-regexp'
+  # conf.gem :github => 'mattn/mruby-onig-regexp'
+  # conf.gem :git => 'git@github.com:mattn/mruby-onig-regexp.git', :branch => 'master', :options => '-v'
+
+  # include the GEM box
+  conf.gembox 'default'
+
+  # C compiler settings
+  # conf.cc do |cc|
+  #   cc.command = ENV['CC'] || 'gcc'
+  #   cc.flags = [ENV['CFLAGS'] || %w()]
+  #   cc.include_paths = ["#{root}/include"]
+  #   cc.defines = %w()
+  #   cc.option_include_path = %q[-I"%s"]
+  #   cc.option_define = '-D%s'
+  #   cc.compile_options = %Q[%{flags} -MMD -o "%{outfile}" -c "%{infile}"]
+  # end
+
+  # mrbc settings
+  # conf.mrbc do |mrbc|
+  #   mrbc.compile_options = "-g -B%{funcname} -o-" # The -g option is required for line numbers
+  # end
+
+  # Linker settings
+  # conf.linker do |linker|
+  #   linker.command = ENV['LD'] || 'gcc'
+  #   linker.flags = [ENV['LDFLAGS'] || []]
+  #   linker.flags_before_libraries = []
+  #   linker.libraries = %w()
+  #   linker.flags_after_libraries = []
+  #   linker.library_paths = []
+  #   linker.option_library = '-l%s'
+  #   linker.option_library_path = '-L%s'
+  #   linker.link_options = %Q[%{flags} -o "%{outfile}" %{objs} %{libs}]
+  # end
+
+  # Archiver settings
+  # conf.archiver do |archiver|
+  #   archiver.command = ENV['AR'] || 'ar'
+  #   archiver.archive_options = 'rs "%{outfile}" %{objs}'
+  # end
+
+  # Parser generator settings
+  # conf.yacc do |yacc|
+  #   yacc.command = ENV['YACC'] || 'bison'
+  #   yacc.compile_options = %q[-o "%{outfile}" "%{infile}"]
+  # end
+
+  # gperf settings
+  # conf.gperf do |gperf|
+  #   gperf.command = 'gperf'
+  #   gperf.compile_options = %q[-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" "%{infile}" > "%{outfile}"]
+  # end
+
+  # file extensions
+  # conf.exts do |exts|
+  #   exts.object = '.o'
+  #   exts.executable = '' # '.exe' if Windows
+  #   exts.library = '.a'
+  # end
+
+  # file separator
+  # conf.file_separator = '/'
+
+  # Turn on `enable_debug` for better debugging
+  # conf.enable_debug
+  conf.enable_bintest
+  conf.enable_test
+end

build_config/dreamcast_shelf.rb

@@ -0,0 +1,117 @@
+# Cross Compiling configuration for the Sega Dreamcast
+# https://dreamcast.wiki/Using_Ruby_for_Sega_Dreamcast_development
+#
+# Requires KallistiOS (KOS)
+# http://gamedev.allusion.net/softprj/kos/
+#
+# Tested on GNU/Linux, macOS and Windows (through MinGW-w64/MSYS2, Cygwin and DreamSDK).
+# DreamSDK is based on MinGW/MSYS: https://dreamsdk.org/
+#
+# Input this command on the directory where mruby is installed:
+#   make MRUBY_CONFIG=dreamcast_shelf
+#
+MRuby::CrossBuild.new("dreamcast") do |conf|
+  toolchain :gcc
+
+  # Support for DreamSDK (based on MinGW/MSYS)
+  # To compile mruby with DreamSDK, RubyInstaller for Windows should be installed
+  DREAMSDK_HOME = ENV["DREAMSDK_HOME"]
+  MSYS_ROOT = !(DREAMSDK_HOME.nil? || DREAMSDK_HOME.empty?) ? "#{DREAMSDK_HOME}/msys/1.0" : ""
+
+  # Setting paths
+  DREAMCAST_PATH = "#{MSYS_ROOT}/opt/toolchains/dc"
+  KOS_PATH = "#{DREAMCAST_PATH}/kos"
+  BIN_PATH = "#{DREAMCAST_PATH}/sh-elf/bin"
+
+  # C compiler
+  # Flags were extracted from KallistiOS environment files
+  conf.cc do |cc|
+    cc.command = "#{BIN_PATH}/sh-elf-gcc"
+    cc.include_paths << ["#{KOS_PATH}/include", "#{KOS_PATH}/kernel/arch/dreamcast/include", "#{KOS_PATH}/addons/include", "#{KOS_PATH}/../kos-ports/include"]
+    cc.flags << ["-O2", "-fomit-frame-pointer", "-ml", "-m4-single-only", "-ffunction-sections", "-fdata-sections", "-Wall", "-g", "-fno-builtin", "-ml", "-m4-single-only", "-Wl,-Ttext=0x8c010000", "-Wl,--gc-sections", "-T#{KOS_PATH}/utils/ldscripts/shlelf.xc", "-nodefaultlibs"]
+    cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
+    cc.defines << %w(_arch_dreamcast)
+    cc.defines << %w(_arch_sub_pristine)
+  end
+
+  # C++ compiler
+  conf.cxx do |cxx|
+    cxx.command = conf.cc.command.dup
+    cxx.include_paths = conf.cc.include_paths.dup
+    cxx.flags = conf.cc.flags.dup
+    cxx.flags << %w(-fno-rtti -fno-exceptions)
+    cxx.defines = conf.cc.defines.dup
+    cxx.compile_options = conf.cc.compile_options.dup
+  end
+
+  # Linker
+  # There is an issue when making the mruby library with KallistiOS:
+  # 'newlib_kill.o' and 'newlib_getpid.o' aren't found so they are explicitly
+  # specified here at least for now.
+  conf.linker do |linker|
+    linker.command="#{BIN_PATH}/sh-elf-gcc"
+    linker.flags << ["#{MSYS_ROOT}/opt/toolchains/dc/kos/kernel/build/newlib_kill.o", "#{MSYS_ROOT}/opt/toolchains/dc/kos/kernel/build/newlib_getpid.o", "-Wl,--start-group -lkallisti -lc -lgcc -Wl,--end-group"]
+    linker.library_paths << ["#{KOS_PATH}/lib/dreamcast", "#{KOS_PATH}/addons/lib/dreamcast", "#{KOS_PATH}/../kos-ports/lib"]
+  end
+
+  # Archiver
+  conf.archiver do |archiver|
+    archiver.command = "#{BIN_PATH}/sh-elf-ar"
+    archiver.archive_options = 'rcs "%{outfile}" %{objs}'
+  end
+
+  # No executables
+  conf.bins = []
+
+  # Do not build executable test
+  conf.build_mrbtest_lib_only
+
+  # Disable C++ exception
+  conf.disable_cxx_exception
+
+  # Gems from core
+  # Some Gems are incompatible and were disabled.
+
+  conf.gem :core => "mruby-array-ext"
+  conf.gem :core => "mruby-binding"
+  conf.gem :core => "mruby-catch"
+  conf.gem :core => "mruby-class-ext"
+  conf.gem :core => "mruby-cmath"
+  conf.gem :core => "mruby-compar-ext"
+  conf.gem :core => "mruby-compiler"
+  conf.gem :core => "mruby-complex"
+  conf.gem :core => "mruby-enum-chain"
+  conf.gem :core => "mruby-enum-ext"
+  conf.gem :core => "mruby-enum-lazy"
+  conf.gem :core => "mruby-enumerator"
+  conf.gem :core => "mruby-error"
+  conf.gem :core => "mruby-eval"
+  conf.gem :core => "mruby-exit"
+  conf.gem :core => "mruby-fiber"
+  conf.gem :core => "mruby-hash-ext"
+#  conf.gem :core => "mruby-io"
+  conf.gem :core => "mruby-kernel-ext"
+  conf.gem :core => "mruby-math"
+  conf.gem :core => "mruby-metaprog"
+  conf.gem :core => "mruby-method"
+  conf.gem :core => "mruby-numeric-ext"
+  conf.gem :core => "mruby-object-ext"
+  conf.gem :core => "mruby-objectspace"
+  conf.gem :core => "mruby-os-memsize"
+  conf.gem :core => "mruby-pack"
+  conf.gem :core => "mruby-print"
+  conf.gem :core => "mruby-proc-binding"
+  conf.gem :core => "mruby-proc-ext"
+  conf.gem :core => "mruby-random"
+  conf.gem :core => "mruby-range-ext"
+  conf.gem :core => "mruby-rational"
+  conf.gem :core => "mruby-sleep"
+#  conf.gem :core => "mruby-socket"
+  conf.gem :core => "mruby-sprintf"
+  conf.gem :core => "mruby-string-ext"
+  conf.gem :core => "mruby-struct"
+  conf.gem :core => "mruby-symbol-ext"
+#  conf.gem :core => "mruby-test"
+#  conf.gem :core => "mruby-time"
+  conf.gem :core => "mruby-toplevel-ext"
+end

build_config/gameboyadvance.rb

@@ -0,0 +1,73 @@
+# Cross Compiling configuration for the Nintendo GameBoyAdvance.
+# This configuration requires devkitARM
+# https://devkitpro.org/wiki/Getting_Started/devkitARM
+#
+# Tested only on GNU/Linux
+#
+MRuby::CrossBuild.new("gameboyadvance") do |conf|
+  toolchain :gcc
+
+  DEVKITPRO_PATH = "/opt/devkitpro"
+  BIN_PATH = "#{DEVKITPRO_PATH}/devkitARM/bin"
+
+  # C compiler
+  conf.cc do |cc|
+    cc.command = "#{BIN_PATH}/arm-none-eabi-gcc"
+    cc.flags << ["-mthumb-interwork", "-mthumb", "-O2"]
+    cc.compile_options = %(%{flags} -o "%{outfile}" -c "%{infile}")
+  end
+
+  # C++ compiler
+  conf.cxx do |cxx|
+    cxx.command = "#{BIN_PATH}/arm-none-eabi-g++"
+    cxx.include_paths = conf.cc.include_paths.dup
+    cxx.flags = conf.cc.flags.dup
+    cxx.flags << %w[-fno-rtti -fno-exceptions]
+    cxx.defines = conf.cc.defines.dup
+    cxx.compile_options = conf.cc.compile_options.dup
+  end
+
+  # Linker
+  conf.linker do |linker|
+    linker.command = "#{BIN_PATH}/arm-none-eabi-gcc"
+    linker.flags << ["-mthumb-interwork", "-mthumb", "-specs=gba.specs"]
+  end
+
+  # No executables
+  conf.bins = []
+
+  # Do not build executable test
+  conf.build_mrbtest_lib_only
+
+  # Disable C++ exception
+  conf.disable_cxx_exception
+
+  # Gems from core
+  # removing mruby-io
+  conf.gem core: "mruby-metaprog"
+  conf.gem core: "mruby-pack"
+  conf.gem core: "mruby-sprintf"
+  conf.gem core: "mruby-print"
+  conf.gem core: "mruby-math"
+  conf.gem core: "mruby-time"
+  conf.gem core: "mruby-struct"
+  conf.gem core: "mruby-compar-ext"
+  conf.gem core: "mruby-enum-ext"
+  conf.gem core: "mruby-string-ext"
+  conf.gem core: "mruby-numeric-ext"
+  conf.gem core: "mruby-array-ext"
+  conf.gem core: "mruby-hash-ext"
+  conf.gem core: "mruby-range-ext"
+  conf.gem core: "mruby-proc-ext"
+  conf.gem core: "mruby-symbol-ext"
+  conf.gem core: "mruby-random"
+  conf.gem core: "mruby-object-ext"
+  conf.gem core: "mruby-objectspace"
+  conf.gem core: "mruby-fiber"
+  conf.gem core: "mruby-enumerator"
+  conf.gem core: "mruby-enum-lazy"
+  conf.gem core: "mruby-toplevel-ext"
+  conf.gem core: "mruby-kernel-ext"
+  conf.gem core: "mruby-class-ext"
+  conf.gem core: "mruby-compiler"
+end

build_config/helpers/wine_runner.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+# Wrapper for running tests for cross-compiled Windows builds in Wine.
+
+require 'open3'
+
+DOSROOT = 'z:'
+
+# Rewrite test output to replace DOS-isms with Unix-isms.
+def clean(output, stderr = false)
+  ends_with_newline = !!(output =~ /\n$/)
+  executable = ARGV[0].gsub(/\.exe\z/i, '')
+
+  # Fix line-ends
+  output = output.gsub(/\r\n/, "\n")
+
+  # Strip out Wine messages
+
+
+  results = output.split(/\n/).map do |line|
+    # Fix file paths
+    if line =~ /#{DOSROOT}\\/i
+      line.gsub!(/#{DOSROOT}([^:]*)/i) { |path|
+        path.gsub!(/^#{DOSROOT}/i, '')
+        path.gsub!(%r{\\}, '/')
+        path
+      }
+    end
+
+    # strip '.exe' off the end of the executable's name if needed
+    line.gsub!(/(#{Regexp.escape executable})\.exe/i, '\1')
+
+    line
+  end
+
+  result_text = results.join("\n")
+  result_text += "\n" if ends_with_newline
+  return result_text
+end
+
+
+def main
+  if ARGV.empty? || ARGV[0] =~ /^- (-?) (\?|help|h) $/x
+    puts "#{$0} <command-line>"
+    exit 0
+  end
+
+  # For simplicity, just read all of stdin into memory and pass that
+  # as an argument when invoking wine.  (Skipped if STDIN was not
+  # redirected.)
+  if !STDIN.tty?
+    input = STDIN.read
+  else
+    input = ""
+  end
+
+  # Disable all Wine messages so they don't interfere with the output
+  ENV['WINEDEBUG'] = 'err-all,warn-all,fixme-all,trace-all'
+
+  # Run the program in wine and capture the output
+  output, errormsg, status = Open3.capture3('wine', *ARGV, :stdin_data => input)
+
+  # Clean and print the results.
+  STDOUT.write clean(output)
+  STDERR.write clean(errormsg)
+
+  exit(status.exitstatus)
+end
+
+
+main()

build_config/host-cxx.rb

@@ -0,0 +1,12 @@
+MRuby::Build.new do |conf|
+  conf.toolchain
+
+  # include the default GEMs
+  conf.gembox 'default'
+
+  # C compiler settings
+  conf.cc.defines = %w(MRB_USE_DEBUG_HOOK)
+  conf.enable_debug
+  conf.enable_cxx_abi
+  conf.enable_test
+end

build_config/host-debug.rb

@@ -0,0 +1,20 @@
+MRuby::Build.new('host') do |conf|
+  # load specific toolchain settings
+  conf.toolchain
+
+  conf.enable_debug
+
+  # include the default GEMs
+  conf.gembox 'full-core'
+
+  # C compiler settings
+  conf.cc.defines = %w(MRB_USE_DEBUG_HOOK MRB_NO_BOXING)
+
+  # Generate mruby debugger command (require mruby-eval)
+  conf.gem :core => "mruby-bin-debugger"
+
+  # test
+  conf.enable_test
+  # bintest
+  conf.enable_bintest
+end

build_config/host-f32.rb

@@ -0,0 +1,14 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  toolchain :gcc
+
+  # include the GEM box
+  conf.gembox 'default'
+
+  conf.cc.defines << 'MRB_USE_FLOAT32'
+
+  # Turn on `enable_debug` for better debugging
+  conf.enable_debug
+  conf.enable_test
+  conf.enable_bintest
+end

build_config/host-gprof.rb

@@ -0,0 +1,14 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  toolchain :gcc
+
+  # include the GEM box
+  conf.gembox 'default'
+
+  conf.cc.flags << '-pg'
+  conf.linker.flags << '-pg'
+
+  # Turn on `enable_debug` for better debugging
+  conf.enable_debug
+  conf.enable_test
+end

build_config/host-m32.rb

@@ -0,0 +1,15 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  toolchain :gcc
+
+  # include the GEM box
+  conf.gembox 'default'
+
+  conf.cc.flags << '-m32'
+  conf.linker.flags << '-m32'
+
+  # Turn on `enable_debug` for better debugging
+  conf.enable_debug
+  conf.enable_test
+  conf.enable_bintest
+end

build_config/host-nofloat.rb

@@ -0,0 +1,22 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  toolchain :gcc
+
+  # include the GEM box
+  conf.gembox "stdlib"
+  conf.gembox "stdlib-ext"
+  conf.gembox "stdlib-io"
+  conf.gembox "metaprog"
+
+  conf.gem :core => 'mruby-bin-mruby'
+  conf.gem :core => 'mruby-bin-mirb'
+
+  # Add configuration
+  conf.compilers.each do |c|
+    c.defines << "MRB_NO_FLOAT"
+  end
+
+  conf.enable_debug
+  conf.enable_test
+  conf.enable_bintest
+end

build_config/host-shared.rb

@@ -0,0 +1,36 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+
+  # Gets set by the VS command prompts.
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+  end
+
+  # include the GEM box
+  conf.gembox 'default'
+
+  # C compiler settings
+  conf.cc do |cc|
+    cc.flags = '-fPIC'
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = 'gcc'
+    archiver.archive_options = '-shared -o %{outfile} %{objs}'
+  end
+
+  # file extensions
+  conf.exts do |exts|
+    exts.library = '.so'
+  end
+
+  # file separator
+  # conf.file_separator = '/'
+
+  # Turn on `enable_debug` for better debugging
+  conf.enable_debug
+  conf.enable_bintest
+  conf.enable_test
+end

build_config/minimal.rb

@@ -0,0 +1,4 @@
+MRuby::CrossBuild.new('minimal') do |conf|
+  conf.toolchain :gcc
+  conf.cc.defines << 'MRB_NO_STDIO'
+end

build_config/mrbc.rb

@@ -0,0 +1,11 @@
+MRuby::Build.new do |conf|
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    conf.toolchain :visualcpp
+  else
+    conf.toolchain :gcc
+  end
+
+  conf.build_mrbc_exec
+  conf.disable_libmruby
+  conf.disable_presym
+end

build_config/nintendo_switch.rb

@@ -0,0 +1,73 @@
+# Cross Compiling configuration for the Nintendo Switch, it requires Nintendo SDK
+# Tested on windows
+MRuby::CrossBuild.new('nintendo_switch_32bit') do |conf|
+  conf.toolchain :clang
+  NINTENDO_SDK_PATH = ENV['NINTENDO_SDK_ROOT']
+
+  include_paths = [
+    "#{NINTENDO_SDK_PATH}/Include",
+    "#{NINTENDO_SDK_PATH}/Common/Configs/Targets/NX-NXFP2-a32/Include"
+  ]
+
+  conf.cc do |cc|
+    cc.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/bin/nx-clang++"
+    cc.include_paths += include_paths
+    cc.flags += ['-fpic -fno-short-enums -ffunction-sections -fdata-sections -fno-common -fno-strict-aliasing -fomit-frame-pointer -fno-vectorize -funsigned-char -O2 -g -mno-implicit-float']
+    cc.defines += 'NN_SDK_BUILD_RELEASE'
+  end
+
+  conf.cxx do |cxx|
+    cxx.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/bin/nx-clang++"
+    cxx.include_paths += include_paths
+    cxx.flags += ['-fpic -fno-short-enums -ffunction-sections -fdata-sections -fno-common -fno-strict-aliasing -fomit-frame-pointer -fno-vectorize -funsigned-char -O2 -g -mno-implicit-float']
+    cxx.defines += 'NN_SDK_BUILD_RELEASE'
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/nx/armv7l/bin/llvm-ar"
+  end
+
+  conf.linker do |linker|
+    linker.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/nx/armv7l/bin/clang++"
+    linker.libraries = []
+  end
+
+  # Add your mrbgems
+end
+
+MRuby::CrossBuild.new('nintendo_switch_64bit') do |conf|
+  conf.toolchain :clang
+  NINTENDO_SDK_PATH = ENV['NINTENDO_SDK_ROOT']
+
+  include_paths = [
+    "#{NINTENDO_SDK_PATH}/Include",
+    "#{NINTENDO_SDK_PATH}/Common/Configs/Targets/NX-NXFP2-a64/Include"
+  ]
+
+  conf.cc do |cc|
+    cc.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/bin/nx-clang++"
+    cc.include_paths += include_paths
+    cc.flags += ['-fpic -fno-short-enums -ffunction-sections -fdata-sections -fno-common -fno-strict-aliasing -fomit-frame-pointer -fno-vectorize -funsigned-char -O2 -g -mno-implicit-float']
+    cc.flags << '--target=aarch64-nintendo-nx-elf'
+    cc.defines += 'NN_SDK_BUILD_RELEASE'
+  end
+
+  conf.cxx do |cxx|
+    cxx.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/bin/nx-clang++"
+    cxx.include_paths += include_paths
+    cxx.flags += ['-fpic -fno-short-enums -ffunction-sections -fdata-sections -fno-common -fno-strict-aliasing -fomit-frame-pointer -fno-vectorize -funsigned-char -O2 -g -mno-implicit-float']
+    cxx.flags << '--target=aarch64-nintendo-nx-elf'
+    cxx.defines += 'NN_SDK_BUILD_RELEASE'
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/nx/aarch64/bin/llvm-ar"
+  end
+
+  conf.linker do |linker|
+    linker.command = "#{NINTENDO_SDK_PATH}/Compilers/NX/nx/aarch64/bin/clang++"
+    linker.libraries = []
+  end
+
+  # Add your mrbgems
+end

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

codespell.txt

@@ -0,0 +1,17 @@
+ans
+ba
+creat
+delet
+disabl
+filetest
+fo
+hel
+hist
+ist
+methid
+nd
+quitt
+remore
+runn
+sting
+upto

doc/guides/compile.md

@@ -6,41 +6,54 @@ binaries.
 ## Prerequisites
 
 To compile mruby out of the source code you need the following tools:
-* C Compiler (i.e. ```gcc```)
-* Linker (i.e. ```gcc```)
-* Archive utility (i.e. ```ar```)
-* Parser generator (i.e. ```bison```)
-* Ruby 1.8 or 1.9 (i.e. ```ruby``` or ```jruby```)
+
+* C Compiler (e.g. `gcc` or `clang`)
+* Linker (e.g. `gcc` or `clang`)
+* Archive utility (e.g. `ar`)
+* Ruby 2.5 or later (e.g. `ruby` or `jruby`)
 
 Optional:
-* GIT (to update mruby source and integrate mrbgems easier)
-* C++ compiler (to use GEMs which include \*.cpp, \*.cxx, \*.cc)
-* Assembler (to use GEMs which include \*.asm)
 
-## Usage
+* Git (to update mruby source and integrate mrbgems easier)
+* C++ compiler (to use mrbgems which include `*.cpp`, `*.cxx`, `*.cc`)
+* Bison (to compile `mrbgems/mruby-compiler/core/parse.y`)
+* gperf (to compile `mrbgems/mruby-compiler/core/keywords`)
+
+Note that `bison` bundled with macOS is too old to compile `mruby`.
+Try `brew install bison` and follow the instruction shown to update
+the `$PATH` to compile `mruby`. We also encourage you to upgrade `ruby`
+on macOS in similar manner.
+
+## Build
+
+To compile `mruby` with the default build configuration, just invoke `rake`
+inside of the mruby source root. To generate and execute the test tools call
+`rake test`. To clean all build files call `rake clean`. To see full command
+line on build, call `rake -v`.
+
+You can specify your own configuration file by the `MRUBY_CONFIG` environment
+variable (you can use `CONFIG` for shorthand for `MRUBY_CONFIG`). If the path
+doesn't exist, `build_config/${MRUBY_CONFIG}.rb` is used. The default
+configuration is defined in the `build_config/default.rb` file.
+
+Those build configuration files contain the build configuration of mruby, for
+example:
 
-Inside of the root directory of the mruby source a file exists
-called *build_config.rb*. This file contains the build configuration
-of mruby and looks like this for example:
 ```ruby
 MRuby::Build.new do |conf|
-  toolchain :gcc
+  conf.toolchain :gcc
 end
 ```
 
-All tools necessary to compile mruby can be set or modified here. In case
-you want to maintain an additional *build_config.rb* you can define a
-customized path using the *$MRUBY_CONFIG* environment variable.
-
-To compile just call ```./minirake``` inside of the mruby source root. To
-generate and execute the test tools call ```./minirake test```. To clean
-all build files call ```./minirake clean```. To see full command line on
-build, call ```./minirake -v```.
+All tools necessary to compile mruby can be set or modified here.
 
 ## Build Configuration
 
-Inside of the *build_config.rb* the following options can be configured
-based on your environment.
+We wish you submit a pull-request to `build_config/PLATFORM.rb`, once you
+created a new configuration for a new platform.
+
+Inside the configuration file, the following options can be
+configured based on your environment.
 
 ### Toolchains
 
@@ -50,54 +63,56 @@ configure the build environment for specific compiler infrastructures.
 #### GCC
 
 Toolchain configuration for the GNU C Compiler.
+
 ```ruby
-toolchain :gcc
+conf.toolchain :gcc
 ```
 
 #### clang
 
 Toolchain configuration for the LLVM C Compiler clang. Mainly equal to the
 GCC toolchain.
+
 ```ruby
-toolchain :clang
+conf.toolchain :clang
 ```
 
 #### Visual Studio 2010, 2012 and 2013
 
 Toolchain configuration for Visual Studio on Windows. If you use the
-[Visual Studio Command Prompt](http://msdn.microsoft.com/en-us/library/ms229859\(v=vs.110\).aspx),
+[Visual Studio Command Prompt](https://msdn.microsoft.com/en-us/library/ms229859\(v=vs.110\).aspx),
 you normally do not have to specify this manually, since it gets automatically detected by our build process.
+
 ```ruby
-toolchain :visualcpp
+conf.toolchain :visualcpp
 ```
 
 #### Android
 
 Toolchain configuration for Android.
+
 ```ruby
-toolchain :android
+conf.toolchain :android
 ```
 
 Requires the custom standalone Android NDK and the toolchain path
-in ```ANDROID_STANDALONE_TOOLCHAIN```.
+in `ANDROID_STANDALONE_TOOLCHAIN`.
 
 ### Binaries
 
 It is possible to select which tools should be compiled during the compilation
-process. The following tools can be selected:
-* mruby (mruby interpreter)
-* mirb (mruby interactive shell)
+process. For example,
 
-To select them declare conf.gem as follows:
-```ruby
-conf.gem "#{root}/mrbgems/mruby-bin-mruby"
-conf.gem "#{root}/mrbgems/mruby-bin-mirb"
-```
+* `mruby`
+* `mirb`
+
+The configuration are done via `mrbgems`. See `Mrbgems` section.
 
 ### File Separator
 
 Some environments require a different file separator character. It is possible to
-set the character via ```conf.file_separator```.
+set the character via `conf.file_separator`.
+
 ```ruby
 conf.file_separator = '/'
 ```
@@ -105,6 +120,7 @@ conf.file_separator = '/'
 ### C Compiler
 
 Configuration of the C compiler binary, flags and include paths.
+
 ```ruby
 conf.cc do |cc|
   cc.command = ...
@@ -119,28 +135,31 @@ end
 
 C Compiler has header searcher to detect installed library.
 
-If you need a include path of header file use ```search_header_path```:
+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```:
+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"
 ```
 
-Header searcher uses compiler's ```include_paths``` by default.
+Header searcher uses compiler's `include_paths` by default.
 When you are using GCC toolchain (including clang toolchain since its base is gcc toolchain)
-it will use compiler specific include paths too. (For example ```/usr/local/include```, ```/usr/include```)
+it will use compiler specific include paths too. (For example `/usr/local/include`, `/usr/include`)
+
+If you need a special header search paths define a singleton method `header_search_paths` to C compiler:
 
-If you need a special header search paths define a singleton method ```header_search_paths``` to C compiler:
 ```ruby
 def conf.cc.header_search_paths
   ['/opt/local/include'] + include_paths
@@ -150,6 +169,7 @@ end
 ### Linker
 
 Configuration of the Linker binary, flags and library paths.
+
 ```ruby
 conf.linker do |linker|
   linker.command = ...
@@ -167,6 +187,7 @@ end
 ### Archiver
 
 Configuration of the Archiver binary and flags.
+
 ```ruby
 conf.archiver do |archiver|
   archiver.command = ...
@@ -177,6 +198,7 @@ end
 ### Parser Generator
 
 Configuration of the Parser Generator binary and flags.
+
 ```ruby
 conf.yacc do |yacc|
   yacc.command = ...
@@ -187,6 +209,7 @@ end
 ### GPerf
 
 Configuration of the GPerf binary and flags.
+
 ```ruby
 conf.gperf do |gperf|
   gperf.command = ...
@@ -195,6 +218,7 @@ end
 ```
 
 ### File Extensions
+
 ```ruby
 conf.exts do |exts|
   exts.object = ...
@@ -203,26 +227,52 @@ conf.exts do |exts|
 end
 ```
 
+### Preallocated Symbols
+
+By far, preallocated symbols are highly compatible with the previous versions, so
+we expect you won't see any problem with them. But just in case you face any
+issue, you can disable preallocated symbols by specifying `conf.disable_presym`.
+
+In the build process, `mrbc` under cross compiling environment will be compiled
+with this configuration.
+
 ### Mrbgems
 
-Integrate GEMs in the build process.
-```ruby
-# Integrate GEM with additional configuration
-conf.gem 'path/to/gem' do |g|
-  g.cc.flags << ...
-end
+`mruby` comes with the (sort of) packaging system named `mrbgems`. To
+specify `gem`, you can use `conf.gem` in the configuration file.
 
-# Integrate GEM without additional configuration
-conf.gem 'path/to/another/gem'
+```ruby
+# Integrate a bundled Gem you see in `mrbgems` directory
+conf.gem :core => 'mruby-something'
+
+# Integrate a Gem from GitHub
+conf.gem :github => 'someone/mruby-another'
+
+# Integrate a mruby binary Gem
+conf.gem :core => 'mruby-bin-mruby'
+
+# Integrate a interactive mruby binary Gem
+conf.gem :core => 'mruby-bin-mirb'
+
+# Integrate GemBox (set of Gems)
+conf.gembox "default"
 ```
 
+A GemBox is a set of Gems defined in `mrbgems/default.gembox` for example.
+It's just a set of `mrbgem` configurations.
+
+There is a `RubyGem` (gem for CRuby) named `mgem` that help you to
+manage `mrbgems`. Try `gem install mgem`. `mgem` can show you the list
+of registered `mrbgems`.
+
 See doc/mrbgems/README.md for more option about mrbgems.
 
 ### Mrbtest
 
 Configuration Mrbtest build process.
 
-If you want mrbtest.a only, You should set ```conf.build_mrbtest_lib_only```
+If you want `mrbtest.a` only, You should set `conf.build_mrbtest_lib_only`
+
 ```ruby
 conf.build_mrbtest_lib_only
 ```
@@ -230,11 +280,12 @@ conf.build_mrbtest_lib_only
 ### Bintest
 
 Tests for mrbgem tools using CRuby.
-To have bintests place \*.rb scripts to ```bintest/``` directory of mrbgems.
-See ```mruby-bin-*/bintest/*.rb``` if you need examples.
-If you want a temporary files use `tempfile` module of CRuby instead of ```/tmp/```.
+To have bintests place `*.rb` scripts to `bintest/` directory of mrbgems.
+See `mruby-bin-*/bintest/*.rb` if you need examples.
+If you want a temporary files use `tempfile` module of CRuby instead of `/tmp/`.
 
 You can enable it with following:
+
 ```ruby
 conf.enable_bintest
 ```
@@ -247,64 +298,71 @@ correctly. To support mrbgems written in C++, mruby can be
 configured to use C++ exception.
 
 There are two levels of C++ exception handling. The one is
-```enable_cxx_exception``` that enables C++ exception, but
-uses C ABI. The other is ```enable_cxx_abi``` where all
+`enable_cxx_exception` that enables C++ exception, but
+uses C ABI. The other is `enable_cxx_abi` where all
 files are compiled by C++ compiler.
 
 When you mix C++ code, C++ exception would be enabled automatically.
 If you need to enable C++ exception explicitly add the following:
+
 ```ruby
 conf.enable_cxx_exception
 ```
 
-#### C++ exception disabling.
+#### C++ exception disabling
 
-If your compiler does not support C++ and you want to ensure
+If your compiler does not support C++, and you want to ensure
 you don't use mrbgem written in C++, you can explicitly disable
 C++ exception, add following:
+
 ```ruby
 conf.disable_cxx_exception
 ```
+
 and you will get an error when you try to use C++ gem.
-Note that it must be called before ```enable_cxx_exception``` or ```gem``` method.
+Note that it must be called before `enable_cxx_exception` or `gem` method.
 
 ### Debugging mode
 
 To enable debugging mode add the following:
+
 ```ruby
 conf.enable_debug
 ```
 
 When debugging mode is enabled
-* Macro ```MRB_DEBUG``` would be defined.
-	* 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.
+
+* Macro `MRB_DEBUG` would be defined.
+  * 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.
     * You can have better backtrace of mruby scripts with this.
 
 ## Cross-Compilation
 
-mruby can also be cross-compiled from one platform to another. To
-achieve this the *build_config.rb* needs to contain an instance of
-```MRuby::CrossBuild```. This instance defines the compilation
-tools and flags for the target platform. An example could look
-like this:
+mruby can also be cross-compiled from one platform to another. To achieve
+cross-compilation, the build configuration needs to contain an instance of
+`MRuby::CrossBuild`. This instance defines the compilation tools and flags
+for the target platform. An example could look like this:
+
 ```ruby
 MRuby::CrossBuild.new('32bit') do |conf|
-  toolchain :gcc
+  conf.toolchain :gcc
 
   conf.cc.flags << "-m32"
   conf.linker.flags << "-m32"
 end
 ```
 
-All configuration options of ```MRuby::Build``` can also be used
-in ```MRuby::CrossBuild```.
+All configuration options of `MRuby::Build` can also be used in
+`MRuby::CrossBuild`. You can find examples under the `build_config`
+directory.
 
 ### Mrbtest in Cross-Compilation
 
-In cross compilation, you can run ```mrbtest``` on emulator if
+In cross compilation, you can run `mrbtest` on an emulator if
 you have it by changing configuration of test runner.
+
 ```ruby
 conf.test_runner do |t|
   t.command = ... # set emulator. this value must be non nil or false
@@ -318,48 +376,44 @@ end
 
 ## Build process
 
-During the build process the directory *build* will be created in the
+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
-	       |
-	       +- bin          <- Binaries (mirb, mrbc and mruby)
-	       |
-	       +- lib          <- Libraries (libmruby.a and libmruby_core.a)
-	       |
-	       +- mrblib
-	       |
-	       +- src
-	       |
-	       +- test         <- mrbtest tool
-	       |
-	       +- tools
-	          |
-	          +- mirb
-	          |
-	          +- mrbc
-	          |
-	          +- mruby
+```
++- 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:
-* compile all files under *src* (object files will be stored
-in *build/host/src*)
-* generate parser grammar out of *src/parse.y* (generated
-result will be stored in *build/host/src/y.tab.c*)
-* compile  *build/host/src/y.tab.c* to  *build/host/src/y.tab.o*
-* create *build/host/lib/libmruby_core.a* out of all object files (C only)
-* create ```build/host/bin/mrbc``` by compiling *tools/mrbc/mrbc.c* and
-linking with *build/host/lib/libmruby_core.a*
-* create *build/host/mrblib/mrblib.c* by compiling all \*.rb files
-under *mrblib* with ```build/host/bin/mrbc```
-* compile *build/host/mrblib/mrblib.c* to *build/host/mrblib/mrblib.o*
-* create *build/host/lib/libmruby.a* out of all object files (C and Ruby)
-* create ```build/host/bin/mruby``` by compiling *mrbgems/mruby-bin-mruby/tools/mruby/mruby.c* and
-linking with *build/host/lib/libmruby.a*
-* create ```build/host/bin/mirb``` by compiling *mrbgems/mruby-bin-mirb/tools/mirb/mirb.c* and
-linking with *build/host/lib/libmruby.a*
+
+* compile minimal `mrbc` from `src` and `mrblib` sources
+  * compile all files under `src` (object files will be stored in `build/host/mrbc/src`)
+  * compile `mruby-compiler` gem
+  * create `build/host/mrbc/lib/libmruby_core.a` out of all object files (C only)
+  * create `build/host/mrbc/bin/mrbc` via `mruby-bin-mrbc` gem
+* compile all files under `src` and store result in `build/host/src`
+* create `build/host/mrblib/mrblib.c` by compiling all `*.rb` files under `mrblib` with `build/host/mrbc/bin/mrbc`
+* compile `build/host/mrblib/mrblib.c` to `build/host/mrblib/mrblib.o`
+* create `build/host/lib/libmruby.a` out of all object files (C and Ruby)
+* compile (normal) mrbgems specified in the configuration file
+* create `build/host/lib/libmruby.a` from object files from gems and `libmruby_core.a`
+* create binary commands according to binary gems (e.g. `mirb` and `mruby`)
+* copy binaries under `build/host/bin` to `bin` directory
 
 ```
  _____    _____    ______    ____    ____    _____    _____    ____
@@ -370,73 +424,54 @@ linking with *build/host/lib/libmruby.a*
 
 ### Cross-Compilation
 
-In case of a cross-compilation to *i386* the *build* directory structure looks
+In case of a cross-compilation to `i386` the `build` directory structure looks
 like this:
 
-	+- build
-	   |
-	   +-  host
-	   |   |
-	   |   +- bin           <- Native Binaries
-	   |   |
-	   |   +- lib           <- Native Libraries
-	   |   |
-	   |   +- mrblib
-	   |   |
-	   |   +- src
-	   |   |
-	   |   +- test          <- Native mrbtest tool
-	   |   |
-	   |   +- tools
-	   |      |
-	   |      +- mirb
-	   |      |
-	   |      +- mrbc
-	   |      |
-	   |      +- mruby
-	   +- i386
-	      |
-	      +- bin            <- Cross-compiled Binaries
-	      |
-	      +- lib            <- Cross-compiled Libraries
-	      |
-	      +- mrblib
-	      |
-	      +- src
-	      |
-	      +- test           <- Cross-compiled mrbtest tool
-	      |
-	      +- tools
-	         |
-	         +- mirb
-	         |
-	         +- mrbc
-	         |
-	         +- mruby
+```
++- 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
+compile for `i386` a directory called `i386` is created under the
 build directory.
 
 The cross compilation workflow starts in the same way as the normal
-compilation by compiling all *native* libraries and binaries.
-Afterwards the cross compilation process proceeds like this:
-* cross-compile all files under *src* (object files will be stored
-in *build/i386/src*)
-* generate parser grammar out of *src/parse.y* (generated
-result will be stored in *build/i386/src/y.tab.c*)
-* cross-compile *build/i386/src/y.tab.c* to *build/i386/src/y.tab.o*
-* create *build/i386/mrblib/mrblib.c* by compiling all \*.rb files
-under *mrblib* with the native ```build/host/bin/mrbc```
-* cross-compile *build/host/mrblib/mrblib.c* to *build/host/mrblib/mrblib.o*
-* create *build/i386/lib/libmruby.a* out of all object files (C and Ruby)
-* create ```build/i386/bin/mruby``` by cross-compiling *mrbgems/mruby-bin-mruby/tools/mruby/mruby.c* and
-linking with *build/i386/lib/libmruby.a*
-* create ```build/i386/bin/mirb``` by cross-compiling *mrbgems/mruby-bin-mirb/tools/mirb/mirb.c* and
-linking with *build/i386/lib/libmruby.a*
-* create *build/i386/lib/libmruby_core.a* out of all object files (C only)
-* create ```build/i386/bin/mrbc``` by cross-compiling *tools/mrbc/mrbc.c* and
-linking with *build/i386/lib/libmruby_core.a*
+compilation by compiling all *native* libraries and binaries, except
+for we don't have `host/mrbc` directory (`host` directory itself works
+as placeholder for `mrbc`). Afterwards the cross compilation process
+proceeds like this:
+
+* cross-compile all files under `src` and store result in `build/i386/src`
+* create `build/i386/lib/libmruby_core.a` out of C object files
+* create `build/i386/mrblib/mrblib.c` by compiling all `*.rb` files under `mrblib` with native `build/host/bin/mrbc`
+* cross-compile `build/i386/mrblib/mrblib.c` to `build/i386/mrblib/mrblib.o`
+* create `build/i386/lib/libmruby.a` from object files from gems and `libmruby_core.a`
+* create binary commands according to binary gems (e.g. `mirb` and `mruby`)
+* copy binaries under `build/host/bin` to `bin` directory
 
 ```
  _______________________________________________________________
@@ -463,26 +498,61 @@ linking with *build/i386/lib/libmruby_core.a*
 ### Minimal Library
 
 To build a minimal mruby library you need to use the Cross Compiling
-feature due to the reason that there are functions (i.e. stdio) which
+feature due to the reason that there are functions (e.g. stdio) which
 can't be disabled for the main build.
 
 ```ruby
-MRuby::CrossBuild.new('Minimal') do |conf|
-  toolchain :gcc
-
-  conf.cc.defines = %w(MRB_DISABLE_STDIO)
-  conf.bins = []
+MRuby::CrossBuild.new('minimal') do |conf|
+  conf.toolchain :gcc
+  conf.cc.defines << 'MRB_NO_STDIO'
 end
 ```
 
-This configuration defines a cross compile build called 'Minimal' which
+This configuration defines a cross compile build called 'minimal' which
 is using the GCC and compiles for the host machine. It also disables
-all usages of stdio and doesn't compile any binaries (i.e. mrbc).
+all usages of stdio and doesn't compile any binaries (e.g. `mrbc`).
 
 ## Test Environment
 
 mruby's build process includes a test environment. In case you start the testing
-of mruby, a native binary called ```mrbtest``` will be generated and executed.
-This binary contains all test cases which are defined under *test/t*. In case
-of a cross-compilation an additional cross-compiled *mrbtest* binary is
+of mruby, a native binary called `mrbtest` will be generated and executed.
+This binary contains all test cases which are defined under `test/t`. In case
+of a cross-compilation an additional cross-compiled `mrbtest` binary is
 generated. You can copy this binary and run on your target system.
+
+## Embedding `mruby` in Your Application
+
+After the build, you will get `libmruby.a`. You can link it to your application.
+
+For compiler options and library path, you can use `mruby-config` command for
+convenience. `mruby-config` command prints the configuration used for `libmruby.a`.
+
+```
+$ mruby-config --help
+Usage: mruby-config [switches]
+  switches:
+  --cc                        print compiler name
+  --cflags                    print flags passed to compiler
+  --ld                        print linker name
+  --ldflags                   print flags passed to linker
+  --ldflags-before-libs       print flags passed to linker before linked libraries
+  --libs                      print linked libraries
+  --libmruby-path             print libmruby path
+  --help                      print this help
+```
+
+For example, when you have a C source file (`c.c`) and try to
+compile and link it with `libmruby.a`, you can run the following command,
+
+```
+gcc `mruby-config --cflags` c.c `mruby-config --ldflags` `mruby-config --libs`
+```
+
+When you use `make`, add following lines in `Makefile`
+
+```
+MRB_CONFIG = <path-to-mruby-config>
+CFLAGS = `$(MRB_CONFIG) --cflags`
+LDFLAGS = `$(MRB_CONFIG) --ldflags`
+LIBS = `$(MRB_CONFIG) --libs`
+```

doc/guides/debugger.md

@@ -38,7 +38,7 @@ To confirm mrdb was installed properly, run mrdb with the `--version` option:
 
 ```bash
 $ mrdb --version
-mruby 2.0.0 (2018-12-11)
+mruby 3.0.0 (2021-03-05)
 ```
 
 ## 2.2 Basic Operation
@@ -114,8 +114,8 @@ b [class:]method
 The breakpoint will be ordered in serial from 1.
 The number, which was given to the deleted breakpoint, will never be given to another breakpoint again.
 
-You can give multiple breakpoints to specified the line number and method.
-Be ware that breakpoint command will not check the validity of the class name and method name.
+You can give multiple breakpoints to the specified the line number and method.
+Be aware that the breakpoint command will not check the validity of the class name and method name.
 
 You can get the current breakpoint information by the following options.
 
@@ -165,7 +165,7 @@ Example:
 (foo.rb:1) delete
 ```
 
-This will delete all of the breakpoints.
+This will delete all the breakpoints.
 
 ```
 (foo.rb:1) delete 1 3
@@ -192,7 +192,7 @@ Example:
 (foo.rb:1) disable
 ```
 
-Use `disable` if you would like to disable all of the breakpoints.
+Use `disable` if you would like to disable all the breakpoints.
 
 ```
 (foo.rb:1) disable 1 3
@@ -220,6 +220,7 @@ Example:
 ```
 
 Enabling all breakpoints
+
 ```
 (foo.rb:1) enable 1 3
 ```
@@ -263,7 +264,7 @@ Example:
 
 ```
 (sample.rb:1) info breakpoints
-Num     Type           Enb What  
+Num     Type           Enb What
 1       breakpoint     y   at sample.rb:3                      -> file name,line number
 2       breakpoint     n   in Sample_class:sample_class_method -> [class:]method name
 3       breakpoint     y   in sample_global_method
@@ -273,8 +274,8 @@ Displaying the specified breakpoint number:
 
 ```
 (foo.rb:1) info breakpoints 1 3
-Num     Type           Enb What  
-1       breakpoint     y   at sample.rb:3  
+Num     Type           Enb What
+1       breakpoint     y   at sample.rb:3
 3       breakpoint     y   in sample_global_method
 ```
 
@@ -323,7 +324,7 @@ expr: expression
 
 The expression is mandatory.
 The displayed expressions will be serially ordered from 1.
-If an exception occurs, the exception information will be displayed and the debugging will be continued.
+If an exception occurs, the exception information will be displayed, and the debugging will be continued.
 
 Example:
 
@@ -366,5 +367,5 @@ r
 #### Step Command
 
 This will run the program step by step.
-When the method and the block are invoked, the program will be stop at the first row.
+When the method and the block are invoked, the program will stop at the first row.
 The program, which is developed in C, will be ignored.

doc/guides/gc-arena-howto.md

@@ -3,7 +3,7 @@
 _This is an English translation of [Matz's blog post][matz blog post]
 written in Japanese._
 _Some parts are updated to reflect recent changes._
-[matz blog post]: http://www.rubyist.net/~matz/20130731.html
+[matz blog post]: <https://www.rubyist.net/~matz/20130731.html>
 
 When you are extending mruby using C language, you may encounter
 mysterious "arena overflow error" or memory leak or very slow
@@ -11,13 +11,13 @@ execution speed.  This is an error indicating overflow of "GC arena"
 implementing "conservative GC".
 
 GC (garbage collector) must ensure that object is "alive", in other
-words, that it is referenced by somewhere from program.  This can be
+words, that it is referenced by somewhere from the program.  This can be
 determined by checking if the object can be directly or indirectly
 referenced by root.  The local variables, global variables and
 constants etc are root.
 
 If program execution is performed inside mruby VM, there is nothing to
-worry about because GC can access all roots owned by VM.
+worry about because GC can access all roots owned by the VM.
 
 The problem arises when executing C functions.  The object referenced
 by C variable is also "alive", but mruby GC cannot aware of this, so
@@ -38,7 +38,7 @@ The biggest problem is we have no way to access to the stack area in
 portable way.  Therefore, we cannot use this method if we'd like to
 implement highly portable runtime, like mruby.
 
-So we came up with an another plan to implement "conservative GC" in mruby.
+So we came up with another plan to implement "conservative GC" in mruby.
 
 Again, the problem is when an object which was created in C function, becomes
 no longer referenced in the Ruby world, and cannot be treated as garbage.
@@ -46,7 +46,7 @@ no longer referenced in the Ruby world, and cannot be treated as garbage.
 In mruby, we recognize all objects created in C function are alive.
 Then we have no problem such as confusing a live object as dead.
 
-This means that because we cannot collect truly dead object, we may
+This means that because we cannot collect a truly dead object, we may
 lose efficiency, but as a trade-off the GC itself is highly portable.
 We can say goodbye to the problem that GC deletes live objects due to
 optimization which sometimes occurs in CRuby.
@@ -140,7 +140,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
 }
 ```
 
-This is a real example, so a little bit complicated, but bear with me.
+This is a real example, so slightly complicated, but bear with me.
 The essence of `Array#inspect` is that after stringifying each element
 of array using `inspect` method, we join them together so that we can
 get `inspect` representation of the entire array.
@@ -161,7 +161,7 @@ Please note that the final `inspect` representation of entire array
 was created before the call of `mrb_gc_arena_restore()`.  Otherwise,
 required temporal object may be deleted by GC.
 
-We may have a usecase where after creating many temporal objects, we'd
+We may have an usecase where after creating many temporal objects, we'd
 like to keep some of them.  In this case, we cannot use the same idea
 in `ary_inspect()` like appending objects to existing one.
 Instead, after `mrb_gc_arena_restore()`, we must re-register the objects we

doc/guides/link.md

@@ -0,0 +1,83 @@
+# Linking `libmruby` to your application
+
+You have two ways to link `libmruby` to your application.
+
+* using executable gem.
+* using normal compilation process
+
+## Executable Gems
+
+If your application is relatively small, `mrbgem` is an easier way to
+create the executable.  By tradition, the gem name start with
+`mruby-bin-`, e.g. `mruby-bin-debugger`.
+
+### `mrbgem.rake` file
+
+The executable name is specified in `mrbgem.rake` file at the top of
+your `mrbgem` directory.
+
+```ruby
+MRuby::Gem::Specification.new('mruby-bin-example') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Example for executable command gem'
+  spec.bins = %w(mruby-example)    # <- this is binary name
+end
+```
+
+### Source tree structure
+
+The source file for the gem executable should be in
+`<gem-name>/tools/<bin-name>`.  Currently, we support C or C++ source code
+(`.c`, `.cpp`, `.cxx`, `.cc`) for the executable. Ruby source files are not
+supported. Put the functionality in the different gem and specify dependency to
+it in `mrbgem.rake`.
+
+## Normal compilation process
+
+The `libmruby` is a normal library so that you can just link it to your
+application. Specify proper compiler options (`-I` etc.) and linker options
+(`-Lmruby` etc.) to compile and link your application. Specify those options in
+your build script (e.g. `Makefile`).
+
+### Compiler options
+
+You need to specify compiler options that are compatible to mruby configuration,
+for example:
+
+* `-I` to specify the place for mruby header files
+* `-D` to specify mruby configuration macros
+
+To retrieve compiler options used to build `mruby`, you can use `mruby-config`
+command with following options:
+
+* `--cc`                    compiler name
+* `--cflags`                options passed to compiler
+
+```
+$ mruby-config --cflags
+-std=gnu99 -g -O3 -Wall -DMRB_GC_FIXED_ARENA -I/home/matz/work/mruby/include -I/home/matz/work/mruby/build/host/include
+```
+
+### Linker options
+
+Just like compiler options, you need to specify linker options that are
+compatible to mruby configuration.
+
+To retrieve linker options, you can use `mruby-config` with following options:
+
+* `--ld`                    linker name
+* `--ldflags`               options passed to linker
+* `--ldflags-before-libs`   options passed to linker before linked libraries
+* `--libs`                  linked libraries
+
+```
+$ mruby-config --ldflags
+-L/home/matz/work/mruby/build/host/lib
+
+$ mruby-config --ldflags-before-libs
+# <nothing in this case>
+
+$ mruby-config --libs
+-lmruby -lm
+```

doc/guides/mrbconf.md

@@ -1,146 +1,209 @@
-# mruby configuration macros.
+# mruby configuration macros
+
+## How to use these macros
 
-## How to use these macros.
 You can use mrbconfs with following ways:
-* Write them in `mrbconf.h`.
- * Using compiler flags is preferred  when building a cross binaries or multiple mruby binaries
- since it's easier to use different mrbconf per each `MRuby::Build`.
- * Most flags can be enabled by just commenting in.
-* Pass them as compiler flags.
- * Make sure you pass the same flags to all compilers since some mrbconf(e.g., `MRB_GC_FIXED_ARENA`)
- changes `struct` layout and cause memory access error when C and other language(e.g., C++) is mixed.
 
-## stdio setting.
-`MRB_DISABLE_STDIO`
+* Write them in `mrbconf.h`.
+  * Using compiler flags is preferred  when building a cross binaries or multiple mruby binaries
+    since it's easier to use different mrbconf per each `MRuby::Build`.
+  * Most flags can be enabled by just commenting in.
+* Pass them as compiler flags.
+  * Make sure you pass the same flags to all compilers since some mrbconf(e.g., `MRB_GC_FIXED_ARENA`)
+    changes `struct` layout and cause memory access error when C and other language(e.g., C++) is mixed.
+
+## stdio setting
+
+`MRB_NO_STDIO`
+
 * When defined `<stdio.h>` functions won't be used.
 * Some features will be disabled when this is enabled:
   * `mrb_irep` load/dump from/to file.
-  * Compiling mruby script from file.
+  * Compiling mruby script from a file.
   * Printing features in **src/print.c**.
 
-## Debug macros.
-`MRB_ENABLE_DEBUG_HOOK`
+## Debug macros
+
+`MRB_USE_DEBUG_HOOK`
+
 * When defined code fetch hook and debug OP hook will be enabled.
 * When using any of the hook set function pointer `code_fetch_hook` and/or `debug_op_hook` of `mrb_state`.
 * Fetch hook will be called before any OP.
 * Debug OP hook will be called when dispatching `OP_DEBUG`.
 
 `MRB_DEBUG`
+
 * When defined `mrb_assert*` macro will be defined with macros from `<assert.h>`.
 * Could be enabled via `enable_debug` method of `MRuby::Build`.
 
 ## Stack configuration
 
 `MRB_STACK_EXTEND_DOUBLING`
+
 * If defined doubles the stack size when extending it.
 * Else extends stack with `MRB_STACK_GROWTH`.
 
 `MRB_STACK_GROWTH`
+
 * Default value is `128`.
 * Used in stack extending.
 * Ignored when `MRB_STACK_EXTEND_DOUBLING` is defined.
 
 `MRB_STACK_MAX`
+
 * Default value is `0x40000 - MRB_STACK_GROWTH`.
 * Raises `RuntimeError` when stack size exceeds this value.
 
-## Primitive type configuration.
+## Primitive type configuration
 
-`MRB_USE_FLOAT`
-* When defined single precision floating point type(C type `float`) is used as `mrb_float`.
-* Else double precision floating point type(C type `double`) is used as `mrb_float`.
+`MRB_USE_FLOAT32`
 
-`MRB_INT16`
-* When defined `int16_t` will be defined as `mrb_int`.
+* When defined single precision floating-point type(C type `float`) is used as `mrb_float`.
+* Otherwise, double precision floating-point type(C type `double`) is used as `mrb_float`.
+
+`MRB_NO_FLOAT`
+
+* When defined removes floating-point numbers from mruby.
+* It makes mruby easier to handle in "Microcontroller without FPU" and "Kernel Space".
+
+`MRB_INT32`
+
+* When defined, or `MRB_INT64` are not defined on 32-bit CPU mode, `mrb_int` will be defined as `int32_t`.
 * Conflicts with `MRB_INT64`.
 
 `MRB_INT64`
-* When defined `int64_t` will be defined as `mrb_int`.
-* Conflicts with `MRB_INT16`.
-* When `MRB_INT16` or `MRB_INT64` isn't defined `int`(most of the times 32-bit integer)
-will be defined as `mrb_int`.
 
-## Garbage collector configuration.
+* When defined, or `MRB_INT32` are not defined on 64-bit CPU mode, `mrb_int` will be defined as `int64_t`.
+* Conflicts with `MRB_INT32`.
+
+## Garbage collector configuration
 
 `MRB_GC_STRESS`
+
 * When defined full GC is emitted per each `RBasic` allocation.
 * Mainly used in memory manager debugging.
 
 `MRB_GC_TURN_OFF_GENERATIONAL`
+
 * When defined turns generational GC by default.
 
 `MRB_GC_FIXED_ARENA`
+
 * When defined used fixed size GC arena.
 * Raises `RuntimeError` when this is defined and GC arena size exceeds `MRB_GC_ARENA_SIZE`.
 * Useful tracking unnecessary mruby object allocation.
 
 `MRB_GC_ARENA_SIZE`
+
 * Default value is `100`.
 * Ignored when `MRB_GC_FIXED_ARENA` isn't defined.
 * Defines fixed GC arena size.
 
 `MRB_HEAP_PAGE_SIZE`
+
 * Defines value is `1024`.
 * Specifies number of `RBasic` per each heap page.
 
-## Memory pool configuration.
+## Memory pool configuration
 
 `POOL_ALIGNMENT`
+
 * Default value is `4`.
 * If you're allocating data types that requires alignment more than default value define the
 largest value of required alignment.
 
 `POOL_PAGE_SIZE`
+
 * Default value is `16000`.
 * Specifies page size of pool page.
 * Smaller the value is increases memory overhead.
 
-## State atexit configuration.
+## State atexit configuration
 
 `MRB_FIXED_STATE_ATEXIT_STACK`
+
 * If defined enables fixed size `mrb_state` atexit stack.
 * Raises `RuntimeError` when `mrb_state_atexit` call count to same `mrb_state` exceeds
 `MRB_FIXED_STATE_ATEXIT_STACK_SIZE`'s value.
 
 `MRB_FIXED_STATE_ATEXIT_STACK_SIZE`
+
 * Default value is `5`.
 * If `MRB_FIXED_STATE_ATEXIT_STACK` isn't defined this macro is ignored.
 
-## `mrb_value` configuration.
+## `mrb_value` configuration
 
 `MRB_ENDIAN_BIG`
+
 * If defined compiles mruby for big endian machines.
 * Used in `MRB_NAN_BOXING`.
 * Some mrbgem use this mrbconf.
 
 `MRB_NAN_BOXING`
+
 * If defined represent `mrb_value` in boxed `double`.
-* Conflicts with `MRB_USE_FLOAT`.
+* Conflicts with `MRB_USE_FLOAT32` and `MRB_NO_FLOAT`.
 
 `MRB_WORD_BOXING`
+
 * If defined represent `mrb_value` as a word.
 * If defined `Float` will be a mruby object with `RBasic`.
 
-## Instance variable configuration.
-`MRB_IV_SEGMENT_SIZE`
-* Default value is `4`.
-* Specifies size of each segment in segment list.
+## Reduce heap memory configuration
+
+`MRB_USE_ETEXT_RO_DATA_P`
+
+* 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`
+
+* 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)`.
+* Return `TRUE` if `ptr` is in the read-only section, otherwise return `FALSE`.
+
+## Other configuration
 
-## Other configuration.
 `MRB_UTF8_STRING`
+
 * Adds UTF-8 encoding support to character-oriented String instance methods.
 * If it isn't defined, they only support the US-ASCII encoding.
 
 `MRB_FUNCALL_ARGC_MAX`
+
 * Default value is `16`.
 * Specifies 4th argument(`argc`) max value of `mrb_funcall`.
 * Raises `ArgumentError` when the `argc` argument is bigger then this value `mrb_funcall`.
 
 `KHASH_DEFAULT_SIZE`
+
 * Default value is `32`.
 * Specifies default size of khash table bucket.
 * Used in `kh_init_ ## name` function.
 
-`MRB_STR_BUF_MIN_SIZE`
-* Default value is `128`.
-* Specifies initial capacity of `RString` created by `mrb_str_buf_new` function..
+`MRB_NO_METHOD_CACHE`
+
+* Disable method cache to save memory.
+
+`MRB_METHOD_CACHE_SIZE`
+
+* Default value is `256`.
+* Ignored if `MRB_NO_METHOD_CACHE` is defined.
+* Need to be the power of 2.
+
+`MRB_USE_METHOD_T_STRUCT`
+
+* Use C struct to represent `mrb_method_t`
+* No `MRB_USE_METHOD_T_STRUCT` requires highest 2 bits of function pointers to be zero
+* Define this macro on machines that use higher bits of pointers
+
+`MRB_USE_ALL_SYMBOLS`
+
+* Make it available `Symbol.all_symbols` in `mrbgems/mruby-symbol-ext`
+* Increase heap memory usage.

doc/guides/mrbgems.md

@@ -1,47 +1,62 @@
 # mrbgems
 
 mrbgems is a library manager to integrate C and Ruby extension in an easy and
-standardised way into mruby.
+standardised way into mruby. Conventionally, each mrbgem name is prefixed by
+`mruby-`, e.g. `mruby-time` for a gem that provides `Time` class functionality.
 
 ## Usage
 
-By default mrbgems is currently deactivated. As soon as you add a GEM to your
-build configuration (i.e. *build_config.rb*), mrbgems will be activated and the
-extension integrated.
+You have to activate mrbgems explicitly in your build configuration.  To add
+a gem, add the following line to your build configuration file, for example:
 
-To add a GEM into the *build_config.rb* add the following line for example:
 ```ruby
 conf.gem '/path/to/your/gem/dir'
 ```
 
-You can also use a relative path which would be relative from the mruby root:
+You can also use a relative path to specify a gem.
+
 ```ruby
 conf.gem 'examples/mrbgems/ruby_extension_example'
 ```
 
+In that case,
+
+* if your build configuration file is in the `build_config` directory, it's
+  relative from `MRUBY_ROOT`.
+* otherwise, it is relative from the directory where your build configuration is.
+
 A remote GIT repository location for a GEM is also supported:
+
 ```ruby
 conf.gem :git => 'https://github.com/masuidrive/mrbgems-example.git', :branch => 'master'
 conf.gem :github => 'masuidrive/mrbgems-example', :branch => 'master'
 conf.gem :bitbucket => 'mruby/mrbgems-example', :branch => 'master'
 ```
 
-You can specify the sub directory of the repository with `:path` option:
+You can specify the subdirectory of the repository with `:path` option:
+
 ```ruby
 conf.gem github: 'mruby/mruby', path: 'mrbgems/mruby-socket'
 ```
 
 To use mrbgem from [mgem-list](https://github.com/mruby/mgem-list) use `:mgem` option:
+
 ```ruby
 conf.gem :mgem => 'mruby-yaml'
 conf.gem :mgem => 'yaml' # 'mruby-' prefix could be omitted
 ```
 
-If there is missing dependencies, mrbgem dependencies solver will reference
-mrbgem from core or mgem-list.
+For specifying the commit hash to checkout use `:checksum_hash` option:
 
-To pull all gems from remote GIT repository on build, call ```./minirake -p```,
-or ```./minirake --pull-gems```.
+```ruby
+conf.gem mgem: 'mruby-redis', checksum_hash: '3446d19fc4a3f9697b5ddbf2a904f301c42f2f4e'
+```
+
+If there are missing dependencies, mrbgem dependencies solver will reference
+mrbgem from the core or mgem-list.
+
+To pull all gems from remote GIT repository on build, call `rake -p`,
+or `rake --pull-gems`.
 
 NOTE: `:bitbucket` option supports only git. Hg is unsupported in this version.
 
@@ -49,13 +64,14 @@ NOTE: `:bitbucket` option supports only git. Hg is unsupported in this version.
 
 There are instances when you wish to add a collection of mrbgems into mruby at
 once, or be able to substitute mrbgems based on configuration, without having to
-add each gem to the *build_config.rb* file.  A packaged collection of mrbgems
+add each gem to your build configuration file.  A packaged collection of mrbgems
 is called a GemBox.  A GemBox is a file that contains a list of mrbgems to load
-into mruby, in the same format as if you were adding them to *build_config.rb*
+into mruby, in the same format as if you were adding them to the build config
 via `config.gem`, but wrapped in an `MRuby::GemBox` object.  GemBoxes are
 loaded into mruby via `config.gembox 'boxname'`.
 
-Below we have created a GemBox containing *mruby-time* and *mrbgems-example*:
+Below we have created a GemBox containing `mruby-time` and `mrbgems-example`:
+
 ```ruby
 MRuby::GemBox.new do |conf|
   conf.gem "#{root}/mrbgems/mruby-time"
@@ -64,20 +80,23 @@ end
 ```
 
 As mentioned, the GemBox uses the same conventions as `MRuby::Build`.  The GemBox
-must be saved with a *.gembox* extension inside the *mrbgems* directory to to be
+must be saved with a `.gembox` extension inside the `mrbgems` directory to be
 picked up by mruby.
 
-To use this example GemBox, we save it as `custom.gembox` inside the *mrbgems*
-directory in mruby, and add the following to our *build_config.rb* file inside
+To use this example GemBox, we save it as `custom.gembox` inside the `mrbgems`
+directory in mruby, and add the following to your build configuration file inside
 the build block:
+
 ```ruby
 conf.gembox 'custom'
 ```
-This will cause the *custom* GemBox to be read in during the build process,
-adding *mruby-time* and *mrbgems-example* to the build.
+
+This will cause the `custom` GemBox to be read in during the build process,
+adding `mruby-time` and `mrbgems-example` to the build.
 
 If you want, you can put GemBox outside of mruby directory. In that case you must
 specify an absolute path like below.
+
 ```ruby
 conf.gembox "#{ENV["HOME"]}/mygemboxes/custom"
 ```
@@ -85,36 +104,41 @@ conf.gembox "#{ENV["HOME"]}/mygemboxes/custom"
 There are two GemBoxes that ship with mruby: [default](../../mrbgems/default.gembox)
 and [full-core](../../mrbgems/full-core.gembox). The [default](../../mrbgems/default.gembox) GemBox
 contains several core components of mruby, and [full-core](../../mrbgems/full-core.gembox)
-contains every gem found in the *mrbgems* directory.
+contains every gem found in the `mrbgems` directory.
 
 ## GEM Structure
 
 The maximal GEM structure looks like this:
 
-	+- GEM_NAME         <- Name of GEM
-	   |
-	   +- include/      <- Header for Ruby extension (will exported)
-	   |
-	   +- mrblib/       <- Source for Ruby extension
-	   |
-	   +- src/          <- Source for C extension
-	   |
-	   +- test/         <- Test code (Ruby)
-	   |
-	   +- mrbgem.rake   <- GEM Specification
-	   |
-	   +- README.md     <- Readme for GEM
+```
++- 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*
-contains C/C++ files to extend mruby. The folder *include* contains C/C++ header
-files. The folder *test* contains C/C++ and pure Ruby files for testing purposes
-which will be used by `mrbtest`. *mrbgem.rake* contains the specification
-to compile C and Ruby files. *README.md* is a short description of your GEM.
+The folder `mrblib` contains pure Ruby files to extend mruby. The folder `src`
+contains C/C++ files to extend mruby. The folder `include` contains C/C++ header
+files. The folder `test` contains C/C++ and pure Ruby files for testing purposes
+which will be used by `mrbtest`. `mrbgem.rake` contains the specification
+to compile C and Ruby files. `README.md` is a short description of your GEM.
 
 ## Build process
 
-mrbgems expects a specification file called *mrbgem.rake* inside of your
+mrbgems expects a specification file called `mrbgem.rake` inside of your
 GEM directory. A typical GEM specification could look like this for example:
+
 ```ruby
 MRuby::Gem::Specification.new('c_and_ruby_extension_example') do |spec|
   spec.license = 'MIT'
@@ -124,10 +148,10 @@ end
 ```
 
 The mrbgems build process will use this specification to compile Object and Ruby
-files. The compilation results will be added to *lib/libmruby.a*. This file exposes
+files. The compilation results will be added to `lib/libmruby.a`. This file exposes
 the GEM functionality to tools like `mruby` and `mirb`.
 
-The following properties can be set inside of your `MRuby::Gem::Specification` for
+The following properties can be set inside your `MRuby::Gem::Specification` for
 information purpose:
 
 * `spec.license` or `spec.licenses` (A single license or a list of them under which this GEM is licensed)
@@ -144,6 +168,7 @@ The `license` and `author` properties are required in every GEM!
 
 In case your GEM is depending on other GEMs please use
 `spec.add_dependency(gem, *requirements[, default_get_info])` like:
+
 ```ruby
 MRuby::Gem::Specification.new('c_and_ruby_extension_example') do |spec|
   spec.license = 'MIT'
@@ -153,10 +178,10 @@ MRuby::Gem::Specification.new('c_and_ruby_extension_example') do |spec|
   # The version must be between 1.0.0 and 1.5.2 .
   spec.add_dependency('mruby-parser', '>= 1.0.0', '<= 1.5.2')
 
-  # Use any version of mruby-uv from github.
+  # Use any version of mruby-uv from GitHub.
   spec.add_dependency('mruby-uv', '>= 0.0.0', :github => 'mattn/mruby-uv')
 
-  # Use latest mruby-onig-regexp from github. (version requirements can be omitted)
+  # Use latest mruby-onig-regexp from GitHub. (version requirements can be omitted)
   spec.add_dependency('mruby-onig-regexp', :github => 'mattn/mruby-onig-regexp')
 
   # You can add extra mgems active only on test
@@ -167,6 +192,7 @@ end
 The version requirements and default gem information are optional.
 
 Version requirement supports following operators:
+
 * '=': is equal
 * '!=': is not equal
 * '>': is greater
@@ -174,23 +200,25 @@ 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.
 
-You can have default gem to use as dependency when it's not defined in *build_config.rb*.
+You can have default gem to use as dependency when it's not defined in your build configuration.
 When the last argument of `add_dependency` call is `Hash`, it will be treated as default gem information.
 Its format is same as argument of method `MRuby::Build#gem`, expect that it can't be treated as path gem location.
 
 When a special version of dependency is required,
-use `MRuby::Build#gem` in *build_config.rb* to override default gem.
+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:
+
 ```ruby
 MRuby::Gem::Specification.new 'some-regexp-binding' do |spec|
   spec.license = 'BSD'
@@ -204,7 +232,7 @@ end
 ```
 
 In case your GEM has more complex build requirements you can use
-the following options additionally inside of your GEM specification:
+the following options additionally inside your GEM specification:
 
 * `spec.cc.flags` (C compiler flags)
 * `spec.cc.defines` (C compiler defines)
@@ -219,7 +247,7 @@ the following options additionally inside of your GEM specification:
 * `spec.test_objs` (Object test files for integration into mrbtest)
 * `spec.test_preload` (Initialization files for mrbtest)
 
-You also can use `spec.mruby.cc` and `spec.mruby.linker` to add extra global parameters for compiler and linker.
+You also can use `spec.mruby.cc` and `spec.mruby.linker` to add extra global parameters for the compiler and linker.
 
 ### include_paths and dependency
 
@@ -228,12 +256,11 @@ By default, `/...absolute path.../{GEM_NAME}/include` will be exported.
 So it is recommended not to put GEM's local header files on include/.
 
 These exports are retroactive.
-For example: when B depends to C and A depends to B, A will get include paths exported by C.
+For example: when B depends on C and A depends on B, A will get include paths exported by C.
 
-Exported include_paths are automatically appended to GEM local include_paths by Minirake.
+Exported include_paths are automatically appended to GEM local include_paths by rake.
 You can use `spec.export_include_paths` accessor if you want more complex build.
 
-
 ## C Extension
 
 mruby can be extended with C. This is possible by using the C API to
@@ -243,9 +270,10 @@ integrate C libraries into mruby.
 
 mrbgems expects that you have implemented a C method called
 `mrb_YOURGEMNAME_gem_init(mrb_state)`. `YOURGEMNAME` will be replaced
-by the name of your GEM. If you call your GEM *c_extension_example*, your
+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");
@@ -257,10 +285,10 @@ mrb_c_extension_example_gem_init(mrb_state* mrb) {
 
 mrbgems expects that you have implemented a C method called
 `mrb_YOURGEMNAME_gem_final(mrb_state)`. `YOURGEMNAME` will be replaced
-by the name of your GEM. If you call your GEM *c_extension_example*, your
+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);
@@ -269,54 +297,57 @@ mrb_c_extension_example_gem_final(mrb_state* mrb) {
 
 ### Example
 
-	+- c_extension_example/
-	   |
-	   +- src/
-	   |  |
-	   |  +- example.c         <- C extension source
-	   |
-	   +- test/
-	   |  |
-	   |  +- example.rb        <- Test code for C extension
-	   |
-	   +- mrbgem.rake          <- GEM specification
-	   |
-	   +- README.md
+```
++- 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
 
 mruby can be extended with pure Ruby. It is possible to override existing
-classes or add new ones in this way. Put all Ruby files into the *mrblib*
+classes or add new ones in this way. Put all Ruby files into the `mrblib`
 folder.
 
-
 ### Pre-Conditions
 
 none
 
 ### Example
 
-	+- ruby_extension_example/
-	   |
-	   +- mrblib/
-	   |  |
-	   |  +- example.rb        <- Ruby extension source
-	   |
-	   +- test/
-	   |  |
-	   |  +- example.rb        <- Test code for Ruby extension
-	   |
-	   +- mrbgem.rake          <- GEM specification
-	   |
-	   +- README.md
+```
++- 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
 
 mruby can be extended with C and Ruby at the same time. It is possible to
 override existing classes or add new ones in this way. Put all Ruby files
-into the *mrblib* folder and all C files into the *src* folder.
+into the `mrblib` folder and all C files into the `src` folder.
 
-mruby codes under *mrblib* directory would be executed after gem init C
+mruby codes under `mrblib` directory would be executed after gem init C
 function is called. Make sure *mruby script* depends on *C code* and
 *C code* doesn't depend on *mruby script*.
 
@@ -326,20 +357,61 @@ See C and Ruby example.
 
 ### Example
 
-	+- c_and_ruby_extension_example/
-	   |
-	   +- 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
-	   |
-	   +- README.md
+```
++- 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
+
+Some gems can generate executables under `bin` directory. Those gems are called
+binary gems.  Names of binary gems are conventionally prefixed by `mruby-bin`,
+e.g. `mruby-bin-mirb` and `mruby-bin-strip`.
+
+To specify the name of executable, you need to specify `spec.bins` in the
+`mrbgem.rake`. The entry point `main()` should be in the C source file under
+`tools/<bin>/*.c` where `<bin>` is a name of the executable. C files under the
+`<bin>` directory are compiled and linked to the executable, but not included in
+`libmruby.a`, whereas files under `mrblib` and `src` are.
+
+It is strongly recommended not to include `mrblib` and `src` directories in the
+binary gems, to separate normal gems and binary gems.
+
+### Example
+
+```
++- mruby-bin-example/
+    |
+    +- README.md        (Optional)
+    |
+    +- bintest/
+    |   |
+    |   +- example.rb   <- Test code for binary gem
+    |
+    +- mrbgem.rake      <- Gem specification
+    |
+    +- mrblib/          <- Source for Ruby extension (Optional)
+    |
+    +- src/             <- Source for C extension (Optional)
+    |
+    +- tools/
+        |
+        +- example/     <- Executable name directory
+        |
+        +- example.c    <- Source for Executable (includes main)
+```

doc/guides/symbol.md

@@ -0,0 +1,83 @@
+# Symbols
+
+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
+struct mt_elem {
+  union mt_ptr ptr;
+  size_t func_p:1;
+  size_t noarg_p:1;
+  mrb_sym key:sizeof(mrb_sym)*8-2;
+};
+```
+
+## C API
+
+We provide following C API for symbols.
+
+### Generate Symbols
+
+#### `mrb_sym mrb_intern(mrb_state*,const char*,size_t)`
+
+Get a symbol from a string.
+
+#### `mrb_sym mrb_intern_check_cstr(mrb_state*,const char*)`
+
+Get a symbol from a NULL terminated (C) string.
+
+#### `mrb_sym mrb_intern_str(mrb_state*,mrb_value)`
+
+Get a symbol from a Ruby string object.
+
+#### `mrb_intern_lit(mrb_state*,const char*)`
+
+Get a symbol from a C string literal. The second argument should be a C string
+literal, otherwise you will get a compilation error. It does not copy C string
+given the fact it's a literal.
+
+#### `mrb_sym mrb_intern_check(mrb_state*,const char*,size_t)`
+
+Get a symbol from a string if the string has been already registered as a
+symbol, otherwise return `0`. We also provide variants `mrb_intern_check_str()`
+(from Ruby string) and `mrb_intern_check_cstr()` (from C string).
+
+#### `const char *mrb_sym_name(mrb_state*,mrb_sym)`
+
+Get a string representation of a symbol as a C string.
+
+#### `const char *mrb_sym_name_len(mrb_state*,mrb_sym,mrb_int*)`
+
+Get a string representation of a symbol, and its length.
+
+## Preallocate Symbols
+
+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)
+
+For `MRB_OPSYM()`, specify the names corresponding to operators (see
+`MRuby::Presym::OPERATORS` in `lib/mruby/presym.rb` for the names that
+can be specified for it). Other than that, describe only word characters
+excluding leading and ending punctuations.
+
+These macros are converted to static symbol IDs at compile time, unless
+preallocate symbols are disabled by  `conf.disable_presym`. In that case,
+these macros are expanded to `mrb_intern_lit` calls, therefore the mruby state
+variable is required. The above macros assume the variable name is `mrb`.  If
+its name is not `mrb`, you need to use macros with `_2` suffix, such as
+`MRB_SYM_2` to specify `mrb_state*` variable.
+
+### Disabling Preallocated Symbols
+
+You can disable preallocated symbols by specifying `conf.disable_presym` in the
+configuration file.

doc/internal/boxing.md

@@ -0,0 +1,52 @@
+# Boxing
+
+The mruby objects and data are represented by C data type `mrb_value`. There are three options how to pack the data values in the `mrb_value`.
+
+* Word Boxing
+* NaN Boxing
+* No Boxing
+
+## Word Boxing
+
+Word boxing packs the Ruby data in a word, which is a natural integer size that equals to the size of pointers (`intptr_t`). Word boxing can be specified by `MRB_WORD_BOXING`, and it's default configuration for most platforms.
+
+Some values (called immediate values, e.g. integers, booleans, symbols, etc.) are directly packed in the word. The other data types are represented by pointers to the heap allocated structures.
+
+The Word boxing packing bit patterns are like following:
+
+| Types  | Bit Pattern                         |
+|--------|-------------------------------------|
+| object | xxxxxxxx xxxxxxxx xxxxxxxx xxxxx000 |
+| fixnum | xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxx1 |
+| nil    | 00000000 00000000 00000000 00000000 |
+| true   | 00000000 00000000 00000000 00001100 |
+| false  | 00000000 00000000 00000000 00000100 |
+| undef  | 00000000 00000000 00000000 00010100 |
+| symbol | xxxxxxxx xxxxxxxx xxxxxxxx xxxxxx10 |
+
+On 64 bit platform (unless `MRB_WORDBOX_NO_FLOAT_TRUNCATE`), float values are also packed in the `mrb_value`. In that case, we drop least significant 2 bits from mantissa.
+If you need full precision for floating point numbers, define `MRB_WORDBOX_NO_FLOAT_TRUNCATE`.
+
+## NaN Boxing
+
+NaN boxing packs the Ruby data in a floating point numbers, which represent NaN (Not a Number) values. Under IEEE753 definitions every value that exponent is all set are considered as NaN. That means NaN can represent `2^51` values. NaN boxing is a teaching to pack the values in those NaN representation. In theory, 64 bits pointers are too big to fit in NaN, but practically most OS uses only 48 bits at most for pointers (except for some OS e.g. Solaris).
+
+The NaN boxing packing bit patterns are like following:
+
+| Types  | Bit Pattern                                                             |
+|--------|-------------------------------------------------------------------------|
+| float  | SEEEEEEE EEEEFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF |
+| +/-inf | S1111111 11110000 00000000 00000000 00000000 00000000 00000000 00000000 |
+| nan    | 01111111 11111000 00000000 00000000 00000000 00000000 00000000 00000000 |
+| fixnum | 01111111 11111001 00000000 00000000 IIIIIIII IIIIIIII IIIIIIII IIIIIIII |
+| symbol | 01111111 11111110 00000000 00000000 SSSSSSSS SSSSSSSS SSSSSSSS SSSSSSSS |
+| misc   | 01111111 11111111 00000000 00000000 00000000 00000000 00TTTTTT 0000MMMM |
+| object | 01111111 11111100 PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPP00 |
+| ptr    | 01111111 11111100 PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPP01 |
+| nil    | 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 |
+
+The object values appear far more frequently than floating point numbers, so we offset the value so that object pointers are unchanged. This technique is called "favor pointer"".
+
+## No Boxing
+
+No boxing represents `mrb_value` by the C struct with `type` and the value union. This is the most portable (but inefficient) representation. No boxing can be specified by `MRB_NO_BOXING`, and it's default for debugging configuration (e.g. `host-debug`).

doc/internal/opcode.md

@@ -0,0 +1,128 @@
+# The new bytecode
+
+We will reimplement the VM to use 8bit instruction code. By
+bytecode, we mean real byte code. The whole purpose is
+reducing the memory consumption of mruby VM.
+
+# Instructions
+
+Instructions are bytes. There can be 256 instructions. Currently, we
+have 94 instructions. Instructions can take 0 to 3 operands.
+
+## operands
+
+The size of operands can be either 8bits, 16bits or 24bits.
+In the table.1 below, the second field describes the size (and
+sign) of operands.
+
+* B: 8bit
+* S: 16bit
+* sS: signed 16bit
+* W: 24bit
+
+## table.1 Instruction Table
+
+| Instruction Name | Operand type | Semantics                                                |
+|------------------|--------------|----------------------------------------------------------|
+| `OP_NOP`         | `-`          | `no operation`                                           |
+| `OP_MOVE`        | `BB`         | `R(a) = R(b)`                                            |
+| `OP_LOADL`       | `BB`         | `R(a) = Pool(b)`                                         |
+| `OP_LOADI`       | `BB`         | `R(a) = mrb_int(b)`                                      |
+| `OP_LOADINEG`    | `BB`         | `R(a) = mrb_int(-b)`                                     |
+| `OP_LOADI__1`    | `B`          | `R(a) = mrb_int(-1)`                                     |
+| `OP_LOADI_0`     | `B`          | `R(a) = mrb_int(0)`                                      |
+| `OP_LOADI_1`     | `B`          | `R(a) = mrb_int(1)`                                      |
+| `OP_LOADI_2`     | `B`          | `R(a) = mrb_int(2)`                                      |
+| `OP_LOADI_3`     | `B`          | `R(a) = mrb_int(3)`                                      |
+| `OP_LOADI_4`     | `B`          | `R(a) = mrb_int(4)`                                      |
+| `OP_LOADI_5`     | `B`          | `R(a) = mrb_int(5)`                                      |
+| `OP_LOADI_6`     | `B`          | `R(a) = mrb_int(6)`                                      |
+| `OP_LOADI_7`     | `B`          | `R(a) = mrb_int(7)`                                      |
+| `OP_LOADI16`     | `BS`         | `R(a) = mrb_int(b)`                                      |
+| `OP_LOADI32`     | `BSS`        | `R(a) = mrb_int((b<<16)+c)`                              |
+| `OP_LOADSYM`     | `BB`         | `R(a) = Syms(b)`                                         |
+| `OP_LOADNIL`     | `B`          | `R(a) = nil`                                             |
+| `OP_LOADSELF`    | `B`          | `R(a) = self`                                            |
+| `OP_LOADT`       | `B`          | `R(a) = true`                                            |
+| `OP_LOADF`       | `B`          | `R(a) = false`                                           |
+| `OP_GETGV`       | `BB`         | `R(a) = getglobal(Syms(b))`                              |
+| `OP_SETGV`       | `BB`         | `setglobal(Syms(b), R(a))`                               |
+| `OP_GETSV`       | `BB`         | `R(a) = Special[Syms(b)]`                                |
+| `OP_SETSV`       | `BB`         | `Special[Syms(b)] = R(a)`                                |
+| `OP_GETIV`       | `BB`         | `R(a) = ivget(Syms(b))`                                  |
+| `OP_SETIV`       | `BB`         | `ivset(Syms(b),R(a))`                                    |
+| `OP_GETCV`       | `BB`         | `R(a) = cvget(Syms(b))`                                  |
+| `OP_SETCV`       | `BB`         | `cvset(Syms(b),R(a))`                                    |
+| `OP_GETCONST`    | `BB`         | `R(a) = constget(Syms(b))`                               |
+| `OP_SETCONST`    | `BB`         | `constset(Syms(b),R(a))`                                 |
+| `OP_GETMCNST`    | `BB`         | `R(a) = R(a)::Syms(b)`                                   |
+| `OP_SETMCNST`    | `BB`         | `R(a+1)::Syms(b) = R(a)`                                 |
+| `OP_GETUPVAR`    | `BBB`        | `R(a) = uvget(b,c)`                                      |
+| `OP_SETUPVAR`    | `BBB`        | `uvset(b,c,R(a))`                                        |
+| `OP_JMP`         | `S`          | `pc+=a`                                                  |
+| `OP_JMPIF`       | `BS`         | `if R(a) pc+=b`                                          |
+| `OP_JMPNOT`      | `BS`         | `if !R(a) pc+=b`                                         |
+| `OP_JMPNIL`      | `BS`         | `if R(a)==nil pc+=b`                                     |
+| `OP_JMPUW`       | `S`          | `unwind_and_jump_to(a)`                                  |
+| `OP_EXCEPT`      | `B`          | `R(a) = exc`                                             |
+| `OP_RESCUE`      | `BB`         | `R(b) = R(a).isa?(R(b))`                                 |
+| `OP_RAISEIF`     | `B`          | `raise(R(a)) if R(a)`                                    |
+| `OP_SEND`        | `BBB`        | `R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))`            |
+| `OP_SENDB`       | `BBB`        | `R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1))`  |
+| `OP_CALL`        | `-`          | `R(0) = self.call(frame.argc, frame.argv)`               |
+| `OP_SUPER`       | `BB`         | `R(a) = super(R(a+1),... ,R(a+b+1))`                     |
+| `OP_ARGARY`      | `BS`         | `R(a) = argument array (16=m5:r1:m5:d1:lv4)`             |
+| `OP_ENTER`       | `W`          | `arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1)` |
+| `OP_KEY_P`       | `BB`         | `R(a) = kdict.key?(Syms(b))`                             |
+| `OP_KEYEND`      | `-`          | `raise unless kdict.empty?`                              |
+| `OP_KARG`        | `BB`         | `R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))`           |
+| `OP_RETURN`      | `B`          | `return R(a) (normal)`                                   |
+| `OP_RETURN_BLK`  | `B`          | `return R(a) (in-block return)`                          |
+| `OP_BREAK`       | `B`          | `break R(a)`                                             |
+| `OP_BLKPUSH`     | `BS`         | `R(a) = block (16=m5:r1:m5:d1:lv4)`                      |
+| `OP_ADD`         | `B`          | `R(a) = R(a)+R(a+1)`                                     |
+| `OP_ADDI`        | `BB`         | `R(a) = R(a)+mrb_int(b)`                                 |
+| `OP_SUB`         | `B`          | `R(a) = R(a)-R(a+1)`                                     |
+| `OP_SUBI`        | `BB`         | `R(a) = R(a)-mrb_int(b)`                                 |
+| `OP_MUL`         | `B`          | `R(a) = R(a)*R(a+1)`                                     |
+| `OP_DIV`         | `B`          | `R(a) = R(a)/R(a+1)`                                     |
+| `OP_EQ`          | `B`          | `R(a) = R(a)==R(a+1)`                                    |
+| `OP_LT`          | `B`          | `R(a) = R(a)<R(a+1)`                                     |
+| `OP_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(b)[c] = R(a)`                                         |
+| `OP_APOST`       | `BBB`        | `*R(a),R(a+1)..R(a+c) = R(a)[b..]`                       |
+| `OP_INTERN`      | `B`          | `R(a) = intern(R(a))`                                    |
+| `OP_STRING`      | `BB`         | `R(a) = str_dup(Pool(b))`                                |
+| `OP_STRCAT`      | `B`          | `str_cat(R(a),R(a+1))`                                   |
+| `OP_HASH`        | `BB`         | `R(a) = hash_new(R(a),R(a+1)..R(a+b*2-1))`               |
+| `OP_HASHADD`     | `BB`         | `hash_push(R(a),R(a+1)..R(a+b*2))`                       |
+| `OP_HASHCAT`     | `B`          | `R(a) = hash_cat(R(a),R(a+1))`                           |
+| `OP_LAMBDA`      | `BB`         | `R(a) = lambda(Irep(b),OP_L_LAMBDA)`                     |
+| `OP_BLOCK`       | `BB`         | `R(a) = lambda(Irep(b),OP_L_BLOCK)`                      |
+| `OP_METHOD`      | `BB`         | `R(a) = lambda(Irep(b),OP_L_METHOD)`                     |
+| `OP_RANGE_INC`   | `B`          | `R(a) = range_new(R(a),R(a+1),FALSE)`                    |
+| `OP_RANGE_EXC`   | `B`          | `R(a) = range_new(R(a),R(a+1),TRUE)`                     |
+| `OP_OCLASS`      | `B`          | `R(a) = ::Object`                                        |
+| `OP_CLASS`       | `BB`         | `R(a) = newclass(R(a),Syms(b),R(a+1))`                   |
+| `OP_MODULE`      | `BB`         | `R(a) = newmodule(R(a),Syms(b))`                         |
+| `OP_EXEC`        | `BB`         | `R(a) = blockexec(R(a),Irep[b])`                         |
+| `OP_DEF`         | `BB`         | `R(a).newmethod(Syms(b),R(a+1)); R(a) = Syms(b)`         |
+| `OP_ALIAS`       | `BB`         | `alias_method(target_class,Syms(a),Syms(b))`             |
+| `OP_UNDEF`       | `B`          | `undef_method(target_class,Syms(a))`                     |
+| `OP_SCLASS`      | `B`          | `R(a) = R(a).singleton_class`                            |
+| `OP_TCLASS`      | `B`          | `R(a) = target_class`                                    |
+| `OP_DEBUG`       | `BBB`        | `print a,b,c`                                            |
+| `OP_ERR`         | `B`          | `raise(LocalJumpError, Pool(a))`                         |
+| `OP_EXT1`        | `-`          | `make 1st operand 16bit`                                 |
+| `OP_EXT2`        | `-`          | `make 2nd operand 16bit`                                 |
+| `OP_EXT3`        | `-`          | `make 1st and 2nd operands 16bit`                        |
+| `OP_STOP`        | `-`          | `stop VM`                                                |
+|------------------|--------------|----------------------------------------------------------|

doc/limitations.md

@@ -13,40 +13,9 @@ 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.
 
+## `Kernel.raise` in rescue clause
 
-## ```1/2``` gives ```0.5```
-
-Since mruby does not have ```Bignum```, bigger integers are represented
-by ```Float``` numbers. To enhance interoperability between ```Fixnum```
-and ```Float```, mruby provides ```Float#upto``` and other iterating
-methods for the ```Float``` class.  As a side effect, ```1/2``` gives ```0.5```
-not ```0```.
-
-## ```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 [2.0.0 (2018-12-11)]
-
-```
-[1, 2, 3]
-```
-
-## ```Kernel.raise``` in rescue clause
-
-```Kernel.raise``` without arguments does not raise the current exception within
+`Kernel.raise` without arguments does not raise the current exception within
 a rescue clause.
 
 ```ruby
@@ -59,26 +28,34 @@ end
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-```ZeroDivisionError``` is raised.
+`ZeroDivisionError` is raised.
 
-#### mruby [2.0.0 (2018-12-11)]
+#### mruby [3.0.0 (2021-03-05)]
 
-No exception is raised.
+`RuntimeError` is raised instead of `ZeroDivisionError`. To re-raise the exception, you have to do:
+
+```ruby
+begin
+  1 / 0
+rescue => e
+  raise e
+end
+```
 
 ## Fiber execution can't cross C function boundary
 
-mruby's ```Fiber``` is implemented in a similar way to Lua's co-routine. This
+mruby's `Fiber` is implemented similarly to Lua's co-routine. This
 results in the consequence that you can't switch context within C functions.
-Only exception is ```mrb_fiber_yield``` at return.
+Only exception is `mrb_fiber_yield` at return.
 
-## ```Array``` does not support instance variables
+## `Array` does not support instance variables
 
-To reduce memory consumption ```Array``` does not support instance variables.
+To reduce memory consumption `Array` does not support instance variables.
 
 ```ruby
 class Liste < Array
   def initialize(str = nil)
-    @feld = str
+    @field = str
   end
 end
 
@@ -87,16 +64,16 @@ p Liste.new "foobar"
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-``` [] ```
+` [] `
 
-#### mruby [1.4.1 (2018-4-27)]
+#### mruby [3.0.0 (2021-03-05)]
 
-```ArgumentError``` is raised.
+`ArgumentError` is raised.
 
 ## Method visibility
 
 For simplicity reasons no method visibility (public/private/protected) is
-supported.
+supported. Those methods are defined, but they are dummy methods.
 
 ```ruby
 class VisibleTest
@@ -119,17 +96,53 @@ false
 true
 ```
 
-#### mruby [2.0.0 (2018-12-11)]
+#### mruby [3.0.0 (2021-03-05)]
 
 ```
 true
 true
 ```
 
-## defined?
+### Visibility Declaration
 
-The ```defined?``` keyword is considered too complex to be fully
-implemented. It is recommended to use ```const_defined?``` and
+The declaration form of following visibility methods are not implemented.
+
+* `public`
+* `private`
+* `protected`
+* `module_function`
+
+Especially, `module_function` method is not dummy, but no declaration form.
+
+```
+module TestModule
+  module_function
+  def test_func
+    p 'test_func called'
+  end
+
+  test_func
+end
+
+p 'ok'
+```
+
+#### Ruby [ruby 2.5.5p157 (2019-03-15 revision 67260)]
+
+```
+ok
+```
+
+#### mruby [3.0.0 (2021-03-05)]
+
+```
+test.rb:8: undefined method 'test_func' (NoMethodError)
+```
+
+## `defined?`
+
+The `defined?` keyword is considered too complex to be fully
+implemented. It is recommended to use `const_defined?` and
 other reflection methods instead.
 
 ```ruby
@@ -142,11 +155,11 @@ defined?(Foo)
 nil
 ```
 
-#### mruby [2.0.0 (2018-12-11)]
+#### mruby [3.0.0 (2021-03-05)]
 
-```NameError``` is raised.
+`NameError` is raised.
 
-## ```alias``` on global variables
+## `alias` on global variables
 
 Aliasing a global variable works in CRuby but is not part
 of the ISO standard.
@@ -157,9 +170,9 @@ alias $a $__a__
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-``` nil ```
+` nil `
 
-#### mruby [2.0.0 (2018-12-11)]
+#### mruby [3.0.0 (2021-03-05)]
 
 Syntax error
 
@@ -178,15 +191,15 @@ end
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-```ArgumentError``` is raised.
-The re-defined ```+``` operator does not accept any arguments.
+`ArgumentError` is raised.
+The re-defined `+` operator does not accept any arguments.
 
-#### mruby [2.0.0 (2018-12-11)]
+#### mruby [3.0.0 (2021-03-05)]
 
-``` 'ab' ```
+` 'ab' `
 Behavior of the operator wasn't changed.
 
-## Kernel#binding is not supported
+## `Kernel#binding` is not supported
 
 `Kernel#binding` method is not supported.
 
@@ -197,7 +210,7 @@ $ ruby -e 'puts Proc.new {}.binding'
 #<Binding:0x00000e9deabb9950>
 ```
 
-#### mruby [2.0.0 (2018-12-11)]
+#### mruby [3.0.0 (2021-03-05)]
 
 ```
 $ ./bin/mruby -e 'puts Proc.new {}.binding'
@@ -206,27 +219,19 @@ trace (most recent call last):
 -e:1: undefined method 'binding' (NoMethodError)
 ```
 
-## Keyword arguments
+## `nil?` redefinition in conditional expressions
 
-mruby keyword arguments behave slightly different from CRuby 2.5
-to make the behavior simpler and less confusing. Maybe in the
-future, the simpler behavior will be adopted to CRuby as well.
+Redefinition of `nil?` is ignored in conditional expressions.
 
-#### Ruby [ruby 2.5.1p57 (2018-03-29 revision 63029)]
-
-```
-$ ruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'
-[[{"a"=>1}], {:b=>2}]
+```ruby
+a = "a"
+def a.nil?
+  true
+end
+puts(a.nil? ? "truthy" : "falsy")
 ```
 
-#### mruby [mruby 2.0.0]
-
-```
-$ ./bin/mruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'
-trace (most recent call last):
-	[0] -e:1
--e:1: keyword argument hash with non symbol keys (ArgumentError)
-```
+Ruby outputs `falsy`. mruby outputs `truthy`.
 
 ## Argument Destructuring
 
@@ -234,11 +239,12 @@ trace (most recent call last):
 def m(a,(b,c),d); p [a,b,c,d]; end
 m(1,[2,3],4)  # => [1,2,3,4]
 ```
+
 Destructured arguments (`b` and `c` in above example) cannot be accessed
 from the default expression of optional arguments and keyword arguments,
 since actual assignment is done after the evaluation of those default
 expressions. Thus:
-    
+
 ```ruby
 def f(a,(b,c),d=b)
   p [a,b,c,d]

doc/mruby3.0.md

@@ -0,0 +1,162 @@
+# User visible changes in `mruby3.0`
+
+# Build System
+
+## `build_config` directory
+
+Typical build configuration files are located in `build_config`
+directory. For examples:
+
+* `default`: the default configuration
+* `host-gprof`: compiles with `gprof` for performance tuning
+* `host-m32`: compiles in gcc 32bit mode on 64bit platforms
+* `boxing`: compiles all three boxing options
+* `clang-asan`: compiles with `clang`'s Address Sanitizer
+
+You can specify the build configuration file with the
+`MRUBY_CONFIG` environment variable (or `CONFIG` in short).
+If the value specified by `MRUBY_CONFIG` is not the path to
+the configuration file, `build_config/${MRUBY_CONFIG}.rb` is
+used.  So you can specify it as `rake MRUBY_CONFIG=boxing`,
+for example.
+
+# Build Configuration Contribution
+
+When you write a new build configuration description, please
+contribute. We welcome your contribution as a GitHub
+pull-request.
+
+# Language Changes
+
+## New Syntax
+
+We have ported some new syntax from CRuby.
+
+* Single line pattern matching (`12 => x`);
+  mruby matches only with local variables at the moment
+* Numbered block parameter (`x.map{_1 * 2}`)
+* End-less `def` (`def double(x) = x*2`)
+
+# Configuration Options Changed
+
+## Renamed for consistency
+
+Some configuration macro names are changed for consistency (use `MRB_USE_XXX`
+ or `MRB_NO_XXX`).
+
+|             mruby2             |          mruby3           |
+|--------------------------------|---------------------------|
+| `MRB_ENABLE_ALL_SYMBOLS`       | `MRB_USE_ALL_SYMBOLS`     |
+| `MRB_ENABLE_CXX_ABI`           | `MRB_USE_CXX_ABI`         |
+| `MRB_ENABLE_CXX_EXCEPTION`     | `MRB_USE_CXX_EXCEPTION`   |
+| `MRB_ENABLE_DEBUG_HOOK`        | `MRB_USE_DEBUG_HOOK`      |
+| `MRB_DISABLE_DIRECT_THREADING` | `MRB_NO_DIRECT_THREADING` |
+| `MRB_DISABLE_STDIO`            | `MRB_NO_STDIO`            |
+| `MRB_METHOD_T_STRUCT`          | `MRB_USE_METHOD_T_STRUCT` |
+| `MRB_USE_FLOAT`                | `MRB_USE_FLOAT32`         |
+| `MRB_WITHOUT_FLOAT`            | `MRB_NO_FLOAT`            |
+| `ENABLE_LINENOISE`             | `MRB_USE_LINENOISE`       |
+| `ENABLE_READLINE`              | `MRB_USE_READLINE`        |
+| `DISABLE_MIRB_UNDERSCORE`      | `MRB_NO_MIRB_UNDERSCORE`  |
+
+* `MRB_USE_FLOAT32` is changed from `MRB_USE_FLOAT` to make sure `float` here
+   means using single precision float, and not the opposite of `MRB_NO_FLOAT`.
+* `MRB_USE_METHOD_T_STRUCT` uses `struct` version of `mrb_method_t`. More
+  portable but consumes more memory. Turned on by default on 32bit platforms.
+* `MRB_` prefix is added to those without.
+
+## `MRB_NO_BOXING`
+
+Uses `struct` to represent `mrb_value`. Consumes more memory
+but easier to investigate the internal and to debug. It used
+to be default `mrb_value` representation. Now the default is
+`MRB_WORD_BOXING`.
+
+## `MRB_WORD_BOXING`
+
+Pack `mrb_value` in an `intptr_t` integer. Consumes less
+memory compared to `MRB_NO_BOXING` especially on 32 bit
+platforms. `Fixnum` size is 31 bits so some integer values
+does not fit in `Fixnum` integers.
+
+## `MRB_NAN_BOXING`
+
+Pack `mrb_value` in a floating pointer number. Nothing
+changed from previous versions.
+
+## `MRB_USE_MALLOC_TRIM`
+
+Call `malloc_trim(0)` from mrb_full_gc() if this macro is defined.
+If you are using glibc malloc, this macro could reduce memory consumption.
+
+# Command Line Program
+
+## `bin/mruby` (by mrbgems/mruby-bin-mruby)
+
+The mruby3 now automatically detects `*.mrb` files without the `-b`
+switch. Therefore, it can be mixed with the `*.rb` file in combination
+with the `-r` switch and specified at the same time.
+Here's an example that works fine:
+
+```console
+$ bin/mruby app.mrb
+$ bin/mruby -r lib1.mrb -r lib2.rb app.rb
+$ bin/mruby -r lib1.rb -r lib2.rb < app.mrb
+```
+
+# Internal Changes
+
+## New Instructions
+
+`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.
+
+* `OP_LOADI32`
+
+Instruction that unwinds jump table for rescue/ensure.
+
+* `OP_JMPUW`
+
+Renamed from `OP_RAISE`
+
+* `OP_RAISEIF`
+
+Instruction that is reserved for the future keyword argument support.
+
+* OP_SENDVK
+
+## Removed Instructions
+
+Instructions for old exception handling
+
+* `OP_ONERR`
+* `OP_POPERR`
+* `OP_EPUSH`
+* `OP_EPOP`
+
+No more operand extension
+
+* `OP_EXT1`
+* `OP_EXT2`
+* `OP_EXT3`
+
+## Changed Instructions
+
+Jump addresses used to be specified by absolute offset from the start of `iseq`. Now they are relative offset from the address of the next instruction.
+
+## `Random` now use `xoshiro128++`.
+
+For better and faster random number generation.
+
+## Preallocated Symbol
+
+Preallocated symbols are interned at compile-time. They can be accessed via symbols macros (e.g. `MRB_SYM()`).
+
+See [Symbols](https://github.com/mruby/mruby/blob/master/doc/guides/symbol.md).

doc/mruby3.1.md

@@ -0,0 +1,148 @@
+# User visible changes in `mruby3.1` from `mruby3.0`
+
+# Build System
+
+## `build_config` directory
+
+Several configurations for new platforms are added:
+
+* `cross-mingw-winetest.rb`
+* `cross-mingw.rb`
+* `nintendo_switch.rb`
+* `serenity.rb`
+
+Some new configurations for added for convenience.
+
+* `minimal`: minimal configuration
+* `host-f32`: compiles with `mrb_float` as 32 bit `float`
+* `host-nofloat`: compiles with no float configuration
+
+And `android_arm64-v8a.rb` was renamed to `android_arm64_v8a.rb` for consistency.
+
+# Configuration Options Changed
+
+Some configuration macros are available:
+
+* `MRB_WORDBOX_NO_FLOAT_TRUNCATE`: by default, float values are packed in the word if possible, but define this macro to allocate float values in the heap.
+* `MRB_USE_RO_DATA_P_ETEXT`: define this macro if `_etext` is available on your platform.
+* `MRB_NO_DEFAULT_RO_DATA_P`: define this macro to avoid using predefined `mrb_ro_data_p()` function
+
+# Language Changes
+
+## Keyword Arguments
+
+CRuby3.0 compatible keyword arguments are introduced.
+Keyword arguments are basically separated from ordinal arguments
+
+## New Methods
+
+* `Array#product`
+* `Array#repeated_combination`
+* `Array#repeated_permutation`
+* `Random.bytes`
+* `Random#bytes`
+
+# Internal Changes
+
+## Reintroduced Instructions
+
+`mruby3.0` removed `OP_EXT1`, `OP_EXT2`, `OP_EXT3` for operand extension. But the operand size limitations was too tight for real-world application.
+`mruby3.1` reintroduces those extension instructions.
+
+## Removed Instructions
+
+`mruby3.1` removed following instructions.
+
+* `OP_LOADL16`
+* `OP_LOADSYM16`
+* `OP_STRING16`
+* `OP_LAMBDA16`
+* `OP_BLOCK16`
+* `OP_METHOD16`
+* `OP_EXEC16`
+
+Those instructions are no longer needed by reintroduction of extension instructions.
+
+* `OP_SENDV`
+* `OP_SENDVB`
+
+Those instructions for method calls with variable number of arguments are no longer needed. They are covered by `OP_SEND` instruction with `n=15`.
+
+## New Instructions
+
+`mruby3.1` introduces following new instructions.
+
+* `OP_GETIDX`: takes 2 operands `a[b]`
+* `OP_SETIDX`: takes 3 operands `a[b]=c`
+* `OP_SSEND`: takes 3 operands `a=self.b(c...)`; see `OP_SEND`
+* `OP_SSENDB`: takes 3 operands `a=self.b(c...){...}`; see `OP_SEND`
+
+### `OP_GETIDX` and `OP_SETIDX`
+
+Execute `obj[int]` and `obj[int] = value` respectively, where `obj` is `string|array|hash`.
+
+### `OP_SSEND` and `OP_SSENDB`
+
+They are similar to `OP_SEND` and `OP_SENDB` respectively. They initialize the `R[a]` by `self` first so that we can skip one `OP_LOADSELF` instruction for each call.
+
+## Changed Instructions
+
+### `OP_SEND` and `OP_SENDB`
+
+Method calling instructions are unified. Now `OP_SEND` and `OP_SENDB` (method call with a block) can support both splat arguments and keyword arguments as well.
+
+The brief description of the instructions:
+
+|`OP_SEND`   | BBB | `R[a] = R[a].call(Syms[b],R[a+1..n],R[a+n+1],R[a+n+2]..nk) c=n|nk<<4`                    |
+|`OP_SENDB`  | BBB | `R[a] = R[a].call(Syms[b],R[a+1..n],R[a+n+1..nk],R[a+n+2..nk],&R[a+n+2*nk+2]) c=n|nk<<4` |
+
+Operand C specifies the number of arguments. Lower 4 bits (`n`) represents the number of ordinal arguments, and higher 4 bits (`nk`) represents the number of keyword arguments.
+When `n == 15`, the method takes arguments packed in an array. When `nk == 15`, the method takes keyword arguments are packed in a hash.
+
+### `OP_ARYPUSH`
+
+Now takes 2 operands and pushes multiple entries to an array.
+
+## Boxing Updated
+
+### Word Boxing
+
+`MRB_WORD_BOXING` now packs floating point numbers in the word, if the size of `mrb_float` is equal or smaller than the size of `mrb_int` by default.
+If the size of `mrb_float` and `mrb_int` are same, the last 2 bits in the `mrb_float` are trimmed and used as flags. If you need full precision, you need to define `MRB_WORDBOX_NO_FLOAT_TRUNCATE` as described above.
+
+### NaN Boxing
+
+Previous NaN boxing packs values in NaN representation, but pointer retrievals are far more frequent than floating point number references. So we add constant offset to NaN representation to clear higher bits of pointer representation. This representation is called "Favor Pointer" NaN Boxing.
+
+Also, previous NaN boxing limit the size of `mrb_int` to 4 bytes (32 bits) to fit in NaN values. Now we allocates integer values in the heap, if the value does not fit in the 32 bit range, just like we did in Word Boxing.
+
+## Constant Folding
+
+The code generator was updated to reduce the number of instructions, e.g.
+
+```
+a = 2 * 5
+```
+
+will be interpreted as
+
+```
+a = 10
+```
+
+In addition, we have improved peephole optimizations, for example:
+
+```
+GETIV R4 :@foo
+MOVE R1 R4
+```
+
+to
+
+```
+GETIV R1 :@foo
+```
+
+## `String#hash` now use `FNV1a` algorithm
+
+For better and faster hash values.

doc/opcode.md

@@ -1,127 +0,0 @@
-# The new bytecode
-
-We will reimplement VM to use 8bit instruction code. By
-bytecode, we mean real byte code. The whole purpose is
-reducing the memory consumption of mruby VM.
-
-# Instructions
-
-Instructions are bytes. There can be 256 instructions. Currently we
-have 94 instructions. Instructions can take 0 to 3 operands.
-
-## operands
-
-The size of operands can be either 8bits, 16bits or 24bits.
-In the table.1 below, the second field describes the size (and
-sign) of operands.
-
-* B: 8bit
-* sB: signed 8bit
-* S: 16bit
-* sS: signed 16bit
-* W: 24bit
-
-First two byte operands may be extended to 16bit. When those byte
-operands are bigger than 256, the instruction will be prefixed by
-`OP_EXT1` (means 1st operand is 16bit) or `OP_EXT2` (means 2nd operand
-is 16bit) or `OP_EXT3` (means 1st and 2nd operands are 16bit).
-
-For instructions marked by `'`, `OP_EXT1` can be prefixed. For those
-with `"`, either `OP_EXT1` or `OP_EXT2` or `OP_EXT2` can be prefixed.
-
-## table.1 Instruction Table
-
-|Instruction Name |Operand type |Semantics        
-|-----------------|-------------|-----------------
-|OP_NOP           | -           |                 
-|OP_MOVE"         |BB           |R(a) = R(b)      
-|OP_LOADL"        |BB           |R(a) = Pool(b)   
-|OP_LOADI"        |BsB          |R(a) = mrb_int(b)
-|OP_LOADI_0'      |B            |R(a) = 0
-|OP_LOADI_1'      |B            |R(a) = 1
-|OP_LOADI_2'      |B            |R(a) = 2
-|OP_LOADI_3'      |B            |R(a) = 3
-|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[b]
-|OP_SETSV"        |BB           |Special[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'        |SB           |if R(b) pc+=a
-|OP_JMPNOT'       |SB           |if !R(b) pc+=a
-|OP_ONERR         |sS           |rescue_push(pc+a)
-|OP_EXCEPT'       |B            |R(a) = exc
-|OP_RESCUE"       |BB           |R(b) = R(a).isa?(R(b))
-|OP_POPERR        |B            |a.times{rescue_pop()}
-|OP_RAISE'        |B            |raise(R(a))
-|OP_EPUSH'        |B            |ensure_push(SEQ[a])
-|OP_EPOP          |B            |A.times{ensure_pop().call}
-|OP_SENDV"        |BB           |R(a) = call(R(a),Syms(b),*R(a+1))
-|OP_SENDVB"       |BB           |R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2))
-|OP_SEND"         |BBB          |R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))
-|OP_SENDB"        |BBB          |R(a) = call(R(a),Syms(Bx),R(a+1),...,R(a+c),&R(a+c+1))
-|OP_CALL'         |B            |R(a) = 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_KARG"         |BB           |R(a) = kdict[Syms(Bx)]                          # todo
-|OP_KARG2"        |BB           |R(a) = kdict[Syms(Bx)]; kdict.rm(Syms(b))       # todo
-|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"          |BB           |R(a) = R(a)+R(a+1)
-|OP_ADDI"         |BBB          |R(a) = R(a)+mrb_int(c)
-|OP_SUB"          |BB           |R(a) = R(a)-R(a+1)
-|OP_SUBI"         |BB           |R(a) = R(a)-C
-|OP_MUL"          |BB           |R(a) = R(a)*R(a+1)
-|OP_DIV"          |BB           |R(a) = R(a)/R(a+1)
-|OP_EQ"           |BB           |R(a) = R(a)==R(a+1)
-|OP_LT"           |BB           |R(a) = R(a)<R(a+1)
-|OP_LE"           |BB           |R(a) = R(a)<=R(a+1)
-|OP_GT"           |BB           |R(a) = R(a)>R(a+1)
-|OP_GE"           |BB           |R(a) = R(a)>=R(a+1)
-|OP_ARRAY'        |BB           |R(a) = ary_new(R(a),R(a+1)..R(a+b))
-|OP_ARRAY2"       |BB           |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_AREF'         |BB           |R(a) = R(a)[b]
-|OP_ASET'         |BB           |R(a)[b] = R(a+1)
-|OP_APOST'        |BB           |*R(a),R(A+1)..R(A+C) = R(a)[B..]
-|OP_STRING"       |BB           |R(a) = str_dup(Lit(b))
-|OP_STRCAT'       |B            |str_cat(R(a),R(a+1))
-|OP_HASH'         |BB           |R(a) = hash_new(R(a),R(a+1)..R(a+b))
-|OP_HASHADD'      |BB           |R(a) = hash_push(R(a),R(a+1)..R(a+b))
-|OP_LAMBDA"       |BB           |R(a) = lambda(SEQ[b],OP_L_LAMBDA)
-|OP_BLOCK"        |BB           |R(a) = lambda(SEQ[b],OP_L_BLOCK)
-|OP_METHOD"       |BB           |R(a) = lambda(SEQ[b],OP_L_METHOD)
-|OP_RANGE_INC'    |B            |R(a) = range_new(R(a),R(a+1),FALSE)
-|OP_RANGE_EXC'    |B            |R(a) = range_new(R(a),R(a+1),TRUE)
-|OP_OCLASS'       |B            |R(a) = ::Object
-|OP_CLASS"        |BB           |R(a) = newclass(R(a),Syms(b),R(a+1))
-|OP_MODULE"       |BB           |R(a) = newmodule(R(a),Syms(b))
-|OP_EXEC"         |BB           |R(a) = blockexec(R(a),SEQ[b])
-|OP_DEF"          |BB           |R(a).newmethod(Syms(b),R(a+1))
-|OP_ALIAS'        |B            |alias_method(R(a),R(a+1),R(a+2))
-|OP_UNDEF"        |BB           |undef_method(R(a),Syms(b))
-|OP_SCLASS'       |B            |R(a) = R(a).singleton_class
-|OP_TCLASS'       |B            |R(a) = target_class
-|OP_ERR'          |B            |raise(RuntimeError, Lit(Bx))
-|OP_EXT1          |-            |make 1st operand 16bit
-|OP_EXT2          |-            |make 2nd operand 16bit
-|OP_EXT3          |-            |make 1st and 2nd operands 16bit
-|OP_STOP          |-            |stop VM

examples/mrbgems/c_and_ruby_extension_example/mrblib/example.rb

@@ -1,5 +1,5 @@
 module CRubyExtension
   def CRubyExtension.ruby_method
-    puts "A Ruby Extension"
+    puts "#{self}: A Ruby Extension"
   end
 end

examples/mrbgems/c_and_ruby_extension_example/src/example.c

@@ -1,10 +1,13 @@
 #include <mruby.h>
+#include <mruby/string.h>
 #include <stdio.h>
 
 static mrb_value
 mrb_c_method(mrb_state *mrb, mrb_value self)
 {
-  puts("A C Extension");
+  mrb_ensure_string_type(mrb, self);
+  printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self));
+
   return self;
 }
 

examples/mrbgems/c_extension_example/src/example.c

@@ -1,10 +1,13 @@
 #include <mruby.h>
+#include <mruby/string.h>
 #include <stdio.h>
 
 static mrb_value
 mrb_c_method(mrb_state *mrb, mrb_value self)
 {
-  puts("A C Extension");
+  mrb_ensure_string_type(mrb, self);
+  printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self));
+
   return self;
 }
 

examples/mrbgems/ruby_extension_example/mrblib/example.rb

@@ -1,5 +1,5 @@
 class RubyExtension
   def RubyExtension.ruby_method
-    puts "A Ruby Extension"
+    puts "#{self}: A Ruby Extension"
   end
 end

examples/targets/build_config_android_arm64-v8a.rb

@@ -1,26 +0,0 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-end
-
-# Requires Android NDK r13 or later.
-MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
-  params = {
-    :arch => 'arm64-v8a',
-    :platform => 'android-24',
-    :toolchain => :clang,
-  }
-  toolchain :android, params
-
-  conf.gembox 'default'
-end

examples/targets/build_config_android_armeabi.rb

@@ -1,26 +0,0 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-end
-
-# Requires Android NDK r13 or later.
-MRuby::CrossBuild.new('android-armeabi') do |conf|
-  params = {
-    :arch => 'armeabi',
-    :platform => 'android-24',
-    :toolchain => :clang,
-  }
-  toolchain :android, params
-
-  conf.gembox 'default'
-end

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)
@@ -25,30 +22,76 @@
 #endif
 
 /* configuration options: */
-/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
-//#define MRB_USE_FLOAT
+/* add -DMRB_USE_FLOAT32 to use float instead of double for floating-point numbers */
+//#define MRB_USE_FLOAT32
 
-/* exclude floating point numbers */
-//#define MRB_WITHOUT_FLOAT
+/* exclude floating-point numbers */
+//#define MRB_NO_FLOAT
 
-/* add -DMRB_METHOD_CACHE to use method cache to improve performance */
-//#define MRB_METHOD_CACHE
+/* obsolete configuration */
+#if defined(MRB_USE_FLOAT)
+# define MRB_USE_FLOAT32
+#endif
+
+/* obsolete configuration */
+#if defined(MRB_WITHOUT_FLOAT)
+# define MRB_NO_FLOAT
+#endif
+
+#if defined(MRB_USE_FLOAT32) && defined(MRB_NO_FLOAT)
+#error Cannot define MRB_USE_FLOAT32 and MRB_NO_FLOAT at the same time
+#endif
+
+/* add -DMRB_NO_METHOD_CACHE to disable method cache to save memory */
+//#define MRB_NO_METHOD_CACHE
 /* size of the method cache (need to be the power of 2) */
-//#define MRB_METHOD_CACHE_SIZE (1<<7)
+//#define MRB_METHOD_CACHE_SIZE (1<<8)
 
-/* add -DMRB_METHOD_TABLE_INLINE to reduce the size of method table */
-/* MRB_METHOD_TABLE_INLINE requires LSB of function pointers to be zero */
-/* you might need to specify --falign-functions=n (where n>1) */
-//#define MRB_METHOD_TABLE_INLINE
+/* add -DMRB_USE_METHOD_T_STRUCT on machines that use higher bits of function pointers */
+/* no MRB_USE_METHOD_T_STRUCT requires highest 2 bits of function pointers to be zero */
+#ifndef MRB_USE_METHOD_T_STRUCT
+  // can't use highest 2 bits of function pointers at least on 32bit
+  // Windows and 32bit Linux.
+# ifdef MRB_32BIT
+#   define MRB_USE_METHOD_T_STRUCT
+# endif
+#endif
 
-/* add -DMRB_INT16 to use 16bit integer for mrb_int; conflict with MRB_INT64 */
-//#define MRB_INT16
+/* define on big endian machines; used by MRB_NAN_BOXING, etc. */
+#ifndef MRB_ENDIAN_BIG
+# if (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \
+     (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#  define MRB_ENDIAN_BIG
+# endif
+#endif
 
-/* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT16 */
+/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT32 and MRB_NO_FLOAT */
+//#define MRB_NAN_BOXING
+
+/* represent mrb_value as a word (natural unit of data for the processor) */
+//#define MRB_WORD_BOXING
+
+/* represent mrb_value as a struct; occupies 2 words */
+//#define MRB_NO_BOXING
+
+/* if no specific boxing type is chosen */
+#if !defined(MRB_NAN_BOXING) && !defined(MRB_WORD_BOXING) && !defined(MRB_NO_BOXING)
+# define MRB_WORD_BOXING
+#endif
+
+/* 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
+
+/* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT32;
+   Default for 64-bit CPU mode (unless using MRB_NAN_BOXING). */
 //#define MRB_INT64
 
 /* if no specific integer type is chosen */
-#if !defined(MRB_INT16) && !defined(MRB_INT32) && !defined(MRB_INT64)
+#if !defined(MRB_INT32) && !defined(MRB_INT64)
 # if defined(MRB_64BIT) && !defined(MRB_NAN_BOXING)
 /* Use 64bit integers on 64bit architecture (without MRB_NAN_BOXING) */
 #  define MRB_INT64
@@ -58,14 +101,8 @@
 # endif
 #endif
 
-/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT and MRB_WITHOUT_FLOAT */
-//#define MRB_NAN_BOXING
-
-/* define on big endian machines; used by MRB_NAN_BOXING */
-//#define MRB_ENDIAN_BIG
-
-/* represent mrb_value as a word (natural unit of data for the processor) */
-//#define MRB_WORD_BOXING
+/* call malloc_trim(0) from mrb_full_gc() */
+//#define MRB_USE_MALLOC_TRIM
 
 /* string class to handle UTF-8 encoding */
 //#define MRB_UTF8_STRING
@@ -76,12 +113,19 @@
 /* number of object per heap page */
 //#define MRB_HEAP_PAGE_SIZE 1024
 
-/* if _etext and _edata available, mruby can reduce memory used by symbols */
-//#define MRB_USE_ETEXT_EDATA
+/* define if your platform does not support etext, edata */
+//#define MRB_NO_DEFAULT_RO_DATA_P
 
-/* do not use __init_array_start to determine readonly data section;
-   effective only when MRB_USE_ETEXT_EDATA is defined */
-//#define MRB_NO_INIT_ARRAY_START
+/* 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
+
+/* 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
 
 /* turn off generational GC by default */
 //#define MRB_GC_TURN_OFF_GENERATIONAL
@@ -95,9 +139,6 @@
 /* page size of memory pool */
 //#define POOL_PAGE_SIZE 16000
 
-/* initial minimum size for string buffer */
-//#define MRB_STR_BUF_MIN_SIZE 128
-
 /* arena size */
 //#define MRB_GC_ARENA_SIZE 100
 
@@ -110,34 +151,82 @@
 /* fixed size state atexit stack */
 //#define MRB_FIXED_STATE_ATEXIT_STACK
 
-/* -DMRB_DISABLE_XXXX to drop following features */
-//#define MRB_DISABLE_STDIO /* use of stdio */
+/* -DMRB_NO_XXXX to drop following features */
+//#define MRB_NO_STDIO /* use of stdio */
 
-/* -DMRB_ENABLE_XXXX to enable following features */
-//#define MRB_ENABLE_DEBUG_HOOK /* hooks for debugger */
+/* -DMRB_USE_XXXX to enable following features */
+//#define MRB_USE_DEBUG_HOOK /* hooks for debugger */
+//#define MRB_USE_ALL_SYMBOLS /* Symbol.all_symbols */
+
+/* obsolete configurations */
+#ifdef MRB_METHOD_T_STRUCT
+# define MRB_USE_METHOD_T_STRUCT
+#endif
+#if defined(DISABLE_STDIO) || defined(MRB_DISABLE_STDIO)
+# define MRB_NO_STDIO
+#endif
+#ifdef MRB_DISABLE_DIRECT_THREADING
+# define MRB_NO_DIRECT_THREADING
+#endif
+#if defined(ENABLE_DEBUG) || defined(MRB_ENABLE_DEBUG_HOOK)
+# define MRB_USE_DEBUG_HOOK
+#endif
+#ifdef MRB_ENABLE_ALL_SYMBOLS
+# define MRB_USE_ALL_SYMBOLS
+#endif
+#ifdef MRB_ENABLE_CXX_ABI
+# define MRB_USE_CXX_ABI
+#endif
+#ifdef MRB_ENABLE_CXX_EXCEPTION
+# define MRB_USE_CXX_EXCEPTION
+#endif
 
 /* end of configuration */
 
-/* define MRB_DISABLE_XXXX from DISABLE_XXX (for compatibility) */
-#ifdef DISABLE_STDIO
-#define MRB_DISABLE_STDIO
-#endif
-
-/* define MRB_ENABLE_XXXX from ENABLE_XXX (for compatibility) */
-#ifdef ENABLE_DEBUG
-#define MRB_ENABLE_DEBUG_HOOK
-#endif
-
-#ifndef MRB_DISABLE_STDIO
+#ifndef MRB_NO_STDIO
 # include <stdio.h>
 #endif
 
-#ifndef FALSE
-# define FALSE 0
-#endif
+/*
+** mruby tuning profiles
+**/
 
-#ifndef TRUE
-# define TRUE 1
+/* A profile for micro controllers */
+#if defined(MRB_CONSTRAINED_BASELINE_PROFILE)
+# ifndef MRB_NO_METHOD_CACHE
+#  define MRB_NO_METHOD_CACHE
+# endif
+
+# ifndef KHASH_DEFAULT_SIZE
+#  define KHASH_DEFAULT_SIZE 16
+# endif
+
+# ifndef MRB_HEAP_PAGE_SIZE
+#  define MRB_HEAP_PAGE_SIZE 256
+# endif
+
+/* A profile for default mruby */
+#elif defined(MRB_BASELINE_PROFILE)
+
+/* A profile for desktop computers or workstations; rich memory! */
+#elif defined(MRB_MAIN_PROFILE)
+# ifndef MRB_METHOD_CACHE_SIZE
+#  define MRB_METHOD_CACHE_SIZE (1<<10)
+# endif
+
+# ifndef MRB_HEAP_PAGE_SIZE
+#  define MRB_HEAP_PAGE_SIZE 4096
+# endif
+
+/* A profile for server; mruby vm is long life */
+#elif defined(MRB_HIGH_PROFILE)
+# ifndef MRB_METHOD_CACHE_SIZE
+#  define MRB_METHOD_CACHE_SIZE (1<<12)
+# endif
+
+# ifndef MRB_HEAP_PAGE_SIZE
+#  define MRB_HEAP_PAGE_SIZE 4096
+# endif
 #endif
 
 #endif  /* MRUBYCONF_H */

include/mruby/array.h

@@ -1,5 +1,5 @@
-/*
-** mruby/array.h - Array class
+/**
+** @file mruby/array.h - Array class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -14,26 +14,37 @@
  */
 MRB_BEGIN_DECL
 
-
 typedef struct mrb_shared_array {
   int refcnt;
-  mrb_int len;
+  mrb_ssize len;
   mrb_value *ptr;
 } mrb_shared_array;
 
-#define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
+#if defined(MRB_32BIT) && defined(MRB_NO_BOXING) && !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)))
+mrb_static_assert(MRB_ARY_EMBED_LEN_MAX > 0, "MRB_ARY_EMBED_LEN_MAX > 0");
+#endif
+
 struct RArray {
   MRB_OBJECT_HEADER;
   union {
     struct {
-      mrb_int len;
+      mrb_ssize len;
       union {
-        mrb_int capa;
+        mrb_ssize capa;
         mrb_shared_array *shared;
       } aux;
       mrb_value *ptr;
     } heap;
-    mrb_value embed[MRB_ARY_EMBED_LEN_MAX];
+#ifndef MRB_ARY_NO_EMBED
+    mrb_value ary[MRB_ARY_EMBED_LEN_MAX];
+#endif
   } as;
 };
 
@@ -41,14 +52,22 @@ struct RArray {
 #define mrb_ary_value(p)  mrb_obj_value((void*)(p))
 #define RARRAY(v)  ((struct RArray*)(mrb_ptr(v)))
 
+#ifdef MRB_ARY_NO_EMBED
+#define ARY_EMBED_P(a) 0
+#define ARY_UNSET_EMBED_FLAG(a) (void)0
+#define ARY_EMBED_LEN(a) 0
+#define ARY_SET_EMBED_LEN(a,len) (void)0
+#define ARY_EMBED_PTR(a) 0
+#else
 #define MRB_ARY_EMBED_MASK  7
 #define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
 #define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK))
 #define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
 #define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
-#define ARY_EMBED_PTR(a) (&((a)->as.embed[0]))
+#define ARY_EMBED_PTR(a) ((a)->as.ary)
+#endif
 
-#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(a)->as.heap.len)
+#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
 #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
 #define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
 #define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
@@ -90,7 +109,7 @@ MRB_API mrb_value mrb_ary_new(mrb_state *mrb);
  *      Array[value1, value2, ...]
  *
  * @param mrb The mruby state reference.
- * @param size The numer of values.
+ * @param size The number of values.
  * @param vals The actual values.
  * @return The initialized array.
  */
@@ -159,20 +178,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
  *
@@ -183,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);
 
@@ -199,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
@@ -226,6 +229,24 @@ 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.
+ *
+ * Equivalent to:
+ *
+ *      ary[head, len] = rpl
+ *
+ * @param mrb The mruby state reference.
+ * @param self The array from which the value will be partiality replaced.
+ * @param head Beginning position of a replacement subsequence.
+ * @param len Length of a replacement subsequence.
+ * @param rpl The array of replacement elements.
+ *            It is possible to pass `mrb_undef_value()` instead of an empty array.
+ * @return The receiver array.
+ */
+MRB_API mrb_value mrb_ary_splice(mrb_state *mrb, mrb_value self, mrb_int head, mrb_int len, mrb_value rpl);
 
 /*
  * Shifts the first element from the array.
@@ -262,7 +283,7 @@ MRB_API mrb_value mrb_ary_clear(mrb_state *mrb, mrb_value self);
  *
  * @param mrb The mruby state reference.
  * @param ary The target array
- * @param sep The separater, can be NULL
+ * @param sep The separator, can be NULL
  */
 MRB_API mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep);
 
@@ -275,6 +296,9 @@ MRB_API mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep);
  */
 MRB_API mrb_value mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len);
 
+/* helper functions */
+mrb_value mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_ARRAY_H */

include/mruby/boxing_nan.h

@@ -1,5 +1,5 @@
-/*
-** mruby/boxing_nan.h - nan boxing mrb_value definition
+/**
+** @file mruby/boxing_nan.h - nan boxing mrb_value definition
 **
 ** See Copyright Notice in mruby.h
 */
@@ -7,96 +7,153 @@
 #ifndef MRUBY_BOXING_NAN_H
 #define MRUBY_BOXING_NAN_H
 
-#ifdef MRB_USE_FLOAT
-# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT conflict <<----
+#ifdef MRB_USE_FLOAT32
+# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT32 conflict <<----
 #endif
 
-#ifdef MRB_WITHOUT_FLOAT
-# error ---->> MRB_NAN_BOXING and MRB_WITHOUT_FLOAT conflict <<----
+#ifdef MRB_NO_FLOAT
+# error ---->> MRB_NAN_BOXING and MRB_NO_FLOAT conflict <<----
 #endif
 
-#ifdef MRB_INT64
-# error ---->> MRB_NAN_BOXING and MRB_INT64 conflict <<----
-#endif
+#define MRB_FIXNUM_MIN INT32_MIN
+#define MRB_FIXNUM_MAX INT32_MAX
 
-#define MRB_FIXNUM_SHIFT 0
-#define MRB_TT_HAS_BASIC MRB_TT_OBJECT
-
-#ifdef MRB_ENDIAN_BIG
-#define MRB_ENDIAN_LOHI(a,b) a b
-#else
-#define MRB_ENDIAN_LOHI(a,b) b a
-#endif
+enum mrb_nanbox_tt_inline {
+  MRB_NANBOX_TT_OBJECT = 0,
+  MRB_NANBOX_TT_INTEGER = 1,
+  MRB_NANBOX_TT_MISC = 2,
+  MRB_NANBOX_TT_CPTR = 3,
+};
 
 /* value representation by nan-boxing:
- *   float : FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF
- *   object: 111111111111TTTT TTPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP
- *   int   : 1111111111110001 0000000000000000 IIIIIIIIIIIIIIII IIIIIIIIIIIIIIII
- *   sym   : 1111111111110001 0100000000000000 SSSSSSSSSSSSSSSS SSSSSSSSSSSSSSSS
- * In order to get enough bit size to save TT, all pointers are shifted 2 bits
- * in the right direction. Also, TTTTTT is the mrb_vtype + 1;
+ *   float : SEEEEEEE EEEEFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF
+ *   +/-inf: S1111111 11110000 00000000 00000000 00000000 00000000 00000000 00000000
+ *   nan   : 01111111 11111000 00000000 00000000 00000000 00000000 00000000 00000000
+ *   int   : 01111111 11111001 00000000 00000000 IIIIIIII IIIIIIII IIIIIIII IIIIIIII
+ *   sym   : 01111111 11111110 00000000 00TTTTTT SSSSSSSS SSSSSSSS SSSSSSSS SSSSSSSS
+ *   misc  : 01111111 11111110 00000000 00TTTTTT 00000000 00000000 00000000 0000MMMM
+ *   object: 01111111 11111100 PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPP00
+ *   cptr  : 01111111 11111111 PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP
+ * Stored as O = R + 0x8004000000000000, retrieved as R = O - 0x8004000000000000.
+ * This makes pointers have all zeros in the top 32 bits.
  */
 typedef struct mrb_value {
-  union {
-    mrb_float f;
-    union {
-      void *p;
-      struct {
-        MRB_ENDIAN_LOHI(
-          uint32_t ttt;
-          ,union {
-            mrb_int i;
-            mrb_sym sym;
-          };
-        )
-      };
-    } value;
-  };
+  uint64_t u;
 } mrb_value;
 
-#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
+static inline mrb_float
+mrb_nan_boxing_value_float(mrb_value v)
+{
+  union {
+    mrb_float f;
+    uint64_t u;
+  } x;
+  x.u = v.u - 0x8004000000000000;
+  return x.f;
+}
 
-#define mrb_tt(o)       ((enum mrb_vtype)(((o).value.ttt & 0xfc000)>>14)-1)
-#define mrb_type(o)     (enum mrb_vtype)((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT)
-#define mrb_ptr(o)      ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2))
-#define mrb_float(o)    (o).f
-#define mrb_cptr(o)     mrb_ptr(o)
-#define mrb_fixnum(o)   (o).value.i
-#define mrb_symbol(o)   (o).value.sym
-
-#ifdef MRB_64BIT
-#define BOXNAN_SHIFT_LONG_POINTER(v) (((uintptr_t)(v)>>34)&0x3fff)
-#else
-#define BOXNAN_SHIFT_LONG_POINTER(v) 0
-#endif
-
-#define BOXNAN_SET_VALUE(o, tt, attr, v) do {\
-  (o).attr = (v);\
-  (o).value.ttt = 0xfff00000 | (((tt)+1)<<14);\
-} while (0)
-
-#define BOXNAN_SET_OBJ_VALUE(o, tt, v) do {\
-  (o).value.p = (void*)((uintptr_t)(v)>>2);\
-  (o).value.ttt = (0xfff00000|(((tt)+1)<<14)|BOXNAN_SHIFT_LONG_POINTER(v));\
-} while (0)
-
-#define SET_FLOAT_VALUE(mrb,r,v) do { \
-  if (v != v) { \
-    (r).value.ttt = 0x7ff80000; \
-    (r).value.i = 0; \
+#define SET_FLOAT_VALUE(mrb,r,f) do { \
+  union { \
+    mrb_float f; \
+    uint64_t u; \
+  } float_uint_union; \
+  if ((f) != (f)) { /* NaN */ \
+    float_uint_union.u = 0x7ff8000000000000UL; \
   } \
   else { \
-    (r).f = v; \
-  }} while(0)
+    float_uint_union.f = (f); \
+  } \
+  r.u = float_uint_union.u + 0x8004000000000000; \
+} while(0)
 
-#define SET_NIL_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
-#define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
-#define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
-#define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
-#define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v))
-#define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_OBJ_VALUE(r, MRB_TT_CPTR, v)
-#define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
+#define mrb_float_p(o) (((uint64_t)((o).u)&0xfffc000000000000) != 0)
+
+struct RInteger {
+  MRB_OBJECT_HEADER;
+  mrb_int i;
+};
+
+#define mrb_nb_tt(o) ((enum mrb_nanbox_tt_inline)((uint32_t)((o).u>>48)&3))
+
+MRB_INLINE enum mrb_vtype
+mrb_type(mrb_value o)
+{
+  if (mrb_float_p(o)) return MRB_TT_FLOAT;
+
+  int64_t u = o.u;
+  switch (mrb_nb_tt(o)) {
+  case MRB_NANBOX_TT_OBJECT: {
+    if (u == 0) return MRB_TT_FALSE;
+    return ((struct RBasic*)(uintptr_t)u)->tt;
+  }
+  case MRB_NANBOX_TT_INTEGER:
+    return MRB_TT_INTEGER;
+  case MRB_NANBOX_TT_MISC:
+    return (enum mrb_vtype)((uint32_t)(o.u >> 32) & 0x1f);
+  case MRB_NANBOX_TT_CPTR:
+    return MRB_TT_CPTR;
+  default:
+    /* never happen */
+    return MRB_TT_FLOAT;
+  }
+}
+
+#define NANBOX_SET_MISC_VALUE(r,t,i) NANBOX_SET_VALUE(r, MRB_NANBOX_TT_MISC, ((uint64_t)(t)<<32) | (i))
+
+#define mrb_float(o) mrb_nan_boxing_value_float(o)
+#ifdef MRB_INT64
+/*
+#ifdef MRB_32BIT
+#define mrb_fixnum(o)  ((mrb_int)((intptr_t)0xffffffffffff&((o).u))|(((o).u & 0x800000000000)?0xffff000000000000:0))
+#else
+#define mrb_fixnum(o)  ((mrb_int)(int32_t)((o).u))
+#endif
+*/
+
+#define mrb_fixnum(o)  ((mrb_int)(int32_t)((o).u))
+
+static inline mrb_int
+mrb_nan_boxing_value_int(mrb_value v)
+{
+  uint64_t u = v.u;
+  if (mrb_nb_tt(v)==MRB_NANBOX_TT_OBJECT) {
+    struct RInteger *p = (struct RInteger*)(uintptr_t)u;
+    return p->i;
+  }
+  return mrb_fixnum(v);
+}
+#define mrb_integer(o) mrb_nan_boxing_value_int(o)
+#else
+#define mrb_fixnum(o)  ((mrb_int)(((uintptr_t)0xffffffff)&((o).u)))
+#define mrb_integer(o) mrb_fixnum(o)
+#endif
+#define mrb_symbol(o)  ((mrb_sym)((uintptr_t)0xffffffff)&((o).u))
+#define mrb_ptr(o)     ((void*)(uintptr_t)(o).u)
+#define mrb_cptr(o)    ((void*)(uintptr_t)(0xffffffffffffULL&(o).u))
+
+#define NANBOX_SET_VALUE(o, tt, v) do { \
+  (o).u = ((uint64_t)(tt)<<48) | ((uint64_t)(v)); \
+} while (0)
+
+#define SET_NIL_VALUE(r) ((r).u = 0)
+#define SET_FALSE_VALUE(r) NANBOX_SET_MISC_VALUE(r, MRB_TT_FALSE, 1)
+#define SET_TRUE_VALUE(r) NANBOX_SET_MISC_VALUE(r, MRB_TT_TRUE, 1)
+#define SET_BOOL_VALUE(r,b) NANBOX_SET_MISC_VALUE(r, (b) ? MRB_TT_TRUE : MRB_TT_FALSE, 1)
+#ifdef MRB_INT64
+MRB_API mrb_value mrb_boxing_int_value(struct mrb_state*, mrb_int);
+#define SET_INT_VALUE(mrb, r, n) ((r) = mrb_boxing_int_value(mrb, n))
+#else
+#define SET_INT_VALUE(mrb, r, n) SET_FIXNUM_VALUE(r, n)
+#endif
+#define SET_FIXNUM_VALUE(r,n) NANBOX_SET_VALUE(r, MRB_NANBOX_TT_INTEGER, (uint32_t)(n))
+#define SET_SYM_VALUE(r,v) NANBOX_SET_MISC_VALUE(r, MRB_TT_SYMBOL, (uint32_t)(v))
+#define SET_OBJ_VALUE(r,v) do {(r).u = (uint64_t)(uintptr_t)(v);} while (0)
+#define SET_CPTR_VALUE(mrb,r,v) NANBOX_SET_VALUE(r, MRB_NANBOX_TT_CPTR, (uint64_t)(uintptr_t)(v) & 0x0000ffffffffffffULL)
+#define SET_UNDEF_VALUE(r) NANBOX_SET_MISC_VALUE(r, MRB_TT_UNDEF, 4)
+
+#define mrb_immediate_p(o) ((mrb_float_p(o) || mrb_nb_tt(o) != MRB_NANBOX_TT_OBJECT) || (o).u == 0)
+#define mrb_nil_p(o)  ((o).u == 0)
+#define mrb_false_p(o) (mrb_type(o) == MRB_TT_FALSE || (o).u == 0)
+#define mrb_fixnum_p(o) (!mrb_float_p(o) && mrb_nb_tt(o)==MRB_NANBOX_TT_INTEGER)
 
 #endif  /* MRUBY_BOXING_NAN_H */

include/mruby/boxing_no.h

@@ -1,5 +1,5 @@
-/*
-** mruby/boxing_no.h - unboxed mrb_value definition
+/**
+** @file mruby/boxing_no.h - unboxed mrb_value definition
 **
 ** See Copyright Notice in mruby.h
 */
@@ -8,30 +8,31 @@
 #define MRUBY_BOXING_NO_H
 
 #define MRB_FIXNUM_SHIFT 0
-#define MRB_TT_HAS_BASIC MRB_TT_OBJECT
+#define MRB_SYMBOL_SHIFT 0
+#define MRB_FIXNUM_MIN MRB_INT_MIN
+#define MRB_FIXNUM_MAX MRB_INT_MAX
+
+union mrb_value_union {
+#ifndef MRB_NO_FLOAT
+  mrb_float f;
+#endif
+  void *p;
+  mrb_int i;
+  mrb_sym sym;
+};
 
 typedef struct mrb_value {
-  union {
-#ifndef MRB_WITHOUT_FLOAT
-    mrb_float f;
-#endif
-    void *p;
-    mrb_int i;
-    mrb_sym sym;
-  } value;
+  union mrb_value_union value;
   enum mrb_vtype tt;
 } mrb_value;
 
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
-#endif
-
 #define mrb_ptr(o)      (o).value.p
 #define mrb_cptr(o)     mrb_ptr(o)
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #define mrb_float(o)    (o).value.f
 #endif
 #define mrb_fixnum(o)   (o).value.i
+#define mrb_integer(o)  mrb_fixnum(o)
 #define mrb_symbol(o)   (o).value.sym
 #define mrb_type(o)     (o).tt
 
@@ -44,8 +45,9 @@ typedef struct mrb_value {
 #define SET_FALSE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
 #define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
 #define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#ifndef MRB_WITHOUT_FLOAT
+#define SET_INT_VALUE(mrb,r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#define SET_FIXNUM_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#ifndef MRB_NO_FLOAT
 #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v))
 #endif
 #define SET_SYM_VALUE(r,v) BOXNIX_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))

include/mruby/boxing_word.h

@@ -1,5 +1,5 @@
-/*
-** mruby/boxing_word.h - word boxing mrb_value definition
+/**
+** @file mruby/boxing_word.h - word boxing mrb_value definition
 **
 ** See Copyright Notice in mruby.h
 */
@@ -7,138 +7,225 @@
 #ifndef MRUBY_BOXING_WORD_H
 #define MRUBY_BOXING_WORD_H
 
-#if defined(MRB_INT16)
-# error MRB_INT16 is too small for MRB_WORD_BOXING.
+#if defined(MRB_32BIT) && !defined(MRB_USE_FLOAT32) && !defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
+# define MRB_WORDBOX_NO_FLOAT_TRUNCATE
 #endif
 
-#if defined(MRB_INT64) && !defined(MRB_64BIT)
-#error MRB_INT64 cannot be used with MRB_WORD_BOXING in 32-bit mode.
-#endif
-
-#ifndef MRB_WITHOUT_FLOAT
+#if !defined(MRB_NO_FLOAT) && defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
 struct RFloat {
   MRB_OBJECT_HEADER;
   mrb_float f;
 };
 #endif
 
-struct RCptr {
+struct RInteger {
   MRB_OBJECT_HEADER;
-  void *p;
+  mrb_int i;
 };
 
-#define MRB_FIXNUM_SHIFT 1
-#ifdef MRB_WITHOUT_FLOAT
-#define MRB_TT_HAS_BASIC MRB_TT_CPTR
-#else
-#define MRB_TT_HAS_BASIC MRB_TT_FLOAT
-#endif
-
 enum mrb_special_consts {
-  MRB_Qnil    = 0,
-  MRB_Qfalse  = 2,
-  MRB_Qtrue   = 4,
-  MRB_Qundef  = 6,
+  MRB_Qnil    =  0,
+  MRB_Qfalse  =  4,
+  MRB_Qtrue   = 12,
+  MRB_Qundef  = 20,
 };
 
-#define MRB_FIXNUM_FLAG   0x01
-#define MRB_SYMBOL_FLAG   0x0e
-#define MRB_SPECIAL_SHIFT 8
-
-#if defined(MRB_64BIT)
-#define MRB_SYMBOL_BITSIZE  (sizeof(mrb_sym) * CHAR_BIT)
-#define MRB_SYMBOL_MAX      UINT32_MAX
+#if defined(MRB_64BIT) && defined(MRB_INT32)
+#define MRB_FIXNUM_SHIFT        0
 #else
-#define MRB_SYMBOL_BITSIZE  (sizeof(mrb_sym) * CHAR_BIT - MRB_SPECIAL_SHIFT)
-#define MRB_SYMBOL_MAX      (UINT32_MAX >> MRB_SPECIAL_SHIFT)
+#define MRB_FIXNUM_SHIFT        WORDBOX_FIXNUM_SHIFT
+#endif
+#define MRB_SYMBOL_SHIFT        WORDBOX_SYMBOL_SHIFT
+
+#if defined(MRB_64BIT) && defined(MRB_INT64)
+# define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
+#else
+# define MRB_FIXNUM_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
 #endif
 
-typedef union mrb_value {
-  union {
-    void *p;
-    struct {
-      unsigned int i_flag : MRB_FIXNUM_SHIFT;
-      mrb_int i : (MRB_INT_BIT - MRB_FIXNUM_SHIFT);
-    };
-    struct {
-      unsigned int sym_flag : MRB_SPECIAL_SHIFT;
-      mrb_sym sym : MRB_SYMBOL_BITSIZE;
-    };
-    struct RBasic *bp;
-#ifndef MRB_WITHOUT_FLOAT
-    struct RFloat *fp;
+#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 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
-    struct RCptr *vp;
-  } value;
-  unsigned long w;
+#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 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 (MRB_WORDBOX_NO_FLOAT_TRUNCATE):
+ *   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
+ *   object: ...PPPP P000 (any bits are 1)
+ */
+typedef struct mrb_value {
+  uintptr_t w;
 } mrb_value;
 
-MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
-#ifndef MRB_WITHOUT_FLOAT
-MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
-MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float);
+union mrb_value_ {
+  void *p;
+  struct RBasic *bp;
+#ifndef MRB_NO_FLOAT
+#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE
+  mrb_float f;
+#else
+  struct RFloat *fp;
 #endif
-
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_pool(mrb,f) mrb_word_boxing_float_pool(mrb,f)
 #endif
+  struct RInteger *ip;
+  struct RCptr *vp;
+  uintptr_t w;
+  mrb_value value;
+};
 
-#define mrb_ptr(o)     (o).value.p
-#define mrb_cptr(o)    (o).value.vp->p
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float(o)   (o).value.fp->f
-#endif
-#define mrb_fixnum(o)  ((mrb_int)(o).value.i)
-#define mrb_symbol(o)  (o).value.sym
+mrb_static_assert(sizeof(mrb_value) == sizeof(union mrb_value_));
 
-static inline enum mrb_vtype
-mrb_type(mrb_value o)
+static inline union mrb_value_
+mrb_val_union(mrb_value v)
 {
-  switch (o.w) {
-  case MRB_Qfalse:
-  case MRB_Qnil:
-    return MRB_TT_FALSE;
-  case MRB_Qtrue:
-    return MRB_TT_TRUE;
-  case MRB_Qundef:
-    return MRB_TT_UNDEF;
-  }
-  if (o.value.i_flag == MRB_FIXNUM_FLAG) {
-    return MRB_TT_FIXNUM;
-  }
-  if (o.value.sym_flag == MRB_SYMBOL_FLAG) {
-    return MRB_TT_SYMBOL;
-  }
-  return o.value.bp->tt;
+  union mrb_value_ x;
+  x.value = v;
+  return x;
 }
 
-#define mrb_bool(o)    ((o).w != MRB_Qnil && (o).w != MRB_Qfalse)
-#define mrb_fixnum_p(o) ((o).value.i_flag == MRB_FIXNUM_FLAG)
+MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
+#ifndef MRB_NO_FLOAT
+MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
+#endif
+MRB_API mrb_value mrb_boxing_int_value(struct mrb_state*, mrb_int);
+
+#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
+#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) >> 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)
+#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) 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 BOXWORD_SET_VALUE(o, ttt, attr, v) do { \
-  switch (ttt) {\
-  case MRB_TT_FALSE:  (o).w = (v) ? MRB_Qfalse : MRB_Qnil; break;\
-  case MRB_TT_TRUE:   (o).w = MRB_Qtrue; break;\
-  case MRB_TT_UNDEF:  (o).w = MRB_Qundef; break;\
-  case MRB_TT_FIXNUM: (o).w = 0;(o).value.i_flag = MRB_FIXNUM_FLAG; (o).attr = (v); break;\
-  case MRB_TT_SYMBOL: (o).w = 0;(o).value.sym_flag = MRB_SYMBOL_FLAG; (o).attr = (v); break;\
-  default:            (o).w = 0; (o).attr = (v); if ((o).value.bp) (o).value.bp->tt = ttt; break;\
-  }\
-} while (0)
-
-#ifndef MRB_WITHOUT_FLOAT
-#define SET_FLOAT_VALUE(mrb,r,v) r = mrb_word_boxing_float_value(mrb, v)
+#define mrb_false_p(o) ((o).w == MRB_Qfalse)
+#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
+#ifndef MRB_NO_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
-#define SET_CPTR_VALUE(mrb,r,v) r = mrb_word_boxing_cptr_value(mrb, v)
-#define SET_NIL_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
-#define SET_FALSE_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
-#define SET_TRUE_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
-#define SET_BOOL_VALUE(r,b) BOXWORD_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXWORD_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#define SET_SYM_VALUE(r,v) BOXWORD_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
-#define SET_OBJ_VALUE(r,v) BOXWORD_SET_VALUE(r, (((struct RObject*)(v))->tt), value.p, (v))
-#define SET_UNDEF_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
+#endif
+#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))
+#endif
+#define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_word_boxing_cptr_value(mrb, v))
+#define SET_UNDEF_VALUE(r) ((r).w = MRB_Qundef)
+#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
+#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
+#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
+#define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
+#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
+#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
+mrb_type(mrb_value o)
+{
+  return !mrb_bool(o)    ? MRB_TT_FALSE :
+         mrb_true_p(o)   ? MRB_TT_TRUE :
+         mrb_fixnum_p(o) ? MRB_TT_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;
+}
 
 #endif  /* MRUBY_BOXING_WORD_H */

include/mruby/class.h

@@ -1,5 +1,5 @@
-/*
-** mruby/class.h - Class class
+/**
+** @file mruby/class.h - Class class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -17,13 +17,13 @@ MRB_BEGIN_DECL
 struct RClass {
   MRB_OBJECT_HEADER;
   struct iv_tbl *iv;
-  struct kh_mt *mt;
+  struct mt_tbl *mt;
   struct RClass *super;
 };
 
 #define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
 
-static inline struct RClass*
+MRB_INLINE struct RClass*
 mrb_class(mrb_state *mrb, mrb_value v)
 {
   switch (mrb_type(v)) {
@@ -35,9 +35,9 @@ mrb_class(mrb_state *mrb, mrb_value v)
     return mrb->true_class;
   case MRB_TT_SYMBOL:
     return mrb->symbol_class;
-  case MRB_TT_FIXNUM:
-    return mrb->fixnum_class;
-#ifndef MRB_WITHOUT_FLOAT
+  case MRB_TT_INTEGER:
+    return mrb->integer_class;
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
     return mrb->float_class;
 #endif
@@ -61,37 +61,48 @@ mrb_class(mrb_state *mrb, mrb_value v)
 #define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
 #define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
 #define MRB_CLASS_ORIGIN(c) do {\
-  if (c->flags & MRB_FL_CLASS_IS_PREPENDED) {\
-    c = c->super;\
-    while (!(c->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
-      c = c->super;\
+  if ((c)->flags & MRB_FL_CLASS_IS_PREPENDED) {\
+    (c) = (c)->super;\
+    while (!((c)->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
+      (c) = (c)->super;\
     }\
   }\
 } while (0)
 #define MRB_FL_CLASS_IS_INHERITED (1 << 17)
 #define MRB_INSTANCE_TT_MASK (0xFF)
-#define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~MRB_INSTANCE_TT_MASK) | (char)tt)
-#define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & MRB_INSTANCE_TT_MASK)
+#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
+#define MRB_INSTANCE_TT(c) (enum mrb_vtype)((c)->flags & MRB_INSTANCE_TT_MASK)
 
-MRB_API struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*);
-MRB_API struct RClass* mrb_define_module_id(mrb_state*, mrb_sym);
-MRB_API struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym);
-MRB_API struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym);
+struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym);
+struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym);
 MRB_API void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, mrb_method_t);
-MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
 MRB_API void mrb_alias_method(mrb_state*, struct RClass *c, mrb_sym a, mrb_sym b);
+MRB_API void mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym sym);
 
 MRB_API mrb_method_t mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym);
 MRB_API mrb_method_t mrb_method_search(mrb_state*, struct RClass*, mrb_sym);
 
 MRB_API struct RClass* mrb_class_real(struct RClass* cl);
+mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
 
 void mrb_class_name_class(mrb_state*, struct RClass*, struct RClass*, mrb_sym);
+mrb_bool mrb_const_name_p(mrb_state*, const char*, mrb_int);
 mrb_value mrb_class_find_path(mrb_state*, struct RClass*);
+mrb_value mrb_mod_to_s(mrb_state*, mrb_value);
 void mrb_gc_mark_mt(mrb_state*, struct RClass*);
 size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
 void mrb_gc_free_mt(mrb_state*, struct RClass*);
 
+#ifndef MRB_NO_METHOD_CACHE
+void mrb_mc_clear_by_class(mrb_state *mrb, struct RClass* c);
+#else
+#define mrb_mc_clear_by_class(mrb,c)
+#endif
+
+/* return non zero to break the loop */
+typedef int (mrb_mt_foreach_func)(mrb_state*,mrb_sym,mrb_method_t,void*);
+MRB_API void mrb_mt_foreach(mrb_state*, struct RClass*, mrb_mt_foreach_func*, void*);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_CLASS_H */

include/mruby/common.h

@@ -1,5 +1,5 @@
-/*
-**"common.h - mruby common platform definition"
+/**
+** @file common.h - mruby common platform definition"
 **
 ** See Copyright Notice in mruby.h
 */
@@ -14,7 +14,7 @@
 #endif
 
 #ifdef __cplusplus
-#ifdef MRB_ENABLE_CXX_ABI
+#ifdef MRB_USE_CXX_ABI
 #define MRB_BEGIN_DECL
 #define MRB_END_DECL
 #else
@@ -28,13 +28,19 @@
 # define MRB_END_DECL
 #endif
 
+#include <sys/types.h>
+#if defined _MSC_VER
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
 /**
  * Shared compiler macros
  */
 MRB_BEGIN_DECL
 
 /** Declare a function that never returns. */
-#if __STDC_VERSION__ >= 201112L
+#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L
 # define mrb_noreturn _Noreturn
 #elif defined __GNUC__ && !defined __STRICT_ANSI__
 # define mrb_noreturn __attribute__((noreturn))
@@ -54,14 +60,15 @@ MRB_BEGIN_DECL
 #endif
 
 /** Declare a function as always inlined. */
-#if defined(_MSC_VER)
-# define MRB_INLINE static __inline
-#else
-# define MRB_INLINE static inline
+#if defined _MSC_VER && _MSC_VER < 1900
+# ifndef __cplusplus
+#  define inline __inline
+# endif
 #endif
-
+#define MRB_INLINE static inline
 
 /** Declare a public MRuby API function. */
+#ifndef MRB_API
 #if defined(MRB_BUILD_AS_DLL)
 #if defined(MRB_CORE) || defined(MRB_LIB)
 # define MRB_API __declspec(dllexport)
@@ -71,6 +78,20 @@ MRB_BEGIN_DECL
 #else
 # define MRB_API extern
 #endif
+#endif
+
+/** Declare mingw versions */
+#if defined(__MINGW32__) || defined(__MINGW64__)
+# include <_mingw.h>
+# if defined(__MINGW64_VERSION_MAJOR)
+#  define MRB_MINGW64_VERSION  (__MINGW64_VERSION_MAJOR * 1000 + __MINGW64_VERSION_MINOR)
+# elif defined(__MINGW32_MAJOR_VERSION)
+#  define MRB_MINGW32_VERSION  (__MINGW32_MAJOR_VERSION * 1000 + __MINGW32_MINOR_VERSION)
+# endif
+# if defined(__MINGW32__) && !defined(__MINGW64__)
+#   define MRB_MINGW32_LEGACY
+# endif
+#endif
 
 MRB_END_DECL
 

include/mruby/compile.h

@@ -1,5 +1,5 @@
-/*
-** mruby/compile.h - mruby parser
+/**
+** @file mruby/compile.h - mruby parser
 **
 ** See Copyright Notice in mruby.h
 */
@@ -16,15 +16,13 @@ MRB_BEGIN_DECL
 
 #include <mruby.h>
 
-struct mrb_jmpbuf;
-
 struct mrb_parser_state;
 /* load context */
 typedef struct mrbc_context {
   mrb_sym *syms;
   int slen;
   char *filename;
-  short lineno;
+  uint16_t lineno;
   int (*partial_hook)(struct mrb_parser_state*);
   void *partial_data;
   struct RClass *target_class;
@@ -33,7 +31,8 @@ typedef struct mrbc_context {
   mrb_bool no_exec:1;
   mrb_bool keep_lv:1;
   mrb_bool no_optimize:1;
-  mrb_bool on_eval:1;
+  mrb_bool no_ext_ops:1;
+  const struct RProc *upper;
 
   size_t parser_nerr;
 } mrbc_context;
@@ -42,6 +41,7 @@ MRB_API mrbc_context* mrbc_context_new(mrb_state *mrb);
 MRB_API void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt);
 MRB_API const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s);
 MRB_API void mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*partial_hook)(struct mrb_parser_state*), void*data);
+MRB_API void mrbc_cleanup_local_variables(mrb_state *mrb, mrbc_context *c);
 
 /* AST node structure */
 typedef struct mrb_ast_node {
@@ -57,7 +57,7 @@ enum mrb_lex_state_enum {
   EXPR_ENDFN,                 /* ditto, and unbound braces. */
   EXPR_ARG,                   /* newline significant, +/- is an operator. */
   EXPR_CMDARG,                /* newline significant, +/- is an operator. */
-  EXPR_MID,                   /* newline significant, +/- is an operator. */
+  EXPR_MID,                   /* newline significant, +/- is a sign. */
   EXPR_FNAME,                 /* ignore newline, no reserved words. */
   EXPR_DOT,                   /* right after '.' or '::', no reserved words. */
   EXPR_CLASS,                 /* immediate after 'class', no here document. */
@@ -67,7 +67,7 @@ enum mrb_lex_state_enum {
 
 /* saved error message */
 struct mrb_parser_message {
-  int lineno;
+  uint16_t lineno;
   int column;
   char* message;
 };
@@ -98,6 +98,9 @@ enum mrb_string_type {
 /* heredoc structure */
 struct mrb_parser_heredoc_info {
   mrb_bool allow_indent:1;
+  mrb_bool remove_indent:1;
+  size_t indent;
+  mrb_ast_node *indented;
   mrb_bool line_head:1;
   enum mrb_string_type type;
   const char *term;
@@ -105,7 +108,7 @@ struct mrb_parser_heredoc_info {
   mrb_ast_node *doc;
 };
 
-#define MRB_PARSER_TOKBUF_MAX 65536
+#define MRB_PARSER_TOKBUF_MAX (UINT16_MAX-1)
 #define MRB_PARSER_TOKBUF_SIZE 256
 
 /* parser structure */
@@ -114,12 +117,13 @@ struct mrb_parser_state {
   struct mrb_pool *pool;
   mrb_ast_node *cells;
   const char *s, *send;
-#ifndef MRB_DISABLE_STDIO
+#ifndef MRB_NO_STDIO
+  /* If both f and s are non-null, it will be taken preferentially from s until s < send. */
   FILE *f;
 #endif
   mrbc_context *cxt;
-  char const *filename;
-  int lineno;
+  mrb_sym filename_sym;
+  uint16_t lineno;
   int column;
 
   enum mrb_lex_state_enum lstate;
@@ -151,8 +155,9 @@ struct mrb_parser_state {
   mrb_ast_node *tree;
 
   mrb_bool no_optimize:1;
-  mrb_bool on_eval:1;
   mrb_bool capture_errors:1;
+  mrb_bool no_ext_ops:1;
+  const struct RProc *upper;
   struct mrb_parser_message error_buffer[10];
   struct mrb_parser_message warn_buffer[10];
 
@@ -160,7 +165,7 @@ struct mrb_parser_state {
   uint16_t filename_table_length;
   uint16_t current_filename_index;
 
-  struct mrb_jmpbuf* jmp;
+  mrb_ast_node *nvars;
 };
 
 MRB_API struct mrb_parser_state* mrb_parser_new(mrb_state*);
@@ -168,10 +173,10 @@ MRB_API void mrb_parser_free(struct mrb_parser_state*);
 MRB_API void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
 
 MRB_API void mrb_parser_set_filename(struct mrb_parser_state*, char const*);
-MRB_API char const* mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
+MRB_API mrb_sym mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
 
 /* utility functions */
-#ifndef MRB_DISABLE_STDIO
+#ifndef MRB_NO_STDIO
 MRB_API struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
 #endif
 MRB_API struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*);
@@ -179,10 +184,19 @@ MRB_API struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,size_t
 MRB_API struct RProc* mrb_generate_code(mrb_state*, struct mrb_parser_state*);
 MRB_API mrb_value mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c);
 
-/* program load functions */
-#ifndef MRB_DISABLE_STDIO
+/** program load functions
+* Please note! Currently due to interactions with the GC calling these functions will
+* leak one RProc object per function call.
+* To prevent this save the current memory arena before calling and restore the arena
+* right after, like so
+* int ai = mrb_gc_arena_save(mrb);
+* mrb_value status = mrb_load_string(mrb, buffer);
+* mrb_gc_arena_restore(mrb, ai);
+*/
+#ifndef MRB_NO_STDIO
 MRB_API mrb_value mrb_load_file(mrb_state*,FILE*);
 MRB_API mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);
+MRB_API mrb_value mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrbc_context *c);
 #endif
 MRB_API mrb_value mrb_load_string(mrb_state *mrb, const char *s);
 MRB_API mrb_value mrb_load_nstring(mrb_state *mrb, const char *s, size_t len);

include/mruby/data.h

@@ -1,5 +1,5 @@
-/*
-** mruby/data.h - Data class
+/**
+** @file mruby/data.h - Data class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -39,10 +39,11 @@ MRB_API struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass
 #define Data_Wrap_Struct(mrb,klass,type,ptr)\
   mrb_data_object_alloc(mrb,klass,ptr,type)
 
-#define Data_Make_Struct(mrb,klass,strct,type,sval,data) do { \
-  sval = mrb_malloc(mrb, sizeof(strct));                     \
-  { static const strct zero = { 0 }; *sval = zero; };\
-  data = Data_Wrap_Struct(mrb,klass,type,sval);\
+#define Data_Make_Struct(mrb,klass,strct,type,sval,data_obj) do { \
+  (data_obj) = Data_Wrap_Struct(mrb,klass,type,NULL);\
+  (sval) = (strct *)mrb_malloc(mrb, sizeof(strct));                     \
+  { static const strct zero = { 0 }; *(sval) = zero; };\
+  (data_obj)->data = (sval);\
 } while (0)
 
 #define RDATA(obj)         ((struct RData *)(mrb_ptr(obj)))
@@ -62,10 +63,10 @@ MRB_API void *mrb_data_check_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_t
   *(void**)&sval = mrb_data_get_ptr(mrb, obj, type); \
 } while (0)
 
-static inline void
+MRB_INLINE void
 mrb_data_init(mrb_value v, void *ptr, const mrb_data_type *type)
 {
-  mrb_assert(mrb_type(v) == MRB_TT_DATA);
+  mrb_assert(mrb_data_p(v));
   DATA_PTR(v) = ptr;
   DATA_TYPE(v) = type;
 }

include/mruby/debug.h

@@ -1,5 +1,5 @@
-/*
-** mruby/debug.h - mruby debug info
+/**
+** @file mruby/debug.h - mruby debug info
 **
 ** See Copyright Notice in mruby.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 {
@@ -26,14 +27,14 @@ typedef struct mrb_irep_debug_info_line {
 
 typedef struct mrb_irep_debug_info_file {
   uint32_t start_pos;
-  const char *filename;
   mrb_sym filename_sym;
   uint32_t line_entry_count;
   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;
 
@@ -47,13 +48,13 @@ typedef struct mrb_irep_debug_info {
  * get line from irep's debug info and program counter
  * @return returns NULL if not found
  */
-MRB_API const char *mrb_debug_get_filename(mrb_irep *irep, ptrdiff_t pc);
+MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep, uint32_t pc);
 
 /*
  * get line from irep's debug info and program counter
  * @return returns -1 if not found
  */
-MRB_API int32_t mrb_debug_get_line(mrb_irep *irep, ptrdiff_t pc);
+MRB_API int32_t mrb_debug_get_line(mrb_state *mrb, const mrb_irep *irep, uint32_t pc);
 
 MRB_API mrb_irep_debug_info *mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep);
 MRB_API mrb_irep_debug_info_file *mrb_debug_info_append_file(