From 73aa465a8ed8dee6c6a27a6f8b2f51227b70789d Mon Sep 17 00:00:00 2001 From: Roberto Ierusalimschy Date: Fri, 10 Mar 2000 15:37:44 -0300 Subject: some name changes --- lcode.c | 172 ++++++++++++++++++++++++++++++++-------------------------------- 1 file changed, 86 insertions(+), 86 deletions(-) (limited to 'lcode.c') diff --git a/lcode.c b/lcode.c index 1a5c23f7..de78c52f 100644 --- a/lcode.c +++ b/lcode.c @@ -1,5 +1,5 @@ /* -** $Id: lcode.c,v 1.8 2000/03/09 13:57:37 roberto Exp roberto $ +** $Id: lcode.c,v 1.9 2000/03/10 14:38:10 roberto Exp roberto $ ** Code generator for Lua ** See Copyright Notice in lua.h */ @@ -32,8 +32,8 @@ static Instruction *previous_instruction (LexState *ls) { if (fs->pc > fs->lasttarget) /* no jumps to current position? */ return &fs->f->code[fs->pc-1]; /* returns previous instruction */ else { - static Instruction dummy = CREATE_0(ENDCODE); - return &dummy; /* no optimizations after an `ENDCODE' */ + static Instruction dummy = CREATE_0(OP_END); + return &dummy; /* no optimizations after an `END' */ } } @@ -49,10 +49,10 @@ int luaK_primitivecode (LexState *ls, Instruction i) { static void luaK_minus (LexState *ls) { Instruction *previous = previous_instruction(ls); switch(GET_OPCODE(*previous)) { - case PUSHINT: SETARG_S(*previous, -GETARG_S(*previous)); return; - case PUSHNUM: SET_OPCODE(*previous, PUSHNEGNUM); return; - case PUSHNEGNUM: SET_OPCODE(*previous, PUSHNUM); return; - default: luaK_primitivecode(ls, CREATE_0(MINUSOP)); + case OP_PUSHINT: SETARG_S(*previous, -GETARG_S(*previous)); return; + case OP_PUSHNUM: SET_OPCODE(*previous, OP_PUSHNEGNUM); return; + case OP_PUSHNEGNUM: SET_OPCODE(*previous, OP_PUSHNUM); return; + default: luaK_primitivecode(ls, CREATE_0(OP_MINUS)); } } @@ -61,8 +61,8 @@ static void luaK_gettable (LexState *ls) { Instruction *previous = previous_instruction(ls); luaK_deltastack(ls, -1); switch(GET_OPCODE(*previous)) { - case PUSHSTRING: SET_OPCODE(*previous, GETDOTTED); break; - default: luaK_primitivecode(ls, CREATE_0(GETTABLE)); + case OP_PUSHSTRING: SET_OPCODE(*previous, OP_GETDOTTED); break; + default: luaK_primitivecode(ls, CREATE_0(OP_GETTABLE)); } } @@ -71,8 +71,8 @@ static void luaK_add (LexState *ls) { Instruction *previous = previous_instruction(ls); luaK_deltastack(ls, -1); switch(GET_OPCODE(*previous)) { - case PUSHINT: SET_OPCODE(*previous, ADDI); break; - default: luaK_primitivecode(ls, CREATE_0(ADDOP)); + case OP_PUSHINT: SET_OPCODE(*previous, OP_ADDI); break; + default: luaK_primitivecode(ls, CREATE_0(OP_ADD)); } } @@ -81,11 +81,11 @@ static void luaK_sub (LexState *ls) { Instruction *previous = previous_instruction(ls); luaK_deltastack(ls, -1); switch(GET_OPCODE(*previous)) { - case PUSHINT: - SET_OPCODE(*previous, ADDI); + case OP_PUSHINT: + SET_OPCODE(*previous, OP_ADDI); SETARG_S(*previous, -GETARG_S(*previous)); break; - default: luaK_primitivecode(ls, CREATE_0(SUBOP)); + default: luaK_primitivecode(ls, CREATE_0(OP_SUB)); } } @@ -94,43 +94,43 @@ static void luaK_conc (LexState *ls) { Instruction *previous = previous_instruction(ls); luaK_deltastack(ls, -1); switch(GET_OPCODE(*previous)) { - case CONCOP: SETARG_U(*previous, GETARG_U(*previous)+1); break; - default: luaK_primitivecode(ls, CREATE_U(CONCOP, 2)); + case OP_CONC: SETARG_U(*previous, GETARG_U(*previous)+1); break; + default: luaK_primitivecode(ls, CREATE_U(OP_CONC, 2)); } } static void luaK_eq (LexState *ls) { Instruction *previous = previous_instruction(ls); - if (*previous == CREATE_U(PUSHNIL, 1)) { - *previous = CREATE_0(NOTOP); + if (*previous == CREATE_U(OP_PUSHNIL, 1)) { + *previous = CREATE_0(OP_NOT); luaK_deltastack(ls, -1); /* undo effect of PUSHNIL */ } else - luaK_S(ls, IFEQJMP, 0, -2); + luaK_S(ls, OP_IFEQJMP, 0, -2); } static void luaK_neq (LexState *ls) { Instruction *previous = previous_instruction(ls); - if (*previous == CREATE_U(PUSHNIL, 1)) { + if (*previous == CREATE_U(OP_PUSHNIL, 1)) { ls->fs->pc--; /* remove PUSHNIL */ luaK_deltastack(ls, -1); /* undo effect of PUSHNIL */ } else - luaK_S(ls, IFNEQJMP, 0, -2); + luaK_S(ls, OP_IFNEQJMP, 0, -2); } void luaK_retcode (LexState *ls, int nlocals, int nexps) { Instruction *previous = previous_instruction(ls); - if (nexps > 0 && GET_OPCODE(*previous) == CALL) { + if (nexps > 0 && GET_OPCODE(*previous) == OP_CALL) { LUA_ASSERT(ls->L, GETARG_B(*previous) == MULT_RET, "call should be open"); - SET_OPCODE(*previous, TAILCALL); + SET_OPCODE(*previous, OP_TAILCALL); SETARG_B(*previous, nlocals); } else - luaK_primitivecode(ls, CREATE_U(RETCODE, nlocals)); + luaK_primitivecode(ls, CREATE_U(OP_RETURN, nlocals)); } @@ -138,8 +138,8 @@ static void luaK_pushnil (LexState *ls, int n) { Instruction *previous = previous_instruction(ls); luaK_deltastack(ls, n); switch(GET_OPCODE(*previous)) { - case PUSHNIL: SETARG_U(*previous, GETARG_U(*previous)+n); break; - default: luaK_primitivecode(ls, CREATE_U(PUSHNIL, n)); + case OP_PUSHNIL: SETARG_U(*previous, GETARG_U(*previous)+n); break; + default: luaK_primitivecode(ls, CREATE_U(OP_PUSHNIL, n)); } } @@ -181,7 +181,7 @@ void luaK_deltastack (LexState *ls, int delta) { void luaK_kstr (LexState *ls, int c) { - luaK_U(ls, PUSHSTRING, c, 1); + luaK_U(ls, OP_PUSHSTRING, c, 1); } @@ -189,32 +189,32 @@ void luaK_kstr (LexState *ls, int c) { #define LOOKBACKNUMS 20 /* arbitrary limit */ #endif -static int real_constant (LexState *ls, real r) { +static int real_constant (LexState *ls, Number r) { /* check whether `r' has appeared within the last LOOKBACKNUMS entries */ - TProtoFunc *f = ls->fs->f; + Proto *f = ls->fs->f; int c = f->nknum; int lim = c < LOOKBACKNUMS ? 0 : c-LOOKBACKNUMS; while (--c >= lim) if (f->knum[c] == r) return c; /* not found; create a new entry */ - luaM_growvector(ls->L, f->knum, f->nknum, 1, real, constantEM, MAXARG_U); + luaM_growvector(ls->L, f->knum, f->nknum, 1, Number, constantEM, MAXARG_U); c = f->nknum++; f->knum[c] = r; return c; } -void luaK_number (LexState *ls, real f) { - if (f <= (real)MAXARG_S && (int)f == f) - luaK_S(ls, PUSHINT, (int)f, 1); /* f has a short integer value */ +void luaK_number (LexState *ls, Number f) { + if (f <= (Number)MAXARG_S && (int)f == f) + luaK_S(ls, OP_PUSHINT, (int)f, 1); /* f has a short integer value */ else - luaK_U(ls, PUSHNUM, real_constant(ls, f), 1); + luaK_U(ls, OP_PUSHNUM, real_constant(ls, f), 1); } void luaK_adjuststack (LexState *ls, int n) { if (n > 0) - luaK_U(ls, POP, n, -n); + luaK_U(ls, OP_POP, n, -n); else if (n < 0) luaK_pushnil(ls, -n); } @@ -223,7 +223,7 @@ void luaK_adjuststack (LexState *ls, int n) { int luaK_lastisopen (LexState *ls) { /* check whether last instruction is an (open) function call */ Instruction *i = previous_instruction(ls); - if (GET_OPCODE(*i) == CALL) { + if (GET_OPCODE(*i) == OP_CALL) { LUA_ASSERT(ls->L, GETARG_B(*i) == MULT_RET, "call should be open"); return 1; } @@ -233,7 +233,7 @@ int luaK_lastisopen (LexState *ls) { void luaK_setcallreturns (LexState *ls, int nresults) { Instruction *i = previous_instruction(ls); - if (GET_OPCODE(*i) == CALL) { /* expression is a function call? */ + if (GET_OPCODE(*i) == OP_CALL) { /* expression is a function call? */ LUA_ASSERT(ls->L, GETARG_B(*i) == MULT_RET, "call should be open"); SETARG_B(*i, nresults); /* set nresults */ luaK_deltastack(ls, nresults); /* push results */ @@ -249,10 +249,10 @@ static void assertglobal (LexState *ls, int index) { static int discharge (LexState *ls, expdesc *var) { switch (var->k) { case VLOCAL: - luaK_U(ls, PUSHLOCAL, var->u.index, 1); + luaK_U(ls, OP_PUSHLOCAL, var->u.index, 1); break; case VGLOBAL: - luaK_U(ls, GETGLOBAL, var->u.index, 1); + luaK_U(ls, OP_GETGLOBAL, var->u.index, 1); assertglobal(ls, var->u.index); /* make sure that there is a global */ break; case VINDEXED: @@ -278,14 +278,14 @@ static void discharge1 (LexState *ls, expdesc *var) { void luaK_storevar (LexState *ls, const expdesc *var) { switch (var->k) { case VLOCAL: - luaK_U(ls, SETLOCAL, var->u.index, -1); + luaK_U(ls, OP_SETLOCAL, var->u.index, -1); break; case VGLOBAL: - luaK_U(ls, SETGLOBAL, var->u.index, -1); + luaK_U(ls, OP_SETGLOBAL, var->u.index, -1); assertglobal(ls, var->u.index); /* make sure that there is a global */ break; case VINDEXED: - luaK_0(ls, SETTABLEPOP, -3); + luaK_0(ls, OP_SETTABLEPOP, -3); break; default: LUA_INTERNALERROR(ls->L, "invalid var kind to store"); @@ -295,17 +295,17 @@ void luaK_storevar (LexState *ls, const expdesc *var) { static OpCode invertjump (OpCode op) { switch (op) { - case IFNEQJMP: return IFEQJMP; - case IFEQJMP: return IFNEQJMP; - case IFLTJMP: return IFGEJMP; - case IFLEJMP: return IFGTJMP; - case IFGTJMP: return IFLEJMP; - case IFGEJMP: return IFLTJMP; - case IFTJMP: case ONTJMP: return IFFJMP; - case IFFJMP: case ONFJMP: return IFTJMP; + case OP_IFNEQJMP: return OP_IFEQJMP; + case OP_IFEQJMP: return OP_IFNEQJMP; + case OP_IFLTJMP: return OP_IFGEJMP; + case OP_IFLEJMP: return OP_IFGTJMP; + case OP_IFGTJMP: return OP_IFLEJMP; + case OP_IFGEJMP: return OP_IFLTJMP; + case OP_IFTJMP: case OP_ONTJMP: return OP_IFFJMP; + case OP_IFFJMP: case OP_ONFJMP: return OP_IFTJMP; default: LUA_INTERNALERROR(NULL, "invalid jump instruction"); - return ENDCODE; /* to avoid warnings */ + return OP_END; /* to avoid warnings */ } } @@ -313,7 +313,7 @@ static OpCode invertjump (OpCode op) { static void luaK_jump (LexState *ls, OpCode jump) { Instruction *previous = previous_instruction(ls); luaK_deltastack(ls, -1); - if (*previous == CREATE_0(NOTOP)) + if (*previous == CREATE_0(OP_NOT)) *previous = CREATE_S(invertjump(jump), 0); else luaK_primitivecode(ls, CREATE_S(jump, 0)); @@ -342,10 +342,10 @@ static void luaK_patchlistaux (LexState *ls, int list, int target, SETARG_S(*i, special_target-(list+1)); else { SETARG_S(*i, target-(list+1)); /* do the patch */ - if (op == ONTJMP) /* remove eventual values */ - SET_OPCODE(*i, IFTJMP); - else if (op == ONFJMP) - SET_OPCODE(*i, IFFJMP); + if (op == OP_ONTJMP) /* remove eventual values */ + SET_OPCODE(*i, OP_IFTJMP); + else if (op == OP_ONFJMP) + SET_OPCODE(*i, OP_IFFJMP); } if (next == 0) return; list += next+1; @@ -355,7 +355,7 @@ static void luaK_patchlistaux (LexState *ls, int list, int target, void luaK_patchlist (LexState *ls, int list, int target) { - luaK_patchlistaux(ls, list, target, ENDCODE, 0); + luaK_patchlistaux(ls, list, target, OP_END, 0); } @@ -399,7 +399,7 @@ void luaK_goiftrue (LexState *ls, expdesc *v, int keepvalue) { if (ISJUMP(GET_OPCODE(*previous))) SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous))); else { - OpCode jump = keepvalue ? ONFJMP : IFFJMP; + OpCode jump = keepvalue ? OP_ONFJMP : OP_IFFJMP; luaK_jump(ls, jump); } insert_last(fs, &v->u.l.f); @@ -414,7 +414,7 @@ void luaK_goiffalse (LexState *ls, expdesc *v, int keepvalue) { discharge1(ls, v); previous = fs->f->code[fs->pc-1]; if (!ISJUMP(GET_OPCODE(previous))) { - OpCode jump = keepvalue ? ONTJMP : IFTJMP; + OpCode jump = keepvalue ? OP_ONTJMP : OP_IFTJMP; luaK_jump(ls, jump); } insert_last(fs, &v->u.l.t); @@ -440,28 +440,28 @@ void luaK_tostack (LexState *ls, expdesc *v, int onlyone) { int final; /* position after whole expression */ if (ISJUMP(previous)) { insert_last(fs, &v->u.l.t); /* put `previous' in true list */ - p_nil = luaK_0(ls, PUSHNILJMP, 0); - p_1 = luaK_S(ls, PUSHINT, 1, 1); + p_nil = luaK_0(ls, OP_PUSHNILJMP, 0); + p_1 = luaK_S(ls, OP_PUSHINT, 1, 1); } else { /* still may need a PUSHNIL or a PUSHINT */ - int need_nil = need_value(fs, v->u.l.f, ONFJMP); - int need_1 = need_value(fs, v->u.l.t, ONTJMP); + int need_nil = need_value(fs, v->u.l.f, OP_ONFJMP); + int need_1 = need_value(fs, v->u.l.t, OP_ONTJMP); if (need_nil && need_1) { - luaK_S(ls, JMP, 2, 0); /* skip both pushes */ - p_nil = luaK_0(ls, PUSHNILJMP, 0); - p_1 = luaK_S(ls, PUSHINT, 1, 0); + luaK_S(ls, OP_JMP, 2, 0); /* skip both pushes */ + p_nil = luaK_0(ls, OP_PUSHNILJMP, 0); + p_1 = luaK_S(ls, OP_PUSHINT, 1, 0); } else if (need_nil || need_1) { - luaK_S(ls, JMP, 1, 0); /* skip one push */ + luaK_S(ls, OP_JMP, 1, 0); /* skip one push */ if (need_nil) - p_nil = luaK_U(ls, PUSHNIL, 1, 0); + p_nil = luaK_U(ls, OP_PUSHNIL, 1, 0); else /* need_1 */ - p_1 = luaK_S(ls, PUSHINT, 1, 0); + p_1 = luaK_S(ls, OP_PUSHINT, 1, 0); } } final = luaK_getlabel(ls); - luaK_patchlistaux(ls, v->u.l.f, p_nil, ONFJMP, final); - luaK_patchlistaux(ls, v->u.l.t, p_1, ONTJMP, final); + luaK_patchlistaux(ls, v->u.l.f, p_nil, OP_ONFJMP, final); + luaK_patchlistaux(ls, v->u.l.t, p_1, OP_ONTJMP, final); v->u.l.f = v->u.l.t = 0; } } @@ -481,7 +481,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(ls, NOTOP, 0); + luaK_0(ls, OP_NOT, 0); /* interchange true and false lists */ { int temp = v->u.l.f; v->u.l.f = v->u.l.t; v->u.l.t = temp; } } @@ -489,9 +489,9 @@ void luaK_prefix (LexState *ls, int op, expdesc *v) { void luaK_infix (LexState *ls, int op, expdesc *v) { - if (op == AND) + if (op == TK_AND) luaK_goiftrue(ls, v, 1); - else if (op == OR) + else if (op == TK_OR) luaK_goiffalse(ls, v, 1); else luaK_tostack(ls, v, 1); /* all other binary operators need a value */ @@ -499,13 +499,13 @@ void luaK_infix (LexState *ls, int op, expdesc *v) { void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) { - if (op == AND) { + if (op == TK_AND) { LUA_ASSERT(ls->L, v1->u.l.t == 0, "list must be closed"); discharge1(ls, v2); v1->u.l.t = v2->u.l.t; concatlists(ls, &v1->u.l.f, v2->u.l.f); } - else if (op == OR) { + else if (op == TK_OR) { LUA_ASSERT(ls->L, v1->u.l.f == 0, "list must be closed"); discharge1(ls, v2); v1->u.l.f = v2->u.l.f; @@ -516,16 +516,16 @@ void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) { switch (op) { case '+': luaK_add(ls); break; case '-': luaK_sub(ls); break; - case '*': luaK_0(ls, MULTOP, -1); break; - case '/': luaK_0(ls, DIVOP, -1); break; - case '^': luaK_0(ls, POWOP, -1); break; - case CONC: luaK_conc(ls); break; - case EQ: luaK_eq(ls); break; - case NE: luaK_neq(ls); break; - case '>': luaK_S(ls, IFGTJMP, 0, -2); break; - case '<': luaK_S(ls, IFLTJMP, 0, -2); break; - case GE: luaK_S(ls, IFGEJMP, 0, -2); break; - case LE: luaK_S(ls, IFLEJMP, 0, -2); break; + case '*': luaK_0(ls, OP_MULT, -1); break; + case '/': luaK_0(ls, OP_DIV, -1); break; + case '^': luaK_0(ls, OP_POW, -1); break; + case TK_CONC: luaK_conc(ls); break; + case TK_EQ: luaK_eq(ls); break; + case TK_NE: luaK_neq(ls); break; + case '>': luaK_S(ls, OP_IFGTJMP, 0, -2); break; + case '<': luaK_S(ls, OP_IFLTJMP, 0, -2); break; + case TK_GE: luaK_S(ls, OP_IFGEJMP, 0, -2); break; + case TK_LE: luaK_S(ls, OP_IFLEJMP, 0, -2); break; } } } -- cgit v1.2.3-55-g6feb