Refactored libimhex to and includes to better represent it as library

plugins/libimhex/include/hex/api/content_registry.hpp

@@ -0,0 +1,148 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <concepts>
+#include <functional>
+#include <map>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+namespace hex {
+
+    class View;
+    namespace lang { class ASTNode; }
+
+    /*
+        The Content Registry is the heart of all features in ImHex that are in some way extendable by Plugins.
+        It allows you to add/register new content that will be picked up and used by the ImHex core or by other
+        plugins when needed.
+    */
+    class ContentRegistry {
+    public:
+        ContentRegistry() = delete;
+
+        /* Settings Registry. Allows adding of new entries into the ImHex preferences window. */
+        struct Settings {
+            Settings() = delete;
+
+            struct Entry {
+                std::string name;
+                std::function<bool(nlohmann::json&)> callback;
+            };
+
+            static void load();
+            static void store();
+
+            static void add(std::string_view category, std::string_view name, s64 defaultValue, const std::function<bool(nlohmann::json&)> &callback);
+            static void add(std::string_view category, std::string_view name, std::string_view defaultValue, const std::function<bool(nlohmann::json&)> &callback);
+
+            static std::map<std::string, std::vector<Entry>>& getEntries();
+            static nlohmann::json& getSettingsData();
+        };
+
+        /* Events Registry. Allows to define new events that can be used by other plugins later on subscribe to */
+        struct Events {
+            Events() = delete;
+
+            static auto get(std::string_view name);
+        };
+
+        /* Command Palette Command Registry. Allows adding of new commands to the command palette */
+        struct CommandPaletteCommands {
+            CommandPaletteCommands() = delete;
+
+            enum class Type : u32 {
+                SymbolCommand,
+                KeywordCommand
+            };
+
+            struct Entry {
+                Type type;
+                std::string command;
+                std::string description;
+                std::function<std::string(std::string)> callback;
+            };
+
+            static void add(Type type, std::string_view command, std::string_view description, const std::function<std::string(std::string)> &callback);
+            static std::vector<Entry>& getEntries();
+        };
+
+        /* Pattern Language Function Registry. Allows adding of new functions that may be used inside the pattern language */
+        struct PatternLanguageFunctions {
+            PatternLanguageFunctions() = delete;
+
+            constexpr static u32 UnlimitedParameters   = 0xFFFF'FFFF;
+            constexpr static u32 MoreParametersThan    = 0x8000'0000;
+            constexpr static u32 LessParametersThan    = 0x4000'0000;
+            constexpr static u32 NoParameters          = 0x0000'0000;
+
+            struct Function {
+                u32 parameterCount;
+                std::function<hex::lang::ASTNode*(std::vector<hex::lang::ASTNode*>)> func;
+            };
+
+            static void add(std::string_view name, u32 parameterCount, const std::function<hex::lang::ASTNode*(std::vector<hex::lang::ASTNode*>)> &func);
+            static std::map<std::string, ContentRegistry::PatternLanguageFunctions::Function>& getEntries();
+        };
+
+        /* View Registry. Allows adding of new windows */
+        struct Views {
+            Views() = delete;
+
+            template<std::derived_from<View> T, typename ... Args>
+            static T* add(Args&& ... args) {
+                return static_cast<T*>(add(new T(std::forward<Args>(args)...)));
+            }
+
+            static std::vector<View*>& getEntries();
+
+        private:
+            static View* add(View *view);
+
+
+        };
+
+        /* Tools Registry. Allows adding new entries to the tools window */
+        struct Tools {
+            Tools() = delete;
+
+            struct Entry {
+                std::string name;
+                std::function<void()> function;
+            };
+
+            static void add(std::string_view name, const std::function<void()> &function);
+
+            static std::vector<Entry>& getEntries();
+        };
+
+        /* Data Inspector Registry. Allows adding of new types to the data inspector */
+        struct DataInspector {
+            DataInspector() = delete;
+
+            enum class NumberDisplayStyle {
+                Decimal,
+                Hexadecimal,
+                Octal
+            };
+
+            using DisplayFunction = std::function<void()>;
+            using GeneratorFunction = std::function<DisplayFunction(const std::vector<u8>&, std::endian, NumberDisplayStyle)>;
+
+            struct Entry {
+                std::string name;
+                size_t requiredSize;
+                GeneratorFunction generatorFunction;
+            };
+
+            static void add(std::string_view name, size_t requiredSize, GeneratorFunction function);
+
+            static std::vector<Entry>& getEntries();
+        };
+    };
+
+}

plugins/libimhex/include/hex/api/event.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <vector>
+#include <functional>
+
+namespace hex {
+
+    enum class Events : u32 {
+        FileLoaded,
+        DataChanged,
+        PatternChanged,
+        FileDropped,
+        WindowClosing,
+        RegionSelected,
+
+        SelectionChangeRequest,
+
+        AddBookmark,
+        AppendPatternLanguageCode,
+
+        ProjectFileStore,
+        ProjectFileLoad,
+
+        SettingsChanged,
+
+
+        /* This is not a real event but a flag to show all events after this one are plugin ones */
+        Events_BuiltinEnd
+    };
+
+    struct EventHandler {
+        void *owner;
+        Events eventType;
+        std::function<void(const void*)> callback;
+    };
+
+    class EventManager {
+    public:
+        static void post(Events eventType, const void *userData);
+        static void subscribe(Events eventType, void *owner, std::function<void(const void*)> callback);
+        static void unsubscribe(Events eventType, void *sender);
+    };
+
+}

plugins/libimhex/include/hex/helpers/shared_data.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <any>
+#include <functional>
+#include <vector>
+#include <map>
+
+#include <hex/api/content_registry.hpp>
+#include <hex/api/event.hpp>
+#include <hex/views/view.hpp>
+
+#include <imgui.h>
+#include <nlohmann/json.hpp>
+
+namespace hex { class SharedData; }
+
+namespace hex::plugin::internal {
+    void initializePlugin(SharedData &sharedData);
+}
+
+namespace hex {
+
+    namespace prv { class Provider; }
+
+    class SharedData {
+        SharedData() = default;
+    public:
+        SharedData(const SharedData&) = delete;
+        SharedData(SharedData&&) = delete;
+
+        friend class Window;
+
+        template<typename T>
+        static T& getVariable(std::string variableName) {
+            return std::any_cast<T&>(SharedData::sharedVariables[variableName]);
+        }
+
+        template<typename T>
+        static void setVariable(std::string variableName, T value) {
+            SharedData::sharedVariables[variableName] = value;
+        }
+
+    public:
+        static std::vector<EventHandler> eventHandlers;
+        static std::vector<std::function<void()>> deferredCalls;
+        static prv::Provider *currentProvider;
+        static std::map<std::string, std::vector<ContentRegistry::Settings::Entry>> settingsEntries;
+        static nlohmann::json settingsJson;
+        static std::map<std::string, Events> customEvents;
+        static u32 customEventsLastId;
+        static std::vector<ContentRegistry::CommandPaletteCommands::Entry> commandPaletteCommands;
+        static std::map<std::string, ContentRegistry::PatternLanguageFunctions::Function> patternLanguageFunctions;
+        static std::vector<View*> views;
+        static std::vector<ContentRegistry::Tools::Entry> toolsEntries;
+        static std::vector<ContentRegistry::DataInspector::Entry> dataInspectorEntries;
+
+        static int mainArgc;
+        static char **mainArgv;
+
+        static ImVec2 windowPos;
+        static ImVec2 windowSize;
+
+    private:
+        static std::map<std::string, std::any> sharedVariables;
+    };
+
+}

plugins/libimhex/include/hex/helpers/utils.hpp

@@ -0,0 +1,207 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <array>
+#include <cstring>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#ifdef __MINGW32__
+#include <winsock.h>
+#else
+#include <arpa/inet.h>
+#endif
+
+#if defined(__APPLE__) || defined(__FreeBSD__)
+    #define off64_t off_t
+    #define fopen64 fopen
+    #define fseeko64 fseek
+    #define ftello64 ftell
+#else
+    template<>
+    struct std::is_integral<u128> : public std::true_type { };
+    template<>
+    struct std::is_integral<s128> : public std::true_type { };
+    template<>
+    struct std::is_signed<s128>   : public std::true_type { };
+#endif
+
+#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 12000
+#if __has_include(<concepts>)
+// Make sure we break when derived_from is implemented in libc++. Then we can fix a compatibility version above
+#include <concepts>
+#endif
+// libcxx 12 still doesn't have many default concepts implemented, as a result we need to define it ourself using clang built-ins.
+// [concept.derived] (patch from https://reviews.llvm.org/D74292)
+namespace hex {
+template<class _Dp, class _Bp>
+concept derived_from =
+  __is_base_of(_Bp, _Dp) && __is_convertible_to(const volatile _Dp*, const volatile _Bp*);
+}
+
+// [concepts.arithmetic]
+namespace hex {
+template<class _Tp>
+concept integral = __is_integral(_Tp);
+
+template<class _Tp>
+concept signed_integral = integral<_Tp> && __is_signed(_Tp);
+
+template<class _Tp>
+concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
+
+template<class _Tp>
+concept floating_point = __is_floating_point(_Tp);
+}
+#else
+// Assume supported
+#include <concepts>
+namespace hex {
+    using std::derived_from;
+
+    using std::integral;
+    using std::signed_integral;
+    using std::unsigned_integral;
+    using std::floating_point;
+}
+#endif
+
+#define TOKEN_CONCAT_IMPL(x, y) x ## y
+#define TOKEN_CONCAT(x, y) TOKEN_CONCAT_IMPL(x, y)
+
+namespace hex {
+
+    template<typename ... Args>
+    inline std::string format(const char *format, Args ... args) {
+        ssize_t size = snprintf( nullptr, 0, format, args ... );
+
+        if (size <= 0)
+            return "";
+
+        std::vector<char> buffer(size + 1, 0x00);
+        snprintf(buffer.data(), size + 1, format, args ...);
+
+        return std::string(buffer.data(), buffer.data() + size);
+    }
+
+    [[nodiscard]] constexpr inline u64 extract(u8 from, u8 to, const hex::unsigned_integral auto &value) {
+        std::remove_cvref_t<decltype(value)> mask = (std::numeric_limits<std::remove_cvref_t<decltype(value)>>::max() >> (((sizeof(value) * 8) - 1) - (from - to))) << to;
+        return (value & mask) >> to;
+    }
+
+    template<hex::integral T>
+    [[nodiscard]] constexpr inline T signExtend(T value, u8 currWidth, u8 targetWidth) {
+        T mask = 1LLU << (currWidth - 1);
+        return (((value ^ mask) - mask) << ((sizeof(T) * 8) - targetWidth)) >> ((sizeof(T) * 8) - targetWidth);
+    }
+
+    std::string toByteString(u64 bytes);
+    std::string makePrintable(char c);
+
+    template<typename T>
+    struct always_false : std::false_type {};
+
+    template<typename T>
+    constexpr T changeEndianess(T value, std::endian endian) {
+        if (endian == std::endian::native)
+            return value;
+
+        if constexpr (sizeof(T) == 1)
+            return value;
+        else if constexpr (sizeof(T) == 2)
+            return __builtin_bswap16(value);
+        else if constexpr (sizeof(T) == 4)
+            return __builtin_bswap32(value);
+        else if constexpr (sizeof(T) == 8)
+            return __builtin_bswap64(value);
+        else
+                static_assert(always_false<T>::value, "Invalid type provided!");
+    }
+
+    template<typename T>
+    constexpr T changeEndianess(T value, size_t size, std::endian endian) {
+        if (endian == std::endian::native)
+            return value;
+
+        if (size == 1)
+            return value;
+        else if (size == 2)
+            return __builtin_bswap16(value);
+        else if (size == 4)
+            return __builtin_bswap32(value);
+        else if (size == 8)
+            return __builtin_bswap64(value);
+        else if (size == 16) {
+            u64 parts[2];
+            std::memcpy(parts, &value, size);
+            return u128(parts[1]) << 64 | u128(parts[0]);
+        }
+        else
+            throw std::invalid_argument("Invalid value size!");
+    }
+
+    template< class T >
+    constexpr T bit_width(T x) noexcept {
+        return std::numeric_limits<T>::digits - std::countl_zero(x);
+    }
+
+    template<typename T>
+    constexpr T bit_ceil(T x) noexcept {
+        if (x <= 1u)
+            return T(1);
+
+        return T(1) << bit_width(T(x - 1));
+    }
+
+    inline std::string toEngineeringString(double value) {
+        constexpr std::array prefixes = { "a", "f", "p", "n", "u", "m", "", "k", "M", "G", "T", "P", "E" };
+
+        int8_t prefixIndex = 6;
+
+        while (prefixIndex != 0 && prefixIndex != 12 && (value >= 1000 || value < 1) && value != 0) {
+            if (value >= 1000) {
+                value /= 1000;
+                prefixIndex++;
+            } else if (value < 1) {
+                value *= 1000;
+                prefixIndex--;
+            }
+        }
+
+        return std::to_string(value).substr(0, 5) + prefixes[prefixIndex];
+    }
+
+    std::vector<u8> readFile(std::string_view path);
+
+    #define SCOPE_EXIT(func) ScopeExit TOKEN_CONCAT(scopeGuard, __COUNTER__)([&] { func })
+    class ScopeExit {
+    public:
+        ScopeExit(std::function<void()> func) : m_func(func) {}
+        ~ScopeExit() { if (this->m_func != nullptr) this->m_func(); }
+
+        void release() {
+            this->m_func = nullptr;
+        }
+
+    private:
+        std::function<void()> m_func;
+    };
+
+    struct Region {
+        u64 address;
+        size_t size;
+    };
+
+    struct Bookmark {
+        Region region;
+
+        std::vector<char> name;
+        std::vector<char> comment;
+        u32 color;
+    };
+}

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

