Update version to 4.0.0RC.

Merge remote-tracking branch 'origin' into stable
Merge pull request #6627 from suetanvil/stable-3.4.0-plus-fixes
2026-06-08 16:11:16 +00:00 · 2026-03-05 11:58:41 +09:00 · 2026-03-05 11:14:03 +09:00 · 2025-09-23 07:54:35 +01:00 · 2025-09-18 12:39:05 -04:00
112 changed files with 3252 additions and 3428 deletions
@@ -5,27 +5,11 @@ 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:
-          - "*"
@@ -0,0 +1,26 @@
+{
+  "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/"
+    }
+  ]
+}
@@ -32,8 +32,6 @@ 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
@@ -47,8 +45,6 @@ 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
@@ -75,8 +71,6 @@ 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
@@ -19,8 +19,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Initialize CodeQL
        uses: github/codeql-action/init@v4
        with:
@@ -2,9 +2,6 @@ name: Coverage

 on: [push]

-permissions:
-  contents: read
-
 jobs:
  coverage:
    name: Coverage
@@ -20,8 +17,6 @@ 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
@@ -39,7 +34,7 @@ jobs:
            echo \`\`\`
          } > "$GITHUB_STEP_SUMMARY"
      - name: Upload coverage report
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
        with:
          name: coverage-${{ github.sha }}
          path: coverage/
@@ -12,8 +12,6 @@ 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
@@ -20,7 +20,7 @@ jobs:
          fuzz-seconds: 600
          dry-run: false
      - name: Upload Crash
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
        if: failure()
        with:
          name: artifacts
@@ -1,22 +0,0 @@
-# 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
@@ -13,8 +13,8 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-      - uses: j178/prek-action@v2
+      - uses: j178/prek-action@v1
        with:
          extra-args: --all-files
+      - name: Run manual pre-commit hooks
+        run: prek run --color=always --all-files --hook-stage manual
@@ -20,8 +20,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref_name }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Builds
        id: builds
        run: |
@@ -19,7 +19,6 @@ 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:
@@ -3,7 +3,7 @@
 default_stages: [pre-commit, pre-push]
 default_language_version:
  python: python3
-  node: 24.14.0
+  node: 24.11.1
 minimum_pre_commit_version: "3.2.0"
 exclude: "^tools/lrama/"
 repos:
@@ -20,11 +20,10 @@ repos:
      - id: prettier
        name: run prettier
        description: format files with prettier
-        entry: prettier --write '**/*.md' '**/*.yaml' '**/*.yml'
-        files: \.(md|ya?ml)$
+        entry: prettier --write '**/*.json' '**/*.md' '**/*.yaml' '**/*.yml'
+        files: \.(json|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
@@ -35,13 +34,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.1
+    rev: v8.30.0
    hooks:
      - id: gitleaks
        name: run gitleaks
        description: detect hardcoded secrets with gitleaks
  - repo: https://github.com/oxipng/oxipng
-    rev: v10.1.0
+    rev: v10.0.0
    hooks:
      - id: oxipng
        name: run oxipng
@@ -56,6 +55,9 @@ 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
@@ -73,7 +75,7 @@ repos:
      - id: mixed-line-ending
      - id: trailing-whitespace
  - repo: https://github.com/Lucas-C/pre-commit-hooks
-    rev: v1.5.6
+    rev: v1.5.5
    hooks:
      - id: forbid-tabs
        name: run no-tabs checker
@@ -85,19 +87,19 @@ repos:
        args: [--whitespaces-count, "2"]
        exclude: Makefile$
  - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.11
+    rev: v1.7.9
    hooks:
      - id: actionlint
        name: run actionlint
        description: lint GitHub Actions workflow files
  - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.2
+    rev: v2.4.1
    hooks:
      - id: codespell
        name: run codespell
        description: check spelling with codespell
  - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.48.0
+    rev: v0.46.0
    hooks:
      - id: markdownlint
        name: run markdownlint
@@ -105,8 +107,18 @@ 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.86.0
+    rev: v1.81.7
    hooks:
      - id: rubocop
        name: run rubocop
@@ -120,7 +132,7 @@ repos:
        name: run shellcheck
        description: check shell scripts with a static analysis tool
  - repo: https://github.com/adrienverge/yamllint
-    rev: v1.38.0
+    rev: v1.37.1
    hooks:
      - id: yamllint
        name: run yamllint
@@ -3,4 +3,3 @@ build
 coverage
 doc/internal/opcode.md
 tools/lrama
-.venv
@@ -23,8 +23,6 @@ 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

@@ -39,8 +37,6 @@ 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

@@ -80,7 +76,6 @@ 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
@@ -115,7 +110,6 @@ 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))
@@ -131,8 +125,6 @@ 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

@@ -193,10 +185,6 @@ 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

@@ -272,7 +260,6 @@ 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
@@ -316,30 +303,6 @@ 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

@@ -357,6 +320,4 @@ 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
@@ -51,6 +51,8 @@ To get mruby, you can download the stable version 4.0.0 from the official mruby
 GitHub repository or clone the trunk of the mruby source tree with the "git
 clone" command. You can also install and compile mruby using [ruby-install](https://github.com/postmodern/ruby-install), [ruby-build](https://github.com/rbenv/ruby-build), [rvm](https://github.com/rvm/rvm), [conda](https://anaconda.org/channels/conda-forge/packages/mruby/overview) or [Homebrew](https://formulae.brew.sh/formula/mruby).

+The release candidate version 4.0.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/4.0.0-rc.zip](https://github.com/mruby/mruby/archive/4.0.0-rc.zip)
+
 The latest development version of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/zipball/master](https://github.com/mruby/mruby/zipball/master)

 The trunk of the mruby source tree can be checked out with the
@@ -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_INITIAL_SIZE=8)
+    cc.defines << %w(KHASH_DEFAULT_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
@@ -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_INITIAL_SIZE=8)
+    cc.defines << %w(KHASH_DEFAULT_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
@@ -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_INITIAL_SIZE=8)
+    cc.defines << %w(KHASH_DEFAULT_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
@@ -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

@@ -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.
@@ -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.
@@ -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.
@@ -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_INITIAL_SIZE`
+`KHASH_DEFAULT_SIZE`

 - Default value is `32`.
