Extend the tester to compile sources

.gitignore

@@ -2,3 +2,4 @@
 .cache/
 CMakeFiles/
 CMakeCache.txt
+dub.selections.json

CMakeLists.txt

@@ -3,8 +3,7 @@ project(Elna)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-
+set(CMAKE_CXX_STANDARD 17)
-find_package(Boost COMPONENTS filesystem REQUIRED)
 
 add_executable(tester tests/runner.cpp include/elna/tester.hpp)
 target_include_directories(tester PRIVATE include)
@@ -13,9 +12,11 @@ add_executable(elnsh shell/main.cpp
 	shell/interactive.cpp include/elna/interactive.hpp
 	shell/history.cpp include/elna/history.hpp
 	shell/state.cpp include/elna/state.hpp
-	shell/lexer.cpp include/elna/lexer.hpp
+	shell/result.cpp include/elna/result.hpp
-	shell/result.cpp include/elna/result.hpp)
-target_include_directories(elnsh PRIVATE include)
-target_link_libraries(elnsh PUBLIC
-	${Boost_FILESYSTEM_LIBRARY}
 )
+target_include_directories(elnsh PRIVATE include)
+
+add_library(elna
+	source/lexer.cpp include/elna/lexer.hpp
+)
+target_include_directories(elna PRIVATE include)

README

@@ -0,0 +1,37 @@
+# Elna programming language
+
+Elna compiles simple mathematical operations to machine code.
+The compiled program returns the result of the operation.
+
+## File extension
+
+.elna
+
+## Grammar PL/0
+
+program = block "." ;
+
+block = [ "const" ident "=" number {"," ident "=" number} ";"]
+        [ "var" ident {"," ident} ";"]
+        { "procedure" ident ";" block ";" } statement ;
+
+statement = [ ident ":=" expression | "call" ident 
+              | "?" ident | "!" expression 
+              | "begin" statement {";" statement } "end" 
+              | "if" condition "then" statement 
+              | "while" condition "do" statement ];
+
+condition = "odd" expression |
+            expression ("="|"#"|"<"|"<="|">"|">=") expression ;
+
+expression = [ "+"|"-"] term { ("+"|"-") term};
+
+term = factor {("*"|"/") factor};
+
+factor = ident | number | "(" expression ")";
+
+## Operations
+
+"!" - Write a line.
+"?" - Read user input.
+"odd" - The only function, returns whether a number is odd.

Rakefile