@@ -0,0 +1,505 @@
+#pragma once
+
+#include "token.hpp"
+
+#include <bit>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+namespace hex::lang {
+
+    class ASTNode {
+    public:
+        constexpr ASTNode() = default;
+        constexpr virtual ~ASTNode() = default;
+        constexpr ASTNode(const ASTNode &) = default;
+
+        [[nodiscard]] constexpr u32 getLineNumber() const { return this->m_lineNumber; }
+        constexpr void setLineNumber(u32 lineNumber) { this->m_lineNumber = lineNumber; }
+
+        virtual ASTNode* clone() const = 0;
+
+    private:
+        u32 m_lineNumber = 1;
+    };
+
+    class ASTNodeIntegerLiteral : public ASTNode {
+    public:
+        ASTNodeIntegerLiteral(Token::IntegerLiteral literal) : ASTNode(), m_literal(literal) { }
+
+        ASTNodeIntegerLiteral(const ASTNodeIntegerLiteral&) = default;
+
+        ASTNode* clone() const override {
+            return new ASTNodeIntegerLiteral(*this);
+        }
+
+        [[nodiscard]] const auto& getValue() const {
+            return this->m_literal.second;
+        }
+
+        [[nodiscard]] Token::ValueType getType() const {
+            return this->m_literal.first;
+        }
+
+    private:
+        Token::IntegerLiteral m_literal;
+    };
+
+    class ASTNodeNumericExpression : public ASTNode {
+    public:
+        ASTNodeNumericExpression(ASTNode *left, ASTNode *right, Token::Operator op)
+                : ASTNode(), m_left(left), m_right(right), m_operator(op) { }
+
+        ~ASTNodeNumericExpression() override {
+            delete this->m_left;
+            delete this->m_right;
+        }
+
+        ASTNodeNumericExpression(const ASTNodeNumericExpression &other) : ASTNode(other) {
+            this->m_operator = other.m_operator;
+            this->m_left = other.m_left->clone();
+            this->m_right = other.m_right->clone();
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeNumericExpression(*this);
+        }
+
+        ASTNode *getLeftOperand() { return this->m_left; }
+        ASTNode *getRightOperand() { return this->m_right; }
+        Token::Operator getOperator() { return this->m_operator; }
+
+    private:
+        ASTNode *m_left, *m_right;
+        Token::Operator m_operator;
+    };
+
+    class ASTNodeTernaryExpression : public ASTNode {
+    public:
+        ASTNodeTernaryExpression(ASTNode *first, ASTNode *second, ASTNode *third, Token::Operator op)
+                : ASTNode(), m_first(first), m_second(second), m_third(third), m_operator(op) { }
+
+        ~ASTNodeTernaryExpression() override {
+            delete this->m_first;
+            delete this->m_second;
+            delete this->m_third;
+        }
+
+        ASTNodeTernaryExpression(const ASTNodeTernaryExpression &other) : ASTNode(other) {
+            this->m_operator = other.m_operator;
+            this->m_first = other.m_first->clone();
+            this->m_second = other.m_second->clone();
+            this->m_third = other.m_third->clone();
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeTernaryExpression(*this);
+        }
+
+        ASTNode *getFirstOperand() { return this->m_first; }
+        ASTNode *getSecondOperand() { return this->m_second; }
+        ASTNode *getThirdOperand() { return this->m_third; }
+        Token::Operator getOperator() { return this->m_operator; }
+
+    private:
+        ASTNode *m_first, *m_second, *m_third;
+        Token::Operator m_operator;
+    };
+
+    class ASTNodeBuiltinType : public ASTNode {
+    public:
+        constexpr explicit ASTNodeBuiltinType(Token::ValueType type)
+                : ASTNode(), m_type(type) { }
+
+        [[nodiscard]] constexpr const auto& getType() const { return this->m_type; }
+
+        ASTNode* clone() const override {
+            return new ASTNodeBuiltinType(*this);
+        }
+
+    private:
+        const Token::ValueType m_type;
+    };
+
+    class ASTNodeTypeDecl : public ASTNode {
+    public:
+        ASTNodeTypeDecl(std::string_view name, ASTNode *type, std::optional<std::endian> endian = { })
+                : ASTNode(), m_name(name), m_type(type), m_endian(endian) { }
+
+        ASTNodeTypeDecl(const ASTNodeTypeDecl& other) : ASTNode(other) {
+            this->m_name = other.m_name;
+            this->m_type = other.m_type->clone();
+            this->m_endian = other.m_endian;
+        }
+
+        ~ASTNodeTypeDecl() override {
+            delete this->m_type;
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeTypeDecl(*this);
+        }
+
+        [[nodiscard]] std::string_view getName() const { return this->m_name; }
+        [[nodiscard]] ASTNode* getType() { return this->m_type; }
+        [[nodiscard]] std::optional<std::endian> getEndian() const { return this->m_endian; }
+
+    private:
+        std::string m_name;
+        ASTNode *m_type;
+        std::optional<std::endian> m_endian;
+    };
+
+    class ASTNodeVariableDecl : public ASTNode {
+    public:
+        ASTNodeVariableDecl(std::string_view name, ASTNode *type, ASTNode *placementOffset = nullptr)
+                : ASTNode(), m_name(name), m_type(type), m_placementOffset(placementOffset) { }
+
+        ASTNodeVariableDecl(const ASTNodeVariableDecl &other) : ASTNode(other) {
+            this->m_name = other.m_name;
+            this->m_type = other.m_type->clone();
+
+            if (other.m_placementOffset != nullptr)
+                this->m_placementOffset = other.m_placementOffset->clone();
+            else
+                this->m_placementOffset = nullptr;
+        }
+
+        ~ASTNodeVariableDecl() override {
+            delete this->m_type;
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeVariableDecl(*this);
+        }
+
+        [[nodiscard]] std::string_view getName() const { return this->m_name; }
+        [[nodiscard]] constexpr ASTNode* getType() const { return this->m_type; }
+        [[nodiscard]] constexpr auto getPlacementOffset() const { return this->m_placementOffset; }
+
+    private:
+        std::string m_name;
+        ASTNode *m_type;
+        ASTNode *m_placementOffset;
+    };
+
+    class ASTNodeArrayVariableDecl : public ASTNode {
+    public:
+        ASTNodeArrayVariableDecl(std::string_view name, ASTNode *type, ASTNode *size, ASTNode *placementOffset = nullptr)
+                : ASTNode(), m_name(name), m_type(type), m_size(size), m_placementOffset(placementOffset) { }
+
+        ASTNodeArrayVariableDecl(const ASTNodeArrayVariableDecl &other) : ASTNode(other) {
+            this->m_name = other.m_name;
+            this->m_type = other.m_type->clone();
+            if (other.m_size != nullptr)
+                this->m_size = other.m_size->clone();
+            else
+                this->m_size = nullptr;
+
+            if (other.m_placementOffset != nullptr)
+                this->m_placementOffset = other.m_placementOffset->clone();
+            else
+                this->m_placementOffset = nullptr;
+        }
+
+        ~ASTNodeArrayVariableDecl() override {
+            delete this->m_type;
+            delete this->m_size;
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeArrayVariableDecl(*this);
+        }
+
+        [[nodiscard]] std::string_view getName() const { return this->m_name; }
+        [[nodiscard]] constexpr ASTNode* getType() const { return this->m_type; }
+        [[nodiscard]] constexpr ASTNode* getSize() const { return this->m_size; }
+        [[nodiscard]] constexpr auto getPlacementOffset() const { return this->m_placementOffset; }
+
+    private:
+        std::string m_name;
+        ASTNode *m_type;
+        ASTNode *m_size;
+        ASTNode *m_placementOffset;
+    };
+
+    class ASTNodePointerVariableDecl : public ASTNode {
+    public:
+        ASTNodePointerVariableDecl(std::string_view name, ASTNode *type, ASTNode *sizeType, ASTNode *placementOffset = nullptr)
+                : ASTNode(), m_name(name), m_type(type), m_sizeType(sizeType), m_placementOffset(placementOffset) { }
+
+        ASTNodePointerVariableDecl(const ASTNodePointerVariableDecl &other) : ASTNode(other) {
+            this->m_name = other.m_name;
+            this->m_type = other.m_type->clone();
+            this->m_sizeType = other.m_sizeType->clone();
+
+            if (other.m_placementOffset != nullptr)
+                this->m_placementOffset = other.m_placementOffset->clone();
+            else
+                this->m_placementOffset = nullptr;
+        }
+
+        ~ASTNodePointerVariableDecl() override {
+            delete this->m_type;
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodePointerVariableDecl(*this);
+        }
+
+        [[nodiscard]] std::string_view getName() const { return this->m_name; }
+        [[nodiscard]] constexpr ASTNode* getType() const { return this->m_type; }
+        [[nodiscard]] constexpr ASTNode* getSizeType() const { return this->m_sizeType; }
+        [[nodiscard]] constexpr auto getPlacementOffset() const { return this->m_placementOffset; }
+
+    private:
+        std::string m_name;
+        ASTNode *m_type;
+        ASTNode *m_sizeType;
+        ASTNode *m_placementOffset;
+    };
+
+    class ASTNodeStruct : public ASTNode {
+    public:
+        ASTNodeStruct() : ASTNode() { }
+
+        ASTNodeStruct(const ASTNodeStruct &other) : ASTNode(other) {
+            for (const auto &otherMember : other.getMembers())
+                this->m_members.push_back(otherMember->clone());
+        }
+
+        ~ASTNodeStruct() override {
+            for (auto &member : this->m_members)
+                delete member;
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeStruct(*this);
+        }
+
+        [[nodiscard]] const std::vector<ASTNode*>& getMembers() const { return this->m_members; }
+        void addMember(ASTNode *node) { this->m_members.push_back(node); }
+
+    private:
+        std::vector<ASTNode*> m_members;
+    };
+
+    class ASTNodeUnion : public ASTNode {
+    public:
+        ASTNodeUnion() : ASTNode() { }
+
+        ASTNodeUnion(const ASTNodeUnion &other) : ASTNode(other) {
+            for (const auto &otherMember : other.getMembers())
+                this->m_members.push_back(otherMember->clone());
+        }
+
+        ~ASTNodeUnion() override {
+            for (auto &member : this->m_members)
+                delete member;
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeUnion(*this);
+        }
+
+        [[nodiscard]] const  std::vector<ASTNode*>& getMembers() const { return this->m_members; }
+        void addMember(ASTNode *node) { this->m_members.push_back(node); }
+
+    private:
+        std::vector<ASTNode*> m_members;
+    };
+
+    class ASTNodeEnum : public ASTNode {
+    public:
+        explicit ASTNodeEnum(ASTNode *underlyingType) : ASTNode(), m_underlyingType(underlyingType) { }
+
+        ASTNodeEnum(const ASTNodeEnum &other) : ASTNode(other) {
+            for (const auto &[name, entry] : other.getEntries())
+                this->m_entries.insert({ name, entry->clone() });
+            this->m_underlyingType = other.m_underlyingType->clone();
+        }
+
+        ~ASTNodeEnum() override {
+            for (auto &[name, expr] : this->m_entries)
+                delete expr;
+            delete this->m_underlyingType;
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeEnum(*this);
+        }
+
+        [[nodiscard]] const std::unordered_map<std::string, ASTNode*>& getEntries() const { return this->m_entries; }
+        void addEntry(const std::string &name, ASTNode* expression) { this->m_entries.insert({ name, expression }); }
+
+        [[nodiscard]] ASTNode *getUnderlyingType() { return this->m_underlyingType; }
+
+    private:
+        std::unordered_map<std::string, ASTNode*> m_entries;
+        ASTNode *m_underlyingType;
+    };
+
+    class ASTNodeBitfield : public ASTNode {
+    public:
+        ASTNodeBitfield() : ASTNode() { }
+
+        ASTNodeBitfield(const ASTNodeBitfield &other) : ASTNode(other) {
+            for (const auto &[name, entry] : other.getEntries())
+                this->m_entries.emplace_back(name, entry->clone());
+        }
+
+        ~ASTNodeBitfield() override {
+            for (auto &[name, expr] : this->m_entries)
+                delete expr;
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeBitfield(*this);
+        }
+
+        [[nodiscard]] const std::vector<std::pair<std::string, ASTNode*>>& getEntries() const { return this->m_entries; }
+        void addEntry(const std::string &name, ASTNode* size) { this->m_entries.emplace_back(name, size); }
+
+    private:
+        std::vector<std::pair<std::string, ASTNode*>> m_entries;
+    };
+
+    class ASTNodeRValue : public ASTNode {
+    public:
+        explicit ASTNodeRValue(std::vector<std::string> path) : ASTNode(), m_path(std::move(path)) { }
+
+        ASTNodeRValue(const ASTNodeRValue&) = default;
+
+        ASTNode* clone() const override {
+            return new ASTNodeRValue(*this);
+        }
+
+        const std::vector<std::string>& getPath() {
+            return this->m_path;
+        }
+
+    private:
+        std::vector<std::string> m_path;
+    };
+
+    class ASTNodeScopeResolution : public ASTNode {
+    public:
+        explicit ASTNodeScopeResolution(std::vector<std::string> path) : ASTNode(), m_path(std::move(path)) { }
+
+        ASTNodeScopeResolution(const ASTNodeScopeResolution&) = default;
+
+        ASTNode* clone() const override {
+            return new ASTNodeScopeResolution(*this);
+        }
+
+        const std::vector<std::string>& getPath() {
+            return this->m_path;
+        }
+
+    private:
+        std::vector<std::string> m_path;
+    };
+
+    class ASTNodeConditionalStatement : public ASTNode {
+    public:
+        explicit ASTNodeConditionalStatement(ASTNode *condition, std::vector<ASTNode*> trueBody, std::vector<ASTNode*> falseBody)
+            : ASTNode(), m_condition(condition), m_trueBody(std::move(trueBody)), m_falseBody(std::move(falseBody)) { }
+
+        ~ASTNodeConditionalStatement() override {
+            delete this->m_condition;
+
+            for (auto &statement : this->m_trueBody)
+                delete statement;
+            for (auto &statement : this->m_falseBody)
+                delete statement;
+        }
+
+        ASTNodeConditionalStatement(const ASTNodeConditionalStatement &other) : ASTNode(other) {
+            this->m_condition = other.m_condition->clone();
+
+            for (auto &statement : other.m_trueBody)
+                this->m_trueBody.push_back(statement->clone());
+            for (auto &statement : other.m_falseBody)
+                this->m_falseBody.push_back(statement->clone());
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeConditionalStatement(*this);
+        }
+
+        [[nodiscard]] ASTNode* getCondition() {
+            return this->m_condition;
+        }
+
+        [[nodiscard]] const std::vector<ASTNode*>& getTrueBody() const {
+            return this->m_trueBody;
+        }
+
+        [[nodiscard]] const std::vector<ASTNode*>& getFalseBody() const {
+            return this->m_falseBody;
+        }
+
+    private:
+        ASTNode *m_condition;
+        std::vector<ASTNode*> m_trueBody, m_falseBody;
+    };
+
+    class ASTNodeFunctionCall : public ASTNode {
+    public:
+        explicit ASTNodeFunctionCall(std::string_view functionName, std::vector<ASTNode*> params)
+                : ASTNode(), m_functionName(functionName), m_params(std::move(params)) { }
+
+        ~ASTNodeFunctionCall() override {
+            for (auto &param : this->m_params)
+                delete param;
+        }
+
+        ASTNodeFunctionCall(const ASTNodeFunctionCall &other) : ASTNode(other) {
+            this->m_functionName = other.m_functionName;
+
+            for (auto &param : other.m_params)
+                this->m_params.push_back(param->clone());
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeFunctionCall(*this);
+        }
+
+        [[nodiscard]] std::string_view getFunctionName() {
+            return this->m_functionName;
+        }
+
+        [[nodiscard]] const std::vector<ASTNode*>& getParams() const {
+            return this->m_params;
+        }
+
+    private:
+        std::string m_functionName;
+        std::vector<ASTNode*> m_params;
+    };
+
+    class ASTNodeStringLiteral : public ASTNode {
+    public:
+        explicit ASTNodeStringLiteral(std::string_view string) : ASTNode(), m_string(string) { }
+
+        ~ASTNodeStringLiteral() override { }
+
+        ASTNodeStringLiteral(const ASTNodeStringLiteral &other) : ASTNode(other) {
+            this->m_string = other.m_string;
+        }
+
+        ASTNode* clone() const override {
+            return new ASTNodeStringLiteral(*this);
+        }
+
+        [[nodiscard]] std::string_view getString() {
+            return this->m_string;
+        }
+
+    private:
+        std::string m_string;
+    };
+
+
+}

