enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-errno/test/errno.rb

@@ -0,0 +1,57 @@
+assert('Errno') do
+  assert_equal(Module, Errno.class)
+end
+
+assert('SystemCallError') do
+  assert_equal(Class, SystemCallError.class)
+end
+
+assert('SystemCallError superclass') do
+  assert_equal(StandardError, SystemCallError.superclass)
+end
+
+assert('SystemCallError#initialize') do
+  assert_equal("unknown error - a", SystemCallError.new("a").message)
+  assert_equal("Unknown error: 12345 - a", SystemCallError.new("a", 12345).message)
+  assert_equal("Unknown error: 12345", SystemCallError.new(12345).message)
+end
+
+assert('SystemCallError#errno') do
+  assert_equal 1, SystemCallError.new("a", 1).errno
+  assert_equal 1, SystemCallError.new(1).errno
+  assert_equal 12345, SystemCallError.new("a", 12345).errno
+  assert_equal 23456, SystemCallError.new(23456).errno
+end
+
+assert('SystemCallError#inspect') do
+  assert_equal("#<SystemCallError: unknown error - a>", SystemCallError.new("a").inspect)
+end
+
+assert('Errno::NOERROR') do
+  assert_equal(Class, Errno::NOERROR.class)
+end
+
+# Is there any platform does not have EPERM?
+assert('Errno::EPERM') do
+  assert_equal(Class, Errno::EPERM.class)
+end
+
+assert('Errno::EPERM superclass') do
+  assert_equal(SystemCallError, Errno::EPERM.superclass)
+end
+
+assert('Errno::EPERM::Errno') do
+  assert_true(Errno::EPERM::Errno.is_a?(Fixnum))
+end
+
+assert('Errno::EPERM#message') do
+  msg = Errno::EPERM.new.message
+  assert_equal("#{msg} - a", Errno::EPERM.new("a").message)
+end
+
+assert('Errno::EPERM#inspect') do
+  e = Errno::EPERM.new
+  msg = e.message
+  assert_equal("#<Errno::EPERM: #{msg}>", e.inspect)
+  assert_equal("#<Errno::EPERM: #{msg} - a>", Errno::EPERM.new("a").inspect)
+end

data/ext/enclave/mruby/mrbgems/mruby-error/README.md

