ruby2d 0.11.2 → 0.12.0

data/assets/include/mruby/ops.h

@@ -13,110 +13,108 @@
 operation code    operands      semantics
 ------------------------------------------------------------------------*/
 OPCODE(NOP,        Z)        /* no operation */
-OPCODE(MOVE,       BB)       /* R(a) = R(b) */
-OPCODE(LOADL,      BB)       /* R(a) = Pool(b) */
-OPCODE(LOADL16,    BS)       /* 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(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(LOADSYM16,  BS)       /* 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(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(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(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(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(b),R(a+1),...,R(a+c),&R(a+c+1)) */
-OPCODE(SENDVK,     BB)       /* R(a) = call(R(a),Syms(b),*R(a+1),**(a+2),&R(a+3)) # todo */
-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(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)        /* 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)) */
+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,    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(STRING16,   BS)       /* 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*2-1)) */
-OPCODE(HASHADD,    BB)       /* R(a) = 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(SEQ[b],L_LAMBDA) */
-OPCODE(LAMBDA16,   BS)       /* R(a) = lambda(SEQ[b],L_LAMBDA) */
-OPCODE(BLOCK,      BB)       /* R(a) = lambda(SEQ[b],L_BLOCK) */
-OPCODE(BLOCK16,    BS)       /* R(a) = lambda(SEQ[b],L_BLOCK) */
-OPCODE(METHOD,     BB)       /* R(a) = lambda(SEQ[b],L_METHOD) */
-OPCODE(METHOD16,   BS)       /* 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(EXEC16,     BS)       /* 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(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(ARYDUP,     B)        /* R[a] = ary_dup(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, Lit(a)) */
+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/assets/include/mruby/presym/scanning.h

@@ -12,16 +12,22 @@
 #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, f, a) MRB_PRESYM_SCANNING_TAGGED(name)
-#define mrb_define_class_method(mrb, c, name, f, a) MRB_PRESYM_SCANNING_TAGGED(name)
-#define mrb_define_singleton_method(mrb, c, name, f, a) MRB_PRESYM_SCANNING_TAGGED(name)
-#define mrb_define_class(mrb, name, s) MRB_PRESYM_SCANNING_TAGGED(name)
-#define mrb_define_class_under(mrb, o, name, s) 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)
-#define mrb_define_module_function(mrb, c, name, f, s) MRB_PRESYM_SCANNING_TAGGED(name)
-#define mrb_define_const(mrb, c, name, v) MRB_PRESYM_SCANNING_TAGGED(name)
-#define mrb_define_global_const(mrb, name, v) 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_CVSYM(name) MRB_PRESYM_SCANNING_TAGGED("@@" #name)

data/assets/include/mruby/proc.h

@@ -83,6 +83,8 @@ struct RProc {
 } 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, it would be something like MRB_ARGS_NONE() or MRB_METHOD_NOARG_FL */
+#define MRB_PROC_NOARG_P(p) (((p)->flags & MRB_PROC_NOARG) != 0)
 
 #define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
 
@@ -90,7 +92,7 @@ struct RProc *mrb_proc_new(mrb_state*, const mrb_irep*);
 struct RProc *mrb_closure_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);
-void mrb_proc_copy(struct RProc *a, struct RProc *b);
+void mrb_proc_copy(mrb_state *mrb, struct RProc *a, struct RProc *b);
 mrb_int mrb_proc_arity(const struct RProc *p);
 
 /* following functions are defined in mruby-proc-ext so please include it when using */
@@ -121,7 +123,7 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
 #define MRB_METHOD_FUNC(m) ((m).func)
 #define MRB_METHOD_NOARG_SET(m) do{(m).flags|=MRB_METHOD_NOARG_FL;}while(0)
 #define MRB_METHOD_FROM_FUNC(m,fn) do{(m).flags=MRB_METHOD_FUNC_FL;(m).func=(fn);}while(0)
