Merge pull request #62 from kornilova-l/defines-for-extern-variables

kornilova203 · web-flow · commit 8b63ced5304c · 2018-06-27T07:35:09.000+03:00
Generate bindings for defines for variables
diff --git a/bindgen/CMakeLists.txt b/bindgen/CMakeLists.txt
@@ -48,6 +48,12 @@ add_executable(bindgen
   ir/Define.cpp
   ir/LiteralDefine.cpp
   ir/LiteralDefine.h
+  ir/VarDefine.cpp
+  ir/VarDefine.h
+  ir/Variable.cpp
+  ir/Variable.h
+  ir/PossibleVarDefine.cpp
+  ir/PossibleVarDefine.h
 )
 
 set_target_properties(bindgen
diff --git a/bindgen/defines/DefineFinder.cpp b/bindgen/defines/DefineFinder.cpp
@@ -42,6 +42,11 @@ void DefineFinder::MacroDefined(const clang::Token &macroNameTok,
             std::string literal(stringToken.getLiteralData(),
                                 stringToken.getLength());
             ir.addLiteralDefine(macroName, "c" + literal, "native.CString");
+        } else if (tokens->size() == 1 &&
+                   (*tokens)[0].getKind() == clang::tok::identifier) {
+            // token might be a variable
+            std::string varName = (*tokens)[0].getIdentifierInfo()->getName();
+            ir.addPossibleVarDefine(macroName, varName);
         }
         std::free(tokens);
     }
diff --git a/bindgen/ir/Define.cpp b/bindgen/ir/Define.cpp
@@ -2,4 +2,4 @@
 
 Define::Define(std::string name) : name(std::move(name)) {}
 
-std::string Define::getName() { return name; }
+std::string Define::getName() const { return name; }
diff --git a/bindgen/ir/Define.h b/bindgen/ir/Define.h
@@ -7,7 +7,7 @@ class Define {
   public:
     explicit Define(std::string name);
 
-    std::string getName();
+    std::string getName() const;
 
   protected:
     std::string name;
diff --git a/bindgen/ir/IR.cpp b/bindgen/ir/IR.cpp
@@ -38,9 +38,18 @@ void IR::addLiteralDefine(std::string name, std::string literal,
                                 std::move(type));
 }
 
+void IR::addPossibleVarDefine(const std::string &macroName,
+                              const std::string &varName) {
+    possibleVarDefines.emplace_back(macroName, varName);
+}
+
+void IR::addVarDefine(std::string name, Variable *variable) {
+    varDefines.emplace_back(name, variable);
+}
+
 bool IR::libObjEmpty() const {
     return functions.empty() && typeDefs.empty() && structs.empty() &&
-           unions.empty();
+           unions.empty() && varDefines.empty();
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
@@ -69,6 +78,10 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
             s << typeDef;
         }
 
+        for (const auto &varDefine : ir.varDefines) {
+            s << varDefine;
+        }
+
         for (const auto &func : ir.functions) {
             s << func;
         }
