ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

First pass at dealing with different size_t/off_t sizes in C90 environments. 

Most of the code dealing with the LogTypes namespace was C which lead to a
lot of nonsensical casting, so I have dumbed LOG_TYPE and LOG_LEVEL down to
plain C even though the move of wiiuse into Source means we don't currently
call GenericLog from C.

Set logging threshold to MAX_LOGLEVEL at startup so debug builds will also
p  rint debugging messages before the GUI is running.

For some reason the way we use SetDefaultStyle doesn't play nice with wx 2.9
so we just get the default black text on a black background. Using a gray
background works around that problem, but I found it to also be much easier
on the eyes so I have switched the background color on all versions.


git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@6528 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
Soren Jorvang 2010-12-05 15:59:11 +00:00
parent e5311460a9
commit f169def36f
49 changed files with 1877 additions and 1888 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/AudioCommon/Src/WaveFile.cpp
View File

@ -74,7 +74,7 @@ bool WaveFileWriter::Start(const char *filename)
// We are now at offset 44 // We are now at offset 44
if (ftello(file) != 44) if (ftello(file) != 44)
PanicAlert("wrong offset: %lli", ftello(file)); PanicAlert("wrong offset: %lld", (long long)ftello(file));
return true; return true;
} }

6
Source/Core/Common/Src/ChunkFile.h
View File

