#define lparser_c

#define LUA_CORE

#include "lprefix.h"

#include <limits.h>

#include <string.h>

#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 MAXVARS 200

#define hasmultret(k) ((k) == VCALL || (k) == VVARARG)

#define eqstr(a,b) ((a) == (b))

typedef struct BlockCnt {

} BlockCnt;

static void statement (LexState *ls);

static void expr (LexState *ls, expdesc *v);

static l_noret error_expected (LexState *ls, int token) {

luaX_syntaxerror(ls,

luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token)));

}

static l_noret errorlimit (FuncState *fs, int limit, const char *what) {

lua_State *L = fs->ls->L;

const char *msg;

int line = fs->f->linedefined;

const char *where = (line == 0)

? "main function"

: luaO_pushfstring(L, "function at line %d", line);

msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s",

what, limit, where);

luaX_syntaxerror(fs->ls, msg);

}

void luaY_checklimit (FuncState *fs, int v, int l, const char *what) {

if (l_unlikely(v > l)) errorlimit(fs, l, what);

}

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 (l_unlikely(!testnext(ls, what))) {

if (where == ls->linenumber) /* all in the same line? */

error_expected(ls, what); /* do not need a complex message */

else {

luaX_syntaxerror(ls, luaO_pushfstring(ls->L,

"%s expected (to close %s 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.info = i;

}

static void codestring (expdesc *e, TString *s) {

e->f = e->t = NO_JUMP;

e->k = VKSTR;

e->u.strval = s;

}

static void codename (LexState *ls, expdesc *e) {

codestring(e, str_checkname(ls));

}

static short registerlocalvar (LexState *ls, FuncState *fs,

TString *varname) {

Proto *f = fs->f;

int oldsize = f->sizelocvars;

luaM_growvector(ls->L, f->locvars, fs->ndebugvars, f->sizelocvars,

LocVar, SHRT_MAX, "local variables");

while (oldsize < f->sizelocvars)

f->locvars[oldsize++].varname = NULL;

f->locvars[fs->ndebugvars].varname = varname;

f->locvars[fs->ndebugvars].startpc = fs->pc;

luaC_objbarrier(ls->L, f, varname);

return fs->ndebugvars++;

}

static int new_varkind (LexState *ls, TString *name, lu_byte kind) {

lua_State *L = ls->L;

FuncState *fs = ls->fs;

Dyndata *dyd = ls->dyd;

Vardesc *var;

luaM_growvector(L, dyd->actvar.arr, dyd->actvar.n + 1,

dyd->actvar.size, Vardesc, SHRT_MAX, "variable declarations");

var = &dyd->actvar.arr[dyd->actvar.n++];

var->vd.kind = kind; /* default */

var->vd.name = name;

return dyd->actvar.n - 1 - fs->firstlocal;

}

static int new_localvar (LexState *ls, TString *name) {

return new_varkind(ls, name, VDKREG);

}

#define new_localvarliteral(ls,v) \

new_localvar(ls, \

luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1));

static Vardesc *getlocalvardesc (FuncState *fs, int vidx) {

return &fs->ls->dyd->actvar.arr[fs->firstlocal + vidx];

}

static lu_byte reglevel (FuncState *fs, int nvar) {

while (nvar-- > 0) {

Vardesc *vd = getlocalvardesc(fs, nvar); /* get previous variable */

if (varinreg(vd)) /* is in a register? */

return cast_byte(vd->vd.ridx + 1);

}

return 0; /* no variables in registers */

}

lu_byte luaY_nvarstack (FuncState *fs) {

return reglevel(fs, fs->nactvar);

}

static LocVar *localdebuginfo (FuncState *fs, int vidx) {

Vardesc *vd = getlocalvardesc(fs, vidx);

if (!varinreg(vd))

return NULL; /* no debug info. for constants */

else {

int idx = vd->vd.pidx;

lua_assert(idx < fs->ndebugvars);

return &fs->f->locvars[idx];

}

}

static void init_var (FuncState *fs, expdesc *e, int vidx) {

e->f = e->t = NO_JUMP;

e->k = VLOCAL;

e->u.var.vidx = cast_short(vidx);

e->u.var.ridx = getlocalvardesc(fs, vidx)->vd.ridx;

}

static void check_readonly (LexState *ls, expdesc *e) {

FuncState *fs = ls->fs;

TString *varname = NULL; /* to be set if variable is const */

switch (e->k) {

case VCONST: {

varname = ls->dyd->actvar.arr[e->u.info].vd.name;

break;

}

case VLOCAL: case VVARGVAR: {

Vardesc *vardesc = getlocalvardesc(fs, e->u.var.vidx);

if (vardesc->vd.kind != VDKREG) /* not a regular variable? */

varname = vardesc->vd.name;

break;

}

case VUPVAL: {

Upvaldesc *up = &fs->f->upvalues[e->u.info];

if (up->kind != VDKREG)

varname = up->name;

break;

}

case VVARGIND: {

needvatab(fs->f); /* function will need a vararg table */

e->k = VINDEXED;

} /* FALLTHROUGH */

case VINDEXUP: case VINDEXSTR: case VINDEXED: { /* global variable */

if (e->u.ind.ro) /* read-only? */

varname = tsvalue(&fs->f->k[e->u.ind.keystr]);

break;

}

default:

lua_assert(e->k == VINDEXI); /* this one doesn't need any check */

return; /* integer index cannot be read-only */

}

if (varname)

luaK_semerror(ls, "attempt to assign to const variable '%s'",

getstr(varname));

}

static void adjustlocalvars (LexState *ls, int nvars) {

FuncState *fs = ls->fs;

int reglevel = luaY_nvarstack(fs);

int i;

for (i = 0; i < nvars; i++) {

int vidx = fs->nactvar++;

Vardesc *var = getlocalvardesc(fs, vidx);

var->vd.ridx = cast_byte(reglevel++);

var->vd.pidx = registerlocalvar(ls, fs, var->vd.name);

luaY_checklimit(fs, reglevel, MAXVARS, "local variables");

}

}

static void removevars (FuncState *fs, int tolevel) {

fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel);

while (fs->nactvar > tolevel) {

LocVar *var = localdebuginfo(fs, --fs->nactvar);

if (var) /* does it have debug information? */

var->endpc = fs->pc;

}

}

static int searchupvalue (FuncState *fs, TString *name) {

int i;

Upvaldesc *up = fs->f->upvalues;

for (i = 0; i < fs->nups; i++) {

if (eqstr(up[i].name, name)) return i;

}

return -1; /* not found */

}

static Upvaldesc *allocupvalue (FuncState *fs) {

Proto *f = fs->f;

int oldsize = f->sizeupvalues;

luaY_checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues");

luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues,

Upvaldesc, MAXUPVAL, "upvalues");

while (oldsize < f->sizeupvalues)

f->upvalues[oldsize++].name = NULL;

return &f->upvalues[fs->nups++];

}

