ghidra/build.gradle
2019-04-23 15:20:26 -04:00

322 lines
12 KiB
Groovy

apply plugin: 'eclipse'
apply from: 'gradle/root/eclipse.gradle'
apply from: "gradle/support/eclipseLauncher.gradle"
/***************************************************************************************
* Make sure the correct version of gradle is being used
***************************************************************************************/
if (gradle.gradleVersion != "5.0") {
throw new GradleException("Requires Gradle 5.0, but was run with $gradle.gradleVersion")
}
/***************************************************************************************
* Define the location of JAVA_HOME
***************************************************************************************/
if (System.env.JAVA_HOME) {
// Allow Gradle's default JAVA_HOME to be overridden by an environment variable we set
project.ext.JAVA_HOME = System.env.JAVA_HOME;
}
else {
project.ext.JAVA_HOME = "${System.properties.'java.home'}/../"
}
/*********************************************************************************
* Define the location of bin repo
*********************************************************************************/
project.ext.GHIDRA_GROUP = "Z Ghidra"
project.ext.BIN_REPO = file("${projectDir}/../ghidra.bin").absolutePath
project.ext.ROOT_PROJECT_DIR = projectDir.absolutePath
project.ext.BIN_REPO_PATH = BIN_REPO // TODO make path names consistent
/*********************************************************************************
* Prevent forked Java processes from stealing focus
*********************************************************************************/
allprojects {
tasks.withType(JavaForkOptions) {
jvmArgs '-Djava.awt.headless=true'
}
}
/*********************************************************************************
* load properties from Ghidra/application.properties file
*********************************************************************************/
apply from: "gradle/support/loadApplicationProperties.gradle"
/****************************************************************************
* Create a set containing all the platforms we need when building native
* artifacts. This is here for convenience and can be used in a build file
* with the following syntax:
*
* project.OS_NAMES.each {...}
****************************************************************************/
project.ext.set("OS_NAMES", ["osx64", "win32", "win64", "linux64"])
/*********************************************************************************
* Imports
* For these tasks to be available on all subprojects, this MUST be placed
* after the "setupJava" configuration.
*
* Note: Distribution.gradle and distributionNew.gradle must not be applied at the
* same time; they have tasks with the same name. The former is the 'old' way
* of building (produces several zips) while the former produces only one.
* Eventually distribution.gradle will be removed entirely, but it is included
* here for the time being for those who need it.
*********************************************************************************/
apply from: "gradle/root/test.gradle" // adds tasks for running tests
apply from: "gradle/root/prepDev.gradle" // adds prepDev task for each subproject
apply from: 'gradle/root/distribution.gradle' // adds zip tasks
apply from: 'gradle/root/usage.gradle' // adds task documentation
apply from: "gradle/root/svg.gradle" // adds task to process svg files
apply from: "gradle/root/jacoco.gradle" // adds tasks for java code coverage
apply plugin: 'base'
clean {
delete "$buildDir"
}
/******************************************************************************************
*
* Utility methods used by multiple build.gradle files
*
*****************************************************************************************/
/*********************************************************************************
* Returns true if the platform is a linux machine.
*********************************************************************************/
def isLinux(String platformName) {
return platformName.startsWith("linux")
}
/*********************************************************************************
* Returns true if the platform is a mac
*********************************************************************************/
def isMac(String platformName) {
return platformName.startsWith("osx")
}
/*********************************************************************************
* Returns true if the platform is a Windows machine.
*********************************************************************************/
def isWindows(String platformName) {
return platformName.startsWith("win")
}
/******************************************************************************************
* Helper method that returns a file that is the same relative location in the bin repo
* as the given project is in its repo.
******************************************************************************************/
File getProjectLocationInBinRepo(Project p) {
String relativePath = getGhidraRelativePath(p)
File binRepoRootProject = new File("${BIN_REPO}")
return new File(binRepoRootProject, relativePath)
}
/****************************************************************************************
* Returns the "effective" relative path (Path starting with Ghidra)
* Normally, for files in the ghidra repo this is just the relative path from
* the root project (ghidra) to the given project.
*
* For example <...>/ghidra/Ghidra/Features/Base will return Ghidra/Features/Base
*
* If the project is in a sibling repo (ghidra.<other> that lives in the same directory
* as ghidra), then this method returns a relative path as though the project lived
* in ghidra.
*
* for example <...>/ghidra.foo/Ghidra/Features/OtherProject will return Ghidra/Features/OtherProject
****************************************************************************************/
String getGhidraRelativePath(Project p) {
String path = rootProject.relativePath(p.projectDir)
// If the project lives outside the ghidra repo, then its relative path will
// start with "../". In this case, we want to remove the "../" and the next path element
// so that the path will appear as though the project lived under the ghidra repo.
// example: "../ghidra/Ghidra/Features/Foo" will get changed to "Ghidra/Features/Foo"
String prefix = ".."+File.separator
if (path.startsWith(prefix)) {
int index = path.indexOf(File.separator,3)
path = path.substring(index+1)
}
return path
}
/*********************************************************************************
* Returns a relative path from the root (ghidra) to the project's directory.
* This is used to determine where inside a zip file to place a particular artifact
* (we want them to all start at "Ghidra/...."
*
* ie: If we have the following:
* project dir = /Users/<blah>/git/ghidra.master/ghidra/Ghidra/Features/Base
* root project = /Users/<blah>/git/ghidra.master/ghidra/Ghidra
*
* Then the returned value will be:
* Ghidra/Features/Base
*
* There are two special cases - Projects that live outside ghidra and projects
* that are extension projects. Projects that live outside ghidra will
* have zip paths that make the project appear as if it did live in ghidra.
* Projects that extend other projects will appear as though they live in the project
* that they extend. See the note at the top of the distribution.gradle file for more details.
*********************************************************************************/
def getZipPath(Project p) {
String path = getGhidraRelativePath(p)
// if the project has been defined as an "extension" to another project, change its
// zip path to the path of its "base" project. A project is an extension if it has
// defined an "extendsFromProject" property.
if (p.hasProperty('extendsFromProject')) {
Project baseProject = p.extendsFromProject
path = getGhidraRelativePath(baseProject);
}
if (p.hasProperty("pathExtension")) {
path = path + "/" + p.pathExtension
}
return path
}
def getBaseProjectName(Project p) {
if (p.hasProperty('extendsFromProject')) {
Project baseProject = p.extendsFromProject
return baseProject.name
}
return p.name
}
/*********************************************************************************
* Returns the current date formatted as yyyyMMdd.
*********************************************************************************/
def getCurrentDate() {
def date = new Date()
def formattedDate = date.format('yyyyMMdd')
return formattedDate
}
/*********************************************************************************
* Returns the current date/time formatted as yyyyMMdd-HHmm.
*********************************************************************************/
def getCurrentDateTime() {
def date = new Date()
def formattedDate = date.format('yyyyMMdd-HHmm')
return formattedDate
}
/*********************************************************************************
* Returns the current date/time formatted as yyyy-MMM-dd HHmm z.
*********************************************************************************/
def getCurrentDateTimeLong() {
def date = new Date()
def formattedDate = date.format('yyyy-MMM-dd HHmm z')
return formattedDate
}
/*********************************************************************************
* Returns the local platform name.
*********************************************************************************/
String getCurrentPlatformName() {
String osName = System.getProperty("os.name")
String archName = System.getProperty("os.arch")
boolean isX86_32 = archName.equals("x86") || archName.equals("i386");
boolean isX86_64 = archName.equals("x86_64") || archName.equals("amd64");
if (osName.startsWith("Windows")) {
if (isX86_32) {
return 'win32'
}
else if (isX86_64) {
return 'win64'
}
}
else if (osName.startsWith("Linux")) {
if (isX86_64) {
return 'linux64'
}
}
else if (osName.startsWith("Mac OS X")) {
if (isX86_64) {
return 'osx64'
}
}
throw new GradleException("Unrecognized current platform -> osName = $osName, archName = $archName")
}
/*********************************************************************************
* Returns a list of all the external library paths declared as dependencies for the
* given project
*
*********************************************************************************/
List<String> getExternalDependencies(Project project) {
List<String> list = new ArrayList<String>()
// for each dependency in the compile configuration
Configuration runtimeConfig = project.configurations.runtime
runtimeConfig.allDependencies.each { dep ->
// if the dependency is an external jar
if (dep.class.toString().contains("DefaultExternalModuleDependency")) {
// loop back through all the dependency files, looking for one that contains the dependency name.
String depPath = runtimeConfig.find {
it.name.contains(dep.name)
}
// if we found the path, then add it to the list
if (depPath && !depPath.contains("libsForBuild")) {
list.add(depPath)
}
}
}
return list
}
/******************************************************************************************
*
* Creates a file that lists the libraries used by each module.
*
******************************************************************************************/
String generateLibraryDependencyMapping() {
File libsFile = file("$buildDir/libraryDependencies.txt")
// Check to make sure the build folder exists - if it doesn't, the 'libsFile.withWriter'
// call (below) will fail miserably.
def buildFolder = file ("$buildDir")
if (!buildFolder.exists()) {
buildFolder.mkdirs()
}
libsFile.withWriter { out ->
subprojects { p ->
p.plugins.withType(JavaPlugin) {
List<String> libs = getExternalDependencies(p);
if (libs != null) {
out.println "Module: $p.name"
libs.each { path ->
out.println "\t$path"
}
}
}
}
}
return libsFile.absolutePath
}
task allSleighCompile {
}