enclave 0.1.0

data/ext/enclave/mruby/include/mruby/object.h

@@ -0,0 +1,44 @@
+/**
+** @file mruby/object.h - mruby object definition
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_OBJECT_H
+#define MRUBY_OBJECT_H
+
+#define MRB_OBJECT_HEADER \
+  struct RClass *c;       \
+  enum mrb_vtype tt:8;    \
+  unsigned int gc_color:3; \
+  unsigned int frozen:1;  \
+  uint32_t flags:20
+
+#define MRB_FLAG_TEST(obj, flag) ((obj)->flags & (flag))
+
+struct RBasic {
+  MRB_OBJECT_HEADER;
+};
+#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
+
+#define MRB_OBJ_IS_FROZEN 1
+#define mrb_frozen_p(o) ((o)->frozen)
+
+struct RObject {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+};
+#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
+
+#define mrb_special_const_p(x) mrb_immediate_p(x)
+
+struct RFiber {
+  MRB_OBJECT_HEADER;
+  struct mrb_context *cxt;
+};
+
+#define mrb_static_assert_object_size(st) \
+  mrb_static_assert(sizeof(st) <= sizeof(void*) * 5, \
+                    #st " size must be within 5 words")
+
+#endif  /* MRUBY_OBJECT_H */

data/ext/enclave/mruby/include/mruby/opcode.h

@@ -0,0 +1,73 @@
+/**
+** @file mruby/opcode.h - RiteVM operation codes
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_OPCODE_H
+#define MRUBY_OPCODE_H
+
+enum mrb_insn {
+#define OPCODE(x,_) OP_ ## x,
+#include <mruby/ops.h>
+#undef OPCODE
+};
+
+/* backward compatibility aliases */
+#define OP_LOADT OP_LOADTRUE
+#define OP_LOADF OP_LOADFALSE
+
+#define OP_L_STRICT  1
+#define OP_L_CAPTURE 2
+#define OP_L_METHOD  OP_L_STRICT
+#define OP_L_LAMBDA  (OP_L_STRICT|OP_L_CAPTURE)
+#define OP_L_BLOCK   OP_L_CAPTURE
+
+#define PEEK_B(pc) (*(pc))
+#define PEEK_S(pc) ((pc)[0]<<8|(pc)[1])
+#define PEEK_W(pc) ((pc)[0]<<16|(pc)[1]<<8|(pc)[2])
+
+#define READ_B() PEEK_B(pc++)
+#define READ_S() (pc+=2, PEEK_S(pc-2))
+#define READ_W() (pc+=3, PEEK_W(pc-3))
+
+#define FETCH_Z() /* nothing */
+#define FETCH_B() do {a=READ_B();} while (0)
+#define FETCH_BB() do {a=READ_B(); b=READ_B();} while (0)
+#define FETCH_BBB() do {a=READ_B(); b=READ_B(); c=READ_B();} while (0)
+#define FETCH_BS() do {a=READ_B(); b=READ_S();} while (0)
+#define FETCH_BSS() do {a=READ_B(); b=READ_S(); c=READ_S();} while (0)
+#define FETCH_S() do {a=READ_S();} while (0)
+#define FETCH_W() do {a=READ_W();} while (0)
+
+/* with OP_EXT1 (1st 16bit) */
+#define FETCH_Z_1() FETCH_Z()
+#define FETCH_B_1() FETCH_S()
+#define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0)
+#define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0)
+#define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0)
+#define FETCH_BSS_1() do {a=READ_S(); b=READ_S();c=READ_S();} while (0)
+#define FETCH_S_1() FETCH_S()
+#define FETCH_W_1() FETCH_W()
+
+/* with OP_EXT2 (2nd 16bit) */
+#define FETCH_Z_2() FETCH_Z()
+#define FETCH_B_2() FETCH_B()
+#define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0)
+#define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0)
+#define FETCH_BS_2() FETCH_BS()
+#define FETCH_BSS_2() FETCH_BSS()
+#define FETCH_S_2() FETCH_S()
+#define FETCH_W_2() FETCH_W()
+
+/* with OP_EXT3 (1st & 2nd 16bit) */
+#define FETCH_Z_3() FETCH_Z()
+#define FETCH_B_3() FETCH_B()
+#define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0)
+#define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0)
+#define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0)
+#define FETCH_BSS_3() FETCH_BSS_1()
+#define FETCH_S_3() FETCH_S()
+#define FETCH_W_3() FETCH_W()
+
+#endif  /* MRUBY_OPCODE_H */

