binaries.all {
                if (flavor == flavors.french) {
                    cppCompiler.define "FRENCH"
                }
            }
        }
    }
}
// end::flavors[]

model {
    binaries {
        withType(SharedLibraryBinarySpec) {
            cppCompiler.define "DLL_EXPORT"
        }
    }
    components {
        main(NativeExecutableSpec) {

model {
    components {
        main(NativeExecutableSpec) {
            binaries.all {
                // Define a preprocessor macro
                cppCompiler.define "NDEBUG"
                // Add some additional compiler arguments
                if (toolChain in Gcc) {
                    cppCompiler.args "-fno-access-control", "-fconserve-space"
                }
            }
        }
    }
    tasks { t ->

        targetBinary.cleanTaskPath == ":project-path:clean"
    }

    def "compiler defines are taken from cpp compiler configuration"() {
        when:
        cppCompiler.macros >> [foo: "bar", empty: null]
        exeBinary.getToolByName("cppCompiler") >> cppCompiler

        then:
        targetBinary.compilerDefines == ["foo=bar", "empty"]
    }

    def "compiler defines are taken from c compiler configuration"() {

        debugX86Binary.compilationDetails.macroUndefines.empty
        debugX86Binary.compilationDetails.additionalArgs.empty
        debugX86Binary.compilationDetails.compilerExecutable.name == toolchain.cppCompiler.name
        debugX86Binary.compilationDetails.compileWorkingDir == projectDir.file("build/obj/main/debug/x86")
        debugX86Binary.compilationDetails.compileTask.path == ":compileDebugX86Cpp"

        helloWorldApp.writeSources(file("src/main"))
        buildFile << """
apply plugin: 'cpp'

model {
    toolChains {
        ${toolChain.id} {
            eachPlatform {
                cppCompiler.withArguments { args ->
                    Collections.replaceAll(args, "CUSTOM", "-DFRENCH")
                }
                linker.withArguments { args ->
                    args.remove "CUSTOM"
                }

        when:
        buildFile << """
model {
    toolChains {
        ${toolChain.id} {
            eachPlatform {
                cppCompiler.executable = 'does-not-exist'
            }
        }
    }
}
"""
        succeeds "mainExecutable"

        then:
        executable("build/exe/main/main").exec().out == helloWorldApp.englishOutput

model {
    components {
        main(NativeLibrarySpec) {
            binaries.withType(SharedLibraryBinarySpec) {
                // Define a preprocessor macro that only applies to shared libraries
                cppCompiler.define "DLL_EXPORT"
            }
        }
    }
}

plugins {
    id 'cpp'
}

// tag::targetplatforms[]
model {
    toolChains {
        gcc(Gcc) {
            target("arm"){
                cppCompiler.withArguments { args ->
                    args << "-m32"
                }
                linker.withArguments { args ->
                    args << "-m32"
                }
            }
            target("sparc")
        }
    }
    platforms {
        arm {

    private final Map<String, Tool> toolsByName = ImmutableMap.<String, Tool>builder()
            .put("assembler", assembler)
            .put("cCompiler", cCompiler)
            .put("cppCompiler", cppCompiler)
            .put("objcCompiler", objcCompiler)
            .put("objcppCompiler", objcppCompiler)
            .put("rcCompiler", rcCompiler)
            .build();

    private PlatformToolProvider toolProvider;

                    withType(GoogleTestTestSuiteBinarySpec) {
                        lib library: "googleTest", linkage: "static"
                        if (targetPlatform.operatingSystem.linux) {
                            cppCompiler.args '-pthread'
                            linker.args '-pthread'
                        }