config.gradle

import edu.wpi.first.nativeutils.*
import org.gradle.internal.os.OperatingSystem

def windowsCompilerArgs = ['/EHsc', '/DNOMINMAX', '/Zi', '/FS', '/Zc:inline', '/MT']
def windowsReleaseCompilerArgs = ['/O2']
def windowsLinkerArgs = [ '/DEBUG:FULL' ]
def windowsReleaseLinkerArgs = [ '/OPT:REF', '/OPT:ICF' ]

def linuxCompilerArgs = ['-std=c++11', '-Wformat=2', '-Wall', '-Wextra', '-Werror', '-pedantic', '-Wno-psabi', '-g',
                         '-Wno-unused-parameter', '-fPIC', '-rdynamic', '-Wno-error=deprecated-declarations', '-pthread']
def linuxLinkerArgs = ['-rdynamic', '-pthread']
def linuxReleaseCompilerArgs = ['-Og']
def linuxDebugCompilerArgs = ['-O0']
def linux32BitArg = '-m32'

def macCompilerArgs =  ['-std=c++11', '-Wall', '-Wextra', '-Werror', '-pedantic-errors', '-fPIC', '-g',
                            '-Wno-unused-parameter', '-Wno-missing-field-initializers', '-Wno-unused-private-field']
def macReleaseCompilerArgs = ['-O2']
def macDebugCompilerArgs = ['-O0']
def mac32BitArg = '-m32'

def buildAll = project.hasProperty('buildAll')

def windows64PlatformDetect = {
    def arch = System.getProperty("os.arch")
    def isWin = OperatingSystem.current().isWindows()
    if (buildAll) {
        return isWin
    } else {
        return isWin && arch == 'amd64'
    }
}

def windows32PlatformDetect = {
    def arch = System.getProperty("os.arch")
    def isWin = OperatingSystem.current().isWindows()
    if (buildAll) {
        return isWin
    } else {
        return isWin && arch == 'x86'
    }
}

def linux32IntelPlatformDetect = {
    def arch = System.getProperty("os.arch")
    def isLinux = OperatingSystem.current().isLinux()
    def isIntel = (arch == 'amd64' || arch == 'i386')
    if (buildAll) {
        return isLinux && isIntel
    } else {
        return isLinux && arch == 'i386'
    }
}

def linux64IntelPlatformDetect = {
    def arch = System.getProperty("os.arch")
    def isLinux = OperatingSystem.current().isLinux()
    def isIntel = (arch == 'amd64' || arch == 'i386')
    if (buildAll) {
        return isLinux && isIntel
    } else {
        return isLinux && arch == 'amd64'
    }
}

def linuxArmPlatformDetect = {
    def arch = System.getProperty("os.arch")
    def isIntel = (arch == 'amd64' || arch == 'i386')
    return OperatingSystem.current().isLinux() && !isIntel
}

def mac64PlatformDetect = {
    def arch = System.getProperty("os.arch")
    def isMac = OperatingSystem.current().isMacOsX()
    if (buildAll) {
        return isMac
    } else {
        return isMac && arch == 'x86_64'
    }
}

def mac32PlatformDetect = {
    def arch = System.getProperty("os.arch")
    def isMac = OperatingSystem.current().isMacOsX()
    if (buildAll) {
        return isMac
    } else {
        return isMac && arch == 'x86'
    }
}

if (!project.hasProperty('skipAthena')) {
    model {
        buildConfigs {
                roboRio(CrossBuildConfig) {
                architecture = 'athena'
                operatingSystem = 'linux'
                toolChainPrefix = 'arm-frc-linux-gnueabi-'
                compilerArgs = linuxCompilerArgs
                linkerArgs = linuxLinkerArgs
                debugCompilerArgs = linuxDebugCompilerArgs
                releaseCompilerArgs = linuxReleaseCompilerArgs
                releaseStripBinaries = true
                compilerFamily = 'Gcc'
                exclude << 'gmock'
                exclude << 'wpiutilTestingBase'
            }
        }
    }
}

