diff options
Diffstat (limited to 'frontend/symbol.cc')
| -rw-r--r-- | frontend/symbol.cc | 427 |
1 files changed, 0 insertions, 427 deletions
diff --git a/frontend/symbol.cc b/frontend/symbol.cc deleted file mode 100644 index bfecbd4..0000000 --- a/frontend/symbol.cc +++ /dev/null @@ -1,427 +0,0 @@ -/* Symbol definitions. - Copyright (C) 2025 Free Software Foundation, Inc. - -GCC 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, or (at your option) -any later version. - -GCC 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 GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -#include "elna/frontend/symbol.h" - -namespace elna::frontend -{ - type::type() - { - } - - type::type(std::shared_ptr<alias_type> alias) - : tag(type_tag::alias), alias(alias) - { - } - - type::type(std::shared_ptr<primitive_type> primitive) - : tag(type_tag::primitive), primitive(primitive) - { - } - - type::type(std::shared_ptr<record_type> record) - : tag(type_tag::record), record(record) - { - } - - type::type(std::shared_ptr<union_type> _union) - : tag(type_tag::_union), _union(_union) - { - } - - type::type(std::shared_ptr<pointer_type> pointer) - : tag(type_tag::pointer), pointer(pointer) - { - } - - type::type(std::shared_ptr<array_type> array) - : tag(type_tag::array), array(array) - { - } - - type::type(std::shared_ptr<procedure_type> procedure) - : tag(type_tag::procedure), procedure(procedure) - { - } - - type::type(std::shared_ptr<enumeration_type> enumeration) - : tag(type_tag::enumeration), enumeration(enumeration) - { - } - - void type::copy(const type& other) - { - switch (other.tag) - { - case type_tag::empty: - break; - case type_tag::alias: - new (&alias) std::weak_ptr<alias_type>(other.alias); - break; - case type_tag::primitive: - new (&primitive) std::shared_ptr<primitive_type>(other.primitive); - break; - case type_tag::record: - new (&record) std::shared_ptr<record_type>(other.record); - break; - case type_tag::_union: - new (&_union) std::shared_ptr<union_type>(other._union); - break; - case type_tag::pointer: - new (&pointer) std::shared_ptr<pointer_type>(other.pointer); - break; - case type_tag::array: - new (&array) std::shared_ptr<array_type>(other.array); - break; - case type_tag::procedure: - new (&procedure) std::shared_ptr<procedure_type>(other.procedure); - break; - case type_tag::enumeration: - new (&enumeration) std::shared_ptr<enumeration_type>(other.enumeration); - break; - } - } - - type::type(const type& other) - : tag(other.tag) - { - copy(other); - } - - void type::move(type&& other) - { - switch (other.tag) - { - case type_tag::empty: - break; - case type_tag::alias: - new (&alias) std::weak_ptr<alias_type>(std::move(other.alias)); - break; - case type_tag::primitive: - new (&primitive) std::shared_ptr<primitive_type>(std::move(other.primitive)); - break; - case type_tag::record: - new (&record) std::shared_ptr<record_type>(std::move(other.record)); - break; - case type_tag::_union: - new (&_union) std::shared_ptr<union_type>(std::move(other._union)); - break; - case type_tag::pointer: - new (&pointer) std::shared_ptr<pointer_type>(std::move(other.pointer)); - break; - case type_tag::array: - new (&array) std::shared_ptr<array_type>(std::move(other.array)); - break; - case type_tag::procedure: - new (&procedure) std::shared_ptr<procedure_type>(std::move(other.procedure)); - break; - case type_tag::enumeration: - new (&enumeration) std::shared_ptr<enumeration_type>(std::move(other.enumeration)); - break; - } - } - - type& type::operator=(const type& other) - { - this->~type(); - this->tag = other.tag; - copy(other); - return *this; - } - - type::type(type&& other) - : tag(other.tag) - { - move(std::move(other)); - } - - type& type::operator=(type&& other) - { - this->~type(); - this->tag = other.tag; - move(std::move(other)); - return *this; - } - - bool type::operator==(const std::nullptr_t&) - { - return empty(); - } - - type::~type() - { - switch (tag) - { - case type_tag::empty: - break; - case type_tag::alias: - this->alias.~weak_ptr<alias_type>(); - break; - case type_tag::primitive: - this->primitive.~shared_ptr<primitive_type>(); - break; - case type_tag::record: - this->record.~shared_ptr<record_type>(); - break; - case type_tag::_union: - this->_union.~shared_ptr<union_type>(); - break; - case type_tag::pointer: - this->pointer.~shared_ptr<pointer_type>(); - break; - case type_tag::array: - this->array.~shared_ptr<array_type>(); - break; - case type_tag::procedure: - this->procedure.~shared_ptr<procedure_type>(); - break; - case type_tag::enumeration: - this->enumeration.~shared_ptr<enumeration_type>(); - break; - } - } - - template<> - std::shared_ptr<alias_type> type::get<alias_type>() const - { - return tag == type_tag::alias ? this->alias.lock() : nullptr; - } - - template<> - std::shared_ptr<primitive_type> type::get<primitive_type>() const - { - return tag == type_tag::primitive ? this->primitive : nullptr; - } - - template<> - std::shared_ptr<record_type> type::get<record_type>() const - { - return tag == type_tag::record ? this->record : nullptr; - } - - template<> - std::shared_ptr<union_type> type::get<union_type>() const - { - return tag == type_tag::_union ? this->_union : nullptr; - } - - template<> - std::shared_ptr<pointer_type> type::get<pointer_type>() const - { - return tag == type_tag::pointer ? this->pointer : nullptr; - } - - template<> - std::shared_ptr<array_type> type::get<array_type>() const - { - return tag == type_tag::array ? this->array : nullptr; - } - - template<> - std::shared_ptr<procedure_type> type::get<procedure_type>() const - { - return tag == type_tag::procedure ? this->procedure : nullptr; - } - - template<> - std::shared_ptr<enumeration_type> type::get<enumeration_type>() const - { - return tag == type_tag::enumeration ? this->enumeration : nullptr; - } - - bool type::empty() const - { - return tag == type_tag::empty; - } - - alias_type::alias_type(const std::string& name) - : name(name), reference() - { - } - - pointer_type::pointer_type(type base) - : base(base) - { - } - - array_type::array_type(type base, std::uint64_t size) - : base(base), size(size) - { - } - - primitive_type::primitive_type(const std::string& identifier) - : identifier(identifier) - { - } - - procedure_type::procedure_type(return_t return_type) - : return_type(return_type) - { - } - - enumeration_type::enumeration_type(const std::vector<std::string>& members) - : members(members) - { - } - - info::~info() - { - } - - std::shared_ptr<type_info> info::is_type() - { - return nullptr; - } - - std::shared_ptr<procedure_info> info::is_procedure() - { - return nullptr; - } - - std::shared_ptr<constant_info> info::is_constant() - { - return nullptr; - } - - std::shared_ptr<variable_info> info::is_variable() - { - return nullptr; - } - - type_info::type_info(const type symbol) - : symbol(symbol) - { - } - - std::shared_ptr<type_info> type_info::is_type() - { - return std::static_pointer_cast<type_info>(shared_from_this()); - } - - procedure_info::procedure_info(const procedure_type symbol, const std::vector<std::string> names, - std::shared_ptr<symbol_table> scope) - : symbol(symbol), names(names), scope(scope) - { - } - - std::shared_ptr<procedure_info> procedure_info::is_procedure() - { - return std::static_pointer_cast<procedure_info>(shared_from_this()); - } - - bool procedure_info::is_extern() const - { - return this->scope == nullptr; - } - - constant_info::constant_info(const variant& symbol) - : symbol(symbol) - { - } - - std::shared_ptr<constant_info> constant_info::is_constant() - { - return std::static_pointer_cast<constant_info>(shared_from_this()); - } - - variable_info::variable_info(const type symbol, bool is_extern) - : symbol(symbol), is_extern(is_extern) - { - } - - std::shared_ptr<variable_info> variable_info::is_variable() - { - return std::static_pointer_cast<variable_info>(shared_from_this()); - } - - std::shared_ptr<symbol_table> builtin_symbol_table() - { - auto result = std::make_shared<symbol_table>(); - - result->enter("Int", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Int")))); - result->enter("Word", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Word")))); - result->enter("Char", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Char")))); - result->enter("Bool", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Bool")))); - result->enter("Pointer", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Pointer")))); - result->enter("Float", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Float")))); - result->enter("String", std::make_shared<type_info>(type(std::make_shared<primitive_type>("String")))); - - return result; - } - - symbol_bag::symbol_bag(forward_table&& unresolved, std::shared_ptr<symbol_table> global_table) - : unresolved(unresolved) - { - this->symbols = std::make_shared<symbol_table>(global_table); - } - - std::shared_ptr<info> symbol_bag::lookup(const std::string& name) - { - for (auto import_bag : this->imports) - { - if (auto result = import_bag->lookup(name)) - { - return result; - } - } - return this->symbols->lookup(name); - } - - bool symbol_bag::enter(const std::string& name, std::shared_ptr<info> entry) - { - return this->symbols->enter(name, entry); - } - - std::shared_ptr<symbol_table> symbol_bag::enter() - { - this->symbols = std::make_shared<symbol_table>(this->symbols); - return this->symbols; - } - - void symbol_bag::enter(std::shared_ptr<symbol_table> child) - { - this->symbols = child; - } - - std::shared_ptr<symbol_table> symbol_bag::leave() - { - std::shared_ptr<symbol_table> result = this->symbols; - - this->symbols = result->scope(); - return result; - } - - std::shared_ptr<alias_type> symbol_bag::declared(const std::string& symbol_name) - { - auto unresolved_alias = this->unresolved.find(symbol_name); - - return unresolved_alias == this->unresolved.end() ? std::shared_ptr<alias_type>() : unresolved_alias->second; - } - - std::shared_ptr<alias_type> symbol_bag::resolve(const std::string& symbol_name, type& resolution) - { - auto unresolved_declaration = this->unresolved.at(symbol_name); - - unresolved_declaration->reference = resolution; - return unresolved_declaration; - } - - void symbol_bag::add_import(const symbol_bag& bag) - { - this->imports.push_front(bag.symbols); - } -} |