plugins/libimhex/include/hex/lang/evaluator.hpp

@@ -0,0 +1,106 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <hex/providers/provider.hpp>
+#include <hex/helpers/utils.hpp>
+#include <hex/lang/pattern_data.hpp>
+#include <hex/lang/ast_node.hpp>
+
+#include <bit>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace hex::lang {
+
+    class Evaluator {
+    public:
+        enum ConsoleLogLevel {
+            Debug,
+            Info,
+            Warning,
+            Error
+        };
+
+        Evaluator(prv::Provider* &provider, std::endian defaultDataEndian);
+
+        std::optional<std::vector<PatternData*>> evaluate(const std::vector<ASTNode*>& ast);
+        const auto& getConsoleLog() { return this->m_consoleLog; }
+
+    private:
+        std::map<std::string, ASTNode*> m_types;
+        prv::Provider* &m_provider;
+        std::endian m_defaultDataEndian;
+        u64 m_currOffset = 0;
+        std::vector<std::endian> m_endianStack;
+        std::vector<PatternData*> m_globalMembers;
+        std::vector<std::vector<PatternData*>*> m_currMembers;
+
+        std::vector<std::pair<ConsoleLogLevel, std::string>> m_consoleLog;
+
+        using EvaluateError = std::string;
+
+        void emmitDebugInfo(std::string_view message) {
+            this->m_consoleLog.emplace_back(ConsoleLogLevel::Debug, "[-] " + std::string(message));
+        }
+
+        void emmitInfo(std::string_view message) {
+            this->m_consoleLog.emplace_back(ConsoleLogLevel::Info, "[i] " + std::string(message));
+        }
+
+        void emmitWaring(std::string_view message) {
+            this->m_consoleLog.emplace_back(ConsoleLogLevel::Warning, "[*] " + std::string(message));
+        }
+
+        [[noreturn]] static void throwEvaluateError(std::string_view message) {
+            throw EvaluateError("[!] " + std::string(message));
+        }
+
+        [[nodiscard]] std::endian getCurrentEndian() const {
+            return this->m_endianStack.back();
+        }
+
+        ASTNodeIntegerLiteral* evaluateScopeResolution(ASTNodeScopeResolution *node);
+        ASTNodeIntegerLiteral* evaluateRValue(ASTNodeRValue *node);
+        ASTNode* evaluateFunctionCall(ASTNodeFunctionCall *node);
+        ASTNodeIntegerLiteral* evaluateOperator(ASTNodeIntegerLiteral *left, ASTNodeIntegerLiteral *right, Token::Operator op);
+        ASTNodeIntegerLiteral* evaluateOperand(ASTNode *node);
+        ASTNodeIntegerLiteral* evaluateTernaryExpression(ASTNodeTernaryExpression *node);
+        ASTNodeIntegerLiteral* evaluateMathematicalExpression(ASTNodeNumericExpression *node);
+
+        PatternData* evaluateBuiltinType(ASTNodeBuiltinType *node);
+        void evaluateMember(ASTNode *node, std::vector<PatternData*> &currMembers, bool increaseOffset);
+        PatternData* evaluateStruct(ASTNodeStruct *node);
+        PatternData* evaluateUnion(ASTNodeUnion *node);
+        PatternData* evaluateEnum(ASTNodeEnum *node);
+        PatternData* evaluateBitfield(ASTNodeBitfield *node);
+        PatternData* evaluateType(ASTNodeTypeDecl *node);
+        PatternData* evaluateVariable(ASTNodeVariableDecl *node);
+        PatternData* evaluateArray(ASTNodeArrayVariableDecl *node);
+        PatternData* evaluatePointer(ASTNodePointerVariableDecl *node);
+
+        template<typename T>
+        T* asType(ASTNode *param) {
+            if (auto evaluatedParam = dynamic_cast<T*>(param); evaluatedParam != nullptr)
+                return evaluatedParam;
+            else
+                throwEvaluateError("function got wrong type of parameter");
+        }
+
+        void registerBuiltinFunctions();
+
+        #define BUILTIN_FUNCTION(name) ASTNodeIntegerLiteral* TOKEN_CONCAT(builtin_, name)(std::vector<ASTNode*> params)
+
+        BUILTIN_FUNCTION(findSequence);
+        BUILTIN_FUNCTION(readUnsigned);
+        BUILTIN_FUNCTION(readSigned);
+
+        BUILTIN_FUNCTION(assert);
+        BUILTIN_FUNCTION(warnAssert);
+        BUILTIN_FUNCTION(print);
+
+        #undef BUILTIN_FUNCTION
+    };
+
+}

