Use LLVM's YAML::IO library to read binding configuration

Also improve the documentation of the binding configuration file with
testable examples.

Author: jonas

Dockerfile

@@ -14,7 +14,6 @@ RUN set -x \
             g++ openjdk-8-jdk-headless sbt cmake make curl git \
             zlib1g-dev \
             libgc-dev libunwind8-dev libre2-dev \
-            nlohmann-json-dev \
  && rm -rf /var/lib/apt/lists/*
 
 ARG LOCALE=en_US.UTF-8

bindgen/ir/Enum.cpp

@@ -1,4 +1,5 @@
 #include "Enum.h"
+#include <sstream>
 
 Enumerator::Enumerator(std::string name, int64_t value)
     : name(std::move(name)), value(value) {}

bindgen/ir/IR.cpp

@@ -1,5 +1,6 @@
 #include "IR.h"
 #include "../Utils.h"
+#include <sstream>
 
 IR::IR(std::string libName, std::string linkName, std::string objectName,
        std::string packageName, const LocationManager &locationManager)

bindgen/ir/LocationManager.cpp

@@ -1,94 +1,55 @@
 #include "LocationManager.h"
 #include "../Utils.h"
-#include "Enum.h"
-#include "Struct.h"
-#include <fstream>
-#include <stdexcept>
+#include <llvm/Support/MemoryBuffer.h>
+#include <llvm/Support/YAMLTraits.h>
 
-LocationManager::LocationManager(std::string mainHeaderPath)
-    : mainHeaderPath(std::move(mainHeaderPath)) {}
-
-void LocationManager::loadConfig(const std::string &path) {
-    std::string realPath = getRealPath(path.c_str());
-
-    std::stringstream s;
-    std::ifstream input(realPath);
-    for (std::string line; getline(input, line);) {
-        s << line;
+template <> struct llvm::yaml::MappingTraits<HeaderEntry> {
+    static void mapping(llvm::yaml::IO &io, HeaderEntry &headerEntry) {
+        io.mapRequired("path", headerEntry.path);
+        io.mapRequired("object", headerEntry.object);
+        io.mapOptional("names", headerEntry.names);
     }
-    config = json::parse(s.str());
-    validateConfig(config);
-}
+};
 
-void LocationManager::validateConfig(const json &config) const {
-    if (!config.is_object()) {
-        throw std::invalid_argument(
-            "Invalid configuration. Configuration should be an object.");
-    }
-    for (auto it = config.begin(); it != config.end(); ++it) {
-        std::string headerName = it.key();
-        if (headerName.empty()) {
-            throw std::invalid_argument("Invalid configuration. Header name "
-                                        "should not be an empty string.");
+template <> struct llvm::yaml::MappingTraits<HeaderEntryName> {
+    static void mapping(llvm::yaml::IO &io, HeaderEntryName &headerEntryName) {
+        // Dynamically look up the available keys when only one key is given.
+        //
+        // ```yaml
+        //  - struct point: Point
+        // ```
+        if (io.keys().size() == 1) {
+            for (auto key : io.keys()) {
+                headerEntryName.original = key;
+                io.mapRequired(headerEntryName.original.c_str(),
+                               headerEntryName.target);
+            }
+        } else {
+            io.mapRequired("original", headerEntryName.original);
+            io.mapRequired("target", headerEntryName.target);
         }
-        json headerEntry = it.value();
-        validateHeaderEntry(headerEntry);
     }
-}
+};
 
-void LocationManager::validateHeaderEntry(const json &headerEntry) const {
-    if (headerEntry.is_string()) {
-        std::string object = headerEntry.get<std::string>();
-        if (object.empty()) {
-            throw std::invalid_argument("Invalid configuration. Each header "
-                                        "entry should contain non-empty "
-                                        "value.");
-        }
-    } else if (headerEntry.is_object()) {
-        std::unordered_set<std::string> headerKeys = {"object", "names"};
-        validateKeys(headerEntry, headerKeys);
-        if (headerEntry.find("object") == headerEntry.end()) {
-            throw std::invalid_argument("Invalid configuration. Header entry "
-                                        "that is represented as an object "
-                                        "should contain 'object' property.");
-        }
-        json object = headerEntry["object"];
-        if (!object.is_string() || object.get<std::string>().empty()) {
-            throw std::invalid_argument("Invalid configuration. 'object' "
-                                        "property should be a not empty "
-                                        "string.");
-        }
-        if (headerEntry.find("name") != headerEntry.end()) {
-            validateNames(headerEntry["names"]);
-        }
-    } else {
-        throw std::invalid_argument("Invalid configuration. Header entry "
-                                    "should be a string or an object.");
-    }
-}
+LLVM_YAML_IS_SEQUENCE_VECTOR(HeaderEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(HeaderEntryName)
 
-void LocationManager::validateKeys(
-    const json &object, const std::unordered_set<std::string> &keys) const {
-    for (auto it = object.begin(); it != object.end(); ++it) {
-        if (keys.find(it.key()) == keys.end()) {
-            throw std::invalid_argument(
-                "Invalid configuration. Unknown key: '" + it.key() + "'.");
-        }
-    }
-}
+LocationManager::LocationManager(std::string mainHeaderPath)
+    : headerEntries(), mainHeaderPath(std::move(mainHeaderPath)) {}
 
-void LocationManager::validateNames(const json &names) const {
-    if (!names.is_object()) {
-        throw std::invalid_argument("Invalid configuration. Library property "
-                                    "'names' should be an object.");
-    }
-    for (auto it = names.begin(); it != names.end(); ++it) {
-        if (!it.value().is_string()) {
-            throw std::invalid_argument(
-                "Invalid configuration. property 'names'"
-                " should contain only string values.");
-        }
-    }
+bool LocationManager::loadConfig(const std::string &path) {
+    llvm::SmallString<4096> realPath;
+    if (llvm::sys::fs::real_path(path, realPath))
+        return false;
+
+    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> mb =
+        llvm::MemoryBuffer::getFile(realPath);
+    if (!mb)
+        return false;
+
+    llvm::yaml::Input input(mb->get()->getBuffer());
+    input >> headerEntries;
+    return true;
 }
 
 bool LocationManager::inMainFile(const Location &location) const {
@@ -99,40 +60,36 @@ bool LocationManager::isImported(const Location &location) const {
     if (location.getPath().empty()) {
         return false;
     }
-    json headerEntry = getHeaderEntry(location);
-    return !headerEntry.empty();
+    return getHeaderEntryIndex(location) != headerEntries.size();
 }
 
-json LocationManager::getHeaderEntry(const Location &location) const {
-    for (auto it = config.begin(); it != config.end(); ++it) {
-        std::string pathToHeader = it.key();
-        if (startsWith(pathToHeader, "/")) {
-            /* full path */
-            if (location.getPath() == pathToHeader) {
-                return it.value();
-            }
-        } else if (endsWith(location.getPath(), "/" + pathToHeader)) {
-            return it.value();
-        }
-    }
-    return json::object();
+std::vector<HeaderEntry>::size_type
+LocationManager::getHeaderEntryIndex(const Location &location) const {
+    auto isHeader = [&](const HeaderEntry &headerEntry) {
+        if (startsWith(headerEntry.path, "/") &&
+            location.getPath() == headerEntry.path)
+            return true;
+        return endsWith(location.getPath(), "/" + headerEntry.path);
+    };
+    auto it =
+        std::find_if(headerEntries.begin(), headerEntries.end(), isHeader);
+    return it - headerEntries.begin();
 }
 
 std::string LocationManager::getImportedType(const Location &location,
                                              const std::string &name) const {
-    json headerEntry = getHeaderEntry(location);
-    if (headerEntry.is_string()) {
-        return headerEntry.get<std::string>() + "." +
-               handleReservedWords(replaceChar(name, " ", "_"));
-    }
-    std::string scalaObject = headerEntry["object"];
+    auto index = getHeaderEntryIndex(location);
+    if (index == headerEntries.size())
+        return name;
+
+    auto headerEntry = headerEntries[index];
 
-    if (headerEntry.find("names") != headerEntry.end()) {
-        /* name mapping */
-        json names = headerEntry["names"];
-        if (names.find(name) != names.end()) {
-            return scalaObject + "." + names[name].get<std::string>();
+    for (auto const &headerEntryName : headerEntry.names) {
+        if (headerEntryName.original == name) {
+            return headerEntry.object + "." + headerEntryName.target;
         }
     }
-    return scalaObject + "." + handleReservedWords(replaceChar(name, " ", "_"));
+
+    return headerEntry.object + "." +
+           handleReservedWords(replaceChar(name, " ", "_"));
 }

bindgen/ir/LocationManager.h

@@ -2,18 +2,26 @@
 #define SCALA_NATIVE_BINDGEN_LOCATIONMANAGER_H
 
 #include "Location.h"
-#include <nlohmann/json.hpp>
+#include <map>
 #include <string>
-#include <unordered_map>
-#include <unordered_set>
+#include <vector>
 
-using json = nlohmann::json;
+struct HeaderEntryName {
+    std::string original;
+    std::string target;
+};
+
+struct HeaderEntry {
+    std::string path;
+    std::string object;
+    std::vector<HeaderEntryName> names;
+};
 
 class LocationManager {
   public:
     explicit LocationManager(std::string mainHeaderPath);
 
-    void loadConfig(const std::string &path);
+    bool loadConfig(const std::string &path);
 
     bool inMainFile(const Location &location) const;
 
@@ -26,19 +34,10 @@ class LocationManager {
                                 const std::string &name) const;
 
   private:
+    std::vector<HeaderEntry>::size_type
+    getHeaderEntryIndex(const Location &location) const;
+    std::vector<HeaderEntry> headerEntries;
     std::string mainHeaderPath;
-    json config;
-
-    json getHeaderEntry(const Location &location) const;
-
-    void validateConfig(const json &config) const;
-
-    void validateHeaderEntry(const json &headerEntry) const;
-
-    void validateNames(const json &names) const;
-
-    void validateKeys(const json &object,
-                      const std::unordered_set<std::string> &keys) const;
 };
 
 #endif // SCALA_NATIVE_BINDGEN_LOCATIONMANAGER_H

build.sbt

@@ -156,7 +156,7 @@ lazy val docs = nativeProject("docs")
         .link("vector")
         .packageName("org.example"), {
         val pathToHeader = docs3rdPartyBindingsDirectory.value / "geometry.h"
-        val pathToConfig = docs3rdPartyBindingsDirectory.value / "config.json"
+        val pathToConfig = docs3rdPartyBindingsDirectory.value / "config.yml"
         //#sbt-binding-config
         NativeBinding(pathToHeader)
           .bindingConfig(pathToConfig)
@@ -173,7 +173,7 @@ lazy val docs = nativeProject("docs")
           .name("WordCount")
           .link("wordcount")
           .packageName("org.example.wordcount")
-          .bindingConfig(docsScalaNativeBindingsDirectory.value / "config.json")
+          .bindingConfig(docsScalaNativeBindingsDirectory.value / "config.yml")
       }
     ),
     nativeBindgenPath := {

docs/src/paradox/configuration.md

@@ -28,7 +28,7 @@ When the exclude prefix is set to `__`, then the resulting bindings will be:
 
 ## Binding Configuration File
 
-The binding configuration is a JSON file which allows to map the path of
+The binding configuration is a YAML file which allows to map the path of
 a header file to the associated object as well as the names of the C
 types and symbols to their respective Scala types and definitions. The
 configuration file can be used when integrating with third party
@@ -50,7 +50,7 @@ If you need to generate bindings that uses types from bindings that have not bee
 
 To use this binding, create a configuration file with the folllowing content, where `path` is the name of the header file (usually the part of the path inside the `/usr/include` or `/usr/local/include` directory), `object` is the fully qualified name of the Scala object (i.e. package name as well as the Scala object name) and finally `names` for each of the types:
 
-@@snip [vector.h] (../test/resources/3rd-party-bindings/config.json)
+@@snip [vector.h] (../test/resources/3rd-party-bindings/config.yml)
 
 Now in the library you are creating a binding for, any usage of `struct point`:
 
@@ -71,7 +71,7 @@ from `<stdio.h>`:
 
 We can then write a binding configuration that maps the header name to the object defined in Scala Native.
 
-@@snip [vector.h] (../test/resources/scala-native-bindings/config.json)
+@@snip [vector.h] (../test/resources/scala-native-bindings/config.yml)
 
 @@@ note
 

docs/src/paradox/contrib/cmake.md

@@ -5,16 +5,13 @@ Building `scala-native-bindgen` requires the following tools and libraries:
  - [CMake] version 3.9 or higher
  - [GNU Make]
  - [LLVM] and [Clang] version 5.0 or 6.0.
- - [nlohmann/json] version 3.1.2 or higher
 
 ```sh
 # On apt-based systems
-apt install cmake make clang-6.0 libclang-6.0-dev llvm-6.0-dev \
-            nlohmann-json-dev
+apt install cmake make clang-6.0 libclang-6.0-dev llvm-6.0-dev
 
 # With `brew`
-brew tap nlohmann/json
-brew install cmake llvm@6 nlohmann_json
+brew install cmake llvm@6
 ```
 
 To run the tests you also need the required Scala Native libraries.
@@ -47,4 +44,3 @@ CXXFLAGS=-g cmake ..
  [LLVM]: https://llvm.org/
  [Clang]: https://clang.llvm.org/
  [Scala Native setup guide]: http://www.scala-native.org/en/latest/user/setup.html
- [nlohmann/json]: https://github.com/nlohmann/json

docs/src/test/resources/3rd-party-bindings/config.json

@@ -0,0 +1,9 @@
+---
+ - path: vector.h
+   object: com.example.custom.binding.Vector
+   names:
+     # Short name mapping
+     - struct point: Point
+     # Full name mapping
+     - original: struct lineSegment
+       target: LineSegment