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

Allow declaring type synonyms

Browse Source
This commit is contained in:
Eugen Wissner
2025-01-07 14:37:30 +01:00
parent ed1bb621d6
commit 2d61828903
13 changed files with 274 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -40,8 +40,10 @@ namespace gcc
void visit(source::string_literal *string) override;
void visit(source::binary_expression *expression) override;
void visit(source::constant_definition *definition) override;
void visit(source::type_definition *definition) override;
void visit(source::declaration *declaration) override;
void visit(source::variable_expression *expression) override;
void visit(source::array_access_expression *expression) override;
void visit(source::assign_statement *statement) override;
void visit(source::if_statement *statement) override;
void visit(source::while_statement *statement) override;

1
include/elna/gcc/elna-tree.h
View File

@ -23,6 +23,7 @@ namespace gcc
{
void init_ttree();
bool is_string_type(tree type);
bool is_array_type(tree type);
class tree_chain_base
{

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

@ -37,6 +37,7 @@ namespace source
class declaration;
class constant_definition;
class procedure_definition;
class type_definition;
class call_statement;
class compound_statement;
class assign_statement;
@ -49,6 +50,7 @@ namespace source
class basic_type_expression;
class array_type_expression;
class variable_expression;
class array_access_expression;
template<typename T>
class number_literal;
class char_literal;
@ -62,6 +64,7 @@ namespace source
virtual void visit(declaration *) = 0;
virtual void visit(constant_definition *) = 0;
virtual void visit(procedure_definition *) = 0;
virtual void visit(type_definition *) = 0;
virtual void visit(call_statement *) = 0;
virtual void visit(compound_statement *) = 0;
virtual void visit(assign_statement *) = 0;
@ -74,6 +77,7 @@ namespace source
virtual void visit(basic_type_expression *) = 0;
virtual void visit(array_type_expression *) = 0;
virtual void visit(variable_expression *) = 0;
virtual void visit(array_access_expression *) = 0;
virtual void visit(number_literal<std::int32_t> *) = 0;
virtual void visit(number_literal<double> *) = 0;
virtual void visit(number_literal<bool> *) = 0;
@ -89,6 +93,7 @@ namespace source
virtual void visit(declaration *) override;
virtual void visit(constant_definition *definition) override;
virtual void visit(procedure_definition *definition) override;
virtual void visit(type_definition *definition) override;
virtual void visit(call_statement *statement) override;
virtual void visit(compound_statement *statement) override;
virtual void visit(assign_statement *statement) override;
@ -99,8 +104,9 @@ namespace source
virtual void visit(binary_expression *expression) override;
virtual void visit(unary_expression *expression) override;
virtual void visit(basic_type_expression *) override;
virtual void visit(array_type_expression *) override;
virtual void visit(array_type_expression *expression) override;
virtual void visit(variable_expression *) override;
virtual void visit(array_access_expression *expression) override;
virtual void visit(number_literal<std::int32_t> *) override;
virtual void visit(number_literal<double> *) override;
virtual void visit(number_literal<bool> *) override;
@ -358,6 +364,20 @@ namespace source
virtual ~procedure_definition() override;
};
class type_definition : public definition
{
type_expression *m_body;
public:
type_definition(const struct position position, const std::string& identifier,
type_expression *expression);
virtual void accept(parser_visitor *visitor) override;
type_expression& body();
virtual ~type_definition() override;
};
/**
* Call statement.
*/
@ -393,9 +413,49 @@ namespace source
virtual ~compound_statement() override;
};
class designator_expression : public expression
{
public:
virtual variable_expression *is_variable();
virtual array_access_expression *is_array_access();
protected:
designator_expression(const struct position position);
};
class variable_expression : public designator_expression
{
std::string m_name;
public:
variable_expression(const struct position position, const std::string& name);
virtual void accept(parser_visitor *visitor) override;
const std::string& name() const;
variable_expression *is_variable() override;
};
class array_access_expression : public designator_expression
{
designator_expression *m_base;
expression *m_index;
public:
array_access_expression(const struct position position, designator_expression *base, expression *index);
virtual void accept(parser_visitor *visitor) override;
designator_expression& base();
expression& index();
array_access_expression *is_array_access() override;
~array_access_expression() override;
};
class assign_statement : public statement
{
std::string m_lvalue;
designator_expression *m_lvalue;
expression *m_rvalue;
public:
@ -404,11 +464,11 @@ namespace source
* \param lvalue Left-hand side.
* \param rvalue Assigned expression.
*/
assign_statement(const struct position position, const std::string& lvalue,
assign_statement(const struct position position, designator_expression *lvalue,
expression *rvalue);
virtual void accept(parser_visitor *visitor) override;
std::string& lvalue();
designator_expression& lvalue();
expression& rvalue();
virtual ~assign_statement() override;
@ -537,17 +597,6 @@ namespace source
const std::string& string() const;
};
class variable_expression : public expression
{
std::string m_name;
public:
variable_expression(const struct position position, const std::string& name);
virtual void accept(parser_visitor *visitor) override;
const std::string& name() const;
};
class binary_expression : public expression
{
expression *m_lhs;

31
include/elna/source/result.h
View File

@ -69,36 +69,5 @@ namespace source
std::string what() const override;
};
struct type_mismatch final : public error
{
/**
* Kind of the operation on the type.
*/
enum class operation
{
dereference,
argument,
arithmetic,
comparison,
condition,
assignment
};
/**
* \param name Given type.
* \param kind Kind of the operation on the type.
* \param path Source file name.
* \param position Operation position.
*/
type_mismatch(std::shared_ptr<const type> got, operation kind, const char *path,
const struct position position);
std::string what() const override;
private:
std::shared_ptr<const type> got;
operation kind;
};
}
}