1 files changed, 79 insertions, 56 deletions

diff --git a/main.cpp b/main.cpp
index e88d740..f172226 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,89 +1,112 @@
-#include <initializer_list>
+#include <fmt/core.h>
 #include <iostream>
-#include <map>
 #include <memory>
 #include <optional>
 #include <string>
-#include <type_traits>
 #include <utility>
-#include <vector>
 
 #include "aisa/aisa.h"
-#include "aisa/eval.h"
+#include "aisa/async.h"
+#include "aisa/simple-models.h"
 #include "git-tag.h"
+#include "isa/fib/fib.h"
+
+const bool show_mem_fetch = false;
+const bool show_mem_store = true;
+const bool show_regs = false;
+const bool show_steps = true;
+const bool show_tasks = false;
 
 int main(int argc, const char *argv[])
 {
     std::cout << "Version " << GIT_TAG << "\n";
 
-    struct CopyStep : public aisa::Step {
-        CopyStep(std::pair<aisa::regnum_t, aisa::regval_t> pred, const std::initializer_list<std::pair<aisa::regnum_t, aisa::regnum_t>> &regs)
+    isa::fib::Fib<2> fib;
+
+    struct Eval : public aisa::AsyncEval<Eval>, aisa::PagedMem<>, aisa::TaskStack, aisa::VectorRF {
+        bool fetch_mem(aisa::byte_t *bytes, aisa::addr_t addr, aisa::addr_t size)
         {
-            predicate = std::move(pred);
-            source_regs.reserve(regs.size());
-            destination_regs.reserve(regs.size());
-            for (const auto &rp : regs) {
-                source_regs.emplace_back(rp.first);
-                destination_regs.emplace_back(rp.second);
+            if (aisa::PagedMem<>::fetch_mem(bytes, addr, size)) {
+                if (show_mem_fetch) {
+                    fmt::print("\t\t\t");
+                    for (; size; --size)
+                        fmt::print("{:02x} ", *bytes++);
+                    fmt::print("= [{:x}]\n", addr);
+                }
+                return true;
             }
+            return false;
         }
-
-        std::vector<aisa::regval_t> compute_destinations(const std::vector<aisa::regval_t> &source_vals) const override
+        bool store_mem(aisa::addr_t addr, const aisa::byte_t *bytes, aisa::addr_t size)
         {
-            return source_vals;
+            if (aisa::PagedMem<>::store_mem(addr, bytes, size)) {
+                if (show_mem_store) {
+                    fmt::print("\t\t\t[{:x}] =", addr);
+                    for (; size; --size)
+                        fmt::print(" {:02x}", *bytes++);
+                    fmt::print("\n");
+                }
+                return true;
+            }
+            return false;
         }
-    } step{{123, 456}, {{1, 2}, {3, 4}, {5, 6}}};
 
-    struct State : public aisa::EvalState<State> {
-        std::map<aisa::regnum_t, aisa::regval_t> regs;
+        bool store_reg(aisa::regnum_t rn, aisa::regval_t rv)
+        {
+            if (aisa::VectorRF::store_reg(rn, rv)) {
+                if (show_regs)
+                    fmt::print(".{} = {}\n", isa::fib::Reg::disasm(rn), rv);
+                return true;
+            }
+            return false;
+        }
 
-        std::optional<aisa::regval_t> load_reg(aisa::regnum_t rn)
+        bool push_task(std::unique_ptr<const aisa::Task> &&task)
         {
-            std::cout << "state.load_reg(" << rn << ") = ";
-            if (auto x = regs.find(rn); x != regs.end()) {
-                std::cout << x->second << "\n";
-                return x->second;
+            auto d = task->disasm();
+            if (aisa::TaskStack::push_task(std::move(task))) {
+                if (show_tasks)
+                    fmt::print("\t\t*** ENTER {} ***\n", d);
+                return true;
             }
-            std::cout << "(not available)\n";
-            return {};
+            return false;
         }
 
-        bool store_reg(aisa::regnum_t rn, aisa::regval_t rv)
+        bool pop_task()
         {
-            std::cout << "state.store_reg(" << rn << " <- " << rv << ")\n";
-            regs[rn] = rv;
-            return true;
+            if (aisa::TaskStack::pop_task()) {
+                if (show_tasks)
+                    fmt::print("\t\t *** LEAVE ***\n");
+                return true;
+            }
+            return false;
         }
-    } state;
+    } eval;
 
-    auto t = state.async_load_reg(999);
-    std::cout << "run\n"; t();
-    std::cout << "run\n"; t();
-    std::cout << "run\n"; t();
-    std::cout << "set regs[999] = 54321\n"; state.store_reg(999, 54321);
-    std::optional<aisa::regval_t> result;
-    while (!result.has_value()) {
-        std::cout << "run\n";
-        result = t();
+    if (!eval.async_setup_initial_task(fib)()) {
+        fmt::print("Failed to complete initial setup.\n");
+        return 1;
     }
-    std::cout << "result = " << *result << "\n";
 
-    std::cout << "\n\n\n";
+    while (true) {
+        auto res = eval.async_fetch_and_run_step()();
+        if (res.has_value()) {
+            auto &es = *res;
+            if (es.first) {
+                auto &step = *es.first;
+                auto &w = es.second;
+                if (show_steps)
+                    fmt::print("\t{}\n", step.disasm(&w));
+            } else {
+                break;
+            }
+        } else {
+            fmt::print("Failed to complete step.\n");
+            return 2;
+        }
+    }
 
-    auto w = state(step);
-    std::cout << "run\n"; w->resume();
-    std::cout << "run\n"; w->resume();
-    std::cout << "run\n"; w->resume();
-    std::cout << "set predicate (valid)\n"; state.store_reg(step.predicate->first, step.predicate->second);
-    std::cout << "run\n"; w->resume();
-    std::cout << "run\n"; w->resume();
-    std::cout << "run\n"; w->resume();
-    std::cout << "set regs (all)\n";
-    for (int i = 0; i < 10; ++i)
-        state.store_reg(i, 1000 + i);
-    for (bool done = false; !done; done = w->resume())
-        std::cout << "run\n";
-    std::cout << "huzzah!\n";
+    fmt::print("Functional model exited.\n");
 
     return 0;
 }