Implement bridges

Author: vendethiel

src/cpp/bin/testml-cpp-tap

@@ -15,7 +15,8 @@ testml-run-file() {
   set -x
   /usr/bin/env c++ \
     -o $testml_runner \
-    -std=c++14 \
+    -std=c++14 -Wall -Wextra \
+    -g \
     $src_bin \
     $lib/run/tap.cpp \
     $lib/runtime.cpp \

src/cpp/lib/testml/bridge.cpp

@@ -0,0 +1,15 @@
+#include "bridge.hpp"
+
+namespace testml {
+
+  using json = nlohmann::json;
+
+  json Bridge::call(std::string const& name, std::vector<json> const& args) {
+    auto it = _fns.find(name);
+    if (it == _fns.end()) {
+      throw std::runtime_error("Bridge method not found: " + name + ".");
+    }
+    return it->second->call(args);
+  }
+
+}

src/cpp/lib/testml/bridge.hpp

@@ -5,32 +5,40 @@
 #include <unordered_map>
 #include <memory>
 #include <stdexcept>
+#include <string>
+
 #include "../../ext/nlohmann/json.hpp"
 
+#include "wrapper.hpp"
+
 namespace testml {
-  
+
   namespace details {
 
     using json = nlohmann::json;
+    using wrapper::cook;
+    using wrapper::uncook;
 
     // we need this details class so that we can have a non-templated value
+    // stored in the Bridge _fns map.
     struct FnHolder {
       virtual json call(std::vector<json> const&) = 0;
     };
 
+    // the implementation of a FnHolder, which keeps the types around
     template<typename Ret, typename... Arg>
     class FnHolderImpl : public FnHolder {
-      using Fn = Ret(*)(Arg...);
+      using Fn = std::function<Ret(Arg...)>;
       Fn _fn;
 
       // type of the N-th argument that the stored function takes
-      template<std::size_t>
-      using ArgType = std::tuple_element<I, std::tuple<Arg...>>;
+      template<std::size_t I>
+      using ArgType = typename std::tuple_element<I, std::tuple<Arg...>>::type;
 
       // uncook each argument to its expected type, and call the function
       template<std::size_t... I>
       Ret call_impl(std::vector<json> const& args, std::index_sequence<I...>) {
-        return _fn(uncook<ArgType<I>>(args[I]), ...);
+        return _fn(uncook<ArgType<I>>(args[I])...);
       }
 
     public:
@@ -40,10 +48,11 @@ namespace testml {
       // check arity and call the function using our little helper, before wrapping it back to json
       json call(std::vector<json> const& args) override {
         if (args.size() != sizeof...(Arg)) {
-          throw new std::runtime_error("Bridge method call with wrong arity, expected " + sizeof...(Arg) + ", got " + args.size() + ".");
+          throw std::runtime_error("Bridge method call with wrong arity, expected " + std::to_string(sizeof...(Arg)) + ", got " + std::to_string(args.size()) + ".");
         }
 
-        return cook(_call(args, std::make_index_sequence<sizeof...(Arg)>{}));
+        // generate an index_sequence so that the call_impl() can spread on each argument
+        return cook(call_impl(args, std::make_index_sequence<sizeof...(Arg)>{}));
       }
 
     };
@@ -54,18 +63,19 @@ namespace testml {
     std::unordered_map<std::string, std::unique_ptr<details::FnHolder>> _fns;
 
   public:
-    template<typename Fn>
-    void register(std::string const& name, Fn&& fn) {
-      _fns[name] = std:make_unique<details::FnHolderImpl>(std::move(fn));
+    template<typename Ret, typename... Arg>
+    void bind(std::string const& name, std::function<Ret(Arg...)> fn) {
+      // store a wrapper FnHolder in the map, with FnHolderImpl to keep the correct types around and do FFI correctly
+      using HolderType = details::FnHolderImpl<Ret, Arg...>;
+      _fns[name] = std::make_unique<HolderType>(std::move(fn));
     }
 
-    json call(std::string const& name, std::vector<json> const& args) override {
-      auto it = _fns.find(name);
-      if (it == _fns.end()) {
-        throw new std::runtime_error("Bridge method not found: " + name + ".");
-      }
-      return it->call(args);
+    template<typename Ret, typename... Arg>
+    void bind(std::string const& name, Ret(*fn)(Arg...)) {
+      bind(name, std::function<Ret(Arg...)>(fn));
     }
+
+    nlohmann::json call(std::string const& name, std::vector<nlohmann::json> const& args);
   };
 
 }

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

@@ -29,5 +29,9 @@ namespace run {
     std::cout << "\n";
   }
 
+  void TAP::testml_done() {
+    std::cout << "1.." << count;
+  }
+
 }
 }

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

@@ -9,10 +9,12 @@ 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;
+    void testml_done() override;
 
   private:
     void tap_pass(std::string const& label);

src/cpp/lib/testml/runtime.cpp

@@ -1,30 +1,44 @@
 #include <string>
+#include <iterator>
 #include <iomanip> // TODO remove
 #include <fstream>
 #include <stdexcept>
 #include <iostream>
+#include <functional>
+
 #include "runtime.hpp"
+#include "bridge.hpp"
 
-static void NYI(std::string const& add = "") {
+[[noreturn]] 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) {
+  namespace {
+    bool is_all_lowercase(std::string const& s) {
+      return std::all_of(s.begin(), s.end(), [](char c) { return std::islower(c); });
+    }
+  }
+
+  Runtime::Runtime(std::string const& filename, Bridge& bridge)
+    : _bridge{bridge} {
+
     std::ifstream stream(filename);
     stream >> _ast;
 
     _data = _ast["data"];
   }
 
-  json Runtime::exec_expr(json::array_t fragment) {
+  json Runtime::exec_expr(json fragment) {
     if (!fragment.is_array() || fragment.size() == 0)
-      return fragment;
+      return json::array_t{fragment};
+
+    // TODO check if the first element is a string, otherwise return it unwrapped
 
-    auto opcode = fragment[0];
+    std::string opcode = fragment[0];
     fragment.erase(fragment.begin()); // pop first arg
     json val;
     if (opcode == "%<>") {
@@ -33,23 +47,29 @@ namespace testml {
       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)");
+      assert_eq(fragment[0], fragment[1], fragment.size() == 3 ? fragment[2] : "");
       return {}; // no return value
     } else if (opcode == ".") {
       val = exec_dot(fragment);
     } else if (opcode == "*") {
       val = get_point(fragment[0]);
-    } else if (opcode == "add") {
+    } else if (is_all_lowercase(opcode)) {
       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::call_bridge(std::string const& name, json::array_t args) {
+    std::vector<json> transformed;
+    std::transform(args.begin(), args.end(), std::back_inserter(transformed),
+      [this](json& j) { return exec_expr(j)[0] /* TODO exec() */; });
+    return _bridge.call(name, transformed);
+  }
+
   json Runtime::get_point(std::string const& name) {
     return _currentBlock["point"][name];
   }
@@ -60,11 +80,10 @@ namespace testml {
     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;
+    return context[0];
   }
 
   void Runtime::each_pick(json::array_t list, json::array_t expr) {
@@ -116,6 +135,7 @@ namespace testml {
     for (auto& statement : _ast["code"]) {
       exec_expr(statement);
     }
+    testml_done();
   }
 
   Runtime::~Runtime() {

src/cpp/lib/testml/runtime.hpp

@@ -1,15 +1,18 @@
 #pragma once
 
 #include <string>
+
 #include "../../ext/nlohmann/json.hpp"
 
+#include "bridge.hpp"
+
 namespace testml {
 
   class Runtime {
     using json = nlohmann::json;
 
   public:
-    Runtime(std::string const& filename);
+    Runtime(std::string const& filename, Bridge&);
     virtual ~Runtime() = 0;
 
     void run();
@@ -21,7 +24,7 @@ namespace testml {
 
   private:
     // other methods
-    json exec_expr(json::array_t fragment);
+    json exec_expr(json 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);
@@ -35,8 +38,11 @@ namespace testml {
   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;
+    virtual void testml_done() = 0;
 
   private:
+    Bridge& _bridge;
+
     json _ast;
     json _data;
     json _currentBlock; /* TODO ptr or smth */

src/cpp/src/testml-run.cpp

@@ -1,11 +1,23 @@
 #include <iostream>
-#include "../lib/testml/run/tap.hpp"
+#include <exception>
 
+#include "../lib/testml/run/tap.hpp"
 
-int main(int argc, char* argv[]) {
+int main(int, char* argv[]) {
 
-  testml::run::TAP tap{argv[1]};
-  tap.run();
+  testml::Bridge bridge;
+  bridge.bind("add", +[](int a, int b) {
+    return a + b;
+  });
+  bridge.bind("sub", +[](int a, int b) {
+    return a - b;
+  });
+  try {
+    testml::run::TAP tap{argv[1], bridge};
+    tap.run();
+  } catch (std::exception& e) {
+    std::cout << "exception thrown: " << e.what() << std::endl;
+  }
 
   return 0;
 }