static int newupvalue (FuncState *fs, TString *name, expdesc *v) {

Upvaldesc *up = allocupvalue(fs);

FuncState *prev = fs->prev;

if (v->k == VLOCAL) {

up->instack = 1;

up->idx = v->u.var.ridx;

up->kind = getlocalvardesc(prev, v->u.var.vidx)->vd.kind;

lua_assert(eqstr(name, getlocalvardesc(prev, v->u.var.vidx)->vd.name));

}

else {

up->instack = 0;

up->idx = cast_byte(v->u.info);

up->kind = prev->f->upvalues[v->u.info].kind;

lua_assert(eqstr(name, prev->f->upvalues[v->u.info].name));

}

up->name = name;

luaC_objbarrier(fs->ls->L, fs->f, name);

return fs->nups - 1;

}

static int searchvar (FuncState *fs, TString *n, expdesc *var) {

int i;

for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {

Vardesc *vd = getlocalvardesc(fs, i);

if (varglobal(vd)) { /* global declaration? */

if (vd->vd.name == NULL) { /* collective declaration? */

if (var->u.info < 0) /* no previous collective declaration? */

var->u.info = fs->firstlocal + i; /* this is the first one */

}

else { /* global name */

if (eqstr(n, vd->vd.name)) { /* found? */

init_exp(var, VGLOBAL, fs->firstlocal + i);

return VGLOBAL;

}

else if (var->u.info == -1) /* active preambular declaration? */

var->u.info = -2; /* invalidate preambular declaration */

}

}

else if (eqstr(n, vd->vd.name)) { /* found? */

if (vd->vd.kind == RDKCTC) /* compile-time constant? */

init_exp(var, VCONST, fs->firstlocal + i);

else { /* local variable */

init_var(fs, var, i);

if (vd->vd.kind == RDKVAVAR) /* vararg parameter? */

var->k = VVARGVAR;

}

return cast_int(var->k);

}

}

return -1; /* not found */

}

