// 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), // also the global `strmatch`, as `string.find` is `strfind`. // - `string.gmatch(s, pattern)` — match iterator (5.1). // - `string.gsub` TABLE replacement — 5.1 form (see the shim below). // - `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. // - `strlenutf8(s)` — WoW global; characters, not bytes. // - `strcmputf8i(a, b)` — WoW global; case-insensitive UTF-8 order. // - `strsplittable(sep, str [, pieces])`— WoW global; `strsplit` into a table. // - `strconcat(...)` / `string.concat` — WoW global; `..` over every argument. // // The two UTF-8 globals are 4.3.4's `Script_strlenutf8` and the newer // clients' `strcmputf8i`, each a thin push over a Storm helper 1.12 does not // have (`SStrLenUTF8` / `SStrCmpUTF8I`) — `Text::Utf8` mirrors those. // `strconcat` is 4.3.4's: `lua_concat` over the whole stack. // // 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: both call forms work — `string.foo(s, ...)` AND the `("x"):foo(...)` // method sugar. Method calls resolve through this same `string` table via // LuaSyntax::StringMethods (the Lua 5.1 string-metatable backport), so // everything registered here is automatically reachable as a method, on // both states. #include "Game.h" #include "Offsets.h" #include "text/Utf8.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); // The scan behind `strsplit` and `strsplittable`: splits `str` on ANY // character in `sep` and hands each piece to `emit(start, length)` in order, // the unsplit remainder last. `pieces > 0` caps the count, with the // remainder (delimiters and all) as the final piece; `0` is unlimited. // Only scans for separators while unlimited or the cap hasn't been reached; // `pieces == 1` (or <= 0 but non-zero) yields the whole string as a single // piece — matches 3.3.5's `strsplit` (FUN_00816a60). template void SplitPieces(const char *sep, const char *str, int pieces, Emit emit) { const char *segStart = str; int count = 0; 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; emit(segStart, static_cast(p - segStart)); segStart = p + 1; if (count == pieces - 1) break; // cap hit; remainder becomes the final piece } } emit(segStart, static_cast(std::strlen(segStart))); } // `strsplit(sep, str [, pieces])` — the WoW global (also aliased as // `string.split`): the pieces as multiple values. Ported from 3.3.5 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; int count = 0; SplitPieces(sep, str, pieces, [L, &count](const char *start, unsigned int len) { ++count; if (Game::Lua::CheckStack(L, count) == 0) { Game::Lua::Error(L, "strsplit(): Stack overflow"); return; // unreachable } Game::Lua::PushLString(L, start, len); }); return count; } // `strsplittable(sep, str [, pieces])` — the same split as one array // table. Every piece goes to the next integer key of a fresh table, so the // Lua stack never grows and no piece count is too many — the point of the // table form. The args stay on the stack (GC-rooting the source, as above); // the table sits above them at index 4. int __fastcall Script_strsplittable(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: strsplittable(\"separators\", str [, pieces])"); return 0; // unreachable } const int pieces = Game::Lua::IsNumber(L, 3) ? static_cast(Game::Lua::ToNumber(L, 3)) : 0; Game::Lua::SetTop(L, 3); Game::Lua::NewTable(L); // 4 int count = 0; SplitPieces(sep, str, pieces, [L, &count](const char *start, unsigned int len) { Game::Lua::PushNumber(L, static_cast(++count)); Game::Lua::PushLString(L, start, len); Game::Lua::RawSet(L, 4); }); return 1; } // `strlenutf8(s)` — 4.3.4's `Script_strlenutf8`: `SStrLenUTF8` on the // string, the count of characters (code points) rather than bytes. Same // usage text and `lua_isstring` gate as the original. int __fastcall Script_strlenutf8(void *L) { if (!Game::Lua::IsString(L, 1)) { Game::Lua::Error(L, "Usage: strlenutf8(string)"); return 0; // unreachable } Game::Lua::PushNumber( L, static_cast(Text::Utf8::Length(Game::Lua::ToString(L, 1)))); return 1; } // `strcmputf8i(string1, string2)` — the newer clients' global (its usage // text is in their binaries) over `SStrCmpUTF8I`: a case-insensitive sort // order for UTF-8 text. The number is the first folded code-point // difference, as Storm returns it; FrameXML only ever tests the sign (`< 0` // in sort comparators, `== 0` for a name match). int __fastcall Script_strcmputf8i(void *L) { if (!Game::Lua::IsString(L, 1) || !Game::Lua::IsString(L, 2)) { Game::Lua::Error(L, "Usage: strcmputf8i(string1, string2)"); return 0; // unreachable } const int result = Text::Utf8::CompareI(Game::Lua::ToString(L, 1), Game::Lua::ToString(L, 2)); Game::Lua::PushNumber(L, static_cast(result)); return 1; } // `strconcat(...)` / `string.concat(...)` — 4.3.4's `Script_strconcat`: // `lua_concat` over everything on the stack, i.e. the `..` operator applied // to every argument (numbers convert, anything else raises the concatenate // error), `""` for no arguments, and a single argument handed back as it is. int __fastcall Script_strconcat(void *L) { Game::Lua::Concat(L, Game::Lua::GetTop(L)); return 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; } // --- string.gsub table-replacement upgrade (Lua 5.1) ------------------------ // // 5.1 allows a TABLE as gsub's replacement: each match looks up the first // capture (the whole match when the pattern declares no captures) in the // table; a nil/false value keeps the original match; string/number values // substitute. This engine's gsub (FUN_LUA_STR_GSUB) is stock 5.0 — // string/function only ("string or function expected" otherwise), and its // add_value appends NOTHING when a replacement function returns a // non-string (match → empty; verified by decode, see Offsets.h). So a // plain table→closure adapter would EAT unmatched tokens where 5.1 keeps // them, and the closure can't reconstruct the whole match from capture // args alone. // // The shim therefore rewrites the pattern with one OUTER capture — // `pat` → `(pat)`, keeping a leading `^` and an unescaped trailing `$` // outside (both are anchors only at their positional ends; inside the // parens they'd turn literal) — so the adapter closure always receives // the whole match as arg 1, the pattern's own first capture as arg 2, and // can hand arg 1 back to reproduce 5.1's keep-match for missing keys. // Patterns containing a `%1`..`%9` back-reference can't be wrapped (the // outer capture would renumber what `%N` refers to); those fall back to // an unwrapped adapter whose missing-key behavior is the engine's own // (match → empty) — the one documented divergence, and the combination // (table replacement + pattern back-references) is essentially absent // from real code. String/function replacements tail-call the engine gsub // untouched. // True when the pattern contains a `%1`..`%9` back-reference. Escape-aware: // the char after any `%` is consumed, so `%%1` (literal percent, then '1') // doesn't count. bool PatternHasBackref(const char *p, unsigned len) { for (unsigned i = 0; i + 1 < len; ++i) { if (p[i] != '%') continue; const char c = p[i + 1]; if (c >= '1' && c <= '9') return true; ++i; // skip the escaped char } return false; } // Adapter for the wrapped-pattern path: arg 1 = whole match, arg 2 = the // pattern's own first capture (when it declared any). Upvalue 1 = the // replacement table. Missing/false value → return the whole match (5.1's // keep-match). int __fastcall GsubTableLookupWrapped(void *L) { const int nargs = Game::Lua::GetTop(L); Game::Lua::PushValue(L, nargs >= 2 ? 2 : 1); // the 5.1 lookup key Game::Lua::GetTable(L, Game::Lua::UpvalueIndex(1)); // tbl[key] const int t = Game::Lua::Type(L, -1); if (t == Game::Lua::TYPE_NIL || (t == Game::Lua::TYPE_BOOLEAN && Game::Lua::ToBoolean(L, -1) == 0)) Game::Lua::PushValue(L, 1); // keep the original match return 1; // top value is the result } // Adapter for back-reference patterns (unwrapped): arg 1 is already the // 5.1 key. A missing key returns nil → the engine appends nothing. int __fastcall GsubTableLookupPlain(void *L) { Game::Lua::PushValue(L, 1); Game::Lua::GetTable(L, Game::Lua::UpvalueIndex(1)); return 1; } int __fastcall Script_string_gsub(void *L) { const auto engineGsub = reinterpret_cast(Offsets::FUN_LUA_STR_GSUB); if (Game::Lua::Type(L, 3) != Game::Lua::TYPE_TABLE) return engineGsub(L); // string/function/error paths untouched const char *pat = Game::Lua::ToString(L, 2); if (pat == nullptr) return engineGsub(L); // let the engine raise its own arg error const unsigned patLen = Game::Lua::StrLen(L, 2); Game::Lua::SetTop(L, 4); // normalize to (s, pat, tbl, n) — gsub reads ≤4 if (!PatternHasBackref(pat, patLen)) { // Build `(body)` with the anchors outside the capture. unsigned b = 0, e = patLen; std::string wrapped; wrapped.reserve(patLen + 3); if (e > b && pat[0] == '^') { wrapped += '^'; b = 1; } bool anchoredBack = false; if (e > b && pat[e - 1] == '$') { // `$` is an anchor only when not %-escaped: an even number of // `%` immediately before it means the `$` itself is unescaped. unsigned pc = 0; for (int idx = static_cast(e) - 2; idx >= static_cast(b) && pat[idx] == '%'; --idx) ++pc; anchoredBack = (pc % 2) == 0; if (anchoredBack) --e; } wrapped += '('; wrapped.append(pat + b, e - b); wrapped += ')'; if (anchoredBack) wrapped += '$'; Game::Lua::PushLString(L, wrapped.data(), static_cast(wrapped.size())); // 5 Game::Lua::PushValue(L, 3); // 6: tbl Game::Lua::PushCClosure(L, &GsubTableLookupWrapped, 1); // 6: closure Game::Lua::Insert(L, 2); // closure→2: s, closure, pat, tbl, n, wrapped Game::Lua::Insert(L, 2); // wrapped→2: s, wrapped, closure, pat, tbl, n Game::Lua::Remove(L, 4); // drop the original pattern Game::Lua::Remove(L, 4); // drop the table → (s, wrapped, closure, n) } else { Game::Lua::PushValue(L, 3); // 5: tbl Game::Lua::PushCClosure(L, &GsubTableLookupPlain, 1); // 5: closure Game::Lua::Insert(L, 3); // → s, pat, closure, tbl, n Game::Lua::Remove(L, 4); // → s, pat, closure, n } return engineGsub(L); } // --- Documentation ---------------------------------------------------------- const Game::Doc::Field kStrlenutf8Args[] = { Game::Doc::Req("string", "string", "UTF-8 text."), }; const Game::Doc::Field kStrlenutf8Rets[] = { Game::Doc::Req("length", "number", "The number of characters; strlen counts bytes."), }; const Game::Doc::Function kStrlenutf8{ "The number of characters in a UTF-8 string, not the number of bytes.", kStrlenutf8Args, kStrlenutf8Rets, "LuaGlobals"}; const Game::Doc::Field kStrcmputf8iArgs[] = { Game::Doc::Req("string1", "string"), Game::Doc::Req("string2", "string"), }; const Game::Doc::Field kStrcmputf8iRets[] = { Game::Doc::Req("result", "number", "Negative when string1 sorts first, 0 when the two match ignoring " "case, positive when string2 sorts first."), }; const Game::Doc::Function kStrcmputf8i{ "Compares two UTF-8 strings ignoring case, for sorting and matching.", kStrcmputf8iArgs, kStrcmputf8iRets, "LuaGlobals"}; const Game::Doc::Field kStrsplittableArgs[] = { Game::Doc::Req("delimiter", "string", "Each character is a delimiter."), Game::Doc::Req("str", "string"), Game::Doc::Opt("pieces", "number", "0", "Maximum number of pieces; the last one holds the rest of the string. " "0 is unlimited."), }; const Game::Doc::Field kStrsplittableRets[] = { Game::Doc::Req("chunks", "table", "Array of the pieces, in order."), }; const Game::Doc::Function kStrsplittable{ "Splits a string on delimiter characters and returns the pieces as an array.", kStrsplittableArgs, kStrsplittableRets, "LuaGlobals"}; const Game::Doc::Field kStrconcatArgs[] = { Game::Doc::Vararg("string", "Strings or numbers."), }; const Game::Doc::Field kStrconcatRets[] = { Game::Doc::Req("result", "string"), }; const Game::Doc::Function kStrconcat{ "Joins every argument into one string with nothing between them.", kStrconcatArgs, kStrconcatRets, "LuaGlobals"}; void RegisterFns() { Game::Lua::RegisterTableFunction("string", "match", &Script_string_match); Game::Lua::RegisterTableFunction("string", "gmatch", Script_string_gmatch); Game::Lua::RegisterTableFunction("string", "gsub", &Script_string_gsub); Game::Lua::RegisterTableFunction("string", "reverse", &Script_string_reverse); Game::Lua::RegisterTableFunction("string", "split", &Script_strsplit); Game::Lua::RegisterTableFunction("string", "trim", &Script_strtrim); 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 (`gsub = str.gsub`, `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`); the bare `gsub` // gets the table-replacement upgrade by being the same function. Game::Lua::RegisterGlobalAlias("gsub", "string", "gsub"); Game::Lua::RegisterGlobalAlias("strmatch", "string", "match"); Game::Lua::RegisterGlobalAlias("strsplit", "string", "split"); Game::Lua::RegisterGlobalAlias("strjoin", "string", "join"); Game::Lua::RegisterGlobalAlias("strtrim", "string", "trim"); Game::Lua::RegisterGlobalAlias("strrev", "string", "reverse"); Game::Lua::RegisterGlobalAlias("strconcat", "string", "concat", &kStrconcat); Game::Lua::RegisterGlobalFunction("strreplace", &Script_strreplace); Game::Lua::RegisterGlobalFunction("strlenutf8", &Script_strlenutf8, &kStrlenutf8); Game::Lua::RegisterGlobalFunction("strcmputf8i", &Script_strcmputf8i, &kStrcmputf8i); Game::Lua::RegisterGlobalFunction("strsplittable", &Script_strsplittable, &kStrsplittable); } // 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