Rust build system integration.

Author: aweinstock314

Diff for: Makefile

@@ -4,6 +4,7 @@ RM = rm -f  # rm command
 TARGET_LIB = assign-server/src/main/resources/libassign_pam.so # target lib
 
 INC = $(JAVA_HOME)/include $(JAVA_HOME)/include/linux ./include
+INC += /usr/lib/jvm/java-8-openjdk-amd64/include /usr/lib/jvm/java-8-openjdk-amd64/include/linux/
 INCDIRS = $(INC:%=-I%)
 
 CFLAGS = ${INCDIRS} -Wall -Wextra -fPIC -O2 -g

Diff for: libaris/build.gradle

@@ -12,6 +12,7 @@ dependencies {
     compile 'org.apache.commons:commons-lang3:3.7'
     compile 'org.apache.logging.log4j:log4j-api:2.10.0'
     compile 'org.apache.logging.log4j:log4j-core:2.10.0'
+    compile group: 'commons-io', name: 'commons-io', version: '2.6'
 
     implementation 'org.antlr:antlr4-runtime:4.7.1'
     antlr 'org.antlr:antlr4:4.7.1'
@@ -23,3 +24,30 @@ dependencies {
 
     testCompile group: 'junit', name: 'junit', version: '4.12'
 }
+
+build { dependsOn "rust-build" }
+test { dependsOn "rust-build" }
+
+task "rust-build" {
+    dependsOn "compileJava"
+    doFirst {
+        exec {
+            workingDir './src/main/rust'
+            commandLine 'cargo', 'build', '--release'
+        }
+        copy {
+            into './build/resources/main'
+            from './src/main/rust/target/release/liblibaris_rs.so'
+        }
+    }
+}
+
+task "get-runtime-classpath" {
+    doFirst {
+        def classpath = ''
+        sourceSets.main.runtimeClasspath.each {
+            classpath += ':' + it
+        }
+        println classpath
+    }
+}

Diff for: libaris/src/main/java/edu/rpi/aris/ast/ASTConstructor.java

@@ -1,12 +1,54 @@
 package edu.rpi.aris.ast;
 
 import edu.rpi.aris.ast.Expression.*;
+import java.io.*;
 import java.util.*;
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.misc.ParseCancellationException;
 import org.antlr.v4.runtime.tree.*;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.SystemUtils;
+import org.apache.logging.log4j.*;
 
 public class ASTConstructor extends ParseExpressionBaseVisitor<Expression> implements ParseExpressionVisitor<Expression> {
+    // TODO: deduplicate with edu.rpi.aris.assign.server.auth.PAMLoginAuth and put into a common util class
+    private static final Logger log = LogManager.getLogger();
+    private static final Set<String> loaded = new HashSet();
+    static { loadLib("liblibaris_rs"); }
+    private static void loadLib(String LIB_NAME) {
+        if (!SystemUtils.IS_OS_LINUX) {
+            // TODO: drop a dll on windows, a .so on mac
+            return;
+        }
+        String LIB_FILE = LIB_NAME + ".so";
+        log.info("Loading " + LIB_FILE + " native library");
+
+        File tmpFile = new File(System.getProperty("java.io.tmpdir"), LIB_FILE);
+        int i = 0;
+        while (tmpFile.exists() && !tmpFile.delete())
+            tmpFile = new File(System.getProperty("java.io.tmpdir"), LIB_NAME + (i++) + ".so");
+        boolean copied = false;
+        try (InputStream in = ClassLoader.getSystemResourceAsStream(LIB_FILE);
+             FileOutputStream out = new FileOutputStream(tmpFile)) {
+            if (in != null) {
+                IOUtils.copy(in, out);
+                copied = true;
+            }
+        } catch (IOException e) {
+            copied = false;
+            log.error("Failed to extract " + LIB_NAME + " to temp directory", e);
+        }
+        if (copied) {
+            try {
+                System.load(tmpFile.getCanonicalPath());
+                loaded.add(LIB_NAME);
+            } catch (Exception e) {
+                log.error("Failed to load native " + LIB_NAME + " library", e);
+            }
+        }
+    }
+
+    public static native Expression parseViaRust(String s);
     public static Expression parse(String s) {
         ASTConstructor x = new ASTConstructor();
         CharStream cs = new ANTLRInputStream(s);

Diff for: libaris/src/main/java/edu/rpi/aris/ast/Expression.java

@@ -25,16 +25,16 @@ public static class PredicateExpression extends Expression {
         }
     }
 
-    public static class UnaryExpression extends Expression {
-        Expression operand;
+    public static abstract class UnaryExpression extends Expression {
+        public Expression operand;
         UnaryExpression() { operand = null; }
     }
     public static class NotExpression extends Expression.UnaryExpression {
         @Override public String toString() { return "~" + operand.toString(); }
     }
 
-    public static class BinaryExpression extends Expression {
-        Expression l; Expression r;
+    public static abstract class BinaryExpression extends Expression {
+        public Expression l; public Expression r;
         BinaryExpression() { l = null; r = null; }
     }
     public static class ImplicationExpression extends Expression.BinaryExpression {
@@ -73,7 +73,7 @@ public static class BiconExpression extends Expression.AssociativeBinopExpressio
     }
 
     public static abstract class QuantifierExpression extends Expression {
-        String boundvar; Expression body;
+        public String boundvar; public Expression body;
         protected abstract String canonicalRepr();
         QuantifierExpression() { boundvar = null; body = null; }
         @Override public String toString() { return canonicalRepr() + boundvar + ", (" + (body != null ? body.toString() : "null") + ")"; }

Diff for: libaris/src/main/rust/Cargo.lock

@@ -0,0 +1,10 @@
+[package]
+name = "libaris-rs"
+version = "0.1.0"
+authors = ["Avi Weinstock <[email protected]>"]
+
+[dependencies]
+jni = "0.10.2"
+
+[lib]
+crate_type = ["cdylib"]

Diff for: libaris/src/main/rust/Cargo.toml

@@ -0,0 +1,40 @@
+extern crate jni;
+
+use jni::JNIEnv;
+use jni::objects::{JClass, JString};
+use jni::sys::jobject;
+
+#[no_mangle]
+#[allow(non_snake_case)]
+pub extern "system" fn Java_edu_rpi_aris_ast_ASTConstructor_parseViaRust(env: JNIEnv, cls: JClass, e: JString) -> jobject {
+    println!("Hello from Rust!");
+    std::ptr::null_mut()
+}
+
+
+
+#[derive(Debug)]
+enum USymbol { Not }
+
+#[derive(Debug)]
+enum BSymbol { Implies, Plus, Mult }
+
+#[derive(Debug)]
+enum ASymbol { And, Or, Bicon }
+
+#[derive(Debug)]
+enum QSymbol { Forall, Exists }
+
+#[derive(Debug)]
+enum Expression {
+    Bottom,
+    Predicate { name: String, args: Vec<String> },
+    Unop { symbol: USymbol, operand: Box<Expression> },
+    Binop { symbol: BSymbol, left: Box<Expression>, right: Box<Expression> },
+    AssocBinop { symbol: ASymbol, exprs: Vec<Expression> },
+    Quantifier { symbol: QSymbol, name: String, body: Box<Expression> },
+}
+
+#[cfg(test)]
+mod tests {
+}