328 lines
8.0 KiB
C++
328 lines
8.0 KiB
C++
/* Name analysis.
|
|
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/boot/semantic.h"
|
|
|
|
namespace elna
|
|
{
|
|
namespace boot
|
|
{
|
|
type::type()
|
|
: tag(type_tag::alias)
|
|
{
|
|
}
|
|
|
|
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)
|
|
{
|
|
}
|
|
|
|
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::weak_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;
|
|
}
|
|
}
|
|
|
|
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::weak_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;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
type::~type()
|
|
{
|
|
switch (tag)
|
|
{
|
|
case type_tag::empty:
|
|
break;
|
|
case type_tag::alias:
|
|
break;
|
|
case type_tag::primitive:
|
|
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;
|
|
}
|
|
}
|
|
|
|
template<>
|
|
std::shared_ptr<alias_type> type::get<alias_type>() const
|
|
{
|
|
if (tag == type_tag::alias)
|
|
{
|
|
return this->alias.lock();
|
|
}
|
|
else
|
|
{
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
template<>
|
|
std::shared_ptr<primitive_type> type::get<primitive_type>() const
|
|
{
|
|
if (tag == type_tag::primitive)
|
|
{
|
|
return this->primitive.lock();
|
|
}
|
|
else
|
|
{
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
template<>
|
|
std::shared_ptr<record_type> type::get<record_type>() const
|
|
{
|
|
if (tag == type_tag::record)
|
|
{
|
|
return this->record;
|
|
}
|
|
else
|
|
{
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
template<>
|
|
std::shared_ptr<union_type> type::get<union_type>() const
|
|
{
|
|
if (tag == type_tag::_union)
|
|
{
|
|
return this->_union;
|
|
}
|
|
else
|
|
{
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
template<>
|
|
std::shared_ptr<pointer_type> type::get<pointer_type>() const
|
|
{
|
|
if (tag == type_tag::pointer)
|
|
{
|
|
return this->pointer;
|
|
}
|
|
else
|
|
{
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
template<>
|
|
std::shared_ptr<array_type> type::get<array_type>() const
|
|
{
|
|
if (tag == type_tag::array)
|
|
{
|
|
return this->array;
|
|
}
|
|
else
|
|
{
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
bool type::empty() const
|
|
{
|
|
return tag == type_tag::empty;
|
|
}
|
|
|
|
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)
|
|
{
|
|
}
|
|
|
|
void declaration_visitor::visit(program *program)
|
|
{
|
|
for (type_definition *const type : program->types)
|
|
{
|
|
this->unresolved.insert({ type->identifier, std::make_shared<alias_type>() });
|
|
}
|
|
for (type_definition *const type : program->types)
|
|
{
|
|
type->accept(this);
|
|
}
|
|
}
|
|
|
|
void declaration_visitor::visit(type_definition *definition)
|
|
{
|
|
auto unresolved_declaration = this->unresolved.at(definition->identifier);
|
|
|
|
definition->body().accept(this);
|
|
|
|
unresolved_declaration->reference = this->current_type;
|
|
}
|
|
|
|
void declaration_visitor::visit(primitive_type_expression *type_expression)
|
|
{
|
|
auto unresolved_alias = this->unresolved.find(type_expression->name);
|
|
|
|
if (unresolved_alias != this->unresolved.end())
|
|
{
|
|
this->current_type = type(unresolved_alias->second);
|
|
}
|
|
else
|
|
{
|
|
this->current_type = type(std::make_shared<primitive_type>(type_expression->name));
|
|
}
|
|
}
|
|
|
|
void declaration_visitor::visit(array_type_expression *type_expression)
|
|
{
|
|
}
|
|
|
|
void declaration_visitor::visit(pointer_type_expression *type_expression)
|
|
{
|
|
type_expression->base().accept(this);
|
|
this->current_type = type(std::make_shared<pointer_type>(this->current_type));
|
|
}
|
|
|
|
void declaration_visitor::visit(record_type_expression *type_expression)
|
|
{
|
|
auto type_definition = std::make_shared<record_type>();
|
|
|
|
this->current_type = type(type_definition);
|
|
}
|
|
|
|
void declaration_visitor::visit(union_type_expression *type_expression)
|
|
{
|
|
auto type_definition = std::make_shared<union_type>();
|
|
|
|
this->current_type = type(type_definition);
|
|
}
|
|
|
|
void declaration_visitor::visit(procedure_type_expression *type_expression)
|
|
{
|
|
}
|
|
}
|
|
}
|