- Specifies initial size of khash table bucket.
+- Specifies default 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_INITIAL_SIZE` to `16`,
+- Enables `MRB_NO_METHOD_CACHE`, reduces `KHASH_DEFAULT_SIZE` to `16`,
  and `MRB_HEAP_PAGE_SIZE` to `256`.

 `MRB_BASELINE_PROFILE`
@@ -79,6 +79,7 @@ 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)),
@@ -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

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

@@ -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 |
@@ -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 |
@@ -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 |
@@ -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
@@ -15,6 +15,11 @@
 */
 #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.
 *
@@ -138,8 +138,8 @@
 /* turn off generational GC by default */
 //#define MRB_GC_TURN_OFF_GENERATIONAL

-/* initial size of khash table bucket */
-//#define KHASH_INITIAL_SIZE 32
+/* default size of khash table bucket */
+//#define KHASH_DEFAULT_SIZE 32

 /* allocated memory address alignment */
 //#define POOL_ALIGNMENT 4
@@ -208,8 +208,8 @@
 #  define MRB_NO_METHOD_CACHE
 # endif

-# ifndef KHASH_INITIAL_SIZE
-#  define KHASH_INITIAL_SIZE 16
+# ifndef KHASH_DEFAULT_SIZE
+#  define KHASH_DEFAULT_SIZE 16
 # endif

 # ifndef MRB_HEAP_PAGE_SIZE
@@ -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;
- *      // `MRB_SYM()` is available via `mruby.h` (which includes `mruby/presym.h`).
+ *      // Note that `#include <mruby/presym.h>` is required beforehand because `MRB_SYM()` is used.
 *      // 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,8 +1594,6 @@ 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
