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

Revamped some console log stuff. 

* Added more colors!
 * VM's EE/IOP logs (the ones that come from the emulated games themselves) are colored accordingly: EE are faint cyan, IOP are faint yellow.  They're intentionally "hard to read" because 99% of the time they're meaningless trivia (but still cool since it's what the actual devs would have used for developing the games!).

Dev Notes:
 * Removed Console.Status (specify blue/green colors manually if you want them).
 * Renamed Console.Notice to Console.Warning.
 * I changed the overloads so that both char* and wxChar* versions work like printf now (no need to use wxsFormat when working with unicode strings).  I also removed wxString& versions of the overloads.  This should (I hope) also be an easier port to wx2.9 or 3.0, when that time comes.
 * Default log color is now black instead of gray; typically you'll want to manually specify Color_Gray when doing high volume logging (like the EErec's block tracking in debug builds).

git-svn-id: http://pcsx2.googlecode.com/svn/trunk@2091 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
Jake.Stine 2009-10-29 13:32:40 +00:00
parent fdde56115c
commit 7d458d583c
79 changed files with 571 additions and 435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
common/include/Utilities/Console.h
View File

@ -23,13 +23,27 @@ enum ConsoleColors
Color_Current = -1,
Color_Black = 0,
Color_Red,
Color_Green,
Color_Yellow,
Color_Red,
Color_Blue,
Color_Magenta,
Color_Cyan,
Color_White,
Color_Orange,
Color_Gray,
Color_Cyan, // faint visibility, intended for logging PS2/IOP output
Color_Yellow, // faint visibility, intended for logging PS2/IOP output
Color_White, // faint visibility, intended for logging PS2/IOP output
// Strong text *may* result in mis-aligned text in the console, depending on the
// font and the platform, so use these with caution.
Color_StrongBlack,
Color_StrongRed, // intended for errors
Color_StrongGreen, // intended for infrequent state information
Color_StrongBlue, // intended for block headings
Color_StrongOrange, // intended for warnings
ConsoleColors_Count
};
// Use fastcall for the console; should be helpful in most cases
@ -62,30 +76,21 @@ struct IConsoleWriter
// ----------------------------------------------------------------------------
// Public members; call these to print stuff to console!
void Write( ConsoleColors color, const char* fmt, ... ) const;
void Write( const char* fmt, ... ) const;
void Write( ConsoleColors color, const wxString& fmt ) const;
void Write( const wxString& fmt ) const;
void WriteLn( ConsoleColors color, const char* fmt, ... ) const;
void Write( const char* fmt, ... ) const;
void WriteLn( const char* fmt, ... ) const;
void WriteLn( ConsoleColors color, const wxString& fmt ) const;
void WriteLn( const wxString& fmt ) const;
void Error( const char* fmt, ... ) const;
void Notice( const char* fmt, ... ) const;
void Status( const char* fmt, ... ) const;
void Warning( const char* fmt, ... ) const;
void Error( const wxString& src ) const;
void Notice( const wxString& src ) const;
void Status( const wxString& src ) const;
void Write( ConsoleColors color, const wxChar* fmt, ... ) const;
void WriteLn( ConsoleColors color, const wxChar* fmt, ... ) const;
void Write( const wxChar* fmt, ... ) const;
void WriteLn( const wxChar* fmt, ... ) const;
void Error( const wxChar* fmt, ... ) const;
void Warning( const wxChar* fmt, ... ) const;
// ----------------------------------------------------------------------------
// Private Members; for internal use only.
void _Write( const char* fmt, va_list args ) const;
void _WriteLn( const char* fmt, va_list args ) const;
void _WriteLn( ConsoleColors color, const char* fmt, va_list args ) const;
};
extern void Console_SetActiveHandler( const IConsoleWriter& writer, FILE* flushfp=NULL );

20
common/include/Utilities/SafeArray.h
View File

@ -74,12 +74,12 @@ public:
static const int DefaultChunkSize = 0x1000 * sizeof(T);
public:
const wxChar* Name; // user-assigned block name
int ChunkSize;
wxString Name; // user-assigned block name
int ChunkSize;
protected:
T* m_ptr;
int m_size; // size of the allocation of memory
T* m_ptr;
int m_size; // size of the allocation of memory
protected:
// Internal constructor for use by derived classes. This allows a derived class to
@ -232,13 +232,13 @@ public:
static const int DefaultChunkSize = 0x80 * sizeof(T);
public:
const wxChar* Name; // user-assigned block name
int ChunkSize; // assigned DefaultChunkSize on init, reconfigurable at any time.
wxString Name; // user-assigned block name
int ChunkSize; // assigned DefaultChunkSize on init, reconfigurable at any time.
protected:
T* m_ptr;
int m_allocsize; // size of the allocation of memory
uint m_length; // length of the array (active items, not buffer allocation)
T* m_ptr;
int m_allocsize; // size of the allocation of memory
uint m_length; // length of the array (active items, not buffer allocation)
protected:
virtual T* _virtual_realloc( int newsize )
@ -312,7 +312,7 @@ public:
wxsFormat(
L"Out-of-memory on SafeList block re-allocation.\n"
L"Name: %s, Old size: %d bytes, New size: %d bytes",
Name, m_allocsize, newalloc
Name.c_str(), m_allocsize, newalloc
),
wxsFormat( _("Out of memory, trying to allocate %d bytes."), newalloc )

260
common/src/Utilities/Console.cpp
View File

@ -198,56 +198,144 @@ const IConsoleWriter ConsoleWriter_wxError =
ConsoleNull_ClearColor,
};
// Sanity check: truncate strings if they exceed 512k in length. Anything like that
// is either a bug or really horrible code that needs to be stopped before it causes
// system deadlock.
static const int MaxFormattedStringLength = 0x80000;
template< typename CharType >
class FormatBuffer : public MutexLock
{
public:
bool& clearbit;
SafeArray<CharType> buffer;
FormatBuffer( bool& bit_to_clear_on_destruction ) :
clearbit( bit_to_clear_on_destruction )
, buffer( 4096, wxsFormat( L"%s Format Buffer", (sizeof(CharType)==1) ? "Ascii" : "Unicode" ) )
{
}
virtual ~FormatBuffer() throw()
{
clearbit = true;
Wait(); // lock the mutex, just in case.
}
};
static bool ascii_buffer_is_deleted = false;
static bool unicode_buffer_is_deleted = false;
static FormatBuffer<char> ascii_buffer( ascii_buffer_is_deleted );
static FormatBuffer<wxChar> unicode_buffer( unicode_buffer_is_deleted );
static void format_that_ascii_mess( SafeArray<char>& buffer, const char* fmt, va_list argptr )
{
while( true )
{
int size = buffer.GetLength();
int len = vsnprintf(buffer.GetPtr(), size, fmt, argptr);
// some implementations of vsnprintf() don't NUL terminate
// the string if there is not enough space for it so
// always do it manually
buffer[size-1] = '\0';
if( size >= MaxFormattedStringLength ) break;
// vsnprintf() may return either -1 (traditional Unix behavior) or the
// total number of characters which would have been written if the
// buffer were large enough (newer standards such as Unix98)
if ( len < 0 )
len = size + (size/4);
if ( len < size ) break;
buffer.ExactAlloc( len + 1 );
};
// performing an assertion or log of a truncated string is unsafe, so let's not; even
// though it'd be kinda nice if we did.
}
static void format_that_unicode_mess( SafeArray<wxChar>& buffer, const wxChar* fmt, va_list argptr)
{
while( true )
{
int size = buffer.GetLength();
int len = wxVsnprintf(buffer.GetPtr(), size, fmt, argptr);
// some implementations of vsnprintf() don't NUL terminate
// the string if there is not enough space for it so
// always do it manually
buffer[size-1] = L'\0';
if( size >= MaxFormattedStringLength ) break;
// vsnprintf() may return either -1 (traditional Unix behavior) or the
// total number of characters which would have been written if the
// buffer were large enough (newer standards such as Unix98)
if ( len < 0 )
len = size + (size/4);
if ( len < size ) break;
buffer.ExactAlloc( len + 1 );
};
// performing an assertion or log of a truncated string is unsafe, so let's not; even
// though it'd be kinda nice if we did.
}
static wxString ascii_format_string(const char* fmt, va_list argptr)
{
if( ascii_buffer_is_deleted )
{
SafeArray<char> localbuf( 4096, L"Temporary Ascii Formatting Buffer" );
format_that_ascii_mess( localbuf, fmt, argptr );
return fromUTF8( localbuf.GetPtr() );
}
else
{
ScopedLock locker( ascii_buffer );
format_that_ascii_mess( ascii_buffer.buffer, fmt, argptr );
return fromUTF8( ascii_buffer.buffer.GetPtr() );
}
}
static wxString unicode_format_string(const wxChar* fmt, va_list argptr)
{
if( unicode_buffer_is_deleted )
{
SafeArray<wxChar> localbuf( 4096, L"Temporary Unicode Formatting Buffer" );
format_that_unicode_mess( localbuf, fmt, argptr );
return localbuf.GetPtr();
}
else
{
ScopedLock locker( unicode_buffer );
format_that_unicode_mess( unicode_buffer.buffer, fmt, argptr );
return unicode_buffer.buffer.GetPtr();
}
}
// =====================================================================================================
// IConsole Interfaces
// =====================================================================================================
// (all non-virtual members that do common work and then pass the result through DoWrite
// or DoWriteLn)
// Writes a line of colored text to the console (no newline).
// The console color is reset to default when the operation is complete.
void IConsoleWriter::Write( ConsoleColors color, const wxString& fmt ) const
{
SetColor( color );
Write( fmt );
ClearColor();
}
// Writes a line of colored text to the console, with automatic newline appendage.
// The console color is reset to default when the operation is complete.
void IConsoleWriter::WriteLn( ConsoleColors color, const wxString& fmt ) const
{
SetColor( color );
WriteLn( fmt );
ClearColor();
}
void IConsoleWriter::_Write( const char* fmt, va_list args ) const
{
std::string m_format_buffer;
vssprintf( m_format_buffer, fmt, args );
Write( fromUTF8( m_format_buffer.c_str() ) );
}
void IConsoleWriter::_WriteLn( const char* fmt, va_list args ) const
{
std::string m_format_buffer;
vssprintf( m_format_buffer, fmt, args );
WriteLn( fromUTF8( m_format_buffer.c_str() ) );
}
void IConsoleWriter::_WriteLn( ConsoleColors color, const char* fmt, va_list args ) const
{
SetColor( color );
_WriteLn( fmt, args );
ClearColor();
}
// --------------------------------------------------------------------------------------
// ASCII/UTF8 (char*)
// --------------------------------------------------------------------------------------
void IConsoleWriter::Write( const char* fmt, ... ) const
{
va_list args;
va_start(args,fmt);
_Write( fmt, args );
DoWrite( ascii_format_string(fmt, args) );
va_end(args);
}
@ -256,7 +344,7 @@ void IConsoleWriter::Write( ConsoleColors color, const char* fmt, ... ) const
va_list args;
va_start(args,fmt);
SetColor( color );
_Write( fmt, args );
DoWrite( ascii_format_string(fmt, args) );
ClearColor();
va_end(args);
}
@ -265,7 +353,7 @@ void IConsoleWriter::WriteLn( const char* fmt, ... ) const
{
va_list args;
va_start(args,fmt);
_WriteLn( fmt, args );
DoWriteLn( ascii_format_string(fmt, args) );
va_end(args);
}
@ -273,59 +361,93 @@ void IConsoleWriter::WriteLn( ConsoleColors color, const char* fmt, ... ) const
{
va_list args;
va_start(args,fmt);
_WriteLn( color, fmt, args );
SetColor( color );
DoWriteLn( ascii_format_string(fmt, args) );
ClearColor();
va_end(args);
}
void IConsoleWriter::Write( const wxString& src ) const
{
DoWrite( src );
}
void IConsoleWriter::WriteLn( const wxString& src ) const
{
DoWriteLn( src );
}
void IConsoleWriter::Error( const char* fmt, ... ) const
{
va_list args;
va_start(args,fmt);
_WriteLn( Color_Red, fmt, args );
SetColor( Color_StrongRed );
DoWriteLn( ascii_format_string(fmt, args) );
ClearColor();
va_end(args);
}
void IConsoleWriter::Notice( const char* fmt, ... ) const
void IConsoleWriter::Warning( const char* fmt, ... ) const
{
va_list list;
va_start(list,fmt);
_WriteLn( Color_Yellow, fmt, list );
va_end(list);
va_list args;
va_start(args,fmt);
SetColor( Color_StrongOrange );
DoWriteLn( ascii_format_string(fmt, args) );
ClearColor();
va_end(args);
}
void IConsoleWriter::Status( const char* fmt, ... ) const
// --------------------------------------------------------------------------------------
// FmtWrite Variants - Unicode/UTF16 style
// --------------------------------------------------------------------------------------
void IConsoleWriter::Write( const wxChar* fmt, ... ) const
{
va_list list;
va_start(list,fmt);
_WriteLn( Color_Green, fmt, list );
va_end(list);
va_list args;
va_start(args,fmt);
DoWrite( unicode_format_string( fmt, args ) );
va_end(args);
}
void IConsoleWriter::Error( const wxString& src ) const
void IConsoleWriter::Write( ConsoleColors color, const wxChar* fmt, ... ) const
{
WriteLn( Color_Red, src );
va_list args;
va_start(args,fmt);
SetColor( color );
DoWrite( unicode_format_string( fmt, args ) );
ClearColor();
va_end(args);
}
void IConsoleWriter::Notice( const wxString& src ) const
void IConsoleWriter::WriteLn( const wxChar* fmt, ... ) const
{
WriteLn( Color_Yellow, src );
va_list args;
va_start(args,fmt);
DoWriteLn( unicode_format_string( fmt, args ) );
va_end(args);
}
void IConsoleWriter::Status( const wxString& src ) const
void IConsoleWriter::WriteLn( ConsoleColors color, const wxChar* fmt, ... ) const
{
WriteLn( Color_Green, src );
va_list args;
va_start(args,fmt);
SetColor( color );
DoWriteLn( unicode_format_string( fmt, args ) );
ClearColor();
va_end(args);
}
void IConsoleWriter::Error( const wxChar* fmt, ... ) const
{
va_list args;
va_start(args,fmt);
SetColor( Color_StrongRed );
DoWriteLn( unicode_format_string( fmt, args ) );
ClearColor();
va_end(args);
}
void IConsoleWriter::Warning( const wxChar* fmt, ... ) const
{
va_list args;
va_start(args,fmt);
SetColor( Color_StrongOrange );
DoWriteLn( unicode_format_string( fmt, args ) );
ClearColor();
va_end(args);
}
// --------------------------------------------------------------------------------------
// Default Writer for C++ init / startup:
// --------------------------------------------------------------------------------------

7
common/src/Utilities/Exceptions.cpp
View File

