dyn_segment.hpp

// SPDX-License-Identifier: BSL-1.0
#ifndef CEL_RUNTIME_DYN_SEGMENT_HPP
#define CEL_RUNTIME_DYN_SEGMENT_HPP
#include <cel/runtime/detail/raw_segment.hpp>
#include <concepts>
#include <new>
#include <optional>
#include <vector>
 
namespace cel {

struct stack_origin {
    std::size_t bytes = 0; 
    std::size_t depth = 0; 
};

inline bool operator==(const stack_origin& left, const stack_origin& right) noexcept {
    return left.bytes == right.bytes && left.depth == right.depth;
}
class compiled_segment;
namespace detail {
class prepared_raw_segment;
}
template <class R, class... Args>
class prepared_segment;

struct stack_reservation {
    layout bytes;      
    std::size_t slots; 
};

struct stack_requirements {
    std::size_t alignment = 1;    
    std::size_t frame_extent = 0; 
    std::size_t live_slots = 0;   

    stack_reservation for_prefix(std::size_t cursor, std::size_t depth) const;
};
 
namespace detail {
struct frozen_program;
template <class T>
inline constexpr bool native_leaf = true;
template <class T, class A>
inline constexpr bool native_leaf<std::vector<T, A>> = false;
template <class... T>
inline constexpr bool native_leaf<std::tuple<T...>> = false;
template <class T>
struct callback_signature {};
template <class R, class... A>
struct callback_signature<R (*)(A...)> {
    using arguments = std::tuple<std::remove_cvref_t<A>...>; 
};
template <class R, class... A>
struct callback_signature<R (*)(A...) noexcept> : callback_signature<R (*)(A...)> {};
template <class C, class R, class... A>
struct callback_signature<R (C::*)(A...) const> : callback_signature<R (*)(A...)> {};
template <class C, class R, class... A>
struct callback_signature<R (C::*)(A...) const noexcept> : callback_signature<R (*)(A...)> {};
template <class C, class R, class... A>
struct callback_signature<R (C::*)(A...) const&> : callback_signature<R (*)(A...)> {};
template <class C, class R, class... A>
struct callback_signature<R (C::*)(A...) const & noexcept> : callback_signature<R (*)(A...)> {};
template <class F, class R, class... A>
consteval auto generic_member() {
    if constexpr (requires { static_cast<R (F::*)(A...) const>(&F::template operator()); })
        return static_cast<R (F::*)(A...) const>(&F::template operator());
    else if constexpr (requires { static_cast<R (F::*)(A...) const&>(&F::template operator()); })
        return static_cast<R (F::*)(A...) const&>(&F::template operator());
    else if constexpr (requires {
                           static_cast<R (F::*)(const A&...) const>(&F::template operator());
                       })
        return static_cast<R (F::*)(const A&...) const>(&F::template operator());
    else if constexpr (requires {
                           static_cast<R (F::*)(const A&...) const&>(&F::template operator());
                       })
        return static_cast<R (F::*)(const A&...) const&>(&F::template operator());
    else if constexpr (requires { static_cast<R (F::*)(A&&...) const>(&F::template operator()); })
        return static_cast<R (F::*)(A&&...) const>(&F::template operator());
    else if constexpr (requires { static_cast<R (F::*)(A&&...) const&>(&F::template operator()); })
        return static_cast<R (F::*)(A&&...) const&>(&F::template operator());
}
template <class F, class R, class... A>
consteval bool exact_callback() {
    using callback_type = std::decay_t<F>;
    if constexpr (!std::is_invocable_v<const callback_type&, A...>)
        return false;
    else {
        constexpr bool result_matches =
            std::same_as<R, std::remove_cvref_t<std::invoke_result_t<const callback_type&, A...>>>;
        if constexpr (requires { typename callback_signature<callback_type>::arguments; })
            return result_matches &&
                   std::same_as<typename callback_signature<callback_type>::arguments,
                                std::tuple<A...>>;
        else if constexpr (requires {
                               typename callback_signature<
                                   decltype(&callback_type::operator())>::arguments;
                           })
            return result_matches &&
                   std::same_as<
                       typename callback_signature<decltype(&callback_type::operator())>::arguments,
                       std::tuple<A...>>;
        else {
            using member =
                decltype(generic_member<callback_type,
                                        std::invoke_result_t<const callback_type&, A...>, A...>());
            if constexpr (std::is_void_v<member>)
                return false;
            else
                return result_matches && std::is_invocable_v<member, const callback_type&, A...>;
        }
    }
}
template <class Signature, class F>
struct signature_binding {
    static constexpr bool available = false; 
};
template <class R, class... A, class F>
struct signature_binding<R(A...), F> {
    static consteval auto select() {
        if constexpr (requires { static_cast<R (F::*)(A...) const>(&F::operator()); })
            return static_cast<R (F::*)(A...) const>(&F::operator());
        else if constexpr (requires { static_cast<R (F::*)(A...) const&>(&F::operator()); })
            return static_cast<R (F::*)(A...) const&>(&F::operator());
    }
    static constexpr bool available = !std::is_void_v<decltype(select())>;
};
template <class Signature, class F>
class signature_callback;
template <class R, class... A, class F>
class signature_callback<R(A...), F> {
    F _callback;
 
public:
    template <class G>
    requires(!std::same_as<std::remove_cvref_t<G>, signature_callback> &&
             std::constructible_from<F, G&&>) explicit signature_callback(G&& callback) :
        _callback(std::forward<G>(callback)) {}
    R operator()(A... arguments) const {
        return std::invoke(signature_binding<R(A...), F>::select(), _callback,
                           std::forward<A>(arguments)...);
    }
};
struct argument_read {
    std::size_t index; 
    value_type type;   
};
struct construction_effect {
    std::size_t cursor;              
    stack_requirements requirements; 
};
} // namespace detail

template <class Signature, class F>
requires(detail::signature_binding<Signature, std::decay_t<F>>::available) auto with_signature(
    F&& callback) {
    return detail::signature_callback<Signature, std::decay_t<F>>(std::forward<F>(callback));
}

class dyn_segment {
    detail::raw_segment _body;
    std::vector<value_type> _stack;
    std::vector<detail::argument_read> _reads;
    std::vector<std::size_t> _end_cursors; 
    stack_requirements _requirements;      
    stack_origin _origin; 
    std::vector<std::optional<stack_requirements>> _known_calls; 
    void pack(value_type type, std::span<const std::size_t> permutation, stack_origin ambient);
    void project(std::size_t index, type_kind category);
    detail::construction_effect check_operation(std::span<const value_type> inputs,
                                                std::span<const value_type> outputs);
    void apply_operation(std::size_t consumed,
                         std::span<const value_type> outputs,
                         const detail::construction_effect& effect) noexcept;
 
public:
    dyn_segment() = default;
    explicit dyn_segment(stack_origin origin) : _origin(origin) {}
    dyn_segment(const dyn_segment&) = delete;
    dyn_segment& operator=(const dyn_segment&) = delete;
    dyn_segment(dyn_segment&&) noexcept = default;
    dyn_segment& operator=(dyn_segment&&) noexcept = default;
    stack_origin origin() const noexcept { return _origin; }
    std::span<const value_type> operand_types(std::size_t arity) const noexcept {
        if (arity > _stack.size()) return {};
        return std::span<const value_type>(_stack).last(arity);
    }

