/* ScummVM - Graphic Adventure Engine * * ScummVM is the legal property of its developers, whose names * are too numerous to list here. Please refer to the COPYRIGHT * file distributed with this source distribution. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * */ // NB: This is really only necessary if USE_READLINE is defined #define FORBIDDEN_SYMBOL_ALLOW_ALL #include "common/file.h" #include "common/debug.h" #include "common/debug-channels.h" #include "common/system.h" #ifndef DISABLE_MD5 #include "common/md5.h" #include "common/archive.h" #include "common/macresman.h" #include "common/stream.h" #endif #include "engines/engine.h" #include "gui/debugger.h" #ifndef USE_TEXT_CONSOLE_FOR_DEBUGGER #include "gui/console.h" #elif defined(USE_READLINE) #include #include #include "common/events.h" #endif namespace GUI { Debugger::Debugger() { _frameCountdown = 0; _isActive = false; _firstTime = true; _defaultCommandProcessor = nullptr; #ifndef USE_TEXT_CONSOLE_FOR_DEBUGGER _debuggerDialog = new GUI::ConsoleDialog(1.0f, 0.67f); _debuggerDialog->setInputCallback(debuggerInputCallback, this); _debuggerDialog->setCompletionCallback(debuggerCompletionCallback, this); #endif // Register variables registerVarImpl("debug_countdown", &_frameCountdown, DVAR_INT, 0); // Register commands //registerCmd("continue", WRAP_METHOD(Debugger, cmdExit)); registerCmd("exit", WRAP_METHOD(Debugger, cmdExit)); registerCmd("quit", WRAP_METHOD(Debugger, cmdExit)); registerCmd("help", WRAP_METHOD(Debugger, cmdHelp)); registerCmd("openlog", WRAP_METHOD(Debugger, cmdOpenLog)); #ifndef DISABLE_MD5 registerCmd("md5", WRAP_METHOD(Debugger, cmdMd5)); registerCmd("md5mac", WRAP_METHOD(Debugger, cmdMd5Mac)); #endif registerCmd("exec", WRAP_METHOD(Debugger, cmdExecFile)); registerCmd("debuglevel", WRAP_METHOD(Debugger, cmdDebugLevel)); registerCmd("debugflag_list", WRAP_METHOD(Debugger, cmdDebugFlagsList)); registerCmd("debugflag_enable", WRAP_METHOD(Debugger, cmdDebugFlagEnable)); registerCmd("debugflag_disable", WRAP_METHOD(Debugger, cmdDebugFlagDisable)); } Debugger::~Debugger() { #ifndef USE_TEXT_CONSOLE_FOR_DEBUGGER delete _debuggerDialog; #endif } void Debugger::clearVars() { _vars.resize(1); // Keep "debug_countdown" } void Debugger::setPrompt(Common::String prompt) { #ifndef USE_TEXT_CONSOLE_FOR_DEBUGGER _debuggerDialog->setPrompt(prompt); #endif } void Debugger::resetPrompt() { #ifndef USE_TEXT_CONSOLE_FOR_DEBUGGER _debuggerDialog->resetPrompt(); #endif } // Initialisation Functions int Debugger::getCharsPerLine() { #ifndef USE_TEXT_CONSOLE_FOR_DEBUGGER const int charsPerLine = _debuggerDialog->getCharsPerLine(); #elif defined(USE_READLINE) int charsPerLine, rows; rl_get_screen_size(&rows, &charsPerLine); #else // Can we do better? const int charsPerLine = 80; #endif return charsPerLine; } int Debugger::debugPrintf(const char *format, ...) { va_list argptr; va_start(argptr, format); int count; #ifndef USE_TEXT_CONSOLE_FOR_DEBUGGER count = _debuggerDialog->vprintFormat(1, format, argptr); #else count = ::vprintf(format, argptr); ::fflush(stdout); #endif va_end (argptr); return count; } void Debugger::debugPrintColumns(const Common::StringArray &list) { uint maxLength = 0; uint i, j; for (i = 0; i < list.size(); i++) { if (list[i].size() > maxLength) maxLength = list[i].size(); } uint charsPerLine = getCharsPerLine(); uint columnWidth = maxLength + 2; uint columns = charsPerLine / columnWidth; uint lines = list.size() / columns; if (list.size() % columns) lines++; // This won't always use all available columns, but even if it did the // number of lines should be the same so that's good enough. for (i = 0; i < lines; i++) { for (j = 0; j < columns; j++) { uint pos = i + j * lines; if (pos < list.size()) { debugPrintf("%*s", -1 * columnWidth, list[pos].c_str()); } } debugPrintf("\n"); } } void Debugger::preEnter() { _debugPauseToken = g_engine->pauseEngine(); } void Debugger::postEnter() { _debugPauseToken.clear(); } void Debugger::attach(const char *entry) { g_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, true); // Set error string (if any) _errStr = entry ? entry : ""; // Reset frame countdown (i.e. attach immediately) _frameCountdown = 1; } void Debugger::detach() { g_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, false); } // Temporary execution handler void Debugger::onFrame() { // Count down until 0 is reached if (_frameCountdown > 0) { --_frameCountdown; if (_frameCountdown == 0) { _isActive = true; preEnter(); enter(); postEnter(); _isActive = false; } } } #if defined(USE_TEXT_CONSOLE_FOR_DEBUGGER) && defined(USE_READLINE) namespace { Debugger *g_readline_debugger; char *readline_completionFunction(const char *text, int state) { return g_readline_debugger->readlineComplete(text, state); } void readline_eventFunction() { Common::EventManager *eventMan = g_system->getEventManager(); Common::Event event; while (eventMan->pollEvent(event)) { // drop all events } } #ifdef USE_READLINE_INT_COMPLETION typedef int RLCompFunc_t(const char *, int); #else typedef char *RLCompFunc_t(const char *, int); #endif } // end of anonymous namespace #endif // Main Debugger Loop void Debugger::enter() { // TODO: Having three I/O methods #ifdef-ed in this file is not the // cleanest approach to this... #ifndef USE_TEXT_CONSOLE_FOR_DEBUGGER if (_firstTime) { debugPrintf("Debugger started, type 'exit' to return to the game.\n"); debugPrintf("Type 'help' to see a little list of commands and variables.\n"); _firstTime = false; } if (_errStr.size()) { debugPrintf("ERROR: %s\n\n", _errStr.c_str()); _errStr.clear(); } _debuggerDialog->runModal(); #else printf("Debugger entered, please switch to this console for input.\n"); #ifdef USE_READLINE // TODO: add support for saving/loading history? g_readline_debugger = this; rl_completion_entry_function = (RLCompFunc_t *)&readline_completionFunction; rl_event_hook = (rl_hook_func_t *)&readline_eventFunction; char *line_read = 0; do { free(line_read); line_read = readline("debug> "); if (line_read && line_read[0]) add_history(line_read); } while (line_read && parseCommand(line_read)); free(line_read); line_read = 0; #else int i; char buf[256]; do { printf("debug> "); ::fflush(stdout); if (!fgets(buf, sizeof(buf), stdin)) return; i = strlen(buf); while (i > 0 && buf[i - 1] == '\n') buf[--i] = 0; if (i == 0) continue; } while (parseCommand(buf)); #endif #endif } bool Debugger::handleCommand(int argc, const char **argv, bool &result) { assert(argc > 0); if (_cmds.contains(argv[0])) { assert(_cmds[argv[0]]); result = (*_cmds[argv[0]])(argc, argv); return true; } return false; } // Command execution loop bool Debugger::parseCommand(const char *inputOrig) { int num_params = 0; const char *param[256]; if (_defaultCommandProcessor) return (*_defaultCommandProcessor)(inputOrig); // Parse out any params Common::String input(inputOrig); splitCommand(input, num_params, ¶m[0]); if (num_params == 0) { return true; } // Handle commands first bool result; if (handleCommand(num_params, param, result)) { return result; } // It's not a command, so things get a little tricky for variables. Do fuzzy matching to ignore things like subscripts. for (uint i = 0; i < _vars.size(); i++) { if (!strncmp(_vars[i].name.c_str(), param[0], _vars[i].name.size())) { if (num_params > 1) { // Alright, we need to check the TYPE of the variable to deref and stuff... the array stuff is a bit ugly :) switch (_vars[i].type) { // Integer case DVAR_BYTE: *(byte *)_vars[i].variable = atoi(param[1]); debugPrintf("byte%s = %d\n", param[0], *(byte *)_vars[i].variable); break; case DVAR_INT: *(int32 *)_vars[i].variable = atoi(param[1]); debugPrintf("(int)%s = %d\n", param[0], *(int32 *)_vars[i].variable); break; case DVAR_FLOAT: *(float *)_vars[i].variable = (float)atof(param[1]); debugPrintf("(float)%s = %f\n", param[0], *(float *)_vars[i].variable); break; case DVAR_BOOL: if (Common::parseBool(param[1], *(bool *)_vars[i].variable)) debugPrintf("(bool)%s = %s\n", param[0], *(bool *)_vars[i].variable ? "true" : "false"); else debugPrintf("Invalid value for boolean variable. Valid values are \"true\", \"false\", \"1\", \"0\", \"yes\", \"no\"\n"); break; // Integer Array case DVAR_INTARRAY: { const char *chr = strchr(param[0], '['); if (!chr) { debugPrintf("You must access this array as %s[element]\n", param[0]); } else { int element = atoi(chr+1); int32 *var = *(int32 **)_vars[i].variable; if (element >= _vars[i].arraySize) { debugPrintf("%s is out of range (array is %d elements big)\n", param[0], _vars[i].arraySize); } else { var[element] = atoi(param[1]); debugPrintf("(int)%s = %d\n", param[0], var[element]); } } } break; default: debugPrintf("Failed to set variable %s to %s - unknown type\n", _vars[i].name.c_str(), param[1]); break; } } else { // And again, type-dependent prints/defrefs. The array one is still ugly. switch (_vars[i].type) { // Integer case DVAR_BYTE: debugPrintf("(byte)%s = %d\n", param[0], *(const byte *)_vars[i].variable); break; case DVAR_INT: debugPrintf("(int)%s = %d\n", param[0], *(const int32 *)_vars[i].variable); break; case DVAR_FLOAT: debugPrintf("(float)%s = %f\n", param[0], *(const float *)_vars[i].variable); break; case DVAR_BOOL: debugPrintf("(bool)%s = %s\n", param[0], *(const bool *)_vars[i].variable ? "true" : "false"); break; // Integer array case DVAR_INTARRAY: { const char *chr = strchr(param[0], '['); if (!chr) { debugPrintf("You must access this array as %s[element]\n", param[0]); } else { int element = atoi(chr+1); const int32 *var = *(const int32 **)_vars[i].variable; if (element >= _vars[i].arraySize) { debugPrintf("%s is out of range (array is %d elements big)\n", param[0], _vars[i].arraySize); } else { debugPrintf("(int)%s = %d\n", param[0], var[element]); } } } break; // String case DVAR_STRING: debugPrintf("(string)%s = %s\n", param[0], ((Common::String *)_vars[i].variable)->c_str()); break; default: debugPrintf("%s = (unknown type)\n", param[0]); break; } } return true; } } debugPrintf("Unknown command or variable\n"); return true; } void Debugger::splitCommand(Common::String &input, int &argc, const char **argv) { byte c; enum states { DULL, IN_WORD, IN_STRING } state = DULL; const char *paramStart = nullptr; argc = 0; for (Common::String::iterator p = input.begin(); *p; ++p) { c = (byte)*p; switch (state) { default: // fallthrough intended case DULL: // not in a word, not in a double quoted string if (isspace(c)) break; // not a space -- if it's a double quote we go to IN_STRING, else to IN_WORD if (c == '"') { state = IN_STRING; paramStart = p + 1; // word starts at *next* char, not this one } else { state = IN_WORD; paramStart = p; // word starts here } break; case IN_STRING: // we're in a double quoted string, so keep going until we hit a close " if (c == '"') { // Add entire quoted string to parameter list *p = '\0'; argv[argc++] = paramStart; state = DULL; // back to "not in word, not in string" state } break; case IN_WORD: // we're in a word, so keep going until we get to a space if (isspace(c)) { *p = '\0'; argv[argc++] = paramStart; state = DULL; // back to "not in word, not in string" state } break; } } if (state != DULL) // Add in final parameter argv[argc++] = paramStart; } // returns true if something has been completed // completion has to be delete[]-ed then bool Debugger::tabComplete(const char *input, Common::String &completion) const { // very basic tab completion // for now it just supports command completions // adding completions of command parameters would be nice (but hard) :-) // maybe also give a list of possible command completions? // (but this will require changes to console) if (strchr(input, ' ')) return false; // already finished the first word const uint inputlen = strlen(input); completion.clear(); CommandsMap::const_iterator i, e = _cmds.end(); for (i = _cmds.begin(); i != e; ++i) { if (i->_key.hasPrefixIgnoreCase(input)) { uint commandlen = i->_key.size(); if (commandlen == inputlen) { // perfect match, so no tab completion possible return false; } if (commandlen > inputlen) { // possible match // no previous match if (completion.empty()) { completion = i->_key.c_str() + inputlen; } else { // take common prefix of previous match and this command for (uint j = 0; j < completion.size(); j++) { if (inputlen + j >= i->_key.size() || completion[j] != i->_key[inputlen + j]) { completion = Common::String(completion.begin(), completion.begin() + j); // If there is no unambiguous completion, abort if (completion.empty()) return false; break; } } } } } } if (completion.empty()) return false; return true; } #if defined(USE_TEXT_CONSOLE_FOR_DEBUGGER) && defined(USE_READLINE) char *Debugger::readlineComplete(const char *input, int state) { static CommandsMap::const_iterator iter; // We assume that _cmds isn't changed between calls to readlineComplete, // unless state is 0. if (state == 0) { iter = _cmds.begin(); } else { ++iter; } for (; iter != _cmds.end(); ++iter) { if (iter->_key.hasPrefix(input)) { char *ret = (char *)malloc(iter->_key.size() + 1); Common::strcpy_s(ret, iter->_key.size() + 1, iter->_key.c_str()); return ret; } } return 0; } #endif // Variable registration function void Debugger::registerVarImpl(const Common::String &varname, void *pointer, VarType type, int arraySize) { // TODO: Filter out duplicates // TODO: Sort this list? Then we can do binary search later on when doing lookups. assert(pointer); Var tmp; tmp.name = varname; tmp.type = type; tmp.variable = pointer; tmp.arraySize = arraySize; _vars.push_back(tmp); } // Command registration function void Debugger::registerCmd(const Common::String &cmdname, Debuglet *debuglet) { assert(debuglet && debuglet->isValid()); _cmds[cmdname] = Common::SharedPtr(debuglet); } // Detach ("exit") the debugger bool Debugger::cmdExit(int argc, const char **argv) { detach(); return false; } // Print a list of all registered commands (and variables, if any), // nicely word-wrapped. bool Debugger::cmdHelp(int argc, const char **argv) { const int charsPerLine = getCharsPerLine(); int width, size; uint i; debugPrintf("Commands are:\n"); // Obtain a list of sorted command names Common::Array cmds; CommandsMap::const_iterator iter, e = _cmds.end(); for (iter = _cmds.begin(); iter != e; ++iter) { cmds.push_back(iter->_key); } sort(cmds.begin(), cmds.end()); // Print them all width = 0; for (i = 0; i < cmds.size(); i++) { size = cmds[i].size() + 1; if ((width + size) >= charsPerLine) { debugPrintf("\n"); width = size; } else width += size; debugPrintf("%s ", cmds[i].c_str()); } debugPrintf("\n"); if (!_vars.empty()) { debugPrintf("\n"); debugPrintf("Variables are:\n"); width = 0; for (i = 0; i < _vars.size(); i++) { size = _vars[i].name.size() + 1; if ((width + size) >= charsPerLine) { debugPrintf("\n"); width = size; } else width += size; debugPrintf("%s ", _vars[i].name.c_str()); } debugPrintf("\n"); } return true; } bool Debugger::cmdOpenLog(int argc, const char **argv) { if (g_system->hasFeature(OSystem::kFeatureDisplayLogFile)) g_system->displayLogFile(); else debugPrintf("Opening the log file not supported on this system\n"); return true; } #ifndef DISABLE_MD5 struct ArchiveMemberLess { bool operator()(const Common::ArchiveMemberPtr &x, const Common::ArchiveMemberPtr &y) const { return (*x).getName().compareToIgnoreCase((*y).getName()) < 0; } }; bool Debugger::cmdMd5(int argc, const char **argv) { if (argc < 2) { debugPrintf("md5 [-n length] \n"); } else { int32 length = 0; uint paramOffset = 0; bool tail = false; // If the user supplied an -n parameter, set the bytes to read if (!strcmp(argv[1], "-n")) { // Make sure that we have at least two more parameters if (argc < 4) { debugPrintf("md5 [-n length] \n"); return true; } length = atoi(argv[2]); if (length < 0) { length = -length; tail = true; } paramOffset = 2; } // Assume that spaces are part of a single filename. Common::String filename = argv[1 + paramOffset]; for (int i = 2 + paramOffset; i < argc; i++) { filename = filename + " " + argv[i]; } Common::ArchiveMemberList list; SearchMan.listMatchingMembers(list, filename); if (list.empty()) { debugPrintf("File '%s' not found\n", filename.c_str()); } else { sort(list.begin(), list.end(), ArchiveMemberLess()); for (Common::ArchiveMemberList::iterator iter = list.begin(); iter != list.end(); ++iter) { Common::SeekableReadStream *stream = (*iter)->createReadStream(); if (tail && stream->size() > length) stream->seek(-length, SEEK_END); Common::String md5 = Common::computeStreamMD5AsString(*stream, length); if (length != 0 && length < stream->size()) md5 += Common::String::format(" (%s %d bytes)", tail ? "last" : "first", length); debugPrintf("%s: %s, %llu bytes\n", (*iter)->getName().c_str(), md5.c_str(), (unsigned long long)stream->size()); delete stream; } } } return true; } bool Debugger::cmdMd5Mac(int argc, const char **argv) { if (argc < 2) { debugPrintf("md5mac [-n length] \n"); } else { int32 length = 0; uint paramOffset = 0; bool tail = false; // If the user supplied an -n parameter, set the bytes to read if (!strcmp(argv[1], "-n")) { // Make sure that we have at least two more parameters if (argc < 4) { debugPrintf("md5mac [-n length] \n"); return true; } length = atoi(argv[2]); if (length < 0) { length = -length; tail = true; } paramOffset = 2; } // Assume that spaces are part of a single filename. Common::String filename = argv[1 + paramOffset]; for (int i = 2 + paramOffset; i < argc; i++) { filename = filename + " " + argv[i]; } Common::MacResManager macResMan; // FIXME: There currently isn't any way to tell the Mac resource // manager to open a specific file. Instead, it takes a "base name" // and constructs a file name out of that. While usually a desirable // thing, it's not ideal here. if (!macResMan.open(filename)) { debugPrintf("Resource file '%s' not found\n", filename.c_str()); } else { Common::ScopedPtr dataFork(Common::MacResManager::openFileOrDataFork(filename)); if (!macResMan.hasResFork() && !dataFork) { debugPrintf("'%s' has neither data not resource fork\n", macResMan.getBaseFileName().toString().c_str()); } else { // The resource fork is probably the most relevant one. if (macResMan.hasResFork()) { Common::String md5 = macResMan.computeResForkMD5AsString(length, tail); if (length != 0 && length < (int32)macResMan.getResForkDataSize()) md5 += Common::String::format(" (%s %d bytes)", tail ? "last" : "first", length); debugPrintf("%s (resource): %s, %llu bytes\n", macResMan.getBaseFileName().toString().c_str(), md5.c_str(), (unsigned long long)macResMan.getResForkDataSize()); } if (dataFork) { if (tail && dataFork->size() > length) dataFork->seek(-length, SEEK_END); Common::String md5 = Common::computeStreamMD5AsString(*dataFork, length); if (length != 0 && length < dataFork->size()) md5 += Common::String::format(" (%s %d bytes)", tail ? "last" : "first", length); debugPrintf("%s (data): %s, %llu bytes\n", macResMan.getBaseFileName().toString().c_str(), md5.c_str(), (unsigned long long)dataFork->size()); } } macResMan.close(); } } return true; } #endif bool Debugger::cmdDebugLevel(int argc, const char **argv) { if (argc == 1) { // print level debugPrintf("Debugging is currently %s (set at level %d)\n", (gDebugLevel >= 0) ? "enabled" : "disabled", gDebugLevel); debugPrintf("Usage: %s where n is 0 to 10 or -1 to disable debugging\n", argv[0]); } else { // set level gDebugLevel = atoi(argv[1]); if (gDebugLevel >= 0 && gDebugLevel < 11) { debugPrintf("Debug level set to level %d\n", gDebugLevel); } else if (gDebugLevel < 0) { debugPrintf("Debugging is now disabled\n"); } else { debugPrintf("Invalid debug level value\n"); debugPrintf("Usage: %s where n is 0 to 10 or -1 to disable debugging\n", argv[0]); } } return true; } bool Debugger::cmdDebugFlagsList(int argc, const char **argv) { const Common::DebugManager::DebugChannelList &debugLevels = DebugMan.getDebugChannels(); debugPrintf("Engine debug levels:\n"); debugPrintf("--------------------\n"); if (debugLevels.empty()) { debugPrintf("No engine debug levels\n"); return true; } for (Common::DebugManager::DebugChannelList::const_iterator i = debugLevels.begin(); i != debugLevels.end(); ++i) { debugPrintf("%c%s - %s (%s)\n", i->enabled ? '+' : ' ', i->name.c_str(), i->description.c_str(), i->enabled ? "enabled" : "disabled"); } debugPrintf("\n"); return true; } bool Debugger::cmdDebugFlagEnable(int argc, const char **argv) { if (argc < 2) { debugPrintf("debugflag_enable [ | all]\n"); } else { if (!scumm_stricmp(argv[1], "all")) { debugPrintf("Enabled all debug flags\n"); DebugMan.enableAllDebugChannels(); } else if (DebugMan.enableDebugChannel(argv[1])) { debugPrintf("Enabled debug flag '%s'\n", argv[1]); } else { debugPrintf("Failed to enable debug flag '%s'\n", argv[1]); } } return true; } bool Debugger::cmdExecFile(int argc, const char **argv) { if (argc <= 1) { debugPrintf("Expected to get the file with debug commands\n"); return false; } const Common::String filename(argv[1]); Common::File file; if (!file.open(filename)) { debugPrintf("Can't open file %s\n", filename.c_str()); return false; } for (;;) { const Common::String &line = file.readLine(); if (line.empty()) { break; } parseCommand(line.c_str()); } return true; } bool Debugger::cmdDebugFlagDisable(int argc, const char **argv) { if (argc < 2) { debugPrintf("debugflag_disable [ | all]\n"); } else { if (!scumm_stricmp(argv[1], "all")) { debugPrintf("Disabled all debug flags\n"); DebugMan.disableAllDebugChannels(); } else if (DebugMan.disableDebugChannel(argv[1])) { debugPrintf("Disabled debug flag '%s'\n", argv[1]); } else { debugPrintf("Failed to disable debug flag '%s'\n", argv[1]); } } return true; } // Console handler #ifndef USE_TEXT_CONSOLE_FOR_DEBUGGER bool Debugger::debuggerInputCallback(GUI::ConsoleDialog *console, const char *input, void *refCon) { Debugger *debugger = (Debugger *)refCon; return debugger->parseCommand(input); } bool Debugger::debuggerCompletionCallback(GUI::ConsoleDialog *console, const char *input, Common::String &completion, void *refCon) { Debugger *debugger = (Debugger *)refCon; return debugger->tabComplete(input, completion); } #endif } // End of namespace GUI