extern void runCShouldNotCallback();
*/
import "C"

import (
	"fmt"
)

func init() {
	register("CgoNoCallback", CgoNoCallback)
}

//export CallbackToGo
func CallbackToGo() {
}

func CgoNoCallback() {
	C.runCShouldNotCallback()
	fmt.Println("OK")

doujiang24 <******@****.***> 1692983191 +0000

//go:linkname write

// used by cgo
//go:linkname _cgo_panic_internal
//go:linkname cgoAlwaysFalse
//go:linkname cgoUse
//go:linkname cgoCheckPointer
//go:linkname cgoCheckResult
//go:linkname cgoNoCallback
//go:linkname gobytes
//go:linkname gostringn

// used in plugin
//go:linkname doInit

// used in math/bits
//go:linkname overflowError
//go:linkname divideError

// used in tests

// escape analysis result. The test is cheaper than the call.
var cgoAlwaysFalse bool

var cgo_yield = &_cgo_yield

func cgoNoCallback(v bool) {
	g := getg()
	if g.nocgocallback && v {
		panic("runtime: unexpected setting cgoNoCallback")
	}
	g.nocgocallback = v

	if output != want {
		t.Fatalf("want %s, got %s\n", want, output)
	}
}

func TestCgoNoCallback(t *testing.T) {
	t.Skip("TODO(#56378): enable in Go 1.23")
	got := runTestProg(t, "testprogcgo", "CgoNoCallback")
	want := "function marked with #cgo nocallback called back into Go"
	if !strings.Contains(got, want) {
		t.Fatalf("did not see %q in output:\n%s", want, got)
	}
}

func TestCgoNoEscape(t *testing.T) {

		fmt.Fprintf(fgo2, "//go:linkname _Cgo_use runtime.cgoUse\n")
		fmt.Fprintf(fgo2, "func _Cgo_use(interface{})\n")
	}
	fmt.Fprintf(fgo2, "//go:linkname _Cgo_no_callback runtime.cgoNoCallback\n")
	fmt.Fprintf(fgo2, "func _Cgo_no_callback(bool)\n")

	typedefNames := make([]string, 0, len(typedef))
	for name := range typedef {
		if name == "_Ctype_void" {
			// We provide an appropriate declaration for