data/ext/enclave/mruby/include/mruby/ops.h

@@ -0,0 +1,133 @@
+/* operand types:
+   + Z: no operand
+   + B: 8bit
+   + BB: 8+8bit
+   + BBB: 8+8+8bit
+   + BS: 8+16bit
+   + BSS: 8+16+16bit
+   + S: 16bit
+   + W: 24bit
+*/
+
+/*-----------------------------------------------------------------------
+operation code    operands      semantics
+------------------------------------------------------------------------*/
+OPCODE(NOP,        Z)        /* no operation */
+OPCODE(MOVE,       BB)       /* R[a] = R[b] */
+OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
+OPCODE(LOADI8,     BB)       /* R[a] = mrb_int(b) */
+OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
+OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
+OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
+OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
+OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
+OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
+OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
+OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
+OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
+OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
+OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
+OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
+OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
+OPCODE(LOADNIL,    B)        /* R[a] = nil */
+OPCODE(LOADSELF,   B)        /* R[a] = self */
+OPCODE(LOADTRUE,   B)        /* R[a] = true */
+OPCODE(LOADFALSE,  B)        /* R[a] = false */
+OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
+OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
+OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
+OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
+OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
+OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
+OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
+OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
+OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
+OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
+OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
+OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
+OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
+OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
+OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
+OPCODE(GETIDX0,    BB)       /* R[a] = R[b][0]; a+1 for method call */
+OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
+OPCODE(JMP,        S)        /* pc+=a */
+OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
+OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
+OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
+OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
+OPCODE(EXCEPT,     B)        /* R[a] = exc */
+OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
+OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
+OPCODE(MATCHERR,   B)        /* raise NoMatchingPatternError unless R[a] */
+OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
+OPCODE(SSEND0,     BB)       /* R[a] = self.send(Syms[b]) (no args) */
+OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
+OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
+OPCODE(SEND0,      BB)       /* R[a] = R[a].send(Syms[b]) (no args) */
+OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
+OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
+OPCODE(BLKCALL,    BB)       /* R[a] = R[a].call(R[a+1],... ,R[a+b]); direct block call */
+OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
+OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
+OPCODE(ENTER,      W)        /* arg setup according to flags (24=n1:m5:o5:r1:m5:k5:d1:b1) */
+OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
+OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
+OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
+OPCODE(RETURN,     B)        /* return R[a] (normal) */
+OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
+OPCODE(RETSELF,    Z)        /* return self */
+OPCODE(RETNIL,     Z)        /* return nil */
+OPCODE(RETTRUE,    Z)        /* return true */
+OPCODE(RETFALSE,   Z)        /* return false */
+OPCODE(BREAK,      B)        /* break R[a] */
+OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
+OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
+OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
+OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
+OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
+OPCODE(ADDILV,     BBB)      /* R[a] = R[a]+mrb_int(c); R[b],R[b+1] for method call */
+OPCODE(SUBILV,     BBB)      /* R[a] = R[a]-mrb_int(c); R[b],R[b+1] for method call */
+OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
+OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
+OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
+OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
+OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
+OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
+OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
+OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
+OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
+OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
+OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
+OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
+OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
+OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
+OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
+OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
+OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
+OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
+OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
+OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
+OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
+OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
+OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
+OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
+OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
+OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
+OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
+OPCODE(OCLASS,     B)        /* R[a] = ::Object */
+OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
+OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
+OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
+OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
+OPCODE(TDEF,       BBB)      /* target_class.newmethod(Syms[b],Irep[c]); R[a] = Syms[b] */
+OPCODE(SDEF,       BBB)      /* R[a].singleton_class.newmethod(Syms[b],Irep[c]); R[a] = Syms[b] */
+OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
+OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
+OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
+OPCODE(TCLASS,     B)        /* R[a] = target_class */
+OPCODE(DEBUG,      BBB)      /* print a,b,c */
+OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
+OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
+OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
+OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
+OPCODE(STOP,       Z)        /* stop VM */

