| /* |
| * 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.cpp.CompilationDatabasePlugin |
| 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 |
| import java.util.concurrent.ConcurrentHashMap |
| |
| 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() |
| } |
| gradlePluginPortal() |
| } |
| |
| dependencies { |
| //classpath project(":kotlin-native-utils") |
| classpath 'gradle.plugin.com.github.johnrengelman:shadow:7.1.2' |
| } |
| } |
| 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/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") |
| kotlinReflectModule= project(":kotlin-reflect") |
| kotlinScriptRuntimeModule= project(":kotlin-script-runtime") |
| kotlinUtilKliMetadatabModule= project(":kotlin-util-klib-metadata") |
| |
| konanVersionFull = ext.kotlinNativeVersion |
| gradlePluginVersion = konanVersionFull |
| |
| // A separate map for each build for automatic cleaning the daemon after the build have finished. |
| toolClassLoadersMap = new ConcurrentHashMap<Object, URLClassLoader>() |
| } |
| |
| 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 = org.jetbrains.kotlin.ExecClang.create(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 |
| distPack |
| commonSources |
| } |
| |
| dependencies { |
| ftpAntTask 'org.apache.ant:ant-commons-net:1.9.9' |
| 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" |
| commonSources project(path: ':kotlin-stdlib-common', configuration: 'sources') |
| commonSources project(path: ':kotlin-test:kotlin-test-common', configuration: 'sources') |
| commonSources project(path: ':kotlin-test:kotlin-test-annotations-common', configuration: 'sources') |
| } |
| |
| apply plugin: CompilationDatabasePlugin |
| |
| //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 configurations.commonSources |
| 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) { |
| // Workaround: make distCompiler no-op if we are using custom dist: |
| // the dist is already in place and has the compiler, so we don't have to |
| // build and copy the compiler to dist. |
| // Moreover, if we do copy it, it might overwrite the compiler files already loaded |
| // by this Gradle process (including the jar loaded to the custom classloader), |
| // causing hard-to-debug errors. |
| if (!UtilsKt.isDefaultNativeHome(project)) { |
| enabled = false |
| } else { |
| 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:libllvmext').file('build/libs/llvmext/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" |
| // TODO: add explicit dependency on host task with IR klib stdlib parts |
| // As for now it is possibly to build up distribution from the tc-dist to crossdist |
| // by request of tests that need cross-targets or platform libs. It may create undesired |
| // issues with overwriting the file being used by the concurrent build/test. |
| // This building (by request) should be turned off when this to-do is fixed. |
| // if (target != hostName) { |
| // dependsOn ":kotlin-native:${hostName}CrossDistStdlib" |
| // } |
| |
| destinationDir project.file("$distDir/$stdlib") |
| |
| from(project(':kotlin-native:runtime').file("build/${target}Stdlib")) { |
| if (target == hostName) { |
| include('**') |
| } else { |
| // We don't want to rewrite stdlib parts as they are the same and may be already used |
| // by the other build phases like caching or endorsed libraries. |
| include('*/targets/**') |
| include('*/manifest') |
| } |
| 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 |
| } |
| } |
| |
| 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 |
| } |
| } |
| |
| void configurePackingLicensesToBundle(AbstractArchiveTask task, boolean containsPlatformLibraries) { |
| task.from(project.projectDir) { |
| include 'licenses/**' |
| if (!containsPlatformLibraries || !isMac()) { |
| exclude '**/xcode_license.pdf' |
| } |
| into task.archiveBaseName |
| } |
| |
| task.from(project.rootProject.file("license")) { |
| into "${task.archiveBaseName.get()}/licenses" |
| } |
| } |
| |
| configurePackingLicensesToBundle(bundleRegular, /* containsPlatformLibraries = */ false) |
| configurePackingLicensesToBundle(bundlePrebuilt, /* containsPlatformLibraries = */ true) |
| |
| configure([bundleRegular, bundlePrebuilt]) { |
| dependsOn("crossDist") |
| dependsOn("crossDistStdlibCache") |
| dependsOn("crossDistEndorsedCache") |
| dependsOn("distSources") |
| dependsOn("distDef") |
| from(project.projectDir) { |
| 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.projectDir) { |
| 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") |
| } |
| |
| compilationDatabase { |
| allTargets { |
| mergeFrom(provider { project("common") }) |
| mergeFrom(provider { project("runtime") }) |
| |
| // TODO: Reconsider this |
| task.configure { |
| dependsOn(":kotlin-native:runtime:downloadGoogleTest") |
| } |
| } |
| } |
| |
| tasks.register("compdb", Copy) { |
| from compilationDatabase.hostTarget.task |
| into layout.projectDirectory |
| |
| group = compilationDatabase.TASK_GROUP |
| description = "Copy host compilation database to kotlin-native/" |
| } |
| |
| 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 |
| } |
