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

Add array_type

Browse Source
This commit is contained in:
Eugen Wissner 2025-03-08 13:55:42 +01:00
parent dc5760394b
commit 868db6e0bf
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
2 changed files with 198 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

185
boot/semantic.cc
View File

@ -21,37 +21,154 @@ namespace elna
{
namespace boot
{
type::type(alias_type *alias)
: payload({ .alias = alias }), tag(type_tag::alias)
type::type()
: tag(type_tag::alias)
{
}
type::type(primitive_type *primitive)
: payload({ .primitive = primitive }), tag(type_tag::primitive)
type::type(std::shared_ptr<alias_type> alias)
: tag(type_tag::alias), alias(alias)
{
}
type::type(record_type *record)
: payload({ .record = record }), tag(type_tag::record)
type::type(std::shared_ptr<primitive_type> primitive)
: tag(type_tag::primitive), primitive(primitive)
{
}
type::type(union_type *_union)
: payload({ ._union = _union }), tag(type_tag::_union)
type::type(std::shared_ptr<record_type> record)
: tag(type_tag::record), record(record)
{
}
type::type(pointer_type *pointer)
: payload({ .pointer = pointer }), tag(type_tag::pointer)
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<>
alias_type *const type::get<alias_type>() const
std::shared_ptr<alias_type> type::get<alias_type>() const
{
if (tag == type_tag::alias)
{
return payload.alias;
return this->alias.lock();
}
else
{
@ -60,11 +177,11 @@ namespace boot
}
template<>
primitive_type *const type::get<primitive_type>() const
std::shared_ptr<primitive_type> type::get<primitive_type>() const
{
if (tag == type_tag::primitive)
{
return payload.primitive;
return this->primitive.lock();
}
else
{
@ -73,11 +190,11 @@ namespace boot
}
template<>
record_type *const type::get<record_type>() const
std::shared_ptr<record_type> type::get<record_type>() const
{
if (tag == type_tag::record)
{
return payload.record;
return this->record;
}
else
{
@ -86,11 +203,11 @@ namespace boot
}
template<>
union_type *const type::get<union_type>() const
std::shared_ptr<union_type> type::get<union_type>() const
{
if (tag == type_tag::_union)
{
return payload._union;
return this->_union;
}
else
{
@ -99,11 +216,24 @@ namespace boot
}
template<>
pointer_type *const type::get<pointer_type>() const
std::shared_ptr<pointer_type> type::get<pointer_type>() const
{
if (tag == type_tag::pointer)
{
return payload.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
{
@ -121,6 +251,11 @@ namespace boot
{
}
array_type::array_type(type base, std::uint64_t size)
: base(base), size(size)
{
}
primitive_type::primitive_type(const std::string& identifier)
: identifier(identifier)
{
@ -130,7 +265,7 @@ namespace boot
{
for (type_definition *const type : program->types)
{
this->unresolved.insert({ type->identifier, new alias_type() });
this->unresolved.insert({ type->identifier, std::make_shared<alias_type>() });
}
for (type_definition *const type : program->types)
{
@ -157,7 +292,7 @@ namespace boot
}
else
{
this->current_type = type(new primitive_type(type_expression->name));
this->current_type = type(std::make_shared<primitive_type>(type_expression->name));
}
}
@ -168,19 +303,19 @@ namespace boot
void declaration_visitor::visit(pointer_type_expression *type_expression)
{
type_expression->base().accept(this);
this->current_type = type(new pointer_type(this->current_type));
this->current_type = type(std::make_shared<pointer_type>(this->current_type));
}
void declaration_visitor::visit(record_type_expression *type_expression)
{
auto type_definition = new record_type();
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 = new union_type();
auto type_definition = std::make_shared<union_type>();
this->current_type = type(type_definition);
}

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

@ -18,6 +18,7 @@ along with GCC; see the file COPYING3. If not see
#include <string>
#include <vector>
#include <unordered_map>
#include <memory>
#include "elna/boot/ast.h"
@ -30,6 +31,7 @@ namespace boot
class record_type;
class union_type;
class pointer_type;
class array_type;
class type
{
@ -41,29 +43,41 @@ namespace boot
record,
_union,
pointer,
array
};
type_tag tag{ type_tag::empty };
union
{
nullptr_t empty;
alias_type *alias;
primitive_type *primitive;
record_type *record;
union_type *_union;
pointer_type *pointer;
} payload{ .empty = nullptr };
std::weak_ptr<alias_type> alias;
std::weak_ptr<primitive_type> primitive;
std::shared_ptr<record_type> record;
std::shared_ptr<union_type> _union;
std::shared_ptr<pointer_type> pointer;
std::shared_ptr<array_type> array;
};
type_tag tag{ type_tag::empty };
void copy(const type& other);
void move(type&& other);
public:
type() = default;
explicit type(alias_type *alias);
explicit type(primitive_type *primitive);
explicit type(record_type *record);
explicit type(union_type *_union);
explicit type(pointer_type *pointer);
type();
explicit type(std::shared_ptr<alias_type> alias);
explicit type(std::shared_ptr<primitive_type> primitive);
explicit type(std::shared_ptr<record_type> record);
explicit type(std::shared_ptr<union_type> _union);
explicit type(std::shared_ptr<pointer_type> pointer);
explicit type(std::shared_ptr<array_type> array);
type(const type& other);
type& operator=(const type& other);
type(type&& other);
type& operator=(type&& other);
~type();
template<typename T>
T *const get() const;
std::shared_ptr<T> get() const;
bool empty() const;
};
@ -80,6 +94,14 @@ namespace boot
explicit pointer_type(type base);
};
struct array_type
{
const type base;
const std::uint64_t size;
array_type(type base, std::uint64_t size);
};
struct primitive_type
{
const std::string identifier;
@ -104,7 +126,7 @@ namespace boot
type current_type;
public:
std::unordered_map<std::string, alias_type *> unresolved;
std::unordered_map<std::string, std::shared_ptr<alias_type>> unresolved;
declaration_visitor() = default;