@@ -0,0 +1,103 @@
+# mruby-error
+
+The `mruby-error` mrbgem provides a set of C-level APIs for structured exception handling within mruby. These functions allow C extensions or embedded mruby code to implement error handling patterns similar to Ruby's `begin`, `rescue`, and `ensure` keywords. This is particularly useful when writing C code that needs to interact with mruby's exception system in a robust way.
+
+## `mrb_protect`
+
+The `mrb_protect` function is used to execute a C function (`body`) and capture any exceptions that might be raised during its execution. This allows you to run potentially unsafe operations and handle errors gracefully.
+
+**C Signature:**
+
+```c
+mrb_value mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state);
+```
+
+**Parameters:**
+
+- `mrb_state *mrb`: The current mruby state.
+- `mrb_func_t body`: A function pointer to the C function to be executed. This function should have the signature `mrb_value (*body)(mrb_state *mrb, mrb_value data)`.
+- `mrb_value data`: A `mrb_value` that will be passed as an argument to the `body` function.
+- `mrb_bool *state`: A pointer to a boolean. After `mrb_protect` returns, this boolean will be:
+  - `FALSE` (0) if the `body` function executed without raising an exception.
+  - `TRUE` (1) if an exception was raised within the `body` function.
+
+**Return Value:**
+
+- If no exception occurs (`*state` is `FALSE`), `mrb_protect` returns the value returned by the `body` function.
+- If an exception occurs (`*state` is `TRUE`), `mrb_protect` returns the exception object.
+
+## `mrb_ensure`
+
+The `mrb_ensure` function ensures that a specific C function (`ensure`) is executed, regardless of whether another C function (`body`) completes normally or raises an exception. This is analogous to Ruby's `ensure` clause.
+
+**C Signature:**
+
+```c
+mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t ensure, mrb_value e_data);
+```
+
+**Parameters:**
+
+- `mrb_state *mrb`: The current mruby state.
+- `mrb_func_t body`: A function pointer to the main C function to be executed.
+- `mrb_value b_data`: A `mrb_value` passed as data to the `body` function.
+- `mrb_func_t ensure`: A function pointer to the C function that will always be executed after the `body` function.
+- `mrb_value e_data`: A `mrb_value` passed as data to the `ensure` function.
+
+**Behavior:**
+The `body` function is executed first. After its completion (either normally or due to an exception), the `ensure` function is executed. If the `body` function raised an exception, that exception is re-thrown after the `ensure` function has finished. The return value of `mrb_ensure` is the result of the `body` function if no exception occurred.
+
+## `mrb_rescue`
+
+The `mrb_rescue` function executes a C function (`body`) and, if an exception that is a `StandardError` (or a subclass of `StandardError`) is raised, it executes a specified `rescue` C function. This is similar to a `rescue` clause in Ruby that doesn't specify a particular exception type (which defaults to `StandardError`).
+
+**C Signature:**
+
+```c
+mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t rescue, mrb_value r_data);
+```
+
+**Parameters:**
+
+- `mrb_state *mrb`: The current mruby state.
+- `mrb_func_t body`: A function pointer to the main C function to be executed.
+- `mrb_value b_data`: A `mrb_value` passed as data to the `body` function.
+- `mrb_func_t rescue`: A function pointer to the C function that will be executed if a `StandardError` (or its subclass) is caught.
+- `mrb_value r_data`: A `mrb_value` passed as data to the `rescue` function.
+
+**Behavior:**
+If the `body` function executes without raising an exception, its result is returned. If a `StandardError` (or one of its descendants) is raised, the `rescue` function is executed, and its result becomes the return value of `mrb_rescue`. If an exception occurs that is not a `StandardError` (or its subclass), it is not caught by this function and will propagate up the call stack. Similarly, if the `rescue` block itself raises an exception, that exception will propagate.
+
+## `mrb_rescue_exceptions`
+
+The `mrb_rescue_exceptions` function provides more fine-grained exception handling than `mrb_rescue`. It executes a C function (`body`) and, if an exception matching one of the specified classes is raised, it executes a `rescue` C function. This is analogous to Ruby's `rescue SpecificError1, SpecificError2 => e` syntax.
+
+**C Signature:**
+
+```c
+mrb_value mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t rescue, mrb_value r_data, mrb_int len, struct RClass **classes);
+```
+
+**Parameters:**
+
+- `mrb_state *mrb`: The current mruby state.
+- `mrb_func_t body`: A function pointer to the main C function to be executed.
+- `mrb_value b_data`: A `mrb_value` passed as data to the `body` function.
+- `mrb_func_t rescue`: A function pointer to the C function that will be executed if a matching exception is caught.
+- `mrb_value r_data`: A `mrb_value` passed as data to the `rescue` function.
+- `mrb_int len`: The number of exception classes provided in the `classes` array.
+- `struct RClass **classes`: An array of pointers to mruby `RClass` objects representing the exception classes to be rescued.
+
+**Behavior:**
+If the `body` function executes without raising an exception, its result is returned. If an exception is raised that is an instance of one of the classes specified in the `classes` array (or a subclass of one of them), the `rescue` function is executed, and its result becomes the return value of `mrb_rescue_exceptions`. If an exception occurs that does not match any of the specified classes, it is not caught and will propagate. If the `rescue` block itself raises an exception, that exception will propagate.
+
+## Usage Examples
+
+The C functions provided by this mrbgem are typically used when writing mruby C extensions that need to interact with Ruby code or manage resources carefully in the presence of potential exceptions.
+
+For concrete examples of how these functions are used, please refer to the test files within this mrbgem:
+
+- `test/exception.c`: Shows how these C functions are called directly.
+- `test/exception.rb`: Demonstrates the behavior of these C functions from the Ruby side, through the `ExceptionTest` module (defined in `test/exception.c`).
+
+These tests illustrate how to set up callback functions and how the error handling mechanisms behave in practice.

