diff options
Diffstat (limited to 'frontend')
| -rw-r--r-- | frontend/ast.cc | 1178 | ||||
| -rw-r--r-- | frontend/dependency.cc | 102 | ||||
| -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/semantic.cc | 644 | ||||
| -rw-r--r-- | frontend/symbol.cc | 427 |
8 files changed, 3456 insertions, 0 deletions
diff --git a/frontend/ast.cc b/frontend/ast.cc new file mode 100644 index 0000000..e067937 --- /dev/null +++ b/frontend/ast.cc @@ -0,0 +1,1178 @@ +/* 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/dependency.cc b/frontend/dependency.cc new file mode 100644 index 0000000..25658f8 --- /dev/null +++ b/frontend/dependency.cc @@ -0,0 +1,102 @@ +/* Dependency graph analysis. + 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/dependency.h" + +#include <fstream> +#include <sstream> +#include <string.h> + +#include "elna/frontend/driver.h" +#include "elna/frontend/semantic.h" +#include "parser.hh" + +namespace elna::frontend +{ + dependency::dependency(const char *path) + : error_container(path) + { + } + + dependency read_source(std::istream& entry_point, const char *entry_path) + { + driver parse_driver{ entry_path }; + lexer tokenizer(entry_point); + yy::parser parser(tokenizer, parse_driver); + + dependency outcome{ entry_path }; + if (parser()) + { + std::swap(outcome.errors(), parse_driver.errors()); + return outcome; + } + else + { + std::swap(outcome.tree, parse_driver.tree); + } + declaration_visitor declaration_visitor(entry_path); + outcome.tree->accept(&declaration_visitor); + + if (!declaration_visitor.errors().empty()) + { + std::swap(outcome.errors(), declaration_visitor.errors()); + } + outcome.unresolved = declaration_visitor.unresolved; + + return outcome; + } + + error_list analyze_semantics(const char *path, std::unique_ptr<unit>& tree, symbol_bag bag) + { + name_analysis_visitor name_analyser(path, bag); + tree->accept(&name_analyser); + + if (name_analyser.has_errors()) + { + return std::move(name_analyser.errors()); + } + type_analysis_visitor type_analyzer(path, bag); + tree->accept(&type_analyzer); + + if (type_analyzer.has_errors()) + { + return std::move(type_analyzer.errors()); + } + return error_list{}; + } + + std::filesystem::path build_path(const std::vector<std::string>& segments) + { + std::filesystem::path result; + std::vector<std::string>::const_iterator segment_iterator = std::cbegin(segments); + + if (segment_iterator == std::cend(segments)) + { + return result; + } + result = *segment_iterator; + + ++segment_iterator; + for (; segment_iterator != std::cend(segments); ++segment_iterator) + { + result /= *segment_iterator; + } + result.replace_extension(".elna"); + + return result; + } +} diff --git a/frontend/driver.cc b/frontend/driver.cc new file mode 100644 index 0000000..1c20d09 --- /dev/null +++ b/frontend/driver.cc @@ -0,0 +1,124 @@ +/* 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 new file mode 100644 index 0000000..f14497b --- /dev/null +++ b/frontend/lexer.ll @@ -0,0 +1,320 @@ +/* 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 new file mode 100644 index 0000000..bace8d7 --- /dev/null +++ b/frontend/parser.yy @@ -0,0 +1,594 @@ +/* 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 new file mode 100644 index 0000000..aca9c5e --- /dev/null +++ b/frontend/result.cc @@ -0,0 +1,67 @@ +/* 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/semantic.cc b/frontend/semantic.cc new file mode 100644 index 0000000..36c75b8 --- /dev/null +++ b/frontend/semantic.cc @@ -0,0 +1,644 @@ +/* Name analysis. + 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/semantic.h" + +#include <algorithm> +#include <set> + +namespace elna::frontend +{ + undeclared_error::undeclared_error(const std::string& identifier, const char *path, const struct position position) + : error(path, position), identifier(identifier) + { + } + + std::string undeclared_error::what() const + { + return "Type '" + identifier + "' not declared"; + } + + already_declared_error::already_declared_error(const std::string& identifier, + const char *path, const struct position position) + : error(path, position), identifier(identifier) + { + } + + std::string already_declared_error::what() const + { + return "Symbol '" + identifier + "' has been already declared"; + } + + field_duplication_error::field_duplication_error(const std::string& field_name, + const char *path, const struct position position) + : error(path, position), field_name(field_name) + { + } + + std::string field_duplication_error::what() const + { + return "Repeated field name '" + field_name + "'"; + } + + cyclic_declaration_error::cyclic_declaration_error(const std::vector<std::string>& cycle, + const char *path, const struct position position) + : error(path, position), cycle(cycle) + { + } + + std::string cyclic_declaration_error::what() const + { + auto segment = std::cbegin(this->cycle); + std::string message = "Type declaration forms a cycle: " + *segment; + + ++segment; + for (; segment != std::cend(this->cycle); ++segment) + { + message += " -> " + *segment; + } + return message; + } + + return_error::return_error(const std::string& identifier, const char *path, const struct position position) + : error(path, position), identifier(identifier) + { + } + + std::string return_error::what() const + { + return "Procedure '" + identifier + "' is expected to return, but does not have a return statement"; + } + + variable_initializer_error::variable_initializer_error(const char *path, const struct position position) + : error(path, position) + { + } + + std::string variable_initializer_error::what() const + { + return "Only one variable can be initialized"; + } + + type_analysis_visitor::type_analysis_visitor(const char *path, symbol_bag bag) + : error_container(path), bag(bag) + { + } + + void type_analysis_visitor::visit(program *program) + { + visit(static_cast<unit *>(program)); + } + + void type_analysis_visitor::visit(procedure_declaration *definition) + { + if (definition->body.has_value() && definition->heading().return_type.proper_type != nullptr) + { + for (statement *const statement : definition->body.value().body()) + { + statement->accept(this); + } + if (!this->returns) + { + add_error<return_error>(definition->identifier.name, this->input_file, definition->position()); + } + } + } + + void type_analysis_visitor::visit(assign_statement *) + { + } + + void type_analysis_visitor::visit(if_statement *) + { + } + + void type_analysis_visitor::visit(while_statement *) + { + } + + void type_analysis_visitor::visit(return_statement *) + { + this->returns = true; + } + + void type_analysis_visitor::visit(defer_statement *) + { + } + + void type_analysis_visitor::visit(case_statement *) + { + } + + void type_analysis_visitor::visit(procedure_call *) + { + } + + bool type_analysis_visitor::check_unresolved_symbol(std::shared_ptr<alias_type> alias, + std::vector<std::string>& alias_path) + { + if (std::find(std::cbegin(alias_path), std::cend(alias_path), alias->name) != std::cend(alias_path)) + { + return false; + } + alias_path.push_back(alias->name); + + if (auto another_alias = alias->reference.get<alias_type>()) + { + return check_unresolved_symbol(another_alias, alias_path); + } + return true; + } + + void type_analysis_visitor::visit(unit *unit) + { + for (type_declaration *const type : unit->types) + { + type->accept(this); + } + for (procedure_declaration *const procedure : unit->procedures) + { + this->returns = false; + procedure->accept(this); + } + } + + void type_analysis_visitor::visit(type_declaration *definition) + { + std::vector<std::string> alias_path; + auto unresolved_type = this->bag.lookup(definition->identifier.name)->is_type()->symbol.get<alias_type>(); + + if (!check_unresolved_symbol(unresolved_type, alias_path)) + { + add_error<cyclic_declaration_error>(alias_path, this->input_file, definition->position()); + } + } + + name_analysis_visitor::name_analysis_visitor(const char *path, symbol_bag bag) + : error_container(path), bag(bag) + { + } + + procedure_type name_analysis_visitor::build_procedure(procedure_type_expression& type_expression) + { + procedure_type::return_t result_return; + + if (type_expression.return_type.no_return) + { + result_return = procedure_type::return_t(std::monostate{}); + } + else if (type_expression.return_type.proper_type != nullptr) + { + type_expression.return_type.proper_type->accept(this); + result_return = procedure_type::return_t(this->current_type); + } + else + { + result_return = procedure_type::return_t(); + } + procedure_type result_type = procedure_type(result_return); + + for (struct type_expression *parameter : type_expression.parameters) + { + parameter->accept(this); + result_type.parameters.push_back(this->current_type); + } + return result_type; + } + + void name_analysis_visitor::visit(program *program) + { + visit(static_cast<unit *>(program)); + + for (statement *const statement : program->body) + { + statement->accept(this); + } + } + + void name_analysis_visitor::visit(type_declaration *definition) + { + definition->body().accept(this); + auto resolved = this->bag.resolve(definition->identifier.name, this->current_type); + auto info = std::make_shared<type_info>(type(resolved)); + + info->exported = definition->identifier.exported; + this->bag.enter(definition->identifier.name, info); + } + + void name_analysis_visitor::visit(named_type_expression *type_expression) + { + auto unresolved_alias = this->bag.declared(type_expression->name); + + if (unresolved_alias != nullptr) + { + this->current_type = type(unresolved_alias); + } + else if (auto from_symbol_table = this->bag.lookup(type_expression->name)) + { + this->current_type = from_symbol_table->is_type()->symbol; + } + else + { + add_error<undeclared_error>(type_expression->name, this->input_file, type_expression->position()); + this->current_type = type(); + } + } + + void name_analysis_visitor::visit(pointer_type_expression *type_expression) + { + type_expression->base().accept(this); + this->current_type = type(std::make_shared<pointer_type>(this->current_type)); + } + + void name_analysis_visitor::visit(array_type_expression *type_expression) + { + type_expression->base().accept(this); + this->current_type = type(std::make_shared<array_type>(this->current_type, type_expression->size)); + } + + std::vector<type_field> name_analysis_visitor::build_composite_type(const std::vector<field_declaration>& fields) + { + std::vector<type_field> result; + std::set<std::string> field_names; + + for (auto& field : fields) + { + if (field_names.find(field.first) != field_names.cend()) + { + add_error<field_duplication_error>(field.first, this->input_file, field.second->position()); + } + else + { + field_names.insert(field.first); + field.second->accept(this); + result.push_back(std::make_pair(field.first, this->current_type)); + } + } + return result; + } + + void name_analysis_visitor::visit(record_type_expression *type_expression) + { + auto result_type = std::make_shared<record_type>(); + + result_type->fields = build_composite_type(type_expression->fields); + + this->current_type = type(result_type); + } + + void name_analysis_visitor::visit(union_type_expression *type_expression) + { + auto result_type = std::make_shared<union_type>(); + + result_type->fields = build_composite_type(type_expression->fields); + + this->current_type = type(result_type); + } + + void name_analysis_visitor::visit(procedure_type_expression *type_expression) + { + std::shared_ptr<procedure_type> result_type = + std::make_shared<procedure_type>(std::move(build_procedure(*type_expression))); + + this->current_type = type(result_type); + } + + void name_analysis_visitor::visit(enumeration_type_expression *type_expression) + { + std::shared_ptr<enumeration_type> result_type = std::make_shared<enumeration_type>(type_expression->members); + + this->current_type = type(result_type); + } + + void name_analysis_visitor::visit(variable_declaration *declaration) + { + declaration->variable_type().accept(this); + + for (const auto& variable_identifier : declaration->identifiers) + { + auto variable_symbol = std::make_shared<variable_info>(this->current_type, declaration->is_extern); + + variable_symbol->exported = variable_identifier.exported; + if (!this->bag.enter(variable_identifier.name, variable_symbol)) + { + add_error<already_declared_error>(variable_identifier.name, this->input_file, + declaration->position()); + } + } + } + + void name_analysis_visitor::visit(constant_declaration *definition) + { + definition->body().accept(this); + auto constant_symbol = std::make_shared<constant_info>(this->current_literal); + + constant_symbol->exported = definition->identifier.exported; + this->bag.enter(definition->identifier.name, constant_symbol); + } + + void name_analysis_visitor::visit(procedure_declaration *definition) + { + std::shared_ptr<procedure_info> info; + auto heading = build_procedure(definition->heading()); + + if (definition->body.has_value()) + { + info = std::make_shared<procedure_info>(heading, definition->parameter_names, this->bag.enter()); + + for (constant_declaration *const constant : definition->body.value().constants()) + { + constant->accept(this); + } + for (variable_declaration *const variable : definition->body.value().variables()) + { + variable->accept(this); + } + for (statement *const statement : definition->body.value().body()) + { + statement->accept(this); + } + this->bag.leave(); + } + else + { + info = std::make_shared<procedure_info>(heading, definition->parameter_names); + } + info->exported = definition->identifier.exported; + this->bag.enter(definition->identifier.name, info); + } + + void name_analysis_visitor::visit(assign_statement *statement) + { + statement->lvalue().accept(this); + statement->rvalue().accept(this); + } + + void name_analysis_visitor::visit(if_statement *statement) + { + statement->body().prerequisite().accept(this); + for (struct statement *const statement : statement->body().statements) + { + statement->accept(this); + } + for (const auto branch : statement->branches) + { + branch->prerequisite().accept(this); + + for (struct statement *const statement : branch->statements) + { + statement->accept(this); + } + } + if (statement->alternative != nullptr) + { + for (struct statement *const statement : *statement->alternative) + { + statement->accept(this); + } + } + } + + void name_analysis_visitor::visit(import_declaration *) + { + } + + void name_analysis_visitor::visit(while_statement *statement) + { + statement->body().prerequisite().accept(this); + for (struct statement *const statement : statement->body().statements) + { + statement->accept(this); + } + for (const auto branch : statement->branches) + { + branch->prerequisite().accept(this); + + for (struct statement *const statement : branch->statements) + { + statement->accept(this); + } + } + } + + void name_analysis_visitor::visit(return_statement *statement) + { + statement->return_expression().accept(this); + } + + void name_analysis_visitor::visit(defer_statement *statement) + { + for (struct statement *const statement : statement->statements) + { + statement->accept(this); + } + } + + void name_analysis_visitor::visit(case_statement *statement) + { + statement->condition().accept(this); + for (const switch_case& case_block : statement->cases) + { + for (expression *const case_label : case_block.labels) + { + case_label->accept(this); + } + for (struct statement *const statement : case_block.statements) + { + statement->accept(this); + } + } + if (statement->alternative != nullptr) + { + for (struct statement *const statement : *statement->alternative) + { + statement->accept(this); + } + } + } + + void name_analysis_visitor::visit(procedure_call *call) + { + call->callable().accept(this); + for (expression *const argument: call->arguments) + { + argument->accept(this); + } + } + + void name_analysis_visitor::visit(unit *unit) + { + for (type_declaration *const type : unit->types) + { + type->accept(this); + } + for (variable_declaration *const variable : unit->variables) + { + variable->accept(this); + } + for (procedure_declaration *const procedure : unit->procedures) + { + procedure->accept(this); + } + } + + void name_analysis_visitor::visit(traits_expression *trait) + { + if (!trait->parameters.empty()) + { + trait->parameters.front()->accept(this); + trait->types.push_back(this->current_type); + } + } + + void name_analysis_visitor::visit(cast_expression *expression) + { + expression->value().accept(this); + expression->target().accept(this); + expression->expression_type = this->current_type; + } + + void name_analysis_visitor::visit(binary_expression *expression) + { + expression->lhs().accept(this); + expression->rhs().accept(this); + } + + void name_analysis_visitor::visit(unary_expression *expression) + { + expression->operand().accept(this); + } + + void name_analysis_visitor::visit(variable_expression *) + { + } + + void name_analysis_visitor::visit(array_access_expression *expression) + { + expression->base().accept(this); + expression->index().accept(this); + } + + void name_analysis_visitor::visit(field_access_expression *expression) + { + expression->base().accept(this); + } + + void name_analysis_visitor::visit(dereference_expression *expression) + { + expression->base().accept(this); + } + + void name_analysis_visitor::visit(literal<std::int32_t> *literal) + { + this->current_literal = literal->value; + } + + void name_analysis_visitor::visit(literal<std::uint32_t> *literal) + { + this->current_literal = literal->value; + } + + void name_analysis_visitor::visit(literal<double> *literal) + { + this->current_literal = literal->value; + } + + void name_analysis_visitor::visit(literal<bool> *literal) + { + this->current_literal = literal->value; + } + + void name_analysis_visitor::visit(literal<unsigned char> *literal) + { + this->current_literal = literal->value; + } + + void name_analysis_visitor::visit(literal<std::nullptr_t> *literal) + { + this->current_literal = literal->value; + } + + void name_analysis_visitor::visit(literal<std::string> *literal) + { + this->current_literal = literal->value; + } + + declaration_visitor::declaration_visitor(const char *path) + : error_container(path) + { + } + + void declaration_visitor::visit(program *program) + { + visit(static_cast<unit *>(program)); + } + + void declaration_visitor::visit(import_declaration *) + { + } + + void declaration_visitor::visit(unit *unit) + { + for (import_declaration *const _import : unit->imports) + { + _import->accept(this); + } + for (type_declaration *const type : unit->types) + { + type->accept(this); + } + for (variable_declaration *const variable : unit->variables) + { + variable->accept(this); + } + for (procedure_declaration *const procedure : unit->procedures) + { + procedure->accept(this); + } + } + + void declaration_visitor::visit(type_declaration *definition) + { + const std::string& type_identifier = definition->identifier.name; + + if (!this->unresolved.insert({ type_identifier, std::make_shared<alias_type>(type_identifier) }).second) + { + add_error<already_declared_error>(definition->identifier.name, this->input_file, + definition->position()); + } + } + + void declaration_visitor::visit(variable_declaration *declaration) + { + if (declaration->has_initializer() && declaration->identifiers.size() > 1) + { + add_error<variable_initializer_error>(this->input_file, declaration->position()); + } + } + + void declaration_visitor::visit(procedure_declaration *definition) + { + if (!definition->body.has_value()) + { + return; + } + for (variable_declaration *const variable : definition->body.value().variables()) + { + variable->accept(this); + } + } +} diff --git a/frontend/symbol.cc b/frontend/symbol.cc new file mode 100644 index 0000000..bfecbd4 --- /dev/null +++ b/frontend/symbol.cc @@ -0,0 +1,427 @@ +/* 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); + } +} |