Rename elna::source to elna:boot

boot/ast.cc

@@ -0,0 +1,982 @@
+// This Source Code Form is subject to the terms of the Mozilla Public License
+// v. 2.0. If a copy of the MPL was not distributed with this file, You can
+// obtain one at http://mozilla.org/MPL/2.0/.
+#include "elna/boot/ast.h"
+
+namespace elna
+{
+namespace boot
+{
+    void empty_visitor::visit(variable_declaration *)
+    {
+    }
+
+    void empty_visitor::visit(constant_definition *definition)
+    {
+        definition->body().accept(this);
+    }
+
+    void empty_visitor::visit(procedure_definition *definition)
+    {
+        for (auto parameter : definition->parameters)
+        {
+            parameter->accept(this);
+        }
+        if (definition->body() != nullptr)
+        {
+            definition->body()->accept(this);
+        }
+    }
+
+    void empty_visitor::visit(type_definition *definition)
+    {
+        definition->body().accept(this);
+    }
+
+    void empty_visitor::visit(call_expression *expression)
+    {
+        for (auto& argument : expression->arguments())
+        {
+            argument->accept(this);
+        }
+    }
+
+    void empty_visitor::visit(cast_expression *expression)
+    {
+        expression->target().accept(this);
+        expression->value().accept(this);
+    }
+
+    void empty_visitor::visit(size_of_expression *expression)
+    {
+        expression->body().accept(this);
+    }
+
+    void empty_visitor::visit(call_statement *statement)
+    {
+        statement->body().accept(this);
+    }
+
+    void empty_visitor::visit(assign_statement *statement)
+    {
+        statement->rvalue().accept(this);
+    }
+
+    void empty_visitor::visit(if_statement *statement)
+    {
+        statement->body().prerequisite().accept(this);
+        for (const auto body_statement : statement->body().statements)
+        {
+            body_statement->accept(this);
+        }
+    }
+
+    void empty_visitor::visit(while_statement *statement)
+    {
+        statement->body().prerequisite().accept(this);
+        for (const auto body_statement : statement->body().statements)
+        {
+            body_statement->accept(this);
+        }
+    }
+
+    void empty_visitor::visit(return_statement *statement)
+    {
+        expression *return_expression = statement->return_expression();
+
+        if (return_expression != nullptr)
+        {
+            return_expression->accept(this);
+        }
+    }
+
+    void empty_visitor::visit(block *block)
+    {
+        for (const auto definition : block->value_definitions)
+        {
+            definition->accept(this);
+        }
+        for (const auto body_statement : block->body)
+        {
+            body_statement->accept(this);
+        }
+    }
+
+    void empty_visitor::visit(program *program)
+    {
+        for (auto definition : program->type_definitions)
+        {
+            definition->accept(this);
+        }
+        visit(reinterpret_cast<block *>(program));
+    }
+
+    void empty_visitor::visit(binary_expression *expression)
+    {
+        expression->lhs().accept(this);
+        expression->rhs().accept(this);
+    }
+
+    void empty_visitor::visit(unary_expression *expression)
+    {
+        expression->operand().accept(this);
+    }
+
+    void empty_visitor::visit(basic_type_expression *)
+    {
+    }
+
+    void empty_visitor::visit(array_type_expression *expression)
+    {
+        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(union_type_expression *expression)
+    {
+        for (auto& field : expression->fields)
+        {
+            field.second->accept(this);
+        }
+    }
+
+    void empty_visitor::visit(variable_expression *)
+    {
+    }
+
+    void empty_visitor::visit(array_access_expression *expression)
+    {
+        expression->base().accept(this);
+        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> *)
+    {
+    }
+
+    void empty_visitor::visit(number_literal<std::uint32_t> *)
+    {
+    }
+
+    void empty_visitor::visit(number_literal<double> *)
+    {
+    }
+
+    void empty_visitor::visit(number_literal<bool> *)
+    {
+    }
+
+    void empty_visitor::visit(number_literal<unsigned char> *)
+    {
+    }
+
+    void empty_visitor::visit(number_literal<std::nullptr_t> *)
+    {
+    }
+
+    void empty_visitor::visit(string_literal *)
+    {
+    }
+
+    node::node(const struct position position)
+        : source_position(position)
+    {
+    }
+
+    const struct position& node::position() const
+    {
+        return this->source_position;
+    }
+
+    statement::statement(const struct position position)
+        : node(position)
+    {
+    }
+
+    expression::expression(const struct position position)
+        : node(position)
+    {
+    }
+
+    type_expression::type_expression(const struct position position)
+        : node(position)
+    {
+    }
+
+    basic_type_expression *type_expression::is_basic()
+    {
+        return nullptr;
+    }
+
+    array_type_expression *type_expression::is_array()
+    {
+        return nullptr;
+    }
+
+    record_type_expression *type_expression::is_record()
+    {
+        return nullptr;
+    }
+
+    union_type_expression *type_expression::is_union()
+    {
+        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)
+    {
+    }
+
+    void basic_type_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    const std::string& basic_type_expression::base_name()
+    {
+        return m_name;
+    }
+
+    basic_type_expression *basic_type_expression::is_basic()
+    {
+        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)
+    {
+    }
+
+    void array_type_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    type_expression& array_type_expression::base()
+    {
+        return *m_base;
+    }
+
+    array_type_expression *array_type_expression::is_array()
+    {
+        return this;
+    }
+
+    array_type_expression::~array_type_expression()
+    {
+        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;
+    }
+
+    pointer_type_expression *pointer_type_expression::is_pointer()
+    {
+        return this;
+    }
+
+    pointer_type_expression::~pointer_type_expression()
+    {
+        delete m_base;
+    }
+
+    composite_type_expression::composite_type_expression(const struct position position,
+            fields_t&& fields)
+        : type_expression(position), fields(std::move(fields))
+    {
+    }
+
+    composite_type_expression::~composite_type_expression()
+    {
+        for (auto& field_declaration : fields)
+        {
+            delete field_declaration.second;
+        }
+    }
+
+    record_type_expression::record_type_expression(const struct position position,
+            fields_t&& fields)
+        : composite_type_expression(position, std::move(fields))
+    {
+    }
+
+    void record_type_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    record_type_expression *record_type_expression::is_record()
+    {
+        return this;
+    }
+
+    union_type_expression::union_type_expression(const struct position position,
+            fields_t&& fields)
+        : composite_type_expression(position, std::move(fields))
+    {
+    }
+
+    union_type_expression *union_type_expression::is_union()
+    {
+        return this;
+    }
+
+    void union_type_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    variable_declaration::variable_declaration(const struct position position, const std::string& identifier,
+            type_expression *type)
+        : definition(position, identifier), m_type(type)
+    {
+    }
+
+    variable_declaration::~variable_declaration()
+    {
+        delete m_type;
+    }
+
+    void variable_declaration::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    type_expression& variable_declaration::type()
+    {
+        return *m_type;
+    }
+
+    definition::definition(const struct position position, const std::string& identifier)
+        : node(position), m_identifier(identifier)
+    {
+    }
+
+    std::string& definition::identifier()
+    {
+        return m_identifier;
+    }
+
+    constant_definition::constant_definition(const struct position position, const std::string& identifier,
+            literal *body)
+        : definition(position, identifier), m_body(body)
+    {
+    }
+
+    void constant_definition::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    literal& constant_definition::body()
+    {
+        return *m_body;
+    }
+
+    constant_definition::~constant_definition()
+    {
+        delete m_body;
+    }
+
+    procedure_definition::procedure_definition(const struct position position, const std::string& identifier,
+            std::vector<variable_declaration *>&& parameters, type_expression *return_type, block *body)
+        : definition(position, identifier), m_return_type(return_type), m_body(body), parameters(std::move(parameters))
+    {
+    }
+
+    void procedure_definition::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    block *procedure_definition::body()
+    {
+        return m_body;
+    }
+
+    type_expression *procedure_definition::return_type()
+    {
+        return m_return_type;
+    }
+
+    procedure_definition::~procedure_definition()
+    {
+        if (m_body != nullptr)
+        {
+            delete m_body;
+        }
+        for (auto parameter : parameters)
+        {
+            delete parameter;
+        }
+    }
+
+    type_definition::type_definition(const struct position position, const std::string& identifier,
+            type_expression *body)
+        : definition(position, identifier), m_body(body)
+    {
+    }
+
+    void type_definition::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    type_expression& type_definition::body()
+    {
+        return *m_body;
+    }
+
+    type_definition::~type_definition()
+    {
+        delete m_body;
+    }
+
+    block::block(const struct position position, std::vector<definition *>&& value_definitions,
+            std::vector<statement *>&& body)
+        : node(position), value_definitions(std::move(value_definitions)), body(std::move(body))
+    {
+    }
+
+    void block::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    block::~block()
+    {
+        for (auto definition : this->value_definitions)
+        {
+            delete definition;
+        }
+        for (auto body_statement : this->body)
+        {
+            delete body_statement;
+        }
+    }
+
+    program::program(const struct position position,
+            std::vector<definition *>&& type_definitions,
+            std::vector<definition *>&& value_definitions, std::vector<statement *>&& body)
+        : block(position, std::move(value_definitions), std::move(body)),
+        type_definitions(std::move(type_definitions))
+    {
+    }
+
+    void program::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    program::~program()
+    {
+        for (auto definition : type_definitions)
+        {
+            delete definition;
+        }
+    }
+
+    literal::literal(const struct position position)
+        : expression(position)
+    {
+    }
+
+    string_literal::string_literal(const struct position position, const std::string& value)
+        : literal(position), m_string(value)
+    {
+    }
+
+    void string_literal::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    const std::string& string_literal::string() const
+    {
+        return m_string;
+    }
+
+    designator_expression::designator_expression(const struct position position)
+        : expression(position)
+    {
+    }
+
+    variable_expression::variable_expression(const struct position position, const std::string& name)
+        : designator_expression(position), m_name(name)
+    {
+    }
+
+    void variable_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    const std::string& variable_expression::name() const
+    {
+        return m_name;
+    }
+
+    variable_expression *variable_expression::is_variable()
+    {
+        return this;
+    }
+
+    array_access_expression::array_access_expression(const struct position position,
+            designator_expression *base, expression *index)
+        : designator_expression(position), m_base(base), m_index(index)
+    {
+    }
+
+    void array_access_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    expression& array_access_expression::index()
+    {
+        return *m_index;
+    }
+
+    designator_expression& array_access_expression::base()
+    {
+        return *m_base;
+    }
+
+    array_access_expression *array_access_expression::is_array_access()
+    {
+        return this;
+    }
+
+    array_access_expression::~array_access_expression()
+    {
+        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 binary_operator operation)
+        : expression(position), m_lhs(lhs), m_rhs(rhs), m_operator(operation)
+    {
+    }
+
+    void binary_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    expression& binary_expression::lhs()
+    {
+        return *m_lhs;
+    }
+
+    expression& binary_expression::rhs()
+    {
+        return *m_rhs;
+    }
+
+    binary_operator binary_expression::operation() const
+    {
+        return m_operator;
+    }
+
+    binary_expression::~binary_expression()
+    {
+        delete m_lhs;
+        delete m_rhs;
+    }
+
+    unary_expression::unary_expression(const struct position position, expression *operand,
+            const unary_operator operation)
+        : expression(position), m_operand(std::move(operand)), m_operator(operation)
+    {
+    }
+
+    void unary_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    expression& unary_expression::operand()
+    {
+        return *m_operand;
+    }
+
+    unary_operator unary_expression::operation() const
+    {
+        return this->m_operator;
+    }
+
+    unary_expression::~unary_expression()
+    {
+        delete m_operand;
+    }
+
+    call_expression::call_expression(const struct position position, const std::string& name)
+        : expression(position), m_name(name)
+    {
+    }
+
+    void call_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    std::string& call_expression::name()
+    {
+        return m_name;
+    }
+
+    std::vector<expression *>& call_expression::arguments()
+    {
+        return m_arguments;
+    }
+
+    call_expression::~call_expression()
+    {
+        for (auto argument : m_arguments)
+        {
+            delete argument;
+        }
+    }
+
+    cast_expression::cast_expression(const struct position position, type_expression *target, expression *value)
+        : expression(position), m_target(target), m_value(value)
+    {
+    }
+
+    void cast_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    type_expression& cast_expression::target()
+    {
+        return *m_target;
+    }
+
+    expression& cast_expression::value()
+    {
+        return *m_value;
+    }
+
+    cast_expression::~cast_expression()
+    {
+        delete m_target;
+        delete m_value;
+    }
+
+    size_of_expression::size_of_expression(const struct position position, type_expression *body)
+        : expression(position), m_body(body)
+    {
+    }
+
+    void size_of_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    type_expression& size_of_expression::body()
+    {
+        return *m_body;
+    }
+
+    size_of_expression::~size_of_expression()
+    {
+        delete m_body;
+    }
+
+    call_statement::call_statement(const struct position position, call_expression *body)
+        : statement(position), m_body(body)
+    {
+    }
+
+    void call_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    call_expression& call_statement::body()
+    {
+        return *m_body;
+    }
+
+    call_statement::~call_statement()
+    {
+        delete m_body;
+    }
+
+    conditional_statements::conditional_statements(expression *prerequisite)
+        : m_prerequisite(prerequisite)
+    {
+    }
+
+    expression& conditional_statements::prerequisite()
+    {
+        return *m_prerequisite;
+    }
+
+    conditional_statements::~conditional_statements()
+    {
+        delete m_prerequisite;
+        for (auto statement : statements)
+        {
+            delete statement;
+        }
+    }
+
+    return_statement::return_statement(const struct position position, expression *return_expression)
+        : statement(position), m_return_expression(return_expression)
+    {
+    }
+
+    void return_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    expression *return_statement::return_expression()
+    {
+        return m_return_expression;
+    }
+
+    return_statement::~return_statement()
+    {
+        if (m_return_expression != nullptr)
+        {
+            delete m_return_expression;
+        }
+    }
+
+    void assign_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    assign_statement::assign_statement(const struct position position, designator_expression *lvalue,
+            expression *rvalue)
+        : statement(position), m_lvalue(lvalue), m_rvalue(rvalue)
+    {
+    }
+
+    variable_expression *designator_expression::is_variable()
+    {
+        return nullptr;
+    }
+
+    array_access_expression *designator_expression::is_array_access()
+    {
+        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;
+    }
+
+    expression& assign_statement::rvalue()
+    {
+        return *m_rvalue;
+    }
+
+    assign_statement::~assign_statement()
+    {
+        delete m_rvalue;
+    }
+
+    if_statement::if_statement(const struct position position, conditional_statements *body,
+            std::vector<statement *> *alternative)
+        : statement(position), m_body(body), m_alternative(alternative)
+    {
+    }
+
+    void if_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    conditional_statements& if_statement::body()
+    {
+        return *m_body;
+    }
+
+    std::vector<statement *> *if_statement::alternative()
+    {
+        return m_alternative;
+    }
+
+    if_statement::~if_statement()
+    {
+        delete m_body;
+        for (const auto branch : branches)
+        {
+            delete branch;
+        }
+        if (m_alternative != nullptr)
+        {
+            delete m_alternative;
+        }
+    }
+
+    while_statement::while_statement(const struct position position, conditional_statements *body)
+        : statement(position), m_body(body)
+    {
+    }
+
+    void while_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    conditional_statements& while_statement::body()
+    {
+        return *m_body;
+    }
+
+    while_statement::~while_statement()
+    {
+        delete m_body;
+    }
+
+    const char *print_binary_operator(const binary_operator operation)
+    {
+        switch (operation)
+        {
+            case binary_operator::sum:
+                return "+";
+            case binary_operator::subtraction: 
+                return "-";
+            case binary_operator::multiplication:
+                return "*";
+            case binary_operator::division:
+                return "/";
+            case binary_operator::remainder:
+                return "%";
+            case binary_operator::equals:
+                return "=";
+            case binary_operator::not_equals:
+                return "<>";
+            case binary_operator::less:
+                return "<";
+            case binary_operator::less_equal:
+                return "<=";
+            case binary_operator::greater:
+                return ">";
+            case binary_operator::greater_equal:
+                return ">=";
+            case binary_operator::conjunction:
+                return "and";
+            case binary_operator::disjunction:
+                return "or";
+        }
+        __builtin_unreachable();
+    };
+}
+}