/*

** codegen.c - mruby code generator

**

** See Copyright Notice in mruby.h

*/

#include <ctype.h>

#include <stdlib.h>

#include <string.h>

#include "mruby.h"

#include "mruby/compile.h"

#include "mruby/irep.h"

#include "mruby/numeric.h"

#include "mruby/string.h"

#include "node.h"

#include "opcode.h"

#include "re.h"

typedef mrb_ast_node node;

typedef struct mrb_parser_state parser_state;

enum looptype {

LOOP_NORMAL,

LOOP_BLOCK,

LOOP_FOR,

LOOP_BEGIN,

LOOP_RESCUE,

} type;

struct loopinfo {

enum looptype type;

int pc1, pc2, pc3, acc;

int ensure_level;

struct loopinfo *prev;

};

typedef struct scope {

mrb_state *mrb;

mrb_pool *mpool;

jmp_buf jmp;

struct scope *prev;

node *lv;

int sp;

int pc;

int lastlabel;

int ainfo:15;

mrb_bool mscope:1;

struct loopinfo *loop;

int ensure_level;

char *filename;

short lineno;

mrb_code *iseq;

short *lines;

int icapa;

mrb_irep *irep;

size_t pcapa;

int scapa;

int nlocals;

int nregs;

int ai;

int idx;

} codegen_scope;

static codegen_scope* scope_new(mrb_state *mrb, codegen_scope *prev, node *lv);

static void scope_finish(codegen_scope *s);

static struct loopinfo *loop_push(codegen_scope *s, enum looptype t);

static void loop_break(codegen_scope *s, node *tree);

static void loop_pop(codegen_scope *s, int val);

static void gen_assignment(codegen_scope *s, node *node, int sp, int val);

static void gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val);

static void codegen(codegen_scope *s, node *tree, int val);

static void

codegen_error(codegen_scope *s, const char *message)

{

if (!s) return;

while (s->prev) {

mrb_pool_close(s->mpool);

s = s->prev;

}

mrb_pool_close(s->mpool);

#ifdef ENABLE_STDIO

if (s->filename && s->lineno) {

fprintf(stderr, "codegen error:%s:%d: %s\n", s->filename, s->lineno, message);

}

else {

fprintf(stderr, "codegen error: %s\n", message);

}

#endif

longjmp(s->jmp, 1);

}

static void*

codegen_palloc(codegen_scope *s, size_t len)

{

void *p = mrb_pool_alloc(s->mpool, len);

if (!p) codegen_error(s, "pool memory allocation");

return p;

}

void*

codegen_malloc(codegen_scope *s, size_t len)

{

void *p = mrb_malloc(s->mrb, len);

if (!p) codegen_error(s, "mrb_malloc");

return p;

}

void*

codegen_realloc(codegen_scope *s, void *p, size_t len)

{

p = mrb_realloc(s->mrb, p, len);

if (!p && len > 0) codegen_error(s, "mrb_realloc");

return p;

}

static int

new_label(codegen_scope *s)

{

s->lastlabel = s->pc;

return s->pc;

}

static inline void

genop(codegen_scope *s, mrb_code i)

{

if (s->pc == s->icapa) {

s->icapa *= 2;

s->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa);

if (s->lines) {

s->lines = (short*)codegen_realloc(s, s->lines, sizeof(short)*s->icapa);

}

}

s->iseq[s->pc] = i;

if (s->lines) {

s->lines[s->pc] = s->lineno;

}

s->pc++;

}

#define NOVAL 0

#define VAL 1

static void

genop_peep(codegen_scope *s, mrb_code i, int val)

