Merge branch 'master' into opaque-type

Author: jonas

bindgen/Utils.h

@@ -3,6 +3,7 @@
 
 #include <clang/AST/AST.h>
 
+#include "ir/TypeDef.h"
 #include "ir/types/Type.h"
 #include <algorithm>
 #include <cctype>
@@ -108,6 +109,17 @@ static inline std::string replaceChar(const std::string &str,
         return std::string(str).replace(f, c1.length(), c2);
     }
     return std::string(str);
+
+/**
+ * Types may be wrapper in a chain of typedefs.
+ * @return true if given type is of type T or is an alias for type T.
+ */
+template <typename T> static inline bool isAliasForType(Type *type) {
+    if (isInstanceOf<TypeDef>(type)) {
+        auto *typeDef = dynamic_cast<TypeDef *>(type);
+        return isAliasForType<T>(typeDef->getType().get());
+    }
+    return isInstanceOf<T>(type);
 }
 
 #endif // UTILS_H

bindgen/ir/Struct.cpp

@@ -11,8 +11,8 @@ std::string Field::generateSetter(int fieldIndex) {
     std::string setter = handleReservedWords(getName(), "_=");
     std::string parameterType = type->str();
     std::string value = "value";
-    if (isInstanceOf<ArrayType>(type.get()) ||
-        isInstanceOf<Struct>(type.get())) {
+    if (isAliasForType<ArrayType>(type.get()) ||
+        isAliasForType<Struct>(type.get())) {
         parameterType = "native.Ptr[" + parameterType + "]";
         value = "!" + value;
     }
@@ -26,8 +26,8 @@ std::string Field::generateGetter(int fieldIndex) {
     std::string getter = handleReservedWords(getName());
     std::string returnType = type->str();
     std::string methodBody;
-    if (isInstanceOf<ArrayType>(type.get()) ||
-        isInstanceOf<Struct>(type.get())) {
+    if (isAliasForType<ArrayType>(type.get()) ||
+        isAliasForType<Struct>(type.get())) {
         returnType = "native.Ptr[" + returnType + "]";
         methodBody = "p._" + std::to_string(fieldIndex + 1);
     } else {

build.sbt

@@ -5,7 +5,7 @@ import java.nio.file.Path
 inThisBuild(
   Def.settings(
     organization := "org.scalanative.bindgen",
-    version := "0.1-SNAPSHOT",
+    version := "0.2-SNAPSHOT",
     scalaVersion := "2.11.12",
     scalacOptions ++= Seq(
       "-deprecation",

docs/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-minimal

docs/index.md

@@ -0,0 +1,6 @@
+# Scala Native Bindgen
+
+This tool generates Scala Native bindings from C headers.
+It's built upon clang and [LibTooling] and thus respects the conventions of clang-tools.
+
+ [LibTooling]: https://clang.llvm.org/docs/LibTooling.html

docs/obtaining-bindgen.md

@@ -0,0 +1,107 @@
+# Obtaining bindgen
+
+There are 2 ways to obtain bindgen:
+ * [Use docker container](#docker-container) 
+ * [Build binary with CMake](#building-with-cmake)
+ * [Build binary with docker-compose](#building-with-docker-compose)
+
+## Docker container
+
+This option requires [Docker].
+
+Download docker image with the binary:
+
+```sh
+docker pull scalabindgen/scala-native-bindgen
+```
+
+Mount directories with required header files and run bindgen:
+
+```sh
+docker run -v "$(pwd)":/src -v /usr/include:/usr/include \
+  --rm scalabindgen/scala-native-bindgen \
+  relative/path/to/my_header.h --name my_header --
+```
+
+The docker image does not contain standard headers so it is important to
+mount all system include directories that are used by the header file
+passed to `scala-native-bindgen`. See the [docker-bindgen.sh] script for
+how to wrap the dockerized program. The `$CWD` of the container is
+`/src` which should be mounted from `$(pwd)` in case relative paths are
+used.
+
+Note, the `scalabindgen/scala-native-bindgen:latest` image is updated on
+each merge to the `master` branch.
+
+ [Docker]: https://www.docker.com/
+ [docker-bindgen.sh]: scripts/docker-bindgen.sh
+
+## Building with `CMake`
+
+Building `scala-native-bindgen` requires the following tools and libraries:
+
+ - [CMake] version 3.9 or higher
+ - [LLVM] and [Clang] version 5.0 or 6.0.
+
+```sh
+# On apt-based systems
+apt install cmake clang-$LLVM_VERSION libclang-$LLVM_VERSION-dev llvm-$LLVM_VERSION-dev
+
+# With `brew`
+brew install cmake llvm@6
+```
+
+To run the tests you also need the required Scala Native libraries.
+See the [Scala Native setup guide] for instructions on installing the dependencies.
+
+```sh
+mkdir -p bindgen/target
+cd bindgen/target
+cmake ..
+make
+./scala-native-bindgen --name ctype /usr/include/ctype.h --
+```
+
+To build a statically linked executable pass `-DSTATIC_LINKING=ON` when invoking `cmake`:
+
+```sh
+cmake -DSTATIC_LINKING=ON ..
+```
+
+Additional compiler and linker flags may be passed as environment variable sor their CMake
+equivalent, e.g. to compile with debug symbols the following are the same:
+
+```sh
+cmake -DCMAKE_CXX_FLAGS=-g ..
+CXXFLAGS=-g cmake ..
+```
+
+## Building with `docker-compose`
+
+Alternatively, you can use [docker-compose] to build and test the program:
+
+```sh
+# Build the docker image with LLVM version 6.0.
+docker-compose build ubuntu-18.04-llvm-6.0
+# Build the bindgen tool and run the tests.
+docker-compose run --rm ubuntu-18.04-llvm-6.0 ./script/test.sh
+# Run the bindgen tool inside the container.
+docker-compose run --rm ubuntu-18.04-llvm-6.0 \
+    bindgen/target/scala-native-bindgen --name union tests/samples/Union.h --
+```
+
+ [CMake]: https://cmake.org/
+ [LLVM]: https://llvm.org/
+ [Clang]: https://clang.llvm.org/
+ [Scala Native setup guide]: http://www.scala-native.org/en/latest/user/setup.html
+ [docker-compose]: https://docs.docker.com/compose/
+
+## Testing
+
+The tests assume that the above instructions for building `scala-native-bindgen` from source
+has been followed.
+
+```sh
+cd tests
+sbt test
+```

tests/samples/ReservedWords.scala

@@ -37,8 +37,8 @@ object ReservedWordsHelpers {
   implicit class struct_finally_ops(val p: native.Ptr[struct_finally]) extends AnyVal {
     def `val`: `def` = !p._1
     def `val_=`(value: `def`): Unit = !p._1 = value
-    def `finally`: `lazy` = !p._2
-    def `finally_=`(value: `lazy`): Unit = !p._2 = value
+    def `finally`: native.Ptr[`lazy`] = p._2
+    def `finally_=`(value: native.Ptr[`lazy`]): Unit = !p._2 = !value
   }
 
   def struct_finally()(implicit z: native.Zone): native.Ptr[struct_finally] = native.alloc[struct_finally]

tests/samples/Struct.c

@@ -1,7 +1,27 @@
 #include "Struct.h"
 #include <stdlib.h>
 
-point_s getPoint() {
+void setPoints(struct points *points, int x1, int y1, int x2, int y2) {
+    points->p1.x = x1;
+    points->p1.y = y1;
+    points->p2.x = x2;
+    points->p2.y = y2;
+}
+
+int getPoint(struct points *points, enum pointIndex pointIndex) {
+    switch (pointIndex) {
+    case X1:
+        return points->p1.x;
+    case X2:
+        return points->p2.x;
+    case Y1:
+        return points->p1.y;
+    case Y2:
+        return points->p2.y;
+    }
+}
+
+point_s createPoint() {
     point_s point = malloc(sizeof(struct point));
     point->x = 10;
     point->y = 20;

tests/samples/Struct.h

@@ -3,9 +3,22 @@ struct point {
     int y;
 };
 
+typedef struct point point;
+
+struct points {
+    struct point p1;
+    point p2;
+};
+
+enum pointIndex { X1, Y1, X2, Y2 };
+
+void setPoints(struct points *points, int x1, int y1, int x2, int y2);
+
+int getPoint(struct points *points, enum pointIndex pointIndex);
+
 typedef struct point *point_s;
 
-point_s getPoint();
+point_s createPoint();
 
 struct bigStruct {
     long one;

tests/samples/Struct.scala

@@ -7,17 +7,29 @@ import scala.scalanative.native._
 @native.extern
 object Struct {
   type struct_point = native.CStruct2[native.CInt, native.CInt]
+  type point = struct_point
+  type struct_points = native.CStruct2[struct_point, point]
+  type enum_pointIndex = native.CUnsignedInt
   type point_s = native.Ptr[struct_point]
   type struct_bigStruct = native.CArray[Byte, native.Nat.Digit[native.Nat._1, native.Nat.Digit[native.Nat._1, native.Nat._2]]]
   type struct_structWithAnonymousStruct = native.CStruct2[native.CInt, native.CArray[Byte, native.Nat._8]]
-  def getPoint(): native.Ptr[struct_point] = native.extern
+  def setPoints(points: native.Ptr[struct_points], x1: native.CInt, y1: native.CInt, x2: native.CInt, y2: native.CInt): Unit = native.extern
+  def getPoint(points: native.Ptr[struct_points], pointIndex: enum_pointIndex): native.CInt = native.extern
+  def createPoint(): native.Ptr[struct_point] = native.extern
   def getBigStructSize(): native.CInt = native.extern
   def getCharFromAnonymousStruct(s: native.Ptr[struct_structWithAnonymousStruct]): native.CChar = native.extern
   def getIntFromAnonymousStruct(s: native.Ptr[struct_structWithAnonymousStruct]): native.CChar = native.extern
 }
 
 import Struct._
 
+object StructEnums {
+  final val enum_pointIndex_X1: enum_pointIndex = 0.toUInt
+  final val enum_pointIndex_Y1: enum_pointIndex = 1.toUInt
+  final val enum_pointIndex_X2: enum_pointIndex = 2.toUInt
+  final val enum_pointIndex_Y2: enum_pointIndex = 3.toUInt
+}
+
 object StructHelpers {
 
   implicit class struct_point_ops(val p: native.Ptr[struct_point]) extends AnyVal {
@@ -29,6 +41,15 @@ object StructHelpers {
 
   def struct_point()(implicit z: native.Zone): native.Ptr[struct_point] = native.alloc[struct_point]
 
+  implicit class struct_points_ops(val p: native.Ptr[struct_points]) extends AnyVal {
+    def p1: native.Ptr[struct_point] = p._1
+    def p1_=(value: native.Ptr[struct_point]): Unit = !p._1 = !value
+    def p2: native.Ptr[point] = p._2
+    def p2_=(value: native.Ptr[point]): Unit = !p._2 = !value
+  }
+
+  def struct_points()(implicit z: native.Zone): native.Ptr[struct_points] = native.alloc[struct_points]
+
   implicit class struct_structWithAnonymousStruct_ops(val p: native.Ptr[struct_structWithAnonymousStruct]) extends AnyVal {
     def a: native.CInt = !p._1
     def a_=(value: native.CInt): Unit = !p._1 = value

tests/samples/Union.c

@@ -1,8 +1,55 @@
 #include "Union.h"
 #include <stdlib.h>
+#include <string.h>
 
-void setIntValue(union values *v) { v->i = 10; }
+int union_get_sizeof() { return sizeof(union values); }
 
-void setLongValue(union values *v) { v->l = 10000000000; }
+int union_test_int(union values *v, enum union_op op, int value) {
+    switch (op) {
+    case UNION_SET:
+        v->i = value;
+        return 1;
+    case UNION_TEST:
+        return v->i == value;
+    }
+}
 
-int getUnionSize() { return sizeof(union values); }
+int union_test_long(union values *v, enum union_op op, long value) {
+    switch (op) {
+    case UNION_SET:
+        v->l = value;
+        return 1;
+    case UNION_TEST:
+        return v->l == value;
+    }
+}
+
+int union_test_long_long(union values *v, enum union_op op, long long value) {
+    switch (op) {
+    case UNION_SET:
+        v->ll = value;
+        return 1;
+    case UNION_TEST:
+        return v->ll == value;
+    }
+}
+
+int union_test_double(union values *v, enum union_op op, double value) {
+    switch (op) {
+    case UNION_SET:
+        v->d = value;
+        return 1;
+    case UNION_TEST:
+        return v->d == value;
+    }
+}
+
+int union_test_string(union values *v, enum union_op op, const char *value) {
+    switch (op) {
+    case UNION_SET:
+        v->s = value;
+        return 1;
+    case UNION_TEST:
+        return v->s == value || !strcmp(v->s, value);
+    }
+}

tests/samples/Union.h

@@ -2,10 +2,16 @@ union values {
     long l;
     int i;
     long long ll;
+    double d;
+    const char *s;
 };
 
-void setIntValue(union values *v);
+enum union_op { UNION_SET, UNION_TEST };
 
-void setLongValue(union values *v);
+int union_get_sizeof();
 
-int getUnionSize();
+int union_test_int(union values *v, enum union_op op, int value);
+int union_test_long(union values *v, enum union_op op, long value);
+int union_test_long_long(union values *v, enum union_op op, long long value);
+int union_test_double(union values *v, enum union_op op, double value);
+int union_test_string(union values *v, enum union_op op, const char *value);