forked from NationalSecurityAgency/ghidra
-
-
Notifications
You must be signed in to change notification settings - Fork 2
/
build.gradle
292 lines (252 loc) · 10.6 KB
/
build.gradle
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
/* ###
* IP: GHIDRA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
apply plugin: 'eclipse'
apply from: 'gradle/root/eclipse.gradle'
apply from: "gradle/support/eclipseLauncher.gradle"
apply from: "gradle/support/loadApplicationProperties.gradle"
/***************************************************************************************
* Make sure the correct version of gradle is being used
***************************************************************************************/
import org.gradle.util.GradleVersion;
final GradleVersion minimum_version = GradleVersion.version("${rootProject.GRADLE_MINIMUM_VERSION}")
if (GradleVersion.current() < minimum_version) {
throw new GradleException("Requires at least $minimum_version, 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'}"
}
/***************************************************************************************
* Make sure Gradle wasn't launched with a 32-bit Java...it can cause confusing errors
***************************************************************************************/
if ("32".equals(System.getProperty("sun.arch.data.model"))) {
throw new GradleException("\n\n\t32-bit Java detected! Please use 64-bit Java.\n\n");
}
/*********************************************************************************
* Define the location of bin repo
*********************************************************************************/
project.ext.GHIDRA_GROUP = "Z Ghidra"
project.ext.ROOT_PROJECT_DIR = projectDir.absolutePath
project.ext.BIN_REPO = file("${projectDir}/../ghidra.bin").absolutePath
project.ext.DEPS_DIR = file("${projectDir}/dependencies")
/*********************************************************************************
* Prevent forked Java processes from stealing focus
*********************************************************************************/
allprojects {
tasks.withType(JavaForkOptions) {
jvmArgs '-Djava.awt.headless=true'
}
}
/*********************************************************************************
* Use flat directory-style repository if flatRepo directory is present.
*********************************************************************************/
def flatRepo = file("${DEPS_DIR}/flatRepo")
if (flatRepo.isDirectory()) {
allprojects {
repositories {
mavenLocal()
mavenCentral()
jcenter()
flatDir name: "flat", dirs:["$flatRepo"]
}
}
}
else {
File f = file("ghidra.repos.config")
if (!f.exists()) {
throw new GradleException("\n\n\n\tUnable to find the local maven repo." +
" Ensure you have created the ${flatRepo.getName()} directory or ${f.getName()} file.\n\n\n");
}
}
/*********************************************************************************
* 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: "GPL/utils.gradle" // adds utilities used in both Ghidra and GPL projects
apply from: "GPL/nativePlatforms.gradle" // adds native platform support
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 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 a list of all the external library paths declared as dependencies for the
* given project
*
*********************************************************************************/
List<String> getExternalRuntimeDependencies(Project project) {
List<String> list = new ArrayList<String>()
if (project.configurations.find { it.name == 'api' }) {
list.addAll(getExternalRuntimeDependencies(project, project.configurations.api));
}
if (project.configurations.find { it.name == 'implementation' }) {
list.addAll(getExternalRuntimeDependencies(project, project.configurations.implementation));
}
if (project.configurations.find { it.name == 'runtimeOnly' }) {
list.addAll(getExternalRuntimeDependencies(project, project.configurations.runtimeOnly));
}
return list
}
List<String> getExternalRuntimeDependencies(Project project, Configuration configuration) {
List<String> list = new ArrayList<>();
configuration.dependencies.each { dep ->
// if the dependency is an external jar
if (dep instanceof ExternalDependency) {
String name = dep.getName()
Set<String> classifiers = dep.artifacts.classifier
String group = dep.getGroup()
String version = dep.getVersion()
String searchString = name
if (version != null) {
searchString = name+"-"+version;
}
if (!classifiers.empty) {
String cls = classifiers.first()
if (cls != null) {
searchString+= "-$cls"
}
}
// search for the dependency in the runtime class path
String depPath = project.configurations.runtimeClasspath.find {
it.name.contains(searchString)
}
if (depPath == null) {
println("****************DID NOT FIND DEPENDENCY: name = "+name+" version = "+version)
}
// if we found the path, then add it to the list
if (depPath) {
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 = getExternalRuntimeDependencies(p);
if (libs != null) {
out.println "Module: $p.name"
libs.each { path ->
out.println "\t$path"
}
}
}
}
}
return libsFile.absolutePath
}
task allSleighCompile {
}