pkg syscall (darwin-arm64), const RTF_ROUTER ideal-int
pkg syscall (darwin-arm64), const RTF_STATIC = 2048
pkg syscall (darwin-arm64), const RTF_STATIC ideal-int
pkg syscall (darwin-arm64), const RTF_UP = 1
pkg syscall (darwin-arm64), const RTF_UP ideal-int
pkg syscall (darwin-arm64), const RTF_WASCLONED = 131072
pkg syscall (darwin-arm64), const RTF_WASCLONED ideal-int
pkg syscall (darwin-arm64), const RTF_XRESOLVE = 512

		}
		buf.WriteByte('\n')
	}
}

// Test the line splitter, including some carriage returns but no long lines.
func TestScanLongLines(t *testing.T) {
	// Build a buffer of lots of line lengths up to but not exceeding smallMaxTokenSize.
	tmp := new(bytes.Buffer)
	buf := new(bytes.Buffer)
	lineNum := 0
	j := 0
	for i := 0; i < 2*smallMaxTokenSize; i++ {
		genLine(tmp, lineNum, j, true)

		return err
	}

	if err := installDevice(appdir); err != nil {
		return err
	}

	if err := mountDevImage(); err != nil {
		return err
	}

	// Kill any hanging debug bridges that might take up port 3222.
	exec.Command("killall", "idevicedebugserverproxy").Run()

	closer, err := startDebugBridge()
	if err != nil {
		return err
	}
	defer closer()

pkg syscall (freebsd-arm64), const RTF_STICKY = 268435456
pkg syscall (freebsd-arm64), const RTF_STICKY ideal-int
pkg syscall (freebsd-arm64), const RTF_UP = 1
pkg syscall (freebsd-arm64), const RTF_UP ideal-int
pkg syscall (freebsd-arm64), const RTF_XRESOLVE = 512
pkg syscall (freebsd-arm64), const RTF_XRESOLVE ideal-int
pkg syscall (freebsd-arm64), const RTM_ADD = 1

pkg syscall (darwin-386), const RTF_PROTO3 ideal-int
pkg syscall (darwin-386), const RTF_REJECT ideal-int
pkg syscall (darwin-386), const RTF_STATIC ideal-int
pkg syscall (darwin-386), const RTF_UP ideal-int
pkg syscall (darwin-386), const RTF_WASCLONED ideal-int
pkg syscall (darwin-386), const RTF_XRESOLVE ideal-int
pkg syscall (darwin-386), const RTM_ADD ideal-int
pkg syscall (darwin-386), const RTM_CHANGE ideal-int

	if !p.more() {
		return EOF
	}
	tok := p.input[p.inputPos]
	p.inputPos++
	return tok
}

func (p *Parser) back() {
	if p.inputPos == 0 {
		p.errorf("internal error: backing up before BOL")
	} else {
		p.inputPos--
	}
}

func (p *Parser) peek() lex.ScanToken {
	if p.more() {
		return p.input[p.inputPos].ScanToken
	}
	return scanner.EOF
}

pkg syscall (freebsd-riscv64), const RTF_STICKY = 268435456 #53466
pkg syscall (freebsd-riscv64), const RTF_STICKY ideal-int #53466
pkg syscall (freebsd-riscv64), const RTF_UP = 1 #53466
pkg syscall (freebsd-riscv64), const RTF_UP ideal-int #53466
pkg syscall (freebsd-riscv64), const RTF_XRESOLVE = 512 #53466
pkg syscall (freebsd-riscv64), const RTF_XRESOLVE ideal-int #53466

		totalLen += len(buf)
	}

	totalLen += len(frag)
	return fullBuffers, frag, totalLen, err
}

// ReadBytes reads until the first occurrence of delim in the input,
// returning a slice containing the data up to and including the delimiter.
// If ReadBytes encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often io.EOF).

// A ScanToken represents an input item. It is a simple wrapping of rune, as
// returned by text/scanner.Scanner, plus a couple of extra values.
type ScanToken rune

const (
	// Asm defines some two-character lexemes. We make up
	// a rune/ScanToken value for them - ugly but simple.
	LSH          ScanToken = -1000 - iota // << Left shift.
	RSH                                   // >> Logical right shift.

<p>
The array underlying a slice may extend past the end of the slice.
The <i>capacity</i> is a measure of that extent: it is the sum of
the length of the slice and the length of the array beyond the slice;
a slice of length up to that capacity can be created by
<a href="#Slice_expressions"><i>slicing</i></a> a new one from the original slice.
The capacity of a slice <code>a</code> can be discovered using the