// tag::apply-plugin[]
plugins {
    id 'assembler'
// end::apply-plugin[]
    id 'c'
// tag::apply-plugin[]
}
// end::apply-plugin[]

model {
    platforms {
        x86 {
            architecture "i386"
        }
    }
}

// tag::assembler-args[]
model {
    components {
        main(NativeExecutableSpec) {
            targetPlatform "x86"
            binaries.all {

        public String getNativePrefix() {
            return nativePrefix;
        }

        private String resolveNativePrefix() {
            String arch = System.getProperty("os.arch");
            if ("i386".equals(arch)) {
                arch = "x86";
            }
            return "win32-" + arch;
        }

        @Override
        public String getPathVar() {
            return "Path";
        }

        testApp.plugins.each { plugin ->
            buildFile << "apply plugin: '$plugin'\n"
        }

        buildFile << """
model {
    platforms {
        x86 {
            architecture "i386"
        }
    }
    components {
        main(NativeExecutableSpec) {
            targetPlatform "x86"
            binaries.all {
                linker.args "-v"
            }
        }
    }
}

 * }
 *
 * model {
 *     components {
 *         main(NativeLibrarySpec) {
 *             sources {
 *                 asm {
 *                     source {
 *                         srcDirs "src/main/i386", "src/shared/asm"
 *                         include "**{@literal /}*.s"
 *                     }
 *                 }
 *             }
 *         }
 *     }
 * }
 * </pre>
 */
@Incubating @Managed

                'net/',
                'net/rubygrapefruit/',
                'net/rubygrapefruit/platform/',
                'net/rubygrapefruit/platform/osx-i386/',
                'net/rubygrapefruit/platform/osx-i386/libnative-platform.dylib',
                'org/gradle/reporting/',
                'org/gradle/reporting/report.js',
                'org/joda/',
                'org/joda/time/',

 * Constants for various processor architectures Gradle runs on.
 *
 * @since 7.6
 */
@Incubating
public enum Architecture {
    /**
     * 32-bit complex instruction set computer (CISC) architectures, including "x32", "i386", "x86"..
     */
    X86,

    /**
     * 64-bit variant of the X86 instruction set, including "x64", "x86_64", "amd64", "ia64".
     */
    X86_64,

    /**

class ArchitecturesTest extends Specification {
    def "test 32-bit aliases"() {
        expect:
        Architectures.forInput(architecture).isI386()
        where:
        architecture << [ "x86", "i386", "ia-32", "i686" ]
    }

    def "test 64-bit aliases"() {
        expect:
        Architectures.forInput(architecture).isAmd64()
        where:
        architecture << [ "x86-64", "x86_64", "amd64", "x64" ]

 *
 * <table>
 *     <tr>
 *         <th>Instruction Set</th>
 *         <th>32-bit names</th>
 *         <th>64-bit names</th>
 *     </tr>
 *     <tr>
 *         <td>Intel x86</td>
 *         <td>"x86", "i386", "ia-32", "i686"</td>
 *         <td>"x86_64", "amd64", "x64", "x86-64"</td>
 *     </tr>
 *     <tr>
 *         <td>Intel Itanium</td>
 *         <td>N/A</td>
 *         <td>"ia-64", "ia64"</td>
 *     </tr>

		// native (widest) instruction set on the running kernel:
		out := run("", CheckExit, "isainfo", "-n")
		if strings.Contains(out, "amd64") {
			gohostarch = "amd64"
		}
		if strings.Contains(out, "i386") {
			gohostarch = "386"
		}
	case "windows":
		exe = ".exe"
	}

	sysinit()

	if gohostarch == "" {
		// Default Unix system.
		out := run("", CheckExit, "uname", "-m")

func (a *Arch) InFamily(xs ...ArchFamily) bool {
	for _, x := range xs {
		if a.Family == x {
			return true
		}
	}
	return false
}

var Arch386 = &Arch{
	Name:           "386",
	Family:         I386,
	ByteOrder:      binary.LittleEndian,
	PtrSize:        4,
	RegSize:        4,
	MinLC:          1,
	Alignment:      1,
	CanMergeLoads:  true,
	HasLR:          false,
	FixedFrameSize: 0,
}