NEWS.md: update for recent changes

Add entries for language changes (case/in NoMatchingPatternError,
compound statement in tLPAREN_ARG), C API additions (mrb_bigint_p(),
RVALUE union), compiler optimizations (literal chunking), build
fixes (MSYS2), security fixes, and 26 merged pull requests.

Co-authored-by: Claude <noreply@anthropic.com>

.github/dependabot.yml

@@ -5,11 +5,27 @@ updates:
     directory: "/"
     schedule:
       interval: "daily"
+    groups:
+      bundler-dependencies:
+        patterns:
+          - "*"
     cooldown:
       default-days: 7
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
       interval: "daily"
+    groups:
+      github-actions-dependencies:
+        patterns:
+          - "*"
     cooldown:
       default-days: 7
+  - package-ecosystem: "pre-commit"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    groups:
+      pre-commit-hooks:
+        patterns:
+          - "*"

.github/linters/mlc_config.json

@@ -1,26 +0,0 @@
-{
-  "retryOn429": true,
-  "retryCount": 3,
-  "aliveStatusCodes": [
-    200,
-    206,
-    502
-  ],
-  "ignorePatterns": [
-    {
-      "pattern": "^https://github.com/mruby/mruby/commit/"
-    },
-    {
-      "pattern": "^http://jp.rubyist.net/magazine/\\?0034-Enumerable_lz"
-    },
-    {
-      "pattern": "^https://ruby-doc.org/core-2.3.3"
-    },
-    {
-      "pattern": "^mailto:"
-    },
-    {
-      "pattern": "^https://www.iso.org/"
-    }
-  ]
-}

.github/workflows/build.yml

@@ -32,6 +32,8 @@ jobs:
     steps:
       - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
         uses: actions/checkout@v6
+        with:
+          persist-credentials: false
       - name: Ruby version
         run: ruby -v
       - name: Compiler version
@@ -45,6 +47,8 @@ jobs:
     steps:
       - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
         uses: actions/checkout@v6
+        with:
+          persist-credentials: false
       - name: Ruby version
         run: ruby -v
       - name: Cache cosmocc
@@ -71,6 +75,8 @@ jobs:
     steps:
       - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
         uses: actions/checkout@v6
+        with:
+          persist-credentials: false
       - name: Ruby version
         run: ruby -v
       - name: Build and test

.github/workflows/codeql-analysis.yml

@@ -19,6 +19,8 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v6
+        with:
+          persist-credentials: false
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v4
         with:

.github/workflows/coverage.yml

@@ -2,6 +2,9 @@ name: Coverage
 
 on: [push]
 
+permissions:
+  contents: read
+
 jobs:
   coverage:
     name: Coverage
@@ -17,6 +20,8 @@ jobs:
     steps:
       - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
         uses: actions/checkout@v6
+        with:
+          persist-credentials: false
       - name: Ruby version
         run: ruby -v
       - name: Compiler version
@@ -34,7 +39,7 @@ jobs:
             echo \`\`\`
           } > "$GITHUB_STEP_SUMMARY"
       - name: Upload coverage report
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: coverage-${{ github.sha }}
           path: coverage/

.github/workflows/ls-lint.yml

@@ -12,6 +12,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
       - uses: ls-lint/action@v2.3.1
         with:
           config: .github/linters/.ls-lint.yml

.github/workflows/oss-fuzz.yml

@@ -20,7 +20,7 @@ jobs:
           fuzz-seconds: 600
           dry-run: false
       - name: Upload Crash
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         if: failure()
         with:
           name: artifacts

.github/workflows/pre-commit-manual.yml

@@ -0,0 +1,22 @@
+# https://github.com/j178/prek
+name: Manual hooks
+
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  pre-commit:
+    name: Run pre-commit
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: j178/prek-action@v2
+        with:
+          install-only: true
+      - name: Run manual pre-commit hooks
+        run: prek run --color=always --all-files --hook-stage manual

.github/workflows/pre-commit.yml

@@ -13,8 +13,8 @@ jobs:
     steps:
       - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
         uses: actions/checkout@v6
-      - uses: j178/prek-action@v1
+        with:
+          persist-credentials: false
+      - uses: j178/prek-action@v2
         with:
           extra-args: --all-files
-      - name: Run manual pre-commit hooks
-        run: prek run --color=always --all-files --hook-stage manual

.github/workflows/release.yml

@@ -20,6 +20,8 @@ jobs:
     steps:
       - name: "Checkout ${{ github.ref_name }} ( ${{ github.sha }} )"
         uses: actions/checkout@v6
+        with:
+          persist-credentials: false
       - name: Builds
         id: builds
         run: |

.github/workflows/super-linter.yml

@@ -19,6 +19,7 @@ jobs:
         with:
           # Full git history is needed to get a proper list of changed files within `super-linter`
           fetch-depth: 0
+          persist-credentials: false
       - name: Lint Code Base
         uses: super-linter/super-linter/slim@v8.5.0
         env:

.pre-commit-config.yaml

@@ -3,7 +3,7 @@
 default_stages: [pre-commit, pre-push]
 default_language_version:
   python: python3
-  node: 24.11.1
+  node: 24.14.0
 minimum_pre_commit_version: "3.2.0"
 exclude: "^tools/lrama/"
 repos:
@@ -20,10 +20,11 @@ repos:
       - id: prettier
         name: run prettier
         description: format files with prettier
-        entry: prettier --write '**/*.json' '**/*.md' '**/*.yaml' '**/*.yml'
-        files: \.(json|md|ya?ml)$
+        entry: prettier --write '**/*.md' '**/*.yaml' '**/*.yml'
+        files: \.(md|ya?ml)$
         language: node
         additional_dependencies: ["prettier@3.7.4"]
+        pass_filenames: false
         stages: [manual]
       - id: check-zip-file-is-not-committed
         name: disallow zip files
@@ -34,13 +35,13 @@ repos:
           track and have security implications. Please remove the zip file from the repository.
         files: \.zip$
   - repo: https://github.com/gitleaks/gitleaks
-    rev: v8.30.0
+    rev: v8.30.1
     hooks:
       - id: gitleaks
         name: run gitleaks
         description: detect hardcoded secrets with gitleaks
   - repo: https://github.com/oxipng/oxipng
-    rev: v10.0.0
+    rev: v10.1.0
     hooks:
       - id: oxipng
         name: run oxipng
@@ -55,9 +56,6 @@ repos:
       - id: check-executables-have-shebangs
         exclude: ^test/t/lang\.rb$
       - id: check-illegal-windows-names
-      - id: pretty-format-json
-        args: [--autofix, --no-sort-keys]
-      - id: check-json
       - id: check-merge-conflict
       - id: check-shebang-scripts-are-executable
       - id: check-vcs-permalinks
@@ -75,7 +73,7 @@ repos:
       - id: mixed-line-ending
       - id: trailing-whitespace
   - repo: https://github.com/Lucas-C/pre-commit-hooks
-    rev: v1.5.5
+    rev: v1.5.6
     hooks:
       - id: forbid-tabs
         name: run no-tabs checker
@@ -87,19 +85,19 @@ repos:
         args: [--whitespaces-count, "2"]
         exclude: Makefile$
   - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.9
+    rev: v1.7.11
     hooks:
       - id: actionlint
         name: run actionlint
         description: lint GitHub Actions workflow files
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.1
+    rev: v2.4.2
     hooks:
       - id: codespell
         name: run codespell
         description: check spelling with codespell
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.46.0
+    rev: v0.48.0
     hooks:
       - id: markdownlint
         name: run markdownlint
@@ -107,18 +105,8 @@ repos:
         args: [--config=.github/linters/.markdown-lint.yml]
         types: [markdown]
         files: \.md$
-  - repo: https://github.com/tcort/markdown-link-check
-    rev: v3.14.2
-    hooks:
-      - id: markdown-link-check
-        name: run markdown-link-check
-        description: checks hyperlinks in Markdown files
-        args: [--config=.github/linters/mlc_config.json, -q]
-        stages: [manual]
-        types: [markdown]
-        files: \.md$
   - repo: https://github.com/rubocop/rubocop
-    rev: v1.81.7
+    rev: v1.86.0
     hooks:
       - id: rubocop
         name: run rubocop
@@ -132,7 +120,7 @@ repos:
         name: run shellcheck
         description: check shell scripts with a static analysis tool
   - repo: https://github.com/adrienverge/yamllint
-    rev: v1.37.1
+    rev: v1.38.0
     hooks:
       - id: yamllint
         name: run yamllint

.prettierignore

@@ -3,3 +3,4 @@ build
 coverage
 doc/internal/opcode.md
 tools/lrama
+.venv

NEWS.md

@@ -23,6 +23,8 @@ mruby now supports pattern matching (case/in) syntax:
 - Trailing comma in method definition parameters: `def foo(a, b,)` ([f78334b](https://github.com/mruby/mruby/commit/f78334b))
 - Array/Hash/String subclasses can now override `[]` and `[]=` methods ([#6675](https://github.com/mruby/mruby/pull/6675))
 - `OP_SETIDX` optimization for Array and Hash ([ddd8fe1](https://github.com/mruby/mruby/commit/ddd8fe1))
+- `case`/`in` without `else` now raises `NoMatchingPatternError` ([d8de35b](https://github.com/mruby/mruby/commit/d8de35b))
+- Allow compound statement in parenthesized argument context ([919cbd8](https://github.com/mruby/mruby/commit/919cbd8))
 
 # Changes in C API
 
@@ -37,6 +39,8 @@ mruby now supports pattern matching (case/in) syntax:
 - `mrb_open()` returns mrb_state with exc set on init failure ([05ffe0c](https://github.com/mruby/mruby/commit/05ffe0c))
 - `mrb_utf8_to_buf()` for UTF-8 encoding consolidation ([7e28e68](https://github.com/mruby/mruby/commit/7e28e68))
 - `kh_is_end()` macro for safe khash iteration ([893cc75](https://github.com/mruby/mruby/commit/893cc75))
+- `mrb_bigint_p()` always defined regardless of bigint gem presence ([6c4a8c0](https://github.com/mruby/mruby/commit/6c4a8c0))
+- `RInteger` and `RFloat` added to `RVALUE` union ([13dbca0](https://github.com/mruby/mruby/commit/13dbca0))
 
 # ROM Method Tables
 
@@ -76,6 +80,7 @@ mruby-symbol-ext, mruby-range-ext, mruby-object-ext.
 - Emscripten: use native WASM exception handling ([ca364e3](https://github.com/mruby/mruby/commit/ca364e3))
 - HAL (Hardware Abstraction Layer) for platform abstraction in mruby-io, mruby-socket, mruby-dir, mruby-task ([74ca22f](https://github.com/mruby/mruby/commit/74ca22f))
 - `MRUBY_MIRB_READLINE` environment variable to control readline library selection ([0aafb83](https://github.com/mruby/mruby/commit/0aafb83))
+- MSYS2 drive letter support in build script ([77f6ffe](https://github.com/mruby/mruby/commit/77f6ffe))
 - Inter-gem headers separated from external API headers ([#6671](https://github.com/mruby/mruby/pull/6671))
 
 # Changes in mrbgems
@@ -110,6 +115,7 @@ mruby-symbol-ext, mruby-range-ext, mruby-object-ext.
 ## Other Gem Changes
 
 - **_NOTE_**: `Hash#deconstruct_keys` removed for CRuby compatibility ([34b9412](https://github.com/mruby/mruby/commit/34b9412))
