1 files changed, 50 insertions, 36 deletions

diff --git a/frontend/ast.cc b/frontend/ast.cc
index e067937..9a1f96b 100644
--- a/frontend/ast.cc
+++ b/frontend/ast.cc
@@ -24,7 +24,7 @@ namespace elna::frontend
         __builtin_unreachable();
     }
 
-    void empty_visitor::visit(named_type_expression *)
+    void empty_visitor::visit(type_expression *)
     {
         not_implemented();
     }
@@ -149,7 +149,7 @@ namespace elna::frontend
         not_implemented();
     }
 
-    void empty_visitor::visit(variable_expression *)
+    void empty_visitor::visit(named_expression *)
     {
         not_implemented();
     }
@@ -253,12 +253,7 @@ namespace elna::frontend
         return nullptr;
     }
 
-    type_expression::type_expression(const struct position position)
-        : node(position)
-    {
-    }
-
-    named_type_expression *type_expression::is_named()
+    named_expression *type_expression::is_named()
     {
         return nullptr;
     }
@@ -293,24 +288,46 @@ namespace elna::frontend
         return nullptr;
     }
 
-    named_type_expression::named_type_expression(const struct position position, const std::string& name)
-        : type_expression(position), name(name)
+    void type_expression::accept(parser_visitor *visitor)
     {
+        if (named_expression *node = is_named())
+        {
+            return visitor->visit(node);
+        }
+        else if (array_type_expression *node = is_array())
+        {
+            return visitor->visit(node);
+        }
+        else if (pointer_type_expression *node = is_pointer())
+        {
+            return visitor->visit(node);
+        }
+        else if (record_type_expression *node = is_record())
+        {
+            return visitor->visit(node);
+        }
+        else if (union_type_expression *node = is_union())
+        {
+            return visitor->visit(node);
+        }
+        else if (procedure_type_expression *node = is_procedure())
+        {
+            return visitor->visit(node);
+        }
+        else if (enumeration_type_expression *node = is_enumeration())
+        {
+            return visitor->visit(node);
+        }
+        __builtin_unreachable();
     }
 
-    void named_type_expression::accept(parser_visitor *visitor)
-    {
-        visitor->visit(this);
-    }
-
-    named_type_expression *named_type_expression::is_named()
+    type_expression::~type_expression()
     {
-        return this;
     }
 
     array_type_expression::array_type_expression(const struct position position,
             type_expression *base, const std::uint32_t size)
-        : type_expression(position), m_base(base), size(size)
+        : node(position), m_base(base), size(size)
     {
     }
 
@@ -336,7 +353,7 @@ namespace elna::frontend
 
     pointer_type_expression::pointer_type_expression(const struct position position,
             type_expression *base)
-        : type_expression(position), m_base(base)
+        : node(position), m_base(base)
     {
     }
 
@@ -362,7 +379,7 @@ namespace elna::frontend
 
     record_type_expression::record_type_expression(const struct position position,
             std::vector<field_declaration>&& fields)
-        : type_expression(position), fields(std::move(fields))
+        : node(position), fields(std::move(fields))
     {
     }
 
@@ -386,7 +403,7 @@ namespace elna::frontend
 
     union_type_expression::union_type_expression(const struct position position,
             std::vector<field_declaration>&& fields)
-        : type_expression(position), fields(std::move(fields))
+        : node(position), fields(std::move(fields))
     {
     }
 
@@ -464,7 +481,7 @@ namespace elna::frontend
     }
 
     procedure_type_expression::procedure_type_expression(const struct position position, return_t return_type)
-        : type_expression(position), return_type(return_type)
+        : node(position), return_type(return_type)
     {
     }
 
@@ -491,7 +508,7 @@ namespace elna::frontend
     }
 
     enumeration_type_expression::enumeration_type_expression(const struct position position, std::vector<std::string>&& members)
-        : type_expression(position), members(members)
+        : node(position), members(members)
     {
     }
 
@@ -559,6 +576,11 @@ namespace elna::frontend
     {
     }
 
+    block::block(std::vector<constant_declaration*>&& constants, std::vector<variable_declaration *>&& variables)
+        : m_variables(std::move(variables)), m_constants(std::move(constants))
+    {
+    }
+
     block::block(block&& that)
         : m_variables(std::move(that.m_variables)), m_constants(std::move(that.m_constants)),
         m_body(std::move(that.m_body))
@@ -657,10 +679,6 @@ namespace elna::frontend
         }
     }
 
-    literal_expression::literal_expression()
-    {
-    }
-
     literal_expression *literal_expression::is_literal()
     {
         return this;
@@ -684,10 +702,6 @@ namespace elna::frontend
         }
     }
 
-    designator_expression::designator_expression()
-    {
-    }
-
     designator_expression::~designator_expression()
     {
     }
@@ -699,7 +713,7 @@ namespace elna::frontend
 
     void designator_expression::accept(parser_visitor *visitor)
     {
-        if (variable_expression *node = is_variable())
+        if (named_expression *node = is_named())
         {
             return visitor->visit(node);
         }
@@ -718,17 +732,17 @@ namespace elna::frontend
         __builtin_unreachable();
     }
 
-    variable_expression::variable_expression(const struct position position, const std::string& name)
+    named_expression::named_expression(const struct position position, const std::string& name)
         : node(position), name(name)
     {
     }
 
-    void variable_expression::accept(parser_visitor *visitor)
+    void named_expression::accept(parser_visitor *visitor)
     {
         visitor->visit(this);
     }
 
-    variable_expression *variable_expression::is_variable()
+    named_expression *named_expression::is_named()
     {
         return this;
     }
@@ -1039,7 +1053,7 @@ namespace elna::frontend
         visitor->visit(this);
     }
 
-    variable_expression *designator_expression::is_variable()
+    named_expression *designator_expression::is_named()
     {
         return nullptr;
     }