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

Add lexer and parser sources

Browse Source
This commit is contained in:
Eugen Wissner
2025-06-14 23:57:48 +02:00
parent d5e2d53e9b
commit f524311f06
25 changed files with 3475 additions and 427 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -54,9 +54,9 @@ namespace elna::boot
};
class variable_declaration;
class constant_definition;
class procedure_definition;
class type_definition;
class constant_declaration;
class procedure_declaration;
class type_declaration;
class procedure_call;
class cast_expression;
class assign_statement;
@ -93,9 +93,9 @@ namespace elna::boot
struct parser_visitor
{
virtual void visit(variable_declaration *) = 0;
virtual void visit(constant_definition *) = 0;
virtual void visit(procedure_definition *) = 0;
virtual void visit(type_definition *) = 0;
virtual void visit(constant_declaration *) = 0;
virtual void visit(procedure_declaration *) = 0;
virtual void visit(type_declaration *) = 0;
virtual void visit(procedure_call *) = 0;
virtual void visit(cast_expression *) = 0;
virtual void visit(traits_expression *) = 0;
@ -178,10 +178,10 @@ namespace elna::boot
/**
* Symbol definition.
*/
class definition : public node
class declaration : public node
{
protected:
definition(const struct position position, identifier_definition identifier);
declaration(const struct position position, identifier_definition identifier);
public:
const identifier_definition identifier;
@ -292,7 +292,7 @@ namespace elna::boot
/**
* Variable declaration.
*/
class variable_declaration : public definition
class variable_declaration : public declaration
{
std::shared_ptr<type_expression> m_variable_type;
@ -320,18 +320,18 @@ namespace elna::boot
/**
* Constant definition.
*/
class constant_definition : public definition
class constant_declaration : public declaration
{
expression *m_body;
public:
constant_definition(const struct position position, identifier_definition identifier,
constant_declaration(const struct position position, identifier_definition identifier,
expression *body);
void accept(parser_visitor *visitor) override;
expression& body();
virtual ~constant_definition() override;
virtual ~constant_declaration() override;
};
/**
@ -354,7 +354,7 @@ namespace elna::boot
struct block
{
block(std::vector<constant_definition *>&& constants, std::vector<variable_declaration *>&& variables,
block(std::vector<constant_declaration*>&& constants, std::vector<variable_declaration *>&& variables,
std::vector<statement *>&& body);
block(const block&) = delete;
block(block&& that);
@ -363,14 +363,14 @@ namespace elna::boot
block& operator=(block&& that);
const std::vector<variable_declaration *>& variables();
const std::vector<constant_definition *>& constants();
const std::vector<constant_declaration *>& constants();
const std::vector<statement *>& body();
virtual ~block();
private:
std::vector<variable_declaration *> m_variables;
std::vector<constant_definition *> m_constants;
std::vector<constant_declaration *> m_constants;
std::vector<statement *> m_body;
};
@ -378,7 +378,7 @@ namespace elna::boot
/**
* Procedure definition.
*/
class procedure_definition : public definition
class procedure_declaration : public declaration
{
procedure_type_expression *m_heading;
@ -386,28 +386,28 @@ namespace elna::boot
std::optional<block> body;
std::vector<std::string> parameter_names;
procedure_definition(const struct position position, identifier_definition identifier,
procedure_declaration(const struct position position, identifier_definition identifier,
procedure_type_expression *heading, block&& body);
procedure_definition(const struct position position, identifier_definition identifier,
procedure_declaration(const struct position position, identifier_definition identifier,
procedure_type_expression *heading);
void accept(parser_visitor *visitor) override;
procedure_type_expression& heading();
virtual ~procedure_definition() override;
virtual ~procedure_declaration() override;
};
/**
* Type definition.
*/
class type_definition : public definition
class type_declaration : public declaration
{
type_expression *m_body;
public:
type_definition(const struct position position, identifier_definition identifier,
type_declaration(const struct position position, identifier_definition identifier,
type_expression *expression);
~type_definition();
~type_declaration();
void accept(parser_visitor *visitor) override;
@ -670,10 +670,10 @@ namespace elna::boot
{
public:
std::vector<import_declaration *> imports;
std::vector<constant_definition *> constants;
std::vector<type_definition *> types;
std::vector<constant_declaration *> constants;
std::vector<type_declaration *> types;
std::vector<variable_declaration *> variables;
std::vector<procedure_definition *> procedures;
std::vector<procedure_declaration *> procedures;
unit(const struct position position);
virtual void accept(parser_visitor *visitor) override;

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

@ -54,27 +54,26 @@ namespace elna::boot
constant_info::variant current_literal;
std::shared_ptr<symbol_table> symbols;
std::unordered_map<std::string, std::shared_ptr<alias_type>> unresolved;
procedure_type build_procedure(procedure_type_expression& type_expression);
public:
std::unordered_map<std::string, std::shared_ptr<alias_type>> unresolved;
explicit declaration_visitor(const char *path, std::shared_ptr<symbol_table> symbols);
void visit(named_type_expression *type_expression) override;
void visit(array_type_expression *type_expression) override;
void visit(pointer_type_expression *type_expression) override;
void visit(program *program) override;
void visit(type_definition *definition) override;
void visit(type_declaration *definition) override;
void visit(record_type_expression *type_expression) override;
void visit(union_type_expression *type_expression) override;
void visit(procedure_type_expression *type_expression) override;
void visit(enumeration_type_expression *type_expression) override;
void visit(variable_declaration *declaration) override;
void visit(constant_definition *definition) override;
void visit(procedure_definition *definition) override;
void visit(constant_declaration *definition) override;
void visit(procedure_declaration *definition) override;
void visit(assign_statement *statement) override;
void visit(if_statement *statement) override;
void visit(import_declaration *) override;

3
include/elna/boot/symbol.h
View File

@ -202,10 +202,9 @@ namespace elna::boot
class variable_info : public info
{
public:
const std::string name;
const type symbol;
variable_info(const std::string& name, const type symbol);
variable_info(const type symbol);
std::shared_ptr<variable_info> is_variable() override;
};

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

@ -33,9 +33,8 @@ along with GCC; see the file COPYING3. If not see
namespace elna::gcc
{
std::deque<std::unique_ptr<boot::error>> do_semantic_analysis(const char *path,
const std::unique_ptr<boot::program>& ast, std::shared_ptr<boot::symbol_table> info_table,
std::shared_ptr<symbol_table> symbols, std::unordered_map<std::string, tree>& unresolved);
std::unordered_map<std::string, tree> do_semantic_analysis(std::shared_ptr<boot::symbol_table> info_table,
std::shared_ptr<symbol_table> symbols);
tree handle_symbol(const std::string& symbol_name, std::shared_ptr<boot::alias_type> reference,
std::shared_ptr<symbol_table> symbols, std::unordered_map<std::string, tree>& unresolved,
std::vector<std::string>& path);
@ -46,7 +45,7 @@ namespace elna::gcc
std::shared_ptr<symbol_table> symbols;
std::unordered_map<std::string, tree> unresolved;
void declare_procedure(boot::procedure_definition *const definition);
void declare_procedure(boot::procedure_declaration *const definition);
tree build_procedure_type(boot::procedure_type_expression& type);
void build_composite_type(const std::vector<boot::field_declaration>& fields,
tree composite_type_node);
@ -79,7 +78,7 @@ namespace elna::gcc
std::unordered_map<std::string, tree>&& unresolved);
void visit(boot::program *program) override;
void visit(boot::procedure_definition *definition) override;
void visit(boot::procedure_declaration *definition) override;
void visit(boot::procedure_call *call) override;
void visit(boot::cast_expression *expression) override;
void visit(boot::traits_expression *trait) override;
@ -92,8 +91,8 @@ namespace elna::gcc
void visit(boot::literal<std::string> *string) override;
void visit(boot::binary_expression *expression) override;
void visit(boot::unary_expression *expression) override;
void visit(boot::constant_definition *definition) override;
void visit(boot::type_definition *definition) override;
void visit(boot::constant_declaration *definition) override;
void visit(boot::type_declaration *definition) override;
void visit(boot::variable_declaration *declaration) override;
void visit(boot::variable_expression *expression) override;
void visit(boot::array_access_expression *expression) override;