@ -51,10 +51,9 @@ DEVASSERT_INLINE void pxOnAssert( const wxChar* file, int line, const char* func
if( wxTheApp == NULL )
{
// Note: Format uses MSVC's syntax for output window hotlinking.
wxsFormat( L"%s(%d): Assertion failed in %s: %s\n",
file, line, fromUTF8(func).c_str(), msg );
wxLogError( msg );
wxLogError( wxsFormat( L"%s(%d): Assertion failed in %s: %s\n",
file, line, fromUTF8(func).c_str(), msg )
);
}
else
{

14
common/src/Utilities/ThreadTools.cpp
View File

@ -87,11 +87,11 @@ Threading::PersistentThread::~PersistentThread() throw()
{
try
{
DevCon.WriteLn( L"(Thread Log) Executing destructor for " + m_name );
DbgCon.WriteLn( L"(Thread Log) Executing destructor for " + m_name );
if( m_running )
{
DevCon.WriteLn( L"\tWaiting for running thread to end...");
DevCon.WriteLn( L"(Thread Log) Waiting for running thread to end...");
m_lock_InThread.Wait();
}
Threading::Sleep( 1 );
@ -108,8 +108,8 @@ Threading::PersistentThread::~PersistentThread() throw()
// so we can't allow for customized deadlock handlers, least not in any useful
// context. So let's just log the condition and move on.
Console.Error( wxsFormat(L"\tThread destructor for '%s' timed out with error:\n\t",
m_name.c_str(), ex.FormatDiagnosticMessage().c_str() ) );
Console.Error( L"(Thread Log) Thread destructor for '%s' timed out with error:\n\t",
m_name.c_str(), ex.FormatDiagnosticMessage().c_str() );
}
DESTRUCTOR_CATCHALL
}
@ -121,8 +121,8 @@ void Threading::PersistentThread::FrankenMutex( MutexLock& mutex )
// Our lock is bupkis, which means the previous thread probably deadlocked.
// Let's create a new mutex lock to replace it.
Console.Error( wxsFormat(
L"(Thread Log) Possible deadlock detected on restarted mutex belonging to '%s'.", m_name.c_str() )
Console.Error(
L"(Thread Log) Possible deadlock detected on restarted mutex belonging to '%s'.", m_name.c_str()
);
}
}
@ -182,7 +182,7 @@ void Threading::PersistentThread::Cancel( bool isBlocking )
if( m_detached )
{
Console.Notice( "(Thread Warning) Ignoring attempted cancellation of detached thread." );
Console.Warning( "(Thread Warning) Ignoring attempted cancellation of detached thread." );
return;
}

10
common/src/x86emitter/cpudetect.cpp
View File

@ -97,7 +97,7 @@ static void SetSingleAffinity()
if( s_oldmask == ERROR_INVALID_PARAMETER )
{
Console.Notice(
Console.Warning(
"CpuDetect: SetThreadAffinityMask failed...\n"
"\tSystem Affinity : 0x%08x"
"\tProcess Affinity: 0x%08x"
@ -353,7 +353,7 @@ void cpudetectInit()
if( sse3_result != !!x86caps.hasStreamingSIMD3Extensions )
{
Console.Notice( "SSE3 Detection Inconsistency: cpuid=%s, test_result=%s",
Console.Warning( "SSE3 Detection Inconsistency: cpuid=%s, test_result=%s",
bool_to_char( !!x86caps.hasStreamingSIMD3Extensions ), bool_to_char( sse3_result ) );
x86caps.hasStreamingSIMD3Extensions = sse3_result;
@ -361,7 +361,7 @@ void cpudetectInit()
if( ssse3_result != !!x86caps.hasSupplementalStreamingSIMD3Extensions )
{
Console.Notice( "SSSE3 Detection Inconsistency: cpuid=%s, test_result=%s",
Console.Warning( "SSSE3 Detection Inconsistency: cpuid=%s, test_result=%s",
bool_to_char( !!x86caps.hasSupplementalStreamingSIMD3Extensions ), bool_to_char( ssse3_result ) );
x86caps.hasSupplementalStreamingSIMD3Extensions = ssse3_result;
@ -369,7 +369,7 @@ void cpudetectInit()
if( sse41_result != !!x86caps.hasStreamingSIMD4Extensions )
{
Console.Notice( "SSE4 Detection Inconsistency: cpuid=%s, test_result=%s",
Console.Warning( "SSE4 Detection Inconsistency: cpuid=%s, test_result=%s",
bool_to_char( !!x86caps.hasStreamingSIMD4Extensions ), bool_to_char( sse41_result ) );
x86caps.hasStreamingSIMD4Extensions = sse41_result;
@ -378,7 +378,7 @@ void cpudetectInit()
}
else
{
Console.Notice(
Console.Warning(
"Notice: Could not allocate memory for SSE3/4 detection.\n"
"\tRelying on CPUID results. [this is not an error]"
);

22
pcsx2/CDVD/CDVD.cpp
View File

@ -84,7 +84,7 @@ FILE *_cdvdOpenMechaVer()
fd = fopen(file, "r+b");
if (fd == NULL)
{
Console.Notice("MEC File Not Found , Creating Blank File");
Console.Warning("MEC File Not Found , Creating Blank File");
fd = fopen(file, "wb");
if (fd == NULL)
{
@ -124,7 +124,7 @@ FILE *_cdvdOpenNVM()
fd = fopen(file, "r+b");
if (fd == NULL)
{
Console.Notice("NVM File Not Found , Creating Blank File");
Console.Warning("NVM File Not Found , Creating Blank File");
fd = fopen(file, "wb");
if (fd == NULL)
{
@ -328,7 +328,7 @@ void cdvdReadKey(u8 arg0, u16 arg1, u32 arg2, u8* key) {
const wxCharBuffer crap( fname.ToAscii() );
const char* str = crap.data();
sprintf(exeName, "%c%c%c%c%c%c%c%c%c%c%c",str[8],str[9],str[10],str[11],str[12],str[13],str[14],str[15],str[16],str[17],str[18]);
DevCon.Notice("exeName = %s", &str[8]);
DevCon.Warning("exeName = %s", &str[8]);
// convert the number characters to a real 32bit number
numbers = ((((exeName[5] - '0'))*10000) +
@ -1048,14 +1048,14 @@ static void cdvdWrite04(u8 rt) { // NCOMMAND
// Seek to sector zero. The cdvdStartSeek function will simulate
// spinup times if needed.
DevCon.Notice( "CdStandby : %d", rt );
DevCon.Warning( "CdStandby : %d", rt );
cdvd.Action = cdvdAction_Standby;
cdvd.ReadTime = cdvdBlockReadTime( MODE_DVDROM );
CDVD_INT( cdvdStartSeek( 0, MODE_DVDROM ) );
break;
case N_CD_STOP: // CdStop
DevCon.Notice( "CdStop : %d", rt );
DevCon.Warning( "CdStop : %d", rt );
cdvd.Action = cdvdAction_Stop;
CDVD_INT( PSXCLK / 6 ); // 166ms delay?
break;
@ -1216,12 +1216,12 @@ static void cdvdWrite04(u8 rt) { // NCOMMAND
break;
case N_CD_CHG_SPDL_CTRL: // CdChgSpdlCtrl
Console.Notice("sceCdChgSpdlCtrl(%d)", cdvd.Param[0]);
Console.Warning("sceCdChgSpdlCtrl(%d)", cdvd.Param[0]);
cdvdSetIrq();
break;
default:
Console.Notice("NCMD Unknown %x", rt);
Console.Warning("NCMD Unknown %x", rt);
cdvdSetIrq();
break;
}
@ -1250,7 +1250,7 @@ static __forceinline void cdvdWrite07(u8 rt) // BREAK
// If we're already in a Ready state or already Breaking, then do nothing:
if ((cdvd.Ready != CDVD_NOTREADY) || (cdvd.Action == cdvdAction_Break)) return;
DbgCon.Notice("*PCSX2*: CDVD BREAK %x", rt);
DbgCon.WriteLn("*PCSX2*: CDVD BREAK %x", rt);
// Aborts any one of several CD commands:
// Pause, Seek, Read, Status, Standby, and Stop
@ -1285,9 +1285,9 @@ static __forceinline void cdvdWrite14(u8 rt) { // PS1 MODE??
u32 cycle = psxRegs.cycle;
if (rt == 0xFE)
Console.Notice("*PCSX2*: go PS1 mode DISC SPEED = FAST");
Console.Warning("*PCSX2*: go PS1 mode DISC SPEED = FAST");
else
Console.Notice("*PCSX2*: go PS1 mode DISC SPEED = %dX", rt);
Console.Warning("*PCSX2*: go PS1 mode DISC SPEED = %dX", rt);
psxReset();
psxHu32(0x1f801450) = 0x8;
@ -1934,7 +1934,7 @@ void cdvdWrite(u8 key, u8 rt)
case 0x18: cdvdWrite18(rt); break;
case 0x3A: cdvdWrite3A(rt); break;
default:
Console.Notice("IOP Unknown 8bit write to addr 0x1f4020%x = 0x%x", key, rt);
Console.Warning("IOP Unknown 8bit write to addr 0x1f4020%x = 0x%x", key, rt);
break;
}
}

12
pcsx2/CDVD/CDVDaccess.cpp
View File

@ -159,15 +159,15 @@ static int FindDiskType(int mType)
switch(iCDType)
{
case CDVD_TYPE_DETCTCD:
Console.Status(" * CDVD Disk Open: CD, %d tracks (%d to %d):", tn.etrack-tn.strack+1,tn.strack,tn.etrack);
Console.WriteLn(" * CDVD Disk Open: CD, %d tracks (%d to %d):", tn.etrack-tn.strack+1,tn.strack,tn.etrack);
break;
case CDVD_TYPE_DETCTDVDS:
Console.Status(" * CDVD Disk Open: DVD, Single layer or unknown:");
Console.WriteLn(" * CDVD Disk Open: DVD, Single layer or unknown:");
break;
case CDVD_TYPE_DETCTDVDD:
Console.Status(" * CDVD Disk Open: DVD, Double layer:");
Console.WriteLn(" * CDVD Disk Open: DVD, Double layer:");
break;
}
@ -188,12 +188,12 @@ static int FindDiskType(int mType)
if (td.type == CDVD_AUDIO_TRACK)
{
audioTracks++;
Console.Status(" * * Track %d: Audio (%d sectors)", i,tlength);
Console.WriteLn(" * * Track %d: Audio (%d sectors)", i,tlength);
}
else
{
dataTracks++;
Console.Status(" * * Track %d: Data (Mode %d) (%d sectors)", i,((td.type==CDVD_MODE1_TRACK)?1:2),tlength);
Console.WriteLn(" * * Track %d: Data (Mode %d) (%d sectors)", i,((td.type==CDVD_MODE1_TRACK)?1:2),tlength);
}
}
@ -406,7 +406,7 @@ s32 DoCDVDreadTrack(u32 lsn, int mode)
break;
}
//DevCon.Notice("CDVD readTrack(lsn=%d,mode=%d)",params lsn, lastReadSize);
//DevCon.Warning("CDVD readTrack(lsn=%d,mode=%d)",params lsn, lastReadSize);
lastLSN = lsn;
return CDVD->readTrack(lsn,mode);
}

6
pcsx2/CDVD/CDVDisoReader.cpp
View File

@ -128,7 +128,7 @@ static void FindLayer1Start()
int off = iso->blockofs;
u8 tempbuffer[CD_FRAMESIZE_RAW];
Console.Status("CDVDiso: searching for layer1...");
Console.WriteLn("CDVDiso: searching for layer1...");
//tempbuffer = (u8*)malloc(CD_FRAMESIZE_RAW);
for (layer1start = (iso->blocks / 2 - 0x10) & ~0xf; layer1start < 0x200010; layer1start += 16)
{
@ -146,12 +146,12 @@ static void FindLayer1Start()
if(layer1start == 0x200010)
{
Console.Status("\tCouldn't find second layer on dual layer... ignoring");
Console.WriteLn("\tCouldn't find second layer on dual layer... ignoring");
layer1start=-2;
}
if(layer1start>=0)
Console.Status("\tfound at 0x%8.8x", layer1start);
Console.WriteLn("\tfound at 0x%8.8x", layer1start);
}
}

6
pcsx2/CDVD/IsoFStools.cpp
View File

@ -209,7 +209,7 @@ int IsoFS_getVolumeDescriptor(void)
else if (CDVolDesc.filesystemType == 2)
DbgCon.WriteLn( Color_Green, "CD FileSystem is Joliet");
else
DbgCon.Notice("Could not detect CD FileSystem type");
DbgCon.Warning("Could not detect CD FileSystem type");
// CdStop();
@ -333,7 +333,7 @@ int IsoFS_findFile(const char* fname, TocEntry* tocEntry){
// If we havent found the directory name we wanted then fail
if (found_dir != TRUE)
{
Console.Notice( "IsoFS_findfile: could not find dir" );
Console.Warning( "IsoFS_findfile: could not find dir" );
return -1;
}
@ -412,7 +412,7 @@ int IsoFS_findFile(const char* fname, TocEntry* tocEntry){
}
}
DbgCon.Notice("IsoFS_findfile: could not find file");
DbgCon.Warning("IsoFS_findfile: could not find file");
return FALSE;
}

4
pcsx2/COP0.cpp
View File

@ -210,10 +210,10 @@ static __forceinline bool PERF_ShouldCountEvent( uint evt )
void COP0_DiagnosticPCCR()
{
if( cpuRegs.PERF.n.pccr.b.Event0 >= 7 && cpuRegs.PERF.n.pccr.b.Event0 <= 10 )
Console.Notice( "PERF/PCR0 Unsupported Update Event Mode = 0x%x", cpuRegs.PERF.n.pccr.b.Event0 );
Console.Warning( "PERF/PCR0 Unsupported Update Event Mode = 0x%x", cpuRegs.PERF.n.pccr.b.Event0 );
if( cpuRegs.PERF.n.pccr.b.Event1 >= 7 && cpuRegs.PERF.n.pccr.b.Event1 <= 10 )
Console.Notice( "PERF/PCR1 Unsupported Update Event Mode = 0x%x", cpuRegs.PERF.n.pccr.b.Event1 );
Console.Warning( "PERF/PCR1 Unsupported Update Event Mode = 0x%x", cpuRegs.PERF.n.pccr.b.Event1 );
}
extern int branch;
__forceinline void COP0_UpdatePCCR()

3
pcsx2/Common.h
View File

@ -36,9 +36,10 @@
#include "Elfheader.h"
#include "Patch.h"
static const ConsoleColors ConColor_IOP = Color_Yellow;
static const ConsoleColors ConColor_EE = Color_Cyan;
// Some homeless externs. This is as good a spot as any for now...
extern void SetCPUState(u32 sseMXCSR, u32 sseVUMXCSR);
extern u32 g_sseVUMXCSR, g_sseMXCSR;

4
pcsx2/Counters.cpp
View File

@ -256,7 +256,7 @@ u32 UpdateVSyncRate()
{
m_iTicks = ticks;
gsOnModeChanged( vSyncInfo.Framerate, m_iTicks );
Console.Status( limiterMsg, EmuConfig.Video.FpsLimit, 0 );
Console.WriteLn( limiterMsg, EmuConfig.Video.FpsLimit, 0 );
}
}
else
@ -266,7 +266,7 @@ u32 UpdateVSyncRate()
{
m_iTicks = ticks;
gsOnModeChanged( vSyncInfo.Framerate, m_iTicks );
Console.Status( limiterMsg, vSyncInfo.Framerate/50, (vSyncInfo.Framerate*2)%100 );
Console.WriteLn( limiterMsg, vSyncInfo.Framerate/50, (vSyncInfo.Framerate*2)%100 );
}
}

2
pcsx2/Dump.cpp
View File

@ -207,7 +207,7 @@ void iDumpBlock( int startpc, u8 * ptr )
u8 fpuused[33];
int numused, fpunumused;
Console.Status( "dump1 %x:%x, %x", startpc, pc, cpuRegs.cycle );
Console.WriteLn( "dump1 %x:%x, %x", startpc, pc, cpuRegs.cycle );
g_Conf->Folders.Logs.Mkdir();
AsciiFile eff(

18
pcsx2/Elfheader.cpp
View File

@ -389,7 +389,7 @@ struct ElfObject
size = proghead[ i ].p_filesz;
if( proghead[ i ].p_vaddr != proghead[ i ].p_paddr )
Console.Notice( "ElfProgram different load addrs: paddr=0x%8.8x, vaddr=0x%8.8x",
Console.Warning( "ElfProgram different load addrs: paddr=0x%8.8x, vaddr=0x%8.8x",
proghead[ i ].p_paddr, proghead[ i ].p_vaddr);
// used to be paddr
@ -515,14 +515,14 @@ u32 loadElfCRC( const char* filename )
IsoFS_init( );
Console.Status("loadElfCRC: %s", filename);
Console.WriteLn("loadElfCRC: %s", filename);
int mylen = strlen( "cdromN:" );
if ( IsoFS_findFile( filename + mylen, &toc ) == -1 ) return 0;
DevCon.Status( "loadElfFile: %d bytes", toc.fileSize );
DevCon.WriteLn( "loadElfFile: %d bytes", toc.fileSize );
u32 crcval = ElfObject( wxString::FromAscii( filename ), toc.fileSize ).GetCRC();
Console.Status( "loadElfFile: %s; CRC = %8.8X", filename, crcval );
Console.WriteLn( "loadElfFile: %s; CRC = %8.8X", filename, crcval );
return crcval;
}
@ -542,7 +542,7 @@ void loadElfFile(const wxString& filename)
if( filename.IsEmpty() ) return;
s64 elfsize;
Console.Status( wxsFormat( L"loadElfFile: %s", filename.c_str() ) );
Console.WriteLn( L"loadElfFile: %s", filename.c_str() );
const wxCharBuffer buffer( filename.ToAscii() );
const char* fnptr = buffer.data();
@ -567,7 +567,7 @@ void loadElfFile(const wxString& filename)
if( elfsize > 0xfffffff )
throw Exception::BadStream( filename, wxLt("Illegal ELF file size, over 2GB!") );
Console.Status( wxsFormat(L"loadElfFile: %d", wxULongLong(elfsize).GetLo() ) );
Console.WriteLn( L"loadElfFile: %d", wxULongLong(elfsize).GetLo() );
if( elfsize == 0 )
throw Exception::BadStream( filename, wxLt("Unexpected end of ELF file: ") );
@ -599,12 +599,12 @@ void loadElfFile(const wxString& filename)
if( memcmp( "rom0:OSDSYS", (char*)PSM( i ), 11 ) == 0 )
{
strcpy( (char*)PSM( i ), fnptr );
DevCon.Status( "loadElfFile: addr %x \"%s\" -> \"%s\"", i, "rom0:OSDSYS", fnptr );
DevCon.WriteLn( "loadElfFile: addr %x \"%s\" -> \"%s\"", i, "rom0:OSDSYS", fnptr );
}
}
ElfCRC = elfobj.GetCRC();
Console.Status( wxsFormat( L"loadElfFile: %s; CRC = %8.8X", filename.c_str(), ElfCRC ) );
Console.WriteLn( L"loadElfFile: %s; CRC = %8.8X", filename.c_str(), ElfCRC );
ElfApplyPatches();
mtgsThread.SendGameCRC( ElfCRC );
@ -626,7 +626,7 @@ int GetPS2ElfName( wxString& name )
// check if the file exists
if (IsoFS_findFile("SYSTEM.CNF;1", &tocEntry) != TRUE){
Console.Status("GetElfName: SYSTEM.CNF not found; invalid cd image or no disc present.");
Console.Warning("GetElfName: SYSTEM.CNF not found; invalid cd image or no disc present.");
return 0;//could not find; not a PS/PS2 cdvd
}

4
pcsx2/FPU.cpp
View File

@ -78,7 +78,7 @@
// If we have an infinity value, then Overflow has occured.
#define checkOverflow(xReg, cFlagsToSet, shouldReturn) { \
if ( ( xReg & ~0x80000000 ) == PosInfinity ) { \
/*Console.Notice( "FPU OVERFLOW!: Changing to +/-Fmax!!!!!!!!!!!!\n" );*/ \
/*Console.Warning( "FPU OVERFLOW!: Changing to +/-Fmax!!!!!!!!!!!!\n" );*/ \
xReg = ( xReg & 0x80000000 ) | posFmax; \
_ContVal_ |= cFlagsToSet; \
if ( shouldReturn ) { return; } \
@ -88,7 +88,7 @@
// If we have a denormal value, then Underflow has occured.
#define checkUnderflow(xReg, cFlagsToSet, shouldReturn) { \
if ( ( ( xReg & 0x7F800000 ) == 0 ) && ( ( xReg & 0x007FFFFF ) != 0 ) ) { \
/*Console.Notice( "FPU UNDERFLOW!: Changing to +/-0!!!!!!!!!!!!\n" );*/ \
/*Console.Warning( "FPU UNDERFLOW!: Changing to +/-0!!!!!!!!!!!!\n" );*/ \
xReg &= 0x80000000; \
_ContVal_ |= cFlagsToSet; \
if ( shouldReturn ) { return; } \

26
pcsx2/FiFo.cpp
View File

@ -43,7 +43,7 @@
void __fastcall ReadFIFO_page_4(u32 mem, u64 *out)
{
jASSUME( (mem >= VIF0_FIFO) && (mem < VIF1_FIFO) );
pxAssert( (mem >= VIF0_FIFO) && (mem < VIF1_FIFO) );
VIF_LOG("ReadFIFO/VIF0 0x%08X", mem);
@ -53,12 +53,12 @@ void __fastcall ReadFIFO_page_4(u32 mem, u64 *out)
void __fastcall ReadFIFO_page_5(u32 mem, u64 *out)
{
jASSUME( (mem >= VIF1_FIFO) && (mem < GIF_FIFO) );
pxAssert( (mem >= VIF1_FIFO) && (mem < GIF_FIFO) );
VIF_LOG("ReadFIFO/VIF1, addr=0x%08X", mem);
if (vif1Regs->stat.test(VIF1_STAT_INT | VIF1_STAT_VSS | VIF1_STAT_VIS | VIF1_STAT_VFS) )
DevCon.Notice( "Reading from vif1 fifo when stalled" );
DevCon.Warning( "Reading from vif1 fifo when stalled" );
if (vif1Regs->stat.FDR)
{
@ -72,9 +72,9 @@ void __fastcall ReadFIFO_page_5(u32 mem, u64 *out)
void __fastcall ReadFIFO_page_6(u32 mem, u64 *out)
{
jASSUME( (mem >= GIF_FIFO) && (mem < IPUout_FIFO) );
pxAssert( (mem >= GIF_FIFO) && (mem < IPUout_FIFO) );
DevCon.Notice( "ReadFIFO/GIF, addr=0x%x", mem );
DevCon.Warning( "ReadFIFO/GIF, addr=0x%x", mem );
out[0] = psHu64(GIF_FIFO);
out[1] = psHu64(GIF_FIFO + 8);
@ -82,7 +82,7 @@ void __fastcall ReadFIFO_page_6(u32 mem, u64 *out)
void __fastcall ReadFIFO_page_7(u32 mem, u64 *out)
{
jASSUME( (mem >= IPUout_FIFO) && (mem < D0_CHCR) );
pxAssert( (mem >= IPUout_FIFO) && (mem < D0_CHCR) );
// All addresses in this page map to 0x7000 and 0x7010:
mem &= 0x10;
@ -107,7 +107,7 @@ void __fastcall ReadFIFO_page_7(u32 mem, u64 *out)
void __fastcall WriteFIFO_page_4(u32 mem, const mem128_t *value)
{
jASSUME( (mem >= VIF0_FIFO) && (mem < VIF1_FIFO) );
pxAssert( (mem >= VIF0_FIFO) && (mem < VIF1_FIFO) );
VIF_LOG("WriteFIFO/VIF0, addr=0x%08X", mem);
@ -121,7 +121,7 @@ void __fastcall WriteFIFO_page_4(u32 mem, const mem128_t *value)
void __fastcall WriteFIFO_page_5(u32 mem, const mem128_t *value)
{
jASSUME( (mem >= VIF1_FIFO) && (mem < GIF_FIFO) );
pxAssert( (mem >= VIF1_FIFO) && (mem < GIF_FIFO) );
VIF_LOG("WriteFIFO/VIF1, addr=0x%08X", mem);
@ -129,9 +129,9 @@ void __fastcall WriteFIFO_page_5(u32 mem, const mem128_t *value)
psHu64(VIF1_FIFO + 8) = value[1];
if (vif1Regs->stat.FDR)
DevCon.Notice("writing to fifo when fdr is set!");
DevCon.Warning("writing to fifo when fdr is set!");
if (vif1Regs->stat.test(VIF1_STAT_INT | VIF1_STAT_VSS | VIF1_STAT_VIS | VIF1_STAT_VFS) )
DevCon.Notice("writing to vif1 fifo when stalled");
DevCon.Warning("writing to vif1 fifo when stalled");
vif1ch->qwc += 1;
int ret = VIF1transfer((u32*)value, 4, 0);
@ -143,7 +143,7 @@ __aligned16 u32 nloop0_packet[4] = {0x8000, 0, 0, 0};
void __fastcall WriteFIFO_page_6(u32 mem, const mem128_t *value)
{
jASSUME( (mem >= GIF_FIFO) && (mem < IPUout_FIFO) );
pxAssert( (mem >= GIF_FIFO) && (mem < IPUout_FIFO) );
GIF_LOG("WriteFIFO/GIF, addr=0x%08X", mem);
psHu64(GIF_FIFO) = value[0];
@ -160,7 +160,7 @@ void __fastcall WriteFIFO_page_6(u32 mem, const mem128_t *value)
void __fastcall WriteFIFO_page_7(u32 mem, const mem128_t *value)
{
jASSUME( (mem >= IPUout_FIFO) && (mem < D0_CHCR) );
pxAssert( (mem >= IPUout_FIFO) && (mem < D0_CHCR) );
// All addresses in this page map to 0x7000 and 0x7010:
mem &= 0x10;
@ -170,7 +170,7 @@ void __fastcall WriteFIFO_page_7(u32 mem, const mem128_t *value)
if( mem == 0 )
{
// Should this raise a PS2 exception or just ignore silently?
Console.Notice( "WriteFIFO/IPUout (ignored)" );
Console.Warning( "WriteFIFO/IPUout (ignored)" );
}
else
{

4
pcsx2/GSState.cpp
View File

@ -73,7 +73,7 @@ void SaveGSState(const wxString& file)
if( g_SaveGSStream ) return;
Console.WriteLn( "Saving GS State..." );
Console.WriteLn( wxsFormat( L"\t%s", file.c_str() ) );
Console.WriteLn( L"\t%s", file.c_str() );
SafeArray<u8> buf;
g_fGSSave = new memSavingState( buf );
@ -88,7 +88,7 @@ void LoadGSState(const wxString& file)
{
int ret;
Console.Status( "Loading GS State..." );
Console.WriteLn( "Loading GS State..." );
wxString src( file );

4
pcsx2/Gif.cpp
View File

@ -73,7 +73,7 @@ __forceinline void gsInterrupt()
{
if (!dmacRegs->ctrl.DMAE)
{
Console.Notice("gs dma masked, re-scheduling...");
Console.Warning("gs dma masked, re-scheduling...");
// re-raise the int shortly in the future
CPU_INT( 2, 64 );
return;
@ -124,7 +124,7 @@ int _GIFchain()
//must increment madr and clear qwc, else it loops
gif->madr += gif->qwc * 16;
gif->qwc = 0;
Console.Notice( "Hackfix - NULL GIFchain" );
Console.Warning( "Hackfix - NULL GIFchain" );
return -1;
}

4
pcsx2/Hw.cpp
View File

@ -75,7 +75,7 @@ __forceinline void intcInterrupt()
if ((cpuRegs.CP0.n.Status.val & 0x400) != 0x400) return;
if ((psHu32(INTC_STAT)) == 0) {
DevCon.Notice("*PCSX2*: intcInterrupt already cleared");
DevCon.Warning("*PCSX2*: intcInterrupt already cleared");
return;
}
if ((psHu32(INTC_STAT) & psHu32(INTC_MASK)) == 0) return;
@ -197,7 +197,7 @@ bool hwDmacSrcChainWithStack(DMACh *dma, int id) {
break;
default:
Console.Notice("Call Stack Overflow (report if it fixes/breaks anything)");
Console.Warning("Call Stack Overflow (report if it fixes/breaks anything)");
return true;
}

4
pcsx2/HwRead.cpp
View File

@ -55,7 +55,7 @@ __forceinline mem8_t hwRead8(u32 mem)
u8 ret;
if( mem >= IPU_CMD && mem < D0_CHCR )
DevCon.Notice("Unexpected hwRead8 from 0x%x", mem);
DevCon.Warning("Unexpected hwRead8 from 0x%x", mem);
switch (mem)
{
@ -128,7 +128,7 @@ __forceinline mem16_t hwRead16(u32 mem)
u16 ret;
if( mem >= IPU_CMD && mem < D0_CHCR )
Console.Notice("Unexpected hwRead16 from 0x%x", mem);
Console.Warning("Unexpected hwRead16 from 0x%x", mem);
switch (mem)
{

72
pcsx2/HwWrite.cpp
View File

@ -147,7 +147,7 @@ void hwWrite8(u32 mem, u8 value)
}
if( mem >= IPU_CMD && mem < D0_CHCR )
DevCon.Notice( "hwWrite8 to 0x%x = 0x%x", mem, value );
DevCon.Warning( "hwWrite8 to 0x%x = 0x%x", mem, value );
switch (mem) {
case RCNT0_COUNT: rcntWcount(0, value); break;
@ -180,7 +180,7 @@ void hwWrite8(u32 mem, u8 value)
( value == '\n' && sio_count != 0 ))
{
sio_buffer[sio_count] = 0;
Console.WriteLn( Color_Cyan, sio_buffer );
Console.WriteLn( ConColor_EE, sio_buffer );
sio_count = 0;
}
else if( value != '\n' )
@ -197,7 +197,7 @@ void hwWrite8(u32 mem, u8 value)
DMA_LOG("VIF0dma EXECUTE, value=0x%x", value);
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit VIF0 DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit VIF0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x1;
}
DmaExec8(dmaVIF0, mem, value);
@ -207,7 +207,7 @@ void hwWrite8(u32 mem, u8 value)
DMA_LOG("VIF1dma EXECUTE, value=0x%x", value);
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit VIF1 DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit VIF1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x2;
}
if(value & 0x1) vif1.done = false; //This must be done here! some games (ala Crash of the Titans) pause the dma to start MFIFO
@ -218,7 +218,7 @@ void hwWrite8(u32 mem, u8 value)
DMA_LOG("GSdma EXECUTE, value=0x%x", value);
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit GIF DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit GIF DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x4;
}
DmaExec8(dmaGIF, mem, value);
@ -228,7 +228,7 @@ void hwWrite8(u32 mem, u8 value)
DMA_LOG("IPU0dma EXECUTE, value=0x%x", value);
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit IPU0 DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit IPU0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x8;
}
DmaExec8(dmaIPU0, mem, value);
@ -238,7 +238,7 @@ void hwWrite8(u32 mem, u8 value)
DMA_LOG("IPU1dma EXECUTE, value=0x%x", value);
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit IPU1 DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit IPU1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x10;
}
DmaExec8(dmaIPU1, mem, value);
@ -249,7 +249,7 @@ void hwWrite8(u32 mem, u8 value)
// if (value == 0) psxSu32(0x30) = 0x40000;
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit SIF0 DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit SIF0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x20;
}
DmaExec8(dmaSIF0, mem, value);
@ -259,7 +259,7 @@ void hwWrite8(u32 mem, u8 value)
DMA_LOG("SIF1dma EXECUTE, value=0x%x", value);
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit SIF1 DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit SIF1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x40;
}
DmaExec8(dmaSIF1, mem, value);
@ -269,7 +269,7 @@ void hwWrite8(u32 mem, u8 value)
DMA_LOG("SIF2dma EXECUTE, value=0x%x", value);
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit SIF2 DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit SIF2 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x80;
}
DmaExec8(dmaSIF2, mem, value);
@ -279,7 +279,7 @@ void hwWrite8(u32 mem, u8 value)
DMA_LOG("fromSPRdma8 EXECUTE, value=0x%x", value);
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit SPR0 DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit SPR0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x100;
}
DmaExec8(dmaSPR0, mem, value);
@ -289,7 +289,7 @@ void hwWrite8(u32 mem, u8 value)
DMA_LOG("toSPRdma8 EXECUTE, value=0x%x", value);
if ((value & 0x1) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("8 bit SPR1 DMA Start while DMAC Disabled\n");
DevCon.Warning("8 bit SPR1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x200;
}
DmaExec8(dmaSPR1, mem, value);
@ -348,7 +348,7 @@ void hwWrite8(u32 mem, u8 value)
__forceinline void hwWrite16(u32 mem, u16 value)
{
if( mem >= IPU_CMD && mem < D0_CHCR )
Console.Notice( "hwWrite16 to %x", mem );
Console.Warning( "hwWrite16 to %x", mem );
switch(mem)
{
@ -374,7 +374,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
DMA_LOG("VIF0dma %lx", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit VIF0 DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit VIF0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x1;
}
DmaExec16(dmaVIF0, mem, value);
@ -384,7 +384,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
DMA_LOG("VIF1dma CHCR %lx", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit VIF1 DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit VIF1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x2;
}
if(value & 0x100) vif1.done = false; //This must be done here! some games (ala Crash of the Titans) pause the dma to start MFIFO
@ -428,7 +428,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
DMA_LOG("0x%8.8x hwWrite32: GSdma %lx", cpuRegs.cycle, value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit GIF DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit GIF DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x4;
}
DmaExec16(dmaGIF, mem, value);
@ -470,7 +470,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
DMA_LOG("IPU0dma %lx", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit IPU0 DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit IPU0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x8;
}
DmaExec16(dmaIPU0, mem, value);
@ -502,7 +502,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
DMA_LOG("IPU1dma %lx", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit IPU1 DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit IPU1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x10;
}
DmaExec16(dmaIPU1, mem, value);
@ -534,7 +534,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
// if (value == 0) psxSu32(0x30) = 0x40000;
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit SIF0 DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit SIF0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x20;
}
DmaExec16(dmaSIF0, mem, value);
@ -548,7 +548,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
DMA_LOG("SIF1dma %lx", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit SIF1 DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit SIF1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x40;
}
DmaExec16(dmaSIF1, mem, value);
@ -580,7 +580,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
DMA_LOG("SIF2dma %lx", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit SIF2 DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit SIF2 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x80;
}
DmaExec16(dmaSIF2, mem, value);
@ -594,7 +594,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
DMA_LOG("fromSPRdma %lx", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit SPR0 DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit SPR0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x100;
}
DmaExec16(dmaSPR0, mem, value);
@ -604,7 +604,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
DMA_LOG("toSPRdma %lx", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("16 bit SPR1 DMA Start while DMAC Disabled\n");
DevCon.Warning("16 bit SPR1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x200;
}
DmaExec16(dmaSPR1, mem, value);
@ -743,7 +743,7 @@ void __fastcall hwWrite32_page_03( u32 mem, u32 value )
break;
case GIF_STAT: // stat is readonly
DevCon.Notice("*PCSX2* GIFSTAT write value = 0x%x (readonly, ignored)", value);
DevCon.Warning("*PCSX2* GIFSTAT write value = 0x%x (readonly, ignored)", value);
break;
default:
@ -762,7 +762,7 @@ void __fastcall hwWrite32_page_0B( u32 mem, u32 value )
DMA_LOG("IPU0dma EXECUTE, value=0x%x\n", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit IPU0 DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit IPU0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x8;
}
DmaExec(dmaIPU0, mem, value);
@ -779,7 +779,7 @@ void __fastcall hwWrite32_page_0B( u32 mem, u32 value )
DMA_LOG("IPU1dma EXECUTE, value=0x%x\n", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit IPU1 DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit IPU1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x10;
}
DmaExec(dmaIPU1, mem, value);
@ -930,7 +930,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit VIF0 DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit VIF0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x1;
}
@ -943,7 +943,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit VIF1 DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit VIF1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x2;
}
@ -967,7 +967,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
DMA_LOG("GIFdma EXECUTE, value=0x%x", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit GIF DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit GIF DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x4;
}
DmaExec(dmaGIF, mem, value);
@ -986,7 +986,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
//if (value == 0) psxSu32(0x30) = 0x40000;
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit SIF0 DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit SIF0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x20;
}
DmaExec(dmaSIF0, mem, value);
@ -996,7 +996,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
DMA_LOG("SIF1dma EXECUTE, value=0x%x", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit SIF1 DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit SIF1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x40;
}
DmaExec(dmaSIF1, mem, value);
@ -1011,7 +1011,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
DMA_LOG("SIF2dma EXECUTE, value=0x%x", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit SIF2 DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit SIF2 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x80;
}
DmaExec(dmaSIF2, mem, value);
@ -1021,7 +1021,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
DMA_LOG("SPR0dma EXECUTE (fromSPR), value=0x%x", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit SPR0 DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit SPR0 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x100;
}
DmaExec(dmaSPR0, mem, value);
@ -1031,7 +1031,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
DMA_LOG("SPR1dma EXECUTE (toSPR), value=0x%x", value);
if ((value & 0x100) && !dmacRegs->ctrl.DMAE)
{
DevCon.Notice("32 bit SPR1 DMA Start while DMAC Disabled\n");
DevCon.Warning("32 bit SPR1 DMA Start while DMAC Disabled\n");
QueuedDMA |= 0x200;
}
DmaExec(dmaSPR1, mem, value);
@ -1081,7 +1081,7 @@ void __fastcall hwWrite64_page_03( u32 mem, const mem64_t* srcval )
switch (mem)
{
case GIF_CTRL:
DevCon.Status("GIF_CTRL write 64", value);
DevCon.WriteLn("GIF_CTRL write 64", value);
psHu32(mem) = value & 0x8;
if(value & 0x1)
gsGIFReset();
@ -1099,7 +1099,7 @@ void __fastcall hwWrite64_page_03( u32 mem, const mem64_t* srcval )
// set/clear bits 0 and 2 as per the GIF_MODE value.
const u32 bitmask = GIF_MODE_M3R | GIF_MODE_IMT;
Console.Status("GIFMODE64 %x", value);
Console.WriteLn("GIFMODE64 %x", value);
psHu64(GIF_MODE) = value;
psHu32(GIF_STAT) &= ~bitmask;

4
pcsx2/IPU/IPU.cpp
View File

@ -282,11 +282,11 @@ __forceinline u64 ipuRead64(u32 mem)
break;
ipucase(IPU_CTRL):
DevCon.Notice("reading 64bit IPU ctrl");
DevCon.Warning("reading 64bit IPU ctrl");
break;
ipucase(IPU_BP):
DevCon.Notice("reading 64bit IPU top");
DevCon.Warning("reading 64bit IPU top");
break;
ipucase(IPU_TOP): // IPU_TOP

14
pcsx2/IopBios.cpp
View File

@ -175,12 +175,8 @@ void bios_write() // 0x35/0x03
{
const char *ptr = Ra1;
// fixme: This should use %s with a length parameter (but I forget the exact syntax
while (a2 > 0)
{
Console.Write("%c", *ptr++);
a2--;
}
// fixme: This should use %s with a length parameter (but I forget the exact syntax)
Console.Write( ConColor_IOP, "%.*s", a2, ptr);
}
else
{
@ -291,19 +287,19 @@ _start:
// Note: Use Read to obtain a write pointer here, since we're just writing back the
// temp buffer we saved earlier.
memcpy( (void*)iopVirtMemR<void>(sp), save, 4*4);
Console.Write( Color_Cyan, "%s", tmp);
Console.Write( ConColor_IOP, tmp);
pc0 = ra;
}
void bios_putchar () // 3d
{
Console.Write( Color_Cyan, "%c", a0 );
Console.Write( ConColor_IOP, "%c", a0 );
pc0 = ra;
}
void bios_puts () // 3e/3f
{
Console.Write( Color_Cyan, Ra0 );
Console.Write( ConColor_IOP, Ra0 );
pc0 = ra;
}

4
pcsx2/IopDma.cpp
View File

@ -31,7 +31,7 @@ static void __fastcall psxDmaGeneric(u32 madr, u32 bcr, u32 chcr, u32 spuCore, _
const char dmaNum = spuCore ? '7' : '4';
/*if (chcr & 0x400) DevCon.Status("SPU 2 DMA %c linked list chain mode! chcr = %x madr = %x bcr = %x\n", dmaNum, chcr, madr, bcr);
if (chcr & 0x40000000) DevCon.Notice("SPU 2 DMA %c Unusual bit set on 'to' direction chcr = %x madr = %x bcr = %x\n", dmaNum, chcr, madr, bcr);
if (chcr & 0x40000000) DevCon.Warning("SPU 2 DMA %c Unusual bit set on 'to' direction chcr = %x madr = %x bcr = %x\n", dmaNum, chcr, madr, bcr);
if ((chcr & 0x1) == 0) DevCon.Status("SPU 2 DMA %c loading from spu2 memory chcr = %x madr = %x bcr = %x\n", dmaNum, chcr, madr, bcr);*/
const int size = (bcr >> 16) * (bcr & 0xFFFF);
@ -53,7 +53,7 @@ static void __fastcall psxDmaGeneric(u32 madr, u32 bcr, u32 chcr, u32 spuCore, _
if((g_psxNextBranchCycle - psxNextsCounter) > (u32)psxNextCounter)
{
//DevCon.Notice("SPU2async Setting new counter branch, old %x new %x ((%x - %x = %x) > %x delta)", g_psxNextBranchCycle, psxNextsCounter + psxNextCounter, g_psxNextBranchCycle, psxNextsCounter, (g_psxNextBranchCycle - psxNextsCounter), psxNextCounter);
//DevCon.Warning("SPU2async Setting new counter branch, old %x new %x ((%x - %x = %x) > %x delta)", g_psxNextBranchCycle, psxNextsCounter + psxNextCounter, g_psxNextBranchCycle, psxNextsCounter, (g_psxNextBranchCycle - psxNextsCounter), psxNextCounter);
g_psxNextBranchCycle = psxNextsCounter + psxNextCounter;
}
}

8
pcsx2/IopHw.cpp
View File

@ -69,7 +69,7 @@ u8 psxHwRead8(u32 add) {
case IOP_T5_COUNT:
case IOP_T5_MODE:
case IOP_T5_TARGET:
DevCon.Notice( "IOP Counter Read8 from addr0x%x = 0x%x", add, psxHu8(add) );
DevCon.Warning( "IOP Counter Read8 from addr0x%x = 0x%x", add, psxHu8(add) );
return psxHu8(add);
#endif
@ -649,7 +649,7 @@ void psxHwWrite8(u32 add, u8 value) {
case IOP_T5_COUNT:
case IOP_T5_MODE:
case IOP_T5_TARGET:
DevCon.Notice( "IOP Counter Write8 to addr 0x%x = 0x%x", add, value );
DevCon.Warning( "IOP Counter Write8 to addr 0x%x = 0x%x", add, value );
psxHu8(add) = value;
return;
@ -673,7 +673,7 @@ void psxHwWrite8(u32 add, u8 value) {
( value == '\n' && g_pbufi != 0 ) )
{
g_pbuf[g_pbufi] = 0;
DevCon.WriteLn( Color_Cyan, "%s", g_pbuf );
Console.WriteLn( ConColor_IOP, g_pbuf );
g_pbufi = 0;
}
else if( value != '\n' )
@ -1236,7 +1236,7 @@ void psxHwWrite32(u32 add, u32 value) {
//------------------------------------------------------------------
case 0x1f8014c0:
PSXHW_LOG("RTC_HOLDMODE 32bit write %lx", value);
Console.Notice("** RTC_HOLDMODE 32bit write %lx", value);
Console.Warning("** RTC_HOLDMODE 32bit write %lx", value);
break;
case 0x1f801450:

2
pcsx2/IopMem.cpp
View File

@ -57,7 +57,7 @@ void psxMemReset()
jASSUME( psxMemWLUT != NULL );
jASSUME( m_psxAllMem != NULL );
DbgCon.Status( "psxMemReset > Resetting core memory!" );
DbgCon.WriteLn( "IOP Resetting physical ram..." );
memzero_ptr<0x2000 * sizeof(uptr) * 2>( psxMemWLUT ); // clears both allocations, RLUT and WLUT
memzero_ptr<m_psxMemSize>( m_psxAllMem );

4
pcsx2/IopSio2.cpp
View File

@ -52,7 +52,7 @@ only recv2 & dataout influences padman
void sio2Reset() {
DevCon.Status( "Sio2 Reset" );
DevCon.WriteLn( "Sio2 Reset" );
memzero(sio2);
sio2.packet.recvVal1 = 0x1D100; // Nothing is connected at start
}
@ -155,7 +155,7 @@ void sio2_serialIn(u8 value){
sioWrite8(value);
if (sio2.packet.sendSize > BUFSIZE) {//asadr
Console.Notice("*PCSX2*: sendSize >= %d", BUFSIZE);
Console.Warning("*PCSX2*: sendSize >= %d", BUFSIZE);
} else {
sio2.buf[sio2.packet.sendSize] = sioRead8();
sio2.packet.sendSize++;

8
pcsx2/MTGS.cpp
View File

@ -466,7 +466,7 @@ void mtgsThreadObject::SetEvent()
void mtgsThreadObject::PrepEventWait()
{
//Console.Notice( "MTGS Stall! EE waits for nothing! ... except your GPU sometimes." );
//Console.Warning( "MTGS Stall! EE waits for nothing! ... except your GPU sometimes." );
SetEvent();
Timeslice();
}
@ -591,15 +591,15 @@ int mtgsThreadObject::PrepDataPacket( GIF_PATH pathidx, const u8* srcdata, u32 s
{
total_bucket+=ringtx_inf[i][j];
bucket_subitems++;
Console.Notice("GSRingBufCopy :tx [%d,%d] algn %d : count= %d [%.2f%%]",1<<i,(1<<(i+1))-16,1<<j,ringtx_inf[i][j],ringtx_inf[i][j]/(float)ringtx_c*100);
Console.Warning("GSRingBufCopy :tx [%d,%d] algn %d : count= %d [%.2f%%]",1<<i,(1<<(i+1))-16,1<<j,ringtx_inf[i][j],ringtx_inf[i][j]/(float)ringtx_c*100);
ringtx_inf[i][j]=0;
}
}
if (total_bucket)
Console.Notice("GSRingBufCopy :tx [%d,%d] total : count= %d [%.2f%%] [%.2f%%]",1<<i,(1<<(i+1))-16,total_bucket,total_bucket/(float)ringtx_c*100,ringtx_inf_s[i]/(float)ringtx_s*100);
Console.Warning("GSRingBufCopy :tx [%d,%d] total : count= %d [%.2f%%] [%.2f%%]",1<<i,(1<<(i+1))-16,total_bucket,total_bucket/(float)ringtx_c*100,ringtx_inf_s[i]/(float)ringtx_s*100);
ringtx_inf_s[i]=0;
}
Console.Notice("GSRingBufCopy :tx ulg count =%d [%.2f%%]",ringtx_s_ulg,ringtx_s_ulg/(float)ringtx_s*100);
Console.Warning("GSRingBufCopy :tx ulg count =%d [%.2f%%]",ringtx_s_ulg,ringtx_s_ulg/(float)ringtx_s*100);
ringtx_s_ulg=0;
ringtx_c=0;
ringtx_s=0;

8
pcsx2/Memory.cpp
View File

@ -870,10 +870,10 @@ void mmap_MarkCountedRamPage( u32 paddr )
if( m_PageProtectInfo[rampage].Mode == ProtMode_Write )
return; // skip town if we're already protected.
if( m_PageProtectInfo[rampage].Mode == ProtMode_Manual )
DbgCon.WriteLn( "dyna_page_reset @ 0x%05x", paddr>>12 );
else
DbgCon.WriteLn( "Write-protected page @ 0x%05x", paddr>>12 );
DbgCon.WriteLn( Color_Gray, (m_PageProtectInfo[rampage].Mode == ProtMode_Manual) ?
"dyna_page_reset @ 0x%05x" : "Write-protected page @ 0x%05x",
paddr>>12
);
m_PageProtectInfo[rampage].Mode = ProtMode_Write;
HostSys::MemProtect( &psM[rampage<<12], 1, Protect_ReadOnly );

26
pcsx2/PluginManager.cpp
View File

@ -662,13 +662,13 @@ static void PS2E_CALLBACK pcsx2_OSD_WriteLn( int icon, const char* msg )
PluginManager::PluginManager( const wxString (&folders)[PluginId_Count] )
{
Console.Status( "Loading plugins..." );
Console.WriteLn( Color_StrongBlue, "Loading plugins..." );
const PluginInfo* pi = tbl_PluginInfo; do
{
const PluginsEnum_t pid = pi->id;
Console.WriteLn( "\tBinding %s\t: %s ", tbl_PluginInfo[pid].shortname, folders[pid].ToUTF8().data() );
Console.WriteLn( L"\tBinding %s\t: %s ", tbl_PluginInfo[pid].GetShortname().c_str(), folders[pid].c_str() );
if( folders[pid].IsEmpty() )
throw Exception::InvalidArgument( "Empty plugin filename." );
@ -707,7 +707,7 @@ PluginManager::PluginManager( const wxString (&folders)[PluginId_Count] )
PADinit = (_PADinit)m_info[PluginId_PAD].CommonBindings.Init;
m_info[PluginId_PAD].CommonBindings.Init = _hack_PADinit;
Console.Status( "Plugins loaded successfully.\n" );
Console.WriteLn( Color_StrongBlue, "Plugins loaded successfully.\n" );
// HACK! Manually bind the Internal MemoryCard plugin for now, until
// we get things more completed in the new plugin api.
@ -906,7 +906,7 @@ void PluginManager::Open( PluginsEnum_t pid )
void PluginManager::Open()
{
Console.Status( "Opening plugins..." );
Console.WriteLn( Color_StrongBlue, "Opening plugins..." );
const PluginInfo* pi = tbl_PluginInfo; do {
Open( pi->id );
@ -918,13 +918,13 @@ void PluginManager::Open()
if (GSopen2) mtgsThread.WaitForOpen();
Console.Status( "Plugins opened successfully." );
Console.WriteLn( Color_StrongBlue, "Plugins opened successfully." );
}
void PluginManager::Close( PluginsEnum_t pid )
{
if( !m_info[pid].IsOpened ) return;
Console.Status( "\tClosing %s", tbl_PluginInfo[pid].shortname );
Console.WriteLn( "\tClosing %s", tbl_PluginInfo[pid].shortname );
if( pid == PluginId_GS )
{
@ -942,7 +942,7 @@ void PluginManager::Close( PluginsEnum_t pid )
void PluginManager::Close( bool closegs )
{
DbgCon.Status( "Closing plugins..." );
DbgCon.WriteLn( Color_StrongBlue, "Closing plugins..." );
// Close plugins in reverse order of the initialization procedure.
@ -952,7 +952,7 @@ void PluginManager::Close( bool closegs )
Close( tbl_PluginInfo[i].id );
}
DbgCon.Status( "Plugins closed successfully." );
DbgCon.WriteLn( Color_StrongBlue, "Plugins closed successfully." );
}
// Initializes all plugins. Plugin initialization should be done once for every new emulation
@ -973,7 +973,7 @@ void PluginManager::Init()
if( m_info[pid].IsInitialized ) continue;
if( !printlog )
{
Console.Status( "Initializing plugins..." );
Console.WriteLn( Color_StrongBlue, "Initializing plugins..." );
printlog = true;
}
Console.WriteLn( "\tInit %s", tbl_PluginInfo[pid].shortname );
@ -993,7 +993,7 @@ void PluginManager::Init()
}
if( printlog )
Console.Status( "Plugins initialized successfully.\n" );
Console.WriteLn( Color_StrongBlue, "Plugins initialized successfully.\n" );
}
// Shuts down all plugins. Plugins are closed first, if necessary.
@ -1007,7 +1007,7 @@ void PluginManager::Shutdown()
mtgsThread.Cancel(); // cancel it for speedier shutdown!
Close();
DbgCon.Status( "Shutting down plugins..." );
DbgCon.WriteLn( Color_StrongGreen, "Shutting down plugins..." );
// Shutdown plugins in reverse order (probably doesn't matter...
// ... but what the heck, right?)
@ -1029,7 +1029,7 @@ void PluginManager::Shutdown()
SysPlugins.Mcd = NULL;
}
DbgCon.Status( "Plugins shutdown successfully." );
DbgCon.WriteLn( Color_StrongGreen, "Plugins shutdown successfully." );
}
// For internal use only, unless you're the MTGS. Then it's for you too!
@ -1072,7 +1072,7 @@ void PluginManager::Freeze( PluginsEnum_t pid, SaveStateBase& state )
// no state data to read, but the plugin expects some state data.
// Issue a warning to console...
if( fP.size != 0 )
Console.Notice( "\tWarning: No data for this plugin was found. Plugin status may be unpredictable." );
Console.Warning( "\tWarning: No data for this plugin was found. Plugin status may be unpredictable." );
return;
// Note: Size mismatch check could also be done here on loading, but

6
pcsx2/R3000AInterpreter.cpp
View File

@ -258,15 +258,15 @@ void zeroEx()
}
if (!strncmp(lib, "loadcore", 8) && code == 6) {
DevCon.WriteLn("loadcore RegisterLibraryEntries (%x): %8.8s", psxRegs.pc, iopVirtMemR<char>(psxRegs.GPR.n.a0+12));
DevCon.WriteLn( Color_Gray, "loadcore RegisterLibraryEntries (%x): %8.8s", psxRegs.pc, iopVirtMemR<char>(psxRegs.GPR.n.a0+12));
}
if (!strncmp(lib, "intrman", 7) && code == 4) {
DevCon.WriteLn("intrman RegisterIntrHandler (%x): intr %s, handler %x", psxRegs.pc, intrname[psxRegs.GPR.n.a0], psxRegs.GPR.n.a2);
DevCon.WriteLn( Color_Gray, "intrman RegisterIntrHandler (%x): intr %s, handler %x", psxRegs.pc, intrname[psxRegs.GPR.n.a0], psxRegs.GPR.n.a2);
}
if (!strncmp(lib, "sifcmd", 6) && code == 17) {
DevCon.WriteLn("sifcmd sceSifRegisterRpc (%x): rpc_id %x", psxRegs.pc, psxRegs.GPR.n.a1);
DevCon.WriteLn( Color_Gray, "sifcmd sceSifRegisterRpc (%x): rpc_id %x", psxRegs.pc, psxRegs.GPR.n.a1);
}
if (!strncmp(lib, "sysclib", 8))

2
pcsx2/R3000AOpcodeTables.cpp
View File

@ -300,7 +300,7 @@ void psxCTC0() { _rFs_ = _u32(_rRt_); }
* Format: ? *
*********************************************************/
void psxNULL() {
Console.Notice("psx: Unimplemented op %x", psxRegs.code);
Console.Warning("psx: Unimplemented op %x", psxRegs.code);
}
void psxSPECIAL() {

18
pcsx2/R5900.cpp
View File

@ -124,7 +124,7 @@ __releaseinline void cpuException(u32 code, u32 bd)
{
//Reset / NMI
cpuRegs.pc = 0xBFC00000;
Console.Notice("Reset request");
Console.Warning("Reset request");
UpdateCP0Status();
return;
}
@ -141,7 +141,7 @@ __releaseinline void cpuException(u32 code, u32 bd)
cpuRegs.CP0.n.Status.b.EXL = 1;
if (bd)
{
Console.Notice("branch delay!!");
Console.Warning("branch delay!!");
cpuRegs.CP0.n.EPC = cpuRegs.pc - 4;
cpuRegs.CP0.n.Cause |= 0x80000000;
}
@ -154,7 +154,7 @@ __releaseinline void cpuException(u32 code, u32 bd)
else
{
offset = 0x180; //Override the cause
if (errLevel2) Console.Notice("cpuException: Status.EXL = 1 cause %x", code);
if (errLevel2) Console.Warning("cpuException: Status.EXL = 1 cause %x", code);
}
if (checkStatus)
@ -170,7 +170,7 @@ void cpuTlbMiss(u32 addr, u32 bd, u32 excode)
Console.Error("cpuTlbMiss pc:%x, cycl:%x, addr: %x, status=%x, code=%x",
cpuRegs.pc, cpuRegs.cycle, addr, cpuRegs.CP0.n.Status.val, excode);
if (bd) Console.Notice("branch delay!!");
if (bd) Console.Warning("branch delay!!");
pxFail( "TLB Miss handler is uninished code." ); // temporary
@ -325,7 +325,7 @@ static __forceinline void _cpuTestTIMR()
if ( (cpuRegs.CP0.n.Status.val & 0x8000) &&
cpuRegs.CP0.n.Count >= cpuRegs.CP0.n.Compare && cpuRegs.CP0.n.Count < cpuRegs.CP0.n.Compare+1000 )
{
Console.Status("timr intr: %x, %x", cpuRegs.CP0.n.Count, cpuRegs.CP0.n.Compare);
Console.WriteLn( Color_Magenta, "timr intr: %x, %x", cpuRegs.CP0.n.Count, cpuRegs.CP0.n.Compare);
cpuException(0x808000, cpuRegs.branch);
}
}
@ -426,7 +426,7 @@ __forceinline void _cpuBranchTest_Shared()
int cycleCount = std::min( EEsCycle, (s32)(eeWaitCycles>>4) );
int cyclesRun = cycleCount - psxCpu->ExecuteBlock( cycleCount );
EEsCycle -= cyclesRun;
//Console.Notice( "IOP Exception-Pending Execution -- EEsCycle: %d", EEsCycle );
//Console.Warning( "IOP Exception-Pending Execution -- EEsCycle: %d", EEsCycle );
}
else*/
{
@ -462,7 +462,7 @@ __forceinline void _cpuBranchTest_Shared()
// IOP extra timeslices in short order.
cpuSetNextBranchDelta( 48 );
//Console.Notice( "EE ahead of the IOP -- Rapid Branch! %d", EEsCycle );
//Console.Warning( "EE ahead of the IOP -- Rapid Branch! %d", EEsCycle );
}
// The IOP could be running ahead/behind of us, so adjust the iop's next branch by its
@ -562,7 +562,7 @@ void cpuExecuteBios()
// Set the video mode to user's default request:
gsSetRegionMode( (GS_RegionMode)EmuConfig.Video.DefaultRegionMode );
Console.Status( "Executing Bios Stub..." );
Console.WriteLn( "Executing Bios Stub..." );
g_ExecBiosHack = true;
while( cpuRegs.pc != 0x00200008 &&
@ -592,7 +592,7 @@ void cpuExecuteBios()
// with new faster versions:
Cpu->Reset();
Console.Notice("Execute Bios Stub Complete");
Console.Warning("Execute Bios Stub Complete");
//GSprintf(5, "PCSX2 " PCSX2_VERSION "\nExecuteBios Complete\n");
}

14
pcsx2/R5900OpcodeImpl.cpp
View File

@ -136,9 +136,9 @@ void Unknown() {
CPU_LOG("%8.8lx: Unknown opcode called", cpuRegs.pc);
}
void MMI_Unknown() { Console.Notice("Unknown MMI opcode called"); }
void COP0_Unknown() { Console.Notice("Unknown COP0 opcode called"); }
void COP1_Unknown() { Console.Notice("Unknown FPU/COP1 opcode called"); }
void MMI_Unknown() { Console.Warning("Unknown MMI opcode called"); }
void COP0_Unknown() { Console.Warning("Unknown COP0 opcode called"); }
void COP1_Unknown() { Console.Warning("Unknown FPU/COP1 opcode called"); }
@ -761,7 +761,7 @@ int __Deci2Call(int call, u32 *addr)
else
{
deci2handler = NULL;
DevCon.Notice( "Deci2Call.Open > NULL address ignored." );
DevCon.Warning( "Deci2Call.Open > NULL address ignored." );
}
return 1;
@ -790,7 +790,7 @@ int __Deci2Call(int call, u32 *addr)
pdeciaddr += (deci2addr[4]+0xc)%16;
memcpy(deci2buffer, pdeciaddr, deci2addr[1]-0xc);
deci2buffer[deci2addr[1]-0xc>=255?255:deci2addr[1]-0xc]='\0';
Console.Write( Color_Cyan, deci2buffer );
Console.Write( ConColor_EE, deci2buffer );
}
deci2addr[3] = 0;
return 1;
@ -809,7 +809,7 @@ int __Deci2Call(int call, u32 *addr)
case 0x10://kputs
if( addr != NULL )
Console.Write( Color_Cyan, "%s", PSM(*addr));
Console.Write( ConColor_EE, (char*)PSM(*addr) );
return 1;
}
@ -831,7 +831,7 @@ void SYSCALL()
if (call == 0x7c)
{
if(cpuRegs.GPR.n.a0.UL[0] == 0x10)
Console.Write( Color_Cyan, (char*)PSM(memRead32(cpuRegs.GPR.n.a1.UL[0])) );
Console.Write( ConColor_EE, (char*)PSM(memRead32(cpuRegs.GPR.n.a1.UL[0])) );
else
__Deci2Call( cpuRegs.GPR.n.a0.UL[0], (u32*)PSM(cpuRegs.GPR.n.a1.UL[0]) );
}

14
pcsx2/RecoverySystem.cpp
View File

@ -330,7 +330,7 @@ void OnFinished_ZipToDisk( const wxCommandEvent& evt )
if( zip_dest_filename.IsEmpty() )
{
Console.Notice( "Cannot save state to disk: empty filename specified." );
Console.Warning( "Cannot save state to disk: empty filename specified." );
return;
}
@ -358,7 +358,7 @@ void StateCopy_SaveToFile( const wxString& file )
if( state_buffer_lock.IsLocked() ) return;
zip_dest_filename = file;
(new StateThread_Freeze( OnFinished_ZipToDisk ))->Start();
Console.Status( wxsFormat( L"Saving savestate to file: %s", zip_dest_filename.c_str() ) );
Console.WriteLn( Color_StrongGreen, L"Saving savestate to file: %s", zip_dest_filename.c_str() );
}
void StateCopy_LoadFromFile( const wxString& file )
@ -378,8 +378,8 @@ void StateCopy_SaveToSlot( uint num )
zip_dest_filename = SaveStateBase::GetFilename( num );
(new StateThread_Freeze( OnFinished_ZipToDisk ))->Start();
Console.Status( "Saving savestate to slot %d...", num );
Console.Status( wxsFormat(L"\tfilename: %s", zip_dest_filename.c_str()) );
Console.WriteLn( Color_StrongGreen, "Saving savestate to slot %d...", num );
Console.WriteLn( Color_StrongGreen, L"\tfilename: %s", zip_dest_filename.c_str() );
}
void StateCopy_LoadFromSlot( uint slot )
@ -389,12 +389,12 @@ void StateCopy_LoadFromSlot( uint slot )
if( !wxFileExists( file ) )
{
Console.Notice( "Savestate slot %d is empty.", slot );
Console.Warning( "Savestate slot %d is empty.", slot );
return;
}
Console.Status( "Loading savestate from slot %d...", slot );
Console.Status( wxsFormat(L"\tfilename: %s", file.c_str()) );
Console.WriteLn( Color_StrongGreen, "Loading savestate from slot %d...", slot );
Console.WriteLn( Color_StrongGreen, L"\tfilename: %s", file.c_str() );
CoreThread.Pause();
(new StateThread_UnzipFromDisk( OnFinished_Restore, file ))->Start();

4
pcsx2/SPR.cpp
View File

@ -38,12 +38,12 @@ static void TestClearVUs(u32 madr, u32 size)
{
if (madr < 0x11004000)
{
DbgCon.Notice("scratch pad clearing vu0");
DbgCon.Warning("scratch pad clearing vu0");
CpuVU0.Clear(madr&0xfff, size);
}
else if (madr >= 0x11008000 && madr < 0x1100c000)
{
DbgCon.Notice("scratch pad clearing vu1");
DbgCon.Warning("scratch pad clearing vu1");
CpuVU1.Clear(madr&0x3fff, size);
}
}

2
pcsx2/SaveState.cpp
View File

@ -325,7 +325,7 @@ bool SaveStateBase::FreezeSection()
Freeze( size );
m_tagspace[sizeof(m_tagspace)-1] = 0;
Console.Notice(
Console.Warning(
"Warning: Unknown tag encountered while loading savestate; going to ignore it!\n"
"\tTagname: %s, Size: %d", m_tagspace, size
);

2
pcsx2/Sio.cpp
View File

@ -382,7 +382,7 @@ void SIO_CommandWrite(u8 value,int way) {
sio.buf[2]='+';
sio.buf[3]=sio.terminator;
//if (sio.k != 0 || (sio.sector & 0xf) != 0)
// Console.Notice("saving : odd position for erase.");
// Console.Warning("saving : odd position for erase.");
_EraseMCDBlock((512+16)*(sio.sector&~0xf));

34
pcsx2/System.cpp
View File

@ -45,18 +45,19 @@ SessionOverrideFlags g_Session = {false};
// This function should be called once during program execution.
void SysDetect()
{
Console.Notice("PCSX2 %d.%d.%d.r%d %s - compiled on " __DATE__, PCSX2_VersionHi, PCSX2_VersionMid, PCSX2_VersionLo,
Console.WriteLn( Color_StrongGreen, "PCSX2 %d.%d.%d.r%d %s - compiled on " __DATE__, PCSX2_VersionHi, PCSX2_VersionMid, PCSX2_VersionLo,
SVN_REV, SVN_MODS ? "(modded)" : ""
);
Console.Notice("Savestate version: %x", g_SaveVersion);
Console.WriteLn( "Savestate version: 0x%x", g_SaveVersion);
Console.Newline();
cpudetectInit();
Console.SetColor( Color_Black );
//Console.SetColor( Color_Gray );
Console.WriteLn( "x86Init:" );
Console.WriteLn( wxsFormat(
Console.WriteLn( Color_StrongBlack, "x86-32 Init:" );
Console.WriteLn(
L"\tCPU vendor name = %s\n"
L"\tFamilyID = %x\n"
L"\tx86Family = %s\n"
@ -65,14 +66,14 @@ void SysDetect()
L"\tx86PType = %s\n"
L"\tx86Flags = %8.8x %8.8x\n"
L"\tx86EFlags = %8.8x\n",
wxString::FromAscii( x86caps.VendorName ).c_str(), x86caps.StepID,
wxString::FromAscii( x86caps.FamilyName ).Trim().Trim(false).c_str(),
fromUTF8( x86caps.VendorName ).c_str(), x86caps.StepID,
fromUTF8( x86caps.FamilyName ).Trim().Trim(false).c_str(),
x86caps.Speed / 1000, x86caps.Speed%1000,
x86caps.PhysicalCores, x86caps.LogicalCores,
wxString::FromAscii( x86caps.TypeName ).c_str(),
fromUTF8( x86caps.TypeName ).c_str(),
x86caps.Flags, x86caps.Flags2,
x86caps.EFlags
) );
);
wxArrayString features[2]; // 2 lines, for readability!
@ -93,11 +94,12 @@ void SysDetect()
JoinString( result[0], features[0], L".. " );
JoinString( result[1], features[1], L".. " );
Console.WriteLn( L"Features Detected:\n\t" + result[0] + (result[1].IsEmpty() ? L"" : (L"\n\t" + result[1])) + L"\n" );
Console.ClearColor();
Console.WriteLn( Color_StrongBlack, L"x86 Features Detected:" );
Console.WriteLn( L"\t" + result[0] + (result[1].IsEmpty() ? L"" : (L"\n\t" + result[1])) + L"\n" );
//if ( x86caps.VendorName[0] == 'A' ) //AMD cpu
Console.ClearColor();
}
// returns the translated error message for the Virtual Machine failing to allocate!
@ -113,7 +115,7 @@ SysCoreAllocations::SysCoreAllocations()
{
InstallSignalHandler();
Console.Status( "Initializing PS2 virtual machine..." );
Console.WriteLn( "Initializing PS2 virtual machine..." );
RecSuccess_EE = false;
RecSuccess_IOP = false;
@ -151,7 +153,7 @@ SysCoreAllocations::SysCoreAllocations()
);
}
Console.Status( "Allocating memory for recompilers..." );
Console.WriteLn( "Allocating memory for recompilers..." );
try
{
@ -265,7 +267,7 @@ u8 *SysMmapEx(uptr base, u32 size, uptr bounds, const char *caller)
if( (Mem == NULL) || (bounds != 0 && (((uptr)Mem + size) > bounds)) )
{
DevCon.Notice( "First try failed allocating %s at address 0x%x", caller, base );
DevCon.Warning( "First try failed allocating %s at address 0x%x", caller, base );
// memory allocation *must* have the top bit clear, so let's try again
// with NULL (let the OS pick something for us).
@ -275,7 +277,7 @@ u8 *SysMmapEx(uptr base, u32 size, uptr bounds, const char *caller)
Mem = (u8*)HostSys::Mmap( NULL, size );
if( bounds != 0 && (((uptr)Mem + size) > bounds) )
{
DevCon.Error( "Fatal Error:\n\tSecond try failed allocating %s, block ptr 0x%x does not meet required criteria.", caller, Mem );
DevCon.Warning( "Fatal Error:\n\tSecond try failed allocating %s, block ptr 0x%x does not meet required criteria.", caller, Mem );
SafeSysMunmap( Mem, size );
// returns NULL, caller should throw an exception.

4
pcsx2/VU0.cpp
View File

@ -75,7 +75,7 @@ __forceinline void _vu0run(bool breakOnMbit) {
do {
// knockout kings 2002 loops here with sVU
if (breakOnMbit && (VU0.cycle-startcycle > 0x1000)) {
Console.Notice("VU0 perma-stall, breaking execution...");
Console.Warning("VU0 perma-stall, breaking execution...");
break; // mVU will never get here (it handles mBit internally)
}
CpuVU0.ExecuteBlock();
@ -354,7 +354,7 @@ void vu0Finish()
if(VU0.VI[REG_VPU_STAT].UL & 0x1) {
VU0.VI[REG_VPU_STAT].UL &= ~1;
// this log tends to spam a lot (MGS3)
//Console.Notice("vu0Finish > stall aborted by force.");
//Console.Warning("vu0Finish > stall aborted by force.");
}
}
}

2
pcsx2/VU0micro.cpp
View File

@ -54,7 +54,7 @@ void __fastcall vu0ExecMicro(u32 addr) {
VUM_LOG("vu0ExecMicro %x", addr);
if(VU0.VI[REG_VPU_STAT].UL & 0x1) {
DevCon.Notice("vu0ExecMicro > Stalling for previous microprogram to finish");
DevCon.Warning("vu0ExecMicro > Stalling for previous microprogram to finish");
vu0Finish();
}
VU0.VI[REG_VPU_STAT].UL|= 0x1;

6
pcsx2/VU0microInterp.cpp
View File

@ -106,7 +106,7 @@ static void _vu0Exec(VURegs* VU)
vfreg = 0; vireg = 0;
if (uregs.VFwrite) {
if (lregs.VFwrite == uregs.VFwrite) {
// Console.Notice("*PCSX2*: Warning, VF write to the same reg in both lower/upper cycle");
// Console.Warning("*PCSX2*: Warning, VF write to the same reg in both lower/upper cycle");
discard = 1;
}
if (lregs.VFread0 == uregs.VFwrite ||
@ -118,7 +118,7 @@ static void _vu0Exec(VURegs* VU)
}
if (uregs.VIread & (1 << REG_CLIP_FLAG)) {
if (lregs.VIwrite & (1 << REG_CLIP_FLAG)) {
Console.Notice("*PCSX2*: Warning, VI write to the same reg in both lower/upper cycle");
Console.Warning("*PCSX2*: Warning, VI write to the same reg in both lower/upper cycle");
discard = 1;
}
if (lregs.VIread & (1 << REG_CLIP_FLAG)) {
@ -176,7 +176,7 @@ void vu0Exec(VURegs* VU)
{
if (VU->VI[REG_TPC].UL >= VU->maxmicro) {
#ifdef CPU_LOG
Console.Notice("VU0 memory overflow!!: %x", VU->VI[REG_TPC].UL);
Console.Warning("VU0 memory overflow!!: %x", VU->VI[REG_TPC].UL);
#endif
VU0.VI[REG_VPU_STAT].UL&= ~0x1;
} else {

4
pcsx2/VU1microInterp.cpp
View File

@ -102,7 +102,7 @@ static void _vu1Exec(VURegs* VU)
vfreg = 0; vireg = 0;
if (uregs.VFwrite) {
if (lregs.VFwrite == uregs.VFwrite) {
// Console.Notice("*PCSX2*: Warning, VF write to the same reg in both lower/upper cycle");
// Console.Warning("*PCSX2*: Warning, VF write to the same reg in both lower/upper cycle");
discard = 1;
}
if (lregs.VFread0 == uregs.VFwrite ||
@ -114,7 +114,7 @@ static void _vu1Exec(VURegs* VU)
}
if (uregs.VIread & (1 << REG_CLIP_FLAG)) {
if (lregs.VIwrite & (1 << REG_CLIP_FLAG)) {
Console.Notice("*PCSX2*: Warning, VI write to the same reg in both lower/upper cycle");
Console.Warning("*PCSX2*: Warning, VI write to the same reg in both lower/upper cycle");
discard = 1;
}
if (lregs.VIread & (1 << REG_CLIP_FLAG)) {

4
pcsx2/VUops.cpp
View File

@ -2064,10 +2064,10 @@ void _vuXGKICK(VURegs * VU)
if((size << 4) > (u32)(0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)))
{
//DevCon.Notice("addr + Size = 0x%x, transferring %x then doing %x", ((VU->VI[_Is_].US[0]*16) & 0x3fff) + (size << 4), (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)) >> 4, size - (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff) >> 4));
//DevCon.Warning("addr + Size = 0x%x, transferring %x then doing %x", ((VU->VI[_Is_].US[0]*16) & 0x3fff) + (size << 4), (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)) >> 4, size - (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff) >> 4));
memcpy_aligned(pmem, (u8*)VU->Mem+((VU->VI[_Is_].US[0]*16) & 0x3fff), 0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff));
size -= (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)) >> 4;
//DevCon.Notice("Size left %x", size);
//DevCon.Warning("Size left %x", size);
pmem += 0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff);
memcpy_aligned(pmem, (u8*)VU->Mem, size<<4);
}

4
pcsx2/Vif0Dma.cpp
View File

@ -197,7 +197,7 @@ static int __fastcall Vif0TransMPG(u32 *data) // MPG
{
if (vif0.vifpacketsize < vif0.tag.size)
{
if((vif0.tag.addr + vif0.vifpacketsize) > 0x1000) DevCon.Notice("Vif0 MPG Split Overflow");
if((vif0.tag.addr + vif0.vifpacketsize) > 0x1000) DevCon.Warning("Vif0 MPG Split Overflow");
vif0mpgTransfer(vif0.tag.addr, data, vif0.vifpacketsize);
vif0.tag.addr += vif0.vifpacketsize << 2;
@ -209,7 +209,7 @@ static int __fastcall Vif0TransMPG(u32 *data) // MPG
{
int ret;
if((vif0.tag.addr + vif0.tag.size) > 0x1000) DevCon.Notice("Vif0 MPG Overflow");
if((vif0.tag.addr + vif0.tag.size) > 0x1000) DevCon.Warning("Vif0 MPG Overflow");
vif0mpgTransfer(vif0.tag.addr, data, vif0.tag.size);
ret = vif0.tag.size;

4
pcsx2/Vif1Dma.cpp
View File

@ -211,7 +211,7 @@ static int __fastcall Vif1TransMPG(u32 *data)
{
if (vif1.vifpacketsize < vif1.tag.size)
{
if((vif1.tag.addr + vif1.vifpacketsize) > 0x4000) DevCon.Notice("Vif1 MPG Split Overflow");
if((vif1.tag.addr + vif1.vifpacketsize) > 0x4000) DevCon.Warning("Vif1 MPG Split Overflow");
vif1mpgTransfer(vif1.tag.addr, data, vif1.vifpacketsize);
vif1.tag.addr += vif1.vifpacketsize << 2;
vif1.tag.size -= vif1.vifpacketsize;
@ -220,7 +220,7 @@ static int __fastcall Vif1TransMPG(u32 *data)
else
{
int ret;
if((vif1.tag.addr + vif1.tag.size) > 0x4000) DevCon.Notice("Vif1 MPG Overflow");
if((vif1.tag.addr + vif1.tag.size) > 0x4000) DevCon.Warning("Vif1 MPG Overflow");
vif1mpgTransfer(vif1.tag.addr, data, vif1.tag.size);
ret = vif1.tag.size;
vif1.tag.size = 0;

16
pcsx2/VifDma.cpp
View File

@ -333,7 +333,7 @@ template<const u32 VIFdmanum> u32 VIFalign(u32 *data, vifCode *v, u32 size)
}
else
{
DevCon.Notice("Offset = %x", vifRegs->offset);
DevCon.Warning("Offset = %x", vifRegs->offset);
vif->tag.addr += unpacksize * 4;
return size>>2;
}
@ -440,7 +440,7 @@ template<const u32 VIFdmanum> u32 VIFalign(u32 *data, vifCode *v, u32 size)
/* unpack one qword */
if(vif->tag.addr + ((size / ft->dsize) * 4) >= (u32)vif_size(VIFdmanum))
{
//DevCon.Notice("Overflow");
//DevCon.Warning("Overflow");
vif->tag.addr &= (u32)(vif_size(VIFdmanum) - 1);
dest = (u32*)(VU->Mem + v->addr);
}
@ -532,7 +532,7 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
{
if (v->addr >= memlimit)
{
//DevCon.Notice("Overflown at the start");
//DevCon.Warning("Overflown at the start");
v->addr &= (memlimit - 1);
dest = (u32*)(VU->Mem + v->addr);
}
@ -557,7 +557,7 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
}
else
{
//DevCon.Notice("VIF%x Unpack ending %x > %x", VIFdmanum, tempsize, VIFdmanum ? 0x4000 : 0x1000);
//DevCon.Warning("VIF%x Unpack ending %x > %x", VIFdmanum, tempsize, VIFdmanum ? 0x4000 : 0x1000);
tempsize = size;
size = 0;
}
@ -679,7 +679,7 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
int incdest = ((vifRegs->cycle.cl - vifRegs->cycle.wl) << 2) + 4;
size = 0;
int addrstart = v->addr;
if((tempsize >> 2) != vif->tag.size) DevCon.Notice("split when size != tagsize");
if((tempsize >> 2) != vif->tag.size) DevCon.Warning("split when size != tagsize");
VIFUNPACK_LOG("sorting tempsize :p, size %d, vifnum %d, addr %x", tempsize, vifRegs->num, vif->tag.addr);
@ -687,7 +687,7 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
{
if(v->addr >= memlimit)
{
DevCon.Notice("Mem limit overflow");
DevCon.Warning("Mem limit overflow");
v->addr &= (memlimit - 1);
dest = (u32*)(VU->Mem + v->addr);
}
@ -756,9 +756,9 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
if(vifRegs->cycle.cl > 0) // Quicker and avoids zero division :P
if((u32)(((size / ft->gsize) / vifRegs->cycle.cl) * vifRegs->cycle.wl) < vifRegs->num)
DevCon.Notice("Filling write warning! %x < %x and CL = %x WL = %x", (size / ft->gsize), vifRegs->num, vifRegs->cycle.cl, vifRegs->cycle.wl);
DevCon.Warning("Filling write warning! %x < %x and CL = %x WL = %x", (size / ft->gsize), vifRegs->num, vifRegs->cycle.cl, vifRegs->cycle.wl);
//DevCon.Notice("filling write %d cl %d, wl %d mask %x mode %x unpacktype %x addr %x", vifRegs->num, vifRegs->cycle.cl, vifRegs->cycle.wl, vifRegs->mask, vifRegs->mode, unpackType, vif->tag.addr);
//DevCon.Warning("filling write %d cl %d, wl %d mask %x mode %x unpacktype %x addr %x", vifRegs->num, vifRegs->cycle.cl, vifRegs->cycle.wl, vifRegs->mask, vifRegs->mode, unpackType, vif->tag.addr);
while (vifRegs->num > 0)
{
if (vif->cl == vifRegs->cycle.wl)

2
pcsx2/gui/AppConfig.cpp
View File

@ -535,7 +535,7 @@ void RelocateLogfile()
if( (emuLog != NULL) && (emuLogName != newlogname) )
{
Console.Status( wxsFormat(L"\nRelocating Logfile...\n\tFrom: %s\n\tTo : %s\n", emuLogName.c_str(), newlogname.c_str()) );
Console.WriteLn( L"\nRelocating Logfile...\n\tFrom: %s\n\tTo : %s\n", emuLogName.c_str(), newlogname.c_str() );
wxGetApp().DisableDiskLogging();
fclose( emuLog );

2
pcsx2/gui/AppCoreThread.cpp
View File

@ -77,7 +77,7 @@ void AppCoreThread::Resume()
sApp.SysExecute();
}
else
Console.Status( "SysResume: Multiple resume retries failed. Giving up..." );
Console.WriteLn( Color_Orange, "SysResume: Multiple resume retries failed. Giving up..." );
}
}

6
pcsx2/gui/AppInit.cpp
View File

@ -68,7 +68,7 @@ void Pcsx2App::ReadUserModeSettings()
wxDirName usrlocaldir( wxStandardPaths::Get().GetUserLocalDataDir() );
if( !usrlocaldir.Exists() )
{
Console.Status( L"Creating UserLocalData folder: " + usrlocaldir.ToString() );
Console.WriteLn( L"Creating UserLocalData folder: " + usrlocaldir.ToString() );
usrlocaldir.Mkdir();
}
@ -199,7 +199,7 @@ bool Pcsx2App::OnCmdLineParsed( wxCmdLineParser& parser )
OverrideOptions.Filenames.Plugins[pi->id] = dest;
if( wxFileExists( dest ) )
Console.Notice( pi->GetShortname() + L" override: " + dest );
Console.Warning( pi->GetShortname() + L" override: " + dest );
else
{
bool result = Msgbox::OkCancel(
@ -335,7 +335,7 @@ bool Pcsx2App::OnInit()
// ----------------------------------------------------------------------------
catch( Exception::StartupAborted& ex )
{
Console.Notice( ex.FormatDiagnosticMessage() );
Console.Warning( ex.FormatDiagnosticMessage() );
CleanupMess();
return false;
}

6
pcsx2/gui/AppMain.cpp
View File

@ -224,13 +224,13 @@ void Pcsx2App::HandleEvent(wxEvtHandler *handler, wxEventFunction func, wxEvent&
// ----------------------------------------------------------------------------
catch( Exception::CancelEvent& ex )
{
Console.Notice( ex.FormatDiagnosticMessage() );
Console.Warning( ex.FormatDiagnosticMessage() );
}
// ----------------------------------------------------------------------------
catch( Exception::BadSavedState& ex)
{
// Saved state load failed.
Console.Notice( ex.FormatDiagnosticMessage() );
Console.Warning( ex.FormatDiagnosticMessage() );
CoreThread.Resume();
}
// ----------------------------------------------------------------------------
@ -524,7 +524,7 @@ __forceinline bool SysHasValidState()
void SysStatus( const wxString& text )
{
// mirror output to the console!
Console.Status( text.c_str() );
Console.WriteLn( text.c_str() );
sMainFrame.SetStatusText( text );
}

31
pcsx2/gui/ConsoleLogger.cpp
View File

@ -96,7 +96,7 @@ void pxLogConsole::DoLog( wxLogLevel level, const wxChar *szString, time_t t )
break;
case wxLOG_Warning:
Console.Notice( wxString(L"wx > ") + szString );
Console.Warning( wxString(L"wx > ") + szString );
break;
}
}
@ -111,8 +111,8 @@ void ConsoleTestThread::ExecuteTaskInThread()
{
// Two lines, both formatted, and varied colors. This makes for a fairly realistic
// worst case scenario (without being entirely unrealistic).
Console.WriteLn( wxsFormat( L"This is a threaded logging test. Something bad could happen... %d", ++numtrack ) );
Console.Status( wxsFormat( L"Testing high stress loads %s", L"(multi-color)" ) );
Console.WriteLn( L"This is a threaded logging test. Something bad could happen... %d", ++numtrack );
Console.Warning( L"Testing high stress loads %s", L"(multi-color)" );
Yield( 0 );
}
}
@ -165,7 +165,7 @@ static bool OpenLogFile(wxFile& file, wxString& filename, wxWindow *parent)
// (actual font used is the system-selected fixed-width font)
//
ConsoleLogFrame::ColorArray::ColorArray( int fontsize ) :
m_table( 8 )
m_table( ConsoleColors_Count )
{
Create( fontsize );
}
@ -177,18 +177,27 @@ ConsoleLogFrame::ColorArray::~ColorArray()
void ConsoleLogFrame::ColorArray::Create( int fontsize )
{
wxFont fixed( fontsize, wxMODERN, wxNORMAL, wxNORMAL );
wxFont fixedB( fontsize, wxMODERN, wxNORMAL, wxBOLD );
const wxFont fixed( fontsize, wxMODERN, wxNORMAL, wxNORMAL );
const wxFont fixedB( fontsize, wxMODERN, wxNORMAL, wxBOLD );
// Standard R, G, B format:
new (&m_table[Color_Black]) wxTextAttr( wxColor( 0, 0, 0 ), wxNullColour, fixed );
new (&m_table[Color_Red]) wxTextAttr( wxColor( 128, 0, 0 ), wxNullColour, fixedB );
new (&m_table[Color_Red]) wxTextAttr( wxColor( 128, 0, 0 ), wxNullColour, fixed );
new (&m_table[Color_Green]) wxTextAttr( wxColor( 0, 128, 0 ), wxNullColour, fixed );
new (&m_table[Color_Blue]) wxTextAttr( wxColor( 0, 0, 128 ), wxNullColour, fixed );
new (&m_table[Color_Yellow]) wxTextAttr( wxColor( 160, 160, 0 ), wxNullColour, fixedB );
new (&m_table[Color_Cyan]) wxTextAttr( wxColor( 0, 140, 140 ), wxNullColour, fixed );
new (&m_table[Color_Magenta]) wxTextAttr( wxColor( 160, 0, 160 ), wxNullColour, fixed );
new (&m_table[Color_White]) wxTextAttr( wxColor( 128, 128, 128 ), wxNullColour, fixed );
new (&m_table[Color_Orange]) wxTextAttr( wxColor( 160, 120, 0 ), wxNullColour, fixed );
new (&m_table[Color_Gray]) wxTextAttr( wxColor( 108, 108, 108 ), wxNullColour, fixed );
new (&m_table[Color_Cyan]) wxTextAttr( wxColor( 128, 180, 180 ), wxNullColour, fixed );
new (&m_table[Color_Yellow]) wxTextAttr( wxColor( 180, 180, 128 ), wxNullColour, fixed );
new (&m_table[Color_White]) wxTextAttr( wxColor( 160, 160, 160 ), wxNullColour, fixed );
new (&m_table[Color_StrongBlack]) wxTextAttr( wxColor( 0, 0, 0 ), wxNullColour, fixedB );
new (&m_table[Color_StrongRed]) wxTextAttr( wxColor( 128, 0, 0 ), wxNullColour, fixedB );
new (&m_table[Color_StrongGreen]) wxTextAttr( wxColor( 0, 128, 0 ), wxNullColour, fixedB );
new (&m_table[Color_StrongBlue]) wxTextAttr( wxColor( 0, 0, 128 ), wxNullColour, fixedB );
new (&m_table[Color_StrongOrange]) wxTextAttr( wxColor( 160, 120, 0 ), wxNullColour, fixedB );
}
void ConsoleLogFrame::ColorArray::Cleanup()
@ -213,7 +222,7 @@ void ConsoleLogFrame::ColorArray::SetFont( int fontsize )
Create( fontsize );
}
static const ConsoleColors DefaultConsoleColor = Color_White;
static const ConsoleColors DefaultConsoleColor = Color_Black;
enum MenuIDs_t
{

10
pcsx2/gui/GlobalCommands.cpp
View File

@ -151,7 +151,7 @@ namespace Implementations
{
#ifdef PCSX2_DEVBUILD
iDumpRegisters(cpuRegs.pc, 0);
Console.Notice("hardware registers dumped EE:%x, IOP:%x\n", cpuRegs.pc, psxRegs.pc);
Console.Warning("hardware registers dumped EE:%x, IOP:%x\n", cpuRegs.pc, psxRegs.pc);
#endif
}
}
@ -261,10 +261,10 @@ void AcceleratorDictionary::Map( const KeyAcceleratorCode& acode, const char *se
if( result != NULL )
{
Console.Notice( wxsFormat(
Console.Warning(
L"Kbd Accelerator '%s' is mapped multiple times.\n"
L"\t'Command %s' is being replaced by '%s'",
acode.ToString().c_str(), fromUTF8( result->Id ).c_str(), searchfor )
acode.ToString().c_str(), fromUTF8( result->Id ).c_str(), searchfor
);
}
@ -272,8 +272,8 @@ void AcceleratorDictionary::Map( const KeyAcceleratorCode& acode, const char *se
if( result == NULL )
{
Console.Notice( wxsFormat( L"Kbd Accelerator '%s' is mapped to unknown command '%s'",
acode.ToString().c_str(), fromUTF8( searchfor ).c_str() )
Console.Warning( L"Kbd Accelerator '%s' is mapped to unknown command '%s'",
acode.ToString().c_str(), fromUTF8( searchfor ).c_str()
);
}
else

8
pcsx2/gui/IniInterface.cpp
View File

@ -174,9 +174,9 @@ void IniLoader::_EnumEntry( const wxString& var, int& value, const wxChar* const
if( enumArray[i] == NULL )
{
Console.Notice( wxsFormat( L"Loadini Warning: Unrecognized value '%s' on key '%s'\n\tUsing the default setting of '%s'.",
Console.Warning( L"Loadini Warning: Unrecognized value '%s' on key '%s'\n\tUsing the default setting of '%s'.",
retval.c_str(), var.c_str(), enumArray[defvalue]
) );
);
value = defvalue;
}
else
@ -258,11 +258,11 @@ void IniSaver::_EnumEntry( const wxString& var, int& value, const wxChar* const*
const int cnt = _calcEnumLength( enumArray );
if( value >= cnt )
{
Console.Notice( wxsFormat(
Console.Warning(
L"Settings Warning: An illegal enumerated index was detected when saving '%s'\n"
L"\tIllegal Value: %d\n"
L"\tUsing Default: %d (%s)\n",
var.c_str(), value, defvalue, enumArray[defvalue] )
var.c_str(), value, defvalue, enumArray[defvalue]
);
// Cause a debug assertion, since this is a fully recoverable error.

2
pcsx2/gui/MainFrame.cpp
View File

@ -158,7 +158,7 @@ void MainEmuFrame::OnMoveAround( wxMoveEvent& evt )
// while the logger spams itself)
// ... makes for a good test of the message pump's responsiveness.
if( EnableThreadedLoggingTest )
Console.Notice( "Threaded Logging Test! (a window move event)" );
Console.Warning( "Threaded Logging Test! (a window move event)" );
// evt.GetPosition() returns the client area position, not the window frame position.
// So read the window's screen-relative position directly.

2
pcsx2/gui/MemoryCardFile.cpp
View File

@ -191,7 +191,7 @@ s32 FileMemoryCard::Save( uint port, uint slot, const u8 *src, u32 adr, int size
for (int i=0; i<size; i++)
{
if ((m_currentdata[i] & src[i]) != src[i])
Console.Notice("MemoryCard: (warning) writing to uncleared data.");
Console.Warning("MemoryCard: (warning) writing to uncleared data.");
m_currentdata[i] &= src[i];
}

10
pcsx2/gui/Panels/PluginSelectorPanel.cpp
View File

@ -109,7 +109,7 @@ public:
if ( ((version >> 16)&0xff) == tbl_PluginInfo[pluginTypeIndex].version )
return true;
Console.Notice("%s Plugin %s: Version %x != %x", info.shortname, m_plugpath.c_str(), 0xff&(version >> 16), info.version);
Console.Warning("%s Plugin %s: Version %x != %x", info.shortname, m_plugpath.c_str(), 0xff&(version >> 16), info.version);
}
return false;
}
@ -551,7 +551,7 @@ Panels::PluginSelectorPanel::EnumThread::EnumThread( PluginSelectorPanel& master
void Panels::PluginSelectorPanel::EnumThread::DoNextPlugin( int curidx )
{
DbgCon.WriteLn( L"Enumerating Plugin: " + m_master.GetFilename( curidx ) );
DbgCon.WriteLn( L"\tEnumerating Plugin: " + m_master.GetFilename( curidx ) );
try
{
@ -574,7 +574,7 @@ void Panels::PluginSelectorPanel::EnumThread::DoNextPlugin( int curidx )
}
catch( Exception::BadStream& ex )
{
Console.Status( ex.FormatDiagnosticMessage() );
Console.Warning( ex.FormatDiagnosticMessage() );
}
wxCommandEvent yay( pxEVT_EnumeratedNext );
@ -585,7 +585,7 @@ void Panels::PluginSelectorPanel::EnumThread::DoNextPlugin( int curidx )
void Panels::PluginSelectorPanel::EnumThread::ExecuteTaskInThread()
{
DevCon.Status( "Plugin Enumeration Thread started..." );
DevCon.WriteLn( "Plugin Enumeration Thread started..." );
wxGetApp().Ping(); // gives the gui thread some time to refresh
Yield( 3 );
@ -602,5 +602,5 @@ void Panels::PluginSelectorPanel::EnumThread::ExecuteTaskInThread()
done.SetClientData( this );
m_master.GetEventHandler()->AddPendingEvent( done );
DevCon.Status( "Plugin Enumeration Thread complete!" );
DevCon.WriteLn( "Plugin Enumeration Thread complete!" );
}

2
pcsx2/gui/Saveslots.cpp
View File

@ -57,7 +57,7 @@ void States_DefrostCurrentSlot()
static void OnSlotChanged()
{
Console.Notice( " > Selected savestate slot %d", StatesC);
Console.Warning( " > Selected savestate slot %d", StatesC);
if( GSchangeSaveState != NULL )
GSchangeSaveState(StatesC, SaveStateBase::GetFilename(StatesC).mb_str());

14
pcsx2/gui/i18n.cpp
View File

@ -140,8 +140,8 @@ const wxChar* __fastcall pxGetTranslation( const wxChar* message )
{
if( wxStrlen( message ) > 96 )
{
Console.Notice( "pxGetTranslation: Long message detected, maybe use pxE() instead?" );
Console.Status( wxsFormat( L"\tMessage: %s", message ) );
Console.Warning( "pxGetTranslation: Long message detected, maybe use pxE() instead?" );
Console.WriteLn( Color_Green, L"\tMessage: %s", message );
}
}
return wxGetTranslation( message );
@ -152,7 +152,7 @@ bool i18n_SetLanguage( int wxLangId )
{
if( !wxLocale::IsAvailable( wxLangId ) )
{
Console.Notice( "Invalid Language Identifier (wxID=%d).", wxLangId );
Console.Warning( "Invalid Language Identifier (wxID=%d).", wxLangId );
return false;
}
@ -160,8 +160,8 @@ bool i18n_SetLanguage( int wxLangId )
if( !locale->IsOk() )
{
Console.Notice( wxsFormat( L"SetLanguage: '%s' [%s] is not supported by the operating system",
wxLocale::GetLanguageName( locale->GetLanguage() ).c_str(), locale->GetCanonicalName().c_str() )
Console.Warning( L"SetLanguage: '%s' [%s] is not supported by the operating system",
wxLocale::GetLanguageName( locale->GetLanguage() ).c_str(), locale->GetCanonicalName().c_str()
);
safe_delete( locale );
@ -170,8 +170,8 @@ bool i18n_SetLanguage( int wxLangId )
if( !IsEnglish(wxLangId) && !locale->AddCatalog( L"pcsx2main" ) )
{
Console.Notice( wxsFormat( L"SetLanguage: Cannot find pcsx2main.mo file for language '%s' [%s]",
wxLocale::GetLanguageName( locale->GetLanguage() ).c_str(), locale->GetCanonicalName().c_str() )
Console.Warning( L"SetLanguage: Cannot find pcsx2main.mo file for language '%s' [%s]",
wxLocale::GetLanguageName( locale->GetLanguage() ).c_str(), locale->GetCanonicalName().c_str()
);
safe_delete( locale );
return false;

4
pcsx2/ps2/BiosTools.cpp
View File

@ -122,7 +122,7 @@ static void loadBiosRom( const wxChar *ext, u8 *dest, s64 maxSize )
Bios1 = Path::ReplaceExtension( Bios, ext );
if( (filesize=Path::GetFileSize( Bios1 ) ) <= 0 )
{
Console.Notice( "Load Bios Warning: %s not found (this is not an error!)", wxString(ext).ToAscii().data() );
Console.Warning( "Load Bios Warning: %s not found (this is not an error!)", wxString(ext).ToAscii().data() );
return;
}
}
@ -167,7 +167,7 @@ void LoadBIOS()
}
BiosVersion = GetBiosVersion();
Console.Status("Bios Version %d.%d", BiosVersion >> 8, BiosVersion & 0xff);
Console.WriteLn("Bios Version %d.%d", BiosVersion >> 8, BiosVersion & 0xff);
//injectIRX("host.irx"); //not fully tested; still buggy

2
pcsx2/ps2/GIFpath.cpp
View File

@ -196,7 +196,7 @@ static void __fastcall RegHandlerUNMAPPED(const u32* data)
// silently ignored.
if( regidx != 0x7f && regidx != 0xee )
Console.Notice( "Ignoring Unmapped GIFtag Register, Index = %02x", regidx );
Console.Warning( "Ignoring Unmapped GIFtag Register, Index = %02x", regidx );
}
#define INSERT_UNMAPPED_4 RegHandlerUNMAPPED, RegHandlerUNMAPPED, RegHandlerUNMAPPED, RegHandlerUNMAPPED,

6
pcsx2/ps2/Iop/IopHwRead.cpp
View File

@ -48,12 +48,12 @@ mem8_t __fastcall iopHwRead8_Page1( u32 addr )
default:
if( masked_addr >= 0x100 && masked_addr < 0x130 )
{
DevCon.Notice( "HwRead8 from Counter16 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
DevCon.Warning( "HwRead8 from Counter16 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
ret = psxHu8( addr );
}
else if( masked_addr >= 0x480 && masked_addr < 0x4a0 )
{
DevCon.Notice( "HwRead8 from Counter32 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
DevCon.Warning( "HwRead8 from Counter32 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
ret = psxHu8( addr );
}
else if( (masked_addr >= pgmsk(HW_USB_START)) && (masked_addr < pgmsk(HW_USB_END)) )
@ -213,7 +213,7 @@ static __forceinline T _HwRead_16or32_Page1( u32 addr )
ret = SPU2read( addr );
else
{
DevCon.Notice( "HwRead32 from SPU2? (addr=0x%08X) .. What manner of trickery is this?!", addr );
DevCon.Warning( "HwRead32 from SPU2? (addr=0x%08X) .. What manner of trickery is this?!", addr );
ret = psxHu32(addr);
}
}

26
pcsx2/ps2/Iop/IopHwWrite.cpp
View File

@ -60,7 +60,7 @@ mem32_t __fastcall iopHwRead32_generic( u32 addr ) { return _generic_read<mem32_
void __fastcall iopHwWrite8_Page1( u32 addr, mem8_t val )
{
// all addresses are assumed to be prefixed with 0x1f801xxx:
jASSUME( (addr >> 12) == 0x1f801 );
pxAssert( (addr >> 12) == 0x1f801 );
u32 masked_addr = pgmsk( addr );
@ -81,12 +81,12 @@ void __fastcall iopHwWrite8_Page1( u32 addr, mem8_t val )
default:
if( masked_addr >= 0x100 && masked_addr < 0x130 )
{
DevCon.Notice( "HwWrite8 to Counter16 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
DevCon.Warning( "HwWrite8 to Counter16 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
psxHu8( addr ) = val;
}
else if( masked_addr >= 0x480 && masked_addr < 0x4a0 )
{
DevCon.Notice( "HwWrite8 to Counter32 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
DevCon.Warning( "HwWrite8 to Counter32 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
psxHu8( addr ) = val;
}
else if( masked_addr >= pgmsk(HW_USB_START) && masked_addr < pgmsk(HW_USB_END) )
@ -109,7 +109,7 @@ static int g_pbufi;
void __fastcall iopHwWrite8_Page3( u32 addr, mem8_t val )
{
// all addresses are assumed to be prefixed with 0x1f803xxx:
jASSUME( (addr >> 12) == 0x1f803 );
pxAssert( (addr >> 12) == 0x1f803 );
if( addr == 0x1f80380c ) // STDOUT
{
@ -119,7 +119,7 @@ void __fastcall iopHwWrite8_Page3( u32 addr, mem8_t val )
( val == '\n' && g_pbufi != 0 ) )
{
g_pbuf[g_pbufi] = 0;
DevCon.WriteLn( Color_Cyan, g_pbuf );
Console.WriteLn( ConColor_IOP, g_pbuf );
g_pbufi = 0;
}
else if( val != '\n' )
@ -135,7 +135,7 @@ void __fastcall iopHwWrite8_Page3( u32 addr, mem8_t val )
void __fastcall iopHwWrite8_Page8( u32 addr, mem8_t val )
{
// all addresses are assumed to be prefixed with 0x1f808xxx:
jASSUME( (addr >> 12) == 0x1f808 );
pxAssert( (addr >> 12) == 0x1f808 );
if( addr == HW_SIO2_DATAIN ) // sio2 serial data feed input
sio2_serialIn( val );
@ -153,10 +153,10 @@ template< typename T >
static __forceinline void _HwWrite_16or32_Page1( u32 addr, T val )
{
// all addresses are assumed to be prefixed with 0x1f801xxx:
jASSUME( (addr >> 12) == 0x1f801 );
pxAssert( (addr >> 12) == 0x1f801 );
// all addresses should be aligned to the data operand size:
jASSUME(
pxAssert(
( sizeof(T) == 2 && (addr & 1) == 0 ) ||
( sizeof(T) == 4 && (addr & 3) == 0 )
);
@ -237,7 +237,7 @@ static __forceinline void _HwWrite_16or32_Page1( u32 addr, T val )
SPU2write( addr, val );
else
{
DevCon.Notice( "HwWrite32 to SPU2? (addr=0x%08X) .. What manner of trickery is this?!", addr );
DevCon.Warning( "HwWrite32 to SPU2? (addr=0x%08X) .. What manner of trickery is this?!", addr );
//psxHu(addr) = val;
}
}
@ -466,7 +466,7 @@ void __fastcall iopHwWrite16_Page1( u32 addr, mem16_t val )
void __fastcall iopHwWrite16_Page3( u32 addr, mem16_t val )
{
// all addresses are assumed to be prefixed with 0x1f803xxx:
jASSUME( (addr >> 12) == 0x1f803 );
pxAssert( (addr >> 12) == 0x1f803 );
psxHu16(addr) = val;
PSXHW_LOG( "HwWrite16 to %s, addr 0x%08x = 0x%04x", _log_GetIopHwName<mem16_t>( addr ), addr, val );
}
@ -474,7 +474,7 @@ void __fastcall iopHwWrite16_Page3( u32 addr, mem16_t val )
void __fastcall iopHwWrite16_Page8( u32 addr, mem16_t val )
{
// all addresses are assumed to be prefixed with 0x1f808xxx:
jASSUME( (addr >> 12) == 0x1f808 );
pxAssert( (addr >> 12) == 0x1f808 );
psxHu16(addr) = val;
PSXHW_LOG( "HwWrite16 to %s, addr 0x%08x = 0x%04x", _log_GetIopHwName<mem16_t>( addr ), addr, val );
}
@ -489,7 +489,7 @@ void __fastcall iopHwWrite32_Page1( u32 addr, mem32_t val )
void __fastcall iopHwWrite32_Page3( u32 addr, mem32_t val )
{
// all addresses are assumed to be prefixed with 0x1f803xxx:
jASSUME( (addr >> 12) == 0x1f803 );
pxAssert( (addr >> 12) == 0x1f803 );
psxHu16(addr) = val;
PSXHW_LOG( "HwWrite32 to %s, addr 0x%08x = 0x%04x", _log_GetIopHwName<mem32_t>( addr ), addr, val );
}
@ -497,7 +497,7 @@ void __fastcall iopHwWrite32_Page3( u32 addr, mem32_t val )
void __fastcall iopHwWrite32_Page8( u32 addr, mem32_t val )
{
// all addresses are assumed to be prefixed with 0x1f808xxx:
jASSUME( (addr >> 12) == 0x1f808 );
pxAssert( (addr >> 12) == 0x1f808 );
u32 masked_addr = addr & 0x0fff;

2
pcsx2/windows/SamplProf.cpp
View File

@ -231,7 +231,7 @@ int __stdcall ProfilerThread(void* nada)
rv += lst[i].ToString(tick_count);
}
Console.WriteLn("+Sampling Profiler Results-\n%s\n+>", rv.ToAscii().data() );
Console.WriteLn( L"+Sampling Profiler Results-\n%s\n+>", rv.c_str() );
tick_count=0;

4
pcsx2/windows/WinCompressNTFS.cpp
View File

@ -98,7 +98,7 @@ bool StreamException_LogFromErrno( const wxString& streamname, const wxChar* act
}
catch( Exception::Stream& ex )
{
Console.Notice( wxsFormat( L"%s: %s", action, ex.FormatDiagnosticMessage().c_str() ) );
Console.Warning( L"%s: %s", action, ex.FormatDiagnosticMessage().c_str() );
return true;
}
return false;
@ -113,7 +113,7 @@ bool StreamException_LogLastError( const wxString& streamname, const wxChar* act
}
catch( Exception::Stream& ex )
{
Console.Notice( wxsFormat( L"%s: %s", action, ex.FormatDiagnosticMessage().c_str() ) );
Console.Warning( L"%s: %s", action, ex.FormatDiagnosticMessage().c_str() );
return true;
}
return false;

10
pcsx2/x86/iFPU.cpp
View File

@ -685,7 +685,7 @@ int recCommutativeOp(int info, int regd, int op)
}
break;
default:
Console.Status("FPU: recCommutativeOp case 4");
Console.WriteLn(Color_Magenta, "FPU: recCommutativeOp case 4");
SSE_MOVSS_M32_to_XMM(regd, (uptr)&fpuRegs.fpr[_Fs_]);
SSE_MOVSS_M32_to_XMM(t0reg, (uptr)&fpuRegs.fpr[_Ft_]);
if (CHECK_FPU_EXTRA_OVERFLOW || (op >= 2)) { fpuFloat2(regd); fpuFloat2(t0reg); }
@ -801,7 +801,7 @@ void recC_EQ_xmm(int info)
SSE_UCOMISS_XMM_to_XMM(EEREC_S, EEREC_T);
break;
default:
Console.Status("recC_EQ_xmm: Default");
Console.WriteLn(Color_Magenta, "recC_EQ_xmm: Default");
tempReg = _allocX86reg(-1, X86TYPE_TEMP, 0, 0);
if (tempReg < 0) {Console.Error("FPU: DIV Allocation Error!"); tempReg = EAX;}
MOV32MtoR(tempReg, (uptr)&fpuRegs.fpr[_Fs_]);
@ -881,7 +881,7 @@ void recC_LE_xmm(int info )
SSE_UCOMISS_XMM_to_XMM(EEREC_S, EEREC_T);
break;
default: // Untested and incorrect, but this case is never reached AFAIK (cottonvibes)
Console.Status("recC_LE_xmm: Default");
Console.WriteLn(Color_Magenta, "recC_LE_xmm: Default");
tempReg = _allocX86reg(-1, X86TYPE_TEMP, 0, 0);
if (tempReg < 0) {Console.Error("FPU: DIV Allocation Error!"); tempReg = EAX;}
MOV32MtoR(tempReg, (uptr)&fpuRegs.fpr[_Fs_]);
@ -957,7 +957,7 @@ void recC_LT_xmm(int info)
SSE_UCOMISS_XMM_to_XMM(EEREC_S, EEREC_T);
break;
default:
Console.Status("recC_LT_xmm: Default");
Console.WriteLn(Color_Magenta, "recC_LT_xmm: Default");
tempReg = _allocX86reg(-1, X86TYPE_TEMP, 0, 0);
if (tempReg < 0) {Console.Error("FPU: DIV Allocation Error!"); tempReg = EAX;}
MOV32MtoR(tempReg, (uptr)&fpuRegs.fpr[_Fs_]);
@ -1629,7 +1629,7 @@ void recSUBop(int info, int regd)
}
break;
default:
Console.Notice("FPU: SUB case 4");
Console.Warning("FPU: SUB case 4");
SSE_MOVSS_M32_to_XMM(t0reg, (uptr)&fpuRegs.fpr[_Ft_]);
SSE_MOVSS_M32_to_XMM(regd, (uptr)&fpuRegs.fpr[_Fs_]);
recSUBhelper(regd, t0reg);

2
pcsx2/x86/iR3000A.cpp
View File

@ -788,7 +788,7 @@ void recResetIOP()
pxAssert( recMem != NULL );
pxAssert( m_recBlockAlloc != NULL );
DevCon.Status( "iR3000A Resetting recompiler memory and structures" );
DevCon.WriteLn( "iR3000A Recompiler reset." );
memset_8<0xcc,RECMEM_SIZE>( recMem ); // 0xcc is INT3
iopClearRecLUT((BASEBLOCK*)m_recBlockAlloc,

4
pcsx2/x86/iVU1micro.cpp
View File

@ -149,14 +149,14 @@ namespace VU1micro
char str2[150];
SysPrintf("\n\n");
SysPrintf("-----------------------------------------------\n");
Console.Notice("Problem Occurred!");
Console.Warning("Problem Occurred!");
SysPrintf("-----------------------------------------------\n");
SysPrintf("runCount = %d\n", runCount);
SysPrintf("StartPC [%04x]\n", ((VURegs*)backVUregs)->VI[REG_TPC].UL);
SysPrintf("-----------------------------------------------\n\n");
SysPrintf("-----------------------------------------------\n");
Console.Notice("Super VU / Micro VU");
Console.Warning("Super VU / Micro VU");
SysPrintf("-----------------------------------------------\n");
for (int i = 0; i < 32; i++) {

16
pcsx2/x86/ix86-32/iR5900-32.cpp
View File

@ -263,7 +263,7 @@ u32* recGetImm64(u32 hi, u32 lo)
if (recConstBufPtr >= recConstBuf + RECCONSTBUF_SIZE)
{
Console.Status( "EErec const buffer filled; Resetting..." );
Console.WriteLn( "EErec const buffer filled; Resetting..." );
throw Exception::ForceDispatcherReg();
/*for (u32 *p = recConstBuf; p < recConstBuf + RECCONSTBUF_SIZE; p += 2)
@ -284,7 +284,7 @@ u32* recGetImm64(u32 hi, u32 lo)
imm64[0] = lo;
imm64[1] = hi;
//Console.Notice("Consts allocated: %d of %u", (recConstBufPtr - recConstBuf) / 2, count);
//Console.Warning("Consts allocated: %d of %u", (recConstBufPtr - recConstBuf) / 2, count);
return imm64;
}
@ -569,7 +569,7 @@ static bool eeRecIsReset = false;
////////////////////////////////////////////////////
void recResetEE( void )
{
Console.Status( "Issuing EE/iR5900-32 Recompiler Reset [mem/structure cleanup]" );
Console.WriteLn( Color_StrongBlack, "Issuing EE/iR5900-32 Recompiler Reset" );
maxrecmem = 0;
@ -1206,7 +1206,7 @@ void recompileNextInstruction(int delayslot)
case 1:
switch(_Rt_) {
case 0: case 1: case 2: case 3: case 0x10: case 0x11: case 0x12: case 0x13:
Console.Notice("branch %x in delay slot!", cpuRegs.code);
Console.Warning("branch %x in delay slot!", cpuRegs.code);
_clearNeededX86regs();
_clearNeededMMXregs();
_clearNeededXMMregs();
@ -1215,7 +1215,7 @@ void recompileNextInstruction(int delayslot)
break;
case 2: case 3: case 4: case 5: case 6: case 7: case 0x14: case 0x15: case 0x16: case 0x17:
Console.Notice("branch %x in delay slot!", cpuRegs.code);
Console.Warning("branch %x in delay slot!", cpuRegs.code);
_clearNeededX86regs();
_clearNeededMMXregs();
_clearNeededXMMregs();
@ -1281,7 +1281,7 @@ static u32 s_recblocks[] = {0};
// Called when a block under manual protection fails it's pre-execution integrity check.
void __fastcall dyna_block_discard(u32 start,u32 sz)
{
DevCon.WriteLn("dyna_block_discard .. start=0x%08X size=%d", start, sz*4);
DevCon.WriteLn("Discarding Manual Block @ 0x%08X [size=%d]", start, sz*4);
recClear(start, sz);
// Stack trick: This function was invoked via a direct jmp, so manually pop the
@ -1393,7 +1393,7 @@ static void __fastcall recRecompile( const u32 startpc )
willbranch3 = 1;
s_nEndBlock = i;
//DevCon.Notice( "Pagesplit @ %08X : size=%d insts", startpc, (i-startpc) / 4 );
//DevCon.Warning( "Pagesplit @ %08X : size=%d insts", startpc, (i-startpc) / 4 );
break;
}
@ -1620,7 +1620,7 @@ StartRecomp:
}
else
{
DbgCon.Notice( "Uncounted Manual block @ %08X : size=%3d page/offs=%05X/%03X inpgsz=%d",
DbgCon.WriteLn( "Uncounted Manual block @ 0x%08X : size=%3d page/offs=%05X/%03X inpgsz=%d",
startpc, sz, inpage_ptr>>12, inpage_ptr&0xfff, pgsz, inpage_sz );
}

6
pcsx2/x86/microVU.cpp
View File

@ -211,7 +211,7 @@ microVUf(int) mVUfindLeastUsedProg() {
mVU->prog.prog[i].isOld = 0;
mVU->prog.prog[i].used = 1;
mVUsortProg(mVU, i);
Console.Notice("microVU%d: Cached MicroPrograms = [%03d] [%03d]", vuIndex, i+1, mVU->prog.total+1);
Console.Warning("microVU%d: Cached MicroPrograms = [%03d] [%03d]", vuIndex, i+1, mVU->prog.total+1);
return i;
}
}
@ -228,7 +228,7 @@ microVUf(int) mVUfindLeastUsedProg() {
mVU->prog.prog[pIdx].isOld = 0;
mVU->prog.prog[pIdx].used = 1;
mVUsortProg(mVU, pIdx);
Console.Notice("microVU%d: Cached MicroPrograms = [%03d] [%03d]", vuIndex, pIdx+1, mVU->prog.total+1);
Console.Warning("microVU%d: Cached MicroPrograms = [%03d] [%03d]", vuIndex, pIdx+1, mVU->prog.total+1);
return pIdx;
}
@ -244,7 +244,7 @@ microVUt(void) mVUvsyncUpdate(mV) {
mVU->prog.total--;
if (!mVU->index) mVUclearProg<0>(i);
else mVUclearProg<1>(i);
DevCon.Status("microVU%d: Killing Dead Program [%03d]", mVU->index, i+1);
DevCon.WriteLn("microVU%d: Killing Dead Program [%03d]", mVU->index, i+1);
}
else if (((mVU->prog.curFrame - mVU->prog.prog[i].frame) >= (30 * 1)) && !mVU->prog.prog[i].isOld) {
mVU->prog.prog[i].isOld = 1;

2
pcsx2/x86/microVU.h
View File

@ -93,7 +93,7 @@ public:
if (listI < 7) return;
microBlockLink* linkI = &blockList;
for (int i = 0; i <= listI; i++) {
DevCon.Status("[%04x][Block #%d][q=%02d][p=%02d][xgkick=%d][vi15=%08x][viBackup=%02d][flags=%02x][exactMatch=%x]",
DevCon.WriteLn( Color_Green, "[%04x][Block #%d][q=%02d][p=%02d][xgkick=%d][vi15=%08x][viBackup=%02d][flags=%02x][exactMatch=%x]",
pc, i, linkI->block->pState.q, linkI->block->pState.p, linkI->block->pState.xgkick, linkI->block->pState.vi15,
linkI->block->pState.viBackUp, linkI->block->pState.flags, linkI->block->pState.needExactMatch);
linkI = linkI->next;

4
pcsx2/x86/microVU_Analyze.inl
View File

@ -380,7 +380,7 @@ microVUt(void) analyzeBranchVI(mV, int xReg, bool &infoVar) {
infoVar = 1;
}
iPC = bPC;
DevCon.Status("microVU%d: Branch VI-Delay (%d) [%04x]", getIndex, i, xPC);
Console.WriteLn( Color_Green, "microVU%d: Branch VI-Delay (%d) [%04x]", getIndex, i, xPC);
}
else iPC = bPC;
}
@ -394,7 +394,7 @@ microVUt(int) mVUbranchCheck(mV) {
incPC(2);
mVUlow.evilBranch = 1;
mVUregs.blockType = 2;
DevCon.Status("microVU%d Warning: Branch in Branch delay slot! [%04x]", mVU->index, xPC);
Console.Warning("microVU%d Warning: Branch in Branch delay slot! [%04x]", mVU->index, xPC);
return 1;
}
incPC(2);

18
pcsx2/x86/microVU_Compile.inl
View File

@ -65,7 +65,7 @@ microVUt(void) mVUsetupRange(mV, s32 pc, bool isStartPC) {
mVUcurProg.ranges.total = 0;
mVUrange[0] = 0;
mVUrange[1] = mVU->microMemSize - 8;
DevCon.Status("microVU%d: Prog Range List Full", mVU->index);
DevCon.WriteLn( Color_StrongBlack, "microVU%d: Prog Range List Full", mVU->index);
}
}
else {
@ -89,7 +89,7 @@ microVUt(void) mVUsetupRange(mV, s32 pc, bool isStartPC) {
}
}
else {
DevCon.Status("microVU%d: Prog Range Wrap [%04x] [%d]", mVU->index, mVUrange[0], mVUrange[1]);
DevCon.WriteLn("microVU%d: Prog Range Wrap [%04x] [%d]", mVU->index, mVUrange[0], mVUrange[1]);
mVUrange[1] = mVU->microMemSize - 8;
if (mVUcurProg.ranges.total < mVUcurProg.ranges.max) {
mVUcurProg.ranges.total++;
@ -100,16 +100,16 @@ microVUt(void) mVUsetupRange(mV, s32 pc, bool isStartPC) {
mVUcurProg.ranges.total = 0;
mVUrange[0] = 0;
mVUrange[1] = mVU->microMemSize - 8;
DevCon.Status("microVU%d: Prog Range List Full", mVU->index);
DevCon.WriteLn( Color_StrongBlack, "microVU%d: Prog Range List Full", mVU->index);
}
}
}
}
microVUt(void) startLoop(mV) {
if (curI & _Mbit_) { Console.Status("microVU%d: M-bit set!", getIndex); }
if (curI & _Dbit_) { DevCon.Status ("microVU%d: D-bit set!", getIndex); }
if (curI & _Tbit_) { DevCon.Status ("microVU%d: T-bit set!", getIndex); }
if (curI & _Mbit_) { Console.WriteLn(Color_Green, "microVU%d: M-bit set!", getIndex); }
if (curI & _Dbit_) { DevCon.WriteLn (Color_Green, "microVU%d: D-bit set!", getIndex); }
if (curI & _Tbit_) { DevCon.WriteLn (Color_Green, "microVU%d: T-bit set!", getIndex); }
memset(&mVUinfo, 0, sizeof(mVUinfo));
memset(&mVUregsTemp, 0, sizeof(mVUregsTemp));
}
@ -121,7 +121,7 @@ microVUt(void) doIbit(mV) {
mVU->regAlloc->clearRegVF(33);
if (CHECK_VU_OVERFLOW && ((curI & 0x7fffffff) >= 0x7f800000)) {
Console.Status("microVU%d: Clamping I Reg", mVU->index);
Console.WriteLn(Color_Green,"microVU%d: Clamping I Reg", mVU->index);
tempI = (0x80000000 & curI) | 0x7f7fffff; // Clamp I Reg
}
else tempI = curI;
@ -133,7 +133,7 @@ microVUt(void) doIbit(mV) {
microVUt(void) doSwapOp(mV) {
if (mVUinfo.backupVF && !mVUlow.noWriteVF) {
DevCon.Status("microVU%d: Backing Up VF Reg [%04x]", getIndex, xPC);
DevCon.WriteLn(Color_Green, "microVU%d: Backing Up VF Reg [%04x]", getIndex, xPC);
int t1 = mVU->regAlloc->allocReg(mVUlow.VF_write.reg);
int t2 = mVU->regAlloc->allocReg();
SSE_MOVAPS_XMM_to_XMM(t2, t1);
@ -182,7 +182,7 @@ microVUt(void) eBitWarning(mV) {
if (mVUpBlock->pState.blockType == 2) Console.Error("microVU%d Warning: Branch, Branch, Branch! [%04x]", mVU->index, xPC);
incPC(2);
if (curI & _Ebit_) {
DevCon.Status("microVU%d: E-bit in Branch delay slot! [%04x]", mVU->index, xPC);
DevCon.Warning("microVU%d: E-bit in Branch delay slot! [%04x]", mVU->index, xPC);
mVUregs.blockType = 1;
}
incPC(-2);

2
pcsx2/x86/microVU_Flags.inl
View File

@ -50,7 +50,7 @@ microVUt(void) mVUstatusFlagOp(mV) {
}
}
iPC = curPC;
DevCon.Status("microVU%d: FSSET Optimization", getIndex);
DevCon.WriteLn(Color_Green, "microVU%d: FSSET Optimization", getIndex);
}
int findFlagInst(int* fFlag, int cycles) {

2
pcsx2/x86/microVU_Misc.h
View File

@ -273,7 +273,7 @@ typedef u32 (__fastcall *mVUCall)(void*, void*);
#define mVUcacheCheck(ptr, start, limit) { \
uptr diff = ptr - start; \
if (diff >= limit) { \
Console.Status("microVU%d: Program cache limit reached. Size = 0x%x", mVU->index, diff); \
Console.WriteLn("microVU%d: Program cache limit reached. Size = 0x%x", mVU->index, diff); \
mVUreset(mVU); \
} \
}

6
pcsx2/x86/sVU_Lower.cpp
View File

@ -1593,7 +1593,7 @@ void recVUMI_ESADD( VURegs *VU, int info)
//Console.WriteLn("VU: ESADD");
pxAssert( VU == &VU1 );
if( EEREC_TEMP == EEREC_D ) { // special code to reset P ( FixMe: don't know if this is still needed! (cottonvibes) )
Console.Notice("ESADD: Resetting P reg!!!\n");
Console.Warning("ESADD: Resetting P reg!!!\n");
MOV32ItoM(VU_VI_ADDR(REG_P, 0), 0);
return;
}
@ -1981,10 +1981,10 @@ void __fastcall VU1XGKICK_MTGSTransfer(u32 *pMem, u32 addr)
if((size << 4) > (0x4000-(addr&0x3fff)))
{
//DevCon.Notice("addr + Size = 0x%x, transferring %x then doing %x", (addr&0x3fff) + (size << 4), (0x4000-(addr&0x3fff)) >> 4, size - ((0x4000-(addr&0x3fff)) >> 4));
//DevCon.Warning("addr + Size = 0x%x, transferring %x then doing %x", (addr&0x3fff) + (size << 4), (0x4000-(addr&0x3fff)) >> 4, size - ((0x4000-(addr&0x3fff)) >> 4));
memcpy_aligned(pmem, (u8*)pMem+addr, 0x4000-(addr&0x3fff));
size -= (0x4000-(addr&0x3fff)) >> 4;
//DevCon.Notice("Size left %x", size);
//DevCon.Warning("Size left %x", size);
pmem += 0x4000-(addr&0x3fff);
memcpy_aligned(pmem, (u8*)pMem, size<<4);
}

4
pcsx2/x86/sVU_Micro.cpp
View File

@ -1727,9 +1727,9 @@ void testPrintOverflow() {
tempRegX[2] &= 0xff800000;
tempRegX[3] &= 0xff800000;
if ( (tempRegX[0] == 0x7f800000) || (tempRegX[1] == 0x7f800000) || (tempRegX[2] == 0x7f800000) || (tempRegX[3] == 0x7f800000) )
Console.Notice( "VU OVERFLOW!: Changing to +Fmax!!!!!!!!!!!!" );
Console.Warning( "VU OVERFLOW!: Changing to +Fmax!!!!!!!!!!!!" );
if ( (tempRegX[0] == 0xff800000) || (tempRegX[1] == 0xff800000) || (tempRegX[2] == 0xff800000) || (tempRegX[3] == 0xff800000) )
Console.Notice( "VU OVERFLOW!: Changing to -Fmax!!!!!!!!!!!!" );
Console.Warning( "VU OVERFLOW!: Changing to -Fmax!!!!!!!!!!!!" );
}
// Outputs to the console when overflow has occured.

16
pcsx2/x86/sVU_zerorec.cpp
View File

@ -343,7 +343,7 @@ void SuperVUAlloc(int vuindex)
{
// The old -1 crap has been depreciated on this function. Please
// specify either 0 or 1, thanks.
jASSUME(vuindex >= 0);
pxAssert(vuindex >= 0);
// upper 4 bits must be zero!
if (s_recVUMem == NULL)
@ -357,6 +357,8 @@ void SuperVUAlloc(int vuindex)
throw Exception::OutOfMemory(
// untranslated diagnostic msg, use exception's default for translation
wxsFormat( L"SuperVU failed to allocate recompiler memory (addr: 0x%x)", (u32)s_recVUMem ),
// Translated message
_("An out of memory error occured while attempting to reserve memory for the core recompilers.")
);
}
@ -368,7 +370,7 @@ void SuperVUAlloc(int vuindex)
if (vuindex >= 0)
{
jASSUME(s_recVUMem != NULL);
pxAssert(s_recVUMem != NULL);
if (recVUHeaders[vuindex] == NULL)
recVUHeaders[vuindex] = new VuFunctionHeader* [s_MemSize[vuindex] / 8];
@ -449,7 +451,7 @@ void SuperVUReset(int vuindex)
if (vuindex < 0)
{
DbgCon.Status("SuperVU reset > Resetting recompiler memory and structures.");
DbgCon.WriteLn("SuperVU: Resetting recompiler memory and structures.");
// Does this cause problems on VU recompiler resets? It could, if the VU works like
// the EE used to, and actually tries to re-enter the recBlock after issuing a clear. (air)
@ -461,7 +463,7 @@ void SuperVUReset(int vuindex)
}
else
{
DbgCon.Status("SuperVU reset [VU%d] > Resetting the recs and junk", vuindex);
DbgCon.WriteLn("SuperVU [VU%d]: Resetting the recs and junk", vuindex);
list<VuFunctionHeader*>::iterator it;
if (recVUHeaders[vuindex]) memset(recVUHeaders[vuindex], 0, sizeof(VuFunctionHeader*) * (s_MemSize[vuindex] / 8));
if (recVUBlocks[vuindex]) memset(recVUBlocks[vuindex], 0, sizeof(VuBlockHeader) * (s_MemSize[vuindex] / 8));
@ -502,7 +504,7 @@ void __fastcall SuperVUClear(u32 startpc, u32 size, int vuindex)
if (plist->size() > 30)
{
// list is too big, delete
//Console.Notice("Performance warning: deleting cached VU program!");
//Console.Warning("Performance warning: deleting cached VU program!");
delete plist->front();
plist->pop_front();
}
@ -3785,7 +3787,7 @@ void VuInstruction::Recompile(list<VuInstruction>::iterator& itinst, u32 vuxyz)
#ifdef PCSX2_DEVBUILD
if (regs[1].VIread & regs[0].VIwrite & ~((1 << REG_Q) | (1 << REG_P) | (1 << REG_VF0_FLAG) | (1 << REG_ACC_FLAG)))
{
Console.Notice("*PCSX2*: Warning, VI write to the same reg %x in both lower/upper cycle %x", regs[1].VIread & regs[0].VIwrite, s_pCurBlock->startpc);
Console.Warning("*PCSX2*: Warning, VI write to the same reg %x in both lower/upper cycle %x", regs[1].VIread & regs[0].VIwrite, s_pCurBlock->startpc);
}
#endif
@ -4596,5 +4598,5 @@ void recVULowerOP_T3_11(VURegs* VU, s32 info)
void recVUunknown(VURegs* VU, s32 info)
{
Console.Notice("Unknown SVU micromode opcode called");
Console.Warning("Unknown SVU micromode opcode called");
}