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

Forbid redefenition of builtin types

Browse Source
This commit is contained in:
Eugen Wissner 2025-03-14 11:22:11 +01:00
parent ac084be7f5
commit fa73f14070
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
6 changed files with 124 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
boot/semantic.cc
View File

@ -15,6 +15,8 @@ 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 <set>
#include "elna/boot/semantic.h"
namespace elna
@ -52,7 +54,8 @@ namespace boot
{
for (type_definition *const type : program->types)
{
if (!this->unresolved.insert({ type->identifier, std::make_shared<alias_type>() }).second)
if (!this->unresolved.insert({ type->identifier, std::make_shared<alias_type>(type->identifier) }).second
|| this->symbols->contains(type->identifier))
{
add_error<already_declared_error>(type->identifier, this->input_file, type->position());
}
@ -61,6 +64,11 @@ namespace boot
{
type->accept(this);
}
for (auto& unresolved : this->unresolved)
{
auto info = std::make_shared<type_info>(type_info(type(unresolved.second)));
this->symbols->enter(std::move(unresolved.first), info);
}
}
void declaration_visitor::visit(type_definition *definition)
@ -79,7 +87,7 @@ namespace boot
{
this->current_type = type(unresolved_alias->second);
}
else if (auto from_symbol_table = this->symbols.lookup(type_expression->name))
else if (auto from_symbol_table = this->symbols->lookup(type_expression->name))
{
this->current_type = from_symbol_table->is_type()->symbol;
}
@ -102,33 +110,55 @@ namespace boot
this->current_type = type(std::make_shared<array_type>(this->current_type, type_expression->size));
}
bool declaration_visitor::build_composite_type(const std::vector<field_declaration>& declarations,
std::vector<type_field>& fields)
{
std::set<std::string> field_names;
for (auto& field : declarations)
{
if (field_names.find(field.first) != field_names.cend())
{
add_error<already_declared_error>(field.first, this->input_file, field.second->position());
this->current_type = type();
return false;
}
field.second->accept(this);
if (!this->current_type.empty())
{
fields.push_back({ field.first, type(this->current_type) });
}
}
return true;
}
void declaration_visitor::visit(record_type_expression *type_expression)
{
auto type_definition = std::make_shared<record_type>();
for (auto& field : type_expression->fields)
if (build_composite_type(type_expression->fields, type_definition->fields))
{
field.second->accept(this);
if (!this->current_type.empty())
{
type_definition->fields.push_back({ field.first, type(this->current_type) });
}
}
this->current_type = type(type_definition);
}
else
{
this->current_type = type();
}
}
void declaration_visitor::visit(union_type_expression *type_expression)
{
auto type_definition = std::make_shared<union_type>();
for (auto& field : type_expression->fields)
if (build_composite_type(type_expression->fields, type_definition->fields))
{
field.second->accept(this);
type_definition->fields.push_back({ field.first, type(this->current_type) });
}
this->current_type = type(type_definition);
}
else
{
this->current_type = type();
}
}
void declaration_visitor::visit(procedure_type_expression *type_expression)
{

5
boot/symbol.cc
View File

@ -247,6 +247,11 @@ namespace boot
return tag == type_tag::empty;
}
alias_type::alias_type(const std::string& name)
: name(name), reference()
{
}
pointer_type::pointer_type(type base)
: base(base)
{

2
gcc/Make-lang.in
View File

@ -136,7 +136,7 @@ elna.stagefeedback: stagefeedback-start
-mv elna/*$(objext) stagefeedback/elna
ELNA_INCLUDES = -I $(srcdir)/elna/include -I elna/generated
ELNA_CXXFLAGS = -std=c++14
ELNA_CXXFLAGS = -std=c++17
elna/%.o: elna/boot/%.cc elna/generated/parser.hh elna/generated/location.hh
$(COMPILE) $(ELNA_CXXFLAGS) $(ELNA_INCLUDES) $<

62
gcc/elna-generic.cc
View File

@ -38,11 +38,15 @@ namespace elna
{
namespace gcc
{
static tree get_inner_alias(std::shared_ptr<symbol_table> symbol_table, const boot::type& type)
tree handle_symbol(const std::string& symbol_name, const boot::type& type,
std::shared_ptr<boot::symbol_table> from, std::shared_ptr<symbol_table> to);
tree get_inner_alias(const boot::type& type,
std::shared_ptr<boot::symbol_table> from, std::shared_ptr<symbol_table> to)
{
if (auto reference = type.get<boot::primitive_type>())
{
return symbol_table->lookup(reference->identifier);
return to->lookup(reference->identifier);
}
else if (auto reference = type.get<boot::record_type>())
{
@ -54,15 +58,36 @@ namespace gcc
}
else if (auto reference = type.get<boot::pointer_type>())
{
return build_pointer_type_for_mode(get_inner_alias(symbol_table, reference->base), VOIDmode, true);
return build_pointer_type_for_mode(get_inner_alias(reference->base, from, to), VOIDmode, true);
}
else if (auto reference = type.get<boot::array_type>())
{
tree lower_bound = build_int_cst_type(integer_type_node, 0);
tree upper_bound = build_int_cst_type(integer_type_node, reference->size);
tree range_type = build_range_type(integer_type_node, lower_bound, upper_bound);
return build_array_type(get_inner_alias(reference->base, from, to), range_type);
}
else if (auto reference = type.get<boot::alias_type>())
{
return get_inner_alias(symbol_table, reference->reference);
return handle_symbol(reference->name, reference->reference, from, to);
}
return error_mark_node;
}
tree handle_symbol(const std::string& symbol_name, const boot::type& type,
std::shared_ptr<boot::symbol_table> from, std::shared_ptr<symbol_table> to)
{
auto looked_up = to->lookup(symbol_name);
if (looked_up == NULL_TREE)
{
looked_up = get_inner_alias(type, from, to);
to->enter(symbol_name, looked_up);
}
return looked_up;
}
std::deque<std::unique_ptr<boot::error>> do_semantic_analysis(const char *path,
std::unique_ptr<boot::program>& ast, std::shared_ptr<symbol_table> symbols)
{
@ -73,10 +98,13 @@ namespace gcc
if (declaration_visitor.errors().empty())
{
for (auto unresolved : declaration_visitor.unresolved)
for (auto& [symbol_name, symbol_info] : *info_table)
{
auto inner_alias = get_inner_alias(symbols, boot::type(unresolved.second));
symbols->enter(unresolved.first, inner_alias);
handle_symbol(symbol_name, symbol_info->is_type()->symbol, info_table, symbols);
}
for (auto& [symbol_name, symbol_info] : *info_table)
{
// printf("%s\n", symbol_name.c_str());
}
}
return std::move(declaration_visitor.errors());
@ -1154,7 +1182,7 @@ namespace gcc
void generic_visitor::visit(boot::record_type_expression *type)
{
std::set<std::string> field_names;
tree record_type_node = this->current_expression == NULL_TREE
tree composite_type_node = this->current_expression == NULL_TREE
? make_node(RECORD_TYPE)
: this->current_expression;
@ -1174,19 +1202,19 @@ namespace gcc
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);
composite_type_node, field.first, this->current_expression);
TYPE_FIELDS(composite_type_node) = chainon(TYPE_FIELDS(composite_type_node), field_declaration);
this->current_expression = NULL_TREE;
}
layout_type(record_type_node);
layout_type(composite_type_node);
this->current_expression = record_type_node;
this->current_expression = composite_type_node;
}
void generic_visitor::visit(boot::union_type_expression *type)
{
std::set<std::string> field_names;
tree union_type_node = this->current_expression == NULL_TREE
tree composite_type_node = this->current_expression == NULL_TREE
? make_node(UNION_TYPE)
: this->current_expression;
@ -1206,13 +1234,13 @@ namespace gcc
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);
composite_type_node, field.first, this->current_expression);
TYPE_FIELDS(composite_type_node) = chainon(TYPE_FIELDS(composite_type_node), field_declaration);
this->current_expression = NULL_TREE;
}
layout_type(union_type_node);
layout_type(composite_type_node);
this->current_expression = union_type_node;
this->current_expression = composite_type_node;
}
void generic_visitor::visit(boot::procedure_type_expression *type)

8
include/elna/boot/semantic.h
View File

@ -51,11 +51,13 @@ namespace boot
class declaration_visitor final : public empty_visitor, public error_container
{
type current_type;
symbol_table symbols;
public:
std::shared_ptr<symbol_table> symbols;
std::unordered_map<std::string, std::shared_ptr<alias_type>> unresolved;
bool build_composite_type(const std::vector<field_declaration>& declarations,
std::vector<type_field>& fields);
public:
explicit declaration_visitor(const char *path, std::shared_ptr<symbol_table> symbols);
void visit(primitive_type_expression *type_expression) override;

28
include/elna/boot/symbol.h
View File

@ -85,7 +85,10 @@ namespace boot
struct alias_type
{
const std::string name;
type reference;
explicit alias_type(const std::string& name);
};
struct pointer_type
@ -173,22 +176,30 @@ namespace boot
iterator begin()
{
return entries.begin();
return this->entries.begin();
}
iterator end()
{
return entries.end();
return this->entries.end();
}
const_iterator cbegin() const
{
return entries.cbegin();
return this->entries.cbegin();
}
const_iterator cend() const
{
return entries.cend();
return this->entries.cend();
}
/**
* \return Symbol count in the current scope.
*/
std::size_t size() const
{
return this->entries.size();
}
/**
@ -213,6 +224,15 @@ namespace boot
return nothing;
}
/**
* \param name Symbol name.
* \return Whether the table contains a symbol with the given name.
*/
bool contains(const std::string& name)
{
return lookup(name) != nothing;
}
/**
* Registers new symbol.
*