Update version to 4.0.0RC2.

Merge branch 'master' into stable
Merge pull request #6736 from jbampton/add-dependabot-pre-commit
2026-06-08 16:11:16 +00:00 · 2026-03-12 19:07:19 +09:00 · 2026-03-12 19:01:29 +09:00 · 2026-03-12 17:16:48 +09:00 · 2026-03-12 16:59:11 +10:00 · 2026-03-12 14:36:46 +09:00
94 changed files with 456 additions and 502 deletions
@@ -5,11 +5,27 @@ updates:
    directory: "/"
    schedule:
      interval: "daily"
+    groups:
+      bundler-dependencies:
+        patterns:
+          - "*"
    cooldown:
      default-days: 7
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "daily"
+    groups:
+      github-actions-dependencies:
+        patterns:
+          - "*"
    cooldown:
      default-days: 7
+  - package-ecosystem: "pre-commit"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    groups:
+      pre-commit-hooks:
+        patterns:
+          - "*"
@@ -1,26 +0,0 @@
-{
-  "retryOn429": true,
-  "retryCount": 3,
-  "aliveStatusCodes": [
-    200,
-    206,
-    502
-  ],
-  "ignorePatterns": [
-    {
-      "pattern": "^https://github.com/mruby/mruby/commit/"
-    },
-    {
-      "pattern": "^http://jp.rubyist.net/magazine/\\?0034-Enumerable_lz"
-    },
-    {
-      "pattern": "^https://ruby-doc.org/core-2.3.3"
-    },
-    {
-      "pattern": "^mailto:"
-    },
-    {
-      "pattern": "^https://www.iso.org/"
-    }
-  ]
-}
@@ -34,7 +34,7 @@ jobs:
            echo \`\`\`
          } > "$GITHUB_STEP_SUMMARY"
      - name: Upload coverage report
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
        with:
          name: coverage-${{ github.sha }}
          path: coverage/
@@ -20,7 +20,7 @@ jobs:
          fuzz-seconds: 600
          dry-run: false
      - name: Upload Crash
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: artifacts
@@ -0,0 +1,20 @@
+# 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
+      - uses: j178/prek-action@v1
+        with:
+          install-only: true
+      - name: Run manual pre-commit hooks
+        run: prek run --color=always --all-files --hook-stage manual
@@ -16,5 +16,3 @@ jobs:
      - 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,10 +20,11 @@ repos:
      - id: prettier
        name: run prettier
        description: format files with prettier
-        entry: prettier --write '**/*.json' '**/*.md' '**/*.yaml' '**/*.yml'
-        files: \.(json|md|ya?ml)$
+        entry: prettier --write '**/*.md' '**/*.yaml' '**/*.yml'
+        files: \.(md|ya?ml)$
        language: node
        additional_dependencies: ["prettier@3.7.4"]
+        pass_filenames: false
        stages: [manual]
      - id: check-zip-file-is-not-committed
        name: disallow zip files
@@ -55,9 +56,6 @@ repos:
      - id: check-executables-have-shebangs
        exclude: ^test/t/lang\.rb$
      - id: check-illegal-windows-names
-      - id: pretty-format-json
-        args: [--autofix, --no-sort-keys]
-      - id: check-json
      - id: check-merge-conflict
      - id: check-shebang-scripts-are-executable
      - id: check-vcs-permalinks
@@ -107,16 +105,6 @@ repos:
        args: [--config=.github/linters/.markdown-lint.yml]
        types: [markdown]
        files: \.md$
-  - repo: https://github.com/tcort/markdown-link-check
-    rev: v3.14.2
-    hooks:
-      - id: markdown-link-check
-        name: run markdown-link-check
-        description: checks hyperlinks in Markdown files
-        args: [--config=.github/linters/mlc_config.json, -q]
-        stages: [manual]
-        types: [markdown]
-        files: \.md$
  - repo: https://github.com/rubocop/rubocop
    rev: v1.81.7
    hooks:
@@ -3,3 +3,4 @@ build
 coverage
 doc/internal/opcode.md
 tools/lrama
+.venv
@@ -51,7 +51,7 @@ 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 release candidate version 4.0.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/4.0.0-rc2.zip](https://github.com/mruby/mruby/archive/4.0.0-rc2.zip)

 The latest development version of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/zipball/master](https://github.com/mruby/mruby/zipball/master)

@@ -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.
@@ -79,7 +79,6 @@ Include `<mruby/class.h>` (which provides `mrb_mt_entry`,

 ```c
 #include <mruby/class.h>
