Small fixes

kornilova203 · kornilova203 · commit b829c004af3d · 2018-06-03T12:02:12.000+03:00
diff --git a/ir/Enum.cpp b/ir/Enum.cpp
@@ -1,5 +1,6 @@
 #include "Enum.h"
-#include <utility>
+#include <sstream>
+#include <cassert>
 
 Enumerator::Enumerator(std::string name, uint64_t value)
         : name(std::move(name)), value(value) {}
@@ -16,7 +17,7 @@ bool Enum::isAnonymous() const {
 }
 
 TypeDef Enum::generateTypeDef() const {
-    assert (!name.empty()); // called after isAnonymous()
+    assert (!isAnonymous());
     return TypeDef("enum_" + name, "native.CInt");
 }
 
@@ -29,7 +30,7 @@ std::ostream &operator<<(std::ostream &s, const Enum &e) {
         } else {
             enumeratorName = "enum_" + enumerator.getName();
         }
-        s << "  final val " << enumeratorName << " = " << std::to_string(i++) + "\n";
+        s << "  final val " << enumeratorName << " = " << std::to_string(i++) << std::endl;
     }
     return s;
 }
diff --git a/ir/Enum.h b/ir/Enum.h
@@ -3,8 +3,7 @@
 
 
 #include <string>
