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

Support the remainder operator

Browse Source
This commit is contained in:
Eugen Wissner 2025-01-25 19:50:36 +01:00
parent 005e9dcc52
commit 1f7c1b4cb8
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
8 changed files with 172 additions and 416 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
example.elna
View File

@ -15,6 +15,52 @@ type
const const
SEEK_SET = 0, SEEK_CUR = 1, SEEK_END = 2; SEEK_SET = 0, SEEK_CUR = 1, SEEK_END = 2;
--
-- External procedures.
--
proc fopen(pathname: String, mode: String): pointer to FILE; extern;
proc fclose(stream: pointer to FILE): Int; extern;
proc fseek(stream: pointer to FILE, off: Int, whence: Int): Int; extern;
proc ftell(stream: pointer to FILE): Int; extern;
proc fread(ptr: pointer to Char, size: Int, nmemb: Int, stream: pointer to FILE): Int; extern;
proc write(fd: Int, buf: pointer to Char, count: Int): Int; extern;
proc malloc(size: Int): pointer to Char; extern;
proc free(ptr: pointer to Char); extern;
proc calloc(nmemb: Int, size: Int): pointer to Char; extern;
proc memset(ptr: pointer to Char, c: Int, n: Int): pointer to Char; extern;
proc strlen(ptr: pointer to Char): Word; extern;
proc exit(code: Int); extern;
--
-- Standard procedures.
--
proc write_s(value: String);
begin
write(0, value, strlen(value))
end;
proc write_b(value: Bool);
begin
if value then
write_s("true")
else
write_s("false")
end
end;
proc write_c(value: Char);
begin
write(0, @value, 1)
end;
--
-- End of standard procedures.
--
proc test_array(); proc test_array();
var a: T, x: Int; var a: T, x: Int;
begin begin
@ -44,31 +90,17 @@ begin
end; end;
proc test_primitive(); proc test_primitive();
var c: Char, z: Float; var u: Word, z: Float;
begin begin
c := 'x'; u := 25u;
z := 8.2; z := 8.2;
writei(""); writei("");
writei("Test primitives:"); writei("Test primitives:");
writei(c); writei(u);
writei(z) writei(z)
end; end;
proc test_if();
var x: Bool, y: Bool;
begin
x := true;
y := false;
writei("");
if x and y then
writei("Test if: True")
else
writei("Test if: False")
end
end;
proc test_param(d: Int, e: Int); proc test_param(d: Int, e: Int);
begin begin
writei(""); writei("");
@ -77,14 +109,6 @@ begin
writei(e) writei(e)
end; end;
proc test_const_char();
const x = 'u';
begin
writei("");
writei("Test constant character");
writei(x)
end;
proc test_return_int(): Int; proc test_return_int(): Int;
begin begin
writei(""); writei("");
@ -92,35 +116,6 @@ begin
return 5 return 5
end; end;
proc exit(code: Int); extern;
proc test_add_pointer();
var x: Int, p1: pointer to Int;
begin
writei("");
writei("Test add pointer:");
x := 5;
p1 := @x;
writei(p1);
p1 := p1 + 2;
writei(p1)
end;
proc fopen(pathname: String, mode: String): pointer to FILE; extern;
proc fclose(stream: pointer to FILE): Int; extern;
proc fseek(stream: pointer to FILE, off: Int, whence: Int): Int; extern;
proc ftell(stream: pointer to FILE): Int; extern;
proc fread(ptr: pointer to Char, size: Int, nmemb: Int, stream: pointer to FILE): Int; extern;
proc write(fd: Int, buf: pointer to Char, count: Int): Int; extern;
proc malloc(size: Int): pointer to Char; extern;
proc free(ptr: pointer to Char); extern;
proc calloc(nmemb: Int, size: Int): pointer to Char; extern;
proc memset(ptr: pointer to Char, c: Int, n: Int): pointer to Char; extern;
proc read_source(filename: String): pointer to Char; proc read_source(filename: String): pointer to Char;
var var
input_file: pointer to FILE, input_file: pointer to FILE,
@ -161,11 +156,10 @@ begin
test_primitive(); test_primitive();
test_array(); test_array();
test_record(); test_record();
test_if();
test_param(8, 7); test_param(8, 7);
test_const_char();
writei(test_return_int()); writei(test_return_int());
test_add_pointer(); write_b(true);
write_c('\n');
compile(); compile();

