call.hpp

#pragma once
 
#include <array>
#include <bit>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <memory>
#include <span>
#include <stdexcept>
#include <type_traits>
 
#include "plugify/global.h"
#include "plugify/mem_addr.hpp"
#include "plugify/method.hpp"
#include "plugify/property.hpp"
#include "plugify/signarure.hpp"
#include "plugify/value_type.hpp"
#include "plg/inplace_vector.hpp"
 
namespace plugify {
    class Return;
 
    class PLUGIFY_API JitCall {
    public:
        JitCall();
 
        JitCall(const JitCall& other) = delete;
 
        JitCall(JitCall&& other) noexcept;
 
        ~JitCall();
 
        enum class WaitType { None, Breakpoint, Wait_Keypress };
 
 
        using CallingFunc = void (*)(const uint64_t* params, const Return*);  // Return can be null
 
        using HiddenParam = bool (*)(ValueType);
 
        MemAddr GetJitFunc(const Signature& sig, MemAddr target, WaitType waitType, bool hidden);
 
        MemAddr GetJitFunc(
            const Method& method,
            MemAddr target,
            WaitType waitType = WaitType::None,
            HiddenParam hidden = &ValueUtils::IsHiddenParam
        );
 
        MemAddr GetFunction() const noexcept;
 
        MemAddr GetTargetFunc() const noexcept;
 
        std::string_view GetError() noexcept;
 
        JitCall& operator=(const JitCall& other) = delete;
 
        JitCall& operator=(JitCall&& other) noexcept;
 
        PLUGIFY_ACCESS : struct Impl;
        PLUGIFY_NO_DLL_EXPORT_WARNING(std::unique_ptr<Impl> _impl;)
    };
 
    // Concept for types that can be stored in parameter slots
    template <typename T>
    concept ParameterType = std::is_trivially_copyable_v<T>
                            && (std::is_arithmetic_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>);
 
    // Concept for types that fit in a single slot
    template <typename T>
    concept SingleSlotType = ParameterType<T> && sizeof(T) <= sizeof(uint64_t);
 
    // Concept for types that need multiple slots
    template <typename T>
    concept MultiSlotType = ParameterType<T> && sizeof(T) > sizeof(uint64_t);
 
    class Parameters {
    public:
        using SlotType = uint64_t;
        static constexpr size_t SlotSize = sizeof(SlotType);
 
        explicit Parameters(size_t slotCount) {
            _storage.reserve(slotCount);
        }
 
        template <SingleSlotType T>
        Parameters& Add(T value) {
            SlotType& slot = _storage.emplace_back();
            std::memcpy(&slot, &value, sizeof(T));
            return *this;
        }
 
        template <MultiSlotType T>
        Parameters& AddLarge(const T& value) {
            constexpr size_t slotsNeeded = (sizeof(T) + SlotSize - 1) / SlotSize;
            size_t oldSize = _storage.size();
            _storage.resize(oldSize + slotsNeeded);
            std::memcpy(&_storage[oldSize], &value, sizeof(T));
            return *this;
        }
 
        template <typename... Args>
            requires(ParameterType<Args> && ...)
        Parameters& AddMultiple(Args... args) {
            (Add(args), ...);
            return *this;
        }
 
        template <SingleSlotType T>
        Parameters& SetAt(size_t index, T value) {
            SlotType& slot = _storage.at(index);
            slot = {};
            std::memcpy(&slot, &value, sizeof(T));
            return *this;
        }
 
        [[nodiscard]] const SlotType* Get() const noexcept {
            return _storage.data();
        }
 
        [[nodiscard]] std::span<const SlotType> GetSpan() const noexcept {
            return { _storage.data(), _storage.size() };
        }
 
        [[nodiscard]] size_t GetUsedSlots() const noexcept {
            return _storage.size();
        }
 
        [[nodiscard]] size_t GetCapacity() const noexcept {
            return _storage.capacity();
        }
 
        void Reset() noexcept {
            _storage.clear();
        }
 
        [[nodiscard]] bool HasSpace(size_t slotsNeeded = 1) const noexcept {
            return _storage.size() + slotsNeeded < _storage.capacity();
        }
 
    private:
        std::inplace_vector<SlotType, Signature::kMaxFuncArgs> _storage{};  
    };
 
    class Return {
    public:
        using SlotType = uint64_t;
        static constexpr size_t MaxSize = 2 * sizeof(SlotType);
 
        template <typename T, typename... Args>
            requires(sizeof(T) <= MaxSize && std::is_trivially_destructible_v<T>)
        void Construct(Args&&... args) noexcept(noexcept(T(std::forward<Args>(args)...))) {
            std::construct_at(reinterpret_cast<T*>(_storage.data()), std::forward<Args>(args)...);
        }
 
        template <typename T>
            requires(sizeof(T) <= MaxSize && std::is_trivially_copyable_v<T>)
        void Set(T value) noexcept {
            _storage = {};
            std::memcpy(_storage.data(), &value, sizeof(T));
        }
 
        template <typename T>
            requires(sizeof(T) <= MaxSize && std::is_trivially_copyable_v<T>)
        [[nodiscard]] T Get() const noexcept {
            T result;
            std::memcpy(&result, _storage.data(), sizeof(T));
            return result;
        }
 
        void Clear() noexcept {
            _storage = {};
        }
 
    private:
        alignas(alignof(std::max_align_t))
        std::array<std::byte, MaxSize> _storage{};  
    };
}  // namespace plugify