code review 4344062: os: add Seek whence constants

src/pkg/archive/zip/reader.go

 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 /*
 The zip package provides support for reading ZIP archives.
 
 See: http://www.pkware.com/documents/casestudies/APPNOTE.TXT
 
 This package does not support ZIP64 or disk spanning.
@@ skipping 55 matching lines @@
         end, err := readDirectoryEnd(r, size)
         if err != nil {
                 return nil, err
         }
         z := &Reader{
                 r:       r,
                 File:    make([]*File, end.directoryRecords),
                 Comment: end.comment,
         }
         rs := io.NewSectionReader(r, 0, size)
-        if _, err = rs.Seek(int64(end.directoryOffset), 0); err != nil {
+        if _, err = rs.Seek(int64(end.directoryOffset), os.SEEK_SET); err != nil {
                 return nil, err
         }
         buf := bufio.NewReader(rs)
         for i := range z.File {
                 z.File[i] = &File{zipr: r, zipsize: size}
                 if err := readDirectoryHeader(z.File[i], buf); err != nil {
                         return nil, err
                 }
         }
         return z, nil
 }
 
 // Open returns a ReadCloser that provides access to the File's contents.
 func (f *File) Open() (rc io.ReadCloser, err os.Error) {
         off := int64(f.headerOffset)
         if f.bodyOffset == 0 {
                 r := io.NewSectionReader(f.zipr, off, f.zipsize-off)
                 if err = readFileHeader(f, r); err != nil {
                         return
                 }
-                if f.bodyOffset, err = r.Seek(0, 1); err != nil {
+                if f.bodyOffset, err = r.Seek(0, os.SEEK_CUR); err != nil {
                         return
                 }
         }
         size := int64(f.CompressedSize)
         if f.hasDataDescriptor() {
                 if size == 0 {
                         // permit SectionReader to see the rest of the file
                         size = f.zipsize - (off + f.bodyOffset)
                 } else {
                         size += dataDescriptorLen
@@ skipping 187 matching lines @@
 func readByteSlice(r io.Reader, l uint16) []byte {
         b := make([]byte, l)
         if l == 0 {
                 return b
         }
         if _, err := io.ReadFull(r, b); err != nil {
                 panic(err)
         }
         return b
 }