mirror of
https://github.com/lua/lua
synced 2024-11-26 22:59:35 +03:00
940 lines
22 KiB
Plaintext
940 lines
22 KiB
Plaintext
%{
|
|
/*
|
|
** $Id: lua.stx,v 1.32 1998/01/12 13:00:51 roberto Exp roberto $
|
|
** Syntax analizer and code generator
|
|
** See Copyright Notice in lua.h
|
|
*/
|
|
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "lauxlib.h"
|
|
#include "ldo.h"
|
|
#include "lfunc.h"
|
|
#include "llex.h"
|
|
#include "lmem.h"
|
|
#include "lopcodes.h"
|
|
#include "lparser.h"
|
|
#include "lstate.h"
|
|
#include "lstring.h"
|
|
#include "lua.h"
|
|
#include "luadebug.h"
|
|
#include "lzio.h"
|
|
|
|
|
|
int luaY_parse (void);
|
|
|
|
|
|
#define MES_LIM(x) "(limit=" x ")"
|
|
|
|
|
|
/* size of a "normal" jump instruction: OpCode + 1 byte */
|
|
#define JMPSIZE 2
|
|
|
|
/* maximum number of local variables */
|
|
#define MAXLOCALS 32
|
|
#define SMAXLOCALS "32"
|
|
|
|
#define MINGLOBAL (MAXLOCALS+1)
|
|
|
|
/* maximum number of variables in a multiple assignment */
|
|
#define MAXVAR 32
|
|
#define SMAXVAR "32"
|
|
|
|
/* maximum number of nested functions */
|
|
#define MAXSTATES 6
|
|
#define SMAXSTATES "6"
|
|
|
|
/* maximum number of upvalues */
|
|
#define MAXUPVALUES 16
|
|
#define SMAXUPVALUES "16"
|
|
|
|
|
|
|
|
/*
|
|
** Variable descriptor:
|
|
** if 0<n<MINGLOBAL, represents local variable indexed by (n-1);
|
|
** if MINGLOBAL<=n, represents global variable at position (n-MINGLOBAL);
|
|
** if n<0, indexed variable with index (-n)-1 (table on top of stack);
|
|
** if n==0, an indexed variable (table and index on top of stack)
|
|
** Must be long to store negative Word values.
|
|
*/
|
|
typedef long vardesc;
|
|
|
|
#define isglobal(v) (MINGLOBAL<=(v))
|
|
#define globalindex(v) ((v)-MINGLOBAL)
|
|
#define islocal(v) (0<(v) && (v)<MINGLOBAL)
|
|
#define localindex(v) ((v)-1)
|
|
#define isdot(v) (v<0)
|
|
#define dotindex(v) ((-(v))-1)
|
|
|
|
/* state needed to generate code for a given function */
|
|
typedef struct FuncState {
|
|
TProtoFunc *f; /* current function header */
|
|
int pc; /* next position to code */
|
|
TaggedString *localvar[MAXLOCALS]; /* store local variable names */
|
|
int stacksize; /* number of values on activation register */
|
|
int maxstacksize; /* maximum number of values on activation register */
|
|
int nlocalvar; /* number of active local variables */
|
|
int nupvalues; /* number of upvalues */
|
|
int nvars; /* number of entries in f->locvars */
|
|
int maxcode; /* size of f->code */
|
|
int maxvars; /* size of f->locvars (-1 if no debug information) */
|
|
int maxconsts; /* size of f->consts */
|
|
vardesc varbuffer[MAXVAR]; /* variables in an assignment list */
|
|
vardesc upvalues[MAXUPVALUES]; /* upvalues */
|
|
} FuncState;
|
|
|
|
|
|
|
|
#define YYPURE 1
|
|
|
|
|
|
void luaY_syntaxerror (char *s, char *token)
|
|
{
|
|
if (token[0] == 0)
|
|
token = "<eof>";
|
|
luaL_verror("%.100s;\n last token read: \"%.50s\" at line %d in file %.50s",
|
|
s, token, L->lexstate->linenumber, L->mainState->f->fileName->str);
|
|
}
|
|
|
|
|
|
void luaY_error (char *s)
|
|
{
|
|
luaY_syntaxerror(s, luaX_lasttoken());
|
|
}
|
|
|
|
|
|
static void check_pc (int n)
|
|
{
|
|
FuncState *fs = L->currState;
|
|
if (fs->pc+n > fs->maxcode)
|
|
fs->maxcode = luaM_growvector(&fs->f->code, fs->maxcode,
|
|
Byte, codeEM, MAX_INT);
|
|
}
|
|
|
|
|
|
static void code_byte (Byte c)
|
|
{
|
|
check_pc(1);
|
|
L->currState->f->code[L->currState->pc++] = c;
|
|
}
|
|
|
|
|
|
static void deltastack (int delta)
|
|
{
|
|
FuncState *fs = L->currState;
|
|
fs->stacksize += delta;
|
|
if (fs->stacksize > fs->maxstacksize) {
|
|
if (fs->stacksize > 255)
|
|
luaY_error("function/expression too complex");
|
|
fs->maxstacksize = fs->stacksize;
|
|
}
|
|
}
|
|
|
|
|
|
static int code_oparg_at (int pc, OpCode op, int builtin, int arg, int delta)
|
|
{
|
|
Byte *code = L->currState->f->code;
|
|
deltastack(delta);
|
|
if (arg < builtin) {
|
|
code[pc] = op+1+arg;
|
|
return 1;
|
|
}
|
|
else if (arg <= 255) {
|
|
code[pc] = op;
|
|
code[pc+1] = arg;
|
|
return 2;
|
|
}
|
|
else if (arg <= MAX_WORD) {
|
|
code[pc] = op+1+builtin;
|
|
code[pc+1] = arg&0xFF;
|
|
code[pc+2] = arg>>8;
|
|
return 3;
|
|
}
|
|
else luaY_error("code too long " MES_LIM("64K"));
|
|
return 0; /* to avoid warnings */
|
|
}
|
|
|
|
|
|
static int fix_opcode (int pc, OpCode op, int builtin, int arg)
|
|
{
|
|
FuncState *fs = L->currState;
|
|
if (arg < builtin) { /* close space */
|
|
luaO_memdown(fs->f->code+pc+1, fs->f->code+pc+2, fs->pc-(pc+2));
|
|
fs->pc--;
|
|
}
|
|
else if (arg > 255) { /* open space */
|
|
check_pc(1);
|
|
luaO_memup(fs->f->code+pc+1, fs->f->code+pc, fs->pc-pc);
|
|
fs->pc++;
|
|
}
|
|
return code_oparg_at(pc, op, builtin, arg, 0) - 2;
|
|
}
|
|
|
|
|
|
static void code_oparg (OpCode op, int builtin, int arg, int delta)
|
|
{
|
|
check_pc(3); /* maximum code size */
|
|
L->currState->pc += code_oparg_at(L->currState->pc, op, builtin, arg, delta);
|
|
}
|
|
|
|
|
|
static void code_opcode (OpCode op, int delta)
|
|
{
|
|
deltastack(delta);
|
|
code_byte(op);
|
|
}
|
|
|
|
|
|
static void code_pop (OpCode op)
|
|
{
|
|
code_opcode(op, -1);
|
|
}
|
|
|
|
/* binary operations get 2 arguments and leave one, so they pop one */
|
|
#define code_binop(op) code_pop(op)
|
|
|
|
|
|
static void code_neutralop (OpCode op)
|
|
{
|
|
code_opcode(op, 0);
|
|
}
|
|
|
|
/* unary operations get 1 argument and leave one, so they are neutral */
|
|
#define code_unop(op) code_neutralop(op)
|
|
|
|
|
|
static void code_constant (int c)
|
|
{
|
|
code_oparg(PUSHCONSTANT, 8, c, 1);
|
|
}
|
|
|
|
|
|
static int next_constant (FuncState *cs)
|
|
{
|
|
TProtoFunc *f = cs->f;
|
|
if (f->nconsts >= cs->maxconsts) {
|
|
cs->maxconsts = luaM_growvector(&f->consts, cs->maxconsts, TObject,
|
|
constantEM, MAX_WORD);
|
|
}
|
|
return f->nconsts++;
|
|
}
|
|
|
|
|
|
static int string_constant (TaggedString *s, FuncState *cs)
|
|
{
|
|
TProtoFunc *f = cs->f;
|
|
int c = s->constindex;
|
|
if (!(c < f->nconsts &&
|
|
ttype(&f->consts[c]) == LUA_T_STRING && tsvalue(&f->consts[c]) == s)) {
|
|
c = next_constant(cs);
|
|
ttype(&f->consts[c]) = LUA_T_STRING;
|
|
tsvalue(&f->consts[c]) = s;
|
|
s->constindex = c; /* hint for next time */
|
|
}
|
|
return c;
|
|
}
|
|
|
|
|
|
static void code_string (TaggedString *s)
|
|
{
|
|
code_constant(string_constant(s, L->currState));
|
|
}
|
|
|
|
|
|
#define LIM 20
|
|
static int real_constant (real r)
|
|
{
|
|
/* check whether 'r' has appeared within the last LIM entries */
|
|
TObject *cnt = L->currState->f->consts;
|
|
int c = L->currState->f->nconsts;
|
|
int lim = c < LIM ? 0 : c-LIM;
|
|
while (--c >= lim) {
|
|
if (ttype(&cnt[c]) == LUA_T_NUMBER && nvalue(&cnt[c]) == r)
|
|
return c;
|
|
}
|
|
/* not found; create a luaM_new entry */
|
|
c = next_constant(L->currState);
|
|
cnt = L->currState->f->consts; /* 'next_constant' may reallocate this vector */
|
|
ttype(&cnt[c]) = LUA_T_NUMBER;
|
|
nvalue(&cnt[c]) = r;
|
|
return c;
|
|
}
|
|
|
|
|
|
static void code_number (real f)
|
|
{
|
|
int i;
|
|
if (f >= 0 && f <= (real)MAX_WORD && (real)(i=(int)f) == f)
|
|
code_oparg(PUSHNUMBER, 3, i, 1); /* f has an (short) integer value */
|
|
else
|
|
code_constant(real_constant(f));
|
|
}
|
|
|
|
|
|
static void flush_record (int n)
|
|
{
|
|
if (n > 0)
|
|
code_oparg(SETMAP, 1, n-1, -2*n);
|
|
}
|
|
|
|
static void flush_list (int m, int n)
|
|
{
|
|
if (n == 0) return;
|
|
code_oparg(SETLIST, 1, m, -n);
|
|
code_byte(n);
|
|
}
|
|
|
|
|
|
static void luaI_registerlocalvar (TaggedString *varname, int line)
|
|
{
|
|
FuncState *fs = L->currState;
|
|
if (fs->maxvars != -1) { /* debug information? */
|
|
if (fs->nvars >= fs->maxvars)
|
|
fs->maxvars = luaM_growvector(&fs->f->locvars, fs->maxvars,
|
|
LocVar, "", MAX_WORD);
|
|
fs->f->locvars[fs->nvars].varname = varname;
|
|
fs->f->locvars[fs->nvars].line = line;
|
|
fs->nvars++;
|
|
}
|
|
}
|
|
|
|
|
|
static void luaI_unregisterlocalvar (int line)
|
|
{
|
|
luaI_registerlocalvar(NULL, line);
|
|
}
|
|
|
|
|
|
static void store_localvar (TaggedString *name, int n)
|
|
{
|
|
if (L->currState->nlocalvar+n < MAXLOCALS)
|
|
L->currState->localvar[L->currState->nlocalvar+n] = name;
|
|
else
|
|
luaY_error("too many local variables " MES_LIM(SMAXLOCALS));
|
|
luaI_registerlocalvar(name, L->lexstate->linenumber);
|
|
}
|
|
|
|
static void add_localvar (TaggedString *name)
|
|
{
|
|
store_localvar(name, 0);
|
|
L->currState->nlocalvar++;
|
|
}
|
|
|
|
|
|
/*
|
|
** dotted variables <a.x> must be stored like regular indexed vars <a["x"]>
|
|
*/
|
|
static vardesc var2store (vardesc var)
|
|
{
|
|
if (isdot(var)) {
|
|
code_constant(dotindex(var));
|
|
var = 0;
|
|
}
|
|
return var;
|
|
}
|
|
|
|
|
|
static void add_varbuffer (vardesc var, int n)
|
|
{
|
|
if (n >= MAXVAR)
|
|
luaY_error("variable buffer overflow " MES_LIM(SMAXVAR));
|
|
L->currState->varbuffer[n] = var2store(var);
|
|
}
|
|
|
|
|
|
static int aux_localname (TaggedString *n, FuncState *st)
|
|
{
|
|
int i;
|
|
for (i=st->nlocalvar-1; i >= 0; i--)
|
|
if (n == st->localvar[i]) return i; /* local var index */
|
|
return -1; /* not found */
|
|
}
|
|
|
|
|
|
static vardesc singlevar (TaggedString *n, FuncState *st)
|
|
{
|
|
int i = aux_localname(n, st);
|
|
if (i == -1) { /* check shadowing */
|
|
int l;
|
|
for (l=1; l<=(st-L->mainState); l++)
|
|
if (aux_localname(n, st-l) >= 0)
|
|
luaY_syntaxerror("cannot access a variable in outer scope", n->str);
|
|
return string_constant(n, st)+MINGLOBAL; /* global value */
|
|
}
|
|
else return i+1; /* local value */
|
|
}
|
|
|
|
|
|
static int indexupvalue (TaggedString *n)
|
|
{
|
|
vardesc v = singlevar(n, L->currState-1);
|
|
int i;
|
|
for (i=0; i<L->currState->nupvalues; i++) {
|
|
if (L->currState->upvalues[i] == v)
|
|
return i;
|
|
}
|
|
/* new one */
|
|
if (++(L->currState->nupvalues) > MAXUPVALUES)
|
|
luaY_error("too many upvalues in a single function " MES_LIM(SMAXUPVALUES));
|
|
L->currState->upvalues[i] = v; /* i = L->currState->nupvalues - 1 */
|
|
return i;
|
|
}
|
|
|
|
|
|
static void pushupvalue (TaggedString *n)
|
|
{
|
|
int i;
|
|
if (L->currState == L->mainState)
|
|
luaY_error("cannot access upvalue in main");
|
|
if (aux_localname(n, L->currState) >= 0)
|
|
luaY_syntaxerror("cannot access an upvalue in current scope", n->str);
|
|
i = indexupvalue(n);
|
|
code_oparg(PUSHUPVALUE, 2, i, 1);
|
|
}
|
|
|
|
|
|
void luaY_codedebugline (int line)
|
|
{
|
|
if (lua_debug && line != L->lexstate->lastline) {
|
|
code_oparg(SETLINE, 0, line, 0);
|
|
L->lexstate->lastline = line;
|
|
}
|
|
}
|
|
|
|
|
|
static void adjuststack (int n)
|
|
{
|
|
if (n > 0)
|
|
code_oparg(POP, 2, n-1, -n);
|
|
else if (n < 0)
|
|
code_oparg(PUSHNIL, 1, (-n)-1, -n);
|
|
}
|
|
|
|
|
|
static long adjust_functioncall (long exp, int nresults)
|
|
{
|
|
if (exp <= 0)
|
|
return -exp; /* exp is -list length */
|
|
else {
|
|
int temp = L->currState->f->code[exp];
|
|
int nparams = L->currState->f->code[exp-1];
|
|
exp += fix_opcode(exp-2, CALLFUNC, 2, nresults);
|
|
L->currState->f->code[exp] = nparams;
|
|
if (nresults != MULT_RET)
|
|
deltastack(nresults);
|
|
deltastack(-(nparams+1));
|
|
return temp+nresults;
|
|
}
|
|
}
|
|
|
|
|
|
static void adjust_mult_assign (int vars, long exps)
|
|
{
|
|
if (exps > 0) { /* must correct function call */
|
|
int diff = L->currState->f->code[exps] - vars;
|
|
if (diff < 0)
|
|
adjust_functioncall(exps, -diff);
|
|
else {
|
|
adjust_functioncall(exps, 0);
|
|
adjuststack(diff);
|
|
}
|
|
}
|
|
else adjuststack((-exps)-vars);
|
|
}
|
|
|
|
|
|
static void code_args (int nparams, int dots)
|
|
{
|
|
L->currState->nlocalvar += nparams; /* "self" may already be there */
|
|
nparams = L->currState->nlocalvar;
|
|
if (!dots) {
|
|
L->currState->f->code[1] = nparams; /* fill-in arg information */
|
|
deltastack(nparams);
|
|
}
|
|
else {
|
|
L->currState->f->code[1] = nparams+ZEROVARARG;
|
|
deltastack(nparams+1);
|
|
add_localvar(luaS_new("arg"));
|
|
}
|
|
}
|
|
|
|
|
|
static void lua_pushvar (vardesc var)
|
|
{
|
|
if (isglobal(var))
|
|
code_oparg(GETGLOBAL, 8, globalindex(var), 1);
|
|
else if (islocal(var))
|
|
code_oparg(PUSHLOCAL, 8, localindex(var), 1);
|
|
else if (isdot(var))
|
|
code_oparg(GETDOTTED, 8, dotindex(var), 0);
|
|
else
|
|
code_pop(GETTABLE);
|
|
}
|
|
|
|
|
|
static void storevar (vardesc var)
|
|
{
|
|
if (var == 0) /* indexed var */
|
|
code_opcode(SETTABLE0, -3);
|
|
else if (isglobal(var))
|
|
code_oparg(SETGLOBAL, 8, globalindex(var), -1);
|
|
else /* local var */
|
|
code_oparg(SETLOCAL, 8, localindex(var), -1);
|
|
}
|
|
|
|
|
|
/* returns how many elements are left as 'garbage' on the stack */
|
|
static int lua_codestore (int i, int left)
|
|
{
|
|
if (L->currState->varbuffer[i] != 0 || /* global or local var or */
|
|
left+i == 0) { /* indexed var without values in between */
|
|
storevar(L->currState->varbuffer[i]);
|
|
return left;
|
|
}
|
|
else { /* indexed var with values in between*/
|
|
code_oparg(SETTABLE, 0, left+i, -1);
|
|
return left+2; /* table/index are not popped, since they are not on top */
|
|
}
|
|
}
|
|
|
|
|
|
static int fix_jump (int pc, OpCode op, int n)
|
|
{
|
|
/* jump is relative to position following jump instruction */
|
|
return fix_opcode(pc, op, 0, n-(pc+JMPSIZE));
|
|
}
|
|
|
|
|
|
static void fix_upjmp (OpCode op, int pos)
|
|
{
|
|
int delta = L->currState->pc+JMPSIZE - pos; /* jump is relative */
|
|
if (delta > 255) delta++;
|
|
code_oparg(op, 0, delta, 0);
|
|
}
|
|
|
|
|
|
static void codeIf (int thenAdd, int elseAdd)
|
|
{
|
|
int elseinit = elseAdd+JMPSIZE;
|
|
if (L->currState->pc == elseinit) { /* no else part */
|
|
L->currState->pc -= JMPSIZE;
|
|
elseinit = L->currState->pc;
|
|
}
|
|
else
|
|
elseinit += fix_jump(elseAdd, JMP, L->currState->pc);
|
|
fix_jump(thenAdd, IFFJMP, elseinit);
|
|
}
|
|
|
|
|
|
static void code_shortcircuit (int pc, OpCode op)
|
|
{
|
|
fix_jump(pc, op, L->currState->pc);
|
|
}
|
|
|
|
|
|
static void codereturn (void)
|
|
{
|
|
code_oparg(RETCODE, 0, L->currState->nlocalvar, 0);
|
|
L->currState->stacksize = L->currState->nlocalvar;
|
|
}
|
|
|
|
|
|
static void func_onstack (TProtoFunc *f)
|
|
{
|
|
int i;
|
|
int nupvalues = (L->currState+1)->nupvalues;
|
|
int c = next_constant(L->currState);
|
|
ttype(&L->currState->f->consts[c]) = LUA_T_PROTO;
|
|
L->currState->f->consts[c].value.tf = (L->currState+1)->f;
|
|
if (nupvalues == 0)
|
|
code_constant(c);
|
|
else {
|
|
for (i=0; i<nupvalues; i++)
|
|
lua_pushvar((L->currState+1)->upvalues[i]);
|
|
code_constant(c);
|
|
code_oparg(CLOSURE, 2, nupvalues, -nupvalues);
|
|
}
|
|
}
|
|
|
|
|
|
static void init_state (TaggedString *filename)
|
|
{
|
|
TProtoFunc *f = luaF_newproto();
|
|
FuncState *fs = L->currState;
|
|
fs->stacksize = 0;
|
|
fs->maxstacksize = 0;
|
|
fs->nlocalvar = 0;
|
|
fs->nupvalues = 0;
|
|
fs->f = f;
|
|
f->fileName = filename;
|
|
fs->pc = 0;
|
|
fs->maxcode = 0;
|
|
f->code = NULL;
|
|
fs->maxconsts = 0;
|
|
if (lua_debug) {
|
|
fs->nvars = 0;
|
|
fs->maxvars = 0;
|
|
}
|
|
else
|
|
fs->maxvars = -1; /* flag no debug information */
|
|
code_byte(0); /* to be filled with stacksize */
|
|
code_byte(0); /* to be filled with arg information */
|
|
L->lexstate->lastline = 0; /* invalidate it */
|
|
}
|
|
|
|
|
|
static void init_func (void)
|
|
{
|
|
if (L->currState-L->mainState >= MAXSTATES-1)
|
|
luaY_error("too many nested functions " MES_LIM(SMAXSTATES));
|
|
L->currState++;
|
|
init_state(L->mainState->f->fileName);
|
|
luaY_codedebugline(L->lexstate->linenumber);
|
|
L->currState->f->lineDefined = L->lexstate->linenumber;
|
|
}
|
|
|
|
static TProtoFunc *close_func (void)
|
|
{
|
|
TProtoFunc *f = L->currState->f;
|
|
code_neutralop(ENDCODE);
|
|
f->code[0] = L->currState->maxstacksize;
|
|
f->code = luaM_reallocvector(f->code, L->currState->pc, Byte);
|
|
f->consts = luaM_reallocvector(f->consts, f->nconsts, TObject);
|
|
if (L->currState->maxvars != -1) { /* debug information? */
|
|
luaI_registerlocalvar(NULL, -1); /* flag end of vector */
|
|
f->locvars = luaM_reallocvector(f->locvars, L->currState->nvars, LocVar);
|
|
}
|
|
L->currState--;
|
|
return f;
|
|
}
|
|
|
|
|
|
/*
|
|
** Parse Lua code.
|
|
*/
|
|
TProtoFunc *luaY_parser (ZIO *z)
|
|
{
|
|
struct LexState lexstate;
|
|
FuncState state[MAXSTATES];
|
|
L->currState = L->mainState = &state[0];
|
|
L->lexstate = &lexstate;
|
|
luaX_setinput(z);
|
|
init_state(luaS_new(zname(z)));
|
|
if (luaY_parse()) lua_error("parse error");
|
|
return close_func();
|
|
}
|
|
|
|
|
|
%}
|
|
|
|
|
|
%union
|
|
{
|
|
int vInt;
|
|
real vReal;
|
|
char *pChar;
|
|
long vLong;
|
|
TaggedString *pTStr;
|
|
TProtoFunc *pFunc;
|
|
}
|
|
|
|
%start chunk
|
|
|
|
%token WRONGTOKEN
|
|
%token NIL
|
|
%token IF THEN ELSE ELSEIF WHILE DO REPEAT UNTIL END
|
|
%token RETURN
|
|
%token LOCAL
|
|
%token FUNCTION
|
|
%token DOTS
|
|
%token <vReal> NUMBER
|
|
%token <pTStr> NAME STRING
|
|
|
|
%type <vInt> SaveWord, cond, GetPC, SaveWordPop, SaveWordPush
|
|
%type <vLong> exprlist, exprlist1 /* if > 0, points to function return
|
|
counter (which has list length); if <= 0, -list lenght */
|
|
%type <vLong> functioncall, expr, sexp /* if != 0, points to function return
|
|
counter */
|
|
%type <vInt> varlist1, funcParams, funcvalue
|
|
%type <vInt> fieldlist, localnamelist, decinit
|
|
%type <vInt> ffieldlist1, lfieldlist1, ffieldlist, lfieldlist, part
|
|
%type <vLong> var, varname, funcname /* vardesc */
|
|
|
|
|
|
%left AND OR
|
|
%left EQ NE '>' '<' LE GE
|
|
%left CONC
|
|
%left '+' '-'
|
|
%left '*' '/'
|
|
%left UNARY NOT
|
|
%right '^'
|
|
|
|
|
|
%% /* beginning of rules section */
|
|
|
|
|
|
chunk : statlist ret ;
|
|
|
|
statlist : /* empty */
|
|
| statlist stat sc
|
|
;
|
|
|
|
sc : /* empty */ | ';' ;
|
|
|
|
stat : IF cond THEN block SaveWord elsepart END { codeIf($2, $5); }
|
|
|
|
| DO block END
|
|
|
|
| WHILE GetPC cond DO block END
|
|
{{
|
|
FuncState *fs = L->currState;
|
|
int expsize = $3-$2;
|
|
int newpos = $2+JMPSIZE;
|
|
check_pc(expsize);
|
|
memcpy(fs->f->code+fs->pc, fs->f->code+$2, expsize);
|
|
luaO_memdown(fs->f->code+$2, fs->f->code+$3, fs->pc-$2);
|
|
newpos += fix_jump($2, JMP, fs->pc-expsize);
|
|
fix_upjmp(IFTUPJMP, newpos);
|
|
}}
|
|
|
|
| REPEAT GetPC block UNTIL expr1
|
|
{
|
|
fix_upjmp(IFFUPJMP, $2);
|
|
deltastack(-1); /* pops condition */
|
|
}
|
|
|
|
| varlist1 '=' exprlist1
|
|
{{
|
|
int i;
|
|
int left = 0;
|
|
adjust_mult_assign($1, $3);
|
|
for (i=$1-1; i>=0; i--)
|
|
left = lua_codestore(i, left);
|
|
adjuststack(left); /* remove eventual 'garbage' left on stack */
|
|
}}
|
|
|
|
| functioncall { adjust_functioncall($1, 0); }
|
|
|
|
| LOCAL localnamelist decinit
|
|
{
|
|
L->currState->nlocalvar += $2;
|
|
adjust_mult_assign($2, $3);
|
|
}
|
|
|
|
| FUNCTION funcname body { storevar($2); }
|
|
;
|
|
|
|
block : {$<vInt>$ = L->currState->nlocalvar;} chunk
|
|
{
|
|
adjuststack(L->currState->nlocalvar - $<vInt>1);
|
|
for (; L->currState->nlocalvar > $<vInt>1; L->currState->nlocalvar--)
|
|
luaI_unregisterlocalvar(L->lexstate->linenumber);
|
|
}
|
|
;
|
|
|
|
funcname : varname { $$ = $1; init_func(); }
|
|
| fvarname '.' fname
|
|
{
|
|
$$ = 0; /* flag indexed variable */
|
|
init_func();
|
|
}
|
|
| fvarname ':' fname
|
|
{
|
|
$$ = 0; /* flag indexed variable */
|
|
init_func();
|
|
add_localvar(luaS_new("self"));
|
|
}
|
|
;
|
|
|
|
fvarname : varname { lua_pushvar($1); } ;
|
|
|
|
fname : NAME { code_string($1); } ;
|
|
|
|
body : '(' parlist ')' chunk END { func_onstack(close_func()); } ;
|
|
|
|
elsepart : /* empty */
|
|
| ELSE block
|
|
| ELSEIF cond THEN block SaveWord elsepart { codeIf($2, $5); }
|
|
;
|
|
|
|
ret : /* empty */
|
|
| RETURN exprlist sc
|
|
{
|
|
adjust_functioncall($2, MULT_RET);
|
|
codereturn();
|
|
}
|
|
;
|
|
|
|
GetPC : /* empty */ { $$ = L->currState->pc; } ;
|
|
|
|
SaveWord : /* empty */
|
|
{ $$ = L->currState->pc;
|
|
check_pc(JMPSIZE);
|
|
L->currState->pc += JMPSIZE; /* open space */
|
|
}
|
|
;
|
|
|
|
SaveWordPop : SaveWord { $$ = $1; deltastack(-1); /* pop condition */ } ;
|
|
|
|
SaveWordPush : SaveWord { $$ = $1; deltastack(1); /* push a value */ } ;
|
|
|
|
cond : expr1 SaveWordPop { $$ = $2; } ;
|
|
|
|
expr1 : expr { adjust_functioncall($1, 1); } ;
|
|
|
|
expr : '(' expr ')' { $$ = $2; }
|
|
| expr1 EQ expr1 { code_binop(EQOP); $$ = 0; }
|
|
| expr1 '<' expr1 { code_binop(LTOP); $$ = 0; }
|
|
| expr1 '>' expr1 { code_binop(GTOP); $$ = 0; }
|
|
| expr1 NE expr1 { code_binop(NEQOP); $$ = 0; }
|
|
| expr1 LE expr1 { code_binop(LEOP); $$ = 0; }
|
|
| expr1 GE expr1 { code_binop(GEOP); $$ = 0; }
|
|
| expr1 '+' expr1 { code_binop(ADDOP); $$ = 0; }
|
|
| expr1 '-' expr1 { code_binop(SUBOP); $$ = 0; }
|
|
| expr1 '*' expr1 { code_binop(MULTOP); $$ = 0; }
|
|
| expr1 '/' expr1 { code_binop(DIVOP); $$ = 0; }
|
|
| expr1 '^' expr1 { code_binop(POWOP); $$ = 0; }
|
|
| expr1 CONC expr1 { code_binop(CONCOP); $$ = 0; }
|
|
| '-' expr1 %prec UNARY { code_unop(MINUSOP); $$ = 0;}
|
|
| NOT expr1 { code_unop(NOTOP); $$ = 0;}
|
|
| sexp { $$ = $1; /* simple expressions */ }
|
|
| table { $$ = 0; }
|
|
| NUMBER { code_number($1); $$ = 0; }
|
|
| STRING { code_string($1); $$ = 0; }
|
|
| NIL { adjuststack(-1); $$ = 0; }
|
|
| FUNCTION { init_func(); } body { $$ = 0; }
|
|
| expr1 AND SaveWordPop expr1 { code_shortcircuit($3, ONFJMP); $$ = 0; }
|
|
| expr1 OR SaveWordPop expr1 { code_shortcircuit($3, ONTJMP); $$ = 0; }
|
|
;
|
|
|
|
sexp1 : sexp { adjust_functioncall($1, 1); } ;
|
|
|
|
sexp : var { lua_pushvar($1); $$ = 0; }
|
|
| '%' NAME { pushupvalue($2); $$ = 0; }
|
|
| functioncall { $$ = $1; }
|
|
;
|
|
|
|
var : varname { $$ = $1; }
|
|
| sexp1 '[' expr1 ']' { $$ = 0; } /* indexed variable */
|
|
| sexp1 '.' NAME { $$ = (-string_constant($3, L->currState))-1; }
|
|
;
|
|
|
|
varname : NAME { $$ = singlevar($1, L->currState); } ;
|
|
|
|
table : '{' SaveWordPush fieldlist '}' { fix_opcode($2, CREATEARRAY, 2, $3); } ;
|
|
|
|
functioncall : funcvalue funcParams
|
|
{
|
|
code_byte(0); /* save space for opcode */
|
|
code_byte($1+$2); /* number of parameters */
|
|
$$ = L->currState->pc;
|
|
code_byte(0); /* must be adjusted by other rules */
|
|
}
|
|
;
|
|
|
|
funcvalue : sexp1 { $$ = 0; }
|
|
| sexp1 ':' NAME
|
|
{
|
|
code_oparg(PUSHSELF, 8, string_constant($3, L->currState), 1);
|
|
$$ = 1;
|
|
}
|
|
;
|
|
|
|
funcParams : '(' exprlist ')' { $$ = adjust_functioncall($2, 1); }
|
|
| table { $$ = 1; }
|
|
| STRING { code_string($1); $$ = 1; }
|
|
;
|
|
|
|
exprlist : /* empty */ { $$ = 0; }
|
|
| exprlist1 { $$ = $1; }
|
|
;
|
|
|
|
exprlist1 : expr { if ($1 != 0) $$ = $1; else $$ = -1; }
|
|
| exprlist1 ',' { $<vLong>$ = adjust_functioncall($1, 1); } expr
|
|
{
|
|
if ($4 == 0) $$ = -($<vLong>3 + 1); /* -length */
|
|
else {
|
|
L->currState->f->code[$4] = $<vLong>3; /* store list length */
|
|
$$ = $4;
|
|
}
|
|
}
|
|
;
|
|
|
|
parlist : /* empty */ { code_args(0, 0); }
|
|
| DOTS { code_args(0, 1); }
|
|
| localnamelist { code_args($1, 0); }
|
|
| localnamelist ',' DOTS { code_args($1, 1); }
|
|
;
|
|
|
|
fieldlist : part { $$ = abs($1); }
|
|
| part ';' part
|
|
{
|
|
if ($1*$3 > 0) /* repeated parts? */
|
|
luaY_error("invalid constructor syntax");
|
|
$$ = abs($1)+abs($3);
|
|
}
|
|
;
|
|
|
|
part : /* empty */ { $$ = 0; }
|
|
| ffieldlist { $$ = $1; }
|
|
| lfieldlist { $$ = $1; }
|
|
;
|
|
|
|
lastcomma : /* empty */ | ',' ;
|
|
|
|
ffieldlist : ffieldlist1 lastcomma
|
|
{
|
|
flush_record($1%RFIELDS_PER_FLUSH);
|
|
$$ = -$1; /* negative signals a "record" part */
|
|
}
|
|
;
|
|
|
|
lfieldlist : lfieldlist1 lastcomma
|
|
{
|
|
flush_list($1/LFIELDS_PER_FLUSH, $1%LFIELDS_PER_FLUSH);
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
ffieldlist1 : ffield {$$=1;}
|
|
| ffieldlist1 ',' ffield
|
|
{
|
|
$$=$1+1;
|
|
if ($$%RFIELDS_PER_FLUSH == 0)
|
|
flush_record(RFIELDS_PER_FLUSH);
|
|
}
|
|
;
|
|
|
|
ffield : ffieldkey '=' expr1 ;
|
|
|
|
ffieldkey : '[' expr1 ']'
|
|
| fname
|
|
;
|
|
|
|
lfieldlist1 : expr1 {$$=1;}
|
|
| lfieldlist1 ',' expr1
|
|
{
|
|
$$=$1+1;
|
|
if ($$%LFIELDS_PER_FLUSH == 0)
|
|
flush_list($$/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH);
|
|
}
|
|
;
|
|
|
|
varlist1 : var { $$ = 1; add_varbuffer($1, 0); }
|
|
| varlist1 ',' var { add_varbuffer($3, $1); $$ = $1+1; }
|
|
;
|
|
|
|
localnamelist : NAME {store_localvar($1, 0); $$ = 1;}
|
|
| localnamelist ',' NAME { store_localvar($3, $1); $$ = $1+1; }
|
|
;
|
|
|
|
decinit : /* empty */ { $$ = 0; }
|
|
| '=' exprlist1 { $$ = $2; }
|
|
;
|
|
|
|
%%
|
|
|