Rename boot namespace to frontend

2025-11-26 20:46:41 +01:00
parent c95466622a
commit 4746bf8242
29 changed files with 421 additions and 421 deletions
--- a/README.md
+++ b/README.md
@@ -9,44 +9,3 @@ representation for a such high-level hypothetical programming language.
 ## File extension

 .elna
-
-## Current implementation
-
-This repository contains a GCC frontend for Elna. After finishing the frontend
-I'm planning to rewrite the compiler in Elna itself with its own backend and
-a hand-written parser. So GCC gives a way to have a simple bootstrap compiler
-and a possbility to compile Elna programs for different platforms.
-
-## Grammar
-
-Flex and bison grammar specifications, `lexer.ll` and `parser.yy`, can be found
-in the `boot/` directory.
-
-## Build
-
-The frontend requires GCC 15.1.0 (not tested with other versions).
-
-Download the GCC source. Copy the contents of this repository into `gcc/elna`
-inside GCC. Finally build GCC enabling the frontend with
-`--enable-languages=c,c++,elna`. After the installation the compiler can be
-invoked with `$prefix/bin/gelna`.
-
-There is also a `Rakefile` that downloads, builds and installs GCC into the
-`./build/` subdirectory. The `Rakefile` assumes that ruby and rake, as well as
-all GCC dependencies are already available in the system. It works under Linux
-and Mac OS. In the latter case GCC is patched with the patches used by Homebrew
-(official GCC doesn't support Apple silicon targets). Invoke with
-
-```sh
-rake boot
-```
-
-`gcc` binary is used by default, but a different gcc version can be specified
-by passing `CC` and `CXX` environment variables to rake, e.g.:
-
-```sh
-rake CC=gcc-15 CXX=g++-15 boot
-```
-
-See `rake -T` for more tasks. The GCC source is under `build/tools`. The
-installation path is `build/host/install`.
--- a/38
+++ b/38
@@ -2,42 +2,8 @@
 # v. 2.0. If a copy of the MPL was not distributed with this file, You can
 # obtain one at https://mozilla.org/MPL/2.0/.

-require 'pathname'
 require 'rake/clean'

-TMP = Pathname.new('./build')
-HOST_INSTALL = TMP + 'host/install'
+CLOBBER.include 'build'

-CLOBBER.include TMP
-CLEAN.include(TMP + 'boot')
-
-directory HOST_INSTALL
-
-task default: ['source/main.elna', TMP + 'boot/elna'] do |t|
-  sources, compiler  = t.prerequisites.partition { |f| f.end_with? '.elna' }
-
-  sh *compiler, '--parse', *sources
-end
-
-rule(/boot\/.+\.o$/ => ->(file) {
-  source = Pathname.new('source') +
-    Pathname.new(file).relative_path_from(TMP + 'boot').sub_ext('.elna')
-
-  [HOST_INSTALL + 'bin/gelna', source]
-}) do |t|
-  Pathname.new(t.name).dirname.mkpath
-  sources, compiler = t.prerequisites.partition { |source| source.end_with? '.elna' }
-
-  sh *compiler, '-c', '-O0', '-g', '-o', t.name, *sources
-end
-
-file TMP + 'boot/elna' => FileList['source/**/*.elna'].reject { |file|
-  file != file.downcase
-}.map { |file|
-  TMP + 'boot' +
-    Pathname.new(file).relative_path_from('source').sub_ext('.o')
-} do |t|
-  compiler = HOST_INSTALL + 'bin/gcc'
-
-  sh compiler.to_path, '-o', t.name, *t.prerequisites
-end
+task default: :source
--- a/frontend/ast.cc
+++ b/frontend/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/boot/ast.h"
+#include "elna/frontend/ast.h"

-namespace elna::boot
+namespace elna::frontend
 {
    void empty_visitor::not_implemented()
    {
--- a/frontend/dependency.cc
+++ b/frontend/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/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)
--- a/frontend/driver.cc
+++ b/frontend/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/boot/driver.h"
+#include "elna/frontend/driver.h"

-namespace elna::boot
+namespace elna::frontend
 {
    position make_position(const yy::location& location)
    {
--- a/frontend/lexer.ll
+++ b/frontend/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::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)
 %}

--- a/frontend/parser.yy
+++ b/frontend/parser.yy
@@ -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
@@ -60,15 +55,14 @@ 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);
 }
--- a/frontend/result.cc
+++ b/frontend/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/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);
 }
--- a/frontend/semantic.cc
+++ b/frontend/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/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);
        }
--- a/frontend/symbol.cc
+++ b/frontend/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/boot/symbol.h"
+#include "elna/frontend/symbol.h"

