diff options
Diffstat (limited to 'frontend')
| -rw-r--r-- | frontend/ast.cc | 1178 | ||||
| -rw-r--r-- | frontend/driver.cc | 124 | ||||
| -rw-r--r-- | frontend/lexer.ll | 320 | ||||
| -rw-r--r-- | frontend/parser.yy | 594 | ||||
| -rw-r--r-- | frontend/result.cc | 67 | ||||
| -rw-r--r-- | frontend/symbol.cc | 427 |
6 files changed, 0 insertions, 2710 deletions
diff --git a/frontend/ast.cc b/frontend/ast.cc deleted file mode 100644 index e067937..0000000 --- a/frontend/ast.cc +++ /dev/null @@ -1,1178 +0,0 @@ -/* Abstract syntax tree representation. - Copyright (C) 2025 Free Software Foundation, Inc. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 3, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -#include "elna/frontend/ast.h" - -namespace elna::frontend -{ - void empty_visitor::not_implemented() - { - __builtin_unreachable(); - } - - void empty_visitor::visit(named_type_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(array_type_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(pointer_type_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(program *) - { - not_implemented(); - } - - void empty_visitor::visit(type_declaration *) - { - not_implemented(); - } - - void empty_visitor::visit(record_type_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(union_type_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(procedure_type_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(enumeration_type_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(variable_declaration *) - { - not_implemented(); - } - - void empty_visitor::visit(constant_declaration *) - { - not_implemented(); - } - - void empty_visitor::visit(procedure_declaration *) - { - not_implemented(); - } - - void empty_visitor::visit(assign_statement *) - { - not_implemented(); - } - - void empty_visitor::visit(if_statement *) - { - not_implemented(); - } - - void empty_visitor::visit(import_declaration *) - { - not_implemented(); - } - - void empty_visitor::visit(while_statement *) - { - not_implemented(); - } - - void empty_visitor::visit(return_statement *) - { - not_implemented(); - } - - void empty_visitor::visit(defer_statement *) - { - not_implemented(); - } - - void empty_visitor::visit(case_statement *) - { - not_implemented(); - } - - void empty_visitor::visit(procedure_call *) - { - not_implemented(); - } - - void empty_visitor::visit(unit *) - { - not_implemented(); - } - - void empty_visitor::visit(cast_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(traits_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(binary_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(unary_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(variable_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(array_access_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(field_access_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(dereference_expression *) - { - not_implemented(); - } - - void empty_visitor::visit(literal<std::int32_t> *) - { - not_implemented(); - } - - void empty_visitor::visit(literal<std::uint32_t> *) - { - not_implemented(); - } - - void empty_visitor::visit(literal<double> *) - { - not_implemented(); - } - - void empty_visitor::visit(literal<bool> *) - { - not_implemented(); - } - - void empty_visitor::visit(literal<unsigned char> *) - { - not_implemented(); - } - - void empty_visitor::visit(literal<std::nullptr_t> *) - { - not_implemented(); - } - - void empty_visitor::visit(literal<std::string> *) - { - not_implemented(); - } - - node::node(const struct position position) - : source_position(position) - { - } - - node::~node() - { - } - - const struct position& node::position() const - { - return this->source_position; - } - - cast_expression *expression::is_cast() - { - return nullptr; - } - - traits_expression *expression::is_traits() - { - return nullptr; - } - - binary_expression *expression::is_binary() - { - return nullptr; - } - - unary_expression *expression::is_unary() - { - return nullptr; - } - - designator_expression *expression::is_designator() - { - return nullptr; - } - - procedure_call *expression::is_call_expression() - { - return nullptr; - } - - literal_expression *expression::is_literal() - { - return nullptr; - } - - type_expression::type_expression(const struct position position) - : node(position) - { - } - - named_type_expression *type_expression::is_named() - { - return nullptr; - } - - array_type_expression *type_expression::is_array() - { - return nullptr; - } - - pointer_type_expression *type_expression::is_pointer() - { - return nullptr; - } - - record_type_expression *type_expression::is_record() - { - return nullptr; - } - - union_type_expression *type_expression::is_union() - { - return nullptr; - } - - procedure_type_expression *type_expression::is_procedure() - { - return nullptr; - } - - enumeration_type_expression *type_expression::is_enumeration() - { - return nullptr; - } - - named_type_expression::named_type_expression(const struct position position, const std::string& name) - : type_expression(position), name(name) - { - } - - void named_type_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - named_type_expression *named_type_expression::is_named() - { - return this; - } - - array_type_expression::array_type_expression(const struct position position, - type_expression *base, const std::uint32_t size) - : type_expression(position), m_base(base), size(size) - { - } - - array_type_expression::~array_type_expression() - { - delete m_base; - } - - void array_type_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - array_type_expression *array_type_expression::is_array() - { - return this; - } - - type_expression& array_type_expression::base() - { - return *m_base; - } - - pointer_type_expression::pointer_type_expression(const struct position position, - type_expression *base) - : type_expression(position), m_base(base) - { - } - - pointer_type_expression::~pointer_type_expression() - { - delete m_base; - } - - void pointer_type_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - pointer_type_expression *pointer_type_expression::is_pointer() - { - return this; - } - - type_expression& pointer_type_expression::base() - { - return *m_base; - } - - record_type_expression::record_type_expression(const struct position position, - std::vector<field_declaration>&& fields) - : type_expression(position), fields(std::move(fields)) - { - } - - record_type_expression::~record_type_expression() - { - for (const field_declaration& field : this->fields) - { - delete field.second; - } - } - - void record_type_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - record_type_expression *record_type_expression::is_record() - { - return this; - } - - union_type_expression::union_type_expression(const struct position position, - std::vector<field_declaration>&& fields) - : type_expression(position), fields(std::move(fields)) - { - } - - union_type_expression::~union_type_expression() - { - for (const field_declaration& field : this->fields) - { - delete field.second; - } - } - - void union_type_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - union_type_expression *union_type_expression::is_union() - { - return this; - } - - variable_declaration::variable_declaration(const struct position position, - std::vector<identifier_definition>&& identifier, std::shared_ptr<type_expression> variable_type, - expression *body) - : node(position), m_variable_type(variable_type), identifiers(std::move(identifier)), body(body) - { - } - - variable_declaration::variable_declaration(const struct position position, - std::vector<identifier_definition>&& identifier, std::shared_ptr<type_expression> variable_type, - std::monostate) - : node(position), m_variable_type(variable_type), identifiers(std::move(identifier)), is_extern(true) - { - } - - void variable_declaration::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - bool variable_declaration::has_initializer() const - { - return this->is_extern || this->body != nullptr; - } - - type_expression& variable_declaration::variable_type() - { - return *m_variable_type; - } - - declaration::declaration(const struct position position, identifier_definition identifier) - : node(position), identifier(identifier) - { - } - - constant_declaration::constant_declaration(const struct position position, identifier_definition identifier, - expression *body) - : declaration(position, identifier), m_body(body) - { - } - - void constant_declaration::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - expression& constant_declaration::body() - { - return *m_body; - } - - constant_declaration::~constant_declaration() - { - delete m_body; - } - - procedure_type_expression::procedure_type_expression(const struct position position, return_t return_type) - : type_expression(position), return_type(return_type) - { - } - - procedure_type_expression::~procedure_type_expression() - { - if (return_type.proper_type != nullptr) - { - delete return_type.proper_type; - } - for (const type_expression *parameter : this->parameters) - { - delete parameter; - } - } - - void procedure_type_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - procedure_type_expression *procedure_type_expression::is_procedure() - { - return this; - } - - enumeration_type_expression::enumeration_type_expression(const struct position position, std::vector<std::string>&& members) - : type_expression(position), members(members) - { - } - - void enumeration_type_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - enumeration_type_expression *enumeration_type_expression::is_enumeration() - { - return this; - } - - procedure_declaration::procedure_declaration(const struct position position, identifier_definition identifier, - procedure_type_expression *heading, block&& body) - : declaration(position, identifier), m_heading(heading), body(std::move(body)) - { - } - - procedure_declaration::procedure_declaration(const struct position position, identifier_definition identifier, - procedure_type_expression *heading) - : declaration(position, identifier), m_heading(heading), body(std::nullopt) - { - } - - void procedure_declaration::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - procedure_type_expression& procedure_declaration::heading() - { - return *m_heading; - } - - procedure_declaration::~procedure_declaration() - { - delete m_heading; - } - - type_declaration::type_declaration(const struct position position, identifier_definition identifier, - type_expression *body) - : declaration(position, identifier), m_body(body) - { - } - - type_declaration::~type_declaration() - { - delete m_body; - } - - void type_declaration::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - type_expression& type_declaration::body() - { - return *m_body; - } - - block::block(std::vector<constant_declaration *>&& constants, std::vector<variable_declaration *>&& variables, - std::vector<statement *>&& body) - : m_variables(std::move(variables)), m_constants(std::move(constants)), m_body(std::move(body)) - { - } - - block::block(block&& that) - : m_variables(std::move(that.m_variables)), m_constants(std::move(that.m_constants)), - m_body(std::move(that.m_body)) - { - } - - block& block::operator=(block&& that) - { - std::swap(m_variables, that.m_variables); - std::swap(m_constants, that.m_constants); - std::swap(m_body, that.m_body); - - return *this; - } - - const std::vector<variable_declaration *>& block::variables() - { - return m_variables; - } - - const std::vector<constant_declaration *>& block::constants() - { - return m_constants; - } - - const std::vector<statement *>& block::body() - { - return m_body; - } - - block::~block() - { - for (statement *body_statement : this->body()) - { - delete body_statement; - } - for (variable_declaration *variable : this->variables()) - { - delete variable; - } - for (constant_declaration *constant : this->constants()) - { - delete constant; - } - } - - unit::unit(const struct position position) - : node(position) - { - } - - void unit::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - unit::~unit() - { - for (procedure_declaration *procedure : this->procedures) - { - delete procedure; - } - for (variable_declaration *variable : this->variables) - { - delete variable; - } - for (type_declaration *type : this->types) - { - delete type; - } - for (constant_declaration *constant : this->constants) - { - delete constant; - } - for (import_declaration *declaration : this->imports) - { - delete declaration; - } - } - - program::program(const struct position position) - : unit(position) - { - } - - void program::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - program::~program() - { - for (statement *body_statement : this->body) - { - delete body_statement; - } - } - - literal_expression::literal_expression() - { - } - - literal_expression *literal_expression::is_literal() - { - return this; - } - - defer_statement::defer_statement(const struct position position, std::vector<statement *>&& statements) - : node(position), statements(std::move(statements)) - { - } - - void defer_statement::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - defer_statement::~defer_statement() - { - for (statement *body_statement : statements) - { - delete body_statement; - } - } - - designator_expression::designator_expression() - { - } - - designator_expression::~designator_expression() - { - } - - designator_expression *designator_expression::is_designator() - { - return this; - } - - void designator_expression::accept(parser_visitor *visitor) - { - if (variable_expression *node = is_variable()) - { - return visitor->visit(node); - } - else if (array_access_expression *node = is_array_access()) - { - return visitor->visit(node); - } - else if (field_access_expression *node = is_field_access()) - { - return visitor->visit(node); - } - else if (dereference_expression *node = is_dereference()) - { - return visitor->visit(node); - } - __builtin_unreachable(); - } - - variable_expression::variable_expression(const struct position position, const std::string& name) - : node(position), name(name) - { - } - - void variable_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - variable_expression *variable_expression::is_variable() - { - return this; - } - - array_access_expression::array_access_expression(const struct position position, - expression *base, expression *index) - : node(position), m_base(base), m_index(index) - { - } - - void array_access_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - expression& array_access_expression::index() - { - return *m_index; - } - - expression& array_access_expression::base() - { - return *m_base; - } - - array_access_expression *array_access_expression::is_array_access() - { - return this; - } - - array_access_expression::~array_access_expression() - { - delete m_index; - delete m_base; - } - - field_access_expression::field_access_expression(const struct position position, - expression *base, const std::string& field) - : node(position), m_base(base), m_field(field) - { - } - - void field_access_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - expression& field_access_expression::base() - { - return *m_base; - } - - std::string& field_access_expression::field() - { - return m_field; - } - - field_access_expression *field_access_expression::is_field_access() - { - return this; - } - - field_access_expression::~field_access_expression() - { - delete m_base; - } - - dereference_expression::dereference_expression(const struct position position, - expression *base) - : node(position), m_base(base) - { - } - - void dereference_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - expression& dereference_expression::base() - { - return *m_base; - } - - dereference_expression *dereference_expression::is_dereference() - { - return this; - } - - dereference_expression::~dereference_expression() - { - delete m_base; - } - - binary_expression::binary_expression(const struct position position, expression *lhs, - expression *rhs, const binary_operator operation) - : node(position), m_lhs(lhs), m_rhs(rhs), m_operator(operation) - { - } - - void binary_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - binary_expression *binary_expression::is_binary() - { - return this; - } - - expression& binary_expression::lhs() - { - return *m_lhs; - } - - expression& binary_expression::rhs() - { - return *m_rhs; - } - - binary_operator binary_expression::operation() const - { - return m_operator; - } - - binary_expression::~binary_expression() - { - delete m_lhs; - delete m_rhs; - } - - unary_expression::unary_expression(const struct position position, expression *operand, - const unary_operator operation) - : node(position), m_operand(std::move(operand)), m_operator(operation) - { - } - - void unary_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - unary_expression *unary_expression::is_unary() - { - return this; - } - - expression& unary_expression::operand() - { - return *m_operand; - } - - unary_operator unary_expression::operation() const - { - return this->m_operator; - } - - unary_expression::~unary_expression() - { - delete m_operand; - } - - procedure_call::procedure_call(const struct position position, designator_expression *callable) - : node(position), m_callable(callable) - { - } - - void procedure_call::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - procedure_call *procedure_call::is_call_expression() - { - return this; - } - - designator_expression& procedure_call::callable() - { - return *m_callable; - } - - procedure_call::~procedure_call() - { - for (expression *const argument : arguments) - { - delete argument; - } - delete m_callable; - } - - cast_expression::cast_expression(const struct position position, type_expression *target, expression *value) - : node(position), m_target(target), m_value(value) - { - } - - void cast_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - cast_expression *cast_expression::is_cast() - { - return this; - } - - type_expression& cast_expression::target() - { - return *m_target; - } - - expression& cast_expression::value() - { - return *m_value; - } - - cast_expression::~cast_expression() - { - delete m_target; - delete m_value; - } - - traits_expression::traits_expression(const struct position position, const std::string& name) - : node(position), name(name) - { - } - - traits_expression::~traits_expression() - { - for (const type_expression *parameter : this->parameters) - { - delete parameter; - } - } - - void traits_expression::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - traits_expression *traits_expression::is_traits() - { - return this; - } - - conditional_statements::conditional_statements(expression *prerequisite, std::vector<statement *>&& statements) - : m_prerequisite(prerequisite), statements(std::move(statements)) - { - } - - expression& conditional_statements::prerequisite() - { - return *m_prerequisite; - } - - conditional_statements::~conditional_statements() - { - delete m_prerequisite; - for (auto statement : statements) - { - delete statement; - } - } - - return_statement::return_statement(const struct position position, expression *return_expression) - : node(position), m_return_expression(return_expression) - { - } - - void return_statement::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - expression& return_statement::return_expression() - { - return *m_return_expression; - } - - return_statement::~return_statement() - { - delete m_return_expression; - } - - case_statement::case_statement(const struct position position, - expression *condition, std::vector<switch_case>&& cases, std::vector<statement *> *alternative) - : node(position), m_condition(condition), cases(std::move(cases)), alternative(alternative) - { - } - - void case_statement::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - expression& case_statement::condition() - { - return *m_condition; - } - - assign_statement::assign_statement(const struct position position, designator_expression *lvalue, - expression *rvalue) - : node(position), m_lvalue(lvalue), m_rvalue(rvalue) - { - } - - void assign_statement::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - variable_expression *designator_expression::is_variable() - { - return nullptr; - } - - array_access_expression *designator_expression::is_array_access() - { - return nullptr; - } - - field_access_expression *designator_expression::is_field_access() - { - return nullptr; - } - - dereference_expression *designator_expression::is_dereference() - { - return nullptr; - } - - designator_expression& assign_statement::lvalue() - { - return *m_lvalue; - } - - expression& assign_statement::rvalue() - { - return *m_rvalue; - } - - assign_statement::~assign_statement() - { - delete m_rvalue; - } - - if_statement::if_statement(const struct position position, conditional_statements *body, - std::vector<conditional_statements *>&& branches, - std::vector<statement *> *alternative) - : node(position), m_body(body), branches(std::move(branches)), alternative(alternative) - { - } - - void if_statement::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - conditional_statements& if_statement::body() - { - return *m_body; - } - - if_statement::~if_statement() - { - delete m_body; - for (const auto branch : branches) - { - delete branch; - } - delete this->alternative; - } - - import_declaration::import_declaration(const struct position position, std::vector<std::string>&& segments) - : node(position), segments(std::move(segments)) - { - } - - void import_declaration::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - while_statement::while_statement(const struct position position, conditional_statements *body, - std::vector<conditional_statements *>&& branches) - : node(position), m_body(body), branches(std::move(branches)) - { - } - - void while_statement::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - conditional_statements& while_statement::body() - { - return *m_body; - } - - while_statement::~while_statement() - { - delete m_body; - for (const auto branch : branches) - { - delete branch; - } - } - - const char *print_binary_operator(const binary_operator operation) - { - switch (operation) - { - case binary_operator::sum: - return "+"; - case binary_operator::subtraction: - return "-"; - case binary_operator::multiplication: - return "*"; - case binary_operator::division: - return "/"; - case binary_operator::remainder: - return "%"; - case binary_operator::equals: - return "="; - case binary_operator::not_equals: - return "<>"; - case binary_operator::less: - return "<"; - case binary_operator::less_equal: - return "<="; - case binary_operator::greater: - return ">"; - case binary_operator::greater_equal: - return ">="; - case binary_operator::conjunction: - return "and"; - case binary_operator::disjunction: - return "or"; - case binary_operator::exclusive_disjunction: - return "xor"; - case binary_operator::shift_left: - return "<<"; - case binary_operator::shift_right: - return ">>"; - } - __builtin_unreachable(); - }; -} diff --git a/frontend/driver.cc b/frontend/driver.cc deleted file mode 100644 index 1c20d09..0000000 --- a/frontend/driver.cc +++ /dev/null @@ -1,124 +0,0 @@ -/* Parsing driver. - Copyright (C) 2025 Free Software Foundation, Inc. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 3, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -#include "elna/frontend/driver.h" - -namespace elna::frontend -{ - position make_position(const yy::location& location) - { - position result; - result.line = static_cast<std::size_t>(location.begin.line); - result.column = static_cast<std::size_t>(location.begin.column); - - return result; - } - - syntax_error::syntax_error(const std::string& message, - const char *input_file, const yy::location& location) - : error(input_file, make_position(location)), message(message) - { - } - - std::string syntax_error::what() const - { - return message; - } - - driver::driver(const char *input_file) - : error_container(input_file) - { - } - - char escape_char(char escape) - { - switch (escape) - { - case 'n': - return '\n'; - case 'a': - return '\a'; - case 'b': - return '\b'; - case 't': - return '\t'; - case 'f': - return '\f'; - case 'r': - return '\r'; - case 'v': - return '\v'; - case '\\': - return '\\'; - case '\'': - return '\''; - case '"': - return '"'; - case '?': - return '\?'; - case '0': - return '\0'; - default: - return escape_invalid_char; - } - } - - std::optional<std::string> escape_string(const char *escape) - { - std::string result; - const char *current_position = escape + 1; - - while (*current_position != '\0') - { - if (*current_position == '\\' && *(current_position + 1) == 'x') - { - current_position += 2; - - std::size_t processed; - char character = static_cast<char>(std::stoi(current_position, &processed, 16)); - if (processed == 0) - { - return std::nullopt; - } - else - { - current_position += processed - 1; - result.push_back(character); - } - } - else if (*current_position == '\\') - { - ++current_position; - - char escape = escape_char(*current_position); - if (escape == escape_invalid_char) - { - return std::nullopt; - } - result.push_back(escape); - } - else - { - result.push_back(*current_position); - } - ++current_position; - } - result.pop_back(); // Remove the terminating quote character. - - return result; - } -} diff --git a/frontend/lexer.ll b/frontend/lexer.ll deleted file mode 100644 index f14497b..0000000 --- a/frontend/lexer.ll +++ /dev/null @@ -1,320 +0,0 @@ -/* Lexical analyzer. - Copyright (C) 2025 Free Software Foundation, Inc. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 3, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -%{ -#define YY_NO_UNISTD_H -#define YY_USER_ACTION this->location.columns(yyleng); - -#include <sstream> -#include "parser.hh" - -#undef YY_DECL -#define YY_DECL yy::parser::symbol_type elna::frontend::lexer::lex(driver& driver) -#define yyterminate() return yy::parser::make_YYEOF(this->location) -%} - -%option c++ noyywrap never-interactive -%option yyclass="lexer" - -%x IN_COMMENT - -ID1 [A-Za-z_] -ID2 [A-Za-z0-9_] -HIGIT [0-9a-fA-F] -BIGIT [01] - -%% -%{ - this->location.step(); -%} - -<IN_COMMENT>{ - \*\) BEGIN(INITIAL); - [^*\n]+ ; /* Eat comment in chunks. */ - \* ; /* Eat the lone star. */ - \n+ { - this->location.lines(yyleng); - this->location.step(); - } -} -\(\* BEGIN(IN_COMMENT); -[ \t\r] { - this->location.step(); -} -\n+ { - this->location.lines(yyleng); -} -if { - return yy::parser::make_IF(this->location); -} -then { - return yy::parser::make_THEN(this->location); -} -else { - return yy::parser::make_ELSE(this->location); -} -elsif { - return yy::parser::make_ELSIF(this->location); -} -while { - return yy::parser::make_WHILE(this->location); -} -do { - return yy::parser::make_DO(this->location); -} -proc { - return yy::parser::make_PROCEDURE(this->location); -} -begin { - return yy::parser::make_BEGIN_BLOCK(this->location); - } -end { - return yy::parser::make_END_BLOCK(this->location); -} -extern { - return yy::parser::make_EXTERN(this->location); -} -const { - return yy::parser::make_CONST(this->location); -} -var { - return yy::parser::make_VAR(this->location); -} -type { - return yy::parser::make_TYPE(this->location); -} -record { - return yy::parser::make_RECORD(this->location); -} -union { - return yy::parser::make_UNION(this->location); -} -true { - return yy::parser::make_BOOLEAN(true, this->location); -} -false { - return yy::parser::make_BOOLEAN(false, this->location); -} -nil { - return yy::parser::make_NIL(this->location); -} -\& { - return yy::parser::make_AND(this->location); -} -xor { - return yy::parser::make_XOR(this->location); -} -or { - return yy::parser::make_OR(this->location); -} -\| { - return yy::parser::make_PIPE(this->location); -} -\~ { - return yy::parser::make_NOT(this->location); -} -return { - return yy::parser::make_RETURN(this->location); -} -module { - return yy::parser::make_MODULE(this->location); -} -program { - return yy::parser::make_PROGRAM(this->location); -} -import { - return yy::parser::make_IMPORT(this->location); -} -cast { - return yy::parser::make_CAST(this->location); -} -defer { - return yy::parser::make_DEFER(this->location); -} -case { - return yy::parser::make_CASE(this->location); -} -of { - return yy::parser::make_OF(this->location); -} -{ID1}{ID2}* { - return yy::parser::make_IDENTIFIER(yytext, this->location); -} -#{ID1}{ID2}* { - return yy::parser::make_TRAIT(yytext + 1, this->location); -} -[[:digit:]]+u { - unsigned long result = strtoul(yytext, NULL, 10); - - if (errno == ERANGE) - { - REJECT; - } - else - { - return yy::parser::make_WORD(result, this->location); - } -} -[[:digit:]]+ { - long result = strtol(yytext, NULL, 10); - - if (errno == ERANGE) - { - REJECT; - } - else - { - return yy::parser::make_INTEGER(result, this->location); - } -} -0x{HIGIT}+ { - unsigned long result = strtoul(yytext, NULL, 16); - - if (errno == ERANGE) - { - REJECT; - } - else - { - return yy::parser::make_WORD(result, this->location); - } -} -0b{BIGIT}+ { - unsigned long result = strtoul(yytext, NULL, 2); - - if (errno == ERANGE) - { - REJECT; - } - else - { - return yy::parser::make_WORD(result, this->location); - } -} -[[:digit:]]+\.[[:digit:]]+ { - float result = strtof(yytext, NULL); - - if (errno == ERANGE) - { - REJECT; - } - else - { - return yy::parser::make_FLOAT(result, this->location); - } -} -'[[:print:]]+' { - std::optional<std::string> result = escape_string(yytext); - if (!result.has_value() || result.value().size() != 1) - { - REJECT; - } - return yy::parser::make_CHARACTER(result.value(), this->location); -} -\"[[:print:]]*\" { - std::optional<std::string> result = escape_string(yytext); - if (!result.has_value()) - { - REJECT; - } - return yy::parser::make_STRING(result.value(), this->location); -} -\( { - return yy::parser::make_LEFT_PAREN(this->location); -} -\) { - return yy::parser::make_RIGHT_PAREN(this->location); -} -\[ { - return yy::parser::make_LEFT_SQUARE(this->location); -} -\] { - return yy::parser::make_RIGHT_SQUARE(this->location); -} -\<\< { - return yy::parser::make_SHIFT_LEFT(this->location); -} -\>\> { - return yy::parser::make_SHIFT_RIGHT(this->location); -} -\>= { - return yy::parser::make_GREATER_EQUAL(this->location); -} -\<= { - return yy::parser::make_LESS_EQUAL(this->location); -} -\> { - return yy::parser::make_GREATER_THAN(this->location); -} -\< { - return yy::parser::make_LESS_THAN(this->location); -} -\<\> { - return yy::parser::make_NOT_EQUAL(this->location); -} -= { - return yy::parser::make_EQUALS(this->location); -} -; { - return yy::parser::make_SEMICOLON(this->location); -} -\. { - return yy::parser::make_DOT(this->location); -} -, { - return yy::parser::make_COMMA(this->location); -} -\+ { - return yy::parser::make_PLUS(this->location); -} -\-> { - return yy::parser::make_ARROW(this->location); -} -\- { - return yy::parser::make_MINUS(this->location); -} -\* { - return yy::parser::make_MULTIPLICATION(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_COLON(this->location); -} -\^ { - return yy::parser::make_HAT(this->location); -} -@ { - return yy::parser::make_AT(this->location); -} -! { - return yy::parser::make_EXCLAMATION(this->location); -} -. { - std::stringstream ss; - - ss << "Illegal character 0x" << std::hex << static_cast<unsigned int>(yytext[0]); - driver.add_error<syntax_error>(ss.str(), driver.input_file, this->location); -} -%% diff --git a/frontend/parser.yy b/frontend/parser.yy deleted file mode 100644 index bace8d7..0000000 --- a/frontend/parser.yy +++ /dev/null @@ -1,594 +0,0 @@ -/* Syntax analyzer. - Copyright (C) 2025 Free Software Foundation, Inc. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 3, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -%require "3.4" -%language "c++" - -%code { - using namespace elna; -} - -%code requires { - #include <cstdint> - #include <iostream> - #include "elna/frontend/driver.h" - - #if !defined(yyFlexLexerOnce) - #include <FlexLexer.h> - #endif - - namespace elna::frontend - { - class lexer; - } -} - -%code provides { - namespace elna::frontend - { - - class lexer: public yyFlexLexer - { - public: - yy::location location; - - lexer(std::istream& arg_yyin) - : yyFlexLexer(&arg_yyin) - { - } - - yy::parser::symbol_type lex(driver& driver); - }; - - } -} - -%define api.token.raw -%define api.token.constructor -%define api.value.type variant - -%parse-param {elna::frontend::lexer& lexer} -%param {elna::frontend::driver& driver} -%locations - -%header - -%code { - #define yylex lexer.lex -} -%start program; - -%token <std::string> IDENTIFIER -%token <std::string> TRAIT -%token <std::int32_t> INTEGER -%token <std::uint32_t> WORD -%token <float> FLOAT -%token <std::string> CHARACTER -%token <std::string> STRING -%token <bool> BOOLEAN -%token LEFT_PAREN "(" RIGHT_PAREN ")" LEFT_SQUARE "[" RIGHT_SQUARE "]" -%token ASSIGNMENT ":=" - ARROW "->" EXCLAMATION "!" - AT "@" HAT "^" - COLON ":" SEMICOLON ";" DOT "." COMMA "," -%token NOT "~" - CAST "cast" - NIL "nil" - CONST "const" - VAR "var" - PROCEDURE "proc" - TYPE "type" - RECORD "record" - UNION "union" - EXTERN "extern" - IF "if" - WHILE "while" - DO "do" - THEN "then" - ELSE "else" - ELSIF "elsif" - RETURN "return" - PROGRAM "program" - MODULE "module" - IMPORT "import" - BEGIN_BLOCK "begin" - END_BLOCK "end" - DEFER "defer" - CASE "case" - OF "of" - PIPE "|" -%token OR "or" AND "&" XOR "xor" - EQUALS "=" NOT_EQUAL "<>" LESS_THAN "<" GREATER_THAN ">" LESS_EQUAL "<=" GREATER_EQUAL ">=" - SHIFT_LEFT "<<" SHIFT_RIGHT ">>" - PLUS "+" MINUS "-" - MULTIPLICATION "*" DIVISION "/" REMAINDER "%" - -%left "or" "&" "xor" -%left "=" "<>" "<" ">" "<=" ">=" -%left "<<" ">>" -%left "+" "-" -%left "*" "/" "%" - -%type <elna::frontend::literal_expression *> literal; -%type <std::vector<elna::frontend::expression *>> case_labels; -%type <elna::frontend::switch_case> switch_case; -%type <std::vector<elna::frontend::switch_case>> switch_cases; -%type <elna::frontend::constant_declaration *> constant_declaration; -%type <std::vector<elna::frontend::constant_declaration *>> constant_part constant_declarations; -%type <elna::frontend::variable_declaration *> variable_declaration; -%type <std::vector<elna::frontend::variable_declaration *>> variable_declarations variable_part; -%type <elna::frontend::type_expression *> type_expression; -%type <std::vector<elna::frontend::type_expression *>> type_expressions; -%type <elna::frontend::traits_expression *> traits_expression; -%type <elna::frontend::expression *> expression operand simple_expression; -%type <elna::frontend::unary_expression *> unary_expression; -%type <elna::frontend::binary_expression *> binary_expression; -%type <std::vector<elna::frontend::expression *>> expressions actual_parameter_list; -%type <elna::frontend::designator_expression *> designator_expression; -%type <elna::frontend::procedure_call*> call_expression; -%type <elna::frontend::return_statement *> return_statement; -%type <elna::frontend::statement *> statement; -%type <std::vector<elna::frontend::statement *>> required_statements optional_statements statement_part; -%type <elna::frontend::procedure_declaration *> procedure_declaration; -%type <std::pair<std::vector<std::string>, elna::frontend::procedure_type_expression *>> procedure_heading; -%type <elna::frontend::procedure_type_expression::return_t> return_declaration; -%type <std::vector<elna::frontend::procedure_declaration *>> procedure_declarations procedure_part; -%type <elna::frontend::type_declaration *> type_declaration; -%type <std::vector<elna::frontend::type_declaration *>> type_declarations type_part; -%type <std::unique_ptr<elna::frontend::block>> block; -%type <elna::frontend::field_declaration> field_declaration formal_parameter; -%type <std::vector<std::pair<std::string, elna::frontend::type_expression *>>> - optional_fields required_fields formal_parameters formal_parameter_list; -%type <std::vector<elna::frontend::conditional_statements *>> elsif_then_statements elsif_do_statements; -%type <std::vector<elna::frontend::statement *> *> else_statements; -%type <elna::frontend::cast_expression *> cast_expression; -%type <elna::frontend::identifier_definition> identifier_definition; -%type <std::vector<elna::frontend::identifier_definition>> identifier_definitions; -%type <std::vector<std::string>> identifiers import_declaration; -%type <std::vector<elna::frontend::import_declaration *>> import_declarations import_part; -%% -program: - "program" ";" import_part constant_part type_part variable_part procedure_part statement_part "end" "." - { - auto tree = new frontend::program(frontend::make_position(@1)); - - std::swap(tree->imports, $3); - std::swap(tree->constants, $4); - std::swap(tree->types , $5); - std::swap(tree->variables, $6); - std::swap(tree->procedures, $7); - std::swap(tree->body, $8); - - driver.tree.reset(tree); - } - | "module" ";" import_part constant_part type_part variable_part procedure_part "end" "." - { - auto tree = new frontend::unit(frontend::make_position(@1)); - - std::swap(tree->imports, $3); - std::swap(tree->constants, $4); - std::swap(tree->types , $5); - std::swap(tree->variables, $6); - std::swap(tree->procedures, $7); - - driver.tree.reset(tree); - } -block: constant_part variable_part statement_part "end" - { - $$ = std::make_unique<frontend::block>(std::move($1), std::move($2), std::move($3)); - } -statement_part: - /* no statements */ {} - | "begin" required_statements { std::swap($$, $2); } - | return_statement { $$.push_back($1); } - | "begin" required_statements ";" return_statement - { - std::swap($$, $2); - $$.push_back($4); - } -identifier_definition: - IDENTIFIER "*" { $$ = frontend::identifier_definition{ $1, true }; } - | IDENTIFIER { $$ = frontend::identifier_definition{ $1, false }; } -identifier_definitions: - identifier_definition "," identifier_definitions - { - std::swap($$, $3); - $$.emplace($$.cbegin(), $1); - } - | identifier_definition { $$.emplace_back(std::move($1)); } -return_declaration: - /* proper procedure */ {} - | "->" "!" { $$ = frontend::procedure_type_expression::return_t(std::monostate{}); } - | "->" type_expression { $$ = frontend::procedure_type_expression::return_t($2); } -procedure_heading: formal_parameter_list return_declaration - { - $$.second = new frontend::procedure_type_expression(frontend::make_position(@1), std::move($2)); - for (auto& [name, type] : $1) - { - $$.first.emplace_back(std::move(name)); - $$.second->parameters.push_back(type); - } - } -procedure_declaration: - "proc" identifier_definition procedure_heading ";" block ";" - { - $$ = new frontend::procedure_declaration(frontend::make_position(@1), std::move($2), $3.second, std::move(*$5)); - std::swap($3.first, $$->parameter_names); - } - | "proc" identifier_definition procedure_heading ";" "extern" ";" - { - $$ = new frontend::procedure_declaration(frontend::make_position(@1), std::move($2), $3.second); - std::swap($3.first, $$->parameter_names); - } -procedure_declarations: - procedure_declaration procedure_declarations - { - std::swap($$, $2); - $$.emplace($$.cbegin(), std::move($1)); - } - | procedure_declaration { $$.emplace_back(std::move($1)); } -procedure_part: - /* no procedure definitions */ {} - | procedure_declarations { std::swap($$, $1); } -call_expression: designator_expression actual_parameter_list - { - $$ = new frontend::procedure_call(frontend::make_position(@1), $1); - std::swap($$->arguments, $2); - } -cast_expression: "cast" "(" expression ":" type_expression ")" - { $$ = new frontend::cast_expression(frontend::make_position(@1), $5, $3); } -elsif_do_statements: - "elsif" expression "do" optional_statements elsif_do_statements - { - frontend::conditional_statements *branch = new frontend::conditional_statements($2, std::move($4)); - std::swap($5, $$); - $$.emplace($$.begin(), branch); - } - | {} -else_statements: - "else" optional_statements { $$ = new std::vector<frontend::statement *>(std::move($2)); } - | { $$ = nullptr; } -elsif_then_statements: - "elsif" expression "then" optional_statements elsif_then_statements - { - frontend::conditional_statements *branch = new frontend::conditional_statements($2, std::move($4)); - std::swap($5, $$); - $$.emplace($$.begin(), branch); - } - | {} -return_statement: "return" expression - { $$ = new frontend::return_statement(frontend::make_position(@1), $2); } -literal: - INTEGER { $$ = new frontend::literal<std::int32_t>(frontend::make_position(@1), $1); } - | WORD { $$ = new frontend::literal<std::uint32_t>(frontend::make_position(@1), $1); } - | FLOAT { $$ = new frontend::literal<double>(frontend::make_position(@1), $1); } - | BOOLEAN { $$ = new frontend::literal<bool>(frontend::make_position(@1), $1); } - | CHARACTER { $$ = new frontend::literal<unsigned char>(frontend::make_position(@1), $1.at(0)); } - | "nil" { $$ = new frontend::literal<std::nullptr_t>(frontend::make_position(@1), nullptr); } - | STRING { $$ = new frontend::literal<std::string>(frontend::make_position(@1), $1); } -traits_expression: - TRAIT "(" type_expressions ")" - { - $$ = new frontend::traits_expression(frontend::make_position(@1), $1); - std::swap($3, $$->parameters); - } -simple_expression: - literal { $$ = $1; } - | designator_expression { $$ = $1; } - | traits_expression { $$ = $1; } - | cast_expression { $$ = $1; } - | call_expression { $$ = $1; } - | "(" expression ")" { $$ = $2; } -operand: - unary_expression { $$ = $1; } - | simple_expression { $$ = $1; } -expression: - binary_expression { $$ = $1; } - | operand { $$ = $1; } -binary_expression: - expression "*" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::multiplication); - } - | expression "/" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::division); - } - | expression "%" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::remainder); - } - | expression "+" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::sum); - } - | expression "-" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::subtraction); - } - | expression "=" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::equals); - } - | expression "<>" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::not_equals); - } - | expression "<" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::less); - } - | expression ">" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::greater); - } - | expression "<=" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, - frontend::binary_operator::less_equal); - } - | expression ">=" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::greater_equal); - } - | expression "&" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::conjunction); - } - | expression "or" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::disjunction); - } - | expression "xor" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, - frontend::binary_operator::exclusive_disjunction); - } - | expression "<<" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::shift_left); - } - | expression ">>" expression - { - $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::shift_right); - } -unary_expression: - "@" operand - { - $$ = new frontend::unary_expression(frontend::make_position(@1), $2, frontend::unary_operator::reference); - } - | "~" operand - { - $$ = new frontend::unary_expression(frontend::make_position(@1), $2, frontend::unary_operator::negation); - } - | "-" operand - { - $$ = new frontend::unary_expression(frontend::make_position(@1), $2, frontend::unary_operator::minus); - } -expressions: - expression "," expressions - { - std::swap($$, $3); - $$.emplace($$.cbegin(), $1); - } - | expression { $$.push_back($1); } -type_expressions: - type_expression "," type_expressions - { - std::swap($$, $3); - $$.emplace($$.cbegin(), $1); - } - | type_expression { $$.push_back($1); } -designator_expression: - simple_expression "[" expression "]" - { $$ = new frontend::array_access_expression(frontend::make_position(@2), $1, $3); } - | simple_expression "." IDENTIFIER - { $$ = new frontend::field_access_expression(frontend::make_position(@2), $1, $3); } - | simple_expression "^" - { $$ = new frontend::dereference_expression(frontend::make_position(@1), $1); } - | IDENTIFIER - { $$ = new frontend::variable_expression(frontend::make_position(@1), $1); } -statement: - designator_expression ":=" expression - { $$ = new frontend::assign_statement(frontend::make_position(@1), $1, $3); } - | "while" expression "do" optional_statements elsif_do_statements "end" - { - frontend::conditional_statements *body = new frontend::conditional_statements($2, std::move($4)); - $$ = new frontend::while_statement(frontend::make_position(@1), body, std::move($5)); - } - | "if" expression "then" optional_statements elsif_then_statements else_statements "end" - { - frontend::conditional_statements *then = new frontend::conditional_statements($2, std::move($4)); - $$ = new frontend::if_statement(frontend::make_position(@1), then, std::move($5), $6); - } - | call_expression { $$ = $1; } - | "defer" optional_statements "end" - { $$ = new frontend::defer_statement(frontend::make_position(@1), std::move($2)); } - | "case" expression "of" switch_cases else_statements "end" - { $$ = new frontend::case_statement(frontend::make_position(@1), $2, std::move($4), $5); } -switch_case: case_labels ":" optional_statements - { $$ = { .labels = std::move($1), .statements = std::move($3) }; } -switch_cases: - switch_case "|" switch_cases - { - std::swap($$, $3); - $$.emplace($$.cbegin(), $1); - } - | switch_case { $$.push_back($1); } -case_labels: - expression "," case_labels - { - std::swap($$, $3); - $$.emplace($$.cbegin(), $1); - } - | expression { $$.push_back($1); } -required_statements: - required_statements ";" statement - { - std::swap($$, $1); - $$.insert($$.cend(), $3); - } - | statement { $$.push_back($1); } -optional_statements: - required_statements { std::swap($$, $1); } - | /* no statements */ {} -field_declaration: - IDENTIFIER ":" type_expression { $$ = std::make_pair($1, $3); } -required_fields: - field_declaration ";" required_fields - { - std::swap($$, $3); - $$.emplace($$.cbegin(), $1); - } - | field_declaration { $$.emplace_back($1); } -optional_fields: - required_fields { std::swap($$, $1); } - | /* no fields */ {} -type_expression: - "[" INTEGER "]" type_expression - { - $$ = new frontend::array_type_expression(frontend::make_position(@1), $4, $2); - } - | "^" type_expression - { - $$ = new frontend::pointer_type_expression(frontend::make_position(@1), $2); - } - | "record" optional_fields "end" - { - $$ = new frontend::record_type_expression(frontend::make_position(@1), std::move($2)); - } - | "union" required_fields "end" - { - $$ = new frontend::union_type_expression(frontend::make_position(@1), std::move($2)); - } - | "proc" "(" type_expressions ")" return_declaration - { - auto result = new frontend::procedure_type_expression(frontend::make_position(@1), std::move($5)); - std::swap(result->parameters, $3); - $$ = result; - } - | "(" identifiers ")" - { - $$ = new frontend::enumeration_type_expression(frontend::make_position(@1), std::move($2)); - } - | IDENTIFIER - { - $$ = new frontend::named_type_expression(frontend::make_position(@1), $1); - } -identifiers: - IDENTIFIER "," identifiers - { - std::swap($$, $3); - $$.emplace($$.cbegin(), std::move($1)); - } - | IDENTIFIER { $$.emplace_back(std::move($1)); } -variable_declaration: - identifier_definitions ":" type_expression ";" - { - std::shared_ptr<frontend::type_expression> shared_type{ $3 }; - $$ = new frontend::variable_declaration( frontend::make_position(@2), std::move($1), shared_type); - } - | identifier_definitions ":" type_expression ":=" "extern" ";" - { - std::shared_ptr<frontend::type_expression> shared_type{ $3 }; - $$ = new frontend::variable_declaration( frontend::make_position(@2), std::move($1), shared_type, - std::monostate{}); - } - | identifier_definitions ":" type_expression ":=" expression ";" - { - std::shared_ptr<frontend::type_expression> shared_type{ $3 }; - $$ = new frontend::variable_declaration( frontend::make_position(@2), std::move($1), shared_type, $5); - } -variable_declarations: - /* no variable declarations */ {} - | variable_declaration variable_declarations - { - std::swap($$, $2); - $$.insert(std::cbegin($$), $1); - } -variable_part: - /* no variable declarations */ {} - | "var" variable_declarations { std::swap($$, $2); } -constant_declaration: identifier_definition ":=" expression ";" - { - $$ = new frontend::constant_declaration(frontend::make_position(@1), std::move($1), $3); - } -constant_declarations: - constant_declaration constant_declarations - { - std::swap($$, $2); - $$.insert(std::cbegin($$), $1); - } - | /* no constant definitions */ {} -constant_part: - /* no constant definitions */ {} - | "const" constant_declarations { std::swap($$, $2); } -import_declaration: - IDENTIFIER "." import_declaration - { - std::swap($$, $3); - $$.emplace($$.cbegin(), std::move($1)); - } - | IDENTIFIER { $$.emplace_back(std::move($1)); } -import_declarations: - import_declaration "," import_declarations - { - std::swap($$, $3); - $$.emplace($$.cbegin(), new frontend::import_declaration(frontend::make_position(@1), std::move($1))); - } - | import_declaration - { - $$.emplace_back(new frontend::import_declaration(frontend::make_position(@1), std::move($1))); - } -import_part: - /* no import declarations */ {} - | "import" import_declarations ";" { std::swap($$, $2); } -type_declaration: identifier_definition "=" type_expression ";" - { - $$ = new frontend::type_declaration(frontend::make_position(@1), std::move($1), $3); - } -type_declarations: - type_declaration type_declarations - { - std::swap($$, $2); - $$.insert($$.cbegin(), $1); - } - | /* no type definitions */ {} -type_part: - /* no type definitions */ {} - | "type" type_declarations { std::swap($$, $2); } -formal_parameter: - IDENTIFIER ":" type_expression { $$ = std::make_pair($1, $3); } -formal_parameter_list: - "(" ")" {} - | "(" formal_parameters ")" { std::swap($$, $2); } -formal_parameters: - formal_parameter "," formal_parameters - { - std::swap($$, $3); - $$.emplace($$.cbegin(), std::move($1)); - } - | formal_parameter { $$.emplace_back(std::move($1)); } -actual_parameter_list: - "(" ")" {} - | "(" expressions ")" { std::swap($$, $2); } -%% - -void yy::parser::error(const location_type& loc, const std::string& message) -{ - driver.add_error<frontend::syntax_error>(message, driver.input_file, loc); -} diff --git a/frontend/result.cc b/frontend/result.cc deleted file mode 100644 index aca9c5e..0000000 --- a/frontend/result.cc +++ /dev/null @@ -1,67 +0,0 @@ -/* Miscellaneous types used across stage boundaries. - Copyright (C) 2025 Free Software Foundation, Inc. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 3, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -#include "elna/frontend/result.h" - -namespace elna::frontend -{ - error::error(const char *path, const struct position position) - : position(position), path(path) - { - } - - std::size_t error::line() const noexcept - { - return this->position.line; - } - - std::size_t error::column() const noexcept - { - return this->position.column; - } - - error_container::error_container(const char *input_file) - : input_file(input_file) - { - } - - std::deque<std::unique_ptr<error>>& error_container::errors() - { - return m_errors; - } - - bool error_container::has_errors() const - { - return !m_errors.empty(); - } - - bool identifier_definition::operator==(const identifier_definition& that) const - { - return *this == that.name; - } - - bool identifier_definition::operator==(const std::string& that) const - { - return this->name == that; - } -} - -std::size_t std::hash<elna::frontend::identifier_definition>::operator()( - const elna::frontend::identifier_definition& key) const -{ - return std::hash<std::string>{}(key.name); -} diff --git a/frontend/symbol.cc b/frontend/symbol.cc deleted file mode 100644 index bfecbd4..0000000 --- a/frontend/symbol.cc +++ /dev/null @@ -1,427 +0,0 @@ -/* Symbol definitions. - Copyright (C) 2025 Free Software Foundation, Inc. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 3, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -#include "elna/frontend/symbol.h" - -namespace elna::frontend -{ - type::type() - { - } - - type::type(std::shared_ptr<alias_type> alias) - : tag(type_tag::alias), alias(alias) - { - } - - type::type(std::shared_ptr<primitive_type> primitive) - : tag(type_tag::primitive), primitive(primitive) - { - } - - type::type(std::shared_ptr<record_type> record) - : tag(type_tag::record), record(record) - { - } - - type::type(std::shared_ptr<union_type> _union) - : tag(type_tag::_union), _union(_union) - { - } - - type::type(std::shared_ptr<pointer_type> pointer) - : tag(type_tag::pointer), pointer(pointer) - { - } - - type::type(std::shared_ptr<array_type> array) - : tag(type_tag::array), array(array) - { - } - - type::type(std::shared_ptr<procedure_type> procedure) - : tag(type_tag::procedure), procedure(procedure) - { - } - - type::type(std::shared_ptr<enumeration_type> enumeration) - : tag(type_tag::enumeration), enumeration(enumeration) - { - } - - void type::copy(const type& other) - { - switch (other.tag) - { - case type_tag::empty: - break; - case type_tag::alias: - new (&alias) std::weak_ptr<alias_type>(other.alias); - break; - case type_tag::primitive: - new (&primitive) std::shared_ptr<primitive_type>(other.primitive); - break; - case type_tag::record: - new (&record) std::shared_ptr<record_type>(other.record); - break; - case type_tag::_union: - new (&_union) std::shared_ptr<union_type>(other._union); - break; - case type_tag::pointer: - new (&pointer) std::shared_ptr<pointer_type>(other.pointer); - break; - case type_tag::array: - new (&array) std::shared_ptr<array_type>(other.array); - break; - case type_tag::procedure: - new (&procedure) std::shared_ptr<procedure_type>(other.procedure); - break; - case type_tag::enumeration: - new (&enumeration) std::shared_ptr<enumeration_type>(other.enumeration); - break; - } - } - - type::type(const type& other) - : tag(other.tag) - { - copy(other); - } - - void type::move(type&& other) - { - switch (other.tag) - { - case type_tag::empty: - break; - case type_tag::alias: - new (&alias) std::weak_ptr<alias_type>(std::move(other.alias)); - break; - case type_tag::primitive: - new (&primitive) std::shared_ptr<primitive_type>(std::move(other.primitive)); - break; - case type_tag::record: - new (&record) std::shared_ptr<record_type>(std::move(other.record)); - break; - case type_tag::_union: - new (&_union) std::shared_ptr<union_type>(std::move(other._union)); - break; - case type_tag::pointer: - new (&pointer) std::shared_ptr<pointer_type>(std::move(other.pointer)); - break; - case type_tag::array: - new (&array) std::shared_ptr<array_type>(std::move(other.array)); - break; - case type_tag::procedure: - new (&procedure) std::shared_ptr<procedure_type>(std::move(other.procedure)); - break; - case type_tag::enumeration: - new (&enumeration) std::shared_ptr<enumeration_type>(std::move(other.enumeration)); - break; - } - } - - type& type::operator=(const type& other) - { - this->~type(); - this->tag = other.tag; - copy(other); - return *this; - } - - type::type(type&& other) - : tag(other.tag) - { - move(std::move(other)); - } - - type& type::operator=(type&& other) - { - this->~type(); - this->tag = other.tag; - move(std::move(other)); - return *this; - } - - bool type::operator==(const std::nullptr_t&) - { - return empty(); - } - - type::~type() - { - switch (tag) - { - case type_tag::empty: - break; - case type_tag::alias: - this->alias.~weak_ptr<alias_type>(); - break; - case type_tag::primitive: - this->primitive.~shared_ptr<primitive_type>(); - break; - case type_tag::record: - this->record.~shared_ptr<record_type>(); - break; - case type_tag::_union: - this->_union.~shared_ptr<union_type>(); - break; - case type_tag::pointer: - this->pointer.~shared_ptr<pointer_type>(); - break; - case type_tag::array: - this->array.~shared_ptr<array_type>(); - break; - case type_tag::procedure: - this->procedure.~shared_ptr<procedure_type>(); - break; - case type_tag::enumeration: - this->enumeration.~shared_ptr<enumeration_type>(); - break; - } - } - - template<> - std::shared_ptr<alias_type> type::get<alias_type>() const - { - return tag == type_tag::alias ? this->alias.lock() : nullptr; - } - - template<> - std::shared_ptr<primitive_type> type::get<primitive_type>() const - { - return tag == type_tag::primitive ? this->primitive : nullptr; - } - - template<> - std::shared_ptr<record_type> type::get<record_type>() const - { - return tag == type_tag::record ? this->record : nullptr; - } - - template<> - std::shared_ptr<union_type> type::get<union_type>() const - { - return tag == type_tag::_union ? this->_union : nullptr; - } - - template<> - std::shared_ptr<pointer_type> type::get<pointer_type>() const - { - return tag == type_tag::pointer ? this->pointer : nullptr; - } - - template<> - std::shared_ptr<array_type> type::get<array_type>() const - { - return tag == type_tag::array ? this->array : nullptr; - } - - template<> - std::shared_ptr<procedure_type> type::get<procedure_type>() const - { - return tag == type_tag::procedure ? this->procedure : nullptr; - } - - template<> - std::shared_ptr<enumeration_type> type::get<enumeration_type>() const - { - return tag == type_tag::enumeration ? this->enumeration : nullptr; - } - - bool type::empty() const - { - return tag == type_tag::empty; - } - - alias_type::alias_type(const std::string& name) - : name(name), reference() - { - } - - pointer_type::pointer_type(type base) - : base(base) - { - } - - array_type::array_type(type base, std::uint64_t size) - : base(base), size(size) - { - } - - primitive_type::primitive_type(const std::string& identifier) - : identifier(identifier) - { - } - - procedure_type::procedure_type(return_t return_type) - : return_type(return_type) - { - } - - enumeration_type::enumeration_type(const std::vector<std::string>& members) - : members(members) - { - } - - info::~info() - { - } - - std::shared_ptr<type_info> info::is_type() - { - return nullptr; - } - - std::shared_ptr<procedure_info> info::is_procedure() - { - return nullptr; - } - - std::shared_ptr<constant_info> info::is_constant() - { - return nullptr; - } - - std::shared_ptr<variable_info> info::is_variable() - { - return nullptr; - } - - type_info::type_info(const type symbol) - : symbol(symbol) - { - } - - std::shared_ptr<type_info> type_info::is_type() - { - return std::static_pointer_cast<type_info>(shared_from_this()); - } - - procedure_info::procedure_info(const procedure_type symbol, const std::vector<std::string> names, - std::shared_ptr<symbol_table> scope) - : symbol(symbol), names(names), scope(scope) - { - } - - std::shared_ptr<procedure_info> procedure_info::is_procedure() - { - return std::static_pointer_cast<procedure_info>(shared_from_this()); - } - - bool procedure_info::is_extern() const - { - return this->scope == nullptr; - } - - constant_info::constant_info(const variant& symbol) - : symbol(symbol) - { - } - - std::shared_ptr<constant_info> constant_info::is_constant() - { - return std::static_pointer_cast<constant_info>(shared_from_this()); - } - - variable_info::variable_info(const type symbol, bool is_extern) - : symbol(symbol), is_extern(is_extern) - { - } - - std::shared_ptr<variable_info> variable_info::is_variable() - { - return std::static_pointer_cast<variable_info>(shared_from_this()); - } - - std::shared_ptr<symbol_table> builtin_symbol_table() - { - auto result = std::make_shared<symbol_table>(); - - result->enter("Int", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Int")))); - result->enter("Word", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Word")))); - result->enter("Char", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Char")))); - result->enter("Bool", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Bool")))); - result->enter("Pointer", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Pointer")))); - result->enter("Float", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Float")))); - result->enter("String", std::make_shared<type_info>(type(std::make_shared<primitive_type>("String")))); - - return result; - } - - symbol_bag::symbol_bag(forward_table&& unresolved, std::shared_ptr<symbol_table> global_table) - : unresolved(unresolved) - { - this->symbols = std::make_shared<symbol_table>(global_table); - } - - std::shared_ptr<info> symbol_bag::lookup(const std::string& name) - { - for (auto import_bag : this->imports) - { - if (auto result = import_bag->lookup(name)) - { - return result; - } - } - return this->symbols->lookup(name); - } - - bool symbol_bag::enter(const std::string& name, std::shared_ptr<info> entry) - { - return this->symbols->enter(name, entry); - } - - std::shared_ptr<symbol_table> symbol_bag::enter() - { - this->symbols = std::make_shared<symbol_table>(this->symbols); - return this->symbols; - } - - void symbol_bag::enter(std::shared_ptr<symbol_table> child) - { - this->symbols = child; - } - - std::shared_ptr<symbol_table> symbol_bag::leave() - { - std::shared_ptr<symbol_table> result = this->symbols; - - this->symbols = result->scope(); - return result; - } - - std::shared_ptr<alias_type> symbol_bag::declared(const std::string& symbol_name) - { - auto unresolved_alias = this->unresolved.find(symbol_name); - - return unresolved_alias == this->unresolved.end() ? std::shared_ptr<alias_type>() : unresolved_alias->second; - } - - std::shared_ptr<alias_type> symbol_bag::resolve(const std::string& symbol_name, type& resolution) - { - auto unresolved_declaration = this->unresolved.at(symbol_name); - - unresolved_declaration->reference = resolution; - return unresolved_declaration; - } - - void symbol_bag::add_import(const symbol_bag& bag) - { - this->imports.push_front(bag.symbols); - } -} |