mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 08:00:42 +00:00
Systematic sweep of the Lua 5.1 stdlib delta against what ClassicAPI
already backports found five gaps, all confirmed by in-game probes:
* unpack(list [, i [, j]]) -- 5.0's unpack silently ignored the range
args, so unpack(t, 2) returned the WHOLE table (wrong values, no
error; the only silent gap). Replaced with a port of 5.1's
luaB_unpack: ranges via luaL_getn + lua_rawgeti, so a vararg arg
table's n field keeps its embedded-nil count. Both states.
* string.gsub table replacement -- 5.0 accepts only string/function
and errors on a table. Shim on string.gsub AND the bare gsub global:
a table becomes an adapter closure over the engine's own gsub
(FUN_LUA_STR_GSUB = 0x007FD0E0, pinned by registration-table
position, name string, and decode). Because this engine's add_value
drops a non-string function result (match -> empty) where 5.1 keeps
the match on nil/false, the shim wraps the pattern in one outer
capture (^/$ anchors kept outside) so the closure receives the whole
match and can hand it back for missing keys -- exact 5.1 keep-match.
Patterns with a %1..%9 backref skip the wrap (renumbering hazard);
their missing-key behavior stays the engine's (documented residual).
* collectgarbage 5.1 options -- "count" -> gcinfo, "collect" ->
original collectgarbage(0), "step" -> loop-safe true, stop/restart/
setpause/setstepmul -> no-op 0, numbers forwarded untouched. The
originals are function objects stashed in the state's registry
before the overwrite, so no new engine offsets and each /reload
re-stashes the fresh engine original. Both states.
* table.maxn -- 5.1 luaB_maxn port (largest positive numeric key,
full next-walk so nil holes don't stop it). Both states.
* coroutine.running -- returns the running coroutine, nil on the main
thread. 5.0 has no lua_pushthread, so the thread TValue (tag 8 +
the running L, this build's {tt@0, value@+8} layout) is written to
the stack raw; main-thread detection via the registration-time L.
Verified in-game: ranged/holed/n-field unpack shapes, all four gsub
shapes (populated table, keep-match on missing key, whole-match key,
anchored pattern), maxn past a nil hole, collectgarbage("count"/
"collect"), and coroutine.running from main + inside a wrap.
Docs: five new API.md sections + TOC entries; README Lua list updated.
87 lines
3.3 KiB
C++
87 lines
3.3 KiB
C++
// This file is part of ClassicAPI.
|
|
//
|
|
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
|
// of the GNU General Public License as published by the Free Software Foundation, either
|
|
// version 3 of the License, or (at your option) any later version.
|
|
//
|
|
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
// PURPOSE. See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License along with
|
|
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
// `unpack(list [, i [, j]])` — upgrade 1.12's Lua 5.0 `unpack` to the 5.1
|
|
// signature. 5.0's unpack takes NO range arguments and silently ignores
|
|
// extras, so 5.1 code calling `unpack(t, 2)` got the WHOLE table back —
|
|
// wrong values with no error, the worst failure mode (verified in-game:
|
|
// `unpack({10,20,30}, 2)` returned 10, 20, 30). This replacement is a
|
|
// port of 5.1's `luaB_unpack` (lbaselib.c): `i` defaults to 1 and `j` to
|
|
// the table length via luaL_getn — which reads a `t.n` field first, so
|
|
// the transpiler's `unpack(arg)` vararg expansion keeps its
|
|
// embedded-nil-aware count exactly as before.
|
|
//
|
|
// Registered on BOTH states (language-level helper, both are 5.0).
|
|
|
|
#include "Game.h"
|
|
#include "Offsets.h"
|
|
|
|
namespace BaseLib::Unpack {
|
|
|
|
namespace {
|
|
|
|
// Engine auxlib/API entries (see Offsets.h for derivations).
|
|
using LuaLGetN_t = int(__fastcall *)(void *L, int idx);
|
|
using RawGetI_t = void(__fastcall *)(void *L, int idx, int n);
|
|
|
|
// Range argument at `idx`: absent/nil → `fallback`; a number (or numeric
|
|
// string, matching luaL_optint's coercion) → its value; anything else
|
|
// errors like 5.1's luaL_optint.
|
|
int OptRange(void *L, int idx, int fallback) {
|
|
if (Game::Lua::Type(L, idx) <= Game::Lua::TYPE_NIL) // none or nil
|
|
return fallback;
|
|
if (!Game::Lua::IsNumber(L, idx)) {
|
|
Game::Lua::Error(L, "bad argument #%d to 'unpack' (number expected)", idx);
|
|
return 0; // unreachable
|
|
}
|
|
return static_cast<int>(Game::Lua::ToNumber(L, idx));
|
|
}
|
|
|
|
int __fastcall Script_unpack(void *L) {
|
|
if (Game::Lua::Type(L, 1) != Game::Lua::TYPE_TABLE) {
|
|
Game::Lua::Error(L, "bad argument #1 to 'unpack' (table expected)");
|
|
return 0; // unreachable
|
|
}
|
|
const int i = OptRange(L, 2, 1);
|
|
const int e = OptRange(
|
|
L, 3, reinterpret_cast<LuaLGetN_t>(Offsets::LUAL_GETN)(L, 1));
|
|
if (i > e)
|
|
return 0;
|
|
// `n <= 0` guards the int overflow of `e - i + 1` (i <= e holds here),
|
|
// mirroring 5.1's luaB_unpack.
|
|
const int n = e - i + 1;
|
|
if (n <= 0 || Game::Lua::CheckStack(L, n) == 0) {
|
|
Game::Lua::Error(L, "too many results to unpack");
|
|
return 0; // unreachable
|
|
}
|
|
const auto rawGetI = reinterpret_cast<RawGetI_t>(Offsets::LUA_RAWGETI);
|
|
for (int k = i; k <= e; ++k)
|
|
rawGetI(L, 1, k);
|
|
return n;
|
|
}
|
|
|
|
void RegisterInGame() {
|
|
Game::Lua::RegisterGlobalFunction("unpack", &Script_unpack);
|
|
}
|
|
|
|
void RegisterGlue() {
|
|
Game::Lua::RegisterGlueFunction("unpack", &Script_unpack);
|
|
}
|
|
|
|
const Game::ModuleAutoRegister _autoreg{&RegisterInGame};
|
|
const Game::GlueModuleAutoRegister _autoregGlue{&RegisterGlue};
|
|
|
|
} // namespace
|
|
|
|
} // namespace BaseLib::Unpack
|