// libc interceptor that writes signal handlers to a global variable within the
// TSAN runtime instead of making a sigaction system call. A bug in
// syscall.runtime_AfterForkInChild corrupted TSAN's signal forwarding table
// during calls to (*os/exec.Cmd).Run, causing the parent process to fail to
// invoke signal handlers.

import (
	"fmt"
	"os"
	"os/exec"
	"os/signal"
	"syscall"
)

}

func scriptHandle() script.Cmd {
	return script.Command(
		script.CmdUsage{
			Summary: "set the HTTP handler that will serve the script's output",
			Args:    "handler [dir]",
			Detail: []string{
				"The handler will be passed the script's current working directory and environment as arguments.",
				"Valid handlers include 'dir' (for general http.Dir serving), 'bzr', 'fossil', 'git', and 'hg'",
			},
		},

var Interrupted = make(chan struct{})

// processSignals setups signal handler.
func processSignals() {
	sig := make(chan os.Signal, 1)
	signal.Notify(sig, signalsToIgnore...)
	go func() {
		<-sig
		close(Interrupted)
	}()
}

var onceProcessSignals sync.Once

// StartSigHandlers starts the signal handlers.
func StartSigHandlers() {
	onceProcessSignals.Do(processSignals)

	})
	return h.svnserveErr == nil
}

// Handler returns an http.Handler that checks for the "vcwebsvn" query
// parameter and then serves the 'svn://' URL for the repository at the
// requested path.
// The HTTP client is expected to read that URL and pass it to the 'svn' client.
func (h *svnHandler) Handler(dir string, env []string, logger *log.Logger) (http.Handler, error) {
	if !h.Available() {

	// To check for data races in the handler, run the root handler to produce an
	// overview of the script status at an arbitrary point during the test.
	// (We ignore the output because the expected failure mode is a friendly stack
	// dump from the race detector.)
	t.Run("overview", func(t *testing.T) {
		t.Parallel()

		time.Sleep(1 * time.Millisecond) // Give the other handlers time to race.

		resp, err := http.Get(srv.URL)

		t.Fatal(err)
	}
	return int(c)
}

func test8517(t *testing.T) {
	c1 := processHandleCount(t)
	C.testHandleLeaks()
	c2 := processHandleCount(t)
	if c1+issue8517counter <= c2 {
		t.Fatalf("too many handles leaked: issue8517counter=%v c1=%v c2=%v", issue8517counter, c1, c2)
	}
}

//export testHandleLeaksCallback
func testHandleLeaksCallback() {
	issue8517counter++

	// method to return a handle that uses ordinary synchronous I/O.”
	// However, LockFileEx still requires an OVERLAPPED structure,
	// which contains the file offset of the beginning of the lock range.
	// We want to lock the entire file, so we leave the offset as zero.
	ol := new(syscall.Overlapped)

	err := windows.LockFileEx(syscall.Handle(f.Fd()), uint32(lt), reserved, allBytes, allBytes, ol)
	if err != nil {

// mangled.
type S struct {
	X int `parser:"|@@)"`
}

//go:noinline
func F[T any]() {}

func P() {
	F[S]()
}

// Issue 62098: the name mangling code doesn't handle some string
// symbols correctly.
func G(id string) error {
	if strings.ContainsAny(id, "&$@;/:+,?\\{^}%`]\">[~<#|") {
		return fmt.Errorf("invalid")
	}
	return nil
}

		// in addition to go tools. Only display go tools here.
		if cfg.BuildToolchainName == "gccgo" && !isGccgoTool(name) {
			continue
		}
		fmt.Println(name)
	}
}

func impersonateDistList(args []string) (handled bool) {
	fs := flag.NewFlagSet("go tool dist list", flag.ContinueOnError)
	jsonFlag := fs.Bool("json", false, "produce JSON output")
	brokenFlag := fs.Bool("broken", false, "include broken ports")

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This program generates a test to verify that the standard arithmetic
// operators properly handle some special cases. The test file should be
// generated with a known working version of go.
// launch with `go run arithBoundaryGen.go` a file called arithBoundary.go
// will be written into the parent directory containing the tests