HASUMI Hitoshi
f1232334c0
This patch fixes a bug thatc09196cintroduced. ## Background `mrb_task_run()` has two usage patterns: 1. Called directly from `main()` as the top-level scheduler (PicoRuby and R2P2). There is no surrounding C exception handler, so mrb->jmp is NULL on entry 2. Called from Ruby code via Task.run, bootstrapped on top of mruby's regular call chain. mrb->jmp is non-NULL Historically, an unhandled exception raised inside a task body was turned into the task's result value by `mrb_vm_exec()`: the L_RAISE path walked callinfo down to cibase, ran `fiber_terminate()`, and - because c->vmexec was TRUE and prev_jmp was NULL in pattern 1 - took `return mrb_obj_value(mrb->exc)`. That value landed in t->result and could be read back through `mrb_task_value()` / `join()`. ## Whatc09196cbroke It consider only pattern 2 and wrapped `mrb_task_run()` in a protect frame (MRB_TRY / mrb_protect_error) to guarantee that loop_running is cleared on exception. As a side effect, mrb->jmp is now always non-NULL while a task body is executing, so the L_RAISE path takes `MRB_THROW(prev_jmp)` instead of returning the exception value. In pattern 2 this merely changed the semantics (exceptions started propagating out of `Task.run` instead of being stored as task results). In pattern 1 it was FATAL: the throw unwound to mrb_task_run's catch handler, which called `mrb_exc_raise()` to re-propagate, and with no outer jmpbuf this aborted the process. PicoRuby/R2P2 could no longer retrieve task exceptions via `mrb_task_value()`. ## Fix Restore the "task exception becomes task result" contract uniformly for both patterns, independent of mrb->jmp: * Add `mrb_task_state.exception_as_result`. When set, `mrb_vm_exec()`'s non-root_c L_RAISE branch returns the exception as a value even if prev_jmp is non-NULL, instead of throwing * `execute_task_vm()` raises the flag around `mrb_vm_exec()`, captures the exception into `t->result`, and clears `mrb->exc` * Wrap `execute_task_vm()` in `mrb_protect_error()` as a safety net for rare paths that still unwind via MRB_THROW (e.g. CINFO_SKIP frames). exception_as_result is reset both at the end of the body and immediately after `mrb_protect_error()` returns, so a caught throw does not leave the llag set * Expose `Task#value` to retrieve t->result from Ruby, since Task#join cannot deliver the value through its return path under cooperative scheduling * Add a test asserting that `Task#join` on a task that raised returns the exception object, matching the pre-c09196c observable behavior ## Notes The "task exception becomes task result" semantics match the mruby/c's rrt0.c and the spirit of CRuby's Thread (an unhandled exception in a thread does not kill the scheduler / process; it surfaces when the thread is joined). The visible API shape still differs from CRuby - `Task#join` here returns the exception object rather than re-raising it - but the scheduler is no longer destabilized by task errors in either invocation pattern.
mruby
Table of contents
- What is mruby
- How to get mruby
- mruby homepage
- Mailing list
- How to compile, test, and install (mruby and gems)
- Amalgamation (single-file build)
- Building documentation
- How to customize mruby (mrbgems)
- Index of Document
- License
- Note for License
- How to Contribute
- Star History
- Contributors
What is mruby
mruby is the lightweight implementation of the Ruby language complying to (part of) the ISO standard with more recent features provided by Ruby 4.x. Also, its syntax is Ruby 4.x compatible.
You can link and embed mruby within your application. The "mruby" interpreter program and the interactive "mirb" shell are provided as examples. You can also compile Ruby programs into compiled byte code using the "mrbc" compiler. All these tools are located in the "bin" directory. "mrbc" can also generate compiled byte code in a C source file. See the "mrbtest" program under the "test" directory for an example.
This achievement was sponsored by the Regional Innovation Creation R&D Programs of the Ministry of Economy, Trade and Industry of Japan.
How to get mruby
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, ruby-build, rvm, conda or Homebrew.
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-rc3.zip
The latest development version of mruby can be downloaded via the following URL: https://github.com/mruby/mruby/zipball/master
The trunk of the mruby source tree can be checked out with the following command:
$ git clone https://github.com/mruby/mruby.git
mruby homepage
The URL of the mruby homepage is: https://mruby.org.
Mailing list
We don't have a mailing list, but you can use GitHub issues.
How to compile, test, and install (mruby and gems)
For the simplest case, type
rake all test
See the compile.md file for the detail.
Amalgamation (single-file build)
mruby supports amalgamation, which combines all source files into a single
mruby.c and mruby.h for easy embedding (similar to SQLite).
rake amalgam
Output files are generated in build/host/amalgam/. To use:
gcc -I./build/host/amalgam your_app.c ./build/host/amalgam/mruby.c -o your_app -lm
Building documentation
There are two sets of documentation in mruby: the mruby API (generated by YARD) and C API (Doxygen and Graphviz)
To build both of them, simply go
rake doc
You can also view them in your browser
rake view_api
rake view_capi
How to customize mruby (mrbgems)
mruby contains a package manager called "mrbgems" that you can use to create extensions in C and/or Ruby. For a guide on how to use mrbgems, consult the mrbgems.md file, and for example code, refer to the examples/mrbgems/ folder.
Index of Document
- About the Limitations of mruby
- About Amalgamation (Single-File Build)
- C API Reference
- About the Compile
- About the Debugger with the
mrdbCommand - About GC Arena
- Getting Started with mruby
- About the mruby directory structure
- About Linking with
libmruby - About Memory Allocator Customization and Heap Regions
- About Build-time Configurations
- About the Build-time Library Manager
- ROM Method Tables for Memory-Efficient Method Registration
- About the Symbols
- Internal Implementation / About mruby Architecture
- Internal Implementation / About Value Boxing
- Internal Implementation / About mruby Virtual Machine Instructions
License
mruby is released under the MIT License.
Note for License
mruby has chosen a MIT License due to its permissive license allowing developers to target various environments such as embedded systems. However, the license requires the display of the copyright notice and license information in manuals for instance. Doing so for big projects can be complicated or troublesome. This is why mruby has decided to display "mruby developers" as the copyright name to make it simple conventionally. In the future, mruby might ask you to distribute your new code (that you will commit,) under the MIT License as a member of "mruby developers" but contributors will keep their copyright. (We did not intend for contributors to transfer or waive their copyrights, actual copyright holder name (contributors) will be listed in the AUTHORS file.)
Please ask us if you want to distribute your code under another license.
How to Contribute
To contribute to mruby, please refer to the contribution guidelines and send a pull request to the mruby GitHub repository. By contributing, you grant non-exclusive rights to your code under the MIT License.