@@ -21,7 +21,7 @@ typedef uint32_t khint_t;
 typedef khint_t khiter_t;

 #ifndef KHASH_INITIAL_SIZE
-# define KHASH_INITIAL_SIZE 32
+# define KHASH_INITIAL_SIZE 8
 #endif
 #define KHASH_MIN_SIZE 8
 #define KHASH_SMALL_LIMIT 4
@@ -316,11 +316,7 @@ 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

 /**
@@ -57,7 +57,7 @@ MRB_BEGIN_DECL
 /*
 * Patch level string. (optional)
 */
-#define MRUBY_PATCHLEVEL_STR ""
+#define MRUBY_PATCHLEVEL_STR "RC"

 #ifndef MRUBY_PATCHLEVEL_STR
 # if MRUBY_PATCHLEVEL < 0
@@ -80,17 +80,17 @@ MRB_BEGIN_DECL
 /*
 * Release year.
 */
-#define MRUBY_RELEASE_YEAR 2025
+#define MRUBY_RELEASE_YEAR 2026

 /*
 * Release month.
 */
-#define MRUBY_RELEASE_MONTH 4
+#define MRUBY_RELEASE_MONTH 3

 /*
 * Release day.
 */
-#define MRUBY_RELEASE_DAY 20
+#define MRUBY_RELEASE_DAY 5

 /*
 * Release date as a string.
@@ -109,8 +109,7 @@ 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}:") } ||
-                 ('a'..'z').to_a.any? { |vol| Dir.exist?("/#{vol}/") }
+          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") }
        end
        return false
      end
@@ -11,6 +11,7 @@
 #include <mruby/string.h>
 #include <mruby/class.h>
 #include <mruby/error.h>
+#include <mruby/presym.h>
 #include "socket_hal.h"

 #include <sys/types.h>
@@ -15,6 +15,7 @@
 #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>
@@ -611,15 +611,37 @@ class Array
  #   ary.product(*arys)                  ->   array
  #   ary.product(*arys) { |item| ... }   ->   self
  def product(*arys, &block)
-    gen = __product_generate(arys, &block)
-    return gen unless block
-
-    if gen
-      while group = __product_next(arys, gen)
-        yield group
+    size = arys.size
+    i = size
+    while i > 0
+      i -= 1
+      unless arys[i].kind_of?(Array)
+        raise TypeError, "no implicit conversion into Array"
      end
    end
-    self
+
+    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
  end

  ##
@@ -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,14 +79,11 @@ 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();
 }
@@ -110,15 +107,12 @@ 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();
 }
@@ -416,12 +410,9 @@ 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)
 {
-  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);
+  mrb_int len = RARRAY_LEN(ary);
+  for (mrb_int i = 0; i < len; i++) {
+    kh_put(ary_set, mrb, set, RARRAY_PTR(ary)[i]);
  }
 }

@@ -470,15 +461,12 @@ 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;
@@ -512,13 +500,13 @@ ary_subtract_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_va
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
+    mrb_int self_len = RARRAY_LEN(self);
+    for (mrb_int i = 0; i < self_len; 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++) {
-        for (mrb_int k = 0; k < RARRAY_LEN(argv[j]); k++) {
+        mrb_int len = RARRAY_LEN(argv[j]);
+        for (mrb_int k = 0; k < len; k++) {
          if (mrb_equal(mrb, p, RARRAY_PTR(argv[j])[k])) {
            found = TRUE;
            break;
@@ -529,7 +517,6 @@ 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);
    }
  }

@@ -573,10 +560,12 @@ 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)
 {
-  for (mrb_int i = 0; i < RARRAY_LEN(result); i++) {
+  const mrb_int len = RARRAY_LEN(result);
+  for (mrb_int i = 0; i < len; i++) {
    if (mrb_eql(mrb, item, RARRAY_PTR(result)[i])) {
      return;
    }
@@ -596,18 +585,15 @@ 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 */
@@ -615,13 +601,11 @@ 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);
    }
  }

