enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-binding/src/binding.c

@@ -0,0 +1,518 @@
+#include <mruby.h>
+#include <mruby/array.h>
+#include <mruby/class.h>
+#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>
+
+#define BINDING_UPPER_DEFAULT  20
+#define BINDING_UPPER_MINIMUM  10
+#define BINDING_UPPER_MAXIMUM 100
+
+#ifndef MRB_BINDING_UPPER_MAX
+# define BINDING_UPPER_MAX BINDING_UPPER_DEFAULT
+#else
+# if (MRB_BINDING_UPPER_MAX) > BINDING_UPPER_MAXIMUM
+#  define BINDING_UPPER_MAX BINDING_UPPER_MAXIMUM
+# elif (MRB_BINDING_UPPER_MAX) < BINDING_UPPER_MINIMUM
+#  define BINDING_UPPER_MAX BINDING_UPPER_MINIMUM
+# else
+#  define BINDING_UPPER_MAX MRB_BINDING_UPPER_MAX
+# endif
+#endif
+
+static mrb_int
+binding_extract_pc(mrb_state *mrb, mrb_value binding)
+{
+  mrb_value obj = mrb_iv_get(mrb, binding, MRB_SYM(pc));
+  if (mrb_nil_p(obj)) {
+    return -1;
+  }
+  else {
+    mrb_check_type(mrb, obj, MRB_TT_INTEGER);
+    return mrb_int(mrb, obj);
+  }
+}
+
+const struct RProc *
+mrb_binding_extract_proc(mrb_state *mrb, mrb_value binding)
+{
+  mrb_value obj = mrb_iv_get(mrb, binding, MRB_SYM(proc));
+  mrb_check_type(mrb, obj, MRB_TT_PROC);
+  return mrb_proc_ptr(obj);
+}
+
+struct REnv *
+mrb_binding_extract_env(mrb_state *mrb, mrb_value binding)
+{
+  mrb_value obj = mrb_iv_get(mrb, binding, MRB_SYM(env));
+  if (mrb_nil_p(obj)) {
+    return NULL;
+  }
+  else {
+    mrb_check_type(mrb, obj, MRB_TT_ENV);
+    return (struct REnv*)mrb_obj_ptr(obj);
+  }
+}
+
+static mrb_irep *
+binding_irep_new_lvspace(mrb_state *mrb)
+{
+  static const mrb_code iseq_dummy[] = { OP_RETURN, 0 };
+
+  mrb_irep *irep = mrb_add_irep(mrb);
+  irep->flags = MRB_ISEQ_NO_FREE;
+  irep->iseq = iseq_dummy;
+  irep->ilen = sizeof(iseq_dummy) / sizeof(iseq_dummy[0]);
+  irep->lv = NULL;
+  irep->nlocals = 1;
+  irep->nregs = 1;
+  return irep;
+}
+
+static struct RProc *
+binding_proc_new_lvspace(mrb_state *mrb, const struct RProc *upper, struct REnv *env)
+{
+  struct RProc *lvspace = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class);
+  lvspace->body.irep = binding_irep_new_lvspace(mrb);
+  lvspace->upper = upper;
+  if (env && env->tt == MRB_TT_ENV) {
+    lvspace->e.env = env;
+    lvspace->flags |= MRB_PROC_ENVSET;
+  }
+  return lvspace;
+}
+
+static struct REnv *
+binding_env_new_lvspace(mrb_state *mrb, const struct REnv *e)
+{
+  struct REnv *env = MRB_OBJ_ALLOC(mrb, MRB_TT_ENV, NULL);
+  mrb_value *stacks = (mrb_value*)mrb_calloc(mrb, 1, sizeof(mrb_value));
+  env->mid = 0;
+  env->stack = stacks;
+  if (e && e->stack && MRB_ENV_LEN(e) > 0) {
+    env->stack[0] = e->stack[0];
+  }
+  else {
+    env->stack[0] = mrb_nil_value();
+  }
+  MRB_ENV_SET_LEN(env, 1);
+  return env;
+}
+
+static void
+binding_check_proc_upper_count(mrb_state *mrb, const struct RProc *proc)
+{
+  for (size_t count = 0; proc && !MRB_PROC_CFUNC_P(proc); proc = proc->upper) {
+    count++;
+    if (count > BINDING_UPPER_MAX) {
+      mrb_raise(mrb, E_RUNTIME_ERROR,
+                "too many upper procs for local variables (mruby limitation; maximum is " MRB_STRINGIZE(BINDING_UPPER_MAX) ")");
+    }
+    if (MRB_PROC_SCOPE_P(proc)) break;
+  }
+}
+
+mrb_bool
+mrb_binding_p(mrb_state *mrb, mrb_value obj)
+{
+  if (!mrb_obj_is_kind_of(mrb, obj, mrb_class_get_id(mrb, MRB_SYM(Binding)))) return FALSE;
+  if (mrb_type(obj) != MRB_TT_OBJECT) return FALSE;
+  if (!mrb_obj_iv_defined(mrb, mrb_obj_ptr(obj), MRB_SYM(proc))) return FALSE;
+  if (!mrb_obj_iv_defined(mrb, mrb_obj_ptr(obj), MRB_SYM(recv))) return FALSE;
+  if (!mrb_obj_iv_defined(mrb, mrb_obj_ptr(obj), MRB_SYM(env))) return FALSE;
+  return TRUE;
+}
+
+static void
+binding_type_ensure(mrb_state *mrb, mrb_value obj)
+{
+  if (mrb_binding_p(mrb, obj)) return;
+  mrb_raise(mrb, E_TYPE_ERROR, "not a binding");
+}
+
+static struct RProc*
+binding_wrap_lvspace(mrb_state *mrb, const struct RProc *proc, struct REnv **envp)
+{
+  /*
+   * local variable space: It is a space to hold the top-level variable of
+   * binding.eval and binding.local_variable_set.
+   */
+
+  struct RProc *lvspace = binding_proc_new_lvspace(mrb, proc, *envp);
+  *envp = binding_env_new_lvspace(mrb, *envp);
+  return lvspace;
+}
+
+static mrb_value
+binding_initialize_copy(mrb_state *mrb, mrb_value binding)
+{
+  mrb_value src = mrb_get_arg1(mrb);
+  binding_type_ensure(mrb, src);
+  const struct RProc *src_proc = mrb_binding_extract_proc(mrb, src);
+  struct REnv *src_env = mrb_binding_extract_env(mrb, src);
+
+  mrb_check_frozen(mrb, mrb_obj_ptr(binding));
+
+  struct RProc *lvspace;
+  struct REnv *env;
+  if (MRB_ENV_LEN(src_env) < 2) {
+    /* when local variables of src are self only */
+    env = src_proc->e.env;
+    lvspace = binding_wrap_lvspace(mrb, src_proc->upper, &env);
+  }
+  else {
+    binding_check_proc_upper_count(mrb, src_proc);
+
+    env = src_env;
+    lvspace = binding_wrap_lvspace(mrb, src_proc, &env);
+
+    // The reason for using the mrb_obj_iv_set_force() function is to allow local
+    // variables to be modified even if src is frozen. This behavior is CRuby imitation.
+    src_proc = binding_wrap_lvspace(mrb, src_proc, &src_env);
+    struct RObject *o = mrb_obj_ptr(src);
+    mrb_obj_iv_set_force(mrb, o, MRB_SYM(proc), mrb_obj_value((struct RProc*)src_proc));
+    mrb_obj_iv_set_force(mrb, o, MRB_SYM(env), mrb_obj_value(src_env));
+  }
+  mrb_iv_set(mrb, binding, MRB_SYM(proc), mrb_obj_value(lvspace));
+  mrb_iv_set(mrb, binding, MRB_SYM(env), mrb_obj_value(env));
+
+  return binding;
+}
+
+static mrb_noreturn void
+badname_error(mrb_state *mrb, mrb_sym id)
+{
+  mrb_raisef(mrb, E_NAME_ERROR, "wrong local variable name %!n for binding", id);
+}
+
+static void
+binding_local_variable_name_check(mrb_state *mrb, mrb_sym id)
+{
+  if (id == 0) {
+    badname_error(mrb, id);
+  }
+
+  mrb_int len;
+  const char *name = mrb_sym_name_len(mrb, id, &len);
+  if (len == 0) {
+    badname_error(mrb, id);
+  }
+
+  if (ISASCII(*name) && !(*name == '_' || ISLOWER(*name))) {
+    badname_error(mrb, id);
+  }
+  len--;
+  name++;
+
+  for (; len > 0; len--, name++) {
+    if (ISASCII(*name) && !(*name == '_' || ISALNUM(*name))) {
+      badname_error(mrb, id);
+    }
+  }
+}
+
+static mrb_value *
+binding_local_variable_search(mrb_state *mrb, const struct RProc *proc, struct REnv *env, mrb_sym varname)
+{
+  binding_local_variable_name_check(mrb, varname);
+
+  while (proc) {
+    if (MRB_PROC_CFUNC_P(proc)) break;
+
+    const mrb_irep *irep = proc->body.irep;
+    const mrb_sym *lv;
+    if (irep && (lv = irep->lv)) {
+      for (int i = 0; i + 1 < irep->nlocals; i++, lv++) {
+        if (varname == *lv) {
+          return (env && MRB_ENV_LEN(env) > i) ? &env->stack[i + 1] : NULL;
+        }
+      }
+    }
+
+    if (MRB_PROC_SCOPE_P(proc)) break;
+    env = MRB_PROC_ENV(proc);
+    proc = proc->upper;
+  }
+
+  return NULL;
+}
+
+/*
+ * call-seq:
+ *  local_variable_defined?(symbol) -> bool
+ *
+ * Returns true if a local variable with the given name is defined
+ * in the binding's context, false otherwise.
+ *
+ *   def foo
+ *     a = 1
+ *     b = binding
+ *     b.local_variable_defined?(:a)  #=> true
+ *     b.local_variable_defined?(:c)  #=> false
+ *   end
+ *
+ *   x = 10
+ *   bind = binding
+ *   bind.local_variable_defined?(:x)     #=> true
+ *   bind.local_variable_defined?(:y)     #=> false
+ *   bind.local_variable_set(:y, 20)
+ *   bind.local_variable_defined?(:y)     #=> true
+ */
+static mrb_value
+binding_local_variable_defined_p(mrb_state *mrb, mrb_value self)
+{
+  mrb_sym varname;
+  mrb_get_args(mrb, "n", &varname);
+
+  const struct RProc *proc = mrb_binding_extract_proc(mrb, self);
+  struct REnv *env = mrb_binding_extract_env(mrb, self);
+  mrb_value *e = binding_local_variable_search(mrb, proc, env, varname);
+  if (e) {
+    return mrb_true_value();
+  }
+  else {
+    return mrb_false_value();
+  }
+}
+
+/*
+ * call-seq:
+ *  local_variable_get(symbol) -> object
+ *
+ * Returns the value of the local variable with the given name
+ * in the binding's context. Raises NameError if the variable
+ * is not defined.
+ *
+ *   def foo
+ *     a = 42
+ *     b = "hello"
+ *     bind = binding
+ *     bind.local_variable_get(:a)  #=> 42
+ *     bind.local_variable_get(:b)  #=> "hello"
+ *     bind.local_variable_get(:c)  #=> NameError
+ *   end
+ *
+ *   x = [1, 2, 3]
+ *   bind = binding
+ *   bind.local_variable_get(:x)      #=> [1, 2, 3]
+ *   x = "modified"
+ *   bind.local_variable_get(:x)      #=> "modified"
+ */
+static mrb_value
+binding_local_variable_get(mrb_state *mrb, mrb_value self)
+{
+  mrb_sym varname;
+  mrb_get_args(mrb, "n", &varname);
+
+  const struct RProc *proc = mrb_binding_extract_proc(mrb, self);
+  struct REnv *env = mrb_binding_extract_env(mrb, self);
+  mrb_value *e = binding_local_variable_search(mrb, proc, env, varname);
+  if (!e) {
+    mrb_raisef(mrb, E_NAME_ERROR, "local variable %!n is not defined", varname);
+  }
+
+  return *e;
+}
+
+/*
+ * call-seq:
+ *   binding.local_variable_set(symbol, obj) -> obj
+ *
+ * Set local variable named symbol as obj in binding's context.
+ * If the variable is not defined in the binding, it will be created.
+ *
+ *   def foo
+ *     a = 1
+ *     binding.local_variable_set(:a, 2)
+ *     binding.local_variable_set(:b, 3)
+ *     [a, b]  #=> [2, 3]
+ *   end
+ */
+static mrb_value
+binding_local_variable_set(mrb_state *mrb, mrb_value self)
+{
+  mrb_sym varname;
+  mrb_value obj;
+  mrb_get_args(mrb, "no", &varname, &obj);
+
+  const struct RProc *proc = mrb_binding_extract_proc(mrb, self);
+  struct REnv *env = mrb_binding_extract_env(mrb, self);
+  mrb_value *e = binding_local_variable_search(mrb, proc, env, varname);
+  if (e) {
+    *e = obj;
+    if (!mrb_immediate_p(obj)) {
+      mrb_field_write_barrier(mrb, (struct RBasic*)env, (struct RBasic*)mrb_obj_ptr(obj));
+    }
+  }
+  else {
+    mrb_proc_merge_lvar(mrb, (mrb_irep*)proc->body.irep, env, 1, &varname, &obj);
+  }
+
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   binding.local_variables -> array
+ *
+ * Returns an array of symbols representing the names of the local variables
+ * in the binding.
+ *
+ *   def foo
+ *     a = 1
+ *     b = 2
+ *     binding.local_variables  #=> [:a, :b]
+ *   end
+ */
+static mrb_value
+binding_local_variables(mrb_state *mrb, mrb_value self)
+{
+  const struct RProc *proc = mrb_proc_ptr(mrb_iv_get(mrb, self, MRB_SYM(proc)));
+  return mrb_proc_local_variables(mrb, proc);
+}
+
+/*
+ * call-seq:
+ *   binding.receiver -> object
+ *
+ * Returns the bound receiver of the binding object.
+ *
+ *   class Demo
+ *     def get_binding
+ *       binding
+ *     end
+ *   end
+ *   Demo.new.get_binding.receiver  #=> #<Demo:0x...>
+ */
+static mrb_value
+binding_receiver(mrb_state *mrb, mrb_value self)
+{
+  return mrb_iv_get(mrb, self, MRB_SYM(recv));
+}
+
+/*
+ * call-seq:
+ *  source_location -> [String, Integer]
+ */
+static mrb_value
+binding_source_location(mrb_state *mrb, mrb_value self)
+{
+  if (mrb_iv_defined(mrb, self, MRB_SYM(source_location))) {
+    return mrb_iv_get(mrb, self, MRB_SYM(source_location));
+  }
+
+  mrb_value srcloc;
+  const struct RProc *proc = mrb_binding_extract_proc(mrb, self);
+  if (!proc || MRB_PROC_CFUNC_P(proc) ||
+      !proc->upper || MRB_PROC_CFUNC_P(proc->upper)) {
+    srcloc = mrb_nil_value();
+  }
+  else {
+    const mrb_irep *irep = proc->upper->body.irep;
+    mrb_int pc = binding_extract_pc(mrb, self);
+    if (pc < 0) {
+      srcloc = mrb_nil_value();
+    }
+    else {
+      const char *fname;
+      int32_t line;
+
+      if (!mrb_debug_get_position(mrb, irep, (uint32_t)pc, &line, &fname)) {
+        srcloc  = mrb_nil_value();
+      }
+      else {
+        srcloc = mrb_assoc_new(mrb, mrb_str_new_cstr(mrb, fname), mrb_fixnum_value(line));
+      }
+    }
+  }
+
+  if (!mrb_frozen_p(mrb_obj_ptr(self))) {
+    mrb_iv_set(mrb, self, MRB_SYM(source_location), srcloc);
+  }
+  return srcloc;
+}
+
+mrb_value
+mrb_binding_new(mrb_state *mrb, const struct RProc *proc, mrb_value recv, struct REnv *env)
+{
+  struct RObject *binding = MRB_OBJ_ALLOC(mrb, MRB_TT_OBJECT, mrb_class_get_id(mrb, MRB_SYM(Binding)));
+
+  if (proc && !MRB_PROC_CFUNC_P(proc)) {
+    const mrb_irep *irep = proc->body.irep;
+    mrb_obj_iv_set(mrb, binding, MRB_SYM(pc), mrb_fixnum_value(mrb->c->ci[-1].pc - irep->iseq - 1 /* step back */));
+  }
+  proc = binding_wrap_lvspace(mrb, proc, &env);
+
+  mrb_obj_iv_set(mrb, binding, MRB_SYM(proc), mrb_obj_value((void*)proc));
+  mrb_obj_iv_set(mrb, binding, MRB_SYM(recv), recv);
+  mrb_obj_iv_set(mrb, binding, MRB_SYM(env), mrb_obj_value(env));
+
+  return mrb_obj_value(binding);
+}
+
+/*
+ * call-seq:
+ *   binding -> binding
+ *
+ * Returns a Binding object, describing the variable and method bindings
+ * at the point of call. This object can be used when calling eval to
+ * execute the evaluated command in this environment.
+ *
+ *   def get_binding(param)
+ *     binding
+ *   end
+ *   b = get_binding("hello")
+ *   b.eval("param")  #=> "hello"
+ */
+static mrb_noreturn void
+caller_error(mrb_state *mrb)
+{
+  mrb_raise(mrb, E_RUNTIME_ERROR, "Cannot create Binding object for non-Ruby caller");
+}
+
+static mrb_value
+mrb_f_binding(mrb_state *mrb, mrb_value self)
+{
+  struct RProc *proc;
+  struct REnv *env;
+
+  if (mrb->c->ci->cci != 0) {
+    caller_error(mrb);
+  }
+  proc = (struct RProc*)mrb_proc_get_caller(mrb, &env);
+  if (!env || MRB_PROC_CFUNC_P(proc)) {
+    caller_error(mrb);
+  }
+  return mrb_binding_new(mrb, proc, self, env);
+}
+
+void
+mrb_mruby_binding_gem_init(mrb_state *mrb)
+{
+  struct RClass *binding = mrb_define_class_id(mrb, MRB_SYM(Binding), mrb->object_class);
+  MRB_SET_INSTANCE_TT(binding, MRB_TT_OBJECT);
+  MRB_UNDEF_ALLOCATOR(binding);
+  mrb_undef_class_method_id(mrb, binding, MRB_SYM(new));
+  mrb_undef_class_method_id(mrb, binding, MRB_SYM(allocate));
+
+  mrb_define_private_method_id(mrb, mrb->kernel_module, MRB_SYM(binding), mrb_f_binding, MRB_ARGS_NONE());
+
+  mrb_define_private_method_id(mrb, binding, MRB_SYM(initialize_copy), binding_initialize_copy, MRB_ARGS_REQ(1));
+  mrb_define_method_id(mrb, binding, MRB_SYM_Q(local_variable_defined), binding_local_variable_defined_p, MRB_ARGS_REQ(1));
+  mrb_define_method_id(mrb, binding, MRB_SYM(local_variable_get), binding_local_variable_get, MRB_ARGS_REQ(1));
+  mrb_define_method_id(mrb, binding, MRB_SYM(local_variable_set), binding_local_variable_set, MRB_ARGS_REQ(2));
+  mrb_define_method_id(mrb, binding, MRB_SYM(local_variables), binding_local_variables, MRB_ARGS_NONE());
+  mrb_define_method_id(mrb, binding, MRB_SYM(receiver), binding_receiver, MRB_ARGS_NONE());
+  mrb_define_method_id(mrb, binding, MRB_SYM(source_location), binding_source_location, MRB_ARGS_NONE());
+  mrb_define_method_id(mrb, binding, MRB_SYM(inspect), mrb_any_to_s, MRB_ARGS_NONE());
+}
+
+void
+mrb_mruby_binding_gem_final(mrb_state *mrb)
+{
+}

data/ext/enclave/mruby/mrbgems/mruby-binding/test/binding.c

@@ -0,0 +1,14 @@
+#include <mruby.h>
+#include <mruby/presym.h>
+
+static mrb_value
+binding_in_c(mrb_state *mrb, mrb_value self)
+{
+  return mrb_funcall_argv(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(binding), 0, NULL);
+}
+
+void
+mrb_mruby_binding_gem_test(mrb_state *mrb)
+{
+  mrb_define_method(mrb, mrb->object_class, "binding_in_c", binding_in_c, MRB_ARGS_NONE());
+}

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

@@ -0,0 +1,64 @@
+assert("Kernel.#binding") do
+  assert_kind_of Binding, binding
+end
+
+assert("Binding#local_variables") do
+  block = Proc.new do |a|
+    b = 1
+    binding
+  end
+  assert_equal [:a, :b, :block], block.call(0).local_variables.sort
+end
+
+assert("Binding#local_variable_set") do
+  bind = binding
+  1.times {
+    assert_equal(9, bind.local_variable_set(:x, 9))
+    assert_raise(NameError) { x }
+    assert_equal([:bind, :x], bind.local_variables.sort)
+  }
+end
+
+assert("Binding#local_variable_get") do
+  bind = binding
+  x = 1
+  1.times {
+    y = 2
+    assert_equal(1, bind.local_variable_get(:x))
+    x = 10
+    assert_equal(10, bind.local_variable_get(:x))
+    assert_raise(NameError) { bind.local_variable_get(:y) }
+    assert_equal([:bind, :x], bind.local_variables.sort)
+  }
+end
+
+assert("Binding#source_location") do
+  skip unless -> {}.source_location
+
+  bind, source_location = binding, [__FILE__, __LINE__]
+  assert_equal source_location, bind.source_location
+end
+
+assert("Binding#dup") do
+  x = 5
+  bind1 = binding
+  bind1.local_variable_set(:y, 10)
+  bind2 = bind1.dup
+  assert_equal 5, bind2.local_variable_get(:x)
+  assert_equal 10, bind2.local_variable_get(:y)
+  x = 50
+  assert_equal 50, bind1.local_variable_get(:x)
+  assert_equal 50, bind2.local_variable_get(:x)
+  bind1.local_variable_set(:y, 20)
+  assert_equal 20, bind1.local_variable_get(:y)
+  assert_equal 20, bind2.local_variable_get(:y)
+  bind1.local_variable_set(:z, 30)
+  assert_raise(NameError) { bind2.local_variable_get(:z) }
+  bind2.local_variable_set(:z, 40)
+  assert_equal 30, bind1.local_variable_get(:z)
+  assert_equal 40, bind2.local_variable_get(:z)
+end
+
+assert "Kernel#binding and .eval from C" do
+  assert_raise(RuntimeError) { binding_in_c }
+end

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

@@ -0,0 +1,94 @@
+# mruby-catch
+
+This mrbgem provides `catch` and `throw` functionality similar to what is available in standard Ruby. It allows for non-local exits from blocks of code.
+
+## `catch`
+
+The `catch` method is used to establish a block that can be exited prematurely using `throw`.
+
+```ruby
+catch(tag) do |current_tag|
+  # ... code ...
+  if some_condition
+    throw(tag, return_value)
+  end
+  # ... more code ...
+end
+```
+
+- **With a tag:** When `catch` is called with a `tag` (any Ruby object), it executes the block. If `throw` is called with the same `tag` from within this block (or any method called from within it), the `catch` block immediately exits and returns the value provided to `throw`.
+- **Block completion:** If the block executes to completion without `throw` being called with a matching tag, the `catch` block returns the result of the last expression evaluated in the block.
+- **No tag:** If `catch` is called without a tag, a new unique `Object` is created and used as the tag. This tag is passed as an argument to the block.
+
+```ruby
+catch do |generated_tag|
+  # generated_tag is a new Object
+  throw(generated_tag, "hello")
+end # => "hello"
+```
+
+## `throw`
+
+The `throw` method is used to initiate a non-local exit to a corresponding `catch` block.
+
+```ruby
+throw(tag)
+throw(tag, value)
+```
+
+- **With a tag and value:** `throw(tag, value)` jumps to the innermost active `catch` block that is waiting for `tag`. The `catch` block then returns `value`.
+- **With only a tag:** `throw(tag)` is equivalent to `throw(tag, nil)`.
+- **Uncaught throw:** If `throw` is called with a `tag` for which there is no matching `catch` block in the current call stack, an `UncaughtThrowError` is raised.
+
+## `UncaughtThrowError`
+
+This is a custom error class that inherits from `ArgumentError`. It is raised when `throw` is called for a tag that is not currently being caught.
+It has two attributes:
+
+- `tag`: The tag that was thrown.
+- `value`: The value that was thrown with the tag.
+
+## Example
+
+```ruby
+def check_value(val)
+  puts "Checking: #{val}"
+  if val < 0
+    throw(:negative_value, val)
+  elsif val == 0
+    throw(:zero_value) # value will be nil
+  end
+  puts "#{val} is positive"
+  val * 2
+end
+
+result = catch(:negative_value) do
+  puts catch(:zero_value) do
+    puts check_value(10)
+    puts check_value(-5) # This will throw to :negative_value
+    puts check_value(0)  # This would throw to :zero_value, but it's not reached
+  end
+  puts "This line is skipped if :zero_value is thrown."
+end
+
+puts "Result: #{result}"
+
+# Output:
+# Checking: 10
+# 10 is positive
+# 20
+# Checking: -5
+# Result: -5
+
+puts "--- Next example --- "
+
+result2 = catch do |tag_a|
+  catch do |tag_b|
+    puts "In tag_b block"
+    throw(tag_a, "Exited from A via B")
+    puts "This is not printed"
+  end
+  puts "This is not printed either"
+end
+puts result2 # => Exited from A via B
+```

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

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-catch') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Catch / Throw non-local Jump'
+end