void CtrlDisplayListView::onMouseDown(WPARAM wParam, LPARAM lParam, int button)
{
int x = LOWORD(lParam);
int y = HIWORD(lParam);
int line = y/rowHeight;
u32 newAddress = windowStart + line*instructionSize;
bool extend = KeyDownAsync(VK_SHIFT);
if (button == 1)
{
if (newAddress == curAddress && hasFocus)
{
toggleBreakpoint();
}
} else if (button == 2)
{
// Maintain the current selection if right clicking into it.
if (newAddress >= selectRangeStart && newAddress < selectRangeEnd)
extend = true;
}
setCurAddress(newAddress,extend);
SetFocus(wnd);
redraw();
}
void CtrlDisAsmView::onMouseDown(WPARAM wParam, LPARAM lParam, int button)
{
dontRedraw = false;
int x = LOWORD(lParam);
int y = HIWORD(lParam);
u32 newAddress = yToAddress(y);
bool extend = KeyDownAsync(VK_SHIFT);
if (button == 1)
{
if (newAddress == curAddress && hasFocus)
{
toggleBreakpoint();
}
}
else if (button == 2)
{
// Maintain the current selection if right clicking into it.
if (newAddress >= selectRangeStart && newAddress < selectRangeEnd)
extend = true;
}
setCurAddress(newAddress, extend);
SetFocus(wnd);
redraw();
}
void CtrlDisAsmView::onMouseMove(WPARAM wParam, LPARAM lParam, int button)
{
if ((button & 1) != 0)
{
int x = LOWORD(lParam);
int y = HIWORD(lParam);
setCurAddress(yToAddress(y), KeyDownAsync(VK_SHIFT));
// TODO: Perhaps don't do this every time, but on a timer?
redraw();
}
}
void CtrlMemView::onKeyDown(WPARAM wParam, LPARAM lParam)
{
if (KeyDownAsync(VK_CONTROL))
{
switch (tolower(wParam & 0xFFFF))
{
case 'g':
{
u32 addr;
if (executeExpressionWindow(wnd,debugger,addr) == false) return;
gotoAddr(addr);
return;
}
break;
case 'f':
case 's':
search(false);
return;
case 'c':
search(true);
return;
}
}
switch (wParam & 0xFFFF)
{
case VK_DOWN:
scrollCursor(rowSize);
break;
case VK_UP:
scrollCursor(-rowSize);
break;
case VK_LEFT:
scrollCursor(-1);
break;
case VK_RIGHT:
scrollCursor(1);
break;
case VK_NEXT:
scrollWindow(visibleRows);
break;
case VK_PRIOR:
scrollWindow(-visibleRows);
break;
case VK_TAB:
SendMessage(GetParent(wnd),WM_DEB_TABPRESSED,0,0);
break;
default:
return;
}
}
void CtrlMemView::onChar(WPARAM wParam, LPARAM lParam)
{
auto memLock = Memory::Lock();
if (!PSP_IsInited())
return;
if (KeyDownAsync(VK_CONTROL) || wParam == VK_TAB) return;
if (!Memory::IsValidAddress(curAddress))
{
scrollCursor(1);
return;
}
bool active = Core_IsActive();
if (active) Core_EnableStepping(true);
if (asciiSelected)
{
u8 newValue = wParam;
Memory::WriteUnchecked_U8(newValue,curAddress);
scrollCursor(1);
} else {
wParam = tolower(wParam);
int inputValue = -1;
if (wParam >= '0' && wParam <= '9') inputValue = wParam - '0';
if (wParam >= 'a' && wParam <= 'f') inputValue = wParam -'a' + 10;
if (inputValue >= 0)
{
int shiftAmount = (1-selectedNibble)*4;
u8 oldValue = Memory::ReadUnchecked_U8(curAddress);
oldValue &= ~(0xF << shiftAmount);
u8 newValue = oldValue | (inputValue << shiftAmount);
Memory::WriteUnchecked_U8(newValue,curAddress);
scrollCursor(1);
}
}
if (active) Core_EnableStepping(false);
}
void CtrlDisplayListView::onKeyDown(WPARAM wParam, LPARAM lParam)
{
u32 windowEnd = windowStart+visibleRows*instructionSize;
switch (wParam & 0xFFFF)
{
case VK_DOWN:
setCurAddress(curAddress + instructionSize, KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
break;
case VK_UP:
setCurAddress(curAddress - instructionSize, KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
break;
case VK_NEXT:
if (curAddress != windowEnd - instructionSize && curAddressIsVisible()) {
setCurAddress(windowEnd - instructionSize, KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
} else {
setCurAddress(curAddress + visibleRows * instructionSize, KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
}
break;
case VK_PRIOR:
if (curAddress != windowStart && curAddressIsVisible()) {
setCurAddress(windowStart, KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
} else {
setCurAddress(curAddress - visibleRows * instructionSize, KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
}
break;
case VK_LEFT:
gotoAddr(list.pc);
return;
case VK_SPACE:
toggleBreakpoint();
break;
case VK_F10:
case VK_F11:
SendMessage(GetParent(wnd),WM_GEDBG_STEPDISPLAYLIST,0,0);
break;
}
redraw();
}
void CtrlDisAsmView::onMouseUp(WPARAM wParam, LPARAM lParam, int button)
{
if (button == 1)
{
int x = LOWORD(lParam);
int y = HIWORD(lParam);
setCurAddress(yToAddress(y), KeyDownAsync(VK_SHIFT));
redraw();
}
else if (button == 2)
{
//popup menu?
POINT pt;
GetCursorPos(&pt);
switch(TrackPopupMenuEx(GetSubMenu(g_hPopupMenus,1),TPM_RIGHTBUTTON|TPM_RETURNCMD,pt.x,pt.y,wnd,0))
{
case ID_DISASM_GOTOINMEMORYVIEW:
SendMessage(GetParent(wnd),WM_DEB_GOTOHEXEDIT,curAddress,0);
break;
case ID_DISASM_ADDHLE:
break;
case ID_DISASM_TOGGLEBREAKPOINT:
toggleBreakpoint();
redraw();
break;
case ID_DISASM_ASSEMBLE:
assembleOpcode(curAddress,"");
break;
case ID_DISASM_COPYINSTRUCTIONDISASM:
copyInstructions(selectRangeStart, selectRangeEnd, true);
break;
case ID_DISASM_COPYADDRESS:
{
char temp[16];
sprintf(temp,"%08X",curAddress);
W32Util::CopyTextToClipboard(wnd, temp);
}
break;
case ID_DISASM_SETPCTOHERE:
debugger->setPC(curAddress);
redraw();
break;
case ID_DISASM_FOLLOWBRANCH:
followBranch();
break;
case ID_DISASM_COPYINSTRUCTIONHEX:
copyInstructions(selectRangeStart, selectRangeEnd, false);
break;
case ID_DISASM_RUNTOHERE:
{
SendMessage(GetParent(wnd), WM_COMMAND, ID_DEBUG_RUNTOLINE, 0);
redraw();
}
break;
case ID_DISASM_RENAMEFUNCTION:
{
u32 funcBegin = symbolMap.GetFunctionStart(curAddress);
if (funcBegin != -1)
{
char name[256];
std::string newname;
strncpy_s(name, symbolMap.GetLabelString(funcBegin).c_str(),_TRUNCATE);
if (InputBox_GetString(MainWindow::GetHInstance(), MainWindow::GetHWND(), L"New function name", name, newname)) {
symbolMap.SetLabelName(newname.c_str(),funcBegin);
u32 funcSize = symbolMap.GetFunctionSize(curAddress);
MIPSAnalyst::RegisterFunction(funcBegin, funcSize, newname.c_str());
MIPSAnalyst::UpdateHashMap();
MIPSAnalyst::ApplyHashMap();
SendMessage(GetParent(wnd),WM_DEB_MAPLOADED,0,0);
redraw();
}
}
else
{
MessageBox(MainWindow::GetHWND(), L"No symbol selected",0,0);
}
}
break;
case ID_DISASM_REMOVEFUNCTION:
{
char statusBarTextBuff[256];
u32 funcBegin = symbolMap.GetFunctionStart(curAddress);
if (funcBegin != -1)
{
u32 prevBegin = symbolMap.GetFunctionStart(funcBegin-1);
if (prevBegin != -1)
{
u32 expandedSize = symbolMap.GetFunctionSize(prevBegin)+symbolMap.GetFunctionSize(funcBegin);
symbolMap.SetFunctionSize(prevBegin,expandedSize);
}
symbolMap.RemoveFunction(funcBegin,true);
symbolMap.SortSymbols();
manager.clear();
SendMessage(GetParent(wnd), WM_DEB_MAPLOADED, 0, 0);
}
else
{
snprintf(statusBarTextBuff,256, "WARNING: unable to find function symbol here");
SendMessage(GetParent(wnd), WM_DEB_SETSTATUSBARTEXT, 0, (LPARAM) statusBarTextBuff);
}
redraw();
}
break;
case ID_DISASM_ADDFUNCTION:
{
char statusBarTextBuff[256];
u32 prevBegin = symbolMap.GetFunctionStart(curAddress);
if (prevBegin != -1)
{
if (prevBegin == curAddress)
{
snprintf(statusBarTextBuff,256, "WARNING: There's already a function entry point at this adress");
SendMessage(GetParent(wnd), WM_DEB_SETSTATUSBARTEXT, 0, (LPARAM) statusBarTextBuff);
}
else
{
char symname[128];
u32 prevSize = symbolMap.GetFunctionSize(prevBegin);
u32 newSize = curAddress-prevBegin;
symbolMap.SetFunctionSize(prevBegin,newSize);
newSize = prevSize-newSize;
snprintf(symname,128,"u_un_%08X",curAddress);
symbolMap.AddFunction(symname,curAddress,newSize);
symbolMap.SortSymbols();
manager.clear();
SendMessage(GetParent(wnd), WM_DEB_MAPLOADED, 0, 0);
}
}
else
{
char symname[128];
int newSize = selectRangeEnd - selectRangeStart;
snprintf(symname, 128, "u_un_%08X", selectRangeStart);
symbolMap.AddFunction(symname, selectRangeStart, newSize);
symbolMap.SortSymbols();
SendMessage(GetParent(wnd), WM_DEB_MAPLOADED, 0, 0);
}
redraw();
}
break;
case ID_DISASM_DISASSEMBLETOFILE:
disassembleToFile();
break;
}
return;
}
redraw();
}
void CtrlDisAsmView::onKeyDown(WPARAM wParam, LPARAM lParam)
{
dontRedraw = false;
u32 windowEnd = manager.getNthNextAddress(windowStart,visibleRows);
keyTaken = true;
if (KeyDownAsync(VK_CONTROL))
{
switch (tolower(wParam & 0xFFFF))
{
case 'f':
case 's':
search(false);
break;
case 'c':
case VK_INSERT:
copyInstructions(selectRangeStart, selectRangeEnd, true);
break;
case 'x':
disassembleToFile();
break;
case 'a':
assembleOpcode(curAddress,"");
break;
case 'g':
{
u32 addr;
if (executeExpressionWindow(wnd,debugger,addr) == false) return;
gotoAddr(addr);
}
break;
case 'e': // edit breakpoint
editBreakpoint();
break;
case 'd': // toogle breakpoint enabled
toggleBreakpoint(true);
break;
case VK_UP:
scrollWindow(-1);
scanFunctions();
break;
case VK_DOWN:
scrollWindow(1);
scanFunctions();
break;
case VK_NEXT:
setCurAddress(manager.getNthPreviousAddress(windowEnd,1),KeyDownAsync(VK_SHIFT));
break;
case VK_PRIOR:
setCurAddress(windowStart,KeyDownAsync(VK_SHIFT));
break;
}
} else {
switch (wParam & 0xFFFF)
{
case VK_DOWN:
setCurAddress(manager.getNthNextAddress(curAddress,1), KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
break;
case VK_UP:
setCurAddress(manager.getNthPreviousAddress(curAddress,1), KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
break;
case VK_NEXT:
if (manager.getNthNextAddress(curAddress,1) != windowEnd && curAddressIsVisible()) {
setCurAddress(manager.getNthPreviousAddress(windowEnd,1), KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
} else {
setCurAddress(manager.getNthNextAddress(windowEnd,visibleRows-1), KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
}
break;
case VK_PRIOR:
if (curAddress != windowStart && curAddressIsVisible()) {
setCurAddress(windowStart, KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
} else {
setCurAddress(manager.getNthPreviousAddress(windowStart,visibleRows), KeyDownAsync(VK_SHIFT));
scrollAddressIntoView();
}
break;
case VK_LEFT:
if (jumpStack.empty())
{
gotoPC();
} else {
u32 addr = jumpStack[jumpStack.size()-1];
jumpStack.pop_back();
gotoAddr(addr);
}
return;
case VK_RIGHT:
followBranch();
return;
case VK_TAB:
displaySymbols = !displaySymbols;
break;
case VK_SPACE:
debugger->toggleBreakpoint(curAddress);
break;
case VK_F3:
search(true);
break;
default:
keyTaken = false;
return;
}
}
redraw();
}
void CtrlDisAsmView::search(bool continueSearch)
{
u32 searchAddress;
if (continueSearch == false || searchQuery[0] == 0)
{
if (InputBox_GetString(MainWindow::GetHInstance(),MainWindow::GetHWND(),L"Search for:","",searchQuery) == false
|| searchQuery[0] == 0)
{
SetFocus(wnd);
return;
}
for (size_t i = 0; i < searchQuery.size(); i++)
{
searchQuery[i] = tolower(searchQuery[i]);
}
SetFocus(wnd);
searchAddress = manager.getNthNextAddress(curAddress,1);
} else {
searchAddress = manager.getNthNextAddress(matchAddress,1);
}
// limit address to sensible ranges
if (searchAddress < 0x04000000) searchAddress = 0x04000000;
if (searchAddress >= 0x04200000 && searchAddress < 0x08000000) searchAddress = 0x08000000;
if (searchAddress >= 0x0A000000) {
MessageBox(wnd,L"Not found",L"Search",MB_OK);
return;
}
searching = true;
redraw(); // so the cursor is disabled
DisassemblyLineInfo lineInfo;
while (searchAddress < 0x0A000000)
{
manager.getLine(searchAddress,displaySymbols,lineInfo);
char addressText[64];
getDisasmAddressText(searchAddress,addressText,true,lineInfo.type == DISTYPE_OPCODE);
const char* opcode = lineInfo.name.c_str();
const char* arguments = lineInfo.params.c_str();
char merged[512];
int mergePos = 0;
// I'm doing it manually to convert everything to lowercase at the same time
for (int i = 0; addressText[i] != 0; i++) merged[mergePos++] = tolower(addressText[i]);
merged[mergePos++] = ' ';
for (int i = 0; opcode[i] != 0; i++) merged[mergePos++] = tolower(opcode[i]);
merged[mergePos++] = ' ';
for (int i = 0; arguments[i] != 0; i++) merged[mergePos++] = tolower(arguments[i]);
merged[mergePos] = 0;
// match!
if (strstr(merged, searchQuery.c_str()) != NULL)
{
matchAddress = searchAddress;
searching = false;
gotoAddr(searchAddress);
return;
}
// cancel search
if ((searchAddress % 256) == 0 && KeyDownAsync(VK_ESCAPE))
{
searching = false;
return;
}
searchAddress = manager.getNthNextAddress(searchAddress,1);
if (searchAddress >= 0x04200000 && searchAddress < 0x08000000) searchAddress = 0x08000000;
}
MessageBox(wnd,L"Not found",L"Search",MB_OK);
searching = false;
}
void CtrlMemView::search(bool continueSearch)
{
u32 searchAddress;
if (continueSearch == false || searchQuery[0] == 0)
{
if (InputBox_GetString(GetModuleHandle(NULL),wnd,L"Search for", "",searchQuery) == false)
{
SetFocus(wnd);
return;
}
SetFocus(wnd);
searchAddress = curAddress+1;
} else {
searchAddress = matchAddress+1;
}
std::vector<u8> searchData;
if (asciiSelected)
{
for (size_t i = 0; i < searchQuery.length(); i++)
{
char c = searchQuery[i];
searchData.push_back(c);
}
} else {
size_t index = 0;
while (index < searchQuery.size())
{
if (searchQuery[index] == ' ' || searchQuery[index] == '\t')
{
index++;
continue;
}
u8 value = 0;
for (int i = 0; i < 2; i++)
{
char c = tolower(searchQuery[index++]);
if (c >= 'a' && c <= 'f')
{
value |= (c-'a'+10) << (1-i)*4;
} else if (c >= '0' && c <= '9')
{
value |= (c-'0') << (1-i)*4;
} else {
MessageBox(wnd,L"Invalid search text.",L"Error",MB_OK);
return;
}
}
searchData.push_back(value);
}
}
std::vector<std::pair<u32,u32>> memoryAreas;
memoryAreas.push_back(std::pair<u32,u32>(0x04000000,0x04200000));
memoryAreas.push_back(std::pair<u32,u32>(0x08000000,0x0A000000));
searching = true;
redraw(); // so the cursor is disabled
for (size_t i = 0; i < memoryAreas.size(); i++)
{
u32 segmentStart = memoryAreas[i].first;
u32 segmentEnd = memoryAreas[i].second;
u8* dataPointer = Memory::GetPointer(segmentStart);
if (dataPointer == NULL) continue; // better safe than sorry, I guess
if (searchAddress < segmentStart) searchAddress = segmentStart;
if (searchAddress >= segmentEnd) continue;
int index = searchAddress-segmentStart;
int endIndex = segmentEnd-segmentStart-(int)searchData.size();
while (index < endIndex)
{
// cancel search
if ((index % 256) == 0 && KeyDownAsync(VK_ESCAPE))
{
searching = false;
return;
}
if (memcmp(&dataPointer[index],searchData.data(),searchData.size()) == 0)
{
matchAddress = index+segmentStart;
searching = false;
gotoAddr(matchAddress);
return;
}
index++;
}
}
MessageBox(wnd,L"Not found",L"Search",MB_OK);
searching = false;
redraw();
}