{

/* peephole optimization */

if (s->lastlabel != s->pc && s->pc > 0) {

mrb_code i0 = s->iseq[s->pc-1];

int c1 = GET_OPCODE(i);

int c0 = GET_OPCODE(i0);

switch (c1) {

case OP_MOVE:

if (GETARG_A(i) == GETARG_B(i)) {

/* skip useless OP_MOVE */

return;

}

if (val) break;

switch (c0) {

case OP_MOVE:

if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i) == GETARG_B(i0) && GETARG_A(i) >= s->nlocals) {

/* skip swapping OP_MOVE */

return;

}

if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {

s->iseq[s->pc-1] = MKOP_AB(OP_MOVE, GETARG_A(i), GETARG_B(i0));

return;

}

break;

case OP_LOADI:

if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {

s->iseq[s->pc-1] = MKOP_AsBx(OP_LOADI, GETARG_A(i), GETARG_sBx(i0));

return;

}

break;

case OP_ARRAY:

case OP_HASH:

case OP_RANGE:

case OP_AREF:

case OP_GETUPVAR:

if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {

s->iseq[s->pc-1] = MKOP_ABC(c0, GETARG_A(i), GETARG_B(i0), GETARG_C(i0));

return;

}

break;

case OP_LOADSYM:

case OP_GETGLOBAL:

case OP_GETIV:

case OP_GETCV:

case OP_GETCONST:

case OP_GETSPECIAL:

case OP_LOADL:

case OP_STRING:

if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {

s->iseq[s->pc-1] = MKOP_ABx(c0, GETARG_A(i), GETARG_Bx(i0));

return;

}

break;

case OP_SCLASS:

if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {

s->iseq[s->pc-1] = MKOP_AB(c0, GETARG_A(i), GETARG_B(i0));

return;

}

break;

case OP_LOADNIL:

case OP_LOADSELF:

case OP_LOADT:

case OP_LOADF:

case OP_OCLASS:

if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {

s->iseq[s->pc-1] = MKOP_A(c0, GETARG_A(i));

return;

}

break;

default:

break;

}

break;

case OP_SETIV:

case OP_SETCV:

case OP_SETCONST:

case OP_SETMCNST:

case OP_SETGLOBAL:

if (val) break;

if (c0 == OP_MOVE) {

if (GETARG_A(i) == GETARG_A(i0)) {

s->iseq[s->pc-1] = MKOP_ABx(c1, GETARG_B(i0), GETARG_Bx(i));

return;

}

}

break;

case OP_SETUPVAR:

if (val) break;

if (c0 == OP_MOVE) {

if (GETARG_A(i) == GETARG_A(i0)) {

s->iseq[s->pc-1] = MKOP_ABC(c1, GETARG_B(i0), GETARG_B(i), GETARG_C(i));

return;

}

}

break;

case OP_EPOP:

if (c0 == OP_EPOP) {

s->iseq[s->pc-1] = MKOP_A(OP_EPOP, GETARG_A(i0)+GETARG_A(i));

return;

}

break;

case OP_POPERR:

if (c0 == OP_POPERR) {

s->iseq[s->pc-1] = MKOP_A(OP_POPERR, GETARG_A(i0)+GETARG_A(i));

return;

}

break;

case OP_RETURN:

switch (c0) {

case OP_RETURN:

return;

case OP_MOVE:

s->iseq[s->pc-1] = MKOP_AB(OP_RETURN, GETARG_B(i0), OP_R_NORMAL);

return;

case OP_LOADI:

s->iseq[s->pc-1] = MKOP_AsBx(OP_LOADI, 0, GETARG_sBx(i0));

genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));

return;

case OP_ARRAY:

case OP_HASH:

case OP_RANGE:

case OP_AREF:

case OP_GETUPVAR:

s->iseq[s->pc-1] = MKOP_ABC(c0, 0, GETARG_B(i0), GETARG_C(i0));

genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));

return;

case OP_SETIV:

case OP_SETCV:

case OP_SETCONST:

case OP_SETMCNST:

case OP_SETUPVAR:

case OP_SETGLOBAL:

s->pc--;

genop_peep(s, i0, NOVAL);

i0 = s->iseq[s->pc-1];

