List<Include> getQuotedIncludes();
    List<Include> getSystemIncludes();
    List<Include> getMacroIncludes();
    List<Include> getAll();
    List<Include> getIncludesOnly();

    Iterable<Macro> getMacros(String name);
    Iterable<MacroFunction> getMacroFunctions(String name);

    Collection<Macro> getAllMacros();
    Collection<MacroFunction> getAllMacroFunctions();

    boolean hasMacros();

    private List<DefaultMacroDirective> macroDefines(CppCompile compileTask) {
        if (compileTask.getMacros().isEmpty()) {
            return Collections.emptyList();
        }
        List<DefaultMacroDirective> macros = new ArrayList<DefaultMacroDirective>(compileTask.getMacros().size());
        for (Map.Entry<String, String> entry : compileTask.getMacros().entrySet()) {
            macros.add(new DefaultMacroDirective(entry.getKey(), entry.getValue()));

    List<File> getRemovedSourceFiles();

    void setRemovedSourceFiles(Collection<File> sources);

    void removedSource(Iterable<File> sources);

    Map<String, String> getMacros();

    void setMacros(Map<String, String> macros);

    void define(String name);

    void define(String name, String value);

    boolean isPositionIndependentCode();

@Incubating
public interface PreprocessingTool extends Tool {
    /**
     * The set of preprocessor macros to define when compiling this binary.
     */
    Map<String, String> getMacros();

    /**
     * Defines a named preprocessor macros to use when compiling this binary.
     * The macro will be supplied to the compiler as '-D name'.
     */
    void define(String name);

    /**

        def expectedArgs = getCompilerSpecificArguments(includeDir, systemIncludeDir)

        when:
        NativeCompileSpec compileSpec = Stub(getCompileSpecType()) {
            getMacros() >> [foo: "bar", empty: null]
            getAllArgs() >> ["-firstArg", "-secondArg"]
            getIncludeRoots() >> [includeDir]
            getSystemIncludeRoots() >> [systemIncludeDir]

public class DefaultPreprocessingTool extends DefaultTool implements PreprocessingTool {
    private final Map<String, String> definitions = new LinkedHashMap<String, String>();

    @Override
    public Map<String, String> getMacros() {
        return definitions;
    }

    @Override
    public void define(String name) {
        definitions.put(name, null);
    }

    @Override

        spec.setTempDir(getTemporaryDir());
        spec.setObjectFileDir(getOutputDir());
        spec.include(getIncludes());
        spec.source(getSource());
        spec.setMacros(getMacros());
        spec.args(getCompilerArgs().get());
        spec.setIncrementalCompile(inputs.isIncremental());
        spec.setOperationLogger(operationLogger);

            args.add(file.getAbsolutePath());
        }
    }

    protected void addMacroArgs(T spec, List<String> args) {
        for (String macroArg : new MacroArgsConverter().transform(spec.getMacros())) {
            args.add("-D" + macroArg);
        }
    }

    protected void addUserArgs(T spec, List<String> args) {
        args.addAll(spec.getAllArgs());
    }

            args.add("/I" + file.getAbsolutePath());
        }
    }

    protected void addMacroArgs(T spec, List<String> args) {
        for (String macroArg : new MacroArgsConverter().transform(spec.getMacros())) {
            args.add(escapeUserArg("/D" + macroArg));
        }
    }

    /**
     * Returns compiler specific language option

        spec.setObjectFileDir(objectFileDir.get().getAsFile());
        spec.include(includes);
        spec.systemInclude(systemIncludes);
        spec.source(getSource());
        spec.setMacros(getMacros());
        spec.args(getCompilerArgs().get());
        spec.setPositionIndependentCode(isPositionIndependentCode());
        spec.setDebuggable(isDebuggable());
        spec.setOptimized(isOptimized());