Pavel Punegov
524c7c4397
JDK17 can't be applied for all subprojects because it will make our bundle require JDK17 to be used by end users.
747 lines
24 KiB
Groovy
747 lines
24 KiB
Groovy
/*
|
|
* Copyright 2010-2017 JetBrains s.r.o.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
import kotlin.text.Regex
|
|
import org.jetbrains.kotlin.konan.target.*
|
|
import org.jetbrains.kotlin.konan.util.*
|
|
import org.jetbrains.kotlin.CopySamples
|
|
import org.jetbrains.kotlin.CopyCommonSources
|
|
import org.jetbrains.kotlin.PlatformInfo
|
|
import org.jetbrains.kotlin.KotlinBuildPusher
|
|
import org.jetbrains.kotlin.CollisionDetector
|
|
import org.jetbrains.kotlin.CollisionTransformer
|
|
import org.jetbrains.kotlin.CompilationDatabaseKt
|
|
import org.jetbrains.kotlin.CompareDistributionSignatures
|
|
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
|
|
import org.apache.tools.ant.filters.ReplaceTokens
|
|
import org.jetbrains.kotlin.UtilsKt
|
|
|
|
buildscript {
|
|
apply from: "gradle/kotlinGradlePlugin.gradle"
|
|
|
|
repositories {
|
|
if (UtilsKt.getCacheRedirectorEnabled(project)) {
|
|
maven { url "https://cache-redirector.jetbrains.com/maven-central" }
|
|
maven { url "https://cache-redirector.jetbrains.com/jcenter" }
|
|
}
|
|
else {
|
|
mavenCentral()
|
|
jcenter()
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
//classpath project(":kotlin-native-utils")
|
|
classpath 'com.github.jengelman.gradle.plugins:shadow:5.1.0'
|
|
}
|
|
}
|
|
import org.jetbrains.kotlin.konan.*
|
|
|
|
// Allows generating wrappers for the root build and all the samples during execution of the default 'wrapper' task.
|
|
// Run './gradlew wrapper --gradle-version <version>' to update all the wrappers.
|
|
//apply plugin: org.jetbrains.kotlin.GradleWrappers
|
|
//
|
|
//wrappers.projects = ['samples', 'samples/calculator', 'samples/androidNativeActivity', 'samples/cocoapods/kotlin-library']
|
|
//wrapper.distributionType = Wrapper.DistributionType.ALL
|
|
|
|
// FIXME: Remove until IDEA-231214 is fixed.
|
|
//defaultTasks 'clean', 'dist'
|
|
|
|
convention.plugins.platformInfo = PlatformInfo
|
|
|
|
if (isMac()) {
|
|
checkXcodeVersion(project)
|
|
}
|
|
|
|
ext {
|
|
distDir = UtilsKt.getKotlinNativeDist(project)
|
|
dependenciesDir = DependencyProcessor.defaultDependenciesRoot
|
|
experimentalEnabled = project.hasProperty("org.jetbrains.kotlin.native.experimentalTargets")
|
|
platformManager = new PlatformManager(DistributionKt.buildDistribution(projectDir.absolutePath),
|
|
ext.experimentalEnabled)
|
|
|
|
cacheableTargetNames = platformManager.hostPlatform.cacheableTargets
|
|
cacheableTargets = cacheableTargetNames.collect { platformManager.targetByName(it) }
|
|
|
|
// Some targets miss zlib in their sysroots.
|
|
// We skip these targets when generate a corresponding platform library.
|
|
// See also: the :distDef task, targetDefFiles in the :platformLibs project.
|
|
targetsWithoutZlib = [
|
|
KonanTarget.LINUX_MIPS32.INSTANCE,
|
|
KonanTarget.LINUX_MIPSEL32.INSTANCE
|
|
]
|
|
|
|
kotlinCompilerModule= [path: ":kotlin-compiler", configuration: "runtimeElements"]
|
|
kotlinStdLibModule= project(":kotlin-stdlib")
|
|
kotlinCommonStdlibModule= project(":kotlin-stdlib-common")
|
|
kotlinTestCommonModule= project(":kotlin-test:kotlin-test-common")
|
|
kotlinTestAnnotationsCommonModule= project(":kotlin-test:kotlin-test-annotations-common")
|
|
kotlinReflectModule= project(":kotlin-reflect")
|
|
kotlinScriptRuntimeModule= project(":kotlin-script-runtime")
|
|
kotlinUtilKliMetadatabModule= project(":kotlin-util-klib-metadata")
|
|
|
|
konanVersionFull = ext.kotlinNativeVersion
|
|
gradlePluginVersion = konanVersionFull
|
|
}
|
|
|
|
allprojects {
|
|
buildscript {
|
|
repositories {
|
|
if (UtilsKt.getCacheRedirectorEnabled(project))
|
|
maven { url 'https://cache-redirector.jetbrains.com/jcenter' }
|
|
else
|
|
jcenter()
|
|
}
|
|
}
|
|
if (path != ":kotlin-native:dependencies") {
|
|
evaluationDependsOn(":kotlin-native:dependencies")
|
|
}
|
|
|
|
repositories {
|
|
if (UtilsKt.getCacheRedirectorEnabled(project))
|
|
maven { url 'https://cache-redirector.jetbrains.com/maven-central' }
|
|
else
|
|
mavenCentral()
|
|
maven {
|
|
url project.bootstrapKotlinRepo
|
|
}
|
|
}
|
|
|
|
setupHostAndTarget()
|
|
loadCommandLineProperties()
|
|
loadLocalProperties()
|
|
setupClang(project)
|
|
}
|
|
|
|
void setupHostAndTarget() {
|
|
ext.hostName = platformManager.hostName
|
|
ext.targetList = platformManager.enabled.collect { it.visibleName } as List
|
|
ext.konanTargetList = platformManager.enabled as List
|
|
}
|
|
|
|
void setupClang(Project project) {
|
|
|
|
project.extensions.platformManager = project.project(":kotlin-native").ext.platformManager
|
|
project.extensions.execClang = new org.jetbrains.kotlin.ExecClang(project)
|
|
}
|
|
|
|
void loadLocalProperties() {
|
|
if (new File("$project.rootDir/local.properties").exists()) {
|
|
Properties props = new Properties()
|
|
props.load(new FileInputStream("$project.rootDir/local.properties"))
|
|
props.each { prop -> project.ext.set(prop.key, prop.value) }
|
|
}
|
|
}
|
|
|
|
void loadCommandLineProperties() {
|
|
if (project.hasProperty("konanc_flags")) {
|
|
throw new Error("Specify either -Ptest_flags or -Pbuild_flags.")
|
|
}
|
|
ext.globalBuildArgs = project.hasProperty("build_flags") ? ext.build_flags.split() : []
|
|
ext.globalTestArgs = project.hasProperty("test_flags") ? ext.test_flags.split() : []
|
|
ext.testTarget = project.hasProperty("test_target") ? ext.test_target : null
|
|
}
|
|
|
|
configurations {
|
|
ftpAntTask
|
|
kotlinCommonSources
|
|
distPack
|
|
}
|
|
|
|
dependencies {
|
|
ftpAntTask 'org.apache.ant:ant-commons-net:1.9.9'
|
|
[kotlinCommonStdlibModule, kotlinTestCommonModule, kotlinTestAnnotationsCommonModule].each {
|
|
kotlinCommonSources(it) { transitive = false }
|
|
}
|
|
distPack project(':kotlin-native:Interop:Runtime')
|
|
distPack project(':kotlin-native:Interop:Indexer')
|
|
distPack project(':kotlin-native:Interop:StubGenerator')
|
|
distPack project(':kotlin-native:Interop:Skia')
|
|
distPack project(':kotlin-native:backend.native')
|
|
distPack project(':kotlin-native:utilities:cli-runner')
|
|
distPack project(':kotlin-native:utilities:basic-utils')
|
|
distPack project(':kotlin-native:klib')
|
|
distPack project(path: ':kotlin-native:endorsedLibraries:kotlinx.cli', configuration: "jvmRuntimeElements")
|
|
//distPack "org.jetbrains.kotlin:kotlin-native-shared:$konanVersion"
|
|
}
|
|
|
|
//task sharedJar {
|
|
// dependsOn gradle.includedBuild('shared').task(':jar')
|
|
//}
|
|
|
|
//task gradlePluginJar {
|
|
// dependsOn gradle.includedBuild('kotlin-native-gradle-plugin').task(':shadowJar')
|
|
//}
|
|
|
|
//task gradlePluginCheck {
|
|
// dependsOn gradle.includedBuild('kotlin-native-gradle-plugin').task(':check')
|
|
//}
|
|
|
|
task dist_compiler(dependsOn: "distCompiler")
|
|
task dist_runtime(dependsOn: "distRuntime")
|
|
task cross_dist(dependsOn: "crossDist")
|
|
task list_dist(dependsOn: "listDist")
|
|
task build {
|
|
dependsOn ':dist', ':distPlatformLibs'
|
|
}
|
|
|
|
task distCommonSources(type: CopyCommonSources) {
|
|
outputDir "$distDir/sources"
|
|
sourcePaths project(":kotlin-stdlib-common").file("src")
|
|
zipSources true
|
|
}
|
|
|
|
task distNativeSources(type: Zip) {
|
|
destinationDirectory = file("$distDir/sources")
|
|
archiveFileName = "kotlin-stdlib-native-sources.zip"
|
|
|
|
includeEmptyDirs = false
|
|
include('**/*.kt')
|
|
|
|
from(project(':kotlin-native:runtime').file('src/main/kotlin'))
|
|
from(project(":kotlin-stdlib-common").file('../native-wasm/src/'))
|
|
from(project(':kotlin-native:Interop:Runtime').file('src/main/kotlin'))
|
|
from(project(':kotlin-native:Interop:Runtime').file('src/native/kotlin'))
|
|
from(project(':kotlin-native:Interop:JsRuntime').file('src/main/kotlin')) {
|
|
into('kotlinx/wasm/jsinterop')
|
|
}
|
|
}
|
|
|
|
task distEndorsedSources {
|
|
dependsOn(':kotlin-native:endorsedLibraries:endorsedLibsSources')
|
|
}
|
|
|
|
task distSources {
|
|
dependsOn(distCommonSources)
|
|
dependsOn(distNativeSources)
|
|
dependsOn(distEndorsedSources)
|
|
}
|
|
|
|
task shadowJar(type: ShadowJar) {
|
|
mergeServiceFiles()
|
|
destinationDirectory.set(file("$distDir/konan/lib"))
|
|
archiveBaseName.set("kotlin-native")
|
|
// Exclude trove4j because of license agreement.
|
|
exclude "*trove4j*"
|
|
exclude("META-INF/versions/9/module-info.class")
|
|
configurations = [project.configurations.distPack]
|
|
archiveClassifier.set(null)
|
|
outputs.upToDateWhen {
|
|
archiveFile.getOrNull()?.asFile.exists() ?: false
|
|
}
|
|
}
|
|
|
|
task distCompiler(type: Copy) {
|
|
dependsOn ":kotlin-native:dependencies:update"
|
|
dependsOn ':kotlin-native:shadowJar'
|
|
dependsOn ":kotlin-native-compiler-embeddable:kotlin-native-compiler-embeddable"
|
|
|
|
destinationDir distDir
|
|
|
|
from(project(':kotlin-native:backend.native').file("build/nativelibs/$hostName")) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:backend.native').file('build/external_jars/trove4j.jar')) {
|
|
into('konan/lib')
|
|
}
|
|
|
|
from(project(":kotlin-native-compiler-embeddable").file("build/libs")) {
|
|
into("konan/lib")
|
|
}
|
|
|
|
from(project(':kotlin-native:Interop').file('Indexer/build/nativelibs')) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:Interop').file('Runtime/build/nativelibs')) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:llvmCoverageMappingC').file('build/libs/coverageMapping/shared')) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:llvmDebugInfoC').file('build/libs/debugInfo/shared')) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:llvmDebugInfoC').file('src/scripts/konan_lldb.py')) {
|
|
into('tools')
|
|
}
|
|
|
|
from(project(':kotlin-native:utilities').file('env_blacklist')) {
|
|
into('tools')
|
|
}
|
|
|
|
from(file('cmd')) {
|
|
fileMode(0755)
|
|
into('bin')
|
|
if (!PlatformInfo.isWindows()) {
|
|
exclude('**/*.bat')
|
|
}
|
|
}
|
|
|
|
from(project.file('konan')) {
|
|
into('konan')
|
|
exclude('**/*.properties')
|
|
}
|
|
|
|
from(project.file('konan')) {
|
|
into('konan')
|
|
include('**/*.properties')
|
|
filter(ReplaceTokens, tokens: [compilerVersion: konanVersionFull.toString()])
|
|
// Set LLVM variant that will be used by default in the distribution.
|
|
// `user` - smaller, includes only necessary components.
|
|
// `dev` - bigger, includes (almost) every possible component. Use this one,
|
|
// if your feature requires component that is not a part of user distribution (yet).
|
|
// Note: by default konan.properties use `dev` variant because it is needed for building our LLVM dynamic library.
|
|
String llvmVariant = 'user'
|
|
filter(ReplaceTokens,
|
|
beginToken: '$',
|
|
endToken: '',
|
|
tokens: [("llvm.${hostName}.dev".toString()): "\$llvm.${hostName}.${llvmVariant}".toString()]
|
|
)
|
|
}
|
|
if (experimentalEnabled) {
|
|
file('konan/experimentalTargetsEnabled').text = ""
|
|
} else {
|
|
delete('konan/experimentalTargetsEnabled')
|
|
}
|
|
}
|
|
|
|
task distDef(type: Copy) {
|
|
destinationDir project.file("$distDir/konan/platformDef/")
|
|
|
|
platformManager.targetValues.each { target ->
|
|
from(project(":kotlin-native:platformLibs").file("src/platform/${target.family.name().toLowerCase()}")) {
|
|
into target.visibleName
|
|
include '**/*.def'
|
|
if (target in targetsWithoutZlib) {
|
|
exclude '**/zlib.def'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
task listDist(type: Exec) {
|
|
commandLine 'find', distDir
|
|
}
|
|
|
|
task distRuntime(type: Copy) {
|
|
dependsOn "${hostName}CrossDistRuntime"
|
|
}
|
|
|
|
task distEndorsedLibraries {
|
|
dependsOn "${hostName}CrossDistEndorsedLibraries"
|
|
}
|
|
|
|
task distStdlibCache {
|
|
if (hostName in cacheableTargetNames) {
|
|
dependsOn("${hostName}StdlibCache")
|
|
}
|
|
}
|
|
|
|
task distEndorsedCache {
|
|
if (hostName in cacheableTargetNames) {
|
|
dependsOn("${hostName}EndorsedCache")
|
|
}
|
|
}
|
|
|
|
def stdlib = 'klib/common/stdlib'
|
|
def stdlibDefaultComponent = "$stdlib/default"
|
|
def endorsedLibs = 'klib/common/endorsedLibraries'
|
|
def endorsedLibsBase = 'klib/common'
|
|
|
|
task crossDistRuntime {
|
|
dependsOn.addAll(targetList.collect { "${it}CrossDistRuntime" })
|
|
}
|
|
|
|
task crossDistEndorsedLibraries {
|
|
dependsOn.addAll(targetList.collect { "${it}CrossDistEndorsedLibraries" })
|
|
}
|
|
|
|
task crossDistPlatformLibs {
|
|
dependsOn.addAll(targetList.collect { "${it}PlatformLibs" })
|
|
}
|
|
|
|
task crossDistStdlib {
|
|
dependsOn.addAll(targetList.collect { "${it}CrossDistStdlib" })
|
|
}
|
|
|
|
task crossDistStdlibCache {
|
|
dependsOn.addAll(targetList.findAll { it in cacheableTargetNames }.collect { "${it}StdlibCache" })
|
|
}
|
|
|
|
task crossDistEndorsedCache {
|
|
dependsOn.addAll(targetList.findAll { it in cacheableTargetNames }.collect { "${it}EndorsedCache" })
|
|
}
|
|
|
|
def endorsedLibsCopyTask = task("crossDistEndorsedLibrariesCopy", type: Copy) {
|
|
destinationDir project.file("$distDir/$endorsedLibsBase")
|
|
|
|
from(project(':kotlin-native:endorsedLibraries').file("build")) {
|
|
include('**')
|
|
exclude('cache')
|
|
}
|
|
}
|
|
|
|
targetList.each { target ->
|
|
task("${target}CrossDistStdlib", type: Copy) {
|
|
dependsOn ":kotlin-native:runtime:${target}Stdlib"
|
|
|
|
destinationDir project.file("$distDir/$stdlib")
|
|
|
|
from(project(':kotlin-native:runtime').file("build/${target}Stdlib")) {
|
|
include('**')
|
|
eachFile {
|
|
if (name == 'manifest') {
|
|
def existingManifest = file("$destinationDir/$path")
|
|
if (existingManifest.exists()) {
|
|
UtilsKt.mergeManifestsByTargets(project, file, existingManifest)
|
|
exclude()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
|
|
}
|
|
|
|
task("${target}CrossDistBitcodeCopy", type: Copy) {
|
|
dependsOn ":kotlin-native:runtime:${target}Runtime"
|
|
|
|
destinationDir project.file("$distDir/konan/targets/")
|
|
|
|
from(project(':kotlin-native:runtime').file("build/bitcode/main/$target")) {
|
|
include("*.bc")
|
|
exclude("runtime.bc")
|
|
into("$target/native")
|
|
}
|
|
}
|
|
|
|
task("${target}CrossDistRuntime", type: Copy) {
|
|
dependsOn ":kotlin-native:runtime:${target}Runtime"
|
|
dependsOn ":kotlin-native:${target}CrossDistStdlib"
|
|
dependsOn "${target}CrossDistBitcodeCopy"
|
|
|
|
destinationDir project.file("$distDir/$stdlibDefaultComponent")
|
|
|
|
if (target == 'wasm32') {
|
|
into("targets/wasm32/included") {
|
|
from(project(':kotlin-native:runtime').file('src/main/js'))
|
|
from(project(':kotlin-native:runtime').file('src/launcher/js'))
|
|
from(project(':kotlin-native:Interop:JsRuntime').file('src/main/js'))
|
|
}
|
|
}
|
|
}
|
|
|
|
task("${target}PlatformLibs") {
|
|
dependsOn ":kotlin-native:platformLibs:${target}Install"
|
|
if (target in cacheableTargetNames) {
|
|
dependsOn(":kotlin-native:platformLibs:${target}Cache")
|
|
}
|
|
}
|
|
|
|
if (target in cacheableTargetNames) {
|
|
task ("${target}StdlibCache", type: Copy) {
|
|
dependsOn "${target}CrossDistStdlib"
|
|
dependsOn ":kotlin-native:runtime:${target}StdlibCache"
|
|
|
|
destinationDir project.file("$distDir/klib/cache/")
|
|
|
|
from("${project(":kotlin-native:runtime").buildDir}/cache/$target") {
|
|
include('**')
|
|
}
|
|
}
|
|
|
|
task ("${target}EndorsedCache", type: Copy) {
|
|
dependsOn "${target}CrossDistStdlib"
|
|
dependsOn ":kotlin-native:endorsedLibraries:${target}Cache"
|
|
|
|
destinationDir project.file("$distDir/klib/cache")
|
|
|
|
from("${project(':kotlin-native:endorsedLibraries').buildDir}/cache/$target") {
|
|
include('**')
|
|
}
|
|
}
|
|
}
|
|
|
|
task("${target}CrossDist") {
|
|
dependsOn "${target}CrossDistRuntime", "distCompiler"
|
|
dependsOn "${target}CrossDistEndorsedLibraries"
|
|
if (target in cacheableTargetNames) {
|
|
dependsOn "${target}StdlibCache", "${target}EndorsedCache"
|
|
}
|
|
}
|
|
|
|
task("${target}CrossDistEndorsedLibraries") {
|
|
def endorsedLibsBuildTask = ":kotlin-native:endorsedLibraries:${target}EndorsedLibraries"
|
|
dependsOn endorsedLibsBuildTask
|
|
dependsOn endorsedLibsCopyTask
|
|
// There is only one copy task for endorsed libs, because they are already copied into a single dir,
|
|
// while having target-tasks will make Gradle issue warnings on incorrect inputs and outputs usage.
|
|
// So this copy task should run after the all build tasks.
|
|
endorsedLibsCopyTask.mustRunAfter(endorsedLibsBuildTask)
|
|
}
|
|
}
|
|
|
|
task distPlatformLibs {
|
|
dependsOn ':kotlin-native:platformLibs:hostInstall'
|
|
dependsOn ':kotlin-native:platformLibs:hostCache'
|
|
}
|
|
|
|
task dist {
|
|
dependsOn "distCompiler",
|
|
"distRuntime",
|
|
"distEndorsedLibraries",
|
|
"distDef",
|
|
"distStdlibCache",
|
|
"distEndorsedCache"
|
|
}
|
|
|
|
task crossDist {
|
|
dependsOn "distCompiler",
|
|
"crossDistRuntime",
|
|
"crossDistEndorsedLibraries",
|
|
"distDef",
|
|
"crossDistStdlib",
|
|
"crossDistStdlibCache",
|
|
"crossDistEndorsedCache"
|
|
}
|
|
|
|
task bundle {
|
|
dependsOn 'bundleRegular', 'bundlePrebuilt'
|
|
}
|
|
|
|
task bundleRegular(type: (isWindows()) ? Zip : Tar) {
|
|
def simpleOsName = HostManager.platformName()
|
|
archiveBaseName.set("kotlin-native-$simpleOsName-$konanVersionFull")
|
|
from(UtilsKt.getKotlinNativeDist(project)) {
|
|
include '**'
|
|
exclude 'dependencies'
|
|
exclude 'klib/testLibrary'
|
|
// Don't include platform libraries into the bundle (generate them at the user side instead).
|
|
exclude 'klib/platform'
|
|
// Exclude platform libraries caches too. Keep caches for stdlib and endorsed libs.
|
|
exclude 'klib/cache/*/org.jetbrains.kotlin.native.platform.*/**'
|
|
into archiveBaseName
|
|
}
|
|
from(project.rootDir) {
|
|
include 'licenses/**'
|
|
exclude '**/xcode_license.pdf'
|
|
into archiveBaseName
|
|
}
|
|
}
|
|
|
|
task bundlePrebuilt(type: (isWindows()) ? Zip : Tar) {
|
|
dependsOn("crossDistPlatformLibs")
|
|
def simpleOsName = HostManager.platformName()
|
|
archiveBaseName.set("kotlin-native-prebuilt-$simpleOsName-$konanVersionFull")
|
|
from(UtilsKt.getKotlinNativeDist(project)) {
|
|
include '**'
|
|
exclude 'dependencies'
|
|
exclude 'klib/testLibrary'
|
|
into archiveBaseName
|
|
}
|
|
from(project.rootDir) {
|
|
include 'licenses/**'
|
|
into archiveBaseName
|
|
}
|
|
}
|
|
|
|
configure([bundleRegular, bundlePrebuilt]) {
|
|
dependsOn("crossDist")
|
|
dependsOn("crossDistStdlibCache")
|
|
dependsOn("crossDistEndorsedCache")
|
|
dependsOn("distSources")
|
|
dependsOn("distDef")
|
|
from(project.rootDir) {
|
|
include 'RELEASE_NOTES.md'
|
|
into baseName
|
|
}
|
|
|
|
destinationDirectory.set(file('.'))
|
|
|
|
if (isWindows()) {
|
|
zip64 true
|
|
} else {
|
|
archiveExtension.set('tar.gz')
|
|
compression = Compression.GZIP
|
|
}
|
|
}
|
|
|
|
task 'tc-dist'(type: (isWindows()) ? Zip : Tar) {
|
|
dependsOn('dist')
|
|
dependsOn('distSources')
|
|
def simpleOsName = HostManager.platformName()
|
|
archiveBaseName.set("kotlin-native-dist-$simpleOsName-$konanVersionFull")
|
|
from(UtilsKt.getKotlinNativeDist(project)) {
|
|
include '**'
|
|
exclude 'dependencies'
|
|
into archiveBaseName
|
|
}
|
|
|
|
destinationDirectory.set(file('.'))
|
|
|
|
if (isWindows()) {
|
|
zip64 true
|
|
} else {
|
|
archiveExtension.set('tar.gz')
|
|
compression = Compression.GZIP
|
|
}
|
|
}
|
|
|
|
task samples {
|
|
dependsOn 'samplesZip', 'samplesTar'
|
|
}
|
|
|
|
task samplesZip(type: Zip)
|
|
task samplesTar(type: Tar) {
|
|
extension = 'tar.gz'
|
|
compression = Compression.GZIP
|
|
}
|
|
|
|
configure([samplesZip, samplesTar]) {
|
|
baseName "kotlin-native-samples-$konanVersionFull"
|
|
destinationDir = projectDir
|
|
into(baseName)
|
|
|
|
from(file('samples')) {
|
|
// Process properties files separately.
|
|
exclude '**/gradle.properties'
|
|
}
|
|
|
|
from(project.rootDir) {
|
|
include 'licenses/**'
|
|
}
|
|
|
|
from(file('samples')) {
|
|
include '**/gradle.properties'
|
|
filter {
|
|
it.startsWith('org.jetbrains.kotlin.native.home=') || it.startsWith('# Use custom Kotlin/Native home:') ? null : it
|
|
}
|
|
}
|
|
|
|
// Exclude build artifacts.
|
|
exclude '**/build'
|
|
exclude '**/.gradle'
|
|
exclude '**/.idea'
|
|
exclude '**/*.kt.bc-build/'
|
|
}
|
|
|
|
project.tasks.register("copy_samples") {
|
|
dependsOn 'copySamples'
|
|
}
|
|
project.tasks.register("copySamples", CopySamples) {
|
|
destinationDir file('build/samples-under-test')
|
|
}
|
|
|
|
task uploadBundle {
|
|
dependsOn ':kotlin-native:bundle'
|
|
if (isMac()) {
|
|
dependsOn ':kotlin-native:bundleRestricted'
|
|
}
|
|
doLast {
|
|
def kind = (konanVersionFull.meta == MetaVersion.DEV) ? "dev" : "releases"
|
|
def ftpSettings = [
|
|
server: project.findProperty("cdnUrl") ?: System.getenv("CDN_URL"),
|
|
userid: project.findProperty("cdnUser") ?: System.getenv("CDN_USER"),
|
|
password: project.findProperty("cdnPass") ?: System.getenv("CDN_PASS"),
|
|
remoteDir: "/builds/$kind/$konanVersion/${HostManager.platformName()}"
|
|
]
|
|
ant {
|
|
taskdef(name: 'ftp',
|
|
classname: 'org.apache.tools.ant.taskdefs.optional.net.FTP',
|
|
classpath: configurations.ftpAntTask.asPath)
|
|
ftp([action: "mkdir"] + ftpSettings)
|
|
ftp(ftpSettings) {
|
|
fileset(file: bundle.archivePath)
|
|
}
|
|
if (isMac()) {
|
|
ftp(ftpSettings) {
|
|
fileset(file: bundleRestricted.archivePath)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
task teamcityCompilerVersion {
|
|
doLast {
|
|
println("##teamcity[setParameter name='kotlin.native.version.base' value='$konanVersion']")
|
|
println("##teamcity[setParameter name='kotlin.native.version.full' value='$konanVersionFull']")
|
|
println("##teamcity[setParameter name='kotlin.native.version.meta' value='${konanVersionFull.meta.toString().toLowerCase()}']")
|
|
println("##teamcity[buildNumber '${konanVersionFull.toString(true, true)}']")
|
|
}
|
|
}
|
|
|
|
task clean(type: Delete) {
|
|
dependsOn subprojects.collect { it.tasks.matching { it.name == "clean" } }
|
|
doFirst {
|
|
delete distDir
|
|
delete buildDir
|
|
delete bundle.outputs.files
|
|
delete "${projectDir}/compile_commands.json"
|
|
}
|
|
}
|
|
|
|
task pusher(type: KotlinBuildPusher){
|
|
kotlinVersion = project.kotlinVersion
|
|
konanVersion = project.ext.kotlinNativeVersion
|
|
buildServer = "buildserver.labs.intellij.net"
|
|
compilerConfigurationId = System.getenv("TEAMCITY_COMPILER_ID") ?: "Kotlin_KotlinDev_Compiler"
|
|
overrideConfigurationId = System.getenv("TEAMCITY_OVERRIDE_NATIVE_ID") ?: "Kotlin_KotlinDev_DeployMavenArtifacts_OverrideNative"
|
|
token = project.findProperty("teamcityBearToken") ?: System.getenv("TEAMCITY_BEAR_TOKEN")
|
|
}
|
|
|
|
targetList.each { target ->
|
|
CompilationDatabaseKt.mergeCompilationDatabases(project, "${target}CompilationDatabase".toString(), [
|
|
":kotlin-native::common:${target}CompilationDatabase".toString(),
|
|
":kotlin-native:runtime:${target}CompilationDatabase".toString()
|
|
]).configure {
|
|
outputFile = file("$buildDir/${target}/compile_commands.json")
|
|
}
|
|
}
|
|
|
|
task compdb(type: Copy) {
|
|
dependsOn "${hostName}CompilationDatabase"
|
|
from "$buildDir/${hostName}/compile_commands.json"
|
|
into "$projectDir"
|
|
}
|
|
|
|
targetList.each { targetName ->
|
|
task "${targetName}CheckPlatformAbiCompatibility"(type: CompareDistributionSignatures) {
|
|
dependsOn "${targetName}PlatformLibs"
|
|
|
|
libraries = new CompareDistributionSignatures.Libraries.Platform(targetName)
|
|
if (project.hasProperty("anotherDistro")) {
|
|
oldDistribution = project.findProperty("anotherDistro")
|
|
}
|
|
onMismatchMode = CompareDistributionSignatures.OnMismatchMode.FAIL
|
|
}
|
|
}
|
|
|
|
task "checkStdlibAbiCompatibility"(type: CompareDistributionSignatures) {
|
|
dependsOn "distRuntime"
|
|
|
|
libraries = CompareDistributionSignatures.Libraries.Standard.INSTANCE
|
|
if (project.hasProperty("anotherDistro")) {
|
|
oldDistribution = project.findProperty("anotherDistro")
|
|
}
|
|
onMismatchMode = CompareDistributionSignatures.OnMismatchMode.FAIL
|
|
}
|