plugins/libimhex/include/hex/lang/lexer.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include "token.hpp"
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace hex::lang {
+
+    class Lexer {
+    public:
+        using LexerError = std::pair<u32, std::string>;
+
+        Lexer();
+
+        std::optional<std::vector<Token>> lex(const std::string& code);
+        const LexerError& getError() { return this->m_error; }
+
+    private:
+        LexerError m_error;
+
+        [[noreturn]] void throwLexerError(std::string_view error, u32 lineNumber) const {
+            throw LexerError(lineNumber, "Lexer: " + std::string(error));
+        }
+    };
+
+}

plugins/libimhex/include/hex/lang/parser.hpp

@@ -0,0 +1,173 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include "token.hpp"
+#include "ast_node.hpp"
+
+#include <hex/helpers/utils.hpp>
+
+#include <unordered_map>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+namespace hex::lang {
+
+    class Parser {
+    public:
+        using TokenIter = std::vector<Token>::const_iterator;
+        using ParseError = std::pair<u32, std::string>;
+
+        Parser() = default;
+        ~Parser() = default;
+
+        std::optional<std::vector<ASTNode*>> parse(const std::vector<Token> &tokens);
+        const ParseError& getError() { return this->m_error; }
+
+    private:
+        ParseError m_error;
+        TokenIter m_curr;
+        TokenIter m_originalPosition;
+
+        std::unordered_map<std::string, ASTNode*> m_types;
+        std::vector<TokenIter> m_matchedOptionals;
+
+        u32 getLineNumber(s32 index) const {
+            return this->m_curr[index].lineNumber;
+        }
+
+        template<typename T>
+        const T& getValue(s32 index) const {
+            auto value = std::get_if<T>(&this->m_curr[index].value);
+
+            if (value == nullptr)
+                throwParseError("failed to decode token. Invalid type.", getLineNumber(index));
+
+            return *value;
+        }
+
+        Token::Type getType(s32 index) const {
+            return this->m_curr[index].type;
+        }
+
+        ASTNode* parseFunctionCall();
+        ASTNode* parseStringLiteral();
+        ASTNode* parseScopeResolution(std::vector<std::string> &path);
+        ASTNode* parseRValue(std::vector<std::string> &path);
+        ASTNode* parseFactor();
+        ASTNode* parseUnaryExpression();
+        ASTNode* parseMultiplicativeExpression();
+        ASTNode* parseAdditiveExpression();
+        ASTNode* parseShiftExpression();
+        ASTNode* parseRelationExpression();
+        ASTNode* parseEqualityExpression();
+        ASTNode* parseBinaryAndExpression();
+        ASTNode* parseBinaryXorExpression();
+        ASTNode* parseBinaryOrExpression();
+        ASTNode* parseBooleanAnd();
+        ASTNode* parseBooleanXor();
+        ASTNode* parseBooleanOr();
+        ASTNode* parseTernaryConditional();
+        ASTNode* parseMathematicalExpression();
+
+        ASTNode* parseConditional();
+        ASTNode* parseType(s32 startIndex);
+        ASTNode* parseUsingDeclaration();
+        ASTNode* parsePadding();
+        ASTNode* parseMemberVariable();
+        ASTNode* parseMemberArrayVariable();
+        ASTNode* parseMemberPointerVariable();
+        ASTNode* parseMember();
+        ASTNode* parseStruct();
+        ASTNode* parseUnion();
+        ASTNode* parseEnum();
+        ASTNode* parseBitfield();
+        ASTNode* parseVariablePlacement();
+        ASTNode* parseArrayVariablePlacement();
+        ASTNode* parsePointerVariablePlacement();
+        ASTNode* parseStatement();
+
+        std::vector<ASTNode*> parseTillToken(Token::Type endTokenType, const auto value) {
+            std::vector<ASTNode*> program;
+            ScopeExit guard([&]{ for (auto &node : program) delete node; });
+
+            while (this->m_curr->type != endTokenType || (*this->m_curr) != value) {
+                program.push_back(parseStatement());
+            }
+
+            this->m_curr++;
+
+            guard.release();
+
+            return program;
+        }
+
+        [[noreturn]] void throwParseError(std::string_view error, s32 token = -1) const {
+            throw ParseError(this->m_curr[token].lineNumber, "Parser: " + std::string(error));
+        }
+
+        /* Token consuming */
+
+        bool begin() {
+            this->m_originalPosition = this->m_curr;
+            this->m_matchedOptionals.clear();
+
+            return true;
+        }
+
+        bool sequence() {
+            return true;
+        }
+
+        bool sequence(Token::Type type, auto value, auto ... args) {
+            if (!peek(type, value)) {
+                this->m_curr = this->m_originalPosition;
+                return false;
+            }
+
+            this->m_curr++;
+
+            if (!sequence(args...)) {
+                this->m_curr = this->m_originalPosition;
+                return false;
+            }
+
+            return true;
+        }
+
+        bool variant(Token::Type type1, auto value1, Token::Type type2, auto value2) {
+            if (!peek(type1, value1)) {
+                if (!peek(type2, value2)) {
+                    this->m_curr = this->m_originalPosition;
+                    return false;
+                }
+            }
+
+            this->m_curr++;
+
+            return true;
+        }
+
+        bool optional(Token::Type type, auto value) {
+            if (peek(type, value)) {
+                this->m_matchedOptionals.push_back(this->m_curr);
+                this->m_curr++;
+            }
+
+            return true;
+        }
+
+        bool peek(Token::Type type, auto value, s32 index = 0) {
+            return this->m_curr[index].type == type && this->m_curr[index] == value;
+        }
+
+        bool peekOptional(Token::Type type, auto value, u32 index = 0) {
+            if (index >= this->m_matchedOptionals.size())
+                return false;
+            return peek(type, value, std::distance(this->m_curr, this->m_matchedOptionals[index]));
+        }
+
+    };
+
+}

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

