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

Parse import declarations

Browse Source
This commit is contained in:
Eugen Wissner
2025-05-16 23:16:19 +02:00
parent 981059e745
commit 573d812f1c
9 changed files with 333 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
include/elna/boot/ast.h
View File

@ -53,12 +53,6 @@ namespace elna::boot
minus
};
enum class escape_direction
{
begin,
end
};
class variable_declaration;
class constant_definition;
class procedure_definition;
@ -67,12 +61,12 @@ namespace elna::boot
class cast_expression;
class assign_statement;
class if_statement;
class escape_statement;
class import_declaration;
class while_statement;
class return_statement;
class case_statement;
class traits_expression;
class block;
class unit;
class program;
class binary_expression;
class unary_expression;
@ -107,12 +101,12 @@ namespace elna::boot
virtual void visit(traits_expression *) = 0;
virtual void visit(assign_statement *) = 0;
virtual void visit(if_statement *) = 0;
virtual void visit(escape_statement *) = 0;
virtual void visit(import_declaration *) = 0;
virtual void visit(while_statement *) = 0;
virtual void visit(return_statement *) = 0;
virtual void visit(defer_statement *) = 0;
virtual void visit(case_statement *) = 0;
virtual void visit(block *) = 0;
virtual void visit(unit *) = 0;
virtual void visit(program *) = 0;
virtual void visit(binary_expression *) = 0;
virtual void visit(unary_expression *) = 0;
@ -358,6 +352,29 @@ namespace elna::boot
procedure_type_expression *is_procedure() override;
};
struct block
{
block(std::vector<constant_definition *>&& constants, std::vector<variable_declaration *>&& variables,
std::vector<statement *>&& body);
block(const block&) = delete;
block(block&& that);
block& operator=(const block&) = delete;
block& operator=(block&& that);
const std::vector<variable_declaration *>& variables();
const std::vector<constant_definition *>& constants();
const std::vector<statement *>& body();
virtual ~block();
private:
std::vector<variable_declaration *> m_variables;
std::vector<constant_definition *> m_constants;
std::vector<statement *> m_body;
};
/**
* Procedure definition.
*/
@ -366,11 +383,13 @@ namespace elna::boot
procedure_type_expression *m_heading;
public:
block *const body;
std::optional<block> body;
std::vector<std::string> parameter_names;
procedure_definition(const struct position position, identifier_definition identifier,
procedure_type_expression *heading, block *body = nullptr);
procedure_type_expression *heading, block&& body);
procedure_definition(const struct position position, identifier_definition identifier,
procedure_type_expression *heading);
void accept(parser_visitor *visitor) override;
procedure_type_expression& heading();
@ -613,14 +632,15 @@ namespace elna::boot
virtual ~if_statement() override;
};
class escape_statement : public statement
/**
* Import statement.
*/
class import_declaration : public node
{
public:
const escape_direction direction;
const std::string label;
const std::vector<std::string> segments;
escape_statement(const struct position position,
escape_direction direction, const std::string& label);
import_declaration(const struct position position, std::vector<std::string>&& segments);
void accept(parser_visitor *visitor) override;
};
@ -648,24 +668,25 @@ namespace elna::boot
virtual ~while_statement() override;
};
class block : public node
class unit : public node
{
public:
std::vector<variable_declaration *> variables;
std::vector<import_declaration *> imports;
std::vector<constant_definition *> constants;
std::vector<statement *> body;
std::vector<type_definition *> types;
std::vector<variable_declaration *> variables;
std::vector<procedure_definition *> procedures;
block(const struct position position);
unit(const struct position position);
virtual void accept(parser_visitor *visitor) override;
virtual ~block() override;
virtual ~unit() override;
};
class program : public block
class program : public unit
{
public:
std::vector<type_definition *> types;
std::vector<procedure_definition *> procedures;
std::vector<statement *> body;
program(const struct position position);
void accept(parser_visitor *visitor) override;

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

@ -77,13 +77,13 @@ namespace elna::boot
void visit(procedure_definition *definition) override;
void visit(assign_statement *statement) override;
void visit(if_statement *statement) override;
void visit(escape_statement *) override;
void visit(import_declaration *) override;
void visit(while_statement *statement) override;
void visit(return_statement *statement) override;
void visit(defer_statement *statement) override;
void visit(case_statement *statement) override;
void visit(procedure_call *call) override;
void visit(block *block) override;
void visit(unit *unit) override;
void visit(cast_expression *expression) override;
void visit(traits_expression *trait) override;
void visit(binary_expression *expression) override;

5
include/elna/gcc/elna-generic.h
View File

@ -45,7 +45,6 @@ namespace elna::gcc
tree current_expression{ NULL_TREE };
std::shared_ptr<symbol_table> symbols;
std::unordered_map<std::string, tree> unresolved;
std::forward_list<std::pair<tree, tree>> loops;
void declare_procedure(boot::procedure_definition *const definition);
tree build_procedure_type(boot::procedure_type_expression& type);
@ -100,10 +99,10 @@ namespace elna::gcc
void visit(boot::array_access_expression *expression) override;
void visit(boot::field_access_expression *expression) override;
void visit(boot::dereference_expression *expression) override;
void visit(boot::block *block) override;
void visit(boot::unit *unit) override;
void visit(boot::assign_statement *statement) override;
void visit(boot::if_statement *statement) override;
void visit(boot::escape_statement *statement) override;
void visit(boot::import_declaration *) override;
void visit(boot::while_statement *statement) override;
void visit(boot::named_type_expression *type) override;
void visit(boot::array_type_expression *type) override;