cpp.gradle

defineWpiUtilProperties()
defineHALProperties()
defineNetworkTablesProperties()
defineWpiLibProperties()
defineCsCoreProperties()

def cppSetupModel = { project ->
    project.model {
        components {
            sweep(NativeLibrarySpec) {
                targetPlatform 'arm'
                setupDefines(project, binaries)

                binaries.all {
                    tasks.withType(CppCompile) {
                        cppCompiler.args "-DNAMESPACED_WPILIB"
                        addHalLibraryLinks(it, linker, targetPlatform)
                        addWpiUtilLibraryLinks(it, linker, targetPlatform)
                        addNetworkTablesLibraryLinks(it, linker, targetPlatform)
                        addWpilibLibraryLinks(it, linker, targetPlatform)
                        addCsCoreLibraryLinks(it, linker, targetPlatform)
                    }
                }

                sources {
                    cpp {
                        source {
                            srcDirs = [cppSrc, cppLibrarySrc]
                            includes = ["**/*.cpp"]
                        }
                        exportedHeaders {
                            srcDirs = [cppInclude, driverLibraryInclude, cppLibraryInclude, wpilibInclude, halInclude, wpiUtilInclude, netTablesInclude, cscoreInclude]
                            includes = ['**/*.h']
                        }
                        if (useDriver) {
                            lib project: ':arm:driver', library: 'sweepDriver', linkage: 'static'
                        }
                    }
                }
            }
        }
    }
}

ext.mergeStaticSetup = { pjt ->
    if (combineStaticLibs && useDriver) {
        pjt.tasks.whenObjectAdded { task ->
            def name = task.name.toLowerCase()
            if (name.contains('create') && name.contains('staticlibrary')) {
                def libraryPath = task.outputFile.parent
                def library = file(task.outputFile.absolutePath)
                project(':arm:driver').model {
                    binaries {
                        withType(StaticLibraryBinarySpec) { binary ->
                            ext.driverLibrary = new File(binary.staticLibraryFile.absolutePath)
                        }
                    }
                }
                task.doLast {
                    library.renameTo(file("${library}.m"))
                    copy {
                        from driverLibrary
                        into libraryPath
                    }
                    
                    ByteArrayOutputStream mriFile = new ByteArrayOutputStream()
                    mriFile << "create lib${libraryName}.a\n"
                    mriFile << "addlib lib${libraryName}.a.m\n"
                    mriFile << "addlib lib${libraryName}Driver.a\n"
                    mriFile << "save\n"
                    mriFile << "end\n"
                    
                    def stdIn = new ByteArrayInputStream(mriFile.buf)

                    def tool = project(':arm:driver').binTools('ar')
                    
                    exec {
                        standardInput = stdIn
                        workingDir = libraryPath
                        commandLine tool, '-M'
                    }
                }
            }
        }
    }
}

project(':arm:cpp') {
    apply plugin: 'cpp'

    apply from: "${rootDir}/toolchains/arm.gradle"
    
    if (!useDriver) {
        apply from: "${rootDir}/java/java.gradle"
    }

    cppSetupModel(project)
    
    project.debugStripSetup()
    mergeStaticSetup(project)
}