static void markupval (FuncState *fs, int level) {

BlockCnt *bl = fs->bl;

while (bl->nactvar > level)

bl = bl->previous;

bl->upval = 1;

fs->needclose = 1;

}

static void marktobeclosed (FuncState *fs) {

BlockCnt *bl = fs->bl;

bl->upval = 1;

bl->insidetbc = 1;

fs->needclose = 1;

}

static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {

int v = searchvar(fs, n, var); /* look up variables at current level */

if (v >= 0) { /* found? */

if (!base) {

if (var->k == VVARGVAR) /* vararg parameter? */

luaK_vapar2local(fs, var); /* change it to a regular local */

if (var->k == VLOCAL)

markupval(fs, var->u.var.vidx); /* will be used as an upvalue */

}

/* else nothing else to be done */

}

else { /* not found at current level; try upvalues */

int idx = searchupvalue(fs, n); /* try existing upvalues */

if (idx < 0) { /* not found? */

if (fs->prev != NULL) /* more levels? */

singlevaraux(fs->prev, n, var, 0); /* try upper levels */

if (var->k == VLOCAL || var->k == VUPVAL) /* local or upvalue? */

idx = newupvalue(fs, n, var); /* will be a new upvalue */

else /* it is a global or a constant */

return; /* don't need to do anything at this level */

}

init_exp(var, VUPVAL, idx); /* new or old upvalue */

}

}

static void buildglobal (LexState *ls, TString *varname, expdesc *var) {

FuncState *fs = ls->fs;

expdesc key;

init_exp(var, VGLOBAL, -1); /* global by default */

singlevaraux(fs, ls->envn, var, 1); /* get environment variable */

if (var->k == VGLOBAL)

luaK_semerror(ls, "%s is global when accessing variable '%s'",

LUA_ENV, getstr(varname));

luaK_exp2anyregup(fs, var); /* _ENV could be a constant */

codestring(&key, varname); /* key is variable name */

luaK_indexed(fs, var, &key); /* 'var' represents _ENV[varname] */

}

static void buildvar (LexState *ls, TString *varname, expdesc *var) {

FuncState *fs = ls->fs;

init_exp(var, VGLOBAL, -1); /* global by default */

singlevaraux(fs, varname, var, 1);

if (var->k == VGLOBAL) { /* global name? */

int info = var->u.info;

/* global by default in the scope of a global declaration? */

if (info == -2)

luaK_semerror(ls, "variable '%s' not declared", getstr(varname));

buildglobal(ls, varname, var);

if (info != -1 && ls->dyd->actvar.arr[info].vd.kind == GDKCONST)

var->u.ind.ro = 1; /* mark variable as read-only */

else /* anyway must be a global */

lua_assert(info == -1 || ls->dyd->actvar.arr[info].vd.kind == GDKREG);

}

}

static void singlevar (LexState *ls, expdesc *var) {

buildvar(ls, str_checkname(ls), var);

}

