import org.gradle.language.nativeplatform.tasks.AbstractNativeSourceCompileTask;
import org.gradle.nativeplatform.toolchain.internal.NativeCompileSpec;

/**
 * Compiles C source files into object files.
 */
@Incubating
@CacheableTask
public abstract class CCompile extends AbstractNativeSourceCompileTask {
    @Override
    protected NativeCompileSpec createCompileSpec() {
        return new DefaultCCompileSpec();
    }

Laura Kassovic <******@****.***> 1701107622 -0800

        def result = Mock(WorkResult)

        when:
        cCompile.toolChain = toolChain
        cCompile.targetPlatform = platform
        cCompile.compilerArgs = ["arg"]
        cCompile.macros = [def: "value"]
        cCompile.objectFileDir = temporaryFolder.file("outputFile")
        cCompile.source sourceFile
        cCompile.setPreCompiledHeader pch
        execute(cCompile)

        then:
        _ * toolChain.outputType >> "c"

import org.gradle.api.Task
import org.gradle.language.AbstractNativeComponentPluginTest
import org.gradle.language.base.LanguageSourceSet
import org.gradle.language.c.CSourceSet
import org.gradle.language.c.tasks.CCompile

class CPluginTest extends AbstractNativeComponentPluginTest {
   @Override
    Class<? extends Plugin> getPluginClass() {
        return CPlugin
    }

    @Override

            tools.put("cCompiler", DefaultPreprocessingTool.class);
            return tools;
        }

        @Override
        public String getLanguageName() {
            return "c";
        }

        @Override
        public ToolType getToolType() {
            return ToolType.C_COMPILER;
        }

        @Override

        buildFile << """
            // prevent assembly and c compile tasks from running in parallel
            // this is because we don't want the c compile tasks to accidentally use
            // the decorated tool provider we set up for testing the parallelism
            tasks.withType(CCompile) { mustRunAfter tasks.withType(Assemble) }
        """

        when:

 *
 * <ul>
 * <li>Creates a {@link org.gradle.language.c.tasks.CCompile} task for each {@link org.gradle.language.c.CSourceSet} to compile the C sources.</li>
 * </ul>
 */
@Incubating
public abstract class CPlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {

	return &compiler{
		varEnvs: mustBuildEnvs(env),
	}
}

// CompileClaimsExpression compiles the given expressionAccessor into a CEL program that can be evaluated.
// The claims CEL variable is available to the expression.
func (c compiler) CompileClaimsExpression(expressionAccessor ExpressionAccessor) (CompilationResult, error) {
	return c.compile(expressionAccessor, claimsVarName)
}

type Compiler interface {
	CompileCELExpression(expressionAccessor ExpressionAccessor) (CompilationResult, error)
}

type compiler struct {
	envSet *environment.EnvSet
}

// NewCompiler returns a new Compiler.
func NewCompiler(env *environment.EnvSet) Compiler {
	return &compiler{
		envSet: mustBuildEnv(env),
	}
}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.language.base.internal.compile;

import org.gradle.api.tasks.WorkResult;

public interface Compiler<T extends CompileSpec> {
    WorkResult execute(T spec);