data/ext/enclave/mruby/mrbgems/mruby-error/mrbgem.rake

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-error') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'extensional error handling'
+end

data/ext/enclave/mruby/mrbgems/mruby-error/src/exception.c

@@ -0,0 +1,143 @@
+#include <mruby.h>
+#include <mruby/error.h>
+
+/* Helper structure to pass function and data to protection wrapper */
+struct protect_data {
+  mrb_func_t body;    /* Function to be executed under protection */
+  mrb_value data;     /* Data to be passed to the function */
+};
+
+/* Helper function that wraps user function calls for exception protection.
+ * Extracts function and data from protect_data structure and calls the
+ * user function with proper parameters. Used internally by mrb_protect. */
+static mrb_value
+protect_body(mrb_state *mrb, void *p)
+{
+  struct protect_data *dp = (struct protect_data*)p;
+  return dp->body(mrb, dp->data);
+}
+
+/*
+ * Executes a function under exception protection.
+ *
+ * @param mrb    mruby state
+ * @param body   Function to execute under protection
+ * @param data   Data to pass to the function
+ * @param state  Pointer to store exception state (true if exception occurred)
+ * @return       Return value from body function, or exception object if error occurred
+ *
+ * This function provides a C API equivalent to Ruby's begin/rescue blocks.
+ * If an exception occurs during execution of body, it will be caught and
+ * the exception object returned, with *state set to true.
+ */
+MRB_API mrb_value
+mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state)
+{
+  struct protect_data protect_data = { body, data };
+  return mrb_protect_error(mrb, protect_body, &protect_data, state);
+}
+
+/*
+ * Executes a function with guaranteed cleanup (ensure block).
+ *
+ * @param mrb      mruby state
+ * @param body     Main function to execute
+ * @param b_data   Data to pass to body function
+ * @param ensure   Cleanup function that always executes
+ * @param e_data   Data to pass to ensure function
+ * @return         Return value from body function
+ *
+ * This function provides a C API equivalent to Ruby's begin/ensure blocks.
+ * The ensure function is guaranteed to execute regardless of whether the
+ * body function completes normally or raises an exception. If an exception
+ * occurs in the body, it will be re-raised after the ensure block executes.
+ */
+MRB_API mrb_value
+mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t ensure, mrb_value e_data)
+{
+  int ai = mrb_gc_arena_save(mrb);
+  struct protect_data protect_data = { body, b_data };
+  mrb_bool error;
+  mrb_value result = mrb_protect_error(mrb, protect_body, &protect_data, &error);
+  ensure(mrb, e_data);
+  mrb_gc_arena_restore(mrb, ai);
+  mrb_gc_protect(mrb, result);
+  if (error) {
+    mrb_exc_raise(mrb, result); /* rethrow caught exceptions */
+  }
+  return result;
+}
+
+/*
+ * Executes a function with exception handling for StandardError and its subclasses.
+ *
+ * @param mrb      mruby state
+ * @param body     Main function to execute
+ * @param b_data   Data to pass to body function
+ * @param rescue   Exception handler function
+ * @param r_data   Data to pass to rescue function
+ * @return         Return value from body function, or rescue function if StandardError occurred
+ *
+ * This function provides a C API equivalent to Ruby's begin/rescue blocks that
+ * catch StandardError. It's a convenience wrapper around mrb_rescue_exceptions
+ * that automatically handles StandardError and its subclasses.
+ */
+MRB_API mrb_value
+mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+           mrb_func_t rescue, mrb_value r_data)
+{
+  return mrb_rescue_exceptions(mrb, body, b_data, rescue, r_data, 1, &mrb->eStandardError_class);
+}
+
+/*
+ * Executes a function with exception handling for specific exception classes.
+ *
+ * @param mrb      mruby state
+ * @param body     Main function to execute
+ * @param b_data   Data to pass to body function
+ * @param rescue   Exception handler function
+ * @param r_data   Data to pass to rescue function
+ * @param len      Number of exception classes to handle
+ * @param classes  Array of exception classes to catch
+ * @return         Return value from body function, or rescue function if matching exception occurred
+ *
+ * This function provides a C API equivalent to Ruby's begin/rescue blocks with
+ * specific exception class handling. Only exceptions that are instances of the
+ * specified classes will be caught; others will be re-raised.
+ */
+MRB_API mrb_value
+mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_func_t rescue, mrb_value r_data,
+                      mrb_int len, struct RClass **classes)
+{
+  int ai = mrb_gc_arena_save(mrb);
+  struct protect_data protect_data = { body, b_data };
+  mrb_bool error;
+  mrb_value result = mrb_protect_error(mrb, protect_body, &protect_data, &error);
+  if (error) {
+    mrb_bool error_matched = FALSE;
+    for (mrb_int i = 0; i < len; i++) {
+      if (mrb_obj_is_kind_of(mrb, result, classes[i])) {
+        error_matched = TRUE;
+        break;
+      }
+    }
+
+    if (!error_matched) { mrb_exc_raise(mrb, result); }
+
+    mrb->exc = NULL;
+    result = rescue(mrb, r_data);
+    mrb_gc_arena_restore(mrb, ai);
+    mrb_gc_protect(mrb, result);
+  }
+  return result;
+}
+
+void
+mrb_mruby_error_gem_init(mrb_state *mrb)
+{
+}
+
+void
+mrb_mruby_error_gem_final(mrb_state *mrb)
+{
+}