if (!project.hasProperty('onlyAthena')) {
    model {
        buildConfigs {
            winX86(BuildConfig) {
                architecture = 'x86'
                operatingSystem = 'windows'
                compilerArgs = windowsCompilerArgs
                linkerArgs = windowsLinkerArgs
                releaseCompilerArgs = windowsReleaseCompilerArgs
                releaseLinkerArgs = windowsReleaseLinkerArgs
                compilerFamily = 'VisualCpp'
                detectPlatform = windows32PlatformDetect
            }
            winX64(BuildConfig) {
                architecture = 'x86-64'
                operatingSystem = 'windows'
                compilerArgs = windowsCompilerArgs
                linkerArgs = windowsLinkerArgs
                releaseCompilerArgs = windowsReleaseCompilerArgs
                releaseLinkerArgs = windowsReleaseLinkerArgs
                compilerFamily = 'VisualCpp'
                detectPlatform = windows64PlatformDetect
            }
            linuxX86(BuildConfig) {
                architecture = 'x86'
                operatingSystem = 'linux'
                compilerArgs = linuxCompilerArgs
                compilerArgs << linux32BitArg
                linkerArgs = linuxLinkerArgs
                linkerArgs << linux32BitArg
                debugCompilerArgs = linuxDebugCompilerArgs
                releaseCompilerArgs = linuxReleaseCompilerArgs
                releaseStripBinaries = true
                compilerFamily = 'Gcc'
                detectPlatform = linux32IntelPlatformDetect
            }
            linuxX64(BuildConfig) {
                architecture = 'x86-64'
                operatingSystem = 'linux'
                compilerArgs = linuxCompilerArgs
                linkerArgs = linuxLinkerArgs
                debugCompilerArgs = linuxDebugCompilerArgs
                releaseCompilerArgs = linuxReleaseCompilerArgs
                releaseStripBinaries = true
                compilerFamily = 'Gcc'
                detectPlatform = linux64IntelPlatformDetect
            }
            /* 32 bit Mac OS X not supported by OpenCV.
             * If support is ever added, will add this back in
            macX86(BuildConfig) {
                architecture = 'x86'
                operatingSystem = 'osx'
                compilerArgs = macCompilerArgs
                compilerArgs << mac32BitArg
                linkerArgs << mac32BitArg
                debugCompilerArgs = macDebugCompilerArgs
                releaseCompilerArgs = macReleaseCompilerArgs
                releaseStripBinaries = true
                compilerFamily = 'Clang'
                detectPlatform = mac32PlatformDetect
            }
            */
            macX64(BuildConfig) {
                architecture = 'x86-64'
                operatingSystem = 'osx'
                compilerArgs = macCompilerArgs
                debugCompilerArgs = macDebugCompilerArgs
                releaseCompilerArgs = macReleaseCompilerArgs
                releaseStripBinaries = true
                compilerFamily = 'Clang'
                detectPlatform = mac64PlatformDetect
            }
        }
    }
}

if (project.hasProperty('linuxCross')) {
    model {
        buildConfigs {
            linuxArm(CrossBuildConfig) {
                architecture = 'nativearm'
                operatingSystem = 'linux'
                toolChainPrefix = 'PLEASE_PROVIDE_A_COMPILER_NAME'
                compilerArgs = linuxCompilerArgs
                linkerArgs = linuxLinkerArgs
                debugCompilerArgs = linuxDebugCompilerArgs
                releaseCompilerArgs = linuxReleaseCompilerArgs
                releaseStripBinaries = true
                skipByDefault = true
                compilerFamily = 'Gcc'
                exclude << 'gmock'
            }
        }
    }
} else {
    model {
        buildConfigs {
            linuxArm(BuildConfig) {
                architecture = 'nativearm'
                operatingSystem = 'linux'
                compilerArgs = linuxCompilerArgs
                linkerArgs = linuxLinkerArgs
                debugCompilerArgs = linuxDebugCompilerArgs
                releaseCompilerArgs = linuxReleaseCompilerArgs
                releaseStripBinaries = true
                compilerFamily = 'Gcc'
                detectPlatform = linuxArmPlatformDetect
            }
        }
    }
}