build.gradle

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

plugins {
    id "java"
}

sourceSets {
    test {
        java {
            srcDirs = ['test/jtreg', file("test/jtreg/generator").listFiles(), 'test/lib', 'test/testng']
            // exclude all test files from compilation. Jtreg compiles these for us when tests run
            exclude "**/*"
        }
    }
}

dependencies {
    // add jtreg jars as dependencies of tests
    testImplementation fileTree(dir: findProperty("jtreg_home") + "/lib/", include: "*.jar")
}

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 = "22"
def jmods_dir = "$buildDir/jmods"
def jextract_jmod_file = "$jmods_dir/org.openjdk.jextract.jmod"
def jextract_jmod_inputs = "$buildDir/jmod_inputs"
def jextract_app_dir = "$buildDir/jextract"
def jextract_runtime_dir = "$jextract_app_dir/runtime"
def jextract_bin_dir = "$jextract_app_dir/bin"
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 = 22
    options.compilerArgs << "--enable-preview"
    options.fork = true
    options.forkOptions.executable = "${jdk22_home}/bin/javac"
}

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

task copyLibClang(type: Sync) {
    into("$buildDir/jmod_inputs")

    from("${libclang_dir}") {
        include("*clang.*")
        include("libLLVM.*")
        exclude("clang.exe")
        into("libs")
    }

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

task createJextractJmod(type: Exec) {
    dependsOn jar, copyLibClang

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

    doFirst {
        delete(jextract_jmod_file)
    }

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

task createJextractImage(type: Exec) {
    dependsOn createJextractJmod

    // if these inputs or outputs change, gradle will rerun the task
    inputs.file("$jextract_jmod_file")
    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)
        project.mkdir "${jextract_bin_dir}"
    }

    executable = "${jdk22_home}/bin/jlink"
    args = [
         "--module-path=$jmods_dir",
         "--add-modules=org.openjdk.jextract",
         "--output=${jextract_runtime_dir}",
         "--strip-debug", "--no-man-pages", "--no-header-files",
         "--add-options",
         "${quote_jlink_opts}"
    ]

    doLast {
        // Add launcher scripts
        Path unixOut = Path.of("${jextract_bin_dir}/jextract");
        Files.copy(Path.of("$projectDir/src/main/jextract"), unixOut);
        if (unixOut.getFileSystem().supportedFileAttributeViews().contains("posix")) {
            Set<PosixFilePermission> perms = Files.getPosixFilePermissions(unixOut);
            perms.add(PosixFilePermission.OWNER_EXECUTE);
            perms.add(PosixFilePermission.GROUP_EXECUTE);
            perms.add(PosixFilePermission.OTHERS_EXECUTE);
            Files.setPosixFilePermissions(unixOut, perms);
        }

        Files.copy(Path.of("$projectDir/src/main/jextract.bat"), Path.of("${jextract_bin_dir}/jextract.bat"))
    }
}

// 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_bin_dir}/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 createJextractJmod

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

    // if these inputs or outputs change, gradle will rerun the task
    inputs.file("$jextract_jmod_file")
    outputs.dir(out_dir)

    doFirst {
        delete(out_dir)
    }

    executable = "${jdk22_home}/bin/jlink"
    args = [
         "--module-path=$jmods_dir" + File.pathSeparator + "$jdk22_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"
    ]
}

void createJtregTask(String name, boolean coverage, String os_lib_dir) {
    tasks.register(name, JavaExec) {
        dependsOn createRuntimeImageForTest,cmakeBuild

        if (findProperty("jtreg_home") == null) {
            throw new GradleException("jtreg_home is not defined")
        }
        // e.g.: <jacoco repo>/org.jacoco.agent/target/classes/jacocoagent.jar
        if (coverage && findProperty("jacoco_agent") == null) {
            throw new GradleException("jacoco_agent 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,fail,error",
                "-retain:fail,error",
        ]

        if (coverage) {
            String jacocoAgent = findProperty("jacoco_agent")
            String coverageFile = "$buildDir/jacoco-run/jextract.exec"
            String includes = "org.openjdk.jextract.*"
            args += "-javaoption:-javaagent:$jacocoAgent=destfile=$coverageFile,includes=$includes"
        }

        args += "../test"
    }
}

createJtregTask("jtreg", false, os_lib_dir)
createJtregTask("jtregWithCoverage", true, os_lib_dir)

tasks.register("coverage", JavaExec) {
    dependsOn jtregWithCoverage

    // e.g.: <jacoco repo>/org.jacoco.cli/target/org.jacoco.cli-0.8.12-SNAPSHOT-nodeps.jar
    if (findProperty("jacoco_cli") == null) {
        throw new GradleException("jacoco_cli is not defined")
    }

    classpath = files(findProperty("jacoco_cli"))

    args = [
            "report",
            "$buildDir/jacoco-run/jextract.exec",
            "--classfiles", "$buildDir/classes/java/main",
            "--sourcefiles", "$projectDir/src/main/java",
            "--html", "$buildDir/jacoco-report"
    ]
}