This commit updates the gradle files to be cleaner. It also builds for the

current platform by default, and only builds tests when building for the
current platform. Mac builds and VS2015 builds are fixed.

The other big change in this update is the introduction of Debug and
Release builds. Debug builds are built with -O0 and -g. Release builds are
built with -O2 and -g. For GCC-based builds, the resulting shared object
is copied, stripped of debug information, and a debug link is set up to
the copied shared object. This allows the release build to clock in at
around 600 KB. On Windows, the debug info is already stored in a separate
PDB file, so this copy and strip is not necessary.

ntcore is being separated out from the rest of allwpilib. All other
builds will consume a published maven dependency from this project.
There are 4 possible publishing targets now: release, stable, beta, and
development. These are specified on the command line via -Prepo=<repo
name>.

Change-Id: Ie8cb21f910953e09b80a5192317033eb0866cb70

build.gradle

@@ -1,284 +1,164 @@
-import org.apache.tools.ant.taskdefs.condition.Os
+import org.gradle.internal.os.OperatingSystem
 
-if (!project.hasProperty('skipJava')) {
-  apply plugin: 'java'
-  apply plugin: 'maven-publish'
-}
 apply plugin: 'cpp'
 apply plugin: 'visual-studio'
 
-def generatedJNIHeaderLoc = 'build/include'
+// Find the target platform. The main wpilib build will set the target platform as a project property. You can also manually build for
+// arm by using ./gradlew build -PbuildPlatform=arm
+allprojects {
+    if (!project.hasProperty('armBuild')) {
+        ext.buildPlatform = OperatingSystem.current().getFamilyName()
+    } else {
+        ext.buildPlatform = 'arm'
+    }
+}
 
