#define lparser_c

#define LUA_CORE

#include "lprefix.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 semerror (LexState *ls, const char *msg) {

ls->t.token = 0; /* remove "near <token>" from final message */

luaX_syntaxerror(ls, msg);

}

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);

}

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

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

if (where == ls->linenumber)

error_expected(ls, what);

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 (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, "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++;

}

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

FuncState *fs = ls->fs;

Dyndata *dyd = ls->dyd;

int reg = registerlocalvar(ls, name);

checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal,

MAXVARS, "local variables");

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

dyd->actvar.size, Vardesc, MAX_INT, "local variables");

dyd->actvar.arr[dyd->actvar.n++].idx = cast(short, reg);

}

static void new_localvarliteral_ (LexState *ls, const char *name, size_t sz) {

new_localvar(ls, luaX_newstring(ls, name, sz));

}

#define new_localvarliteral(ls,v) \

new_localvarliteral_(ls, "" v, (sizeof(v)/sizeof(char))-1)

static LocVar *getlocvar (FuncState *fs, int i) {

int idx = fs->ls->dyd->actvar.arr[fs->firstlocal + i].idx;

lua_assert(idx < fs->nlocvars);

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

}

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 (FuncState *fs, int tolevel) {

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

while (fs->nactvar > tolevel)

getlocvar(fs, --fs->nactvar)->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 int newupvalue (FuncState *fs, TString *name, expdesc *v) {

Proto *f = fs->f;

int oldsize = f->sizeupvalues;

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;

f->upvalues[fs->nups].instack = (v->k == VLOCAL);

f->upvalues[fs->nups].idx = cast_byte(v->u.info);

f->upvalues[fs->nups].name = name;

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

return fs->nups++;

}

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

int i;

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

if (eqstr(n, getlocvar(fs, i)->varname))

return i;

}

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;

}

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

if (fs == NULL) /* no more levels? */

init_exp(var, VVOID, 0); /* default is global */

else {

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

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

init_exp(var, VLOCAL, v); /* variable is local */

if (!base)

markupval(fs, v); /* local will be used as an upval */

}

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

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

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

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

if (var->k == VVOID) /* not found? */

return; /* it is a global */

/* else was LOCAL or UPVAL */

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

}

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

}

}

}

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

TString *varname = str_checkname(ls);

FuncState *fs = ls->fs;

singlevaraux(fs, varname, var, 1);

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

expdesc key;

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

lua_assert(var->k != VVOID); /* this one must exist */

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

luaK_indexed(fs, var, &key); /* env[varname] */

}

}

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);

}

}

if (nexps > nvars)

ls->fs->freereg -= nexps - nvars; /* remove extra values */

}

static void enterlevel (LexState *ls) {

lua_State *L = ls->L;

++L->nCcalls;

checklimit(ls->fs, L->nCcalls, LUAI_MAXCCALLS, "C levels");

}

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

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

int i;

FuncState *fs = ls->fs;

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

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

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

if (gt->nactvar < label->nactvar) {

TString *vname = getlocvar(fs, gt->nactvar)->varname;

const char *msg = luaO_pushfstring(ls->L,

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

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

semerror(ls, msg);

}

luaK_patchlist(fs, gt->pc, label->pc);

/* remove goto from pending list */

for (i = g; i < gl->n - 1; i++)

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

gl->n--;

}

static int findlabel (LexState *ls, int g) {

int i;

BlockCnt *bl = ls->fs->bl;

Dyndata *dyd = ls->dyd;

Labeldesc *gt = &dyd->gt.arr[g];

/* check labels in current block for a match */

for (i = bl->firstlabel; i < dyd->label.n; i++) {

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

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

if (gt->nactvar > lb->nactvar &&

(bl->upval || dyd->label.n > bl->firstlabel))

luaK_patchclose(ls->fs, gt->pc, lb->nactvar);

closegoto(ls, g, lb); /* close it */

return 1;

}

}

return 0; /* label not found; cannot close goto */

}

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].pc = pc;

l->n = n + 1;

return n;

}

static void findgotos (LexState *ls, Labeldesc *lb) {

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

int i = ls->fs->bl->firstgoto;

while (i < gl->n) {

if (eqstr(gl->arr[i].name, lb->name))

closegoto(ls, i, lb);

else

i++;

}

}

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

int i = bl->firstgoto;

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

/* correct pending gotos to current block and try to close it

while (i < gl->n) {

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

if (gt->nactvar > bl->nactvar) {

if (bl->upval)

luaK_patchclose(fs, gt->pc, bl->nactvar);

gt->nactvar = bl->nactvar;

}

if (!findlabel(fs->ls, i))

i++; /* move to next one */

}

}

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;

bl->previous = fs->bl;

fs->bl = bl;

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

}

