ScriptUtils.h

Go to the documentation of this file.

#pragma once
 
#include "ScriptMacros.h"
#include <functional>
#include <unordered_map>
#include <unordered_set>
 
class Script;
 
class ScriptUtils
{
public:
 
    static bool IsScriptLoaded(const std::string& className);
    static bool ReloadScriptFile(const std::string& fileName);
    static bool CallLuaFunc(int numArgs, int numResults = 0);
    // reportMissingClass: log an error when the chunk ran but never defined a
    // global table named className. True for anything a Script component asked
    // for (a class script that lost its table IS a bug). False for speculative
    // loads -- the disk sweep in ReloadAllScriptFiles also picks up plain
    // module/library scripts, which legitimately have no class table.
    static bool LoadScriptFile(const std::string& fileName, const std::string& className, bool reportMissingClass = true);
    // Optional progress callback. Called once per file with (fileName, done,
    // total). Return false to abort the loop after the current file. Default
    // nullptr keeps non-editor callers unchanged.
    using ReloadProgressFn = std::function<bool(const std::string&, int, int)>;
    static void ReloadAllScriptFiles(const ReloadProgressFn& onProgress = nullptr);
    static void LoadAllScripts();
    static void LoadScriptDirectory(const std::string& dirName, bool recurse = true);
    // Wipe the loaded-script registry. The Lua globals themselves are left in
    // place (re-running a class chunk overwrites its table), but subsequent
    // Script attaches will re-read the .lua from disk instead of seeing the
    // IsScriptLoaded fast-path and reusing the stale prototype. Called on
    // project switch so addon Lua edits made between sessions take effect.
    static void ClearLoadedScripts();
 
    static std::string GetClassNameFromFileName(const std::string& fileName);
    // True for scripts that are executed once at boot (or are pure templates)
    // and must never be re-executed by the reload-all sweep. Re-running them
    // has session-persistent side effects -- StartLuaPanda.lua reopens the
    // debugger socket and steals the debug hook back from LuaDebugger.
    static bool IsReloadExcludedScript(const std::string& fileName);
    static void SetEmbeddedScripts(EmbeddedFile* embeddedScripts, uint32_t numEmbeddedScripts);
    static EmbeddedFile* FindEmbeddedScript(const std::string& className);
    static bool RunScript(const char* fileName, Datum* ret = nullptr);
 
    // Reads a script's decoded source from whichever source holds it: the
    // embedded table first, then Content.pak / disk. Used by the require()
    // searcher in LuaBindings.cpp, which cannot go through Lua's own
    // package.path -- a packaged build has no loose .lua files to find.
    static bool ReadScriptSource(const char* fileName, std::string& outSource);
 
    static uint32_t GetNextScriptInstanceNumber();
 
    static void CallMethod(Node* node, const char* funcName, uint32_t numParams, const Datum** params, Datum* ret);
    static void SetBreakOnScriptError(bool enableBreak);
 
    static void GarbageCollect();
 
    static Datum GetField(Node* node, const char* key);
    static void SetField(Node* node, const char* key, const Datum& value);
    static Datum GetField(Node* node, int32_t key);
    static void SetField(Node* node, int32_t key, const Datum& value);
 
    static Datum GetField(const char* table, const char* key);
    static void SetField(const char* table, const char* key, const Datum& value);
    static Datum GetField(const char* table, int32_t key);
    static void SetField(const char* table, int32_t key, const Datum& value);
 
    static void DumpStack();
 
private:
 
    // className -> last fileName used to load it. The fileName is preserved so
    // ReloadAllScriptFiles can re-route addon paths (e.g. "Packages/Foo/Bar")
    // through RunScript's Packages/ branch on the next pass; a className-only
    // entry like "Bar" would fall through to the legacy Scripts/ probe and
    // silently fail to reload.
    static std::unordered_map<std::string, std::string> sLoadedLuaFiles;
    static std::unordered_set<std::string> sLoadingLuaFiles;
    static EmbeddedFile* sEmbeddedScripts;
    static uint32_t sNumEmbeddedScripts;
    static uint32_t sNumScriptInstances;
 
    static bool sBreakOnScriptError;
};