import org.gradle.integtests.fixtures.SourceFile

import static org.gradle.nativeplatform.fixtures.app.SourceFileElement.ofFile

class CppGreeterWithOptionalFeature extends CppLibraryElement implements GreeterElement {
    final SourceFileElement header = ofFile(new SourceFile("headers", "greeter.h", """
#ifdef _WIN32
#define EXPORT_FUNC __declspec(dllexport)
#else
#define EXPORT_FUNC
#endif

class CppAlternateSourceGreeterFunction extends CppGreeterFunction {
    final SourceFileElement source

    @Override
    SourceElement getSources() {
        return source
    }

    CppAlternateSourceGreeterFunction(String publicHeaderDir = "headers") {
        super(publicHeaderDir)

        source = ofFile(sourceFile("cpp", "greeter.cpp", """
#include <iostream>

class CppAlternateHeaderGreeterFunction extends CppGreeterFunction {
    final SourceFileElement header

    @Override
    SourceElement getPublicHeaders() {
        return header
    }

    CppAlternateHeaderGreeterFunction(String publicHeaderDir = "headers") {
        super(publicHeaderDir)
        header = ofFile(sourceFile(publicHeaderDir, "greeter.h", """

import java.util.List;

/**
 * A single source file.
 */
public abstract class SourceFileElement extends SourceElement {
    public abstract SourceFile getSourceFile();

    @Override
    public List<SourceFile> getFiles() {
        return Collections.singletonList(getSourceFile());
    }

    public static SourceFileElement ofFile(final SourceFile file) {
        return new SourceFileElement() {
            @Override

func (tools gccgoToolchain) asm(b *Builder, a *Action, sfiles []string) ([]string, error) {
	p := a.Package
	var ofiles []string
	for _, sfile := range sfiles {
		base := filepath.Base(sfile)
		ofile := a.Objdir + base[:len(base)-len(".s")] + ".o"
		ofiles = append(ofiles, ofile)
		sfile, _ = fsys.OverlayPath(mkAbs(p.Dir, sfile))
		defs := []string{"-D", "GOOS_" + cfg.Goos, "-D", "GOARCH_" + cfg.Goarch}

	p := a.Package
	args := asmArgs(a, p)

	var ofiles []string
	for _, sfile := range sfiles {
		overlayPath, _ := fsys.OverlayPath(mkAbs(p.Dir, sfile))
		ofile := a.Objdir + sfile[:len(sfile)-len(".s")] + ".o"
		ofiles = append(ofiles, ofile)
		args1 := append(args, "-o", ofile, overlayPath)
		if err := b.Shell(a).run(p.Dir, p.ImportPath, nil, args1...); err != nil {
			return nil, err

			t.Fatalf("gccgo %s failed: %s", gofile, err)
		}

		runImporterTest(t, imp, initmap, &test)

		cmd = testenv.Command(t, "ar", "cr", afile, ofile)
		out, err = cmd.CombinedOutput()
		if err != nil {
			t.Logf("%s", out)
			t.Fatalf("ar cr %s %s failed: %s", afile, ofile, err)
		}

		runImporterTest(t, arimp, arinitmap, &test)

		if err = os.Remove(ofile); err != nil {
			t.Fatal(err)
		}

	Library string
}

// FileHeader holds information about an XCOFF file header.
type FileHeader struct {
	TargetMachine uint16
}

// A File represents an open XCOFF file.
type File struct {
	FileHeader
	Sections     []*Section
	Symbols      []*Symbol
	StringTable  []byte
	LibraryPaths []string

	closer io.Closer
}

// Open opens the named file using os.Open and prepares it for use as an XCOFF binary.

	}

	cxxflags := str.StringList(cgoCPPFLAGS, cgoCXXFLAGS)
	for _, file := range gxxfiles {
		ofile := nextOfile()
		if err := b.gxx(a, a.Objdir, ofile, cxxflags, file); err != nil {
			return nil, nil, err
		}
		outObj = append(outObj, ofile)
	}

	for _, file := range mfiles {
		ofile := nextOfile()
		if err := b.gcc(a, a.Objdir, ofile, cflags, file); err != nil {

Ilya Kirillov <******@****.***> 1637343566 +0100