static void breaklabel (LexState *ls) {

TString *n = luaS_new(ls->L, "break");

int l = newlabelentry(ls, &ls->dyd->label, n, 0, ls->fs->pc);

findgotos(ls, &ls->dyd->label.arr[l]);

}

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

const char *msg = isreserved(gt->name)

? "<%s> at line %d not inside a loop"

: "no visible label '%s' for <goto> at line %d";

msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);

semerror(ls, msg);

}

static void leaveblock (FuncState *fs) {

BlockCnt *bl = fs->bl;

LexState *ls = fs->ls;

if (bl->previous && bl->upval) {

/* create a 'jump to here' to close upvalues */

int j = luaK_jump(fs);

luaK_patchclose(fs, j, bl->nactvar);

luaK_patchtohere(fs, j);

}

if (bl->isloop)

breaklabel(ls); /* close pending breaks */

fs->bl = bl->previous;

removevars(fs, bl->nactvar);

lua_assert(bl->nactvar == fs->nactvar);

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

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

if (bl->previous) /* inner block? */

movegotosout(fs, bl); /* update pending gotos to outer block */

else if (bl->firstgoto < ls->dyd->gt.n) /* pending gotos in outer block? */

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

}

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, VRELOCABLE, 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) {

Proto *f;

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

fs->ls = ls;

ls->fs = fs;

fs->pc = 0;

fs->lasttarget = 0;

fs->jpc = NO_JUMP;

fs->freereg = 0;

fs->nk = 0;

fs->np = 0;

fs->nups = 0;

fs->nlocvars = 0;

fs->nactvar = 0;

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

fs->bl = NULL;

f = fs->f;

f->source = ls->source;

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

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

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, 0, 0); /* final return */

leaveblock(fs);

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, fs->nups, Upvaldesc);

f->sizeupvalues = fs->nups;

lua_assert(fs->bl == NULL);

ls->fs = fs->prev;

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 */

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

}

struct ConsControl {

};

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

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

FuncState *fs = ls->fs;

int reg = ls->fs->freereg;

expdesc key, val;

int rkkey;

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

checklimit(fs, cc->nh, MAX_INT, "items in a constructor");

checkname(ls, &key);

}

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

yindex(ls, &key);

cc->nh++;

checknext(ls, '=');

rkkey = luaK_exp2RK(fs, &key);

expr(ls, &val);

luaK_codeABC(fs, OP_SETTABLE, cc->t->u.info, rkkey, luaK_exp2RK(fs, &val));

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

}

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

if (cc->v.k == VVOID) return; /* there is no list item */

luaK_exp2nextreg(fs, &cc->v);

cc->v.k = VVOID;

if (cc->tostore == LFIELDS_PER_FLUSH) {

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

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

}

}

static void lastlistfield (FuncState *fs, struct 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);

}

}

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

/* listfield -> exp */

expr(ls, &cc->v);

checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");

cc->na++;

cc->tostore++;

}

static void field (LexState *ls, struct 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 '[': {

recfield(ls, cc);

break;

}

default: {

listfield(ls, cc);

break;

}

}

}

static void constructor (LexState *ls, expdesc *t) {

/* constructor -> '{' [ field { sep field } [sep] ] '}'

FuncState *fs = ls->fs;

int line = ls->linenumber;

int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);

struct ConsControl cc;

cc.na = cc.nh = cc.tostore = 0;

cc.t = t;

init_exp(t, VRELOCABLE, pc);

init_exp(&cc.v, VVOID, 0); /* no value (yet) */

luaK_exp2nextreg(ls->fs, t); /* fix it at stack top */

checknext(ls, '{');

do {

lua_assert(cc.v.k == VVOID || cc.tostore > 0);

if (ls->t.token == '}') break;

closelistfield(fs, &cc);

field(ls, &cc);

} while (testnext(ls, ',') || testnext(ls, ';'));

check_match(ls, '}', '{', line);

lastlistfield(fs, &cc);

SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */

SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh)); /* set initial table size */

}

static void parlist (LexState *ls) {

/* parlist -> [ param { ',' param } ] */

FuncState *fs = ls->fs;

Proto *f = fs->f;

int nparams = 0;

f->is_vararg = 0;

if (ls->t.token != ')') { /* is 'parlist' not empty? */

do {

switch (ls->t.token) {

case TK_NAME: { /* param -> NAME */

new_localvar(ls, str_checkname(ls));

nparams++;

break;

}

case TK_DOTS: { /* param -> '...' */

luaX_next(ls);

f->is_vararg = 1; /* declared vararg */

break;

}

default: luaX_syntaxerror(ls, "<name> or '...' expected");

}

} while (!f->is_vararg && testnext(ls, ','));

}

adjustlocalvars(ls, nparams);

f->numparams = cast_byte(fs->nactvar);

luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */

}