static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {

FuncState *fs = ls->fs;

int needed = nvars - nexps; /* extra values needed */

luaK_checkstack(fs, needed);

if (hasmultret(e->k)) { /* last expression has multiple returns? */

int extra = needed + 1; /* discount last expression itself */

if (extra < 0)

extra = 0;

luaK_setreturns(fs, e, extra); /* last exp. provides the difference */

}

else {

if (e->k != VVOID) /* at least one expression? */

luaK_exp2nextreg(fs, e); /* close last expression */

if (needed > 0) /* missing values? */

luaK_nil(fs, fs->freereg, needed); /* complete with nils */

}

if (needed > 0)

luaK_reserveregs(fs, needed); /* registers for extra values */

else /* adding 'needed' is actually a subtraction */

fs->freereg = cast_byte(fs->freereg + needed); /* remove extra values */

}

#define enterlevel(ls) luaE_incCstack(ls->L)

#define leavelevel(ls) ((ls)->L->nCcalls--)

static l_noret jumpscopeerror (LexState *ls, Labeldesc *gt) {

TString *tsname = getlocalvardesc(ls->fs, gt->nactvar)->vd.name;

const char *varname = (tsname != NULL) ? getstr(tsname) : "*";

luaK_semerror(ls,

"<goto %s> at line %d jumps into the scope of '%s'",

getstr(gt->name), gt->line, varname); /* raise the error */

}

static void closegoto (LexState *ls, int g, Labeldesc *label, int bup) {

int i;

FuncState *fs = ls->fs;

Labellist *gl = &ls->dyd->gt; /* list of gotos */

Labeldesc *gt = &gl->arr[g]; /* goto to be resolved */

lua_assert(eqstr(gt->name, label->name));

if (l_unlikely(gt->nactvar < label->nactvar)) /* enter some scope? */

jumpscopeerror(ls, gt);

if (gt->close ||

(label->nactvar < gt->nactvar && bup)) { /* needs close? */

lu_byte stklevel = reglevel(fs, label->nactvar);

/* move jump to CLOSE position */

fs->f->code[gt->pc + 1] = fs->f->code[gt->pc];

/* put CLOSE instruction at original position */

fs->f->code[gt->pc] = CREATE_ABCk(OP_CLOSE, stklevel, 0, 0, 0);

gt->pc++; /* must point to jump instruction */

}

luaK_patchlist(ls->fs, gt->pc, label->pc); /* goto jumps to label */

for (i = g; i < gl->n - 1; i++) /* remove goto from pending list */

gl->arr[i] = gl->arr[i + 1];

gl->n--;

}

static Labeldesc *findlabel (LexState *ls, TString *name, int ilb) {

Dyndata *dyd = ls->dyd;

for (; ilb < dyd->label.n; ilb++) {

Labeldesc *lb = &dyd->label.arr[ilb];

if (eqstr(lb->name, name)) /* correct label? */

return lb;

}

return NULL; /* label not found */

}

static int newlabelentry (LexState *ls, Labellist *l, TString *name,

int line, int pc) {

int n = l->n;

luaM_growvector(ls->L, l->arr, n, l->size,

Labeldesc, SHRT_MAX, "labels/gotos");

l->arr[n].name = name;

l->arr[n].line = line;

l->arr[n].nactvar = ls->fs->nactvar;

l->arr[n].close = 0;

l->arr[n].pc = pc;

l->n = n + 1;

return n;

}

static int newgotoentry (LexState *ls, TString *name, int line) {

FuncState *fs = ls->fs;

int pc = luaK_jump(fs); /* create jump */

luaK_codeABC(fs, OP_CLOSE, 0, 1, 0); /* spaceholder, marked as dead */

return newlabelentry(ls, &ls->dyd->gt, name, line, pc);

}

static void createlabel (LexState *ls, TString *name, int line, int last) {

FuncState *fs = ls->fs;

Labellist *ll = &ls->dyd->label;

int l = newlabelentry(ls, ll, name, line, luaK_getlabel(fs));

if (last) { /* label is last no-op statement in the block? */

/* assume that locals are already out of scope */

ll->arr[l].nactvar = fs->bl->nactvar;

}

}