genop(s, MKOP_AB(OP_RETURN, GETARG_A(i0), OP_R_NORMAL));

return;

case OP_LOADSYM:

case OP_GETGLOBAL:

case OP_GETIV:

case OP_GETCV:

case OP_GETCONST:

case OP_GETSPECIAL:

case OP_LOADL:

case OP_STRING:

s->iseq[s->pc-1] = MKOP_ABx(c0, 0, GETARG_Bx(i0));

genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));

return;

case OP_SCLASS:

s->iseq[s->pc-1] = MKOP_AB(c0, GETARG_A(i), GETARG_B(i0));

genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));

return;

case OP_LOADNIL:

case OP_LOADSELF:

case OP_LOADT:

case OP_LOADF:

case OP_OCLASS:

s->iseq[s->pc-1] = MKOP_A(c0, 0);

genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));

return;

#if 0

case OP_SEND:

if (GETARG_B(i) == OP_R_NORMAL && GETARG_A(i) == GETARG_A(i0)) {

s->iseq[s->pc-1] = MKOP_ABC(OP_TAILCALL, GETARG_A(i0), GETARG_B(i0), GETARG_C(i0));

return;

}

break;

#endif

default:

break;

}

break;

case OP_ADD:

case OP_SUB:

if (c0 == OP_LOADI) {

int c = GETARG_sBx(i0);

if (c1 == OP_SUB) c = -c;

if (c > 127 || c < -127) break;

if (0 <= c)

s->iseq[s->pc-1] = MKOP_ABC(OP_ADDI, GETARG_A(i), GETARG_B(i), c);

else

s->iseq[s->pc-1] = MKOP_ABC(OP_SUBI, GETARG_A(i), GETARG_B(i), -c);

return;

}

case OP_STRCAT:

if (c0 == OP_STRING) {

int i = GETARG_Bx(i0);

if (mrb_type(s->irep->pool[i]) == MRB_TT_STRING &&

RSTRING_LEN(s->irep->pool[i]) == 0) {

s->pc--;

return;

}

}

break;

default:

break;

}

}

genop(s, i);

}

static void

scope_error(codegen_scope *s)

{

exit(EXIT_FAILURE);

}

static inline void

dispatch(codegen_scope *s, int pc)

{

int diff = s->pc - pc;

mrb_code i = s->iseq[pc];

int c = GET_OPCODE(i);

s->lastlabel = s->pc;

switch (c) {

case OP_JMP:

case OP_JMPIF:

case OP_JMPNOT:

case OP_ONERR:

break;

default:

#ifdef ENABLE_STDIO

fprintf(stderr, "bug: dispatch on non JMP op\n");

#endif

scope_error(s);

break;

}

s->iseq[pc] = MKOP_AsBx(c, GETARG_A(i), diff);

}

static void

dispatch_linked(codegen_scope *s, int pc)

{

mrb_code i;

int pos;

if (!pc) return;

for (;;) {

i = s->iseq[pc];

pos = GETARG_sBx(i);

dispatch(s, pc);

if (!pos) break;

pc = pos;

}

}

#define nregs_update do {if (s->sp > s->nregs) s->nregs = s->sp;} while (0)

static void

push_(codegen_scope *s)

{

if (s->sp > 511) {

codegen_error(s, "too complex expression");

}

s->sp++;

nregs_update;

}

#define push() push_(s)

#define pop_(s) ((s)->sp--)

#define pop() pop_(s)

#define pop_n(n) (s->sp-=(n))

#define cursp() (s->sp)

static inline int

new_lit(codegen_scope *s, mrb_value val)

