mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-15 23:50:38 +00:00
284 lines
12 KiB
C++
284 lines
12 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/>.
|
|
|
|
// String helpers that 1.12's Lua 5.0 is missing:
|
|
//
|
|
// - `string.match(s, pattern [, init])` — first-match extraction (5.1).
|
|
// - `string.gmatch(s, pattern)` — match iterator (5.1).
|
|
// - `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.
|
|
// - `strreplace(str, find, replace)` — plain-text replace (see below).
|
|
// - `string.reverse(s)` / `strrev(s)` — 5.1 string function, missing in 5.0.
|
|
//
|
|
// The two pattern `string.*` ones reuse machinery 5.0 already ships:
|
|
// - `match` is `find` returning captures / the whole match instead of the
|
|
// start/end indices — so we call the engine's `str_find` and transform.
|
|
// - `gmatch` is exactly 5.0's `string.gfind` (renamed in 5.1); we register
|
|
// it as a direct alias of the engine's `gfind` C function.
|
|
// `strsplit` is a hand-rolled port of 3.3.5's `strsplit` (see below).
|
|
//
|
|
// NOTE: only the `string.foo(s, ...)` call form works — NOT the
|
|
// `("x"):foo(...)` method sugar. WoW's Lua VM strips type-metatables for
|
|
// every value except tables/userdata (both `lua_setmetatable` and the VM's
|
|
// `luaT_gettmbyobj` hard-return "no metamethod" for strings), so strings have
|
|
// no `__index`, and there's no client-side way to add one short of hooking a
|
|
// hot VM-core function. This is the long-standing vanilla constraint.
|
|
|
|
#include "Game.h"
|
|
#include "Offsets.h"
|
|
|
|
#include <cstddef>
|
|
#include <cstring>
|
|
#include <string>
|
|
|
|
namespace BaseLib::StringLib {
|
|
|
|
namespace {
|
|
|
|
// `string.match(s, pattern [, init])`. Calls the engine `str_find` and
|
|
// reshapes its result: no match → nil; match with captures → the captures;
|
|
// match with no captures → the whole matched substring.
|
|
int __fastcall Script_string_match(void *L) {
|
|
// Normalize to exactly (s, pattern, init): pad missing args with nil so
|
|
// str_find defaults `init` to 1, and drop any stray 4th value so it can't
|
|
// be misread as find's `plain` flag (match has no plain form).
|
|
Game::Lua::SetTop(L, 3);
|
|
constexpr int kBase = 3;
|
|
|
|
auto strFind = reinterpret_cast<Game::Lua::CFunction>(Offsets::FUN_LUA_STR_FIND);
|
|
const int nres = strFind(L); // pushes start,end,caps.. above kBase, or a nil
|
|
|
|
if (nres <= 1) {
|
|
// No match. str_find pushed the nil (return 1); guard the degenerate
|
|
// nres==0 case by pushing our own nil so the shape holds.
|
|
if (nres < 1)
|
|
Game::Lua::PushNil(L);
|
|
return 1;
|
|
}
|
|
|
|
if (nres == 2) {
|
|
// No captures → the whole matched substring s[start..end] (1-based,
|
|
// inclusive). An empty match has end == start-1 → an empty string.
|
|
const int start = static_cast<int>(Game::Lua::ToNumber(L, kBase + 1));
|
|
const int end = static_cast<int>(Game::Lua::ToNumber(L, kBase + 2));
|
|
// str_find already coerced arg 1 to a string, so this is safe.
|
|
const char *s = Game::Lua::ToString(L, 1);
|
|
Game::Lua::SetTop(L, kBase); // drop start, end
|
|
const size_t len = (end >= start) ? static_cast<size_t>(end - start + 1) : 0;
|
|
Game::Lua::PushLString(L, s + start - 1, static_cast<unsigned int>(len));
|
|
return 1;
|
|
}
|
|
|
|
// Captures present → drop start & end, hand back only the captures.
|
|
Game::Lua::Remove(L, kBase + 1); // remove start; end → kBase+1, caps → kBase+2..
|
|
Game::Lua::Remove(L, kBase + 1); // remove end; caps → kBase+1..
|
|
return nres - 2;
|
|
}
|
|
|
|
// `string.gmatch` is 5.0's `string.gfind` verbatim — register the engine
|
|
// function pointer directly rather than wrapping it.
|
|
const auto Script_string_gmatch =
|
|
reinterpret_cast<Game::Lua::CFunction>(Offsets::FUN_LUA_STR_GFIND);
|
|
|
|
// `strsplit(sep, str [, pieces])` — the WoW global (also aliased as
|
|
// `string.split`), split `str` on ANY character in `sep` and return the
|
|
// pieces as multiple values. `pieces > 0` caps the result count, with the
|
|
// unsplit remainder as the final piece; `0` / omitted = unlimited. Ported
|
|
// from 3.3.5's `strsplit` (FUN_00816a60) with one deliberate change: we do
|
|
// NOT `lua_settop(L, 0)` up front. Popping the args would leave the source
|
|
// string unreferenced, so a GC step triggered by a `pushlstring` could free
|
|
// the very buffer we're still scanning. Keeping the args on the stack keeps
|
|
// the source GC-rooted; Lua returns the top N values (our pieces) regardless
|
|
// of the args sitting below them. Each push is guarded by `lua_checkstack`
|
|
// (this pushes an unbounded number of results), erroring like 3.3.5 on
|
|
// genuine stack exhaustion.
|
|
int __fastcall Script_strsplit(void *L) {
|
|
const char *sep = Game::Lua::ToString(L, 1);
|
|
const char *str = Game::Lua::ToString(L, 2);
|
|
if (sep == nullptr || str == nullptr) {
|
|
Game::Lua::Error(L, "Usage: strsplit(\"separators\", str [, pieces])");
|
|
return 0; // unreachable
|
|
}
|
|
const int pieces =
|
|
Game::Lua::IsNumber(L, 3) ? static_cast<int>(Game::Lua::ToNumber(L, 3)) : 0;
|
|
|
|
const char *segStart = str;
|
|
int count = 0;
|
|
// Only scan for separators while unlimited (pieces == 0) or the cap
|
|
// hasn't been reached (pieces > 1). pieces == 1 (or <= 0 but non-zero)
|
|
// yields the whole string as a single piece — matches 3.3.5.
|
|
if (pieces == 0 || pieces > 1) {
|
|
for (const char *p = str; *p != '\0'; ++p) {
|
|
bool isSep = false;
|
|
for (const char *s = sep; *s != '\0'; ++s) {
|
|
if (*p == *s) {
|
|
isSep = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!isSep)
|
|
continue;
|
|
++count;
|
|
if (Game::Lua::CheckStack(L, count) == 0) {
|
|
Game::Lua::Error(L, "strsplit(): Stack overflow");
|
|
return 0; // unreachable
|
|
}
|
|
Game::Lua::PushLString(L, segStart,
|
|
static_cast<unsigned int>(p - segStart));
|
|
segStart = p + 1;
|
|
if (count == pieces - 1)
|
|
break; // cap hit; remainder becomes the final piece
|
|
}
|
|
}
|
|
if (Game::Lua::CheckStack(L, count + 1) == 0) {
|
|
Game::Lua::Error(L, "strsplit(): Stack overflow");
|
|
return 0; // unreachable
|
|
}
|
|
Game::Lua::PushString(L, segStart); // final piece (remainder to end)
|
|
return count + 1;
|
|
}
|
|
|
|
// `strjoin(delimiter, ...)` — the inverse of `strsplit`: concatenate the
|
|
// vararg pieces with `delimiter` between each. Standard WoW global (FrameXML
|
|
// defines it in Lua; there's no C original to mirror). A nil / non-coercible
|
|
// piece is treated as an empty string rather than erroring, so the delimiter
|
|
// placement stays predictable. `strjoin(",")` with no pieces returns "".
|
|
int __fastcall Script_strjoin(void *L) {
|
|
const char *delim = Game::Lua::ToString(L, 1);
|
|
if (delim == nullptr) {
|
|
Game::Lua::Error(L, "Usage: strjoin(delimiter, ...)");
|
|
return 0; // unreachable
|
|
}
|
|
const unsigned delimLen = Game::Lua::StrLen(L, 1);
|
|
const int top = Game::Lua::GetTop(L);
|
|
|
|
std::string out; // no Error() past this point — a longjmp would leak it
|
|
for (int i = 2; i <= top; ++i) {
|
|
if (i > 2)
|
|
out.append(delim, delimLen);
|
|
const char *piece = Game::Lua::ToString(L, i);
|
|
if (piece != nullptr)
|
|
out.append(piece, Game::Lua::StrLen(L, i));
|
|
}
|
|
Game::Lua::PushLString(L, out.data(), static_cast<unsigned int>(out.size()));
|
|
return 1;
|
|
}
|
|
|
|
// `strtrim(str [, chars])` — remove any of the characters in `chars` from
|
|
// both ends of `str` (default: whitespace). `chars` is a literal set of
|
|
// characters, not a pattern. Standard WoW global. Two-ended scan — no
|
|
// allocation, embedded NULs preserved (bounds come from the Lua length).
|
|
int __fastcall Script_strtrim(void *L) {
|
|
const char *str = Game::Lua::ToString(L, 1);
|
|
if (str == nullptr) {
|
|
Game::Lua::Error(L, "Usage: strtrim(str [, chars])");
|
|
return 0; // unreachable
|
|
}
|
|
const unsigned len = Game::Lua::StrLen(L, 1);
|
|
const char *chars = Game::Lua::IsString(L, 2) ? Game::Lua::ToString(L, 2)
|
|
: " \t\n\v\f\r";
|
|
|
|
bool trim[256] = {false};
|
|
for (const char *c = chars; *c != '\0'; ++c)
|
|
trim[static_cast<unsigned char>(*c)] = true;
|
|
|
|
unsigned start = 0, end = len;
|
|
while (start < end && trim[static_cast<unsigned char>(str[start])])
|
|
++start;
|
|
while (end > start && trim[static_cast<unsigned char>(str[end - 1])])
|
|
--end;
|
|
Game::Lua::PushLString(L, str + start, end - start);
|
|
return 1;
|
|
}
|
|
|
|
// `strreplace(str, find, replace)` — replace every occurrence of the literal
|
|
// substring `find` with `replace`; returns `(result, count)`. NOT a stock WoW
|
|
// global and NOT pattern-based (that's `gsub`) — a plain-text replace that
|
|
// needs no magic-character escaping. Empty `find` returns `str` unchanged
|
|
// (count 0) rather than looping forever.
|
|
int __fastcall Script_strreplace(void *L) {
|
|
const char *str = Game::Lua::ToString(L, 1);
|
|
const char *find = Game::Lua::ToString(L, 2);
|
|
const char *repl = Game::Lua::ToString(L, 3);
|
|
if (str == nullptr || find == nullptr || repl == nullptr) {
|
|
Game::Lua::Error(L, "Usage: strreplace(str, find, replace)");
|
|
return 0; // unreachable
|
|
}
|
|
const unsigned strLen = Game::Lua::StrLen(L, 1);
|
|
const unsigned findLen = Game::Lua::StrLen(L, 2);
|
|
const unsigned replLen = Game::Lua::StrLen(L, 3);
|
|
|
|
if (findLen == 0) { // nothing to match — return input unchanged
|
|
Game::Lua::PushLString(L, str, strLen);
|
|
Game::Lua::PushNumber(L, 0.0);
|
|
return 2;
|
|
}
|
|
|
|
std::string out; // no Error() past this point
|
|
int count = 0;
|
|
unsigned i = 0;
|
|
while (i < strLen) {
|
|
if (i + findLen <= strLen && std::memcmp(str + i, find, findLen) == 0) {
|
|
out.append(repl, replLen);
|
|
i += findLen;
|
|
++count;
|
|
} else {
|
|
out.push_back(str[i]);
|
|
++i;
|
|
}
|
|
}
|
|
Game::Lua::PushLString(L, out.data(), static_cast<unsigned int>(out.size()));
|
|
Game::Lua::PushNumber(L, static_cast<double>(count));
|
|
return 2;
|
|
}
|
|
|
|
// `string.reverse(s)` / `strrev(s)` — return `s` with its bytes reversed.
|
|
// Lua 5.1 added `string.reverse`; 5.0's strlib lacks it. Byte-wise (not
|
|
// UTF-8 aware), matching stock Lua; embedded NULs preserved (bounds from the
|
|
// Lua length).
|
|
int __fastcall Script_string_reverse(void *L) {
|
|
const char *s = Game::Lua::ToString(L, 1);
|
|
if (s == nullptr) {
|
|
Game::Lua::Error(L, "Usage: string.reverse(s)");
|
|
return 0; // unreachable
|
|
}
|
|
const unsigned len = Game::Lua::StrLen(L, 1);
|
|
std::string out(len, '\0'); // no Error() past this point
|
|
for (unsigned i = 0; i < len; ++i)
|
|
out[i] = s[len - 1 - i];
|
|
Game::Lua::PushLString(L, out.data(), len);
|
|
return 1;
|
|
}
|
|
|
|
void RegisterFns() {
|
|
Game::Lua::RegisterTableFunction("string", "match", &Script_string_match);
|
|
Game::Lua::RegisterTableFunction("string", "gmatch", Script_string_gmatch);
|
|
Game::Lua::RegisterTableFunction("string", "reverse", &Script_string_reverse);
|
|
Game::Lua::RegisterTableFunction("string", "split", &Script_strsplit);
|
|
Game::Lua::RegisterGlobalFunction("strsplit", &Script_strsplit);
|
|
Game::Lua::RegisterGlobalFunction("strjoin", &Script_strjoin);
|
|
Game::Lua::RegisterGlobalFunction("strtrim", &Script_strtrim);
|
|
Game::Lua::RegisterGlobalFunction("strreplace", &Script_strreplace);
|
|
Game::Lua::RegisterGlobalFunction("strrev", &Script_string_reverse);
|
|
}
|
|
|
|
// Both states are Lua 5.0 and equally missing these; RegisterTableFunction
|
|
// targets whichever state is active in each registration hook.
|
|
const Game::ModuleAutoRegister _autoreg{&RegisterFns};
|
|
const Game::GlueModuleAutoRegister _autoregGlue{&RegisterFns};
|
|
|
|
} // namespace
|
|
|
|
} // namespace BaseLib::StringLib
|