build: Bumped version to 1.13.1

Fixes #385

CMakeLists.txt

@@ -1,11 +1,12 @@
 cmake_minimum_required(VERSION 3.16)
 
 # Updating the version here will update it throughout ImHex as well
-set(IMHEX_VERSION "1.13.0")
+set(IMHEX_VERSION "1.13.1")
 project(imhex VERSION ${IMHEX_VERSION})
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules")
+set(IMHEX_BASE_FOLDER ${CMAKE_CURRENT_SOURCE_DIR})
 include("${CMAKE_SOURCE_DIR}/cmake/build_helpers.cmake")
 
 # List plugin names here. Project name must match folder name

plugins/builtin/include/content/views/view_command_palette.hpp

@@ -11,8 +11,6 @@
 
 namespace hex::plugin::builtin {
 
-    namespace prv { class Provider; }
-
     class ViewCommandPalette : public View {
     public:
         ViewCommandPalette();
@@ -20,12 +18,12 @@ namespace hex::plugin::builtin {
 
         void drawContent() override;
         void drawMenu() override;
-        bool isAvailable() override { return true; }
-        bool shouldProcess() override { return true; }
+        [[nodiscard]] bool isAvailable() const override { return true; }
+        [[nodiscard]] bool shouldProcess() const override { return true; }
 
-        bool hasViewMenuItemEntry() override { return false; }
-        ImVec2 getMinSize() override { return ImVec2(400, 100); }
-        ImVec2 getMaxSize() override { return ImVec2(400, 100); }
+        [[nodiscard]] bool hasViewMenuItemEntry() const override { return false; }
+        [[nodiscard]] ImVec2 getMinSize() const override { return ImVec2(400, 100); }
+        [[nodiscard]] ImVec2 getMaxSize() const override { return ImVec2(400, 100); }
 
     private:
         enum class MatchType {

plugins/builtin/include/content/views/view_help.hpp

@@ -20,11 +20,11 @@ namespace hex::plugin::builtin {
 
         void drawContent() override;
         void drawMenu() override;
-        bool isAvailable() override { return true; }
+        bool isAvailable() const override { return true; }
 
-        bool hasViewMenuItemEntry() override { return false; }
+        bool hasViewMenuItemEntry() const override { return false; }
 
-        ImVec2 getMinSize() override {
+        ImVec2 getMinSize() const override {
             return ImVec2(400, 300);
         }
 

plugins/builtin/include/content/views/view_provider_settings.hpp

@@ -13,14 +13,14 @@ namespace hex::plugin::builtin {
     class ViewProviderSettings : public hex::View {
     public:
         ViewProviderSettings();
-        ~ViewProviderSettings();
+        ~ViewProviderSettings() override;
 
         void drawContent() override;
         void drawAlwaysVisible() override;
 
-        bool hasViewMenuItemEntry() override;
+        [[nodiscard]] bool hasViewMenuItemEntry() const override;
 
-        bool isAvailable();
+        [[nodiscard]] bool isAvailable() const override;
     };
 
 }

plugins/builtin/include/content/views/view_settings.hpp

@@ -14,9 +14,13 @@ namespace hex::plugin::builtin {
 
         void drawContent() override;
         void drawMenu() override;
-        bool isAvailable() override { return true; }
+        [[nodiscard]] bool isAvailable() const override { return true; }
 
-        bool hasViewMenuItemEntry() override { return false; }
+        [[nodiscard]] bool hasViewMenuItemEntry() const override { return false; }
+
+        [[nodiscard]] ImVec2 getMinSize() const override {
+            return ImVec2(500, 300) * SharedData::globalScale;
+        }
     };
 
 }

plugins/builtin/include/content/views/view_store.hpp

@@ -35,8 +35,8 @@ namespace hex::plugin::builtin {
         void drawContent() override;
         void drawMenu() override;
 
-        bool isAvailable() override { return true; }
-        bool hasViewMenuItemEntry() override { return false; }
+        [[nodiscard]] bool isAvailable() const override { return true; }
+        [[nodiscard]] bool hasViewMenuItemEntry() const override { return false; }
 
     private:
         Net m_net;

plugins/builtin/source/content/views/view_disassembler.cpp

@@ -281,31 +281,34 @@ namespace hex::plugin::builtin {
                     ImGui::TableSetupColumn("hex.builtin.view.disassembler.disassembly.bytes"_lang);
                     ImGui::TableSetupColumn("hex.builtin.view.disassembler.disassembly.title"_lang);
 
-                    ImGuiListClipper clipper;
-                    clipper.Begin(this->m_disassembly.size());
+                    if (!this->m_disassembling) {
+                        ImGuiListClipper clipper;
+                        clipper.Begin(this->m_disassembly.size());
 
-                    ImGui::TableHeadersRow();
-                    while (clipper.Step()) {
-                        for (u64 i = clipper.DisplayStart; i < clipper.DisplayEnd; i++) {
-                            ImGui::TableNextRow();
-                            ImGui::TableNextColumn();
-                            if (ImGui::Selectable(("##DisassemblyLine"s + std::to_string(i)).c_str(), false, ImGuiSelectableFlags_SpanAllColumns)) {
-                                EventManager::post<RequestSelectionChange>(Region { this->m_disassembly[i].offset, this->m_disassembly[i].size });
+                        ImGui::TableHeadersRow();
+                        while (clipper.Step()) {
+                            for (u64 i = clipper.DisplayStart; i < clipper.DisplayEnd; i++) {
+                                const auto &instruction = this->m_disassembly[i];
+                                ImGui::TableNextRow();
+                                ImGui::TableNextColumn();
+                                if (ImGui::Selectable(("##DisassemblyLine"s + std::to_string(i)).c_str(), false, ImGuiSelectableFlags_SpanAllColumns)) {
+                                    EventManager::post<RequestSelectionChange>(Region { instruction.offset, instruction.size });
+                                }
+                                ImGui::SameLine();
+                                ImGui::TextFormatted("0x{0:X}", instruction.address);
+                                ImGui::TableNextColumn();
+                                ImGui::TextFormatted("0x{0:X}", instruction.offset);
+                                ImGui::TableNextColumn();
+                                ImGui::TextUnformatted(instruction.bytes.c_str());
+                                ImGui::TableNextColumn();
+                                ImGui::TextFormattedColored(ImColor(0xFFD69C56), "{}", instruction.mnemonic);
+                                ImGui::SameLine();
+                                ImGui::TextUnformatted(instruction.operators.c_str());
                             }
-                            ImGui::SameLine();
-                            ImGui::TextFormatted("0x{0:X}", this->m_disassembly[i].address);
-                            ImGui::TableNextColumn();
-                            ImGui::TextFormatted("0x{0:X}", this->m_disassembly[i].offset);
-                            ImGui::TableNextColumn();
-                            ImGui::TextUnformatted(this->m_disassembly[i].bytes.c_str());
-                            ImGui::TableNextColumn();
-                            ImGui::TextFormattedColored(ImColor(0xFFD69C56), "{}", this->m_disassembly[i].mnemonic);
-                            ImGui::SameLine();
-                            ImGui::TextUnformatted(this->m_disassembly[i].operators.c_str());
                         }
-                    }
 
-                    clipper.End();
+                        clipper.End();
+                    }
 
                     ImGui::EndTable();
                 }

plugins/builtin/source/content/views/view_provider_settings.cpp

@@ -52,11 +52,11 @@ namespace hex::plugin::builtin {
         }
     }
 
-    bool ViewProviderSettings::hasViewMenuItemEntry() {
+    bool ViewProviderSettings::hasViewMenuItemEntry() const {
         return this->isAvailable();
     }
 
-    bool ViewProviderSettings::isAvailable() {
+    bool ViewProviderSettings::isAvailable() const {
         auto provider = hex::ImHexApi::Provider::get();
 
         return provider != nullptr && provider->hasInterface();

plugins/builtin/source/content/views/view_settings.cpp

@@ -21,7 +21,6 @@ namespace hex::plugin::builtin {
 
     void ViewSettings::drawContent() {
 
-        ImGui::SetNextWindowSize(ImVec2(500, 300) * SharedData::globalScale, ImGuiCond_Always);
         if (ImGui::BeginPopupModal(View::toWindowName("hex.builtin.view.settings.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoResize)) {
             if (ImGui::BeginTabBar("settings")) {
                 for (auto &[category, entries] : ContentRegistry::Settings::getEntries()) {

plugins/builtin/source/lang/de_DE.cpp

@@ -185,6 +185,7 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.view.hexeditor.script.script.title", "Loader Script: Skript öffnen" },
                     { "hex.builtin.view.hexeditor.script.file", "Datei" },
                     { "hex.builtin.view.hexeditor.script.file.title", "Loader Script: Datei öffnen" },
+                    { "hex.builtin.view.hexeditor.processing", "Importieren / Exportieren" },
 
                     { "hex.builtin.view.hexeditor.menu.file.open_file", "Datei öffnen..." },
                     { "hex.builtin.view.hexeditor.menu.file.open_recent", "Kürzlich geöffnete Dateien" },

plugins/builtin/source/lang/en_US.cpp

@@ -188,7 +188,7 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.view.hexeditor.script.script.title", "Loader Script: Open Script" },
                     { "hex.builtin.view.hexeditor.script.file", "File" },
                     { "hex.builtin.view.hexeditor.script.file.title", "Loader Script: Open File" },
-                    { "hex.builtin.view.hexeditor.processing", "Processing" },
+                    { "hex.builtin.view.hexeditor.processing", "Importing / Exporting" },
 
                     { "hex.builtin.view.hexeditor.menu.file.open_file", "Open File..." },
                     { "hex.builtin.view.hexeditor.menu.file.open_recent", "Open Recent" },

plugins/builtin/source/lang/it_IT.cpp

@@ -188,6 +188,7 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.view.hexeditor.script.script.title", "Caricatore Script: Apri Script" },
                     { "hex.builtin.view.hexeditor.script.file", "File" },
                     { "hex.builtin.view.hexeditor.script.file.title", "Caricatore Script: Apri File" },
+                    //{ "hex.builtin.view.hexeditor.processing", "Importing / Exporting" },
 
                     { "hex.builtin.view.hexeditor.menu.file.open_file", "Apri File..." },
                     { "hex.builtin.view.hexeditor.menu.file.save", "Salva" },

plugins/builtin/source/lang/zh_CN.cpp

@@ -185,6 +185,7 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.view.hexeditor.script.script.title", "加载器脚本：打开脚本" },
                     { "hex.builtin.view.hexeditor.script.file", "文件" },
                     { "hex.builtin.view.hexeditor.script.file.title", "加载器脚本：打开文件" },
+                    //{ "hex.builtin.view.hexeditor.processing", "Importing / Exporting" },
 
                     { "hex.builtin.view.hexeditor.menu.file.open_file", "打开文件..." },
                     { "hex.builtin.view.hexeditor.menu.file.open_recent", "打开最近" },

plugins/libimhex/CMakeLists.txt

@@ -13,7 +13,7 @@ set_target_properties(microtar PROPERTIES POSITION_INDEPENDENT_CODE ON)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../external/nativefiledialog ${CMAKE_CURRENT_BINARY_DIR}/external/nativefiledialog EXCLUDE_FROM_ALL)
 set_target_properties(nfd PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
-set(LIBROMFS_RESOURCE_LOCATION ${CMAKE_SOURCE_DIR}/res/resources)
+set(LIBROMFS_RESOURCE_LOCATION ${IMHEX_BASE_FOLDER}/res/resources)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../external/libromfs ${CMAKE_CURRENT_BINARY_DIR}/external/libromfs EXCLUDE_FROM_ALL)
 set_target_properties(libromfs PROPERTIES POSITION_INDEPENDENT_CODE ON)
 

plugins/libimhex/include/hex/pattern_language/ast_node.hpp

@@ -718,16 +718,14 @@ namespace hex::pl {
                     LogConsole::abortEvaluation("pointer base function needs exactly one parameter", node);
 
                 if (auto pointerPattern = dynamic_cast<PatternDataPointer*>(pattern)) {
-                    u128 value = 0;
-                    evaluator->getProvider()->read(pattern->getOffset(), &value, pattern->getSize());
-                    value = hex::changeEndianess(value, pattern->getSize(), pattern->getEndian());
+                    u128 pointerValue = pointerPattern->getPointedAtAddress();
 
-                    auto result = function.func(evaluator, { value });
+                    auto result = function.func(evaluator, { pointerValue });
 
                     if (!result.has_value())
                         LogConsole::abortEvaluation("pointer base function did not return a value", node);
 
-                    pointerPattern->rebase(Token::literalToUnsigned(result.value()));
+                    pointerPattern->setPointedAtAddress(Token::literalToUnsigned(result.value()) + pointerValue);
                 } else {
                     LogConsole::abortEvaluation("pointer_base attribute may only be applied to a pointer");
                 }
@@ -1130,24 +1128,27 @@ namespace hex::pl {
                 }, offset->getValue());
             }
 
-            auto offset = evaluator->dataOffset();
+            auto startOffset = evaluator->dataOffset();
 
             auto sizePattern = this->m_sizeType->createPatterns(evaluator).front();
             ON_SCOPE_EXIT { delete sizePattern; };
 
-            auto pattern = new PatternDataPointer(offset, sizePattern->getSize(), evaluator);
+            auto pattern = new PatternDataPointer(startOffset, sizePattern->getSize(), evaluator);
             pattern->setVariableName(this->m_name);
 
-            applyVariableAttributes(evaluator, this, pattern);
-
-            offset = evaluator->dataOffset();
+            auto endOffset = evaluator->dataOffset();
 
             {
                 u128 pointerAddress = 0;
                 evaluator->getProvider()->read(pattern->getOffset(), &pointerAddress, pattern->getSize());
                 pointerAddress = hex::changeEndianess(pointerAddress, sizePattern->getSize(), sizePattern->getEndian());
 
-                evaluator->dataOffset() = pointerAddress;
+                evaluator->dataOffset() = startOffset;
+
+                pattern->setPointedAtAddress(pointerAddress);
+                applyVariableAttributes(evaluator, this, pattern);
+
+                evaluator->dataOffset() = pattern->getPointedAtAddress();
 
                 auto pointedAtPattern = this->m_type->createPatterns(evaluator).front();
 
@@ -1155,7 +1156,7 @@ namespace hex::pl {
                 pattern->setEndian(sizePattern->getEndian());
             }
 
-            evaluator->dataOffset() = offset;
+            evaluator->dataOffset() = endOffset;
 
             return { pattern };
         }
@@ -1716,15 +1717,21 @@ namespace hex::pl {
                     currPattern = newPattern;
                 }
 
-                if (auto structPattern = dynamic_cast<PatternDataStruct*>(currPattern))
+                PatternData *indexPattern;
+                if (currPattern->isLocal())
+                    indexPattern = std::get<PatternData*>(evaluator->getStack()[currPattern->getOffset()]);
+                else
+                    indexPattern = currPattern;
+
+                if (auto structPattern = dynamic_cast<PatternDataStruct*>(indexPattern))
                     searchScope = structPattern->getMembers();
-                else if (auto unionPattern = dynamic_cast<PatternDataUnion*>(currPattern))
+                else if (auto unionPattern = dynamic_cast<PatternDataUnion*>(indexPattern))
                     searchScope = unionPattern->getMembers();
-                else if (auto bitfieldPattern = dynamic_cast<PatternDataBitfield*>(currPattern))
+                else if (auto bitfieldPattern = dynamic_cast<PatternDataBitfield*>(indexPattern))
                     searchScope = bitfieldPattern->getFields();
-                else if (auto dynamicArrayPattern = dynamic_cast<PatternDataDynamicArray*>(currPattern))
+                else if (auto dynamicArrayPattern = dynamic_cast<PatternDataDynamicArray*>(indexPattern))
                     searchScope = dynamicArrayPattern->getEntries();
-                else if (auto staticArrayPattern = dynamic_cast<PatternDataStaticArray*>(currPattern))
+                else if (auto staticArrayPattern = dynamic_cast<PatternDataStaticArray*>(indexPattern))
                     searchScope = { staticArrayPattern->getTemplate() };
 
             }

plugins/libimhex/include/hex/pattern_language/pattern_data.hpp

@@ -378,7 +378,7 @@ namespace hex::pl {
             ImGui::TableNextColumn();
             ImGui::TextFormattedColored(ImColor(0xFF9BC64D), "{}", this->getFormattedName());
             ImGui::TableNextColumn();
-            ImGui::TextFormatted("*(0x{0})", data);
+            ImGui::TextFormatted("*(0x{0:X})", data);
 
             if (open) {
                 this->m_pointedAt->createEntry(provider);
@@ -423,6 +423,15 @@ namespace hex::pl {
         void setPointedAtPattern(PatternData *pattern) {
             this->m_pointedAt = pattern;
             this->m_pointedAt->setVariableName(hex::format("*({})", this->getVariableName()));
+            this->m_pointedAt->setOffset(this->m_pointedAtAddress);
+        }
+
+        void setPointedAtAddress(u64 address) {
+            this->m_pointedAtAddress = address;
+        }
+
+        [[nodiscard]] u64 getPointedAtAddress() const {
+            return this->m_pointedAtAddress;
         }
 
         [[nodiscard]] PatternData* getPointedAtPattern() {
@@ -440,14 +449,18 @@ namespace hex::pl {
         }
 
         void rebase(u64 base) {
-            if (this->m_pointedAt != nullptr)
-                this->m_pointedAt->setOffset((this->m_pointedAt->getOffset() - this->m_pointerBase) + base);
+            if (this->m_pointedAt != nullptr) {
+                this->m_pointedAtAddress = (this->m_pointedAt->getOffset() - this->m_pointerBase) + base;
+                this->m_pointedAt->setOffset(this->m_pointedAtAddress);
+            }
 
             this->m_pointerBase = base;
         }
 
     private:
         PatternData *m_pointedAt = nullptr;
+        u64 m_pointedAtAddress = 0;
+
         u64 m_pointerBase = 0;
     };
 

plugins/libimhex/include/hex/views/view.hpp

@@ -33,8 +33,8 @@ namespace hex {
         virtual void drawContent() = 0;
         virtual void drawAlwaysVisible() { }
         virtual void drawMenu();
-        virtual bool isAvailable();
-        virtual bool shouldProcess() { return this->isAvailable() && this->getWindowOpenState(); }
+        virtual bool isAvailable() const;
+        virtual bool shouldProcess() const { return this->isAvailable() && this->getWindowOpenState(); }
 
         static void doLater(std::function<void()> &&function);
         static std::vector<std::function<void()>>& getDeferedCalls();
@@ -45,11 +45,12 @@ namespace hex {
         static void showErrorPopup(const std::string &errorMessage);
         static void showFatalPopup(const std::string &errorMessage);
 
-        virtual bool hasViewMenuItemEntry();
-        virtual ImVec2 getMinSize();
-        virtual ImVec2 getMaxSize();
+        virtual bool hasViewMenuItemEntry() const;
+        virtual ImVec2 getMinSize() const;
+        virtual ImVec2 getMaxSize() const;
 
         bool& getWindowOpenState();
+        const bool& getWindowOpenState() const;
 
         [[nodiscard]] const std::string& getUnlocalizedName() const;
 

plugins/libimhex/source/views/view.cpp

@@ -14,7 +14,7 @@ namespace hex {
 
     void View::drawMenu() { }
 
-    bool View::isAvailable() {
+    bool View::isAvailable() const {
         return ImHexApi::Provider::isValid() && ImHexApi::Provider::get()->isAvailable();
     }
 
@@ -80,15 +80,15 @@ namespace hex {
         View::doLater([] { ImGui::OpenPopup("hex.common.fatal"_lang); });
     }
 
-    bool View::hasViewMenuItemEntry() {
+    bool View::hasViewMenuItemEntry() const {
         return true;
     }
 
-    ImVec2 View::getMinSize() {
+    ImVec2 View::getMinSize() const {
         return ImVec2(480, 720) * SharedData::globalScale;
     }
 
-    ImVec2 View::getMaxSize() {
+    ImVec2 View::getMaxSize() const {
         return { FLT_MAX, FLT_MAX };
     }
 
@@ -97,6 +97,10 @@ namespace hex {
         return this->m_windowOpen;
     }
 
+    const bool& View::getWindowOpenState() const {
+        return this->m_windowOpen;
+    }
+
     const std::string& View::getUnlocalizedName() const {
         return this->m_unlocalizedViewName;
     }

tests/pattern_language/include/test_patterns/test_pattern_pointers.hpp

@@ -10,6 +10,8 @@ namespace hex::test {
             // placementPointer
             {
                 auto placementPointer = create<PatternDataPointer>("", "placementPointer", 0x0C, sizeof(u8), nullptr);
+                placementPointer->setPointedAtAddress(0x49);
+
                 auto pointedTo = create<PatternDataUnsigned>("u32", "", 0x49, sizeof(u32), nullptr);
                 placementPointer->setPointedAtPattern(pointedTo);
                 addPattern(placementPointer);