belka/elna
1
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

Replace build_type with visitor functions

Browse Source
This commit is contained in:
Eugen Wissner 2025-03-02 10:05:47 +01:00
parent b141dc1a5a
commit 75561fd18a
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
4 changed files with 170 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
boot/ast.cc
View File

@ -239,36 +239,6 @@ namespace boot
{
}
std::shared_ptr<basic_type> top_type::is_basic()
{
return nullptr;
}
std::shared_ptr<array_type> top_type::is_array()
{
return nullptr;
}
std::shared_ptr<record_type> top_type::is_record()
{
return nullptr;
}
std::shared_ptr<union_type> top_type::is_union()
{
return nullptr;
}
std::shared_ptr<pointer_type> top_type::is_pointer()
{
return nullptr;
}
std::shared_ptr<procedure_type> top_type::is_procedure()
{
return nullptr;
}
basic_type::basic_type(const struct position position, const std::string& name)
: top_type(position), m_name(name)
{
@ -284,11 +254,6 @@ namespace boot
return m_name;
}
std::shared_ptr<basic_type> basic_type::is_basic()
{
return std::static_pointer_cast<basic_type>(shared_from_this());
}
array_type::array_type(const struct position position, std::shared_ptr<top_type> base, const std::uint32_t size)
: top_type(position), m_base(base), size(size)
{
@ -304,11 +269,6 @@ namespace boot
return *m_base;
}
std::shared_ptr<array_type> array_type::is_array()
{
return std::static_pointer_cast<array_type>(shared_from_this());
}
pointer_type::pointer_type(const struct position position, std::shared_ptr<top_type> base)
: top_type(position), m_base(base)
{
@ -324,11 +284,6 @@ namespace boot
return *m_base;
}
std::shared_ptr<pointer_type> pointer_type::is_pointer()
{
return std::static_pointer_cast<pointer_type>(shared_from_this());
}
record_type::record_type(const struct position position, fields_t&& fields)
: top_type(position), fields(std::move(fields))
{
@ -339,21 +294,11 @@ namespace boot
visitor->visit(this);
}
std::shared_ptr<record_type> record_type::is_record()
{
return std::static_pointer_cast<record_type>(shared_from_this());
}
union_type::union_type(const struct position position, fields_t&& fields)
: top_type(position), fields(std::move(fields))
{
}
std::shared_ptr<union_type> union_type::is_union()
{
return std::static_pointer_cast<union_type>(shared_from_this());
}
void union_type::accept(parser_visitor *visitor)
{
visitor->visit(this);
@ -416,11 +361,6 @@ namespace boot
visitor->visit(this);
}
std::shared_ptr<procedure_type> procedure_type::is_procedure()
{
return std::static_pointer_cast<procedure_type>(shared_from_this());
}
procedure_type::~procedure_type()
{
for (auto parameter : this->parameters)

262
gcc/elna-generic.cc
View File

@ -164,8 +164,8 @@ namespace gcc
void generic_visitor::visit(boot::cast_expression *expression)
{
tree cast_target = build_type(expression->target());
gcc_assert(cast_target != NULL_TREE);
expression->target().accept(this);
tree cast_target = this->current_expression;
expression->value().accept(this);
@ -732,15 +732,16 @@ namespace gcc
void generic_visitor::visit(boot::type_definition *definition)
{
location_t definition_location = get_location(&definition->position());
tree tree_type = build_type(definition->body());
definition->body().accept(this);
tree definition_tree = build_decl(definition_location, TYPE_DECL,
get_identifier(definition->identifier.c_str()), tree_type);
auto result = this->symbol_map->enter(definition->identifier, tree_type);
get_identifier(definition->identifier.c_str()), this->current_expression);
auto result = this->symbol_map->enter(definition->identifier, this->current_expression);
if (result)
{
TREE_PUBLIC(definition_tree) = definition->exported;
TYPE_NAME(tree_type) = get_identifier(definition->identifier.c_str());
TYPE_NAME(this->current_expression) = get_identifier(definition->identifier.c_str());
}
else
{
@ -748,6 +749,7 @@ namespace gcc
"type '%s' already declared in this scope",
definition->identifier.c_str());
}
this->current_expression = NULL_TREE;
}
tree generic_visitor::build_procedure_type(boot::procedure_type& type)
@ -756,130 +758,36 @@ namespace gcc
for (std::size_t i = 0; i < type.parameters.size(); ++i)
{
parameter_types[i] = build_type(type.parameters.at(i)->variable_type());
boot::top_type& parameter_type = type.parameters.at(i)->variable_type();
parameter_type.accept(this);
parameter_types[i] = this->current_expression;
}
tree return_type = type.return_type == nullptr
? void_type_node
: build_type(*type.return_type);
tree return_type = void_type_node;
if (type.return_type != nullptr)
{
type.return_type->accept(this);
return_type = this->current_expression;
}
this->current_expression = NULL_TREE;
return build_function_type_array(return_type, type.parameters.size(), parameter_types.data());
}
tree generic_visitor::build_type(boot::top_type& type)
{
if (std::shared_ptr<boot::basic_type> basic_type = type.is_basic())
{
tree symbol = this->lookup(basic_type->base_name());
if (symbol != NULL_TREE && TYPE_P(symbol))
{
return symbol;
}
error_at(get_location(&basic_type->position()),
"type '%s' not declared", basic_type->base_name().c_str());
return error_mark_node;
}
else if (std::shared_ptr<boot::array_type> array_type = type.is_array())
{
tree lower_bound = build_int_cst_type(integer_type_node, 0);
tree upper_bound = build_int_cst_type(integer_type_node, array_type->size);
tree base_type = build_type(array_type->base());
if (base_type == NULL_TREE || base_type == error_mark_node)
{
return base_type;
}
tree range_type = build_range_type(integer_type_node, lower_bound, upper_bound);
return build_array_type(base_type, range_type);
}
else if (std::shared_ptr<boot::pointer_type> pointer_type = type.is_pointer())
{
tree base_type = build_type(pointer_type->base());
if (base_type == NULL_TREE || base_type == error_mark_node)
{
return base_type;
}
return build_pointer_type_for_mode(base_type, VOIDmode, true);
}
else if (std::shared_ptr<boot::record_type> record_type = type.is_record())
{
std::set<std::string> field_names;
tree record_type_node = make_node(RECORD_TYPE);
for (auto& field : record_type->fields)
{
if (field_names.find(field.first) != field_names.cend())
{
error_at(get_location(&field.second->position()), "repeated field name");
return error_mark_node;
}
field_names.insert(field.first);
tree field_type = build_type(*field.second);
if (field_type == NULL_TREE || field_type == error_mark_node)
{
return field_type;
}
tree field_declaration = build_field(get_location(&field.second->position()),
record_type_node, field.first, field_type);
TYPE_FIELDS(record_type_node) = chainon(TYPE_FIELDS(record_type_node), field_declaration);
}
layout_type(record_type_node);
return record_type_node;
}
else if (std::shared_ptr<boot::union_type> union_type = type.is_union())
{
std::set<std::string> field_names;
tree union_type_node = make_node(UNION_TYPE);
for (auto& field : union_type->fields)
{
if (field_names.find(field.first) != field_names.cend())
{
error_at(get_location(&field.second->position()), "repeated field name");
return error_mark_node;
}
field_names.insert(field.first);
tree field_type = build_type(*field.second);
if (field_type == NULL_TREE || field_type == error_mark_node)
{
return field_type;
}
tree field_declaration = build_field(get_location(&field.second->position()),
union_type_node, field.first, field_type);
TYPE_FIELDS(union_type_node) = chainon(TYPE_FIELDS(union_type_node), field_declaration);
}
layout_type(union_type_node);
return union_type_node;
}
else if (std::shared_ptr<boot::procedure_type> procedure_type = type.is_procedure())
{
tree procedure_type_node = build_procedure_type(*procedure_type);
return build_pointer_type_for_mode(procedure_type_node, VOIDmode, true);
}
return NULL_TREE;
}
void generic_visitor::visit(boot::variable_declaration *declaration)
{
tree declaration_type = build_type(declaration->variable_type());
gcc_assert(declaration_type != NULL_TREE);
declaration->variable_type().accept(this);
location_t declaration_location = get_location(&declaration->position());
tree declaration_tree = build_decl(declaration_location, VAR_DECL,
get_identifier(declaration->identifier.c_str()), declaration_type);
get_identifier(declaration->identifier.c_str()), this->current_expression);
bool result = this->symbol_map->enter(declaration->identifier, declaration_tree);
if (is_pointer_type(declaration_type))
if (is_pointer_type(this->current_expression))
{
DECL_INITIAL(declaration_tree) = elna_pointer_nil_node;
}
this->current_expression = NULL_TREE;
if (!result)
{
error_at(declaration_location, "variable '%s' already declared in this scope",
@ -967,28 +875,30 @@ namespace gcc
void generic_visitor::visit(boot::traits_expression *trait)
{
tree type_expression = build_type(trait->type());
trait->type().accept(this);
if (trait->name == "size")
{
this->current_expression = build1(CONVERT_EXPR, elna_word_type_node, size_in_bytes(type_expression));
this->current_expression = build1(CONVERT_EXPR, elna_word_type_node,
size_in_bytes(this->current_expression));
}
else if (trait->name == "alignment")
{
this->current_expression = build_int_cstu(elna_word_type_node, TYPE_ALIGN_UNIT(type_expression));
this->current_expression = build_int_cstu(elna_word_type_node,
TYPE_ALIGN_UNIT(this->current_expression));
}
else if (trait->name == "min" && is_integral_type(type_expression))
else if (trait->name == "min" && is_integral_type(this->current_expression))
{
this->current_expression = TYPE_MIN_VALUE(type_expression);
this->current_expression = TYPE_MIN_VALUE(this->current_expression);
}
else if (trait->name == "max" && is_integral_type(type_expression))
else if (trait->name == "max" && is_integral_type(this->current_expression))
{
this->current_expression = TYPE_MAX_VALUE(type_expression);
this->current_expression = TYPE_MAX_VALUE(this->current_expression);
}
else
{
error_at(get_location(&trait->position()), "type '%s' does not have property '%s'",
print_type(type_expression).c_str(), trait->name.c_str());
print_type(this->current_expression).c_str(), trait->name.c_str());
this->current_expression = error_mark_node;
}
}
@ -1190,5 +1100,111 @@ namespace gcc
this->current_expression = NULL_TREE;
}
void generic_visitor::visit(boot::basic_type *type)
{
tree symbol = this->lookup(type->base_name());
if (symbol == NULL_TREE && TYPE_P(symbol))
{
error_at(get_location(&type->position()),
"type '%s' not declared", type->base_name().c_str());
this->current_expression = error_mark_node;
}
else
{
this->current_expression = symbol;
}
}
void generic_visitor::visit(boot::array_type *type)
{
tree lower_bound = build_int_cst_type(integer_type_node, 0);
tree upper_bound = build_int_cst_type(integer_type_node, type->size);
type->base().accept(this);
if (this->current_expression != NULL_TREE && this->current_expression != error_mark_node)
{
tree range_type = build_range_type(integer_type_node, lower_bound, upper_bound);
this->current_expression = build_array_type(this->current_expression, range_type);
}
}
void generic_visitor::visit(boot::pointer_type *type)
{
type->base().accept(this);
if (this->current_expression != NULL_TREE && this->current_expression != error_mark_node)
{
this->current_expression = build_pointer_type_for_mode(this->current_expression, VOIDmode, true);
}
}
void generic_visitor::visit(boot::record_type *type)
{
std::set<std::string> field_names;
tree record_type_node = make_node(RECORD_TYPE);
for (auto& field : type->fields)
{
if (field_names.find(field.first) != field_names.cend())
{
error_at(get_location(&field.second->position()), "repeated field name");
this->current_expression = error_mark_node;
return;
}
field_names.insert(field.first);
field.second->accept(this);
if (this->current_expression == NULL_TREE || this->current_expression == error_mark_node)
{
return;
}
tree field_declaration = build_field(get_location(&field.second->position()),
record_type_node, field.first, this->current_expression);
TYPE_FIELDS(record_type_node) = chainon(TYPE_FIELDS(record_type_node), field_declaration);
}
layout_type(record_type_node);
this->current_expression = record_type_node;
}
void generic_visitor::visit(boot::union_type *type)
{
std::set<std::string> field_names;
tree union_type_node = make_node(UNION_TYPE);
for (auto& field : type->fields)
{
if (field_names.find(field.first) != field_names.cend())
{
error_at(get_location(&field.second->position()), "repeated field name");
this->current_expression = error_mark_node;
return;
}
field_names.insert(field.first);
field.second->accept(this);
if (this->current_expression == NULL_TREE || this->current_expression == error_mark_node)
{
return;
}
tree field_declaration = build_field(get_location(&field.second->position()),
union_type_node, field.first, this->current_expression);
TYPE_FIELDS(union_type_node) = chainon(TYPE_FIELDS(union_type_node), field_declaration);
}
layout_type(union_type_node);
this->current_expression = union_type_node;
}
void generic_visitor::visit(boot::procedure_type *type)
{
tree procedure_type_node = build_procedure_type(*type);
this->current_expression = build_pointer_type_for_mode(procedure_type_node, VOIDmode, true);
}
}
}

