WINTERMUTE: Add DebuggerController

1 files changed, 219 insertions, 5 deletions

diff --git a/engines/wintermute/debugger.cpp b/engines/wintermute/debugger.cpp
index 5b617d9db9..42fba60f9a 100644
--- a/engines/wintermute/debugger.cpp
+++ b/engines/wintermute/debugger.cpp
@@ -21,29 +21,189 @@
  */
 
 #include "engines/wintermute/debugger.h"
-#include "engines/wintermute/wintermute.h"
 #include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/base/base_file_manager.h"
-#include "engines/wintermute/base/base_game.h"
+#include "engines/wintermute/base/scriptables/script_value.h"
+#include "engines/wintermute/debugger/debugger_controller.h"
+#include "engines/wintermute/wintermute.h"
+
+#define CONTROLLER _engineRef->_dbgController
 
 namespace Wintermute {
 
 Console::Console(WintermuteEngine *vm) : GUI::Debugger(), _engineRef(vm) {
 	registerCmd("show_fps", WRAP_METHOD(Console, Cmd_ShowFps));
 	registerCmd("dump_file", WRAP_METHOD(Console, Cmd_DumpFile));
+	registerCmd("show_fps", WRAP_METHOD(Console, Cmd_ShowFps));
+	registerCmd("dump_file", WRAP_METHOD(Console, Cmd_DumpFile));
+	registerCmd("help", WRAP_METHOD(Console, Cmd_Help));
+	// Actual (script) debugger commands
+	registerCmd(STEP_CMD, WRAP_METHOD(Console, Cmd_Step));
+	registerCmd(CONTINUE_CMD, WRAP_METHOD(Console, Cmd_Continue));
+	registerCmd(FINISH_CMD, WRAP_METHOD(Console, Cmd_Finish));
+	registerCmd(BREAK_CMD, WRAP_METHOD(Console, Cmd_AddBreakpoint));
+	registerCmd(LIST_CMD, WRAP_METHOD(Console, Cmd_List));
+	registerCmd(REMOVE_BREAKPOINT_CMD, WRAP_METHOD(Console, Cmd_RemoveBreakpoint));
+	registerCmd(DISABLE_BREAKPOINT_CMD, WRAP_METHOD(Console, Cmd_DisableBreakpoint));
+	registerCmd(ENABLE_BREAKPOINT_CMD, WRAP_METHOD(Console, Cmd_EnableBreakpoint));
+	registerCmd(INFO_CMD, WRAP_METHOD(Console, Cmd_Info));
+	registerCmd(TOP_CMD, WRAP_METHOD(Console, Cmd_Top));
 }
 
 Console::~Console(void) {
+}
+
+bool Console::Cmd_Help(int argc, const char **argv) {
+	if (argc == 1) {
+		// Debugger::Cmd_Help(argc, argv);
+		debugPrintf("\nType help somecommand to get specific help.\n");
+	} else {
+		printUsage(argv[1]);
+	}
+	return true;
+}
+
+void Console::printUsage(const Common::String &command) {
+	// TODO: This is horrible and would probably benefit from a map or something.
+	if (command.equals(BREAK_CMD)) {
+		debugPrintf("Usage: %s <file path> <line> to break at line <line> of file <file path>\n", command.c_str());
+	} else if (command.equals(REMOVE_BREAKPOINT_CMD)) {
+		debugPrintf("Usage: %s <id> to remove breakpoint #id\n", command.c_str());
+	} else if (command.equals(ENABLE_BREAKPOINT_CMD)) {
+		debugPrintf("Usage: %s <id> to enable breakpoint #id\n", command.c_str());
+	} else if (command.equals(DISABLE_BREAKPOINT_CMD)) {
+		debugPrintf("Usage: %s <id> to disable breakpoint #id\n", command.c_str());
+	} else if (command.equals(INFO_CMD)) {
+		debugPrintf("Usage: %s [watch|breakpoints]\n", command.c_str());
+	} else if (command.equals(STEP_CMD)) {
+		debugPrintf("Usage: %s to step\n", command.c_str());
+	} else if (command.equals(CONTINUE_CMD)) {
+		debugPrintf("Usage: %s to continue\n", command.c_str());
+	} else if (command.equals(FINISH_CMD)) {
+		debugPrintf("Usage: %s to finish\n", command.c_str());
+	} else {
+		debugPrintf("No help about this command, sorry.");
+	}
+}
+
+bool Console::Cmd_AddBreakpoint(int argc, const char **argv) {
+	if (argc == 3) {
+		Wintermute::Error error = CONTROLLER->addBreakpoint(argv[1], atoi(argv[2]));
+		printError(argv[0], error);
+	} else {
+		printUsage(argv[0]);
+	}
+	return true;
+}
 
+bool Console::Cmd_RemoveBreakpoint(int argc, const char **argv) {
+	if (argc == 2) {
+		Error error = CONTROLLER->removeBreakpoint(atoi(argv[1]));
+		printError(argv[0], error);
+	} else {
+		printUsage(argv[0]);
+	}
+	return true;
+}
+
+bool Console::Cmd_EnableBreakpoint(int argc, const char **argv) {
+	if (argc == 2) {
+		Error error = CONTROLLER->enableBreakpoint(atoi(argv[1]));
+		printError(argv[0], error);
+	} else {
+		printUsage(argv[0]);
+	}
+	return true;
+}
+
+bool Console::Cmd_DisableBreakpoint(int argc, const char **argv) {
+	if (argc == 2) {
+		Error error = CONTROLLER->disableBreakpoint(atoi(argv[1]));
+		debugPrintf("%s: %s\n", argv[0], error.getErrorDisplayStr().c_str());
+	} else {
+		printUsage(argv[0]);
+	}
+	return true;
+}
+
+bool Console::Cmd_Info(int argc, const char **argv) {
+	if (argc == 2 && !strncmp(argv[1], "breakpoints", 10)) {
+		Common::Array<BreakpointInfo> breakpoints = CONTROLLER->getBreakpoints();
+		for (uint i = 0; i < breakpoints.size(); i++) {
+			debugPrintf("%d %s:%d x%d, enabled: %d \n", i, breakpoints[i]._filename.c_str(), breakpoints[i]._line, breakpoints[i]._hits, breakpoints[i]._enabled);
+		}
+		return 1;
+	} else {
+		printUsage(argv[0]);
+		return 1;
+	}
+}
+
+bool Console::Cmd_Step(int argc, const char **argv) {
+	if (argc == 1) {
+		Error error = CONTROLLER->step();
+		if (error.getErrorLevel() == SUCCESS) {
+			return false;
+		} else {
+			printError(argv[0], error);
+			return true;
+		}
+	} else {
+		printUsage(argv[0]);
+		return true;
+	}
+}
+
+bool Console::Cmd_Continue(int argc, const char **argv) {
+	if (argc == 1) {
+		Error error = CONTROLLER->stepContinue();
+		if (error.getErrorLevel() == SUCCESS) {
+			return false;
+		} else {
+			printError(argv[0], error);
+			return true;
+		}
+	} else {
+		printUsage(argv[0]);
+		return true;
+	}
+}
+
+bool Console::Cmd_Finish(int argc, const char **argv) {
+	if (argc == 1) {
+		Error error = CONTROLLER->stepFinish();
+		printError(argv[0], error);
+		if (error.getErrorLevel() == SUCCESS) {
+			return false;
+		} else {
+			printError(argv[0], error);
+			return true;
+		}
+	} else {
+		printUsage(argv[0]);
+		return true;
+	}
+}
+
+bool Console::Cmd_List(int argc, const char **argv) {
+	Error error = printSource();
+	if (error.getErrorLevel() != SUCCESS) {
+		printError(argv[0], error);
+	}
+	return true;
 }
 
 bool Console::Cmd_ShowFps(int argc, const char **argv) {
-	if (argc > 1) {
+	if (argc == 2) {
 		if (Common::String(argv[1]) == "true") {
-			_engineRef->_game->setShowFPS(true);
+			CONTROLLER->showFps(true);
 		} else if (Common::String(argv[1]) == "false") {
-			_engineRef->_game->setShowFPS(false);
+			CONTROLLER->showFps(false);
+		} else {
+			debugPrintf("%s: argument 1 must be \"true\" or \"false\"\n", argv[0]);
 		}
+	} else {
+		debugPrintf("Usage: %s [true|false]\n", argv[0]);
 	}
 	return true;
 }
@@ -81,4 +241,58 @@ bool Console::Cmd_DumpFile(int argc, const char **argv) {
 	return true;
 }
 
+void Console::notifyBreakpoint(const char *filename, int line) {
+	debugPrintf("Breakpoint hit %s: %d\n", filename, line);
+	printSource(0);
+	attach();
+	onFrame();
+}
+
+void Console::notifyStep(const char *filename, int line) {
+	debugPrintf("Step: %s:%d\n", filename, line);
+	printSource(0);
+	attach();
+	onFrame();
+}
+
+Error Console::printSource(int n) {
+
+	Error* error = nullptr;
+	Listing *listing = CONTROLLER->getListing(error);
+	Error err(*error);
+	delete error;
+
+	if (err.getErrorLevel() == SUCCESS || err.getErrorLevel() == WARNING) {
+		Common::Array<ListingLine> lines = listing->getLines(CONTROLLER->getLastLine(), n);
+		for (uint i = 0; i < lines.size(); i++) {
+			if (lines[i].number == CONTROLLER->getLastLine()) {
+				debugPrintf(" -> ");
+			} else {
+				debugPrintf("    ");
+			}
+			debugPrintf("%d", lines[i].number);
+			debugPrintf("%s", lines[i].text.c_str());
+			debugPrintf("\n");
+		}
+	}
+
+	delete listing;
+	return err;
+}
+
+bool Console::Cmd_Top(int argc, const char **argv) {
+	Common::Array<TopEntry> entries = CONTROLLER->getTop();
+	for (uint i = 0; i < entries.size(); i++) {
+		if (entries[i].current) {
+			debugPrintf("%d*: %s\n", i, entries[i].filename.c_str());
+		} else {
+			debugPrintf("%d: %s\n", i, entries[i].filename.c_str());
+		}
+	}
+	return true;
+}
+
+void Console::printError(const Common::String &command, Error error) {
+	debugPrintf("%s: %s\n", command.c_str(), error.getErrorDisplayStr().c_str());
+}
 } // End of namespace Wintermute