@ -70,7 +70,7 @@ public:
case MODE_READ: memcpy(data, *ptr, size); break; case MODE_READ: memcpy(data, *ptr, size); break;
case MODE_WRITE: memcpy(*ptr, data, size); break; case MODE_WRITE: memcpy(*ptr, data, size); break;
case MODE_MEASURE: break; // MODE_MEASURE - don't need to do anything case MODE_MEASURE: break; // MODE_MEASURE - don't need to do anything
case MODE_VERIFY: for(int i = 0; i < size; i++) _dbg_assert_msg_(COMMON, ((u8*)data)[i] == (*ptr)[i], "Savestate verification failure: %d (0x%X) (at 0x%X) != %d (0x%X) (at 0x%X).\n", ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i], &(*ptr)[i]); break; case MODE_VERIFY: for(int i = 0; i < size; i++) _dbg_assert_msg_(COMMON, ((u8*)data)[i] == (*ptr)[i], "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n", ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i], &(*ptr)[i]); break;
default: break; // throw an error? default: break; // throw an error?
} }
(*ptr) += size; (*ptr) += size;
@ -136,7 +136,7 @@ public:
case MODE_READ: x = (char*)*ptr; break; case MODE_READ: x = (char*)*ptr; break;
case MODE_WRITE: memcpy(*ptr, x.c_str(), stringLen); break; case MODE_WRITE: memcpy(*ptr, x.c_str(), stringLen); break;
case MODE_MEASURE: break; case MODE_MEASURE: break;
case MODE_VERIFY: _dbg_assert_msg_(COMMON, !strcmp(x.c_str(), (char*)*ptr), "Savestate verification failure: \"%s\" != \"%s\" (at 0x%X).\n", x.c_str(), (char*)*ptr, ptr); break; case MODE_VERIFY: _dbg_assert_msg_(COMMON, !strcmp(x.c_str(), (char*)*ptr), "Savestate verification failure: \"%s\" != \"%s\" (at %p).\n", x.c_str(), (char*)*ptr, ptr); break;
} }
(*ptr) += stringLen; (*ptr) += stringLen;
} }
@ -150,7 +150,7 @@ public:
case MODE_READ: delete[] *pBuffer; *pBuffer = new u8[_Size]; memcpy(*pBuffer, *ptr, _Size); break; case MODE_READ: delete[] *pBuffer; *pBuffer = new u8[_Size]; memcpy(*pBuffer, *ptr, _Size); break;
case MODE_WRITE: memcpy(*ptr, *pBuffer, _Size); break; case MODE_WRITE: memcpy(*ptr, *pBuffer, _Size); break;
case MODE_MEASURE: break; case MODE_MEASURE: break;
case MODE_VERIFY: if(*pBuffer) for(u32 i = 0; i < _Size; i++) _dbg_assert_msg_(COMMON, (*pBuffer)[i] == (*ptr)[i], "Savestate verification failure: %d (0x%X) (at 0x%X) != %d (0x%X) (at 0x%X).\n", (*pBuffer)[i], (*pBuffer)[i], &(*pBuffer)[i], (*ptr)[i], (*ptr)[i], &(*ptr)[i]); break; case MODE_VERIFY: if(*pBuffer) for(u32 i = 0; i < _Size; i++) _dbg_assert_msg_(COMMON, (*pBuffer)[i] == (*ptr)[i], "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n", (*pBuffer)[i], (*pBuffer)[i], &(*pBuffer)[i], (*ptr)[i], (*ptr)[i], &(*ptr)[i]); break;
} }
} else { } else {
*pBuffer = NULL; *pBuffer = NULL;

4
Source/Core/Common/Src/ConsoleListener.cpp
View File

@ -245,14 +245,14 @@ void ConsoleListener::PixelSpace(int Left, int Top, int Width, int Height, bool
COORD Coo = GetCoordinates(OldCursor, LBufWidth); COORD Coo = GetCoordinates(OldCursor, LBufWidth);
SetConsoleCursorPosition(hConsole, Coo); SetConsoleCursorPosition(hConsole, Coo);
if (SLog.length() > 0) Log(LogTypes::LNOTICE, SLog.c_str()); if (SLog.length() > 0) Log(NOTICE_LEVEL, SLog.c_str());
// Resize the window too // Resize the window too
if (Resize) MoveWindow(GetConsoleWindow(), Left,Top, (Width + 100),Height, true); if (Resize) MoveWindow(GetConsoleWindow(), Left,Top, (Width + 100),Height, true);
#endif #endif
} }
void ConsoleListener::Log(LogTypes::LOG_LEVELS Level, const char *Text) void ConsoleListener::Log(enum LOG_LEVEL Level, const char *Text)
{ {
#if defined(_WIN32) #if defined(_WIN32)
/* /*

2
Source/Core/Common/Src/ConsoleListener.h
View File

@ -40,7 +40,7 @@ public:
#ifdef _WIN32 #ifdef _WIN32
COORD GetCoordinates(int BytesRead, int BufferWidth); COORD GetCoordinates(int BytesRead, int BufferWidth);
#endif #endif
void Log(LogTypes::LOG_LEVELS, const char *Text); void Log(enum LOG_LEVEL level, const char *Text);
void ClearScreen(bool Cursor = true); void ClearScreen(bool Cursor = true);
const char *getName() const { return "Console"; } const char *getName() const { return "Console"; }

3
Source/Core/Common/Src/FileUtil.cpp
View File

@ -337,7 +337,8 @@ u64 GetSize(const char *filename)
// on windows it's actually _stat64 defined in commonFuncs // on windows it's actually _stat64 defined in commonFuncs
struct stat64 buf; struct stat64 buf;
if (stat64(filename, &buf) == 0) { if (stat64(filename, &buf) == 0) {
DEBUG_LOG(COMMON, "GetSize: %s: %lld", filename, buf.st_size); DEBUG_LOG(COMMON, "GetSize: %s: %lld",
filename, (long long)buf.st_size);
return buf.st_size; return buf.st_size;
} }

63
Source/Core/Common/Src/Log.h
View File

@ -18,17 +18,6 @@
#ifndef _LOG_H_ #ifndef _LOG_H_
#define _LOG_H_ #define _LOG_H_
#define NOTICE_LEVEL 1 // VERY important information that is NOT errors. Like startup and OSReports.
#define ERROR_LEVEL 2 // Critical errors
#define WARNING_LEVEL 3 // Something is suspicious.
#define INFO_LEVEL 4 // General information.
#define DEBUG_LEVEL 5 // Detailed debugging - might make things slow.
#ifdef __cplusplus
namespace LogTypes
{
#endif
enum LOG_TYPE { enum LOG_TYPE {
ACTIONREPLAY, ACTIONREPLAY,
AUDIO, AUDIO,
@ -48,7 +37,7 @@ enum LOG_TYPE {
EXPANSIONINTERFACE, EXPANSIONINTERFACE,
POWERPC, POWERPC,
GPFIFO, GPFIFO,
HLE, OSHLE,
MASTER_LOG, MASTER_LOG,
MEMMAP, MEMMAP,
MEMCARD_MANAGER, MEMCARD_MANAGER,
@ -77,37 +66,21 @@ enum LOG_TYPE {
NUMBER_OF_LOGS // Must be last NUMBER_OF_LOGS // Must be last
}; };
// FIXME: should this be removed? enum LOG_LEVEL {
enum LOG_LEVELS { NOTICE_LEVEL = 1, // VERY important information that is NOT errors. Like startup and OSReports
LNOTICE = NOTICE_LEVEL, ERROR_LEVEL = 2, // Critical errors
LERROR = ERROR_LEVEL, WARNING_LEVEL = 3, // Something is suspicious
LWARNING = WARNING_LEVEL, INFO_LEVEL = 4, // General information
LINFO = INFO_LEVEL, DEBUG_LEVEL = 5, // Detailed debugging - might make things slow
LDEBUG = DEBUG_LEVEL,
}; };
#ifdef __cplusplus extern "C"
#define LOGTYPES_LEVELS LogTypes::LOG_LEVELS void GenericLog(enum LOG_LEVEL level, enum LOG_TYPE type,
#define LOGTYPES_TYPE LogTypes::LOG_TYPE
#else
#define LOGTYPES_LEVELS enum LOG_LEVELS
#define LOGTYPES_TYPE enum LOG_TYPE
#endif
#ifdef __cplusplus
} // namespace
extern "C" {
#endif
void GenericLog(LOGTYPES_LEVELS level, LOGTYPES_TYPE type,
const char *file, int line, const char *fmt, ...) const char *file, int line, const char *fmt, ...)
#ifdef __GNUC__ #ifdef __GNUC__
__attribute__((format(printf, 5, 6))) __attribute__((format(printf, 5, 6)))
#endif #endif
; ;
#ifdef __cplusplus
};
#endif
#if defined LOGGING || defined _DEBUG || defined DEBUGFAST #if defined LOGGING || defined _DEBUG || defined DEBUGFAST
#define MAX_LOGLEVEL DEBUG_LEVEL #define MAX_LOGLEVEL DEBUG_LEVEL
@ -120,16 +93,20 @@ void GenericLog(LOGTYPES_LEVELS level, LOGTYPES_TYPE type,
#ifdef GEKKO #ifdef GEKKO
#define GENERIC_LOG(t, v, ...) #define GENERIC_LOG(t, v, ...)
#else #else
// Let the compiler optimize this out // Let the compiler optimize this out
#define GENERIC_LOG(t, v, ...) {if (v <= MAX_LOGLEVEL) {GenericLog(v, t, __FILE__, __LINE__, __VA_ARGS__);}} #define GENERIC_LOG(t, v, ...) { \
if (v <= MAX_LOGLEVEL) \
GenericLog(v, t, __FILE__, __LINE__, __VA_ARGS__); \
}
//#define GENERIC_LOG(t, v, ...) { if (v <= MAX_LOGLEVEL)
// GenericLog(v, t, __FILE__, __LINE__, __VA_ARGS__); }
#endif #endif
#define ERROR_LOG(t,...) { GENERIC_LOG(LogTypes::t, LogTypes::LERROR, __VA_ARGS__) } #define ERROR_LOG(t,...) { GENERIC_LOG(t, ERROR_LEVEL, __VA_ARGS__) }
#define WARN_LOG(t,...) { GENERIC_LOG(LogTypes::t, LogTypes::LWARNING, __VA_ARGS__) } #define WARN_LOG(t,...) { GENERIC_LOG(t, WARNING_LEVEL, __VA_ARGS__) }
#define NOTICE_LOG(t,...) { GENERIC_LOG(LogTypes::t, LogTypes::LNOTICE, __VA_ARGS__) } #define NOTICE_LOG(t,...) { GENERIC_LOG(t, NOTICE_LEVEL, __VA_ARGS__) }
#define INFO_LOG(t,...) { GENERIC_LOG(LogTypes::t, LogTypes::LINFO, __VA_ARGS__) } #define INFO_LOG(t,...) { GENERIC_LOG(t, INFO_LEVEL, __VA_ARGS__) }
#define DEBUG_LOG(t,...) { GENERIC_LOG(LogTypes::t, LogTypes::LDEBUG, __VA_ARGS__) } #define DEBUG_LOG(t,...) { GENERIC_LOG(t, DEBUG_LEVEL, __VA_ARGS__) }
#if MAX_LOGLEVEL >= DEBUG_LEVEL #if MAX_LOGLEVEL >= DEBUG_LEVEL
#define _dbg_assert_(_t_, _a_) \ #define _dbg_assert_(_t_, _a_) \

111
Source/Core/Common/Src/LogManager.cpp
View File

@ -23,7 +23,7 @@
#include "Thread.h" #include "Thread.h"
#include "FileUtil.h" #include "FileUtil.h"
void GenericLog(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, void GenericLog(enum LOG_LEVEL level, enum LOG_TYPE type,
const char *file, int line, const char* fmt, ...) const char *file, int line, const char* fmt, ...)
{ {
va_list args; va_list args;
@ -40,54 +40,54 @@ LogManager::LogManager() {
logMutex = new Common::CriticalSection(1); logMutex = new Common::CriticalSection(1);
// create log files // create log files
m_Log[LogTypes::MASTER_LOG] = new LogContainer("*", "Master Log"); m_Log[MASTER_LOG] = new LogContainer("*", "Master Log");
m_Log[LogTypes::BOOT] = new LogContainer("BOOT", "Boot"); m_Log[BOOT] = new LogContainer("BOOT", "Boot");
m_Log[LogTypes::COMMON] = new LogContainer("COMMON", "Common"); m_Log[COMMON] = new LogContainer("COMMON", "Common");
m_Log[LogTypes::DISCIO] = new LogContainer("DIO", "Disc IO"); m_Log[DISCIO] = new LogContainer("DIO", "Disc IO");
m_Log[LogTypes::FILEMON] = new LogContainer("FileMon", "File Monitor"); m_Log[FILEMON] = new LogContainer("FileMon", "File Monitor");
m_Log[LogTypes::PAD] = new LogContainer("PAD", "Pad"); m_Log[PAD] = new LogContainer("PAD", "Pad");
m_Log[LogTypes::PIXELENGINE] = new LogContainer("PE", "PixelEngine"); m_Log[PIXELENGINE] = new LogContainer("PE", "PixelEngine");
m_Log[LogTypes::COMMANDPROCESSOR] = new LogContainer("CP", "CommandProc"); m_Log[COMMANDPROCESSOR] = new LogContainer("CP", "CommandProc");
m_Log[LogTypes::VIDEOINTERFACE] = new LogContainer("VI", "VideoInt"); m_Log[VIDEOINTERFACE] = new LogContainer("VI", "VideoInt");
m_Log[LogTypes::SERIALINTERFACE] = new LogContainer("SI", "SerialInt"); m_Log[SERIALINTERFACE] = new LogContainer("SI", "SerialInt");
m_Log[LogTypes::PROCESSORINTERFACE] = new LogContainer("PI", "ProcessorInt"); m_Log[PROCESSORINTERFACE] = new LogContainer("PI", "ProcessorInt");
m_Log[LogTypes::MEMMAP] = new LogContainer("MI", "MI & memmap"); m_Log[MEMMAP] = new LogContainer("MI", "MI & memmap");
m_Log[LogTypes::SP1] = new LogContainer("SP1", "Serial Port 1"); m_Log[SP1] = new LogContainer("SP1", "Serial Port 1");
m_Log[LogTypes::STREAMINGINTERFACE] = new LogContainer("Stream", "StreamingInt"); m_Log[STREAMINGINTERFACE] = new LogContainer("Stream", "StreamingInt");
m_Log[LogTypes::DSPINTERFACE] = new LogContainer("DSP", "DSPInterface"); m_Log[DSPINTERFACE] = new LogContainer("DSP", "DSPInterface");
m_Log[LogTypes::DVDINTERFACE] = new LogContainer("DVD", "DVDInterface"); m_Log[DVDINTERFACE] = new LogContainer("DVD", "DVDInterface");
m_Log[LogTypes::GPFIFO] = new LogContainer("GP", "GPFifo"); m_Log[GPFIFO] = new LogContainer("GP", "GPFifo");
m_Log[LogTypes::EXPANSIONINTERFACE] = new LogContainer("EXI", "ExpansionInt"); m_Log[EXPANSIONINTERFACE] = new LogContainer("EXI", "ExpansionInt");
m_Log[LogTypes::AUDIO_INTERFACE] = new LogContainer("AI", "AudioInt"); m_Log[AUDIO_INTERFACE] = new LogContainer("AI", "AudioInt");
m_Log[LogTypes::POWERPC] = new LogContainer("PowerPC", "IBM CPU"); m_Log[POWERPC] = new LogContainer("PowerPC", "IBM CPU");
m_Log[LogTypes::HLE] = new LogContainer("HLE", "HLE"); m_Log[OSHLE] = new LogContainer("HLE", "HLE");
m_Log[LogTypes::DSPHLE] = new LogContainer("DSPHLE", "DSP HLE"); m_Log[DSPHLE] = new LogContainer("DSPHLE", "DSP HLE");
m_Log[LogTypes::DSPLLE] = new LogContainer("DSPLLE", "DSP LLE"); m_Log[DSPLLE] = new LogContainer("DSPLLE", "DSP LLE");
m_Log[LogTypes::DSP_MAIL] = new LogContainer("DSPMails", "DSP Mails"); m_Log[DSP_MAIL] = new LogContainer("DSPMails", "DSP Mails");
m_Log[LogTypes::VIDEO] = new LogContainer("Video", "Video Plugin"); m_Log[VIDEO] = new LogContainer("Video", "Video Plugin");
m_Log[LogTypes::AUDIO] = new LogContainer("Audio", "Audio Plugin"); m_Log[AUDIO] = new LogContainer("Audio", "Audio Plugin");
m_Log[LogTypes::DYNA_REC] = new LogContainer("JIT", "Dynamic Recompiler"); m_Log[DYNA_REC] = new LogContainer("JIT", "Dynamic Recompiler");
m_Log[LogTypes::CONSOLE] = new LogContainer("CONSOLE", "Dolphin Console"); m_Log[CONSOLE] = new LogContainer("CONSOLE", "Dolphin Console");
m_Log[LogTypes::OSREPORT] = new LogContainer("OSREPORT", "OSReport"); m_Log[OSREPORT] = new LogContainer("OSREPORT", "OSReport");
m_Log[LogTypes::WIIMOTE] = new LogContainer("Wiimote", "Wiimote Plugin"); m_Log[WIIMOTE] = new LogContainer("Wiimote", "Wiimote Plugin");
m_Log[LogTypes::WII_IOB] = new LogContainer("WII_IOB", "WII IO Bridge"); m_Log[WII_IOB] = new LogContainer("WII_IOB", "WII IO Bridge");
m_Log[LogTypes::WII_IPC] = new LogContainer("WII_IPC", "WII IPC"); m_Log[WII_IPC] = new LogContainer("WII_IPC", "WII IPC");
m_Log[LogTypes::WII_IPC_HLE] = new LogContainer("WII_IPC_HLE", "WII IPC HLE"); m_Log[WII_IPC_HLE] = new LogContainer("WII_IPC_HLE", "WII IPC HLE");
m_Log[LogTypes::WII_IPC_DVD] = new LogContainer("WII_IPC_DVD", "WII IPC DVD"); m_Log[WII_IPC_DVD] = new LogContainer("WII_IPC_DVD", "WII IPC DVD");
m_Log[LogTypes::WII_IPC_ES] = new LogContainer("WII_IPC_ES", "WII IPC ES"); m_Log[WII_IPC_ES] = new LogContainer("WII_IPC_ES", "WII IPC ES");
m_Log[LogTypes::WII_IPC_FILEIO] = new LogContainer("WII_IPC_FILEIO","WII IPC FILEIO"); m_Log[WII_IPC_FILEIO] = new LogContainer("WII_IPC_FILEIO", "WII IPC FILEIO");
m_Log[LogTypes::WII_IPC_SD] = new LogContainer("WII_IPC_SD", "WII IPC SD"); m_Log[WII_IPC_SD] = new LogContainer("WII_IPC_SD", "WII IPC SD");
m_Log[LogTypes::WII_IPC_STM] = new LogContainer("WII_IPC_STM", "WII IPC STM"); m_Log[WII_IPC_STM] = new LogContainer("WII_IPC_STM", "WII IPC STM");
m_Log[LogTypes::WII_IPC_NET] = new LogContainer("WII_IPC_NET", "WII IPC NET"); m_Log[WII_IPC_NET] = new LogContainer("WII_IPC_NET", "WII IPC NET");
m_Log[LogTypes::WII_IPC_WIIMOTE] = new LogContainer("WII_IPC_WIIMOTE","WII IPC WIIMOTE"); m_Log[WII_IPC_WIIMOTE] = new LogContainer("WII_IPC_WIIMOTE", "WII IPC WIIMOTE");
m_Log[LogTypes::ACTIONREPLAY] = new LogContainer("ActionReplay", "ActionReplay"); m_Log[ACTIONREPLAY] = new LogContainer("ActionReplay", "ActionReplay");
m_Log[LogTypes::MEMCARD_MANAGER] = new LogContainer("MemCard Manager", "MemCard Manager"); m_Log[MEMCARD_MANAGER] = new LogContainer("MemCard Manager", "MemCard Manager");
m_Log[LogTypes::NETPLAY] = new LogContainer("NETPLAY", "Netplay"); m_Log[NETPLAY] = new LogContainer("NETPLAY", "Netplay");
m_fileLog = new FileLogListener(File::GetUserPath(F_MAINLOG_IDX)); m_fileLog = new FileLogListener(File::GetUserPath(F_MAINLOG_IDX));
m_consoleLog = new ConsoleListener(); m_consoleLog = new ConsoleListener();
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) { for (int i = 0; i < NUMBER_OF_LOGS; ++i) {
m_Log[i]->setEnable(true); m_Log[i]->setEnable(true);
m_Log[i]->addListener(m_fileLog); m_Log[i]->addListener(m_fileLog);
m_Log[i]->addListener(m_consoleLog); m_Log[i]->addListener(m_consoleLog);
@ -95,12 +95,12 @@ LogManager::LogManager() {
} }
LogManager::~LogManager() { LogManager::~LogManager() {
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) { for (int i = 0; i < NUMBER_OF_LOGS; ++i) {
m_logManager->removeListener((LogTypes::LOG_TYPE)i, m_fileLog); m_logManager->removeListener(i, m_fileLog);
m_logManager->removeListener((LogTypes::LOG_TYPE)i, m_consoleLog); m_logManager->removeListener(i, m_consoleLog);
} }
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) for (int i = 0; i < NUMBER_OF_LOGS; ++i)
delete m_Log[i]; delete m_Log[i];
delete m_fileLog; delete m_fileLog;
@ -108,9 +108,8 @@ LogManager::~LogManager() {
delete logMutex; delete logMutex;
} }
void LogManager::Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, void LogManager::Log(enum LOG_LEVEL level, enum LOG_TYPE type,
const char *file, int line, const char *format, const char *file, int line, const char *format, va_list args) {
va_list args) {
char temp[MAX_MSGLEN]; char temp[MAX_MSGLEN];
char msg[MAX_MSGLEN * 2]; char msg[MAX_MSGLEN * 2];
@ -132,7 +131,7 @@ void LogManager::Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type,
logMutex->Leave(); logMutex->Leave();
} }
void LogManager::removeListener(LogTypes::LOG_TYPE type, LogListener *listener) { void LogManager::removeListener(int type, LogListener *listener) {
logMutex->Enter(); logMutex->Enter();
m_Log[type]->removeListener(listener); m_Log[type]->removeListener(listener);
logMutex->Leave(); logMutex->Leave();
@ -153,7 +152,7 @@ LogContainer::LogContainer(const char* shortName, const char* fullName, bool ena
: m_enable(enable) { : m_enable(enable) {
strncpy(m_fullName, fullName, 128); strncpy(m_fullName, fullName, 128);
strncpy(m_shortName, shortName, 32); strncpy(m_shortName, shortName, 32);
m_level = LogTypes::LWARNING; m_level = MAX_LOGLEVEL;
} }
// LogContainer // LogContainer
@ -172,7 +171,7 @@ bool LogContainer::isListener(LogListener *listener) const {
return listeners.end() != std::find(listeners.begin(), listeners.end(), listener); return listeners.end() != std::find(listeners.begin(), listeners.end(), listener);
} }
void LogContainer::trigger(LogTypes::LOG_LEVELS level, const char *msg) { void LogContainer::trigger(enum LOG_LEVEL level, const char *msg) {
std::vector<LogListener *>::const_iterator i; std::vector<LogListener *>::const_iterator i;
for (i = listeners.begin(); i != listeners.end(); ++i) { for (i = listeners.begin(); i != listeners.end(); ++i) {
(*i)->Log(level, msg); (*i)->Log(level, msg);
@ -191,7 +190,7 @@ FileLogListener::~FileLogListener() {
fclose(m_logfile); fclose(m_logfile);
} }
void FileLogListener::Log(LogTypes::LOG_LEVELS, const char *msg) { void FileLogListener::Log(enum LOG_LEVEL, const char *msg) {
if (!m_enable || !isValid()) if (!m_enable || !isValid())
return; return;

32
Source/Core/Common/Src/LogManager.h
View File

@ -33,7 +33,7 @@
class LogListener { class LogListener {
public: public:
virtual ~LogListener() {} virtual ~LogListener() {}
virtual void Log(LogTypes::LOG_LEVELS, const char *msg) = 0; virtual void Log(enum LOG_LEVEL level, const char *msg) = 0;
virtual const char *getName() const = 0; virtual const char *getName() const = 0;
}; };
@ -42,7 +42,7 @@ public:
FileLogListener(const char *filename); FileLogListener(const char *filename);
~FileLogListener(); ~FileLogListener();
void Log(LogTypes::LOG_LEVELS, const char *msg); void Log(enum LOG_LEVEL level, const char *msg);
bool isValid() { bool isValid() {
return (m_logfile != NULL); return (m_logfile != NULL);
@ -75,18 +75,18 @@ public:
void addListener(LogListener *listener); void addListener(LogListener *listener);
void removeListener(LogListener *listener); void removeListener(LogListener *listener);
void trigger(LogTypes::LOG_LEVELS, const char *msg); void trigger(enum LOG_LEVEL level, const char *msg);
bool isEnable() const { return m_enable; } bool isEnable() const { return m_enable; }
void setEnable(bool enable) { void setEnable(bool enable) {
m_enable = enable; m_enable = enable;
} }
LogTypes::LOG_LEVELS getLevel() const { enum LOG_LEVEL getLevel() const {
return m_level; return m_level;
} }
void setLevel(LogTypes::LOG_LEVELS level) { void setLevel(enum LOG_LEVEL level) {
m_level = level; m_level = level;
} }
@ -94,7 +94,7 @@ private:
char m_fullName[128]; char m_fullName[128];
char m_shortName[32]; char m_shortName[32];
bool m_enable; bool m_enable;
LogTypes::LOG_LEVELS m_level; enum LOG_LEVEL m_level;
std::vector<LogListener *> listeners; std::vector<LogListener *> listeners;
}; };
@ -109,7 +109,7 @@ namespace Common {
class LogManager : NonCopyable class LogManager : NonCopyable
{ {
private: private:
LogContainer* m_Log[LogTypes::NUMBER_OF_LOGS]; LogContainer *m_Log[NUMBER_OF_LOGS];
Common::CriticalSection *logMutex; Common::CriticalSection *logMutex;
FileLogListener *m_fileLog; FileLogListener *m_fileLog;
ConsoleListener *m_consoleLog; ConsoleListener *m_consoleLog;
@ -121,38 +121,38 @@ public:
static u32 GetMaxLevel() { return MAX_LOGLEVEL; } static u32 GetMaxLevel() { return MAX_LOGLEVEL; }
void Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, void Log(enum LOG_LEVEL level, enum LOG_TYPE type,
const char *file, int line, const char *fmt, va_list args); const char *file, int line, const char *fmt, va_list args);
void setLogLevel(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level) { void setLogLevel(int type, LOG_LEVEL level) {
m_Log[type]->setLevel(level); m_Log[type]->setLevel(level);
} }
void setEnable(LogTypes::LOG_TYPE type, bool enable) { void setEnable(int type, bool enable) {
m_Log[type]->setEnable(enable); m_Log[type]->setEnable(enable);
} }
bool isEnable(LogTypes::LOG_TYPE type) { bool isEnable(int type) {
return m_Log[type]->isEnable(); return m_Log[type]->isEnable();
} }
const char *getShortName(LogTypes::LOG_TYPE type) const { const char *getShortName(int type) const {
return m_Log[type]->getShortName(); return m_Log[type]->getShortName();
} }
const char *getFullName(LogTypes::LOG_TYPE type) const { const char *getFullName(int type) const {
return m_Log[type]->getFullName(); return m_Log[type]->getFullName();
} }
bool isListener(LogTypes::LOG_TYPE type, LogListener *listener) const { bool isListener(int type, LogListener *listener) const {
return m_Log[type]->isListener(listener); return m_Log[type]->isListener(listener);
} }
void addListener(LogTypes::LOG_TYPE type, LogListener *listener) { void addListener(int type, LogListener *listener) {
m_Log[type]->addListener(listener); m_Log[type]->addListener(listener);
} }
void removeListener(LogTypes::LOG_TYPE type, LogListener *listener); void removeListener(int type, LogListener *listener);
FileLogListener *getFileListener() { FileLogListener *getFileListener() {
return m_fileLog; return m_fileLog;

8
Source/Core/Common/Src/SymbolDB.cpp
View File

@ -22,9 +22,13 @@ void SymbolDB::List()
{ {
for (XFuncMap::iterator iter = functions.begin(); iter != functions.end(); ++iter) for (XFuncMap::iterator iter = functions.begin(); iter != functions.end(); ++iter)
{ {
DEBUG_LOG(HLE,"%s @ %08x: %i bytes (hash %08x) : %i calls", iter->second.name.c_str(), iter->second.address, iter->second.size, iter->second.hash,iter->second.numCalls); DEBUG_LOG(OSHLE, "%s @ %08x: %i bytes (hash %08x) : %i calls",
iter->second.name.c_str(), iter->second.address,
iter->second.size, iter->second.hash,
iter->second.numCalls);
} }
INFO_LOG(HLE,"%i functions known in this program above.", functions.size()); INFO_LOG(OSHLE, "%lu functions known in this program above.",
functions.size());
} }
void SymbolDB::Clear(const char *prefix) void SymbolDB::Clear(const char *prefix)

11
Source/Core/Common/Src/Thread.cpp
View File

@ -356,7 +356,8 @@ namespace Common
if (ret) ERROR_LOG(COMMON, "%s: pthread_create(%p, %p, %p, %p) failed: %s\n", if (ret) ERROR_LOG(COMMON, "%s: pthread_create(%p, %p, %p, %p) failed: %s\n",
__FUNCTION__, &thread_id, &attr, function, arg, strerror(ret)); __FUNCTION__, &thread_id, &attr, function, arg, strerror(ret));
INFO_LOG(COMMON, "created new thread %lu (func=%p, arg=%p)\n", thread_id, function, arg); INFO_LOG(COMMON, "created new thread %lu (func=%p, arg=%p)\n",
(unsigned long)thread_id, function, arg);
} }
@ -372,9 +373,13 @@ namespace Common
{ {
void* exit_status; void* exit_status;
int ret = pthread_join(thread_id, &exit_status); int ret = pthread_join(thread_id, &exit_status);
if (ret) ERROR_LOG(COMMON, "error joining thread %lu: %s\n", thread_id, strerror(ret)); if (ret) ERROR_LOG(COMMON,
"error joining thread %lu: %s\n",
(unsigned long)thread_id, strerror(ret));
if (exit_status) if (exit_status)
ERROR_LOG(COMMON, "thread %lu exited with status %d\n", thread_id, *(int *)exit_status); ERROR_LOG(COMMON,
"thread %lu exited with status %d\n",
(unsigned long)thread_id, *(int *)exit_status);
thread_id = 0; thread_id = 0;
} }
} }

2
Source/Core/Common/Src/x64Emitter.cpp
View File

@ -171,7 +171,7 @@ void OpArg::WriteRest(XEmitter *emit, int extraBytes, X64Reg _operandReg) const
s64 distance = (s64)offset - (s64)ripAddr; s64 distance = (s64)offset - (s64)ripAddr;
if (distance >= 0x0000000080000000LL if (distance >= 0x0000000080000000LL
|| distance < -0x0000000080000000LL) { || distance < -0x0000000080000000LL) {
PanicAlert("WriteRest: op out of range (%p uses %p)", ripAddr, offset); PanicAlert("WriteRest: op out of range (0x%llx uses 0x%llx)", ripAddr, offset);
} }
s32 offs = (s32)distance; s32 offs = (s32)distance;
emit->Write32((u32)offs); emit->Write32((u32)offs);

6
Source/Core/Core/Src/ActionReplay.cpp
View File

@ -238,7 +238,7 @@ void LogInfo(const char *format, ...)
{ {
if (!b_RanOnce) if (!b_RanOnce)
{ {
if (LogManager::GetMaxLevel() >= LogTypes::LINFO || logSelf) if (LogManager::GetMaxLevel() >= INFO_LEVEL || logSelf)
{ {
char* temp = (char*)alloca(strlen(format)+512); char* temp = (char*)alloca(strlen(format)+512);
va_list args; va_list args;
@ -448,7 +448,7 @@ ARCode GetARCode(size_t index)
{ {
if (index > arCodes.size()) if (index > arCodes.size())
{ {
PanicAlert("GetARCode: Index is greater than ar code list size %i", index); PanicAlert("GetARCode: Index is greater than ar code list size %lu", index);
return ARCode(); return ARCode();
} }
return arCodes[index]; return arCodes[index];
@ -458,7 +458,7 @@ void SetARCode_IsActive(bool active, size_t index)
{ {
if (index > arCodes.size()) if (index > arCodes.size())
{ {
PanicAlert("SetARCode_IsActive: Index is greater than ar code list size %i", index); PanicAlert("SetARCode_IsActive: Index is greater than ar code list size %lu", index);
return; return;
} }
arCodes[index].active = active; arCodes[index].active = active;

4
Source/Core/Core/Src/Core.cpp
View File

@ -407,7 +407,7 @@ THREAD_RETURN EmuThread(void *pArg)
PowerPC::SetMode(PowerPC::MODE_INTERPRETER); PowerPC::SetMode(PowerPC::MODE_INTERPRETER);
// Spawn the CPU thread // Spawn the CPU thread
_dbg_assert_(HLE, cpuThread == NULL); _dbg_assert_(OSHLE, cpuThread == NULL);
// ENTER THE VIDEO THREAD LOOP // ENTER THE VIDEO THREAD LOOP
if (_CoreParameter.bCPUThread) if (_CoreParameter.bCPUThread)
{ {
@ -710,7 +710,7 @@ void Callback_VideoRequestWindowSize(int& x, int& y, int& width, int& height)
// WARNING - THIS MAY BE EXECUTED FROM DSP THREAD // WARNING - THIS MAY BE EXECUTED FROM DSP THREAD
void Callback_DSPLog(const TCHAR* _szMessage, int _v) void Callback_DSPLog(const TCHAR* _szMessage, int _v)
{ {
GENERIC_LOG(LogTypes::AUDIO, (LogTypes::LOG_LEVELS)_v, "%s", _szMessage); GENERIC_LOG(AUDIO, (enum LOG_LEVEL)_v, "%s", _szMessage);
} }

8
Source/Core/Core/Src/Debugger/Debugger_SymbolMap.cpp
View File

@ -127,7 +127,7 @@ void PrintCallstack()
} }
} }
void PrintCallstack(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level) void PrintCallstack(enum LOG_TYPE type, enum LOG_LEVEL level)
{ {
u32 addr = Memory::ReadUnchecked_U32(PowerPC::ppcState.gpr[1]); // SP u32 addr = Memory::ReadUnchecked_U32(PowerPC::ppcState.gpr[1]); // SP
@ -157,9 +157,9 @@ void PrintCallstack(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level)
} }
} }
void PrintDataBuffer(LogTypes::LOG_TYPE type, u8* _pData, size_t _Size, const char* _title) void PrintDataBuffer(enum LOG_TYPE type, u8* _pData, size_t _Size, const char* _title)
{ {
GENERIC_LOG(type, LogTypes::LDEBUG, "%s", _title); DEBUG_LOG(type, "%s", _title);
for (u32 j = 0; j < _Size;) for (u32 j = 0; j < _Size;)
{ {
std::string Temp; std::string Temp;
@ -172,7 +172,7 @@ void PrintDataBuffer(LogTypes::LOG_TYPE type, u8* _pData, size_t _Size, const ch
if (j >= _Size) if (j >= _Size)
break; break;
} }
GENERIC_LOG(type, LogTypes::LDEBUG, " Data: %s", Temp.c_str()); DEBUG_LOG(type, " Data: %s", Temp.c_str());
} }
} }

4
Source/Core/Core/Src/Debugger/Debugger_SymbolMap.h
View File

@ -34,8 +34,8 @@ struct CallstackEntry
bool GetCallstack(std::vector<CallstackEntry> &output); bool GetCallstack(std::vector<CallstackEntry> &output);
void PrintCallstack(); void PrintCallstack();
void PrintCallstack(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level); void PrintCallstack(enum LOG_TYPE type, enum LOG_LEVEL level);
void PrintDataBuffer(LogTypes::LOG_TYPE _Log, u8* _pData, size_t _Size, const char* _title); void PrintDataBuffer(enum LOG_TYPE _Log, u8* _pData, size_t _Size, const char* _title);
void AddAutoBreakpoints(); void AddAutoBreakpoints();

4
Source/Core/Core/Src/HLE/HLE.cpp
View File

@ -127,7 +127,7 @@ void PatchFunctions()
orig_instruction[addr] = Memory::ReadUnchecked_U32(addr); orig_instruction[addr] = Memory::ReadUnchecked_U32(addr);
Memory::Write_U32(HLEPatchValue | i, addr); Memory::Write_U32(HLEPatchValue | i, addr);
} }
INFO_LOG(HLE,"Patching %s %08x", OSPatches[i].m_szPatchName, symbol->address); INFO_LOG(OSHLE, "Patching %s %08x", OSPatches[i].m_szPatchName, symbol->address);
} }
} }
@ -137,7 +137,7 @@ void PatchFunctions()
if (symbol > 0) if (symbol > 0)
{ {
PowerPC::breakpoints.Add(symbol->address, false); PowerPC::breakpoints.Add(symbol->address, false);
INFO_LOG(HLE,"Adding BP to %s %08x", OSBreakPoints[i].m_szPatchName, symbol->address); INFO_LOG(OSHLE, "Adding BP to %s %08x", OSBreakPoints[i].m_szPatchName, symbol->address);
} }
} }

2
Source/Core/Core/Src/HW/EXI_DeviceEthernet.cpp
View File

@ -40,7 +40,7 @@ void DEBUGPRINT (const char * format, ...)
#endif #endif
printf("%s\n", buffer); printf("%s\n", buffer);
#else #else
INFO_LOG(SP1, buffer); INFO_LOG(SP1, "%s", buffer);
#endif #endif
va_end(args); va_end(args);
} }

6
Source/Core/Core/Src/HW/Memmap.cpp
View File

@ -121,10 +121,10 @@ readFn64 hwReadWii64[NUMHWMEMFUN];
// Default read and write functions // Default read and write functions
template <class T> template <class T>
void HW_Default_Write(const T _Data, const u32 _Address){ ERROR_LOG(MASTER_LOG, "Illegal HW Write%i %08x", sizeof(T)*8, _Address);_dbg_assert_(MEMMAP, 0);} void HW_Default_Write(const T _Data, const u32 _Address){ ERROR_LOG(MASTER_LOG, "Illegal HW Write%lu %08x", sizeof(T)*8, _Address);_dbg_assert_(MEMMAP, 0);}
template <class T> template <class T>
void HW_Default_Read(T _Data, const u32 _Address){ ERROR_LOG(MASTER_LOG, "Illegal HW Read%i %08x", sizeof(T)*8, _Address); _dbg_assert_(MEMMAP, 0);} void HW_Default_Read(T _Data, const u32 _Address){ ERROR_LOG(MASTER_LOG, "Illegal HW Read%lu %08x", sizeof(T)*8, _Address); _dbg_assert_(MEMMAP, 0);}
#define PAGE_SHIFT 10 #define PAGE_SHIFT 10
#define PAGE_SIZE (1 << PAGE_SHIFT) #define PAGE_SIZE (1 << PAGE_SHIFT)
@ -623,7 +623,7 @@ u8 *GetPointer(const u32 _Address)
case 0xCC: case 0xCC:
case 0xCD: case 0xCD:
_dbg_assert_msg_(MEMMAP, 0, "Memory", "GetPointer from IO Bridge doesnt work"); _dbg_assert_msg_(MEMMAP, 0, "GetPointer from IO Bridge doesnt work");
return NULL; return NULL;
default: default:
if (bFakeVMEM) if (bFakeVMEM)

6
Source/Core/Core/Src/HW/MemmapFunctions.cpp
View File

@ -229,10 +229,10 @@ inline void WriteToHardware(u32 em_address, const T data, u32 effective_address,
// TODO figure out a way to send data without falling into the template trap // TODO figure out a way to send data without falling into the template trap
if (em_address & 0x00400000) { if (em_address & 0x00400000) {
CPluginManager::GetInstance().GetVideo()->Video_AccessEFB(POKE_Z, x, y, (u32)data); CPluginManager::GetInstance().GetVideo()->Video_AccessEFB(POKE_Z, x, y, (u32)data);
DEBUG_LOG(MEMMAP, "EFB Z Write %08x @ %i, %i", data, x, y); DEBUG_LOG(MEMMAP, "EFB Z Write %08x @ %i, %i", (u32)data, x, y);
} else { } else {
CPluginManager::GetInstance().GetVideo()->Video_AccessEFB(POKE_COLOR, x, y,(u32)data); CPluginManager::GetInstance().GetVideo()->Video_AccessEFB(POKE_COLOR, x, y,(u32)data);
DEBUG_LOG(MEMMAP, "EFB Color Write %08x @ %i, %i", data, x, y); DEBUG_LOG(MEMMAP, "EFB Color Write %08x @ %i, %i", (u32)data, x, y);
} }
return; return;
} }
@ -256,7 +256,7 @@ inline void WriteToHardware(u32 em_address, const T data, u32 effective_address,
} }
else else
{ {
ERROR_LOG(MEMMAP, "hwwrite [%08x] := %08x (PC: %08x)", em_address, data, PC); ERROR_LOG(MEMMAP, "hwwrite [%08x] := %08x (PC: %08x)", em_address, (u32)data, PC);
_dbg_assert_msg_(MEMMAP,0,"Memory - Unknown HW address %08x", em_address); _dbg_assert_msg_(MEMMAP,0,"Memory - Unknown HW address %08x", em_address);
} }
} }

2
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE.cpp
View File

@ -458,7 +458,7 @@ void Update()
request_queue.pop(); request_queue.pop();
#if MAX_LOGLEVEL >= DEBUG_LEVEL #if MAX_LOGLEVEL >= DEBUG_LEVEL
Dolphin_Debugger::PrintCallstack(LogTypes::WII_IPC_HLE, LogTypes::LDEBUG); Dolphin_Debugger::PrintCallstack(WII_IPC_HLE, DEBUG_LEVEL);
#endif #endif
} }

16
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device.h
View File

@ -162,8 +162,8 @@ protected:
// Write out the IPC struct from _CommandAddress to _NumberOfCommands numbers // Write out the IPC struct from _CommandAddress to _NumberOfCommands numbers
// of 4 byte commands. // of 4 byte commands.
void DumpCommands(u32 _CommandAddress, size_t _NumberOfCommands = 8, void DumpCommands(u32 _CommandAddress, size_t _NumberOfCommands = 8,
LogTypes::LOG_TYPE LogType = LogTypes::WII_IPC_HLE, enum LOG_TYPE LogType = WII_IPC_HLE,
LogTypes::LOG_LEVELS Verbosity = LogTypes::LDEBUG) enum LOG_LEVEL Verbosity = DEBUG_LEVEL)
{ {
GENERIC_LOG(LogType, Verbosity, "CommandDump of %s", GENERIC_LOG(LogType, Verbosity, "CommandDump of %s",
GetDeviceName().c_str()); GetDeviceName().c_str());
@ -175,8 +175,8 @@ protected:
} }
void DumpAsync(u32 BufferVector, u32 NumberInBuffer, u32 NumberOutBuffer, void DumpAsync(u32 BufferVector, u32 NumberInBuffer, u32 NumberOutBuffer,
LogTypes::LOG_TYPE LogType = LogTypes::WII_IPC_HLE, enum LOG_TYPE LogType = WII_IPC_HLE,
LogTypes::LOG_LEVELS Verbosity = LogTypes::LDEBUG) enum LOG_LEVEL Verbosity = DEBUG_LEVEL)
{ {
GENERIC_LOG(LogType, Verbosity, "======= DumpAsync ======"); GENERIC_LOG(LogType, Verbosity, "======= DumpAsync ======");
@ -186,7 +186,7 @@ protected:
u32 InBuffer = Memory::Read_U32(BufferOffset); BufferOffset += 4; u32 InBuffer = Memory::Read_U32(BufferOffset); BufferOffset += 4;
u32 InBufferSize = Memory::Read_U32(BufferOffset); BufferOffset += 4; u32 InBufferSize = Memory::Read_U32(BufferOffset); BufferOffset += 4;
GENERIC_LOG(LogType, LogTypes::LINFO, "%s - IOCtlV InBuffer[%i]:", INFO_LOG(LogType, "%s - IOCtlV InBuffer[%i]:",
GetDeviceName().c_str(), i); GetDeviceName().c_str(), i);
std::string Temp; std::string Temp;
@ -197,7 +197,7 @@ protected:
Temp.append(Buffer); Temp.append(Buffer);
} }
GENERIC_LOG(LogType, LogTypes::LDEBUG, " Buffer: %s", Temp.c_str()); DEBUG_LOG(LogType, " Buffer: %s", Temp.c_str());
} }
for (u32 i = 0; i < NumberOutBuffer; i++) for (u32 i = 0; i < NumberOutBuffer; i++)
@ -205,9 +205,9 @@ protected:
u32 OutBuffer = Memory::Read_U32(BufferOffset); BufferOffset += 4; u32 OutBuffer = Memory::Read_U32(BufferOffset); BufferOffset += 4;
u32 OutBufferSize = Memory::Read_U32(BufferOffset); BufferOffset += 4; u32 OutBufferSize = Memory::Read_U32(BufferOffset); BufferOffset += 4;
GENERIC_LOG(LogType, LogTypes::LINFO, "%s - IOCtlV OutBuffer[%i]:", INFO_LOG(LogType, "%s - IOCtlV OutBuffer[%i]:",
GetDeviceName().c_str(), i); GetDeviceName().c_str(), i);
GENERIC_LOG(LogType, LogTypes::LINFO, " OutBuffer: 0x%08x (0x%x):", INFO_LOG(LogType, " OutBuffer: 0x%08x (0x%x):",
OutBuffer, OutBufferSize); OutBuffer, OutBufferSize);
#if defined(MAX_LOGLEVEL) && MAX_LOGLEVEL >= INFO_LEVEL #if defined(MAX_LOGLEVEL) && MAX_LOGLEVEL >= INFO_LEVEL

6
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_es.cpp
View File

@ -218,7 +218,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
else else
{ {
Memory::Write_U32((u32)rNANDCOntent.GetContentSize(), _CommandAddress + 0x4); Memory::Write_U32((u32)rNANDCOntent.GetContentSize(), _CommandAddress + 0x4);
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLECONTENTS: Unable to open content %d", rNANDCOntent.GetContentSize()); INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLECONTENTS: Unable to open content %lu", rNANDCOntent.GetContentSize());
} }
return true; return true;
@ -399,7 +399,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
Memory::Write_U32((u32)m_TitleIDs.size(), Buffer.PayloadBuffer[0].m_Address); Memory::Write_U32((u32)m_TitleIDs.size(), Buffer.PayloadBuffer[0].m_Address);
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLECNT: Number of Titles %i", m_TitleIDs.size()); INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLECNT: Number of Titles %lu", m_TitleIDs.size());
Memory::Write_U32(0, _CommandAddress + 0x4); Memory::Write_U32(0, _CommandAddress + 0x4);
@ -751,7 +751,7 @@ bool CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
default: default:
WARN_LOG(WII_IPC_ES, "CWII_IPC_HLE_Device_es: 0x%x", Buffer.Parameter); WARN_LOG(WII_IPC_ES, "CWII_IPC_HLE_Device_es: 0x%x", Buffer.Parameter);
DumpCommands(_CommandAddress, 8, LogTypes::WII_IPC_ES); DumpCommands(_CommandAddress, 8, WII_IPC_ES);
INFO_LOG(WII_IPC_ES, "command.Parameter: 0x%08x", Buffer.Parameter); INFO_LOG(WII_IPC_ES, "command.Parameter: 0x%08x", Buffer.Parameter);
break; break;
} }

2
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_fs.cpp
View File

@ -151,7 +151,7 @@ bool CWII_IPC_HLE_Device_fs::IOCtlV(u32 _CommandAddress)
if ((CommandBuffer.InBuffer.size() == 1) && (CommandBuffer.PayloadBuffer.size() == 1)) if ((CommandBuffer.InBuffer.size() == 1) && (CommandBuffer.PayloadBuffer.size() == 1))
{ {
size_t numFile = FileSearch.GetFileNames().size(); size_t numFile = FileSearch.GetFileNames().size();
INFO_LOG(WII_IPC_FILEIO, "\t%i Files found", numFile); INFO_LOG(WII_IPC_FILEIO, "\t%lu Files found", numFile);
Memory::Write_U32((u32)numFile, CommandBuffer.PayloadBuffer[0].m_Address); Memory::Write_U32((u32)numFile, CommandBuffer.PayloadBuffer[0].m_Address);
} }

10
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_sdio_slot0.cpp
View File

@ -188,9 +188,9 @@ bool CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress)
} }
// INFO_LOG(WII_IPC_SD, "InBuffer"); // INFO_LOG(WII_IPC_SD, "InBuffer");
// DumpCommands(BufferIn, BufferInSize / 4, LogTypes::WII_IPC_SD); // DumpCommands(BufferIn, BufferInSize / 4, WII_IPC_SD);
// INFO_LOG(WII_IPC_SD, "OutBuffer"); // INFO_LOG(WII_IPC_SD, "OutBuffer");
// DumpCommands(BufferOut, BufferOutSize/4, LogTypes::WII_IPC_SD); // DumpCommands(BufferOut, BufferOutSize/4, WII_IPC_SD);
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
@ -226,7 +226,7 @@ bool CWII_IPC_HLE_Device_sdio_slot0::IOCtlV(u32 _CommandAddress)
break; break;
} }
//DumpAsync(CommandBuffer.BufferVector, CommandBuffer.NumberInBuffer, CommandBuffer.NumberPayloadBuffer, LogTypes::WII_IPC_SD); //DumpAsync(CommandBuffer.BufferVector, CommandBuffer.NumberInBuffer, CommandBuffer.NumberPayloadBuffer, WII_IPC_SD);
Memory::Write_U32(ReturnValue, _CommandAddress + 0x4); Memory::Write_U32(ReturnValue, _CommandAddress + 0x4);
@ -361,7 +361,7 @@ u32 CWII_IPC_HLE_Device_sdio_slot0::ExecuteCommand(u32 _BufferIn, u32 _BufferInS
} }
else else
{ {
ERROR_LOG(WII_IPC_SD, "Read Failed - read %x, error %i, eof? %i", ERROR_LOG(WII_IPC_SD, "Read Failed - read %lx, error %i, eof? %i",
nRead, ferror(m_Card), feof(m_Card)); nRead, ferror(m_Card), feof(m_Card));
rwFail = 1; rwFail = 1;
} }
@ -396,7 +396,7 @@ u32 CWII_IPC_HLE_Device_sdio_slot0::ExecuteCommand(u32 _BufferIn, u32 _BufferInS
size_t nWritten = fwrite(buffer, req.bsize, req.blocks, m_Card); size_t nWritten = fwrite(buffer, req.bsize, req.blocks, m_Card);
if (nWritten != req.blocks) if (nWritten != req.blocks)
{ {
ERROR_LOG(WII_IPC_SD, "Write Failed - wrote %x, error %i, eof? %i", ERROR_LOG(WII_IPC_SD, "Write Failed - wrote %lx, error %i, eof? %i",
nWritten, ferror(m_Card), feof(m_Card)); nWritten, ferror(m_Card), feof(m_Card));
rwFail = 1; rwFail = 1;
} }

4
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_stm.h
View File

@ -94,7 +94,7 @@ public:
case IOCTL_STM_VIDIMMING: // (Input: 20 bytes, Output: 20 bytes) case IOCTL_STM_VIDIMMING: // (Input: 20 bytes, Output: 20 bytes)
INFO_LOG(WII_IPC_STM, "%s - IOCtl:", GetDeviceName().c_str()); INFO_LOG(WII_IPC_STM, "%s - IOCtl:", GetDeviceName().c_str());
INFO_LOG(WII_IPC_STM, " IOCTL_STM_VIDIMMING"); INFO_LOG(WII_IPC_STM, " IOCTL_STM_VIDIMMING");
//DumpCommands(BufferIn, BufferInSize / 4, LogTypes::WII_IPC_STM); //DumpCommands(BufferIn, BufferInSize / 4, WII_IPC_STM);
//Memory::Write_U32(1, BufferOut); //Memory::Write_U32(1, BufferOut);
//ReturnValue = 1; //ReturnValue = 1;
break; break;
@ -182,7 +182,7 @@ public:
DEBUG_LOG(WII_IPC_STM, "BufferOut: 0x%08x", BufferOut); DEBUG_LOG(WII_IPC_STM, "BufferOut: 0x%08x", BufferOut);
DEBUG_LOG(WII_IPC_STM, "BufferOutSize: 0x%08x", BufferOutSize); DEBUG_LOG(WII_IPC_STM, "BufferOutSize: 0x%08x", BufferOutSize);
DumpCommands(BufferIn, BufferInSize/4, LogTypes::WII_IPC_STM); DumpCommands(BufferIn, BufferInSize/4, WII_IPC_STM);
} }
break; break;

16
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_usb.cpp
View File

@ -300,7 +300,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendACLPacket(u16 _ConnectionHandle, u
} }
else else
{ {
DEBUG_LOG(WII_IPC_WIIMOTE, "ACL endpoint not currently valid, queueing(%i)...", m_ACLQ.size()); DEBUG_LOG(WII_IPC_WIIMOTE, "ACL endpoint not currently valid, queueing(%lu)...", m_ACLQ.size());
m_ACLQ.push(ACLQ(_pData, _Size, _ConnectionHandle)); m_ACLQ.push(ACLQ(_pData, _Size, _ConnectionHandle));
} }
} }
@ -330,10 +330,10 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::AddEventToQueue(const SQueuedEvent& _e
} }
else // push new one, pop oldest else // push new one, pop oldest
{ {
DEBUG_LOG(WII_IPC_WIIMOTE, "HCI endpoint not currently valid, queueing(%i)...", m_EventQueue.size()); DEBUG_LOG(WII_IPC_WIIMOTE, "HCI endpoint not currently valid, queueing(%lu)...", m_EventQueue.size());
m_EventQueue.push(_event); m_EventQueue.push(_event);
const SQueuedEvent& event = m_EventQueue.front(); const SQueuedEvent& event = m_EventQueue.front();
DEBUG_LOG(WII_IPC_WIIMOTE, "HCI event %x being written from queue(%i) to %08x...", DEBUG_LOG(WII_IPC_WIIMOTE, "HCI event %x being written from queue(%lu) to %08x...",
((hci_event_hdr_t*)event.m_buffer)->event, m_EventQueue.size()-1, m_HCIEndpoint.m_address); ((hci_event_hdr_t*)event.m_buffer)->event, m_EventQueue.size()-1, m_HCIEndpoint.m_address);
m_HCIEndpoint.FillBuffer(event.m_buffer, event.m_size); m_HCIEndpoint.FillBuffer(event.m_buffer, event.m_size);
m_HCIEndpoint.SetRetVal(event.m_size); m_HCIEndpoint.SetRetVal(event.m_size);
@ -345,7 +345,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::AddEventToQueue(const SQueuedEvent& _e
} }
else else
{ {
DEBUG_LOG(WII_IPC_WIIMOTE, "HCI endpoint not currently valid, queueing(%i)...", m_EventQueue.size()); DEBUG_LOG(WII_IPC_WIIMOTE, "HCI endpoint not currently valid, queueing(%lu)...", m_EventQueue.size());
m_EventQueue.push(_event); m_EventQueue.push(_event);
} }
} }
@ -357,7 +357,7 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
{ {
// an endpoint has become available, and we have a stored response. // an endpoint has become available, and we have a stored response.
const SQueuedEvent& event = m_EventQueue.front(); const SQueuedEvent& event = m_EventQueue.front();
DEBUG_LOG(WII_IPC_WIIMOTE, "HCI event %x being written from queue(%i) to %08x...", DEBUG_LOG(WII_IPC_WIIMOTE, "HCI event %x being written from queue(%lu) to %08x...",
((hci_event_hdr_t*)event.m_buffer)->event, m_EventQueue.size()-1, m_HCIEndpoint.m_address); ((hci_event_hdr_t*)event.m_buffer)->event, m_EventQueue.size()-1, m_HCIEndpoint.m_address);
m_HCIEndpoint.FillBuffer(event.m_buffer, event.m_size); m_HCIEndpoint.FillBuffer(event.m_buffer, event.m_size);
m_HCIEndpoint.SetRetVal(event.m_size); m_HCIEndpoint.SetRetVal(event.m_size);
@ -373,7 +373,7 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
if (!m_ACLQ.empty() && m_ACLEndpoint.IsValid() && m_EventQueue.empty()) if (!m_ACLQ.empty() && m_ACLEndpoint.IsValid() && m_EventQueue.empty())
{ {
const ACLQ& acl_data = m_ACLQ.front(); const ACLQ& acl_data = m_ACLQ.front();
DEBUG_LOG(WII_IPC_WIIMOTE, "ACL packet being written from queue(%i) to %08x", DEBUG_LOG(WII_IPC_WIIMOTE, "ACL packet being written from queue(%lu) to %08x",
m_ACLQ.size()-1, m_ACLEndpoint.m_address); m_ACLQ.size()-1, m_ACLEndpoint.m_address);
hci_acldata_hdr_t* pHeader = (hci_acldata_hdr_t*)Memory::GetPointer(m_ACLEndpoint.m_buffer); hci_acldata_hdr_t* pHeader = (hci_acldata_hdr_t*)Memory::GetPointer(m_ACLEndpoint.m_buffer);
@ -1728,7 +1728,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4F(u8* _Input,
INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4F: (callstack WUDiRemovePatch)"); INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4F: (callstack WUDiRemovePatch)");
INFO_LOG(WII_IPC_WIIMOTE, "input (size 0x%x):", _Size); INFO_LOG(WII_IPC_WIIMOTE, "input (size 0x%x):", _Size);
Dolphin_Debugger::PrintDataBuffer(LogTypes::WII_IPC_WIIMOTE, _Input, _Size, "Data: "); Dolphin_Debugger::PrintDataBuffer(WII_IPC_WIIMOTE, _Input, _Size, "Data: ");
SendEventCommandComplete(0xFC4F, &Reply, sizeof(hci_status_rp)); SendEventCommandComplete(0xFC4F, &Reply, sizeof(hci_status_rp));
} }
@ -1740,7 +1740,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4C(u8* _Input,
INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4C:"); INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4C:");
INFO_LOG(WII_IPC_WIIMOTE, "input (size 0x%x):", _Size); INFO_LOG(WII_IPC_WIIMOTE, "input (size 0x%x):", _Size);
Dolphin_Debugger::PrintDataBuffer(LogTypes::WII_IPC_WIIMOTE, _Input, _Size, "Data: "); Dolphin_Debugger::PrintDataBuffer(WII_IPC_WIIMOTE, _Input, _Size, "Data: ");
SendEventCommandComplete(0xFC4C, &Reply, sizeof(hci_status_rp)); SendEventCommandComplete(0xFC4C, &Reply, sizeof(hci_status_rp));
} }

2
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_usb_kbd.cpp
View File

@ -64,7 +64,7 @@ bool CWII_IPC_HLE_Device_usb_kbd::Write(u32 _CommandAddress)
{ {
INFO_LOG(WII_IPC_STM, "Ignoring write to CWII_IPC_HLE_Device_usb_kbd"); INFO_LOG(WII_IPC_STM, "Ignoring write to CWII_IPC_HLE_Device_usb_kbd");
#if defined(_DEBUG) || defined(DEBUGFAST) #if defined(_DEBUG) || defined(DEBUGFAST)
DumpCommands(_CommandAddress, 10, LogTypes::WII_IPC_STM, LogTypes::LDEBUG); DumpCommands(_CommandAddress, 10, WII_IPC_STM, DEBUG_LEVEL);
#endif #endif
return true; return true;
} }

6
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.cpp
View File

@ -756,12 +756,12 @@ void CWII_IPC_HLE_WiiMote::SDPSendServiceAttributeResponse(u16 cid, u16 Transact
pHeader->length = (u16)(Offset - sizeof(l2cap_hdr_t)); pHeader->length = (u16)(Offset - sizeof(l2cap_hdr_t));
m_pHost->SendACLPacket(GetConnectionHandle(), DataFrame, pHeader->length + sizeof(l2cap_hdr_t)); m_pHost->SendACLPacket(GetConnectionHandle(), DataFrame, pHeader->length + sizeof(l2cap_hdr_t));
// Debugger::PrintDataBuffer(LogTypes::WIIMOTE, DataFrame, pHeader->length + sizeof(l2cap_hdr_t), "test response: "); // Debugger::PrintDataBuffer(WIIMOTE, DataFrame, pHeader->length + sizeof(l2cap_hdr_t), "test response: ");
} }
void CWII_IPC_HLE_WiiMote::HandleSDP(u16 cid, u8* _pData, u32 _Size) void CWII_IPC_HLE_WiiMote::HandleSDP(u16 cid, u8* _pData, u32 _Size)
{ {
// Debugger::PrintDataBuffer(LogTypes::WIIMOTE, _pData, _Size, "HandleSDP: "); // Debugger::PrintDataBuffer(WIIMOTE, _pData, _Size, "HandleSDP: ");
CBigEndianBuffer buffer(_pData); CBigEndianBuffer buffer(_pData);
@ -847,7 +847,7 @@ void CWII_IPC_HLE_WiiMote::SendCommandToACL(u8 _Ident, u8 _Code, u8 _CommandLeng
// send .... // send ....
m_pHost->SendACLPacket(GetConnectionHandle(), DataFrame, pHeader->length + sizeof(l2cap_hdr_t)); m_pHost->SendACLPacket(GetConnectionHandle(), DataFrame, pHeader->length + sizeof(l2cap_hdr_t));
//Debugger::PrintDataBuffer(LogTypes::WIIMOTE, DataFrame, pHeader->length + sizeof(l2cap_hdr_t), "m_pHost->SendACLPacket: "); //Debugger::PrintDataBuffer(WIIMOTE, DataFrame, pHeader->length + sizeof(l2cap_hdr_t), "m_pHost->SendACLPacket: ");
} }
void CWII_IPC_HLE_WiiMote::ReceiveL2capData(u16 scid, const void* _pData, u32 _Size) void CWII_IPC_HLE_WiiMote::ReceiveL2capData(u16 scid, const void* _pData, u32 _Size)

2
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_Branch.cpp
View File

@ -127,7 +127,7 @@ void Interpreter::rfi(UGeckoInstruction _inst)
void Interpreter::rfid(UGeckoInstruction _inst) void Interpreter::rfid(UGeckoInstruction _inst)
{ {
_dbg_assert_msg_(POWERPC,0,"Instruction unimplemented (does this instruction even exist?)","rfid"); _dbg_assert_msg_(POWERPC, 0, "rfid instruction unimplemented (does this instruction even exist?)");
m_EndBlock = true; m_EndBlock = true;
} }

4
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_LoadStorePaired.cpp
View File

@ -109,7 +109,7 @@ void Interpreter::Helper_Quantize(const u32 _Addr, const double _fValue,
break; break;
default: default:
_dbg_assert_msg_(POWERPC,0,"PS dequantize","Unknown type to read"); _dbg_assert_msg_(POWERPC, 0, "PS dequantize - unknown type to read");
break; break;
} }
} }
@ -146,7 +146,7 @@ float Interpreter::Helper_Dequantize(const u32 _Addr, const EQuantizeType _quant
break; break;
default: default:
_dbg_assert_msg_(POWERPC,0,"PS dequantize","Unknown type to read"); _dbg_assert_msg_(POWERPC, 0, "PS dequantize - unknown type to read");
fResult = 0; fResult = 0;
break; break;
} }

4
Source/Core/Core/Src/PowerPC/Jit64IL/IR.cpp
View File

@ -1325,7 +1325,7 @@ void IRBuilder::WriteToFile(u64 codeHash) {
if (isImm(*inst)) { if (isImm(*inst)) {
fprintf(file, " 0x%08x", GetImmValue(inst)); fprintf(file, " 0x%08x", GetImmValue(inst));
} else { } else {
fprintf(file, " %10u", i - (I - inst)); fprintf(file, " %10u", i - (unsigned int)(I - inst));
} }
} }
@ -1335,7 +1335,7 @@ void IRBuilder::WriteToFile(u64 codeHash) {
if (isImm(*inst)) { if (isImm(*inst)) {
fprintf(file, " 0x%08x", GetImmValue(inst)); fprintf(file, " 0x%08x", GetImmValue(inst));
} else { } else {
fprintf(file, " %10u", i - (I - inst)); fprintf(file, " %10u", i - (unsigned int)(I - inst));
} }
} }

9
Source/Core/Core/Src/PowerPC/PPCAnalyst.cpp
View File

@ -700,7 +700,7 @@ void FindFunctions(u32 startAddr, u32 endAddr, PPCSymbolDB *func_db)
{ {
if (iter->second.address == 4) if (iter->second.address == 4)
{ {
WARN_LOG(HLE, "weird function"); WARN_LOG(OSHLE, "weird function");
continue; continue;
} }
AnalyzeFunction2(&(iter->second)); AnalyzeFunction2(&(iter->second));
@ -750,8 +750,11 @@ void FindFunctions(u32 startAddr, u32 endAddr, PPCSymbolDB *func_db)
else else
unniceSize /= numUnNice; unniceSize /= numUnNice;
INFO_LOG(HLE, "Functions analyzed. %i leafs, %i nice, %i unnice. %i timer, %i rfi. %i are branchless leafs.",numLeafs,numNice,numUnNice,numTimer,numRFI,numStraightLeaf); INFO_LOG(OSHLE, "Functions analyzed. %i leafs, %i nice, %i unnice."
INFO_LOG(HLE, "Average size: %i (leaf), %i (nice), %i(unnice)", leafSize, niceSize, unniceSize); "%i timer, %i rfi. %i are branchless leafs.", numLeafs,
numNice, numUnNice, numTimer, numRFI, numStraightLeaf);
INFO_LOG(OSHLE, "Average size: %i (leaf), %i (nice), %i(unnice)",
leafSize, niceSize, unniceSize);
} }
} // namespace } // namespace

6
Source/Core/Core/Src/PowerPC/PPCSymbolDB.cpp
View File

@ -58,7 +58,7 @@ Symbol *PPCSymbolDB::AddFunction(u32 startAddr)
u32 targetEnd = PPCAnalyst::AnalyzeFunction(startAddr, tempFunc); u32 targetEnd = PPCAnalyst::AnalyzeFunction(startAddr, tempFunc);
if (targetEnd == 0) if (targetEnd == 0)
return 0; //found a dud :( return 0; //found a dud :(
//LOG(HLE,"Symbol found at %08x",startAddr); //LOG(OSHLE, "Symbol found at %08x", startAddr);
functions[startAddr] = tempFunc; functions[startAddr] = tempFunc;
tempFunc.type = Symbol::SYMBOL_FUNCTION; tempFunc.type = Symbol::SYMBOL_FUNCTION;
checksumToFunction[tempFunc.hash] = &(functions[startAddr]); checksumToFunction[tempFunc.hash] = &(functions[startAddr]);
@ -144,7 +144,7 @@ void PPCSymbolDB::FillInCallers()
} }
else else
{ {
//LOG(HLE,"FillInCallers tries to fill data in an unknown function 0x%08x.", FunctionAddress); //LOG(OSHLE, "FillInCallers tries to fill data in an unknown function 0x%08x.", FunctionAddress);
// TODO - analyze the function instead. // TODO - analyze the function instead.
} }
} }
@ -157,7 +157,7 @@ void PPCSymbolDB::PrintCalls(u32 funcAddr) const
if (iter != functions.end()) if (iter != functions.end())
{ {
const Symbol &f = iter->second; const Symbol &f = iter->second;
INFO_LOG(HLE, "The function %s at %08x calls:", f.name.c_str(), f.address); INFO_LOG(OSHLE, "The function %s at %08x calls:", f.name.c_str(), f.address);
for (std::vector<SCall>::const_iterator fiter = f.calls.begin(); fiter!=f.calls.end(); ++fiter) for (std::vector<SCall>::const_iterator fiter = f.calls.begin(); fiter!=f.calls.end(); ++fiter)
{ {
XFuncMap::const_iterator n = functions.find(fiter->function); XFuncMap::const_iterator n = functions.find(fiter->function);

2
Source/Core/Core/Src/PowerPC/PowerPC.cpp
View File

@ -381,7 +381,7 @@ void CheckExceptions()
INFO_LOG(POWERPC, "EXCEPTION_EXTERNAL_INT"); INFO_LOG(POWERPC, "EXCEPTION_EXTERNAL_INT");
Common::AtomicAnd(ppcState.Exceptions, ~EXCEPTION_EXTERNAL_INT); Common::AtomicAnd(ppcState.Exceptions, ~EXCEPTION_EXTERNAL_INT);
_dbg_assert_msg_(POWERPC, (SRR1 & 0x02) != 0, "GEKKO", "EXTERNAL_INT unrecoverable???"); _dbg_assert_msg_(POWERPC, (SRR1 & 0x02) != 0, "EXTERNAL_INT unrecoverable???");
} }
else if (exceptions & EXCEPTION_DECREMENTER) else if (exceptions & EXCEPTION_DECREMENTER)
{ {

12
Source/Core/Core/Src/PowerPC/SignatureDB.cpp
View File

@ -63,7 +63,7 @@ bool SignatureDB::Save(const char *filename)
FILE *f = fopen(filename,"wb"); FILE *f = fopen(filename,"wb");
if (!f) if (!f)
{ {
ERROR_LOG(HLE, "Database save failed"); ERROR_LOG(OSHLE, "Database save failed");
return false; return false;
} }
int fcount = (int)database.size(); int fcount = (int)database.size();
@ -78,7 +78,7 @@ bool SignatureDB::Save(const char *filename)
fwrite(&temp, sizeof(temp), 1, f); fwrite(&temp, sizeof(temp), 1, f);
} }
fclose(f); fclose(f);
INFO_LOG(HLE,"Database save successful"); INFO_LOG(OSHLE, "Database save successful");
return true; return true;
} }
@ -101,9 +101,9 @@ void SignatureDB::List()
{ {
for (FuncDB::iterator iter = database.begin(); iter != database.end(); ++iter) for (FuncDB::iterator iter = database.begin(); iter != database.end(); ++iter)
{ {
INFO_LOG(HLE,"%s : %i bytes, hash = %08x",iter->second.name.c_str(), iter->second.size, iter->first); INFO_LOG(OSHLE, "%s : %i bytes, hash = %08x", iter->second.name.c_str(), iter->second.size, iter->first);
} }
INFO_LOG(HLE, "%i functions known in current database.", database.size()); INFO_LOG(OSHLE, "%lu functions known in current database.", database.size());
} }
void SignatureDB::Clear() void SignatureDB::Clear()
@ -123,12 +123,12 @@ void SignatureDB::Apply(PPCSymbolDB *symbol_db)
if (iter->second.size == (unsigned int)function->size) if (iter->second.size == (unsigned int)function->size)
{ {
function->name = iter->second.name; function->name = iter->second.name;
INFO_LOG(HLE, "Found %s at %08x (size: %08x)!", iter->second.name.c_str(), function->address, function->size); INFO_LOG(OSHLE, "Found %s at %08x (size: %08x)!", iter->second.name.c_str(), function->address, function->size);
} }
else else
{ {
function->name = iter->second.name; function->name = iter->second.name;
ERROR_LOG(HLE, "Wrong sizzze! Found %s at %08x (size: %08x instead of %08x)!", iter->second.name.c_str(), function->address, function->size, iter->second.size); ERROR_LOG(OSHLE, "Wrong sizzze! Found %s at %08x (size: %08x instead of %08x)!", iter->second.name.c_str(), function->address, function->size, iter->second.size);
} }
} }
} }

4
Source/Core/Core/Src/State.cpp
View File

@ -357,7 +357,7 @@ void LoadStateCallback(u64 userdata, int cyclesLate)
buffer = new u8[sz]; buffer = new u8[sz];
int x; int x;
if ((x = (int)fread(buffer, 1, sz, f)) != (int)sz) if ((x = (int)fread(buffer, 1, sz, f)) != (int)sz)
PanicAlert("wtf? %d %d", x, sz); PanicAlert("wtf? %d %lu", x, sz);
} }
fclose(f); fclose(f);
@ -457,7 +457,7 @@ void VerifyStateCallback(u64 userdata, int cyclesLate)
buffer = new u8[sz]; buffer = new u8[sz];
int x; int x;
if ((x = (int)fread(buffer, 1, sz, f)) != (int)sz) if ((x = (int)fread(buffer, 1, sz, f)) != (int)sz)
PanicAlert("wtf? %d %d", x, sz); PanicAlert("wtf? %d %lu", x, sz);
} }
fclose(f); fclose(f);

2
Source/Core/DiscIO/Src/BannerLoaderGC.cpp
View File

@ -44,7 +44,7 @@ CBannerLoaderGC::CBannerLoaderGC(DiscIO::IFileSystem& _rFileSystem)
else m_IsValid = true; else m_IsValid = true;
} }
} }
else WARN_LOG(DISCIO, "Invalid opening.bnr size: %0x", FileSize); else WARN_LOG(DISCIO, "Invalid opening.bnr size: %0lx", FileSize);
} }

4
Source/Core/DiscIO/Src/FileMonitor.cpp
View File

@ -98,7 +98,7 @@ void ReadGC(std::string FileName)
void CheckFile(std::string File, u64 Size) void CheckFile(std::string File, u64 Size)
{ {
// Don't do anything if the log is unselected // Don't do anything if the log is unselected
if (!LogManager::GetInstance()->isEnable(LogTypes::FILEMON)) return; if (!LogManager::GetInstance()->isEnable(FILEMON)) return;
// Do nothing if we found the same file again // Do nothing if we found the same file again
if (CurrentFile == File) return; if (CurrentFile == File) return;
@ -124,7 +124,7 @@ void FindFilename(u64 offset)
// Don't do anything if a game is not running // Don't do anything if a game is not running
if (Core::GetState() != Core::CORE_RUN) return; if (Core::GetState() != Core::CORE_RUN) return;
// Or if the log is unselected // Or if the log is unselected
if (!LogManager::GetInstance()->isEnable(LogTypes::FILEMON)) return; if (!LogManager::GetInstance()->isEnable(FILEMON)) return;
if (!FileAccess) return; if (!FileAccess) return;
if (!pFileSystem || ISOFile != SConfig::GetInstance().m_LastFilename) if (!pFileSystem || ISOFile != SConfig::GetInstance().m_LastFilename)

2
Source/Core/DolphinWX/Src/GeckoCodeDiag.cpp
View File

@ -240,7 +240,7 @@ void CodeConfigPanel::DownloadCodes(wxCommandEvent&)
if (gcodes.size()) if (gcodes.size())
{ {
PanicAlert("Downloaded %i codes.", gcodes.size()); PanicAlert("Downloaded %lu codes.", gcodes.size());
// append the codes to the code list // append the codes to the code list
std::vector<GeckoCode>::const_iterator std::vector<GeckoCode>::const_iterator

72
Source/Core/DolphinWX/Src/LogWindow.cpp
View File

@ -55,8 +55,8 @@ CLogWindow::CLogWindow(CFrame *parent, wxWindowID id, const wxPoint& pos,
#endif #endif
{ {
m_LogManager = LogManager::GetInstance(); m_LogManager = LogManager::GetInstance();
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) for (int i = 0; i < NUMBER_OF_LOGS; ++i)
m_LogManager->addListener((LogTypes::LOG_TYPE)i, this); m_LogManager->addListener(i, this);
m_fileLog = m_LogManager->getFileListener(); m_fileLog = m_LogManager->getFileListener();
m_console = m_LogManager->getConsoleListener(); m_console = m_LogManager->getConsoleListener();
@ -151,9 +151,9 @@ void CLogWindow::CreateGUIControls()
CLogWindow::~CLogWindow() CLogWindow::~CLogWindow()
{ {
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) for (int i = 0; i < NUMBER_OF_LOGS; ++i)
{ {
m_LogManager->removeListener((LogTypes::LOG_TYPE)i, this); m_LogManager->removeListener(i, this);
} }
m_LogTimer->Stop(); m_LogTimer->Stop();
delete m_LogTimer; delete m_LogTimer;
@ -193,8 +193,8 @@ void CLogWindow::SaveSettings()
ini.Set("Options", "WriteToFile", m_writeFile); ini.Set("Options", "WriteToFile", m_writeFile);
ini.Set("Options", "WriteToConsole", m_writeConsole); ini.Set("Options", "WriteToConsole", m_writeConsole);
ini.Set("Options", "WriteToWindow", m_writeWindow); ini.Set("Options", "WriteToWindow", m_writeWindow);
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) for (int i = 0; i < NUMBER_OF_LOGS; ++i)
ini.Set("Logs", m_LogManager->getShortName((LogTypes::LOG_TYPE)i), m_checks->IsChecked(i)); ini.Set("Logs", m_LogManager->getShortName(i), m_checks->IsChecked(i));
ini.Save(File::GetUserPath(F_LOGGERCONFIG_IDX)); ini.Save(File::GetUserPath(F_LOGGERCONFIG_IDX));
} }
@ -222,26 +222,26 @@ void CLogWindow::LoadSettings()
m_writeConsoleCB->SetValue(m_writeConsole); m_writeConsoleCB->SetValue(m_writeConsole);
ini.Get("Options", "WriteToWindow", &m_writeWindow, true); ini.Get("Options", "WriteToWindow", &m_writeWindow, true);
m_writeWindowCB->SetValue(m_writeWindow); m_writeWindowCB->SetValue(m_writeWindow);
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) for (int i = 0; i < NUMBER_OF_LOGS; ++i)
{ {
bool enable; bool enable;
ini.Get("Logs", m_LogManager->getShortName((LogTypes::LOG_TYPE)i), &enable, true); ini.Get("Logs", m_LogManager->getShortName(i), &enable, true);
if (m_writeWindow && enable) if (m_writeWindow && enable)
m_LogManager->addListener((LogTypes::LOG_TYPE)i, this); m_LogManager->addListener(i, this);
else else
m_LogManager->removeListener((LogTypes::LOG_TYPE)i, this); m_LogManager->removeListener(i, this);
if (m_writeFile && enable) if (m_writeFile && enable)
m_LogManager->addListener((LogTypes::LOG_TYPE)i, m_fileLog); m_LogManager->addListener(i, m_fileLog);
else else
m_LogManager->removeListener((LogTypes::LOG_TYPE)i, m_fileLog); m_LogManager->removeListener(i, m_fileLog);
if (m_writeConsole && enable) if (m_writeConsole && enable)
m_LogManager->addListener((LogTypes::LOG_TYPE)i, m_console); m_LogManager->addListener(i, m_console);
else else
m_LogManager->removeListener((LogTypes::LOG_TYPE)i, m_console); m_LogManager->removeListener(i, m_console);
m_LogManager->setLogLevel((LogTypes::LOG_TYPE)i, (LogTypes::LOG_LEVELS)(verbosity)); m_LogManager->setLogLevel(i, (enum LOG_LEVEL)verbosity);
} }
UpdateChecks(); UpdateChecks();
} }
@ -270,7 +270,7 @@ void CLogWindow::OnClear(wxCommandEvent& WXUNUSED (event))
void CLogWindow::OnToggleAll(wxCommandEvent& WXUNUSED (event)) void CLogWindow::OnToggleAll(wxCommandEvent& WXUNUSED (event))
{ {
static bool enableAll = false; static bool enableAll = false;
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) for (int i = 0; i < NUMBER_OF_LOGS; ++i)
{ {
ToggleLog(i, enableAll); ToggleLog(i, enableAll);
} }
@ -289,20 +289,20 @@ void CLogWindow::UpdateChecks()
// if you don't do it (at least the win version) // if you don't do it (at least the win version)
m_checks->Freeze(); m_checks->Freeze();
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; i++) for (int i = 0; i < NUMBER_OF_LOGS; i++)
{ {
m_checks->Append(wxString::FromAscii(m_LogManager->getFullName( (LogTypes::LOG_TYPE)i ))); m_checks->Append(wxString::FromAscii(m_LogManager->getFullName(i)));
} }
m_checks->Thaw(); m_checks->Thaw();
} }
m_checks->Freeze(); m_checks->Freeze();
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; i++) for (int i = 0; i < NUMBER_OF_LOGS; i++)
{ {
m_checks->Check(i, m_checks->Check(i,
m_LogManager->isListener((LogTypes::LOG_TYPE)i, this) || m_LogManager->isListener(i, this) ||
m_LogManager->isListener((LogTypes::LOG_TYPE)i, m_console) || m_LogManager->isListener(i, m_console) ||
m_LogManager->isListener((LogTypes::LOG_TYPE)i, m_fileLog)); m_LogManager->isListener(i, m_fileLog));
} }
m_checks->Thaw(); m_checks->Thaw();
} }
@ -324,7 +324,7 @@ void CLogWindow::PopulateRight()
wxTextCtrl* CLogWindow::CreateTextCtrl(wxPanel* parent, wxWindowID id, long Style) wxTextCtrl* CLogWindow::CreateTextCtrl(wxPanel* parent, wxWindowID id, long Style)
{ {
wxTextCtrl* TC = new wxTextCtrl(parent, id, wxEmptyString, wxDefaultPosition, wxDefaultSize, Style); wxTextCtrl* TC = new wxTextCtrl(parent, id, wxEmptyString, wxDefaultPosition, wxDefaultSize, Style);
TC->SetBackgroundColour(*wxBLACK); TC->SetBackgroundColour(*wxLIGHT_GREY);
if (m_FontChoice) if (m_FontChoice)
{ {
if (m_FontChoice->GetSelection() < (int)LogFont.size()) if (m_FontChoice->GetSelection() < (int)LogFont.size())
@ -344,9 +344,9 @@ void CLogWindow::OnOptionsCheck(wxCommandEvent& event)
{ {
// get selection // get selection
int v = m_verbosity->GetSelection() + 1; int v = m_verbosity->GetSelection() + 1;
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; i++) for (int i = 0; i < NUMBER_OF_LOGS; i++)
{ {
m_LogManager->setLogLevel((LogTypes::LOG_TYPE)i, (LogTypes::LOG_LEVELS)v); m_LogManager->setLogLevel(i, (enum LOG_LEVEL)v);
} }
} }
break; break;
@ -385,43 +385,43 @@ void CLogWindow::OnOptionsCheck(wxCommandEvent& event)
break; break;
case IDM_WRITEFILE: case IDM_WRITEFILE:
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) for (int i = 0; i < NUMBER_OF_LOGS; ++i)
{ {
m_writeFile = event.IsChecked(); m_writeFile = event.IsChecked();
if (m_checks->IsChecked(i)) if (m_checks->IsChecked(i))
{ {
if (m_writeFile) if (m_writeFile)
m_LogManager->addListener((LogTypes::LOG_TYPE)i, m_fileLog); m_LogManager->addListener(i, m_fileLog);
else else
m_LogManager->removeListener((LogTypes::LOG_TYPE)i, m_fileLog); m_LogManager->removeListener(i, m_fileLog);
} }
} }
break; break;
case IDM_WRITEWINDOW: case IDM_WRITEWINDOW:
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) for (int i = 0; i < NUMBER_OF_LOGS; ++i)
{ {
m_writeWindow = event.IsChecked(); m_writeWindow = event.IsChecked();
if (m_checks->IsChecked(i)) if (m_checks->IsChecked(i))
{ {
if (m_writeWindow) if (m_writeWindow)
m_LogManager->addListener((LogTypes::LOG_TYPE)i, this); m_LogManager->addListener(i, this);
else else
m_LogManager->removeListener((LogTypes::LOG_TYPE)i, this); m_LogManager->removeListener(i, this);
} }
} }
break; break;
case IDM_WRITECONSOLE: case IDM_WRITECONSOLE:
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) for (int i = 0; i < NUMBER_OF_LOGS; ++i)
{ {
m_writeConsole = event.IsChecked(); m_writeConsole = event.IsChecked();
if (m_checks->IsChecked(i)) if (m_checks->IsChecked(i))
{ {
if (m_writeConsole) if (m_writeConsole)
m_LogManager->addListener((LogTypes::LOG_TYPE)i, m_console); m_LogManager->addListener(i, m_console);
else else
m_LogManager->removeListener((LogTypes::LOG_TYPE)i, m_console); m_LogManager->removeListener(i, m_console);
} }
} }
break; break;
@ -440,7 +440,7 @@ void CLogWindow::OnLogCheck(wxCommandEvent& event)
void CLogWindow::ToggleLog(int _logType, bool enable) void CLogWindow::ToggleLog(int _logType, bool enable)
{ {
LogTypes::LOG_TYPE logType = (LogTypes::LOG_TYPE)_logType; enum LOG_TYPE logType = (enum LOG_TYPE)_logType;
m_checks->Check(_logType, enable); m_checks->Check(_logType, enable);
@ -528,7 +528,7 @@ void CLogWindow::UpdateLog()
m_LogTimer->Start(UPDATETIME); m_LogTimer->Start(UPDATETIME);
} }
void CLogWindow::Log(LogTypes::LOG_LEVELS level, const char *text) void CLogWindow::Log(enum LOG_LEVEL level, const char *text)
{ {
m_LogSection.Enter(); m_LogSection.Enter();
if (msgQueue.size() >= 100) if (msgQueue.size() >= 100)

2
Source/Core/DolphinWX/Src/LogWindow.h
View File

@ -60,7 +60,7 @@ public:
void SaveSettings(); void SaveSettings();
void LoadSettings(); void LoadSettings();
void Log(LogTypes::LOG_LEVELS, const char *text); void Log(enum LOG_LEVEL level, const char *text);
int x, y, winpos; int x, y, winpos;

2
Source/Core/VideoCommon/Src/Fifo.cpp
View File

@ -197,7 +197,7 @@ void Fifo_EnterLoop(const SVideoInitialize &video_initialize)
} }
_assert_msg_(COMMANDPROCESSOR, _fifo.CPReadWriteDistance - distToSend >= 0 , _assert_msg_(COMMANDPROCESSOR, (s32)_fifo.CPReadWriteDistance - distToSend >= 0 ,
"Negative fifo.CPReadWriteDistance = %i in FIFO Loop !\nThat can produce inestabilty in the game. Please report it.", _fifo.CPReadWriteDistance - distToSend); "Negative fifo.CPReadWriteDistance = %i in FIFO Loop !\nThat can produce inestabilty in the game. Please report it.", _fifo.CPReadWriteDistance - distToSend);
Common::AtomicStore(_fifo.CPReadPointer, readPtr); Common::AtomicStore(_fifo.CPReadPointer, readPtr);

4
Source/Core/VideoCommon/Src/PixelShaderGen.cpp
View File

@ -58,7 +58,7 @@ void GetPixelShaderId(PIXELSHADERUID *uid, DSTALPHA_MODE dstAlphaMode)
for (int i = 0; i < 8; i += 2) for (int i = 0; i < 8; i += 2)
((u8*)&uid->values[1])[i / 2] = (bpmem.tevksel[i].hex & 0xf) | ((bpmem.tevksel[i + 1].hex & 0xf) << 4); ((u8*)&uid->values[1])[i / 2] = (bpmem.tevksel[i].hex & 0xf) | ((bpmem.tevksel[i + 1].hex & 0xf) << 4);
u32 enableZTexture = (bpmem.ztex2.op != ZTEXTURE_DISABLE && !bpmem.zcontrol.zcomploc || g_ActiveConfig.bEnablePerPixelDepth)? 1 : 0; u32 enableZTexture = (bpmem.ztex2.op != (ZTEXTURE_DISABLE && !bpmem.zcontrol.zcomploc) || g_ActiveConfig.bEnablePerPixelDepth)? 1 : 0;
uid->values[2] = (u32)bpmem.fog.c_proj_fsel.fsel | uid->values[2] = (u32)bpmem.fog.c_proj_fsel.fsel |
((u32)bpmem.fog.c_proj_fsel.proj << 3) | ((u32)bpmem.fog.c_proj_fsel.proj << 3) |
@ -466,7 +466,7 @@ const char *GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType
nIndirectStagesUsed |= 1 << bpmem.tevind[i].bt; nIndirectStagesUsed |= 1 << bpmem.tevind[i].bt;
} }
} }
DepthTextureEnable = bpmem.ztex2.op != ZTEXTURE_DISABLE && !bpmem.zcontrol.zcomploc || g_ActiveConfig.bEnablePerPixelDepth ; DepthTextureEnable = bpmem.ztex2.op != (ZTEXTURE_DISABLE && !bpmem.zcontrol.zcomploc) || g_ActiveConfig.bEnablePerPixelDepth ;
// Declare samplers // Declare samplers
if(ApiType != API_D3D11) if(ApiType != API_D3D11)