portable_mruby 0.1.0

data/vendor/mruby/include/mruby/numeric.h

@@ -0,0 +1,174 @@
+/**
+** @file mruby/numeric.h - Numeric, Integer, Float class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_NUMERIC_H
+#define MRUBY_NUMERIC_H
+
+#include "common.h"
+
+/**
+ * Numeric class and it's sub-classes.
+ *
+ * Integer and Float
+ */
+MRB_BEGIN_DECL
+
+#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX)
+#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN)
+#define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
+#define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int)
+#define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int)
+#define FIXABLE(f) TYPED_FIXABLE(f,mrb_int)
+#ifndef MRB_NO_FLOAT
+#ifdef MRB_INT64
+#define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0)
+#else
+#define FIXABLE_FLOAT(f) TYPED_FIXABLE(f,mrb_float)
+#endif
+#endif
+
+/* utility functions */
+MRB_API mrb_value mrb_num_add(mrb_state *mrb, mrb_value x, mrb_value y);
+MRB_API mrb_value mrb_num_sub(mrb_state *mrb, mrb_value x, mrb_value y);
+MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y);
+/* obsolete old names */
+#define mrb_num_plus(mrb, x, y) mrb_num_add(mrb, x, y)
+#define mrb_num_minus(mrb, x, y) mrb_num_sub(mrb, x, y)
+
+MRB_API mrb_value mrb_integer_to_str(mrb_state *mrb, mrb_value x, mrb_int base);
+MRB_API char *mrb_int_to_cstr(char *buf, size_t len, mrb_int n, mrb_int base);
+
+/* obsolete function(s); will be removed */
+#define mrb_fixnum_to_str(mrb, x, base) mrb_integer_to_str(mrb, x, base)
+
+#ifndef __has_builtin
+  #define __has_builtin(x) 0
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ >= 5) ||   \
+    (__has_builtin(__builtin_add_overflow) && \
+     __has_builtin(__builtin_sub_overflow) && \
+     __has_builtin(__builtin_mul_overflow))
+# define MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
+#endif
+
+/*
+// Clang 3.8 and 3.9 have problem compiling mruby in 32-bit mode, when MRB_INT64 is set
+// because of missing __mulodi4 and similar functions in its runtime. We need to use custom
+// implementation for them.
+*/
+#ifdef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
+#if defined(__clang__) && (__clang_major__ == 3) && (__clang_minor__ >= 8) && \
+    defined(MRB_32BIT) && defined(MRB_INT64)
+#undef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
+#endif
+#endif
+
+#ifdef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
+
+static inline mrb_bool
+mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum)
+{
+  return __builtin_add_overflow(augend, addend, sum);
+}
+
+static inline mrb_bool
+mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference)
+{
+  return __builtin_sub_overflow(minuend, subtrahend, difference);
+}
+
+static inline mrb_bool
+mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
+{
+  return __builtin_mul_overflow(multiplier, multiplicand, product);
+}
+
+#else
+
+#define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1))
+
+static inline mrb_bool
+mrb_int_add_overflow(mrb_int a, mrb_int b, mrb_int *c)
+{
+  mrb_uint x = (mrb_uint)a;
+  mrb_uint y = (mrb_uint)b;
+  mrb_uint z = (mrb_uint)(x + y);
+  *c = (mrb_int)z;
+  return !!(((x ^ z) & (y ^ z)) & MRB_INT_OVERFLOW_MASK);
+}
+
+static inline mrb_bool
+mrb_int_sub_overflow(mrb_int a, mrb_int b, mrb_int *c)
+{
+  mrb_uint x = (mrb_uint)a;
+  mrb_uint y = (mrb_uint)b;
+  mrb_uint z = (mrb_uint)(x - y);
+  *c = (mrb_int)z;
+  return !!(((x ^ z) & (~y ^ z)) & MRB_INT_OVERFLOW_MASK);
+}
+
+static inline mrb_bool
+mrb_int_mul_overflow(mrb_int a, mrb_int b, mrb_int *c)
+{
+#ifdef MRB_INT32
+  int64_t n = (int64_t)a * b;
+  *c = (mrb_int)n;
+  return n > MRB_INT_MAX || n < MRB_INT_MIN;
+#else /* MRB_INT64 */
+  *c = a * b;
+  if (a > 0 && b > 0 && a > MRB_INT_MAX / b) return TRUE;
+  if (a < 0 && b > 0 && a < MRB_INT_MIN / b) return TRUE;
+  if (a > 0 && b < 0 && b < MRB_INT_MIN / a) return TRUE;
+  if (a < 0 && b < 0 && (a <= MRB_INT_MIN || b <= MRB_INT_MIN || -a > MRB_INT_MAX / -b))
+    return TRUE;
+  return FALSE;
+#endif
+}
+
+#undef MRB_INT_OVERFLOW_MASK
+
+#endif
+
+#ifndef MRB_NO_FLOAT
+
+# define MRB_FLT_RADIX          FLT_RADIX
+
+# ifdef MRB_USE_FLOAT32
+#  define MRB_FLT_MANT_DIG      FLT_MANT_DIG
+#  define MRB_FLT_EPSILON       FLT_EPSILON
+#  define MRB_FLT_DIG           FLT_DIG
+#  define MRB_FLT_MIN_EXP       FLT_MIN_EXP
+#  define MRB_FLT_MIN           FLT_MIN
+#  define MRB_FLT_MIN_10_EXP    FLT_MIN_10_EXP
+#  define MRB_FLT_MAX_EXP       FLT_MAX_EXP
+#  define MRB_FLT_MAX           FLT_MAX
+#  define MRB_FLT_MAX_10_EXP    FLT_MAX_10_EXP
+
+# else /* not MRB_USE_FLOAT32 */
+#  define MRB_FLT_MANT_DIG      DBL_MANT_DIG
+#  define MRB_FLT_EPSILON       DBL_EPSILON
+#  define MRB_FLT_DIG           DBL_DIG
+#  define MRB_FLT_MIN_EXP       DBL_MIN_EXP
+#  define MRB_FLT_MIN           DBL_MIN
+#  define MRB_FLT_MIN_10_EXP    DBL_MIN_10_EXP
+#  define MRB_FLT_MAX_EXP       DBL_MAX_EXP
+#  define MRB_FLT_MAX           DBL_MAX
+#  define MRB_FLT_MAX_10_EXP    DBL_MAX_10_EXP
+# endif /* MRB_USE_FLOAT32 */
+
+MRB_API mrb_value mrb_float_to_integer(mrb_state *mrb, mrb_value val);
+
+/* internal functions */
+mrb_float mrb_div_float(mrb_float x, mrb_float y);
+mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt);
+int mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, char sign);
+
+#endif /* MRB_NO_FLOAT */
+
+MRB_END_DECL
+
+#endif  /* MRUBY_NUMERIC_H */

