120 lines
3.8 KiB
C++
120 lines
3.8 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
|
|
{
|
|
declaration_error::declaration_error(const std::string& identifier, const char *path, const struct position position)
|
|
: error(path, position), identifier(identifier)
|
|
{
|
|
}
|
|
|
|
std::string declaration_error::what() const
|
|
{
|
|
return "Type '" + identifier + "' not declared";
|
|
}
|
|
|
|
declaration_visitor::declaration_visitor(const char *path, std::shared_ptr<symbol_table> symbols)
|
|
: path(path), symbols(symbols)
|
|
{
|
|
}
|
|
|
|
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)
|
|
{
|
|
definition->body().accept(this);
|
|
auto unresolved_declaration = this->unresolved.at(definition->identifier);
|
|
|
|
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
|
|
{
|
|
auto new_error = std::make_unique<declaration_error>(type_expression->name,
|
|
path, type_expression->position());
|
|
this->errors.emplace_back(std::move(new_error));
|
|
// TODO: Delete the next line.
|
|
this->current_type = type(std::make_shared<primitive_type>(type_expression->name));
|
|
}
|
|
}
|
|
|
|
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(array_type_expression *type_expression)
|
|
{
|
|
type_expression->base().accept(this);
|
|
this->current_type = type(std::make_shared<array_type>(this->current_type, type_expression->size));
|
|
}
|
|
|
|
void declaration_visitor::visit(record_type_expression *type_expression)
|
|
{
|
|
auto type_definition = std::make_shared<record_type>();
|
|
|
|
for (auto& field : type_expression->fields)
|
|
{
|
|
field.second->accept(this);
|
|
|
|
type_definition->fields.push_back({ field.first, type(this->current_type) });
|
|
}
|
|
this->current_type = type(type_definition);
|
|
}
|
|
|
|
void declaration_visitor::visit(union_type_expression *type_expression)
|
|
{
|
|
auto type_definition = std::make_shared<union_type>();
|
|
|
|
for (auto& field : type_expression->fields)
|
|
{
|
|
field.second->accept(this);
|
|
|
|
type_definition->fields.push_back({ field.first, type(this->current_type) });
|
|
}
|
|
this->current_type = type(type_definition);
|
|
}
|
|
|
|
void declaration_visitor::visit(procedure_type_expression *type_expression)
|
|
{
|
|
}
|
|
}
|
|
}
|