-#include <clang/AST/Type.h>
-#include <stdint-gcc.h>
+#include <vector>
 #include "TypeDef.h"
 
 class Enumerator {
diff --git a/ir/Function.cpp b/ir/Function.cpp
@@ -1,6 +1,5 @@
 #include "Function.h"
 #include "../Utils.h"
-#include <utility>
 
 
 Parameter::Parameter(std::string name, std::string type)
diff --git a/ir/Function.h b/ir/Function.h
@@ -4,7 +4,6 @@
 
 #include <string>
 #include <vector>
-#include <clang/AST/Type.h>
 #include "TypeAndName.h"
 
 class Parameter : public TypeAndName {
diff --git a/ir/IR.cpp b/ir/IR.cpp
@@ -1,6 +1,4 @@
 #include <sstream>
-#include <utility>
-#include <llvm/Support/raw_ostream.h>
 #include "IR.h"
 #include "../Utils.h"
 
@@ -41,17 +39,17 @@ std::string IR::generate() {
     generateDecl();
     std::stringstream s;
     if (!libObjEmpty() || !enums.empty()) {
-        s << "import scala.scalanative._\n"
-          << "import scala.scalanative.native._\n"
-          << "import scala.scalanative.native.Nat._\n\n";
+        s << "import scala.scalanative._" << std::endl
+          << "import scala.scalanative.native._" << std::endl
+          << "import scala.scalanative.native.Nat._" << std::endl << std::endl;
     }
 
     std::string libObjName = handleReservedWords(libName);
 
     if (!libObjEmpty()) {
-        s << "@native.link(\"" << libName << "\")\n"
-          << "@native.extern\n"
-          << "object " << libObjName << " {\n";
+        s << "@native.link(\"" << libName << "\")" << std::endl
+          << "@native.extern" << std::endl
+          << "object " << libObjName << " {" << std::endl;
 
         for (const auto &typeDef : typeDefs) {
             s << typeDef;
@@ -61,38 +59,38 @@ std::string IR::generate() {
             s << func;
         }
 
-        s << "}\n\n";
+        s << "}" << std::endl << std::endl;
     }
 
     if (!enums.empty() || hasHelperMethods()) {
-        s << "import " << libObjName << "._\n\n";
+        s << "import " << libObjName << "._" << std::endl << std::endl;
     }
 
     if (!enums.empty()) {
-        s << "object " << libName << "Enums {\n";
+        s << "object " << libName << "Enums {" << std::endl;
 
         for (const auto &e : enums) {
             s << e
-              << "\n"; // space between groups of enums
+              << std::endl; // space between groups of enums
         }
 
-        s << "}\n\n";
+        s << "}" << std::endl << std::endl;
     }
 
     if (hasHelperMethods()) {
-        s << "object " << libName << "Helpers {\n";
+        s << "object " << libName << "Helpers {" << std::endl;
 
         for (const auto &st : structs) {
-            s << "\n";
-            s << st.generateHelperClass();
+            s << std::endl
+              << st.generateHelperClass();
         }
 
         for (const auto &u : unions) {
-            s << "\n";
-            s << u.generateHelperClass();
+            s << std::endl
+              << u.generateHelperClass();
         }
 
-        s << "}\n";
+        s << "}" << std::endl << std::endl;
     }
 
     return s.str();
@@ -132,3 +130,7 @@ bool IR::hasHelperMethods() const {
     }
     return false;
 }
+
+bool IR::hasEnums() const {
+    return enums.size() != 0;
+}
diff --git a/ir/IR.h b/ir/IR.h
@@ -32,6 +32,8 @@ class IR {
      */
     bool libObjEmpty() const;
 
+    bool hasEnums() const;
+
     std::string generate();
 
 private:
@@ -54,7 +56,7 @@ class IR {
     std::vector<Struct> structs;
     std::vector<Union> unions;
     std::vector<Enum> enums;
-    bool generated = false; // generate type defs only ones
+    bool generated = false; // generate type defs only once
 };
 
 
diff --git a/ir/Struct.cpp b/ir/Struct.cpp
@@ -1,6 +1,5 @@
 #include "Struct.h"
 #include "../Utils.h"
-#include <utility>
 #include <sstream>
 
 Field::Field(std::string name, std::string type)
@@ -18,7 +17,7 @@ TypeDef Struct::generateTypeDef() const {
                        "native.CStruct" + std::to_string(fields.size()) + "[" + getFieldsTypes() + "]");
     } else {
         // There is no easy way to represent it as a struct in scala native, have to represent it as an array and then
-        // Add helpers to help with it's manipulation
+        // Add helpers to help with its manipulation
         return TypeDef("struct_" + name, "native.CArray[Byte, " + uint64ToScalaNat(typeSize) + "]");
     }
 }
@@ -42,22 +41,24 @@ std::string Struct::generateHelperClass() const {
     }
     std::stringstream s;
     std::string newName = "struct_" + name;
-    s << "  implicit class " << newName << "_ops(val p: native.Ptr[struct_" << name << "]) extends AnyVal {\n";
+    s << "  implicit class " << newName << "_ops(val p: native.Ptr[struct_" << name << "])"
+      << " extends AnyVal {" << std::endl;
     int fieldIndex = 0;
     for (const auto &field : fields) {
         if (!field.getName().empty()) {
             std::string fname = handleReservedWords(field.getName());
             std::string ftype = field.getType();
-            s << "    def " << fname << ": " << ftype << " = !p._" << std::to_string(fieldIndex + 1) << "\n";
-            s << "    def " << fname << "_=(value: " + ftype + "):Unit = !p._" << std::to_string(fieldIndex + 1)
-              << " = value\n";
+            s << "    def " << fname << ": " << ftype << " = !p._" << std::to_string(fieldIndex + 1) << std::endl
+              << "    def " << fname << "_=(value: " + ftype + "):Unit = !p._" << std::to_string(fieldIndex + 1)
+              << " = value" << std::endl;
         }
         fieldIndex++;
     }
-    s << "  }\n\n";
+    s << "  }" << std::endl << std::endl;
 
     /* makes struct instantiation easier */
-    s << "  def " << newName + "()(implicit z: native.Zone): native.Ptr[" + newName + "] = native.alloc[" + newName + "]\n";
+    s << "  def " << newName + "()(implicit z: native.Zone): native.Ptr[" + newName + "]"
+      << " = native.alloc[" + newName + "]" << std::endl;
 
     return s.str();
 }
@@ -77,18 +78,18 @@ TypeDef Union::generateTypeDef() const {
 std::string Union::generateHelperClass() const {
     std::stringstream s;
     s << "  implicit class union_" << name << "_pos"
-      << "(val p: native.Ptr[native.CArray[Byte, " << uint64ToScalaNat(maxSize) << "]]) extends AnyVal {\n";
+      << "(val p: native.Ptr[union_" << name << "]) extends AnyVal {" << std::endl;
     for (const auto &field : fields) {
         if (!field.getName().empty()) {
             std::string fname = handleReservedWords(field.getName());
             std::string ftype = field.getType();
             s << "    def " << fname
-              << ": native.Ptr[" << ftype << "] = p.cast[native.Ptr[" << ftype << "]]\n";
+              << ": native.Ptr[" << ftype << "] = p.cast[native.Ptr[" << ftype << "]]" << std::endl;
 
             s << "    def " << fname
-              << "_=(value: " << ftype << "): Unit = !(p.cast[native.Ptr[" << ftype << "]]) = value\n";
+              << "_=(value: " << ftype << "): Unit = !p.cast[native.Ptr[" << ftype << "]] = value" << std::endl;
         }
     }
-    s << " }\n";
+    s << "  }" << std::endl;
     return s.str();
 }
diff --git a/ir/TypeAndName.h b/ir/TypeAndName.h
@@ -3,7 +3,6 @@
 
 
 #include <string>
-#include <clang/AST/Type.h>
 
 /**
  * Base class for function parameters, struct fields
diff --git a/ir/TypeDef.cpp b/ir/TypeDef.cpp
@@ -1,6 +1,5 @@
 #include "TypeDef.h"
 #include "../Utils.h"
-#include <utility>
 
 TypeDef::TypeDef(std::string name, std::string type)
         : TypeAndName(std::move(name), std::move(type)) {}
diff --git a/ir/TypeDef.h b/ir/TypeDef.h
@@ -3,7 +3,6 @@
 
 
 #include <string>
-#include <clang/AST/Type.h>
 #include "TypeAndName.h"
 
 
diff --git a/make.sh~ b/make.sh~
diff --git a/tests/samples/Struct.scala b/tests/samples/Struct.scala
@@ -21,4 +21,4 @@ object StructHelpers {
   }
 
   def struct_point()(implicit z: native.Zone): native.Ptr[struct_point] = native.alloc[struct_point]
-}
+}
diff --git a/tests/samples/Union.h b/tests/samples/Union.h
@@ -0,0 +1,5 @@
+union point {
+    long a;
+    int b;
+    long long c;
+};
diff --git a/tests/samples/Union.scala b/tests/samples/Union.scala
@@ -0,0 +1,23 @@
+import scala.scalanative._
+import scala.scalanative.native._
+import scala.scalanative.native.Nat._
+
+@native.link("Union")
+@native.extern
+object Union {
+  type union_point = native.CArray[Byte, Digit[_6, _4]]
+}
+
+import Union._
+
+object UnionHelpers {
+
+  implicit class union_point_pos(val p: native.Ptr[union_point]) extends AnyVal {
+    def a: native.Ptr[native.CLong] = p.cast[native.Ptr[native.CLong]]
+    def a_=(value: native.CLong): Unit = !p.cast[native.Ptr[native.CLong]] = value
+    def b: native.Ptr[native.CInt] = p.cast[native.Ptr[native.CInt]]
+    def b_=(value: native.CInt): Unit = !p.cast[native.Ptr[native.CInt]] = value
+    def c: native.Ptr[native.CLongLong] = p.cast[native.Ptr[native.CLongLong]]
+    def c_=(value: native.CLongLong): Unit = !p.cast[native.Ptr[native.CLongLong]] = value
+  }
+}
diff --git a/tests/tests.cpp b/tests/tests.cpp
diff --git a/visitor/ScalaFrontendActionFactory.cpp b/visitor/ScalaFrontendActionFactory.cpp
@@ -6,10 +6,9 @@ ScalaFrontendActionFactory::ScalaFrontendActionFactory(std::string libName)
           ir(libName) {}
 
 clang::FrontendAction *ScalaFrontendActionFactory::create() {
-    if (actionExecuted) {
-        std::cerr << "Action was already executed";
+    if (!ir.libObjEmpty() || ir.hasEnums()) {
+        std::cerr << "IR is not empty. Please use new instance of ScalaFrontendActionFactory." << std::endl;
     }
-    actionExecuted = true;
     return new ScalaFrontendAction(&ir); // instance will be deleted by LibTooling
 }
 
diff --git a/visitor/ScalaFrontendActionFactory.h b/visitor/ScalaFrontendActionFactory.h
@@ -23,12 +23,6 @@ class ScalaFrontendActionFactory : public clang::tooling::FrontendActionFactory
     std::string libName;
 
     IR ir;
-
-    /**
-     * Helps to make sure that action is executed only ones
-     * (otherwise `ir` will contain undefined results)
-     */
-    bool actionExecuted = false;
 };
 
 
diff --git a/visitor/TreeVisitor.cpp b/visitor/TreeVisitor.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`#include "Enum.h"`
`2`		`-#include <utility>`
	`2`	`+#include <sstream>`
	`3`	`+#include <cassert>`
`3`	`4`
`4`	`5`	`Enumerator::Enumerator(std::string name, uint64_t value)`
`5`	`6`	`: name(std::move(name)), value(value) {}`
`@@ -16,7 +17,7 @@ bool Enum::isAnonymous() const {`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`TypeDef Enum::generateTypeDef() const {`
`19`		`- assert (!name.empty()); // called after isAnonymous()`
	`20`	`+ assert (!isAnonymous());`
`20`	`21`	`return TypeDef("enum_" + name, "native.CInt");`
`21`	`22`	`}`
`22`	`23`
`@@ -29,7 +30,7 @@ std::ostream &operator<<(std::ostream &s, const Enum &e) {`
`29`	`30`	`} else {`
`30`	`31`	`enumeratorName = "enum_" + enumerator.getName();`
`31`	`32`	`}`
`32`		`- s << " final val " << enumeratorName << " = " << std::to_string(i++) + "\n";`
	`33`	`+ s << " final val " << enumeratorName << " = " << std::to_string(i++) << std::endl;`
`33`	`34`	`}`
`34`	`35`	`return s;`
`35`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`
`4`	`4`
`5`	`5`	`#include <string>`
`6`		`-#include <clang/AST/Type.h>`
`7`	`6`	`#include "TypeAndName.h"`
`8`	`7`
`9`	`8`