data/vendor/mruby/include/mruby/object.h

@@ -0,0 +1,45 @@
+/**
+** @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;       \
+  struct RBasic *gcnext;  \
+  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*) * 6, \
+                    #st " size must be within 6 words")
+
+#endif  /* MRUBY_OBJECT_H */

data/vendor/mruby/include/mruby/opcode.h

@@ -0,0 +1,69 @@
+/**
+** @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
+};
+
+#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/vendor/mruby/include/mruby/ops.h

@@ -0,0 +1,120 @@
+/* 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(LOADT,      B)        /* R[a] = true */
+OPCODE(LOADF,      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(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(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
+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(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(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 (23=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(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(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(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/vendor/mruby/include/mruby/presym/disable.h

@@ -0,0 +1,72 @@
+/**
+** @file mruby/presym/disable.h - Disable Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_DISABLE_H
+#define MRUBY_PRESYM_DISABLE_H
+
+#include <string.h>
+
+#define MRB_PRESYM_MAX 0
+
+#define MRB_OPSYM(name) MRB_OPSYM__##name(mrb)
+#define MRB_GVSYM(name) mrb_intern_lit(mrb, "$" #name)
+#define MRB_CVSYM(name) mrb_intern_lit(mrb, "@@" #name)
+#define MRB_IVSYM(name) mrb_intern_lit(mrb, "@" #name)
+#define MRB_SYM_B(name) mrb_intern_lit(mrb, #name "!")
+#define MRB_SYM_Q(name) mrb_intern_lit(mrb, #name "?")
+#define MRB_SYM_E(name) mrb_intern_lit(mrb, #name "=")
+#define MRB_SYM(name) mrb_intern_lit(mrb, #name)
+
+#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name(mrb)
+#define MRB_GVSYM_2(mrb, name) mrb_intern_lit(mrb, "$" #name)
+#define MRB_CVSYM_2(mrb, name) mrb_intern_lit(mrb, "@@" #name)
+#define MRB_IVSYM_2(mrb, name) mrb_intern_lit(mrb, "@" #name)
+#define MRB_SYM_B_2(mrb, name) mrb_intern_lit(mrb, #name "!")
+#define MRB_SYM_Q_2(mrb, name) mrb_intern_lit(mrb, #name "?")
+#define MRB_SYM_E_2(mrb, name) mrb_intern_lit(mrb, #name "=")
+#define MRB_SYM_2(mrb, name) mrb_intern_lit(mrb, #name)
+
+#define MRB_OPSYM__not(mrb) mrb_intern_lit(mrb, "!")
+#define MRB_OPSYM__mod(mrb) mrb_intern_lit(mrb, "%")
+#define MRB_OPSYM__and(mrb) mrb_intern_lit(mrb, "&")
+#define MRB_OPSYM__mul(mrb) mrb_intern_lit(mrb, "*")
+#define MRB_OPSYM__add(mrb) mrb_intern_lit(mrb, "+")
+#define MRB_OPSYM__sub(mrb) mrb_intern_lit(mrb, "-")
+#define MRB_OPSYM__div(mrb) mrb_intern_lit(mrb, "/")
+#define MRB_OPSYM__lt(mrb) mrb_intern_lit(mrb, "<")
+#define MRB_OPSYM__gt(mrb) mrb_intern_lit(mrb, ">")
+#define MRB_OPSYM__xor(mrb) mrb_intern_lit(mrb, "^")
+#define MRB_OPSYM__tick(mrb) mrb_intern_lit(mrb, "`")
+#define MRB_OPSYM__or(mrb) mrb_intern_lit(mrb, "|")
+#define MRB_OPSYM__neg(mrb) mrb_intern_lit(mrb, "~")
+#define MRB_OPSYM__neq(mrb) mrb_intern_lit(mrb, "!=")
+#define MRB_OPSYM__nmatch(mrb) mrb_intern_lit(mrb, "!~")
+#define MRB_OPSYM__andand(mrb) mrb_intern_lit(mrb, "&&")
+#define MRB_OPSYM__pow(mrb) mrb_intern_lit(mrb, "**")
+#define MRB_OPSYM__plus(mrb) mrb_intern_lit(mrb, "+@")
+#define MRB_OPSYM__minus(mrb) mrb_intern_lit(mrb, "-@")
+#define MRB_OPSYM__lshift(mrb) mrb_intern_lit(mrb, "<<")
+#define MRB_OPSYM__le(mrb) mrb_intern_lit(mrb, "<=")
+#define MRB_OPSYM__eq(mrb) mrb_intern_lit(mrb, "==")
+#define MRB_OPSYM__match(mrb) mrb_intern_lit(mrb, "=~")
+#define MRB_OPSYM__ge(mrb) mrb_intern_lit(mrb, ">=")
+#define MRB_OPSYM__rshift(mrb) mrb_intern_lit(mrb, ">>")
+#define MRB_OPSYM__aref(mrb) mrb_intern_lit(mrb, "[]")
+#define MRB_OPSYM__oror(mrb) mrb_intern_lit(mrb, "||")
+#define MRB_OPSYM__cmp(mrb) mrb_intern_lit(mrb, "<=>")
+#define MRB_OPSYM__eqq(mrb) mrb_intern_lit(mrb, "===")
+#define MRB_OPSYM__aset(mrb) mrb_intern_lit(mrb, "[]=")
+
+#define MRB_PRESYM_DEFINE_VAR_AND_INITER(name, size, ...)                     \
+  static mrb_sym name[size];                                                  \
+  static void presym_init_##name(mrb_state *mrb) {                            \
+    mrb_sym name__[] = {__VA_ARGS__};                                         \
+    memcpy(name, name__, sizeof(name));                                       \
+  }
+
+#define MRB_PRESYM_INIT_SYMBOLS(mrb, name) presym_init_##name(mrb)
+
+#endif  /* MRUBY_PRESYM_DISABLE_H */

data/vendor/mruby/include/mruby/presym/enable.h

@@ -0,0 +1,39 @@
+/**
+** @file mruby/presym/enable.h - Enable Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_ENABLE_H
+#define MRUBY_PRESYM_ENABLE_H
+
+#include <mruby/presym/id.h>
+
+#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
+
+#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  /* MRUBY_PRESYM_ENABLE_H */