From 54dd5cc7fd42a8b073f64b7d16efdb1ed01e2dd5 Mon Sep 17 00:00:00 2001 From: Roberto Ierusalimschy Date: Fri, 7 Apr 2000 16:35:20 -0300 Subject: reorganization of lcode.c --- lcode.c | 460 +++++++++++++++++++++++++++++++------------------------------- lcode.h | 11 +- lparser.c | 33 ++--- 3 files changed, 252 insertions(+), 252 deletions(-) diff --git a/lcode.c b/lcode.c index 157724d1..c1bcc980 100644 --- a/lcode.c +++ b/lcode.c @@ -1,5 +1,5 @@ /* -** $Id: lcode.c,v 1.21 2000/04/06 17:36:52 roberto Exp roberto $ +** $Id: lcode.c,v 1.22 2000/04/07 13:13:11 roberto Exp roberto $ ** Code generator for Lua ** See Copyright Notice in lua.h */ @@ -23,8 +23,9 @@ void luaK_error (LexState *ls, const char *msg) { luaX_error(ls, msg, ls->token); } + /* -** Returns the the previous instruction, for optimizations. +** Returns the the previous instruction, for optimizations. ** If there is a jump target between this and the current instruction, ** returns a dummy instruction to avoid wrong optimizations. */ @@ -36,154 +37,8 @@ static Instruction previous_instruction (FuncState *fs) { } -int luaK_code (FuncState *fs, Instruction i, int delta) { - luaK_deltastack(fs, delta); - luaM_growvector(fs->L, fs->f->code, fs->pc, 1, Instruction, codeEM, MAX_INT); - fs->f->code[fs->pc] = i; - return fs->pc++; -} - -int luaK_0(FuncState *fs, OpCode o, int d) { - return luaK_code(fs, CREATE_0(o), d); -} - -int luaK_U(FuncState *fs, OpCode o, int u, int d) { - return luaK_code(fs, CREATE_U(o,u), d); -} - -int luaK_S(FuncState *fs, OpCode o, int s, int d) { - return luaK_code(fs, CREATE_S(o,s), d); -} - -int luaK_AB(FuncState *fs, OpCode o, int a, int b, int d) { - return luaK_code(fs, CREATE_AB(o,a,b), d); -} - - -static Instruction prepare (FuncState *fs, Instruction i, int delta) { - Instruction previous = previous_instruction(fs); - luaK_code(fs, i, delta); - return previous; -} - - -static void setprevious (FuncState *fs, Instruction i) { - fs->pc--; /* remove last instruction */ - fs->f->code[fs->pc-1] = i; /* change previous instruction */ -} - - -static void luaK_minus (FuncState *fs) { - /* PUSHINT s; MINUS -> PUSHINT -s (-k) */ - /* PUSHNUM u; MINUS -> PUSHNEGNUM u (-k) */ - Instruction previous = prepare(fs, CREATE_0(OP_MINUS), 0); - switch(GET_OPCODE(previous)) { - case OP_PUSHINT: SETARG_S(previous, -GETARG_S(previous)); break; - case OP_PUSHNUM: SET_OPCODE(previous, OP_PUSHNEGNUM); break; - default: return; - } - setprevious(fs, previous); -} - - -static void luaK_gettable (FuncState *fs) { - /* PUSHSTRING u; GETTABLE -> GETDOTTED u (t.x) */ - /* GETLOCAL u; GETTABLE -> GETINDEXED u (t[i]) */ - Instruction previous = prepare(fs, CREATE_0(OP_GETTABLE), -1); - switch(GET_OPCODE(previous)) { - case OP_PUSHSTRING: SET_OPCODE(previous, OP_GETDOTTED); break; - case OP_GETLOCAL: SET_OPCODE(previous, OP_GETINDEXED); break; - default: return; - } - setprevious(fs, previous); -} - - -static void luaK_add (FuncState *fs) { - /* PUSHINT s; ADD -> ADDI s (a+k) */ - Instruction previous = prepare(fs, CREATE_0(OP_ADD), -1); - switch(GET_OPCODE(previous)) { - case OP_PUSHINT: SET_OPCODE(previous, OP_ADDI); break; - default: return; - } - setprevious(fs, previous); -} - - -static void luaK_sub (FuncState *fs) { - /* PUSHINT s; SUB -> ADDI -s (a-k) */ - Instruction previous = prepare(fs, CREATE_0(OP_SUB), -1); - switch(GET_OPCODE(previous)) { - case OP_PUSHINT: - SET_OPCODE(previous, OP_ADDI); - SETARG_S(previous, -GETARG_S(previous)); - break; - default: return; - } - setprevious(fs, previous); -} - - -static void luaK_conc (FuncState *fs) { - /* CONCAT u; CONCAT 2 -> CONCAT u+1 (a..b..c) */ - Instruction previous = prepare(fs, CREATE_U(OP_CONCAT, 2), -1); - switch(GET_OPCODE(previous)) { - case OP_CONCAT: SETARG_U(previous, GETARG_U(previous)+1); break; - default: return; - } - setprevious(fs, previous); -} - - -static void luaK_getlocal (FuncState *fs, int l) { - /* SETLOCAL l 1; GETLOCAL l -> SETLOCAL l 0 */ - Instruction previous = prepare(fs, CREATE_U(OP_GETLOCAL, l), 1); - if (previous == CREATE_AB(OP_SETLOCAL, l, 1)) { - SETARG_B(previous, 0); - setprevious(fs, previous); - } -} - - -static void luaK_setlocal (FuncState *fs, int l) { - /* GETLOCAL l; ADDI k, SETLOCAL l -> INCLOCAL k, l ((local)a=a+k) */ - Instruction *code = fs->f->code; - int pc = fs->pc; - if (pc-1 > fs->lasttarget && /* no jumps in-between instructions? */ - code[pc-2] == CREATE_U(OP_GETLOCAL, l) && - GET_OPCODE(code[pc-1]) == OP_ADDI && - abs(GETARG_S(code[pc-1])) <= MAXARG_sA) { - int inc = GETARG_S(code[pc-1]); - fs->pc = pc-1; - code[pc-2] = CREATE_sAB(OP_INCLOCAL, inc, l); - luaK_deltastack(fs, -1); - } - else - luaK_AB(fs, OP_SETLOCAL, l, 1, -1); -} - - -static void luaK_eq (FuncState *fs) { - /* PUSHNIL 1; JMPEQ -> NOT (a==nil) */ - Instruction previous = prepare(fs, CREATE_S(OP_JMPEQ, NO_JUMP), -2); - if (previous == CREATE_U(OP_PUSHNIL, 1)) { - setprevious(fs, CREATE_0(OP_NOT)); - luaK_deltastack(fs, 1); /* undo delta from `prepare' */ - } -} - - -static void luaK_neq (FuncState *fs) { - /* PUSHNIL 1; JMPNE -> JMPT (a~=nil) */ - Instruction previous = prepare(fs, CREATE_S(OP_JMPNE, NO_JUMP), -2); - if (previous == CREATE_U(OP_PUSHNIL, 1)) { - setprevious(fs, CREATE_S(OP_JMPT, NO_JUMP)); - } -} - - int luaK_jump (FuncState *fs) { - int j = luaK_S(fs, OP_JMP, NO_JUMP, 0); + int j = luaK_code1(fs, OP_JMP, NO_JUMP); if (j == fs->lasttarget) { /* possible jumps to this jump? */ luaK_concat(fs, &j, fs->jlt); /* keep them on hold */ fs->jlt = NO_JUMP; @@ -192,38 +47,6 @@ int luaK_jump (FuncState *fs) { } -void luaK_retcode (FuncState *fs, int nlocals, int nexps) { - Instruction previous = prepare(fs, CREATE_U(OP_RETURN, nlocals), 0); - if (nexps > 0 && GET_OPCODE(previous) == OP_CALL) { - LUA_ASSERT(fs->L, GETARG_B(previous) == MULT_RET, "call should be open"); - SET_OPCODE(previous, OP_TAILCALL); - SETARG_B(previous, nlocals); - setprevious(fs, previous); - } -} - - -static void luaK_pushnil (FuncState *fs, int n) { - Instruction previous = prepare(fs, CREATE_U(OP_PUSHNIL, n), n); - switch(GET_OPCODE(previous)) { - case OP_PUSHNIL: SETARG_U(previous, GETARG_U(previous)+n); break; - default: return; - } - setprevious(fs, previous); -} - - -static void luaK_pop (FuncState *fs, int n) { - Instruction previous = prepare(fs, CREATE_U(OP_POP, n), -n); - switch(GET_OPCODE(previous)) { - case OP_SETTABLE: SETARG_B(previous, GETARG_B(previous)+n); break; - case OP_SETLOCAL: SETARG_B(previous, GETARG_B(previous)+n); break; - default: return; - } - setprevious(fs, previous); -} - - static void luaK_fixjump (FuncState *fs, int pc, int dest) { Instruction *jmp = &fs->f->code[pc]; if (dest == NO_JUMP) @@ -274,7 +97,7 @@ void luaK_deltastack (FuncState *fs, int delta) { void luaK_kstr (LexState *ls, int c) { - luaK_U(ls->fs, OP_PUSHSTRING, c, 1); + luaK_code1(ls->fs, OP_PUSHSTRING, c); } @@ -295,17 +118,17 @@ static int real_constant (FuncState *fs, Number r) { void luaK_number (FuncState *fs, Number f) { if (f <= (Number)MAXARG_S && (int)f == f) - luaK_S(fs, OP_PUSHINT, (int)f, 1); /* f has a short integer value */ + luaK_code1(fs, OP_PUSHINT, (int)f); /* f has a short integer value */ else - luaK_U(fs, OP_PUSHNUM, real_constant(fs, f), 1); + luaK_code1(fs, OP_PUSHNUM, real_constant(fs, f)); } void luaK_adjuststack (FuncState *fs, int n) { if (n > 0) - luaK_pop(fs, n); + luaK_code1(fs, OP_POP, n); else if (n < 0) - luaK_pushnil(fs, -n); + luaK_code1(fs, OP_PUSHNIL, -n); } @@ -334,14 +157,14 @@ static void assertglobal (FuncState *fs, int index) { static int discharge (FuncState *fs, expdesc *var) { switch (var->k) { case VLOCAL: - luaK_getlocal(fs, var->u.index); + luaK_code1(fs, OP_GETLOCAL, var->u.index); break; case VGLOBAL: - luaK_U(fs, OP_GETGLOBAL, var->u.index, 1); + luaK_code1(fs, OP_GETGLOBAL, var->u.index); assertglobal(fs, var->u.index); /* make sure that there is a global */ break; case VINDEXED: - luaK_gettable(fs); + luaK_code0(fs, OP_GETTABLE); break; case VEXP: return 0; /* nothing to do */ @@ -358,20 +181,20 @@ static void discharge1 (FuncState *fs, expdesc *var) { if (var->u.l.t == NO_JUMP && var->u.l.f == NO_JUMP) luaK_setcallreturns(fs, 1); /* call must return 1 value */ } - + void luaK_storevar (LexState *ls, const expdesc *var) { FuncState *fs = ls->fs; switch (var->k) { case VLOCAL: - luaK_setlocal(fs, var->u.index); + luaK_code1(fs, OP_SETLOCAL, var->u.index); break; case VGLOBAL: - luaK_U(fs, OP_SETGLOBAL, var->u.index, -1); + luaK_code1(fs, OP_SETGLOBAL, var->u.index); assertglobal(fs, var->u.index); /* make sure that there is a global */ break; case VINDEXED: /* table is at top-3; pop 3 elements after operation */ - luaK_AB(fs, OP_SETTABLE, 3, 3, -3); + luaK_code2(fs, OP_SETTABLE, 3, 3); break; default: LUA_INTERNALERROR(ls->L, "invalid var kind to store"); @@ -396,16 +219,6 @@ static OpCode invertjump (OpCode op) { } -static void luaK_condjump (FuncState *fs, OpCode jump) { - Instruction previous = prepare(fs, CREATE_S(jump, NO_JUMP), -1); - switch (GET_OPCODE(previous)) { - case OP_NOT: previous = CREATE_S(invertjump(jump), NO_JUMP); break; - default: return; - } - setprevious(fs, previous); -} - - static void luaK_patchlistaux (FuncState *fs, int list, int target, OpCode special, int special_target) { Instruction *code = fs->f->code; @@ -475,7 +288,7 @@ static void luaK_testgo (FuncState *fs, expdesc *v, int invert, OpCode jump) { SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous))); } else - luaK_condjump(fs, jump); + luaK_code0(fs, jump); luaK_concat(fs, exitlist, fs->pc-1); /* insert last jump in `exitlist' */ luaK_patchlist(fs, *golist, luaK_getlabel(fs)); *golist = NO_JUMP; @@ -508,23 +321,25 @@ void luaK_tostack (LexState *ls, expdesc *v, int onlyone) { int final; /* position after whole expression */ if (ISJUMP(previous)) { luaK_concat(fs, &v->u.l.t, fs->pc-1); /* put `previous' in true list */ - p_nil = luaK_0(fs, OP_PUSHNILJMP, 0); - p_1 = luaK_S(fs, OP_PUSHINT, 1, 1); + p_nil = luaK_code0(fs, OP_PUSHNILJMP); + p_1 = luaK_code1(fs, OP_PUSHINT, 1); } else { /* still may need a PUSHNIL or a PUSHINT */ int need_nil = need_value(fs, v->u.l.f, OP_JMPONF); int need_1 = need_value(fs, v->u.l.t, OP_JMPONT); if (need_nil && need_1) { - luaK_S(fs, OP_JMP, 2, 0); /* skip both pushes */ - p_nil = luaK_0(fs, OP_PUSHNILJMP, 0); - p_1 = luaK_S(fs, OP_PUSHINT, 1, 0); + luaK_code1(fs, OP_JMP, 2); /* skip both pushes */ + p_nil = luaK_code0(fs, OP_PUSHNILJMP); + p_1 = luaK_code1(fs, OP_PUSHINT, 1); + luaK_deltastack(fs, -1); /* previous PUSHINT may be skipped */ } else if (need_nil || need_1) { - luaK_S(fs, OP_JMP, 1, 0); /* skip one push */ + luaK_code1(fs, OP_JMP, 1); /* skip one push */ if (need_nil) - p_nil = luaK_U(fs, OP_PUSHNIL, 1, 0); + p_nil = luaK_code1(fs, OP_PUSHNIL, 1); else /* need_1 */ - p_1 = luaK_S(fs, OP_PUSHINT, 1, 0); + p_1 = luaK_code1(fs, OP_PUSHINT, 1); + luaK_deltastack(fs, -1); /* previous PUSHs may be skipped */ } } final = luaK_getlabel(fs); @@ -540,7 +355,7 @@ void luaK_prefix (LexState *ls, int op, expdesc *v) { FuncState *fs = ls->fs; if (op == '-') { luaK_tostack(ls, v, 1); - luaK_minus(fs); + luaK_code0(fs, OP_MINUS); } else { /* op == NOT */ Instruction *previous; @@ -549,7 +364,7 @@ void luaK_prefix (LexState *ls, int op, expdesc *v) { if (ISJUMP(GET_OPCODE(*previous))) SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous))); else - luaK_0(fs, OP_NOT, 0); + luaK_code0(fs, OP_NOT); /* interchange true and false lists */ { int temp = v->u.l.f; v->u.l.f = v->u.l.t; v->u.l.t = temp; } } @@ -564,7 +379,7 @@ void luaK_infix (LexState *ls, int op, expdesc *v) { luaK_goiffalse(fs, v, 1); else luaK_tostack(ls, v, 1); /* all other binary operators need a value */ -} +} void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) { @@ -584,19 +399,210 @@ void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) { else { luaK_tostack(ls, v2, 1); /* `v2' must be a value */ switch (op) { - case '+': luaK_add(fs); break; - case '-': luaK_sub(fs); break; - case '*': luaK_0(fs, OP_MULT, -1); break; - case '/': luaK_0(fs, OP_DIV, -1); break; - case '^': luaK_0(fs, OP_POW, -1); break; - case TK_CONCAT: luaK_conc(fs); break; - case TK_EQ: luaK_eq(fs); break; - case TK_NE: luaK_neq(fs); break; - case '>': luaK_S(fs, OP_JMPGT, NO_JUMP, -2); break; - case '<': luaK_S(fs, OP_JMPLT, NO_JUMP, -2); break; - case TK_GE: luaK_S(fs, OP_JMPGE, NO_JUMP, -2); break; - case TK_LE: luaK_S(fs, OP_JMPLE, NO_JUMP, -2); break; + case '+': luaK_code0(fs, OP_ADD); break; + case '-': luaK_code0(fs, OP_SUB); break; + case '*': luaK_code0(fs, OP_MULT); break; + case '/': luaK_code0(fs, OP_DIV); break; + case '^': luaK_code0(fs, OP_POW); break; + case TK_CONCAT: luaK_code1(fs, OP_CONCAT, 2); break; + case TK_EQ: luaK_code0(fs, OP_JMPEQ); break; + case TK_NE: luaK_code0(fs, OP_JMPNE); break; + case '>': luaK_code0(fs, OP_JMPGT); break; + case '<': luaK_code0(fs, OP_JMPLT); break; + case TK_GE: luaK_code0(fs, OP_JMPGE); break; + case TK_LE: luaK_code0(fs, OP_JMPLE); break; } } } + +int luaK_code0 (FuncState *fs, OpCode o) { + return luaK_code2(fs, o, 0, 0); +} + + +int luaK_code1 (FuncState *fs, OpCode o, int arg1) { + return luaK_code2(fs, o, arg1, 0); +} + + + +int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) { + Instruction i = previous_instruction(fs); + int delta = 0; + enum {iO, iU, iS, iAB, iP} mode; /* instruction format (or iP to optimize) */ + mode = iP; + switch (o) { + + case OP_JMP: delta = 0; mode = iS; break; + case OP_CLOSURE: delta = -arg2+1; mode = iAB; break; + case OP_SETLINE: mode = iU; break; + case OP_CALL: mode = iAB; break; + case OP_PUSHINT: delta = 1; mode = iS; break; + case OP_SETGLOBAL: delta = -1; mode = iU; break; + case OP_SETTABLE: delta = -arg2; mode = iAB; break; + case OP_SETLIST: delta = -(arg2+1); mode = iAB; break; + case OP_SETMAP: delta = -2*(arg1+1); mode = iU; break; + + case OP_END: case OP_PUSHNILJMP: case OP_NOT: + mode = iO; break; + + case OP_PUSHSTRING: case OP_PUSHNUM: + case OP_PUSHNEGNUM: case OP_PUSHUPVALUE: + case OP_GETGLOBAL: case OP_PUSHSELF: case OP_CREATETABLE: + delta = 1; mode = iU; break; + + case OP_JMPLT: case OP_JMPLE: case OP_JMPGT: case OP_JMPGE: + delta = -2; arg1 = NO_JUMP; mode = iS; break; + + case OP_MULT: case OP_DIV: case OP_POW: + delta = -1; mode = iO; break; + + case OP_RETURN: + if (GET_OPCODE(i) == OP_CALL && GETARG_B(i) == MULT_RET) { + SET_OPCODE(i, OP_TAILCALL); + SETARG_B(i, arg1); + } + else mode = iU; + break; + + case OP_PUSHNIL: + delta = arg1; + switch(GET_OPCODE(i)) { + case OP_PUSHNIL: SETARG_U(i, GETARG_U(i)+arg1); break; + default: mode = iU; break; + } + break; + + case OP_POP: + delta = -arg1; + switch(GET_OPCODE(i)) { + case OP_SETTABLE: SETARG_B(i, GETARG_B(i)+arg1); break; + case OP_SETLOCAL: SETARG_B(i, GETARG_B(i)+arg1); break; + default: mode = iU; break; + } + break; + + case OP_GETLOCAL: + delta = 1; + if (i == CREATE_AB(OP_SETLOCAL, arg1, 1)) + SETARG_B(i, 0); + else mode = iU; + break; + + case OP_GETTABLE: + delta = -1; + switch(GET_OPCODE(i)) { + case OP_PUSHSTRING: SET_OPCODE(i, OP_GETDOTTED); break; /* `t.x' */ + case OP_GETLOCAL: SET_OPCODE(i, OP_GETINDEXED); break; /* `t[i]' */ + default: mode = iO; break; + } + break; + + case OP_SETLOCAL: { + int pc = fs->pc; + Instruction *code = fs->f->code; + delta = -1; + if (pc-1 > fs->lasttarget && /* no jumps in-between instructions? */ + code[pc-2] == CREATE_U(OP_GETLOCAL, arg1) && + GET_OPCODE(i) == OP_ADDI && abs(GETARG_S(i)) <= MAXARG_sA) { + /* `local=local+k' */ + fs->pc = pc-1; + code[pc-2] = CREATE_sAB(OP_INCLOCAL, GETARG_S(i), arg1); + luaK_deltastack(fs, delta); + return pc-1; + } + else { + arg2 = 1; /* `setlocal' default pops one value */ + mode = iAB; + } + break; + } + + case OP_ADD: + delta = -1; + switch(GET_OPCODE(i)) { + case OP_PUSHINT: SET_OPCODE(i, OP_ADDI); break; /* `a+k' */ + default: mode = iO; break; + } + break; + + case OP_SUB: + delta = -1; + switch(GET_OPCODE(i)) { + case OP_PUSHINT: i = CREATE_S(OP_ADDI, -GETARG_S(i)); break; /* `a-k' */ + default: mode = iO; break; + } + break; + + case OP_CONCAT: + delta = -arg1+1; + switch(GET_OPCODE(i)) { + case OP_CONCAT: SETARG_U(i, GETARG_U(i)+1); break; /* `a..b..c' */ + default: mode = iU; break; + } + break; + + case OP_MINUS: + switch(GET_OPCODE(i)) { + case OP_PUSHINT: SETARG_S(i, -GETARG_S(i)); break; /* `-k' */ + case OP_PUSHNUM: SET_OPCODE(i, OP_PUSHNEGNUM); break; /* `-k' */ + default: mode = iO; break; + } + break; + + case OP_JMPNE: + delta = -2; + if (i == CREATE_U(OP_PUSHNIL, 1)) /* `a~=nil' */ + i = CREATE_S(OP_JMPT, NO_JUMP); + else { + arg1 = NO_JUMP; + mode = iS; + } + break; + + case OP_JMPEQ: + delta = -2; + if (i == CREATE_U(OP_PUSHNIL, 1)) { /* `a==nil' */ + i = CREATE_0(OP_NOT); + delta = -1; /* just undo effect of previous PUSHNIL */ + } + else { + arg1 = NO_JUMP; + mode = iS; + } + break; + + case OP_JMPT: case OP_JMPF: case OP_JMPONT: case OP_JMPONF: + delta = -1; + arg1 = NO_JUMP; + switch (GET_OPCODE(i)) { + case OP_NOT: i = CREATE_S(invertjump(o), NO_JUMP); break; + default: mode = iS; break; + } + break; + + case OP_GETDOTTED: case OP_GETINDEXED: + case OP_TAILCALL: case OP_INCLOCAL: + case OP_ADDI: + LUA_INTERNALERROR(L, "instruction used only for optimizations"); + return 0; /* to avoid warnings */ + + } + luaK_deltastack(fs, delta); + switch (mode) { /* handle instruction formats */ + case iO: i = CREATE_0(o); break; + case iU: i = CREATE_U(o, arg1); break; + case iS: i = CREATE_S(o, arg1); break; + case iAB: i = CREATE_AB(o, arg1, arg2); break; + case iP: { /* optimize: put instruction in place of last one */ + fs->f->code[fs->pc-1] = i; /* change previous instruction */ + return fs->pc-1; + } + } + /* actually create the new instruction */ + luaM_growvector(fs->L, fs->f->code, fs->pc, 1, Instruction, codeEM, MAX_INT); + fs->f->code[fs->pc] = i; + return fs->pc++; +} + diff --git a/lcode.h b/lcode.h index 287977d2..60955615 100644 --- a/lcode.h +++ b/lcode.h @@ -1,5 +1,5 @@ /* -** $Id: lcode.h,v 1.9 2000/03/17 13:09:46 roberto Exp roberto $ +** $Id: lcode.h,v 1.10 2000/04/05 17:51:58 roberto Exp roberto $ ** Code generator for Lua ** See Copyright Notice in lua.h */ @@ -17,12 +17,9 @@ void luaK_error (LexState *ls, const char *msg); -int luaK_0(FuncState *fs, OpCode o, int d); -int luaK_U(FuncState *fs, OpCode o, int u, int d); -int luaK_S(FuncState *fs, OpCode o, int s, int d); -int luaK_AB(FuncState *fs, OpCode o, int a, int b, int d); -int luaK_code (FuncState *fs, Instruction i, int delta); -void luaK_retcode (FuncState *fs, int nlocals, int nexps); +int luaK_code0 (FuncState *fs, OpCode o); +int luaK_code1 (FuncState *fs, OpCode o, int arg1); +int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2); int luaK_jump (FuncState *fs); void luaK_patchlist (FuncState *fs, int list, int target); void luaK_concat (FuncState *fs, int *l1, int l2); diff --git a/lparser.c b/lparser.c index 85799240..f49d6135 100644 --- a/lparser.c +++ b/lparser.c @@ -1,5 +1,5 @@ /* -** $Id: lparser.c,v 1.77 2000/04/06 17:36:52 roberto Exp roberto $ +** $Id: lparser.c,v 1.78 2000/04/07 13:13:11 roberto Exp roberto $ ** LL(1) Parser and code generator for Lua ** See Copyright Notice in lua.h */ @@ -91,7 +91,7 @@ static void setline (LexState *ls) { FuncState *fs = ls->fs; if (ls->L->debug && ls->linenumber != fs->lastsetline) { checklimit(ls, ls->linenumber, MAXARG_U, "lines in a chunk"); - luaK_U(fs, OP_SETLINE, ls->linenumber, 0); + luaK_code1(fs, OP_SETLINE, ls->linenumber); fs->lastsetline = ls->linenumber; } } @@ -260,7 +260,7 @@ static void pushupvalue (LexState *ls, TString *n) { luaX_syntaxerror(ls, "cannot access upvalue in main", n->str); if (aux_localname(ls->fs, n) >= 0) luaX_syntaxerror(ls, "cannot access an upvalue in current scope", n->str); - luaK_U(fs, OP_PUSHUPVALUE, indexupvalue(ls, n), 1); + luaK_code1(fs, OP_PUSHUPVALUE, indexupvalue(ls, n)); } @@ -339,8 +339,7 @@ static void func_onstack (LexState *ls, FuncState *func) { luaM_growvector(ls->L, f->kproto, f->nkproto, 1, Proto *, constantEM, MAXARG_A); f->kproto[f->nkproto++] = func->f; - luaK_deltastack(fs, 1); /* CLOSURE puts one extra element before popping */ - luaK_AB(fs, OP_CLOSURE, f->nkproto-1, func->nupvalues, -func->nupvalues); + luaK_code2(fs, OP_CLOSURE, f->nkproto-1, func->nupvalues); } @@ -373,7 +372,7 @@ static void close_func (LexState *ls) { lua_State *L = ls->L; FuncState *fs = ls->fs; Proto *f = fs->f; - luaK_0(fs, OP_END, 0); + luaK_code0(fs, OP_END); luaK_getlabel(fs); /* close eventual list of pending jumps */ luaM_reallocvector(L, f->code, fs->pc, Instruction); luaM_reallocvector(L, f->kstr, f->nkstr, TString *); @@ -469,7 +468,7 @@ static void funcargs (LexState *ls, int slf) { break; } fs->stacklevel = slevel; /* call will remove function and arguments */ - luaK_AB(fs, OP_CALL, slevel, MULT_RET, 0); + luaK_code2(fs, OP_CALL, slevel, MULT_RET); } @@ -496,7 +495,7 @@ static void var_or_func_tail (LexState *ls, expdesc *v) { next(ls); name = checkname(ls); luaK_tostack(ls, v, 1); /* `v' must be on stack */ - luaK_U(ls->fs, OP_PUSHSELF, name, 1); + luaK_code1(ls->fs, OP_PUSHSELF, name); funcargs(ls, 1); v->k = VEXP; v->u.l.t = v->u.l.f = NO_JUMP; @@ -569,12 +568,12 @@ static int recfields (LexState *ls) { recfield(ls); n++; if (++mod_n == RFIELDS_PER_FLUSH) { - luaK_U(fs, OP_SETMAP, RFIELDS_PER_FLUSH-1, -2*RFIELDS_PER_FLUSH); + luaK_code1(fs, OP_SETMAP, RFIELDS_PER_FLUSH-1); mod_n = 0; } } if (mod_n) - luaK_U(fs, OP_SETMAP, mod_n-1, -2*mod_n); + luaK_code1(fs, OP_SETMAP, mod_n-1); return n; } @@ -593,13 +592,12 @@ static int listfields (LexState *ls) { checklimit(ls, n, MAXARG_A*LFIELDS_PER_FLUSH, "items in a list initializer"); if (++mod_n == LFIELDS_PER_FLUSH) { - luaK_AB(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH-1, - -LFIELDS_PER_FLUSH); + luaK_code2(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH-1); mod_n = 0; } } if (mod_n > 0) - luaK_AB(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH, mod_n-1, -mod_n); + luaK_code2(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH, mod_n-1); return n; } @@ -649,7 +647,7 @@ static void constructor (LexState *ls) { /* constructor -> '{' constructor_part [';' constructor_part] '}' */ FuncState *fs = ls->fs; int line = ls->linenumber; - int pc = luaK_U(fs, OP_CREATETABLE, 0, 1); + int pc = luaK_code1(fs, OP_CREATETABLE, 0); int nelems; Constdesc cd; check(ls, '{'); @@ -835,7 +833,7 @@ static int assignment (LexState *ls, expdesc *v, int nvars) { if (v->k != VINDEXED) luaK_storevar(ls, v); else { /* there may be garbage between table-index and value */ - luaK_AB(ls->fs, OP_SETTABLE, left+nvars+2, 1, -1); + luaK_code2(ls->fs, OP_SETTABLE, left+nvars+2, 1); left += 2; } return left; @@ -1099,10 +1097,9 @@ static void ret (LexState *ls) { FuncState *fs = ls->fs; switch (ls->token) { case TK_RETURN: { - int nexps; /* number of expressions returned */ setline_and_next(ls); /* skip RETURN */ - nexps = explist(ls); - luaK_retcode(fs, ls->fs->nlocalvar, nexps); + explist(ls); + luaK_code1(fs, OP_RETURN, ls->fs->nlocalvar); fs->stacklevel = fs->nlocalvar; /* removes all temp values */ optional(ls, ';'); break; -- cgit v1.2.3-55-g6feb