Update version and release date. (mruby 3.3.0 (2024-02-14))

For example, the following code was crashing.

```c
#include <mruby.h>
#include <mruby/compile.h>
#include <mruby/proc.h>

int
main(int argc, char *argv[])
{
  mrb_state *mrb = mrb_open();

  mrb_value fiber = mrb_load_string(mrb, "Fiber.new { Fiber.new { 12345.6789 }.transfer }");
  mrb_value res = mrb_fiber_resume(mrb, fiber, 0, NULL);
  mrb_p(mrb, res);

  mrb_close(mrb);

  return 0;
}
```

.dockerignore

@@ -0,0 +1,14 @@
+.DS_Store
+.idea
+.vscode
+*.bak
+*.iml
+*.ipr
+*.swp
+*.tmp
+
+/.yardoc
+/bin
+/build
+/doc/api
+/doc/capi

.editorconfig

@@ -0,0 +1,34 @@
+# 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 = 2
+indent_style = space
+insert_final_newline = true
+tab_width = 8
+trim_trailing_whitespace = true
+
+[{Makefile,Makefile.*,makefile,*.mk}]
+indent_style = tab
+#max_line_length = 80
+
+#[*.{c,cc,C,cxx,cpp,h,hh,H,hxx,hpp,inc,y}]
+#max_line_length = 120
+
+#[{*.rb,Rakefile,rakefile,*.rake,*.gemspec,*.gembox}]
+#max_line_length = 120
+
+# limitation to US-ASCII
+[*.bat]
+end_of_line = crlf
+#max_line_length = 80
+
+#[*.{yaml,yml}]
+
+#[*.md]

.git-blame-ignore-revs

@@ -0,0 +1,6 @@
+# Extend the tab with 8 whitespace
+6fc5dc986a5ffc1a74c63ad0617ea1dcc10d3cdd
+# reformatted doc/opcode.md
+61e8a540869c57ebddac53cf9d243db407d57fff
+# reindent parse.y
+650ffb9d8410e1ae2206890ef6e2a8643c600454

.gitattributes

@@ -0,0 +1,4 @@
+*       text=auto eol=lf
+*.bat   text eol=crlf
+*.cmd   text eol=crlf
+*.png   binary

.github/dependabot.yml

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

.github/labeler.yml

@@ -0,0 +1,50 @@
+benchmark:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - benchmark/**/*
+build:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - Makefile
+              - Rakefile
+              - build_config/**/*
+              - lib/**/*
+              - tasks/**/*
+core:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - include/**/*
+              - mrblib/**/*
+              - src/**/*
+              - test/**/*
+doc:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - CONTRIBUTING.md
+              - LEGAL
+              - LICENSE
+              - NEWS
+              - README.md
+              - SECURITY.md
+              - TODO.md
+              - doc/**/*
+              - examples/**/*
+github:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - .github/**/*
+mrbgems:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - mrbgems/**/*
+oss-fuzz:
+  - any:
+      - changed-files:
+          - any-glob-to-any-file:
+              - oss-fuzz/**/*

.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,29 @@
+# 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
+
+# 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
+
+# MD033/no-inline-html - Inline HTML
+MD033: false
+
+# MD040 fenced-code-language - Fenced code blocks should have a language specified
+MD040: false
+
+# MD041 first-line-heading/first-line-h1 - First line in a file should be a top-level heading
+MD041: false

.github/linters/.yaml-lint.yml

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

.github/workflows/build.yml

@@ -2,24 +2,33 @@ name: Build & Test
 
 on: [push, pull_request]
 
+permissions:
+  contents: read
+
 jobs:
-  Check-Skip:
-    if: |
-      !contains(github.event.head_commit.message, '[ci skip]') &&
-      !contains(github.event.head_commit.message, '[skip ci]') &&
-      !contains(github.event.head_commit.message, '[skip gha]')
-    runs-on: ubuntu-latest
-    steps:
-      - run: echo not skip
-
-  Ubuntu-1604:
-    needs: Check-Skip
-    runs-on: ubuntu-16.04
+  GCC-CLANG:
+    name: "${{ matrix.os }}-${{ matrix.altname || matrix.cc }}"
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      max-parallel: 8
+      matrix:
+        include:
+          - {os: ubuntu-22.04, cc: gcc, cxx: g++}
+          - {os: ubuntu-22.04, cc: clang, cxx: clang++}
+          - {os: ubuntu-20.04, cc: gcc, cxx: g++}
+          - {os: ubuntu-20.04, cc: clang, cxx: clang++}
+          - {os: macos-latest, cc: clang, cxx: clang++}
+          - {os: windows-latest, cc: gcc, cxx: g++, altname: "mingw-gcc"}
     env:
       MRUBY_CONFIG: ci/gcc-clang
-      CC: gcc
+      CC: ${{ matrix.cc }}
+      CXX: ${{ matrix.cxx }}
+      LD: ${{ matrix.cc }}
     steps:
-      - uses: actions/checkout@v2
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v4
       - name: Ruby version
         run: ruby -v
       - name: Compiler version
@@ -27,123 +36,18 @@ jobs:
       - name: Build and test
         run: rake -m test:build && rake test:run
 
-  Ubuntu-1804-gcc:
-    needs: Check-Skip
-    runs-on: ubuntu-18.04
-    env:
-      MRUBY_CONFIG: ci/gcc-clang
-      CC: gcc
-    steps:
-      - uses: actions/checkout@v2
-      - 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:
-    needs: Check-Skip
-    runs-on: ubuntu-18.04
-    env:
-      MRUBY_CONFIG: ci/gcc-clang
-      CC: clang
-    steps:
-      - uses: actions/checkout@v2
-      - 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:
-    needs: Check-Skip
-    runs-on: macos-latest
-    env:
-      MRUBY_CONFIG: ci/gcc-clang
-      CC: clang
-    steps:
-      - uses: actions/checkout@v2
-      - 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:
-    needs: Check-Skip
-    runs-on: windows-latest
-    env:
-      MRUBY_CONFIG: ci/gcc-clang
-      CC: gcc
-    steps:
-      - uses: actions/checkout@v2
-      - 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:
-    needs: Check-Skip
-    runs-on: windows-latest
-    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
-      - uses: actions/cache@v2
-        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:
-    needs: Check-Skip
-    runs-on: windows-latest
+    runs-on: windows-2022
+    timeout-minutes: 10
     env:
       MRUBY_CONFIG: ci/msvc
     steps:
-      - uses: actions/checkout@v2
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v4
       - 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"
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           rake -m test:build && rake test:run

.github/workflows/codeql-analysis.yml

@@ -1,55 +0,0 @@
-name: "Code scanning - action"
-
-on:
-  push:
-  pull_request:
-  schedule:
-    - cron: '0 19 * * 4'
-
-jobs:
-  CodeQL-Build:
-    if: |
-      !contains(github.event.head_commit.message, '[ci skip]') &&
-      !contains(github.event.head_commit.message, '[skip ci]') &&
-      !contains(github.event.head_commit.message, '[skip gha]')
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
-        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
-
-      # If this run was triggered by a pull request event, then checkout
-      # the head of the pull request instead of the merge commit.
-      - run: git checkout HEAD^2
-        if: ${{ github.event_name == 'pull_request' }}
-
-      # 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/labeler.yml

@@ -0,0 +1,15 @@
+# https://github.com/actions/labeler
+name: Pull Request Labeler
+on:
+  - pull_request_target
+jobs:
+  triage:
+    permissions:
+      contents: read
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/labeler@v5
+        with:
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"
+          sync-labels: true

.github/workflows/lint.yml

@@ -1,23 +1,27 @@
-name: ❄️ Lint
+# https://pre-commit.com/
+name: Lint
 
 on: [pull_request]
 
+permissions:
+  contents: read
+
 jobs:
-  yamllint:
-    name: 🍶 YAML
+  pre-commit:
+    name: Run pre-commit
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - name: 🧹 YAML Lint
-        uses: ibiqlik/action-yamllint@v3
-  markdownlint:
-    name: 🍸 Markdown
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: 🚀 Use Node.js
-        uses: actions/setup-node@v2.1.4
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v4
+      - name: Install
+        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@v3
         with:
-          node-version: '12.x'
-      - run: npm install -g markdownlint-cli@0.25.0
-      - run: markdownlint '**/*.md'
+          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

@@ -1,26 +1,26 @@
+# https://github.com/google/oss-fuzz
 name: CIFuzz
 on: [pull_request]
+permissions:
+  contents: read
+
 jobs:
   Fuzzing:
-    if: |
-      !contains(github.event.head_commit.message, '[ci skip]') &&
-      !contains(github.event.head_commit.message, '[skip ci]') &&
-      !contains(github.event.head_commit.message, '[skip gha]')
     runs-on: ubuntu-latest
     steps:
       - name: Build Fuzzers
         uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
         with:
-          oss-fuzz-project-name: 'mruby'
+          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'
+          oss-fuzz-project-name: "mruby"
           fuzz-seconds: 600
           dry-run: false
       - name: Upload Crash
-        uses: actions/upload-artifact@v1
+        uses: actions/upload-artifact@v4
         if: failure()
         with:
           name: artifacts

.github/workflows/spell-checker.yml

@@ -1,17 +0,0 @@
-name: 💎 Spellchecker
-
-on: [pull_request]
-
-jobs:
-  misspell:
-    name: 🧹 Check Spelling
-    runs-on: ubuntu-latest
-    steps:
-      - name: 🍒 Check Out
-        uses: actions/checkout@v2
-      - name: 🍅 Install
-        run: |
-          wget -O - -q https://git.io/misspell | sh -s -- -b .
-      - name: 🌶️ Misspell
-        run: |
-          git ls-files --empty-directory | xargs ./misspell -error

.github/workflows/super-linter.yml

@@ -0,0 +1,32 @@
+# https://github.com/super-linter/super-linter
+name: Super-Linter
+
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    permissions:
+      contents: read # for actions/checkout to fetch code
+      statuses: write # for github/super-linter/slim to mark status of each linter run
+    name: Lint Code Base
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v4
+        with:
+          # Full git history is needed to get a proper list of changed files within `super-linter`
+          fetch-depth: 0
+      - name: Lint Code Base
+        uses: super-linter/super-linter/slim@v5.7.2
+        env:
+          ERROR_ON_MISSING_EXEC_BIT: true
+          VALIDATE_BASH: true
+          # VALIDATE_BASH_EXEC: true
+          # VALIDATE_EDITORCONFIG: true
+          # VALIDATE_SHELL_SHFMT: true
+          DEFAULT_BRANCH: master
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          VALIDATE_ALL_CODEBASE: false

.gitignore

@@ -1,8 +1,8 @@
-*.lock
 *.bak
 *.bc
 *.d
 *.i
+*.lock
 *.o
 *.orig
 *.pdb
@@ -13,25 +13,24 @@
 *.tmp
 *~
 .DS_Store
+.ccls*
 .ccmalloc
 .svn
 .vscode
 .yardoc
-.ccls*
-compile_flags.txt
-compile_commands.json
-cscope.files
-cscope.out
-tags
-
 /.git
-/bin
-/build
-/mruby-source-*.gem
-
 /benchmark/**/*.dat
 /benchmark/*.pdf
 /benchmark/*.png
-
+/bin
+/build
 /doc/api
 /doc/capi
+/mruby-source-*.gem
+compile_commands.json
+compile_flags.txt
+cscope.files
+cscope.out
+node_modules
+tags
+!Gemfile.lock

.markdownlint.yml

@@ -1,16 +0,0 @@
-MD001: false
-MD003: false
-MD004: false
-MD005: false
-MD007: false
-MD010: false
-MD011: false
-MD013: false
-MD014: false
-MD024: false
-MD025: false
-MD026: false
-MD034: false
-MD040: false
-MD041: false
-MD046: false

.pre-commit-config.yaml

@@ -0,0 +1,84 @@
+---
+default_stages: [commit, push]
+default_language_version:
+  # force all unspecified Python hooks to run python3
+  python: python3
+minimum_pre_commit_version: "2.18.1"
+repos:
+  - repo: meta
+    hooks:
+      - id: identity
+      - id: check-hooks-apply
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.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-shebang-scripts-are-executable
+      - id: check-vcs-permalinks
+      - id: check-yaml
+      - id: detect-private-key
+      - id: end-of-file-fixer
+      - id: file-contents-sorter
+        args: [--unique]
+        files: ^codespell\.txt$
+      - id: fix-byte-order-marker
+      - id: forbid-submodules
+      - id: mixed-line-ending
+      - id: trailing-whitespace
+  - repo: https://github.com/Lucas-C/pre-commit-hooks
+    rev: v1.5.4
+    hooks:
+      - id: forbid-tabs
+        exclude: Makefile$|Makefile\..+$|makefile$|\.mk$
+      - id: remove-tabs
+        args: [--whitespaces-count, "2"]
+        exclude: Makefile$|Makefile\..+$|makefile$|\.mk$
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.2.6
+    hooks:
+      - id: codespell
+        name: Run codespell
+        description: Check spelling with codespell
+        entry: codespell --ignore-words=codespell.txt
+  - repo: https://github.com/jumanjihouse/pre-commit-hooks
+    rev: 3.0.0
+    hooks:
+      - id: script-must-not-have-extension
+        name: Local policy is to exclude extension from all shell files
+        types: [shell]
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v4.0.0-alpha.8
+    hooks:
+      - id: prettier
+        exclude: ^doc/internal/opcode\.md$
+  - repo: https://github.com/igorshubovych/markdownlint-cli
+    rev: v0.38.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/tcort/markdown-link-check
+    rev: v3.11.2
+    hooks:
+      - id: markdown-link-check
+        name: Run markdown-link-check
+        description: Checks hyperlinks in Markdown files
+        args: [-q]
+        types: [markdown]
+        files: \.(md|mdown|markdown)$
+  - repo: https://github.com/adrienverge/yamllint
+    rev: v1.33.0
+    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)$

.prettierrc

@@ -0,0 +1,3 @@
+{
+  "bracketSpacing": false
+}

.yamllint

@@ -1,8 +0,0 @@
----
-
-extends: default
-
-rules:
-  document-start: disable
-  line-length: disable
-  truthy: false

.yardopts

@@ -11,7 +11,13 @@ mrbgems/*/src/**/*.c
 mrbgems/*/mrblib/**/*.rb
 mrbgems/*/include/**/*.h
 -
-AUTHORS
-LICENSE
 CONTRIBUTING.md
