...
Run Format

Source file src/os/types.go

Documentation: os

  // 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.
  
  package os
  
  import (
  	"syscall"
  	"time"
  )
  
  // Getpagesize returns the underlying system's memory page size.
  func Getpagesize() int { return syscall.Getpagesize() }
  
  // File represents an open file descriptor.
  type File struct {
  	*file // os specific
  }
  
  // A FileInfo describes a file and is returned by Stat and Lstat.
  type FileInfo interface {
  	Name() string       // base name of the file
  	Size() int64        // length in bytes for regular files; system-dependent for others
  	Mode() FileMode     // file mode bits
  	ModTime() time.Time // modification time
  	IsDir() bool        // abbreviation for Mode().IsDir()
  	Sys() interface{}   // underlying data source (can return nil)
  }
  
  // A FileMode represents a file's mode and permission bits.
  // The bits have the same definition on all systems, so that
  // information about files can be moved from one system
  // to another portably. Not all bits apply to all systems.
  // The only required bit is ModeDir for directories.
  type FileMode uint32
  
  // The defined file mode bits are the most significant bits of the FileMode.
  // The nine least-significant bits are the standard Unix rwxrwxrwx permissions.
  // The values of these bits should be considered part of the public API and
  // may be used in wire protocols or disk representations: they must not be
  // changed, although new bits might be added.
  const (
  	// The single letters are the abbreviations
  	// used by the String method's formatting.
  	ModeDir        FileMode = 1 << (32 - 1 - iota) // d: is a directory
  	ModeAppend                                     // a: append-only
  	ModeExclusive                                  // l: exclusive use
  	ModeTemporary                                  // T: temporary file (not backed up)
  	ModeSymlink                                    // L: symbolic link
  	ModeDevice                                     // D: device file
  	ModeNamedPipe                                  // p: named pipe (FIFO)
  	ModeSocket                                     // S: Unix domain socket
  	ModeSetuid                                     // u: setuid
  	ModeSetgid                                     // g: setgid
  	ModeCharDevice                                 // c: Unix character device, when ModeDevice is set
  	ModeSticky                                     // t: sticky
  
  	// Mask for the type bits. For regular files, none will be set.
  	ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
  
  	ModePerm FileMode = 0777 // Unix permission bits
  )
  
  func (m FileMode) String() string {
  	const str = "dalTLDpSugct"
  	var buf [32]byte // Mode is uint32.
  	w := 0
  	for i, c := range str {
  		if m&(1<<uint(32-1-i)) != 0 {
  			buf[w] = byte(c)
  			w++
  		}
  	}
  	if w == 0 {
  		buf[w] = '-'
  		w++
  	}
  	const rwx = "rwxrwxrwx"
  	for i, c := range rwx {
  		if m&(1<<uint(9-1-i)) != 0 {
  			buf[w] = byte(c)
  		} else {
  			buf[w] = '-'
  		}
  		w++
  	}
  	return string(buf[:w])
  }
  
  // IsDir reports whether m describes a directory.
  // That is, it tests for the ModeDir bit being set in m.
  func (m FileMode) IsDir() bool {
  	return m&ModeDir != 0
  }
  
  // IsRegular reports whether m describes a regular file.
  // That is, it tests that no mode type bits are set.
  func (m FileMode) IsRegular() bool {
  	return m&ModeType == 0
  }
  
  // Perm returns the Unix permission bits in m.
  func (m FileMode) Perm() FileMode {
  	return m & ModePerm
  }
  
  func (fs *fileStat) Name() string { return fs.name }
  func (fs *fileStat) IsDir() bool  { return fs.Mode().IsDir() }
  
  // SameFile reports whether fi1 and fi2 describe the same file.
  // For example, on Unix this means that the device and inode fields
  // of the two underlying structures are identical; on other systems
  // the decision may be based on the path names.
  // SameFile only applies to results returned by this package's Stat.
  // It returns false in other cases.
  func SameFile(fi1, fi2 FileInfo) bool {
  	fs1, ok1 := fi1.(*fileStat)
  	fs2, ok2 := fi2.(*fileStat)
  	if !ok1 || !ok2 {
  		return false
  	}
  	return sameFile(fs1, fs2)
  }
  

View as plain text