code review 851045: os: mingw version of Readdir() and Stat() implemented

src/pkg/os/file.go

 // Copyright 2009 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 os package provides a platform-independent interface to operating
 // system functionality.  The design is Unix-like.
 package os
 
 import (
         "runtime"
         "syscall"
 )
 
-// Auxiliary information if the File describes a directory
-type dirInfo struct {
-        buf  []byte // buffer for directory I/O
-        nbuf int    // length of buf; return value from Getdirentries
-        bufp int    // location of next record in buf.
-}
-
 // File represents an open file descriptor.
 type File struct {
         fd      int
         name    string
         dirinfo *dirInfo // nil unless directory being read
         nepipe  int      // number of consecutive EPIPE in Write
 }
 
 // Fd returns the integer Unix file descriptor referencing the open file.
 func (file *File) Fd() int { return file.fd }
@@ skipping 30 matching lines @@
         O_CREAT    = syscall.O_CREAT    // create a new file if none exists.
         O_EXCL     = syscall.O_EXCL     // used with O_CREAT, file must not exist
         O_NOCTTY   = syscall.O_NOCTTY   // do not make file the controlling tty.
         O_NONBLOCK = syscall.O_NONBLOCK // open in non-blocking mode.
         O_NDELAY   = O_NONBLOCK         // synonym for O_NONBLOCK
         O_SYNC     = syscall.O_SYNC     // open for synchronous I/O.
         O_TRUNC    = syscall.O_TRUNC    // if possible, truncate file when opened.
         O_CREATE   = O_CREAT            // create a new file if none exists.
 )
 
-// Open opens the named file with specified flag (O_RDONLY etc.) and perm, (0666 etc.)
-// if applicable.  If successful, methods on the returned File can be used for I/O.
-// It returns the File and an Error, if any.
-func Open(name string, flag int, perm int) (file *File, err Error) {
-        r, e := syscall.Open(name, flag|syscall.O_CLOEXEC, perm)
-        if e != 0 {
-                return nil, &PathError{"open", name, Errno(e)}
-        }
-
-        // There's a race here with fork/exec, which we are
-        // content to live with.  See ../syscall/exec.go
-        if syscall.O_CLOEXEC == 0 { // O_CLOEXEC not supported
-                syscall.CloseOnExec(r)
-        }
-
-        return NewFile(r, name), nil
-}
-
-// Close closes the File, rendering it unusable for I/O.
-// It returns an Error, if any.
-func (file *File) Close() Error {
-        if file == nil || file.fd < 0 {
-                return EINVAL
-        }
-        var err Error
-        if e := syscall.Close(file.fd); e != 0 {
-                err = &PathError{"close", file.name, Errno(e)}
-        }
-        file.fd = -1 // so it can't be closed again
-
-        // no need for a finalizer anymore
-        runtime.SetFinalizer(file, nil)
-        return err
-}
-
 type eofError int
 
 func (eofError) String() string { return "EOF" }
 
 // EOF is the Error returned by Read when no more input is available.
 // Functions should return EOF only to signal a graceful end of input.
 // If the EOF occurs unexpectedly in a structured data stream,
 // the appropriate error is either io.ErrUnexpectedEOF or some other error
 // giving more detail.
 var EOF Error = eofError(0)
@@ skipping 179 matching lines @@
 // describes the symbolic link.  Lstat makes no attempt to follow the link.
 func Lstat(name string) (fi *FileInfo, err Error) {
         var stat syscall.Stat_t
         e := syscall.Lstat(name, &stat)
         if e != 0 {
                 return nil, &PathError{"lstat", name, Errno(e)}
         }
         return fileInfoFromStat(name, new(FileInfo), &stat, &stat), nil
 }
 
-// Readdir reads the contents of the directory associated with file and
-// returns an array of up to count FileInfo structures, as would be returned
-// by Stat, in directory order.  Subsequent calls on the same file will yield
-// further FileInfos.
-// A negative count means to read until EOF.
-// Readdir returns the array and an Error, if any.
-func (file *File) Readdir(count int) (fi []FileInfo, err Error) {
-        dirname := file.name
-        if dirname == "" {
-                dirname = "."
-        }
-        dirname += "/"
-        names, err1 := file.Readdirnames(count)
-        if err1 != nil {
-                return nil, err1
-        }
-        fi = make([]FileInfo, len(names))
-        for i, filename := range names {
-                fip, err := Lstat(dirname + filename)
-                if fip == nil || err != nil {
-                        fi[i].Name = filename // rest is already zeroed out
-                } else {
-                        fi[i] = *fip
-                }
-        }
-        return
-}
-
 // Chdir changes the current working directory to the named directory.
 func Chdir(dir string) Error {
         if e := syscall.Chdir(dir); e != 0 {
                 return &PathError{"chdir", dir, Errno(e)}
         }
         return nil
 }
 
 // Chdir changes the current working directory to the file,
 // which must be a directory.
@@ skipping 144 matching lines @@
 }
 
 // Truncate changes the size of the file.
 // It does not change the I/O offset.
 func (f *File) Truncate(size int64) Error {
         if e := syscall.Ftruncate(f.fd, size); e != 0 {
                 return &PathError{"truncate", f.name, Errno(e)}
         }
         return nil
 }