types.go 4.04 KB
Newer Older
1 2 3 4 5 6
// 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

7 8 9 10
import (
	"syscall"
	"time"
)
11 12 13 14

// Getpagesize returns the underlying system's memory page size.
func Getpagesize() int { return syscall.Getpagesize() }

15 16 17 18 19
// File represents an open file descriptor.
type File struct {
	*file // os specific
}

20
// A FileInfo describes a file and is returned by Stat and Lstat.
21 22
type FileInfo interface {
	Name() string       // base name of the file
23
	Size() int64        // length in bytes for regular files; system-dependent for others
24 25 26
	Mode() FileMode     // file mode bits
	ModTime() time.Time // modification time
	IsDir() bool        // abbreviation for Mode().IsDir()
27
	Sys() interface{}   // underlying data source (can return nil)
28 29
}

30 31 32
// 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
33
// to another portably. Not all bits apply to all systems.
34 35
// The only required bit is ModeDir for directories.
type FileMode uint32
36

37 38
// The defined file mode bits are the most significant bits of the FileMode.
// The nine least-significant bits are the standard Unix rwxrwxrwx permissions.
39 40 41
// 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.
42 43 44
const (
	// The single letters are the abbreviations
	// used by the String method's formatting.
45 46 47
	ModeDir        FileMode = 1 << (32 - 1 - iota) // d: is a directory
	ModeAppend                                     // a: append-only
	ModeExclusive                                  // l: exclusive use
48
	ModeTemporary                                  // T: temporary file (not backed up)
49 50 51 52 53 54 55
	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
56
	ModeSticky                                     // t: sticky
57

58 59
	// Mask for the type bits. For regular files, none will be set.
	ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
60

61
	ModePerm FileMode = 0777 // Unix permission bits
62
)
63

64
func (m FileMode) String() string {
65
	const str = "dalTLDpSugct"
66
	var buf [32]byte // Mode is uint32.
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
	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])
}
89

90 91 92 93 94 95
// 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
}

96 97 98 99 100 101
// 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
}

102 103 104 105
// Perm returns the Unix permission bits in m.
func (m FileMode) Perm() FileMode {
	return m & ModePerm
}
106

107 108
func (fs *fileStat) Name() string { return fs.name }
func (fs *fileStat) IsDir() bool  { return fs.Mode().IsDir() }
109

110
// SameFile reports whether fi1 and fi2 describe the same file.
111 112 113
// 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.
114 115 116 117 118 119 120 121
// 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
	}
122
	return sameFile(fs1, fs2)
123
}