From f33cc4ddec886ea499d7d41dd60cac5ddc5687db Mon Sep 17 00:00:00 2001 From: Roberto I Date: Wed, 26 Nov 2025 11:18:29 -0300 Subject: New conceptual model for vararg Conceptually, all functions get their vararg arguments in a vararg table. The storing of vararg arguments in the stack is always treated as an optimization. --- lcode.c | 5 ++++ lobject.h | 5 ++-- lopcodes.h | 2 +- lparser.c | 24 +++++++++---------- ltm.c | 64 +++++++++++++++++++++++++++++++++++++++---------- ltm.h | 4 ++-- lvm.c | 5 ++-- manual/manual.of | 68 +++++++++++++++++++++++++++++----------------------- testes/coroutine.lua | 4 +++- testes/db.lua | 9 +++---- testes/vararg.lua | 33 +++++++++++++++++++++++++ 11 files changed, 154 insertions(+), 69 deletions(-) diff --git a/lcode.c b/lcode.c index 95ef900c..afed05d1 100644 --- a/lcode.c +++ b/lcode.c @@ -1951,6 +1951,11 @@ void luaK_finish (FuncState *fs) { SET_OPCODE(*pc, OP_GETTABLE); /* must get vararg there */ break; } + case OP_VARARG: { + if (p->flag & PF_VATAB) /* function has a vararg table? */ + SETARG_k(*pc, 1); /* must get vararg there */ + break; + } case OP_JMP: { /* to optimize jumps to jumps */ int target = finaltarget(p->code, i); fixjump(fs, i, target); /* jump directly to final target */ diff --git a/lobject.h b/lobject.h index 841ab5b9..070f12a4 100644 --- a/lobject.h +++ b/lobject.h @@ -584,9 +584,8 @@ typedef struct AbsLineInfo { ** Flags in Prototypes */ #define PF_ISVARARG 1 /* function is vararg */ -#define PF_VAVAR 2 /* function has vararg parameter */ -#define PF_VATAB 4 /* function has vararg table */ -#define PF_FIXED 8 /* prototype has parts in fixed memory */ +#define PF_VATAB 2 /* function has vararg table */ +#define PF_FIXED 4 /* prototype has parts in fixed memory */ /* diff --git a/lopcodes.h b/lopcodes.h index f5c95151..fac87da2 100644 --- a/lopcodes.h +++ b/lopcodes.h @@ -336,7 +336,7 @@ OP_SETLIST,/* A vB vC k R[A][vC+i] := R[A+i], 1 <= i <= vB */ OP_CLOSURE,/* A Bx R[A] := closure(KPROTO[Bx]) */ -OP_VARARG,/* A C R[A], R[A+1], ..., R[A+C-2] = vararg */ +OP_VARARG,/* A C R[A], ..., R[A+C-2] = vararg, R[B] is vararg param. */ OP_GETVARG, /* A B C R[A] := R[B][R[C]], R[B] is vararg parameter */ diff --git a/lparser.c b/lparser.c index 77141e79..a07044b8 100644 --- a/lparser.c +++ b/lparser.c @@ -1056,9 +1056,8 @@ static void constructor (LexState *ls, expdesc *t) { /* }====================================================================== */ -static void setvararg (FuncState *fs, int kind) { - lua_assert(kind & PF_ISVARARG); - fs->f->flag |= cast_byte(kind); +static void setvararg (FuncState *fs) { + fs->f->flag |= PF_ISVARARG; luaK_codeABC(fs, OP_VARARGPREP, 0, 0, 0); } @@ -1078,12 +1077,12 @@ static void parlist (LexState *ls) { break; } case TK_DOTS: { - varargk |= PF_ISVARARG; + varargk = 1; luaX_next(ls); /* skip '...' */ - if (ls->t.token == TK_NAME) { + if (ls->t.token == TK_NAME) new_varkind(ls, str_checkname(ls), RDKVAVAR); - varargk |= PF_VAVAR; - } + else + new_localvarliteral(ls, "(vararg table)"); break; } default: luaX_syntaxerror(ls, " or '...' expected"); @@ -1092,10 +1091,9 @@ static void parlist (LexState *ls) { } adjustlocalvars(ls, nparams); f->numparams = cast_byte(fs->nactvar); - if (varargk != 0) { - setvararg(fs, varargk); /* declared vararg */ - if (varargk & PF_VAVAR) - adjustlocalvars(ls, 1); /* vararg parameter */ + if (varargk) { + setvararg(fs); /* declared vararg */ + adjustlocalvars(ls, 1); /* vararg parameter */ } /* reserve registers for parameters (plus vararg parameter, if present) */ luaK_reserveregs(fs, fs->nactvar); @@ -1287,7 +1285,7 @@ static void simpleexp (LexState *ls, expdesc *v) { FuncState *fs = ls->fs; check_condition(ls, fs->f->flag & PF_ISVARARG, "cannot use '...' outside a vararg function"); - init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 0, 1)); + init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, fs->f->numparams, 1)); break; } case '{' /*}*/: { /* constructor */ @@ -2153,7 +2151,7 @@ static void mainfunc (LexState *ls, FuncState *fs) { BlockCnt bl; Upvaldesc *env; open_func(ls, fs, &bl); - setvararg(fs, PF_ISVARARG); /* main function is always vararg */ + setvararg(fs); /* main function is always vararg */ env = allocupvalue(fs); /* ...set environment upvalue */ env->instack = 1; env->idx = 0; diff --git a/ltm.c b/ltm.c index 8d64235e..39ac59d4 100644 --- a/ltm.c +++ b/ltm.c @@ -242,6 +242,7 @@ static void createvarargtab (lua_State *L, StkId f, int n) { luaH_set(L, t, &key, &value); /* t.n = n */ for (i = 0; i < n; i++) luaH_setint(L, t, i + 1, s2v(f + i)); + luaC_checkGC(L); } @@ -265,11 +266,11 @@ void luaT_adjustvarargs (lua_State *L, CallInfo *ci, const Proto *p) { setobjs2s(L, L->top.p++, ci->func.p + i); setnilvalue(s2v(ci->func.p + i)); /* erase original parameter (for GC) */ } - if (p->flag & PF_VAVAR) { /* is there a vararg parameter? */ - if (p->flag & PF_VATAB) /* does it need a vararg table? */ - createvarargtab(L, ci->func.p + nfixparams + 1, nextra); - else /* no table; set parameter to nil */ - setnilvalue(s2v(L->top.p)); + if (p->flag & PF_VATAB) /* does it need a vararg table? */ + createvarargtab(L, ci->func.p + nfixparams + 1, nextra); + else { /* no table; set parameter to nil */ + setnilvalue(s2v(L->top.p)); + L->top.p++; } ci->func.p += totalargs + 1; ci->top.p += totalargs + 1; @@ -299,16 +300,53 @@ void luaT_getvararg (CallInfo *ci, StkId ra, TValue *rc) { } -void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted) { - int i; - int nextra = ci->u.l.nextraargs; +/* +** Get the number of extra arguments in a vararg function. If vararg +** table has been optimized away, that number is in the call info. +** Otherwise, get the field 'n' from the vararg table and check that it +** has a proper value (non-negative integer not larger than the stack +** limit). +*/ +static int getnumargs (lua_State *L, CallInfo *ci, Table *h) { + if (h == NULL) /* no vararg table? */ + return ci->u.l.nextraargs; + else { + TValue res; + if (luaH_getshortstr(h, luaS_new(L, "n"), &res) != LUA_VNUMINT || + l_castS2U(ivalue(&res)) > cast_uint(INT_MAX/2)) + luaG_runerror(L, "vararg table has no proper 'n'"); + return cast_int(ivalue(&res)); + } +} + + +/* +** Get 'wanted' vararg arguments and put them in 'where'. 'vatab' is +** the register of the vararg table or -1 if there is no vararg table. +*/ +void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted, + int vatab) { + Table *h = (vatab < 0) ? NULL : hvalue(s2v(ci->func.p + vatab + 1)); + int nargs = getnumargs(L, ci, h); /* number of available vararg args. */ + int i, touse; /* 'touse' is minimum between 'wanted' and 'nargs' */ if (wanted < 0) { - wanted = nextra; /* get all extra arguments available */ - checkstackp(L, nextra, where); /* ensure stack space */ - L->top.p = where + nextra; /* next instruction will need top */ + touse = wanted = nargs; /* get all extra arguments available */ + checkstackp(L, nargs, where); /* ensure stack space */ + L->top.p = where + nargs; /* next instruction will need top */ + } + else + touse = (nargs > wanted) ? wanted : nargs; + if (h == NULL) { /* no vararg table? */ + for (i = 0; i < touse; i++) /* get vararg values from the stack */ + setobjs2s(L, where + i, ci->func.p - nargs + i); + } + else { /* get vararg values from vararg table */ + for (i = 0; i < touse; i++) { + lu_byte tag = luaH_getint(h, i + 1, s2v(where + i)); + if (tagisempty(tag)) + setnilvalue(s2v(where + i)); + } } - for (i = 0; i < wanted && i < nextra; i++) - setobjs2s(L, where + i, ci->func.p - nextra + i); for (; i < wanted; i++) /* complete required results with nil */ setnilvalue(s2v(where + i)); } diff --git a/ltm.h b/ltm.h index 86f457eb..07fc8c1c 100644 --- a/ltm.h +++ b/ltm.h @@ -98,8 +98,8 @@ LUAI_FUNC int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2, LUAI_FUNC void luaT_adjustvarargs (lua_State *L, struct CallInfo *ci, const Proto *p); LUAI_FUNC void luaT_getvararg (CallInfo *ci, StkId ra, TValue *rc); -LUAI_FUNC void luaT_getvarargs (lua_State *L, struct CallInfo *ci, - StkId where, int wanted); +LUAI_FUNC void luaT_getvarargs (lua_State *L, struct CallInfo *ci, StkId where, + int wanted, int vatab); #endif diff --git a/lvm.c b/lvm.c index 2c868c21..c70e2b8a 100644 --- a/lvm.c +++ b/lvm.c @@ -1935,8 +1935,9 @@ void luaV_execute (lua_State *L, CallInfo *ci) { } vmcase(OP_VARARG) { StkId ra = RA(i); - int n = GETARG_C(i) - 1; /* required results */ - Protect(luaT_getvarargs(L, ci, ra, n)); + int n = GETARG_C(i) - 1; /* required results (-1 means all) */ + int vatab = GETARG_k(i) ? GETARG_B(i) : -1; + Protect(luaT_getvarargs(L, ci, ra, n, vatab)); vmbreak; } vmcase(OP_GETVARG) { diff --git a/manual/manual.of b/manual/manual.of index 96203d7f..9b8e144d 100644 --- a/manual/manual.of +++ b/manual/manual.of @@ -2221,7 +2221,7 @@ The form } can be used to emulate methods. A call @T{v:name(@rep{args})} -is syntactic sugar for @T{v.name(v,@rep{args})}, +is syntactic sugar for @T{v.name(v, @rep{args})}, except that @id{v} is evaluated only once. Arguments have the following syntax: @@ -2372,12 +2372,10 @@ which is indicated by three dots (@Char{...}) at the end of its parameter list. A variadic function does not adjust its argument list; instead, it collects all extra arguments and supplies them -to the function through a @def{vararg expression} and, -if present, a @def{vararg table}. - -A vararg expression is also written as three dots, -and its value is a list of all actual extra arguments, -similar to a function with multiple results @see{multires}. +to the function through a @def{vararg table}. +In that table, +the values at indices 1, 2, etc. are the extra arguments, +and the value at index @St{n} is the number of extra arguments. As an example, consider the following definitions: @verbatim{ @@ -2386,7 +2384,7 @@ function g(a, b, ...) end function r() return 1,2,3 end } Then, we have the following mapping from arguments to parameters and -to the vararg expression: +to the vararg table: @verbatim{ CALL PARAMETERS @@ -2396,33 +2394,39 @@ f(3, 4, 5) a=3, b=4 f(r(), 10) a=1, b=10 f(r()) a=1, b=2 -g(3) a=3, b=nil, ... -> (nothing) -g(3, 4) a=3, b=4, ... -> (nothing) -g(3, 4, 5, 8) a=3, b=4, ... -> 5 8 -g(5, r()) a=5, b=1, ... -> 2 3 +g(3) a=3, b=nil, va. table -> {n = 0} +g(3, 4) a=3, b=4, va. table -> {n = 0} +g(3, 4, 5, 8) a=3, b=4, va. table -> {5, 8, n = 2} +g(5, r()) a=5, b=1, va. table -> {2, 3, n = 2} } -The presence of a vararg table in a variadic function is indicated -by a name after the three dots. +A vararg table in a variadic function can have an optional name, +given after the three dots. When present, -a vararg table behaves like a read-only local variable -with the given name that is initialized with a table. -In that table, -the values at indices 1, 2, etc. are the extra arguments, -and the value at index @St{n} is the number of extra arguments. -In other words, the code behaves as if the function started with -the following statement, -assuming the standard behavior of @Lid{table.pack}: -@verbatim{ -local name = table.pack(...) -} +that name denotes a read-only local variable that +refers to the vararg table. +If the vararg table does not have a name, +it can only be accessed through a vararg expression. + +A vararg expression is also written as three dots, +and its value is a list of the values in the vararg table, +from 1 to the integer value at index @St{n}. +(Therefore, if the code does not modify the vararg table, +this list corresponds to the extra arguments in the function call.) +This list behaves like the results from a +function with multiple results @see{multires}. As an optimization, -if the vararg table is used only as the base table -in the syntactic constructions @T{t[exp]} or @T{t.id}) -and it is not an upvalue, +if the vararg table satisfies some conditions, the code does not create an actual table and instead translates -the indexing expressions into accesses to the internal vararg data. +the indexing expressions and the vararg expressions +into accesses to the internal vararg data. +The conditions are as follows: +If the vararg table has a name, +that name is not an upvalue in a nested function +and it is used only as the base table +in the syntactic constructions @T{t[exp]} or @T{t.id}). +Note that an anonymous vararg table always satisfy these conditions. } @@ -3103,7 +3107,7 @@ void *luaL_alloc (void *ud, void *ptr, size_t osize, } Note that @N{ISO C} ensures that @T{free(NULL)} has no effect and that -@T{realloc(NULL,size)} is equivalent to @T{malloc(size)}. +@T{realloc(NULL, size)} is equivalent to @T{malloc(size)}. } @@ -9197,6 +9201,10 @@ Compile-time constants may not appear in this listing, if they were optimized away by the compiler. Negative indices refer to vararg arguments; @num{-1} is the first vararg argument. +These negative indices are only available when the vararg table +has been optimized away; +otherwise, the vararg arguments are available in the vararg table. + The function returns @fail if there is no variable with the given index, and raises an error when called with a level out of range. diff --git a/testes/coroutine.lua b/testes/coroutine.lua index 4881d964..ba394e0c 100644 --- a/testes/coroutine.lua +++ b/testes/coroutine.lua @@ -702,7 +702,9 @@ else assert(t.currentline == t.linedefined + 2) assert(not debug.getinfo(c, 1)) -- no other level assert(coroutine.resume(c)) -- run next line - local n,v = debug.getlocal(c, 0, 2) -- check next local + local n,v = debug.getlocal(c, 0, 2) -- check vararg table + assert(n == "(vararg table)" and v == nil) + local n,v = debug.getlocal(c, 0, 3) -- check next local assert(n == "b" and v == 10) v = {coroutine.resume(c)} -- finish coroutine assert(v[1] == true and v[2] == 2 and v[3] == 3 and v[4] == undef) diff --git a/testes/db.lua b/testes/db.lua index 0f174f17..4220b68b 100644 --- a/testes/db.lua +++ b/testes/db.lua @@ -356,8 +356,8 @@ function f(a,b) global assert, g, string local _, y = debug.getlocal(1, 2) assert(x == a and y == b) - assert(debug.setlocal(2, 3, "pera") == "AA".."AA") - assert(debug.setlocal(2, 4, "manga") == "B") + assert(debug.setlocal(2, 4, "pera") == "AA".."AA") + assert(debug.setlocal(2, 5, "manga") == "B") x = debug.getinfo(2) assert(x.func == g and x.what == "Lua" and x.name == 'g' and x.nups == 2 and string.find(x.source, "^@.*db%.lua$")) @@ -392,7 +392,7 @@ function g (...) global * local B = 13 global assert - local x,y = debug.getlocal(1,5) + local x,y = debug.getlocal(1,6) assert(x == 'B' and y == 13) end end @@ -458,7 +458,8 @@ local function collectlocals (level) local tab = {} for i = 1, math.huge do local n, v = debug.getlocal(level + 1, i) - if not (n and string.find(n, "^[a-zA-Z0-9_]+$")) then + if not (n and string.find(n, "^[a-zA-Z0-9_]+$") or + n == "(vararg table)") then break -- consider only real variables end tab[n] = v diff --git a/testes/vararg.lua b/testes/vararg.lua index a01598ff..043fa7d4 100644 --- a/testes/vararg.lua +++ b/testes/vararg.lua @@ -101,6 +101,38 @@ a,b,c,d,e = f(4) assert(a==nil and b==nil and c==nil and d==nil and e==nil) +do -- vararg expressions using unpack + local function aux (a, v, ...t) + for k, val in pairs(v) do t[k] = val end + return ... + end + + local t = table.pack(aux(10, {11, [5] = 24}, 1, 2, 3, nil, 4)) + assert(t.n == 5 and t[1] == 11 and t[2] == 2 and t[3] == 3 + and t[4] == nil and t[5] == 24) + + local t = table.pack(aux(nil, {1, [20] = "a", [30] = "b", n = 30})) + assert(t.n == 30 and t[1] == 1 and t[20] == "a" and t[30] == "b") + -- table has only those four elements + assert(next(t, next(t, next(t, next(t, next(t, nil))))) == nil) + + local a, b, c, d = aux(nil, {}, 10, 20, 30) + assert(a == 10 and b == 20 and c == 30 and d == nil) + + local function aux (a, b, n, ...t) t.n = n; return b, ... end + local t = table.pack(aux(10, 1, 10000)) + assert(t.n == 10001 and t[1] == 1 and #t == 1) + + local function checkerr (emsg, f, ...) + local st, msg = pcall(f, ...) + assert(not st and string.find(msg, emsg)) + end + checkerr("no proper 'n'", aux, 1, 1, -1) + checkerr("no proper 'n'", aux, 1, 1, math.maxinteger) + checkerr("no proper 'n'", aux, 1, 1, math.mininteger) + checkerr("no proper 'n'", aux, 1, 1, 1.0) +end + -- varargs for main chunks local f = assert(load[[ return {...} ]]) local x = f(2,3) @@ -205,6 +237,7 @@ do -- access to vararg parameter assert(t[k] == v[k]) end assert(t.n == v.n) + return ... end local t = table.pack(10, 20, 30) -- cgit v1.2.3-55-g6feb