ScopeView.hpp

Go to the documentation of this file.

/**
 * @file Scope.hpp
 * @author Alexandre Plateau ([email protected])
 * @brief The virtual machine scope system
 * @date 2020-10-27
 *
 * @copyright Copyright (c) 2020-2025
 *
 */
 
#ifndef ARK_VM_SCOPE_HPP
#define ARK_VM_SCOPE_HPP
 
#include <array>
#include <cinttypes>
 
#include <Ark/Platform.hpp>
#include <Ark/VM/Value.hpp>
 
namespace Ark::internal
{
    /**
     * @brief A class to handle the VM scope more efficiently
     *
     */
    class ARK_API ScopeView
    {
    public:
        using pair_t = std::pair<uint16_t, Value>;
 
        /**
         * @brief Deleted constructor to avoid creating ScopeViews pointing to nothing. Helps catch bugs at compile time
         */
        ScopeView() = delete;
 
        /**
         * @brief Create a new ScopeView
         *
         * @param storage pointer to the shared scope storage
         * @param start first free starting position
         */
        ScopeView(pair_t* storage, std::size_t start) noexcept;
 
        /**
         * @brief Put a value in the scope
         *
         * @param id The symbol id of the variable
         * @param val The value linked to the symbol
         */
        void push_back(uint16_t id, Value&& val) noexcept;
 
        /**
         * @brief Put a value in the scope
         *
         * @param id The symbol id of the variable
         * @param val The value linked to the symbol
         */
        void push_back(uint16_t id, const Value& val) noexcept;
 
        /**
         * @brief Check if the scope maybe holds a specific symbol in memory
         *
         * @param id The id of the symbol
         * @return true On success
         * @return false Otherwise
         */
        bool maybeHas(uint16_t id) const noexcept;
 
        /**
         * @brief Get a value from its symbol id
         *
         * @param id_to_look_for
         * @return Value* Returns nullptr if the value can not be found
         */
        Value* operator[](uint16_t id_to_look_for) noexcept;
 
        /**
         * @brief Get a value from its symbol id
         *
         * @param id_to_look_for
         * @return const Value* Returns nullptr if the value can not be found
         */
        const Value* operator[](uint16_t id_to_look_for) const noexcept;
 
        /**
         * @brief Get the id of a variable based on its value ; used for debug only
         *
         * @param val
         * @return uint16_t
         */
        [[nodiscard]] uint16_t idFromValue(const Value& val) const noexcept;
 
        /**
         * @brief Return the element at index in scope
         *
         * @return const pair_t&
         */
        [[nodiscard]] inline const pair_t& atPos(const std::size_t i) const noexcept
        {
            return m_storage[m_start + i];
        }
 
        /**
         * @brief Return the element at index, starting from the end
         *
         * @return const pair_t&
         */
        [[nodiscard]] inline pair_t& atPosReverse(const std::size_t i) noexcept
        {
            return m_storage[m_start + m_size - 1 - i];
        }
 
        /**
         * @brief Reset size, min and max id for the scope, to signify it's empty
         */
        void reset() noexcept;
 
        /**
         * @brief Return the size of the scope
         *
         * @return const std::size_t
         */
        [[nodiscard]] inline std::size_t size() const noexcept
        {
            return m_size;
        }
 
        /**
         * @brief Compute the position of the first free slot in the shared storage, after this scope
         *
         * @return std::size_t
         */
        [[nodiscard]] inline std::size_t storageEnd() const noexcept
        {
            return m_start + m_size;
        }
 
        friend ARK_API bool operator==(const ScopeView& A, const ScopeView& B) noexcept;
 
        friend class Ark::VM;
 
    private:
        pair_t* m_storage;
        std::size_t m_start;
        std::size_t m_size;
        uint16_t m_min_id;  ///< Minimum stored ID, used for a basic bloom filter
        uint16_t m_max_id;  ///< Maximum stored ID, used for a basic bloom filter
    };
}
 
#endif