libgo/go/os/types.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package os
   6
   7 import (
   8         "syscall"
   9         "time"
  10 )
  11
  12 // Getpagesize returns the underlying system's memory page size.
  13 func Getpagesize() int { return syscall.Getpagesize() }
  14
  15 // A FileInfo describes a file and is returned by Stat and Lstat
  16 type FileInfo interface {
  17         Name() string       // base name of the file
  18         Size() int64        // length in bytes for regular files; system-dependent for others
  19         Mode() FileMode     // file mode bits
  20         ModTime() time.Time // modification time
  21         IsDir() bool        // abbreviation for Mode().IsDir()
  22         Sys() interface{}   // underlying data source (can return nil)
  23 }
  24
  25 // A FileMode represents a file's mode and permission bits.
  26 // The bits have the same definition on all systems, so that
  27 // information about files can be moved from one system
  28 // to another portably.  Not all bits apply to all systems.
  29 // The only required bit is ModeDir for directories.
  30 type FileMode uint32
  31
  32 // The defined file mode bits are the most significant bits of the FileMode.
  33 // The nine least-significant bits are the standard Unix rwxrwxrwx permissions.
  34 // The values of these bits should be considered part of the public API and
  35 // may be used in wire protocols or disk representations: they must not be
  36 // changed, although new bits might be added.
  37 const (
  38         // The single letters are the abbreviations
  39         // used by the String method's formatting.
  40         ModeDir        FileMode = 1 << (32 - 1 - iota) // d: is a directory
  41         ModeAppend                                     // a: append-only
  42         ModeExclusive                                  // l: exclusive use
  43         ModeTemporary                                  // T: temporary file (not backed up)
  44         ModeSymlink                                    // L: symbolic link
  45         ModeDevice                                     // D: device file
  46         ModeNamedPipe                                  // p: named pipe (FIFO)
  47         ModeSocket                                     // S: Unix domain socket
  48         ModeSetuid                                     // u: setuid
  49         ModeSetgid                                     // g: setgid
  50         ModeCharDevice                                 // c: Unix character device, when ModeDevice is set
  51         ModeSticky                                     // t: sticky
  52
  53         // Mask for the type bits. For regular files, none will be set.
  54         ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
  55
  56         ModePerm FileMode = 0777 // permission bits
  57 )
  58
  59 func (m FileMode) String() string {
  60         const str = "dalTLDpSugct"
  61         var buf [20]byte
  62         w := 0
  63         for i, c := range str {
  64                 if m&(1<<uint(32-1-i)) != 0 {
  65                         buf[w] = byte(c)
  66                         w++
  67                 }
  68         }
  69         if w == 0 {
  70                 buf[w] = '-'
  71                 w++
  72         }
  73         const rwx = "rwxrwxrwx"
  74         for i, c := range rwx {
  75                 if m&(1<<uint(9-1-i)) != 0 {
  76                         buf[w] = byte(c)
  77                 } else {
  78                         buf[w] = '-'
  79                 }
  80                 w++
  81         }
  82         return string(buf[:w])
  83 }
  84
  85 // IsDir reports whether m describes a directory.
  86 // That is, it tests for the ModeDir bit being set in m.
  87 func (m FileMode) IsDir() bool {
  88         return m&ModeDir != 0
  89 }
  90
  91 // Perm returns the Unix permission bits in m.
  92 func (m FileMode) Perm() FileMode {
  93         return m & ModePerm
  94 }
  95
  96 // A fileStat is the implementation of FileInfo returned by Stat and Lstat.
  97 type fileStat struct {
  98         name    string
  99         size    int64
 100         mode    FileMode
 101         modTime time.Time
 102         sys     interface{}
 103 }
 104
 105 func (fs *fileStat) Name() string       { return fs.name }
 106 func (fs *fileStat) Size() int64        { return fs.size }
 107 func (fs *fileStat) Mode() FileMode     { return fs.mode }
 108 func (fs *fileStat) ModTime() time.Time { return fs.modTime }
 109 func (fs *fileStat) IsDir() bool        { return fs.mode.IsDir() }
 110 func (fs *fileStat) Sys() interface{}   { return fs.sys }
 111
 112 // SameFile reports whether fi1 and fi2 describe the same file.
 113 // For example, on Unix this means that the device and inode fields
 114 // of the two underlying structures are identical; on other systems
 115 // the decision may be based on the path names.
 116 // SameFile only applies to results returned by this package's Stat.
 117 // It returns false in other cases.
 118 func SameFile(fi1, fi2 FileInfo) bool {
 119         fs1, ok1 := fi1.(*fileStat)
 120         fs2, ok2 := fi2.(*fileStat)
 121         if !ok1 || !ok2 {
 122                 return false
 123         }
 124         return sameFile(fs1.sys, fs2.sys)
 125 }