    stack_origin snapshot() const;
    stack_origin origin_below(std::size_t count) const;
    stack_origin before_top() const;
    void make_tuple(std::size_t count, stack_origin ambient);
    void make_array(std::size_t count, value_type element, stack_origin ambient);
    void make_record(value_type record, stack_origin ambient);
    void make_record(value_type record,
                     std::span<const std::size_t> permutation,
                     stack_origin ambient);
    void project_tuple(std::size_t index);
    void project_record(std::string_view name);
    // [knowledge] Check representability before the size_t cast, then exact bounds before access.
    void index_array();
    void make_range(range_kind kind);
    void if_else(dyn_segment then_body, dyn_segment else_body);
    void logical_and(dyn_segment rhs);
    void logical_or(dyn_segment rhs);
    void push_closure(compiled_segment body, std::span<const value_type> parameters);
    void invoke_closure(std::size_t arity);
    void push_argument(std::size_t index, value_type type);
    void just(value literal);
    template <class R, class... Args, class F>
    requires(detail::exact_callback<F, R, Args...>()) void op(F&& callback) {
        static_assert((std::same_as<Args, std::remove_cvref_t<Args>> && ...));
        const std::array<value_type, sizeof...(Args)> inputs{
            detail::concrete_adapter<Args>::type()...};
        const auto outputs = [] {
            if constexpr (std::is_void_v<R>)
                return std::array<value_type, 0>{};
            else
                return std::array{detail::concrete_adapter<R>::type()};
        }();
        const auto effect = check_operation(inputs, outputs);
        _body.template push_op<R, Args...>(
            [callback = std::forward<F>(callback)](detail::frame&, Args&&... operands) -> R {
                return std::invoke(callback, std::move(operands)...);
            });
        apply_operation(sizeof...(Args), outputs, effect);
    }

