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

Global Variable: Rename _Notify to g_Notify

This commit is contained in:
zilmar 2012-11-17 11:58:31 +11:00
parent ca161dfd07
commit ab57cdbc7e
50 changed files with 820 additions and 820 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Project64/N64 System/C Core/r4300i Commands.cpp
View File

@ -841,7 +841,7 @@ int DisplayR4300iCommand (DWORD location, int InsertPos) {
return LinesUsed;
}
} __except( r4300i_Command_MemoryFilter( GetExceptionCode(), GetExceptionInformation()) ) {
_Notify->DisplayError(GS(MSG_UNKNOWN_MEM_ACTION));
g_Notify->DisplayError(GS(MSG_UNKNOWN_MEM_ACTION));
ExitThread(0);
}
if (SelfModCheck == ModCode_ChangeMemory) {

8
Source/Project64/N64 System/Cheat Class.cpp
View File

@ -473,7 +473,7 @@ void CCheats::AddCodeLayers (int CheatNumber, const stdstr &CheatName, WND_HANDL
//Work out text to add
char Text[500], Item[500];
if (CheatName.length() > (sizeof(Text) - 5)) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (CheatName.length() > (sizeof(Text) - 5)) { g_Notify->BreakPoint(__FILE__,__LINE__); }
strcpy(Text,CheatName.c_str());
if (strchr(Text,'\\') > 0) { *strchr(Text,'\\') = 0; }
@ -517,7 +517,7 @@ void CCheats::AddCodeLayers (int CheatNumber, const stdstr &CheatName, WND_HANDL
stdstr CCheats::GetCheatName(int CheatNo, bool AddExtension) const
{
if (CheatNo > MaxCheats) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (CheatNo > MaxCheats) { g_Notify->BreakPoint(__FILE__,__LINE__); }
stdstr LineEntry = _Settings->LoadStringIndex(Cheat_Entry,CheatNo);
if (LineEntry.length() == 0) { return LineEntry; }
@ -756,13 +756,13 @@ int CALLBACK CCheats::CheatAddProc (WND_HANDLE hDlg,DWORD uMsg,DWORD wParam, DWO
break;
}
if (_stricmp(CheatName.c_str(),NewCheatName.c_str()) == 0) {
_Notify->DisplayError(GS(MSG_CHEAT_NAME_IN_USE));
g_Notify->DisplayError(GS(MSG_CHEAT_NAME_IN_USE));
SetFocus(GetDlgItem((HWND)hDlg,IDC_CODE_NAME));
return true;
}
}
if (_this->m_EditCheat < 0 && i == MaxCheats) {
_Notify->DisplayError(GS(MSG_MAX_CHEATS));
g_Notify->DisplayError(GS(MSG_MAX_CHEATS));
return true;
}

12
Source/Project64/N64 System/Debugger/Debugger - Memory Dump.cpp
View File

@ -79,7 +79,7 @@ LRESULT CDumpMemory::OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/,
GetDlgItemText(IDC_FILENAME,FileName,sizeof(FileName));
if (strlen(FileName) == 0)
{
_Notify->DisplayError("Please Choose target file");
g_Notify->DisplayError("Please Choose target file");
::SetFocus(GetDlgItem(IDC_FILENAME));
return false;
}
@ -255,7 +255,7 @@ LRESULT CDumpMemory::OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/,
// GetDlgItemText((HWND)hDlg,IDC_FILENAME,FileName,sizeof(FileName));
// if (strlen(FileName) == 0)
// {
// _Notify->DisplayError("Please Choose target file");
// g_Notify->DisplayError("Please Choose target file");
// SetFocus(GetDlgItem((HWND)hDlg,IDC_FILENAME));
// return false;
// }
@ -299,12 +299,12 @@ bool CDumpMemory::DumpMemory ( LPCSTR FileName,DumpFormat Format, DWORD StartPC,
CLog LogFile;
if (!LogFile.Open(FileName))
{
_Notify->DisplayError("Failed to open\n%s",FileName);
g_Notify->DisplayError("Failed to open\n%s",FileName);
return false;
}
LogFile.SetFlush(false);
LogFile.SetTruncateFile(false);
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
char Command[200];
for (COpcode OpCode(StartPC); OpCode.PC() < EndPC; OpCode.Next())
@ -479,7 +479,7 @@ bool CDumpMemory::DumpMemory ( LPCSTR FileName,DumpFormat Format, DWORD StartPC,
//
// if (strlen(FileName) == 0)
// {
// _Notify->DisplayError("Please Choose target file");
// g_Notify->DisplayError("Please Choose target file");
// SetFocus(GetDlgItem((HWND)hDlg,IDC_FILENAME));
// return false;
// }
@ -524,7 +524,7 @@ bool CDumpMemory::DumpMemory ( LPCSTR FileName,DumpFormat Format, DWORD StartPC,
// CLog LogFile(FileName);
// if (!LogFile.IsOpen())
// {
// _Notify->DisplayError("Failed to open\n%s",FileName);
// g_Notify->DisplayError("Failed to open\n%s",FileName);
// return false;
// }
//

4
Source/Project64/N64 System/Debugger/Debugger - Memory Search.cpp
View File

@ -13,7 +13,7 @@ CDebugMemorySearch::~CDebugMemorySearch()
void CDebugMemorySearch::AddAlignmentOptions (CComboBox & ctrl)
{
/*int Index =*/ ctrl.AddString("32 bits (aligned)");
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
ctrl.SetItemData(Index,_32Bit);
Index = ctrl.AddString("16bits (aligned)");
@ -225,7 +225,7 @@ void CDebugMemorySearch::EnableUnknownOptions( bool Enable )
void CDebugMemorySearch::SearchForValue( void )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
MemorySize Size = (MemorySize)m_ValueSize.GetItemData(m_ValueSize.GetCurSel());
DWORD Value = m_SearchValue.GetValue();

24
Source/Project64/N64 System/Interpreter/Interpreter CPU.cpp
View File

@ -5,14 +5,14 @@ DWORD CInterpreterCPU::m_CountPerOp = 2;
void ExecuteInterpreterOps (DWORD /*Cycles*/)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
bool DelaySlotEffectsCompare (DWORD PC, DWORD Reg1, DWORD Reg2) {
OPCODE Command;
if (!_MMU->LW_VAddr(PC + 4, Command.Hex)) {
//_Notify->DisplayError("Failed to load word 2");
//g_Notify->DisplayError("Failed to load word 2");
//ExitThread(0);
return TRUE;
}
@ -68,7 +68,7 @@ bool DelaySlotEffectsCompare (DWORD PC, DWORD Reg1, DWORD Reg2) {
break;
default:
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Does %s effect Delay slot at %X?",R4300iOpcodeName(Command.Hex,PC+4), PC);
g_Notify->DisplayError("Does %s effect Delay slot at %X?",R4300iOpcodeName(Command.Hex,PC+4), PC);
#endif
return TRUE;
}
@ -90,13 +90,13 @@ bool DelaySlotEffectsCompare (DWORD PC, DWORD Reg1, DWORD Reg2) {
case R4300i_COP0_CO_TLBP: break;
default:
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Does %s effect Delay slot at %X?\n6",R4300iOpcodeName(Command.Hex,PC+4), PC);
g_Notify->DisplayError("Does %s effect Delay slot at %X?\n6",R4300iOpcodeName(Command.Hex,PC+4), PC);
#endif
return TRUE;
}
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Does %s effect Delay slot at %X?\n7",R4300iOpcodeName(Command.Hex,PC+4), PC);
g_Notify->DisplayError("Does %s effect Delay slot at %X?\n7",R4300iOpcodeName(Command.Hex,PC+4), PC);
#endif
return TRUE;
}
@ -118,7 +118,7 @@ bool DelaySlotEffectsCompare (DWORD PC, DWORD Reg1, DWORD Reg2) {
case R4300i_COP1_L: break;
#ifndef EXTERNAL_RELEASE
default:
_Notify->DisplayError("Does %s effect Delay slot at %X?",R4300iOpcodeName(Command.Hex,PC+4), PC);
g_Notify->DisplayError("Does %s effect Delay slot at %X?",R4300iOpcodeName(Command.Hex,PC+4), PC);
#endif
return TRUE;
}
@ -160,7 +160,7 @@ bool DelaySlotEffectsCompare (DWORD PC, DWORD Reg1, DWORD Reg2) {
case R4300i_SD: break;
default:
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Does %s effect Delay slot at %X?",R4300iOpcodeName(Command.Hex,PC+4), PC);
g_Notify->DisplayError("Does %s effect Delay slot at %X?",R4300iOpcodeName(Command.Hex,PC+4), PC);
#endif
return TRUE;
}
@ -206,7 +206,7 @@ void CInterpreterCPU::InPermLoop (void) {
//CurrentFrame = 0;
//CurrentPercent = 0;
//DisplayFPS();
_Notify->DisplayError(GS(MSG_PERM_LOOP));
g_Notify->DisplayError(GS(MSG_PERM_LOOP));
_System->CloseCpu();
} else {
/* check sound playing */
@ -290,7 +290,7 @@ void CInterpreterCPU::ExecuteCPU (void )
}
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
} else {
_Reg->DoTLBReadMiss(R4300iOp::m_NextInstruction == JUMP,PROGRAM_COUNTER);
@ -298,7 +298,7 @@ void CInterpreterCPU::ExecuteCPU (void )
}
}
} __except( _MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation()) ) {
_Notify->DisplayError(GS(MSG_UNKNOWN_MEM_ACTION));
g_Notify->DisplayError(GS(MSG_UNKNOWN_MEM_ACTION));
ExitThread(0);
}
}
@ -396,7 +396,7 @@ void CInterpreterCPU::ExecuteOps ( int Cycles )
}
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
} else {
_Reg->DoTLBReadMiss(R4300iOp::m_NextInstruction == JUMP,PROGRAM_COUNTER);
@ -404,7 +404,7 @@ void CInterpreterCPU::ExecuteOps ( int Cycles )
}
}
} __except( _MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation()) ) {
_Notify->DisplayError(GS(MSG_UNKNOWN_MEM_ACTION));
g_Notify->DisplayError(GS(MSG_UNKNOWN_MEM_ACTION));
ExitThread(0);
}
}

30
Source/Project64/N64 System/Interpreter/Interpreter Ops 32.cpp
View File

