build.gradle

import org.apache.tools.ant.taskdefs.condition.Os
import java.nio.file.Files;
import java.nio.file.Path;

plugins {
    id "java"
}

def static checkPath(String p) {
    if (!Files.exists(Path.of(p))) {
        throw new IllegalArgumentException("Error: the path ${p} does not exist");
    }
}

def llvm_home = project.property("llvm_home")
checkPath(llvm_home)
checkPath("${llvm_home}/lib/clang")
def clang_versions = new File("${llvm_home}/lib/clang/").list();
if (clang_versions.length == 0) {
    throw new IllegalArgumentException("Could not detect clang version." +
            " Make sure a ${llvm_home}/lib/clang/<VERSION> directory exists")
}
def clang_version = clang_versions[0]

def jextract_version = "19"
def jmods_dir = "$buildDir/jmods"
def jextract_jmod_file = "$jmods_dir/org.openjdk.jextract.jmod"
def jextract_jmod_libs_dir = "$buildDir/jextract_jmod_libs"
def jextract_jmod_conf_dir = "$buildDir/jextract_jmod_conf";
def jextract_app_dir = "$buildDir/jextract"
def clang_include_dir = "${llvm_home}/lib/clang/${clang_version}/include"
checkPath(clang_include_dir)
def os_lib_dir = Os.isFamily(Os.FAMILY_WINDOWS)? "bin" : "lib"
def os_script_extension = Os.isFamily(Os.FAMILY_WINDOWS)? ".bat" : ""
def libclang_dir = "${llvm_home}/${os_lib_dir}"
checkPath(libclang_dir)

repositories {
    mavenCentral()
}

compileJava {
    options.release = 19
    options.compilerArgs << "--enable-preview"
    options.fork = true
    options.forkOptions.executable = "${jdk19_home}/bin/javac"
}

jar {
    archiveBaseName = 'org.openjdk.jextract'
    archiveVersion = project.version
}

task copyLibClang(type: Copy) {
    dependsOn jar

    def dir_prefix_len = "$buildDir".length()
    def libs_dir = jextract_jmod_libs_dir.substring(dir_prefix_len)
    def conf_dir = jextract_jmod_conf_dir.substring(dir_prefix_len)

    into("$buildDir")

    from("${libclang_dir}") {
        include("*clang.*")
        include("libLLVM.*")
        into(libs_dir)
    }

    from("$clang_include_dir") {
        include("*.h")
        into(conf_dir + "/jextract")
    }
}

task createJextractJmod(type: Exec) {
    dependsOn copyLibClang

    // if these inputs or outputs change, gradle will rerun the task
    inputs.file(jar.archiveFile.get())
    outputs.file(jextract_jmod_file)

    doFirst {
        delete(jextract_jmod_file)
    }

    executable = "${jdk19_home}/bin/jmod"
    args = [
          "create",
          "--module-version=$jextract_version",
          "--class-path=" + jar.archiveFile.get(),
          "--libs=$jextract_jmod_libs_dir",
          "--conf=$jextract_jmod_conf_dir",
          "${jextract_jmod_file}"
    ]
}

task createJextractImage(type: Exec) {
    dependsOn createJextractJmod

    // if these inputs or outputs change, gradle will rerun the task
    inputs.file(jar.archiveFile.get())
    outputs.dir(jextract_app_dir)

    def quote_jlink_opts = Os.isFamily(Os.FAMILY_WINDOWS)?
        '\\"--enable-native-access=org.openjdk.jextract\\" \\"--enable-preview\""' :
        '"--enable-native-access=org.openjdk.jextract" "--enable-preview"'

    doFirst {
        delete(jextract_app_dir)
    }

    executable = "${jdk19_home}/bin/jlink"
    args = [
         "--module-path=$jmods_dir",
         "--add-modules=org.openjdk.jextract,jdk.compiler,jdk.zipfs",
         "--output=${jextract_app_dir}",
         "--launcher=jextract=org.openjdk.jextract/org.openjdk.jextract.JextractTool",
         "--add-options",
         "${quote_jlink_opts}"
    ]
}

// build the jextract image when the build or assemble task is run
assemble.dependsOn(createJextractImage)

// very simple integration test for generated jextract
task verify(type: Exec) {
    dependsOn createJextractImage

    executable = "${jextract_app_dir}/bin/jextract${os_script_extension}"
    args = [ "test.h", "--output", "$buildDir/integration_test" ]
}

// jlink a JDK image with org.openjdk.jextract for testing
task createRuntimeImageForTest(type: Exec) {
    dependsOn verify

    def out_dir = "$buildDir/jextract-jdk-test-image"

    // if these inputs or outputs change, gradle will rerun the task
    inputs.file(jar.archiveFile.get())
    outputs.dir(out_dir)

    doFirst {
        delete(out_dir)
    }

    executable = "${jdk19_home}/bin/jlink"
    args = [
         "--module-path=$jmods_dir" + File.pathSeparator + "$jdk19_home/jmods",
         "--add-modules=ALL-MODULE-PATH",
         "--output=$out_dir",
    ]
}

task cmakeConfigure(type: Exec) {
    executable = "cmake"
    args = [
        "-B", "$buildDir/testlib-build",
        "-S", "$projectDir/test/test-support",
        "-DTEST_SOURCE_ROOT:FILEPATH=$projectDir/test",
        "-DCMAKE_BUILD_TYPE:STRING=Release",
        "-DCMAKE_INSTALL_PREFIX:FILEPATH=$buildDir/testlib-install"
    ]
}

task cmakeBuild(type: Exec) {
    dependsOn cmakeConfigure

    executable = "cmake"
    args = [
        "--build", "$buildDir/testlib-build",
        "--config", "Release",
        "--target", "install"
    ]
}

// run jtreg tests. Note: needs jtreg_home variable set to point to the jtreg
task jtreg(type: JavaExec) {
    dependsOn createRuntimeImageForTest,cmakeBuild

    doFirst {
        if (findProperty("jtreg_home") == null) {
            throw new GradleException("jtreg_home is not defined")
        }
    }

    workingDir = "$buildDir"

    classpath = files(findProperty("jtreg_home") + "/lib/jtreg.jar")

    args = [
            "-jdk", "$buildDir/jextract-jdk-test-image",
            "-nativepath:$buildDir/testlib-install/${os_lib_dir}",
            "-javaoption:--enable-preview",
            "-javaoption:--enable-native-access=org.openjdk.jextract,ALL-UNNAMED",
            "-avm", "-conc:auto", "-verbose:summary",
            "../test"
    ]
}