ruby2d 0.8.1 → 0.9.0

data/assets/tvos/MRuby.framework/Headers/mruby/irep.h

@@ -39,23 +39,36 @@ typedef struct mrb_irep {
 
   struct mrb_locals *lv;
   /* debug info */
-  mrb_bool own_filename;
-  const char *filename;
-  uint16_t *lines;
   struct mrb_irep_debug_info* debug_info;
 
-  int ilen, plen, slen, rlen, refcnt;
+  uint16_t ilen, plen, slen, rlen;
+  uint32_t refcnt;
 } mrb_irep;
 
 #define MRB_ISEQ_NO_FREE 1
 
 MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
+
+/* @param [const uint8_t*] irep code, expected as a literal */
 MRB_API mrb_value mrb_load_irep(mrb_state*, const uint8_t*);
+
+/* @param [const uint8_t*] irep code, expected as a literal */
 MRB_API mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*);
+
 void mrb_irep_free(mrb_state*, struct mrb_irep*);
 void mrb_irep_incref(mrb_state*, struct mrb_irep*);
 void mrb_irep_decref(mrb_state*, struct mrb_irep*);
 void mrb_irep_cutref(mrb_state*, struct mrb_irep*);
+void mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep);
+
+struct mrb_insn_data {
+  uint8_t insn;
+  uint16_t a;
+  uint16_t b;
+  uint8_t c;
+};
+
+struct mrb_insn_data mrb_decode_insn(mrb_code *pc);
 
 MRB_END_DECL
 

data/assets/tvos/MRuby.framework/Headers/mruby/object.h

@@ -22,11 +22,10 @@ struct RBasic {
 };
 #define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
 
