elna/source/result.cpp

#include "elna/source/result.hpp"

namespace elna::source
{
    error::error(const position position)
        : m_position(position)
    {
    }

    std::size_t error::line() const noexcept
    {
        return this->m_position.line;
    }

    std::size_t error::column() const noexcept
    {
        return this->m_position.column;
    }

    name_collision::name_collision(const std::string& name, const position current, const position previous)
        : error(current), name(name), previous(previous)
    {
    }

    std::string name_collision::what() const
    {
        return "Name '" + name + "' was already defined";
    }

    type::type(const std::size_t byte_size)
        : byte_size(byte_size)
    {
    }

    primitive_type::primitive_type(const std::string& type_name, const std::size_t byte_size)
        : type(byte_size), type_name(type_name)
   {
   }

    symbol_table::symbol_table(std::shared_ptr<symbol_table> scope)
        : outer_scope(scope)
    {
        if (scope == nullptr)
        {
            auto writei = std::make_shared<intrinsic_info>();
            writei->parameter_infos.emplace_back(int_type);
            enter("writei", writei);

            auto writeb = std::make_shared<intrinsic_info>();
            writeb->parameter_infos.emplace_back(boolean_type);
            enter("writeb", writeb);

            enter("Boolean", std::make_shared<type_info>(boolean_type));
            enter("Int", std::make_shared<type_info>(int_type));
        }
    }

    std::shared_ptr<info> symbol_table::lookup(const std::string& name)
    {
        auto entry = entries.find(name);

        if (entry != entries.cend())
        {
            return entry->second;
        }
        if (this->outer_scope != nullptr)
        {
            return this->outer_scope->lookup(name);
        }
        return nullptr;
    }

    void symbol_table::enter(const std::string& name, std::shared_ptr<info> entry)
    {
        entries.insert_or_assign(name, entry);
    }

    std::shared_ptr<symbol_table> symbol_table::scope()
    {
        return this->outer_scope;
    }

    info::~info()
    {
    }

    info::info()
    {
    }

    type_info::type_info(const class type& type)
        : info(), m_type(type)
    {
    }

    type_info::~type_info()
    {
    }

    const class type& type_info::type() const noexcept
    {
        return m_type;
    }

    constant_info::constant_info(const std::int32_t value)
        : m_value(value)
    {
    }

    constant_info::~constant_info()
    {
    }

    std::int32_t constant_info::value() const noexcept
    {
        return m_value;
    }

    variable_info::variable_info(const class type& type)
        : m_type(type)
    {
    }

    variable_info::~variable_info()
    {
    }

    const class type& variable_info::type() const noexcept
    {
        return m_type;
    }

    parameter_info::parameter_info(const class type& type)
        : m_type(type)
    {
    }

    parameter_info::~parameter_info()
    {
    }

    const class type& parameter_info::type() const noexcept
    {
        return m_type;
    }

    intrinsic_info::~intrinsic_info()
    {
    }

    std::size_t intrinsic_info::parameter_stack_size() const noexcept
    {
        return this->parameter_infos.size() * sizeof(std::int32_t);
    }

    procedure_info::procedure_info(std::shared_ptr<symbol_table> outer_scope)
        : local_table(std::make_shared<symbol_table>(outer_scope))
    {
    }

    procedure_info::~procedure_info()
    {
    }

    std::shared_ptr<symbol_table> procedure_info::scope()
    {
        return local_table;
    }

    std::size_t procedure_info::stack_size() const noexcept
    {
        return local_stack_size + argument_stack_size;
    }
}