+SECURITY.md
+TODO.md
+doc/*.md
 doc/guides/*.md
+doc/internal/*.md
+AUTHORS
+LEGAL
+LICENSE
+NEWS

AUTHORS

@@ -1,48 +1,325 @@
-This is the (likely incomplete) list of "mruby developers".
-If you submit a patch to mruby, please add your name to the end
-of this list.
+# Authors of mruby (mruby developers)
 
-   Yukihiro Matsumoto (Matz)
+## The List of Contributors sorted by number of commits (as of 2023-12-28 67cb987)
+
+   9477 Yukihiro "Matz" Matsumoto (@matz)*
+    586 KOBAYASHI Shuji (@shuujii)
+    533 dearblue (@dearblue)*
+    378 Daniel Bovensiepen (@bovi)*
+    346 Takeshi Watanabe (@take-cheeze)*
+    334 Masaki Muranaka (@monaka)
+    328 Tomoyuki Sahara (@tsahara)*
+    234 Jun Hiroe (@suzukaze)
+    220 Cremno (@cremno)*
+    209 Yuki Kurihara (@ksss)+
+    166 John Bampton (@jbampton)
+    151 Yasuhiro Matsumoto (@mattn)*
+    113 Carson McDonald (@carsonmcdonald)
+    103 Tomasz Dąbrowski (@dabroz)*
+     84 Akira Yumiyama (@akiray03)*
+     84 skandhas (@skandhas)
+     81 Hiroshi Mimaki (@mimaki)*
+     80 Masamitsu MURASE (@masamitsu-murase)
+     74 Yuichiro MASUI (@masuidrive)
+     71 Tatsuhiko Kubo (@cubicdaiya)*
+     65 Yuichiro Kaneko (@yui-knk)+
+     64 Paolo Bosetti (@pbosetti)*
+     59 Kurebayashi, Takahiro (@crimsonwoods)*
+     56 h2so5 (@h2so5)
+     52 Ralph Desir (@Mav7)*
+     45 Rory O'Connell (@RoryO)*
+     42 fleuria (@flaneur2020)
+     40 Christopher Aue (@christopheraue)
+     40 Seba Gamboa (@sagmor)
+     38 Koji Yoshioka (@kyab)*+
+     38 Kouhei Sutou (@kou)*
+     32 Masayoshi Takahashi (@takahashim)+
+     31 MATSUMOTO Ryosuke (@matsumotory)*
+     30 Nobuyoshi Nakada (@nobu)
+     26 Julian Aron Prenner (@furunkel)*
+     24 Ryan Scott (@ryan-scott-dev)*
+     22 Clayton Smith (@clayton-shopify)
+     22 Uchio Kondo (@udzura)*
+     22 Zachary Scott (@zzak)*
+     22 mirichi (@mirichi)
+     21 Jared Breeden (@jbreeden)*
+     21 Ryan Lopopolo (@lopopolo)
+     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)*
+     16 bggd (@bggd)
+     16 kano4 (@kano4)
+     14 Blaž Hrastnik (@archseer)*
+     14 Jose Narvaez (@goyox86)
+     14 Kazuki Tsujimoto (@k-tsj)
+     14 Tadashi FUKUZAWA (@FUKUZAWA-Tadashi)+
+     14 fn ⌃ ⌥ (@FnControlOption)
+     13 Patrick Hogan (@pbhogan)
+     12 Akira Kuroda (@akuroda)
+     12 Kouki Ooyatsu (kaishuu0123)*
+     12 NAKAMURA Usaku (@unak)*
+     12 RIZAL Reckordp (@Reckordp)+
+     12 Ray Chason (@chasonr)*
+     12 Takashi Sawanaka (@sdottaka)*
+     12 Ukrainskiy Sergey (@ukrainskiysergey)
+     12 Xuejie "Rafael" Xiao (@xxuejie)*
+     11 Julien Ammous (@schmurfy)
+     11 Kazuho Oku (@kazuho)
+     11 Seeker (@SeekingMeaning)
+     11 YAMAMOTO Masaya (pandax381)
+     11 takkaw (@takkaw)
+     10 Miura Hideki (@miura1729)
+     10 Narihiro Nakamura (@authorNari)
+     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 SiZiOUS (@sizious)
+      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)*
+      6 masahino (@masahino)
+      5 Chris Reuter (@suetanvil)
+      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 Rodrigo Malizia (@rmalizia44)+
+      5 Syohei YOSHIDA (@syohex)
+      5 TOMITA Masahiro (@tmtm)
+      5 Yurie Yamane (@yurie)+
+      5 dreamedge (@dreamedge)
+      5 nkshigeru (@nkshigeru)
+      5 xuejianqing (@joans321)
+      4 Dante Catalfamo (@dantecatalfamo)
+      4 Goro Kikuchi (@gorogit)
+      4 Herwin Weststrate (@herwinw)
+      4 Horimoto Yasuhiro (@komainu8)
+      4 Jon Moss (@maclover7)
+      4 Ken Muramatsu (@ken-mu)+
+      4 Kohei Suzuki (@eagletmt)
+      4 Lanza (@LanzaSchneider)
+      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 wanabe (@wanabe)*
+      3 Anton Davydov (@davydovanton)
+      3 Carlo Prelz (@asfluido)*
+      3 David Turnbull (@AE9RB)
+      3 Franck Verrot (@franckverrot)
+      3 HASUMI Hitoshi (@hasumikin)
+      3 J. Mutua (@katmutua)+
+      3 Jan Berdajs (@mrbrdo)
+      3 Jonas Minnberg (@sasq64)
+      3 Joseph McCullough (@joequery)
+      3 Mark McCurry (@fundamental)
+      3 Nobuhiro Iwamatsu (@iwamatsu)
+      3 Per Lundberg (@perlun)*
+      3 Rob Fors (@robfors)*
+      3 Robert Rowe (@CaptainJet)
+      3 Sebastián Katzer (@katzer)*
+      3 Shouji Kuboyama (@Shokuji)*
+      3 Shuta Kimura (@kimushu)+
+      3 TERAJIMA, Motoyuki (@trmmy)
+      3 Taichi AOKI (@aoki1980taichi)
+      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)
+      3 windwiny (@windwiny)
+      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 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 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)
+      1 A-Sat (@asatou)+
+      1 Abinoam Praxedes Marques Junior (@abinoam)
+      1 Alex Wang (@nanamiwang)+
+      1 AlexDenisov (@AlexDenisov)
+      1 Andrew Nordman (@cadwallion)
+      1 Ashish Kurmi (@boahc077)
+      1 Atsushi Morimoto (@mynz)
+      1 Ben A Morgan (@BenMorganIO)
+      1 Benoit Daloze (@eregon)
+      1 Colin MacKenzie IV (@sinisterchipmunk)
+      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 Gwendolyn Boatrite (@boatrite)
+      1 HARADA Makoto (@haramako)
+      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 Koichi ITO (@koic)
+      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 Ryan Scott Lewis (@RyanScottLewis)
+      1 Ryo Okubo (@syucream)
+      1 SAkira a.k.a. Akira Suzuki (@sakisakira)
+      1 Santiago Rodriguez (@sanrodari)
+      1 Satoh, Hiroh (@cho45)+
+      1 Sayed Abdelhaleem (@visualsayed)
+      1 Sergey Ukrainskiy (@ukrainskiysergey)
+      1 Shugo Maeda (@shugo)
+      1 Sorah Fukumori (@sorah)
+      1 Stephen Jothen (@sjothen)
+      1 Stuart Hinson (@stuarth)
+      1 Takuma Kume (@takumakume)+
+      1 Takuya ASADA (@syuu1228)
+      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 Yuji Yokoo (@yujiyokoo)
+      1 Yukang (@chenyukang)
+      1 Yurii Nakonechnyi (@inobelar)
+      1 Yusuke Suzuki (@Constellation)+
+      1 Yusuke Tanaka (@csouls)
+      1 alpha.netzilla (@alpha-netzilla)
+      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
-   KOBAYASHI Shuji
-   RIZAL Reckordp
-   Rory O'Connell
-   John Bampton
-   Seeker

CONTRIBUTING.md

@@ -8,16 +8,120 @@ Contributors agree to license their contribution(s) under MIT license.
 To make it easy to review and understand your change please keep the following
 things in mind before submitting your pull request:
 
-* Work on the latest possible state of **mruby/master**
-* Create a branch which is dedicated to your change
-* Test your changes before creating a pull request (```rake test```)
-* 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
-* Explain your change (i.e. with a link to the issue you are fixing)
-* Use mrbgem to provide non ISO features (classes, modules and methods) unless
+- Work on the latest possible state of **mruby/master**
+- Create a branch which is dedicated to your change
+- Test your changes before creating a pull request (`rake test`)
+- 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
+- Explain your change (i.e. with a link to the issue you are fixing)
+- 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`
+
+Sometimes you might need to skip one or more hooks which can be done with the `SKIP` environment variable.
+
+`$ SKIP=yamllint git commit -m "foo"`
+
+For convenience, we have added `pre-commit run --all-files`, `pre-commit install` and `pre-commit autoupdate`
+to both the Makefile and the Rakefile. Run them with:
+
+- `make check` or `rake check`
+- `make checkinstall` or `rake checkinstall`
+- `make checkupdate` or `rake checkupdate`
+
+To configure `pre-commit` you can modify the config file [.pre-commit-config.yaml](.pre-commit-config.yaml).
+We use [GitHub Actions](.github/workflows/lint.yml) to run `pre-commit` on every pull request.
+
+### pre-commit quick links
+
+- [Quick start](https://pre-commit.com/#quick-start)
+- [Usage](https://pre-commit.com/#usage)
+- [pre-commit autoupdate](https://pre-commit.com/#pre-commit-autoupdate)
+- [Temporarily disabling hooks](https://pre-commit.com/#temporarily-disabling-hooks)
+
+## Docker
+
+We have both a `Dockerfile` and `docker-compose.yml` files in the repository root.
+You can run these with the command line or use
+[Docker Desktop](https://www.docker.com/products/docker-desktop/).
+
+The Docker image is running Debian bullseye with Ruby and Python installed.
+You can build the Docker image with:
+
+`$ docker-compose build test`
+
+So far we just have one service: `test`. Running the default `docker-compose`
+command will create the Docker image, spin up a container and then build and
+run all mruby tests.
+
+The default `docker-compose` command is:
+
+`$ docker-compose -p mruby run test`
+
+You can also use Make or Rake to run the default `docker-compose`
+command from above:
+
+- `make composetest`
+- `rake composetest`
+
+List your Docker images with:
+
+```console
+$ docker images
+REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
+mruby-test   latest    ec60f9536948   29 seconds ago   1.29GB
+```
+
+You can also run any custom `docker-compose` command which will override
+the default. For example to run `pre-commit run --all-files` type:
+
+`$ docker-compose -p mruby run test pre-commit run --all-files`
+
+For convenience, you can also run `pre-commit` with:
+
+- `make composecheck`
+- `rake composecheck`
+
+The bonus of running `pre-commit` with `docker-compose` is that you won't need
+to install `pre-commit` and the hooks on your local machine. And that also
+means you won't need to install `brew`, `conda` or `pip`.
+
+Note limitation: currently running `pre-commit` with `docker-compose` we
+skip the `check-executables-have-shebangs` hook.
+
+Two more examples of custom `docker-compose` commands are:
+
+- `$ docker-compose -p mruby run test ls`
+- `$ docker-compose -p mruby run test rake doc:api`
+
+If you want to test using a different `docker-compose` YAML config file you
+can use the `-f` flag:
+
+`$ docker-compose -p mruby -f docker-compose.test.yml run test`
+
+- <https://docs.docker.com/compose/>
+- <https://docs.docker.com/engine/reference/commandline/cli/>
+
+## Spell Checking
+
+We are using `pre-commit` to run [codespell](https://github.com/codespell-project/codespell)
+to check code for common misspellings. We have a small custom dictionary file [codespell.txt](codespell.txt).
+
 ## Coding conventions
 
 How to style your C and Ruby code which you want to submit.
@@ -32,7 +136,7 @@ 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>).
 
 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
@@ -48,13 +152,13 @@ on-demand.
 
 #### Insert a break after the function return value:
 
-    ```C
-    int
-    main(void)
-    {
-      ...
-    }
-    ```
+```c
+int
+main(void)
+{
+  ...
+}
+```
 
 ### Ruby code
 
@@ -64,5 +168,18 @@ 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 (https://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.
+
+## Building documentation
+
+### mruby API
+
+- [YARD](https://yardoc.org/) - YARD is a documentation generation tool for the Ruby programming language
+- [yard-mruby](https://rubygems.org/gems/yard-mruby) - Document mruby sources with YARD
+- [yard-coderay](https://rubygems.org/gems/yard-coderay) - Adds coderay syntax highlighting to YARD docs
+
+### C API
+
+- [Doxygen](https://www.doxygen.nl/) - Generate documentation from source code
+- [Graphviz](https://graphviz.org/) - Graphviz is open source graph visualization software

Dockerfile

@@ -0,0 +1,13 @@
+FROM ruby:3.2.2-bullseye
+
+RUN apt-get update && apt-get install --no-install-recommends -y python3-pip shellcheck \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY Gemfile Gemfile.lock .pre-commit-config.yaml ./
+
+RUN bundle install && pip3 install pre-commit && git init . && pre-commit install-hooks
+
+COPY . .

Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'yard'
+gem 'yard-coderay'
+gem 'yard-mruby'

Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.3)
+    rake (13.0.6)
+    webrick (1.7.0)
+    yard (0.9.28)
+      webrick (~> 1.7.0)
+    yard-coderay (0.1.0)
+      coderay
+      yard
+    yard-mruby (0.3.0)
+      yard (~> 0.9.0)
+
+PLATFORMS
+  ruby
+  x86_64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  rake
+  yard
+  yard-coderay
+  yard-mruby
+
+BUNDLED WITH
+   2.4.10

LEGAL

@@ -4,3 +4,37 @@ LEGAL NOTICE INFORMATION
 All the files in this distribution are covered under the MIT license
 (see the file LICENSE) except some files mentioned below:
 
+- src/readfloat.c: public domain by Yasuhiro Matsumoto (@mattn)
+- src/fmt_fp.c: public domain by Dave Hylands (@dhylands)
+- mrbgems/mruby-dir/src/Win/dirent.c: MIT-like license by Kevlin Henney
+
+[src/readfloat.c]
+
+strtod implementation.
+author: Yasuhiro Matsumoto (@mattn)
+license: public domain
+
+The original code can be found in https://github.com/mattn/strtod
+
+[src/fmt_fp.c]
+
+The code in this function was inspired from Fred Bayer's pdouble.c.
+Since pdouble.c was released as Public Domain, I'm releasing this
+code as public domain as well.
+
+Dave Hylands
+
+The original code can be found in https://github.com/dhylands/format-float
+
+[mrbgems/mruby-dir/src/Win/dirent.c] used only for Windows platform
+
+Copyright Kevlin Henney, 1997, 2003, 2012. All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose is hereby granted without fee, provided
+that this copyright and permissions notice appear in all copies and
+derivatives.
+
+This software is supplied "as is" without express or implied warranty.
+
+But that said, if there are any problems please get in touch.

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2021 mruby developers
+Copyright (c) 2010- 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

@@ -13,3 +13,23 @@ test : all
 clean :
 	$(RAKE) clean
 .PHONY : clean
+
+check :
+	pre-commit run --all-files
+.PHONY : check
+
+checkinstall :
+	pre-commit install
+.PHONY : checkinstall
+
+checkupdate :
+	pre-commit autoupdate
+.PHONY : checkupdate
+
+composecheck :
+	docker-compose -p mruby run test pre-commit run --all-files
+.PHONY : composecheck
+
+composetest :
+	docker-compose -p mruby run test
+.PHONY : composetest

NEWS

@@ -1,13 +1,189 @@
-* NEWS
+NEWS
+----
 
-This document is a list of user visible feature changes made between
-releases except for bug fixes.
+# User visible changes in `mruby3.3` from `mruby3.2`
 
-Note that each entry is kept so brief that no reason behind or
-reference information is supplied with.  For a full list of changes
-with all sufficient information, see the ChangeLog file.
+"**_NOTE_**:" are changes to be aware of.
 
+# The language
 
-** Information about first release v1.0.0
+- aliases work properly with `super` ([2ad3f0e](https://github.com/mruby/mruby/commit/2ad3f0e))
+- `callee` method work differently with aliases in mruby ([f2dc76e](https://github.com/mruby/mruby/commit/f2dc76e))
+- define `Kernel#respond_to_missing?` method ([347586e](https://github.com/mruby/mruby/commit/347586e))
+- `_inspect` method (`inspect` with recursive check) is removed
+  ([e2bbf75](https://github.com/mruby/mruby/commit/e2bbf75), [5cb0c74](https://github.com/mruby/mruby/commit/5cb0c74), [113565a](https://github.com/mruby/mruby/commit/113565a),
+  [0713f2a](https://github.com/mruby/mruby/commit/0713f2a), [6ae6b63](https://github.com/mruby/mruby/commit/6ae6b63), [fc9fffc](https://github.com/mruby/mruby/commit/fc9fffc))
+- `__printstr__` method is removed; use `print` instead
+  ([acecee0](https://github.com/mruby/mruby/commit/acecee0), [192e6e3](https://github.com/mruby/mruby/commit/192e6e3))
+- New method `String#bytesplice` ([5274647](https://github.com/mruby/mruby/commit/5274647), [a2e2e83](https://github.com/mruby/mruby/commit/a2e2e83))
+- Allow `return` in blocks to cross C boundaries ([#6125](https://github.com/mruby/mruby/pull/6125))
 
+# Configuration
 
+- mruby can be built using Docker now. Try `docker-compose build` for example. ([#5961](https://github.com/mruby/mruby/pull/5961))
+- New Platform: DJGPP (MS-DOS) ([#6022](https://github.com/mruby/mruby/pull/6022))
+- New Platform: Nintendo Wii ([#6086](https://github.com/mruby/mruby/pull/6086))
+- Improved Platform: Android ([#6013](https://github.com/mruby/mruby/pull/6013))
+- Improved Platform: Dreamcast ([#6130](https://github.com/mruby/mruby/pull/6130))
+- Allow tests to be disabled for specific gems; warn about disabled tests ([#6012](https://github.com/mruby/mruby/pull/6012))
+- Replace `MRB_NO_DIRECT_THREADING` with `MRB_USE_VM_SWITCH_DISPATCH` ([#5902](https://github.com/mruby/mruby/pull/5902))
+
+# mruby memory API
+
+- `mrb_default_allocf` can be overridden by the application ([34c5d96](https://github.com/mruby/mruby/commit/34c5d96))
+- `mrb_open_allocf` will be deprecated ([cfee5c2](https://github.com/mruby/mruby/commit/cfee5c2))
+
+# Changes in C API
+
+- add new error handling API functions ([8c8bbd9](https://github.com/mruby/mruby/commit/8c8bbd9))
+- Add `mrb_vm_ci_env_clear()` function with `MRB_API` ([#5945](https://github.com/mruby/mruby/pull/5945))
+- a new function `mrb_check_frozen_value()` ([ccdf75c](https://github.com/mruby/mruby/commit/ccdf75c))
+- avoid formatting in `mrb_bug()` ([82a48bd](https://github.com/mruby/mruby/commit/82a48bd)) <br>
+  **_NOTE_**: If you are using it, you must give a simple string or replace it with a call to `mrb_raise()` series.
+- stop using `mrbc_` prefix for compiler context ([c5e3cbe](https://github.com/mruby/mruby/commit/c5e3cbe)) <br>
+  The same names are provided as before, but we recommend replacing them.
+- Allow `Class#allocate` to be prohibited
+  ([#5979](https://github.com/mruby/mruby/pull/5979), [#6122](https://github.com/mruby/mruby/pull/6122), [#6123](https://github.com/mruby/mruby/pull/6123)) <br>
+  To disable `#allocate`, use `MRB_UNDEF_ALLOCATOR()`.
+  This is also automatically applied when the subclass is created, but to explicitly allow it, use `MRB_DEFINE_ALLOCATOR()`.
+
+# Changes in mrbgems
+
+- **default.gembox**: Add mruby debugger mrdb (`mruby-bin-debugger`) ([#5966](https://github.com/mruby/mruby/pull/5966))
+- **mruby-bin-config**: new options `--cxx`, `--cxxflags`, `--as`, `--asflags`, `--objc`, `--objcflags` ([#6054](https://github.com/mruby/mruby/pull/6054))
+- **mruby-binding**: renamed from `mruby-binding-core` of mruby3.2 ([11af5db](https://github.com/mruby/mruby/commit/11af5db)) <br>
+  **_NOTE_**: If using `mruby-binding-core` of mruby 3.2, replace it with `mruby-binding`.
+- **mruby-binding**: implemented `Binding#initialize_copy` method ([#5517](https://github.com/mruby/mruby/pull/5517))
+- **mruby-binding**: `Kernel#binding` responds only to calls from Ruby ([#5981](https://github.com/mruby/mruby/pull/5981))
+- **mruby-compar-ext**: Comparable#clamp to accept nil as arguments ([836bebc](https://github.com/mruby/mruby/commit/836bebc))
+- **mruby-compiler**: add print name for identifier tokens ([d7b2e3a](https://github.com/mruby/mruby/commit/d7b2e3a))
+- **mruby-data**: allow empty Data ([927a9df](https://github.com/mruby/mruby/commit/927a9df))
+- **mruby-enumerator**: remove internal attribute methods `obj`, `args`, `kwd`, `meth`, `fib`. ([735fa24](https://github.com/mruby/mruby/commit/735fa24))
+- **mruby-enumerator**: add Enumerator#size ([861f8bd](https://github.com/mruby/mruby/commit/861f8bd))
+- **mruby-eval**: merged `mruby-binding` of mruby3.2 ([501b22a](https://github.com/mruby/mruby/commit/501b22a), [#5989](https://github.com/mruby/mruby/pull/5989)) <br>
+  **_NOTE_**: If using `mruby-binding` of mruby 3.2, replace it with `mruby-eval`.
+- **mruby-fiber**: Add a new `mrb_fiber_new()` with `MRB_API` ([#6097](https://github.com/mruby/mruby/pull/6097))
+- **mruby-fiber**: Allows calling `Fiber#resume` from C ([#6106](https://github.com/mruby/mruby/pull/6106))
+- **mruby-fiber**: `Fiber#to_s` format changed ([#6105](https://github.com/mruby/mruby/pull/6105))
+- **mruby-io**: add File#atime and File#ctime ([321cfe9](https://github.com/mruby/mruby/commit/321cfe9))
+- **mruby-io**: Add "x" mode option for `IO.open` ([#6081](https://github.com/mruby/mruby/pull/6081))
+- **mruby-io**: File.new should not take blocks ([53de964](https://github.com/mruby/mruby/commit/53de964))
+- **mruby-method**: `Method#to_s` format changed ([f5bc82f](https://github.com/mruby/mruby/commit/f5bc82f), [02f189c](https://github.com/mruby/mruby/commit/02f189c))
+- **mruby-numeric-ext**: `int.pow(n,m)` to take bigint as exponential ([d482eab](https://github.com/mruby/mruby/commit/d482eab))
+- **mruby-pack**: support new directives `j`, `J`, `b`, `B`, `#`
+  ([2a1e3a5](https://github.com/mruby/mruby/commit/2a1e3a5), [e7021f1](https://github.com/mruby/mruby/commit/e7021f1), [e17f325](https://github.com/mruby/mruby/commit/e17f325))
+- **mruby-range-ext**: new method `Range#overlap?` ([384d0e2](https://github.com/mruby/mruby/commit/384d0e2))
+- **mruby-string-ext**: Add `String#valid_encoding?` method ([eabe2d9](https://github.com/mruby/mruby/commit/eabe2d9))
+- **mruby-struct**: allow empty Struct when a name is not given ([c212ede](https://github.com/mruby/mruby/commit/c212ede))
+- **mruby-time**: should allow year before 1900 ([e5de08b](https://github.com/mruby/mruby/commit/e5de08b))
+- **mruby-time**: support bigint to time_t if necessary ([7096d27](https://github.com/mruby/mruby/commit/7096d27))
+- **mruby-time**: need to handle negative time_t ([b064d7e](https://github.com/mruby/mruby/commit/b064d7e))
+
+# Changes in build system
+
+- Extended `rake install` task ([#5928](https://github.com/mruby/mruby/pull/5928)) <br>
+  **_NOTE_**: Due to this impact, executable files in the `mruby/bin/` directory by default are now symbolic links (batch files on Windows).
+  If previously relied on those executables, should be replaced with direct references to the entity created under the build directory (e.g. `mruby/build/host/bin/`).
+- Encode and decode escape characters for presym ([#6011](https://github.com/mruby/mruby/pull/6011))
+- Rakefile: remove default build target directories in `deep_clean` ([#6032](https://github.com/mruby/mruby/pull/6032), [1e38569](https://github.com/mruby/mruby/commit/1e38569))
+
+# Other breaking changes
+
+- `mrb_f_raise()` is now an internal function
+  ([#5923](https://github.com/mruby/mruby/pull/5923), [#6070](https://github.com/mruby/mruby/pull/6070))
+- `mrb_make_exception()` is now an internal function with different parameters
+  ([431f83e](https://github.com/mruby/mruby/commit/431f83e), [78137f3](https://github.com/mruby/mruby/commit/78137f3))
+- The `File#path` method no longer uses the `#to_path` method for implicit conversion
+  ([d86c4a7](https://github.com/mruby/mruby/commit/d86c4a7))
+- stop mrb isolation for each test file ([a20fbe5](https://github.com/mruby/mruby/commit/a20fbe5))
+- RBreak remembers the CI location ([#6103](https://github.com/mruby/mruby/pull/6103))
+
+# Bugs Fixed
+
+- [#5724](https://github.com/mruby/mruby/issues/5724) Rational#\*\* is missing
+- [#5725](https://github.com/mruby/mruby/issues/5725) weird const_missing exceptions in mrblib code
+- [#5789](https://github.com/mruby/mruby/issues/5789) No memory release of backtrace information due to stack error
+- [#5932](https://github.com/mruby/mruby/issues/5932) How to create a block using the C API? mrb_yield keeps crashing!
+- [#5943](https://github.com/mruby/mruby/issues/5943) TCPSocket#write is failed
+- [#5944](https://github.com/mruby/mruby/issues/5944) Behavior of calling method with a hash variable
+- [#5946](https://github.com/mruby/mruby/pull/5946) Don't switch constant search path from modules to Object
+- [#5949](https://github.com/mruby/mruby/issues/5949) Caller appears to report wrong line when block passed and brackets omitted
+- [0906cd7](https://github.com/mruby/mruby/commit/0906cd7) numeric.c: fix rounding function issues with big numbers
+- [#5974](https://github.com/mruby/mruby/issues/5974) Invalid escape sequences in gem_init.c on windows
+- [#5975](https://github.com/mruby/mruby/issues/5975) Equals comparison fails on extreme ends of 64-bit integers
+- [#5985](https://github.com/mruby/mruby/issues/5985) Sign extension with OP_LOADI32 in get_int_operand()
+- [#5986](https://github.com/mruby/mruby/issues/5986) Fix bugs in String#bytesplice
+- [#5987](https://github.com/mruby/mruby/issues/5987) ~(-1 << 64) is incorrect
+- [#5991](https://github.com/mruby/mruby/issues/5991) 'gets' method not working in mruby-3.2.0
+- [#5994](https://github.com/mruby/mruby/pull/5994) fix typo in mrbgems/mruby-io/src/io.c
+- [#5995](https://github.com/mruby/mruby/issues/5995) One seemingly unnecessary parameter is passed in the block parameters
+- [#6008](https://github.com/mruby/mruby/pull/6008) Make "bintest" independent of directory
+- [b47c8b7](https://github.com/mruby/mruby/commit/b47c8b7) gc.c (clear_all_old): fix a generational GC bug
+- [#6029](https://github.com/mruby/mruby/issues/6029) mruby build fails under mrbgems directory
+- [a264965](https://github.com/mruby/mruby/commit/a264965) mruby-os-memsize/memsize.c: fix irep size calculation
+- [3310e10](https://github.com/mruby/mruby/commit/3310e10) mruby-test/mrbgem.rake: fix mrb_state handling bug
+- [#6041](https://github.com/mruby/mruby/issues/6041) GC Performance may have degraded
+- [#6044](https://github.com/mruby/mruby/issues/6044) Generated presym/table.h contains invalid characters
+- [#6051](https://github.com/mruby/mruby/issues/6051) Null pointer dereference in mrb_addrinfo_unix_path
+- [#6052](https://github.com/mruby/mruby/issues/6052) Null pointer dereference while handling the Proc class
+- [#6055](https://github.com/mruby/mruby/pull/6055) Fix libmruby name for VisualC++
+- [#6060](https://github.com/mruby/mruby/issues/6060) SEGFAULT Issue Related to Fiber Usage in ngx_mruby Development
+- [#6061](https://github.com/mruby/mruby/issues/6061) Performance issue in String#codepoints
+- [#6064](https://github.com/mruby/mruby/issues/6064) MRUBY_PACKAGE_DIR does not always have a value.
+- [#6065](https://github.com/mruby/mruby/issues/6065) Null pointer dereference while handling the Proc class
+- [#6066](https://github.com/mruby/mruby/issues/6066) Null pointer dereference involving Struct.new()
+- [#6067](https://github.com/mruby/mruby/issues/6067) Null pointer dereference in mrb_string_value_cstr
+- [#6068](https://github.com/mruby/mruby/issues/6068) Stack overflow in mrb_vm_exec
+- [#6076](https://github.com/mruby/mruby/pull/6076) Fixed unwinding block that could point to invalid PC
+- [#6084](https://github.com/mruby/mruby/issues/6084) Incorrect symbolic sinks in binary built on Linux
+- [#6087](https://github.com/mruby/mruby/issues/6087) 'Remote branch HEAD not found in upstream origin' error on build
+- [#6089](https://github.com/mruby/mruby/issues/6089) binding.eval() handles def expressions differently from CRuby
+- [#6098](https://github.com/mruby/mruby/issues/6098) Fails to call superclass of wrapped method
+- [#6099](https://github.com/mruby/mruby/issues/6099) `ensure` section is not executed if the function exits via a return in a proc
+- [#6108](https://github.com/mruby/mruby/issues/6108) VM crashes with break
+- [#6118](https://github.com/mruby/mruby/pull/6118) Fixed IO#read with buf
+- [#6120](https://github.com/mruby/mruby/pull/6120) Set EBADF if check_file_descriptor() fails
+- [#6126](https://github.com/mruby/mruby/pull/6126) Fixed return value of `OP_RETURN_BLK` called directly under C function
+- [#6134](https://github.com/mruby/mruby/issues/6134) String#unpack1 returns an array instead of a single string
+- [#6136](https://github.com/mruby/mruby/pull/6136) Fixed when combined `mrb_fiber_resume()` and `Fiber#transfer`
+
+# Pull Requests (User Visible Ones)
+
+- [#5517](https://github.com/mruby/mruby/pull/5517) Fixed local variables not separated between copied binding objects
+- [#5902](https://github.com/mruby/mruby/pull/5902) Replace `MRB_NO_DIRECT_THREADING` with `MRB_USE_VM_SWITCH_DISPATCH`
+- [#5923](https://github.com/mruby/mruby/pull/5923) Demotion `mrb_f_raise()` from `MRB_API`
+- [#5928](https://github.com/mruby/mruby/pull/5928) Improved `rake install`
+- [#5945](https://github.com/mruby/mruby/pull/5945) Avoid exposure for `REnv` objects
+- [#5946](https://github.com/mruby/mruby/pull/5946) Don't switch constant search path from modules to Object
+- [#5966](https://github.com/mruby/mruby/pull/5966) Update default.gembox add mruby debugger mrdb
+- [#5979](https://github.com/mruby/mruby/pull/5979) Allow Class#allocate to be prohibited
+- [#5981](https://github.com/mruby/mruby/pull/5981) `Kernel#binding` responds only to calls from Ruby
+- [#5989](https://github.com/mruby/mruby/pull/5989) Integrate mruby-binding-eval into mruby-eval
+- [#5961](https://github.com/mruby/mruby/pull/5961) Add Docker to build and run all mruby tests. Run pre-commit and generate YARD docs with Docker
+- [#5994](https://github.com/mruby/mruby/pull/5994) fix typo in mrbgems/mruby-io/src/io.c
+- [#6008](https://github.com/mruby/mruby/pull/6008) Make "bintest" independent of directory
+- [#6009](https://github.com/mruby/mruby/pull/6009) Avoid adding <MRUBY_ROOT>/bintest which does not exist
+- [#6011](https://github.com/mruby/mruby/pull/6011) Encode and decode escape characters for presym
+- [#6012](https://github.com/mruby/mruby/pull/6012) Allow tests to be disabled for specific gems; warn about disabled tests
+- [#6013](https://github.com/mruby/mruby/pull/6013) Fix Android toolchain
+- [#6022](https://github.com/mruby/mruby/pull/6022) Build configuration for MS-DOS and DJGPP
+- [#6032](https://github.com/mruby/mruby/pull/6032) Rake: update task clean to remove bin and build folders
+- [#6045](https://github.com/mruby/mruby/pull/6045) Fixes escape sequence bug and enhancements in Presym scanning
+- [#6054](https://github.com/mruby/mruby/pull/6054) Extends `bin/mruby-config`
+- [#6055](https://github.com/mruby/mruby/pull/6055) Fix libmruby name for VisualC++
+- [#6070](https://github.com/mruby/mruby/pull/6070) Demotion mrb_f_raise() in kernel.c from MRB_API too
+- [#6076](https://github.com/mruby/mruby/pull/6076) Fixed unwinding block that could point to invalid PC
+- [#6081](https://github.com/mruby/mruby/pull/6081) Add "x" mode option for IO.open
+- [#6086](https://github.com/mruby/mruby/pull/6086) Add build config for Nintendo Wii
+- [#6097](https://github.com/mruby/mruby/pull/6097) Add a new mrb_fiber_new() with MRB_API
+- [#6103](https://github.com/mruby/mruby/pull/6103) RBreak remembers the CI location
+- [#6105](https://github.com/mruby/mruby/pull/6105) Implement `Fiber#to_s` method
+- [#6106](https://github.com/mruby/mruby/pull/6106) Ease fiber limitations
+- [#6118](https://github.com/mruby/mruby/pull/6118) Fixed IO#read with buf
+- [#6120](https://github.com/mruby/mruby/pull/6120) Set EBADF if check_file_descriptor() fails
+- [#6122](https://github.com/mruby/mruby/pull/6122) Prohibit `Class#allocate` in a different way
+- [#6123](https://github.com/mruby/mruby/pull/6123) Inherit `MRB_FL_UNDEF_ALLOCATE` in subclasses
+- [#6125](https://github.com/mruby/mruby/pull/6125) Allow `OP_RETURN_BLK` to cross C boundaries
+- [#6126](https://github.com/mruby/mruby/pull/6126) Fixed return value of `OP_RETURN_BLK` called directly under C function
+- [#6130](https://github.com/mruby/mruby/pull/6130) `dreamcast_shelf build config`: complete overhaul
+- [#6136](https://github.com/mruby/mruby/pull/6136) Fixed when combined `mrb_fiber_resume()` and `Fiber#transfer`

README.md

@@ -1,36 +1,51 @@
-[![Build Status][build-status-img]][travis-ci]
+<div align="center">
+  <p>
+    <a href="https://mruby.org/">
+      <img src="https://avatars.githubusercontent.com/u/1796512?s=200&v=4"
+        alt="The mruby programming language" title="mruby">
+    </a>
+  </p>
+  <h1>mruby</h1>
+  <a href="https://github.com/marketplace/actions/super-linter">
+    <img src="https://github.com/mruby/mruby/actions/workflows/super-linter.yml/badge.svg"
+      alt="GitHub Super-Linter">
+  </a>
+</div>
 
 ## 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 2.x compatible.
+of) the [ISO standard][ISO-standard] with more recent features provided by Ruby 3.x.
+Also, its syntax is Ruby 3.x compatible except for pattern matching.
 
-mruby can be linked and embedded within your application.  We provide the
-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"
-program under the "test" directory for an example.
+You can link and embed mruby within your application. The "mruby" interpreter
+program and the interactive "mirb" shell are provided as examples. You can also
+compile Ruby programs into compiled byte code using the "mrbc" compiler. All
+these tools are located in the "bin" directory. "mrbc" can also generate
+compiled byte code in a C source file. See the "mrbtest" program under the
+"test" directory for an example.
 
 This achievement was sponsored by the Regional Innovation Creation R&D Programs
 of the Ministry of Economy, Trade and Industry of Japan.
 
 ## How to get mruby
 
-The stable version 3.0.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/3.0.0.zip](https://github.com/mruby/mruby/archive/3.0.0.zip)
+To get mruby, you can download the stable version 3.3.0 from the official mruby
+GitHub repository or clone the trunk of the mruby source tree with the "git
+clone" command. 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).
 
 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
+```console
+$ 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 homepage
 
-## mruby home-page
-
-The URL of the mruby home-page is: https://mruby.org.
+The URL of the mruby homepage is: <https://mruby.org>.
 
 ## Mailing list
 
@@ -38,31 +53,41 @@ We don't have a mailing list, but you can use [GitHub issues](https://github.com
 
 ## How to compile, test, and install (mruby and gems)
 
-See the [compile.md](https://github.com/mruby/mruby/blob/master/doc/guides/compile.md) file.
+For the simplest case, type
+
+```console
+rake all test
+```
+
+See the [compile.md](doc/guides/compile.md) file for the detail.
 
 ## Building documentation
 
-There are two sets of documentation in mruby: the mruby API (generated by yard) and C API (Doxygen)
+There are two sets of documentation in mruby: the mruby API (generated by YARD) and C API (Doxygen and Graphviz)
 
 To build both of them, simply go
 
-    rake doc
+```console
+rake doc
+```
 
 You can also view them in your browser
 
-    rake view_api
-    rake view_capi
+```console
+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 [mrbgems.md](https://github.com/mruby/mruby/blob/master/doc/guides/mrbgems.md).
-For example code of how to use mrbgems look into the folder *examples/mrbgems/*.
+mruby contains a package manager called "mrbgems" that you can use to create
+extensions in C and/or Ruby. For a guide on how to use mrbgems, consult the
+[mrbgems.md](doc/guides/mrbgems.md) file, and for example code, refer to the
+[examples/mrbgems/](examples/mrbgems) folder.
 
 ## License
 
-mruby is released under the [MIT License](https://github.com/mruby/mruby/blob/master/LICENSE).
+mruby is released under the [MIT License](LICENSE).
 
 ## Note for License
 
@@ -70,26 +95,21 @@ mruby has chosen a MIT License due to its permissive license allowing
 developers to target various environments such as embedded systems.
 However, the license requires the display of the copyright notice and license
 information in manuals for instance. Doing so for big projects can be
-complicated or troublesome.  This is why mruby has decided to display "mruby
+complicated or troublesome. This is why mruby has decided to display "mruby
 developers" as the copyright name to make it simple conventionally.
 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.
 
 ## How to Contribute
 
-See the [contribution guidelines][contribution-guidelines], and then send a pull
-request to <https://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.
+To contribute to mruby, please refer to the [contribution guidelines][contribution-guidelines] and send a pull request to the [mruby GitHub repository](https://github.com/mruby/mruby).
+By contributing, you grant non-exclusive rights to your code under the MIT License.
 
 [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]: https://github.com/mruby/mruby/blob/master/CONTRIBUTING.md
-[travis-ci]: https://travis-ci.org/mruby/mruby
+[contribution-guidelines]: CONTRIBUTING.md

Rakefile

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # Build description.
 # basic build file for mruby
 MRUBY_ROOT = File.dirname(File.expand_path(__FILE__))
@@ -31,8 +30,8 @@ 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"
+load "#{MRUBY_ROOT}/tasks/install.rake"
 
 ##############################
 # generic build targets, rules
@@ -58,7 +57,7 @@ task :clean do
     rm_rf build.build_dir
     rm_f build.products
   end
-  puts "Cleaned up target build folder"
+  puts "Cleaned up target build directory"
 end
 
 desc "clean everything!"
@@ -66,5 +65,32 @@ 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"
+  rm_rf "#{MRUBY_ROOT}/bin"
+  rm_rf "#{MRUBY_ROOT}/build"
+  puts "Cleaned up mrbgems build directory"
+end
+
+desc "run all pre-commit hooks against all files"
+task :check do
+  sh "pre-commit run --all-files"
+end
+
+desc "install the pre-commit hooks"
+task :checkinstall do
+  sh "pre-commit install"
+end
+
+desc "check the pre-commit hooks for updates"
+task :checkupdate do
+  sh "pre-commit autoupdate"
+end
+
+desc "run all pre-commit hooks against all files with docker-compose"
+task :composecheck do
+  sh "docker-compose -p mruby run test pre-commit run --all-files"
+end
+
+desc "build and run all mruby tests with docker-compose"
+task :composetest do
+  sh "docker-compose -p mruby run test"
 end

SECURITY.md

@@ -0,0 +1,20 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+If you have any security concern, contact <matz@ruby.or.jp>.
+
+## Scope
+
+We consider the following issues as vulnerabilities:
+
+- Remote code execution
+- Crash caused by a valid Ruby script
+
+We _don't_ consider the following issues as vulnerabilities:
+
+- Runtime C undefined behavior (including integer overflow)
+- Crash caused by misused API
+- Crash caused by modified compiled binary
+- ASAN/Valgrind warning for too big memory allocation
+  mruby assumes `malloc(3)` returns `NULL` for too big allocations

TODO.md

@@ -1,17 +1,13 @@
-Thing to Do in the future
-===
+# Things to Do in the future
 
-# After mruby 3.0
+# After mruby 3.1
 
-* replace `fp_fmt.c` by `float_format` (https://github.com/dhylands/format-float.git)
-* multi-precision integer
-* WORD_BOXING: Pack some floats in `mrb_value`
-* NAN_BOXING: Allow `MRB_INT64` along with NaN boxing
-* keyword arguments a la Ruby3.0 (using `OP_SENDVK`)
-* parser and code generator independent from `mrb_state` (mmruby?)
+- 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 that are not done yet)
+# Things to do (Things we need to consider)
 
-* `begin ... end while cond` to behave as CRuby
-* special variables ($1,$2..)
-* super in aliased methods
+- `begin ... end while cond` to behave as CRuby
+- special variables ($1,$2..)

appveyor.yml

@@ -4,6 +4,10 @@ shallow_clone: true
 
 environment:
   matrix:
+    - job_name: Visual Studio 2022 64bit
+      visualcpp: C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat
+      appveyor_build_worker_image: Visual Studio 2022
+
     - 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
@@ -32,13 +36,12 @@ environment:
 
 init:
   - call "%visualcpp%" %machine%
-  # For using Rubyins4aller's Ruby 2.6 64bit
+  # 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
 
-
 build_script:
   - set MRUBY_CONFIG=ci/msvc
   - rake -m test:build

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
@@ -179,7 +179,7 @@ def clamp(f)
   i.to_i
 end
 
-def otherBasis(basis, n)
+def orthoBasis(basis, n)
   basis[2] = Vec.new(n.x, n.y, n.z)
   basis[1] = Vec.new(0.0, 0.0, 0.0)
 
@@ -211,7 +211,7 @@ class Scene
 
   def ambient_occlusion(isect)
     basis = Array.new(3)
-    otherBasis(basis, isect.n)
+    orthoBasis(basis, isect.n)
 
     ntheta    = NAO_SAMPLES
     nphi      = NAO_SAMPLES
@@ -243,8 +243,6 @@ class Scene
         @plane.intersect(ray, occisect)
         if occisect.hit
           occlusion = occlusion + 1.0
-        else
-          0.0
         end
       end
     end
@@ -254,8 +252,8 @@ class Scene
   end
 
   def render(w, h, nsubsamples)
-    cnt = 0
     nsf = nsubsamples.to_f
+    nsfs = nsf * nsf
     h.times do |y|
       w.times do |x|
         rad = Vec.new(0.0, 0.0, 0.0)
@@ -263,7 +261,6 @@ class Scene
         # Subsampling
         nsubsamples.times do |v|
           nsubsamples.times do |u|
-            cnt = cnt + 1
             wf = w.to_f
             hf = h.to_f
             xf = x.to_f
@@ -288,15 +285,13 @@ class Scene
               rad.x = rad.x + col.x
               rad.y = rad.y + col.y
               rad.z = rad.z + col.z
-            else
-              0.0
             end
           end
         end
 
-        r = rad.x / (nsf * nsf)
-        g = rad.y / (nsf * nsf)
-        b = rad.z / (nsf * nsf)
+        r = rad.x / nsfs
+        g = rad.y / nsfs
+        b = rad.z / nsfs
         printf("%c", clamp(r))
         printf("%c", clamp(g))
         printf("%c", clamp(b))

benchmark/bm_fib.rb

@@ -1,4 +1,3 @@
-
 def fib n
   return n if n < 2
   fib(n-2) + fib(n-1)

benchmark/bm_so_lists.rb

@@ -1,9 +1,11 @@
-#from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
+# from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
+# which is lost long time ago. The past content can be retrieved from
+# https://web.archive.org/web/20040805115204/http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
 
 NUM = 300
 SIZE = 10000
 
-def test_lists()
+def test_lists
   # create a list of integers (Li1) from 1 to SIZE
   li1 = (1..SIZE).to_a
   # copy the list to li2 (not by individual items)

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/ArduinoDue.rb

@@ -11,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"
@@ -32,7 +32,7 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
     cc.defines << %w(KHASH_DEFAULT_SIZE=8)
     cc.defines << %w(MRB_GC_STRESS)
-    #cc.defines << %w(MRB_NO_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
 

build_config/IntelEdison.rb

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

build_config/IntelGalileo.rb

@@ -12,7 +12,7 @@ MRuby::CrossBuild.new("Galileo") do |conf|
   #ARDUINO_GALILEO_PATH = '/opt/arduino'
 
   GALILEO_BIN_PATH = "#{GALILEO_ARDUINO_PATH}/hardware/tools/x86/i386-pokysdk-darwin/usr/bin/i586-poky-linux-uclibc"
-  GALILEO_SYSROOT =  "#{GALILEO_ARDUINO_PATH}/hardware/tools/x86/i586-poky-linux-uclibc"
+  GALILEO_SYSROOT  = "#{GALILEO_ARDUINO_PATH}/hardware/tools/x86/i586-poky-linux-uclibc"
   GALILEO_X86_PATH = "#{GALILEO_ARDUINO_PATH}/hardware/arduino/x86"
 
 
@@ -74,7 +74,7 @@ MRuby::CrossBuild.new("Galileo") do |conf|
   conf.gem :core => "mruby-fiber"
   conf.gem :core => "mruby-toplevel-ext"
 
-  #lightweigh regular expression
+  #lightweight regular expression
   conf.gem :github => "masamitsu-murase/mruby-hs-regexp", :branch => "master"
 
   #Arduino API

build_config/RX630.rb

@@ -18,7 +18,7 @@ MRuby::CrossBuild.new("RX630") do |conf|
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
     cc.defines << %w(KHASH_DEFAULT_SIZE=8)
     cc.defines << %w(MRB_GC_STRESS)
-    cc.defines << %w(MRB_NO_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
 

build_config/android_arm64_v8a.rb

@@ -2,8 +2,8 @@
 MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
   params = {
     :arch => 'arm64-v8a',
-    :platform => 'android-24',
-    :toolchain => :clang,
+    :sdk_version => 33,
+    :toolchain => :clang
   }
   toolchain :android, params
 

build_config/android_armeabi.rb

@@ -1,11 +0,0 @@
-# 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

@@ -4,8 +4,8 @@ MRuby::CrossBuild.new('android-armeabi-v7a-neon-hard') do |conf|
     :arch => 'armeabi-v7a',
     :mfpu => 'neon',
     :mfloat_abi => 'hard',
-    :platform => 'android-24',
-    :toolchain => :clang,
+    :sdk_version => 33,
+    :toolchain => :clang
   }
   toolchain :android, params
 

build_config/boxing.rb

@@ -3,11 +3,9 @@ bits = [64, 32]
 ints = [64, 32]
 
 boxings.product(bits, ints) do |boxing, bit, int|
-  next if boxing == "nan" && int == 64
-
   MRuby::Build.new("boxing-#{boxing}-m#{bit}-i#{int}") do |conf|
     conf.toolchain :gcc
-    conf.gembox 'default'
+    conf.gembox 'full-core'
     conf.compilers.each do |c|
       c.defines << "MRB_#{boxing.upcase}_BOXING"
       c.defines << "MRB_INT#{int}"

build_config/chipKITMax32.rb

@@ -29,7 +29,7 @@ MRuby::CrossBuild.new("chipKITMax32") do |conf|
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
     cc.defines << %w(KHASH_DEFAULT_SIZE=8)
     cc.defines << %w(MRB_GC_STRESS)
-    #cc.defines << %w(MRB_NO_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
 

build_config/ci/gcc-clang.rb

@@ -6,7 +6,7 @@ MRuby::Build.new('full-debug') do |conf|
 
   # include all core GEMs
   conf.gembox 'full-core'
-  conf.cc.defines += %w(MRB_GC_STRESS MRB_USE_DEBUG_HOOK)
+  conf.cc.defines += %w(MRB_GC_STRESS MRB_USE_DEBUG_HOOK MRB_UTF8_STRING)
 
   conf.enable_test
 end
@@ -18,7 +18,7 @@ MRuby::Build.new do |conf|
   conf.gembox 'full-core'
   conf.gem :core => 'mruby-bin-debugger'
   conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_FIXED_ARENA)
+    c.defines += %w(MRB_GC_FIXED_ARENA MRB_UTF8_STRING)
   end
   conf.enable_bintest
   conf.enable_test
@@ -28,9 +28,9 @@ MRuby::Build.new('cxx_abi') do |conf|
   conf.toolchain
 
   conf.gembox 'full-core'
-  conf.cc.flags += %w(-fpermissive)
+  conf.cc.flags += %w(-fpermissive -std=gnu++03)
   conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_FIXED_ARENA)
+    c.defines += %w(MRB_GC_FIXED_ARENA MRB_UTF8_STRING)
   end
   conf.enable_test
 

build_config/clang-asan.rb

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

build_config/cross-mingw-winetest.rb

@@ -0,0 +1,90 @@
+# 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

@@ -42,7 +42,7 @@ MRuby::Build.new do |conf|
   #   linker.library_paths = []
   #   linker.option_library = '-l%s'
   #   linker.option_library_path = '-L%s'
-  #   linker.link_options = "%{flags} -o "%{outfile}" %{objs} %{libs}"
+  #   linker.link_options = %Q[%{flags} -o "%{outfile}" %{objs} %{libs}]
   # end
 
   # Archiver settings

build_config/dreamcast_shelf.rb

@@ -1,28 +1,34 @@
 # Cross Compiling configuration for the Sega Dreamcast
-# This configuration requires KallistiOS (KOS)
-# https://dreamcast.wiki
+# https://dreamcast.wiki/Using_Ruby_for_Sega_Dreamcast_development
 #
-# Tested on GNU/Linux, MinGW-w64/MSYS2, Cygwin, macOS and MinGW/MSYS (see below)
+# Requires KallistiOS (KOS)
+# http://gamedev.allusion.net/softprj/kos/
+#
+# This configuration has been improved to be used as KallistiOS Port (kos-ports)
+# Updated: 2023-12-24
+#
+# Tested on GNU/Linux, macOS and Windows (MinGW-w64/MSYS2, Cygwin, DreamSDK)
+# DreamSDK is based on MinGW/MSYS: https://dreamsdk.org/
+#
+# Install mruby for Sega Dreamcast using the "mruby" kos-port.
 #
 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" : ""
+  # Getting critical environment variables
+  KOS_BASE = ENV["KOS_BASE"]
+  KOS_CC_BASE = ENV["KOS_CC_BASE"]
 
-  # Setting paths
-  DREAMCAST_PATH = "#{MSYS_ROOT}/opt/toolchains/dc"
-  KOS_PATH = "#{DREAMCAST_PATH}/kos"
-  BIN_PATH = "#{DREAMCAST_PATH}/sh-elf/bin"
+  if (KOS_BASE.nil? || KOS_BASE.empty? || KOS_CC_BASE.nil? || KOS_CC_BASE.empty?)
+    raise "Error: KallistiOS is required; KOS_BASE/KOS_CC_BASE needs to be declared; Stop."
+  end
 
   # C compiler
-  # Flags were extracted from KallistiOS environment files
+  # All flags and settings below 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.command = "#{KOS_CC_BASE}/bin/sh-elf-gcc"
+    cc.include_paths << ["#{KOS_BASE}/include", "#{KOS_BASE}/kernel/arch/dreamcast/include", "#{KOS_BASE}/addons/include", "#{KOS_BASE}/../kos-ports/include"]
+    cc.flags << ["-O2", "-fomit-frame-pointer", "-fno-builtin", "-ml", "-m4-single-only", "-ffunction-sections", "-fdata-sections", "-matomic-model=soft-imask", "-ftls-model=local-exec", "-Wall", "-g"]
     cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
     cc.defines << %w(_arch_dreamcast)
     cc.defines << %w(_arch_sub_pristine)
@@ -33,62 +39,45 @@ MRuby::CrossBuild.new("dreamcast") do |conf|
     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.flags << %w(-fno-operator-names)
     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"]
+    linker.command = "#{KOS_CC_BASE}/bin/sh-elf-gcc"
+    linker.flags << ["-Wl,-Ttext=0x8c010000", "-Wl,--gc-sections", "-T#{KOS_BASE}/utils/ldscripts/shlelf.xc", "-nodefaultlibs", "-Wl,--start-group -lkallisti -lc -lgcc -Wl,--end-group"]
+    linker.library_paths << ["#{KOS_BASE}/lib/dreamcast", "#{KOS_BASE}/addons/lib/dreamcast", "#{KOS_BASE}/../kos-ports/lib"]
   end
 
   # Archiver
   conf.archiver do |archiver|
-    archiver.command = "#{BIN_PATH}/sh-elf-ar"
+    archiver.command = "#{KOS_CC_BASE}/bin/sh-elf-ar"
     archiver.archive_options = 'rcs "%{outfile}" %{objs}'
   end
 
-  # No executables
+  # No executables needed for KallistiOS
   conf.bins = []
 
-  # Do not build executable test
+  # Do not build test binaries
   conf.build_mrbtest_lib_only
 
-  # Disable C++ exception
-  conf.disable_cxx_exception
+  # Gemboxes
+  conf.gembox "default-no-stdio"
+  conf.gembox "stdlib-ext"
+  conf.gembox "metaprog"
 
-  # Gems from core
-  # removing mruby-io
-  conf.gem :core => "mruby-metaprog"
-  conf.gem :core => "mruby-pack"
-  conf.gem :core => "mruby-sprintf"
+  # Additional Gems
+  # Currently unsupported on KallistiOS: "mruby-io", "mruby-dir", "mruby-socket"
+  conf.gem :core => "mruby-binding"
+  conf.gem :core => "mruby-catch"
+  conf.gem :core => "mruby-enum-chain"
+  conf.gem :core => "mruby-errno"
+  conf.gem :core => "mruby-error"
+  conf.gem :core => "mruby-exit"
+  conf.gem :core => "mruby-os-memsize"
   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"
+  conf.gem :core => "mruby-proc-binding"
+  conf.gem :core => "mruby-sleep"
 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
+  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-debug.rb

@@ -8,7 +8,7 @@ MRuby::Build.new('host') do |conf|
   conf.gembox 'full-core'
 
   # C compiler settings
-  conf.cc.defines = %w(MRB_USE_DEBUG_HOOK MRB_NO_BOXING)
+  conf.cc.defines = %w(MRB_USE_DEBUG_HOOK MRB_NO_BOXING MRB_UTF8_STRING)
 
   # Generate mruby debugger command (require mruby-eval)
   conf.gem :core => "mruby-bin-debugger"

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 'full-core'
+
+  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

@@ -3,7 +3,7 @@ MRuby::Build.new do |conf|
   toolchain :gcc
 
   # include the GEM box
-  conf.gembox 'default'
+  conf.gembox 'full-core'
 
   conf.cc.flags << '-pg'
   conf.linker.flags << '-pg'

build_config/host-m32.rb

@@ -3,7 +3,7 @@ MRuby::Build.new do |conf|
   toolchain :gcc
 
   # include the GEM box
-  conf.gembox 'default'
+  conf.gembox 'full-core'
 
   conf.cc.flags << '-m32'
   conf.linker.flags << '-m32'

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

@@ -1,34 +1,34 @@
+# NOTE: Currently, this configuration file does not support VisualC++!
+#       Your help is needed!
+
 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
+  conf.toolchain
 
   # include the GEM box
   conf.gembox 'default'
 
   # C compiler settings
-  conf.cc do |cc|
-    cc.flags = '-fPIC'
+  conf.compilers.each do |cc|
+    cc.flags << '-fPIC'
   end
 
   conf.archiver do |archiver|
-    archiver.command = 'gcc'
+    archiver.command = cc.command
     archiver.archive_options = '-shared -o %{outfile} %{objs}'
   end
 
   # file extensions
   conf.exts do |exts|
-     exts.library = '.so'
+    exts.library = '.so'
   end
 
   # file separator
   # conf.file_separator = '/'
 
+  # enable this if better compatibility with C++ is desired
+  #conf.enable_cxx_exception
+
   # Turn on `enable_debug` for better debugging
   conf.enable_debug
   conf.enable_bintest

build_config/i586-pc-msdosdjgpp.rb

@@ -0,0 +1,77 @@
+# Cross Compiling configuration for MS-DOS
+#
+# Requires DJGPP cross-compiler, see
+# https://github.com/andrewwutw/build-djgpp/releases
+
+MRuby::CrossBuild.new("i586-pc-msdosdjgpp") do |conf|
+  toolchain :gcc
+
+  # If DJGPP is not in the PATH, set this to the bin directory
+  DJGPP_PATH = nil
+
+  GCC = 'i586-pc-msdosdjgpp-gcc'
+  GXX = 'i586-pc-msdosdjgpp-g++'
+  AR  = 'i586-pc-msdosdjgpp-ar'
+
+  conf.cc do |cc|
+    cc.command = DJGPP_PATH ? File.join(DJGPP_PATH, GCC) : GCC
+    cc.defines << 'MRB_WITHOUT_IO_PREAD_PWRITE'
+    cc.defines << 'MRB_UTF8_STRING'
+  end
+
+  conf.cxx do |cxx|
+    cxx.command = DJGPP_PATH ? File.join(DJGPP_PATH, GXX) : GXX
+    cxx.defines << 'MRB_WITHOUT_IO_PREAD_PWRITE'
+    cxx.defines << 'MRB_UTF8_STRING'
+  end
+
+  conf.linker do |linker|
+    linker.command = DJGPP_PATH ? File.join(DJGPP_PATH, GXX) : GXX
+    linker.libraries = %w(m)
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = DJGPP_PATH ? File.join(DJGPP_PATH, AR) : AR
+  end
+
+  # All provided gems that can be reasonably made to compile:
+  # default.gembox, minus mruby-socket and replacing mruby-cmath with mruby-cmath-alt
+  conf.gembox "stdlib"
+  conf.gembox "stdlib-ext"
+
+  conf.gem :core => 'mruby-io'              # stdlib-io.gembox <- default.gembox
+# No socket support in DJGPP
+# conf.gem :core => 'mruby-socket'          # stdlib-io.gembox <- default.gembox
+  conf.gem :core => 'mruby-print'           # stdlib-io.gembox <- default.gembox
+  conf.gem :core => 'mruby-errno'           # stdlib-io.gembox <- default.gembox
+  conf.gem :core => 'mruby-dir'             # stdlib-io.gembox <- default.gembox
+
+  conf.gem :core => 'mruby-bigint'          # math.gembox <- default.gembox
+  conf.gem :core => 'mruby-complex'         # math.gembox <- default.gembox
+  conf.gem :core => 'mruby-math'            # math.gembox <- default.gembox
+  conf.gem :core => 'mruby-rational'        # math.gembox <- default.gembox
+  # Alternative implementation of cmath, not requiring <complex.h>
+# conf.gem :github => 'chasonr/mruby-cmath-alt' # math.gembox <- default.gembox
+
+  conf.gembox "metaprog"
+
+  conf.gem :core => 'mruby-bin-mrbc'        # default.gembox
+  conf.gem :core => 'mruby-bin-debugger'    # default.gembox
+  conf.gem :core => 'mruby-bin-mirb'        # default.gembox
+  conf.gem :core => 'mruby-bin-mruby'       # default.gembox
+  conf.gem :core => 'mruby-bin-strip'       # default.gembox
+  conf.gem :core => 'mruby-bin-config'      # default.gembox
+
+  # Other compilable gems
+  conf.gem :core => 'mruby-binding'
+  conf.gem :core => 'mruby-catch'
+  conf.gem :core => 'mruby-enum-chain'
+  conf.gem :core => 'mruby-error'
+  conf.gem :core => 'mruby-exit'
+  conf.gem :core => 'mruby-os-memsize'
+  conf.gem :core => 'mruby-proc-binding'
+  conf.gem :core => 'mruby-sleep'
+
+  # For Onigmo regular expression support
+  conf.gem :github => 'mattn/mruby-onig-regexp'
+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/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/nintendo_wii.rb

@@ -0,0 +1,96 @@
+# Cross Compiling configuration for the Nintendo Wii
+# This configuration requires devkitPPC
+# https://devkitpro.org/wiki/Getting_Started
+#
+#
+MRuby::CrossBuild.new("wii") do |conf|
+  toolchain :gcc
+
+  DEVKITPRO_PATH = "/opt/devkitpro"
+  BIN_PATH = "#{DEVKITPRO_PATH}/devkitPPC/bin"
+
+  # C compiler
+  conf.cc do |cc|
+    cc.command = "#{BIN_PATH}/powerpc-eabi-gcc"
+    cc.compile_options = %(%{flags} -o "%{outfile}" -c "%{infile}")
+  end
+
+  # C++ compiler
+  conf.cxx do |cxx|
+    cxx.command = "#{BIN_PATH}/powerpc-eabi-g++"
+    cxx.include_paths = conf.cc.include_paths.dup
+    cxx.flags = conf.cc.flags.dup
+    cxx.defines = conf.cc.defines.dup
+    cxx.compile_options = conf.cc.compile_options.dup
+  end
+
+  # Linker
+  conf.linker do |linker|
+    linker.command = "#{BIN_PATH}/powerpc-eabi-gcc"
+  end
+
+  # No executables
+  conf.bins = []
+
+  # Do not build executable test
+  conf.build_mrbtest_lib_only
+
+  # Disable C++ exception
+  conf.disable_cxx_exception
+
+  # All current core gems with ones with build issues commented out
+  conf.gem 'mrbgems/mruby-array-ext/'
+  conf.gem 'mrbgems/mruby-bigint/'
+  conf.gem 'mrbgems/mruby-bin-config/'
+  conf.gem 'mrbgems/mruby-bin-debugger/'
+  conf.gem 'mrbgems/mruby-bin-mirb/'
+  conf.gem 'mrbgems/mruby-bin-mrbc/'
+  conf.gem 'mrbgems/mruby-bin-mruby/'
+  conf.gem 'mrbgems/mruby-bin-strip/'
+  conf.gem 'mrbgems/mruby-binding/'
+  conf.gem 'mrbgems/mruby-catch/'
+  conf.gem 'mrbgems/mruby-class-ext/'
+  conf.gem 'mrbgems/mruby-cmath/'
+  conf.gem 'mrbgems/mruby-compar-ext/'
+  conf.gem 'mrbgems/mruby-compiler/'
+  conf.gem 'mrbgems/mruby-complex/'
+  conf.gem 'mrbgems/mruby-data/'
+  #conf.gem 'mrbgems/mruby-dir/'
+  conf.gem 'mrbgems/mruby-enum-chain/'
+  conf.gem 'mrbgems/mruby-enum-ext/'
+  conf.gem 'mrbgems/mruby-enum-lazy/'
+  conf.gem 'mrbgems/mruby-enumerator/'
+  conf.gem 'mrbgems/mruby-errno/'
+  conf.gem 'mrbgems/mruby-error/'
+  conf.gem 'mrbgems/mruby-eval/'
+  conf.gem 'mrbgems/mruby-exit/'
+  conf.gem 'mrbgems/mruby-fiber/'
+  conf.gem 'mrbgems/mruby-hash-ext/'
+  #conf.gem 'mrbgems/mruby-io/'
+  conf.gem 'mrbgems/mruby-kernel-ext/'
+  conf.gem 'mrbgems/mruby-math/'
+  conf.gem 'mrbgems/mruby-metaprog/'
+  conf.gem 'mrbgems/mruby-method/'
+  conf.gem 'mrbgems/mruby-numeric-ext/'
+  conf.gem 'mrbgems/mruby-object-ext/'
+  conf.gem 'mrbgems/mruby-objectspace/'
+  conf.gem 'mrbgems/mruby-os-memsize/'
+  conf.gem 'mrbgems/mruby-pack/'
+  conf.gem 'mrbgems/mruby-print/'
+  conf.gem 'mrbgems/mruby-proc-binding/'
+  conf.gem 'mrbgems/mruby-proc-ext/'
+  conf.gem 'mrbgems/mruby-random/'
+  conf.gem 'mrbgems/mruby-range-ext/'
+  conf.gem 'mrbgems/mruby-rational/'
+  conf.gem 'mrbgems/mruby-set/'
+  conf.gem 'mrbgems/mruby-sleep/'
+  #conf.gem 'mrbgems/mruby-socket/'
+  conf.gem 'mrbgems/mruby-sprintf/'
+  conf.gem 'mrbgems/mruby-string-ext/'
+  conf.gem 'mrbgems/mruby-struct/'
+  conf.gem 'mrbgems/mruby-symbol-ext/'
+  conf.gem 'mrbgems/mruby-test-inline-struct/'
+  #conf.gem 'mrbgems/mruby-test/'
+  conf.gem 'mrbgems/mruby-time/'
+  conf.gem 'mrbgems/mruby-toplevel-ext/'
+end

build_config/no-float.rb

@@ -1,17 +0,0 @@
-# Define cross build settings
-MRuby::CrossBuild.new('no-float') do |conf|
-  conf.toolchain
-
-  # Add configuration
-  conf.compilers.each do |c|
-    c.defines << "MRB_NO_FLOAT"
-  end
-
-  conf.gem :core => "mruby-bin-mruby"
-
-  conf.test_runner.command = 'env'
-
-  conf.enable_debug
-#  conf.enable_bintest
-  conf.enable_test
-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,16 @@
+ans
+celler
+clen
+delet
+disabl
+filetest
+fo
+hel
+ist
+nd
+quitt
+remore
+runn
+sting
+strin
+wronly

doc/guides/compile.md

@@ -7,21 +7,22 @@ binaries.
 
 To compile mruby out of the source code you need the following tools:
 
-* C Compiler (e.g. `gcc` or `clang`)
-* Linker (e.g. `gcc` or `clang`)
-* Archive utility (e.g. `ar`)
-* Parser generator (`bison`)
-* Ruby 2.0 or later (e.g. `ruby` or `jruby`)
-
-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 to upgrade `ruby`
-on MacOS in similar manner.
+- 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)
+- 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
 
@@ -32,7 +33,7 @@ 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
+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
@@ -48,10 +49,10 @@ All tools necessary to compile mruby can be set or modified here.
 
 ## Build Configuration
 
-We wish you submit a pull-request to *build_config/**PLATFORM**.rb*, once you
+We wish you submit a pull-request to `build_config/PLATFORM.rb`, once you
 created a new configuration for a new platform.
 
-Inside of the configuration file, the following options can be
+Inside the configuration file, the following options can be
 configured based on your environment.
 
 ### Toolchains
@@ -79,7 +80,7 @@ conf.toolchain :clang
 #### Visual Studio 2010, 2012 and 2013
 
 Toolchain configuration for Visual Studio on Windows. If you use the
-[Visual Studio Command Prompt](https://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
@@ -102,8 +103,8 @@ in `ANDROID_STANDALONE_TOOLCHAIN`.
 It is possible to select which tools should be compiled during the compilation
 process. For example,
 
-* `mruby`
-* `mirb`
+- `mruby`
+- `mirb`
 
 The configuration are done via `mrbgems`. See `Mrbgems` section.
 
@@ -134,21 +135,21 @@ 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`:
 
 ```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"
 ```
@@ -176,7 +177,7 @@ conf.linker do |linker|
   linker.flags_before_libraries = ...
   linker.libraries = ...
   linker.flags_after_libraries = ...
-  linker.library_paths = ....
+  linker.library_paths = ...
   linker.option_library = ...
   linker.option_library_path = ...
   linker.link_options = ...
@@ -228,7 +229,7 @@ end
 
 ### Preallocated Symbols
 
-By far, preallocate symbols are highly compatible with the previous versions, so
+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`.
 
@@ -264,13 +265,13 @@ 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.
+See [doc/guides/mrbgems.md](mrbgems.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
@@ -279,7 +280,7 @@ conf.build_mrbtest_lib_only
 ### Bintest
 
 Tests for mrbgem tools using CRuby.
-To have bintests place \*.rb scripts to `bintest/` directory of mrbgems.
+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/`.
 
@@ -308,9 +309,9 @@ If you need to enable C++ exception explicitly add the following:
 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:
 
@@ -331,11 +332,11 @@ 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.
-    * You can have better backtrace of mruby scripts with this.
+- 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
 
@@ -354,12 +355,12 @@ end
 ```
 
 All configuration options of `MRuby::Build` can also be used in
-`MRuby::CrossBuild`. You can find examples under the *build_config*
+`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
@@ -375,49 +376,44 @@ end
 
 ## Build process
 
-During the build process the directory *build* will be created in the
+During the build process the `build` directory 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
 
 ```
  _____    _____    ______    ____    ____    _____    _____    ____
@@ -428,74 +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:
+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* (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*
+- 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
 
 ```
  _______________________________________________________________
@@ -526,24 +502,22 @@ 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_NO_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 (e.g. 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
+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
@@ -553,22 +527,25 @@ 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`.
 
-```
+```console
 $ 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`
+`mruby-config --cc --cflags` c.c `mruby-config --ldflags --libs`
 ```
 
 When you use `make`, add following lines in `Makefile`
@@ -579,3 +556,57 @@ CFLAGS = `$(MRB_CONFIG) --cflags`
 LDFLAGS = `$(MRB_CONFIG) --ldflags`
 LIBS = `$(MRB_CONFIG) --libs`
 ```
+
+## Install
+
+To install the files in the `bin`, `include` and `lib` directories generated by the "host" build target into a system directory, do the following:
+
+```console
+$ rake install
+```
+
+If there are multiple build targets in the build configuration file, to install the products of all build targets, do the following:
+
+```console
+$ rake install:full
+```
+
+To install only one of several build targets, e.g., the "its-mine" build target, do the following:
+
+```console
+$ rake install:full:its-mine
+```
+
+To install only the executable files, do the following:
+
+```console
+$ rake install_bin              # only "host" build target
+$ rake install:bin              # all build targets
+$ rake install:bin:its-mine     # only "its-mine" build target
+```
+
+### Installation Directory
+
+The installation directory is `/usr/local` for the "host" build target and `/usr/local/mruby/<build-name>` for the others.
+To change them, you can set the environment variable `PREFIX` or use `MRuby::Build#install_prefix = dir` in your build configuration file.
+
+The `PREFIX` environment variable affects all build targets and changes the `/usr/local` part.
+
+The `MRuby::Build#install_prefix` can be set for each individual build target.
+In this case, the environment variable `PREFIX` is ignored.
+
+Also, if the environment variable `DESTDIR` is set, it will prepend to the path obtained by `install_prefix` to determine the final write directory.
+This is intended for temporary file expansion by the user's package work.
+
+---
+
+To summarize:
+
+- The default value of the environment variable `PREFIX` is `/usr/local`.
+- For the "host" build target, the default value of `MRuby::Build#install_prefix` is `<PREFIX>`.
+- For a build target other than "host", the default value of `MRuby::Build#install_prefix` is `<PREFIX>/mruby/<build-name>`.
+- If the environment variable `DESTDIR` is set, the actual write directory is `<DESTDIR>/<MRuby::Build#install_prefix>`.
+
+## Tips
+
+- If you see compilation troubles, try `rake clean` first.

doc/guides/debugger.md

@@ -38,7 +38,7 @@ To confirm mrdb was installed properly, run mrdb with the `--version` option:
 
 ```bash
 $ mrdb --version
-mruby 3.0.0 (2021-03-05)
+mruby 3.3.0 (2024-02-14)
 ```
 
 ## 2.2 Basic Operation
@@ -61,20 +61,20 @@ $ mrdb sample.rb
 
 You can execute the shell commands listed below:
 
-|command|description|
-|:-:|:--|
-|run|execute programs|
-|step|execute stepping|
-|continue|execute continuing program|
-|break|configure the breaking point|
-|delete|deleting the breaking points|
-|disable|disabling the breaking points|
-|enable|enabling the breaking points|
-|info breakpoints|showing list of the breaking points|
-|print|evaluating and printing the values of the mruby expressions in the script|
-|list|displaying the source cords|
-|help|showing help|
-|quit|terminating the mruby debugger|
+|     command      | description                                                               |
+| :--------------: | :------------------------------------------------------------------------ |
+|       run        | execute programs                                                          |
+|       step       | execute stepping                                                          |
+|     continue     | execute continuing program                                                |
+|      break       | configure the breaking point                                              |
+|      delete      | deleting the breaking points                                              |
+|     disable      | disabling the breaking points                                             |
+|      enable      | enabling the breaking points                                              |
+| info breakpoints | showing list of the breaking points                                       |
+|      print       | evaluating and printing the values of the mruby expressions in the script |
+|       list       | displaying the source cords                                               |
+|       help       | showing help                                                              |
+|       quit       | terminating the mruby debugger                                            |
 
 ### 2.2.2 Debugging mruby Binary Files (mrb file) with mrdb
 
@@ -82,8 +82,8 @@ You can debug the mruby binary files.
 
 #### 2.2.2.1 Debugging the binary files
 
-* notice
-To debug mruby binary files, you need to compile mruby files with option `-g`.
+- notice
+  To debug mruby binary files, you need to compile mruby files with option `-g`.
 
 ```bash
 $ mrbc -g sample.rb
@@ -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
@@ -324,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:
 
@@ -367,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,23 +3,24 @@
 _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]: 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
-execution speed.  This is an error indicating overflow of "GC arena"
+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.
+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
+The problem arises when executing C functions. The object referenced
 by C variable is also "alive", but mruby GC cannot aware of this, so
 it might mistakenly recognize the objects referenced by only C
 variables as dead.
@@ -27,18 +28,18 @@ variables as dead.
 This can be a fatal bug if the GC tries to collect a live object.
 
 In CRuby, we scan C stack area, and use C variable as root to check
-whether object is alive or not.  Of course, because we are accessing C
+whether object is alive or not. Of course, because we are accessing C
 stack just as memory region, we never know it is an integer or a
-pointer.  We workaround this by assuming that if it looks like a
-pointer, then assume it as a pointer.  We call it "conservative".
+pointer. We work around this by assuming that if it looks like a
+pointer, then assume it as a pointer. We call it "conservative".
 
 By the way, CRuby's "conservative GC" has some problems.
 
 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
+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 +47,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.
@@ -62,17 +63,17 @@ memory leak.
 
 As of this writing, mruby automatically extend arena to remember
 objects (See `MRB_GC_FIXED_ARENA` and `MRB_GC_ARENA_SIZE` in
-doc/guides/mrbconf.md).
+[doc/guides/mrbconf.md](mrbconf.md)).
 
 If you create many objects in C functions, memory usage will increase, since
-GC never kick in.  This memory usage may look like memory leak, but will also
+GC never kicks in. This memory usage may look like memory leaks, but will also
 make execution slower as more memory will need to be allocated.
 
 With the build time configuration, you can limit the maximum size of
-arena (e.g., 100).  Then if you create many objects, arena overflows,
+arena (e.g., 100). Then if you create many objects, arena overflows,
 thus you will get an "arena overflow error".
 
-To workaround these problems, we have `mrb_gc_arena_save()` and
+To work around these problems, we have `mrb_gc_arena_save()` and
 `mrb_gc_arena_restore()` functions.
 
 `int mrb_gc_arena_save(mrb)` returns the current position of the stack
@@ -93,7 +94,7 @@ In mruby, C function calls are surrounded by this save/restore, but we
 can further optimize memory usage by surrounding save/restore, and can
 avoid creating arena overflow bugs.
 
-Let's take a real example.  Here is the source code of `Array#inspect`:
+Let's take a real example. Here is the source code of `Array#inspect`:
 
 ```c
 static mrb_value
@@ -106,7 +107,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
   char tail[] = { ']' };
 
   /* check recursive */