{

size_t i;

switch (mrb_type(val)) {

case MRB_TT_STRING:

for (i=0; i<s->irep->plen; i++) {

mrb_value pv = s->irep->pool[i];

mrb_int len;

if (mrb_type(pv) != MRB_TT_STRING) continue;

if ((len = RSTRING_LEN(pv)) != RSTRING_LEN(val)) continue;

if (memcmp(RSTRING_PTR(pv), RSTRING_PTR(val), len) == 0)

return i;

}

break;

case MRB_TT_FLOAT:

default:

for (i=0; i<s->irep->plen; i++) {

if (mrb_obj_equal(s->mrb, s->irep->pool[i], val)) return i;

}

break;

}

if (s->irep->plen == s->pcapa) {

s->pcapa *= 2;

s->irep->pool = (mrb_value *)codegen_realloc(s, s->irep->pool, sizeof(mrb_value)*s->pcapa);

}

s->irep->pool[s->irep->plen] = val;

i = s->irep->plen++;

return i;

}

static inline int

new_msym(codegen_scope *s, mrb_sym sym)

{

size_t i, len;

len = s->irep->slen;

if (len > 256) len = 256;

for (i=0; i<len; i++) {

if (s->irep->syms[i] == sym) return i;

if (s->irep->syms[i] == 0) break;

}

if (i == 256) {

codegen_error(s, "too many symbols (max 256)");

}

s->irep->syms[i] = sym;

if (i == s->irep->slen) s->irep->slen++;

return i;

}

static inline int

new_sym(codegen_scope *s, mrb_sym sym)

{

size_t i;

for (i=0; i<s->irep->slen; i++) {

if (s->irep->syms[i] == sym) return i;

}

if (s->irep->slen > 125 && s->irep->slen < 256) {

s->irep->syms = (mrb_sym *)codegen_realloc(s, s->irep->syms, sizeof(mrb_sym)*65536);

for (i = 0; i < 256 - s->irep->slen; i++) {

static const mrb_sym mrb_sym_zero = { 0 };

s->irep->syms[i + s->irep->slen] = mrb_sym_zero;

}

s->irep->slen = 256;

}

s->irep->syms[s->irep->slen] = sym;

return s->irep->slen++;

}

static int

node_len(node *tree)

{

int n = 0;

while (tree) {

n++;

tree = tree->cdr;

}

return n;

}

#define sym(x) ((mrb_sym)(intptr_t)(x))

#define lv_name(lv) sym((lv)->car)

static int

lv_idx(codegen_scope *s, mrb_sym id)

{

node *lv = s->lv;

int n = 1;

while (lv) {

if (lv_name(lv) == id) return n;

n++;

lv = lv->cdr;

}

return 0;

}

static void

for_body(codegen_scope *s, node *tree)

{

codegen_scope *prev = s;

int idx, base = s->idx;

struct loopinfo *lp;

node *n2;

mrb_code c;

// generate receiver

codegen(s, tree->cdr->car, VAL);

// generate loop-block

s = scope_new(s->mrb, s, tree->car);

idx = s->idx;

lp = loop_push(s, LOOP_FOR);

lp->pc1 = new_label(s);

// generate loop variable

n2 = tree->car;

if (n2->car && !n2->car->cdr && !n2->cdr) {

genop(s, MKOP_Ax(OP_ENTER, 0x40000));

gen_assignment(s, n2->car->car, 1, NOVAL);

}

else {

genop(s, MKOP_Ax(OP_ENTER, 0x40000));

gen_vmassignment(s, n2, 1, VAL);

}

codegen(s, tree->cdr->cdr->car, VAL);

pop();

if (s->pc > 0) {

c = s->iseq[s->pc-1];

if (GET_OPCODE(c) != OP_RETURN || GETARG_B(c) != OP_R_NORMAL || s->pc == s->lastlabel)

genop_peep(s, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL), NOVAL);

}

loop_pop(s, NOVAL);

scope_finish(s);

s = prev;

genop(s, MKOP_Abc(OP_LAMBDA, cursp(), idx - base, OP_L_BLOCK));

pop();

idx = new_msym(s, mrb_intern2(s->mrb, "each", 4));

