* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.language.nativeplatform.internal;

/**
 * An 'object-like' macro definition.
 */
public interface Macro extends Expression {
    String getName();

        def include4 = new IncludeWithMacroFunctionCallExpression("A", true, ImmutableList.of(new SimpleExpression("X", IncludeType.MACRO)))
        def include5 = new IncludeWithMacroFunctionCallExpression("A", true, ImmutableList.of(new SimpleExpression("X", IncludeType.MACRO), new SimpleExpression("Y", IncludeType.MACRO)))

     */
    SYSTEM,
    /**
     * A quoted include path eg {@code "hello.h"}
     */
    QUOTED,
    /**
     * An identifier that should be macro expanded. These appear in the body of a directive eg {@code #define HEADER ABC}.
     */
    MACRO,
    /**
     * A macro function invocation that should be expanded. These appear in the body of a directive and as arguments to another function eg {@code #define HEADER ABC(X, Y)}.
     */

	{
		"define without value",
		"#define A",
		"",
	},
	{
		"macro without arguments",
		"#define A() 1234\n" + "A()\n",
		"1234.\n",
	},
	{
		"macro with just parens as body",
		"#define A () \n" + "A\n",
		"(.).\n",
	},
	{
		"macro with parens but no arguments",
		"#define A (x) \n" + "A\n",
		"(.x.).\n",
	},
	{
		"macro with arguments",
		"#define A(x, y, z) x+z+y\n" + "A(1, 2, 3)\n",

    private final ImmutableList<Include> allIncludes;
    private final ImmutableListMultimap<String, Macro> macros;
    private final ImmutableListMultimap<String, MacroFunction> macroFunctions;

    public static IncludeDirectives of(ImmutableList<Include> allIncludes, ImmutableList<Macro> macros, ImmutableList<MacroFunction> macroFunctions) {
        if (allIncludes.isEmpty() && macros.isEmpty() && macroFunctions.isEmpty()) {

 */

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.

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

//   - 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