<code>package math</code>, which exports function <code>Sin</code>, and
installed the compiled package in the file identified by
<code>"lib/math"</code>.
This table illustrates how <code>Sin</code> is accessed in files
that import the package after the
various types of import declaration.
</p>

<pre class="grammar">
Import declaration          Local name of Sin

import   "lib/math"         math.Sin

pkg syscall (windows-386), const PROV_DSS_DH ideal-int
pkg syscall (windows-386), const PROV_EC_ECDSA_FULL ideal-int
pkg syscall (windows-386), const PROV_EC_ECDSA_SIG ideal-int
pkg syscall (windows-386), const PROV_EC_ECNRA_FULL ideal-int
pkg syscall (windows-386), const PROV_EC_ECNRA_SIG ideal-int
pkg syscall (windows-386), const PROV_FORTEZZA ideal-int
pkg syscall (windows-386), const PROV_INTEL_SEC ideal-int

Russ Cox <******@****.***> 1410149331 -0400

func (f *File) findBodyOffset() (int64, error) {
	var buf [fileHeaderLen]byte
	if _, err := f.zipr.ReadAt(buf[:], f.headerOffset); err != nil {
		return 0, err
	}
	b := readBuf(buf[:])
	if sig := b.uint32(); sig != fileHeaderSignature {
		return 0, ErrFormat
	}
	b = b[22:] // skip over most of the header
	filenameLen := int(b.uint16())
	extraLen := int(b.uint16())

Andrew <******@****.***> 1574269611 -0500

		return false
	}

	d = make([]byte, directory64EndLen)
	if _, err := zip.ReadAt(d, dirOff); err != nil {
		t.Fatalf("ReadAt(off=%d): %v", dirOff, err)
	}

	b := readBuf(d)
	if sig := b.uint32(); sig != directory64EndSignature {
		return false
	}

	size := b.uint64()
	if size != directory64EndLen-12 {
		t.Errorf("expected length of %d, got %d", directory64EndLen-12, size)
	}
	return true
}

	frameSize := p.positiveAtoi(op[0].String())
	if negative {
		frameSize = -frameSize
	}
	op = op[1:]
	argSize := int64(abi.ArgsSizeUnknown)
	if len(op) > 0 {
		// There is an argument size. It must be a minus sign followed by a non-negative integer literal.
		if len(op) != 2 || op[0].ScanToken != '-' || op[1].ScanToken != scanner.Int {
			p.errorf("TEXT %s: argument size must be of form -integer", name)
			return
		}

pkg syscall (windows-386), const PROV_DSS_DH = 13
pkg syscall (windows-386), const PROV_EC_ECDSA_FULL = 16
pkg syscall (windows-386), const PROV_EC_ECDSA_SIG = 14
pkg syscall (windows-386), const PROV_EC_ECNRA_FULL = 17
pkg syscall (windows-386), const PROV_EC_ECNRA_SIG = 15
pkg syscall (windows-386), const PROV_FORTEZZA = 4
pkg syscall (windows-386), const PROV_INTEL_SEC = 22
pkg syscall (windows-386), const PROV_MS_EXCHANGE = 5

	sys.stderr.write("lldb: failed to connect to remote target %s: %s\n" % (device_exe_or_pid, err))
	sys.exit(1)

# Don't stop on signals.
sigs = process.GetUnixSignals()
for i in range(0, sigs.GetNumSignals()):
	sig = sigs.GetSignalAtIndex(i)
	sigs.SetShouldStop(sig, False)
	sigs.SetShouldNotify(sig, False)

event = lldb.SBEvent()
running = False
prev_handler = None

def signal_handler(signal, frame):

	default:
		panic(fmt.Sprintf("unknown type %T", typ))
	}
}

func (w *Walker) writeSignature(buf *bytes.Buffer, sig *types.Signature) {
	if tparams := sig.TypeParams(); tparams != nil {
		w.writeTypeParams(buf, tparams, true)
	}
	w.writeParams(buf, sig.Params(), sig.Variadic())
	switch res := sig.Results(); res.Len() {
	case 0:
		// nothing to do
	case 1:
		buf.WriteByte(' ')
		w.writeType(buf, res.At(0).Type())