genop(s, MKOP_ABC(OP_SENDB, cursp(), idx, 0));

}

static int

lambda_body(codegen_scope *s, node *tree, int blk)

{

int idx, base = s->idx;

mrb_code c;

s = scope_new(s->mrb, s, tree->car);

idx = s->idx;

s->mscope = !blk;

if (blk) {

struct loopinfo *lp = loop_push(s, LOOP_BLOCK);

lp->pc1 = new_label(s);

}

tree = tree->cdr;

if (tree->car) {

mrb_aspec a;

int ma, oa, ra, pa, ka, kd, ba;

int pos, i;

node *n, *opt;

ma = node_len(tree->car->car);

n = tree->car->car;

while (n) {

n = n->cdr;

}

oa = node_len(tree->car->cdr->car);

ra = tree->car->cdr->cdr->car ? 1 : 0;

pa = node_len(tree->car->cdr->cdr->cdr->car);

ka = kd = 0;

ba = tree->car->cdr->cdr->cdr->cdr ? 1 : 0;

a = ((mrb_aspec)(ma & 0x1f) << 18)

| ((mrb_aspec)(oa & 0x1f) << 13)

| ((ra & 1) << 12)

| ((pa & 0x1f) << 7)

| ((ka & 0x1f) << 2)

| ((kd & 1)<< 1)

| (ba & 1);

s->ainfo = (((ma+oa) & 0x3f) << 6) /* (12bits = 6:1:5) */

| ((ra & 1) << 5)

| (pa & 0x1f);

genop(s, MKOP_Ax(OP_ENTER, a));

pos = new_label(s);

for (i=0; i<oa; i++) {

new_label(s);

genop(s, MKOP_sBx(OP_JMP, 0));

}

if (oa > 0) {

genop(s, MKOP_sBx(OP_JMP, 0));

}

opt = tree->car->cdr->car;

i = 0;

while (opt) {

int idx;

dispatch(s, pos+i);

codegen(s, opt->car->cdr, VAL);

idx = lv_idx(s, (mrb_sym)(intptr_t)opt->car->car);

pop();

genop_peep(s, MKOP_AB(OP_MOVE, idx, cursp()), NOVAL);

i++;

opt = opt->cdr;

}

if (oa > 0) {

dispatch(s, pos+i);

}

}

codegen(s, tree->cdr->car, VAL);

pop();

if (s->pc > 0) {

c = s->iseq[s->pc-1];

if (GET_OPCODE(c) != OP_RETURN || GETARG_B(c) != OP_R_NORMAL || s->pc == s->lastlabel) {

if (s->nregs == 0) {

genop(s, MKOP_A(OP_LOADNIL, 0));

genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));

}

else {

genop_peep(s, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL), NOVAL);

}

}

}

if (blk) {

loop_pop(s, NOVAL);

}

scope_finish(s);

return idx - base;

}

static int

scope_body(codegen_scope *s, node *tree)

{

codegen_scope *scope = scope_new(s->mrb, s, tree->car);

int idx = scope->idx;

codegen(scope, tree->cdr, VAL);

if (!s->iseq) {

genop(scope, MKOP_A(OP_STOP, 0));

}

else {

if (scope->nregs == 0) {

genop(scope, MKOP_A(OP_LOADNIL, 0));

genop(scope, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));

}

else {

genop_peep(scope, MKOP_AB(OP_RETURN, scope->sp, OP_R_NORMAL), NOVAL);

}

}

scope_finish(scope);

return idx - s->idx;

}

static int

nosplat(node *t)

{

while (t) {

if ((intptr_t)t->car->car == NODE_SPLAT) return FALSE;

t = t->cdr;

}

return TRUE;

}

static mrb_sym

attrsym(codegen_scope *s, mrb_sym a)

{

const char *name;

size_t len;

char *name2;

name = mrb_sym2name_len(s->mrb, a, &len);

name2 = (char *)codegen_palloc(s, len+1);

memcpy(name2, name, len);

name2[len] = '=';

name2[len+1] = '\0';

return mrb_intern2(s->mrb, name2, len+1);

}