@@ -0,0 +1,90 @@
+require 'pathname'
+require 'rake/clean'
+require 'open3'
+
+DFLAGS = ['--warn-no-deprecated', '-L/usr/lib64/gcc-12']
+BINARY = 'build/bin/elna'
+TESTS = FileList['tests/*.eln'].flat_map do |test|
+  build = Pathname.new 'build'
+  test_basename = Pathname.new(test).basename('')
+
+  [build + 'riscv' + test_basename].map { |path| path.sub_ext('').to_path }
+end
+
+SOURCES = FileList['source/**/*.d']
+
+directory 'build'
+
+CLEAN.include 'build'
+CLEAN.include '.dub'
+
+rule(/build\/riscv\/[^\/\.]+$/ => ->(file) { test_for_out(file, '.o') }) do |t|
+  sh '/opt/riscv/bin/riscv32-unknown-elf-ld',
+    '-o', t.name,
+    '-L/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/',
+    '-L/opt/riscv/riscv32-unknown-elf/lib',
+    '/opt/riscv/riscv32-unknown-elf/lib/crt0.o',
+    '/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/crtbegin.o',
+    t.source,
+    '--start-group', '-lgcc', '-lc', '-lgloss', '--end-group',
+    '/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/crtend.o'
+end
+
+rule(/build\/riscv\/.+\.o$/ => ->(file) { test_for_object(file, '.eln') }) do |t|
+  Pathname.new(t.name).dirname.mkpath
+  sh BINARY, '-o', t.name, t.source
+end
+
+file BINARY => SOURCES do |t|
+  sh({ 'DFLAGS' => (DFLAGS * ' ') }, 'dub', 'build', '--compiler=gdc')
+end
+
+task default: BINARY
+
+desc 'Run all tests and check the results'
+task test: TESTS
+task test: BINARY do
+  TESTS.each do |test|
+    expected = Pathname
+      .new(test)
+      .sub_ext('.txt')
+      .sub(/^build\/[[:alpha:]]+\//, 'tests/expectations/')
+      .to_path
+
+    puts "Running #{test}"
+    if test.include? '/riscv/'
+      spike = [
+        '/opt/riscv/bin/spike',
+        '--isa=RV32IMAC',
+        '/opt/riscv/riscv32-unknown-elf/bin/pk',
+        test
+      ]
+      diff = ['diff', '-Nur', '--color', expected, '-']
+      tail = ['tail', '-n', '1']
+
+      last_stdout, wait_threads = Open3.pipeline_r spike, tail, diff
+    else
+      raise 'Unsupported test platform'
+    end
+    print last_stdout.read
+    last_stdout.close
+
+    fail unless wait_threads.last.value.exitstatus.zero?
+  end
+end
+
+def test_for_object(out_file, extension)
+  test_source = Pathname
+    .new(out_file)
+    .sub_ext(extension)
+    .sub(/^build\/[[:alpha:]]+\//, 'tests/')
+    .to_path
+  [test_source, BINARY]
+end
+
+def test_for_out(out_file, extension)
+  Pathname
+    .new(out_file)
+    .sub_ext(extension)
+    .to_path
+end

TODO

@@ -1,15 +1,23 @@
-- After inserting autocompletion move the cursor to the end of the insertion.
+# Completion
+
+- Configure fzf to show only the current directory files
 - Support multiple selections for insertion in fzf.
-- Vi mode.
 - Don't hardcode fzf binary path.
-- Persist the history.
 - Send the word under the cursor to fzf as initial input.
-- Replace hard coded ANSI codes with constants or functions.
-- Show the hostname in the prompt.
-- Crash if the cd directory doesn't exist.
 - Home directory expansion.
-- Paste pastes only the first character.
+- Show files in the PATH if starting at the beginning of the prompt
-- When we read the key and an error occures how it should be handled?
+
-- Kitty protocol works with UTF8 code points for escape sequences with modifiers.
+# Appearance
-  They can be wider than an unsigned char.
+
-- Add a bar with additional information under the prompt (edit_bar).
+- Add a bar with additional information under the prompt (edit_bar), like the hostname.
+- Show current time in the prompt.
+
+# Input
+
+- DEL handling.
+- Starting long running process and killing it with Ctrl-C kills the shell.
+
+# Other
+
+- Persist the history.
+- Replace hard coded ANSI codes with constants or functions.

dub.json

@@ -0,0 +1,9 @@
+{
+	"dependencies": {
+		"tanya": "~>0.19.0"
+	},
+	"name": "elna",
+	"targetType": "executable",
+	"targetPath": "build/bin",
+	"mainSourceFile": "source/main.d"
+}

include/elna/interactive.hpp

@@ -5,10 +5,11 @@
 #include <string>
 #include <optional>
 
-#include "elna/lexer.hpp"
 #include "elna/state.hpp"
 #include "elna/history.hpp"
 
+#define BOOST_PROCESS_USE_STD_FS
+
 namespace elna
 {
     /**
@@ -42,15 +43,14 @@ namespace elna
      * \param line The command and arguments.
      * \return Whether the input shoud continued (no exit requested).
      */
-    bool execute(const std::vector<token>& line);
+    bool execute(const std::string& line);
 
     /**
      * Runs the binary specified in its argument.
      *
      * \param program Program name in PATH.
-     * \param arguments Command arguments.
      */
-    void launch(const std::string& program, const std::vector<std::string>& arguments);
+    void launch(const std::string& program);
 
     /**
      * Enables the raw mode.
@@ -74,7 +74,16 @@ namespace elna
     /**
      * Calls autocompletion.
      *
+     * \param User input.
+     * \param Cursor position in the user input.
      * \return Selected item.
      */
-    std::string complete();
+    std::string complete(const std::string& input, const std::size_t position);
+
+    /**
+     * Prints the message from the exception.
+     *
+     * \param exception The exception to print.
+     */
+    void print_exception(const std::exception& exception);
 }

include/elna/lexer.hpp

@@ -14,9 +14,10 @@ namespace elna
         class const_iterator
         {
             std::string::const_iterator m_buffer;
-            Position m_position;
+            source_position m_position;
 
-            const_iterator(std::string::const_iterator buffer, const Position& position);
+            const_iterator(std::string::const_iterator buffer,
+                    const source_position position = source_position());
 
         public:
             using iterator_category = std::forward_iterator_tag;
@@ -25,7 +26,7 @@ namespace elna
             using pointer = const value_type *;
             using reference = const value_type&;
 
-            const Position& position() const noexcept;
+            const source_position& position() const noexcept;
 
             reference operator*() const noexcept;
             pointer operator->() const noexcept;
@@ -68,11 +69,11 @@ namespace elna
 
         type of() const noexcept;
         const value& identifier() const noexcept;
-        const Position& position() const noexcept;
+        const source_position& position() const noexcept;
 
     private:
         std::string m_value;
-        Position m_position;
+        source_position m_position;
         type m_type;
     };
 

include/elna/result.hpp

@@ -8,7 +8,7 @@ namespace elna
     /**
      * Position in the source text.
      */
-    struct Position
+    struct source_position
     {
         /// Line.
         std::size_t line = 1;
@@ -20,21 +20,21 @@ namespace elna
     /**
      * A compilation error consists of an error message and position.
      */
-    struct CompileError
+    struct compile_error
     {
     private:
-        char const *message_;
+        char const *message;
-        Position position_;
+        source_position position;
 
     public:
         /**
          * @param message Error text.
          * @param position Error position in the source text.
          */
-        CompileError(char const *message, Position position) noexcept;
+        compile_error(char const *message, const source_position position) noexcept;
 
         /// Error text.
-        char const *message() const noexcept;
+        const char *what() const noexcept;
 
         /// Error line in the source text.
         std::size_t line() const noexcept;
@@ -44,5 +44,5 @@ namespace elna
     };
 
     template<typename T>
-    using result = boost::outcome_v2::result<T, CompileError>;
+    using result = boost::outcome_v2::result<T, compile_error>;
 }

include/elna/state.hpp

@@ -38,30 +38,28 @@ namespace elna
         num_lock = 0b10000000, ///< 128
     };
 
-    class key
+    struct key
     {
-        std::variant<special_key, unsigned char> store;
+        using char_t = std::uint32_t;
-        std::uint8_t modifiers;
 
-    public:
         key();
-        explicit key(const unsigned char c, const std::uint8_t modifiers = 0);
+        explicit key(const char_t c, const std::uint8_t modifiers = 0);
-        explicit key(const unsigned char c, const modifier modifiers);
+        explicit key(const char_t c, const modifier modifiers);
         explicit key(const special_key control, const std::uint8_t modifiers = 0);
         explicit key(const special_key control, const modifier modifiers);
 
-        bool operator==(const unsigned char c) const;
+        bool operator==(const char_t c) const;
-        friend bool operator==(const unsigned char c, const key& that);
+        friend bool operator==(const char_t c, const key& that);
         bool operator==(const special_key control) const;
         friend bool operator==(const special_key control, const key& that);
         bool operator==(const key& that) const;
-        bool operator!=(const unsigned char c) const;
+        bool operator!=(const char_t c) const;
-        friend bool operator!=(const unsigned char c, const key& that);
+        friend bool operator!=(const char_t c, const key& that);
         bool operator!=(const special_key control) const;
         friend bool operator!=(const special_key control, const key& that);
         bool operator!=(const key& that) const;
 
-        unsigned char character() const;
+        char_t character() const;
         special_key control() const;
         bool modified(const std::uint8_t modifiers) const noexcept;
         bool modified(const modifier modifiers) const noexcept;
@@ -69,6 +67,10 @@ namespace elna
         bool is_character() const noexcept;
         bool is_control() const noexcept;
         bool empty() const noexcept;
+
+    private:
+        std::variant<special_key, char_t> store;
+        std::uint8_t modifiers;
     };
 
     /**
@@ -143,12 +145,20 @@ namespace elna
          */
         std::size_t absolute_position() const noexcept;
 
+        /**
+         * Cursor position relative to the start of the user input.
+         *
+         * \returns Cursor position.
+         */
+        std::size_t relative_position() const noexcept;
+
         /**
          * Inserts text at cursor position.
          *
          * \param text Text to insert.
          */
         void insert(const std::string& text);
+        void insert(const key::char_t text);
 
         /**
          * Replaces the user input with the given string.

shell/history.cpp

@@ -9,8 +9,8 @@ namespace elna
 
     void editor_history::push(const std::string& entry)
     {
-        commands.push_front(entry);
+        commands.push_back(entry);
-        current_pointer = commands.cbegin();
+        current_pointer = commands.cend();
     }
 
     void editor_history::clear()
@@ -46,4 +46,9 @@ namespace elna
     {
         return this->commands.cend();
     }
+
+    editor_history::const_iterator editor_history::current() const noexcept
+    {
+        return this->current_pointer;
+    }
 }

shell/interactive.cpp

@@ -1,9 +1,10 @@
+#include "elna/interactive.hpp"
+
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/process.hpp>
 #include <termios.h>
 #include <filesystem>
 
-#include "elna/interactive.hpp"
-
 namespace elna
 {
     static termios original_termios;
@@ -39,9 +40,8 @@ namespace elna
                 break;
             }
             history.push(line.value().command_line());
-            auto tokens = lex(line.value().command_line());
 
-            if (!execute(tokens.assume_value()))
+            if (!execute(line.value().command_line()))
             {
                 break;
             }
@@ -53,6 +53,7 @@ namespace elna
     {
         editor_state state;
         std::string buffer;
+        std::string saved;
 
         state.draw(std::back_inserter(buffer));
         write(STDOUT_FILENO, buffer.data(), buffer.size());
@@ -81,7 +82,7 @@ namespace elna
                     break;
                 case action::complete:
                     write(STDOUT_FILENO, "\x1b[1E\x1b[2K", 8);
-                    state.insert(complete());
+                    state.insert(complete(state.command_line(), state.relative_position()));
                     write(STDOUT_FILENO, "\x1b[1A", 4);
                     state.draw(std::back_inserter(buffer));
                     write(STDOUT_FILENO, buffer.data(), buffer.size());
@@ -104,18 +105,26 @@ namespace elna
 
                     if (pressed_key == key(special_key::arrow_up, modifier::ctrl))
                     {
-                        history_iterator = history.next();
+                        if (history.current() == history.cend())
+                        {
+                            saved = state.command_line();
+                        }
+                        history_iterator = history.prev();
                     }
                     else if (pressed_key == key(special_key::arrow_down, modifier::ctrl))
                     {
-                        history_iterator = history.prev();
+                        history_iterator = history.next();
+                        if (history_iterator == history.cend())
+                        {
+                            state.load(saved);
+                        }
                     }
                     if (history_iterator != history.cend())
                     {
                         state.load(*history_iterator);
-                        state.draw(std::back_inserter(buffer));
-                        write(STDOUT_FILENO, buffer.data(), buffer.size());
                     }
+                    state.draw(std::back_inserter(buffer));
+                    write(STDOUT_FILENO, buffer.data(), buffer.size());
                     break;
             }
         }
@@ -137,7 +146,7 @@ namespace elna
         {
             return key();
         }
-        auto [number, last_char] = read_number<unsigned char>();
+        auto [number, last_char] = read_number<key::char_t>();
         std::uint8_t modifiers{ 0 };
 
         if (last_char == ';')
@@ -185,35 +194,51 @@ namespace elna
         return key();
     }
 
-    bool execute(const std::vector<token>& tokens)
+    void print_exception(const std::exception& exception)
     {
-        if (tokens.empty())
+        std::string message{ exception.what()  };
+        message += "\r\n";
+        write(STDERR_FILENO, message.data(), message.size());
+    }
+
+    bool execute(const std::string& line)
+    {
+        if (line.empty())
         {
             return true;
         }
-        std::string program = tokens.front().identifier();
+        if (line == "exit")
-        if (program == "exit")
         {
             return false;
         }
-        else if (program == "cd")
+        else if (boost::starts_with(line, "cd "))
         {
-            std::filesystem::current_path(tokens[1].identifier());
+            try
+            {
+                std::filesystem::current_path(line.substr(strlen("cd ")));
+            }
+            catch (const std::filesystem::filesystem_error& exception)
+            {
+                print_exception(exception);
+            }
 
             return true;
         }
-        std::vector<std::string> arguments;
+        launch(line);
-        for (auto argument = tokens.cbegin() + 1; argument != std::cend(tokens); ++argument)
-        {
-            arguments.push_back(argument->identifier());
-        }
-        launch(program, arguments);
         return true;
     }
 
-    void launch(const std::string& program, const std::vector<std::string>& arguments)
+    void launch(const std::string& program)
     {
-        boost::process::system(boost::process::search_path(program), arguments);
+        try
+        {
+            boost::process::system(program);
+        }
+        catch (const boost::process::process_error& exception)
+        {
+            print_exception(exception);
+        }
+        enable_raw_mode();
     }
 
     bool enable_raw_mode()
@@ -240,10 +265,17 @@ namespace elna
         tcsetattr(STDIN_FILENO, TCSAFLUSH, &original_termios);
     }
 
-    std::string complete()
+    std::string complete(const std::string& input, const std::size_t position)
     {
+        std::filesystem::path program = boost::process::search_path("fzf");
+
+        if (program.empty())
+        {
+            return "";
+        }
         boost::process::ipstream output;
-        boost::process::system("/usr/bin/fzf", "--height=10", "--layout=reverse",
+        boost::process::system(program,
+                "--height=10", "--layout=reverse", "-1", "--no-multi",
                 boost::process::std_out > output);
 
         std::string selections;

shell/result.cpp

@@ -2,24 +2,24 @@
 
 namespace elna
 {
-    CompileError::CompileError(char const *message, Position position) noexcept
+    compile_error::compile_error(const char *message, const source_position position) noexcept
     {
-        this->message_ = message;
+        this->message = message;
-        this->position_ = position;
+        this->position = position;
     }
 
-    char const *CompileError::message() const noexcept
+    char const *compile_error::what() const noexcept
     {
-        return this->message_;
+        return this->message;
     }
 
-    std::size_t CompileError::line() const noexcept
+    std::size_t compile_error::line() const noexcept
     {
-        return this->position_.line;
+        return this->position.line;
     }
 
-    std::size_t CompileError::column() const noexcept
+    std::size_t compile_error::column() const noexcept
     {
-        return this->position_.column;
+        return this->position.column;
     }
 }

shell/state.cpp

@@ -1,3 +1,6 @@
+#include <algorithm>
+#include <boost/endian.hpp>
+
 #include "elna/state.hpp"
 
 namespace elna
@@ -12,16 +15,16 @@ namespace elna
     }
 
     key::key()
-        : store(static_cast<unsigned char>(0x1b))
+        : store(0x1bu)
     {
     }
 
-    key::key(const unsigned char c, const std::uint8_t modifiers)
+    key::key(const char_t c, const std::uint8_t modifiers)
         : store(c), modifiers(modifiers == 0 ? 0 : modifiers - 1)
     {
     }
 
-    key::key(const unsigned char c, const modifier modifiers)
+    key::key(const char_t c, const modifier modifiers)
         : store(c), modifiers(static_cast<uint8_t>(modifiers))
     {
     }
@@ -36,9 +39,9 @@ namespace elna
     {
     }
 
-    unsigned char key::character() const
+    key::char_t key::character() const
     {
-        return std::get<unsigned char>(this->store);
+        return std::get<char_t>(this->store);
     }
 
     special_key key::control() const
@@ -56,10 +59,10 @@ namespace elna
         return this->modifiers == static_cast<std::uint8_t>(modifiers);
     }
 
-    bool key::operator==(const unsigned char c) const
+    bool key::operator==(const char_t c) const
     {
-        return std::holds_alternative<unsigned char>(this->store)
+        return std::holds_alternative<char_t>(this->store)
-            && std::get<unsigned char>(this->store) == c;
+            && std::get<char_t>(this->store) == c;
     }
 
     bool key::operator==(const special_key control) const
@@ -73,7 +76,7 @@ namespace elna
         return this->store == that.store;
     }
 
-    bool key::operator!=(const unsigned char c) const
+    bool key::operator!=(const char_t c) const
     {
         return !(*this == c);
     }
@@ -90,7 +93,7 @@ namespace elna
 
     bool key::is_character() const noexcept
     {
-        return std::holds_alternative<unsigned char>(this->store);
+        return std::holds_alternative<char_t>(this->store);
     }
 
     bool key::is_control() const noexcept
@@ -131,6 +134,7 @@ namespace elna
     void editor_state::load(const std::string& text)
     {
         this->input = text;
+        this->position = this->input.size() + 1;
     }
 
     const std::string& editor_state::command_line() const noexcept
@@ -143,9 +147,36 @@ namespace elna
         return this->prompt.size() + this->position;
     }
 
+    std::size_t editor_state::relative_position() const noexcept
+    {
+        return this->position;
+    }
+
     void editor_state::insert(const std::string& text)
     {
-        this->input.insert(std::end(this->input), std::cbegin(text), std::cend(text));
+        this->input.insert(this->position - 1, text);
+        this->position += text.size();
+    }
+
+    void editor_state::insert(const key::char_t text)
+    {
+        if (text == 0u)
+        {
+            this->input.insert(this->position - 1, '\0', 1);
+            ++this->position;
+            return;
+        }
+        key::char_t buffer = boost::endian::native_to_big<key::char_t>(text);
+
+        const char *begin = reinterpret_cast<char *>(&buffer);
+        const char *end = begin + sizeof(key::char_t);
+        const char *significant = std::find_if(begin, end,
+                [](const char byte) {
+                    return byte != 0;
+                });
+
+        this->input.insert(this->position - 1, significant, end - significant);
+        this->position += end - significant;
     }
 
     action editor_state::process_keypress(const key& press)
@@ -202,12 +233,21 @@ namespace elna
                         this->input.erase(this->position - 1, 1);
                     }
                     return action::redraw;
+                case 9: // Tab.
+                    return action::complete;
                 case '\r':
                     return action::finalize;
                 default:
-                    ++this->position;
+                    if (this->position - 1 < input.size())
-                    this->input.push_back(press.character());
+                    {
-                    return action::write;
+                        insert(press.character());
+                        return action::redraw;
+                    }
+                    else
+                    {
+                        insert(press.character());
+                        return action::write;
+                    }
             }
         }
     }

source/elna/arguments.d

@@ -0,0 +1,154 @@
+/**
+ * Argument parsing.
+ */
+module elna.arguments;
+
+import std.algorithm;
+import std.range;
+import std.sumtype;
+
+struct ArgumentError
+{
+    enum Type
+    {
+        expectedOutputFile,
+        noInput,
+        superfluousArguments,
+    }
+
+    private Type type_;
+    private string argument_;
+
+    @property Type type() const @nogc nothrow pure @safe
+    {
+        return this.type_;
+    }
+
+    @property string argument() const @nogc nothrow pure @safe
+    {
+        return this.argument_;
+    }
+
+    void toString(OR)(OR range)
+    if (isOutputRage!OR)
+    {
+        final switch (Type)
+        {
+            case Type.expectedOutputFile:
+                put(range, "Expected an output filename after -o");
+                break;
+            case Type.noInput:
+                put(range, "No input files specified");
+                break;
+        }
+    }
+}
+
+/**
+ * Supported compiler arguments.
+ */
+struct Arguments
+{
+    private bool assembler_;
+    private string output_;
+    private string inFile_;
+
+    @property string inFile() @nogc nothrow pure @safe
+    {
+        return this.inFile_;
+    }
+
+    /**
+     * Returns: Whether to generate assembly instead of an object file.
+     */
+    @property bool assembler() const @nogc nothrow pure @safe
+    {
+        return this.assembler_;
+    }
+
+    /**
+     * Returns: Output file.
+     */
+    @property string output() const @nogc nothrow pure @safe
+    {
+        return this.output_;
+    }
+
+    /**
+     * Parse command line arguments.
+     *
+     * The first argument is expected to be the program name (and it is
+     * ignored).
+     *
+     * Params:
+     *   arguments = Command line arguments.
+     *
+     * Returns: Parsed arguments or an error.
+     */
+    static SumType!(ArgumentError, Arguments) parse(string[] arguments)
+    @nogc nothrow pure @safe
+    {
+        if (!arguments.empty)
+        {
+            arguments.popFront;
+        }
+        alias ReturnType = typeof(return);
+
+        return parseArguments(arguments).match!(
+            (Arguments parsed) {
+                if (parsed.inFile is null)
+                {
+                    return ReturnType(ArgumentError(ArgumentError.Type.noInput));
+                }
+                else if (!arguments.empty)
+                {
+                    return ReturnType(ArgumentError(
+                        ArgumentError.Type.superfluousArguments,
+                        arguments.front
+                    ));
+                }
+                return ReturnType(parsed);
+            },
+            (ArgumentError argumentError) => ReturnType(argumentError)
+        );
+    }
+
+    private static SumType!(ArgumentError, Arguments) parseArguments(ref string[] arguments)
+    @nogc nothrow pure @safe
+    {
+        Arguments parsed;
+
+        while (!arguments.empty)
+        {
+            if (arguments.front == "-s")
+            {
+                parsed.assembler_ = true;
+            }
+            else if (arguments.front == "-o")
+            {
+                if (arguments.empty)
+                {
+                    return typeof(return)(ArgumentError(
+                        ArgumentError.Type.expectedOutputFile,
+                        arguments.front
+                    ));
+                }
+                arguments.popFront;
+                parsed.output_ = arguments.front;
+            }
+            else if (arguments.front == "--")
+            {
+                arguments.popFront;
+                parsed.inFile_ = arguments.front;
+                arguments.popFront;
+                break;
+            }
+            else if (!arguments.front.startsWith("-"))
+            {
+                parsed.inFile_ = arguments.front;
+            }
+            arguments.popFront;
+        }
+        return typeof(return)(parsed);
+    }
+}

source/elna/backend.d

@@ -0,0 +1,105 @@
+module elna.backend;
+
+import core.stdc.stdio;
+import core.stdc.stdlib;
+import elna.elf;
+import elna.ir;
+import elna.extended;
+import elna.riscv;
+import elna.lexer;
+import elna.parser;
+import elna.result;
+import std.algorithm;
+import std.sumtype;
+import std.typecons;
+import tanya.os.error;
+import tanya.container.array;
+import tanya.container.string;
+import tanya.memory.allocator;
+
+private Nullable!String readSource(string source) @nogc
+{
+    enum size_t bufferSize = 255;
+    auto sourceFilename = String(source);
+
+    return readFile(sourceFilename).match!(
+        (ErrorCode errorCode) {
+            perror(sourceFilename.toStringz);
+            return Nullable!String();
+        },
+        (Array!ubyte contents) => nullable(String(cast(char[]) contents.get))
+    );
+}
+
+int generate(string inFile, ref String outputFilename) @nogc
+{
+    auto sourceText = readSource(inFile);
+    if (sourceText.isNull)
+    {
+        return 3;
+    }
+    auto tokens = lex(sourceText.get.get);
+    if (!tokens.valid)
+    {
+        auto compileError = tokens.error.get;
+        printf("%lu:%lu: %s\n", compileError.line, compileError.column, compileError.message.ptr);
+        return 1;
+    }
+    auto ast = parse(tokens.result);
+    if (!ast.valid)
+    {
+        auto compileError = ast.error.get;
+        printf("%lu:%lu: %s\n", compileError.line, compileError.column, compileError.message.ptr);
+        return 2;
+    }
+    auto transformVisitor = cast(TransformVisitor) malloc(__traits(classInstanceSize, TransformVisitor));
+    (cast(void*) transformVisitor)[0 .. __traits(classInstanceSize, TransformVisitor)] = __traits(initSymbol, TransformVisitor)[];
+
+    auto ir = transformVisitor.visit(ast.result);
+
+    transformVisitor.__xdtor();
+    free(cast(void*) transformVisitor);
+
+    auto handle = File.open(outputFilename.toStringz, BitFlags!(File.Mode)(File.Mode.truncate));
+    if (!handle.valid)
+    {
+        return 1;
+    }
+    auto program = writeNext(ir);
+    auto elf = Elf!ELFCLASS32(move(handle));
+    auto readOnlyData = Array!ubyte(cast(const(ubyte)[]) "%d\n".ptr[0 .. 4]); // With \0.
+
+    elf.addReadOnlyData(String(".CL0"), readOnlyData);
+    elf.addCode(program.name, program.text);
+
+    elf.addExternSymbol(String("printf"));
+    foreach (ref reference; program.symbols)
+    {
+        elf.Rela relocationEntry = {
+            r_offset: cast(elf.Addr) reference.offset
+        };
+        elf.Rela relocationSub = {
+            r_offset: cast(elf.Addr) reference.offset,
+            r_info: R_RISCV_RELAX
+        };
+
+        final switch (reference.target)
+        {
+            case Reference.Target.text:
+                relocationEntry.r_info = R_RISCV_CALL;
+                break;
+            case Reference.Target.high20:
+                relocationEntry.r_info = R_RISCV_HI20;
+                break;
+            case Reference.Target.lower12i:
+                relocationEntry.r_info = R_RISCV_LO12_I;
+                break;
+        }
+
+        elf.relocate(reference.name, relocationEntry, relocationSub);
+    }
+
+    elf.finish();
+
+    return 0;
+}

source/elna/extended.d

@@ -0,0 +1,335 @@
+/**
+ * File I/O that can be moved into more generic library when and if finished.
+ */
+module elna.extended;
+
+import core.stdc.errno;
+import core.stdc.stdio;
+import std.sumtype;
+import std.typecons;
+import tanya.os.error;
+import tanya.container.array;
+import tanya.container.string;
+
+/**
+ * File handle abstraction.
+ */
+struct File
+{
+    /// Plattform dependent file type.
+    alias Handle = FILE*;
+
+    /// Uninitialized file handle value.
+    enum Handle invalid = null;
+
+    /**
+     * Relative position.
+     */
+    enum Whence
+    {
+        /// Relative to the start of the file.
+        set = SEEK_SET,
+        /// Relative to the current cursor position.
+        currentt = SEEK_CUR,
+        /// Relative from the end of the file.
+        end = SEEK_END,
+    }
+
+    /**
+     * File open modes.
+     */
+    enum Mode
+    {
+        /// Open the file for reading.
+        read = 1 << 0,
+        /// Open the file for writing. The stream is positioned at the beginning
+        /// of the file.
+        write = 1 << 1,
+        /// Open the file for writing and remove its contents.
+        truncate = 1 << 2,
+        /// Open the file for writing. The stream is positioned at the end of
+        /// the file.
+        append = 1 << 3,
+    }
+
+    private enum Status
+    {
+        invalid,
+        owned,
+        borrowed,
+    }
+
+    private union Storage
+    {
+        Handle handle;
+        ErrorCode errorCode;
+    }
+    private Storage storage;
+    private Status status = Status.invalid;
+
+    @disable this(scope return ref File f);
+    @disable this();
+
+    /**
+     * Closes the file.
+     */
+    ~this() @nogc nothrow
+    {
+        if (this.status == Status.owned)
+        {
+            fclose(this.storage.handle);
+        }
+        this.storage.handle = invalid;
+        this.status = Status.invalid;
+    }
+
+    /**
+     * Construct the object with the given system handle. The won't be claused
+     * in the descructor if this constructor is used.
+     *
+     * Params:
+     *   handle = File handle to be wrapped by this structure.
+     */
+    this(Handle handle) @nogc nothrow pure @safe
+    {
+        this.storage.handle = handle;
+        this.status = Status.borrowed;
+    }
+
+    /**
+     * Returns: Plattform dependent file handle.
+     */
+    @property Handle handle() @nogc nothrow pure @trusted
+    {
+        return valid ? this.storage.handle : invalid;
+    }
+
+    /**
+     * Returns: An error code if an error has occurred.
+     */
+    @property ErrorCode errorCode() @nogc nothrow pure @safe
+    {
+        return valid ? ErrorCode() : this.storage.errorCode;
+    }
+
+    /**
+     * Returns: Whether a valid, opened file is represented.
+     */
+    @property bool valid() @nogc nothrow pure @safe
+    {
+        return this.status != Status.invalid;
+    }
+
+    /**
+     * Transfers the file into invalid state.
+     *
+     * Returns: The old file handle.
+     */
+    Handle reset() @nogc nothrow pure @safe
+    {
+        if (!valid)
+        {
+            return invalid;
+        }
+        auto oldHandle = handle;
+
+        this.status = Status.invalid;
+        this.storage.errorCode = ErrorCode();
+
+        return oldHandle;
+    }
+
+    /**
+     * Sets stream position in the file.
+     *
+     * Params:
+     *   offset = File offset.
+     *   whence = File position to add the offset to.
+     *
+     * Returns: Error code if any.
+     */
+    ErrorCode seek(size_t offset, Whence whence) @nogc nothrow
+    {
+        if (!valid)
+        {
+            return ErrorCode(ErrorCode.ErrorNo.badDescriptor);
+        }
+        if (fseek(this.storage.handle, offset, whence))
+        {
+            return ErrorCode(cast(ErrorCode.ErrorNo) errno);
+        }
+        return ErrorCode();
+    }
+
+    /**
+     * Returns: Current offset or an error.
+     */
+    SumType!(ErrorCode, size_t) tell() @nogc nothrow
+    {
+        if (!valid)
+        {
+            return typeof(return)(ErrorCode(ErrorCode.ErrorNo.badDescriptor));
+        }
+        auto result = ftell(this.storage.handle);
+
+        if (result < 0)
+        {
+            return typeof(return)(ErrorCode(cast(ErrorCode.ErrorNo) errno));
+        }
+        return typeof(return)(cast(size_t) result);
+    }
+
+    /**
+     * Params:
+     *   buffer = Destination buffer.
+     *
+     * Returns: Bytes read. $(D_PSYMBOL ErrorCode.ErrorNo.success) means that
+     *          while reading the file an unknown error has occurred.
+     */
+    SumType!(ErrorCode, size_t) read(ubyte[] buffer) @nogc nothrow
+    {
+        if (!valid)
+        {
+            return typeof(return)(ErrorCode(ErrorCode.ErrorNo.badDescriptor));
+        }
+        const bytesRead = fread(buffer.ptr, 1, buffer.length, this.storage.handle);
+        if (bytesRead == buffer.length || eof())
+        {
+            return typeof(return)(bytesRead);
+        }
+        return typeof(return)(ErrorCode());
+    }
+
+    /**
+     * Params:
+     *   buffer = Source buffer.
+     *
+     * Returns: Bytes written. $(D_PSYMBOL ErrorCode.ErrorNo.success) means that
+     *          while reading the file an unknown error has occurred.
+     */
+    SumType!(ErrorCode, size_t) write(const(ubyte)[] buffer) @nogc nothrow
+    {
+        if (!valid)
+        {
+            return typeof(return)(ErrorCode(ErrorCode.ErrorNo.badDescriptor));
+        }
+        const bytesWritten = fwrite(buffer.ptr, 1, buffer.length, this.storage.handle);
+        if (bytesWritten == buffer.length)
+        {
+            return typeof(return)(buffer.length);
+        }
+        return typeof(return)(ErrorCode());
+    }
+
+    /**
+     * Returns: EOF status of the file.
+     */
+    bool eof() @nogc nothrow
+    {
+        return valid && feof(this.storage.handle) != 0;
+    }
+
+    /**
+     * Constructs a file object that will be closed in the destructor.
+     *
+     * Params:
+     *   filename = The file to open.
+     *
+     * Returns: Opened file or an error.
+     */
+    static File open(const(char)* filename, BitFlags!Mode mode) @nogc nothrow
+    {
+        char[3] modeBuffer = "\0\0\0";
+
+        if (mode.truncate)
+        {
+            modeBuffer[0] = 'w';
+            if (mode.read)
+            {
+                modeBuffer[1] = '+';
+            }
+        }
+        else if (mode.append)
+        {
+            modeBuffer[0] = 'a';
+            if (mode.read)
+            {
+                modeBuffer[1] = '+';
+            }
+        }
+        else if (mode.read)
+        {
+            modeBuffer[0] = 'r';
+            if (mode.write)
+            {
+                modeBuffer[1] = '+';
+            }
+        }
+
+        auto newHandle = fopen(filename, modeBuffer.ptr);
+        auto newFile = File(newHandle);
+
+        if (newHandle is null)
+        {
+            newFile.status = Status.invalid;
+            newFile.storage.errorCode = ErrorCode(cast(ErrorCode.ErrorNo) errno);
+        }
+        else
+        {
+            if (mode == BitFlags!Mode(Mode.write))
+            {
+                rewind(newHandle);
+            }
+            newFile.status = Status.owned;
+        }
+
+        return newFile;
+    }
+}
+
+/**
+ * Reads the whole file and returns its contents.
+ *
+ * Params:
+ *   sourceFilename = Source filename.
+ *
+ * Returns: File contents or an error.
+ *
+ * See_Also: $(D_PSYMBOL File.read)
+ */
+SumType!(ErrorCode, Array!ubyte) readFile(String sourceFilename) @nogc
+{
+    enum size_t bufferSize = 255;
+    auto sourceFile = File.open(sourceFilename.toStringz, BitFlags!(File.Mode)(File.Mode.read));
+
+    if (!sourceFile.valid)
+    {
+        return typeof(return)(sourceFile.errorCode);
+    }
+    Array!ubyte sourceText;
+    size_t totalRead;
+    size_t bytesRead;
+    do
+    {
+        sourceText.length = sourceText.length + bufferSize;
+        const readStatus = sourceFile
+            .read(sourceText[totalRead .. $].get)
+            .match!(
+                (ErrorCode errorCode) => nullable(errorCode),
+                (size_t bytesRead_) {
+                    bytesRead = bytesRead_;
+                    return Nullable!ErrorCode();
+                }
+            );
+        if (!readStatus.isNull)
+        {
+            return typeof(return)(readStatus.get);
+        }
+        totalRead += bytesRead;
+    }
+    while (bytesRead == bufferSize);
+
+    sourceText.length = totalRead;
+
+    return typeof(return)(sourceText);
+}

source/elna/ir.d

@@ -0,0 +1,268 @@
+module elna.ir;
+
+import parser = elna.parser;
+import tanya.container.array;
+import tanya.container.hashtable;
+import tanya.container.string;
+import tanya.memory.allocator;
+public import elna.parser : BinaryOperator;
+
+/**
+ * Mapping between the parser and IR AST.
+ */
+struct ASTMapping
+{
+    alias Node = .Node;
+    alias Definition = .Definition;
+    alias VariableDeclaration = .VariableDeclaration;
+    alias Statement = .Operand;
+    alias BangStatement = .Operand;
+    alias Block = .Definition;
+    alias Expression = .Operand;
+    alias Number = .Number;
+    alias Variable = .Number;
+    alias BinaryExpression = .Variable;
+
+}
+
+/**
+ * IR visitor.
+*/
+interface IRVisitor
+{
+    abstract void visit(Node) @nogc;
+    abstract void visit(Definition) @nogc;
+    abstract void visit(Operand) @nogc;
+    abstract void visit(BinaryExpression) @nogc;
+    abstract void visit(Variable) @nogc;
+    abstract void visit(VariableDeclaration) @nogc;
+    abstract void visit(Number) @nogc;
+}
+
+/**
+ * AST node.
+ */
+abstract class Node
+{
+    abstract void accept(IRVisitor) @nogc;
+}
+
+/**
+ * Definition.
+ */
+class Definition : Node
+{
+    char[] identifier;
+    Array!BinaryExpression statements;
+    Array!VariableDeclaration variableDeclarations;
+    Operand result;
+
+    override void accept(IRVisitor visitor) @nogc
+    {
+        visitor.visit(this);
+    }
+}
+
+abstract class Statement : Node
+{
+}
+
+abstract class Operand : Node
+{
+    override void accept(IRVisitor visitor) @nogc
+    {
+        visitor.visit(this);
+    }
+}
+
+class Number : Operand
+{
+    int value;
+
+    override void accept(IRVisitor visitor) @nogc
+    {
+        visitor.visit(this);
+    }
+}
+
+class Variable : Operand
+{
+    size_t counter;
+
+    override void accept(IRVisitor visitor) @nogc
+    {
+        visitor.visit(this);
+    }
+}
+
+class VariableDeclaration : Node
+{
+    String identifier;
+
+    override void accept(IRVisitor visitor) @nogc
+    {
+        visitor.visit(this);
+    }
+}
+
+class BinaryExpression : Statement
+{
+    Operand lhs, rhs;
+    BinaryOperator operator;
+
+    this(Operand lhs, Operand rhs, BinaryOperator operator)
+    @nogc
+    {
+        this.lhs = lhs;
+        this.rhs = rhs;
+        this.operator = operator;
+    }
+
+    override void accept(IRVisitor visitor) @nogc
+    {
+        visitor.visit(this);
+    }
+}
+
+class BangExpression : Statement
+{
+    Operand operand;
+
+    this(Operand operand)
+    {
+        this.operand = operand;
+    }
+
+    override void accept(IRVisitor visitor) @nogc
+    {
+        visitor.visit(this);
+    }
+}
+
+final class TransformVisitor : parser.ParserVisitor!ASTMapping
+{
+    private HashTable!(String, int) constants;
+    private Array!BinaryExpression statements;
+
+    ASTMapping.Node visit(parser.Node node) @nogc
+    {
+        assert(false, "Not implemented");
+    }
+
+    ASTMapping.Definition visit(parser.Definition definition) @nogc
+    {
+        assert(false, "Not implemented");
+    }
+
+    ASTMapping.VariableDeclaration visit(parser.VariableDeclaration declaration) @nogc
+    {
+        assert(false, "Not implemented");
+    }
+
+    ASTMapping.BangStatement visit(parser.BangStatement statement) @nogc
+    {
+        return statement.expression.accept(this);
+    }
+
+    ASTMapping.Block visit(parser.Block block) @nogc
+    {
+        auto target = defaultAllocator.make!Definition;
+        this.constants = transformConstants(block.definitions);
+
+        target.result = block.statement.accept(this);
+        target.statements = this.statements;
+
+        target.variableDeclarations = transformVariableDeclarations(block.variableDeclarations);
+
+        return target;
+    }
+
+    ASTMapping.Expression visit(parser.Expression expression) @nogc
+    {
+        if ((cast(parser.Number) expression) !is null)
+        {
+            return (cast(parser.Number) expression).accept(this);
+        }
+        if ((cast(parser.Variable) expression) !is null)
+        {
+            return (cast(parser.Variable) expression).accept(this);
+        }
+        else if ((cast(parser.BinaryExpression) expression) !is null)
+        {
+            return (cast(parser.BinaryExpression) expression).accept(this);
+        }
+        assert(false, "Invalid expression type");
+    }
+
+    ASTMapping.Number visit(parser.Number number) @nogc
+    {
+        auto numberExpression = defaultAllocator.make!Number;
+        numberExpression.value = number.value;
+
+        return numberExpression;
+    }
+
+    ASTMapping.Variable visit(parser.Variable variable) @nogc
+    {
+        auto numberExpression = defaultAllocator.make!Number;
+        numberExpression.value = this.constants[variable.identifier];
+
+        return numberExpression;
+    }
+
+    ASTMapping.BinaryExpression visit(parser.BinaryExpression binaryExpression) @nogc
+    {
+        auto target = defaultAllocator.make!BinaryExpression(
+            binaryExpression.lhs.accept(this),
+            binaryExpression.rhs.accept(this),
+            binaryExpression.operator
+        );
+        statements.insertBack(target);
+
+        auto newVariable = defaultAllocator.make!Variable;
+        newVariable.counter = statements.length;
+
+        return newVariable;
+    }
+
+    private Number transformNumber(parser.Number number) @nogc
+    {
+        return defaultAllocator.make!Number(number.value);
+    }
+
+    override Operand visit(parser.Statement statement) @nogc
+    {
+        if ((cast(parser.BangStatement) statement) !is null)
+        {
+            return (cast(parser.BangStatement) statement).accept(this);
+        }
+        assert(false, "Invalid statement type");
+    }
+
+    private HashTable!(String, int) transformConstants(ref Array!(parser.Definition) definitions) @nogc
+    {
+        typeof(return) constants;
+
+        foreach (definition; definitions[])
+        {
+            constants[definition.identifier] = definition.number.value;
+        }
+
+        return constants;
+    }
+
+    Array!VariableDeclaration transformVariableDeclarations(ref Array!(parser.VariableDeclaration) variableDeclarations)
+    @nogc
+    {
+        typeof(return) variables;
+
+        foreach (ref variableDeclaration; variableDeclarations)
+        {
+            auto newDeclaration = defaultAllocator.make!VariableDeclaration;
+            newDeclaration.identifier = variableDeclaration.identifier;
+            variables.insertBack(newDeclaration);
+        }
+
+        return variables;
+    }
+}

source/elna/lexer.d

@@ -0,0 +1,254 @@
+module elna.lexer;
+
+import core.stdc.stdlib;
+import core.stdc.ctype;
+import core.stdc.string;
+import elna.result;
+import std.range;
+import tanya.container.array;
+import tanya.container.string;
+
+struct Token
+{
+    enum Type
+    {
+        number,
+        operator,
+        let,
+        identifier,
+        equals,
+        var,
+        semicolon,
+        leftParen,
+        rightParen,
+        bang,
+        dot,
+        comma,
+    }
+
+    union Value
+    {
+        int number;
+        String identifier;
+    }
+
+    private Type type;
+    private Value value_;
+    private Position position_;
+
+    @disable this();
+
+    this(Type type, Position position) @nogc nothrow pure @safe
+    {
+        this.type = type;
+        this.position_ = position;
+    }
+
+    this(Type type, int value, Position position) @nogc nothrow pure @trusted
+    in (type == Type.number)
+    {
+        this(type, position);
+        this.value_.number = value;
+    }
+
+    this()(Type type, auto ref String value, Position position)
+    @nogc nothrow pure @trusted
+    in (type == Type.identifier || type == Type.operator)
+    {
+        this(type, position);
+        this.value_.identifier = value;
+    }
+
+    /**
+     * Params:
+     *   type = Expected type.
+     *
+     * Returns: Whether this token is of the expected type.
+     */
+    bool ofType(Type type) const @nogc nothrow pure @safe
+    {
+        return this.type == type;
+    }
+
+    @property auto value(Type type)() @nogc nothrow pure @trusted
+    in (ofType(type))
+    {
+        static if (type == Type.number)
+        {
+            return this.value_.number;
+        }
+        else static if (type == Type.identifier || type == Type.operator)
+        {
+            return this.value_.identifier;
+        }
+        else
+        {
+            static assert(false, "This type doesn't have a value");
+        }
+    }
+
+    /**
+     * Returns: The token position in the source text.
+     */
+    @property const(Position) position() const @nogc nothrow pure @safe
+    {
+        return this.position_;
+    }
+}
+
+/**
+ * Range over the source text that keeps track of the current position.
+ */
+struct Source
+{
+    char[] buffer;
+    Position position;
+
+    this(char[] buffer) @nogc nothrow pure @safe
+    {
+        this.buffer = buffer;
+    }
+
+    @disable this();
+
+    bool empty() @nogc nothrow pure @safe
+    {
+        return this.length == 0;
+    }
+
+    char front() @nogc nothrow pure @safe
+    in (!empty)
+    {
+        return this.buffer[0];
+    }
+
+    void popFront() @nogc nothrow pure @safe
+    in (!empty)
+    {
+        this.buffer = buffer[1 .. $];
+        ++this.position.column;
+    }
+
+    void breakLine() @nogc nothrow pure @safe
+    in (!empty)
+    {
+        this.buffer = buffer[1 .. $];
+        ++this.position.line;
+        this.position.column = 1;
+    }
+
+    @property size_t length() const @nogc nothrow pure @safe
+    {
+        return this.buffer.length;
+    }
+
+    char opIndex(size_t index) @nogc nothrow pure @safe
+    in (index < length)
+    {
+        return this.buffer[index];
+    }
+
+    char[] opSlice(size_t i, size_t j) @nogc nothrow pure @safe
+    in
+    {
+        assert(i <= j);
+        assert(j <= length);
+    }
+    do
+    {
+        return this.buffer[i .. j];
+    }
+}
+
+Result!(Array!Token) lex(char[] buffer) @nogc
+{
+    Array!Token tokens;
+    auto source = Source(buffer);
+
+    while (!source.empty)
+    {
+        if (source.front == ' ')
+        {
+            source.popFront;
+        }
+        else if (source.front >= '0' && source.front <= '9') // Multi-digit.
+        {
+            tokens.insertBack(Token(Token.Type.number, source.front - '0', source.position));
+            source.popFront;
+        }
+        else if (source.front == '=')
+        {
+            tokens.insertBack(Token(Token.Type.equals, source.position));
+            source.popFront;
+        }
+        else if (source.front == '(')
+        {
+            tokens.insertBack(Token(Token.Type.leftParen, source.position));
+            source.popFront;
+        }
+        else if (source.front == ')')
+        {
+            tokens.insertBack(Token(Token.Type.rightParen, source.position));
+            source.popFront;
+        }
+        else if (source.front == ';')
+        {
+            tokens.insertBack(Token(Token.Type.semicolon, source.position));
+            source.popFront;
+        }
+        else if (source.front == ',')
+        {
+            tokens.insertBack(Token(Token.Type.comma, source.position));
+            source.popFront;
+        }
+        else if (source.front == '!')
+        {
+            tokens.insertBack(Token(Token.Type.bang, source.position));
+            source.popFront;
+        }
+        else if (source.front == '.')
+        {
+            tokens.insertBack(Token(Token.Type.dot, source.position));
+            source.popFront;
+        }
+        else if (isalpha(source.front))
+        {
+            size_t i = 1;
+            while (i < source.length && isalpha(source[i]))
+            {
+                ++i;
+            }
+            if (source[0 .. i] == "const")
+            {
+                tokens.insertBack(Token(Token.Type.let, source.position));
+            }
+            else if (source[0 .. i] == "var")
+            {
+                tokens.insertBack(Token(Token.Type.var, source.position));
+            }
+            else
+            {
+                auto identifier = String(source[0 .. i]);
+                tokens.insertBack(Token(Token.Type.identifier, identifier, source.position));
+            }
+            source.popFrontN(i);
+        }
+        else if (source.front == '+' || source.front == '-')
+        {
+            String operator;
+
+            operator.insertBack(source.front);
+            tokens.insertBack(Token(Token.Type.operator, operator, source.position));
+            source.popFront;
+        }
+        else if (source.front == '\n')
+        {
+            source.breakLine;
+        }
+        else
+        {
+            return typeof(return)("Unexptected next character", source.position);
+        }
+    }
+    return typeof(return)(tokens);
+}

source/elna/parser.d

@@ -0,0 +1,372 @@
+module elna.parser;
+
+import elna.lexer;
+import elna.result;
+import tanya.container.array;
+import tanya.container.string;
+import tanya.memory.allocator;
+
+
+/**
+ * Parser visitor.
+ */
+interface ParserVisitor(Mapping)
+{
+    Mapping.Node visit(Node) @nogc;
+    Mapping.Definition visit(Definition) @nogc;
+    Mapping.VariableDeclaration visit(VariableDeclaration) @nogc;
+    Mapping.Statement visit(Statement) @nogc;
+    Mapping.BangStatement visit(BangStatement) @nogc;
+    Mapping.Block visit(Block) @nogc;
+    Mapping.Expression visit(Expression) @nogc;
+    Mapping.Number visit(Number) @nogc;
+    Mapping.Variable visit(Variable) @nogc;
+    Mapping.BinaryExpression visit(BinaryExpression) @nogc;
+}
+
+/**
+ * AST node.
+ */
+abstract class Node
+{
+    Mapping.Node accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+/**
+ * Constant definition.
+ */
+class Definition : Node
+{
+    Number number;
+    String identifier;
+
+    Mapping.Definition accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+/**
+ * Variable declaration.
+ */
+class VariableDeclaration : Node
+{
+    String identifier;
+
+    Mapping.VariableDeclaration accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+abstract class Statement : Node
+{
+    Mapping.Statement accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+class BangStatement : Statement
+{
+    Expression expression;
+
+    Mapping.BangStatement accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+class Block : Node
+{
+    Array!Definition definitions;
+    Array!VariableDeclaration variableDeclarations;
+    Statement statement;
+
+    Mapping.Block accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+abstract class Expression : Node
+{
+    Mapping.Expression accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+class Number : Expression
+{
+    int value;
+
+    Mapping.Number accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+class Variable : Expression
+{
+    String identifier;
+
+    Mapping.Variable accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+enum BinaryOperator
+{
+    sum,
+    subtraction
+}
+
+class BinaryExpression : Expression
+{
+    Expression lhs, rhs;
+    BinaryOperator operator;
+
+    this(Expression lhs, Expression rhs, String operator) @nogc
+    {
+        this.lhs = lhs;
+        this.rhs = rhs;
+        if (operator == "+")
+        {
+            this.operator = BinaryOperator.sum;
+        }
+        else if (operator == "-")
+        {
+            this.operator = BinaryOperator.subtraction;
+        }
+        else
+        {
+            assert(false, "Invalid binary operator");
+        }
+    }
+
+    Mapping.BinaryExpression accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
+    {
+        return visitor.visit(this);
+    }
+}
+
+private Result!Expression parseFactor(ref Array!Token.Range tokens) @nogc
+in (!tokens.empty, "Expected factor, got end of stream")
+{
+    if (tokens.front.ofType(Token.Type.identifier))
+    {
+        auto variable = defaultAllocator.make!Variable;
+        variable.identifier = tokens.front.value!(Token.Type.identifier);
+        tokens.popFront;
+        return Result!Expression(variable);
+    }
+    else if (tokens.front.ofType(Token.Type.number))
+    {
+        auto number = defaultAllocator.make!Number;
+        number.value = tokens.front.value!(Token.Type.number);
+        tokens.popFront;
+        return Result!Expression(number);
+    }
+    else if (tokens.front.ofType(Token.Type.leftParen))
+    {
+        tokens.popFront;
+
+        auto expression = parseExpression(tokens);
+
+        tokens.popFront;
+        return expression;
+    }
+    return Result!Expression("Expected a factor", tokens.front.position);
+}
+
+private Result!Expression parseTerm(ref Array!(Token).Range tokens) @nogc
+{
+    return parseFactor(tokens);
+}
+
+private Result!Expression parseExpression(ref Array!(Token).Range tokens) @nogc
+in (!tokens.empty, "Expected expression, got end of stream")
+{
+    auto term = parseTerm(tokens);
+    if (!term.valid || tokens.empty || !tokens.front.ofType(Token.Type.operator))
+    {
+        return term;
+    }
+    auto operator = tokens.front.value!(Token.Type.operator);
+    tokens.popFront;
+
+    auto expression = parseExpression(tokens);
+
+    if (expression.valid)
+    {
+        auto binaryExpression = defaultAllocator
+            .make!BinaryExpression(term.result, expression.result, operator);
+
+        return Result!Expression(binaryExpression);
+    }
+    else
+    {
+        return Result!Expression("Expected right-hand side to be an expression", tokens.front.position);
+    }
+}
+
+private Result!Definition parseDefinition(ref Array!Token.Range tokens) @nogc
+in (!tokens.empty, "Expected definition, got end of stream")
+{
+    auto definition = defaultAllocator.make!Definition;
+    definition.identifier = tokens.front.value!(Token.Type.identifier); // Copy.
+
+    tokens.popFront();
+    tokens.popFront(); // Skip the equals sign.
+
+    if (tokens.front.ofType(Token.Type.number))
+    {
+        auto number = defaultAllocator.make!Number;
+        number.value = tokens.front.value!(Token.Type.number);
+        definition.number = number;
+        tokens.popFront;
+        return Result!Definition(definition);
+    }
+    return Result!Definition("Expected a number", tokens.front.position);
+}
+
+private Result!Statement parseStatement(ref Array!Token.Range tokens) @nogc
+in (!tokens.empty, "Expected block, got end of stream")
+{
+    if (tokens.front.ofType(Token.Type.bang))
+    {
+        tokens.popFront;
+        auto statement = defaultAllocator.make!BangStatement;
+        auto expression = parseExpression(tokens);
+        if (expression.valid)
+        {
+            statement.expression = expression.result;
+        }
+        else
+        {
+            return Result!Statement(expression.error.get);
+        }
+        return Result!Statement(statement);
+    }
+    return Result!Statement("Expected ! statement", tokens.front.position);
+}
+
+private Result!(Array!Definition) parseDefinitions(ref Array!Token.Range tokens) @nogc
+in (!tokens.empty, "Expected definition, got end of stream")
+{
+    tokens.popFront; // Skip const.
+
+    Array!Definition definitions;
+
+    while (!tokens.empty)
+    {
+        auto definition = parseDefinition(tokens);
+        if (!definition.valid)
+        {
+            return typeof(return)(definition.error.get);
+        }
+        definitions.insertBack(definition.result);
+        if (tokens.front.ofType(Token.Type.semicolon))
+        {
+            break;
+        }
+        if (tokens.front.ofType(Token.Type.comma))
+        {
+            tokens.popFront;
+        }
+    }
+
+    return typeof(return)(definitions);
+}
+
+private Result!(Array!VariableDeclaration) parseVariableDeclarations(ref Array!Token.Range tokens) @nogc
+in (!tokens.empty, "Expected variable declarations, got end of stream")
+{
+    tokens.popFront; // Skip var.
+
+    Array!VariableDeclaration variableDeclarations;
+
+    while (!tokens.empty)
+    {
+        auto currentToken = tokens.front;
+        if (currentToken.ofType(Token.Type.identifier))
+        {
+            auto variableDeclaration = defaultAllocator.make!VariableDeclaration;
+            variableDeclaration.identifier = currentToken.value!(Token.Type.identifier);
+            variableDeclarations.insertBack(variableDeclaration);
+            tokens.popFront;
+        }
+        else
+        {
+            return typeof(return)("Expected variable name", tokens.front.position);
+        }
+        if (tokens.empty)
+        {
+            return typeof(return)("Expected \";\" or \",\" name", currentToken.position);
+        }
+        if (tokens.front.ofType(Token.Type.semicolon))
+        {
+            break;
+        }
+        if (tokens.front.ofType(Token.Type.comma))
+        {
+            tokens.popFront;
+        }
+    }
+
+    return typeof(return)(variableDeclarations);
+}
+
+private Result!Block parseBlock(ref Array!Token.Range tokens) @nogc
+in (!tokens.empty, "Expected block, got end of stream")
+{
+    auto block = defaultAllocator.make!Block;
+    if (tokens.front.ofType(Token.Type.let))
+    {
+        auto constDefinitions = parseDefinitions(tokens);
+        if (constDefinitions.valid)
+        {
+            block.definitions = constDefinitions.result;
+        }
+        else
+        {
+            return Result!Block(constDefinitions.error.get);
+        }
+        tokens.popFront;
+    }
+    if (tokens.front.ofType(Token.Type.var))
+    {
+        auto variableDeclarations = parseVariableDeclarations(tokens);
+        if (variableDeclarations.valid)
+        {
+            block.variableDeclarations = variableDeclarations.result;
+        }
+        else
+        {
+            return Result!Block(variableDeclarations.error.get);
+        }
+        tokens.popFront;
+    }
+    auto statement = parseStatement(tokens);
+    if (statement.valid)
+    {
+        block.statement = statement.result;
+    }
+    else
+    {
+        return Result!Block(statement.error.get);
+    }
+
+    return Result!Block(block);
+}
+
+Result!Block parse(ref Array!Token tokenStream) @nogc
+{
+    auto tokens = tokenStream[];
+    return parseBlock(tokens);
+}

source/elna/result.d

@@ -0,0 +1,107 @@
+module elna.result;
+
+import std.typecons;
+import tanya.container.array;
+import tanya.container.string;
+
+/**
+ * Position in the source text.
+ */
+struct Position
+{
+    /// Line.
+    size_t line = 1;
+
+    /// Column.
+    size_t column = 1;
+}
+
+struct CompileError
+{
+    private string message_;
+
+    private Position position_;
+
+    @disable this();
+
+    /**
+     * Params:
+     *   message = Error text.
+     *   position = Error position in the source text.
+     */
+    this(string message, Position position) @nogc nothrow pure @safe
+    {
+        this.message_ = message;
+        this.position_ = position;
+    }
+
+    /// Error text.
+    @property string message() const @nogc nothrow pure @safe
+    {
+        return this.message_;
+    }
+
+    /// Error line in the source text.
+    @property size_t line() const @nogc nothrow pure @safe
+    {
+        return this.position_.line;
+    }
+
+    /// Error column in the source text.
+    @property size_t column() const @nogc nothrow pure @safe
+    {
+        return this.position_.column;
+    }
+}
+
+struct Result(T)
+{
+    Nullable!CompileError error;
+    T result;
+
+    this(T result)
+    {
+        this.result = result;
+        this.error = typeof(this.error).init;
+    }
+
+    this(string message, Position position)
+    {
+        this.result = T.init;
+        this.error = CompileError(message, position);
+    }
+
+    this(CompileError compileError)
+    {
+        this.result = null;
+        this.error = compileError;
+    }
+
+    @disable this();
+
+    @property bool valid() const
+    {
+        return error.isNull;
+    }
+}
+
+struct Reference
+{
+    enum Target
+    {
+        text,
+        high20,
+        lower12i
+    }
+
+    String name;
+    size_t offset;
+    Target target;
+}
+
+struct Symbol
+{
+    String name;
+    Array!ubyte text;
+    Array!Reference symbols;
+}

source/elna/riscv.d

@@ -0,0 +1,363 @@
+module elna.riscv;
+
+import core.stdc.stdlib;
+import elna.extended;
+import elna.ir;
+import elna.result;
+import std.algorithm;
+import std.typecons;
+import tanya.container.array;
+import tanya.container.string;
+
+enum XRegister : ubyte
+{
+    zero = 0,
+    ra = 1,
+    sp = 2,
+    gp = 3,
+    tp = 4,
+    t0 = 5,
+    t1 = 6,
+    t2 = 7,
+    s0 = 8,
+    s1 = 9,
+    a0 = 10,
+    a1 = 11,
+    a2 = 12,
+    a3 = 13,
+    a4 = 14,
+    a5 = 15,
+    a6 = 16,
+    a7 = 17,
+    s2 = 18,
+    s3 = 19,
+    s4 = 20,
+    s5 = 21,
+    s6 = 22,
+    s7 = 23,
+    s8 = 24,
+    s9 = 25,
+    s10 = 26,
+    s11 = 27,
+    t3 = 28,
+    t4 = 29,
+    t5 = 30,
+    t6 = 31,
+}
+
+enum Funct3 : ubyte
+{
+    addi = 0b000,
+    slti = 0b001,
+    sltiu = 0b011,
+    andi = 0b111,
+    ori = 0b110,
+    xori = 0b100,
+    slli = 0b000,
+    srli = 0b101,
+    srai = 0b101,
+    add = 0b000,
+    slt = 0b010,
+    sltu = 0b011,
+    and = 0b111,
+    or = 0b110,
+    xor = 0b100,
+    sll = 0b001,
+    srl = 0b101,
+    sub = 0b000,
+    sra = 0b101,
+    beq = 0b000,
+    bne = 0b001,
+    blt = 0b100,
+    bltu = 0b110,
+    bge = 0b101,
+    bgeu = 0b111,
+    fence = 0b000,
+    fenceI = 0b001,
+    csrrw = 0b001,
+    csrrs = 0b010,
+    csrrc = 0b011,
+    csrrwi = 0b101,
+    csrrsi = 0b110,
+    csrrci = 0b111,
+    priv = 0b000,
+    sb = 0b000,
+    sh = 0b001,
+    sw = 0b010,
+    lb = 0b000,
+    lh = 0b001,
+    lw = 0b010,
+    lbu = 0b100,
+    lhu = 0b101,
+    jalr = 0b000,
+}
+
+enum Funct12 : ubyte
+{
+    ecall = 0b000000000000,
+    ebreak = 0b000000000001,
+}
+
+enum Funct7 : ubyte
+{
+    none = 0,
+    sub = 0b0100000
+}
+
+enum BaseOpcode : ubyte
+{
+    opImm = 0b0010011,
+    lui = 0b0110111,
+    auipc = 0b0010111,
+    op = 0b0110011,
+    jal = 0b1101111,
+    jalr = 0b1100111,
+    branch = 0b1100011,
+    load = 0b0000011,
+    store = 0b0100011,
+    miscMem = 0b0001111,
+    system = 0b1110011,
+}
+
+struct Instruction
+{
+    private uint instruction;
+
+    this(BaseOpcode opcode) @nogc
+    {
+        this.instruction = opcode;
+    }
+    @disable this();
+
+    ref Instruction i(XRegister rd, Funct3 funct3, XRegister rs1, uint immediate)
+    return scope @nogc
+    {
+        this.instruction |= (rd << 7)
+            | (funct3 << 12)
+            | (rs1 << 15)
+            | (immediate << 20);
+
+        return this;
+    }
+
+    ref Instruction s(uint imm1, Funct3 funct3, XRegister rs1, XRegister rs2)
+    return scope @nogc
+    {
+        this.instruction |= ((imm1 & 0b11111) << 7)
+            | (funct3 << 12)
+            | (rs1 << 15)
+            | (rs2 << 20)
+            | ((imm1 & 0b111111100000) << 20);
+
+        return this;
+    }
+
+    ref Instruction r(XRegister rd, Funct3 funct3, XRegister rs1, XRegister rs2, Funct7 funct7 = Funct7.none)
+    return scope @nogc
+    {
+        this.instruction |= (rd << 7)
+            | (funct3 << 12)
+            | (rs1 << 15)
+            | (rs2 << 20)
+            | (funct7 << 25);
+
+        return this;
+    }
+
+    ref Instruction u(XRegister rd, uint imm)
+    return scope @nogc
+    {
+        this.instruction |= (rd << 7) | (imm << 12);
+
+        return this;
+    }
+
+    ubyte* encode() return scope @nogc
+    {
+        return cast(ubyte*) (&this.instruction);
+    }
+}
+
+class RiscVVisitor : IRVisitor
+{
+    Array!Instruction instructions;
+    bool registerInUse;
+    uint variableCounter = 1;
+    Array!Reference references;
+
+    override void visit(Node) @nogc
+    {
+    }
+
+    override void visit(Definition definition) @nogc
+    {
+        const uint stackSize = cast(uint) (definition.statements.length * 4 + 12);
+
+        // Prologue.
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.opImm)
+                .i(XRegister.sp, Funct3.addi, XRegister.sp, -stackSize)
+        );
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.store)
+                .s(stackSize - 4, Funct3.sw, XRegister.sp, XRegister.s0)
+        );
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.store)
+                .s(stackSize - 8, Funct3.sw, XRegister.sp, XRegister.ra)
+        );
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.opImm)
+                .i(XRegister.s0, Funct3.addi, XRegister.sp, stackSize)
+        );
+
+        foreach (statement; definition.statements[])
+        {
+            statement.accept(this);
+        }
+        foreach (variableDeclaration; definition.variableDeclarations[])
+        {
+            variableDeclaration.accept(this);
+        }
+        this.registerInUse = true;
+        definition.result.accept(this);
+        this.registerInUse = false;
+
+        // Print the result.
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.opImm)
+                .i(XRegister.a1, Funct3.addi, XRegister.a0, 0)
+        );
+        this.references.insertBack(Reference(String(".CL0"), instructions.length * 4, Reference.Target.high20));
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.lui).u(XRegister.a5, 0)
+        );
+        this.references.insertBack(Reference(String(".CL0"), instructions.length * 4, Reference.Target.lower12i));
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.opImm).i(XRegister.a0, Funct3.addi, XRegister.a5, 0)
+        );
+        this.references.insertBack(Reference(String("printf"), instructions.length * 4, Reference.Target.text));
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.auipc).u(XRegister.ra, 0)
+        );
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.jalr)
+                .i(XRegister.ra, Funct3.jalr, XRegister.ra, 0)
+        );
+        // Set the return value (0).
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.op)
+                .r(XRegister.a0, Funct3.and, XRegister.zero, XRegister.zero)
+        );
+
+        // Epilogue.
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.load)
+                .i(XRegister.s0, Funct3.lw, XRegister.sp, stackSize - 4)
+        );
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.load)
+                .i(XRegister.ra, Funct3.lw, XRegister.sp, stackSize - 8)
+        );
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.opImm)
+                .i(XRegister.sp, Funct3.addi, XRegister.sp, stackSize)
+        );
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.jalr)
+                .i(XRegister.zero, Funct3.jalr, XRegister.ra, 0)
+        );
+    }
+
+    override void visit(Operand operand) @nogc
+    {
+        if ((cast(Variable) operand) !is null)
+        {
+            return (cast(Variable) operand).accept(this);
+        }
+        if ((cast(Number) operand) !is null)
+        {
+            return (cast(Number) operand).accept(this);
+        }
+    }
+
+    override void visit(Variable variable) @nogc
+    {
+        const freeRegister = this.registerInUse ? XRegister.a0 : XRegister.t0;
+
+        // movl -x(%rbp), %eax; where x is a number.
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.load)
+                .i(freeRegister, Funct3.lw, XRegister.sp,
+                    cast(byte) (variable.counter * 4))
+        );
+    }
+
+    override void visit(VariableDeclaration) @nogc
+    {
+    }
+
+    override void visit(Number number) @nogc
+    {
+        const freeRegister = this.registerInUse ? XRegister.a0 : XRegister.t0;
+
+        this.instructions.insertBack(
+            Instruction(BaseOpcode.opImm) // movl $x, %eax; where $x is a number.
+                .i(freeRegister, Funct3.addi, XRegister.zero, number.value)
+        );
+    }
+
+    override void visit(BinaryExpression expression) @nogc
+    {
+        this.registerInUse = true;
+        expression.lhs.accept(this);
+        this.registerInUse = false;
+        expression.rhs.accept(this);
+
+        // Calculate the result and assign it to a variable on the stack.
+        final switch (expression.operator)
+        {
+            case BinaryOperator.sum:
+                this.instructions.insertBack(
+                    Instruction(BaseOpcode.op)
+                        .r(XRegister.a0, Funct3.add, XRegister.a0, XRegister.t0)
+                );
+                break;
+            case BinaryOperator.subtraction:
+                this.instructions.insertBack(
+                    Instruction(BaseOpcode.op)
+                        .r(XRegister.a0, Funct3.sub, XRegister.a0, XRegister.t0, Funct7.sub)
+                );
+                break;
+        }
+        this.instructions.insertBack( // movl %eax, -x(%rbp); where x is a number.
+            Instruction(BaseOpcode.store)
+                .s(cast(uint) (this.variableCounter * 4), Funct3.sw, XRegister.sp, XRegister.a0)
+        );
+
+        ++this.variableCounter;
+    }
+}
+
+Symbol writeNext(Definition ast) @nogc
+{
+    Array!Instruction instructions;
+    Array!Reference references;
+    auto visitor = cast(RiscVVisitor) malloc(__traits(classInstanceSize, RiscVVisitor));
+    (cast(void*) visitor)[0 .. __traits(classInstanceSize, RiscVVisitor)] = __traits(initSymbol, RiscVVisitor)[];
+    scope (exit)
+    {
+        visitor.__xdtor();
+        free(cast(void*) visitor);
+    }
+    visitor.visit(ast);
+
+    auto program = Symbol(String("main"));
+
+    program.symbols = move(visitor.references);
+    foreach (ref instruction; visitor.instructions)
+    {
+        program.text.insertBack(instruction.encode[0 .. uint.sizeof]);
+    }
+    return program;
+}

