code review 5655045: os: delete Exec, NewFile takes uintpr, rename ShellExpa...

src/pkg/os/file_unix.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.
 
 // +build darwin freebsd linux netbsd openbsd
 
 package os
 
 import (
         "runtime"
@@ skipping 10 matching lines @@
 // can overwrite this data, which could cause the finalizer
 // to close the wrong 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 (f *File) Fd() int {
+func (f *File) Fd() uintptr {
         if f == nil {
-                return -1
-        }
-        return f.fd
+                return ^(uintptr(0))
+        }
+        return uintptr(f.fd)
 }
 
 // NewFile returns a new File with the given file descriptor and name.
-func NewFile(fd int, name string) *File {
-        if fd < 0 {
+func NewFile(fd uintptr, name string) *File {
+        fdi := int(fd)
+        if fdi < 0 {
                 return nil
         }
-        f := &File{&file{fd: fd, name: name}}
+        f := &File{&file{fd: fdi, name: name}}
         runtime.SetFinalizer(f.file, (*file).close)
         return f
 }
 
 // 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.
 }
@@ skipping 17 matching lines @@
         // content to live with.  See ../syscall/exec_unix.go.
         // On OS X 10.6, the O_CLOEXEC flag is not respected.
         // On OS X 10.7, the O_CLOEXEC flag works.
         // Without a cheap & reliable way to detect 10.6 vs 10.7 at
         // runtime, we just always call syscall.CloseOnExec on Darwin.
         // Once >=10.7 is prevalent, this extra call can removed.
         if syscall.O_CLOEXEC == 0 || runtime.GOOS == "darwin" { // O_CLOEXEC not supported
                 syscall.CloseOnExec(r)
         }
 
-        return NewFile(r, name), nil
+        return NewFile(uintptr(r), name), nil
 }
 
 // Close closes the File, rendering it unusable for I/O.
 // It returns an error, if any.
 func (f *File) Close() error {
         return f.file.close()
 }
 
 func (file *file) close() error {
         if file == nil || file.fd < 0 {
@@ skipping 15 matching lines @@
 func (f *File) Stat() (fi FileInfo, err error) {
         var stat syscall.Stat_t
         err = syscall.Fstat(f.fd, &stat)
         if err != nil {
                 return nil, &PathError{"stat", f.name, err}
         }
         return fileInfoFromStat(&stat, f.name), nil
 }
 
 // Stat returns a FileInfo describing the named file.
-// If name names a valid symbolic link, the returned FileInfo describes
-// the file pointed at by the link and has fi.FollowedSymlink set to true.
-// If name names an invalid symbolic link, the returned FileInfo describes
-// the link itself and has fi.FollowedSymlink set to false.
 // If there is an error, it will be of type *PathError.
 func Stat(name string) (fi FileInfo, err error) {
         var stat syscall.Stat_t
         err = syscall.Stat(name, &stat)
         if err != nil {
                 return nil, &PathError{"stat", name, err}
         }
         return fileInfoFromStat(&stat, name), nil
 }
 
@@ skipping 130 matching lines @@
         syscall.ForkLock.RLock()
         e := syscall.Pipe(p[0:])
         if e != nil {
                 syscall.ForkLock.RUnlock()
                 return nil, nil, NewSyscallError("pipe", e)
         }
         syscall.CloseOnExec(p[0])
         syscall.CloseOnExec(p[1])
         syscall.ForkLock.RUnlock()
 
-        return NewFile(p[0], "|0"), NewFile(p[1], "|1"), nil
+        return NewFile(uintptr(p[0]), "|0"), NewFile(uintptr(p[1]), "|1"), nil
 }
 
 // TempDir returns the default directory to use for temporary files.
 func TempDir() string {
         dir := Getenv("TMPDIR")
         if dir == "" {
                 dir = "/tmp"
         }
         return dir
 }