mirrors/lua
1
0
Fork 0
mirror of https://github.com/lua/lua synced 2025-04-04 03:52:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

vararg back to '...' (but with another implementation)

Browse Source 
new implementation should have zero overhead for non-vararg functions
This commit is contained in:
Roberto Ierusalimschy 2018-02-09 13:16:06 -02:00
parent 4e0de3a43c
commit b1379936cf
11 changed files with 136 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
lcode.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lcode.c,v 2.151 2018/01/27 16:56:33 roberto Exp roberto $ ** $Id: lcode.c,v 2.152 2018/01/28 15:13:26 roberto Exp roberto $
** Code generator for Lua ** Code generator for Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -31,7 +31,7 @@
/* Maximum number of registers in a Lua function (must fit in 8 bits) */ /* Maximum number of registers in a Lua function (must fit in 8 bits) */
#define MAXREGS 255 #define MAXREGS 254
#define hasjumps(e) ((e)->t != (e)->f) #define hasjumps(e) ((e)->t != (e)->f)
@ -157,17 +157,17 @@ int luaK_jump (FuncState *fs) {
** Code a 'return' instruction ** Code a 'return' instruction
*/ */
void luaK_ret (FuncState *fs, int first, int nret) { void luaK_ret (FuncState *fs, int first, int nret) {
switch (nret) { OpCode op;
case 0: if (fs->f->is_vararg)
luaK_codeABC(fs, OP_RETURN0, 0, 0, 0); op = OP_RETVARARG;
break; else {
case 1: switch (nret) {
luaK_codeABC(fs, OP_RETURN1, first, 0, 0); case 0: op = OP_RETURN0; break;
break; case 1: op = OP_RETURN1; break;
default: default: op = OP_RETURN; break;
luaK_codeABC(fs, OP_RETURN, first, nret + 1, 0); }
break;
} }
luaK_codeABC(fs, op, first, nret + 1, fs->f->numparams);
} }
@ -1647,7 +1647,7 @@ void luaK_finish (FuncState *fs) {
lua_assert(i == 0 || isOT(*(pc - 1)) == isIT(*pc)); lua_assert(i == 0 || isOT(*(pc - 1)) == isIT(*pc));
switch (GET_OPCODE(*pc)) { switch (GET_OPCODE(*pc)) {
case OP_RETURN: case OP_RETURN0: case OP_RETURN1: case OP_RETURN: case OP_RETURN0: case OP_RETURN1:
case OP_TAILCALL: { case OP_RETVARARG: case OP_TAILCALL: {
if (p->sizep > 0) if (p->sizep > 0)
SETARG_k(*pc, 1); /* signal that they must close upvalues */ SETARG_k(*pc, 1); /* signal that they must close upvalues */
break; break;

26
ldebug.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: ldebug.c,v 2.152 2018/01/10 12:02:35 roberto Exp roberto $ ** $Id: ldebug.c,v 2.153 2018/02/06 19:16:56 roberto Exp roberto $
** Debug Interface ** Debug Interface
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -187,12 +187,28 @@ static const char *upvalname (Proto *p, int uv) {
} }
static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
if (clLvalue(s2v(ci->func))->p->is_vararg) {
int nextra = ci->u.l.nextraargs;
if (n <= nextra) {
*pos = ci->func - nextra + (n - 1);
return "(*vararg)"; /* generic name for any vararg */
}
}
return NULL; /* no such vararg */
}
static const char *findlocal (lua_State *L, CallInfo *ci, int n, static const char *findlocal (lua_State *L, CallInfo *ci, int n,
StkId *pos) { StkId *pos) {
StkId base = ci->func + 1; StkId base = ci->func + 1;
const char *name = (isLua(ci)) const char *name = NULL;
? luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci)) if (isLua(ci)) {
: NULL; if (n < 0) /* access to vararg values? */
return findvararg(ci, -n, pos);
else
name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
}
if (name == NULL) { /* no 'standard' name? */ if (name == NULL) { /* no 'standard' name? */
StkId limit = (ci == L->ci) ? L->top : ci->next->func; StkId limit = (ci == L->ci) ? L->top : ci->next->func;
if (limit - base >= n && n > 0) /* is 'n' inside 'ci' stack? */ if (limit - base >= n && n > 0) /* is 'n' inside 'ci' stack? */
@ -324,7 +340,7 @@ static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
} }
else { else {
ar->isvararg = f->l.p->is_vararg; ar->isvararg = f->l.p->is_vararg;
ar->nparams = f->l.p->numparams + f->l.p->is_vararg; ar->nparams = f->l.p->numparams;
} }
break; break;
} }

37
ldo.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: ldo.c,v 2.191 2018/02/07 15:18:04 roberto Exp roberto $ ** $Id: ldo.c,v 2.192 2018/02/07 15:55:18 roberto Exp roberto $
** Stack and Call structure of Lua ** Stack and Call structure of Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -310,7 +310,7 @@ void luaD_hookcall (lua_State *L, CallInfo *ci) {
} }
static void rethook (lua_State *L, CallInfo *ci) { void luaD_rethook (lua_State *L, CallInfo *ci) {
if (isLuacode(ci)) if (isLuacode(ci))
L->top = ci->top; /* prepare top */ L->top = ci->top; /* prepare top */
if (L->hookmask & LUA_MASKRET) /* is return hook on? */ if (L->hookmask & LUA_MASKRET) /* is return hook on? */
@ -343,8 +343,8 @@ void luaD_tryfuncTM (lua_State *L, StkId func) {
** expressions, multiple results for tail calls/single parameters) ** expressions, multiple results for tail calls/single parameters)
** separated. ** separated.
*/ */
static void moveresults (lua_State *L, StkId firstResult, StkId res, void luaD_moveresults (lua_State *L, StkId firstResult, StkId res,
int nres, int wanted) { int nres, int wanted) {
switch (wanted) { /* handle typical cases separately */ switch (wanted) { /* handle typical cases separately */
case 0: break; /* nothing to move */ case 0: break; /* nothing to move */
case 1: { /* one result needed */ case 1: { /* one result needed */
@ -382,27 +382,22 @@ static void moveresults (lua_State *L, StkId firstResult, StkId res,
/* /*
** Finishes a function call: calls hook if necessary, removes CallInfo, ** Finishes a function call: calls hook if necessary, removes CallInfo,
** moves current number of results to proper place; returns 0 iff call ** moves current number of results to proper place.
** wanted multiple (variable number of) results.
*/ */
void luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, int nres) { void luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, int nres) {
if (L->hookmask) { if (L->hookmask) {
ptrdiff_t fr = savestack(L, firstResult); /* hook may change stack */ ptrdiff_t fr = savestack(L, firstResult); /* hook may change stack */
rethook(L, ci); luaD_rethook(L, ci);
firstResult = restorestack(L, fr); firstResult = restorestack(L, fr);
} }
L->ci = ci->previous; /* back to caller */ L->ci = ci->previous; /* back to caller */
/* move results to proper place */ /* move results to proper place */
moveresults(L, firstResult, ci->func, nres, ci->nresults); luaD_moveresults(L, firstResult, ci->func, nres, ci->nresults);
} }
#define next_ci(L) (L->ci->next ? L->ci->next : luaE_extendCI(L)) #define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L)))
#define checkstackGC(L,fsize) \
luaD_checkstackaux(L, (fsize), (void)0, luaC_checkGC(L))
/* /*
@ -438,8 +433,6 @@ void luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func, int narg1) {
void luaD_call (lua_State *L, StkId func, int nresults) { void luaD_call (lua_State *L, StkId func, int nresults) {
lua_CFunction f; lua_CFunction f;
TValue *funcv = s2v(func); TValue *funcv = s2v(func);
CallInfo *ci = next_ci(L);
ci->nresults = nresults;
switch (ttype(funcv)) { switch (ttype(funcv)) {
case LUA_TCCL: /* C closure */ case LUA_TCCL: /* C closure */
f = clCvalue(funcv)->f; f = clCvalue(funcv)->f;
@ -448,12 +441,14 @@ void luaD_call (lua_State *L, StkId func, int nresults) {
f = fvalue(funcv); f = fvalue(funcv);
Cfunc: { Cfunc: {
int n; /* number of returns */ int n; /* number of returns */
CallInfo *ci;
checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */ checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */
ci = next_ci(L);
ci->nresults = nresults;
ci->callstatus = CIST_C; ci->callstatus = CIST_C;
ci->top = L->top + LUA_MINSTACK; ci->top = L->top + LUA_MINSTACK;
ci->func = func; ci->func = func;
lua_assert(ci->top <= L->stack_last); lua_assert(ci->top <= L->stack_last);
L->ci = ci; /* now 'enter' new function */
if (L->hookmask & LUA_MASKCALL) if (L->hookmask & LUA_MASKCALL)
luaD_hook(L, LUA_HOOKCALL, -1); luaD_hook(L, LUA_HOOKCALL, -1);
lua_unlock(L); lua_unlock(L);
@ -464,18 +459,20 @@ void luaD_call (lua_State *L, StkId func, int nresults) {
break; break;
} }
case LUA_TLCL: { /* Lua function */ case LUA_TLCL: { /* Lua function */
CallInfo *ci;
Proto *p = clLvalue(funcv)->p; Proto *p = clLvalue(funcv)->p;
int narg = cast_int(L->top - func) - 1; /* number of real arguments */ int narg = cast_int(L->top - func) - 1; /* number of real arguments */
int nfixparams = p->numparams; int nfixparams = p->numparams;
int fsize = p->maxstacksize; /* frame size */ int fsize = p->maxstacksize; /* frame size */
ci->u.l.savedpc = p->code; /* starting point */
checkstackp(L, fsize, func); checkstackp(L, fsize, func);
for (; narg < nfixparams; narg++) ci = next_ci(L);
setnilvalue(s2v(L->top++)); /* complete missing arguments */ ci->nresults = nresults;
ci->u.l.savedpc = p->code; /* starting point */
ci->callstatus = 0; ci->callstatus = 0;
ci->top = func + 1 + fsize; ci->top = func + 1 + fsize;
ci->func = func; ci->func = func;
L->ci = ci; /* now 'enter' new function */ for (; narg < nfixparams; narg++)
setnilvalue(s2v(L->top++)); /* complete missing arguments */
lua_assert(ci->top <= L->stack_last); lua_assert(ci->top <= L->stack_last);
luaV_execute(L, ci); /* run the function */ luaV_execute(L, ci); /* run the function */
break; break;

10
ldo.h
View File

@ -1,5 +1,5 @@
/* /*
** $Id: ldo.h,v 2.39 2018/01/10 19:19:27 roberto Exp roberto $ ** $Id: ldo.h,v 2.40 2018/02/06 19:16:56 roberto Exp roberto $
** Stack and Call structure of Lua ** Stack and Call structure of Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -42,6 +42,11 @@
p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ p = restorestack(L, t__)) /* 'pos' part: restore 'p' */
/* macro to check stack size and GC */
#define checkstackGC(L,fsize) \
luaD_checkstackaux(L, (fsize), (void)0, luaC_checkGC(L))
/* type of protected functions, to be ran by 'runprotected' */ /* type of protected functions, to be ran by 'runprotected' */
typedef void (*Pfunc) (lua_State *L, void *ud); typedef void (*Pfunc) (lua_State *L, void *ud);
@ -57,7 +62,10 @@ LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
ptrdiff_t oldtop, ptrdiff_t ef); ptrdiff_t oldtop, ptrdiff_t ef);
LUAI_FUNC void luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, LUAI_FUNC void luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult,
int nres); int nres);
LUAI_FUNC void luaD_rethook (lua_State *L, CallInfo *ci);
LUAI_FUNC int luaD_reallocstack (lua_State *L, int newsize, int raiseerror); LUAI_FUNC int luaD_reallocstack (lua_State *L, int newsize, int raiseerror);
LUAI_FUNC void luaD_moveresults (lua_State *L, StkId firstResult, StkId res,
int nres, int wanted);
LUAI_FUNC int luaD_growstack (lua_State *L, int n, int raiseerror); LUAI_FUNC int luaD_growstack (lua_State *L, int n, int raiseerror);
LUAI_FUNC void luaD_shrinkstack (lua_State *L); LUAI_FUNC void luaD_shrinkstack (lua_State *L);
LUAI_FUNC void luaD_inctop (lua_State *L); LUAI_FUNC void luaD_inctop (lua_State *L);

4
lopcodes.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lopcodes.c,v 1.75 2017/12/22 14:16:46 roberto Exp roberto $ ** $Id: lopcodes.c,v 1.76 2018/02/07 15:18:04 roberto Exp roberto $
** Opcodes for Lua virtual machine ** Opcodes for Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -80,6 +80,7 @@ LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
"CALL", "CALL",
"TAILCALL", "TAILCALL",
"RETURN", "RETURN",
"RETVARARG",
"RETURN0", "RETURN0",
"RETURN1", "RETURN1",
"FORLOOP1", "FORLOOP1",
@ -161,6 +162,7 @@ LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
,opmode(1, 1, 0, 1, iABC) /* OP_CALL */ ,opmode(1, 1, 0, 1, iABC) /* OP_CALL */
,opmode(1, 1, 0, 1, iABC) /* OP_TAILCALL */ ,opmode(1, 1, 0, 1, iABC) /* OP_TAILCALL */
,opmode(0, 1, 0, 0, iABC) /* OP_RETURN */ ,opmode(0, 1, 0, 0, iABC) /* OP_RETURN */
,opmode(0, 1, 0, 0, iABC) /* OP_RETVARARG */
,opmode(0, 0, 0, 0, iABC) /* OP_RETURN0 */ ,opmode(0, 0, 0, 0, iABC) /* OP_RETURN0 */
,opmode(0, 0, 0, 0, iABC) /* OP_RETURN1 */ ,opmode(0, 0, 0, 0, iABC) /* OP_RETURN1 */
,opmode(0, 0, 0, 1, iABx) /* OP_FORLOOP1 */ ,opmode(0, 0, 0, 1, iABx) /* OP_FORLOOP1 */

10
lopcodes.h
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lopcodes.h,v 1.184 2018/01/28 15:13:26 roberto Exp roberto $ ** $Id: lopcodes.h,v 1.186 2018/02/07 15:18:04 roberto Exp roberto $
** Opcodes for Lua virtual machine ** Opcodes for Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -268,6 +268,7 @@ OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */ OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */
OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */ OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */
OP_RETVARARG,/* A B return R(A), ... ,R(A+B-2) (see note) */
OP_RETURN0,/* return */ OP_RETURN0,/* return */
OP_RETURN1,/* A return R(A) */ OP_RETURN1,/* A return R(A) */
@ -286,7 +287,7 @@ OP_SETLIST,/* A B C R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B */
OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx]) */ OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx]) */
OP_VARARG,/* A B C R(A), R(A+1), ..., R(A+C-2) = vararg(B) */ OP_VARARG,/* A B C R(A), R(A+1), ..., R(A+C-2) = vararg */
OP_PREPVARARG,/*A (adjust vararg parameters) */ OP_PREPVARARG,/*A (adjust vararg parameters) */
@ -305,9 +306,10 @@ OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */
OP_SETLIST) may use 'top'. OP_SETLIST) may use 'top'.
(*) In OP_VARARG, if (C == 0) then use actual number of varargs and (*) In OP_VARARG, if (C == 0) then use actual number of varargs and
set top (like in OP_CALL with C == 0). B is the vararg parameter. set top (like in OP_CALL with C == 0).
(*) In OP_RETURN, if (B == 0) then return up to 'top'. (*) In OP_RETURN/OP_RETVARARG, if (B == 0) then return up to 'top'.
(OP_RETVARARG is the return instruction for vararg functions.)
(*) In OP_SETLIST, if (B == 0) then real B = 'top'; if (C == 0) then (*) In OP_SETLIST, if (B == 0) then real B = 'top'; if (C == 0) then
next 'instruction' is EXTRAARG(real C). next 'instruction' is EXTRAARG(real C).

22
lparser.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lparser.c,v 2.175 2017/12/22 14:16:46 roberto Exp roberto $ ** $Id: lparser.c,v 2.176 2018/02/07 15:18:04 roberto Exp roberto $
** Lua Parser ** Lua Parser
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -568,6 +568,7 @@ static void close_func (LexState *ls) {
Proto *f = fs->f; Proto *f = fs->f;
luaK_ret(fs, 0, 0); /* final return */ luaK_ret(fs, 0, 0); /* final return */
leaveblock(fs); leaveblock(fs);
lua_assert(fs->bl == NULL);
luaK_finish(fs); luaK_finish(fs);
luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction); 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->lineinfo, f->sizelineinfo, fs->pc, ls_byte);
@ -577,7 +578,8 @@ static void close_func (LexState *ls) {
luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *); luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *);
luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar); luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc); luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc);
lua_assert(fs->bl == NULL); if (f->is_vararg)
f->maxstacksize++; /* ensure space to copy the function */
ls->fs = fs->prev; ls->fs = fs->prev;
luaC_checkGC(L); luaC_checkGC(L);
} }
@ -781,11 +783,6 @@ static void parlist (LexState *ls) {
} }
case TK_DOTS: { /* param -> '...' */ case TK_DOTS: { /* param -> '...' */
luaX_next(ls); luaX_next(ls);
if (testnext(ls, '='))
new_localvar(ls, str_checkname(ls));
else
new_localvarliteral(ls, "_ARG");
nparams++;
isvararg = 1; isvararg = 1;
break; break;
} }
@ -795,10 +792,8 @@ static void parlist (LexState *ls) {
} }
adjustlocalvars(ls, nparams); adjustlocalvars(ls, nparams);
f->numparams = cast_byte(fs->nactvar); f->numparams = cast_byte(fs->nactvar);
if (isvararg) { if (isvararg)
f->numparams--; /* exclude vararg parameter */
setvararg(fs, f->numparams); /* declared vararg */ setvararg(fs, f->numparams); /* declared vararg */
}
luaK_reserveregs(fs, fs->nactvar); /* reserve registers for parameters */ luaK_reserveregs(fs, fs->nactvar); /* reserve registers for parameters */
} }
@ -984,10 +979,9 @@ static void simpleexp (LexState *ls, expdesc *v) {
} }
case TK_DOTS: { /* vararg */ case TK_DOTS: { /* vararg */
FuncState *fs = ls->fs; FuncState *fs = ls->fs;
int lastparam = fs->f->numparams;
check_condition(ls, fs->f->is_vararg, check_condition(ls, fs->f->is_vararg,
"cannot use '...' outside a vararg function"); "cannot use '...' outside a vararg function");
init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, lastparam, 1)); init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 0, 1));
break; break;
} }
case '{': { /* constructor */ case '{': { /* constructor */
@ -1703,10 +1697,6 @@ static void mainfunc (LexState *ls, FuncState *fs) {
expdesc v; expdesc v;
open_func(ls, fs, &bl); open_func(ls, fs, &bl);
setvararg(fs, 0); /* main function is always declared vararg */ setvararg(fs, 0); /* main function is always declared vararg */
fs->f->numparams = 0;
new_localvarliteral(ls, "_ARG");
adjustlocalvars(ls, 1);
luaK_reserveregs(fs, 1); /* reserve register for vararg */
init_exp(&v, VLOCAL, 0); /* create and... */ init_exp(&v, VLOCAL, 0); /* create and... */
newupvalue(fs, ls->envn, &v); /* ...set environment upvalue */ newupvalue(fs, ls->envn, &v); /* ...set environment upvalue */
luaX_next(ls); /* read first token */ luaX_next(ls); /* read first token */

3
lstate.h
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lstate.h,v 2.152 2017/11/23 16:35:54 roberto Exp roberto $ ** $Id: lstate.h,v 2.153 2017/12/19 16:40:17 roberto Exp roberto $
** Global State ** Global State
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -92,6 +92,7 @@ typedef struct CallInfo {
struct { /* only for Lua functions */ struct { /* only for Lua functions */
const Instruction *savedpc; const Instruction *savedpc;
l_signalT trap; l_signalT trap;
int nextraargs; /* # of extra arguments in vararg functions */
} l; } l;
struct { /* only for C functions */ struct { /* only for C functions */
lua_KFunction k; /* continuation in case of yields */ lua_KFunction k; /* continuation in case of yields */

61
ltm.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: ltm.c,v 2.58 2018/01/28 13:39:52 roberto Exp roberto $ ** $Id: ltm.c,v 2.59 2018/02/07 15:18:04 roberto Exp roberto $
** Tag methods ** Tag methods
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -216,41 +216,32 @@ int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2,
} }
void luaT_adjustvarargs (lua_State *L, int nfixparams, StkId base) { void luaT_adjustvarargs (lua_State *L, int nfixparams, CallInfo *ci) {
int i; int i;
Table *vtab; int actual = cast_int(L->top - ci->func) - 1; /* number of arguments */
TValue nname;
int actual = cast_int(L->top - base); /* number of arguments */
int nextra = actual - nfixparams; /* number of extra arguments */ int nextra = actual - nfixparams; /* number of extra arguments */
vtab = luaH_new(L); /* create vararg table */ ci->u.l.nextraargs = nextra;
sethvalue2s(L, L->top, vtab); /* anchor it for resizing */ checkstackGC(L, nfixparams + 1);
L->top++; /* space ensured by caller */ /* copy function and fixed parameters to the top of the stack */
luaH_resize(L, vtab, nextra, 1); for (i = 0; i <= nfixparams; i++) {
for (i = 0; i < nextra; i++) /* put extra arguments into vararg table */ setobjs2s(L, L->top++, ci->func + i);
setobj2n(L, &vtab->array[i], s2v(L->top - nextra + i - 1)); setnilvalue(s2v(ci->func + i)); /* erase original copy (for GC) */
setsvalue(L, &nname, G(L)->nfield); /* get field 'n' */
setivalue(luaH_set(L, vtab, &nname), nextra); /* store counter there */
L->top -= nextra; /* remove extra elements from the stack */
sethvalue2s(L, L->top - 1, vtab); /* move table to new top */
luaC_checkGC(L);
}
void luaT_getvarargs (lua_State *L, TValue *t, StkId where, int wanted) {
if (!ttistable(t))
luaG_runerror(L, "'vararg' parameter is not a table");
else {
int i;
Table *h = hvalue(t);
if (wanted < 0) { /* get all? */
const TValue *ns = luaH_getstr(h, G(L)->nfield);
int n = (ttisinteger(ns)) ? cast_int(ivalue(ns)) : 0;
wanted = n;
checkstackp(L, n, where);
L->top = where + n;
}
for (i = 0; i < wanted; i++) /* get what is available */
setobj2s(L, where + i, luaH_getint(h, i + 1));
return;
} }
ci->func += actual + 1;
ci->top += actual + 1;
}
void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted) {
int i;
int nextra = ci->u.l.nextraargs;
if (wanted < 0) {
wanted = nextra; /* get all extra arguments available */
checkstackp(L, nextra, where); /* ensure stack space */
L->top = where + nextra; /* next instruction will need top */
}
for (i = 0; i < wanted && i < nextra; i++)
setobjs2s(L, where + i, ci->func - nextra + i);
for (; i < wanted; i++) /* complete required results with nil */
setnilvalue(s2v(where + i));
} }

10
ltm.h
View File

@ -1,5 +1,5 @@
/* /*
** $Id: ltm.h,v 2.29 2018/01/28 13:39:52 roberto Exp roberto $ ** $Id: ltm.h,v 2.30 2018/02/07 15:18:04 roberto Exp roberto $
** Tag methods ** Tag methods
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -9,6 +9,7 @@
#include "lobject.h" #include "lobject.h"
#include "lstate.h"
/* /*
@ -77,9 +78,10 @@ LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1,
LUAI_FUNC int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2, LUAI_FUNC int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2,
int inv, TMS event); int inv, TMS event);
LUAI_FUNC void luaT_adjustvarargs (lua_State *L, int nfixparams, StkId base); LUAI_FUNC void luaT_adjustvarargs (lua_State *L, int nfixparams,
LUAI_FUNC void luaT_getvarargs (lua_State *L, TValue *t, StkId where, struct CallInfo *ci);
int wanted); LUAI_FUNC void luaT_getvarargs (lua_State *L, struct CallInfo *ci,
StkId where, int wanted);
#endif #endif

40
lvm.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lvm.c,v 2.337 2018/02/06 19:16:56 roberto Exp roberto $ ** $Id: lvm.c,v 2.338 2018/02/07 15:18:04 roberto Exp roberto $
** Lua virtual machine ** Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -1506,14 +1506,10 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
luaF_close(L, base); /* close upvalues from current call */ luaF_close(L, base); /* close upvalues from current call */
if (!ttisLclosure(vra)) { /* C function? */ if (!ttisLclosure(vra)) { /* C function? */
ProtectNT(luaD_call(L, ra, LUA_MULTRET)); /* call it */ ProtectNT(luaD_call(L, ra, LUA_MULTRET)); /* call it */
if (trap) {
updatebase(ci);
ra = RA(i);
}
luaD_poscall(L, ci, ra, cast_int(L->top - ra));
return;
} }
else { /* Lua tail call */ else { /* Lua tail call */
if (cl->p->is_vararg)
ci->func -= cl->p->numparams + ci->u.l.nextraargs + 1;
luaD_pretailcall(L, ci, ra, b); /* prepare call frame */ luaD_pretailcall(L, ci, ra, b); /* prepare call frame */
goto tailcall; goto tailcall;
} }
@ -1521,11 +1517,30 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
} }
vmcase(OP_RETURN) { vmcase(OP_RETURN) {
int b = GETARG_B(i); int b = GETARG_B(i);
int n = (b != 0 ? b - 1 : cast_int(L->top - ra));
if (TESTARG_k(i)) if (TESTARG_k(i))
luaF_close(L, base); luaF_close(L, base);
halfProtect( halfProtect(luaD_poscall(L, ci, ra, n));
luaD_poscall(L, ci, ra, (b != 0 ? b - 1 : cast_int(L->top - ra))) return;
); }
vmcase(OP_RETVARARG) {
int b = GETARG_B(i);
int nparams = GETARG_C(i);
int nres = (b != 0 ? b - 1 : cast_int(L->top - ra));
int delta = ci->u.l.nextraargs + nparams + 2;
if (TESTARG_k(i))
luaF_close(L, base);
savepc(L);
/* code similar to 'luaD_poscall', but with a delta */
if (L->hookmask) {
luaD_rethook(L, ci);
if (ci->u.l.trap) {
updatebase(ci);
ra = RA(i);
}
}
L->ci = ci->previous; /* back to caller */
luaD_moveresults(L, ra, base - delta, nres, ci->nresults);
return; return;
} }
vmcase(OP_RETURN0) { vmcase(OP_RETURN0) {
@ -1702,12 +1717,11 @@ void luaV_execute (lua_State *L, CallInfo *ci) {
} }
vmcase(OP_VARARG) { vmcase(OP_VARARG) {
int n = GETARG_C(i) - 1; /* required results */ int n = GETARG_C(i) - 1; /* required results */
TValue *vtab = vRB(i); /* vararg table */ ProtectNT(luaT_getvarargs(L, ci, ra, n));
Protect(luaT_getvarargs(L, vtab, ra, n));
vmbreak; vmbreak;
} }
vmcase(OP_PREPVARARG) { vmcase(OP_PREPVARARG) {
luaT_adjustvarargs(L, GETARG_A(i), base); luaT_adjustvarargs(L, GETARG_A(i), ci);
updatetrap(ci); updatetrap(ci);
if (trap) { if (trap) {
luaD_hookcall(L, ci); luaD_hookcall(L, ci);