piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-11-14 21:37:52 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #10528 from TryTwo/PR_Debugger_Memory_Input_Types

Browse Source 
Debugger: MemoryWidget: add float and integer input types. Add input preview.
This commit is contained in:
Admiral H. Curtiss 2022-04-07 02:13:21 +02:00 committed by GitHub
commit 368342cb9b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 225 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

273
Source/Core/DolphinQt/Debugger/MemoryWidget.cpp
View File

@ -7,8 +7,11 @@
#include <optional>
#include <string>
#include <fmt/printf.h>
#include <QButtonGroup>
#include <QCheckBox>
#include <QComboBox>
#include <QGroupBox>
#include <QHBoxLayout>
#include <QLabel>
@ -22,6 +25,7 @@
#include <QTableWidget>
#include <QVBoxLayout>
#include "Common/BitUtils.h"
#include "Common/FileUtil.h"
#include "Common/IOFile.h"
#include "Core/ConfigManager.h"
@ -92,12 +96,11 @@ void MemoryWidget::CreateWidgets()
m_search_address = new QLineEdit;
m_search_offset = new QLineEdit;
m_data_edit = new QLineEdit;
m_set_value = new QPushButton(tr("Set &Value"));
m_search_address->setMaxLength(8);
m_search_offset->setMaxLength(9);
m_search_address->setPlaceholderText(tr("Search Address"));
m_search_offset->setPlaceholderText(tr("Offset"));
m_data_edit->setPlaceholderText(tr("Value"));
m_address_splitter->addWidget(m_search_address);
m_address_splitter->addWidget(m_search_offset);
@ -105,11 +108,34 @@ void MemoryWidget::CreateWidgets()
m_address_splitter->setCollapsible(0, false);
m_address_splitter->setStretchFactor(1, 2);
auto* search_type_group = new QButtonGroup(this);
m_find_ascii = new QRadioButton(tr("ASCII"));
m_find_hex = new QRadioButton(tr("Hex string"));
search_type_group->addButton(m_find_ascii);
search_type_group->addButton(m_find_hex);
auto* input_layout = new QHBoxLayout;
m_data_edit = new QLineEdit;
m_base_check = new QCheckBox(tr("Hex"));
m_set_value = new QPushButton(tr("Set &Value"));
m_data_preview = new QLabel;
m_base_check->setLayoutDirection(Qt::RightToLeft);
m_data_edit->setPlaceholderText(tr("Value"));
m_data_preview->setBackgroundRole(QPalette::AlternateBase);
m_data_preview->setAutoFillBackground(true);
input_layout->addWidget(m_data_edit);
input_layout->addWidget(m_base_check);
// Input types
m_input_combo = new QComboBox;
m_input_combo->setMaxVisibleItems(20);
// Order here determines combo list order.
m_input_combo->addItem(tr("Hex Byte String"), int(InputID::HEXSTR));
m_input_combo->addItem(tr("ASCII"), int(InputID::ASCII));
m_input_combo->addItem(tr("Float"), int(InputID::FLOAT));
m_input_combo->addItem(tr("Double"), int(InputID::DOUBLE));
m_input_combo->addItem(tr("Unsigned 8"), int(InputID::U8));
m_input_combo->addItem(tr("Unsigned 16"), int(InputID::U16));
m_input_combo->addItem(tr("Unsigned 32"), int(InputID::U32));
m_input_combo->addItem(tr("Signed 8"), int(InputID::S8));
m_input_combo->addItem(tr("Signed 16"), int(InputID::S16));
m_input_combo->addItem(tr("Signed 32"), int(InputID::S32));
// Dump
m_dump_mram = new QPushButton(tr("Dump &MRAM"));
@ -197,19 +223,11 @@ void MemoryWidget::CreateWidgets()
auto* sidebar = new QWidget;
auto* sidebar_layout = new QVBoxLayout;
sidebar_layout->setSpacing(1);
sidebar->setLayout(sidebar_layout);
sidebar_layout->addWidget(m_address_splitter);
sidebar_layout->addWidget(m_data_edit);
auto* types_layout = new QHBoxLayout;
types_layout->addWidget(m_find_ascii);
types_layout->addItem(new QSpacerItem(20, 1));
types_layout->addWidget(m_find_hex);
types_layout->setAlignment(Qt::AlignCenter);
sidebar_layout->addLayout(types_layout);
sidebar_layout->addLayout(input_layout);
sidebar_layout->addWidget(m_input_combo);
sidebar_layout->addWidget(m_data_preview);
sidebar_layout->addWidget(m_set_value);
sidebar_layout->addItem(new QSpacerItem(1, 20));
sidebar_layout->addWidget(m_dump_mram);
@ -247,10 +265,10 @@ void MemoryWidget::ConnectWidgets()
{
connect(m_search_address, &QLineEdit::textChanged, this, &MemoryWidget::OnSearchAddress);
connect(m_search_offset, &QLineEdit::textChanged, this, &MemoryWidget::OnSearchAddress);
connect(m_data_edit, &QLineEdit::textChanged, this, &MemoryWidget::ValidateAndPreviewInputValue);
connect(m_data_edit, &QLineEdit::textChanged, this, &MemoryWidget::ValidateSearchValue);
connect(m_find_ascii, &QRadioButton::toggled, this, &MemoryWidget::ValidateSearchValue);
connect(m_find_hex, &QRadioButton::toggled, this, &MemoryWidget::ValidateSearchValue);
connect(m_input_combo, qOverload<int>(&QComboBox::currentIndexChanged), this,
&MemoryWidget::ValidateAndPreviewInputValue);
connect(m_set_value, &QPushButton::clicked, this, &MemoryWidget::OnSetValue);
@ -274,6 +292,7 @@ void MemoryWidget::ConnectWidgets()
for (auto* radio : {m_bp_read_write, m_bp_read_only, m_bp_write_only})
connect(radio, &QRadioButton::toggled, this, &MemoryWidget::OnBPTypeChanged);
connect(m_base_check, &QCheckBox::toggled, this, &MemoryWidget::ValidateAndPreviewInputValue);
connect(m_bp_log_check, &QCheckBox::toggled, this, &MemoryWidget::OnBPLogChanged);
connect(m_memory_view, &MemoryViewWidget::BreakpointsChanged, this,
&MemoryWidget::BreakpointsChanged);
@ -304,12 +323,9 @@ void MemoryWidget::LoadSettings()
{
QSettings& settings = Settings::GetQSettings();
const bool search_ascii =
settings.value(QStringLiteral("memorywidget/searchascii"), true).toBool();
const bool search_hex = settings.value(QStringLiteral("memorywidget/searchhex"), false).toBool();
const int combo_index = settings.value(QStringLiteral("memorywidget/inputcombo"), 1).toInt();
m_find_ascii->setChecked(search_ascii);
m_find_hex->setChecked(search_hex);
m_input_combo->setCurrentIndex(combo_index);
const bool address_space_effective =
settings.value(QStringLiteral("memorywidget/addrspace_effective"), true).toBool();
@ -356,8 +372,7 @@ void MemoryWidget::SaveSettings()
{
QSettings& settings = Settings::GetQSettings();
settings.setValue(QStringLiteral("memorywidget/searchascii"), m_find_ascii->isChecked());
settings.setValue(QStringLiteral("memorywidget/searchhex"), m_find_hex->isChecked());
settings.setValue(QStringLiteral("memorywidget/inputcombo"), m_input_combo->currentIndex());
settings.setValue(QStringLiteral("memorywidget/addrspace_effective"),
m_address_space_effective->isChecked());
@ -409,6 +424,7 @@ void MemoryWidget::OnTypeChanged()
else
type = MemoryViewWidget::Type::Float32;
ValidateAndPreviewInputValue();
m_memory_view->SetType(type);
SaveSettings();
@ -476,12 +492,138 @@ void MemoryWidget::OnSearchAddress()
m_search_offset->setPalette(offset_palette);
}
void MemoryWidget::ValidateSearchValue()
void MemoryWidget::ValidateAndPreviewInputValue()
{
m_data_preview->clear();
QString input_text = m_data_edit->text();
const auto combo_id = static_cast<InputID>(m_input_combo->currentData().toInt());
m_base_check->setEnabled(combo_id == InputID::U32 || combo_id == InputID::S32 ||
combo_id == InputID::U16 || combo_id == InputID::S16 ||
combo_id == InputID::U8 || combo_id == InputID::S8);
if (input_text.isEmpty())
return;
// Remove any spaces
if (combo_id != InputID::ASCII)
input_text.remove(QLatin1Char(' '));
QFont font;
QPalette palette;
QString hex_string;
bool good = false;
const int radix = (m_base_check->isChecked() && m_base_check->isEnabled()) ? 16 : 0;
if (!IsValueValid())
switch (combo_id)
{
case InputID::ASCII:
{
good = true;
const QByteArray bytes = input_text.toLatin1();
hex_string = QString::fromLatin1(bytes.toHex());
break;
}
case InputID::FLOAT:
{
const float value_float = input_text.toFloat(&good);
if (good)
{
const u32 hex_out = Common::BitCast<u32>(value_float);
hex_string = QString::fromStdString(fmt::format("{:X}", hex_out));
}
break;
}
case InputID::DOUBLE:
{
const double value_double = input_text.toDouble(&good);
if (good)
{
const u64 hex_out = Common::BitCast<u64>(value_double);
hex_string = QString::fromStdString(fmt::format("{:X}", hex_out));
}
break;
}
case InputID::S8:
{
const short value = input_text.toShort(&good, radix);
good &= std::numeric_limits<signed char>::min() <= value &&
value <= std::numeric_limits<signed char>::max();
if (good)
hex_string = QString::fromStdString(fmt::sprintf("%02hhX", value));
break;
}
case InputID::S16:
{
const short value = input_text.toShort(&good, radix);
if (good)
hex_string = QString::fromStdString(fmt::sprintf("%04hX", value));
break;
}
case InputID::S32:
{
const int value_int = input_text.toInt(&good, radix);
if (good)
hex_string = QString::fromStdString(fmt::sprintf("%08X", value_int));
break;
}
case InputID::U8:
{
const unsigned short value = input_text.toUShort(&good, radix);
good &= (value & 0xFF00) == 0;
if (good)
hex_string = QString::fromStdString(fmt::format("{:02X}", value));
break;
}
case InputID::U16:
{
const unsigned short value = input_text.toUShort(&good, radix);
if (good)
hex_string = QString::fromStdString(fmt::format("{:04X}", value));
break;
}
case InputID::U32:
{
const u32 value = input_text.toUInt(&good, radix);
if (good)
hex_string = QString::fromStdString(fmt::format("{:08X}", value));
break;
}
case InputID::HEXSTR:
{
// Confirm it is only hex bytes
const QRegularExpression is_hex(QStringLiteral("^([0-9A-F]{2})*$"),
QRegularExpression::CaseInsensitiveOption);
const QRegularExpressionMatch match = is_hex.match(input_text);
good = match.hasMatch();
if (good)
{
const QByteArray hbytes = QByteArray::fromHex(input_text.toUtf8());
hex_string = QString::fromLatin1(hbytes.toHex());
}
break;
}
}
if (good)
{
int output_length = hex_string.length();
if (output_length > 16)
{
hex_string.truncate(16);
output_length = hex_string.length();
hex_string.append(QStringLiteral("..."));
}
for (int i = 2; i < output_length; i += 2)
hex_string.insert(output_length - i, QLatin1Char{' '});
m_data_preview->setText(hex_string);
}
else
{
font.setBold(true);
palette.setColor(QPalette::Text, Qt::red);
@ -491,6 +633,26 @@ void MemoryWidget::ValidateSearchValue()
m_data_edit->setPalette(palette);
}
QByteArray MemoryWidget::GetInputData() const
{
// Empty or invalid input data returns an empty array.
if (m_data_preview->text().isEmpty())
return QByteArray();
const auto combo_id = static_cast<InputID>(m_input_combo->currentData().toInt());
// Ascii might be truncated, pull from data edit box.
if (combo_id == InputID::ASCII)
return QByteArray(m_data_edit->text().toUtf8());
// If we are doing a large aray of hex bytes
if (combo_id == InputID::HEXSTR)
return QByteArray::fromHex(m_data_edit->text().toUtf8());
// Data preview has exactly what we want to input, so pull it from there.
return QByteArray::fromHex(m_data_preview->text().toUtf8());
}
void MemoryWidget::OnSetValue()
{
if (!Core::IsRunning())
@ -510,13 +672,10 @@ void MemoryWidget::OnSetValue()
return;
}
if (m_data_edit->text().isEmpty())
{
ModalMessageBox::critical(this, tr("Error"), tr("No value provided."));
return;
}
const QByteArray bytes = GetInputData();
if (!IsValueValid())
// Invalid input will give an empty array.
if (bytes.isEmpty())
{
ModalMessageBox::critical(this, tr("Error"), tr("Bad value provided."));
return;
@ -524,7 +683,6 @@ void MemoryWidget::OnSetValue()
AddressSpace::Accessors* accessors = AddressSpace::GetAccessors(m_memory_view->GetAddressSpace());
const QByteArray bytes = GetValueData();
for (const char c : bytes)
accessors->WriteU8(target_addr.address++, static_cast<u8>(c));
@ -582,29 +740,6 @@ void MemoryWidget::OnDumpFakeVMEM()
std::distance(accessors->begin(), accessors->end()));
}
bool MemoryWidget::IsValueValid() const
{
if (m_find_ascii->isChecked())
return true;
const QRegularExpression is_hex(QStringLiteral("^([0-9A-F]{2})*$"),
QRegularExpression::CaseInsensitiveOption);
const QRegularExpressionMatch match = is_hex.match(m_data_edit->text());
return match.hasMatch();
}
QByteArray MemoryWidget::GetValueData() const
{
if (!IsValueValid())
return QByteArray();
const QByteArray value = m_data_edit->text().toUtf8();
if (m_find_ascii->isChecked())
return value;
return QByteArray::fromHex(value);
}
MemoryWidget::TargetAddress MemoryWidget::GetTargetAddress() const
{
TargetAddress target;
@ -646,20 +781,20 @@ void MemoryWidget::FindValue(bool next)
return;
}
const QByteArray search_for = GetInputData();
if (search_for.isEmpty())
{
m_result_label->setText(tr("Bad Value Given"));
return;
}
if (!m_search_address->text().isEmpty())
{
// skip the quoted address so we don't potentially refind the last result
target_addr.address += next ? 1 : -1;
}
const QByteArray search_for = GetValueData();
if (search_for.isEmpty())
{
m_result_label->setText(tr("No value provided."));
return;
}
AddressSpace::Accessors* accessors = AddressSpace::GetAccessors(m_memory_view->GetAddressSpace());
const auto found_addr =

27
Source/Core/DolphinQt/Debugger/MemoryWidget.h
View File

@ -12,6 +12,7 @@
class MemoryViewWidget;
class QCheckBox;
class QComboBox;
class QLabel;
class QLineEdit;
class QPushButton;
@ -19,6 +20,21 @@ class QRadioButton;
class QShowEvent;
class QSplitter;
enum class InputID : int
{
// Order does not matter here.
S8 = 1,
S16,
S32,
U8,
U16,
U32,
HEXSTR,
FLOAT,
DOUBLE,
ASCII
};
class MemoryWidget : public QDockWidget
{
Q_OBJECT
@ -55,7 +71,6 @@ private:
void OnSearchAddress();
void OnFindNextValue();
void OnFindPreviousValue();
void ValidateSearchValue();
void OnSetValue();
@ -64,10 +79,9 @@ private:
void OnDumpARAM();
void OnDumpFakeVMEM();
bool IsValueValid() const;
QByteArray GetValueData() const;
void ValidateAndPreviewInputValue();
QByteArray GetInputData() const;
TargetAddress GetTargetAddress() const;
void FindValue(bool next);
void closeEvent(QCloseEvent*) override;
@ -78,6 +92,8 @@ private:
QLineEdit* m_search_address;
QLineEdit* m_search_offset;
QLineEdit* m_data_edit;
QCheckBox* m_base_check;
QLabel* m_data_preview;
QPushButton* m_set_value;
QPushButton* m_dump_mram;
QPushButton* m_dump_exram;
@ -87,8 +103,7 @@ private:
// Search
QPushButton* m_find_next;
QPushButton* m_find_previous;
QRadioButton* m_find_ascii;
QRadioButton* m_find_hex;
QComboBox* m_input_combo;
QLabel* m_result_label;
// Address Spaces