-#define MRB_METHOD_FROM_PROC(m,pr) do{(m).flags=0;(m).proc=(pr);}while(0)
+#define MRB_METHOD_FROM_PROC(m,pr) do{(m).flags=0;(m).proc=(struct RProc*)(pr);}while(0)
 #define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
 #define MRB_METHOD_PROC(m) ((m).proc)
 #define MRB_METHOD_UNDEF_P(m) ((m).proc==NULL)

data/assets/include/mruby/string.h

@@ -324,20 +324,6 @@ MRB_API mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len);
  */
 MRB_API mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
 
-/**
- * Returns a Ruby string type.
- *
- *
- * @param mrb The current mruby state.
- * @param 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_str_new_capa(mrb_state *mrb, size_t capa);
 #define mrb_str_buf_new(mrb, capa) mrb_str_new_capa(mrb, (capa))
 
@@ -369,17 +355,10 @@ MRB_API mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str);
  */
 MRB_API mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self);
 
-MRB_API mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck);
-MRB_API mrb_value mrb_cstr_to_inum(mrb_state *mrb, const char *s, mrb_int base, mrb_bool badcheck);
+MRB_API mrb_value mrb_str_to_integer(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck);
+/* obsolete: use mrb_str_to_integer() */
+#define mrb_str_to_inum(mrb, str, base, badcheck) mrb_str_to_integer(mrb, str, base, badcheck)
 MRB_API double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck);
-MRB_API double mrb_cstr_to_dbl(mrb_state *mrb, const char *s, mrb_bool badcheck);
-
-/**
- * Returns a converted string type.
- * For type checking, non converting `mrb_to_str` is recommended.
- * obsolete: use `mrb_obj_as_string()` instead.
- */
-#define mrb_str_to_str(mrb, str) mrb_obj_as_string(mrb, str)
 
 /**
  * Returns true if the strings match and false if the strings don't match.

data/assets/include/mruby/value.h

@@ -31,7 +31,30 @@ typedef uint32_t mrb_sym;
  * Not to be confused with Ruby's boolean classes, which can be
  * obtained using mrb_false_value() and mrb_true_value()
  */
+#if defined(__cplusplus) || (defined(__bool_true_false_are_defined) && __bool_true_false_are_defined)
+typedef bool mrb_bool;
+
+# ifndef FALSE
+#  define FALSE false
+# endif
+# ifndef TRUE
+#  define TRUE true
+# endif
+#else
+# if __STDC_VERSION__ >= 199901L
+typedef _Bool mrb_bool;
+# else
 typedef uint8_t mrb_bool;
+# endif
+
+# ifndef FALSE
+#  define FALSE 0
+# endif
+# ifndef TRUE
+#  define TRUE 1
+# endif
+#endif
+
 struct mrb_state;
 
 #if defined _MSC_VER && _MSC_VER < 1800
@@ -77,6 +100,7 @@ struct mrb_state;
 # define MRB_ENDIAN_LOHI(a,b) b a
 #endif
 
+MRB_API mrb_int mrb_int_read(const char *p, const char *e, char **endp);
 #ifndef MRB_NO_FLOAT
 MRB_API double mrb_float_read(const char*, char**);
 #ifdef MRB_USE_FLOAT32
@@ -87,13 +111,11 @@ MRB_API double mrb_float_read(const char*, char**);
 #endif
 
 #if defined _MSC_VER && _MSC_VER < 1900
-# include <stdarg.h>
 MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list arg);
 MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...);
 # define vsnprintf(s, n, format, arg) mrb_msvc_vsnprintf(s, n, format, arg)
 # define snprintf(s, n, format, ...) mrb_msvc_snprintf(s, n, format, __VA_ARGS__)
 # if _MSC_VER < 1800 && !defined MRB_NO_FLOAT
-#  include <float.h>
 #  define isfinite(n) _finite(n)
 #  define isnan _isnan
 #  define isinf(n) (!_finite(n) && !_isnan(n))
@@ -104,34 +126,49 @@ static const unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000;
 # endif
 #endif
 
