enclave 0.1.0

data/ext/enclave/mruby/src/print.c

@@ -0,0 +1,136 @@
+/*
+** print.c - Kernel#p, Kernel#print
+**
+** See Copyright Notice in mruby.h
+*/
+
+#include <mruby.h>
+#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>
+# include <io.h>
+#ifdef _MSC_VER
+# define isatty(x) _isatty(x)
+# define fileno(x) _fileno(x)
+#endif
+#else
+# include <unistd.h>
+#endif
+
+#ifndef MRB_NO_STDIO
+static void
+printcstr(mrb_state *mrb, const char *str, size_t len, FILE *stream)
+{
+#if defined(_WIN32)
+  if (isatty(fileno(stream))) {
+    DWORD written;
+    int wlen = MultiByteToWideChar(CP_UTF8, 0, str, (int)len, NULL, 0);
+    wchar_t* utf16 = (wchar_t*)mrb_malloc(mrb, (wlen+1) * sizeof(wchar_t));
+    if (MultiByteToWideChar(CP_UTF8, 0, str, (int)len, utf16, wlen) > 0) {
+      utf16[wlen] = 0;
+      WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE),
+                    utf16, (DWORD)wlen, &written, NULL);
+    }
+    mrb_free(mrb, utf16);
+    return;
+  }
+#endif
+  fwrite(str, (size_t)len, 1, stream);
+}
+
+static void
+printstr(mrb_state *mrb, mrb_value obj, FILE *stream)
+{
+  if (!mrb_string_p(obj)) {
+    obj = mrb_obj_as_string(mrb, obj);
+  }
+  printcstr(mrb, RSTRING_PTR(obj), RSTRING_LEN(obj), stream);
+}
+
+static void
+printstrln(mrb_state *mrb, mrb_value obj, FILE *stream)
+{
+  printstr(mrb, obj, stream);
+  printcstr(mrb, "\n", 1, stdout);
+}
+
+void
+mrb_core_init_printabort(mrb_state *mrb)
+{
+  static const char *str = "Failed mruby core initialization";
+  printcstr(mrb, str, strlen(str), stdout);
+}
+
+#ifndef HAVE_MRUBY_IO_GEM
+mrb_value
+mrb_print_m(mrb_state *mrb, mrb_value self)
+{
+  mrb_int argc;
+  mrb_value *argv;
+
+  mrb_get_args(mrb, "*", &argv, &argc);
+  for (mrb_int i=0; i<argc; i++) {
+    printstr(mrb, mrb_obj_as_string(mrb, argv[i]), stdout);
+  }
+  if (isatty(fileno(stdout))) fflush(stdout);
+  return mrb_nil_value();
+}
+#endif
+
+MRB_API void
+mrb_p(mrb_state *mrb, mrb_value obj)
+{
+  if (mrb_type(obj) == MRB_TT_EXCEPTION && mrb_obj_ptr(obj) == mrb->nomem_err) {
+    static const char *str = "Out of memory\n";
+    printcstr(mrb, str, strlen(str), stdout);
+  }
+  else {
+    printstrln(mrb, mrb_inspect(mrb, obj), stdout);
+  }
+  if (isatty(fileno(stdout))) fflush(stdout);
+}
+
+
+MRB_API void
+mrb_show_version(mrb_state *mrb)
+{
+  printstrln(mrb, mrb_const_get(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(MRUBY_DESCRIPTION)), stdout);
+}
+
+MRB_API void
+mrb_show_copyright(mrb_state *mrb)
+{
+  printstrln(mrb, mrb_const_get(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(MRUBY_COPYRIGHT)), stdout);
+}
+
+#else
+void
+mrb_core_init_printabort(mrb_state *mrb)
+{
+}
+
+mrb_value
+mrb_print_m(mrb_state *mrb, mrb_value self)
+{
+  return mrb_nil_value();
+}
+
+MRB_API void
+mrb_p(mrb_state *mrb, mrb_value obj)
+{
+}
+
+MRB_API void
+mrb_show_version(mrb_state *mrb)
+{
+}
+
+MRB_API void
+mrb_show_copyright(mrb_state *mrb)
+{
+}
+#endif

data/ext/enclave/mruby/src/proc.c

