Add pointer and field access nodes

source/ast.cc

@@ -101,6 +101,19 @@ namespace source
         expression->base().accept(this);
     }
 
+    void empty_visitor::visit(pointer_type_expression *expression)
+    {
+        expression->base().accept(this);
+    }
+
+    void empty_visitor::visit(record_type_expression *expression)
+    {
+        for (auto& field : expression->fields())
+        {
+            field.second->accept(this);
+        }
+    }
+
     void empty_visitor::visit(variable_expression *)
     {
     }
@@ -111,6 +124,16 @@ namespace source
         expression->index().accept(this);
     }
 
+    void empty_visitor::visit(field_access_expression *expression)
+    {
+        expression->base().accept(this);
+    }
+
+    void empty_visitor::visit(dereference_expression *expression)
+    {
+        expression->base().accept(this);
+    }
+
     void empty_visitor::visit(number_literal<std::int32_t> *)
     {
     }
@@ -210,6 +233,16 @@ namespace source
         return nullptr;
     }
 
+    record_type_expression *type_expression::is_record()
+    {
+        return nullptr;
+    }
+
+    pointer_type_expression *type_expression::is_pointer()
+    {
+        return nullptr;
+    }
+
     basic_type_expression::basic_type_expression(
             const struct position position, const std::string& name)
         : type_expression(position), m_name(name)
@@ -262,6 +295,57 @@ namespace source
         delete m_base;
     }
 
+    pointer_type_expression::pointer_type_expression(const struct position position, type_expression *base)
+        : type_expression(position), m_base(base)
+    {
+    }
+
+    void pointer_type_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    type_expression& pointer_type_expression::base()
+    {
+        return *m_base;
+    }
+
+    const std::string& pointer_type_expression::base_name()
+    {
+        return base().base_name();
+    }
+
+    pointer_type_expression *pointer_type_expression::is_pointer()
+    {
+        return this;
+    }
+
+    pointer_type_expression::~pointer_type_expression()
+    {
+        delete m_base;
+    }
+
+    record_type_expression::record_type_expression(const struct position position,
+            record_type_expression::fields_t&& fields)
+        : type_expression(position), m_fields(std::move(fields))
+    {
+    }
+
+    void record_type_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    record_type_expression::fields_t& record_type_expression::fields()
+    {
+        return m_fields;
+    }
+
+    record_type_expression *record_type_expression::is_record()
+    {
+        return this;
+    }
+
     declaration::declaration(const struct position position, const std::string& identifier,
             type_expression *type)
         : definition(position, identifier), m_type(type)
@@ -504,6 +588,63 @@ namespace source
         delete m_base;
     }
 
+    field_access_expression::field_access_expression(const struct position position,
+            designator_expression *base, const std::string& field)
+        : designator_expression(position), m_base(base), m_field(field)
+    {
+    }
+
+    void field_access_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    designator_expression& field_access_expression::base()
+    {
+        return *m_base;
+    }
+
+    std::string& field_access_expression::field()
+    {
+        return m_field;
+    }
+
+    field_access_expression *field_access_expression::is_field_access()
+    {
+        return this;
+    }
+
+    field_access_expression::~field_access_expression()
+    {
+        delete m_base;
+    }
+
+    dereference_expression::dereference_expression(const struct position position,
+            designator_expression *base)
+        : designator_expression(position), m_base(base)
+    {
+    }
+
+    void dereference_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    designator_expression& dereference_expression::base()
+    {
+        return *m_base;
+    }
+
+    dereference_expression *dereference_expression::is_dereference()
+    {
+        return this;
+    }
+
+    dereference_expression::~dereference_expression()
+    {
+        delete m_base;
+    }
+
     binary_expression::binary_expression(const struct position position, expression *lhs,
             expression *rhs, const unsigned char operation)
         : expression(position), m_lhs(std::move(lhs)), m_rhs(std::move(rhs))
@@ -680,6 +821,16 @@ namespace source
         return nullptr;
     }
 
+    field_access_expression *designator_expression::is_field_access()
+    {
+        return nullptr;
+    }
+
+    dereference_expression *designator_expression::is_dereference()
+    {
+        return nullptr;
+    }
+
     designator_expression& assign_statement::lvalue()
     {
         return *m_lvalue;

source/lexer.ll

@@ -70,7 +70,9 @@ of                      {
 type                    {
                             return yy::parser::make_TYPE(this->location);
                         }
-
+record                  {
+                            return yy::parser::make_RECORD(this->location);
+                        }
 true                    {
                             return yy::parser::make_BOOLEAN(true, this->location);
                         }

source/parser.yy

@@ -63,7 +63,7 @@
 %token <std::string> STRING "string"
 %token <bool> BOOLEAN
 %token IF WHILE DO
-%token CONST VAR PROCEDURE ARRAY OF TYPE
+%token CONST VAR PROCEDURE ARRAY OF TYPE RECORD
 %token BEGIN_BLOCK END_BLOCK
 %token LEFT_PAREN RIGHT_PAREN LEFT_SQUARE RIGHT_SQUARE SEMICOLON DOT COMMA
 %token GREATER_EQUAL LESS_EQUAL LESS_THAN GREATER_THAN NOT_EQUAL EQUALS
@@ -315,14 +315,17 @@ type_expression:
         {
             $$ = new elna::source::array_type_expression(elna::source::make_position(@1), $4, $2);
         }
+    | HAT type_expression
+        {
+            $$ = new elna::source::pointer_type_expression(elna::source::make_position(@1), $2);
+        }
     | IDENTIFIER
         {
             $$ = new elna::source::basic_type_expression(elna::source::make_position(@1), $1);
         }
 variable_declaration: IDENTIFIER COLON type_expression
         {
-            $$ = new elna::source::declaration(elna::source::make_position(@1),
-                $1, $3); 
+            $$ = new elna::source::declaration(elna::source::make_position(@1), $1, $3); 
         };
 variable_declarations:
     variable_declaration COMMA variable_declarations

source/result.cc

@@ -21,16 +21,5 @@ namespace source
     {
         return this->position.column;
     }
-
-    name_collision::name_collision(const std::string& name, const char *path,
-            const struct position current, const struct position previous)
-        : error(path, current), previous(previous), name(name)
-    {
-    }
-
-    std::string name_collision::what() const
-    {
-        return "Name '" + name + "' was already defined";
-    }
 }
 }