Reuse generated bindings

Author: kornilova203

bindgen/Main.cpp

@@ -26,6 +26,10 @@ int main(int argc, const char *argv[]) {
     llvm::cl::opt<std::string> LinkName(
         "link", llvm::cl::cat(Category),
         llvm::cl::desc("Library to link with, e.g. -luv for libuv"));
+    llvm::cl::opt<std::string> ReuseBindingsConfig(
+        "use-bindings", llvm::cl::cat(Category),
+        llvm::cl::desc(
+            "File that contains information about generated bindings."));
     clang::tooling::CommonOptionsParser op(argc, argv, Category);
     clang::tooling::ClangTool Tool(op.getCompilations(),
                                    op.getSourcePathList());
@@ -62,6 +66,11 @@ int main(int argc, const char *argv[]) {
     char *resolved = realpath(op.getSourcePathList()[0].c_str(), nullptr);
     LocationManager locationManager(resolved);
 
+    auto reuseBindingsConfig = ReuseBindingsConfig.getValue();
+    if (!reuseBindingsConfig.empty()) {
+        locationManager.loadConfig(reuseBindingsConfig);
+    }
+
     IR ir(libName, linkName, objectName, Package.getValue(), locationManager);
 
     DefineFinderActionFactory defineFinderActionFactory(ir);

bindgen/Utils.h

@@ -63,6 +63,13 @@ static inline bool startsWith(const std::string &str,
     return str.substr(0, prefix.size()) == prefix;
 }
 
+/**
+ * @return true if str ends with given prefix
+ */
+static inline bool endsWith(const std::string &str, const std::string &suffix) {
+    return str.substr(str.length() - suffix.size(), str.length()) == suffix;
+}
+
 template <typename T, typename PT> static inline bool isInstanceOf(PT *type) {
     auto *p = dynamic_cast<const T *>(type);
     return p != nullptr;
@@ -119,4 +126,16 @@ static inline bool contains(const Type *type,
     return false;
 }
 
+static inline std::string getRealPath(const char *path) {
+    char *p = realpath(path, nullptr);
+    std::string realPath;
+    if (p) {
+        realPath = p;
+        delete[] p;
+    } else {
+        realPath = "";
+    }
+    return realPath;
+}
+
 #endif // UTILS_H

bindgen/ir/Function.cpp

@@ -1,6 +1,7 @@
 #include "Function.h"
 #include "../Utils.h"
 #include "Struct.h"
+#include <sstream>
 
 Parameter::Parameter(std::string name, std::shared_ptr<const Type> type)
     : TypeAndName(std::move(name), type) {}
@@ -11,24 +12,26 @@ Function::Function(const std::string &name,
     : name(name), scalaName(name), parameters(std::move(parameters)),
       retType(std::move(retType)), isVariadic(isVariadic) {}
 
-llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const Function &func) {
-    if (func.scalaName != func.name) {
-        s << "  @native.link(\"" << func.name << "\")\n";
+std::string
+Function::getDefinition(const LocationManager &locationManager) const {
+    std::stringstream s;
+    if (scalaName != name) {
+        s << "  @native.link(\"" << name << "\")\n";
     }
-    s << "  def " << handleReservedWords(func.scalaName) << "(";
+    s << "  def " << handleReservedWords(scalaName) << "(";
     std::string sep = "";
-    for (const auto &param : func.parameters) {
+    for (const auto &param : parameters) {
         s << sep << handleReservedWords(param->getName()) << ": "
-          << param->getType()->str();
+          << param->getType()->str(locationManager);
         sep = ", ";
     }
-    if (func.isVariadic) {
+    if (isVariadic) {
         /* the C Iso require at least one argument in a variadic function, so
          * the comma is fine */
-        s << ", " << func.getVarargsParameterName() << ": native.CVararg*";
+        s << ", " << getVarargsParameterName() << ": native.CVararg*";
     }
-    s << "): " << func.retType->str() << " = native.extern\n";
-    return s;
+    s << "): " << retType->str(locationManager) << " = native.extern\n";
+    return s.str();
 }
 
 bool Function::usesType(

bindgen/ir/Function.h

@@ -18,8 +18,7 @@ class Function {
              std::vector<std::shared_ptr<Parameter>> parameters,
              std::shared_ptr<const Type> retType, bool isVariadic);
 
-    friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
-                                         const Function &func);
+    std::string getDefinition(const LocationManager &locationManager) const;
 
     bool usesType(std::shared_ptr<const Type> type, bool stopOnTypeDefs,
                   std::vector<std::shared_ptr<const Type>> &visitedTypes) const;

bindgen/ir/IR.cpp

@@ -81,10 +81,9 @@ void IR::addVarDefine(std::string name, std::shared_ptr<Variable> variable) {
 }
 
 bool IR::libObjEmpty() const {
-    return functions.empty() && !hasOutputtedDeclaration(typeDefs) &&
-           !hasOutputtedDeclaration(structs) &&
-           !hasOutputtedDeclaration(unions) && varDefines.empty() &&
-           variables.empty();
+    return functions.empty() && !hasOutputtedType(typeDefs) &&
+           !hasOutputtedType(structs) && !hasOutputtedType(unions) &&
+           varDefines.empty() && variables.empty();
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
@@ -94,7 +93,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
         s << "package " << ir.packageName << "\n\n";
     }
 
-    if (!ir.libObjEmpty() || ir.hasOutputtedDeclaration(ir.enums) ||
+    if (!ir.libObjEmpty() || ir.hasOutputtedType(ir.enums) ||
         !ir.literalDefines.empty()) {
         s << "import scala.scalanative._\n"
           << "import scala.scalanative.native._\n\n";
@@ -117,8 +116,8 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
 
     for (const auto &typeDef : ir.typeDefs) {
         visitedTypes.clear();
-        if (ir.shouldOutput(typeDef, visitedTypes)) {
-            s << *typeDef;
+        if (ir.shouldOutputTypeDef(typeDef, visitedTypes)) {
+            s << typeDef->getDefinition(ir.locationManager);
         } else if (typeDef->hasLocation() &&
                    isAliasForOpaqueType(typeDef.get()) &&
                    ir.locationManager.inMainFile(*typeDef->getLocation())) {
@@ -132,7 +131,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
 
     for (const auto &variable : ir.variables) {
         if (!variable->hasIllegalUsageOfOpaqueType()) {
-            s << *variable;
+            s << variable->getDefinition(ir.locationManager);
         } else {
             llvm::errs() << "Error: Variable " << variable->getName()
                          << " is skipped because it has incomplete type.\n";
@@ -141,7 +140,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
 
     for (const auto &varDefine : ir.varDefines) {
         if (!varDefine->hasIllegalUsageOfOpaqueType()) {
-            s << *varDefine;
+            s << varDefine->getDefinition(ir.locationManager);
         } else {
             llvm::errs() << "Error: Variable alias " << varDefine->getName()
                          << " is skipped because it has incomplete type.\n";
@@ -156,7 +155,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
                             "passing structs and arrays by value.\n";
             llvm::errs().flush();
         } else {
-            s << *func;
+            s << func->getDefinition(ir.locationManager);
         }
     }
 
@@ -167,16 +166,16 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
     if (!ir.literalDefines.empty()) {
         s << "object " << ir.libName << "Defines {\n";
         for (const auto &literalDefine : ir.literalDefines) {
-            s << *literalDefine;
+            s << literalDefine->getDefinition(ir.locationManager);
         }
         s << "}\n\n";
     }
 
-    if (ir.hasOutputtedDeclaration(ir.enums) || ir.hasHelperMethods()) {
+    if (ir.hasOutputtedType(ir.enums) || ir.hasHelperMethods()) {
         s << "import " << objectName << "._\n\n";
     }
 
-    if (ir.hasOutputtedDeclaration(ir.enums)) {
+    if (ir.hasOutputtedType(ir.enums)) {
         s << "object " << ir.libName << "Enums {\n";
 
         std::string sep = "";
@@ -197,14 +196,14 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
         for (const auto &st : ir.structs) {
             visitedTypes.clear();
             if (ir.shouldOutput(st, visitedTypes) && st->hasHelperMethods()) {
-                s << "\n" << st->generateHelperClass();
+                s << "\n" << st->generateHelperClass(ir.locationManager);
             }
         }
 
         for (const auto &u : ir.unions) {
             visitedTypes.clear();
             if (ir.shouldOutput(u, visitedTypes) && u->hasHelperMethods()) {
-                s << "\n" << u->generateHelperClass();
+                s << "\n" << u->generateHelperClass(ir.locationManager);
             }
         }
 
@@ -321,7 +320,7 @@ bool IR::isTypeUsed(
     for (const auto &typeDef : typeDefs) {
         visitedTypesInner.clear();
         if (typeDef->usesType(type, false, visitedTypesInner)) {
-            if (shouldOutput(typeDef, visitedTypes)) {
+            if (shouldOutputTypeDef(typeDef, visitedTypes)) {
                 return true;
             }
         }
@@ -461,13 +460,21 @@ IR::~IR() {
 }
 
 template <typename T>
-bool IR::hasOutputtedDeclaration(
+bool IR::hasOutputtedType(
     const std::vector<std::shared_ptr<T>> &declarations) const {
     std::vector<std::shared_ptr<const Type>> visitedTypes;
     for (const auto &declaration : declarations) {
         visitedTypes.clear();
-        if (shouldOutput(declaration, visitedTypes)) {
-            return true;
+        auto typeDefPointer =
+            std::dynamic_pointer_cast<const TypeDef>(declaration);
+        if (typeDefPointer) {
+            if (shouldOutputTypeDef(typeDefPointer, visitedTypes)) {
+                return true;
+            }
+        } else {
+            if (shouldOutput(declaration, visitedTypes)) {
+                return true;
+            }
         }
     }
     return false;
@@ -476,12 +483,31 @@ bool IR::hasOutputtedDeclaration(
 bool IR::shouldOutput(
     const std::shared_ptr<const LocatableType> &type,
     std::vector<std::shared_ptr<const Type>> &visitedTypes) const {
+    if (locationManager.isImported(*type->getLocation())) {
+        return false;
+    }
     if (isTypeUsed(type, visitedTypes)) {
         return true;
     }
-    if (isAliasForOpaqueType(type.get())) {
+    /* remove unused types from included files */
+    return locationManager.inMainFile(*type->getLocation());
+}
+
+bool IR::shouldOutputTypeDef(
+    const std::shared_ptr<const TypeDef> &typeDef,
+    std::vector<std::shared_ptr<const Type>> &visitedTypes) const {
+    if (isTypeUsed(typeDef, visitedTypes)) {
+        if (typeDef->wrapperForOpaqueType()) {
+            /* it is not possible to get location of this typedef
+             * so the typedef cannot be imported from other bindings */
+            return true;
+        }
+        return !locationManager.isImported(*typeDef->getLocation());
+    }
+    if (isAliasForOpaqueType(typeDef.get())) {
+        /* it does not matter where unused alias for opaque type is located */
         return false;
     }
     /* remove unused types from included files */
-    return locationManager.inMainFile(*type->getLocation());
+    return locationManager.inMainFile(*typeDef->getLocation());
 }

bindgen/ir/IR.h

@@ -159,21 +159,31 @@ class IR {
     /**
      * @return true if the type will be printed.
      *         Following types are not printed:
+     *         - Types that should be imported from other bindings
      *         - Unused types from included headers
-     *         - Unused typedefs from main header if they reference an opaque
-     *           type (if such typedef is used then true is returned but error
-     *           message is printed when bindings are generated)
      */
     bool
     shouldOutput(const std::shared_ptr<const LocatableType> &type,
                  std::vector<std::shared_ptr<const Type>> &visitedTypes) const;
 
     /**
-     * @tparam T Struct or Union
+     * @return true if typedef will be printed.
+     *         Following typedefs are not printed:
+     *         - TypeDefs that should be imported from other bindings
+     *         - Unused typedefs from included headers
+     *         - Unused typedefs from main header if they reference an opaque
+     *           type
+     */
+    bool shouldOutputTypeDef(
+        const std::shared_ptr<const TypeDef> &typeDef,
+        std::vector<std::shared_ptr<const Type>> &visitedTypes) const;
+
+    /**
+     * @tparam T one of LocatableType
      */
     template <typename T>
-    bool hasOutputtedDeclaration(
-        const std::vector<std::shared_ptr<T>> &declarations) const;
+    bool
+    hasOutputtedType(const std::vector<std::shared_ptr<T>> &declarations) const;
 
     std::string libName;    // name of the library
     std::string linkName;   // name of the library to link with

bindgen/ir/LiteralDefine.cpp

@@ -4,11 +4,10 @@ LiteralDefine::LiteralDefine(std::string name, std::string literal,
                              std::shared_ptr<const Type> type)
     : Define(std::move(name)), literal(std::move(literal)), type(type) {}
 
-llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
-                              const LiteralDefine &literalDefine) {
-    s << "  val " << literalDefine.name << ": " << literalDefine.type->str()
-      << " = " << literalDefine.literal << "\n";
-    return s;
+std::string
+LiteralDefine::getDefinition(const LocationManager &locationManager) const {
+    return "  val " + name + ": " + type->str(locationManager) + " = " +
+           literal + "\n";
 }
 
 bool LiteralDefine::usesType(

bindgen/ir/LiteralDefine.h

@@ -10,8 +10,7 @@ class LiteralDefine : public Define {
     LiteralDefine(std::string name, std::string literal,
                   std::shared_ptr<const Type> type);
 
-    friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
-                                         const LiteralDefine &literalDefine);
+    std::string getDefinition(const LocationManager &locationManager) const;
 
     bool usesType(const std::shared_ptr<const Type> &type, bool stopOnTypeDefs,
                   std::vector<std::shared_ptr<const Type>> &visitedTypes) const;

bindgen/ir/LocationManager.cpp

@@ -1,12 +1,45 @@
 #include "LocationManager.h"
+#include "../Utils.h"
+#include "Enum.h"
+#include "Struct.h"
+#include <fstream>
 
 LocationManager::LocationManager(std::string mainHeaderPath)
     : mainHeaderPath(std::move(mainHeaderPath)) {}
 
 void LocationManager::loadConfig(const std::string &path) {
-    // TODO: implement
+    std::string realPath = getRealPath(path.c_str());
+
+    std::ifstream input(realPath);
+    for (std::string line; getline(input, line);) {
+        size_t f = line.find('=');
+        if (f != std::string::npos) {
+            std::string header = line.substr(0, f);
+            std::string import = line.substr(f + 1, std::string::npos);
+            existingBindings[header] = import;
+        }
+    }
 }
 
 bool LocationManager::inMainFile(const Location &location) const {
     return location.getPath() == mainHeaderPath;
 }
+
+bool LocationManager::isImported(const Location &location) const {
+    for (const auto &existingBinding : existingBindings) {
+        if (endsWith(location.getPath(), existingBinding.first)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+std::string
+LocationManager::getContainingObject(const Location &location) const {
+    for (const auto &existingBinding : existingBindings) {
+        if (endsWith(location.getPath(), existingBinding.first)) {
+            return existingBinding.second;
+        }
+    }
+    assert(false && "Location is not in the list of imported bindings");
+}

bindgen/ir/LocationManager.h

@@ -13,6 +13,13 @@ class LocationManager {
 
     bool inMainFile(const Location &location) const;
 
+    /**
+     * @return true if given type is imported from another Scala object
+     */
+    bool isImported(const Location &location) const;
+
+    std::string getContainingObject(const Location &location) const;
+
   private:
     std::string mainHeaderPath;
     std::unordered_map<std::string, std::string> existingBindings;