static int

gen_values(codegen_scope *s, node *t, int val)

{

int n = 0;

while (t) {

if (n >= 127 || (intptr_t)t->car->car == NODE_SPLAT) { // splat mode

if (val) {

pop_n(n);

genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), n));

push();

codegen(s, t->car, VAL);

pop(); pop();

genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));

t = t->cdr;

while (t) {

push();

codegen(s, t->car, VAL);

pop(); pop();

if ((intptr_t)t->car->car == NODE_SPLAT) {

genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));

}

else {

genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1));

}

t = t->cdr;

}

}

else {

codegen(s, t->car->cdr, NOVAL);

t = t->cdr;

while (t) {

codegen(s, t->car, NOVAL);

t = t->cdr;

}

}

return -1;

}

// normal (no splat) mode

codegen(s, t->car, val);

n++;

t = t->cdr;

}

return n;

}

#define CALL_MAXARGS 127

static void

gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val)

{

mrb_sym sym = name ? name : sym(tree->cdr->car);

int idx;

int n = 0, noop = 0, sendv = 0, blk = 0;

codegen(s, tree->car, VAL); /* receiver */

idx = new_msym(s, sym);

tree = tree->cdr->cdr->car;

if (tree) {

n = gen_values(s, tree->car, VAL);

if (n < 0) {

n = noop = sendv = 1;

push();

}

}

if (sp) {

if (sendv) {

pop();

genop(s, MKOP_AB(OP_ARYPUSH, cursp(), sp));

push();

}

else {

genop(s, MKOP_AB(OP_MOVE, cursp(), sp));

push();

n++;

}

}

if (tree && tree->cdr) {

noop = 1;

codegen(s, tree->cdr, VAL);

pop();

}

else {

blk = cursp();

}

pop_n(n+1);

{

size_t len;

const char *name = mrb_sym2name_len(s->mrb, sym, &len);

if (!noop && len == 1 && name[0] == '+') {

genop_peep(s, MKOP_ABC(OP_ADD, cursp(), idx, n), val);

}

else if (!noop && len == 1 && name[0] == '-') {

genop_peep(s, MKOP_ABC(OP_SUB, cursp(), idx, n), val);

}

else if (!noop && len == 1 && name[0] == '*') {

genop(s, MKOP_ABC(OP_MUL, cursp(), idx, n));

}

else if (!noop && len == 1 && name[0] == '/') {

genop(s, MKOP_ABC(OP_DIV, cursp(), idx, n));

}

else if (!noop && len == 1 && name[0] == '<') {

genop(s, MKOP_ABC(OP_LT, cursp(), idx, n));

}

else if (!noop && len == 2 && name[0] == '<' && name[1] == '=') {

genop(s, MKOP_ABC(OP_LE, cursp(), idx, n));

}

else if (!noop && len == 1 && name[0] == '>') {

genop(s, MKOP_ABC(OP_GT, cursp(), idx, n));

}

else if (!noop && len == 2 && name[0] == '>' && name[1] == '=') {

genop(s, MKOP_ABC(OP_GE, cursp(), idx, n));

}

else if (!noop && len == 2 && name[0] == '=' && name[1] == '=') {

genop(s, MKOP_ABC(OP_EQ, cursp(), idx, n));

}

else {

if (sendv) n = CALL_MAXARGS;

if (blk > 0) { /* no block */

genop(s, MKOP_ABC(OP_SEND, cursp(), idx, n));

}

else {

genop(s, MKOP_ABC(OP_SENDB, cursp(), idx, n));

}

}

}

if (val) {

push();

}

}

static void

gen_assignment(codegen_scope *s, node *node, int sp, int val)