-#include <mruby/presym.h>

 static const mrb_mt_entry my_rom_entries[] = {
  MRB_MT_ENTRY(my_method_a,  MRB_SYM(method_a), MRB_ARGS_REQ(1)),
@@ -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,11 +15,6 @@
 */
 #include <mruby/internal.h>

-/*
- * The "mruby/presym.h" file is placed at the end of the mruby header file.
- */
-#include <mruby/presym.h>
-
 /*
 * Define your own struct RBigint.
 *
@@ -1015,7 +1015,7 @@ typedef const char *mrb_args_format;
 *      mrb_value str, kw_rest;
 *      uint32_t kw_num = 3;
 *      uint32_t kw_required = 1;
- *      // Note that `#include <mruby/presym.h>` is required beforehand because `MRB_SYM()` is used.
+ *      // `MRB_SYM()` is available via `mruby.h` (which includes `mruby/presym.h`).
 *      // If the usage of `MRB_SYM()` is not desired, replace it with `mrb_intern_lit()`.
 *      mrb_sym kw_names[] = { MRB_SYM(x), MRB_SYM(y), MRB_SYM(z) };
 *      mrb_value kw_values[kw_num];
@@ -1594,6 +1594,8 @@ MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...);

 #ifdef MRB_PRESYM_SCANNING
 # include <mruby/presym/scanning.h>
+#else
+# include <mruby/presym.h>
 #endif

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

 #ifndef MRUBY_PATCHLEVEL_STR
 # if MRUBY_PATCHLEVEL < 0
@@ -90,7 +90,7 @@ MRB_BEGIN_DECL
 /*
 * Release day.
 */
-#define MRUBY_RELEASE_DAY 5
+#define MRUBY_RELEASE_DAY 12

 /*
 * Release date as a string.
@@ -109,7 +109,8 @@ module MRuby
        if build.kind_of?(MRuby::CrossBuild)
          return %w(x86_64-w64-mingw32 i686-w64-mingw32).include?(build.host_target)
        elsif build.kind_of?(MRuby::Build)
-          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") }
+          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") } ||
+                 ('a'..'z').to_a.any? { |vol| Dir.exist?("/#{vol}/") }
        end
        return false
      end
@@ -11,7 +11,6 @@
 #include <mruby/string.h>
 #include <mruby/class.h>
 #include <mruby/error.h>
-#include <mruby/presym.h>
 #include "socket_hal.h"

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

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

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

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

 #if defined(_WIN32)
 # include <io.h> /* for setmode */
@@ -4,7 +4,6 @@
 #include <mruby/hash.h>
 #include <mruby/proc.h>
 #include <mruby/variable.h>
-#include <mruby/presym.h>
 #include <mruby/opcode.h>
 #include <mruby/debug.h>
 #include <mruby/internal.h>
@@ -1,5 +1,4 @@
 #include <mruby.h>
-#include <mruby/presym.h>

 static mrb_value
 binding_in_c(mrb_state *mrb, mrb_value self)
@@ -4,7 +4,6 @@
 #include <mruby/error.h>
 #include <mruby/proc.h>
 #include <mruby/opcode.h>
-#include <mruby/presym.h>

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

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

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

 #ifdef MRB_NO_FLOAT
 # error CMath conflicts with 'MRB_NO_FLOAT' configuration
@@ -46,7 +46,6 @@
 #include <mruby/numeric.h>
 #include <mruby/string.h>
 #include <mruby/debug.h>
-#include <mruby/presym.h>
 #include "node.h"
 #include <mruby/opcode.h>
 #include <mruby/re.h>
@@ -3176,8 +3175,12 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
 {
  if (val) {
    int array_size = 0;
+    int first = 1;
+    int slimit = GEN_LIT_ARY_MAX;
    node *current = tree;

+    if (cursp() >= slimit) slimit = GEN_VAL_STACK_MAX;
+
    /* Process each segment separated by NODE_LITERAL_DELIM */
    while (current) {
      /* Find the segment boundaries without allocating */
@@ -3214,6 +3217,24 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)

        /* Only process non-empty segments */
        if (!is_empty_segment) {
+          /* Flush accumulated elements when stack is full */
+          if (cursp() >= slimit) {
+            if (array_size > 0) {
+              pop_n(array_size);
+              if (first) {
+                genop_2(s, OP_ARRAY, cursp(), array_size);
+                push();
+                first = 0;
+              }
+              else {
+                pop();
+                genop_2(s, OP_ARYPUSH, cursp(), array_size);
+                push();
+              }
+              array_size = 0;
+            }
+          }
+
          /* Temporarily terminate the segment by saving and clearing the cdr */
          node *saved_cdr = NULL;
          if (segment_prev) {
@@ -3244,8 +3265,14 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
      }
    }

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

  if (!val) return;

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

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

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

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

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

 #define YYLEX_PARAM p
@@ -85,7 +85,6 @@
 #include <mruby/string.h>
 #include <mruby/dump.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include "node.h"

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

 #ifdef MRB_NO_FLOAT
@@ -13,7 +13,6 @@
 #include <mruby/hash.h>
 #include <mruby/proc.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

 #define RDATA_LEN(st) RARRAY_LEN(st)
 #define RDATA_PTR(st) RARRAY_PTR(st)
@@ -10,7 +10,6 @@
 #include <mruby/data.h>
 #include <mruby/error.h>
 #include <mruby/string.h>
-#include <mruby/presym.h>
 #include "dir_hal.h"

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

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

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

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

 #ifndef EXIT_SUCCESS
 # define EXIT_SUCCESS 0
@@ -6,7 +6,6 @@
 #include <mruby/numeric.h>
 #include <mruby/proc.h>
 #include <mruby/string.h>
-#include <mruby/presym.h>

 #define fiber_ptr(o) ((struct RFiber*)mrb_ptr(o))

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

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

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

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

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

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

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

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

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

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

 #ifndef MRB_NO_FLOAT
 static mrb_value flo_remainder(mrb_state *mrb, mrb_value self);
@@ -4,7 +4,6 @@
 #include <mruby/hash.h>
 #include <mruby/proc.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

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

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

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

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

 /*
 *  call-seq:
@@ -11,7 +11,6 @@
 #include <mruby/data.h>
 #include <mruby/array.h>
 #include <mruby/istruct.h>
-#include <mruby/presym.h>
 #include <mruby/range.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>
@@ -2,7 +2,6 @@
 #include <mruby/range.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

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

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

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

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

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

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

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

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

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

 /*
 *  call-seq:
@@ -12,7 +12,6 @@
 #include <mruby/gc.h>
 #include <mruby/hash.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include <mruby/proc.h>
 #include <mruby/string.h>
 #include <mruby/variable.h>
@@ -11,7 +11,6 @@
 #include <mruby/time.h>
 #include <mruby/string.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

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

 #define ARY_DEFAULT_LEN   4
@@ -15,7 +15,6 @@
 #include <mruby/numeric.h>
 #include <mruby/data.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

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

 /* mrb_mt_tbl, union mrb_mt_ptr, mrb_mt_entry defined in internal.h */
 #define MT_PROTECTED MRB_METHOD_PROTECTED_FL
@@ -6,7 +6,6 @@

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

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

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

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


 /*
@@ -14,7 +14,6 @@
 #include <mruby/error.h>
 #include <mruby/istruct.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

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

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

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

 /*
 * Checks if two mruby values, `v1` and `v2`, are identical.
@@ -8,7 +8,6 @@
 #include <mruby/string.h>
 #include <mruby/variable.h>
 #include <mruby/error.h>
-#include <mruby/presym.h>
 #include <string.h>
 #if defined(_WIN32)
 # include <windows.h>
@@ -12,7 +12,6 @@
 #include <mruby/array.h>
 #include <mruby/hash.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

 static const mrb_code call_iseq[] = {
  OP_CALL,
@@ -11,7 +11,6 @@
 #include <mruby/array.h>
 #include <mruby/numeric.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

 #define RANGE_INITIALIZED_FLAG 1
 #define RANGE_INITIALIZED(p) ((p)->flags |= RANGE_INITIALIZED_FLAG)
@@ -16,7 +16,6 @@
 #include <mruby/string.h>
 #include <mruby/numeric.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>
 #include <string.h>

 typedef struct mrb_shared_string {
@@ -10,7 +10,6 @@
 #include <mruby/dump.h>
 #include <mruby/class.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

 #ifndef MRB_PRESYM_SCANNING
 /* const uint16_t presym_length_table[]   */
@@ -11,7 +11,6 @@
 #include <mruby/string.h>
 #include <mruby/variable.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

 /* Instance variable table structure */
 typedef struct iv_tbl {
@@ -20,7 +20,6 @@
 #include <mruby/throw.h>
 #include <mruby/dump.h>
 #include <mruby/internal.h>
-#include <mruby/presym.h>

 #ifdef MRB_NO_STDIO
 #if defined(__cplusplus)
@@ -708,7 +707,9 @@ prepare_missing(mrb_state *mrb, mrb_callinfo *ci, mrb_value recv, mrb_sym mid, m
  }
  else {
    mrb_assert(ci->nk == 15);
-    argv[1] = argv[ci->n];
+    if (ci->n != CALL_MAXARGS) {
+      argv[1] = argv[ci->n];    /* keyword arguments */
+    }
    argv[2] = blk;
  }
  argv[0] = args;               /* must be replaced after saving argv[0] as it may be a keyword argument */
@@ -7,8 +7,6 @@ all_prerequisites = ->(task_name, prereqs) do
 end

 MRuby.each_target do |build|
-  gensym_task = task(:gensym)
-
  presym = build.presym

  include_dir = "#{build.build_dir}/include"
@@ -34,12 +32,12 @@ MRuby.each_target do |build|
  file presym.list_path => ppps do
    presyms = presym.scan(ppps)
    current_presyms = presym.read_list if File.exist?(presym.list_path)
-    update = presyms != current_presyms
-    presym.write_list(presyms) if update
-    mkdir_p presym.header_dir
-    %w[id table].each do |type|
-      next if !update && File.exist?(presym.send("#{type}_header_path"))
-      presym.send("write_#{type}_header", presyms)
+    if presyms != current_presyms
+      mkdir_p presym.header_dir
+      %w[id table].each do |type|
+        presym.send("write_#{type}_header", presyms)
+      end
+      presym.write_list(presyms)
    end
  end

@@ -55,5 +53,5 @@ MRuby.each_target do |build|
    file prereq => presym.list_path
  end

-  gensym_task.enhance([presym.list_path])
+  task gensym: presym.list_path
 end
@@ -1246,12 +1246,13 @@ assert('pattern matching - NoMatchingPatternError') do
    assert_true e.message.is_a?(String)
  end

-  # case/in without else returns nil (no match)
-  result = case 5
-  in 1 then :one
-  in 2 then :two
+  # case/in without else raises NoMatchingPatternError
+  assert_raise(NoMatchingPatternError) do
+    case 5
+    in 1 then :one
+    in 2 then :two
+    end
  end
-  assert_nil result
 end

 assert('pattern matching - complex patterns') do
Author	SHA1	Message	Date
mimaki	9d523e2f74	Update version to 4.0.0RC2.	2026-03-12 19:07:19 +09:00
mimaki	380c459d37	Merge branch 'master' into stable	2026-03-12 19:01:29 +09:00
Yukihiro "Matz" Matsumoto	eb7d0b86d7	Merge pull request #6736 from jbampton/add-dependabot-pre-commit	2026-03-12 17:16:48 +09:00
John Bampton	9bdf998faa	Add pre-commit ecosystem to Dependabot Group dependabot updates to reduce repo noise Add descriptive group labels https://github.blog/changelog/2026-03-10-dependabot-now-supports-pre-commit-hooks/ https://docs.github.com/en/code-security/reference/supply-chain-security/dependabot-options-reference#package-ecosystem-	2026-03-12 16:59:11 +10:00
Yukihiro "Matz" Matsumoto	457a50b485	Merge pull request #6744 from mruby/fix/case-in-no-match-error	2026-03-12 14:36:46 +09:00
Yukihiro "Matz" Matsumoto	143959b94b	doc: fix prettier formatting in markdown files Co-authored-by: Claude <noreply@anthropic.com>	2026-03-12 14:33:37 +09:00
Yukihiro "Matz" Matsumoto	d8de35b635	codegen.c: raise NoMatchingPatternError in case/in without else case/in without else clause now raises NoMatchingPatternError when no pattern matches, matching CRuby behavior. Fixes #6741. Co-authored-by: Claude <noreply@anthropic.com>	2026-03-12 14:28:17 +09:00
Yukihiro "Matz" Matsumoto	b34b7206f9	Merge pull request #6738 from jbampton/add-manual-hooks-workflow	2026-03-12 14:20:02 +09:00
Yukihiro "Matz" Matsumoto	03d1f7d6ec	Merge pull request #6743 from mruby/fix/words-chunking	2026-03-12 14:17:38 +09:00
Yukihiro "Matz" Matsumoto	9239a9e0ef	pre-commit: fix prettier formatting in doc/guides/capi.md Co-authored-by: Claude <noreply@anthropic.com>	2026-03-12 14:05:48 +09:00
Yukihiro "Matz" Matsumoto	62cf0dc17a	codegen.c: chunk %w() and %i() literals to reduce register pressure Apply the same chunking strategy used for regular array literals to %w() and %i() literal arrays in gen_literal_array(). Fixes #6740. Co-authored-by: Claude <noreply@anthropic.com>	2026-03-12 12:12:50 +09:00
Yukihiro "Matz" Matsumoto	12af8f513e	Merge pull request #6742 from mruby/fix/remove-markdown-link-check	2026-03-12 11:52:45 +09:00
Yukihiro "Matz" Matsumoto	6a7561da5f	pre-commit: remove JSON references from prettier hook Co-authored-by: Claude <noreply@anthropic.com>	2026-03-12 11:41:17 +09:00
Yukihiro "Matz" Matsumoto	ab378ec01e	Merge pull request #6690 from jbampton/cleanup-prettier-pre-commit	2026-03-12 11:37:25 +09:00
Yukihiro "Matz" Matsumoto	2d00f4a284	Merge pull request #6739 from mimaki/fix-msys2-build-error	2026-03-12 11:36:53 +09:00
Yukihiro "Matz" Matsumoto	628cf498a7	pre-commit: remove markdown-link-check hook External link checkers are inherently flaky in CI due to websites blocking automated requests (e.g. 403 errors). Also remove JSON hooks (pretty-format-json, check-json) since no JSON files remain in the repository. Co-authored-by: Claude <noreply@anthropic.com>	2026-03-12 11:32:37 +09:00
mimaki	77f6ffecc7	Updates build script to support MSYS2 drive letters, fixing build error with MSYS2.	2026-03-11 11:31:55 +09:00
John Bampton	626b2fa469	Put manual hooks in separate workflow file	2026-03-11 10:29:57 +10:00
Yukihiro "Matz" Matsumoto	cfc83bb6ac	Merge pull request #6734 from mruby/fix/array-chunking	2026-03-10 17:01:28 +09:00
Yukihiro "Matz" Matsumoto	46e8101c03	Merge pull request #6733 from mruby/fix/presym-include	2026-03-10 16:59:51 +09:00
Yukihiro "Matz" Matsumoto	fff7db05bf	Merge pull request #6732 from mruby/fix/language-md-markup	2026-03-10 16:58:34 +09:00
Yukihiro "Matz" Matsumoto	f98d6414dc	codegen.c: chunk array literals at 64 elements to reduce register pressure Array literals were being built by loading all elements into registers before constructing the array, requiring nregs proportional to the array size (e.g. nregs=99 for 100 elements). This exceeds mruby/c's register limit. Restore 3.4-era chunking at GEN_LIT_ARY_MAX (64) elements. fixes mruby/mruby#6731 Co-authored-by: Claude <noreply@anthropic.com>	2026-03-09 16:50:59 +09:00
Yukihiro "Matz" Matsumoto	8956c5abb5	mruby.h: include mruby/presym.h for all source files Since presym is now mandatory, mruby.h includes presym.h so that MRB_SYM() macros are available everywhere without explicit include. Remove redundant #include <mruby/presym.h> from all source files. Co-authored-by: Claude <noreply@anthropic.com>	2026-03-09 16:50:58 +09:00
Yukihiro "Matz" Matsumoto	8f3917f361	language.md: remove unnecessary bold markup from "operator" Co-authored-by: Claude <noreply@anthropic.com>	2026-03-09 16:50:54 +09:00
Yukihiro "Matz" Matsumoto	72c9e5d027	Merge pull request #6598 from dearblue/method_missing	2026-03-09 16:38:08 +09:00
Yukihiro "Matz" Matsumoto	295b40534f	Merge pull request #6730 from dearblue/presym	2026-03-09 10:35:42 +09:00
Yukihiro "Matz" Matsumoto	5acc520a1e	Merge pull request #6729 from dearblue/gensym	2026-03-09 10:34:02 +09:00
dearblue	f6f1a42039	Simplifying presym file generation actions By performing output to presym files after header files, there is no longer a need to check for the existence of header files. Furthermore, concentrating the file output logic into an "if" block eliminates the need for the `update` variable. Strict atomicity between presym files and header files is still not guaranteed, as before. If atomicity is truly required, it can be achieved by deleting the presym file before updating the header files.	2026-03-08 22:45:45 +09:00
dearblue	9fff63b436	Simplifying dependency addition for gensym task The `gensym_task` variable was only used for dependency addition and is no longer needed.	2026-03-08 22:43:47 +09:00
Yukihiro "Matz" Matsumoto	17ab42d4c9	Merge pull request #6728 from mruby/dependabot/github_actions/actions/upload-artifact-7	2026-03-06 08:17:12 +09:00
dependabot[bot]	fcb665b88c	build(deps): bump actions/upload-artifact from 6 to 7 Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 6 to 7. - [Release notes](https://github.com/actions/upload-artifact/releases) - [Commits](https://github.com/actions/upload-artifact/compare/v6...v7) --- updated-dependencies: - dependency-name: actions/upload-artifact dependency-version: '7' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2026-03-05 14:52:19 +00:00
John Bampton	3c7d19d41b	prettier: set `pass_filenames: false` to avoid multiple passes Updated `.prettierignore` to ingnore the typical Python environment files from `.venv` If you are running pre-commit locally you probably have a Python environment setup. This PR speeds up the prettier hook and avoids multiple passes through the targetted files.	2025-12-30 01:53:03 +10:00
dearblue	550d10adb7	Fixed heap buffer overflow in `#method_missing` When `ci->n == CALL_MAXARGS`, the correct value is `argv[1] = argv[1]`. However, it was always `args[1] = args[ci->n]`, which caused objects outside the range to be picked up. fixed #6584	2025-07-30 21:35:55 +09:00