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

Project64: Code cleanup

This commit is contained in:
zilmar 2022-09-26 12:01:54 +09:30
parent a65086579f
commit 179282043f
151 changed files with 11511 additions and 9945 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
Source/Project64-core/AppInit.cpp
View File

@ -1,16 +1,16 @@
#include "stdafx.h" #include "stdafx.h"
#include <Common/path.h>
#include <Common/Trace.h> #include <Common/Trace.h>
#include <Common/Util.h> #include <Common/Util.h>
#include <Common/path.h>
#include "Settings/SettingType/SettingsType-Application.h"
#include <Project64-core/N64System/Enhancement/Enhancements.h>
#include <Project64-core/N64System/Mips/MemoryVirtualMem.h> #include <Project64-core/N64System/Mips/MemoryVirtualMem.h>
#include <Project64-core/N64System/N64Disk.h>
#include <Project64-core/N64System/N64Rom.h>
#include <Project64-core/N64System/SystemGlobals.h> #include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/Plugins/Plugin.h> #include <Project64-core/Plugins/Plugin.h>
#include <Project64-core/N64System/N64Rom.h>
#include <Project64-core/N64System/N64Disk.h>
#include <Project64-core/N64System/Enhancement/Enhancements.h>
#include "Settings/SettingType/SettingsType-Application.h"
static void FixDirectories(void); static void FixDirectories(void);
void SetTraceModuleNames(void); void SetTraceModuleNames(void);
@ -164,7 +164,11 @@ void CleanupTrace(void)
void TraceDone(void) void TraceDone(void)
{ {
CloseTrace(); CloseTrace();
if (g_LogFile) { delete g_LogFile; g_LogFile = nullptr; } if (g_LogFile)
{
delete g_LogFile;
g_LogFile = nullptr;
}
} }
const char * AppName(void) const char * AppName(void)
@ -173,7 +177,7 @@ const char * AppName(void)
return ApplicationName.c_str(); return ApplicationName.c_str();
} }
static bool ParseCommand(int32_t argc, char **argv) static bool ParseCommand(int32_t argc, char ** argv)
{ {
if (argc <= 1) if (argc <= 1)
{ {
@ -213,7 +217,7 @@ static bool ParseCommand(int32_t argc, char **argv)
return false; return false;
} }
bool AppInit(CNotification * Notify, const char * BaseDirectory, int argc, char **argv) bool AppInit(CNotification * Notify, const char * BaseDirectory, int argc, char ** argv)
{ {
try try
{ {
@ -283,13 +287,41 @@ void AppCleanup(void)
WriteTrace(TraceAppCleanup, TraceDebug, "Cleaning up global objects"); WriteTrace(TraceAppCleanup, TraceDebug, "Cleaning up global objects");
CleanupTrace(); CleanupTrace();
if (g_Enhancements) { delete g_Enhancements; g_Enhancements = nullptr; } if (g_Enhancements)
if (g_Rom) { delete g_Rom; g_Rom = nullptr; } {
if (g_DDRom) { delete g_DDRom; g_DDRom = nullptr; } delete g_Enhancements;
if (g_Disk) { delete g_Disk; g_Disk = nullptr; } g_Enhancements = nullptr;
if (g_Plugins) { delete g_Plugins; g_Plugins = nullptr; } }
if (g_Settings) { delete g_Settings; g_Settings = nullptr; } if (g_Rom)
if (g_Lang) { delete g_Lang; g_Lang = nullptr; } {
delete g_Rom;
g_Rom = nullptr;
}
if (g_DDRom)
{
delete g_DDRom;
g_DDRom = nullptr;
}
if (g_Disk)
{
delete g_Disk;
g_Disk = nullptr;
}
if (g_Plugins)
{
delete g_Plugins;
g_Plugins = nullptr;
}
if (g_Settings)
{
delete g_Settings;
g_Settings = nullptr;
}
if (g_Lang)
{
delete g_Lang;
g_Lang = nullptr;
}
CMipsMemoryVM::FreeReservedMemory(); CMipsMemoryVM::FreeReservedMemory();
TraceDone(); TraceDone();

6
Source/Project64-core/Logging.cpp
View File

@ -1,12 +1,12 @@
#include "stdafx.h" #include "stdafx.h"
#include <Project64-core/Logging.h> #include <Project64-core/Logging.h>
#include <stdio.h>
#include <stdarg.h>
#include <Common/path.h> #include <Common/path.h>
#include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/N64System/Mips/MemoryVirtualMem.h> #include <Project64-core/N64System/Mips/MemoryVirtualMem.h>
#include <Project64-core/N64System/N64Rom.h> #include <Project64-core/N64System/N64Rom.h>
#include <Project64-core/N64System/SystemGlobals.h>
#include <stdarg.h>
#include <stdio.h>
CFile * CLogging::m_hLogFile = nullptr; CFile * CLogging::m_hLogFile = nullptr;

2
Source/Project64-core/MemoryExceptionFilter.cpp
View File

@ -1,8 +1,8 @@
#include "stdafx.h" #include "stdafx.h"
#include <Project64-core/N64System/Mips/MemoryVirtualMem.h> #include <Project64-core/N64System/Mips/MemoryVirtualMem.h>
#include <Project64-core/N64System/N64System.h>
#include <Project64-core/N64System/Recompiler/Recompiler.h> #include <Project64-core/N64System/Recompiler/Recompiler.h>
#include <Project64-core/N64System/SystemGlobals.h> #include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/N64System/N64System.h>
#ifndef _WIN32 #ifndef _WIN32
#include <stdlib.h> #include <stdlib.h>
#endif #endif

26
Source/Project64-core/Multilanguage/Language.cpp
View File

@ -1,13 +1,14 @@
#include "stdafx.h" #include "stdafx.h"
#include <stdio.h>
#include <stdint.h>
#include <Common/path.h> #include <Common/path.h>
#include <stdint.h>
#include <stdio.h>
CLanguage * g_Lang = nullptr; CLanguage * g_Lang = nullptr;
void CLanguage::LoadDefaultStrings(void) void CLanguage::LoadDefaultStrings(void)
{ {
#define DEF_STR(ID,str) m_DefaultStrings.insert(LANG_STRINGS::value_type(ID,str)) #define DEF_STR(ID, str) m_DefaultStrings.insert(LANG_STRINGS::value_type(ID, str))
DEF_STR(EMPTY_STRING, ""); DEF_STR(EMPTY_STRING, "");
@ -610,7 +611,7 @@ bool CLanguage::LoadCurrentStrings(void)
} }
// Process the file // Process the file
FILE *file = fopen(Filename.c_str(), "rb"); FILE * file = fopen(Filename.c_str(), "rb");
if (file == nullptr) if (file == nullptr)
{ {
return false; return false;
@ -696,7 +697,7 @@ const std::string & CLanguage::GetString(LanguageStringID StringID)
std::string CLanguage::GetLangString(const char * FileName, LanguageStringID ID) std::string CLanguage::GetLangString(const char * FileName, LanguageStringID ID)
{ {
FILE *file = fopen(FileName, "rb"); FILE * file = fopen(FileName, "rb");
if (file == nullptr) if (file == nullptr)
{ {
return ""; return "";
@ -729,9 +730,12 @@ std::string CLanguage::GetLangString(const char * FileName, LanguageStringID ID)
LANG_STR CLanguage::GetNextLangString(void * OpenFile) LANG_STR CLanguage::GetNextLangString(void * OpenFile)
{ {
enum { MAX_STRING_LEN = 800 }; enum
int32_t StringID; {
char szString[MAX_STRING_LEN]; // Temporarily store the string from the file MAX_STRING_LEN = 800
};
int32_t StringID;
char szString[MAX_STRING_LEN]; // Temporarily store the string from the file
FILE * file = (FILE *)OpenFile; FILE * file = (FILE *)OpenFile;
@ -762,7 +766,8 @@ LANG_STR CLanguage::GetNextLangString(void * OpenFile)
} }
if (feof(file)) if (feof(file))
{ {
StringID = EMPTY_STRING; return LANG_STR(0, ""); StringID = EMPTY_STRING;
return LANG_STR(0, "");
} }
// Search for start of string '"' // Search for start of string '"'
@ -772,7 +777,8 @@ LANG_STR CLanguage::GetNextLangString(void * OpenFile)
} }
if (feof(file)) if (feof(file))
{ {
StringID = EMPTY_STRING; return LANG_STR(0, ""); StringID = EMPTY_STRING;
return LANG_STR(0, "");
} }
int32_t pos = 0; int32_t pos = 0;

20
Source/Project64-core/N64System/Enhancement/Enhancement.cpp
View File

@ -1,13 +1,13 @@
#include "stdafx.h" #include "stdafx.h"
#include <Project64-core/N64System/Enhancement/Enhancement.h> #include <Project64-core/N64System/Enhancement/Enhancement.h>
#include <Project64-core/Settings/SettingType/SettingsType-GameSetting.h>
#include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/N64System/N64System.h> #include <Project64-core/N64System/N64System.h>
#include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/Settings/SettingType/SettingsType-GameSetting.h>
const char * CEnhancement::CheatIdent = "Cheat"; const char * CEnhancement::CheatIdent = "Cheat";
const char * CEnhancement::EnhancementIdent = "Enhancement"; const char * CEnhancement::EnhancementIdent = "Enhancement";
#pragma warning(disable:4996) #pragma warning(disable : 4996)
static std::string GenerateKeyName(const char * Name, const char * Ident, const char * PostIdent) static std::string GenerateKeyName(const char * Name, const char * Ident, const char * PostIdent)
{ {
@ -26,7 +26,7 @@ class CSettingEnhancementActive :
{ {
public: public:
CSettingEnhancementActive(const char * Name, const char * Ident, bool Default) : CSettingEnhancementActive(const char * Name, const char * Ident, bool Default) :
CSettingTypeGame("",false), CSettingTypeGame("", false),
m_Default(Default) m_Default(Default)
{ {
m_KeyNameIdex = GenerateKeyName(Name, Ident, "Active"); m_KeyNameIdex = GenerateKeyName(Name, Ident, "Active");
@ -90,7 +90,7 @@ public:
Flush(); Flush();
} }
bool SelectedValue(uint16_t &Value) bool SelectedValue(uint16_t & Value)
{ {
uint32_t StoredValue = 0; uint32_t StoredValue = 0;
if (!Load(0, StoredValue)) if (!Load(0, StoredValue))
@ -281,8 +281,14 @@ void CEnhancement::SetName(const char * Name)
CSettingEnhancementSelectedOption(m_Name.c_str(), m_Ident.c_str()).Delete(); CSettingEnhancementSelectedOption(m_Name.c_str(), m_Ident.c_str()).Delete();
m_Name = stdstr(Name != nullptr ? Name : "").Trim("\t ,"); m_Name = stdstr(Name != nullptr ? Name : "").Trim("\t ,");
m_NameAndExtension = m_Name; m_NameAndExtension = m_Name;
if (m_Active != m_OnByDefault) { CSettingEnhancementActive(m_Name.c_str(), m_Ident.c_str(), m_OnByDefault).SetActive(m_OnByDefault); } if (m_Active != m_OnByDefault)
if (OptionSelected()) { CSettingEnhancementSelectedOption(m_Name.c_str(), m_Ident.c_str()).SetOption(SelectedOption()); } {
CSettingEnhancementActive(m_Name.c_str(), m_Ident.c_str(), m_OnByDefault).SetActive(m_OnByDefault);
}
if (OptionSelected())
{
CSettingEnhancementSelectedOption(m_Name.c_str(), m_Ident.c_str()).SetOption(SelectedOption());
}
CheckValid(); CheckValid();
} }

24
Source/Project64-core/N64System/Enhancement/Enhancements.cpp
View File

@ -1,18 +1,19 @@
#include "stdafx.h" #include "stdafx.h"
#include <Project64-core/N64System/Enhancement/Enhancements.h>
#include <Common/Util.h>
#include <Common/path.h>
#include <Project64-core/N64System/Enhancement/EnhancementFile.h> #include <Project64-core/N64System/Enhancement/EnhancementFile.h>
#include <Project64-core/N64System/Enhancement/Enhancements.h>
#include <Project64-core/N64System/Mips/MemoryVirtualMem.h> #include <Project64-core/N64System/Mips/MemoryVirtualMem.h>
#include <Project64-core/N64System/Recompiler/Recompiler.h> #include <Project64-core/N64System/Recompiler/Recompiler.h>
#include <Project64-core/N64System/SystemGlobals.h> #include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/Plugins/Plugin.h>
#include <Project64-core/Plugins/GFXPlugin.h>
#include <Project64-core/Plugins/AudioPlugin.h> #include <Project64-core/Plugins/AudioPlugin.h>
#include <Project64-core/Plugins/RSPPlugin.h>
#include <Project64-core/Plugins/ControllerPlugin.h> #include <Project64-core/Plugins/ControllerPlugin.h>
#include <Common/path.h> #include <Project64-core/Plugins/GFXPlugin.h>
#include <Common/Util.h> #include <Project64-core/Plugins/Plugin.h>
#include <Project64-core/Plugins/RSPPlugin.h>
CEnhancements::GAMESHARK_CODE::GAMESHARK_CODE(const GAMESHARK_CODE&rhs) CEnhancements::GAMESHARK_CODE::GAMESHARK_CODE(const GAMESHARK_CODE & rhs)
{ {
m_Command = rhs.m_Command; m_Command = rhs.m_Command;
m_Value = rhs.m_Value; m_Value = rhs.m_Value;
@ -72,7 +73,8 @@ void CEnhancements::ApplyGSButton(CMipsMemoryVM & MMU, bool /*UpdateChanges*/)
for (size_t CurrentEntry = 0; CurrentEntry < CodeEntry.size(); CurrentEntry++) for (size_t CurrentEntry = 0; CurrentEntry < CodeEntry.size(); CurrentEntry++)
{ {
const GAMESHARK_CODE & Code = CodeEntry[CurrentEntry]; const GAMESHARK_CODE & Code = CodeEntry[CurrentEntry];
switch (Code.Command() & 0xFF000000) { switch (Code.Command() & 0xFF000000)
{
case 0x88000000: case 0x88000000:
ModifyMemory8(MMU, 0x80000000 | (Code.Command() & 0xFFFFFF), (uint8_t)Code.Value(), Code.HasDisableValue(), (uint8_t)Code.DisableValue()); ModifyMemory8(MMU, 0x80000000 | (Code.Command() & 0xFFFFFF), (uint8_t)Code.Value(), Code.HasDisableValue(), (uint8_t)Code.DisableValue());
break; break;
@ -147,7 +149,7 @@ void CEnhancements::UpdateEnhancements(const CEnhancementList & Enhancements)
#endif #endif
CGuard Guard(m_CS); CGuard Guard(m_CS);
if (m_EnhancementFile.get() == nullptr ||strcmp(m_EnhancementFile->FileName(), OutFile) != 0) if (m_EnhancementFile.get() == nullptr || strcmp(m_EnhancementFile->FileName(), OutFile) != 0)
{ {
if (!OutFile.DirectoryExists()) if (!OutFile.DirectoryExists())
{ {
@ -426,7 +428,8 @@ void CEnhancements::ApplyGameSharkCodes(CMipsMemoryVM & MMU, CODES & CodeEntry,
int incr = Code.Value(); int incr = Code.Value();
int i; int i;
switch (NextCodeEntry.Command() & 0xFF000000) { switch (NextCodeEntry.Command() & 0xFF000000)
{
case 0x10000000: // Xplorer64 case 0x10000000: // Xplorer64
case 0x80000000: case 0x80000000:
Address = 0x80000000 | (NextCodeEntry.Command() & 0xFFFFFF); Address = 0x80000000 | (NextCodeEntry.Command() & 0xFFFFFF);
@ -620,7 +623,6 @@ void CEnhancements::ModifyMemory16(CMipsMemoryVM & MMU, uint32_t Address, uint16
} }
} }
void CEnhancements::ScanFileThread(void) void CEnhancements::ScanFileThread(void)
{ {
SectionFiles CheatFiles; SectionFiles CheatFiles;

36
Source/Project64-core/N64System/Interpreter/InterpreterCPU.cpp
View File

@ -1,15 +1,16 @@
#include "stdafx.h" #include "stdafx.h"
#include "InterpreterCPU.h" #include "InterpreterCPU.h"
#include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/N64System/N64System.h>
#include <Project64-core/N64System/Mips/MemoryVirtualMem.h>
#include <Project64-core/N64System/Interpreter/InterpreterOps32.h>
#include <Project64-core/N64System/Mips/R4300iInstruction.h>
#include <Project64-core/Plugins/Plugin.h>
#include <Project64-core/Plugins/GFXPlugin.h>
#include <Project64-core/ExceptionHandler.h>
#include <Project64-core/Debugger.h> #include <Project64-core/Debugger.h>
#include <Project64-core/ExceptionHandler.h>
#include <Project64-core/N64System/Interpreter/InterpreterOps32.h>
#include <Project64-core/N64System/Mips/MemoryVirtualMem.h>
#include <Project64-core/N64System/Mips/R4300iInstruction.h>
#include <Project64-core/N64System/N64System.h>
#include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/Plugins/GFXPlugin.h>
#include <Project64-core/Plugins/Plugin.h>
R4300iOp::Func * CInterpreterCPU::m_R4300i_Opcode = nullptr; R4300iOp::Func * CInterpreterCPU::m_R4300i_Opcode = nullptr;
@ -36,9 +37,9 @@ void CInterpreterCPU::InPermLoop()
{ {
if (EndOnPermLoop() && if (EndOnPermLoop() &&
((g_Reg->STATUS_REGISTER & STATUS_IE) == 0 || ((g_Reg->STATUS_REGISTER & STATUS_IE) == 0 ||
(g_Reg->STATUS_REGISTER & STATUS_EXL) != 0 || (g_Reg->STATUS_REGISTER & STATUS_EXL) != 0 ||
(g_Reg->STATUS_REGISTER & STATUS_ERL) != 0 || (g_Reg->STATUS_REGISTER & STATUS_ERL) != 0 ||
(g_Reg->STATUS_REGISTER & 0xFF00) == 0)) (g_Reg->STATUS_REGISTER & 0xFF00) == 0))
{ {
if (g_Plugins->Gfx()->UpdateScreen != nullptr) if (g_Plugins->Gfx()->UpdateScreen != nullptr)
{ {
@ -117,7 +118,10 @@ void CInterpreterCPU::ExecuteCPU()
_GPR[0].DW = 0; // MIPS $zero hard-wired to 0 _GPR[0].DW = 0; // MIPS $zero hard-wired to 0
NextTimer -= CountPerOp; NextTimer -= CountPerOp;
if (CDebugSettings::HaveDebugger()) { g_Debugger->CPUStepEnded(); } if (CDebugSettings::HaveDebugger())
{
g_Debugger->CPUStepEnded();
}
PROGRAM_COUNTER += 4; PROGRAM_COUNTER += 4;
switch (PipelineStage) switch (PipelineStage)
@ -127,10 +131,10 @@ void CInterpreterCPU::ExecuteCPU()
case PIPELINE_STAGE_DELAY_SLOT: case PIPELINE_STAGE_DELAY_SLOT:
PipelineStage = PIPELINE_STAGE_JUMP; PipelineStage = PIPELINE_STAGE_JUMP;
break; break;
case PIPELINE_STAGE_PERMLOOP_DO_DELAY: case PIPELINE_STAGE_PERMLOOP_DO_DELAY:
PipelineStage = PIPELINE_STAGE_PERMLOOP_DELAY_DONE; PipelineStage = PIPELINE_STAGE_PERMLOOP_DELAY_DONE;
break; break;
case PIPELINE_STAGE_JUMP: case PIPELINE_STAGE_JUMP:
CheckTimer = (JumpToLocation < PROGRAM_COUNTER - 4 || TestTimer); CheckTimer = (JumpToLocation < PROGRAM_COUNTER - 4 || TestTimer);
PROGRAM_COUNTER = JumpToLocation; PROGRAM_COUNTER = JumpToLocation;
PipelineStage = PIPELINE_STAGE_NORMAL; PipelineStage = PIPELINE_STAGE_NORMAL;
@ -172,11 +176,11 @@ void CInterpreterCPU::ExecuteCPU()
void CInterpreterCPU::ExecuteOps(int32_t Cycles) void CInterpreterCPU::ExecuteOps(int32_t Cycles)
{ {
bool & Done = g_System->m_EndEmulation; bool & Done = g_System->m_EndEmulation;
uint32_t & PROGRAM_COUNTER = *_PROGRAM_COUNTER; uint32_t & PROGRAM_COUNTER = *_PROGRAM_COUNTER;
R4300iOpcode & Opcode = R4300iOp::m_Opcode; R4300iOpcode & Opcode = R4300iOp::m_Opcode;
PIPELINE_STAGE & PipelineStage = g_System->m_PipelineStage; PIPELINE_STAGE & PipelineStage = g_System->m_PipelineStage;
uint32_t & JumpToLocation = g_System->m_JumpToLocation; uint32_t & JumpToLocation = g_System->m_JumpToLocation;
bool & TestTimer = R4300iOp::m_TestTimer; bool & TestTimer = R4300iOp::m_TestTimer;
const int32_t & DoSomething = g_SystemEvents->DoSomething(); const int32_t & DoSomething = g_SystemEvents->DoSomething();
uint32_t CountPerOp = g_System->CountPerOp(); uint32_t CountPerOp = g_System->CountPerOp();
bool CheckTimer = false; bool CheckTimer = false;

93
Source/Project64-core/N64System/Interpreter/InterpreterOps.cpp
View File

@ -1,14 +1,15 @@
#include "stdafx.h" #include "stdafx.h"
#include <Project64-core/Debugger.h>
#include <Project64-core/Logging.h>
#include <Project64-core/N64System/Interpreter/InterpreterCPU.h>
#include <Project64-core/N64System/Interpreter/InterpreterOps.h> #include <Project64-core/N64System/Interpreter/InterpreterOps.h>
#include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/N64System/N64System.h>
#include <Project64-core/N64System/Mips/MemoryVirtualMem.h> #include <Project64-core/N64System/Mips/MemoryVirtualMem.h>
#include <Project64-core/N64System/Mips/R4300iInstruction.h>
#include <Project64-core/N64System/Mips/SystemTiming.h> #include <Project64-core/N64System/Mips/SystemTiming.h>
#include <Project64-core/N64System/Mips/TLB.h> #include <Project64-core/N64System/Mips/TLB.h>
#include <Project64-core/N64System/Mips/R4300iInstruction.h> #include <Project64-core/N64System/N64System.h>
#include <Project64-core/N64System/Interpreter/InterpreterCPU.h> #include <Project64-core/N64System/SystemGlobals.h>
#include <Project64-core/Logging.h>
#include <Project64-core/Debugger.h>
#include <float.h> #include <float.h>
#include <math.h> #include <math.h>
@ -39,22 +40,24 @@ R4300iOp::Func R4300iOp::Jump_CoP1_D[64];
R4300iOp::Func R4300iOp::Jump_CoP1_W[64]; R4300iOp::Func R4300iOp::Jump_CoP1_W[64];
R4300iOp::Func R4300iOp::Jump_CoP1_L[64]; R4300iOp::Func R4300iOp::Jump_CoP1_L[64];
const uint32_t R4300iOp::SWL_MASK[4] = { 0x00000000, 0xFF000000, 0xFFFF0000, 0xFFFFFF00 }; const uint32_t R4300iOp::SWL_MASK[4] = {0x00000000, 0xFF000000, 0xFFFF0000, 0xFFFFFF00};
const uint32_t R4300iOp::SWR_MASK[4] = { 0x00FFFFFF, 0x0000FFFF, 0x000000FF, 0x00000000 }; const uint32_t R4300iOp::SWR_MASK[4] = {0x00FFFFFF, 0x0000FFFF, 0x000000FF, 0x00000000};
const uint32_t R4300iOp::LWL_MASK[4] = { 0x00000000, 0x000000FF, 0x0000FFFF, 0x00FFFFFF }; const uint32_t R4300iOp::LWL_MASK[4] = {0x00000000, 0x000000FF, 0x0000FFFF, 0x00FFFFFF};
const uint32_t R4300iOp::LWR_MASK[4] = { 0xFFFFFF00, 0xFFFF0000, 0xFF000000, 0x0000000 }; const uint32_t R4300iOp::LWR_MASK[4] = {0xFFFFFF00, 0xFFFF0000, 0xFF000000, 0x0000000};
const int32_t R4300iOp::SWL_SHIFT[4] = { 0, 8, 16, 24 }; const int32_t R4300iOp::SWL_SHIFT[4] = {0, 8, 16, 24};
const int32_t R4300iOp::SWR_SHIFT[4] = { 24, 16, 8, 0 }; const int32_t R4300iOp::SWR_SHIFT[4] = {24, 16, 8, 0};
const int32_t R4300iOp::LWL_SHIFT[4] = { 0, 8, 16, 24 }; const int32_t R4300iOp::LWL_SHIFT[4] = {0, 8, 16, 24};
const int32_t R4300iOp::LWR_SHIFT[4] = { 24, 16, 8, 0 }; const int32_t R4300iOp::LWR_SHIFT[4] = {24, 16, 8, 0};
#define TEST_COP1_USABLE_EXCEPTION() \ #define TEST_COP1_USABLE_EXCEPTION() \
if ((g_Reg->STATUS_REGISTER & STATUS_CU1) == 0) {\ if ((g_Reg->STATUS_REGISTER & STATUS_CU1) == 0) \
g_Reg->DoCopUnusableException(g_System->m_PipelineStage == PIPELINE_STAGE_JUMP,1);\ { \
g_System->m_PipelineStage = PIPELINE_STAGE_JUMP;\ g_Reg->DoCopUnusableException(g_System->m_PipelineStage == PIPELINE_STAGE_JUMP, 1); \
g_System->m_JumpToLocation = (*_PROGRAM_COUNTER);\ g_System->m_PipelineStage = PIPELINE_STAGE_JUMP; \
return;}\ g_System->m_JumpToLocation = (*_PROGRAM_COUNTER); \
return; \
}
void R4300iOp::SPECIAL() void R4300iOp::SPECIAL()
{ {
@ -996,7 +999,6 @@ void R4300iOp::DADDI()
return; return;
} }
_GPR[m_Opcode.rt].DW = sum; _GPR[m_Opcode.rt].DW = sum;
} }
void R4300iOp::DADDIU() void R4300iOp::DADDIU()
@ -1004,8 +1006,8 @@ void R4300iOp::DADDIU()
_GPR[m_Opcode.rt].DW = _GPR[m_Opcode.rs].DW + (int64_t)((int16_t)m_Opcode.immediate); _GPR[m_Opcode.rt].DW = _GPR[m_Opcode.rs].DW + (int64_t)((int16_t)m_Opcode.immediate);
} }
uint64_t LDL_MASK[8] = { 0, 0xFF, 0xFFFF, 0xFFFFFF, 0xFFFFFFFF, 0xFFFFFFFFFF, 0xFFFFFFFFFFFF, 0xFFFFFFFFFFFFFF }; uint64_t LDL_MASK[8] = {0, 0xFF, 0xFFFF, 0xFFFFFF, 0xFFFFFFFF, 0xFFFFFFFFFF, 0xFFFFFFFFFFFF, 0xFFFFFFFFFFFFFF};
int32_t LDL_SHIFT[8] = { 0, 8, 16, 24, 32, 40, 48, 56 }; int32_t LDL_SHIFT[8] = {0, 8, 16, 24, 32, 40, 48, 56};
void R4300iOp::LDL() void R4300iOp::LDL()
{ {
@ -1019,11 +1021,11 @@ void R4300iOp::LDL()
} }
} }
uint64_t LDR_MASK[8] = { 0xFFFFFFFFFFFFFF00, 0xFFFFFFFFFFFF0000, uint64_t LDR_MASK[8] = {0xFFFFFFFFFFFFFF00, 0xFFFFFFFFFFFF0000,
0xFFFFFFFFFF000000, 0xFFFFFFFF00000000, 0xFFFFFFFFFF000000, 0xFFFFFFFF00000000,
0xFFFFFF0000000000, 0xFFFF000000000000, 0xFFFFFF0000000000, 0xFFFF000000000000,
0xFF00000000000000, 0 }; 0xFF00000000000000, 0};
int32_t LDR_SHIFT[8] = { 56, 48, 40, 32, 24, 16, 8, 0 }; int32_t LDR_SHIFT[8] = {56, 48, 40, 32, 24, 16, 8, 0};
void R4300iOp::LDR() void R4300iOp::LDR()
{ {
@ -1161,15 +1163,15 @@ void R4300iOp::SW()
g_MMU->SW_Memory(Address, _GPR[m_Opcode.rt].UW[0]); g_MMU->SW_Memory(Address, _GPR[m_Opcode.rt].UW[0]);
} }
uint64_t SDL_MASK[8] = { 0, 0xFF00000000000000, uint64_t SDL_MASK[8] = {0, 0xFF00000000000000,
0xFFFF000000000000, 0xFFFF000000000000,
0xFFFFFF0000000000, 0xFFFFFF0000000000,
0xFFFFFFFF00000000, 0xFFFFFFFF00000000,
0xFFFFFFFFFF000000, 0xFFFFFFFFFF000000,
0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFF0000,
0xFFFFFFFFFFFFFF00 }; 0xFFFFFFFFFFFFFF00};
int32_t SDL_SHIFT[8] = { 0, 8, 16, 24, 32, 40, 48, 56 }; int32_t SDL_SHIFT[8] = {0, 8, 16, 24, 32, 40, 48, 56};
void R4300iOp::SDL() void R4300iOp::SDL()
{ {
@ -1188,16 +1190,16 @@ void R4300iOp::SDL()
} }
} }
uint64_t SDR_MASK[8] = { 0x00FFFFFFFFFFFFFF, uint64_t SDR_MASK[8] = {0x00FFFFFFFFFFFFFF,
0x0000FFFFFFFFFFFF, 0x0000FFFFFFFFFFFF,
0x000000FFFFFFFFFF, 0x000000FFFFFFFFFF,
0x00000000FFFFFFFF, 0x00000000FFFFFFFF,
0x0000000000FFFFFF, 0x0000000000FFFFFF,
0x000000000000FFFF, 0x000000000000FFFF,
0x00000000000000FF, 0x00000000000000FF,
0x0000000000000000 }; 0x0000000000000000};
int32_t SDR_SHIFT[8] = { 56, 48, 40, 32, 24, 16, 8, 0 }; int32_t SDR_SHIFT[8] = {56, 48, 40, 32, 24, 16, 8, 0};
void R4300iOp::SDR() void R4300iOp::SDR()
{ {
@ -1232,7 +1234,6 @@ void R4300iOp::SWR()
{ {
GenerateTLBWriteException(Address, __FUNCTION__); GenerateTLBWriteException(Address, __FUNCTION__);
} }
} }
void R4300iOp::CACHE() void R4300iOp::CACHE()

134
Source/Project64-core/Settings.cpp
View File

@ -1,27 +1,27 @@
#include "stdafx.h" #include "stdafx.h"
#include <Common/Platform.h>
#include "Settings/SettingType/SettingsType-Application.h" #include "Settings/SettingType/SettingsType-Application.h"
#include "Settings/SettingType/SettingsType-ApplicationPath.h"
#include "Settings/SettingType/SettingsType-ApplicationIndex.h" #include "Settings/SettingType/SettingsType-ApplicationIndex.h"
#include "Settings/SettingType/SettingsType-ApplicationPath.h"
#include "Settings/SettingType/SettingsType-GameSetting.h" #include "Settings/SettingType/SettingsType-GameSetting.h"
#include "Settings/SettingType/SettingsType-GameSettingIndex.h" #include "Settings/SettingType/SettingsType-GameSettingIndex.h"
#include "Settings/SettingType/SettingsType-RelativePath.h"
#include "Settings/SettingType/SettingsType-RomDatabase.h"
#include "Settings/SettingType/SettingsType-RomDatabaseSetting.h"
#include "Settings/SettingType/SettingsType-RomDatabaseIndex.h"
#include "Settings/SettingType/SettingsType-RDBCpuType.h" #include "Settings/SettingType/SettingsType-RDBCpuType.h"
#include "Settings/SettingType/SettingsType-RDBOnOff.h"
#include "Settings/SettingType/SettingsType-RDBRamSize.h" #include "Settings/SettingType/SettingsType-RDBRamSize.h"
#include "Settings/SettingType/SettingsType-RDBSaveChip.h" #include "Settings/SettingType/SettingsType-RDBSaveChip.h"
#include "Settings/SettingType/SettingsType-RDBYesNo.h" #include "Settings/SettingType/SettingsType-RDBYesNo.h"
#include "Settings/SettingType/SettingsType-RDBOnOff.h" #include "Settings/SettingType/SettingsType-RelativePath.h"
#include "Settings/SettingType/SettingsType-RomDatabase.h"
#include "Settings/SettingType/SettingsType-RomDatabaseIndex.h"
#include "Settings/SettingType/SettingsType-RomDatabaseSetting.h"
#include "Settings/SettingType/SettingsType-SelectedDirectory.h" #include "Settings/SettingType/SettingsType-SelectedDirectory.h"
#include "Settings/SettingType/SettingsType-TempString.h"
#include "Settings/SettingType/SettingsType-TempNumber.h"
#include "Settings/SettingType/SettingsType-TempBool.h" #include "Settings/SettingType/SettingsType-TempBool.h"
#include <Project64-core/Settings.h> #include "Settings/SettingType/SettingsType-TempNumber.h"
#include <Project64-core/N64System/N64Types.h> #include "Settings/SettingType/SettingsType-TempString.h"
#include <Common/Platform.h>
#include <Common/Trace.h> #include <Common/Trace.h>
#include <Project64-core/N64System/N64Types.h>
#include <Project64-core/Settings.h>
CSettings * g_Settings = nullptr; CSettings * g_Settings = nullptr;
@ -95,53 +95,53 @@ void CSettings::AddHowToHandleSetting(const char * BaseDirectory)
AddHandler(SupportFile_EnhancementDirDefault, new CSettingTypeRelativePath("Config\\Enhancements", "")); AddHandler(SupportFile_EnhancementDirDefault, new CSettingTypeRelativePath("Config\\Enhancements", ""));
AddHandler(SupportFile_UserEnhancementDir, new CSettingTypeApplicationPath("Settings", "UserEnhancementDir", SupportFile_UserEnhancementDirDefault)); AddHandler(SupportFile_UserEnhancementDir, new CSettingTypeApplicationPath("Settings", "UserEnhancementDir", SupportFile_UserEnhancementDirDefault));
AddHandler(SupportFile_UserEnhancementDirDefault, new CSettingTypeRelativePath("Config\\Enhancements-User", "")); AddHandler(SupportFile_UserEnhancementDirDefault, new CSettingTypeRelativePath("Config\\Enhancements-User", ""));
AddHandler(SupportFile_Notes, new CSettingTypeApplicationPath("Settings", "Notes", SupportFile_NotesDefault)); AddHandler(SupportFile_Notes, new CSettingTypeApplicationPath("Settings", "Notes", SupportFile_NotesDefault));
AddHandler(SupportFile_NotesDefault, new CSettingTypeRelativePath("Config", "Project64.rdn")); AddHandler(SupportFile_NotesDefault, new CSettingTypeRelativePath("Config", "Project64.rdn"));
AddHandler(SupportFile_ExtInfo, new CSettingTypeApplicationPath("Settings", "ExtInfo", SupportFile_ExtInfoDefault)); AddHandler(SupportFile_ExtInfo, new CSettingTypeApplicationPath("Settings", "ExtInfo", SupportFile_ExtInfoDefault));
AddHandler(SupportFile_ExtInfoDefault, new CSettingTypeRelativePath("Config", "Project64.rdx")); AddHandler(SupportFile_ExtInfoDefault, new CSettingTypeRelativePath("Config", "Project64.rdx"));
// Settings location // Settings location
AddHandler(Setting_ApplicationName, new CSettingTypeTempString("")); AddHandler(Setting_ApplicationName, new CSettingTypeTempString(""));
AddHandler(Setting_UseFromRegistry, new CSettingTypeApplication("Settings", "Use Registry", (uint32_t)false)); AddHandler(Setting_UseFromRegistry, new CSettingTypeApplication("Settings", "Use Registry", (uint32_t) false));
AddHandler(Setting_RdbEditor, new CSettingTypeApplication("Settings", "Rdb Editor", false)); AddHandler(Setting_RdbEditor, new CSettingTypeApplication("Settings", "Rdb Editor", false));
AddHandler(Setting_CN64TimeCritical, new CSettingTypeApplication("Settings", "CN64TimeCritical", false)); AddHandler(Setting_CN64TimeCritical, new CSettingTypeApplication("Settings", "CN64TimeCritical", false));
AddHandler(Setting_AutoStart, new CSettingTypeApplication("Settings", "Auto Start", (uint32_t)true)); AddHandler(Setting_AutoStart, new CSettingTypeApplication("Settings", "Auto Start", (uint32_t) true));
AddHandler(Setting_AutoZipInstantSave, new CSettingTypeApplication("Settings", "Auto Zip Saves", (uint32_t)true)); AddHandler(Setting_AutoZipInstantSave, new CSettingTypeApplication("Settings", "Auto Zip Saves", (uint32_t) true));
AddHandler(Setting_EraseGameDefaults, new CSettingTypeApplication("Settings", "Erase on default", (uint32_t)true)); AddHandler(Setting_EraseGameDefaults, new CSettingTypeApplication("Settings", "Erase on default", (uint32_t) true));
AddHandler(Setting_CheckEmuRunning, new CSettingTypeApplication("Settings", "Check Running", (uint32_t)true)); AddHandler(Setting_CheckEmuRunning, new CSettingTypeApplication("Settings", "Check Running", (uint32_t) true));
#ifndef _M_X64 #ifndef _M_X64
AddHandler(Setting_ForceInterpreterCPU, new CSettingTypeApplication("Settings", "Force Interpreter CPU", false)); AddHandler(Setting_ForceInterpreterCPU, new CSettingTypeApplication("Settings", "Force Interpreter CPU", false));
#else #else
AddHandler(Setting_ForceInterpreterCPU, new CSettingTypeApplication("Settings", "Force Interpreter CPU", true)); AddHandler(Setting_ForceInterpreterCPU, new CSettingTypeApplication("Settings", "Force Interpreter CPU", true));
#endif #endif
AddHandler(Setting_FixedRdramAddress, new CSettingTypeApplication("Settings", "Fixed Rdram Address", (uint32_t)0)); AddHandler(Setting_FixedRdramAddress, new CSettingTypeApplication("Settings", "Fixed Rdram Address", (uint32_t)0));
AddHandler(Setting_Enhancement, new CSettingTypeApplication("Settings", "Enable Enhancement", (uint32_t)true)); AddHandler(Setting_Enhancement, new CSettingTypeApplication("Settings", "Enable Enhancement", (uint32_t) true));
AddHandler(Setting_RememberCheats, new CSettingTypeApplication("Settings", "Remember Cheats", (bool)false)); AddHandler(Setting_RememberCheats, new CSettingTypeApplication("Settings", "Remember Cheats", (bool)false));
AddHandler(Setting_UniqueSaveDir, new CSettingTypeApplication("Settings", "Unique Game Dir", true)); AddHandler(Setting_UniqueSaveDir, new CSettingTypeApplication("Settings", "Unique Game Dir", true));
AddHandler(Setting_CurrentLanguage, new CSettingTypeApplication("Settings", "Current Language", "")); AddHandler(Setting_CurrentLanguage, new CSettingTypeApplication("Settings", "Current Language", ""));
AddHandler(Setting_EnableDisk, new CSettingTypeTempBool(false)); AddHandler(Setting_EnableDisk, new CSettingTypeTempBool(false));
AddHandler(Setting_LanguageDirDefault, new CSettingTypeRelativePath("Lang", "")); AddHandler(Setting_LanguageDirDefault, new CSettingTypeRelativePath("Lang", ""));
AddHandler(Setting_LanguageDir, new CSettingTypeApplicationPath("Lang Directory", "Directory", Setting_LanguageDirDefault)); AddHandler(Setting_LanguageDir, new CSettingTypeApplicationPath("Lang Directory", "Directory", Setting_LanguageDirDefault));
AddHandler(Setting_SyncViaAudioEnabled, new CSettingTypeTempBool(false, "SyncViaAudioEnabled")); AddHandler(Setting_SyncViaAudioEnabled, new CSettingTypeTempBool(false, "SyncViaAudioEnabled"));
AddHandler(Setting_DiskSaveType, new CSettingTypeApplication("Settings", "Disk Save Type", (uint32_t)1)); AddHandler(Setting_DiskSaveType, new CSettingTypeApplication("Settings", "Disk Save Type", (uint32_t)1));
AddHandler(Setting_UpdateControllerOnRefresh, new CSettingTypeTempBool(false)); AddHandler(Setting_UpdateControllerOnRefresh, new CSettingTypeTempBool(false));
AddHandler(Default_RDRamSize, new CSettingTypeApplication("Defaults", "RDRAM Size", 0x800000u)); AddHandler(Default_RDRamSize, new CSettingTypeApplication("Defaults", "RDRAM Size", 0x800000u));
AddHandler(Default_UseHleGfx, new CSettingTypeApplication("Defaults", "HLE GFX Default", true)); AddHandler(Default_UseHleGfx, new CSettingTypeApplication("Defaults", "HLE GFX Default", true));
AddHandler(Default_ViRefreshRate, new CSettingTypeApplication("Defaults", "ViRefresh", 1500u)); AddHandler(Default_ViRefreshRate, new CSettingTypeApplication("Defaults", "ViRefresh", 1500u));
AddHandler(Default_AiCountPerBytes, new CSettingTypeApplication("Defaults", "AiCountPerBytes", 0u)); AddHandler(Default_AiCountPerBytes, new CSettingTypeApplication("Defaults", "AiCountPerBytes", 0u));
AddHandler(Default_CounterFactor, new CSettingTypeApplication("Defaults", "Counter Factor", 2u)); AddHandler(Default_CounterFactor, new CSettingTypeApplication("Defaults", "Counter Factor", 2u));
AddHandler(Default_32Bit, new CSettingTypeApplication("Defaults", "32bit", false)); AddHandler(Default_32Bit, new CSettingTypeApplication("Defaults", "32bit", false));
AddHandler(Default_SyncViaAudio, new CSettingTypeApplication("Defaults", "Audio-Sync Audio", true)); AddHandler(Default_SyncViaAudio, new CSettingTypeApplication("Defaults", "Audio-Sync Audio", true));
AddHandler(Default_FixedAudio, new CSettingTypeApplication("Defaults", "Fixed Audio", true)); AddHandler(Default_FixedAudio, new CSettingTypeApplication("Defaults", "Fixed Audio", true));
AddHandler(Default_UnalignedDMA, new CSettingTypeApplication("Defaults", "Unaligned DMA", false)); AddHandler(Default_UnalignedDMA, new CSettingTypeApplication("Defaults", "Unaligned DMA", false));
AddHandler(Default_RandomizeSIPIInterrupts, new CSettingTypeApplication("Defaults", "Randomize SI/PI Interrupts", true)); AddHandler(Default_RandomizeSIPIInterrupts, new CSettingTypeApplication("Defaults", "Randomize SI/PI Interrupts", true));
AddHandler(Default_SMM_Protect_Memory, new CSettingTypeApplication("Defaults", "SMM-Protect", false)); AddHandler(Default_SMM_Protect_Memory, new CSettingTypeApplication("Defaults", "SMM-Protect", false));
AddHandler(Default_DiskSeekTiming, new CSettingTypeApplication("Defaults", "Disk Seek Timing", (uint32_t)DiskSeek_Turbo)); AddHandler(Default_DiskSeekTiming, new CSettingTypeApplication("Defaults", "Disk Seek Timing", (uint32_t)DiskSeek_Turbo));
AddHandler(Rdb_GoodName, new CSettingTypeRomDatabase("Good Name", Game_GameName)); AddHandler(Rdb_GoodName, new CSettingTypeRomDatabase("Good Name", Game_GameName));
AddHandler(Rdb_RPCKey, new CSettingTypeRomDatabase("RPC Key", Game_RPCKey)); AddHandler(Rdb_RPCKey, new CSettingTypeRomDatabase("RPC Key", Game_RPCKey));
AddHandler(Rdb_SaveChip, new CSettingTypeRDBSaveChip("Save Type", (uint32_t)SaveChip_Auto)); AddHandler(Rdb_SaveChip, new CSettingTypeRDBSaveChip("Save Type", (uint32_t)SaveChip_Auto));
AddHandler(Rdb_CpuType, new CSettingTypeRDBCpuType("CPU Type", CPU_Recompiler)); AddHandler(Rdb_CpuType, new CSettingTypeRDBCpuType("CPU Type", CPU_Recompiler));
AddHandler(Rdb_RDRamSize, new CSettingTypeRDBRDRamSize("RDRAM Size", Default_RDRamSize)); AddHandler(Rdb_RDRamSize, new CSettingTypeRDBRDRamSize("RDRAM Size", Default_RDRamSize));
@ -164,9 +164,9 @@ void CSettings::AddHowToHandleSetting(const char * BaseDirectory)
#ifdef ANDROID #ifdef ANDROID
AddHandler(Rdb_BlockLinking, new CSettingTypeRDBOnOff("Linking", false)); AddHandler(Rdb_BlockLinking, new CSettingTypeRDBOnOff("Linking", false));
#else #else
AddHandler(Rdb_BlockLinking, new CSettingTypeRDBOnOff("Linking", true)); AddHandler(Rdb_BlockLinking, new CSettingTypeRDBOnOff("Linking", true));
#endif #endif
AddHandler(Rdb_SMM_Cache, new CSettingTypeRomDatabase("SMM-Cache", true)); AddHandler(Rdb_SMM_Cache, new CSettingTypeRomDatabase("SMM-Cache", true));
AddHandler(Rdb_SMM_StoreInstruc, new CSettingTypeRomDatabase("SMM-StoreInstr", false)); AddHandler(Rdb_SMM_StoreInstruc, new CSettingTypeRomDatabase("SMM-StoreInstr", false));
AddHandler(Rdb_SMM_PIDMA, new CSettingTypeRomDatabase("SMM-PI DMA", true)); AddHandler(Rdb_SMM_PIDMA, new CSettingTypeRomDatabase("SMM-PI DMA", true));
AddHandler(Rdb_SMM_TLB, new CSettingTypeRomDatabase("SMM-TLB", true)); AddHandler(Rdb_SMM_TLB, new CSettingTypeRomDatabase("SMM-TLB", true));
@ -238,12 +238,12 @@ void CSettings::AddHowToHandleSetting(const char * BaseDirectory)
AddHandler(Game_FullSpeed, new CSettingTypeTempBool(true, "Full Speed")); AddHandler(Game_FullSpeed, new CSettingTypeTempBool(true, "Full Speed"));
AddHandler(Game_UnalignedDMA, new CSettingTypeGame("Unaligned DMA", Rdb_UnalignedDMA)); AddHandler(Game_UnalignedDMA, new CSettingTypeGame("Unaligned DMA", Rdb_UnalignedDMA));
AddHandler(Game_RandomizeSIPIInterrupts, new CSettingTypeGame("Randomize SI/PI Interrupts", Rdb_RandomizeSIPIInterrupts)); AddHandler(Game_RandomizeSIPIInterrupts, new CSettingTypeGame("Randomize SI/PI Interrupts", Rdb_RandomizeSIPIInterrupts));
AddHandler(Game_RPCKey, new CSettingTypeTempString("")); AddHandler(Game_RPCKey, new CSettingTypeTempString(""));
AddHandler(Game_DiskSeekTiming, new CSettingTypeGame("DiskSeekTiming", Rdb_DiskSeekTiming)); AddHandler(Game_DiskSeekTiming, new CSettingTypeGame("DiskSeekTiming", Rdb_DiskSeekTiming));
// User interface // User interface
AddHandler(UserInterface_ShowCPUPer, new CSettingTypeApplication("Settings", "Display CPU Usage", (uint32_t)false)); AddHandler(UserInterface_ShowCPUPer, new CSettingTypeApplication("Settings", "Display CPU Usage", (uint32_t) false));
AddHandler(UserInterface_DisplayFrameRate, new CSettingTypeApplication("Settings", "Display Frame Rate", (uint32_t)false)); AddHandler(UserInterface_DisplayFrameRate, new CSettingTypeApplication("Settings", "Display Frame Rate", (uint32_t) false));
AddHandler(UserInterface_FrameDisplayType, new CSettingTypeApplication("Settings", "Frame Rate Display Type", (uint32_t)FR_VIs)); AddHandler(UserInterface_FrameDisplayType, new CSettingTypeApplication("Settings", "Frame Rate Display Type", (uint32_t)FR_VIs));
AddHandler(Directory_Plugin, new CSettingTypeSelectedDirectory("Dir:Plugin", Directory_PluginInitial, Directory_PluginSelected, Directory_PluginUseSelected, Directory_Plugin)); AddHandler(Directory_Plugin, new CSettingTypeSelectedDirectory("Dir:Plugin", Directory_PluginInitial, Directory_PluginSelected, Directory_PluginUseSelected, Directory_Plugin));
#ifndef _M_X64 #ifndef _M_X64
@ -313,7 +313,7 @@ void CSettings::AddHowToHandleSetting(const char * BaseDirectory)
AddHandler(GameRunning_ScreenHertz, new CSettingTypeTempNumber(60)); AddHandler(GameRunning_ScreenHertz, new CSettingTypeTempNumber(60));
AddHandler(GameRunning_InReset, new CSettingTypeTempBool(false)); AddHandler(GameRunning_InReset, new CSettingTypeTempBool(false));
AddHandler(UserInterface_BasicMode, new CSettingTypeApplication("Settings", "Basic Mode", (uint32_t)true)); AddHandler(UserInterface_BasicMode, new CSettingTypeApplication("Settings", "Basic Mode", (uint32_t) true));
AddHandler(File_DiskIPLPath, new CSettingTypeApplicationPath("Settings", "Disk IPL ROM Path", Default_None)); AddHandler(File_DiskIPLPath, new CSettingTypeApplicationPath("Settings", "Disk IPL ROM Path", Default_None));
AddHandler(File_DiskIPLUSAPath, new CSettingTypeApplicationPath("Settings", "Disk IPL USA ROM Path", Default_None)); AddHandler(File_DiskIPLUSAPath, new CSettingTypeApplicationPath("Settings", "Disk IPL USA ROM Path", Default_None));
AddHandler(File_DiskIPLTOOLPath, new CSettingTypeApplicationPath("Settings", "Disk IPL TOOL ROM Path", Default_None)); AddHandler(File_DiskIPLTOOLPath, new CSettingTypeApplicationPath("Settings", "Disk IPL TOOL ROM Path", Default_None));
@ -342,7 +342,7 @@ void CSettings::AddHowToHandleSetting(const char * BaseDirectory)
AddHandler(Debugger_IntrBreakpoints, new CSettingTypeApplication("Debugger", "Interrupt Breakpoints", (uint32_t)0)); AddHandler(Debugger_IntrBreakpoints, new CSettingTypeApplication("Debugger", "Interrupt Breakpoints", (uint32_t)0));
AddHandler(Debugger_RcpIntrBreakpoints, new CSettingTypeApplication("Debugger", "RCP Interrupt Breakpoints", (uint32_t)0)); AddHandler(Debugger_RcpIntrBreakpoints, new CSettingTypeApplication("Debugger", "RCP Interrupt Breakpoints", (uint32_t)0));
AddHandler(Debugger_DebugLanguage, new CSettingTypeApplication("Debugger", "Debug Language", false)); AddHandler(Debugger_DebugLanguage, new CSettingTypeApplication("Debugger", "Debug Language", false));
AddHandler(Debugger_AppLogFlush, new CSettingTypeApplication("Logging", "Log Auto Flush", (uint32_t)false)); AddHandler(Debugger_AppLogFlush, new CSettingTypeApplication("Logging", "Log Auto Flush", (uint32_t) false));
AddHandler(Debugger_RecordRecompilerAsm, new CSettingTypeApplication("Debugger", "Record Recompiler Asm", false)); AddHandler(Debugger_RecordRecompilerAsm, new CSettingTypeApplication("Debugger", "Record Recompiler Asm", false));
AddHandler(Debugger_AutorunScripts, new CSettingTypeApplication("Debugger", "Autorun Scripts", "")); AddHandler(Debugger_AutorunScripts, new CSettingTypeApplication("Debugger", "Autorun Scripts", ""));
@ -375,8 +375,8 @@ void CSettings::AddHowToHandleSetting(const char * BaseDirectory)
AddHandler(Plugin_RSP_Current, new CSettingTypeApplication("Plugin", "RSP Dll", "RSP\\RSP 1.7.dll")); AddHandler(Plugin_RSP_Current, new CSettingTypeApplication("Plugin", "RSP Dll", "RSP\\RSP 1.7.dll"));
#ifdef _DEBUG #ifdef _DEBUG
AddHandler(Plugin_GFX_Default, new CSettingTypeApplication("Plugin", "Graphics Dll Default", "GFX\\Project64-Video_d.dll")); AddHandler(Plugin_GFX_Default, new CSettingTypeApplication("Plugin", "Graphics Dll Default", "GFX\\Project64-Video_d.dll"));
AddHandler(Plugin_GFX_Current, new CSettingTypeApplication("Plugin", "Graphics Dll", Plugin_GFX_Default)); AddHandler(Plugin_GFX_Current, new CSettingTypeApplication("Plugin", "Graphics Dll", Plugin_GFX_Default));
AddHandler(Plugin_AUDIO_Current, new CSettingTypeApplication("Plugin", "Audio Dll", "Audio\\Project64-Audio_d.dll")); AddHandler(Plugin_AUDIO_Current, new CSettingTypeApplication("Plugin", "Audio Dll", "Audio\\Project64-Audio_d.dll"));
AddHandler(Plugin_CONT_Current, new CSettingTypeApplication("Plugin", "Controller Dll", "Input\\Project64-Input_d.dll")); AddHandler(Plugin_CONT_Current, new CSettingTypeApplication("Plugin", "Controller Dll", "Input\\Project64-Input_d.dll"));
#else #else
AddHandler(Plugin_GFX_Default, new CSettingTypeApplication("Plugin", "Graphics Dll Default", "GFX\\Project64-Video.dll")); AddHandler(Plugin_GFX_Default, new CSettingTypeApplication("Plugin", "Graphics Dll Default", "GFX\\Project64-Video.dll"));
@ -395,7 +395,7 @@ void CSettings::AddHowToHandleSetting(const char * BaseDirectory)
AddHandler(Plugin_AUDIO_CurVer, new CSettingTypeApplication("Plugin", "Audio Dll Ver", "")); AddHandler(Plugin_AUDIO_CurVer, new CSettingTypeApplication("Plugin", "Audio Dll Ver", ""));
AddHandler(Plugin_CONT_CurVer, new CSettingTypeApplication("Plugin", "Controller Dll Ver", "")); AddHandler(Plugin_CONT_CurVer, new CSettingTypeApplication("Plugin", "Controller Dll Ver", ""));
AddHandler(Plugin_UseHleGfx, new CSettingTypeApplication("RSP", "HLE GFX Plugin", Default_UseHleGfx)); AddHandler(Plugin_UseHleGfx, new CSettingTypeApplication("RSP", "HLE GFX Plugin", Default_UseHleGfx));
AddHandler(Plugin_UseHleAudio, new CSettingTypeApplication("RSP", "HLE Audio Plugin", false)); AddHandler(Plugin_UseHleAudio, new CSettingTypeApplication("RSP", "HLE Audio Plugin", false));
AddHandler(Plugin_EnableAudio, new CSettingTypeApplication("Audio", "Enable Audio", true)); AddHandler(Plugin_EnableAudio, new CSettingTypeApplication("Audio", "Enable Audio", true));
@ -426,12 +426,12 @@ void CSettings::AddHowToHandleSetting(const char * BaseDirectory)
AddHandler(Logging_LogRomHeader, new CSettingTypeApplication("Logging", "Generate Log Files", false)); AddHandler(Logging_LogRomHeader, new CSettingTypeApplication("Logging", "Generate Log Files", false));
AddHandler(Logging_LogUnknown, new CSettingTypeApplication("Logging", "Log Rom Header", false)); AddHandler(Logging_LogUnknown, new CSettingTypeApplication("Logging", "Log Rom Header", false));
WriteTrace(TraceAppInit, TraceDebug, "Done"); WriteTrace(TraceAppInit, TraceDebug, "Done");
} }
uint32_t CSettings::FindSetting(CSettings * _this, const char * Name) uint32_t CSettings::FindSetting(CSettings * _this, const char * Name)
{ {
uint32_t setting_id = 0; uint32_t setting_id = 0;
for (SETTING_MAP::iterator iter = _this->m_SettingInfo.begin(); iter != _this->m_SettingInfo.end(); iter++) for (SETTING_MAP::iterator iter = _this->m_SettingInfo.begin(); iter != _this->m_SettingInfo.end(); iter++)
{ {
CSettingType * Setting = iter->second; CSettingType * Setting = iter->second;
@ -442,11 +442,11 @@ uint32_t CSettings::FindSetting(CSettings * _this, const char * Name)
{ {
continue; continue;
} }
if (setting_id != 0) if (setting_id != 0)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
} }
setting_id = iter->first; setting_id = iter->first;
} }
else if (Setting->GetSettingType() == SettingType_CfgFile) else if (Setting->GetSettingType() == SettingType_CfgFile)
{ {
@ -455,11 +455,11 @@ uint32_t CSettings::FindSetting(CSettings * _this, const char * Name)
{ {
continue; continue;
} }
if (setting_id != 0) if (setting_id != 0)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
} }
setting_id = iter->first; setting_id = iter->first;
} }
else if (Setting->GetSettingType() == SettingType_SelectedDirectory) else if (Setting->GetSettingType() == SettingType_SelectedDirectory)
{ {
@ -468,11 +468,11 @@ uint32_t CSettings::FindSetting(CSettings * _this, const char * Name)
{ {
continue; continue;
} }
if (setting_id != 0) if (setting_id != 0)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
} }
setting_id = iter->first; setting_id = iter->first;
} }
else if (Setting->GetSettingType() == SettingType_BoolVariable) else if (Setting->GetSettingType() == SettingType_BoolVariable)
{ {
@ -481,11 +481,11 @@ uint32_t CSettings::FindSetting(CSettings * _this, const char * Name)
{ {
continue; continue;
} }
if (setting_id != 0) if (setting_id != 0)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
} }
setting_id = iter->first; setting_id = iter->first;
} }
} }
return setting_id; return setting_id;
@ -532,8 +532,8 @@ void CSettings::SetSettingSz(CSettings * _this, SettingID ID, const char * Value
} }
void CSettings::RegisterSetting(CSettings * _this, SettingID ID, SettingID DefaultID, SettingDataType DataType, void CSettings::RegisterSetting(CSettings * _this, SettingID ID, SettingID DefaultID, SettingDataType DataType,
SettingType Type, const char * Category, const char * DefaultStr, SettingType Type, const char * Category, const char * DefaultStr,
uint32_t Value) uint32_t Value)
{ {
SettingID RdbSetting; SettingID RdbSetting;
stdstr Name; stdstr Name;
@ -921,7 +921,7 @@ void CSettings::LoadDefaultBoolIndex(SettingID /*Type*/, uint32_t /*index*/, boo
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
} }
uint32_t CSettings::LoadDefaultDword(SettingID Type) uint32_t CSettings::LoadDefaultDword(SettingID Type)
{ {
uint32_t Value = 0; uint32_t Value = 0;
LoadDefaultDword(Type, Value); LoadDefaultDword(Type, Value);

31
Source/Project64-core/Settings/SettingType/SettingsType-RDBCpuType.h
View File

@ -1,34 +1,35 @@
#pragma once #pragma once
#include <Project64-core\Settings\SettingType\SettingsType-RomDatabase.h>
class CSettingTypeRDBCpuType : class CSettingTypeRDBCpuType :
public CSettingTypeRomDatabase public CSettingTypeRomDatabase
{ {
public: public:
CSettingTypeRDBCpuType(const char * Name, SettingID DefaultSetting ); CSettingTypeRDBCpuType(const char * Name, SettingID DefaultSetting);
CSettingTypeRDBCpuType(const char * Name, uint32_t DefaultValue ); CSettingTypeRDBCpuType(const char * Name, uint32_t DefaultValue);
~CSettingTypeRDBCpuType(); ~CSettingTypeRDBCpuType();
// Return the values // Return the values
virtual bool Load (uint32_t Index, bool & Value ) const; virtual bool Load(uint32_t Index, bool & Value) const;
virtual bool Load (uint32_t Index, uint32_t & Value ) const; virtual bool Load(uint32_t Index, uint32_t & Value) const;
virtual bool Load (uint32_t Index, std::string & Value ) const; virtual bool Load(uint32_t Index, std::string & Value) const;
// Return the default values // Return the default values
virtual void LoadDefault (uint32_t Index, bool & Value ) const; virtual void LoadDefault(uint32_t Index, bool & Value) const;
virtual void LoadDefault (uint32_t Index, uint32_t & Value ) const; virtual void LoadDefault(uint32_t Index, uint32_t & Value) const;
virtual void LoadDefault (uint32_t Index, std::string & Value ) const; virtual void LoadDefault(uint32_t Index, std::string & Value) const;
// Update the settings // Update the settings
virtual void Save (uint32_t Index, bool Value ); virtual void Save(uint32_t Index, bool Value);
virtual void Save (uint32_t Index, uint32_t Value ); virtual void Save(uint32_t Index, uint32_t Value);
virtual void Save (uint32_t Index, const std::string & Value ); virtual void Save(uint32_t Index, const std::string & Value);
virtual void Save (uint32_t Index, const char * Value ); virtual void Save(uint32_t Index, const char * Value);
// Delete the setting // Delete the setting
virtual void Delete (uint32_t Index ); virtual void Delete(uint32_t Index);
private: private:
CSettingTypeRDBCpuType(void); CSettingTypeRDBCpuType(void);
CSettingTypeRDBCpuType(const CSettingTypeRDBCpuType&); CSettingTypeRDBCpuType(const CSettingTypeRDBCpuType &);
CSettingTypeRDBCpuType& operator=(const CSettingTypeRDBCpuType&); CSettingTypeRDBCpuType & operator=(const CSettingTypeRDBCpuType &);
}; };

8
Source/Project64/N64System.h
View File

@ -1,9 +1,9 @@
#pragma once #pragma once
#include "Support.h" #include "Support.h"
#include <string> // Needed for stl string (std::string)
#include <float.h> #include <float.h>
#include <math.h> #include <math.h>
#include <string>
#include "UserInterface.h" #include "UserInterface.h"
#include <Project64-core/N64System/N64Types.h> #include <Project64-core/N64System/N64Types.h>
@ -12,9 +12,9 @@
// General MIPS information // General MIPS information
#include <Project64-core/N64System/N64Rom.h>
#include <Project64-core/N64System/SpeedLimiter.h>
#include <Project64-core/N64System/Mips/R4300iOpcode.h> #include <Project64-core/N64System/Mips/R4300iOpcode.h>
#include <Project64-core/N64System/Recompiler/x86/x86ops.h> #include <Project64-core/N64System/N64Rom.h>
#include <Project64-core/N64System/N64System.h> #include <Project64-core/N64System/N64System.h>
#include <Project64-core/N64System/Recompiler/x86/x86ops.h>
#include <Project64-core/N64System/SpeedLimiter.h>
#include <Project64-core/N64System/SystemGlobals.h> #include <Project64-core/N64System/SystemGlobals.h>

14
Source/Project64/Plugins/PluginList.h
View File

@ -8,24 +8,24 @@ public:
typedef struct typedef struct
{ {
PLUGIN_INFO Info; PLUGIN_INFO Info;
bool AboutFunction; bool AboutFunction;
CPath FullPath; CPath FullPath;
stdstr FileName; stdstr FileName;
} PLUGIN; } PLUGIN;
public: public:
CPluginList(bool bAutoFill = true); CPluginList(bool bAutoFill = true);
~CPluginList(); ~CPluginList();
bool LoadList(void); bool LoadList(void);
int GetPluginCount(void) const; int GetPluginCount(void) const;
const PLUGIN * GetPluginInfo(int indx) const; const PLUGIN * GetPluginInfo(int indx) const;
private: private:
typedef std::vector<PLUGIN> PluginList; typedef std::vector<PLUGIN> PluginList;
PluginList m_PluginList; PluginList m_PluginList;
CPath m_PluginDir; CPath m_PluginDir;
void AddPluginFromDir(CPath Dir); void AddPluginFromDir(CPath Dir);
}; };

23
Source/Project64/Settings/GuiSettings.h
View File

@ -3,18 +3,23 @@
class CGuiSettings class CGuiSettings
{ {
protected: protected:
CGuiSettings(); CGuiSettings();
virtual ~CGuiSettings(); virtual ~CGuiSettings();
static inline bool bCPURunning ( void) { return m_bCPURunning; } static inline bool bCPURunning(void)
static inline bool bAutoSleep ( void) { return m_bAutoSleep; } {
return m_bCPURunning;
}
static inline bool bAutoSleep(void)
{
return m_bAutoSleep;
}
private: private:
static void RefreshSettings (void *); static void RefreshSettings(void *);
static bool m_bCPURunning; static bool m_bCPURunning;
static bool m_bAutoSleep; static bool m_bAutoSleep;
static int m_RefCount;
static int m_RefCount;
}; };

5
Source/Project64/Settings/NotificationSettings.h
View File

@ -16,5 +16,8 @@ protected:
virtual ~CNotificationSettings(); virtual ~CNotificationSettings();
void RegisterNotifications(void); void RegisterNotifications(void);
inline bool InFullScreen(void) const { return m_bInFullScreen; } inline bool InFullScreen(void) const
{
return m_bInFullScreen;
}
}; };

6
Source/Project64/Settings/UISettings.h
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <string>
#include <stdint.h> #include <stdint.h>
#include <string>
enum UISettingID enum UISettingID
{ {
@ -16,7 +16,7 @@ enum UISettingID
// Settings location // Settings location
Setting_PluginPageFirst, Setting_PluginPageFirst,
Setting_DisableScrSaver, Setting_DisableScrSaver,
Setting_EnableDiscordRPC, Setting_EnableDiscordRPC,
Setting_AutoSleep, Setting_AutoSleep,
Setting_AutoFullscreen, Setting_AutoFullscreen,
@ -71,7 +71,7 @@ enum UISettingID
}; };
float DPIScale(void); float DPIScale(void);
void RegisterUISettings (void); void RegisterUISettings(void);
void UISettingsSaveBool(UISettingID Type, bool Value); void UISettingsSaveBool(UISettingID Type, bool Value);
void UISettingsSaveBoolIndex(UISettingID Type, int32_t index, bool Value); void UISettingsSaveBoolIndex(UISettingID Type, int32_t index, bool Value);
void UISettingsSaveDword(UISettingID Type, uint32_t Value); void UISettingsSaveDword(UISettingID Type, uint32_t Value);

10
Source/Project64/Support.h
View File

@ -2,12 +2,12 @@
#include <windows.h> #include <windows.h>
#endif #endif
#include <Common/MemTest.h>
#include <Common/CriticalSection.h> #include <Common/CriticalSection.h>
#include <Common/StdString.h>
#include <Common/File.h> #include <Common/File.h>
#include <Common/Log.h>
#include <Common/Trace.h>
#include <Common/path.h>
#include <Common/IniFile.h> #include <Common/IniFile.h>
#include <Common/Log.h>
#include <Common/MemTest.h>
#include <Common/StdString.h>
#include <Common/Trace.h>
#include <Common/md5.h> #include <Common/md5.h>
#include <Common/path.h>

16
Source/Project64/UserInterface.h
View File

@ -1,20 +1,20 @@
#pragma once #pragma once
#pragma warning(disable:4786) #pragma warning(disable : 4786)
#include "Support.h" #include "Support.h"
#include <Project64-core/Multilanguage.h> #include <Project64-core/Multilanguage.h>
#include <Project64-core/Settings.h> #include <Project64-core/Settings.h>
#include "WTLApp.h" #include "UserInterface/CheatUI.h"
#include "UserInterface/MenuShortCuts.h" #include "UserInterface/MainMenu.h"
#include "UserInterface/RomBrowser.h"
#include "UserInterface/MainWindow.h" #include "UserInterface/MainWindow.h"
#include "UserInterface/MenuItem.h" #include "UserInterface/MenuItem.h"
#include "UserInterface/MainMenu.h" #include "UserInterface/MenuShortCuts.h"
#include "UserInterface/Notification.h" #include "UserInterface/Notification.h"
#include <Project64-core/N64System/FramePerSecond.h> #include "UserInterface/RomBrowser.h"
#include "UserInterface/resource.h"
#include "UserInterface/SettingsConfig.h" #include "UserInterface/SettingsConfig.h"
#include "UserInterface/CheatUI.h"
#include "UserInterface/SupportWindow.h" #include "UserInterface/SupportWindow.h"
#include "UserInterface/resource.h"
#include "WTLApp.h"
#include <Project64-core/N64System/FramePerSecond.h>

25
Source/Project64/UserInterface/About.h
View File

@ -1,29 +1,34 @@
#pragma once #pragma once
#include <Project64\UserInterface\WTLControls\wtl-BitmapPicture.h>
#include "resource.h" #include "resource.h"
#include <Project64\UserInterface\WTLControls\wtl-BitmapPicture.h>
class CAboutDlg : class CAboutDlg :
public CDialogImpl<CAboutDlg> public CDialogImpl<CAboutDlg>
{ {
public: public:
BEGIN_MSG_MAP_EX(CAboutDlg) BEGIN_MSG_MAP_EX(CAboutDlg)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground) MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic);
COMMAND_ID_HANDLER(IDOK, OnOkCmd) MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground);
COMMAND_ID_HANDLER(IDCANCEL, OnOkCmd) COMMAND_ID_HANDLER(IDOK, OnOkCmd);
COMMAND_ID_HANDLER(IDCANCEL, OnOkCmd);
}
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_About }; enum
{
IDD = IDD_About
};
CAboutDlg(CProjectSupport & Support); CAboutDlg(CProjectSupport & Support);
private: private:
CAboutDlg(void); CAboutDlg(void);
CAboutDlg(const CAboutDlg&); CAboutDlg(const CAboutDlg &);
CAboutDlg& operator=(const CAboutDlg&); CAboutDlg & operator=(const CAboutDlg &);
void SetWindowDetais(int nIDDlgItem, int nAboveIDDlgItem, const wchar_t * Text, const HFONT &font); void SetWindowDetais(int nIDDlgItem, int nAboveIDDlgItem, const wchar_t * Text, const HFONT & font);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnColorStatic(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled); LRESULT OnColorStatic(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);

60
Source/Project64/UserInterface/CheatUI.cpp
View File

@ -322,7 +322,10 @@ LRESULT CCheatList::OnTreeClicked(NMHDR * lpnmh)
LRESULT CCheatList::OnTreeRClicked(NMHDR * lpnmh) LRESULT CCheatList::OnTreeRClicked(NMHDR * lpnmh)
{ {
if (g_Settings->LoadBool(UserInterface_BasicMode)) { return true; } if (g_Settings->LoadBool(UserInterface_BasicMode))
{
return true;
}
// Work out what item is selected // Work out what item is selected
TVHITTESTINFO ht = {0}; TVHITTESTINFO ht = {0};
@ -397,7 +400,10 @@ LRESULT CCheatList::OnTreeSelChanged(NMHDR * /*lpnmh*/)
void CCheatList::RefreshItems() void CCheatList::RefreshItems()
{ {
if (m_hWnd == nullptr) { return; } if (m_hWnd == nullptr)
{
return;
}
m_DeleteingEntries = true; m_DeleteingEntries = true;
m_hCheatTree.DeleteAllItems(); m_hCheatTree.DeleteAllItems();
@ -419,9 +425,15 @@ void CCheatList::AddCodeLayers(LPARAM Enhancement, const std::wstring & Name, HT
TV_INSERTSTRUCT tv; TV_INSERTSTRUCT tv;
wchar_t Text[500], Item[500]; wchar_t Text[500], Item[500];
if (Name.length() > ((sizeof(Text) / sizeof(Text[0])) - 5)) { g_Notify->BreakPoint(__FILE__, __LINE__); } if (Name.length() > ((sizeof(Text) / sizeof(Text[0])) - 5))
{
g_Notify->BreakPoint(__FILE__, __LINE__);
}
wcscpy(Text, Name.c_str()); wcscpy(Text, Name.c_str());
if (wcschr(Text, L'\\') > 0) { *wcschr(Text, L'\\') = 0; } if (wcschr(Text, L'\\') > 0)
{
*wcschr(Text, L'\\') = 0;
}
tv.item.mask = TVIF_TEXT; tv.item.mask = TVIF_TEXT;
tv.item.pszText = Item; tv.item.pszText = Item;
@ -457,7 +469,10 @@ void CCheatList::AddCodeLayers(LPARAM Enhancement, const std::wstring & Name, HT
hParent = TreeView_InsertItem(m_hCheatTree, &tv); hParent = TreeView_InsertItem(m_hCheatTree, &tv);
TV_SetCheckState(hParent, CheatActive ? TV_STATE_CHECKED : TV_STATE_CLEAR); TV_SetCheckState(hParent, CheatActive ? TV_STATE_CHECKED : TV_STATE_CLEAR);
if (wcscmp(Text, Name.c_str()) == 0) { return; } if (wcscmp(Text, Name.c_str()) == 0)
{
return;
}
AddCodeLayers(Enhancement, Name.substr(wcslen(Text) + 1), hParent, CheatActive); AddCodeLayers(Enhancement, Name.substr(wcslen(Text) + 1), hParent, CheatActive);
} }
@ -466,9 +481,12 @@ void CCheatList::ChangeChildrenStatus(HTREEITEM hParent, bool Checked)
HTREEITEM hItem = m_hCheatTree.GetChildItem(hParent); HTREEITEM hItem = m_hCheatTree.GetChildItem(hParent);
if (hItem == nullptr) if (hItem == nullptr)
{ {
if (hParent == TVI_ROOT) { return; } if (hParent == TVI_ROOT)
{
return;
}
TVITEM item = { 0 }; TVITEM item = {0};
item.mask = TVIF_PARAM; item.mask = TVIF_PARAM;
item.hItem = hParent; item.hItem = hParent;
m_hCheatTree.GetItem(&item); m_hCheatTree.GetItem(&item);
@ -494,14 +512,19 @@ void CCheatList::ChangeChildrenStatus(HTREEITEM hParent, bool Checked)
while (hItem != nullptr) while (hItem != nullptr)
{ {
TV_CHECK_STATE ChildState = TV_GetCheckState(hItem); TV_CHECK_STATE ChildState = TV_GetCheckState(hItem);
if ((ChildState != TV_STATE_CHECKED || !Checked) && if ((ChildState != TV_STATE_CHECKED || !Checked) && (ChildState != TV_STATE_CLEAR || Checked))
(ChildState != TV_STATE_CLEAR || Checked))
{ {
ChangeChildrenStatus(hItem, Checked); ChangeChildrenStatus(hItem, Checked);
} }
ChildState = TV_GetCheckState(hItem); ChildState = TV_GetCheckState(hItem);
if (state == TV_STATE_UNKNOWN) { state = ChildState; } if (state == TV_STATE_UNKNOWN)
if (state != ChildState) { state = TV_STATE_INDETERMINATE; } {
state = ChildState;
}
if (state != ChildState)
{
state = TV_STATE_INDETERMINATE;
}
hItem = m_hCheatTree.GetNextSiblingItem(hItem); hItem = m_hCheatTree.GetNextSiblingItem(hItem);
} }
if (state != TV_STATE_UNKNOWN) if (state != TV_STATE_UNKNOWN)
@ -603,8 +626,14 @@ void CCheatList::MenuSetText(HMENU hMenu, int MenuPos, const wchar_t * Title, co
GetMenuItemInfo(hMenu, MenuPos, true, &MenuInfo); GetMenuItemInfo(hMenu, MenuPos, true, &MenuInfo);
wcscpy(String, Title); wcscpy(String, Title);
if (wcschr(String, '\t') != nullptr) { *(wcschr(String, '\t')) = '\0'; } if (wcschr(String, '\t') != nullptr)
if (ShortCut) { _swprintf(String, L"%s\t%s", String, ShortCut); } {
*(wcschr(String, '\t')) = '\0';
}
if (ShortCut)
{
_swprintf(String, L"%s\t%s", String, ShortCut);
}
SetMenuItemInfo(hMenu, MenuPos, true, &MenuInfo); SetMenuItemInfo(hMenu, MenuPos, true, &MenuInfo);
} }
@ -865,10 +894,7 @@ bool CEditCheat::ValuesChanged(void)
bool Changed = false; bool Changed = false;
if (m_hWnd != nullptr) if (m_hWnd != nullptr)
{ {
if (m_EditName != GetCWindowText(GetDlgItem(IDC_CODE_NAME)) || if (m_EditName != GetCWindowText(GetDlgItem(IDC_CODE_NAME)) || m_EditCode != GetCWindowText(GetDlgItem(IDC_CHEAT_CODES)) || m_EditOptions != GetCWindowText(GetDlgItem(IDC_CHEAT_OPTIONS)) || m_EditNotes != GetCWindowText(GetDlgItem(IDC_NOTES)))
m_EditCode != GetCWindowText(GetDlgItem(IDC_CHEAT_CODES)) ||
m_EditOptions != GetCWindowText(GetDlgItem(IDC_CHEAT_OPTIONS)) ||
m_EditNotes != GetCWindowText(GetDlgItem(IDC_NOTES)))
{ {
Changed = true; Changed = true;
} }

157
Source/Project64/UserInterface/CheatUI.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <Project64\WTLApp.h>
#include <Project64-core/N64System/Enhancement/Enhancement.h> #include <Project64-core/N64System/Enhancement/Enhancement.h>
#include <Project64-core/N64System/Enhancement/EnhancementList.h> #include <Project64-core/N64System/Enhancement/EnhancementList.h>
#include <Project64\WTLApp.h>
class CEditCheat; class CEditCheat;
class CCheatsUI; class CCheatsUI;
@ -16,18 +16,23 @@ class CCheatList :
public: public:
BEGIN_MSG_MAP_EX(CCheatList) BEGIN_MSG_MAP_EX(CCheatList)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
MESSAGE_HANDLER(WM_DESTROY, OnDestroy) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MESSAGE_HANDLER(UM_CHANGECODEEXTENSION, OnChangeCodeExtension) MESSAGE_HANDLER(WM_DESTROY, OnDestroy);
COMMAND_ID_HANDLER(IDC_UNMARK, OnUnmark) MESSAGE_HANDLER(UM_CHANGECODEEXTENSION, OnChangeCodeExtension);
COMMAND_ID_HANDLER(ID_POPUP_DELETE, OnPopupDelete) COMMAND_ID_HANDLER(IDC_UNMARK, OnUnmark);
NOTIFY_HANDLER_EX(IDC_MYTREE, NM_CLICK, OnTreeClicked) COMMAND_ID_HANDLER(ID_POPUP_DELETE, OnPopupDelete);
NOTIFY_HANDLER_EX(IDC_MYTREE, NM_RCLICK, OnTreeRClicked) NOTIFY_HANDLER_EX(IDC_MYTREE, NM_CLICK, OnTreeClicked);
NOTIFY_HANDLER_EX(IDC_MYTREE, NM_DBLCLK, OnTreeDClicked) NOTIFY_HANDLER_EX(IDC_MYTREE, NM_RCLICK, OnTreeRClicked);
NOTIFY_HANDLER_EX(IDC_MYTREE, TVN_SELCHANGED, OnTreeSelChanged) NOTIFY_HANDLER_EX(IDC_MYTREE, NM_DBLCLK, OnTreeDClicked);
NOTIFY_HANDLER_EX(IDC_MYTREE, TVN_SELCHANGED, OnTreeSelChanged);
}
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_Cheats_List }; enum
{
IDD = IDD_Cheats_List
};
CCheatList(CEnhancementList & Cheats, CEditCheat & EditCheat); CCheatList(CEnhancementList & Cheats, CEditCheat & EditCheat);
~CCheatList(); ~CCheatList();
@ -36,21 +41,27 @@ public:
private: private:
CCheatList(void); CCheatList(void);
CCheatList(const CCheatList&); CCheatList(const CCheatList &);
CCheatList& operator=(const CCheatList&); CCheatList & operator=(const CCheatList &);
enum TV_CHECK_STATE { TV_STATE_UNKNOWN, TV_STATE_CLEAR, TV_STATE_CHECKED, TV_STATE_INDETERMINATE }; enum TV_CHECK_STATE
{
TV_STATE_UNKNOWN,
TV_STATE_CLEAR,
TV_STATE_CHECKED,
TV_STATE_INDETERMINATE
};
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnChangeCodeExtension(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnChangeCodeExtension(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnUnmark(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnUnmark(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnPopupDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnPopupDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnTreeClicked(NMHDR* lpnmh); LRESULT OnTreeClicked(NMHDR * lpnmh);
LRESULT OnTreeRClicked(NMHDR* lpnmh); LRESULT OnTreeRClicked(NMHDR * lpnmh);
LRESULT OnTreeDClicked(NMHDR* lpnmh); LRESULT OnTreeDClicked(NMHDR * lpnmh);
LRESULT OnTreeSelChanged(NMHDR* lpnmh); LRESULT OnTreeSelChanged(NMHDR * lpnmh);
void AddCodeLayers(LPARAM ListID, const std::wstring &Name, HTREEITEM hParent, bool CheatActive); void AddCodeLayers(LPARAM ListID, const std::wstring & Name, HTREEITEM hParent, bool CheatActive);
void ChangeChildrenStatus(HTREEITEM hParent, bool Checked); void ChangeChildrenStatus(HTREEITEM hParent, bool Checked);
void CheckParentStatus(HTREEITEM hParent); void CheckParentStatus(HTREEITEM hParent);
void DeleteCheat(LPARAM Enhancement); void DeleteCheat(LPARAM Enhancement);
@ -58,7 +69,10 @@ private:
bool TV_SetCheckState(HTREEITEM hItem, TV_CHECK_STATE state); bool TV_SetCheckState(HTREEITEM hItem, TV_CHECK_STATE state);
static void MenuSetText(HMENU hMenu, int MenuPos, const wchar_t * Title, const wchar_t * ShortCut); static void MenuSetText(HMENU hMenu, int MenuPos, const wchar_t * Title, const wchar_t * ShortCut);
enum { IDC_MYTREE = 0x500 }; enum
{
IDC_MYTREE = 0x500
};
CEnhancementList & m_Cheats; CEnhancementList & m_Cheats;
CEditCheat & m_EditCheat; CEditCheat & m_EditCheat;
@ -79,32 +93,35 @@ public:
}; };
BEGIN_MSG_MAP_EX(CEditCheat) BEGIN_MSG_MAP_EX(CEditCheat)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
MESSAGE_HANDLER(WM_EDITCHEAT, OnEditCheat) MESSAGE_HANDLER(WM_EDITCHEAT, OnEditCheat)
COMMAND_ID_HANDLER(IDC_ADD, OnAddCheat) COMMAND_ID_HANDLER(IDC_ADD, OnAddCheat)
COMMAND_ID_HANDLER(IDC_NEWCHEAT, OnNewCheat) COMMAND_ID_HANDLER(IDC_NEWCHEAT, OnNewCheat)
COMMAND_HANDLER(IDC_CODE_NAME, EN_CHANGE, OnCodeNameChanged) COMMAND_HANDLER(IDC_CODE_NAME, EN_CHANGE, OnCodeNameChanged)
COMMAND_HANDLER(IDC_CHEAT_CODES, EN_CHANGE, OnCheatCodeChanged) COMMAND_HANDLER(IDC_CHEAT_CODES, EN_CHANGE, OnCheatCodeChanged)
COMMAND_HANDLER(IDC_CHEAT_OPTIONS, EN_CHANGE, OnCheatOptionsChanged) COMMAND_HANDLER(IDC_CHEAT_OPTIONS, EN_CHANGE, OnCheatOptionsChanged)
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_Cheats_Add }; enum
{
IDD = IDD_Cheats_Add
};
CEditCheat(CEnhancementList & Cheats, CCheatList & CheatList); CEditCheat(CEnhancementList & Cheats, CCheatList & CheatList);
~CEditCheat(); ~CEditCheat();
private: private:
CEditCheat(); CEditCheat();
CEditCheat(const CEditCheat&); CEditCheat(const CEditCheat &);
CEditCheat& operator=(const CEditCheat&); CEditCheat & operator=(const CEditCheat &);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnEditCheat(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnEditCheat(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnAddCheat(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnAddCheat(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnNewCheat(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnNewCheat(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCodeNameChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnCodeNameChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCheatCodeChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnCheatCodeChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCheatOptionsChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnCheatOptionsChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
bool ReadEnhancement(CEnhancement & Enhancement); bool ReadEnhancement(CEnhancement & Enhancement);
@ -126,25 +143,28 @@ class CEnhancementCodeEx :
{ {
public: public:
BEGIN_MSG_MAP_EX(CEnhancementCodeEx) BEGIN_MSG_MAP_EX(CEnhancementCodeEx)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
COMMAND_HANDLER(IDC_CHEAT_LIST, LBN_DBLCLK, OnListDblClick) COMMAND_HANDLER(IDC_CHEAT_LIST, LBN_DBLCLK, OnListDblClick)
COMMAND_ID_HANDLER(IDOK, OnOkCmd) COMMAND_ID_HANDLER(IDOK, OnOkCmd)
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd) COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd)
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_Cheats_CodeEx }; enum
{
IDD = IDD_Cheats_CodeEx
};
CEnhancementCodeEx(CEnhancement * Enhancement); CEnhancementCodeEx(CEnhancement * Enhancement);
private: private:
CEnhancementCodeEx(); CEnhancementCodeEx();
CEnhancementCodeEx(const CEnhancementCodeEx&); CEnhancementCodeEx(const CEnhancementCodeEx &);
CEnhancementCodeEx& operator=(const CEnhancementCodeEx&); CEnhancementCodeEx & operator=(const CEnhancementCodeEx &);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnListDblClick(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnListDblClick(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnOkCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnOkCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
CEnhancement * m_Enhancement; CEnhancement * m_Enhancement;
}; };
@ -158,13 +178,18 @@ class CCheatsUI :
public: public:
BEGIN_MSG_MAP_EX(CCheatsUI) BEGIN_MSG_MAP_EX(CCheatsUI)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
MESSAGE_HANDLER(WM_DESTROY, OnDestroy) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_ID_HANDLER(IDC_STATE, OnStateChange) MESSAGE_HANDLER(WM_DESTROY, OnDestroy);
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd) COMMAND_ID_HANDLER(IDC_STATE, OnStateChange);
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd);
}
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_Cheats_Select }; enum
{
IDD = IDD_Cheats_Select
};
CCheatsUI(void); CCheatsUI(void);
~CCheatsUI(void); ~CCheatsUI(void);
@ -172,17 +197,21 @@ public:
void Display(HWND hParent, bool BlockExecution); void Display(HWND hParent, bool BlockExecution);
private: private:
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnStateChange(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnStateChange(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
CEnhancementList m_Cheats; CEnhancementList m_Cheats;
CEditCheat m_EditCheat; CEditCheat m_EditCheat;
CCheatList m_SelectCheat; CCheatList m_SelectCheat;
CButton m_StateBtn; CButton m_StateBtn;
int m_MinSizeDlg, m_MaxSizeDlg; int m_MinSizeDlg, m_MaxSizeDlg;
bool m_bModal; bool m_bModal;
enum Dialog_State { CONTRACTED, EXPANDED } m_DialogState; enum Dialog_State
{
CONTRACTED,
EXPANDED
} m_DialogState;
}; };

582
Source/Project64/UserInterface/Debugger/Assembler.cpp
View File

@ -35,262 +35,366 @@ const ASM_SYNTAX_FN CAssembler::syn_cop_mv[] = {arg_reg_t, arg_reg_d, nullptr};
const ASM_SYNTAX_FN CAssembler::syn_cache[] = {arg_cache_op, arg_imm16, arg_reg_s, nullptr}; const ASM_SYNTAX_FN CAssembler::syn_cache[] = {arg_cache_op, arg_imm16, arg_reg_s, nullptr};
const ASM_SYNTAX_FN CAssembler::syn_syscall[] = {arg_syscall_code, nullptr}; const ASM_SYNTAX_FN CAssembler::syn_syscall[] = {arg_syscall_code, nullptr};
const ASM_INSTRUCTION CAssembler::m_Instructions[] = const ASM_INSTRUCTION CAssembler::m_Instructions[] = {
{ {"j", R4300i_J, base_op, syn_jump},
{ "j", R4300i_J, base_op, syn_jump }, {"jal", R4300i_JAL, base_op, syn_jump},
{ "jal", R4300i_JAL, base_op, syn_jump }, {"beq", R4300i_BEQ, base_op, syn_branch},
{ "beq", R4300i_BEQ, base_op, syn_branch }, {"beqz", R4300i_BEQ, base_op, syn_branch_z},
{ "beqz", R4300i_BEQ, base_op, syn_branch_z }, {"b", R4300i_BEQ, base_op, syn_branch_unc},
{ "b", R4300i_BEQ, base_op, syn_branch_unc }, {"bne", R4300i_BNE, base_op, syn_branch},
{ "bne", R4300i_BNE, base_op, syn_branch }, {"bnez", R4300i_BNE, base_op, syn_branch_z},
{ "bnez", R4300i_BNE, base_op, syn_branch_z }, {"blez", R4300i_BLEZ, base_op, syn_branch_z},
{ "blez", R4300i_BLEZ, base_op, syn_branch_z }, {"bgtz", R4300i_BGTZ, base_op, syn_branch_z},
{ "bgtz", R4300i_BGTZ, base_op, syn_branch_z }, {"addi", R4300i_ADDI, base_op, syn_arith_i},
{ "addi", R4300i_ADDI, base_op, syn_arith_i }, {"addiu", R4300i_ADDIU, base_op, syn_arith_i},
{ "addiu", R4300i_ADDIU, base_op, syn_arith_i }, {"slti", R4300i_SLTI, base_op, syn_arith_i},
{ "slti", R4300i_SLTI, base_op, syn_arith_i }, {"sltiu", R4300i_SLTIU, base_op, syn_arith_i},
{ "sltiu", R4300i_SLTIU, base_op, syn_arith_i }, {"andi", R4300i_ANDI, base_op, syn_arith_i},
{ "andi", R4300i_ANDI, base_op, syn_arith_i }, {"ori", R4300i_ORI, base_op, syn_arith_i},
{ "ori", R4300i_ORI, base_op, syn_arith_i }, {"xori", R4300i_XORI, base_op, syn_arith_i},
{ "xori", R4300i_XORI, base_op, syn_arith_i }, {"lui", R4300i_LUI, base_op, syn_load_i},
{ "lui", R4300i_LUI, base_op, syn_load_i }, {"beql", R4300i_BEQL, base_op, syn_branch},
{ "beql", R4300i_BEQL, base_op, syn_branch }, {"beqzl", R4300i_BEQL, base_op, syn_branch_z},
{ "beqzl", R4300i_BEQL, base_op, syn_branch_z }, {"bnel", R4300i_BNEL, base_op, syn_branch},
{ "bnel", R4300i_BNEL, base_op, syn_branch }, {"bnezl", R4300i_BNEL, base_op, syn_branch_z},
{ "bnezl", R4300i_BNEL, base_op, syn_branch_z }, {"blezl", R4300i_BLEZL, base_op, syn_branch_z},
{ "blezl", R4300i_BLEZL, base_op, syn_branch_z }, {"bgtzl", R4300i_BGTZL, base_op, syn_branch_z},
{ "bgtzl", R4300i_BGTZL, base_op, syn_branch_z }, {"daddi", R4300i_DADDI, base_op, syn_arith_i},
{ "daddi", R4300i_DADDI, base_op, syn_arith_i }, {"daddiu", R4300i_DADDIU, base_op, syn_arith_i},
{ "daddiu", R4300i_DADDIU, base_op, syn_arith_i }, {"ldl", R4300i_LDL, base_op, syn_loadstore},
{ "ldl", R4300i_LDL, base_op, syn_loadstore }, {"ldr", R4300i_LDR, base_op, syn_loadstore},
{ "ldr", R4300i_LDR, base_op, syn_loadstore }, {"lb", R4300i_LB, base_op, syn_loadstore},
{ "lb", R4300i_LB, base_op, syn_loadstore }, {"lh", R4300i_LH, base_op, syn_loadstore},
{ "lh", R4300i_LH, base_op, syn_loadstore }, {"lwl", R4300i_LWL, base_op, syn_loadstore},
{ "lwl", R4300i_LWL, base_op, syn_loadstore }, {"lw", R4300i_LW, base_op, syn_loadstore},
{ "lw", R4300i_LW, base_op, syn_loadstore }, {"lbu", R4300i_LBU, base_op, syn_loadstore},
{ "lbu", R4300i_LBU, base_op, syn_loadstore }, {"lhu", R4300i_LHU, base_op, syn_loadstore},
{ "lhu", R4300i_LHU, base_op, syn_loadstore }, {"lwr", R4300i_LWR, base_op, syn_loadstore},
{ "lwr", R4300i_LWR, base_op, syn_loadstore }, {"lwu", R4300i_LWU, base_op, syn_loadstore},
{ "lwu", R4300i_LWU, base_op, syn_loadstore }, {"sb", R4300i_SB, base_op, syn_loadstore},
{ "sb", R4300i_SB, base_op, syn_loadstore }, {"sh", R4300i_SH, base_op, syn_loadstore},
{ "sh", R4300i_SH, base_op, syn_loadstore }, {"swl", R4300i_SWL, base_op, syn_loadstore},
{ "swl", R4300i_SWL, base_op, syn_loadstore }, {"sw", R4300i_SW, base_op, syn_loadstore},
{ "sw", R4300i_SW, base_op, syn_loadstore }, {"sdl", R4300i_SDL, base_op, syn_loadstore},
{ "sdl", R4300i_SDL, base_op, syn_loadstore }, {"sdr", R4300i_SDR, base_op, syn_loadstore},
{ "sdr", R4300i_SDR, base_op, syn_loadstore }, {"swr", R4300i_SWR, base_op, syn_loadstore},
{ "swr", R4300i_SWR, base_op, syn_loadstore }, {"cache", R4300i_CACHE, base_op, syn_cache},
{ "cache", R4300i_CACHE, base_op, syn_cache }, {"ll", R4300i_LL, base_op, syn_loadstore},
{ "ll", R4300i_LL, base_op, syn_loadstore }, {"lwc1", R4300i_LWC1, base_op, syn_loadstore},
{ "lwc1", R4300i_LWC1, base_op, syn_loadstore }, {"ldc1", R4300i_LDC1, base_op, syn_loadstore},
{ "ldc1", R4300i_LDC1, base_op, syn_loadstore }, {"ld", R4300i_LD, base_op, syn_loadstore},
{ "ld", R4300i_LD, base_op, syn_loadstore }, {"sc", R4300i_SC, base_op, syn_loadstore},
{ "sc", R4300i_SC, base_op, syn_loadstore }, {"swc1", R4300i_SWC1, base_op, syn_loadstore},
{ "swc1", R4300i_SWC1, base_op, syn_loadstore }, {"sdc1", R4300i_SDC1, base_op, syn_loadstore},
{ "sdc1", R4300i_SDC1, base_op, syn_loadstore }, {"sdc2", R4300i_SDC2, base_op, syn_loadstore},
{ "sdc2", R4300i_SDC2, base_op, syn_loadstore }, {"sd", R4300i_SD, base_op, syn_loadstore},
{ "sd", R4300i_SD, base_op, syn_loadstore },
{ "sll", R4300i_SPECIAL_SLL, base_spec, syn_shift }, {"sll", R4300i_SPECIAL_SLL, base_spec, syn_shift},
{ "nop", R4300i_SPECIAL_SLL, base_spec, nullptr }, {"nop", R4300i_SPECIAL_SLL, base_spec, nullptr},
{ "srl", R4300i_SPECIAL_SRL, base_spec, syn_shift }, {"srl", R4300i_SPECIAL_SRL, base_spec, syn_shift},
{ "sra", R4300i_SPECIAL_SRA, base_spec, syn_shift }, {"sra", R4300i_SPECIAL_SRA, base_spec, syn_shift},
{ "sllv", R4300i_SPECIAL_SLLV, base_spec, syn_shiftv }, {"sllv", R4300i_SPECIAL_SLLV, base_spec, syn_shiftv},
{ "srlv", R4300i_SPECIAL_SRLV, base_spec, syn_shiftv }, {"srlv", R4300i_SPECIAL_SRLV, base_spec, syn_shiftv},
{ "srav", R4300i_SPECIAL_SRAV, base_spec, syn_shiftv }, {"srav", R4300i_SPECIAL_SRAV, base_spec, syn_shiftv},
{ "jr", R4300i_SPECIAL_JR, base_spec, syn_jr }, {"jr", R4300i_SPECIAL_JR, base_spec, syn_jr},
{ "jalr", R4300i_SPECIAL_JALR, base_spec, syn_jalr }, {"jalr", R4300i_SPECIAL_JALR, base_spec, syn_jalr},
{ "jalr", R4300i_SPECIAL_JALR, base_spec_jalr_ra, syn_jr }, {"jalr", R4300i_SPECIAL_JALR, base_spec_jalr_ra, syn_jr},
{ "syscall", R4300i_SPECIAL_SYSCALL, base_spec, syn_syscall }, {"syscall", R4300i_SPECIAL_SYSCALL, base_spec, syn_syscall},
{ "break", R4300i_SPECIAL_BREAK, base_spec, syn_syscall }, {"break", R4300i_SPECIAL_BREAK, base_spec, syn_syscall},
{ "sync", R4300i_SPECIAL_SYNC, base_spec, nullptr }, {"sync", R4300i_SPECIAL_SYNC, base_spec, nullptr},
{ "mfhi", R4300i_SPECIAL_MFHI, base_spec, syn_mf }, {"mfhi", R4300i_SPECIAL_MFHI, base_spec, syn_mf},
{ "mthi", R4300i_SPECIAL_MTHI, base_spec, syn_mf }, {"mthi", R4300i_SPECIAL_MTHI, base_spec, syn_mf},
{ "mflo", R4300i_SPECIAL_MFLO, base_spec, syn_mf }, {"mflo", R4300i_SPECIAL_MFLO, base_spec, syn_mf},
{ "mtlo", R4300i_SPECIAL_MTLO, base_spec, syn_mf }, {"mtlo", R4300i_SPECIAL_MTLO, base_spec, syn_mf},
{ "dsllv", R4300i_SPECIAL_DSLLV, base_spec, syn_shiftv }, {"dsllv", R4300i_SPECIAL_DSLLV, base_spec, syn_shiftv},
{ "dsrlv", R4300i_SPECIAL_DSRLV, base_spec, syn_shiftv }, {"dsrlv", R4300i_SPECIAL_DSRLV, base_spec, syn_shiftv},
{ "dsrav", R4300i_SPECIAL_DSRAV, base_spec, syn_shiftv }, {"dsrav", R4300i_SPECIAL_DSRAV, base_spec, syn_shiftv},
{ "mult", R4300i_SPECIAL_MULT, base_spec, syn_arith2 }, {"mult", R4300i_SPECIAL_MULT, base_spec, syn_arith2},
{ "multu", R4300i_SPECIAL_MULTU, base_spec, syn_arith2 }, {"multu", R4300i_SPECIAL_MULTU, base_spec, syn_arith2},
{ "div", R4300i_SPECIAL_DIV, base_spec, syn_arith2 }, {"div", R4300i_SPECIAL_DIV, base_spec, syn_arith2},
{ "divu", R4300i_SPECIAL_DIVU, base_spec, syn_arith2 }, {"divu", R4300i_SPECIAL_DIVU, base_spec, syn_arith2},
{ "dmult", R4300i_SPECIAL_DMULT, base_spec, syn_arith2 }, {"dmult", R4300i_SPECIAL_DMULT, base_spec, syn_arith2},
{ "dmultu", R4300i_SPECIAL_DMULTU, base_spec, syn_arith2 }, {"dmultu", R4300i_SPECIAL_DMULTU, base_spec, syn_arith2},
{ "ddiv", R4300i_SPECIAL_DDIV, base_spec, syn_arith2 }, {"ddiv", R4300i_SPECIAL_DDIV, base_spec, syn_arith2},
{ "ddivu", R4300i_SPECIAL_DDIVU, base_spec, syn_arith2 }, {"ddivu", R4300i_SPECIAL_DDIVU, base_spec, syn_arith2},
{ "add", R4300i_SPECIAL_ADD, base_spec, syn_arith }, {"add", R4300i_SPECIAL_ADD, base_spec, syn_arith},
{ "addu", R4300i_SPECIAL_ADDU, base_spec, syn_arith }, {"addu", R4300i_SPECIAL_ADDU, base_spec, syn_arith},
{ "sub", R4300i_SPECIAL_SUB, base_spec, syn_arith }, {"sub", R4300i_SPECIAL_SUB, base_spec, syn_arith},
{ "subu", R4300i_SPECIAL_SUBU, base_spec, syn_arith }, {"subu", R4300i_SPECIAL_SUBU, base_spec, syn_arith},
{ "and", R4300i_SPECIAL_AND, base_spec, syn_arith }, {"and", R4300i_SPECIAL_AND, base_spec, syn_arith},
{ "or", R4300i_SPECIAL_OR, base_spec, syn_arith }, {"or", R4300i_SPECIAL_OR, base_spec, syn_arith},
{ "xor", R4300i_SPECIAL_XOR, base_spec, syn_arith }, {"xor", R4300i_SPECIAL_XOR, base_spec, syn_arith},
{ "nor", R4300i_SPECIAL_NOR, base_spec, syn_arith }, {"nor", R4300i_SPECIAL_NOR, base_spec, syn_arith},
{ "slt", R4300i_SPECIAL_SLT, base_spec, syn_arith }, {"slt", R4300i_SPECIAL_SLT, base_spec, syn_arith},
{ "sltu", R4300i_SPECIAL_SLTU, base_spec, syn_arith }, {"sltu", R4300i_SPECIAL_SLTU, base_spec, syn_arith},
{ "dadd", R4300i_SPECIAL_DADD, base_spec, syn_arith }, {"dadd", R4300i_SPECIAL_DADD, base_spec, syn_arith},
{ "daddu", R4300i_SPECIAL_DADDU, base_spec, syn_arith }, {"daddu", R4300i_SPECIAL_DADDU, base_spec, syn_arith},
{ "dsub", R4300i_SPECIAL_DSUB, base_spec, syn_arith }, {"dsub", R4300i_SPECIAL_DSUB, base_spec, syn_arith},
{ "dsubu", R4300i_SPECIAL_DSUBU, base_spec, syn_arith }, {"dsubu", R4300i_SPECIAL_DSUBU, base_spec, syn_arith},
{ "tge", R4300i_SPECIAL_TGE, base_spec, syn_arith2 }, // Note: no code field {"tge", R4300i_SPECIAL_TGE, base_spec, syn_arith2}, // Note: no code field
{ "tgeu", R4300i_SPECIAL_TGEU, base_spec, syn_arith2 }, // {"tgeu", R4300i_SPECIAL_TGEU, base_spec, syn_arith2}, //
{ "tlt", R4300i_SPECIAL_TLT, base_spec, syn_arith2 }, // {"tlt", R4300i_SPECIAL_TLT, base_spec, syn_arith2}, //
{ "tltu", R4300i_SPECIAL_TLTU, base_spec, syn_arith2 }, // {"tltu", R4300i_SPECIAL_TLTU, base_spec, syn_arith2}, //
{ "teq", R4300i_SPECIAL_TEQ, base_spec, syn_arith2 }, // {"teq", R4300i_SPECIAL_TEQ, base_spec, syn_arith2}, //
{ "tne", R4300i_SPECIAL_TNE, base_spec, syn_arith2 }, // {"tne", R4300i_SPECIAL_TNE, base_spec, syn_arith2}, //
{ "dsll", R4300i_SPECIAL_DSLL, base_spec, syn_shift }, {"dsll", R4300i_SPECIAL_DSLL, base_spec, syn_shift},
{ "dsrl", R4300i_SPECIAL_DSRL, base_spec, syn_shift }, {"dsrl", R4300i_SPECIAL_DSRL, base_spec, syn_shift},
{ "dsra", R4300i_SPECIAL_DSRA, base_spec, syn_shift }, {"dsra", R4300i_SPECIAL_DSRA, base_spec, syn_shift},
{ "dsll32", R4300i_SPECIAL_DSLL32, base_spec, syn_shift }, {"dsll32", R4300i_SPECIAL_DSLL32, base_spec, syn_shift},
{ "dsrl32", R4300i_SPECIAL_DSRL32, base_spec, syn_shift }, {"dsrl32", R4300i_SPECIAL_DSRL32, base_spec, syn_shift},
{ "dsra32", R4300i_SPECIAL_DSRA32, base_spec, syn_shift }, {"dsra32", R4300i_SPECIAL_DSRA32, base_spec, syn_shift},
{ "bltz", R4300i_REGIMM_BLTZ, base_regimm, syn_branch_z }, {"bltz", R4300i_REGIMM_BLTZ, base_regimm, syn_branch_z},
{ "bgez", R4300i_REGIMM_BGEZ, base_regimm, syn_branch_z }, {"bgez", R4300i_REGIMM_BGEZ, base_regimm, syn_branch_z},
{ "bltzl", R4300i_REGIMM_BLTZL, base_regimm, syn_branch_z }, {"bltzl", R4300i_REGIMM_BLTZL, base_regimm, syn_branch_z},
{ "bgezl", R4300i_REGIMM_BGEZL, base_regimm, syn_branch_z }, {"bgezl", R4300i_REGIMM_BGEZL, base_regimm, syn_branch_z},
{ "tgei", R4300i_REGIMM_TGEI, base_regimm, syn_trap_i }, {"tgei", R4300i_REGIMM_TGEI, base_regimm, syn_trap_i},
{ "tgeiu", R4300i_REGIMM_TGEIU, base_regimm, syn_trap_i }, {"tgeiu", R4300i_REGIMM_TGEIU, base_regimm, syn_trap_i},
{ "tlti", R4300i_REGIMM_TLTI, base_regimm, syn_trap_i }, {"tlti", R4300i_REGIMM_TLTI, base_regimm, syn_trap_i},
{ "tltiu", R4300i_REGIMM_TLTIU, base_regimm, syn_trap_i }, {"tltiu", R4300i_REGIMM_TLTIU, base_regimm, syn_trap_i},
{ "teqi", R4300i_REGIMM_TEQI, base_regimm, syn_trap_i }, {"teqi", R4300i_REGIMM_TEQI, base_regimm, syn_trap_i},
{ "tnei", R4300i_REGIMM_TNEI, base_regimm, syn_trap_i }, {"tnei", R4300i_REGIMM_TNEI, base_regimm, syn_trap_i},
{ "bltzal", R4300i_REGIMM_BLTZAL, base_regimm, syn_branch_z }, {"bltzal", R4300i_REGIMM_BLTZAL, base_regimm, syn_branch_z},
{ "bgezal", R4300i_REGIMM_BGEZAL, base_regimm, syn_branch_z }, {"bgezal", R4300i_REGIMM_BGEZAL, base_regimm, syn_branch_z},
{ "bal", R4300i_REGIMM_BGEZAL, base_regimm, syn_branch_unc }, {"bal", R4300i_REGIMM_BGEZAL, base_regimm, syn_branch_unc},
{ "bltzall", R4300i_REGIMM_BLTZALL, base_regimm, syn_branch_z }, {"bltzall", R4300i_REGIMM_BLTZALL, base_regimm, syn_branch_z},
{ "bgezall", R4300i_REGIMM_BGEZALL, base_regimm, syn_branch_z }, {"bgezall", R4300i_REGIMM_BGEZALL, base_regimm, syn_branch_z},
{ "mfc0", R4300i_COP0_MF , base_cop0_mv, syn_cop_mv }, {"mfc0", R4300i_COP0_MF, base_cop0_mv, syn_cop_mv},
{ "mtc0", R4300i_COP0_MT , base_cop0_mv, syn_cop_mv }, {"mtc0", R4300i_COP0_MT, base_cop0_mv, syn_cop_mv},
{ "tlbr", R4300i_COP0_CO_TLBR, base_cop0_co, nullptr }, {"tlbr", R4300i_COP0_CO_TLBR, base_cop0_co, nullptr},
{ "tlbwi", R4300i_COP0_CO_TLBWI, base_cop0_co, nullptr }, {"tlbwi", R4300i_COP0_CO_TLBWI, base_cop0_co, nullptr},
{ "tlbwr", R4300i_COP0_CO_TLBWR, base_cop0_co, nullptr }, {"tlbwr", R4300i_COP0_CO_TLBWR, base_cop0_co, nullptr},
{ "tlbp", R4300i_COP0_CO_TLBP, base_cop0_co, nullptr }, {"tlbp", R4300i_COP0_CO_TLBP, base_cop0_co, nullptr},
{ "eret", R4300i_COP0_CO_ERET, base_cop0_co, nullptr }, {"eret", R4300i_COP0_CO_ERET, base_cop0_co, nullptr},
{ "mfc1", R4300i_COP1_MF, base_cop1_mv, syn_cop_mv }, {"mfc1", R4300i_COP1_MF, base_cop1_mv, syn_cop_mv},
{ "dmfc1", R4300i_COP1_DMF, base_cop1_mv, syn_cop_mv }, {"dmfc1", R4300i_COP1_DMF, base_cop1_mv, syn_cop_mv},
{ "cfc1", R4300i_COP1_CF, base_cop1_mv, syn_cop_mv }, {"cfc1", R4300i_COP1_CF, base_cop1_mv, syn_cop_mv},
{ "mtc1", R4300i_COP1_MT, base_cop1_mv, syn_cop_mv }, {"mtc1", R4300i_COP1_MT, base_cop1_mv, syn_cop_mv},
{ "dmtc1", R4300i_COP1_DMT, base_cop1_mv, syn_cop_mv }, {"dmtc1", R4300i_COP1_DMT, base_cop1_mv, syn_cop_mv},
{ "ctc1", R4300i_COP1_CT, base_cop1_mv, syn_cop_mv }, {"ctc1", R4300i_COP1_CT, base_cop1_mv, syn_cop_mv},
{ "bc1f", R4300i_COP1_BC_BCF, base_cop1_bc, syn_branch_unc }, {"bc1f", R4300i_COP1_BC_BCF, base_cop1_bc, syn_branch_unc},
{ "bc1t", R4300i_COP1_BC_BCT, base_cop1_bc, syn_branch_unc }, {"bc1t", R4300i_COP1_BC_BCT, base_cop1_bc, syn_branch_unc},
{ "bc1fl", R4300i_COP1_BC_BCFL, base_cop1_bc, syn_branch_unc }, {"bc1fl", R4300i_COP1_BC_BCFL, base_cop1_bc, syn_branch_unc},
{ "bc1tl", R4300i_COP1_BC_BCTL, base_cop1_bc, syn_branch_unc }, {"bc1tl", R4300i_COP1_BC_BCTL, base_cop1_bc, syn_branch_unc},
{ "add.s", R4300i_COP1_FUNCT_ADD, base_cop1_s, syn_cop1_arith }, {"add.s", R4300i_COP1_FUNCT_ADD, base_cop1_s, syn_cop1_arith},
{ "sub.s", R4300i_COP1_FUNCT_SUB, base_cop1_s, syn_cop1_arith }, {"sub.s", R4300i_COP1_FUNCT_SUB, base_cop1_s, syn_cop1_arith},
{ "mul.s", R4300i_COP1_FUNCT_MUL, base_cop1_s, syn_cop1_arith }, {"mul.s", R4300i_COP1_FUNCT_MUL, base_cop1_s, syn_cop1_arith},
{ "div.s", R4300i_COP1_FUNCT_DIV, base_cop1_s, syn_cop1_arith }, {"div.s", R4300i_COP1_FUNCT_DIV, base_cop1_s, syn_cop1_arith},
{ "sqrt.s", R4300i_COP1_FUNCT_SQRT, base_cop1_s, syn_cop1 }, {"sqrt.s", R4300i_COP1_FUNCT_SQRT, base_cop1_s, syn_cop1},
{ "abs.s", R4300i_COP1_FUNCT_ABS, base_cop1_s, syn_cop1 }, {"abs.s", R4300i_COP1_FUNCT_ABS, base_cop1_s, syn_cop1},
{ "mov.s", R4300i_COP1_FUNCT_MOV, base_cop1_s, syn_cop1 }, {"mov.s", R4300i_COP1_FUNCT_MOV, base_cop1_s, syn_cop1},
{ "neg.s", R4300i_COP1_FUNCT_NEG, base_cop1_s, syn_cop1 }, {"neg.s", R4300i_COP1_FUNCT_NEG, base_cop1_s, syn_cop1},
{ "round.l.s", R4300i_COP1_FUNCT_ROUND_L, base_cop1_s, syn_cop1 }, {"round.l.s", R4300i_COP1_FUNCT_ROUND_L, base_cop1_s, syn_cop1},
{ "trunc.l.s", R4300i_COP1_FUNCT_TRUNC_L, base_cop1_s, syn_cop1 }, {"trunc.l.s", R4300i_COP1_FUNCT_TRUNC_L, base_cop1_s, syn_cop1},
{ "ceil.l.s", R4300i_COP1_FUNCT_CEIL_L, base_cop1_s, syn_cop1 }, {"ceil.l.s", R4300i_COP1_FUNCT_CEIL_L, base_cop1_s, syn_cop1},
{ "floor.l.s", R4300i_COP1_FUNCT_FLOOR_L, base_cop1_s, syn_cop1 }, {"floor.l.s", R4300i_COP1_FUNCT_FLOOR_L, base_cop1_s, syn_cop1},
{ "round.w.s", R4300i_COP1_FUNCT_ROUND_W, base_cop1_s, syn_cop1 }, {"round.w.s", R4300i_COP1_FUNCT_ROUND_W, base_cop1_s, syn_cop1},
{ "trunc.w.s", R4300i_COP1_FUNCT_TRUNC_W, base_cop1_s, syn_cop1 }, {"trunc.w.s", R4300i_COP1_FUNCT_TRUNC_W, base_cop1_s, syn_cop1},
{ "ceil.w.s", R4300i_COP1_FUNCT_CEIL_W, base_cop1_s, syn_cop1 }, {"ceil.w.s", R4300i_COP1_FUNCT_CEIL_W, base_cop1_s, syn_cop1},
{ "floor.w.s", R4300i_COP1_FUNCT_FLOOR_W, base_cop1_s, syn_cop1 }, {"floor.w.s", R4300i_COP1_FUNCT_FLOOR_W, base_cop1_s, syn_cop1},
{ "cvt.s.s", R4300i_COP1_FUNCT_CVT_S, base_cop1_s, syn_cop1 }, {"cvt.s.s", R4300i_COP1_FUNCT_CVT_S, base_cop1_s, syn_cop1},
{ "cvt.d.s", R4300i_COP1_FUNCT_CVT_D, base_cop1_s, syn_cop1 }, {"cvt.d.s", R4300i_COP1_FUNCT_CVT_D, base_cop1_s, syn_cop1},
{ "cvt.w.s", R4300i_COP1_FUNCT_CVT_W, base_cop1_s, syn_cop1 }, {"cvt.w.s", R4300i_COP1_FUNCT_CVT_W, base_cop1_s, syn_cop1},
{ "cvt.l.s", R4300i_COP1_FUNCT_CVT_L, base_cop1_s, syn_cop1 }, {"cvt.l.s", R4300i_COP1_FUNCT_CVT_L, base_cop1_s, syn_cop1},
{ "c.f.s", R4300i_COP1_FUNCT_C_F, base_cop1_s, syn_cop1_cmp }, {"c.f.s", R4300i_COP1_FUNCT_C_F, base_cop1_s, syn_cop1_cmp},
{ "c.un.s", R4300i_COP1_FUNCT_C_UN, base_cop1_s, syn_cop1_cmp }, {"c.un.s", R4300i_COP1_FUNCT_C_UN, base_cop1_s, syn_cop1_cmp},
{ "c.eq.s", R4300i_COP1_FUNCT_C_EQ, base_cop1_s, syn_cop1_cmp }, {"c.eq.s", R4300i_COP1_FUNCT_C_EQ, base_cop1_s, syn_cop1_cmp},
{ "c.ueq.s", R4300i_COP1_FUNCT_C_UEQ, base_cop1_s, syn_cop1_cmp }, {"c.ueq.s", R4300i_COP1_FUNCT_C_UEQ, base_cop1_s, syn_cop1_cmp},
{ "c.olt.s", R4300i_COP1_FUNCT_C_OLT, base_cop1_s, syn_cop1_cmp }, {"c.olt.s", R4300i_COP1_FUNCT_C_OLT, base_cop1_s, syn_cop1_cmp},
{ "c.ult.s", R4300i_COP1_FUNCT_C_ULT, base_cop1_s, syn_cop1_cmp }, {"c.ult.s", R4300i_COP1_FUNCT_C_ULT, base_cop1_s, syn_cop1_cmp},
{ "c.ole.s", R4300i_COP1_FUNCT_C_OLE, base_cop1_s, syn_cop1_cmp }, {"c.ole.s", R4300i_COP1_FUNCT_C_OLE, base_cop1_s, syn_cop1_cmp},
{ "c.ule.s", R4300i_COP1_FUNCT_C_ULE, base_cop1_s, syn_cop1_cmp }, {"c.ule.s", R4300i_COP1_FUNCT_C_ULE, base_cop1_s, syn_cop1_cmp},
{ "c.sf.s", R4300i_COP1_FUNCT_C_SF, base_cop1_s, syn_cop1_cmp }, {"c.sf.s", R4300i_COP1_FUNCT_C_SF, base_cop1_s, syn_cop1_cmp},
{ "c.ngle.s", R4300i_COP1_FUNCT_C_NGLE, base_cop1_s, syn_cop1_cmp }, {"c.ngle.s", R4300i_COP1_FUNCT_C_NGLE, base_cop1_s, syn_cop1_cmp},
{ "c.seq.s", R4300i_COP1_FUNCT_C_SEQ, base_cop1_s, syn_cop1_cmp }, {"c.seq.s", R4300i_COP1_FUNCT_C_SEQ, base_cop1_s, syn_cop1_cmp},
{ "c.ngl.s", R4300i_COP1_FUNCT_C_NGL, base_cop1_s, syn_cop1_cmp }, {"c.ngl.s", R4300i_COP1_FUNCT_C_NGL, base_cop1_s, syn_cop1_cmp},
{ "c.lt.s", R4300i_COP1_FUNCT_C_LT, base_cop1_s, syn_cop1_cmp }, {"c.lt.s", R4300i_COP1_FUNCT_C_LT, base_cop1_s, syn_cop1_cmp},
{ "c.nge.s", R4300i_COP1_FUNCT_C_NGE, base_cop1_s, syn_cop1_cmp }, {"c.nge.s", R4300i_COP1_FUNCT_C_NGE, base_cop1_s, syn_cop1_cmp},
{ "c.le.s", R4300i_COP1_FUNCT_C_LE, base_cop1_s, syn_cop1_cmp }, {"c.le.s", R4300i_COP1_FUNCT_C_LE, base_cop1_s, syn_cop1_cmp},
{ "c.ngt.s", R4300i_COP1_FUNCT_C_NGT, base_cop1_s, syn_cop1_cmp }, {"c.ngt.s", R4300i_COP1_FUNCT_C_NGT, base_cop1_s, syn_cop1_cmp},
{ "add.d", R4300i_COP1_FUNCT_ADD, base_cop1_d, syn_cop1_arith }, {"add.d", R4300i_COP1_FUNCT_ADD, base_cop1_d, syn_cop1_arith},
{ "sub.d", R4300i_COP1_FUNCT_SUB, base_cop1_d, syn_cop1_arith }, {"sub.d", R4300i_COP1_FUNCT_SUB, base_cop1_d, syn_cop1_arith},
{ "mul.d", R4300i_COP1_FUNCT_MUL, base_cop1_d, syn_cop1_arith }, {"mul.d", R4300i_COP1_FUNCT_MUL, base_cop1_d, syn_cop1_arith},
{ "div.d", R4300i_COP1_FUNCT_DIV, base_cop1_d, syn_cop1_arith }, {"div.d", R4300i_COP1_FUNCT_DIV, base_cop1_d, syn_cop1_arith},
{ "sqrt.d", R4300i_COP1_FUNCT_SQRT, base_cop1_d, syn_cop1 }, {"sqrt.d", R4300i_COP1_FUNCT_SQRT, base_cop1_d, syn_cop1},
{ "abs.d", R4300i_COP1_FUNCT_ABS, base_cop1_d, syn_cop1 }, {"abs.d", R4300i_COP1_FUNCT_ABS, base_cop1_d, syn_cop1},
{ "mov.d", R4300i_COP1_FUNCT_MOV, base_cop1_d, syn_cop1 }, {"mov.d", R4300i_COP1_FUNCT_MOV, base_cop1_d, syn_cop1},
{ "neg.d", R4300i_COP1_FUNCT_NEG, base_cop1_d, syn_cop1 }, {"neg.d", R4300i_COP1_FUNCT_NEG, base_cop1_d, syn_cop1},
{ "round.l.d", R4300i_COP1_FUNCT_ROUND_L, base_cop1_d, syn_cop1 }, {"round.l.d", R4300i_COP1_FUNCT_ROUND_L, base_cop1_d, syn_cop1},
{ "trunc.l.d", R4300i_COP1_FUNCT_TRUNC_L, base_cop1_d, syn_cop1 }, {"trunc.l.d", R4300i_COP1_FUNCT_TRUNC_L, base_cop1_d, syn_cop1},
{ "ceil.l.d", R4300i_COP1_FUNCT_CEIL_L, base_cop1_d, syn_cop1 }, {"ceil.l.d", R4300i_COP1_FUNCT_CEIL_L, base_cop1_d, syn_cop1},
{ "floor.l.d", R4300i_COP1_FUNCT_FLOOR_L, base_cop1_d, syn_cop1 }, {"floor.l.d", R4300i_COP1_FUNCT_FLOOR_L, base_cop1_d, syn_cop1},
{ "round.w.d", R4300i_COP1_FUNCT_ROUND_W, base_cop1_d, syn_cop1 }, {"round.w.d", R4300i_COP1_FUNCT_ROUND_W, base_cop1_d, syn_cop1},
{ "trunc.w.d", R4300i_COP1_FUNCT_TRUNC_W, base_cop1_d, syn_cop1 }, {"trunc.w.d", R4300i_COP1_FUNCT_TRUNC_W, base_cop1_d, syn_cop1},
{ "ceil.w.d", R4300i_COP1_FUNCT_CEIL_W, base_cop1_d, syn_cop1 }, {"ceil.w.d", R4300i_COP1_FUNCT_CEIL_W, base_cop1_d, syn_cop1},
{ "floor.w.d", R4300i_COP1_FUNCT_FLOOR_W, base_cop1_d, syn_cop1 }, {"floor.w.d", R4300i_COP1_FUNCT_FLOOR_W, base_cop1_d, syn_cop1},
{ "cvt.s.d", R4300i_COP1_FUNCT_CVT_S, base_cop1_d, syn_cop1 }, {"cvt.s.d", R4300i_COP1_FUNCT_CVT_S, base_cop1_d, syn_cop1},
{ "cvt.d.d", R4300i_COP1_FUNCT_CVT_D, base_cop1_d, syn_cop1 }, {"cvt.d.d", R4300i_COP1_FUNCT_CVT_D, base_cop1_d, syn_cop1},
{ "cvt.w.d", R4300i_COP1_FUNCT_CVT_W, base_cop1_d, syn_cop1 }, {"cvt.w.d", R4300i_COP1_FUNCT_CVT_W, base_cop1_d, syn_cop1},
{ "cvt.l.d", R4300i_COP1_FUNCT_CVT_L, base_cop1_d, syn_cop1 }, {"cvt.l.d", R4300i_COP1_FUNCT_CVT_L, base_cop1_d, syn_cop1},
{ "c.f.d", R4300i_COP1_FUNCT_C_F, base_cop1_d, syn_cop1_cmp }, {"c.f.d", R4300i_COP1_FUNCT_C_F, base_cop1_d, syn_cop1_cmp},
{ "c.un.d", R4300i_COP1_FUNCT_C_UN, base_cop1_d, syn_cop1_cmp }, {"c.un.d", R4300i_COP1_FUNCT_C_UN, base_cop1_d, syn_cop1_cmp},
{ "c.eq.d", R4300i_COP1_FUNCT_C_EQ, base_cop1_d, syn_cop1_cmp }, {"c.eq.d", R4300i_COP1_FUNCT_C_EQ, base_cop1_d, syn_cop1_cmp},
{ "c.ueq.d", R4300i_COP1_FUNCT_C_UEQ, base_cop1_d, syn_cop1_cmp }, {"c.ueq.d", R4300i_COP1_FUNCT_C_UEQ, base_cop1_d, syn_cop1_cmp},
{ "c.olt.d", R4300i_COP1_FUNCT_C_OLT, base_cop1_d, syn_cop1_cmp }, {"c.olt.d", R4300i_COP1_FUNCT_C_OLT, base_cop1_d, syn_cop1_cmp},
{ "c.ult.d", R4300i_COP1_FUNCT_C_ULT, base_cop1_d, syn_cop1_cmp }, {"c.ult.d", R4300i_COP1_FUNCT_C_ULT, base_cop1_d, syn_cop1_cmp},
{ "c.ole.d", R4300i_COP1_FUNCT_C_OLE, base_cop1_d, syn_cop1_cmp }, {"c.ole.d", R4300i_COP1_FUNCT_C_OLE, base_cop1_d, syn_cop1_cmp},
{ "c.ule.d", R4300i_COP1_FUNCT_C_ULE, base_cop1_d, syn_cop1_cmp }, {"c.ule.d", R4300i_COP1_FUNCT_C_ULE, base_cop1_d, syn_cop1_cmp},
{ "c.sf.d", R4300i_COP1_FUNCT_C_SF, base_cop1_d, syn_cop1_cmp }, {"c.sf.d", R4300i_COP1_FUNCT_C_SF, base_cop1_d, syn_cop1_cmp},
{ "c.ngle.d", R4300i_COP1_FUNCT_C_NGLE, base_cop1_d, syn_cop1_cmp }, {"c.ngle.d", R4300i_COP1_FUNCT_C_NGLE, base_cop1_d, syn_cop1_cmp},
{ "c.seq.d", R4300i_COP1_FUNCT_C_SEQ, base_cop1_d, syn_cop1_cmp }, {"c.seq.d", R4300i_COP1_FUNCT_C_SEQ, base_cop1_d, syn_cop1_cmp},
{ "c.ngl.d", R4300i_COP1_FUNCT_C_NGL, base_cop1_d, syn_cop1_cmp }, {"c.ngl.d", R4300i_COP1_FUNCT_C_NGL, base_cop1_d, syn_cop1_cmp},
{ "c.lt.d", R4300i_COP1_FUNCT_C_LT, base_cop1_d, syn_cop1_cmp }, {"c.lt.d", R4300i_COP1_FUNCT_C_LT, base_cop1_d, syn_cop1_cmp},
{ "c.nge.d", R4300i_COP1_FUNCT_C_NGE, base_cop1_d, syn_cop1_cmp }, {"c.nge.d", R4300i_COP1_FUNCT_C_NGE, base_cop1_d, syn_cop1_cmp},
{ "c.le.d", R4300i_COP1_FUNCT_C_LE, base_cop1_d, syn_cop1_cmp }, {"c.le.d", R4300i_COP1_FUNCT_C_LE, base_cop1_d, syn_cop1_cmp},
{ "c.ngt.d", R4300i_COP1_FUNCT_C_NGT, base_cop1_d, syn_cop1_cmp }, {"c.ngt.d", R4300i_COP1_FUNCT_C_NGT, base_cop1_d, syn_cop1_cmp},
{ "cvt.s.w", R4300i_COP1_FUNCT_CVT_S, base_cop1_w, syn_cop1 }, {"cvt.s.w", R4300i_COP1_FUNCT_CVT_S, base_cop1_w, syn_cop1},
{ "cvt.d.w", R4300i_COP1_FUNCT_CVT_D, base_cop1_w, syn_cop1 }, {"cvt.d.w", R4300i_COP1_FUNCT_CVT_D, base_cop1_w, syn_cop1},
{ "cvt.s.l", R4300i_COP1_FUNCT_CVT_S, base_cop1_l, syn_cop1 }, {"cvt.s.l", R4300i_COP1_FUNCT_CVT_S, base_cop1_l, syn_cop1},
{ "cvt.d.l", R4300i_COP1_FUNCT_CVT_D, base_cop1_l, syn_cop1 }, {"cvt.d.l", R4300i_COP1_FUNCT_CVT_D, base_cop1_l, syn_cop1},
{ nullptr } {nullptr},
}; };
const ASM_REGISTER CAssembler::m_Registers[] = const ASM_REGISTER CAssembler::m_Registers[] = {
{ {"r0", 0},
{ "r0", 0 },{ "at", 1 },{ "v0", 2 },{ "v1", 3 },{ "a0", 4 },{ "a1", 5 },{ "a2", 6 },{ "a3", 7 }, {"at", 1},
{ "t0", 8 },{ "t1", 9 },{ "t2", 10 },{ "t3", 11 },{ "t4", 12 },{ "t5", 13 },{ "t6", 14 },{ "t7", 15 }, {"v0", 2},
{ "s0", 16 },{ "s1", 17 },{ "s2", 18 },{ "s3", 19 },{ "s4", 20 },{ "s5", 21 },{ "s6", 22 },{ "s7", 23 }, {"v1", 3},
{ "t8", 24 },{ "t9", 25 },{ "k0", 26 },{ "k1", 27 },{ "gp", 28 },{ "sp", 29 },{ "s8", 30 },{ "ra", 31 }, {"a0", 4},
{"a1", 5},
{"a2", 6},
{"a3", 7},
{"t0", 8},
{"t1", 9},
{"t2", 10},
{"t3", 11},
{"t4", 12},
{"t5", 13},
{"t6", 14},
{"t7", 15},
{"s0", 16},
{"s1", 17},
{"s2", 18},
{"s3", 19},
{"s4", 20},
{"s5", 21},
{"s6", 22},
{"s7", 23},
{"t8", 24},
{"t9", 25},
{"k0", 26},
{"k1", 27},
{"gp", 28},
{"sp", 29},
{"s8", 30},
{"ra", 31},
{ "fp", 30 }, {"fp", 30},
{ "r0", 0 },{ "r1", 1 },{ "r2", 2 },{ "r3", 3 },{ "r4", 4 },{ "r5", 5 },{ "r6", 6 },{ "r7", 7 }, {"r0", 0},
{ "r8", 8 },{ "r9", 9 },{ "r10", 10 },{ "r11", 11 },{ "r12", 12 },{ "r13", 13 },{ "r14", 14 },{ "r15", 15 }, {"r1", 1},
{ "r16", 16 },{ "r17", 17 },{ "r18", 18 },{ "r19", 19 },{ "r20", 20 },{ "r21", 21 },{ "r22", 22 },{ "r23", 23 }, {"r2", 2},
{ "r24", 24 },{ "r25", 25 },{ "r26", 26 },{ "r27", 27 },{ "r28", 28 },{ "r29", 29 },{ "r30", 30 },{ "r31", 31 }, {"r3", 3},
{"r4", 4},
{"r5", 5},
{"r6", 6},
{"r7", 7},
{"r8", 8},
{"r9", 9},
{"r10", 10},
{"r11", 11},
{"r12", 12},
{"r13", 13},
{"r14", 14},
{"r15", 15},
{"r16", 16},
{"r17", 17},
{"r18", 18},
{"r19", 19},
{"r20", 20},
{"r21", 21},
{"r22", 22},
{"r23", 23},
{"r24", 24},
{"r25", 25},
{"r26", 26},
{"r27", 27},
{"r28", 28},
{"r29", 29},
{"r30", 30},
{"r31", 31},
{ "f0", 0 },{ "f1", 1 },{ "f2", 2 },{ "f3", 3 },{ "f4", 4 },{ "f5", 5 },{ "f6", 6 },{ "f7", 7 }, {"f0", 0},
{ "f8", 8 },{ "f9", 9 },{ "f10", 10 },{ "f11", 11 },{ "f12", 12 },{ "f13", 13 },{ "f14", 14 },{ "f15", 15 }, {"f1", 1},
{ "f16", 16 },{ "f17", 17 },{ "f18", 18 },{ "f19", 19 },{ "f20", 20 },{ "f21", 21 },{ "f22", 22 },{ "f23", 23 }, {"f2", 2},
{ "f24", 24 },{ "f25", 25 },{ "f26", 26 },{ "f27", 27 },{ "f28", 28 },{ "f29", 29 },{ "f30", 30 },{ "f31", 31 }, {"f3", 3},
{"f4", 4},
{"f5", 5},
{"f6", 6},
{"f7", 7},
{"f8", 8},
{"f9", 9},
{"f10", 10},
{"f11", 11},
{"f12", 12},
{"f13", 13},
{"f14", 14},
{"f15", 15},
{"f16", 16},
{"f17", 17},
{"f18", 18},
{"f19", 19},
{"f20", 20},
{"f21", 21},
{"f22", 22},
{"f23", 23},
{"f24", 24},
{"f25", 25},
{"f26", 26},
{"f27", 27},
{"f28", 28},
{"f29", 29},
{"f30", 30},
{"f31", 31},
{ "revision", 0 },{ "fcsr", 31 },{ "fcs", 31 }, {"revision", 0},
{"fcsr", 31},
{"fcs", 31},
{ "index", 0 },{ "random", 1 },{ "entrylo0", 2 },{ "entrylo1", 3 },{ "context", 4 },{ "pagemask", 5 }, {"index", 0},
{ "wired", 6 },{ "badvaddr", 8 },{ "count", 9 },{ "entryhi", 10 },{ "compare", 11 },{ "status", 12 }, {"random", 1},
{ "cause", 13 },{ "epc", 14 },{ "prid", 15 },{ "config", 16 },{ "lladdr", 17 },{ "watchlo", 18 }, {"entrylo0", 2},
{ "watchhi", 19 },{ "xcontext", 20 },{ "ecc", 26 },{ "cacheerr", 27 },{ "taglo", 28 },{ "taghi", 29 }, {"entrylo1", 3},
{ "errepc", 30 }, {"context", 4},
{"pagemask", 5},
{"wired", 6},
{"badvaddr", 8},
{"count", 9},
{"entryhi", 10},
{"compare", 11},
{"status", 12},
{"cause", 13},
{"epc", 14},
{"prid", 15},
{"config", 16},
{"lladdr", 17},
{"watchlo", 18},
{"watchhi", 19},
{"xcontext", 20},
{"ecc", 26},
{"cacheerr", 27},
{"taglo", 28},
{"taghi", 29},
{"errepc", 30},
{ nullptr } {nullptr},
}; };
bool CAssembler::AssembleLine(const char * line, uint32_t * opcode, uint32_t address) bool CAssembler::AssembleLine(const char * line, uint32_t * opcode, uint32_t address)

50
Source/Project64/UserInterface/Debugger/Assembler.h
View File

@ -2,17 +2,19 @@
#include <stdint.h> #include <stdint.h>
typedef void(*ASM_SYNTAX_FN)(uint32_t* opcode); typedef void (*ASM_SYNTAX_FN)(uint32_t * opcode);
typedef struct { typedef struct
const char* name; {
const char * name;
uint32_t val; uint32_t val;
uint32_t(*base)(uint32_t val); // Value shift uint32_t (*base)(uint32_t val); // Value shift
const ASM_SYNTAX_FN* syntax; // Arguments const ASM_SYNTAX_FN * syntax; // Arguments
} ASM_INSTRUCTION; } ASM_INSTRUCTION;
typedef struct { typedef struct
const char* name; {
const char * name;
uint32_t val; uint32_t val;
} ASM_REGISTER; } ASM_REGISTER;
@ -32,7 +34,7 @@ private:
static ASM_PARSE_ERROR m_ParseError; static ASM_PARSE_ERROR m_ParseError;
public: public:
static bool AssembleLine(const char* line, uint32_t* opcode, uint32_t address = 0x00000000); static bool AssembleLine(const char * line, uint32_t * opcode, uint32_t address = 0x00000000);
private: private:
static const ASM_SYNTAX_FN syn_jump[]; static const ASM_SYNTAX_FN syn_jump[];
@ -60,12 +62,12 @@ private:
static const ASM_INSTRUCTION m_Instructions[]; static const ASM_INSTRUCTION m_Instructions[];
static const ASM_REGISTER m_Registers[]; static const ASM_REGISTER m_Registers[];
static char* m_TokContext; static char * m_TokContext;
static const ASM_REGISTER* LookupRegister(char* name); static const ASM_REGISTER * LookupRegister(char * name);
static const ASM_INSTRUCTION* LookupInstruction(char* name, int nFallback); static const ASM_INSTRUCTION * LookupInstruction(char * name, int nFallback);
static void StrToLower(char* str); static void StrToLower(char * str);
static uint32_t pop_reg(); static uint32_t pop_reg();
static uint32_t pop_val(); static uint32_t pop_val();
@ -83,16 +85,16 @@ private:
static uint32_t base_cop0_mv(uint32_t val); static uint32_t base_cop0_mv(uint32_t val);
static uint32_t base_cop1_mv(uint32_t val); static uint32_t base_cop1_mv(uint32_t val);
static void arg_reg_t(uint32_t* opcode); static void arg_reg_t(uint32_t * opcode);
static void arg_reg_s(uint32_t* opcode); static void arg_reg_s(uint32_t * opcode);
static void arg_reg_d(uint32_t* opcode); static void arg_reg_d(uint32_t * opcode);
static void arg_reg_ft(uint32_t* opcode); static void arg_reg_ft(uint32_t * opcode);
static void arg_reg_fs(uint32_t* opcode); static void arg_reg_fs(uint32_t * opcode);
static void arg_reg_fd(uint32_t* opcode); static void arg_reg_fd(uint32_t * opcode);
static void arg_jump(uint32_t* opcode); static void arg_jump(uint32_t * opcode);
static void arg_imm16(uint32_t* opcode); static void arg_imm16(uint32_t * opcode);
static void arg_bra_target(uint32_t* opcode); static void arg_bra_target(uint32_t * opcode);
static void arg_shamt(uint32_t* opcode); static void arg_shamt(uint32_t * opcode);
static void arg_cache_op(uint32_t* opcode); static void arg_cache_op(uint32_t * opcode);
static void arg_syscall_code(uint32_t* opcode); static void arg_syscall_code(uint32_t * opcode);
}; };

41
Source/Project64/UserInterface/Debugger/Breakpoints.cpp
View File

@ -354,12 +354,41 @@ void CBreakpoints::UpdateHaveRegBP(void)
m_bHaveRegBP = HaveAnyGPRWriteBP() || HaveAnyGPRReadBP() || HaveHIWriteBP() || HaveHIReadBP() || HaveLOWriteBP() || HaveLOReadBP(); m_bHaveRegBP = HaveAnyGPRWriteBP() || HaveAnyGPRReadBP() || HaveHIWriteBP() || HaveHIReadBP() || HaveLOWriteBP() || HaveLOReadBP();
} }
void CBreakpoints::ToggleGPRWriteBP(int nReg) { m_GPRWriteBP ^= (1 << nReg); UpdateHaveRegBP(); } void CBreakpoints::ToggleGPRWriteBP(int nReg)
void CBreakpoints::ToggleGPRReadBP(int nReg) { m_GPRReadBP ^= (1 << nReg); UpdateHaveRegBP(); } {
void CBreakpoints::ToggleHIWriteBP(void) { m_HIWriteBP = !m_HIWriteBP; UpdateHaveRegBP(); } m_GPRWriteBP ^= (1 << nReg);
void CBreakpoints::ToggleHIReadBP(void) { m_HIReadBP = !m_HIReadBP; UpdateHaveRegBP(); } UpdateHaveRegBP();
void CBreakpoints::ToggleLOWriteBP(void) { m_LOWriteBP = !m_LOWriteBP; UpdateHaveRegBP(); } }
void CBreakpoints::ToggleLOReadBP(void) { m_LOReadBP = !m_LOReadBP; UpdateHaveRegBP(); }
void CBreakpoints::ToggleGPRReadBP(int nReg)
{
m_GPRReadBP ^= (1 << nReg);
UpdateHaveRegBP();
}
void CBreakpoints::ToggleHIWriteBP(void)
{
m_HIWriteBP = !m_HIWriteBP;
UpdateHaveRegBP();
}
void CBreakpoints::ToggleHIReadBP(void)
{
m_HIReadBP = !m_HIReadBP;
UpdateHaveRegBP();
}
void CBreakpoints::ToggleLOWriteBP(void)
{
m_LOWriteBP = !m_LOWriteBP;
UpdateHaveRegBP();
}
void CBreakpoints::ToggleLOReadBP(void)
{
m_LOReadBP = !m_LOReadBP;
UpdateHaveRegBP();
}
void CBreakpoints::PreUpdateBP() void CBreakpoints::PreUpdateBP()
{ {

62
Source/Project64/UserInterface/Debugger/Breakpoints.h
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <stdint.h>
#include <map> #include <map>
#include <stdint.h>
class CBreakpoints : class CBreakpoints :
private CDebugSettings private CDebugSettings
@ -20,9 +20,18 @@ public:
CBreakpoints(); CBreakpoints();
const breakpoints_t & ReadMem(void) const { return m_ReadMem; } const breakpoints_t & ReadMem(void) const
const breakpoints_t & WriteMem(void) const { return m_WriteMem; } {
const breakpoints_t & Execution(void) const { return m_Execution; } return m_ReadMem;
}
const breakpoints_t & WriteMem(void) const
{
return m_WriteMem;
}
const breakpoints_t & Execution(void) const
{
return m_Execution;
}
BPSTATE ReadBPExists8(uint32_t address); BPSTATE ReadBPExists8(uint32_t address);
BPSTATE ReadBPExists16(uint32_t address); BPSTATE ReadBPExists16(uint32_t address);
@ -57,15 +66,42 @@ public:
void ClearMemLocks(void); void ClearMemLocks(void);
size_t NumMemLocks(void); size_t NumMemLocks(void);
inline bool HaveRegBP(void) { return m_bHaveRegBP; } inline bool HaveRegBP(void)
inline bool HaveAnyGPRWriteBP(void) { return m_GPRWriteBP != 0; } {
inline bool HaveAnyGPRReadBP(void) { return m_GPRReadBP != 0; } return m_bHaveRegBP;
inline bool HaveGPRWriteBP(int nReg) { return (m_GPRWriteBP & (1 << nReg)) != 0; } }
inline bool HaveGPRReadBP(int nReg) { return (m_GPRReadBP & (1 << nReg)) != 0; } inline bool HaveAnyGPRWriteBP(void)
inline bool HaveHIWriteBP(void) { return m_HIWriteBP; } {
inline bool HaveHIReadBP(void) { return m_HIReadBP; } return m_GPRWriteBP != 0;
inline bool HaveLOWriteBP(void) { return m_LOWriteBP; } }
inline bool HaveLOReadBP(void) { return m_LOReadBP; } inline bool HaveAnyGPRReadBP(void)
{
return m_GPRReadBP != 0;
}
inline bool HaveGPRWriteBP(int nReg)
{
return (m_GPRWriteBP & (1 << nReg)) != 0;
}
inline bool HaveGPRReadBP(int nReg)
{
return (m_GPRReadBP & (1 << nReg)) != 0;
}
inline bool HaveHIWriteBP(void)
{
return m_HIWriteBP;
}
inline bool HaveHIReadBP(void)
{
return m_HIReadBP;
}
inline bool HaveLOWriteBP(void)
{
return m_LOWriteBP;
}
inline bool HaveLOReadBP(void)
{
return m_LOReadBP;
}
void UpdateHaveRegBP(void); void UpdateHaveRegBP(void);
void ToggleGPRWriteBP(int nReg); void ToggleGPRWriteBP(int nReg);

8
Source/Project64/UserInterface/Debugger/CPULog.h
View File

@ -16,7 +16,7 @@ class CCPULog
size_t m_Size; size_t m_Size;
bool m_bMaxed; bool m_bMaxed;
size_t m_Index; size_t m_Index;
CPUState* m_Array; CPUState * m_Array;
public: public:
CCPULog(size_t size = 0); CCPULog(size_t size = 0);
@ -24,8 +24,8 @@ public:
void PushState(void); void PushState(void);
size_t GetCount(void); size_t GetCount(void);
size_t GetSize(void); size_t GetSize(void);
CPUState* GetEntry(size_t index); CPUState * GetEntry(size_t index);
void Reset(void); void Reset(void);
CCPULog* Clone(void); CCPULog * Clone(void);
void DumpToFile(const char* path); void DumpToFile(const char * path);
}; };

16
Source/Project64/UserInterface/Debugger/DMALog.h
View File

@ -13,12 +13,12 @@ private:
vector<DMALOGENTRY> m_Log; vector<DMALOGENTRY> m_Log;
public: public:
void AddEntry(uint32_t romAddr, uint32_t ramAddr, uint32_t length); void AddEntry(uint32_t romAddr, uint32_t ramAddr, uint32_t length);
void ClearEntries(); void ClearEntries();
size_t GetNumEntries(); size_t GetNumEntries();
DMALOGENTRY* GetEntryByIndex(uint32_t index); DMALOGENTRY * GetEntryByIndex(uint32_t index);
DMALOGENTRY* GetEntryByRamAddress(uint32_t ramAddr); DMALOGENTRY * GetEntryByRamAddress(uint32_t ramAddr);
DMALOGENTRY* GetEntryByRamAddress(uint32_t ramAddr, uint32_t* lpRomAddr, uint32_t* lpOffset); DMALOGENTRY * GetEntryByRamAddress(uint32_t ramAddr, uint32_t * lpRomAddr, uint32_t * lpOffset);
DMALOGENTRY* GetEntryByRomAddress(uint32_t romAddr); DMALOGENTRY * GetEntryByRomAddress(uint32_t romAddr);
DMALOGENTRY* GetEntryByRomAddress(uint32_t romAddr, uint32_t* lpRamAddr, uint32_t* lpOffset); DMALOGENTRY * GetEntryByRomAddress(uint32_t romAddr, uint32_t * lpRamAddr, uint32_t * lpOffset);
}; };

30
Source/Project64/UserInterface/Debugger/DebugDialog.h
View File

@ -3,14 +3,14 @@
#include <Project64-core/Settings/SettingType/SettingsType-Application.h> #include <Project64-core/Settings/SettingType/SettingsType-Application.h>
template <class T> template <class T>
class CDebugDialog : class CDebugDialog :
public CDialogImpl < T > public CDialogImpl<T>
{ {
protected: protected:
CDebuggerUI * m_Debugger; CDebuggerUI * m_Debugger;
HANDLE m_CreatedEvent; HANDLE m_CreatedEvent;
HANDLE m_DialogThread; HANDLE m_DialogThread;
UISettingID m_UISettingID; UISettingID m_UISettingID;
bool m_bInitialized; bool m_bInitialized;
static DWORD CreateDebuggerWindow(CDebugDialog<T> * pThis) static DWORD CreateDebuggerWindow(CDebugDialog<T> * pThis)
{ {
@ -38,7 +38,7 @@ protected:
return; return;
} }
T* pT = static_cast<T*>(this); T * pT = static_cast<T *>(this);
std::string str = UISettingsLoadStringVal(m_UISettingID); std::string str = UISettingsLoadStringVal(m_UISettingID);
int left, top, width, height; int left, top, width, height;
int nParams = sscanf(str.c_str(), "%d,%d,%d,%d", &left, &top, &width, &height); int nParams = sscanf(str.c_str(), "%d,%d,%d,%d", &left, &top, &width, &height);
@ -47,7 +47,8 @@ protected:
pT->SetWindowPos(nullptr, left, top, width, height, 0); pT->SetWindowPos(nullptr, left, top, width, height, 0);
pT->RedrawWindow(); pT->RedrawWindow();
} }
if (nParams == 2) { if (nParams == 2)
{
pT->SetWindowPos(nullptr, left, top, width, height, 1); pT->SetWindowPos(nullptr, left, top, width, height, 1);
pT->RedrawWindow(); pT->RedrawWindow();
} }
@ -60,13 +61,15 @@ protected:
return; return;
} }
T* pT = static_cast<T*>(this); T * pT = static_cast<T *>(this);
CRect rect; CRect rect;
pT->GetWindowRect(&rect); pT->GetWindowRect(&rect);
if (!bSaveSize) { if (!bSaveSize)
{
UISettingsSaveString(m_UISettingID, stdstr_f("%d,%d", rect.left, rect.top).c_str()); UISettingsSaveString(m_UISettingID, stdstr_f("%d,%d", rect.left, rect.top).c_str());
} }
else { else
{
UISettingsSaveString(m_UISettingID, stdstr_f("%d,%d,%d,%d", rect.left, rect.top, rect.Width(), rect.Height()).c_str()); UISettingsSaveString(m_UISettingID, stdstr_f("%d,%d,%d,%d", rect.left, rect.top, rect.Width(), rect.Height()).c_str());
} }
} }
@ -129,8 +132,9 @@ public:
SetForegroundWindow((HWND)m_hWnd); SetForegroundWindow((HWND)m_hWnd);
} }
} }
private: private:
bool m_SaveWnd; bool m_SaveWnd;
LONG m_SaveWndTop; LONG m_SaveWndTop;
LONG m_SaveWndLeft; LONG m_SaveWndLeft;
}; };

62
Source/Project64/UserInterface/Debugger/DebugMMU.h
View File

@ -3,16 +3,17 @@
class CDebugMMU class CDebugMMU
{ {
public: public:
size_t ReadPhysical(uint32_t paddr, size_t length, uint8_t* buffer); size_t ReadPhysical(uint32_t paddr, size_t length, uint8_t * buffer);
size_t ReadVirtual(uint32_t vaddr, size_t length, uint8_t* buffer); size_t ReadVirtual(uint32_t vaddr, size_t length, uint8_t * buffer);
size_t WritePhysical(uint32_t paddr, size_t length, uint8_t* buffer); size_t WritePhysical(uint32_t paddr, size_t length, uint8_t * buffer);
size_t WriteVirtual(uint32_t vaddr, size_t length, uint8_t* buffer); size_t WriteVirtual(uint32_t vaddr, size_t length, uint8_t * buffer);
template<typename T> template <typename T>
bool DebugLoad_PAddr(uint32_t paddr, T& value) bool DebugLoad_PAddr(uint32_t paddr, T & value)
{ {
union { union
T word; {
T word;
uint8_t bytes[sizeof(T)]; uint8_t bytes[sizeof(T)];
} buffer; } buffer;
@ -25,11 +26,12 @@ public:
return false; return false;
} }
template<typename T> template <typename T>
bool DebugLoad_VAddr(uint32_t vaddr, T& value) bool DebugLoad_VAddr(uint32_t vaddr, T & value)
{ {
union { union
T word; {
T word;
uint8_t bytes[sizeof(T)]; uint8_t bytes[sizeof(T)];
} buffer; } buffer;
@ -42,39 +44,41 @@ public:
return false; return false;
} }
template<typename T> template <typename T>
bool DebugStore_PAddr(uint32_t paddr, T value) bool DebugStore_PAddr(uint32_t paddr, T value)
{ {
union { union
T word; {
T word;
uint8_t bytes[sizeof(T)]; uint8_t bytes[sizeof(T)];
} buffer = { ByteSwap<T>(value) }; } buffer = {ByteSwap<T>(value)};
return (WritePhysical(paddr, sizeof(buffer), buffer.bytes) == sizeof(buffer)); return (WritePhysical(paddr, sizeof(buffer), buffer.bytes) == sizeof(buffer));
} }
template<typename T> template <typename T>
bool DebugStore_VAddr(uint32_t vaddr, T value) bool DebugStore_VAddr(uint32_t vaddr, T value)
{ {
union { union
T word; {
T word;
uint8_t bytes[sizeof(T)]; uint8_t bytes[sizeof(T)];
} buffer = { ByteSwap<T>(value) }; } buffer = {ByteSwap<T>(value)};
return (WriteVirtual(vaddr, sizeof(buffer), buffer.bytes) == sizeof(buffer)); return (WriteVirtual(vaddr, sizeof(buffer), buffer.bytes) == sizeof(buffer));
} }
private: private:
uint8_t* GetPhysicalPtr(uint32_t paddr, WORD* flags = nullptr); uint8_t * GetPhysicalPtr(uint32_t paddr, WORD * flags = nullptr);
bool GetPhysicalByte(uint32_t paddr, uint8_t* value); bool GetPhysicalByte(uint32_t paddr, uint8_t * value);
bool SetPhysicalByte(uint32_t paddr, uint8_t value); bool SetPhysicalByte(uint32_t paddr, uint8_t value);
template<typename T> template <typename T>
T ByteSwap(T value) T ByteSwap(T value)
{ {
union union
{ {
T value; T value;
uint16_t u16; uint16_t u16;
uint32_t u32; uint32_t u32;
uint64_t u64; uint64_t u64;
@ -84,15 +88,15 @@ private:
switch (sizeof(T)) switch (sizeof(T))
{ {
case sizeof(uint8_t) : case sizeof(uint8_t):
break; break;
case sizeof(uint16_t) : case sizeof(uint16_t):
bytes.u16 = _byteswap_ushort(bytes.u16); bytes.u16 = _byteswap_ushort(bytes.u16);
break; break;
case sizeof(uint32_t) : case sizeof(uint32_t):
bytes.u32 = _byteswap_ulong(bytes.u32); bytes.u32 = _byteswap_ulong(bytes.u32);
break; break;
case sizeof(uint64_t) : case sizeof(uint64_t):
bytes.u64 = _byteswap_uint64(bytes.u64); bytes.u64 = _byteswap_uint64(bytes.u64);
break; break;
default: default:

23
Source/Project64/UserInterface/Debugger/Debugger-AddBreakpoint.h
View File

@ -3,32 +3,37 @@
class CAddBreakpointDlg : public CDialogImpl<CAddBreakpointDlg> class CAddBreakpointDlg : public CDialogImpl<CAddBreakpointDlg>
{ {
public: public:
enum { IDD = IDD_Debugger_AddBreakpoint }; enum
{
IDD = IDD_Debugger_AddBreakpoint
};
INT_PTR CAddBreakpointDlg::DoModal(CDebuggerUI* debugger) INT_PTR CAddBreakpointDlg::DoModal(CDebuggerUI * debugger)
{ {
m_Debugger = debugger; m_Debugger = debugger;
return CDialogImpl<CAddBreakpointDlg>::DoModal(); return CDialogImpl<CAddBreakpointDlg>::DoModal();
} }
private: private:
CDebuggerUI* m_Debugger; CDebuggerUI * m_Debugger;
CButton m_ReadCheck; CButton m_ReadCheck;
CButton m_WriteCheck; CButton m_WriteCheck;
CButton m_ExecuteCheck; CButton m_ExecuteCheck;
CEdit m_AddressEdit; CEdit m_AddressEdit;
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnDestroy(void) LRESULT OnDestroy(void)
{ {
return 0; return 0;
} }
BEGIN_MSG_MAP_EX(CAddBreakpointDlg) BEGIN_MSG_MAP_EX(CAddBreakpointDlg)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MSG_WM_DESTROY(OnDestroy) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
MSG_WM_DESTROY(OnDestroy);
}
END_MSG_MAP() END_MSG_MAP()
}; };

33
Source/Project64/UserInterface/Debugger/Debugger-AddSymbol.h
View File

@ -3,14 +3,17 @@
class CAddSymbolDlg : public CDialogImpl<CAddSymbolDlg> class CAddSymbolDlg : public CDialogImpl<CAddSymbolDlg>
{ {
public: public:
enum { IDD = IDD_Debugger_AddSymbol }; enum
{
IDD = IDD_Debugger_AddSymbol
};
INT_PTR DoModal(CDebuggerUI* debugger); INT_PTR DoModal(CDebuggerUI * debugger);
INT_PTR DoModal(CDebuggerUI* debugger, uint32_t initAddress); INT_PTR DoModal(CDebuggerUI * debugger, uint32_t initAddress);
INT_PTR DoModal(CDebuggerUI* debugger, uint32_t initAddress, int initType); INT_PTR DoModal(CDebuggerUI * debugger, uint32_t initAddress, int initType);
private: private:
CDebuggerUI* m_Debugger; CDebuggerUI * m_Debugger;
bool m_bHaveAddress; bool m_bHaveAddress;
bool m_bHaveType; bool m_bHaveType;
@ -18,20 +21,22 @@ private:
int m_InitType; int m_InitType;
CEditNumber32 m_AddressEdit; CEditNumber32 m_AddressEdit;
CComboBox m_TypeComboBox; CComboBox m_TypeComboBox;
CEdit m_NameEdit; CEdit m_NameEdit;
CEdit m_DescriptionEdit; CEdit m_DescriptionEdit;
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnDestroy(void) LRESULT OnDestroy(void)
{ {
return 0; return 0;
} }
BEGIN_MSG_MAP_EX(CAddSymbolDlg) BEGIN_MSG_MAP_EX(CAddSymbolDlg)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MSG_WM_DESTROY(OnDestroy) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
END_MSG_MAP() MSG_WM_DESTROY(OnDestroy);
}
END_MSG_MAP()
}; };

5
Source/Project64/UserInterface/Debugger/Debugger-CPULogView.cpp
View File

@ -428,8 +428,5 @@ bool CDebugCPULogView::MouseHovering(WORD ctrlId, int xMargin, int yMargin)
::GetCursorPos(&pointerPos); ::GetCursorPos(&pointerPos);
return ( return (
pointerPos.x >= rect.left - xMargin && pointerPos.x >= rect.left - xMargin && pointerPos.x <= rect.right + xMargin && pointerPos.y >= rect.top - yMargin && pointerPos.y <= rect.bottom + yMargin);
pointerPos.x <= rect.right + xMargin &&
pointerPos.y >= rect.top - yMargin &&
pointerPos.y <= rect.bottom + yMargin);
} }

71
Source/Project64/UserInterface/Debugger/Debugger-CPULogView.h
View File

@ -1,5 +1,6 @@
#pragma once #pragma once
#include "DebuggerUI.h" #include "DebuggerUI.h"
#include <Project64\UserInterface\WTLControls\TooltipDialog.h>
class CDebugCPULogView : class CDebugCPULogView :
public CDebugDialog<CDebugCPULogView>, public CDebugDialog<CDebugCPULogView>,
@ -7,7 +8,10 @@ class CDebugCPULogView :
public CToolTipDialog<CDebugCPULogView> public CToolTipDialog<CDebugCPULogView>
{ {
public: public:
enum { IDD = IDD_Debugger_CPULog }; enum
{
IDD = IDD_Debugger_CPULog
};
CDebugCPULogView(CDebuggerUI * debugger); CDebugCPULogView(CDebuggerUI * debugger);
virtual ~CDebugCPULogView(void); virtual ~CDebugCPULogView(void);
@ -15,32 +19,31 @@ public:
void RefreshList(bool bUpdateBuffer = true); void RefreshList(bool bUpdateBuffer = true);
private: private:
CCPULog* m_CPULogCopy; CCPULog * m_CPULogCopy;
int m_RowHeight; int m_RowHeight;
int m_LogStartIndex; int m_LogStartIndex;
CListViewCtrl m_CPUListView; CListViewCtrl m_CPUListView;
CEdit m_StateInfoEdit; CEdit m_StateInfoEdit;
CEditNumber32 m_BuffSizeEdit; CEditNumber32 m_BuffSizeEdit;
CButton m_EnabledChk; CButton m_EnabledChk;
CScrollBar m_Scrollbar; CScrollBar m_Scrollbar;
CButton m_ExportBtn; CButton m_ExportBtn;
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL & bHandled);
LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnListDblClicked(NMHDR* pNMHDR); LRESULT OnListDblClicked(NMHDR * pNMHDR);
LRESULT OnListItemChanged(NMHDR* pNMHDR); LRESULT OnListItemChanged(NMHDR * pNMHDR);
LRESULT OnMeasureItem(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/); LRESULT OnMeasureItem(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL & /*bHandled*/);
LRESULT OnScroll(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/); LRESULT OnScroll(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL & /*bHandled*/);
void OnExitSizeMove(void); void OnExitSizeMove(void);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
void InterceptMouseWheel(WPARAM wParam, LPARAM lParam); void InterceptMouseWheel(WPARAM wParam, LPARAM lParam);
static CDebugCPULogView* _this; static CDebugCPULogView * _this;
static HHOOK hWinMessageHook; static HHOOK hWinMessageHook;
static LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam); static LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam);
@ -48,29 +51,31 @@ private:
void ShowRegStates(size_t stateIndex); void ShowRegStates(size_t stateIndex);
void Export(void); void Export(void);
int GetNumVisibleRows(CListViewCtrl& list); int GetNumVisibleRows(CListViewCtrl & list);
bool MouseHovering(WORD ctrlId, int xMargin = 0, int yMargin = 0); bool MouseHovering(WORD ctrlId, int xMargin = 0, int yMargin = 0);
BEGIN_MSG_MAP_EX(CDebugCPULogView) BEGIN_MSG_MAP_EX(CDebugCPULogView)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MESSAGE_HANDLER(WM_ACTIVATE, OnActivate) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
NOTIFY_HANDLER_EX(IDC_CPU_LIST, NM_DBLCLK, OnListDblClicked) MESSAGE_HANDLER(WM_ACTIVATE, OnActivate);
NOTIFY_HANDLER_EX(IDC_CPU_LIST, LVN_ITEMCHANGED, OnListItemChanged) NOTIFY_HANDLER_EX(IDC_CPU_LIST, NM_DBLCLK, OnListDblClicked);
MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem) NOTIFY_HANDLER_EX(IDC_CPU_LIST, LVN_ITEMCHANGED, OnListItemChanged);
MESSAGE_HANDLER(WM_VSCROLL, OnScroll) MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove) MESSAGE_HANDLER(WM_VSCROLL, OnScroll);
CHAIN_MSG_MAP(CDialogResize<CDebugCPULogView>) MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
CHAIN_MSG_MAP(CDialogResize<CDebugCPULogView>);
}
END_MSG_MAP() END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CDebugCPULogView) BEGIN_DLGRESIZE_MAP(CDebugCPULogView)
DLGRESIZE_CONTROL(IDC_CPU_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_CPU_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_REGSTATES_GRP, DLSZ_MOVE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_REGSTATES_GRP, DLSZ_MOVE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_STATEINFO_EDIT, DLSZ_MOVE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_STATEINFO_EDIT, DLSZ_MOVE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_SCRL_BAR, DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_SCRL_BAR, DLSZ_SIZE_Y)
END_DLGRESIZE_MAP() END_DLGRESIZE_MAP()
BEGIN_TOOLTIP_MAP() BEGIN_TOOLTIP_MAP()
TOOLTIP(IDC_BUFFSIZE_EDIT, "Maximum number of states to keep (1024 = 416kB)") // sizeof(CPUState) TOOLTIP(IDC_BUFFSIZE_EDIT, "Maximum number of states to keep (1024 = 416kB)") // sizeof(CPUState)
END_TOOLTIP_MAP() END_TOOLTIP_MAP()
}; };

44
Source/Project64/UserInterface/Debugger/Debugger-Commands.cpp
View File

@ -161,9 +161,7 @@ void CDebugCommandsView::RecompilerCheck(void)
return; return;
} }
if (g_Settings->LoadBool(Debugger_Enabled) && if (g_Settings->LoadBool(Debugger_Enabled) && !g_Settings->LoadBool(Setting_ForceInterpreterCPU) && (CPU_TYPE)g_Settings->LoadDword(Game_CpuType) != CPU_Interpreter)
!g_Settings->LoadBool(Setting_ForceInterpreterCPU) &&
(CPU_TYPE)g_Settings->LoadDword(Game_CpuType) != CPU_Interpreter)
{ {
// TODO: Remove this or fix? // TODO: Remove this or fix?
MessageBox(L"Debugger support for the recompiler core is experimental.\n\n" MessageBox(L"Debugger support for the recompiler core is experimental.\n\n"
@ -264,9 +262,7 @@ void CDebugCommandsView::AddBranchArrow(int startPos, int endPos)
BRANCHARROW arrow = m_BranchArrows[j]; BRANCHARROW arrow = m_BranchArrows[j];
// Arrow's start or end position within another arrow's stride // Arrow's start or end position within another arrow's stride
if ((startPos >= arrow.startPos && startPos <= arrow.endPos) || if ((startPos >= arrow.startPos && startPos <= arrow.endPos) || (endPos >= arrow.startPos && endPos <= arrow.endPos) || (arrow.startPos <= startPos && arrow.startPos >= endPos))
(endPos >= arrow.startPos && endPos <= arrow.endPos) ||
(arrow.startPos <= startPos && arrow.startPos >= endPos))
{ {
if (margin <= arrow.margin) if (margin <= arrow.margin)
{ {
@ -485,8 +481,7 @@ void CDebugCommandsView::ShowAddress(uint32_t address, bool top, bool bUserInput
} }
else else
{ {
bool bOutOfView = address < m_StartAddress || bool bOutOfView = address < m_StartAddress || address > m_StartAddress + (m_CommandListRows - 1) * 4;
address > m_StartAddress + (m_CommandListRows - 1) * 4;
if (bOutOfView) if (bOutOfView)
{ {
@ -704,17 +699,13 @@ LRESULT CDebugCommandsView::OnCustomDrawList(NMHDR * pNMHDR)
{ {
// Breakpoint // Breakpoint
pLVCD->clrTextBk = RGB(0x44, 0x00, 0x00); pLVCD->clrTextBk = RGB(0x44, 0x00, 0x00);
pLVCD->clrText = (address == pc && isDebugging()) ? pLVCD->clrText = (address == pc && isDebugging()) ? RGB(0xFF, 0xFF, 0x00) : RGB(0xFF, 0xCC, 0xCC);
RGB(0xFF, 0xFF, 0x00) : // Breakpoint and current PC
RGB(0xFF, 0xCC, 0xCC);
} }
else if (bpState == CBreakpoints::BP_SET_TEMP) else if (bpState == CBreakpoints::BP_SET_TEMP)
{ {
// Breakpoint // Breakpoint
pLVCD->clrTextBk = RGB(0x66, 0x44, 0x00); pLVCD->clrTextBk = RGB(0x66, 0x44, 0x00);
pLVCD->clrText = (address == pc && isDebugging()) ? pLVCD->clrText = (address == pc && isDebugging()) ? RGB(0xFF, 0xFF, 0x00) : RGB(0xFF, 0xEE, 0xCC);
RGB(0xFF, 0xFF, 0x00) : // Breakpoint and current PC
RGB(0xFF, 0xEE, 0xCC);
} }
else if (address == pc && isStepping()) else if (address == pc && isStepping())
{ {
@ -867,19 +858,18 @@ LRESULT CDebugCommandsView::OnMeasureItem(UINT /*uMsg*/, WPARAM wParam, LPARAM l
// Draw branch arrows // Draw branch arrows
void CDebugCommandsView::DrawBranchArrows(HDC listDC) void CDebugCommandsView::DrawBranchArrows(HDC listDC)
{ {
COLORREF colors[] = COLORREF colors[] = {
{ RGB(240, 240, 240), // White
RGB(240, 240, 240), // White RGB(30, 135, 255), // Blue
RGB(30, 135, 255), // Blue RGB(255, 0, 200), // Pink
RGB(255, 0, 200), // Pink RGB(215, 155, 0), // Yellow
RGB(215, 155, 0), // Yellow RGB(100, 180, 0), // Green
RGB(100, 180, 0), // Green RGB(200, 100, 255), // Purple
RGB(200, 100, 255), // Purple RGB(120, 120, 120), // Gray
RGB(120, 120, 120), // Gray RGB(0, 220, 160), // Cyan
RGB(0, 220, 160), // Cyan RGB(255, 100, 0), // Orange
RGB(255, 100, 0), // Orange RGB(255, 255, 0), // Yellow
RGB(255, 255, 0), // Yellow };
};
int nColors = sizeof(colors) / sizeof(COLORREF); int nColors = sizeof(colors) / sizeof(COLORREF);

279
Source/Project64/UserInterface/Debugger/Debugger-Commands.h
View File

@ -1,9 +1,9 @@
#pragma once #pragma once
#include "OpInfo.h"
#include "Breakpoints.h" #include "Breakpoints.h"
#include "Debugger-AddBreakpoint.h" #include "Debugger-AddBreakpoint.h"
#include "Debugger-RegisterTabs.h" #include "Debugger-RegisterTabs.h"
#include "OpInfo.h"
#include <Project64/UserInterface/WTLControls/TooltipDialog.h> #include <Project64/UserInterface/WTLControls/TooltipDialog.h>
@ -32,10 +32,10 @@ class CDebugCommandsView;
class CEditOp : public CWindowImpl<CEditOp, CEdit> class CEditOp : public CWindowImpl<CEditOp, CEdit>
{ {
private: private:
CDebugCommandsView* m_CommandsWindow; CDebugCommandsView * m_CommandsWindow;
LRESULT OnKeyDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnKeyDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) LRESULT OnKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL & bHandled)
{ {
if (wParam == VK_RETURN || wParam == VK_ESCAPE) if (wParam == VK_RETURN || wParam == VK_ESCAPE)
{ {
@ -47,13 +47,15 @@ private:
} }
BEGIN_MSG_MAP_EX(CEditOp) BEGIN_MSG_MAP_EX(CEditOp)
MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown) {
MESSAGE_HANDLER(WM_KEYUP, OnKeyUp) MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown);
MESSAGE_HANDLER(WM_CHAR, OnKeyUp) MESSAGE_HANDLER(WM_KEYUP, OnKeyUp);
MESSAGE_HANDLER(WM_CHAR, OnKeyUp);
}
END_MSG_MAP() END_MSG_MAP()
public: public:
void SetCommandsWindow(CDebugCommandsView* commandsWindow); void SetCommandsWindow(CDebugCommandsView * commandsWindow);
BOOL Attach(HWND hWndNew); BOOL Attach(HWND hWndNew);
}; };
@ -66,9 +68,12 @@ class CDebugCommandsView :
friend class CEditOp; friend class CEditOp;
public: public:
enum { IDD = IDD_Debugger_Commands }; enum
{
IDD = IDD_Debugger_Commands
};
CDebugCommandsView(CDebuggerUI * debugger, SyncEvent &StepEvent); CDebugCommandsView(CDebuggerUI * debugger, SyncEvent & StepEvent);
virtual ~CDebugCommandsView(void); virtual ~CDebugCommandsView(void);
void ShowAddress(uint32_t address, bool top, bool bUserInput = false); void ShowAddress(uint32_t address, bool top, bool bUserInput = false);
@ -78,136 +83,144 @@ public:
private: private:
BEGIN_MSG_MAP_EX(CDebugCommandsView) BEGIN_MSG_MAP_EX(CDebugCommandsView)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
MESSAGE_HANDLER(WM_ACTIVATE, OnActivate) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MESSAGE_HANDLER(WM_SIZING, OnSizing) MESSAGE_HANDLER(WM_ACTIVATE, OnActivate);
MESSAGE_HANDLER(WM_GETMINMAXINFO, OnGetMinMaxInfo) MESSAGE_HANDLER(WM_SIZING, OnSizing);
MESSAGE_HANDLER(WM_VSCROLL, OnScroll) MESSAGE_HANDLER(WM_GETMINMAXINFO, OnGetMinMaxInfo);
MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem) MESSAGE_HANDLER(WM_VSCROLL, OnScroll);
COMMAND_HANDLER(IDC_ADDR_EDIT, EN_CHANGE, OnAddrChanged) MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem);
COMMAND_HANDLER(IDC_PC_EDIT, EN_CHANGE, OnPCChanged) COMMAND_HANDLER(IDC_ADDR_EDIT, EN_CHANGE, OnAddrChanged);
COMMAND_CODE_HANDLER(LBN_DBLCLK, OnListBoxClicked) COMMAND_HANDLER(IDC_PC_EDIT, EN_CHANGE, OnPCChanged);
COMMAND_HANDLER(IDC_BACK_BTN, BN_CLICKED, OnBackButton) COMMAND_CODE_HANDLER(LBN_DBLCLK, OnListBoxClicked);
COMMAND_HANDLER(IDC_FORWARD_BTN, BN_CLICKED, OnForwardButton) COMMAND_HANDLER(IDC_BACK_BTN, BN_CLICKED, OnBackButton);
COMMAND_HANDLER(IDC_VIEWPC_BTN, BN_CLICKED, OnViewPCButton) COMMAND_HANDLER(IDC_FORWARD_BTN, BN_CLICKED, OnForwardButton);
COMMAND_HANDLER(IDC_SYMBOLS_BTN, BN_CLICKED, OnSymbolsButton) COMMAND_HANDLER(IDC_VIEWPC_BTN, BN_CLICKED, OnViewPCButton);
COMMAND_HANDLER(ID_POPUPMENU_RUNTO, BN_CLICKED, OnPopupmenuRunTo) COMMAND_HANDLER(IDC_SYMBOLS_BTN, BN_CLICKED, OnSymbolsButton);
COMMAND_HANDLER(IDC_GO_BTN, BN_CLICKED, OnGoButton) COMMAND_HANDLER(ID_POPUPMENU_RUNTO, BN_CLICKED, OnPopupmenuRunTo);
COMMAND_HANDLER(IDC_STEP_BTN, BN_CLICKED, OnStepButton) COMMAND_HANDLER(IDC_GO_BTN, BN_CLICKED, OnGoButton);
COMMAND_HANDLER(IDC_STEPOVER_BTN, BN_CLICKED, OnStepOverButton) COMMAND_HANDLER(IDC_STEP_BTN, BN_CLICKED, OnStepButton);
COMMAND_HANDLER(IDC_SKIP_BTN, BN_CLICKED, OnSkipButton) COMMAND_HANDLER(IDC_STEPOVER_BTN, BN_CLICKED, OnStepOverButton);
COMMAND_HANDLER(IDC_CLEARBP_BTN, BN_CLICKED, OnClearBPButton) COMMAND_HANDLER(IDC_SKIP_BTN, BN_CLICKED, OnSkipButton);
COMMAND_HANDLER(IDC_ADDBP_BTN, BN_CLICKED, OnAddBPButton) COMMAND_HANDLER(IDC_CLEARBP_BTN, BN_CLICKED, OnClearBPButton);
COMMAND_HANDLER(IDC_RMBP_BTN, BN_CLICKED, OnRemoveBPButton) COMMAND_HANDLER(IDC_ADDBP_BTN, BN_CLICKED, OnAddBPButton);
COMMAND_HANDLER(IDC_COPYTABREGISTERS_BTN, BN_CLICKED, OnCopyTabRegistersButton) COMMAND_HANDLER(IDC_RMBP_BTN, BN_CLICKED, OnRemoveBPButton);
COMMAND_HANDLER(IDC_COPYALLREGISTERS_BTN, BN_CLICKED, OnCopyAllRegistersButton) COMMAND_HANDLER(IDC_COPYTABREGISTERS_BTN, BN_CLICKED, OnCopyTabRegistersButton);
COMMAND_HANDLER(IDCANCEL, BN_CLICKED, OnCancel) COMMAND_HANDLER(IDC_COPYALLREGISTERS_BTN, BN_CLICKED, OnCopyAllRegistersButton);
COMMAND_HANDLER(ID_POPUPMENU_EDIT, BN_CLICKED, OnPopupmenuEdit) COMMAND_HANDLER(IDCANCEL, BN_CLICKED, OnCancel);
COMMAND_HANDLER(ID_POPUPMENU_INSERTNOP, BN_CLICKED, OnPopupmenuInsertNOP) COMMAND_HANDLER(ID_POPUPMENU_EDIT, BN_CLICKED, OnPopupmenuEdit);
COMMAND_HANDLER(ID_POPUPMENU_RESTORE, BN_CLICKED, OnPopupmenuRestore) COMMAND_HANDLER(ID_POPUPMENU_INSERTNOP, BN_CLICKED, OnPopupmenuInsertNOP);
COMMAND_HANDLER(ID_POPUPMENU_RESTOREALL, BN_CLICKED, OnPopupmenuRestoreAll) COMMAND_HANDLER(ID_POPUPMENU_RESTORE, BN_CLICKED, OnPopupmenuRestore);
COMMAND_HANDLER(ID_POPUPMENU_ADDSYMBOL, BN_CLICKED, OnPopupmenuAddSymbol) COMMAND_HANDLER(ID_POPUPMENU_RESTOREALL, BN_CLICKED, OnPopupmenuRestoreAll);
COMMAND_HANDLER(ID_POPUPMENU_FOLLOWJUMP, BN_CLICKED, OnPopupmenuFollowJump) COMMAND_HANDLER(ID_POPUPMENU_ADDSYMBOL, BN_CLICKED, OnPopupmenuAddSymbol);
COMMAND_HANDLER(ID_POPUPMENU_VIEWMEMORY, BN_CLICKED, OnPopupmenuViewMemory) COMMAND_HANDLER(ID_POPUPMENU_FOLLOWJUMP, BN_CLICKED, OnPopupmenuFollowJump);
COMMAND_HANDLER(ID_POPUPMENU_TOGGLEBP, BN_CLICKED, OnPopupmenuToggleBP) COMMAND_HANDLER(ID_POPUPMENU_VIEWMEMORY, BN_CLICKED, OnPopupmenuViewMemory);
COMMAND_HANDLER(ID_POPUPMENU_CLEARBPS, BN_CLICKED, OnPopupmenuClearBP) COMMAND_HANDLER(ID_POPUPMENU_TOGGLEBP, BN_CLICKED, OnPopupmenuToggleBP);
COMMAND_HANDLER(IDC_OP_EDIT, EN_CHANGE, OnOpEditChanged) COMMAND_HANDLER(ID_POPUPMENU_CLEARBPS, BN_CLICKED, OnPopupmenuClearBP);
COMMAND_HANDLER(IDC_OP_EDIT, EN_CHANGE, OnOpEditChanged);
NOTIFY_HANDLER_EX(IDC_CMD_LIST, NM_CLICK, OnCommandListClicked) NOTIFY_HANDLER_EX(IDC_CMD_LIST, NM_CLICK, OnCommandListClicked);
NOTIFY_HANDLER_EX(IDC_CMD_LIST, NM_DBLCLK, OnCommandListDblClicked) NOTIFY_HANDLER_EX(IDC_CMD_LIST, NM_DBLCLK, OnCommandListDblClicked);
NOTIFY_HANDLER_EX(IDC_CMD_LIST, NM_RCLICK, OnCommandListRightClicked) NOTIFY_HANDLER_EX(IDC_CMD_LIST, NM_RCLICK, OnCommandListRightClicked);
NOTIFY_HANDLER_EX(IDC_REG_TABS, TCN_SELCHANGE, OnRegisterTabChange) NOTIFY_HANDLER_EX(IDC_REG_TABS, TCN_SELCHANGE, OnRegisterTabChange);
NOTIFY_HANDLER_EX(IDC_CMD_LIST, NM_CUSTOMDRAW, OnCustomDrawList) NOTIFY_HANDLER_EX(IDC_CMD_LIST, NM_CUSTOMDRAW, OnCustomDrawList);
MSG_WM_DESTROY(OnDestroy) MSG_WM_DESTROY(OnDestroy);
CHAIN_MSG_MAP(CDialogResize<CDebugCommandsView>) CHAIN_MSG_MAP(CDialogResize<CDebugCommandsView>);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove) MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
}
END_MSG_MAP() END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CDebugCommandsView) BEGIN_DLGRESIZE_MAP(CDebugCommandsView)
DLGRESIZE_CONTROL(IDC_GO_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_GO_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_STEP_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_STEP_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_STEPOVER_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_STEPOVER_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_SKIP_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_SKIP_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_ADDR_EDIT, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_ADDR_EDIT, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_SYMBOLS_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_SYMBOLS_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_OPCODE_BOX, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_OPCODE_BOX, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_BP_LIST, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_BP_LIST, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_ADDBP_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_ADDBP_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_RMBP_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_RMBP_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_CLEARBP_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_CLEARBP_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_COPYTABREGISTERS_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_COPYTABREGISTERS_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_COPYALLREGISTERS_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_COPYALLREGISTERS_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_REG_TABS, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_REG_TABS, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_BACK_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_BACK_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_FORWARD_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_FORWARD_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_PC_STATIC, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_PC_STATIC, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_PC_EDIT, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_PC_EDIT, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_VIEWPC_BTN, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_VIEWPC_BTN, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_CMD_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_CMD_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_SCRL_BAR, DLSZ_MOVE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_SCRL_BAR, DLSZ_MOVE_X | DLSZ_SIZE_Y)
END_DLGRESIZE_MAP() END_DLGRESIZE_MAP()
BEGIN_TOOLTIP_MAP() BEGIN_TOOLTIP_MAP()
TOOLTIP(IDC_SKIP_BTN, "Skip (F1)") TOOLTIP(IDC_SKIP_BTN, "Skip (F1)")
TOOLTIP(IDC_STEP_BTN, "Step (F2)") TOOLTIP(IDC_STEP_BTN, "Step (F2)")
TOOLTIP(IDC_STEPOVER_BTN, "Step Over (F3)") TOOLTIP(IDC_STEPOVER_BTN, "Step Over (F3)")
TOOLTIP(IDC_GO_BTN, "Go (F4)") TOOLTIP(IDC_GO_BTN, "Go (F4)")
TOOLTIP(IDC_ADDBP_BTN, "Add breakpoint...") TOOLTIP(IDC_ADDBP_BTN, "Add breakpoint...")
TOOLTIP(IDC_RMBP_BTN, "Remove selected breakpoint") TOOLTIP(IDC_RMBP_BTN, "Remove selected breakpoint")
TOOLTIP(IDC_CLEARBP_BTN, "Remove all breakpoints") TOOLTIP(IDC_CLEARBP_BTN, "Remove all breakpoints")
TOOLTIP(IDC_VIEWPC_BTN, "Jump to program counter") TOOLTIP(IDC_VIEWPC_BTN, "Jump to program counter")
TOOLTIP(IDC_BP_LIST, "Active breakpoints") TOOLTIP(IDC_BP_LIST, "Active breakpoints")
TOOLTIP(IDC_SYMBOLS_BTN, "Symbols...") TOOLTIP(IDC_SYMBOLS_BTN, "Symbols...")
END_TOOLTIP_MAP() END_TOOLTIP_MAP()
static void StaticSteppingOpsChanged(CDebugCommandsView * __this) { __this->SteppingOpsChanged(); } static void StaticSteppingOpsChanged(CDebugCommandsView * __this)
static void StaticWaitingForStepChanged(CDebugCommandsView * __this) { __this->WaitingForStepChanged(); } {
static void GameCpuRunningChanged(CDebugCommandsView* _this); __this->SteppingOpsChanged();
}
static void StaticWaitingForStepChanged(CDebugCommandsView * __this)
{
__this->WaitingForStepChanged();
}
static void GameCpuRunningChanged(CDebugCommandsView * _this);
void RecompilerCheck(void); void RecompilerCheck(void);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnSizing(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnSizing(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnScroll(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnScroll(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnMeasureItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnMeasureItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnAddrChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnAddrChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnPCChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnPCChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnListBoxClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnListBoxClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnBackButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnBackButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnForwardButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnForwardButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnViewPCButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnViewPCButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnSymbolsButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnSymbolsButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuRunTo(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuRunTo(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnGoButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnGoButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnStepButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnStepButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnStepOverButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnStepOverButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnSkipButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnSkipButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnClearBPButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnClearBPButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnAddBPButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnAddBPButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnRemoveBPButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnRemoveBPButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnCopyTabRegistersButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnCopyTabRegistersButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnCopyAllRegistersButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnCopyAllRegistersButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnCancel(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnCancel(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuEdit(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuEdit(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuInsertNOP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuInsertNOP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuRestore(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuRestore(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuRestoreAll(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuRestoreAll(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuAddSymbol(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuAddSymbol(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuFollowJump(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuFollowJump(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuViewMemory(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuViewMemory(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuToggleBP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuToggleBP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnPopupmenuClearBP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnPopupmenuClearBP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnOpEditChanged(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnOpEditChanged(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnOpEditKeyDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnOpEditKeyDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnCommandListClicked(NMHDR* pNMHDR); LRESULT OnCommandListClicked(NMHDR * pNMHDR);
LRESULT OnCommandListDblClicked(NMHDR* pNMHDR); LRESULT OnCommandListDblClicked(NMHDR * pNMHDR);
LRESULT OnCommandListRightClicked(NMHDR* pNMHDR); LRESULT OnCommandListRightClicked(NMHDR * pNMHDR);
LRESULT OnRegisterTabChange(NMHDR* pNMHDR); LRESULT OnRegisterTabChange(NMHDR * pNMHDR);
LRESULT OnCustomDrawList(NMHDR* pNMHDR); LRESULT OnCustomDrawList(NMHDR * pNMHDR);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
void OnExitSizeMove(void); void OnExitSizeMove(void);
@ -225,14 +238,14 @@ private:
void HistoryPushState(); void HistoryPushState();
void ToggleHistoryButtons(); void ToggleHistoryButtons();
static CDebugCommandsView* _this; static CDebugCommandsView * _this;
static HHOOK hWinMessageHook; static HHOOK hWinMessageHook;
static LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam); static LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam);
void InterceptKeyDown(WPARAM wParam, LPARAM lParam); void InterceptKeyDown(WPARAM wParam, LPARAM lParam);
void InterceptMouseWheel(WPARAM wParam, LPARAM lParam); void InterceptMouseWheel(WPARAM wParam, LPARAM lParam);
static const char* GetCodeAddressNotes(uint32_t vAddr); static const char * GetCodeAddressNotes(uint32_t vAddr);
static const char* GetDataAddressNotes(uint32_t vAddr); static const char * GetDataAddressNotes(uint32_t vAddr);
void CPUSkip(); void CPUSkip();
void CPUResume(); void CPUResume();
@ -246,7 +259,7 @@ private:
void RedrawCommandsAndRegisters(); void RedrawCommandsAndRegisters();
CBreakpoints* m_Breakpoints; CBreakpoints * m_Breakpoints;
vector<uint32_t> m_History; vector<uint32_t> m_History;
int m_HistoryIndex; int m_HistoryIndex;
@ -278,11 +291,11 @@ private:
CButton m_GoButton; CButton m_GoButton;
bool m_bEditing; bool m_bEditing;
CEditOp m_OpEdit; CEditOp m_OpEdit;
uint32_t m_SelectedAddress; uint32_t m_SelectedAddress;
COpInfo m_SelectedOpInfo; COpInfo m_SelectedOpInfo;
R4300iOpcode& m_SelectedOpCode = m_SelectedOpInfo.m_OpCode; R4300iOpcode & m_SelectedOpCode = m_SelectedOpInfo.m_OpCode;
uint32_t m_FollowAddress; uint32_t m_FollowAddress;
uint32_t m_RowHeight; uint32_t m_RowHeight;

6
Source/Project64/UserInterface/Debugger/Debugger-DMALogView.cpp
View File

@ -136,11 +136,7 @@ void CDebugDMALogView::Export(void)
wsprintf(filePath, L"*.csv"); wsprintf(filePath, L"*.csv");
const TCHAR * filters = ( const TCHAR * filters = L"Comma separated values (*.csv)\0*.csv;\0Plain text (*.txt)\0*.txt;\0";
/*1*/ L"Comma separated values (*.csv)\0*.csv;\0"
/*2*/ L"Plain text (*.txt)\0*.txt;\0"
);
const char * extensions[] = {"", ".csv", ".txt"}; const char * extensions[] = {"", ".csv", ".txt"};
openfilename.lStructSize = sizeof(openfilename); openfilename.lStructSize = sizeof(openfilename);

65
Source/Project64/UserInterface/Debugger/Debugger-DMALogView.h
View File

@ -6,7 +6,10 @@ class CDebugDMALogView :
public CDialogResize<CDebugDMALogView> public CDialogResize<CDebugDMALogView>
{ {
public: public:
enum { IDD = IDD_Debugger_DMALog }; enum
{
IDD = IDD_Debugger_DMALog
};
CDebugDMALogView(CDebuggerUI * debugger); CDebugDMALogView(CDebuggerUI * debugger);
virtual ~CDebugDMALogView(void); virtual ~CDebugDMALogView(void);
@ -22,7 +25,7 @@ private:
void RefreshList(void); void RefreshList(void);
void Export(void); void Export(void);
CDMALog* m_DMALog; CDMALog * m_DMALog;
int m_nLastStartIndex; int m_nLastStartIndex;
bool m_bConvertingAddress; bool m_bConvertingAddress;
@ -34,43 +37,45 @@ private:
bool FilterEntry(int dmaLogIndex); bool FilterEntry(int dmaLogIndex);
CListViewCtrl m_DMAList; CListViewCtrl m_DMAList;
CEdit m_DMARamEdit; CEdit m_DMARamEdit;
CEdit m_DMARomEdit; CEdit m_DMARomEdit;
CStatic m_BlockInfo; CStatic m_BlockInfo;
bool m_bCustomDrawClrNext; bool m_bCustomDrawClrNext;
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnRefresh(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnRefresh(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL & bHandled);
LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnRamAddrChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnRamAddrChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnRomAddrChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnRomAddrChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCustomDrawList(NMHDR* pNMHDR); LRESULT OnCustomDrawList(NMHDR * pNMHDR);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
void OnExitSizeMove(void); void OnExitSizeMove(void);
BEGIN_MSG_MAP_EX(CDebugDMALogView) BEGIN_MSG_MAP_EX(CDebugDMALogView)
MESSAGE_HANDLER(WM_REFRESH, OnRefresh) {
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) MESSAGE_HANDLER(WM_REFRESH, OnRefresh);
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MESSAGE_HANDLER(WM_ACTIVATE, OnActivate) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
COMMAND_HANDLER(IDC_DMA_RAM_EDIT, EN_CHANGE, OnRamAddrChanged) MESSAGE_HANDLER(WM_ACTIVATE, OnActivate);
COMMAND_HANDLER(IDC_DMA_ROM_EDIT, EN_CHANGE, OnRomAddrChanged) COMMAND_HANDLER(IDC_DMA_RAM_EDIT, EN_CHANGE, OnRamAddrChanged);
NOTIFY_HANDLER_EX(IDC_DMA_LIST, NM_CUSTOMDRAW, OnCustomDrawList) COMMAND_HANDLER(IDC_DMA_ROM_EDIT, EN_CHANGE, OnRomAddrChanged);
CHAIN_MSG_MAP(CDialogResize<CDebugDMALogView>) NOTIFY_HANDLER_EX(IDC_DMA_LIST, NM_CUSTOMDRAW, OnCustomDrawList);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove) CHAIN_MSG_MAP(CDialogResize<CDebugDMALogView>);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
}
END_MSG_MAP() END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CDebugDMALogView) BEGIN_DLGRESIZE_MAP(CDebugDMALogView)
DLGRESIZE_CONTROL(IDC_DMA_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_DMA_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_TRACE_STATIC, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_TRACE_STATIC, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_BLOCK_INFO, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_BLOCK_INFO, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_RAM_STATIC, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_RAM_STATIC, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_ROM_STATIC, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_ROM_STATIC, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_DMA_ROM_EDIT, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_DMA_ROM_EDIT, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_DMA_RAM_EDIT, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_DMA_RAM_EDIT, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_CLEAR_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_CLEAR_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_EXPORT_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_EXPORT_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y)
END_DLGRESIZE_MAP() END_DLGRESIZE_MAP()
}; };

8
Source/Project64/UserInterface/Debugger/Debugger-ExceptionBreakpoints.cpp
View File

@ -21,7 +21,7 @@ CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::ExcCheckboxMap[] = {
{IDC_CHK_FPE, 15}, {IDC_CHK_FPE, 15},
{IDC_CHK_WATCH, 23}, {IDC_CHK_WATCH, 23},
{IDC_CHK_VCED, 31}, {IDC_CHK_VCED, 31},
{ 0, 0 } {0, 0},
}; };
CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::FpExcCheckboxMap[] = { CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::FpExcCheckboxMap[] = {
@ -31,7 +31,7 @@ CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::FpExcCheckboxMap[] =
{IDC_CHK_FP_CZ, (1 << 3)}, {IDC_CHK_FP_CZ, (1 << 3)},
{IDC_CHK_FP_CV, (1 << 4)}, {IDC_CHK_FP_CV, (1 << 4)},
{IDC_CHK_FP_CE, (1 << 5)}, {IDC_CHK_FP_CE, (1 << 5)},
{ 0, 0 } {0, 0},
}; };
CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::IntrCheckboxMap[] = { CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::IntrCheckboxMap[] = {
@ -43,7 +43,7 @@ CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::IntrCheckboxMap[] =
{IDC_CHK_INTR_IP5, (1 << 5)}, {IDC_CHK_INTR_IP5, (1 << 5)},
{IDC_CHK_INTR_IP6, (1 << 6)}, {IDC_CHK_INTR_IP6, (1 << 6)},
{IDC_CHK_INTR_IP7, (1 << 7)}, {IDC_CHK_INTR_IP7, (1 << 7)},
{ 0, 0 } {0, 0},
}; };
CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::RcpIntrCheckboxMap[] = { CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::RcpIntrCheckboxMap[] = {
@ -53,7 +53,7 @@ CDebugExcBreakpoints::ExcCheckboxMeta CDebugExcBreakpoints::RcpIntrCheckboxMap[]
{IDC_CHK_INTR_VI, (1 << 3)}, {IDC_CHK_INTR_VI, (1 << 3)},
{IDC_CHK_INTR_PI, (1 << 4)}, {IDC_CHK_INTR_PI, (1 << 4)},
{IDC_CHK_INTR_DP, (1 << 5)}, {IDC_CHK_INTR_DP, (1 << 5)},
{ 0, 0 } {0, 0},
}; };
CDebugExcBreakpoints::CDebugExcBreakpoints(CDebuggerUI * debugger) : CDebugExcBreakpoints::CDebugExcBreakpoints(CDebuggerUI * debugger) :

28
Source/Project64/UserInterface/Debugger/Debugger-ExceptionBreakpoints.h
View File

@ -1,7 +1,6 @@
#pragma once #pragma once
#include "DebuggerUI.h" #include "DebuggerUI.h"
class CDebugExcBreakpoints : class CDebugExcBreakpoints :
public CDebugDialog<CDebugExcBreakpoints> public CDebugDialog<CDebugExcBreakpoints>
{ {
@ -12,7 +11,10 @@ class CDebugExcBreakpoints :
} ExcCheckboxMeta; } ExcCheckboxMeta;
public: public:
enum { IDD = IDD_Debugger_ExceptionBP }; enum
{
IDD = IDD_Debugger_ExceptionBP
};
CDebugExcBreakpoints(CDebuggerUI * debugger); CDebugExcBreakpoints(CDebuggerUI * debugger);
virtual ~CDebugExcBreakpoints(void); virtual ~CDebugExcBreakpoints(void);
@ -23,20 +25,22 @@ private:
static ExcCheckboxMeta IntrCheckboxMap[]; static ExcCheckboxMeta IntrCheckboxMap[];
static ExcCheckboxMeta RcpIntrCheckboxMap[]; static ExcCheckboxMeta RcpIntrCheckboxMap[];
void InitCheckboxes(ExcCheckboxMeta* checkboxMap, SettingID settingID, bool bShift = false); void InitCheckboxes(ExcCheckboxMeta * checkboxMap, SettingID settingID, bool bShift = false);
void UpdateBpSetting(ExcCheckboxMeta* checkboxMap, SettingID settingID, WORD wID, bool bChecked, bool bShift = false); void UpdateBpSetting(ExcCheckboxMeta * checkboxMap, SettingID settingID, WORD wID, bool bChecked, bool bShift = false);
void EnableCheckboxes(ExcCheckboxMeta* checkboxMap, bool bEnable); void EnableCheckboxes(ExcCheckboxMeta * checkboxMap, bool bEnable);
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL & bHandled);
void OnExitSizeMove(void); void OnExitSizeMove(void);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
BEGIN_MSG_MAP_EX(CDebugExcBreakpoints) BEGIN_MSG_MAP_EX(CDebugExcBreakpoints)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
MSG_WM_DESTROY(OnDestroy) MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
MSG_WM_DESTROY(OnDestroy);
}
END_MSG_MAP() END_MSG_MAP()
}; };

27
Source/Project64/UserInterface/Debugger/Debugger-MemoryDump.h
View File

@ -1,18 +1,21 @@
#pragma once #pragma once
class CDumpMemory : class CDumpMemory :
public CDebugDialog < CDumpMemory > public CDebugDialog<CDumpMemory>
{ {
public: public:
enum { IDD = IDD_Cheats_DumpMemory }; enum
{
IDD = IDD_Cheats_DumpMemory
};
CDumpMemory(CDebuggerUI * debugger); CDumpMemory(CDebuggerUI * debugger);
virtual ~CDumpMemory(void); virtual ~CDumpMemory(void);
private: private:
CDumpMemory(void); CDumpMemory(void);
CDumpMemory(const CDumpMemory&); CDumpMemory(const CDumpMemory &);
CDumpMemory& operator=(const CDumpMemory&); CDumpMemory & operator=(const CDumpMemory &);
enum DumpFormat enum DumpFormat
{ {
@ -21,18 +24,20 @@ private:
}; };
BEGIN_MSG_MAP_EX(CDumpMemory) BEGIN_MSG_MAP_EX(CDumpMemory)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove); MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
END_MSG_MAP() }
END_MSG_MAP()
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL & bHandled);
void OnExitSizeMove(void); void OnExitSizeMove(void);
bool DumpMemory(LPCTSTR FileName, DumpFormat Format, DWORD StartPC, DWORD EndPC, DWORD DumpPC); bool DumpMemory(LPCTSTR FileName, DumpFormat Format, DWORD StartPC, DWORD EndPC, DWORD DumpPC);
CComboBox m_FormatList; CComboBox m_FormatList;
CEdit m_FileName; CEdit m_FileName;
CEditNumber32 m_StartAddress, m_EndAddress, m_PC; CEditNumber32 m_StartAddress, m_EndAddress, m_PC;
}; };

12
Source/Project64/UserInterface/Debugger/Debugger-MemorySearch.cpp
View File

@ -18,7 +18,7 @@ const CSetValueDlg::ComboItem CDebugMemorySearch::ModalChangeTypeItems[] = {
{"float", ValueType_float}, {"float", ValueType_float},
{"double", ValueType_double}, {"double", ValueType_double},
{"string", ValueType_string}, {"string", ValueType_string},
{ nullptr, 0 } {nullptr, 0},
}; };
CDebugMemorySearch::CDebugMemorySearch(CDebuggerUI * debugger) : CDebugMemorySearch::CDebugMemorySearch(CDebuggerUI * debugger) :
@ -1448,10 +1448,7 @@ bool CDebugMemorySearch::MouseHovering(WORD ctrlId, int hMargin, int vMargin)
::GetWindowRect(GetDlgItem(ctrlId), &ctrlRect); ::GetWindowRect(GetDlgItem(ctrlId), &ctrlRect);
return ( return (
pointerPos.x >= ctrlRect.left - hMargin && pointerPos.x >= ctrlRect.left - hMargin && pointerPos.x <= ctrlRect.right + hMargin && pointerPos.y >= ctrlRect.top - vMargin && pointerPos.y <= ctrlRect.bottom + vMargin);
pointerPos.x <= ctrlRect.right + hMargin &&
pointerPos.y >= ctrlRect.top - vMargin &&
pointerPos.y <= ctrlRect.bottom + vMargin);
} }
void CDebugMemorySearch::SeparatorMoveCtrl(WORD ctrlId, int yChange, bool bResize) void CDebugMemorySearch::SeparatorMoveCtrl(WORD ctrlId, int yChange, bool bResize)
@ -1757,10 +1754,7 @@ void CDebugMemorySearch::UpdateOptions(void)
m_SearchValue.EnableWindow(TRUE); m_SearchValue.EnableWindow(TRUE);
if (searchType == SearchType_JalTo || if (searchType == SearchType_JalTo || valueType == ValueType_string || valueType == ValueType_istring || valueType == ValueType_unkstring)
valueType == ValueType_string ||
valueType == ValueType_istring ||
valueType == ValueType_unkstring)
{ {
// Complex search types, disable next search // Complex search types, disable next search
::EnableWindow(GetDlgItem(IDC_BTN_SEARCH), false); ::EnableWindow(GetDlgItem(IDC_BTN_SEARCH), false);

341
Source/Project64/UserInterface/Debugger/Debugger-MemorySearch.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include "MemoryScanner.h"
#include "Debugger-AddSymbol.h" #include "Debugger-AddSymbol.h"
#include "MemoryScanner.h"
class CEditMixed : class CEditMixed :
public CWindowImpl<CEditMixed, CEdit>, public CWindowImpl<CEditMixed, CEdit>,
@ -16,18 +16,18 @@ public:
DisplayFormat GetDisplayFormat(void); DisplayFormat GetDisplayFormat(void);
void SetDisplayFormat(DisplayFormat fmt); void SetDisplayFormat(DisplayFormat fmt);
bool GetValue(uint8_t& value); bool GetValue(uint8_t & value);
bool GetValue(int8_t& value); bool GetValue(int8_t & value);
bool GetValue(uint16_t& value); bool GetValue(uint16_t & value);
bool GetValue(int16_t& value); bool GetValue(int16_t & value);
bool GetValue(uint32_t& value); bool GetValue(uint32_t & value);
bool GetValue(int32_t& value); bool GetValue(int32_t & value);
bool GetValue(uint64_t& value); bool GetValue(uint64_t & value);
bool GetValue(int64_t& value); bool GetValue(int64_t & value);
bool GetValue(float& value); bool GetValue(float & value);
bool GetValue(double& value); bool GetValue(double & value);
bool GetValueString(const wchar_t*& value, int& length); bool GetValueString(const wchar_t *& value, int & length);
bool GetValueHexString(const wchar_t*& value, int& length); bool GetValueHexString(const wchar_t *& value, int & length);
BEGIN_MSG_MAP_EX(CEditMixed) BEGIN_MSG_MAP_EX(CEditMixed)
END_MSG_MAP() END_MSG_MAP()
@ -35,7 +35,7 @@ public:
private: private:
ValueType m_Type; ValueType m_Type;
DisplayFormat m_DisplayFormat; DisplayFormat m_DisplayFormat;
wchar_t *m_String; wchar_t * m_String;
int m_StringLength; int m_StringLength;
void ReloadString(void); void ReloadString(void);
}; };
@ -44,33 +44,38 @@ class CSetValueDlg : public CDialogImpl<CSetValueDlg>
{ {
public: public:
BEGIN_MSG_MAP_EX(CSetValueDlg) BEGIN_MSG_MAP_EX(CSetValueDlg)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_HANDLER(IDOK, BN_CLICKED, OnOK) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_HANDLER(IDCANCEL, BN_CLICKED, OnCancel) COMMAND_HANDLER(IDOK, BN_CLICKED, OnOK);
MSG_WM_DESTROY(OnDestroy) COMMAND_HANDLER(IDCANCEL, BN_CLICKED, OnCancel);
MSG_WM_DESTROY(OnDestroy);
}
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_Debugger_Search_SetValue }; enum
{
IDD = IDD_Debugger_Search_SetValue
};
typedef struct typedef struct
{ {
const char* str; const char * str;
DWORD_PTR data; DWORD_PTR data;
} ComboItem; } ComboItem;
CSetValueDlg(void); CSetValueDlg(void);
virtual ~CSetValueDlg(void); virtual ~CSetValueDlg(void);
INT_PTR DoModal(const char* caption, const char* label, const char* initialText); INT_PTR DoModal(const char * caption, const char * label, const char * initialText);
INT_PTR DoModal(const char* caption, const char* label, DWORD_PTR initialData, const ComboItem items[]); INT_PTR DoModal(const char * caption, const char * label, DWORD_PTR initialData, const ComboItem items[]);
const std::string & GetEnteredString(void); const std::string & GetEnteredString(void);
DWORD_PTR GetEnteredData(void); DWORD_PTR GetEnteredData(void);
private: private:
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
LRESULT OnOK(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnOK(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnCancel(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnCancel(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
enum Mode enum Mode
{ {
@ -80,9 +85,9 @@ private:
Mode m_Mode; Mode m_Mode;
const char* m_Caption; const char * m_Caption;
const char* m_Label; const char * m_Label;
const ComboItem* m_ComboItems; const ComboItem * m_ComboItems;
const char * m_InitialText; const char * m_InitialText;
std::string m_EnteredString; std::string m_EnteredString;
@ -100,7 +105,10 @@ class CDebugMemorySearch :
public CDialogResize<CDebugMemorySearch> public CDialogResize<CDebugMemorySearch>
{ {
public: public:
enum { IDD = IDD_Debugger_Search }; enum
{
IDD = IDD_Debugger_Search
};
CDebugMemorySearch(CDebuggerUI * debugger); CDebugMemorySearch(CDebuggerUI * debugger);
virtual ~CDebugMemorySearch(void); virtual ~CDebugMemorySearch(void);
@ -113,7 +121,8 @@ private:
WM_GAMERESET = WM_USER + 1 WM_GAMERESET = WM_USER + 1
}; };
enum { enum
{
TIMER_ID_AUTO_REFRESH TIMER_ID_AUTO_REFRESH
}; };
@ -123,7 +132,8 @@ private:
GS_TWOBYTE = 0x01000000 GS_TWOBYTE = 0x01000000
}; };
enum { enum
{
WatchListCtrl_Col_Lock, WatchListCtrl_Col_Lock,
WatchListCtrl_Col_BP, WatchListCtrl_Col_BP,
WatchListCtrl_Col_Address, WatchListCtrl_Col_Address,
@ -133,74 +143,75 @@ private:
WatchListCtrl_Num_Columns WatchListCtrl_Num_Columns
}; };
enum { enum
{
ResultsListCtrl_Col_Address, ResultsListCtrl_Col_Address,
ResultsListCtrl_Col_Value, ResultsListCtrl_Col_Value,
ResultsListCtrl_Col_Previous ResultsListCtrl_Col_Previous
}; };
CDebugMemorySearch(void); CDebugMemorySearch(void);
CDebugMemorySearch(const CDebugMemorySearch&); CDebugMemorySearch(const CDebugMemorySearch &);
CDebugMemorySearch& operator=(const CDebugMemorySearch&); CDebugMemorySearch & operator=(const CDebugMemorySearch &);
static LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam); static LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam);
static CDebugMemorySearch* _this; static CDebugMemorySearch * _this;
static HHOOK hWinMessageHook; static HHOOK hWinMessageHook;
static const CSetValueDlg::ComboItem ModalChangeTypeItems[]; static const CSetValueDlg::ComboItem ModalChangeTypeItems[];
LRESULT OnSetFont(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnSetFont(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
LRESULT OnGameReset(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnGameReset(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
void OnExitSizeMove(void); void OnExitSizeMove(void);
void OnSizing(UINT fwSide, LPRECT pRect); void OnSizing(UINT fwSide, LPRECT pRect);
void OnTimer(UINT_PTR nIDEvent); void OnTimer(UINT_PTR nIDEvent);
LRESULT OnScroll(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnScroll(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnMouseDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnMouseDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnMouseUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnMouseUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
void OnInterceptMouseWheel(WPARAM wParam, LPARAM lParam); void OnInterceptMouseWheel(WPARAM wParam, LPARAM lParam);
void OnInterceptMouseMove(WPARAM wParam, LPARAM lParam); void OnInterceptMouseMove(WPARAM wParam, LPARAM lParam);
LRESULT OnMeasureItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnMeasureItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnCancel(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnCancel(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnHexCheckbox(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnHexCheckbox(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnSearchButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnSearchButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnResetButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnResetButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnRdramButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnRdramButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnRomButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnRomButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnSpmemButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnSpmemButton(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnScanTypeChanged(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnScanTypeChanged(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnValueTypeChanged(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnValueTypeChanged(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnResultsCustomDraw(LPNMHDR lpnmh); LRESULT OnResultsCustomDraw(LPNMHDR lpnmh);
LRESULT OnResultsDblClick(LPNMHDR lpnmh); LRESULT OnResultsDblClick(LPNMHDR lpnmh);
LRESULT OnResultsRClick(LPNMHDR lpnmh); LRESULT OnResultsRClick(LPNMHDR lpnmh);
LRESULT OnResultsPopupViewMemory(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnResultsPopupViewMemory(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnResultsPopupAddToWatchList(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnResultsPopupAddToWatchList(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnResultsPopupAddAllToWatchList(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnResultsPopupAddAllToWatchList(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnResultsPopupSetValue(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnResultsPopupSetValue(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnResultsPopupRemove(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnResultsPopupRemove(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListItemChanged(LPNMHDR lpnmh); LRESULT OnWatchListItemChanged(LPNMHDR lpnmh);
LRESULT OnWatchListCustomDraw(LPNMHDR lpnmh); LRESULT OnWatchListCustomDraw(LPNMHDR lpnmh);
LRESULT OnWatchListRClick(LPNMHDR lpnmh); LRESULT OnWatchListRClick(LPNMHDR lpnmh);
LRESULT OnWatchListDblClick(LPNMHDR lpnmh); LRESULT OnWatchListDblClick(LPNMHDR lpnmh);
LRESULT OnWatchListPopupLock(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupLock(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupReadBP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupReadBP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupWriteBP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupWriteBP(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupViewMemory(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupViewMemory(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupAddSymbol(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupAddSymbol(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupHexadecimal(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupHexadecimal(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupChangeValue(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupChangeValue(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupChangeDescription(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupChangeDescription(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupChangeType(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupChangeType(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupChangeAddress(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupChangeAddress(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupChangeAddressBy(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupChangeAddressBy(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupRemove(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupRemove(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupRemoveAll(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupRemoveAll(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupCopyGamesharkCode(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupCopyGamesharkCode(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnWatchListPopupCopyAddressAndDescription(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnWatchListPopupCopyAddressAndDescription(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
CScanResult* GetFirstSelectedScanResult(void); CScanResult * GetFirstSelectedScanResult(void);
CScanResult* GetFirstSelectedWatchListResult(void); CScanResult * GetFirstSelectedWatchListResult(void);
void ResetResults(void); void ResetResults(void);
void Search(void); void Search(void);
@ -222,10 +233,10 @@ private:
CPath GetWatchListPath(void); CPath GetWatchListPath(void);
// Generic UI utility // Generic UI utility
void FixListHeader(CListViewCtrl& listCtrl); void FixListHeader(CListViewCtrl & listCtrl);
void SetComboBoxSelByData(CComboBox& cb, DWORD_PTR data); void SetComboBoxSelByData(CComboBox & cb, DWORD_PTR data);
bool MouseHovering(WORD ctrlId, int hMargin = 0, int vMargin = 0); bool MouseHovering(WORD ctrlId, int hMargin = 0, int vMargin = 0);
int GetNumVisibleRows(CListViewCtrl& list); int GetNumVisibleRows(CListViewCtrl & list);
bool m_bJalSelected; bool m_bJalSelected;
bool m_bJalHexWasChecked; bool m_bJalHexWasChecked;
@ -235,105 +246,107 @@ private:
DWORD m_ThreadId; DWORD m_ThreadId;
CFile m_WatchListFile; CFile m_WatchListFile;
CSetValueDlg m_SetValueDlg; CSetValueDlg m_SetValueDlg;
CAddSymbolDlg m_AddSymbolDlg; CAddSymbolDlg m_AddSymbolDlg;
CEditMixed m_SearchValue; CEditMixed m_SearchValue;
CEditNumber32 m_AddrStart, m_AddrEnd; CEditNumber32 m_AddrStart, m_AddrEnd;
CComboBox m_SearchTypeOptions, m_ValueTypeOptions; CComboBox m_SearchTypeOptions, m_ValueTypeOptions;
CListViewCtrl m_ResultsListCtrl, m_WatchListCtrl; CListViewCtrl m_ResultsListCtrl, m_WatchListCtrl;
CScrollBar m_ResultsScrollbar, m_WatchListScrollbar; CScrollBar m_ResultsScrollbar, m_WatchListScrollbar;
CButton m_PhysicalCheckbox, m_HexCheckbox; CButton m_PhysicalCheckbox, m_HexCheckbox;
CButton m_UnsignedCheckbox, m_IgnoreCaseCheckbox, m_UnkEncodingCheckbox; CButton m_UnsignedCheckbox, m_IgnoreCaseCheckbox, m_UnkEncodingCheckbox;
CMemoryScanner m_MemoryScanner; CMemoryScanner m_MemoryScanner;
std::vector<CScanResult> m_WatchList; std::vector<CScanResult> m_WatchList;
bool m_bDraggingSeparator; bool m_bDraggingSeparator;
CRect m_InitialSeparatorRect, m_LastSeparatorRect; CRect m_InitialSeparatorRect, m_LastSeparatorRect;
int m_ListCtrlRowHeight; int m_ListCtrlRowHeight;
HCURSOR m_hCursorSizeNS; HCURSOR m_hCursorSizeNS;
BEGIN_MSG_MAP_EX(CDebugMemorySearch) BEGIN_MSG_MAP_EX(CDebugMemorySearch)
MESSAGE_HANDLER(WM_GAMERESET, OnGameReset) {
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) MESSAGE_HANDLER(WM_GAMERESET, OnGameReset);
MSG_WM_DESTROY(OnDestroy) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove) MSG_WM_DESTROY(OnDestroy);
MSG_WM_SIZING(OnSizing) MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
MSG_WM_TIMER(OnTimer) MSG_WM_SIZING(OnSizing);
COMMAND_HANDLER(IDCANCEL, BN_CLICKED, OnCancel) MSG_WM_TIMER(OnTimer);
MESSAGE_HANDLER(WM_VSCROLL, OnScroll) COMMAND_HANDLER(IDCANCEL, BN_CLICKED, OnCancel);
MESSAGE_HANDLER(WM_LBUTTONDOWN, OnMouseDown) MESSAGE_HANDLER(WM_VSCROLL, OnScroll);
MESSAGE_HANDLER(WM_LBUTTONUP, OnMouseUp) MESSAGE_HANDLER(WM_LBUTTONDOWN, OnMouseDown);
MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem) MESSAGE_HANDLER(WM_LBUTTONUP, OnMouseUp);
MESSAGE_HANDLER(WM_SETFONT, OnSetFont) MESSAGE_HANDLER(WM_MEASUREITEM, OnMeasureItem);
COMMAND_HANDLER(IDC_CHK_HEX, BN_CLICKED, OnHexCheckbox) MESSAGE_HANDLER(WM_SETFONT, OnSetFont);
COMMAND_HANDLER(IDC_BTN_SEARCH, BN_CLICKED, OnSearchButton) COMMAND_HANDLER(IDC_CHK_HEX, BN_CLICKED, OnHexCheckbox);
COMMAND_HANDLER(IDC_BTN_RESET, BN_CLICKED, OnResetButton) COMMAND_HANDLER(IDC_BTN_SEARCH, BN_CLICKED, OnSearchButton);
COMMAND_HANDLER(IDC_CMB_SCANTYPE, CBN_SELCHANGE, OnScanTypeChanged) COMMAND_HANDLER(IDC_BTN_RESET, BN_CLICKED, OnResetButton);
COMMAND_HANDLER(IDC_CMB_VALUETYPE, CBN_SELCHANGE, OnValueTypeChanged) COMMAND_HANDLER(IDC_CMB_SCANTYPE, CBN_SELCHANGE, OnScanTypeChanged);
COMMAND_HANDLER(IDC_BTN_RDRAM, BN_CLICKED, OnRdramButton) COMMAND_HANDLER(IDC_CMB_VALUETYPE, CBN_SELCHANGE, OnValueTypeChanged);
COMMAND_HANDLER(IDC_BTN_ROM, BN_CLICKED, OnRomButton) COMMAND_HANDLER(IDC_BTN_RDRAM, BN_CLICKED, OnRdramButton);
COMMAND_HANDLER(IDC_BTN_SPMEM, BN_CLICKED, OnSpmemButton) COMMAND_HANDLER(IDC_BTN_ROM, BN_CLICKED, OnRomButton);
NOTIFY_HANDLER_EX(IDC_LST_RESULTS, NM_CUSTOMDRAW, OnResultsCustomDraw) COMMAND_HANDLER(IDC_BTN_SPMEM, BN_CLICKED, OnSpmemButton);
NOTIFY_HANDLER_EX(IDC_LST_RESULTS, NM_DBLCLK, OnResultsDblClick) NOTIFY_HANDLER_EX(IDC_LST_RESULTS, NM_CUSTOMDRAW, OnResultsCustomDraw);
NOTIFY_HANDLER_EX(IDC_LST_RESULTS, NM_RCLICK, OnResultsRClick) NOTIFY_HANDLER_EX(IDC_LST_RESULTS, NM_DBLCLK, OnResultsDblClick);
COMMAND_HANDLER(ID_RESULTS_VIEWMEMORY, BN_CLICKED, OnResultsPopupViewMemory) NOTIFY_HANDLER_EX(IDC_LST_RESULTS, NM_RCLICK, OnResultsRClick);
COMMAND_HANDLER(ID_RESULTS_ADDTOWATCHLIST, BN_CLICKED, OnResultsPopupAddToWatchList) COMMAND_HANDLER(ID_RESULTS_VIEWMEMORY, BN_CLICKED, OnResultsPopupViewMemory);
COMMAND_HANDLER(ID_RESULTS_ADDALLTOWATCHLIST, BN_CLICKED, OnResultsPopupAddAllToWatchList) COMMAND_HANDLER(ID_RESULTS_ADDTOWATCHLIST, BN_CLICKED, OnResultsPopupAddToWatchList);
COMMAND_HANDLER(ID_RESULTS_CHANGEVALUE, BN_CLICKED, OnResultsPopupSetValue) COMMAND_HANDLER(ID_RESULTS_ADDALLTOWATCHLIST, BN_CLICKED, OnResultsPopupAddAllToWatchList);
COMMAND_HANDLER(ID_RESULTS_REMOVE, BN_CLICKED, OnResultsPopupRemove) COMMAND_HANDLER(ID_RESULTS_CHANGEVALUE, BN_CLICKED, OnResultsPopupSetValue);
NOTIFY_HANDLER_EX(IDC_LST_WATCHLIST, LVN_ITEMCHANGED, OnWatchListItemChanged) COMMAND_HANDLER(ID_RESULTS_REMOVE, BN_CLICKED, OnResultsPopupRemove);
NOTIFY_HANDLER_EX(IDC_LST_WATCHLIST, NM_CUSTOMDRAW, OnWatchListCustomDraw) NOTIFY_HANDLER_EX(IDC_LST_WATCHLIST, LVN_ITEMCHANGED, OnWatchListItemChanged);
NOTIFY_HANDLER_EX(IDC_LST_WATCHLIST, NM_DBLCLK, OnWatchListDblClick) NOTIFY_HANDLER_EX(IDC_LST_WATCHLIST, NM_CUSTOMDRAW, OnWatchListCustomDraw);
NOTIFY_HANDLER_EX(IDC_LST_WATCHLIST, NM_RCLICK, OnWatchListRClick) NOTIFY_HANDLER_EX(IDC_LST_WATCHLIST, NM_DBLCLK, OnWatchListDblClick);
COMMAND_HANDLER(ID_WATCHLIST_VIEWMEMORY, BN_CLICKED, OnWatchListPopupViewMemory) NOTIFY_HANDLER_EX(IDC_LST_WATCHLIST, NM_RCLICK, OnWatchListRClick);
COMMAND_HANDLER(ID_WATCHLIST_LOCKVALUE, BN_CLICKED, OnWatchListPopupLock) COMMAND_HANDLER(ID_WATCHLIST_VIEWMEMORY, BN_CLICKED, OnWatchListPopupViewMemory);
COMMAND_HANDLER(ID_WATCHLIST_READBP, BN_CLICKED, OnWatchListPopupReadBP) COMMAND_HANDLER(ID_WATCHLIST_LOCKVALUE, BN_CLICKED, OnWatchListPopupLock);
COMMAND_HANDLER(ID_WATCHLIST_WRITEBP, BN_CLICKED, OnWatchListPopupWriteBP) COMMAND_HANDLER(ID_WATCHLIST_READBP, BN_CLICKED, OnWatchListPopupReadBP);
COMMAND_HANDLER(ID_WATCHLIST_ADDSYMBOL, BN_CLICKED, OnWatchListPopupAddSymbol) COMMAND_HANDLER(ID_WATCHLIST_WRITEBP, BN_CLICKED, OnWatchListPopupWriteBP);
COMMAND_HANDLER(ID_WATCHLIST_HEXADECIMAL, BN_CLICKED, OnWatchListPopupHexadecimal) COMMAND_HANDLER(ID_WATCHLIST_ADDSYMBOL, BN_CLICKED, OnWatchListPopupAddSymbol);
COMMAND_HANDLER(ID_WATCHLIST_CHANGE_VALUE, BN_CLICKED, OnWatchListPopupChangeValue) COMMAND_HANDLER(ID_WATCHLIST_HEXADECIMAL, BN_CLICKED, OnWatchListPopupHexadecimal);
COMMAND_HANDLER(ID_WATCHLIST_CHANGE_DESCRIPTION, BN_CLICKED, OnWatchListPopupChangeDescription) COMMAND_HANDLER(ID_WATCHLIST_CHANGE_VALUE, BN_CLICKED, OnWatchListPopupChangeValue);
COMMAND_HANDLER(ID_WATCHLIST_CHANGE_TYPE, BN_CLICKED, OnWatchListPopupChangeType) COMMAND_HANDLER(ID_WATCHLIST_CHANGE_DESCRIPTION, BN_CLICKED, OnWatchListPopupChangeDescription);
COMMAND_HANDLER(ID_WATCHLIST_CHANGE_ADDRESS, BN_CLICKED, OnWatchListPopupChangeAddress) COMMAND_HANDLER(ID_WATCHLIST_CHANGE_TYPE, BN_CLICKED, OnWatchListPopupChangeType);
COMMAND_HANDLER(ID_WATCHLIST_CHANGE_ADDRESSBY, BN_CLICKED, OnWatchListPopupChangeAddressBy) COMMAND_HANDLER(ID_WATCHLIST_CHANGE_ADDRESS, BN_CLICKED, OnWatchListPopupChangeAddress);
COMMAND_HANDLER(ID_WATCHLIST_REMOVE, BN_CLICKED, OnWatchListPopupRemove) COMMAND_HANDLER(ID_WATCHLIST_CHANGE_ADDRESSBY, BN_CLICKED, OnWatchListPopupChangeAddressBy);
COMMAND_HANDLER(ID_WATCHLIST_REMOVEALL, BN_CLICKED, OnWatchListPopupRemoveAll) COMMAND_HANDLER(ID_WATCHLIST_REMOVE, BN_CLICKED, OnWatchListPopupRemove);
COMMAND_HANDLER(ID_WATCHLIST_COPY_GSCODE, BN_CLICKED, OnWatchListPopupCopyGamesharkCode) COMMAND_HANDLER(ID_WATCHLIST_REMOVEALL, BN_CLICKED, OnWatchListPopupRemoveAll);
COMMAND_HANDLER(ID_WATCHLIST_COPY_ADDRDESC, BN_CLICKED, OnWatchListPopupCopyAddressAndDescription) COMMAND_HANDLER(ID_WATCHLIST_COPY_GSCODE, BN_CLICKED, OnWatchListPopupCopyGamesharkCode);
CHAIN_MSG_MAP(CDialogResize<CDebugMemorySearch>) COMMAND_HANDLER(ID_WATCHLIST_COPY_ADDRDESC, BN_CLICKED, OnWatchListPopupCopyAddressAndDescription);
CHAIN_MSG_MAP(CDialogResize<CDebugMemorySearch>);
}
END_MSG_MAP() END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CDebugMemorySearch) BEGIN_DLGRESIZE_MAP(CDebugMemorySearch)
DLGRESIZE_CONTROL(IDC_LST_WATCHLIST, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_LST_WATCHLIST, DLSZ_SIZE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_SCRL_WATCHLIST, DLSZ_MOVE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_SCRL_WATCHLIST, DLSZ_MOVE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_NUM_RESULTS, DLSZ_SIZE_X) DLGRESIZE_CONTROL(IDC_NUM_RESULTS, DLSZ_SIZE_X)
DLGRESIZE_CONTROL(IDC_LST_RESULTS, DLSZ_SIZE_X) DLGRESIZE_CONTROL(IDC_LST_RESULTS, DLSZ_SIZE_X)
DLGRESIZE_CONTROL(IDC_SCRL_RESULTS, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_SCRL_RESULTS, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_SEPARATOR, DLSZ_SIZE_X) DLGRESIZE_CONTROL(IDC_SEPARATOR, DLSZ_SIZE_X)
DLGRESIZE_CONTROL(IDC_BTN_SEARCH, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_BTN_SEARCH, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_BTN_RESET, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_BTN_RESET, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_GRP_SEARCH, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_GRP_SEARCH, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_CHK_HEX, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_CHK_HEX, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_CHK_UNSIGNED, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_CHK_UNSIGNED, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_CHK_IGNORECASE, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_CHK_IGNORECASE, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_CHK_UNKENCODING, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_CHK_UNKENCODING, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_SEARCH_VALUE, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_SEARCH_VALUE, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_LBL_SCANTYPE, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_LBL_SCANTYPE, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_LBL_VALUETYPE, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_LBL_VALUETYPE, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_CMB_SCANTYPE, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_CMB_SCANTYPE, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_CMB_VALUETYPE, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_CMB_VALUETYPE, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_LBL_ADDRSTART, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_LBL_ADDRSTART, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_LBL_ADDREND, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_LBL_ADDREND, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_ADDR_START, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_ADDR_START, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_ADDR_END, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_ADDR_END, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_CHK_PHYSICAL, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_CHK_PHYSICAL, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_BTN_RDRAM, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_BTN_RDRAM, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_BTN_ROM, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_BTN_ROM, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_BTN_SPMEM, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_BTN_SPMEM, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_GRP_ADDR, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_GRP_ADDR, DLSZ_MOVE_X)
END_DLGRESIZE_MAP() END_DLGRESIZE_MAP()
}; };

12
Source/Project64/UserInterface/Debugger/Debugger-RegisterTabData.h
View File

@ -12,9 +12,9 @@ using FieldPairCallback = std::function<void(const CWindow & Label, const CWindo
struct TabRecord struct TabRecord
{ {
const size_t FieldCount = 0; const size_t FieldCount = 0;
const FieldPair* Fields = nullptr; const FieldPair * Fields = nullptr;
constexpr TabRecord(size_t arraySize, const FieldPair *pairs) : constexpr TabRecord(size_t arraySize, const FieldPair * pairs) :
FieldCount{arraySize / sizeof(*pairs)}, FieldCount{arraySize / sizeof(*pairs)},
Fields{pairs} Fields{pairs}
{ {
@ -24,7 +24,7 @@ struct TabRecord
{ {
for (int i = 0, end = FieldCount; i < end; i++) for (int i = 0, end = FieldCount; i < end; i++)
{ {
const FieldPair *pair = (Fields + i); const FieldPair * pair = (Fields + i);
if (pair->LabelId == ctrl) if (pair->LabelId == ctrl)
{ {
return i; return i;
@ -37,7 +37,7 @@ struct TabRecord
{ {
for (int i = 0, end = FieldCount; i < end; i++) for (int i = 0, end = FieldCount; i < end; i++)
{ {
const FieldPair *pair = (Fields + i); const FieldPair * pair = (Fields + i);
if (pair->EditId == ctrl) if (pair->EditId == ctrl)
{ {
return i; return i;
@ -50,7 +50,7 @@ struct TabRecord
{ {
for (size_t i = 0, end = FieldCount; i < end; i++) for (size_t i = 0, end = FieldCount; i < end; i++)
{ {
const FieldPair *pair = (Fields + i); const FieldPair * pair = (Fields + i);
if (callback(parent.GetDescendantWindow(pair->LabelId), parent.GetDescendantWindow(pair->EditId))) if (callback(parent.GetDescendantWindow(pair->LabelId), parent.GetDescendantWindow(pair->EditId)))
{ {
break; break;
@ -62,7 +62,7 @@ struct TabRecord
{ {
for (size_t i = 0, end = FieldCount; i < end; i++) for (size_t i = 0, end = FieldCount; i < end; i++)
{ {
const FieldPair *pair = (Fields + i); const FieldPair * pair = (Fields + i);
callback(parent.GetDescendantWindow(pair->LabelId), parent.GetDescendantWindow(pair->EditId)); callback(parent.GetDescendantWindow(pair->LabelId), parent.GetDescendantWindow(pair->EditId));
} }
} }

8
Source/Project64/UserInterface/Debugger/Debugger-RegisterTabs.cpp
View File

@ -733,8 +733,7 @@ CWindow CRegisterTabs::AddTab(char * caption, int dialogId, DLGPROC dlgProc)
pageRect.top, pageRect.top,
pageRect.Width(), pageRect.Width(),
pageRect.Height(), pageRect.Height(),
SWP_HIDEWINDOW SWP_HIDEWINDOW);
);
m_TabWindows.push_back(tabWin); m_TabWindows.push_back(tabWin);
@ -920,9 +919,8 @@ stdstr CRegisterTabs::CopyTabRegisters(int id)
break; break;
} }
record->Iterate(tab, [&str](const CWindow & label, const CWindow & edit) record->Iterate(tab, [&str](const CWindow & label, const CWindow & edit) {
{ str += stdstr_f("\r\n%s %s", GetCWindowText(label).c_str(), GetCWindowText(edit).c_str());
str += stdstr_f( "\r\n%s %s", GetCWindowText(label).c_str(), GetCWindowText(edit).c_str());
}); });
switch (id) switch (id)

41
Source/Project64/UserInterface/Debugger/Debugger-RegisterTabs.h
View File

@ -7,17 +7,19 @@ class CEditReg64 :
private CDebugSettings private CDebugSettings
{ {
public: public:
static uint64_t ParseValue(const char* wordPair); static uint64_t ParseValue(const char * wordPair);
BOOL Attach(HWND hWndNew); BOOL Attach(HWND hWndNew);
LRESULT OnChar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnChar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnLostFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnLostFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
uint64_t GetValue(); uint64_t GetValue();
void SetValue(uint32_t h, uint32_t l); void SetValue(uint32_t h, uint32_t l);
void SetValue(uint64_t value); void SetValue(uint64_t value);
BEGIN_MSG_MAP_EX(CRegEdit64) BEGIN_MSG_MAP_EX(CRegEdit64)
MESSAGE_HANDLER(WM_CHAR, OnChar) {
MESSAGE_HANDLER(WM_KILLFOCUS, OnLostFocus) MESSAGE_HANDLER(WM_CHAR, OnChar);
MESSAGE_HANDLER(WM_KILLFOCUS, OnLostFocus);
}
END_MSG_MAP() END_MSG_MAP()
}; };
@ -36,10 +38,10 @@ public:
CRegisterTabs(void); CRegisterTabs(void);
~CRegisterTabs(); ~CRegisterTabs();
void Attach(HWND hWndNew, CDebuggerUI* debugger); void Attach(HWND hWndNew, CDebuggerUI * debugger);
HWND Detach(); HWND Detach();
CWindow AddTab(char* caption, int dialogId, DLGPROC dlgProc); CWindow AddTab(char * caption, int dialogId, DLGPROC dlgProc);
void ShowTab(int nPage); void ShowTab(int nPage);
CRect GetPageRect(); CRect GetPageRect();
void RedrawCurrentTab(); void RedrawCurrentTab();
@ -49,8 +51,8 @@ public:
void CopyAllRegisters(); void CopyAllRegisters();
private: private:
CRegisterTabs(const CRegisterTabs&); CRegisterTabs(const CRegisterTabs &);
CRegisterTabs& operator=(const CRegisterTabs&); CRegisterTabs & operator=(const CRegisterTabs &);
stdstr CopyTabRegisters(int id); stdstr CopyTabRegisters(int id);
@ -60,16 +62,15 @@ private:
static INT_PTR CALLBACK TabProcGPR(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam); static INT_PTR CALLBACK TabProcGPR(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);
static INT_PTR CALLBACK TabProcFPR(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam); static INT_PTR CALLBACK TabProcFPR(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);
static void InitRegisterEdit(CWindow & tab, CEditNumber32 & edit, FieldPair ctrl);
static void InitRegisterEdits(CWindow & tab, CEditNumber32 * edits, const TabRecord * ctrlIds);
static void InitRegisterEdit64(CWindow & tab, CEditReg64 & edit, FieldPair ctrl);
static void InitRegisterEdits64(CWindow & tab, CEditReg64 * edits, const TabRecord * ctrlIds);
static void InitRegisterEdit(CWindow& tab, CEditNumber32& edit, FieldPair ctrl); static void ZeroRegisterEdit(CEditNumber32 & edit);
static void InitRegisterEdits(CWindow& tab, CEditNumber32* edits, const TabRecord* ctrlIds); static void ZeroRegisterEdits(CEditNumber32 * edits, uint32_t ctrlIdsCount);
static void InitRegisterEdit64(CWindow& tab, CEditReg64& edit, FieldPair ctrl); static void ZeroRegisterEdit64(CEditReg64 & edit);
static void InitRegisterEdits64(CWindow& tab, CEditReg64* edits, const TabRecord* ctrlIds); static void ZeroRegisterEdits64(CEditReg64 * edits, uint32_t ctrlIdsCount);
static void ZeroRegisterEdit(CEditNumber32& edit);
static void ZeroRegisterEdits(CEditNumber32* edits, uint32_t ctrlIdsCount);
static void ZeroRegisterEdit64(CEditReg64& edit);
static void ZeroRegisterEdits64(CEditReg64* edits, uint32_t ctrlIdsCount);
typedef union typedef union
{ {
@ -128,12 +129,12 @@ private:
"? 28", "? 28",
"? 29", "? 29",
"? 30", "? 30",
"Virtual coherency (data)" "Virtual coherency (data)",
}; };
// For static dlgprocs, assumes single instance // For static dlgprocs, assumes single instance
static bool m_bColorsEnabled; static bool m_bColorsEnabled;
static CDebuggerUI* m_Debugger; static CDebuggerUI * m_Debugger;
vector<CWindow> m_TabWindows; vector<CWindow> m_TabWindows;
bool m_attached; bool m_attached;

3
Source/Project64/UserInterface/Debugger/Debugger-Scripts.cpp
View File

@ -441,8 +441,7 @@ LRESULT CDebugScripts::OnRefreshList(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*
} }
} while (searchPath.FindNext()); } while (searchPath.FindNext());
fileNames.sort([](stdstr a, stdstr b) fileNames.sort([](stdstr a, stdstr b) { return a.ToLower() < b.ToLower(); });
{ return a.ToLower() < b.ToLower(); });
m_ScriptList.SetRedraw(false); m_ScriptList.SetRedraw(false);
m_ScriptList.DeleteAllItems(); m_ScriptList.DeleteAllItems();

107
Source/Project64/UserInterface/Debugger/Debugger-Scripts.h
View File

@ -1,9 +1,9 @@
#pragma once #pragma once
#include "Debugger-ScriptsAutorun.h"
#include "DebuggerUI.h" #include "DebuggerUI.h"
#include "ScriptSystem.h" #include "ScriptSystem.h"
#include <Project64/UserInterface/WTLControls/EditConInput.h> #include <Project64/UserInterface/WTLControls/EditConInput.h>
#include <Project64/UserInterface/WTLControls/TooltipDialog.h> #include <Project64/UserInterface/WTLControls/TooltipDialog.h>
#include "Debugger-ScriptsAutorun.h"
#include <string> #include <string>
#include <vector> #include <vector>
@ -13,14 +13,16 @@ class CDebugScripts :
public CToolTipDialog<CDebugScripts> public CToolTipDialog<CDebugScripts>
{ {
private: private:
enum { enum
{
WM_REFRESH_LIST = WM_USER + 1, WM_REFRESH_LIST = WM_USER + 1,
WM_SCRIPT_STATUS = WM_USER + 2, WM_SCRIPT_STATUS = WM_USER + 2,
WM_CONSOLE_PRINT = WM_USER + 3, WM_CONSOLE_PRINT = WM_USER + 3,
WM_CONSOLE_CLEAR = WM_USER + 4 WM_CONSOLE_CLEAR = WM_USER + 4
}; };
enum { enum
{
CONFLUSH_TIMER_ID = 0, CONFLUSH_TIMER_ID = 0,
CONFLUSH_TIMER_INTERVAL = 50 CONFLUSH_TIMER_INTERVAL = 50
}; };
@ -38,14 +40,14 @@ private:
stdstr m_ScriptsDir; stdstr m_ScriptsDir;
stdstr m_SelectedScriptName; stdstr m_SelectedScriptName;
std::vector<wchar_t*> m_InputHistory; std::vector<wchar_t *> m_InputHistory;
size_t m_InputHistoryIndex; size_t m_InputHistoryIndex;
stdstr m_ConOutputBuffer; stdstr m_ConOutputBuffer;
HANDLE m_hQuitScriptDirWatchEvent; HANDLE m_hQuitScriptDirWatchEvent;
HANDLE m_hScriptDirWatchThread; HANDLE m_hScriptDirWatchThread;
static DWORD WINAPI ScriptDirWatchProc(void *ctx); static DWORD WINAPI ScriptDirWatchProc(void * ctx);
void RunSelected(); void RunSelected();
void StopSelected(); void StopSelected();
@ -54,72 +56,77 @@ private:
void RefreshStatus(); void RefreshStatus();
void ConsoleCopy(); void ConsoleCopy();
void SendInput(const char* name, const char* code); void SendInput(const char * name, const char * code);
public: public:
enum { IDD = IDD_Debugger_Scripts }; enum
{
IDD = IDD_Debugger_Scripts
};
CDebugScripts(CDebuggerUI * debugger); CDebugScripts(CDebuggerUI * debugger);
virtual ~CDebugScripts(void); virtual ~CDebugScripts(void);
void ConsolePrint(const char* text); void ConsolePrint(const char * text);
void ConsoleClear(); void ConsoleClear();
void RefreshList(); void RefreshList();
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnCtlColorStatic(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnCtlColorStatic(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnCtlColorEdit(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnCtlColorEdit(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
LRESULT OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/); LRESULT OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/);
LRESULT OnScriptListDblClicked(NMHDR* pNMHDR); LRESULT OnScriptListDblClicked(NMHDR * pNMHDR);
LRESULT OnScriptListRClicked(NMHDR* pNMHDR); LRESULT OnScriptListRClicked(NMHDR * pNMHDR);
LRESULT OnScriptListCustomDraw(NMHDR* pNMHDR); LRESULT OnScriptListCustomDraw(NMHDR * pNMHDR);
LRESULT OnScriptListItemChanged(NMHDR* pNMHDR); LRESULT OnScriptListItemChanged(NMHDR * pNMHDR);
LRESULT OnInputSpecialKey(NMHDR* pNMHDR); LRESULT OnInputSpecialKey(NMHDR * pNMHDR);
void OnExitSizeMove(void); void OnExitSizeMove(void);
void OnTimer(UINT_PTR nIDEvent); void OnTimer(UINT_PTR nIDEvent);
LRESULT OnConsolePrint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnConsolePrint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnConsoleClear(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnConsoleClear(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnRefreshList(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnRefreshList(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
BEGIN_MSG_MAP_EX(CDebugScripts) BEGIN_MSG_MAP_EX(CDebugScripts)
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) {
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnCtlColorStatic) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MESSAGE_HANDLER(WM_CTLCOLOREDIT, OnCtlColorEdit) MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnCtlColorStatic);
NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, NM_DBLCLK, OnScriptListDblClicked) MESSAGE_HANDLER(WM_CTLCOLOREDIT, OnCtlColorEdit);
NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, NM_RCLICK, OnScriptListRClicked) NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, NM_DBLCLK, OnScriptListDblClicked);
NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, NM_CUSTOMDRAW, OnScriptListCustomDraw) NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, NM_RCLICK, OnScriptListRClicked);
NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, LVN_ITEMCHANGED, OnScriptListItemChanged) NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, NM_CUSTOMDRAW, OnScriptListCustomDraw);
NOTIFY_HANDLER_EX(IDC_EVAL_EDIT, CIN_SPECIALKEY, OnInputSpecialKey) NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, LVN_ITEMCHANGED, OnScriptListItemChanged);
MSG_WM_TIMER(OnTimer) NOTIFY_HANDLER_EX(IDC_EVAL_EDIT, CIN_SPECIALKEY, OnInputSpecialKey);
MSG_WM_DESTROY(OnDestroy) MSG_WM_TIMER(OnTimer);
MSG_WM_DESTROY(OnDestroy);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove); MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
MESSAGE_HANDLER(WM_CONSOLE_PRINT, OnConsolePrint) MESSAGE_HANDLER(WM_CONSOLE_PRINT, OnConsolePrint);
MESSAGE_HANDLER(WM_CONSOLE_CLEAR, OnConsoleClear) MESSAGE_HANDLER(WM_CONSOLE_CLEAR, OnConsoleClear);
MESSAGE_HANDLER(WM_REFRESH_LIST, OnRefreshList) MESSAGE_HANDLER(WM_REFRESH_LIST, OnRefreshList);
CHAIN_MSG_MAP(CDialogResize<CDebugScripts>) CHAIN_MSG_MAP(CDialogResize<CDebugScripts>);
}
END_MSG_MAP() END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CDebugScripts) BEGIN_DLGRESIZE_MAP(CDebugScripts)
DLGRESIZE_CONTROL(IDC_CONSOLE_EDIT, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_CONSOLE_EDIT, DLSZ_SIZE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_SCRIPT_LIST, DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_SCRIPT_LIST, DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_CLEAR_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_CLEAR_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_COPY_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_COPY_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_SCRIPTS_GRP, DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_SCRIPTS_GRP, DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_OUTPUT_GRP, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_OUTPUT_GRP, DLSZ_SIZE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_EVAL_LBL, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_EVAL_LBL, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_EVAL_EDIT, DLSZ_SIZE_X | DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_EVAL_EDIT, DLSZ_SIZE_X | DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_RUN_BTN, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_RUN_BTN, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_SCRIPTDIR_BTN, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_SCRIPTDIR_BTN, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_STATUSBAR, DLSZ_SIZE_X | DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_STATUSBAR, DLSZ_SIZE_X | DLSZ_MOVE_Y)
END_DLGRESIZE_MAP() END_DLGRESIZE_MAP()
BEGIN_TOOLTIP_MAP() BEGIN_TOOLTIP_MAP()
TOOLTIP(IDC_CLEAR_BTN, "Clear console output") TOOLTIP(IDC_CLEAR_BTN, "Clear console output")
TOOLTIP(IDC_COPY_BTN, "Copy console output to the clipboard") TOOLTIP(IDC_COPY_BTN, "Copy console output to the clipboard")
TOOLTIP(IDC_RUN_BTN, "Toggle selected script") TOOLTIP(IDC_RUN_BTN, "Toggle selected script")
TOOLTIP(IDC_SCRIPTDIR_BTN, "Open scripts directory in file explorer") TOOLTIP(IDC_SCRIPTDIR_BTN, "Open scripts directory in file explorer")
END_TOOLTIP_MAP() END_TOOLTIP_MAP()
}; };

3
Source/Project64/UserInterface/Debugger/Debugger-ScriptsAutorun.cpp
View File

@ -137,8 +137,7 @@ LRESULT CScriptsAutorunDlg::OnRefreshScriptList(UINT /*uMsg*/, WPARAM /*wParam*/
do do
{ {
stdstr fileName = searchPath.GetNameExtension(); stdstr fileName = searchPath.GetNameExtension();
if (searchPath.GetExtension() == "js" && if (searchPath.GetExtension() == "js" && m_ScriptSystem->AutorunList().count(fileName) == 0)
m_ScriptSystem->AutorunList().count(fileName) == 0)
{ {
fileNames.push_back(searchPath.GetNameExtension()); fileNames.push_back(searchPath.GetNameExtension());
} }

55
Source/Project64/UserInterface/Debugger/Debugger-ScriptsAutorun.h
View File

@ -5,36 +5,41 @@ class CScriptsAutorunDlg :
public CDialogImpl<CScriptsAutorunDlg> public CDialogImpl<CScriptsAutorunDlg>
{ {
public: public:
enum { IDD = IDD_Debugger_ScriptsAutorun }; enum
{
IDD = IDD_Debugger_ScriptsAutorun
};
CScriptsAutorunDlg(); CScriptsAutorunDlg();
virtual ~CScriptsAutorunDlg(); virtual ~CScriptsAutorunDlg();
INT_PTR DoModal(CDebuggerUI* debugger, stdstr selectedScriptName); INT_PTR DoModal(CDebuggerUI * debugger, stdstr selectedScriptName);
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
LRESULT OnOKCancel(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnOKCancel(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnAdd(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnAdd(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnRemove(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL& bHandled); LRESULT OnRemove(WORD wNotifyCode, WORD wID, HWND hwnd, BOOL & bHandled);
LRESULT OnScriptListDblClicked(NMHDR* pNMHDR); LRESULT OnScriptListDblClicked(NMHDR * pNMHDR);
LRESULT OnAutorunListDblClicked(NMHDR* pNMHDR); LRESULT OnAutorunListDblClicked(NMHDR * pNMHDR);
LRESULT OnCtrlSetFocus(NMHDR* pNMHDR); LRESULT OnCtrlSetFocus(NMHDR * pNMHDR);
LRESULT OnRefreshScriptList(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnRefreshScriptList(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnRefreshAutorunList(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnRefreshAutorunList(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
BEGIN_MSG_MAP_EX(CAddBreakpointDlg) BEGIN_MSG_MAP_EX(CAddBreakpointDlg)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
MSG_WM_DESTROY(OnDestroy) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_HANDLER(IDOK, BN_CLICKED, OnOKCancel) MSG_WM_DESTROY(OnDestroy);
COMMAND_HANDLER(IDCANCEL, BN_CLICKED, OnOKCancel) COMMAND_HANDLER(IDOK, BN_CLICKED, OnOKCancel);
COMMAND_HANDLER(IDC_ADD_BTN, BN_CLICKED, OnAdd) COMMAND_HANDLER(IDCANCEL, BN_CLICKED, OnOKCancel);
COMMAND_HANDLER(IDC_REMOVE_BTN, BN_CLICKED, OnRemove) COMMAND_HANDLER(IDC_ADD_BTN, BN_CLICKED, OnAdd);
NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, NM_DBLCLK, OnScriptListDblClicked) COMMAND_HANDLER(IDC_REMOVE_BTN, BN_CLICKED, OnRemove);
NOTIFY_HANDLER_EX(IDC_AUTORUN_LIST, NM_DBLCLK, OnAutorunListDblClicked) NOTIFY_HANDLER_EX(IDC_SCRIPT_LIST, NM_DBLCLK, OnScriptListDblClicked);
NOTIFY_CODE_HANDLER_EX(NM_SETFOCUS, OnCtrlSetFocus) NOTIFY_HANDLER_EX(IDC_AUTORUN_LIST, NM_DBLCLK, OnAutorunListDblClicked);
MESSAGE_HANDLER(WM_REFRESH_LIST, OnRefreshScriptList) NOTIFY_CODE_HANDLER_EX(NM_SETFOCUS, OnCtrlSetFocus);
MESSAGE_HANDLER(WM_REFRESH_AUTORUN_LIST, OnRefreshAutorunList) MESSAGE_HANDLER(WM_REFRESH_LIST, OnRefreshScriptList);
MESSAGE_HANDLER(WM_REFRESH_AUTORUN_LIST, OnRefreshAutorunList);
}
END_MSG_MAP() END_MSG_MAP()
private: private:
@ -44,8 +49,8 @@ private:
WM_REFRESH_AUTORUN_LIST = WM_USER + 2 WM_REFRESH_AUTORUN_LIST = WM_USER + 2
}; };
CDebuggerUI* m_Debugger; CDebuggerUI * m_Debugger;
CScriptSystem* m_ScriptSystem; CScriptSystem * m_ScriptSystem;
stdstr m_InitSelectedScriptName; stdstr m_InitSelectedScriptName;
//std::set<std::string> m_AutorunSet; //std::set<std::string> m_AutorunSet;
@ -58,7 +63,7 @@ private:
HANDLE m_hQuitScriptDirWatchEvent; HANDLE m_hQuitScriptDirWatchEvent;
HANDLE m_hScriptDirWatchThread; HANDLE m_hScriptDirWatchThread;
static DWORD WINAPI ScriptDirWatchProc(void* ctx); static DWORD WINAPI ScriptDirWatchProc(void * ctx);
void AddSelected(); void AddSelected();
void RemoveSelected(); void RemoveSelected();

39
Source/Project64/UserInterface/Debugger/Debugger-StackTrace.h
View File

@ -3,7 +3,8 @@
#define STACKTRACE_MAX_ENTRIES 100 #define STACKTRACE_MAX_ENTRIES 100
typedef struct { typedef struct
{
uint32_t routineAddress; uint32_t routineAddress;
uint32_t callingAddress; uint32_t callingAddress;
} STACKTRACE_ENTRY; } STACKTRACE_ENTRY;
@ -14,7 +15,10 @@ class CDebugStackTrace :
private CDebugSettings private CDebugSettings
{ {
public: public:
enum { IDD = IDD_Debugger_StackTrace }; enum
{
IDD = IDD_Debugger_StackTrace
};
CDebugStackTrace(CDebuggerUI * debugger); CDebugStackTrace(CDebuggerUI * debugger);
virtual ~CDebugStackTrace(void); virtual ~CDebugStackTrace(void);
@ -25,7 +29,7 @@ public:
{ {
if (m_EntriesIndex < STACKTRACE_MAX_ENTRIES) if (m_EntriesIndex < STACKTRACE_MAX_ENTRIES)
{ {
m_Entries[m_EntriesIndex] = { routineAddress, callingAddress }; m_Entries[m_EntriesIndex] = {routineAddress, callingAddress};
m_EntriesIndex++; m_EntriesIndex++;
} }
} }
@ -44,30 +48,31 @@ public:
} }
private: private:
STACKTRACE_ENTRY m_Entries[STACKTRACE_MAX_ENTRIES]; STACKTRACE_ENTRY m_Entries[STACKTRACE_MAX_ENTRIES];
int m_EntriesIndex; int m_EntriesIndex;
CListViewCtrl m_List; CListViewCtrl m_List;
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/); LRESULT OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/);
LRESULT OnListDblClicked(NMHDR* pNMHDR); LRESULT OnListDblClicked(NMHDR * pNMHDR);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
void OnExitSizeMove(void); void OnExitSizeMove(void);
BEGIN_MSG_MAP_EX(CDebugStackTrace) BEGIN_MSG_MAP_EX(CDebugStackTrace)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
MSG_WM_DESTROY(OnDestroy) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MESSAGE_HANDLER(WM_ACTIVATE, OnActivate) MSG_WM_DESTROY(OnDestroy);
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_ACTIVATE, OnActivate);
NOTIFY_HANDLER_EX(IDC_STACKTRACE_LIST, NM_DBLCLK, OnListDblClicked) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
CHAIN_MSG_MAP(CDialogResize<CDebugStackTrace>) NOTIFY_HANDLER_EX(IDC_STACKTRACE_LIST, NM_DBLCLK, OnListDblClicked);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove) CHAIN_MSG_MAP(CDialogResize<CDebugStackTrace>);
END_MSG_MAP() MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
}
END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CDebugStackTrace) BEGIN_DLGRESIZE_MAP(CDebugStackTrace)
DLGRESIZE_CONTROL(IDC_STACKTRACE_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_STACKTRACE_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y)
END_DLGRESIZE_MAP() END_DLGRESIZE_MAP()
}; };

23
Source/Project64/UserInterface/Debugger/Debugger-StackView.h
View File

@ -5,7 +5,10 @@ class CDebugStackView :
public CDialogResize<CDebugStackView> public CDialogResize<CDebugStackView>
{ {
public: public:
enum { IDD = IDD_Debugger_Stack }; enum
{
IDD = IDD_Debugger_Stack
};
CDebugStackView(CDebuggerUI * debugger); CDebugStackView(CDebuggerUI * debugger);
virtual ~CDebugStackView(void); virtual ~CDebugStackView(void);
@ -16,20 +19,22 @@ private:
CListViewCtrl m_StackList; CListViewCtrl m_StackList;
CStatic m_SPStatic; CStatic m_SPStatic;
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
void OnExitSizeMove(void); void OnExitSizeMove(void);
BEGIN_MSG_MAP_EX(CDebugStackView) BEGIN_MSG_MAP_EX(CDebugStackView)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
MSG_WM_DESTROY(OnDestroy) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MSG_WM_DESTROY(OnDestroy);
CHAIN_MSG_MAP(CDialogResize<CDebugStackView>) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
CHAIN_MSG_MAP(CDialogResize<CDebugStackView>);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove); MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
END_MSG_MAP() }
END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CDebugStackView) BEGIN_DLGRESIZE_MAP(CDebugStackView)
DLGRESIZE_CONTROL(IDC_STACK_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_STACK_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y)
END_DLGRESIZE_MAP() END_DLGRESIZE_MAP()
}; };

5
Source/Project64/UserInterface/Debugger/Debugger-Symbols.cpp
View File

@ -23,7 +23,7 @@ const CSetValueDlg::ComboItem CDebugSymbols::ModalChangeTypeItems[] = {
{"v2", SYM_VECTOR2}, {"v2", SYM_VECTOR2},
{"v3", SYM_VECTOR3}, {"v3", SYM_VECTOR3},
{"v4", SYM_VECTOR4}, {"v4", SYM_VECTOR4},
{ nullptr, 0 } {nullptr, 0},
}; };
CDebugSymbols::CDebugSymbols(CDebuggerUI * debugger) : CDebugSymbols::CDebugSymbols(CDebuggerUI * debugger) :
@ -396,8 +396,7 @@ void CDebugSymbols::UpdateFilteredSymbols()
std::wstring strName = stdstr(symbol.m_Name).ToUTF16(); std::wstring strName = stdstr(symbol.m_Name).ToUTF16();
std::wstring strDesc = stdstr(symbol.m_Description).ToUTF16(); std::wstring strDesc = stdstr(symbol.m_Description).ToUTF16();
if (strName.find(m_FilterText) != std::wstring::npos || if (strName.find(m_FilterText) != std::wstring::npos || strDesc.find(m_FilterText) != std::wstring::npos)
strDesc.find(m_FilterText) != std::wstring::npos)
{ {
SymbolCacheItem item(symbol, m_SymbolTable); SymbolCacheItem item(symbol, m_SymbolTable);
m_FilteredSymbols.push_back(item); m_FilteredSymbols.push_back(item);

72
Source/Project64/UserInterface/Debugger/Debugger-Symbols.h
View File

@ -8,7 +8,8 @@ class CDebugSymbols :
public CDialogResize<CDebugSymbols> public CDialogResize<CDebugSymbols>
{ {
private: private:
enum { enum
{
SymbolsListView_Col_Address, SymbolsListView_Col_Address,
SymbolsListView_Col_Type, SymbolsListView_Col_Type,
SymbolsListView_Col_Name, SymbolsListView_Col_Name,
@ -17,15 +18,16 @@ private:
SymbolsListView_Num_Columns SymbolsListView_Num_Columns
}; };
struct SymbolCacheItem { struct SymbolCacheItem
int m_Id; {
int m_Id;
wchar_t m_Address[16]; wchar_t m_Address[16];
wchar_t m_Type[16]; wchar_t m_Type[16];
wchar_t m_Name[48]; wchar_t m_Name[48];
wchar_t m_Value[64]; wchar_t m_Value[64];
wchar_t m_Description[256]; wchar_t m_Description[256];
SymbolCacheItem(CSymbol& symbol, CSymbolTable* symbolTable) SymbolCacheItem(CSymbol & symbol, CSymbolTable * symbolTable)
{ {
char szValue[64]; char szValue[64];
symbolTable->GetValueString(szValue, &symbol); symbolTable->GetValueString(szValue, &symbol);
@ -46,9 +48,9 @@ private:
static const CSetValueDlg::ComboItem ModalChangeTypeItems[]; static const CSetValueDlg::ComboItem ModalChangeTypeItems[];
CSymbolTable* m_SymbolTable; CSymbolTable * m_SymbolTable;
CListViewCtrl m_SymbolsListView; CListViewCtrl m_SymbolsListView;
CSetValueDlg m_SetValueDlg; CSetValueDlg m_SetValueDlg;
CAddSymbolDlg m_AddSymbolDlg; CAddSymbolDlg m_AddSymbolDlg;
size_t m_SymbolCacheStartIndex; size_t m_SymbolCacheStartIndex;
@ -59,45 +61,53 @@ private:
std::vector<SymbolCacheItem> m_FilteredSymbols; std::vector<SymbolCacheItem> m_FilteredSymbols;
public: public:
enum { IDD = IDD_Debugger_Symbols }; enum
enum { TIMER_ID_AUTO_REFRESH }; {
IDD = IDD_Debugger_Symbols
};
enum
{
TIMER_ID_AUTO_REFRESH
};
CDebugSymbols(CDebuggerUI * debugger); CDebugSymbols(CDebuggerUI * debugger);
//virtual ~CDebugSymbols(void); //virtual ~CDebugSymbols(void);
void Refresh(); void Refresh();
void UpdateFilteredSymbols(); void UpdateFilteredSymbols();
int GetListItemSymbolId(int nItem); int GetListItemSymbolId(int nItem);
int ColumnHitTest(POINT& pt); int ColumnHitTest(POINT & pt);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/); LRESULT OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/);
LRESULT OnFilterChanged(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/); LRESULT OnFilterChanged(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL & /*bHandled*/);
LRESULT OnListDblClicked(NMHDR* pNMHDR); LRESULT OnListDblClicked(NMHDR * pNMHDR);
LRESULT OnListGetDispInfo(NMHDR* pNMHDR); LRESULT OnListGetDispInfo(NMHDR * pNMHDR);
LRESULT OnListCacheHint(NMHDR* pNMHDR); LRESULT OnListCacheHint(NMHDR * pNMHDR);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
void OnExitSizeMove(void); void OnExitSizeMove(void);
void OnTimer(UINT_PTR nIDEvent); void OnTimer(UINT_PTR nIDEvent);
BEGIN_MSG_MAP_EX(CDebugSymbols) BEGIN_MSG_MAP_EX(CDebugSymbols)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_HANDLER(IDC_FILTER_EDIT, EN_CHANGE, OnFilterChanged) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
NOTIFY_HANDLER_EX(IDC_SYMBOLS_LIST, NM_DBLCLK, OnListDblClicked) COMMAND_HANDLER(IDC_FILTER_EDIT, EN_CHANGE, OnFilterChanged);
NOTIFY_HANDLER_EX(IDC_SYMBOLS_LIST, LVN_GETDISPINFO, OnListGetDispInfo) NOTIFY_HANDLER_EX(IDC_SYMBOLS_LIST, NM_DBLCLK, OnListDblClicked);
NOTIFY_HANDLER_EX(IDC_SYMBOLS_LIST, LVN_ODCACHEHINT, OnListCacheHint) NOTIFY_HANDLER_EX(IDC_SYMBOLS_LIST, LVN_GETDISPINFO, OnListGetDispInfo);
MSG_WM_TIMER(OnTimer) NOTIFY_HANDLER_EX(IDC_SYMBOLS_LIST, LVN_ODCACHEHINT, OnListCacheHint);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove) MSG_WM_TIMER(OnTimer);
MSG_WM_DESTROY(OnDestroy) MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
CHAIN_MSG_MAP(CDialogResize<CDebugSymbols>) MSG_WM_DESTROY(OnDestroy);
CHAIN_MSG_MAP(CDialogResize<CDebugSymbols>);
}
END_MSG_MAP() END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CDebugSymbols) BEGIN_DLGRESIZE_MAP(CDebugSymbols)
DLGRESIZE_CONTROL(IDC_FILTER_EDIT, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_FILTER_EDIT, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_FILTER_STATIC, DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_FILTER_STATIC, DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_REMOVESYMBOL_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_REMOVESYMBOL_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_ADDSYMBOL_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_ADDSYMBOL_BTN, DLSZ_MOVE_X | DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_SYMBOLS_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_SYMBOLS_LIST, DLSZ_SIZE_X | DLSZ_SIZE_Y)
END_DLGRESIZE_MAP() END_DLGRESIZE_MAP()
}; };

19
Source/Project64/UserInterface/Debugger/Debugger-TLB.h
View File

@ -1,20 +1,25 @@
#pragma once #pragma once
class CDebugTlb : class CDebugTlb :
public CDebugDialog < CDebugTlb > public CDebugDialog<CDebugTlb>
{ {
BEGIN_MSG_MAP_EX(CDebugTlb) BEGIN_MSG_MAP_EX(CDebugTlb)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
}
END_MSG_MAP() END_MSG_MAP()
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/); LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND /*hWndCtl*/, BOOL & bHandled);
void OnExitSizeMove(void); void OnExitSizeMove(void);
public: public:
enum { IDD = IDD_Debugger_TLB }; enum
{
IDD = IDD_Debugger_TLB
};
CDebugTlb(CDebuggerUI * debugger); CDebugTlb(CDebuggerUI * debugger);
virtual ~CDebugTlb(void); virtual ~CDebugTlb(void);

36
Source/Project64/UserInterface/Debugger/Debugger-ViewMemory.cpp
View File

@ -28,7 +28,7 @@ CDebugMemoryView::jump_item_t CDebugMemoryView::JumpItems[] = {
{0xB0000000, 0x10000000, 0xFC00000, "Cartridge ROM"}, {0xB0000000, 0x10000000, 0xFC00000, "Cartridge ROM"},
{0xBFC00000, 0x1FC00000, 0x00007C0, "PIF ROM"}, {0xBFC00000, 0x1FC00000, 0x00007C0, "PIF ROM"},
{0xBFC007C0, 0x1FC007C0, 0x0000040, "PIF RAM"}, {0xBFC007C0, 0x1FC007C0, 0x0000040, "PIF RAM"},
{ 0, NULL} {0, NULL},
}; };
CDebugMemoryView::CDebugMemoryView(CDebuggerUI * debugger) : CDebugMemoryView::CDebugMemoryView(CDebuggerUI * debugger) :
@ -117,9 +117,7 @@ void CDebugMemoryView::CopyBytesToClipboard(uint32_t startAddress, uint32_t endA
if (bIncludeAddresses) if (bIncludeAddresses)
{ {
if ((bRowAddresses && offsetFromBase % rowSize == 0) || if ((bRowAddresses && offsetFromBase % rowSize == 0) || (!bRowAddresses && offsetFromBase % groupSize == 0) || (offsetFromSelStart == 0))
(!bRowAddresses && offsetFromBase % groupSize == 0) ||
(offsetFromSelStart == 0))
{ {
str += stdstr_f("%08X: ", address); str += stdstr_f("%08X: ", address);
} }
@ -341,7 +339,7 @@ LRESULT CDebugMemoryView::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM
(int)(MEMSB_BLOCK_W * dpiScale), (int)(MEMSB_BLOCK_W * dpiScale),
(int)(MEMSB_BLOCKLEN_W * dpiScale), (int)(MEMSB_BLOCKLEN_W * dpiScale),
(int)(MEMSB_DMAINFO_W * dpiScale), (int)(MEMSB_DMAINFO_W * dpiScale),
(int)(MEMSB_SAFEMODE_W * dpiScale) (int)(MEMSB_SAFEMODE_W * dpiScale),
}; };
m_StatusBar.SetParts(MEMSB_NUM_PANES, statusPaneWidths); m_StatusBar.SetParts(MEMSB_NUM_PANES, statusPaneWidths);
@ -371,7 +369,7 @@ LRESULT CDebugMemoryView::OnDestroy(void)
return 0; return 0;
} }
LRESULT CDebugMemoryView::OnShowAddress(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) LRESULT CDebugMemoryView::OnShowAddress(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL & /*bHandled*/)
{ {
uint32_t address = (uint32_t)wParam; uint32_t address = (uint32_t)wParam;
bool bVirtual = (lParam != 0); bool bVirtual = (lParam != 0);
@ -385,7 +383,7 @@ void CDebugMemoryView::OnExitSizeMove()
SaveWindowPos(true); SaveWindowPos(true);
} }
LRESULT CDebugMemoryView::OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND, BOOL& /*bHandled*/) LRESULT CDebugMemoryView::OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND, BOOL & /*bHandled*/)
{ {
switch (wID) switch (wID)
{ {
@ -432,26 +430,26 @@ LRESULT CDebugMemoryView::OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND, BOOL&
m_HexEditCtrl.Copy(); m_HexEditCtrl.Copy();
break; break;
case ID_POPUPMENU_COPYGAMESHARKCODE: case ID_POPUPMENU_COPYGAMESHARKCODE:
{ {
uint32_t startAddress, endAddress; uint32_t startAddress, endAddress;
m_HexEditCtrl.GetSelectionRange(&startAddress, &endAddress); m_HexEditCtrl.GetSelectionRange(&startAddress, &endAddress);
CopyGameSharkCodeToClipboard(startAddress, endAddress); CopyGameSharkCodeToClipboard(startAddress, endAddress);
}
break; break;
}
case ID_POPUPMENU_COPYDATAWITHGROUPADDRESSES: case ID_POPUPMENU_COPYDATAWITHGROUPADDRESSES:
{ {
uint32_t startAddress, endAddress; uint32_t startAddress, endAddress;
m_HexEditCtrl.GetSelectionRange(&startAddress, &endAddress); m_HexEditCtrl.GetSelectionRange(&startAddress, &endAddress);
CopyBytesToClipboard(startAddress, endAddress, m_HexEditCtrl.GetFocusedColumn() == HX_COL_HEXDATA, true, false); CopyBytesToClipboard(startAddress, endAddress, m_HexEditCtrl.GetFocusedColumn() == HX_COL_HEXDATA, true, false);
}
break; break;
}
case ID_POPUPMENU_COPYDATAWITHROWADDRESSES: case ID_POPUPMENU_COPYDATAWITHROWADDRESSES:
{ {
uint32_t startAddress, endAddress; uint32_t startAddress, endAddress;
m_HexEditCtrl.GetSelectionRange(&startAddress, &endAddress); m_HexEditCtrl.GetSelectionRange(&startAddress, &endAddress);
CopyBytesToClipboard(startAddress, endAddress, m_HexEditCtrl.GetFocusedColumn() == HX_COL_HEXDATA, true, true); CopyBytesToClipboard(startAddress, endAddress, m_HexEditCtrl.GetFocusedColumn() == HX_COL_HEXDATA, true, true);
}
break; break;
}
case ID_POPUPMENU_PASTE: case ID_POPUPMENU_PASTE:
m_HexEditCtrl.Paste(); m_HexEditCtrl.Paste();
break; break;
@ -590,16 +588,16 @@ LRESULT CDebugMemoryView::OnHxCtrlKeyPressed(LPNMHDR lpNMHDR)
FollowPointer(false); FollowPointer(false);
break; break;
case VK_TAB: case VK_TAB:
{
int curSel = m_TabCtrl.GetCurSel();
if (m_TabCtrl.SetCurSel(curSel + 1) == -1)
{ {
int curSel = m_TabCtrl.GetCurSel(); m_TabCtrl.SetCurSel(0);
if (m_TabCtrl.SetCurSel(curSel + 1) == -1)
{
m_TabCtrl.SetCurSel(0);
}
TabSelChanged();
} }
TabSelChanged();
break; break;
} }
}
return FALSE; return FALSE;
} }

245
Source/Project64/UserInterface/Debugger/Debugger-ViewMemory.h
View File

@ -1,13 +1,13 @@
#pragma once #pragma once
#include "Debugger-AddSymbol.h" #include "Debugger-AddSymbol.h"
#include <UserInterface/WTLControls/HexEditCtrl.h>
#include <Project64/UserInterface/WTLControls/TooltipDialog.h> #include <Project64/UserInterface/WTLControls/TooltipDialog.h>
#include <UserInterface/WTLControls/HexEditCtrl.h>
typedef struct typedef struct
{ {
NMHDR nmh; NMHDR nmh;
int nItem; int nItem;
} NMMTRCLICK; } NMMTRCLICK;
enum enum
@ -35,13 +35,13 @@ public:
private: private:
void OnLButtonDblClk(UINT /*nFlags*/, CPoint /*point*/) void OnLButtonDblClk(UINT /*nFlags*/, CPoint /*point*/)
{ {
NMHDR nmh = { m_hWnd, (UINT_PTR)::GetDlgCtrlID(m_hWnd), NM_DBLCLK }; NMHDR nmh = {m_hWnd, (UINT_PTR)::GetDlgCtrlID(m_hWnd), NM_DBLCLK};
::SendMessage(::GetParent(m_hWnd), WM_NOTIFY, NM_DBLCLK, (LPARAM)&nmh); ::SendMessage(::GetParent(m_hWnd), WM_NOTIFY, NM_DBLCLK, (LPARAM)&nmh);
} }
void OnRButtonDown(UINT /*nFlags*/, CPoint point) void OnRButtonDown(UINT /*nFlags*/, CPoint point)
{ {
TCHITTESTINFO ht = { point, 0}; TCHITTESTINFO ht = {point, 0};
int nItem = ::SendMessage(m_hWnd, TCM_HITTEST, 0, (LPARAM)&ht); int nItem = ::SendMessage(m_hWnd, TCM_HITTEST, 0, (LPARAM)&ht);
if (nItem != -1) if (nItem != -1)
{ {
@ -51,21 +51,23 @@ private:
void OnRButtonUp(UINT /*nFlags*/, CPoint point) void OnRButtonUp(UINT /*nFlags*/, CPoint point)
{ {
TCHITTESTINFO ht = { point, 0 }; TCHITTESTINFO ht = {point, 0};
int nItem = ::SendMessage(m_hWnd, TCM_HITTEST, 0, (LPARAM)&ht); int nItem = ::SendMessage(m_hWnd, TCM_HITTEST, 0, (LPARAM)&ht);
if (nItem != -1 && nItem == m_nItemRClick) if (nItem != -1 && nItem == m_nItemRClick)
{ {
NMMTRCLICK nmrc = { { m_hWnd, (UINT_PTR)::GetDlgCtrlID(m_hWnd), MTCN_RCLICK }, nItem }; NMMTRCLICK nmrc = {{m_hWnd, (UINT_PTR)::GetDlgCtrlID(m_hWnd), MTCN_RCLICK}, nItem};
::SendMessage(::GetParent(m_hWnd), WM_NOTIFY, MTCN_RCLICK, (LPARAM)&nmrc); ::SendMessage(::GetParent(m_hWnd), WM_NOTIFY, MTCN_RCLICK, (LPARAM)&nmrc);
} }
m_nItemRClick = -1; m_nItemRClick = -1;
} }
BEGIN_MSG_MAP_EX(CMemTabCtrl) BEGIN_MSG_MAP_EX(CMemTabCtrl)
MSG_WM_LBUTTONDBLCLK(OnLButtonDblClk) {
MSG_WM_RBUTTONDOWN(OnRButtonDown) MSG_WM_LBUTTONDBLCLK(OnLButtonDblClk);
MSG_WM_RBUTTONUP(OnRButtonUp) MSG_WM_RBUTTONDOWN(OnRButtonDown);
MSG_WM_RBUTTONDBLCLK(OnRButtonDown) MSG_WM_RBUTTONUP(OnRButtonUp);
MSG_WM_RBUTTONDBLCLK(OnRButtonDown);
}
END_MSG_MAP() END_MSG_MAP()
}; };
@ -75,7 +77,10 @@ class CDebugMemoryView :
public CToolTipDialog<CDebugMemoryView> public CToolTipDialog<CDebugMemoryView>
{ {
public: public:
enum { IDD = IDD_Debugger_Memory }; enum
{
IDD = IDD_Debugger_Memory
};
CDebugMemoryView(CDebuggerUI * debugger); CDebugMemoryView(CDebuggerUI * debugger);
virtual ~CDebugMemoryView(void); virtual ~CDebugMemoryView(void);
@ -120,11 +125,11 @@ private:
enum enum
{ {
MEMSB_HOTADDR_W = 160, MEMSB_HOTADDR_W = 160,
MEMSB_BLOCK_W = 120 + MEMSB_HOTADDR_W, MEMSB_BLOCK_W = 120 + MEMSB_HOTADDR_W,
MEMSB_BLOCKLEN_W = 60 + MEMSB_BLOCK_W, MEMSB_BLOCKLEN_W = 60 + MEMSB_BLOCK_W,
MEMSB_DMAINFO_W = 60 + MEMSB_BLOCKLEN_W, MEMSB_DMAINFO_W = 60 + MEMSB_BLOCKLEN_W,
MEMSB_SAFEMODE_W = -1 MEMSB_SAFEMODE_W = -1
}; };
enum edit_type_t enum edit_type_t
@ -138,7 +143,7 @@ private:
edit_type_t type; edit_type_t type;
uint32_t startAddress; uint32_t startAddress;
uint32_t endAddress; uint32_t endAddress;
uint8_t value; uint8_t value;
//uint8_t* data; //uint8_t* data;
} edit_t; } edit_t;
@ -147,133 +152,135 @@ private:
uint32_t vaddr; uint32_t vaddr;
uint32_t paddr; uint32_t paddr;
uint32_t size; uint32_t size;
const char* caption; const char * caption;
} jump_item_t; } jump_item_t;
typedef struct typedef struct
{ {
uint32_t address; uint32_t address;
bool bVirtual; bool bVirtual;
int numBytesPerGroup; int numBytesPerGroup;
} tab_info_t; } tab_info_t;
static jump_item_t JumpItems[]; static jump_item_t JumpItems[];
static int GetJumpItemIndex(uint32_t address, bool bVirtual); static int GetJumpItemIndex(uint32_t address, bool bVirtual);
CHexEditCtrl m_HexEditCtrl; CHexEditCtrl m_HexEditCtrl;
CEditNumber32 m_MemAddr; CEditNumber32 m_MemAddr;
CAddSymbolDlg m_AddSymbolDlg; CAddSymbolDlg m_AddSymbolDlg;
CButton m_VirtualCheckbox; CButton m_VirtualCheckbox;
CMemTabCtrl m_TabCtrl; CMemTabCtrl m_TabCtrl;
CStatusBarCtrl m_StatusBar; CStatusBarCtrl m_StatusBar;
CComboBox m_CmbJump; CComboBox m_CmbJump;
std::vector<tab_info_t> m_TabData; std::vector<tab_info_t> m_TabData;
CBreakpoints* m_Breakpoints; CBreakpoints * m_Breakpoints;
int m_WriteTargetColorStride; int m_WriteTargetColorStride;
int m_ReadTargetColorStride; int m_ReadTargetColorStride;
int m_SymbolColorStride; int m_SymbolColorStride;
int m_SymbolColorPhase; int m_SymbolColorPhase;
uint32_t m_ContextMenuAddress; uint32_t m_ContextMenuAddress;
uint32_t m_HotAddress; uint32_t m_HotAddress;
bool m_bIgnoreAddressInput; bool m_bIgnoreAddressInput;
bool m_bVirtualMemory; bool m_bVirtualMemory;
bool m_bSafeEditMode; bool m_bSafeEditMode;
std::vector<edit_t> m_SafeEditQueue; std::vector<edit_t> m_SafeEditQueue;
bool GetByte(uint32_t address, uint8_t* value); bool GetByte(uint32_t address, uint8_t * value);
bool SetByte(uint32_t address, uint8_t value); bool SetByte(uint32_t address, uint8_t value);
void SetupJumpMenu(bool bVirtual); void SetupJumpMenu(bool bVirtual);
bool GetSafeEditValue(uint32_t address, uint8_t* value); bool GetSafeEditValue(uint32_t address, uint8_t * value);
void ApplySafeEdits(void); void ApplySafeEdits(void);
void CopyTextToClipboard(const char* text); void CopyTextToClipboard(const char * text);
void CopyBytesToClipboard(uint32_t startAddress, uint32_t endAddress, bool bHex, bool bIncludeAddresses = false, bool bRowAddresses = false); void CopyBytesToClipboard(uint32_t startAddress, uint32_t endAddress, bool bHex, bool bIncludeAddresses = false, bool bRowAddresses = false);
void CopyGameSharkCodeToClipboard(uint32_t startAddress, uint32_t endAddress); void CopyGameSharkCodeToClipboard(uint32_t startAddress, uint32_t endAddress);
void FillRange(uint32_t startAddress, uint32_t endAddress, uint8_t value); void FillRange(uint32_t startAddress, uint32_t endAddress, uint8_t value);
void FollowPointer(bool bContextMenuAddress = true); void FollowPointer(bool bContextMenuAddress = true);
void JumpToSelection(void); void JumpToSelection(void);
int AddTab(uint32_t address, bool bVirtual, int numBytesPerGroup); int AddTab(uint32_t address, bool bVirtual, int numBytesPerGroup);
int InsertTab(int nItem, uint32_t address, bool bVirtual, int numBytesPerGroup); int InsertTab(int nItem, uint32_t address, bool bVirtual, int numBytesPerGroup);
void DeleteTab(int index); void DeleteTab(int index);
void UpdateCurrentTab(uint32_t address); void UpdateCurrentTab(uint32_t address);
void OpenNewTab(uint32_t address, bool bVirtual, int numBytesPerGroup, bool bInsert = false, bool bOpenExisting = false); void OpenNewTab(uint32_t address, bool bVirtual, int numBytesPerGroup, bool bInsert = false, bool bOpenExisting = false);
void OpenDuplicateTab(void); void OpenDuplicateTab(void);
void CloseTab(int nItem); void CloseTab(int nItem);
void CloseCurrentTab(void); void CloseCurrentTab(void);
void TabSelChanged(void); void TabSelChanged(void);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnShowAddress(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnShowAddress(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
void OnAddrChanged(UINT Code, int id, HWND ctl); void OnAddrChanged(UINT Code, int id, HWND ctl);
void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar); void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar);
void OnExitSizeMove(void); void OnExitSizeMove(void);
LRESULT OnDestroy(void); LRESULT OnDestroy(void);
LRESULT OnHxGetByteInfo(LPNMHDR lpNMHDR); LRESULT OnHxGetByteInfo(LPNMHDR lpNMHDR);
LRESULT OnHxSetNibble(LPNMHDR lpNMHDR); LRESULT OnHxSetNibble(LPNMHDR lpNMHDR);
LRESULT OnHxSetByte(LPNMHDR lpNMHDR); LRESULT OnHxSetByte(LPNMHDR lpNMHDR);
LRESULT OnHxRightClick(LPNMHDR lpNMHDR); LRESULT OnHxRightClick(LPNMHDR lpNMHDR);
LRESULT OnHxEnterPressed(LPNMHDR lpNMHDR); LRESULT OnHxEnterPressed(LPNMHDR lpNMHDR);
LRESULT OnHxRedrawStarted(LPNMHDR lpNMHDR); LRESULT OnHxRedrawStarted(LPNMHDR lpNMHDR);
LRESULT OnHxBaseAddrChanged(LPNMHDR lpNMHDR); LRESULT OnHxBaseAddrChanged(LPNMHDR lpNMHDR);
LRESULT OnHxHotAddrChanged(LPNMHDR lpNMHDR); LRESULT OnHxHotAddrChanged(LPNMHDR lpNMHDR);
LRESULT OnHxCopy(LPNMHDR lpNMHDR); LRESULT OnHxCopy(LPNMHDR lpNMHDR);
LRESULT OnHxPaste(LPNMHDR lpNMHDR); LRESULT OnHxPaste(LPNMHDR lpNMHDR);
LRESULT OnHxCtrlKeyPressed(LPNMHDR lpNMHDR); LRESULT OnHxCtrlKeyPressed(LPNMHDR lpNMHDR);
LRESULT OnHxFillRange(LPNMHDR lpNMHDR); LRESULT OnHxFillRange(LPNMHDR lpNMHDR);
LRESULT OnHxInsertModeChanged(LPNMHDR lpNMHDR); LRESULT OnHxInsertModeChanged(LPNMHDR lpNMHDR);
LRESULT OnHxSelectionChanged(LPNMHDR lpNMHDR); LRESULT OnHxSelectionChanged(LPNMHDR lpNMHDR);
LRESULT OnHxGroupSizeChanged(LPNMHDR lpNMHDR); LRESULT OnHxGroupSizeChanged(LPNMHDR lpNMHDR);
LRESULT OnTabSelChange(LPNMHDR lpNMHDR); LRESULT OnTabSelChange(LPNMHDR lpNMHDR);
LRESULT OnTabDblClick(LPNMHDR lpNMHDR); LRESULT OnTabDblClick(LPNMHDR lpNMHDR);
LRESULT OnTabRClick(LPNMHDR lpNMHDR); LRESULT OnTabRClick(LPNMHDR lpNMHDR);
LRESULT OnStatusBarClick(LPNMHDR lpNMHDR); LRESULT OnStatusBarClick(LPNMHDR lpNMHDR);
void OnJumpComboSelChange(UINT uNotifyCode, int nID, CWindow wndCtl); void OnJumpComboSelChange(UINT uNotifyCode, int nID, CWindow wndCtl);
BEGIN_MSG_MAP_EX(CDebugMemoryView) BEGIN_MSG_MAP_EX(CDebugMemoryView)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
MESSAGE_HANDLER(WM_SHOWADDRESS, OnShowAddress) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked) MESSAGE_HANDLER(WM_SHOWADDRESS, OnShowAddress);
COMMAND_HANDLER_EX(IDC_ADDR_EDIT, EN_CHANGE, OnAddrChanged) COMMAND_CODE_HANDLER(BN_CLICKED, OnClicked);
MSG_WM_EXITSIZEMOVE(OnExitSizeMove) COMMAND_HANDLER_EX(IDC_ADDR_EDIT, EN_CHANGE, OnAddrChanged);
MSG_WM_DESTROY(OnDestroy) MSG_WM_EXITSIZEMOVE(OnExitSizeMove);
MSG_WM_VSCROLL(OnVScroll) MSG_WM_DESTROY(OnDestroy);
COMMAND_HANDLER_EX(IDC_CMB_JUMP, CBN_SELCHANGE, OnJumpComboSelChange) MSG_WM_VSCROLL(OnVScroll);
NOTIFY_HANDLER_EX(IDC_STATUSBAR, NM_CLICK, OnStatusBarClick) COMMAND_HANDLER_EX(IDC_CMB_JUMP, CBN_SELCHANGE, OnJumpComboSelChange);
NOTIFY_HANDLER_EX(IDC_MEMTABS, NM_DBLCLK, OnTabDblClick) NOTIFY_HANDLER_EX(IDC_STATUSBAR, NM_CLICK, OnStatusBarClick);
NOTIFY_HANDLER_EX(IDC_MEMTABS, TCN_SELCHANGE, OnTabSelChange) NOTIFY_HANDLER_EX(IDC_MEMTABS, NM_DBLCLK, OnTabDblClick);
NOTIFY_HANDLER_EX(IDC_MEMTABS, MTCN_RCLICK, OnTabRClick) NOTIFY_HANDLER_EX(IDC_MEMTABS, TCN_SELCHANGE, OnTabSelChange);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_GETBYTEINFO, OnHxGetByteInfo) NOTIFY_HANDLER_EX(IDC_MEMTABS, MTCN_RCLICK, OnTabRClick);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_SETNIBBLE, OnHxSetNibble) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_GETBYTEINFO, OnHxGetByteInfo);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_SETBYTE, OnHxSetByte) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_SETNIBBLE, OnHxSetNibble);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_RCLICK, OnHxRightClick) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_SETBYTE, OnHxSetByte);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_HOTADDRCHANGED, OnHxHotAddrChanged) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_RCLICK, OnHxRightClick);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_REDRAWSTARTED, OnHxRedrawStarted) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_HOTADDRCHANGED, OnHxHotAddrChanged);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_BASEADDRCHANGED, OnHxBaseAddrChanged) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_REDRAWSTARTED, OnHxRedrawStarted);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_HOTADDRCHANGED, OnHxHotAddrChanged) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_BASEADDRCHANGED, OnHxBaseAddrChanged);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_PASTE, OnHxPaste) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_HOTADDRCHANGED, OnHxHotAddrChanged);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_CTRLKEYPRESSED, OnHxCtrlKeyPressed) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_PASTE, OnHxPaste);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_FILLRANGE, OnHxFillRange) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_CTRLKEYPRESSED, OnHxCtrlKeyPressed);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_COPY, OnHxCopy) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_FILLRANGE, OnHxFillRange);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_INSERTMODECHANGED, OnHxInsertModeChanged) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_COPY, OnHxCopy);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_ENTERPRESSED, OnHxEnterPressed) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_INSERTMODECHANGED, OnHxInsertModeChanged);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_SELCHANGED, OnHxSelectionChanged) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_ENTERPRESSED, OnHxEnterPressed);
NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_GROUPSIZECHANGED, OnHxGroupSizeChanged) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_SELCHANGED, OnHxSelectionChanged);
CHAIN_MSG_MAP(CDialogResize<CDebugMemoryView>) NOTIFY_HANDLER_EX(IDC_HEXEDIT, HXN_GROUPSIZECHANGED, OnHxGroupSizeChanged);
CHAIN_MSG_MAP(CDialogResize<CDebugMemoryView>);
}
END_MSG_MAP() END_MSG_MAP()
BEGIN_DLGRESIZE_MAP(CDebugMemoryView) BEGIN_DLGRESIZE_MAP(CDebugMemoryView)
DLGRESIZE_CONTROL(IDC_CMB_JUMP, DLSZ_MOVE_X) DLGRESIZE_CONTROL(IDC_CMB_JUMP, DLSZ_MOVE_X)
DLGRESIZE_CONTROL(IDC_STATUSBAR, DLSZ_SIZE_X | DLSZ_MOVE_Y) DLGRESIZE_CONTROL(IDC_STATUSBAR, DLSZ_SIZE_X | DLSZ_MOVE_Y)
DLGRESIZE_CONTROL(IDC_HEXEDIT, DLSZ_SIZE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_HEXEDIT, DLSZ_SIZE_X | DLSZ_SIZE_Y)
DLGRESIZE_CONTROL(IDC_MEMTABS, DLSZ_SIZE_X) DLGRESIZE_CONTROL(IDC_MEMTABS, DLSZ_SIZE_X)
DLGRESIZE_CONTROL(IDC_SCRL_BAR, DLSZ_MOVE_X | DLSZ_SIZE_Y) DLGRESIZE_CONTROL(IDC_SCRL_BAR, DLSZ_MOVE_X | DLSZ_SIZE_Y)
END_DLGRESIZE_MAP() END_DLGRESIZE_MAP()
BEGIN_TOOLTIP_MAP() BEGIN_TOOLTIP_MAP()
TOOLTIP(IDC_SYMBOLS_BTN, "Symbols...") TOOLTIP(IDC_SYMBOLS_BTN, "Symbols...")
TOOLTIP(IDC_CHK_VADDR, "Checked = Use virtual address space (CPU), Unchecked = Use physical address space (RCP)") TOOLTIP(IDC_CHK_VADDR, "Checked = Use virtual address space (CPU), Unchecked = Use physical address space (RCP)")
END_TOOLTIP_MAP() END_TOOLTIP_MAP()
}; };

17
Source/Project64/UserInterface/Debugger/Debugger.cpp
View File

@ -613,13 +613,11 @@ void CDebuggerUI::CPUStepStarted()
m_ScriptSystem->InvokeAppCallbacks(JS_HOOK_CPU_EXEC, (void *)&hookEnv); m_ScriptSystem->InvokeAppCallbacks(JS_HOOK_CPU_EXEC, (void *)&hookEnv);
} }
if (hookEnv.opInfo.IsLoadCommand() && if (hookEnv.opInfo.IsLoadCommand() && m_ScriptSystem->HaveCpuReadCallbacks(hookEnv.opInfo.GetLoadStoreAddress()))
m_ScriptSystem->HaveCpuReadCallbacks(hookEnv.opInfo.GetLoadStoreAddress()))
{ {
m_ScriptSystem->InvokeAppCallbacks(JS_HOOK_CPU_READ, (void *)&hookEnv); m_ScriptSystem->InvokeAppCallbacks(JS_HOOK_CPU_READ, (void *)&hookEnv);
} }
else if (hookEnv.opInfo.IsStoreCommand() && else if (hookEnv.opInfo.IsStoreCommand() && m_ScriptSystem->HaveCpuWriteCallbacks(hookEnv.opInfo.GetLoadStoreAddress()))
m_ScriptSystem->HaveCpuWriteCallbacks(hookEnv.opInfo.GetLoadStoreAddress()))
{ {
m_ScriptSystem->InvokeAppCallbacks(JS_HOOK_CPU_WRITE, (void *)&hookEnv); m_ScriptSystem->InvokeAppCallbacks(JS_HOOK_CPU_WRITE, (void *)&hookEnv);
} }
@ -629,8 +627,7 @@ void CDebuggerUI::CPUStepStarted()
{ {
uint32_t pc = g_Reg->m_PROGRAM_COUNTER; uint32_t pc = g_Reg->m_PROGRAM_COUNTER;
if (pc == 0x80000000 || pc == 0x80000080 || if (pc == 0x80000000 || pc == 0x80000080 || pc == 0xA0000100 || pc == 0x80000180)
pc == 0xA0000100 || pc == 0x80000180)
{ {
if ((g_Reg->STATUS_REGISTER >> 1) & 3) // If EXL/ERL bits are set if ((g_Reg->STATUS_REGISTER >> 1) & 3) // If EXL/ERL bits are set
{ {
@ -659,17 +656,13 @@ void CDebuggerUI::CPUStepStarted()
int nReg1 = 0, nReg2 = 0; int nReg1 = 0, nReg2 = 0;
opInfo.ReadsGPR(&nReg1, &nReg2); opInfo.ReadsGPR(&nReg1, &nReg2);
if ((nReg1 != 0 && m_Breakpoints->HaveGPRReadBP(nReg1)) || if ((nReg1 != 0 && m_Breakpoints->HaveGPRReadBP(nReg1)) || (nReg2 != 0 && m_Breakpoints->HaveGPRReadBP(nReg2)))
(nReg2 != 0 && m_Breakpoints->HaveGPRReadBP(nReg2)))
{ {
g_Settings->SaveBool(Debugger_SteppingOps, true); g_Settings->SaveBool(Debugger_SteppingOps, true);
} }
} }
if (m_Breakpoints->HaveHIWriteBP() && opInfo.WritesHI() || if (m_Breakpoints->HaveHIWriteBP() && opInfo.WritesHI() || m_Breakpoints->HaveLOWriteBP() && opInfo.WritesLO() || m_Breakpoints->HaveHIReadBP() && opInfo.ReadsHI() || m_Breakpoints->HaveLOReadBP() && opInfo.ReadsLO())
m_Breakpoints->HaveLOWriteBP() && opInfo.WritesLO() ||
m_Breakpoints->HaveHIReadBP() && opInfo.ReadsHI() ||
m_Breakpoints->HaveLOReadBP() && opInfo.ReadsLO())
{ {
g_Settings->SaveBool(Debugger_SteppingOps, true); g_Settings->SaveBool(Debugger_SteppingOps, true);
} }

24
Source/Project64/UserInterface/Debugger/DebuggerUI.h
View File

@ -1,20 +1,20 @@
#pragma once #pragma once
#include "../../WTLApp.h"
#include "../../N64System.h" #include "../../N64System.h"
#include "../../WTLApp.h"
#include "DebugDialog.h" #include "DebugDialog.h"
#include "Debugger-MemorySearch.h"
#include "Debugger-ViewMemory.h"
#include "Debugger-MemoryDump.h"
#include "Debugger-TLB.h"
#include "Debugger-Commands.h"
#include "Debugger-Scripts.h"
#include "Debugger-ScriptsAutorun.h"
#include "Debugger-Symbols.h"
#include "Debugger-AddBreakpoint.h" #include "Debugger-AddBreakpoint.h"
#include "Debugger-AddSymbol.h" #include "Debugger-AddSymbol.h"
#include "Debugger-DMALogView.h"
#include "Debugger-CPULogView.h" #include "Debugger-CPULogView.h"
#include "Debugger-StackView.h" #include "Debugger-Commands.h"
#include "Debugger-StackTrace.h" #include "Debugger-DMALogView.h"
#include "Debugger-ExceptionBreakpoints.h" #include "Debugger-ExceptionBreakpoints.h"
#include "Debugger-MemoryDump.h"
#include "Debugger-MemorySearch.h"
#include "Debugger-Scripts.h"
#include "Debugger-ScriptsAutorun.h"
#include "Debugger-StackTrace.h"
#include "Debugger-StackView.h"
#include "Debugger-Symbols.h"
#include "Debugger-TLB.h"
#include "Debugger-ViewMemory.h"

25
Source/Project64/UserInterface/Debugger/MemoryScanner.cpp
View File

@ -16,7 +16,7 @@ CMixed::TypeNameEntry CMixed::TypeNames[] = {
{"char", ValueType_string}, {"char", ValueType_string},
{"char", ValueType_unkstring}, {"char", ValueType_unkstring},
{"char", ValueType_unkstring}, {"char", ValueType_unkstring},
{ nullptr, ValueType_invalid} {nullptr, ValueType_invalid},
}; };
const char * CMixed::GetTypeName(void) const char * CMixed::GetTypeName(void)
@ -231,9 +231,7 @@ int CScanResult::GetMemoryValueString(char * buffer, size_t size, bool bIgnoreHe
uint8_t * mem = CMemoryScanner::GetMemoryPool(paddr); uint8_t * mem = CMemoryScanner::GetMemoryPool(paddr);
if (m_Type == ValueType_istring || if (m_Type == ValueType_istring || m_Type == ValueType_string || m_Type == ValueType_unkstring)
m_Type == ValueType_string ||
m_Type == ValueType_unkstring)
{ {
if (bHex) if (bHex)
{ {
@ -407,9 +405,7 @@ bool CScanResult::SetAddressSafe(uint32_t address)
return false; return false;
} }
if (!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x00000000, ramSize - 1) && if (!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x00000000, ramSize - 1) && !CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x10000000, 0x10000000 + romSize - 1) && !CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x04000000, 0x04001FFF))
!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x10000000, 0x10000000 + romSize - 1) &&
!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x04000000, 0x04001FFF))
{ {
return false; return false;
} }
@ -432,9 +428,7 @@ bool CScanResult::SetStrLengthSafe(int length)
uint32_t paddrStart = m_Address & 0x1FFFFFFF; uint32_t paddrStart = m_Address & 0x1FFFFFFF;
uint32_t paddrEnd = (paddrStart + length) - 1; uint32_t paddrEnd = (paddrStart + length) - 1;
if (!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x00000000, ramSize - 1) && if (!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x00000000, ramSize - 1) && !CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x10000000, 0x10000000 + romSize - 1) && !CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x04000000, 0x04001FFF))
!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x10000000, 0x10000000 + romSize - 1) &&
!CMemoryScanner::RangeCheck(paddrStart, paddrEnd, 0x04000000, 0x04001FFF))
{ {
return false; return false;
} }
@ -488,16 +482,12 @@ bool CMemoryScanner::PAddrValid(uint32_t physAddr)
uint32_t ramSize = g_MMU->RdramSize(); uint32_t ramSize = g_MMU->RdramSize();
uint32_t romSize = g_Rom->GetRomSize(); uint32_t romSize = g_Rom->GetRomSize();
return (AddrCheck(physAddr, 0x00000000, 0x00000000 + ramSize - 1) || return (AddrCheck(physAddr, 0x00000000, 0x00000000 + ramSize - 1) || AddrCheck(physAddr, 0x10000000, 0x10000000 + romSize - 1) || AddrCheck(physAddr, 0x04000000, 0x04001FFF));
AddrCheck(physAddr, 0x10000000, 0x10000000 + romSize - 1) ||
AddrCheck(physAddr, 0x04000000, 0x04001FFF));
} }
bool CMemoryScanner::PAddrRangeValid(uint32_t physAddrStart, uint32_t physAddrEnd) bool CMemoryScanner::PAddrRangeValid(uint32_t physAddrStart, uint32_t physAddrEnd)
{ {
return (RangeCheck(physAddrStart, physAddrEnd, 0x00000000, g_MMU->RdramSize()) || return (RangeCheck(physAddrStart, physAddrEnd, 0x00000000, g_MMU->RdramSize()) || RangeCheck(physAddrStart, physAddrEnd, 0x04000000, 0x04001FFF) || RangeCheck(physAddrStart, physAddrEnd, 0x10000000, 0x15FFFFFF));
RangeCheck(physAddrStart, physAddrEnd, 0x04000000, 0x04001FFF) ||
RangeCheck(physAddrStart, physAddrEnd, 0x10000000, 0x15FFFFFF));
} }
void CMemoryScanner::SetAddressType(AddressType addressType) void CMemoryScanner::SetAddressType(AddressType addressType)
@ -587,8 +577,7 @@ uint8_t * CMemoryScanner::GetMemoryPool(uint32_t physAddr)
return nullptr; return nullptr;
} }
if ((physAddr >= 0x00000000 && physAddr < g_MMU->RdramSize()) || if ((physAddr >= 0x00000000 && physAddr < g_MMU->RdramSize()) || (physAddr >= 0x04000000 && physAddr <= 0x04001FFF))
(physAddr >= 0x04000000 && physAddr <= 0x04001FFF))
{ {
return g_MMU->Rdram(); return g_MMU->Rdram();
} }

286
Source/Project64/UserInterface/Debugger/MemoryScanner.h
View File

@ -49,18 +49,19 @@ enum DisplayFormat
DisplayHex DisplayHex
}; };
typedef union { typedef union
uint8_t _uint8; {
int8_t _sint8; uint8_t _uint8;
uint16_t _uint16; int8_t _sint8;
int16_t _sint16; uint16_t _uint16;
uint32_t _uint32; int16_t _sint16;
int32_t _sint32; uint32_t _uint32;
uint64_t _uint64; int32_t _sint32;
int64_t _sint64; uint64_t _uint64;
float _float; int64_t _sint64;
double _double; float _float;
const wchar_t* _string; double _double;
const wchar_t * _string;
} MixedValue; } MixedValue;
class CMixed class CMixed
@ -79,47 +80,136 @@ public:
m_Type = ValueType_uint64; m_Type = ValueType_uint64;
} }
inline void SetType(ValueType t) { m_Type = t; } inline void SetType(ValueType t)
inline ValueType GetType(void) { return m_Type; } {
m_Type = t;
}
inline ValueType GetType(void)
{
return m_Type;
}
inline void SetStrLength(int length) { m_StrLength = length; } inline void SetStrLength(int length)
inline int GetStrLength(void) { return m_StrLength; } {
m_StrLength = length;
}
inline int GetStrLength(void)
{
return m_StrLength;
}
inline void Set(uint8_t v) { SetType(ValueType_uint8); m_Value._uint8 = v; } inline void Set(uint8_t v)
inline void Set(int8_t v) { SetType(ValueType_int8); m_Value._sint8 = v; } {
inline void Set(uint16_t v) { SetType(ValueType_uint16); m_Value._uint16 = v; } SetType(ValueType_uint8);
inline void Set(int16_t v) { SetType(ValueType_int16); m_Value._sint16 = v; } m_Value._uint8 = v;
inline void Set(uint32_t v) { SetType(ValueType_uint32); m_Value._uint32 = v; } }
inline void Set(int32_t v) { SetType(ValueType_int32); m_Value._sint32 = v; } inline void Set(int8_t v)
inline void Set(uint64_t v) { SetType(ValueType_uint64); m_Value._uint64 = v; } {
inline void Set(int64_t v) { SetType(ValueType_int64); m_Value._sint64 = v; } SetType(ValueType_int8);
inline void Set(float v) { SetType(ValueType_float); m_Value._float = v; } m_Value._sint8 = v;
inline void Set(double v) { SetType(ValueType_double); m_Value._double = v; } }
inline void Set(const wchar_t* v) { SetType(ValueType_string); m_Value._string = v; } inline void Set(uint16_t v)
{
SetType(ValueType_uint16);
m_Value._uint16 = v;
}
inline void Set(int16_t v)
{
SetType(ValueType_int16);
m_Value._sint16 = v;
}
inline void Set(uint32_t v)
{
SetType(ValueType_uint32);
m_Value._uint32 = v;
}
inline void Set(int32_t v)
{
SetType(ValueType_int32);
m_Value._sint32 = v;
}
inline void Set(uint64_t v)
{
SetType(ValueType_uint64);
m_Value._uint64 = v;
}
inline void Set(int64_t v)
{
SetType(ValueType_int64);
m_Value._sint64 = v;
}
inline void Set(float v)
{
SetType(ValueType_float);
m_Value._float = v;
}
inline void Set(double v)
{
SetType(ValueType_double);
m_Value._double = v;
}
inline void Set(const wchar_t * v)
{
SetType(ValueType_string);
m_Value._string = v;
}
inline void Get(uint8_t* v) { *v = m_Value._uint8; } inline void Get(uint8_t * v)
inline void Get(int8_t* v) { *v = m_Value._sint8; } {
inline void Get(uint16_t* v) { *v = m_Value._uint16; } *v = m_Value._uint8;
inline void Get(int16_t* v) { *v = m_Value._sint16; } }
inline void Get(uint32_t* v) { *v = m_Value._uint32; } inline void Get(int8_t * v)
inline void Get(int32_t* v) { *v = m_Value._sint32; } {
inline void Get(uint64_t* v) { *v = m_Value._uint64; } *v = m_Value._sint8;
inline void Get(int64_t* v) { *v = m_Value._sint64; } }
inline void Get(float* v) { *v = m_Value._float; } inline void Get(uint16_t * v)
inline void Get(double* v) { *v = m_Value._double; } {
inline void Get(const wchar_t** v) { *v = m_Value._string; } *v = m_Value._uint16;
}
inline void Get(int16_t * v)
{
*v = m_Value._sint16;
}
inline void Get(uint32_t * v)
{
*v = m_Value._uint32;
}
inline void Get(int32_t * v)
{
*v = m_Value._sint32;
}
inline void Get(uint64_t * v)
{
*v = m_Value._uint64;
}
inline void Get(int64_t * v)
{
*v = m_Value._sint64;
}
inline void Get(float * v)
{
*v = m_Value._float;
}
inline void Get(double * v)
{
*v = m_Value._double;
}
inline void Get(const wchar_t ** v)
{
*v = m_Value._string;
}
const char* GetTypeName(void); const char * GetTypeName(void);
int GetTypeSize(void); int GetTypeSize(void);
bool IsStringType(void); bool IsStringType(void);
int ToString(char* buffer, bool bHex, size_t size); int ToString(char * buffer, bool bHex, size_t size);
static ValueType GetTypeFromString(const char* name, int* typeArraySize); static ValueType GetTypeFromString(const char * name, int * typeArraySize);
private: private:
typedef struct typedef struct
{ {
const char* name; const char * name;
ValueType type; ValueType type;
} TypeNameEntry; } TypeNameEntry;
@ -139,17 +229,17 @@ public:
std::string m_Description; std::string m_Description;
public: public:
int GetValueString(char* buffer, size_t size); int GetValueString(char * buffer, size_t size);
int GetMemoryValueString(char* buffer, size_t size, bool bIgnoreHex = false); int GetMemoryValueString(char * buffer, size_t size, bool bIgnoreHex = false);
int GetAddressString(char *buffer); int GetAddressString(char * buffer);
uint32_t GetVirtualAddress(void); uint32_t GetVirtualAddress(void);
bool SetMemoryValueFromString(const char* str); bool SetMemoryValueFromString(const char * str);
//bool IsSelected(void); //bool IsSelected(void);
//void SetSelected(bool bSelected); //void SetSelected(bool bSelected);
void SetDescription(const char* str); void SetDescription(const char * str);
const char* GetDescription(void); const char * GetDescription(void);
void DeleteDescription(void); void DeleteDescription(void);
bool GetMemoryValue(CMixed* v); bool GetMemoryValue(CMixed * v);
bool SetAddressSafe(uint32_t address); bool SetAddressSafe(uint32_t address);
bool SetStrLengthSafe(int length); bool SetStrLengthSafe(int length);
@ -165,7 +255,7 @@ public:
bool SetSearchType(SearchType searchType); bool SetSearchType(SearchType searchType);
void SetAddressType(AddressType addressType); void SetAddressType(AddressType addressType);
static int ParseHexString(char* dst, const char* src); static int ParseHexString(char * dst, const char * src);
static bool AddrCheck(uint32_t addr, uint32_t rangeStart, uint32_t rangeEnd); static bool AddrCheck(uint32_t addr, uint32_t rangeStart, uint32_t rangeEnd);
static bool RangeCheck(uint32_t addrStart, uint32_t addrEnd, uint32_t rangeStart, uint32_t rangeEnd); static bool RangeCheck(uint32_t addrStart, uint32_t addrEnd, uint32_t rangeStart, uint32_t rangeEnd);
@ -175,7 +265,7 @@ public:
template <class T> template <class T>
void SetValue(T value) void SetValue(T value)
{ {
*(T*)&m_Value = value; *(T *)&m_Value = value;
} }
void SetStringValueLength(int length); void SetStringValueLength(int length);
@ -187,13 +277,13 @@ public:
bool DidFirstScan(void); bool DidFirstScan(void);
size_t GetNumResults(void); size_t GetNumResults(void);
CScanResult* GetResult(size_t index); CScanResult * GetResult(size_t index);
void RemoveResult(size_t index); void RemoveResult(size_t index);
private: private:
static int HexDigitVal(char c); static int HexDigitVal(char c);
uint8_t* m_Memory; uint8_t * m_Memory;
bool m_DidFirstScan; bool m_DidFirstScan;
uint32_t m_RangeStartAddress; uint32_t m_RangeStartAddress;
@ -212,24 +302,52 @@ private:
int m_StringValueLength; int m_StringValueLength;
friend class CScanResult; friend class CScanResult;
static uint8_t* GetMemoryPool(uint32_t physAddr); static uint8_t * GetMemoryPool(uint32_t physAddr);
template <class T> static bool CompareLessThan(T a, T b) { return a < b; } template <class T>
template <class T> static bool CompareLessThanOrEqual(T a, T b) { return a <= b; } static bool CompareLessThan(T a, T b)
template <class T> static bool CompareGreaterThan(T a, T b) { return a > b; } {
template <class T> static bool CompareGreaterThanOrEqual(T a, T b) { return a >= b; } return a < b;
template <class T> static bool CompareEqual(T a, T b) { return a == b; } }
template <class T> static bool CompareNotEqual(T a, T b) { return a != b; } template <class T>
template <class T> static bool NoCompare(T /*a*/, T /*b*/) { return true; } static bool CompareLessThanOrEqual(T a, T b)
{
return a <= b;
}
template <class T>
static bool CompareGreaterThan(T a, T b)
{
return a > b;
}
template <class T>
static bool CompareGreaterThanOrEqual(T a, T b)
{
return a >= b;
}
template <class T>
static bool CompareEqual(T a, T b)
{
return a == b;
}
template <class T>
static bool CompareNotEqual(T a, T b)
{
return a != b;
}
template <class T>
static bool NoCompare(T /*a*/, T /*b*/)
{
return true;
}
void FirstScanLoopString(DisplayFormat resultDisplayFormat); void FirstScanLoopString(DisplayFormat resultDisplayFormat);
void FirstScanLoopIString(DisplayFormat resultDisplayFormat); void FirstScanLoopIString(DisplayFormat resultDisplayFormat);
void FirstScanLoopUnkString(void); void FirstScanLoopUnkString(void);
template <class T> template <class T>
void FirstScanLoopPrimitive(bool(*CompareFunc)(T, T), DisplayFormat resultDisplayFormat) void FirstScanLoopPrimitive(bool (*CompareFunc)(T, T), DisplayFormat resultDisplayFormat)
{ {
T searchValue = *(T*)&m_Value; T searchValue = *(T *)&m_Value;
uint32_t startAddr = ((m_RangeStartAddress - 1) | (sizeof(T) - 1)) + 1; uint32_t startAddr = ((m_RangeStartAddress - 1) | (sizeof(T) - 1)) + 1;
uint32_t endAddr = m_RangeEndAddress; uint32_t endAddr = m_RangeEndAddress;
@ -238,7 +356,7 @@ private:
for (uint32_t addr = startAddr; addr <= endAddr; addr += sizeof(T)) for (uint32_t addr = startAddr; addr <= endAddr; addr += sizeof(T))
{ {
uint32_t leAddr = (addr ^ (4 - sizeof(T))); uint32_t leAddr = (addr ^ (4 - sizeof(T)));
T memValue = *(T*)&m_Memory[leAddr]; T memValue = *(T *)&m_Memory[leAddr];
if (CompareFunc(memValue, searchValue)) if (CompareFunc(memValue, searchValue))
{ {
@ -251,9 +369,9 @@ private:
// For int64 and double // For int64 and double
template <class T> template <class T>
void FirstScanLoopPrimitive64(bool(*CompareFunc)(T, T), DisplayFormat resultDisplayFormat) void FirstScanLoopPrimitive64(bool (*CompareFunc)(T, T), DisplayFormat resultDisplayFormat)
{ {
T searchValue = *(T*)&m_Value; T searchValue = *(T *)&m_Value;
uint32_t startAddr = ((m_RangeStartAddress - 1) | (sizeof(T) - 1)) + 1; uint32_t startAddr = ((m_RangeStartAddress - 1) | (sizeof(T) - 1)) + 1;
uint32_t endAddr = m_RangeEndAddress; uint32_t endAddr = m_RangeEndAddress;
@ -263,8 +381,8 @@ private:
{ {
T memValue; T memValue;
*((uint32_t*)(&memValue) + 1) = *(uint32_t*) &m_Memory[addr]; *((uint32_t *)(&memValue) + 1) = *(uint32_t *)&m_Memory[addr];
*((uint32_t*)(&memValue) + 0) = *(uint32_t*) &m_Memory[addr + 4]; *((uint32_t *)(&memValue) + 0) = *(uint32_t *)&m_Memory[addr + 4];
if (CompareFunc(memValue, searchValue)) if (CompareFunc(memValue, searchValue))
{ {
@ -277,17 +395,17 @@ private:
// Compare result's current value in memory against m_Value // Compare result's current value in memory against m_Value
template <class T> template <class T>
void NextScanLoopPrimitive(bool(*CompareFunc)(T, T)) void NextScanLoopPrimitive(bool (*CompareFunc)(T, T))
{ {
T searchValue = *(T*)&m_Value; T searchValue = *(T *)&m_Value;
for (size_t index = 0; index < m_Results.size(); index++) for (size_t index = 0; index < m_Results.size(); index++)
{ {
CScanResult* presult = &m_Results[index]; CScanResult * presult = &m_Results[index];
uint32_t addr = presult->m_Address & 0x1FFFFFFF; uint32_t addr = presult->m_Address & 0x1FFFFFFF;
uint32_t leAddr = (addr ^ (4 - sizeof(T))); uint32_t leAddr = (addr ^ (4 - sizeof(T)));
T memValue = *(T*) &m_Memory[leAddr]; T memValue = *(T *)&m_Memory[leAddr];
if (CompareFunc(memValue, searchValue)) if (CompareFunc(memValue, searchValue))
{ {
@ -302,19 +420,19 @@ private:
// Compare result's current value in memory against m_Value (for 64-bit types) // Compare result's current value in memory against m_Value (for 64-bit types)
template <class T> template <class T>
void NextScanLoopPrimitive64(bool(*CompareFunc)(T, T)) void NextScanLoopPrimitive64(bool (*CompareFunc)(T, T))
{ {
T searchValue = *(T*)&m_Value; T searchValue = *(T *)&m_Value;
for (size_t index = 0; index < m_Results.size(); index++) for (size_t index = 0; index < m_Results.size(); index++)
{ {
CScanResult* presult = &m_Results[index]; CScanResult * presult = &m_Results[index];
uint32_t addr = presult->m_Address & 0x1FFFFFFF; uint32_t addr = presult->m_Address & 0x1FFFFFFF;
T memValue; T memValue;
*((uint32_t*)(&memValue) + 1) = *(uint32_t*) &m_Memory[addr]; *((uint32_t *)(&memValue) + 1) = *(uint32_t *)&m_Memory[addr];
*((uint32_t*)(&memValue) + 0) = *(uint32_t*) &m_Memory[addr + 4]; *((uint32_t *)(&memValue) + 0) = *(uint32_t *)&m_Memory[addr + 4];
if (CompareFunc(memValue, searchValue)) if (CompareFunc(memValue, searchValue))
{ {
@ -329,17 +447,17 @@ private:
// Compare result's current value in memory against result's old value // Compare result's current value in memory against result's old value
template <class T> template <class T>
void NextScanLoopPrimitiveResults(bool(*CompareFunc)(T, T)) void NextScanLoopPrimitiveResults(bool (*CompareFunc)(T, T))
{ {
for (size_t index = 0; index < m_Results.size(); index++) for (size_t index = 0; index < m_Results.size(); index++)
{ {
CScanResult* presult = &m_Results[index]; CScanResult * presult = &m_Results[index];
uint32_t addr = presult->m_Address & 0x1FFFFFFF; uint32_t addr = presult->m_Address & 0x1FFFFFFF;
uint32_t leAddr = (addr ^ (4 - sizeof(T))); uint32_t leAddr = (addr ^ (4 - sizeof(T)));
T memValue, oldValue; T memValue, oldValue;
memValue = *(T*)&m_Memory[leAddr]; memValue = *(T *)&m_Memory[leAddr];
presult->Get(&oldValue); presult->Get(&oldValue);
if (CompareFunc(memValue, oldValue)) if (CompareFunc(memValue, oldValue))
@ -355,18 +473,18 @@ private:
// Compare result's current value in memory against result's old value (for 64-bit types) // Compare result's current value in memory against result's old value (for 64-bit types)
template <class T> template <class T>
void NextScanLoopPrimitiveResults64(bool(*CompareFunc)(T, T)) void NextScanLoopPrimitiveResults64(bool (*CompareFunc)(T, T))
{ {
for (size_t index = 0; index < m_Results.size(); index++) for (size_t index = 0; index < m_Results.size(); index++)
{ {
CScanResult* presult = &m_Results[index]; CScanResult * presult = &m_Results[index];
uint32_t addr = presult->m_Address & 0x1FFFFFFF; uint32_t addr = presult->m_Address & 0x1FFFFFFF;
T memValue, oldValue; T memValue, oldValue;
*((uint32_t*)(&memValue) + 1) = *(uint32_t*)&m_Memory[addr]; *((uint32_t *)(&memValue) + 1) = *(uint32_t *)&m_Memory[addr];
*((uint32_t*)(&memValue) + 0) = *(uint32_t*)&m_Memory[addr + 4]; *((uint32_t *)(&memValue) + 0) = *(uint32_t *)&m_Memory[addr + 4];
presult->Get(&oldValue); presult->Get(&oldValue);

58
Source/Project64/UserInterface/Debugger/OpInfo.h
View File

@ -5,14 +5,13 @@
class COpInfo class COpInfo
{ {
public: public:
R4300iOpcode m_OpCode; R4300iOpcode m_OpCode;
COpInfo() COpInfo()
{ {
} }
inline COpInfo(R4300iOpcode opcode): inline COpInfo(R4300iOpcode opcode) :
m_OpCode(opcode) m_OpCode(opcode)
{ {
} }
@ -135,14 +134,12 @@ public:
inline bool IsLoadCommand() inline bool IsLoadCommand()
{ {
return (m_OpCode.op >= R4300i_LDL && m_OpCode.op <= R4300i_LWU || return (m_OpCode.op >= R4300i_LDL && m_OpCode.op <= R4300i_LWU || m_OpCode.op >= R4300i_LL && m_OpCode.op <= R4300i_LD);
m_OpCode.op >= R4300i_LL && m_OpCode.op <= R4300i_LD);
} }
inline bool IsStoreCommand() inline bool IsStoreCommand()
{ {
return (m_OpCode.op >= R4300i_SB && m_OpCode.op <= R4300i_SWR || return (m_OpCode.op >= R4300i_SB && m_OpCode.op <= R4300i_SWR || m_OpCode.op >= R4300i_SC && m_OpCode.op <= R4300i_SD);
m_OpCode.op >= R4300i_SC && m_OpCode.op <= R4300i_SD);
} }
// ADDIU SP, SP, X // ADDIU SP, SP, X
@ -173,7 +170,7 @@ public:
return (short)m_OpCode.immediate > 0; return (short)m_OpCode.immediate > 0;
} }
void ReadsGPR(int* nReg1, int* nReg2) void ReadsGPR(int * nReg1, int * nReg2)
{ {
uint32_t op = m_OpCode.op; uint32_t op = m_OpCode.op;
@ -181,25 +178,21 @@ public:
{ {
uint32_t fn = m_OpCode.funct; uint32_t fn = m_OpCode.funct;
if (fn >= R4300i_SPECIAL_SLLV && fn <= R4300i_SPECIAL_SRAV || if (fn >= R4300i_SPECIAL_SLLV && fn <= R4300i_SPECIAL_SRAV || fn >= R4300i_SPECIAL_DSLLV && fn <= R4300i_SPECIAL_DSRAV || fn >= R4300i_SPECIAL_MULT && fn <= R4300i_SPECIAL_TNE)
fn >= R4300i_SPECIAL_DSLLV && fn <= R4300i_SPECIAL_DSRAV ||
fn >= R4300i_SPECIAL_MULT && fn <= R4300i_SPECIAL_TNE)
{ {
*nReg1 = m_OpCode.rs; *nReg1 = m_OpCode.rs;
*nReg2 = m_OpCode.rt; *nReg2 = m_OpCode.rt;
return; return;
} }
if (fn == R4300i_SPECIAL_MTLO || fn == R4300i_SPECIAL_MTHI || if (fn == R4300i_SPECIAL_MTLO || fn == R4300i_SPECIAL_MTHI || fn == R4300i_SPECIAL_JR || fn == R4300i_SPECIAL_JALR)
fn == R4300i_SPECIAL_JR || fn == R4300i_SPECIAL_JALR)
{ {
*nReg1 = m_OpCode.rs; *nReg1 = m_OpCode.rs;
*nReg2 = 0; *nReg2 = 0;
return; return;
} }
if (fn >= R4300i_SPECIAL_SLL && fn <= R4300i_SPECIAL_SRA || if (fn >= R4300i_SPECIAL_SLL && fn <= R4300i_SPECIAL_SRA || fn >= R4300i_SPECIAL_DSLL && fn <= R4300i_SPECIAL_DSRA32)
fn >= R4300i_SPECIAL_DSLL && fn <= R4300i_SPECIAL_DSRA32)
{ {
*nReg1 = m_OpCode.rt; *nReg1 = m_OpCode.rt;
*nReg2 = 0; *nReg2 = 0;
@ -211,21 +204,14 @@ public:
return; return;
} }
if (op >= R4300i_SB && op <= R4300i_SWR || if (op >= R4300i_SB && op <= R4300i_SWR || op == R4300i_SC || op == R4300i_SD || op == R4300i_BEQ || op == R4300i_BEQL || op == R4300i_BNE || op == R4300i_BNEL)
op == R4300i_SC || op == R4300i_SD ||
op == R4300i_BEQ || op == R4300i_BEQL ||
op == R4300i_BNE || op == R4300i_BNEL)
{ {
*nReg1 = m_OpCode.rs; *nReg1 = m_OpCode.rs;
*nReg2 = m_OpCode.rt; *nReg2 = m_OpCode.rt;
return; return;
} }
if (op >= R4300i_BLEZL && op <= R4300i_LWU || if (op >= R4300i_BLEZL && op <= R4300i_LWU || op >= R4300i_BLEZ && op <= R4300i_XORI || op >= R4300i_CACHE && op <= R4300i_LD || op >= R4300i_SWC1 && op <= R4300i_SDC2 || op == R4300i_REGIMM)
op >= R4300i_BLEZ && op <= R4300i_XORI ||
op >= R4300i_CACHE && op <= R4300i_LD ||
op >= R4300i_SWC1 && op <= R4300i_SDC2 ||
op == R4300i_REGIMM)
{ {
*nReg1 = m_OpCode.rs; *nReg1 = m_OpCode.rs;
*nReg2 = 0; *nReg2 = 0;
@ -241,9 +227,7 @@ public:
if (op == R4300i_CP1) if (op == R4300i_CP1)
{ {
if (m_OpCode.fmt == R4300i_COP1_MT || if (m_OpCode.fmt == R4300i_COP1_MT || m_OpCode.fmt == R4300i_COP1_DMT || m_OpCode.fmt == R4300i_COP1_CT)
m_OpCode.fmt == R4300i_COP1_DMT ||
m_OpCode.fmt == R4300i_COP1_CT)
{ {
*nReg1 = m_OpCode.rt; *nReg1 = m_OpCode.rt;
*nReg2 = 0; *nReg2 = 0;
@ -255,7 +239,7 @@ public:
*nReg2 = 0; *nReg2 = 0;
} }
inline void WritesGPR(int* nReg) inline void WritesGPR(int * nReg)
{ {
uint32_t op = m_OpCode.op; uint32_t op = m_OpCode.op;
@ -263,12 +247,7 @@ public:
{ {
uint32_t fn = m_OpCode.funct; uint32_t fn = m_OpCode.funct;
if (fn >= R4300i_SPECIAL_SLL && fn <= R4300i_SPECIAL_SRAV || if (fn >= R4300i_SPECIAL_SLL && fn <= R4300i_SPECIAL_SRAV || fn >= R4300i_SPECIAL_DSLLV && fn <= R4300i_SPECIAL_DSRAV || fn >= R4300i_SPECIAL_DIVU && fn <= R4300i_SPECIAL_DSUBU || fn >= R4300i_SPECIAL_DSLL && fn <= R4300i_SPECIAL_DSRA32 || fn == R4300i_SPECIAL_JALR || fn == R4300i_SPECIAL_MFLO || fn == R4300i_SPECIAL_MFHI)
fn >= R4300i_SPECIAL_DSLLV && fn <= R4300i_SPECIAL_DSRAV ||
fn >= R4300i_SPECIAL_DIVU && fn <= R4300i_SPECIAL_DSUBU ||
fn >= R4300i_SPECIAL_DSLL && fn <= R4300i_SPECIAL_DSRA32 ||
fn == R4300i_SPECIAL_JALR || fn == R4300i_SPECIAL_MFLO ||
fn == R4300i_SPECIAL_MFHI)
{ {
*nReg = m_OpCode.rd; *nReg = m_OpCode.rd;
return; return;
@ -278,12 +257,7 @@ public:
return; return;
} }
if (op >= R4300i_DADDI && op <= R4300i_LWU || if (op >= R4300i_DADDI && op <= R4300i_LWU || op >= R4300i_ADDI && op <= R4300i_LUI || op == R4300i_LL || op == R4300i_LD || (op == R4300i_CP0 && m_OpCode.fmt == R4300i_COP0_MF) || (op == R4300i_CP1 && m_OpCode.fmt == R4300i_COP1_MF) || (op == R4300i_CP1 && m_OpCode.fmt == R4300i_COP1_CF))
op >= R4300i_ADDI && op <= R4300i_LUI ||
op == R4300i_LL || op == R4300i_LD ||
(op == R4300i_CP0 && m_OpCode.fmt == R4300i_COP0_MF) ||
(op == R4300i_CP1 && m_OpCode.fmt == R4300i_COP1_MF) ||
(op == R4300i_CP1 && m_OpCode.fmt == R4300i_COP1_CF))
{ {
*nReg = m_OpCode.rt; *nReg = m_OpCode.rt;
return; return;
@ -312,8 +286,7 @@ public:
{ {
if (m_OpCode.op == R4300i_SPECIAL) if (m_OpCode.op == R4300i_SPECIAL)
{ {
if (m_OpCode.funct == R4300i_SPECIAL_MTHI || if (m_OpCode.funct == R4300i_SPECIAL_MTHI || m_OpCode.funct >= R4300i_SPECIAL_MULT && m_OpCode.funct <= R4300i_SPECIAL_DDIVU)
m_OpCode.funct >= R4300i_SPECIAL_MULT && m_OpCode.funct <= R4300i_SPECIAL_DDIVU)
{ {
return true; return true;
} }
@ -325,8 +298,7 @@ public:
{ {
if (m_OpCode.op == R4300i_SPECIAL) if (m_OpCode.op == R4300i_SPECIAL)
{ {
if (m_OpCode.funct == R4300i_SPECIAL_MTLO || if (m_OpCode.funct == R4300i_SPECIAL_MTLO || m_OpCode.funct >= R4300i_SPECIAL_MULT && m_OpCode.funct <= R4300i_SPECIAL_DDIVU)
m_OpCode.funct >= R4300i_SPECIAL_MULT && m_OpCode.funct <= R4300i_SPECIAL_DDIVU)
{ {
return true; return true;
} }

6
Source/Project64/UserInterface/Debugger/ScriptAPI/JSIntervalWorker.h
View File

@ -2,13 +2,15 @@
#pragma once #pragma once
class CJSIntervalWorker : public CScriptWorker { class CJSIntervalWorker : public CScriptWorker
{
private: private:
int m_DelayMS; int m_DelayMS;
bool m_bOnce; bool m_bOnce;
HANDLE m_hTimerQuitEvent; HANDLE m_hTimerQuitEvent;
public: public:
CJSIntervalWorker(CScriptInstance* inst, void* dukObjectHeapPtr, int delayMS, bool bOnce); CJSIntervalWorker(CScriptInstance * inst, void * dukObjectHeapPtr, int delayMS, bool bOnce);
virtual ~CJSIntervalWorker(); virtual ~CJSIntervalWorker();
virtual void WorkerProc(); virtual void WorkerProc();

27
Source/Project64/UserInterface/Debugger/ScriptAPI/JSServerWorker.cpp
View File

@ -3,7 +3,7 @@
#include "JSServerWorker.h" #include "JSServerWorker.h"
#include "JSSocketWorker.h" #include "JSSocketWorker.h"
CJSServerWorker::CJSServerWorker(CScriptInstance* instance, void* dukObjectHeapPtr) : CJSServerWorker::CJSServerWorker(CScriptInstance * instance, void * dukObjectHeapPtr) :
CScriptWorker(instance, dukObjectHeapPtr), CScriptWorker(instance, dukObjectHeapPtr),
m_bWinsockOK(false), m_bWinsockOK(false),
m_ServerSocket(INVALID_SOCKET) m_ServerSocket(INVALID_SOCKET)
@ -22,7 +22,7 @@ CJSServerWorker::~CJSServerWorker()
} }
} }
void CJSServerWorker::Init(const char* address, unsigned short port) void CJSServerWorker::Init(const char * address, unsigned short port)
{ {
m_Queue.listenAddress = address; m_Queue.listenAddress = address;
m_Queue.listenPort = port; m_Queue.listenPort = port;
@ -32,9 +32,10 @@ void CJSServerWorker::WorkerProc()
{ {
int rc; int rc;
union { union
SOCKADDR service; {
SOCKADDR_IN service_ipv4; SOCKADDR service;
SOCKADDR_IN service_ipv4;
SOCKADDR_IN6 service_ipv6; SOCKADDR_IN6 service_ipv6;
}; };
@ -74,8 +75,8 @@ void CJSServerWorker::WorkerProc()
goto stop_cleanup; goto stop_cleanup;
} }
rc = ::bind(m_ServerSocket, (const SOCKADDR*)&service, rc = ::bind(m_ServerSocket, (const SOCKADDR *)&service,
service.sa_family == AF_INET ? sizeof(service_ipv4) : sizeof(service_ipv6)); service.sa_family == AF_INET ? sizeof(service_ipv4) : sizeof(service_ipv6));
if (rc == SOCKET_ERROR) if (rc == SOCKET_ERROR)
{ {
@ -143,12 +144,12 @@ void CJSServerWorker::WorkerProc()
} }
stop_cleanup: stop_cleanup:
{ {
CGuard guard(m_CS); CGuard guard(m_CS);
strncpy(m_Address.address, "", sizeof(m_Address.address)); strncpy(m_Address.address, "", sizeof(m_Address.address));
m_Address.port = 0; m_Address.port = 0;
m_Address.family = ""; m_Address.family = "";
} }
if (m_ServerSocket != INVALID_SOCKET) if (m_ServerSocket != INVALID_SOCKET)
{ {

35
Source/Project64/UserInterface/Debugger/ScriptAPI/JSServerWorker.h
View File

@ -1,27 +1,34 @@
#pragma once #pragma once
#include "ScriptAPI.h"
#include <windows.h>
#include <winsock2.h> #include <winsock2.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
#include <windows.h>
#include "ScriptAPI.h"
class CJSServerWorker : public CScriptWorker class CJSServerWorker : public CScriptWorker
{ {
private: private:
enum { TIMEOUT_MS = 1 }; enum
{
TIMEOUT_MS = 1
};
struct ServerQueue { struct ServerQueue
{
CriticalSection cs; CriticalSection cs;
std::string listenAddress; std::string listenAddress;
unsigned short listenPort; unsigned short listenPort;
bool bClosePending; bool bClosePending;
ServerQueue() : listenAddress(""), listenPort(0), bClosePending(false) {} ServerQueue() :
listenAddress(""), listenPort(0), bClosePending(false)
{
}
} m_Queue; } m_Queue;
struct JSServerAddrInfo struct JSServerAddrInfo
{ {
char address[INET6_ADDRSTRLEN]; char address[INET6_ADDRSTRLEN];
const char* family; const char * family;
unsigned short port; unsigned short port;
JSServerAddrInfo() : JSServerAddrInfo() :
@ -37,24 +44,24 @@ private:
JSServerAddrInfo m_Address; JSServerAddrInfo m_Address;
public: public:
CJSServerWorker(CScriptInstance* instance, void* dukObjectHeapPtr); CJSServerWorker(CScriptInstance * instance, void * dukObjectHeapPtr);
virtual ~CJSServerWorker(); virtual ~CJSServerWorker();
void Init(const char* address, unsigned short port); void Init(const char * address, unsigned short port);
void WorkerProc(); void WorkerProc();
std::string GetAddress(); std::string GetAddress();
unsigned short GetPort(); unsigned short GetPort();
const char* GetFamily(); const char * GetFamily();
private: private:
void JSEmitConnection(SOCKET c); void JSEmitConnection(SOCKET c);
void JSEmitClose(); void JSEmitClose();
void JSEmitListening(); void JSEmitListening();
void JSEmitError(const char* errMessage); void JSEmitError(const char * errMessage);
static duk_idx_t CbArgs_EmitConnection(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitConnection(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_EmitClose(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitClose(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_EmitListening(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitListening(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_EmitError(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitError(duk_context * ctx, void * _env);
}; };

7
Source/Project64/UserInterface/Debugger/ScriptAPI/JSSocketWorker.cpp
View File

@ -69,9 +69,7 @@ bool CJSSocketWorker::Write(const char * data, size_t length, duk_int_t callback
{ {
CGuard guard(m_Queue.cs); CGuard guard(m_Queue.cs);
if (m_Queue.bFullClosePending || if (m_Queue.bFullClosePending || m_Queue.bSendClosePending || m_Queue.bSendClosed)
m_Queue.bSendClosePending ||
m_Queue.bSendClosed)
{ {
return false; return false;
} }
@ -313,8 +311,7 @@ void CJSSocketWorker::ProcSendData()
JSEmitError("send() error"); JSEmitError("send() error");
} }
if (m_Queue.writes.size() == 0 && if (m_Queue.writes.size() == 0 && m_Queue.bSendClosePending)
m_Queue.bSendClosePending)
{ {
shutdown(m_Socket, SD_SEND); shutdown(m_Socket, SD_SEND);
m_Queue.bSendClosePending = false; m_Queue.bSendClosePending = false;

58
Source/Project64/UserInterface/Debugger/ScriptAPI/JSSocketWorker.h
View File

@ -1,20 +1,23 @@
#include "../ScriptWorker.h"
#include "ScriptAPI.h"
#include <windows.h>
#include <winsock2.h> #include <winsock2.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
#include <windows.h> #pragma comment(lib, "Ws2_32.lib")
#include "ScriptAPI.h"
#include "../ScriptWorker.h"
#pragma comment (lib, "Ws2_32.lib")
#pragma once #pragma once
class CJSSocketWorker : public CScriptWorker class CJSSocketWorker : public CScriptWorker
{ {
private: private:
enum { TIMEOUT_MS = 1 }; enum
{
TIMEOUT_MS = 1
};
struct JSSocketAddrInfo struct JSSocketAddrInfo
{ {
char address[INET6_ADDRSTRLEN]; char address[INET6_ADDRSTRLEN];
const char* family; const char * family;
unsigned short port; unsigned short port;
JSSocketAddrInfo() : JSSocketAddrInfo() :
@ -32,8 +35,9 @@ private:
duk_int_t callbackId; duk_int_t callbackId;
}; };
struct JSEmitDataEnv { struct JSEmitDataEnv
char* data; {
char * data;
size_t size; size_t size;
}; };
@ -63,29 +67,29 @@ private:
} }
}; };
SOCKET m_Socket; SOCKET m_Socket;
bool m_bWinsockOK; bool m_bWinsockOK;
bool m_bAllowHalfOpen; bool m_bAllowHalfOpen;
JSSocketAddrInfo m_LocalAddress; JSSocketAddrInfo m_LocalAddress;
JSSocketAddrInfo m_RemoteAddress; JSSocketAddrInfo m_RemoteAddress;
JSSocketQueue m_Queue; JSSocketQueue m_Queue;
public: public:
CJSSocketWorker(CScriptInstance* inst, void* objectHeapPtr, bool bAllowHalfOpen); CJSSocketWorker(CScriptInstance * inst, void * objectHeapPtr, bool bAllowHalfOpen);
virtual ~CJSSocketWorker(); virtual ~CJSSocketWorker();
bool Init(SOCKET sock); bool Init(SOCKET sock);
bool Init(const char* host, unsigned short port); bool Init(const char * host, unsigned short port);
void WorkerProc(); void WorkerProc();
bool Write(const char* data, size_t length, duk_int_t callbackId, bool bEnd = false); bool Write(const char * data, size_t length, duk_int_t callbackId, bool bEnd = false);
//bool GetAddress(JSSocketAddrInfo& address); //bool GetAddress(JSSocketAddrInfo& address);
std::string GetLocalAddress(); std::string GetLocalAddress();
unsigned short GetLocalPort(); unsigned short GetLocalPort();
std::string GetRemoteAddress(); std::string GetRemoteAddress();
unsigned short GetRemotePort(); unsigned short GetRemotePort();
const char* GetFamily(); const char * GetFamily();
private: private:
bool ProcConnect(); bool ProcConnect();
@ -97,19 +101,19 @@ private:
void ClearQueue(); void ClearQueue();
void JSEmitConnect(); void JSEmitConnect();
void JSEmitData(const char* data, size_t size); void JSEmitData(const char * data, size_t size);
void JSEmitEnd(); void JSEmitEnd();
void JSEmitClose(); void JSEmitClose();
void JSEmitDrain(); void JSEmitDrain();
void JSEmitLookup(JSSocketAddrInfo& addr); void JSEmitLookup(JSSocketAddrInfo & addr);
void JSEmitError(const char* errMessage); void JSEmitError(const char * errMessage);
static duk_idx_t CbArgs_EmitConnect(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitConnect(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_EmitData(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitData(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_EmitEnd(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitEnd(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_EmitClose(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitClose(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_EmitDrain(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitDrain(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_EmitLookup(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitLookup(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_EmitError(duk_context* ctx, void* _env); static duk_idx_t CbArgs_EmitError(duk_context * ctx, void * _env);
static duk_idx_t CbArgs_Write(duk_context* ctx, void* _env); static duk_idx_t CbArgs_Write(duk_context * ctx, void * _env);
}; };

2
Source/Project64/UserInterface/Debugger/ScriptAPI/N64Image.cpp
View File

@ -510,7 +510,7 @@ const char * CN64Image::ResultCodeName(int resultCode)
{N64IMG_PNG_HEADER_MISSING, "ERR_PNG_HEADER_MISSING"}, {N64IMG_PNG_HEADER_MISSING, "ERR_PNG_HEADER_MISSING"},
{N64IMG_PNG_OUT_OF_MEMORY, "ERR_PNG_OUT_OF_MEMORY"}, {N64IMG_PNG_OUT_OF_MEMORY, "ERR_PNG_OUT_OF_MEMORY"},
{N64IMG_PNG_EXCEPTION, "ERR_PNG_EXCEPTION"}, {N64IMG_PNG_EXCEPTION, "ERR_PNG_EXCEPTION"},
{ N64IMG_PNG_PARSER_FAILED, "ERR_PNG_PARSER_FAILED" } {N64IMG_PNG_PARSER_FAILED, "ERR_PNG_PARSER_FAILED"},
}; };
if (names.count(resultCode) != 0) if (names.count(resultCode) != 0)

45
Source/Project64/UserInterface/Debugger/ScriptAPI/N64Image.h
View File

@ -1,7 +1,8 @@
#pragma once #pragma once
#include "ScriptAPI.h" #include "ScriptAPI.h"
enum { enum
{
G_IM_FMT_RGBA, G_IM_FMT_RGBA,
G_IM_FMT_YUV, G_IM_FMT_YUV,
G_IM_FMT_CI, G_IM_FMT_CI,
@ -9,20 +10,23 @@ enum {
G_IM_FMT_I G_IM_FMT_I
}; };
enum { enum
{
G_IM_SIZ_4b, G_IM_SIZ_4b,
G_IM_SIZ_8b, G_IM_SIZ_8b,
G_IM_SIZ_16b, G_IM_SIZ_16b,
G_IM_SIZ_32b G_IM_SIZ_32b
}; };
enum { enum
{
G_TT_NONE = 0x0000, G_TT_NONE = 0x0000,
G_TT_RGBA16 = 0x8000, G_TT_RGBA16 = 0x8000,
G_TT_IA16 = 0xC000, G_TT_IA16 = 0xC000,
}; };
enum { enum
{
IMG_RGBA16 = (G_IM_FMT_RGBA << 3 | G_IM_SIZ_16b), IMG_RGBA16 = (G_IM_FMT_RGBA << 3 | G_IM_SIZ_16b),
IMG_RGBA32 = (G_IM_FMT_RGBA << 3 | G_IM_SIZ_32b), IMG_RGBA32 = (G_IM_FMT_RGBA << 3 | G_IM_SIZ_32b),
IMG_CI4_RGBA16 = (G_IM_FMT_CI << 3 | G_IM_SIZ_4b) | G_TT_RGBA16, IMG_CI4_RGBA16 = (G_IM_FMT_CI << 3 | G_IM_SIZ_4b) | G_TT_RGBA16,
@ -36,7 +40,8 @@ enum {
IMG_I8 = (G_IM_FMT_I << 3 | G_IM_SIZ_8b), IMG_I8 = (G_IM_FMT_I << 3 | G_IM_SIZ_8b),
}; };
enum N64ImageResult { enum N64ImageResult
{
N64IMG_OK, N64IMG_OK,
N64IMG_DATA_SIZE_INCORRECT, N64IMG_DATA_SIZE_INCORRECT,
N64IMG_INVALID_COLOR_INDEX, N64IMG_INVALID_COLOR_INDEX,
@ -67,40 +72,40 @@ public:
CN64Image(); CN64Image();
int Init(int format, size_t width, size_t height, int Init(int format, size_t width, size_t height,
void* pixelData = nullptr, size_t pixelDataSize = 0, void * pixelData = nullptr, size_t pixelDataSize = 0,
void* paletteData = nullptr, size_t paletteDataSize = 0); void * paletteData = nullptr, size_t paletteDataSize = 0);
int Init(int format, uint8_t* pngData, size_t pngSize); int Init(int format, uint8_t * pngData, size_t pngSize);
void ToPNG(std::vector<uint8_t>& outPngImage); void ToPNG(std::vector<uint8_t> & outPngImage);
int UpdateBitmap(); int UpdateBitmap();
std::vector<uint8_t>& PaletteData(); std::vector<uint8_t> & PaletteData();
std::vector<uint8_t>& PixelData(); std::vector<uint8_t> & PixelData();
std::vector<uint8_t>& Bitmap(); std::vector<uint8_t> & Bitmap();
size_t Width(); size_t Width();
size_t Height(); size_t Height();
int Format(); int Format();
bool UsesPalette(); bool UsesPalette();
static int ReadPNG(uint8_t* pngData, size_t pngSize, size_t* width, size_t* height, std::vector<uint8_t>& outRGBA32); static int ReadPNG(uint8_t * pngData, size_t pngSize, size_t * width, size_t * height, std::vector<uint8_t> & outRGBA32);
static void WritePNG(uint8_t* rgba32, size_t width, size_t height, std::vector<uint8_t>& buffer); static void WritePNG(uint8_t * rgba32, size_t width, size_t height, std::vector<uint8_t> & buffer);
static unsigned int ColorFromRgba32(int dstFormat, uint32_t rgba32); static unsigned int ColorFromRgba32(int dstFormat, uint32_t rgba32);
static uint32_t ColorToRgba32(int srcFormat, unsigned int color); static uint32_t ColorToRgba32(int srcFormat, unsigned int color);
static int BitsPerPixel(int format); static int BitsPerPixel(int format);
static int PaletteColorCount(int format); static int PaletteColorCount(int format);
static bool UsesPalette(int format); static bool UsesPalette(int format);
static const char* ResultCodeName(int resultCode); static const char * ResultCodeName(int resultCode);
private: private:
uint16_t* PalettePtr(size_t index); uint16_t * PalettePtr(size_t index);
void* TexelPtr(size_t index); void * TexelPtr(size_t index);
uint32_t* BitmapPtr(size_t index); uint32_t * BitmapPtr(size_t index);
unsigned int GetTexel(size_t index); unsigned int GetTexel(size_t index);
void SetTexel(size_t index, unsigned int value); void SetTexel(size_t index, unsigned int value);
bool GetPaletteColor(size_t index, unsigned int* color); bool GetPaletteColor(size_t index, unsigned int * color);
bool SetPaletteColor(size_t index, unsigned int color); bool SetPaletteColor(size_t index, unsigned int color);
bool GetBitmapColor(size_t index, uint32_t* color); bool GetBitmapColor(size_t index, uint32_t * color);
bool SetBitmapColor(size_t index, unsigned int color); bool SetBitmapColor(size_t index, unsigned int color);
int UpdatePixelsAndPaletteFromBitmap(); int UpdatePixelsAndPaletteFromBitmap();
}; };

3
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI.cpp
View File

@ -841,8 +841,7 @@ void ScriptAPI::DukPutPropList(duk_context * ctx, duk_idx_t obj_idx, const DukPr
} }
else else
{ {
if (prop.typeId == Type_DukGetter || if (prop.typeId == Type_DukGetter || prop.typeId == Type_DukGetterSetter)
prop.typeId == Type_DukGetterSetter)
{ {
// not compatible // not compatible
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);

898
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI.h
View File

@ -1,462 +1,552 @@
#include "../ScriptTypes.h"
#include "../ScriptSystem.h"
#include "../ScriptInstance.h" #include "../ScriptInstance.h"
#include "../ScriptSystem.h"
#include "../ScriptTypes.h"
#pragma once #pragma once
#define PJ64_JSAPI_VERSION "jsapi-2" #define PJ64_JSAPI_VERSION "jsapi-2"
#define HS_gAppCallbacks DUK_HIDDEN_SYMBOL("gAppCallbacks") #define HS_gAppCallbacks DUK_HIDDEN_SYMBOL("gAppCallbacks")
#define HS_gInstancePtr DUK_HIDDEN_SYMBOL("gInstancePtr") #define HS_gInstancePtr DUK_HIDDEN_SYMBOL("gInstancePtr")
#define HS_gInputListener DUK_HIDDEN_SYMBOL("gInputListener") #define HS_gInputListener DUK_HIDDEN_SYMBOL("gInputListener")
#define HS_gOpenFileDescriptors DUK_HIDDEN_SYMBOL("gOpenFileDescriptors") #define HS_gOpenFileDescriptors DUK_HIDDEN_SYMBOL("gOpenFileDescriptors")
#define HS_gKeepAlive DUK_HIDDEN_SYMBOL("gKeepAlive") #define HS_gKeepAlive DUK_HIDDEN_SYMBOL("gKeepAlive")
#define HS_gPrivateCallEnabled DUK_HIDDEN_SYMBOL("gPrivateCallEnabled") #define HS_gPrivateCallEnabled DUK_HIDDEN_SYMBOL("gPrivateCallEnabled")
#define HS_gNativeModules DUK_HIDDEN_SYMBOL("gNativeModules") #define HS_gNativeModules DUK_HIDDEN_SYMBOL("gNativeModules")
#define HS_gObjectRefs DUK_HIDDEN_SYMBOL("gObjectRefs") #define HS_gObjectRefs DUK_HIDDEN_SYMBOL("gObjectRefs")
#define HS_gNextObjectRefId DUK_HIDDEN_SYMBOL("gNextObjectRefId") #define HS_gNextObjectRefId DUK_HIDDEN_SYMBOL("gNextObjectRefId")
#define HS_gIntervals DUK_HIDDEN_SYMBOL("gIntervals") #define HS_gIntervals DUK_HIDDEN_SYMBOL("gIntervals")
#define HS_gNextInvervalId DUK_HIDDEN_SYMBOL("gNextIntervalId") #define HS_gNextInvervalId DUK_HIDDEN_SYMBOL("gNextIntervalId")
#define HS_objectRefId DUK_HIDDEN_SYMBOL("objectRefId") #define HS_objectRefId DUK_HIDDEN_SYMBOL("objectRefId")
#define HS_emitterListeners DUK_HIDDEN_SYMBOL("emitterListeners") #define HS_emitterListeners DUK_HIDDEN_SYMBOL("emitterListeners")
#define HS_emitterNextListenerId DUK_HIDDEN_SYMBOL("emitterNextListenerId") #define HS_emitterNextListenerId DUK_HIDDEN_SYMBOL("emitterNextListenerId")
#define HS_socketWorkerPtr DUK_HIDDEN_SYMBOL("socketWorkerPtr") #define HS_socketWorkerPtr DUK_HIDDEN_SYMBOL("socketWorkerPtr")
#define HS_socketNextWriteCallbackId DUK_HIDDEN_SYMBOL("nextWriteCallbackId") #define HS_socketNextWriteCallbackId DUK_HIDDEN_SYMBOL("nextWriteCallbackId")
#define HS_socketWriteCallbacks DUK_HIDDEN_SYMBOL("writeCallbacks") #define HS_socketWriteCallbacks DUK_HIDDEN_SYMBOL("writeCallbacks")
#define HS_socketWriteEndCallbacks DUK_HIDDEN_SYMBOL("endCallbacks") #define HS_socketWriteEndCallbacks DUK_HIDDEN_SYMBOL("endCallbacks")
#define HS_serverWorkerPtr DUK_HIDDEN_SYMBOL("serverWorkerPtr") #define HS_serverWorkerPtr DUK_HIDDEN_SYMBOL("serverWorkerPtr")
#define HS_renderWindowPtr DUK_HIDDEN_SYMBOL("renderWindowPtr") #define HS_renderWindowPtr DUK_HIDDEN_SYMBOL("renderWindowPtr")
#define HS_n64ImagePtr DUK_HIDDEN_SYMBOL("n64ImagePtr") #define HS_n64ImagePtr DUK_HIDDEN_SYMBOL("n64ImagePtr")
namespace ScriptAPI namespace ScriptAPI
{ {
struct DukPropListEntry; struct DukPropListEntry;
enum MemType { enum MemType
U8, U16, U32, S8, S16, S32, F32, F64, {
U64, S64 U8,
}; U16,
U32,
S8,
S16,
S32,
F32,
F64,
U64,
S64
};
enum ArgType { enum ArgType
Arg_Any, {
Arg_Number, Arg_Any,
Arg_BufferData, Arg_Number,
Arg_String, Arg_BufferData,
Arg_Function, Arg_String,
Arg_Object, Arg_Function,
Arg_Array, Arg_Object,
Arg_Boolean, Arg_Array,
Arg_Boolean,
ArgAttr_Optional = (1 << 31), ArgAttr_Optional = (1 << 31),
Arg_OptAny = Arg_Any | ArgAttr_Optional, Arg_OptAny = Arg_Any | ArgAttr_Optional,
Arg_OptNumber = Arg_Number | ArgAttr_Optional, Arg_OptNumber = Arg_Number | ArgAttr_Optional,
Arg_OptBufferData = Arg_BufferData | ArgAttr_Optional, Arg_OptBufferData = Arg_BufferData | ArgAttr_Optional,
Arg_OptString = Arg_String | ArgAttr_Optional, Arg_OptString = Arg_String | ArgAttr_Optional,
Arg_OptFunction = Arg_Function | ArgAttr_Optional, Arg_OptFunction = Arg_Function | ArgAttr_Optional,
Arg_OptObject = Arg_Object | ArgAttr_Optional, Arg_OptObject = Arg_Object | ArgAttr_Optional,
Arg_OptArray = Arg_Array | ArgAttr_Optional, Arg_OptArray = Arg_Array | ArgAttr_Optional,
Arg_OptBoolean = Arg_Boolean | ArgAttr_Optional, Arg_OptBoolean = Arg_Boolean | ArgAttr_Optional,
ArgAttrs = ArgAttr_Optional ArgAttrs = ArgAttr_Optional
}; };
// ScriptAPI // ScriptAPI
void InitEnvironment(duk_context* ctx, CScriptInstance* inst); void InitEnvironment(duk_context * ctx, CScriptInstance * inst);
void DefineGlobalConstants(duk_context* ctx); void DefineGlobalConstants(duk_context * ctx);
void DefineGlobalClass(duk_context* ctx, const char* className, void DefineGlobalClass(duk_context * ctx, const char * className,
duk_c_function constructorFunc, duk_c_function constructorFunc,
const DukPropListEntry* prototypeProps = nullptr, const DukPropListEntry * prototypeProps = nullptr,
const DukPropListEntry* staticProps = nullptr); const DukPropListEntry * staticProps = nullptr);
void DefineGlobalInterface(duk_context* ctx, const char* name, const DukPropListEntry* props); void DefineGlobalInterface(duk_context * ctx, const char * name, const DukPropListEntry * props);
void DefineGlobalFunction(duk_context* ctx, const char* name, duk_c_function func); void DefineGlobalFunction(duk_context * ctx, const char * name, duk_c_function func);
CScriptInstance* GetInstance(duk_context* ctx); CScriptInstance * GetInstance(duk_context * ctx);
JSAppCallbackID AddAppCallback(duk_context* ctx, duk_idx_t callbackFuncIdx, JSAppCallbackID AddAppCallback(duk_context * ctx, duk_idx_t callbackFuncIdx,
JSAppHookID hookId, JSAppHookID hookId,
JSDukArgSetupFunc argSetupFunc = nullptr, JSDukArgSetupFunc argSetupFunc = nullptr,
JSAppCallbackCondFunc conditionFunc = nullptr, JSAppCallbackCondFunc conditionFunc = nullptr,
JSAppCallbackCleanupFunc cleanupFunc = nullptr); JSAppCallbackCleanupFunc cleanupFunc = nullptr);
JSAppCallbackID AddAppCallback(duk_context* ctx, JSAppHookID hookId, JSAppCallback& callback); JSAppCallbackID AddAppCallback(duk_context * ctx, JSAppHookID hookId, JSAppCallback & callback);
bool RemoveAppCallback(duk_context* ctx, JSAppCallbackID callbackId); bool RemoveAppCallback(duk_context * ctx, JSAppCallbackID callbackId);
duk_ret_t js__AppCallbackFinalizer(duk_context* ctx); duk_ret_t js__AppCallbackFinalizer(duk_context * ctx);
void RefObject(duk_context* ctx, duk_idx_t idx); void RefObject(duk_context * ctx, duk_idx_t idx);
void UnrefObject(duk_context* ctx, duk_idx_t idx); void UnrefObject(duk_context * ctx, duk_idx_t idx);
duk_ret_t js__UnrefObject(duk_context* ctx); duk_ret_t js__UnrefObject(duk_context * ctx);
void InitEmitter(duk_context* ctx, duk_idx_t obj_idx, const std::vector<std::string>& eventNames); void InitEmitter(duk_context * ctx, duk_idx_t obj_idx, const std::vector<std::string> & eventNames);
duk_ret_t js__Emitter_emit(duk_context* ctx); duk_ret_t js__Emitter_emit(duk_context * ctx);
duk_ret_t js__Emitter_on(duk_context* ctx); duk_ret_t js__Emitter_on(duk_context * ctx);
duk_ret_t js__Emitter_off(duk_context* ctx); duk_ret_t js__Emitter_off(duk_context * ctx);
duk_ret_t js_Duktape_modSearch(duk_context* ctx); // require() duk_ret_t js_Duktape_modSearch(duk_context * ctx); // require()
void RegisterNativeModule(duk_context* ctx, HMODULE hModule); void RegisterNativeModule(duk_context * ctx, HMODULE hModule);
duk_ret_t js__NativeModuleFinalizer(duk_context* ctx); duk_ret_t js__NativeModuleFinalizer(duk_context * ctx);
void AllowPrivateCall(duk_context* ctx, bool bAllow); void AllowPrivateCall(duk_context * ctx, bool bAllow);
bool PrivateCallAllowed(duk_context* ctx); bool PrivateCallAllowed(duk_context * ctx);
void PushNewDummyConstructor(duk_context* ctx, bool bFrozen = true); void PushNewDummyConstructor(duk_context * ctx, bool bFrozen = true);
void DefineGlobalDummyConstructors(duk_context* ctx, const char* constructorNames[], bool bFreeze = true); void DefineGlobalDummyConstructors(duk_context * ctx, const char * constructorNames[], bool bFreeze = true);
void SetDummyConstructor(duk_context* ctx, duk_idx_t obj_idx, const char* globalConstructorName); void SetDummyConstructor(duk_context * ctx, duk_idx_t obj_idx, const char * globalConstructorName);
duk_ret_t js_DummyConstructor(duk_context* ctx); duk_ret_t js_DummyConstructor(duk_context * ctx);
const char* ArgTypeName(ArgType argType); const char * ArgTypeName(ArgType argType);
duk_bool_t ArgTypeMatches(duk_context* ctx, duk_idx_t idx, ArgType wantType); duk_bool_t ArgTypeMatches(duk_context * ctx, duk_idx_t idx, ArgType wantType);
duk_ret_t CheckArgs(duk_context* ctx, const std::vector<ArgType>& argTypes); duk_ret_t CheckArgs(duk_context * ctx, const std::vector<ArgType> & argTypes);
duk_ret_t CheckSetterAssignment(duk_context* ctx, ArgType wantType); duk_ret_t CheckSetterAssignment(duk_context * ctx, ArgType wantType);
duk_ret_t ThrowInvalidArgsError(duk_context* ctx); duk_ret_t ThrowInvalidArgsError(duk_context * ctx);
duk_ret_t ThrowInvalidArgError(duk_context* ctx, duk_idx_t idx, ArgType wantType); duk_ret_t ThrowInvalidArgError(duk_context * ctx, duk_idx_t idx, ArgType wantType);
duk_ret_t ThrowTooManyArgsError(duk_context* ctx); duk_ret_t ThrowTooManyArgsError(duk_context * ctx);
duk_ret_t ThrowInvalidAssignmentError(duk_context* ctx, ArgType wantType); duk_ret_t ThrowInvalidAssignmentError(duk_context * ctx, ArgType wantType);
duk_ret_t ThrowNotCallableError(duk_context* ctx); duk_ret_t ThrowNotCallableError(duk_context * ctx);
void DebugStack(duk_context* ctx, const char* file, int line); void DebugStack(duk_context * ctx, const char * file, int line);
// ScriptAPI_events // ScriptAPI_events
void Define_events(duk_context* ctx); void Define_events(duk_context * ctx);
duk_ret_t js_events_onstatechange(duk_context* ctx); duk_ret_t js_events_onstatechange(duk_context * ctx);
duk_ret_t js_events_onexec(duk_context* ctx); duk_ret_t js_events_onexec(duk_context * ctx);
duk_ret_t js_events_onread(duk_context* ctx); duk_ret_t js_events_onread(duk_context * ctx);
duk_ret_t js_events_onwrite(duk_context* ctx); duk_ret_t js_events_onwrite(duk_context * ctx);
duk_ret_t js_events_onopcode(duk_context* ctx); duk_ret_t js_events_onopcode(duk_context * ctx);
duk_ret_t js_events_ongprvalue(duk_context* ctx); duk_ret_t js_events_ongprvalue(duk_context * ctx);
duk_ret_t js_events_onpifread(duk_context* ctx); duk_ret_t js_events_onpifread(duk_context * ctx);
duk_ret_t js_events_onsptask(duk_context* ctx); duk_ret_t js_events_onsptask(duk_context * ctx);
duk_ret_t js_events_onpidma(duk_context* ctx); duk_ret_t js_events_onpidma(duk_context * ctx);
duk_ret_t js_events_onmouseup(duk_context* ctx); duk_ret_t js_events_onmouseup(duk_context * ctx);
duk_ret_t js_events_onmousedown(duk_context* ctx); duk_ret_t js_events_onmousedown(duk_context * ctx);
duk_ret_t js_events_onmousemove(duk_context* ctx); duk_ret_t js_events_onmousemove(duk_context * ctx);
duk_ret_t js_events_remove(duk_context* ctx); duk_ret_t js_events_remove(duk_context * ctx);
// ScriptAPI_console // ScriptAPI_console
void Define_console(duk_context* ctx); void Define_console(duk_context * ctx);
duk_ret_t js_console_print(duk_context* ctx); duk_ret_t js_console_print(duk_context * ctx);
duk_ret_t js_console_log(duk_context* ctx); duk_ret_t js_console_log(duk_context * ctx);
duk_ret_t js_console_error(duk_context* ctx); duk_ret_t js_console_error(duk_context * ctx);
duk_ret_t js_console_clear(duk_context* ctx); duk_ret_t js_console_clear(duk_context * ctx);
duk_ret_t js_console_listen(duk_context* ctx); duk_ret_t js_console_listen(duk_context * ctx);
// ScriptAPI_mem // ScriptAPI_mem
void Define_mem(duk_context* ctx); void Define_mem(duk_context * ctx);
template <class T> duk_ret_t js_mem__get(duk_context* ctx); template <class T>
template <class T> duk_ret_t js_mem__set(duk_context* ctx); duk_ret_t js_mem__get(duk_context * ctx);
duk_ret_t js_mem__boundget(duk_context* ctx); template <class T>
duk_ret_t js_mem__boundset(duk_context* ctx); duk_ret_t js_mem__set(duk_context * ctx);
duk_ret_t js_mem__type_constructor(duk_context* ctx); duk_ret_t js_mem__boundget(duk_context * ctx);
duk_ret_t js_mem__get_ramsize(duk_context* ctx); duk_ret_t js_mem__boundset(duk_context * ctx);
duk_ret_t js_mem__get_romsize(duk_context* ctx); duk_ret_t js_mem__type_constructor(duk_context * ctx);
duk_ret_t js_mem__get_ptr(duk_context* ctx); duk_ret_t js_mem__get_ramsize(duk_context * ctx);
duk_ret_t js_mem_getblock(duk_context* ctx); duk_ret_t js_mem__get_romsize(duk_context * ctx);
duk_ret_t js_mem_getstring(duk_context* ctx); duk_ret_t js_mem__get_ptr(duk_context * ctx);
duk_ret_t js_mem_setblock(duk_context* ctx); duk_ret_t js_mem_getblock(duk_context * ctx);
duk_ret_t js_mem_bindvar(duk_context* ctx); duk_ret_t js_mem_getstring(duk_context * ctx);
duk_ret_t js_mem_bindvars(duk_context* ctx); duk_ret_t js_mem_setblock(duk_context * ctx);
duk_ret_t js_mem_bindstruct(duk_context* ctx); duk_ret_t js_mem_bindvar(duk_context * ctx);
duk_ret_t js_mem_typedef(duk_context* ctx); duk_ret_t js_mem_bindvars(duk_context * ctx);
duk_ret_t js_mem_bindstruct(duk_context * ctx);
duk_ret_t js_mem_typedef(duk_context * ctx);
// ScriptAPI_Server // ScriptAPI_Server
void Define_Server(duk_context* ctx); void Define_Server(duk_context * ctx);
duk_ret_t js_Server__constructor(duk_context* ctx); duk_ret_t js_Server__constructor(duk_context * ctx);
duk_ret_t js_Server__finalizer(duk_context* ctx); duk_ret_t js_Server__finalizer(duk_context * ctx);
duk_ret_t js_Server__get_port(duk_context* ctx); duk_ret_t js_Server__get_port(duk_context * ctx);
duk_ret_t js_Server__get_address(duk_context* ctx); duk_ret_t js_Server__get_address(duk_context * ctx);
duk_ret_t js_Server__get_addressFamily(duk_context* ctx); duk_ret_t js_Server__get_addressFamily(duk_context * ctx);
duk_ret_t js_Server_listen(duk_context* ctx); duk_ret_t js_Server_listen(duk_context * ctx);
duk_ret_t js_Server_close(duk_context* ctx); duk_ret_t js_Server_close(duk_context * ctx);
// ScriptAPI_Socket // ScriptAPI_Socket
void Define_Socket(duk_context* ctx); void Define_Socket(duk_context * ctx);
duk_ret_t js_Socket__constructor(duk_context* ctx); duk_ret_t js_Socket__constructor(duk_context * ctx);
duk_ret_t js_Socket__finalizer(duk_context* ctx); duk_ret_t js_Socket__finalizer(duk_context * ctx);
duk_ret_t js_Socket__invokeWriteCallback(duk_context* ctx); duk_ret_t js_Socket__invokeWriteCallback(duk_context * ctx);
duk_ret_t js_Socket__invokeWriteEndCallbacks(duk_context* ctx); duk_ret_t js_Socket__invokeWriteEndCallbacks(duk_context * ctx);
duk_ret_t js_Socket_connect(duk_context* ctx); duk_ret_t js_Socket_connect(duk_context * ctx);
duk_ret_t js_Socket_write(duk_context* ctx); duk_ret_t js_Socket_write(duk_context * ctx);
duk_ret_t js_Socket_end(duk_context* ctx); duk_ret_t js_Socket_end(duk_context * ctx);
duk_ret_t js_Socket_close(duk_context* ctx); duk_ret_t js_Socket_close(duk_context * ctx);
duk_ret_t js_Socket__get_localAddress(duk_context* ctx); duk_ret_t js_Socket__get_localAddress(duk_context * ctx);
duk_ret_t js_Socket__get_localPort(duk_context* ctx); duk_ret_t js_Socket__get_localPort(duk_context * ctx);
duk_ret_t js_Socket__get_remoteAddress(duk_context* ctx); duk_ret_t js_Socket__get_remoteAddress(duk_context * ctx);
duk_ret_t js_Socket__get_remotePort(duk_context* ctx); duk_ret_t js_Socket__get_remotePort(duk_context * ctx);
duk_ret_t js_Socket__get_addressFamily(duk_context* ctx); duk_ret_t js_Socket__get_addressFamily(duk_context * ctx);
// ScriptAPI_script // ScriptAPI_script
void Define_script(duk_context* ctx); void Define_script(duk_context * ctx);
duk_ret_t js_script_keepalive(duk_context* ctx); duk_ret_t js_script_keepalive(duk_context * ctx);
duk_ret_t js_script_timeout(duk_context* ctx); duk_ret_t js_script_timeout(duk_context * ctx);
duk_ret_t js_script_abort(duk_context* ctx); duk_ret_t js_script_abort(duk_context * ctx);
// ScriptAPI_fs // ScriptAPI_fs
void Define_fs(duk_context* ctx); void Define_fs(duk_context * ctx);
duk_ret_t js_fs_open(duk_context* ctx); duk_ret_t js_fs_open(duk_context * ctx);
duk_ret_t js_fs_close(duk_context* ctx); duk_ret_t js_fs_close(duk_context * ctx);
duk_ret_t js_fs_write(duk_context* ctx); duk_ret_t js_fs_write(duk_context * ctx);
duk_ret_t js_fs_writefile(duk_context* ctx); duk_ret_t js_fs_writefile(duk_context * ctx);
duk_ret_t js_fs_read(duk_context* ctx); duk_ret_t js_fs_read(duk_context * ctx);
duk_ret_t js_fs_readfile(duk_context* ctx); duk_ret_t js_fs_readfile(duk_context * ctx);
duk_ret_t js_fs_exists(duk_context* ctx); duk_ret_t js_fs_exists(duk_context * ctx);
duk_ret_t js_fs_fstat(duk_context* ctx); duk_ret_t js_fs_fstat(duk_context * ctx);
duk_ret_t js_fs_stat(duk_context* ctx); duk_ret_t js_fs_stat(duk_context * ctx);
duk_ret_t js_fs_unlink(duk_context* ctx); duk_ret_t js_fs_unlink(duk_context * ctx);
duk_ret_t js_fs_mkdir(duk_context* ctx); duk_ret_t js_fs_mkdir(duk_context * ctx);
duk_ret_t js_fs_rmdir(duk_context* ctx); duk_ret_t js_fs_rmdir(duk_context * ctx);
duk_ret_t js_fs_readdir(duk_context* ctx); duk_ret_t js_fs_readdir(duk_context * ctx);
duk_ret_t js_fs_Stats__constructor(duk_context* ctx); duk_ret_t js_fs_Stats__constructor(duk_context * ctx);
duk_ret_t js_fs_Stats_isDirectory(duk_context* ctx); duk_ret_t js_fs_Stats_isDirectory(duk_context * ctx);
duk_ret_t js_fs_Stats_isFile(duk_context* ctx); duk_ret_t js_fs_Stats_isFile(duk_context * ctx);
// ScriptAPI_debug // ScriptAPI_debug
void Define_debug(duk_context* ctx); void Define_debug(duk_context * ctx);
duk_ret_t js_debug__get_paused(duk_context* ctx); duk_ret_t js_debug__get_paused(duk_context * ctx);
duk_ret_t js_debug_breakhere(duk_context* ctx); duk_ret_t js_debug_breakhere(duk_context * ctx);
duk_ret_t js_debug_step(duk_context* ctx); duk_ret_t js_debug_step(duk_context * ctx);
duk_ret_t js_debug_skip(duk_context* ctx); duk_ret_t js_debug_skip(duk_context * ctx);
duk_ret_t js_debug_resume(duk_context* ctx); duk_ret_t js_debug_resume(duk_context * ctx);
duk_ret_t js_debug_showmemory(duk_context* ctx); duk_ret_t js_debug_showmemory(duk_context * ctx);
duk_ret_t js_debug_showcommands(duk_context* ctx); duk_ret_t js_debug_showcommands(duk_context * ctx);
// ScriptAPI_asm // ScriptAPI_asm
void Define_asm(duk_context* ctx); void Define_asm(duk_context * ctx);
duk_ret_t js_asm_gprname(duk_context* ctx); duk_ret_t js_asm_gprname(duk_context * ctx);
duk_ret_t js_asm_encode(duk_context* ctx); duk_ret_t js_asm_encode(duk_context * ctx);
duk_ret_t js_asm_decode(duk_context* ctx); duk_ret_t js_asm_decode(duk_context * ctx);
// ScriptAPI_cpu // ScriptAPI_cpu
void Define_cpu(duk_context* ctx); void Define_cpu(duk_context * ctx);
duk_ret_t js_cpu_get(duk_context* ctx); duk_ret_t js_cpu_get(duk_context * ctx);
duk_ret_t js_cpu_set(duk_context* ctx); duk_ret_t js_cpu_set(duk_context * ctx);
duk_ret_t js_cpu_gpr_get(duk_context* ctx); duk_ret_t js_cpu_gpr_get(duk_context * ctx);
duk_ret_t js_cpu_gpr_set(duk_context* ctx); duk_ret_t js_cpu_gpr_set(duk_context * ctx);
duk_ret_t js_cpu_ugpr_get(duk_context* ctx); duk_ret_t js_cpu_ugpr_get(duk_context * ctx);
duk_ret_t js_cpu_ugpr_set(duk_context* ctx); duk_ret_t js_cpu_ugpr_set(duk_context * ctx);
duk_ret_t js_cpu_fpr_get(duk_context* ctx); duk_ret_t js_cpu_fpr_get(duk_context * ctx);
duk_ret_t js_cpu_fpr_set(duk_context* ctx); duk_ret_t js_cpu_fpr_set(duk_context * ctx);
duk_ret_t js_cpu_dfpr_get(duk_context* ctx); duk_ret_t js_cpu_dfpr_get(duk_context * ctx);
duk_ret_t js_cpu_dfpr_set(duk_context* ctx); duk_ret_t js_cpu_dfpr_set(duk_context * ctx);
duk_ret_t js_cpu_cop0_get(duk_context* ctx); duk_ret_t js_cpu_cop0_get(duk_context * ctx);
duk_ret_t js_cpu_cop0_set(duk_context* ctx); duk_ret_t js_cpu_cop0_set(duk_context * ctx);
// ScriptAPI_pj64 // ScriptAPI_pj64
void Define_pj64(duk_context* ctx); void Define_pj64(duk_context * ctx);
duk_ret_t js_pj64_open(duk_context* ctx); duk_ret_t js_pj64_open(duk_context * ctx);
duk_ret_t js_pj64_close(duk_context* ctx); duk_ret_t js_pj64_close(duk_context * ctx);
duk_ret_t js_pj64_reset(duk_context* ctx); duk_ret_t js_pj64_reset(duk_context * ctx);
duk_ret_t js_pj64_pause(duk_context* ctx); duk_ret_t js_pj64_pause(duk_context * ctx);
duk_ret_t js_pj64_resume(duk_context* ctx); duk_ret_t js_pj64_resume(duk_context * ctx);
duk_ret_t js_pj64_limitfps(duk_context* ctx); duk_ret_t js_pj64_limitfps(duk_context * ctx);
duk_ret_t js_pj64__get_installDirectory(duk_context* ctx); duk_ret_t js_pj64__get_installDirectory(duk_context * ctx);
duk_ret_t js_pj64__get_scriptsDirectory(duk_context* ctx); duk_ret_t js_pj64__get_scriptsDirectory(duk_context * ctx);
duk_ret_t js_pj64__get_modulesDirectory(duk_context* ctx); duk_ret_t js_pj64__get_modulesDirectory(duk_context * ctx);
duk_ret_t js_pj64__get_romDirectory(duk_context* ctx); duk_ret_t js_pj64__get_romDirectory(duk_context * ctx);
duk_ret_t js_pj64__get_romInfo(duk_context* ctx); duk_ret_t js_pj64__get_romInfo(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_goodName(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_goodName(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_fileName(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_fileName(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_filePath(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_filePath(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_headerCrc1(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_headerCrc1(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_headerCrc2(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_headerCrc2(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_headerName(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_headerName(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_headerMediaFormat(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_headerMediaFormat(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_headerId(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_headerId(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_headerCountryCode(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_headerCountryCode(duk_context * ctx);
duk_ret_t js_pj64_romInfo__get_headerVersion(duk_context* ctx); duk_ret_t js_pj64_romInfo__get_headerVersion(duk_context * ctx);
// ScriptAPI_AddressRange // ScriptAPI_AddressRange
void Define_AddressRange(duk_context* ctx); void Define_AddressRange(duk_context * ctx);
duk_ret_t js_AddressRange__constructor(duk_context* ctx); duk_ret_t js_AddressRange__constructor(duk_context * ctx);
duk_ret_t js_AddressRange_size(duk_context* ctx); duk_ret_t js_AddressRange_size(duk_context * ctx);
duk_ret_t js_AddressRange_includes(duk_context* ctx); duk_ret_t js_AddressRange_includes(duk_context * ctx);
duk_ret_t js_AddressRange_offset(duk_context* ctx); duk_ret_t js_AddressRange_offset(duk_context * ctx);
duk_ret_t js_AddressRange_address(duk_context* ctx); duk_ret_t js_AddressRange_address(duk_context * ctx);
// ScriptAPI_Number_hex // ScriptAPI_Number_hex
void Define_Number_prototype_hex(duk_context* ctx); void Define_Number_prototype_hex(duk_context * ctx);
duk_ret_t js_Number_prototype_hex(duk_context* ctx); duk_ret_t js_Number_prototype_hex(duk_context * ctx);
// ScriptAPI_N64Image // ScriptAPI_N64Image
void Define_N64Image(duk_context* ctx); void Define_N64Image(duk_context * ctx);
duk_ret_t js_N64Image__constructor(duk_context* ctx); duk_ret_t js_N64Image__constructor(duk_context * ctx);
duk_ret_t js_N64Image__finalizer(duk_context* ctx); duk_ret_t js_N64Image__finalizer(duk_context * ctx);
duk_ret_t js_N64Image_static_fromPNG(duk_context* ctx); duk_ret_t js_N64Image_static_fromPNG(duk_context * ctx);
duk_ret_t js_N64Image_static_format(duk_context* ctx); duk_ret_t js_N64Image_static_format(duk_context * ctx);
duk_ret_t js_N64Image_static_bpp(duk_context* ctx); duk_ret_t js_N64Image_static_bpp(duk_context * ctx);
duk_ret_t js_N64Image_toPNG(duk_context* ctx); duk_ret_t js_N64Image_toPNG(duk_context * ctx);
duk_ret_t js_N64Image_update(duk_context* ctx); duk_ret_t js_N64Image_update(duk_context * ctx);
// ScriptAPI_exec // ScriptAPI_exec
void Define_exec(duk_context* ctx); void Define_exec(duk_context * ctx);
duk_ret_t js_exec(duk_context* ctx); duk_ret_t js_exec(duk_context * ctx);
// ScriptAPI_alert // ScriptAPI_alert
void Define_alert(duk_context* ctx); void Define_alert(duk_context * ctx);
duk_ret_t js_alert(duk_context* ctx); duk_ret_t js_alert(duk_context * ctx);
// ScriptAPI_interval // ScriptAPI_interval
void Define_interval(duk_context* ctx); void Define_interval(duk_context * ctx);
duk_ret_t js_setInterval(duk_context* ctx); duk_ret_t js_setInterval(duk_context * ctx);
duk_ret_t js_clearInterval(duk_context* ctx); duk_ret_t js_clearInterval(duk_context * ctx);
duk_ret_t js_setTimeout(duk_context* ctx); duk_ret_t js_setTimeout(duk_context * ctx);
duk_ret_t js_clearTimeout(duk_context* ctx); duk_ret_t js_clearTimeout(duk_context * ctx);
duk_ret_t js__IntervalContext_invokeFunc(duk_context* ctx); duk_ret_t js__IntervalContext_invokeFunc(duk_context * ctx);
duk_ret_t js__IntervalContext_remove(duk_context* ctx); duk_ret_t js__IntervalContext_remove(duk_context * ctx);
duk_ret_t js__IntervalContext_finalizer(duk_context* ctx); duk_ret_t js__IntervalContext_finalizer(duk_context * ctx);
enum { enum
R0, AT, V0, V1, A0, A1, A2, A3, {
T0, T1, T2, T3, T4, T5, T6, T7, R0,
S0, S1, S2, S3, S4, S5, S6, S7, AT,
T8, T9, K0, K1, GP, SP, FP, RA, V0,
//S8 = FP V1,
}; A0,
A1,
A2,
A3,
T0,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
S0,
S1,
S2,
S3,
S4,
S5,
S6,
S7,
T8,
T9,
K0,
K1,
GP,
SP,
FP,
RA,
//S8 = FP
};
enum { enum
GPR_R0 = (1 << R0), {
GPR_AT = (1 << AT), GPR_R0 = (1 << R0),
GPR_V0 = (1 << V0), GPR_AT = (1 << AT),
GPR_V1 = (1 << V1), GPR_V0 = (1 << V0),
GPR_A0 = (1 << A0), GPR_V1 = (1 << V1),
GPR_A1 = (1 << A1), GPR_A0 = (1 << A0),
GPR_A2 = (1 << A2), GPR_A1 = (1 << A1),
GPR_A3 = (1 << A3), GPR_A2 = (1 << A2),
GPR_T0 = (1 << T0), GPR_A3 = (1 << A3),
GPR_T1 = (1 << T1), GPR_T0 = (1 << T0),
GPR_T2 = (1 << T2), GPR_T1 = (1 << T1),
GPR_T3 = (1 << T3), GPR_T2 = (1 << T2),
GPR_T4 = (1 << T4), GPR_T3 = (1 << T3),
GPR_T5 = (1 << T5), GPR_T4 = (1 << T4),
GPR_T6 = (1 << T6), GPR_T5 = (1 << T5),
GPR_T7 = (1 << T7), GPR_T6 = (1 << T6),
GPR_S0 = (1 << S0), GPR_T7 = (1 << T7),
GPR_S1 = (1 << S1), GPR_S0 = (1 << S0),
GPR_S2 = (1 << S2), GPR_S1 = (1 << S1),
GPR_S3 = (1 << S3), GPR_S2 = (1 << S2),
GPR_S4 = (1 << S4), GPR_S3 = (1 << S3),
GPR_S5 = (1 << S5), GPR_S4 = (1 << S4),
GPR_S6 = (1 << S6), GPR_S5 = (1 << S5),
GPR_S7 = (1 << S7), GPR_S6 = (1 << S6),
GPR_T8 = (1 << T8), GPR_S7 = (1 << S7),
GPR_T9 = (1 << T9), GPR_T8 = (1 << T8),
GPR_K0 = (1 << K0), GPR_T9 = (1 << T9),
GPR_K1 = (1 << K1), GPR_K0 = (1 << K0),
GPR_GP = (1 << GP), GPR_K1 = (1 << K1),
GPR_SP = (1 << SP), GPR_GP = (1 << GP),
GPR_FP = (1 << FP), GPR_SP = (1 << SP),
GPR_RA = (1 << RA), GPR_FP = (1 << FP),
//GPR_S8 = GPR_FP, GPR_RA = (1 << RA),
GPR_ANY = 0xFFFFFFFF //GPR_S8 = GPR_FP,
}; GPR_ANY = 0xFFFFFFFF
};
#define DUK_TYPE_ID(id) \ #define DUK_TYPE_ID(id) \
static const DukPropTypeID _TYPE = DukPropTypeID::Type_ ## id; static const DukPropTypeID _TYPE = DukPropTypeID::Type_##id;
#define DUK_DECLVAL_MEMBER(structName, memberName) \ #define DUK_DECLVAL_MEMBER(structName, memberName) \
structName memberName; Value(structName v) : memberName(v) {} structName memberName; \
Value(structName v) : memberName(v) \
{ \
}
#define DUK_SCALARTYPE_IMPL(structName, primitiveType) \ #define DUK_SCALARTYPE_IMPL(structName, primitiveType) \
DUK_TYPE_ID(structName) primitiveType value; structName(primitiveType value) : value(value){} DUK_TYPE_ID(structName) \
primitiveType value; \
structName(primitiveType value) : value(value) \
{ \
}
enum DukPropTypeID enum DukPropTypeID
{ {
Type_DukInt, Type_DukInt,
Type_DukUInt, Type_DukUInt,
Type_DukNumber, Type_DukNumber,
Type_DukString, Type_DukString,
Type_DukBoolean, Type_DukBoolean,
Type_DukPointer, Type_DukPointer,
Type_DukCFunction, Type_DukCFunction,
Type_DukDupIndex, Type_DukDupIndex,
Type_DukGetter, Type_DukGetter,
Type_DukGetterSetter, Type_DukGetterSetter,
Type_DukObject, Type_DukObject,
Type_DukProxy Type_DukProxy
};
struct DukInt { DUK_SCALARTYPE_IMPL(DukInt, duk_int_t) };
struct DukUInt { DUK_SCALARTYPE_IMPL(DukUInt, duk_uint_t) };
struct DukNumber { DUK_SCALARTYPE_IMPL(DukNumber, duk_double_t) };
struct DukBoolean { DUK_SCALARTYPE_IMPL(DukBoolean, duk_bool_t) };
struct DukString { DUK_SCALARTYPE_IMPL(DukString, const char*) };
struct DukPointer { DUK_SCALARTYPE_IMPL(DukPointer, void*) };
struct DukDupIndex { DUK_SCALARTYPE_IMPL(DukDupIndex, duk_idx_t) };
//struct DukObject { DUK_SCALARTYPE_IMPL(DukObject, duk_idx_t) };
struct DukCFunction {
DUK_TYPE_ID(DukCFunction)
duk_c_function func;
duk_int_t nargs;
DukCFunction(duk_c_function func, duk_int_t nargs = DUK_VARARGS) :
func(func), nargs(nargs) {}
};
struct DukObject {
DUK_TYPE_ID(DukObject)
const DukPropListEntry* props;
DukObject(const DukPropListEntry* props = nullptr) :
props(props) {}
};
struct DukGetter {
DUK_SCALARTYPE_IMPL(DukGetter, duk_c_function)
};
struct DukGetterSetter {
DUK_TYPE_ID(DukGetterSetter)
duk_c_function getter, setter;
DukGetterSetter(duk_c_function getter, duk_c_function setter) :
getter(getter), setter(setter) {}
};
struct DukProxy {
DUK_TYPE_ID(DukProxy)
duk_c_function getter, setter;
DukProxy(duk_c_function getter, duk_c_function setter) :
getter(getter), setter(setter) {}
};
struct DukPropListEntry
{
const char* key;
DukPropTypeID typeId;
bool writable, enumerable;
union Value {
DUK_DECLVAL_MEMBER(DukInt, dukInt)
DUK_DECLVAL_MEMBER(DukUInt, dukUInt)
DUK_DECLVAL_MEMBER(DukNumber, dukNumber)
DUK_DECLVAL_MEMBER(DukBoolean, dukBoolean)
DUK_DECLVAL_MEMBER(DukString, dukString)
DUK_DECLVAL_MEMBER(DukPointer, dukPointer)
DUK_DECLVAL_MEMBER(DukCFunction, dukCFunction)
DUK_DECLVAL_MEMBER(DukGetter, dukGetter)
DUK_DECLVAL_MEMBER(DukGetterSetter, dukGetterSetter)
DUK_DECLVAL_MEMBER(DukDupIndex, dukDupIndex)
DUK_DECLVAL_MEMBER(DukObject, dukObject)
DUK_DECLVAL_MEMBER(DukProxy, dukProxy)
} value;
template<class T>
DukPropListEntry(const char* key, T value, bool writable = false, bool enumerable = true) :
key(key), typeId(T::_TYPE), writable(writable), enumerable(enumerable), value(value) {}
DukPropListEntry(nullptr_t) :
key(nullptr), value(DukInt(0)) {}
DukPropListEntry(const char* key) :
key(key), typeId(Type_DukInt), writable(false), enumerable(false), value(DukInt(0)) {}
};
// todo proxy object
// todo DukObjectConfig_DummyConstructor
// todo DukObjectConfig_Finalizer
// todo DukObjectConfig_Freeze
void DukPutPropList(duk_context* ctx, duk_idx_t obj_idx, const DukPropListEntry* props);
}; };
struct DukInt
{
DUK_SCALARTYPE_IMPL(DukInt, duk_int_t)
};
struct DukUInt
{
DUK_SCALARTYPE_IMPL(DukUInt, duk_uint_t)
};
struct DukNumber
{
DUK_SCALARTYPE_IMPL(DukNumber, duk_double_t)
};
struct DukBoolean
{
DUK_SCALARTYPE_IMPL(DukBoolean, duk_bool_t)
};
struct DukString
{
DUK_SCALARTYPE_IMPL(DukString, const char *)
};
struct DukPointer
{
DUK_SCALARTYPE_IMPL(DukPointer, void *)
};
struct DukDupIndex
{
DUK_SCALARTYPE_IMPL(DukDupIndex, duk_idx_t)
};
//struct DukObject { DUK_SCALARTYPE_IMPL(DukObject, duk_idx_t) };
struct DukCFunction
{
DUK_TYPE_ID(DukCFunction)
duk_c_function func;
duk_int_t nargs;
DukCFunction(duk_c_function func, duk_int_t nargs = DUK_VARARGS) :
func(func), nargs(nargs)
{
}
};
struct DukObject
{
DUK_TYPE_ID(DukObject)
const DukPropListEntry * props;
DukObject(const DukPropListEntry * props = nullptr) :
props(props)
{
}
};
struct DukGetter
{
DUK_SCALARTYPE_IMPL(DukGetter, duk_c_function)
};
struct DukGetterSetter
{
DUK_TYPE_ID(DukGetterSetter)
duk_c_function getter, setter;
DukGetterSetter(duk_c_function getter, duk_c_function setter) :
getter(getter), setter(setter)
{
}
};
struct DukProxy
{
DUK_TYPE_ID(DukProxy)
duk_c_function getter, setter;
DukProxy(duk_c_function getter, duk_c_function setter) :
getter(getter), setter(setter)
{
}
};
struct DukPropListEntry
{
const char * key;
DukPropTypeID typeId;
bool writable, enumerable;
union Value
{
DUK_DECLVAL_MEMBER(DukInt, dukInt)
DUK_DECLVAL_MEMBER(DukUInt, dukUInt)
DUK_DECLVAL_MEMBER(DukNumber, dukNumber)
DUK_DECLVAL_MEMBER(DukBoolean, dukBoolean)
DUK_DECLVAL_MEMBER(DukString, dukString)
DUK_DECLVAL_MEMBER(DukPointer, dukPointer)
DUK_DECLVAL_MEMBER(DukCFunction, dukCFunction)
DUK_DECLVAL_MEMBER(DukGetter, dukGetter)
DUK_DECLVAL_MEMBER(DukGetterSetter, dukGetterSetter)
DUK_DECLVAL_MEMBER(DukDupIndex, dukDupIndex)
DUK_DECLVAL_MEMBER(DukObject, dukObject)
DUK_DECLVAL_MEMBER(DukProxy, dukProxy)
} value;
template <class T>
DukPropListEntry(const char * key, T value, bool writable = false, bool enumerable = true) :
key(key), typeId(T::_TYPE), writable(writable), enumerable(enumerable), value(value)
{
}
DukPropListEntry(nullptr_t) :
key(nullptr), value(DukInt(0))
{
}
DukPropListEntry(const char * key) :
key(key), typeId(Type_DukInt), writable(false), enumerable(false), value(DukInt(0))
{
}
};
// todo proxy object
// todo DukObjectConfig_DummyConstructor
// todo DukObjectConfig_Finalizer
// todo DukObjectConfig_Freeze
void DukPutPropList(duk_context * ctx, duk_idx_t obj_idx, const DukPropListEntry * props);
}; // namespace ScriptAPI

4
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_AddressRange.cpp
View File

@ -13,7 +13,7 @@ void ScriptAPI::Define_AddressRange(duk_context * ctx)
{"includes", DukCFunction(js_AddressRange_includes)}, {"includes", DukCFunction(js_AddressRange_includes)},
{"offset", DukCFunction(js_AddressRange_offset)}, {"offset", DukCFunction(js_AddressRange_offset)},
{"address", DukCFunction(js_AddressRange_address)}, {"address", DukCFunction(js_AddressRange_address)},
{ nullptr } {nullptr},
}; };
DefineGlobalClass(ctx, "AddressRange", js_AddressRange__constructor, prototype); DefineGlobalClass(ctx, "AddressRange", js_AddressRange__constructor, prototype);
@ -32,7 +32,7 @@ void ScriptAPI::Define_AddressRange(duk_context * ctx)
{"ADDR_ANY_RDRAM_UNC", 0xA0000000, 0xA07FFFFF}, {"ADDR_ANY_RDRAM_UNC", 0xA0000000, 0xA07FFFFF},
{"ADDR_ANY_CART_ROM", 0x90000000, 0x95FFFFFF}, {"ADDR_ANY_CART_ROM", 0x90000000, 0x95FFFFFF},
{"ADDR_ANY_CART_ROM_UNC", 0xB0000000, 0xB5FFFFFF}, {"ADDR_ANY_CART_ROM_UNC", 0xB0000000, 0xB5FFFFFF},
{ nullptr, 0, 0 } {nullptr, 0, 0},
}; };
duk_push_global_object(ctx); duk_push_global_object(ctx);

6
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_N64Image.cpp
View File

@ -28,14 +28,14 @@ void ScriptAPI::Define_N64Image(duk_context * ctx)
const DukPropListEntry prototype[] = { const DukPropListEntry prototype[] = {
{"toPNG", DukCFunction(js_N64Image_toPNG)}, {"toPNG", DukCFunction(js_N64Image_toPNG)},
{"update", DukCFunction(js_N64Image_update)}, {"update", DukCFunction(js_N64Image_update)},
{ nullptr} {nullptr},
}; };
const DukPropListEntry staticProps[] = { const DukPropListEntry staticProps[] = {
{"fromPNG", DukCFunction(js_N64Image_static_fromPNG)}, {"fromPNG", DukCFunction(js_N64Image_static_fromPNG)},
{"format", DukCFunction(js_N64Image_static_format)}, {"format", DukCFunction(js_N64Image_static_format)},
{"bpp", DukCFunction(js_N64Image_static_bpp)}, {"bpp", DukCFunction(js_N64Image_static_bpp)},
{ nullptr } {nullptr},
}; };
DefineGlobalClass(ctx, "N64Image", js_N64Image__constructor, prototype, staticProps); DefineGlobalClass(ctx, "N64Image", js_N64Image__constructor, prototype, staticProps);
@ -72,7 +72,7 @@ static void InitImageObjectProps(duk_context * ctx, duk_idx_t idx, CN64Image * i
{"palette", DukDupIndex(palette_idx)}, {"palette", DukDupIndex(palette_idx)},
{"width", DukUInt(image->Width())}, {"width", DukUInt(image->Width())},
{"height", DukUInt(image->Height())}, {"height", DukUInt(image->Height())},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, idx, props); DukPutPropList(ctx, idx, props);

2
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_Server.cpp
View File

@ -15,7 +15,7 @@ void ScriptAPI::Define_Server(duk_context * ctx)
{"port", DukGetter(js_Server__get_port)}, {"port", DukGetter(js_Server__get_port)},
{"address", DukGetter(js_Server__get_address)}, {"address", DukGetter(js_Server__get_address)},
{"addressFamily", DukGetter(js_Server__get_addressFamily)}, {"addressFamily", DukGetter(js_Server__get_addressFamily)},
{ nullptr } {nullptr},
}; };
DefineGlobalClass(ctx, "Server", js_Server__constructor, prototype); DefineGlobalClass(ctx, "Server", js_Server__constructor, prototype);

2
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_Socket.cpp
View File

@ -24,7 +24,7 @@ void ScriptAPI::Define_Socket(duk_context * ctx)
{"remoteAddress", DukGetter(js_Socket__get_remoteAddress)}, {"remoteAddress", DukGetter(js_Socket__get_remoteAddress)},
{"remotePort", DukGetter(js_Socket__get_remotePort)}, {"remotePort", DukGetter(js_Socket__get_remotePort)},
{"addressFamily", DukGetter(js_Socket__get_addressFamily)}, {"addressFamily", DukGetter(js_Socket__get_addressFamily)},
{ nullptr } {nullptr},
}; };
DefineGlobalClass(ctx, "Socket", js_Socket__constructor, prototype, nullptr); DefineGlobalClass(ctx, "Socket", js_Socket__constructor, prototype, nullptr);

38
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_asm.cpp
View File

@ -10,7 +10,7 @@ void ScriptAPI::Define_asm(duk_context * ctx)
{"gprname", DukCFunction(js_asm_gprname)}, {"gprname", DukCFunction(js_asm_gprname)},
{"encode", DukCFunction(js_asm_encode)}, {"encode", DukCFunction(js_asm_encode)},
{"decode", DukCFunction(js_asm_decode)}, {"decode", DukCFunction(js_asm_decode)},
{ nullptr } {nullptr},
}; };
DefineGlobalInterface(ctx, "asm", props); DefineGlobalInterface(ctx, "asm", props);
@ -19,10 +19,38 @@ void ScriptAPI::Define_asm(duk_context * ctx)
duk_ret_t ScriptAPI::js_asm_gprname(duk_context * ctx) duk_ret_t ScriptAPI::js_asm_gprname(duk_context * ctx)
{ {
const char * names[32] = { const char * names[32] = {
"r0", "at", "v0", "v1", "a0", "a1", "a2", "a3", "r0",
"t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "at",
"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "v0",
"t8", "t9", "k0", "k1", "gp", "sp", "fp", "ra" "v1",
"a0",
"a1",
"a2",
"a3",
"t0",
"t1",
"t2",
"t3",
"t4",
"t5",
"t6",
"t7",
"s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
"t8",
"t9",
"k0",
"k1",
"gp",
"sp",
"fp",
"ra",
}; };
CheckArgs(ctx, {Arg_Number}); CheckArgs(ctx, {Arg_Number});

2
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_console.cpp
View File

@ -13,7 +13,7 @@ void ScriptAPI::Define_console(duk_context * ctx)
{"error", DukCFunction(js_console_error)}, {"error", DukCFunction(js_console_error)},
{"clear", DukCFunction(js_console_clear)}, {"clear", DukCFunction(js_console_clear)},
{"listen", DukCFunction(js_console_listen)}, {"listen", DukCFunction(js_console_listen)},
{ nullptr } {nullptr},
}; };
DefineGlobalInterface(ctx, "console", props); DefineGlobalInterface(ctx, "console", props);

76
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_cpu.cpp
View File

@ -39,7 +39,7 @@ void ScriptAPI::Define_cpu(duk_context * ctx)
{"fpr", REG_PROXY_FUNCTIONS(js_cpu_fpr_get, js_cpu_fpr_set)}, {"fpr", REG_PROXY_FUNCTIONS(js_cpu_fpr_get, js_cpu_fpr_set)},
{"dfpr", REG_PROXY_FUNCTIONS(js_cpu_dfpr_get, js_cpu_dfpr_set)}, {"dfpr", REG_PROXY_FUNCTIONS(js_cpu_dfpr_get, js_cpu_dfpr_set)},
{"cop0", REG_PROXY_FUNCTIONS(js_cpu_cop0_get, js_cpu_cop0_set)}, {"cop0", REG_PROXY_FUNCTIONS(js_cpu_cop0_get, js_cpu_cop0_set)},
{ nullptr, nullptr } {nullptr, nullptr},
}; };
const duk_function_list_entry cpufuncs[] = REG_PROXY_FUNCTIONS(js_cpu_get, js_cpu_set); const duk_function_list_entry cpufuncs[] = REG_PROXY_FUNCTIONS(js_cpu_get, js_cpu_set);
@ -368,10 +368,38 @@ static duk_ret_t FPRSetImpl(duk_context * ctx, bool bDouble)
static int GPRIndex(const char * regName) static int GPRIndex(const char * regName)
{ {
const char * names[] = { const char * names[] = {
"r0", "at", "v0", "v1", "a0", "a1", "a2", "a3", "r0",
"t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "at",
"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "v0",
"t8", "t9", "k0", "k1", "gp", "sp", "fp", "ra" "v1",
"a0",
"a1",
"a2",
"a3",
"t0",
"t1",
"t2",
"t3",
"t4",
"t5",
"t6",
"t7",
"s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
"t8",
"t9",
"k0",
"k1",
"gp",
"sp",
"fp",
"ra",
}; };
for (int i = 0; i < 32; i++) for (int i = 0; i < 32; i++)
@ -388,10 +416,38 @@ static int GPRIndex(const char * regName)
static int FPRIndex(const char * regName) static int FPRIndex(const char * regName)
{ {
const char * names[32] = { const char * names[32] = {
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f0",
"f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f1",
"f17", "f18", "f19", "f20", "f21", "f22", "f23", "f24", "f2",
"f25", "f26", "f27", "f28", "f29", "f30", "f31" "f3",
"f4",
"f5",
"f6",
"f7",
"f8",
"f9",
"f10",
"f11",
"f12",
"f13",
"f14",
"f15",
"f16",
"f17",
"f18",
"f19",
"f20",
"f21",
"f22",
"f23",
"f24",
"f25",
"f26",
"f27",
"f28",
"f29",
"f30",
"f31",
}; };
for (int i = 0; i < 32; i++) for (int i = 0; i < 32; i++)
@ -435,7 +491,7 @@ static uint32_t * COP0RegPtr(const char * regName)
{"taglo", (uint32_t *)&g_Reg->TAGLO_REGISTER}, {"taglo", (uint32_t *)&g_Reg->TAGLO_REGISTER},
{"taghi", (uint32_t *)&g_Reg->TAGHI_REGISTER}, {"taghi", (uint32_t *)&g_Reg->TAGHI_REGISTER},
{"errorepc", (uint32_t *)&g_Reg->ERROREPC_REGISTER}, {"errorepc", (uint32_t *)&g_Reg->ERROREPC_REGISTER},
{ nullptr, nullptr } {nullptr, nullptr},
}; };
for (int i = 0; names[i].name != nullptr; i++) for (int i = 0; names[i].name != nullptr; i++)

10
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_debug.cpp
View File

@ -12,8 +12,8 @@ void ScriptAPI::Define_debug(duk_context * ctx)
{"resume", DukCFunction(js_debug_resume)}, {"resume", DukCFunction(js_debug_resume)},
{"showmemory", DukCFunction(js_debug_showmemory)}, {"showmemory", DukCFunction(js_debug_showmemory)},
{"showcommands", DukCFunction(js_debug_showcommands)}, {"showcommands", DukCFunction(js_debug_showcommands)},
{ "paused", DukGetter(js_debug__get_paused) }, {"paused", DukGetter(js_debug__get_paused)},
{ nullptr } {nullptr},
}; };
DefineGlobalInterface(ctx, "debug", props); DefineGlobalInterface(ctx, "debug", props);
@ -35,8 +35,7 @@ duk_ret_t ScriptAPI::js_debug_step(duk_context * ctx)
{ {
CheckArgs(ctx, {}); CheckArgs(ctx, {});
if (g_Settings->LoadBool(Debugger_SteppingOps) && if (g_Settings->LoadBool(Debugger_SteppingOps) && CDebugSettings::WaitingForStep())
CDebugSettings::WaitingForStep())
{ {
g_Settings->SaveBool(Debugger_SilentBreak, true); g_Settings->SaveBool(Debugger_SilentBreak, true);
GetInstance(ctx)->Debugger()->StepEvent().Trigger(); GetInstance(ctx)->Debugger()->StepEvent().Trigger();
@ -50,8 +49,7 @@ duk_ret_t ScriptAPI::js_debug_skip(duk_context * ctx)
g_Settings->SaveBool(Debugger_SkipOp, true); g_Settings->SaveBool(Debugger_SkipOp, true);
if (g_Settings->LoadBool(Debugger_SteppingOps) && if (g_Settings->LoadBool(Debugger_SteppingOps) && CDebugSettings::WaitingForStep())
CDebugSettings::WaitingForStep())
{ {
GetInstance(ctx)->Debugger()->StepEvent().Trigger(); GetInstance(ctx)->Debugger()->StepEvent().Trigger();
} }

75
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_events.cpp
View File

@ -43,7 +43,7 @@ void ScriptAPI::Define_events(duk_context * ctx)
{"onmousedown", DukCFunction(js_events_onmousedown)}, {"onmousedown", DukCFunction(js_events_onmousedown)},
{"onmousemove", DukCFunction(js_events_onmousemove)}, {"onmousemove", DukCFunction(js_events_onmousemove)},
{"remove", DukCFunction(js_events_remove)}, {"remove", DukCFunction(js_events_remove)},
{ nullptr } {nullptr},
}; };
DefineGlobalInterface(ctx, "events", props); DefineGlobalInterface(ctx, "events", props);
@ -63,7 +63,7 @@ void ScriptAPI::Define_events(duk_context * ctx)
{"LEFT", DukNumber(0)}, {"LEFT", DukNumber(0)},
{"MIDDLE", DukNumber(1)}, {"MIDDLE", DukNumber(1)},
{"RIGHT", DukNumber(2)}, {"RIGHT", DukNumber(2)},
{nullptr} {nullptr},
}; };
DefineGlobalClass(ctx, "MouseEvent", js_DummyConstructor, nullptr, mouseEventStaticProps); DefineGlobalClass(ctx, "MouseEvent", js_DummyConstructor, nullptr, mouseEventStaticProps);
@ -266,8 +266,7 @@ bool CbCond_ReadAddrBetween(JSAppCallback * cb, void * _env)
uint32_t addr = env->opInfo.GetLoadStoreAddress(); uint32_t addr = env->opInfo.GetLoadStoreAddress();
return (addr >= cb->m_Params.addrStart && return (addr >= cb->m_Params.addrStart && addr <= cb->m_Params.addrEnd);
addr <= cb->m_Params.addrEnd);
} }
bool CbCond_WriteAddrBetween(JSAppCallback * cb, void * _env) bool CbCond_WriteAddrBetween(JSAppCallback * cb, void * _env)
@ -281,15 +280,13 @@ bool CbCond_WriteAddrBetween(JSAppCallback * cb, void * _env)
uint32_t addr = env->opInfo.GetLoadStoreAddress(); uint32_t addr = env->opInfo.GetLoadStoreAddress();
return (addr >= cb->m_Params.addrStart && return (addr >= cb->m_Params.addrStart && addr <= cb->m_Params.addrEnd);
addr <= cb->m_Params.addrEnd);
} }
bool CbCond_PcBetween(JSAppCallback * cb, void * _env) bool CbCond_PcBetween(JSAppCallback * cb, void * _env)
{ {
JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env; JSHookCpuStepEnv * env = (JSHookCpuStepEnv *)_env;
return (env->pc >= cb->m_Params.addrStart && return (env->pc >= cb->m_Params.addrStart && env->pc <= cb->m_Params.addrEnd);
env->pc <= cb->m_Params.addrEnd);
} }
bool CbCond_PcBetween_OpcodeEquals(JSAppCallback * cb, void * _env) bool CbCond_PcBetween_OpcodeEquals(JSAppCallback * cb, void * _env)
@ -337,7 +334,7 @@ duk_idx_t CbArgs_EmuStateChangeEventObject(duk_context * ctx, void * _env)
const DukPropListEntry props[] = { const DukPropListEntry props[] = {
{"callbackId", DukUInt(inst->CallbackId())}, {"callbackId", DukUInt(inst->CallbackId())},
{"state", DukUInt(env->state)}, {"state", DukUInt(env->state)},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -353,7 +350,7 @@ duk_idx_t CbArgs_GenericEventObject(duk_context * ctx, void * /*_env*/)
const DukPropListEntry props[] = { const DukPropListEntry props[] = {
{"callbackId", DukUInt(inst->CallbackId())}, {"callbackId", DukUInt(inst->CallbackId())},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -371,7 +368,7 @@ duk_idx_t CbArgs_ExecEventObject(duk_context * ctx, void * _env)
const DukPropListEntry props[] = { const DukPropListEntry props[] = {
{"callbackId", DukUInt(inst->CallbackId())}, {"callbackId", DukUInt(inst->CallbackId())},
{"pc", DukUInt(env->pc)}, {"pc", DukUInt(env->pc)},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -400,7 +397,7 @@ duk_idx_t CbArgs_ReadEventObject(duk_context * ctx, void * _env)
{"address", DukUInt(address)}, {"address", DukUInt(address)},
{"reg", DukUInt(rt)}, {"reg", DukUInt(rt)},
{"fpu", DukBoolean(bFPU)}, {"fpu", DukBoolean(bFPU)},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -470,7 +467,7 @@ duk_idx_t CbArgs_ReadEventObject(duk_context * ctx, void * _env)
bNeedUpper32 = true; bNeedUpper32 = true;
break; break;
case R4300i_LDL: case R4300i_LDL:
{ {
int shift = (address & 7) * 8; int shift = (address & 7) * 8;
uint64_t mask = ~(((uint64_t)-1) << shift); uint64_t mask = ~(((uint64_t)-1) << shift);
debugger->DebugLoad_VAddr(address & ~7, value.u64); debugger->DebugLoad_VAddr(address & ~7, value.u64);
@ -478,10 +475,10 @@ duk_idx_t CbArgs_ReadEventObject(duk_context * ctx, void * _env)
duk_push_number(ctx, (duk_double_t)(value.u64 & 0xFFFFFFFF)); duk_push_number(ctx, (duk_double_t)(value.u64 & 0xFFFFFFFF));
duk_push_int(ctx, U64); duk_push_int(ctx, U64);
bNeedUpper32 = true; bNeedUpper32 = true;
}
break; break;
}
case R4300i_LDR: case R4300i_LDR:
{ {
int shift = 56 - ((address & 7) * 8); int shift = 56 - ((address & 7) * 8);
uint64_t mask = ~(((uint64_t)-1) >> shift); uint64_t mask = ~(((uint64_t)-1) >> shift);
debugger->DebugLoad_VAddr(address & ~7, value.u64); debugger->DebugLoad_VAddr(address & ~7, value.u64);
@ -489,28 +486,28 @@ duk_idx_t CbArgs_ReadEventObject(duk_context * ctx, void * _env)
duk_push_number(ctx, (duk_double_t)(value.u64 & 0xFFFFFFFF)); duk_push_number(ctx, (duk_double_t)(value.u64 & 0xFFFFFFFF));
duk_push_int(ctx, U64); duk_push_int(ctx, U64);
bNeedUpper32 = true; bNeedUpper32 = true;
}
break; break;
}
case R4300i_LWL: case R4300i_LWL:
{ {
int shift = (address & 3) * 8; int shift = (address & 3) * 8;
uint32_t mask = ~(((uint32_t)-1) << shift); uint32_t mask = ~(((uint32_t)-1) << shift);
debugger->DebugLoad_VAddr(address & ~3, value.s32); debugger->DebugLoad_VAddr(address & ~3, value.s32);
value.s32 = (g_Reg->m_GPR[rt].W[0] & mask) + (value.s32 << shift); value.s32 = (g_Reg->m_GPR[rt].W[0] & mask) + (value.s32 << shift);
duk_push_number(ctx, value.s32); duk_push_number(ctx, value.s32);
duk_push_int(ctx, S32); duk_push_int(ctx, S32);
}
break; break;
}
case R4300i_LWR: case R4300i_LWR:
{ {
int shift = 24 - ((address & 3) * 8); int shift = 24 - ((address & 3) * 8);
uint32_t mask = ~(((uint32_t)-1) >> shift); uint32_t mask = ~(((uint32_t)-1) >> shift);
debugger->DebugLoad_VAddr(address & ~3, value.s32); debugger->DebugLoad_VAddr(address & ~3, value.s32);
value.s32 = (g_Reg->m_GPR[rt].W[0] & mask) + (value.s32 >> shift); value.s32 = (g_Reg->m_GPR[rt].W[0] & mask) + (value.s32 >> shift);
duk_push_number(ctx, value.s32); duk_push_number(ctx, value.s32);
duk_push_int(ctx, S32); duk_push_int(ctx, S32);
}
break; break;
}
default: default:
duk_push_number(ctx, 0); duk_push_number(ctx, 0);
duk_push_number(ctx, 0); duk_push_number(ctx, 0);
@ -551,7 +548,7 @@ duk_idx_t CbArgs_WriteEventObject(duk_context * ctx, void * _env)
{"address", DukUInt(address)}, {"address", DukUInt(address)},
{"reg", DukUInt(rt)}, {"reg", DukUInt(rt)},
{"fpu", DukBoolean(bFPU)}, {"fpu", DukBoolean(bFPU)},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -587,7 +584,7 @@ duk_idx_t CbArgs_WriteEventObject(duk_context * ctx, void * _env)
bNeedUpper32 = true; bNeedUpper32 = true;
break; break;
case R4300i_SWL: case R4300i_SWL:
{ {
int shift = (address & 3) * 8; int shift = (address & 3) * 8;
uint32_t mask = ~(((uint32_t)-1) >> shift); uint32_t mask = ~(((uint32_t)-1) >> shift);
uint32_t value; uint32_t value;
@ -595,10 +592,10 @@ duk_idx_t CbArgs_WriteEventObject(duk_context * ctx, void * _env)
value = (value & mask) + (g_Reg->m_GPR[rt].UW[0] >> shift); value = (value & mask) + (g_Reg->m_GPR[rt].UW[0] >> shift);
duk_push_number(ctx, value); duk_push_number(ctx, value);
duk_push_int(ctx, S32); duk_push_int(ctx, S32);
}
break; break;
}
case R4300i_SWR: case R4300i_SWR:
{ {
int shift = 24 - ((address & 3) * 8); int shift = 24 - ((address & 3) * 8);
uint32_t mask = ~(((uint32_t)-1) << shift); uint32_t mask = ~(((uint32_t)-1) << shift);
uint32_t value; uint32_t value;
@ -606,17 +603,18 @@ duk_idx_t CbArgs_WriteEventObject(duk_context * ctx, void * _env)
value = (value & mask) + (g_Reg->m_GPR[rt].UW[0] >> shift); value = (value & mask) + (g_Reg->m_GPR[rt].UW[0] >> shift);
duk_push_number(ctx, value); duk_push_number(ctx, value);
duk_push_int(ctx, S32); duk_push_int(ctx, S32);
}
break; break;
}
case R4300i_SDL: case R4300i_SDL:
{ {
int shift = (address & 7) * 8; int shift = (address & 7) * 8;
uint64_t mask = ~(((uint64_t)-1) >> shift); uint64_t mask = ~(((uint64_t)-1) >> shift);
debugger->DebugLoad_VAddr(address & ~7, value64); debugger->DebugLoad_VAddr(address & ~7, value64);
value64 = (value64 & mask) + (g_Reg->m_GPR[rt].UDW >> shift); value64 = (value64 & mask) + (g_Reg->m_GPR[rt].UDW >> shift);
duk_push_number(ctx, (duk_double_t)(value64 & 0xFFFFFFFF)); duk_push_number(ctx, (duk_double_t)(value64 & 0xFFFFFFFF));
duk_push_int(ctx, U64); duk_push_int(ctx, U64);
} break;
}
case R4300i_SDR: case R4300i_SDR:
{ {
int shift = 56 - ((address & 7) * 8); int shift = 56 - ((address & 7) * 8);
@ -625,6 +623,7 @@ duk_idx_t CbArgs_WriteEventObject(duk_context * ctx, void * _env)
value64 = (value64 & mask) + (g_Reg->m_GPR[rt].UDW >> shift); value64 = (value64 & mask) + (g_Reg->m_GPR[rt].UDW >> shift);
duk_push_number(ctx, (duk_double_t)(value64 & 0xFFFFFFFF)); duk_push_number(ctx, (duk_double_t)(value64 & 0xFFFFFFFF));
duk_push_int(ctx, U64); duk_push_int(ctx, U64);
break;
} }
default: default:
duk_push_number(ctx, 0); duk_push_number(ctx, 0);
@ -657,7 +656,7 @@ duk_idx_t CbArgs_OpcodeEventObject(duk_context * ctx, void * _env)
{"callbackId", DukUInt(inst->CallbackId())}, {"callbackId", DukUInt(inst->CallbackId())},
{"pc", DukUInt(env->pc)}, {"pc", DukUInt(env->pc)},
{"opcode", DukUInt(env->opInfo.m_OpCode.Value)}, {"opcode", DukUInt(env->opInfo.m_OpCode.Value)},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -677,7 +676,7 @@ duk_idx_t CbArgs_RegValueEventObject(duk_context * ctx, void * _env)
{"pc", DukUInt(env->pc)}, {"pc", DukUInt(env->pc)},
{"value", DukUInt(g_Reg->m_GPR[env->outAffectedRegIndex].UW[0])}, {"value", DukUInt(g_Reg->m_GPR[env->outAffectedRegIndex].UW[0])},
{"reg", DukUInt(env->outAffectedRegIndex)}, {"reg", DukUInt(env->outAffectedRegIndex)},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -697,7 +696,7 @@ static duk_idx_t CbArgs_MouseEventObject(duk_context * ctx, void * _env)
{"button", DukInt(env->button)}, {"button", DukInt(env->button)},
{"x", DukInt(env->x)}, {"x", DukInt(env->x)},
{"y", DukInt(env->y)}, {"y", DukInt(env->y)},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -730,7 +729,7 @@ static duk_idx_t CbArgs_SPTaskEventObject(duk_context * ctx, void * _env)
{"dataSize", DukUInt(env->dataSize)}, {"dataSize", DukUInt(env->dataSize)},
{"yieldDataAddress", DukUInt(env->yieldDataAddress | 0x80000000)}, {"yieldDataAddress", DukUInt(env->yieldDataAddress | 0x80000000)},
{"yieldDataSize", DukUInt(env->yieldDataSize)}, {"yieldDataSize", DukUInt(env->yieldDataSize)},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -751,7 +750,7 @@ static duk_idx_t CbArgs_PIEventObject(duk_context * ctx, void * _env)
{"dramAddress", DukUInt(env->dramAddress | 0x80000000)}, {"dramAddress", DukUInt(env->dramAddress | 0x80000000)},
{"cartAddress", DukUInt(env->cartAddress | 0xA0000000)}, {"cartAddress", DukUInt(env->cartAddress | 0xA0000000)},
{"length", DukUInt(env->length + 1)}, {"length", DukUInt(env->length + 1)},
{ nullptr } {nullptr},
}; };
DukPutPropList(ctx, -1, props); DukPutPropList(ctx, -1, props);
@ -778,8 +777,7 @@ duk_ret_t RequireAddressOrAddressRange(duk_context * ctx, duk_idx_t idx, uint32_
if (duk_is_object(ctx, idx)) if (duk_is_object(ctx, idx))
{ {
if (!duk_has_prop_string(ctx, idx, "start") || if (!duk_has_prop_string(ctx, idx, "start") || !duk_has_prop_string(ctx, idx, "end"))
!duk_has_prop_string(ctx, idx, "end"))
{ {
duk_push_error_object(ctx, DUK_ERR_REFERENCE_ERROR, duk_push_error_object(ctx, DUK_ERR_REFERENCE_ERROR,
"object is missing 'start' or 'end' property"); "object is missing 'start' or 'end' property");
@ -789,8 +787,7 @@ duk_ret_t RequireAddressOrAddressRange(duk_context * ctx, duk_idx_t idx, uint32_
duk_get_prop_string(ctx, idx, "start"); duk_get_prop_string(ctx, idx, "start");
duk_get_prop_string(ctx, idx, "end"); duk_get_prop_string(ctx, idx, "end");
if (!duk_is_number(ctx, -2) || if (!duk_is_number(ctx, -2) || !duk_is_number(ctx, -1))
!duk_is_number(ctx, -1))
{ {
duk_pop_n(ctx, 2); duk_pop_n(ctx, 2);
duk_push_error_object(ctx, DUK_ERR_REFERENCE_ERROR, duk_push_error_object(ctx, DUK_ERR_REFERENCE_ERROR,
@ -798,8 +795,7 @@ duk_ret_t RequireAddressOrAddressRange(duk_context * ctx, duk_idx_t idx, uint32_
return duk_throw(ctx); return duk_throw(ctx);
} }
if (abs(duk_get_number(ctx, -2)) > 0xFFFFFFFF || if (abs(duk_get_number(ctx, -2)) > 0xFFFFFFFF || abs(duk_get_number(ctx, -1)) > 0xFFFFFFFF)
abs(duk_get_number(ctx, -1)) > 0xFFFFFFFF)
{ {
duk_push_error_object(ctx, DUK_ERR_RANGE_ERROR, duk_push_error_object(ctx, DUK_ERR_RANGE_ERROR,
"'start' or 'end' property out of range"); "'start' or 'end' property out of range");
@ -819,8 +815,7 @@ duk_ret_t RequireAddressOrAddressRange(duk_context * ctx, duk_idx_t idx, uint32_
duk_ret_t RequireInterpreterCPU(duk_context * ctx) duk_ret_t RequireInterpreterCPU(duk_context * ctx)
{ {
if (!g_Settings->LoadBool(Setting_ForceInterpreterCPU) && if (!g_Settings->LoadBool(Setting_ForceInterpreterCPU) && (CPU_TYPE)g_Settings->LoadDword(Game_CpuType) != CPU_Interpreter)
(CPU_TYPE)g_Settings->LoadDword(Game_CpuType) != CPU_Interpreter)
{ {
duk_push_error_object(ctx, DUK_ERR_ERROR, duk_push_error_object(ctx, DUK_ERR_ERROR,
"this feature requires the interpreter core"); "this feature requires the interpreter core");

2
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_exec.cpp
View File

@ -135,7 +135,7 @@ duk_ret_t ScriptAPI::js_exec(duk_context * ctx)
{"stdout", DukString(resultStdOut.c_str())}, {"stdout", DukString(resultStdOut.c_str())},
{"stderr", DukString(resultStdErr.c_str())}, {"stderr", DukString(resultStdErr.c_str())},
{"pid", DukUInt(processInfo.dwProcessId)}, {"pid", DukUInt(processInfo.dwProcessId)},
{ nullptr } {nullptr},
}; };
duk_push_error_object(ctx, resultExitCode, "exec(): process returned %d", resultExitCode); duk_push_error_object(ctx, resultExitCode, "exec(): process returned %d", resultExitCode);

266
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_fs.cpp
View File

@ -1,39 +1,44 @@
#include <stdafx.h> #include <stdafx.h>
#include "ScriptAPI.h" #include "ScriptAPI.h"
#include <sys/stat.h> #include <sys/stat.h>
#pragma warning(disable: 4702) // disable unreachable code warning #pragma warning(disable : 4702) // disable unreachable code warning
enum fsop { FS_READ, FS_WRITE }; enum fsop
static duk_ret_t ReadWriteImpl(duk_context *ctx, fsop op); // (fd, buffer, offset, length, position) {
static duk_ret_t js__FileFinalizer(duk_context *ctx); FS_READ,
FS_WRITE
};
static duk_ret_t ReadWriteImpl(duk_context * ctx, fsop op); // (fd, buffer, offset, length, position)
static duk_ret_t js__FileFinalizer(duk_context * ctx);
void ScriptAPI::Define_fs(duk_context *ctx) void ScriptAPI::Define_fs(duk_context * ctx)
{ {
// todo DukPutProps DukClass // todo DukPutProps DukClass
const duk_function_list_entry funcs[] = { const duk_function_list_entry funcs[] = {
{ "open", js_fs_open, DUK_VARARGS }, {"open", js_fs_open, DUK_VARARGS},
{ "close", js_fs_close, DUK_VARARGS }, {"close", js_fs_close, DUK_VARARGS},
{ "write", js_fs_write, DUK_VARARGS }, {"write", js_fs_write, DUK_VARARGS},
{ "writefile", js_fs_writefile, DUK_VARARGS }, {"writefile", js_fs_writefile, DUK_VARARGS},
{ "read", js_fs_read, DUK_VARARGS }, {"read", js_fs_read, DUK_VARARGS},
{ "readfile", js_fs_readfile, DUK_VARARGS }, {"readfile", js_fs_readfile, DUK_VARARGS},
{ "exists", js_fs_exists, DUK_VARARGS }, {"exists", js_fs_exists, DUK_VARARGS},
{ "fstat", js_fs_fstat, DUK_VARARGS }, {"fstat", js_fs_fstat, DUK_VARARGS},
{ "stat", js_fs_stat, DUK_VARARGS }, {"stat", js_fs_stat, DUK_VARARGS},
{ "unlink", js_fs_unlink, DUK_VARARGS }, {"unlink", js_fs_unlink, DUK_VARARGS},
{ "mkdir", js_fs_mkdir, DUK_VARARGS }, {"mkdir", js_fs_mkdir, DUK_VARARGS},
{ "rmdir", js_fs_rmdir, DUK_VARARGS }, {"rmdir", js_fs_rmdir, DUK_VARARGS},
{ "readdir", js_fs_readdir, DUK_VARARGS }, {"readdir", js_fs_readdir, DUK_VARARGS},
{ "Stats", js_fs_Stats__constructor, DUK_VARARGS }, {"Stats", js_fs_Stats__constructor, DUK_VARARGS},
{ nullptr, nullptr, 0 } {nullptr, nullptr, 0},
}; };
const duk_function_list_entry Stats_funcs[] = { const duk_function_list_entry Stats_funcs[] = {
{ "isFile", js_fs_Stats_isFile, DUK_VARARGS }, {"isFile", js_fs_Stats_isFile, DUK_VARARGS},
{ "isDirectory", js_fs_Stats_isDirectory, DUK_VARARGS }, {"isDirectory", js_fs_Stats_isDirectory, DUK_VARARGS},
{ nullptr, nullptr, 0 } {nullptr, nullptr, 0},
}; };
duk_push_global_object(ctx); duk_push_global_object(ctx);
@ -52,16 +57,16 @@ void ScriptAPI::Define_fs(duk_context *ctx)
duk_pop(ctx); duk_pop(ctx);
} }
duk_ret_t ScriptAPI::js_fs_open(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_open(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_String, Arg_String }); CheckArgs(ctx, {Arg_String, Arg_String});
const char* path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
const char* mode = duk_get_string(ctx, 1); const char * mode = duk_get_string(ctx, 1);
bool bModeValid = false; bool bModeValid = false;
const char* validModes[] = { const char * validModes[] = {
"r", "rb", "r", "rb",
"w", "wb", "w", "wb",
"a", "ab", "a", "ab",
@ -86,9 +91,9 @@ duk_ret_t ScriptAPI::js_fs_open(duk_context *ctx)
return duk_throw(ctx); return duk_throw(ctx);
} }
FILE *fp = fopen(path, mode); FILE * fp = fopen(path, mode);
if(fp == nullptr) if (fp == nullptr)
{ {
duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: '%s')", path, mode); duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: '%s')", path, mode);
return duk_throw(ctx); return duk_throw(ctx);
@ -113,21 +118,21 @@ duk_ret_t ScriptAPI::js_fs_open(duk_context *ctx)
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_close(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_close(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_Number }); CheckArgs(ctx, {Arg_Number});
int fd = duk_get_int(ctx, 0); int fd = duk_get_int(ctx, 0);
int rc = -1; int rc = -1;
duk_get_global_string(ctx, HS_gOpenFileDescriptors); duk_get_global_string(ctx, HS_gOpenFileDescriptors);
if(duk_has_prop_index(ctx, -1, fd)) if (duk_has_prop_index(ctx, -1, fd))
{ {
duk_get_prop_index(ctx, -1, fd); duk_get_prop_index(ctx, -1, fd);
duk_get_prop_string(ctx, -1, "fp"); duk_get_prop_string(ctx, -1, "fp");
FILE* fp = (FILE*)duk_get_pointer(ctx, -1); FILE * fp = (FILE *)duk_get_pointer(ctx, -1);
rc = fclose(fp); rc = fclose(fp);
// unset finalizer before deleting // unset finalizer before deleting
@ -148,26 +153,26 @@ duk_ret_t ScriptAPI::js_fs_close(duk_context *ctx)
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_write(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_write(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_Number, Arg_Any, Arg_OptNumber, Arg_OptNumber, Arg_OptNumber }); CheckArgs(ctx, {Arg_Number, Arg_Any, Arg_OptNumber, Arg_OptNumber, Arg_OptNumber});
return ReadWriteImpl(ctx, FS_WRITE); return ReadWriteImpl(ctx, FS_WRITE);
} }
duk_ret_t ScriptAPI::js_fs_writefile(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_writefile(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_String, Arg_Any }); CheckArgs(ctx, {Arg_String, Arg_Any});
const char* path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
void* buffer; void * buffer;
duk_size_t bufferSize; duk_size_t bufferSize;
if(duk_is_string(ctx, 1)) if (duk_is_string(ctx, 1))
{ {
buffer = (void*)duk_get_lstring(ctx, 1, &bufferSize); buffer = (void *)duk_get_lstring(ctx, 1, &bufferSize);
} }
else if(duk_is_buffer_data(ctx, 1)) else if (duk_is_buffer_data(ctx, 1))
{ {
buffer = duk_get_buffer_data(ctx, 1, &bufferSize); buffer = duk_get_buffer_data(ctx, 1, &bufferSize);
} }
@ -176,15 +181,15 @@ duk_ret_t ScriptAPI::js_fs_writefile(duk_context *ctx)
return ThrowInvalidArgsError(ctx); return ThrowInvalidArgsError(ctx);
} }
FILE* fp = fopen(path, "wb"); FILE * fp = fopen(path, "wb");
if(fp == nullptr) if (fp == nullptr)
{ {
duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: 'wb')", path); duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: 'wb')", path);
return duk_throw(ctx); return duk_throw(ctx);
} }
if(fwrite(buffer, 1, bufferSize, fp) != bufferSize) if (fwrite(buffer, 1, bufferSize, fp) != bufferSize)
{ {
fclose(fp); fclose(fp);
return DUK_RET_ERROR; return DUK_RET_ERROR;
@ -194,37 +199,37 @@ duk_ret_t ScriptAPI::js_fs_writefile(duk_context *ctx)
return 0; return 0;
} }
duk_ret_t ScriptAPI::js_fs_read(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_read(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_Number, Arg_Any, Arg_Number, Arg_Number, Arg_Number }); CheckArgs(ctx, {Arg_Number, Arg_Any, Arg_Number, Arg_Number, Arg_Number});
return ReadWriteImpl(ctx, FS_READ); return ReadWriteImpl(ctx, FS_READ);
} }
duk_ret_t ScriptAPI::js_fs_readfile(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_readfile(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_String }); CheckArgs(ctx, {Arg_String});
const char* path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
FILE* fp = fopen(path, "rb"); FILE * fp = fopen(path, "rb");
if(fp == nullptr) if (fp == nullptr)
{ {
duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: 'rb')", path); duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: 'rb')", path);
return duk_throw(ctx); return duk_throw(ctx);
} }
struct stat stats; struct stat stats;
if(fstat(_fileno(fp), &stats) != 0) if (fstat(_fileno(fp), &stats) != 0)
{ {
fclose(fp); fclose(fp);
return DUK_RET_ERROR; return DUK_RET_ERROR;
} }
void *data = duk_push_fixed_buffer(ctx, stats.st_size); void * data = duk_push_fixed_buffer(ctx, stats.st_size);
duk_push_buffer_object(ctx, -1, 0, stats.st_size, DUK_BUFOBJ_NODEJS_BUFFER); duk_push_buffer_object(ctx, -1, 0, stats.st_size, DUK_BUFOBJ_NODEJS_BUFFER);
if(fread(data, 1, stats.st_size, fp) != (size_t)stats.st_size) if (fread(data, 1, stats.st_size, fp) != (size_t)stats.st_size)
{ {
duk_pop(ctx); duk_pop(ctx);
fclose(fp); fclose(fp);
@ -235,17 +240,17 @@ duk_ret_t ScriptAPI::js_fs_readfile(duk_context *ctx)
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_exists(duk_context* ctx) duk_ret_t ScriptAPI::js_fs_exists(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_String }); CheckArgs(ctx, {Arg_String});
const char* path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
duk_push_boolean(ctx, PathFileExistsA(path) ? 1 : 0); duk_push_boolean(ctx, PathFileExistsA(path) ? 1 : 0);
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_fstat(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_fstat(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_Number }); CheckArgs(ctx, {Arg_Number});
int fd = duk_get_int(ctx, 0); int fd = duk_get_int(ctx, 0);
@ -257,11 +262,11 @@ duk_ret_t ScriptAPI::js_fs_fstat(duk_context *ctx)
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_stat(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_stat(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_String }); CheckArgs(ctx, {Arg_String});
const char *path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
duk_push_global_object(ctx); duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, "fs"); duk_get_prop_string(ctx, -1, "fs");
@ -271,39 +276,39 @@ duk_ret_t ScriptAPI::js_fs_stat(duk_context *ctx)
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_unlink(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_unlink(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_String }); CheckArgs(ctx, {Arg_String});
const char *path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
duk_push_boolean(ctx, DeleteFileA(path) != 0); duk_push_boolean(ctx, DeleteFileA(path) != 0);
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_mkdir(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_mkdir(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_String }); CheckArgs(ctx, {Arg_String});
const char *path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
duk_push_boolean(ctx, CreateDirectoryA(path, nullptr) != 0); duk_push_boolean(ctx, CreateDirectoryA(path, nullptr) != 0);
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_rmdir(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_rmdir(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_String }); CheckArgs(ctx, {Arg_String});
const char *path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
duk_push_boolean(ctx, RemoveDirectoryA(path) != 0); duk_push_boolean(ctx, RemoveDirectoryA(path) != 0);
return 1; return 1;
} }
// todo make sure failure behavior is similar to nodejs's fs.readdirSync // todo make sure failure behavior is similar to nodejs's fs.readdirSync
duk_ret_t ScriptAPI::js_fs_readdir(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_readdir(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_String }); CheckArgs(ctx, {Arg_String});
const char* path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
char findFileName[MAX_PATH]; char findFileName[MAX_PATH];
snprintf(findFileName, sizeof(findFileName), "%s%s", path, "\\*"); snprintf(findFileName, sizeof(findFileName), "%s%s", path, "\\*");
@ -311,7 +316,7 @@ duk_ret_t ScriptAPI::js_fs_readdir(duk_context *ctx)
WIN32_FIND_DATAA ffd; WIN32_FIND_DATAA ffd;
HANDLE hFind = FindFirstFileA(findFileName, &ffd); HANDLE hFind = FindFirstFileA(findFileName, &ffd);
if(hFind == INVALID_HANDLE_VALUE) if (hFind == INVALID_HANDLE_VALUE)
{ {
return DUK_RET_ERROR; return DUK_RET_ERROR;
} }
@ -321,45 +326,44 @@ duk_ret_t ScriptAPI::js_fs_readdir(duk_context *ctx)
do do
{ {
if(strcmp(ffd.cFileName, ".") == 0 || if (strcmp(ffd.cFileName, ".") == 0 || strcmp(ffd.cFileName, "..") == 0)
strcmp(ffd.cFileName, "..") == 0)
{ {
continue; continue;
} }
duk_push_string(ctx, ffd.cFileName); duk_push_string(ctx, ffd.cFileName);
duk_put_prop_index(ctx, -2, idx++); duk_put_prop_index(ctx, -2, idx++);
} while(FindNextFileA(hFind, &ffd)); } while (FindNextFileA(hFind, &ffd));
FindClose(hFind); FindClose(hFind);
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_Stats__constructor(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_Stats__constructor(duk_context * ctx)
{ {
if(!duk_is_constructor_call(ctx)) if (!duk_is_constructor_call(ctx))
{ {
return DUK_RET_TYPE_ERROR; return DUK_RET_TYPE_ERROR;
} }
if(duk_get_top(ctx) != 1) if (duk_get_top(ctx) != 1)
{ {
return ThrowInvalidArgsError(ctx); return ThrowInvalidArgsError(ctx);
} }
struct stat stats; struct stat stats;
if(duk_is_number(ctx, 0)) if (duk_is_number(ctx, 0))
{ {
int fd = duk_get_int(ctx, 0); int fd = duk_get_int(ctx, 0);
if(fstat(fd, &stats) != 0) if (fstat(fd, &stats) != 0)
{ {
return DUK_RET_ERROR; return DUK_RET_ERROR;
} }
} }
else if(duk_is_string(ctx, 0)) else if (duk_is_string(ctx, 0))
{ {
const char *path = duk_get_string(ctx, 0); const char * path = duk_get_string(ctx, 0);
if(stat(path, &stats) != 0) if (stat(path, &stats) != 0)
{ {
return DUK_RET_ERROR; return DUK_RET_ERROR;
} }
@ -370,24 +374,24 @@ duk_ret_t ScriptAPI::js_fs_Stats__constructor(duk_context *ctx)
} }
const duk_number_list_entry numbers[] = { const duk_number_list_entry numbers[] = {
{ "dev", (double)stats.st_dev }, {"dev", (double)stats.st_dev},
{ "ino", (double)stats.st_ino }, {"ino", (double)stats.st_ino},
{ "mode", (double)stats.st_mode }, {"mode", (double)stats.st_mode},
{ "nlink", (double)stats.st_nlink }, {"nlink", (double)stats.st_nlink},
{ "uid", (double)stats.st_uid }, {"uid", (double)stats.st_uid},
{ "gid", (double)stats.st_gid }, {"gid", (double)stats.st_gid},
{ "rdev", (double)stats.st_rdev }, {"rdev", (double)stats.st_rdev},
{ "size", (double)stats.st_size }, {"size", (double)stats.st_size},
{ "atimeMs", (double)stats.st_atime * 1000 }, {"atimeMs", (double)stats.st_atime * 1000},
{ "mtimeMs", (double)stats.st_mtime * 1000 }, {"mtimeMs", (double)stats.st_mtime * 1000},
{ "ctimeMs", (double)stats.st_ctime * 1000 }, {"ctimeMs", (double)stats.st_ctime * 1000},
{ nullptr, 0 } {nullptr, 0},
}; };
struct { const char *key; time_t time; } dates[3] = { struct { const char *key; time_t time; } dates[3] = {
{ "atime", stats.st_atime * 1000 }, {"atime", stats.st_atime * 1000},
{ "mtime", stats.st_mtime * 1000 }, {"mtime", stats.st_mtime * 1000},
{ "ctime", stats.st_ctime * 1000 }, {"ctime", stats.st_ctime * 1000},
}; };
duk_push_global_object(ctx); duk_push_global_object(ctx);
@ -397,7 +401,7 @@ duk_ret_t ScriptAPI::js_fs_Stats__constructor(duk_context *ctx)
duk_push_this(ctx); duk_push_this(ctx);
duk_put_number_list(ctx, -1, numbers); duk_put_number_list(ctx, -1, numbers);
for(int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
{ {
duk_dup(ctx, -2); duk_dup(ctx, -2);
duk_push_number(ctx, (duk_double_t)dates[i].time); duk_push_number(ctx, (duk_double_t)dates[i].time);
@ -410,7 +414,7 @@ duk_ret_t ScriptAPI::js_fs_Stats__constructor(duk_context *ctx)
return 0; return 0;
} }
duk_ret_t ScriptAPI::js_fs_Stats_isDirectory(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_Stats_isDirectory(duk_context * ctx)
{ {
CheckArgs(ctx, {}); CheckArgs(ctx, {});
@ -421,7 +425,7 @@ duk_ret_t ScriptAPI::js_fs_Stats_isDirectory(duk_context *ctx)
return 1; return 1;
} }
duk_ret_t ScriptAPI::js_fs_Stats_isFile(duk_context *ctx) duk_ret_t ScriptAPI::js_fs_Stats_isFile(duk_context * ctx)
{ {
CheckArgs(ctx, {}); CheckArgs(ctx, {});
@ -432,33 +436,33 @@ duk_ret_t ScriptAPI::js_fs_Stats_isFile(duk_context *ctx)
return 1; return 1;
} }
static duk_ret_t ReadWriteImpl(duk_context *ctx, fsop op) static duk_ret_t ReadWriteImpl(duk_context * ctx, fsop op)
{ {
int fd; int fd;
const char* buffer; const char * buffer;
size_t offset = 0; size_t offset = 0;
size_t length = 0; size_t length = 0;
size_t position = 0; size_t position = 0;
bool bHavePos = false; bool bHavePos = false;
duk_size_t bufferSize; duk_size_t bufferSize;
FILE* fp; FILE * fp;
size_t rc; size_t rc;
duk_idx_t nargs = duk_get_top(ctx); duk_idx_t nargs = duk_get_top(ctx);
if(nargs < 2 || !duk_is_number(ctx, 0)) if (nargs < 2 || !duk_is_number(ctx, 0))
{ {
goto err_invalid_args; goto err_invalid_args;
} }
fd = duk_get_int(ctx, 0); fd = duk_get_int(ctx, 0);
if(duk_is_buffer_data(ctx, 1)) if (duk_is_buffer_data(ctx, 1))
{ {
buffer = (const char*)duk_get_buffer_data(ctx, 1, &bufferSize); buffer = (const char *)duk_get_buffer_data(ctx, 1, &bufferSize);
} }
else if(duk_is_string(ctx, 1) && op == FS_WRITE) else if (duk_is_string(ctx, 1) && op == FS_WRITE)
{ {
buffer = duk_get_lstring(ctx, 1, &bufferSize); buffer = duk_get_lstring(ctx, 1, &bufferSize);
} }
@ -467,16 +471,16 @@ static duk_ret_t ReadWriteImpl(duk_context *ctx, fsop op)
goto err_invalid_args; goto err_invalid_args;
} }
if(nargs >= 3) if (nargs >= 3)
{ {
if(!duk_is_number(ctx, 2)) if (!duk_is_number(ctx, 2))
{ {
goto err_invalid_args; goto err_invalid_args;
} }
offset = duk_get_uint(ctx, 2); offset = duk_get_uint(ctx, 2);
if(offset >= bufferSize) if (offset >= bufferSize)
{ {
goto err_invalid_range; goto err_invalid_range;
} }
@ -484,18 +488,18 @@ static duk_ret_t ReadWriteImpl(duk_context *ctx, fsop op)
length = bufferSize - offset; length = bufferSize - offset;
if(nargs >= 4) if (nargs >= 4)
{ {
if(!duk_is_number(ctx, 3)) if (!duk_is_number(ctx, 3))
{ {
goto err_invalid_args; goto err_invalid_args;
} }
length = duk_get_uint(ctx, 3); length = duk_get_uint(ctx, 3);
} }
if(nargs >= 5) if (nargs >= 5)
{ {
if(!duk_is_number(ctx, 4)) if (!duk_is_number(ctx, 4))
{ {
goto err_invalid_args; goto err_invalid_args;
} }
@ -503,36 +507,36 @@ static duk_ret_t ReadWriteImpl(duk_context *ctx, fsop op)
bHavePos = true; bHavePos = true;
} }
if(offset + length > bufferSize) if (offset + length > bufferSize)
{ {
goto err_invalid_range; goto err_invalid_range;
} }
duk_get_global_string(ctx, HS_gOpenFileDescriptors); duk_get_global_string(ctx, HS_gOpenFileDescriptors);
if(!duk_has_prop_index(ctx, -1, fd)) if (!duk_has_prop_index(ctx, -1, fd))
{ {
goto err_invalid_fd; goto err_invalid_fd;
} }
duk_get_prop_index(ctx, -1, fd); duk_get_prop_index(ctx, -1, fd);
duk_get_prop_string(ctx, -1, "fp"); duk_get_prop_string(ctx, -1, "fp");
fp = (FILE*)duk_get_pointer(ctx, -1); fp = (FILE *)duk_get_pointer(ctx, -1);
duk_pop_n(ctx, 3); duk_pop_n(ctx, 3);
if(bHavePos) if (bHavePos)
{ {
fseek(fp, position, SEEK_SET); fseek(fp, position, SEEK_SET);
} }
switch(op) switch (op)
{ {
case FS_READ: case FS_READ:
rc = fread((void*)&buffer[offset], 1, length, fp); rc = fread((void *)&buffer[offset], 1, length, fp);
break; break;
case FS_WRITE: case FS_WRITE:
rc = fwrite((void*)&buffer[offset], 1, length, fp); rc = fwrite((void *)&buffer[offset], 1, length, fp);
break; break;
default: default:
return DUK_RET_ERROR; return DUK_RET_ERROR;
@ -553,17 +557,17 @@ err_invalid_fd:
return duk_throw(ctx); return duk_throw(ctx);
} }
static duk_ret_t js__FileFinalizer(duk_context *ctx) static duk_ret_t js__FileFinalizer(duk_context * ctx)
{ {
CScriptInstance* inst = ScriptAPI::GetInstance(ctx); CScriptInstance * inst = ScriptAPI::GetInstance(ctx);
duk_get_prop_string(ctx, 0, "fp"); duk_get_prop_string(ctx, 0, "fp");
FILE *fp = (FILE *)duk_get_pointer(ctx, -1); FILE * fp = (FILE *)duk_get_pointer(ctx, -1);
duk_pop(ctx); duk_pop(ctx);
fclose(fp); fclose(fp);
inst->System()->ConsoleLog("[SCRIPTSYS]: warning ('%s'): gc closed leftover file descriptor", inst->System()->ConsoleLog("[SCRIPTSYS]: warning ('%s'): gc closed leftover file descriptor",
inst->Name().c_str()); inst->Name().c_str());
return 0; return 0;
} }

32
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_mem.cpp
View File

@ -37,7 +37,7 @@ void ScriptAPI::Define_mem(duk_context * ctx)
{"s8", DukProxy(MEM_PROXY_FUNCS(int8_t))}, {"s8", DukProxy(MEM_PROXY_FUNCS(int8_t))},
{"f64", DukProxy(MEM_PROXY_FUNCS(double))}, {"f64", DukProxy(MEM_PROXY_FUNCS(double))},
{"f32", DukProxy(MEM_PROXY_FUNCS(float))}, {"f32", DukProxy(MEM_PROXY_FUNCS(float))},
{ nullptr } {nullptr},
}; };
DefineGlobalInterface(ctx, "mem", props); DefineGlobalInterface(ctx, "mem", props);
@ -109,8 +109,7 @@ duk_ret_t ScriptAPI::js_mem_getblock(duk_context * ctx)
memsrc = g_MMU->Rdram(); memsrc = g_MMU->Rdram();
offsetStart = paddr; offsetStart = paddr;
} }
else if (g_Rom && paddr >= 0x10000000 && else if (g_Rom && paddr >= 0x10000000 && ((paddr - 0x10000000) + length) <= g_Rom->GetRomSize())
((paddr - 0x10000000) + length) <= g_Rom->GetRomSize())
{ {
memsrc = g_Rom->GetRomAddress(); memsrc = g_Rom->GetRomAddress();
offsetStart = paddr - 0x10000000; offsetStart = paddr - 0x10000000;
@ -282,9 +281,15 @@ duk_ret_t ScriptAPI::js_mem__boundget(duk_context * ctx)
double f64; double f64;
} retval; } retval;
#define MEM_BOUNDGET_TRY(addr, T, result, dukpush) \ #define MEM_BOUNDGET_TRY(addr, T, result, dukpush) \
if(debugger->DebugLoad_VAddr<T>(addr, result)) { dukpush(ctx, result); } \ if (debugger->DebugLoad_VAddr<T>(addr, result)) \
else { goto memory_error; } { \
dukpush(ctx, result); \
} \
else \
{ \
goto memory_error; \
}
switch (type) switch (type)
{ {
@ -325,9 +330,15 @@ duk_ret_t ScriptAPI::js_mem__boundset(duk_context * ctx)
uint32_t addr = duk_get_uint(ctx, 0); uint32_t addr = duk_get_uint(ctx, 0);
duk_int_t type = duk_get_int(ctx, 1); duk_int_t type = duk_get_int(ctx, 1);
#define MEM_BOUNDSET_TRY(addr, T, value) \ #define MEM_BOUNDSET_TRY(addr, T, value) \
if(debugger->DebugStore_VAddr<T>(addr, value)) { return 1; } \ if (debugger->DebugStore_VAddr<T>(addr, value)) \
else { goto memory_error; } { \
return 1; \
} \
else \
{ \
goto memory_error; \
}
switch (type) switch (type)
{ {
@ -404,8 +415,7 @@ duk_ret_t ScriptAPI::js_mem_bindvars(duk_context * ctx)
for (duk_uarridx_t i = 0; i < length; i++) for (duk_uarridx_t i = 0; i < length; i++)
{ {
duk_get_prop_index(ctx, 1, i); duk_get_prop_index(ctx, 1, i);
if (!duk_is_array(ctx, -1) || if (!duk_is_array(ctx, -1) || duk_get_length(ctx, -1) != 3)
duk_get_length(ctx, -1) != 3)
{ {
return DUK_RET_TYPE_ERROR; return DUK_RET_TYPE_ERROR;
} }

4
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_pj64.cpp
View File

@ -17,7 +17,7 @@ void ScriptAPI::Define_pj64(duk_context * ctx)
{"id", DukGetter(js_pj64_romInfo__get_headerId)}, {"id", DukGetter(js_pj64_romInfo__get_headerId)},
{"countryCode", DukGetter(js_pj64_romInfo__get_headerCountryCode)}, {"countryCode", DukGetter(js_pj64_romInfo__get_headerCountryCode)},
{"version", DukGetter(js_pj64_romInfo__get_headerVersion)}, {"version", DukGetter(js_pj64_romInfo__get_headerVersion)},
{ nullptr } {nullptr},
}; };
const DukPropListEntry props[] = { const DukPropListEntry props[] = {
@ -35,7 +35,7 @@ void ScriptAPI::Define_pj64(duk_context * ctx)
{"romDirectory", DukGetter(js_pj64__get_romDirectory)}, {"romDirectory", DukGetter(js_pj64__get_romDirectory)},
{DUK_HIDDEN_SYMBOL("romInfo"), DukObject(romInfoProps)}, {DUK_HIDDEN_SYMBOL("romInfo"), DukObject(romInfoProps)},
{"romInfo", DukGetter(js_pj64__get_romInfo)}, {"romInfo", DukGetter(js_pj64__get_romInfo)},
{ nullptr } {nullptr},
}; };
DefineGlobalInterface(ctx, "pj64", props); DefineGlobalInterface(ctx, "pj64", props);

33
Source/Project64/UserInterface/Debugger/ScriptAPI/ScriptAPI_script.cpp
View File

@ -1,45 +1,46 @@
#include <stdafx.h> #include <stdafx.h>
#include "ScriptAPI.h" #include "ScriptAPI.h"
#pragma warning(disable: 4702) // disable unreachable code warning #pragma warning(disable : 4702) // disable unreachable code warning
void ScriptAPI::Define_script(duk_context *ctx) void ScriptAPI::Define_script(duk_context * ctx)
{ {
const DukPropListEntry props[] = { const DukPropListEntry props[] = {
{ "timeout", DukCFunction(js_script_timeout) }, {"timeout", DukCFunction(js_script_timeout)},
{ "keepalive", DukCFunction(js_script_keepalive) }, {"keepalive", DukCFunction(js_script_keepalive)},
{ "abort", DukCFunction(js_script_abort) }, {"abort", DukCFunction(js_script_abort)},
{ nullptr } {nullptr},
}; };
DefineGlobalInterface(ctx, "script", props); DefineGlobalInterface(ctx, "script", props);
} }
duk_ret_t ScriptAPI::js_script_timeout(duk_context *ctx) duk_ret_t ScriptAPI::js_script_timeout(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_Number }); CheckArgs(ctx, {Arg_Number});
CScriptInstance* inst = GetInstance(ctx); CScriptInstance * inst = GetInstance(ctx);
inst->SetExecTimeout((uint64_t)duk_get_number(ctx, 0)); inst->SetExecTimeout((uint64_t)duk_get_number(ctx, 0));
return 0; return 0;
} }
duk_ret_t ScriptAPI::js_script_keepalive(duk_context *ctx) duk_ret_t ScriptAPI::js_script_keepalive(duk_context * ctx)
{ {
CheckArgs(ctx, { Arg_Boolean }); CheckArgs(ctx, {Arg_Boolean});
CScriptInstance* inst = GetInstance(ctx); CScriptInstance * inst = GetInstance(ctx);
duk_bool_t bKeepAlive = duk_get_boolean(ctx, 0); duk_bool_t bKeepAlive = duk_get_boolean(ctx, 0);
duk_push_global_object(ctx); duk_push_global_object(ctx);
duk_bool_t bHaveProp = duk_has_prop_string(ctx, -1, HS_gKeepAlive); duk_bool_t bHaveProp = duk_has_prop_string(ctx, -1, HS_gKeepAlive);
if(bKeepAlive && !bHaveProp) if (bKeepAlive && !bHaveProp)
{ {
duk_push_boolean(ctx, 1); duk_push_boolean(ctx, 1);
duk_put_prop_string(ctx, -2, HS_gKeepAlive); duk_put_prop_string(ctx, -2, HS_gKeepAlive);
inst->IncRefCount(); inst->IncRefCount();
} }
else if(!bKeepAlive && bHaveProp) else if (!bKeepAlive && bHaveProp)
{ {
duk_del_prop_string(ctx, -1, HS_gKeepAlive); duk_del_prop_string(ctx, -1, HS_gKeepAlive);
inst->DecRefCount(); inst->DecRefCount();
@ -50,10 +51,10 @@ duk_ret_t ScriptAPI::js_script_keepalive(duk_context *ctx)
return 0; return 0;
} }
duk_ret_t ScriptAPI::js_script_abort(duk_context* ctx) duk_ret_t ScriptAPI::js_script_abort(duk_context * ctx)
{ {
CheckArgs(ctx, {}); CheckArgs(ctx, {});
CScriptInstance* inst = GetInstance(ctx); CScriptInstance * inst = GetInstance(ctx);
if (inst->PrepareAbort()) if (inst->PrepareAbort())
{ {
return duk_fatal(ctx, "aborted"); return duk_fatal(ctx, "aborted");

6
Source/Project64/UserInterface/Debugger/ScriptInstance.cpp
View File

@ -99,8 +99,7 @@ bool CScriptInstance::Run(const char * path)
try try
{ {
duk_push_string(m_Ctx, m_InstanceName.c_str()); duk_push_string(m_Ctx, m_InstanceName.c_str());
if (duk_pcompile_string_filename(m_Ctx, DUK_COMPILE_STRICT, m_SourceCode) != 0 || if (duk_pcompile_string_filename(m_Ctx, DUK_COMPILE_STRICT, m_SourceCode) != 0 || duk_pcall(m_Ctx, 0) == DUK_EXEC_ERROR)
duk_pcall(m_Ctx, 0) == DUK_EXEC_ERROR)
{ {
duk_get_prop_string(m_Ctx, -1, "stack"); duk_get_prop_string(m_Ctx, -1, "stack");
m_System->ConsoleLog("%s", duk_safe_to_string(m_Ctx, -1)); m_System->ConsoleLog("%s", duk_safe_to_string(m_Ctx, -1));
@ -211,8 +210,7 @@ void CScriptInstance::RawConsoleInput(const char * code)
m_ExecStartTime = Timestamp(); m_ExecStartTime = Timestamp();
duk_push_string(m_Ctx, stdstr_f("<input:%s>", m_InstanceName.c_str()).c_str()); duk_push_string(m_Ctx, stdstr_f("<input:%s>", m_InstanceName.c_str()).c_str());
if (duk_pcompile_string_filename(m_Ctx, DUK_COMPILE_STRICT, code) != 0 || if (duk_pcompile_string_filename(m_Ctx, DUK_COMPILE_STRICT, code) != 0 || duk_pcall(m_Ctx, 0) == DUK_EXEC_ERROR)
duk_pcall(m_Ctx, 0) == DUK_EXEC_ERROR)
{ {
duk_get_prop_string(m_Ctx, -1, "stack"); duk_get_prop_string(m_Ctx, -1, "stack");
m_System->ConsoleLog("%s", duk_safe_to_string(m_Ctx, -1)); m_System->ConsoleLog("%s", duk_safe_to_string(m_Ctx, -1));

82
Source/Project64/UserInterface/Debugger/ScriptInstance.h
View File

@ -1,5 +1,5 @@
#include "ScriptTypes.h"
#include "ScriptSystem.h" #include "ScriptSystem.h"
#include "ScriptTypes.h"
#include "ScriptWorker.h" #include "ScriptWorker.h"
#pragma once #pragma once
@ -7,44 +7,50 @@
class CScriptInstance class CScriptInstance
{ {
private: private:
JSInstanceName m_InstanceName; JSInstanceName m_InstanceName;
CScriptSystem* m_System; CScriptSystem * m_System;
duk_context* m_Ctx; duk_context * m_Ctx;
size_t m_RefCount; size_t m_RefCount;
uint64_t m_ExecTimeout; uint64_t m_ExecTimeout;
uint64_t m_ExecStartTime; uint64_t m_ExecStartTime;
std::ifstream m_SourceFile; std::ifstream m_SourceFile;
char* m_SourceCode; char * m_SourceCode;
JSAppCallbackID m_CurExecCallbackId; JSAppCallbackID m_CurExecCallbackId;
std::vector<CScriptWorker*> m_Workers; std::vector<CScriptWorker *> m_Workers;
bool m_bStopping; bool m_bStopping;
bool m_bAborting; bool m_bAborting;
public: public:
CScriptInstance(CScriptSystem* sys, const char* name); CScriptInstance(CScriptSystem * sys, const char * name);
~CScriptInstance(); ~CScriptInstance();
JSInstanceName& Name(); JSInstanceName & Name();
CScriptSystem* System(); CScriptSystem * System();
CDebuggerUI* Debugger(); CDebuggerUI * Debugger();
JSAppCallbackID CallbackId(); JSAppCallbackID CallbackId();
bool Run(const char* path); bool Run(const char * path);
void SetExecTimeout(uint64_t timeout); void SetExecTimeout(uint64_t timeout);
bool IsTimedOut(); bool IsTimedOut();
inline size_t GetRefCount() { return m_RefCount; } inline size_t GetRefCount()
void IncRefCount(); {
void DecRefCount(); return m_RefCount;
void SetStopping(bool bStopping); }
inline bool IsStopping() { return m_bStopping; } void IncRefCount();
bool PrepareAbort(); void DecRefCount();
void SetStopping(bool bStopping);
inline bool IsStopping()
{
return m_bStopping;
}
bool PrepareAbort();
bool RegisterWorker(CScriptWorker* worker); bool RegisterWorker(CScriptWorker * worker);
void UnregisterWorker(CScriptWorker* worker); void UnregisterWorker(CScriptWorker * worker);
void StopRegisteredWorkers(); void StopRegisteredWorkers();
inline void RawInvokeAppCallback(JSAppCallback& cb, void* _hookEnv) inline void RawInvokeAppCallback(JSAppCallback & cb, void * _hookEnv)
{ {
m_CurExecCallbackId = cb.m_CallbackId; m_CurExecCallbackId = cb.m_CallbackId;
@ -58,7 +64,7 @@ public:
m_CurExecCallbackId = JS_INVALID_CALLBACK; m_CurExecCallbackId = JS_INVALID_CALLBACK;
} }
inline void RawCall(void *dukFuncHeapPtr, JSDukArgSetupFunc argSetupFunc, void *param = nullptr) inline void RawCall(void * dukFuncHeapPtr, JSDukArgSetupFunc argSetupFunc, void * param = nullptr)
{ {
m_ExecStartTime = Timestamp(); m_ExecStartTime = Timestamp();
duk_push_heapptr(m_Ctx, dukFuncHeapPtr); duk_push_heapptr(m_Ctx, dukFuncHeapPtr);
@ -75,24 +81,24 @@ public:
duk_pop(m_Ctx); duk_pop(m_Ctx);
} }
catch (std::runtime_error& exc) catch (std::runtime_error & exc)
{ {
FatalHandler(exc); FatalHandler(exc);
} }
} }
void RawCMethodCall(void* dukThisHeapPtr, duk_c_function func, void RawCMethodCall(void * dukThisHeapPtr, duk_c_function func,
JSDukArgSetupFunc argSetupFunc = nullptr, JSDukArgSetupFunc argSetupFunc = nullptr,
void* argSetupParam = nullptr); void * argSetupParam = nullptr);
void PostCMethodCall(void* dukThisHeapPtr, duk_c_function func, void PostCMethodCall(void * dukThisHeapPtr, duk_c_function func,
JSDukArgSetupFunc argSetupFunc = nullptr, JSDukArgSetupFunc argSetupFunc = nullptr,
void* argSetupParam = nullptr, size_t argSetupParamSize = 0); void * argSetupParam = nullptr, size_t argSetupParamSize = 0);
void RawConsoleInput(const char* code); void RawConsoleInput(const char * code);
private: private:
void FatalHandler(std::runtime_error& exc); void FatalHandler(std::runtime_error & exc);
static uint64_t Timestamp(); static uint64_t Timestamp();
void Cleanup(); void Cleanup();
}; };

13
Source/Project64/UserInterface/Debugger/ScriptSystem.cpp
View File

@ -162,8 +162,7 @@ bool CScriptSystem::HaveAppCallbacks(JSAppHookID hookId)
{ {
CGuard guard(m_InstancesCS); CGuard guard(m_InstancesCS);
return (hookId < JS_NUM_APP_HOOKS && return (hookId < JS_NUM_APP_HOOKS && m_AppCallbackHooks[hookId].size() > 0);
m_AppCallbackHooks[hookId].size() > 0);
} }
void CScriptSystem::InvokeAppCallbacks(JSAppHookID hookId, void * env) void CScriptSystem::InvokeAppCallbacks(JSAppHookID hookId, void * env)
@ -180,10 +179,7 @@ void CScriptSystem::InvokeAppCallbacks(JSAppHookID hookId, void * env)
JSAppCallback & callback = callbacks[i]; JSAppCallback & callback = callbacks[i];
CScriptInstance * instance = callback.m_Instance; CScriptInstance * instance = callback.m_Instance;
if (callback.m_bDisabled || if (callback.m_bDisabled || instance->IsStopping() || m_StopsIssued.count(instance->Name()) != 0 || !callback.m_ConditionFunc(&callback, env))
instance->IsStopping() ||
m_StopsIssued.count(instance->Name()) != 0 ||
!callback.m_ConditionFunc(&callback, env))
{ {
continue; continue;
} }
@ -215,10 +211,7 @@ void CScriptSystem::UpdateCpuCbListInfo(volatile JSCpuCbListInfo & info, JSAppCa
for (i = 0; i < numCacheEntries; i++) for (i = 0; i < numCacheEntries; i++)
{ {
// combine adjacent/overlapping ranges // combine adjacent/overlapping ranges
if ((callback.m_Params.addrStart >= info.rangeCache[i].addrStart && if ((callback.m_Params.addrStart >= info.rangeCache[i].addrStart && callback.m_Params.addrStart <= info.rangeCache[i].addrEnd + 1) || (callback.m_Params.addrEnd >= info.rangeCache[i].addrStart - 1 && callback.m_Params.addrEnd <= info.rangeCache[i].addrEnd))
callback.m_Params.addrStart <= info.rangeCache[i].addrEnd + 1) ||
(callback.m_Params.addrEnd >= info.rangeCache[i].addrStart - 1 &&
callback.m_Params.addrEnd <= info.rangeCache[i].addrEnd))
{ {
info.rangeCache[i].addrStart = min(info.rangeCache[i].addrStart, callback.m_Params.addrStart); info.rangeCache[i].addrStart = min(info.rangeCache[i].addrStart, callback.m_Params.addrStart);
info.rangeCache[i].addrEnd = max(info.rangeCache[i].addrEnd, callback.m_Params.addrEnd); info.rangeCache[i].addrEnd = max(info.rangeCache[i].addrEnd, callback.m_Params.addrEnd);

113
Source/Project64/UserInterface/Debugger/ScriptSystem.h
View File

@ -1,6 +1,6 @@
#include <windows.h>
#include <fstream> #include <fstream>
#include <map> #include <map>
#include <windows.h>
#include "ScriptTypes.h" #include "ScriptTypes.h"
#include "debugger.h" #include "debugger.h"
@ -12,49 +12,53 @@
class CScriptSystem class CScriptSystem
{ {
typedef std::map<JSInstanceName, CScriptInstance*> JSInstanceMap; typedef std::map<JSInstanceName, CScriptInstance *> JSInstanceMap;
typedef std::vector<JSAppCallback> JSAppCallbackList; typedef std::vector<JSAppCallback> JSAppCallbackList;
typedef std::map<JSInstanceName, JSInstanceStatus> JSInstanceStatusMap; typedef std::map<JSInstanceName, JSInstanceStatus> JSInstanceStatusMap;
typedef std::vector<JSSysCommand> JSSysCommandQueue; typedef std::vector<JSSysCommand> JSSysCommandQueue;
enum { JS_CPU_CB_RANGE_CACHE_SIZE = 256 }; enum
{
JS_CPU_CB_RANGE_CACHE_SIZE = 256
};
struct JSCpuCbListInfo struct JSCpuCbListInfo
{ {
size_t numCallbacks; size_t numCallbacks;
uint32_t minAddrStart; uint32_t minAddrStart;
uint32_t maxAddrEnd; uint32_t maxAddrEnd;
size_t numRangeCacheEntries; size_t numRangeCacheEntries;
bool bRangeCacheExceeded; bool bRangeCacheExceeded;
struct { struct
{
uint32_t addrStart; uint32_t addrStart;
uint32_t addrEnd; uint32_t addrEnd;
} rangeCache[JS_CPU_CB_RANGE_CACHE_SIZE]; } rangeCache[JS_CPU_CB_RANGE_CACHE_SIZE];
}; };
HANDLE m_hThread; HANDLE m_hThread;
CriticalSection m_CmdQueueCS; CriticalSection m_CmdQueueCS;
JSSysCommandQueue m_CmdQueue; JSSysCommandQueue m_CmdQueue;
HANDLE m_hCmdEvent; HANDLE m_hCmdEvent;
std::set<JSInstanceName> m_StopsIssued; std::set<JSInstanceName> m_StopsIssued;
CriticalSection m_InstancesCS; CriticalSection m_InstancesCS;
JSInstanceMap m_Instances; JSInstanceMap m_Instances;
JSAppCallbackList m_AppCallbackHooks[JS_NUM_APP_HOOKS]; JSAppCallbackList m_AppCallbackHooks[JS_NUM_APP_HOOKS];
JSAppCallbackID m_NextAppCallbackId; JSAppCallbackID m_NextAppCallbackId;
volatile size_t m_AppCallbackCount; volatile size_t m_AppCallbackCount;
volatile JSCpuCbListInfo m_CpuExecCbInfo; volatile JSCpuCbListInfo m_CpuExecCbInfo;
volatile JSCpuCbListInfo m_CpuReadCbInfo; volatile JSCpuCbListInfo m_CpuReadCbInfo;
volatile JSCpuCbListInfo m_CpuWriteCbInfo; volatile JSCpuCbListInfo m_CpuWriteCbInfo;
CriticalSection m_UIStateCS; CriticalSection m_UIStateCS;
JSInstanceStatusMap m_UIInstanceStatus; JSInstanceStatusMap m_UIInstanceStatus;
stdstr m_UILog; stdstr m_UILog;
CDebuggerUI* m_Debugger; CDebuggerUI * m_Debugger;
std::set<std::string> m_AutorunList; std::set<std::string> m_AutorunList;
@ -63,35 +67,38 @@ class CScriptSystem
stdstr m_ModulesDirFullPath; stdstr m_ModulesDirFullPath;
public: public:
CScriptSystem(CDebuggerUI* debugger); CScriptSystem(CDebuggerUI * debugger);
~CScriptSystem(); ~CScriptSystem();
CDebuggerUI* Debugger(); CDebuggerUI * Debugger();
void StartScript(const char* instanceName, const char* path); void StartScript(const char * instanceName, const char * path);
void StopScript(const char* instanceName); void StopScript(const char * instanceName);
void Input(const char* instanceName, const char* code); void Input(const char * instanceName, const char * code);
stdstr InstallDirPath(); stdstr InstallDirPath();
stdstr ScriptsDirPath(); stdstr ScriptsDirPath();
stdstr ModulesDirPath(); stdstr ModulesDirPath();
JSInstanceStatus GetStatus(const char* instanceName); JSInstanceStatus GetStatus(const char * instanceName);
void NotifyStatus(const char* instanceName, JSInstanceStatus status); void NotifyStatus(const char * instanceName, JSInstanceStatus status);
void ConsoleLog(const char* format, ...); void ConsoleLog(const char * format, ...);
void ConsolePrint(const char* format, ...); void ConsolePrint(const char * format, ...);
void ConsoleClear(); void ConsoleClear();
stdstr GetConsoleBuffer(); stdstr GetConsoleBuffer();
void PostCMethodCall(const char* instanceName, void* dukThisHeapPtr, duk_c_function func, void PostCMethodCall(const char * instanceName, void * dukThisHeapPtr, duk_c_function func,
JSDukArgSetupFunc argSetupFunc = nullptr, JSDukArgSetupFunc argSetupFunc = nullptr,
void* argSetupParam = nullptr, void * argSetupParam = nullptr,
size_t argSetupParamSize = 0); size_t argSetupParamSize = 0);
bool HaveAppCallbacks(JSAppHookID hookId); bool HaveAppCallbacks(JSAppHookID hookId);
// Note: Unguarded for speed, shouldn't matter // Note: Unguarded for speed, shouldn't matter
inline bool HaveAppCallbacks() { return m_AppCallbackCount != 0; } inline bool HaveAppCallbacks()
{
return m_AppCallbackCount != 0;
}
inline bool HaveCpuExecCallbacks(uint32_t address) inline bool HaveCpuExecCallbacks(uint32_t address)
{ {
@ -108,21 +115,21 @@ public:
return HaveCpuCallbacks(m_CpuWriteCbInfo, m_AppCallbackHooks[JS_HOOK_CPU_WRITE], address); return HaveCpuCallbacks(m_CpuWriteCbInfo, m_AppCallbackHooks[JS_HOOK_CPU_WRITE], address);
} }
static void UpdateCpuCbListInfo(volatile JSCpuCbListInfo& info, JSAppCallbackList& callbacks); static void UpdateCpuCbListInfo(volatile JSCpuCbListInfo & info, JSAppCallbackList & callbacks);
void DoMouseEvent(JSAppHookID hookId, int x, int y, DWORD uMsg = (DWORD)-1); void DoMouseEvent(JSAppHookID hookId, int x, int y, DWORD uMsg = (DWORD)-1);
void InvokeAppCallbacks(JSAppHookID hookId, void* env = nullptr); void InvokeAppCallbacks(JSAppHookID hookId, void * env = nullptr);
void ExecAutorunList(); void ExecAutorunList();
std::set<std::string>& AutorunList(); std::set<std::string> & AutorunList();
void LoadAutorunList(); void LoadAutorunList();
void SaveAutorunList(); void SaveAutorunList();
JSAppCallbackID RawAddAppCallback(JSAppHookID hookId, JSAppCallback& callback); JSAppCallbackID RawAddAppCallback(JSAppHookID hookId, JSAppCallback & callback);
void RawRemoveAppCallback(JSAppHookID hookId, JSAppCallbackID callbackId); void RawRemoveAppCallback(JSAppHookID hookId, JSAppCallbackID callbackId);
private: private:
inline bool HaveCpuCallbacks(volatile JSCpuCbListInfo& info, JSAppCallbackList& callbacks, uint32_t address) inline bool HaveCpuCallbacks(volatile JSCpuCbListInfo & info, JSAppCallbackList & callbacks, uint32_t address)
{ {
if (info.numCallbacks == 0 || address < info.minAddrStart || address > info.maxAddrEnd) if (info.numCallbacks == 0 || address < info.minAddrStart || address > info.maxAddrEnd)
{ {
@ -133,8 +140,7 @@ private:
{ {
for (size_t i = 0; i < info.numRangeCacheEntries; i++) for (size_t i = 0; i < info.numRangeCacheEntries; i++)
{ {
if (address >= info.rangeCache[i].addrStart && if (address >= info.rangeCache[i].addrStart && address <= info.rangeCache[i].addrEnd)
address <= info.rangeCache[i].addrEnd)
{ {
return true; return true;
} }
@ -145,10 +151,9 @@ private:
CGuard guard(m_InstancesCS); CGuard guard(m_InstancesCS);
for (JSAppCallback& callback : callbacks) for (JSAppCallback & callback : callbacks)
{ {
if (address >= callback.m_Params.addrStart && if (address >= callback.m_Params.addrStart && address <= callback.m_Params.addrEnd)
address <= callback.m_Params.addrEnd)
{ {
return true; return true;
} }
@ -159,23 +164,23 @@ private:
void InitDirectories(); void InitDirectories();
void PostCommand(JSSysCommandID id, stdstr paramA = "", stdstr paramB = "", void* paramC = nullptr); void PostCommand(JSSysCommandID id, stdstr paramA = "", stdstr paramB = "", void * paramC = nullptr);
static DWORD WINAPI ThreadProc(void* _this); static DWORD WINAPI ThreadProc(void * _this);
void ThreadProc(); void ThreadProc();
bool ProcessCommand(JSSysCommand& cmd); bool ProcessCommand(JSSysCommand & cmd);
bool ProcessCommandQueue(std::vector<JSSysCommand>& queue); bool ProcessCommandQueue(std::vector<JSSysCommand> & queue);
void PullCommands(JSSysCommandID id, std::vector<JSSysCommand>& out); void PullCommands(JSSysCommandID id, std::vector<JSSysCommand> & out);
void OnStartScript(const char* name, const char* path); void OnStartScript(const char * name, const char * path);
void OnStopScript(const char* name); void OnStopScript(const char * name);
void OnInput(const char* name, const char* code); void OnInput(const char * name, const char * code);
void OnCMethodCall(const char* name, JSSysCMethodCall* methodCall); void OnCMethodCall(const char * name, JSSysCMethodCall * methodCall);
void OnSweep(bool bIfDone); void OnSweep(bool bIfDone);
bool RawRemoveInstance(const char* key); bool RawRemoveInstance(const char * key);
void RefreshCallbackMaps(); void RefreshCallbackMaps();
static stdstr FixStringReturns(const char* str); static stdstr FixStringReturns(const char * str);
}; };

73
Source/Project64/UserInterface/Debugger/ScriptTypes.h
View File

@ -1,5 +1,5 @@
#include <3rdparty/duktape/duktape.h>
#include <3rdparty/duktape/duk_module_duktape.h> #include <3rdparty/duktape/duk_module_duktape.h>
#include <3rdparty/duktape/duktape.h>
#include <cstdint> #include <cstdint>
#include <string> #include <string>
@ -66,9 +66,9 @@ class CScriptInstance;
typedef std::string JSInstanceName; typedef std::string JSInstanceName;
struct JSAppCallback; struct JSAppCallback;
typedef duk_idx_t (*JSDukArgSetupFunc)(duk_context *ctx, void *argSetupParam); typedef duk_idx_t (*JSDukArgSetupFunc)(duk_context * ctx, void * argSetupParam);
typedef bool (*JSAppCallbackCondFunc)(JSAppCallback* cb, void* hookEnv); typedef bool (*JSAppCallbackCondFunc)(JSAppCallback * cb, void * hookEnv);
typedef void (*JSAppCallbackCleanupFunc)(duk_context* ctx, void *hookEnv); typedef void (*JSAppCallbackCleanupFunc)(duk_context * ctx, void * hookEnv);
typedef size_t JSAppCallbackID; typedef size_t JSAppCallbackID;
#define JS_INVALID_CALLBACK ((JSAppCallbackID)(-1)) #define JS_INVALID_CALLBACK ((JSAppCallbackID)(-1))
@ -76,26 +76,37 @@ typedef size_t JSAppCallbackID;
struct JSAppCallback struct JSAppCallback
{ {
// assigned by scriptsys when this is added to a callback map // assigned by scriptsys when this is added to a callback map
JSAppCallbackID m_CallbackId; JSAppCallbackID m_CallbackId;
bool m_bDisabled; bool m_bDisabled;
CScriptInstance *m_Instance; CScriptInstance * m_Instance;
void *m_DukFuncHeapPtr; void * m_DukFuncHeapPtr;
JSAppCallbackCondFunc m_ConditionFunc; JSAppCallbackCondFunc m_ConditionFunc;
JSDukArgSetupFunc m_DukArgSetupFunc; JSDukArgSetupFunc m_DukArgSetupFunc;
JSAppCallbackCleanupFunc m_CleanupFunc; JSAppCallbackCleanupFunc m_CleanupFunc;
struct { struct
{
uint32_t addrStart, addrEnd; uint32_t addrStart, addrEnd;
union { union
struct { uint32_t opcode, opcodeMask; }; {
struct { uint32_t regIndices, regValue; }; struct
{
uint32_t opcode, opcodeMask;
};
struct
{
uint32_t regIndices, regValue;
};
}; };
} m_Params; } m_Params;
static bool CbCondTrue(JSAppCallback*, void*) { return true; } static bool CbCondTrue(JSAppCallback *, void *)
{
return true;
}
JSAppCallback(CScriptInstance* instance, void* dukFuncHeapPtr, JSAppCallback(CScriptInstance * instance, void * dukFuncHeapPtr,
JSAppCallbackCondFunc condFunc = nullptr, JSAppCallbackCondFunc condFunc = nullptr,
JSDukArgSetupFunc argSetupFunc = nullptr, JSDukArgSetupFunc argSetupFunc = nullptr,
JSAppCallbackCleanupFunc cleanupFunc = nullptr) : JSAppCallbackCleanupFunc cleanupFunc = nullptr) :
@ -135,9 +146,9 @@ struct JSAppCallback
struct JSHookCpuStepEnv struct JSHookCpuStepEnv
{ {
uint32_t pc; uint32_t pc;
COpInfo opInfo; COpInfo opInfo;
int outAffectedRegIndex; // set by the condition function int outAffectedRegIndex; // set by the condition function
}; };
struct JSHookMouseEnv struct JSHookMouseEnv
@ -168,7 +179,7 @@ struct JSHookSpTaskEnv
struct JSHookPiDmaEnv struct JSHookPiDmaEnv
{ {
int direction; int direction;
uint32_t dramAddress; uint32_t dramAddress;
uint32_t cartAddress; uint32_t cartAddress;
uint32_t length; uint32_t length;
@ -182,21 +193,21 @@ struct JSHookEmuStateChangeEnv
struct JSSysCommand struct JSSysCommand
{ {
JSSysCommandID id; JSSysCommandID id;
stdstr paramA; stdstr paramA;
stdstr paramB; stdstr paramB;
void* paramC; void * paramC;
}; };
struct JSSysCMethodCall struct JSSysCMethodCall
{ {
void* m_DukThisHeapPtr; void * m_DukThisHeapPtr;
duk_c_function m_Func; duk_c_function m_Func;
JSDukArgSetupFunc m_ArgSetupFunc; JSDukArgSetupFunc m_ArgSetupFunc;
void* m_ArgSetupParam; void * m_ArgSetupParam;
JSSysCMethodCall(void* dukThisHeapPtr, duk_c_function func, JSSysCMethodCall(void * dukThisHeapPtr, duk_c_function func,
JSDukArgSetupFunc argSetupFunc = nullptr, JSDukArgSetupFunc argSetupFunc = nullptr,
void* argSetupParam = nullptr, void * argSetupParam = nullptr,
size_t argSetupParamSize = 0) : size_t argSetupParamSize = 0) :
m_DukThisHeapPtr(dukThisHeapPtr), m_DukThisHeapPtr(dukThisHeapPtr),
m_Func(func), m_Func(func),
@ -205,7 +216,7 @@ struct JSSysCMethodCall
{ {
if (argSetupParam != nullptr && argSetupParamSize != 0) if (argSetupParam != nullptr && argSetupParamSize != 0)
{ {
m_ArgSetupParam = (void*)(new char[argSetupParamSize]); m_ArgSetupParam = (void *)(new char[argSetupParamSize]);
memcpy(m_ArgSetupParam, argSetupParam, argSetupParamSize); memcpy(m_ArgSetupParam, argSetupParam, argSetupParamSize);
} }
} }
@ -214,7 +225,7 @@ struct JSSysCMethodCall
{ {
if (m_ArgSetupParam != nullptr) if (m_ArgSetupParam != nullptr)
{ {
delete[](char*)m_ArgSetupParam; delete[](char *) m_ArgSetupParam;
} }
} }
}; };

12
Source/Project64/UserInterface/Debugger/ScriptWorker.h
View File

@ -8,19 +8,19 @@ class CScriptWorker
private: private:
bool m_bStopping; bool m_bStopping;
bool m_bRegistered; bool m_bRegistered;
static DWORD WINAPI ThreadProc(void* _this); static DWORD WINAPI ThreadProc(void * _this);
public: public:
CScriptWorker(CScriptInstance* instance, void* dukObjectHeapPtr); CScriptWorker(CScriptInstance * instance, void * dukObjectHeapPtr);
virtual ~CScriptWorker(); virtual ~CScriptWorker();
void StartWorkerProc(); void StartWorkerProc();
virtual void StopWorkerProc(); virtual void StopWorkerProc();
protected: protected:
CScriptInstance* m_Instance; CScriptInstance * m_Instance;
void* m_DukObjectHeapPtr; void * m_DukObjectHeapPtr;
CriticalSection m_CS; CriticalSection m_CS;
HANDLE m_hThread; HANDLE m_hThread;
// Implementation should return when StopRequested() is true // Implementation should return when StopRequested() is true
virtual void WorkerProc() = 0; virtual void WorkerProc() = 0;

2
Source/Project64/UserInterface/Debugger/Symbols.cpp
View File

@ -38,7 +38,7 @@ symbol_type_info_t CSymbolTable::m_SymbolTypes[] = {
{SYM_VECTOR2, "v2", 8}, {SYM_VECTOR2, "v2", 8},
{SYM_VECTOR3, "v3", 12}, {SYM_VECTOR3, "v3", 12},
{SYM_VECTOR4, "v4", 16}, {SYM_VECTOR4, "v4", 16},
{ SYM_INVALID, nullptr, 0 } {SYM_INVALID, nullptr, 0},
}; };
symbol_type_id_t CSymbolTable::GetTypeId(char * typeName) symbol_type_id_t CSymbolTable::GetTypeId(char * typeName)

73
Source/Project64/UserInterface/Debugger/Symbols.h
View File

@ -2,7 +2,8 @@
class CSymbol; class CSymbol;
typedef enum { typedef enum
{
SYM_INVALID = -1, SYM_INVALID = -1,
SYM_CODE, SYM_CODE,
SYM_DATA, SYM_DATA,
@ -24,12 +25,13 @@ typedef enum {
typedef struct typedef struct
{ {
symbol_type_id_t id; symbol_type_id_t id;
const char* name; const char * name;
int size; int size;
} symbol_type_info_t; } symbol_type_info_t;
typedef enum { typedef enum
{
ERR_SUCCESS, ERR_SUCCESS,
ERR_INVALID_TYPE, ERR_INVALID_TYPE,
ERR_INVALID_ADDR, ERR_INVALID_ADDR,
@ -40,62 +42,63 @@ typedef enum {
class CSymbolTable class CSymbolTable
{ {
public: public:
CSymbolTable(CDebuggerUI* debugger); CSymbolTable(CDebuggerUI * debugger);
~CSymbolTable(); ~CSymbolTable();
private: private:
CSymbolTable(); CSymbolTable();
CDebuggerUI* m_Debugger; CDebuggerUI * m_Debugger;
CriticalSection m_CS; CriticalSection m_CS;
std::vector<CSymbol> m_Symbols; std::vector<CSymbol> m_Symbols;
std::map<uint32_t, size_t> m_AddressMap; // address -> symbol index std::map<uint32_t, size_t> m_AddressMap; // address -> symbol index
int m_NextSymbolId; int m_NextSymbolId;
CFile m_SymFileHandle; CFile m_SymFileHandle;
char* m_SymFileBuffer; char * m_SymFileBuffer;
size_t m_SymFileSize; size_t m_SymFileSize;
char* m_ParserToken; char * m_ParserToken;
size_t m_ParserTokenLength; size_t m_ParserTokenLength;
char* m_TokPos; char * m_TokPos;
char m_ParserDelimeter; char m_ParserDelimeter;
char* m_SymFileParseBuffer; char * m_SymFileParseBuffer;
bool m_bHaveFirstToken; bool m_bHaveFirstToken;
void ParserFetchToken(const char* delim); void ParserFetchToken(const char * delim);
void UpdateAddressMap(); void UpdateAddressMap();
public: public:
static symbol_type_info_t m_SymbolTypes[]; static symbol_type_info_t m_SymbolTypes[];
static const char* GetTypeName(int typeId); static const char * GetTypeName(int typeId);
static int GetTypeSize(int typeId); static int GetTypeSize(int typeId);
static symbol_type_id_t GetTypeId(char* typeName); static symbol_type_id_t GetTypeId(char * typeName);
static bool CmpSymbolAddresses(CSymbol& a, CSymbol& b); static bool CmpSymbolAddresses(CSymbol & a, CSymbol & b);
void GetValueString(char* dst, CSymbol* symbol); void GetValueString(char * dst, CSymbol * symbol);
CPath GetSymFilePath(); CPath GetSymFilePath();
void Load(); void Load();
void Save(); void Save();
void ParseErrorAlert(char* message, int lineNumber); void ParseErrorAlert(char * message, int lineNumber);
void AddSymbol(int type, uint32_t address, const char* name, const char* description = nullptr, bool bSortAfter = true); void AddSymbol(int type, uint32_t address, const char * name, const char * description = nullptr, bool bSortAfter = true);
void Reset(); void Reset();
int GetCount(); int GetCount();
bool GetSymbolById(int id, CSymbol* symbol); bool GetSymbolById(int id, CSymbol * symbol);
bool GetSymbolByIndex(size_t index, CSymbol* symbol); bool GetSymbolByIndex(size_t index, CSymbol * symbol);
bool GetSymbolByAddress(uint32_t address, CSymbol* symbol); bool GetSymbolByAddress(uint32_t address, CSymbol * symbol);
bool RemoveSymbolById(int id); bool RemoveSymbolById(int id);
}; };
class CSymbol { class CSymbol
{
public: public:
int m_Id; int m_Id;
int m_Type; int m_Type;
uint32_t m_Address; uint32_t m_Address;
char* m_Name; char * m_Name;
char* m_Description; char * m_Description;
CSymbol() : CSymbol() :
m_Id(0), m_Id(0),
@ -106,7 +109,7 @@ public:
{ {
} }
CSymbol(int id, int type, uint32_t address, const char* name, const char* description) : CSymbol(int id, int type, uint32_t address, const char * name, const char * description) :
m_Id(id), m_Id(id),
m_Type(type), m_Type(type),
m_Address(address), m_Address(address),
@ -124,7 +127,7 @@ public:
} }
} }
CSymbol(const CSymbol& symbol): CSymbol(const CSymbol & symbol) :
m_Id(symbol.m_Id), m_Id(symbol.m_Id),
m_Type(symbol.m_Type), m_Type(symbol.m_Type),
m_Address(symbol.m_Address), m_Address(symbol.m_Address),
@ -135,7 +138,7 @@ public:
m_Description = symbol.m_Description ? _strdup(symbol.m_Description) : nullptr; m_Description = symbol.m_Description ? _strdup(symbol.m_Description) : nullptr;
} }
CSymbol& operator= (const CSymbol& symbol) CSymbol & operator=(const CSymbol & symbol)
{ {
if (m_Name != nullptr) if (m_Name != nullptr)
{ {
@ -168,7 +171,7 @@ public:
} }
} }
const char* TypeName() const char * TypeName()
{ {
return CSymbolTable::GetTypeName(m_Type); return CSymbolTable::GetTypeName(m_Type);
} }

60
Source/Project64/UserInterface/Debugger/debugger.h
View File

@ -1,8 +1,8 @@
#pragma once #pragma once
#include <Project64-core/Debugger.h>
#include <Common/SyncEvent.h>
#include <Project64-core/Settings/DebugSettings.h>
#include "DebugMMU.h" #include "DebugMMU.h"
#include <Common/SyncEvent.h>
#include <Project64-core/Debugger.h>
#include <Project64-core/Settings/DebugSettings.h>
class CDumpMemory; class CDumpMemory;
class CDebugMemoryView; class CDebugMemoryView;
@ -43,7 +43,7 @@ public:
void OpenCommandWindow(void); void OpenCommandWindow(void);
void Debug_ShowCommandsLocation(uint32_t address, bool top); void Debug_ShowCommandsLocation(uint32_t address, bool top);
void OpenScriptsWindow(void); void OpenScriptsWindow(void);
void Debug_LogScriptsWindow(const char* text); void Debug_LogScriptsWindow(const char * text);
void Debug_ClearScriptsWindow(void); void Debug_ClearScriptsWindow(void);
void Debug_RefreshScriptsWindow(void); void Debug_RefreshScriptsWindow(void);
void Debug_RefreshSymbolsWindow(void); void Debug_RefreshSymbolsWindow(void);
@ -71,14 +71,14 @@ public:
bool WriteBP64(uint32_t address); bool WriteBP64(uint32_t address);
void WaitForStep(void); void WaitForStep(void);
CBreakpoints* Breakpoints(); CBreakpoints * Breakpoints();
CDebugSymbols* Symbols(); CDebugSymbols * Symbols();
CScriptSystem* ScriptSystem(); CScriptSystem * ScriptSystem();
CDebugScripts* ScriptConsole(); CDebugScripts * ScriptConsole();
CDMALog* DMALog(); CDMALog * DMALog();
CCPULog* CPULog(); CCPULog * CPULog();
CSymbolTable* SymbolTable(); CSymbolTable * SymbolTable();
SyncEvent& StepEvent(); SyncEvent & StepEvent();
static void GameReset(CDebuggerUI * _this); static void GameReset(CDebuggerUI * _this);
static void GameCpuRunningChanged(CDebuggerUI * _this); static void GameCpuRunningChanged(CDebuggerUI * _this);
@ -101,27 +101,27 @@ protected:
void EmulationStopped(void); void EmulationStopped(void);
private: private:
CDebuggerUI(const CDebuggerUI&); CDebuggerUI(const CDebuggerUI &);
CDebuggerUI& operator=(const CDebuggerUI&); CDebuggerUI & operator=(const CDebuggerUI &);
CDumpMemory * m_MemoryDump; CDumpMemory * m_MemoryDump;
CDebugMemoryView * m_MemoryView; CDebugMemoryView * m_MemoryView;
CDebugMemorySearch * m_MemorySearch; CDebugMemorySearch * m_MemorySearch;
CDebugTlb * m_DebugTLB; CDebugTlb * m_DebugTLB;
CDebugCommandsView * m_CommandsView; CDebugCommandsView * m_CommandsView;
CDebugScripts * m_Scripts; CDebugScripts * m_Scripts;
CDebugSymbols * m_Symbols; CDebugSymbols * m_Symbols;
CDebugDMALogView * m_DMALogView; CDebugDMALogView * m_DMALogView;
CDebugCPULogView * m_CPULogView; CDebugCPULogView * m_CPULogView;
CDebugStackTrace * m_StackTrace; CDebugStackTrace * m_StackTrace;
CDebugStackView * m_StackView; CDebugStackView * m_StackView;
CDebugExcBreakpoints * m_ExcBreakpoints; CDebugExcBreakpoints * m_ExcBreakpoints;
CBreakpoints * m_Breakpoints; CBreakpoints * m_Breakpoints;
CScriptSystem * m_ScriptSystem; CScriptSystem * m_ScriptSystem;
CSymbolTable * m_SymbolTable; CSymbolTable * m_SymbolTable;
CDMALog * m_DMALog; CDMALog * m_DMALog;
CCPULog * m_CPULog; CCPULog * m_CPULog;
SyncEvent m_StepEvent; SyncEvent m_StepEvent;

8
Source/Project64/UserInterface/DiscordRPC.h
View File

@ -4,10 +4,10 @@
class CDiscord class CDiscord
{ {
private: private:
static int64_t Timestamp(void); static int64_t Timestamp(void);
public: public:
static void Init(void); static void Init(void);
static void Shutdown(void); static void Shutdown(void);
static void Update(bool bHaveGame = true); static void Update(bool bHaveGame = true);
}; };

195
Source/Project64/UserInterface/EnhancementUI.cpp
View File

@ -1,36 +1,41 @@
#include "stdafx.h" #include "stdafx.h"
#include <Project64\UserInterface\EnhancementUI.h>
#include <Project64-core/N64System/Enhancement/Enhancements.h> #include <Project64-core/N64System/Enhancement/Enhancements.h>
#include <Project64\UserInterface\EnhancementUI.h>
class CEditEnhancement : class CEditEnhancement :
public CDialogImpl < CEditEnhancement > public CDialogImpl<CEditEnhancement>
{ {
public: public:
BEGIN_MSG_MAP_EX(CEditEnhancement) BEGIN_MSG_MAP_EX(CEditEnhancement)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_HANDLER_EX(IDC_GAMESHARK, BN_CLICKED, OnGamesharkBtn) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_HANDLER_EX(IDC_OVERCLOCK, BN_CLICKED, OnOverClockBtn) COMMAND_HANDLER_EX(IDC_GAMESHARK, BN_CLICKED, OnGamesharkBtn);
COMMAND_ID_HANDLER(IDC_BTN_GAMESHARK, OnEditGameshark) COMMAND_HANDLER_EX(IDC_OVERCLOCK, BN_CLICKED, OnOverClockBtn);
COMMAND_ID_HANDLER(IDOK, OnOkCmd) COMMAND_ID_HANDLER(IDC_BTN_GAMESHARK, OnEditGameshark);
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd) COMMAND_ID_HANDLER(IDOK, OnOkCmd);
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd);
}
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_Enhancement_Edit }; enum
{
IDD = IDD_Enhancement_Edit
};
CEditEnhancement(CEnhancementUI & EnhancementUI, CEnhancement * Enhancement); CEditEnhancement(CEnhancementUI & EnhancementUI, CEnhancement * Enhancement);
private: private:
CEditEnhancement(void); CEditEnhancement(void);
CEditEnhancement(const CEditEnhancement&); CEditEnhancement(const CEditEnhancement &);
CEditEnhancement& operator=(const CEditEnhancement&); CEditEnhancement & operator=(const CEditEnhancement &);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnGamesharkBtn(UINT Code, int id, HWND ctl); LRESULT OnGamesharkBtn(UINT Code, int id, HWND ctl);
LRESULT OnOverClockBtn(UINT Code, int id, HWND ctl); LRESULT OnOverClockBtn(UINT Code, int id, HWND ctl);
LRESULT OnEditGameshark(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnEditGameshark(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnOkCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnOkCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
CEnhancementUI & m_EnhancementUI; CEnhancementUI & m_EnhancementUI;
CEnhancement::CodeEntries m_Entries; CEnhancement::CodeEntries m_Entries;
@ -43,26 +48,31 @@ class CEditGS :
{ {
public: public:
BEGIN_MSG_MAP_EX(CEditGS) BEGIN_MSG_MAP_EX(CEditGS)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_HANDLER(IDC_CHEAT_CODES, EN_CHANGE, OnCheatChanged) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_HANDLER_EX(IDC_CHK_LIMIT_PLUGINS, BN_CLICKED, OnPluginBtn) COMMAND_HANDLER(IDC_CHEAT_CODES, EN_CHANGE, OnCheatChanged);
COMMAND_ID_HANDLER(IDC_BTN_PLUGIN, OnEditPlugins) COMMAND_HANDLER_EX(IDC_CHK_LIMIT_PLUGINS, BN_CLICKED, OnPluginBtn);
COMMAND_ID_HANDLER(IDOK, OnOkCmd) COMMAND_ID_HANDLER(IDC_BTN_PLUGIN, OnEditPlugins);
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd) COMMAND_ID_HANDLER(IDOK, OnOkCmd);
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd);
}
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_Enhancement_GS }; enum
{
IDD = IDD_Enhancement_GS
};
CEditGS(CEnhancement::CodeEntries & Entries, CEnhancement::PluginList & PluginList); CEditGS(CEnhancement::CodeEntries & Entries, CEnhancement::PluginList & PluginList);
private: private:
CEditGS(); CEditGS();
CEditGS(const CEditGS&); CEditGS(const CEditGS &);
CEditGS& operator=(const CEditGS&); CEditGS & operator=(const CEditGS &);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnPluginBtn(UINT Code, int id, HWND ctl); LRESULT OnPluginBtn(UINT Code, int id, HWND ctl);
LRESULT OnEditPlugins(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnEditPlugins(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled); LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnOkCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled); LRESULT OnOkCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCheatChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled); LRESULT OnCheatChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
@ -78,25 +88,30 @@ class CEditPluginList :
{ {
public: public:
BEGIN_MSG_MAP_EX(CEditPluginList) BEGIN_MSG_MAP_EX(CEditPluginList)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
COMMAND_ID_HANDLER(IDC_ADD, OnAddBtn) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_ID_HANDLER(IDC_REMOVE, OnRemoveBtn) COMMAND_ID_HANDLER(IDC_ADD, OnAddBtn);
COMMAND_ID_HANDLER(IDOK, OnOkCmd) COMMAND_ID_HANDLER(IDC_REMOVE, OnRemoveBtn);
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd) COMMAND_ID_HANDLER(IDOK, OnOkCmd);
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd);
}
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_Enhancement_Plugins }; enum
{
IDD = IDD_Enhancement_Plugins
};
CEditPluginList(CEnhancement::PluginList & List); CEditPluginList(CEnhancement::PluginList & List);
private: private:
CEditPluginList(); CEditPluginList();
CEditPluginList(const CEditPluginList&); CEditPluginList(const CEditPluginList &);
CEditPluginList& operator=(const CEditPluginList&); CEditPluginList & operator=(const CEditPluginList &);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnAddBtn(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnAddBtn(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnRemoveBtn(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnRemoveBtn(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled); LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnOkCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled); LRESULT OnOkCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
@ -132,7 +147,7 @@ void CEnhancementUI::Display(HWND hParent, bool BlockExecution)
} }
} }
LRESULT CEnhancementUI::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) LRESULT CEnhancementUI::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/)
{ {
SetWindowText(wGS(ENHANCEMENT_TITLE).c_str()); SetWindowText(wGS(ENHANCEMENT_TITLE).c_str());
@ -169,7 +184,7 @@ LRESULT CEnhancementUI::OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lPa
return 0; return 0;
} }
LRESULT CEnhancementUI::OnCloseCmd(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEnhancementUI::OnCloseCmd(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
if (g_BaseSystem) if (g_BaseSystem)
{ {
@ -186,9 +201,9 @@ LRESULT CEnhancementUI::OnCloseCmd(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hW
return TRUE; return TRUE;
} }
LRESULT CEnhancementUI::OnEditEnhancement(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEnhancementUI::OnEditEnhancement(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
TVITEM item = { 0 }; TVITEM item = {0};
item.mask = TVIF_PARAM; item.mask = TVIF_PARAM;
item.hItem = m_hSelectedItem; item.hItem = m_hSelectedItem;
if (!m_TreeList.GetItem(&item) || item.lParam == NULL) if (!m_TreeList.GetItem(&item) || item.lParam == NULL)
@ -200,17 +215,17 @@ LRESULT CEnhancementUI::OnEditEnhancement(WORD /*wNotifyCode*/, WORD /*wID*/, HW
return TRUE; return TRUE;
} }
LRESULT CEnhancementUI::OnAddEnhancement(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEnhancementUI::OnAddEnhancement(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
CEditEnhancement(*this, nullptr).DoModal(m_hWnd); CEditEnhancement(*this, nullptr).DoModal(m_hWnd);
RefreshList(); RefreshList();
return TRUE; return TRUE;
} }
LRESULT CEnhancementUI::OnEnhancementListClicked(NMHDR* lpnmh) LRESULT CEnhancementUI::OnEnhancementListClicked(NMHDR * lpnmh)
{ {
uint32_t dwpos = GetMessagePos(); uint32_t dwpos = GetMessagePos();
TVHITTESTINFO ht = { 0 }; TVHITTESTINFO ht = {0};
ht.pt.x = GET_X_LPARAM(dwpos); ht.pt.x = GET_X_LPARAM(dwpos);
ht.pt.y = GET_Y_LPARAM(dwpos); ht.pt.y = GET_Y_LPARAM(dwpos);
::MapWindowPoints(HWND_DESKTOP, lpnmh->hwndFrom, &ht.pt, 1); ::MapWindowPoints(HWND_DESKTOP, lpnmh->hwndFrom, &ht.pt, 1);
@ -248,7 +263,7 @@ LRESULT CEnhancementUI::OnEnhancementListClicked(NMHDR* lpnmh)
return 0; return 0;
} }
LRESULT CEnhancementUI::OnPopupDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) LRESULT CEnhancementUI::OnPopupDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled)
{ {
int Response = MessageBox(wGS(MSG_DEL_SURE).c_str(), wGS(MSG_DEL_TITLE).c_str(), MB_YESNO | MB_ICONQUESTION); int Response = MessageBox(wGS(MSG_DEL_SURE).c_str(), wGS(MSG_DEL_TITLE).c_str(), MB_YESNO | MB_ICONQUESTION);
if (Response != IDYES) if (Response != IDYES)
@ -256,7 +271,7 @@ LRESULT CEnhancementUI::OnPopupDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl,
return 0; return 0;
} }
TVITEM item = { 0 }; TVITEM item = {0};
item.hItem = m_hSelectedItem; item.hItem = m_hSelectedItem;
item.mask = TVIF_PARAM; item.mask = TVIF_PARAM;
m_TreeList.GetItem(&item); m_TreeList.GetItem(&item);
@ -276,9 +291,9 @@ LRESULT CEnhancementUI::OnPopupDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl,
return 0; return 0;
} }
LRESULT CEnhancementUI::OnEnhancementListRClicked(NMHDR* pNMHDR) LRESULT CEnhancementUI::OnEnhancementListRClicked(NMHDR * pNMHDR)
{ {
TVHITTESTINFO ht = { 0 }; TVHITTESTINFO ht = {0};
uint32_t dwpos = GetMessagePos(); uint32_t dwpos = GetMessagePos();
ht.pt.x = GET_X_LPARAM(dwpos); ht.pt.x = GET_X_LPARAM(dwpos);
ht.pt.y = GET_Y_LPARAM(dwpos); ht.pt.y = GET_Y_LPARAM(dwpos);
@ -307,7 +322,7 @@ LRESULT CEnhancementUI::OnEnhancementListRClicked(NMHDR* pNMHDR)
LRESULT CEnhancementUI::OnEnhancementListDClicked(NMHDR * lpnmh) LRESULT CEnhancementUI::OnEnhancementListDClicked(NMHDR * lpnmh)
{ {
uint32_t dwpos = GetMessagePos(); uint32_t dwpos = GetMessagePos();
TVHITTESTINFO ht = { 0 }; TVHITTESTINFO ht = {0};
ht.pt.x = GET_X_LPARAM(dwpos); ht.pt.x = GET_X_LPARAM(dwpos);
ht.pt.y = GET_Y_LPARAM(dwpos); ht.pt.y = GET_Y_LPARAM(dwpos);
::MapWindowPoints(HWND_DESKTOP, lpnmh->hwndFrom, &ht.pt, 1); ::MapWindowPoints(HWND_DESKTOP, lpnmh->hwndFrom, &ht.pt, 1);
@ -318,7 +333,7 @@ LRESULT CEnhancementUI::OnEnhancementListDClicked(NMHDR * lpnmh)
{ {
return 0; return 0;
} }
TVITEM item = { 0 }; TVITEM item = {0};
item.mask = TVIF_PARAM; item.mask = TVIF_PARAM;
item.hItem = (HTREEITEM)ht.hItem; item.hItem = (HTREEITEM)ht.hItem;
if (!m_TreeList.GetItem(&item) || item.lParam == NULL) if (!m_TreeList.GetItem(&item) || item.lParam == NULL)
@ -337,7 +352,7 @@ LRESULT CEnhancementUI::OnEnhancementListSelChanged(NMHDR * /*lpnmh*/)
GetDlgItem(IDC_NOTES).SetWindowText(L""); GetDlgItem(IDC_NOTES).SetWindowText(L"");
if (m_TreeList.GetChildItem(hItem) == nullptr) if (m_TreeList.GetChildItem(hItem) == nullptr)
{ {
TVITEM item = { 0 }; TVITEM item = {0};
item.mask = TVIF_PARAM; item.mask = TVIF_PARAM;
item.hItem = hItem; item.hItem = hItem;
m_TreeList.GetItem(&item); m_TreeList.GetItem(&item);
@ -355,9 +370,15 @@ void CEnhancementUI::AddCodeLayers(LPARAM Enhancement, const std::wstring & Name
TV_INSERTSTRUCT tv; TV_INSERTSTRUCT tv;
wchar_t Text[500], Item[500]; wchar_t Text[500], Item[500];
if (Name.length() > ((sizeof(Text) / sizeof(Text[0])) - 5)) { g_Notify->BreakPoint(__FILE__, __LINE__); } if (Name.length() > ((sizeof(Text) / sizeof(Text[0])) - 5))
{
g_Notify->BreakPoint(__FILE__, __LINE__);
}
wcscpy(Text, Name.c_str()); wcscpy(Text, Name.c_str());
if (wcschr(Text, L'\\') > 0) { *wcschr(Text, L'\\') = 0; } if (wcschr(Text, L'\\') > 0)
{
*wcschr(Text, L'\\') = 0;
}
tv.item.mask = TVIF_TEXT; tv.item.mask = TVIF_TEXT;
tv.item.pszText = Item; tv.item.pszText = Item;
@ -393,18 +414,25 @@ void CEnhancementUI::AddCodeLayers(LPARAM Enhancement, const std::wstring & Name
hParent = m_TreeList.InsertItem(&tv); hParent = m_TreeList.InsertItem(&tv);
TV_SetCheckState(hParent, Active ? TV_STATE_CHECKED : TV_STATE_CLEAR); TV_SetCheckState(hParent, Active ? TV_STATE_CHECKED : TV_STATE_CLEAR);
if (wcscmp(Text, Name.c_str()) == 0) { return; } if (wcscmp(Text, Name.c_str()) == 0)
{
return;
}
AddCodeLayers(Enhancement, Name.substr(wcslen(Text) + 1), hParent, Active); AddCodeLayers(Enhancement, Name.substr(wcslen(Text) + 1), hParent, Active);
} }
void CEnhancementUI::ChangeChildrenStatus(HTREEITEM hParent, bool Checked) void CEnhancementUI::ChangeChildrenStatus(HTREEITEM hParent, bool Checked)
{ {
HTREEITEM hItem = m_TreeList.GetChildItem(hParent);; HTREEITEM hItem = m_TreeList.GetChildItem(hParent);
;
if (hItem == nullptr) if (hItem == nullptr)
{ {
if (hParent == TVI_ROOT) { return; } if (hParent == TVI_ROOT)
{
return;
}
TVITEM item = { 0 }; TVITEM item = {0};
item.mask = TVIF_PARAM; item.mask = TVIF_PARAM;
item.hItem = hParent; item.hItem = hParent;
m_TreeList.GetItem(&item); m_TreeList.GetItem(&item);
@ -430,14 +458,19 @@ void CEnhancementUI::ChangeChildrenStatus(HTREEITEM hParent, bool Checked)
while (hItem != nullptr) while (hItem != nullptr)
{ {
TV_CHECK_STATE ChildState = TV_GetCheckState(hItem); TV_CHECK_STATE ChildState = TV_GetCheckState(hItem);
if ((ChildState != TV_STATE_CHECKED || !Checked) && if ((ChildState != TV_STATE_CHECKED || !Checked) && (ChildState != TV_STATE_CLEAR || Checked))
(ChildState != TV_STATE_CLEAR || Checked))
{ {
ChangeChildrenStatus(hItem, Checked); ChangeChildrenStatus(hItem, Checked);
} }
ChildState = TV_GetCheckState(hItem); ChildState = TV_GetCheckState(hItem);
if (state == TV_STATE_UNKNOWN) { state = ChildState; } if (state == TV_STATE_UNKNOWN)
if (state != ChildState) { state = TV_STATE_INDETERMINATE; } {
state = ChildState;
}
if (state != ChildState)
{
state = TV_STATE_INDETERMINATE;
}
hItem = m_TreeList.GetNextSiblingItem(hItem); hItem = m_TreeList.GetNextSiblingItem(hItem);
} }
if (state != TV_STATE_UNKNOWN) if (state != TV_STATE_UNKNOWN)
@ -487,7 +520,7 @@ void CEnhancementUI::RefreshList()
CEnhancementUI::TV_CHECK_STATE CEnhancementUI::TV_GetCheckState(HTREEITEM hItem) CEnhancementUI::TV_CHECK_STATE CEnhancementUI::TV_GetCheckState(HTREEITEM hItem)
{ {
TVITEM tvItem = { 0 }; TVITEM tvItem = {0};
tvItem.mask = TVIF_HANDLE | TVIF_STATE; tvItem.mask = TVIF_HANDLE | TVIF_STATE;
tvItem.hItem = hItem; tvItem.hItem = hItem;
tvItem.stateMask = TVIS_STATEIMAGEMASK; tvItem.stateMask = TVIS_STATEIMAGEMASK;
@ -505,7 +538,7 @@ CEnhancementUI::TV_CHECK_STATE CEnhancementUI::TV_GetCheckState(HTREEITEM hItem)
bool CEnhancementUI::TV_SetCheckState(HTREEITEM hItem, TV_CHECK_STATE state) bool CEnhancementUI::TV_SetCheckState(HTREEITEM hItem, TV_CHECK_STATE state)
{ {
TVITEM tvItem = { 0 }; TVITEM tvItem = {0};
tvItem.mask = TVIF_HANDLE | TVIF_STATE; tvItem.mask = TVIF_HANDLE | TVIF_STATE;
tvItem.hItem = (HTREEITEM)hItem; tvItem.hItem = (HTREEITEM)hItem;
tvItem.stateMask = TVIS_STATEIMAGEMASK; tvItem.stateMask = TVIS_STATEIMAGEMASK;
@ -526,7 +559,7 @@ CEditEnhancement::CEditEnhancement(CEnhancementUI & EnhancementUI, CEnhancement
{ {
} }
LRESULT CEditEnhancement::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) LRESULT CEditEnhancement::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/)
{ {
m_Entries = m_EditEnhancement != nullptr ? m_EditEnhancement->GetEntries() : CEnhancement::CodeEntries(); m_Entries = m_EditEnhancement != nullptr ? m_EditEnhancement->GetEntries() : CEnhancement::CodeEntries();
m_PluginList = m_EditEnhancement != nullptr ? m_EditEnhancement->GetPluginList() : CEnhancement::PluginList(); m_PluginList = m_EditEnhancement != nullptr ? m_EditEnhancement->GetPluginList() : CEnhancement::PluginList();
@ -536,7 +569,7 @@ LRESULT CEditEnhancement::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM
CButton(GetDlgItem(IDC_AUTOON)).SetCheck(m_EditEnhancement != nullptr ? (m_EditEnhancement->GetOnByDefault() ? BST_CHECKED : BST_UNCHECKED) : BST_UNCHECKED); CButton(GetDlgItem(IDC_AUTOON)).SetCheck(m_EditEnhancement != nullptr ? (m_EditEnhancement->GetOnByDefault() ? BST_CHECKED : BST_UNCHECKED) : BST_UNCHECKED);
CButton(GetDlgItem(IDC_GAMESHARK)).SetCheck(m_Entries.size() > 0 ? BST_CHECKED : BST_UNCHECKED); CButton(GetDlgItem(IDC_GAMESHARK)).SetCheck(m_Entries.size() > 0 ? BST_CHECKED : BST_UNCHECKED);
CButton(GetDlgItem(IDC_OVERCLOCK)).SetCheck(m_EditEnhancement != nullptr ? (m_EditEnhancement->OverClock() ? BST_CHECKED : BST_UNCHECKED) : BST_UNCHECKED); CButton(GetDlgItem(IDC_OVERCLOCK)).SetCheck(m_EditEnhancement != nullptr ? (m_EditEnhancement->OverClock() ? BST_CHECKED : BST_UNCHECKED) : BST_UNCHECKED);
GetDlgItem(IDC_OVER_CLOCK_MODIFIER).SetWindowText(m_EditEnhancement != nullptr ? stdstr_f("%d",m_EditEnhancement->OverClockModifier()).ToUTF16().c_str() : L"1"); GetDlgItem(IDC_OVER_CLOCK_MODIFIER).SetWindowText(m_EditEnhancement != nullptr ? stdstr_f("%d", m_EditEnhancement->OverClockModifier()).ToUTF16().c_str() : L"1");
GetDlgItem(IDC_OVER_CLOCK_MODIFIER).EnableWindow(m_EditEnhancement != nullptr ? m_EditEnhancement->OverClock() : false); GetDlgItem(IDC_OVER_CLOCK_MODIFIER).EnableWindow(m_EditEnhancement != nullptr ? m_EditEnhancement->OverClock() : false);
return TRUE; return TRUE;
@ -556,19 +589,19 @@ LRESULT CEditEnhancement::OnOverClockBtn(UINT /*Code*/, int /*id*/, HWND /*ctl*/
return 0; return 0;
} }
LRESULT CEditEnhancement::OnEditGameshark(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEditEnhancement::OnEditGameshark(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
OnGamesharkBtn(0, 0, 0); OnGamesharkBtn(0, 0, 0);
return TRUE; return TRUE;
} }
LRESULT CEditEnhancement::OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEditEnhancement::OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
EndDialog(wID); EndDialog(wID);
return TRUE; return TRUE;
} }
LRESULT CEditEnhancement::OnOkCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEditEnhancement::OnOkCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
CEnhancement TempEnhancement(CEnhancement::EnhancementIdent); CEnhancement TempEnhancement(CEnhancement::EnhancementIdent);
CEnhancement & Enhancement = m_EditEnhancement != nullptr ? *m_EditEnhancement : TempEnhancement; CEnhancement & Enhancement = m_EditEnhancement != nullptr ? *m_EditEnhancement : TempEnhancement;
@ -597,7 +630,7 @@ CEditGS::CEditGS(CEnhancement::CodeEntries & Entries, CEnhancement::PluginList &
{ {
} }
LRESULT CEditGS::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) LRESULT CEditGS::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/)
{ {
stdstr Buffer; stdstr Buffer;
for (size_t i = 0, n = m_Entries.size(); i < n; i++) for (size_t i = 0, n = m_Entries.size(); i < n; i++)
@ -623,20 +656,20 @@ LRESULT CEditGS::OnPluginBtn(UINT /*Code*/, int /*id*/, HWND /*ctl*/)
return 0; return 0;
} }
LRESULT CEditGS::OnEditPlugins(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEditGS::OnEditPlugins(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
OnPluginBtn(0, 0, 0); OnPluginBtn(0, 0, 0);
return 0; return 0;
} }
LRESULT CEditGS::OnCheatChanged(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEditGS::OnCheatChanged(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
CEnhancement::CodeEntries Entries; CEnhancement::CodeEntries Entries;
GetDlgItem(IDOK).EnableWindow(CheatCode(Entries)); GetDlgItem(IDOK).EnableWindow(CheatCode(Entries));
return true; return true;
} }
LRESULT CEditGS::OnOkCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEditGS::OnOkCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
CEnhancement::CodeEntries Entries; CEnhancement::CodeEntries Entries;
if (CheatCode(Entries)) if (CheatCode(Entries))
@ -647,7 +680,7 @@ LRESULT CEditGS::OnOkCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL&
return TRUE; return TRUE;
} }
LRESULT CEditGS::OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/) LRESULT CEditGS::OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/)
{ {
EndDialog(wID); EndDialog(wID);
return TRUE; return TRUE;
@ -665,15 +698,18 @@ bool CEditGS::CheatCode(CEnhancement::CodeEntries & Entries)
{ {
const char * formatnormal = "XXXXXXXX XXXX"; const char * formatnormal = "XXXXXXXX XXXX";
wchar_t wstr[128] = { 0 }; wchar_t wstr[128] = {0};
*(LPWORD)wstr = sizeof(wstr) / sizeof(wstr[0]); *(LPWORD)wstr = sizeof(wstr) / sizeof(wstr[0]);
uint32_t len = CheatCodes.GetLine(line, wstr); uint32_t len = CheatCodes.GetLine(line, wstr);
wstr[len] = 0; wstr[len] = 0;
if (len <= 0) { continue; } if (len <= 0)
{
continue;
}
std::string str = stdstr().FromUTF16(wstr); std::string str = stdstr().FromUTF16(wstr);
char tempformat[128] = { 0 }; char tempformat[128] = {0};
for (uint32_t i = 0; i < sizeof(tempformat); i++) for (uint32_t i = 0; i < sizeof(tempformat); i++)
{ {
if (isxdigit(str[i])) if (isxdigit(str[i]))
@ -684,7 +720,10 @@ bool CEditGS::CheatCode(CEnhancement::CodeEntries & Entries)
{ {
tempformat[i] = str[i]; tempformat[i] = str[i];
} }
if (str[i] == 0) { break; } if (str[i] == 0)
{
break;
}
} }
if (strcmp(tempformat, formatnormal) == 0) if (strcmp(tempformat, formatnormal) == 0)
@ -728,7 +767,7 @@ CEditPluginList::CEditPluginList(CEnhancement::PluginList & List) :
{ {
} }
LRESULT CEditPluginList::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/) LRESULT CEditPluginList::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/)
{ {
m_PluginListBox.Attach(GetDlgItem(IDC_PLUGIN_LIST)); m_PluginListBox.Attach(GetDlgItem(IDC_PLUGIN_LIST));
for (size_t i = 0, n = m_PluginList.size(); i < n; i++) for (size_t i = 0, n = m_PluginList.size(); i < n; i++)

35
Source/Project64/UserInterface/EnhancementUI.h
View File

@ -16,19 +16,24 @@ class CEnhancementUI :
public: public:
BEGIN_MSG_MAP_EX(CEnhancementUI) BEGIN_MSG_MAP_EX(CEnhancementUI)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) {
MESSAGE_HANDLER(WM_DESTROY, OnDestroy) MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog);
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd) MESSAGE_HANDLER(WM_DESTROY, OnDestroy);
COMMAND_ID_HANDLER(ID_POPUP_EDIT, OnEditEnhancement) COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd);
COMMAND_ID_HANDLER(ID_POPUP_ADDENHANCEMENT, OnAddEnhancement) COMMAND_ID_HANDLER(ID_POPUP_EDIT, OnEditEnhancement);
COMMAND_ID_HANDLER(ID_POPUP_DELETE, OnPopupDelete) COMMAND_ID_HANDLER(ID_POPUP_ADDENHANCEMENT, OnAddEnhancement);
NOTIFY_HANDLER_EX(IDC_ENHANCEMENTLIST, NM_CLICK, OnEnhancementListClicked) COMMAND_ID_HANDLER(ID_POPUP_DELETE, OnPopupDelete);
NOTIFY_HANDLER_EX(IDC_ENHANCEMENTLIST, NM_RCLICK, OnEnhancementListRClicked) NOTIFY_HANDLER_EX(IDC_ENHANCEMENTLIST, NM_CLICK, OnEnhancementListClicked);
NOTIFY_HANDLER_EX(IDC_ENHANCEMENTLIST, NM_DBLCLK, OnEnhancementListDClicked) NOTIFY_HANDLER_EX(IDC_ENHANCEMENTLIST, NM_RCLICK, OnEnhancementListRClicked);
NOTIFY_HANDLER_EX(IDC_ENHANCEMENTLIST, TVN_SELCHANGED, OnEnhancementListSelChanged) NOTIFY_HANDLER_EX(IDC_ENHANCEMENTLIST, NM_DBLCLK, OnEnhancementListDClicked);
NOTIFY_HANDLER_EX(IDC_ENHANCEMENTLIST, TVN_SELCHANGED, OnEnhancementListSelChanged);
}
END_MSG_MAP() END_MSG_MAP()
enum { IDD = IDD_Enhancement_Config }; enum
{
IDD = IDD_Enhancement_Config
};
CEnhancementUI(); CEnhancementUI();
@ -37,15 +42,15 @@ public:
private: private:
friend CEditEnhancement; friend CEditEnhancement;
CEnhancementUI(const CEnhancementUI&); CEnhancementUI(const CEnhancementUI &);
CEnhancementUI& operator=(const CEnhancementUI&); CEnhancementUI & operator=(const CEnhancementUI &);
LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled); LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled); LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
LRESULT OnEditEnhancement(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled); LRESULT OnEditEnhancement(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnAddEnhancement(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled ); LRESULT OnAddEnhancement(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled); LRESULT OnCloseCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnPopupDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); LRESULT OnPopupDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL & bHandled);
LRESULT OnEnhancementListClicked(NMHDR * lpnmh); LRESULT OnEnhancementListClicked(NMHDR * lpnmh);
LRESULT OnEnhancementListRClicked(NMHDR * lpnmh); LRESULT OnEnhancementListRClicked(NMHDR * lpnmh);
LRESULT OnEnhancementListDClicked(NMHDR * lpnmh); LRESULT OnEnhancementListDClicked(NMHDR * lpnmh);

125
Source/Project64/UserInterface/LoggingUI.cpp
View File

@ -61,18 +61,45 @@ LRESULT CALLBACK LogGeneralProc(HWND hDlg, UINT uMsg, WPARAM /*wParam*/, LPARAM
{ {
case WM_INITDIALOG: case WM_INITDIALOG:
{ {
if (CLogSettings::LogCP0changes()) { CheckDlgButton(hDlg, IDC_CP0_WRITE, BST_CHECKED); } if (CLogSettings::LogCP0changes())
if (CLogSettings::LogCP0reads()) { CheckDlgButton(hDlg, IDC_CP0_READ, BST_CHECKED); } {
if (CLogSettings::LogCache()) { CheckDlgButton(hDlg, IDC_CACHE, BST_CHECKED); } CheckDlgButton(hDlg, IDC_CP0_WRITE, BST_CHECKED);
if (CLogSettings::LogExceptions()) { CheckDlgButton(hDlg, IDC_EXCEPTIONS, BST_CHECKED); } }
if (CLogSettings::LogNoInterrupts()) { CheckDlgButton(hDlg, IDC_INTERRUPTS, BST_CHECKED); } if (CLogSettings::LogCP0reads())
if (CLogSettings::LogTLB()) { CheckDlgButton(hDlg, IDC_TLB, BST_CHECKED); } {
if (CLogSettings::LogRomHeader()) { CheckDlgButton(hDlg, IDC_ROM_HEADER, BST_CHECKED); } CheckDlgButton(hDlg, IDC_CP0_READ, BST_CHECKED);
if (CLogSettings::LogUnknown()) { CheckDlgButton(hDlg, IDC_UNKOWN, BST_CHECKED); } }
if (CLogSettings::LogCache())
{
CheckDlgButton(hDlg, IDC_CACHE, BST_CHECKED);
}
if (CLogSettings::LogExceptions())
{
CheckDlgButton(hDlg, IDC_EXCEPTIONS, BST_CHECKED);
}
if (CLogSettings::LogNoInterrupts())
{
CheckDlgButton(hDlg, IDC_INTERRUPTS, BST_CHECKED);
}
if (CLogSettings::LogTLB())
{
CheckDlgButton(hDlg, IDC_TLB, BST_CHECKED);
}
if (CLogSettings::LogRomHeader())
{
CheckDlgButton(hDlg, IDC_ROM_HEADER, BST_CHECKED);
}
if (CLogSettings::LogUnknown())
{
CheckDlgButton(hDlg, IDC_UNKOWN, BST_CHECKED);
}
} }
break; break;
case WM_NOTIFY: case WM_NOTIFY:
if (((NMHDR FAR *) lParam)->code != PSN_APPLY) { break; } if (((NMHDR FAR *)lParam)->code != PSN_APPLY)
{
break;
}
g_Settings->SaveBool(Logging_LogCP0changes, IsDlgButtonChecked(hDlg, IDC_CP0_WRITE) == BST_CHECKED ? true : false); g_Settings->SaveBool(Logging_LogCP0changes, IsDlgButtonChecked(hDlg, IDC_CP0_WRITE) == BST_CHECKED ? true : false);
g_Settings->SaveBool(Logging_LogCP0reads, IsDlgButtonChecked(hDlg, IDC_CP0_READ) == BST_CHECKED ? true : false); g_Settings->SaveBool(Logging_LogCP0reads, IsDlgButtonChecked(hDlg, IDC_CP0_READ) == BST_CHECKED ? true : false);
g_Settings->SaveBool(Logging_LogCache, IsDlgButtonChecked(hDlg, IDC_CACHE) == BST_CHECKED ? true : false); g_Settings->SaveBool(Logging_LogCache, IsDlgButtonChecked(hDlg, IDC_CACHE) == BST_CHECKED ? true : false);
@ -94,12 +121,30 @@ LRESULT CALLBACK LogPifProc(HWND hDlg, UINT uMsg, WPARAM /*wParam*/, LPARAM lPar
{ {
case WM_INITDIALOG: case WM_INITDIALOG:
{ {
if (CLogSettings::LogPRDMAOperations()) { CheckDlgButton(hDlg, IDC_SI_DMA, BST_CHECKED); } if (CLogSettings::LogPRDMAOperations())
if (CLogSettings::LogPRDirectMemLoads()) { CheckDlgButton(hDlg, IDC_DIRECT_WRITE, BST_CHECKED); } {
if (CLogSettings::LogPRDMAMemLoads()) { CheckDlgButton(hDlg, IDC_DMA_WRITE, BST_CHECKED); } CheckDlgButton(hDlg, IDC_SI_DMA, BST_CHECKED);
if (CLogSettings::LogPRDirectMemStores()) { CheckDlgButton(hDlg, IDC_DIRECT_READ, BST_CHECKED); } }
if (CLogSettings::LogPRDMAMemStores()) { CheckDlgButton(hDlg, IDC_DMA_READ, BST_CHECKED); } if (CLogSettings::LogPRDirectMemLoads())
if (CLogSettings::LogControllerPak()) { CheckDlgButton(hDlg, IDC_CONT_PAK, BST_CHECKED); } {
CheckDlgButton(hDlg, IDC_DIRECT_WRITE, BST_CHECKED);
}
if (CLogSettings::LogPRDMAMemLoads())
{
CheckDlgButton(hDlg, IDC_DMA_WRITE, BST_CHECKED);
}
if (CLogSettings::LogPRDirectMemStores())
{
CheckDlgButton(hDlg, IDC_DIRECT_READ, BST_CHECKED);
}
if (CLogSettings::LogPRDMAMemStores())
{
CheckDlgButton(hDlg, IDC_DMA_READ, BST_CHECKED);
}
if (CLogSettings::LogControllerPak())
{
CheckDlgButton(hDlg, IDC_CONT_PAK, BST_CHECKED);
}
} }
break; break;
case WM_NOTIFY: case WM_NOTIFY:
@ -126,16 +171,46 @@ LRESULT CALLBACK LogRegProc(HWND hDlg, UINT uMsg, WPARAM /*wParam*/, LPARAM lPar
{ {
case WM_INITDIALOG: case WM_INITDIALOG:
{ {
if (CLogSettings::LogRDRamRegisters()) { CheckDlgButton(hDlg, IDC_RDRAM, BST_CHECKED); } if (CLogSettings::LogRDRamRegisters())
if (CLogSettings::LogSPRegisters()) { CheckDlgButton(hDlg, IDC_SP_REG, BST_CHECKED); } {
if (CLogSettings::LogDPCRegisters()) { CheckDlgButton(hDlg, IDC_DPC_REG, BST_CHECKED); } CheckDlgButton(hDlg, IDC_RDRAM, BST_CHECKED);
if (CLogSettings::LogDPSRegisters()) { CheckDlgButton(hDlg, IDC_DPS_REG, BST_CHECKED); } }
if (CLogSettings::LogMIPSInterface()) { CheckDlgButton(hDlg, IDC_MI_REG, BST_CHECKED); } if (CLogSettings::LogSPRegisters())
if (CLogSettings::LogVideoInterface()) { CheckDlgButton(hDlg, IDC_VI_REG, BST_CHECKED); } {
if (CLogSettings::LogAudioInterface()) { CheckDlgButton(hDlg, IDC_AI_REG, BST_CHECKED); } CheckDlgButton(hDlg, IDC_SP_REG, BST_CHECKED);
if (CLogSettings::LogPerInterface()) { CheckDlgButton(hDlg, IDC_PI_REG, BST_CHECKED); } }
if (CLogSettings::LogRDRAMInterface()) { CheckDlgButton(hDlg, IDC_RI_REG, BST_CHECKED); } if (CLogSettings::LogDPCRegisters())
if (CLogSettings::LogSerialInterface()) { CheckDlgButton(hDlg, IDC_SI_REG, BST_CHECKED); } {
CheckDlgButton(hDlg, IDC_DPC_REG, BST_CHECKED);
}
if (CLogSettings::LogDPSRegisters())
{
CheckDlgButton(hDlg, IDC_DPS_REG, BST_CHECKED);
}
if (CLogSettings::LogMIPSInterface())
{
CheckDlgButton(hDlg, IDC_MI_REG, BST_CHECKED);
}
if (CLogSettings::LogVideoInterface())
{
CheckDlgButton(hDlg, IDC_VI_REG, BST_CHECKED);
}
if (CLogSettings::LogAudioInterface())
{
CheckDlgButton(hDlg, IDC_AI_REG, BST_CHECKED);
}
if (CLogSettings::LogPerInterface())
{
CheckDlgButton(hDlg, IDC_PI_REG, BST_CHECKED);
}
if (CLogSettings::LogRDRAMInterface())
{
CheckDlgButton(hDlg, IDC_RI_REG, BST_CHECKED);
}
if (CLogSettings::LogSerialInterface())
{
CheckDlgButton(hDlg, IDC_SI_REG, BST_CHECKED);
}
} }
break; break;
case WM_NOTIFY: case WM_NOTIFY:

2
Source/Project64/UserInterface/LoggingUI.h
View File

@ -1,3 +1,3 @@
#pragma once #pragma once
void EnterLogOptions ( HWND hwndOwner ); void EnterLogOptions(HWND hwndOwner);

142
Source/Project64/UserInterface/MainMenu.cpp
View File

@ -94,7 +94,10 @@ int CMainMenu::ProcessAccelerator(HWND hWnd, void * lpMsg)
m_ResetAccelerators = false; m_ResetAccelerators = false;
RebuildAccelerators(); RebuildAccelerators();
} }
if (!m_AccelTable) { return false; } if (!m_AccelTable)
{
return false;
}
return TranslateAccelerator((HWND)hWnd, (HACCEL)m_AccelTable, (LPMSG)lpMsg); return TranslateAccelerator((HWND)hWnd, (HACCEL)m_AccelTable, (LPMSG)lpMsg);
} }
@ -604,8 +607,7 @@ bool CMainMenu::ProcessMessage(HWND hWnd, DWORD /*FromAccelerator*/, DWORD MenuI
if (MenuID >= ID_RECENT_ROM_START && MenuID < ID_RECENT_ROM_END) if (MenuID >= ID_RECENT_ROM_START && MenuID < ID_RECENT_ROM_END)
{ {
stdstr FileName; stdstr FileName;
if (UISettingsLoadStringIndex(File_RecentGameFileIndex, MenuID - ID_RECENT_ROM_START, FileName) && if (UISettingsLoadStringIndex(File_RecentGameFileIndex, MenuID - ID_RECENT_ROM_START, FileName) && FileName.length() > 0)
FileName.length() > 0)
{ {
if ((CPath(FileName).GetExtension() != "ndd") && (CPath(FileName).GetExtension() != "d64")) if ((CPath(FileName).GetExtension() != "ndd") && (CPath(FileName).GetExtension() != "d64"))
g_BaseSystem->RunFileImage(FileName.c_str()); g_BaseSystem->RunFileImage(FileName.c_str());
@ -692,7 +694,10 @@ std::wstring CMainMenu::GetSaveSlotString(int Slot)
case 10: SlotName = GS(MENU_SLOT_10); break; case 10: SlotName = GS(MENU_SLOT_10); break;
} }
if (!g_Settings->LoadBool(GameRunning_CPU_Running)) { return SlotName.ToUTF16(); } if (!g_Settings->LoadBool(GameRunning_CPU_Running))
{
return SlotName.ToUTF16();
}
stdstr LastSaveTime; stdstr LastSaveTime;
@ -880,38 +885,71 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
MenuItemList CurrentSaveMenu; MenuItemList CurrentSaveMenu;
DWORD _CurrentSaveState = g_Settings->LoadDword(Game_CurrentSaveState); DWORD _CurrentSaveState = g_Settings->LoadDword(Game_CurrentSaveState);
Item.Reset(ID_CURRENT_SAVE_DEFAULT, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_DEFAULT, RunningState), nullptr, GetSaveSlotString(0)); Item.Reset(ID_CURRENT_SAVE_DEFAULT, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_DEFAULT, RunningState), nullptr, GetSaveSlotString(0));
if (_CurrentSaveState == 0) { Item.SetItemTicked(true); } if (_CurrentSaveState == 0)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
CurrentSaveMenu.push_back(MENU_ITEM(SPLITER)); CurrentSaveMenu.push_back(MENU_ITEM(SPLITER));
Item.Reset(ID_CURRENT_SAVE_1, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_1, RunningState), nullptr, GetSaveSlotString(1)); Item.Reset(ID_CURRENT_SAVE_1, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_1, RunningState), nullptr, GetSaveSlotString(1));
if (_CurrentSaveState == 1) { Item.SetItemTicked(true); } if (_CurrentSaveState == 1)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
Item.Reset(ID_CURRENT_SAVE_2, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_2, RunningState), nullptr, GetSaveSlotString(2)); Item.Reset(ID_CURRENT_SAVE_2, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_2, RunningState), nullptr, GetSaveSlotString(2));
if (_CurrentSaveState == 2) { Item.SetItemTicked(true); } if (_CurrentSaveState == 2)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
Item.Reset(ID_CURRENT_SAVE_3, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_3, RunningState), nullptr, GetSaveSlotString(3)); Item.Reset(ID_CURRENT_SAVE_3, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_3, RunningState), nullptr, GetSaveSlotString(3));
if (_CurrentSaveState == 3) { Item.SetItemTicked(true); } if (_CurrentSaveState == 3)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
Item.Reset(ID_CURRENT_SAVE_4, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_4, RunningState), nullptr, GetSaveSlotString(4)); Item.Reset(ID_CURRENT_SAVE_4, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_4, RunningState), nullptr, GetSaveSlotString(4));
if (_CurrentSaveState == 4) { Item.SetItemTicked(true); } if (_CurrentSaveState == 4)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
Item.Reset(ID_CURRENT_SAVE_5, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_5, RunningState), nullptr, GetSaveSlotString(5)); Item.Reset(ID_CURRENT_SAVE_5, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_5, RunningState), nullptr, GetSaveSlotString(5));
if (_CurrentSaveState == 5) { Item.SetItemTicked(true); } if (_CurrentSaveState == 5)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
Item.Reset(ID_CURRENT_SAVE_6, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_6, RunningState), nullptr, GetSaveSlotString(6)); Item.Reset(ID_CURRENT_SAVE_6, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_6, RunningState), nullptr, GetSaveSlotString(6));
if (_CurrentSaveState == 6) { Item.SetItemTicked(true); } if (_CurrentSaveState == 6)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
Item.Reset(ID_CURRENT_SAVE_7, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_7, RunningState), nullptr, GetSaveSlotString(7)); Item.Reset(ID_CURRENT_SAVE_7, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_7, RunningState), nullptr, GetSaveSlotString(7));
if (_CurrentSaveState == 7) { Item.SetItemTicked(true); } if (_CurrentSaveState == 7)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
Item.Reset(ID_CURRENT_SAVE_8, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_8, RunningState), nullptr, GetSaveSlotString(8)); Item.Reset(ID_CURRENT_SAVE_8, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_8, RunningState), nullptr, GetSaveSlotString(8));
if (_CurrentSaveState == 8) { Item.SetItemTicked(true); } if (_CurrentSaveState == 8)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
Item.Reset(ID_CURRENT_SAVE_9, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_9, RunningState), nullptr, GetSaveSlotString(9)); Item.Reset(ID_CURRENT_SAVE_9, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_9, RunningState), nullptr, GetSaveSlotString(9));
if (_CurrentSaveState == 9) { Item.SetItemTicked(true); } if (_CurrentSaveState == 9)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
Item.Reset(ID_CURRENT_SAVE_10, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_10, RunningState), nullptr, GetSaveSlotString(10)); Item.Reset(ID_CURRENT_SAVE_10, EMPTY_STRING, m_ShortCuts.ShortCutString(ID_CURRENT_SAVE_10, RunningState), nullptr, GetSaveSlotString(10));
if (_CurrentSaveState == 10) { Item.SetItemTicked(true); } if (_CurrentSaveState == 10)
{
Item.SetItemTicked(true);
}
CurrentSaveMenu.push_back(Item); CurrentSaveMenu.push_back(Item);
// System menu // System menu
@ -940,12 +978,18 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
if (!inBasicMode) if (!inBasicMode)
{ {
Item.Reset(ID_SYSTEM_LIMITFPS, MENU_LIMIT_FPS, m_ShortCuts.ShortCutString(ID_SYSTEM_LIMITFPS, RunningState)); Item.Reset(ID_SYSTEM_LIMITFPS, MENU_LIMIT_FPS, m_ShortCuts.ShortCutString(ID_SYSTEM_LIMITFPS, RunningState));
if (g_Settings->LoadBool(GameRunning_LimitFPS)) { Item.SetItemTicked(true); } if (g_Settings->LoadBool(GameRunning_LimitFPS))
{
Item.SetItemTicked(true);
}
SystemMenu.push_back(Item); SystemMenu.push_back(Item);
SystemMenu.push_back(MENU_ITEM(SPLITER)); SystemMenu.push_back(MENU_ITEM(SPLITER));
} }
Item.Reset(ID_SYSTEM_SWAPDISK, MENU_SWAPDISK, m_ShortCuts.ShortCutString(ID_SYSTEM_SWAPDISK, RunningState)); Item.Reset(ID_SYSTEM_SWAPDISK, MENU_SWAPDISK, m_ShortCuts.ShortCutString(ID_SYSTEM_SWAPDISK, RunningState));
if (g_Disk == nullptr) { Item.SetItemEnabled(false); } if (g_Disk == nullptr)
{
Item.SetItemEnabled(false);
}
SystemMenu.push_back(Item); SystemMenu.push_back(Item);
SystemMenu.push_back(MENU_ITEM(SPLITER)); SystemMenu.push_back(MENU_ITEM(SPLITER));
SystemMenu.push_back(MENU_ITEM(ID_SYSTEM_SAVE, MENU_SAVE, m_ShortCuts.ShortCutString(ID_SYSTEM_SAVE, RunningState))); SystemMenu.push_back(MENU_ITEM(ID_SYSTEM_SAVE, MENU_SAVE, m_ShortCuts.ShortCutString(ID_SYSTEM_SAVE, RunningState)));
@ -980,7 +1024,10 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
if (!inBasicMode) if (!inBasicMode)
{ {
Item.Reset(ID_OPTIONS_ALWAYSONTOP, MENU_ON_TOP, m_ShortCuts.ShortCutString(ID_OPTIONS_ALWAYSONTOP, RunningState)); Item.Reset(ID_OPTIONS_ALWAYSONTOP, MENU_ON_TOP, m_ShortCuts.ShortCutString(ID_OPTIONS_ALWAYSONTOP, RunningState));
if (UISettingsLoadDword(UserInterface_AlwaysOnTop)) { Item.SetItemTicked(true); } if (UISettingsLoadDword(UserInterface_AlwaysOnTop))
{
Item.SetItemTicked(true);
}
Item.SetItemEnabled(CPURunning); Item.SetItemEnabled(CPURunning);
OptionMenu.push_back(Item); OptionMenu.push_back(Item);
} }
@ -1018,7 +1065,10 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
if (!inBasicMode) if (!inBasicMode)
{ {
Item.Reset(ID_OPTIONS_CPU_USAGE, MENU_SHOW_CPU, m_ShortCuts.ShortCutString(ID_OPTIONS_CPU_USAGE, RunningState)); Item.Reset(ID_OPTIONS_CPU_USAGE, MENU_SHOW_CPU, m_ShortCuts.ShortCutString(ID_OPTIONS_CPU_USAGE, RunningState));
if (g_Settings->LoadDword(UserInterface_ShowCPUPer)) { Item.SetItemTicked(true); } if (g_Settings->LoadDword(UserInterface_ShowCPUPer))
{
Item.SetItemTicked(true);
}
OptionMenu.push_back(Item); OptionMenu.push_back(Item);
} }
OptionMenu.push_back(MENU_ITEM(ID_OPTIONS_SETTINGS, MENU_SETTINGS, m_ShortCuts.ShortCutString(ID_OPTIONS_SETTINGS, RunningState))); OptionMenu.push_back(MENU_ITEM(ID_OPTIONS_SETTINGS, MENU_SETTINGS, m_ShortCuts.ShortCutString(ID_OPTIONS_SETTINGS, RunningState)));
@ -1028,13 +1078,22 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
if (HaveDebugger()) if (HaveDebugger())
{ {
Item.Reset(ID_PROFILE_PROFILE, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Record Execution Times"); Item.Reset(ID_PROFILE_PROFILE, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Record Execution Times");
if (g_Settings->LoadBool(Debugger_RecordExecutionTimes)) { Item.SetItemTicked(true); } if (g_Settings->LoadBool(Debugger_RecordExecutionTimes))
{
Item.SetItemTicked(true);
}
DebugProfileMenu.push_back(Item); DebugProfileMenu.push_back(Item);
Item.Reset(ID_PROFILE_RESETCOUNTER, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Reset Counters"); Item.Reset(ID_PROFILE_RESETCOUNTER, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Reset Counters");
if (!CPURunning) { Item.SetItemEnabled(false); } if (!CPURunning)
{
Item.SetItemEnabled(false);
}
DebugProfileMenu.push_back(Item); DebugProfileMenu.push_back(Item);
Item.Reset(ID_PROFILE_GENERATELOG, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Generate Log File"); Item.Reset(ID_PROFILE_GENERATELOG, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Generate Log File");
if (!CPURunning) { Item.SetItemEnabled(false); } if (!CPURunning)
{
Item.SetItemEnabled(false);
}
DebugProfileMenu.push_back(Item); DebugProfileMenu.push_back(Item);
} }
@ -1156,7 +1215,7 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
DebugAppLoggingMenu.push_back(Item); DebugAppLoggingMenu.push_back(Item);
Item.Reset(ID_DEBUGGER_TRACE_PLUGINS, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Plugins"); Item.Reset(ID_DEBUGGER_TRACE_PLUGINS, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Plugins");
Item.SetItemTicked(g_Settings->LoadDword(Debugger_TracePlugins) == TraceVerbose);; Item.SetItemTicked(g_Settings->LoadDword(Debugger_TracePlugins) == TraceVerbose);
DebugAppLoggingMenu.push_back(Item); DebugAppLoggingMenu.push_back(Item);
Item.Reset(ID_DEBUGGER_TRACE_GFXPLUGIN, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"GFX plugin"); Item.Reset(ID_DEBUGGER_TRACE_GFXPLUGIN, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"GFX plugin");
@ -1172,7 +1231,7 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
DebugAppLoggingMenu.push_back(Item); DebugAppLoggingMenu.push_back(Item);
Item.Reset(ID_DEBUGGER_TRACE_RSPPLUGIN, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"RSP plugin"); Item.Reset(ID_DEBUGGER_TRACE_RSPPLUGIN, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"RSP plugin");
Item.SetItemTicked(g_Settings->LoadDword(Debugger_TraceRSPPlugin) == TraceVerbose);; Item.SetItemTicked(g_Settings->LoadDword(Debugger_TraceRSPPlugin) == TraceVerbose);
DebugAppLoggingMenu.push_back(Item); DebugAppLoggingMenu.push_back(Item);
Item.Reset(ID_DEBUGGER_TRACE_RSP, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"RSP"); Item.Reset(ID_DEBUGGER_TRACE_RSP, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"RSP");
@ -1206,7 +1265,10 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
DebugAppLoggingMenu.push_back(MENU_ITEM(SPLITER)); DebugAppLoggingMenu.push_back(MENU_ITEM(SPLITER));
Item.Reset(ID_DEBUGGER_APPLOG_FLUSH, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Auto flush file"); Item.Reset(ID_DEBUGGER_APPLOG_FLUSH, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Auto flush file");
if (g_Settings->LoadBool(Debugger_AppLogFlush)) { Item.SetItemTicked(true); } if (g_Settings->LoadBool(Debugger_AppLogFlush))
{
Item.SetItemTicked(true);
}
DebugAppLoggingMenu.push_back(Item); DebugAppLoggingMenu.push_back(Item);
// Debug - logging // Debug - logging
@ -1214,7 +1276,10 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
DebugLoggingMenu.push_back(Item); DebugLoggingMenu.push_back(Item);
Item.Reset(ID_DEBUGGER_GENERATELOG, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Generate log"); Item.Reset(ID_DEBUGGER_GENERATELOG, EMPTY_STRING, EMPTY_STDSTR, nullptr, L"Generate log");
if (g_Settings->LoadBool(Logging_GenerateLog)) { Item.SetItemTicked(true); } if (g_Settings->LoadBool(Logging_GenerateLog))
{
Item.SetItemTicked(true);
}
DebugLoggingMenu.push_back(Item); DebugLoggingMenu.push_back(Item);
// Debugger main menu // Debugger main menu
@ -1305,28 +1370,43 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
// Main title bar Menu // Main title bar Menu
MenuItemList MainTitleMenu; MenuItemList MainTitleMenu;
Item.Reset(SUB_MENU, MENU_FILE, EMPTY_STDSTR, &FileMenu); Item.Reset(SUB_MENU, MENU_FILE, EMPTY_STDSTR, &FileMenu);
if (RomLoading) { Item.SetItemEnabled(false); } if (RomLoading)
{
Item.SetItemEnabled(false);
}
MainTitleMenu.push_back(Item); MainTitleMenu.push_back(Item);
if (CPURunning) if (CPURunning)
{ {
Item.Reset(SUB_MENU, MENU_SYSTEM, EMPTY_STDSTR, &SystemMenu); Item.Reset(SUB_MENU, MENU_SYSTEM, EMPTY_STDSTR, &SystemMenu);
if (RomLoading) { Item.SetItemEnabled(false); } if (RomLoading)
{
Item.SetItemEnabled(false);
}
MainTitleMenu.push_back(Item); MainTitleMenu.push_back(Item);
} }
Item.Reset(SUB_MENU, MENU_OPTIONS, EMPTY_STDSTR, &OptionMenu); Item.Reset(SUB_MENU, MENU_OPTIONS, EMPTY_STDSTR, &OptionMenu);
if (RomLoading) { Item.SetItemEnabled(false); } if (RomLoading)
{
Item.SetItemEnabled(false);
}
MainTitleMenu.push_back(Item); MainTitleMenu.push_back(Item);
if (!inBasicMode) if (!inBasicMode)
{ {
if (HaveDebugger()) if (HaveDebugger())
{ {
Item.Reset(SUB_MENU, MENU_DEBUGGER, EMPTY_STDSTR, &DebugMenu); Item.Reset(SUB_MENU, MENU_DEBUGGER, EMPTY_STDSTR, &DebugMenu);
if (RomLoading) { Item.SetItemEnabled(false); } if (RomLoading)
{
Item.SetItemEnabled(false);
}
MainTitleMenu.push_back(Item); MainTitleMenu.push_back(Item);
} }
} }
Item.Reset(SUB_MENU, MENU_HELP, EMPTY_STDSTR, &HelpMenu); Item.Reset(SUB_MENU, MENU_HELP, EMPTY_STDSTR, &HelpMenu);
if (RomLoading) { Item.SetItemEnabled(false); } if (RomLoading)
{
Item.SetItemEnabled(false);
}
MainTitleMenu.push_back(Item); MainTitleMenu.push_back(Item);
if (UISettingsLoadBool(UserInterface_ShowingNagWindow)) if (UISettingsLoadBool(UserInterface_ShowingNagWindow))

154
Source/Project64/UserInterface/MainMenu.h
View File

@ -1,62 +1,144 @@
#pragma once #pragma once
#include <Project64-core/Settings/DebugSettings.h>
#include <Project64/Settings/UISettings.h> #include <Project64/Settings/UISettings.h>
#include <Project64/UserInterface/MenuItem.h>
#include <Project64/UserInterface/MenuShortCuts.h>
enum MainMenuID enum MainMenuID
{ {
// File menu // File menu
ID_FILE_OPEN_ROM = 4000, ID_FILE_OPEN_COMBO, ID_FILE_ROM_INFO, ID_FILE_STARTEMULATION, ID_FILE_ENDEMULATION, ID_FILE_OPEN_ROM = 4000,
ID_FILE_ROMDIRECTORY, ID_FILE_REFRESHROMLIST, ID_FILE_EXIT, ID_FILE_OPEN_COMBO,
ID_FILE_ROM_INFO,
ID_FILE_STARTEMULATION,
ID_FILE_ENDEMULATION,
ID_FILE_ROMDIRECTORY,
ID_FILE_REFRESHROMLIST,
ID_FILE_EXIT,
// Language // Language
ID_LANG_START, ID_LANG_END = ID_LANG_START + 100, ID_LANG_START,
ID_LANG_END = ID_LANG_START + 100,
// Recent files // Recent files
ID_RECENT_ROM_START, ID_RECENT_ROM_END = ID_RECENT_ROM_START + 20, ID_RECENT_ROM_START,
ID_RECENT_ROM_END = ID_RECENT_ROM_START + 20,
// Recent directory // Recent directory
ID_RECENT_DIR_START, ID_RECENT_DIR_END = ID_RECENT_DIR_START + 20, ID_RECENT_DIR_START,
ID_RECENT_DIR_END = ID_RECENT_DIR_START + 20,
// System menu // System menu
ID_SYSTEM_RESET_SOFT, ID_SYSTEM_RESET_HARD, ID_SYSTEM_PAUSE, ID_SYSTEM_BITMAP, ID_SYSTEM_RESET_SOFT,
ID_SYSTEM_LIMITFPS, ID_SYSTEM_SWAPDISK, ID_SYSTEM_RESTORE, ID_SYSTEM_LOAD, ID_SYSTEM_SAVE, ID_SYSTEM_RESET_HARD,
ID_SYSTEM_SAVEAS, ID_SYSTEM_ENHANCEMENT, ID_SYSTEM_CHEAT, ID_SYSTEM_GSBUTTON, ID_SYSTEM_PAUSE,
ID_SYSTEM_BITMAP,
ID_SYSTEM_LIMITFPS,
ID_SYSTEM_SWAPDISK,
ID_SYSTEM_RESTORE,
ID_SYSTEM_LOAD,
ID_SYSTEM_SAVE,
ID_SYSTEM_SAVEAS,
ID_SYSTEM_ENHANCEMENT,
ID_SYSTEM_CHEAT,
ID_SYSTEM_GSBUTTON,
//Current save slot //Current save slot
ID_CURRENT_SAVE_1, ID_CURRENT_SAVE_2, ID_CURRENT_SAVE_3, ID_CURRENT_SAVE_4, ID_CURRENT_SAVE_5, ID_CURRENT_SAVE_1,
ID_CURRENT_SAVE_6, ID_CURRENT_SAVE_7, ID_CURRENT_SAVE_8, ID_CURRENT_SAVE_9, ID_CURRENT_SAVE_10, ID_CURRENT_SAVE_2,
ID_CURRENT_SAVE_3,
ID_CURRENT_SAVE_4,
ID_CURRENT_SAVE_5,
ID_CURRENT_SAVE_6,
ID_CURRENT_SAVE_7,
ID_CURRENT_SAVE_8,
ID_CURRENT_SAVE_9,
ID_CURRENT_SAVE_10,
ID_CURRENT_SAVE_DEFAULT, ID_CURRENT_SAVE_DEFAULT,
// Option menu // Option menu
ID_OPTIONS_FULLSCREEN, ID_OPTIONS_FULLSCREEN2, ID_OPTIONS_ALWAYSONTOP, ID_OPTIONS_CONFIG_GFX, ID_OPTIONS_FULLSCREEN,
ID_OPTIONS_CONFIG_AUDIO, ID_OPTIONS_CONFIG_CONT, ID_OPTIONS_CONFIG_RSP, ID_OPTIONS_CPU_USAGE, ID_OPTIONS_FULLSCREEN2,
ID_OPTIONS_SETTINGS, ID_OPTIONS_DISPLAY_FR, ID_OPTIONS_CHANGE_FR, ID_OPTIONS_INCREASE_SPEED, ID_OPTIONS_ALWAYSONTOP,
ID_OPTIONS_CONFIG_GFX,
ID_OPTIONS_CONFIG_AUDIO,
ID_OPTIONS_CONFIG_CONT,
ID_OPTIONS_CONFIG_RSP,
ID_OPTIONS_CPU_USAGE,
ID_OPTIONS_SETTINGS,
ID_OPTIONS_DISPLAY_FR,
ID_OPTIONS_CHANGE_FR,
ID_OPTIONS_INCREASE_SPEED,
ID_OPTIONS_DECREASE_SPEED, ID_OPTIONS_DECREASE_SPEED,
// Debugger menu // Debugger menu
ID_DEBUG_END_ON_PERM_LOOP, ID_DEBUG_STEP_ON_BREAK_OPCODE, ID_DEBUG_END_ON_PERM_LOOP,
ID_DEBUG_BREAK_ON_UNHANDLED_MEM, ID_DEBUG_BREAK_ON_ADDRESS_ERROR, ID_DEBUG_SHOW_PIF_ERRORS, ID_DEBUG_STEP_ON_BREAK_OPCODE,
ID_DEBUG_SHOW_DLIST_COUNT, ID_DEBUG_SHOW_RECOMP_MEM_SIZE, ID_DEBUG_BREAK_ON_UNHANDLED_MEM,
ID_DEBUG_RECORD_RECOMPILER_ASM, ID_DEBUG_DISABLE_GAMEFIX, ID_DEBUG_LANGUAGE, ID_DEBUG_BREAK_ON_ADDRESS_ERROR,
ID_DEBUGGER_LOGOPTIONS, ID_DEBUGGER_GENERATELOG, ID_DEBUGGER_DUMPMEMORY, ID_DEBUGGER_SEARCHMEMORY, ID_DEBUG_SHOW_PIF_ERRORS,
ID_DEBUGGER_TLBENTRIES, ID_DEBUGGER_BREAKPOINTS, ID_DEBUGGER_MEMORY, ID_DEBUGGER_R4300REGISTERS, ID_DEBUG_SHOW_DLIST_COUNT,
ID_DEBUGGER_INTERRUPT_SP, ID_DEBUGGER_INTERRUPT_SI, ID_DEBUGGER_INTERRUPT_AI, ID_DEBUGGER_INTERRUPT_VI, ID_DEBUG_SHOW_RECOMP_MEM_SIZE,
ID_DEBUGGER_INTERRUPT_PI, ID_DEBUGGER_INTERRUPT_DP, ID_DEBUGGER_SCRIPTS, ID_DEBUGGER_SYMBOLS, ID_DEBUGGER_DMALOG, ID_DEBUG_RECORD_RECOMPILER_ASM,
ID_DEBUGGER_EXCBREAKPOINTS, ID_DEBUGGER_CPULOG, ID_DEBUGGER_STACKTRACE, ID_DEBUGGER_STACKVIEW, ID_DEBUG_DISABLE_GAMEFIX,
ID_DEBUG_LANGUAGE,
ID_DEBUGGER_LOGOPTIONS,
ID_DEBUGGER_GENERATELOG,
ID_DEBUGGER_DUMPMEMORY,
ID_DEBUGGER_SEARCHMEMORY,
ID_DEBUGGER_TLBENTRIES,
ID_DEBUGGER_BREAKPOINTS,
ID_DEBUGGER_MEMORY,
ID_DEBUGGER_R4300REGISTERS,
ID_DEBUGGER_INTERRUPT_SP,
ID_DEBUGGER_INTERRUPT_SI,
ID_DEBUGGER_INTERRUPT_AI,
ID_DEBUGGER_INTERRUPT_VI,
ID_DEBUGGER_INTERRUPT_PI,
ID_DEBUGGER_INTERRUPT_DP,
ID_DEBUGGER_SCRIPTS,
ID_DEBUGGER_SYMBOLS,
ID_DEBUGGER_DMALOG,
ID_DEBUGGER_EXCBREAKPOINTS,
ID_DEBUGGER_CPULOG,
ID_DEBUGGER_STACKTRACE,
ID_DEBUGGER_STACKVIEW,
// App logging // App logging
ID_DEBUGGER_APPLOG_FLUSH, ID_DEBUGGER_TRACE_MD5, ID_DEBUGGER_TRACE_SETTINGS, ID_DEBUGGER_TRACE_UNKNOWN, ID_DEBUGGER_TRACE_APPINIT, ID_DEBUGGER_APPLOG_FLUSH,
ID_DEBUGGER_TRACE_APPCLEANUP, ID_DEBUGGER_TRACE_N64SYSTEM, ID_DEBUGGER_TRACE_PLUGINS, ID_DEBUGGER_TRACE_GFXPLUGIN, ID_DEBUGGER_TRACE_MD5,
ID_DEBUGGER_TRACE_AUDIOPLUGIN, ID_DEBUGGER_TRACE_CONTROLLERPLUGIN, ID_DEBUGGER_TRACE_RSPPLUGIN, ID_DEBUGGER_TRACE_RSP, ID_DEBUGGER_TRACE_SETTINGS,
ID_DEBUGGER_TRACE_AUDIO, ID_DEBUGGER_TRACE_REGISTERCACHE, ID_DEBUGGER_TRACE_RECOMPILER, ID_DEBUGGER_TRACE_TLB, ID_DEBUGGER_TRACE_UNKNOWN,
ID_DEBUGGER_TRACE_PROTECTEDMEM, ID_DEBUGGER_TRACE_USERINTERFACE, ID_DEBUGGER_TRACE_APPINIT,
ID_DEBUGGER_TRACE_APPCLEANUP,
ID_DEBUGGER_TRACE_N64SYSTEM,
ID_DEBUGGER_TRACE_PLUGINS,
ID_DEBUGGER_TRACE_GFXPLUGIN,
ID_DEBUGGER_TRACE_AUDIOPLUGIN,
ID_DEBUGGER_TRACE_CONTROLLERPLUGIN,
ID_DEBUGGER_TRACE_RSPPLUGIN,
ID_DEBUGGER_TRACE_RSP,
ID_DEBUGGER_TRACE_AUDIO,
ID_DEBUGGER_TRACE_REGISTERCACHE,
ID_DEBUGGER_TRACE_RECOMPILER,
ID_DEBUGGER_TRACE_TLB,
ID_DEBUGGER_TRACE_PROTECTEDMEM,
ID_DEBUGGER_TRACE_USERINTERFACE,
// Profile menu // Profile menu
ID_PROFILE_PROFILE, ID_PROFILE_RESETCOUNTER, ID_PROFILE_GENERATELOG, ID_PROFILE_PROFILE,
ID_PROFILE_RESETCOUNTER,
ID_PROFILE_GENERATELOG,
// Help menu // Help menu
ID_HELP_SUPPORT_PROJECT64, ID_HELP_DISCORD, ID_HELP_WEBSITE, ID_HELP_ABOUT, ID_HELP_SUPPORT_PROJECT64,
ID_HELP_DISCORD,
ID_HELP_WEBSITE,
ID_HELP_ABOUT,
}; };
class CMainGui;
class CMainMenu : class CMainMenu :
public CBaseMenu, public CBaseMenu,
private CDebugSettings private CDebugSettings
@ -68,12 +150,15 @@ public:
int ProcessAccelerator(HWND hWnd, void * lpMsg); int ProcessAccelerator(HWND hWnd, void * lpMsg);
bool ProcessMessage(HWND hWnd, DWORD wNotifyCode, DWORD wID); bool ProcessMessage(HWND hWnd, DWORD wNotifyCode, DWORD wID);
void ResetMenu(void); void ResetMenu(void);
void ResetAccelerators(void) { m_ResetAccelerators = true; } void ResetAccelerators(void)
{
m_ResetAccelerators = true;
}
private: private:
CMainMenu(); CMainMenu();
CMainMenu(const CMainMenu&); CMainMenu(const CMainMenu &);
CMainMenu& operator=(const CMainMenu&); CMainMenu & operator=(const CMainMenu &);
void OnOpenRom(HWND hWnd); void OnOpenRom(HWND hWnd);
void OnOpenCombo(HWND hWnd); void OnOpenCombo(HWND hWnd);
@ -98,7 +183,10 @@ private:
void ShortCutsChanged(void); void ShortCutsChanged(void);
static void SettingsChanged(CMainMenu * _this); static void SettingsChanged(CMainMenu * _this);
static void stShortCutsChanged(CMainMenu * _this) { return _this->ShortCutsChanged(); } static void stShortCutsChanged(CMainMenu * _this)
{
return _this->ShortCutsChanged();
}
typedef std::list<SettingID> SettingList; typedef std::list<SettingID> SettingList;
typedef std::list<UISettingID> UISettingList; typedef std::list<UISettingID> UISettingList;

68
Source/Project64/UserInterface/MainWindow.cpp
View File

@ -113,7 +113,10 @@ bool CMainGui::RegisterWinClass(void)
void CMainGui::AddRecentRom(const char * ImagePath) void CMainGui::AddRecentRom(const char * ImagePath)
{ {
if (HIWORD(ImagePath) == NULL) { return; } if (HIWORD(ImagePath) == NULL)
{
return;
}
// Get information about the stored ROM list // Get information about the stored ROM list
size_t MaxRememberedFiles = UISettingsLoadDword(File_RecentGameFileCount); size_t MaxRememberedFiles = UISettingsLoadDword(File_RecentGameFileCount);
@ -413,12 +416,14 @@ WPARAM CMainGui::ProcessAllMessages(void)
SetEvent(m_ResetInfo->hEvent); SetEvent(m_ResetInfo->hEvent);
m_ResetInfo = nullptr; m_ResetInfo = nullptr;
} }
if ((m_CheatsUI.m_hWnd != nullptr && IsDialogMessage(m_CheatsUI.m_hWnd, &msg)) || if ((m_CheatsUI.m_hWnd != nullptr && IsDialogMessage(m_CheatsUI.m_hWnd, &msg)) || (m_EnhancementUI.m_hWnd != nullptr && IsDialogMessage(m_EnhancementUI.m_hWnd, &msg)))
(m_EnhancementUI.m_hWnd != nullptr && IsDialogMessage(m_EnhancementUI.m_hWnd, &msg))) {
continue;
}
if (m_Menu->ProcessAccelerator(m_hMainWindow, &msg))
{ {
continue; continue;
} }
if (m_Menu->ProcessAccelerator(m_hMainWindow, &msg)) { continue; }
TranslateMessage(&msg); TranslateMessage(&msg);
DispatchMessage(&msg); DispatchMessage(&msg);
} }
@ -440,7 +445,10 @@ bool CMainGui::ProcessGuiMessages(void)
return true; return true;
} }
PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE); PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE);
if (m_Menu->ProcessAccelerator(m_hMainWindow, &msg)) { continue; } if (m_Menu->ProcessAccelerator(m_hMainWindow, &msg))
{
continue;
}
TranslateMessage(&msg); TranslateMessage(&msg);
DispatchMessage(&msg); DispatchMessage(&msg);
} }
@ -485,7 +493,10 @@ void CMainGui::EnterLogOptions(void)
int CMainGui::Height(void) int CMainGui::Height(void)
{ {
if (!m_hMainWindow) { return 0; } if (!m_hMainWindow)
{
return 0;
}
RECT rect; RECT rect;
GetWindowRect(m_hMainWindow, &rect); GetWindowRect(m_hMainWindow, &rect);
@ -494,7 +505,10 @@ int CMainGui::Height(void)
int CMainGui::Width(void) int CMainGui::Width(void)
{ {
if (!m_hMainWindow) { return 0; } if (!m_hMainWindow)
{
return 0;
}
RECT rect; RECT rect;
GetWindowRect(m_hMainWindow, &rect); GetWindowRect(m_hMainWindow, &rect);
@ -532,7 +546,10 @@ void CMainGui::SetWindowMenu(CBaseMenu * Menu)
void CMainGui::RefreshMenu(void) void CMainGui::RefreshMenu(void)
{ {
if (!m_Menu) { return; } if (!m_Menu)
{
return;
}
m_Menu->ResetMenu(); m_Menu->ResetMenu();
} }
@ -622,10 +639,7 @@ LRESULT CALLBACK CMainGui::MainGui_Proc(HWND hWnd, DWORD uMsg, DWORD wParam, DWO
case SC_MONITORPOWER: case SC_MONITORPOWER:
{ {
CMainGui * _this = (CMainGui *)GetProp(hWnd, L"Class"); CMainGui * _this = (CMainGui *)GetProp(hWnd, L"Class");
if (_this && if (_this && _this->bCPURunning() && !g_Settings->LoadBool(GameRunning_CPU_Paused) && UISettingsLoadBool(Setting_DisableScrSaver))
_this->bCPURunning() &&
!g_Settings->LoadBool(GameRunning_CPU_Paused) &&
UISettingsLoadBool(Setting_DisableScrSaver))
{ {
return 0; return 0;
} }
@ -650,12 +664,7 @@ LRESULT CALLBACK CMainGui::MainGui_Proc(HWND hWnd, DWORD uMsg, DWORD wParam, DWO
{ {
CMainGui * _this = (CMainGui *)GetProp(hWnd, L"Class"); CMainGui * _this = (CMainGui *)GetProp(hWnd, L"Class");
if (!_this->m_bMainWindow || if (!_this->m_bMainWindow || !_this->m_Created || _this->m_AttachingMenu || _this->m_MakingVisible || IsIconic(hWnd) || _this->ShowingRomBrowser())
!_this->m_Created ||
_this->m_AttachingMenu ||
_this->m_MakingVisible ||
IsIconic(hWnd) ||
_this->ShowingRomBrowser())
{ {
break; break;
} }
@ -711,7 +720,10 @@ LRESULT CALLBACK CMainGui::MainGui_Proc(HWND hWnd, DWORD uMsg, DWORD wParam, DWO
case WM_SIZE: case WM_SIZE:
{ {
CMainGui * _this = (CMainGui *)GetProp(hWnd, L"Class"); CMainGui * _this = (CMainGui *)GetProp(hWnd, L"Class");
if (_this) { _this->Resize(wParam, LOWORD(lParam), HIWORD(lParam)); } if (_this)
{
_this->Resize(wParam, LOWORD(lParam), HIWORD(lParam));
}
if (_this) if (_this)
{ {
if (wParam == SIZE_MAXIMIZED) if (wParam == SIZE_MAXIMIZED)
@ -875,11 +887,17 @@ LRESULT CALLBACK CMainGui::MainGui_Proc(HWND hWnd, DWORD uMsg, DWORD wParam, DWO
case WM_HIDE_CUROSR: case WM_HIDE_CUROSR:
if (!wParam) if (!wParam)
{ {
while (ShowCursor(FALSE) >= 0) { Sleep(0); } while (ShowCursor(FALSE) >= 0)
{
Sleep(0);
}
} }
else else
{ {
while (ShowCursor(TRUE) < 0) { Sleep(0); } while (ShowCursor(TRUE) < 0)
{
Sleep(0);
}
} }
break; break;
case WM_MAKE_FOCUS: case WM_MAKE_FOCUS:
@ -927,8 +945,7 @@ LRESULT CALLBACK CMainGui::MainGui_Proc(HWND hWnd, DWORD uMsg, DWORD wParam, DWO
{ {
char * romPath = (char *)lParam; char * romPath = (char *)lParam;
stdstr ext = CPath(romPath).GetExtension(); stdstr ext = CPath(romPath).GetExtension();
if ((_stricmp(ext.c_str(), "ndd") != 0) && if ((_stricmp(ext.c_str(), "ndd") != 0) && (_stricmp(ext.c_str(), "d64") != 0))
(_stricmp(ext.c_str(), "d64") != 0))
{ {
g_BaseSystem->RunFileImage(romPath); g_BaseSystem->RunFileImage(romPath);
} }
@ -1006,7 +1023,10 @@ LRESULT CALLBACK CMainGui::MainGui_Proc(HWND hWnd, DWORD uMsg, DWORD wParam, DWO
case WM_COMMAND: case WM_COMMAND:
{ {
CMainGui * _this = (CMainGui *)GetProp(hWnd, L"Class"); CMainGui * _this = (CMainGui *)GetProp(hWnd, L"Class");
if (_this == nullptr) { break; } if (_this == nullptr)
{
break;
}
switch (LOWORD(wParam)) switch (LOWORD(wParam))
{ {

Some files were not shown because too many files have changed in this diff Show More