{

int idx;

int type = (intptr_t)node->car;

node = node->cdr;

switch ((intptr_t)type) {

case NODE_GVAR:

idx = new_sym(s, sym(node));

genop_peep(s, MKOP_ABx(OP_SETGLOBAL, sp, idx), val);

break;

case NODE_LVAR:

idx = lv_idx(s, sym(node));

if (idx > 0) {

if (idx != sp) {

genop_peep(s, MKOP_AB(OP_MOVE, idx, sp), val);

}

break;

}

else { /* upvar */

int lv = 0;

codegen_scope *up = s->prev;

while (up) {

idx = lv_idx(up, sym(node));

if (idx > 0) {

genop_peep(s, MKOP_ABC(OP_SETUPVAR, sp, idx, lv), val);

break;

}

lv++;

up = up->prev;

}

}

break;

case NODE_IVAR:

idx = new_sym(s, sym(node));

genop_peep(s, MKOP_ABx(OP_SETIV, sp, idx), val);

break;

case NODE_CVAR:

idx = new_sym(s, sym(node));

genop_peep(s, MKOP_ABx(OP_SETCV, sp, idx), val);

break;

case NODE_CONST:

idx = new_sym(s, sym(node));

genop_peep(s, MKOP_ABx(OP_SETCONST, sp, idx), val);

break;

case NODE_COLON2:

idx = new_sym(s, sym(node->cdr));

genop_peep(s, MKOP_AB(OP_MOVE, cursp(), sp), NOVAL);

push();

codegen(s, node->car, VAL);

pop_n(2);

genop_peep(s, MKOP_ABx(OP_SETMCNST, cursp(), idx), val);

break;

case NODE_CALL:

push();

gen_call(s, node, attrsym(s, sym(node->cdr->car)), sp, NOVAL);

pop();

if (val) {

genop_peep(s, MKOP_AB(OP_MOVE, cursp(), sp), val);

}

break;

default:

#ifdef ENABLE_STDIO

printf("unknown lhs %d\n", type);

#endif

break;

}

if (val) push();

}

static void

gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val)

{

int n = 0, post = 0;

node *t, *p;

if (tree->car) { /* pre */

t = tree->car;

n = 0;

while (t) {

genop(s, MKOP_ABC(OP_AREF, cursp(), rhs, n));

gen_assignment(s, t->car, cursp(), NOVAL);

n++;

t = t->cdr;

}

}

t = tree->cdr;

if (t) {

if (t->cdr) { /* post count */

p = t->cdr->car;

while (p) {

post++;

p = p->cdr;

}

}

if (val) {

genop(s, MKOP_AB(OP_MOVE, cursp(), rhs));

push();

}

pop();

genop(s, MKOP_ABC(OP_APOST, cursp(), n, post));

n = 1;

if (t->car) { /* rest */

gen_assignment(s, t->car, cursp(), NOVAL);

}

if (t->cdr && t->cdr->car) {

t = t->cdr->car;

while (t) {

gen_assignment(s, t->car, cursp()+n, NOVAL);

t = t->cdr;

n++;

}

}

}

}

static void

gen_send_intern(codegen_scope *s)

{

pop();

genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern2(s->mrb, "intern", 6)), 0));

push();

}

static void

gen_literal_array(codegen_scope *s, node *tree, int sym, int val)

{

if (val) {

int i = 0, j = 0;

while (tree) {

switch ((intptr_t)tree->car->car) {

case NODE_STR:

if ((tree->cdr == NULL) && ((intptr_t)tree->car->cdr->cdr == 0))

break;

/* fall through */

case NODE_BEGIN:

codegen(s, tree->car, VAL);

++j;

break;

case NODE_LITERAL_DELIM:

if (j > 0) {

j = 0;

++i;

if (sym)

gen_send_intern(s);

}

break;

}

if (j >= 2) {

pop(); pop();

genop_peep(s, MKOP_AB(OP_STRCAT, cursp(), cursp()+1), VAL);

push();