v2: native .decode() and .root() implementations

Many tests are Ignored or are expected to fail,
due to rest of the native API not implemented yet.

Signed-off-by: Alexander Bezzubov <[email protected]>

Author: bzz

.travis.yml

@@ -21,7 +21,7 @@ before_install:
  - docker run --privileged -d -p 9432:9432 --name bblfsh bblfsh/bblfshd
  - docker exec -it bblfsh bblfshctl driver install --recommended
  - sudo apt-get update
- - sudo apt-get install -y --no-install-recommends clang g++ gcc gcc-multilib libc6-dev libc6-dev-i386 mingw-w64 patch xz-utils libxml2-dev
+ - sudo apt-get install -y --no-install-recommends clang g++ gcc gcc-multilib libc6-dev libc6-dev-i386 mingw-w64 patch xz-utils
 
 env:
   global:

build.sbt

@@ -121,6 +121,7 @@ getLibuast := {
     s"mv ${os}-amd64 libuast" #&&
     "rm -rf src/main/resources/libuast" #&&
     "mv libuast src/main/resources" #&&
+    "rm src/main/resources/libuast.so" #&&
     "rm -rf libuast" #&&
     "rm libuast-bin.tar.gz" !
 }
@@ -133,10 +134,8 @@ compileScalaLibuast := {
 
     "mkdir -p ./src/main/resources/lib/" !
 
-    val nativeSourceFiles = "src/main/native/org_bblfsh_client_libuast_Libuast.cc "
-        // "src/main/native/jni_utils.cc " +
-        // "src/main/scala/org/bblfsh/client/libuast/nodeiface.cc " +
-        // "src/main/scala/org/bblfsh/client/libuast/memtracker.cc " +
+    val nativeSourceFiles = "src/main/native/org_bblfsh_client_v2_libuast_Libuast.cc " +
+        "src/main/native/jni_utils.cc "
 
     compileUnix(nativeSourceFiles)
     crossCompileMacOS(nativeSourceFiles)
@@ -151,12 +150,14 @@ def compileUnix(sourceFiles: String) = {
   }
 
   val osName = System.getProperty("os.name").toLowerCase()
-  if (osName.contains("mac os x")) {
-    val cmd:String = "g++ -shared -Wall -fPIC -O2 -std=c++11 " +
+  if (osName.contains("mac os x")) { // TODO(bzz): change to '-fPIC -O2' for release
+    val cmd:String = "g++ -shared -Wall -g -std=c++11 " +
       "-I/usr/include " +
       "-I" + javaHome + "/include/ " +
       "-I" + javaHome + "/include/darwin " +
       "-Isrc/main/resources/libuast " +
+      "-Lsrc/main/resources/libuast " +
+      "-l uast " +
       "-o src/main/resources/lib/libscalauast.dylib " +
       sourceFiles + " "
 
@@ -167,6 +168,8 @@ def compileUnix(sourceFiles: String) = {
       "-I" + javaHome + "/include/ " +
       "-I" + javaHome + "/include/linux " +
       "-Isrc/main/resources/libuast " +
+      "-Lsrc/main/resources/libuast " +
+      "-l uast " +
       "-o src/main/resources/lib/libscalauast.so " +
       sourceFiles + " "
 
@@ -194,6 +197,8 @@ def crossCompileMacOS(sourceFiles: String): Unit = {
       "-I/usr/lib/jvm/java-8-openjdk-amd64/include " +
       "-I/usr/lib/jvm/java-8-openjdk-amd64/include/linux " +
       "-Isrc/libuast-native/ " +
+      "-Lsrc/main/resources/libuast " +
+      "-l uast " +
       "-o src/main/resources/lib/libscalauast.dylib " +
       sourceFiles
 

src/main/native/jni_handle.h

@@ -0,0 +1,34 @@
+#ifndef _JNI_HANDLE_H_INCLUDED_
+#define _JNI_HANDLE_H_INCLUDED_
+
+#include <jni.h>
+
+jfieldID getHandleField(JNIEnv *env, jobject obj, const char *name) {
+  jclass cls = env->GetObjectClass(obj);
+  if (env->ExceptionOccurred() || !cls) {
+    return nullptr;
+  }
+
+  jfieldID jfid = env->GetFieldID(cls, name, "J");
+  if (env->ExceptionOccurred() || !jfid) {
+    return nullptr;
+  }
+  return jfid;
+}
+
+template <typename T>
+T *getHandle(JNIEnv *env, jobject obj, const char *name) {
+  jlong handle = env->GetLongField(obj, getHandleField(env, obj, name));
+  if (env->ExceptionOccurred() || !handle) {
+    return nullptr;
+  }
+  return reinterpret_cast<T *>(handle);
+}
+
+template <typename T>
+void setHandle(JNIEnv *env, jobject obj, T *t, const char *name) {
+  jlong handle = reinterpret_cast<jlong>(t);
+  env->SetLongField(obj, getHandleField(env, obj, name), handle);
+}
+
+#endif

src/main/native/jni_utils.cc

@@ -0,0 +1,58 @@
+#include "jni_utils.h"
+
+// Class fully qualified names
+const char *CLS_NODE = "org/bblfsh/client/v2/Node";
+const char *CLS_CTX = "org/bblfsh/client/v2/Context";
+
+extern JavaVM *jvm;  // FIXME(bzz): double-check and document
+
+JNIEnv *getJNIEnv() {
+  JNIEnv *pEnv = NULL;
+
+  switch (jvm->GetEnv((void **)&pEnv, JNI_VERSION_1_8)) {
+    case JNI_OK:  // Thread is ready to use, nothing to do
+      break;
+
+    case JNI_EDETACHED:  // Thread is detached, need to attach
+      jvm->AttachCurrentThread((void **)&pEnv, NULL);
+      break;
+  }
+
+  return pEnv;
+}
+
+jobject NewJavaObject(JNIEnv *env, const char *className, const char *initSign,
+                      ...) {
+  jclass cls = env->FindClass(className);
+  if (env->ExceptionOccurred() || !cls) {
+    return NULL;
+  }
+
+  jmethodID initId = env->GetMethodID(cls, "<init>", initSign);
+  if (env->ExceptionOccurred() || !initId) {
+    return NULL;
+  }
+
+  va_list varargs;
+  va_start(varargs, initSign);
+  jobject instance = env->NewObjectV(cls, initId, varargs);
+  va_end(varargs);
+  if (env->ExceptionOccurred() || !instance) {
+    return NULL;
+  }
+
+  return instance;
+}
+
+jfieldID getField(JNIEnv *env, jobject obj, const char *name) {
+  jclass cls = env->GetObjectClass(obj);
+  if (env->ExceptionOccurred() || !cls) {
+    return nullptr;
+  }
+
+  jfieldID jfid = env->GetFieldID(cls, name, "J");
+  if (env->ExceptionOccurred() || !jfid) {
+    return nullptr;
+  }
+  return jfid;
+}

src/main/native/jni_utils.h

@@ -0,0 +1,13 @@
+#ifndef _Included_org_bblfsh_client_libuast_Libuast_jni_utils
+#define _Included_org_bblfsh_client_libuast_Libuast_jni_utils
+
+#include <jni.h>
+
+extern const char *CLS_NODE;
+extern const char *CLS_CTX;
+
+JNIEnv *getJNIEnv();
+jobject NewJavaObject(JNIEnv *, const char *, const char *, ...);
+jfieldID getField(JNIEnv *env, jobject obj, const char *name);
+
+#endif

src/main/native/org_bblfsh_client_v2_Context.h

@@ -1,11 +1,136 @@
 #include "org_bblfsh_client_v2_libuast_Libuast.h"
+#include "jni_handle.h"
+#include "jni_utils.h"
+#include "org_bblfsh_client_v2_Context.h"
 
-JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_libuast_Libuast_decode
-    (JNIEnv *, jobject, jobject) {
-    return NULL;
+#include "libuast.h"
+#include "libuast.hpp"
+
+JavaVM *jvm;  // FIXME(bzz): double-check and document
+
+jobject asJvmBuffer(uast::Buffer buf) {
+  JNIEnv *env = getJNIEnv();
+  return env->NewDirectByteBuffer(buf.ptr, buf.size);
+}
+
+class ContextExt {
+ private:
+  uast::Context<NodeHandle> *ctx;
+
+  jobject toJ(NodeHandle node) {
+    if (node == 0) return nullptr;
+
+    JNIEnv *env = getJNIEnv();
+    jobject jObj = NewJavaObject(env, CLS_NODE, "(JJ)V", this, node);
+    return jObj;
+  }
+
+  // toHandle casts an object to NodeExt and returns its handle.
+  // Borrows the reference.
+  NodeHandle toHandle(jobject obj) {
+    if (!obj) return 0;
+
+    JNIEnv *env = getJNIEnv();
+    jclass cls = env->FindClass(CLS_NODE);
+    if (env->ExceptionOccurred() || !cls) {
+      return 0;
+    }
+
+    if (!env->IsInstanceOf(obj, cls)) {
+      const char *err = "ContextExt.toHandle() called not on Node type";
+      ctx->SetError(err);
+      return 0;
+    }
+
+    auto handle =
+        (NodeHandle)env->GetLongField(obj, getField(env, obj, "handle"));
+    if (env->ExceptionOccurred() || !handle) {
+      return 0;
+    }
+
+    return handle;
+  }
+
+ public:
+  friend class Context;
+
+  ContextExt(uast::Context<NodeHandle> *c) : ctx(c) {}
+
+  ~ContextExt() { delete (ctx); }
+
+  jobject RootNode() {
+    NodeHandle root = ctx->RootNode();
+    return toJ(root);
+  }
+
+  // Encode serializes existing-on-guest-side UAST.
+  // Borrows the reference.
+  jobject Encode(jobject node, UastFormat format) {
+    NodeHandle h = toHandle(node);
+    uast::Buffer data = ctx->Encode(h, format);
+    return asJvmBuffer(data);
+  }
+};
+
+// v2.libuast.Libuast()
+JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_libuast_Libuast_decode(
+    JNIEnv *env, jobject self, jobject directBuf) {
+  UastFormat format = UAST_BINARY;  // TODO: make it arg
+
+  // works only with ByteBuffer.allocateDirect()
+  void *buf = env->GetDirectBufferAddress(directBuf);
+  if (env->ExceptionCheck() == JNI_TRUE) {
+    return nullptr;
+  }
+  jlong len = env->GetDirectBufferCapacity(directBuf);
+  if (env->ExceptionCheck() == JNI_TRUE) {
+    return nullptr;
+  }
+
+  // another option (instead of XXX) is to use
+  // GetPrimitiveArrayCritical
+  uast::Buffer ubuf(buf, (size_t)(len));
+  uast::Context<NodeHandle> *ctx = uast::Decode(ubuf, format);
+  // ReleasePrimitiveArrayCritical
+
+  auto p = new ContextExt(ctx);
+
+  jobject jCtxExt = NewJavaObject(env, CLS_CTX, "(J)V", p);
+  if (env->ExceptionCheck() == JNI_TRUE || !jCtxExt) {
+    jCtxExt = nullptr;
+    delete (ctx);
+    env->ExceptionDescribe();
+    throw std::runtime_error("failed to instantiate Context class");
+  }
+
+  return jCtxExt;
 }
 
-JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_libuast_Libuast_filter
-    (JNIEnv *, jobject, jobject, jstring) {
-    return NULL;
-}
+JNIEXPORT void JNICALL Java_org_bblfsh_client_v2_Context_dispose(JNIEnv *env,
+                                                                 jobject self) {
+  ContextExt *p = getHandle<ContextExt>(env, self, "nativeContext");
+  setHandle<ContextExt>(env, self, 0, "nativeContext");
+  delete p;
+}
+
+JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_libuast_Libuast_filter(
+    JNIEnv *, jobject, jobject, jstring) {
+  return NULL;  // TODO(bzz): implement
+}
+
+// v2.Context()
+JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_Context_root(JNIEnv *env,
+                                                                 jobject self) {
+  ContextExt *p = getHandle<ContextExt>(env, self, "nativeContext");
+  return p->RootNode();
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
+  JNIEnv *env;
+  if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_8) != JNI_OK) {
+    return -1;
+  }
+  jvm = vm;
+
+  return JNI_VERSION_1_8;
+}