static void solvegotos (FuncState *fs, BlockCnt *bl) {

LexState *ls = fs->ls;

Labellist *gl = &ls->dyd->gt;

int outlevel = reglevel(fs, bl->nactvar); /* level outside the block */

int igt = bl->firstgoto; /* first goto in the finishing block */

while (igt < gl->n) { /* for each pending goto */

Labeldesc *gt = &gl->arr[igt];

/* search for a matching label in the current block */

Labeldesc *lb = findlabel(ls, gt->name, bl->firstlabel);

if (lb != NULL) /* found a match? */

closegoto(ls, igt, lb, bl->upval); /* close and remove goto */

else { /* adjust 'goto' for outer block */

/* block has variables to be closed and goto escapes the scope of

if (bl->upval && reglevel(fs, gt->nactvar) > outlevel)

gt->close = 1; /* jump may need a close */

gt->nactvar = bl->nactvar; /* correct level for outer block */

igt++; /* go to next goto */

}

}

ls->dyd->label.n = bl->firstlabel; /* remove local labels */

}

static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {

bl->isloop = isloop;

bl->nactvar = fs->nactvar;

bl->firstlabel = fs->ls->dyd->label.n;

bl->firstgoto = fs->ls->dyd->gt.n;

bl->upval = 0;

/* inherit 'insidetbc' from enclosing block */

bl->insidetbc = (fs->bl != NULL && fs->bl->insidetbc);

bl->previous = fs->bl; /* link block in function's block list */

fs->bl = bl;

lua_assert(fs->freereg == luaY_nvarstack(fs));

}

static l_noret undefgoto (LexState *ls, Labeldesc *gt) {

/* breaks are checked when created, cannot be undefined */

lua_assert(!eqstr(gt->name, ls->brkn));

luaK_semerror(ls, "no visible label '%s' for <goto> at line %d",

getstr(gt->name), gt->line);

}

static void leaveblock (FuncState *fs) {

BlockCnt *bl = fs->bl;

LexState *ls = fs->ls;

lu_byte stklevel = reglevel(fs, bl->nactvar); /* level outside block */

if (bl->previous && bl->upval) /* need a 'close'? */

luaK_codeABC(fs, OP_CLOSE, stklevel, 0, 0);

fs->freereg = stklevel; /* free registers */

removevars(fs, bl->nactvar); /* remove block locals */

lua_assert(bl->nactvar == fs->nactvar); /* back to level on entry */

if (bl->isloop == 2) /* has to fix pending breaks? */

createlabel(ls, ls->brkn, 0, 0);

solvegotos(fs, bl);

if (bl->previous == NULL) { /* was it the last block? */

if (bl->firstgoto < ls->dyd->gt.n) /* still pending gotos? */

undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */

}

fs->bl = bl->previous; /* current block now is previous one */

}

static Proto *addprototype (LexState *ls) {

Proto *clp;

lua_State *L = ls->L;

FuncState *fs = ls->fs;

Proto *f = fs->f; /* prototype of current function */

if (fs->np >= f->sizep) {

int oldsize = f->sizep;

luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions");

while (oldsize < f->sizep)

f->p[oldsize++] = NULL;

}

f->p[fs->np++] = clp = luaF_newproto(L);

luaC_objbarrier(L, f, clp);

return clp;

}

static void codeclosure (LexState *ls, expdesc *v) {

FuncState *fs = ls->fs->prev;

init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1));

luaK_exp2nextreg(fs, v); /* fix it at the last register */

}

static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {

lua_State *L = ls->L;

Proto *f = fs->f;

fs->prev = ls->fs; /* linked list of funcstates */

fs->ls = ls;

ls->fs = fs;

fs->pc = 0;

fs->previousline = f->linedefined;

fs->iwthabs = 0;

fs->lasttarget = 0;

fs->freereg = 0;

fs->nk = 0;

fs->nabslineinfo = 0;

fs->np = 0;

fs->nups = 0;

fs->ndebugvars = 0;

fs->nactvar = 0;

fs->needclose = 0;

fs->firstlocal = ls->dyd->actvar.n;

fs->firstlabel = ls->dyd->label.n;

fs->bl = NULL;

f->source = ls->source;

luaC_objbarrier(L, f, f->source);

f->maxstacksize = 2; /* registers 0/1 are always valid */

fs->kcache = luaH_new(L); /* create table for function */

sethvalue2s(L, L->top.p, fs->kcache); /* anchor it */

luaD_inctop(L);

enterblock(fs, bl, 0);

}