@@ -0,0 +1,572 @@
+/*
+** proc.c - Proc class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#include <mruby.h>
+#include <mruby/class.h>
+#include <mruby/proc.h>
+#include <mruby/opcode.h>
+#include <mruby/data.h>
+#include <mruby/array.h>
+#include <mruby/hash.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+static const mrb_code call_iseq[] = {
+  OP_CALL,
+};
+
+static const mrb_irep call_irep = {
+  0,                                   /* nlocals */
+  2,                                   /* nregs */
+  0,                                   /* clen */
+  MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE, /* flags */
+  call_iseq,                           /* iseq */
+  NULL,                                /* pool */
+  NULL,                                /* syms */
+  NULL,                                /* reps */
+  NULL,                                /* lv */
+  NULL,                                /* debug_info */
+  1,                                   /* ilen */
+  0,                                   /* plen */
+  0,                                   /* slen */
+  1,                                   /* rlen */
+  0,                                   /* refcnt */
+};
+
+mrb_alignas(8)
+static const struct RProc call_proc = {
+  NULL, MRB_TT_PROC, MRB_GC_RED, MRB_OBJ_IS_FROZEN, MRB_PROC_SCOPE | MRB_PROC_STRICT,
+  { &call_irep }, NULL, { NULL }
+};
+
+struct RProc*
+mrb_proc_new(mrb_state *mrb, const mrb_irep *irep)
+{
+  struct RProc *p;
+  mrb_callinfo *ci = mrb->c->ci;
+
+  p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class);
+  if (ci) {
+    struct RClass *tc = NULL;
+
+    if (ci->proc) {
+      tc = MRB_PROC_TARGET_CLASS(ci->proc);
+    }
+    if (tc == NULL) {
+      tc = mrb_vm_ci_target_class(ci);
+    }
+    p->upper = ci->proc;
+    p->e.target_class = tc;
+  }
+  if (irep) {
+    mrb_irep_incref(mrb, (mrb_irep*)irep);
+  }
+  p->body.irep = irep;
+
+  return p;
+}
+
+struct REnv*
+mrb_env_new(mrb_state *mrb, struct mrb_context *c, mrb_callinfo *ci, int nstacks, mrb_value *stack, struct RClass *tc)
+{
+  struct REnv *e;
+  mrb_int bidx = 1;
+  int n = ci->n;
+  int nk = ci->nk;
+
+  e = MRB_OBJ_ALLOC(mrb, MRB_TT_ENV, NULL);
+  e->c = tc;
+  MRB_ENV_SET_LEN(e, nstacks);
+  bidx += (n == 15) ? 1 : n;
+  bidx += (nk == 15) ? 1 : (2*nk);
+  MRB_ENV_SET_BIDX(e, bidx);
+  e->mid = ci->mid;
+  e->stack = stack;
+  e->cxt = c;
+  MRB_ENV_COPY_FLAGS_FROM_CI(e, ci);
+
+  return e;
+}
+
+static void
+closure_setup(mrb_state *mrb, struct RProc *p)
+{
+  mrb_callinfo *ci = mrb->c->ci;
+  const struct RProc *up = p->upper;
+  struct REnv *e = NULL;
+
+  mrb_assert(ci != NULL);
+  if ((e = mrb_vm_ci_env(ci)) != NULL) {
+    /* do nothing, because e is assigned already */
+  }
+  else if (up) {
+    struct RClass *tc = ci->u.target_class;
+
+    if (MRB_PROC_ALIAS_P(up)) { /* alias */
+      up = up->upper;
+    }
+    e = mrb_env_new(mrb, mrb->c, ci, up->body.irep->nlocals, ci->stack, tc);
+    ci->u.env = e;
+    if (MRB_PROC_ENV_P(up) && MRB_PROC_ENV(up)->cxt == NULL) {
+      e->mid = MRB_PROC_ENV(up)->mid;
+    }
+  }
+  if (e) {
+    p->e.env = e;
+    p->flags |= MRB_PROC_ENVSET;
+    mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e);
+  }
+}
+
+struct RProc*
+mrb_closure_new(mrb_state *mrb, const mrb_irep *irep)
+{
+  struct RProc *p = mrb_proc_new(mrb, irep);
+
+  closure_setup(mrb, p);
+  return p;
+}
+
+/*
+ * Creates a new Proc object from a C function.
+ *
+ * mrb: The mruby state.
+ * func: The C function to create the Proc from.
+ *
+ * Returns a pointer to the new Proc object.
+ */
+MRB_API struct RProc*
+mrb_proc_new_cfunc(mrb_state *mrb, mrb_func_t func)
+{
+  struct RProc *p;
+
+  p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class);
+  p->body.func = func;
+  p->flags |= MRB_PROC_CFUNC_FL;
+  p->upper = 0;
+  p->e.target_class = 0;
+
+  return p;
+}
+
+/*
+ * Creates a new Proc object from a C function with a new environment.
+ *
+ * mrb: The mruby state.
+ * func: The C function to create the Proc from.
+ * argc: The number of arguments to be stored in the environment.
+ * argv: The array of mrb_value to be stored in the environment.
+ *       These values are copied into the environment.
+ *
+ * Returns a pointer to the new Proc object.
+ */
+MRB_API struct RProc*
+mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const mrb_value *argv)
+{
+  struct RProc *p = mrb_proc_new_cfunc(mrb, func);
+  struct REnv *e;
+  int i;
+
+  p->e.env = e = mrb_env_new(mrb, mrb->c, mrb->c->ci, 0, NULL, NULL);
+  p->flags |= MRB_PROC_ENVSET;
+  mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e);
+  MRB_ENV_CLOSE(e);
+
+  e->stack = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * argc);
+  MRB_ENV_SET_LEN(e, argc);
+
+  if (argv) {
+    for (i = 0; i < argc; i++) {
+      e->stack[i] = argv[i];
+    }
+  }
+  else {
+    for (i = 0; i < argc; i++) {
+      SET_NIL_VALUE(e->stack[i]);
+    }
+  }
+  return p;
+}
+
+/*
+ * Creates a new closure from a C function.
+ *
+ * This function creates a new Proc object that represents a C function
+ * along with an environment for a specified number of local variables.
+ * The local variables in the environment are initialized to nil.
+ *
+ * mrb: The mruby state.
+ * func: The C function to create the closure from.
+ * nlocals: The number of local variables to allocate space for in the
+ *          closure's environment.
+ *
+ * Returns a pointer to the new Proc object representing the closure.
+ */
+MRB_API struct RProc*
+mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals)
+{
+  return mrb_proc_new_cfunc_with_env(mrb, func, nlocals, NULL);
+}
+
+/*
+ * Retrieves a value from the environment of the currently executing C function Proc.
+ *
+ * This function is used within a C function that was wrapped into a Proc
+ * (e.g., using mrb_closure_new_cfunc or mrb_proc_new_cfunc_with_env)
+ * to access values stored in its associated environment.
+ *
+ * mrb: The mruby state.
+ * idx: The index of the value to retrieve from the C function's environment.
+ *      The index must be non-negative and less than the number of
+ *      environment entries (argc passed during creation).
+ *
+ * Returns the mrb_value stored at the specified index in the environment.
+ *
+ * Raises E_TYPE_ERROR if the currently executing Proc is not a C function
+ * or if it does not have an associated environment.
+ * Raises E_INDEX_ERROR if the provided index is out of bounds.
+ */
+MRB_API mrb_value
+mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx)
+{
+  const struct RProc *p = mrb->c->ci->proc;
+  struct REnv *e;
+
+  if (!p || !MRB_PROC_CFUNC_P(p)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "Can't get cfunc env from non-cfunc proc");
+  }
+  e = MRB_PROC_ENV(p);
+  if (!e) {
+    mrb_raise(mrb, E_TYPE_ERROR, "Can't get cfunc env from cfunc Proc without REnv");
+  }
+  if (idx < 0 || MRB_ENV_LEN(e) <= idx) {
+    mrb_raisef(mrb, E_INDEX_ERROR, "Env index out of range: %i (expected: 0 <= index < %i)",
+               idx, MRB_ENV_LEN(e));
+  }
+
+  return e->stack[idx];
+}
+
+mrb_value
+mrb_proc_get_self(mrb_state *mrb, const struct RProc *p, struct RClass **target_class_p)
+{
+  if (MRB_PROC_CFUNC_P(p)) {
+    *target_class_p = mrb->object_class;
+    return mrb_nil_value();
+  }
+  else {
+    struct REnv *e = p->e.env;
+
+    if (!e || e->tt != MRB_TT_ENV) {
+      *target_class_p = mrb->object_class;
+      return mrb_top_self(mrb);
+    }
+    else if (MRB_ENV_LEN(e) < 1) {
+      mrb_raise(mrb, E_ARGUMENT_ERROR, "self is lost (probably ran out of memory when the block became independent)");
+    }
+
+    *target_class_p = e->c;
+    return e->stack[0];
+  }
+}
+
+void
+mrb_proc_copy(mrb_state *mrb, struct RProc *a, const struct RProc *b)
+{
+  if (a->body.irep) {
+    /* already initialized proc */
+    return;
+  }
+  if (!MRB_PROC_CFUNC_P(b) && b->body.irep) {
+    mrb_irep_incref(mrb, (mrb_irep*)b->body.irep);
+  }
+  a->flags = b->flags;
+  a->body = b->body;
+  a->upper = b->upper;
+  a->e.env = b->e.env;
+  /* a->e.target_class = a->e.target_class; */
+}
+
+static mrb_value
+mrb_proc_s_new(mrb_state *mrb, mrb_value proc_class)
+{
+  mrb_value blk;
+
+  /* Calling Proc.new without a block is not implemented yet */
+  mrb_get_args(mrb, "&!", &blk);
+  struct RProc *p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb_class_ptr(proc_class));
+  mrb_proc_copy(mrb, p, mrb_proc_ptr(blk));
+  mrb_value proc = mrb_obj_value(p);
+  mrb_funcall_with_block(mrb, proc, MRB_SYM(initialize), 0, NULL, proc);
+  if (!MRB_PROC_STRICT_P(p) &&
+      mrb->c->ci > mrb->c->cibase && MRB_PROC_ENV(p) == mrb->c->ci[-1].u.env) {
+    p->flags |= MRB_PROC_ORPHAN;
+  }
+  return proc;
+}
+
+static void
+check_proc(mrb_state *mrb, mrb_value proc)
+{
+  if (!mrb_proc_p(proc)) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "not a proc");
+  }
+}
+
+static mrb_value
+mrb_proc_init_copy(mrb_state *mrb, mrb_value self)
+{
+  mrb_value proc = mrb_get_arg1(mrb);
+
+  check_proc(mrb, proc);
+  mrb_proc_copy(mrb, mrb_proc_ptr(self), mrb_proc_ptr(proc));
+  return self;
+}
+
+static mrb_value
+proc_arity(mrb_state *mrb, mrb_value self)
+{
+  return mrb_int_value(mrb, mrb_proc_arity(mrb_proc_ptr(self)));
+}
+
+mrb_bool
+mrb_proc_eql(mrb_state *mrb, mrb_value self, mrb_value other)
+{
+  if (mrb_type(self) != MRB_TT_PROC) return FALSE;
+  if (mrb_type(other) != MRB_TT_PROC) return FALSE;
+
+  const struct RProc *p1 = mrb_proc_ptr(self);
+  const struct RProc *p2 = mrb_proc_ptr(other);
+
+  /* Follow alias chains to get the real procs */
+  while (p1 && MRB_PROC_ALIAS_P(p1)) {
+    p1 = p1->upper;
+  }
+  while (p2 && MRB_PROC_ALIAS_P(p2)) {
+    p2 = p2->upper;
+  }
+
+  /* If either pointer is NULL after following aliases, they can't be equal */
+  if (!p1 || !p2) return FALSE;
+
+  if (MRB_PROC_CFUNC_P(p1)) {
+    if (!MRB_PROC_CFUNC_P(p2)) return FALSE;
+    if (p1->body.func != p2->body.func) return FALSE;
+  }
+  else if (MRB_PROC_CFUNC_P(p2)) return FALSE;
+  else if (p1->body.irep != p2->body.irep) return FALSE;
+  else if (MRB_PROC_ENV(p1) != MRB_PROC_ENV(p2)) return FALSE;
+  return TRUE;
+}
+
+static mrb_value
+proc_eql(mrb_state *mrb, mrb_value self)
+{
+  return mrb_bool_value(mrb_proc_eql(mrb, self, mrb_get_arg1(mrb)));
+}
+
+static mrb_value
+proc_hash(mrb_state *mrb, mrb_value self)
+{
+  const struct RProc *p = mrb_proc_ptr(self);
+  return mrb_int_value(mrb, (mrb_int)((intptr_t)p->body.irep^((intptr_t)MRB_PROC_ENV(p)>>2)^MRB_TT_PROC));
+}
+
+/* 15.3.1.2.6  */
+/* 15.3.1.3.27 */
+/*
+ * call-seq:
+ *   lambda { |...| block }  -> a_proc
+ *
+ * Equivalent to `Proc.new`, except the resulting Proc objects
+ * check the number of parameters passed when called.
+ */
+static mrb_value
+proc_lambda(mrb_state *mrb, mrb_value self)
+{
+  mrb_value blk;
+
+  mrb_get_args(mrb, "&", &blk);
+  if (mrb_nil_p(blk)) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Proc object without a block");
+  }
+  check_proc(mrb, blk);
+  const struct RProc *p = mrb_proc_ptr(blk);
+  if (!MRB_PROC_STRICT_P(p)) {
+    struct RProc *p2 = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, p->c);
+    mrb_proc_copy(mrb, p2, p);
+    p2->flags |= MRB_PROC_STRICT;
+    return mrb_obj_value(p2);
+  }
+  return blk;
+}
+
+mrb_int
+mrb_proc_arity(const struct RProc *p)
+{
+  const mrb_irep *irep;
+  const mrb_code *pc;
+  mrb_aspec aspec;
+  int ma, op, ra, pa, arity;
+
+  if (MRB_PROC_CFUNC_P(p)) {
+    /* TODO cfunc aspec not implemented yet */
+    return -1;
+  }
+
+  irep = p->body.irep;
+  if (!irep) {
+    return 0;
+  }
+
+  pc = irep->iseq;
+  /* arity is depend on OP_ENTER */
+  if (*pc != OP_ENTER) {
+    return 0;
+  }
+
+  aspec = PEEK_W(pc+1);
+  ma = MRB_ASPEC_REQ(aspec);
+  op = MRB_ASPEC_OPT(aspec);
+  ra = MRB_ASPEC_REST(aspec);
+  pa = MRB_ASPEC_POST(aspec);
+  arity = ra || (MRB_PROC_STRICT_P(p) && op) ? -(ma + pa + 1) : ma + pa;
+
+  return arity;
+}
+
+mrb_value
+mrb_proc_local_variables(mrb_state *mrb, const struct RProc *proc)
+{
+  if (proc == NULL || MRB_PROC_CFUNC_P(proc)) {
+    return mrb_ary_new(mrb);
+  }
+  mrb_value vars = mrb_hash_new(mrb);
+  while (proc) {
+    if (MRB_PROC_CFUNC_P(proc)) break;
+    const mrb_irep *irep = proc->body.irep;
+    if (irep->lv) {
+      for (size_t i = 0; i + 1 < irep->nlocals; i++) {
+        if (irep->lv[i]) {
+          mrb_sym sym = irep->lv[i];
+          const char *name = mrb_sym_name(mrb, sym);
+          switch (name[0]) {
+          case '*': case '&':
+            break;
+          default:
+            mrb_hash_set(mrb, vars, mrb_symbol_value(sym), mrb_true_value());
+            break;
+          }
+        }
+      }
+    }
+    if (MRB_PROC_SCOPE_P(proc)) break;
+    proc = proc->upper;
+  }
+
+  return mrb_hash_keys(mrb, vars);
+}
+
+const struct RProc *
+mrb_proc_get_caller(mrb_state *mrb, struct REnv **envp)
+{
+  struct mrb_context *c = mrb->c;
+  mrb_callinfo *ci = (c->ci > c->cibase) ? c->ci - 1 : c->cibase;
+  const struct RProc *proc = ci->proc;
+
+  if (!proc || MRB_PROC_CFUNC_P(proc)) {
+    if (envp) *envp = NULL;
+  }
+  else {
+    struct REnv *e = mrb_vm_ci_env(ci);
+
+    if (e == NULL) {
+      int nstacks = proc->body.irep->nlocals;
+      e = mrb_env_new(mrb, c, ci, nstacks, ci->stack, mrb_vm_ci_target_class(ci));
+      ci->u.env = e;
+    }
+    if (envp) *envp = e;
+  }
+
+  return proc;
+}
+
+#define IREP_LVAR_MERGE_DEFAULT  50
+#define IREP_LVAR_MERGE_MINIMUM   8
+#define IREP_LVAR_MERGE_MAXIMUM 240
+
+#ifdef MRB_IREP_LVAR_MERGE_LIMIT
+# define IREP_LVAR_MERGE_LIMIT \
+  ((MRB_IREP_LVAR_MERGE_LIMIT) < IREP_LVAR_MERGE_MINIMUM ? IREP_LVAR_MERGE_MINIMUM : \
+   (MRB_IREP_LVAR_MERGE_LIMIT) > IREP_LVAR_MERGE_MAXIMUM ? IREP_LVAR_MERGE_MAXIMUM : \
+   (MRB_IREP_LVAR_MERGE_LIMIT))
+#else
+# define IREP_LVAR_MERGE_LIMIT IREP_LVAR_MERGE_DEFAULT
+#endif
+
+void
+mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, const mrb_sym *lv, const mrb_value *stack)
+{
+  mrb_assert(!(irep->flags & MRB_IREP_NO_FREE));
+
+  if ((irep->nlocals + num) > IREP_LVAR_MERGE_LIMIT) {
+    mrb_raise(mrb, E_RUNTIME_ERROR, "too many local variables for binding (mruby limitation)");
+  }
+
+  if (!lv) {
+    mrb_raise(mrb, E_RUNTIME_ERROR, "unavailable local variable names");
+  }
+
+  irep->lv = (mrb_sym*)mrb_realloc(mrb, (mrb_sym*)irep->lv, sizeof(mrb_sym) * (irep->nlocals - 1 /* self */ + num));
+  env->stack = (mrb_value*)mrb_realloc(mrb, env->stack, sizeof(mrb_value) * (irep->nlocals + num));
+
+  mrb_sym *destlv = (mrb_sym*)irep->lv + irep->nlocals - 1 /* self */;
+  mrb_value *destst = env->stack + irep->nlocals;
+  memmove(destlv, lv, sizeof(mrb_sym) * num);
+  if (stack) {
+    memmove(destst, stack, sizeof(mrb_value) * num);
+    for (int i = 0; i < num; i++) {
+      if (!mrb_immediate_p(stack[i])) {
+        mrb_field_write_barrier(mrb, (struct RBasic*)env, (struct RBasic*)mrb_obj_ptr(stack[i]));
+      }
+    }
+  }
+  else {
+    for (int i = num; i > 0; i--, destst++) {
+      *destst = mrb_nil_value();
+    }
+  }
+  irep->nlocals += num;
+  irep->nregs = irep->nlocals;
+  MRB_ENV_SET_LEN(env, irep->nlocals);
+}
+
+/* ---------------------------*/
+static const mrb_mt_entry proc_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_proc_init_copy, MRB_SYM(initialize_copy), MRB_ARGS_REQ(1) | MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(proc_arity,         MRB_SYM(arity),        MRB_ARGS_NONE()),  /* 15.2.17.4.2 */
+  MRB_MT_ENTRY(proc_eql,           MRB_OPSYM(eq), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(proc_eql,           MRB_SYM_Q(eql), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(proc_hash,          MRB_SYM(hash),         MRB_ARGS_NONE()),  /* 15.2.17.4.2 */
+};
+
+void
+mrb_init_proc(mrb_state *mrb)
+{
+  mrb_method_t m;
+  struct RClass *pc = mrb->proc_class = mrb_define_class_id(mrb, MRB_SYM(Proc), mrb->object_class); /* 15.2.17 */
+
+  MRB_SET_INSTANCE_TT(pc, MRB_TT_PROC);
+  MRB_UNDEF_ALLOCATOR(pc);
+  mrb_define_class_method_id(mrb, pc, MRB_SYM(new), mrb_proc_s_new, MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
+  MRB_MT_INIT_ROM(mrb, pc, proc_rom_entries);
+
+  MRB_METHOD_FROM_PROC(m, &call_proc);
+  mrb_define_method_raw(mrb, pc, MRB_SYM(call), m);   /* 15.2.17.4.3 */
+  mrb_define_method_raw(mrb, pc, MRB_OPSYM(aref), m); /* 15.2.17.4.1 */
+
+  mrb_define_private_method_id(mrb, mrb->kernel_module, MRB_SYM(lambda), proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.3.27 */
+}