static void body (LexState *ls, expdesc *e, int ismethod, int line) {

/* body -> '(' parlist ')' block END */

FuncState new_fs;

BlockCnt bl;

new_fs.f = addprototype(ls);

new_fs.f->linedefined = line;

open_func(ls, &new_fs, &bl);

checknext(ls, '(');

if (ismethod) {

new_localvarliteral(ls, "self"); /* create 'self' parameter */

adjustlocalvars(ls, 1);

}

parlist(ls);

checknext(ls, ')');

statlist(ls);

new_fs.f->lastlinedefined = ls->linenumber;

check_match(ls, TK_END, TK_FUNCTION, line);

codeclosure(ls, e);

close_func(ls);

}

static int explist (LexState *ls, expdesc *v) {

/* explist -> expr { ',' expr } */

int n = 1; /* at least one expression */

expr(ls, v);

while (testnext(ls, ',')) {

luaK_exp2nextreg(ls->fs, v);

expr(ls, v);

n++;

}

return n;

}

static void funcargs (LexState *ls, expdesc *f, int line) {

FuncState *fs = ls->fs;

expdesc args;

int base, nparams;

switch (ls->t.token) {

case '(': { /* funcargs -> '(' [ explist ] ')' */

luaX_next(ls);

if (ls->t.token == ')') /* arg list is empty? */

args.k = VVOID;

else {

explist(ls, &args);

luaK_setmultret(fs, &args);

}

check_match(ls, ')', '(', line);

break;

}

case '{': { /* funcargs -> constructor */

constructor(ls, &args);

break;

}

case TK_STRING: { /* funcargs -> STRING */

codestring(ls, &args, ls->t.seminfo.ts);

luaX_next(ls); /* must use 'seminfo' before 'next' */

break;

}

default: {

luaX_syntaxerror(ls, "function arguments expected");

}

}

lua_assert(f->k == VNONRELOC);

base = f->u.info; /* base register for call */

if (hasmultret(args.k))

nparams = LUA_MULTRET; /* open call */

else {

if (args.k != VVOID)

luaK_exp2nextreg(fs, &args); /* close last argument */

nparams = fs->freereg - (base+1);

}

init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));

luaK_fixline(fs, line);

fs->freereg = base+1; /* call remove function and arguments and leaves

}

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

/* primaryexp -> NAME | '(' expr ')' */

switch (ls->t.token) {

case '(': {

int line = ls->linenumber;

luaX_next(ls);

expr(ls, v);

check_match(ls, ')', '(', line);

luaK_dischargevars(ls->fs, v);

return;

}

case TK_NAME: {

singlevar(ls, v);

return;

}

default: {

luaX_syntaxerror(ls, "unexpected symbol");

}

}

}

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

/* suffixedexp ->

FuncState *fs = ls->fs;

int line = ls->linenumber;

primaryexp(ls, v);

for (;;) {

switch (ls->t.token) {

case '.': { /* fieldsel */

fieldsel(ls, v);

break;

}

case '[': { /* '[' exp1 ']' */

expdesc key;

luaK_exp2anyregup(fs, v);

yindex(ls, &key);

luaK_indexed(fs, v, &key);

break;

}

case ':': { /* ':' NAME funcargs */

expdesc key;

luaX_next(ls);

checkname(ls, &key);

luaK_self(fs, v, &key);

funcargs(ls, v, line);

break;

}

case '(': case TK_STRING: case '{': { /* funcargs */

luaK_exp2nextreg(fs, v);

funcargs(ls, v, line);

break;

}

default: return;

}

}

}

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

/* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... |

switch (ls->t.token) {

case TK_FLT: {

init_exp(v, VKFLT, 0);

v->u.nval = ls->t.seminfo.r;

break;

}

case TK_INT: {

init_exp(v, VKINT, 0);

v->u.ival = ls->t.seminfo.i;

break;

}

case TK_STRING: {

codestring(ls, v, ls->t.seminfo.ts);

break;

}

case TK_NIL: {

init_exp(v, VNIL, 0);

break;

}

case TK_TRUE: {

init_exp(v, VTRUE, 0);

break;

}

case TK_FALSE: {

init_exp(v, VFALSE, 0);

break;

}

case TK_DOTS: { /* vararg */

FuncState *fs = ls->fs;

check_condition(ls, fs->f->is_vararg,

"cannot use '...' outside a vararg function");

init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));

break;

}

case '{': { /* constructor */

constructor(ls, v);

return;

}

case TK_FUNCTION: {

luaX_next(ls);

body(ls, v, 0, ls->linenumber);

return;

}

default: {

suffixedexp(ls, v);

return;

}

}

luaX_next(ls);

}

static UnOpr getunopr (int op) {

switch (op) {

case TK_NOT: return OPR_NOT;

case '-': return OPR_MINUS;

case '~': return OPR_BNOT;

case '#': return OPR_LEN;

default: return OPR_NOUNOPR;

}

}

static BinOpr getbinopr (int op) {

switch (op) {

case '+': return OPR_ADD;