data/ext/enclave/mruby/include/mruby/presym/scanning.h

@@ -0,0 +1,82 @@
+/**
+** @file mruby/presym/scanning.h - Scanning Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_SCANNING_H
+#define MRUBY_PRESYM_SCANNING_H
+
+#define MRB_PRESYM_SCANNING_TAGGED(arg) <@! arg !@>
+
+#undef mrb_intern_lit
+#define mrb_intern_lit(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_intern_cstr(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_define_method(mrb, c, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (c) (__VA_ARGS__)
+#define mrb_define_class_method(mrb, c, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (c) (__VA_ARGS__)
+#define mrb_define_singleton_method(mrb, c, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (c) (__VA_ARGS__)
+#define mrb_define_class(mrb, name, s) MRB_PRESYM_SCANNING_TAGGED(name) (s)
+#define mrb_define_class_under(mrb, o, name, s) MRB_PRESYM_SCANNING_TAGGED(name) (o) (s)
+#define mrb_define_module(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_define_module_under(mrb, o, name) MRB_PRESYM_SCANNING_TAGGED(name) (o)
+#define mrb_define_module_function(mrb, c, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (c) (__VA_ARGS__)
+#define mrb_define_const(mrb, c, name, v) MRB_PRESYM_SCANNING_TAGGED(name) (c) (v)
+#define mrb_define_global_const(mrb, name, v) MRB_PRESYM_SCANNING_TAGGED(name) (v)
+#define mrb_define_alias(mrb, c, a, b) MRB_PRESYM_SCANNING_TAGGED(a) MRB_PRESYM_SCANNING_TAGGED(b) (c)
+#define mrb_class_get(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_class_get_under(mrb, outer, name) MRB_PRESYM_SCANNING_TAGGED(name) (outer)
+#define mrb_module_get(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_module_get_under(mrb, outer, name) MRB_PRESYM_SCANNING_TAGGED(name) (outer)
+#define mrb_funcall(mrb, v, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (v) (__VA_ARGS__)
+
+#define MRB_OPSYM(name) MRB_OPSYM__##name(mrb)
+#define MRB_GVSYM(name) MRB_PRESYM_SCANNING_TAGGED("$" #name)
+#define MRB_CVSYM(name) MRB_PRESYM_SCANNING_TAGGED("@@" #name)
+#define MRB_IVSYM(name) MRB_PRESYM_SCANNING_TAGGED("@" #name)
+#define MRB_SYM_B(name) MRB_PRESYM_SCANNING_TAGGED(#name "!")
+#define MRB_SYM_Q(name) MRB_PRESYM_SCANNING_TAGGED(#name "?")
+#define MRB_SYM_E(name) MRB_PRESYM_SCANNING_TAGGED(#name "=")
+#define MRB_SYM(name) MRB_PRESYM_SCANNING_TAGGED(#name)
+
+/* backward compatibility: _2 variants accept but ignore mrb_state* */
+#define MRB_OPSYM_2(mrb, name) MRB_OPSYM(name)
+#define MRB_GVSYM_2(mrb, name) MRB_GVSYM(name)
+#define MRB_CVSYM_2(mrb, name) MRB_CVSYM(name)
+#define MRB_IVSYM_2(mrb, name) MRB_IVSYM(name)
+#define MRB_SYM_B_2(mrb, name) MRB_SYM_B(name)
+#define MRB_SYM_Q_2(mrb, name) MRB_SYM_Q(name)
+#define MRB_SYM_E_2(mrb, name) MRB_SYM_E(name)
+#define MRB_SYM_2(mrb, name) MRB_SYM(name)
+
+#define MRB_OPSYM__not(mrb) MRB_PRESYM_SCANNING_TAGGED("!")
+#define MRB_OPSYM__mod(mrb) MRB_PRESYM_SCANNING_TAGGED("%")
+#define MRB_OPSYM__and(mrb) MRB_PRESYM_SCANNING_TAGGED("&")
+#define MRB_OPSYM__mul(mrb) MRB_PRESYM_SCANNING_TAGGED("*")
+#define MRB_OPSYM__add(mrb) MRB_PRESYM_SCANNING_TAGGED("+")
+#define MRB_OPSYM__sub(mrb) MRB_PRESYM_SCANNING_TAGGED("-")
+#define MRB_OPSYM__div(mrb) MRB_PRESYM_SCANNING_TAGGED("/")
+#define MRB_OPSYM__lt(mrb) MRB_PRESYM_SCANNING_TAGGED("<")
+#define MRB_OPSYM__gt(mrb) MRB_PRESYM_SCANNING_TAGGED(">")
+#define MRB_OPSYM__xor(mrb) MRB_PRESYM_SCANNING_TAGGED("^")
+#define MRB_OPSYM__tick(mrb) MRB_PRESYM_SCANNING_TAGGED("`")
+#define MRB_OPSYM__or(mrb) MRB_PRESYM_SCANNING_TAGGED("|")
+#define MRB_OPSYM__neg(mrb) MRB_PRESYM_SCANNING_TAGGED("~")
+#define MRB_OPSYM__neq(mrb) MRB_PRESYM_SCANNING_TAGGED("!=")
+#define MRB_OPSYM__nmatch(mrb) MRB_PRESYM_SCANNING_TAGGED("!~")
+#define MRB_OPSYM__andand(mrb) MRB_PRESYM_SCANNING_TAGGED("&&")
+#define MRB_OPSYM__pow(mrb) MRB_PRESYM_SCANNING_TAGGED("**")
+#define MRB_OPSYM__plus(mrb) MRB_PRESYM_SCANNING_TAGGED("+@")
+#define MRB_OPSYM__minus(mrb) MRB_PRESYM_SCANNING_TAGGED("-@")
+#define MRB_OPSYM__lshift(mrb) MRB_PRESYM_SCANNING_TAGGED("<<")
+#define MRB_OPSYM__le(mrb) MRB_PRESYM_SCANNING_TAGGED("<=")
+#define MRB_OPSYM__eq(mrb) MRB_PRESYM_SCANNING_TAGGED("==")
+#define MRB_OPSYM__match(mrb) MRB_PRESYM_SCANNING_TAGGED("=~")
+#define MRB_OPSYM__ge(mrb) MRB_PRESYM_SCANNING_TAGGED(">=")
+#define MRB_OPSYM__rshift(mrb) MRB_PRESYM_SCANNING_TAGGED(">>")
+#define MRB_OPSYM__aref(mrb) MRB_PRESYM_SCANNING_TAGGED("[]")
+#define MRB_OPSYM__oror(mrb) MRB_PRESYM_SCANNING_TAGGED("||")
+#define MRB_OPSYM__cmp(mrb) MRB_PRESYM_SCANNING_TAGGED("<=>")
+#define MRB_OPSYM__eqq(mrb) MRB_PRESYM_SCANNING_TAGGED("===")
+#define MRB_OPSYM__aset(mrb) MRB_PRESYM_SCANNING_TAGGED("[]=")
+
+#endif  /* MRUBY_PRESYM_SCANNING_H */