source/lexer.cpp

@@ -9,22 +9,23 @@ namespace elna
 
     source::const_iterator source::begin() const
     {
-        return source::const_iterator(std::cbegin(m_buffer), Position());
+        return source::const_iterator(std::cbegin(m_buffer));
     }
 
     source::const_iterator source::end() const
     {
-        Position end_position{ 0, 0 };
+        source_position end_position{ 0, 0 };
 
         return source::const_iterator(std::cend(m_buffer), end_position);
     }
 
-    source::const_iterator::const_iterator(std::string::const_iterator buffer, const Position& start_position)
+    source::const_iterator::const_iterator(std::string::const_iterator buffer,
+            const source_position start_position)
         : m_buffer(buffer), m_position(start_position)
     {
     }
 
-    const Position& source::const_iterator::position() const noexcept
+    const source_position& source::const_iterator::position() const noexcept
     {
         return this->m_position;
     }
@@ -87,7 +88,7 @@ namespace elna
         return m_value;
     }
 
-    const Position& token::position() const noexcept
+    const source_position& token::position() const noexcept
     {
         return m_position;
     }

source/main.d

@@ -0,0 +1,33 @@
+import elna.backend;
+import elna.ir;
+import elna.arguments;
+import std.path;
+import std.sumtype;
+import tanya.container.string;
+import tanya.memory.allocator;
+import tanya.memory.mmappool;
+
+int main(string[] args)
+{
+    defaultAllocator = MmapPool.instance;
+
+    return Arguments.parse(args).match!(
+        (ArgumentError argumentError) => 4,
+        (Arguments arguments) {
+            String outputFilename;
+            if (arguments.output is null)
+            {
+                outputFilename = arguments
+                    .inFile
+                    .baseName
+                    .withExtension("o");
+            }
+            else
+            {
+                outputFilename = String(arguments.output);
+            }
+
+            return generate(arguments.inFile, outputFilename);
+        }
+    );
+}