-  for(i=0; i<RARRAY_LEN(list); i++) {
+  for (i=0; i<RARRAY_LEN(list); i++) {
     if (mrb_obj_equal(mrb, ary, RARRAY_PTR(list)[i])) {
       return mrb_str_new(mrb, "[...]", 5);
     }
@@ -117,7 +118,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
   arystr = mrb_str_new_capa(mrb, 64);
   mrb_str_cat(mrb, arystr, head, sizeof(head));
 
-  for(i=0; i<RARRAY_LEN(ary); i++) {
+  for (i=0; i<RARRAY_LEN(ary); i++) {
     int ai = mrb_gc_arena_save(mrb);
 
     if (i > 0) {
@@ -140,29 +141,29 @@ 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.
 
 After the `inspect` representation is created, we no longer require the
-individual string representation.  This means that we don't have to register
+individual string representation. This means that we don't have to register
 these temporal objects into GC arena.
 
 Therefore, in order to keep the arena size small; the `ary_inspect()` function
 will do the following:
 
-* save the position of the stack top using `mrb_gc_arena_save()`.
-* get `inspect` representation of each element.
-* append it to the constructing entire `inspect` representation of array.
-* restore stack top position using `mrb_gc_arena_restore()`.
+- save the position of the stack top using `mrb_gc_arena_save()`.
+- get `inspect` representation of each element.
+- append it to the constructing entire `inspect` representation of array.
+- restore stack top position using `mrb_gc_arena_restore()`.
 
 Please note that the final `inspect` representation of entire array
-was created before the call of `mrb_gc_arena_restore()`.  Otherwise,
+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
-like to keep some of them.  In this case, we cannot use the same idea
+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
 want to keep in the arena using `mrb_gc_protect(mrb, obj)`.

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
+
+```console
+$ 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
+
+```console
+$ 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/memory.md

@@ -0,0 +1,21 @@
+# Memory Allocation
+
+There are three methods to customize memory allocation in mruby.
+
+1. Provide your own `realloc()`/`free()`
+2. Redefine `mrb_default_allocf()`
+3. Specify a function with `mrb_open_allocf()`
+
+## Provide your own `realloc()`/`free()`
+
+On some platforms, especially on microcontrollers, the standard library may not provide `malloc()`, `realloc()`, and `free()`. In such cases, it may be necessary to define memory allocation functions for the specific platform. mruby uses `realloc()` and `free()` from the standard C library for memory management. By defining these two functions of your own, you can make mruby work. However, note the following two points:
+
+First, `realloc(NULL, size)` behaves the same as malloc(size). Second, `free(NULL)` exits without doing anything.
+
+## Redefine `mrb_default_allocf()`
+
+The only function in mruby that uses the standard C library's memory allocation functions is `mrb_default_allocf()`, defined in `alloc.c`. By defining this function within your application, you can customize the memory management of your application.
+
+## Specify a function with `mrb_open_allocf()`
+
+If you want to perform different memory management for each `mrb_state` within your application, you can use the `mrb_open_allocf()` function to create the `mrb_state` structure. This allows you to specify a memory allocation function (which is compatible with `mrb_default_allocf`) for each `mrb_state`. Although this scheme is not recommended. It may become obsolete in the future, since I have never seen per mrb_state memory management use-case.

doc/guides/mrbconf.md

@@ -1,208 +1,252 @@
-# mruby configuration macros.
+# mruby configuration macros
 
-## How to use these macros.
+## The configuration file
 
-You can use mrbconfs with following ways:
+You can do the build configuration in the build configuration file. The default
+configuration file is `build_config/default.rb`.
 
-* 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.
+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.
 
-## stdio setting.
+## How to use these macros
+
+Just add the configuration value to the `MRuby::Build#defines` attribute.
+This is the same for `MRuby::CrossBuild`.
+
+```ruby
+# build_config.rb
+
+MRuby::Build.new do |conf|
+  ...
+  conf.defines << 'MRB_GC_FIXED_ARENA'
+  conf.defines << 'MRB_NO_METHOD_CACHE'
+  ...
+end
+```
+
+**_NOTE_**
+
+- Use common definitions (`conf.defines`) instead of per-compiler definitions (e.g., `conf.cc.defines`) unless there is a special reason not to.
+- It is now deprecated to edit the `include/mruby/mrbconf.h` file or give it directly as a compiler flag, as was the case before.
+
+## 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.
-  * Printing features in **src/print.c**.
+- 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 a file.
+  - Printing features in **src/print.c**.
 
-## Debug macros.
+## 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`.
+- 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`.
+- 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`.
+- If defined doubles the stack size when extending it.
+- Otherwise 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.
+- 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.
+- Default value is `0x40000 - MRB_STACK_GROWTH`.
+- Raises `RuntimeError` when stack size exceeds this value.
 
-## Primitive type configuration.
+## Primitive type configuration
 
 `MRB_USE_FLOAT32`
 
-* 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`.
+- 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".
+- When defined removes floating-point numbers from mruby.
+- It makes mruby easier to handle in "Micro-controller 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`.
+- 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, or `MRB_INT32` are not defined on 64-bit CPU mode, `mrb_int` will be defined as `int64_t`.
-* Conflicts with `MRB_INT32`.
+- 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.
+## Garbage collector configuration
 
 `MRB_GC_STRESS`
 
-* When defined full GC is emitted per each `RBasic` allocation.
-* Mainly used in memory manager debugging.
+- When defined full GC is emitted per each `RBasic` allocation.
+- Mainly used in memory manager debugging.
+- If defined at the same time as `MRB_DEBUG`, full GC is emitted also per each heap allocation (`mrb_malloc()` or etc.).
+  This configuration slows down mruby execution by a factor of 2 to 3 or even more.
 
 `MRB_GC_TURN_OFF_GENERATIONAL`
 
-* When defined turns generational GC by default.
+- 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.
+- 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.
+- 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.
+- Defines value is `1024`.
+- Specifies number of `RBasic` per each heap page.
+- To calculate the number of bytes per heap page, it is "(size of management data per heap page) + (size per object) \* `MRB_HEAP_PAGE_SIZE`".
+  In mruby 3.1.0, the "size of management data per heap page" is 6 words, also "size per object" is 6 words.
+  For a 32-bit CPU, `(6 * 4) + (6 * 4) * MRB_HEAP_PAGE_SIZE` gives the bytes of size per heap page.
+  Conversely, for example, to keep the size per heap page to 4 Ki bytes,
+  calculate `(4096 - (6 * 4)) / (6 * 4)` to specify `MRB_HEAP_PAGE_SIZE=169`.
 
-## 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.
+- 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.
+- 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.
+- 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.
+- 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.
+- 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_FLOAT32` and `MRB_NO_FLOAT`.
+- If defined represent `mrb_value` in boxed `double`.
+- 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`.
+- If defined represent `mrb_value` as a word.
+- If defined `Float` will be a mruby object with `RBasic`.
 
-## Reduce heap memory configuration.
+## Reduce heap memory configuration
 
-`MRB_USE_LINK_TIME_RO_DATA_P`
+`MRB_USE_ETEXT_RO_DATA_P`
 
-* Only available on ELF platforms.
-* If you specify the address of a read-only section when creating a symbol or string, that string will be used as it is.
-* Heap memory can be saved.
-* Uses `__ehdr_start` and `__init_array_start`.
-* It must be `__ehdr_start < data_addr < __init_array_start`.
+- Use `etext` and `edata` section addresses defined by the linker to detect read-only data.
+- Those addresses are widely available, but not portable, nor standardized.
+- This macro is defined by default on User-mode Linux.
+
+`MRB_NO_DEFAULT_RO_DATA_P`
+
+- Define this macro when the default `mrb_ro_data_p()` does not work for any reason.
 
 `MRB_USE_CUSTOM_RO_DATA_P`
 
-* Takes precedence over `MRB_USE_LINK_TIME_RO_DATA_P`.
-* Please try if `MRB_USE_LINK_TIME_RO_DATA_P` is not available.
-* The `mrb_ro_data_p()` function is implemented by the user in an arbitrary file.
-* The prototype declaration is `mrb_bool mrb_ro_data_p(const char *ptr)`.
-* Return `TRUE` if `ptr` is in read-only section, otherwise return `FALSE`.
+- 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_MALLOC_TRIM`
+
+- call malloc_trim(0) for each mrb_full_gc() call
 
 `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.
+- Adds UTF-8 encoding support to character-oriented String instance methods.
+- If it isn't defined, they only support the US-ASCII encoding.
+
+`MRB_STR_LENGTH_MAX`
+
+- The maximum length of strings (default 1MB)
+- set this value to zero to skip the check
+
+`MRB_ARY_LENGTH_MAX`
+
+- The maximum length of strings (default 1MB)
+- set this value to zero to skip the check
 
 `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`.
+- 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.
+- Default value is `32`.
+- Specifies default size of khash table bucket.
+- Used in `kh_init_ ## name` function.
 
 `MRB_NO_METHOD_CACHE`
 
-* Disable method cache to save memory.
+- 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.
+- 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
+- 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.
+- Make it available `Symbol.all_symbols` in `mrbgems/mruby-symbol-ext`
+- Increase heap memory usage.
+
+`MRB_USE_VM_SWITCH_DISPATCH`
+
+- Turn on switch dispatch in VM loop

doc/guides/mrbgems.md

@@ -1,12 +1,13 @@
 # mrbgems
 
-mrbgems is a library manager to integrate C and Ruby extension in an easy and
-standardised way into mruby.
+mrbgems is a library manager to integrate C and Ruby extensions in an easy and
+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
 
-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:
+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:
 
 ```ruby
 conf.gem '/path/to/your/gem/dir'
@@ -20,9 +21,9 @@ conf.gem 'examples/mrbgems/ruby_extension_example'
 
 In that case,
 
-* if your build configuration file is in the `build_config` directory, it's
+- 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.
+- otherwise, it is relative from the directory where your build configuration is.
 
 A remote GIT repository location for a GEM is also supported:
 
@@ -32,7 +33,10 @@ 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:
+NOTE: `:bitbucket` option supports only git. Hg is unsupported in this
+version.
+
+You can specify the subdirectory of the repository with `:path` option:
 
 ```ruby
 conf.gem github: 'mruby/mruby', path: 'mrbgems/mruby-socket'
@@ -45,31 +49,75 @@ conf.gem :mgem => 'mruby-yaml'
 conf.gem :mgem => 'yaml' # 'mruby-' prefix could be omitted
 ```
 
-For specifying commit hash to checkout use `:checksum_hash` option:
+For specifying the commit hash to checkout use `:checksum_hash` option:
 
 ```ruby
 conf.gem mgem: 'mruby-redis', checksum_hash: '3446d19fc4a3f9697b5ddbf2a904f301c42f2f4e'
 ```
 
-If there is missing dependencies, mrbgem dependencies solver will reference
-mrbgem from core or mgem-list.
+If there are missing dependencies, mrbgem dependencies solver will reference
+mrbgem from the core or mgem-list.
 
-To pull all gems from remote GIT repository on build, call ```rake -p```,
-or ```rake --pull-gems```.
+Note that if more than one git-based gem has the same base name
+(i.e. the default checkout directory name), it is (now) an error
+**UNLESS** they have the same repository URL, branch name and
+commit-id (i.e. checksum hash). You can bypass this by explicitly
+importing your preferred version **first** and setting the
+`canonical:` option to `true`:
 
-NOTE: `:bitbucket` option supports only git. Hg is unsupported in this version.
+```ruby
+conf.gem github: 'me/mruby-yaml', branch: 'my-hacked-branch', canonical: true
+```
+
+If you do this, the system will (mostly) silently ignore other
+attempts to clone a gem with this name.
+
+Note that this only affects cloning the gem from git. It does not
+resolve version conflicts. If the version as specified in the gem's
+rakefile is incompatible with a dependency, your build will still
+fail.
+
+### Tweak the gem in your build configuration file
+
+You can give blocks in the `conf.gem` call to make adjustments for
+environments where the original gem does not expect them:
+
+```ruby
+conf.gem core: "mruby-bin-mirb" do |g|
+  # For cross build to NetBSD
+  g.linker.libraries = %w(edit termcap)
+end
+```
+
+However, it should be used with caution, as it may deviate from the intent
+of the gem's author.
+
+### Gem Testing
+
+If you enable unit tests in your build with `enable_test`, tests will be
+generated for all gems and their dependencies by default. If necessary, it is
+possible to suppress tests for a specific gem like so:
+
+```ruby
+conf.gem 'mruby-noisygem' do |g|
+  g.skip_test = true
+end
+```
+
+However, it is considered best practice to leave all tests enabled whenever
+possible. A warning message will be generated for each gem with disabled tests.
 
 ## GemBox
 
 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 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
+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 the build config
-via `config.gem`, but wrapped in an `MRuby::GemBox` object.  GemBoxes are
+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|
@@ -78,11 +126,11 @@ MRuby::GemBox.new do |conf|
 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
+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 be
 picked up by mruby.
 
-To use this example GemBox, we save it as `custom.gembox` inside the *mrbgems*
+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:
 
@@ -90,10 +138,10 @@ the build block:
 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
+If you want, you can put GemBox outside the mruby directory. In that case you must
 specify an absolute path like below.
 
 ```ruby
@@ -103,61 +151,65 @@ 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 `mrblib` directory contains pure Ruby files to extend mruby. The `src` directory
+contains C/C++ files to extend mruby. The `include` directory contains C/C++ header
+files. The `test` directory 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'
   spec.author  = 'mruby developers'
-  spec.summary = 'Example mrbgem using C and ruby'
+  spec.summary = 'Example mrbgem using C and Ruby'
 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)
-* `spec.author` or `spec.authors` (Developer name or a list of them)
-* `spec.version` (Current version)
-* `spec.description` (Detailed description)
-* `spec.summary`
-  * One line short description of mrbgem.
-  * Printed in build summary of rake when set.
-* `spec.homepage` (Homepage)
-* `spec.requirements` (External requirements as information for user)
+- `spec.license` or `spec.licenses` (A single license or a list of them under which this GEM is licensed)
+- `spec.author` or `spec.authors` (Developer name or a list of them)
+- `spec.version` (Current version)
+- `spec.description` (Detailed description)
+- `spec.summary`
+  - One line short description of mrbgem.
+  - Printed in build summary of rake when set.
+- `spec.homepage` (Homepage)
+- `spec.requirements` (External requirements as information for user)
 
 The `license` and `author` properties are required in every GEM!
 
@@ -188,15 +240,15 @@ The version requirements and default gem information are optional.
 
 Version requirement supports following operators:
 
-* '=': is equal
-* '!=': is not equal
-* '>': is greater
-* '<': is lesser
-* '>=': 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'
+- '=': is equal
+- '!=': is not equal
+- '>': is greater
+- '<': is lesser
+- '>=': 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'
 
 When more than one version requirements is passed, the dependency must satisfy all of it.
 
@@ -209,8 +261,8 @@ 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.
+- `spec.add_conflict(gem, *requirements)`
+  - The `requirements` argument is same as in `add_dependency` method.
 
 like following code:
 
@@ -227,22 +279,22 @@ 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)
-* `spec.cc.include_paths` (C compiler include paths)
-* `spec.linker.flags` (Linker flags)
-* `spec.linker.libraries` (Linker libraries)
-* `spec.linker.library_paths` (Linker additional library path)
-* `spec.bins` (Generate binary file)
-* `spec.rbfiles` (Ruby files to compile)
-* `spec.objs` (Object files to compile)
-* `spec.test_rbfiles` (Ruby test files for integration into mrbtest)
-* `spec.test_objs` (Object test files for integration into mrbtest)
-* `spec.test_preload` (Initialization files for mrbtest)
+- `spec.cc.flags` (C compiler flags)
+- `spec.cc.defines` (C compiler defines)
+- `spec.cc.include_paths` (C compiler include paths)
+- `spec.linker.flags` (Linker flags)
+- `spec.linker.libraries` (Linker libraries)
+- `spec.linker.library_paths` (Linker additional library path)
+- `spec.bins` (Generate binary file)
+- `spec.rbfiles` (Ruby files to compile)
+- `spec.objs` (Object files to compile)
+- `spec.test_rbfiles` (Ruby test files for integration into mrbtest)
+- `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
 
@@ -251,7 +303,7 @@ 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 rake.
 You can use `spec.export_include_paths` accessor if you want more complex build.
@@ -265,10 +317,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");
@@ -280,10 +332,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);
@@ -292,25 +344,27 @@ 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*
-folder.
+classes or add new ones in this way. Put all Ruby files into the `mrblib`
+directory.
 
 ### Pre-Conditions
 
@@ -318,29 +372,31 @@ 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` directory and all C files into the `src` directory.
 
-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*.
+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_.
 
 ### Pre-Conditions
 
@@ -348,20 +404,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

@@ -1,10 +1,10 @@
 # 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
+`uint32_t`. Lower 30 bits are used for symbols so that higher 2 bits can be
 used as flags, e.g. `struct mt_elem` in `class.c`.
 
-```C
+```c
 struct mt_elem {
   union mt_ptr ptr;
   size_t func_p:1;
@@ -57,13 +57,13 @@ To save RAM, `mruby` can use compile-time allocation of some symbols. You can
 use following macros to get preallocated symbols by including `mruby/presym.h`
 header.
 
- * `MRB_SYM(xor)`    //=> xor    (Word characters)
- * `MRB_SYM_B(xor)`  //=> xor!   (Method with Bang)
- * `MRB_SYM_Q(xor)`  //=> xor?   (Method with Question mark)
- * `MRB_SYM_E(xor)`  //=> xor=   (Method with Equal)
- * `MRB_CVSYM(xor)`  //=> @@xor  (Class Variable)
- * `MRB_IVSYM(xor)`  //=> @xor   (Instance Variable)
- * `MRB_OPSYM(xor)`  //=> ^      (Operator)
+- `MRB_SYM(xor)` //=> xor (Word characters)
+- `MRB_SYM_B(xor)` //=> xor! (Method with Bang)
+- `MRB_SYM_Q(xor)` //=> xor? (Method with Question mark)
+- `MRB_SYM_E(xor)` //=> xor= (Method with Equal)
+- `MRB_CVSYM(xor)` //=> @@xor (Class Variable)
+- `MRB_IVSYM(xor)` //=> @xor (Instance Variable)
+- `MRB_OPSYM(xor)` //=> ^ (Operator)
 
 For `MRB_OPSYM()`, specify the names corresponding to operators (see
 `MRuby::Presym::OPERATORS` in `lib/mruby/presym.rb` for the names that
@@ -71,9 +71,9 @@ 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,
+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
+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.
 

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 platforms (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 bit pointers are too big to fit in NaN, but practically most OS use 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,136 @@
+# 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 106 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
+of operands.
+
+- B: 8bit
+- S: 16bit
+- W: 24bit
+
+If the first and second operands are of type `B` (8bits), they may be
+extended to 16bits by the operand extension instruction immediately
+preceding them.
+See also `OP_EXT1`, `OP_EXT2` and `OP_EXT3`.
+
+## 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_GETIDX`        | `B`            | `R(a) = R(a)[R(a+1)]`                                      |
+| `OP_SETIDX`        | `B`            | `R(a)[R(a+1)] = R(a+2)`                                    |
+| `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_SSEND`         | `BBB`          | `R(a) = self.send(Syms(b),R(a+1)..,R(a+n+1):R(a+n+2)..) (c=n\|k<<4)` |
+| `OP_SSENDB`        | `BBB`          | `R(a) = self.send(Syms(b),R(a+1)..,R(a+n+1):R(a+n+2)..,&R(a+n+2k+1))` |
+| `OP_SEND`          | `BBB`          | `R(a) = R(a).send(Syms(b),R(a+1)..,R(a+n+1):R(a+n+2)..) (c=n\|k<<4)` |
+| `OP_SENDB`         | `BBB`          | `R(a) = R(a).send(Syms(b),R(a+1)..,R(a+n+1):R(a+n+2)..,&R(a+n+2k+1))` |
+| `OP_CALL`          | `-`            | `self.call(*, **, &) (But overlay the current call frame; tailcall)` |
+| `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_ARYSPLAT`      | `B`            | `R(a) = ary_splat(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_SYMBOL`        | `BB`           | `R(a) = intern(Pool(b))`                                   |
+| `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 (a) 16bit`                               |
+| `OP_EXT2`          | `-`            | `make 2nd operand (b) 16bit`                               |
+| `OP_EXT3`          | `-`            | `make 1st and 2nd operands 16bit`                          |
+| `OP_STOP`          | `-`            | `stop VM`                                                  |

doc/limitations.md

@@ -13,28 +13,6 @@ This document is collecting these limitations.
 This document does not contain a complete list of limitations.
 Please help to improve it by submitting your findings.
 
-## `Array` passed to `puts`
-
-Passing an Array to `puts` results in different output.
-
-```ruby
-puts [1,2,3]
-```
-
-#### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
-
-```
-1
-2
-3
-```
-
-#### mruby [3.0.0 (2021-03-05)]
-
-```
-[1, 2, 3]
-```
-
 ## `Kernel.raise` in rescue clause
 
 `Kernel.raise` without arguments does not raise the current exception within
@@ -52,9 +30,9 @@ end
 
 `ZeroDivisionError` is raised.
 
-#### mruby [3.0.0 (2021-03-05)]
+#### mruby [3.1.0 (2022-05-12)]
 
-No exception is raised. Instead you have to do:
+`RuntimeError` is raised instead of `ZeroDivisionError`. To re-raise the exception, you have to do:
 
 ```ruby
 begin
@@ -66,7 +44,7 @@ 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.
 
@@ -77,7 +55,7 @@ To reduce memory consumption `Array` does not support instance variables.
 ```ruby
 class Liste < Array
   def initialize(str = nil)
-    @feld = str
+    @field = str
   end
 end
 
@@ -86,16 +64,16 @@ p Liste.new "foobar"
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-` [] `
+`[]`
 
-#### mruby [3.0.0 (2021-03-05)]
+#### mruby [3.1.0 (2022-05-12)]
 
 `ArgumentError` is raised.
 
 ## Method visibility
 
 For simplicity reasons no method visibility (public/private/protected) is
-supported. Those methods are defined but they are dummy methods.
+supported. Those methods are defined, but they are dummy methods.
 
 ```ruby
 class VisibleTest
@@ -118,7 +96,7 @@ false
 true
 ```
 
-#### mruby [3.0.0 (2021-03-05)]
+#### mruby [3.1.0 (2022-05-12)]
 
 ```
 true
@@ -129,14 +107,14 @@ true
 
 The declaration form of following visibility methods are not implemented.
 
-* `public`
-* `private`
-* `protected`
-* `module_function`
+- `public`
+- `private`
+- `protected`
+- `module_function`
 
 Especially, `module_function` method is not dummy, but no declaration form.
 
-```
+```ruby
 module TestModule
   module_function
   def test_func
@@ -155,7 +133,7 @@ p 'ok'
 ok
 ```
 
-#### mruby [3.0.0 (2021-03-05)]
+#### mruby [3.1.0 (2022-05-12)]
 
 ```
 test.rb:8: undefined method 'test_func' (NoMethodError)
@@ -177,7 +155,7 @@ defined?(Foo)
 nil
 ```
 
-#### mruby [3.0.0 (2021-03-05)]
+#### mruby [3.1.0 (2022-05-12)]
 
 `NameError` is raised.
 
@@ -192,9 +170,9 @@ alias $a $__a__
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-` nil `
+`nil`
 
-#### mruby [3.0.0 (2021-03-05)]
+#### mruby [3.1.0 (2022-05-12)]
 
 Syntax error
 
@@ -216,52 +194,22 @@ end
 `ArgumentError` is raised.
 The re-defined `+` operator does not accept any arguments.
 
-#### mruby [3.0.0 (2021-03-05)]
+#### mruby [3.1.0 (2022-05-12)]
 
-` 'ab' `
+`'ab'`
 Behavior of the operator wasn't changed.
 
-## `Kernel#binding` is not supported
+## `Kernel#binding` is not supported until [3.0.0 (2021-03-05)]
 
 `Kernel#binding` method is not supported.
 
 #### Ruby [ruby 2.5.1p57 (2018-03-29 revision 63029)]
 
-```
+```shell
 $ ruby -e 'puts Proc.new {}.binding'
 #<Binding:0x00000e9deabb9950>
 ```
 
-#### mruby [3.0.0 (2021-03-05)]
-
-```
-$ ./bin/mruby -e 'puts Proc.new {}.binding'
-trace (most recent call last):
-        [0] -e:1
--e:1: undefined method 'binding' (NoMethodError)
-```
-
-## Keyword arguments
-
-mruby keyword arguments behave slightly different from CRuby 2.5
-to make the behavior simpler and less confusing.
-
-#### 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}]
-```
-
-#### mruby [3.0.0 (2021-03-05)]
-
-```
-$ ./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)
-```
-
 ## `nil?` redefinition in conditional expressions
 
 Redefinition of `nil?` is ignored in conditional expressions.
@@ -274,7 +222,7 @@ end
 puts(a.nil? ? "truthy" : "falsy")
 ```
 
-Ruby outputs `falsy`. mruby outputs `truthy`.
+Ruby outputs `truthy`. mruby outputs `falsy`.
 
 ## Argument Destructuring
 
@@ -296,3 +244,12 @@ f(1,[2,3])
 ```
 
 CRuby gives `[1,2,3,nil]`. mruby raises `NoMethodError` for `b`.
+
+Keyword argument expansion has similar restrictions. The following example, gives `[1, 1]` for CRuby, mruby raises `NoMethodError` for `b`.
+
+```ruby
+def g(a: 1, b: a)
+  p [a,b]
+end
+g(a:1)
+```

doc/mruby3.0.md

@@ -1,5 +1,4 @@
-User visible changes in `mruby3`
-===
+# User visible changes in `mruby3.0`
 
 # Build System
 
@@ -8,17 +7,17 @@ User visible changes in `mruby3`
 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
+- `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`,
+used. So you can specify it as `rake MRUBY_CONFIG=boxing`,
 for example.
 
 # Build Configuration Contribution
@@ -33,20 +32,20 @@ pull-request.
 
 We have ported some new syntax from CRuby.
 
-* Single line pattern matching (`12 => x`);
+- 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`)
+- 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`).
+or `MRB_NO_XXX`).
 
-|             mruby2             |          mruby3           |
-|--------------------------------|---------------------------|
+| 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`   |
@@ -60,11 +59,11 @@ Some configuration macro names are changed for consistency (use `MRB_USE_XXX`
 | `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
+- `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_` prefix is added to those without.
 
 ## `MRB_NO_BOXING`
 
@@ -76,13 +75,13 @@ to be default `mrb_value` representation. Now the default is
 ## `MRB_WORD_BOXING`
 
 Pack `mrb_value` in an `intptr_t` integer. Consumes less
-memory compared to `MRB_NO_BOXING` especially on 32 bit
+memory compared to `MRB_NO_BOXING` especially on 32-bit
 platforms. `Fixnum` size is 31 bits so some integer values
 does not fit in `Fixnum` integers.
 
 ## `MRB_NAN_BOXING`
 
-Pack `mrb_value` in a floating pointer number. Nothing
+Pack `mrb_value` in a floating-point number. Nothing
 changed from previous versions.
 
 ## `MRB_USE_MALLOC_TRIM`
@@ -113,44 +112,45 @@ $ bin/mruby -r lib1.rb -r lib2.rb < app.mrb
 
 Instructions that access pool[i]/syms[i] where i>255.
 
-* `OP_LOADL16`
-* `OP_STRING16`
-* `OP_LOADSYM16`
+- `OP_LOADL16`
+- `OP_STRING16`
+- `OP_LOADSYM16`
 
-Instructions that load a 32 bit integer.
+Instructions that load a 32-bit integer.
 
-* `OP_LOADI32`
+- `OP_LOADI32`
 
 Instruction that unwinds jump table for rescue/ensure.
 
-* `OP_JMPUW`
+- `OP_JMPUW`
 
 Renamed from `OP_RAISE`
 
-* `OP_RAISEIF`
+- `OP_RAISEIF`
 
 Instruction that is reserved for the future keyword argument support.
 
-* OP_SENDVK
+- OP_SENDVK
 
 ## Removed Instructions
 
 Instructions for old exception handling
 
-* `OP_ONERR`
-* `OP_POPERR`
-* `OP_EPUSH`
-* `OP_EPOP`
+- `OP_ONERR`
+- `OP_POPERR`
+- `OP_EPUSH`
+- `OP_EPOP`
 
 No more operand extension
 
-* `OP_EXT1`
-* `OP_EXT2`
-* `OP_EXT3`
+- `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.
+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++`.
 
@@ -160,4 +160,4 @@ For better and faster random number generation.
 
 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).
+See [Symbols](guides/symbol.md).

doc/mruby3.1.md

@@ -0,0 +1,255 @@
+# User visible changes in `mruby3.1` from `mruby3.0`
+
+# New Features
+
+## Core Language Features
+
+### Keyword Arguments
+
+CRuby3.0 compatible keyword arguments are introduced.
+Keyword arguments are basically separated from ordinal arguments.
+
+### Other Language Enhancement
+
+- Implement endless-def [Ruby:Feature#16746](https://bugs.ruby-lang.org/issues/16746)
+- Replace `R-assignment` by `single-line pattern matching` [Ruby:Feature#15921](https://bugs.ruby-lang.org/issues/15921)
+- Support squiggly heredocs. [#5246](https://github.com/mruby/mruby/pull/5246)
+- Hash value omission [Ruby:Feature#14579](https://bugs.ruby-lang.org/issues/14579)
+
+## 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
+
+---
+
+# Updated Features
+
+## New build configurations
+
+We have added several new build configurations in the `build_config` directory.
+
+- `cross-mingw-winetest.rb`
+- `cross-mingw.rb`
+- `nintendo_switch.rb`
+- `serenity.rb`
+- `minimal`: minimal configuration
+- `host-f32`: compiles with `mrb_float` as 32 bit `float`
+- `host-nofloat`: compiles with no float configuration
+- `android_arm64_v8a.rb`: renamed from `android_arm64-v8a.rb`
+
+## Core Libraries
+
+### New Methods
+
+- `Array#product`
+- `Array#repeated_combination`
+- `Array#repeated_permutation`
+- `Kernel#__ENCODING__`
+- `Random.bytes`
+- `Random#bytes`
+- `String#center`
+
+### New Gem Enhancement
+
+- `mrbgems/mruby-pack` now supports `M` directive (Q encoding)
+- `mrbgems/mruby-pack` now supports `X` directive (back-up by bytes)
+- `mrbgems/mruby-pack` now supports `@` directive (absolute position)
+- `mrbgems/mruby-pack` now supports `w` directive (BER compression)
+
+## Tools
+
+- `mruby-config` now supports `--cc` and `--ld` options.
+- Remove `OP_` prefix from `mruby -v` code dump output.
+- Prohibit use of `OP_EXT{1,2,3}` by `mrbc` with `--no-ext-ops` option.
+
+## Features for mruby Developer
+
+- Add new specifier `c` to `mrb_get_args()` for receive Class/Module.
+
+---
+
+# Breaking Changes
+
+## Incompatibly Changed Methods
+
+- `Kernel#printf` (`mruby-sprintf`) Format specifiers `%a` and `%A` are removed.
+- `Kernel#puts` (`mruby-print`) Now expand Array arguments.
+
+## mruby VM and bytecode
+
+Due to improvements in the binary format, mruby binaries are no longer backward compatible.
+To run the mruby binaries on mruby 3.1, recompile with the mruby 3.1 `mrbc`.
+
+- Upgrade mruby VM version `RITE_VM_VER` to `0300` (means mruby 3.0 or after).
+- Upgrade mruby binary version `RITE_BINARY_FORMAT_VER` to `0300`.
+
+## Reintroduced Instructions
+
+`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 1 operands `R[a][a+1]`
+- `OP_SETIDX`: takes 1 operands `R[a][a+1]=R[a+2]`
+- `OP_SSEND`: takes 3 operands `a=self.b(c...)`; see `OP_SEND`
+- `OP_SSENDB`: takes 3 operands `a=self.b(c...){...}`; see `OP_SEND`
+- `OP_SYMBOL`: takes 2 operands `R[a] = intern(Pool[b])`
+
+### `OP_GETIDX` and `OP_SETIDX`
+
+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.
+
+### `OP_SYMBOL`
+
+Extracts the character string placed in the pool as a symbol.
+
+## 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 allocate integer values in the heap, if the value does not fit in the 32 bit range, just like we did in Word Boxing.
+
+## Constant Folding
+
+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.
+
+---
+
+# Major bug fixes
+
+- Fix infinite recursive call bugs in integer division [98799aa6](https://github.com/mruby/mruby/commit/98799aa6)
+- Fix to raise TypeError with super inside instance_eval / class_eval [#5476](https://github.com/mruby/mruby/pull/5476)
+- Fix to call `method_added` hooks on method definitions; [#2339](https://github.com/mruby/mruby/pull/2339)
+- Fix a potential buffer overflow in `time_zonename` [26340a88](https://github.com/mruby/mruby/commit/26340a88)
+- Fix `Module.instance_eval` bug [#5528](https://github.com/mruby/mruby/pull/5528)
+- Fix fix `M` packing bug [bfe2bd49](https://github.com/mruby/mruby/commit/bfe2bd49)
+- Fix a bug regarding attribute assignment with kargs [de2b4bd0](https://github.com/mruby/mruby/commit/de2b4bd0)
+- Fix SIGSEGV with mrbgems/mruby-method [#5580](https://github.com/mruby/mruby/pull/5580)
+- Fix print error before cleanup in `codegen_error()` [#5603](https://github.com/mruby/mruby/pull/5603)
+- Fix a bug in unpacking BER [#5611](https://github.com/mruby/mruby/pull/5611)
+- Fix a bug with numbered parameters as arguments [#5605](https://github.com/mruby/mruby/pull/5605)
+- Fix `mrb_ary_shift_m` initialization bug [27d1e013](https://github.com/mruby/mruby/commit/27d1e013)
+- Fix keyword argument with `super` [#5628](https://github.com/mruby/mruby/pull/5628)
+- Fix a bug with numbered parameters on toplevel [7e7f1b2f](https://github.com/mruby/mruby/commit/7e7f1b2f)
+- Fix keyword argument bug [#5632](https://github.com/mruby/mruby/issues/5632)
+- Fix multiple assignments in parameters [#5647](https://github.com/mruby/mruby/issues/5647)
+- Fix keyword parameters not passing through super [#5660](https://github.com/mruby/mruby/issues/5660)
+- Fix infinite loop from unclosed here-doc [#5676](https://github.com/mruby/mruby/issues/5676)
+- Fix negative integer division bug [#5678](https://github.com/mruby/mruby/issues/5678)
+
+# CVEs
+
+## Fixed CVEs
+
+Following CVEs are fixed in this release.
+
+- [CVE-2021-4110](https://www.cve.org/CVERecord?id=CVE-2021-4110)
+- [CVE-2021-4188](https://www.cve.org/CVERecord?id=CVE-2021-4188)
+- [CVE-2022-0080](https://www.cve.org/CVERecord?id=CVE-2022-0080)
+- [CVE-2022-0240](https://www.cve.org/CVERecord?id=CVE-2022-0240)
+- [CVE-2022-0326](https://www.cve.org/CVERecord?id=CVE-2022-0326)
+- [CVE-2022-0481](https://www.cve.org/CVERecord?id=CVE-2022-0481)
+- [CVE-2022-0631](https://www.cve.org/CVERecord?id=CVE-2022-0631)
+- [CVE-2022-0632](https://www.cve.org/CVERecord?id=CVE-2022-0632)
+- [CVE-2022-0890](https://www.cve.org/CVERecord?id=CVE-2022-0890)
+- [CVE-2022-1071](https://www.cve.org/CVERecord?id=CVE-2022-1071)
+- [CVE-2022-1106](https://www.cve.org/CVERecord?id=CVE-2022-1106)
+- [CVE-2022-1201](https://www.cve.org/CVERecord?id=CVE-2022-1201)
+- [CVE-2022-1427](https://www.cve.org/CVERecord?id=CVE-2022-1427)
+
+## Unaffected CVEs
+
+Following CVEs do not cause problems in this release. They are fixed in the later release.
+
+- [CVE-2022-0481](https://www.cve.org/CVERecord?id=CVE-2022-0481)
+- [CVE-2022-0525](https://www.cve.org/CVERecord?id=CVE-2022-0525)
+- [CVE-2022-0570](https://www.cve.org/CVERecord?id=CVE-2022-0570)
+- [CVE-2022-0614](https://www.cve.org/CVERecord?id=CVE-2022-0614)
+- [CVE-2022-0623](https://www.cve.org/CVERecord?id=CVE-2022-0623)
+- [CVE-2022-0630](https://www.cve.org/CVERecord?id=CVE-2022-0630)
+- [CVE-2022-0717](https://www.cve.org/CVERecord?id=CVE-2022-0817)
+- [CVE-2022-1212](https://www.cve.org/CVERecord?id=CVE-2022-1212)
+- [CVE-2022-1276](https://www.cve.org/CVERecord?id=CVE-2022-1276)
+- [CVE-2022-1286](https://www.cve.org/CVERecord?id=CVE-2022-1286)

doc/mruby3.2.md

@@ -0,0 +1,79 @@
+# User visible changes in `mruby3.2` from `mruby3.1`
+
+# The language
+
+- Now `a::B = c` should evaluate `a` then `c`.
+- Anonymous arguments `*`, `**`, `&` can be passed for forwarding.
+- Multi-precision integer is available now via `mruby-bigint` gem.
+
+# mruby VM and bytecode
+
+- `OP_ARYDUP` was renamed to `OP_ARYSPLAT`. The instruction name
+  was changed but instruction number and basic behavior have not
+  changed (except that `ARYDUP nil` makes `[]`).
+
+# Tools
+
+## `mruby`
+
+- `-b` only specifies the script is the binary. The files loaded by `-r` are not affected by the option.
+- `mruby` now loads complied binary if the suffix is `.mrb`.
+
+## `mrbc`
+
+- Add `--no-optimize` option to disable optimization.
+
+# mrbgems
+
+## mruby-class-ext
+
+- Add `Class#subclasses` method.
+- Add `Module#undefined_instance_methods` method.
+
+## New bundled gems
+
+- mruby-errno from <https://github.com/iij/mruby-errno.git>
+- mruby-set from <https://github.com/yui-knk/mruby-set.git>
+- mruby-dir from <https://github.com/iij/mruby-dir.git>
+- mruby-data
+
+# Breaking Changes
+
+## `mrb_vm_run()` may detach top-level local variables referenced from blocks
+
+When the `mrb_vm_run()` function (including `mrb_top_run()`) is called,
+the previous top-level local variables referenced from blocks is detached under either of the following conditions.
+
+- If the `stack_keep` parameter is given as 0.
+- If the number of variables in `irep` to be executed is less than the number of previous top-level local variables.
+
+This change also affects API functions such as `mrb_load_string()` and `mrb_load_file()`.
+The conditions under which the previous top-level local variables referenced from blocks is detached in these functions are as follows:
+
+- If the function has no `mrbc_context` pointer parameter, or the `mrbc_context` pointer parameter is set to `NULL`.
+- If the number of variables held in the `mrbc_context` pointer is less than the number of previous top-level local variables.
+
+Intentional reliance on previous behavior may cause compatibility problems in your application.
+
+# CVEs
+
+Following CVEs are fixed.
+
+- [CVE-2022-0080](https://www.cve.org/CVERecord?id=CVE-2022-0080)
+- [CVE-2022-0240](https://www.cve.org/CVERecord?id=CVE-2022-0240)
+- [CVE-2022-0326](https://www.cve.org/CVERecord?id=CVE-2022-0326)
+- [CVE-2022-0481](https://www.cve.org/CVERecord?id=CVE-2022-0481)
+- [CVE-2022-0525](https://www.cve.org/CVERecord?id=CVE-2022-0525)
+- [CVE-2022-0570](https://www.cve.org/CVERecord?id=CVE-2022-0570)
+- [CVE-2022-0614](https://www.cve.org/CVERecord?id=CVE-2022-0614)
+- [CVE-2022-0623](https://www.cve.org/CVERecord?id=CVE-2022-0623)
+- [CVE-2022-0630](https://www.cve.org/CVERecord?id=CVE-2022-0630)
+- [CVE-2022-0631](https://www.cve.org/CVERecord?id=CVE-2022-0631)
+- [CVE-2022-0632](https://www.cve.org/CVERecord?id=CVE-2022-0632)
+- [CVE-2022-0717](https://www.cve.org/CVERecord?id=CVE-2022-0717)
+- [CVE-2022-0890](https://www.cve.org/CVERecord?id=CVE-2022-0890)
+- [CVE-2022-1106](https://www.cve.org/CVERecord?id=CVE-2022-1106)
+- [CVE-2022-1212](https://www.cve.org/CVERecord?id=CVE-2022-1212)
+- [CVE-2022-1276](https://www.cve.org/CVERecord?id=CVE-2022-1276)
+- [CVE-2022-1286](https://www.cve.org/CVERecord?id=CVE-2022-1286)
+- [CVE-2022-1934](https://www.cve.org/CVERecord?id=CVE-2022-1934)

doc/mruby3.3.md

@@ -0,0 +1,186 @@
+# User visible changes in `mruby3.3` from `mruby3.2`
+
+"**_NOTE_**:" are changes to be aware of.
+
+# The language
+
+- aliases work properly with `super` ([2ad3f0e](https://github.com/mruby/mruby/commit/2ad3f0e))
+- `callee` method work differently with aliases in mruby ([f2dc76e](https://github.com/mruby/mruby/commit/f2dc76e))
+- define `Kernel#respond_to_missing?` method ([347586e](https://github.com/mruby/mruby/commit/347586e))
+- `_inspect` method (`inspect` with recursive check) is removed
+  ([e2bbf75](https://github.com/mruby/mruby/commit/e2bbf75), [5cb0c74](https://github.com/mruby/mruby/commit/5cb0c74), [113565a](https://github.com/mruby/mruby/commit/113565a),
+  [0713f2a](https://github.com/mruby/mruby/commit/0713f2a), [6ae6b63](https://github.com/mruby/mruby/commit/6ae6b63), [fc9fffc](https://github.com/mruby/mruby/commit/fc9fffc))
+- `__printstr__` method is removed; use `print` instead
+  ([acecee0](https://github.com/mruby/mruby/commit/acecee0), [192e6e3](https://github.com/mruby/mruby/commit/192e6e3))
+- New method `String#bytesplice` ([5274647](https://github.com/mruby/mruby/commit/5274647), [a2e2e83](https://github.com/mruby/mruby/commit/a2e2e83))
+- Allow `return` in blocks to cross C boundaries ([#6125](https://github.com/mruby/mruby/pull/6125))
+
+# Configuration
+
+- mruby can be built using Docker now. Try `docker-compose build` for example. ([#5961](https://github.com/mruby/mruby/pull/5961))
+- New Platform: DJGPP (MS-DOS) ([#6022](https://github.com/mruby/mruby/pull/6022))
+- New Platform: Nintendo Wii ([#6086](https://github.com/mruby/mruby/pull/6086))
+- Improved Platform: Android ([#6013](https://github.com/mruby/mruby/pull/6013))
+- Improved Platform: Dreamcast ([#6130](https://github.com/mruby/mruby/pull/6130))
+- Allow tests to be disabled for specific gems; warn about disabled tests ([#6012](https://github.com/mruby/mruby/pull/6012))
+- Replace `MRB_NO_DIRECT_THREADING` with `MRB_USE_VM_SWITCH_DISPATCH` ([#5902](https://github.com/mruby/mruby/pull/5902))
+
+# mruby memory API
+
+- `mrb_default_allocf` can be overridden by the application ([34c5d96](https://github.com/mruby/mruby/commit/34c5d96))
+- `mrb_open_allocf` will be deprecated ([cfee5c2](https://github.com/mruby/mruby/commit/cfee5c2))
+
+# Changes in C API
+
+- add new error handling API functions ([8c8bbd9](https://github.com/mruby/mruby/commit/8c8bbd9))
+- Add `mrb_vm_ci_env_clear()` function with `MRB_API` ([#5945](https://github.com/mruby/mruby/pull/5945))
+- a new function `mrb_check_frozen_value()` ([ccdf75c](https://github.com/mruby/mruby/commit/ccdf75c))
+- avoid formatting in `mrb_bug()` ([82a48bd](https://github.com/mruby/mruby/commit/82a48bd)) <br>
+  **_NOTE_**: If you are using it, you must give a simple string or replace it with a call to `mrb_raise()` series.
+- stop using `mrbc_` prefix for compiler context ([c5e3cbe](https://github.com/mruby/mruby/commit/c5e3cbe)) <br>
+  The same names are provided as before, but we recommend replacing them.
+- Allow `Class#allocate` to be prohibited
+  ([#5979](https://github.com/mruby/mruby/pull/5979), [#6122](https://github.com/mruby/mruby/pull/6122), [#6123](https://github.com/mruby/mruby/pull/6123)) <br>
+  To disable `#allocate`, use `MRB_UNDEF_ALLOCATOR()`.
+  This is also automatically applied when the subclass is created, but to explicitly allow it, use `MRB_DEFINE_ALLOCATOR()`.
+
+# Changes in mrbgems
+
+- **default.gembox**: Add mruby debugger mrdb (`mruby-bin-debugger`) ([#5966](https://github.com/mruby/mruby/pull/5966))
+- **mruby-bin-config**: new options `--cxx`, `--cxxflags`, `--as`, `--asflags`, `--objc`, `--objcflags` ([#6054](https://github.com/mruby/mruby/pull/6054))
+- **mruby-binding**: renamed from `mruby-binding-core` of mruby3.2 ([11af5db](https://github.com/mruby/mruby/commit/11af5db)) <br>
+  **_NOTE_**: If using `mruby-binding-core` of mruby 3.2, replace it with `mruby-binding`.
+- **mruby-binding**: implemented `Binding#initialize_copy` method ([#5517](https://github.com/mruby/mruby/pull/5517))
+- **mruby-binding**: `Kernel#binding` responds only to calls from Ruby ([#5981](https://github.com/mruby/mruby/pull/5981))
+- **mruby-compar-ext**: Comparable#clamp to accept nil as arguments ([836bebc](https://github.com/mruby/mruby/commit/836bebc))
+- **mruby-compiler**: add print name for identifier tokens ([d7b2e3a](https://github.com/mruby/mruby/commit/d7b2e3a))
+- **mruby-data**: allow empty Data ([927a9df](https://github.com/mruby/mruby/commit/927a9df))
+- **mruby-enumerator**: remove internal attribute methods `obj`, `args`, `kwd`, `meth`, `fib`. ([735fa24](https://github.com/mruby/mruby/commit/735fa24))
+- **mruby-enumerator**: add Enumerator#size ([861f8bd](https://github.com/mruby/mruby/commit/861f8bd))
+- **mruby-eval**: merged `mruby-binding` of mruby3.2 ([501b22a](https://github.com/mruby/mruby/commit/501b22a), [#5989](https://github.com/mruby/mruby/pull/5989)) <br>
+  **_NOTE_**: If using `mruby-binding` of mruby 3.2, replace it with `mruby-eval`.
+- **mruby-fiber**: Add a new `mrb_fiber_new()` with `MRB_API` ([#6097](https://github.com/mruby/mruby/pull/6097))
+- **mruby-fiber**: Allows calling `Fiber#resume` from C ([#6106](https://github.com/mruby/mruby/pull/6106))
+- **mruby-fiber**: `Fiber#to_s` format changed ([#6105](https://github.com/mruby/mruby/pull/6105))
+- **mruby-io**: add File#atime and File#ctime ([321cfe9](https://github.com/mruby/mruby/commit/321cfe9))
+- **mruby-io**: Add "x" mode option for `IO.open` ([#6081](https://github.com/mruby/mruby/pull/6081))
+- **mruby-io**: File.new should not take blocks ([53de964](https://github.com/mruby/mruby/commit/53de964))
+- **mruby-method**: `Method#to_s` format changed ([f5bc82f](https://github.com/mruby/mruby/commit/f5bc82f), [02f189c](https://github.com/mruby/mruby/commit/02f189c))
+- **mruby-numeric-ext**: `int.pow(n,m)` to take bigint as exponential ([d482eab](https://github.com/mruby/mruby/commit/d482eab))
+- **mruby-pack**: support new directives `j`, `J`, `b`, `B`, `#`
+  ([2a1e3a5](https://github.com/mruby/mruby/commit/2a1e3a5), [e7021f1](https://github.com/mruby/mruby/commit/e7021f1), [e17f325](https://github.com/mruby/mruby/commit/e17f325))
+- **mruby-range-ext**: new method `Range#overlap?` ([384d0e2](https://github.com/mruby/mruby/commit/384d0e2))
+- **mruby-string-ext**: Add `String#valid_encoding?` method ([eabe2d9](https://github.com/mruby/mruby/commit/eabe2d9))
+- **mruby-struct**: allow empty Struct when a name is not given ([c212ede](https://github.com/mruby/mruby/commit/c212ede))
+- **mruby-time**: should allow year before 1900 ([e5de08b](https://github.com/mruby/mruby/commit/e5de08b))
+- **mruby-time**: support bigint to time_t if necessary ([7096d27](https://github.com/mruby/mruby/commit/7096d27))
+- **mruby-time**: need to handle negative time_t ([b064d7e](https://github.com/mruby/mruby/commit/b064d7e))
+
+# Changes in build system
+
+- Extended `rake install` task ([#5928](https://github.com/mruby/mruby/pull/5928)) <br>
+  **_NOTE_**: Due to this impact, executable files in the `mruby/bin/` directory by default are now symbolic links (batch files on Windows).
+  If previously relied on those executables, should be replaced with direct references to the entity created under the build directory (e.g. `mruby/build/host/bin/`).
+- Encode and decode escape characters for presym ([#6011](https://github.com/mruby/mruby/pull/6011))
+- Rakefile: remove default build target directories in `deep_clean` ([#6032](https://github.com/mruby/mruby/pull/6032), [1e38569](https://github.com/mruby/mruby/commit/1e38569))
+
+# Other breaking changes
+
+- `mrb_f_raise()` is now an internal function
+  ([#5923](https://github.com/mruby/mruby/pull/5923), [#6070](https://github.com/mruby/mruby/pull/6070))
+- `mrb_make_exception()` is now an internal function with different parameters
+  ([431f83e](https://github.com/mruby/mruby/commit/431f83e), [78137f3](https://github.com/mruby/mruby/commit/78137f3))
+- The `File#path` method no longer uses the `#to_path` method for implicit conversion
+  ([d86c4a7](https://github.com/mruby/mruby/commit/d86c4a7))
+- stop mrb isolation for each test file ([a20fbe5](https://github.com/mruby/mruby/commit/a20fbe5))
+- RBreak remembers the CI location ([#6103](https://github.com/mruby/mruby/pull/6103))
+
+# Bugs Fixed
+
+- [#5724](https://github.com/mruby/mruby/issues/5724) Rational#\*\* is missing
+- [#5725](https://github.com/mruby/mruby/issues/5725) weird const_missing exceptions in mrblib code
+- [#5789](https://github.com/mruby/mruby/issues/5789) No memory release of backtrace information due to stack error
+- [#5932](https://github.com/mruby/mruby/issues/5932) How to create a block using the C API? mrb_yield keeps crashing!
+- [#5943](https://github.com/mruby/mruby/issues/5943) TCPSocket#write is failed
+- [#5944](https://github.com/mruby/mruby/issues/5944) Behavior of calling method with a hash variable
+- [#5946](https://github.com/mruby/mruby/pull/5946) Don't switch constant search path from modules to Object
+- [#5949](https://github.com/mruby/mruby/issues/5949) Caller appears to report wrong line when block passed and brackets omitted
+- [0906cd7](https://github.com/mruby/mruby/commit/0906cd7) numeric.c: fix rounding function issues with big numbers
+- [#5974](https://github.com/mruby/mruby/issues/5974) Invalid escape sequences in gem_init.c on windows
+- [#5975](https://github.com/mruby/mruby/issues/5975) Equals comparison fails on extreme ends of 64-bit integers
+- [#5985](https://github.com/mruby/mruby/issues/5985) Sign extension with OP_LOADI32 in get_int_operand()
+- [#5986](https://github.com/mruby/mruby/issues/5986) Fix bugs in String#bytesplice
+- [#5987](https://github.com/mruby/mruby/issues/5987) ~(-1 << 64) is incorrect
+- [#5991](https://github.com/mruby/mruby/issues/5991) 'gets' method not working in mruby-3.2.0
+- [#5994](https://github.com/mruby/mruby/pull/5994) fix typo in mrbgems/mruby-io/src/io.c
+- [#5995](https://github.com/mruby/mruby/issues/5995) One seemingly unnecessary parameter is passed in the block parameters
+- [#6008](https://github.com/mruby/mruby/pull/6008) Make "bintest" independent of directory
+- [b47c8b7](https://github.com/mruby/mruby/commit/b47c8b7) gc.c (clear_all_old): fix a generational GC bug
+- [#6029](https://github.com/mruby/mruby/issues/6029) mruby build fails under mrbgems directory
+- [a264965](https://github.com/mruby/mruby/commit/a264965) mruby-os-memsize/memsize.c: fix irep size calculation
+- [3310e10](https://github.com/mruby/mruby/commit/3310e10) mruby-test/mrbgem.rake: fix mrb_state handling bug
+- [#6041](https://github.com/mruby/mruby/issues/6041) GC Performance may have degraded
+- [#6044](https://github.com/mruby/mruby/issues/6044) Generated presym/table.h contains invalid characters
+- [#6051](https://github.com/mruby/mruby/issues/6051) Null pointer dereference in mrb_addrinfo_unix_path
+- [#6052](https://github.com/mruby/mruby/issues/6052) Null pointer dereference while handling the Proc class
+- [#6055](https://github.com/mruby/mruby/pull/6055) Fix libmruby name for VisualC++
+- [#6060](https://github.com/mruby/mruby/issues/6060) SEGFAULT Issue Related to Fiber Usage in ngx_mruby Development
+- [#6061](https://github.com/mruby/mruby/issues/6061) Performance issue in String#codepoints
+- [#6064](https://github.com/mruby/mruby/issues/6064) MRUBY_PACKAGE_DIR does not always have a value.
+- [#6065](https://github.com/mruby/mruby/issues/6065) Null pointer dereference while handling the Proc class
+- [#6066](https://github.com/mruby/mruby/issues/6066) Null pointer dereference involving Struct.new()
+- [#6067](https://github.com/mruby/mruby/issues/6067) Null pointer dereference in mrb_string_value_cstr
+- [#6068](https://github.com/mruby/mruby/issues/6068) Stack overflow in mrb_vm_exec
+- [#6076](https://github.com/mruby/mruby/pull/6076) Fixed unwinding block that could point to invalid PC
+- [#6084](https://github.com/mruby/mruby/issues/6084) Incorrect symbolic sinks in binary built on Linux
+- [#6087](https://github.com/mruby/mruby/issues/6087) 'Remote branch HEAD not found in upstream origin' error on build
+- [#6089](https://github.com/mruby/mruby/issues/6089) binding.eval() handles def expressions differently from CRuby
+- [#6098](https://github.com/mruby/mruby/issues/6098) Fails to call superclass of wrapped method
+- [#6099](https://github.com/mruby/mruby/issues/6099) `ensure` section is not executed if the function exits via a return in a proc
+- [#6108](https://github.com/mruby/mruby/issues/6108) VM crashes with break
+- [#6118](https://github.com/mruby/mruby/pull/6118) Fixed IO#read with buf
+- [#6120](https://github.com/mruby/mruby/pull/6120) Set EBADF if check_file_descriptor() fails
+- [#6126](https://github.com/mruby/mruby/pull/6126) Fixed return value of `OP_RETURN_BLK` called directly under C function
+- [#6134](https://github.com/mruby/mruby/issues/6134) String#unpack1 returns an array instead of a single string
+- [#6136](https://github.com/mruby/mruby/pull/6136) Fixed when combined `mrb_fiber_resume()` and `Fiber#transfer`
+
+# Pull Requests (User Visible Ones)
+
+- [#5517](https://github.com/mruby/mruby/pull/5517) Fixed local variables not separated between copied binding objects
+- [#5902](https://github.com/mruby/mruby/pull/5902) Replace `MRB_NO_DIRECT_THREADING` with `MRB_USE_VM_SWITCH_DISPATCH`
+- [#5923](https://github.com/mruby/mruby/pull/5923) Demotion `mrb_f_raise()` from `MRB_API`
+- [#5928](https://github.com/mruby/mruby/pull/5928) Improved `rake install`
+- [#5945](https://github.com/mruby/mruby/pull/5945) Avoid exposure for `REnv` objects
+- [#5946](https://github.com/mruby/mruby/pull/5946) Don't switch constant search path from modules to Object
+- [#5966](https://github.com/mruby/mruby/pull/5966) Update default.gembox add mruby debugger mrdb
+- [#5979](https://github.com/mruby/mruby/pull/5979) Allow Class#allocate to be prohibited
+- [#5981](https://github.com/mruby/mruby/pull/5981) `Kernel#binding` responds only to calls from Ruby
+- [#5989](https://github.com/mruby/mruby/pull/5989) Integrate mruby-binding-eval into mruby-eval
+- [#5961](https://github.com/mruby/mruby/pull/5961) Add Docker to build and run all mruby tests. Run pre-commit and generate YARD docs with Docker
+- [#5994](https://github.com/mruby/mruby/pull/5994) fix typo in mrbgems/mruby-io/src/io.c
+- [#6008](https://github.com/mruby/mruby/pull/6008) Make "bintest" independent of directory
+- [#6009](https://github.com/mruby/mruby/pull/6009) Avoid adding <MRUBY_ROOT>/bintest which does not exist
+- [#6011](https://github.com/mruby/mruby/pull/6011) Encode and decode escape characters for presym
+- [#6012](https://github.com/mruby/mruby/pull/6012) Allow tests to be disabled for specific gems; warn about disabled tests
+- [#6013](https://github.com/mruby/mruby/pull/6013) Fix Android toolchain
+- [#6022](https://github.com/mruby/mruby/pull/6022) Build configuration for MS-DOS and DJGPP
+- [#6032](https://github.com/mruby/mruby/pull/6032) Rake: update task clean to remove bin and build folders
+- [#6045](https://github.com/mruby/mruby/pull/6045) Fixes escape sequence bug and enhancements in Presym scanning
+- [#6054](https://github.com/mruby/mruby/pull/6054) Extends `bin/mruby-config`
+- [#6055](https://github.com/mruby/mruby/pull/6055) Fix libmruby name for VisualC++
+- [#6070](https://github.com/mruby/mruby/pull/6070) Demotion mrb_f_raise() in kernel.c from MRB_API too
+- [#6076](https://github.com/mruby/mruby/pull/6076) Fixed unwinding block that could point to invalid PC
+- [#6081](https://github.com/mruby/mruby/pull/6081) Add "x" mode option for IO.open
+- [#6086](https://github.com/mruby/mruby/pull/6086) Add build config for Nintendo Wii
+- [#6097](https://github.com/mruby/mruby/pull/6097) Add a new mrb_fiber_new() with MRB_API
+- [#6103](https://github.com/mruby/mruby/pull/6103) RBreak remembers the CI location
+- [#6105](https://github.com/mruby/mruby/pull/6105) Implement `Fiber#to_s` method
+- [#6106](https://github.com/mruby/mruby/pull/6106) Ease fiber limitations
+- [#6118](https://github.com/mruby/mruby/pull/6118) Fixed IO#read with buf
+- [#6120](https://github.com/mruby/mruby/pull/6120) Set EBADF if check_file_descriptor() fails
+- [#6122](https://github.com/mruby/mruby/pull/6122) Prohibit `Class#allocate` in a different way
+- [#6123](https://github.com/mruby/mruby/pull/6123) Inherit `MRB_FL_UNDEF_ALLOCATE` in subclasses
+- [#6125](https://github.com/mruby/mruby/pull/6125) Allow `OP_RETURN_BLK` to cross C boundaries
+- [#6126](https://github.com/mruby/mruby/pull/6126) Fixed return value of `OP_RETURN_BLK` called directly under C function
+- [#6130](https://github.com/mruby/mruby/pull/6130) `dreamcast_shelf build config`: complete overhaul
+- [#6136](https://github.com/mruby/mruby/pull/6136) Fixed when combined `mrb_fiber_resume()` and `Fiber#transfer`

doc/opcode.md

@@ -1,126 +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
-* 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       | BsS          | R(a) = mrb_int(b)                                      |
-| OP_LOADSYM       | BB           | R(a) = Syms(b)                                         |
-| OP_LOADNIL       | B            | R(a) = nil                                             |
-| OP_LOADSELF      | B            | R(a) = self                                            |
-| OP_LOADT         | B            | R(a) = true                                            |
-| OP_LOADF         | B            | R(a) = false                                           |
-| OP_GETGV         | BB           | R(a) = getglobal(Syms(b))                              |
-| OP_SETGV         | BB           | setglobal(Syms(b), R(a))                               |
-| OP_GETSV         | BB           | R(a) = Special[Syms(b)]                                |
-| OP_SETSV         | BB           | Special[Syms(b)] = R(a)                                |
-| OP_GETIV         | BB           | R(a) = ivget(Syms(b))                                  |
-| OP_SETIV         | BB           | ivset(Syms(b),R(a))                                    |
-| OP_GETCV         | BB           | R(a) = cvget(Syms(b))                                  |
-| OP_SETCV         | BB           | cvset(Syms(b),R(a))                                    |
-| OP_GETCONST      | BB           | R(a) = constget(Syms(b))                               |
-| OP_SETCONST      | BB           | constset(Syms(b),R(a))                                 |
-| OP_GETMCNST      | BB           | R(a) = R(a)::Syms(b)                                   |
-| OP_SETMCNST      | BB           | R(a+1)::Syms(b) = R(a)                                 |
-| OP_GETUPVAR      | BBB          | R(a) = uvget(b,c)                                      |
-| OP_SETUPVAR      | BBB          | uvset(b,c,R(a))                                        |
-| OP_JMP           | S            | pc=a                                                   |
-| OP_JMPIF         | BS           | if R(a) pc=b                                           |
-| OP_JMPNOT        | BS           | if !R(a) pc=b                                          |
-| OP_JMPNIL        | BS           | if R(a)==nil pc=b                                      |
-| OP_JMPUW         | S            | unwind_and_jump_to(a)                                  |
-| OP_EXCEPT        | B            | R(a) = exc                                             |
-| OP_RESCUE        | BB           | R(b) = R(a).isa?(R(b))                                 |
-| OP_RAISEIF       | B            | raise(R(a)) if R(a)                                    |
-| OP_SENDV         | BB           | R(a) = call(R(a),Syms(b),*R(a+1))                      |
-| OP_SENDVB        | BB           | R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2))              |
-| OP_SEND          | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))            |
-| OP_SENDB         | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1))  |
-| OP_CALL          | -            | R(0) = self.call(frame.argc, frame.argv)               |
-| OP_SUPER         | BB           | R(a) = super(R(a+1),... ,R(a+b+1))                     |
-| OP_ARGARY        | BS           | R(a) = argument array (16=5:1:5:1:4)                   |
-| OP_ENTER         | W            | arg setup according to flags (23=5:5:1:5:5:1:1)        |
-| OP_KEY_P         | BB           | R(a) = kdict.key?(Syms(b))                             |
-| OP_KEYEND        | -            | raise unless kdict.empty?                              |
-| OP_KARG          | BB           | R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))           |
-| OP_RETURN        | B            | return R(a) (normal)                                   |
-| OP_RETURN_BLK    | B            | return R(a) (in-block return)                          |
-| OP_BREAK         | B            | break R(a)                                             |
-| OP_BLKPUSH       | BS           | R(a) = block (16=5:1:5:1:4)                            |
-| OP_ADD           | B            | R(a) = R(a)+R(a+1)                                     |
-| OP_ADDI          | BB           | R(a) = R(a)+mrb_int(b)                                 |
-| OP_SUB           | B            | R(a) = R(a)-R(a+1)                                     |
-| OP_SUBI          | BB           | R(a) = R(a)-mrb_int(b)                                 |
-| OP_MUL           | B            | R(a) = R(a)*R(a+1)                                     |
-| OP_DIV           | B            | R(a) = R(a)/R(a+1)                                     |
-| OP_EQ            | B            | R(a) = R(a)==R(a+1)                                    |
-| OP_LT            | B            | R(a) = R(a)<R(a+1)                                     |
-| OP_LE            | B            | R(a) = R(a)<=R(a+1)                                    |
-| OP_GT            | B            | R(a) = R(a)>R(a+1)                                     |
-| OP_GE            | B            | R(a) = R(a)>=R(a+1)                                    |
-| OP_ARRAY         | BB           | R(a) = ary_new(R(a),R(a+1)..R(a+b))                    |
-| OP_ARRAY2        | BBB          | R(a) = ary_new(R(b),R(b+1)..R(b+c))                    |
-| OP_ARYCAT        | B            | ary_cat(R(a),R(a+1))                                   |
-| OP_ARYPUSH       | B            | ary_push(R(a),R(a+1))                                  |
-| OP_ARYDUP        | B            | R(a) = ary_dup(R(a))                                   |
-| OP_AREF          | BBB          | R(a) = R(b)[c]                                         |
-| OP_ASET          | BBB          | R(a)[c] = R(b)                                         |
-| OP_APOST         | BBB          | *R(a),R(a+1)..R(a+c) = R(a)[b..]                       |
-| OP_INTERN        | B            | R(a) = intern(R(a))                                    |
-| OP_STRING        | BB           | R(a) = str_dup(Lit(b))                                 |
-| OP_STRCAT        | B            | str_cat(R(a),R(a+1))                                   |
-| OP_HASH          | BB           | R(a) = hash_new(R(a),R(a+1)..R(a+b))                   |
-| OP_HASHADD       | BB           | R(a) = hash_push(R(a),R(a+1)..R(a+b))                  |
-| OP_HASHCAT       | B            | R(a) = hash_cat(R(a),R(a+1))                           |
-| OP_LAMBDA        | BB           | R(a) = lambda(SEQ[b],OP_L_LAMBDA)                      |
-| OP_BLOCK         | BB           | R(a) = lambda(SEQ[b],OP_L_BLOCK)                       |
-| OP_METHOD        | BB           | R(a) = lambda(SEQ[b],OP_L_METHOD)                      |
-| OP_RANGE_INC     | B            | R(a) = range_new(R(a),R(a+1),FALSE)                    |
-| OP_RANGE_EXC     | B            | R(a) = range_new(R(a),R(a+1),TRUE)                     |
-| OP_OCLASS        | B            | R(a) = ::Object                                        |
-| OP_CLASS         | BB           | R(a) = newclass(R(a),Syms(b),R(a+1))                   |
-| OP_MODULE        | BB           | R(a) = newmodule(R(a),Syms(b))                         |
-| OP_EXEC          | BB           | R(a) = blockexec(R(a),SEQ[b])                          |
-| OP_DEF           | BB           | R(a).newmethod(Syms(b),R(a+1))                         |
-| OP_ALIAS         | BB           | alias_method(target_class,Syms(a),Syms(b))             |
-| OP_UNDEF         | B            | undef_method(target_class,Syms(a))                     |
-| OP_SCLASS        | B            | R(a) = R(a).singleton_class                            |
-| OP_TCLASS        | B            | R(a) = target_class                                    |
-| OP_DEBUG         | BBB          | print a,b,c                                            |
-| OP_ERR           | B            | raise(LocalJumpError, Lit(a))                          |
-| OP_STOP          | -            | stop VM                                                |
-|------------------|--------------|--------------------------------------------------------|

docker-compose.yml

@@ -0,0 +1,13 @@
+version: "3.8"
+services:
+  test:
+    build:
+      context: .
+    command: sh -c 'rake deep_clean && rake -m test:build && rake test:run'
+    environment:
+      - MRUBY_CONFIG=ci/gcc-clang
+      - CC=gcc
+      - CXX=g++
+      - LD=gcc
+      - SKIP=check-executables-have-shebangs
+    working_dir: /app

examples/mrbgems/c_and_ruby_extension_example/README.md

@@ -1,4 +1,3 @@
-C and Ruby Extension Example
-=========
+# C and Ruby Extension Example
 
 This is an example gem which implements a C and Ruby extension.

examples/mrbgems/c_and_ruby_extension_example/src/example.c

@@ -5,9 +5,8 @@
 static mrb_value
 mrb_c_method(mrb_state *mrb, mrb_value self)
 {
-  mrb_value self_str = mrb_str_to_str(mrb, self);
-
-  printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self_str));
+  mrb_ensure_string_type(mrb, self);
+  printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self));
 
   return self;
 }

examples/mrbgems/c_extension_example/README.md

@@ -1,4 +1,3 @@
-C Extension Example
-=========
+# C Extension Example
 
 This is an example gem which implements a C extension.

examples/mrbgems/c_extension_example/src/example.c

@@ -5,9 +5,8 @@
 static mrb_value
 mrb_c_method(mrb_state *mrb, mrb_value self)
 {
-  mrb_value self_str = mrb_str_to_str(mrb, self);
-
-  printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self_str));
+  mrb_ensure_string_type(mrb, self);
+  printf("%s: A C Extension\n", mrb_str_to_cstr(mrb, self));
 
   return self;
 }

examples/mrbgems/cdata_extension_example/README.md

@@ -0,0 +1,3 @@
+# C Data Extension Example
+
+This is an example gem which implements a C extension with Data.

examples/mrbgems/cdata_extension_example/mrbgem.rake

@@ -0,0 +1,23 @@
+MRuby::Gem::Specification.new('cdata_extension_example') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+
+  # Add compile flags
+  # spec.cc.flags << '-g'
+
+  # Add cflags to all
+  # spec.mruby.cc.flags << '-g'
+
+  # Add libraries
+  # spec.linker.libraries << 'external_lib'
+
+  # Default build files
+  # spec.rbfiles = Dir.glob("#{dir}/mrblib/*.rb")
+  # spec.objs = Dir.glob("#{dir}/src/*.{c,cpp,m,asm,S}").map { |f| objfile(f.relative_path_from(dir).pathmap("#{build_dir}/%X")) }
+  # spec.test_rbfiles = Dir.glob("#{dir}/test/*.rb")
+  # spec.test_objs = Dir.glob("#{dir}/test/*.{c,cpp,m,asm,S}").map { |f| objfile(f.relative_path_from(dir).pathmap("#{build_dir}/%X")) }
+  # spec.test_preload = 'test/assert.rb'
+
+  # Values accessible as TEST_ARGS inside test scripts
+  # spec.test_args = {'tmp_dir' => Dir::tmpdir}
+end

examples/mrbgems/cdata_extension_example/src/example.c

@@ -0,0 +1,77 @@
+#include <mruby.h>
+#include <mruby/string.h>
+#include <mruby/class.h>
+#include <mruby/data.h>
+#include <stdio.h>
+
+static void mrb_foo_free(mrb_state *mrb, void *ptr) {
+  /* custom destructor */
+  mrb_free(mrb, ptr);
+}
+struct mrb_data_type mrb_foo_type = { "Foo", mrb_foo_free };
+
+struct Foo {
+  int bar;
+  char baz[32];
+};
+
+static mrb_value
+mrb_foo_initialize(mrb_state *mrb, mrb_value self)
+{
+  struct Foo *f;
+
+  f = (struct Foo*)mrb_malloc(mrb, sizeof(struct Foo));
+  f->bar = 0;
+
+  DATA_PTR(self) = f;
+  DATA_TYPE(self) = &mrb_foo_type;
+
+  return self;
+}
+
+static mrb_value
+mrb_foo_get_bar(mrb_state *mrb, mrb_value self)
+{
+  struct Foo *f;
+
+  f = (struct Foo*)mrb_data_get_ptr(mrb, self, &mrb_foo_type);
+  if (f == NULL) {
+    mrb_raise(mrb, E_RUNTIME_ERROR, "uninitialized data");
+  }
+
+  return mrb_fixnum_value(f->bar);
+}
+
+static mrb_value
+mrb_foo_set_bar(mrb_state *mrb, mrb_value self)
+{
+  struct Foo *f;
+  int v;
+
+  f = (struct Foo*)mrb_data_get_ptr(mrb, self, &mrb_foo_type);
+  if (f == NULL) {
+    mrb_raise(mrb, E_RUNTIME_ERROR, "uninitialized data");
+  }
+
+  mrb_get_args(mrb, "i", &v);
+
+  f->bar = v;
+
+  return mrb_fixnum_value(f->bar);
+}
+
+void
+mrb_cdata_extension_example_gem_init(mrb_state* mrb) {
+  struct RClass *class_foo;
+
+  class_foo = mrb_define_class(mrb, "Foo", mrb->object_class);
+  MRB_SET_INSTANCE_TT(class_foo, MRB_TT_CDATA);
+  mrb_define_method(mrb, class_foo, "initialize", mrb_foo_initialize, MRB_ARGS_NONE());
+  mrb_define_method(mrb, class_foo, "bar", mrb_foo_get_bar, MRB_ARGS_NONE());
+  mrb_define_method(mrb, class_foo, "bar=", mrb_foo_set_bar, MRB_ARGS_REQ(1));
+}
+
+void
+mrb_cdata_extension_example_gem_final(mrb_state* mrb) {
+  /* gem finalizer */
+}

examples/mrbgems/cdata_extension_example/test/example.c

@@ -0,0 +1,7 @@
+#include <mruby.h>
+
+void
+mrb_cdata_extension_example_gem_test(mrb_state *mrb)
+{
+  /* test initializer in C */
+}

examples/mrbgems/mruby-YOUR-bigint/TODO-HINT.md

@@ -0,0 +1,39 @@
+# Hints for creating your own bigint GEM
+
+This example gem, mruby-YOUR-bigint, is available under the Creative Commons Zero License (CC0).
+
+This file is placed for the purpose of describing hints for creating a `mruby-bigint` compatible GEM to realize multiple integers.
+
+The file structure in this example is as follows:
+
+```
++- mruby-YOUR-bigint/   <-  Make this directory public if necessary.
+    |                       Change the name of copied directory.
+    |
+    +- TODO-HINT.md     <-  You are currently viewing this file.
+    |                       Remove this from copied directory.
+    |
+    +- core/
+    |   |
+    |   +- bigint.c     <-  Body of the implementation.
+    |
+    +- mrbgem.rake      <-  GEM name is "mruby-bigint".
+                            May be depended on by other GEMs.
+```
+
+Implementers of their own bigints should copy below this directory to another directory and do the following:
+
+- Rewrite `spec.author`, `spec.license`, `spec.homepage` and `spec.summary` in `<gem-dir>/mrbgem.rake` file to those of your own implementers.
+- Implement the respective functions in `<gem-dir>/core/bigint.c`.
+  - Define and use an object structure for `MRB_TT_BIGINT` type-tag.
+    It is recommended to use `mrb_static_assert_object_size()` to ensure that the size of the object structure is within six words.
+- Delete this file from the destination of the copy.
+
+If you wish to use it as an alternative to the `mruby-bigint` provided by mruby, please leave the GEM name in `<gem-dir>/mrbgem.rake` as it is.
+This is an important factor when it is depended from other GEMs with `spec.add_dependency 'mruby-bigint'`.
+
+The name of the top directory of the GEM can be changed arbitrarily.
+The name of the Git repository can also be changed arbitrarily.
+
+Note that there is no need for an initialization function as there is in a normal GEM.
+If you need it, create a file `<gem-dir>/src/bigint.c` for example, and implement the `mrb_mruby_bigint_gem_init()` function.

examples/mrbgems/mruby-YOUR-bigint/core/bigint.c

@@ -0,0 +1,70 @@
+/*
+ * If placed under the "mruby/examples/mrbgems/mruby-YOUR-bigint" directory,
+ * this file is available under the Creative Commons Zero License (CC0).
+ * Note that file is incomplete.
+ *
+ * TODO: If this file is copied and another implementation is written,
+ * remove this comment block from the copied file.
+ */
+
+#include <mruby.h>
+#include <mruby/numeric.h>
+
+/*
+ * The "mruby/internal.h" file should be placed after the other mruby header files.
+ */
+#include <mruby/internal.h>
+
+/*
+ * The "mruby/presym.h" file is placed at the end of the mruby header file.
+ */
+#include <mruby/presym.h>
+
+/*
+ * Define your own struct RBigint.
+ *
+ * - Object type must be MRB_TT_BIGINT.
+ * - If the structure is named RBigint, MRB_OBJ_ALLOC() can be used as is.
+ */
+struct RBigint {
+  /*
+   * Put MRB_OBJECT_HEADER before the first member of the structure.
+   */
+  MRB_OBJECT_HEADER;
+
+  /*
+   * Up to 3 words can be freely configured.
+   */
+  size_t len;
+  size_t capa;
+  uintptr_t *num;
+};
+
+/*
+ * Assert with mrb_static_assert_object_size() that the entire structure is within 6 words.
+ */
+mrb_static_assert_object_size(struct RBigint);
+
+/*
+ * The lower 16 bits of the object flags (`obj->flags`) can be used freely by the GEM author.
+ */
+#define MY_BIGINT_NEGATIVE_FLAG 1
+#define MY_BIGINT_NEGATIVE_P(obj) ((obj)->flags & MY_BIGINT_NEGATIVE_FLAG)
+
+/*
+ * Implement the functions declared in `#ifdef MRUBY_USE_BIGINT ... #endif` in the "mruby/internal.h" file.
+ */
+
+mrb_value
+mrb_bint_new_int(mrb_state *mrb, mrb_int x)
+{
+  struct RBigint *obj = MRB_OBJ_ALLOC(mrb, MRB_TT_BIGINT, mrb->integer_class);
+
+  ...
+
+  return mrb_obj_value(obj);
+}
+
+/*
+ * The implementation function continues...
+ */

examples/mrbgems/mruby-YOUR-bigint/mrbgem.rake

@@ -0,0 +1,12 @@
+MRuby::Gem::Specification.new('mruby-bigint') do |spec|
+  spec.author = 'YOUR-NAME-HERE'
+  spec.license = 'YOUR-LICENSE-HERE'
+  spec.summary = 'Yet another multi-precision Integer extension'
+  spec.homepage = 'https://gem.example/for/mruby-YOUR-bigint'
+  spec.build.defines << 'MRB_USE_BIGINT'
+  #spec.build.linker.libraries << 'gmp' # when uses libgmp
+
+  spec.build.libmruby_core_objs << Dir.glob(File.join(__dir__, 'core/**/*.c')).map { |fn|
+    objfile(fn.relative_path_from(__dir__).pathmap("#{spec.build_dir}/%X"))
+  }
+end

examples/mrbgems/ruby_extension_example/README.md

@@ -1,4 +1,3 @@
-Pure Ruby Extension Example
-=========
+# Pure Ruby Extension Example
 
 This is an example gem which implements a pure Ruby extension.