47
gcc/elna-generic.cc
View File

@ -50,14 +50,6 @@ namespace gcc
{ {
format_number = "%f\n"; format_number = "%f\n";
} }
else if (argument_type == elna_char_type_node)
{
format_number = "%c\n";
}
else if (is_string_type(argument_type))
{
format_number = "%s\n";
}
else if (is_pointer_type(argument_type)) else if (is_pointer_type(argument_type))
{ {
format_number = "%p\n"; format_number = "%p\n";
@ -357,6 +349,10 @@ namespace gcc
operator_code = TRUNC_DIV_EXPR; operator_code = TRUNC_DIV_EXPR;
target_type = left_type; target_type = left_type;
break; break;
case source::binary_operator::remainder:
operator_code = TRUNC_MOD_EXPR;
target_type = left_type;
break;
case source::binary_operator::multiplication: case source::binary_operator::multiplication:
operator_code = MULT_EXPR; operator_code = MULT_EXPR;
target_type = left_type; target_type = left_type;
@ -737,18 +733,18 @@ namespace gcc
void generic_visitor::visit(source::if_statement *statement) void generic_visitor::visit(source::if_statement *statement)
{ {
statement->prerequisite().accept(this); statement->body().prerequisite().accept(this);
if (TREE_TYPE(this->current_expression) != boolean_type_node) if (TREE_TYPE(this->current_expression) != boolean_type_node)
{ {
error_at(get_location(&statement->prerequisite().position()), error_at(get_location(&statement->body().prerequisite().position()),
"expected expression of boolean type but its type is %s", "expected expression of boolean type but its type is %s",
print_type(TREE_TYPE(this->current_expression))); print_type(TREE_TYPE(this->current_expression)));
this->current_expression = error_mark_node; this->current_expression = error_mark_node;
return; return;
} }
auto then_location = get_location(&statement->body().position()); auto then_location = get_location(&statement->position());
auto prerequisite_location = get_location(&statement->prerequisite().position()); auto prerequisite_location = get_location(&statement->body().prerequisite().position());
auto then_label_decl = build_label_decl("then", then_location); auto then_label_decl = build_label_decl("then", then_location);
auto endif_label_decl = build_label_decl("end_if", then_location); auto endif_label_decl = build_label_decl("end_if", then_location);
@ -762,7 +758,7 @@ namespace gcc
tree goto_else_or_endif = NULL_TREE; tree goto_else_or_endif = NULL_TREE;
if (statement->alternative() != nullptr) if (statement->alternative() != nullptr)
{ {
auto else_location = get_location(&statement->alternative()->position()); auto else_location = get_location(&statement->position());
else_label_decl = build_label_decl("else", else_location); else_label_decl = build_label_decl("else", else_location);
goto_else_or_endif = build1_loc(else_location, GOTO_EXPR, void_type_node, else_label_decl); goto_else_or_endif = build1_loc(else_location, GOTO_EXPR, void_type_node, else_label_decl);
} }
@ -779,8 +775,10 @@ namespace gcc
void_type_node, then_label_decl); void_type_node, then_label_decl);
append_to_statement_list(then_label_expr, &this->current_statements); append_to_statement_list(then_label_expr, &this->current_statements);
statement->body().accept(this); for (const auto body_statement : statement->body().statements)
{
body_statement->accept(this);
}
if (statement->alternative() != nullptr) if (statement->alternative() != nullptr)
{ {
append_to_statement_list(goto_endif, &this->current_statements); append_to_statement_list(goto_endif, &this->current_statements);
@ -788,7 +786,10 @@ namespace gcc
auto else_label_expr = build1(LABEL_EXPR, void_type_node, else_label_decl); auto else_label_expr = build1(LABEL_EXPR, void_type_node, else_label_decl);
append_to_statement_list(else_label_expr, &this->current_statements); append_to_statement_list(else_label_expr, &this->current_statements);
statement->alternative()->accept(this); for (const auto body_statement : *statement->alternative())
{
body_statement->accept(this);
}
} }
auto endif_label_expr = build1(LABEL_EXPR, void_type_node, endif_label_decl); auto endif_label_expr = build1(LABEL_EXPR, void_type_node, endif_label_decl);
append_to_statement_list(endif_label_expr, &this->current_statements); append_to_statement_list(endif_label_expr, &this->current_statements);
@ -808,18 +809,18 @@ namespace gcc
void generic_visitor::visit(source::while_statement *statement) void generic_visitor::visit(source::while_statement *statement)
{ {
statement->prerequisite().accept(this); statement->body().prerequisite().accept(this);
if (TREE_TYPE(this->current_expression) != boolean_type_node) if (TREE_TYPE(this->current_expression) != boolean_type_node)
{ {
error_at(get_location(&statement->prerequisite().position()), error_at(get_location(&statement->body().prerequisite().position()),
"expected expression of boolean type but its type is %s", "expected expression of boolean type but its type is %s",
print_type(TREE_TYPE(this->current_expression))); print_type(TREE_TYPE(this->current_expression)));
this->current_expression = error_mark_node; this->current_expression = error_mark_node;
return; return;
} }
auto prerequisite_location = get_location(&statement->prerequisite().position()); auto prerequisite_location = get_location(&statement->body().prerequisite().position());
auto body_location = get_location(&statement->body().position()); auto body_location = get_location(&statement->position());
auto prerequisite_label_decl = build_label_decl("while_check", prerequisite_location); auto prerequisite_label_decl = build_label_decl("while_check", prerequisite_location);
auto prerequisite_label_expr = build1_loc(prerequisite_location, LABEL_EXPR, auto prerequisite_label_expr = build1_loc(prerequisite_location, LABEL_EXPR,
@ -842,8 +843,10 @@ namespace gcc
void_type_node, body_label_decl); void_type_node, body_label_decl);
append_to_statement_list(body_label_expr, &this->current_statements); append_to_statement_list(body_label_expr, &this->current_statements);
statement->body().accept(this); for (const auto body_statement : statement->body().statements)
{
body_statement->accept(this);
}
auto goto_check = build1(GOTO_EXPR, void_type_node, prerequisite_label_decl); auto goto_check = build1(GOTO_EXPR, void_type_node, prerequisite_label_decl);
append_to_statement_list(goto_check, &this->current_statements); append_to_statement_list(goto_check, &this->current_statements);

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

@ -19,6 +19,7 @@ namespace source
subtraction, subtraction,
multiplication, multiplication,
division, division,
remainder,
equals, equals,
not_equals, not_equals,
less, less,
@ -40,7 +41,6 @@ namespace source
class procedure_definition; class procedure_definition;
class type_definition; class type_definition;
class call_expression; class call_expression;
class compound_statement;
class assign_statement; class assign_statement;
class if_statement; class if_statement;
class while_statement; class while_statement;
@ -75,7 +75,6 @@ namespace source
virtual void visit(type_definition *) = 0; virtual void visit(type_definition *) = 0;
virtual void visit(call_expression *) = 0; virtual void visit(call_expression *) = 0;
virtual void visit(expression_statement *) = 0; virtual void visit(expression_statement *) = 0;
virtual void visit(compound_statement *) = 0;
virtual void visit(assign_statement *) = 0; virtual void visit(assign_statement *) = 0;
virtual void visit(if_statement *) = 0; virtual void visit(if_statement *) = 0;
virtual void visit(while_statement *) = 0; virtual void visit(while_statement *) = 0;
@ -112,7 +111,6 @@ namespace source
virtual void visit(type_definition *definition) override; virtual void visit(type_definition *definition) override;
virtual void visit(call_expression *statement) override; virtual void visit(call_expression *statement) override;
virtual void visit(expression_statement *statement) override; virtual void visit(expression_statement *statement) override;
virtual void visit(compound_statement *statement) override;
virtual void visit(assign_statement *statement) override; virtual void visit(assign_statement *statement) override;
virtual void visit(if_statement *) override; virtual void visit(if_statement *) override;
virtual void visit(while_statement *) override; virtual void visit(while_statement *) override;
@ -484,15 +482,21 @@ namespace source
virtual ~expression_statement() override; virtual ~expression_statement() override;
}; };
class compound_statement : public node /**
* List of statements paired with a condition.
*/
class conditional_statements
{ {
expression *m_prerequisite;
public: public:
std::vector<statement *> statements; std::vector<statement *> statements;
compound_statement(const struct position position, std::vector<statement *>&& statements); conditional_statements(expression *prerequisite);
virtual void accept(parser_visitor *visitor) override;
virtual ~compound_statement() override; expression& prerequisite();
virtual ~conditional_statements();
}; };
class return_statement : public statement class return_statement : public statement
@ -609,24 +613,16 @@ namespace source
*/ */
class if_statement : public statement class if_statement : public statement
{ {
expression *m_prerequisite; conditional_statements *m_body;
compound_statement *m_body; std::vector<statement *> *m_alternative;
compound_statement *m_alternative;
public: public:
/** if_statement(const struct position position, conditional_statements *body,
* \param position Source code position. std::vector<statement *> *alternative = nullptr);
* \param prerequisite Condition.
* \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, expression *prerequisite,
compound_statement *body, compound_statement *alternative = nullptr);
virtual void accept(parser_visitor *visitor) override; virtual void accept(parser_visitor *visitor) override;
expression& prerequisite(); conditional_statements& body();
compound_statement& body(); std::vector<statement *> *alternative();
compound_statement *alternative();
virtual ~if_statement() override; virtual ~if_statement() override;
}; };
@ -636,21 +632,13 @@ namespace source
*/ */
class while_statement : public statement class while_statement : public statement
{ {
expression *m_prerequisite; conditional_statements *m_body;
compound_statement *m_body;
public: public:
/** while_statement(const struct position position, conditional_statements *body);
* \param position Source code position.
* \param prerequisite Condition.
* \param body Statement executed while the condition is met.
*/
while_statement(const struct position position, expression *prerequisite,
compound_statement *body);
virtual void accept(parser_visitor *visitor) override; virtual void accept(parser_visitor *visitor) override;
expression& prerequisite(); conditional_statements& body();
compound_statement& body();
virtual ~while_statement() override; virtual ~while_statement() override;
}; };
@ -721,7 +709,7 @@ namespace source
public: public:
binary_expression(const struct position position, expression *lhs, binary_expression(const struct position position, expression *lhs,
expression *rhs, const unsigned char operation); expression *rhs, const binary_operator operation);
virtual void accept(parser_visitor *visitor) override; virtual void accept(parser_visitor *visitor) override;
expression& lhs(); expression& lhs();

116
include/elna/source/types.h
View File

@ -1,116 +0,0 @@
// 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/.
#pragma once
#include <memory>
#include <string>
#include <vector>
namespace elna
{
namespace source
{
class primitive_type;
class pointer_type;
class procedure_type;
/**
* Type representation.
*/
class type
{
const std::size_t byte_size;
protected:
/**
* Constructor.
*
* \param byte_size The type size in bytes.
*/
explicit type(const std::size_t byte_size);
public:
/**
* \return The type size in bytes.
*/
virtual std::size_t size() const noexcept;
/**
* \return Unique type representation.
*/
virtual std::string type_name() const = 0;
virtual const pointer_type *is_pointer_type() const;
friend bool operator==(const type& lhs, const type& rhs) noexcept;
friend bool operator!=(const type& lhs, const type& rhs) noexcept;
};
/**
* Built-in type representation.
*/
class primitive_type final : public type
{
/// Type name.
const std::string m_type_name;
public:
/**
* Constructor.
*
* \param type_name Type name.
* \param byte_size The type size in bytes.
*/
primitive_type(const std::string& type_name, const std::size_t byte_size);
virtual std::string type_name() const override;
};
/**
* Typed pointer.
*/
struct pointer_type final : public type
{
/// Pointer target type.
std::shared_ptr<const type> base_type;
/**
* Constructor.
*
* \param base_type Pointer target type.
* \param byte_size The type size in bytes.
*/
pointer_type(std::shared_ptr<const type> base_type, const std::size_t byte_size);
virtual std::string type_name() const override;
virtual const pointer_type *is_pointer_type() const override;
};
/**
* Type of a procedure.
*/
struct procedure_type final : public type
{
/// Argument types.
std::vector<std::shared_ptr<const type>> arguments;
/**
* Constructor.
*
* \param arguments Argument types.
* \param byte_size Function pointer size.
*/
procedure_type(std::vector<std::shared_ptr<const type>> arguments, const std::size_t byte_size);
virtual std::string type_name() const override;
};
bool operator==(const type& lhs, const type& rhs) noexcept;
bool operator!=(const type& lhs, const type& rhs) noexcept;
extern const primitive_type boolean_type;
extern const primitive_type int_type;
}
}

110
source/ast.cc
View File

@ -46,14 +46,6 @@ namespace source
statement->body().accept(this); statement->body().accept(this);
} }
void empty_visitor::visit(compound_statement *statement)
{
for (const auto nested_statement : statement->statements)
{
nested_statement->accept(this);
}
}
void empty_visitor::visit(assign_statement *statement) void empty_visitor::visit(assign_statement *statement)
{ {
statement->rvalue().accept(this); statement->rvalue().accept(this);
@ -61,14 +53,20 @@ namespace source
void empty_visitor::visit(if_statement *statement) void empty_visitor::visit(if_statement *statement)
{ {
statement->prerequisite().accept(this); statement->body().prerequisite().accept(this);
statement->body().accept(this); for (const auto body_statement : statement->body().statements)
{
body_statement->accept(this);
}
} }
void empty_visitor::visit(while_statement *statement) void empty_visitor::visit(while_statement *statement)
{ {
statement->prerequisite().accept(this); statement->body().prerequisite().accept(this);
statement->body().accept(this); for (const auto body_statement : statement->body().statements)
{
body_statement->accept(this);
}
} }
void empty_visitor::visit(return_statement *statement) void empty_visitor::visit(return_statement *statement)
@ -683,50 +681,9 @@ namespace source
} }
binary_expression::binary_expression(const struct position position, expression *lhs, binary_expression::binary_expression(const struct position position, expression *lhs,
expression *rhs, const unsigned char operation) expression *rhs, const binary_operator operation)
: expression(position), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) : expression(position), m_lhs(lhs), m_rhs(rhs), m_operator(operation)
{ {
switch (operation)
{
case '+':
this->m_operator = binary_operator::sum;
break;
case '-':
this->m_operator = binary_operator::subtraction;
break;
case '*':
this->m_operator = binary_operator::multiplication;
break;
case '/':
this->m_operator = binary_operator::division;
break;
case '=':
this->m_operator = binary_operator::equals;
break;
case 'n':
this->m_operator = binary_operator::not_equals;
break;
case '<':
this->m_operator = binary_operator::less;
break;
case 'l':
this->m_operator = binary_operator::less_equal;
break;
case '>':
this->m_operator = binary_operator::greater;
break;
case 'g':
this->m_operator = binary_operator::greater_equal;
break;
case 'o':
this->m_operator = binary_operator::disjunction;
break;
case 'a':
this->m_operator = binary_operator::conjunction;
break;
default:
__builtin_unreachable();
}
} }
void binary_expression::accept(parser_visitor *visitor) void binary_expression::accept(parser_visitor *visitor)
@ -829,18 +786,19 @@ namespace source
delete m_body; delete m_body;
} }
compound_statement::compound_statement(const struct position position, std::vector<statement *>&& statements) conditional_statements::conditional_statements(expression *prerequisite)
: node(position), statements(std::move(statements)) : m_prerequisite(prerequisite)
{ {
} }
void compound_statement::accept(parser_visitor *visitor) expression& conditional_statements::prerequisite()
{ {
visitor->visit(this); return *m_prerequisite;
} }
compound_statement::~compound_statement() conditional_statements::~conditional_statements()
{ {
delete m_prerequisite;
for (auto statement : statements) for (auto statement : statements)
{ {
delete statement; delete statement;
@ -916,10 +874,9 @@ namespace source
delete m_rvalue; delete m_rvalue;
} }
if_statement::if_statement(const struct position position, expression *prerequisite, if_statement::if_statement(const struct position position, conditional_statements *body,
compound_statement *body, compound_statement *alternative) std::vector<statement *> *alternative)
: statement(position), m_prerequisite(prerequisite), m_body(body), : statement(position), m_body(body), m_alternative(alternative)
m_alternative(alternative)
{ {
} }
@ -928,24 +885,18 @@ namespace source
visitor->visit(this); visitor->visit(this);
} }
expression& if_statement::prerequisite() conditional_statements& if_statement::body()
{
return *m_prerequisite;
}
compound_statement& if_statement::body()
{ {
return *m_body; return *m_body;
} }
compound_statement *if_statement::alternative() std::vector<statement *> *if_statement::alternative()
{ {
return m_alternative; return m_alternative;
} }
if_statement::~if_statement() if_statement::~if_statement()
{ {
delete m_prerequisite;
delete m_body; delete m_body;
if (m_alternative != nullptr) if (m_alternative != nullptr)
@ -954,9 +905,8 @@ namespace source
} }
} }
while_statement::while_statement(const struct position position, expression *prerequisite, while_statement::while_statement(const struct position position, conditional_statements *body)
compound_statement *body) : statement(position), m_body(body)
: statement(position), m_prerequisite(prerequisite), m_body(body)
{ {
} }
@ -965,19 +915,13 @@ namespace source
visitor->visit(this); visitor->visit(this);
} }
expression& while_statement::prerequisite() conditional_statements& while_statement::body()
{
return *m_prerequisite;
}
compound_statement& while_statement::body()
{ {
return *m_body; return *m_body;
} }
while_statement::~while_statement() while_statement::~while_statement()
{ {
delete m_prerequisite;
delete m_body; delete m_body;
} }
@ -993,6 +937,8 @@ namespace source
return "*"; return "*";
case binary_operator::division: case binary_operator::division:
return "/"; return "/";
case binary_operator::remainder:
return "%";
case binary_operator::equals: case binary_operator::equals:
return "="; return "=";
case binary_operator::not_equals: case binary_operator::not_equals:

