mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-10-06 06:21:16 +07:00
606 lines
18 KiB
Plaintext
606 lines
18 KiB
Plaintext
import org.jetbrains.jps.Jps
|
|
import org.jetbrains.jps.LayoutInfo
|
|
import org.jetbrains.jps.Module
|
|
import static org.jetbrains.jps.idea.IdeaProjectLoader.guessHome
|
|
|
|
includeTargets << new File("${guessHome(this as Script)}/community/build/scripts/utils.gant")
|
|
includeTargets << new File("${guessHome(this)}/build/scripts/libLicenses.gant")
|
|
includeTargets << new File("${guessHome(this)}/python/build/python_common.gant")
|
|
includeTool << Jps
|
|
|
|
requireProperty("buildNumber", requireProperty("build.number", snapshot))
|
|
|
|
// load ApplicationInfo.xml properties
|
|
ant.xmlproperty(file: "$home/python/resources/idea/PythonApplicationInfo.xml", collapseAttributes: "true")
|
|
|
|
setProperty("system_selector", "PyCharm${p("component.version.major")}0")
|
|
|
|
setProperty("ch", "$home/community")
|
|
setProperty("dryRun", false)
|
|
setProperty("jdk16", guessJdk())
|
|
|
|
setProperty("pluginFilter", [
|
|
"htmltools",
|
|
"JavaScriptLanguage",
|
|
"JavaScriptDebugger", "FirefoxConnector", "ChromeConnector", "python-javascript-debugger",
|
|
"cvsIntegration", "cvs-core", "cvs-plugin", "javacvs-src", "smartcvs-src",
|
|
"PerforceIntegration", "Perforce", "perforce_util",
|
|
"svn4ideaOld",
|
|
"git4idea",
|
|
"CSS", "css-api",
|
|
"JSInspections",
|
|
"JSIntentionPowerPack",
|
|
"less", "sass",
|
|
"haml", "haml-plugin",
|
|
"hg4idea",
|
|
"tasks", "tasks-core", "tasks-api", "jira-connector",
|
|
"github",
|
|
"webDeployment",
|
|
"jdbc-console", "django-db-config",
|
|
"database-impl", "DatabaseSupport",
|
|
"sql",
|
|
"coffeescript"
|
|
])
|
|
|
|
private List platformImplementationModules() {
|
|
return [
|
|
"core-impl",
|
|
"RegExpSupport",
|
|
"license_common",
|
|
"platform-ultimate",
|
|
"platform-impl",
|
|
"vcs-impl",
|
|
"lang-impl",
|
|
"testRunner",
|
|
"smRunner",
|
|
"xdebugger-impl",
|
|
"xml",
|
|
"relaxng",
|
|
"lvcs-impl",
|
|
"images",
|
|
"spellchecker",
|
|
"dom-impl",
|
|
"yaml",
|
|
"coverage-impl"
|
|
]
|
|
}
|
|
|
|
private List<String> platformApiModules() {
|
|
return ["core-api", "platform-api", "lvcs-api", "lang-api", "vcs-api", "usageView", "xdebugger-api", "xml-openapi", "dom-openapi", "webide-api"]
|
|
}
|
|
|
|
class Paths {
|
|
final sandbox
|
|
final distAll
|
|
final distWin
|
|
final distMac
|
|
final distUnix
|
|
final artifacts
|
|
final ideaSystem
|
|
final ideaConfig
|
|
|
|
def Paths(String home) {
|
|
sandbox = "$home/out/pycharm"
|
|
distAll = "$sandbox/layout"
|
|
distWin = "$sandbox/win"
|
|
distMac = "$sandbox/mac"
|
|
distUnix = "$sandbox/unix"
|
|
|
|
ideaSystem = "$sandbox/system"
|
|
ideaConfig = "$sandbox/config"
|
|
|
|
artifacts = "$home/out/pycharm/artifacts"
|
|
}
|
|
}
|
|
|
|
setProperty("paths", new Paths(home))
|
|
|
|
def sandbox = "$home/out/pycharm";
|
|
|
|
setProperty("buildName", "PY-$buildNumber")
|
|
|
|
target('default': "Build artifacts") {
|
|
|
|
def modules = [
|
|
"python", "python-ide", "python-pydev", "colorSchemes", platformApiModules(), platformImplementationModules(), pluginFilter
|
|
].flatten()
|
|
|
|
loadProject()
|
|
|
|
// project.dryRun = true
|
|
project.stage("Cleaning up sandbox folder")
|
|
|
|
project.targetFolder = "$sandbox/classes"
|
|
project.dryRun = dryRun
|
|
|
|
if (!dryRun) {
|
|
forceDelete(sandbox)
|
|
ant.mkdir(dir: sandbox)
|
|
}
|
|
|
|
ant.tstamp() {
|
|
format(property: "todayYear", pattern: "yyyy")
|
|
}
|
|
|
|
if (isEap()) {
|
|
binding.setVariable("common_vmoptions",
|
|
"$common_vmoptions -XX:+HeapDumpOnOutOfMemoryError -agentlib:yjpagent=disablej2ee,disablecounts,disablealloc,sessionname=PyCharm")
|
|
}
|
|
|
|
ant.patternset(id: "resources.included") {
|
|
include(name: "**/*.properties")
|
|
include(name: "fileTemplates/**/*")
|
|
include(name: "inspectionDescriptions/**/*")
|
|
include(name: "intentionDescriptions/**/*")
|
|
include(name: "tips/**/*")
|
|
include(name: "search/**/*")
|
|
}
|
|
|
|
ant.patternset(id: "resources.excluded") {
|
|
exclude(name: "**/*.properties")
|
|
exclude(name: "fileTemplates/**/*")
|
|
exclude(name: "fileTemplates")
|
|
exclude(name: "inspectionDescriptions/**/*")
|
|
exclude(name: "inspectionDescriptions")
|
|
exclude(name: "intentionDescriptions/**/*")
|
|
exclude(name: "intentionDescriptions")
|
|
exclude(name: "tips/**/*")
|
|
exclude(name: "tips")
|
|
}
|
|
|
|
zipSources(home, paths.artifacts)
|
|
|
|
def usedJars = new HashSet();
|
|
|
|
def forbiddenJars = ["client-api", "ideaLicenseDecoder", "eawtstub.jar", "ui.jar", "exe4jlib.jar", "cglib", "jcip-annotations"]
|
|
|
|
project.clean()
|
|
modules.each {
|
|
Module module = project[it] as Module
|
|
if (module != null) {
|
|
project.info("Building $module.name")
|
|
module.runtimeClasspath().each {
|
|
File file = new File(it)
|
|
if (file.exists()) {
|
|
String path = file.canonicalPath.replace('\\', '/')
|
|
String normalizedHome = home.replace('\\', '/')
|
|
if (path.endsWith(".jar") && (path.startsWith("$normalizedHome/lib/") ||
|
|
path.startsWith("$normalizedHome/community/lib/") ||
|
|
path.startsWith("$normalizedHome/python/lib") ||
|
|
path.startsWith("$normalizedHome/plugins/coverage-impl/lib") ||
|
|
path.startsWith("$normalizedHome/community/xml/relaxng/lib"))
|
|
&& !path.contains("/dev/") && !path.contains("/rt/") && !path.contains("/ant/")
|
|
&& !forbiddenJars.any { path.contains(it) }) {
|
|
usedJars.add(path);
|
|
}
|
|
}
|
|
}
|
|
module.make()
|
|
}
|
|
else {
|
|
project.warning("$it is not a module")
|
|
}
|
|
}
|
|
|
|
usedJars.add("$home/community/lib/jgoodies-common-1.2.1.jar")
|
|
usedJars.add("$home/community/lib/jgoodies-looks-2.4.2.jar")
|
|
|
|
build_searchable_options()
|
|
wire_build_date(buildName)
|
|
LayoutInfo layoutInfo = layoutFull(paths.distAll, usedJars)
|
|
generateLicensesTable("$paths.artifacts/third-party-libraries.txt", layoutInfo.usedModules);
|
|
|
|
egg = buildDebuggerEgg(paths.sandbox, "$home/python", buildName)
|
|
|
|
ant.copy(file: egg, todir: paths.distAll)
|
|
|
|
scramble()
|
|
|
|
layoutWin(paths.distWin)
|
|
layoutUnix(paths.distUnix)
|
|
layoutMac(buildName: buildName,
|
|
version: "1.0",
|
|
system_selector: system_selector,
|
|
paths.distMac)
|
|
|
|
buildExe()
|
|
|
|
ant.echo(message: buildName, file: "$sandbox/layout/build.txt")
|
|
|
|
def root = isEap() ? "PyCharm ${p("component.version.major")}.${p("component.version.minor")} EAP.app" : "PyCharm.app"
|
|
|
|
ant.zip(zipfile: "${paths.artifacts}/pycharm${buildName}.sit") {
|
|
tarfileset(dir: paths.distAll, prefix: root) {
|
|
exclude(name: "bin/idea.properties")
|
|
}
|
|
tarfileset(dir: paths.distMac, prefix: root) {
|
|
exclude(name: "bin/*.sh")
|
|
exclude(name: "bin/idea.properties")
|
|
exclude(name: "Contents/MacOS/idea")
|
|
}
|
|
tarfileset(dir: paths.distMac, filemode: "755", prefix: root) {
|
|
include(name: "bin/*.sh")
|
|
include(name: "Contents/MacOS/idea")
|
|
}
|
|
}
|
|
executeExternalAnt("file.name": "pycharm",
|
|
"dmg.image.name" : "${home}/python/build/DMG_background.png",
|
|
"$home/build/buildDmg.xml")
|
|
|
|
buildTarGz()
|
|
|
|
ant.zip(zipfile: "${paths.artifacts}/pycharm${buildName}.zip") {
|
|
fileset(dir: paths.distAll)
|
|
fileset(dir: paths.distWin)
|
|
}
|
|
|
|
def installer = includeFile("$home/build/scripts/nsis_installer.gant")
|
|
installer.nsis_installer([paths.distAll, paths.distWin],
|
|
"$home/python/build/strings.nsi",
|
|
"$home/python/build/paths.nsi",
|
|
"pycharm", false, true, system_selector)
|
|
}
|
|
|
|
def build_searchable_options() {
|
|
def dest_dir = "${project["platform-resources"].output}/search"
|
|
project.stage("Building searchable options")
|
|
ant.mkdir(dir: "${dest_dir}/search")
|
|
ant.copy(file: "$home/build/idea.license", todir: paths.ideaSystem)
|
|
ant.copy(file: "$home/build/pycharm.license", todir: paths.ideaSystem)
|
|
ant.java(classname: "com.intellij.idea.Main", fork: "true") {
|
|
jvmarg(line: "-ea -Xmx250m -Didea.home.path=$home -Didea.system.path=${paths.ideaSystem} -Didea.config.path=${paths.ideaConfig} -Didea.platform.prefix=Python -Didea.no.jre.check=true")
|
|
jvmarg(value: "-Xbootclasspath/a:${boot.output}")
|
|
arg(line: "traverseUI ${dest_dir}/searchableOptions.xml")
|
|
|
|
classpath() {
|
|
project["python-ide"].runtimeClasspath().each {
|
|
pathelement(location: it)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
def zkmScramble(String script, String dir, String jarName) {
|
|
ant.java(classname: "ZKM", fork: "true", failonerror: "true") {
|
|
jvmarg(value: "-Xmx1100m")
|
|
arg(value: "-v")
|
|
arg(value: script)
|
|
classpath {
|
|
fileset(dir: dir) {
|
|
include(name: "*.jar")
|
|
exclude(name: jarName)
|
|
}
|
|
|
|
fileset(dir: "$home/lib") {
|
|
include(name: "*.jar")
|
|
}
|
|
fileset(dir: "$home/community/lib") {
|
|
include(name: "*.jar")
|
|
}
|
|
fileset(dir: "$home/community/xml/relaxng/lib", includes: "*.jar")
|
|
|
|
pathelement(location: "$home/build/lib/ZKM.jar")
|
|
}
|
|
}
|
|
|
|
ant.delete(file: "$dir/${jarName}.BACKUP", failonerror: "false")
|
|
}
|
|
|
|
def scramble() {
|
|
ant.copy(file: "$home/build/conf/script.zkm.stub", tofile: "$paths.sandbox/script.zkm", overwrite: "true") {
|
|
filterset(begintoken: "__", endtoken: "__") {
|
|
filter(token: "CLASSES", value: "\"${paths.distAll}/lib/pycharm.jar\"")
|
|
filter(token: "SCRAMBLED_CLASSES", value: "${paths.distAll}/")
|
|
filter(token: "INCREMENTAL", value: "")
|
|
}
|
|
}
|
|
ant.mkdir(dir: "$paths.artifacts/pycharm.unscrambled")
|
|
ant.copy(file: "$paths.distAll/lib/pycharm.jar", todir: "$paths.artifacts/pycharm.unscrambled")
|
|
zkmScramble("$paths.sandbox/script.zkm", "$paths.distAll/lib", "pycharm.jar")
|
|
ant.move(file: "$paths.distAll/pycharm.jar", todir: "$paths.distAll/lib")
|
|
ant.zip(destfile: "$paths.artifacts/logs.zip") {
|
|
fileset(file: "ChangeLog.txt")
|
|
fileset(file: "ZKM_log.txt")
|
|
fileset(file: "$paths.sandbox/script.zkm")
|
|
}
|
|
ant.delete(file: "ChangeLog.txt")
|
|
ant.delete(file: "ZKM_log.txt")
|
|
}
|
|
|
|
String appInfoFile() {
|
|
return "$home/out/pycharm/classes/production/python-ide/idea/PythonApplicationInfo.xml"
|
|
}
|
|
|
|
void wire_build_date(String buildName) {
|
|
if (!dryRun) {
|
|
ant.replace(token: "__BUILD_NUMBER__", value: buildName, file: appInfoFile())
|
|
ant.replace(token: "__BUILD_DATE__", value: DSTAMP, file: appInfoFile())
|
|
}
|
|
}
|
|
|
|
def buildExe() {
|
|
if (!isMac()) {
|
|
ant.mkdir(dir: paths.distWin)
|
|
executeExternalAnt(
|
|
"config.file": "$home/python/build/pycharm.exe4j",
|
|
"output.file": "pycharm.exe",
|
|
"system_selector" : system_selector,
|
|
"$home/build/buildLauncher.xml")
|
|
}
|
|
else {
|
|
project.warning("Building .exe executable skipped")
|
|
}
|
|
}
|
|
|
|
def buildTarGz() {
|
|
project.stage("tar.gz")
|
|
def tarRoot = isEap() ? "pycharm-$buildNumber" : "pycharm-${p("component.version.major")}.${p("component.version.minor")}"
|
|
def tarPath = "$paths.artifacts/pycharm${buildName}.tar"
|
|
ant.echo(file: "$paths.distUnix/bin/pycharm.vmoptions", message: vmoptions32().replace(' ', '\n').replace("agentlib:yjpagent", "agentlib:yjpagent\$BITS"))
|
|
ant.tar(tarfile: tarPath) {
|
|
tarfileset(dir: paths.distAll, prefix: tarRoot) {
|
|
exclude(name: "**/*.dll")
|
|
exclude(name: "bin/*.sh")
|
|
}
|
|
tarfileset(dir: "$home/bin", prefix: "$tarRoot/bin") {
|
|
include(name: "libyjpagent*.so")
|
|
}
|
|
tarfileset(dir: "$home/community/bin/linux", prefix: "$tarRoot/bin") {
|
|
exclude(name: "libbreakgen*")
|
|
exclude(name: "fsnotifier*")
|
|
}
|
|
tarfileset(dir: "$home/community/bin/linux", filemode: "755", prefix: "$tarRoot/bin") {
|
|
include(name: "fsnotifier*")
|
|
}
|
|
tarfileset(dir: "$home/community/bin/nix", filemode: "755", prefix: "$tarRoot/bin") {
|
|
include(name: "inspect*.sh")
|
|
}
|
|
tarfileset(dir: "$paths.distUnix/bin", filemode: "755", prefix: "$tarRoot/bin") {
|
|
include(name: "pycharm.sh")
|
|
}
|
|
tarfileset(dir: "$paths.distUnix/bin", prefix: "$tarRoot/bin") {
|
|
include(name: "pycharm.vmoptions")
|
|
}
|
|
tarfileset(dir: "$home/python/resources", prefix: "$tarRoot/bin") {
|
|
include(name: "PyCharm_16.png")
|
|
include(name: "PyCharm_32.png")
|
|
include(name: "PyCharm_48.png")
|
|
include(name: "PyCharm_128.png")
|
|
}
|
|
tarfileset(dir: "$home/python/help", includes: "pycharmhelp.jar", prefix: "$tarRoot/help")
|
|
}
|
|
|
|
ant.gzip(src: tarPath, zipfile: "${tarPath}.gz")
|
|
ant.delete(file: tarPath)
|
|
}
|
|
|
|
def layoutFull(String target, Set usedJars) {
|
|
def openapiModules = platformApiModules()
|
|
def implementationModules = [platformImplementationModules(), "python", "python-ide"].flatten()
|
|
|
|
def result = layout(target) {
|
|
dir("lib") {
|
|
jar("util.jar") { module("util") }
|
|
|
|
jar("openapi.jar") {
|
|
openapiModules.each { module it}
|
|
}
|
|
|
|
jar("annotations.jar") { module("annotations")}
|
|
jar("extensions.jar") { module("extensions")}
|
|
|
|
jar("pycharm.jar") {
|
|
implementationModules.each {
|
|
module(it) {
|
|
exclude(name: "**/tips/**")
|
|
}
|
|
}
|
|
zipfileset(src: "${home}/lib/client-api.jar")
|
|
zipfileset(src: "${home}/lib/ideaLicenseDecoder.jar")
|
|
}
|
|
|
|
jar("pycharm-pydev.jar") {
|
|
module("python-pydev")
|
|
}
|
|
|
|
jar("bootstrap.jar") { module("bootstrap")}
|
|
jar("resources.jar") {
|
|
module("platform-resources")
|
|
module("colorSchemes")
|
|
}
|
|
|
|
jar("forms_rt.jar") {
|
|
module("forms_rt")
|
|
}
|
|
|
|
jar([name: "resources_en.jar", duplicate: "preserve"]) {
|
|
// custom resources go first
|
|
fileset(dir: "$home/python/resources") {
|
|
include(name: "**/tips/**")
|
|
}
|
|
module("platform-resources-en") {
|
|
ant.patternset {
|
|
exclude(name: "tips/images/switcher.png")
|
|
exclude(name: "tips/images/navigateToFilePath.gif")
|
|
}
|
|
}
|
|
zipfileset(dir: "$home/python/resources/tips", prefix: "tips")
|
|
}
|
|
|
|
jar("icons.jar") { module("icons") }
|
|
jar("boot.jar") { module("boot") }
|
|
|
|
usedJars.each {
|
|
fileset(file: it)
|
|
}
|
|
|
|
dir("ext") {
|
|
fileset(dir: "$home/community/lib") {
|
|
include(name: "cglib*.jar")
|
|
}
|
|
}
|
|
|
|
dir("src") {
|
|
fileset(dir: "$home/community/lib/src") {
|
|
include(name: "trove4j_changes.txt")
|
|
include(name: "trove4j_src.jar")
|
|
}
|
|
|
|
jar("pycharm-pydev-src.zip") {
|
|
fileset(dir: "$home/python/pydevSrc")
|
|
}
|
|
}
|
|
}
|
|
|
|
dir("help") {
|
|
fileset(dir: "$home/python/help") {
|
|
include(name: "*.pdf")
|
|
}
|
|
}
|
|
|
|
dir("helpers") {
|
|
fileset(dir: "$home/python/helpers")
|
|
}
|
|
|
|
dir("license") {
|
|
fileset(dir: "$home/python/license")
|
|
fileset(dir: "$home/community/license")
|
|
}
|
|
|
|
dir("plugins") {
|
|
dir("django-db-config") {
|
|
dir("lib") {
|
|
jar("django-db-config.jar") {
|
|
module("django-db-config")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
def layouts = includeFile("$home/build/scripts/layouts.gant")
|
|
layouts.layoutPlugins()
|
|
|
|
dir("bin") {
|
|
fileset(dir: "$home/community/bin") {
|
|
include(name: "*.*")
|
|
exclude(name: "idea.properties")
|
|
exclude(name: "appletviewer.policy")
|
|
}
|
|
fileset(dir: "$home/python/build") {
|
|
include(name: "idea.properties")
|
|
}
|
|
}
|
|
}
|
|
|
|
patchPropertiesFile(target)
|
|
return result
|
|
}
|
|
|
|
def layoutMac(Map args, String target) {
|
|
layout(target) {
|
|
dir("bin") {
|
|
fileset(dir: "$home/bin", includes: "*.jnilib")
|
|
}
|
|
|
|
dir("skeletons") {
|
|
fileset(dir: "$home/python/skeletons") {
|
|
include(name: "skeletons-mac*.zip")
|
|
}
|
|
}
|
|
}
|
|
|
|
args.buildNumber = buildName
|
|
args["executable"] = "pycharm"
|
|
args["icns"] = "$home/python/resources/PyCharm.icns"
|
|
args["bundle_name"] = "PyCharm"
|
|
args["bundleIdentifier"] = "com.jetbrains.pycharm"
|
|
args["platform_prefix"] = "Python"
|
|
args["idea.properties.path"] = "$home/python/build/idea.properties"
|
|
args["idea.properties"] = ["ide.mac.useNativeClipboard":"false"];
|
|
|
|
layoutMacApp(target, "$home/community", args)
|
|
|
|
ant.copy(file: "$home/python/help/pycharmhelp_mac.jar", tofile: "$target/help/pycharmhelp.jar")
|
|
}
|
|
|
|
def layoutWin(String target) {
|
|
layout(target) {
|
|
dir("bin") {
|
|
fileset(dir: "$home/bin") {
|
|
include(name: "yjpagent.dll")
|
|
}
|
|
fileset(dir: "$home/community/bin/win") {
|
|
exclude(name: "breakgen*")
|
|
exclude(name: "idea.bat")
|
|
}
|
|
fileset(dir: "$home/python/build") {
|
|
include(name: "pycharm.bat")
|
|
}
|
|
}
|
|
dir("skeletons") {
|
|
fileset(dir: "$home/python/skeletons") {
|
|
include(name: "skeletons-win*.zip")
|
|
}
|
|
}
|
|
}
|
|
|
|
ant.replace(file: "$target/bin/pycharm.bat") {
|
|
replacefilter(token: "@@system_selector@@", value: system_selector)
|
|
}
|
|
ant.copy(file: "$home/python/help/pycharmhelp.jar", todir: "$target/help")
|
|
ant.echo(file: "$target/bin/pycharm.exe.vmoptions", message: vmoptions32().replace(' ', '\n'))
|
|
}
|
|
|
|
def layoutUnix(String target) {
|
|
ant.copy(file: "$home/python/build/pycharm.sh", todir: "$target/bin")
|
|
ant.replace(file: "$target/bin/pycharm.sh") {
|
|
replacefilter(token: "@@isEap@@", value: isEap())
|
|
replacefilter(token: "@@system_selector@@", value: system_selector)
|
|
}
|
|
}
|
|
|
|
def set(Map args, String key, Object value) {
|
|
if (!args.containsKey(key)) {
|
|
args[key] = value
|
|
}
|
|
}
|
|
|
|
def executeExternalAnt(Map args, String file) {
|
|
set(args, "build.number", buildName)
|
|
set(args, "project.home", home)
|
|
set(args, "artifacts.path", paths.artifacts)
|
|
set(args, "dist.win", paths.distWin)
|
|
//set(args, "dist.all", paths.distAll)
|
|
|
|
//set(args, "dist.all.15", paths.distAll15)
|
|
//set(args, "dist.all.16", paths.distAll16)
|
|
set(args, "sandbox.path", "$home/out/pycharm")
|
|
set(args, "component.version.major", getProperty("component.version.major"))
|
|
set(args, "component.version.minor", "\"" + getProperty("component.version.minor") + "\"")
|
|
|
|
ant.java(failonerror: "true", classname: "org.apache.tools.ant.Main", fork: "true") {
|
|
args.each { String key, String value ->
|
|
jvmarg(line: "-D$key=$value")
|
|
}
|
|
|
|
jvmarg(line: "-Xmx250m")
|
|
|
|
classpath {
|
|
fileset(dir: "$home/build/lib") {
|
|
include(name: "commons-net-1.4.1.jar")
|
|
include(name: "jsch-0.1.43.jar")
|
|
}
|
|
|
|
fileset(dir: "$ch/lib/ant/lib") {
|
|
include(name: "*.jar")
|
|
}
|
|
|
|
fileset(file: "$jdk16/lib/tools.jar")
|
|
fileset(file: "$ch/lib/oromatcher.jar")
|
|
}
|
|
|
|
arg(value: "-f")
|
|
arg(value: file)
|
|
}
|
|
}
|