data/ext/enclave/mruby/include/mruby/presym.h

@@ -0,0 +1,65 @@
+/**
+** @file mruby/presym.h - Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_H
+#define MRUBY_PRESYM_H
+
+#if !defined(MRB_PRESYM_SCANNING)
+
+#include <mruby/presym/id.h>
+
+/*
+ * Where `mrb_intern_lit` is allowed for symbol interning, it is directly
+ * replaced by the symbol ID using the following macros.
+ *
+ *   MRB_OPSYM(xor)  //=> ^      (Operator)
+ *   MRB_GVSYM(xor)  //=> $xor   (Global Variable)
+ *   MRB_CVSYM(xor)  //=> @@xor  (Class Variable)
+ *   MRB_IVSYM(xor)  //=> @xor   (Instance Variable)
+ *   MRB_SYM_B(xor)  //=> xor!   (Method with Bang)
+ *   MRB_SYM_Q(xor)  //=> xor?   (Method with Question mark)
+ *   MRB_SYM_E(xor)  //=> xor=   (Method with Equal)
+ *   MRB_SYM(xor)    //=> xor    (Word characters)
+ *
+ * For `MRB_OPSYM`, specify the names corresponding to operators (see
+ * `MRuby::Presym::OPERATORS` in `lib/mruby/presym.rb` for the names that
+ * can be specified for it). Other than that, describe only word characters
+ * excluding leading and ending punctuation.
+ *
+ * These macros are expanded to compile-time integer constants.
+ */
+
+#define MRB_OPSYM(name) MRB_OPSYM__##name
+#define MRB_GVSYM(name) MRB_GVSYM__##name
+#define MRB_CVSYM(name) MRB_CVSYM__##name
+#define MRB_IVSYM(name) MRB_IVSYM__##name
+#define MRB_SYM_B(name) MRB_SYM_B__##name
+#define MRB_SYM_Q(name) MRB_SYM_Q__##name
+#define MRB_SYM_E(name) MRB_SYM_E__##name
+#define MRB_SYM(name) MRB_SYM__##name
+
+/* backward compatibility: _2 variants accept but ignore mrb_state* */
+#define MRB_OPSYM_2(mrb, name) MRB_OPSYM(name)
+#define MRB_GVSYM_2(mrb, name) MRB_GVSYM(name)
+#define MRB_CVSYM_2(mrb, name) MRB_CVSYM(name)
+#define MRB_IVSYM_2(mrb, name) MRB_IVSYM(name)
+#define MRB_SYM_B_2(mrb, name) MRB_SYM_B(name)
+#define MRB_SYM_Q_2(mrb, name) MRB_SYM_Q(name)
+#define MRB_SYM_E_2(mrb, name) MRB_SYM_E(name)
+#define MRB_SYM_2(mrb, name) MRB_SYM(name)
+
+#define MRB_PRESYM_DEFINE_VAR_AND_INITER(name, size, ...)                     \
+  static const mrb_sym name[] = {__VA_ARGS__};
+
+#define MRB_PRESYM_INIT_SYMBOLS(mrb, name) (void)(mrb)
+
+/* use MRB_SYM() for E_RUNTIME_ERROR etc. */
+#undef MRB_ERROR_SYM
+#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
+
+#endif  /* !MRB_PRESYM_SCANNING */
+
+#endif  /* MRUBY_PRESYM_H */

