wip: refactor the hawk compilation process

It is a bit of a mess right now. I'm trying to get it to smell a bit
more like a traditional compiler architecture.

Author: sillydan1

src/parser/hawk/compiler.cpp

@@ -0,0 +1,31 @@
+#include "compiler.h"
+#include <overload>
+#include <variant>
+
+namespace aaltitoad::hawk {
+    compiler::compiler(const frontend::scanner& scanner, const frontend::parser& parser, const middleend::semantic_analyzer& analyzer, const middleend::optimizer& optimizer, const backend::generator& generator)
+        : scanner{scanner}, parser{parser}, analyzer{analyzer}, optimizer{optimizer}, generator{generator}, symbols{}, diagnostic_factory{}
+    {
+
+    }
+
+    void compiler::add_symbols(const expr::symbol_table_t& symbols) {
+        this->symbols.put(symbols);
+    }
+
+    void compiler::clear_symbols() {
+        symbols.clear();
+    }
+
+    auto compiler::compile(const std::string& path) -> result<ntta_t> {
+        auto stream = scanner.scan(*this, path);
+        std::visit(ya::overload(
+            [](const std::string& stream){},
+            [](const error& err){}
+        ), stream);
+        auto ast = parser.parse(*this, stream);
+        auto dast = analyzer.analyze(*this, ast);
+        optimizer.optimize(*this, dast);
+        return generator.generate(*this, dast);
+    }
+}

src/parser/hawk/compiler.h

@@ -0,0 +1,67 @@
+#ifndef AALTITOAD_HAWK_COMPILER_H
+#define AALTITOAD_HAWK_COMPILER_H
+#include "ntta/tta.h"
+#include "parser/hawk/diagnostics.h"
+#include "symbol_table.h"
+#include <string>
+
+namespace aaltitoad::hawk {
+    class compiler;
+
+    struct error {
+        diagnostic diagnostic;
+    };
+    template<typename ok>
+    using result = std::variant<error, ok>; // TODO: Consider making this a simple yalibs thing
+
+    namespace frontend {
+        struct scanner {
+            virtual auto scan(compiler& ctx, const std::string& path) const noexcept -> result<std::string> = 0;  // TODO: probably shouldnt be a string output...
+        };
+
+        struct parser { 
+            virtual auto parse(compiler& ctx, const std::string& stream) const noexcept -> result<int> = 0;  // TODO: Should be an AST output
+        };
+    }
+
+    namespace middleend {
+        struct semantic_analyzer {
+            virtual auto analyze(compiler& ctx, const int& ast) const noexcept -> result<int> = 0; // TODO: Should be an ast output
+        };
+
+        struct optimizer {
+            // Note that optimizers are not allowed to return errors, but can throw exceptions.
+            virtual void optimize(compiler& ctx, int& ast) const = 0;
+        };
+    }
+
+    namespace backend {
+        struct generator {
+            virtual auto generate(compiler& ctx, const int& ast) const noexcept -> result<ntta_t> = 0;
+        };
+    }
+
+    class compiler {
+    public:
+        compiler(const frontend::scanner& scanner,
+                const frontend::parser& parser,
+                const middleend::semantic_analyzer& analyzer,
+                const middleend::optimizer& optimizer,
+                const backend::generator& generator);
+        void add_symbols(const expr::symbol_table_t& symbols);
+        void clear_symbols();
+        auto get_diagnostic_factory() -> diagnostic_factory&;
+        auto compile(const std::string& path) -> result<ntta_t>;
+
+    private:
+        const frontend::scanner& scanner;
+        const frontend::parser& parser;
+        const middleend::semantic_analyzer& analyzer;
+        const middleend::optimizer& optimizer;
+        const backend::generator& generator;
+        expr::symbol_table_t symbols;
+        diagnostic_factory diagnostic_factory;
+    };
+}
+
+#endif // AALTITOAD_HAWK_COMPILER_H

src/parser/hawk/diagnostics.h

@@ -17,7 +17,7 @@ namespace aaltitoad::hawk {
         // TODO: suggestion generator
     public:
         diagnostic_factory() = default;
-        auto without_context() -> diagnostic_factory&;
+        auto without_context() const -> diagnostic_factory&;
         auto with_model_key(const std::string& key) -> diagnostic_factory&;
         auto with_context(const std::string& element) -> diagnostic_factory&;
         auto with_context(const std::initializer_list<std::string>& elements) -> diagnostic_factory&;