programs into the system C compiler and interpreting the generated
error messages, debug information, and object files. In practice,
parsing these is significantly less work and more robust than parsing
C source.

Cgo first invokes gcc -E -dM on the preamble, in order to find out
about simple #defines for constants and the like. These are recorded
for later use.

Next, cgo needs to identify the kinds for each identifier. For the

<p>
If <code>a</code> is not a map:
</p>
<ul>
	<li>the index <code>x</code> must be of integer type or an untyped constant</li>
	<li>a constant index must be non-negative and
	    <a href="#Representability">representable</a> by a value of type <code>int</code></li>
	<li>a constant index that is untyped is given type <code>int</code></li>
	<li>the index <code>x</code> is <i>in range</i> if <code>0 &lt;= x &lt; len(a)</code>,

pkg syscall (netbsd-arm64-cgo), const EVFILT_TIMER = 6
pkg syscall (netbsd-arm64-cgo), const EVFILT_TIMER ideal-int
pkg syscall (netbsd-arm64-cgo), const EVFILT_VNODE = 3
pkg syscall (netbsd-arm64-cgo), const EVFILT_VNODE ideal-int
pkg syscall (netbsd-arm64-cgo), const EVFILT_WRITE = 1
pkg syscall (netbsd-arm64-cgo), const EVFILT_WRITE ideal-int
pkg syscall (netbsd-arm64-cgo), const EV_FLAG1 = 8192

	n, perr := strconv.ParseInt(nStr, 10, 0) // Intentionally parse as native int
	if perr != nil || n < 5 || n > int64(len(s)) {
		return "", "", s, ErrHeader
	}
	n -= int64(len(nStr) + 1) // convert from index in s to index in rest
	if n <= 0 {
		return "", "", s, ErrHeader
	}

	// Extract everything between the space and the final newline.
	rec, nl, rem := rest[:n-1], rest[n-1:n], rest[n:]
	if nl != "\n" {

	TypeLink    = '1' // Hard link
	TypeSymlink = '2' // Symbolic link
	TypeChar    = '3' // Character device node
	TypeBlock   = '4' // Block device node
	TypeDir     = '5' // Directory
	TypeFifo    = '6' // FIFO node

	// Type '7' is reserved.
	TypeCont = '7'

	// Type 'x' is used by the PAX format to store key-value records that
	// are only relevant to the next file.

			AccessTime: time.Unix(1389782991, 419875220),
			ChangeTime: time.Unix(1389782956, 794414986),
			Xattrs: map[string]string{
				"user.key":  "value",
				"user.key2": "value2",
				// Interestingly, selinux encodes the terminating null inside the xattr
				"security.selinux": "unconfined_u:object_r:default_t:s0\x00",
			},
			PAXRecords: map[string]string{
				"mtime":                         "1386065770.44825232",

	if !ok || u.Op != token.AND {
		return false
	}
	index, ok := u.X.(*ast.IndexExpr)
	if !ok {
		return false
	}

	addr := ""
	deref := ""
	if p.isVariable(index.X) {
		addr = "&"
		deref = "*"
	}

	fmt.Fprintf(sb, "_cgoIndex%d := %s%s; ", i, addr, gofmtPos(index.X, index.X.Pos()))
	origX := index.X
	index.X = ast.NewIdent(fmt.Sprintf("_cgoIndex%d", i))
	if deref == "*" {

pkg image/png, type UnsupportedError string
pkg index/suffixarray, func New([]uint8) *Index
pkg index/suffixarray, method (*Index) Bytes() []uint8
pkg index/suffixarray, method (*Index) FindAllIndex(*regexp.Regexp, int) [][]int
pkg index/suffixarray, method (*Index) Lookup([]uint8, int) []int
pkg index/suffixarray, method (*Index) Read(io.Reader) error
pkg index/suffixarray, method (*Index) Write(io.Writer) error

pkg syscall (darwin-arm64), const EVFILT_USER ideal-int
pkg syscall (darwin-arm64), const EVFILT_VM = -12
pkg syscall (darwin-arm64), const EVFILT_VM ideal-int
pkg syscall (darwin-arm64), const EVFILT_VNODE = -4
pkg syscall (darwin-arm64), const EVFILT_VNODE ideal-int
pkg syscall (darwin-arm64), const EVFILT_WRITE = -2
pkg syscall (darwin-arm64), const EVFILT_WRITE ideal-int
pkg syscall (darwin-arm64), const EV_ADD = 1

pkg syscall (freebsd-arm64), const EVFILT_USER = -11
pkg syscall (freebsd-arm64), const EVFILT_USER ideal-int
pkg syscall (freebsd-arm64), const EVFILT_VNODE = -4
pkg syscall (freebsd-arm64), const EVFILT_VNODE ideal-int
pkg syscall (freebsd-arm64), const EVFILT_WRITE = -2
pkg syscall (freebsd-arm64), const EVFILT_WRITE ideal-int
pkg syscall (freebsd-arm64), const EWOULDBLOCK = 35