@@ -653,25 +637,19 @@ 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 */
-    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);
+    mrb_int alen = RARRAY_LEN(self);
+    for (mrb_int i = 0; i < alen; i++) {
+      add_uniq(mrb, RARRAY_PTR(self)[i], result);
    }

    /* Add unique elements from others */
    for (mrb_int i = 0; i < argc; i++) {
      mrb_value other = argv[i];
-      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);
+      mrb_int olen = RARRAY_LEN(other);
+      for (mrb_int j = 0; j < olen; j++) {
+        add_uniq(mrb, RARRAY_PTR(other)[j], result);
      }
    }
  }
@@ -734,16 +712,13 @@ 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;
@@ -777,15 +752,15 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
+    mrb_int self_len = RARRAY_LEN(self);
+    for (mrb_int i = 0; i < self_len; 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;
-        for (mrb_int k = 0; k < RARRAY_LEN(argv[j]); k++) {
+        mrb_int len = RARRAY_LEN(argv[j]);
+        for (mrb_int k = 0; k < len; k++) {
          if (mrb_equal(mrb, p, RARRAY_PTR(argv[j])[k])) {
            found_in_current_other = TRUE;
            break;
@@ -799,7 +774,8 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr

      if (found_in_all) {
        mrb_bool already_added = FALSE;
-        for (mrb_int j = 0; j < RARRAY_LEN(result); j++) {
+        mrb_int result_len = RARRAY_LEN(result);
+        for (mrb_int j = 0; j < result_len; j++) {
          if (mrb_equal(mrb, p, RARRAY_PTR(result)[j])) {
            already_added = TRUE;
            break;
@@ -809,7 +785,6 @@ 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;
@@ -880,12 +855,8 @@ 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++) {
-    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);
+    khiter_t k = kh_get(ary_set, mrb, ctx->set, RARRAY_PTR(ctx->longer_ary)[i]);
    if (!kh_is_end(ctx->set, k)) {
      *ctx->found = TRUE;
      break;
@@ -935,16 +906,12 @@ 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, p, RARRAY_PTR(shorter_ary)[j])) {
+        if (mrb_equal(mrb, RARRAY_PTR(longer_ary)[i], RARRAY_PTR(shorter_ary)[j])) {
          return mrb_true_value();
        }
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -1075,7 +1042,6 @@ 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;
@@ -1093,6 +1059,7 @@ struct ary_uniq_bang_ctx {
  mrb_value self_copy;
  mrb_value self;
  mrb_int *write_pos;
+  mrb_int len;
 };

 static mrb_value
@@ -1102,19 +1069,15 @@ ary_uniq_bang_body(mrb_state *mrb, void *data)

  ary_populate_temp_set(mrb, ctx->set, ctx->self_copy);

-  int ai = mrb_gc_arena_save(mrb);
-  for (mrb_int read_pos = 0; read_pos < RARRAY_LEN(ctx->self); read_pos++) {
+  for (mrb_int read_pos = 0; read_pos < ctx->len; 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 && *ctx->write_pos < RARRAY_LEN(ctx->self)) {
-        mrb_ary_modify(mrb, mrb_ary_ptr(ctx->self));
+      if (*ctx->write_pos != read_pos) {
        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);
    }
  }

@@ -1141,32 +1104,28 @@ 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 };
+    struct ary_uniq_bang_ctx ctx = { set, self_copy, self, &write_pos, len };
    mrb_value result;
    MRB_ENSURE(mrb, result, ary_uniq_bang_body, &ctx) {
      ary_destroy_temp_set(mrb, set);
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-    for (mrb_int read_pos = 0; read_pos < RARRAY_LEN(self); read_pos++) {
+    for (mrb_int read_pos = 0; read_pos < len; 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 < RARRAY_LEN(self); j++) {
+      for (mrb_int j = 0; j < write_pos; j++) {
        if (mrb_equal(mrb, elem, RARRAY_PTR(self)[j])) {
          found = TRUE;
          break;
        }
      }
      if (!found) {
-        if (write_pos != read_pos && write_pos < RARRAY_LEN(self)) {
-          mrb_ary_modify(mrb, mrb_ary_ptr(self));
+        if (write_pos != read_pos) {
          RARRAY_PTR(self)[write_pos] = elem;
        }
        write_pos++;
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -1415,13 +1374,6 @@ 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),
@@ -1429,85 +1381,29 @@ static struct mrb_data_type ary_product_generator_type = { "ary_product_generato
 *  of the group array (group_len).
 */
 static mrb_value
-ary_product_fetch(mrb_state *mrb, mrb_value self_ary, mrb_value arys_ary, mrb_int n)
+ary_product_group(mrb_state *mrb, mrb_value self_ary)
 {
-  mrb_int j = RARRAY_LEN(arys_ary); // Corresponds to 'size' in Ruby
-  mrb_value group = mrb_ary_new_capa(mrb, j + 1 /* self_ary */);
+  mrb_value arys_ary;
+  mrb_int current_i, group_len;
+  mrb_get_args(mrb, "Aii", &arys_ary, &current_i, &group_len);

-  while (j-- > 0) {
+  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;
+
+  while (j > 0) {
+    j -= 1;
    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
@@ -1668,8 +1564,7 @@ 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_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_product_group,      MRB_SYM(__product_group),    MRB_ARGS_REQ(3)),
  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)),
 };
@@ -12,6 +12,7 @@
 #include <mruby/numeric.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>
 #include "apiprint.h"

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

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

 #if defined(_WIN32)
 # include <io.h> /* for setmode */
@@ -4,6 +4,7 @@
 #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>
@@ -1,4 +1,5 @@
 #include <mruby.h>
+#include <mruby/presym.h>

 static mrb_value
 binding_in_c(mrb_state *mrb, mrb_value self)
@@ -4,6 +4,7 @@
 #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))
@@ -5,6 +5,7 @@
 #include <mruby/proc.h>
 #include <mruby/variable.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>

 /*
 * Get the name of a module/class.
@@ -10,6 +10,7 @@
 */

 #include <mruby.h>
+#include <mruby/presym.h>

 #ifdef MRB_NO_FLOAT
 # error CMath conflicts with 'MRB_NO_FLOAT' configuration
@@ -46,6 +46,7 @@
 #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>
@@ -3175,12 +3176,8 @@ 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 */
@@ -3217,24 +3214,6 @@ 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) {
@@ -3265,14 +3244,8 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
      }
    }

-    /* 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) {
+    /* Generate the array from pushed elements */
+    if (array_size > 0) {
      pop_n(array_size);
      genop_2(s, OP_ARRAY, cursp(), array_size);
    }
@@ -3848,7 +3821,7 @@ codegen_array(codegen_scope *s, node *varnode, int val)
  node *elements = array->elements;
  int regular_elements = 0;
  int first = 1;
-  int slimit = GEN_LIT_ARY_MAX;
+  int slimit = GEN_VAL_STACK_MAX;

  if (!val) return;

@@ -3858,7 +3831,7 @@ codegen_array(codegen_scope *s, node *varnode, int val)
    return;
  }

-  if (cursp() >= slimit) slimit = GEN_VAL_STACK_MAX;
+  if (cursp() >= GEN_LIT_ARY_MAX) slimit = INT16_MAX;

  /* Process each element using cons-list iteration, handling splats */
  node *current = elements;
@@ -4455,9 +4428,10 @@ codegen_case_match(codegen_scope *s, node *varnode, int val)
    current_in = current_in->cdr;
  }

-  /* No pattern matched - raise NoMatchingPatternError */
-  genop_1(s, OP_LOADFALSE, cursp());
-  genop_1(s, OP_MATCHERR, cursp());
+  /* No pattern matched - generate nil or error */
+  if (val) {
+    genop_1(s, OP_LOADNIL, cursp());
+  }

  /* Dispatch all end jumps */
  if (case_end_jumps != JMPLINK_START) {
@@ -23,6 +23,7 @@
 #include <mruby/string.h>
 #include <mruby/dump.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>
 #include "node.h"

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

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

 #ifdef MRB_NO_FLOAT
@@ -13,6 +13,7 @@
 #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)
@@ -10,6 +10,7 @@
 #include <mruby/data.h>
 #include <mruby/error.h>
 #include <mruby/string.h>
+#include <mruby/presym.h>
 #include "dir_hal.h"

 #include <string.h>
@@ -2,6 +2,7 @@
 #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"
@@ -291,12 +291,11 @@ class Enumerator
    #
    def flat_map(&block)
      Lazy.new(self){|yielder, val|
-        result = block.call(val)
-        if result.respond_to?(:each)
-          result.each {|x| yielder << x }
-        else
-          yielder << result
-        end
+        ary = block.call(val)
+        # TODO: check ary is an Array
+        ary.each {|x|
+          yielder << x
+        }
      }
    end
    alias collect_concat flat_map
@@ -46,18 +46,6 @@ 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
@@ -7,6 +7,7 @@
 #include <mruby/string.h>
 #include <mruby/variable.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>
 #include <errno.h>
 #include <string.h>

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

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

 #ifndef EXIT_SUCCESS
 # define EXIT_SUCCESS 0
@@ -6,6 +6,7 @@
 #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))

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

 /*
 * call-seq:
@@ -10,6 +10,7 @@
 #include <mruby/io.h>
 #include <mruby/error.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>
 #include "io_hal.h"

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

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

 #include <sys/types.h>
@@ -8,6 +8,7 @@
 #include <mruby/proc.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>

 /*
 * call-seq:
@@ -11,6 +11,7 @@
 #endif

 #include <mruby/array.h>
+#include <mruby/presym.h>

 static void
 domain_error(mrb_state *mrb, const char *func)
@@ -7,6 +7,7 @@
 #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)
@@ -5,6 +5,7 @@
 #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);
@@ -4,6 +4,7 @@
 #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);
@@ -190,7 +191,11 @@ 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) && !mrb_bigint_p(e)) {
+  if (!mrb_integer_p(e)
+#ifdef MRB_USE_BIGINT
+      && !mrb_bigint_p(e)
+#endif
+      ) {
    mrb_raise(mrb, E_TYPE_ERROR, "int.pow(n,m): 2nd argument not allowed unless 1st argument is an integer");
  }
 #ifdef MRB_USE_BIGINT
@@ -4,6 +4,7 @@
 #include <mruby/hash.h>
 #include <mruby/proc.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>

 /*
 *  call-seq:
@@ -10,6 +10,7 @@
 #include <mruby/proc.h>
 #include <mruby/value.h>
 #include <mruby/range.h>
+#include <mruby/presym.h>

 struct os_count_struct {
  mrb_int total;
@@ -11,6 +11,7 @@
 #include <mruby/variable.h>
 #include <mruby/endian.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>

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

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

 /*
 *  call-seq:
@@ -11,6 +11,7 @@
 #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>
@@ -2,6 +2,7 @@
 #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)
@@ -2,6 +2,7 @@
 #include <mruby/class.h>
 #include <mruby/numeric.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>

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

@@ -37,6 +37,7 @@
 #endif

 #include <mruby.h>
+#include <mruby/presym.h>

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

 #include <mruby/io.h>
 #include "socket_hal.h"
@@ -8,6 +8,7 @@
 #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>
@@ -8,6 +8,7 @@
 #include <mruby/string.h>
 #include <mruby/time.h>
 #include <mruby/class.h>
+#include <mruby/presym.h>
 #include <time.h>
 #include <string.h>

@@ -5,6 +5,7 @@
 #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"
@@ -14,6 +14,7 @@
 #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)
@@ -3,6 +3,7 @@
 #include <mruby/class.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>

 /*
 *  call-seq:
@@ -12,6 +12,7 @@
 #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>
@@ -19,11 +19,9 @@ 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)
-    tmpfile = t.name + ".tmp"
-    open(tmpfile, 'w') do |f|
+    open(t.name, '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
@@ -38,8 +36,7 @@ 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)
-      tmpfile = t.name + ".tmp"
-      open(tmpfile, 'w') do |f|
+      open(t.name, '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)
@@ -120,7 +117,6 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
        end
        f.puts %Q[}]
      end
-      File.rename(tmpfile, t.name)
    end
  end

@@ -138,8 +134,7 @@ 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)
-    tmpfile = clib + ".tmp"
-    open(tmpfile, 'w') do |f|
+    open(clib, 'w') do |f|
      f.puts %Q[/*]
      f.puts %Q[ * This file contains a list of all]
      f.puts %Q[ * test functions.]
@@ -174,6 +169,5 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
      end
      f.puts %Q[}]
    end
-    File.rename(tmpfile, clib)
  end
 end
@@ -11,6 +11,7 @@
 #include <mruby/time.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>

 #ifdef MRB_NO_STDIO
 #include <string.h>
@@ -11,6 +11,7 @@
 #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
@@ -15,6 +15,7 @@
 #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
@@ -456,6 +456,7 @@ 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;
  }
@@ -17,6 +17,7 @@
 #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
@@ -2748,7 +2749,7 @@ prepare_writer_name(mrb_state *mrb, mrb_sym sym)
 }

 static mrb_value
-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))
+mod_attr_define(mrb_state *mrb, mrb_value mod, 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;
@@ -2765,7 +2766,6 @@ mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_int aargc, mrb_value (*access
    }

    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, 0, attr_reader, NULL);
+  return mod_attr_define(mrb, mod, 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, 1, attr_writer, prepare_writer_name);
+  return mod_attr_define(mrb, mod, attr_writer, prepare_writer_name);
 }

 static mrb_value
@@ -6,6 +6,7 @@

 #include <mruby.h>
 #include <mruby/proc.h>
+#include <mruby/presym.h>

 /* internal method `__update_hash(oldhash, index, itemhash)` */
 static mrb_value
@@ -16,6 +16,7 @@
 #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)
@@ -22,6 +22,7 @@
 #include <mruby/error.h>
 #include <mruby/throw.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>

 #ifdef MRB_GC_STRESS
 #include <stdlib.h>
@@ -541,15 +542,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);
+  mrb_int len = ARY_LEN(a)-1;
  mrb_value *ptr = ARY_PTR(a);
-  mrb_int w = 0;
-  for (mrb_int r = 0; r < len; r++) {
-    if (mrb_ptr(ptr[r]) != mrb_ptr(obj)) {
-      ptr[w++] = ptr[r];
+  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;
    }
  }
-  ARY_SET_LEN(a, w);
 }

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


 /*
@@ -14,6 +14,7 @@
 #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
@@ -10,6 +10,7 @@
 #include <mruby/string.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
+#include <mruby/presym.h>
 #include <string.h>

 #ifndef MRB_NO_FLOAT
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
mimaki	1d34c3bed5	Update version to 4.0.0RC.	2026-03-05 11:58:41 +09:00
mimaki	18a1c33fd4	Merge remote-tracking branch 'origin' into stable	2026-03-05 11:14:03 +09:00
Yukihiro "Matz" Matsumoto	40436e4e3c	Merge pull request #6627 from suetanvil/stable-3.4.0-plus-fixes	2025-09-23 07:54:35 +01:00
Hendrik	651a183228	fix bigint on raspberry pi this fixes an issue where base can be out of range on a raspberry pi.	2025-09-18 12:39:05 -04:00