// 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 . // 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 #include #include 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(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(Game::Lua::ToNumber(L, kBase + 1)); const int end = static_cast(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(end - start + 1) : 0; Game::Lua::PushLString(L, s + start - 1, static_cast(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(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(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(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(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(*c)] = true; unsigned start = 0, end = len; while (start < end && trim[static_cast(str[start])]) ++start; while (end > start && trim[static_cast(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(out.size())); Game::Lua::PushNumber(L, static_cast(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