+#define MRB_VTYPE_FOREACH(f) \
+    /* mrb_vtype */     /* c type */        /* ruby class */ \
+  f(MRB_TT_FALSE,       void,               "false") \
+  f(MRB_TT_TRUE,        void,               "true") \
+  f(MRB_TT_SYMBOL,      void,               "Symbol") \
+  f(MRB_TT_UNDEF,       void,               "undefined") \
+  f(MRB_TT_FREE,        void,               "free") \
+  f(MRB_TT_FLOAT,       struct RFloat,      "Float") \
+  f(MRB_TT_INTEGER,     struct RInteger,    "Integer") \
+  f(MRB_TT_CPTR,        struct RCptr,       "cptr") \
+  f(MRB_TT_OBJECT,      struct RObject,     "Object") \
+  f(MRB_TT_CLASS,       struct RClass,      "Class") \
+  f(MRB_TT_MODULE,      struct RClass,      "Module") \
+  f(MRB_TT_ICLASS,      struct RClass,      "iClass") \
+  f(MRB_TT_SCLASS,      struct RClass,      "SClass") \
+  f(MRB_TT_PROC,        struct RProc,       "Proc") \
+  f(MRB_TT_ARRAY,       struct RArray,      "Array") \
+  f(MRB_TT_HASH,        struct RHash,       "Hash") \
+  f(MRB_TT_STRING,      struct RString,     "String") \
+  f(MRB_TT_RANGE,       struct RRange,      "Range") \
+  f(MRB_TT_EXCEPTION,   struct RException,  "Exception") \
+  f(MRB_TT_ENV,         struct REnv,        "env") \
+  f(MRB_TT_DATA,        struct RData,       "Data") \
+  f(MRB_TT_FIBER,       struct RFiber,      "Fiber") \
+  f(MRB_TT_STRUCT,      struct RArray,      "Struct") \
+  f(MRB_TT_ISTRUCT,     struct RIStruct,    "istruct") \
+  f(MRB_TT_BREAK,       struct RBreak,      "break") \
+  f(MRB_TT_COMPLEX,     struct RComplex,    "Complex") \
+  f(MRB_TT_RATIONAL,    struct RRational,   "Rational")
+
 enum mrb_vtype {
-  MRB_TT_FALSE = 0,
-  MRB_TT_TRUE,
-  MRB_TT_FLOAT,
-  MRB_TT_INTEGER,
-  MRB_TT_SYMBOL,
-  MRB_TT_UNDEF,
-  MRB_TT_CPTR,
-  MRB_TT_FREE,
-  MRB_TT_OBJECT,
-  MRB_TT_CLASS,
-  MRB_TT_MODULE,
-  MRB_TT_ICLASS,
-  MRB_TT_SCLASS,
-  MRB_TT_PROC,
-  MRB_TT_ARRAY,
-  MRB_TT_HASH,
-  MRB_TT_STRING,
-  MRB_TT_RANGE,
-  MRB_TT_EXCEPTION,
-  MRB_TT_ENV,
-  MRB_TT_DATA,
-  MRB_TT_FIBER,
-  MRB_TT_ISTRUCT,
-  MRB_TT_BREAK,
+#define MRB_VTYPE_DEFINE(tt, type, name) tt,
+  MRB_VTYPE_FOREACH(MRB_VTYPE_DEFINE)
+#undef MRB_VTYPE_DEFINE
   MRB_TT_MAXDEFINE
 };
 
+#define MRB_VTYPE_TYPEOF(tt) MRB_TYPEOF_##tt
+
+#define MRB_VTYPE_TYPEDEF(tt, type, name) typedef type MRB_VTYPE_TYPEOF(tt);
+MRB_VTYPE_FOREACH(MRB_VTYPE_TYPEDEF)
+#undef MRB_VTYPE_TYPEDEF
+
 /* for compatibility */
 #define MRB_TT_FIXNUM MRB_TT_INTEGER
 
