| %{ |
| /* |
| ** $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; } |
| ; |
| |
| %% |
| |