From 6ed0edc9476366f65b4316661966881fa1097e4e Mon Sep 17 00:00:00 2001 From: Brues <5278969+brues-code@users.noreply.github.com> Date: Tue, 3 Nov 2026 14:23:25 -0600 Subject: [PATCH] feat(baselib): gmatch, table.removemulti, math hyperbolics, difftime, newproxy, scrub The base-library names that 1.12.1's Lua 5.0 and its compat.lua do not have: - gmatch: the global alias of string.gmatch (5.0's str_gfind, 0x7FCFA0), set by value like strmatch and strrev. - table.removemulti(t [, pos [, count]]): removes count elements from pos, shifts the rest down with lua_rawgeti/lua_rawseti and returns the removed elements. 5.0 keeps the length apart from the keys, so like the engine's table.remove (0x7FB770) it records the new length with luaL_setn (0x6F4EA0). - math.cosh, math.sinh, math.tanh: luaL_checknumber (0x6F4C80) and the C function. - difftime(t2 [, t1]): C difftime over the two times, next to the engine's date and time globals. - newproxy([false | true | proxy]): an empty userdata from lua_newuserdata. The closure's upvalue is a weak table (its own metatable, __mode "kv") that marks the metatables newproxy(true) makes, so only those can be shared. - scrub(...): replaces each argument that is not a boolean, number or string with nil, in place with lua_replace (0x6F32B0). All are registered on both Lua states. Game::Lua gains RawSetI (lua_rawseti, 0x6F3F60), Replace, CheckLString (luaL_checklstring, 0x6F4BE0), CheckNumber and OptNumber (luaL_optnumber, 0x6F4CD0); string.byte now uses them instead of local typedefs. issecure, issecurevariable and forceinsecure are left out. 1.12.1 has no taint, so they could only return constants, and a constant "secure" from issecurevariable makes AceHook-3.0 refuse every plain hook. --- docs/API.md | 71 ++++++++++++++++++++++++++++++++++- src/Game.cpp | 5 +++ src/Game.h | 14 +++++++ src/Offsets.h | 6 +++ src/baselib/DiffTime.cpp | 58 +++++++++++++++++++++++++++++ src/baselib/MathLib.cpp | 23 +++++++++++- src/baselib/NewProxy.cpp | 78 +++++++++++++++++++++++++++++++++++++++ src/baselib/Scrub.cpp | 63 +++++++++++++++++++++++++++++++ src/baselib/StringLib.cpp | 30 +++++++-------- src/table/RemoveMulti.cpp | 68 ++++++++++++++++++++++++++++++++++ 10 files changed, 398 insertions(+), 18 deletions(-) create mode 100644 src/baselib/DiffTime.cpp create mode 100644 src/baselib/NewProxy.cpp create mode 100644 src/baselib/Scrub.cpp create mode 100644 src/table/RemoveMulti.cpp diff --git a/docs/API.md b/docs/API.md index 77a248fc..c9fcd8a6 100644 --- a/docs/API.md +++ b/docs/API.md @@ -673,12 +673,16 @@ build instructions. - [`getfenv` / `setfenv` environment protection](#getfenv--setfenv-environment-protection) - [`select(index, ...)`](#selectindex-) - [`unpack(list [, i [, j]])`](#unpacklist--i--j) + - [`newproxy([proxy])`](#newproxyproxy) + - [`scrub(...)`](#scrub) + - [`difftime(time2 [, time1])`](#difftimetime2--time1) - [`xpcall(f, msgh [, arg1, ...])`](#xpcallf-msgh--arg1-) - [`GetCallstackHeight()` / `GetErrorCallstackHeight()` / `SetErrorCallstackHeight([height])`](#getcallstackheight--geterrorcallstackheight--seterrorcallstackheightheight) - [`collectgarbage(opt [, arg])`](#collectgarbageopt--arg) - [`table.wipe(t)` / `wipe(t)`](#tablewipet--wipet) - [`table.count(tbl)`](#tablecounttbl) - [`table.maxn(t)`](#tablemaxnt) + - [`table.removemulti(t [, pos [, count]])`](#tableremovemultit--pos--count) - [Stale table lengths (5.1 healing)](#stale-table-lengths-51-healing) - [`Mixin(object, ...)` / `CreateFromMixins(...)`](#mixinobject---createfrommixins) - [`string.match` / `string.gmatch`](#stringmatch--stringgmatch) @@ -696,6 +700,7 @@ build instructions. - [`math.fmod(x, y)`](#mathfmodx-y) - [`math.modf(x)`](#mathmodfx) - [`math.huge`](#mathhuge) + - [`math.cosh(x)` / `math.sinh(x)` / `math.tanh(x)`](#mathcoshx--mathsinhx--mathtanhx) - [`coroutine.create(fn)`](#coroutinecreatefn) - [`coroutine.resume(co, ...)`](#coroutineresumeco-) - [`coroutine.yield(...)`](#coroutineyield) @@ -16032,6 +16037,44 @@ unpack({10, 20, 30}, 2, 2) -- 20 length, so a vararg `arg` table's `n` field is honored and embedded nils keep their slots. Errors on a non-table first argument, exactly like 5.1. +### `newproxy([proxy])` + +Returns a new empty userdata. The argument sets its metatable: + +- `false` or no argument: the userdata has no metatable. +- `true`: the userdata gets a new empty metatable. Use `getmetatable` to get + this metatable and add metamethods to it. +- A userdata from `newproxy(true)`: the new userdata shares the metatable of + that userdata. + +Any other argument causes the error `boolean or proxy expected`. + +```lua +local proxy = newproxy(true) +getmetatable(proxy).__gc = function() print("collected") end +local twin = newproxy(proxy) -- same metatable as proxy +``` + +### `scrub(...)` + +Returns its arguments. Each argument that is not a boolean, a number or a +string becomes `nil`. + +```lua +scrub(1, "a", true, {}, print) -- 1, "a", true, nil, nil +``` + +### `difftime(time2 [, time1])` + +Returns the number of seconds from `time1` to `time2`. `time1` is 0 by +default. Both values are times in seconds, as `time()` returns. + +```lua +local start = time() +-- ... +difftime(time(), start) -- the seconds since start +``` + ### `xpcall(f, msgh [, arg1, ...])` Calls `f` under the message handler `msgh`, passing the trailing arguments @@ -16167,6 +16210,21 @@ table.maxn({ a = 1 }) -- 0 Errors on non-table input. +### `table.removemulti(t [, pos [, count]])` + +Removes `count` elements from `t`, starting at position `pos`, and returns +the removed elements in order. The elements after them move down to fill the +gap. `pos` is the last position by default, and `count` is 1 by default. + +If `t` is empty, the function returns no values. If the range is not inside +the table, the function causes the error `parameters out of bounds`. + +```lua +local t = { "a", "b", "c", "d", "e" } +table.removemulti(t, 2, 3) -- "b", "c", "d" +-- t is now { "a", "e" } +``` + ### Stale table lengths (5.1 healing) Lua 5.0 stores a table's `table.insert` / `table.getn` length **out of @@ -16253,7 +16311,8 @@ for word in string.gmatch("a,bb,ccc", "[^,]+") do print(word) end -- a / bb / cc Both call forms work: `string.match(s, p)` and `s:match(p)`. See [String methods](#string-methods-supper-sformat). `string.match` is also the global `strmatch`, as on 3.x clients, alongside 1.12's own `strfind`, `strsub` -and the other globals for the 5.0 string functions. +and the other globals for the 5.0 string functions. `string.gmatch` is also the +global `gmatch`. ### `string.gsub` replacements @@ -16486,6 +16545,16 @@ local best = math.huge for _, v in ipairs(costs) do best = math.min(best, v) end ``` +### `math.cosh(x)` / `math.sinh(x)` / `math.tanh(x)` + +The hyperbolic cosine, sine and tangent of `x`. + +```lua +math.cosh(0) -- 1 +math.sinh(0) -- 0 +math.tanh(1) -- 0.76159415595576 +``` + ### `coroutine.*` The Lua 5.1 `coroutine` library: `create`, `resume`, `running`, diff --git a/src/Game.cpp b/src/Game.cpp index ccaef896..7ef64927 100644 --- a/src/Game.cpp +++ b/src/Game.cpp @@ -73,12 +73,14 @@ namespace Lua { F(GetTable, lua_gettable, LUA_GET_TABLE) \ F(RawGet, lua_rawget, LUA_RAW_GET) \ F(RawGetI, lua_rawgeti, LUA_RAWGETI) \ + F(RawSetI, lua_rawseti, LUA_RAW_SET_I) \ F(SetTable, lua_settable, LUA_SET_TABLE) \ F(RawSet, lua_rawset, LUA_RAW_SET) \ F(GetMetatable,lua_getmetatable,LUA_GET_METATABLE)\ F(SetMetatable,lua_setmetatable,LUA_SET_METATABLE)\ F(Insert, lua_insert, LUA_INSERT) \ F(Remove, lua_remove, LUA_REMOVE) \ + F(Replace, lua_replace, LUA_REPLACE) \ F(GetTop, lua_gettop, LUA_GET_TOP) \ F(SetTop, lua_settop, LUA_SET_TOP) \ F(Call, lua_call, LUA_CALL) \ @@ -98,6 +100,9 @@ namespace Lua { F(Resume, lua_resume, LUA_RESUME) \ F(Yield, lua_yield, LUA_YIELD) \ F(ArgError, luaL_argerror, LUAL_ARG_ERROR) \ + F(CheckLString,luaL_checklstring,LUAL_CHECK_LSTRING)\ + F(CheckNumber, luaL_checknumber,LUAL_CHECK_NUMBER)\ + F(OptNumber, luaL_optnumber, LUAL_OPT_NUMBER) \ F(SetN, luaL_setn, LUAL_SETN) \ F(Ref, luaL_ref, LUA_REF_REF) \ F(Unref, luaL_unref, LUA_REF_UNREF) \ diff --git a/src/Game.h b/src/Game.h index 4a16efb8..e8da2ef5 100644 --- a/src/Game.h +++ b/src/Game.h @@ -270,6 +270,8 @@ using lua_rawget_t = void(__fastcall *)(void *L, int idx); // Pushes t[n] for the table at idx, raw (no metamethods). With idx = // REGISTRY_INDEX it pushes a value stored under an integer ref. using lua_rawgeti_t = void(__fastcall *)(void *L, int idx, int n); +// Pops the top value into t[n] for the table at idx, raw. +using lua_rawseti_t = void(__fastcall *)(void *L, int idx, int n); using lua_settable_t = void(__fastcall *)(void *L, int idx); using lua_rawset_t = void(__fastcall *)(void *L, int idx); // Pushes the metatable of the value at idx and returns 1, or pushes @@ -280,6 +282,8 @@ using lua_getmetatable_t = int(__fastcall *)(void *L, int idx); using lua_setmetatable_t = int(__fastcall *)(void *L, int idx); using lua_insert_t = void(__fastcall *)(void *L, int idx); using lua_remove_t = void(__fastcall *)(void *L, int idx); +// Pops the top value into slot idx. +using lua_replace_t = void(__fastcall *)(void *L, int idx); using lua_gettop_t = int(__fastcall *)(void *L); using lua_settop_t = void(__fastcall *)(void *L, int idx); using lua_call_t = void(__fastcall *)(void *L, int nargs, int nresults); @@ -313,6 +317,11 @@ using lua_newthread_t = void *(__fastcall *)(void *L); using lua_resume_t = int(__fastcall *)(void *L, int nargs); using lua_yield_t = int(__fastcall *)(void *L, int nresults); using luaL_argerror_t = void(__fastcall *)(void *L, int narg, const char *msg); +// The auxlib argument readers: each raises the engine's own "bad argument" +// error. CheckLString's `len` may be null. +using luaL_checklstring_t = const char *(__fastcall *)(void *L, int narg, unsigned int *len); +using luaL_checknumber_t = double(__fastcall *)(void *L, int narg); +using luaL_optnumber_t = double(__fastcall *)(void *L, int narg, double def); using luaL_setn_t = void(__fastcall *)(void *L, int t, int n); // Pops the top value into the table at `t` under a fresh integer key and // returns the key (LUA_REFNIL, -1, for a nil). With REGISTRY_INDEX it anchors @@ -358,12 +367,14 @@ extern const lua_newtable_t NewTable; extern const lua_gettable_t GetTable; extern const lua_rawget_t RawGet; extern const lua_rawgeti_t RawGetI; +extern const lua_rawseti_t RawSetI; extern const lua_settable_t SetTable; extern const lua_rawset_t RawSet; extern const lua_getmetatable_t GetMetatable; extern const lua_setmetatable_t SetMetatable; extern const lua_insert_t Insert; extern const lua_remove_t Remove; +extern const lua_replace_t Replace; extern const lua_gettop_t GetTop; extern const lua_settop_t SetTop; extern const lua_call_t Call; @@ -383,6 +394,9 @@ extern const lua_newthread_t NewThread; extern const lua_resume_t Resume; extern const lua_yield_t Yield; extern const luaL_argerror_t ArgError; +extern const luaL_checklstring_t CheckLString; +extern const luaL_checknumber_t CheckNumber; +extern const luaL_optnumber_t OptNumber; extern const luaL_setn_t SetN; extern const luaL_ref_t Ref; extern const luaL_unref_t Unref; diff --git a/src/Offsets.h b/src/Offsets.h index 0853df4a..1e6052b4 100644 --- a/src/Offsets.h +++ b/src/Offsets.h @@ -8360,6 +8360,9 @@ enum Offsets { // CObjects — which is exactly why the engine pushes handler/frame // through it rather than a plain rawget. LUA_RAWGETI = 0x6F3BC0, + // `lua_rawseti(L, idx, n)` — __fastcall (n on the stack): t[n] = top, + // pops it. Calls luaH_setnum (0x006FAD80); stamps the GC context tag. + LUA_RAW_SET_I = 0x6F3F60, // `luaA_indexAcceptable(L, idx)` — the API's index walk: stack, pseudo // (registry / globals) or upvalue index → TObject*, or NULL for a // positive index at or past the top. __fastcall(L /*ecx*/, idx /*edx*/), @@ -8479,6 +8482,9 @@ enum Offsets { // `luaL_optnumber(L, narg, double def)` — __fastcall (def on the stack, // ret 8), returns the double in ST0. As str_gsub calls it (0x007FD12F). LUAL_OPT_NUMBER = 0x6F4CD0, + // `luaL_checknumber(L, narg)` — __fastcall, returns the double in ST0. + // As str_format calls it (0x007FD570). + LUAL_CHECK_NUMBER = 0x6F4C80, // `luaL_getn(L, tableIndex)` — Lua 5.0 auxlib table-length getter, // `int __fastcall(L /*ecx*/, idx /*edx*/)`, plain RET (no stack // args), length in eax. Verified by disassembly: a negative idx is diff --git a/src/baselib/DiffTime.cpp b/src/baselib/DiffTime.cpp new file mode 100644 index 00000000..7a976a19 --- /dev/null +++ b/src/baselib/DiffTime.cpp @@ -0,0 +1,58 @@ +// 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 . + +// `difftime(t2 [, t1])` — the seconds from `t1` (0 by default) to `t2`, the +// companion of the engine's `date` and `time` globals. 4.3.4's +// Script_difftime: C `difftime` over the two arguments as time_t. +// +// Registered on BOTH states, as the engine registers `date` and `time`. + +#include "Game.h" + +#include + +namespace BaseLib::DiffTime { + +namespace { + +int __fastcall Script_difftime(void *L) { + const auto t2 = static_cast(Game::Lua::CheckNumber(L, 1)); + const auto t1 = static_cast(Game::Lua::OptNumber(L, 2, 0)); + Game::Lua::PushNumber(L, std::difftime(t2, t1)); + return 1; +} + +const Game::Doc::Field kDifftimeArgs[] = { + Game::Doc::Req("time2", "number", "A time in seconds, as `time()` returns."), + Game::Doc::Opt("time1", "number", "0"), +}; +const Game::Doc::Field kDifftimeRets[] = { + Game::Doc::Req("seconds", "number", "time2 minus time1."), +}; +const Game::Doc::Function kDifftime{"The number of seconds from time1 to time2.", + kDifftimeArgs, kDifftimeRets, "LuaGlobals"}; + +void RegisterInGame() { + Game::Lua::RegisterGlobalFunction("difftime", &Script_difftime, &kDifftime); +} + +void RegisterGlue() { + Game::Lua::RegisterGlueFunction("difftime", &Script_difftime, &kDifftime); +} + +const Game::ModuleAutoRegister _autoreg{&RegisterInGame}; +const Game::GlueModuleAutoRegister _autoregGlue{&RegisterGlue}; + +} // namespace + +} // namespace BaseLib::DiffTime diff --git a/src/baselib/MathLib.cpp b/src/baselib/MathLib.cpp index 0ae52398..1d640280 100644 --- a/src/baselib/MathLib.cpp +++ b/src/baselib/MathLib.cpp @@ -16,13 +16,16 @@ // - `math.fmod(x, y)` — floating-point remainder of `x / y`. // - `math.modf(x)` — split into integral + fractional parts. // - `math.huge` — positive infinity constant. +// - `math.cosh(x)`, `math.sinh(x)`, `math.tanh(x)` — hyperbolic functions. // // `math.fmod` is a pure rename: Lua 5.0 ships the exact same C function under // the name `math.mod`; 5.1 renamed the Lua-facing entry to `math.fmod`. We // register it as a direct alias of the engine's `math.mod` C function // (`FUN_LUA_MATH_FMOD`) — no wrapper. `math.mod` stays available too, so code // written for either name works. `modf` and `huge` are genuinely new in 5.1 -// (not in 1.12's mathlib table), so we implement/define them here. +// (not in 1.12's mathlib table), so we implement/define them here, as are the +// hyperbolic functions (5.1's math_cosh/sinh/tanh: luaL_checknumber, the C +// function, one number). #include "Game.h" #include "Offsets.h" @@ -53,9 +56,27 @@ int __fastcall Script_math_modf(void *L) { return 2; } +int __fastcall Script_math_cosh(void *L) { + Game::Lua::PushNumber(L, std::cosh(Game::Lua::CheckNumber(L, 1))); + return 1; +} + +int __fastcall Script_math_sinh(void *L) { + Game::Lua::PushNumber(L, std::sinh(Game::Lua::CheckNumber(L, 1))); + return 1; +} + +int __fastcall Script_math_tanh(void *L) { + Game::Lua::PushNumber(L, std::tanh(Game::Lua::CheckNumber(L, 1))); + return 1; +} + void RegisterFns() { Game::Lua::RegisterTableFunction("math", "fmod", Script_math_fmod); Game::Lua::RegisterTableFunction("math", "modf", &Script_math_modf); + Game::Lua::RegisterTableFunction("math", "cosh", &Script_math_cosh); + Game::Lua::RegisterTableFunction("math", "sinh", &Script_math_sinh); + Game::Lua::RegisterTableFunction("math", "tanh", &Script_math_tanh); // `math.huge` — a numeric constant, not a function. Fetch the (now // guaranteed-present) `math` table and set the field directly. diff --git a/src/baselib/NewProxy.cpp b/src/baselib/NewProxy.cpp new file mode 100644 index 00000000..c6d402b3 --- /dev/null +++ b/src/baselib/NewProxy.cpp @@ -0,0 +1,78 @@ +// 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 . + +// `newproxy([false | true | proxy])` — Lua 5.1's empty userdata (luaB_newproxy, +// lbaselib.c). `false` or nothing: no metatable. `true`: a new metatable of +// its own. Another proxy: share that proxy's metatable. Only metatables made +// by `newproxy(true)` count; any other argument raises "boolean or proxy +// expected". 5.0 has userdata and their `__gc`, only not this function. +// +// As in 5.1, the closure's upvalue is a weak table that marks the valid +// metatables (weak[m] = true), and is its own metatable with __mode "kv". +// +// Registered on BOTH states (language-level helper, both are 5.0). + +#include "Game.h" + +namespace BaseLib::NewProxy { + +namespace { + +namespace Lua = Game::Lua; + +int __fastcall Script_newproxy(void *L) { + Lua::SetTop(L, 1); + Lua::NewUserdata(L, 0); // the proxy, at 2 + if (Lua::ToBoolean(L, 1) == 0) + return 1; // no metatable + if (Lua::Type(L, 1) == Lua::TYPE_BOOLEAN) { + Lua::NewTable(L); // a new metatable m ... + Lua::PushValue(L, -1); + Lua::PushBoolean(L, 1); + Lua::RawSet(L, Lua::UpvalueIndex(1)); // ... marked valid: weak[m] = true + } else { + bool valid = false; + if (Lua::GetMetatable(L, 1)) { + Lua::RawGet(L, Lua::UpvalueIndex(1)); + valid = Lua::ToBoolean(L, -1) != 0; + Lua::SetTop(L, -2); + } + if (!valid) + Lua::ArgError(L, 1, "boolean or proxy expected"); + Lua::GetMetatable(L, 1); + } + Lua::SetMetatable(L, 2); + return 1; +} + +void Register() { + void *L = Lua::State(); + if (L == nullptr) + return; + Lua::PushString(L, "newproxy"); + Lua::NewTable(L); // the weak table w + Lua::PushString(L, "__mode"); + Lua::PushString(L, "kv"); + Lua::RawSet(L, -3); + Lua::PushValue(L, -1); + Lua::SetMetatable(L, -2); // w is its own metatable + Lua::PushCClosure(L, &Script_newproxy, 1); + Lua::SetTable(L, Lua::GLOBALS_INDEX); +} + +const Game::ModuleAutoRegister _autoreg{&Register}; +const Game::GlueModuleAutoRegister _autoregGlue{&Register}; + +} // namespace + +} // namespace BaseLib::NewProxy diff --git a/src/baselib/Scrub.cpp b/src/baselib/Scrub.cpp new file mode 100644 index 00000000..80b46b83 --- /dev/null +++ b/src/baselib/Scrub.cpp @@ -0,0 +1,63 @@ +// 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 . + +// `scrub(...)` — returns its arguments, each one that is not a boolean, +// number or string replaced by nil. 4.3.4's Script_scrub. +// +// Registered on both Lua states, like the base-library helpers. + +#include "Game.h" + +namespace BaseLib::Scrub { + +namespace { + +namespace Lua = Game::Lua; + +int __fastcall Script_scrub(void *L) { + const int top = Lua::GetTop(L); + Lua::CheckStack(L, 1); + for (int i = 1; i <= top; i++) { + const int type = Lua::Type(L, i); + if (type != Lua::TYPE_BOOLEAN && type != Lua::TYPE_NUMBER && type != Lua::TYPE_STRING) { + Lua::PushNil(L); + Lua::Replace(L, i); + } + } + return top; +} + +const Game::Doc::Field kScrubArgs[] = { + Game::Doc::Vararg("any"), +}; +const Game::Doc::Field kScrubRets[] = { + Game::Doc::Vararg("any", "Each argument, or nil when it is not a boolean, number or string."), +}; +const Game::Doc::Function kScrub{ + "Returns its arguments, with each one that is not a boolean, number or string replaced by nil.", + kScrubArgs, kScrubRets, "LuaGlobals"}; + +void RegisterInGame() { + Game::Lua::RegisterGlobalFunction("scrub", &Script_scrub, &kScrub); +} + +void RegisterGlue() { + Game::Lua::RegisterGlueFunction("scrub", &Script_scrub, &kScrub); +} + +const Game::ModuleAutoRegister _autoreg{&RegisterInGame}; +const Game::GlueModuleAutoRegister _autoregGlue{&RegisterGlue}; + +} // namespace + +} // namespace BaseLib::Scrub diff --git a/src/baselib/StringLib.cpp b/src/baselib/StringLib.cpp index e821f814..ea905b89 100644 --- a/src/baselib/StringLib.cpp +++ b/src/baselib/StringLib.cpp @@ -15,7 +15,7 @@ // // - `string.match(s, pattern [, init])` — first-match extraction (5.1), // also the global `strmatch`, as `string.find` is `strfind`. -// - `string.gmatch(s, pattern)` — match iterator (5.1). +// - `string.gmatch(s, pattern)` — match iterator (5.1), also `gmatch`. // - `strsplit(sep, str [, pieces])` — WoW global; split on any char. // - `strjoin(delimiter, ...)` — WoW global; join varargs. // - `strtrim(str [, chars])` — WoW global; trim a char set. @@ -347,8 +347,6 @@ int __fastcall Script_string_reverse(void *L) { // result for every `i`. Positions truncate toward zero as the engine's // str_byte and str_sub do. The engine's lua_checkstack (0x6F2F30) refuses // more than 2048 stack slots, so the longest range is about 2000 bytes. -using luaL_checklstring_t = const char *(__fastcall *)(void *L, int narg, unsigned int *len); -using luaL_optnumber_t = double(__fastcall *)(void *L, int narg, double def); // 5.1's posrelat: a negative position counts from the end; before the start is 0. long PosRelat(long pos, long len) { @@ -358,14 +356,12 @@ long PosRelat(long pos, long len) { } int __fastcall Script_string_byte(void *L) { - const auto checkLString = - reinterpret_cast(Offsets::LUAL_CHECK_LSTRING); - const auto optNumber = reinterpret_cast(Offsets::LUAL_OPT_NUMBER); unsigned int l = 0; - const char *s = checkLString(L, 1, &l); + const char *s = Game::Lua::CheckLString(L, 1, &l); const long len = static_cast(l); - long posi = PosRelat(static_cast(optNumber(L, 2, 1)), len); - long pose = PosRelat(static_cast(optNumber(L, 3, static_cast(posi))), len); + long posi = PosRelat(static_cast(Game::Lua::OptNumber(L, 2, 1)), len); + long pose = + PosRelat(static_cast(Game::Lua::OptNumber(L, 3, static_cast(posi))), len); if (posi <= 0) posi = 1; if (pose > len) @@ -439,13 +435,15 @@ void RegisterFns() { Game::Lua::RegisterTableFunction("string", "join", &Script_strjoin); Game::Lua::RegisterTableFunction("string", "concat", &Script_strconcat, &kStrconcat); // 4.3.4's compat.lua binds each short global and its string-table twin - // to ONE function by assignment (`strmatch = str.match`, `strrev = - // str.reverse`, `str.trim = strtrim`, `str.split = strsplit`, `str.join = - // strjoin`), so `strtrim == string.trim`. A second Register* call would - // mint a second closure over the same C function, so the globals alias - // the table entries by value instead. The string-table half is what lets - // `(" x "):trim()` work and libraries capture it at file scope - // (AceConfigCmd-3.0: `strtrim = string.trim`). + // to ONE function by assignment (`gmatch = str.gmatch`, `strmatch = + // str.match`, `strrev = str.reverse`, `str.trim = strtrim`, `str.split = + // strsplit`, `str.join = strjoin`), so `strtrim == string.trim`. A second + // Register* call would mint a second closure over the same C function, so + // the globals alias the table entries by value instead. The string-table + // half is what lets `(" x "):trim()` work and libraries capture it at + // file scope (AceConfigCmd-3.0: `strtrim = string.trim`). 1.12's own + // compat.lua set `strbyte` from the old string.byte, so it is re-aliased. + Game::Lua::RegisterGlobalAlias("gmatch", "string", "gmatch"); Game::Lua::RegisterGlobalAlias("strmatch", "string", "match"); Game::Lua::RegisterGlobalAlias("strsplit", "string", "split"); Game::Lua::RegisterGlobalAlias("strjoin", "string", "join"); diff --git a/src/table/RemoveMulti.cpp b/src/table/RemoveMulti.cpp new file mode 100644 index 00000000..612c8f95 --- /dev/null +++ b/src/table/RemoveMulti.cpp @@ -0,0 +1,68 @@ +// 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 . + +// `table.removemulti(t [, pos [, count]])` — WoW's addition to the table +// library (4.3.4's tremovemulti, ltablib.c): removes `count` elements (1 by +// default) from position `pos` (the last element by default), shifts the +// rest down and returns the removed elements in order. +// +// 5.0 keeps a table's length apart from its keys, so like the engine's own +// table.remove (0x7FB770) this records the new length with luaL_setn. +// +// Registered on BOTH states (language-level helper, both are 5.0). + +#include "Game.h" +#include "Offsets.h" + +namespace Table::RemoveMulti { + +namespace { + +using luaL_getn_t = int(__fastcall *)(void *L, int t); + +int __fastcall Script_table_removemulti(void *L) { + if (Game::Lua::Type(L, 1) != Game::Lua::TYPE_TABLE) + Game::Lua::ArgError(L, 1, "table expected"); + const int e = reinterpret_cast(Offsets::LUAL_GETN)(L, 1); + int pos = static_cast(Game::Lua::OptNumber(L, 2, e)); + const int n = static_cast(Game::Lua::OptNumber(L, 3, 1)); + if (e == 0) + return 0; + if (pos <= 0 || n < 0 || pos > e || pos + n - 1 > e) + Game::Lua::Error(L, "parameters out of bounds"); + if (!Game::Lua::CheckStack(L, n)) + Game::Lua::Error(L, "stack overflow"); + for (int i = pos; i < pos + n; i++) + Game::Lua::RawGetI(L, 1, i); + for (; pos < e; pos++) { + Game::Lua::RawGetI(L, 1, pos + n); + Game::Lua::RawSetI(L, 1, pos); + } + for (; pos < e + n; pos++) { + Game::Lua::PushNil(L); + Game::Lua::RawSetI(L, 1, pos); + } + Game::Lua::SetN(L, 1, e - n); + return n; +} + +void Register() { + Game::Lua::RegisterTableFunction("table", "removemulti", &Script_table_removemulti); +} + +const Game::ModuleAutoRegister _autoreg{&Register}; +const Game::GlueModuleAutoRegister _autoregGlue{&Register}; + +} // namespace + +} // namespace Table::RemoveMulti