data/ext/enclave/mruby/include/mruby/proc.h

@@ -0,0 +1,184 @@
+/**
+** @file mruby/proc.h - Proc class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PROC_H
+#define MRUBY_PROC_H
+
+#include "common.h"
+#include <mruby/irep.h>
+#include <string.h>
+
+/**
+ * Proc class
+ */
+MRB_BEGIN_DECL
+
+/*
+ * env object (for internal used)
+ *
+ * - don't create multiple envs on one ci.
+ * - don't share a env to different ci.
+ * - don't attach a closed env to any ci.
+ */
+struct REnv {
+  MRB_OBJECT_HEADER;
+  mrb_value *stack;
+  struct mrb_context *cxt; /* if not null, it means that the stack is shared with the call frame */
+  mrb_sym mid;
+};
+
+/* flags (20bits): 1(ZERO):1(separate module):2(visibility):8(cioff/bidx):8(stack_len) */
+#define MRB_ENV_SET_LEN(e,len) ((e)->flags = (((e)->flags & ~0xff)|((unsigned int)(len) & 0xff)))
+#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
+#define MRB_ENV_CLOSE(e) ((e)->cxt = NULL)
+#define MRB_ENV_ONSTACK_P(e) ((e)->cxt != NULL)
+#define MRB_ENV_BIDX(e) (((e)->flags >> 8) & 0xff)
+#define MRB_ENV_SET_BIDX(e,idx) ((e)->flags = (((e)->flags & ~(0xff<<8))|((unsigned int)(idx) & 0xff)<<8))
+#define MRB_ENV_SET_VISIBILITY(e, vis) MRB_FLAGS_SET((e)->flags, 16, 2, vis)
+#define MRB_ENV_VISIBILITY(e) MRB_FLAGS_GET((e)->flags, 16, 2)
+#define MRB_ENV_VISIBILITY_BREAK_P(e) MRB_FLAG_CHECK((e)->flags, 18)
+#define MRB_ENV_COPY_FLAGS_FROM_CI(e, ci) MRB_FLAGS_SET((e)->flags, 16, 3, (ci)->vis)
+
+/*
+ * Returns TRUE on success.
+ * If the function fails:
+ * * Returns FALSE if noraise is TRUE.
+ * * Raises a NoMemoryError exception if noraise is FALSE.
+ */
+mrb_bool mrb_env_unshare(mrb_state*, struct REnv*, mrb_bool noraise);
+
+struct RProc {
+  MRB_OBJECT_HEADER;
+  union {
+    const mrb_irep *irep;
+    mrb_func_t func;
+    mrb_sym mid;
+  } body;
+  const struct RProc *upper;
+  union {
+    struct RClass *target_class;
+    struct REnv *env;
+  } e;
+};
+
+/* aspec access */
+#define MRB_ASPEC_REQ(a)          (((a) >> 18) & 0x1f)
+#define MRB_ASPEC_OPT(a)          (((a) >> 13) & 0x1f)
+#define MRB_ASPEC_REST(a)         (((a) >> 12) & 0x1)
+#define MRB_ASPEC_POST(a)         (((a) >> 7) & 0x1f)
+#define MRB_ASPEC_KEY(a)          (((a) >> 2) & 0x1f)
+#define MRB_ASPEC_KDICT(a)        (((a) >> 1) & 0x1)
+#define MRB_ASPEC_BLOCK(a)        ((a) & 1)
+#define MRB_ASPEC_NOBLOCK(a)      (((a) >> 23) & 0x1)
+
+#define MRB_PROC_CFUNC_FL 128
+#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
+#define MRB_PROC_CFUNC(p) (p)->body.func
+#define MRB_PROC_STRICT 256
+#define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
+#define MRB_PROC_ORPHAN 512
+#define MRB_PROC_ORPHAN_P(p) (((p)->flags & MRB_PROC_ORPHAN) != 0)
+#define MRB_PROC_ENVSET 1024
+#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
+#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
+#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
+#define MRB_PROC_SET_TARGET_CLASS(p,tc) do {\
+  if (MRB_PROC_ENV_P(p)) {\
+    (p)->e.env->c = (tc);\
+    mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)(tc));\
+  }\
+  else {\
+    (p)->e.target_class = (tc);\
+    mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)(tc));\
+  }\
+} while (0)
+#define MRB_PROC_SCOPE 2048
+#define MRB_PROC_SCOPE_P(p) (((p)->flags & MRB_PROC_SCOPE) != 0)
+#define MRB_PROC_NOARG 4096 /* for MRB_PROC_CFUNC_FL, aspec == MRB_ARGS_NONE() */
+#define MRB_PROC_NOARG_P(p) (((p)->flags & MRB_PROC_NOARG) != 0)
+#define MRB_PROC_ALIAS 8192
+#define MRB_PROC_ALIAS_P(p) (((p)->flags & MRB_PROC_ALIAS) != 0)
+
+#define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
+
+struct RProc *mrb_proc_new(mrb_state*, const mrb_irep*);
+MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
+MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals);
+
+/* following functions are defined in mruby-proc-ext so please include it when using */
+MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const mrb_value *argv);
+MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
+/* old name */
+#define mrb_cfunc_env_get(mrb, idx) mrb_proc_cfunc_env_get(mrb, idx)
+
+#define MRB_METHOD_FUNC_FL    (1 << 24)
+#define MRB_METHOD_PUBLIC_FL  0
+#define MRB_METHOD_PRIVATE_FL (1 << 25)
+#define MRB_METHOD_PROTECTED_FL (1 << 26)
+#define MRB_METHOD_VDEFAULT_FL ((1 << 25) | (1 << 26))
+#define MRB_METHOD_VISIBILITY_MASK ((1 << 25) | (1 << 26))
+
+#define MRB_METHOD_FUNC_P(m) ((m).flags&MRB_METHOD_FUNC_FL)
+#define MRB_METHOD_FUNC(m) ((m).as.func)
+#define MRB_METHOD_FROM_FUNC(m,fn) do{(m).flags=MRB_METHOD_FUNC_FL;(m).as.func=(fn);}while(0)
+#define MRB_METHOD_FROM_PROC(m,pr) do{(m).flags=0;(m).as.proc=(pr);}while(0)
+#define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
+#define MRB_METHOD_PROC(m) ((m).as.proc)
+#define MRB_METHOD_UNDEF_P(m) ((m).as.proc==NULL)
+#define MRB_METHOD_VISIBILITY(m) ((m).flags & MRB_METHOD_VISIBILITY_MASK)
+#define MRB_SET_VISIBILITY_FLAGS(f,v) ((f)=(((f)&~MRB_METHOD_VISIBILITY_MASK)|(v)))
+#define MRB_METHOD_SET_VISIBILITY(m,v) MRB_SET_VISIBILITY_FLAGS((m).flags,(v))
+
+#define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m) || (MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
+/* use MRB_METHOD_CFUNC(m) only when MRB_METHOD_CFUNC_P(m) is true */
+#define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):MRB_PROC_CFUNC(MRB_METHOD_PROC(m)))
+
+MRB_API mrb_value mrb_load_proc(mrb_state *mrb, const struct RProc *proc);
+
+/**
+ *  It can be used to isolate top-level scopes referenced by blocks generated by
+ *  `mrb_load_string_cxt()` or similar called before entering the mruby VM (e.g. from `main()`).
+ *  In that case, the `ci` parameter should be `mrb->c->cibase`.
+ *
+ *      #include <mruby.h>
+ *      #include <mruby/compile.h>
+ *      #include <mruby/proc.h>
+ *
+ *      int
+ *      main(int argc, char **argv)
+ *      {
+ *        mrb_state *mrb;
+ *        mrb_ccontext *cxt;
+ *        mrb_value blk, ret;
+ *
+ *        mrb = mrb_open();
+ *        cxt = mrb_ccontext_new(mrb);
+ *        blk = mrb_load_string_cxt(mrb, "x, y, z = 1, 2, 3; proc { [x, y, z] }", cxt);
+ *        mrb_vm_ci_env_clear(mrb, mrb->c->cibase);
+ *        mrb_load_string_cxt(mrb, "x, y, z = 4, 5, 6", cxt);
+ *        ret = mrb_funcall(mrb, blk, "call", 0);
+ *        mrb_p(mrb, ret);  // => [1, 2, 3]
+ *                          // => [4, 5, 6] if `mrb_vm_ci_env_clear()` is commented out
+ *        mrb_ccontext_free(mrb, cxt);
+ *        mrb_close(mrb);
+ *
+ *        return 0;
+ *      }
+ *
+ *  The top-level local variable names stored in `mrb_ccontext` are retained.
+ *  Use also `mrb_ccontext_cleanup_local_variables()` at the same time, if necessary.
+ */
+MRB_API void mrb_vm_ci_env_clear(mrb_state *mrb, mrb_callinfo *ci);
+
+void mrb_vm_ci_proc_set(mrb_callinfo *ci, const struct RProc *p);
+struct RClass * mrb_vm_ci_target_class(const mrb_callinfo *ci);
+void mrb_vm_ci_target_class_set(mrb_callinfo *ci, struct RClass *tc);
+struct REnv * mrb_vm_ci_env(const mrb_callinfo *ci);
+void mrb_vm_ci_env_set(mrb_callinfo *ci, struct REnv *e);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_PROC_H */

