-

Author: aiekick

3rdparty/imguipack

@@ -165,7 +165,7 @@ you also have this dialog when you quit the app
 -- ltg:logDebug(infos_string) : will log the message in the in app console 
 -- ltg:addSignalTag(date, r, g, b, a, name, help) : add a signal tag with date, color a name (color is linear [0:1]. the help will be displayed when mouse over the tag
 -- ltg:addSignalStatus(signal_category, signal_name, signal_epoch_time, signal_status) : will add a signal string status
--- ltg:addSignalValue(signal_category, signal_name, signal_epoch_time, signal_value) : will add a signal numerical value
+-- ltg:addSignalValue(signal_category, signal_name, signal_epoch_time, signal_value, description_string_optional) : will add a signal numerical value
 -- ltg:addSignalStartZone(signal_category, signal_name, signal_epoch_time, signal_string) : will add a signal start zone
 -- ltg:addSignalEndZone(signal_category, signal_name, signal_epoch_time, signal_string) : will add a signal end zone 
 -- get/set epoch time from datetime in format "YYYY-MM-DD HH:MM:SS,MS" or "YYYY-MM-DD HH:MM:SS.MS" with hour offset in second param

README.md

@@ -71,6 +71,13 @@ struct DebugState {
     int32_t logRowIndex = 0;
     std::vector<DebugFrame> callStack;  // innermost frame first; each frame holds its vars
     std::vector<DebugVar> globals;      // top-level _G entries (no filter)
+    // true when the pause was triggered by the auto-bp-on-error path (plugin caught a
+    // sol2/Lua exception, queried IScriptDebugHost::shouldPauseOnError, and called onPause
+    // synchronously with the throwing frame still on the Lua stack). Lets the host distinguish
+    // an error pause from a breakpoint hit — used to auto-set a breakpoint at the error line
+    // so subsequent runs can re-investigate.
+    bool errorPause = false;
+    std::string errorMessage;  // full Lua error text (used by the host as the auto-set bp tooltip / log)
 };
 
 // Set of breakpoint lines (1-based) for the active script.
@@ -114,6 +121,10 @@ struct IScriptDebugHost {
     // queried by the plugin hook on each line: is there a breakpoint on this line ?
     // live + thread-safe, so add/remove during a session takes effect immediately
     virtual bool isBreakpoint(int32_t aLine) = 0;
+    // queried by the plugin catch block when a runtime error fires: should the worker pause
+    // synchronously (state.errorPause = true) instead of just logging the error and moving on?
+    // live so the toggle takes effect mid-run.
+    virtual bool shouldPauseOnError() const = 0;
 };
 
 // Implemented by the plugin (extended by ScriptingModule), called by the host from

apis/IScriptDebugger.h

@@ -142,7 +142,6 @@ typedef std::shared_ptr<IDatasModel> IDatasModelPtr;
 typedef std::weak_ptr<IDatasModel> IDatasModelWeak;
 
 struct ScriptingDatas {
-    std::string filename;
     std::string filepath;
     std::string buffer;
 };

apis/LtgPluginApi.h

@@ -71,9 +71,29 @@ class Module : public Ltg::ScriptingModule {
 
 private:
     static void sLuaHook(lua_State* apLua, lua_Debug* apDebug);
+    // Lua-level message handler — invoked by lua_pcall BEFORE the stack unwinds when the called
+    // function (or anything it calls) raises a Lua error (string.match(nil), nil:method(), etc.).
+    // Distinct from the sol2 exception_handler which only fires for C++ exceptions thrown by
+    // bindings. Recovers `this` from the lua_State registry (same key as the line hook), checks
+    // shouldPauseOnError, and calls m_pauseOnError synchronously while the throwing frame is
+    // still alive — so locals/upvalues/call-stack are inspectable in the debug UI.
+    static int sLuaErrorHandler(lua_State* apLua);
     void m_onHook(lua_State* apLua, lua_Debug* apDebug);
     bool m_shouldBreak(lua_State* apLua, int32_t aLine);
     Ltg::DebugState m_buildState(lua_State* apLua, lua_Debug* apDebug);
+    // Build a paused-on-error snapshot from the sol2 exception_handler. Same call-stack + globals
+    // walk as m_buildState, but line/source come from the parsed error message (which carries the
+    // Lua-reported throw site), and the state is flagged errorPause = true so the host can auto-set
+    // a breakpoint at that line.
+    Ltg::DebugState m_buildErrorState(lua_State* apLua, const std::string& aErrorMessage);
+    // Shared helper — walks the Lua call stack (innermost first, capped at 64) and the _G table,
+    // filling state.callStack and state.globals. Used by both m_buildState and m_buildErrorState.
+    void m_fillCallStackAndGlobals(lua_State* apLua, Ltg::DebugState& aoState);
+    // Drives the onPause -> waitAction loop and applies the returned command. Used by both the
+    // line-hook path (m_onHook) and the exception_handler path (m_pauseOnError).
+    void m_runPauseLoop(lua_State* apLua, Ltg::DebugState aState);
+    // Called from the sol2 exception_handler when shouldPauseOnError() is true.
+    void m_pauseOnError(lua_State* apLua, const std::string& aErrorMessage);
     void m_applyCommand(lua_State* apLua, Ltg::DebugCommand aCommand);
     int32_t m_makeRef(lua_State* apLua, int32_t aIndex);
     Ltg::DebugVar m_makeVar(lua_State* apLua, int32_t aIndex, const std::string& aName, const std::string& aKeyType);

plugins/LuaScripting/src/modules/Module.cpp

@@ -66,25 +66,48 @@ bool CodeEditor::init() {
     m_Editor.SetCompletionCallbacks(
         [this](size_t aSelectedIndex) { m_OnCompletionAccepted(aSelectedIndex); },
         [this]() { m_OnCompletionCancelled(); });
-    // a narrow gutter decorator: a red dot marks a breakpoint, double-click toggles it
+    // a narrow gutter decorator: a red dot marks a breakpoint, single click toggles it; an amber
+    // right-pointing arrow marks the current paused line (VS-style). When both apply (paused on a
+    // breakpoint line) the arrow is drawn ON TOP of the dot so both states are visible at once.
+    //
+    // Breakpoint TOGGLING is always allowed — the user can set/remove BPs even when Debug is off
+    // (they're stored, just dormant until shouldArmDebug() installs the line hook). The visual
+    // alpha fades when Debug is off as a hint that those BPs won't fire yet — see
+    // m_BreakpointInteractionEnabled (renamed semantically to "BPs will actually fire").
     m_Editor.SetLineDecorator(16.0f, [this](TextEditor::Decorator& aDecorator) {
         const int32_t line0 = aDecorator.line;  // zero-based
         ImGui::InvisibleButton("##bp", ImVec2(aDecorator.width, aDecorator.height));
         const bool hovered = ImGui::IsItemHovered();
-        if (m_BreakpointInteractionEnabled && hovered && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
+        if (hovered && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
             const bool has = (m_BreakpointLines.find(line0) != m_BreakpointLines.end());
             if (m_OnBreakpointToggled) {
-                m_OnBreakpointToggled(line0, !has);  // toggle
+                m_OnBreakpointToggled(line0, !has);  // toggle — allowed regardless of debug state
             }
         }
         const bool isBreakpoint = (m_BreakpointLines.find(line0) != m_BreakpointLines.end());
-        const bool drawHoverHalo = hovered && m_BreakpointInteractionEnabled;  // no false affordance when interaction is off
-        if (isBreakpoint || drawHoverHalo) {
-            const ImVec2 rectMin = ImGui::GetItemRectMin();
+        const ImVec2 rectMin = ImGui::GetItemRectMin();
+        const float centerX = rectMin.x + aDecorator.width * 0.5f;
+        const float centerY = rectMin.y + aDecorator.height * 0.5f;
+        ImDrawList* drawList = ImGui::GetWindowDrawList();
+        if (isBreakpoint || hovered) {
             const float radius = (aDecorator.height - 6.0f) * 0.5f;
-            const uint8_t bpAlpha = m_BreakpointInteractionEnabled ? 255 : 110;  // fade existing dot when toggling is off
+            // when debug is off the user can still toggle BPs but they won't fire yet — fade the
+            // dot alpha as a visual hint.
+            const uint8_t bpAlpha = m_BreakpointInteractionEnabled ? 255 : 110;
             const ImU32 color = isBreakpoint ? IM_COL32(220, 40, 40, bpAlpha) : IM_COL32(220, 40, 40, 90);
-            ImGui::GetWindowDrawList()->AddCircleFilled(ImVec2(rectMin.x + aDecorator.width * 0.5f, rectMin.y + aDecorator.height * 0.5f), radius, color);
+            drawList->AddCircleFilled(ImVec2(centerX, centerY), radius, color);
+        }
+        // current paused line: amber right-pointing arrow (VS-style). Drawn after the bp dot so it
+        // sits on top when both coexist — the high-contrast amber/red pair stays readable.
+        if (m_CurrentExecLine == line0) {
+            const float arrowHalfWidth = aDecorator.width * 0.30f;
+            const float arrowHalfHeight = aDecorator.height * 0.28f;
+            const ImVec2 p1(centerX - arrowHalfWidth, centerY - arrowHalfHeight);  // top-left
+            const ImVec2 p2(centerX - arrowHalfWidth, centerY + arrowHalfHeight);  // bottom-left
+            const ImVec2 p3(centerX + arrowHalfWidth, centerY);                    // right-middle (tip)
+            drawList->AddTriangleFilled(p1, p2, p3, IM_COL32(255, 200, 0, 255));
+            // thin black outline so the arrow stays visible against any line background tint.
+            drawList->AddTriangle(p1, p2, p3, IM_COL32(0, 0, 0, 200), 1.0f);
         }
     });
     return true;
@@ -280,10 +303,12 @@ void CodeEditor::ClearErrorMarkers() {
 
 void CodeEditor::AddErrorMarker(const size_t& vErrorLine, const std::string& vErrorMsg) {
     m_ErrorMarkers[(int32_t)vErrorLine] = vErrorMsg;
-    // AddMarker's textTooltip carries the message again, so the per-line error tooltip
-    // is back (regression #2/#4 fixed); the cursor still jumps to the error line.
+    // AddMarker's textTooltip carries the message again, so the per-line error tooltip is back
+    // (regression #2/#4 fixed). The caret is NOT moved here — that used to jump the caret to
+    // the error line on every error-revision bump (incl. the end-of-run bump from
+    // ScriptingEngine::m_run), which fought with CodePane's VS-style caret sync on Step. The
+    // host now drives caret movement exclusively via MoveCursorTo on state-revision bumps.
     m_RebuildMarkers();
-    m_Editor.SetCursor((int32_t)vErrorLine, 0);
 }
 
 // Commands
@@ -390,9 +415,15 @@ void CodeEditor::SetCurrentExecLine(int32_t aZeroBasedLine) {
     if (m_CurrentExecLine != aZeroBasedLine) {
         m_CurrentExecLine = aZeroBasedLine;
         m_RebuildMarkers();
-        if (m_CurrentExecLine >= 0) {
-            m_Editor.SetCursor(m_CurrentExecLine, 0);  // scroll to the paused line
-        }
+    }
+}
+
+void CodeEditor::MoveCursorTo(int32_t aZeroBasedLine, int32_t aZeroBasedColumn) {
+    // explicit caret jump — used by CodePane to sync the caret to the active line on each new
+    // pause event (state revision bump). Separated from SetCurrentExecLine so the marker update
+    // (drawn every frame) doesn't fight a user who manually moved the caret between pauses.
+    if (aZeroBasedLine >= 0) {
+        m_Editor.SetCursor(aZeroBasedLine, aZeroBasedColumn);
     }
 }
 
@@ -410,13 +441,31 @@ float CodeEditor::GetCurrentFontScale() const {
 
 void CodeEditor::m_RebuildMarkers() {
     m_Editor.ClearMarkers();
-    // breakpoints are drawn by the line decorator (a red dot); markers carry errors + current line
+    // breakpoints are drawn by the line decorator (a red dot); markers carry errors + current line.
+    //
+    // Line-number gutter color: leave default (0 = no override). Only the code-line background is
+    // tinted, so the gutter numbers stay readable on dark themes (the amber tint behind white text
+    // washed out the line numbers on the previous design).
+    //
+    // TextEditor::AddMarker keys by line, so two calls on the same line — the second wins. On a
+    // pause-on-error the error line IS the current exec line, so we'd lose either the amber
+    // pause hint or the red error styling + tooltip. Merge them: red text background (error) +
+    // error message as the text tooltip + "current line" gutter tooltip on hover so the dual
+    // role of the line is still surfaced.
     for (const auto& errorMarker : m_ErrorMarkers) {
-        m_Editor.AddMarker(errorMarker.first - 1, 0, IM_COL32(200, 0, 40, 80), "", errorMarker.second);
-    }
-    // current paused line: amber line number + translucent amber text
+        const int32_t errorLine0Based = errorMarker.first - 1;
+        const bool isAlsoCurrentLine = (m_CurrentExecLine == errorLine0Based);
+        const char* lineNumberTooltip = isAlsoCurrentLine ? "current line" : "";
+        m_Editor.AddMarker(errorLine0Based, 0, IM_COL32(200, 0, 40, 80), lineNumberTooltip, errorMarker.second);
+    }
+    // current paused line: translucent amber over the code line — ONLY when not already emitted
+    // as a merged error marker above. Alpha kept low so the syntax-highlighted text reads cleanly
+    // on top.
     if (m_CurrentExecLine >= 0) {
-        m_Editor.AddMarker(m_CurrentExecLine, IM_COL32(255, 200, 0, 255), IM_COL32(255, 200, 0, 60), "current line", "");
+        const bool alreadyEmittedAsError = (m_ErrorMarkers.find(m_CurrentExecLine + 1) != m_ErrorMarkers.end());
+        if (!alreadyEmittedAsError) {
+            m_Editor.AddMarker(m_CurrentExecLine, 0, IM_COL32(255, 200, 0, 60), "current line", "");
+        }
     }
 }
 

plugins/LuaScripting/src/modules/Module.h

@@ -98,6 +98,7 @@ class CodeEditor {
     void SetHoverTokenCallback(std::function<void(const std::string& aToken)> aCallback);
     void SetBreakpoints(const std::unordered_set<int32_t>& aZeroBasedLines, int64_t aRevision);
     void SetCurrentExecLine(int32_t aZeroBasedLine);
+    void MoveCursorTo(int32_t aZeroBasedLine, int32_t aZeroBasedColumn);  // jump caret; caller decides when to sync
 
     // per-editor persistent font scale — pushes a one-shot value into the underlying TextEditor
     // (applied on the next render after BeginChild). GetCurrentFontScale reads back the effective

src/frontend/Components/CodeEditor.cpp

@@ -16,11 +16,34 @@ limitations under the License.
 
 #include "ScriptDebugger.h"
 
+#include <settings/DebugSettings.h>
+#include <models/script/ScriptingEngine.h>
+
 ///////////////////////////////////////////////////////////////////////////////////
 //// RENDEZVOUS (worker thread) /////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////
 
 Ltg::DebugAction ScriptDebugger::onPause(const Ltg::DebugState& aState) {
+    // auto-bp-on-error path: when the plugin paused us synchronously from its catch block, persist
+    // a breakpoint at the error line BEFORE handing off to the UI. The user can step / continue
+    // normally, and on the next run the same line stays armed so they can re-investigate without
+    // re-triggering the original throw. Also publish the error to ScriptingEngine NOW so the
+    // CodePane red marker + tooltip show up during the pause (the worker's normal publication
+    // path only fires when m_run finishes the whole source-file loop — way after the user clicks
+    // Continue).
+    if (aState.errorPause && aState.line > 0 && !aState.sourceFile.empty()) {
+        setBreakpoint(aState.sourceFile, aState.line, true);
+        Ltg::ScriptingError err;
+        err.file = aState.sourceFile;
+        err.line = static_cast<size_t>(aState.line);
+        err.message = aState.errorMessage;
+        ScriptingEngine::ref()->AddRuntimeError(err);
+        // Auto-arm the master Debug toggle. The CodePane toolbar gates Continue/Step on isDebugArmed,
+        // and the user opted into pause-on-error already — so we flip the master switch ON to keep
+        // the toolbar consistent (otherwise the user would be paused with all debug buttons greyed
+        // out). This persists across runs; user can flip it off manually after they're done.
+        m_DebugArmed.store(true, std::memory_order_release);
+    }
     {
         std::lock_guard<std::mutex> lock(m_Mutex);
         m_State = aState;
@@ -78,7 +101,13 @@ bool ScriptDebugger::shouldArmDebug() const {
     // installed and the existing breakpoints are kept in memory but stay inert (they are honoured
     // again as soon as the user re-arms Debug). this keeps `Debug off` synonymous with `full JIT speed`,
     // regardless of leftover breakpoints from a previous debug session.
-    return m_DebugArmed.load(std::memory_order_acquire);
+    // Exception: when the auto-bp-on-error toggle is on, we also arm the debugger — the plugin's
+    // catch block needs a non-null IScriptDebugHost to call onPause synchronously. Without this,
+    // the user would have to manually arm Debug to get pause-on-error, defeating the toggle.
+    if (m_DebugArmed.load(std::memory_order_acquire)) {
+        return true;
+    }
+    return DebugSettings::ref()->isAutoBreakpointOnErrorEnabled();
 }
 
 const Ltg::BreakpointLines& ScriptDebugger::getBreakpoints() const {
@@ -94,6 +123,12 @@ bool ScriptDebugger::isBreakpoint(int32_t aLine) {
     return m_Breakpoints.find(aLine) != m_Breakpoints.end();
 }
 
+bool ScriptDebugger::shouldPauseOnError() const {
+    // live read of the user toggle — plugin queries this from its catch block each time an error
+    // fires, so flipping the toggle mid-run takes effect on the next exception (no need to reload).
+    return DebugSettings::ref()->isAutoBreakpointOnErrorEnabled();
+}
+
 ///////////////////////////////////////////////////////////////////////////////////
 //// BREAKPOINTS (UI thread) ////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////

src/frontend/Components/CodeEditor.h

@@ -81,6 +81,7 @@ class ScriptDebugger : public Ltg::IScriptDebugHost {
     void publishExpansion(int32_t aRef, const std::vector<Ltg::DebugVar>& aChildren) final;
     void publishEvalResult(int32_t aEvalId, const Ltg::EvalResult& aResult) final;
     bool isBreakpoint(int32_t aLine) final;
+    bool shouldPauseOnError() const final;
 
     // session binding — called by ScriptingEngine around the parse run
     void bindPlugin(Ltg::IScriptDebugger* apPluginDebugger);