summaryrefslogtreecommitdiffhomepage
path: root/src/vm.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/vm.c')
-rw-r--r--src/vm.c834
1 files changed, 417 insertions, 417 deletions
diff --git a/src/vm.c b/src/vm.c
index f74aac1b8..48a329a7d 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1,6 +1,6 @@
/*
** vm.c - virtual machine for mruby (RiteVM)
-**
+**
** See Copyright Notice in mruby.h
*/
@@ -393,7 +393,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_MOVE) {
- /* A B R(A) := R(B) */
+ /* A B R(A) := R(B) */
#if 0
regs[GETARG_A(i)] = regs[GETARG_B(i)];
#elif 1
@@ -409,51 +409,51 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_LOADL) {
- /* A Bx R(A) := Pool(Bx) */
+ /* A Bx R(A) := Pool(Bx) */
regs[GETARG_A(i)] = pool[GETARG_Bx(i)];
NEXT;
}
CASE(OP_LOADI) {
- /* A Bx R(A) := sBx */
+ /* A Bx R(A) := sBx */
SET_INT_VALUE(regs[GETARG_A(i)], GETARG_sBx(i));
NEXT;
}
CASE(OP_LOADSYM) {
- /* A B R(A) := Sym(B) */
+ /* A B R(A) := Sym(B) */
SET_SYM_VALUE(regs[GETARG_A(i)], syms[GETARG_Bx(i)]);
NEXT;
}
CASE(OP_LOADNIL) {
- /* A B R(A) := nil */
+ /* A B R(A) := nil */
int a = GETARG_A(i);
-
+
SET_NIL_VALUE(regs[a]);
NEXT;
}
CASE(OP_LOADSELF) {
- /* A R(A) := self */
+ /* A R(A) := self */
regs[GETARG_A(i)] = mrb->stack[0];
NEXT;
}
CASE(OP_LOADT) {
- /* A R(A) := true */
+ /* A R(A) := true */
regs[GETARG_A(i)] = mrb_true_value();
NEXT;
}
CASE(OP_LOADF) {
- /* A R(A) := false */
+ /* A R(A) := false */
regs[GETARG_A(i)] = mrb_false_value();
NEXT;
}
CASE(OP_GETGLOBAL) {
- /* A B R(A) := getglobal(Sym(B)) */
+ /* A B R(A) := getglobal(Sym(B)) */
regs[GETARG_A(i)] = mrb_gv_get(mrb, syms[GETARG_Bx(i)]);
NEXT;
}
@@ -465,19 +465,19 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_GETSPECIAL) {
- /* A Bx R(A) := Special[Bx] */
+ /* A Bx R(A) := Special[Bx] */
regs[GETARG_A(i)] = mrb_vm_special_get(mrb, GETARG_Bx(i));
NEXT;
}
CASE(OP_SETSPECIAL) {
- /* A Bx Special[Bx] := R(A) */
+ /* A Bx Special[Bx] := R(A) */
mrb_vm_special_set(mrb, GETARG_Bx(i), regs[GETARG_A(i)]);
NEXT;
}
CASE(OP_GETIV) {
- /* A Bx R(A) := ivget(Bx) */
+ /* A Bx R(A) := ivget(Bx) */
regs[GETARG_A(i)] = mrb_vm_iv_get(mrb, syms[GETARG_Bx(i)]);
NEXT;
}
@@ -489,7 +489,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_GETCV) {
- /* A B R(A) := ivget(Sym(B)) */
+ /* A B R(A) := ivget(Sym(B)) */
regs[GETARG_A(i)] = mrb_vm_cv_get(mrb, syms[GETARG_Bx(i)]);
NEXT;
}
@@ -501,19 +501,19 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_GETCONST) {
- /* A B R(A) := constget(Sym(B)) */
+ /* A B R(A) := constget(Sym(B)) */
regs[GETARG_A(i)] = mrb_vm_const_get(mrb, syms[GETARG_Bx(i)]);
NEXT;
}
CASE(OP_SETCONST) {
- /* A B constset(Sym(B),R(A)) */
+ /* A B constset(Sym(B),R(A)) */
mrb_vm_const_set(mrb, syms[GETARG_Bx(i)], regs[GETARG_A(i)]);
NEXT;
}
CASE(OP_GETMCNST) {
- /* A B C R(A) := R(C)::Sym(B) */
+ /* A B C R(A) := R(C)::Sym(B) */
int a = GETARG_A(i);
regs[a] = mrb_const_get(mrb, regs[a], syms[GETARG_Bx(i)]);
@@ -521,7 +521,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_SETMCNST) {
- /* A B C R(A+1)::Sym(B) := R(A) */
+ /* A B C R(A+1)::Sym(B) := R(A) */
int a = GETARG_A(i);
mrb_const_set(mrb, regs[a+1], syms[GETARG_Bx(i)], regs[a]);
@@ -529,54 +529,54 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_GETUPVAR) {
- /* A B C R(A) := uvget(B,C) */
+ /* A B C R(A) := uvget(B,C) */
regs[GETARG_A(i)] = uvget(mrb, GETARG_C(i), GETARG_B(i));
NEXT;
}
CASE(OP_SETUPVAR) {
- /* A B C uvset(B,C,R(A)) */
+ /* A B C uvset(B,C,R(A)) */
uvset(mrb, GETARG_C(i), GETARG_B(i), regs[GETARG_A(i)]);
NEXT;
}
CASE(OP_JMP) {
- /* sBx pc+=sBx */
+ /* sBx pc+=sBx */
pc += GETARG_sBx(i);
JUMP;
}
CASE(OP_JMPIF) {
- /* A sBx if R(A) pc+=sBx */
+ /* A sBx if R(A) pc+=sBx */
if (mrb_test(regs[GETARG_A(i)])) {
- pc += GETARG_sBx(i);
- JUMP;
+ pc += GETARG_sBx(i);
+ JUMP;
}
NEXT;
}
CASE(OP_JMPNOT) {
- /* A sBx if R(A) pc+=sBx */
+ /* A sBx if R(A) pc+=sBx */
if (!mrb_test(regs[GETARG_A(i)])) {
- pc += GETARG_sBx(i);
- JUMP;
+ pc += GETARG_sBx(i);
+ JUMP;
}
NEXT;
}
CASE(OP_ONERR) {
- /* sBx pc+=sBx on exception */
+ /* sBx pc+=sBx on exception */
if (mrb->rsize <= mrb->ci->ridx) {
- if (mrb->rsize == 0) mrb->rsize = 16;
- else mrb->rsize *= 2;
- mrb->rescue = mrb_realloc(mrb, mrb->rescue, sizeof(mrb_code*) * mrb->rsize);
+ if (mrb->rsize == 0) mrb->rsize = 16;
+ else mrb->rsize *= 2;
+ mrb->rescue = mrb_realloc(mrb, mrb->rescue, sizeof(mrb_code*) * mrb->rsize);
}
mrb->rescue[mrb->ci->ridx++] = pc + GETARG_sBx(i);
NEXT;
}
CASE(OP_RESCUE) {
- /* A R(A) := exc; clear(exc) */
+ /* A R(A) := exc; clear(exc) */
SET_OBJ_VALUE(regs[GETARG_A(i)],mrb->exc);
mrb->exc = 0;
NEXT;
@@ -586,46 +586,46 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
int a = GETARG_A(i);
while (a--) {
- mrb->ci->ridx--;
+ mrb->ci->ridx--;
}
NEXT;
}
CASE(OP_RAISE) {
- /* A raise(R(A)) */
+ /* A raise(R(A)) */
mrb->exc = mrb_object(regs[GETARG_A(i)]);
goto L_RAISE;
}
CASE(OP_EPUSH) {
- /* Bx ensure_push(SEQ[Bx]) */
+ /* Bx ensure_push(SEQ[Bx]) */
struct RProc *p;
p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_Bx(i)]);
/* push ensure_stack */
if (mrb->esize <= mrb->ci->eidx) {
- if (mrb->esize == 0) mrb->esize = 16;
- else mrb->esize *= 2;
- mrb->ensure = mrb_realloc(mrb, mrb->ensure, sizeof(struct RProc*) * mrb->esize);
+ if (mrb->esize == 0) mrb->esize = 16;
+ else mrb->esize *= 2;
+ mrb->ensure = mrb_realloc(mrb, mrb->ensure, sizeof(struct RProc*) * mrb->esize);
}
mrb->ensure[mrb->ci->eidx++] = p;
NEXT;
}
CASE(OP_EPOP) {
- /* A A.times{ensure_pop().call} */
+ /* A A.times{ensure_pop().call} */
int n;
int a = GETARG_A(i);
for (n=0; n<a; n++) {
- ecall(mrb, --mrb->ci->eidx);
+ ecall(mrb, --mrb->ci->eidx);
}
NEXT;
}
L_SEND:
CASE(OP_SEND) {
- /* A B C R(A) := call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
+ /* A B C R(A) := call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
int a = GETARG_A(i);
int n = GETARG_C(i);
struct RProc *m;
@@ -638,18 +638,18 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
c = mrb_class(mrb, recv);
m = mrb_method_search_vm(mrb, &c, mid);
if (!m) {
- mrb_value sym = mrb_symbol_value(mid);
-
- mid = mrb_intern(mrb, "method_missing");
- m = mrb_method_search_vm(mrb, &c, mid);
- if (n == CALL_MAXARGS) {
- mrb_ary_unshift(mrb, regs[a+1], sym);
- }
- else {
- memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
- regs[a+1] = sym;
- n++;
- }
+ mrb_value sym = mrb_symbol_value(mid);
+
+ mid = mrb_intern(mrb, "method_missing");
+ m = mrb_method_search_vm(mrb, &c, mid);
+ if (n == CALL_MAXARGS) {
+ mrb_ary_unshift(mrb, regs[a+1], sym);
+ }
+ else {
+ memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
+ regs[a+1] = sym;
+ n++;
+ }
}
/* push callinfo */
@@ -666,48 +666,48 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
mrb->stack += a;
if (MRB_PROC_CFUNC_P(m)) {
- mrb->stack[0] = m->body.func(mrb, recv);
- mrb->arena_idx = ai;
- if (mrb->exc) goto L_RAISE;
- /* pop stackpos */
- mrb->stack = mrb->stbase + ci->stackidx;
- cipop(mrb);
- NEXT;
+ mrb->stack[0] = m->body.func(mrb, recv);
+ mrb->arena_idx = ai;
+ if (mrb->exc) goto L_RAISE;
+ /* pop stackpos */
+ mrb->stack = mrb->stbase + ci->stackidx;
+ cipop(mrb);
+ NEXT;
}
else {
- /* fill callinfo */
- ci->acc = a;
-
- /* setup environment for calling method */
- proc = mrb->ci->proc = m;
- irep = m->body.irep;
- pool = irep->pool;
- syms = irep->syms;
- ci->nregs = irep->nregs;
- if (ci->argc < 0) {
- stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
- }
- else {
- stack_extend(mrb, irep->nregs, ci->argc+2);
- }
- regs = mrb->stack;
- pc = irep->iseq;
- JUMP;
+ /* fill callinfo */
+ ci->acc = a;
+
+ /* setup environment for calling method */
+ proc = mrb->ci->proc = m;
+ irep = m->body.irep;
+ pool = irep->pool;
+ syms = irep->syms;
+ ci->nregs = irep->nregs;
+ if (ci->argc < 0) {
+ stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
+ }
+ else {
+ stack_extend(mrb, irep->nregs, ci->argc+2);
+ }
+ regs = mrb->stack;
+ pc = irep->iseq;
+ JUMP;
}
}
CASE(OP_FSEND) {
- /* A B C R(A) := fcall(R(A),Sym(B),R(A+1),... ,R(A+C)) */
+ /* A B C R(A) := fcall(R(A),Sym(B),R(A+1),... ,R(A+C)) */
NEXT;
}
CASE(OP_VSEND) {
- /* A B R(A) := vcall(R(A),Sym(B)) */
+ /* A B R(A) := vcall(R(A),Sym(B)) */
NEXT;
}
CASE(OP_CALL) {
- /* A R(A) := self.call(frame.argc, frame.argv) */
+ /* A R(A) := self.call(frame.argc, frame.argv) */
mrb_callinfo *ci;
mrb_value recv = mrb->stack[0];
struct RProc *m = mrb_proc_ptr(recv);
@@ -717,44 +717,44 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
ci->target_class = m->target_class;
ci->proc = m;
if (m->env) {
- ci->mid = m->env->mid;
- if (!m->env->stack) {
- m->env->stack = mrb->stack;
- }
+ ci->mid = m->env->mid;
+ if (!m->env->stack) {
+ m->env->stack = mrb->stack;
+ }
}
/* prepare stack */
if (MRB_PROC_CFUNC_P(m)) {
- mrb->stack[0] = m->body.func(mrb, recv);
- mrb->arena_idx = ai;
- if (mrb->exc) goto L_RAISE;
- /* pop stackpos */
- regs = mrb->stack = mrb->stbase + ci->stackidx;
- cipop(mrb);
- NEXT;
+ mrb->stack[0] = m->body.func(mrb, recv);
+ mrb->arena_idx = ai;
+ if (mrb->exc) goto L_RAISE;
+ /* pop stackpos */
+ regs = mrb->stack = mrb->stbase + ci->stackidx;
+ cipop(mrb);
+ NEXT;
}
else {
- /* setup environment for calling method */
- proc = m;
- irep = m->body.irep;
- pool = irep->pool;
- syms = irep->syms;
- ci->nregs = irep->nregs;
- if (ci->argc < 0) {
- stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
- }
- else {
- stack_extend(mrb, irep->nregs, ci->argc+2);
- }
- regs = mrb->stack;
- regs[0] = m->env->stack[0];
- pc = m->body.irep->iseq;
- JUMP;
+ /* setup environment for calling method */
+ proc = m;
+ irep = m->body.irep;
+ pool = irep->pool;
+ syms = irep->syms;
+ ci->nregs = irep->nregs;
+ if (ci->argc < 0) {
+ stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
+ }
+ else {
+ stack_extend(mrb, irep->nregs, ci->argc+2);
+ }
+ regs = mrb->stack;
+ regs[0] = m->env->stack[0];
+ pc = m->body.irep->iseq;
+ JUMP;
}
}
CASE(OP_SUPER) {
- /* A B C R(A) := super(R(A+1),... ,R(A+C-1)) */
+ /* A B C R(A) := super(R(A+1),... ,R(A+C-1)) */
mrb_value recv;
mrb_callinfo *ci = mrb->ci;
struct RProc *m;
@@ -767,17 +767,17 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
c = mrb->ci->proc->target_class->super;
m = mrb_method_search_vm(mrb, &c, mid);
if (!m) {
- c = mrb->ci->proc->target_class;
- mid = mrb_intern(mrb, "method_missing");
- m = mrb_method_search_vm(mrb, &c, mid);
- if (n == CALL_MAXARGS) {
- mrb_ary_unshift(mrb, regs[a+1], mrb_symbol_value(ci->mid));
- }
- else {
- memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
- regs[a+1] = mrb_symbol_value(ci->mid);
- n++;
- }
+ c = mrb->ci->proc->target_class;
+ mid = mrb_intern(mrb, "method_missing");
+ m = mrb_method_search_vm(mrb, &c, mid);
+ if (n == CALL_MAXARGS) {
+ mrb_ary_unshift(mrb, regs[a+1], mrb_symbol_value(ci->mid));
+ }
+ else {
+ memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
+ regs[a+1] = mrb_symbol_value(ci->mid);
+ n++;
+ }
}
/* push callinfo */
@@ -795,38 +795,38 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
mrb->stack[0] = recv;
if (MRB_PROC_CFUNC_P(m)) {
- mrb->stack[0] = m->body.func(mrb, recv);
- mrb->arena_idx = ai;
- if (mrb->exc) goto L_RAISE;
- /* pop stackpos */
- mrb->stack = mrb->stbase + ci->stackidx;
- cipop(mrb);
- NEXT;
+ mrb->stack[0] = m->body.func(mrb, recv);
+ mrb->arena_idx = ai;
+ if (mrb->exc) goto L_RAISE;
+ /* pop stackpos */
+ mrb->stack = mrb->stbase + ci->stackidx;
+ cipop(mrb);
+ NEXT;
}
else {
- /* fill callinfo */
- ci->acc = a;
-
- /* setup environment for calling method */
- ci->proc = m;
- irep = m->body.irep;
- pool = irep->pool;
- syms = irep->syms;
- ci->nregs = irep->nregs;
- if (ci->argc < 0) {
- stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
- }
- else {
- stack_extend(mrb, irep->nregs, ci->argc+2);
- }
- regs = mrb->stack;
- pc = irep->iseq;
- JUMP;
+ /* fill callinfo */
+ ci->acc = a;
+
+ /* setup environment for calling method */
+ ci->proc = m;
+ irep = m->body.irep;
+ pool = irep->pool;
+ syms = irep->syms;
+ ci->nregs = irep->nregs;
+ if (ci->argc < 0) {
+ stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
+ }
+ else {
+ stack_extend(mrb, irep->nregs, ci->argc+2);
+ }
+ regs = mrb->stack;
+ pc = irep->iseq;
+ JUMP;
}
}
CASE(OP_ARGARY) {
- /* A Bx R(A) := argument array (16=6:1:5:4) */
+ /* A Bx R(A) := argument array (16=6:1:5:4) */
int a = GETARG_A(i);
int bx = GETARG_Bx(i);
int m1 = (bx>>10)&0x3f;
@@ -837,40 +837,40 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
if (lv == 0) stack = regs + 1;
else {
- struct REnv *e = uvenv(mrb, lv-1);
- stack = e->stack + 1;
+ struct REnv *e = uvenv(mrb, lv-1);
+ stack = e->stack + 1;
}
if (r == 0) {
- regs[a] = mrb_ary_new_elts(mrb, m1+m2, stack);
+ regs[a] = mrb_ary_new_elts(mrb, m1+m2, stack);
}
else {
- mrb_value *pp;
- struct RArray *rest;
- int len = 0;
-
- if (stack[m1].tt == MRB_TT_ARRAY) {
- struct RArray *ary = mrb_ary_ptr(stack[m1]);
-
- pp = ary->buf;
- len = ary->len;
- }
- regs[a] = mrb_ary_new_capa(mrb, m1+len+m2);
- rest = mrb_ary_ptr(regs[a]);
- memcpy(rest->buf, stack, sizeof(mrb_value)*m1);
- if (len > 0) {
- memcpy(rest->buf+m1, pp, sizeof(mrb_value)*len);
- }
- if (m2 > 0) {
- memcpy(rest->buf+m1+len, stack+m1+1, sizeof(mrb_value)*m2);
- }
- rest->len = m1+len+m2;
+ mrb_value *pp;
+ struct RArray *rest;
+ int len = 0;
+
+ if (stack[m1].tt == MRB_TT_ARRAY) {
+ struct RArray *ary = mrb_ary_ptr(stack[m1]);
+
+ pp = ary->buf;
+ len = ary->len;
+ }
+ regs[a] = mrb_ary_new_capa(mrb, m1+len+m2);
+ rest = mrb_ary_ptr(regs[a]);
+ memcpy(rest->buf, stack, sizeof(mrb_value)*m1);
+ if (len > 0) {
+ memcpy(rest->buf+m1, pp, sizeof(mrb_value)*len);
+ }
+ if (m2 > 0) {
+ memcpy(rest->buf+m1+len, stack+m1+1, sizeof(mrb_value)*m2);
+ }
+ rest->len = m1+len+m2;
}
regs[a+1] = stack[m1+r+m2];
NEXT;
}
CASE(OP_ENTER) {
- /* Ax arg setup according to flags (24=5:5:1:5:5:1:1) */
+ /* Ax arg setup according to flags (24=5:5:1:5:5:1:1) */
/* number of optional arguments times OP_JMP should follow */
int ax = GETARG_Ax(i);
int m1 = (ax>>18)&0x1f;
@@ -887,142 +887,142 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
int len = m1 + o + r + m2;
if (argc < 0) {
- struct RArray *ary = mrb_ary_ptr(regs[1]);
- argv = ary->buf;
- argc = ary->len;
- regs[len+2] = regs[1]; /* save argary in register */
+ struct RArray *ary = mrb_ary_ptr(regs[1]);
+ argv = ary->buf;
+ argc = ary->len;
+ regs[len+2] = regs[1]; /* save argary in register */
}
if (mrb->ci->proc && MRB_PROC_STRICT_P(mrb->ci->proc)) {
- if (argc >= 0) {
- if (argc < m1 + m2 || (r == 0 && argc > len)) {
- fprintf(stderr, "'%s': wrong number of arguments (%d for %d)\n",
- mrb_sym2name(mrb, mrb->ci->mid),
- mrb->ci->argc, m1+m2);
- exit(1);
- }
- }
+ if (argc >= 0) {
+ if (argc < m1 + m2 || (r == 0 && argc > len)) {
+ fprintf(stderr, "'%s': wrong number of arguments (%d for %d)\n",
+ mrb_sym2name(mrb, mrb->ci->mid),
+ mrb->ci->argc, m1+m2);
+ exit(1);
+ }
+ }
}
else if (len > 1 && argc == 1 && argv[0].tt == MRB_TT_ARRAY) {
- argc = mrb_ary_ptr(argv[0])->len;
- argv = mrb_ary_ptr(argv[0])->buf;
+ argc = mrb_ary_ptr(argv[0])->len;
+ argv = mrb_ary_ptr(argv[0])->buf;
}
mrb->ci->argc = len;
if (argc < len) {
- regs[len+1] = argv[argc]; /* move block */
- memmove(&regs[1], argv, sizeof(mrb_value)*(argc-m2)); /* m1 + o */
- memmove(&regs[len-m2+1], &argv[argc-m2], sizeof(mrb_value)*m2); /* m2 */
- if (r) { /* r */
- regs[m1+o+1] = mrb_ary_new_capa(mrb, 0);
- }
- pc += argc - m1 - m2 + 1;
+ regs[len+1] = argv[argc]; /* move block */
+ memmove(&regs[1], argv, sizeof(mrb_value)*(argc-m2)); /* m1 + o */
+ memmove(&regs[len-m2+1], &argv[argc-m2], sizeof(mrb_value)*m2); /* m2 */
+ if (r) { /* r */
+ regs[m1+o+1] = mrb_ary_new_capa(mrb, 0);
+ }
+ pc += argc - m1 - m2 + 1;
}
else {
- memmove(&regs[1], argv, sizeof(mrb_value)*(m1+o)); /* m1 + o */
- if (r) { /* r */
- regs[m1+o+1] = mrb_ary_new_elts(mrb, argc-m1-o-m2, argv+m1+o);
- }
- memmove(&regs[m1+o+r+1], &argv[argc-m2], sizeof(mrb_value)*m2);
- regs[len+1] = argv[argc]; /* move block */
- pc += o + 1;
+ memmove(&regs[1], argv, sizeof(mrb_value)*(m1+o)); /* m1 + o */
+ if (r) { /* r */
+ regs[m1+o+1] = mrb_ary_new_elts(mrb, argc-m1-o-m2, argv+m1+o);
+ }
+ memmove(&regs[m1+o+r+1], &argv[argc-m2], sizeof(mrb_value)*m2);
+ regs[len+1] = argv[argc]; /* move block */
+ pc += o + 1;
}
JUMP;
}
CASE(OP_KARG) {
- /* A B C R(A) := kdict[Sym(B)]; if C kdict.rm(Sym(B)) */
+ /* A B C R(A) := kdict[Sym(B)]; if C kdict.rm(Sym(B)) */
/* if C == 2; raise unless kdict.empty? */
/* OP_JMP should follow to skip init code */
NEXT;
}
CASE(OP_KDICT) {
- /* A C R(A) := kdict */
+ /* A C R(A) := kdict */
NEXT;
}
CASE(OP_RETURN) {
- /* A return R(A) */
+ /* A return R(A) */
L_RETURN:
if (mrb->ci->env) {
- struct REnv *e = mrb->ci->env;
- int len = (int)e->flags;
- mrb_value *p = mrb_malloc(mrb, sizeof(mrb_value)*len);
+ struct REnv *e = mrb->ci->env;
+ int len = (int)e->flags;
+ mrb_value *p = mrb_malloc(mrb, sizeof(mrb_value)*len);
- e->cioff = -1;
- memcpy(p, e->stack, sizeof(mrb_value)*len);
- e->stack = p;
+ e->cioff = -1;
+ memcpy(p, e->stack, sizeof(mrb_value)*len);
+ e->stack = p;
}
if (mrb->exc) {
- mrb_callinfo *ci;
+ mrb_callinfo *ci;
L_RAISE:
- ci = mrb->ci;
- if (ci == mrb->cibase) goto L_STOP;
- while (ci[0].ridx == ci[-1].ridx) {
- cipop(mrb);
- ci = mrb->ci;
- if (ci == mrb->cibase) {
- if (ci->ridx == 0) goto L_STOP;
- break;
- }
- }
- irep = ci->proc->body.irep;
- pool = irep->pool;
- syms = irep->syms;
- regs = mrb->stack = mrb->stbase + ci->stackidx;
- pc = mrb->rescue[--ci->ridx];
+ ci = mrb->ci;
+ if (ci == mrb->cibase) goto L_STOP;
+ while (ci[0].ridx == ci[-1].ridx) {
+ cipop(mrb);
+ ci = mrb->ci;
+ if (ci == mrb->cibase) {
+ if (ci->ridx == 0) goto L_STOP;
+ break;
+ }
+ }
+ irep = ci->proc->body.irep;
+ pool = irep->pool;
+ syms = irep->syms;
+ regs = mrb->stack = mrb->stbase + ci->stackidx;
+ pc = mrb->rescue[--ci->ridx];
}
else {
- mrb_callinfo *ci = mrb->ci;
- int acc, eidx = mrb->ci->eidx;
- mrb_value v = regs[GETARG_A(i)];
-
- switch (GETARG_B(i)) {
- case OP_R_NORMAL:
- ci = mrb->ci;
- break;
- case OP_R_BREAK:
- if (proc->env->cioff < 0) {
- localjump_error(mrb, "break");
- goto L_RAISE;
- }
- ci = mrb->ci = mrb->cibase + proc->env->cioff + 1;
- break;
- case OP_R_RETURN:
- if (proc->env->cioff < 0) {
- localjump_error(mrb, "return");
- }
- ci = mrb->ci = mrb->cibase + proc->env->cioff;
- break;
- default:
- /* cannot happen */
- break;
- }
- cipop(mrb);
- acc = ci->acc;
- pc = ci->pc;
- regs = mrb->stack = mrb->stbase + ci->stackidx;
- while (eidx > mrb->ci->eidx) {
- ecall(mrb, --eidx);
- }
- if (acc < 0) {
- mrb->jmp = prev_jmp;
- return v;
- }
- DEBUG(printf("from :%s\n", mrb_sym2name(mrb, ci->mid)));
- proc = mrb->ci->proc;
- irep = proc->body.irep;
- pool = irep->pool;
- syms = irep->syms;
-
- regs[acc] = v;
+ mrb_callinfo *ci = mrb->ci;
+ int acc, eidx = mrb->ci->eidx;
+ mrb_value v = regs[GETARG_A(i)];
+
+ switch (GETARG_B(i)) {
+ case OP_R_NORMAL:
+ ci = mrb->ci;
+ break;
+ case OP_R_BREAK:
+ if (proc->env->cioff < 0) {
+ localjump_error(mrb, "break");
+ goto L_RAISE;
+ }
+ ci = mrb->ci = mrb->cibase + proc->env->cioff + 1;
+ break;
+ case OP_R_RETURN:
+ if (proc->env->cioff < 0) {
+ localjump_error(mrb, "return");
+ }
+ ci = mrb->ci = mrb->cibase + proc->env->cioff;
+ break;
+ default:
+ /* cannot happen */
+ break;
+ }
+ cipop(mrb);
+ acc = ci->acc;
+ pc = ci->pc;
+ regs = mrb->stack = mrb->stbase + ci->stackidx;
+ while (eidx > mrb->ci->eidx) {
+ ecall(mrb, --eidx);
+ }
+ if (acc < 0) {
+ mrb->jmp = prev_jmp;
+ return v;
+ }
+ DEBUG(printf("from :%s\n", mrb_sym2name(mrb, ci->mid)));
+ proc = mrb->ci->proc;
+ irep = proc->body.irep;
+ pool = irep->pool;
+ syms = irep->syms;
+
+ regs[acc] = v;
}
JUMP;
}
CASE(OP_TAILCALL) {
- /* A B C return call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
+ /* A B C return call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
int a = GETARG_A(i);
int n = GETARG_C(i);
struct RProc *m;
@@ -1035,18 +1035,18 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
c = mrb_class(mrb, recv);
m = mrb_method_search_vm(mrb, &c, mid);
if (!m) {
- mrb_value sym = mrb_symbol_value(mid);
-
- mid = mrb_intern(mrb, "method_missing");
- m = mrb_method_search_vm(mrb, &c, mid);
- if (n == CALL_MAXARGS) {
- mrb_ary_unshift(mrb, regs[a+1], sym);
- }
- else {
- memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
- regs[a+1] = sym;
- n++;
- }
+ mrb_value sym = mrb_symbol_value(mid);
+
+ mid = mrb_intern(mrb, "method_missing");
+ m = mrb_method_search_vm(mrb, &c, mid);
+ if (n == CALL_MAXARGS) {
+ mrb_ary_unshift(mrb, regs[a+1], sym);
+ }
+ else {
+ memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
+ regs[a+1] = sym;
+ n++;
+ }
}
@@ -1061,29 +1061,29 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
memmove(mrb->stack, &regs[a], (ci->argc+1)*sizeof(mrb_value));
if (MRB_PROC_CFUNC_P(m)) {
- mrb->stack[0] = m->body.func(mrb, recv);
- mrb->arena_idx = ai;
- goto L_RETURN;
+ mrb->stack[0] = m->body.func(mrb, recv);
+ mrb->arena_idx = ai;
+ goto L_RETURN;
}
else {
- /* setup environment for calling method */
- irep = m->body.irep;
- pool = irep->pool;
- syms = irep->syms;
- if (ci->argc < 0) {
- stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
- }
- else {
- stack_extend(mrb, irep->nregs, ci->argc+2);
- }
- regs = mrb->stack;
- pc = irep->iseq;
+ /* setup environment for calling method */
+ irep = m->body.irep;
+ pool = irep->pool;
+ syms = irep->syms;
+ if (ci->argc < 0) {
+ stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
+ }
+ else {
+ stack_extend(mrb, irep->nregs, ci->argc+2);
+ }
+ regs = mrb->stack;
+ pc = irep->iseq;
}
JUMP;
}
CASE(OP_BLKPUSH) {
- /* A Bx R(A) := block (16=6:1:5:4) */
+ /* A Bx R(A) := block (16=6:1:5:4) */
int a = GETARG_A(i);
int bx = GETARG_Bx(i);
int m1 = (bx>>10)&0x3f;
@@ -1094,8 +1094,8 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
if (lv == 0) stack = regs + 1;
else {
- struct REnv *e = uvenv(mrb, lv-1);
- stack = e->stack + 1;
+ struct REnv *e = uvenv(mrb, lv-1);
+ stack = e->stack + 1;
}
regs[a] = stack[m1+r+m2];
NEXT;
@@ -1111,7 +1111,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
/* need to check if - is overridden */\
switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\
- OP_MATH_BODY(op,i,i); \
+ OP_MATH_BODY(op,i,i); \
break;\
case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):\
{\
@@ -1133,90 +1133,90 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
} while (0)
CASE(OP_ADD) {
- /* A B C R(A) := R(A)+R(A+1) (Syms[B]=:+,C=1)*/
+ /* A B C R(A) := R(A)+R(A+1) (Syms[B]=:+,C=1)*/
int a = GETARG_A(i);
switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
- OP_MATH_BODY(+,i,i);
- break;
+ OP_MATH_BODY(+,i,i);
+ break;
case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):
- {
- mrb_int x = regs[a].value.i;
- mrb_float y = regs[a+1].value.f;
- SET_FLOAT_VALUE(regs[a], (mrb_float)x + y);
- }
- break;
+ {
+ mrb_int x = regs[a].value.i;
+ mrb_float y = regs[a+1].value.f;
+ SET_FLOAT_VALUE(regs[a], (mrb_float)x + y);
+ }
+ break;
case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):
- OP_MATH_BODY(+,f,i);
- break;
+ OP_MATH_BODY(+,f,i);
+ break;
case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):
- OP_MATH_BODY(+,f,f);
- break;
+ OP_MATH_BODY(+,f,f);
+ break;
case TYPES2(MRB_TT_STRING,MRB_TT_STRING):
- regs[a] = mrb_str_plus(mrb, regs[a], regs[a+1]);
- break;
+ regs[a] = mrb_str_plus(mrb, regs[a], regs[a+1]);
+ break;
default:
- i = MKOP_ABC(OP_SEND, a, GETARG_B(i), GETARG_C(i));
- goto L_SEND;
+ i = MKOP_ABC(OP_SEND, a, GETARG_B(i), GETARG_C(i));
+ goto L_SEND;
}
NEXT;
}
CASE(OP_SUB) {
- /* A B C R(A) := R(A)-R(A+1) (Syms[B]=:-,C=1)*/
+ /* A B C R(A) := R(A)-R(A+1) (Syms[B]=:-,C=1)*/
OP_MATH(-);
NEXT;
}
CASE(OP_MUL) {
- /* A B C R(A) := R(A)*R(A+1) (Syms[B]=:*,C=1)*/
+ /* A B C R(A) := R(A)*R(A+1) (Syms[B]=:*,C=1)*/
OP_MATH(*);
NEXT;
}
CASE(OP_DIV) {
- /* A B C R(A) := R(A)/R(A+1) (Syms[B]=:/,C=1)*/
+ /* A B C R(A) := R(A)/R(A+1) (Syms[B]=:/,C=1)*/
OP_MATH(/);
NEXT;
}
CASE(OP_ADDI) {
- /* A B C R(A) := R(A)+C (Syms[B]=:+)*/
+ /* A B C R(A) := R(A)+C (Syms[B]=:+)*/
int a = GETARG_A(i);
/* need to check if + is overridden */
switch (mrb_type(regs[a])) {
case MRB_TT_FIXNUM:
- regs[a].value.i += GETARG_C(i);
- break;
+ regs[a].value.i += GETARG_C(i);
+ break;
case MRB_TT_FLOAT:
- regs[a].value.f += GETARG_C(i);
- break;
+ regs[a].value.f += GETARG_C(i);
+ break;
default:
- SET_INT_VALUE(regs[a+1], GETARG_C(i));
- i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
- goto L_SEND;
+ SET_INT_VALUE(regs[a+1], GETARG_C(i));
+ i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
+ goto L_SEND;
}
NEXT;
}
CASE(OP_SUBI) {
- /* A B C R(A) := R(A)-C (Syms[B]=:+)*/
+ /* A B C R(A) := R(A)-C (Syms[B]=:+)*/
int a = GETARG_A(i);
/* need to check if + is overridden */
switch (mrb_type(regs[a])) {
case MRB_TT_FIXNUM:
- regs[a].value.i -= GETARG_C(i);
- break;
+ regs[a].value.i -= GETARG_C(i);
+ break;
case MRB_TT_FLOAT:
- regs[a].value.f -= GETARG_C(i);
- break;
+ regs[a].value.f -= GETARG_C(i);
+ break;
default:
- SET_INT_VALUE(regs[a+1], GETARG_C(i));
- i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
- goto L_SEND;
+ SET_INT_VALUE(regs[a+1], GETARG_C(i));
+ i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
+ goto L_SEND;
}
NEXT;
}
@@ -1235,7 +1235,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
/* need to check if - is overridden */\
switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\
- OP_CMP_BODY(op,i,i); \
+ OP_CMP_BODY(op,i,i); \
break;\
case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):\
OP_CMP_BODY(op,i,f);\
@@ -1253,134 +1253,134 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
} while (0)
CASE(OP_EQ) {
- /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+ /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
OP_CMP(==);
NEXT;
}
CASE(OP_LT) {
- /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+ /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
OP_CMP(<);
NEXT;
}
CASE(OP_LE) {
- /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+ /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
OP_CMP(<=);
NEXT;
}
CASE(OP_GT) {
- /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+ /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
OP_CMP(>);
NEXT;
}
CASE(OP_GE) {
- /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+ /* A B C R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
OP_CMP(>=);
NEXT;
}
CASE(OP_ARRAY) {
- /* A B C R(A) := ary_new(R(B),R(B+1)..R(B+C)) */
+ /* A B C R(A) := ary_new(R(B),R(B+1)..R(B+C)) */
int b = GETARG_B(i);
int lim = b+GETARG_C(i);
mrb_value ary = mrb_ary_new_capa(mrb, GETARG_C(i));
while (b < lim) {
- mrb_ary_push(mrb, ary, regs[b++]);
+ mrb_ary_push(mrb, ary, regs[b++]);
}
regs[GETARG_A(i)] = ary;
NEXT;
}
CASE(OP_ARYCAT) {
- /* A B mrb_ary_concat(R(A),R(B)) */
+ /* A B mrb_ary_concat(R(A),R(B)) */
mrb_ary_concat(mrb, regs[GETARG_A(i)],
- mrb_ary_splat(mrb, regs[GETARG_B(i)]));
+ mrb_ary_splat(mrb, regs[GETARG_B(i)]));
NEXT;
}
CASE(OP_ARYPUSH) {
- /* A B R(A).push(R(B)) */
+ /* A B R(A).push(R(B)) */
mrb_ary_push(mrb, regs[GETARG_A(i)], regs[GETARG_B(i)]);
NEXT;
}
CASE(OP_AREF) {
- /* A B C R(A) := R(B)[C] */
+ /* A B C R(A) := R(B)[C] */
int a = GETARG_A(i);
int c = GETARG_C(i);
mrb_value v = regs[GETARG_B(i)];
if (v.tt != MRB_TT_ARRAY) {
- if (c == 0) {
- regs[GETARG_A(i)] = v;
- }
- else {
- SET_NIL_VALUE(regs[a]);
- }
+ if (c == 0) {
+ regs[GETARG_A(i)] = v;
+ }
+ else {
+ SET_NIL_VALUE(regs[a]);
+ }
}
else {
- regs[GETARG_A(i)] = mrb_ary_ref(mrb, v, c);
+ regs[GETARG_A(i)] = mrb_ary_ref(mrb, v, c);
}
NEXT;
}
CASE(OP_ASET) {
- /* A B C R(B)[C] := R(A) */
+ /* A B C R(B)[C] := R(A) */
mrb_ary_set(mrb, regs[GETARG_B(i)], GETARG_C(i), regs[GETARG_A(i)]);
NEXT;
}
CASE(OP_APOST) {
- /* A B C *R(A),R(A+1)..R(A+C) := R(A) */
+ /* A B C *R(A),R(A+1)..R(A+C) := R(A) */
int a = GETARG_A(i);
mrb_value v = regs[a];
int pre = GETARG_B(i);
int post = GETARG_C(i);
if (v.tt != MRB_TT_ARRAY) {
- regs[a++] = mrb_ary_new_capa(mrb, 0);
- while (post--) {
- SET_NIL_VALUE(regs[a]);
- a++;
- }
+ regs[a++] = mrb_ary_new_capa(mrb, 0);
+ while (post--) {
+ SET_NIL_VALUE(regs[a]);
+ a++;
+ }
}
else {
- struct RArray *ary = mrb_ary_ptr(v);
- size_t len = ary->len;
- int i;
-
- if (len > pre + post) {
- regs[a++] = mrb_ary_new_elts(mrb, len - pre - post, ary->buf+pre);
- while (post--) {
- regs[a++] = ary->buf[len-post-1];
- }
- }
- else {
- regs[a++] = mrb_ary_new_capa(mrb, 0);
- for (i=0; i+pre<len; i++) {
- regs[a+i] = ary->buf[pre+i];
- }
- while (i < post) {
- SET_NIL_VALUE(regs[a+i]);
- i++;
- }
- }
+ struct RArray *ary = mrb_ary_ptr(v);
+ size_t len = ary->len;
+ int i;
+
+ if (len > pre + post) {
+ regs[a++] = mrb_ary_new_elts(mrb, len - pre - post, ary->buf+pre);
+ while (post--) {
+ regs[a++] = ary->buf[len-post-1];
+ }
+ }
+ else {
+ regs[a++] = mrb_ary_new_capa(mrb, 0);
+ for (i=0; i+pre<len; i++) {
+ regs[a+i] = ary->buf[pre+i];
+ }
+ while (i < post) {
+ SET_NIL_VALUE(regs[a+i]);
+ i++;
+ }
+ }
}
NEXT;
}
CASE(OP_STRING) {
- /* A Bx R(A) := str_new(Lit(Bx)) */
+ /* A Bx R(A) := str_new(Lit(Bx)) */
regs[GETARG_A(i)] = mrb_str_literal(mrb, pool[GETARG_Bx(i)]);
NEXT;
}
CASE(OP_STRCAT) {
- /* A B R(A).concat(R(B)) */
+ /* A B R(A).concat(R(B)) */
mrb_str_concat(mrb, regs[GETARG_A(i)], regs[GETARG_B(i)]);
NEXT;
}
@@ -1393,23 +1393,23 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
mrb_value hash = mrb_hash_new_capa(mrb, c);
while (b < lim) {
- mrb_hash_set(mrb, hash, regs[b], regs[b+1]);
- b+=2;
+ mrb_hash_set(mrb, hash, regs[b], regs[b+1]);
+ b+=2;
}
regs[GETARG_A(i)] = hash;
NEXT;
}
CASE(OP_LAMBDA) {
- /* A b c R(A) := lambda(SEQ[b],c) (b:c = 14:2) */
+ /* A b c R(A) := lambda(SEQ[b],c) (b:c = 14:2) */
struct RProc *p;
int c = GETARG_c(i);
if (c & OP_L_CAPTURE) {
- p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
+ p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
}
else {
- p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
+ p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
}
if (c & OP_L_STRICT) p->flags |= MRB_PROC_STRICT;
regs[GETARG_A(i)] = mrb_obj_value(p);
@@ -1417,13 +1417,13 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_OCLASS) {
- /* A R(A) := ::Object */
+ /* A R(A) := ::Object */
regs[GETARG_A(i)] = mrb_obj_value(mrb->object_class);
NEXT;
}
CASE(OP_CLASS) {
- /* A B R(A) := newclass(R(A),Sym(B),R(A+1)) */
+ /* A B R(A) := newclass(R(A),Sym(B),R(A+1)) */
struct RClass *c = 0;
int a = GETARG_A(i);
mrb_value base, super;
@@ -1432,7 +1432,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
base = regs[a];
super = regs[a+1];
if (mrb_nil_p(base)) {
- base = mrb_obj_value(mrb->ci->target_class);
+ base = mrb_obj_value(mrb->ci->target_class);
}
c = mrb_vm_define_class(mrb, base, super, id);
regs[a] = mrb_obj_value(c);
@@ -1440,7 +1440,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_MODULE) {
- /* A B R(A) := newmodule(R(A),Sym(B)) */
+ /* A B R(A) := newmodule(R(A),Sym(B)) */
struct RClass *c = 0;
int a = GETARG_A(i);
mrb_value base;
@@ -1448,7 +1448,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
base = regs[a];
if (mrb_nil_p(base)) {
- base = mrb_obj_value(mrb->ci->target_class);
+ base = mrb_obj_value(mrb->ci->target_class);
}
c = mrb_vm_define_module(mrb, base, id);
regs[a] = mrb_obj_value(c);
@@ -1456,7 +1456,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_EXEC) {
- /* A Bx R(A) := blockexec(R(A),SEQ[Bx]) */
+ /* A Bx R(A) := blockexec(R(A),SEQ[Bx]) */
int a = GETARG_A(i);
mrb_callinfo *ci;
mrb_value recv = regs[a];
@@ -1476,29 +1476,29 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
ci->proc = p;
if (MRB_PROC_CFUNC_P(p)) {
- mrb->stack[0] = p->body.func(mrb, recv);
- mrb->arena_idx = ai;
- if (mrb->exc) goto L_RAISE;
- /* pop stackpos */
- regs = mrb->stack = mrb->stbase + ci->stackidx;
- cipop(mrb);
- NEXT;
+ mrb->stack[0] = p->body.func(mrb, recv);
+ mrb->arena_idx = ai;
+ if (mrb->exc) goto L_RAISE;
+ /* pop stackpos */
+ regs = mrb->stack = mrb->stbase + ci->stackidx;
+ cipop(mrb);
+ NEXT;
}
else {
- /* setup environment for calling method */
- irep = p->body.irep;
- pool = irep->pool;
- syms = irep->syms;
- mrb->stack += a;
- stack_extend(mrb, irep->nregs, 1);
- regs = mrb->stack;
- pc = irep->iseq;
- JUMP;
+ /* setup environment for calling method */
+ irep = p->body.irep;
+ pool = irep->pool;
+ syms = irep->syms;
+ mrb->stack += a;
+ stack_extend(mrb, irep->nregs, 1);
+ regs = mrb->stack;
+ pc = irep->iseq;
+ JUMP;
}
}
CASE(OP_METHOD) {
- /* A B R(A).newmethod(Sym(B),R(A+1)) */
+ /* A B R(A).newmethod(Sym(B),R(A+1)) */
int a = GETARG_A(i);
struct RClass *c = mrb_class_ptr(regs[a]);
@@ -1507,39 +1507,39 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
}
CASE(OP_SCLASS) {
- /* A B R(A) := R(B).singleton_class */
+ /* A B R(A) := R(B).singleton_class */
regs[GETARG_A(i)] = mrb_singleton_class(mrb, regs[GETARG_B(i)]);
NEXT;
}
CASE(OP_TCLASS) {
- /* A B R(A) := target_class */
+ /* A B R(A) := target_class */
regs[GETARG_A(i)] = mrb_obj_value(mrb->ci->target_class);
NEXT;
}
CASE(OP_RANGE) {
- /* A B C R(A) := range_new(R(B),R(B+1),C) */
+ /* A B C R(A) := range_new(R(B),R(B+1),C) */
int b = GETARG_B(i);
regs[GETARG_A(i)] = mrb_range_new(mrb, regs[b], regs[b+1], GETARG_C(i));
NEXT;
}
CASE(OP_DEBUG) {
- /* A debug print R(A),R(B),R(C) */
+ /* A debug print R(A),R(B),R(C) */
printf("OP_DEBUG %d %d %d\n", GETARG_A(i), GETARG_B(i), GETARG_C(i));
NEXT;
}
CASE(OP_STOP) {
- /* stop VM */
+ /* stop VM */
L_STOP:
mrb->jmp = prev_jmp;
return mrb_nil_value();
}
CASE(OP_ERR) {
- /* Bx raise RuntimeError with message Lit(Bx) */
+ /* Bx raise RuntimeError with message Lit(Bx) */
mrb_value msg = pool[GETARG_Bx(i)];
mrb_value exc = mrb_exc_new3(mrb, mrb->eRuntimeError_class, msg);
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-15 01:02:18 +0000