data/ext/enclave/mruby/include/mruby/range.h

@@ -0,0 +1,77 @@
+/**
+** @file mruby/range.h - Range class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_RANGE_H
+#define MRUBY_RANGE_H
+
+#include "common.h"
+
+/**
+ * Range class
+ */
+MRB_BEGIN_DECL
+
+#if defined(MRB_NAN_BOXING) && defined(MRB_64BIT) || defined(MRB_WORD_BOXING)
+# define MRB_RANGE_EMBED
+#endif
+
+#ifdef MRB_RANGE_EMBED
+struct RRange {
+  MRB_OBJECT_HEADER;
+  mrb_value beg;
+  mrb_value end;
+  mrb_bool excl;
+};
+# define mrb_gc_free_range(mrb, p) ((void)0)
+# define RANGE_BEG(p) ((p)->beg)
+# define RANGE_END(p) ((p)->end)
+#else
+typedef struct mrb_range_edges {
+  mrb_value beg;
+  mrb_value end;
+} mrb_range_edges;
+struct RRange {
+  MRB_OBJECT_HEADER;
+  mrb_range_edges *edges;
+  mrb_bool excl;
+};
+# define mrb_gc_free_range(mrb, p) mrb_free(mrb, (p)->edges)
+# define RANGE_BEG(p) ((p)->edges->beg)
+# define RANGE_END(p) ((p)->edges->end)
+#endif
+
+#define mrb_range_beg(mrb, r) RANGE_BEG(mrb_range_ptr(mrb, r))
+#define mrb_range_end(mrb, r) RANGE_END(mrb_range_ptr(mrb, r))
+#define mrb_range_excl_p(mrb, r) RANGE_EXCL(mrb_range_ptr(mrb, r))
+#define mrb_range_raw_ptr(r) ((struct RRange*)mrb_ptr(r))
+#define mrb_range_value(p) mrb_obj_value((void*)(p))
+#define RANGE_EXCL(p) ((p)->excl)
+
+MRB_API struct RRange* mrb_range_ptr(mrb_state *mrb, mrb_value range);
+
+/*
+ * Initializes a Range.
+ *
+ * If the third parameter is FALSE then it includes the last value in the range.
+ * If the third parameter is TRUE then it excludes the last value in the range.
+ *
+ * @param start the beginning value.
+ * @param end the ending value.
+ * @param exclude represents the inclusion or exclusion of the last value.
+ */
+MRB_API mrb_value mrb_range_new(mrb_state *mrb, mrb_value start, mrb_value end, mrb_bool exclude);
+
+enum mrb_range_beg_len {
+  MRB_RANGE_TYPE_MISMATCH = 0,  /* (failure) not range */
+  MRB_RANGE_OK = 1,             /* (success) range */
+  MRB_RANGE_OUT = 2             /* (failure) out of range */
+};
+
+MRB_API enum mrb_range_beg_len mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_RANGE_H */

data/ext/enclave/mruby/include/mruby/re.h

@@ -0,0 +1,16 @@
+/**
+** @file mruby/re.h - Regexp class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_RE_H
+#define MRUBY_RE_H
+
+MRB_BEGIN_DECL
+
+#define REGEXP_CLASS          "Regexp"
+
+MRB_END_DECL
+
+#endif  /* RE_H */