@@ -177,7 +214,7 @@ struct RCptr {
 #endif
 
 #ifndef mrb_immediate_p
-#define mrb_immediate_p(o) (mrb_type(o) < MRB_TT_FREE)
+#define mrb_immediate_p(o) (mrb_type(o) <= MRB_TT_CPTR)
 #endif
 #ifndef mrb_integer_p
 #define mrb_integer_p(o) (mrb_type(o) == MRB_TT_INTEGER)
@@ -372,26 +409,29 @@ mrb_undef_value(void)
   return v;
 }
 
-#if defined(MRB_USE_ETEXT_EDATA) && !defined(MRB_USE_LINK_TIME_RO_DATA_P)
-# ifdef __GNUC__
-#  warning MRB_USE_ETEXT_EDATA is deprecated. Define MRB_USE_LINK_TIME_RO_DATA_P instead.
-# endif
-# define MRB_USE_LINK_TIME_RO_DATA_P
-#endif
-
 #if defined(MRB_USE_CUSTOM_RO_DATA_P)
 /* If you define `MRB_USE_CUSTOM_RO_DATA_P`, you must implement `mrb_ro_data_p()`. */
 mrb_bool mrb_ro_data_p(const char *p);
-#elif defined(MRB_USE_LINK_TIME_RO_DATA_P)
-extern char __ehdr_start[];
-extern char __init_array_start[];
-
+#elif !defined(MRB_NO_DEFAULT_RO_DATA_P)
+#if defined(MRB_USE_ETEXT_RO_DATA_P)
+#define MRB_LINK_TIME_RO_DATA_P
+extern char etext, edata;
 static inline mrb_bool
 mrb_ro_data_p(const char *p)
 {
-  return __ehdr_start < p && p < __init_array_start;
+  return &etext < p && p < &edata;
 }
-#else
+#elif defined(__APPLE__)
+#define MRB_LINK_TIME_RO_DATA_P
+#include <mach-o/getsect.h>
+static inline mrb_bool
+mrb_ro_data_p(const char *p)
+{
+  return (char*)get_etext() < p && p < (char*)get_edata();
+}
+#endif  /* Linux or macOS */
+#endif  /* MRB_NO_DEFAULT_RO_DATA_P */
+#ifndef MRB_LINK_TIME_RO_DATA_P
 # define mrb_ro_data_p(p) FALSE
 #endif
 

data/assets/include/mruby/variable.h

@@ -14,21 +14,6 @@
  */
 MRB_BEGIN_DECL
 
-typedef struct global_variable {
-  int   counter;
-  mrb_value *data;
-  mrb_value (*getter)(void);
-  void  (*setter)(void);
-  /* void  (*marker)(); */
-  /* int block_trace; */
-  /* struct trace_var *trace; */
-} global_variable;
-
-struct global_entry {
-  global_variable *var;
-  mrb_sym id;
-};
-
 mrb_value mrb_vm_special_get(mrb_state*, mrb_sym);
 void mrb_vm_special_set(mrb_state*, mrb_sym, mrb_value);
 mrb_value mrb_vm_cv_get(mrb_state*, mrb_sym);

data/assets/include/mruby/version.h

@@ -27,7 +27,7 @@ MRB_BEGIN_DECL
 /*
  * The version of Ruby used by mruby.
  */
-#define MRUBY_RUBY_VERSION "3.0"
+#define MRUBY_RUBY_VERSION "3.1"
 
 /*
  * Ruby engine.
@@ -42,7 +42,7 @@ MRB_BEGIN_DECL
 /*
  * Minor release version number.
  */
-#define MRUBY_RELEASE_MINOR 0
+#define MRUBY_RELEASE_MINOR 1
 
 /*
  * Tiny release version number.
@@ -80,17 +80,17 @@ MRB_BEGIN_DECL
 /*
  * Release year.
  */
-#define MRUBY_RELEASE_YEAR 2021
+#define MRUBY_RELEASE_YEAR 2022
 
 /*
  * Release month.
  */
-#define MRUBY_RELEASE_MONTH 3
+#define MRUBY_RELEASE_MONTH 5
 
 /*
  * Release day.
  */
-#define MRUBY_RELEASE_DAY 5
+#define MRUBY_RELEASE_DAY 12
 
 /*
  * Release date as a string.