data/ext/enclave/mruby/mrbgems/mruby-error/test/exception.c

@@ -0,0 +1,60 @@
+#include <mruby.h>
+#include <mruby/error.h>
+#include <mruby/array.h>
+
+static mrb_value
+protect_cb(mrb_state *mrb, mrb_value b)
+{
+  return mrb_yield_argv(mrb, b, 0, NULL);
+}
+
+static mrb_value
+run_protect(mrb_state *mrb, mrb_value self)
+{
+  mrb_value b;
+  mrb_get_args(mrb, "&", &b);
+
+  mrb_bool state;
+  mrb_value ret[2];
+  ret[0] = mrb_protect(mrb, protect_cb, b, &state);
+  ret[1] = mrb_bool_value(state);
+  return mrb_ary_new_from_values(mrb, 2, ret);
+}
+
+static mrb_value
+run_ensure(mrb_state *mrb, mrb_value self)
+{
+  mrb_value b, e;
+  mrb_get_args(mrb, "oo", &b, &e);
+  return mrb_ensure(mrb, protect_cb, b, protect_cb, e);
+}
+
+static mrb_value
+run_rescue(mrb_state *mrb, mrb_value self)
+{
+  mrb_value b, r;
+  mrb_get_args(mrb, "oo", &b, &r);
+  return mrb_rescue(mrb, protect_cb, b, protect_cb, r);
+}
+
+static mrb_value
+run_rescue_exceptions(mrb_state *mrb, mrb_value self)
+{
+  mrb_value b, r;
+  struct RClass *cls[1];
+  mrb_get_args(mrb, "oo", &b, &r);
+  cls[0] = E_TYPE_ERROR;
+  return mrb_rescue_exceptions(mrb, protect_cb, b, protect_cb, r, 1, cls);
+}
+
+void
+mrb_mruby_error_gem_test(mrb_state *mrb)
+{
+  struct RClass *cls;
+
+  cls = mrb_define_class(mrb, "ExceptionTest", mrb->object_class);
+  mrb_define_module_function(mrb, cls, "mrb_protect", run_protect, MRB_ARGS_NONE() | MRB_ARGS_BLOCK());
+  mrb_define_module_function(mrb, cls, "mrb_ensure", run_ensure, MRB_ARGS_REQ(2));
+  mrb_define_module_function(mrb, cls, "mrb_rescue", run_rescue, MRB_ARGS_REQ(2));
+  mrb_define_module_function(mrb, cls, "mrb_rescue_exceptions", run_rescue_exceptions, MRB_ARGS_REQ(2));
+}

