*/

package org.gradle.tooling.model.cpp;

import javax.annotation.Nullable;

/**
 * Represent a macro directive.
 *
 * @since 4.10
 */
public interface MacroDirective {
    /**
     * Returns the name of the macro.
     */
    String getName();

    /**
     * Returns the value of the macro, if any.
     */
    @Nullable
    String getValue();

    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();
    boolean hasMacroFunctions();

    /**

	return Token{ScanToken: token, text: text}
}

func (l Token) String() string {
	return l.text
}

// A Macro represents the definition of a #defined macro.
type Macro struct {
	name   string   // The #define name.
	args   []string // Formal arguments.
	tokens []Token  // Body of macro.
}

// Tokenize turns a string into a list of Tokens; used to parse the -D flag and in tests.

// Parameters:
//   statement -  A statement that a macro such as EXPECT_DEATH would test
//                for program termination. This macro has to make sure this
//                statement is compiled but not executed, to ensure that
//                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
//                parameter iff EXPECT_DEATH compiles with it.
//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test

    /**
     * When type is {@link IncludeType#QUOTED} or {@link IncludeType#SYSTEM}, then this returns the path, without the delimiters or escape characters.
     * When type is {@link IncludeType#MACRO} or {@link IncludeType#MACRO_FUNCTION}, then this returns the name of the macro.
     * When type is {@link IncludeType#IDENTIFIER} or {@link IncludeType#TOKEN}, then this returns the token.
     * When type anything else, returns null.
     */
    @Nullable

            parseMacroFunctionDirectiveBody(buffer, name, macroFunctions);
        } else {
            // An object-like macro
            parseMacroObjectDirectiveBody(buffer, name, macros);
        }
    }

    /**
     * Parse an "object-like" macro directive body. Consumes all input.
     */
    private void parseMacroObjectDirectiveBody(Buffer buffer, String macroName, Collection<Macro> macros) {

//   - You cannot stream a failure message to this macro.
//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works.  If we do that, the code won't compile when the user gives
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that

//   - You cannot stream a failure message to this macro.
//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works.  If we do that, the code won't compile when the user gives
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that

    /**
     * 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);

    /**
     * Defines a named preprocessor macro with a value, which will be used when compiling this binary.
     * The macro will be supplied to the compiler as '-D name=definition'.
     */
    void define(String name, String definition);

        boolean found = false;
        for (IncludeDirectives includeDirectives : visibleMacros) {
            Iterable<Macro> macros = includeDirectives.getMacros(expression.getValue());
            for (Macro macro : macros) {
                found = true;
                resolveExpression(visibleMacros, macro, visitor, tokenLookup);
            }
        }
        if (!found) {