aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--boot/ast.cc (renamed from frontend/ast.cc)4
-rw-r--r--boot/dependency.cc (renamed from frontend/dependency.cc)8
-rw-r--r--boot/driver.cc (renamed from frontend/driver.cc)4
-rw-r--r--boot/lexer.ll (renamed from frontend/lexer.ll)2
-rw-r--r--boot/parser.yy (renamed from frontend/parser.yy)238
-rw-r--r--boot/result.cc (renamed from frontend/result.cc)8
-rw-r--r--boot/semantic.cc (renamed from frontend/semantic.cc)4
-rw-r--r--boot/symbol.cc (renamed from frontend/symbol.cc)4
-rw-r--r--gcc/Make-lang.in6
-rw-r--r--gcc/elna-builtins.cc54
-rw-r--r--gcc/elna-diagnostic.cc6
-rw-r--r--gcc/elna-generic.cc170
-rw-r--r--gcc/elna-tree.cc10
-rw-r--r--gcc/elna1.cc16
-rw-r--r--include/elna/boot/ast.h (renamed from include/elna/frontend/ast.h)6
-rw-r--r--include/elna/boot/dependency.h (renamed from include/elna/frontend/dependency.h)8
-rw-r--r--include/elna/boot/driver.h (renamed from include/elna/frontend/driver.h)4
-rw-r--r--include/elna/boot/result.h (renamed from include/elna/frontend/result.h)6
-rw-r--r--include/elna/boot/semantic.h (renamed from include/elna/frontend/semantic.h)8
-rw-r--r--include/elna/boot/symbol.h (renamed from include/elna/frontend/symbol.h)4
-rw-r--r--include/elna/gcc/elna-builtins.h10
-rw-r--r--include/elna/gcc/elna-diagnostic.h6
-rw-r--r--include/elna/gcc/elna-generic.h92
-rw-r--r--include/elna/gcc/elna-tree.h12
24 files changed, 345 insertions, 345 deletions
diff --git a/frontend/ast.cc b/boot/ast.cc
index 9a1f96b..e4c46a4 100644
--- a/frontend/ast.cc
+++ b/boot/ast.cc
@@ -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/frontend/ast.h"
+#include "elna/boot/ast.h"
-namespace elna::frontend
+namespace elna::boot
{
void empty_visitor::not_implemented()
{
diff --git a/frontend/dependency.cc b/boot/dependency.cc
index 25658f8..6b10611 100644
--- a/frontend/dependency.cc
+++ b/boot/dependency.cc
@@ -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/frontend/dependency.h"
+#include "elna/boot/dependency.h"
#include <fstream>
#include <sstream>
#include <string.h>
-#include "elna/frontend/driver.h"
-#include "elna/frontend/semantic.h"
+#include "elna/boot/driver.h"
+#include "elna/boot/semantic.h"
#include "parser.hh"
-namespace elna::frontend
+namespace elna::boot
{
dependency::dependency(const char *path)
: error_container(path)
diff --git a/frontend/driver.cc b/boot/driver.cc
index a266937..abbf0f1 100644
--- a/frontend/driver.cc
+++ b/boot/driver.cc
@@ -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/frontend/driver.h"
+#include "elna/boot/driver.h"
-namespace elna::frontend
+namespace elna::boot
{
position make_position(const yy::location& location)
{
diff --git a/frontend/lexer.ll b/boot/lexer.ll
index b48b4a6..fac70f0 100644
--- a/frontend/lexer.ll
+++ b/boot/lexer.ll
@@ -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::frontend::lexer::lex(driver& driver)
+#define YY_DECL yy::parser::symbol_type elna::boot::lexer::lex(driver& driver)
#define yyterminate() return yy::parser::make_YYEOF(this->location)
%}
diff --git a/frontend/parser.yy b/boot/parser.yy
index 5e3837b..1a5364b 100644
--- a/frontend/parser.yy
+++ b/boot/parser.yy
@@ -25,20 +25,20 @@ along with GCC; see the file COPYING3. If not see
%code requires {
#include <cstdint>
#include <iostream>
- #include "elna/frontend/driver.h"
+ #include "elna/boot/driver.h"
#if !defined(yyFlexLexerOnce)
#include <FlexLexer.h>
#endif
- namespace elna::frontend
+ namespace elna::boot
{
class lexer;
}
}
%code provides {
- namespace elna::frontend
+ namespace elna::boot
{
class lexer: public yyFlexLexer
@@ -61,8 +61,8 @@ along with GCC; see the file COPYING3. If not see
%define api.token.constructor
%define api.value.type variant
-%parse-param {elna::frontend::lexer& lexer}
-%param {elna::frontend::driver& driver}
+%parse-param {elna::boot::lexer& lexer}
+%param {elna::boot::driver& driver}
%locations
%header
@@ -121,58 +121,58 @@ along with GCC; see the file COPYING3. If not see
%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;
-%type <std::unique_ptr<std::vector<elna::frontend::statement *>>> 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_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 *>>>
+%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;
+%type <std::unique_ptr<std::vector<elna::boot::statement *>>> 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_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 *>>>
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<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<std::string>> identifiers import_declaration;
-%type <std::vector<elna::frontend::import_declaration *>> import_declarations import_part;
+%type <std::vector<elna::boot::import_declaration *>> import_declarations import_part;
%%
program:
import_part constant_part type_part variable_part procedure_part statement_part "end" "."
{
if ($6)
{
- frontend::program *tree = new frontend::program(frontend::make_position(@1));
+ boot::program *tree = new boot::program(boot::make_position(@1));
std::swap(tree->body, *$6.release());
driver.tree.reset(tree);
}
else
{
- driver.tree.reset(new frontend::unit(frontend::make_position(@1)));
+ driver.tree.reset(new boot::unit(boot::make_position(@1)));
}
std::swap(driver.tree->imports, $1);
std::swap(driver.tree->constants, $2);
@@ -184,28 +184,28 @@ block: constant_part variable_part statement_part "end"
{
if ($3)
{
- $$ = std::make_unique<frontend::block>(std::move($1), std::move($2), std::move(*$3.release()));
+ $$ = std::make_unique<boot::block>(std::move($1), std::move($2), std::move(*$3.release()));
}
else
{
- $$ = std::make_unique<frontend::block>(std::move($1), std::move($2));
+ $$ = std::make_unique<boot::block>(std::move($1), std::move($2));
}
}
statement_part:
/* no statements */ {}
- | "begin" required_statements { $$ = std::make_unique<std::vector<frontend::statement *>>(std::move($2));; }
+ | "begin" required_statements { $$ = std::make_unique<std::vector<boot::statement *>>(std::move($2));; }
| return_statement
{
- $$ = std::make_unique<std::vector<frontend::statement *>>(std::vector<frontend::statement *>{ $1 });
+ $$ = std::make_unique<std::vector<boot::statement *>>(std::vector<boot::statement *>{ $1 });
}
| "begin" required_statements ";" return_statement
{
- $$ = std::make_unique<std::vector<frontend::statement *>>(std::move($2));
+ $$ = std::make_unique<std::vector<boot::statement *>>(std::move($2));
$$->push_back($4);
}
identifier_definition:
- IDENTIFIER "*" { $$ = frontend::identifier_definition{ $1, true }; }
- | IDENTIFIER { $$ = frontend::identifier_definition{ $1, false }; }
+ IDENTIFIER "*" { $$ = boot::identifier_definition{ $1, true }; }
+ | IDENTIFIER { $$ = boot::identifier_definition{ $1, false }; }
identifier_definitions:
identifier_definition "," identifier_definitions
{
@@ -215,11 +215,11 @@ identifier_definitions:
| 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); }
+ | "->" "!" { $$ = boot::procedure_type_expression::return_t(std::monostate{}); }
+ | "->" type_expression { $$ = boot::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));
+ $$.second = new boot::procedure_type_expression(boot::make_position(@1), std::move($2));
for (auto& [name, type] : $1)
{
$$.first.emplace_back(std::move(name));
@@ -229,13 +229,13 @@ procedure_heading: formal_parameter_list return_declaration
procedure_declaration:
"proc" identifier_definition procedure_heading block
{
- $$ = new frontend::procedure_declaration(frontend::make_position(@1), std::move($2), $3.second,
+ $$ = new boot::procedure_declaration(boot::make_position(@1), std::move($2), $3.second,
std::move(*$4));
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);
+ $$ = new boot::procedure_declaration(boot::make_position(@1), std::move($2), $3.second);
std::swap($3.first, $$->parameter_names);
}
procedure_part:
@@ -247,44 +247,44 @@ procedure_part:
}
call_expression: designator_expression actual_parameter_list
{
- $$ = new frontend::procedure_call(frontend::make_position(@1), $1);
+ $$ = new boot::procedure_call(boot::make_position(@1), $1);
std::swap($$->arguments, $2);
}
cast_expression: "cast" "(" expression ":" type_expression ")"
- { $$ = new frontend::cast_expression(frontend::make_position(@1), $5, $3); }
+ { $$ = new boot::cast_expression(boot::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));
+ boot::conditional_statements *branch = new boot::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)); }
+ "else" optional_statements { $$ = new std::vector<boot::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));
+ boot::conditional_statements *branch = new boot::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); }
+ { $$ = new boot::return_statement(boot::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); }
+ 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); }
traits_expression:
TRAIT "(" type_expressions ")"
{
- $$ = new frontend::traits_expression(frontend::make_position(@1), $1);
+ $$ = new boot::traits_expression(boot::make_position(@1), $1);
std::swap($3, $$->parameters);
}
simple_expression:
@@ -303,82 +303,82 @@ expression:
binary_expression:
expression "*" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::multiplication);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::multiplication);
}
| expression "/" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::division);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::division);
}
| expression "%" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::remainder);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::remainder);
}
| expression "+" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::sum);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::sum);
}
| expression "-" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::subtraction);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::subtraction);
}
| expression "=" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::equals);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::equals);
}
| expression "<>" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::not_equals);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::not_equals);
}
| expression "<" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::less);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::less);
}
| expression ">" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::greater);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::greater);
}
| expression "<=" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3,
- frontend::binary_operator::less_equal);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3,
+ boot::binary_operator::less_equal);
}
| expression ">=" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::greater_equal);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::greater_equal);
}
| expression "&" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::conjunction);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::conjunction);
}
| expression "or" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::disjunction);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::disjunction);
}
| expression "xor" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3,
- frontend::binary_operator::exclusive_disjunction);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3,
+ boot::binary_operator::exclusive_disjunction);
}
| expression "<<" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::shift_left);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::shift_left);
}
| expression ">>" expression
{
- $$ = new frontend::binary_expression(frontend::make_position(@2), $1, $3, frontend::binary_operator::shift_right);
+ $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::shift_right);
}
unary_expression:
"@" operand
{
- $$ = new frontend::unary_expression(frontend::make_position(@1), $2, frontend::unary_operator::reference);
+ $$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::reference);
}
| "~" operand
{
- $$ = new frontend::unary_expression(frontend::make_position(@1), $2, frontend::unary_operator::negation);
+ $$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::negation);
}
| "-" operand
{
- $$ = new frontend::unary_expression(frontend::make_position(@1), $2, frontend::unary_operator::minus);
+ $$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::minus);
}
expressions:
expression "," expressions
@@ -396,31 +396,31 @@ type_expressions:
| type_expression { $$.push_back($1); }
designator_expression:
simple_expression "[" expression "]"
- { $$ = new frontend::array_access_expression(frontend::make_position(@2), $1, $3); }
+ { $$ = new boot::array_access_expression(boot::make_position(@2), $1, $3); }
| simple_expression "." IDENTIFIER
- { $$ = new frontend::field_access_expression(frontend::make_position(@2), $1, $3); }
+ { $$ = new boot::field_access_expression(boot::make_position(@2), $1, $3); }
| simple_expression "^"
- { $$ = new frontend::dereference_expression(frontend::make_position(@1), $1); }
+ { $$ = new boot::dereference_expression(boot::make_position(@1), $1); }
| IDENTIFIER
- { $$ = new frontend::named_expression(frontend::make_position(@1), $1); }
+ { $$ = new boot::named_expression(boot::make_position(@1), $1); }
statement:
designator_expression ":=" expression
- { $$ = new frontend::assign_statement(frontend::make_position(@1), $1, $3); }
+ { $$ = new boot::assign_statement(boot::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));
+ boot::conditional_statements *body = new boot::conditional_statements($2, std::move($4));
+ $$ = new boot::while_statement(boot::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);
+ 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);
}
| call_expression { $$ = $1; }
| "defer" optional_statements "end"
- { $$ = new frontend::defer_statement(frontend::make_position(@1), std::move($2)); }
+ { $$ = new boot::defer_statement(boot::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); }
+ { $$ = new boot::case_statement(boot::make_position(@1), $2, std::move($4), $5); }
switch_case: case_labels ":" optional_statements
{ $$ = { .labels = std::move($1), .statements = std::move($3) }; }
switch_cases:
@@ -462,33 +462,33 @@ optional_fields:
type_expression:
"[" INTEGER "]" type_expression
{
- $$ = new frontend::array_type_expression(frontend::make_position(@1), $4, $2);
+ $$ = new boot::array_type_expression(boot::make_position(@1), $4, $2);
}
| "^" type_expression
{
- $$ = new frontend::pointer_type_expression(frontend::make_position(@1), $2);
+ $$ = new boot::pointer_type_expression(boot::make_position(@1), $2);
}
| "record" optional_fields "end"
{
- $$ = new frontend::record_type_expression(frontend::make_position(@1), std::move($2));
+ $$ = new boot::record_type_expression(boot::make_position(@1), std::move($2));
}
| "union" required_fields "end"
{
- $$ = new frontend::union_type_expression(frontend::make_position(@1), std::move($2));
+ $$ = new boot::union_type_expression(boot::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));
+ auto result = new boot::procedure_type_expression(boot::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));
+ $$ = new boot::enumeration_type_expression(boot::make_position(@1), std::move($2));
}
| IDENTIFIER
{
- $$ = new frontend::named_expression(frontend::make_position(@1), $1);
+ $$ = new boot::named_expression(boot::make_position(@1), $1);
}
identifiers:
IDENTIFIER "," identifiers
@@ -500,19 +500,19 @@ identifiers:
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);
+ std::shared_ptr<boot::type_expression> shared_type{ $3 };
+ $$ = new boot::variable_declaration( boot::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::shared_ptr<boot::type_expression> shared_type{ $3 };
+ $$ = new boot::variable_declaration( boot::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);
+ std::shared_ptr<boot::type_expression> shared_type{ $3 };
+ $$ = new boot::variable_declaration( boot::make_position(@2), std::move($1), shared_type, $5);
}
variable_declarations:
/* no variable declarations */ {}
@@ -526,7 +526,7 @@ variable_part:
| "var" variable_declarations { std::swap($$, $2); }
constant_declaration: identifier_definition ":=" expression
{
- $$ = new frontend::constant_declaration(frontend::make_position(@1), std::move($1), $3);
+ $$ = new boot::constant_declaration(boot::make_position(@1), std::move($1), $3);
}
constant_declarations:
constant_declaration constant_declarations
@@ -549,18 +549,18 @@ import_declarations:
import_declaration "," import_declarations
{
std::swap($$, $3);
- $$.emplace($$.cbegin(), new frontend::import_declaration(frontend::make_position(@1), std::move($1)));
+ $$.emplace($$.cbegin(), new boot::import_declaration(boot::make_position(@1), std::move($1)));
}
| import_declaration
{
- $$.emplace_back(new frontend::import_declaration(frontend::make_position(@1), std::move($1)));
+ $$.emplace_back(new boot::import_declaration(boot::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);
+ $$ = new boot::type_declaration(boot::make_position(@1), std::move($1), $3);
}
type_declarations:
type_declaration type_declarations
@@ -591,5 +591,5 @@ actual_parameter_list:
void yy::parser::error(const location_type& loc, const std::string& message)
{
- driver.add_error<frontend::syntax_error>(message, driver.input_file, loc);
+ driver.add_error<boot::syntax_error>(message, driver.input_file, loc);
}
diff --git a/frontend/result.cc b/boot/result.cc
index aca9c5e..dab82f4 100644
--- a/frontend/result.cc
+++ b/boot/result.cc
@@ -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/frontend/result.h"
+#include "elna/boot/result.h"
-namespace elna::frontend
+namespace elna::boot
{
error::error(const char *path, const struct position position)
: position(position), path(path)
@@ -60,8 +60,8 @@ namespace elna::frontend
}
}
-std::size_t std::hash<elna::frontend::identifier_definition>::operator()(
- const elna::frontend::identifier_definition& key) const
+std::size_t std::hash<elna::boot::identifier_definition>::operator()(
+ const elna::boot::identifier_definition& key) const
{
return std::hash<std::string>{}(key.name);
}
diff --git a/frontend/semantic.cc b/boot/semantic.cc
index ee18492..3ccc81b 100644
--- a/frontend/semantic.cc
+++ b/boot/semantic.cc
@@ -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/frontend/semantic.h"
+#include "elna/boot/semantic.h"
#include <algorithm>
#include <set>
-namespace elna::frontend
+namespace elna::boot
{
undeclared_error::undeclared_error(const std::string& identifier, const char *path, const struct position position)
: error(path, position), identifier(identifier)
diff --git a/frontend/symbol.cc b/boot/symbol.cc
index bfecbd4..902d331 100644
--- a/frontend/symbol.cc
+++ b/boot/symbol.cc
@@ -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/frontend/symbol.h"
+#include "elna/boot/symbol.h"
-namespace elna::frontend
+namespace elna::boot
{
type::type()
{
diff --git a/gcc/Make-lang.in b/gcc/Make-lang.in
index e25fc6d..efc7687 100644
--- a/gcc/Make-lang.in
+++ b/gcc/Make-lang.in
@@ -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/frontend/%.cc elna/generated/parser.hh elna/generated/location.hh
+elna/%.o: elna/boot/%.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/frontend/parser.yy
+elna/generated/parser.cc: elna/boot/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/frontend/lexer.ll
+elna/generated/lexer.cc: elna/boot/lexer.ll
mkdir -p $(dir $@)
$(FLEX) -o $@ $<
diff --git a/gcc/elna-builtins.cc b/gcc/elna-builtins.cc
index cf06df8..7c97027 100644
--- a/gcc/elna-builtins.cc
+++ b/gcc/elna-builtins.cc
@@ -64,23 +64,23 @@ namespace elna::gcc
std::shared_ptr<symbol_table> builtin_symbol_table()
{
- std::shared_ptr<elna::gcc::symbol_table> symbol_table = std::make_shared<elna::gcc::symbol_table>();
+ auto builtin_table = std::make_shared<symbol_table>();
- declare_builtin_type(symbol_table, "Int", elna_int_type_node);
- declare_builtin_type(symbol_table, "Word", elna_word_type_node);
- declare_builtin_type(symbol_table, "Char", elna_char_type_node);
- declare_builtin_type(symbol_table, "Bool", elna_bool_type_node);
- declare_builtin_type(symbol_table, "Pointer", elna_pointer_type_node);
- declare_builtin_type(symbol_table, "Float", elna_float_type_node);
+ declare_builtin_type(builtin_table, "Int", elna_int_type_node);
+ declare_builtin_type(builtin_table, "Word", elna_word_type_node);
+ declare_builtin_type(builtin_table, "Char", elna_char_type_node);
+ declare_builtin_type(builtin_table, "Bool", elna_bool_type_node);
+ declare_builtin_type(builtin_table, "Pointer", elna_pointer_type_node);
+ declare_builtin_type(builtin_table, "Float", elna_float_type_node);
- tree string_declaration = declare_builtin_type(symbol_table, "String", elna_string_type_node);
+ tree string_declaration = declare_builtin_type(builtin_table, "String", elna_string_type_node);
TYPE_NAME(elna_string_type_node) = DECL_NAME(string_declaration);
TYPE_STUB_DECL(elna_string_type_node) = string_declaration;
- return symbol_table;
+ return builtin_table;
}
- tree build_composite_type(const std::vector<frontend::type_field>& fields, tree composite_type_node,
+ tree build_composite_type(const std::vector<boot::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 frontend::procedure_type& procedure, std::shared_ptr<symbol_table> symbols)
+ tree build_procedure_type(const boot::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 frontend::type& type, std::shared_ptr<symbol_table> symbols)
+ tree get_inner_alias(const boot::type& type, std::shared_ptr<symbol_table> symbols)
{
- if (auto reference = type.get<frontend::primitive_type>())
+ if (auto reference = type.get<boot::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<frontend::record_type>())
+ else if (auto reference = type.get<boot::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<frontend::union_type>())
+ else if (auto reference = type.get<boot::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<frontend::enumeration_type>())
+ else if (auto reference = type.get<boot::enumeration_type>())
{
return build_enumeration_type(reference->members);
}
- else if (auto reference = type.get<frontend::pointer_type>())
+ else if (auto reference = type.get<boot::pointer_type>())
{
return build_global_pointer_type(get_inner_alias(reference->base, symbols));
}
- else if (auto reference = type.get<frontend::array_type>())
+ else if (auto reference = type.get<boot::array_type>())
{
tree base = get_inner_alias(reference->base, symbols);
return build_static_array_type(base, reference->size);
}
- else if (auto reference = type.get<frontend::procedure_type>())
+ else if (auto reference = type.get<boot::procedure_type>())
{
auto procedure = build_procedure_type(*reference, symbols);
return build_global_pointer_type(procedure);
}
- else if (auto reference = type.get<frontend::alias_type>())
+ else if (auto reference = type.get<boot::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<frontend::alias_type> reference,
+ tree handle_symbol(const std::string& symbol_name, std::shared_ptr<boot::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 frontend::procedure_info& info,
+ void declare_procedure(const std::string& name, const boot::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 (frontend::type parameter : info.symbol.parameters)
+ for (boot::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 frontend::variable_info& info,
+ tree declare_variable(const std::string& name, const boot::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 frontend::type_info& info, std::shared_ptr<symbol_table> symbols)
+ void declare_type(const std::string& name, const boot::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<frontend::alias_type>())
+ if (auto alias_type = info.symbol.get<boot::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<frontend::symbol_table> info_table, std::shared_ptr<symbol_table> symbols)
+ void rewrite_symbol_table(std::shared_ptr<boot::symbol_table> info_table, std::shared_ptr<symbol_table> symbols)
{
for (auto& [symbol_name, symbol_info] : *info_table)
{
diff --git a/gcc/elna-diagnostic.cc b/gcc/elna-diagnostic.cc
index 162d6cb..fa32788 100644
--- a/gcc/elna-diagnostic.cc
+++ b/gcc/elna-diagnostic.cc
@@ -31,7 +31,7 @@ namespace elna::gcc
linemap_add(line_table, LC_LEAVE, 0, NULL, 0);
}
- location_t get_location(const frontend::position *position)
+ location_t get_location(const boot::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<frontend::error>>& errors)
+ void report_errors(const std::deque<std::unique_ptr<boot::error>>& errors)
{
for (const auto& error : errors)
{
@@ -159,7 +159,7 @@ namespace elna::gcc
if (error->position.line != 0 || error->position.column != 0)
{
- gcc_location = elna::gcc::get_location(&error->position);
+ gcc_location = get_location(&error->position);
}
error_at(gcc_location, error->what().c_str());
}
diff --git a/gcc/elna-generic.cc b/gcc/elna-generic.cc
index a5aa5f5..66bd9a2 100644
--- a/gcc/elna-generic.cc
+++ b/gcc/elna-generic.cc
@@ -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::frontend::symbol_bag bag)
+ generic_visitor::generic_visitor(std::shared_ptr<symbol_table> symbol_table, boot::symbol_bag bag)
: bag(bag), symbols(symbol_table)
{
}
void generic_visitor::build_procedure_call(location_t call_location,
- tree procedure_address, const std::vector<frontend::expression *>& arguments)
+ tree procedure_address, const std::vector<boot::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 (frontend::expression *const argument : arguments)
+ for (boot::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<frontend::expression *>& arguments)
+ tree symbol, const std::vector<boot::expression *>& arguments)
{
vec<constructor_elt, va_gc> *tree_arguments = nullptr;
tree record_fields = TYPE_FIELDS(symbol);
- for (frontend::expression *const argument : arguments)
+ for (boot::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<frontend::expression *>& arguments)
+ const std::vector<boot::expression *>& arguments)
{
if (arguments.size() != 1)
{
@@ -165,11 +165,11 @@ namespace elna::gcc
}
}
- bool generic_visitor::build_builtin_procedures(frontend::procedure_call *call)
+ bool generic_visitor::build_builtin_procedures(boot::procedure_call *call)
{
location_t call_location = get_location(&call->position());
- if (frontend::named_expression *named_call = call->callable().is_named())
+ if (boot::named_expression *named_call = call->callable().is_named())
{
if (named_call->name == "assert")
{
@@ -180,7 +180,7 @@ namespace elna::gcc
return false;
}
- void generic_visitor::visit(frontend::procedure_call *call)
+ void generic_visitor::visit(boot::procedure_call *call)
{
if (build_builtin_procedures(call))
{
@@ -215,7 +215,7 @@ namespace elna::gcc
}
}
- void generic_visitor::visit(frontend::cast_expression *expression)
+ void generic_visitor::visit(boot::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(frontend::program *program)
+ void generic_visitor::visit(boot::program *program)
{
- visit(static_cast<frontend::unit *>(program));
+ visit(static_cast<boot::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(frontend::unit *unit)
+ void generic_visitor::visit(boot::unit *unit)
{
- for (frontend::import_declaration *const declaration : unit->imports)
+ for (boot::import_declaration *const declaration : unit->imports)
{
declaration->accept(this);
}
- for (frontend::constant_declaration *const constant : unit->constants)
+ for (boot::constant_declaration *const constant : unit->constants)
{
constant->accept(this);
}
- for (frontend::variable_declaration *const variable : unit->variables)
+ for (boot::variable_declaration *const variable : unit->variables)
{
variable->accept(this);
}
- for (frontend::procedure_declaration *const procedure : unit->procedures)
+ for (boot::procedure_declaration *const procedure : unit->procedures)
{
procedure->accept(this);
}
}
- void generic_visitor::visit(frontend::procedure_declaration *definition)
+ void generic_visitor::visit(boot::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 (frontend::constant_declaration *const constant : definition->body.value().constants())
+ for (boot::constant_declaration *const constant : definition->body.value().constants())
{
constant->accept(this);
}
- for (frontend::variable_declaration *const variable : definition->body.value().variables())
+ for (boot::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(frontend::literal<std::int32_t> *literal)
+ void generic_visitor::visit(boot::literal<std::int32_t> *literal)
{
this->current_expression = build_int_cst(elna_int_type_node, literal->value);
}
- void generic_visitor::visit(frontend::literal<std::uint32_t> *literal)
+ void generic_visitor::visit(boot::literal<std::uint32_t> *literal)
{
this->current_expression = build_int_cstu(elna_word_type_node, literal->value);
}
- void generic_visitor::visit(frontend::literal<double> *literal)
+ void generic_visitor::visit(boot::literal<double> *literal)
{
REAL_VALUE_TYPE real_value1;
@@ -406,22 +406,22 @@ namespace elna::gcc
mpfr_clear(number);
}
- void generic_visitor::visit(frontend::literal<bool> *boolean)
+ void generic_visitor::visit(boot::literal<bool> *boolean)
{
this->current_expression = boolean->value ? boolean_true_node : boolean_false_node;
}
- void generic_visitor::visit(frontend::literal<unsigned char> *character)
+ void generic_visitor::visit(boot::literal<unsigned char> *character)
{
this->current_expression = build_int_cstu(elna_char_type_node, character->value);
}
- void generic_visitor::visit(frontend::literal<nullptr_t> *)
+ void generic_visitor::visit(boot::literal<nullptr_t> *)
{
this->current_expression = elna_pointer_nil_node;
}
- void generic_visitor::visit(frontend::literal<std::string> *string)
+ void generic_visitor::visit(boot::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(frontend::binary_expression *expression,
+ tree generic_visitor::build_arithmetic_operation(boot::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(frontend::binary_expression *expression,
+ tree generic_visitor::build_comparison_operation(boot::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(frontend::binary_expression *expression, tree left, tree right)
+ tree generic_visitor::build_bit_logic_operation(boot::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() == frontend::binary_operator::conjunction)
+ if (expression->operation() == boot::binary_operator::conjunction)
{
bit_code = BIT_AND_EXPR;
logical_code = TRUTH_ANDIF_EXPR;
}
- else if (expression->operation() == frontend::binary_operator::disjunction)
+ else if (expression->operation() == boot::binary_operator::disjunction)
{
bit_code = BIT_IOR_EXPR;
logical_code = TRUTH_ORIF_EXPR;
}
- else if (expression->operation() == frontend::binary_operator::exclusive_disjunction)
+ else if (expression->operation() == boot::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::frontend::print_binary_operator(expression->operation()));
+ boot::print_binary_operator(expression->operation()));
return error_mark_node;
}
}
- tree generic_visitor::build_equality_operation(frontend::binary_expression *expression, tree left, tree right)
+ tree generic_visitor::build_equality_operation(boot::binary_expression *expression, tree left, tree right)
{
location_t expression_location = get_location(&expression->position());
tree_code equality_code, combination_code;
- if (expression->operation() == frontend::binary_operator::equals)
+ if (expression->operation() == boot::binary_operator::equals)
{
equality_code = EQ_EXPR;
combination_code = TRUTH_ANDIF_EXPR;
}
- else if (expression->operation() == frontend::binary_operator::not_equals)
+ else if (expression->operation() == boot::binary_operator::not_equals)
{
equality_code = NE_EXPR;
combination_code = TRUTH_ORIF_EXPR;
@@ -545,7 +545,7 @@ namespace elna::gcc
}
}
- void generic_visitor::visit(frontend::binary_expression *expression)
+ void generic_visitor::visit(boot::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() == frontend::binary_operator::sum
- || expression->operation() == frontend::binary_operator::subtraction))
+ && (expression->operation() == boot::binary_operator::sum
+ || expression->operation() == boot::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",
- frontend::print_binary_operator(expression->operation()));
+ boot::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(),
- frontend::print_binary_operator(expression->operation()));
+ boot::print_binary_operator(expression->operation()));
this->current_expression = error_mark_node;
return;
}
switch (expression->operation())
{
- case frontend::binary_operator::sum:
+ case boot::binary_operator::sum:
this->current_expression = build_arithmetic_operation(expression, PLUS_EXPR, left, right);
break;
- case frontend::binary_operator::subtraction:
+ case boot::binary_operator::subtraction:
this->current_expression = build_arithmetic_operation(expression, MINUS_EXPR, left, right);
break;
- case frontend::binary_operator::division:
+ case boot::binary_operator::division:
this->current_expression = build_arithmetic_operation(expression, TRUNC_DIV_EXPR, left, right);
break;
- case frontend::binary_operator::remainder:
+ case boot::binary_operator::remainder:
this->current_expression = build_arithmetic_operation(expression, TRUNC_MOD_EXPR, left, right);
break;
- case frontend::binary_operator::multiplication:
+ case boot::binary_operator::multiplication:
this->current_expression = build_arithmetic_operation(expression, MULT_EXPR, left, right);
break;
- case frontend::binary_operator::less:
+ case boot::binary_operator::less:
this->current_expression = build_comparison_operation(expression, LT_EXPR, left, right);
break;
- case frontend::binary_operator::greater:
+ case boot::binary_operator::greater:
this->current_expression = build_comparison_operation(expression, GT_EXPR, left, right);
break;
- case frontend::binary_operator::less_equal:
+ case boot::binary_operator::less_equal:
this->current_expression = build_comparison_operation(expression, LE_EXPR, left, right);
break;
- case frontend::binary_operator::greater_equal:
+ case boot::binary_operator::greater_equal:
this->current_expression = build_comparison_operation(expression, GE_EXPR, left, right);
break;
- case frontend::binary_operator::conjunction:
+ case boot::binary_operator::conjunction:
this->current_expression = build_bit_logic_operation(expression, left, right);
break;
- case frontend::binary_operator::disjunction:
+ case boot::binary_operator::disjunction:
this->current_expression = build_bit_logic_operation(expression, left, right);
break;
- case frontend::binary_operator::exclusive_disjunction:
+ case boot::binary_operator::exclusive_disjunction:
this->current_expression = build_bit_logic_operation(expression, left, right);
break;
- case frontend::binary_operator::equals:
+ case boot::binary_operator::equals:
this->current_expression = build_equality_operation(expression, left, right);
break;
- case frontend::binary_operator::not_equals:
+ case boot::binary_operator::not_equals:
this->current_expression = build_equality_operation(expression, left, right);
break;
- case frontend::binary_operator::shift_left:
+ case boot::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 frontend::binary_operator::shift_right:
+ case boot::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(frontend::unary_expression *expression)
+ void generic_visitor::visit(boot::unary_expression *expression)
{
expression->operand().accept(this);
location_t location = get_location(&expression->position());
switch (expression->operation())
{
- case frontend::unary_operator::reference:
+ case boot::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 frontend::unary_operator::negation:
+ case boot::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 frontend::unary_operator::minus:
+ case boot::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(frontend::constant_declaration *definition)
+ void generic_visitor::visit(boot::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(frontend::variable_declaration *declaration)
+ void generic_visitor::visit(boot::variable_declaration *declaration)
{
for (const auto& variable_identifier : declaration->identifiers)
{
@@ -784,7 +784,7 @@ namespace elna::gcc
}
}
- void generic_visitor::visit(frontend::named_expression *expression)
+ void generic_visitor::visit(boot::named_expression *expression)
{
auto symbol = this->symbols->lookup(expression->name);
@@ -800,7 +800,7 @@ namespace elna::gcc
}
}
- void generic_visitor::visit(frontend::array_access_expression *expression)
+ void generic_visitor::visit(boot::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(frontend::binary_operator::sum, string_ptr, offset, location);
+ tree target_pointer = do_pointer_arithmetic(boot::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(frontend::traits_expression *trait)
+ bool generic_visitor::expect_trait_type_only(boot::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(frontend::traits_expression *trait)
+ bool generic_visitor::expect_trait_for_integral_type(boot::traits_expression *trait)
{
if (!expect_trait_type_only(trait))
{
@@ -872,7 +872,7 @@ namespace elna::gcc
return true;
}
- void generic_visitor::visit(frontend::traits_expression *trait)
+ void generic_visitor::visit(boot::traits_expression *trait)
{
location_t trait_location = get_location(&trait->position());
@@ -945,7 +945,7 @@ namespace elna::gcc
}
}
- void generic_visitor::visit(frontend::field_access_expression *expression)
+ void generic_visitor::visit(boot::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(frontend::dereference_expression *expression)
+ void generic_visitor::visit(boot::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(frontend::assign_statement *statement)
+ void generic_visitor::visit(boot::assign_statement *statement)
{
statement->lvalue().accept(this);
@@ -1045,7 +1045,7 @@ namespace elna::gcc
this->current_expression = NULL_TREE;
}
- void generic_visitor::visit(frontend::if_statement *statement)
+ void generic_visitor::visit(boot::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(frontend::conditional_statements& branch, tree goto_endif)
+ void generic_visitor::make_if_branch(boot::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(frontend::import_declaration *)
+ void generic_visitor::visit(boot::import_declaration *)
{
}
- void generic_visitor::visit(frontend::while_statement *statement)
+ void generic_visitor::visit(boot::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<frontend::statement *>& statements)
+ void generic_visitor::visit_statements(const std::vector<boot::statement *>& statements)
{
- for (frontend::statement *const statement : statements)
+ for (boot::statement *const statement : statements)
{
statement->accept(this);
@@ -1141,9 +1141,9 @@ namespace elna::gcc
}
}
- void generic_visitor::visit(frontend::return_statement *statement)
+ void generic_visitor::visit(boot::return_statement *statement)
{
- frontend::expression *return_expression = &statement->return_expression();
+ boot::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(frontend::defer_statement *statement)
+ void generic_visitor::visit(boot::defer_statement *statement)
{
enter_scope();
visit_statements(statement->statements);
defer(leave_scope());
}
- void generic_visitor::visit(frontend::case_statement *statement)
+ void generic_visitor::visit(boot::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 frontend::switch_case& case_block : statement->cases)
+ for (const boot::switch_case& case_block : statement->cases)
{
- for (frontend::expression *const case_label : case_block.labels)
+ for (boot::expression *const case_label : case_block.labels)
{
case_label->accept(this);
location_t case_location = get_location(&case_label->position());
diff --git a/gcc/elna-tree.cc b/gcc/elna-tree.cc
index 93f796b..de7f6b0 100644
--- a/gcc/elna-tree.cc
+++ b/gcc/elna-tree.cc
@@ -128,12 +128,12 @@ namespace elna::gcc
return field_declaration;
}
- tree do_pointer_arithmetic(frontend::binary_operator binary_operator,
+ tree do_pointer_arithmetic(boot::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 == frontend::binary_operator::sum)
+ if (binary_operator == boot::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 == frontend::binary_operator::subtraction)
+ else if (binary_operator == boot::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, frontend::binary_expression *expression,
+ tree build_binary_operation(bool condition, boot::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::frontend::print_binary_operator(expression->operation()));
+ boot::print_binary_operator(expression->operation()));
return error_mark_node;
}
}
diff --git a/gcc/elna1.cc b/gcc/elna1.cc
index 448a24c..0333f70 100644
--- a/gcc/elna1.cc
+++ b/gcc/elna1.cc
@@ -29,7 +29,7 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks-def.h"
#include <fstream>
-#include "elna/frontend/dependency.h"
+#include "elna/boot/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::frontend::dependency_state<std::shared_ptr<elna::gcc::symbol_table>>;
+using dependency_state = elna::boot::dependency_state<std::shared_ptr<elna::gcc::symbol_table>>;
-static elna::frontend::dependency elna_parse_file(dependency_state& state, const char *filename)
+static elna::boot::dependency elna_parse_file(dependency_state& state, const char *filename)
{
std::ifstream entry_point{ filename, std::ios::in };
@@ -73,19 +73,19 @@ static elna::frontend::dependency elna_parse_file(dependency_state& state, const
fatal_error(UNKNOWN_LOCATION, "Cannot open filename %s: %m", filename);
}
elna::gcc::linemap_guard{ filename };
- elna::frontend::dependency outcome = elna::frontend::read_source(entry_point, filename);
+ elna::boot::dependency outcome = elna::boot::read_source(entry_point, filename);
if (outcome.has_errors())
{
elna::gcc::report_errors(outcome.errors());
return outcome;
}
- elna::frontend::symbol_bag outcome_bag = elna::frontend::symbol_bag{ std::move(outcome.unresolved), state.globals };
+ elna::boot::symbol_bag outcome_bag = elna::boot::symbol_bag{ std::move(outcome.unresolved), state.globals };
for (const auto& sub_tree : outcome.tree->imports)
{
- 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 =
+ 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 =
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::frontend::dependency outcome = elna_parse_file(state, in_fnames[i]);
+ elna::boot::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 };
diff --git a/include/elna/frontend/ast.h b/include/elna/boot/ast.h
index 0b5f3d7..7d94e84 100644
--- a/include/elna/frontend/ast.h
+++ b/include/elna/boot/ast.h
@@ -22,10 +22,10 @@ along with GCC; see the file COPYING3. If not see
#include <string>
#include <vector>
#include <optional>
-#include "elna/frontend/symbol.h"
-#include "elna/frontend/result.h"
+#include "elna/boot/symbol.h"
+#include "elna/boot/result.h"
-namespace elna::frontend
+namespace elna::boot
{
enum class binary_operator
{
diff --git a/include/elna/frontend/dependency.h b/include/elna/boot/dependency.h
index f1502d1..4ec4d44 100644
--- a/include/elna/frontend/dependency.h
+++ b/include/elna/boot/dependency.h
@@ -19,11 +19,11 @@ along with GCC; see the file COPYING3. If not see
#include <filesystem>
#include <fstream>
-#include "elna/frontend/result.h"
-#include "elna/frontend/ast.h"
-#include "elna/frontend/symbol.h"
+#include "elna/boot/result.h"
+#include "elna/boot/ast.h"
+#include "elna/boot/symbol.h"
-namespace elna::frontend
+namespace elna::boot
{
class dependency : public error_container
{
diff --git a/include/elna/frontend/driver.h b/include/elna/boot/driver.h
index 66ef579..288aa0c 100644
--- a/include/elna/frontend/driver.h
+++ b/include/elna/boot/driver.h
@@ -18,10 +18,10 @@ along with GCC; see the file COPYING3. If not see
#pragma once
#include <optional>
-#include "elna/frontend/ast.h"
+#include "elna/boot/ast.h"
#include "location.hh"
-namespace elna::frontend
+namespace elna::boot
{
position make_position(const yy::location& location);
diff --git a/include/elna/frontend/result.h b/include/elna/boot/result.h
index 7e5ed77..9fc1849 100644
--- a/include/elna/frontend/result.h
+++ b/include/elna/boot/result.h
@@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see
#include <memory>
#include <variant>
-namespace elna::frontend
+namespace elna::boot
{
/**
* Position in the source text.
@@ -118,7 +118,7 @@ namespace elna::frontend
}
template<>
-struct std::hash<elna::frontend::identifier_definition>
+struct std::hash<elna::boot::identifier_definition>
{
- std::size_t operator()(const elna::frontend::identifier_definition& key) const noexcept;
+ std::size_t operator()(const elna::boot::identifier_definition& key) const noexcept;
};
diff --git a/include/elna/frontend/semantic.h b/include/elna/boot/semantic.h
index 887b660..66eb0a7 100644
--- a/include/elna/frontend/semantic.h
+++ b/include/elna/boot/semantic.h
@@ -22,11 +22,11 @@ along with GCC; see the file COPYING3. If not see
#include <memory>
#include <deque>
-#include "elna/frontend/ast.h"
-#include "elna/frontend/result.h"
-#include "elna/frontend/symbol.h"
+#include "elna/boot/ast.h"
+#include "elna/boot/result.h"
+#include "elna/boot/symbol.h"
-namespace elna::frontend
+namespace elna::boot
{
class undeclared_error : public error
{
diff --git a/include/elna/frontend/symbol.h b/include/elna/boot/symbol.h
index ec912ef..5ef917e 100644
--- a/include/elna/frontend/symbol.h
+++ b/include/elna/boot/symbol.h
@@ -24,9 +24,9 @@ along with GCC; see the file COPYING3. If not see
#include <vector>
#include <forward_list>
-#include "elna/frontend/result.h"
+#include "elna/boot/result.h"
-namespace elna::frontend
+namespace elna::boot
{
class alias_type;
class primitive_type;
diff --git a/include/elna/gcc/elna-builtins.h b/include/elna/gcc/elna-builtins.h
index 60baab7..0cdf519 100644
--- a/include/elna/gcc/elna-builtins.h
+++ b/include/elna/gcc/elna-builtins.h
@@ -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<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,
+ 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,
std::shared_ptr<symbol_table> symbols);
- 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,
+ 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,
std::shared_ptr<symbol_table> symbols);
- tree declare_variable(const std::string& name, const frontend::variable_info& info,
+ tree declare_variable(const std::string& name, const boot::variable_info& info,
std::shared_ptr<symbol_table> symbols);
}
diff --git a/include/elna/gcc/elna-diagnostic.h b/include/elna/gcc/elna-diagnostic.h
index 83f768e..1eef65d 100644
--- a/include/elna/gcc/elna-diagnostic.h
+++ b/include/elna/gcc/elna-diagnostic.h
@@ -27,7 +27,7 @@ along with GCC; see the file COPYING3. If not see
#include <deque>
#include <memory>
-#include "elna/frontend/result.h"
+#include "elna/boot/result.h"
namespace elna::gcc
{
@@ -40,7 +40,7 @@ namespace elna::gcc
~linemap_guard();
};
- location_t get_location(const frontend::position *position);
+ location_t get_location(const boot::position *position);
std::string print_type(tree type);
- void report_errors(const std::deque<std::unique_ptr<frontend::error>>& errors);
+ void report_errors(const std::deque<std::unique_ptr<boot::error>>& errors);
}
diff --git a/include/elna/gcc/elna-generic.h b/include/elna/gcc/elna-generic.h
index ec6f32f..7490e92 100644
--- a/include/elna/gcc/elna-generic.h
+++ b/include/elna/gcc/elna-generic.h
@@ -17,9 +17,9 @@ along with GCC; see the file COPYING3. If not see
#pragma once
-#include "elna/frontend/ast.h"
-#include "elna/frontend/symbol.h"
-#include "elna/frontend/semantic.h"
+#include "elna/boot/ast.h"
+#include "elna/boot/symbol.h"
+#include "elna/boot/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 frontend::empty_visitor
+ class generic_visitor final : public boot::empty_visitor
{
tree current_expression{ NULL_TREE };
- elna::frontend::symbol_bag bag;
+ elna::boot::symbol_bag bag;
std::shared_ptr<symbol_table> symbols;
void enter_scope();
tree leave_scope();
- void make_if_branch(frontend::conditional_statements& branch, tree goto_endif);
+ void make_if_branch(boot::conditional_statements& branch, tree goto_endif);
- tree build_arithmetic_operation(frontend::binary_expression *expression,
+ tree build_arithmetic_operation(boot::binary_expression *expression,
tree_code operator_code, tree left, tree right);
- tree build_comparison_operation(frontend::binary_expression *expression,
+ tree build_comparison_operation(boot::binary_expression *expression,
tree_code operator_code, 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);
+ 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);
void build_procedure_call(location_t call_location,
- tree procedure_address, const std::vector<frontend::expression *>& arguments);
+ tree procedure_address, const std::vector<boot::expression *>& arguments);
void build_record_call(location_t call_location,
- 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);
+ 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);
- 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 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 assert_constant(location_t expression_location);
public:
- generic_visitor(std::shared_ptr<symbol_table> symbol_table, elna::frontend::symbol_bag bag);
+ generic_visitor(std::shared_ptr<symbol_table> symbol_table, elna::boot::symbol_bag bag);
- 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::named_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;
+ 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::named_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;
};
}
diff --git a/include/elna/gcc/elna-tree.h b/include/elna/gcc/elna-tree.h
index 48dfeb5..f1402a7 100644
--- a/include/elna/gcc/elna-tree.h
+++ b/include/elna/gcc/elna-tree.h
@@ -27,13 +27,13 @@ along with GCC; see the file COPYING3. If not see
#include "stringpool.h"
#include "fold-const.h"
-#include "elna/frontend/ast.h"
-#include "elna/frontend/symbol.h"
+#include "elna/boot/ast.h"
+#include "elna/boot/symbol.h"
#include "elna/gcc/elna1.h"
namespace elna::gcc
{
- using symbol_table = frontend::symbol_map<tree, tree, NULL_TREE>;
+ using symbol_table = boot::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(frontend::binary_operator binary_operator,
+ tree do_pointer_arithmetic(boot::binary_operator binary_operator,
tree left, tree right, location_t expression_location);
- tree build_binary_operation(bool condition, frontend::binary_expression *expression,
+ tree build_binary_operation(bool condition, boot::binary_expression *expression,
tree_code operator_code, tree left, tree right, tree target_type);
- tree build_arithmetic_operation(frontend::binary_expression *expression,
+ tree build_arithmetic_operation(boot::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);
generated by cgit v1.2.3 (git 2.26.2) at 2026-07-03 14:01:34 +0000