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);
#if defined(LUA_COMPAT_VARARG)
/* use `arg' as default name */
new_localvarliteral(ls, "arg", nparams++);
f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
#endif
f->is_vararg |= VARARG_ISVARARG;
break;
}
default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
}
} while (!f->is_vararg && testnext(ls, ','));
}
adjustlocalvars(ls, nparams);
f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */
}
static void localstat (LexState *ls)
{
/* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
int nvars = 0;
int nexps;
expdesc e;
do
{
new_localvar(ls, str_checkname(ls), nvars++);
}
while (testnext(ls, ','));
if (testnext(ls, '='))
{
nexps = explist1(ls, &e);
}
else
{
e.k = VVOID;
nexps = 0;
}
adjust_assign(ls, nvars, nexps, &e);
adjustlocalvars(ls, nvars);
}
static void forlist (LexState *ls, TString *indexname)
{
/* forlist -> NAME {,NAME} IN explist1 forbody */
FuncState *fs = GetCurrentFuncState( ls );
expdesc e;
int nvars = 0;
int base = fs->freereg;
/* create control variables */
new_localvarliteral(ls, "(for generator)", nvars++);
new_localvarliteral(ls, "(for state)", nvars++);
new_localvarliteral(ls, "(for control)", nvars++);
/* create declared variables */
new_localvar(ls, indexname, nvars++);
while (testnext(ls, ','))
{
new_localvar(ls, str_checkname(ls), nvars++);
}
checknext(ls, TK_IN);
int line = ls->linenumber;
adjust_assign(ls, 3, explist1(ls, &e), &e);
luaK_checkstack(fs, 3); /* extra space to call generator */
forbody(ls, base, line, nvars - 3, 0);
}
static void forstat (LexState *ls, int line)
{
/* forstat -> FOR (fornum | forlist) END */
FuncState *fs = GetCurrentFuncState( ls );
TString *varname;
BlockCnt bl;
enterblock(fs, &bl, 1); /* scope for loop and control variables */
luaX_next(ls); /* skip `for' */
varname = str_checkname(ls); /* first variable name */
switch (ls->t.token)
{
case '=':
fornum(ls, varname, line);
break;
case ',': case TK_IN:
forlist(ls, varname);
break;
default:
luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected");
break;
}
check_match(ls, TK_END, TK_FOR, line);
leaveblock(fs); /* loop scope (`break' jumps to this point) */
}
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 localfunc (LexState *ls) {
expdesc v, b;
new_localvar(ls, str_checkname(ls), 0);
init_exp(&v, VLOCAL, ls->fs->freereg++);
adjustlocalvars(ls, 1);
body(ls, &b, 0, ls->linenumber);
luaK_storevar(ls->fs, &v, &b);
}
static void singlevar (LexState *ls, expdesc *var) {
TString *varname = str_checkname(ls);
FuncState *fs = ls->fs;
if (singlevaraux(fs, varname, var) == VVOID) { /* global name? */
expdesc key;
singlevaraux(fs, ls->envn, var); /* get environment variable */
lua_assert(var->k == VLOCAL || var->k == VUPVAL);
codestring(ls, &key, varname); /* key is variable name */
luaK_indexed(fs, var, &key); /* env[varname] */
}
}
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 */
#ifdef LUA_UTILITIES_NET
GetGlobal(varname, ls);
#endif
}
}
/*static*/ void LexState::singlevar (/*LexState *ls,*/ expdesc *var) {
TString *varname = str_checkname();
//FuncState *fs = fs;
if (fs->singlevaraux(varname, var, 1) == VVOID) { /* global name? */
expdesc key;
fs->singlevaraux(envn, var, 1); /* get environment variable */
lua_assert(var->k == VLOCAL || var->k == VUPVAL);
codestring(&key, varname); /* key is variable name */
fs->luaK_indexed(var, &key); /* env[varname] */
}
}
static void localfunc (LexState *ls) {
expdesc v, b;
FuncState *fs = ls->fs;
new_localvar(ls, str_checkname(ls), 0);
init_exp(&v, VLOCAL, fs->freereg);
luaK_reserveregs(fs, 1);
adjustlocalvars(ls, 1);
body(ls, &b, 0, ls->linenumber);
luaK_storevar(fs, &v, &b);
/* debug information will only see the variable after this point! */
getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
}
static void singlevar(ktap_lexstate *ls, ktap_expdesc *var)
{
ktap_string *varname = str_checkname(ls);
ktap_funcstate *fs = ls->fs;
if (singlevaraux(fs, varname, var, 1) == VVOID) { /* global name? */
ktap_expdesc key;
singlevaraux(fs, ls->envn, var, 1); /* get environment variable */
ktap_assert(var->k == VLOCAL || var->k == VUPVAL);
codestring(ls, &key, varname); /* key is variable name */
codegen_indexed(fs, var, &key); /* env[varname] */
}
}
static void parlist (LexState *ls) {
/* parlist -> [ param { `,' param } ] */
int nparams = 0;
int dots = 0;
if (ls->t.token != ')') { /* is `parlist' not empty? */
do {
switch (ls->t.token) {
case TK_DOTS: dots = 1; next(ls); break;
case TK_NAME: new_localvar(ls, str_checkname(ls), nparams++); break;
default: luaX_syntaxerror(ls, "<name> or `...' expected");
}
} while (!dots && testnext(ls, ','));
}
code_params(ls, nparams, dots);
}
static void forstat (LexState *ls, int line) {
/* forstat -> fornum | forlist */
FuncState *fs = ls->fs;
TString *varname;
BlockCnt bl;
enterblock(fs, &bl, 0); /* block to control variable scope */
next(ls); /* skip `for' */
varname = str_checkname(ls); /* first variable name */
switch (ls->t.token) {
case '=': fornum(ls, varname, line); break;
case ',': case TK_IN: forlist(ls, varname); break;
default: luaX_syntaxerror(ls, "`=' or `in' expected");
}
check_match(ls, TK_END, TK_FOR, line);
leaveblock(fs);
}
static void localstat (LexState *ls) {
/* stat -> LOCAL NAME {`,' NAME} [ IN primaryexp | `=' explist1] */
int nvars = 0;
int nexps;
expdesc e;
do {
new_localvar(ls, str_checkname(ls), nvars++);
} while (testnext(ls, ','));
if (testnext(ls, TK_IN)) {
lu_byte from_var;
int regs = ls->fs->freereg;
int vars = ls->fs->nactvar;
luaK_reserveregs(ls->fs, nvars);
adjustlocalvars(ls, nvars);
new_localvarliteral(ls, "(from)", 0);
primaryexp(ls, &e);
luaK_exp2nextreg(ls->fs, &e);
from_var = ls->fs->nactvar;
adjustlocalvars(ls, 1);
luaK_setoneret(ls->fs, &e); /* close last expression */
for (nexps=0; nexps<nvars; nexps++) {
expdesc v, key;
init_exp(&e, VNONRELOC, ls->fs->freereg-1);
codestring(ls, &key, getlocvar(ls->fs, vars+nexps).varname);
luaK_indexed(ls->fs, &e, &key);
init_exp(&v, VLOCAL, regs+nexps);
luaK_storevar(ls->fs, &v, &e);
}
removevars(ls, from_var);
return;
}
if (testnext(ls, '='))
nexps = explist1(ls, &e);
else {
e.k = VVOID;
nexps = 0;
}
adjust_assign(ls, nvars, nexps, &e);
adjustlocalvars(ls, nvars);
}
static void forlist (LexState *ls, TString *indexname) {
/* forlist -> NAME {,NAME} IN explist1 DO body */
FuncState *fs = ls->fs;
expdesc e;
int nvars = 0;
int line;
int base = fs->freereg;
new_localvarstr(ls, "(for generator)", nvars++);
new_localvarstr(ls, "(for state)", nvars++);
new_localvar(ls, indexname, nvars++);
while (testnext(ls, ','))
new_localvar(ls, str_checkname(ls), nvars++);
check(ls, TK_IN);
line = ls->linenumber;
adjust_assign(ls, nvars, explist1(ls, &e), &e);
luaK_checkstack(fs, 3); /* extra space to call generator */
luaK_codeAsBx(fs, OP_TFORPREP, base, NO_JUMP);
forbody(ls, base, line, nvars, 0);
}
static void checkname (LexState *ls, expdesc *e) {
codestring(ls, e, str_checkname(ls));
}
static TString *singlevar (LexState *ls, expdesc *var, int base) {
TString *varname = str_checkname(ls);
singlevaraux(ls->fs, varname, var, base);
return varname;
}
static void checkname(ktap_lexstate *ls, ktap_expdesc *e)
{
codestring(ls, e, str_checkname(ls));
}
static void trystat (LexState *ls, int line) {
/* trystat -> TRY block CATCH err DO block END */
FuncState *fs = ls->fs;
BlockCnt bl;
int base, pc, escapelist = NO_JUMP;
luaX_next(ls);
enterblock(fs, &bl, 2); /* try block */
base = fs->freereg;
new_localvarliteral(ls, "(error obj)", 0);
adjustlocalvars(ls, 1); /* error object */
luaK_reserveregs(fs, 1);
pc = luaK_codeAsBx(fs, OP_TRY, base, NO_JUMP);
chunk(ls);
if (ls->t.token == TK_CATCH) {
TString *varname;
int errobj;
luaK_codeABC(fs, OP_EXITTRY, 0, 0, 0);
luaK_concat(fs, &escapelist, luaK_jump(fs));
SET_OPCODE(fs->f->code[pc], OP_TRYCATCH); /* change it to TRYCATCH */
luaK_patchtohere(fs, pc);
bl.isbreakable = 0;
// local err
luaX_next(ls); /* skip `catch' */
varname = str_checkname(ls); /* first variable name */
// do
checknext(ls, TK_DO);
errobj = fs->freereg;
new_localvar(ls, varname, 0);
adjustlocalvars(ls, 1);
luaK_reserveregs(fs, 1);
luaK_codeABC(fs, OP_MOVE, errobj, base, 0);
block(ls);
} else if (ls->t.token == TK_FINALLY) {
luaK_codeABC(fs, OP_EXITTRY, 0, 0, 0);
luaK_concat(fs, &escapelist, luaK_jump(fs));
SET_OPCODE(fs->f->code[pc], OP_TRYFIN); /* change it to TRYFIN */
luaK_patchtohere(fs, pc);
bl.isbreakable = 3;
luaX_next(ls); /* skip 'finally' */
block(ls);
luaK_codeABC(fs, OP_RETFIN, base, 0, 0); /* OP_ENDFIN jump to the return point */
} else {
luaK_codeABC(fs, OP_EXITTRY, 0, 0, 0);
luaK_concat(fs, &escapelist, pc);
}
leaveblock(fs);
luaK_patchtohere(fs, escapelist);
check_match(ls, TK_END, TK_TRY, line);
}
static void constructor (LexState *ls, expdesc *t) {
/* constructor -> ?? */
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 (for gc) */
checknext(ls, '{');
#if LUA_OPTIONAL_COMMA
for (;;) {
#else
do {
#endif /* LUA_OPTIONAL_COMMA */
lua_assert(cc.v.k == VVOID || cc.tostore > 0);
if (ls->t.token == '}') break;
closelistfield(fs, &cc);
switch(ls->t.token) {
case TK_NAME: { /* may be listfields or recfields */
luaX_lookahead(ls);
if (ls->lookahead.token != '=') /* expression? */
listfield(ls, &cc);
else
recfield(ls, &cc);
break;
}
case '[': { /* constructor_item -> recfield */
recfield(ls, &cc);
break;
}
default: { /* constructor_part -> listfield */
listfield(ls, &cc);
break;
}
}
#if LUA_OPTIONAL_COMMA
if (ls->t.token == ',' || ls->t.token == ';')
next(ls);
else if (ls->t.token == '}')
break;
}
#else
} while (testnext(ls, ',') || testnext(ls, ';'));
#endif /* LUA_OPTIONAL_COMMA */
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);
#if defined(LUA_COMPAT_VARARG)
/* use `arg' as default name */
new_localvarliteral(ls, "arg", nparams++);
f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
#endif
f->is_vararg |= VARARG_ISVARARG;
break;
}
default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
}
} while (!f->is_vararg && testnext(ls, ','));
}
adjustlocalvars(ls, nparams);
f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */
}
static void ICACHE_FLASH_ATTR checkname(LexState *ls, expdesc *e) {
codestring(ls, e, str_checkname(ls));
}
/*static*/ void LexState::checkname (/*LexState *ls,*/ expdesc *e) {
codestring(e, str_checkname());
}