Merge pull request #38 from aiekick/debugger

Debugger

Author: aiekick

3rdparty/ezlibs

@@ -282,7 +282,6 @@ if (EXISTS ${CMAKE_BINARY_DIR}/current_build_type)
 	add_custom_command(
 		TARGET ${PROJECT} PRE_BUILD
 		COMMAND echo "${PROJECT}_${CMAKE_SYSTEM_NAME}_${PROJECT_BUILD_CONFIG_NAME}_${ARCH}_v${MajorNumber}.${MinorNumber}.${BuildNumber}" > ${CMAKE_SOURCE_DIR}/VERSION
-		DEPENDS ${PROJECT}
 	)
 
 	#############################################################

CMakeLists.txt

@@ -1 +1 @@
-LogToGraph_Windows_Debug_x64_v0.3.3629 
+LogToGraph_Windows_Release_x64_v0.3.3629 

VERSION

@@ -0,0 +1,118 @@
+/*
+Copyright 2022-2026 Stephane Cuillerdier (aka aiekick)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#pragma once
+#pragma warning(disable : 4251)
+
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <unordered_set>
+
+namespace Ltg {
+
+// Common debugger contract shared by the host and every scripting plugin.
+//
+// Line-number convention: every line number here (DebugFrame::line,
+// DebugState::line, and the entries of BreakpointLines) is 1-based, i.e. the
+// number Lua reports through lua_getinfo("l") and the number the user sees in
+// the editor gutter. The 0-based <-> 1-based conversion to the TextEditor
+// widget happens in the CodeEditor, not here.
+
+// The control command the host hands back to the paused plugin.
+enum class DebugCommand {
+    Continue,  // resume until the next breakpoint
+    StepInto,  // stop on the next executed line, entering called functions
+    StepOver,  // stop on the next line at the same call depth
+    StepOut,   // stop after the current function returns
+    Stop       // abort the current script execution
+};
+
+// One inspected value: a stack local/upvalue, a global, or a table entry.
+// Values are stringified by the plugin (the host cannot read a Lua TValue). A
+// table exposes a non-negative `ref` (a Lua registry reference) so the UI can
+// expand it lazily; scalars/functions/userdata stay leaves with ref == -1.
+struct DebugVar {
+    std::string name;
+    std::string keyType;   // type of the key ("none" for stack locals/upvalues)
+    std::string typeName;  // type of the value
+    std::string value;     // stringified value (address for table/function)
+    int32_t ref = -1;      // Lua registry ref when expandable, else -1
+};
+
+// One call-stack frame; carries its own locals and upvalues (roots only, lazy).
+struct DebugFrame {
+    std::string function;
+    std::string source;
+    int32_t line = 0;
+    std::vector<DebugVar> locals;
+    std::vector<DebugVar> upvalues;
+};
+
+// Immutable snapshot of the paused state. Only roots are captured up front;
+// tables are expanded on demand through their `ref`. It holds no pointer into
+// the runtime, so it is safe to read from the UI thread.
+struct DebugState {
+    std::string sourceFile;
+    int32_t line = 0;
+    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)
+};
+
+// Set of breakpoint lines (1-based) for the active script.
+using BreakpointLines = std::unordered_set<int32_t>;
+
+// What the paused plugin should do next: resume with a command, or read the
+// children of an expandable node before resuming.
+struct DebugAction {
+    enum class Kind { Command, Expand };
+    Kind kind = Kind::Command;
+    DebugCommand command = DebugCommand::Continue;  // when kind == Command
+    int32_t expandRef = -1;                         // when kind == Expand (a registry ref)
+};
+
+// Implemented by the host (ScriptDebugger), called by the plugin from the worker
+// thread. The plugin loops:
+//   action = onPause(state)
+//   while action is Expand: publishExpansion(ref, children); action = waitAction()
+//   apply action.command
+struct IScriptDebugHost {
+    virtual ~IScriptDebugHost() = default;
+    // publish the paused snapshot (roots) and block until the first action
+    virtual DebugAction onPause(const DebugState& aState) = 0;
+    // block until the next action (after an expansion has been handled)
+    virtual DebugAction waitAction() = 0;
+    // publish the lazily-read children of an expandable node (non-blocking)
+    virtual void publishExpansion(int32_t aRef, const std::vector<DebugVar>& aChildren) = 0;
+    // 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;
+};
+
+// Implemented by the plugin (extended by ScriptingModule), called by the host from
+// the UI thread. Default no-ops so a scripting plugin that does not support
+// debugging compiles unchanged (e.g. PythonScripting); the Lua plugin overrides them.
+struct IScriptDebugger {
+    virtual ~IScriptDebugger() = default;
+    virtual void enableDebug(IScriptDebugHost* /*apHost*/) {}
+    virtual void disableDebug() {}
+    virtual void setBreakpoints(const BreakpointLines& /*aLines*/) {}
+    virtual void requestPause() {}
+    virtual void requestStop() {}
+};
+
+}  // namespace Ltg