-/* flags bits >= 18 is reserved */
-#define MRB_FLAG_IS_FROZEN (1 << 18)
-#define MRB_FROZEN_P(o) ((o)->flags & MRB_FLAG_IS_FROZEN)
-#define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FLAG_IS_FROZEN)
-#define MRB_UNSET_FROZEN_FLAG(o) ((o)->flags &= ~MRB_FLAG_IS_FROZEN)
+#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
+#define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
+#define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FL_OBJ_IS_FROZEN)
+#define MRB_UNSET_FROZEN_FLAG(o) ((o)->flags &= ~MRB_FL_OBJ_IS_FROZEN)
 
 struct RObject {
   MRB_OBJECT_HEADER;

data/assets/tvos/MRuby.framework/Headers/mruby/opcode.h

@@ -7,145 +7,10 @@
 #ifndef MRUBY_OPCODE_H
 #define MRUBY_OPCODE_H
 
-#define MAXARG_Bx        (0xffff)
-#define MAXARG_sBx       (MAXARG_Bx>>1)         /* 'sBx' is signed */
-
-/* instructions: packed 32 bit      */
-/* -------------------------------  */
-/*     A:B:C:OP = 9: 9: 7: 7        */
-/*      A:Bx:OP =    9:16: 7        */
-/*        Ax:OP =      25: 7        */
-/*   A:Bz:Cz:OP = 9:14: 2: 7        */
-
-#define GET_OPCODE(i)            ((int)(((mrb_code)(i)) & 0x7f))
-#define GETARG_A(i)              ((int)((((mrb_code)(i)) >> 23) & 0x1ff))
-#define GETARG_B(i)              ((int)((((mrb_code)(i)) >> 14) & 0x1ff))
-#define GETARG_C(i)              ((int)((((mrb_code)(i)) >>  7) & 0x7f))
-#define GETARG_Bx(i)             ((int)((((mrb_code)(i)) >>  7) & 0xffff))
-#define GETARG_sBx(i)            ((int)(GETARG_Bx(i)-MAXARG_sBx))
-#define GETARG_Ax(i)             ((int32_t)((((mrb_code)(i)) >>  7) & 0x1ffffff))
-#define GETARG_UNPACK_b(i,n1,n2) ((int)((((mrb_code)(i)) >> (7+(n2))) & (((1<<(n1))-1))))
-#define GETARG_UNPACK_c(i,n1,n2) ((int)((((mrb_code)(i)) >> 7) & (((1<<(n2))-1))))
-#define GETARG_b(i)              GETARG_UNPACK_b(i,14,2)
-#define GETARG_c(i)              GETARG_UNPACK_c(i,14,2)
-
-#define MKOPCODE(op)          ((op) & 0x7f)
-#define MKARG_A(c)            ((mrb_code)((c) & 0x1ff) << 23)
-#define MKARG_B(c)            ((mrb_code)((c) & 0x1ff) << 14)
-#define MKARG_C(c)            (((c) & 0x7f) <<  7)
-#define MKARG_Bx(v)           ((mrb_code)((v) & 0xffff) << 7)
-#define MKARG_sBx(v)          MKARG_Bx((v)+MAXARG_sBx)
-#define MKARG_Ax(v)           ((mrb_code)((v) & 0x1ffffff) << 7)
-#define MKARG_PACK(b,n1,c,n2) ((((b) & ((1<<n1)-1)) << (7+n2))|(((c) & ((1<<n2)-1)) << 7))
-#define MKARG_bc(b,c)         MKARG_PACK(b,14,c,2)
-
-#define MKOP_A(op,a)        (MKOPCODE(op)|MKARG_A(a))
-#define MKOP_AB(op,a,b)     (MKOP_A(op,a)|MKARG_B(b))
-#define MKOP_ABC(op,a,b,c)  (MKOP_AB(op,a,b)|MKARG_C(c))
-#define MKOP_ABx(op,a,bx)   (MKOP_A(op,a)|MKARG_Bx(bx))
-#define MKOP_Bx(op,bx)      (MKOPCODE(op)|MKARG_Bx(bx))
-#define MKOP_sBx(op,sbx)    (MKOPCODE(op)|MKARG_sBx(sbx))
-#define MKOP_AsBx(op,a,sbx) (MKOP_A(op,a)|MKARG_sBx(sbx))
-#define MKOP_Ax(op,ax)      (MKOPCODE(op)|MKARG_Ax(ax))
-#define MKOP_Abc(op,a,b,c)  (MKOP_A(op,a)|MKARG_bc(b,c))
-
-enum {
-  /*-----------------------------------------------------------------------
-  operation code  operand description
-  ------------------------------------------------------------------------*/
-  OP_NOP=0,/*                                                             */
-  OP_MOVE,/*      A B     R(A) := R(B)                                    */
-  OP_LOADL,/*     A Bx    R(A) := Pool(Bx)                                */
-  OP_LOADI,/*     A sBx   R(A) := sBx                                     */
-  OP_LOADSYM,/*   A Bx    R(A) := Syms(Bx)                                */
-  OP_LOADNIL,/*   A       R(A) := nil                                     */
-  OP_LOADSELF,/*  A       R(A) := self                                    */
-  OP_LOADT,/*     A       R(A) := true                                    */
-  OP_LOADF,/*     A       R(A) := false                                   */
-
-  OP_GETGLOBAL,/* A Bx    R(A) := getglobal(Syms(Bx))                     */
-  OP_SETGLOBAL,/* A Bx    setglobal(Syms(Bx), R(A))                       */
-  OP_GETSPECIAL,/*A Bx    R(A) := Special[Bx]                             */
-  OP_SETSPECIAL,/*A Bx    Special[Bx] := R(A)                             */
-  OP_GETIV,/*     A Bx    R(A) := ivget(Syms(Bx))                         */
-  OP_SETIV,/*     A Bx    ivset(Syms(Bx),R(A))                            */
-  OP_GETCV,/*     A Bx    R(A) := cvget(Syms(Bx))                         */
-  OP_SETCV,/*     A Bx    cvset(Syms(Bx),R(A))                            */
-  OP_GETCONST,/*  A Bx    R(A) := constget(Syms(Bx))                      */
-  OP_SETCONST,/*  A Bx    constset(Syms(Bx),R(A))                         */
-  OP_GETMCNST,/*  A Bx    R(A) := R(A)::Syms(Bx)                          */
-  OP_SETMCNST,/*  A Bx    R(A+1)::Syms(Bx) := R(A)                        */
-  OP_GETUPVAR,/*  A B C   R(A) := uvget(B,C)                              */
-  OP_SETUPVAR,/*  A B C   uvset(B,C,R(A))                                 */
-
-  OP_JMP,/*       sBx     pc+=sBx                                         */
-  OP_JMPIF,/*     A sBx   if R(A) pc+=sBx                                 */
-  OP_JMPNOT,/*    A sBx   if !R(A) pc+=sBx                                */
-  OP_ONERR,/*     sBx     rescue_push(pc+sBx)                             */
-  OP_RESCUE,/*    A B C   if A (if C exc=R(A) else R(A) := exc);
-                          if B R(B) := exc.isa?(R(B)); clear(exc)         */
-  OP_POPERR,/*    A       A.times{rescue_pop()}                           */
-  OP_RAISE,/*     A       raise(R(A))                                     */
-  OP_EPUSH,/*     Bx      ensure_push(SEQ[Bx])                            */
-  OP_EPOP,/*      A       A.times{ensure_pop().call}                      */
-
-  OP_SEND,/*      A B C   R(A) := call(R(A),Syms(B),R(A+1),...,R(A+C))    */
-  OP_SENDB,/*     A B C   R(A) := call(R(A),Syms(B),R(A+1),...,R(A+C),&R(A+C+1))*/
-  OP_FSEND,/*     A B C   R(A) := fcall(R(A),Syms(B),R(A+1),...,R(A+C-1)) */
-  OP_CALL,/*      A       R(A) := self.call(frame.argc, frame.argv)       */
-  OP_SUPER,/*     A C     R(A) := super(R(A+1),... ,R(A+C+1))             */
-  OP_ARGARY,/*    A Bx    R(A) := argument array (16=6:1:5:4)             */
-  OP_ENTER,/*     Ax      arg setup according to flags (23=5:5:1:5:5:1:1) */
-  OP_KARG,/*      A B C   R(A) := kdict[Syms(B)]; if C kdict.rm(Syms(B))  */
-  OP_KDICT,/*     A C     R(A) := kdict                                   */
-
-  OP_RETURN,/*    A B     return R(A) (B=normal,in-block return/break)    */
-  OP_TAILCALL,/*  A B C   return call(R(A),Syms(B),*R(C))                 */
-  OP_BLKPUSH,/*   A Bx    R(A) := block (16=6:1:5:4)                      */
-
-  OP_ADD,/*       A B C   R(A) := R(A)+R(A+1) (Syms[B]=:+,C=1)            */
-  OP_ADDI,/*      A B C   R(A) := R(A)+C (Syms[B]=:+)                     */
-  OP_SUB,/*       A B C   R(A) := R(A)-R(A+1) (Syms[B]=:-,C=1)            */
-  OP_SUBI,/*      A B C   R(A) := R(A)-C (Syms[B]=:-)                     */
-  OP_MUL,/*       A B C   R(A) := R(A)*R(A+1) (Syms[B]=:*,C=1)            */
-  OP_DIV,/*       A B C   R(A) := R(A)/R(A+1) (Syms[B]=:/,C=1)            */
-  OP_EQ,/*        A B C   R(A) := R(A)==R(A+1) (Syms[B]=:==,C=1)          */
-  OP_LT,/*        A B C   R(A) := R(A)<R(A+1)  (Syms[B]=:<,C=1)           */
-  OP_LE,/*        A B C   R(A) := R(A)<=R(A+1) (Syms[B]=:<=,C=1)          */
-  OP_GT,/*        A B C   R(A) := R(A)>R(A+1)  (Syms[B]=:>,C=1)           */
-  OP_GE,/*        A B C   R(A) := R(A)>=R(A+1) (Syms[B]=:>=,C=1)          */
-
-  OP_ARRAY,/*     A B C   R(A) := ary_new(R(B),R(B+1)..R(B+C))            */
-  OP_ARYCAT,/*    A B     ary_cat(R(A),R(B))                              */
-  OP_ARYPUSH,/*   A B     ary_push(R(A),R(B))                             */
-  OP_AREF,/*      A B C   R(A) := R(B)[C]                                 */
-  OP_ASET,/*      A B C   R(B)[C] := R(A)                                 */
-  OP_APOST,/*     A B C   *R(A),R(A+1)..R(A+C) := R(A)                    */
-
-  OP_STRING,/*    A Bx    R(A) := str_dup(Lit(Bx))                        */
-  OP_STRCAT,/*    A B     str_cat(R(A),R(B))                              */
-
-  OP_HASH,/*      A B C   R(A) := hash_new(R(B),R(B+1)..R(B+C))           */
-  OP_LAMBDA,/*    A Bz Cz R(A) := lambda(SEQ[Bz],Cz)                      */
-  OP_RANGE,/*     A B C   R(A) := range_new(R(B),R(B+1),C)                */
-
-  OP_OCLASS,/*    A       R(A) := ::Object                                */
-  OP_CLASS,/*     A B     R(A) := newclass(R(A),Syms(B),R(A+1))           */
-  OP_MODULE,/*    A B     R(A) := newmodule(R(A),Syms(B))                 */
-  OP_EXEC,/*      A Bx    R(A) := blockexec(R(A),SEQ[Bx])                 */
-  OP_METHOD,/*    A B     R(A).newmethod(Syms(B),R(A+1))                  */
-  OP_SCLASS,/*    A B     R(A) := R(B).singleton_class                    */
-  OP_TCLASS,/*    A       R(A) := target_class                            */
-
-  OP_DEBUG,/*     A B C   print R(A),R(B),R(C)                            */
-  OP_STOP,/*              stop VM                                         */
-  OP_ERR,/*       Bx      raise RuntimeError with message Lit(Bx)         */
-
-  OP_RSVD1,/*             reserved instruction #1                         */
-  OP_RSVD2,/*             reserved instruction #2                         */
-  OP_RSVD3,/*             reserved instruction #3                         */
-  OP_RSVD4,/*             reserved instruction #4                         */
-  OP_RSVD5,/*             reserved instruction #5                         */
+enum mrb_insn {
+#define OPCODE(x,_) OP_ ## x,
+#include "mruby/ops.h"
+#undef OPCODE
 };
 
 #define OP_L_STRICT  1
@@ -158,4 +23,47 @@ enum {
 #define OP_R_BREAK  1
 #define OP_R_RETURN 2
 
+#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_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_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_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_S_3() FETCH_S()
+#define FETCH_W_3() FETCH_W()
+
 #endif  /* MRUBY_OPCODE_H */

data/assets/tvos/MRuby.framework/Headers/mruby/ops.h

@@ -0,0 +1,117 @@
+/* operand types:
+   + Z: no operand (Z,Z,Z,Z)
+   + B: 8bit (B,S,B,B)
+   + BB: 8+8bit (BB,SB,BS,SS)
+   + BBB: 8+8+8bit (BBB,SBB,BSB,SSB)
+   + BS: 8+16bit (BS,SS,BS,BS)
+   + S: 16bit (S,S,S,S)
+   + W: 24bit (W,W,W,W)
+*/
+
+/*-----------------------------------------------------------------------
+operation code    operands      semantics
+------------------------------------------------------------------------*/
+OPCODE(NOP,        Z)        /* no operation */
+OPCODE(MOVE,       BB)       /* R(a) = R(b) */
+OPCODE(LOADL,      BB)       /* R(a) = Pool(b) */
+OPCODE(LOADI,      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(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(JMP,        S)        /* pc=a */
+OPCODE(JMPIF,      BS)       /* if R(b) pc=a */
+OPCODE(JMPNOT,     BS)       /* if !R(b) pc=a */
+OPCODE(JMPNIL,     BS)       /* if R(b)==nil pc=a */
+OPCODE(ONERR,      S)        /* rescue_push(a) */
+OPCODE(EXCEPT,     B)        /* R(a) = exc */
+OPCODE(RESCUE,     BB)       /* R(b) = R(a).isa?(R(b)) */
+OPCODE(POPERR,     B)        /* a.times{rescue_pop()} */
+OPCODE(RAISE,      B)        /* raise(R(a)) */
+OPCODE(EPUSH,      B)        /* ensure_push(SEQ[a]) */
+OPCODE(EPOP,       B)        /* A.times{ensure_pop().call} */
+OPCODE(SENDV,      BB)       /* R(a) = call(R(a),Syms(b),*R(a+1)) */
+OPCODE(SENDVB,     BB)       /* R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) */
+OPCODE(SEND,       BBB)      /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) */
+OPCODE(SENDB,      BBB)      /* R(a) = call(R(a),Syms(Bx),R(a+1),...,R(a+c),&R(a+c+1)) */
+OPCODE(CALL,       Z)        /* R(0) = self.call(frame.argc, frame.argv) */
+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))                      # todo */
+OPCODE(KEYEND,     Z)        /* raise unless kdict.empty?                       # todo */
+OPCODE(KARG,       BB)       /* R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))    # todo */
+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(c)  */
+OPCODE(SUB,        B)        /* R(a) = R(a)-R(a+1) */
+OPCODE(SUBI,       BB)       /* R(a) = R(a)-C */
+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,    B)        /* ary_push(R(a),R(a+1)) */
+OPCODE(ARYDUP,     B)        /* R(a) = ary_dup(R(a)) */
+OPCODE(AREF,       BBB)      /* R(a) = R(b)[c] */
+OPCODE(ASET,       BBB)      /* R(a)[c] = R(b) */
+OPCODE(APOST,      BBB)      /* *R(a),R(a+1)..R(a+C) = R(a)[b..] */
+OPCODE(INTERN,     B)        /* R(a) = intern(R(a)) */
+OPCODE(STRING,     BB)       /* R(a) = str_dup(Lit(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)) */
+OPCODE(HASHADD,    BB)       /* R(a) = hash_push(R(a),R(a+1)..R(a+b)) */
+OPCODE(HASHCAT,    B)        /* R(a) = hash_cat(R(a),R(a+1)) */
+OPCODE(LAMBDA,     BB)       /* R(a) = lambda(SEQ[b],L_LAMBDA) */
+OPCODE(BLOCK,      BB)       /* R(a) = lambda(SEQ[b],L_BLOCK) */
+OPCODE(METHOD,     BB)       /* R(a) = lambda(SEQ[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),SEQ[b]) */
+OPCODE(DEF,        BB)       /* R(a).newmethod(Syms(b),R(a+1)) */
+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, Lit(a)) */
+OPCODE(EXT1,       Z)        /* make 1st operand 16bit */
+OPCODE(EXT2,       Z)        /* make 2nd operand 16bit */
+OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
+OPCODE(STOP,       Z)        /* stop VM */