    template <class R, class F>
    requires(detail::exact_callback<F, R>()) void op0(F&& callback) {
        op<R>(std::forward<F>(callback));
    }

    template <class R, class A, class F>
    requires(detail::exact_callback<F, R, A>()) void op1(F&& callback) {
        op<R, A>(std::forward<F>(callback));
    }

    template <class R, class A, class B, class F>
    requires(detail::exact_callback<F, R, A, B>()) void op2(F&& callback) {
        op<R, A, B>(std::forward<F>(callback));
    }

    template <class R, class A, class B, class C, class F>
    requires(detail::exact_callback<F, R, A, B, C>()) void op3(F&& callback) {
        op<R, A, B, C>(std::forward<F>(callback));
    }

    compiled_segment finish() &&;
};

class compiled_segment {
    detail::retirement_ptr<const detail::frozen_program> _program;
    friend class dyn_segment;
    friend struct detail::segment_access;
    explicit compiled_segment(
        detail::retirement_ptr<const detail::frozen_program> program) noexcept;

    detail::prepared_raw_segment prepare_raw(std::span<const value_type> arguments,
                                             const value_type& result) const;
 
public:
    compiled_segment(const compiled_segment&) = delete;
    compiled_segment& operator=(const compiled_segment&) = delete;
    compiled_segment(compiled_segment&&) noexcept = default;
    compiled_segment& operator=(compiled_segment&&) noexcept = default;
    const value_type& result_type() const noexcept;
    const stack_requirements& requirements() const noexcept;
    value execute(raw_stack& stack, std::span<const value> arguments) const;
    template <class R, class... Args>
    prepared_segment<R, Args...> prepare() const;
};
 
namespace detail {
class prepared_raw_segment {
    detail::retirement_ptr<const detail::frozen_program> _program;
    std::vector<value_type> _arguments;
    value_type _result;
    std::vector<bool> _used;
    value_type _unit;
    friend class cel::compiled_segment;
    friend struct segment_access;
    template <class R, class... Args>
    friend class cel::prepared_segment;
    prepared_raw_segment(detail::retirement_ptr<const detail::frozen_program> program,
                         std::span<const value_type> arguments,
                         value_type result);
 
public:
    prepared_raw_segment(const prepared_raw_segment&) = delete;
    prepared_raw_segment& operator=(const prepared_raw_segment&) = delete;
    prepared_raw_segment(prepared_raw_segment&&) noexcept = default;
    prepared_raw_segment& operator=(prepared_raw_segment&&) noexcept = default;
    std::span<const value_type> argument_types() const noexcept { return _arguments; }
    const value_type& result_type() const noexcept { return _result; }
    const stack_requirements& requirements() const noexcept;
    void call_into(raw_stack& stack,
                   std::span<const borrowed_value> arguments,
                   std::byte* result_destination) const;
    void destroy_result(std::byte* result) const noexcept;
};

const std::byte* canonical_data(const value& source) noexcept;
template <class T>
struct typed_input {
    using storage = std::conditional_t<native_leaf<T>, std::reference_wrapper<const T>, value>;
    storage source; 

