From 1f7c1b4cb8062c8cb530e69f950b592631d05861 Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Sat, 25 Jan 2025 19:50:36 +0100 Subject: [PATCH] Support the remainder operator --- example.elna | 108 ++++++++++++++++----------------- gcc/elna-generic.cc | 47 ++++++++------- include/elna/source/ast.h | 54 +++++++---------- include/elna/source/types.h | 116 ------------------------------------ source/ast.cc | 110 +++++++++------------------------- source/lexer.ll | 6 ++ source/parser.yy | 64 +++++++++++++------- source/types.cc | 83 -------------------------- 8 files changed, 172 insertions(+), 416 deletions(-) delete mode 100644 include/elna/source/types.h delete mode 100644 source/types.cc diff --git a/example.elna b/example.elna index 80e2f50..318c87a 100644 --- a/example.elna +++ b/example.elna @@ -15,6 +15,52 @@ type const 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(); var a: T, x: Int; begin @@ -44,31 +90,17 @@ begin end; proc test_primitive(); -var c: Char, z: Float; +var u: Word, z: Float; begin - c := 'x'; + u := 25u; z := 8.2; writei(""); writei("Test primitives:"); - writei(c); + writei(u); writei(z) 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); begin writei(""); @@ -77,14 +109,6 @@ begin writei(e) end; -proc test_const_char(); -const x = 'u'; -begin - writei(""); - writei("Test constant character"); - writei(x) -end; - proc test_return_int(): Int; begin writei(""); @@ -92,35 +116,6 @@ begin return 5 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; var input_file: pointer to FILE, @@ -161,11 +156,10 @@ begin test_primitive(); test_array(); test_record(); - test_if(); test_param(8, 7); - test_const_char(); writei(test_return_int()); - test_add_pointer(); + write_b(true); + write_c('\n'); compile(); diff --git a/gcc/elna-generic.cc b/gcc/elna-generic.cc index b0cfa13..195c9e3 100644 --- a/gcc/elna-generic.cc +++ b/gcc/elna-generic.cc @@ -50,14 +50,6 @@ namespace gcc { 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)) { format_number = "%p\n"; @@ -357,6 +349,10 @@ namespace gcc operator_code = TRUNC_DIV_EXPR; target_type = left_type; break; + case source::binary_operator::remainder: + operator_code = TRUNC_MOD_EXPR; + target_type = left_type; + break; case source::binary_operator::multiplication: operator_code = MULT_EXPR; target_type = left_type; @@ -737,18 +733,18 @@ namespace gcc 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) { - 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", print_type(TREE_TYPE(this->current_expression))); this->current_expression = error_mark_node; return; } - auto then_location = get_location(&statement->body().position()); - auto prerequisite_location = get_location(&statement->prerequisite().position()); + auto then_location = get_location(&statement->position()); + auto prerequisite_location = get_location(&statement->body().prerequisite().position()); auto then_label_decl = build_label_decl("then", 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; 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); 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); 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) { 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); 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); append_to_statement_list(endif_label_expr, &this->current_statements); @@ -808,18 +809,18 @@ namespace gcc 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) { - 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", print_type(TREE_TYPE(this->current_expression))); this->current_expression = error_mark_node; return; } - auto prerequisite_location = get_location(&statement->prerequisite().position()); - auto body_location = get_location(&statement->body().position()); + auto prerequisite_location = get_location(&statement->body().prerequisite().position()); + auto body_location = get_location(&statement->position()); auto prerequisite_label_decl = build_label_decl("while_check", prerequisite_location); auto prerequisite_label_expr = build1_loc(prerequisite_location, LABEL_EXPR, @@ -842,8 +843,10 @@ namespace gcc void_type_node, body_label_decl); 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); append_to_statement_list(goto_check, &this->current_statements); diff --git a/include/elna/source/ast.h b/include/elna/source/ast.h index c3cae7b..8c759c6 100644 --- a/include/elna/source/ast.h +++ b/include/elna/source/ast.h @@ -19,6 +19,7 @@ namespace source subtraction, multiplication, division, + remainder, equals, not_equals, less, @@ -40,7 +41,6 @@ namespace source class procedure_definition; class type_definition; class call_expression; - class compound_statement; class assign_statement; class if_statement; class while_statement; @@ -75,7 +75,6 @@ namespace source virtual void visit(type_definition *) = 0; virtual void visit(call_expression *) = 0; virtual void visit(expression_statement *) = 0; - virtual void visit(compound_statement *) = 0; virtual void visit(assign_statement *) = 0; virtual void visit(if_statement *) = 0; virtual void visit(while_statement *) = 0; @@ -112,7 +111,6 @@ namespace source virtual void visit(type_definition *definition) override; virtual void visit(call_expression *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(if_statement *) override; virtual void visit(while_statement *) override; @@ -484,15 +482,21 @@ namespace source virtual ~expression_statement() override; }; - class compound_statement : public node + /** + * List of statements paired with a condition. + */ + class conditional_statements { + expression *m_prerequisite; + public: std::vector statements; - compound_statement(const struct position position, std::vector&& statements); - virtual void accept(parser_visitor *visitor) override; + conditional_statements(expression *prerequisite); - virtual ~compound_statement() override; + expression& prerequisite(); + + virtual ~conditional_statements(); }; class return_statement : public statement @@ -609,24 +613,16 @@ namespace source */ class if_statement : public statement { - expression *m_prerequisite; - compound_statement *m_body; - compound_statement *m_alternative; + conditional_statements *m_body; + std::vector *m_alternative; public: - /** - * \param position Source code position. - * \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); + if_statement(const struct position position, conditional_statements *body, + std::vector *alternative = nullptr); virtual void accept(parser_visitor *visitor) override; - expression& prerequisite(); - compound_statement& body(); - compound_statement *alternative(); + conditional_statements& body(); + std::vector *alternative(); virtual ~if_statement() override; }; @@ -636,21 +632,13 @@ namespace source */ class while_statement : public statement { - expression *m_prerequisite; - compound_statement *m_body; + conditional_statements *m_body; public: - /** - * \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); + while_statement(const struct position position, conditional_statements *body); virtual void accept(parser_visitor *visitor) override; - expression& prerequisite(); - compound_statement& body(); + conditional_statements& body(); virtual ~while_statement() override; }; @@ -721,7 +709,7 @@ namespace source public: 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; expression& lhs(); diff --git a/include/elna/source/types.h b/include/elna/source/types.h deleted file mode 100644 index 40792f9..0000000 --- a/include/elna/source/types.h +++ /dev/null @@ -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 -#include -#include - -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 base_type; - - /** - * Constructor. - * - * \param base_type Pointer target type. - * \param byte_size The type size in bytes. - */ - pointer_type(std::shared_ptr 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> arguments; - - /** - * Constructor. - * - * \param arguments Argument types. - * \param byte_size Function pointer size. - */ - procedure_type(std::vector> 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; -} -} diff --git a/source/ast.cc b/source/ast.cc index 13388ee..385c5f8 100644 --- a/source/ast.cc +++ b/source/ast.cc @@ -46,14 +46,6 @@ namespace source 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) { statement->rvalue().accept(this); @@ -61,14 +53,20 @@ namespace source void empty_visitor::visit(if_statement *statement) { - statement->prerequisite().accept(this); - statement->body().accept(this); + statement->body().prerequisite().accept(this); + for (const auto body_statement : statement->body().statements) + { + body_statement->accept(this); + } } void empty_visitor::visit(while_statement *statement) { - statement->prerequisite().accept(this); - statement->body().accept(this); + statement->body().prerequisite().accept(this); + for (const auto body_statement : statement->body().statements) + { + body_statement->accept(this); + } } void empty_visitor::visit(return_statement *statement) @@ -683,50 +681,9 @@ namespace source } binary_expression::binary_expression(const struct position position, expression *lhs, - expression *rhs, const unsigned char operation) - : expression(position), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) + expression *rhs, const binary_operator operation) + : 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) @@ -829,18 +786,19 @@ namespace source delete m_body; } - compound_statement::compound_statement(const struct position position, std::vector&& statements) - : node(position), statements(std::move(statements)) + conditional_statements::conditional_statements(expression *prerequisite) + : 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) { delete statement; @@ -916,10 +874,9 @@ namespace source delete m_rvalue; } - if_statement::if_statement(const struct position position, expression *prerequisite, - compound_statement *body, compound_statement *alternative) - : statement(position), m_prerequisite(prerequisite), m_body(body), - m_alternative(alternative) + if_statement::if_statement(const struct position position, conditional_statements *body, + std::vector *alternative) + : statement(position), m_body(body), m_alternative(alternative) { } @@ -928,24 +885,18 @@ namespace source visitor->visit(this); } - expression& if_statement::prerequisite() - { - return *m_prerequisite; - } - - compound_statement& if_statement::body() + conditional_statements& if_statement::body() { return *m_body; } - compound_statement *if_statement::alternative() + std::vector *if_statement::alternative() { return m_alternative; } if_statement::~if_statement() { - delete m_prerequisite; delete m_body; if (m_alternative != nullptr) @@ -954,9 +905,8 @@ namespace source } } - while_statement::while_statement(const struct position position, expression *prerequisite, - compound_statement *body) - : statement(position), m_prerequisite(prerequisite), m_body(body) + while_statement::while_statement(const struct position position, conditional_statements *body) + : statement(position), m_body(body) { } @@ -965,19 +915,13 @@ namespace source visitor->visit(this); } - expression& while_statement::prerequisite() - { - return *m_prerequisite; - } - - compound_statement& while_statement::body() + conditional_statements& while_statement::body() { return *m_body; } while_statement::~while_statement() { - delete m_prerequisite; delete m_body; } @@ -993,6 +937,8 @@ namespace source return "*"; case binary_operator::division: return "/"; + case binary_operator::remainder: + return "%"; case binary_operator::equals: return "="; case binary_operator::not_equals: diff --git a/source/lexer.ll b/source/lexer.ll index c056d94..877660a 100644 --- a/source/lexer.ll +++ b/source/lexer.ll @@ -40,6 +40,9 @@ then { else { return yy::parser::make_ELSE(this->location); } +elsif { + return yy::parser::make_ELSIF(this->location); + } while { return yy::parser::make_WHILE(this->location); } @@ -237,6 +240,9 @@ return { \/ { return yy::parser::make_DIVISION(this->location); } +% { + return yy::parser::make_REMAINDER(this->location); + } := { return yy::parser::make_ASSIGNMENT(this->location); } diff --git a/source/parser.yy b/source/parser.yy index e7aa924..bbda45f 100644 --- a/source/parser.yy +++ b/source/parser.yy @@ -63,13 +63,13 @@ %token CHARACTER "character" %token STRING "string" %token 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 BEGIN_BLOCK END_BLOCK EXTERN %token LEFT_PAREN RIGHT_PAREN LEFT_SQUARE RIGHT_SQUARE SEMICOLON DOT COMMA %token AND OR NOT %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 %type literal; @@ -184,20 +184,23 @@ call_expression: IDENTIFIER actual_parameter_list } while_statement: WHILE expression DO optional_statements END_BLOCK { - auto body = new elna::source::compound_statement(elna::source::make_position(@3), std::move($4)); - $$ = new elna::source::while_statement(elna::source::make_position(@1), $2, body); + auto body = new elna::source::conditional_statements($2); + std::swap($4, body->statements); + $$ = new elna::source::while_statement(elna::source::make_position(@1), body); } if_statement: IF expression THEN optional_statements END_BLOCK { - auto then = new elna::source::compound_statement(elna::source::make_position(@3), std::move($4)); - $$ = new elna::source::if_statement(elna::source::make_position(@1), $2, then); + auto then = new elna::source::conditional_statements($2); + 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 { - auto then = new elna::source::compound_statement(elna::source::make_position(@3), std::move($4)); - auto _else = new elna::source::compound_statement(elna::source::make_position(@5), std::move($6)); - $$ = new elna::source::if_statement(elna::source::make_position(@1), $2, then, _else); + auto then = new elna::source::conditional_statements($2); + std::swap($4, then->statements); + auto _else = new std::vector(std::move($6)); + $$ = new elna::source::if_statement(elna::source::make_position(@1), then, _else); } return_statement: RETURN expression @@ -238,13 +241,18 @@ summand: factor { $$ = std::move($1); } | factor MULTIPLICATION factor { - $$ = 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::multiplication); } | factor DIVISION factor { - $$ = 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::division); + } + | factor REMAINDER factor + { + $$ = new elna::source::binary_expression(elna::source::make_position(@2), $1, $3, + elna::source::binary_operator::remainder); } factor: AT pointer @@ -261,47 +269,57 @@ factor: comparand: 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 { - $$ = 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); } logical_operand: 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 { - $$ = 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 { - $$ = 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 { - $$ = 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 { - $$ = 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 { - $$ = 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; } expression: 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 { - $$ = 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; } expressions: diff --git a/source/types.cc b/source/types.cc deleted file mode 100644 index 993a38c..0000000 --- a/source/types.cc +++ /dev/null @@ -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 - -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 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> 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 }; -} -}