data/assets/tvos/MRuby.framework/Headers/mruby/proc.h

@@ -88,7 +88,7 @@ MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int
 void mrb_proc_copy(struct RProc *a, struct RProc *b);
 
 /* implementation of #send method */
-MRB_API mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
 
 /* 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_func_t, mrb_int, const mrb_value*);
@@ -98,8 +98,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state*, mrb_int);
 
 #ifdef MRB_METHOD_TABLE_INLINE
 
-#define MRB_METHOD_FUNC_FL ((uintptr_t)1U<<(sizeof(uintptr_t)*8-1))
-#define MRB_METHOD_FUNC_P(m) ((uintptr_t)(m)&MRB_METHOD_FUNC_FL)
+#define MRB_METHOD_FUNC_FL ((uintptr_t)1)
+#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
 #define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)&(~MRB_METHOD_FUNC_FL)))
 #define MRB_METHOD_FROM_FUNC(m,fn) m=(mrb_method_t)((struct RProc*)((uintptr_t)(fn)|MRB_METHOD_FUNC_FL))
 #define MRB_METHOD_FROM_PROC(m,pr) m=(mrb_method_t)(struct RProc*)(pr)
@@ -114,7 +114,7 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state*, mrb_int);
 #define MRB_METHOD_FROM_FUNC(m,fn) do{(m).func_p=TRUE;(m).func=(fn);}while(0)
 #define MRB_METHOD_FROM_PROC(m,pr) do{(m).func_p=FALSE;(m).proc=(pr);}while(0)
 #define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
-#define MRB_METHOD_PROC(fn) ((m).proc)
+#define MRB_METHOD_PROC(m) ((m).proc)
 #define MRB_METHOD_UNDEF_P(m) ((m).proc==NULL)
 
 #endif /* MRB_METHOD_TABLE_INLINE */

