// The bytes are taken from at most one Read on the underlying [Reader],
// hence n may be less than len(p).
// To read exactly len(p) bytes, use io.ReadFull(b, p).
// If the underlying [Reader] can return a non-zero count with io.EOF,
// then this Read method can do so as well; see the [io.Reader] docs.
func (b *Reader) Read(p []byte) (n int, err error) {
	n = len(p)
	if n == 0 {
		if b.Buffered() > 0 {
			return 0, nil
		}

		tokens: tokens,
		base:   base,
		line:   line,
		pos:    -1, // Next will advance to zero.
	}
}

func (s *Slice) Next() ScanToken {
	s.pos++
	if s.pos >= len(s.tokens) {
		return scanner.EOF
	}
	return s.tokens[s.pos].ScanToken
}

func (s *Slice) Text() string {
	return s.tokens[s.pos].text
}

func (s *Slice) File() string {
	return s.base.Filename()
}

	last := nargs[li]
	nargs[li] = "-O0"
	nargs = append(nargs, extraArgs...)
	nargs = append(nargs, last)

	if *debugGcc {
		fmt.Fprintf(os.Stderr, "$ %s <<EOF\n", strings.Join(nargs, " "))
		os.Stderr.Write(stdin)
		fmt.Fprint(os.Stderr, "EOF\n")
	}
	stdout, stderr, _ := run(stdin, nargs)
	if *debugGcc {
		os.Stderr.Write(stdout)
		os.Stderr.Write(stderr)
	}
	return string(stderr)
}

}

// drain returns a single string representing the processed input tokens.
func drain(input *Input) string {
	var buf strings.Builder
	for {
		tok := input.Next()
		if tok == scanner.EOF {
			return buf.String()
		}
		if tok == '#' {
			continue
		}
		if buf.Len() > 0 {
			buf.WriteByte('.')
		}
		buf.WriteString(input.Text())
	}
}

type badLexTest struct {

pkg syscall (netbsd-arm64-cgo), const EV_ENABLE = 4
pkg syscall (netbsd-arm64-cgo), const EV_ENABLE ideal-int
pkg syscall (netbsd-arm64-cgo), const EV_EOF = 32768
pkg syscall (netbsd-arm64-cgo), const EV_EOF ideal-int
pkg syscall (netbsd-arm64-cgo), const EV_ERROR = 16384
pkg syscall (netbsd-arm64-cgo), const EV_ERROR ideal-int
pkg syscall (netbsd-arm64-cgo), const EVFILT_AIO = 2

		na++
		i++
		// Skip spaces in between fields.
		for i < len(s) && asciiSpace[s[i]] != 0 {
			i++
		}
		fieldStart = i
	}
	if fieldStart < len(s) { // Last field might end at EOF.
		a[na] = s[fieldStart:len(s):len(s)]
	}
	return a
}

// FieldsFunc interprets s as a sequence of UTF-8-encoded code points.
// It splits the slice s at each run of code points c satisfying f(c) and

constant, even if the literal's fractional part is zero.
</p>

<pre>
const Pi float64 = 3.14159265358979323846
const zero = 0.0         // untyped floating-point constant
const (
	size int64 = 1024
	eof        = -1  // untyped integer constant
)
const a, b, c = 3, 4, "foo"  // a = 3, b = 4, c = "foo", untyped integer and string constants
const u, v float32 = 0, 3    // u = 0.0, v = 3.0
</pre>

<p>

	back := ss.size - off
	if back > int64(ss.keep) {
		return 0, errDiscardedBytes
	}
	suf := ss.Suffix()
	n = copy(p, suf[len(suf)-int(back):])
	if n != len(p) {
		err = io.EOF
	}
	return
}

func (ss *suffixSaver) Suffix() []byte {
	if len(ss.buf) < ss.keep {
		return ss.buf
	}
	buf := make([]byte, ss.keep)
	n := copy(buf, ss.buf[ss.start:])
	copy(buf[n:], ss.buf[:])

pkg syscall (darwin-arm64), const EV_DISPATCH ideal-int
pkg syscall (darwin-arm64), const EV_ENABLE = 4
pkg syscall (darwin-arm64), const EV_ENABLE ideal-int
pkg syscall (darwin-arm64), const EV_EOF = 32768
pkg syscall (darwin-arm64), const EV_EOF ideal-int
pkg syscall (darwin-arm64), const EV_ERROR = 16384
pkg syscall (darwin-arm64), const EV_ERROR ideal-int
pkg syscall (darwin-arm64), const EV_FLAG0 = 4096

pkg syscall (freebsd-arm64), const EV_DROP ideal-int
pkg syscall (freebsd-arm64), const EV_ENABLE = 4
pkg syscall (freebsd-arm64), const EV_ENABLE ideal-int
pkg syscall (freebsd-arm64), const EV_EOF = 32768
pkg syscall (freebsd-arm64), const EV_EOF ideal-int
pkg syscall (freebsd-arm64), const EV_ERROR = 16384
pkg syscall (freebsd-arm64), const EV_ERROR ideal-int
pkg syscall (freebsd-arm64), const EV_FLAG1 = 8192