    static storage bind(const T& input, bool used) {
        if constexpr (native_leaf<T>) {
            return std::cref(input);
        } else {
            return used ? value::from(input) : value{};
        }
    }
    explicit typed_input(const T& input, bool used) : source(bind(input, used)) {}
    borrowed_value borrow(const value_type& type) const noexcept {
        if constexpr (native_leaf<T>) {
            return {type, reinterpret_cast<const std::byte*>(&source.get())};
        } else {
            return {type, canonical_data(source)};
        }
    }
};
class result_storage {
    const prepared_raw_segment& _binding;
    std::byte* _data;
    bool _initialized = false;
 
public:
    explicit result_storage(const prepared_raw_segment& binding);
    ~result_storage();
    result_storage(const result_storage&) = delete;
    result_storage& operator=(const result_storage&) = delete;
    std::byte* data() const noexcept { return _data; }
    void initialized() noexcept { _initialized = true; }
};
} // namespace detail

template <class R, class... Args>
class prepared_segment {
    detail::prepared_raw_segment _binding;
    friend class compiled_segment;
    explicit prepared_segment(detail::prepared_raw_segment binding) :
        _binding(std::move(binding)) {}
    template <std::size_t... I>
    auto bind(const std::tuple<const Args&...>& inputs, std::index_sequence<I...>) const {
        return std::tuple<detail::typed_input<Args>...>{
            detail::typed_input<Args>(std::get<I>(inputs), _binding._used[I])...};
    }
    template <std::size_t... I>
    auto borrow(const std::tuple<detail::typed_input<Args>...>& inputs,
                std::index_sequence<I...>) const {
        return std::array<detail::borrowed_value, sizeof...(Args)>{
            (_binding._used[I] ? std::get<I>(inputs).borrow(_binding.argument_types()[I]) :
                                 detail::borrowed_value{_binding._unit, nullptr})...};
    }
 
public:
    prepared_segment(const prepared_segment&) = delete;
    prepared_segment& operator=(const prepared_segment&) = delete;
    prepared_segment(prepared_segment&&) noexcept = default;
    prepared_segment& operator=(prepared_segment&&) noexcept = default;
    const stack_requirements& requirements() const noexcept { return _binding.requirements(); }
    R call(raw_stack& stack, const Args&... arguments) const {
        const auto inputs = bind(std::tie(arguments...), std::index_sequence_for<Args...>{});
        const auto views = borrow(inputs, std::index_sequence_for<Args...>{});
        if constexpr (detail::native_leaf<R>) {
            alignas(R) std::array<std::byte, sizeof(R)> bytes{};
            _binding.call_into(stack, views, bytes.data());
            return detail::concrete_adapter<R>::read(_binding.result_type(), bytes.data());
        } else {
            detail::result_storage result(_binding);
            _binding.call_into(stack, views, result.data());
            result.initialized();
            return detail::concrete_adapter<R>::read(_binding.result_type(), result.data());
        }
    }
};

template <class R, class... Args>
prepared_segment<R, Args...> compiled_segment::prepare() const {
    static_assert(!std::is_void_v<R>, "use tuple<> for the source-unit result");
    const std::array<value_type, sizeof...(Args)> types{detail::concrete_adapter<Args>::type()...};
    return prepared_segment<R, Args...>(prepare_raw(types, detail::concrete_adapter<R>::type()));
}

} // namespace cel
#endif