rm whitespace

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);