static void close_func (LexState *ls) {

lua_State *L = ls->L;

FuncState *fs = ls->fs;

Proto *f = fs->f;

luaK_ret(fs, luaY_nvarstack(fs), 0); /* final return */

leaveblock(fs);

lua_assert(fs->bl == NULL);

luaK_finish(fs);

luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction);

luaM_shrinkvector(L, f->lineinfo, f->sizelineinfo, fs->pc, ls_byte);

luaM_shrinkvector(L, f->abslineinfo, f->sizeabslineinfo,

fs->nabslineinfo, AbsLineInfo);

luaM_shrinkvector(L, f->k, f->sizek, fs->nk, TValue);

luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *);

luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->ndebugvars, LocVar);

luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc);

ls->fs = fs->prev;

L->top.p--; /* pop kcache table */

luaC_checkGC(L);

}

static int block_follow (LexState *ls, int withuntil) {

switch (ls->t.token) {

case TK_ELSE: case TK_ELSEIF:

case TK_END: case TK_EOS:

return 1;

case TK_UNTIL: return withuntil;

default: return 0;

}

}

static void statlist (LexState *ls) {

/* statlist -> { stat [';'] } */

while (!block_follow(ls, 1)) {

if (ls->t.token == TK_RETURN) {

statement(ls);

return; /* 'return' must be last statement */

}

statement(ls);

}

}

static void fieldsel (LexState *ls, expdesc *v) {

/* fieldsel -> ['.' | ':'] NAME */

FuncState *fs = ls->fs;

expdesc key;

luaK_exp2anyregup(fs, v);

luaX_next(ls); /* skip the dot or colon */

codename(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, ']');

}

typedef struct ConsControl {

} ConsControl;

#define MAX_CNST (INT_MAX/2)

#if MAX_CNST/(MAXARG_vC + 1) > MAXARG_Ax

#undef MAX_CNST

#define MAX_CNST (MAXARG_Ax * (MAXARG_vC + 1))

static void recfield (LexState *ls, ConsControl *cc) {

/* recfield -> (NAME | '['exp']') = exp */

FuncState *fs = ls->fs;

lu_byte reg = ls->fs->freereg;

expdesc tab, key, val;

if (ls->t.token == TK_NAME)

codename(ls, &key);

else /* ls->t.token == '[' */

yindex(ls, &key);

cc->nh++;

checknext(ls, '=');

tab = *cc->t;

luaK_indexed(fs, &tab, &key);

expr(ls, &val);

luaK_storevar(fs, &tab, &val);

fs->freereg = reg; /* free registers */

}

static void closelistfield (FuncState *fs, ConsControl *cc) {

lua_assert(cc->tostore > 0);

luaK_exp2nextreg(fs, &cc->v);

cc->v.k = VVOID;

if (cc->tostore >= cc->maxtostore) {

luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); /* flush */

cc->na += cc->tostore;

cc->tostore = 0; /* no more items pending */

}

}

static void lastlistfield (FuncState *fs, ConsControl *cc) {

if (cc->tostore == 0) return;

if (hasmultret(cc->v.k)) {

luaK_setmultret(fs, &cc->v);

luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET);

cc->na--; /* do not count last expression (unknown number of elements) */

}

else {

if (cc->v.k != VVOID)

luaK_exp2nextreg(fs, &cc->v);

luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore);

}

cc->na += cc->tostore;

}

static void listfield (LexState *ls, ConsControl *cc) {

/* listfield -> exp */

expr(ls, &cc->v);

cc->tostore++;

}

static void field (LexState *ls, ConsControl *cc) {

/* field -> listfield | recfield */

switch(ls->t.token) {

case TK_NAME: { /* may be 'listfield' or 'recfield' */

if (luaX_lookahead(ls) != '=') /* expression? */

listfield(ls, cc);

else

recfield(ls, cc);

break;

}

case '[': {