17
include/elna/boot/ast.h
View File

@ -210,14 +210,6 @@ namespace boot
*/
class top_type : public node, public std::enable_shared_from_this<top_type>
{
public:
virtual std::shared_ptr<basic_type> is_basic();
virtual std::shared_ptr<array_type> is_array();
virtual std::shared_ptr<pointer_type> is_pointer();
virtual std::shared_ptr<record_type> is_record();
virtual std::shared_ptr<union_type> is_union();
virtual std::shared_ptr<procedure_type> is_procedure();
protected:
top_type(const struct position position);
};
@ -238,8 +230,6 @@ namespace boot
virtual void accept(parser_visitor *visitor) override;
const std::string& base_name();
std::shared_ptr<basic_type> is_basic() override;
};
class array_type : public top_type
@ -253,8 +243,6 @@ namespace boot
virtual void accept(parser_visitor *visitor) override;
top_type& base();
std::shared_ptr<array_type> is_array() override;
};
class pointer_type : public top_type
@ -266,8 +254,6 @@ namespace boot
virtual void accept(parser_visitor *visitor) override;
top_type& base();
std::shared_ptr<pointer_type> is_pointer() override;
};
using field_t = std::pair<std::string, std::shared_ptr<top_type>>;
@ -281,7 +267,6 @@ namespace boot
record_type(const struct position position, fields_t&& fields);
virtual void accept(parser_visitor *visitor) override;
std::shared_ptr<record_type> is_record() override;
};
class union_type : public top_type
@ -292,7 +277,6 @@ namespace boot
union_type(const struct position position, fields_t&& fields);
virtual void accept(parser_visitor *visitor) override;
std::shared_ptr<union_type> is_union() override;
};
/**
@ -363,7 +347,6 @@ namespace boot
procedure_type(const struct position position, no_return_t);
virtual void accept(parser_visitor *visitor) override;
std::shared_ptr<procedure_type> is_procedure() override;
virtual ~procedure_type() override;
};

57
include/elna/gcc/elna-generic.h
View File

@ -41,7 +41,6 @@ namespace gcc
tree build_label_decl(const char *name, location_t loc);
tree build_procedure_type(boot::procedure_type& type);
tree build_type(boot::top_type& type);
void enter_scope();
tree leave_scope();
@ -66,31 +65,37 @@ namespace gcc
public:
generic_visitor(std::shared_ptr<symbol_table> symbol_table);
void visit(boot::program *program) override;
void visit(boot::procedure_definition *definition) override;
void visit(boot::procedure_call *call) override;
void visit(boot::cast_expression *expression) override;
void visit(boot::traits_expression *trait) override;
void visit(boot::number_literal<std::int32_t> *literal) override;
void visit(boot::number_literal<std::uint32_t> *literal) override;
void visit(boot::number_literal<double> *literal) override;
void visit(boot::number_literal<bool> *boolean) override;
void visit(boot::number_literal<unsigned char> *character) override;
void visit(boot::number_literal<std::nullptr_t> *) override;
void visit(boot::number_literal<std::string> *string) override;
void visit(boot::binary_expression *expression) override;
void visit(boot::unary_expression *expression) override;
void visit(boot::constant_definition *definition) override;
void visit(boot::type_definition *definition) override;
void visit(boot::variable_declaration *declaration) override;
void visit(boot::variable_expression *expression) override;
void visit(boot::array_access_expression *expression) override;
void visit(boot::field_access_expression *expression) override;
void visit(boot::dereference_expression *expression) override;
void visit(boot::block *block) override;
void visit(boot::assign_statement *statement) override;
void visit(boot::if_statement *statement) override;
void visit(boot::while_statement *statement) override;
virtual void visit(boot::program *program) override;
virtual void visit(boot::procedure_definition *definition) override;
virtual void visit(boot::procedure_call *call) override;
virtual void visit(boot::cast_expression *expression) override;
virtual void visit(boot::traits_expression *trait) override;
virtual void visit(boot::number_literal<std::int32_t> *literal) override;
virtual void visit(boot::number_literal<std::uint32_t> *literal) override;
virtual void visit(boot::number_literal<double> *literal) override;
virtual void visit(boot::number_literal<bool> *boolean) override;
virtual void visit(boot::number_literal<unsigned char> *character) override;
virtual void visit(boot::number_literal<std::nullptr_t> *) override;
virtual void visit(boot::number_literal<std::string> *string) override;
virtual void visit(boot::binary_expression *expression) override;
virtual void visit(boot::unary_expression *expression) override;
virtual void visit(boot::constant_definition *definition) override;
virtual void visit(boot::type_definition *definition) override;
virtual void visit(boot::variable_declaration *declaration) override;
virtual void visit(boot::variable_expression *expression) override;
virtual void visit(boot::array_access_expression *expression) override;
virtual void visit(boot::field_access_expression *expression) override;
virtual void visit(boot::dereference_expression *expression) override;
virtual void visit(boot::block *block) override;
virtual void visit(boot::assign_statement *statement) override;
virtual void visit(boot::if_statement *statement) override;
virtual void visit(boot::while_statement *statement) override;
virtual void visit(boot::basic_type *type) override;
virtual void visit(boot::array_type *type) override;
virtual void visit(boot::pointer_type *type) override;
virtual void visit(boot::record_type *type) override;
virtual void visit(boot::union_type *type) override;
virtual void visit(boot::procedure_type *type) override;
};
}
}