@@ -166,9 +179,11 @@ void IR::filterDeclarations(const std::string &excludePrefix) {
 
     filterTypeDefs(excludePrefix);
 
-    filter(functions, excludePrefix);
+    filterByPrefix(functions, excludePrefix);
+
+    filterByPrefix(literalDefines, excludePrefix);
 
-    filter(literalDefines, excludePrefix);
+    filterByPrefix(varDefines, excludePrefix);
 }
 
 void IR::filterTypeDefs(const std::string &excludePrefix) {
@@ -236,24 +251,53 @@ bool IR::existsFunctionWithName(std::string functionName) {
 }
 
 void IR::removeDefine(const std::string &name) {
-    for (auto it = literalDefines.begin(), end = literalDefines.end();
-         it != end; ++it) {
-        if ((*it).getName() == name) {
-            literalDefines.erase(it);
-            return;
+    filterByName(literalDefines, name);
+    filterByName(possibleVarDefines, name);
+    filterByName(varDefines, name);
+}
+
+template <typename T>
+void IR::filterByPrefix(std::vector<T> &declarations,
+                        const std::string &excludePrefix) {
+    for (auto it = declarations.begin(); it != declarations.end();) {
+        auto &declaration = *it;
+        if (startsWith(declaration.getName(), excludePrefix)) {
+            it = declarations.erase(it);
+        } else {
+            it++;
         }
     }
 }
 
 template <typename T>
-void IR::filter(std::vector<T> &declarations,
-                const std::string &excludePrefix) {
+void IR::filterByName(std::vector<T> &declarations, const std::string &name) {
     for (auto it = declarations.begin(); it != declarations.end();) {
         auto &declaration = *it;
-        if (startsWith(declaration.getName(), excludePrefix)) {
+        if (declaration.getName() == name) {
             it = declarations.erase(it);
         } else {
             it++;
         }
     }
 }
+
+std::string IR::getDefineForVar(const std::string &varName) const {
+    for (const auto &varDefine : possibleVarDefines) {
+        if (varDefine.getVariableName() == varName) {
+            return varDefine.getName();
+        }
+    }
+    return "";
+}
+
+Variable *IR::addVariable(const std::string &name, const std::string &type) {
+    Variable *variable = new Variable(name, type);
+    variables.push_back(variable);
+    return variable;
+}
+
+IR::~IR() {
+    for (auto variable : variables) {
+        std::free(variable);
+    }
+}
diff --git a/bindgen/ir/IR.h b/bindgen/ir/IR.h
@@ -4,8 +4,10 @@
 #include "Enum.h"
 #include "Function.h"
 #include "LiteralDefine.h"
+#include "PossibleVarDefine.h"
 #include "Struct.h"
 #include "TypeDef.h"
+#include "VarDefine.h"
 
 /**
  * Intermediate representation
@@ -15,6 +17,8 @@ class IR {
     explicit IR(std::string libName, std::string linkName,
                 std::string objectName, std::string packageName);
 
+    ~IR();
+
     void addFunction(std::string name, std::vector<Parameter> parameters,
                      std::string, bool isVariadic);
 
@@ -32,6 +36,13 @@ class IR {
     void addLiteralDefine(std::string name, std::string literal,
                           std::string type);
 
+    void addPossibleVarDefine(const std::string &macroName,
+                              const std::string &varName);
+
+    void addVarDefine(std::string name, Variable *variable);
+
+    Variable *addVariable(const std::string &name, const std::string &type);
+
     /**
      * @return true if there are no functions, types,
      *         structs and unions
@@ -46,6 +57,12 @@ class IR {
 
     void removeDefine(const std::string &name);
 
+    /**
+     * @return macro name if there is a macro for the variable.
+     *         otherwise return empty string
+     */
+    std::string getDefineForVar(const std::string &varName) const;
+
   private:
     /**
      * Generates type defs for enums, structs and unions
@@ -106,7 +123,11 @@ class IR {
     bool existsFunctionWithName(std::string functionName);
 
     template <typename T>
-    void filter(std::vector<T> &declarations, const std::string &excludePrefix);
+    void filterByPrefix(std::vector<T> &declarations,
+                        const std::string &excludePrefix);
+
+    template <typename T>
+    void filterByName(std::vector<T> &declarations, const std::string &name);
 
     std::string libName;    // name of the library
     std::string linkName;   // name of the library to link with
@@ -117,6 +138,9 @@ class IR {
     std::vector<Union> unions;
     std::vector<Enum> enums;
     std::vector<LiteralDefine> literalDefines;
+    std::vector<PossibleVarDefine> possibleVarDefines;
+    std::vector<VarDefine> varDefines;
+    std::vector<Variable *> variables;
     bool generated = false; // generate type defs only once
     std::string packageName;
 };
diff --git a/bindgen/ir/PossibleVarDefine.cpp b/bindgen/ir/PossibleVarDefine.cpp
@@ -0,0 +1,7 @@
+#include "PossibleVarDefine.h"
+
+PossibleVarDefine::PossibleVarDefine(const std::string &name,
+                                     const std::string &variableName)
+    : Define(name), variableName(variableName) {}
+
+std::string PossibleVarDefine::getVariableName() const { return variableName; }
diff --git a/bindgen/ir/PossibleVarDefine.h b/bindgen/ir/PossibleVarDefine.h
@@ -0,0 +1,19 @@
+#ifndef SCALA_NATIVE_BINDGEN_POSSIBLEVARDEFINE_H
+#define SCALA_NATIVE_BINDGEN_POSSIBLEVARDEFINE_H
+
+#include "Define.h"
+
+/**
+ * Stores name of possible variable.
+ */
+class PossibleVarDefine : public Define {
+  public:
+    PossibleVarDefine(const std::string &name, const std::string &variableName);
+
+    std::string getVariableName() const;
+
+  private:
+    std::string variableName;
+};
+
+#endif // SCALA_NATIVE_BINDGEN_POSSIBLEVARDEFINE_H
diff --git a/bindgen/ir/VarDefine.cpp b/bindgen/ir/VarDefine.cpp
@@ -0,0 +1,12 @@
+#include "VarDefine.h"
+
+VarDefine::VarDefine(std::string name, Variable *variable)
+    : Define(std::move(name)), variable(variable) {}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
+                              const VarDefine &varDefine) {
+    s << "  @name(\"" << varDefine.variable->getName() << "\")\n"
+      << "  val " << varDefine.getName() << ": "
+      << varDefine.variable->getType() << " = native.extern\n";
+    return s;
+}
diff --git a/bindgen/ir/VarDefine.h b/bindgen/ir/VarDefine.h
@@ -0,0 +1,22 @@
+#ifndef SCALA_NATIVE_BINDGEN_VARDEFINE_H
+#define SCALA_NATIVE_BINDGEN_VARDEFINE_H
+
+#include "Define.h"
+#include "Variable.h"
+#include <llvm/Support/raw_ostream.h>
+
+/**
+ * Stores a pointer to Variable instance from IR
+ */
+class VarDefine : public Define {
+  public:
+    VarDefine(std::string name, Variable *variable);
+
+    friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
+                                         const VarDefine &varDefine);
+
+  private:
+    Variable *variable;
+};
+
+#endif // SCALA_NATIVE_BINDGEN_VARDEFINE_H
diff --git a/bindgen/ir/Variable.cpp b/bindgen/ir/Variable.cpp
@@ -0,0 +1,4 @@
+#include "Variable.h"
+
+Variable::Variable(const std::string &name, const std::string &type)
+    : TypeAndName(name, type) {}
diff --git a/bindgen/ir/Variable.h b/bindgen/ir/Variable.h
@@ -0,0 +1,11 @@
+#ifndef SCALA_NATIVE_BINDGEN_VARIABLE_H
+#define SCALA_NATIVE_BINDGEN_VARIABLE_H
+
+#include "TypeAndName.h"
+
+class Variable : public TypeAndName {
+  public:
+    Variable(const std::string &name, const std::string &type);
+};
+
+#endif // SCALA_NATIVE_BINDGEN_VARIABLE_H
diff --git a/bindgen/visitor/TreeVisitor.cpp b/bindgen/visitor/TreeVisitor.cpp
@@ -159,3 +159,19 @@ void TreeVisitor::handleStruct(clang::RecordDecl *record, std::string name) {
     ir.addStruct(name, fields,
                  astContext->getTypeSize(record->getTypeForDecl()));
 }
+
+bool TreeVisitor::VisitVarDecl(clang::VarDecl *varDecl) {
+    if (!varDecl->isThisDeclarationADefinition()) {
+        std::string variableName = varDecl->getName().str();
+        std::string type =
+            handleReservedWords(typeTranslator.Translate(varDecl->getType()));
+        Variable *variable = ir.addVariable(variableName, type);
+        /* check if there is a macro for the variable.
+         * Macros were saved by DefineFinder */
+        std::string macroName = ir.getDefineForVar(variableName);
+        if (!macroName.empty()) {
+            ir.addVarDefine(macroName, variable);
+        }
+    }
+    return true;
+}
diff --git a/bindgen/visitor/TreeVisitor.h b/bindgen/visitor/TreeVisitor.h
@@ -37,4 +37,5 @@ class TreeVisitor : public clang::RecursiveASTVisitor<TreeVisitor> {
     virtual bool VisitTypedefDecl(clang::TypedefDecl *tpdef);
     virtual bool VisitEnumDecl(clang::EnumDecl *enumdecl);
     virtual bool VisitRecordDecl(clang::RecordDecl *record);
+    virtual bool VisitVarDecl(clang::VarDecl *VD);
 };
diff --git a/tests/samples/LiteralDefine.h b/tests/samples/LiteralDefine.h
@@ -19,9 +19,6 @@
 #define NEW_INT INT
 #define NEG_INT -INT
 
-extern int a;
-#define MY_A a // unsupported
-
 #define __PRIVATE 1
 
 #define wait_for_it(cond)                                                      \
diff --git a/tests/samples/VarDefine.c b/tests/samples/VarDefine.c
@@ -0,0 +1,5 @@
+#include "VarDefine.h"
+
+int a = 23;
+const int constInt = 10;
+const int *constIntPointer = 0;
diff --git a/tests/samples/VarDefine.h b/tests/samples/VarDefine.h
@@ -0,0 +1,17 @@
+extern int a;
+#define A a
+
+extern const int constInt;
+#define CONST_INT constInt
+
+extern const int *constIntPointer;
+#define CONST_INT_POINTER constIntPointer
+
+#define B b // ignored because there is no such variable
+
+extern int c;
+#define C c
+#undef C // removed
+
+extern float f;
+#define __PRIVATE f // should be filtered
diff --git a/tests/samples/VarDefine.scala b/tests/samples/VarDefine.scala
@@ -0,0 +1,15 @@
+package org.scalanative.bindgen.samples
+
+import scala.scalanative._
+import scala.scalanative.native._
+
+@native.link("bindgentests")
+@native.extern
+object VarDefine {
+  @name("a")
+  val A: native.CInt = native.extern
+  @name("constInt")
+  val CONST_INT: native.CInt = native.extern
+  @name("constIntPointer")
+  val CONST_INT_POINTER: native.Ptr[native.CInt] = native.extern
+}
diff --git a/tests/samples/src/test/scala/org/scalanative/bindgen/samples/VarDefineTests.scala b/tests/samples/src/test/scala/org/scalanative/bindgen/samples/VarDefineTests.scala
@@ -0,0 +1,12 @@
+package org.scalanative.bindgen.samples
+
+import utest._
+
+object VarDefineTests extends TestSuite {
+  val tests = Tests {
+    'getA - {
+      assert(VarDefine.A == 23)
+      assert(VarDefine.CONST_INT == 10)
+    }
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,11 @@ void DefineFinder::MacroDefined(const clang::Token &macroNameTok,`
`42`	`42`	`std::string literal(stringToken.getLiteralData(),`
`43`	`43`	`stringToken.getLength());`
`44`	`44`	`ir.addLiteralDefine(macroName, "c" + literal, "native.CString");`
	`45`	`+ } else if (tokens->size() == 1 &&`
	`46`	`+ (*tokens)[0].getKind() == clang::tok::identifier) {`
	`47`	`+ // token might be a variable`
	`48`	`+ std::string varName = (*tokens)[0].getIdentifierInfo()->getName();`
	`49`	`+ ir.addPossibleVarDefine(macroName, varName);`
`45`	`50`	`}`
`46`	`51`	`std::free(tokens);`
`47`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,4 +2,4 @@`
`2`	`2`
`3`	`3`	`Define::Define(std::string name) : name(std::move(name)) {}`
`4`	`4`
`5`		`-std::string Define::getName() { return name; }`
	`5`	`+std::string Define::getName() const { return name; }`