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) {

			t.Fatal(err)
		}
		return out
	}

	// Build a shared library that defines a symbol whose name
	// contains magicInput.

	cShared := cCompile("-shared", "c.so", cDefFile)

	// Build an object file that refers to the symbol whose name
	// contains magicInput.

	cObj := cCompile("-c", "c.o", cRefFile)

	// Rewrite the shared library and the object file, replacing
	// magicInput with magicReplace. This will have the effect of

	p := a.Package
	return b.ccompile(a, out, flags, cxxfile, b.GxxCmd(p.Dir, workdir))
}

// gfortran runs the gfortran Fortran compiler to create an object from a single Fortran file.
func (b *Builder) gfortran(a *Action, workdir, out string, flags []string, ffile string) error {
	p := a.Package
	return b.ccompile(a, out, flags, ffile, b.gfortranCmd(p.Dir, workdir))
}

    link:{groovyDslPath}/org.gradle.api.tasks.scala.ScalaDoc.html[ScalaDoc]
* Native toolchain:
    link:{javadocPath}/org/gradle/language/cpp/tasks/CppCompile.html[CppCompile],
    link:{javadocPath}/org/gradle/language/c/tasks/CCompile.html[CCompile],
    link:{javadocPath}/org/gradle/language/swift/tasks/SwiftCompile.html[SwiftCompile]
* Testing:
    link:{groovyDslPath}/org.gradle.api.tasks.testing.Test.html[Test]