-namespace elna::boot
+namespace elna::frontend
 {
    type::type()
    {
--- 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/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 $@ $<
--- a/gcc/README.md
+++ b/gcc/README.md
@@ -0,0 +1,42 @@
+# Elna programming language
+
+## Current implementation
+
+This repository contains a GCC frontend for Elna. After finishing the frontend
+I'm planning to rewrite the compiler in Elna itself with its own backend and
+a hand-written parser. So GCC gives a way to have a simple bootstrap compiler
+and a possbility to compile Elna programs for different platforms.
+
+## Grammar
+
+Flex and bison grammar specifications, `lexer.ll` and `parser.yy`, can be found
+in the `boot/` directory.
+
+## Build
+
+The frontend requires GCC 15.2.0 (not tested with other versions).
+
+Download the GCC source. Copy the contents of this repository into `gcc/elna`
+inside GCC. Finally build GCC enabling the frontend with
+`--enable-languages=c,c++,elna`. After the installation the compiler can be
+invoked with `$prefix/bin/gelna`.
+
+There is also a `Rakefile` that downloads, builds and installs GCC into the
+`./build/` subdirectory. The `Rakefile` assumes that ruby and rake, as well as
+all GCC dependencies are already available in the system. It works under Linux
+and Mac OS. In the latter case GCC is patched with the patches used by Homebrew
+(official GCC doesn't support Apple silicon targets). Invoke with
+
+```sh
+rake boot
+```
+
+`gcc` binary is used by default, but a different gcc version can be specified
+by passing `CC` and `CXX` environment variables to rake, e.g.:
+
+```sh
+rake CC=gcc-15 CXX=g++-15 boot
+```
+
+See `rake -T` for more tasks. The GCC source is under `build/tools`. The
+installation path is `build/host/install`.
--- a/gcc/elna-builtins.cc
+++ b/gcc/elna-builtins.cc
@@ -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)
        {
--- 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 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)
        {
--- 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::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());
--- a/gcc/elna-tree.cc
+++ b/gcc/elna-tree.cc
@@ -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;
        }
    }
--- 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/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 };
--- a/include/elna/frontend/ast.h
+++ b/include/elna/frontend/ast.h
@@ -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
    {
--- a/include/elna/frontend/dependency.h
+++ b/include/elna/frontend/dependency.h
@@ -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)
        {
        }
    };
--- a/include/elna/frontend/driver.h
+++ b/include/elna/frontend/driver.h
@@ -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);

--- a/include/elna/frontend/result.h
+++ b/include/elna/frontend/result.h
@@ -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;
 };
--- a/include/elna/frontend/semantic.h
+++ b/include/elna/frontend/semantic.h
@@ -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
    {
--- a/include/elna/frontend/symbol.h
+++ b/include/elna/frontend/symbol.h
@@ -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;
--- 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<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);
 }
--- 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/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);
 }
--- 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/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;
    };
 }
--- 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/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);
--- a/rakelib/boot.rake
+++ b/rakelib/boot.rake
@@ -6,6 +6,7 @@
 require 'uri'
 require 'net/http'
 require 'open3'
+require 'pathname'

 def gcc_verbose(gcc_binary)
  read, write = IO.pipe
@@ -59,18 +60,20 @@ end

 namespace :boot do
  # Dependencies.
-  GCC_VERSION = "15.1.0"
-  HOST_GCC = TMP + 'host/gcc'
+  GCC_VERSION = "15.2.0"
+  HOST_GCC = 'build/host/gcc'
+  HOST_INSTALL = 'build/host/install'
  GCC_PATCH = 'https://raw.githubusercontent.com/Homebrew/formula-patches/575ffcaed6d3112916fed77d271dd3799a7255c4/gcc/gcc-15.1.0.diff'

  directory HOST_GCC
-  directory(TMP + 'tools')
+  directory HOST_INSTALL
+  directory 'build/tools'

  desc 'Download and configure the bootstrap compiler'
-  task configure: [TMP + 'tools', HOST_GCC, HOST_INSTALL] do
+  task configure: ['build/tools', HOST_GCC, HOST_INSTALL] do
    url = URI.parse "https://gcc.gnu.org/pub/gcc/releases/gcc-#{GCC_VERSION}/gcc-#{GCC_VERSION}.tar.xz"
    build_target = find_build_target
-    source_directory = TMP + "tools/gcc-#{GCC_VERSION}"
+    source_directory = Pathname.new "build/tools/gcc-#{GCC_VERSION}"
    frontend_link = source_directory + 'gcc'

    download_and_pipe url, source_directory.dirname, ['tar', '-Jxv']
@@ -80,7 +83,7 @@ namespace :boot do
    File.symlink Pathname.new('.').relative_path_from(frontend_link), (frontend_link + 'elna')

    configure_options = [
-      "--prefix=#{HOST_INSTALL.realpath}",
+      "--prefix=#{File.realpath HOST_INSTALL}",
      '--enable-languages=c,c++,elna',
      '--disable-bootstrap',
      '--disable-multilib',
--- a/rakelib/gcc.rake
+++ b/rakelib/gcc.rake
@@ -0,0 +1,36 @@
+# This Source Code Form is subject to the terms of the Mozilla Public License,
+# v. 2.0. If a copy of the MPL was not distributed with this file, You can
+# obtain one at https://mozilla.org/MPL/2.0/. -}
+# frozen_string_literal: true
+
+require 'pathname'
+require 'rake/clean'
+
+CLEAN.include 'build/gcc'
+
+task source: ['source/main.elna', 'build/gcc/elna'] do |t|
+  sources, compiler  = t.prerequisites.partition { |f| f.end_with? '.elna' }
+
+  sh *compiler, '--parse', *sources
+end
+
+rule(/gcc\/.+\.o$/ => ->(file) {
+  source = Pathname.new('source') +
+    Pathname.new(file).relative_path_from('build/gcc').sub_ext('.elna')
+
+  ['build/host/install/bin/gelna', source]
+}) do |t|
+  Pathname.new(t.name).dirname.mkpath
+  sources, compiler = t.prerequisites.partition { |source| source.end_with? '.elna' }
+
+  sh *compiler, '-c', '-O0', '-g', '-o', t.name, *sources
+end
+
+file 'build/gcc/elna' => FileList['source/**/*.elna'].reject { |file|
+  file != file.downcase
+}.map { |file|
+  Pathname.new('build/gcc') +
+    Pathname.new(file).relative_path_from('source').sub_ext('.o')
+} do |t|
+  sh 'build/host/install/bin/gcc', '-o', t.name, *t.prerequisites
+end