display script error in code editor

Author: aiekick

apis/LtgPluginApi.h

@@ -88,9 +88,15 @@ struct ScriptingError {
     ScriptFilePathName file;
     size_t line = 0;
     size_t column = 0;
+    std::string message;  // full error text, used as the per-line marker tooltip in the editor
 };
 typedef std::vector<ScriptingError> ErrorContainer;
 
+// chunk name passed to the scripting runtime when compiling the in-memory project script.
+// the host's CodePane uses the SAME string as the sheet id, so a ScriptingError's `file` field
+// can be routed back to the matching sheet. keep both sides in sync.
+static constexpr const char* sc_PROJECT_SCRIPT_CHUNK = "<project script>";
+
 // lua_register(lua_state_ptr, "print", lua_int_print_args);
 struct IDatasModel {
     // add a signal tag with date, color a name. the help will be displayed when mouse over the tag

plugins/LuaScripting/CMakeLists.txt

@@ -127,6 +127,10 @@ target_include_directories(${PROJECT} PRIVATE
 target_link_libraries(${PROJECT}
 	${LUA_JIT_LIBRARIES}
 	${SOL2_LIBRARIES}
+	# boost_regex is created by imguipack when USE_IMGUI_COLOR_TEXT_EDIT is ON (forced ON by the host
+	# in cmake/imguipack.cmake). Linking it here gives the plugin a real regex engine without dragging
+	# imguipack, and keeps the host + plugin on the SAME regex library for future ltg:regex bindings.
+	boost_regex
 )
 
 # add plugin name in parent LOADED_STROCKER_PLUGINS list

plugins/LuaScripting/src/modules/Module.cpp

@@ -13,6 +13,10 @@
 #include <unordered_map>
 #include <unordered_set>
 
+// boost::regex (vendored by imguipack via USE_IMGUI_COLOR_TEXT_EDIT) — same engine the host will use
+// when the future shared ltg:regex(...) brick lands. linked through the boost_regex CMake target.
+#include <boost/regex.hpp>
+
 #include <lua.hpp>
 #include <sol/sol.hpp>
 
@@ -25,6 +29,33 @@ namespace {
 // plugin DLL's unload.
 const char* const kDebugModuleRegistryKey = "ltg_debug_module";
 
+// Parse a Lua/sol2 error message and extract (file, line). Sol2 wraps an in-memory chunk as
+// `[string "NAME"]:LINE: MSG`; a file-based script reads `NAME:LINE: MSG`. On a match, the full
+// original message is kept as `aoErr.message` (it stays useful for the tooltip even if regex only
+// found a prefix). On no match, the message lands on `aFallbackChunk:0` so the host can still display
+// it (just unanchored). Returns true on a regex match.
+bool parseLuaError(const std::string& aMsg, const std::string& aFallbackChunk, Ltg::ScriptingError& aoErr) {
+    // delimiter `re(...)re` mandatory: the chunkRe pattern contains a literal `)"` (the `+)"` after
+    // the `[^"]+` group), which would otherwise close an empty-delimiter R"(...)" prematurely.
+    static const boost::regex chunkRe(R"re(\[string\s+"([^"]+)"\]:(\d+):\s*(.*))re");
+    static const boost::regex plainRe(R"re(([^:\[\]\s]+):(\d+):\s*(.*))re");
+    boost::smatch match;
+    aoErr.message = aMsg;
+    if (boost::regex_search(aMsg, match, chunkRe)) {
+        aoErr.file = match[1].str();
+        aoErr.line = static_cast<size_t>(std::stoul(match[2].str()));
+        return true;
+    }
+    if (boost::regex_search(aMsg, match, plainRe)) {
+        aoErr.file = match[1].str();
+        aoErr.line = static_cast<size_t>(std::stoul(match[2].str()));
+        return true;
+    }
+    aoErr.file = aFallbackChunk;
+    aoErr.line = 0;
+    return false;
+}
+
 // Stringify a value on the Lua stack WITHOUT luaL_tolstring (absent from LuaJIT 5.1).
 // The type is checked first so lua_tostring is only called on real strings (it would
 // otherwise coerce a number in place and disturb the stack inside the hook).
@@ -198,7 +229,9 @@ bool Module::compileScript(const Ltg::ScriptFilePathName& vFilePathName, Ltg::Er
 
 bool Module::compileScriptCode(const std::string& aCode, Ltg::ErrorContainer& vOutErrors) {
     try {
-        m_luaPtr->script(aCode);  // compile + run the chunk from memory (defines parse/startFile/endFile)
+        // pass an explicit chunk name so sol2's error messages identify our project script
+        // (otherwise sol2 uses the first line of code as the chunk name, which breaks routing).
+        m_luaPtr->script(aCode, Ltg::sc_PROJECT_SCRIPT_CHUNK);  // compile + run the chunk (defines parse/startFile/endFile)
         bool res = true;
         sol::function parse = (*m_luaPtr)["parse"];
         if (!parse.valid()) {
@@ -209,10 +242,20 @@ bool Module::compileScriptCode(const std::string& aCode, Ltg::ErrorContainer& vO
         res &= callScriptEnd(vOutErrors);
         return res;
     } catch (const sol::error& ex) {
+        Ltg::ScriptingError err;
+        parseLuaError(ex.what(), Ltg::sc_PROJECT_SCRIPT_CHUNK, err);
+        vOutErrors.push_back(err);
         LogVarError("Lua: Error in the Lua script : %s", ex.what());
     } catch (const std::exception& ex) {
+        Ltg::ScriptingError err;
+        parseLuaError(ex.what(), Ltg::sc_PROJECT_SCRIPT_CHUNK, err);
+        vOutErrors.push_back(err);
         LogVarError("Lua: Error in the Lua script : %s", ex.what());
     } catch (...) {
+        Ltg::ScriptingError err;
+        err.file = Ltg::sc_PROJECT_SCRIPT_CHUNK;
+        err.message = "Unknown error in the Lua script";
+        vOutErrors.push_back(err);
         LogVarError("Lua: %s", "Unknown error in the Lua script");
     }
     return false;
@@ -226,8 +269,11 @@ bool Module::callScriptStart(Ltg::ErrorContainer& vOutErrors) {
     }
     sol::protected_function_result result = startFile();
     if (!result.valid()) {
-        sol::error err = result;
-        LogVarLightError("Lua: error in startFile func call : %s", err.what());
+        sol::error solErr = result;
+        Ltg::ScriptingError err;
+        parseLuaError(solErr.what(), Ltg::sc_PROJECT_SCRIPT_CHUNK, err);
+        vOutErrors.push_back(err);
+        LogVarLightError("Lua: error in startFile func call : %s", solErr.what());
         return false;
     }
     return true;
@@ -241,8 +287,11 @@ bool Module::callScriptExec(const Ltg::ScriptingDatas& vOutDatas, Ltg::ErrorCont
     }
     sol::protected_function_result result = parse(vOutDatas.buffer);
     if (!result.valid()) {
-        sol::error err = result;
-        LogVarLightError("Lua: error in parse func call : %s", err.what());
+        sol::error solErr = result;
+        Ltg::ScriptingError err;
+        parseLuaError(solErr.what(), Ltg::sc_PROJECT_SCRIPT_CHUNK, err);
+        vErrors.push_back(err);
+        LogVarLightError("Lua: error in parse func call : %s", solErr.what());
         return false;
     }
     return true;
@@ -256,8 +305,11 @@ bool Module::callScriptEnd(Ltg::ErrorContainer& vOutErrors) {
     }
     sol::protected_function_result result = endFile();
     if (!result.valid()) {
-        sol::error err = result;
-        LogVarLightError("Lua: error in endFile func call : %s", err.what());
+        sol::error solErr = result;
+        Ltg::ScriptingError err;
+        parseLuaError(solErr.what(), Ltg::sc_PROJECT_SCRIPT_CHUNK, err);
+        vOutErrors.push_back(err);
+        LogVarLightError("Lua: error in endFile func call : %s", solErr.what());
         return false;
     }
     return true;

src/frontend/Components/CodeEditor.cpp

@@ -299,7 +299,7 @@ void CodeEditor::m_RebuildMarkers() {
     m_Editor.ClearMarkers();
     // breakpoints are drawn by the line decorator (a red dot); markers carry errors + current line
     for (const auto& errorMarker : m_ErrorMarkers) {
-        m_Editor.AddMarker(errorMarker.first, 0, IM_COL32(200, 0, 40, 80), "", errorMarker.second);
+        m_Editor.AddMarker(errorMarker.first - 1, 0, IM_COL32(200, 0, 40, 80), "", errorMarker.second);
     }
     // current paused line: amber line number + translucent amber text
     if (m_CurrentExecLine >= 0) {

src/models/script/ScriptingEngine.cpp

@@ -67,6 +67,14 @@ void ScriptingEngine::m_run(std::atomic<double>& vProgress, std::atomic<bool>& v
 
     vGenerationTime = 0.0f;
 
+    // wipe errors from the previous run + bump revision so the UI clears its editor markers before
+    // we start producing new ones (release order; UI reads via acquire load — no mutex on hot path).
+    {
+        std::lock_guard<std::mutex> lock(m_ErrorsMutex);
+        m_LastRunErrors.clear();
+        m_ErrorsRevision.fetch_add(1, std::memory_order_release);
+    }
+
     const int64_t firstTimeMark = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
 
     Ltg::ScriptingModulePtr scriptingPtr = nullptr;
@@ -148,6 +156,13 @@ void ScriptingEngine::m_run(std::atomic<double>& vProgress, std::atomic<bool>& v
                         ScriptDebugger::ref()->unbindPlugin();
                     }
                 }
+                // publish whatever errors accumulated (compile + runtime) for the UI to consume.
+                // errorContainer goes out of scope right after — this is the last chance to capture.
+                {
+                    std::lock_guard<std::mutex> lock(m_ErrorsMutex);
+                    m_LastRunErrors = errorContainer;
+                    m_ErrorsRevision.fetch_add(1, std::memory_order_release);
+                }
                 scriptingPtr->unload();
             }
         }
@@ -156,6 +171,15 @@ void ScriptingEngine::m_run(std::atomic<double>& vProgress, std::atomic<bool>& v
     vWorking = false;
 }
 
+int64_t ScriptingEngine::GetErrorsRevision() const {
+    return m_ErrorsRevision.load(std::memory_order_acquire);
+}
+
+std::vector<Ltg::ScriptingError> ScriptingEngine::GetLastRunErrors() const {
+    std::lock_guard<std::mutex> lock(m_ErrorsMutex);
+    return m_LastRunErrors;
+}
+
 ///////////////////////////////////////////////////
 /// INIT/UNIT /////////////////////////////////////
 ///////////////////////////////////////////////////

src/models/script/ScriptingEngine.h

@@ -59,6 +59,11 @@ class ScriptingEngine : public Ltg::IDatasModel, public ez::xml::Config {
 private:  // thread
     std::thread m_WorkerThread;
 
+private:  // errors collected during the last run (worker writes, UI reads via revision pattern)
+    mutable std::mutex m_ErrorsMutex;
+    std::vector<Ltg::ScriptingError> m_LastRunErrors;
+    std::atomic<int64_t> m_ErrorsRevision{0};
+
 public:
     void Clear();
 
@@ -106,6 +111,10 @@ class ScriptingEngine : public Ltg::IDatasModel, public ez::xml::Config {
     void Join();
     bool FinishIfRequired();
 
+    // errors collected during the last run — UI reads them via revision-cache pattern (worker fills under mutex)
+    int64_t GetErrorsRevision() const;  // atomic acquire load; no mutex
+    std::vector<Ltg::ScriptingError> GetLastRunErrors() const;  // mutex-locked copy by value (worker mutates)
+
     bool drawMenu();
     bool isValidScriptingSelected() const;
 

src/panes/misc/CodePane.cpp

@@ -32,6 +32,8 @@ void CodePane::Clear() {
     m_Breakpoints0BasedCache.clear();
     m_LastStateRevision = -1;
     m_StateCache = Ltg::DebugState{};
+    m_LastErrorsRevisionSeen = -1;
+    m_ErrorsCache.clear();
 }
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -74,6 +76,24 @@ bool CodePane::drawPanes(bool* apOpened, LayoutPaneUserDatas apUserDatas) {
                 m_LastStateRevision = stateRevision;
             }
 
+            // scripting errors — refreshed when ScriptingEngine bumps GetErrorsRevision(). on a bump,
+            // wipe all sheets' error markers then push the new ones to each matching sheet (route by err.file).
+            const int64_t errorsRevision = ScriptingEngine::ref()->GetErrorsRevision();
+            if (errorsRevision != m_LastErrorsRevisionSeen) {
+                m_ErrorsCache = ScriptingEngine::ref()->GetLastRunErrors();
+                m_LastErrorsRevisionSeen = errorsRevision;
+                for (auto& sheet : m_CodeSheets) {
+                    sheet.codeEditor.ClearErrorMarkers();
+                }
+                for (const auto& errorEntry : m_ErrorsCache) {
+                    for (auto& sheet : m_CodeSheets) {
+                        if (sheet.filepathName == errorEntry.file) {
+                            sheet.codeEditor.AddErrorMarker(errorEntry.line, errorEntry.message);
+                        }
+                    }
+                }
+            }
+
             const bool isPaused = (ScriptDebugger::ref()->getMode() == ScriptDebugger::Mode::Paused);
             const bool isDebugArmed = ScriptDebugger::ref()->isDebugArmed();
             int32_t currentExecLine0Based = -1;

src/panes/misc/CodePane.h

@@ -4,7 +4,7 @@
 #include <ezlibs/ezSingleton.hpp>
 #include <imguipack.h>
 #include <frontend/Components/CodeEditor.h>
-#include <apis/IScriptDebugger.h>
+#include <apis/LtgPluginApi.h>  // also pulls IScriptDebugger.h transitively; brings ScriptingError + sc_PROJECT_SCRIPT_CHUNK
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -33,6 +33,9 @@ class CodePane : public AbstractPane {
     // paused state cache — refreshed only when ScriptDebugger::getStateRevision() advances (i.e. on a new pause)
     int64_t m_LastStateRevision = -1;
     Ltg::DebugState m_StateCache;
+    // last-run scripting errors — refreshed when ScriptingEngine::GetErrorsRevision() advances
+    int64_t m_LastErrorsRevisionSeen = -1;
+    std::vector<Ltg::ScriptingError> m_ErrorsCache;
 
 public:
     bool init() final;