//go:cgo_import_dynamic _NSGetEnviron _NSGetEnviron ""
//go:cgo_import_dynamic _NSGetExecutablePath _NSGetExecutablePath ""
//go:cgo_import_dynamic __bzero __bzero ""
//go:cgo_import_dynamic __error __error ""
//go:cgo_import_dynamic __fork __fork ""
//go:cgo_import_dynamic __mmap __mmap ""
//go:cgo_import_dynamic __munmap __munmap ""
//go:cgo_import_dynamic __stack_chk_fail __stack_chk_fail ""
//go:cgo_import_dynamic __stack_chk_guard __stack_chk_guard ""

//go:cgo_import_dynamic _NSGetArgv _NSGetArgv ""
//go:cgo_import_dynamic _NSGetEnviron _NSGetEnviron ""
//go:cgo_import_dynamic _NSGetExecutablePath _NSGetExecutablePath ""
//go:cgo_import_dynamic __error __error ""
//go:cgo_import_dynamic __fork __fork ""
//go:cgo_import_dynamic __mmap __mmap ""
//go:cgo_import_dynamic __munmap __munmap ""
//go:cgo_import_dynamic __stack_chk_fail __stack_chk_fail ""
//go:cgo_import_dynamic __stack_chk_guard __stack_chk_guard ""

// end::parallel-calculated[]

// tag::fork-every[]
    forkEvery = 100
// end::fork-every[]

// tag::disable-reports[]
    reports.html.required = false
    reports.junitXml.required = false
// end::disable-reports[]

// tag::parallel-4[]
// tag::parallel-calculated[]
// tag::fork-every[]
// tag::disable-reports[]
}
// end::parallel-4[]
// end::parallel-calculated[]
// end::fork-every[]
// end::disable-reports[]

	type foo struct {
		bar int64
	}

	var doFork func(f *foo, depth int)
	doFork = func(f *foo, depth int) {
		atomic.StoreInt64(&f.bar, 1)
		defer atomic.StoreInt64(&f.bar, 0)
		if depth > 0 {
			for i := 0; i < 2; i++ {
				f2 := &foo{}
				go doFork(f2, depth-1)
			}
		}
		runtime.GC()
	}

	f := &foo{}
	doFork(f, 11)

        return encoding;
    }

    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }

    public boolean isFork() {
        return fork;
    }

    public void setFork(boolean fork) {
        this.fork = fork;
    }

    public boolean isKeepStubs() {
        return keepStubs;
    }

    public void setKeepStubs(boolean keepStubs) {

        tasks.withType<JavaCompile> {
            options.isFork = true
            options.isIncremental = true
            options.forkOptions.memoryInitialSize = compilerMemory
            options.forkOptions.memoryMaximumSize = compilerMemory
        }
        tasks.withType<GroovyCompile> {
            options.isFork = true
            options.isIncremental = true

		tf_stack: uintptr(stk) - goarch.PtrSize,
	}

	var oset sigset
	sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
	ret := retryOnEAGAIN(func() int32 {
		errno := tfork(&param, unsafe.Sizeof(param), mp, mp.g0, abi.FuncPCABI0(mstart))
		// tfork returns negative errno
		return -errno
	})
	sigprocmask(_SIG_SETMASK, &oset, nil)

	if ret != 0 {

}

tasks.withType<GroovyCompile>().configureEach {
    groovyOptions.apply {
        encoding = "utf-8"
        forkOptions.jvmArgs?.add("-XX:+HeapDumpOnOutOfMemoryError")
    }
    options.apply {
        isFork = true
        encoding = "utf-8"
        compilerArgs = mutableListOf("-Xlint:-options", "-Xlint:-path")
    }
}

tasks.withType<Test>().configureEach {
    if (JavaVersion.current().isJava9Compatible) {

package plan9

// Plan 9 Constants

// Open modes
const (
	O_RDONLY  = 0
	O_WRONLY  = 1
	O_RDWR    = 2
	O_TRUNC   = 16
	O_CLOEXEC = 32
	O_EXCL    = 0x1000
)

// Rfork flags
const (
	RFNAMEG  = 1 << 0
	RFENVG   = 1 << 1
	RFFDG    = 1 << 2
	RFNOTEG  = 1 << 3
	RFPROC   = 1 << 4
	RFMEM    = 1 << 5
	RFNOWAIT = 1 << 6
	RFCNAMEG = 1 << 10
	RFCENVG  = 1 << 11
	RFCFDG   = 1 << 12
	RFREND   = 1 << 13

        outputs.doNotCacheIf(
            "Forking compiler via ForkOptions.executable",
            spec(element -> compileOptions.isFork() && compileOptions.getForkOptions().getExecutable() != null)
        );
    }