-def platformSpecificIncludeFlag(loc, cppCompiler) {
-  if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-    cppCompiler.args "/I$loc"
-  } else {
-    cppCompiler.args '-I', loc
-  }
+ext.getPlatformPath = { binary ->
+    if (binary.targetPlatform.architecture.arm) {
+        return 'Linux/arm'
+    } else if (binary.targetPlatform.operatingSystem.linux) {
+        if (binary.targetPlatform.architecture.amd64) {
+            return 'Linux/amd64'
+        } else {
+            return 'Linux/' + binary.targetPlatform.architecture.name
+        }
+    } else if (binary.targetPlatform.operatingSystem.windows) {
+        if (binary.targetPlatform.architecture.amd64) {
+            return 'Windows/amd64'
+        } else {
+            return 'Windows/' + binary.targetPlatform.architecture.name
+        }
+    } else {
+        return binary.targetPlatform.operatingSystem.name + '/' + binary.targetPlatform.architecture.name
+    }
+}
+
+// Apply the correct toolchain settings for the target platform
+if (buildPlatform == 'arm') {
+    apply from: 'toolchains/arm.gradle'
+} else if (OperatingSystem.current().isLinux()) {
+    apply from: 'toolchains/linux.gradle'
+} else if (OperatingSystem.current().isMacOsX()) {
+    apply from: 'toolchains/mac.gradle'
+} else if (OperatingSystem.current().isWindows()) {
+    apply from: 'toolchains/windows.gradle'
+} else {
+    throw new GradleException("ntcore does not support building on ${OperatingSystem.current().getFamilyName()}.")
+}
+
+// We only build and run the tests when building for the native platform. If we just build arm, there's not much point.
+if (buildPlatform != 'arm') {
+    apply from: 'test/tests.gradle'
+}
+
+if (!hasProperty('skipJava')) {
+    apply from: 'java/java.gradle'
 }
 
 model {
-  toolChains {
-    gcc(Gcc) {
-      target("arm"){
-        // We use a custom-built cross compiler with the prefix arm-frc-linux-gnueabi-<util name>
-        // If this ever changes, the prefix will need to be changed here
-        def compilerPrefix = 'arm-frc-linux-gnueabi-'
-        cppCompiler.executable = compilerPrefix + cppCompiler.executable
-        linker.executable = compilerPrefix + linker.executable
-        assembler.executable = compilerPrefix + assembler.executable
-        // Gradle auto-adds the -m32 argument to the linker and compiler. Our compiler only supports
-        // arm, and doesn't understand this flag, so it is removed from both
-        cppCompiler.withArguments { args ->
-          args << '-std=c++1y' << '-Wformat=2' << '-Wall' << '-Wextra' << '-Werror' << '-pedantic'
-          args << '-Wno-psabi' << '-Wno-unused-parameter' << '-fPIC' << '-O0' << '-g3' << '-rdynamic'
-          //TODO: When the compiler allows us to actually call deprecated functions from within
-          // deprecated function, remove this line (this will cause calling deprecated functions
-          // to be treated as a warning rather than an error).
-          args << '-Wno-error=deprecated-declarations'
-          args.remove('-m32')
+    platforms {
+        if (project.buildPlatform == 'arm') {
+            arm {
+                architecture 'arm'
+                operatingSystem 'linux'
+            }
+        } else {
+            x86 {
+                architecture 'x86'
+                operatingSystem project.buildPlatform
+            }
+            x64 {
+                architecture 'x86_64'
+                operatingSystem project.buildPlatform
+            }
         }
-        linker.withArguments { args ->
-          args << '-rdynamic'
-          args.remove('-m32')
-        }
-        staticLibArchiver.executable = compilerPrefix + staticLibArchiver.executable
-      }
-      target('x86') {
-        cppCompiler.withArguments { args ->
-          args << '-std=c++11' << '-Wformat=2' << '-Wall' << '-Wextra' << '-Werror' << '-pedantic'
-          args << '-Wno-psabi' << '-Wno-unused-parameter' << '-fPIC' << '-O0' << '-g3' << '-rdynamic'
-          //TODO: When the compiler allows us to actually call deprecated functions from within
-          // deprecated function, remove this line (this will cause calling deprecated functions
-          // to be treated as a warning rather than an error).
-          args << '-Wno-error=deprecated-declarations'
-          args << '-m32'
-        }
-        linker.withArguments { args ->
-          args << '-rdynamic'
-          args << '-m32'
-        }
-      }
-      target('x64') {
-        cppCompiler.withArguments { args ->
-          args << '-std=c++11' << '-Wformat=2' << '-Wall' << '-Wextra' << '-Werror' << '-pedantic'
-          args << '-Wno-psabi' << '-Wno-unused-parameter' << '-fPIC' << '-O0' << '-g3' << '-rdynamic'
-          //TODO: When the compiler allows us to actually call deprecated functions from within
-          // deprecated function, remove this line (this will cause calling deprecated functions
-          // to be treated as a warning rather than an error).
-          args << '-Wno-error=deprecated-declarations'
-        }
-        linker.withArguments { args ->
-          args << '-rdynamic'
-        }
-      }
     }
-    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-      visualCpp(VisualCpp) {
-        def vs14Dir = file('C:\\Program Files (x86)\\Microsoft Visual Studio 14.0')
-        // If vs2015 is installed, fall back to vs2013 for now, until Gradle pulls in the right
-        // includes for the win10 sdk.
-        if (vs14Dir.exists()) {
-          def vs12Dir = file('C:\\Program Files (x86)\\Microsoft Visual Studio 12.0')
-          if (!vs12Dir.exists()) {
-            throw new GradleException('Compilation with VS 2015 is not currently supported by Gradle. Please install VS 2013, or use the CMake build option.')
-          }
-          installDir = vs12Dir
-        }
-        eachPlatform {
-          cppCompiler.withArguments { args ->
-            args << '/EHsc' << '/DNOMINMAX' << '/D_SCL_SECURE_NO_WARNINGS' << '/D_WINSOCK_DEPRECATED_NO_WARNINGS'
-          }
-          linker.withArguments { args ->
-            args << '/DEF:ntcore.def'
-          }
-        }
-      }
-    }
-  }
 
-  platforms {
-    arm {
-      architecture "arm"
-      operatingSystem 'linux'
-    }
-    x86 {
-      architecture "x86"
-    }
-    x64 {
-      architecture "x86_64"
-    }
-  }
-
-  components {
-    ntcore(NativeLibrarySpec) {
-      targetPlatform 'arm'
-      targetPlatform 'x86'
-      targetPlatform 'x64'
-      binaries.all {
-        tasks.withType(CppCompile) {
-
-
-          if (!project.hasProperty('skipJava')) {
-            if (targetPlatform == platforms.arm) {
-              // ARM JDK is included for jni.h. We also need the arm-linux specific headers.
-              // This does not need to change when compiling on Windows
-              // The JNI headers are put into the build/include directory by the jniHeaders task
-              sources {
-                arm(CppSourceSet) {
-                  source {
-                    includes "java/arm-linux"
-                    includes "java/arm-linux/linux"
-                  }
+    components {
+        ntcore(NativeLibrarySpec) {
+            if (project.buildPlatform == 'arm') {
+                targetPlatform 'arm'
+                binaries.all {
+                    if (project.hasProperty('debug')) {
+                        setupDebugDefines(cppCompiler, linker)
+                    } else {
+                        setupReleaseDefines(cppCompiler, linker)
+                    }
                 }
-              }
             } else {
-              def jdkLocation = org.gradle.internal.jvm.Jvm.current().javaHome
-              platformSpecificIncludeFlag("${jdkLocation}/include", cppCompiler)
-
-              if (targetPlatform.operatingSystem.macOsX) {
-                platformSpecificIncludeFlag("${jdkLocation}/include/darwin", cppCompiler)
-              } else if (targetPlatform.operatingSystem.linux) {
-                platformSpecificIncludeFlag("${jdkLocation}/include/linux", cppCompiler)
-              } else if (targetPlatform.operatingSystem.windows) {
-                platformSpecificIncludeFlag("${jdkLocation}/include/win32", cppCompiler)
-              } else if (targetPlatform.operatingSystem.freeBSD) {
-                platformSpecificIncludeFlag("${jdkLocation}/include/freebsd", cppCompiler)
-              }
+                targetPlatform 'x86'
+                targetPlatform 'x64'
+                binaries.all {
+                    if (project.hasProperty('debug')) {
+                        setupDebugDefines(cppCompiler, linker)
+                    } else {
+                        setupReleaseDefines(cppCompiler, linker)
+                    }
+                }
             }
 
-            jniHeadersNetworkTables.outputs.files.each { file ->
-              if (targetPlatform == platforms.arm) {
-                cppCompiler.args '-I', file.getPath()
-              } else {
-                platformSpecificIncludeFlag(file.getPath(), cppCompiler)
-              }
-            }
-            dependsOn jniHeadersNetworkTables
-          }
-        }
-      }
-      sources {
-        cpp {
-          source {
-            srcDirs = ["src"]
             if (!project.hasProperty('skipJava')) {
-              srcDirs "java/lib"
+                setupJniIncludes(binaries)
             }
-            includes = ["**/*.cpp"]
-          }
-          exportedHeaders {
-            srcDirs = ["include"]
-            if (!project.hasProperty('skipJava')) {
-              jniHeadersNetworkTables.outputs.files.each { file ->
-                srcDirs file.getPath()
-              }
+
+            sources {
+                cpp {
+                    source {
+                        srcDirs = ['src']
+                        if (!project.hasProperty('skipJava')) {
+                            srcDirs "java/lib"
+                        }
+                        includes = ['**/*.cpp']
+                    }
+                    exportedHeaders {
+                        srcDirs = ['include']
+                        if (!project.hasProperty('skipJava')) {
+                            jniHeadersNetworkTables.outputs.files.each { file ->
+                                srcDirs file.getPath()
+                            }
+                        }
+                        includes = ['**/*.h']
+                    }
+                }
             }
-            includes = ["**/*.h"]
-          }
         }
-      }
     }
-  }
 }
 
-if (!project.hasProperty('skipJava')) {
-
-  publishing {
-    publications {
-      java(MavenPublication) {
-        artifact jar
-        artifact (networktablesJavaSource) {
-          classifier = 'sources'
-        }
-        artifact(networktablesJavadoc) {
-          classifier = 'javadoc'
-        }
-
-        groupId 'edu.wpi.first.wpilib.networktables.java'
-        artifactId 'NetworkTables'
-        version '3.0.0-SNAPSHOT'
-      }
-    }
-  }
-
-  compileJava {
-    options.compilerArgs << "-Xlint:unchecked"
-  }
-
-  sourceSets {
-    main {
-      java {
-        srcDirs = ["java/src"]
-      }
-    }
-  }
-
-  jar {
-    description = 'Generates NetworkTables jar, with the JNI shared libraries embedded'
-    dependsOn { armNtcoreSharedLibrary }
-    dependsOn { x64NtcoreSharedLibrary }
-    dependsOn { x86NtcoreSharedLibrary }
-    dependsOn { classes }
-    binaries.withType(SharedLibraryBinary) { binary ->
-      from(file(binary.sharedLibraryFile)) {
-        if (binary.targetPlatform == platforms.arm) {
-          into "Linux/arm"
-        } else if (binary.targetPlatform.operatingSystem.name == "Linux") {
-          if (binary.targetPlatform.architecture.name == "x86-64") {
-            into "Linux/amd64"
-          } else {
-            into "Linux/" + binary.targetPlatform.architecture.name
-          }
-        } else if (binary.targetPlatform.operatingSystem.name.startsWith("Windows")) {
-          if (binary.targetPlatform.architecture.name == "x86-64") {
-            into "Windows/amd64"
-          } else {
-            into "Windows/" + binary.targetPlatform.architecture.name
-          }
-        } else {
-          into binary.targetPlatform.operatingSystem.name + "/" + binary.targetPlatform.architecture.name
-        }
-      }
-    }
-  }
-
-  task networktablesJavaSource(type: Jar, dependsOn: classes) {
-    description = 'Generates the source jar for NetworkTables java'
+task ntcoreZip(type: Zip) {
+    description = 'Creates platform-specific zip of the desktop ntcore libraries.'
     group = 'WPILib'
-    classifier = 'classes'
-    from sourceSets.main.allJava
-  }
+    destinationDir = project.buildDir
 
-  task networktablesJavadoc(type: Jar, dependsOn: javadoc) {
-    description = 'Generates the javadoc jar for NetworkTables java'
-    group = 'WPILib'
-    classifier = 'javadoc'
-    from javadoc.destinationDir
-  }
-
-  /**
-   * Generates the JNI headers
-   */
-  task jniHeadersNetworkTables {
-    description = 'Generates JNI headers from edu.wpi.first.wpilibj.networktables.*'
-    group = 'WPILib'
-    def outputFolder = file(generatedJNIHeaderLoc)
-    inputs.files sourceSets.main.output
-    outputs.file outputFolder
-    doLast {
-      outputFolder.mkdirs()
-      exec {
-        executable org.gradle.internal.jvm.Jvm.current().getExecutable('javah')
-        args '-d', outputFolder
-        args '-classpath', sourceSets.main.output.classesDir
-        args 'edu.wpi.first.wpilibj.networktables.NetworkTablesJNI'
-      }
+    from(file('include')) {
+        into 'include'
     }
-  }
 
-  clean {
-    delete generatedJNIHeaderLoc
-  }
+    binaries.withType(StaticLibraryBinarySpec) { binary ->
+        from(binary.staticLibraryFile) {
+            into getPlatformPath(binary)
+        }
+    }
 
-}  // skipJava
+    binaries.withType(SharedLibraryBinarySpec) { binary ->
+        from(binary.sharedLibraryFile) {
+            into getPlatformPath(binary)
+        }
+    }
+}
+
+releaseSetup(ntcoreZip)
+
+if (!hasProperty('skipJava')) {
+    jar.dependsOn ntcoreZip
+}
+
+tasks.whenTaskAdded { task ->
+    def name = task.name.toLowerCase()
+    if (name.contains("ntcoresharedlibrary") || name.contains("ntcorestaticlibrary") ||
+        name.contains("ntcoretest")) {
+        ntcoreZip.dependsOn task
+    }
+}
+
+apply from: 'publish.gradle'

gmock/build.gradle

@@ -1,45 +1,55 @@
-import org.apache.tools.ant.taskdefs.condition.Os
+import org.gradle.internal.os.OperatingSystem
+
 apply plugin: 'cpp'
 apply plugin: 'visual-studio'
 
-model {
-  toolChains {
-    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-      visualCpp(VisualCpp) {
-        def vs14Dir = file('C:\\Program Files (x86)\\Microsoft Visual Studio 14.0')
-        // If vs2015 is installed, fall back to vs2013 for now, until Gradle pulls in the right
-        // includes for the win10 sdk.
-        if (vs14Dir.exists()) {
-          def vs12Dir = file('C:\\Program Files (x86)\\Microsoft Visual Studio 12.0')
-          if (!vs12Dir.exists()) {
-            throw new GradleException('Compilation with VS 2015 is not currently supported by Gradle. Please install VS 2013, or use the CMake build option.')
-          }
-          installDir = vs12Dir
-        }
-      }
-    }
-  }
-  components {
-    gmock(NativeLibrarySpec) {
-      sources {
-        cpp {
-          source {
-            srcDirs = ['src', 'gtest/src']
-            includes = ['*-all.cc']
-          }
-          exportedHeaders {
-            srcDirs = ['include', 'gtest/include', '.', 'gtest']
-            includes = ['**/*.h', '**/*.cc']
-          }
-        }
-      }
-      binaries.all {
-        if (toolChain in VisualCpp) {
-          cppCompiler.args '-D_UNICODE', '-DUNICODE', '-DWIN32',  '-D_WIN32', '-DSTRICT', '-DWIN32_LEAN_AND_MEAN', '-D_HAS_EXCEPTIONS=1'
-        } else {
-          cppCompiler.args '-Wall', '-Wshadow', '-fexceptions', '-Wextra', '-Wno-unused-parameter', '-Wno-missing-field-initializers', '-lpthreads', '-fPIC'
-        }
-      }
-    }
-  }
+// Apply the correct toolchain settings for the target platform
+if (buildPlatform == 'arm') {
+    apply from: '../toolchains/arm.gradle'
+} else if (OperatingSystem.current().isLinux()) {
+    apply from: '../toolchains/linux.gradle'
+} else if (OperatingSystem.current().isMacOsX()) {
+    apply from: '../toolchains/mac.gradle'
+} else if (OperatingSystem.current().isWindows()) {
+    apply from: '../toolchains/windows.gradle'
+} else {
+    throw new GradleException("ntcore does not support building on ${OperatingSystem.current().getFamilyName()}.")
+}
+
+model {
+    platforms {
+        x86 {
+            architecture 'x86'
+            operatingSystem OperatingSystem.current().getFamilyName()
+        }
+        x64 {
+            architecture 'x86_64'
+            operatingSystem OperatingSystem.current().getFamilyName()
+        }
+    }
+    components {
+        gmock(NativeLibrarySpec) {
+            targetPlatform 'x86'
+            targetPlatform 'x64'
+            sources {
+                cpp {
+                    source {
+                        srcDirs = ['src', 'gtest/src']
+                        includes = ['*-all.cc']
+                    }
+                    exportedHeaders {
+                        srcDirs = ['include', 'gtest/include', '.', 'gtest']
+                        includes = ['**/*.h', '**/*.cc']
+                    }
+                }
+            }
+            binaries.all {
+                if (toolChain in VisualCpp) {
+                    cppCompiler.args '-D_UNICODE', '-DUNICODE', '-DWIN32',  '-D_WIN32', '-DSTRICT', '-DWIN32_LEAN_AND_MEAN', '-D_HAS_EXCEPTIONS=1'
+                } else {
+                    cppCompiler.args '-Wall', '-Wshadow', '-fexceptions', '-Wextra', '-Wno-unused-parameter', '-Wno-missing-field-initializers', '-lpthreads', '-fPIC'
+                }
+            }
+        }
+    }
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Sat Sep 19 10:44:07 EDT 2015
+#Sat Oct 31 11:10:48 EDT 2015
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.8-bin.zip

gradlew

@@ -42,11 +42,6 @@ case "`uname`" in
     ;;
 esac
 
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -114,6 +109,7 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`

java/java.gradle

@@ -0,0 +1,120 @@
+import org.gradle.internal.os.OperatingSystem
+
+apply plugin: 'java'
+
+def generatedJNIHeaderLoc = 'build/include'
+
+sourceSets {
+    main {
+        java {
+            srcDirs = ['java/src']
+        }
+    }
+}
+
+jar {
+    description = 'Generates NetworkTables jar, with the JNI shared libraries embedded'
+
+    if (buildPlatform == 'arm') {
+        dependsOn { ntcoreSharedLibrary }
+    } else {
+        dependsOn { x64NtcoreSharedLibrary }
+        dependsOn { x86NtcoreSharedLibrary }
+    }
+
+    dependsOn { classes }
+    binaries.withType(SharedLibraryBinary) { binary ->
+        from(file(binary.sharedLibraryFile)) {
+            into getPlatformPath(binary)
+        }
+    }
+}
+
+task networktablesJavaSource(type: Jar, dependsOn: classes) {
+    description = 'Generates the source jar for NetworkTables java'
+    group = 'WPILib'
+    classifier = 'source'
+    from sourceSets.main.allJava
+}
+
+task networktablesJavadoc(type: Jar, dependsOn: javadoc) {
+    description = 'Generates the javadoc jar for NetworkTables java'
+    group = 'WPILib'
+    classifier = 'javadoc'
+    from javadoc.destinationDir
+}
+
+/**
+ * Generates the JNI headers
+ */
+task jniHeadersNetworkTables {
+    description = 'Generates JNI headers from edu.wpi.first.wpilibj.networktables.*'
+    group = 'WPILib'
+    def outputFolder = file(generatedJNIHeaderLoc)
+    inputs.files sourceSets.main.output
+    outputs.file outputFolder
+    doLast {
+        outputFolder.mkdirs()
+        exec {
+            executable org.gradle.internal.jvm.Jvm.current().getExecutable('javah')
+            args '-d', outputFolder
+            args '-classpath', sourceSets.main.output.classesDir
+            args 'edu.wpi.first.wpilibj.networktables.NetworkTablesJNI'
+        }
+    }
+}
+
+clean {
+    delete generatedJNIHeaderLoc
+}
+
+compileJava {
+    options.compilerArgs << '-Xlint:unchecked'
+}
+
+javadoc {
+    options.addStringOption('Xdoclint:none', '-quiet')
+}
+
+// This creates a lambda that the main build.gradle can access, which sets up the JNI includes for the
+// target build platform. This lambda is exposed as a property in the main build.gradle.
+ext.setupJniIncludes = { binaries ->
+    def platformSpecificIncludeFlag = { loc, cppCompiler ->
+        if (OperatingSystem.current().isWindows()) {
+            cppCompiler.args "/I$loc"
+        } else {
+            cppCompiler.args '-I', loc
+        }
+    }
+    binaries.all {
+        tasks.withType(CppCompile) {
+            if (buildPlatform == 'arm') {
+                cppCompiler.args '-I', file('java/arm-linux').absolutePath
+                cppCompiler.args '-I', file('java/arm-linux/linux').absolutePath
+            } else {
+                def jdkLocation = org.gradle.internal.jvm.Jvm.current().javaHome
+                platformSpecificIncludeFlag("${jdkLocation}/include", cppCompiler)
+
+                if (targetPlatform.operatingSystem.macOsX) {
+                    platformSpecificIncludeFlag("${jdkLocation}/include/darwin", cppCompiler)
+                } else if (targetPlatform.operatingSystem.linux) {
+                    platformSpecificIncludeFlag("${jdkLocation}/include/linux", cppCompiler)
+                } else if (targetPlatform.operatingSystem.windows) {
+                    platformSpecificIncludeFlag("${jdkLocation}/include/win32", cppCompiler)
+                } else if (targetPlatform.operatingSystem.freeBSD) {
+                    platformSpecificIncludeFlag("${jdkLocation}/include/freebsd", cppCompiler)
+                }
+            }
+
+            jniHeadersNetworkTables.outputs.files.each { file ->
+                if (buildPlatform == 'arm') {
+                    cppCompiler.args '-I', file.getPath()
+                } else {
+                    platformSpecificIncludeFlag(file.getPath(), cppCompiler)
+                }
+            }
+
+            dependsOn jniHeadersNetworkTables
+        }
+    }
+}

publish.gradle

@@ -0,0 +1,50 @@
+import org.gradle.internal.os.OperatingSystem
+
+apply plugin: 'maven-publish'
+
+publishing {
+    publications {
+        if (!project.hasProperty('skipJava')) {
+            java(MavenPublication) {
+                artifact jar {
+                    // If we're building the regular ntcore for arm, it has no classifier. Otherwise, classify
+                    // the platform this jar is built for.
+                    classifier = buildPlatform
+                }
+                artifact (networktablesJavaSource) {
+                    classifier = 'sources'
+                }
+                artifact(networktablesJavadoc) {
+                    classifier = 'javadoc'
+                }
+
+                groupId 'edu.wpi.first.wpilib.networktables.java'
+                artifactId 'NetworkTables'
+                version '3.0.0-SNAPSHOT'
+            }
+        }
+        cpp(MavenPublication) {
+            artifact ntcoreZip {
+                classifier = buildPlatform
+            }
+
+            groupId 'edu.wpi.first.wpilib.networktables.cpp'
+            artifactId 'NetworkTables'
+            version '3.0.0-SNAPSHOT'
+        }
+    }
+
+    // If we want to publish to a specific repository on Jenkins, we specify it on the command line. The valid
+    // repository names are:
+    //     release
+    //     stable
+    //     beta
+    //     development
+    if (project.hasProperty('repo')) {
+        repositories {
+            maven {
+                url "${System.getProperty('user.home')}/releases/maven/$repo"
+            }
+        }
+    }
+}

settings.gradle

@@ -1 +1,2 @@
-include 'gmock', 'test'
+if (!hasProperty('armBuild'))
+    include 'gmock'

test/build.gradle

@@ -1,59 +0,0 @@
-import org.apache.tools.ant.taskdefs.condition.Os
-apply plugin: 'cpp'
-apply plugin: 'google-test'
-apply plugin: 'visual-studio'
-
-model {
-  toolChains {
-    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-      visualCpp(VisualCpp) {
-        def vs14Dir = file('C:\\Program Files (x86)\\Microsoft Visual Studio 14.0')
-        // If vs2015 is installed, fall back to vs2013 for now, until Gradle pulls in the right
-        // includes for the win10 sdk.
-        if (vs14Dir.exists()) {
-          def vs12Dir = file('C:\\Program Files (x86)\\Microsoft Visual Studio 12.0')
-          if (!vs12Dir.exists()) {
-            throw new GradleException('Compilation with VS 2015 is not currently supported by Gradle. Please install VS 2013, or use the CMake build option.')
-          }
-          installDir = vs12Dir
-        }
-      }
-    }
-  }
-  components {
-    tests(NativeLibrarySpec) {
-      sources {
-        cpp {
-          source {
-            srcDirs = ["unit", "../src"]
-            includes = ["**/*.cpp"]
-          }
-          exportedHeaders {
-            srcDirs = ["../include", "../src", "../gmock/include", "../gmock/gtest/include"]
-            includes = ["**/*.h"]
-          }
-        }
-      }
-      binaries.all {
-        lib project: ':gmock', library: "gmock", linkage: "static"
-        if (toolChain in Gcc) {
-          cppCompiler.args '-std=c++1y', '-Wformat=2', '-Wall', '-Wextra', '-Werror', '-pedantic', '-Wno-unused-parameter'
-          linker.args '-pthread'
-        }
-        if (toolChain in VisualCpp) {
-          cppCompiler.args '/EHsc', '/DNOMINMAX', '/D_SCL_SECURE_NO_WARNINGS', '/D_WINSOCK_DEPRECATED_NO_WARNINGS'
-        }
-      }
-    }
-  }
-}
-binaries.withType(GoogleTestTestSuiteBinarySpec) {
-  lib project: ':gmock', library: "gmock", linkage: "static"
-  if (targetPlatform.operatingSystem.linux) {
-    cppCompiler.args '-pthread', '-std=c++1y'
-    linker.args '-pthread'
-  } else {
-    cppCompiler.args '/EHsc', '/DNOMINMAX', '/D_SCL_SECURE_NO_WARNINGS', '/D_WINSOCK_DEPRECATED_NO_WARNINGS'
-  }
-}
-

test/tests.gradle

@@ -0,0 +1,45 @@
+apply plugin: 'google-test'
+task check() {}
+
+model {
+    testSuites {
+        ntcoreTest {
+            if (!project.hasProperty('skipJava')) {
+                setupJniIncludes(binaries)
+            }
+            sources {
+                cpp {
+                    source {
+                        srcDirs = ['test/unit']
+                        includes = ['**/*.cpp']
+                    }
+                    exportedHeaders {
+                        srcDirs = ['include', 'src', 'gmock/include', 'gmock/gtest/include']
+                        includes = ['**/*.h']
+                    }
+                }
+            }
+            binaries.all {
+                if (project.hasProperty('wpilib')) {
+                    lib project: ':ntcore:gmock', library: "gmock", linkage: "static"
+                } else {
+                    lib project: ':gmock', library: "gmock", linkage: "static"
+                }
+            }
+        }
+    }
+}
+
+binaries.withType(GoogleTestTestSuiteBinarySpec) {
+    if (project.hasProperty('wpilib')) {
+        lib project: ':ntcore:gmock', library: "gmock", linkage: "static"
+    } else {
+        lib project: ':gmock', library: "gmock", linkage: "static"
+    }
+    if (targetPlatform.operatingSystem.linux) {
+        cppCompiler.args '-pthread', '-std=c++1y'
+        linker.args '-pthread'
+    } else {
+        cppCompiler.args '/EHsc', '/DNOMINMAX', '/D_SCL_SECURE_NO_WARNINGS', '/D_WINSOCK_DEPRECATED_NO_WARNINGS'
+    }
+}

toolchains/arm.gradle

@@ -0,0 +1,66 @@
+def compilerPrefix = 'arm-frc-linux-gnueabi-'
+model {
+    toolChains {
+        gcc(Gcc) {
+            target("arm"){
+                // We use a custom-built cross compiler with the prefix arm-frc-linux-gnueabi-<util name>
+                // If this ever changes, the prefix will need to be changed here
+                cppCompiler.executable = compilerPrefix + cppCompiler.executable
+                linker.executable = compilerPrefix + linker.executable
+                assembler.executable = compilerPrefix + assembler.executable
+                // Gradle auto-adds the -m32 argument to the linker and compiler. Our compiler only supports
+                // arm, and doesn't understand this flag, so it is removed from both
+                cppCompiler.withArguments { args ->
+                    args << '-std=c++1y' << '-Wformat=2' << '-Wall' << '-Wextra' << '-Werror' << '-pedantic'
+                    args << '-Wno-psabi' << '-Wno-unused-parameter' << '-fPIC' << '-rdynamic'
+                    //TODO: When the compiler allows us to actually call deprecated functions from within
+                    // deprecated function, remove this line (this will cause calling deprecated functions
+                    // to be treated as a warning rather than an error).
+                    args << '-Wno-error=deprecated-declarations'
+                    args.remove('-m32')
+                }
+                linker.withArguments { args ->
+                    args << '-rdynamic'
+                    args.remove('-m32')
+                }
+                staticLibArchiver.executable = compilerPrefix + staticLibArchiver.executable
+            }
+        }
+    }
+}
+
+ext.setupReleaseDefines = { cppCompiler, linker ->
+    cppCompiler.args '-O2', '-g'
+}
+
+ext.setupDebugDefines = { cppCompiler, linker ->
+    cppCompiler.args '-g', '-O0'
+}
+
+ext.releaseSetup = { releaseTask ->
+    binaries.withType(SharedLibraryBinarySpec) { binary ->
+        if (!project.hasProperty('debug')) {
+            def library = binary.sharedLibraryFile.absolutePath
+            def debugLibrary = binary.sharedLibraryFile.absolutePath + ".debug"
+            if (project.tasks.findByName("firstObjcopy${binary.name}") == null) {
+                def firstObjcopy = project.tasks.create("firstObjcopy${binary.name}", Exec) { task ->
+                    task.commandLine "${compilerPrefix}objcopy", '--only-keep-debug', library, debugLibrary
+                }
+                def strip = project.tasks.create("strip${binary.name}", Exec) { task ->
+                    task.commandLine "${compilerPrefix}strip", '-g', library
+                }
+                def secondObjcopy = project.tasks.create("secondObjcopy${binary.name}", Exec) { task ->
+                    task.commandLine "${compilerPrefix}objcopy", "--add-gnu-debuglink=$debugLibrary", library
+                }
+                secondObjcopy.dependsOn strip
+                strip.dependsOn firstObjcopy
+                binary.tasks.whenObjectAdded { task ->
+                    if (task.name.contains('link')) {
+                        firstObjcopy.dependsOn task
+                    }
+                }
+            }
+            releaseTask.dependsOn project.tasks.getByName("secondObjcopy${binary.name}")
+        }
+    }
+}

toolchains/linux.gradle

@@ -0,0 +1,70 @@
+model {
+    toolChains {
+        gcc(Gcc) {
+            target('x86') {
+                cppCompiler.withArguments { args ->
+                    args << '-std=c++11' << '-Wformat=2' << '-Wall' << '-Wextra' << '-Werror' << '-pedantic'
+                    args << '-Wno-psabi' << '-Wno-unused-parameter' << '-fPIC' << '-rdynamic'
+                    //TODO: When the compiler allows us to actually call deprecated functions from within
+                    // deprecated function, remove this line (this will cause calling deprecated functions
+                    // to be treated as a warning rather than an error).
+                    args << '-Wno-error=deprecated-declarations'
+                    args << '-m32'
+                }
+                linker.withArguments { args ->
+                    args << '-rdynamic'
+                    args << '-m32'
+                }
+            }
+            target('x64') {
+                cppCompiler.withArguments { args ->
+                    args << '-std=c++11' << '-Wformat=2' << '-Wall' << '-Wextra' << '-Werror' << '-pedantic'
+                    args << '-Wno-psabi' << '-Wno-unused-parameter' << '-fPIC' << '-rdynamic'
+                    //TODO: When the compiler allows us to actually call deprecated functions from within
+                    // deprecated function, remove this line (this will cause calling deprecated functions
+                    // to be treated as a warning rather than an error).
+                    args << '-Wno-error=deprecated-declarations'
+                }
+                linker.withArguments { args ->
+                    args << '-rdynamic'
+                }
+            }
+        }
+    }
+}
+
+ext.setupReleaseDefines = { cppCompiler, linker ->
+    cppCompiler.args '-O2', '-g'
+}
+
+ext.setupDebugDefines = { cppCompiler, linker ->
+    cppCompiler.args '-g', '-O0'
+}
+
+ext.releaseSetup = { releaseTask ->
+    binaries.withType(SharedLibraryBinarySpec) { binary ->
+        if (!project.hasProperty('debug')) {
+            def library = binary.sharedLibraryFile.absolutePath
+            def debugLibrary = binary.sharedLibraryFile.absolutePath + ".debug"
+            if (project.tasks.findByName("firstObjcopy${binary.name}") == null) {
+                def firstObjcopy = project.tasks.create("firstObjcopy${binary.name}", Exec) { task ->
+                    task.commandLine 'objcopy', '--only-keep-debug', library, debugLibrary
+                }
+                def strip = project.tasks.create("strip${binary.name}", Exec) { task ->
+                    task.commandLine 'strip', '-g', library
+                }
+                def secondObjcopy = project.tasks.create("secondObjcopy${binary.name}", Exec) { task ->
+                    task.commandLine 'objcopy', "--add-gnu-debuglink=$debugLibrary", library
+                }
+                secondObjcopy.dependsOn strip
+                strip.dependsOn firstObjcopy
+                binary.tasks.whenObjectAdded { task ->
+                    if (task.name.contains('link')) {
+                        firstObjcopy.dependsOn task
+                    }
+                }
+            }
+            releaseTask.dependsOn project.tasks.getByName("secondObjcopy${binary.name}")
+        }
+    }
+}

toolchains/mac.gradle

@@ -0,0 +1,57 @@
+model {
+    toolChains {
+        clang(Clang) {
+            target('x86') {
+                cppCompiler.withArguments { args ->
+                    args << '-std=c++11' << '-Wall' << '-Wextra' << '-Werror' << '-pedantic-errors'
+                    args << '-Wno-unused-parameter' << '-fPIC' << '-m32'
+                }
+                linker.withArguments { args ->
+                    args << '-m32'
+                }
+            }
+            target('x64') {
+                cppCompiler.withArguments { args ->
+                    args << '-std=c++11' << '-Wall' << '-Wextra' << '-Werror' << '-pedantic-errors'
+                    args << '-Wno-unused-parameter' << '-fPIC'
+                }
+            }
+        }
+    }
+}
+
+ext.setupReleaseDefines = { cppCompiler, linker ->
+    cppCompiler.args '-O2'
+}
+
+ext.setupDebugDefines = { cppCompiler, linker ->
+    cppCompiler.args '-g', '-O0'
+}
+
+ext.releaseSetup = { releaseTask ->
+    binaries.withType(SharedLibraryBinarySpec) { binary ->
+        if (!project.hasProperty('debug')) {
+            def library = binary.sharedLibraryFile.absolutePath
+            def debugLibrary = binary.sharedLibraryFile.absolutePath + ".debug"
+            if (project.tasks.findByName("firstObjcopy${binary.name}") == null) {
+                def firstObjcopy = project.tasks.create("firstObjcopy${binary.name}", Exec) { task ->
+                    task.commandLine 'objcopy', '--only-keep-debug', library, debugLibrary
+                }
+                def strip = project.tasks.create("strip${binary.name}", Exec) { task ->
+                    task.commandLine 'strip', '-g', library
+                }
+                def secondObjcopy = project.tasks.create("secondObjcopy${binary.name}", Exec) { task ->
+                    task.commandLine 'objcopy', "--add-gnu-debuglink=$debugLibrary", library
+                }
+                secondObjcopy.dependsOn strip
+                strip.dependsOn firstObjcopy
+                binary.tasks.whenObjectAdded { task ->
+                    if (task.name.contains('link')) {
+                        firstObjcopy.dependsOn task
+                    }
+                }
+            }
+            releaseTask.dependsOn project.tasks.getByName("secondObjcopy${binary.name}")
+        }
+    }
+}

toolchains/windows.gradle

@@ -0,0 +1,49 @@
+model {
+    toolChains {
+        visualCpp(VisualCpp) {
+            // Workaround for VS2015 adapted from https://github.com/couchbase/couchbase-lite-java-native/issues/23
+            def VS_2015_INCLUDE_DIR = "C:/Program Files (x86)/Windows Kits/10/Include/10.0.10240.0/ucrt"
+            def VS_2015_LIB_DIR = "C:/Program Files (x86)/Windows Kits/10/Lib/10.0.10240.0/ucrt"
+            def VS_2015_INSTALL_DIR = 'C:/Program Files (x86)/Microsoft Visual Studio 14.0'
+            def vsInstallDir = file(VS_2015_INSTALL_DIR)
+
+            // If you ever happen to install and uninstall any other version of VS, Gradle will misdetect the compiler
+            // and linker to run. This fixes that by manually setting the install dir
+            if (vsInstallDir.exists()) {
+                installDir = vsInstallDir
+            }
+
+            eachPlatform {
+                cppCompiler.withArguments { args ->
+                    args << '/EHsc' << '/DNOMINMAX' << '/D_SCL_SECURE_NO_WARNINGS' << '/D_WINSOCK_DEPRECATED_NO_WARNINGS'
+                    if (file(VS_2015_INCLUDE_DIR).exists()) {
+                        args << "/I$VS_2015_INCLUDE_DIR"
+                    }
+                }
+                linker.withArguments { args ->
+                    if (file(VS_2015_LIB_DIR).exists()) {
+                        if (platform.architecture.name == 'x86') {
+                            args << "/LIBPATH:$VS_2015_LIB_DIR/x86"
+                        } else {
+                            args << "/LIBPATH:$VS_2015_LIB_DIR/x64"
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+ext.setupReleaseDefines = { cppCompiler, linker ->
+    cppCompiler.args '/O2', '/Zi', '/FS'
+    linker.args '/DEF:ntcore.def'
+}
+
+ext.setupDebugDefines = { cppCompiler, linker ->
+    cppCompiler.args '/Zi', '/FS'
+    linker.args '/DEBUG', '/DEF:ntcore.def'
+}
+
+// This is a noop on Windows. On gcc platforms, we strip the release binary and create a separate
+// debug library, but Windows already separates debug symbols into a .pdb file.
+ext.releaseSetup = {}