raw_stack.hpp

// SPDX-License-Identifier: BSL-1.0
#ifndef CEL_RUNTIME_RAW_STACK_HPP
#define CEL_RUNTIME_RAW_STACK_HPP
 
#include <array>
#include <cel/runtime/value.hpp>
#include <cstddef>
#include <memory>
#include <span>
#include <tuple>
#include <utility>
 
namespace cel {
 
namespace detail {
class frame;
class raw_segment;
struct stack_state;
struct frame_access;
} // namespace detail

// [knowledge] Transfer only internal canonical carriers bytewise, never public facades.
// [knowledge] Keep the ownership-phase gate nonallocating and release it before ordinary callbacks.
class raw_stack {
    std::unique_ptr<detail::stack_state> _state;
    friend class detail::frame;
    friend struct detail::frame_access;

    class phase_guard {
        detail::stack_state* _state;
 
    public:
        explicit phase_guard(raw_stack& stack) noexcept;
        ~phase_guard() noexcept;
        phase_guard(const phase_guard&) = delete;
        phase_guard& operator=(const phase_guard&) = delete;
    };
    detail::stack_state& state();
    void require_idle() const;
    void require_access(const detail::frame* owner) const;
    template <class T>
    T read_value(std::size_t floor) {
        if (depth() <= floor) throw std::out_of_range("operand underflow");
        phase_guard phase(*this);
        const auto type = detail::concrete_adapter<T>::type();
        return detail::concrete_adapter<T>::read(type, borrow(floor, 0, type));
    }
    std::size_t prepare(const value_type& type);
    void publish(const value_type& type, std::size_t offset) noexcept;
    void push_written(const value_type& type,
                      const void* source,
                      void (*write)(const void*, const value_type&, std::byte*));
    void clone(const value& source);
    void take(value& source);
    const std::byte* borrow(std::size_t floor,
                            std::size_t from_top,
                            const value_type& expected) const;
    const std::byte* borrow_trusted(std::size_t floor,
                                    std::size_t from_top,
                                    const value_type& expected) const;
    void truncate(std::size_t floor) noexcept;
    value extract(std::size_t floor);
    void release(std::size_t floor, const value_type& expected, std::byte* destination);
 
public:
    raw_stack();
    ~raw_stack();
    raw_stack(const raw_stack&) = delete;
    raw_stack& operator=(const raw_stack&) = delete;
    raw_stack(raw_stack&& other);
    raw_stack& operator=(raw_stack&& other);
    void reserve(std::size_t bytes, std::size_t alignment);
    void reserve_depth(std::size_t count);
    void clear();
    std::size_t depth() const noexcept;
    std::size_t cursor() const noexcept;
    template <class T>
    void push(const T& source) {
        require_access(nullptr);
        push_written(detail::concrete_adapter<T>::type(), &source,
                     [](const void* input, const value_type& type, std::byte* destination) {
                         detail::concrete_adapter<T>::write(*static_cast<const T*>(input), type,
                                                            destination);
                     });
    }

    template <class T>
    T pop() {
        require_access(nullptr);
        auto result = read_value<T>(0);
        truncate(depth() - 1);
        return result;
    }

    void push_clone(const value& source);
    void push_take(value& source);
    value pop_value();
};

} // namespace cel
#endif