common/debug.cpp

   1 /* ScummVM - Graphic Adventure Engine
   2  *
   3  * ScummVM is the legal property of its developers, whose names
   4  * are too numerous to list here. Please refer to the COPYRIGHT
   5  * file distributed with this source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  * $URL$
  22  * $Id$
  23  */
  24
  25 #include "common/debug.h"
  26 #include "common/util.h"
  27 #include "common/hashmap.h"
  28
  29 #include "engines/engine.h"
  30
  31 #include <stdarg.h>     // For va_list etc.
  32
  33
  34 #ifdef __PLAYSTATION2__
  35         // for those replaced fopen/fread/etc functions
  36         typedef unsigned long   uint64;
  37         typedef signed long     int64;
  38         #include "backends/platform/ps2/fileio.h"
  39
  40         #define fprintf                         ps2_fprintf
  41         #define fputs(str, file)        ps2_fputs(str, file)
  42         #define fflush(a)                       ps2_fflush(a)
  43 #endif
  44
  45 #ifdef __DS__
  46         #include "backends/fs/ds/ds-fs.h"
  47
  48         void    std_fprintf(FILE* handle, const char* fmt, ...);
  49         void    std_fflush(FILE* handle);
  50
  51         #define fprintf(file, fmt, ...)                         do { char str[128]; sprintf(str, fmt, ##__VA_ARGS__); DS::std_fwrite(str, strlen(str), 1, file); } while(0)
  52         #define fputs(str, file)                                        DS::std_fwrite(str, strlen(str), 1, file)
  53         #define fflush(file)                                            DS::std_fflush(file)
  54 #endif
  55
  56
  57 namespace Common {
  58
  59 namespace {
  60
  61 typedef HashMap<String, DebugChannel, IgnoreCase_Hash, IgnoreCase_EqualTo> DebugLevelMap;
  62
  63 static DebugLevelMap gDebugLevels;
  64 static uint32 gDebugLevelsEnabled = 0;
  65
  66 struct DebugLevelComperator {
  67         bool operator()(const DebugChannel &l, const DebugChannel &r) {
  68                 return (l.name.compareToIgnoreCase(r.name) < 0);
  69         }
  70 };
  71
  72 }
  73
  74 bool addDebugChannel(uint32 level, const String &name, const String &description) {
  75         if (gDebugLevels.contains(name)) {
  76                 warning("Duplicate declaration of engine debug level '%s'", name.c_str());
  77         }
  78         gDebugLevels[name] = DebugChannel(level, name, description);
  79
  80         return true;
  81 }
  82
  83 void clearAllDebugChannels() {
  84         gDebugLevelsEnabled = 0;
  85         gDebugLevels.clear();
  86 }
  87
  88 bool enableDebugChannel(const String &name) {
  89         DebugLevelMap::iterator i = gDebugLevels.find(name);
  90
  91         if (i != gDebugLevels.end()) {
  92                 gDebugLevelsEnabled |= i->_value.level;
  93                 i->_value.enabled = true;
  94
  95                 return true;
  96         } else {
  97                 return false;
  98         }
  99 }
 100
 101 bool disableDebugChannel(const String &name) {
 102         DebugLevelMap::iterator i = gDebugLevels.find(name);
 103
 104         if (i != gDebugLevels.end()) {
 105                 gDebugLevelsEnabled &= ~i->_value.level;
 106                 i->_value.enabled = false;
 107
 108                 return true;
 109         } else {
 110                 return false;
 111         }
 112 }
 113
 114
 115 DebugChannelList listDebugChannels() {
 116         DebugChannelList tmp;
 117         for (DebugLevelMap::iterator i = gDebugLevels.begin(); i != gDebugLevels.end(); ++i)
 118                 tmp.push_back(i->_value);
 119         sort(tmp.begin(), tmp.end(), DebugLevelComperator());
 120
 121         return tmp;
 122 }
 123
 124 bool isDebugChannelEnabled(uint32 level) {
 125         // Debug level 11 turns on all special debug level messages
 126         if (gDebugLevel == 11)
 127                 return true;
 128 //      return gDebugLevelsEnabled & (1 << level);
 129         return gDebugLevelsEnabled & level;
 130 }
 131
 132 bool isDebugChannelEnabled(const String &name) {
 133         // Debug level 11 turns on all special debug level messages
 134         if (gDebugLevel == 11)
 135                 return true;
 136
 137         // Search for the debug level with the given name and check if it is enabled
 138         DebugLevelMap::iterator i = gDebugLevels.find(name);
 139         if (i != gDebugLevels.end())
 140                 return i->_value.enabled;
 141         return false;
 142 }
 143
 144
 145 }       // End of namespace Common
 146
 147
 148 int gDebugLevel = -1;
 149
 150 #ifndef DISABLE_TEXT_CONSOLE
 151
 152 static void debugHelper(const char *s, va_list va, bool caret = true) {
 153         char in_buf[STRINGBUFLEN];
 154         char buf[STRINGBUFLEN];
 155         vsnprintf(in_buf, STRINGBUFLEN, s, va);
 156
 157         // Next, give the active engine (if any) a chance to augment the message,
 158         // but only if not used from debugN.
 159         if (g_engine && caret) {
 160                 g_engine->errorString(in_buf, buf, STRINGBUFLEN);
 161         } else {
 162                 strncpy(buf, in_buf, STRINGBUFLEN);
 163         }
 164         buf[STRINGBUFLEN-1] = '\0';
 165
 166         if (caret) {
 167                 buf[STRINGBUFLEN-2] = '\0';
 168                 strcat(buf, "\n");
 169         }
 170
 171         fputs(buf, stdout);
 172
 173 #if defined( USE_WINDBG )
 174 #if defined( _WIN32_WCE )
 175         TCHAR buf_unicode[1024];
 176         MultiByteToWideChar(CP_ACP, 0, buf, strlen(buf) + 1, buf_unicode, sizeof(buf_unicode));
 177         OutputDebugString(buf_unicode);
 178 #else
 179         OutputDebugString(buf);
 180 #endif
 181 #endif
 182
 183         fflush(stdout);
 184 }
 185
 186 void debug(const char *s, ...) {
 187         va_list va;
 188
 189         va_start(va, s);
 190         debugHelper(s, va);
 191         va_end(va);
 192 }
 193
 194 void debug(int level, const char *s, ...) {
 195         va_list va;
 196
 197         if (level > gDebugLevel)
 198                 return;
 199
 200         va_start(va, s);
 201         debugHelper(s, va);
 202         va_end(va);
 203
 204 }
 205
 206 void debugN(int level, const char *s, ...) {
 207         va_list va;
 208
 209         if (level > gDebugLevel)
 210                 return;
 211
 212         va_start(va, s);
 213         debugHelper(s, va, false);
 214         va_end(va);
 215 }
 216
 217 void debugC(int level, uint32 debugChannels, const char *s, ...) {
 218         va_list va;
 219
 220         // Debug level 11 turns on all special debug level messages
 221         if (gDebugLevel != 11)
 222                 if (level > gDebugLevel || !(Common::gDebugLevelsEnabled & debugChannels))
 223                         return;
 224
 225         va_start(va, s);
 226         debugHelper(s, va);
 227         va_end(va);
 228 }
 229
 230 void debugCN(int level, uint32 debugChannels, const char *s, ...) {
 231         va_list va;
 232
 233         // Debug level 11 turns on all special debug level messages
 234         if (gDebugLevel != 11)
 235                 if (level > gDebugLevel || !(Common::gDebugLevelsEnabled & debugChannels))
 236                         return;
 237
 238         va_start(va, s);
 239         debugHelper(s, va, false);
 240         va_end(va);
 241 }
 242
 243 void debugC(uint32 debugChannels, const char *s, ...) {
 244         va_list va;
 245
 246         // Debug level 11 turns on all special debug level messages
 247         if (gDebugLevel != 11)
 248                 if (!(Common::gDebugLevelsEnabled & debugChannels))
 249                         return;
 250
 251         va_start(va, s);
 252         debugHelper(s, va);
 253         va_end(va);
 254 }
 255
 256 void debugCN(uint32 debugChannels, const char *s, ...) {
 257         va_list va;
 258
 259         // Debug level 11 turns on all special debug level messages
 260         if (gDebugLevel != 11)
 261                 if (!(Common::gDebugLevelsEnabled & debugChannels))
 262                         return;
 263
 264         va_start(va, s);
 265         debugHelper(s, va, false);
 266         va_end(va);
 267 }
 268
 269 #endif