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

package org.gradle.language.nativeplatform.internal;

public enum IncludeType {
    /**
     * A system include path, eg {@code <hello.h>}
     */
    SYSTEM,
    /**
     * A quoted include path eg {@code "hello.h"}
     */
    QUOTED,
    /**

            return;
        }
        Expression expression = parseDirectiveBodyExpression(buffer);
        if (expression.getType() == IncludeType.TOKEN_CONCATENATION || expression.getType() == IncludeType.ARGS_LIST || expression.getType() == IncludeType.EXPRESSIONS) {
            // Token concatenation is only allowed inside a #define body
            // Arbitrary tokens won't resolve to an include path

     */
    String getAsSourceText();

    IncludeType getType();

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

    static final int REPLACE_ARGS = -2;
    private final int[] argsMap;
    private final IncludeType type;
    private final String value;
    private final List<Expression> arguments;

    public ArgsMappingMacroFunction(String macroName, int parameters, int[] argsMap, IncludeType type,  String value, List<Expression> arguments) {
        super(macroName, parameters);
        this.argsMap = argsMap;

    }

    static Expression asMacroExpansion(Expression expression) {
        if (expression.getType() == IncludeType.IDENTIFIER) {
            return new SimpleExpression(expression.getValue(), IncludeType.MACRO);
        }
        if (expression.getType() == IncludeType.TOKEN_CONCATENATION) {
            return new ComplexExpression(IncludeType.EXPAND_TOKEN_CONCATENATION, expression.getValue(), expression.getArguments());
        }

        def expression2 = new ComplexExpression(IncludeType.MACRO_FUNCTION, "X", [new SimpleExpression("Y", IncludeType.MACRO), new SimpleExpression("Z", IncludeType.MACRO)])
        def expression3 = new ComplexExpression(IncludeType.TOKEN_CONCATENATION, null, [new SimpleExpression("X", IncludeType.IDENTIFIER), new SimpleExpression("Y", IncludeType.IDENTIFIER)])

        this.name = name;
        this.isImport = isImport;
        this.arguments = arguments;
    }

    @Override
    public IncludeType getType() {
        return IncludeType.MACRO_FUNCTION;
    }

    @Override
    public String getValue() {
        return name;
    }

    @Override
    public boolean isImport() {
        return isImport;
    }

import org.gradle.language.nativeplatform.internal.IncludeType;

import javax.annotation.Nullable;

/**
 * An "object-like" macro #define whose body is an expression with no arguments.
 */
public class MacroWithSimpleExpression extends AbstractMacro {
    private final IncludeType includeType;
    private final String value;

    public MacroWithSimpleExpression(String name, IncludeType includeType, @Nullable String value) {
        super(name);

    static final Expression COMMA = new SimpleExpression(",", IncludeType.TOKEN);
    static final Expression RIGHT_PAREN = new SimpleExpression(")", IncludeType.TOKEN);

    private final String value;
    private final IncludeType type;

    public SimpleExpression(@Nullable String value, IncludeType type) {
        this.value = value;
        this.type = type;
    }

    @Override

import org.gradle.language.nativeplatform.internal.IncludeType;

/**
 * A macro function whose body cannot be resolved.
 */
public class UnresolvableMacro extends AbstractMacro {
    public UnresolvableMacro(String name) {
        super(name);
    }

    @Override
    public IncludeType getType() {
        return IncludeType.OTHER;
    }

    @Override
    public String getValue() {