apis/IScriptDebugger.h

@@ -24,8 +24,13 @@ limitations under the License.
 #include <array>
 #include <map>
 
-#include "ILayoutPane.h"
-#include <ezlibs/ezXml.hpp>
+// The plugin API is deliberately ImGui-free: plugins are pure modules (scripting + data) and link
+// no imguipack/glad/glfw. The host owns all UI. The only host objects a plugin borrows are
+// forwarded by pointer/interface at instantiation (ez::Log via init(), IDatasModel via load(),
+// IScriptDebugHost via enableDebug()). This is what lets LogToGraph build fully static. The host
+// settings-dialog interface (ISettings) is NOT here anymore — it moved to src/systems/ISettings.h
+// since plugins no longer provide settings.
+#include "IScriptDebugger.h"
 
 namespace ez {
 class Log;
@@ -44,46 +49,6 @@ class IProject {
 typedef std::shared_ptr<IProject> IProjectPtr;
 typedef std::weak_ptr<IProject> IProjectWeak;
 
-struct PluginPane : public virtual ILayoutPane {
-    bool init() override = 0;  // return false if the init was failed
-    void unit() override = 0;
-
-    // the return, is a user side use case here
-    bool drawPanes(bool* apOpened, LayoutPaneUserDatas apUserDatas) override = 0;
-    bool drawWidgets(LayoutPaneUserDatas /*apUserDatas*/) override { return false; }
-    bool drawOverlays(const ImRect& /*aRect*/, LayoutPaneUserDatas /*apUserDatas*/) override { return false; }
-    bool drawDialogsAndPopups(const ImRect& /*aRect*/, LayoutPaneUserDatas /*apUserDatas*/) override { return false; }
-
-    // if for any reason the pane must be hidden temporary, the user can control this here
-    virtual bool canBeDisplayed() override = 0;
-
-    virtual void SetProjectInstance(IProjectWeak vProjectInstance) = 0;
-};
-
-struct PluginPaneConfig {
-    ILayoutPaneWeak pane;
-    std::string name;
-    std::string category;
-    std::string disposal = "CENTRAL";
-    float disposalRatio = 0.0f;
-    bool openedDefault = false;
-    bool focusedDefault = false;
-};
-
-typedef std::string SettingsCategoryPath;
-enum class ISettingsType {
-    NONE = 0,
-    APP,     // common for all users
-    PROJECT  // user specific
-};
-
-struct IXmlSettings {
-    // will be called by the saver
-    virtual ez::xml::Nodes getXmlSettings(const ISettingsType& vType) const = 0;
-    // will be called by the loader
-    virtual void setXmlSettings(const ez::xml::Node& vName, const ez::xml::Node& vParent, const std::string& vValue, const ISettingsType& vType) = 0;
-};
-
 struct PluginParam {
     std::string name;
     enum class Type { NUM, STRING } type = Type::NUM;
@@ -117,21 +82,6 @@ struct PluginModuleInfos {
         : path(vPath), label(vLabel), type(vType), color(vColor) {}
 };
 
-struct ISettings : public IXmlSettings {
-    virtual ~ISettings() = default;
-    // get the category path of the settings for the mebnu display. ex: "plugins/apis"
-    virtual SettingsCategoryPath getCategory() const = 0;
-    // will be called by the loader for inform the pluign than he must load somethings if any
-    virtual bool loadSettings() = 0;
-    // will be called by the saver for inform the pluign than he must save somethings if any, by ex: temporary vars
-    virtual bool saveSettings() = 0;
-    // will draw custom settings via imgui
-    virtual bool drawSettings() = 0;
-};
-
-typedef std::shared_ptr<ISettings> ISettingsPtr;
-typedef std::weak_ptr<ISettings> ISettingsWeak;
-
 typedef std::string ScriptFilePathName;
 
 struct ScriptingError {
@@ -163,14 +113,21 @@ struct ScriptingDatas {
     std::string buffer;
 };
 typedef std::string ScriptingModuleName;
-struct ScriptingModule : public PluginModule {
+struct ScriptingModule : public PluginModule, public IScriptDebugger {
     virtual ~ScriptingModule() = default;
     // will load the related scripting engine
     virtual bool load(IDatasModelWeak vDatasModel) = 0;
     // will unload the related scripting engine
     virtual void unload() = 0;
-    // will compile the script and return errors
+    // will compile the script from a file path and return errors
     virtual bool compileScript(const ScriptFilePathName& vFilePathName, ErrorContainer& vOutErrors) = 0;
+    // will compile the script from in-memory code (project script stored in the .ltg db).
+    // default no-op so plugins that only support file-based scripts compile unchanged.
+    virtual bool compileScriptCode(const std::string& aCode, ErrorContainer& aOutErrors) {
+        (void)aCode;
+        (void)aOutErrors;
+        return false;
+    }
     // will call the start function from script and return errors
     virtual bool callScriptStart(ErrorContainer& vOutErrors) = 0;
     // will call the exec function from script with a buffer and return errors
@@ -186,11 +143,6 @@ struct ScriptingModule : public PluginModule {
 typedef std::shared_ptr<ScriptingModule> ScriptingModulePtr;
 typedef std::weak_ptr<ScriptingModule> ScriptingModuleWeak;
 
-struct PluginSettingsConfig {
-    ISettingsWeak settings;
-    PluginSettingsConfig(ISettingsWeak vSertings) : settings(vSertings) {}
-};
-
 struct PluginInterface {
     virtual ~PluginInterface() = default;
     virtual bool init(ez::Log* vLoggerInstancePtr) = 0;
@@ -206,8 +158,6 @@ struct PluginInterface {
     virtual std::string getDescription() const = 0;
     virtual std::vector<PluginModuleInfos> getModulesInfos() const = 0;
     virtual PluginModulePtr createModule(const std::string& vPluginModuleName, Ltg::PluginBridge* vBridgePtr) = 0;
-    virtual std::vector<PluginPaneConfig> getPanes() const = 0;
-    virtual std::vector<PluginSettingsConfig> getSettings() const = 0;
 };
 
-}  // namespace Ltg
+}  // namespace Ltg

apis/LtgPluginApi.h

@@ -20,7 +20,6 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-add_definitions(-DUSE_DECORATIONS_FOR_RESIZE_CHILD_WINDOWS) ## for the resize imgui issue when we have child glfw windows
 
 if (uninstall)
 	set_target_properties(uninstall PROPERTIES FOLDER "CmakeTargets")
@@ -75,13 +74,8 @@ else()
 endif()
 
 set_target_properties(${PROJECT} PROPERTIES	OUTPUT_NAME "${PROJECT}")
-## these defines mirror USE_SHARED_LIBS from the root CMake — only emit them when
-## imguipack is actually built as a DLL, otherwise IMGUI_API resolves to dllimport
-## against a static lib and ImGui::Header (and friends) end up unresolved.
-if (USE_SHARED_LIBS)
-	target_compile_definitions(${PROJECT} PRIVATE BUILD_CTOOLS_SHARED_LIBS)
-	target_compile_definitions(${PROJECT} PRIVATE BUILD_IMGUI_PACK_SHARED_LIBS)
-endif()
+## the plugin links no imguipack/glad/glfw anymore (pure Lua module), so the root
+## BUILD_*_SHARED_LIBS / IMGUI_API mirror is no longer needed here.
 
 ## sol2 config — MUST be visible to every TU before the first <sol/sol.hpp>:
 ## - SOL_ALL_SAFETIES_ON=1     : full runtime safety checks (arg counts, types, …)
@@ -125,16 +119,12 @@ target_include_directories(${PROJECT} PRIVATE
 	${CMAKE_CURRENT_SOURCE_DIR}/src
 	${CMAKE_CURRENT_SOURCE_DIR}
 	${LUA_JIT_INCLUDE_DIR}/src
-	${IMGUIPACK_INCLUDE_DIRS}
 	${EZLIBS_INCLUDE_DIR}
-	${GLAD_INCLUDE_DIR}                ## CustomInAppGpuProfiler.h (consumed via add_definitions) pulls glad+glfw
-	${GLFW_INCLUDE_DIR}
 	${CMAKE_SOURCE_DIR}
 	${SOL2_INCLUDE_DIR}
 )
 
 target_link_libraries(${PROJECT}
-	${IMGUIPACK_LIBRARIES}
 	${LUA_JIT_LIBRARIES}
 	${SOL2_LIBRARIES}
 )

plugins/LuaScripting/CMakeLists.txt

@@ -29,15 +29,13 @@ PLUGIN_PREFIX void deleter(LuaScripting* ptr) {
 LuaScripting::LuaScripting() = default;
 
 bool LuaScripting::init(ez::Log* vLoggerInstancePtr) {
-    m_SettingsPtr = std::make_shared<Settings>();
     // borrow the host's ez::Log so every LogVar* call from this DLL routes through
     // the host's standardLogFunctor (which pushes into the Messaging pane)
     ez::Log::initSingleton(vLoggerInstancePtr);
     return true;
 }
 
 void LuaScripting::unit() {
-    m_SettingsPtr.reset();
     ez::Log::unitSingleton();  // only releases the borrow — does NOT delete the host instance
 }
 
@@ -85,18 +83,7 @@ std::vector<Ltg::PluginModuleInfos> LuaScripting::getModulesInfos() const {
 
 Ltg::PluginModulePtr LuaScripting::createModule(const std::string& vPluginModuleName, Ltg::PluginBridge* vBridgePtr) {
     if (vPluginModuleName == "Lua") {
-        return Module::create(m_SettingsPtr);
+        return Module::create();
     }
     return nullptr;
 }
-
-std::vector<Ltg::PluginPaneConfig> LuaScripting::getPanes() const {
-    std::vector<Ltg::PluginPaneConfig> res;
-    return res;
-}
-
-std::vector<Ltg::PluginSettingsConfig> LuaScripting::getSettings() const {
-    std::vector<Ltg::PluginSettingsConfig> res;
-    res.push_back(Ltg::PluginSettingsConfig(m_SettingsPtr));
-    return res;
-}

plugins/LuaScripting/src/LuaScripting.cpp

@@ -1,12 +1,8 @@
 #pragma once
 
 #include <apis/LtgPluginApi.h>
-#include <Settings/Settings.h>
 
 class LuaScripting : public Ltg::PluginInterface {
-private:
-    SettingsPtr m_SettingsPtr = nullptr;  // common eettings for whole module
-
 public:
     LuaScripting();
     virtual ~LuaScripting() = default;
@@ -23,6 +19,4 @@ class LuaScripting : public Ltg::PluginInterface {
     std::string getDescription() const override;
     std::vector<Ltg::PluginModuleInfos> getModulesInfos() const override;
     Ltg::PluginModulePtr createModule(const std::string& vPluginModuleName, Ltg::PluginBridge* vBridgePtr) override;
-    std::vector<Ltg::PluginPaneConfig> getPanes() const override;
-    std::vector<Ltg::PluginSettingsConfig> getSettings() const override;
-};
+};