+- **mruby-enum-lazy**: Fix `Lazy#flat_map` to handle non-enumerable block return values ([#6765](https://github.com/mruby/mruby/pull/6765))
 - **mruby-array-ext**: Add `Array#find` and `Array#rfind` methods
 - **mruby-io**: Add `IO#putc` and `Kernel#putc` ([baff6e6](https://github.com/mruby/mruby/commit/baff6e6))
 - **mruby-random**: Replace xoshiro with PCG for better memory efficiency ([f1bab01](https://github.com/mruby/mruby/commit/f1bab01))
@@ -125,6 +131,8 @@ mruby-symbol-ext, mruby-range-ext, mruby-object-ext.
 - Optimized masgn to generate literals directly into target registers ([fb5d966](https://github.com/mruby/mruby/commit/fb5d966))
 - Optimized splat of literal arrays in args/literals ([1cb8d73](https://github.com/mruby/mruby/commit/1cb8d73))
 - Early termination after too many parse errors ([510ebd7](https://github.com/mruby/mruby/commit/510ebd7))
+- Chunk array literals at 64 elements to reduce register pressure ([f98d641](https://github.com/mruby/mruby/commit/f98d641))
+- Chunk `%w()` and `%i()` literals to reduce register pressure ([62cf0dc](https://github.com/mruby/mruby/commit/62cf0dc))
 
 # VM Optimizations
 
@@ -185,6 +193,10 @@ Other optimizations:
 - [#6705](https://github.com/mruby/mruby/issues/6705) Can't get outer class of an object in C
 - [#6713](https://github.com/mruby/mruby/issues/6713) mruby-polarssl not work
 - [#6720](https://github.com/mruby/mruby/issues/6720) Random float range: different behavior from CRuby
+- [#6722](https://github.com/mruby/mruby/issues/6722) RBreak size overflow on 32-bit platforms with MRB_NO_BOXING
+- [#6740](https://github.com/mruby/mruby/issues/6740) `%w()`/`%i()` register pressure with large literals
+- [#6741](https://github.com/mruby/mruby/issues/6741) `case`/`in` without `else` should raise `NoMatchingPatternError`
+- [#6760](https://github.com/mruby/mruby/issues/6760) `mrb_gc_unregister()` not removing all matching entries
 
 # Merged Pull Requests
 
@@ -260,6 +272,7 @@ Other optimizations:
 - [#6589](https://github.com/mruby/mruby/pull/6589) Add pre-commit hook `check-zip-file-is-not-committed`
 - [#6591](https://github.com/mruby/mruby/pull/6591) mruby-eval fix license link in README
 - [#6593](https://github.com/mruby/mruby/pull/6593) README: Add Contributors Avatars, Star History, Table of Contents
+- [#6598](https://github.com/mruby/mruby/pull/6598) Fix heap buffer overflow in `#method_missing`
 - [#6599](https://github.com/mruby/mruby/pull/6599) pre-commit: run `markdown-link-check`, `oxipng`, `prettier` manually
 - [#6600](https://github.com/mruby/mruby/pull/6600) `dreamcast_shelf build config`: update to use KallistiOS wrappers
 - [#6601](https://github.com/mruby/mruby/pull/6601) fix: skip local build_config.rb when working in MRUBY_ROOT
@@ -303,6 +316,30 @@ Other optimizations:
 - [#6716](https://github.com/mruby/mruby/pull/6716) Fixes identity for proc object
 - [#6717](https://github.com/mruby/mruby/pull/6717) Fix mruby-task: wrapping by critical section and setting initial task receiver
 - [#6718](https://github.com/mruby/mruby/pull/6718) Add installation instructions for conda and Homebrew
+- [#6723](https://github.com/mruby/mruby/pull/6723) Add `RInteger` and `RFloat` to `RVALUE`
+- [#6727](https://github.com/mruby/mruby/pull/6727) Language documentation: update wording of "overloading" section
+- [#6729](https://github.com/mruby/mruby/pull/6729) Simplifying dependency addition for gensym task
+- [#6730](https://github.com/mruby/mruby/pull/6730) Simplifying presym file generation actions
+- [#6733](https://github.com/mruby/mruby/pull/6733) Include `mruby/presym.h` for all source files
+- [#6734](https://github.com/mruby/mruby/pull/6734) Chunk array literals at 64 elements to reduce register pressure
+- [#6735](https://github.com/mruby/mruby/pull/6735) Prevent full recompilation without changes to presym file
+- [#6739](https://github.com/mruby/mruby/pull/6739) Fix MSYS2 build error with drive letters
+- [#6743](https://github.com/mruby/mruby/pull/6743) Chunk `%w()` and `%i()` literals to reduce register pressure
+- [#6744](https://github.com/mruby/mruby/pull/6744) Raise `NoMatchingPatternError` in `case`/`in` without `else`
+- [#6747](https://github.com/mruby/mruby/pull/6747) Correctly handle empty hash as default named argument
+- [#6749](https://github.com/mruby/mruby/pull/6749) Fix microcontroller profile
+- [#6750](https://github.com/mruby/mruby/pull/6750) Fix out-of-bounds read and divide-by-zero in `Array#product`
+- [#6752](https://github.com/mruby/mruby/pull/6752) Fix `attr_reader`-generated methods accepting extra arguments
+- [#6753](https://github.com/mruby/mruby/pull/6753) Further optimize `Array#product`
+- [#6754](https://github.com/mruby/mruby/pull/6754) Mark `attr_reader` procs as noarg
+- [#6755](https://github.com/mruby/mruby/pull/6755) Reload `ci` after `mrb_hash_delete_key()` in keyword argument handling
+- [#6756](https://github.com/mruby/mruby/pull/6756) Avoid impact of object modifications caused by `mrb_vm_exec()` calls
+- [#6758](https://github.com/mruby/mruby/pull/6758) Don't assign result of `mrb_funcall()` directly to `regs`
+- [#6759](https://github.com/mruby/mruby/pull/6759) Define `mrb_bigint_p()` always
+- [#6761](https://github.com/mruby/mruby/pull/6761) Fix `mrb_gc_unregister()` to remove all matching entries
+- [#6762](https://github.com/mruby/mruby/pull/6762) Write generated test C files atomically to avoid build race condition
+- [#6765](https://github.com/mruby/mruby/pull/6765) Fix `Lazy#flat_map` to handle non-enumerable block return values
+- [#6767](https://github.com/mruby/mruby/pull/6767) Allow compound statement in parenthesized argument context
 
 # Security Fixes
 
@@ -320,4 +357,6 @@ Other optimizations:
 - Heap-use-after-free in insertion_sort ([099d2c47](https://github.com/mruby/mruby/commit/099d2c47))
 - Integer overflow in str_check_length ([6afff1c3](https://github.com/mruby/mruby/commit/6afff1c3))
 - Integer overflow in Integer#lcm ([070bef24](https://github.com/mruby/mruby/commit/070bef24))
+- Heap buffer overflow in `#method_missing` ([550d10a](https://github.com/mruby/mruby/commit/550d10a))
+- Out-of-bounds read and divide-by-zero in `Array#product` ([8441eaf](https://github.com/mruby/mruby/commit/8441eaf))
 - Multiple memory leak fixes in bigint, Set, Array, and Task gems

build_config/ArduinoDue.rb

@@ -30,7 +30,7 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|
 
     #configuration for low memory environment
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
+    cc.defines << %w(KHASH_INITIAL_SIZE=8)
     cc.defines << %w(MRB_GC_STRESS)
     #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

build_config/RX630.rb

@@ -16,7 +16,7 @@ MRuby::CrossBuild.new("RX630") do |conf|
     #configuration for low memory environment
     cc.defines << %w(MRB_USE_FLOAT32)
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
+    cc.defines << %w(KHASH_INITIAL_SIZE=8)
     cc.defines << %w(MRB_GC_STRESS)
     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

build_config/chipKITMax32.rb

@@ -27,7 +27,7 @@ MRuby::CrossBuild.new("chipKITMax32") do |conf|
 
     #configuration for low memory environment
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
+    cc.defines << %w(KHASH_INITIAL_SIZE=8)
     cc.defines << %w(MRB_GC_STRESS)
     #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

doc/README.md

@@ -4,44 +4,44 @@
 
 New to mruby? Start here:
 
-| Document | Description |
-| -------- | ----------- |
+| Document                                     | Description                            |
+| -------------------------------------------- | -------------------------------------- |
 | [Getting Started](guides/getting-started.md) | Build mruby and run your first program |
-| [Language Features](guides/language.md) | Ruby subset supported by mruby |
-| [Limitations](limitations.md) | Behavioral differences from CRuby |
+| [Language Features](guides/language.md)      | Ruby subset supported by mruby         |
+| [Limitations](limitations.md)                | Behavioral differences from CRuby      |
 
 ## Guides (for embedders and gem authors)
 
 ### Embedding mruby in C
 
-| Document | Description |
-| -------- | ----------- |
-| [C API Reference](guides/capi.md) | Values, classes, methods, error handling, fibers |
-| [GC Arena](guides/gc-arena-howto.md) | Managing temporary objects in C extensions |
-| [Linking](guides/link.md) | Linking with `libmruby` |
-| [Amalgamation](guides/amalgamation.md) | Single-file build for easy integration |
-| [Precompiled Symbols](guides/symbol.md) | Compile-time symbol allocation |
+| Document                                | Description                                      |
+| --------------------------------------- | ------------------------------------------------ |
+| [C API Reference](guides/capi.md)       | Values, classes, methods, error handling, fibers |
+| [GC Arena](guides/gc-arena-howto.md)    | Managing temporary objects in C extensions       |
+| [Linking](guides/link.md)               | Linking with `libmruby`                          |
+| [Amalgamation](guides/amalgamation.md)  | Single-file build for easy integration           |
+| [Precompiled Symbols](guides/symbol.md) | Compile-time symbol allocation                   |
 
 ### Building and Configuring
 
-| Document | Description |
-| -------- | ----------- |
-| [Compilation](guides/compile.md) | Build system, cross-compilation, toolchains |
-| [Build Configuration](guides/mrbconf.md) | Compile-time macros (`MRB_*` flags) |
-| [mrbgems](guides/mrbgems.md) | Creating and managing gems |
-| [Memory](guides/memory.md) | Allocator customization and heap regions |
+| Document                                 | Description                                 |
+| ---------------------------------------- | ------------------------------------------- |
+| [Compilation](guides/compile.md)         | Build system, cross-compilation, toolchains |
+| [Build Configuration](guides/mrbconf.md) | Compile-time macros (`MRB_*` flags)         |
+| [mrbgems](guides/mrbgems.md)             | Creating and managing gems                  |
+| [Memory](guides/memory.md)               | Allocator customization and heap regions    |
 
 ### Tools
 
-| Document | Description |
-| -------- | ----------- |
-| [Debugger](guides/debugger.md) | Using `mrdb` for debugging |
+| Document                                        | Description                                     |
+| ----------------------------------------------- | ----------------------------------------------- |
+| [Debugger](guides/debugger.md)                  | Using `mrdb` for debugging                      |
 | [ROM Method Tables](guides/rom-method-table.md) | Read-only method tables for constrained devices |
 
 ### Reference
 
-| Document | Description |
-| -------- | ----------- |
+| Document                              | Description        |
+| ------------------------------------- | ------------------ |
 | [Directory Structure](guides/hier.md) | Source tree layout |
 
 ## Internals (for mruby contributors)
@@ -49,14 +49,14 @@ New to mruby? Start here:
 Start with [Architecture](internal/architecture.md) for an overview,
 then dive into the subsystem you need:
 
-| Document | Description |
-| -------- | ----------- |
-| [Architecture](internal/architecture.md) | Overview of object model, VM, GC, compiler |
-| [Virtual Machine](internal/vm.md) | Dispatch loop, call frames, method lookup, fibers |
-| [Garbage Collector](internal/gc.md) | Tri-color marking, write barriers, generational GC |
-| [Compiler Pipeline](internal/compiler.md) | Parser, code generator, IRep, binary format |
-| [Opcodes](internal/opcode.md) | VM instruction set reference |
-| [Value Boxing](internal/boxing.md) | How `mrb_value` encodes types |
+| Document                                  | Description                                        |
+| ----------------------------------------- | -------------------------------------------------- |
+| [Architecture](internal/architecture.md)  | Overview of object model, VM, GC, compiler         |
+| [Virtual Machine](internal/vm.md)         | Dispatch loop, call frames, method lookup, fibers  |
+| [Garbage Collector](internal/gc.md)       | Tri-color marking, write barriers, generational GC |
+| [Compiler Pipeline](internal/compiler.md) | Parser, code generator, IRep, binary format        |
+| [Opcodes](internal/opcode.md)             | VM instruction set reference                       |
+| [Value Boxing](internal/boxing.md)        | How `mrb_value` encodes types                      |
 
 ## Release Notes
 

doc/guides/capi.md

@@ -99,23 +99,23 @@ mrb_str_to_cstr(mrb, v)     /* const char* from String value */
 
 ### Value Types
 
-| `mrb_vtype` | Ruby Class | Notes |
-| ----------- | ---------- | ----- |
-| `MRB_TT_FALSE` | FalseClass/NilClass | `nil` has `MRB_TT_FALSE` |
-| `MRB_TT_TRUE` | TrueClass | |
-| `MRB_TT_INTEGER` | Integer | Immediate value |
-| `MRB_TT_FLOAT` | Float | May be immediate |
-| `MRB_TT_SYMBOL` | Symbol | Immediate value |
-| `MRB_TT_STRING` | String | Heap object |
-| `MRB_TT_ARRAY` | Array | Heap object |
-| `MRB_TT_HASH` | Hash | Heap object |
-| `MRB_TT_OBJECT` | Object | User-defined classes |
-| `MRB_TT_CLASS` | Class | |
-| `MRB_TT_MODULE` | Module | |
-| `MRB_TT_PROC` | Proc | |
-| `MRB_TT_CDATA` | (C data) | Wrapped C structs |
-| `MRB_TT_EXCEPTION` | Exception | |
-| `MRB_TT_FIBER` | Fiber | |
+| `mrb_vtype`        | Ruby Class          | Notes                    |
+| ------------------ | ------------------- | ------------------------ |
+| `MRB_TT_FALSE`     | FalseClass/NilClass | `nil` has `MRB_TT_FALSE` |
+| `MRB_TT_TRUE`      | TrueClass           |                          |
+| `MRB_TT_INTEGER`   | Integer             | Immediate value          |
+| `MRB_TT_FLOAT`     | Float               | May be immediate         |
+| `MRB_TT_SYMBOL`    | Symbol              | Immediate value          |
+| `MRB_TT_STRING`    | String              | Heap object              |
+| `MRB_TT_ARRAY`     | Array               | Heap object              |
+| `MRB_TT_HASH`      | Hash                | Heap object              |
+| `MRB_TT_OBJECT`    | Object              | User-defined classes     |
+| `MRB_TT_CLASS`     | Class               |                          |
+| `MRB_TT_MODULE`    | Module              |                          |
+| `MRB_TT_PROC`      | Proc                |                          |
+| `MRB_TT_CDATA`     | (C data)            | Wrapped C structs        |
+| `MRB_TT_EXCEPTION` | Exception           |                          |
+| `MRB_TT_FIBER`     | Fiber               |                          |
 
 ## Defining Classes and Modules
 
@@ -165,15 +165,15 @@ mrb_define_module_function(mrb, mod, "name", my_method, MRB_ARGS_ANY());
 
 ### Argument Specifiers
 
-| Macro | Meaning |
-| ----- | ------- |
-| `MRB_ARGS_NONE()` | No arguments |
-| `MRB_ARGS_REQ(n)` | `n` required arguments |
-| `MRB_ARGS_OPT(n)` | `n` optional arguments |
-| `MRB_ARGS_ARG(r,o)` | `r` required + `o` optional |
-| `MRB_ARGS_REST()` | Splat (`*args`) |
-| `MRB_ARGS_BLOCK()` | Block (`&block`) |
-| `MRB_ARGS_ANY()` | Any number (same as REST) |
+| Macro                  | Meaning                               |
+| ---------------------- | ------------------------------------- |
+| `MRB_ARGS_NONE()`      | No arguments                          |
+| `MRB_ARGS_REQ(n)`      | `n` required arguments                |
+| `MRB_ARGS_OPT(n)`      | `n` optional arguments                |
+| `MRB_ARGS_ARG(r,o)`    | `r` required + `o` optional           |
+| `MRB_ARGS_REST()`      | Splat (`*args`)                       |
+| `MRB_ARGS_BLOCK()`     | Block (`&block`)                      |
+| `MRB_ARGS_ANY()`       | Any number (same as REST)             |
 | `MRB_ARGS_KEY(n,rest)` | `n` keyword args, `rest`=1 for `**kw` |
 
 These can be combined with `|`:
@@ -192,27 +192,27 @@ mrb_int mrb_get_args(mrb_state *mrb, const char *format, ...);
 
 ### Format Specifiers
 
-| Spec | Ruby Type | C Type(s) | Notes |
-| ---- | --------- | --------- | ----- |
-| `o` | any | `mrb_value` | No type check |
-| `i` | Numeric | `mrb_int` | Coerces to integer |
-| `f` | Numeric | `mrb_float` | Coerces to float |
-| `b` | any | `mrb_bool` | Truthiness |
-| `n` | String/Symbol | `mrb_sym` | Converts to symbol |
-| `s` | String | `const char*, mrb_int` | Pointer + length |
-| `z` | String | `const char*` | Null-terminated |
-| `S` | String | `mrb_value` | String value |
-| `A` | Array | `mrb_value` | Array value |
-| `H` | Hash | `mrb_value` | Hash value |
-| `C` | Class | `mrb_value` | Class/Module value |
-| `c` | Class | `struct RClass*` | Class pointer |
-| `a` | Array | `const mrb_value*, mrb_int` | Array pointer + length |
-| `d` | C Data | `void*` | Requires `mrb_data_type*` |
-| `&` | Block | `mrb_value` | Block argument |
-| `*` | rest | `const mrb_value*, mrb_int` | Rest arguments |
-| `\|` | — | — | Following args are optional |
-| `?` | — | `mrb_bool` | Was previous optional arg given? |
-| `:` | keywords | `mrb_kwargs` | Keyword arguments |
+| Spec | Ruby Type     | C Type(s)                   | Notes                            |
+| ---- | ------------- | --------------------------- | -------------------------------- |
+| `o`  | any           | `mrb_value`                 | No type check                    |
+| `i`  | Numeric       | `mrb_int`                   | Coerces to integer               |
+| `f`  | Numeric       | `mrb_float`                 | Coerces to float                 |
+| `b`  | any           | `mrb_bool`                  | Truthiness                       |
+| `n`  | String/Symbol | `mrb_sym`                   | Converts to symbol               |
+| `s`  | String        | `const char*, mrb_int`      | Pointer + length                 |
+| `z`  | String        | `const char*`               | Null-terminated                  |
+| `S`  | String        | `mrb_value`                 | String value                     |
+| `A`  | Array         | `mrb_value`                 | Array value                      |
+| `H`  | Hash          | `mrb_value`                 | Hash value                       |
+| `C`  | Class         | `mrb_value`                 | Class/Module value               |
+| `c`  | Class         | `struct RClass*`            | Class pointer                    |
+| `a`  | Array         | `const mrb_value*, mrb_int` | Array pointer + length           |
+| `d`  | C Data        | `void*`                     | Requires `mrb_data_type*`        |
+| `&`  | Block         | `mrb_value`                 | Block argument                   |
+| `*`  | rest          | `const mrb_value*, mrb_int` | Rest arguments                   |
+| `\|` | —             | —                           | Following args are optional      |
+| `?`  | —             | `mrb_bool`                  | Was previous optional arg given? |
+| `:`  | keywords      | `mrb_kwargs`                | Keyword arguments                |
 
 Adding `!` to `S`, `A`, `H`, `C`, `c`, `s`, `z`, `a`, `d` allows `nil`
 (returns NULL/zero for nil).
@@ -608,14 +608,14 @@ my_yield_method(mrb_state *mrb, mrb_value self)
 
 ### Fiber States
 
-| State | Meaning |
-| ----- | ------- |
-| `MRB_FIBER_CREATED` | Created but not yet resumed |
-| `MRB_FIBER_RUNNING` | Currently executing |
-| `MRB_FIBER_RESUMED` | Resumed another fiber |
-| `MRB_FIBER_SUSPENDED` | Yielded, waiting to resume |
+| State                   | Meaning                          |
+| ----------------------- | -------------------------------- |
+| `MRB_FIBER_CREATED`     | Created but not yet resumed      |
+| `MRB_FIBER_RUNNING`     | Currently executing              |
+| `MRB_FIBER_RESUMED`     | Resumed another fiber            |
+| `MRB_FIBER_SUSPENDED`   | Yielded, waiting to resume       |
 | `MRB_FIBER_TRANSFERRED` | Transferred via `Fiber#transfer` |
-| `MRB_FIBER_TERMINATED` | Finished execution |
+| `MRB_FIBER_TERMINATED`  | Finished execution               |
 
 **Limitation:** fibers cannot yield across C function boundaries.
 You cannot call `mrb_fiber_yield` from within a C-implemented
@@ -644,13 +644,13 @@ mrb_ccontext_free(mrb, cxt);
 
 The `mrb_ccontext` structure provides several flags:
 
-| Field | Purpose |
-| ----- | ------- |
+| Field            | Purpose                                 |
+| ---------------- | --------------------------------------- |
 | `capture_errors` | Collect parse errors instead of raising |
-| `no_exec` | Compile without executing (get RProc) |
-| `no_optimize` | Disable peephole optimizations |
-| `no_ext_ops` | Disable extended operand instructions |
-| `keep_lv` | Preserve local variables across loads |
+| `no_exec`        | Compile without executing (get RProc)   |
+| `no_optimize`    | Disable peephole optimizations          |
+| `no_ext_ops`     | Disable extended operand instructions   |
+| `keep_lv`        | Preserve local variables across loads   |
 
 ### Loading with Context
 
@@ -843,14 +843,14 @@ $ build/host/bin/mruby-config --libs      # libraries
 
 Key macros that affect ABI:
 
-| Macro | Effect |
-| ----- | ------ |
-| `MRB_NO_BOXING` | Struct-based values (larger, debuggable) |
-| `MRB_WORD_BOXING` | Single-word values (fast, 32-bit safe) |
-| `MRB_NAN_BOXING` | NaN-tagged values (default on 32-bit) |
-| `MRB_NO_FLOAT` | Disable Float support |
-| `MRB_INT64` | 64-bit integers |
-| `MRB_USE_FLOAT32` | 32-bit floats |
+| Macro             | Effect                                   |
+| ----------------- | ---------------------------------------- |
+| `MRB_NO_BOXING`   | Struct-based values (larger, debuggable) |
+| `MRB_WORD_BOXING` | Single-word values (fast, 32-bit safe)   |
+| `MRB_NAN_BOXING`  | NaN-tagged values (default on 32-bit)    |
+| `MRB_NO_FLOAT`    | Disable Float support                    |
+| `MRB_INT64`       | 64-bit integers                          |
+| `MRB_USE_FLOAT32` | 32-bit floats                            |
 
 Mismatching these between library and application causes silent
 data corruption.

doc/guides/language.md

@@ -205,11 +205,11 @@ mruby's numeric type sizes depend on the boxing mode and platform.
 
 ### Integer
 
-| Configuration | Range |
-| ------------- | ----- |
+| Configuration                          | Range            |
+| -------------------------------------- | ---------------- |
 | 64-bit word boxing (default on 64-bit) | roughly +/- 2^62 |
 | 32-bit word boxing (default on 32-bit) | roughly +/- 2^30 |
-| NaN boxing (64-bit only) | -2^31 to 2^31-1 |
+| NaN boxing (64-bit only)               | -2^31 to 2^31-1  |
 
 Integer overflow raises a `RangeError` unless the `mruby-bigint` gem
 is included, in which case integers automatically promote to
@@ -235,32 +235,32 @@ With word boxing on 64-bit, many float values are stored inline
 
 These classes are always available in mruby (no gem required):
 
-| Class | Notes |
-| ----- | ----- |
-| Object | Base class for all objects |
-| Module | Module definition and mixin |
-| Class | Class definition and instantiation |
-| NilClass | Singleton `nil` |
-| TrueClass | Singleton `true` |
-| FalseClass | Singleton `false` |
-| Integer | Fixed-precision integer |
-| Float | Floating-point (unless `MRB_NO_FLOAT`) |
-| Symbol | Interned identifier |
-| String | Mutable byte string |
-| Array | Ordered collection |
-| Hash | Key-value mapping |
-| Range | Interval representation |
-| Proc | Closure / callable object |
-| Exception | Exception hierarchy root |
-| StandardError | Common error base |
+| Class         | Notes                                  |
+| ------------- | -------------------------------------- |
+| Object        | Base class for all objects             |
+| Module        | Module definition and mixin            |
+| Class         | Class definition and instantiation     |
+| NilClass      | Singleton `nil`                        |
+| TrueClass     | Singleton `true`                       |
+| FalseClass    | Singleton `false`                      |
+| Integer       | Fixed-precision integer                |
+| Float         | Floating-point (unless `MRB_NO_FLOAT`) |
+| Symbol        | Interned identifier                    |
+| String        | Mutable byte string                    |
+| Array         | Ordered collection                     |
+| Hash          | Key-value mapping                      |
+| Range         | Interval representation                |
+| Proc          | Closure / callable object              |
+| Exception     | Exception hierarchy root               |
+| StandardError | Common error base                      |
 
 ### Core Modules
 
-| Module | Notes |
-| ------ | ----- |
-| Kernel | Core methods (`puts`, `p`, `raise`, etc.) |
-| Comparable | Comparison operators via `<=>` |
-| Enumerable | Collection iteration methods |
+| Module     | Notes                                     |
+| ---------- | ----------------------------------------- |
+| Kernel     | Core methods (`puts`, `p`, `raise`, etc.) |
+| Comparable | Comparison operators via `<=>`            |
+| Enumerable | Collection iteration methods              |
 
 ## Standard Library (via gemboxes)
 
@@ -270,70 +270,70 @@ gembox provides the class or feature you need:
 
 ### Classes and Modules
 
-| Class/Module | Gembox | Gem |
-| ------------ | ------ | --- |
-| Fiber | stdlib | mruby-fiber |
-| Enumerator | stdlib | mruby-enumerator |
-| Enumerator::Lazy | stdlib | mruby-enum-lazy |
-| Set | stdlib | mruby-set |
-| ObjectSpace | stdlib | mruby-objectspace |
-| Time | stdlib-ext | mruby-time |
-| Struct | stdlib-ext | mruby-struct |
-| Data | stdlib-ext | mruby-data |
-| Random | stdlib-ext | mruby-random |
-| IO, File | stdlib-io | mruby-io |
-| Socket | stdlib-io | mruby-socket |
-| Dir | stdlib-io | mruby-dir |
-| Errno | stdlib-io | mruby-errno |
-| Math | math | mruby-math |
-| Rational | math | mruby-rational |
-| Complex | math | mruby-complex |
-| Bigint | math | mruby-bigint |
-| Method, UnboundMethod | metaprog | mruby-method |
+| Class/Module          | Gembox     | Gem               |
+| --------------------- | ---------- | ----------------- |
+| Fiber                 | stdlib     | mruby-fiber       |
+| Enumerator            | stdlib     | mruby-enumerator  |
+| Enumerator::Lazy      | stdlib     | mruby-enum-lazy   |
+| Set                   | stdlib     | mruby-set         |
+| ObjectSpace           | stdlib     | mruby-objectspace |
+| Time                  | stdlib-ext | mruby-time        |
+| Struct                | stdlib-ext | mruby-struct      |
+| Data                  | stdlib-ext | mruby-data        |
+| Random                | stdlib-ext | mruby-random      |
+| IO, File              | stdlib-io  | mruby-io          |
+| Socket                | stdlib-io  | mruby-socket      |
+| Dir                   | stdlib-io  | mruby-dir         |
+| Errno                 | stdlib-io  | mruby-errno       |
+| Math                  | math       | mruby-math        |
+| Rational              | math       | mruby-rational    |
+| Complex               | math       | mruby-complex     |
+| Bigint                | math       | mruby-bigint      |
+| Method, UnboundMethod | metaprog   | mruby-method      |
 
 ### Methods and Features
 
-| Feature | Gembox | Gem |
-| ------- | ------ | --- |
-| `catch`/`throw` | stdlib | mruby-catch |
-| `Kernel#sprintf`, `String#%` | stdlib-ext | mruby-sprintf |
-| `Array#pack`, `String#unpack` | stdlib-ext | mruby-pack |
-| `Kernel#rand` | stdlib-ext | mruby-random |
-| `Kernel#eval` | metaprog | mruby-eval |
-| `Kernel#binding` | metaprog | mruby-binding |
-| `Proc#binding` | metaprog | mruby-proc-binding |
-| Runtime compiler | metaprog | mruby-compiler |
+| Feature                       | Gembox     | Gem                |
+| ----------------------------- | ---------- | ------------------ |
+| `catch`/`throw`               | stdlib     | mruby-catch        |
+| `Kernel#sprintf`, `String#%`  | stdlib-ext | mruby-sprintf      |
+| `Array#pack`, `String#unpack` | stdlib-ext | mruby-pack         |
+| `Kernel#rand`                 | stdlib-ext | mruby-random       |
+| `Kernel#eval`                 | metaprog   | mruby-eval         |
+| `Kernel#binding`              | metaprog   | mruby-binding      |
+| `Proc#binding`                | metaprog   | mruby-proc-binding |
+| Runtime compiler              | metaprog   | mruby-compiler     |
 
 ### Core Class Extensions
 
 The `stdlib` gembox also extends built-in classes with additional
 methods. These are included by default:
 
-| Extension | Examples |
-| --------- | -------- |
-| Array extensions | `#dig`, `#union`, `#difference` |
-| Hash extensions | `#dig`, `#transform_keys`, `#transform_values` |
-| String extensions | `#encode`, `#bytes`, `#chars` |
-| Numeric extensions | `Integer#digits`, `Integer#pow` |
-| Comparable extensions | `#clamp` |
-| Enumerable extensions | `#sort_by`, `#min_by`, `#max_by`, `#tally` |
-| Range extensions | `#size`, `#cover?` |
-| Proc extensions | `#<<`, `#>>` (composition) |
-| Symbol extensions | `#to_proc` |
-| Object extensions | `#then`, `#yield_self` |
-| Kernel extensions | `#__method__` |
-| Class/Module extensions | `Module#name` |
+| Extension               | Examples                                       |
+| ----------------------- | ---------------------------------------------- |
+| Array extensions        | `#dig`, `#union`, `#difference`                |
+| Hash extensions         | `#dig`, `#transform_keys`, `#transform_values` |
+| String extensions       | `#encode`, `#bytes`, `#chars`                  |
+| Numeric extensions      | `Integer#digits`, `Integer#pow`                |
+| Comparable extensions   | `#clamp`                                       |
+| Enumerable extensions   | `#sort_by`, `#min_by`, `#max_by`, `#tally`     |
+| Range extensions        | `#size`, `#cover?`                             |
+| Proc extensions         | `#<<`, `#>>` (composition)                     |
+| Symbol extensions       | `#to_proc`                                     |
+| Object extensions       | `#then`, `#yield_self`                         |
+| Kernel extensions       | `#__method__`                                  |
+| Class/Module extensions | `Module#name`                                  |
 
 ### Gembox Summary
 
-| Gembox | Contents | Notes |
-| ------ | -------- | ----- |
-| `stdlib` | Core class extensions, Fiber, Enumerator, Set | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
-| `stdlib-ext` | Time, Struct, Data, Random, sprintf, pack | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
-| `stdlib-io` | IO, File, Dir, Socket, Errno | Requires stdio |
-| `math` | Math, Rational, Complex, Bigint | Works with `MRB_NO_STDIO` |
-| `metaprog` | eval, binding, Method, compiler | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
-| `default` | All of the above + CLI tools | Full installation |
+| Gembox       | Contents                                      | Notes                                        |
+| ------------ | --------------------------------------------- | -------------------------------------------- |
+| `stdlib`     | Core class extensions, Fiber, Enumerator, Set | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
+| `stdlib-ext` | Time, Struct, Data, Random, sprintf, pack     | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
+| `stdlib-io`  | IO, File, Dir, Socket, Errno                  | Requires stdio                               |
+| `math`       | Math, Rational, Complex, Bigint               | Works with `MRB_NO_STDIO`                    |
+| `metaprog`   | eval, binding, Method, compiler               | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
+| `default`    | All of the above + CLI tools                  | Full installation                            |
 
 ## Key Differences from CRuby
 
@@ -378,8 +378,8 @@ This means subclassing `Array` or `String` and adding `@fields` will raise an er
 
 ### Operator Overriding
 
-Operators of primitive classes cannot be overridden by user code. 
-Redefining `String#+` has no effect on the behavior of the `+` __operator__.
+Operators of primitive classes cannot be overridden by user code.
+Redefining `String#+` has no effect on the behavior of the `+` operator.
 
 ### Module Loading Hooks
 
@@ -416,15 +416,15 @@ differently on 32-bit or NaN boxing configurations.
 
 Key compile-time macros that affect language behavior:
 
-| Macro | Effect |
-| ----- | ------ |
-| `MRB_NO_FLOAT` | Remove all float support |
-| `MRB_USE_FLOAT32` | Use 32-bit float instead of double |
-| `MRB_UTF8_STRING` | Enable UTF-8 string handling |
-| `MRB_INT32` | Force 32-bit integer |
-| `MRB_INT64` | Force 64-bit integer |
-| `MRB_STR_LENGTH_MAX` | Max string length (default 1MB) |
-| `MRB_ARY_LENGTH_MAX` | Max array length (default 2^17) |
+| Macro                | Effect                             |
+| -------------------- | ---------------------------------- |
+| `MRB_NO_FLOAT`       | Remove all float support           |
+| `MRB_USE_FLOAT32`    | Use 32-bit float instead of double |
+| `MRB_UTF8_STRING`    | Enable UTF-8 string handling       |
+| `MRB_INT32`          | Force 32-bit integer               |
+| `MRB_INT64`          | Force 64-bit integer               |
+| `MRB_STR_LENGTH_MAX` | Max string length (default 1MB)    |
+| `MRB_ARY_LENGTH_MAX` | Max array length (default 2^17)    |
 
 See [mrbconf.md](mrbconf.md) for the complete list of configuration
 macros.

doc/guides/memory.md

@@ -202,10 +202,10 @@ any other heap page. The only differences are:
 The page size is controlled by `MRB_HEAP_PAGE_SIZE` (default: 1024 slots).
 Each page occupies:
 
-| Platform | Slot size | Page size (approx)  |
-|----------|-----------|---------------------|
-| 64-bit   | 40 bytes  | ~41 KB              |
-| 32-bit   | 24 bytes  | ~25 KB              |
+| Platform | Slot size | Page size (approx) |
+| -------- | --------- | ------------------ |
+| 64-bit   | 40 bytes  | ~41 KB             |
+| 32-bit   | 24 bytes  | ~25 KB             |
 
 To estimate pages for a given buffer: `pages = buffer_size / sizeof(mrb_heap_page)`.
 Each page provides `MRB_HEAP_PAGE_SIZE` object slots.

doc/guides/mrbconf.md

@@ -233,10 +233,10 @@ end
 - 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`
+`KHASH_INITIAL_SIZE`
 
 - Default value is `32`.
-- Specifies default size of khash table bucket.
+- Specifies initial size of khash table bucket.
 - Used in `kh_init_ ## name` function.
 
 `MRB_NO_METHOD_CACHE`
@@ -272,7 +272,7 @@ deployment targets. Define one of the following:
 `MRB_CONSTRAINED_BASELINE_PROFILE`
 
 - For micro controllers.
-- Enables `MRB_NO_METHOD_CACHE`, reduces `KHASH_DEFAULT_SIZE` to `16`,
+- Enables `MRB_NO_METHOD_CACHE`, reduces `KHASH_INITIAL_SIZE` to `16`,
   and `MRB_HEAP_PAGE_SIZE` to `256`.
 
 `MRB_BASELINE_PROFILE`

doc/guides/rom-method-table.md

@@ -79,7 +79,6 @@ Include `<mruby/class.h>` (which provides `mrb_mt_entry`,
 
 ```c
 #include <mruby/class.h>
-#include <mruby/presym.h>
 
 static const mrb_mt_entry my_rom_entries[] = {
   MRB_MT_ENTRY(my_method_a,  MRB_SYM(method_a), MRB_ARGS_REQ(1)),

doc/internal/architecture.md

@@ -31,17 +31,17 @@ struct RBasic (8 bytes on 64-bit)
 
 All object structs embed this header via `MRB_OBJECT_HEADER`:
 
-| Struct | Ruby Type | Extra Fields |
-| ------ | --------- | ------------ |
-| `RObject` | Object instances | `iv` (instance variables) |
-| `RClass` | Class/Module | `iv`, `mt` (method table), `super` |
-| `RString` | String | embedded or heap buffer, length |
-| `RArray` | Array | embedded or heap buffer, length |
-| `RHash` | Hash | hash table or k-v array |
-| `RProc` | Proc/Lambda | `irep` or C function, environment |
-| `RData` | C data wrapper | `void *data`, `mrb_data_type` |
-| `RFiber` | Fiber | `mrb_context` |
-| `RException` | Exception | `iv` |
+| Struct       | Ruby Type        | Extra Fields                       |
+| ------------ | ---------------- | ---------------------------------- |
+| `RObject`    | Object instances | `iv` (instance variables)          |
+| `RClass`     | Class/Module     | `iv`, `mt` (method table), `super` |
+| `RString`    | String           | embedded or heap buffer, length    |
+| `RArray`     | Array            | embedded or heap buffer, length    |
+| `RHash`      | Hash             | hash table or k-v array            |
+| `RProc`      | Proc/Lambda      | `irep` or C function, environment  |
+| `RData`      | C data wrapper   | `void *data`, `mrb_data_type`      |
+| `RFiber`     | Fiber            | `mrb_context`                      |
+| `RException` | Exception        | `iv`                               |
 
 Immediate values (Integer, Symbol, `true`, `false`, `nil`) are encoded
 directly in `mrb_value` without heap allocation. The encoding depends on
@@ -111,52 +111,52 @@ See [compiler.md](compiler.md) for detailed compiler internals,
 
 ### Core (`src/`)
 
-| File | Responsibility |
-| ---- | -------------- |
-| `vm.c` | Bytecode dispatch loop, method invocation |
-| `state.c` | `mrb_state` init/close, irep management |
-| `gc.c` | Garbage collector (mark-sweep, incremental) |
-| `class.c` | Class/module definition, method tables |
-| `object.c` | Core object operations |
-| `variable.c` | Instance/class/global variables, object shapes |
-| `proc.c` | Proc/Lambda/closure handling |
-| `array.c` | Array implementation |
-| `string.c` | String implementation (embedded, shared, heap) |
-| `hash.c` | Hash implementation (open addressing) |
-| `numeric.c` | Integer/Float arithmetic |
-| `symbol.c` | Symbol table and interning |
-| `range.c` | Range implementation |
-| `error.c` | Exception creation, raise, backtrace |
-| `kernel.c` | Kernel module methods |
-| `load.c` | `.mrb` bytecode loading |
-| `dump.c` | Bytecode serialization (write `.mrb`) |
-| `print.c` | Print/puts/p output |
-| `backtrace.c` | Stack trace generation |
+| File          | Responsibility                                 |
+| ------------- | ---------------------------------------------- |
+| `vm.c`        | Bytecode dispatch loop, method invocation      |
+| `state.c`     | `mrb_state` init/close, irep management        |
+| `gc.c`        | Garbage collector (mark-sweep, incremental)    |
+| `class.c`     | Class/module definition, method tables         |
+| `object.c`    | Core object operations                         |
+| `variable.c`  | Instance/class/global variables, object shapes |
+| `proc.c`      | Proc/Lambda/closure handling                   |
+| `array.c`     | Array implementation                           |
+| `string.c`    | String implementation (embedded, shared, heap) |
+| `hash.c`      | Hash implementation (open addressing)          |
+| `numeric.c`   | Integer/Float arithmetic                       |
+| `symbol.c`    | Symbol table and interning                     |
+| `range.c`     | Range implementation                           |
+| `error.c`     | Exception creation, raise, backtrace           |
+| `kernel.c`    | Kernel module methods                          |
+| `load.c`      | `.mrb` bytecode loading                        |
+| `dump.c`      | Bytecode serialization (write `.mrb`)          |
+| `print.c`     | Print/puts/p output                            |
+| `backtrace.c` | Stack trace generation                         |
 
 ### Compiler (`mrbgems/mruby-compiler/core/`)
 
-| File | Responsibility |
-| ---- | -------------- |
-| `parse.y` | Yacc grammar → AST |
-| `y.tab.c` | Generated parser (from parse.y) |
-| `codegen.c` | AST → bytecode (irep) |
-| `node.h` | AST node type definitions |
+| File        | Responsibility                  |
+| ----------- | ------------------------------- |
+| `parse.y`   | Yacc grammar → AST              |
+| `y.tab.c`   | Generated parser (from parse.y) |
+| `codegen.c` | AST → bytecode (irep)           |
+| `node.h`    | AST node type definitions       |
 
 ### Key Headers (`include/mruby/`)
 
-| Header | Contents |
-| ------ | -------- |
-| `mruby.h` | `mrb_state`, core API declarations |
-| `value.h` | `mrb_value`, type enums, value macros |
-| `object.h` | `RBasic`, `RObject`, object header |
-| `class.h` | `RClass`, method table types |
-| `string.h` | `RString`, string macros |
-| `array.h` | `RArray`, array macros |
-| `hash.h` | `RHash`, hash API |
-| `data.h` | `RData`, C data wrapping |
-| `irep.h` | `mrb_irep`, bytecode structures |
-| `compile.h` | Compiler context, `mrb_load_string` |
-| `boxing_*.h` | Value boxing implementations |
+| Header       | Contents                              |
+| ------------ | ------------------------------------- |
+| `mruby.h`    | `mrb_state`, core API declarations    |
+| `value.h`    | `mrb_value`, type enums, value macros |
+| `object.h`   | `RBasic`, `RObject`, object header    |
+| `class.h`    | `RClass`, method table types          |
+| `string.h`   | `RString`, string macros              |
+| `array.h`    | `RArray`, array macros                |
+| `hash.h`     | `RHash`, hash API                     |
+| `data.h`     | `RData`, C data wrapping              |
+| `irep.h`     | `mrb_irep`, bytecode structures       |
+| `compile.h`  | Compiler context, `mrb_load_string`   |
+| `boxing_*.h` | Value boxing implementations          |
 
 ## mrbgems System
 

doc/internal/boxing.md

@@ -77,16 +77,16 @@ No boxing represents `mrb_value` by the C struct with `type` and the value union
 
 ## Comparison
 
-| Property               | Word Boxing        | NaN Boxing         | No Boxing            |
-| ---------------------- | ------------------ | ------------------ | -------------------- |
-| `mrb_value` size       | 1 word (4/8 byte)  | 8 bytes            | 2 words (8/16 bytes) |
-| Default on             | most platforms     | (manual opt-in)    | `host-debug`         |
-| Macro                  | `MRB_WORD_BOXING`  | `MRB_NAN_BOXING`   | `MRB_NO_BOXING`      |
-| Inline integers        | yes (31/63 bit)    | yes (32 bit)       | yes (full width)     |
-| Inline floats (64-bit) | yes (rotation)     | yes (native)       | yes (struct field)   |
-| Inline floats (32-bit) | no (heap RFloat)   | yes (native)       | yes (struct field)   |
-| Pointer size limit     | none               | 48 bits            | none                 |
-| Debugger friendly      | no                 | no                 | yes                  |
+| Property               | Word Boxing       | NaN Boxing       | No Boxing            |
+| ---------------------- | ----------------- | ---------------- | -------------------- |
+| `mrb_value` size       | 1 word (4/8 byte) | 8 bytes          | 2 words (8/16 bytes) |
+| Default on             | most platforms    | (manual opt-in)  | `host-debug`         |
+| Macro                  | `MRB_WORD_BOXING` | `MRB_NAN_BOXING` | `MRB_NO_BOXING`      |
+| Inline integers        | yes (31/63 bit)   | yes (32 bit)     | yes (full width)     |
+| Inline floats (64-bit) | yes (rotation)    | yes (native)     | yes (struct field)   |
+| Inline floats (32-bit) | no (heap RFloat)  | yes (native)     | yes (struct field)   |
+| Pointer size limit     | none              | 48 bits          | none                 |
+| Debugger friendly      | no                | no               | yes                  |
 
 ## ABI Compatibility
 

doc/internal/compiler.md

@@ -40,18 +40,18 @@ file: `mrbgems/mruby-compiler/core/parse.y`.
 
 The parser maintains extensive state in `mrb_parser_state`:
 
-- **lstate**: current lexer state (EXPR\_BEG, EXPR\_END, EXPR\_ARG,
-  EXPR\_DOT, EXPR\_FNAME, etc.). Controls how tokens like `+`/`-`
+- **lstate**: current lexer state (EXPR_BEG, EXPR_END, EXPR_ARG,
+  EXPR_DOT, EXPR_FNAME, etc.). Controls how tokens like `+`/`-`
   are interpreted (sign vs operator) and whether newlines are
   significant.
 - **locals**: stack of local variable lists (one per scope), stored
   as cons-lists of symbols.
-- **lex\_strterm**: string/heredoc parsing state for handling nested
+- **lex_strterm**: string/heredoc parsing state for handling nested
   interpolation.
-- **cond\_stack**, **cmdarg\_stack**: bit stacks tracking
+- **cond_stack**, **cmdarg_stack**: bit stacks tracking
   conditional and command argument contexts.
 - **tree**: root AST node after successful parse.
-- **error\_buffer**: accumulated parse errors.
+- **error_buffer**: accumulated parse errors.
 
 ### AST Nodes
 
@@ -123,10 +123,10 @@ reuse temporaries within an expression.
 Instructions are emitted via helper functions:
 
 - `genop_0(opcode)`: no operands
-- `genop_1(opcode, a)`: one operand (auto-extends with OP\_EXT1
+- `genop_1(opcode, a)`: one operand (auto-extends with OP_EXT1
   if a > 255)
 - `genop_2(opcode, a, b)`: two operands (auto-extends with
-  OP\_EXT1/2/3 as needed)
+  OP_EXT1/2/3 as needed)
 - `genop_3(opcode, a, b, c)`: three operands
 - `genop_W(opcode, a)`: 24-bit operand
 - `genop_2S(opcode, a, b)`: one 8-bit + one 16-bit operand
@@ -176,14 +176,14 @@ mrb_irep
 
 Pool entries store constants referenced by instructions:
 
-| Type | Tag | Description |
-| ---- | --- | ----------- |
-| `IREP_TT_STR` | 0 | Dynamic string (heap allocated) |
-| `IREP_TT_SSTR` | 2 | Static string (read-only) |
-| `IREP_TT_INT32` | 1 | 32-bit integer |
-| `IREP_TT_INT64` | 3 | 64-bit integer |
-| `IREP_TT_FLOAT` | 5 | Floating-point number |
-| `IREP_TT_BIGINT` | 7 | Arbitrary-precision integer |
+| Type             | Tag | Description                     |
+| ---------------- | --- | ------------------------------- |
+| `IREP_TT_STR`    | 0   | Dynamic string (heap allocated) |
+| `IREP_TT_SSTR`   | 2   | Static string (read-only)       |
+| `IREP_TT_INT32`  | 1   | 32-bit integer                  |
+| `IREP_TT_INT64`  | 3   | 64-bit integer                  |
+| `IREP_TT_FLOAT`  | 5   | Floating-point number           |
+| `IREP_TT_BIGINT` | 7   | Arbitrary-precision integer     |
 
 The code generator deduplicates pool entries: identical strings
 and equal numeric values share the same pool index.
@@ -209,28 +209,28 @@ During exception unwinding, handlers are searched in reverse order
 Standard instructions use 8-bit operands. When a value exceeds
 255, extension prefixes widen operands to 16 bits:
 
-| Prefix | Effect |
-| ------ | ------ |
-| `OP_EXT1` | First operand (a) becomes 16-bit |
+| Prefix    | Effect                            |
+| --------- | --------------------------------- |
+| `OP_EXT1` | First operand (a) becomes 16-bit  |
 | `OP_EXT2` | Second operand (b) becomes 16-bit |
-| `OP_EXT3` | Both a and b become 16-bit |
+| `OP_EXT3` | Both a and b become 16-bit        |
 
 Instruction formats:
 
-| Format | Layout | Size |
-| ------ | ------ | ---- |
-| Z | opcode only | 1 byte |
-| B | opcode + a(8) | 2 bytes |
-| BB | opcode + a(8) + b(8) | 3 bytes |
-| BBB | opcode + a(8) + b(8) + c(8) | 4 bytes |
-| BS | opcode + a(8) + b(16) | 4 bytes |
-| BSS | opcode + a(8) + b(16) + c(16) | 6 bytes |
-| S | opcode + a(16) | 3 bytes |
-| W | opcode + a(24) | 4 bytes |
+| Format | Layout                        | Size    |
+| ------ | ----------------------------- | ------- |
+| Z      | opcode only                   | 1 byte  |
+| B      | opcode + a(8)                 | 2 bytes |
+| BB     | opcode + a(8) + b(8)          | 3 bytes |
+| BBB    | opcode + a(8) + b(8) + c(8)   | 4 bytes |
+| BS     | opcode + a(8) + b(16)         | 4 bytes |
+| BSS    | opcode + a(8) + b(16) + c(16) | 6 bytes |
+| S      | opcode + a(16)                | 3 bytes |
+| W      | opcode + a(24)                | 4 bytes |
 
 See [opcode.md](opcode.md) for the full instruction table.
 
-## OP\_ENTER: Argument Specification
+## OP_ENTER: Argument Specification
 
 `OP_ENTER` encodes a method's argument layout in a 24-bit value
 (W format). The bit fields are defined by the `MRB_ARGS_*` macros:
@@ -258,16 +258,16 @@ string interning for common symbols.
 Generated by `lib/mruby/presym.rb`, the presym table maps symbol
 names to compile-time constants:
 
-| Macro | Example | Symbol |
-| ----- | ------- | ------ |
-| `MRB_SYM(name)` | `MRB_SYM(initialize)` | `:initialize` |
-| `MRB_SYM_B(name)` | `MRB_SYM_B(map)` | `:map!` |
-| `MRB_SYM_Q(name)` | `MRB_SYM_Q(nil)` | `:nil?` |
-| `MRB_SYM_E(name)` | `MRB_SYM_E(name)` | `:name=` |
-| `MRB_OPSYM(op)` | `MRB_OPSYM(add)` | `:+` |
-| `MRB_IVSYM(name)` | `MRB_IVSYM(name)` | `:@name` |
-| `MRB_CVSYM(name)` | `MRB_CVSYM(count)` | `:@@count` |
-| `MRB_GVSYM(name)` | `MRB_GVSYM(stdout)` | `:$stdout` |
+| Macro             | Example               | Symbol        |
+| ----------------- | --------------------- | ------------- |
+| `MRB_SYM(name)`   | `MRB_SYM(initialize)` | `:initialize` |
+| `MRB_SYM_B(name)` | `MRB_SYM_B(map)`      | `:map!`       |
+| `MRB_SYM_Q(name)` | `MRB_SYM_Q(nil)`      | `:nil?`       |
+| `MRB_SYM_E(name)` | `MRB_SYM_E(name)`     | `:name=`      |
+| `MRB_OPSYM(op)`   | `MRB_OPSYM(add)`      | `:+`          |
+| `MRB_IVSYM(name)` | `MRB_IVSYM(name)`     | `:@name`      |
+| `MRB_CVSYM(name)` | `MRB_CVSYM(count)`    | `:@@count`    |
+| `MRB_GVSYM(name)` | `MRB_GVSYM(stdout)`   | `:$stdout`    |
 
 ## Binary Format (.mrb)
 
@@ -299,25 +299,25 @@ mrbc -Boutput source.rb           # C array format
 
 ## Compilation Limits
 
-| Limit | Value |
-| ----- | ----- |
-| Max nesting depth | 256 (`MRB_CODEGEN_LEVEL_MAX`) |
-| Max local variables | 255 (uint16 `nlocals`) |
-| Max symbols per irep | 65535 |
-| Max operand (standard) | 255 (8-bit) |
-| Max operand (extended) | 65535 (16-bit) |
+| Limit                  | Value                         |
+| ---------------------- | ----------------------------- |
+| Max nesting depth      | 256 (`MRB_CODEGEN_LEVEL_MAX`) |
+| Max local variables    | 255 (uint16 `nlocals`)        |
+| Max symbols per irep   | 65535                         |
+| Max operand (standard) | 255 (8-bit)                   |
+| Max operand (extended) | 65535 (16-bit)                |
 
 ## Source Files
 
-| File | Contents |
-| ---- | -------- |
-| `mrbgems/mruby-compiler/core/parse.y` | Lrama/Bison grammar |
-| `mrbgems/mruby-compiler/core/y.tab.c` | Generated parser |
-| `mrbgems/mruby-compiler/core/codegen.c` | Code generator |
-| `mrbgems/mruby-compiler/core/node.h` | AST node types |
-| `include/mruby/irep.h` | IRep structure definition |
-| `include/mruby/compile.h` | Compiler context API |
-| `include/mruby/ops.h` | Opcode definitions |
-| `src/load.c` | Binary format loader |
-| `src/dump.c` | Binary format writer |
-| `lib/mruby/presym.rb` | Presym table generator |
+| File                                    | Contents                  |
+| --------------------------------------- | ------------------------- |
+| `mrbgems/mruby-compiler/core/parse.y`   | Lrama/Bison grammar       |
+| `mrbgems/mruby-compiler/core/y.tab.c`   | Generated parser          |
+| `mrbgems/mruby-compiler/core/codegen.c` | Code generator            |
+| `mrbgems/mruby-compiler/core/node.h`    | AST node types            |
+| `include/mruby/irep.h`                  | IRep structure definition |
+| `include/mruby/compile.h`               | Compiler context API      |
+| `include/mruby/ops.h`                   | Opcode definitions        |
+| `src/load.c`                            | Binary format loader      |
+| `src/dump.c`                            | Binary format writer      |
+| `lib/mruby/presym.rb`                   | Presym table generator    |

doc/internal/gc.md

@@ -26,12 +26,12 @@ pauses.
 Every heap-allocated object has a color stored in
 `RBasic::gc_color` (3 bits):
 
-| Color | Value | Meaning |
-| ----- | ----- | ------- |
-| White (A or B) | 1 or 2 | Unmarked, candidate for collection |
-| Gray | 0 | Marked, but children not yet scanned |
-| Black | 4 | Fully marked and scanned |
-| Red | 7 | Static/ROM object, never collected |
+| Color          | Value  | Meaning                              |
+| -------------- | ------ | ------------------------------------ |
+| White (A or B) | 1 or 2 | Unmarked, candidate for collection   |
+| Gray           | 0      | Marked, but children not yet scanned |
+| Black          | 4      | Fully marked and scanned             |
+| Red            | 7      | Static/ROM object, never collected   |
 
 The GC uses two white types (A and B) in a flip-flop scheme. At the
 start of each GC cycle, the meaning of "current white" is flipped by
@@ -107,7 +107,7 @@ The GC operates as a three-state machine:
 GC_STATE_ROOT --> GC_STATE_MARK --> GC_STATE_SWEEP --> GC_STATE_ROOT
 ```
 
-### Root Scan (GC\_STATE\_ROOT)
+### Root Scan (GC_STATE_ROOT)
 
 Marks objects directly reachable from the VM:
 
@@ -121,7 +121,7 @@ Marks objects directly reachable from the VM:
 
 After root scanning, the white color is flipped.
 
-### Incremental Marking (GC\_STATE\_MARK)
+### Incremental Marking (GC_STATE_MARK)
 
 Gray objects are popped from the gray stack and their children
 marked. Each step processes a limited number of objects:
@@ -137,7 +137,7 @@ When the gray stack is exhausted, the final marking phase re-marks
 the arena and global variables to catch objects created during
 marking, then transitions to sweep.
 
-### Sweep (GC\_STATE\_SWEEP)
+### Sweep (GC_STATE_SWEEP)
 
 Iterates through heap pages. For each object:
 
@@ -325,15 +325,15 @@ From Ruby: `GC.start`.
 
 ### Compile-Time
 
-| Macro | Default | Description |
-| ----- | ------- | ----------- |
-| `MRB_HEAP_PAGE_SIZE` | 1024 | Objects per heap page |
-| `MRB_GRAY_STACK_SIZE` | 1024 | Gray stack capacity |
-| `MRB_GC_ARENA_SIZE` | 100 | Arena size (fixed mode) or initial size |
-| `MRB_GC_FIXED_ARENA` | off | Use fixed-size arena |
-| `MRB_GC_TURN_OFF_GENERATIONAL` | off | Disable generational mode |
-| `MRB_GC_STRESS` | off | Full GC on every allocation (debug) |
-| `MRB_USE_MALLOC_TRIM` | off | Call `malloc_trim()` after full GC |
+| Macro                          | Default | Description                             |
+| ------------------------------ | ------- | --------------------------------------- |
+| `MRB_HEAP_PAGE_SIZE`           | 1024    | Objects per heap page                   |
+| `MRB_GRAY_STACK_SIZE`          | 1024    | Gray stack capacity                     |
+| `MRB_GC_ARENA_SIZE`            | 100     | Arena size (fixed mode) or initial size |
+| `MRB_GC_FIXED_ARENA`           | off     | Use fixed-size arena                    |
+| `MRB_GC_TURN_OFF_GENERATIONAL` | off     | Disable generational mode               |
+| `MRB_GC_STRESS`                | off     | Full GC on every allocation (debug)     |
+| `MRB_USE_MALLOC_TRIM`          | off     | Call `malloc_trim()` after full GC      |
 
 ### Runtime
 
@@ -350,8 +350,8 @@ GC.disable                 # disable GC
 
 ## Source Files
 
-| File | Contents |
-| ---- | -------- |
-| `src/gc.c` | GC implementation (~1400 lines) |
+| File                 | Contents                          |
+| -------------------- | --------------------------------- |
+| `src/gc.c`           | GC implementation (~1400 lines)   |
 | `include/mruby/gc.h` | `mrb_gc` structure, public GC API |
-| `include/mruby.h` | Arena save/restore macros |
+| `include/mruby.h`    | Arena save/restore macros         |

doc/internal/vm.md

@@ -97,12 +97,12 @@ return n + 1 (skip self)
 
 ### Call Context Info (cci)
 
-| Value | Name | Meaning |
-| ----- | ---- | ------- |
-| 0 | `CINFO_NONE` | Normal VM-to-VM call |
-| 1 | `CINFO_DIRECT` | Explicit VM call (block, lambda.call) |
-| 2 | `CINFO_SKIP` | Skip frame in stack traces |
-| 3 | `CINFO_RESUMED` | Fiber resumed (stop execution) |
+| Value | Name            | Meaning                               |
+| ----- | --------------- | ------------------------------------- |
+| 0     | `CINFO_NONE`    | Normal VM-to-VM call                  |
+| 1     | `CINFO_DIRECT`  | Explicit VM call (block, lambda.call) |
+| 2     | `CINFO_SKIP`    | Skip frame in stack traces            |
+| 3     | `CINFO_RESUMED` | Fiber resumed (stop execution)        |
 
 ## Dispatch Loop
 
@@ -241,13 +241,13 @@ correctness.
 
 ### Proc Types
 
-| Flag | Meaning |
-| ---- | ------- |
-| `MRB_PROC_CFUNC_FL` | C function (not irep-based) |
-| `MRB_PROC_STRICT` | Lambda (strict argument check) |
-| `MRB_PROC_ORPHAN` | No environment attachment |
-| `MRB_PROC_ENVSET` | Has captured environment |
-| `MRB_PROC_SCOPE` | Defines a new variable scope |
+| Flag                | Meaning                        |
+| ------------------- | ------------------------------ |
+| `MRB_PROC_CFUNC_FL` | C function (not irep-based)    |
+| `MRB_PROC_STRICT`   | Lambda (strict argument check) |
+| `MRB_PROC_ORPHAN`   | No environment attachment      |
+| `MRB_PROC_ENVSET`   | Has captured environment       |
+| `MRB_PROC_SCOPE`    | Defines a new variable scope   |
 
 ## Fiber Switching
 
@@ -317,9 +317,9 @@ ensuring the incremental GC correctly tracks live references.
 
 ## Source Files
 
-| File | Contents |
-| ---- | -------- |
-| `src/vm.c` | Dispatch loop, method invocation (~1900 lines) |
-| `include/mruby.h` | `mrb_state`, `mrb_callinfo`, `mrb_context` |
-| `include/mruby/proc.h` | `RProc`, `REnv` structures |
-| `include/mruby/throw.h` | `MRB_TRY`/`MRB_CATCH` macros |
+| File                    | Contents                                       |
+| ----------------------- | ---------------------------------------------- |
+| `src/vm.c`              | Dispatch loop, method invocation (~1900 lines) |
+| `include/mruby.h`       | `mrb_state`, `mrb_callinfo`, `mrb_context`     |
+| `include/mruby/proc.h`  | `RProc`, `REnv` structures                     |
+| `include/mruby/throw.h` | `MRB_TRY`/`MRB_CATCH` macros                   |

doc/limitations.md

@@ -274,11 +274,11 @@ enabled with the `MRB_UTF8_STRING` compile flag.
 
 Integer size depends on the value boxing configuration:
 
-| Configuration | Integer range |
-| ------------- | ------------- |
+| Configuration                 | Integer range    |
+| ----------------------------- | ---------------- |
 | Word boxing, 64-bit (default) | roughly +/- 2^62 |
 | Word boxing, 32-bit (default) | roughly +/- 2^30 |
-| NaN boxing (64-bit only) | -2^31 to 2^31-1 |
+| NaN boxing (64-bit only)      | -2^31 to 2^31-1  |
 
 Code relying on 64-bit integer precision may behave differently
 across configurations. The `mruby-bigint` gem provides

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

@@ -15,11 +15,6 @@
  */
 #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.
  *

include/mrbconf.h

@@ -138,8 +138,8 @@
 /* turn off generational GC by default */
 //#define MRB_GC_TURN_OFF_GENERATIONAL
 
-/* default size of khash table bucket */
-//#define KHASH_DEFAULT_SIZE 32
+/* initial size of khash table bucket */
+//#define KHASH_INITIAL_SIZE 32
 
 /* allocated memory address alignment */
 //#define POOL_ALIGNMENT 4
@@ -208,8 +208,8 @@
 #  define MRB_NO_METHOD_CACHE
 # endif
 
-# ifndef KHASH_DEFAULT_SIZE
-#  define KHASH_DEFAULT_SIZE 16
+# ifndef KHASH_INITIAL_SIZE
+#  define KHASH_INITIAL_SIZE 16
 # endif
 
 # ifndef MRB_HEAP_PAGE_SIZE

include/mruby.h

@@ -1015,7 +1015,7 @@ typedef const char *mrb_args_format;
  *      mrb_value str, kw_rest;
  *      uint32_t kw_num = 3;
  *      uint32_t kw_required = 1;
- *      // Note that `#include <mruby/presym.h>` is required beforehand because `MRB_SYM()` is used.
+ *      // `MRB_SYM()` is available via `mruby.h` (which includes `mruby/presym.h`).
  *      // If the usage of `MRB_SYM()` is not desired, replace it with `mrb_intern_lit()`.
  *      mrb_sym kw_names[] = { MRB_SYM(x), MRB_SYM(y), MRB_SYM(z) };
  *      mrb_value kw_values[kw_num];
@@ -1594,6 +1594,8 @@ MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...);
 
 #ifdef MRB_PRESYM_SCANNING
 # include <mruby/presym/scanning.h>
+#else
+# include <mruby/presym.h>
 #endif
 
 #if 0

include/mruby/khash.h

@@ -21,7 +21,7 @@ typedef uint32_t khint_t;
 typedef khint_t khiter_t;
 
 #ifndef KHASH_INITIAL_SIZE
-# define KHASH_INITIAL_SIZE 8
+# define KHASH_INITIAL_SIZE 32
 #endif
 #define KHASH_MIN_SIZE 8
 #define KHASH_SMALL_LIMIT 4

include/mruby/value.h

@@ -316,7 +316,11 @@ struct RCptr {
 #endif
 #define mrb_test(o)   mrb_bool(o)
 #ifndef mrb_bigint_p
+#ifdef MRB_USE_BIGINT
 #define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
+#else
+#define mrb_bigint_p(o) FALSE
+#endif
 #endif
 
 /**

lib/mruby/gem.rb

@@ -109,7 +109,8 @@ module MRuby
         if build.kind_of?(MRuby::CrossBuild)
           return %w(x86_64-w64-mingw32 i686-w64-mingw32).include?(build.host_target)
         elsif build.kind_of?(MRuby::Build)
-          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") }
+          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") } ||
+                 ('a'..'z').to_a.any? { |vol| Dir.exist?("/#{vol}/") }
         end
         return false
       end

mrbgems/hal-posix-socket/src/socket_hal.c

@@ -11,7 +11,6 @@
 #include <mruby/string.h>
 #include <mruby/class.h>
 #include <mruby/error.h>
-#include <mruby/presym.h>
 #include "socket_hal.h"
 
 #include <sys/types.h>

mrbgems/hal-win-socket/src/socket_hal.c

@@ -15,7 +15,6 @@
 #include <mruby/string.h>
 #include <mruby/class.h>
 #include <mruby/error.h>
-#include <mruby/presym.h>
 #include "socket_hal.h"
 #include <winsock2.h>
 #include <ws2tcpip.h>

mrbgems/mruby-array-ext/mrblib/array.rb

@@ -611,37 +611,15 @@ class Array
   #   ary.product(*arys)                  ->   array
   #   ary.product(*arys) { |item| ... }   ->   self
   def product(*arys, &block)
-    size = arys.size
-    i = size
-    while i > 0
-      i -= 1
-      unless arys[i].kind_of?(Array)
-        raise TypeError, "no implicit conversion into Array"
+    gen = __product_generate(arys, &block)
+    return gen unless block
+
+    if gen
+      while group = __product_next(arys, gen)
+        yield group
       end
     end
-
-    i = size
-    total = self.size
-    total *= arys[i -= 1].size while i > 0
-
-    if block
-      i = 0
-      while i < total
-        group = self.__product_group(arys, i, size + 1)
-        block.call(group)
-        i += 1
-      end
-      return self
-    else
-      result = [nil] * total
-      i = 0
-      while i < total
-        group = self.__product_group(arys, i, size + 1)
-        result[i] = group
-        i += 1
-      end
-      return result
-    end
+    self
   end
 
   ##

mrbgems/mruby-array-ext/src/array.c

@@ -6,8 +6,8 @@
 #include <mruby/hash.h>
 #include <mruby/data.h>
 #include <mruby/class.h>
+#include <mruby/numeric.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include <mruby/khash.h>
 #include <mruby/error.h>
 
@@ -79,11 +79,14 @@ ary_assoc(mrb_state *mrb, mrb_value ary)
 {
   mrb_value k = mrb_get_arg1(mrb);
 
+  int ai = mrb_gc_arena_save(mrb);
   for (mrb_int i = 0; i < RARRAY_LEN(ary); i++) {
     mrb_value v = mrb_check_array_type(mrb, RARRAY_PTR(ary)[i]);
+    mrb_gc_protect(mrb, v); // v may be removed from ary by mrb_equal()
     if (!mrb_nil_p(v) && RARRAY_LEN(v) > 0 &&
         mrb_equal(mrb, RARRAY_PTR(v)[0], k))
       return v;
+    mrb_gc_arena_restore(mrb, ai);
   }
   return mrb_nil_value();
 }
@@ -107,12 +110,15 @@ ary_rassoc(mrb_state *mrb, mrb_value ary)
 {
   mrb_value value = mrb_get_arg1(mrb);
 
+  int ai = mrb_gc_arena_save(mrb);
   for (mrb_int i = 0; i < RARRAY_LEN(ary); i++) {
     mrb_value v = RARRAY_PTR(ary)[i];
+    mrb_gc_protect(mrb, v); // v may be removed from ary by mrb_equal()
     if (mrb_array_p(v) &&
         RARRAY_LEN(v) > 1 &&
         mrb_equal(mrb, RARRAY_PTR(v)[1], value))
       return v;
+    mrb_gc_arena_restore(mrb, ai);
   }
   return mrb_nil_value();
 }
@@ -410,9 +416,12 @@ ary_init_temp_set(mrb_state *mrb, ary_set_t *set, mrb_int capacity)
 static void
 ary_populate_temp_set(mrb_state *mrb, ary_set_t *set, mrb_value ary)
 {
-  mrb_int len = RARRAY_LEN(ary);
-  for (mrb_int i = 0; i < len; i++) {
-    kh_put(ary_set, mrb, set, RARRAY_PTR(ary)[i]);
+  int ai = mrb_gc_arena_save(mrb);
+  for (mrb_int i = 0; i < RARRAY_LEN(ary); i++) {
+    mrb_value p = RARRAY_PTR(ary)[i];
+    mrb_gc_protect(mrb, p); // p may be removed from ary by kh_put(ary_set, ...)
+    kh_put(ary_set, mrb, set, p);
+    mrb_gc_arena_restore(mrb, ai);
   }
 }
 
@@ -461,12 +470,15 @@ ary_subtract_body(mrb_state *mrb, void *data)
     ary_populate_temp_set(mrb, ctx->set, ctx->argv[i]);
   }
 
+  int ai = mrb_gc_arena_save(mrb);
   for (mrb_int i = 0; i < RARRAY_LEN(ctx->self); i++) {
     mrb_value p = RARRAY_PTR(ctx->self)[i];
+    mrb_gc_protect(mrb, p); // p may be removed from self by kh_get(ary_set, ...)
     khiter_t k = kh_get(ary_set, mrb, ctx->set, p);
     if (kh_is_end(ctx->set, k)) {  /* key doesn't exist in any ary */
       mrb_ary_push(mrb, ctx->result, p);
     }
+    mrb_gc_arena_restore(mrb, ai);
   }
 
   return ctx->result;
@@ -500,13 +512,13 @@ ary_subtract_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_va
     }
   }
   else {
-    mrb_int self_len = RARRAY_LEN(self);
-    for (mrb_int i = 0; i < self_len; i++) {
+    int ai = mrb_gc_arena_save(mrb);
+    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
       mrb_value p = RARRAY_PTR(self)[i];
+      mrb_gc_protect(mrb, p); // p may be removed from self by mrb_equal()
       mrb_bool found = FALSE;
       for (mrb_int j = 0; j < argc; j++) {
-        mrb_int len = RARRAY_LEN(argv[j]);
-        for (mrb_int k = 0; k < len; k++) {
+        for (mrb_int k = 0; k < RARRAY_LEN(argv[j]); k++) {
           if (mrb_equal(mrb, p, RARRAY_PTR(argv[j])[k])) {
             found = TRUE;
             break;
@@ -517,6 +529,7 @@ ary_subtract_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_va
       if (!found) {
         mrb_ary_push(mrb, result, p);
       }
+      mrb_gc_arena_restore(mrb, ai);
     }
   }
 
@@ -560,12 +573,10 @@ ary_difference(mrb_state *mrb, mrb_value self)
   return ary_subtract_internal(mrb, self, argc, argv);
 }
 
-
 static void
 add_uniq(mrb_state *mrb, mrb_value item, mrb_value result)
 {
-  const mrb_int len = RARRAY_LEN(result);
-  for (mrb_int i = 0; i < len; i++) {
+  for (mrb_int i = 0; i < RARRAY_LEN(result); i++) {
     if (mrb_eql(mrb, item, RARRAY_PTR(result)[i])) {
       return;
     }
@@ -585,15 +596,18 @@ static mrb_value
 ary_union_body(mrb_state *mrb, void *data)
 {
   struct ary_union_ctx *ctx = (struct ary_union_ctx *)data;
+  int ai = mrb_gc_arena_save(mrb);
 
   /* Add unique elements from self */
   for (mrb_int i = 0; i < RARRAY_LEN(ctx->self_copy); i++) {
     mrb_value elem = RARRAY_PTR(ctx->self_copy)[i];
+    mrb_gc_protect(mrb, elem); // elem may be removed from self_copy by kh_get(ary_set, ...)
     khiter_t k = kh_get(ary_set, mrb, ctx->set, elem);
     if (kh_is_end(ctx->set, k)) {
       kh_put(ary_set, mrb, ctx->set, elem);
       mrb_ary_push(mrb, ctx->result, elem);
     }
+    mrb_gc_arena_restore(mrb, ai);
   }
 
   /* Add unique elements from others */
@@ -601,11 +615,13 @@ ary_union_body(mrb_state *mrb, void *data)
     mrb_value other = ctx->argv[i];
     for (mrb_int j = 0; j < RARRAY_LEN(other); j++) {
       mrb_value elem = RARRAY_PTR(other)[j];
+      mrb_gc_protect(mrb, elem); // elem may be removed from other by kh_get(ary_set, ...)
       khiter_t k = kh_get(ary_set, mrb, ctx->set, elem);
       if (kh_is_end(ctx->set, k)) {
         kh_put(ary_set, mrb, ctx->set, elem);
         mrb_ary_push(mrb, ctx->result, elem);
       }
+      mrb_gc_arena_restore(mrb, ai);
     }
   }
 
@@ -637,19 +653,25 @@ ary_union_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_value
     }
   }
   else {
+    int ai = mrb_gc_arena_save(mrb);
+
     /* Use linear search for small arrays */
     /* Add unique elements from self */
-    mrb_int alen = RARRAY_LEN(self);
-    for (mrb_int i = 0; i < alen; i++) {
-      add_uniq(mrb, RARRAY_PTR(self)[i], result);
+    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
+      mrb_value p = RARRAY_PTR(self)[i];
+      mrb_gc_protect(mrb, p); // p may be removed from self by add_uniq()
+      add_uniq(mrb, p, result);
+      mrb_gc_arena_restore(mrb, ai);
     }
 
     /* Add unique elements from others */
     for (mrb_int i = 0; i < argc; i++) {
       mrb_value other = argv[i];
-      mrb_int olen = RARRAY_LEN(other);
-      for (mrb_int j = 0; j < olen; j++) {
-        add_uniq(mrb, RARRAY_PTR(other)[j], result);
+      for (mrb_int j = 0; j < RARRAY_LEN(other); j++) {
+        mrb_value p = RARRAY_PTR(other)[j];
+        mrb_gc_protect(mrb, p); // p may be removed from other by add_uniq()
+        add_uniq(mrb, p, result);
+        mrb_gc_arena_restore(mrb, ai);
       }
     }
   }
@@ -712,13 +734,16 @@ ary_intersection_body(mrb_state *mrb, void *data)
     ary_populate_temp_set(mrb, ctx->set, ctx->argv[i]);
   }
 
+  int ai = mrb_gc_arena_save(mrb);
   for (mrb_int i = 0; i < RARRAY_LEN(ctx->self); i++) {
     mrb_value p = RARRAY_PTR(ctx->self)[i];
+    mrb_gc_protect(mrb, p); // p may be removed from self by kh_get(ary_set, ...)
     khiter_t k = kh_get(ary_set, mrb, ctx->set, p);
     if (!kh_is_end(ctx->set, k)) {
       mrb_ary_push(mrb, ctx->result, p);
       kh_del(ary_set, mrb, ctx->set, k);
     }
+    mrb_gc_arena_restore(mrb, ai);
   }
 
   return ctx->result;
@@ -752,15 +777,15 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr
     }
   }
   else {
-    mrb_int self_len = RARRAY_LEN(self);
-    for (mrb_int i = 0; i < self_len; i++) {
+    int ai = mrb_gc_arena_save(mrb);
+    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
       mrb_value p = RARRAY_PTR(self)[i];
+      mrb_gc_protect(mrb, p); // p may be removed from self by mrb_equal()
       mrb_bool found_in_all = TRUE;
 
       for (mrb_int j = 0; j < argc; j++) {
         mrb_bool found_in_current_other = FALSE;
-        mrb_int len = RARRAY_LEN(argv[j]);
-        for (mrb_int k = 0; k < len; k++) {
+        for (mrb_int k = 0; k < RARRAY_LEN(argv[j]); k++) {
           if (mrb_equal(mrb, p, RARRAY_PTR(argv[j])[k])) {
             found_in_current_other = TRUE;
             break;
@@ -774,8 +799,7 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr
 
       if (found_in_all) {
         mrb_bool already_added = FALSE;
-        mrb_int result_len = RARRAY_LEN(result);
-        for (mrb_int j = 0; j < result_len; j++) {
+        for (mrb_int j = 0; j < RARRAY_LEN(result); j++) {
           if (mrb_equal(mrb, p, RARRAY_PTR(result)[j])) {
             already_added = TRUE;
             break;
@@ -785,6 +809,7 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr
           mrb_ary_push(mrb, result, p);
         }
       }
+      mrb_gc_arena_restore(mrb, ai);
     }
   }
   return result;
@@ -855,8 +880,12 @@ ary_intersect_p_body(mrb_state *mrb, void *data)
 
   ary_populate_temp_set(mrb, ctx->set, ctx->shorter_ary_copy);
 
+  int ai = mrb_gc_arena_save(mrb);
   for (mrb_int i = 0; i < RARRAY_LEN(ctx->longer_ary); i++) {
-    khiter_t k = kh_get(ary_set, mrb, ctx->set, RARRAY_PTR(ctx->longer_ary)[i]);
+    mrb_value p = RARRAY_PTR(ctx->longer_ary)[i];
+    mrb_gc_protect(mrb, p); // p may be removed from longer_ary by kh_get(ary_set, ...)
+    khiter_t k = kh_get(ary_set, mrb, ctx->set, p);
+    mrb_gc_arena_restore(mrb, ai);
     if (!kh_is_end(ctx->set, k)) {
       *ctx->found = TRUE;
       break;
@@ -906,12 +935,16 @@ ary_intersect_p(mrb_state *mrb, mrb_value self)
     }
   }
   else {
+    int ai = mrb_gc_arena_save(mrb);
     for (mrb_int i = 0; i < RARRAY_LEN(longer_ary); i++) {
+      mrb_value p = RARRAY_PTR(longer_ary)[i];
+      mrb_gc_protect(mrb, p); // p may be removed from longer_ary by mrb_equal()
       for (mrb_int j = 0; j < RARRAY_LEN(shorter_ary); j++) {
-        if (mrb_equal(mrb, RARRAY_PTR(longer_ary)[i], RARRAY_PTR(shorter_ary)[j])) {
+        if (mrb_equal(mrb, p, RARRAY_PTR(shorter_ary)[j])) {
           return mrb_true_value();
         }
       }
+      mrb_gc_arena_restore(mrb, ai);
     }
   }
 
@@ -1042,6 +1075,7 @@ ary_fill_exec(mrb_state *mrb, mrb_value self)
   }
 
   /* Fill the array */
+  mrb_ary_modify(mrb, ary);
   mrb_value *ptr = ARY_PTR(ary) + start;
   for (mrb_int i = 0; i < length; i++) {
     ptr[i] = obj;
@@ -1059,7 +1093,6 @@ struct ary_uniq_bang_ctx {
   mrb_value self_copy;
   mrb_value self;
   mrb_int *write_pos;
-  mrb_int len;
 };
 
 static mrb_value
@@ -1069,15 +1102,19 @@ ary_uniq_bang_body(mrb_state *mrb, void *data)
 
   ary_populate_temp_set(mrb, ctx->set, ctx->self_copy);
 
-  for (mrb_int read_pos = 0; read_pos < ctx->len; read_pos++) {
+  int ai = mrb_gc_arena_save(mrb);
+  for (mrb_int read_pos = 0; read_pos < RARRAY_LEN(ctx->self); read_pos++) {
     mrb_value elem = RARRAY_PTR(ctx->self)[read_pos];
+    mrb_gc_protect(mrb, elem); // elem may be removed from self by kh_get(ary_set, ...)
     khiter_t k = kh_get(ary_set, mrb, ctx->set, elem);
     if (!kh_is_end(ctx->set, k)) {
-      if (*ctx->write_pos != read_pos) {
+      if (*ctx->write_pos != read_pos && *ctx->write_pos < RARRAY_LEN(ctx->self)) {
+        mrb_ary_modify(mrb, mrb_ary_ptr(ctx->self));
         RARRAY_PTR(ctx->self)[*ctx->write_pos] = elem;
       }
       (*ctx->write_pos)++;
       kh_del(ary_set, mrb, ctx->set, k);
+      mrb_gc_arena_restore(mrb, ai);
     }
   }
 
@@ -1104,28 +1141,32 @@ ary_uniq_bang(mrb_state *mrb, mrb_value self)
     ary_set_t *set = &set_struct;
     ary_init_temp_set(mrb, set, len);
 
-    struct ary_uniq_bang_ctx ctx = { set, self_copy, self, &write_pos, len };
+    struct ary_uniq_bang_ctx ctx = { set, self_copy, self, &write_pos };
     mrb_value result;
     MRB_ENSURE(mrb, result, ary_uniq_bang_body, &ctx) {
       ary_destroy_temp_set(mrb, set);
     }
   }
   else {
-    for (mrb_int read_pos = 0; read_pos < len; read_pos++) {
+    int ai = mrb_gc_arena_save(mrb);
+    for (mrb_int read_pos = 0; read_pos < RARRAY_LEN(self); read_pos++) {
       mrb_value elem = RARRAY_PTR(self)[read_pos];
+      mrb_gc_protect(mrb, elem); // elem may be removed from self by mrb_equal()
       mrb_bool found = FALSE;
-      for (mrb_int j = 0; j < write_pos; j++) {
+      for (mrb_int j = 0; j < write_pos && j < RARRAY_LEN(self); j++) {
         if (mrb_equal(mrb, elem, RARRAY_PTR(self)[j])) {
           found = TRUE;
           break;
         }
       }
       if (!found) {
-        if (write_pos != read_pos) {
+        if (write_pos != read_pos && write_pos < RARRAY_LEN(self)) {
+          mrb_ary_modify(mrb, mrb_ary_ptr(self));
           RARRAY_PTR(self)[write_pos] = elem;
         }
         write_pos++;
       }
+      mrb_gc_arena_restore(mrb, ai);
     }
   }
 
@@ -1374,6 +1415,13 @@ ary_insert(mrb_state *mrb, mrb_value self)
   return self;
 }
 
+struct ary_product_generator {
+  mrb_int total;
+  mrb_int cursor;
+};
+
+static struct mrb_data_type ary_product_generator_type = { "ary_product_generator", mrb_free };
+
 /*
  *  Internal helper for Array#product to construct a group array.
  *  Takes the base array (self), the array of other arrays (arys),
@@ -1381,29 +1429,85 @@ ary_insert(mrb_state *mrb, mrb_value self)
  *  of the group array (group_len).
  */
 static mrb_value
-ary_product_group(mrb_state *mrb, mrb_value self_ary)
+ary_product_fetch(mrb_state *mrb, mrb_value self_ary, mrb_value arys_ary, mrb_int n)
 {
-  mrb_value arys_ary;
-  mrb_int current_i, group_len;
-  mrb_get_args(mrb, "Aii", &arys_ary, &current_i, &group_len);
-
-  mrb_value group = mrb_ary_new_capa(mrb, group_len);
   mrb_int j = RARRAY_LEN(arys_ary); // Corresponds to 'size' in Ruby
-  mrb_int n = current_i;
+  mrb_value group = mrb_ary_new_capa(mrb, j + 1 /* self_ary */);
 
-  while (j > 0) {
-    j -= 1;
+  while (j-- > 0) {
     mrb_value a = RARRAY_PTR(arys_ary)[j]; // arys[j]
     mrb_check_type(mrb, a, MRB_TT_ARRAY);
     mrb_int b = RARRAY_LEN(a);             // a.size
+    if (b <= 0) {
+      mrb_raise(mrb, E_ARGUMENT_ERROR, "cannot compute product with an empty array");
+    }
     mrb_ary_set(mrb, group, j + 1, RARRAY_PTR(a)[n % b]);
     n /= b;
   }
+  if (n >= RARRAY_LEN(self_ary)) {
+    mrb_raise(mrb, E_INDEX_ERROR, "index out of range");
+  }
   mrb_ary_set(mrb, group, 0, RARRAY_PTR(self_ary)[n]);
 
   return group;
 }
 
+static mrb_value
+ary_product_generate(mrb_state *mrb, mrb_value self)
+{
+  mrb_value arys_ary, block;
+  mrb_get_args(mrb, "A&", &arys_ary, &block);
+
+  mrb_int total = RARRAY_LEN(self);
+  for (mrb_int i = 0; i < RARRAY_LEN(arys_ary); i++) {
+    mrb_value a = RARRAY_PTR(arys_ary)[i];
+    mrb_check_type(mrb, a, MRB_TT_ARRAY);
+    mrb_int n = RARRAY_LEN(a);
+    if (n == 0) {
+      total = 0;
+      break;
+    }
+    if (mrb_int_mul_overflow(total, n, &total)) {
+      mrb_raise(mrb, E_ARGUMENT_ERROR, "result too big");
+    }
+  }
+
+  if (mrb_nil_p(block)) {
+    mrb_value result = mrb_ary_new_capa(mrb, total);
+    for (mrb_int i = 0; i < total; i++) {
+      mrb_value group = ary_product_fetch(mrb, self, arys_ary, i);
+      mrb_ary_push(mrb, result, group);
+    }
+    return result;
+  }
+  else if (total > 0) {
+    struct RData *d;
+    struct ary_product_generator *g;
+    Data_Make_Struct(mrb, mrb->object_class, struct ary_product_generator,
+                     &ary_product_generator_type, g, d);
+    g->total = total;
+    g->cursor = 0;
+    return mrb_obj_value(d);
+  }
+  else {
+    return mrb_nil_value();
+  }
+}
+
+static mrb_value
+ary_product_next(mrb_state *mrb, mrb_value self)
+{
+  mrb_value arys;
+  struct ary_product_generator *g;
+  mrb_get_args(mrb, "Ad", &arys, &g, &ary_product_generator_type);
+
+  if (g->cursor >= g->total) {
+    return mrb_nil_value();
+  }
+
+  return ary_product_fetch(mrb, self, arys, g->cursor++);
+}
+
 /*
  *  call-seq:
  *     ary.deconstruct -> ary
@@ -1564,7 +1668,8 @@ static const mrb_mt_entry array_ext_rom_entries[] = {
   MRB_MT_ENTRY(ary_fetch,              MRB_SYM(__fetch),            MRB_ARGS_REQ(3)),
   MRB_MT_ENTRY(ary_insert,             MRB_SYM(insert),             MRB_ARGS_ARG(1,-1)),
   MRB_MT_ENTRY(ary_deconstruct,        MRB_SYM(deconstruct),        MRB_ARGS_NONE()),
-  MRB_MT_ENTRY(ary_product_group,      MRB_SYM(__product_group),    MRB_ARGS_REQ(3)),
+  MRB_MT_ENTRY(ary_product_generate,   MRB_SYM(__product_generate), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(ary_product_next,       MRB_SYM(__product_next),     MRB_ARGS_REQ(2)),
   MRB_MT_ENTRY(ary_combination_init,   MRB_SYM(__combination_init), MRB_ARGS_REQ(2)),
   MRB_MT_ENTRY(ary_combination_next,   MRB_SYM(__combination_next), MRB_ARGS_REQ(1)),
 };

mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c

@@ -12,7 +12,6 @@
 #include <mruby/numeric.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include "apiprint.h"
 
 static void

mrbgems/mruby-bin-mirb/tools/mirb/mirb.c

@@ -19,7 +19,6 @@
 #include <mruby/string.h>
 #include <mruby/variable.h>
 #include <mruby/error.h>
-#include <mruby/presym.h>
 #include <mruby/internal.h>
 
 #include <stdlib.h>

mrbgems/mruby-bin-mruby/tools/mruby/mruby.c

@@ -12,7 +12,6 @@
 #include <mruby/variable.h>
 #include <mruby/proc.h>
 #include <mruby/error.h>
-#include <mruby/presym.h>
 
 #if defined(_WIN32)
 # include <io.h> /* for setmode */

mrbgems/mruby-binding/src/binding.c

@@ -4,7 +4,6 @@
 #include <mruby/hash.h>
 #include <mruby/proc.h>
 #include <mruby/variable.h>
-#include <mruby/presym.h>
 #include <mruby/opcode.h>
 #include <mruby/debug.h>
 #include <mruby/internal.h>

mrbgems/mruby-binding/test/binding.c

@@ -1,5 +1,4 @@
 #include <mruby.h>
-#include <mruby/presym.h>
 
 static mrb_value
 binding_in_c(mrb_state *mrb, mrb_value self)

mrbgems/mruby-catch/src/catch.c

@@ -4,7 +4,6 @@
 #include <mruby/error.h>
 #include <mruby/proc.h>
 #include <mruby/opcode.h>
-#include <mruby/presym.h>
 
 /* Pre-defined symbols used by catch implementation */
 MRB_PRESYM_DEFINE_VAR_AND_INITER(catch_syms, 3, MRB_SYM(Object), MRB_SYM(new), MRB_SYM(call))

mrbgems/mruby-class-ext/src/class.c

@@ -5,7 +5,6 @@
 #include <mruby/proc.h>
 #include <mruby/variable.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 /*
  * Get the name of a module/class.

mrbgems/mruby-cmath/src/cmath.c

@@ -10,7 +10,6 @@
 */
 
 #include <mruby.h>
-#include <mruby/presym.h>
 
 #ifdef MRB_NO_FLOAT
 # error CMath conflicts with 'MRB_NO_FLOAT' configuration

mrbgems/mruby-compiler/core/codegen.c

@@ -46,7 +46,6 @@
 #include <mruby/numeric.h>
 #include <mruby/string.h>
 #include <mruby/debug.h>
-#include <mruby/presym.h>
 #include "node.h"
 #include <mruby/opcode.h>
 #include <mruby/re.h>
@@ -3176,8 +3175,12 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
 {
   if (val) {
     int array_size = 0;
+    int first = 1;
+    int slimit = GEN_LIT_ARY_MAX;
     node *current = tree;
 
+    if (cursp() >= slimit) slimit = GEN_VAL_STACK_MAX;
+
     /* Process each segment separated by NODE_LITERAL_DELIM */
     while (current) {
       /* Find the segment boundaries without allocating */
@@ -3214,6 +3217,24 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
 
         /* Only process non-empty segments */
         if (!is_empty_segment) {
+          /* Flush accumulated elements when stack is full */
+          if (cursp() >= slimit) {
+            if (array_size > 0) {
+              pop_n(array_size);
+              if (first) {
+                genop_2(s, OP_ARRAY, cursp(), array_size);
+                push();
+                first = 0;
+              }
+              else {
+                pop();
+                genop_2(s, OP_ARYPUSH, cursp(), array_size);
+                push();
+              }
+              array_size = 0;
+            }
+          }
+
           /* Temporarily terminate the segment by saving and clearing the cdr */
           node *saved_cdr = NULL;
           if (segment_prev) {
@@ -3244,8 +3265,14 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
       }
     }
 
-    /* Generate the array from pushed elements */
-    if (array_size > 0) {
+    /* Handle remaining elements */
+    if (!first) {
+      if (array_size > 0) {
+        pop_n(array_size + 1);
+        genop_2(s, OP_ARYPUSH, cursp(), array_size);
+      }
+    }
+    else if (array_size > 0) {
       pop_n(array_size);
       genop_2(s, OP_ARRAY, cursp(), array_size);
     }
@@ -3821,7 +3848,7 @@ codegen_array(codegen_scope *s, node *varnode, int val)
   node *elements = array->elements;
   int regular_elements = 0;
   int first = 1;
-  int slimit = GEN_VAL_STACK_MAX;
+  int slimit = GEN_LIT_ARY_MAX;
 
   if (!val) return;
 
@@ -3831,7 +3858,7 @@ codegen_array(codegen_scope *s, node *varnode, int val)
     return;
   }
 
-  if (cursp() >= GEN_LIT_ARY_MAX) slimit = INT16_MAX;
+  if (cursp() >= slimit) slimit = GEN_VAL_STACK_MAX;
 
   /* Process each element using cons-list iteration, handling splats */
   node *current = elements;
@@ -4428,10 +4455,9 @@ codegen_case_match(codegen_scope *s, node *varnode, int val)
     current_in = current_in->cdr;
   }
 
-  /* No pattern matched - generate nil or error */
-  if (val) {
-    genop_1(s, OP_LOADNIL, cursp());
-  }
+  /* No pattern matched - raise NoMatchingPatternError */
+  genop_1(s, OP_LOADFALSE, cursp());
+  genop_1(s, OP_MATCHERR, cursp());
 
   /* Dispatch all end jumps */
   if (case_end_jumps != JMPLINK_START) {

mrbgems/mruby-compiler/core/parse.y

@@ -23,7 +23,6 @@
 #include <mruby/string.h>
 #include <mruby/dump.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include "node.h"
 
 #define YYLEX_PARAM p
@@ -3261,7 +3260,7 @@ primary         : literal
                       $<stack>$ = p->cmdarg_stack;
                       p->cmdarg_stack = 0;
                     }
-                  stmt {p->lstate = EXPR_ENDARG;} rparen
+                  compstmt {p->lstate = EXPR_ENDARG;} rparen
                     {
                       p->cmdarg_stack = $<stack>2;
                       $$ = $3;
@@ -4564,13 +4563,13 @@ f_label         : tIDENTIFIER tLABEL_TAG
                     {
                       $$ = $1;
                       local_nest(p);
-                      p->lstate = EXPR_ARG;  /* make newlines significant after label */
+                      p->lstate = EXPR_MID;  /* make newlines significant after label */
                     }
                 | tNUMPARAM tLABEL_TAG
                     {
                       $$ = intern_numparam($1);
                       local_nest(p);
-                      p->lstate = EXPR_ARG;  /* make newlines significant after label */
+                      p->lstate = EXPR_MID;  /* make newlines significant after label */
                     }
                 ;
 

mrbgems/mruby-complex/src/complex.c

@@ -2,7 +2,6 @@
 #include <mruby/class.h>
 #include <mruby/numeric.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include <float.h>
 
 #ifdef MRB_NO_FLOAT

mrbgems/mruby-data/src/data.c

@@ -13,7 +13,6 @@
 #include <mruby/hash.h>
 #include <mruby/proc.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #define RDATA_LEN(st) RARRAY_LEN(st)
 #define RDATA_PTR(st) RARRAY_PTR(st)

mrbgems/mruby-dir/src/dir.c

@@ -10,7 +10,6 @@
 #include <mruby/data.h>
 #include <mruby/error.h>
 #include <mruby/string.h>
-#include <mruby/presym.h>
 #include "dir_hal.h"
 
 #include <string.h>

mrbgems/mruby-encoding/src/encoding.c

@@ -2,7 +2,6 @@
 #include <mruby/string.h>
 #include <mruby/variable.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #define ENC_ASCII_8BIT "ASCII-8BIT"
 #define ENC_BINARY     "BINARY"

mrbgems/mruby-enum-lazy/mrblib/lazy.rb

@@ -291,11 +291,12 @@ class Enumerator
     #
     def flat_map(&block)
       Lazy.new(self){|yielder, val|
-        ary = block.call(val)
-        # TODO: check ary is an Array
-        ary.each {|x|
-          yielder << x
-        }
+        result = block.call(val)
+        if result.respond_to?(:each)
+          result.each {|x| yielder << x }
+        else
+          yielder << result
+        end
       }
     end
     alias collect_concat flat_map

mrbgems/mruby-enum-lazy/test/lazy.rb

@@ -46,6 +46,18 @@ assert("Enumerator::Lazy#to_enum") do
   assert_equal [0*1, 2*3, 4*5, 6*7], lazy_enum.map { |a| a.first * a.last }.first(4)
 end
 
+assert("Enumerator::Lazy#flat_map with array from block") do
+  assert_equal [1, 10, 2, 20, 3, 30], [1, 2, 3].lazy.flat_map {|x| [x, x*10]}.force
+end
+
+assert("Enumerator::Lazy#flat_map with non-enumerable from block") do
+  assert_equal [1, 2, 3], [1, 2, 3].lazy.flat_map {|x| x}.force
+end
+
+assert("Enumerator::Lazy#flat_map with nested array from block") do
+  assert_equal [[1, 2], [3, 4]], [1, 3].lazy.flat_map {|x| [[x, x+1]]}.force
+end
+
 assert("Enumerator::Lazy#grep_v") do
   lazy_grep_v = (0..).lazy.grep_v(2..4)
   assert_kind_of Enumerator::Lazy, lazy_grep_v

mrbgems/mruby-errno/src/errno.c

@@ -7,7 +7,6 @@
 #include <mruby/string.h>
 #include <mruby/variable.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include <errno.h>
 #include <string.h>
 

mrbgems/mruby-eval/src/eval.c

@@ -6,7 +6,6 @@
 #include <mruby/proc.h>
 #include <mruby/opcode.h>
 #include <mruby/error.h>
-#include <mruby/presym.h>
 #include <mruby/variable.h>
 #include <mruby/internal.h>
 

mrbgems/mruby-exit/src/mruby_exit.c

@@ -2,7 +2,6 @@
 #include <mruby.h>
 #include <mruby/error.h>
 #include <mruby/variable.h>
-#include <mruby/presym.h>
 
 #ifndef EXIT_SUCCESS
 # define EXIT_SUCCESS 0

mrbgems/mruby-fiber/src/fiber.c

@@ -6,7 +6,6 @@
 #include <mruby/numeric.h>
 #include <mruby/proc.h>
 #include <mruby/string.h>
-#include <mruby/presym.h>
 
 #define fiber_ptr(o) ((struct RFiber*)mrb_ptr(o))
 

mrbgems/mruby-hash-ext/src/hash_ext.c

@@ -9,7 +9,6 @@
 #include <mruby/hash.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 /*
  * call-seq:

mrbgems/mruby-io/src/file.c

@@ -10,7 +10,6 @@
 #include <mruby/io.h>
 #include <mruby/error.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include "io_hal.h"
 
 #include <sys/types.h>

mrbgems/mruby-io/src/file_test.c

@@ -8,7 +8,6 @@
 #include <mruby/string.h>
 #include <mruby/io.h>
 #include <mruby/error.h>
-#include <mruby/presym.h>
 #include <mruby/internal.h>
 #include "io_hal.h"
 

mrbgems/mruby-io/src/io.c

@@ -12,7 +12,6 @@
 #include <mruby/io.h>
 #include <mruby/error.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include "io_hal.h"
 
 #include <sys/types.h>

mrbgems/mruby-kernel-ext/src/kernel.c

@@ -8,7 +8,6 @@
 #include <mruby/proc.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 /*
  * call-seq:

mrbgems/mruby-math/src/math.c

@@ -11,7 +11,6 @@
 #endif
 
 #include <mruby/array.h>
-#include <mruby/presym.h>
 
 static void
 domain_error(mrb_state *mrb, const char *func)

mrbgems/mruby-metaprog/src/metaprog.c

@@ -7,7 +7,6 @@
 #include <mruby/string.h>
 #include <mruby/internal.h>
 #include <mruby/khash.h>
-#include <mruby/presym.h>
 
 #define MT_PROTECTED MRB_METHOD_PROTECTED_FL
 #define MT_NOPRIV (MRB_METHOD_PRIVATE_FL|MT_PROTECTED)

mrbgems/mruby-method/src/method.c

@@ -5,7 +5,6 @@
 #include <mruby/proc.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 // Defined by mruby-proc-ext on which mruby-method depends
 mrb_value mrb_proc_parameters(mrb_state *mrb, mrb_value proc);

mrbgems/mruby-numeric-ext/src/numeric_ext.c

@@ -4,7 +4,6 @@
 #include <mruby/string.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #ifndef MRB_NO_FLOAT
 static mrb_value flo_remainder(mrb_state *mrb, mrb_value self);
@@ -191,11 +190,7 @@ int_powm(mrb_state *mrb, mrb_value x)
     return mrb_int_pow(mrb, x, mrb_get_arg1(mrb));
   }
   mrb_get_args(mrb, "oo", &e, &m);
-  if (!mrb_integer_p(e)
-#ifdef MRB_USE_BIGINT
-      && !mrb_bigint_p(e)
-#endif
-      ) {
+  if (!mrb_integer_p(e) && !mrb_bigint_p(e)) {
     mrb_raise(mrb, E_TYPE_ERROR, "int.pow(n,m): 2nd argument not allowed unless 1st argument is an integer");
   }
 #ifdef MRB_USE_BIGINT

mrbgems/mruby-object-ext/src/object.c

@@ -4,7 +4,6 @@
 #include <mruby/hash.h>
 #include <mruby/proc.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 /*
  *  call-seq:

mrbgems/mruby-objectspace/src/mruby_objectspace.c

@@ -10,7 +10,6 @@
 #include <mruby/proc.h>
 #include <mruby/value.h>
 #include <mruby/range.h>
-#include <mruby/presym.h>
 
 struct os_count_struct {
   mrb_int total;

mrbgems/mruby-pack/src/pack.c

@@ -11,7 +11,6 @@
 #include <mruby/variable.h>
 #include <mruby/endian.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #include <ctype.h>
 #include <string.h>

mrbgems/mruby-proc-binding/src/proc_binding.c

@@ -1,5 +1,4 @@
 #include <mruby.h>
-#include <mruby/presym.h>
 #include <mruby/proc.h>
 #include <mruby/variable.h>
 

mrbgems/mruby-proc-ext/src/proc.c

@@ -6,7 +6,6 @@
 #include <mruby/string.h>
 #include <mruby/debug.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 /*
  *  call-seq:

mrbgems/mruby-random/src/random.c

@@ -11,7 +11,6 @@
 #include <mruby/data.h>
 #include <mruby/array.h>
 #include <mruby/istruct.h>
-#include <mruby/presym.h>
 #include <mruby/range.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>

mrbgems/mruby-range-ext/src/range.c

@@ -2,7 +2,6 @@
 #include <mruby/range.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 static mrb_bool
 r_less(mrb_state *mrb, mrb_value a, mrb_value b, mrb_bool excl)

mrbgems/mruby-rational/src/rational.c

@@ -2,7 +2,6 @@
 #include <mruby/class.h>
 #include <mruby/numeric.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #ifndef MRB_NO_FLOAT
 #include <math.h>

mrbgems/mruby-set/src/set.c

@@ -13,7 +13,6 @@
 #include <mruby/proc.h>
 #include <mruby/data.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include <mruby/error.h>
 #include <mruby/khash.h>
 

mrbgems/mruby-sleep/src/sleep.c

@@ -37,7 +37,6 @@
 #endif
 
 #include <mruby.h>
-#include <mruby/presym.h>
 
 /*
  * call-seq:

mrbgems/mruby-socket/src/socket.c

@@ -36,7 +36,6 @@
 #include <mruby/variable.h>
 #include <mruby/error.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #include <mruby/io.h>
 #include "socket_hal.h"

mrbgems/mruby-sprintf/src/sprintf.c

@@ -8,7 +8,6 @@
 #include <mruby/string.h>
 #include <mruby/hash.h>
 #include <mruby/numeric.h>
-#include <mruby/presym.h>
 #include <mruby/internal.h>
 #include <string.h>
 #include <ctype.h>

mrbgems/mruby-strftime/src/strftime.c

@@ -8,7 +8,6 @@
 #include <mruby/string.h>
 #include <mruby/time.h>
 #include <mruby/class.h>
-#include <mruby/presym.h>
 #include <time.h>
 #include <string.h>
 

mrbgems/mruby-string-ext/src/string.c

@@ -5,7 +5,6 @@
 #include <mruby/string.h>
 #include <mruby/range.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #define ENC_ASCII_8BIT "ASCII-8BIT"
 #define ENC_BINARY     "BINARY"

mrbgems/mruby-struct/src/struct.c

@@ -14,7 +14,6 @@
 #include <mruby/range.h>
 #include <mruby/proc.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #define RSTRUCT_LEN(st) RARRAY_LEN(st)
 #define RSTRUCT_PTR(st) RARRAY_PTR(st)

mrbgems/mruby-symbol-ext/src/symbol.c

@@ -3,7 +3,6 @@
 #include <mruby/class.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 /*
  *  call-seq:

mrbgems/mruby-task/src/task.c

@@ -12,7 +12,6 @@
 #include <mruby/gc.h>
 #include <mruby/hash.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include <mruby/proc.h>
 #include <mruby/string.h>
 #include <mruby/variable.h>

mrbgems/mruby-test/mrbgem.rake

@@ -19,9 +19,11 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
   file assert_c => [assert_rb, build.mrbcfile] do |t|
     _pp "GEN", t.name.relative_path
     mkdir_p File.dirname(t.name)
-    open(t.name, 'w') do |f|
+    tmpfile = t.name + ".tmp"
+    open(tmpfile, 'w') do |f|
       mrbc.run f, assert_rb, 'mrbtest_assert_irep', cdump: false
     end
+    File.rename(tmpfile, t.name)
   end
 
   gem_table = build.gems.generate_gem_table build
@@ -36,7 +38,8 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
     file g.test_rbireps => [g.test_rbfiles, build.mrbcfile].flatten do |t|
       _pp "GEN", t.name.relative_path
       mkdir_p File.dirname(t.name)
-      open(t.name, 'w') do |f|
+      tmpfile = t.name + ".tmp"
+      open(tmpfile, 'w') do |f|
         g.print_gem_test_header(f)
         test_preload = g.test_preload and [g.dir, MRUBY_ROOT].map {|dir|
           File.expand_path(g.test_preload, dir)
@@ -117,6 +120,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
         end
         f.puts %Q[}]
       end
+      File.rename(tmpfile, t.name)
     end
   end
 
@@ -134,7 +138,8 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
   file clib => ["#{build.build_dir}/mrbgems/active_gems.txt", build.mrbcfile, __FILE__] do |_t|
     _pp "GEN", clib.relative_path
     mkdir_p File.dirname(clib)
-    open(clib, 'w') do |f|
+    tmpfile = clib + ".tmp"
+    open(tmpfile, 'w') do |f|
       f.puts %Q[/*]
       f.puts %Q[ * This file contains a list of all]
       f.puts %Q[ * test functions.]
@@ -169,5 +174,6 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
       end
       f.puts %Q[}]
     end
+    File.rename(tmpfile, clib)
   end
 end

mrbgems/mruby-time/src/time.c

@@ -11,7 +11,6 @@
 #include <mruby/time.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #ifdef MRB_NO_STDIO
 #include <string.h>

src/array.c

@@ -11,7 +11,6 @@
 #include <mruby/range.h>
 #include <mruby/proc.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include "value_array.h"
 
 #define ARY_DEFAULT_LEN   4

src/backtrace.c

@@ -15,7 +15,6 @@
 #include <mruby/numeric.h>
 #include <mruby/data.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #define MAX_IREP_REFCNT UINT16_MAX
 #define UNKNOWN_LINENO -1

src/cdump.c

@@ -456,7 +456,6 @@ mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE
                   "#include <mruby/irep.h>\n"
                   "#include <mruby/debug.h>\n"
                   "#include <mruby/proc.h>\n"
-                  "#include <mruby/presym.h>\n"
                   "\n") < 0) {
     return MRB_DUMP_WRITE_FAULT;
   }

src/class.c

@@ -17,7 +17,6 @@
 #include <mruby/istruct.h>
 #include <mruby/opcode.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 /* mrb_mt_tbl, union mrb_mt_ptr, mrb_mt_entry defined in internal.h */
 #define MT_PROTECTED MRB_METHOD_PROTECTED_FL
@@ -2749,7 +2748,7 @@ prepare_writer_name(mrb_state *mrb, mrb_sym sym)
 }
 
 static mrb_value
-mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_value (*accessor)(mrb_state*, mrb_value), mrb_sym (*access_name)(mrb_state*, mrb_sym))
+mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_int aargc, mrb_value (*accessor)(mrb_state*, mrb_value), mrb_sym (*access_name)(mrb_state*, mrb_sym))
 {
   struct RClass *c = mrb_class_ptr(mod);
   const mrb_value *argv;
@@ -2766,6 +2765,7 @@ mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_value (*accessor)(mrb_state*,
     }
 
     struct RProc *p = mrb_proc_new_cfunc_with_env(mrb, accessor, 1, &name);
+    p->flags |= aargc == 0 ? MRB_PROC_NOARG : 0;
     mrb_method_t m;
     MRB_METHOD_FROM_PROC(m, p);
     mrb_define_method_raw(mrb, c, method, m);
@@ -2784,7 +2784,7 @@ attr_reader(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_mod_attr_reader(mrb_state *mrb, mrb_value mod)
 {
-  return mod_attr_define(mrb, mod, attr_reader, NULL);
+  return mod_attr_define(mrb, mod, 0, attr_reader, NULL);
 }
 
 static mrb_value
@@ -2800,7 +2800,7 @@ attr_writer(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_mod_attr_writer(mrb_state *mrb, mrb_value mod)
 {
-  return mod_attr_define(mrb, mod, attr_writer, prepare_writer_name);
+  return mod_attr_define(mrb, mod, 1, attr_writer, prepare_writer_name);
 }
 
 static mrb_value

src/enum.c

@@ -6,7 +6,6 @@
 
 #include <mruby.h>
 #include <mruby/proc.h>
-#include <mruby/presym.h>
 
 /* internal method `__update_hash(oldhash, index, itemhash)` */
 static mrb_value

src/error.c

@@ -16,7 +16,6 @@
 #include <mruby/class.h>
 #include <mruby/throw.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 void
 mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg)

src/gc.c

@@ -22,7 +22,6 @@
 #include <mruby/error.h>
 #include <mruby/throw.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 #ifdef MRB_GC_STRESS
 #include <stdlib.h>
@@ -542,15 +541,15 @@ mrb_gc_unregister(mrb_state *mrb, mrb_value obj)
   if (!mrb_array_p(table)) return;
   struct RArray *a = mrb_ary_ptr(table);
   mrb_ary_modify(mrb, a);
-  mrb_int len = ARY_LEN(a)-1;
+  mrb_int len = ARY_LEN(a);
   mrb_value *ptr = ARY_PTR(a);
-  for (mrb_int i = 0; i <= len; i++) {
-    if (mrb_ptr(ptr[i]) == mrb_ptr(obj)) {
-      ARY_SET_LEN(a, len);
-      memmove(&ptr[i], &ptr[i + 1], (len - i) * sizeof(mrb_value));
-      break;
+  mrb_int w = 0;
+  for (mrb_int r = 0; r < len; r++) {
+    if (mrb_ptr(ptr[r]) != mrb_ptr(obj)) {
+      ptr[w++] = ptr[r];
     }
   }
+  ARY_SET_LEN(a, w);
 }
 
 MRB_API struct RBasic*

src/hash.c

@@ -13,7 +13,6 @@
 #include <mruby/variable.h>
 #include <mruby/proc.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 
 /*

src/kernel.c

@@ -14,7 +14,6 @@
 #include <mruby/error.h>
 #include <mruby/istruct.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 /*
  * Checks if the method `mid` for object `obj` is implemented by

src/numeric.c

@@ -10,7 +10,6 @@
 #include <mruby/string.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include <string.h>
 
 #ifndef MRB_NO_FLOAT

src/numops.c

@@ -7,7 +7,6 @@
 #include <mruby.h>
 #include <mruby/numeric.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 MRB_API mrb_value
 mrb_num_add(mrb_state *mrb, mrb_value x, mrb_value y)

src/object.c

@@ -10,7 +10,6 @@
 #include <mruby/string.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 
 /*
  * Checks if two mruby values, `v1` and `v2`, are identical.