Overhaul of the debugger code

* Moved Common::Debuggger to GUI::Debugger (mainly to satisfy linker
  restrictions)
* Change the base Debugger class to *not* be a template class anymore;
  instead, a thin (template based) wrapper class is used to hook up
  debugger commands
* Removed duplicate Cmd_Exit and Cmd_Help methods in favor of a single
  version of each in GUI::Debugger
* New Cmd_Help doesn't word wrap after 39/78 chars, but rather queries
  the console to determine when to wrap
* Debugger::preEnter and postEnter aren't pure virtual anymore

svn-id: r23890

18 files changed, 154 insertions, 504 deletions

diff --git a/engines/agi/console.cpp b/engines/agi/console.cpp
index 1c761f1c6f..abf66ced48 100644
--- a/engines/agi/console.cpp
+++ b/engines/agi/console.cpp
@@ -32,33 +32,28 @@
 #include "agi/opcodes.h"
 #include "agi/console.h"
 
-#include "common/debugger.cpp"
-
 namespace Agi {
 
 struct agi_debug debug_;
 
-Console::Console(AgiEngine *vm) : Common::Debugger<Console>() {
+Console::Console(AgiEngine *vm) : GUI::Debugger() {
 	_vm = vm;
 
-	DCmd_Register("debug", &Console::Cmd_Debug);
-	DCmd_Register("cont", &Console::Cmd_Cont);
-	DCmd_Register("exit", &Console::Cmd_Exit);
-	DCmd_Register("quit", &Console::Cmd_Exit);
-	DCmd_Register("help", &Console::Cmd_Help);
-	DCmd_Register("agiver", &Console::Cmd_Agiver);
-	DCmd_Register("crc", &Console::Cmd_Crc);
-	DCmd_Register("flags", &Console::Cmd_Flags);
-	DCmd_Register("logic0", &Console::Cmd_Logic0);
-	DCmd_Register("objs", &Console::Cmd_Objs);
-	DCmd_Register("runopcode", &Console::Cmd_RunOpcode);
-	DCmd_Register("opcode", &Console::Cmd_Opcode);
-	DCmd_Register("step", &Console::Cmd_Step);
-	DCmd_Register("trigger", &Console::Cmd_Trigger);
-	DCmd_Register("vars", &Console::Cmd_Vars);
-	DCmd_Register("setvar", &Console::Cmd_SetVar);
-	DCmd_Register("setflag", &Console::Cmd_SetFlag);
-	DCmd_Register("setobj", &Console::Cmd_SetObj);
+	DCmd_Register("debug",      WRAP_METHOD(Console, Cmd_Debug));
+	DCmd_Register("cont",       WRAP_METHOD(Console, Cmd_Cont));
+	DCmd_Register("agiver",     WRAP_METHOD(Console, Cmd_Agiver));
+	DCmd_Register("crc",        WRAP_METHOD(Console, Cmd_Crc));
+	DCmd_Register("flags",      WRAP_METHOD(Console, Cmd_Flags));
+	DCmd_Register("logic0",     WRAP_METHOD(Console, Cmd_Logic0));
+	DCmd_Register("objs",       WRAP_METHOD(Console, Cmd_Objs));
+	DCmd_Register("runopcode",  WRAP_METHOD(Console, Cmd_RunOpcode));
+	DCmd_Register("opcode",     WRAP_METHOD(Console, Cmd_Opcode));
+	DCmd_Register("step",       WRAP_METHOD(Console, Cmd_Step));
+	DCmd_Register("trigger",    WRAP_METHOD(Console, Cmd_Trigger));
+	DCmd_Register("vars",       WRAP_METHOD(Console, Cmd_Vars));
+	DCmd_Register("setvar",     WRAP_METHOD(Console, Cmd_SetVar));
+	DCmd_Register("setflag",    WRAP_METHOD(Console, Cmd_SetFlag));
+	DCmd_Register("setobj",     WRAP_METHOD(Console, Cmd_SetObj));
 }
 
 Console::~Console() {
@@ -70,34 +65,6 @@ void Console::preEnter() {
 void Console::postEnter() {
 }
 
-bool Console::Cmd_Exit(int argc, const char **argv) {
-	_detach_now = true;
-	return false;
-}
-
-bool Console::Cmd_Help(int argc, const char **argv) {
-	// console normally has 39 line width
-	// wrap around nicely
-	int width = 0, size, i;
-
-	DebugPrintf("Commands are:\n");
-	for (i = 0 ; i < _dcmd_count ; i++) {
-		size = strlen(_dcmds[i].name) + 1;
-
-		if ((width + size) >= 39) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dcmds[i].name);
-	}
-
-	DebugPrintf("\n");
-
-	return true;
-}
-
 bool Console::Cmd_SetVar(int argc, const char **argv) {
 	if (argc != 3) {
 		DebugPrintf("Usage: setvar <varnum> <value>");
diff --git a/engines/agi/console.h b/engines/agi/console.h
index c94a9099e5..e0f108afce 100644
--- a/engines/agi/console.h
+++ b/engines/agi/console.h
@@ -25,7 +25,7 @@
 #ifndef AGI_CONSOLE_H
 #define AGI_CONSOLE_H
 
-#include "common/debugger.h"
+#include "gui/debugger.h"
 
 namespace Agi {
 
@@ -41,7 +41,7 @@ struct agi_debug {
 	int ignoretriggers;
 };
 
-class Console : public Common::Debugger<Console> {
+class Console : public GUI::Debugger {
 public:
 	Console(AgiEngine *vm);
 	virtual ~Console(void);
@@ -51,8 +51,6 @@ protected:
 	virtual void postEnter();
 
 private:
-	bool Cmd_Exit(int argc, const char **argv);
-	bool Cmd_Help(int argc, const char **argv);
 	bool Cmd_SetVar(int argc, const char **argv);
 	bool Cmd_SetFlag(int argc, const char **argv);
 	bool Cmd_SetObj(int argc, const char **argv);
diff --git a/engines/kyra/debugger.cpp b/engines/kyra/debugger.cpp
index 7e3b109448..30ec201f27 100644
--- a/engines/kyra/debugger.cpp
+++ b/engines/kyra/debugger.cpp
@@ -22,7 +22,7 @@
 
 #include "common/stdafx.h"
 #include "common/config-manager.h"
-#include "common/debugger.cpp"
+#include "common/system.h"
 #include "kyra/debugger.h"
 #include "kyra/kyra.h"
 #include "kyra/screen.h"
@@ -30,21 +30,18 @@
 namespace Kyra {
 
 Debugger::Debugger(KyraEngine *vm)
-	: Common::Debugger<Debugger>() {
+	: GUI::Debugger() {
 	_vm = vm;
 
-	DCmd_Register("continue",			&Debugger::cmd_exit);
-	DCmd_Register("exit",				&Debugger::cmd_exit);
-	DCmd_Register("help",				&Debugger::cmd_help);
-	DCmd_Register("quit",				&Debugger::cmd_exit);
-	DCmd_Register("enter",				&Debugger::cmd_enterRoom);
-	DCmd_Register("rooms",				&Debugger::cmd_listRooms);
-	DCmd_Register("flags",				&Debugger::cmd_listFlags);
-	DCmd_Register("toggleflag",			&Debugger::cmd_toggleFlag);
-	DCmd_Register("queryflag",			&Debugger::cmd_queryFlag);
-	DCmd_Register("timers",				&Debugger::cmd_listTimers);
-	DCmd_Register("settimercountdown",	&Debugger::cmd_setTimerCountdown);
-	DCmd_Register("give",				&Debugger::cmd_giveItem);
+	DCmd_Register("continue",			WRAP_METHOD(Debugger, Cmd_Exit));
+	DCmd_Register("enter",				WRAP_METHOD(Debugger, cmd_enterRoom));
+	DCmd_Register("rooms",				WRAP_METHOD(Debugger, cmd_listRooms));
+	DCmd_Register("flags",				WRAP_METHOD(Debugger, cmd_listFlags));
+	DCmd_Register("toggleflag",			WRAP_METHOD(Debugger, cmd_toggleFlag));
+	DCmd_Register("queryflag",			WRAP_METHOD(Debugger, cmd_queryFlag));
+	DCmd_Register("timers",				WRAP_METHOD(Debugger, cmd_listTimers));
+	DCmd_Register("settimercountdown",	WRAP_METHOD(Debugger, cmd_setTimerCountdown));
+	DCmd_Register("give",				WRAP_METHOD(Debugger, cmd_giveItem));
 }
 
 void Debugger::preEnter() {
@@ -93,32 +90,6 @@ bool Debugger::cmd_enterRoom(int argc, const char **argv) {
 	return true;
 }
 
-bool Debugger::cmd_exit(int argc, const char **argv) {
-	_detach_now = true;
-	return false;
-}
-
-bool Debugger::cmd_help(int argc, const char **argv) {
-	// console normally has 39 line width
-	// wrap around nicely
-	int width = 0, size, i;
-
-	DebugPrintf("Commands are:\n");
-	for (i = 0 ; i < _dcmd_count ; i++) {
-		size = strlen(_dcmds[i].name) + 1;
-
-		if ((width + size) >= 39) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dcmds[i].name);
-	}
-	DebugPrintf("\n");
-	return true;
-}
-
 bool Debugger::cmd_listRooms(int argc, const char **argv) {
 	for (int i = 0; i < _vm->_roomTableSize; i++) {
 		DebugPrintf("%-3i: %-10s", i, _vm->_roomFilenameTable[_vm->_roomTable[i].nameIndex]);
diff --git a/engines/kyra/debugger.h b/engines/kyra/debugger.h
index 69766f3fc0..91f90ee3ef 100644
--- a/engines/kyra/debugger.h
+++ b/engines/kyra/debugger.h
@@ -23,13 +23,13 @@
 #ifndef KYRA_DEBUGGER_H
 #define KYRA_DEBUGGER_H
 
-#include "common/debugger.h"
+#include "gui/debugger.h"
 
 namespace Kyra {
 
 class KyraEngine;
 
-class Debugger : public Common::Debugger<Debugger> {
+class Debugger : public GUI::Debugger {
 public:
 	Debugger(KyraEngine *vm);
 	virtual ~Debugger() {}  // we need this for __SYMBIAN32__ archaic gcc/UIQ
@@ -40,8 +40,6 @@ protected:
 	virtual void preEnter();
 	virtual void postEnter();
 
-	bool cmd_exit(int argc, const char **argv);
-	bool cmd_help(int argc, const char **argv);
 	bool cmd_enterRoom(int argc, const char **argv);
 	bool cmd_listRooms(int argc, const char **argv);
 	bool cmd_listFlags(int argc, const char **argv);
diff --git a/engines/lure/debugger.cpp b/engines/lure/debugger.cpp
index 4c67176a27..1d26556917 100644
--- a/engines/lure/debugger.cpp
+++ b/engines/lure/debugger.cpp
@@ -22,7 +22,6 @@
 
 #include "common/stdafx.h"
 #include "common/config-manager.h"
-#include "common/debugger.cpp"
 #include "lure/debugger.h"
 #include "lure/res.h"
 #include "lure/res_struct.h"
@@ -31,19 +30,16 @@
 
 namespace Lure {
 
-Debugger::Debugger(): Common::Debugger<Debugger>() {
-	DCmd_Register("continue",			&Debugger::cmd_exit);
-	DCmd_Register("exit",				&Debugger::cmd_exit);
-	DCmd_Register("help",				&Debugger::cmd_help);
-	DCmd_Register("quit",				&Debugger::cmd_exit);
-	DCmd_Register("enter",				&Debugger::cmd_enterRoom);
-	DCmd_Register("rooms",				&Debugger::cmd_listRooms);
-	DCmd_Register("fields",				&Debugger::cmd_listFields);
-	DCmd_Register("setfield",			&Debugger::cmd_setField);
-	DCmd_Register("queryfield",			&Debugger::cmd_queryField);
-	DCmd_Register("give",				&Debugger::cmd_giveItem);
-	DCmd_Register("hotspots",			&Debugger::cmd_hotspots);
-	DCmd_Register("hotspot",			&Debugger::cmd_hotspot);
+Debugger::Debugger(): GUI::Debugger() {
+	DCmd_Register("continue",			WRAP_METHOD(Debugger, Cmd_Exit));
+	DCmd_Register("enter",				WRAP_METHOD(Debugger, cmd_enterRoom));
+	DCmd_Register("rooms",				WRAP_METHOD(Debugger, cmd_listRooms));
+	DCmd_Register("fields",				WRAP_METHOD(Debugger, cmd_listFields));
+	DCmd_Register("setfield",			WRAP_METHOD(Debugger, cmd_setField));
+	DCmd_Register("queryfield",			WRAP_METHOD(Debugger, cmd_queryField));
+	DCmd_Register("give",				WRAP_METHOD(Debugger, cmd_giveItem));
+	DCmd_Register("hotspots",			WRAP_METHOD(Debugger, cmd_hotspots));
+	DCmd_Register("hotspot",			WRAP_METHOD(Debugger, cmd_hotspot));
 }
 
 static int strToInt(const char *s) {
@@ -73,14 +69,6 @@ static int strToInt(const char *s) {
 	return result;
 }
 
-void Debugger::preEnter() {
-	// NO IMPLEMENTATION
-}
-
-void Debugger::postEnter() {
-	// NO IMPLEMENTATION
-}
-
 bool Debugger::cmd_enterRoom(int argc, const char **argv) {
 	Resources &res = Resources::getReference();
 	Room &room = Room::getReference();
@@ -114,32 +102,6 @@ bool Debugger::cmd_enterRoom(int argc, const char **argv) {
 	return true;
 }
 
-bool Debugger::cmd_exit(int argc, const char **argv) {
-	_detach_now = true;
-	return false;
-}
-
-bool Debugger::cmd_help(int argc, const char **argv) {
-	// console normally has 39 line width
-	// wrap around nicely
-	int width = 0, size, i;
-
-	DebugPrintf("Commands are:\n");
-	for (i = 0 ; i < _dcmd_count ; i++) {
-		size = strlen(_dcmds[i].name) + 1;
-
-		if ((width + size) >= 69) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dcmds[i].name);
-	}
-	DebugPrintf("\n");
-	return true;
-}
-
 bool Debugger::cmd_listRooms(int argc, const char **argv) {
 	RoomDataList &rooms = Resources::getReference().roomData();
 	RoomDataList::iterator i;
diff --git a/engines/lure/debugger.h b/engines/lure/debugger.h
index cfd48ec274..6080c76fb5 100644
--- a/engines/lure/debugger.h
+++ b/engines/lure/debugger.h
@@ -23,23 +23,18 @@
 #ifndef LURE_DEBUGGER_H
 #define LURE_DEBUGGER_H
 
-#include "common/debugger.h"
+#include "gui/debugger.h"
 
 namespace Lure {
 
 class KyraEngine;
 
-class Debugger : public Common::Debugger<Debugger> {
+class Debugger : public GUI::Debugger {
 public:
 	Debugger();
 	virtual ~Debugger() {}  // we need this for __SYMBIAN32__ archaic gcc/UIQ
 
 protected:
-	virtual void preEnter();
-	virtual void postEnter();
-
-	bool cmd_exit(int argc, const char **argv);
-	bool cmd_help(int argc, const char **argv);
 	bool cmd_enterRoom(int argc, const char **argv);
 	bool cmd_listRooms(int argc, const char **argv);
 	bool cmd_listFields(int argc, const char **argv);
diff --git a/engines/queen/debug.cpp b/engines/queen/debug.cpp
index 63fc40f444..8f49753d17 100644
--- a/engines/queen/debug.cpp
+++ b/engines/queen/debug.cpp
@@ -29,24 +29,20 @@
 #include "queen/resource.h"
 #include "queen/sound.h"
 
-#include "common/debugger.cpp"
-
 namespace Queen {
 
 Debugger::Debugger(QueenEngine *vm)
 	: _vm(vm), _flags(0) {
 
-	DCmd_Register("exit", &Debugger::Cmd_Exit);
-	DCmd_Register("help", &Debugger::Cmd_Help);
-	DCmd_Register("areas", &Debugger::Cmd_Areas);
-	DCmd_Register("asm", &Debugger::Cmd_Asm);
-	DCmd_Register("bob", &Debugger::Cmd_Bob);
-	DCmd_Register("bobs", &Debugger::Cmd_PrintBobs);
-	DCmd_Register("gs", &Debugger::Cmd_GameState);
-	DCmd_Register("info", &Debugger::Cmd_Info);
-	DCmd_Register("items", &Debugger::Cmd_Items);
-	DCmd_Register("room", &Debugger::Cmd_Room);
-	DCmd_Register("song", &Debugger::Cmd_Song);
+	DCmd_Register("areas", WRAP_METHOD(Debugger, Cmd_Areas));
+	DCmd_Register("asm",   WRAP_METHOD(Debugger, Cmd_Asm));
+	DCmd_Register("bob",   WRAP_METHOD(Debugger, Cmd_Bob));
+	DCmd_Register("bobs",  WRAP_METHOD(Debugger, Cmd_PrintBobs));
+	DCmd_Register("gs",    WRAP_METHOD(Debugger, Cmd_GameState));
+	DCmd_Register("info",  WRAP_METHOD(Debugger, Cmd_Info));
+	DCmd_Register("items", WRAP_METHOD(Debugger, Cmd_Items));
+	DCmd_Register("room",  WRAP_METHOD(Debugger, Cmd_Room));
+	DCmd_Register("song",  WRAP_METHOD(Debugger, Cmd_Song));
 }
 
 Debugger::~Debugger() {} // we need this here for __SYMBIAN32__
@@ -57,32 +53,6 @@ void Debugger::postEnter() {
 	_vm->graphics()->setupMouseCursor();
 }
 
-bool Debugger::Cmd_Exit(int argc, const char **argv) {
-	_detach_now = true;
-	return false;
-}
-
-bool Debugger::Cmd_Help(int argc, const char **argv) {
-	// console normally has 39 line width
-	// wrap around nicely
-	int width = 0, size, i;
-
-	DebugPrintf("Commands are:\n");
-	for (i = 0 ; i < _dcmd_count ; i++) {
-		size = strlen(_dcmds[i].name) + 1;
-
-		if ((width + size) >= 39) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dcmds[i].name);
-	}
-	DebugPrintf("\n");
-	return true;
-}
-
 bool Debugger::Cmd_Asm(int argc, const char **argv) {
 	if (argc == 2) {
 		uint16 sm = atoi(argv[1]);
diff --git a/engines/queen/debug.h b/engines/queen/debug.h
index 40cb8bb6ff..0959686a45 100644
--- a/engines/queen/debug.h
+++ b/engines/queen/debug.h
@@ -23,13 +23,13 @@
 #ifndef QUEENDEBUG_H
 #define QUEENDEBUG_H
 
-#include "common/debugger.h"
+#include "gui/debugger.h"
 
 namespace Queen {
 
 class QueenEngine;
 
-class Debugger : public Common::Debugger<Debugger> {
+class Debugger : public GUI::Debugger {
 public:
 
 	Debugger(QueenEngine *vm);
@@ -46,8 +46,6 @@ protected:
 	virtual void preEnter();
 	virtual void postEnter();
 
-	bool Cmd_Exit(int argc, const char **argv);
-	bool Cmd_Help(int argc, const char **argv);
 	bool Cmd_Areas(int argc, const char **argv);
 	bool Cmd_Asm(int argc, const char **argv);
 	bool Cmd_Bob(int argc, const char **argv);
diff --git a/engines/saga/console.cpp b/engines/saga/console.cpp
index 3455c8c1c3..6aa7c60de9 100644
--- a/engines/saga/console.cpp
+++ b/engines/saga/console.cpp
@@ -32,26 +32,21 @@
 
 #include "saga/console.h"
 
-#include "common/debugger.cpp"
-
 namespace Saga {
 
-Console::Console(SagaEngine *vm) : Common::Debugger<Console>() {
+Console::Console(SagaEngine *vm) : GUI::Debugger() {
 	_vm = vm;
 
-	DCmd_Register("continue", &Console::Cmd_Exit);
-	DCmd_Register("exit", &Console::Cmd_Exit);
-	DCmd_Register("quit", &Console::Cmd_Exit);
-	DCmd_Register("help", &Console::Cmd_Help);
+	DCmd_Register("continue",         WRAP_METHOD(Console, Cmd_Exit));
 
 	// CVAR_Register_I(&_soundEnabled, "sound", NULL, CVAR_CFG, 0, 1);
 	// CVAR_Register_I(&_musicEnabled, "music", NULL, CVAR_CFG, 0, 1);
 
 	// Actor commands
-	DCmd_Register("actor_walk_to", &Console::cmdActorWalkTo);
+	DCmd_Register("actor_walk_to",    WRAP_METHOD(Console, cmdActorWalkTo));
 
 	// Animation commands
-	DCmd_Register("anim_info", &Console::Cmd_AnimInfo);
+	DCmd_Register("anim_info",        WRAP_METHOD(Console, Cmd_AnimInfo));
 
 	// Game stuff
 
@@ -66,63 +61,14 @@ Console::Console(SagaEngine *vm) : Common::Debugger<Console>() {
 #endif
 
 	// Scene commands
-	DCmd_Register("scene_change", &Console::cmdSceneChange);
-	DCmd_Register("action_map_info", &Console::cmdActionMapInfo);
-	DCmd_Register("object_map_info", &Console::cmdObjectMapInfo);
+	DCmd_Register("scene_change",     WRAP_METHOD(Console, cmdSceneChange));
+	DCmd_Register("action_map_info",  WRAP_METHOD(Console, cmdActionMapInfo));
+	DCmd_Register("object_map_info",  WRAP_METHOD(Console, cmdObjectMapInfo));
 }
 
 Console::~Console() {
 }
 
-void Console::preEnter() {
-}
-
-void Console::postEnter() {
-}
-
-bool Console::Cmd_Exit(int argc, const char **argv) {
-	_detach_now = true;
-	return false;
-}
-
-bool Console::Cmd_Help(int argc, const char **argv) {
-	// console normally has 39 line width
-	// wrap around nicely
-	int width = 0, size, i;
-
-	DebugPrintf("Commands are:\n");
-	for (i = 0 ; i < _dcmd_count ; i++) {
-		size = strlen(_dcmds[i].name) + 1;
-
-		if ((width + size) >= 39) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dcmds[i].name);
-	}
-
-	width = 0;
-
-	DebugPrintf("\n\nVariables are:\n");
-	for (i = 0 ; i < _dvar_count ; i++) {
-		size = strlen(_dvars[i].name) + 1;
-
-		if ((width + size) >= 39) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dvars[i].name);
-	}
-
-	DebugPrintf("\n");
-
-	return true;
-}
-
 bool Console::cmdActorWalkTo(int argc, const char **argv) {
 	if (argc != 4)
 		DebugPrintf("Usage: %s <Actor id> <lx> <ly>\n", argv[0]);
diff --git a/engines/saga/console.h b/engines/saga/console.h
index c93373960f..1a2693e25e 100644
--- a/engines/saga/console.h
+++ b/engines/saga/console.h
@@ -27,23 +27,16 @@
 #ifndef SAGA_CONSOLE_H_
 #define SAGA_CONSOLE_H_
 
-#include "common/debugger.h"
+#include "gui/debugger.h"
 
 namespace Saga {
 
-class Console : public Common::Debugger<Console> {
+class Console : public GUI::Debugger {
 public:
 	Console(SagaEngine *vm);
 	virtual ~Console(void);
 
-protected:
-	virtual void preEnter();
-	virtual void postEnter();
-
 private:
-	bool Cmd_Exit(int argc, const char **argv);
-	bool Cmd_Help(int argc, const char **argv);
-
 	bool cmdActorWalkTo(int argc, const char **argv);
 
 	bool Cmd_AnimInfo(int argc, const char **argv);
diff --git a/engines/scumm/debugger.cpp b/engines/scumm/debugger.cpp
index c064405b15..fe4f13ead7 100644
--- a/engines/scumm/debugger.cpp
+++ b/engines/scumm/debugger.cpp
@@ -36,8 +36,6 @@
 #include "scumm/scumm.h"
 #include "scumm/sound.h"
 
-#include "common/debugger.cpp"
-
 namespace Scumm {
 
 // Debug channel lookup table for Debugger console
@@ -71,7 +69,7 @@ void CDECL debugC(int channel, const char *s, ...) {
 }
 
 ScummDebugger::ScummDebugger(ScummEngine *s)
-	: Common::Debugger<ScummDebugger>() {
+	: GUI::Debugger() {
 	_vm = s;
 
 	// Register variables
@@ -87,38 +85,35 @@ ScummDebugger::ScummDebugger(ScummEngine *s)
 	DVar_Register("scumm_gameid", &_vm->_game.id, DVAR_BYTE, 0);
 
 	// Register commands
-	DCmd_Register("continue", &ScummDebugger::Cmd_Exit);
-	DCmd_Register("exit", &ScummDebugger::Cmd_Exit);
-	DCmd_Register("quit", &ScummDebugger::Cmd_Exit);
-	DCmd_Register("restart", &ScummDebugger::Cmd_Restart);
-
-	DCmd_Register("actor", &ScummDebugger::Cmd_Actor);
-	DCmd_Register("actors", &ScummDebugger::Cmd_PrintActor);
-	DCmd_Register("box", &ScummDebugger::Cmd_PrintBox);
-	DCmd_Register("matrix", &ScummDebugger::Cmd_PrintBoxMatrix);
-	DCmd_Register("camera", &ScummDebugger::Cmd_Camera);
-	DCmd_Register("room", &ScummDebugger::Cmd_Room);
-	DCmd_Register("objects", &ScummDebugger::Cmd_PrintObjects);
-	DCmd_Register("object", &ScummDebugger::Cmd_Object);
-	DCmd_Register("script", &ScummDebugger::Cmd_Script);
-	DCmd_Register("scr", &ScummDebugger::Cmd_Script);
-	DCmd_Register("scripts", &ScummDebugger::Cmd_PrintScript);
-	DCmd_Register("importres", &ScummDebugger::Cmd_ImportRes);
+	DCmd_Register("continue",  WRAP_METHOD(ScummDebugger, Cmd_Exit));
+	DCmd_Register("restart",   WRAP_METHOD(ScummDebugger, Cmd_Restart));
+
+	DCmd_Register("actor",     WRAP_METHOD(ScummDebugger, Cmd_Actor));
+	DCmd_Register("actors",    WRAP_METHOD(ScummDebugger, Cmd_PrintActor));
+	DCmd_Register("box",       WRAP_METHOD(ScummDebugger, Cmd_PrintBox));
+	DCmd_Register("matrix",    WRAP_METHOD(ScummDebugger, Cmd_PrintBoxMatrix));
+	DCmd_Register("camera",    WRAP_METHOD(ScummDebugger, Cmd_Camera));
+	DCmd_Register("room",      WRAP_METHOD(ScummDebugger, Cmd_Room));
+	DCmd_Register("objects",   WRAP_METHOD(ScummDebugger, Cmd_PrintObjects));
+	DCmd_Register("object",    WRAP_METHOD(ScummDebugger, Cmd_Object));
+	DCmd_Register("script",    WRAP_METHOD(ScummDebugger, Cmd_Script));
+	DCmd_Register("scr",       WRAP_METHOD(ScummDebugger, Cmd_Script));
+	DCmd_Register("scripts",   WRAP_METHOD(ScummDebugger, Cmd_PrintScript));
+	DCmd_Register("importres", WRAP_METHOD(ScummDebugger, Cmd_ImportRes));
 
 	if (_vm->_game.id == GID_LOOM)
-		DCmd_Register("drafts", &ScummDebugger::Cmd_PrintDraft);
+		DCmd_Register("drafts",  WRAP_METHOD(ScummDebugger, Cmd_PrintDraft));
 
-	DCmd_Register("loadgame", &ScummDebugger::Cmd_LoadGame);
-	DCmd_Register("savegame", &ScummDebugger::Cmd_SaveGame);
+	DCmd_Register("loadgame",  WRAP_METHOD(ScummDebugger, Cmd_LoadGame));
+	DCmd_Register("savegame",  WRAP_METHOD(ScummDebugger, Cmd_SaveGame));
 
-	DCmd_Register("level", &ScummDebugger::Cmd_DebugLevel);
-	DCmd_Register("debug", &ScummDebugger::Cmd_Debug);
-	DCmd_Register("help", &ScummDebugger::Cmd_Help);
+	DCmd_Register("level",     WRAP_METHOD(ScummDebugger, Cmd_DebugLevel));
+	DCmd_Register("debug",     WRAP_METHOD(ScummDebugger, Cmd_Debug));
 
-	DCmd_Register("show", &ScummDebugger::Cmd_Show);
-	DCmd_Register("hide", &ScummDebugger::Cmd_Hide);
+	DCmd_Register("show",      WRAP_METHOD(ScummDebugger, Cmd_Show));
+	DCmd_Register("hide",      WRAP_METHOD(ScummDebugger, Cmd_Hide));
 
-	DCmd_Register("imuse", &ScummDebugger::Cmd_IMuse);
+	DCmd_Register("imuse",     WRAP_METHOD(ScummDebugger, Cmd_IMuse));
 }
 
 ScummDebugger::~ScummDebugger() {} // we need this here for __SYMBIAN32__
@@ -138,11 +133,6 @@ void ScummDebugger::postEnter() {
 // Now the fun stuff:
 
 // Commands
-bool ScummDebugger::Cmd_Exit(int argc, const char **argv) {
-	_detach_now = true;
-	return false;
-}
-
 bool ScummDebugger::Cmd_Restart(int argc, const char **argv) {
 	_vm->restart();
 
@@ -518,44 +508,6 @@ bool ScummDebugger::Cmd_Object(int argc, const char **argv) {
 	return true;
 }
 
-bool ScummDebugger::Cmd_Help(int argc, const char **argv) {
-	// console normally has 39 line width
-	// wrap around nicely
-	int width = 0, size, i;
-
-	DebugPrintf("Commands are:\n");
-	for (i = 0 ; i < _dcmd_count ; i++) {
-		size = strlen(_dcmds[i].name) + 1;
-
-		if ((width + size) >= 39) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dcmds[i].name);
-	}
-
-	width = 0;
-
-	DebugPrintf("\n\nVariables are:\n");
-	for (i = 0 ; i < _dvar_count ; i++) {
-		size = strlen(_dvars[i].name) + 1;
-
-		if ((width + size) >= 39) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dvars[i].name);
-	}
-
-	DebugPrintf("\n");
-
-	return true;
-}
-
 bool ScummDebugger::Cmd_Debug(int argc, const char **argv) {
 	int numChannels = sizeof(debugChannels) / sizeof(dbgChannelDesc);
 
diff --git a/engines/scumm/debugger.h b/engines/scumm/debugger.h
index 664c28923d..d781b957de 100644
--- a/engines/scumm/debugger.h
+++ b/engines/scumm/debugger.h
@@ -19,16 +19,16 @@
  * $Id$
  */
 
-#ifndef DEBUGGER_H
-#define DEBUGGER_H
+#ifndef SCUMM_DEBUGGER_H
+#define SCUMM_DEBUGGER_H
 
-#include "common/debugger.h"
+#include "gui/debugger.h"
 
 namespace Scumm {
 
 class ScummEngine;
 
-class ScummDebugger : public Common::Debugger<ScummDebugger> {
+class ScummDebugger : public GUI::Debugger {
 public:
 	ScummDebugger(ScummEngine *s);
 	virtual ~ScummDebugger(); // we need this here for __SYMBIAN32__
@@ -41,7 +41,6 @@ protected:
 	virtual void postEnter();
 
 	// Commands
-	bool Cmd_Exit(int argc, const char **argv);
 	bool Cmd_Room(int argc, const char **argv);
 	bool Cmd_LoadGame(int argc, const char **argv);
 	bool Cmd_SaveGame(int argc, const char **argv);
@@ -62,7 +61,6 @@ protected:
 
 	bool Cmd_Debug(int argc, const char **argv);
 	bool Cmd_DebugLevel(int argc, const char **argv);
-	bool Cmd_Help(int argc, const char **argv);
 
 	bool Cmd_Show(int argc, const char **argv);
 	bool Cmd_Hide(int argc, const char **argv);
diff --git a/engines/simon/debugger.cpp b/engines/simon/debugger.cpp
index 5f3ac44be8..7e2694966a 100644
--- a/engines/simon/debugger.cpp
+++ b/engines/simon/debugger.cpp
@@ -24,7 +24,6 @@
 #include "common/stdafx.h"
 
 #include "common/config-manager.h"
-#include "common/debugger.cpp"
 
 #include "simon/debugger.h"
 #include "simon/simon.h"
@@ -32,20 +31,17 @@
 namespace Simon {
 
 Debugger::Debugger(SimonEngine *vm)
-	: Common::Debugger<Debugger>() {
+	: GUI::Debugger() {
 	_vm = vm;
 
-	DCmd_Register("continue", &Debugger::Cmd_Exit);
-	DCmd_Register("exit", &Debugger::Cmd_Exit);
-	DCmd_Register("help", &Debugger::Cmd_Help);
-	DCmd_Register("quit", &Debugger::Cmd_Exit);
-	DCmd_Register("level", &Debugger::Cmd_DebugLevel);
-	DCmd_Register("music", &Debugger::Cmd_PlayMusic);
-	DCmd_Register("sound", &Debugger::Cmd_PlaySound);
-	DCmd_Register("voice", &Debugger::Cmd_PlayVoice);
-	DCmd_Register("bit", &Debugger::Cmd_SetBit);
-	DCmd_Register("var", &Debugger::Cmd_SetVar);
-	DCmd_Register("sub", &Debugger::Cmd_StartSubroutine);
+	DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
+	DCmd_Register("level",    WRAP_METHOD(Debugger, Cmd_DebugLevel));
+	DCmd_Register("music",    WRAP_METHOD(Debugger, Cmd_PlayMusic));
+	DCmd_Register("sound",    WRAP_METHOD(Debugger, Cmd_PlaySound));
+	DCmd_Register("voice",    WRAP_METHOD(Debugger, Cmd_PlayVoice));
+	DCmd_Register("bit",      WRAP_METHOD(Debugger, Cmd_SetBit));
+	DCmd_Register("var",      WRAP_METHOD(Debugger, Cmd_SetVar));
+	DCmd_Register("sub",      WRAP_METHOD(Debugger, Cmd_StartSubroutine));
 
 }
 
@@ -60,32 +56,6 @@ void Debugger::postEnter() {
 }
 
 
-bool Debugger::Cmd_Exit(int argc, const char **argv) {
-	_detach_now = true;
-	return false;
-}
-
-bool Debugger::Cmd_Help(int argc, const char **argv) {
-	// console normally has 39 line width
-	// wrap around nicely
-	int width = 0, size, i;
-
-	DebugPrintf("Commands are:\n");
-	for (i = 0 ; i < _dcmd_count ; i++) {
-		size = strlen(_dcmds[i].name) + 1;
-
-		if ((width + size) >= 39) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dcmds[i].name);
-	}
-	DebugPrintf("\n");
-	return true;
-}
-
 bool Debugger::Cmd_DebugLevel(int argc, const char **argv) {
 	if (argc == 1) {
 		if (_vm->_debugMode == false)
diff --git a/engines/simon/debugger.h b/engines/simon/debugger.h
index bfb2183e13..2c8e28d20e 100644
--- a/engines/simon/debugger.h
+++ b/engines/simon/debugger.h
@@ -24,13 +24,13 @@
 #ifndef SIMON_DEBUGGER_H
 #define SIMON_DEBUGGER_H
 
-#include "common/debugger.h"
+#include "gui/debugger.h"
 
 namespace Simon {
 
 class SimonEngine;
 
-class Debugger : public Common::Debugger<Debugger> {
+class Debugger : public GUI::Debugger {
 public:
 	Debugger(SimonEngine *vm);
 	virtual ~Debugger() {}  // we need this for __SYMBIAN32__ archaic gcc/UIQ
@@ -41,8 +41,6 @@ protected:
 	virtual void preEnter();
 	virtual void postEnter();
 
-	bool Cmd_Exit(int argc, const char **argv);
-	bool Cmd_Help(int argc, const char **argv);
 	bool Cmd_DebugLevel(int argc, const char **argv);
 	bool Cmd_PlayMusic(int argc, const char **argv);
 	bool Cmd_PlaySound(int argc, const char **argv);
diff --git a/engines/sky/debug.cpp b/engines/sky/debug.cpp
index d7e8f6694c..24d52aa59d 100644
--- a/engines/sky/debug.cpp
+++ b/engines/sky/debug.cpp
@@ -23,7 +23,6 @@
 #include "common/stdafx.h"
 #include "common/endian.h"
 #include "common/util.h"
-#include "common/debugger.cpp"
 
 #include "sky/debug.h"
 #include "sky/grid.h"
@@ -1280,16 +1279,14 @@ void Debug::mcode(uint32 mcode, uint32 a, uint32 b, uint32 c) {
 
 
 Debugger::Debugger(Logic *logic, Mouse *mouse, Screen *screen, SkyCompact *skyCompact)
-: Common::Debugger<Debugger>(), _logic(logic), _mouse(mouse), _screen(screen), _skyCompact(skyCompact), _showGrid(false) {
-	DCmd_Register("exit", &Debugger::Cmd_Exit);
-	DCmd_Register("help", &Debugger::Cmd_Help);
-	DCmd_Register("info", &Debugger::Cmd_Info);
-	DCmd_Register("showgrid", &Debugger::Cmd_ShowGrid);
-	DCmd_Register("reloadgrid", &Debugger::Cmd_ReloadGrid);
-	DCmd_Register("compact", &Debugger::Cmd_ShowCompact);
-	DCmd_Register("logiccmd", &Debugger::Cmd_LogicCommand);
-	DCmd_Register("scriptvar", &Debugger::Cmd_ScriptVar);
-	DCmd_Register("section", &Debugger::Cmd_Section);
+: GUI::Debugger(), _logic(logic), _mouse(mouse), _screen(screen), _skyCompact(skyCompact), _showGrid(false) {
+	DCmd_Register("info",       WRAP_METHOD(Debugger, Cmd_Info));
+	DCmd_Register("showgrid",   WRAP_METHOD(Debugger, Cmd_ShowGrid));
+	DCmd_Register("reloadgrid", WRAP_METHOD(Debugger, Cmd_ReloadGrid));
+	DCmd_Register("compact",    WRAP_METHOD(Debugger, Cmd_ShowCompact));
+	DCmd_Register("logiccmd",   WRAP_METHOD(Debugger, Cmd_LogicCommand));
+	DCmd_Register("scriptvar",  WRAP_METHOD(Debugger, Cmd_ScriptVar));
+	DCmd_Register("section",    WRAP_METHOD(Debugger, Cmd_Section));
 }
 
 Debugger::~Debugger() {} // we need this here for __SYMBIAN32__
@@ -1302,33 +1299,6 @@ void Debugger::postEnter() {
 	_mouse->resetCursor();
 }
 
-bool Debugger::Cmd_Exit(int argc, const char **argv) {
-	_detach_now = true;
-	return false;
-}
-
-bool Debugger::Cmd_Help(int argc, const char **argv) {
-	// console normally has 39 line width
-	// wrap around nicely
-	int width = 0, size;
-
-	DebugPrintf("Commands are:\n");
-	for (int i = 0; i < _dcmd_count; ++i) {
-		size = strlen(_dcmds[i].name) + 1;
-
-		if ((width + size) >= 39) {
-			DebugPrintf("\n");
-			width = size;
-		} else {
-			width += size;
-		}
-
-		DebugPrintf("%s ", _dcmds[i].name);
-	}
-	DebugPrintf("\n");
-	return true;
-}
-
 bool Debugger::Cmd_ShowGrid(int argc, const char **argv) {
 	_showGrid = !_showGrid;
 	DebugPrintf("Show grid: %s\n", _showGrid ? "On" : "Off");
diff --git a/engines/sky/debug.h b/engines/sky/debug.h
index 8fdb46d2e1..ec43f40edd 100644
--- a/engines/sky/debug.h
+++ b/engines/sky/debug.h
@@ -25,7 +25,7 @@
 
 #include "common/stdafx.h"
 #include "common/scummsys.h"
-#include "common/debugger.h"
+#include "gui/debugger.h"
 
 namespace Sky {
 
@@ -34,7 +34,7 @@ class Mouse;
 class Screen;
 class SkyCompact;
 
-class Debugger : public Common::Debugger<Debugger> {
+class Debugger : public GUI::Debugger {
 public:
 	Debugger(Logic *logic, Mouse *mouse, Screen *screen, SkyCompact *skyCompact);
 	virtual ~Debugger(); // we need this here for __SYMBIAN32__ archaic gcc/UIQ
@@ -44,8 +44,6 @@ protected:
 	virtual void preEnter();
 	virtual void postEnter();
 
-	bool Cmd_Exit(int argc, const char **argv);
-	bool Cmd_Help(int argc, const char **argv);
 	bool Cmd_ShowGrid(int argc, const char **argv);
 	bool Cmd_ReloadGrid(int argc, const char **argv);
 	bool Cmd_ShowCompact(int argc, const char **argv);
diff --git a/engines/sword2/console.cpp b/engines/sword2/console.cpp
index 02f85418ad..4e8e0eda24 100644
--- a/engines/sword2/console.cpp
+++ b/engines/sword2/console.cpp
@@ -21,6 +21,7 @@
 
 #include "common/stdafx.h"
 #include "common/rect.h"
+#include "common/system.h"
 
 #include "sword2/sword2.h"
 #include "sword2/defs.h"
@@ -34,12 +35,10 @@
 #include "sword2/screen.h"
 #include "sword2/sound.h"
 
-#include "common/debugger.cpp"
-
 namespace Sword2 {
 
 Debugger::Debugger(Sword2Engine *vm)
-	: Common::Debugger<Debugger>() {
+	: GUI::Debugger() {
 	_vm = vm;
 
 	memset(_debugTextBlocks, 0, sizeof(_debugTextBlocks));
@@ -79,47 +78,44 @@ Debugger::Debugger(Sword2Engine *vm)
 
 	// Register commands
 
-	DCmd_Register("continue", &Debugger::Cmd_Exit);
-	DCmd_Register("exit", &Debugger::Cmd_Exit);
-	DCmd_Register("quit", &Debugger::Cmd_Exit);
-	DCmd_Register("q", &Debugger::Cmd_Exit);
-	DCmd_Register("help", &Debugger::Cmd_Help);
-	DCmd_Register("mem", &Debugger::Cmd_Mem);
-	DCmd_Register("tony", &Debugger::Cmd_Tony);
-	DCmd_Register("res", &Debugger::Cmd_Res);
-	DCmd_Register("reslist", &Debugger::Cmd_ResList);
-	DCmd_Register("starts", &Debugger::Cmd_Starts);
-	DCmd_Register("start", &Debugger::Cmd_Start);
-	DCmd_Register("s", &Debugger::Cmd_Start);
-	DCmd_Register("info", &Debugger::Cmd_Info);
-	DCmd_Register("walkgrid", &Debugger::Cmd_WalkGrid);
-	DCmd_Register("mouse", &Debugger::Cmd_Mouse);
-	DCmd_Register("player", &Debugger::Cmd_Player);
-	DCmd_Register("reslook", &Debugger::Cmd_ResLook);
-	DCmd_Register("cur", &Debugger::Cmd_CurrentInfo);
-	DCmd_Register("runlist", &Debugger::Cmd_RunList);
-	DCmd_Register("kill", &Debugger::Cmd_Kill);
-	DCmd_Register("nuke", &Debugger::Cmd_Nuke);
-	DCmd_Register("var", &Debugger::Cmd_Var);
-	DCmd_Register("rect", &Debugger::Cmd_Rect);
-	DCmd_Register("clear", &Debugger::Cmd_Clear);
-	DCmd_Register("debugon", &Debugger::Cmd_DebugOn);
-	DCmd_Register("debugoff", &Debugger::Cmd_DebugOff);
-	DCmd_Register("saverest", &Debugger::Cmd_SaveRest);
-	DCmd_Register("timeon", &Debugger::Cmd_TimeOn);
-	DCmd_Register("timeoff", &Debugger::Cmd_TimeOff);
-	DCmd_Register("text", &Debugger::Cmd_Text);
-	DCmd_Register("showvar", &Debugger::Cmd_ShowVar);
-	DCmd_Register("hidevar", &Debugger::Cmd_HideVar);
-	DCmd_Register("version", &Debugger::Cmd_Version);
-	DCmd_Register("animtest", &Debugger::Cmd_AnimTest);
-	DCmd_Register("texttest", &Debugger::Cmd_TextTest);
-	DCmd_Register("linetest", &Debugger::Cmd_LineTest);
-	DCmd_Register("events", &Debugger::Cmd_Events);
-	DCmd_Register("sfx", &Debugger::Cmd_Sfx);
-	DCmd_Register("english", &Debugger::Cmd_English);
-	DCmd_Register("finnish", &Debugger::Cmd_Finnish);
-	DCmd_Register("polish", &Debugger::Cmd_Polish);
+	DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
+	DCmd_Register("q",        WRAP_METHOD(Debugger, Cmd_Exit));
+	DCmd_Register("mem",      WRAP_METHOD(Debugger, Cmd_Mem));
+	DCmd_Register("tony",     WRAP_METHOD(Debugger, Cmd_Tony));
+	DCmd_Register("res",      WRAP_METHOD(Debugger, Cmd_Res));
+	DCmd_Register("reslist",  WRAP_METHOD(Debugger, Cmd_ResList));
+	DCmd_Register("starts",   WRAP_METHOD(Debugger, Cmd_Starts));
+	DCmd_Register("start",    WRAP_METHOD(Debugger, Cmd_Start));
+	DCmd_Register("s",        WRAP_METHOD(Debugger, Cmd_Start));
+	DCmd_Register("info",     WRAP_METHOD(Debugger, Cmd_Info));
+	DCmd_Register("walkgrid", WRAP_METHOD(Debugger, Cmd_WalkGrid));
+	DCmd_Register("mouse",    WRAP_METHOD(Debugger, Cmd_Mouse));
+	DCmd_Register("player",   WRAP_METHOD(Debugger, Cmd_Player));
+	DCmd_Register("reslook",  WRAP_METHOD(Debugger, Cmd_ResLook));
+	DCmd_Register("cur",      WRAP_METHOD(Debugger, Cmd_CurrentInfo));
+	DCmd_Register("runlist",  WRAP_METHOD(Debugger, Cmd_RunList));
+	DCmd_Register("kill",     WRAP_METHOD(Debugger, Cmd_Kill));
+	DCmd_Register("nuke",     WRAP_METHOD(Debugger, Cmd_Nuke));
+	DCmd_Register("var",      WRAP_METHOD(Debugger, Cmd_Var));
+	DCmd_Register("rect",     WRAP_METHOD(Debugger, Cmd_Rect));
+	DCmd_Register("clear",    WRAP_METHOD(Debugger, Cmd_Clear));
+	DCmd_Register("debugon",  WRAP_METHOD(Debugger, Cmd_DebugOn));
+	DCmd_Register("debugoff", WRAP_METHOD(Debugger, Cmd_DebugOff));
+	DCmd_Register("saverest", WRAP_METHOD(Debugger, Cmd_SaveRest));
+	DCmd_Register("timeon",   WRAP_METHOD(Debugger, Cmd_TimeOn));
+	DCmd_Register("timeoff",  WRAP_METHOD(Debugger, Cmd_TimeOff));
+	DCmd_Register("text",     WRAP_METHOD(Debugger, Cmd_Text));
+	DCmd_Register("showvar",  WRAP_METHOD(Debugger, Cmd_ShowVar));
+	DCmd_Register("hidevar",  WRAP_METHOD(Debugger, Cmd_HideVar));
+	DCmd_Register("version",  WRAP_METHOD(Debugger, Cmd_Version));
+	DCmd_Register("animtest", WRAP_METHOD(Debugger, Cmd_AnimTest));
+	DCmd_Register("texttest", WRAP_METHOD(Debugger, Cmd_TextTest));
+	DCmd_Register("linetest", WRAP_METHOD(Debugger, Cmd_LineTest));
+	DCmd_Register("events",   WRAP_METHOD(Debugger, Cmd_Events));
+	DCmd_Register("sfx",      WRAP_METHOD(Debugger, Cmd_Sfx));
+	DCmd_Register("english",  WRAP_METHOD(Debugger, Cmd_English));
+	DCmd_Register("finnish",  WRAP_METHOD(Debugger, Cmd_Finnish));
+	DCmd_Register("polish",   WRAP_METHOD(Debugger, Cmd_Polish));
 }
 
 void Debugger::varGet(int var) {
@@ -157,34 +153,6 @@ void Debugger::postEnter() {
 
 // Now the fun stuff: Commands
 
-bool Debugger::Cmd_Exit(int argc, const char **argv) {
-	_detach_now = true;
-	_vm->clearInputEvents();
-	return false;
-}
-
-bool Debugger::Cmd_Help(int argc, const char **argv) {
-	// console normally has 78 line width
-	// wrap around nicely
-	int width = 0;
-
-	DebugPrintf("Commands are:\n");
-	for (int i = 0 ; i < _dcmd_count ; i++) {
-		int size = strlen(_dcmds[i].name) + 1;
-
-		if (width + size >= 75) {
-			DebugPrintf("\n");
-			width = size;
-		} else
-			width += size;
-
-		DebugPrintf("%s ", _dcmds[i].name);
-	}
-
-	DebugPrintf("\n");
-	return true;
-}
-
 static int compare_blocks(const void *p1, const void *p2) {
 	const MemBlock *m1 = *(const MemBlock * const *)p1;
 	const MemBlock *m2 = *(const MemBlock * const *)p2;
diff --git a/engines/sword2/console.h b/engines/sword2/console.h
index 858149d7cb..35c6d582e7 100644
--- a/engines/sword2/console.h
+++ b/engines/sword2/console.h
@@ -22,12 +22,12 @@
 #ifndef	SWORD2_CONSOLE_H
 #define	SWORD2_CONSOLE_H
 
-#include "common/debugger.h"
+#include "gui/debugger.h"
 #include "sword2/debug.h"
 
 namespace Sword2 {
 
-class Debugger : public Common::Debugger<Debugger> {
+class Debugger : public GUI::Debugger {
 private:
 	void varGet(int var);
 	void varSet(int var, int val);
@@ -83,8 +83,6 @@ protected:
 	virtual void postEnter();
 
 	// Commands
-	bool Cmd_Exit(int argc, const char **argv);
-	bool Cmd_Help(int argc, const char **argv);
 	bool Cmd_Mem(int argc, const char **argv);
 	bool Cmd_Tony(int argc, const char **argv);
 	bool Cmd_Res(int argc, const char **argv);