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

Construct the parse tree with raw pointers

Browse Source
This commit is contained in:
Eugen Wissner
2025-01-05 15:21:25 +01:00
parent bbd38a5d26
commit e8747a803f
3 changed files with 269 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
include/elna/source/ast.h
View File

@ -262,7 +262,7 @@ namespace source
*/
class declaration : public definition
{
std::unique_ptr<type_expression> m_type;
type_expression *m_type;
public:
/**
@ -273,10 +273,12 @@ namespace source
* \param type Declared type.
*/
declaration(const struct position position, const std::string& identifier,
std::unique_ptr<type_expression>&& type);
type_expression *type);
virtual void accept(parser_visitor *visitor) override;
type_expression& type() noexcept;
virtual ~declaration() override;
};
/**
@ -284,7 +286,7 @@ namespace source
*/
class constant_definition : public definition
{
std::unique_ptr<number_literal<std::int32_t>> m_body;
number_literal<std::int32_t> *m_body;
public:
/**
@ -293,10 +295,12 @@ namespace source
* \param body Constant value.
*/
constant_definition(const struct position position, const std::string& identifier,
std::unique_ptr<number_literal<std::int32_t>>&& body);
number_literal<std::int32_t> *body);
virtual void accept(parser_visitor *visitor) override;
number_literal<std::int32_t>& body();
virtual ~constant_definition() override;
};
/**
@ -304,8 +308,8 @@ namespace source
*/
class procedure_definition : public definition
{
std::unique_ptr<block> m_body;
std::vector<std::unique_ptr<declaration>> m_parameters;
block *m_body;
std::vector<declaration *> m_parameters;
public:
/**
@ -314,11 +318,13 @@ namespace source
* \param body Procedure body.
*/
procedure_definition(const struct position position, const std::string& identifier,
std::unique_ptr<block>&& body);
block *body);
virtual void accept(parser_visitor *visitor) override;
block& body();
std::vector<std::unique_ptr<declaration>>& parameters() noexcept;
std::vector<declaration *>& parameters() noexcept;
virtual ~procedure_definition() override;
};
/**
@ -327,7 +333,7 @@ namespace source
class call_statement : public statement
{
std::string m_name;
std::vector<std::unique_ptr<expression>> m_arguments;
std::vector<expression *> m_arguments;
public:
/**
@ -338,24 +344,28 @@ namespace source
virtual void accept(parser_visitor *visitor) override;
std::string& name() noexcept;
std::vector<std::unique_ptr<expression>>& arguments() noexcept;
std::vector<expression *>& arguments() noexcept;
virtual ~call_statement() override;
};
class compound_statement : public statement
{
std::vector<std::unique_ptr<statement>> m_statements;
std::vector<statement *> m_statements;
public:
explicit compound_statement(const struct position position);
virtual void accept(parser_visitor *visitor) override;
std::vector<std::unique_ptr<statement>>& statements();
std::vector<statement *>& statements();
virtual ~compound_statement() override;
};
class assign_statement : public statement
{
std::string m_lvalue;
std::unique_ptr<expression> m_rvalue;
expression *m_rvalue;
public:
/**
@ -364,11 +374,13 @@ namespace source
* \param rvalue Assigned expression.
*/
assign_statement(const struct position position, const std::string& lvalue,
std::unique_ptr<expression>&& rvalue);
expression *rvalue);
virtual void accept(parser_visitor *visitor) override;
std::string& lvalue() noexcept;
expression& rvalue();
virtual ~assign_statement() override;
};
/**
@ -376,9 +388,9 @@ namespace source
*/
class if_statement : public statement
{
std::unique_ptr<expression> m_prerequisite;
std::unique_ptr<statement> m_body;
std::unique_ptr<statement> m_alternative;
expression *m_prerequisite;
statement *m_body;
statement *m_alternative;
public:
/**
@ -387,13 +399,15 @@ namespace source
* \param body Statement executed if the condition is met.
* \param alternative Statement executed if the condition is not met.
*/
if_statement(const struct position position, std::unique_ptr<expression>&& prerequisite,
std::unique_ptr<statement>&& body, std::unique_ptr<statement>&& alternative = nullptr);
if_statement(const struct position position, expression *prerequisite,
statement *body, statement *alternative = nullptr);
virtual void accept(parser_visitor *visitor) override;
expression& prerequisite();
statement& body();
std::unique_ptr<statement>& alternative();
statement *alternative();
virtual ~if_statement() override;
};
/**
@ -401,8 +415,8 @@ namespace source
*/
class while_statement : public statement
{
std::unique_ptr<expression> m_prerequisite;
std::unique_ptr<statement> m_body;
expression *m_prerequisite;
statement *m_body;
public:
/**
@ -410,37 +424,41 @@ namespace source
* \param prerequisite Condition.
* \param body Statement executed while the condition is met.
*/
while_statement(const struct position position, std::unique_ptr<expression>&& prerequisite,
std::unique_ptr<statement>&& body);
while_statement(const struct position position, expression *prerequisite,
statement *body);
virtual void accept(parser_visitor *visitor) override;
expression& prerequisite();
statement& body();
virtual ~while_statement() override;
};
class block : public node
{
std::vector<std::unique_ptr<definition>> m_definitions;
std::vector<std::unique_ptr<declaration>> m_declarations;
std::unique_ptr<statement> m_body;
std::vector<definition *> m_definitions;
std::vector<declaration *> m_declarations;
statement *m_body;
public:
block(const struct position position, std::vector<std::unique_ptr<definition>>&& definitions,
std::vector<std::unique_ptr<declaration>>&& declarations,
std::unique_ptr<statement>&& body);
block(const struct position position, std::vector<definition *>&& definitions,
std::vector<declaration *>&& declarations,
statement *body);
virtual void accept(parser_visitor *visitor) override;
statement& body();
std::vector<std::unique_ptr<definition>>& definitions() noexcept;
std::vector<std::unique_ptr<declaration>>& declarations() noexcept;
std::vector<definition *>& definitions() noexcept;
std::vector<declaration *>& declarations() noexcept;
virtual ~block() override;
};
class program : public block
{
public:
program(const struct position position, std::vector<std::unique_ptr<definition>>&& definitions,
std::vector<std::unique_ptr<declaration>>&& declarations,
std::unique_ptr<statement>&& body);
program(const struct position position, std::vector<definition *>&& definitions,
std::vector<declaration *>&& declarations,
statement *body);
virtual void accept(parser_visitor *visitor) override;
};
@ -501,32 +519,36 @@ namespace source
class binary_expression : public expression
{
std::unique_ptr<expression> m_lhs;
std::unique_ptr<expression> m_rhs;
expression *m_lhs;
expression *m_rhs;
binary_operator m_operator;
public:
binary_expression(const struct position position, std::unique_ptr<expression>&& lhs,
std::unique_ptr<expression>&& rhs, const unsigned char operation);
binary_expression(const struct position position, expression *lhs,
expression *rhs, const unsigned char operation);
virtual void accept(parser_visitor *visitor) override;
expression& lhs();
expression& rhs();
binary_operator operation() const noexcept;
virtual ~binary_expression() override;
};
class unary_expression : public expression
{
std::unique_ptr<expression> m_operand;
expression *m_operand;
unary_operator m_operator;
public:
unary_expression(const struct position position, std::unique_ptr<expression>&& operand,
unary_expression(const struct position position, expression *operand,
const unsigned char operation);
virtual void accept(parser_visitor *visitor) override;
expression& operand();
unary_operator operation() const noexcept;
virtual ~unary_expression() override;
};
const char *print_binary_operator(const binary_operator operation);