kotlin-fork/kotlin-native/tools/benchmarksAnalyzer/build.gradle

import org.jetbrains.kotlin.gradle.dsl.JsMainFunctionExecutionMode
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
import org.jetbrains.kotlin.konan.target.HostManager
import org.jetbrains.kotlin.UtilsKt

buildscript {
    ext.rootBuildDirectory = file('../..')

    ext {
        def properties = new java.util.Properties()
        properties.load(new java.io.FileReader(project.file("$rootBuildDirectory/../gradle.properties")))
        properties.each { k, v ->
            def key = k as String
            def value = project.findProperty(key) ?: v
            project.logger.info("${project.name} $key: $value")
            set(key, value)
        }
    }
    ext["withoutEmbedabble"] = true
    UtilsKt.kotlinInit(project, findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() ?: false)
    ext["bootstrapKotlinRepo"] = BootstrapKt.getBootstrapKotlinRepo(project)
    ext["bootstrapKotlinVersion"] = BootstrapKt.getBootstrapKotlinVersion(project)
    ext["kotlinVersion"] = project.bootstrapKotlinVersion

    apply from: "$rootBuildDirectory/gradle/loadRootProperties.gradle"
    apply from: "$rootBuildDirectory/gradle/kotlinGradlePlugin.gradle"
}

plugins {
    id("org.jetbrains.kotlin.multiplatform")
}

repositories {
    mavenCentral()
}

def getHostName() {
    def target = System.getProperty("os.name")
    if (target == 'Linux') return 'linux'
    if (target.startsWith('Windows')) return 'windows'
    if (target.startsWith('Mac'))
        if (System.getProperty("os.arch") == "aarch64")
            return 'macosArm64'
        else
            return 'macosX64'
    return 'unknown'
}

kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
            }
            kotlin.srcDir '../benchmarks/shared/src'
            kotlin.srcDir 'src/main/kotlin'
            kotlin.srcDir '../../endorsedLibraries/kotlinx.cli/src/main/kotlin'
        }
        commonTest {
            dependencies {
                implementation "org.jetbrains.kotlin:kotlin-test:$kotlinVersion"
            }
            kotlin.srcDir 'src/tests'
        }
        jvmTest {
        }
        jsTest {
        }
        nativeMain {
            dependsOn commonMain
            kotlin.srcDir 'src/main/kotlin-native'
            kotlin.srcDir '../../endorsedLibraries/kotlinx.cli/src/main/kotlin-native'
        }
        jvmMain {
            kotlin.srcDir 'src/main/kotlin-jvm'
            kotlin.srcDir '../../endorsedLibraries/kotlinx.cli/src/main/kotlin-jvm'
        }
        jsMain {
            kotlin.srcDir 'src/main/kotlin-js'
            kotlin.srcDir '../../endorsedLibraries/kotlinx.cli/src/main/kotlin-js'
        }
        linuxMain { dependsOn nativeMain }
        windowsMain { dependsOn nativeMain }
        macosX64Main { dependsOn nativeMain }
        macosArm64Main { dependsOn nativeMain }
    }

    targets {
        fromPreset(presets.jvm, 'jvm') {
            compilations.all {
                compileTaskProvider.configure {
                    compilerOptions {
                        jvmTarget = JvmTarget.JVM_1_8
                        suppressWarnings = true
                    }
                }
            }
        }

        if (HostManager.hostIsMingw) {
            fromPreset(presets.mingwX64, 'windows') {
                binaries.all {
                    linkerOpts = ["-L${getMingwPath()}/lib".toString()]
                }
                compilations.main.cinterops {
                    libcurl {
                        includeDirs.headerFilterOnly "${getMingwPath()}/include"
                    }
                }
            }
        }

        if (HostManager.hostIsLinux) {
            fromPreset(presets.linuxX64, 'linux') {
                compilations.main.cinterops {
                    libcurl {
                        includeDirs.headerFilterOnly '/usr/include', '/usr/include/x86_64-linux-gnu'
                    }
                }
            }
        }

        if (HostManager.hostIsMac) {
            fromPreset(presets.macosX64, 'macosX64') {
                compilations.main.cinterops {
                    libcurl {
                        includeDirs.headerFilterOnly '/opt/local/include', '/usr/local/include'
                    }
                }
            }
            fromPreset(presets.macosArm64, 'macosArm64') {
                compilations.main.cinterops {
                    libcurl {
                        includeDirs.headerFilterOnly '/opt/local/include', '/usr/local/include'
                    }
                }
            }
        }
        fromPreset(presets.js, 'js') {
            compilations.main.compileTaskProvider.configure {
                compilerOptions.main = JsMainFunctionExecutionMode.NO_CALL
            }
        }

        configure([findByName('windows'), findByName('linux'), findByName('macosX64'), findByName('macosArm64')].findAll { it != null }) {
            def isCurrentHost = (name == getHostName())
            compilations.all {
                cinterops.all {
                    project.tasks[interopProcessingTaskName].enabled = isCurrentHost
                }
                compileKotlinTask.enabled = isCurrentHost
            }
            binaries.all {
                linkTask.enabled = isCurrentHost
            }

            binaries {
                executable('benchmarksAnalyzer', [RELEASE]) {
                    if (org.gradle.internal.os.OperatingSystem.current().isWindows()) {
                        linkerOpts("-L${getMingwPath()}/lib")
                    }
                }
            }
        }
    }

    js {
        browser {
            distribution {
                directory = new File("$projectDir/web/")
            }
            dceTask {
                keep 'benchmarksAnalyzer.main_kand9s$'
            }
        }
    }
}

def getMingwPath() {
    def directory = System.getenv("MINGW64_DIR")
    if (directory == null)
        directory = "c:/msys64/mingw64"
    return directory
}

tasks.register("assembleWeb", Sync) {
    def runtimeDependencies = kotlin.targets.js.compilations.main.runtimeDependencyFiles
    from(files {
        runtimeDependencies.collect { File file ->
            zipTree(file.absolutePath)
        }
    }.builtBy(runtimeDependencies)) {
        includeEmptyDirs = false
        include { fileTreeElement ->
            def path = fileTreeElement.path
            path.endsWith(".js") && (path.startsWith("META-INF/resources/") ||
                    !path.startsWith("META-INF/"))
        }
    }

    from compileKotlinJs.destinationDirectory
    into "${projectDir}/web"
}