@@ -0,0 +1,817 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <imgui.h>
+
+#include <hex/providers/provider.hpp>
+#include <hex/helpers/utils.hpp>
+#include <hex/lang/token.hpp>
+#include <hex/views/view.hpp>
+
+#include <cstring>
+#include <random>
+#include <string>
+
+namespace hex::lang {
+
+    using namespace ::std::literals::string_literals;
+
+    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;
+            }
+
+            if (*(data + size - 1) == '\x00')
+                result.pop_back();
+
+            return result;
+        }
+
+    }
+
+    class PatternData {
+    public:
+        PatternData(u64 offset, size_t size, u32 color = 0)
+        : m_offset(offset), m_size(size), m_color(color) {
+            constexpr u32 Palette[] = { 0x70b4771f, 0x700e7fff, 0x702ca02c, 0x702827d6, 0x70bd6794, 0x704b568c, 0x70c277e3, 0x707f7f7f, 0x7022bdbc, 0x70cfbe17 };
+
+            if (color != 0)
+                return;
+
+            this->m_color = Palette[PatternData::s_paletteOffset++];
+
+            if (PatternData::s_paletteOffset >= (sizeof(Palette) / sizeof(u32)))
+                PatternData::s_paletteOffset = 0;
+        }
+        virtual ~PatternData() = default;
+
+        virtual PatternData* clone() = 0;
+
+        [[nodiscard]] u64 getOffset() const { return this->m_offset; }
+        [[nodiscard]] size_t getSize() const { return this->m_size; }
+
+        [[nodiscard]] const std::string& getVariableName() const { return this->m_variableName; }
+        void setVariableName(std::string name) { this->m_variableName = std::move(name); }
+
+        [[nodiscard]] const std::string& getTypeName() const { return this->m_typeName; }
+        void setTypeName(std::string name) { this->m_typeName = std::move(name); }
+
+        [[nodiscard]] u32 getColor() const { return this->m_color; }
+        void setColor(u32 color) { this->m_color = color; }
+
+        [[nodiscard]] std::endian getEndian() const { return this->m_endian; }
+        void setEndian(std::endian endian) { this->m_endian = endian; }
+
+        virtual void createEntry(prv::Provider* &provider) = 0;
+        [[nodiscard]] virtual std::string getFormattedName() const = 0;
+
+        virtual std::optional<u32> highlightBytes(size_t offset) {
+            auto currOffset = this->getOffset();
+            if (offset >= currOffset && offset < (currOffset + this->getSize()))
+                return this->getColor();
+            else
+                return { };
+        }
+
+        virtual std::map<u64, u32> getHighlightedAddresses() {
+            if (this->m_highlightedAddresses.empty()) {
+                for (u64 i = 0; i < this->getSize(); i++)
+                    this->m_highlightedAddresses.insert({ this->getOffset() + i, this->getColor() });
+            }
+
+            return this->m_highlightedAddresses;
+        }
+
+        virtual void sort(ImGuiTableSortSpecs *sortSpecs, prv::Provider *provider) { }
+
+        static bool sortPatternDataTable(ImGuiTableSortSpecs *sortSpecs, prv::Provider *provider, lang::PatternData* left, lang::PatternData* right) {
+            if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("name")) {
+                if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
+                    return left->getVariableName() > right->getVariableName();
+                else
+                    return left->getVariableName() < right->getVariableName();
+            }
+            else if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("offset")) {
+                if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
+                    return left->getOffset() > right->getOffset();
+                else
+                    return left->getOffset() < right->getOffset();
+            }
+            else if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("size")) {
+                if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
+                    return left->getSize() > right->getSize();
+                else
+                    return left->getSize() < right->getSize();
+            }
+            else if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("value")) {
+                size_t biggerSize = std::max(left->getSize(), right->getSize());
+                std::vector<u8> leftBuffer(biggerSize, 0x00), rightBuffer(biggerSize, 0x00);
+
+                provider->read(left->getOffset(), leftBuffer.data(), left->getSize());
+                provider->read(right->getOffset(), rightBuffer.data(), right->getSize());
+
+                if (left->m_endian != std::endian::native)
+                    std::reverse(leftBuffer.begin(), leftBuffer.end());
+                if (right->m_endian != std::endian::native)
+                    std::reverse(rightBuffer.begin(), rightBuffer.end());
+
+                if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
+                    return leftBuffer > rightBuffer;
+                else
+                    return leftBuffer < rightBuffer;
+            }
+            else if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("type")) {
+                if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
+                    return left->getTypeName() > right->getTypeName();
+                else
+                    return left->getTypeName() < right->getTypeName();
+            }
+            else if (sortSpecs->Specs->ColumnUserID == ImGui::GetID("color")) {
+                if (sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending)
+                    return left->getColor() > right->getColor();
+                else
+                    return left->getColor() < right->getColor();
+            }
+
+            return false;
+        }
+
+        static void resetPalette() { PatternData::s_paletteOffset = 0; }
+
+    protected:
+        void createDefaultEntry(std::string_view value) const {
+            ImGui::TableNextRow();
+            ImGui::TreeNodeEx(this->getVariableName().c_str(), ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_AllowItemOverlap);
+            ImGui::TableNextColumn();
+            if (ImGui::Selectable(("##PatternDataLine"s + std::to_string(this->getOffset())).c_str(), false, ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowItemOverlap)) {
+                Region selectRegion = { this->getOffset(), this->getSize() };
+                View::postEvent(Events::SelectionChangeRequest, &selectRegion);
+            }
+            ImGui::SameLine();
+            ImGui::Text("%s", this->getVariableName().c_str());
+            ImGui::TableNextColumn();
+            ImGui::ColorButton("color", ImColor(this->getColor()), ImGuiColorEditFlags_NoTooltip, ImVec2(ImGui::GetColumnWidth(), ImGui::GetTextLineHeight()));
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%08llX : 0x%08llX", this->getOffset(), this->getOffset() + this->getSize() - 1);
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%04llX", this->getSize());
+            ImGui::TableNextColumn();
+            ImGui::TextColored(ImColor(0xFF9BC64D), "%s", this->getFormattedName().c_str());
+            ImGui::TableNextColumn();
+            ImGui::Text("%s", value.data());
+        }
+
+    protected:
+        std::endian m_endian = std::endian::native;
+        std::map<u64, u32> m_highlightedAddresses;
+
+    private:
+        u64 m_offset;
+        size_t m_size;
+
+        u32 m_color;
+        std::string m_variableName;
+        std::string m_typeName;
+
+        static inline u8 s_paletteOffset = 0;
+
+    };
+
+    class PatternDataPadding : public PatternData {
+    public:
+        PatternDataPadding(u64 offset, size_t size) : PatternData(offset, size, 0x00FFFFFF) { }
+
+        PatternData* clone() override {
+            return new PatternDataPadding(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            return "";
+        }
+    };
+
+    class PatternDataPointer : public PatternData {
+    public:
+        PatternDataPointer(u64 offset, size_t size, PatternData *pointedAt, u32 color = 0)
+        : PatternData(offset, size, color), m_pointedAt(pointedAt) {
+            this->m_pointedAt->setVariableName("*" + this->m_pointedAt->getVariableName());
+        }
+
+        PatternData* clone() override {
+            return new PatternDataPointer(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            u64 data = 0;
+            provider->read(this->getOffset(), &data, this->getSize());
+            data = hex::changeEndianess(data, this->getSize(), this->getEndian());
+
+            ImGui::TableNextRow();
+            ImGui::TableNextColumn();
+            bool open = ImGui::TreeNodeEx(this->getVariableName().c_str(), ImGuiTreeNodeFlags_SpanFullWidth);
+            ImGui::TableNextColumn();
+            ImGui::ColorButton("color", ImColor(this->getColor()), ImGuiColorEditFlags_NoTooltip, ImVec2(ImGui::GetColumnWidth(), ImGui::GetTextLineHeight()));
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%08llX : 0x%08llX", this->getOffset(), this->getOffset() + this->getSize() - 1);
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%04llX", this->getSize());
+            ImGui::TableNextColumn();
+            ImGui::TextColored(ImColor(0xFF9BC64D), "%s*", this->m_pointedAt->getFormattedName().c_str());
+            ImGui::TableNextColumn();
+            ImGui::Text("*(0x%llX)", data);
+
+            if (open) {
+                this->m_pointedAt->createEntry(provider);
+
+                ImGui::TreePop();
+            }
+        }
+
+        std::optional<u32> highlightBytes(size_t offset) override {
+            if (offset >= this->getOffset() && offset < (this->getOffset() + this->getSize()))
+                return this->getColor();
+            else if (auto color = this->m_pointedAt->highlightBytes(offset); color.has_value())
+                return color.value();
+            else
+                return { };
+        }
+
+        std::map<u64, u32> getHighlightedAddresses() override {
+            if (this->m_highlightedAddresses.empty()) {
+                auto ownAddresses = PatternData::getHighlightedAddresses();
+                auto pointedToAddresses = this->m_pointedAt->getHighlightedAddresses();
+
+                ownAddresses.merge(pointedToAddresses);
+                this->m_highlightedAddresses = ownAddresses;
+            }
+
+            return this->m_highlightedAddresses;
+        }
+        [[nodiscard]] std::string getFormattedName() const override {
+            return "Pointer";
+        }
+
+        [[nodiscard]] PatternData* getPointedAtPattern() {
+            return this->m_pointedAt;
+        }
+
+    private:
+        PatternData *m_pointedAt;
+    };
+
+    class PatternDataUnsigned : public PatternData {
+    public:
+        PatternDataUnsigned(u64 offset, size_t size, u32 color = 0)
+            : PatternData(offset, size, color) { }
+
+        PatternData* clone() override {
+            return new PatternDataUnsigned(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            u64 data = 0;
+            provider->read(this->getOffset(), &data, this->getSize());
+            data = hex::changeEndianess(data, this->getSize(), this->getEndian());
+
+            this->createDefaultEntry(hex::format("%llu (0x%0*llX)", data, this->getSize() * 2, data));
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            switch (this->getSize()) {
+                case 1:     return "u8";
+                case 2:     return "u16";
+                case 4:     return "u32";
+                case 8:     return "u64";
+                case 16:    return "u128";
+                default:    return "Unsigned data";
+            }
+        }
+    };
+
+    class PatternDataSigned : public PatternData {
+    public:
+        PatternDataSigned(u64 offset, size_t size, u32 color = 0)
+            : PatternData(offset, size, color) { }
+
+        PatternData* clone() override {
+            return new PatternDataSigned(*this);
+        }
+
+       void createEntry(prv::Provider* &provider) override {
+            u64 data = 0;
+            provider->read(this->getOffset(), &data, this->getSize());
+            data = hex::changeEndianess(data, this->getSize(), this->getEndian());
+
+            s64 signedData = hex::signExtend(data, this->getSize(), 64);
+
+           this->createDefaultEntry(hex::format("%lld (0x%0*llX)", signedData, this->getSize() * 2, data));
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            switch (this->getSize()) {
+                case 1:     return "s8";
+                case 2:     return "s16";
+                case 4:     return "s32";
+                case 8:     return "s64";
+                case 16:    return "s128";
+                default:    return "Signed data";
+            }
+        }
+    };
+
+    class PatternDataFloat : public PatternData {
+    public:
+        PatternDataFloat(u64 offset, size_t size, u32 color = 0)
+            : PatternData(offset, size, color) { }
+
+        PatternData* clone() override {
+            return new PatternDataFloat(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            if (this->getSize() == 4) {
+                u32 data = 0;
+                provider->read(this->getOffset(), &data, 4);
+                data = hex::changeEndianess(data, 4, this->getEndian());
+
+                this->createDefaultEntry(hex::format("%e (0x%0*lX)", *reinterpret_cast<float*>(&data), this->getSize() * 2, data));
+            } else if (this->getSize() == 8) {
+                u64 data = 0;
+                provider->read(this->getOffset(), &data, 8);
+                data = hex::changeEndianess(data, 8, this->getEndian());
+
+                this->createDefaultEntry(hex::format("%e (0x%0*llX)", *reinterpret_cast<double*>(&data), this->getSize() * 2, data));
+            }
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            switch (this->getSize()) {
+                case 4:     return "float";
+                case 8:     return "double";
+                default:    return "Floating point data";
+            }
+        }
+    };
+
+    class PatternDataBoolean : public PatternData {
+    public:
+        explicit PatternDataBoolean(u64 offset, u32 color = 0)
+                : PatternData(offset, 1, color) { }
+
+        PatternData* clone() override {
+            return new PatternDataBoolean(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            u8 boolean;
+            provider->read(this->getOffset(), &boolean, 1);
+
+            if (boolean == 0)
+                this->createDefaultEntry("false");
+            else if (boolean == 1)
+                this->createDefaultEntry("true");
+            else
+                this->createDefaultEntry("true*");
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            return "bool";
+        }
+    };
+
+    class PatternDataCharacter : public PatternData {
+    public:
+        explicit PatternDataCharacter(u64 offset, u32 color = 0)
+            : PatternData(offset, 1, color) { }
+
+        PatternData* clone() override {
+            return new PatternDataCharacter(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            char character;
+            provider->read(this->getOffset(), &character, 1);
+
+            this->createDefaultEntry(hex::format("'%c'", character));
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            return "char";
+        }
+    };
+
+    class PatternDataString : public PatternData {
+    public:
+        PatternDataString(u64 offset, size_t size, u32 color = 0)
+            : PatternData(offset, size, color) { }
+
+        PatternData* clone() override {
+            return new PatternDataString(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            std::vector<u8> buffer(this->getSize() + 1, 0x00);
+            provider->read(this->getOffset(), buffer.data(), this->getSize());
+            buffer[this->getSize()] = '\0';
+
+            this->createDefaultEntry(hex::format("\"%s\"", makeDisplayable(buffer.data(), this->getSize()).c_str()));
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+           return "String";
+        }
+    };
+
+    class PatternDataArray : public PatternData {
+    public:
+        PatternDataArray(u64 offset, size_t size, std::vector<PatternData*> entries, u32 color = 0)
+            : PatternData(offset, size, color), m_entries(std::move(entries)) { }
+
+        PatternDataArray(const PatternDataArray &other) : PatternData(other.getOffset(), other.getSize(), other.getColor()) {
+            for (const auto &entry : other.m_entries)
+                this->m_entries.push_back(entry->clone());
+        }
+
+        PatternData* clone() override {
+            return new PatternDataArray(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            if (this->m_entries.empty())
+                return;
+
+            ImGui::TableNextRow();
+            ImGui::TableNextColumn();
+            bool open = ImGui::TreeNodeEx(this->getVariableName().c_str(), ImGuiTreeNodeFlags_SpanFullWidth);
+            ImGui::TableNextColumn();
+            ImGui::ColorButton("color", ImColor(this->getColor()), ImGuiColorEditFlags_NoTooltip, ImVec2(ImGui::GetColumnWidth(), ImGui::GetTextLineHeight()));
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%08llX : 0x%08llX", this->getOffset(), this->getOffset() + this->getSize() - 1);
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%04llX", this->getSize());
+            ImGui::TableNextColumn();
+            ImGui::TextColored(ImColor(0xFF9BC64D), "%s", this->m_entries[0]->getTypeName().c_str());
+            ImGui::SameLine(0, 0);
+
+            ImGui::TextUnformatted("[");
+            ImGui::SameLine(0, 0);
+            ImGui::TextColored(ImColor(0xFF00FF00), "%llu", this->m_entries.size());
+            ImGui::SameLine(0, 0);
+            ImGui::TextUnformatted("]");
+
+            ImGui::TableNextColumn();
+            ImGui::Text("%s", "{ ... }");
+
+            if (open) {
+                for (auto &member : this->m_entries)
+                    member->createEntry(provider);
+
+                ImGui::TreePop();
+            }
+        }
+
+        std::optional<u32> highlightBytes(size_t offset) override{
+            for (auto &entry : this->m_entries) {
+                if (auto color = entry->highlightBytes(offset); color.has_value())
+                    return color.value();
+            }
+
+            return { };
+        }
+
+        std::map<u64, u32> getHighlightedAddresses() override {
+            if (this->m_highlightedAddresses.empty()) {
+                for (auto &entry : this->m_entries) {
+                    this->m_highlightedAddresses.merge(entry->getHighlightedAddresses());
+                }
+            }
+
+            return this->m_highlightedAddresses;
+        }
+        [[nodiscard]] std::string getFormattedName() const override {
+            return this->m_entries[0]->getTypeName() + "[" + std::to_string(this->m_entries.size()) + "]";
+        }
+
+    private:
+        std::vector<PatternData*> m_entries;
+    };
+
+    class PatternDataStruct : public PatternData {
+    public:
+        PatternDataStruct(u64 offset, size_t size, const std::vector<PatternData*> & members, u32 color = 0)
+                : PatternData(offset, size, color), m_members(members), m_sortedMembers(members) { }
+
+        PatternDataStruct(const PatternDataStruct &other) : PatternData(other.getOffset(), other.getSize(), other.getColor()) {
+            for (const auto &member : other.m_members)
+                this->m_members.push_back(member->clone());
+        }
+
+        PatternData* clone() override {
+            return new PatternDataStruct(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            ImGui::TableNextRow();
+            ImGui::TableNextColumn();
+            bool open = ImGui::TreeNodeEx(this->getVariableName().c_str(), ImGuiTreeNodeFlags_SpanFullWidth);
+            ImGui::TableNextColumn();
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%08llX : 0x%08llX", this->getOffset(), this->getOffset() + this->getSize() - (this->getSize() == 0 ? 0 : 1));
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%04llX", this->getSize());
+            ImGui::TableNextColumn();
+            ImGui::TextColored(ImColor(0xFFD69C56), "struct"); ImGui::SameLine(); ImGui::Text("%s", this->getTypeName().c_str());
+            ImGui::TableNextColumn();
+            ImGui::Text("%s", "{ ... }");
+
+            if (open) {
+                for (auto &member : this->m_sortedMembers)
+                    member->createEntry(provider);
+
+                ImGui::TreePop();
+            }
+
+        }
+
+        std::optional<u32> highlightBytes(size_t offset) override{
+            for (auto &member : this->m_members) {
+                if (auto color = member->highlightBytes(offset); color.has_value())
+                    return color.value();
+            }
+
+            return { };
+        }
+
+        std::map<u64, u32> getHighlightedAddresses() override {
+            if (this->m_highlightedAddresses.empty()) {
+                for (auto &member : this->m_members) {
+                    this->m_highlightedAddresses.merge(member->getHighlightedAddresses());
+                }
+            }
+
+            return this->m_highlightedAddresses;
+        }
+
+        void sort(ImGuiTableSortSpecs *sortSpecs, prv::Provider *provider) override {
+            this->m_sortedMembers = this->m_members;
+
+            std::sort(this->m_sortedMembers.begin(), this->m_sortedMembers.end(), [&sortSpecs, &provider](PatternData *left, PatternData *right) {
+                return PatternData::sortPatternDataTable(sortSpecs, provider, left, right);
+            });
+
+            for (auto &member : this->m_members)
+                member->sort(sortSpecs, provider);
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            return "struct " + PatternData::getTypeName();
+        }
+
+        const auto& getMembers() const {
+            return this->m_members;
+        }
+
+    private:
+        std::vector<PatternData*> m_members;
+        std::vector<PatternData*> m_sortedMembers;
+    };
+
+    class PatternDataUnion : public PatternData {
+    public:
+        PatternDataUnion(u64 offset, size_t size, const std::vector<PatternData*> & members, u32 color = 0)
+                : PatternData(offset, size, color), m_members(members), m_sortedMembers(members) { }
+
+        PatternDataUnion(const PatternDataUnion &other) : PatternData(other.getOffset(), other.getSize(), other.getColor()) {
+            for (const auto &member : other.m_members)
+                this->m_members.push_back(member->clone());
+        }
+
+        PatternData* clone() override {
+            return new PatternDataUnion(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            ImGui::TableNextRow();
+            ImGui::TableNextColumn();
+            bool open = ImGui::TreeNodeEx(this->getVariableName().c_str(), ImGuiTreeNodeFlags_SpanFullWidth);
+            ImGui::TableNextColumn();
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%08llX : 0x%08llX", this->getOffset(), std::max(this->getOffset() + this->getSize() - (this->getSize() == 0 ? 0 : 1), u64(0)));
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%04llX", this->getSize());
+            ImGui::TableNextColumn();
+            ImGui::TextColored(ImColor(0xFFD69C56), "union"); ImGui::SameLine(); ImGui::Text("%s", PatternData::getTypeName().c_str());
+
+            ImGui::TableNextColumn();
+            ImGui::Text("%s", "{ ... }");
+
+            if (open) {
+                for (auto &member : this->m_sortedMembers)
+                    member->createEntry(provider);
+
+                ImGui::TreePop();
+            }
+
+        }
+
+        std::optional<u32> highlightBytes(size_t offset) override{
+            for (auto &member : this->m_members) {
+                if (auto color = member->highlightBytes(offset); color.has_value())
+                    return color.value();
+            }
+
+            return { };
+        }
+
+        std::map<u64, u32> getHighlightedAddresses() override {
+            if (this->m_highlightedAddresses.empty()) {
+                for (auto &member : this->m_members) {
+                    this->m_highlightedAddresses.merge(member->getHighlightedAddresses());
+                }
+            }
+
+            return this->m_highlightedAddresses;
+        }
+
+        void sort(ImGuiTableSortSpecs *sortSpecs, prv::Provider *provider) override {
+            this->m_sortedMembers = this->m_members;
+
+            std::sort(this->m_sortedMembers.begin(), this->m_sortedMembers.end(), [&sortSpecs, &provider](PatternData *left, PatternData *right) {
+                return PatternData::sortPatternDataTable(sortSpecs, provider, left, right);
+            });
+
+            for (auto &member : this->m_members)
+                member->sort(sortSpecs, provider);
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            return "union " + PatternData::getTypeName();;
+        }
+
+        const auto& getMembers() const {
+            return this->m_members;
+        }
+
+    private:
+        std::vector<PatternData*> m_members;
+        std::vector<PatternData*> m_sortedMembers;
+    };
+
+    class PatternDataEnum : public PatternData {
+    public:
+        PatternDataEnum(u64 offset, size_t size, std::vector<std::pair<Token::IntegerLiteral, std::string>> enumValues, u32 color = 0)
+            : PatternData(offset, size, color), m_enumValues(std::move(enumValues)) { }
+
+        PatternData* clone() override {
+            return new PatternDataEnum(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            u64 value = 0;
+            provider->read(this->getOffset(), &value, this->getSize());
+            value = hex::changeEndianess(value, this->getSize(), this->getEndian());
+
+            std::string valueString = PatternData::getTypeName() + "::";
+
+            bool foundValue = false;
+            for (auto &[entryValueLiteral, entryName] : this->m_enumValues) {
+                bool matches = std::visit([&, name = entryName](auto &&entryValue) {
+                    if (value == entryValue) {
+                        valueString += name;
+                        foundValue = true;
+                        return true;
+                    }
+
+                    return false;
+                }, entryValueLiteral.second);
+                if (matches)
+                    break;
+            }
+
+            if (!foundValue)
+                valueString += "???";
+
+            ImGui::TableNextRow();
+            ImGui::TreeNodeEx(this->getVariableName().c_str(), ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_SpanFullWidth);
+            ImGui::TableNextColumn();
+            if (ImGui::Selectable(("##PatternDataLine"s + std::to_string(this->getOffset())).c_str(), false, ImGuiSelectableFlags_SpanAllColumns)) {
+                Region selectRegion = { this->getOffset(), this->getSize() };
+                View::postEvent(Events::SelectionChangeRequest, &selectRegion);
+            }
+            ImGui::SameLine();
+            ImGui::Text("%s", this->getVariableName().c_str());
+            ImGui::TableNextColumn();
+            ImGui::ColorButton("color", ImColor(this->getColor()), ImGuiColorEditFlags_NoTooltip, ImVec2(ImGui::GetColumnWidth(), ImGui::GetTextLineHeight()));
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%08llX : 0x%08llX", this->getOffset(), this->getOffset() + this->getSize() - 1);
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%04llX", this->getSize());
+            ImGui::TableNextColumn();
+            ImGui::TextColored(ImColor(0xFFD69C56), "enum"); ImGui::SameLine(); ImGui::Text("%s", PatternData::getTypeName().c_str());
+            ImGui::TableNextColumn();
+            ImGui::Text("%s", hex::format("%s (0x%0*llX)", valueString.c_str(), this->getSize() * 2, value).c_str());
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            return "enum " + PatternData::getTypeName();
+        }
+
+        const auto& getEnumValues() const {
+            return this->m_enumValues;
+        }
+
+    private:
+        std::vector<std::pair<Token::IntegerLiteral, std::string>> m_enumValues;
+    };
+
+    class PatternDataBitfield : public PatternData {
+    public:
+        PatternDataBitfield(u64 offset, size_t size, std::vector<std::pair<std::string, size_t>> fields, u32 color = 0)
+                : PatternData(offset, size, color), m_fields(std::move(fields)) { }
+
+        PatternData* clone() override {
+            return new PatternDataBitfield(*this);
+        }
+
+        void createEntry(prv::Provider* &provider) override {
+            std::vector<u8> value(this->getSize(), 0);
+            provider->read(this->getOffset(), &value[0], value.size());
+
+            if (this->m_endian == std::endian::big)
+                std::reverse(value.begin(), value.end());
+
+            ImGui::TableNextRow();
+            ImGui::TableNextColumn();
+            bool open = ImGui::TreeNodeEx(this->getVariableName().c_str(), ImGuiTreeNodeFlags_SpanFullWidth);
+            ImGui::TableNextColumn();
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%08llX : 0x%08llX", this->getOffset(), this->getOffset() + this->getSize() - 1);
+            ImGui::TableNextColumn();
+            ImGui::Text("0x%04llX", this->getSize());
+            ImGui::TableNextColumn();
+            ImGui::TextColored(ImColor(0xFFD69C56), "bitfield"); ImGui::SameLine(); ImGui::Text("%s", PatternData::getTypeName().c_str());
+            ImGui::TableNextColumn();
+
+            std::string valueString = "{ ";
+            for (u64 i = 0; i < value.size(); i++)
+                valueString += hex::format("%02x ", value[i]);
+            valueString += "}";
+
+            ImGui::TextUnformatted(valueString.c_str());
+
+            if (open) {
+                u16 bitOffset = 0;
+                for (auto &[entryName, entrySize] : this->m_fields) {
+                    ImGui::TableNextRow();
+                    ImGui::TreeNodeEx(this->getVariableName().c_str(), ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_SpanFullWidth);
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%s", entryName.c_str());
+                    ImGui::TableNextColumn();
+                    ImGui::ColorButton("color", ImColor(this->getColor()), ImGuiColorEditFlags_NoTooltip, ImVec2(ImGui::GetColumnWidth(), ImGui::GetTextLineHeight()));
+                    ImGui::TableNextColumn();
+                    ImGui::Text("0x%08llX : 0x%08llX", this->getOffset() + (bitOffset >> 3), this->getOffset() + ((bitOffset + entrySize) >> 3));
+                    ImGui::TableNextColumn();
+                    if (entrySize == 1)
+                        ImGui::Text("%llu bit", entrySize);
+                    else
+                        ImGui::Text("%llu bits", entrySize);
+                    ImGui::TableNextColumn();
+                    ImGui::TextColored(ImColor(0xFF9BC64D), "bits");
+                    ImGui::TableNextColumn();
+                    {
+                        u128 fieldValue = 0;
+                        std::memcpy(&fieldValue, value.data() + (bitOffset / 8), (entrySize / 8) + 1);
+                        ImGui::Text("%llX", hex::extract((bitOffset + entrySize) - 1 - ((bitOffset / 8) * 8), bitOffset - ((bitOffset / 8) * 8), fieldValue));
+                    }
+                    bitOffset += entrySize;
+                }
+
+                ImGui::TreePop();
+            }
+
+        }
+
+        [[nodiscard]] std::string getFormattedName() const override {
+            return "bitfield " + PatternData::getTypeName();
+        }
+
+        const auto& getFields() const {
+            return this->m_fields;
+        }
+
+    private:
+        std::vector<std::pair<std::string, size_t>> m_fields;
+    };
+
+
+}

plugins/libimhex/include/hex/lang/preprocessor.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include "token.hpp"
+
+#include <functional>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+namespace hex::lang {
+
+    class Preprocessor {
+    public:
+        Preprocessor();
+
+        std::optional<std::string> preprocess(const std::string& code, bool initialRun = true);
+
+        void addPragmaHandler(const std::string &pragmaType, const std::function<bool(const std::string&)> &function);
+        void addDefaultPragmaHandlers();
+
+        const std::pair<u32, std::string>& getError() { return this->m_error; }
+
+    private:
+        using PreprocessorError = std::pair<u32, std::string>;
+
+        [[noreturn]] void throwPreprocessorError(std::string_view error, u32 lineNumber) const {
+            throw PreprocessorError(lineNumber, "Preprocessor: " + std::string(error));
+        }
+
+        std::unordered_map<std::string, std::function<bool(std::string)>> m_pragmaHandlers;
+
+        std::set<std::pair<std::string, std::string>> m_defines;
+        std::set<std::pair<std::string, std::string>> m_pragmas;
+
+        std::pair<u32, std::string> m_error;
+    };
+
+}

plugins/libimhex/include/hex/lang/token.hpp

@@ -0,0 +1,245 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <hex/helpers/utils.hpp>
+
+#include <utility>
+#include <string>
+#include <variant>
+
+namespace hex::lang {
+
+    class Token {
+    public:
+        enum class Type : u64 {
+            Keyword,
+            ValueType,
+            Operator,
+            Integer,
+            String,
+            Identifier,
+            Separator
+        };
+
+        enum class Keyword {
+            Struct,
+            Union,
+            Using,
+            Enum,
+            Bitfield,
+            LittleEndian,
+            BigEndian,
+            If,
+            Else
+        };
+
+        enum class Operator {
+            AtDeclaration,
+            Assignment,
+            Inherit,
+            Plus,
+            Minus,
+            Star,
+            Slash,
+            ShiftLeft,
+            ShiftRight,
+            BitOr,
+            BitAnd,
+            BitXor,
+            BitNot,
+            BoolEquals,
+            BoolNotEquals,
+            BoolGreaterThan,
+            BoolLessThan,
+            BoolGreaterThanOrEquals,
+            BoolLessThanOrEquals,
+            BoolAnd,
+            BoolOr,
+            BoolXor,
+            BoolNot,
+            TernaryConditional
+        };
+
+        enum class ValueType {
+            Unsigned8Bit        = 0x10,
+            Signed8Bit          = 0x11,
+            Unsigned16Bit       = 0x20,
+            Signed16Bit         = 0x21,
+            Unsigned32Bit       = 0x40,
+            Signed32Bit         = 0x41,
+            Unsigned64Bit       = 0x80,
+            Signed64Bit         = 0x81,
+            Unsigned128Bit      = 0x100,
+            Signed128Bit        = 0x101,
+            Character           = 0x13,
+            Boolean             = 0x14,
+            Float               = 0x42,
+            Double              = 0x82,
+            CustomType          = 0x00,
+            Padding             = 0x1F,
+
+            Unsigned            = 0xFF00,
+            Signed              = 0xFF01,
+            FloatingPoint       = 0xFF02,
+            Integer             = 0xFF03,
+            Any                 = 0xFFFF
+        };
+
+        enum class Separator {
+            RoundBracketOpen,
+            RoundBracketClose,
+            CurlyBracketOpen,
+            CurlyBracketClose,
+            SquareBracketOpen,
+            SquareBracketClose,
+            Comma,
+            Dot,
+            ScopeResolution,
+            EndOfExpression,
+            EndOfProgram
+        };
+
+        using IntegerLiteral = std::pair<ValueType, std::variant<u8, s8, u16, s16, u32, s32, u64, s64, u128, s128, float, double>>;
+        using ValueTypes = std::variant<Keyword, std::string, Operator, IntegerLiteral, ValueType, Separator>;
+
+        Token(Type type, auto value, u32 lineNumber) : type(type), value(value), lineNumber(lineNumber) {
+
+        }
+
+        [[nodiscard]] constexpr static inline bool isUnsigned(const ValueType type) {
+            return (static_cast<u32>(type) & 0x0F) == 0x00;
+        }
+
+        [[nodiscard]] constexpr static inline bool isSigned(const ValueType type) {
+            return (static_cast<u32>(type) & 0x0F) == 0x01;
+        }
+
+        [[nodiscard]] constexpr static inline bool isFloatingPoint(const ValueType type) {
+            return (static_cast<u32>(type) & 0x0F) == 0x02;
+        }
+
+        [[nodiscard]] constexpr static inline u32 getTypeSize(const ValueType type) {
+            return static_cast<u32>(type) >> 4;
+        }
+
+        [[nodiscard]] constexpr static auto getTypeName(const lang::Token::ValueType type) {
+            switch (type) {
+                case ValueType::Signed8Bit:     return "s8";
+                case ValueType::Signed16Bit:    return "s16";
+                case ValueType::Signed32Bit:    return "s32";
+                case ValueType::Signed64Bit:    return "s64";
+                case ValueType::Signed128Bit:   return "s128";
+                case ValueType::Unsigned8Bit:   return "u8";
+                case ValueType::Unsigned16Bit:  return "u16";
+                case ValueType::Unsigned32Bit:  return "u32";
+                case ValueType::Unsigned64Bit:  return "u64";
+                case ValueType::Unsigned128Bit: return "u128";
+                case ValueType::Float:          return "float";
+                case ValueType::Double:         return "double";
+                case ValueType::Character:      return "char";
+                default:                        return "< ??? >";
+            }
+        }
+
+        bool operator==(const ValueTypes &other) const {
+            if (this->type == Type::Integer || this->type == Type::Identifier || this->type == Type::String)
+                return true;
+            else if (this->type == Type::ValueType) {
+                auto otherValueType =   std::get_if<ValueType>(&other);
+                auto valueType =        std::get_if<ValueType>(&this->value);
+
+                if (otherValueType == nullptr) return false;
+                if (valueType == nullptr) return false;
+
+                if (*otherValueType == *valueType)
+                    return true;
+                else if (*otherValueType == ValueType::Any)
+                    return *valueType != ValueType::CustomType && *valueType != ValueType::Padding;
+                else if (*otherValueType == ValueType::Unsigned)
+                    return isUnsigned(*valueType);
+                else if (*otherValueType == ValueType::Signed)
+                    return isSigned(*valueType);
+                else if (*otherValueType == ValueType::FloatingPoint)
+                    return isFloatingPoint(*valueType);
+                else if (*otherValueType == ValueType::Integer)
+                    return isUnsigned(*valueType) || isSigned(*valueType);
+            }
+            else
+                return other == this->value;
+
+            return false;
+        }
+
+        bool operator!=(const ValueTypes &other) const {
+            return !operator==(other);
+        }
+
+        Type type;
+        ValueTypes value;
+        u32 lineNumber;
+
+    };
+
+}
+
+#define COMPONENT(type, value) hex::lang::Token::Type::type, hex::lang::Token::type::value
+
+#define KEYWORD_STRUCT                      COMPONENT(Keyword, Struct)
+#define KEYWORD_UNION                       COMPONENT(Keyword, Union)
+#define KEYWORD_USING                       COMPONENT(Keyword, Using)
+#define KEYWORD_ENUM                        COMPONENT(Keyword, Enum)
+#define KEYWORD_BITFIELD                    COMPONENT(Keyword, Bitfield)
+#define KEYWORD_LE                          COMPONENT(Keyword, LittleEndian)
+#define KEYWORD_BE                          COMPONENT(Keyword, BigEndian)
+#define KEYWORD_IF                          COMPONENT(Keyword, If)
+#define KEYWORD_ELSE                        COMPONENT(Keyword, Else)
+
+#define INTEGER                             hex::lang::Token::Type::Integer, hex::lang::Token::IntegerLiteral(hex::lang::Token::ValueType::Any, u64(0))
+#define IDENTIFIER                          hex::lang::Token::Type::Identifier, ""
+#define STRING                              hex::lang::Token::Type::String, ""
+
+#define OPERATOR_AT                         COMPONENT(Operator, AtDeclaration)
+#define OPERATOR_ASSIGNMENT                 COMPONENT(Operator, Assignment)
+#define OPERATOR_INHERIT                    COMPONENT(Operator, Inherit)
+#define OPERATOR_PLUS                       COMPONENT(Operator, Plus)
+#define OPERATOR_MINUS                      COMPONENT(Operator, Minus)
+#define OPERATOR_STAR                       COMPONENT(Operator, Star)
+#define OPERATOR_SLASH                      COMPONENT(Operator, Slash)
+#define OPERATOR_SHIFTLEFT                  COMPONENT(Operator, ShiftLeft)
+#define OPERATOR_SHIFTRIGHT                 COMPONENT(Operator, ShiftRight)
+#define OPERATOR_BITOR                      COMPONENT(Operator, BitOr)
+#define OPERATOR_BITAND                     COMPONENT(Operator, BitAnd)
+#define OPERATOR_BITXOR                     COMPONENT(Operator, BitXor)
+#define OPERATOR_BITNOT                     COMPONENT(Operator, BitNot)
+#define OPERATOR_BOOLEQUALS                 COMPONENT(Operator, BoolEquals)
+#define OPERATOR_BOOLNOTEQUALS              COMPONENT(Operator, BoolNotEquals)
+#define OPERATOR_BOOLGREATERTHAN            COMPONENT(Operator, BoolGreaterThan)
+#define OPERATOR_BOOLLESSTHAN               COMPONENT(Operator, BoolLessThan)
+#define OPERATOR_BOOLGREATERTHANOREQUALS    COMPONENT(Operator, BoolGreaterThanOrEquals)
+#define OPERATOR_BOOLLESSTHANOREQUALS       COMPONENT(Operator, BoolLessThanOrEquals)
+#define OPERATOR_BOOLAND                    COMPONENT(Operator, BoolAnd)
+#define OPERATOR_BOOLOR                     COMPONENT(Operator, BoolOr)
+#define OPERATOR_BOOLXOR                    COMPONENT(Operator, BoolXor)
+#define OPERATOR_BOOLNOT                    COMPONENT(Operator, BoolNot)
+#define OPERATOR_TERNARYCONDITIONAL         COMPONENT(Operator, TernaryConditional)
+
+#define VALUETYPE_CUSTOMTYPE                COMPONENT(ValueType, CustomType)
+#define VALUETYPE_PADDING                   COMPONENT(ValueType, Padding)
+#define VALUETYPE_UNSIGNED                  COMPONENT(ValueType, Unsigned)
+#define VALUETYPE_SIGNED                    COMPONENT(ValueType, Signed)
+#define VALUETYPE_FLOATINGPOINT             COMPONENT(ValueType, FloatingPoint)
+#define VALUETYPE_INTEGER                   COMPONENT(ValueType, Integer)
+#define VALUETYPE_ANY                       COMPONENT(ValueType, Any)
+
+#define SEPARATOR_ROUNDBRACKETOPEN          COMPONENT(Separator, RoundBracketOpen)
+#define SEPARATOR_ROUNDBRACKETCLOSE         COMPONENT(Separator, RoundBracketClose)
+#define SEPARATOR_CURLYBRACKETOPEN          COMPONENT(Separator, CurlyBracketOpen)
+#define SEPARATOR_CURLYBRACKETCLOSE         COMPONENT(Separator, CurlyBracketClose)
+#define SEPARATOR_SQUAREBRACKETOPEN         COMPONENT(Separator, SquareBracketOpen)
+#define SEPARATOR_SQUAREBRACKETCLOSE        COMPONENT(Separator, SquareBracketClose)
+#define SEPARATOR_COMMA                     COMPONENT(Separator, Comma)
+#define SEPARATOR_DOT                       COMPONENT(Separator, Dot)
+#define SEPARATOR_SCOPE_RESOLUTION          COMPONENT(Separator, ScopeResolution)
+#define SEPARATOR_ENDOFEXPRESSION           COMPONENT(Separator, EndOfExpression)
+#define SEPARATOR_ENDOFPROGRAM              COMPONENT(Separator, EndOfProgram)

plugins/libimhex/include/hex/lang/validator.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include "token.hpp"
+#include "ast_node.hpp"
+
+#include <string>
+#include <vector>
+
+namespace hex::lang {
+
+    class Validator {
+    public:
+        Validator();
+
+        bool validate(const std::vector<ASTNode*>& ast);
+        void printAST(const std::vector<ASTNode*>& ast);
+
+        const std::pair<u32, std::string>& getError() { return this->m_error; }
+
+    private:
+        std::pair<u32, std::string> m_error;
+
+        using ValidatorError = std::pair<u32, std::string>;
+
+        [[noreturn]] void throwValidateError(std::string_view error, u32 lineNumber) const {
+            throw ValidatorError(lineNumber, error);
+        }
+
+    };
+
+}

plugins/libimhex/include/hex/plugin.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <glad/glad.h>
+#include <imgui.h>
+
+#include <hex.hpp>
+#include <hex/api/content_registry.hpp>
+#include <hex/views/view.hpp>
+#include <hex/providers/provider.hpp>
+#include <hex/helpers/shared_data.hpp>
+
+#define IMHEX_PLUGIN_SETUP      namespace hex::plugin::internal {               \
+                                    void initializePlugin();                    \
+                                }                                               \
+                                void hex::plugin::internal::initializePlugin()

plugins/libimhex/include/hex/providers/provider.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <hex/helpers/shared_data.hpp>
+
+namespace hex::prv {
+
+    class Provider {
+    public:
+        constexpr static size_t PageSize = 0x1000'0000;
+
+        Provider();
+        virtual ~Provider() = default;
+
+        virtual bool isAvailable() = 0;
+        virtual bool isReadable() = 0;
+        virtual bool isWritable() = 0;
+
+        virtual void read(u64 offset, void *buffer, size_t size);
+        virtual void write(u64 offset, const void *buffer, size_t size);
+
+        virtual void readRaw(u64 offset, void *buffer, size_t size) = 0;
+        virtual void writeRaw(u64 offset, const void *buffer, size_t size) = 0;
+        virtual size_t getActualSize() = 0;
+
+        std::map<u64, u8>& getPatches();
+        void applyPatches();
+
+        u32 getPageCount();
+        u32 getCurrentPage() const;
+        void setCurrentPage(u32 page);
+
+        virtual void setBaseAddress(u64 address);
+        virtual u64 getBaseAddress();
+        virtual size_t getSize();
+        virtual std::optional<u32> getPageOfAddress(u64 address);
+
+        virtual std::vector<std::pair<std::string, std::string>> getDataInformation() = 0;
+
+    protected:
+        u32 m_currPage = 0;
+        u64 m_baseAddress = 0;
+
+        std::vector<std::map<u64, u8>> m_patches;
+    };
+
+}

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

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <imgui.h>
+
+#include <hex/api/event.hpp>
+
+#include <functional>
+#include <string>
+#include <vector>
+
+
+namespace hex {
+
+    class View {
+    public:
+        View(std::string viewName);
+        virtual ~View() = default;
+
+        virtual void drawContent() = 0;
+        virtual void drawMenu();
+        virtual bool handleShortcut(int key, int mods);
+
+        static std::vector<std::function<void()>>& getDeferedCalls();
+
+        static void postEvent(Events eventType, const void *userData = nullptr);
+
+        static void drawCommonInterfaces();
+
+        static void showErrorPopup(std::string_view errorMessage);
+
+        virtual bool hasViewMenuItemEntry();
+        virtual ImVec2 getMinSize();
+        virtual ImVec2 getMaxSize();
+
+        bool& getWindowOpenState();
+
+        const std::string getName() const;
+
+    protected:
+        void subscribeEvent(Events eventType, std::function<void(const void*)> callback);
+
+        void unsubscribeEvent(Events eventType);
+
+        void doLater(std::function<void()> &&function);
+
+    protected:
+        void confirmButtons(const char *textLeft, const char *textRight, std::function<void()> leftButtonFn, std::function<void()> rightButtonFn);
+
+    private:
+        std::string m_viewName;
+        bool m_windowOpen = false;
+
+        static inline std::string s_errorMessage;
+    };
+
+}