data/assets/tvos/MRuby.framework/Headers/mruby/string.h

@@ -102,7 +102,7 @@ MRB_API mrb_int mrb_str_index(mrb_state*, mrb_value, const char*, mrb_int, mrb_i
 #define mrb_str_index_lit(mrb, str, lit, off) mrb_str_index(mrb, str, lit, mrb_strlen_lit(lit), off);
 
 /*
- * Appends self to other. Returns self as a concatnated string.
+ * Appends self to other. Returns self as a concatenated string.
  *
  *
  *  Example:
@@ -126,10 +126,10 @@ MRB_API mrb_int mrb_str_index(mrb_state*, mrb_value, const char*, mrb_int, mrb_i
  *       str1 = mrb_str_new_lit(mrb, "abc");
  *       str2 = mrb_str_new_lit(mrb, "def");
  *
- *       // Concatnates str2 to str1.
+ *       // Concatenates str2 to str1.
  *       mrb_str_concat(mrb, str1, str2);
  *
- *      // Prints new Concatnated Ruby string.
+ *      // Prints new Concatenated Ruby string.
  *      mrb_p(mrb, str1);
  *
  *      mrb_close(mrb);
@@ -178,10 +178,10 @@ MRB_API void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
  *       mrb_p(mrb, a);
  *       mrb_p(mrb, b);
  *
- *       // Concatnates both Ruby strings.
+ *       // Concatenates both Ruby strings.
  *       c = mrb_str_plus(mrb, a, b);
  *
- *      // Prints new Concatnated Ruby string.
+ *      // Prints new Concatenated Ruby string.
  *      mrb_p(mrb, c);
  *
  *      mrb_close(mrb);
@@ -193,7 +193,7 @@ MRB_API void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
  *
  *     => "abc"  # First string
  *     => "def"  # Second string
- *     => "abcdef" # First & Second concatnated.
+ *     => "abcdef" # First & Second concatenated.
  *
  * @param [mrb_state] mrb The current mruby state.
  * @param [mrb_value] a First string to concatenate.
@@ -311,9 +311,12 @@ MRB_API mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb
  * @param [mrb_value] str Ruby string.
  * @return [mrb_value] A Ruby string.
  */
+MRB_API mrb_value mrb_ensure_string_type(mrb_state *mrb, mrb_value str);
+MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str);
+/* obsolete: use mrb_ensure_string_type() instead */
 MRB_API mrb_value mrb_string_type(mrb_state *mrb, mrb_value str);
 
-MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str);
+
 MRB_API mrb_value mrb_str_new_capa(mrb_state *mrb, size_t capa);
 MRB_API mrb_value mrb_str_buf_new(mrb_state *mrb, size_t capa);
 
@@ -353,6 +356,7 @@ MRB_API double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck);
 
 /*
  * Returns a converted string type.
+ * For type checking, non converting `mrb_to_str` is recommended.
  */
 MRB_API mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);