/*** $Id: lparser.c,v 2.42.1.3 2007/12/28 15:32:23 roberto Exp $** Lua Parser** See Copyright Notice in lua.h*/#include <string.h>#define lparser_c#define LUA_CORE#include "lua.h"#include "lcode.h"#include "ldebug.h"#include "ldo.h"#include "lfunc.h"#include "llex.h"#include "lmem.h"#include "lobject.h"#include "lopcodes.h"#include "lparser.h"#include "lstate.h"#include "lstring.h"#include "ltable.h"#define hasmultret(k)		((k) == VCALL || (k) == VVARARG)#define getlocvar(fs, i)	((fs)->f->locvars[(fs)->actvar[i]])#define luaY_checklimit(fs,v,l,m)	if ((v)>(l)) errorlimit(fs,l,m)/*** nodes for block list (list of active blocks)*/typedef struct BlockCnt {  struct BlockCnt *previous;  /* chain */  int breaklist;  /* list of jumps out of this loop */  lu_byte nactvar;  /* # active locals outside the breakable structure */  lu_byte upval;  /* true if some variable in the block is an upvalue */  lu_byte isbreakable;  /* true if `block' is a loop */} BlockCnt;/*** prototypes for recursive non-terminal functions*/static void chunk (LexState *ls);static void expr (LexState *ls, expdesc *v);static void anchor_token (LexState *ls) {  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {    TString *ts = ls->t.seminfo.ts;    luaX_newstring(ls, getstr(ts), ts->tsv.len);  }}static void error_expected (LexState *ls, int token) {  luaX_syntaxerror(ls,      luaO_pushfstring(ls->L, LUA_QS " expected", luaX_token2str(ls, token)));}static void errorlimit (FuncState *fs, int limit, const char *what) {  const char *msg = (fs->f->linedefined == 0) ?    luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :    luaO_pushfstring(fs->L, "function at line %d has more than %d %s",                            fs->f->linedefined, limit, what);  luaX_lexerror(fs->ls, msg, 0);}static int testnext (LexState *ls, int c) {  if (ls->t.token == c) {    luaX_next(ls);    return 1;  }  else return 0;}static void check (LexState *ls, int c) {  if (ls->t.token != c)    error_expected(ls, c);}static void checknext (LexState *ls, int c) {  check(ls, c);  luaX_next(ls);}#define check_condition(ls,c,msg)	{ if (!(c)) luaX_syntaxerror(ls, msg); }static void check_match (LexState *ls, int what, int who, int where) {  if (!testnext(ls, what)) {    if (where == ls->linenumber)      error_expected(ls, what);    else {      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,             LUA_QS " expected (to close " LUA_QS " at line %d)",              luaX_token2str(ls, what), luaX_token2str(ls, who), where));    }  }}static TString *str_checkname (LexState *ls) {  TString *ts;  check(ls, TK_NAME);  ts = ls->t.seminfo.ts;  luaX_next(ls);  return ts;}static void init_exp (expdesc *e, expkind k, int i) {  e->f = e->t = NO_JUMP;  e->k = k;  e->u.s.info = i;}static void codestring (LexState *ls, expdesc *e, TString *s) {  init_exp(e, VK, luaK_stringK(ls->fs, s));}static void checkname(LexState *ls, expdesc *e) {  codestring(ls, e, str_checkname(ls));}static int registerlocalvar (LexState *ls, TString *varname) {  FuncState *fs = ls->fs;  Proto *f = fs->f;  int oldsize = f->sizelocvars;  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,                  LocVar, SHRT_MAX, "too many local variables");  while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;  f->locvars[fs->nlocvars].varname = varname;  luaC_objbarrier(ls->L, f, varname);  return fs->nlocvars++;}#define new_localvarliteral(ls,v,n) \  new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n)static void new_localvar (LexState *ls, TString *name, int n) {  FuncState *fs = ls->fs;  luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables");  fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));}static void adjustlocalvars (LexState *ls, int nvars) {  FuncState *fs = ls->fs;  fs->nactvar = cast_byte(fs->nactvar + nvars);  for (; nvars; nvars--) {    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;  }}static void removevars (LexState *ls, int tolevel) {  FuncState *fs = ls->fs;  while (fs->nactvar > tolevel)    getlocvar(fs, --fs->nactvar).endpc = fs->pc;}static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {  int i;  Proto *f = fs->f;  int oldsize = f->sizeupvalues;  for (i=0; i<f->nups; i++) {    if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {      lua_assert(f->upvalues[i] == name);      return i;    }  }  /* new one */  luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");  luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,                  TString *, MAX_INT, "");  while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;  f->upvalues[f->nups] = name;  luaC_objbarrier(fs->L, f, name);  lua_assert(v->k == VLOCAL || v->k == VUPVAL);  fs->upvalues[f->nups].k = cast_byte(v->k);  fs->upvalues[f->nups].info = cast_byte(v->u.s.info);  return f->nups++;}static int searchvar (FuncState *fs, TString *n) {  int i;  for (i=fs->nactvar-1; i >= 0; i--) {    if (n == getlocvar(fs, i).varname)      return i;  }  return -1;  /* not found */}static void markupval (FuncState *fs, int level) {  BlockCnt *bl = fs->bl;  while (bl && bl->nactvar > level) bl = bl->previous;  if (bl) bl->upval = 1;}static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {  if (fs == NULL) {  /* no more levels? */    init_exp(var, VGLOBAL, NO_REG);  /* default is global variable */    return VGLOBAL;  }  else {    int v = searchvar(fs, n);  /* look up at current level */    if (v >= 0) {      init_exp(var, VLOCAL, v);      if (!base)        markupval(fs, v);  /* local will be used as an upval */      return VLOCAL;    }    else {  /* not found at current level; try upper one */      if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)        return VGLOBAL;      var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */      var->k = VUPVAL;  /* upvalue in this level */      return VUPVAL;    }  }}static void singlevar (LexState *ls, expdesc *var) {  TString *varname = str_checkname(ls);  FuncState *fs = ls->fs;  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */}static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {  FuncState *fs = ls->fs;  int extra = nvars - nexps;  if (hasmultret(e->k)) {    extra++;  /* includes call itself */    if (extra < 0) extra = 0;    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */    if (extra > 1) luaK_reserveregs(fs, extra-1);  }  else {    if (e->k != VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */    if (extra > 0) {      int reg = fs->freereg;      luaK_reserveregs(fs, extra);      luaK_nil(fs, reg, extra);    }  }}static void enterlevel (LexState *ls) {  if (++ls->L->nCcalls > LUAI_MAXCCALLS)	luaX_lexerror(ls, "chunk has too many syntax levels", 0);}#define leavelevel(ls)	((ls)->L->nCcalls--)static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {  bl->breaklist = NO_JUMP;  bl->isbreakable = isbreakable;  bl->nactvar = fs->nactvar;  bl->upval = 0;  bl->previous = fs->bl;  fs->bl = bl;  lua_assert(fs->freereg == fs->nactvar);}static void leaveblock (FuncState *fs) {  BlockCnt *bl = fs->bl;  fs->bl = bl->previous;  removevars(fs->ls, bl->nactvar);  if (bl->upval)    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);  /* a block either controls scope or breaks (never both) */  lua_assert(!bl->isbreakable || !bl->upval);  lua_assert(bl->nactvar == fs->nactvar);  fs->freereg = fs->nactvar;  /* free registers */  luaK_patchtohere(fs, bl->breaklist);}static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {  FuncState *fs = ls->fs;  Proto *f = fs->f;  int oldsize = f->sizep;  int i;  luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,                  MAXARG_Bx, "constant table overflow");  while (oldsize < f->sizep) f->p[oldsize++] = NULL;  f->p[fs->np++] = func->f;  luaC_objbarrier(ls->L, f, func->f);  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));  for (i=0; i<func->f->nups; i++) {    OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;    luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);  }}static void open_func (LexState *ls, FuncState *fs) {  lua_State *L = ls->L;  Proto *f = luaF_newproto(L);  fs->f = f;  fs->prev = ls->fs;  /* linked list of funcstates */  fs->ls = ls;  fs->L = L;  ls->fs = fs;  fs->pc = 0;  fs->lasttarget = -1;  fs->jpc = NO_JUMP;  fs->freereg = 0;  fs->nk = 0;  fs->np = 0;  fs->nlocvars = 0;  fs->nactvar = 0;  fs->bl = NULL;  f->source = ls->source;  f->maxstacksize = 2;  /* registers 0/1 are always valid */  fs->h = luaH_new(L, 0, 0);  /* anchor table of constants and prototype (to avoid being collected) */  sethvalue2s(L, L->top, fs->h);  incr_top(L);  setptvalue2s(L, L->top, f);  incr_top(L);}static void close_func (LexState *ls) {  lua_State *L = ls->L;  FuncState *fs = ls->fs;  Proto *f = fs->f;  removevars(ls, 0);  luaK_ret(fs, 0, 0);  /* final return */  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);  f->sizecode = fs->pc;  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);  f->sizelineinfo = fs->pc;  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);  f->sizek = fs->nk;  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);  f->sizep = fs->np;  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);  f->sizelocvars = fs->nlocvars;  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);  f->sizeupvalues = f->nups;  lua_assert(luaG_checkcode(f));  lua_assert(fs->bl == NULL);  ls->fs = fs->prev;  L->top -= 2;  /* remove table and prototype from the stack */  /* last token read was anchored in defunct function; must reanchor it */  if (fs) anchor_token(ls);}Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {  struct LexState lexstate;  struct FuncState funcstate;  lexstate.buff = buff;  luaX_setinput(L, &lexstate, z, luaS_new(L, name));  open_func(&lexstate, &funcstate);  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */  luaX_next(&lexstate);  /* read first token */  chunk(&lexstate);  check(&lexstate, TK_EOS);  close_func(&lexstate);  lua_assert(funcstate.prev == NULL);  lua_assert(funcstate.f->nups == 0);  lua_assert(lexstate.fs == NULL);  return funcstate.f;}/*============================================================*//* GRAMMAR RULES *//*============================================================*/static void field (LexState *ls, expdesc *v) {  /* field -> ['.' | ':'] NAME */  FuncState *fs = ls->fs;  expdesc key;  luaK_exp2anyreg(fs, v);  luaX_next(ls);  /* skip the dot or colon */  checkname(ls, &key);  luaK_indexed(fs, v, &key);}static void yindex (LexState *ls, expdesc *v) {  /* index -> '[' expr ']' */  luaX_next(ls);  /* skip the '[' */  expr(ls, v);  luaK_exp2val(ls->fs, v);  checknext(ls, ']');}/*** {======================================================================** Rules for Constructors** =======================================================================*/struct ConsControl {  expdesc v;  /* last list item read */  expdesc *t;  /* table descriptor */  int nh;  /* total number of `record' elements */  int na;  /* total number of array elements */  int tostore;  /* number of array elements pending to be stored */};static void recfield (LexState *ls, struct ConsControl *cc) {  /* recfield -> (NAME | `['exp1`]') = exp1 */  FuncState *fs = ls->fs;  int reg = ls->fs->freereg;  expdesc key, val;