}

var (
	swigOnce sync.Once
	haveSwig bool
)

func mustHaveSwig(t *testing.T) {
	swigOnce.Do(func() {
		mustHaveSwigOnce(t)
		haveSwig = true
	})
	// The first call will skip t with a nice message. On later calls, we just skip.
	if !haveSwig {
		t.Skip("swig not found")
	}
}

func mustHaveSwigOnce(t *testing.T) {
	swig, err := exec.LookPath("swig")
	if err != nil {

<=    less or equal
>     greater
>=    greater or equal
</pre>

<p>
In any comparison, the first operand
must be <a href="#Assignability">assignable</a>
to the type of the second operand, or vice versa.
</p>
<p>
The equality operators <code>==</code> and <code>!=</code> apply
to operands that are <i>comparable</i>.

			p.errorf("cannot reference %s without a symbol", name)
		}
		p.setPseudoRegister(a, name, false, prefix)
		return
	}
	a.Reg = r1
	if r2 != 0 {
		// TODO: Consistency in the encoding would be nice here.
		if p.arch.InFamily(sys.ARM, sys.ARM64) {
			// Special form
			// ARM: destination register pair (R1, R2).
			// ARM64: register pair (R1, R2) for LDP/STP.
			if prefix != 0 || scale != 0 {

</p>

<h3 id="Function_declarations">Function declarations</h3>

<!--
	Given the importance of functions, this section has always
	been woefully underdeveloped. Would be nice to expand this
	a bit.
-->

<p>
A function declaration binds an identifier, the <i>function name</i>,
to a function.
</p>

<pre class="ebnf">

pkg syscall (linux-386), const SYS_MUNMAP = 91
pkg syscall (linux-386), const SYS_NANOSLEEP = 162
pkg syscall (linux-386), const SYS_NFSSERVCTL = 169
pkg syscall (linux-386), const SYS_NICE = 34
pkg syscall (linux-386), const SYS_OLDFSTAT = 28
pkg syscall (linux-386), const SYS_OLDLSTAT = 84
pkg syscall (linux-386), const SYS_OLDOLDUNAME = 59
pkg syscall (linux-386), const SYS_OLDSTAT = 18

		return true
	}
	for _, f := range strings.Split(s, " or ") {
		if f == "" || len(f)%2 != 0 || strings.TrimLeft(f, "0123456789abcdef") != "" {
			return false
		}
	}
	return true
}

// It would be nice if the error messages always began with
// the standard file:line: prefix,
// but that's not where we are today.
// It might be at the beginning but it might be in the middle of the printed instruction.

pkg syscall (linux-arm-cgo), const SYS_NAME_TO_HANDLE_AT ideal-int
pkg syscall (linux-arm-cgo), const SYS_NANOSLEEP ideal-int
pkg syscall (linux-arm-cgo), const SYS_NFSSERVCTL ideal-int
pkg syscall (linux-arm-cgo), const SYS_NICE ideal-int
pkg syscall (linux-arm-cgo), const SYS_OABI_SYSCALL_BASE ideal-int
pkg syscall (linux-arm-cgo), const SYS_OPEN ideal-int
pkg syscall (linux-arm-cgo), const SYS_OPENAT ideal-int

		}
	}
	return dst
}

// invertSparseEntries converts a sparse map from one form to the other.
// If the input is sparseHoles, then it will output sparseDatas and vice-versa.
// The input must have been already validated.
//
// This function mutates src and returns a normalized map where:
//   - adjacent fragments are coalesced together
//   - only the last fragment may be empty

		goIdent[name.Name] = name
		if dt.ByteSize < 0 {
			// Don't override old type
			if _, ok := typedef[name.Name]; ok {
				break
			}

			// Size calculation in c.Struct/c.Opaque will die with size=-1 (unknown),
			// so execute the basic things that the struct case would do
			// other than try to determine a Go representation.
			tt := *t
			tt.C = &TypeRepr{"%s %s", []interface{}{dt.Kind, tag}}

pkg syscall (linux-386), const SYS_MUNMAP ideal-int
pkg syscall (linux-386), const SYS_NANOSLEEP ideal-int
pkg syscall (linux-386), const SYS_NFSSERVCTL ideal-int
pkg syscall (linux-386), const SYS_NICE ideal-int
pkg syscall (linux-386), const SYS_OLDFSTAT ideal-int
pkg syscall (linux-386), const SYS_OLDLSTAT ideal-int
pkg syscall (linux-386), const SYS_OLDOLDUNAME ideal-int