6
source/lexer.ll
View File

@ -40,6 +40,9 @@ then {
else { else {
return yy::parser::make_ELSE(this->location); return yy::parser::make_ELSE(this->location);
} }
elsif {
return yy::parser::make_ELSIF(this->location);
}
while { while {
return yy::parser::make_WHILE(this->location); return yy::parser::make_WHILE(this->location);
} }
@ -237,6 +240,9 @@ return {
\/ { \/ {
return yy::parser::make_DIVISION(this->location); return yy::parser::make_DIVISION(this->location);
} }
% {
return yy::parser::make_REMAINDER(this->location);
}
:= { := {
return yy::parser::make_ASSIGNMENT(this->location); return yy::parser::make_ASSIGNMENT(this->location);
} }

64
source/parser.yy
View File

@ -63,13 +63,13 @@
%token <std::string> CHARACTER "character" %token <std::string> CHARACTER "character"
%token <std::string> STRING "string" %token <std::string> STRING "string"
%token <bool> BOOLEAN %token <bool> BOOLEAN
%token IF WHILE DO THEN ELSE RETURN %token IF WHILE DO THEN ELSE ELSIF RETURN
%token CONST VAR PROCEDURE ARRAY OF TYPE RECORD POINTER TO UNION %token CONST VAR PROCEDURE ARRAY OF TYPE RECORD POINTER TO UNION
%token BEGIN_BLOCK END_BLOCK EXTERN %token BEGIN_BLOCK END_BLOCK EXTERN
%token LEFT_PAREN RIGHT_PAREN LEFT_SQUARE RIGHT_SQUARE SEMICOLON DOT COMMA %token LEFT_PAREN RIGHT_PAREN LEFT_SQUARE RIGHT_SQUARE SEMICOLON DOT COMMA
%token AND OR NOT %token AND OR NOT
%token GREATER_EQUAL LESS_EQUAL LESS_THAN GREATER_THAN NOT_EQUAL EQUALS %token GREATER_EQUAL LESS_EQUAL LESS_THAN GREATER_THAN NOT_EQUAL EQUALS
%token PLUS MINUS MULTIPLICATION DIVISION %token PLUS MINUS MULTIPLICATION DIVISION REMAINDER
%token ASSIGNMENT COLON HAT AT %token ASSIGNMENT COLON HAT AT
%type <elna::source::literal *> literal; %type <elna::source::literal *> literal;
@ -184,20 +184,23 @@ call_expression: IDENTIFIER actual_parameter_list
} }
while_statement: WHILE expression DO optional_statements END_BLOCK while_statement: WHILE expression DO optional_statements END_BLOCK
{ {
auto body = new elna::source::compound_statement(elna::source::make_position(@3), std::move($4)); auto body = new elna::source::conditional_statements($2);
$$ = new elna::source::while_statement(elna::source::make_position(@1), $2, body); std::swap($4, body->statements);
$$ = new elna::source::while_statement(elna::source::make_position(@1), body);
} }
if_statement: if_statement:
IF expression THEN optional_statements END_BLOCK IF expression THEN optional_statements END_BLOCK
{ {
auto then = new elna::source::compound_statement(elna::source::make_position(@3), std::move($4)); auto then = new elna::source::conditional_statements($2);
$$ = new elna::source::if_statement(elna::source::make_position(@1), $2, then); std::swap($4, then->statements);
$$ = new elna::source::if_statement(elna::source::make_position(@1), then);
} }
| IF expression THEN optional_statements ELSE optional_statements END_BLOCK | IF expression THEN optional_statements ELSE optional_statements END_BLOCK
{ {
auto then = new elna::source::compound_statement(elna::source::make_position(@3), std::move($4)); auto then = new elna::source::conditional_statements($2);
auto _else = new elna::source::compound_statement(elna::source::make_position(@5), std::move($6)); std::swap($4, then->statements);
$$ = new elna::source::if_statement(elna::source::make_position(@1), $2, then, _else); auto _else = new std::vector<elna::source::statement *>(std::move($6));
$$ = new elna::source::if_statement(elna::source::make_position(@1), then, _else);
} }
return_statement: return_statement:
RETURN expression RETURN expression
@ -238,13 +241,18 @@ summand:
factor { $$ = std::move($1); } factor { $$ = std::move($1); }
| factor MULTIPLICATION factor | factor MULTIPLICATION factor
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
$1, $3, '*'); elna::source::binary_operator::multiplication);
} }
| factor DIVISION factor | factor DIVISION factor
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
$1, $3, '/'); elna::source::binary_operator::division);
}
| factor REMAINDER factor
{
$$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::remainder);
} }
factor: factor:
AT pointer AT pointer
@ -261,47 +269,57 @@ factor:
comparand: comparand:
summand PLUS summand summand PLUS summand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, '+'); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::sum);
} }
| summand MINUS summand | summand MINUS summand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, '-'); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::subtraction);
} }
| summand { $$ = std::move($1); } | summand { $$ = std::move($1); }
logical_operand: logical_operand:
comparand EQUALS comparand comparand EQUALS comparand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, '='); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::equals);
} }
| comparand NOT_EQUAL comparand | comparand NOT_EQUAL comparand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, 'n'); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::not_equals);
} }
| comparand LESS_THAN comparand | comparand LESS_THAN comparand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, '<'); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::less);
} }
| comparand GREATER_THAN comparand | comparand GREATER_THAN comparand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, '>'); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::greater);
} }
| comparand LESS_EQUAL comparand | comparand LESS_EQUAL comparand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, '<'); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::less_equal);
} }
| comparand GREATER_EQUAL comparand | comparand GREATER_EQUAL comparand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, '>'); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::greater_equal);
} }
| comparand { $$ = $1; } | comparand { $$ = $1; }
expression: expression:
logical_operand AND logical_operand logical_operand AND logical_operand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, 'a'); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::conjunction);
} }
| logical_operand OR logical_operand | logical_operand OR logical_operand
{ {
$$ = new elna::source::binary_expression(elna::source::make_position(@1), $1, $3, 'o'); $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3,
elna::source::binary_operator::disjunction);
} }
| logical_operand { $$ = $1; } | logical_operand { $$ = $1; }
expressions: expressions:

83
source/types.cc
View File

@ -1,83 +0,0 @@
// 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/source/types.h>
namespace elna
{
namespace source
{
type::type(const std::size_t byte_size)
: byte_size(byte_size)
{
}
std::size_t type::size() const noexcept
{
return this->byte_size;
}
const pointer_type *type::is_pointer_type() const
{
return nullptr;
}
primitive_type::primitive_type(const std::string& type_name, const std::size_t byte_size)
: type(byte_size), m_type_name(type_name)
{
}
std::string primitive_type::type_name() const
{
return m_type_name;
}
pointer_type::pointer_type(std::shared_ptr<const type> base_type, const std::size_t byte_size)
: type(byte_size), base_type(base_type)
{
}
const pointer_type *pointer_type::is_pointer_type() const
{
return this;
}
std::string pointer_type::type_name() const
{
return '^' + base_type->type_name();
}
procedure_type::procedure_type(std::vector<std::shared_ptr<const type>> arguments, const std::size_t byte_size)
:type(byte_size), arguments(std::move(arguments))
{
}
std::string procedure_type::type_name() const
{
std::string result{ "proc(" };
for (const auto& argument : arguments)
{
result += argument->type_name() + ',';
}
result.at(result.size() - 1) = ')';
return result;
}
bool operator==(const type& lhs, const type& rhs) noexcept
{
auto lhs_type = lhs.type_name();
auto rhs_type = rhs.type_name();
return lhs_type == rhs_type;
}
bool operator!=(const type& lhs, const type& rhs) noexcept
{
return !(lhs == rhs);
}
const primitive_type boolean_type{ "Boolean", 1 };
const primitive_type int_type{ "Int", 4 };
}
}