WIP C++ impl

Author: vendethiel

src/cpp/bin/testml-cpp-tap

@@ -15,9 +15,10 @@ testml-run-file() {
   set -x
   /usr/bin/env c++ \
     -o $testml_runner \
+    -std=c++14 \
     $src_bin \
     $lib/run/tap.cpp \
-    $lib/run.cpp \
+    $lib/runtime.cpp \
     $lib/stdlib.cpp \
     $lib/bridge.cpp \
     $bridge_file || return

src/cpp/lib/testml/run.cpp

@@ -1,12 +1,33 @@
-#include <iostream>
 #include <string>
-#include "tap.h"
+#include <iostream>
+#include "tap.hpp"
+
+namespace testml {
+namespace run {
 
-void TestML_Run_TAP::run(std::string file) {
-  TestML_Run_TAP tap;
+  void TAP::testml_eq(json want, json got, std::string const& label) {
+    if (want == got) {
+      tap_pass(label);
+    } else {
+      tap_fail(label);
+    }
+  }
 
-  tap.from_file(file);
+  void TAP::tap_pass(std::string const& label) {
+    std::cout << "ok " << ++count;
+    if (!label.empty()) {
+      std::cout << " - " << label;
+    }
+    std::cout << "\n";
+  }
 
-  std::cout << "1..1" << std::endl;
-  std::cout << "ok 1 - It worked" << std::endl;
+  void TAP::tap_fail(std::string const& label) {
+    std::cout << "not ok " << ++count;
+    if (!label.empty()) {
+      std::cout << " - " << label;
+    }
+    std::cout << "\n";
+  }
+
+}
 }

src/cpp/lib/testml/run.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "../runtime.hpp"
+
+#include <string>
+
+namespace testml {
+namespace run {
+
+  class TAP : public Runtime {
+    using json = nlohmann::json;
+    using Runtime::Runtime;
+
+  protected:
+    void testml_eq(json want, json got, std::string const& label) override;
+
+  private:
+    void tap_pass(std::string const& label);
+    void tap_fail(std::string const& label);
+
+  private:
+    int count = 0;
+  };
+
+}
+}

src/cpp/lib/testml/run/tap.cpp

@@ -0,0 +1,124 @@
+#include <string>
+#include <iomanip> // TODO remove
+#include <fstream>
+#include <stdexcept>
+#include <iostream>
+#include "runtime.hpp"
+
+static void NYI(std::string const& add = "") {
+  throw std::runtime_error("Not Yet Implemented, sorry! " + add);
+}
+
+using json = nlohmann::json;
+
+namespace testml {
+
+  Runtime::Runtime(std::string const& filename) {
+    std::ifstream stream(filename);
+    stream >> _ast;
+
+    _data = _ast["data"];
+  }
+
+  json Runtime::exec_expr(json::array_t fragment) {
+    if (!fragment.is_array() || fragment.size() == 0)
+      return fragment;
+
+    auto opcode = fragment[0];
+    fragment.erase(fragment.begin()); // pop first arg
+    json val;
+    if (opcode == "%<>") {
+      // TODO bound check
+      // TODO std::unordered_map<std::string key, std::tuple<int arity, std::function call>>
+      each_pick(fragment[0], fragment[1]);
+      return {}; // no return value
+    } else if (opcode == "==") {
+      assert_eq(fragment[0], fragment[1], fragment.size() == 3 ? fragment[2] : "(no reason)");
+      return {}; // no return value
+    } else if (opcode == ".") {
+      val = exec_dot(fragment);
+    } else if (opcode == "*") {
+      val = get_point(fragment[0]);
+    } else if (opcode == "add") {
+      val = call_bridge(opcode, fragment);
+    } else if (true) {
+      NYI(opcode);
+      return {}; // stupid compiler.
+    } else {
+      throw std::runtime_error("Can't resolve TestML function");
+    }
+    return val.is_null() ? json::array_t{} : json::array_t{val};
+  }
+
+  json Runtime::get_point(std::string const& name) {
+    return _currentBlock["point"][name];
+  }
+
+  json Runtime::exec_dot(json::array_t fragment) {
+    json context = {}; // result of last call
+    
+    for (auto call : fragment) {
+      // add context right after the opcode
+      call.insert(call.begin() + 1 /* after opcode */, context.begin(), context.end());
+      std::cout << "call: " << call << " with context " << context << std::endl;
+      // we now have the full argument list
+      context = exec_expr(call);
+    }
+    return context;
+  }
+
+  void Runtime::each_pick(json::array_t list, json::array_t expr) {
+    for (auto& datum : _data) {
+      _currentBlock = datum;
+      // TODO block.point.ONLY
+
+      pick_exec(list, expr);
+    }
+    _currentBlock = {};
+  }
+
+  void Runtime::pick_exec(json::array_t list, json::array_t expr) {
+    // check whether we should run or not
+    auto& points = _currentBlock["point"];
+    for (json::string_t str : list) {
+      if (!str.compare(0, 1, "*") && points.find(str.substr(1)) == points.end()) {
+        return;
+      }
+      if (!str.compare(0, 2, "!*") && points.find(str.substr(2)) != points.end()) {
+        return;
+      }
+    }
+
+    // if we didn't return beforehand, we're safe to run the expression
+    if (is_function(expr)) {
+      // exec_func
+      NYI();
+    } else {
+      exec_expr(expr);
+    }
+  }
+
+  void Runtime::assert_eq(json::array_t left, json::array_t right, std::string const& label) {
+    testml_eq(exec_expr(left), exec_expr(right), label);
+  }
+
+  bool Runtime::is_function(json value) {
+    if (!value.is_object()) {
+      return false;
+    }
+    if (value.size() < 1) {
+      return false;
+    }
+    return value[0].is_string() && value[0] == "=>";
+  }
+
+  void Runtime::run() {
+    for (auto& statement : _ast["code"]) {
+      exec_expr(statement);
+    }
+  }
+
+  Runtime::~Runtime() {
+  }
+
+}

src/cpp/lib/testml/run/tap.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <string>
+#include "../../ext/nlohmann/json.hpp"
+
+namespace testml {
+
+  class Runtime {
+    using json = nlohmann::json;
+
+  public:
+    Runtime(std::string const& filename);
+    virtual ~Runtime() = 0;
+
+    void run();
+
+  private:
+    // toplevel methods
+    void each_pick(json::array_t list, json::array_t expr);
+    void pick_exec(json::array_t list, json::array_t expr);
+
+  private:
+    // other methods
+    json exec_expr(json::array_t fragment);
+    json exec_dot(json::array_t fragment);
+    json call_bridge(std::string const& name, json::array_t args);
+    json get_point(std::string const& name);
+
+  private:
+    void assert_eq(json::array_t got, json::array_t want, std::string const& label);
+
+  private:
+    bool is_function(json value);
+
+  protected:
+    // those methods are to be overriden by the runtime class implementing
+    virtual void testml_eq(json want, json got, std::string const& label) = 0;
+
+  private:
+    json _ast;
+    json _data;
+    json _currentBlock; /* TODO ptr or smth */
+  };
+
+}

src/cpp/lib/testml/run/tap.hpp

@@ -1,15 +1,11 @@
 #include <iostream>
-#include "../lib/testml/run/tap.h"
+#include "../lib/testml/run/tap.hpp"
 
 
 int main(int argc, char* argv[]) {
 
-  std::string file(argv[1]);
-//   TestML_Run_TAP tap;
-//   std::string f("asdf");
-
-  TestML_Run_TAP::run(file);
-//   tap.run();
+  testml::run::TAP tap{argv[1]};
+  tap.run();
 
   return 0;
 }