#pragma once /* * Copyright (C) 2024 Brett Terpstra * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef BLT_GP_PROGRAM_H #define BLT_GP_PROGRAM_H #include #include #include #include #include #include #include #include #include namespace blt::gp { class identifier { }; class type { public: template static type make_type(blt::size_t id) { return type(sizeof(T), id, blt::type_string()); } [[nodiscard]] blt::size_t size() const { return size_; } [[nodiscard]] blt::size_t id() const { return id_; } [[nodiscard]] std::string_view name() const { return name_; } private: type(size_t size, size_t id, std::string_view name): size_(size), id_(id), name_(name) {} blt::size_t size_; blt::size_t id_; std::string name_; }; class type_system { public: type_system() = default; template inline type register_type() { types.push_back(type::make_type(types.size())); return types.back(); } private: std::vector types; }; class stack_allocator { constexpr static blt::size_t BLOCK_SIZE = 4096; public: private: template static inline auto to_block(T* p) { return reinterpret_cast(reinterpret_cast(p) & static_cast(~(BLOCK_SIZE - 1))); } struct block { struct block_metadata_t { block* next = nullptr; block* prev = nullptr; blt::u8* offset = nullptr; } metadata; blt::u8 buffer[BLOCK_SIZE - sizeof(block_metadata_t)]{}; block() { metadata.offset = buffer; } // remaining space inside the block after accounting for the metadata static constexpr blt::size_t BLOCK_REMAINDER = BLOCK_SIZE - sizeof(typename block::block_metadata_t); }; static block* allocate_block() { return reinterpret_cast(std::aligned_alloc(BLOCK_SIZE, BLOCK_SIZE)); } private: block* head = nullptr; }; template class operation { public: using function_t = std::function; operation(const operation& copy) = default; operation(operation&& move) = default; template, void>> explicit operation(const T& functor): func(functor) {} template, void>> explicit operation(const T& functor) { func = [&functor](Args... args) { return functor(args...); }; } explicit operation(function_t&& functor): func(std::move(functor)) {} inline Return operator()(Args... args) { return func(args...); } Return operator()(blt::span args) { auto pack_sequence = std::make_integer_sequence(); return function_evaluator(args, pack_sequence); } std::function)> to_functor() { return [this](blt::span args) { return this->operator()(args); }; } private: template static inline T& access_pack_index(blt::span args) { return *reinterpret_cast(args[index]); } template Return function_evaluator(blt::span args, std::integer_sequence) { return func(access_pack_index(args)...); } function_t func; }; } #endif //BLT_GP_PROGRAM_H