fasmcpp.h

#pragma once

#include <string>
#include <vector>
#include <unordered_map>

#include "fasmIO.h"

class AssemblyKey;

namespace fasmcpp
{
    namespace size_multipliers
    {
        constexpr size_t operator""_KB(unsigned long long int size)
        {
            return static_cast<size_t>(size * 1024);
        }

        constexpr size_t operator""_KB(long double size)
        {
            return static_cast<size_t>(size * 1024);
        }

        constexpr size_t operator""_MB(unsigned long long int size)
        {
            return static_cast<size_t>(size * 1024 * 1024);
        }

        constexpr size_t operator""_MB(long double size)
        {
            return static_cast<size_t>(size * 1024 * 1024);
        }

        constexpr size_t operator""_GB(unsigned long long int size)
        {
            return static_cast<size_t>(size * 1024 * 1024 * 1024);
        }

        constexpr size_t operator""_GB(long double size)
        {
            return static_cast<size_t>(size * 1024 * 1024 * 1024);
        }
    }

    using ::fasmcpp::size_multipliers::operator""_KB;

    class Assembler
    {
    public:
        Assembler();
        Assembler(size_t memory, size_t predefinitionsMemory = 10_KB);
        Assembler(const Assembler&) = delete;
        Assembler(Assembler&&);
        Assembler& operator=(const Assembler&) = delete;
        Assembler& operator=(Assembler&&);
        ~Assembler();
        void* getMemory() const;
        uint32_t getMemorySize() const;
        char* getPredefinitionsMemory() const;
        uint32_t getPredefinitionsMemorySize() const;

    private:
        void* _assemblerMemory;
        uint32_t _assemblerMemorySize;
        char* _predefinitionsMemory = nullptr;
        uint32_t _predefinitionsMemorySize = 0;
    };

    class Assembly
    {
    public:
        Assembly();
        Assembly(const char* code);
        Assembly(const Assembly&) = delete;
        Assembly(Assembly&&);
        Assembly& operator=(const Assembly&) = delete;
        Assembly& operator=(Assembly&&);
        void setAssembler(Assembler* assembler);
        Assembler* getAssembler() const;
        bool assemble();
        int64_t run(bool preserveRegisters = true) const;
        const char* getErrors() const;
        const char* getMessages() const;
        void addError(const char* error, AssemblyKey);
        void addMessage(const char* message, AssemblyKey);
        _fasmcpp::AssemblerInput& getInput(AssemblyKey);
        _fasmcpp::AssemblerOutput& getOutput(AssemblyKey);
        void addPredefinition(const char* name, const char* value);
        void addPredefinition(const char* name, const void* value);
        void clearPredefinitions();
        const char* getOutput();
        size_t getOutputSize();

    private:
        void allocateExecutableMemory(size_t size);
        void freeExecutableMemory();

        Assembler* _assembler;
        _fasmcpp::AssemblerInput _code;
        _fasmcpp::AssemblerOutput _bytecode;
        std::string _errors;
        std::string _messages;
        std::unordered_map<std::string, std::string> _predefinitions;
        bool _predefinitionsChanged = false;
        void* _executableMemory = nullptr;
        size_t _executableMemorySize = 0;

#ifdef _WIN64
        const char* rebuildPredefinitionsString();
#else
        std::vector<char> _predefinitionsString;
#endif
    };
}