chore: no need to register pydebug

ShrBox · ShrBox · commit d87d9623cb91 · 2025-02-08T16:13:15.000+08:00
diff --git a/src/legacy/api/EventAPI.cpp b/src/legacy/api/EventAPI.cpp
@@ -777,10 +777,12 @@ void InitBasicEventListeners() {
             if (cmd.starts_with("/")) {
                 cmd.erase(0, 1);
             }
+#ifndef LEGACY_SCRIPT_ENGINE_BACKEND_NODEJS
             if (!ProcessDebugEngine(cmd)) {
                 ev.cancel();
                 return;
             }
+#endif
 #ifdef LEGACY_SCRIPT_ENGINE_BACKEND_NODEJS
             if (!NodeJsHelper::processConsoleNpmCmd(cmd)) {
                 ev.cancel();
diff --git a/src/legacy/main/BuiltinCommands.cpp b/src/legacy/main/BuiltinCommands.cpp
@@ -16,32 +16,33 @@
 #include "PythonHelper.h"
 #endif
 
-extern bool                     isInConsoleDebugMode;
-extern ScriptEngine*            debugEngine;
-std::shared_ptr<ll::io::Logger> debugLogger = ll::io::LoggerRegistry::getInstance().getOrCreate("LSEDEBUG");
-inline void                     printConsoleSymbol() { debugLogger->info("> "); }
+extern bool                     InConsoleDebugMode;
+extern ScriptEngine*            DebugEngine;
+std::shared_ptr<ll::io::Logger> DebugCmdLogger = ll::io::LoggerRegistry::getInstance().getOrCreate("LSEDEBUG");
+
+inline void PrintDebugSign() { DebugCmdLogger->info("> "); }
 
 bool ProcessDebugEngine(const std::string& cmd) {
 #ifdef LEGACY_SCRIPT_ENGINE_BACKEND_PYTHON
     // process python debug seperately
     return PythonHelper::processPythonDebugEngine(cmd);
 #endif
-    if (isInConsoleDebugMode) {
-        EngineScope enter(debugEngine);
+    if (InConsoleDebugMode) {
+        EngineScope enter(DebugEngine);
         auto&       logger = lse::LegacyScriptEngine::getInstance().getSelf().getLogger();
         try {
             if (cmd == "stop" || cmd == LLSE_DEBUG_CMD) {
                 return true;
             } else {
-                auto               result = debugEngine->eval(cmd);
+                auto               result = DebugEngine->eval(cmd);
                 std::ostringstream sout;
                 PrintValue(sout, result);
                 logger.info(sout.str());
-                printConsoleSymbol();
+                PrintDebugSign();
             }
         } catch (...) {
             ll::error_utils::printCurrentException(logger);
-            printConsoleSymbol();
+            PrintDebugSign();
         }
         return false;
     }
@@ -53,34 +54,37 @@ struct EngineDebugCommand {
 };
 
 void RegisterDebugCommand() {
-    debugLogger->setFormatter(ll::makePolymorphic<lse::io::DirectFormatter>());
+    DebugCmdLogger->setFormatter(ll::makePolymorphic<lse::io::DirectFormatter>());
+    // Node.js engine doesn't support debug engine, Python engine don't need to register command.
+#if (!defined LEGACY_SCRIPT_ENGINE_BACKEND_NODEJS) && (!defined LEGACY_SCRIPT_ENGINE_BACKEND_PYTHON)
     auto& command = ll::command::CommandRegistrar::getInstance()
                         .getOrCreateCommand(LLSE_DEBUG_CMD, "Debug LegacyScriptEngine", CommandPermissionLevel::Owner);
     command.overload<EngineDebugCommand>().optional("eval").execute(
         [](CommandOrigin const&, CommandOutput& output, EngineDebugCommand const& param) {
             auto& logger = lse::LegacyScriptEngine::getInstance().getSelf().getLogger();
             if (!param.eval.getText().empty()) {
-                EngineScope enter(debugEngine);
+                EngineScope enter(DebugEngine);
                 try {
-                    auto               result = debugEngine->eval(param.eval.getText());
+                    auto               result = DebugEngine->eval(param.eval.getText());
                     std::ostringstream sout;
                     PrintValue(sout, result);
                     output.success(sout.str());
                 } catch (...) {
                     ll::error_utils::printCurrentException(logger);
                 }
             } else {
-                if (isInConsoleDebugMode) {
+                if (InConsoleDebugMode) {
                     // EndDebug
                     logger.info("Debug mode ended");
-                    isInConsoleDebugMode = false;
+                    InConsoleDebugMode = false;
                 } else {
                     // StartDebug
                     logger.info("Debug mode begins");
-                    isInConsoleDebugMode = true;
-                    printConsoleSymbol();
+                    InConsoleDebugMode = true;
+                    PrintDebugSign();
                 }
             }
         }
     );
+#endif
 }
diff --git a/src/legacy/main/PythonHelper.cpp b/src/legacy/main/PythonHelper.cpp
@@ -17,9 +17,10 @@
 const unsigned long PIP_EXECUTE_TIMEOUT = 1800 * 1000;
 
 // pre-declare
-extern void          BindAPIs(ScriptEngine* engine);
-extern bool          isInConsoleDebugMode;
-extern ScriptEngine* debugEngine;
+extern void                            BindAPIs(ScriptEngine* engine);
+extern bool                            InConsoleDebugMode;
+extern ScriptEngine*                   DebugEngine;
+extern std::shared_ptr<ll::io::Logger> DebugCmdLogger;
 
 struct PyConfig;
 typedef PyObject* (*create_stdio_func_type)(
@@ -142,8 +143,8 @@ std::string getPluginPackDependencyFilePath(const std::string& dirPath) {
     else return "";
 }
 
-inline void OUTPUT_DEBUG_SIGN() { std::cout << ">>> " << std::flush; }
-inline void OUTPUT_DEBUG_NEED_MORE_CODE_SIGN() { std::cout << "... " << std::flush; }
+inline void PrintPyDebugSign() { DebugCmdLogger->info(">>> "); }
+inline void OutputDebugNeedMoreCodeSign() { DebugCmdLogger->info("... "); }
 std::string codeBuffer        = "";
 bool        isInsideCodeBlock = false;
 
@@ -157,22 +158,23 @@ static PyObject* getPyGlobalDict() {
 
 bool processPythonDebugEngine(const std::string& cmd) {
     if (cmd == LLSE_DEBUG_CMD) {
-        if (isInConsoleDebugMode) {
+        auto& logger = lse::LegacyScriptEngine::getInstance().getSelf().getLogger();
+        if (InConsoleDebugMode) {
             // EndDebug
-            lse::LegacyScriptEngine::getInstance().getSelf().getLogger().info("Debug mode ended");
-            isInConsoleDebugMode = false;
+            logger.info("Debug mode ended");
+            InConsoleDebugMode = false;
         } else {
             // StartDebug
-            lse::LegacyScriptEngine::getInstance().getSelf().getLogger().info("Debug mode begins");
+            logger.info("Debug mode begins");
             codeBuffer.clear();
-            isInsideCodeBlock    = false;
-            isInConsoleDebugMode = true;
-            OUTPUT_DEBUG_SIGN();
+            isInsideCodeBlock  = false;
+            InConsoleDebugMode = true;
+            PrintPyDebugSign();
         }
         return false;
     }
-    if (isInConsoleDebugMode) {
-        EngineScope enter(debugEngine);
+    if (InConsoleDebugMode) {
+        EngineScope enter(DebugEngine);
         if (cmd == "stop") {
             return true;
         } else {
@@ -185,7 +187,7 @@ bool processPythonDebugEngine(const std::string& cmd) {
                     } else {
                         // add a new line to buffer
                         codeBuffer += cmd + "\n";
-                        OUTPUT_DEBUG_NEED_MORE_CODE_SIGN();
+                        OutputDebugNeedMoreCodeSign();
                         return false;
                     }
                 } else {
@@ -194,7 +196,7 @@ bool processPythonDebugEngine(const std::string& cmd) {
                         // begin code block mode
                         isInsideCodeBlock = true;
                         codeBuffer        = cmd + "\n";
-                        OUTPUT_DEBUG_NEED_MORE_CODE_SIGN();
+                        OutputDebugNeedMoreCodeSign();
                         return false;
                     } else {
                         codeBuffer = cmd;
@@ -207,13 +209,13 @@ bool processPythonDebugEngine(const std::string& cmd) {
                     auto exp = script::py_interop::getAndClearLastException();
                     throw exp;
                 }
-            } catch (const Exception& e) {
+            } catch (...) {
                 isInsideCodeBlock = false;
                 codeBuffer.clear();
-                ll::error_utils::printException(e, lse::LegacyScriptEngine::getInstance().getSelf().getLogger());
+                ll::error_utils::printCurrentException(logger);
             }
         }
-        OUTPUT_DEBUG_SIGN();
+        PrintPyDebugSign();
         return false;
     }
     return true;
diff --git a/src/lse/Entry.cpp b/src/lse/Entry.cpp
@@ -55,8 +55,8 @@ void                  InitLocalShareData();
 void                  InitMessageSystem();
 void                  InitSafeGuardRecord();
 void                  RegisterDebugCommand();
-bool                  isInConsoleDebugMode; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-script::ScriptEngine* debugEngine;          // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+bool                  InConsoleDebugMode; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+script::ScriptEngine* DebugEngine;        // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 namespace lse {
 
@@ -75,14 +75,14 @@ bool LegacyScriptEngine::enable() {
         logger.error("Failed to enable MoreGlobal"_tr());
     }
     ll::service::PlayerInfo::getInstance();
-#ifndef LEGACY_SCRIPT_ENGINE_BACKEND_NODEJS
+
     try {
         RegisterDebugCommand();
-    } catch (const std::exception& error) {
-        logger.error("Failed to enable: {0}"_tr(error.what()));
+    } catch (...) {
+        logger.error("Failed to enable: {0}"_tr("RegisterDebugCommand"));
+        ll::error_utils::printCurrentException(logger);
         return false;
     }
-#endif
     return true;
 }
 
@@ -172,7 +172,7 @@ void loadDebugEngine(const ll::mod::NativeMod& self) {
     }
     scriptEngine->eval(baseLibContent.value());
 
-    debugEngine = scriptEngine;
+    DebugEngine = scriptEngine;
 #endif
 }
 

Original file line number	Diff line number	Diff line change
`@@ -777,10 +777,12 @@ void InitBasicEventListeners() {`
`777`	`777`	`if (cmd.starts_with("/")) {`
`778`	`778`	`cmd.erase(0, 1);`
`779`	`779`	`}`
	`780`	`+#ifndef LEGACY_SCRIPT_ENGINE_BACKEND_NODEJS`
`780`	`781`	`if (!ProcessDebugEngine(cmd)) {`
`781`	`782`	`ev.cancel();`
`782`	`783`	`return;`
`783`	`784`	`}`
	`785`	`+#endif`
`784`	`786`	`#ifdef LEGACY_SCRIPT_ENGINE_BACKEND_NODEJS`
`785`	`787`	`if (!NodeJsHelper::processConsoleNpmCmd(cmd)) {`
`786`	`788`	`ev.cancel();`