tests/7_member_sum.eln

@@ -0,0 +1 @@
+! 3 + 4 + 5 + 1 + 2 + 4 + 3

tests/const_list.eln

@@ -0,0 +1,3 @@
+const a = 1, b = 2;
+! a + b
+.

tests/expectations/7_member_sum.txt

@@ -0,0 +1 @@
+22

tests/expectations/const_list.txt

@@ -0,0 +1 @@
+3

tests/expectations/left_nested_sum.txt

@@ -0,0 +1 @@
+8

tests/expectations/print_number.txt

@@ -0,0 +1 @@
+3

tests/expectations/subtraction.txt

@@ -0,0 +1 @@
+1

tests/expectations/sum.txt

@@ -0,0 +1 @@
+8

tests/expectations/sums.txt

@@ -0,0 +1 @@
+8

tests/left_nested_sum.eln

@@ -0,0 +1,2 @@
+! (3 + 4) + 1
+.

tests/print_number.eln

@@ -0,0 +1,2 @@
+! 3
+.

tests/runner.cpp

@@ -35,11 +35,48 @@ namespace elna
         }
     }
 
+    static std::string in_build_directory(const std::filesystem::path& path)
+    {
+        return "build/riscv" / path;
+    }
+
+    static int build_test(const std::filesystem::directory_entry& test_entry)
+    {
+        const std::filesystem::path test_filename = test_entry.path().filename();
+
+        std::filesystem::path test_binary = in_build_directory(test_filename);
+        std::filesystem::path test_object = test_binary;
+        test_binary.replace_extension();
+        test_object.replace_extension(".o");
+
+        std::filesystem::remove(test_binary);
+        std::filesystem::remove(test_object);
+
+        auto status = boost::process::system("./build/bin/elna",
+                "-o", test_object.string(), test_entry.path().string());
+        if (status != 0)
+        {
+            return status;
+        }
+        status = boost::process::system(
+                "/opt/riscv/bin/riscv32-unknown-elf-ld",
+                "-o", test_binary.string(),
+                "-L/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/",
+                "-L/opt/riscv/riscv32-unknown-elf/lib",
+                "/opt/riscv/riscv32-unknown-elf/lib/crt0.o",
+                "/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/crtbegin.o",
+               test_object.string(),
+                "--start-group", "-lgcc", "-lc", "-lgloss", "--end-group",
+                "/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/crtend.o"
+        );
+        return status;
+    }
+
     static int run_test(const std::filesystem::directory_entry& test_entry)
     {
         const std::filesystem::path test_filename = test_entry.path().filename();
 
-        std::filesystem::path test_binary = "build/riscv" / test_filename;
+        std::filesystem::path test_binary = in_build_directory(test_filename);
         test_binary.replace_extension();
 
         std::filesystem::path expectation_path = test_entry.path().parent_path() / "expectations" / test_filename;
@@ -75,7 +112,23 @@ namespace elna
             {
                 continue;
             }
-            results.add_exit_code(run_test(test_entry));
+            int status{ 0 };
+
+            try
+            {
+                status = build_test(test_entry);
+            }
+            catch (const boost::process::process_error& exception)
+            {
+                std::cout << exception.what() << std::endl;
+                status = 3;
+                continue;
+            }
+            if (status == 0)
+            {
+                status = run_test(test_entry);
+            }
+            results.add_exit_code(status);
         }
         return results;
     }

tests/subtraction.eln

@@ -0,0 +1,2 @@
+! 5 - 4
+.

tests/sum.eln

@@ -0,0 +1,2 @@
+! 1 + 7
+.

tests/sums.eln

@@ -0,0 +1,2 @@
+! 1 + (3 + 4)
+.