data/ext/enclave/mruby/mrbgems/mruby-error/test/exception.rb

@@ -0,0 +1,55 @@
+assert 'mrb_protect' do
+  # no failure in protect returns [result, false]
+  assert_equal ['test', false] do
+    ExceptionTest.mrb_protect { 'test' }
+  end
+  # failure in protect returns [exception, true]
+  result = ExceptionTest.mrb_protect { raise 'test' }
+  assert_kind_of RuntimeError, result[0]
+  assert_true result[1]
+end
+
+assert 'mrb_ensure' do
+  a = false
+  assert_equal 'test' do
+    ExceptionTest.mrb_ensure Proc.new { 'test' }, Proc.new { a = true }
+  end
+  assert_true a
+
+  a = false
+  assert_raise RuntimeError do
+    ExceptionTest.mrb_ensure Proc.new { raise 'test' }, Proc.new { a = true }
+  end
+  assert_true a
+end
+
+assert 'mrb_rescue' do
+  assert_equal 'test' do
+    ExceptionTest.mrb_rescue Proc.new { 'test' }, Proc.new {}
+  end
+
+  class CustomExp < Exception
+  end
+
+  assert_raise CustomExp do
+    ExceptionTest.mrb_rescue Proc.new { raise CustomExp.new 'test' }, Proc.new { 'rescue' }
+  end
+
+  assert_equal 'rescue' do
+    ExceptionTest.mrb_rescue Proc.new { raise 'test' }, Proc.new { 'rescue' }
+  end
+end
+
+assert 'mrb_rescue_exceptions' do
+  assert_equal 'test' do
+    ExceptionTest.mrb_rescue_exceptions Proc.new { 'test' }, Proc.new {}
+  end
+
+  assert_raise RangeError do
+    ExceptionTest.mrb_rescue_exceptions Proc.new { raise RangeError.new 'test' }, Proc.new { 'rescue' }
+  end
+
+  assert_equal 'rescue' do
+    ExceptionTest.mrb_rescue_exceptions Proc.new { raise TypeError.new 'test' }, Proc.new { 'rescue' }
+  end
+end

data/ext/enclave/mruby/mrbgems/mruby-eval/README.md

@@ -0,0 +1,26 @@
+# mruby-eval
+
+This mrbgem provides methods for evaluating Ruby code from strings in mruby.
+
+## Features
+
+The `mruby-eval` gem implements the following methods:
+
+- **`eval`**: Evaluates a string as Ruby code. This is a private method on `Kernel`.
+- **`instance_eval`**: Evaluates a string or a block within the context of an object. This is a method on `BasicObject`.
+- **`class_eval` / `module_eval`**: Evaluates a string or a block within the context of a class or module. This is a method on `Module`.
+- **`Binding#eval`**: Evaluates a string within the context of a `Binding` object.
+
+## Usage
+
+For detailed usage and examples, please refer to the standard Ruby documentation for these methods. The mruby implementation aims to be compatible with the behavior of these methods in CRuby.
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.
+
+## License
+
+mruby-eval is released under the MIT License. See the [LICENSE](../../LICENSE) file in the main mruby repository for details.

data/ext/enclave/mruby/mrbgems/mruby-eval/mrbgem.rake

@@ -0,0 +1,10 @@
+MRuby::Gem::Specification.new('mruby-eval') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'standard Kernel#eval method'
+
+  add_dependency 'mruby-compiler', :core => 'mruby-compiler'
+  add_dependency 'mruby-binding', :core => 'mruby-binding'
+  spec.add_test_dependency('mruby-metaprog', :core => 'mruby-metaprog')
+  spec.add_test_dependency('mruby-method', :core => 'mruby-method')
+end