From 658d4ec4780a59d2958bb7f1e4bf3361e786d9cb Mon Sep 17 00:00:00 2001 From: WerWolv Date: Sat, 14 Nov 2020 14:42:21 +0100 Subject: [PATCH] Revamped pattern data displaying to support per-type displaying --- include/utils.hpp | 39 ++++++ include/views/highlight.hpp | 25 ---- include/views/pattern_data.hpp | 154 ++++++++++++++++++++++++ include/views/view_hexeditor.hpp | 6 +- include/views/view_pattern.hpp | 10 +- include/views/view_pattern_data.hpp | 6 +- source/main.cpp | 10 +- source/views/view_hexeditor.cpp | 12 +- source/views/view_pattern.cpp | 179 +++++++++++++++++++++------- source/views/view_pattern_data.cpp | 50 ++------ 10 files changed, 358 insertions(+), 133 deletions(-) delete mode 100644 include/views/highlight.hpp create mode 100644 include/views/pattern_data.hpp diff --git a/include/utils.hpp b/include/utils.hpp index e7054829a..7a4d6a66e 100644 --- a/include/utils.hpp +++ b/include/utils.hpp @@ -5,7 +5,46 @@ #include #include #include +#include +#include + +#include "parser/token.hpp" namespace hex { + template + inline std::string format(const std::string &format, Args ... args) { + size_t size = snprintf( nullptr, 0, format.c_str(), args ... ); + + if( size <= 0 ) + return ""; + + std::vector buffer(size + 1, 0x00); + snprintf(buffer.data(), size + 1, format.c_str(), args ...); + + return std::string(buffer.data(), buffer.data() + size); + } + + [[nodiscard]] constexpr inline u64 signExtend(u64 value, u8 currWidth, u8 targetWidth) { + u64 mask = 1LLU << (currWidth - 1); + return (((value ^ mask) - mask) << (64 - targetWidth)) >> (64 - targetWidth); + } + + constexpr inline bool isUnsigned(const lang::Token::TypeToken::Type type) { + return (static_cast(type) & 0x0F) == 0x00; + } + + constexpr inline bool isSigned(const lang::Token::TypeToken::Type type) { + return (static_cast(type) & 0x0F) == 0x01; + } + + constexpr inline bool isFloatingPoint(const lang::Token::TypeToken::Type type) { + return (static_cast(type) & 0x0F) == 0x02; + } + + constexpr inline u32 getTypeSize(const lang::Token::TypeToken::Type type) { + return static_cast(type) >> 4; + } + + } \ No newline at end of file diff --git a/include/views/highlight.hpp b/include/views/highlight.hpp deleted file mode 100644 index f6a886f3a..000000000 --- a/include/views/highlight.hpp +++ /dev/null @@ -1,25 +0,0 @@ -#pragma once - -#include -#include - -namespace hex { - - struct VariableType { - size_t size; - enum class Kind { Unsigned, Signed, FloatingPoint } kind; - }; - - struct Highlight { - Highlight(u64 offset, VariableType type, u32 color, std::string name) - : offset(offset), type(type), color(color), name(name) { - - } - - u64 offset; - VariableType type; - u32 color; - std::string name; - }; - -} \ No newline at end of file diff --git a/include/views/pattern_data.hpp b/include/views/pattern_data.hpp new file mode 100644 index 000000000..9422d8d98 --- /dev/null +++ b/include/views/pattern_data.hpp @@ -0,0 +1,154 @@ +#pragma once + +#include +#include + +#include "providers/provider.hpp" +#include "utils.hpp" + +#include + +namespace hex { + + namespace { + + std::string makeDisplayable(u8 *data, size_t size) { + std::string result; + for (u8* c = data; c < (data + size); c++) { + if (iscntrl(*c) || *c > 0x7F) + result += " "; + else + result += *c; + } + + return result; + } + + } + + class PatternData { + public: + PatternData(u64 offset, size_t size, const std::string &name, u32 color = 0) + : m_offset(offset), m_size(size), m_color(color), m_name(name) { + if (color == 0) + color = std::mt19937(std::random_device()())(); + + color &= ~0xFF00'0000; + color |= 0x5000'0000; + + this->m_color = color; + } + virtual ~PatternData() = default; + + [[nodiscard]] u64 getOffset() const { return this->m_offset; } + [[nodiscard]] size_t getSize() const { return this->m_size; } + + [[nodiscard]] u32 getColor() const { return this->m_color; } + [[nodiscard]] const std::string& getName() const { return this->m_name; } + + virtual std::string format(prv::Provider* &provider) = 0; + + private: + u64 m_offset; + size_t m_size; + + u32 m_color; + std::string m_name; + }; + + + class PatternDataUnsigned : public PatternData { + public: + PatternDataUnsigned(u64 offset, size_t size, const std::string &name, u32 color = 0) : PatternData(offset, size, name, color) { } + + std::string format(prv::Provider* &provider) override { + u64 data = 0; + provider->read(this->getOffset(), &data, this->getSize()); + + return hex::format("%lu (0x%08lx)", data, data); + } + }; + + class PatternDataSigned : public PatternData { + public: + PatternDataSigned(u64 offset, size_t size, const std::string &name, u32 color = 0) : PatternData(offset, size, name, color) { } + + std::string format(prv::Provider* &provider) override { + u64 data = 0; + provider->read(this->getOffset(), &data, this->getSize()); + + s64 signedData = signedData = hex::signExtend(data, this->getSize(), 64); + + return hex::format("%ld (0x%08lx)", signedData, data); + } + }; + + class PatternDataFloat : public PatternData { + public: + PatternDataFloat(u64 offset, size_t size, const std::string &name, u32 color = 0) : PatternData(offset, size, name, color) { } + + std::string format(prv::Provider* &provider) override { + double formatData = 0; + if (this->getSize() == 4) { + float data = 0; + provider->read(this->getOffset(), &data, 4); + formatData = data; + } else if (this->getSize() == 8) { + double data = 0; + provider->read(this->getOffset(), &data, 8); + formatData = data; + } + + return hex::format("%f (0x%08lx)", formatData, formatData); + } + }; + + class PatternDataCharacter : public PatternData { + public: + PatternDataCharacter(u64 offset, size_t size, const std::string &name, u32 color = 0) : PatternData(offset, size, name, color) { } + + std::string format(prv::Provider* &provider) override { + char character; + provider->read(this->getOffset(), &character, 1); + + return hex::format("'%c'", character); + } + }; + + class PatternDataString : public PatternData { + public: + PatternDataString(u64 offset, size_t size, const std::string &name, u32 color = 0) : PatternData(offset, size, name, color) { } + + std::string format(prv::Provider* &provider) override { + std::vector buffer(this->getSize() + 1, 0x00); + provider->read(this->getOffset(), buffer.data(), this->getSize()); + buffer[this->getSize()] = '\0'; + + return hex::format("\"%s\"", makeDisplayable(buffer.data(), this->getSize()).c_str()); + } + }; + + class PatternDataEnum : public PatternData { + public: + PatternDataEnum(u64 offset, size_t size, const std::string &name, const std::string &enumName, std::vector> enumValues, u32 color = 0) + : PatternData(offset, size, name, color), m_enumName(enumName), m_enumValues(enumValues) { } + + std::string format(prv::Provider* &provider) override { + u64 value = 0; + provider->read(this->getOffset(), &value, this->getSize()); + + for (auto [enumValue, name] : this->m_enumValues) { + if (value == enumValue) + return hex::format("%lu (0x%08lx) : %s::%s", value, value, this->m_enumName.c_str(), name.c_str()); + } + + return hex::format("%lu (0x%08lx) : %s::???", value, value, this->m_enumName.c_str()); + } + + private: + std::string m_enumName; + std::vector> m_enumValues; + }; + + +} \ No newline at end of file diff --git a/include/views/view_hexeditor.hpp b/include/views/view_hexeditor.hpp index b8c5b801f..515cbf844 100644 --- a/include/views/view_hexeditor.hpp +++ b/include/views/view_hexeditor.hpp @@ -10,7 +10,7 @@ #include #include -#include "views/highlight.hpp" +#include "views/pattern_data.hpp" namespace hex { @@ -18,7 +18,7 @@ namespace hex { class ViewHexEditor : public View { public: - ViewHexEditor(prv::Provider* &dataProvider, std::vector &highlights); + ViewHexEditor(prv::Provider* &dataProvider, std::vector &patternData); ~ViewHexEditor() override; void createView() override; @@ -32,7 +32,7 @@ namespace hex { prv::Provider* &m_dataProvider; - std::vector &m_highlights; + std::vector &m_patternData; char m_searchBuffer[0xFFFF] = { 0 }; s64 m_lastSearchIndex = 0; diff --git a/include/views/view_pattern.hpp b/include/views/view_pattern.hpp index 7594b3c96..cc6843b4f 100644 --- a/include/views/view_pattern.hpp +++ b/include/views/view_pattern.hpp @@ -5,7 +5,7 @@ #include "parser/lexer.hpp" #include "views/view.hpp" -#include "views/highlight.hpp" +#include "views/pattern_data.hpp" #include "providers/provider.hpp" @@ -19,7 +19,7 @@ namespace hex { class ViewPattern : public View { public: - explicit ViewPattern(prv::Provider* &dataProvider, std::vector &highlights); + explicit ViewPattern(prv::Provider* &dataProvider, std::vector &patternData); ~ViewPattern() override; void createMenu() override; @@ -28,18 +28,20 @@ namespace hex { private: char *m_buffer = nullptr; - std::vector &m_highlights; + std::vector &m_patternData; prv::Provider* &m_dataProvider; bool m_windowOpen = true; ImGui::FileBrowser m_fileBrowser; - void setHighlight(u64 offset, std::string name, lang::Token::TypeToken::Type type, size_t size = 0, u32 color = 0); + void addPatternData(PatternData *patternData); + void clearPatternData(); void parsePattern(char *buffer); s32 highlightUsingDecls(std::vector &ast, lang::ASTNodeTypeDecl* currTypeDeclNode, lang::ASTNodeVariableDecl* currVarDec, u64 offset, std::string name); s32 highlightStruct(std::vector &ast, lang::ASTNodeStruct* currStructNode, u64 offset, std::string name); + s32 highlightEnum(std::vector &ast, lang::ASTNodeEnum* currEnumNode, u64 offset, std::string name); }; } \ No newline at end of file diff --git a/include/views/view_pattern_data.hpp b/include/views/view_pattern_data.hpp index 07cb456fb..85c265b74 100644 --- a/include/views/view_pattern_data.hpp +++ b/include/views/view_pattern_data.hpp @@ -4,7 +4,7 @@ #include "imgui.h" #include "views/view.hpp" -#include "views/highlight.hpp" +#include "views/pattern_data.hpp" #include #include @@ -16,7 +16,7 @@ namespace hex { class ViewPatternData : public View { public: - ViewPatternData(prv::Provider* &dataProvider, std::vector &highlights); + ViewPatternData(prv::Provider* &dataProvider, std::vector &patternData); ~ViewPatternData() override; void createView() override; @@ -24,7 +24,7 @@ namespace hex { private: prv::Provider* &m_dataProvider; - std::vector &m_highlights; + std::vector &m_patternData; bool m_windowOpen = true; }; diff --git a/source/main.cpp b/source/main.cpp index 3c56b53a6..a8f8b4f76 100644 --- a/source/main.cpp +++ b/source/main.cpp @@ -1,6 +1,6 @@ #include "window.hpp" -#include "views/highlight.hpp" +#include "views/pattern_data.hpp" #include "views/view_hexeditor.hpp" #include "views/view_pattern.hpp" #include "views/view_pattern_data.hpp" @@ -15,13 +15,13 @@ int main() { hex::Window window; // Shared Data - std::vector highlights; + std::vector patternData; hex::prv::Provider *dataProvider = nullptr; // Create views - window.addView(dataProvider, highlights); - window.addView(dataProvider, highlights); - window.addView(dataProvider, highlights); + window.addView(dataProvider, patternData); + window.addView(dataProvider, patternData); + window.addView(dataProvider, patternData); window.addView(dataProvider); window.addView(dataProvider); diff --git a/source/views/view_hexeditor.cpp b/source/views/view_hexeditor.cpp index 826265ad2..25debd896 100644 --- a/source/views/view_hexeditor.cpp +++ b/source/views/view_hexeditor.cpp @@ -7,8 +7,8 @@ namespace hex { - ViewHexEditor::ViewHexEditor(prv::Provider* &dataProvider, std::vector &highlights) - : View(), m_dataProvider(dataProvider), m_highlights(highlights) { + ViewHexEditor::ViewHexEditor(prv::Provider* &dataProvider, std::vector &patternData) + : View(), m_dataProvider(dataProvider), m_patternData(patternData) { this->m_memoryEditor.ReadFn = [](const ImU8 *data, size_t off) -> ImU8 { ViewHexEditor *_this = (ViewHexEditor *) data; @@ -35,13 +35,13 @@ namespace hex { this->m_memoryEditor.HighlightFn = [](const ImU8 *data, size_t off, bool next) -> bool { ViewHexEditor *_this = (ViewHexEditor *) data; - for (auto&[offset, type, color, name] : _this->m_highlights) { - if (next && off == (offset + type.size)) { + for (auto& pattern : _this->m_patternData) { + if (next && off == (pattern->getOffset() + pattern->getSize())) { return false; } - if (off >= offset && off < (offset + type.size)) { - _this->m_memoryEditor.HighlightColor = color; + if (off >= pattern->getOffset() && off < (pattern->getOffset() + pattern->getSize())) { + _this->m_memoryEditor.HighlightColor = pattern->getColor(); return true; } } diff --git a/source/views/view_pattern.cpp b/source/views/view_pattern.cpp index d2cc93993..bd5034cfb 100644 --- a/source/views/view_pattern.cpp +++ b/source/views/view_pattern.cpp @@ -5,8 +5,8 @@ namespace hex { - ViewPattern::ViewPattern(prv::Provider* &dataProvider, std::vector &highlights) - : View(), m_dataProvider(dataProvider), m_highlights(highlights) { + ViewPattern::ViewPattern(prv::Provider* &dataProvider, std::vector &patternData) + : View(), m_dataProvider(dataProvider), m_patternData(patternData) { this->m_buffer = new char[0xFF'FFFF]; std::memset(this->m_buffer, 0x00, 0xFF'FFFF); @@ -86,25 +86,15 @@ namespace hex { } - void ViewPattern::setHighlight(u64 offset, std::string name, lang::Token::TypeToken::Type type, size_t size, u32 color) { - if (color == 0) - color = std::mt19937(std::random_device()())(); + void ViewPattern::addPatternData(PatternData *patternData) { + this->m_patternData.push_back(patternData); + } - color &= ~0xFF00'0000; - color |= 0x5000'0000; + void ViewPattern::clearPatternData() { + for (auto &data : this->m_patternData) + delete data; - VariableType varType = { 0 }; - - switch (static_cast(type) & 0x0F) { - default: - case 0: varType.kind = VariableType::Kind::Unsigned; break; - case 1: varType.kind = VariableType::Kind::Signed; break; - case 2: varType.kind = VariableType::Kind::FloatingPoint; break; - } - - varType.size = size; - - this->m_highlights.emplace_back(offset, varType, color, name); + this->m_patternData.clear(); } template T> @@ -122,7 +112,7 @@ namespace hex { static hex::lang::Lexer lexer; static hex::lang::Parser parser; - this->m_highlights.clear(); + this->clearPatternData(); auto [lexResult, tokens] = lexer.lex(buffer); @@ -142,10 +132,22 @@ namespace hex { u64 offset = varNode->getOffset().value(); if (varNode->getVariableType() != lang::Token::TypeToken::Type::CustomType) { - size_t size = static_cast(varNode->getVariableType()) >> 4 * varNode->getArraySize(); - this->setHighlight(offset, varNode->getVariableName(), varNode->getVariableType(), size); + size_t size = getTypeSize(varNode->getVariableType()) * varNode->getArraySize(); + + if (isUnsigned(varNode->getVariableType())) + this->addPatternData(new PatternDataUnsigned(offset, size, varNode->getVariableName())); + else if (isSigned(varNode->getVariableType())) { + if (getTypeSize(varNode->getVariableType()) == 1 && varNode->getArraySize() == 1) + this->addPatternData(new PatternDataCharacter(offset, size, varNode->getVariableName())); + else if (getTypeSize(varNode->getVariableType()) == 1 && varNode->getArraySize() > 1) + this->addPatternData(new PatternDataString(offset, size, varNode->getVariableName())); + else + this->addPatternData(new PatternDataSigned(offset, size, varNode->getVariableName())); + } + else if (isFloatingPoint(varNode->getVariableType())) + this->addPatternData(new PatternDataFloat(offset, size, varNode->getVariableName())); } else { - for (auto &structNode : findNodes(lang::ASTNode::Type::Struct, ast)) + for (auto &structNode : findNodes(lang::ASTNode::Type::Struct, ast)) { if (varNode->getCustomVariableTypeName() == structNode->getName()) { for (u32 i = 0; i < varNode->getArraySize(); i++) { std::string name = varNode->getVariableName(); @@ -153,11 +155,27 @@ namespace hex { name += "[" + std::to_string(varNode->getArraySize()) + "]"; if (size_t size = this->highlightStruct(ast, structNode, offset, name); size == -1) - this->m_highlights.clear(); + this->clearPatternData(); else offset += size; } } + } + + for (auto &enumNode : findNodes(lang::ASTNode::Type::Enum, ast)) { + if (varNode->getCustomVariableTypeName() == enumNode->getName()) { + for (u32 i = 0; i < varNode->getArraySize(); i++) { + std::string name = varNode->getVariableName(); + if (varNode->getArraySize() > 1) + name += "[" + std::to_string(varNode->getArraySize()) + "]"; + + if (size_t size = this->highlightEnum(ast, enumNode, offset, name); size == -1) + this->clearPatternData(); + else + offset += size; + } + } + } for (auto &usingNode : findNodes(lang::ASTNode::Type::TypeDecl, ast)) { if (varNode->getCustomVariableTypeName() == usingNode->getTypeName()) { @@ -167,7 +185,7 @@ namespace hex { name += "[" + std::to_string(varNode->getArraySize()) + "]"; if (size_t size = this->highlightUsingDecls(ast, usingNode, varNode, offset, name); size == -1) - this->m_highlights.clear(); + this->clearPatternData(); else offset += size; } @@ -186,11 +204,17 @@ namespace hex { if (currTypeDeclNode->getAssignedType() != lang::Token::TypeToken::Type::CustomType) { size_t size = (static_cast(currTypeDeclNode->getAssignedType()) >> 4); - this->setHighlight(offset, name, currTypeDeclNode->getAssignedType(), size); + if (isUnsigned(currTypeDeclNode->getAssignedType())) + this->addPatternData(new PatternDataUnsigned(offset, size, currTypeDeclNode->getTypeName())); + else if (isSigned(currTypeDeclNode->getAssignedType())) + this->addPatternData(new PatternDataSigned(offset, size, currTypeDeclNode->getTypeName())); + else if (isFloatingPoint(currTypeDeclNode->getAssignedType())) + this->addPatternData(new PatternDataFloat(offset, size, currTypeDeclNode->getTypeName())); + offset += size; } else { bool foundType = false; - for (auto &structNode : findNodes(lang::ASTNode::Type::Struct, ast)) + for (auto &structNode : findNodes(lang::ASTNode::Type::Struct, ast)) { if (structNode->getName() == currTypeDeclNode->getAssignedCustomTypeName()) { for (size_t i = 0; i < currVarDecl->getArraySize(); i++) { size_t size = this->highlightStruct(ast, structNode, offset, name); @@ -204,6 +228,24 @@ namespace hex { foundType = true; break; } + } + + for (auto &enumNode : findNodes(lang::ASTNode::Type::Enum, ast)) { + if (enumNode->getName() == currTypeDeclNode->getAssignedCustomTypeName()) { + for (size_t i = 0; i < currVarDecl->getArraySize(); i++) { + size_t size = this->highlightEnum(ast, enumNode, offset, name); + + if (size == -1) + return -1; + + offset += size; + } + + foundType = true; + break; + } + } + for (auto &typeDeclNode : findNodes(lang::ASTNode::Type::TypeDecl, ast)) { if (typeDeclNode->getTypeName() == currTypeDeclNode->getAssignedCustomTypeName()) { @@ -232,25 +274,40 @@ namespace hex { u64 startOffset = offset; for (auto &node : currStructNode->getNodes()) { - auto var = static_cast(node); + auto varNode = static_cast(node); - if (var->getVariableType() != lang::Token::TypeToken::Type::CustomType) { - size_t size = (static_cast(var->getVariableType()) >> 4); - for (size_t i = 0; i < var->getArraySize(); i++) { - std::string memberName = name + "." + var->getVariableName(); - if (var->getArraySize() > 1) + if (varNode->getVariableType() != lang::Token::TypeToken::Type::CustomType) { + size_t size = (static_cast(varNode->getVariableType()) >> 4); + for (size_t i = 0; i < varNode->getArraySize(); i++) { + std::string memberName = name + "." + varNode->getVariableName(); + if (varNode->getArraySize() > 1) memberName += "[" + std::to_string(i) + "]"; - this->setHighlight(offset, memberName, var->getVariableType(), size); + if (isUnsigned(varNode->getVariableType())) + this->addPatternData(new PatternDataUnsigned(offset, size, memberName)); + else if (isSigned(varNode->getVariableType())) { + if (getTypeSize(varNode->getVariableType()) == 1 && varNode->getArraySize() == 1) + this->addPatternData(new PatternDataCharacter(offset, size, memberName)); + else if (getTypeSize(varNode->getVariableType()) == 1 && varNode->getArraySize() > 1) { + this->addPatternData(new PatternDataString(offset, size * varNode->getArraySize(), name + "." + varNode->getVariableName())); + offset += size * varNode->getArraySize(); + break; + } + else + this->addPatternData(new PatternDataSigned(offset, size, memberName)); + } + else if (isFloatingPoint(varNode->getVariableType())) + this->addPatternData(new PatternDataFloat(offset, size, memberName)); + offset += size; } } else { bool foundType = false; for (auto &structNode : findNodes(lang::ASTNode::Type::Struct, ast)) { - if (structNode->getName() == var->getCustomVariableTypeName()) { - for (size_t i = 0; i < var->getArraySize(); i++) { - std::string memberName = name + "." + var->getVariableName(); - if (var->getArraySize() > 1) + if (structNode->getName() == varNode->getCustomVariableTypeName()) { + for (size_t i = 0; i < varNode->getArraySize(); i++) { + std::string memberName = name + "." + varNode->getVariableName(); + if (varNode->getArraySize() > 1) memberName += "[" + std::to_string(i) + "]"; size_t size = this->highlightStruct(ast, structNode, offset, memberName); @@ -266,14 +323,34 @@ namespace hex { } } - for (auto &typeDeclNode : findNodes(lang::ASTNode::Type::TypeDecl, ast)) { - if (typeDeclNode->getTypeName() == var->getCustomVariableTypeName()) { - for (size_t i = 0; i < var->getArraySize(); i++) { - std::string memberName = name + "." + var->getVariableName(); - if (var->getArraySize() > 1) + for (auto &enumNode : findNodes(lang::ASTNode::Type::Enum, ast)) { + if (enumNode->getName() == varNode->getCustomVariableTypeName()) { + for (size_t i = 0; i < varNode->getArraySize(); i++) { + std::string memberName = name + "." + varNode->getVariableName(); + if (varNode->getArraySize() > 1) memberName += "[" + std::to_string(i) + "]"; - size_t size = this->highlightUsingDecls(ast, typeDeclNode, var, offset, memberName); + size_t size = this->highlightEnum(ast, enumNode, offset, memberName); + + if (size == -1) + return -1; + + offset += size; + } + + foundType = true; + break; + } + } + + for (auto &typeDeclNode : findNodes(lang::ASTNode::Type::TypeDecl, ast)) { + if (typeDeclNode->getTypeName() == varNode->getCustomVariableTypeName()) { + for (size_t i = 0; i < varNode->getArraySize(); i++) { + std::string memberName = name + "." + varNode->getVariableName(); + if (varNode->getArraySize() > 1) + memberName += "[" + std::to_string(i) + "]"; + + size_t size = this->highlightUsingDecls(ast, typeDeclNode, varNode, offset, memberName); if (size == -1) return -1; @@ -295,4 +372,18 @@ namespace hex { return offset - startOffset; } + s32 ViewPattern::highlightEnum(std::vector &ast, lang::ASTNodeEnum* currEnumNode, u64 offset, std::string name) { + if (!isUnsigned(currEnumNode->getUnderlyingType())) + return -1; + + s32 size = static_cast(currEnumNode->getUnderlyingType()) >> 4; + + if (size > 8) + return -1; + + this->addPatternData(new PatternDataEnum(offset, size, name, currEnumNode->getName(), currEnumNode->getValues())); + + return size; + } + } \ No newline at end of file diff --git a/source/views/view_pattern_data.cpp b/source/views/view_pattern_data.cpp index d82b323ab..f527fad58 100644 --- a/source/views/view_pattern_data.cpp +++ b/source/views/view_pattern_data.cpp @@ -6,8 +6,8 @@ namespace hex { - ViewPatternData::ViewPatternData(prv::Provider* &dataProvider, std::vector &highlights) - : View(), m_dataProvider(dataProvider), m_highlights(highlights) { + ViewPatternData::ViewPatternData(prv::Provider* &dataProvider, std::vector &patternData) + : View(), m_dataProvider(dataProvider), m_patternData(patternData) { } @@ -15,18 +15,6 @@ namespace hex { } - std::string makeDisplayable(u8 *data, size_t size) { - std::string result; - for (u8* c = data; c < (data + size - 1); c++) { - if (iscntrl(*c) || *c > 0x7F) - result += " "; - else - result += *c; - } - - return result; - } - void ViewPatternData::createView() { if (!this->m_windowOpen) return; @@ -36,35 +24,11 @@ namespace hex { if (this->m_dataProvider != nullptr && this->m_dataProvider->isReadable()) { - for (auto&[offset, type, color, name] : this->m_highlights) { - std::vector buffer(type.size + 1, 0x00); - - this->m_dataProvider->read(offset, buffer.data(), type.size); - - if (type.size <= 8) { - u64 data = 0; - std::memcpy(&data, buffer.data(), type.size); - - switch (type.kind) { - case VariableType::Kind::Unsigned: - ImGui::LabelText(name.c_str(), "[0x%08lx:0x%08lx] %lu (0x%08lx) \"%s\"", offset, - offset + type.size, data, data, - makeDisplayable(buffer.data(), buffer.size()).c_str()); - break; - case VariableType::Kind::Signed: - ImGui::LabelText(name.c_str(), "[0x%08lx:0x%08lx] %ld (0x%08lx) \"%s\"", offset, - offset + type.size, data, data, - makeDisplayable(buffer.data(), buffer.size()).c_str()); - break; - case VariableType::Kind::FloatingPoint: - ImGui::LabelText(name.c_str(), "[0x%08lx:0x%08lx] %f (0x%08lx) \"%s\"", offset, - offset + type.size, data, data, - makeDisplayable(buffer.data(), buffer.size()).c_str()); - break; - } - } else - ImGui::LabelText(name.c_str(), "[0x%08lx:0x%08lx] [ ARRAY ] \"%s\"", offset, offset + type.size, - makeDisplayable(buffer.data(), buffer.size()).c_str()); + for (auto& patternData : this->m_patternData) { + ImGui::LabelText(patternData->getName().c_str(), "[0x%08lx:0x%08lx] %s", + patternData->getOffset(), + patternData->getOffset() + patternData->getSize(), + patternData->format(this->m_dataProvider).c_str()); } }