@ -834,7 +834,7 @@ void R4300iOp32::LB (void) {
if (!_MMU->LB_VAddr(Address,_GPR[m_Opcode.rt].UB[0])) {
if (bShowTLBMisses()) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("LB TLB: %X",Address);
g_Notify->DisplayError("LB TLB: %X",Address);
#endif
}
TLB_READ_EXCEPTION(Address);
@ -848,7 +848,7 @@ void R4300iOp32::LH (void) {
if ((Address & 1) != 0) { ADDRESS_ERROR_EXCEPTION(Address,TRUE); }
if (!_MMU->LH_VAddr(Address,_GPR[m_Opcode.rt].UHW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LH TLB: %X",Address);
g_Notify->DisplayError("LH TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -864,10 +864,10 @@ void R4300iOp32::LWL (void) {
if (!_MMU->LW_VAddr((Address & ~3),Value))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
if (bShowTLBMisses())
{
_Notify->DisplayError("LWL TLB: %X",Address);
g_Notify->DisplayError("LWL TLB: %X",Address);
}
return;
}
@ -891,7 +891,7 @@ void R4300iOp32::LW (void) {
if (!_MMU->LW_VAddr(Address,_GPR[m_Opcode.rt].UW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LW TLB: %X",Address);
g_Notify->DisplayError("LW TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -903,7 +903,7 @@ void R4300iOp32::LBU (void) {
DWORD Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
if (!_MMU->LB_VAddr(Address,_GPR[m_Opcode.rt].UB[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LBU TLB: %X",Address);
g_Notify->DisplayError("LBU TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -916,7 +916,7 @@ void R4300iOp32::LHU (void) {
if ((Address & 1) != 0) { ADDRESS_ERROR_EXCEPTION(Address,TRUE); }
if (!_MMU->LH_VAddr(Address,_GPR[m_Opcode.rt].UHW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LHU TLB: %X",Address);
g_Notify->DisplayError("LHU TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -932,10 +932,10 @@ void R4300iOp32::LWR (void) {
if (!_MMU->LW_VAddr((Address & ~3),Value))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
if (bShowTLBMisses())
{
_Notify->DisplayError("LWR TLB: %X",Address);
g_Notify->DisplayError("LWR TLB: %X",Address);
}
return;
}
@ -951,7 +951,7 @@ void R4300iOp32::LWU (void) {
if (!_MMU->LW_VAddr(Address,_GPR[m_Opcode.rt].UW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LWU TLB: %X",Address);
g_Notify->DisplayError("LWU TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -968,7 +968,7 @@ void R4300iOp32::LL (void) {
if (!_MMU->LW_VAddr(Address,_GPR[m_Opcode.rt].UW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LL TLB: %X",Address);
g_Notify->DisplayError("LL TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -1062,7 +1062,7 @@ void R4300iOp32::SPECIAL_SLTU (void) {
void R4300iOp32::SPECIAL_TEQ (void) {
if (_GPR[m_Opcode.rs].W[0] == _GPR[m_Opcode.rt].W[0]) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Should trap this ???");
g_Notify->DisplayError("Should trap this ???");
#endif
}
}
@ -1245,7 +1245,7 @@ void R4300iOp32::COP0_MT (void) {
}
if ((_CP0[m_Opcode.rd] & 0x18) != 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Left kernel mode ??");
g_Notify->DisplayError("Left kernel mode ??");
#endif
}
_Reg->CheckInterrupts();
@ -1253,7 +1253,7 @@ void R4300iOp32::COP0_MT (void) {
case 13: //cause
_CP0[m_Opcode.rd] &= 0xFFFFCFF;
#ifndef EXTERNAL_RELEASE
if ((_GPR[m_Opcode.rt].UW[0] & 0x300) != 0 ){ _Notify->DisplayError("Set IP0 or IP1"); }
if ((_GPR[m_Opcode.rt].UW[0] & 0x300) != 0 ){ g_Notify->DisplayError("Set IP0 or IP1"); }
#endif
break;
default:
@ -1271,7 +1271,7 @@ void R4300iOp32::COP1_CF (void) {
TEST_COP1_USABLE_EXCEPTION
if (m_Opcode.fs != 31 && m_Opcode.fs != 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("CFC1 what register are you writing to ?");
g_Notify->DisplayError("CFC1 what register are you writing to ?");
#endif
return;
}

132
Source/Project64/N64 System/Interpreter/Interpreter Ops.cpp
View File

@ -958,10 +958,10 @@ void R4300iOp::LDL (void) {
if (!_MMU->LD_VAddr((Address & ~7),Value))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
if (bShowTLBMisses())
{
_Notify->DisplayError("LDL TLB: %X",Address);
g_Notify->DisplayError("LDL TLB: %X",Address);
}
return;
}
@ -984,10 +984,10 @@ void R4300iOp::LDR (void) {
if (!_MMU->LD_VAddr((Address & ~7),Value))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
if (bShowTLBMisses())
{
_Notify->DisplayError("LDR TLB: %X",Address);
g_Notify->DisplayError("LDR TLB: %X",Address);
}
return;
}
@ -1003,7 +1003,7 @@ void R4300iOp::LB (void) {
if (!_MMU->LB_VAddr(Address,_GPR[m_Opcode.rt].UB[0])) {
if (bShowTLBMisses()) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("LB TLB: %X",Address);
g_Notify->DisplayError("LB TLB: %X",Address);
#endif
}
TLB_READ_EXCEPTION(Address);
@ -1017,7 +1017,7 @@ void R4300iOp::LH (void) {
if ((Address & 1) != 0) { ADDRESS_ERROR_EXCEPTION(Address,TRUE); }
if (!_MMU->LH_VAddr(Address,_GPR[m_Opcode.rt].UHW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LH TLB: %X",Address);
g_Notify->DisplayError("LH TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -1033,10 +1033,10 @@ void R4300iOp::LWL (void) {
if (!_MMU->LW_VAddr((Address & ~3),Value))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
if (bShowTLBMisses())
{
_Notify->DisplayError("LWL TLB: %X",Address);
g_Notify->DisplayError("LWL TLB: %X",Address);
}
return;
}
@ -1060,7 +1060,7 @@ void R4300iOp::LW (void) {
if (!_MMU->LW_VAddr(Address,_GPR[m_Opcode.rt].UW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LW TLB: %X",Address);
g_Notify->DisplayError("LW TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -1072,7 +1072,7 @@ void R4300iOp::LBU (void) {
DWORD Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
if (!_MMU->LB_VAddr(Address,_GPR[m_Opcode.rt].UB[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LBU TLB: %X",Address);
g_Notify->DisplayError("LBU TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -1085,7 +1085,7 @@ void R4300iOp::LHU (void) {
if ((Address & 1) != 0) { ADDRESS_ERROR_EXCEPTION(Address,TRUE); }
if (!_MMU->LH_VAddr(Address,_GPR[m_Opcode.rt].UHW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LHU TLB: %X",Address);
g_Notify->DisplayError("LHU TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -1101,10 +1101,10 @@ void R4300iOp::LWR (void) {
if (!_MMU->LW_VAddr((Address & ~3),Value))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
if (bShowTLBMisses())
{
_Notify->DisplayError("LWR TLB: %X",Address);
g_Notify->DisplayError("LWR TLB: %X",Address);
}
return;
}
@ -1120,7 +1120,7 @@ void R4300iOp::LWU (void) {
if (!_MMU->LW_VAddr(Address,_GPR[m_Opcode.rt].UW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LWU TLB: %X",Address);
g_Notify->DisplayError("LWU TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -1131,9 +1131,9 @@ void R4300iOp::LWU (void) {
void R4300iOp::SB (void) {
DWORD Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
if (!_MMU->SB_VAddr(Address,_GPR[m_Opcode.rt].UB[0])) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SB TLB: %X",Address);
g_Notify->DisplayError("SB TLB: %X",Address);
#endif
}
}
@ -1142,9 +1142,9 @@ void R4300iOp::SH (void) {
DWORD Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
if ((Address & 1) != 0) { ADDRESS_ERROR_EXCEPTION(Address,FALSE); }
if (!_MMU->SH_VAddr(Address,_GPR[m_Opcode.rt].UHW[0])) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SH TLB: %X",Address);
g_Notify->DisplayError("SH TLB: %X",Address);
#endif
}
}
@ -1157,9 +1157,9 @@ void R4300iOp::SWL (void) {
if (!_MMU->LW_VAddr((Address & ~3),Value)) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SWL TLB: %X",Address);
g_Notify->DisplayError("SWL TLB: %X",Address);
#endif
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
@ -1168,9 +1168,9 @@ void R4300iOp::SWL (void) {
if (!_MMU->SW_VAddr((Address & ~0x03),Value)) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SWL TLB: %X",Address);
g_Notify->DisplayError("SWL TLB: %X",Address);
#endif
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -1186,10 +1186,10 @@ void R4300iOp::SW (void) {
#endif
if (!_MMU->SW_VAddr(Address,_GPR[m_Opcode.rt].UW[0]))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
if (bShowTLBMisses())
{
_Notify->DisplayError("SW TLB: %X",Address);
g_Notify->DisplayError("SW TLB: %X",Address);
}
}
}
@ -1212,9 +1212,9 @@ void R4300iOp::SDL (void) {
Offset = Address & 7;
if (!_MMU->LD_VAddr((Address & ~7),Value)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SDL TLB: %X",Address);
g_Notify->DisplayError("SDL TLB: %X",Address);
#endif
return;
}
@ -1223,9 +1223,9 @@ void R4300iOp::SDL (void) {
Value += _GPR[m_Opcode.rt].UDW >> SDL_SHIFT[Offset];
if (!_MMU->SD_VAddr((Address & ~7),Value)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SDL TLB: %X",Address);
g_Notify->DisplayError("SDL TLB: %X",Address);
#endif
}
}
@ -1249,9 +1249,9 @@ void R4300iOp::SDR (void) {
Offset = Address & 7;
if (!_MMU->LD_VAddr((Address & ~7),Value)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SDL TLB: %X",Address);
g_Notify->DisplayError("SDL TLB: %X",Address);
#endif
return;
}
@ -1260,9 +1260,9 @@ void R4300iOp::SDR (void) {
Value += _GPR[m_Opcode.rt].UDW << SDR_SHIFT[Offset];
if (!_MMU->SD_VAddr((Address & ~7),Value)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SDL TLB: %X",Address);
g_Notify->DisplayError("SDL TLB: %X",Address);
#endif
}
}
@ -1274,9 +1274,9 @@ void R4300iOp::SWR (void) {
Offset = Address & 3;
if (!_MMU->LW_VAddr((Address & ~3),Value)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SWL TLB: %X",Address);
g_Notify->DisplayError("SWL TLB: %X",Address);
#endif
return;
}
@ -1285,9 +1285,9 @@ void R4300iOp::SWR (void) {
Value += _GPR[m_Opcode.rt].UW[0] << SWR_SHIFT[Offset];
if (!_MMU->SW_VAddr((Address & ~0x03),Value)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SWL TLB: %X",Address);
g_Notify->DisplayError("SWL TLB: %X",Address);
#endif
}
}
@ -1308,7 +1308,7 @@ void R4300iOp::LL (void) {
if (!_MMU->LW_VAddr(Address,_GPR[m_Opcode.rt].UW[0])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LL TLB: %X",Address);
g_Notify->DisplayError("LL TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
} else {
@ -1323,7 +1323,7 @@ void R4300iOp::LWC1 (void) {
if ((Address & 3) != 0) { ADDRESS_ERROR_EXCEPTION(Address,TRUE); }
if (!_MMU->LW_VAddr(Address,*(DWORD *)_FPR_S[m_Opcode.ft])) {
if (bShowTLBMisses()) {
_Notify->DisplayError("LWC1 TLB: %X",Address);
g_Notify->DisplayError("LWC1 TLB: %X",Address);
}
TLB_READ_EXCEPTION(Address);
}
@ -1338,10 +1338,10 @@ void R4300iOp::SC (void) {
if ((*_LLBit) == 1) {
if (!_MMU->SW_VAddr(Address,_GPR[m_Opcode.rt].UW[0]))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
if (bShowTLBMisses())
{
_Notify->DisplayError("SC TLB: %X",Address);
g_Notify->DisplayError("SC TLB: %X",Address);
}
}
}
@ -1352,9 +1352,9 @@ void R4300iOp::LD (void) {
DWORD Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
if ((Address & 7) != 0) { ADDRESS_ERROR_EXCEPTION(Address,TRUE); }
if (!_MMU->LD_VAddr(Address,_GPR[m_Opcode.rt].UDW)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("LD TLB: %X",Address);
g_Notify->DisplayError("LD TLB: %X",Address);
#endif
}
#ifdef Interpreter_StackTest
@ -1371,9 +1371,9 @@ void R4300iOp::LDC1 (void) {
TEST_COP1_USABLE_EXCEPTION
if ((Address & 7) != 0) { ADDRESS_ERROR_EXCEPTION(Address,TRUE); }
if (!_MMU->LD_VAddr(Address,*(unsigned __int64 *)_FPR_D[m_Opcode.ft])) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("LD TLB: %X",Address);
g_Notify->DisplayError("LD TLB: %X",Address);
#endif
}
}
@ -1384,9 +1384,9 @@ void R4300iOp::SWC1 (void) {
if ((Address & 3) != 0) { ADDRESS_ERROR_EXCEPTION(Address,FALSE); }
if (!_MMU->SW_VAddr(Address,*(DWORD *)_FPR_S[m_Opcode.ft])) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SWC1 TLB: %X",Address);
g_Notify->DisplayError("SWC1 TLB: %X",Address);
#endif
}
}
@ -1397,9 +1397,9 @@ void R4300iOp::SDC1 (void) {
TEST_COP1_USABLE_EXCEPTION
if ((Address & 7) != 0) { ADDRESS_ERROR_EXCEPTION(Address,FALSE); }
if (!_MMU->SD_VAddr(Address,*(__int64 *)_FPR_D[m_Opcode.ft])) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SDC1 TLB: %X",Address);
g_Notify->DisplayError("SDC1 TLB: %X",Address);
#endif
}
}
@ -1408,9 +1408,9 @@ void R4300iOp::SD (void) {
DWORD Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
if ((Address & 7) != 0) { ADDRESS_ERROR_EXCEPTION(Address,FALSE); }
if (!_MMU->SD_VAddr(Address,_GPR[m_Opcode.rt].UDW)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SD TLB: %X",Address);
g_Notify->DisplayError("SD TLB: %X",Address);
#endif
}
}
@ -1513,7 +1513,7 @@ void R4300iOp::SPECIAL_DIV (void) {
_RegLO->DW = _GPR[m_Opcode.rs].W[0] / _GPR[m_Opcode.rt].W[0];
_RegHI->DW = _GPR[m_Opcode.rs].W[0] % _GPR[m_Opcode.rt].W[0];
} else {
if (bShowDivByZero()) { _Notify->DisplayError("DIV by 0 ???"); }
if (bShowDivByZero()) { g_Notify->DisplayError("DIV by 0 ???"); }
_RegLO->DW = 0;
_RegHI->DW = 0;
}
@ -1524,7 +1524,7 @@ void R4300iOp::SPECIAL_DIVU (void) {
_RegLO->DW = (int)(_GPR[m_Opcode.rs].UW[0] / _GPR[m_Opcode.rt].UW[0]);
_RegHI->DW = (int)(_GPR[m_Opcode.rs].UW[0] % _GPR[m_Opcode.rt].UW[0]);
} else {
if (bShowDivByZero()) { _Notify->DisplayError("DIVU by 0 ???"); }
if (bShowDivByZero()) { g_Notify->DisplayError("DIVU by 0 ???"); }
_RegLO->DW = 0;
_RegHI->DW = 0;
}
@ -1563,7 +1563,7 @@ void R4300iOp::SPECIAL_DDIV (void) {
_RegHI->DW = _GPR[m_Opcode.rs].DW % _GPR[m_Opcode.rt].DW;
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("DDIV by 0 ???");
g_Notify->DisplayError("DDIV by 0 ???");
#endif
}
}
@ -1574,7 +1574,7 @@ void R4300iOp::SPECIAL_DDIVU (void) {
_RegHI->UDW = _GPR[m_Opcode.rs].UDW % _GPR[m_Opcode.rt].UDW;
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("DDIVU by 0 ???");
g_Notify->DisplayError("DDIVU by 0 ???");
#endif
}
}
@ -1651,7 +1651,7 @@ void R4300iOp::SPECIAL_DSUBU (void) {
void R4300iOp::SPECIAL_TEQ (void) {
if (_GPR[m_Opcode.rs].DW == _GPR[m_Opcode.rt].DW) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Should trap this ???");
g_Notify->DisplayError("Should trap this ???");
#endif
}
}
@ -1848,7 +1848,7 @@ void R4300iOp::COP0_MT (void) {
}
if ((_CP0[m_Opcode.rd] & 0x18) != 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Left kernel mode ??");
g_Notify->DisplayError("Left kernel mode ??");
#endif
}
_Reg->CheckInterrupts();
@ -1856,7 +1856,7 @@ void R4300iOp::COP0_MT (void) {
case 13: //cause
_CP0[m_Opcode.rd] &= 0xFFFFCFF;
#ifndef EXTERNAL_RELEASE
if ((_GPR[m_Opcode.rt].UW[0] & 0x300) != 0 ){ _Notify->DisplayError("Set IP0 or IP1"); }
if ((_GPR[m_Opcode.rt].UW[0] & 0x300) != 0 ){ g_Notify->DisplayError("Set IP0 or IP1"); }
#endif
break;
default:
@ -1914,7 +1914,7 @@ void R4300iOp::COP1_CF (void) {
TEST_COP1_USABLE_EXCEPTION
if (m_Opcode.fs != 31 && m_Opcode.fs != 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("CFC1 what register are you writing to ?");
g_Notify->DisplayError("CFC1 what register are you writing to ?");
#endif
return;
}
@ -1944,7 +1944,7 @@ void R4300iOp::COP1_CT (void) {
return;
}
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("CTC1 what register are you writing to ?");
g_Notify->DisplayError("CTC1 what register are you writing to ?");
#endif
}
@ -2139,14 +2139,14 @@ void R4300iOp::COP1_S_CMP (void) {
if (_isnan(Temp0) || _isnan(Temp1)) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Nan ?");
g_Notify->DisplayError("Nan ?");
#endif
less = FALSE;
equal = FALSE;
unorded = TRUE;
if ((m_Opcode.funct & 8) != 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Signal InvalidOperationException\nin r4300i_COP1_S_CMP\n%X %ff\n%X %ff",
g_Notify->DisplayError("Signal InvalidOperationException\nin r4300i_COP1_S_CMP\n%X %ff\n%X %ff",
Temp0,Temp0,Temp1,Temp1);
#endif
}
@ -2305,14 +2305,14 @@ void R4300iOp::COP1_D_CMP (void) {
if (_isnan(Temp0.D) || _isnan(Temp1.D)) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Nan ?");
g_Notify->DisplayError("Nan ?");
#endif
less = FALSE;
equal = FALSE;
unorded = TRUE;
if ((m_Opcode.funct & 8) != 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Signal InvalidOperationException\nin r4300i_COP1_D_CMP");
g_Notify->DisplayError("Signal InvalidOperationException\nin r4300i_COP1_D_CMP");
#endif
}
} else {
@ -2360,11 +2360,11 @@ void R4300iOp::COP1_L_CVT_D (void) {
/************************** Other functions **************************/
void R4300iOp::UnknownOpcode (void)
{
_Notify->DisplayError("%s: %08X\n%s\n\nStopping Emulation !", GS(MSG_UNHANDLED_OP), (*_PROGRAM_COUNTER),
g_Notify->DisplayError("%s: %08X\n%s\n\nStopping Emulation !", GS(MSG_UNHANDLED_OP), (*_PROGRAM_COUNTER),
R4300iOpcodeName(m_Opcode.Hex,(*_PROGRAM_COUNTER)));
_System->m_EndEmulation = true;
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (HaveDebugger && !inFullScreen) {
int response;
@ -2377,7 +2377,7 @@ void R4300iOp::UnknownOpcode (void)
}
ExitThread(0);
} else {
_Notify->DisplayError(Message);
g_Notify->DisplayError(Message);
ExitThread(0);
}
#endif

2
Source/Project64/N64 System/Mips/Audio.cpp
View File

@ -50,7 +50,7 @@ void CAudio::LenChanged ( void )
{
if (m_SecondBuff)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
WriteTraceF(TraceAudio,__FUNCTION__ ": Set Timer AI_LEN_REG: %d m_CountsPerByte: %d",_Reg->AI_LEN_REG,m_CountsPerByte);
_SystemTimer->SetTimer(CSystemTimer::AiTimer,_Reg->AI_LEN_REG * m_CountsPerByte,false);

32
Source/Project64/N64 System/Mips/Dma.cpp
View File

@ -13,7 +13,7 @@ void CDMA::OnFirstDMA (void) {
case 3: *(DWORD *)&((_MMU->Rdram())[0x318]) = _MMU->RdramSize(); break;
case 5: *(DWORD *)&((_MMU->Rdram())[0x3F0]) = _MMU->RdramSize(); break;
case 6: *(DWORD *)&((_MMU->Rdram())[0x318]) = _MMU->RdramSize(); break;
default: _Notify->DisplayError("Unhandled CicChip(%d) in first DMA",_Rom->CicChipID());
default: g_Notify->DisplayError("Unhandled CicChip(%d) in first DMA",_Rom->CicChipID());
}
}
@ -22,7 +22,7 @@ void CDMA::PI_DMA_READ (void) {
if ( _Reg->PI_DRAM_ADDR_REG + _Reg->PI_RD_LEN_REG + 1 > _MMU->RdramSize()) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("PI_DMA_READ not in Memory");
g_Notify->DisplayError("PI_DMA_READ not in Memory");
#endif
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
@ -57,14 +57,14 @@ void CDMA::PI_DMA_READ (void) {
}
if (_System->m_SaveUsing == SaveChip_FlashRam)
{
_Notify->DisplayError("**** FLashRam DMA Read address %X *****",_Reg->PI_CART_ADDR_REG);
g_Notify->DisplayError("**** FLashRam DMA Read address %X *****",_Reg->PI_CART_ADDR_REG);
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
return;
}
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("PI_DMA_READ where are you dmaing to ?");
g_Notify->DisplayError("PI_DMA_READ where are you dmaing to ?");
#endif
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
@ -77,7 +77,7 @@ void CDMA::PI_DMA_WRITE (void) {
_Reg->PI_STATUS_REG |= PI_STATUS_DMA_BUSY;
if ( _Reg->PI_DRAM_ADDR_REG + _Reg->PI_WR_LEN_REG + 1 > _MMU->RdramSize())
{
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("PI_DMA_WRITE not in Memory"); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("PI_DMA_WRITE not in Memory"); }
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
@ -157,7 +157,7 @@ void CDMA::PI_DMA_WRITE (void) {
return;
}
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("PI_DMA_WRITE not in ROM"); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("PI_DMA_WRITE not in ROM"); }
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
@ -169,7 +169,7 @@ void CDMA::SP_DMA_READ (void) {
if (_Reg->SP_DRAM_ADDR_REG > _MMU->RdramSize()) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SP DMA\nSP_DRAM_ADDR_REG not in RDRam space");
g_Notify->DisplayError("SP DMA\nSP_DRAM_ADDR_REG not in RDRam space");
#endif
_Reg->SP_DMA_BUSY_REG = 0;
_Reg->SP_STATUS_REG &= ~SP_STATUS_DMA_BUSY;
@ -178,14 +178,14 @@ void CDMA::SP_DMA_READ (void) {
if (_Reg->SP_RD_LEN_REG + 1 + (_Reg->SP_MEM_ADDR_REG & 0xFFF) > 0x1000) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SP DMA\ncould not fit copy in memory segement");
g_Notify->DisplayError("SP DMA\ncould not fit copy in memory segement");
#endif
return;
}
if ((_Reg->SP_MEM_ADDR_REG & 3) != 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
if ((_Reg->SP_DRAM_ADDR_REG & 3) != 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (((_Reg->SP_RD_LEN_REG + 1) & 3) != 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
if ((_Reg->SP_MEM_ADDR_REG & 3) != 0) { g_Notify->BreakPoint(__FILE__,__LINE__); }
if ((_Reg->SP_DRAM_ADDR_REG & 3) != 0) { g_Notify->BreakPoint(__FILE__,__LINE__); }
if (((_Reg->SP_RD_LEN_REG + 1) & 3) != 0) { g_Notify->BreakPoint(__FILE__,__LINE__); }
memcpy( _MMU->Dmem() + (_Reg->SP_MEM_ADDR_REG & 0x1FFF), _MMU->Rdram() + _Reg->SP_DRAM_ADDR_REG,
_Reg->SP_RD_LEN_REG + 1 );
@ -197,21 +197,21 @@ void CDMA::SP_DMA_READ (void) {
void CDMA::SP_DMA_WRITE (void) {
if (_Reg->SP_DRAM_ADDR_REG > _MMU->RdramSize()) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SP DMA WRITE\nSP_DRAM_ADDR_REG not in RDRam space");
g_Notify->DisplayError("SP DMA WRITE\nSP_DRAM_ADDR_REG not in RDRam space");
#endif
return;
}
if (_Reg->SP_WR_LEN_REG + 1 + (_Reg->SP_MEM_ADDR_REG & 0xFFF) > 0x1000) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("SP DMA WRITE\ncould not fit copy in memory segement");
g_Notify->DisplayError("SP DMA WRITE\ncould not fit copy in memory segement");
#endif
return;
}
if ((_Reg->SP_MEM_ADDR_REG & 3) != 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
if ((_Reg->SP_DRAM_ADDR_REG & 3) != 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (((_Reg->SP_WR_LEN_REG + 1) & 3) != 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
if ((_Reg->SP_MEM_ADDR_REG & 3) != 0) { g_Notify->BreakPoint(__FILE__,__LINE__); }
if ((_Reg->SP_DRAM_ADDR_REG & 3) != 0) { g_Notify->BreakPoint(__FILE__,__LINE__); }
if (((_Reg->SP_WR_LEN_REG + 1) & 3) != 0) { g_Notify->BreakPoint(__FILE__,__LINE__); }
memcpy( _MMU->Rdram() + _Reg->SP_DRAM_ADDR_REG, _MMU->Dmem() + (_Reg->SP_MEM_ADDR_REG & 0x1FFF),
_Reg->SP_WR_LEN_REG + 1);

12
Source/Project64/N64 System/Mips/Eeprom.cpp
View File

@ -51,15 +51,15 @@ void CEeprom::EepromCommand ( BYTE * Command) {
break;
case 4: // Read from Eeprom
#ifndef EXTERNAL_RELEASE
if (Command[0] != 2) { _Notify->DisplayError("What am I meant to do with this Eeprom Command"); }
if (Command[1] != 8) { _Notify->DisplayError("What am I meant to do with this Eeprom Command"); }
if (Command[0] != 2) { g_Notify->DisplayError("What am I meant to do with this Eeprom Command"); }
if (Command[1] != 8) { g_Notify->DisplayError("What am I meant to do with this Eeprom Command"); }
#endif
ReadFrom(&Command[4],Command[3]);
break;
case 5:
#ifndef EXTERNAL_RELEASE
if (Command[0] != 10) { _Notify->DisplayError("What am I meant to do with this Eeprom Command"); }
if (Command[1] != 1) { _Notify->DisplayError("What am I meant to do with this Eeprom Command"); }
if (Command[0] != 10) { g_Notify->DisplayError("What am I meant to do with this Eeprom Command"); }
if (Command[1] != 1) { g_Notify->DisplayError("What am I meant to do with this Eeprom Command"); }
#endif
WriteTo(&Command[4],Command[3]);
break;
@ -98,7 +98,7 @@ void CEeprom::EepromCommand ( BYTE * Command) {
//Write RTC, unimplemented
break;
default:
if (_Settings->LoadDword(Debugger_ShowPifErrors)) { _Notify->DisplayError("Unknown EepromCommand %d",Command[2]); }
if (_Settings->LoadDword(Debugger_ShowPifErrors)) { g_Notify->DisplayError("Unknown EepromCommand %d",Command[2]); }
}
}
@ -122,7 +122,7 @@ void CEeprom::LoadEeprom (void) {
if (m_hFile == INVALID_HANDLE_VALUE)
{
WriteTraceF(TraceError,"CEeprom::LoadEeprom: Failed to open (%s), ReadOnly = %d, LastError = %X",(LPCTSTR)FileName, m_ReadOnly, GetLastError());
_Notify->DisplayError(GS(MSG_FAIL_OPEN_EEPROM));
g_Notify->DisplayError(GS(MSG_FAIL_OPEN_EEPROM));
return;
}
SetFilePointer(m_hFile,0,NULL,FILE_BEGIN);

18
Source/Project64/N64 System/Mips/FlashRam.cpp
View File

@ -29,13 +29,13 @@ void CFlashram::DmaFromFlashram ( BYTE * dest, int StartOffset, int len)
}
if (len > 0x10000) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("DmaFromFlashram FlipBuffer to small (len: %d)",len);
g_Notify->DisplayError("DmaFromFlashram FlipBuffer to small (len: %d)",len);
#endif
len = 0x10000;
}
if ((len & 3) != 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Unaligned flash ram read ???");
g_Notify->DisplayError("Unaligned flash ram read ???");
#endif
return;
}
@ -64,7 +64,7 @@ void CFlashram::DmaFromFlashram ( BYTE * dest, int StartOffset, int len)
case FLASHRAM_MODE_STATUS:
if (StartOffset != 0 && len != 8) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Reading m_FlashStatus not being handled correctly\nStart: %X len: %X",StartOffset,len);
g_Notify->DisplayError("Reading m_FlashStatus not being handled correctly\nStart: %X len: %X",StartOffset,len);
#endif
}
*((DWORD *)(dest)) = (DWORD)((m_FlashStatus >> 32) & 0xFFFFFFFF);
@ -72,7 +72,7 @@ void CFlashram::DmaFromFlashram ( BYTE * dest, int StartOffset, int len)
break;
#ifndef EXTERNAL_RELEASE
default:
_Notify->DisplayError("DmaFromFlashram Start: %X, Offset: %X len: %X",dest - _MMU->Rdram(),StartOffset,len);
g_Notify->DisplayError("DmaFromFlashram Start: %X, Offset: %X len: %X",dest - _MMU->Rdram(),StartOffset,len);
#endif
}
}
@ -84,7 +84,7 @@ void CFlashram::DmaToFlashram(BYTE * Source, int StartOffset, int len) {
break;
#ifndef EXTERNAL_RELEASE
default:
_Notify->DisplayError("DmaToFlashram Start: %X, Offset: %X len: %X",Source - _MMU->Rdram(),StartOffset,len);
g_Notify->DisplayError("DmaToFlashram Start: %X, Offset: %X len: %X",Source - _MMU->Rdram(),StartOffset,len);
#endif
}
}
@ -96,7 +96,7 @@ DWORD CFlashram::ReadFromFlashStatus (DWORD PAddr)
case 0x08000000: return (DWORD)(m_FlashStatus >> 32);
default:
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Reading from flash ram status (%X)",PAddr);
g_Notify->DisplayError("Reading from flash ram status (%X)",PAddr);
#endif
break;
}
@ -120,7 +120,7 @@ bool CFlashram::LoadFlashram (void) {
if (m_hFile == INVALID_HANDLE_VALUE)
{
WriteTraceF(TraceError,"CFlashram::LoadFlashram: Failed to open (%s), ReadOnly = %d, LastError = %X",(LPCTSTR)FileName, m_ReadOnly, GetLastError());
_Notify->DisplayError(GS(MSG_FAIL_OPEN_FLASH));
g_Notify->DisplayError(GS(MSG_FAIL_OPEN_FLASH));
return false;
}
SetFilePointer(m_hFile,0,NULL,FILE_BEGIN);
@ -174,7 +174,7 @@ void CFlashram::WriteToFlashCommand(DWORD FlashRAM_Command) {
}
break;
default:
_Notify->DisplayError("Writing %X to flash ram command register\nm_FlashFlag: %d",FlashRAM_Command,m_FlashFlag);
g_Notify->DisplayError("Writing %X to flash ram command register\nm_FlashFlag: %d",FlashRAM_Command,m_FlashFlag);
}
m_FlashFlag = FLASHRAM_MODE_NOPES;
break;
@ -202,7 +202,7 @@ void CFlashram::WriteToFlashCommand(DWORD FlashRAM_Command) {
break;
#ifndef EXTERNAL_RELEASE
default:
_Notify->DisplayError("Writing %X to flash ram command register",FlashRAM_Command);
g_Notify->DisplayError("Writing %X to flash ram command register",FlashRAM_Command);
#endif
}
}

190
Source/Project64/N64 System/Mips/Memory Virtual Mem.cpp
View File

@ -210,7 +210,7 @@ BOOL CMipsMemoryVM::LW_VAddr ( DWORD VAddr, DWORD & Value )
// if (LookUpMode == FuncFind_ChangeMemory)
// {
// _Notify->BreakPoint(__FILE__,__LINE__);
// g_Notify->BreakPoint(__FILE__,__LINE__);
// if ( (Command.Hex >> 16) == 0x7C7C) {
// Command.Hex = OrigMem[(Command.Hex & 0xFFFF)].OriginalValue;
// }
@ -293,7 +293,7 @@ void CMipsMemoryVM::Compile_LB ( x86Reg Reg, DWORD VAddr, BOOL SignExtend) {
if (!TranslateVaddr(VAddr,PAddr)) {
MoveConstToX86reg(0,Reg);
CPU_Message("Compile_LB\nFailed to translate address %X",VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_LB\nFailed to translate address %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_LB\nFailed to translate address %X",VAddr); }
return;
}
@ -316,7 +316,7 @@ void CMipsMemoryVM::Compile_LB ( x86Reg Reg, DWORD VAddr, BOOL SignExtend) {
break;
default:
MoveConstToX86reg(0,Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_LB\nFailed to compile address: %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_LB\nFailed to compile address: %X",VAddr); }
}
}
@ -327,7 +327,7 @@ void CMipsMemoryVM::Compile_LH ( x86Reg Reg, DWORD VAddr, BOOL SignExtend) {
if (!TranslateVaddr(VAddr, PAddr)) {
MoveConstToX86reg(0,Reg);
CPU_Message("Compile_LH\nFailed to translate address %X",VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_LH\nFailed to translate address %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_LH\nFailed to translate address %X",VAddr); }
return;
}
@ -350,7 +350,7 @@ void CMipsMemoryVM::Compile_LH ( x86Reg Reg, DWORD VAddr, BOOL SignExtend) {
break;
default:
MoveConstToX86reg(0,Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_LHU\nFailed to compile address: %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_LHU\nFailed to compile address: %X",VAddr); }
}
}
@ -363,7 +363,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
{
if (!bUseTlb())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
@ -376,7 +376,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
} else {
if (!TranslateVaddr(VAddr, PAddr))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
switch (PAddr & 0xFFF00000) {
@ -405,7 +405,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
case 0x04080000: MoveVariableToX86reg(&_Reg->SP_PC_REG,"SP_PC_REG",Reg); break;
default:
MoveConstToX86reg(0,Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
}
break;
case 0x04100000:
@ -428,7 +428,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
case 0x0430000C: MoveVariableToX86reg(&_Reg->MI_INTR_MASK_REG,"MI_INTR_MASK_REG",Reg); break;
default:
MoveConstToX86reg(0,Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
}
break;
case 0x04400000:
@ -445,7 +445,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
break;
default:
MoveConstToX86reg(0,Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
}
break;
case 0x04500000: /* AI registers */
@ -489,7 +489,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
break;
default:
MoveConstToX86reg(0,Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
}
break;
case 0x04600000:
@ -505,7 +505,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
case 0x04600030: MoveVariableToX86reg(&_Reg->PI_BSD_DOM2_RLS_REG,"PI_BSD_DOM2_RLS_REG",Reg); break;
default:
MoveConstToX86reg(0,Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
}
break;
case 0x04700000:
@ -514,7 +514,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
case 0x04700010: MoveVariableToX86reg(&_Reg->RI_REFRESH_REG,"RI_REFRESH_REG",Reg); break;
default:
MoveConstToX86reg(0,Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
}
break;
case 0x04800000:
@ -522,7 +522,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
case 0x04800018: MoveVariableToX86reg(&_Reg->SI_STATUS_REG,"SI_STATUS_REG",Reg); break;
default:
MoveConstToX86reg(0,Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr); }
}
break;
case 0x1FC00000:
@ -533,7 +533,7 @@ void CMipsMemoryVM::Compile_LW (x86Reg Reg, DWORD VAddr ) {
MoveConstToX86reg(((PAddr & 0xFFFF) << 16) | (PAddr & 0xFFFF),Reg);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) {
CPU_Message(__FUNCTION__ "\nFailed to translate address: %X",VAddr);
_Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr);
g_Notify->DisplayError(__FUNCTION__ "\nFailed to translate address: %X",VAddr);
}
}
}
@ -545,7 +545,7 @@ void CMipsMemoryVM::Compile_SB_Const ( BYTE Value, DWORD VAddr ) {
if (!TranslateVaddr(VAddr, PAddr)) {
CPU_Message("Compile_SB\nFailed to translate address %X",VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SB\nFailed to translate address %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SB\nFailed to translate address %X",VAddr); }
return;
}
@ -562,7 +562,7 @@ void CMipsMemoryVM::Compile_SB_Const ( BYTE Value, DWORD VAddr ) {
MoveConstByteToVariable(Value,PAddr + m_RDRAM,VarName);
break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SB_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SB_Const\ntrying to store %X in %X?",Value,VAddr); }
}
}
@ -572,7 +572,7 @@ void CMipsMemoryVM::Compile_SB_Register ( x86Reg Reg, DWORD VAddr ) {
if (!TranslateVaddr(VAddr, PAddr)) {
CPU_Message("Compile_SB\nFailed to translate address %X",VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SB\nFailed to translate address %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SB\nFailed to translate address %X",VAddr); }
return;
}
@ -589,7 +589,7 @@ void CMipsMemoryVM::Compile_SB_Register ( x86Reg Reg, DWORD VAddr ) {
MoveX86regByteToVariable(Reg,PAddr + m_RDRAM,VarName);
break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SB_Register\ntrying to store in %X?",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SB_Register\ntrying to store in %X?",VAddr); }
}
}
@ -599,7 +599,7 @@ void CMipsMemoryVM::Compile_SH_Const ( WORD Value, DWORD VAddr ) {
if (!TranslateVaddr(VAddr, PAddr)) {
CPU_Message("Compile_SH\nFailed to translate address %X",VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SH\nFailed to translate address %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SH\nFailed to translate address %X",VAddr); }
return;
}
@ -616,7 +616,7 @@ void CMipsMemoryVM::Compile_SH_Const ( WORD Value, DWORD VAddr ) {
MoveConstHalfToVariable(Value,PAddr + m_RDRAM,VarName);
break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SH_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SH_Const\ntrying to store %X in %X?",Value,VAddr); }
}
}
@ -626,7 +626,7 @@ void CMipsMemoryVM::Compile_SH_Register ( x86Reg Reg, DWORD VAddr ) {
if (!TranslateVaddr(VAddr, PAddr)) {
CPU_Message("Compile_SH\nFailed to translate address %X",VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SH\nFailed to translate address %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SH\nFailed to translate address %X",VAddr); }
return;
}
@ -643,7 +643,7 @@ void CMipsMemoryVM::Compile_SH_Register ( x86Reg Reg, DWORD VAddr ) {
MoveX86regHalfToVariable(Reg,PAddr + m_RDRAM,VarName);
break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SH_Register\ntrying to store in %X?",PAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SH_Register\ntrying to store in %X?",PAddr); }
}
}
@ -654,7 +654,7 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
if (!TranslateVaddr(VAddr, PAddr)) {
CPU_Message("Compile_SW\nFailed to translate address %X",VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW\nFailed to translate address %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW\nFailed to translate address %X",VAddr); }
return;
}
@ -689,7 +689,7 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
case 0x03F8000C: break;
case 0x03F80014: break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
}
break;
case 0x04000000:
@ -771,7 +771,7 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
case 0x0404001C: MoveConstToVariable(0,&_Reg->SP_SEMAPHORE_REG,"SP_SEMAPHORE_REG"); break;
case 0x04080000: MoveConstToVariable(Value & 0xFFC,&_Reg->SP_PC_REG,"SP_PC_REG"); break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
}
break;
case 0x04300000:
@ -827,7 +827,7 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
}
break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
}
break;
case 0x04400000:
@ -879,7 +879,7 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
case 0x04400030: MoveConstToVariable(Value,&_Reg->VI_X_SCALE_REG,"VI_X_SCALE_REG"); break;
case 0x04400034: MoveConstToVariable(Value,&_Reg->VI_Y_SCALE_REG,"VI_Y_SCALE_REG"); break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
}
break;
case 0x04500000: /* AI registers */
@ -919,7 +919,7 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
default:
sprintf(VarName,"m_RDRAM + %X",PAddr);
MoveConstToVariable(Value,PAddr + m_RDRAM,VarName);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
}
break;
case 0x04600000:
@ -954,7 +954,7 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
case 0x0460001C: MoveConstToVariable((Value & 0xFF),&_Reg->PI_BSD_DOM1_PGS_REG,"PI_BSD_DOM1_PGS_REG"); break;
case 0x04600020: MoveConstToVariable((Value & 0xFF),&_Reg->PI_BSD_DOM1_RLS_REG,"PI_BSD_DOM1_RLS_REG"); break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
}
break;
case 0x04700000:
@ -964,7 +964,7 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
case 0x04700008: MoveConstToVariable(Value,&_Reg->RI_CURRENT_LOAD_REG,"RI_CURRENT_LOAD_REG"); break;
case 0x0470000C: MoveConstToVariable(Value,&_Reg->RI_SELECT_REG,"RI_SELECT_REG"); break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
}
break;
case 0x04800000:
@ -999,11 +999,11 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
AfterCallDirect(m_RegWorkingSet);
break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
}
break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Const\ntrying to store %X in %X?",Value,VAddr); }
}
}
@ -1015,7 +1015,7 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
if (!TranslateVaddr(VAddr, PAddr)) {
CPU_Message("Compile_SW_Register\nFailed to translate address %X",VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\nFailed to translate address %X",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\nFailed to translate address %X",VAddr); }
return;
}
@ -1069,7 +1069,7 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
MoveX86regToVariable(Reg,PAddr + m_RDRAM,VarName);
} else {
CPU_Message(" Should be moving %s in to %X ?!?",x86_Name(Reg),VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
}
}
break;
@ -1103,7 +1103,7 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
break;
default:
CPU_Message(" Should be moving %s in to %X ?!?",x86_Name(Reg),VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
}
break;
case 0x04400000:
@ -1159,7 +1159,7 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
case 0x04400034: MoveX86regToVariable(Reg,&_Reg->VI_Y_SCALE_REG,"VI_Y_SCALE_REG"); break;
default:
CPU_Message(" Should be moving %s in to %X ?!?",x86_Name(Reg),VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
}
break;
case 0x04500000: /* AI registers */
@ -1203,7 +1203,7 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
default:
sprintf(VarName,"m_RDRAM + %X",PAddr);
MoveX86regToVariable(Reg,PAddr + m_RDRAM,VarName);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); } }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); } }
break;
case 0x04600000:
switch (PAddr) {
@ -1224,7 +1224,7 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
AfterCallDirect(m_RegWorkingSet);
break;
case 0x04600010:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
AndConstToVariable((DWORD)~MI_INTR_PI,&_Reg->MI_INTR_REG,"MI_INTR_REG");
BeforeCallDirect(m_RegWorkingSet);
MoveConstToX86reg((DWORD)_Reg,x86_ECX);
@ -1251,14 +1251,14 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
break;
default:
CPU_Message(" Should be moving %s in to %X ?!?",x86_Name(Reg),VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
}
break;
case 0x04700000:
switch (PAddr) {
case 0x04700010: MoveX86regToVariable(Reg,&_Reg->RI_REFRESH_REG,"RI_REFRESH_REG"); break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
}
break;
case 0x04800000:
@ -1287,7 +1287,7 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
AfterCallDirect(m_RegWorkingSet);
break;
default:
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\ntrying to store at %X?",VAddr); }
}
break;
case 0x1FC00000:
@ -1296,7 +1296,7 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
break;
default:
CPU_Message(" Should be moving %s in to %X ?!?",x86_Name(Reg),VAddr);
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { _Notify->DisplayError("Compile_SW_Register\ntrying to store in %X?",VAddr); }
if (_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError("Compile_SW_Register\ntrying to store in %X?",VAddr); }
}
}
@ -1338,7 +1338,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
{
if (dwExptCode != EXCEPTION_ACCESS_VIOLATION)
{
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
@ -1348,7 +1348,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
DWORD MemAddress = (char *)lpEP->ExceptionRecord->ExceptionInformation[1] - (char *)_MMU->Rdram();
if ((int)(MemAddress) < 0 || MemAddress > 0x1FFFFFFF)
{
// if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
// if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
@ -1364,7 +1364,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
if ((int)Start < 0)
{
if (bHaveDebugger()) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
return EXCEPTION_EXECUTE_HANDLER;
}
@ -1390,7 +1390,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
_Recompiler->ClearRecompCode_Phys(Start & ~0xFFF,0x1000,CRecompiler::Remove_ProtectedMem);
return EXCEPTION_CONTINUE_EXECUTION;
}
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
@ -1435,7 +1435,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 6: ReadPos += 1; break;
case 7: ReadPos += 1; break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
case 5: ReadPos += 5; break;
@ -1455,13 +1455,13 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0x86: ReadPos += 5; break;
case 0x87: ReadPos += 5; break;
default:
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
if (Reg == NULL)
{
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
@ -1471,7 +1471,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0xB6:
if (!LB_NonMemory(MemAddress,(DWORD *)Reg,FALSE)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to load byte\n\nMIPS Address: %X\nX86 Address",
g_Notify->DisplayError("Failed to load byte\n\nMIPS Address: %X\nX86 Address",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
@ -1481,7 +1481,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0xB7:
if (!LH_NonMemory(MemAddress,(DWORD *)Reg,FALSE)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to load half word\n\nMIPS Address: %X\nX86 Address",
g_Notify->DisplayError("Failed to load half word\n\nMIPS Address: %X\nX86 Address",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
@ -1491,7 +1491,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0xBE:
if (!LB_NonMemory(MemAddress,Reg,TRUE)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to load byte\n\nMIPS Address: %X\nX86 Address",
g_Notify->DisplayError("Failed to load byte\n\nMIPS Address: %X\nX86 Address",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
@ -1501,7 +1501,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0xBF:
if (!LH_NonMemory(MemAddress,Reg,TRUE)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to load half word\n\nMIPS Address: %X\nX86 Address",
g_Notify->DisplayError("Failed to load half word\n\nMIPS Address: %X\nX86 Address",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
@ -1509,7 +1509,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
lpEP->ContextRecord->Eip = (DWORD)ReadPos;
return EXCEPTION_CONTINUE_EXECUTION;
default:
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
break;
@ -1518,7 +1518,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0x8B:
if (!LH_NonMemory(MemAddress,Reg,FALSE)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to half word\n\nMIPS Address: %X\nX86 Address",
g_Notify->DisplayError("Failed to half word\n\nMIPS Address: %X\nX86 Address",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
@ -1528,7 +1528,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0x89:
if (!SH_NonMemory(MemAddress,*(WORD *)Reg)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to store half word\n\nMIPS Address: %X\nX86 Address",MemAddress,
g_Notify->DisplayError("Failed to store half word\n\nMIPS Address: %X\nX86 Address",MemAddress,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
}
@ -1537,26 +1537,26 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0xC7:
if (Reg != &lpEP->ContextRecord->Eax)
{
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
if (!SH_NonMemory(MemAddress,*(WORD *)ReadPos)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to store half word\n\nMIPS Address: %X\nX86 Address",MemAddress,
g_Notify->DisplayError("Failed to store half word\n\nMIPS Address: %X\nX86 Address",MemAddress,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
}
lpEP->ContextRecord->Eip = (DWORD)(ReadPos + 2);
return EXCEPTION_CONTINUE_EXECUTION;
default:
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
break;
case 0x88:
if (!SB_NonMemory(MemAddress,*(BYTE *)Reg)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to store byte\n\nMIPS Address: %X\nX86 Address",
g_Notify->DisplayError("Failed to store byte\n\nMIPS Address: %X\nX86 Address",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
@ -1566,7 +1566,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0x8A:
if (!LB_NonMemory(MemAddress,Reg,FALSE)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to load byte\n\nMIPS Address: %X\nX86 Address",
g_Notify->DisplayError("Failed to load byte\n\nMIPS Address: %X\nX86 Address",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
@ -1576,7 +1576,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0x8B:
if (!LW_NonMemory(MemAddress,Reg)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to load word\n\nMIPS Address: %X\nX86 Address",
g_Notify->DisplayError("Failed to load word\n\nMIPS Address: %X\nX86 Address",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
@ -1586,7 +1586,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0x89:
if (!SW_NonMemory(MemAddress,*(DWORD *)Reg)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to store word\n\nMIPS Address: %X\nX86 Address",MemAddress,
g_Notify->DisplayError("Failed to store word\n\nMIPS Address: %X\nX86 Address",MemAddress,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
}
@ -1595,12 +1595,12 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0xC6:
if (Reg != &lpEP->ContextRecord->Eax)
{
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
if (!SB_NonMemory(MemAddress,*(BYTE *)ReadPos)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to store byte\n\nMIPS Address: %X\nX86 Address",MemAddress,
g_Notify->DisplayError("Failed to store byte\n\nMIPS Address: %X\nX86 Address",MemAddress,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
}
@ -1609,22 +1609,22 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0xC7:
if (Reg != &lpEP->ContextRecord->Eax)
{
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
if (!SW_NonMemory(MemAddress,*(DWORD *)ReadPos)) {
if (_Settings->LoadDword(Debugger_ShowUnhandledMemory)) {
_Notify->DisplayError("Failed to store word\n\nMIPS Address: %X\nX86 Address",MemAddress,
g_Notify->DisplayError("Failed to store word\n\nMIPS Address: %X\nX86 Address",MemAddress,
*(unsigned char *)lpEP->ContextRecord->Eip);
}
}
lpEP->ContextRecord->Eip = (DWORD)(ReadPos + 4);
return EXCEPTION_CONTINUE_EXECUTION;
default:
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
if (bHaveDebugger()) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (bHaveDebugger()) { g_Notify->BreakPoint(__FILE__,__LINE__); }
return EXCEPTION_EXECUTE_HANDLER;
}
@ -1635,7 +1635,7 @@ int CMipsMemoryVM::LB_NonMemory ( DWORD PAddr, DWORD * Value, BOOL /*SignExtend*
* Value = 0;
return true;
}
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (PAddr >= 0x10000000 && PAddr < 0x16000000) {
if (WrittenToRom) { return FALSE; }
@ -1670,7 +1670,7 @@ int CMipsMemoryVM::LH_NonMemory ( DWORD PAddr, DWORD * Value, int/* SignExtend*/
return true;
}
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
// switch (PAddr & 0xFFF00000) {
// default:
* Value = 0;
@ -1879,7 +1879,7 @@ int CMipsMemoryVM::LW_NonMemory ( DWORD PAddr, DWORD * Value ) {
mov ToSwap,eax
}
* Value = ToSwap;*/
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return TRUE;
}
else if (PAddr < 0x1FC00800)
@ -1897,7 +1897,7 @@ int CMipsMemoryVM::LW_NonMemory ( DWORD PAddr, DWORD * Value ) {
* Value = 0;
return FALSE;
}
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
break;
default:
*Value = PAddr & 0xFFFF;
@ -1924,7 +1924,7 @@ int CMipsMemoryVM::SB_NonMemory ( DWORD PAddr, BYTE Value ) {
VirtualProtect(m_RDRAM+(PAddr & ~0xFFF),0xFFC,PAGE_READWRITE, &OldProtect);
*(BYTE *)(m_RDRAM+PAddr) = Value;
VirtualProtect(m_RDRAM+(PAddr & ~0xFFF),0xFFC,OldProtect, &OldProtect);
_Notify->DisplayError("FrameBufferWrite");
g_Notify->DisplayError("FrameBufferWrite");
if (FrameBufferWrite) { FrameBufferWrite(PAddr,1); }
break;
}
@ -1962,7 +1962,7 @@ int CMipsMemoryVM::SH_NonMemory ( DWORD PAddr, WORD Value ) {
if (FrameBufferWrite) { FrameBufferWrite(PAddr & ~0xFFF,2); }
//*(WORD *)(m_RDRAM+PAddr) = 0xFFFF;
//VirtualProtect(m_RDRAM+(PAddr & ~0xFFF),0xFFC,PAGE_NOACCESS, &OldProtect);
_Notify->DisplayError("PAddr = %x",PAddr);
g_Notify->DisplayError("PAddr = %x",PAddr);
break;
}
#endif
@ -2013,7 +2013,7 @@ int CMipsMemoryVM::SW_NonMemory ( DWORD PAddr, DWORD Value ) {
VirtualProtect(m_RDRAM+(PAddr & ~0xFFF),0xFFC,PAGE_READWRITE, &OldProtect);
*(DWORD *)(m_RDRAM+PAddr) = Value;
VirtualProtect(m_RDRAM+(PAddr & ~0xFFF),0xFFC,OldProtect, &OldProtect);
_Notify->DisplayError("FrameBufferWrite %X",PAddr);
g_Notify->DisplayError("FrameBufferWrite %X",PAddr);
if (FrameBufferWrite) { FrameBufferWrite(PAddr,4); }
break;
}
@ -2073,7 +2073,7 @@ int CMipsMemoryVM::SW_NonMemory ( DWORD PAddr, DWORD Value ) {
_Reg->CheckInterrupts();
}
#ifndef EXTERNAL_RELEASE
if ( ( Value & SP_SET_INTR ) != 0) { _Notify->DisplayError("SP_SET_INTR"); }
if ( ( Value & SP_SET_INTR ) != 0) { g_Notify->DisplayError("SP_SET_INTR"); }
#endif
if ( ( Value & SP_CLR_SSTEP ) != 0) { _Reg->SP_STATUS_REG &= ~SP_STATUS_SSTEP; }
if ( ( Value & SP_SET_SSTEP ) != 0) { _Reg->SP_STATUS_REG |= SP_STATUS_SSTEP; }
@ -2106,7 +2106,7 @@ int CMipsMemoryVM::SW_NonMemory ( DWORD PAddr, DWORD Value ) {
try {
_System->RunRSP();
} catch (...) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
//}
break;
@ -2144,17 +2144,17 @@ int CMipsMemoryVM::SW_NonMemory ( DWORD PAddr, DWORD Value ) {
try {
_System->RunRSP();
} catch (...) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
}
}
#ifdef tofix
if (ShowUnhandledMemory) {
//if ( ( Value & DPC_CLR_TMEM_CTR ) != 0) { _Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_TMEM_CTR"); }
//if ( ( Value & DPC_CLR_PIPE_CTR ) != 0) { _Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_PIPE_CTR"); }
//if ( ( Value & DPC_CLR_CMD_CTR ) != 0) { _Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_CMD_CTR"); }
//if ( ( Value & DPC_CLR_CLOCK_CTR ) != 0) { _Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_CLOCK_CTR"); }
//if ( ( Value & DPC_CLR_TMEM_CTR ) != 0) { g_Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_TMEM_CTR"); }
//if ( ( Value & DPC_CLR_PIPE_CTR ) != 0) { g_Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_PIPE_CTR"); }
//if ( ( Value & DPC_CLR_CMD_CTR ) != 0) { g_Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_CMD_CTR"); }
//if ( ( Value & DPC_CLR_CLOCK_CTR ) != 0) { g_Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_CLOCK_CTR"); }
}
#endif
break;
@ -2283,7 +2283,7 @@ int CMipsMemoryVM::SW_NonMemory ( DWORD PAddr, DWORD Value ) {
PI_DMA_WRITE();
break;
case 0x04600010:
//if ((Value & PI_SET_RESET) != 0 ) { _Notify->DisplayError("reset Controller"); }
//if ((Value & PI_SET_RESET) != 0 ) { g_Notify->DisplayError("reset Controller"); }
if ((Value & PI_CLR_INTR) != 0 ) {
_Reg->MI_INTR_REG &= ~MI_INTR_PI;
_Reg->CheckInterrupts();
@ -2384,12 +2384,12 @@ void CMipsMemoryVM::ProtectMemory( DWORD StartVaddr, DWORD EndVaddr )
//Get Physical Addresses passed
DWORD StartPAddr, EndPAddr;
if (!TranslateVaddr(StartVaddr,StartPAddr)) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (!TranslateVaddr(EndVaddr,EndPAddr)) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (!TranslateVaddr(StartVaddr,StartPAddr)) { g_Notify->BreakPoint(__FILE__,__LINE__); }
if (!TranslateVaddr(EndVaddr,EndPAddr)) { g_Notify->BreakPoint(__FILE__,__LINE__); }
//Get Length of memory being protected
int Length = ((EndPAddr + 3) - StartPAddr) & ~3;
if (Length < 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (Length < 0) { g_Notify->BreakPoint(__FILE__,__LINE__); }
//Proect that memory address space
DWORD OldProtect;
@ -2406,12 +2406,12 @@ void CMipsMemoryVM::UnProtectMemory( DWORD StartVaddr, DWORD EndVaddr )
//Get Physical Addresses passed
DWORD StartPAddr, EndPAddr;
if (!TranslateVaddr(StartVaddr,StartPAddr)) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (!TranslateVaddr(EndVaddr,EndPAddr)) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (!TranslateVaddr(StartVaddr,StartPAddr)) { g_Notify->BreakPoint(__FILE__,__LINE__); }
if (!TranslateVaddr(EndVaddr,EndPAddr)) { g_Notify->BreakPoint(__FILE__,__LINE__); }
//Get Length of memory being protected
int Length = ((EndPAddr + 3) - StartPAddr) & ~3;
if (Length < 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (Length < 0) { g_Notify->BreakPoint(__FILE__,__LINE__); }
//Proect that memory address space
DWORD OldProtect;
@ -3558,7 +3558,7 @@ void CMipsMemoryVM::Compile_StoreInstructClean (x86Reg AddressReg, int Length )
{
return;
}
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
/*
stdstr_f strLen("%d",Length);
@ -3851,7 +3851,7 @@ void CMipsMemoryVM::RdramChanged ( CMipsMemoryVM * _this )
if (VirtualAlloc(_this->m_RDRAM + 0x400000, 0x400000, MEM_COMMIT, PAGE_READWRITE)==NULL)
{
WriteTrace(TraceError,"CMipsMemoryVM::RdramChanged: failed to allocate extended memory");
_Notify->FatalError(GS(MSG_MEM_ALLOC_ERROR));
g_Notify->FatalError(GS(MSG_MEM_ALLOC_ERROR));
}
_this->m_AllocatedRdramSize = 0x800000;
} else {
@ -3872,7 +3872,7 @@ void CMipsMemoryVM::ChangeSpStatus (void)
_Reg->CheckInterrupts();
}
#ifndef EXTERNAL_RELEASE
if ( ( RegModValue & SP_SET_INTR ) != 0) { _Notify->DisplayError("SP_SET_INTR"); }
if ( ( RegModValue & SP_SET_INTR ) != 0) { g_Notify->DisplayError("SP_SET_INTR"); }
#endif
if ( ( RegModValue & SP_CLR_SSTEP ) != 0) { _Reg->SP_STATUS_REG &= ~SP_STATUS_SSTEP; }
if ( ( RegModValue & SP_SET_SSTEP ) != 0) { _Reg->SP_STATUS_REG |= SP_STATUS_SSTEP; }
@ -3906,7 +3906,7 @@ void CMipsMemoryVM::ChangeSpStatus (void)
try {
_System->RunRSP();
} catch (...) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
//}
}

12
Source/Project64/N64 System/Mips/OpCode Analysis Class.cpp
View File

@ -51,7 +51,7 @@ bool COpcodeAnalysis::DelaySlotEffectsCompare (DWORD Reg1, DWORD Reg2) {
case R4300i_SPECIAL_JALR:
return true;
default:
//_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC());
//g_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC());
return true;
}
break;
@ -72,11 +72,11 @@ bool COpcodeAnalysis::DelaySlotEffectsCompare (DWORD Reg1, DWORD Reg2) {
case R4300i_COP0_CO_TLBWR: break;
case R4300i_COP0_CO_TLBP: break;
default:
//_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC());
//g_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC());
return true;
}
} else {
//_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC());
//g_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC());
return true;
}
}
@ -97,7 +97,7 @@ bool COpcodeAnalysis::DelaySlotEffectsCompare (DWORD Reg1, DWORD Reg2) {
case R4300i_COP1_W: break;
case R4300i_COP1_L: break;
default:
//_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC(),DelayOp.m_opcode.op);
//g_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC(),DelayOp.m_opcode.op);
return true;
}
break;
@ -155,7 +155,7 @@ bool COpcodeAnalysis::DelaySlotEffectsCompare (DWORD Reg1, DWORD Reg2) {
case 0x3E:
break;
default:
//_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?\n%x",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC(),DelayOp.m_opcode.op);
//g_Notify->DisplayError("%s\nDoes %s effect Delay slot at %X?\n%x",Name().c_str(),DelayOp.Name().c_str(),DelayOp.PC(),DelayOp.m_opcode.op);
return true;
}
return false;
@ -458,7 +458,7 @@ stdstr COpcodeAnalysis::FullName(bool * MultipleOps) {
OpParam = stdstr(Param);
}
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
// if (OpName.length() == 0) { OpName = OpcodeName(); }
// if (OpParam.length() == 0) { OpParam = OpcodeParam(); }
while (OpName.length() < 7) { OpName += " "; }

4
Source/Project64/N64 System/Mips/OpCode Class.cpp
View File

@ -41,7 +41,7 @@ COpcode::COpcode ( DWORD VirtualAddress ):
//set up the details about the current opcode
m_opcode.VirtualAddress = VirtualAddress & ~3;
if (!SetPC(m_opcode.VirtualAddress)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -84,7 +84,7 @@ bool COpcode::Next (void) {
break;
default:
m_opcode.VirtualAddress += m_OpLen;
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (!_MMU->LW_VAddr(m_opcode.VirtualAddress,m_opcode.Hex)) {

34
Source/Project64/N64 System/Mips/Pif Ram.cpp
View File

@ -107,7 +107,7 @@ void CPifRam::PifRamRead (void)
CurPos += m_PifRam[CurPos] + (m_PifRam[CurPos + 1] & 0x3F) + 1;
Channel += 1;
} else {
if (bShowPifRamErrors()) { _Notify->DisplayError("Unknown Command in PifRamRead(%X)",m_PifRam[CurPos]); }
if (bShowPifRamErrors()) { g_Notify->DisplayError("Unknown Command in PifRamRead(%X)",m_PifRam[CurPos]); }
CurPos = 0x40;
}
break;
@ -158,7 +158,7 @@ void CPifRam::PifRamWrite (void) {
memset(m_PifRam,0,0x40);
break;
default:
if (bShowPifRamErrors()) { _Notify->DisplayError("Unkown PifRam control: %d",m_PifRam[0x3F]); }
if (bShowPifRamErrors()) { g_Notify->DisplayError("Unkown PifRam control: %d",m_PifRam[0x3F]); }
}
return;
}
@ -185,13 +185,13 @@ void CPifRam::PifRamWrite (void) {
} else {
if (bShowPifRamErrors())
{
_Notify->DisplayError("Command on channel 5?");
g_Notify->DisplayError("Command on channel 5?");
}
}
CurPos += m_PifRam[CurPos] + (m_PifRam[CurPos + 1] & 0x3F) + 1;
Channel += 1;
} else {
if (bShowPifRamErrors()) { _Notify->DisplayError("Unknown Command in PifRamWrite(%X)",m_PifRam[CurPos]); }
if (bShowPifRamErrors()) { g_Notify->DisplayError("Unknown Command in PifRamWrite(%X)",m_PifRam[CurPos]); }
CurPos = 0x40;
}
break;
@ -211,7 +211,7 @@ void CPifRam::SI_DMA_READ (void)
{
if (bShowPifRamErrors())
{
_Notify->DisplayError("SI DMA\nSI_DRAM_ADDR_REG not in RDRam space");
g_Notify->DisplayError("SI DMA\nSI_DRAM_ADDR_REG not in RDRam space");
}
return;
}
@ -303,7 +303,7 @@ void CPifRam::SI_DMA_WRITE (void)
{
if (bShowPifRamErrors())
{
_Notify->DisplayError("SI DMA\nSI_DRAM_ADDR_REG not in RDRam space");
g_Notify->DisplayError("SI DMA\nSI_DRAM_ADDR_REG not in RDRam space");
}
return;
}
@ -400,8 +400,8 @@ void CPifRam::ProcessControllerCommand ( int Control, BYTE * Command)
if ((Command[1] & 0x80) != 0) { break; }
if (bShowPifRamErrors())
{
if (Command[0] != 1) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 3) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[0] != 1) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 3) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
}
if (Controllers[Control].Present == TRUE) {
Command[3] = 0x05;
@ -419,8 +419,8 @@ void CPifRam::ProcessControllerCommand ( int Control, BYTE * Command)
case 0x01: // read controller
if (bShowPifRamErrors())
{
if (Command[0] != 1) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 4) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[0] != 1) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 4) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
}
if (Controllers[Control].Present == FALSE) {
Command[1] |= 0x80;
@ -432,8 +432,8 @@ void CPifRam::ProcessControllerCommand ( int Control, BYTE * Command)
#endif
if (bShowPifRamErrors())
{
if (Command[0] != 3) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 33) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[0] != 3) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 33) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
}
if (Controllers[Control].Present == TRUE) {
DWORD address = ((Command[3] << 8) | Command[4]);
@ -462,8 +462,8 @@ void CPifRam::ProcessControllerCommand ( int Control, BYTE * Command)
#endif
if (bShowPifRamErrors())
{
if (Command[0] != 35) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 1) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[0] != 35) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 1) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
}
if (Controllers[Control].Present == TRUE) {
DWORD address = ((Command[3] << 8) | Command[4]);
@ -485,7 +485,7 @@ void CPifRam::ProcessControllerCommand ( int Control, BYTE * Command)
#endif
break;
default:
if (bShowPifRamErrors()) { _Notify->DisplayError("Unknown ControllerCommand %d",Command[2]); }
if (bShowPifRamErrors()) { g_Notify->DisplayError("Unknown ControllerCommand %d",Command[2]); }
}
}
@ -498,8 +498,8 @@ void CPifRam::ReadControllerCommand (int Control, BYTE * Command) {
{
if (bShowPifRamErrors())
{
if (Command[0] != 1) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 4) { _Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[0] != 1) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 4) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
}
*(DWORD *)&Command[3] = _BaseSystem->GetButtons(Control);
}

20
Source/Project64/N64 System/Mips/Register Class.cpp
View File

@ -296,12 +296,12 @@ void CRegisters::CheckInterrupts ( void )
void CRegisters::DoAddressError ( BOOL DelaySlot, DWORD BadVaddr, BOOL FromRead)
{
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("AddressError");
g_Notify->DisplayError("AddressError");
if (( STATUS_REGISTER & STATUS_EXL ) != 0 ) {
_Notify->DisplayError("EXL set in AddressError Exception");
g_Notify->DisplayError("EXL set in AddressError Exception");
}
if (( STATUS_REGISTER & STATUS_ERL ) != 0 ) {
_Notify->DisplayError("ERL set in AddressError Exception");
g_Notify->DisplayError("ERL set in AddressError Exception");
}
#endif
if (FromRead) {
@ -338,10 +338,10 @@ void CRegisters::DoBreakException ( BOOL DelaySlot)
{
#ifndef EXTERNAL_RELEASE
if (( STATUS_REGISTER & STATUS_EXL ) != 0 ) {
_Notify->DisplayError("EXL set in Break Exception");
g_Notify->DisplayError("EXL set in Break Exception");
}
if (( STATUS_REGISTER & STATUS_ERL ) != 0 ) {
_Notify->DisplayError("ERL set in Break Exception");
g_Notify->DisplayError("ERL set in Break Exception");
}
#endif
@ -360,10 +360,10 @@ void CRegisters::DoCopUnusableException ( BOOL DelaySlot, int Coprocessor )
{
#ifndef EXTERNAL_RELEASE
if (( STATUS_REGISTER & STATUS_EXL ) != 0 ) {
_Notify->DisplayError("EXL set in Break Exception");
g_Notify->DisplayError("EXL set in Break Exception");
}
if (( STATUS_REGISTER & STATUS_ERL ) != 0 ) {
_Notify->DisplayError("ERL set in Break Exception");
g_Notify->DisplayError("ERL set in Break Exception");
}
#endif
@ -426,7 +426,7 @@ void CRegisters::DoTLBReadMiss ( BOOL DelaySlot, DWORD BadVaddr )
STATUS_REGISTER |= STATUS_EXL;
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("TLBMiss - EXL Set\nBadVaddr = %X\nAddress Defined: %s",BadVaddr,_TLB->AddressDefined(BadVaddr)?"TRUE":"FALSE");
g_Notify->DisplayError("TLBMiss - EXL Set\nBadVaddr = %X\nAddress Defined: %s",BadVaddr,_TLB->AddressDefined(BadVaddr)?"TRUE":"FALSE");
#endif
m_PROGRAM_COUNTER = 0x80000180;
}
@ -436,10 +436,10 @@ void CRegisters::DoSysCallException ( BOOL DelaySlot)
{
#ifndef EXTERNAL_RELEASE
if (( STATUS_REGISTER & STATUS_EXL ) != 0 ) {
_Notify->DisplayError("EXL set in SysCall Exception");
g_Notify->DisplayError("EXL set in SysCall Exception");
}
if (( STATUS_REGISTER & STATUS_ERL ) != 0 ) {
_Notify->DisplayError("ERL set in SysCall Exception");
g_Notify->DisplayError("ERL set in SysCall Exception");
}
#endif

10
Source/Project64/N64 System/Mips/System Events.cpp
View File

@ -108,7 +108,7 @@ void CSystemEvents::ExecuteEvents ( void )
ChangePluginFunc();
break;
case SysEvent_ChangingFullScreen:
_Notify->ChangeFullScreen();
g_Notify->ChangeFullScreen();
break;
case SysEvent_GSButtonPressed:
if (_BaseSystem == NULL)
@ -174,7 +174,7 @@ void CSystemEvents::ExecuteEvents ( void )
}
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
break;
}
}
@ -187,7 +187,7 @@ void CSystemEvents::ExecuteEvents ( void )
void CSystemEvents::ChangePluginFunc ( void )
{
_Notify->DisplayMessage(0,MSG_PLUGIN_INIT);
g_Notify->DisplayMessage(0,MSG_PLUGIN_INIT);
if (_Settings->LoadBool(Plugin_GFX_Changed))
{
_Plugins->Reset(PLUGIN_TYPE_GFX);
@ -210,10 +210,10 @@ void CSystemEvents::ChangePluginFunc ( void )
_Settings->SaveBool(Plugin_AUDIO_Changed,false);
_Settings->SaveBool(Plugin_GFX_Changed, false);
_Settings->SaveBool(Plugin_CONT_Changed, false);
_Notify->RefreshMenu();
g_Notify->RefreshMenu();
if (!_Plugins->Initiate())
{
_Notify->DisplayMessage(5,MSG_PLUGIN_NOT_INIT);
g_Notify->DisplayMessage(5,MSG_PLUGIN_NOT_INIT);
_BaseSystem->m_EndEmulation = true;
}
_Recompiler->ResetRecompCode();

14
Source/Project64/N64 System/Mips/System Timing.cpp
View File

@ -26,7 +26,7 @@ void CSystemTimer::SetTimer ( TimerType Type, DWORD Cycles, bool bRelative )
{
if (Type >= MaxTimer || Type == UnknownTimer)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
UpdateTimers();
@ -50,7 +50,7 @@ DWORD CSystemTimer::GetTimer ( TimerType Type )
{
if (Type >= MaxTimer || Type == UnknownTimer)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return 0;
}
if (!m_TimerDetatils[Type].Active)
@ -73,7 +73,7 @@ void CSystemTimer::StopTimer ( TimerType Type )
{
if (Type >= MaxTimer || Type == UnknownTimer)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
m_TimerDetatils[Type].Active = false;
@ -206,7 +206,7 @@ void CSystemTimer::TimerDone (void)
try {
_System->RunRSP();
} catch (...) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
case CSystemTimer::RSPTimerDlist:
@ -219,7 +219,7 @@ void CSystemTimer::TimerDone (void)
_Audio->TimerDone();
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
//CheckTimer();
/*if (Profiling) {
@ -283,8 +283,8 @@ void CSystemTimer::LoadData ( void * file )
unzReadCurrentFile( file,&TimerDetailsSize,sizeof(TimerDetailsSize));
unzReadCurrentFile( file,&Entries,sizeof(Entries));
if (TimerDetailsSize != sizeof(TIMER_DETAILS)) { _Notify->BreakPoint(__FILE__,__LINE__); return; }
if (Entries != sizeof(m_TimerDetatils)/sizeof(m_TimerDetatils[0])) { _Notify->BreakPoint(__FILE__,__LINE__); return; }
if (TimerDetailsSize != sizeof(TIMER_DETAILS)) { g_Notify->BreakPoint(__FILE__,__LINE__); return; }
if (Entries != sizeof(m_TimerDetatils)/sizeof(m_TimerDetatils[0])) { g_Notify->BreakPoint(__FILE__,__LINE__); return; }
unzReadCurrentFile(file,(void *)&m_TimerDetatils,sizeof(m_TimerDetatils));
unzReadCurrentFile(file,(void *)&m_LastUpdate,sizeof(m_LastUpdate));

92
Source/Project64/N64 System/N64 Class.cpp
View File

@ -7,8 +7,8 @@
CN64System::CN64System ( CPlugins * Plugins, bool SavesReadOnly ) :
m_MMU_VM(this,SavesReadOnly),
m_TLB(this),
m_FPS(_Notify),
m_Limitor(_Notify),
m_FPS(g_Notify),
m_Limitor(g_Notify),
m_Plugins(Plugins),
m_Cheats(NULL),
m_SyncCPU(NULL),
@ -133,7 +133,7 @@ void CN64System::ExternalEvent ( SystemEvent action )
break;
default:
WriteTraceF(TraceError,"CN64System::ExternalEvent - Unknown event %d",action);
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -176,7 +176,7 @@ bool CN64System::EmulationStarting ( HANDLE hThread, DWORD ThreadId )
_BaseSystem = NULL;
}
WriteTrace(TraceDebug,"CN64System::stLoadFileImage: Hide Rom Browser");
_Notify->HideRomBrowser();
g_Notify->HideRomBrowser();
WriteTrace(TraceDebug,"CN64System::stLoadFileImage: Creating N64 system");
_BaseSystem = new CN64System(_Plugins,false);
WriteTrace(TraceDebug,"CN64System::stLoadFileImage: Setting N64 system as active");
@ -186,7 +186,7 @@ bool CN64System::EmulationStarting ( HANDLE hThread, DWORD ThreadId )
_BaseSystem->m_CPU_ThreadID = ThreadId;
WriteTrace(TraceDebug,"CN64System::stLoadFileImage: Setting up N64 system done");
_Settings->SaveBool(GameRunning_LoadingInProgress,false);
_Notify->RefreshMenu();
g_Notify->RefreshMenu();
try
{
WriteTrace(TraceDebug,"CN64System::stLoadFileImage: Game set to auto start, starting");
@ -204,9 +204,9 @@ bool CN64System::EmulationStarting ( HANDLE hThread, DWORD ThreadId )
_BaseSystem->m_CPU_ThreadID = 0;
} else {
WriteTrace(TraceError,"CN64System::stLoadFileImage: SetActiveSystem failed");
_Notify->DisplayError("Failed to Initialize N64 System");
g_Notify->DisplayError("Failed to Initialize N64 System");
_Settings->SaveBool(GameRunning_LoadingInProgress,false);
_Notify->RefreshMenu();
g_Notify->RefreshMenu();
bRes = false;
}
@ -234,7 +234,7 @@ void CN64System::stLoadFileImage ( FileImageInfo * Info )
//Mark the rom as loading
_Settings->SaveBool(GameRunning_LoadingInProgress,true);
_Notify->RefreshMenu();
g_Notify->RefreshMenu();
//Try to load the passed N64 rom
if (_Rom == NULL)
@ -249,21 +249,21 @@ void CN64System::stLoadFileImage ( FileImageInfo * Info )
if (_Rom->LoadN64Image(ImageInfo.FileName.c_str()))
{
WriteTrace(TraceDebug,"CN64System::stLoadFileImage: Add Recent Rom");
_Notify->AddRecentRom(ImageInfo.FileName.c_str());
_Notify->SetWindowCaption(_Settings->LoadString(Game_GoodName).c_str());
g_Notify->AddRecentRom(ImageInfo.FileName.c_str());
g_Notify->SetWindowCaption(_Settings->LoadString(Game_GoodName).c_str());
if (_Settings->LoadDword(Setting_AutoStart) != 0)
{
EmulationStarting(*((HANDLE *)ImageInfo.ThreadHandle),ImageInfo.ThreadID);
}
_Settings->SaveBool(GameRunning_LoadingInProgress,false);
_Notify->RefreshMenu();
g_Notify->RefreshMenu();
} else {
WriteTraceF(TraceError,"CN64System::stLoadFileImage: LoadN64Image failed (\"%s\")",ImageInfo.FileName.c_str());
_Notify->DisplayError(_Rom->GetError());
g_Notify->DisplayError(_Rom->GetError());
delete _Rom;
_Rom = NULL;
_Settings->SaveBool(GameRunning_LoadingInProgress,false);
_Notify->RefreshMenu();
g_Notify->RefreshMenu();
return;
}
CoUninitialize();
@ -288,31 +288,31 @@ void CN64System::StartEmulation2 ( bool NewThread )
}
WriteTrace(TraceDebug,"CN64System::StartEmulation2: Starting");
_Notify->HideRomBrowser();
g_Notify->HideRomBrowser();
//RefreshSettings();
if (!SetActiveSystem())
{
_Settings->SaveBool(GameRunning_LoadingInProgress,false);
_Notify->DisplayError(MSG_PLUGIN_NOT_INIT);
g_Notify->DisplayError(MSG_PLUGIN_NOT_INIT);
//Set handle to NULL so this thread is not terminated
m_CPU_Handle = NULL;
m_CPU_ThreadID = 0;
_Notify->RefreshMenu();
_Notify->ShowRomBrowser();
g_Notify->RefreshMenu();
g_Notify->ShowRomBrowser();
}
_Notify->MakeWindowOnTop(_Settings->LoadBool(UserInterface_AlwaysOnTop));
g_Notify->MakeWindowOnTop(_Settings->LoadBool(UserInterface_AlwaysOnTop));
if (!_Settings->LoadBool(Beta_IsValidExe))
{
return;
}
//mark the emulation as starting and fix up menus
_Notify->DisplayMessage(5,MSG_EMULATION_STARTED);
g_Notify->DisplayMessage(5,MSG_EMULATION_STARTED);
if (_Settings->LoadBool(Setting_AutoFullscreen))
{
@ -324,7 +324,7 @@ void CN64System::StartEmulation2 ( bool NewThread )
RomIniFile.GetString("Rom Status",stdstr_f("%s.AutoFullScreen", Status.c_str()).c_str(),"true",String,sizeof(String));
if (_stricmp(String,"true") == 0)
{
_Notify->ChangeFullScreen();
g_Notify->ChangeFullScreen();
}
}
ExecuteCPU();
@ -376,7 +376,7 @@ void CN64System::CloseCpu ( void )
for (int count = 0; count < 200; count ++ )
{
Sleep(100);
if (_Notify->ProcessGuiMessages())
if (g_Notify->ProcessGuiMessages())
{
return;
}
@ -423,13 +423,13 @@ void CN64System::Pause(void)
}
ResetEvent(m_hPauseEvent);
_Settings->SaveBool(GameRunning_CPU_Paused,true);
_Notify->RefreshMenu();
_Notify->DisplayMessage(5,MSG_CPU_PAUSED);
g_Notify->RefreshMenu();
g_Notify->DisplayMessage(5,MSG_CPU_PAUSED);
WaitForSingleObject(m_hPauseEvent, INFINITE);
ResetEvent(m_hPauseEvent);
_Settings->SaveBool(GameRunning_CPU_Paused,(DWORD)false);
_Notify->RefreshMenu();
_Notify->DisplayMessage(5,MSG_CPU_RESUMED);
g_Notify->RefreshMenu();
g_Notify->DisplayMessage(5,MSG_CPU_RESUMED);
}
stdstr CN64System::ChooseFileToOpen ( WND_HANDLE hParent ) {
@ -577,7 +577,7 @@ bool CN64System::SetActiveSystem( bool bActive )
if (bInitPlugin)
{
WriteTrace(TraceDebug,"CN64System::SetActiveSystem: Reseting Plugins");
_Notify->DisplayMessage(5,MSG_PLUGIN_INIT);
g_Notify->DisplayMessage(5,MSG_PLUGIN_INIT);
_Plugins->Reset();
bRes = _Plugins->Initiate();
if (!bRes)
@ -765,10 +765,10 @@ void CN64System::ExecuteCPU ( void )
//reset code
_Settings->SaveBool(GameRunning_CPU_Running,true);
_Settings->SaveBool(GameRunning_CPU_Paused,false);
_Notify->DisplayMessage(5,MSG_EMULATION_STARTED);
g_Notify->DisplayMessage(5,MSG_EMULATION_STARTED);
m_EndEmulation = false;
_Notify->RefreshMenu();
g_Notify->RefreshMenu();
#ifndef EXTERNAL_RELEASE
LogOptions.GenerateLog = _Settings->LoadDword(Debugger_GenerateDebugLog);
@ -802,7 +802,7 @@ void CN64System::ExecuteRecompiler ()
void CN64System::ExecuteSyncCPU ()
{
_Notify->DisplayMessage(5,"Copy Plugins");
g_Notify->DisplayMessage(5,"Copy Plugins");
_Plugins->CopyPlugins(_Settings->LoadString(Directory_PluginSync));
CMainGui SyncWindow(false);
CPlugins SyncPlugins ( _Settings->LoadString(Directory_PluginSync) );
@ -818,13 +818,13 @@ void CN64System::ExecuteSyncCPU ()
m_Recomp->Run();
} else {
SetActiveSystem();
_Notify->DisplayError(MSG_PLUGIN_NOT_INIT);
g_Notify->DisplayError(MSG_PLUGIN_NOT_INIT);
}
}
void CN64System::CpuStopped ( void ) {
_Settings->SaveBool(GameRunning_CPU_Running,(DWORD)false);
_Notify->WindowMode();
g_Notify->WindowMode();
if (!m_InReset)
{
CloseCpu();
@ -838,11 +838,11 @@ void CN64System::CpuStopped ( void ) {
m_hPauseEvent = NULL;
}
_Notify->RefreshMenu();
_Notify->MakeWindowOnTop(false);
_Notify->DisplayMessage(5,MSG_EMULATION_ENDED);
g_Notify->RefreshMenu();
g_Notify->MakeWindowOnTop(false);
g_Notify->DisplayMessage(5,MSG_EMULATION_ENDED);
if (_Settings->LoadDword(RomBrowser_Enabled)) {
_Notify->ShowRomBrowser();
g_Notify->ShowRomBrowser();
}
}
if (m_SyncCPU)
@ -974,7 +974,7 @@ void CN64System::SyncCPU (CN64System * const SecondCPU)
}
m_LastSuccessSyncPC[0] = m_Reg.m_PROGRAM_COUNTER;
// if (PROGRAM_COUNTER == 0x8009BBD8) {
// _Notify->BreakPoint(__FILE__,__LINE__);
// g_Notify->BreakPoint(__FILE__,__LINE__);
// }
}
@ -1152,8 +1152,8 @@ void CN64System::DumpSyncErrors (CN64System * SecondCPU) {
}
}
_Notify->DisplayError("Sync Error");
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->DisplayError("Sync Error");
g_Notify->BreakPoint(__FILE__,__LINE__);
// AddEvent(CloseCPU);
}
@ -1249,7 +1249,7 @@ bool CN64System::SaveState(void)
HANDLE hSaveFile = CreateFile(FileName.c_str(),GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ,
NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
if (hSaveFile == INVALID_HANDLE_VALUE) {
_Notify->DisplayError(GS(MSG_FAIL_OPEN_SAVE));
g_Notify->DisplayError(GS(MSG_FAIL_OPEN_SAVE));
m_Reg.MI_INTR_REG = MiInterReg;
return true;
}
@ -1290,8 +1290,8 @@ bool CN64System::SaveState(void)
CPath SavedFileName(FileName);
_Notify->DisplayMessage(5,"%s %s",SaveMessage.c_str(),SavedFileName.GetNameExtension().c_str());
_Notify->RefreshMenu();
g_Notify->DisplayMessage(5,"%s %s",SaveMessage.c_str(),SavedFileName.GetNameExtension().c_str());
g_Notify->RefreshMenu();
WriteTrace(TraceDebug,"CN64System::SaveState 20");
return true;
}
@ -1434,7 +1434,7 @@ bool CN64System::LoadState(LPCSTR FileName) {
HANDLE hSaveFile = CreateFile(FileNameStr.c_str(),GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ,NULL,
OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
if (hSaveFile == INVALID_HANDLE_VALUE) {
_Notify->DisplayMessage(5,"%s %s",GS(MSG_UNABLED_LOAD_STATE),FileNameStr.c_str());
g_Notify->DisplayMessage(5,"%s %s",GS(MSG_UNABLED_LOAD_STATE),FileNameStr.c_str());
return false;
}
SetFilePointer(hSaveFile,0,NULL,FILE_BEGIN);
@ -1526,7 +1526,7 @@ bool CN64System::LoadState(LPCSTR FileName) {
WriteTrace(TraceDebug,"CN64System::LoadState 14");
stdstr LoadMsg = _Lang->GetString(MSG_LOADED_STATE);
WriteTrace(TraceDebug,"CN64System::LoadState 15");
_Notify->DisplayMessage(5,"%s %s",LoadMsg.c_str(),CPath(FileNameStr).GetNameExtension().c_str());
g_Notify->DisplayMessage(5,"%s %s",LoadMsg.c_str(),CPath(FileNameStr).GetNameExtension().c_str());
WriteTrace(TraceDebug,"CN64System::LoadState 16");
return true;
}
@ -1560,7 +1560,7 @@ void CN64System::RunRSP ( void ) {
break;
}
if (bShowDListAListCount()) {
_Notify->DisplayMessage(0,"Dlist: %d Alist: %d Unknown: %d",m_DlistCount,m_AlistCount,m_UnknownCount);
g_Notify->DisplayMessage(0,"Dlist: %d Alist: %d Unknown: %d",m_DlistCount,m_AlistCount,m_UnknownCount);
}
if (bShowCPUPer()) {
switch (Task) {
@ -1582,7 +1582,7 @@ void CN64System::RunRSP ( void ) {
WriteTrace(TraceRSP, "RunRSP: do cycles - Done");
} __except( _MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation()) ) {
WriteTrace(TraceError, "RunRSP: exception generated");
_Notify->FatalError("Unknown memory action\n\nEmulation stop");
g_Notify->FatalError("Unknown memory action\n\nEmulation stop");
}
if (Task == 1 && bDelayDP() && ((m_Reg.m_GfxIntrReg & MI_INTR_DP) != 0))
{
@ -1735,7 +1735,7 @@ bool CN64System::WriteToProtectedMemory (DWORD Address, int length)
WriteTraceF(TraceDebug,"WriteToProtectedMemory Addres: %X Len: %d",Address,length);
if (m_Recomp)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
return m_Recomp->ClearRecompCode_Phys(Address,length,CRecompiler::Remove_ProtectedMem);
#endif

24
Source/Project64/N64 System/N64 Rom Class.cpp
View File

@ -47,7 +47,7 @@ bool CN64Rom::AllocateAndLoadN64Image ( const char * FileLoc, bool LoadBootCodeO
}
//Load the n64 rom to the allocated memory
_Notify->DisplayMessage(5,MSG_LOADING);
g_Notify->DisplayMessage(5,MSG_LOADING);
SetFilePointer(hFile,0,0,FILE_BEGIN);
DWORD count, TotalRead = 0;
@ -64,7 +64,7 @@ bool CN64Rom::AllocateAndLoadN64Image ( const char * FileLoc, bool LoadBootCodeO
TotalRead += dwRead;
//Show Message of how much % wise of the rom has been loaded
_Notify->DisplayMessage(0,"%s: %.2f%c",GS(MSG_LOADED),((float)TotalRead/(float)RomFileSize) * 100.0f,'%');
g_Notify->DisplayMessage(0,"%s: %.2f%c",GS(MSG_LOADED),((float)TotalRead/(float)RomFileSize) * 100.0f,'%');
}
dwRead = TotalRead;
@ -80,7 +80,7 @@ bool CN64Rom::AllocateAndLoadN64Image ( const char * FileLoc, bool LoadBootCodeO
m_ROMImage = Image;
m_RomFileSize = RomFileSize;
_Notify->DisplayMessage(5,MSG_BYTESWAP);
g_Notify->DisplayMessage(5,MSG_BYTESWAP);
ByteSwapRom();
//Protect the memory so that it can not be written to.
@ -129,7 +129,7 @@ bool CN64Rom::AllocateAndLoadZipImage ( const char * FileLoc, bool LoadBootCodeO
}
//Load the n64 rom to the allocated memory
_Notify->DisplayMessage(5,MSG_LOADING);
g_Notify->DisplayMessage(5,MSG_LOADING);
memcpy(Image,Test,4);
DWORD dwRead, count, TotalRead = 0;
@ -147,7 +147,7 @@ bool CN64Rom::AllocateAndLoadZipImage ( const char * FileLoc, bool LoadBootCodeO
TotalRead += dwRead;
//Show Message of how much % wise of the rom has been loaded
_Notify->DisplayMessage(5,"%s: %.2f%c",GS(MSG_LOADED),((float)TotalRead/(float)RomFileSize) * 100.0f,'%');
g_Notify->DisplayMessage(5,"%s: %.2f%c",GS(MSG_LOADED),((float)TotalRead/(float)RomFileSize) * 100.0f,'%');
}
dwRead = TotalRead + 4;
@ -155,7 +155,7 @@ bool CN64Rom::AllocateAndLoadZipImage ( const char * FileLoc, bool LoadBootCodeO
VirtualFree(Image,0,MEM_RELEASE);
unzCloseCurrentFile(file);
SetError(MSG_FAIL_ZIP);
_Notify->DisplayMessage(1,"");
g_Notify->DisplayMessage(1,"");
break;
}
@ -165,13 +165,13 @@ bool CN64Rom::AllocateAndLoadZipImage ( const char * FileLoc, bool LoadBootCodeO
m_RomFileSize = RomFileSize;
FoundRom = true;
_Notify->DisplayMessage(5,MSG_BYTESWAP);
g_Notify->DisplayMessage(5,MSG_BYTESWAP);
ByteSwapRom();
//Protect the memory so that it can not be written to.
DWORD OldProtect;
VirtualProtect(m_ROMImage,m_RomFileSize,PAGE_READONLY,&OldProtect);
_Notify->DisplayMessage(1,"");
g_Notify->DisplayMessage(1,"");
}
unzCloseCurrentFile(file);
if (FoundRom == FALSE) {
@ -209,7 +209,7 @@ void CN64Rom::ByteSwapRom (void) {
break;
case 0x80371240: break;
default:
_Notify->DisplayError("ByteSwapRom: %X",m_ROMImage[0]);
g_Notify->DisplayError("ByteSwapRom: %X",m_ROMImage[0]);
}
}
@ -252,7 +252,7 @@ bool CN64Rom::IsValidRomImage ( BYTE Test[4] ) {
void CN64Rom::NotificationCB ( LPCSTR Status, CN64Rom * /*_this*/ )
{
_Notify->DisplayMessage(5,"%s",Status);
g_Notify->DisplayMessage(5,"%s",Status);
}
bool CN64Rom::LoadN64Image ( const char * FileLoc, bool LoadBootCodeOnly ) {
@ -306,7 +306,7 @@ bool CN64Rom::LoadN64Image ( const char * FileLoc, bool LoadBootCodeOnly ) {
}
//Load the n64 rom to the allocated memory
_Notify->DisplayMessage(5,MSG_LOADING);
g_Notify->DisplayMessage(5,MSG_LOADING);
if (!ZipFile.GetFile(i,Image,RomFileSize))
{
VirtualFree(Image,0,MEM_RELEASE);
@ -325,7 +325,7 @@ bool CN64Rom::LoadN64Image ( const char * FileLoc, bool LoadBootCodeOnly ) {
m_ROMImage = Image;
m_RomFileSize = RomFileSize;
_Notify->DisplayMessage(5,MSG_BYTESWAP);
g_Notify->DisplayMessage(5,MSG_BYTESWAP);
ByteSwapRom();
//Protect the memory so that it can not be written to.

2
Source/Project64/N64 System/Profiling Class.cpp
View File

@ -85,7 +85,7 @@ void CProfiling::ShowCPU_Usage (void) {
TotalTime = CPU + Alist + Dlist + Idle;
_Notify->DisplayMessage(0,"r4300i: %0.1f%c GFX: %0.1f%c Alist: %0.1f%c Idle: %0.1f%c",
g_Notify->DisplayMessage(0,"r4300i: %0.1f%c GFX: %0.1f%c Alist: %0.1f%c Idle: %0.1f%c",
(float)(((double)CPU / (double)TotalTime) * 100),'%',
(float)(((double)Dlist / (double)TotalTime) * 100),'%',
(float)(((double)Alist / (double)TotalTime) * 100),'%',

50
Source/Project64/N64 System/Recompiler/Code Block.cpp
View File

@ -13,7 +13,7 @@ CCodeBlock::CCodeBlock(DWORD VAddrEnter, BYTE * RecompPos) :
CCodeSection * baseSection = new CCodeSection(this, VAddrEnter, 0, false);
if (baseSection == NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
m_Sections.push_back(baseSection);
baseSection->AddParent(NULL);
@ -25,7 +25,7 @@ CCodeBlock::CCodeBlock(DWORD VAddrEnter, BYTE * RecompPos) :
m_EnterSection = new CCodeSection(this, VAddrEnter, 1, true);
if (m_EnterSection == NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
baseSection->m_ContinueSection = m_EnterSection;
@ -59,7 +59,7 @@ bool CCodeBlock::SetSection ( CCodeSection * & Section, CCodeSection * CurrentSe
{
if (Section != NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (TargetPC >= ((CurrentPC + 0x1000) & 0xFFFFF000))
@ -76,7 +76,7 @@ bool CCodeBlock::SetSection ( CCodeSection * & Section, CCodeSection * CurrentSe
{
if (Section != NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
SectionMap::const_iterator itr = m_SectionMap.find(TargetPC);
if (itr != m_SectionMap.end())
@ -91,7 +91,7 @@ bool CCodeBlock::SetSection ( CCodeSection * & Section, CCodeSection * CurrentSe
Section = new CCodeSection(this,TargetPC,m_Sections.size(),LinkAllowed);
if (Section == NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
m_Sections.push_back(Section);
@ -113,11 +113,11 @@ bool CCodeBlock::SetSection ( CCodeSection * & Section, CCodeSection * CurrentSe
}
if (SplitSection == NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (SplitSection->m_EndPC == (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (SplitSection->m_EndPC >= TargetPC)
{
@ -158,7 +158,7 @@ bool CCodeBlock::CreateBlockLinkage ( CCodeSection * EnterSection )
if (CurrentSection->m_ContinueSection != NULL &&
CurrentSection->m_ContinueSection != itr->second)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (CurrentSection->m_ContinueSection == NULL)
{
@ -190,7 +190,7 @@ bool CCodeBlock::CreateBlockLinkage ( CCodeSection * EnterSection )
CurrentSection->m_EndPC = TestPC;
if (!AnalyzeInstruction(TestPC, TargetPC, ContinuePC, LikelyBranch, IncludeDelaySlot, EndBlock, PermLoop))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
@ -204,7 +204,7 @@ bool CCodeBlock::CreateBlockLinkage ( CCodeSection * EnterSection )
{
if (ContinuePC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
continue;
}
@ -239,7 +239,7 @@ bool CCodeBlock::CreateBlockLinkage ( CCodeSection * EnterSection )
JumpSection->SetDelaySlot();
SetSection(JumpSection->m_JumpSection,CurrentSection->m_JumpSection,TargetPC,true,TestPC);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
else if (TargetPC != ((DWORD)-1))
@ -276,7 +276,7 @@ bool CCodeBlock::CreateBlockLinkage ( CCodeSection * EnterSection )
}
if (CurrentSection == NewSection)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
CurrentSection = NewSection;
if (CurrentSection->m_JumpSection != NULL ||
@ -304,7 +304,7 @@ bool CCodeBlock::CreateBlockLinkage ( CCodeSection * EnterSection )
}
if (CurrentSection->m_EndPC == (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
return true;
}
@ -349,7 +349,7 @@ bool CCodeBlock::AnalyzeInstruction ( DWORD PC, DWORD & TargetPC, DWORD & Contin
OPCODE Command;
if (!_MMU->LW_VAddr(PC, Command.Hex)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
@ -387,7 +387,7 @@ bool CCodeBlock::AnalyzeInstruction ( DWORD PC, DWORD & TargetPC, DWORD & Contin
EndBlock = true;
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
break;
@ -399,11 +399,11 @@ bool CCodeBlock::AnalyzeInstruction ( DWORD PC, DWORD & TargetPC, DWORD & Contin
TargetPC = PC + ((short)Command.offset << 2) + 4;
if (TargetPC == PC + 8)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (TargetPC == PC)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
ContinuePC = PC + 8;
IncludeDelaySlot = true;
@ -450,7 +450,7 @@ bool CCodeBlock::AnalyzeInstruction ( DWORD PC, DWORD & TargetPC, DWORD & Contin
IncludeDelaySlot = true;
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
break;
@ -519,11 +519,11 @@ bool CCodeBlock::AnalyzeInstruction ( DWORD PC, DWORD & TargetPC, DWORD & Contin
EndBlock = true;
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
break;
@ -546,7 +546,7 @@ bool CCodeBlock::AnalyzeInstruction ( DWORD PC, DWORD & TargetPC, DWORD & Contin
} else {
if (TargetPC == PC)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
ContinuePC = PC + 8;
IncludeDelaySlot = true;
@ -557,18 +557,18 @@ bool CCodeBlock::AnalyzeInstruction ( DWORD PC, DWORD & TargetPC, DWORD & Contin
TargetPC = PC + ((short)Command.offset << 2) + 4;
if (TargetPC == PC)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
ContinuePC = PC + 8;
LikelyBranch = true;
IncludeDelaySlot = true;
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
break;
@ -619,7 +619,7 @@ bool CCodeBlock::AnalyzeInstruction ( DWORD PC, DWORD & TargetPC, DWORD & Contin
EndBlock = true;
break;
}
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
return true;

74
Source/Project64/N64 System/Recompiler/Code Section.cpp
View File

@ -104,7 +104,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo &ExitReg
sprintf(String,"Exit_%d",m_BlockInfo->m_ExitInfo.size());
if (x86Jmp == NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
x86Jmp(String,0);
@ -158,7 +158,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo &ExitReg
{
if (LookUpMode() == FuncFind_ChangeMemory)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
// BYTE * Jump, * Jump2;
// if (TargetPC >= 0x80000000 && TargetPC < 0xC0000000) {
// DWORD pAddr = TargetPC & 0x1FFFFFFF;
@ -279,7 +279,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo &ExitReg
}
break;
case CExitInfo::ExitResetRecompCode:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (m_NextInstruction == JUMP || m_NextInstruction == DELAY_SLOT) {
X86BreakPoint(__FILE__,__LINE__);
@ -322,7 +322,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo &ExitReg
ExitCodeBlock();
break;
default:
_Notify->DisplayError("how did you want to exit on reason (%d) ???",reason);
g_Notify->DisplayError("how did you want to exit on reason (%d) ???",reason);
}
}
@ -343,7 +343,7 @@ void CCodeSection::GenerateSectionLinkage (void)
if ((CompilePC() & 0xFFC) == 0xFFC)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
//Handle Fall througth
BYTE * Jump = NULL;
@ -576,7 +576,7 @@ void CCodeSection::GenerateSectionLinkage (void)
}
if (JumpInfo[i]->TargetPC != TargetSection[i]->m_EnterPC)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (TargetSection[i]->m_CompiledLocation == NULL)
{
@ -669,19 +669,19 @@ void CCodeSection::SyncRegState ( const CRegInfo & SyncTo )
case CRegInfo::STATE_CONST_64:
if (GetMipsReg(i) != SyncTo.GetMipsReg(i))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
continue;
case CRegInfo::STATE_CONST_32:
if (GetMipsRegLo(i) != SyncTo.GetMipsRegLo(i))
{
CPU_Message("Value of const is different Reg %d (%s) Value: 0x%08X to 0x%08X",i,CRegName::GPR[i],GetMipsRegLo(i),SyncTo.GetMipsRegLo(i));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
continue;
default:
CPU_Message("Unhandled Reg state %d\nin SyncRegState",GetMipsRegState(i));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
changed = true;
@ -726,7 +726,7 @@ void CCodeSection::SyncRegState ( const CRegInfo & SyncTo )
break;
default:
CPU_Message("Do something with states in SyncRegState\nSTATE_MAPPED_64\n%d",GetMipsRegState(i));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
continue;
}
m_RegWorkingSet.SetMipsRegMapLo(i,Reg);
@ -764,7 +764,7 @@ void CCodeSection::SyncRegState ( const CRegInfo & SyncTo )
CPU_Message("hi %X\nLo %X",GetMipsRegHi(i),GetMipsRegLo(i));
default:
CPU_Message("Do something with states in SyncRegState\nSTATE_MAPPED_32_SIGN\n%d",GetMipsRegState(i));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
m_RegWorkingSet.SetMipsRegMapLo(i,Reg);
m_RegWorkingSet.SetMipsRegState(i, CRegInfo::STATE_MAPPED_32_SIGN);
@ -792,7 +792,7 @@ void CCodeSection::SyncRegState ( const CRegInfo & SyncTo )
m_RegWorkingSet.SetX86Mapped(GetMipsRegMapLo(i),CRegInfo::NotMapped);
} else {
CPU_Message("Do something with states in SyncRegState\nSTATE_MAPPED_32_ZERO\n%d",GetMipsRegState(i));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
case CRegInfo::STATE_CONST_32:
@ -800,13 +800,13 @@ void CCodeSection::SyncRegState ( const CRegInfo & SyncTo )
{
CPU_Message("Sign Problems in SyncRegState\nSTATE_MAPPED_32_ZERO");
CPU_Message("%s: %X",CRegName::GPR[i],GetMipsRegLo_S(i));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
MoveConstToX86reg(GetMipsRegLo(i),Reg);
break;
default:
CPU_Message("Do something with states in SyncRegState\nSTATE_MAPPED_32_ZERO\n%d",GetMipsRegState(i));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
m_RegWorkingSet.SetMipsRegMapLo(i,Reg);
m_RegWorkingSet.SetMipsRegState(i, SyncTo.GetMipsRegState(i));
@ -816,7 +816,7 @@ void CCodeSection::SyncRegState ( const CRegInfo & SyncTo )
break;
default:
CPU_Message("%d - %d reg: %s (%d)",SyncTo.GetMipsRegState(i),GetMipsRegState(i),CRegName::GPR[i],i);
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
changed = false;
}
}
@ -874,7 +874,7 @@ void TestFunc ( void )
TestValue += 1;
if (TestValue >= 4)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}*/
@ -914,11 +914,11 @@ bool CCodeSection::GenerateX86Code ( DWORD Test )
__try {
if (!_MMU->LW_VAddr(m_CompilePC,m_Opcode.Hex))
{
_Notify->DisplayError(GS(MSG_FAIL_LOAD_WORD));
g_Notify->DisplayError(GS(MSG_FAIL_LOAD_WORD));
ExitThread(0);
}
} __except( _MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation()) ) {
_Notify->DisplayError(GS(MSG_UNKNOWN_MEM_ACTION));
g_Notify->DisplayError(GS(MSG_UNKNOWN_MEM_ACTION));
ExitThread(0);
}
@ -1018,7 +1018,7 @@ bool CCodeSection::GenerateX86Code ( DWORD Test )
/* if (m_CompilePC == 0x803245CC && m_NextInstruction == NORMAL)
{
//m_RegWorkingSet.UnMap_AllFPRs();
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
//X86HardBreakPoint();
//X86BreakPoint(__FILE__,__LINE__);
//m_RegWorkingSet.UnMap_AllFPRs();
@ -1273,7 +1273,7 @@ bool CCodeSection::GenerateX86Code ( DWORD Test )
{
if (m_NextInstruction == DO_DELAY_SLOT)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_NextInstruction == NORMAL)
{
@ -1319,7 +1319,7 @@ bool CCodeSection::GenerateX86Code ( DWORD Test )
{
if (m_NextInstruction != NORMAL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
m_CompilePC -= 4;
m_Cont.RegSet = m_RegWorkingSet;
@ -1358,7 +1358,7 @@ void CCodeSection::AddParent(CCodeSection * Parent )
} else if (Parent->m_JumpSection == this) {
m_RegEnter = Parent->m_Jump.RegSet;
} else {
_Notify->DisplayError("How are these sections joined?????");
g_Notify->DisplayError("How are these sections joined?????");
}
m_RegWorkingSet = m_RegEnter;
} else {
@ -1390,7 +1390,7 @@ void CCodeSection::SwitchParent(CCodeSection * OldParent, CCodeSection * NewPare
if (!bFoundOldParent)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
m_ParentSection.push_back(NewParent);
}
@ -1504,7 +1504,7 @@ void CCodeSection::UnlinkParent( CCodeSection * Parent, bool ContinueSection )
CPU_Message(__FUNCTION__ ": Section %d Parent: %d ContinueSection = %s",m_SectionID,Parent->m_SectionID,ContinueSection?"Yes" :"No");
if (Parent->m_ContinueSection == this && Parent->m_JumpSection == this)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
SECTION_LIST::iterator iter = m_ParentSection.begin();
@ -1542,7 +1542,7 @@ void CCodeSection::UnlinkParent( CCodeSection * Parent, bool ContinueSection )
{
if (ParentIter->m_CompiledLocation)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
ParentIter->m_ContinueSection = NULL;
}
@ -1551,7 +1551,7 @@ void CCodeSection::UnlinkParent( CCodeSection * Parent, bool ContinueSection )
{
if (ParentIter->m_CompiledLocation)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
ParentIter->m_JumpSection = NULL;
}
@ -1631,7 +1631,7 @@ bool CCodeSection::InheritParentInfo ( void )
CCodeSection * Parent = *(m_ParentSection.begin());
if (Parent->m_CompiledLocation == NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
CJumpInfo * JumpInfo = this == Parent->m_ContinueSection ? &Parent->m_Cont : &Parent->m_Jump;
@ -1672,7 +1672,7 @@ bool CCodeSection::InheritParentInfo ( void )
size_t NoOfCompiledParents = ParentList.size();
if (NoOfCompiledParents == 0)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
@ -1705,7 +1705,7 @@ bool CCodeSection::InheritParentInfo ( void )
}
if (FirstParent != -1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
FirstParent = i;
}
@ -1734,7 +1734,7 @@ bool CCodeSection::InheritParentInfo ( void )
UpdateCounters(m_RegWorkingSet,m_EnterPC < JumpInfo->JumpPC,true);
if (JumpInfo->JumpPC == (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_EnterPC <= JumpInfo->JumpPC)
{
@ -1817,7 +1817,7 @@ bool CCodeSection::InheritParentInfo ( void )
break;
default:
CPU_Message("Unknown CPU State(%d) in InheritParentInfo",GetMipsRegState(i2));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
if (IsConst(i2)) {
@ -1832,7 +1832,7 @@ bool CCodeSection::InheritParentInfo ( void )
{
Map_GPR_32bit(i2,(GetMipsRegLo(i2) & 0x80000000) != 0,i2);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
case CRegInfo::STATE_MAPPED_32_SIGN:
@ -1840,7 +1840,7 @@ bool CCodeSection::InheritParentInfo ( void )
{
Map_GPR_32bit(i2,true,i2);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
case CRegInfo::STATE_UNKNOWN:
@ -1853,7 +1853,7 @@ bool CCodeSection::InheritParentInfo ( void )
break;
default:
CPU_Message("Unknown CPU State(%d) in InheritParentInfo",RegSet->GetMipsRegState(i2));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
break;
}
} else if (Is32Bit(i2) && GetMipsRegLo(i2) != RegSet->GetMipsRegLo(i2)) {
@ -1928,13 +1928,13 @@ bool CCodeSection::InheritParentInfo ( void )
case CRegInfo::STATE_CONST_32:
if (GetMipsRegLo(i2) != RegSet->GetMipsRegLo(i2))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
NeedSync = true;
}
break;
default:
WriteTraceF(TraceError,"Unhandled Reg state %d\nin InheritParentInfo",GetMipsRegState(i2));
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
if (NeedSync == false) { continue; }
@ -1958,7 +1958,7 @@ bool CCodeSection::InheritParentInfo ( void )
}
//if (m_EnterPC == 0x8031CE44 && m_SectionID == 6)
//{
// _Notify->BreakPoint(__FILE__,__LINE__);
// g_Notify->BreakPoint(__FILE__,__LINE__);
//}
m_RegWorkingSet = JumpInfo->RegSet;
if (m_EnterPC < JumpInfo->JumpPC )

10
Source/Project64/N64 System/Recompiler/Function Map Class.cpp
View File

@ -20,7 +20,7 @@ bool CFunctionMap::AllocateMemory()
m_FunctionTable = (PCCompiledFunc_TABLE *)VirtualAlloc(NULL,0xFFFFF * sizeof(CCompiledFunc *),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
if (m_FunctionTable == NULL) {
WriteTrace(TraceError,"CFunctionMap::AllocateMemory: failed to allocate function table");
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
g_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
return false;
}
memset(m_FunctionTable,0,0xFFFFF * sizeof(CCompiledFunc *));
@ -31,7 +31,7 @@ bool CFunctionMap::AllocateMemory()
m_JumpTable = new PCCompiledFunc[_MMU->RdramSize() >> 2];
if (m_JumpTable == NULL) {
WriteTrace(TraceError,"CFunctionMap::AllocateMemory: failed to allocate jump table");
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
g_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
return false;
}
memset(m_JumpTable,0,(_MMU->RdramSize() >> 2) * sizeof(PCCompiledFunc));
@ -165,7 +165,7 @@ void CFunctionMap::Reset( bool AllocateMemory )
{
m_FunctionTable = (CCompiledFunc *)VirtualAlloc(NULL,0xFFFFF * sizeof(CCompiledFunc *),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
if (m_FunctionTable == NULL) {
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
g_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
}
}
memset(m_FunctionTable,0,0xFFFFF * sizeof(DWORD));
@ -181,7 +181,7 @@ CCompiledFunc * CFunctionMap::AddFunctionInfo( DWORD vAddr, DWORD pAddr )
table = new PCCompiledFunc[(0x1000 >> 2)];
if (table == NULL)
{
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
g_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
}
memset(table,0,sizeof(PCCompiledFunc) * (0x1000 >> 2));
}
@ -219,7 +219,7 @@ void CFunctionMap::Remove(CCompiledFunc * info)
delete info;
table[(vAddr & 0xFFF) >> 2] = NULL;
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
*/

96
Source/Project64/N64 System/Recompiler/Loop Analysis.cpp
View File

@ -60,7 +60,7 @@ bool LoopAnalysis::SetupEnterSection ( CCodeSection * Section, bool & bChanged,
{
bChanged = false;
bSkipedSection = false;
if (Section->m_ParentSection.empty()) { _Notify->BreakPoint(__FILE__,__LINE__); return true; }
if (Section->m_ParentSection.empty()) { g_Notify->BreakPoint(__FILE__,__LINE__); return true; }
CPU_Message(__FUNCTION__ ": Block EnterPC: %X Section ID %d Test: %X Section Test: %X CompiledLocation: %X",m_BlockInfo->VAddrEnter(),Section->m_SectionID,m_Test,Section->m_Test, Section->m_CompiledLocation);
@ -106,7 +106,7 @@ bool LoopAnalysis::SetupEnterSection ( CCodeSection * Section, bool & bChanged,
if (bFirstParent)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
RegisterMap::iterator itr = m_EnterRegisters.find(Section->m_SectionID);
@ -157,7 +157,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
do {
if (!_MMU->LW_VAddr(m_PC, m_Command.Hex))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
CPU_Message(" %08X: %s",m_PC,R4300iOpcodeName(m_Command.Hex,m_PC));
@ -211,10 +211,10 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
case R4300i_SPECIAL_DSRL32: SPECIAL_DSRL32(); break;
case R4300i_SPECIAL_DSRA32: SPECIAL_DSRA32(); break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (m_Command.Hex == 0x00000001) { break; }
_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 5\n%s",
g_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 5\n%s",
R4300iOpcodeName(m_Command.Hex,m_PC));
#endif
m_NextInstruction = END_BLOCK;
@ -231,19 +231,19 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
Section->m_ContinueSection != NULL &&
Section->m_Cont.TargetPC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (Section->m_Jump.TargetPC != m_PC + ((short)m_Command.offset << 2) + 4 &&
Section->m_JumpSection != NULL &&
Section->m_Jump.TargetPC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_PC == Section->m_Jump.TargetPC)
{
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,0) && !Section->m_Jump.PermLoop)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
#endif
@ -256,27 +256,27 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
Section->m_ContinueSection != NULL &&
Section->m_Cont.TargetPC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (Section->m_Jump.TargetPC != m_PC + 4)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
/*if (Section->m_Jump.TargetPC != m_PC + ((short)m_Command.offset << 2) + 4)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}*/
if (m_PC == m_PC + ((short)m_Command.offset << 2) + 4)
{
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,0) && !Section->m_Jump.PermLoop)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
#endif
break;
case R4300i_REGIMM_BLTZAL:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
m_Reg.GetMipsRegLo(31) = m_PC + 8;
m_Reg.SetMipsRegState(31,CRegInfo::STATE_CONST_32);
@ -290,7 +290,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
#endif
break;
case R4300i_REGIMM_BGEZAL:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
m_NextInstruction = DELAY_SLOT;
if (m_Reg.IsConst(m_Command.rs))
@ -328,10 +328,10 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
#endif
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (m_Command.Hex == 0x0407000D) { break; }
_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 4\n%s",
g_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 4\n%s",
R4300iOpcodeName(m_Command.Hex,m_PC));
m_NextInstruction = END_BLOCK;
m_PC -= 4;
@ -339,7 +339,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
}
break;
case R4300i_JAL:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
m_NextInstruction = DELAY_SLOT;
m_Reg.GetMipsRegLo(31) = m_PC + 8;
@ -357,11 +357,11 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
#ifdef CHECKED_BUILD
if (Section->m_Jump.TargetPC != (m_PC & 0xF0000000) + (m_Command.target << 2))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_PC == Section->m_Jump.TargetPC && !Section->m_Jump.PermLoop)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
#endif
break;
@ -376,23 +376,23 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
Section->m_ContinueSection != NULL &&
Section->m_Cont.TargetPC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
} else {
if (Section->m_Cont.TargetPC != (DWORD)-1)
{
//_Notify->BreakPoint(__FILE__,__LINE__);
//g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
if (Section->m_Jump.TargetPC != m_PC + ((short)m_Command.offset << 2) + 4)
{
//_Notify->BreakPoint(__FILE__,__LINE__);
//g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_PC == Section->m_Jump.TargetPC)
{
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,m_Command.rt) && !Section->m_Jump.PermLoop)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
#endif
@ -409,19 +409,19 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
Section->m_ContinueSection != NULL &&
Section->m_Cont.TargetPC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (Section->m_Jump.TargetPC != m_PC + ((short)m_Command.offset << 2) + 4 &&
Section->m_JumpSection != NULL &&
Section->m_Jump.TargetPC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_PC == Section->m_Jump.TargetPC)
{
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,m_Command.rt) && !Section->m_Jump.PermLoop)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
#endif
@ -517,13 +517,13 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
case R4300i_COP0_CO_TLBP: break;
case R4300i_COP0_CO_ERET: m_NextInstruction = END_BLOCK; break;
default:
_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo\n%s",
g_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo\n%s",
R4300iOpcodeName(m_Command.Hex,m_PC));
m_NextInstruction = END_BLOCK;
m_PC -= 4;
}
} else {
_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 3\n%s",
g_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 3\n%s",
R4300iOpcodeName(m_Command.Hex,m_PC));
m_NextInstruction = END_BLOCK;
m_PC -= 4;
@ -548,17 +548,17 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
Section->m_ContinueSection != NULL &&
Section->m_Cont.TargetPC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_PC == m_PC + ((short)m_Command.offset << 2) + 4)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,m_Command.rt))
{
if (!Section->m_Jump.PermLoop)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
#endif
@ -573,15 +573,15 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
Section->m_ContinueSection != NULL &&
Section->m_Cont.TargetPC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (Section->m_Jump.TargetPC != m_PC + ((short)m_Command.offset << 2) + 4)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_PC == Section->m_Jump.TargetPC)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,m_Command.rt)) {
Section->m_Jump.PermLoop = true;
@ -600,7 +600,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
case R4300i_COP1_W: break;
case R4300i_COP1_L: break;
default:
_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 2\n%s",
g_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 2\n%s",
R4300iOpcodeName(m_Command.Hex,m_PC));
m_NextInstruction = END_BLOCK;
m_PC -= 4;
@ -616,21 +616,21 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
Section->m_ContinueSection != NULL &&
Section->m_Cont.TargetPC != (DWORD)-1)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (Section->m_Jump.TargetPC != m_PC + 4)
{
//_Notify->BreakPoint(__FILE__,__LINE__);
//g_Notify->BreakPoint(__FILE__,__LINE__);
}
/*if (Section->m_Jump.TargetPC != m_PC + ((short)m_Command.offset << 2) + 4)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}*/
if (m_PC == m_PC + ((short)m_Command.offset << 2) + 4)
{
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,m_Command.rt) && !Section->m_Jump.PermLoop)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
#endif
@ -695,7 +695,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
if (m_Command.Hex == 0xF1F3F5F7) { break; }
if (m_Command.Hex == 0xC1200000) { break; }
if (m_Command.Hex == 0x4C5A5353) { break; }
_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 1\n%s\n%X",
g_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 1\n%s\n%X",
R4300iOpcodeName(m_Command.Hex,m_PC),m_Command.Hex);
}
@ -703,7 +703,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
if (Section->m_DelaySlot)
{
if (m_NextInstruction != NORMAL) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (m_NextInstruction != NORMAL) { g_Notify->BreakPoint(__FILE__,__LINE__); }
m_NextInstruction = END_BLOCK;
SetJumpRegSet(Section,m_Reg);
} else {
@ -716,7 +716,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
m_PC += 4;
if ((m_PC & 0xFFFFF000) != (m_EnterSection->m_EnterPC & 0xFFFFF000))
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
case LIKELY_DELAY_SLOT:
@ -734,7 +734,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
m_NextInstruction = END_BLOCK;
break;
case LIKELY_DELAY_SLOT_DONE:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
if (Section->m_CompiledLocation)
{
} else {
@ -755,9 +755,9 @@ bool LoopAnalysis::CheckLoopRegisterUsage( CCodeSection * Section)
if ((m_PC & 0xFFFFF000) != (m_EnterSection->m_EnterPC & 0xFFFFF000)) {
if (m_NextInstruction != END_BLOCK && m_NextInstruction != NORMAL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
} while (m_NextInstruction != END_BLOCK);
@ -783,7 +783,7 @@ bool LoopAnalysis::SyncRegState ( CRegInfo & RegSet, const CRegInfo& SyncReg )
RegSet.SetMipsRegState(x,CRegInfo::STATE_MODIFIED);
bChanged = true;
} else if (RegSet.IsConst(x) && RegSet.Is64Bit(x) && RegSet.GetMipsReg_S(x) != SyncReg.GetMipsReg_S(x)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
return bChanged;
@ -875,7 +875,7 @@ void LoopAnalysis::SPECIAL_SRAV ( void )
void LoopAnalysis::SPECIAL_JR ( void )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (m_Reg.IsConst(m_Command.rs)) {
Section->m_Jump.TargetPC = m_Reg.GetMipsRegLo(m_Command.rs);
@ -888,7 +888,7 @@ void LoopAnalysis::SPECIAL_JR ( void )
void LoopAnalysis::SPECIAL_JALR ( void )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
m_Reg.GetMipsRegLo(m_Command.rd) = m_PC + 8;
m_Reg.SetMipsRegState(m_Command.rd,CRegInfo::STATE_CONST_32);

54
Source/Project64/N64 System/Recompiler/Recompiler Class.cpp
View File

@ -72,7 +72,7 @@ void CRecompiler::Run()
}
__except( _MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation()) )
{
_Notify->DisplayError(MSG_UNKNOWN_MEM_ACTION);
g_Notify->DisplayError(MSG_UNKNOWN_MEM_ACTION);
}
}
@ -88,7 +88,7 @@ void CRecompiler::RecompilerMain_VirtualTable ( void )
_Reg->DoTLBReadMiss(false,PC);
if (!_TransVaddr->ValidVaddr(PC))
{
_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PC);
g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PC);
return;
}
continue;
@ -117,7 +117,7 @@ void CRecompiler::RecompilerMain_VirtualTable ( void )
if (table == NULL)
{
WriteTrace(TraceError,"CRecompiler::RecompilerMain_VirtualTable: failed to allocate PCCompiledFunc");
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
g_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
}
memset(table,0,sizeof(PCCompiledFunc) * (0x1000 >> 2));
if (bSMM_Protect())
@ -134,7 +134,7 @@ void CRecompiler::RecompilerMain_VirtualTable ( void )
void CRecompiler::RecompilerMain_VirtualTable_validate ( void )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
/* PCCompiledFunc_TABLE * m_FunctionTable = m_Functions.GetFunctionTable();
while(!m_EndEmulation)
@ -145,7 +145,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate ( void )
//Find Block on hash table
if (Info == NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (!_TLB->ValidVaddr(PROGRAM_COUNTER))
{
@ -153,7 +153,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate ( void )
NextInstruction = NORMAL;
if (!_TLB->ValidVaddr(PROGRAM_COUNTER))
{
_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
return;
}
continue;
@ -205,7 +205,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate ( void )
continue;
}
}
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (!_TLB->ValidVaddr(PROGRAM_COUNTER))
{
@ -213,7 +213,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate ( void )
NextInstruction = NORMAL;
if (!_TLB->ValidVaddr(PROGRAM_COUNTER))
{
_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
return;
}
}
@ -236,7 +236,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate ( void )
NextInstruction = NORMAL;
if (!_MMU->ValidVaddr(PROGRAM_COUNTER))
{
_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
return;
}
}
@ -353,14 +353,14 @@ void CRecompiler::RecompilerMain_Lookup( void )
{
/*if (bUseTlb())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (!_TLB->TranslateVaddr(PROGRAM_COUNTER, Addr))
{
DoTLBMiss(NextInstruction == DELAY_SLOT,PROGRAM_COUNTER);
NextInstruction = NORMAL;
if (!TranslateVaddr(PROGRAM_COUNTER, &Addr)) {
_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
return;
}
}
@ -410,7 +410,7 @@ void CRecompiler::RecompilerMain_Lookup( void )
if (Addr > 0x20000000)
{
WriteTraceF(TraceDebug,"Executing from non mapped space .1 PC: %X Addr: %X",PROGRAM_COUNTER, Addr);
_Notify->DisplayError(GS(MSG_NONMAPPED_SPACE));
g_Notify->DisplayError(GS(MSG_NONMAPPED_SPACE));
break;
}
Info = (CCompiledFunc *)*(JumpTable + (Addr >> 2));
@ -422,7 +422,7 @@ void CRecompiler::RecompilerMain_Lookup( void )
continue;
} else {
WriteTraceF(TraceDebug,"Executing from non mapped space .1 PC: %X Addr: %X",PROGRAM_COUNTER, Addr);
_Notify->DisplayError(GS(MSG_NONMAPPED_SPACE));
g_Notify->DisplayError(GS(MSG_NONMAPPED_SPACE));
break;
}
}
@ -437,7 +437,7 @@ void CRecompiler::RecompilerMain_Lookup( void )
continue;
} else {
WriteTraceF(TraceDebug,"Executing from non mapped space .2 PC: %X Addr: %X",PROGRAM_COUNTER, Addr);
_Notify->DisplayError(GS(MSG_NONMAPPED_SPACE));
g_Notify->DisplayError(GS(MSG_NONMAPPED_SPACE));
return;
}
}
@ -466,7 +466,7 @@ void CRecompiler::RecompilerMain_Lookup( void )
continue;
}
}
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (Profiling && IndvidualBlock) {
static DWORD ProfAddress = 0;
@ -507,7 +507,7 @@ void CRecompiler::RecompilerMain_Lookup_TLB( void )
_Reg->DoTLBReadMiss(false,PROGRAM_COUNTER);
if (!_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr))
{
_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
m_EndEmulation = true;
}
continue;
@ -607,7 +607,7 @@ void CRecompiler::RecompilerMain_Lookup_validate_TLB( void )
_Reg->DoTLBReadMiss(false,PROGRAM_COUNTER);
if (!_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr))
{
_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
m_EndEmulation = true;
}
continue;
@ -641,7 +641,7 @@ void CRecompiler::RecompilerMain_Lookup_validate_TLB( void )
info = JumpTable()[PhysicalAddr >> 2];
if (info != NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
info = NULL;
}
continue;
@ -693,7 +693,7 @@ void CRecompiler::ResetRecompCode()
void CRecompiler::RecompilerMain_ChangeMemory ( void )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
DWORD Value, Addr;
BYTE * Block;
@ -705,7 +705,7 @@ void CRecompiler::RecompilerMain_ChangeMemory ( void )
NextInstruction = NORMAL;
if (!TranslateVaddr(PROGRAM_COUNTER, &Addr)) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
#endif
ExitThread(0);
}
@ -719,7 +719,7 @@ void CRecompiler::RecompilerMain_ChangeMemory ( void )
Value = (DWORD)(*(DelaySlotTable + (Addr >> 12)));
} __except(EXCEPTION_EXECUTE_HANDLER) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Executing Delay Slot from non maped space\nPROGRAM_COUNTER = 0x%X",PROGRAM_COUNTER);
g_Notify->DisplayError("Executing Delay Slot from non maped space\nPROGRAM_COUNTER = 0x%X",PROGRAM_COUNTER);
#endif
ExitThread(0);
}
@ -770,7 +770,7 @@ void CRecompiler::RecompilerMain_ChangeMemory ( void )
Block = NULL;
}
} __except(EXCEPTION_EXECUTE_HANDLER) {
_Notify->DisplayError(GS(MSG_NONMAPPED_SPACE));
g_Notify->DisplayError(GS(MSG_NONMAPPED_SPACE));
ExitThread(0);
}
@ -912,7 +912,7 @@ void CRecompiler::ClearRecompCode_Phys(DWORD Address, int length, REMOVE_REASON
int ClearLen = ((length + 3) & ~3);
if (Address + ClearLen > RdramSize())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
ClearLen = RdramSize() - Address;
}
WriteTraceF(TraceRecompiler,"Reseting Jump Table, Addr: %X len: %d",Address,ClearLen);
@ -954,7 +954,7 @@ void CRecompiler::ClearRecompCode_Virt(DWORD Address, int length,REMOVE_REASON R
if (DataLeft > 0)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
break;
@ -968,7 +968,7 @@ void CRecompiler::ClearRecompCode_Virt(DWORD Address, int length,REMOVE_REASON R
}
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -981,11 +981,11 @@ void CRecompiler::ResetMemoryStackPos( void )
}
if (_MMU == NULL || _Reg == NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (_Reg->m_GPR[29].UW[0] < 0x80000000 || _Reg->m_GPR[29].UW[0] >= 0xC0000000)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
m_MemoryStack = (DWORD)(_MMU->Rdram() + (_Reg->m_GPR[29].UW[0] & 0x1FFFFFFF));
}

8
Source/Project64/N64 System/Recompiler/Recompiler Memory.cpp
View File

@ -23,7 +23,7 @@ bool CRecompMemory::AllocateMemory()
if (RecompCodeBase==NULL)
{
WriteTrace(TraceError,"CRecompMemory::AllocateMemory: failed to allocate RecompCodeBase");
_Notify->DisplayError(MSG_MEM_ALLOC_ERROR);
g_Notify->DisplayError(MSG_MEM_ALLOC_ERROR);
return FALSE;
}
@ -32,7 +32,7 @@ bool CRecompMemory::AllocateMemory()
{
WriteTrace(TraceError,"CRecompMemory::AllocateMemory: failed to commit initial buffer");
VirtualFree( RecompCodeBase, 0 , MEM_RELEASE);
_Notify->DisplayError(MSG_MEM_ALLOC_ERROR);
g_Notify->DisplayError(MSG_MEM_ALLOC_ERROR);
return FALSE;
}
m_RecompSize = InitialCompileBufferSize;
@ -57,7 +57,7 @@ void CRecompMemory::CheckRecompMem ( void )
if (MemAddr == NULL)
{
WriteTrace(TraceError,"CRecompMemory::CheckRecompMem: failed to increase buffer");
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
g_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
}
m_RecompSize += IncreaseCompileBufferSize;
@ -78,5 +78,5 @@ void CRecompMemory::ShowMemUsed()
DWORD TotalAvaliable = m_RecompSize / 0x100000;
_Notify->DisplayMessage(0,"Memory used: %d mb %-3d kb %-3d bytes Total Available: %d mb",MB,KB,Size, TotalAvaliable);
g_Notify->DisplayMessage(0,"Memory used: %d mb %-3d kb %-3d bytes Total Available: %d mb",MB,KB,Size, TotalAvaliable);
}

54
Source/Project64/N64 System/Recompiler/Recompiler Ops.cpp
View File

@ -54,7 +54,7 @@ void CRecompilerOps::Compile_Branch (CRecompilerOps::BranchFunction CompareFunc,
OPCODE Command;
if (!_MMU->LW_VAddr(m_CompilePC + 4, Command.Hex)) {
_Notify->DisplayError(GS(MSG_FAIL_LOAD_WORD));
g_Notify->DisplayError(GS(MSG_FAIL_LOAD_WORD));
ExitThread(0);
}
@ -71,7 +71,7 @@ void CRecompilerOps::Compile_Branch (CRecompilerOps::BranchFunction CompareFunc,
break;
#ifndef EXTERNAL_RELEASE
default:
_Notify->DisplayError("Unknown branch type");
g_Notify->DisplayError("Unknown branch type");
#endif
}
} else {
@ -153,7 +153,7 @@ void CRecompilerOps::Compile_Branch (CRecompilerOps::BranchFunction CompareFunc,
{
if (m_Section->m_Jump.LinkLocation != NULL || m_Section->m_Jump.LinkLocation2 != NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
MoveConstToVariable(m_Section->m_Jump.TargetPC,&R4300iOp::m_JumpToLocation,"R4300iOp::m_JumpToLocation");
}
@ -161,7 +161,7 @@ void CRecompilerOps::Compile_Branch (CRecompilerOps::BranchFunction CompareFunc,
{
if (m_Section->m_Cont.LinkLocation != NULL || m_Section->m_Cont.LinkLocation2 != NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
MoveConstToVariable(m_Section->m_Cont.TargetPC,&R4300iOp::m_JumpToLocation,"R4300iOp::m_JumpToLocation");
}
@ -169,7 +169,7 @@ void CRecompilerOps::Compile_Branch (CRecompilerOps::BranchFunction CompareFunc,
if (m_Section->m_Jump.LinkLocation != NULL || m_Section->m_Jump.LinkLocation2 != NULL)
{
JmpLabel8("DoDelaySlot",0);
if (DelayLinkLocation != NULL) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (DelayLinkLocation != NULL) { g_Notify->BreakPoint(__FILE__,__LINE__); }
DelayLinkLocation = (BYTE *)(m_RecompPos - 1);
CPU_Message(" ");
@ -185,7 +185,7 @@ void CRecompilerOps::Compile_Branch (CRecompilerOps::BranchFunction CompareFunc,
if (m_Section->m_Cont.LinkLocation != NULL || m_Section->m_Cont.LinkLocation2 != NULL)
{
JmpLabel8("DoDelaySlot",0);
if (DelayLinkLocation != NULL) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (DelayLinkLocation != NULL) { g_Notify->BreakPoint(__FILE__,__LINE__); }
DelayLinkLocation = (BYTE *)(m_RecompPos - 1);
CPU_Message(" ");
@ -287,7 +287,7 @@ void CRecompilerOps::Compile_Branch (CRecompilerOps::BranchFunction CompareFunc,
m_NextInstruction = END_BLOCK;
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction);
g_Notify->DisplayError("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction);
#endif
}
}
@ -306,15 +306,15 @@ void CRecompilerOps::Compile_BranchLikely (BranchFunction CompareFunc, BOOL Link
} else {
if (m_Section->m_Jump.JumpPC != m_CompilePC)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_Section->m_Cont.JumpPC != m_CompilePC)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (m_Section->m_Cont.TargetPC != m_CompilePC + 8)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
if (m_Section->m_JumpSection != NULL) {
@ -345,7 +345,7 @@ void CRecompilerOps::Compile_BranchLikely (BranchFunction CompareFunc, BOOL Link
m_Section->m_Cont.RegSet = m_RegWorkingSet;
if ((m_CompilePC & 0xFFC) == 0xFFC)
{
if (m_Section->m_Cont.FallThrough) { _Notify->BreakPoint(__FILE__,__LINE__); }
if (m_Section->m_Cont.FallThrough) { g_Notify->BreakPoint(__FILE__,__LINE__); }
if (m_Section->m_Jump.LinkLocation != NULL) {
SetJump32(m_Section->m_Jump.LinkLocation,(DWORD *)m_RecompPos);
@ -384,7 +384,7 @@ void CRecompilerOps::Compile_BranchLikely (BranchFunction CompareFunc, BOOL Link
{
if (m_Section->m_Jump.LinkLocation != NULL)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
m_Section->GenerateSectionLinkage();
m_NextInstruction = END_BLOCK;
@ -397,7 +397,7 @@ void CRecompilerOps::Compile_BranchLikely (BranchFunction CompareFunc, BOOL Link
m_NextInstruction = END_BLOCK;
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("WTF\n\nBranchLikely\nNextInstruction = %X", m_NextInstruction);
g_Notify->DisplayError("WTF\n\nBranchLikely\nNextInstruction = %X", m_NextInstruction);
#endif
}
}
@ -1193,7 +1193,7 @@ void CRecompilerOps::BLTZ_Compare (void) {
void CRecompilerOps::BGEZ_Compare (void) {
if (IsConst(m_Opcode.rs)) {
if (Is64Bit(m_Opcode.rs)) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
CRecompilerOps::UnknownOpcode();
} else if (IsSigned(m_Opcode.rs)) {
if (GetMipsRegLo_S(m_Opcode.rs) >= 0) {
@ -1322,7 +1322,7 @@ void CRecompilerOps::J (void) {
m_NextInstruction = END_BLOCK;
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("WTF\n\nJ\nNextInstruction = %X", m_NextInstruction);
g_Notify->DisplayError("WTF\n\nJ\nNextInstruction = %X", m_NextInstruction);
#endif
}
}
@ -1362,7 +1362,7 @@ void CRecompilerOps::JAL (void) {
m_NextInstruction = END_BLOCK;
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction);
g_Notify->DisplayError("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction);
#endif
}
return;
@ -1715,13 +1715,13 @@ void CRecompilerOps::CACHE (void){
break;
#ifndef EXTERNAL_RELEASE
default:
_Notify->DisplayError("cache: %d",m_Opcode.rt);
g_Notify->DisplayError("cache: %d",m_Opcode.rt);
#endif
}
}
void CRecompilerOps::LL (void) {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
x86Reg TempReg1, TempReg2;
@ -1735,7 +1735,7 @@ void CRecompilerOps::LL (void) {
_MMU->Compile_LW(m_Section, GetMipsRegLo(m_Opcode.rt),Address);
MoveConstToVariable(1,_LLBit,"LLBit");
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
TranslateVaddr(Address, &Address);
#endif
@ -2057,7 +2057,7 @@ void CRecompilerOps::SPECIAL_JR (void) {
m_NextInstruction = END_BLOCK;
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction);
g_Notify->DisplayError("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction);
#endif
}
}
@ -2112,7 +2112,7 @@ void CRecompilerOps::SPECIAL_JALR (void)
m_NextInstruction = END_BLOCK;
} else {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction);
g_Notify->DisplayError("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction);
#endif
}
}
@ -2983,7 +2983,7 @@ void CRecompilerOps::SPECIAL_XOR (void) {
if (IsMapped(m_Opcode.rd)) { UnMap_GPR(m_Opcode.rd, FALSE); }
if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs)) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("XOR 1");
g_Notify->DisplayError("XOR 1");
#endif
CRecompilerOps::UnknownOpcode();
} else {
@ -3208,7 +3208,7 @@ void CRecompilerOps::SPECIAL_SLT (void) {
if (IsKnown(m_Opcode.rt) && IsKnown(m_Opcode.rs)) {
if (IsConst(m_Opcode.rt) && IsConst(m_Opcode.rs)) {
if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs)) {
_Notify->DisplayError("1");
g_Notify->DisplayError("1");
CRecompilerOps::UnknownOpcode();
} else {
if (IsMapped(m_Opcode.rd)) { UnMap_GPR(m_Opcode.rd, FALSE); }
@ -3441,7 +3441,7 @@ void CRecompilerOps::SPECIAL_SLTU (void) {
if (IsKnown(m_Opcode.rt) && IsKnown(m_Opcode.rs)) {
if (IsConst(m_Opcode.rt) && IsConst(m_Opcode.rs)) {
if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs)) {
_Notify->DisplayError("1");
g_Notify->DisplayError("1");
CRecompilerOps::UnknownOpcode();
} else {
if (IsMapped(m_Opcode.rd)) { UnMap_GPR(m_Opcode.rd, FALSE); }
@ -4126,10 +4126,10 @@ void CRecompilerOps::COP0_MT (void) {
if (IsConst(m_Opcode.rt)) {
AndConstToVariable(0xFFFFCFF,&_CP0[m_Opcode.rd], CRegName::Cop0[m_Opcode.rd]);
#ifndef EXTERNAL_RELEASE
if ((GetMipsRegLo(m_Opcode.rt) & 0x300) != 0 ){ _Notify->DisplayError("Set IP0 or IP1"); }
if ((GetMipsRegLo(m_Opcode.rt) & 0x300) != 0 ){ g_Notify->DisplayError("Set IP0 or IP1"); }
#endif
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CRecompilerOps::UnknownOpcode();
#endif
@ -4140,7 +4140,7 @@ void CRecompilerOps::COP0_MT (void) {
AfterCallDirect(m_RegWorkingSet);
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CRecompilerOps::UnknownOpcode();
#endif

42
Source/Project64/N64 System/Recompiler/Reg Info.cpp
View File

@ -69,7 +69,7 @@ CRegInfo& CRegInfo::operator=(const CRegInfo& right)
#ifdef _DEBUG
if (*this != right)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
#endif
return *this;
@ -151,7 +151,7 @@ void CRegInfo::FixRoundModel(FPU_ROUND RoundMethod )
case RoundDown: OrConstToX86Reg(0x0400, reg); break;
case RoundUp: OrConstToX86Reg(0x0800, reg); break;
default:
_Notify->DisplayError("Unknown Rounding model");
g_Notify->DisplayError("Unknown Rounding model");
}
}
MoveX86regToVariable(reg, &m_fpuControl, "m_fpuControl");
@ -182,7 +182,7 @@ void CRegInfo::ChangeFPURegFormat (int Reg, FPU_STATE OldFormat, FPU_STATE NewFo
}
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("ChangeFormat: Register not on stack!!");
g_Notify->DisplayError("ChangeFormat: Register not on stack!!");
#endif
}
@ -195,8 +195,8 @@ void CRegInfo::Load_FPR_ToTop ( int Reg, int RegToLoad, FPU_STATE Format)
CPU_Message("CurrentRoundingModel: %s FpuRoundingModel(StackTopPos()): %s",RoundingModelName(GetRoundingModel()),RoundingModelName(FpuRoundingModel(StackTopPos())));
int i;
if (RegToLoad < 0) { _Notify->DisplayError("Load_FPR_ToTop\nRegToLoad < 0 ???"); return; }
if (Reg < 0) { _Notify->DisplayError("Load_FPR_ToTop\nReg < 0 ???"); return; }
if (RegToLoad < 0) { g_Notify->DisplayError("Load_FPR_ToTop\nRegToLoad < 0 ???"); return; }
if (Reg < 0) { g_Notify->DisplayError("Load_FPR_ToTop\nReg < 0 ???"); return; }
if (Format == FPU_Double || Format == FPU_Qword) {
UnMap_FPR(Reg + 1,TRUE);
@ -327,7 +327,7 @@ void CRegInfo::Load_FPR_ToTop ( int Reg, int RegToLoad, FPU_STATE Format)
break;
#ifndef EXTERNAL_RELEASE
default:
_Notify->DisplayError("Load_FPR_ToTop\nUnkown format to load %d",Format);
g_Notify->DisplayError("Load_FPR_ToTop\nUnkown format to load %d",Format);
#endif
}
SetX86Protected(TempReg,FALSE);
@ -507,8 +507,8 @@ CRegInfo::x86Reg CRegInfo::Map_MemoryStack ( x86Reg Reg, bool bMapRegister, bool
Reg = FreeX86Reg();
if (Reg == x86_Unknown)
{
_Notify->DisplayError("Map_MemoryStack\n\nOut of registers");
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->DisplayError("Map_MemoryStack\n\nOut of registers");
g_Notify->BreakPoint(__FILE__,__LINE__);
}
SetX86Mapped(Reg,CRegInfo::Stack_Mapped);
CPU_Message(" regcache: allocate %s as Memory Stack",x86_Name(Reg));
@ -545,7 +545,7 @@ void CRegInfo::Map_GPR_32bit (int MipsReg, bool SignValue, int MipsRegToLoad)
x86Reg Reg;
if (MipsReg == 0)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
@ -554,9 +554,9 @@ void CRegInfo::Map_GPR_32bit (int MipsReg, bool SignValue, int MipsRegToLoad)
Reg = FreeX86Reg();
if (Reg < 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Map_GPR_32bit\n\nOut of registers");
g_Notify->DisplayError("Map_GPR_32bit\n\nOut of registers");
#endif
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
CPU_Message(" regcache: allocate %s to %s",x86_Name(Reg),CRegName::GPR[MipsReg]);
@ -610,7 +610,7 @@ void CRegInfo::Map_GPR_64bit ( int MipsReg, int MipsRegToLoad)
if (MipsReg == 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("Map_GPR_32bit\n\nWhy are you trying to map reg 0");
g_Notify->DisplayError("Map_GPR_32bit\n\nWhy are you trying to map reg 0");
#endif
return;
}
@ -618,11 +618,11 @@ void CRegInfo::Map_GPR_64bit ( int MipsReg, int MipsRegToLoad)
ProtectGPR(MipsReg);
if (IsUnknown(MipsReg) || IsConst(MipsReg)) {
x86Hi = FreeX86Reg();
if (x86Hi < 0) { _Notify->DisplayError("Map_GPR_64bit\n\nOut of registers"); return; }
if (x86Hi < 0) { g_Notify->DisplayError("Map_GPR_64bit\n\nOut of registers"); return; }
SetX86Protected(x86Hi,TRUE);
x86lo = FreeX86Reg();
if (x86lo < 0) { _Notify->DisplayError("Map_GPR_64bit\n\nOut of registers"); return; }
if (x86lo < 0) { g_Notify->DisplayError("Map_GPR_64bit\n\nOut of registers"); return; }
SetX86Protected(x86lo,TRUE);
CPU_Message(" regcache: allocate %s to hi word of %s",x86_Name(x86Hi),CRegName::GPR[MipsReg]);
@ -634,7 +634,7 @@ void CRegInfo::Map_GPR_64bit ( int MipsReg, int MipsRegToLoad)
x86Hi = FreeX86Reg();
if (x86Hi == x86_Unknown)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
SetX86Protected(x86Hi,TRUE);
@ -721,7 +721,7 @@ CX86Ops::x86Reg CRegInfo::Map_TempReg (CX86Ops::x86Reg Reg, int MipsReg, BOOL Lo
if (Reg == x86_Unknown)
{
WriteTrace(TraceError,"CRegInfo::Map_TempReg: Failed to find a free register");
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return x86_Unknown;
}
}
@ -738,7 +738,7 @@ CX86Ops::x86Reg CRegInfo::Map_TempReg (CX86Ops::x86Reg Reg, int MipsReg, BOOL Lo
Reg = Free8BitX86Reg();
if (Reg < 0) {
WriteTrace(TraceError,"CRegInfo::Map_TempReg: Failed to find a free 8 bit register");
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return x86_Unknown;
}
}
@ -746,7 +746,7 @@ CX86Ops::x86Reg CRegInfo::Map_TempReg (CX86Ops::x86Reg Reg, int MipsReg, BOOL Lo
if (GetX86Protected(Reg))
{
WriteTrace(TraceError,"CRegInfo::Map_TempReg: Register is protected");
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return x86_Unknown;
}
@ -963,7 +963,7 @@ void CRegInfo::UnMap_FPR (int Reg, int WriteBackValue )
break;
#ifndef EXTERNAL_RELEASE
default:
_Notify->DisplayError("UnMap_FPR\nUnknown format to load %d",x86fpu_State[StackTopPos()]);
g_Notify->DisplayError("UnMap_FPR\nUnknown format to load %d",x86fpu_State[StackTopPos()]);
#endif
}
SetX86Protected(TempReg,FALSE);
@ -986,7 +986,7 @@ void CRegInfo::UnMap_GPR (DWORD Reg, bool WriteBackValue)
{
if (Reg == 0) {
#ifndef EXTERNAL_RELEASE
_Notify->DisplayError("UnMap_GPR\n\nWhy are you trying to unmap reg 0");
g_Notify->DisplayError("UnMap_GPR\n\nWhy are you trying to unmap reg 0");
#endif
return;
}
@ -1209,7 +1209,7 @@ void CRegInfo::WriteBackRegisters ()
break;
default:
CPU_Message(__FUNCTION__ ": Unknown State: %d reg %d (%s)",GetMipsRegState(count),count,CRegName::GPR[count])
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
}

8
Source/Project64/N64 System/Recompiler/Section Info.cpp
View File

@ -56,7 +56,7 @@ void CCodeSection::UnlinkParent( CCodeSection * Parent, bool AllowDelete, bool C
// {
// if (!ContinueSection && Parent->ContinueSection == this)
// {
// _Notify->BreakPoint(__FILE__,__LINE__);
// g_Notify->BreakPoint(__FILE__,__LINE__);
// }
// }
if (ContinueSection && Parent->ContinueSection == this)
@ -67,7 +67,7 @@ void CCodeSection::UnlinkParent( CCodeSection * Parent, bool AllowDelete, bool C
// {
// if (ContinueSection && Parent->JumpSection == this)
// {
// _Notify->BreakPoint(__FILE__,__LINE__);
// g_Notify->BreakPoint(__FILE__,__LINE__);
// }
// }
if (!ContinueSection && Parent->JumpSection == this)
@ -106,7 +106,7 @@ CCodeSection::~CCodeSection ( void )
ContinueSection->UnlinkParent(this, true, true);
if (ContinueSection)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
ContinueSection = NULL;
}
@ -115,7 +115,7 @@ CCodeSection::~CCodeSection ( void )
JumpSection->UnlinkParent(this, true, false);
if (JumpSection)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
JumpSection = NULL;
}

366
Source/Project64/N64 System/Recompiler/X86ops.cpp
View File

File diff suppressed because it is too large Load Diff

6
Source/Project64/N64 System/Speed Limitor Class.cpp
View File

@ -1,8 +1,8 @@
#include "stdafx.h"
#pragma comment(lib, "winmm.lib")
CSpeedLimitor::CSpeedLimitor(CNotification * const _Notify ) :
_Notify(_Notify)
CSpeedLimitor::CSpeedLimitor(CNotification * const g_Notify ) :
g_Notify(g_Notify)
{
m_Frames = 0;
m_LastTime = 0;
@ -13,7 +13,7 @@ CSpeedLimitor::CSpeedLimitor(CNotification * const _Notify ) :
TIMECAPS Caps;
timeGetDevCaps(&Caps, sizeof(Caps));
if (timeBeginPeriod(Caps.wPeriodMin) == TIMERR_NOCANDO) {
_Notify->DisplayError("Error during timer begin");
g_Notify->DisplayError("Error during timer begin");
}
}

4
Source/Project64/N64 System/Speed Limitor Class.h
View File

@ -1,12 +1,12 @@
class CSpeedLimitor {
CNotification * const _Notify;
CNotification * const g_Notify;
DWORD m_Speed, m_BaseSpeed, m_Frames, m_LastTime;
double m_Ratio;
void FixSpeedRatio ( void );
public:
CSpeedLimitor ( CNotification * const _Notify );
CSpeedLimitor ( CNotification * const g_Notify );
~CSpeedLimitor ( void );
void SetHertz ( const DWORD Hertz );
bool Timer_Process ( DWORD * const FrameRate );

2
Source/Project64/N64 System/System Globals.cpp
View File

@ -7,7 +7,7 @@ CRecompiler * _Recompiler = NULL;
CMipsMemory * _MMU = NULL; //Memory of the n64
CTLB * _TLB = NULL; //TLB Unit
CRegisters * _Reg = NULL; //Current Register Set attacted to the _MMU
CNotification * _Notify = NULL;
CNotification * g_Notify = NULL;
CPlugins * _Plugins = NULL;
CN64Rom * _Rom = NULL; //The current rom that this system is executing.. it can only execute one file at the time
CAudio * _Audio = NULL;

2
Source/Project64/N64 System/System Globals.h
View File

@ -1,4 +1,4 @@
extern CNotification * _Notify;
extern CNotification * g_Notify;
extern CSettings * _Settings;
extern CN64System * _System;

2
Source/Project64/Plugins/Controller Plugin.cpp
View File

@ -273,7 +273,7 @@ void CControl_Plugin::UpdateKeys (void) {
if (!m_Controllers[cont]->m_RawData) {
GetKeys(cont,&m_Controllers[cont]->m_Buttons);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
if (ReadController) { ReadController(-1,NULL); }

4
Source/Project64/Plugins/Plugin Class.cpp
View File

@ -47,7 +47,7 @@ void CPlugins::PluginChanged ( CPlugins * _this )
if (_BaseSystem) { _BaseSystem->ExternalEvent(SysEvent_ChangePlugins); }
} else {
_this->Reset();
_Notify->RefreshMenu();
g_Notify->RefreshMenu();
}
}
}
@ -60,7 +60,7 @@ void CPlugins::CreatePlugins( void ) {
if (bHaveDebugger())
{
_Notify->RefreshMenu();
g_Notify->RefreshMenu();
}
}

16
Source/Project64/Settings/SettingType/SettingsType-Application.cpp
View File

@ -112,7 +112,7 @@ bool CSettingTypeApplication::Load ( int /*Index*/, bool & Value ) const
Value = dwValue != 0;
}
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (!bRes && m_DefaultSetting != Default_None)
@ -134,7 +134,7 @@ bool CSettingTypeApplication::Load ( int /*Index*/, ULONG & Value ) const
{
bRes = m_SettingsIniFile->GetNumber(SectionName(),m_KeyNameIdex.c_str(),Value,Value);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (!bRes && m_DefaultSetting != Default_None)
{
@ -160,7 +160,7 @@ bool CSettingTypeApplication::Load ( int Index, stdstr & Value ) const
{
bRes = m_SettingsIniFile ? m_SettingsIniFile->GetString(SectionName(),m_KeyNameIdex.c_str(),m_DefaultStr,Value) : false;
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (!bRes)
{
@ -216,7 +216,7 @@ void CSettingTypeApplication::Save ( int /*Index*/, bool Value )
{
m_SettingsIniFile->SaveNumber(SectionName(),m_KeyNameIdex.c_str(),Value);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -226,7 +226,7 @@ void CSettingTypeApplication::Save ( int /*Index*/, ULONG Value )
{
m_SettingsIniFile->SaveNumber(SectionName(),m_KeyNameIdex.c_str(),Value);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -236,7 +236,7 @@ void CSettingTypeApplication::Save ( int /*Index*/, const stdstr & Value )
{
m_SettingsIniFile->SaveString(SectionName(),m_KeyNameIdex.c_str(),Value.c_str());
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -246,7 +246,7 @@ void CSettingTypeApplication::Save ( int /*Index*/, const char * Value )
{
m_SettingsIniFile->SaveString(SectionName(),m_KeyNameIdex.c_str(),Value);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -271,6 +271,6 @@ void CSettingTypeApplication::Delete( int /*Index*/ )
{
m_SettingsIniFile->SaveString(SectionName(),m_KeyNameIdex.c_str(),NULL);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}

16
Source/Project64/Settings/SettingType/SettingsType-Cheats.cpp
View File

@ -62,18 +62,18 @@ LPCSTR CSettingTypeCheats::SectionName ( void ) const
void CSettingTypeCheats::UpdateSettings ( void * )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}*/
bool CSettingTypeCheats::Load ( int /*Index*/, bool & /*Value*/ ) const
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
bool CSettingTypeCheats::Load ( int /*Index*/, ULONG & /*Value*/ ) const
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
@ -90,28 +90,28 @@ bool CSettingTypeCheats::Load ( int Index, stdstr & Value ) const
//return the default values
void CSettingTypeCheats::LoadDefault ( int /*Index*/, bool & /*Value*/ ) const
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeCheats::LoadDefault ( int /*Index*/, ULONG & /*Value*/ ) const
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeCheats::LoadDefault ( int /*Index*/, stdstr & /*Value*/ ) const
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
//Update the settings
void CSettingTypeCheats::Save ( int /*Index*/, bool /*Value*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeCheats::Save ( int /*Index*/, ULONG /*Value*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeCheats::Save ( int Index, const stdstr & Value )

12
Source/Project64/Settings/SettingType/SettingsType-RDBYesNo.cpp
View File

@ -44,13 +44,13 @@ bool CSettingTypeRDBYesNo::Load ( int Index, bool & Value ) const
bool CSettingTypeRDBYesNo::Load ( int /*Index*/, ULONG & /*Value*/ ) const
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
bool CSettingTypeRDBYesNo::Load ( int /*Index*/, stdstr & /*Value*/ ) const
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
@ -70,12 +70,12 @@ void CSettingTypeRDBYesNo::LoadDefault ( int /*Index*/, bool & Value ) const
void CSettingTypeRDBYesNo::LoadDefault ( int /*Index*/, ULONG & /*Value*/ ) const
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeRDBYesNo::LoadDefault ( int /*Index*/, stdstr & /*Value*/ ) const
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
@ -92,12 +92,12 @@ void CSettingTypeRDBYesNo::Save ( int /*Index*/, ULONG Value )
void CSettingTypeRDBYesNo::Save ( int /*Index*/, const stdstr & /*Value*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeRDBYesNo::Save ( int /*Index*/, const char * /*Value*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeRDBYesNo::Delete( int /*Index*/ )

72
Source/Project64/Settings/Settings Class.cpp
View File

@ -356,7 +356,7 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
case SettingType_ConstValue:
if (DataType != Data_DWORD)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
_this->AddHandler(ID,new CSettingTypeTempNumber(Value));
@ -364,7 +364,7 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
case SettingType_ConstString:
if (DataType != Data_String)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
_this->AddHandler(ID,new CSettingTypeTempString(DefaultStr));
@ -390,7 +390,7 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
}
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
case SettingType_GameSetting:
@ -415,7 +415,7 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
}
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
break;
@ -439,11 +439,11 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
}
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -477,7 +477,7 @@ bool CSettings::LoadBool ( SettingID Type, bool & Value )
}
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
return FindInfo->second->Load(0,Value);
}
@ -504,7 +504,7 @@ bool CSettings::LoadBoolIndex( SettingID Type, int index , bool & Value )
{
return FindInfo->second->Load(index,Value);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
return false;
}
@ -527,7 +527,7 @@ bool CSettings::LoadDword ( SettingID Type, DWORD & Value)
}
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
return FindInfo->second->Load(0,Value);
}
@ -554,7 +554,7 @@ bool CSettings::LoadDwordIndex( SettingID Type, int index, DWORD & Value)
{
return FindInfo->second->Load(index,Value);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
return false;
}
@ -577,7 +577,7 @@ bool CSettings::LoadString ( SettingID Type, stdstr & Value )
}
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
return FindInfo->second->Load(0,Value);
}
@ -596,7 +596,7 @@ bool CSettings::LoadString ( SettingID Type, char * Buffer, int BufferSize )
bool bRes = false;
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
stdstr Value;
bRes = FindInfo->second->Load(0,Value);
@ -630,14 +630,14 @@ bool CSettings::LoadStringIndex ( SettingID Type, int index, stdstr & Value )
{
return FindInfo->second->Load(index,Value);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
return false;
}
bool CSettings::LoadStringIndex ( SettingID /*Type*/, int /*index*/, char * /*Buffer*/, int /*BufferSize*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
@ -659,7 +659,7 @@ void CSettings::LoadDefaultBool ( SettingID Type, bool & Value )
} else {
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->LoadDefault(0,Value);
}
@ -668,13 +668,13 @@ void CSettings::LoadDefaultBool ( SettingID Type, bool & Value )
bool CSettings::LoadDefaultBoolIndex ( SettingID /*Type*/, int /*index*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
void CSettings::LoadDefaultBoolIndex ( SettingID /*Type*/, int /*index*/, bool & /*Value*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
DWORD CSettings::LoadDefaultDword ( SettingID Type )
@ -694,7 +694,7 @@ void CSettings::LoadDefaultDword ( SettingID Type, DWORD & Value)
} else {
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->LoadDefault(0,Value);
}
@ -703,13 +703,13 @@ void CSettings::LoadDefaultDword ( SettingID Type, DWORD & Value)
DWORD CSettings::LoadDefaultDwordIndex ( SettingID /*Type*/, int /*index*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
void CSettings::LoadDefaultDwordIndex ( SettingID /*Type*/, int /*index*/, DWORD & /*Value*/)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
stdstr CSettings::LoadDefaultString ( SettingID Type )
@ -729,7 +729,7 @@ void CSettings::LoadDefaultString ( SettingID Type, stdstr & Value )
} else {
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->LoadDefault(0,Value);
}
@ -738,23 +738,23 @@ void CSettings::LoadDefaultString ( SettingID Type, stdstr & Value )
void CSettings::LoadDefaultString ( SettingID /*Type*/, char * /*Buffer*/, int /*BufferSize*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
stdstr CSettings::LoadDefaultStringIndex ( SettingID /*Type*/, int /*index*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
void CSettings::LoadDefaultStringIndex ( SettingID /*Type*/, int /*index*/, stdstr & /*Value*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettings::LoadDefaultStringIndex ( SettingID /*Type*/, int /*index*/, char * /*Buffer*/, int /*BufferSize*/ )
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettings::SaveBool ( SettingID Type, bool Value )
@ -768,7 +768,7 @@ void CSettings::SaveBool ( SettingID Type, bool Value )
}
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Save(0,Value);
}
@ -788,7 +788,7 @@ void CSettings::SaveBoolIndex( SettingID Type, int index, bool Value )
{
FindInfo->second->Save(index,Value);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
NotifyCallBacks(Type);
}
@ -804,7 +804,7 @@ void CSettings::SaveDword ( SettingID Type, DWORD Value )
}
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Save(0,Value);
}
@ -824,7 +824,7 @@ void CSettings::SaveDwordIndex ( SettingID Type, int index, DWORD Value )
{
FindInfo->second->Save(index,Value);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
NotifyCallBacks(Type);
}
@ -840,7 +840,7 @@ void CSettings::SaveString ( SettingID Type, const stdstr & Value )
}
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Save(0,Value);
}
@ -857,7 +857,7 @@ void CSettings::SaveString ( SettingID Type, const char * Buffer )
}
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Save(0,Buffer);
}
@ -876,7 +876,7 @@ void CSettings::SaveStringIndex( SettingID Type, int index, const char * Buffer
{
FindInfo->second->Save(index,Buffer);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
NotifyCallBacks(Type);
}
@ -896,7 +896,7 @@ void CSettings::DeleteSetting( SettingID Type )
}
if (FindInfo->second->IndexBasedSetting())
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Delete(0);
}
@ -915,7 +915,7 @@ void CSettings::DeleteSettingIndex( SettingID Type, int index )
{
FindInfo->second->Delete(index);
} else {
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
NotifyCallBacks(Type);
}
@ -960,7 +960,7 @@ void CSettings::SettingTypeChanged( SettingType Type )
void CSettings::UnknownSetting (SettingID /*Type*/)
{
#ifdef _DEBUG
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
#endif
}
@ -1044,6 +1044,6 @@ void CSettings::UnregisterChangeCB(SettingID Type,void * Data, SettingChangedFun
if (!bRemoved)
{
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}

20
Source/Project64/User Interface/Frame Per Second Class.cpp
View File

@ -1,7 +1,7 @@
#include "stdafx.h"
CFramePerSecond::CFramePerSecond (CNotification * Notification):
_Notify(Notification)
g_Notify(Notification)
{
m_iFrameRateType = _Settings->LoadDword(UserInterface_FrameDisplayType);
m_ScreenHertz = _Settings->LoadDword(GameRunning_ScreenHertz);
@ -34,7 +34,7 @@ void CFramePerSecond::Reset (bool ClearDisplay) {
}
if (ClearDisplay)
{
_Notify->DisplayMessage2("");
g_Notify->DisplayMessage2("");
return;
}
@ -64,7 +64,7 @@ void CFramePerSecond::DisplayViCounter(DWORD FrameRate) {
if (m_iFrameRateType == FR_VIs)
{
if (FrameRate != 0) {
_Notify->DisplayMessage2("VI/s: %d.00", FrameRate);
g_Notify->DisplayMessage2("VI/s: %d.00", FrameRate);
} else {
if (CurrentFrame > (NoOfFrames << 3)) {
__int64 Total;
@ -73,9 +73,9 @@ void CFramePerSecond::DisplayViCounter(DWORD FrameRate) {
for (int count = 0; count < NoOfFrames; count ++) {
Total += Frames[count];
}
_Notify->DisplayMessage2("VI/s: %.2f", Frequency/ ((double)Total / (NoOfFrames << 3)));
g_Notify->DisplayMessage2("VI/s: %.2f", Frequency/ ((double)Total / (NoOfFrames << 3)));
} else {
_Notify->DisplayMessage2("VI/s: -.--");
g_Notify->DisplayMessage2("VI/s: -.--");
}
}
}
@ -94,11 +94,11 @@ void CFramePerSecond::DisplayViCounter(DWORD FrameRate) {
}
Percent = ((float)(Frequency/ ((double)Total / (NoOfFrames << 3)))) / m_ScreenHertz;
} else {
_Notify->DisplayMessage2("");
g_Notify->DisplayMessage2("");
return;
}
}
_Notify->DisplayMessage2("%.1f %%",Percent * 100);
g_Notify->DisplayMessage2("%.1f %%",Percent * 100);
}
}
@ -136,7 +136,7 @@ void CFramePerSecond::DisplayDlCounter(DWORD FrameRate) {
return;
}
if (FrameRate != 0) {
_Notify->DisplayMessage2("DL/s: %d.00", FrameRate);
g_Notify->DisplayMessage2("DL/s: %d.00", FrameRate);
} else {
if (CurrentFrame > (NoOfFrames << 2)) {
__int64 Total;
@ -145,9 +145,9 @@ void CFramePerSecond::DisplayDlCounter(DWORD FrameRate) {
for (int count = 0; count < NoOfFrames; count ++) {
Total += Frames[count];
}
_Notify->DisplayMessage2("DL/s: %.1f", Frequency/ ((double)Total / (NoOfFrames << 2)));
g_Notify->DisplayMessage2("DL/s: %.1f", Frequency/ ((double)Total / (NoOfFrames << 2)));
} else {
_Notify->DisplayMessage2("DL/s: -.--");
g_Notify->DisplayMessage2("DL/s: -.--");
}
}
}

2
Source/Project64/User Interface/Frame Per Second Class.h
View File

@ -1,5 +1,5 @@
class CFramePerSecond {
CNotification * const _Notify;
CNotification * const g_Notify;
int m_iFrameRateType, m_ScreenHertz;
enum { NoOfFrames = 7 };

6
Source/Project64/User Interface/Gui Class.cpp
View File

@ -687,7 +687,7 @@ DWORD CALLBACK CMainGui::MainGui_Proc (WND_HANDLE hWnd, DWORD uMsg, DWORD wParam
{
if (!fActive && _Settings->LoadBool(UserInterface_InFullScreen))
{
_Notify->WindowMode();
g_Notify->WindowMode();
if (bAutoSleep() && _BaseSystem)
{
//System->ExternalEvent(PauseCPU_AppLostActiveDelayed );
@ -792,7 +792,7 @@ DWORD CALLBACK CMainGui::MainGui_Proc (WND_HANDLE hWnd, DWORD uMsg, DWORD wParam
break;
}
Rom.SaveRomSettingID();
_Notify->DisplayMessage(0,"");
g_Notify->DisplayMessage(0,"");
BYTE * RomHeader = Rom.GetRomAddress();
WriteTrace(TraceGfxPlugin,"OnRomBrowserMenuItem: Starting");
_Plugins->Gfx()->OnRomBrowserMenuItem(LOWORD(wParam),hWnd,RomHeader);
@ -816,7 +816,7 @@ DWORD CALLBACK CMainGui::MainGui_Proc (WND_HANDLE hWnd, DWORD uMsg, DWORD wParam
CMainGui * _this = (CMainGui *)GetProp((HWND)hWnd,"Class");
if (_this->m_bMainWindow)
{
_Notify->WindowMode();
g_Notify->WindowMode();
}
_this->m_hMainWindow = NULL;
WriteTrace(TraceDebug,"WM_DESTROY - 1");

8
Source/Project64/User Interface/Main Menu Class.cpp
View File

@ -295,7 +295,7 @@ bool CMainMenu::ProcessMessage(WND_HANDLE hWnd, DWORD /*FromAccelerator*/, DWORD
if (_Settings->LoadBool(UserInterface_ShowCPUPer))
{
_Settings->SaveBool(UserInterface_ShowCPUPer,false);
_Notify->DisplayMessage(0,"");
g_Notify->DisplayMessage(0,"");
} else {
_Settings->SaveBool(UserInterface_ShowCPUPer,true);
}
@ -322,11 +322,11 @@ bool CMainMenu::ProcessMessage(WND_HANDLE hWnd, DWORD /*FromAccelerator*/, DWORD
_Settings->SaveBool(Debugger_ShowPifErrors,!_Settings->LoadBool(Debugger_ShowPifErrors));
break;
case ID_DEBUG_SHOW_DLIST_COUNT:
_Notify->DisplayMessage(0,"");
g_Notify->DisplayMessage(0,"");
_Settings->SaveBool(Debugger_ShowDListAListCount,!_Settings->LoadBool(Debugger_ShowDListAListCount));
break;
case ID_DEBUG_SHOW_RECOMP_MEM_SIZE:
_Notify->DisplayMessage(0,"");
g_Notify->DisplayMessage(0,"");
_Settings->SaveBool(Debugger_ShowRecompMemSize,!_Settings->LoadBool(Debugger_ShowRecompMemSize));
break;
case ID_DEBUG_SHOW_DIV_BY_ZERO:
@ -525,7 +525,7 @@ bool CMainMenu::ProcessMessage(WND_HANDLE hWnd, DWORD /*FromAccelerator*/, DWORD
stdstr Dir = _Settings->LoadStringIndex(Directory_RecentGameDirIndex,Offset);
if (Dir.length() > 0) {
_Settings->SaveString(Directory_Game,Dir.c_str());
_Notify->AddRecentDir(Dir.c_str());
g_Notify->AddRecentDir(Dir.c_str());
_Gui->RefreshMenu();
if (_Gui->RomBrowserVisible()) {
_Gui->RefreshRomBrowser();

4
Source/Project64/User Interface/Notification Class.cpp
View File

@ -3,8 +3,8 @@
CNotification & Notify ( void )
{
static CNotification _Notify;
return _Notify;
static CNotification g_Notify;
return g_Notify;
}
CNotification::CNotification ( ) :

4
Source/Project64/User Interface/Rom Browser Class.cpp
View File

@ -540,7 +540,7 @@ bool CRomBrowser::GetRomFileNames( strlist & FileList, const CPath & BaseDirecto
void CRomBrowser::NotificationCB ( LPCSTR Status, CRomBrowser * /*_this*/ )
{
_Notify->DisplayMessage(5,"%s",Status);
g_Notify->DisplayMessage(5,"%s",Status);
}
@ -1542,7 +1542,7 @@ void CRomBrowser::SelectRomDir(void)
WriteTrace(TraceDebug,"CRomBrowser::SelectRomDir 6");
_Settings->SaveString(Directory_Game,Directory);
WriteTrace(TraceDebug,"CRomBrowser::SelectRomDir 7");
_Notify->AddRecentDir(Directory);
g_Notify->AddRecentDir(Directory);
WriteTrace(TraceDebug,"CRomBrowser::SelectRomDir 8");
RefreshRomBrowser();
WriteTrace(TraceDebug,"CRomBrowser::SelectRomDir 9");

14
Source/Project64/User Interface/Settings/Settings Page - Keyboard Shortcuts.cpp
View File

@ -120,13 +120,13 @@ void COptionsShortCutsPage::OnRemoveClicked ( UINT /*Code*/, int /*id*/, HWND /*
HTREEITEM hSelectedItem = m_MenuItems.GetSelectedItem();
if (hSelectedItem == NULL)
{
_Notify->DisplayError(GS(MSG_NO_SEL_SHORTCUT));
g_Notify->DisplayError(GS(MSG_NO_SEL_SHORTCUT));
return;
}
HTREEITEM hParent = m_MenuItems.GetParentItem(hSelectedItem);
if (hParent == NULL)
{
_Notify->DisplayError(GS(MSG_NO_SEL_SHORTCUT));
g_Notify->DisplayError(GS(MSG_NO_SEL_SHORTCUT));
return;
}
@ -136,7 +136,7 @@ void COptionsShortCutsPage::OnRemoveClicked ( UINT /*Code*/, int /*id*/, HWND /*
int index = m_CurrentKeys.GetCurSel();
if (index < 0)
{
_Notify->DisplayError(GS(MSG_NO_SEL_SHORTCUT));
g_Notify->DisplayError(GS(MSG_NO_SEL_SHORTCUT));
return;
}
ShortCut->RemoveItem((CMenuShortCutKey *)m_CurrentKeys.GetItemData(index));
@ -159,7 +159,7 @@ void COptionsShortCutsPage::OnAssignClicked ( UINT /*Code*/, int /*id*/, HWND /*
int index = m_VirtualKeyList.GetCurSel();
if (index < 0)
{
_Notify->DisplayError(GS(MSG_NO_SHORTCUT_SEL));
g_Notify->DisplayError(GS(MSG_NO_SHORTCUT_SEL));
return;
}
@ -174,13 +174,13 @@ void COptionsShortCutsPage::OnAssignClicked ( UINT /*Code*/, int /*id*/, HWND /*
HTREEITEM hSelectedItem = m_MenuItems.GetSelectedItem();
if (hSelectedItem == NULL)
{
_Notify->DisplayError(GS(MSG_NO_MENUITEM_SEL));
g_Notify->DisplayError(GS(MSG_NO_MENUITEM_SEL));
return;
}
HTREEITEM hParent = m_MenuItems.GetParentItem(hSelectedItem);
if (hParent == NULL)
{
_Notify->DisplayError(GS(MSG_NO_MENUITEM_SEL));
g_Notify->DisplayError(GS(MSG_NO_MENUITEM_SEL));
return;
}
@ -189,7 +189,7 @@ void COptionsShortCutsPage::OnAssignClicked ( UINT /*Code*/, int /*id*/, HWND /*
LanguageStringID strid = m_ShortCuts.GetMenuItemName(key,bCtrl,bAlt,bShift,AccessLevel);
if (strid != EMPTY_STRING)
{
_Notify->DisplayError(GS(MSG_MENUITEM_ASSIGNED));
g_Notify->DisplayError(GS(MSG_MENUITEM_ASSIGNED));
return;
}
ShortCut->AddShortCut(key,bCtrl,bAlt,bShift,AccessLevel,true,false);

2
Source/Project64/User Interface/Settings/Settings Page - Plugin.cpp
View File

@ -244,7 +244,7 @@ void COptionPluginPage::ApplyComboBoxes ( void )
case PLUGIN_TYPE_AUDIO: _Settings->SaveBool(Plugin_AUDIO_Changed,true); break;
case PLUGIN_TYPE_CONTROLLER: _Settings->SaveBool(Plugin_CONT_Changed,true); break;
default:
_Notify->BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
if (ComboBox->IsReset())

4
Source/Project64/main.cpp
View File

@ -263,7 +263,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPSTR /*lps
WriteTrace(TraceDebug,"WinMain - Application Starting");
FixUPXIssue((BYTE *)hInstance);
_Notify = &Notify();
g_Notify = &Notify();
//Create the plugin container
WriteTrace(TraceDebug,"WinMain - Create Plugins");
@ -282,7 +282,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPSTR /*lps
CMainGui MainWindow(true,WinTitle.c_str()), HiddenWindow(false);
CMainMenu MainMenu(&MainWindow);
_Plugins->SetRenderWindows(&MainWindow,&HiddenWindow);
_Notify->SetMainWindow(&MainWindow);
g_Notify->SetMainWindow(&MainWindow);
{
stdstr_f User("%s",_Settings->LoadString(Beta_UserName).c_str());