stringData := data[:sLen]
declData := data[sLen:]
- in.Seek(int64(sLen+dLen), os.SEEK_CUR)
+ in.MustSeek(int64(sLen+dLen), os.SEEK_CUR)
p := &iimporter{
ipkg: pkg,
if size&1 != 0 {
bout.WriteByte(0)
}
- bout.Seek(start-ArhdrSize, 0)
+ bout.MustSeek(start-ArhdrSize, 0)
var arhdr [ArhdrSize]byte
formathdr(arhdr[:], name, size)
bout.Write(arhdr[:])
bout.Flush()
- bout.Seek(start+size+(size&1), 0)
+ bout.MustSeek(start+size+(size&1), 0)
}
func dumpCompilerObj(bout *bio.Writer) {
return &Reader{f: f, Reader: bufio.NewReader(f)}, nil
}
-func (r *Reader) Seek(offset int64, whence int) int64 {
+func (r *Reader) MustSeek(offset int64, whence int) int64 {
if whence == 1 {
offset -= int64(r.Buffered())
}
return off
}
-func (w *Writer) Seek(offset int64, whence int) int64 {
+func (w *Writer) MustSeek(offset int64, whence int) int64 {
if err := w.Flush(); err != nil {
log.Fatalf("writing output: %v", err)
}
}
data = data[off-aoff:]
- r.Seek(int64(length), 1)
+ r.MustSeek(int64(length), 1)
return data, true
}
libgcc := sym.Library{Pkg: "libgcc"}
h := ldobj(ctxt, f, &libgcc, l, pname, name)
- f.Seek(h.off, 0)
+ f.MustSeek(h.off, 0)
h.ld(ctxt, f, h.pkg, h.length, h.pn)
}
if off&1 != 0 {
off++
}
- bp.Seek(off, 0)
+ bp.MustSeek(off, 0)
var buf [SAR_HDR]byte
if n, err := io.ReadFull(bp, buf[:]); err != nil {
if n == 0 && err != io.EOF {
}
/* load it as a regular file */
- l := f.Seek(0, 2)
- f.Seek(0, 0)
+ l := f.MustSeek(0, 2)
+ f.MustSeek(0, 0)
ldobj(ctxt, f, lib, l, lib.File, lib.File)
return
}
Exitf("cannot reopen %s: %v", h.pn, err)
}
- f.Seek(h.off, 0)
+ f.MustSeek(h.off, 0)
h.ld(ctxt, f, h.pkg, h.length, h.pn)
f.Close()
}
c2 := bgetc(f)
c3 := bgetc(f)
c4 := bgetc(f)
- f.Seek(start, 0)
+ f.MustSeek(start, 0)
magic := uint32(c1)<<24 | uint32(c2)<<16 | uint32(c3)<<8 | uint32(c4)
if magic == 0x7f454c46 { // \x7F E L F
import1 := f.Offset()
- f.Seek(import0, 0)
+ f.MustSeek(import0, 0)
ldpkg(ctxt, f, lib, import1-import0-2, pn) // -2 for !\n
- f.Seek(import1, 0)
+ f.MustSeek(import1, 0)
flags := 0
switch *FlagStrictDups {
elfobj.nsect = uint(elfobj.shnum)
for i := 0; uint(i) < elfobj.nsect; i++ {
- if f.Seek(int64(uint64(base)+elfobj.shoff+uint64(int64(i)*int64(elfobj.shentsize))), 0) < 0 {
- return errorf("malformed elf file: negative seek")
- }
+ f.MustSeek(int64(uint64(base)+elfobj.shoff+uint64(int64(i)*int64(elfobj.shentsize))), 0)
sect := &elfobj.sect[i]
if is64 != 0 {
var b ElfSectBytes64
}
sect.base = make([]byte, sect.size)
- if elfobj.f.Seek(int64(uint64(elfobj.base)+sect.off), 0) < 0 {
- return fmt.Errorf("short read: seek not successful")
- }
+ elfobj.f.MustSeek(int64(uint64(elfobj.base)+sect.off), 0)
if _, err := io.ReadFull(elfobj.f, sect.base); err != nil {
return fmt.Errorf("short read: %v", err)
}
rel := make([]ldMachoRel, sect.nreloc)
n := int(sect.nreloc * 8)
buf := make([]byte, n)
- if m.f.Seek(m.base+int64(sect.reloff), 0) < 0 {
- return -1
- }
+ m.f.MustSeek(m.base+int64(sect.reloff), 0)
if _, err := io.ReadFull(m.f, buf); err != nil {
return -1
}
n := int(d.nindirectsyms)
p := make([]byte, n*4)
- if m.f.Seek(m.base+int64(d.indirectsymoff), 0) < 0 {
- return -1
- }
+ m.f.MustSeek(m.base+int64(d.indirectsymoff), 0)
if _, err := io.ReadFull(m.f, p); err != nil {
return -1
}
}
strbuf := make([]byte, symtab.strsize)
- if m.f.Seek(m.base+int64(symtab.stroff), 0) < 0 {
- return -1
- }
+ m.f.MustSeek(m.base+int64(symtab.stroff), 0)
if _, err := io.ReadFull(m.f, strbuf); err != nil {
return -1
}
}
n := int(symtab.nsym * uint32(symsize))
symbuf := make([]byte, n)
- if m.f.Seek(m.base+int64(symtab.symoff), 0) < 0 {
- return -1
- }
+ m.f.MustSeek(m.base+int64(symtab.symoff), 0)
if _, err := io.ReadFull(m.f, symbuf); err != nil {
return -1
}
}
if is64 {
- f.Seek(4, 1) // skip reserved word in header
+ f.MustSeek(4, 1) // skip reserved word in header
}
m := &ldMachoObj{
return errorf("load segment out of range")
}
- if f.Seek(m.base+int64(c.seg.fileoff), 0) < 0 {
- return errorf("cannot load object data: seek failed")
- }
+ f.MustSeek(m.base+int64(c.seg.fileoff), 0)
dat := make([]byte, c.seg.filesz)
if _, err := io.ReadFull(f, dat); err != nil {
return errorf("cannot load object data: %v", err)
type peBiobuf bio.Reader
func (f *peBiobuf) ReadAt(p []byte, off int64) (int, error) {
- ret := ((*bio.Reader)(f)).Seek(off, 0)
+ ret := ((*bio.Reader)(f)).MustSeek(off, 0)
if ret < 0 {
return 0, errors.New("fail to seek")
}
type xcoffBiobuf bio.Reader
func (f *xcoffBiobuf) ReadAt(p []byte, off int64) (int, error) {
- ret := ((*bio.Reader)(f)).Seek(off, 0)
+ ret := ((*bio.Reader)(f)).MustSeek(off, 0)
if ret < 0 {
return 0, errors.New("fail to seek")
}
start := f.Offset()
roObject := f.SliceRO(uint64(length))
if roObject != nil {
- f.Seek(int64(-length), os.SEEK_CUR)
+ f.MustSeek(int64(-length), os.SEEK_CUR)
}
r := &objReader{
rd: f,
if r.roOffset != length {
log.Fatalf("%s: unexpected end at %d, want %d", pn, r.roOffset, start+length)
}
- r.rd.Seek(int64(length), os.SEEK_CUR)
+ r.rd.MustSeek(int64(length), os.SEEK_CUR)
} else if f.Offset() != start+length {
log.Fatalf("%s: unexpected end at %d, want %d", pn, f.Offset(), start+length)
}
// These cases are basically ok.
// Errors are handled reasonably and there's no clear need for interface satisfaction.
// Except for the runtime/pprof case, the API is not exported.
-cmd/internal/bio/buf.go: method Seek(offset int64, whence int) int64 should have signature Seek(int64, int) (int64, error)
-cmd/internal/bio/buf.go: method Seek(offset int64, whence int) int64 should have signature Seek(int64, int) (int64, error)
fmt/print.go: method WriteByte(c byte) should have signature WriteByte(byte) error
// Also non-standard, but this method is on an unexported type, so it's