OSS/elna
1
0
Fork 0
Code Issues 12 Pull Requests Releases Activity

Rename boot namespace to frontend

Browse Source
This commit is contained in:
Eugen Wissner
2025-11-26 20:46:41 +01:00
parent c95466622a
commit 86f3034921
25 changed files with 333 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
boot/ast.cc → frontend/ast.cc
View File

@@ -15,9 +15,9 @@ 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/boot/ast.h"
#include "elna/frontend/ast.h"
namespace elna::boot
namespace elna::frontend
{
void empty_visitor::not_implemented()
{

8
boot/dependency.cc → frontend/dependency.cc
View File

@@ -15,17 +15,17 @@ 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/boot/dependency.h"
#include "elna/frontend/dependency.h"
#include <fstream>
#include <sstream>
#include <string.h>
#include "elna/boot/driver.h"
#include "elna/boot/semantic.h"
#include "elna/frontend/driver.h"
#include "elna/frontend/semantic.h"
#include "parser.hh"
namespace elna::boot
namespace elna::frontend
{
dependency::dependency(const char *path)
: error_container(path)

4
boot/driver.cc → frontend/driver.cc
View File

@@ -15,9 +15,9 @@ 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/boot/driver.h"
#include "elna/frontend/driver.h"
namespace elna::boot
namespace elna::frontend
{
position make_position(const yy::location& location)
{

2
boot/lexer.ll → frontend/lexer.ll
View File

@@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see
#include "parser.hh"
#undef YY_DECL
#define YY_DECL yy::parser::symbol_type elna::boot::lexer::lex(driver& driver)
#define YY_DECL yy::parser::symbol_type elna::frontend::lexer::lex(driver& driver)
#define yyterminate() return yy::parser::make_YYEOF(this->location)
%}

234
boot/parser.yy → frontend/parser.yy
View File

@@ -25,25 +25,20 @@ along with GCC; see the file COPYING3. If not see
%code requires {
#include <cstdint>
#include <iostream>
#include "elna/boot/driver.h"
#include "elna/frontend/driver.h"
#if !defined(yyFlexLexerOnce)
#include <FlexLexer.h>
#endif
namespace elna
{
namespace boot
namespace elna::frontend
{
class lexer;
}
}
}
%code provides {
namespace elna
{
namespace boot
namespace elna::frontend
{
class lexer: public yyFlexLexer
@@ -61,14 +56,13 @@ along with GCC; see the file COPYING3. If not see
}
}
}
%define api.token.raw
%define api.token.constructor
%define api.value.type variant
%parse-param {elna::boot::lexer& lexer}
%param {elna::boot::driver& driver}
%parse-param {elna::frontend::lexer& lexer}
%param {elna::frontend::driver& driver}
%locations
%header
@@ -129,48 +123,48 @@ along with GCC; see the file COPYING3. If not see
%left "+" "-"
%left "*" "/" "%"
%type <elna::boot::literal_expression *> literal;
%type <std::vector<elna::boot::expression *>> case_labels;
%type <elna::boot::switch_case> switch_case;
%type <std::vector<elna::boot::switch_case>> switch_cases;
%type <elna::boot::constant_declaration *> constant_declaration;
%type <std::vector<elna::boot::constant_declaration *>> constant_part constant_declarations;
%type <elna::boot::variable_declaration *> variable_declaration;
%type <std::vector<elna::boot::variable_declaration *>> variable_declarations variable_part;
%type <elna::boot::type_expression *> type_expression;
%type <std::vector<elna::boot::type_expression *>> type_expressions;
%type <elna::boot::traits_expression *> traits_expression;
%type <elna::boot::expression *> expression operand simple_expression;
%type <elna::boot::unary_expression *> unary_expression;
%type <elna::boot::binary_expression *> binary_expression;
%type <std::vector<elna::boot::expression *>> expressions actual_parameter_list;
%type <elna::boot::designator_expression *> designator_expression;
%type <elna::boot::procedure_call*> call_expression;
%type <elna::boot::return_statement *> return_statement;
%type <elna::boot::statement *> statement;
%type <std::vector<elna::boot::statement *>> required_statements optional_statements statement_part;
%type <elna::boot::procedure_declaration *> procedure_declaration;
%type <std::pair<std::vector<std::string>, elna::boot::procedure_type_expression *>> procedure_heading;
%type <elna::boot::procedure_type_expression::return_t> return_declaration;
%type <std::vector<elna::boot::procedure_declaration *>> procedure_declarations procedure_part;
%type <elna::boot::type_declaration *> type_declaration;
%type <std::vector<elna::boot::type_declaration *>> type_declarations type_part;
%type <std::unique_ptr<elna::boot::block>> block;
%type <elna::boot::field_declaration> field_declaration formal_parameter;
%type <std::vector<std::pair<std::string, elna::boot::type_expression *>>>
%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::boot::conditional_statements *>> elsif_then_statements elsif_do_statements;
%type <std::vector<elna::boot::statement *> *> else_statements;
%type <elna::boot::cast_expression *> cast_expression;
%type <elna::boot::identifier_definition> identifier_definition;
%type <std::vector<elna::boot::identifier_definition>> identifier_definitions;
%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::boot::import_declaration *>> import_declarations import_part;
%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 boot::program(boot::make_position(@1));
auto tree = new frontend::program(frontend::make_position(@1));
std::swap(tree->imports, $3);
std::swap(tree->constants, $4);
@@ -183,7 +177,7 @@ program:
}
| "module" ";" import_part constant_part type_part variable_part procedure_part "end" "."
{
auto tree = new boot::unit(boot::make_position(@1));
auto tree = new frontend::unit(frontend::make_position(@1));
std::swap(tree->imports, $3);
std::swap(tree->constants, $4);
@@ -195,7 +189,7 @@ program:
}
block: constant_part variable_part statement_part "end"
{
$$ = std::make_unique<boot::block>(std::move($1), std::move($2), std::move($3));
$$ = std::make_unique<frontend::block>(std::move($1), std::move($2), std::move($3));
}
statement_part:
/* no statements */ {}
@@ -207,8 +201,8 @@ statement_part:
$$.push_back($4);
}
identifier_definition:
IDENTIFIER "*" { $$ = boot::identifier_definition{ $1, true }; }
| IDENTIFIER { $$ = boot::identifier_definition{ $1, false }; }
IDENTIFIER "*" { $$ = frontend::identifier_definition{ $1, true }; }
| IDENTIFIER { $$ = frontend::identifier_definition{ $1, false }; }
identifier_definitions:
identifier_definition "," identifier_definitions
{
@@ -218,11 +212,11 @@ identifier_definitions:
| identifier_definition { $$.emplace_back(std::move($1)); }
return_declaration:
/* proper procedure */ {}
| "->" "!" { $$ = boot::procedure_type_expression::return_t(std::monostate{}); }
| "->" type_expression { $$ = boot::procedure_type_expression::return_t($2); }
| "->" "!" { $$ = 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 boot::procedure_type_expression(boot::make_position(@1), std::move($2));
$$.second = new frontend::procedure_type_expression(frontend::make_position(@1), std::move($2));
for (auto& [name, type] : $1)
{
$$.first.emplace_back(std::move(name));
@@ -232,12 +226,12 @@ procedure_heading: formal_parameter_list return_declaration
procedure_declaration:
"proc" identifier_definition procedure_heading ";" block ";"
{
$$ = new boot::procedure_declaration(boot::make_position(@1), std::move($2), $3.second, std::move(*$5));
$$ = 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 boot::procedure_declaration(boot::make_position(@1), std::move($2), $3.second);
$$ = new frontend::procedure_declaration(frontend::make_position(@1), std::move($2), $3.second);
std::swap($3.first, $$->parameter_names);
}
procedure_declarations:
@@ -252,44 +246,44 @@ procedure_part:
| procedure_declarations { std::swap($$, $1); }
call_expression: designator_expression actual_parameter_list
{
$$ = new boot::procedure_call(boot::make_position(@1), $1);
$$ = new frontend::procedure_call(frontend::make_position(@1), $1);
std::swap($$->arguments, $2);
}
cast_expression: "cast" "(" expression ":" type_expression ")"
{ $$ = new boot::cast_expression(boot::make_position(@1), $5, $3); }
{ $$ = new frontend::cast_expression(frontend::make_position(@1), $5, $3); }
elsif_do_statements:
"elsif" expression "do" optional_statements elsif_do_statements
{
boot::conditional_statements *branch = new boot::conditional_statements($2, std::move($4));
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<boot::statement *>(std::move($2)); }
"else" optional_statements { $$ = new std::vector<frontend::statement *>(std::move($2)); }
| { $$ = nullptr; }
elsif_then_statements:
"elsif" expression "then" optional_statements elsif_then_statements
{
boot::conditional_statements *branch = new boot::conditional_statements($2, std::move($4));
frontend::conditional_statements *branch = new frontend::conditional_statements($2, std::move($4));
std::swap($5, $$);
$$.emplace($$.begin(), branch);
}
| {}
return_statement: "return" expression
{ $$ = new boot::return_statement(boot::make_position(@1), $2); }
{ $$ = new frontend::return_statement(frontend::make_position(@1), $2); }
literal:
INTEGER { $$ = new boot::literal<std::int32_t>(boot::make_position(@1), $1); }
| WORD { $$ = new boot::literal<std::uint32_t>(boot::make_position(@1), $1); }
| FLOAT { $$ = new boot::literal<double>(boot::make_position(@1), $1); }
| BOOLEAN { $$ = new boot::literal<bool>(boot::make_position(@1), $1); }
| CHARACTER { $$ = new boot::literal<unsigned char>(boot::make_position(@1), $1.at(0)); }
| "nil" { $$ = new boot::literal<std::nullptr_t>(boot::make_position(@1), nullptr); }
| STRING { $$ = new boot::literal<std::string>(boot::make_position(@1), $1); }
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 boot::traits_expression(boot::make_position(@1), $1);
$$ = new frontend::traits_expression(frontend::make_position(@1), $1);
std::swap($3, $$->parameters);
}
simple_expression:
@@ -308,82 +302,82 @@ expression:
binary_expression:
expression "*" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::multiplication);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::multiplication);
}
| expression "/" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::division);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::division);
}
| expression "%" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::remainder);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::remainder);
}
| expression "+" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::sum);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::sum);
}
| expression "-" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::subtraction);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::subtraction);
}
| expression "=" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::equals);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::equals);
}
| expression "<>" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::not_equals);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::not_equals);
}
| expression "<" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::less);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::less);
}
| expression ">" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::greater);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::greater);
}
| expression "<=" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3,
boot::binary_operator::less_equal);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3,
frontend::binary_operator::less_equal);
}
| expression ">=" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::greater_equal);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::greater_equal);
}
| expression "&" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::conjunction);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::conjunction);
}
| expression "or" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::disjunction);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::disjunction);
}
| expression "xor" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3,
boot::binary_operator::exclusive_disjunction);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3,
frontend::binary_operator::exclusive_disjunction);
}
| expression "<<" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::shift_left);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::shift_left);
}
| expression ">>" expression
{
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::shift_right);
$$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::shift_right);
}
unary_expression:
"@" operand
{
$$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::reference);
$$ = new frontend::unary_expression(frontend::make_position(@1), $2, frontend::unary_operator::reference);
}
| "~" operand
{
$$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::negation);
$$ = new frontend::unary_expression(frontend::make_position(@1), $2, frontend::unary_operator::negation);
}
| "-" operand
{
$$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::minus);
$$ = new frontend::unary_expression(frontend::make_position(@1), $2, frontend::unary_operator::minus);
}
expressions:
expression "," expressions
@@ -401,31 +395,31 @@ type_expressions:
| type_expression { $$.push_back($1); }
designator_expression:
simple_expression "[" expression "]"
{ $$ = new boot::array_access_expression(boot::make_position(@2), $1, $3); }
{ $$ = new frontend::array_access_expression(frontend::make_position(@2), $1, $3); }
| simple_expression "." IDENTIFIER
{ $$ = new boot::field_access_expression(boot::make_position(@2), $1, $3); }
{ $$ = new frontend::field_access_expression(frontend::make_position(@2), $1, $3); }
| simple_expression "^"
{ $$ = new boot::dereference_expression(boot::make_position(@1), $1); }
{ $$ = new frontend::dereference_expression(frontend::make_position(@1), $1); }
| IDENTIFIER
{ $$ = new boot::variable_expression(boot::make_position(@1), $1); }
{ $$ = new frontend::variable_expression(frontend::make_position(@1), $1); }
statement:
designator_expression ":=" expression
{ $$ = new boot::assign_statement(boot::make_position(@1), $1, $3); }
{ $$ = new frontend::assign_statement(frontend::make_position(@1), $1, $3); }
| "while" expression "do" optional_statements elsif_do_statements "end"
{
boot::conditional_statements *body = new boot::conditional_statements($2, std::move($4));
$$ = new boot::while_statement(boot::make_position(@1), body, std::move($5));
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"
{
boot::conditional_statements *then = new boot::conditional_statements($2, std::move($4));
$$ = new boot::if_statement(boot::make_position(@1), then, std::move($5), $6);
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 boot::defer_statement(boot::make_position(@1), std::move($2)); }
{ $$ = new frontend::defer_statement(frontend::make_position(@1), std::move($2)); }
| "case" expression "of" switch_cases else_statements "end"
{ $$ = new boot::case_statement(boot::make_position(@1), $2, std::move($4), $5); }
{ $$ = 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:
@@ -467,33 +461,33 @@ optional_fields:
type_expression:
"[" INTEGER "]" type_expression
{
$$ = new boot::array_type_expression(boot::make_position(@1), $4, $2);
$$ = new frontend::array_type_expression(frontend::make_position(@1), $4, $2);
}
| "^" type_expression
{
$$ = new boot::pointer_type_expression(boot::make_position(@1), $2);
$$ = new frontend::pointer_type_expression(frontend::make_position(@1), $2);
}
| "record" optional_fields "end"
{
$$ = new boot::record_type_expression(boot::make_position(@1), std::move($2));
$$ = new frontend::record_type_expression(frontend::make_position(@1), std::move($2));
}
| "union" required_fields "end"
{
$$ = new boot::union_type_expression(boot::make_position(@1), std::move($2));
$$ = new frontend::union_type_expression(frontend::make_position(@1), std::move($2));
}
| "proc" "(" type_expressions ")" return_declaration
{
auto result = new boot::procedure_type_expression(boot::make_position(@1), std::move($5));
auto result = new frontend::procedure_type_expression(frontend::make_position(@1), std::move($5));
std::swap(result->parameters, $3);
$$ = result;
}
| "(" identifiers ")"
{
$$ = new boot::enumeration_type_expression(boot::make_position(@1), std::move($2));
$$ = new frontend::enumeration_type_expression(frontend::make_position(@1), std::move($2));
}
| IDENTIFIER
{
$$ = new boot::named_type_expression(boot::make_position(@1), $1);
$$ = new frontend::named_type_expression(frontend::make_position(@1), $1);
}
identifiers:
IDENTIFIER "," identifiers
@@ -505,19 +499,19 @@ identifiers:
variable_declaration:
identifier_definitions ":" type_expression ";"
{
std::shared_ptr<boot::type_expression> shared_type{ $3 };
$$ = new boot::variable_declaration( boot::make_position(@2), std::move($1), shared_type);
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<boot::type_expression> shared_type{ $3 };
$$ = new boot::variable_declaration( boot::make_position(@2), std::move($1), shared_type,
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<boot::type_expression> shared_type{ $3 };
$$ = new boot::variable_declaration( boot::make_position(@2), std::move($1), shared_type, $5);
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 */ {}
@@ -531,7 +525,7 @@ variable_part:
| "var" variable_declarations { std::swap($$, $2); }
constant_declaration: identifier_definition ":=" expression ";"
{
$$ = new boot::constant_declaration(boot::make_position(@1), std::move($1), $3);
$$ = new frontend::constant_declaration(frontend::make_position(@1), std::move($1), $3);
}
constant_declarations:
constant_declaration constant_declarations
@@ -554,18 +548,18 @@ import_declarations:
import_declaration "," import_declarations
{
std::swap($$, $3);
$$.emplace($$.cbegin(), new boot::import_declaration(boot::make_position(@1), std::move($1)));
$$.emplace($$.cbegin(), new frontend::import_declaration(frontend::make_position(@1), std::move($1)));
}
| import_declaration
{
$$.emplace_back(new boot::import_declaration(boot::make_position(@1), std::move($1)));
$$.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 boot::type_declaration(boot::make_position(@1), std::move($1), $3);
$$ = new frontend::type_declaration(frontend::make_position(@1), std::move($1), $3);
}
type_declarations:
type_declaration type_declarations
@@ -596,5 +590,5 @@ actual_parameter_list:
void yy::parser::error(const location_type& loc, const std::string& message)
{
driver.add_error<boot::syntax_error>(message, driver.input_file, loc);
driver.add_error<frontend::syntax_error>(message, driver.input_file, loc);
}

8
boot/result.cc → frontend/result.cc
View File

@@ -15,9 +15,9 @@ 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/boot/result.h"
#include "elna/frontend/result.h"
namespace elna::boot
namespace elna::frontend
{
error::error(const char *path, const struct position position)
: position(position), path(path)
@@ -60,8 +60,8 @@ namespace elna::boot
}
}
std::size_t std::hash<elna::boot::identifier_definition>::operator()(
const elna::boot::identifier_definition& key) const
std::size_t std::hash<elna::frontend::identifier_definition>::operator()(
const elna::frontend::identifier_definition& key) const
{
return std::hash<std::string>{}(key.name);
}

6
boot/semantic.cc → frontend/semantic.cc
View File

@@ -15,12 +15,12 @@ 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/boot/semantic.h"
#include "elna/frontend/semantic.h"
#include <algorithm>
#include <set>
namespace elna::boot
namespace elna::frontend
{
undeclared_error::undeclared_error(const std::string& identifier, const char *path, const struct position position)
: error(path, position), identifier(identifier)
@@ -636,7 +636,7 @@ namespace elna::boot
{
return;
}
for (boot::variable_declaration *const variable : definition->body.value().variables())
for (variable_declaration *const variable : definition->body.value().variables())
{
variable->accept(this);
}

4
boot/symbol.cc → frontend/symbol.cc
View File

@@ -15,9 +15,9 @@ 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/boot/symbol.h"
#include "elna/frontend/symbol.h"
namespace elna::boot
namespace elna::frontend
{
type::type()
{

6
gcc/Make-lang.in
View File

@@ -150,7 +150,7 @@ elna.stagefeedback: stagefeedback-start
ELNA_INCLUDES = -I $(srcdir)/elna/include -I elna/generated
ELNA_CXXFLAGS = -std=c++17
elna/%.o: elna/boot/%.cc elna/generated/parser.hh elna/generated/location.hh
elna/%.o: elna/frontend/%.cc elna/generated/parser.hh elna/generated/location.hh
$(COMPILE) $(ELNA_CXXFLAGS) $(ELNA_INCLUDES) $<
$(POSTCOMPILE)
@@ -162,13 +162,13 @@ elna/%.o: elna/gcc/%.cc elna/generated/parser.hh elna/generated/location.hh
$(COMPILE) $(ELNA_CXXFLAGS) $(ELNA_INCLUDES) $<
$(POSTCOMPILE)
elna/generated/parser.cc: elna/boot/parser.yy
elna/generated/parser.cc: elna/frontend/parser.yy
mkdir -p $(dir $@)
$(BISON) -d -o $@ $<
elna/generated/parser.hh elna/generated/location.hh: elna/generated/parser.cc
@touch $@
elna/generated/lexer.cc: elna/boot/lexer.ll
elna/generated/lexer.cc: elna/frontend/lexer.ll
mkdir -p $(dir $@)
$(FLEX) -o $@ $<

36
gcc/elna-builtins.cc
View File

@@ -80,7 +80,7 @@ namespace elna::gcc
return symbol_table;
}
tree build_composite_type(const std::vector<boot::type_field>& fields, tree composite_type_node,
tree build_composite_type(const std::vector<frontend::type_field>& fields, tree composite_type_node,
std::shared_ptr<symbol_table> symbols)
{
for (auto& field : fields)
@@ -94,7 +94,7 @@ namespace elna::gcc
return composite_type_node;
}
tree build_procedure_type(const boot::procedure_type& procedure, std::shared_ptr<symbol_table> symbols)
tree build_procedure_type(const frontend::procedure_type& procedure, std::shared_ptr<symbol_table> symbols)
{
std::vector<tree> parameter_types(procedure.parameters.size());
@@ -111,16 +111,16 @@ namespace elna::gcc
return build_function_type_array(return_type, procedure.parameters.size(), parameter_types.data());
}
tree get_inner_alias(const boot::type& type, std::shared_ptr<symbol_table> symbols)
tree get_inner_alias(const frontend::type& type, std::shared_ptr<symbol_table> symbols)
{
if (auto reference = type.get<boot::primitive_type>())
if (auto reference = type.get<frontend::primitive_type>())
{
auto looked_up = symbols->lookup(reference->identifier);
gcc_assert(looked_up != NULL_TREE);
return TREE_TYPE(looked_up);
}
else if (auto reference = type.get<boot::record_type>())
else if (auto reference = type.get<frontend::record_type>())
{
tree composite_type_node = make_node(RECORD_TYPE);
@@ -128,7 +128,7 @@ namespace elna::gcc
return composite_type_node;
}
else if (auto reference = type.get<boot::union_type>())
else if (auto reference = type.get<frontend::union_type>())
{
tree composite_type_node = make_node(UNION_TYPE);
@@ -136,34 +136,34 @@ namespace elna::gcc
return composite_type_node;
}
else if (auto reference = type.get<boot::enumeration_type>())
else if (auto reference = type.get<frontend::enumeration_type>())
{
return build_enumeration_type(reference->members);
}
else if (auto reference = type.get<boot::pointer_type>())
else if (auto reference = type.get<frontend::pointer_type>())
{
return build_global_pointer_type(get_inner_alias(reference->base, symbols));
}
else if (auto reference = type.get<boot::array_type>())
else if (auto reference = type.get<frontend::array_type>())
{
tree base = get_inner_alias(reference->base, symbols);
return build_static_array_type(base, reference->size);
}
else if (auto reference = type.get<boot::procedure_type>())
else if (auto reference = type.get<frontend::procedure_type>())
{
auto procedure = build_procedure_type(*reference, symbols);
return build_global_pointer_type(procedure);
}
else if (auto reference = type.get<boot::alias_type>())
else if (auto reference = type.get<frontend::alias_type>())
{
return TREE_TYPE(handle_symbol(reference->name, reference, symbols));
}
return error_mark_node;
}
tree handle_symbol(const std::string& symbol_name, std::shared_ptr<boot::alias_type> reference,
tree handle_symbol(const std::string& symbol_name, std::shared_ptr<frontend::alias_type> reference,
std::shared_ptr<symbol_table> symbols)
{
tree looked_up = symbols->lookup(symbol_name);
@@ -189,7 +189,7 @@ namespace elna::gcc
return looked_up;
}
void declare_procedure(const std::string& name, const boot::procedure_info& info,
void declare_procedure(const std::string& name, const frontend::procedure_info& info,
std::shared_ptr<symbol_table> symbols)
{
tree declaration_type = gcc::build_procedure_type(info.symbol, symbols);
@@ -210,7 +210,7 @@ namespace elna::gcc
std::vector<std::string>::const_iterator parameter_name = info.names.cbegin();
for (boot::type parameter : info.symbol.parameters)
for (frontend::type parameter : info.symbol.parameters)
{
tree declaration_tree = build_decl(UNKNOWN_LOCATION, PARM_DECL,
get_identifier(parameter_name->c_str()), function_args_iter_cond(&parameter_type));
@@ -227,7 +227,7 @@ namespace elna::gcc
TREE_PUBLIC(fndecl) = info.exported;
}
tree declare_variable(const std::string& name, const boot::variable_info& info,
tree declare_variable(const std::string& name, const frontend::variable_info& info,
std::shared_ptr<symbol_table> symbols)
{
auto variable_type = get_inner_alias(info.symbol, symbols);
@@ -242,10 +242,10 @@ namespace elna::gcc
return declaration_tree;
}
void declare_type(const std::string& name, const boot::type_info& info, std::shared_ptr<symbol_table> symbols)
void declare_type(const std::string& name, const frontend::type_info& info, std::shared_ptr<symbol_table> symbols)
{
// The top level symbol table has basic (builtin) types in it which are not aliases.
if (auto alias_type = info.symbol.get<boot::alias_type>())
if (auto alias_type = info.symbol.get<frontend::alias_type>())
{
tree type_declaration = handle_symbol(name, alias_type, symbols);
@@ -253,7 +253,7 @@ namespace elna::gcc
}
}
void rewrite_symbol_table(std::shared_ptr<boot::symbol_table> info_table, std::shared_ptr<symbol_table> symbols)
void rewrite_symbol_table(std::shared_ptr<frontend::symbol_table> info_table, std::shared_ptr<symbol_table> symbols)
{
for (auto& [symbol_name, symbol_info] : *info_table)
{

4
gcc/elna-diagnostic.cc
View File

@@ -31,7 +31,7 @@ namespace elna::gcc
linemap_add(line_table, LC_LEAVE, 0, NULL, 0);
}
location_t get_location(const boot::position *position)
location_t get_location(const frontend::position *position)
{
linemap_line_start(line_table, position->line, 0);
@@ -151,7 +151,7 @@ namespace elna::gcc
gcc_unreachable();
}
void report_errors(const std::deque<std::unique_ptr<boot::error>>& errors)
void report_errors(const std::deque<std::unique_ptr<frontend::error>>& errors)
{
for (const auto& error : errors)
{

170
gcc/elna-generic.cc
View File

@@ -35,13 +35,13 @@ along with GCC; see the file COPYING3. If not see
namespace elna::gcc
{
generic_visitor::generic_visitor(std::shared_ptr<symbol_table> symbol_table, elna::boot::symbol_bag bag)
generic_visitor::generic_visitor(std::shared_ptr<symbol_table> symbol_table, elna::frontend::symbol_bag bag)
: bag(bag), symbols(symbol_table)
{
}
void generic_visitor::build_procedure_call(location_t call_location,
tree procedure_address, const std::vector<boot::expression *>& arguments)
tree procedure_address, const std::vector<frontend::expression *>& arguments)
{
vec<tree, va_gc> *argument_trees = nullptr;
tree symbol_type = TREE_TYPE(TREE_TYPE(procedure_address));
@@ -49,7 +49,7 @@ namespace elna::gcc
tree current_parameter = TYPE_ARG_TYPES(symbol_type);
vec_alloc(argument_trees, arguments.size());
for (boot::expression *const argument : arguments)
for (frontend::expression *const argument : arguments)
{
location_t argument_location = get_location(&argument->position());
if (VOID_TYPE_P(TREE_VALUE(current_parameter)))
@@ -88,11 +88,11 @@ namespace elna::gcc
}
void generic_visitor::build_record_call(location_t call_location,
tree symbol, const std::vector<boot::expression *>& arguments)
tree symbol, const std::vector<frontend::expression *>& arguments)
{
vec<constructor_elt, va_gc> *tree_arguments = nullptr;
tree record_fields = TYPE_FIELDS(symbol);
for (boot::expression *const argument : arguments)
for (frontend::expression *const argument : arguments)
{
location_t argument_location = get_location(&argument->position());
@@ -129,7 +129,7 @@ namespace elna::gcc
}
void generic_visitor::build_assert_builtin(location_t call_location,
const std::vector<boot::expression *>& arguments)
const std::vector<frontend::expression *>& arguments)
{
if (arguments.size() != 1)
{
@@ -165,11 +165,11 @@ namespace elna::gcc
}
}
bool generic_visitor::build_builtin_procedures(boot::procedure_call *call)
bool generic_visitor::build_builtin_procedures(frontend::procedure_call *call)
{
location_t call_location = get_location(&call->position());
if (boot::variable_expression *named_call = call->callable().is_variable())
if (frontend::variable_expression *named_call = call->callable().is_variable())
{
if (named_call->name == "assert")
{
@@ -180,7 +180,7 @@ namespace elna::gcc
return false;
}
void generic_visitor::visit(boot::procedure_call *call)
void generic_visitor::visit(frontend::procedure_call *call)
{
if (build_builtin_procedures(call))
{
@@ -215,7 +215,7 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::cast_expression *expression)
void generic_visitor::visit(frontend::cast_expression *expression)
{
tree cast_target = get_inner_alias(expression->expression_type, this->symbols->scope());
@@ -235,9 +235,9 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::program *program)
void generic_visitor::visit(frontend::program *program)
{
visit(static_cast<boot::unit *>(program));
visit(static_cast<frontend::unit *>(program));
tree declaration_type = build_function_type_list(elna_int_type_node,
elna_int_type_node,
@@ -285,27 +285,27 @@ namespace elna::gcc
cgraph_node::finalize_function(fndecl, true);
}
void generic_visitor::visit(boot::unit *unit)
void generic_visitor::visit(frontend::unit *unit)
{
for (boot::import_declaration *const declaration : unit->imports)
for (frontend::import_declaration *const declaration : unit->imports)
{
declaration->accept(this);
}
for (boot::constant_declaration *const constant : unit->constants)
for (frontend::constant_declaration *const constant : unit->constants)
{
constant->accept(this);
}
for (boot::variable_declaration *const variable : unit->variables)
for (frontend::variable_declaration *const variable : unit->variables)
{
variable->accept(this);
}
for (boot::procedure_declaration *const procedure : unit->procedures)
for (frontend::procedure_declaration *const procedure : unit->procedures)
{
procedure->accept(this);
}
}
void generic_visitor::visit(boot::procedure_declaration *definition)
void generic_visitor::visit(frontend::procedure_declaration *definition)
{
tree fndecl = this->symbols->lookup(definition->identifier.name);
@@ -324,11 +324,11 @@ namespace elna::gcc
{
this->symbols->enter(IDENTIFIER_POINTER(DECL_NAME(argument_chain)), argument_chain);
}
for (boot::constant_declaration *const constant : definition->body.value().constants())
for (frontend::constant_declaration *const constant : definition->body.value().constants())
{
constant->accept(this);
}
for (boot::variable_declaration *const variable : definition->body.value().variables())
for (frontend::variable_declaration *const variable : definition->body.value().variables())
{
variable->accept(this);
}
@@ -381,17 +381,17 @@ namespace elna::gcc
return bind_expr;
}
void generic_visitor::visit(boot::literal<std::int32_t> *literal)
void generic_visitor::visit(frontend::literal<std::int32_t> *literal)
{
this->current_expression = build_int_cst(elna_int_type_node, literal->value);
}
void generic_visitor::visit(boot::literal<std::uint32_t> *literal)
void generic_visitor::visit(frontend::literal<std::uint32_t> *literal)
{
this->current_expression = build_int_cstu(elna_word_type_node, literal->value);
}
void generic_visitor::visit(boot::literal<double> *literal)
void generic_visitor::visit(frontend::literal<double> *literal)
{
REAL_VALUE_TYPE real_value1;
@@ -406,22 +406,22 @@ namespace elna::gcc
mpfr_clear(number);
}
void generic_visitor::visit(boot::literal<bool> *boolean)
void generic_visitor::visit(frontend::literal<bool> *boolean)
{
this->current_expression = boolean->value ? boolean_true_node : boolean_false_node;
}
void generic_visitor::visit(boot::literal<unsigned char> *character)
void generic_visitor::visit(frontend::literal<unsigned char> *character)
{
this->current_expression = build_int_cstu(elna_char_type_node, character->value);
}
void generic_visitor::visit(boot::literal<nullptr_t> *)
void generic_visitor::visit(frontend::literal<nullptr_t> *)
{
this->current_expression = elna_pointer_nil_node;
}
void generic_visitor::visit(boot::literal<std::string> *string)
void generic_visitor::visit(frontend::literal<std::string> *string)
{
tree index_constant = build_int_cstu(elna_word_type_node, string->value.size());
tree string_type = build_array_type(elna_char_type_node, build_index_type(index_constant));
@@ -444,38 +444,38 @@ namespace elna::gcc
this->current_expression = build_constructor(elna_string_type_node, elms);
}
tree generic_visitor::build_arithmetic_operation(boot::binary_expression *expression,
tree generic_visitor::build_arithmetic_operation(frontend::binary_expression *expression,
tree_code operator_code, tree left, tree right)
{
return build_binary_operation(is_numeric_type(TREE_TYPE(left)),
expression, operator_code, left, right, TREE_TYPE(left));
}
tree generic_visitor::build_comparison_operation(boot::binary_expression *expression,
tree generic_visitor::build_comparison_operation(frontend::binary_expression *expression,
tree_code operator_code, tree left, tree right)
{
return build_binary_operation(is_numeric_type(TREE_TYPE(left)) || POINTER_TYPE_P(TREE_TYPE(left)),
expression, operator_code, left, right, elna_bool_type_node);
}
tree generic_visitor::build_bit_logic_operation(boot::binary_expression *expression, tree left, tree right)
tree generic_visitor::build_bit_logic_operation(frontend::binary_expression *expression, tree left, tree right)
{
location_t expression_location = get_location(&expression->position());
tree left_type = TREE_TYPE(left);
tree right_type = TREE_TYPE(right);
tree_code logical_code, bit_code;
if (expression->operation() == boot::binary_operator::conjunction)
if (expression->operation() == frontend::binary_operator::conjunction)
{
bit_code = BIT_AND_EXPR;
logical_code = TRUTH_ANDIF_EXPR;
}
else if (expression->operation() == boot::binary_operator::disjunction)
else if (expression->operation() == frontend::binary_operator::disjunction)
{
bit_code = BIT_IOR_EXPR;
logical_code = TRUTH_ORIF_EXPR;
}
else if (expression->operation() == boot::binary_operator::exclusive_disjunction)
else if (expression->operation() == frontend::binary_operator::exclusive_disjunction)
{
bit_code = BIT_XOR_EXPR;
logical_code = TRUTH_XOR_EXPR;
@@ -496,22 +496,22 @@ namespace elna::gcc
{
error_at(expression_location, "Invalid operands of type '%s' and '%s' for operator %s",
print_type(left_type).c_str(), print_type(right_type).c_str(),
elna::boot::print_binary_operator(expression->operation()));
elna::frontend::print_binary_operator(expression->operation()));
return error_mark_node;
}
}
tree generic_visitor::build_equality_operation(boot::binary_expression *expression, tree left, tree right)
tree generic_visitor::build_equality_operation(frontend::binary_expression *expression, tree left, tree right)
{
location_t expression_location = get_location(&expression->position());
tree_code equality_code, combination_code;
if (expression->operation() == boot::binary_operator::equals)
if (expression->operation() == frontend::binary_operator::equals)
{
equality_code = EQ_EXPR;
combination_code = TRUTH_ANDIF_EXPR;
}
else if (expression->operation() == boot::binary_operator::not_equals)
else if (expression->operation() == frontend::binary_operator::not_equals)
{
equality_code = NE_EXPR;
combination_code = TRUTH_ORIF_EXPR;
@@ -545,7 +545,7 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::binary_expression *expression)
void generic_visitor::visit(frontend::binary_expression *expression)
{
expression->lhs().accept(this);
tree left = this->current_expression;
@@ -558,8 +558,8 @@ namespace elna::gcc
location_t expression_location = get_location(&expression->position());
if ((POINTER_TYPE_P(left_type) || POINTER_TYPE_P(right_type))
&& (expression->operation() == boot::binary_operator::sum
|| expression->operation() == boot::binary_operator::subtraction))
&& (expression->operation() == frontend::binary_operator::sum
|| expression->operation() == frontend::binary_operator::subtraction))
{
this->current_expression = do_pointer_arithmetic(expression->operation(),
left, right, expression_location);
@@ -567,7 +567,7 @@ namespace elna::gcc
{
error_at(expression_location,
"invalid operation %s on a pointer and an integral type",
boot::print_binary_operator(expression->operation()));
frontend::print_binary_operator(expression->operation()));
}
else if (TREE_TYPE(this->current_expression) == ssizetype)
{
@@ -583,60 +583,60 @@ namespace elna::gcc
error_at(expression_location,
"invalid operands of type '%s' and '%s' for operator %s",
print_type(left_type).c_str(), print_type(right_type).c_str(),
boot::print_binary_operator(expression->operation()));
frontend::print_binary_operator(expression->operation()));
this->current_expression = error_mark_node;
return;
}
switch (expression->operation())
{
case boot::binary_operator::sum:
case frontend::binary_operator::sum:
this->current_expression = build_arithmetic_operation(expression, PLUS_EXPR, left, right);
break;
case boot::binary_operator::subtraction:
case frontend::binary_operator::subtraction:
this->current_expression = build_arithmetic_operation(expression, MINUS_EXPR, left, right);
break;
case boot::binary_operator::division:
case frontend::binary_operator::division:
this->current_expression = build_arithmetic_operation(expression, TRUNC_DIV_EXPR, left, right);
break;
case boot::binary_operator::remainder:
case frontend::binary_operator::remainder:
this->current_expression = build_arithmetic_operation(expression, TRUNC_MOD_EXPR, left, right);
break;
case boot::binary_operator::multiplication:
case frontend::binary_operator::multiplication:
this->current_expression = build_arithmetic_operation(expression, MULT_EXPR, left, right);
break;
case boot::binary_operator::less:
case frontend::binary_operator::less:
this->current_expression = build_comparison_operation(expression, LT_EXPR, left, right);
break;
case boot::binary_operator::greater:
case frontend::binary_operator::greater:
this->current_expression = build_comparison_operation(expression, GT_EXPR, left, right);
break;
case boot::binary_operator::less_equal:
case frontend::binary_operator::less_equal:
this->current_expression = build_comparison_operation(expression, LE_EXPR, left, right);
break;
case boot::binary_operator::greater_equal:
case frontend::binary_operator::greater_equal:
this->current_expression = build_comparison_operation(expression, GE_EXPR, left, right);
break;
case boot::binary_operator::conjunction:
case frontend::binary_operator::conjunction:
this->current_expression = build_bit_logic_operation(expression, left, right);
break;
case boot::binary_operator::disjunction:
case frontend::binary_operator::disjunction:
this->current_expression = build_bit_logic_operation(expression, left, right);
break;
case boot::binary_operator::exclusive_disjunction:
case frontend::binary_operator::exclusive_disjunction:
this->current_expression = build_bit_logic_operation(expression, left, right);
break;
case boot::binary_operator::equals:
case frontend::binary_operator::equals:
this->current_expression = build_equality_operation(expression, left, right);
break;
case boot::binary_operator::not_equals:
case frontend::binary_operator::not_equals:
this->current_expression = build_equality_operation(expression, left, right);
break;
case boot::binary_operator::shift_left:
case frontend::binary_operator::shift_left:
this->current_expression = build_binary_operation(
is_numeric_type(left_type) && right_type == elna_word_type_node,
expression, LSHIFT_EXPR, left, right, left_type);
break;
case boot::binary_operator::shift_right:
case frontend::binary_operator::shift_right:
this->current_expression = build_binary_operation(
is_numeric_type(left_type) && right_type == elna_word_type_node,
expression, RSHIFT_EXPR, left, right, left_type);
@@ -644,14 +644,14 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::unary_expression *expression)
void generic_visitor::visit(frontend::unary_expression *expression)
{
expression->operand().accept(this);
location_t location = get_location(&expression->position());
switch (expression->operation())
{
case boot::unary_operator::reference:
case frontend::unary_operator::reference:
this->current_expression = prepare_rvalue(this->current_expression);
TREE_ADDRESSABLE(this->current_expression) = 1;
this->current_expression = build_fold_addr_expr_with_type_loc(location,
@@ -659,7 +659,7 @@ namespace elna::gcc
build_global_pointer_type(TREE_TYPE(this->current_expression)));
TREE_NO_TRAMPOLINE(this->current_expression) = 1;
break;
case boot::unary_operator::negation:
case frontend::unary_operator::negation:
if (TREE_TYPE(this->current_expression) == elna_bool_type_node)
{
this->current_expression = build1_loc(location, TRUTH_NOT_EXPR,
@@ -677,7 +677,7 @@ namespace elna::gcc
this->current_expression = error_mark_node;
}
break;
case boot::unary_operator::minus:
case frontend::unary_operator::minus:
if (is_integral_type(TREE_TYPE(this->current_expression)))
{
this->current_expression = fold_build1(NEGATE_EXPR, TREE_TYPE(this->current_expression),
@@ -692,7 +692,7 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::constant_declaration *definition)
void generic_visitor::visit(frontend::constant_declaration *definition)
{
location_t definition_location = get_location(&definition->position());
definition->body().accept(this);
@@ -732,7 +732,7 @@ namespace elna::gcc
this->current_expression = NULL_TREE;
}
void generic_visitor::visit(boot::variable_declaration *declaration)
void generic_visitor::visit(frontend::variable_declaration *declaration)
{
for (const auto& variable_identifier : declaration->identifiers)
{
@@ -784,7 +784,7 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::variable_expression *expression)
void generic_visitor::visit(frontend::variable_expression *expression)
{
auto symbol = this->symbols->lookup(expression->name);
@@ -800,7 +800,7 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::array_access_expression *expression)
void generic_visitor::visit(frontend::array_access_expression *expression)
{
expression->base().accept(this);
tree designator = this->current_expression;
@@ -829,7 +829,7 @@ namespace elna::gcc
tree string_ptr = build3_loc(location, COMPONENT_REF, TREE_TYPE(elna_string_ptr_field_node),
designator, elna_string_ptr_field_node, NULL_TREE);
tree target_pointer = do_pointer_arithmetic(boot::binary_operator::sum, string_ptr, offset, location);
tree target_pointer = do_pointer_arithmetic(frontend::binary_operator::sum, string_ptr, offset, location);
this->current_expression = build1_loc(location, INDIRECT_REF,
elna_char_type_node, target_pointer);
@@ -842,7 +842,7 @@ namespace elna::gcc
}
}
bool generic_visitor::expect_trait_type_only(boot::traits_expression *trait)
bool generic_visitor::expect_trait_type_only(frontend::traits_expression *trait)
{
if (trait->parameters.size() != 1)
{
@@ -856,7 +856,7 @@ namespace elna::gcc
return this->current_expression != error_mark_node;
}
bool generic_visitor::expect_trait_for_integral_type(boot::traits_expression *trait)
bool generic_visitor::expect_trait_for_integral_type(frontend::traits_expression *trait)
{
if (!expect_trait_type_only(trait))
{
@@ -872,7 +872,7 @@ namespace elna::gcc
return true;
}
void generic_visitor::visit(boot::traits_expression *trait)
void generic_visitor::visit(frontend::traits_expression *trait)
{
location_t trait_location = get_location(&trait->position());
@@ -945,7 +945,7 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::field_access_expression *expression)
void generic_visitor::visit(frontend::field_access_expression *expression)
{
expression->base().accept(this);
location_t expression_location = get_location(&expression->position());
@@ -991,7 +991,7 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::dereference_expression *expression)
void generic_visitor::visit(frontend::dereference_expression *expression)
{
expression->base().accept(this);
location_t expression_location = get_location(&expression->position());
@@ -1010,7 +1010,7 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::assign_statement *statement)
void generic_visitor::visit(frontend::assign_statement *statement)
{
statement->lvalue().accept(this);
@@ -1045,7 +1045,7 @@ namespace elna::gcc
this->current_expression = NULL_TREE;
}
void generic_visitor::visit(boot::if_statement *statement)
void generic_visitor::visit(frontend::if_statement *statement)
{
tree endif_label_decl = create_artificial_label(UNKNOWN_LOCATION);
tree goto_endif = build1(GOTO_EXPR, void_type_node, endif_label_decl);
@@ -1068,7 +1068,7 @@ namespace elna::gcc
this->current_expression = NULL_TREE;
}
void generic_visitor::make_if_branch(boot::conditional_statements& branch, tree goto_endif)
void generic_visitor::make_if_branch(frontend::conditional_statements& branch, tree goto_endif)
{
branch.prerequisite().accept(this);
@@ -1102,11 +1102,11 @@ namespace elna::gcc
append_statement(else_label_expr);
}
void generic_visitor::visit(boot::import_declaration *)
void generic_visitor::visit(frontend::import_declaration *)
{
}
void generic_visitor::visit(boot::while_statement *statement)
void generic_visitor::visit(frontend::while_statement *statement)
{
location_t prerequisite_location = get_location(&statement->body().prerequisite().position());
tree prerequisite_label_decl = build_label_decl("while_do", prerequisite_location);
@@ -1127,9 +1127,9 @@ namespace elna::gcc
this->current_expression = NULL_TREE;
}
void generic_visitor::visit_statements(const std::vector<boot::statement *>& statements)
void generic_visitor::visit_statements(const std::vector<frontend::statement *>& statements)
{
for (boot::statement *const statement : statements)
for (frontend::statement *const statement : statements)
{
statement->accept(this);
@@ -1141,9 +1141,9 @@ namespace elna::gcc
}
}
void generic_visitor::visit(boot::return_statement *statement)
void generic_visitor::visit(frontend::return_statement *statement)
{
boot::expression *return_expression = &statement->return_expression();
frontend::expression *return_expression = &statement->return_expression();
location_t statement_position = get_location(&statement->position());
tree set_result{ NULL_TREE };
tree return_type = TREE_TYPE(TREE_TYPE(current_function_decl));
@@ -1183,14 +1183,14 @@ namespace elna::gcc
this->current_expression = NULL_TREE;
}
void generic_visitor::visit(boot::defer_statement *statement)
void generic_visitor::visit(frontend::defer_statement *statement)
{
enter_scope();
visit_statements(statement->statements);
defer(leave_scope());
}
void generic_visitor::visit(boot::case_statement *statement)
void generic_visitor::visit(frontend::case_statement *statement)
{
statement->condition().accept(this);
tree condition_expression = this->current_expression;
@@ -1207,9 +1207,9 @@ namespace elna::gcc
tree end_label_declaration = create_artificial_label(get_location(&statement->position()));
tree switch_statements = alloc_stmt_list();
for (const boot::switch_case& case_block : statement->cases)
for (const frontend::switch_case& case_block : statement->cases)
{
for (boot::expression *const case_label : case_block.labels)
for (frontend::expression *const case_label : case_block.labels)
{
case_label->accept(this);
location_t case_location = get_location(&case_label->position());

10
gcc/elna-tree.cc
View File

@@ -128,12 +128,12 @@ namespace elna::gcc
return field_declaration;
}
tree do_pointer_arithmetic(boot::binary_operator binary_operator,
tree do_pointer_arithmetic(frontend::binary_operator binary_operator,
tree left, tree right, location_t operation_location)
{
tree left_type = get_qualified_type(TREE_TYPE(left), TYPE_UNQUALIFIED);
tree right_type = get_qualified_type(TREE_TYPE(right), TYPE_UNQUALIFIED);
if (binary_operator == boot::binary_operator::sum)
if (binary_operator == frontend::binary_operator::sum)
{
tree pointer{ NULL_TREE };
tree offset{ NULL_TREE };
@@ -164,7 +164,7 @@ namespace elna::gcc
return fold_build2_loc(operation_location, POINTER_PLUS_EXPR, TREE_TYPE(pointer), pointer, offset);
}
else if (binary_operator == boot::binary_operator::subtraction)
else if (binary_operator == frontend::binary_operator::subtraction)
{
if (POINTER_TYPE_P(left_type) && is_integral_type(right_type))
{
@@ -186,7 +186,7 @@ namespace elna::gcc
gcc_unreachable();
}
tree build_binary_operation(bool condition, boot::binary_expression *expression,
tree build_binary_operation(bool condition, frontend::binary_expression *expression,
tree_code operator_code, tree left, tree right, tree target_type)
{
location_t expression_location = get_location(&expression->position());
@@ -202,7 +202,7 @@ namespace elna::gcc
error_at(expression_location,
"invalid operands of type '%s' and '%s' for operator %s",
print_type(left_type).c_str(), print_type(right_type).c_str(),
elna::boot::print_binary_operator(expression->operation()));
elna::frontend::print_binary_operator(expression->operation()));
return error_mark_node;
}
}

16
gcc/elna1.cc
View File

@@ -29,7 +29,7 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks-def.h"
#include <fstream>
#include "elna/boot/dependency.h"
#include "elna/frontend/dependency.h"
#include "elna/gcc/elna-tree.h"
#include "elna/gcc/elna-generic.h"
#include "elna/gcc/elna-diagnostic.h"
@@ -62,9 +62,9 @@ static bool elna_langhook_init(void)
return true;
}
using dependency_state = elna::boot::dependency_state<std::shared_ptr<elna::gcc::symbol_table>>;
using dependency_state = elna::frontend::dependency_state<std::shared_ptr<elna::gcc::symbol_table>>;
static elna::boot::dependency elna_parse_file(dependency_state& state, const char *filename)
static elna::frontend::dependency elna_parse_file(dependency_state& state, const char *filename)
{
std::ifstream entry_point{ filename, std::ios::in };
@@ -73,19 +73,19 @@ static elna::boot::dependency elna_parse_file(dependency_state& state, const cha
fatal_error(UNKNOWN_LOCATION, "Cannot open filename %s: %m", filename);
}
elna::gcc::linemap_guard{ filename };
elna::boot::dependency outcome = elna::boot::read_source(entry_point, filename);
elna::frontend::dependency outcome = elna::frontend::read_source(entry_point, filename);
if (outcome.has_errors())
{
elna::gcc::report_errors(outcome.errors());
return outcome;
}
elna::boot::symbol_bag outcome_bag = elna::boot::symbol_bag{ std::move(outcome.unresolved), state.globals };
elna::frontend::symbol_bag outcome_bag = elna::frontend::symbol_bag{ std::move(outcome.unresolved), state.globals };
for (const auto& sub_tree : outcome.tree->imports)
{
std::filesystem::path sub_path = "source" / elna::boot::build_path(sub_tree->segments);
std::unordered_map<std::filesystem::path, elna::boot::symbol_bag>::const_iterator cached_import =
std::filesystem::path sub_path = "source" / elna::frontend::build_path(sub_tree->segments);
std::unordered_map<std::filesystem::path, elna::frontend::symbol_bag>::const_iterator cached_import =
state.cache.find(sub_path);
if (cached_import == state.cache.end())
@@ -114,7 +114,7 @@ static void elna_langhook_parse_file(void)
for (unsigned int i = 0; i < num_in_fnames; i++)
{
elna::boot::dependency outcome = elna_parse_file(state, in_fnames[i]);
elna::frontend::dependency outcome = elna_parse_file(state, in_fnames[i]);
linemap_add(line_table, LC_ENTER, 0, in_fnames[i], 1);
elna::gcc::generic_visitor generic_visitor{ state.custom, state.cache.find(in_fnames[i])->second };

6
include/elna/boot/ast.h → include/elna/frontend/ast.h
View File

@@ -22,10 +22,10 @@ along with GCC; see the file COPYING3. If not see
#include <string>
#include <vector>
#include <optional>
#include "elna/boot/symbol.h"
#include "elna/boot/result.h"
#include "elna/frontend/symbol.h"
#include "elna/frontend/result.h"
namespace elna::boot
namespace elna::frontend
{
enum class binary_operator
{

10
include/elna/boot/dependency.h → include/elna/frontend/dependency.h
View File

@@ -19,11 +19,11 @@ along with GCC; see the file COPYING3. If not see
#include <filesystem>
#include <fstream>
#include "elna/boot/result.h"
#include "elna/boot/ast.h"
#include "elna/boot/symbol.h"
#include "elna/frontend/result.h"
#include "elna/frontend/ast.h"
#include "elna/frontend/symbol.h"
namespace elna::boot
namespace elna::frontend
{
class dependency : public error_container
{
@@ -48,7 +48,7 @@ namespace elna::boot
std::unordered_map<std::filesystem::path, symbol_bag> cache;
explicit dependency_state(T custom)
: globals(elna::boot::builtin_symbol_table()), custom(custom)
: globals(builtin_symbol_table()), custom(custom)
{
}
};

4
include/elna/boot/driver.h → include/elna/frontend/driver.h
View File

@@ -18,10 +18,10 @@ along with GCC; see the file COPYING3. If not see
#pragma once
#include <optional>
#include "elna/boot/ast.h"
#include "elna/frontend/ast.h"
#include "location.hh"
namespace elna::boot
namespace elna::frontend
{
position make_position(const yy::location& location);

6
include/elna/boot/result.h → include/elna/frontend/result.h
View File

@@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see
#include <memory>
#include <variant>
namespace elna::boot
namespace elna::frontend
{
/**
* Position in the source text.
@@ -118,7 +118,7 @@ namespace elna::boot
}
template<>
struct std::hash<elna::boot::identifier_definition>
struct std::hash<elna::frontend::identifier_definition>
{
std::size_t operator()(const elna::boot::identifier_definition& key) const noexcept;
std::size_t operator()(const elna::frontend::identifier_definition& key) const noexcept;
};

8
include/elna/boot/semantic.h → include/elna/frontend/semantic.h
View File

@@ -22,11 +22,11 @@ along with GCC; see the file COPYING3. If not see
#include <memory>
#include <deque>
#include "elna/boot/ast.h"
#include "elna/boot/result.h"
#include "elna/boot/symbol.h"
#include "elna/frontend/ast.h"
#include "elna/frontend/result.h"
#include "elna/frontend/symbol.h"
namespace elna::boot
namespace elna::frontend
{
class undeclared_error : public error
{

4
include/elna/boot/symbol.h → include/elna/frontend/symbol.h
View File

@@ -24,9 +24,9 @@ along with GCC; see the file COPYING3. If not see
#include <vector>
#include <forward_list>
#include "elna/boot/result.h"
#include "elna/frontend/result.h"
namespace elna::boot
namespace elna::frontend
{
class alias_type;
class primitive_type;

10
include/elna/gcc/elna-builtins.h
View File

@@ -30,12 +30,12 @@ namespace elna::gcc
void init_ttree();
std::shared_ptr<symbol_table> builtin_symbol_table();
void rewrite_symbol_table(std::shared_ptr<boot::symbol_table> info_table, std::shared_ptr<symbol_table> symbols);
tree handle_symbol(const std::string& symbol_name, std::shared_ptr<boot::alias_type> reference,
void rewrite_symbol_table(std::shared_ptr<frontend::symbol_table> info_table, std::shared_ptr<symbol_table> symbols);
tree handle_symbol(const std::string& symbol_name, std::shared_ptr<frontend::alias_type> reference,
std::shared_ptr<symbol_table> symbols);
tree get_inner_alias(const boot::type& type, std::shared_ptr<symbol_table> symbols);
void declare_procedure(const std::string& name, const boot::procedure_info& info,
tree get_inner_alias(const frontend::type& type, std::shared_ptr<symbol_table> symbols);
void declare_procedure(const std::string& name, const frontend::procedure_info& info,
std::shared_ptr<symbol_table> symbols);
tree declare_variable(const std::string& name, const boot::variable_info& info,
tree declare_variable(const std::string& name, const frontend::variable_info& info,
std::shared_ptr<symbol_table> symbols);
}

6
include/elna/gcc/elna-diagnostic.h
View File

@@ -27,7 +27,7 @@ along with GCC; see the file COPYING3. If not see
#include <deque>
#include <memory>
#include "elna/boot/result.h"
#include "elna/frontend/result.h"
namespace elna::gcc
{
@@ -40,7 +40,7 @@ namespace elna::gcc
~linemap_guard();
};
location_t get_location(const boot::position *position);
location_t get_location(const frontend::position *position);
std::string print_type(tree type);
void report_errors(const std::deque<std::unique_ptr<boot::error>>& errors);
void report_errors(const std::deque<std::unique_ptr<frontend::error>>& errors);
}

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

@@ -17,9 +17,9 @@ along with GCC; see the file COPYING3. If not see
#pragma once
#include "elna/boot/ast.h"
#include "elna/boot/symbol.h"
#include "elna/boot/semantic.h"
#include "elna/frontend/ast.h"
#include "elna/frontend/symbol.h"
#include "elna/frontend/semantic.h"
#include "elna/gcc/elna-tree.h"
#include "config.h"
@@ -33,65 +33,65 @@ along with GCC; see the file COPYING3. If not see
namespace elna::gcc
{
class generic_visitor final : public boot::empty_visitor
class generic_visitor final : public frontend::empty_visitor
{
tree current_expression{ NULL_TREE };
elna::boot::symbol_bag bag;
elna::frontend::symbol_bag bag;
std::shared_ptr<symbol_table> symbols;
void enter_scope();
tree leave_scope();
void make_if_branch(boot::conditional_statements& branch, tree goto_endif);
void make_if_branch(frontend::conditional_statements& branch, tree goto_endif);
tree build_arithmetic_operation(boot::binary_expression *expression,
tree build_arithmetic_operation(frontend::binary_expression *expression,
tree_code operator_code, tree left, tree right);
tree build_comparison_operation(boot::binary_expression *expression,
tree build_comparison_operation(frontend::binary_expression *expression,
tree_code operator_code, tree left, tree right);
tree build_bit_logic_operation(boot::binary_expression *expression, tree left, tree right);
tree build_equality_operation(boot::binary_expression *expression, tree left, tree right);
tree build_bit_logic_operation(frontend::binary_expression *expression, tree left, tree right);
tree build_equality_operation(frontend::binary_expression *expression, tree left, tree right);
void build_procedure_call(location_t call_location,
tree procedure_address, const std::vector<boot::expression *>& arguments);
tree procedure_address, const std::vector<frontend::expression *>& arguments);
void build_record_call(location_t call_location,
tree symbol, const std::vector<boot::expression *>& arguments);
bool build_builtin_procedures(boot::procedure_call *call);
void build_assert_builtin(location_t call_location, const std::vector<boot::expression *>& arguments);
tree symbol, const std::vector<frontend::expression *>& arguments);
bool build_builtin_procedures(frontend::procedure_call *call);
void build_assert_builtin(location_t call_location, const std::vector<frontend::expression *>& arguments);
bool expect_trait_type_only(boot::traits_expression *trait);
bool expect_trait_for_integral_type(boot::traits_expression *trait);
void visit_statements(const std::vector<boot::statement *>& statements);
bool expect_trait_type_only(frontend::traits_expression *trait);
bool expect_trait_for_integral_type(frontend::traits_expression *trait);
void visit_statements(const std::vector<frontend::statement *>& statements);
bool assert_constant(location_t expression_location);
public:
generic_visitor(std::shared_ptr<symbol_table> symbol_table, elna::boot::symbol_bag bag);
generic_visitor(std::shared_ptr<symbol_table> symbol_table, elna::frontend::symbol_bag bag);
void visit(boot::program *program) override;
void visit(boot::procedure_declaration *definition) override;
void visit(boot::procedure_call *call) override;
void visit(boot::cast_expression *expression) override;
void visit(boot::traits_expression *trait) override;
void visit(boot::literal<std::int32_t> *literal) override;
void visit(boot::literal<std::uint32_t> *literal) override;
void visit(boot::literal<double> *literal) override;
void visit(boot::literal<bool> *boolean) override;
void visit(boot::literal<unsigned char> *character) override;
void visit(boot::literal<std::nullptr_t> *) override;
void visit(boot::literal<std::string> *string) override;
void visit(boot::binary_expression *expression) override;
void visit(boot::unary_expression *expression) override;
void visit(boot::constant_declaration *definition) override;
void visit(boot::variable_declaration *declaration) override;
void visit(boot::variable_expression *expression) override;
void visit(boot::array_access_expression *expression) override;
void visit(boot::field_access_expression *expression) override;
void visit(boot::dereference_expression *expression) override;
void visit(boot::unit *unit) override;
void visit(boot::assign_statement *statement) override;
void visit(boot::if_statement *statement) override;
void visit(boot::import_declaration *) override;
void visit(boot::while_statement *statement) override;
void visit(boot::return_statement *statement) override;
void visit(boot::defer_statement *statement) override;
void visit(boot::case_statement *statement) override;
void visit(frontend::program *program) override;
void visit(frontend::procedure_declaration *definition) override;
void visit(frontend::procedure_call *call) override;
void visit(frontend::cast_expression *expression) override;
void visit(frontend::traits_expression *trait) override;
void visit(frontend::literal<std::int32_t> *literal) override;
void visit(frontend::literal<std::uint32_t> *literal) override;
void visit(frontend::literal<double> *literal) override;
void visit(frontend::literal<bool> *boolean) override;
void visit(frontend::literal<unsigned char> *character) override;
void visit(frontend::literal<std::nullptr_t> *) override;
void visit(frontend::literal<std::string> *string) override;
void visit(frontend::binary_expression *expression) override;
void visit(frontend::unary_expression *expression) override;
void visit(frontend::constant_declaration *definition) override;
void visit(frontend::variable_declaration *declaration) override;
void visit(frontend::variable_expression *expression) override;
void visit(frontend::array_access_expression *expression) override;
void visit(frontend::field_access_expression *expression) override;
void visit(frontend::dereference_expression *expression) override;
void visit(frontend::unit *unit) override;
void visit(frontend::assign_statement *statement) override;
void visit(frontend::if_statement *statement) override;
void visit(frontend::import_declaration *) override;
void visit(frontend::while_statement *statement) override;
void visit(frontend::return_statement *statement) override;
void visit(frontend::defer_statement *statement) override;
void visit(frontend::case_statement *statement) override;
};
}

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

@@ -27,13 +27,13 @@ along with GCC; see the file COPYING3. If not see
#include "stringpool.h"
#include "fold-const.h"
#include "elna/boot/ast.h"
#include "elna/boot/symbol.h"
#include "elna/frontend/ast.h"
#include "elna/frontend/symbol.h"
#include "elna/gcc/elna1.h"
namespace elna::gcc
{
using symbol_table = boot::symbol_map<tree, tree, NULL_TREE>;
using symbol_table = frontend::symbol_map<tree, tree, NULL_TREE>;
bool is_integral_type(tree type);
bool is_numeric_type(tree type);
@@ -74,11 +74,11 @@ namespace elna::gcc
void defer(tree statement_tree);
tree chain_defer();
tree do_pointer_arithmetic(boot::binary_operator binary_operator,
tree do_pointer_arithmetic(frontend::binary_operator binary_operator,
tree left, tree right, location_t expression_location);
tree build_binary_operation(bool condition, boot::binary_expression *expression,
tree build_binary_operation(bool condition, frontend::binary_expression *expression,
tree_code operator_code, tree left, tree right, tree target_type);
tree build_arithmetic_operation(boot::binary_expression *expression,
tree build_arithmetic_operation(frontend::binary_expression *expression,
tree_code operator_code, tree left, tree right);
tree build_field(location_t location, tree record_type, const std::string name, tree type);
tree find_field_by_name(location_t expression_location, tree type, const std::string& field_name);

2
rakelib/boot.rake
View File

@@ -59,7 +59,7 @@ end
namespace :boot do
# Dependencies.
GCC_VERSION = "15.1.0"
GCC_VERSION = "15.2.0"
HOST_GCC = TMP + 'host/gcc'
GCC_PATCH = 'https://raw.githubusercontent.com/Homebrew/formula-patches/575ffcaed6d3112916fed77d271dd3799a7255c4/gcc/gcc-15.1.0.diff'