package os

Import Path
	os (on go.dev)

Dependency Relation
	imports 16 packages, and imported by 23 packages

Involved Source Files

	    dir.go
	    dir_unix.go
	    dirent_linux.go
	    endian_little.go
	    env.go
	    error.go
	    error_errno.go
	    error_posix.go
	    exec.go
	    exec_posix.go
	    exec_unix.go
	    executable.go
	    executable_procfs.go
	  d file.go
		Package os provides a platform-independent interface to operating system
		functionality. The design is Unix-like, although the error handling is
		Go-like; failing calls return values of type error rather than error numbers.
		Often, more information is available within the error. For example,
		if a call that takes a file name fails, such as Open or Stat, the error
		will include the failing file name when printed and will be of type
		*PathError, which may be unpacked for more information.
		
		The os interface is intended to be uniform across all operating systems.
		Features not generally available appear in the system-specific package syscall.
		
		Here is a simple example, opening a file and reading some of it.
		
			file, err := os.Open("file.go") // For read access.
			if err != nil {
				log.Fatal(err)
			}
		
		If the open fails, the error string will be self-explanatory, like
		
			open file.go: no such file or directory
		
		The file's data can then be read into a slice of bytes. Read and
		Write take their byte counts from the length of the argument slice.
		
			data := make([]byte, 100)
			count, err := file.Read(data)
			if err != nil {
				log.Fatal(err)
			}
			fmt.Printf("read %d bytes: %q\n", count, data[:count])
		
		Note: The maximum number of concurrent operations on a File may be limited by
		the OS or the system. The number should be high, but exceeding it may degrade
		performance or cause other issues.

	    file_open_unix.go
	    file_posix.go
	    file_unix.go
	    getwd.go
	    path.go
	    path_unix.go
	    pipe2_unix.go
	    proc.go
	    rawconn.go
	    readfrom_linux.go
	    removeall_at.go
	    stat.go
	    stat_linux.go
	    stat_unix.go
	    sticky_notbsd.go
	    str.go
	    sys.go
	    sys_linux.go
	    sys_unix.go
	    tempfile.go
	    types.go
	    types_unix.go
	    wait_waitid.go
Code Examples

	Chmod
		package main
		
		import (
			"log"
			"os"
		)
		
		func main() {
			if err := os.Chmod("some-filename", 0644); err != nil {
				log.Fatal(err)
			}
		}

	Chtimes
		package main
		
		import (
			"log"
			"os"
			"time"
		)
		
		func main() {
			mtime := time.Date(2006, time.February, 1, 3, 4, 5, 0, time.UTC)
			atime := time.Date(2007, time.March, 2, 4, 5, 6, 0, time.UTC)
			if err := os.Chtimes("some-filename", atime, mtime); err != nil {
				log.Fatal(err)
			}
		}

	CreateTemp
		package main
		
		import (
			"log"
			"os"
		)
		
		func main() {
			f, err := os.CreateTemp("", "example")
			if err != nil {
				log.Fatal(err)
			}
			defer os.Remove(f.Name()) // clean up
		
			if _, err := f.Write([]byte("content")); err != nil {
				log.Fatal(err)
			}
			if err := f.Close(); err != nil {
				log.Fatal(err)
			}
		}

	CreateTemp_suffix
		package main
		
		import (
			"log"
			"os"
		)
		
		func main() {
			f, err := os.CreateTemp("", "example.*.txt")
			if err != nil {
				log.Fatal(err)
			}
			defer os.Remove(f.Name()) // clean up
		
			if _, err := f.Write([]byte("content")); err != nil {
				f.Close()
				log.Fatal(err)
			}
			if err := f.Close(); err != nil {
				log.Fatal(err)
			}
		}

	ErrNotExist
		package main
		
		import (
			"errors"
			"fmt"
			"io/fs"
			"os"
		)
		
		func main() {
			filename := "a-nonexistent-file"
			if _, err := os.Stat(filename); errors.Is(err, fs.ErrNotExist) {
				fmt.Println("file does not exist")
			}
		}

	Expand
		package main
		
		import (
			"fmt"
			"os"
		)
		
		func main() {
			mapper := func(placeholderName string) string {
				switch placeholderName {
				case "DAY_PART":
					return "morning"
				case "NAME":
					return "Gopher"
				}
		
				return ""
			}
		
			fmt.Println(os.Expand("Good ${DAY_PART}, $NAME!", mapper))
		
		}

	ExpandEnv
		package main
		
		import (
			"fmt"
			"os"
		)
		
		func main() {
			os.Setenv("NAME", "gopher")
			os.Setenv("BURROW", "/usr/gopher")
		
			fmt.Println(os.ExpandEnv("$NAME lives in ${BURROW}."))
		
		}

	FileMode
		package main
		
		import (
			"fmt"
			"io/fs"
			"log"
			"os"
		)
		
		func main() {
			fi, err := os.Lstat("some-filename")
			if err != nil {
				log.Fatal(err)
			}
		
			fmt.Printf("permissions: %#o\n", fi.Mode().Perm()) // 0400, 0777, etc.
			switch mode := fi.Mode(); {
			case mode.IsRegular():
				fmt.Println("regular file")
			case mode.IsDir():
				fmt.Println("directory")
			case mode&fs.ModeSymlink != 0:
				fmt.Println("symbolic link")
			case mode&fs.ModeNamedPipe != 0:
				fmt.Println("named pipe")
			}
		}

	Getenv
		package main
		
		import (
			"fmt"
			"os"
		)
		
		func main() {
			os.Setenv("NAME", "gopher")
			os.Setenv("BURROW", "/usr/gopher")
		
			fmt.Printf("%s lives in %s.\n", os.Getenv("NAME"), os.Getenv("BURROW"))
		
		}

	LookupEnv
		package main
		
		import (
			"fmt"
			"os"
		)
		
		func main() {
			show := func(key string) {
				val, ok := os.LookupEnv(key)
				if !ok {
					fmt.Printf("%s not set\n", key)
				} else {
					fmt.Printf("%s=%s\n", key, val)
				}
			}
		
			os.Setenv("SOME_KEY", "value")
			os.Setenv("EMPTY_KEY", "")
		
			show("SOME_KEY")
			show("EMPTY_KEY")
			show("MISSING_KEY")
		
		}

	Mkdir
		package main
		
		import (
			"log"
			"os"
		)
		
		func main() {
			err := os.Mkdir("testdir", 0750)
			if err != nil && !os.IsExist(err) {
				log.Fatal(err)
			}
			err = os.WriteFile("testdir/testfile.txt", []byte("Hello, Gophers!"), 0660)
			if err != nil {
				log.Fatal(err)
			}
		}

	MkdirAll
		package main
		
		import (
			"log"
			"os"
		)
		
		func main() {
			err := os.MkdirAll("test/subdir", 0750)
			if err != nil {
				log.Fatal(err)
			}
			err = os.WriteFile("test/subdir/testfile.txt", []byte("Hello, Gophers!"), 0660)
			if err != nil {
				log.Fatal(err)
			}
		}

	MkdirTemp
		package main
		
		import (
			"log"
			"os"
			"path/filepath"
		)
		
		func main() {
			dir, err := os.MkdirTemp("", "example")
			if err != nil {
				log.Fatal(err)
			}
			defer os.RemoveAll(dir) // clean up
		
			file := filepath.Join(dir, "tmpfile")
			if err := os.WriteFile(file, []byte("content"), 0666); err != nil {
				log.Fatal(err)
			}
		}

	MkdirTemp_suffix
		package main
		
		import (
			"log"
			"os"
			"path/filepath"
		)
		
		func main() {
			logsDir, err := os.MkdirTemp("", "*-logs")
			if err != nil {
				log.Fatal(err)
			}
			defer os.RemoveAll(logsDir) // clean up
		
			// Logs can be cleaned out earlier if needed by searching
			// for all directories whose suffix ends in *-logs.
			globPattern := filepath.Join(os.TempDir(), "*-logs")
			matches, err := filepath.Glob(globPattern)
			if err != nil {
				log.Fatalf("Failed to match %q: %v", globPattern, err)
			}
		
			for _, match := range matches {
				if err := os.RemoveAll(match); err != nil {
					log.Printf("Failed to remove %q: %v", match, err)
				}
			}
		}

	OpenFile
		package main
		
		import (
			"log"
			"os"
		)
		
		func main() {
			f, err := os.OpenFile("notes.txt", os.O_RDWR|os.O_CREATE, 0755)
			if err != nil {
				log.Fatal(err)
			}
			if err := f.Close(); err != nil {
				log.Fatal(err)
			}
		}

	OpenFile_append
		package main
		
		import (
			"log"
			"os"
		)
		
		func main() {
			// If the file doesn't exist, create it, or append to the file
			f, err := os.OpenFile("access.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
			if err != nil {
				log.Fatal(err)
			}
			if _, err := f.Write([]byte("appended some data\n")); err != nil {
				f.Close() // ignore error; Write error takes precedence
				log.Fatal(err)
			}
			if err := f.Close(); err != nil {
				log.Fatal(err)
			}
		}

	ReadDir
		package main
		
		import (
			"fmt"
			"log"
			"os"
		)
		
		func main() {
			files, err := os.ReadDir(".")
			if err != nil {
				log.Fatal(err)
			}
		
			for _, file := range files {
				fmt.Println(file.Name())
			}
		}

	ReadFile
		package main
		
		import (
			"log"
			"os"
		)
		
		func main() {
			data, err := os.ReadFile("testdata/hello")
			if err != nil {
				log.Fatal(err)
			}
			os.Stdout.Write(data)
		
		}

	Unsetenv
		package main
		
		import (
			"os"
		)
		
		func main() {
			os.Setenv("TMPDIR", "/my/tmp")
			defer os.Unsetenv("TMPDIR")
		}

	WriteFile
		package main
		
		import (
			"log"
			"os"
		)
		
		func main() {
			err := os.WriteFile("testdata/hello", []byte("Hello, Gophers!"), 0666)
			if err != nil {
				log.Fatal(err)
			}
		}


Package-Level Type Names (total 22, in which 11 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type DirEntry = fs.DirEntry (interface)
		A DirEntry is an entry read from a directory
		(using the ReadDir function or a File's ReadDir method).

	 type File (struct)
		File represents an open file descriptor.

		Fields (total 7, none are exported)
			/* 7 unexporteds ... *//* 7 unexporteds: */
			file *file
				// os specific

			file.appendMode bool
				// whether file is opened for appending

			file.dirinfo *dirInfo
				// nil unless directory being read

			file.name string
			file.nonblock bool
				// whether we set nonblocking mode

			file.pfd poll.FD
			file.stdoutOrErr bool
				// whether this is stdout or stderr

		Methods (total 39, in which 23 are exported)
			(*File) Chdir() error
				Chdir changes the current working directory to the file,
				which must be a directory.
				If there is an error, it will be of type *PathError.

			(*File) Chmod(mode FileMode) error
				Chmod changes the mode of the file to mode.
				If there is an error, it will be of type *PathError.

			(*File) Chown(uid, gid int) error
				Chown changes the numeric uid and gid of the named file.
				If there is an error, it will be of type *PathError.
				
				On Windows, it always returns the syscall.EWINDOWS error, wrapped
				in *PathError.

			(*File) Close() error
				Close closes the File, rendering it unusable for I/O.
				On files that support SetDeadline, any pending I/O operations will
				be canceled and return immediately with an ErrClosed error.
				Close will return an error if it has already been called.

			(*File) Fd() uintptr
				Fd returns the integer Unix file descriptor referencing the open file.
				If f is closed, the file descriptor becomes invalid.
				If f is garbage collected, a finalizer may close the file descriptor,
				making it invalid; see runtime.SetFinalizer for more information on when
				a finalizer might be run. On Unix systems this will cause the SetDeadline
				methods to stop working.
				Because file descriptors can be reused, the returned file descriptor may
				only be closed through the Close method of f, or by its finalizer during
				garbage collection. Otherwise, during garbage collection the finalizer
				may close an unrelated file descriptor with the same (reused) number.
				
				As an alternative, see the f.SyscallConn method.

			(*File) Name() string
				Name returns the name of the file as presented to Open.

			(*File) Read(b []byte) (n int, err error)
				Read reads up to len(b) bytes from the File and stores them in b.
				It returns the number of bytes read and any error encountered.
				At end of file, Read returns 0, io.EOF.

			(*File) ReadAt(b []byte, off int64) (n int, err error)
				ReadAt reads len(b) bytes from the File starting at byte offset off.
				It returns the number of bytes read and the error, if any.
				ReadAt always returns a non-nil error when n < len(b).
				At end of file, that error is io.EOF.

			(*File) ReadDir(n int) ([]DirEntry, error)
				ReadDir reads the contents of the directory associated with the file f
				and returns a slice of DirEntry values in directory order.
				Subsequent calls on the same file will yield later DirEntry records in the directory.
				
				If n > 0, ReadDir returns at most n DirEntry records.
				In this case, if ReadDir returns an empty slice, it will return an error explaining why.
				At the end of a directory, the error is io.EOF.
				
				If n <= 0, ReadDir returns all the DirEntry records remaining in the directory.
				When it succeeds, it returns a nil error (not io.EOF).

			(*File) ReadFrom(r io.Reader) (n int64, err error)
				ReadFrom implements io.ReaderFrom.

			(*File) Readdir(n int) ([]FileInfo, error)
				Readdir reads the contents of the directory associated with file and
				returns a slice of up to n FileInfo values, as would be returned
				by Lstat, in directory order. Subsequent calls on the same file will yield
				further FileInfos.
				
				If n > 0, Readdir returns at most n FileInfo structures. In this case, if
				Readdir returns an empty slice, it will return a non-nil error
				explaining why. At the end of a directory, the error is io.EOF.
				
				If n <= 0, Readdir returns all the FileInfo from the directory in
				a single slice. In this case, if Readdir succeeds (reads all
				the way to the end of the directory), it returns the slice and a
				nil error. If it encounters an error before the end of the
				directory, Readdir returns the FileInfo read until that point
				and a non-nil error.
				
				Most clients are better served by the more efficient ReadDir method.

			(*File) Readdirnames(n int) (names []string, err error)
				Readdirnames reads the contents of the directory associated with file
				and returns a slice of up to n names of files in the directory,
				in directory order. Subsequent calls on the same file will yield
				further names.
				
				If n > 0, Readdirnames returns at most n names. In this case, if
				Readdirnames returns an empty slice, it will return a non-nil error
				explaining why. At the end of a directory, the error is io.EOF.
				
				If n <= 0, Readdirnames returns all the names from the directory in
				a single slice. In this case, if Readdirnames succeeds (reads all
				the way to the end of the directory), it returns the slice and a
				nil error. If it encounters an error before the end of the
				directory, Readdirnames returns the names read until that point and
				a non-nil error.

			(*File) Seek(offset int64, whence int) (ret int64, err error)
				Seek sets the offset for the next Read or Write on file to offset, interpreted
				according to whence: 0 means relative to the origin of the file, 1 means
				relative to the current offset, and 2 means relative to the end.
				It returns the new offset and an error, if any.
				The behavior of Seek on a file opened with O_APPEND is not specified.

			(*File) SetDeadline(t time.Time) error
				SetDeadline sets the read and write deadlines for a File.
				It is equivalent to calling both SetReadDeadline and SetWriteDeadline.
				
				Only some kinds of files support setting a deadline. Calls to SetDeadline
				for files that do not support deadlines will return ErrNoDeadline.
				On most systems ordinary files do not support deadlines, but pipes do.
				
				A deadline is an absolute time after which I/O operations fail with an
				error instead of blocking. The deadline applies to all future and pending
				I/O, not just the immediately following call to Read or Write.
				After a deadline has been exceeded, the connection can be refreshed
				by setting a deadline in the future.
				
				If the deadline is exceeded a call to Read or Write or to other I/O
				methods will return an error that wraps ErrDeadlineExceeded.
				This can be tested using errors.Is(err, os.ErrDeadlineExceeded).
				That error implements the Timeout method, and calling the Timeout
				method will return true, but there are other possible errors for which
				the Timeout will return true even if the deadline has not been exceeded.
				
				An idle timeout can be implemented by repeatedly extending
				the deadline after successful Read or Write calls.
				
				A zero value for t means I/O operations will not time out.

			(*File) SetReadDeadline(t time.Time) error
				SetReadDeadline sets the deadline for future Read calls and any
				currently-blocked Read call.
				A zero value for t means Read will not time out.
				Not all files support setting deadlines; see SetDeadline.

			(*File) SetWriteDeadline(t time.Time) error
				SetWriteDeadline sets the deadline for any future Write calls and any
				currently-blocked Write call.
				Even if Write times out, it may return n > 0, indicating that
				some of the data was successfully written.
				A zero value for t means Write will not time out.
				Not all files support setting deadlines; see SetDeadline.

			(*File) Stat() (FileInfo, error)
				Stat returns the FileInfo structure describing file.
				If there is an error, it will be of type *PathError.

			(*File) Sync() error
				Sync commits the current contents of the file to stable storage.
				Typically, this means flushing the file system's in-memory copy
				of recently written data to disk.

			(*File) SyscallConn() (syscall.RawConn, error)
				SyscallConn returns a raw file.
				This implements the syscall.Conn interface.

			(*File) Truncate(size int64) error
				Truncate changes the size of the file.
				It does not change the I/O offset.
				If there is an error, it will be of type *PathError.

			(*File) Write(b []byte) (n int, err error)
				Write writes len(b) bytes from b to the File.
				It returns the number of bytes written and an error, if any.
				Write returns a non-nil error when n != len(b).

			(*File) WriteAt(b []byte, off int64) (n int, err error)
				WriteAt writes len(b) bytes to the File starting at byte offset off.
				It returns the number of bytes written and an error, if any.
				WriteAt returns a non-nil error when n != len(b).
				
				If file was opened with the O_APPEND flag, WriteAt returns an error.

			(*File) WriteString(s string) (n int, err error)
				WriteString is like Write, but writes the contents of string s rather than
				a slice of bytes.

			/* 16 unexporteds ... *//* 16 unexporteds: */
			(*File) checkValid(op string) error
				checkValid checks whether f is valid for use.
				If not, it returns an appropriate error, perhaps incorporating the operation name op.

			(*File) chmod(mode FileMode) error
				See docs in file.go:(*File).Chmod.

			( File) close() error
			(*File) copyFileRange(r io.Reader) (written int64, handled bool, err error)
			(*File) pread(b []byte, off int64) (n int, err error)
				pread reads len(b) bytes from the File starting at byte offset off.
				It returns the number of bytes read and the error, if any.
				EOF is signaled by a zero count with err set to nil.

			(*File) pwrite(b []byte, off int64) (n int, err error)
				pwrite writes len(b) bytes to the File starting at byte offset off.
				It returns the number of bytes written and an error, if any.

			(*File) read(b []byte) (n int, err error)
				read reads up to len(b) bytes from the File.
				It returns the number of bytes read and an error, if any.

			(*File) readFrom(r io.Reader) (written int64, handled bool, err error)
			(*File) readdir(n int, mode readdirMode) (names []string, dirents []DirEntry, infos []FileInfo, err error)
			(*File) seek(offset int64, whence int) (ret int64, err error)
				seek sets the offset for the next Read or Write on file to offset, interpreted
				according to whence: 0 means relative to the origin of the file, 1 means
				relative to the current offset, and 2 means relative to the end.
				It returns the new offset and an error, if any.

			(*File) setDeadline(t time.Time) error
				setDeadline sets the read and write deadline.

			(*File) setReadDeadline(t time.Time) error
				setReadDeadline sets the read deadline.

			(*File) setWriteDeadline(t time.Time) error
				setWriteDeadline sets the write deadline.

			(*File) spliceToFile(r io.Reader) (written int64, handled bool, err error)
			(*File) wrapErr(op string, err error) error
				wrapErr wraps an error that occurred during an operation on an open file.
				It passes io.EOF through unchanged, otherwise converts
				poll.ErrFileClosing to ErrClosed and wraps the error in a PathError.

			(*File) write(b []byte) (n int, err error)
				write writes len(b) bytes to the File.
				It returns the number of bytes written and an error, if any.

		Implements (at least 26, in which 24 are exported)
			*File : go.uber.org/zap.Sink
			*File : go.uber.org/zap/zapcore.WriteSyncer
			*File : internal/bisect.Writer
			*File : io.Closer
			*File : io.ReadCloser
			*File : io.Reader
			*File : io.ReaderAt
			*File : io.ReaderFrom
			*File : io.ReadSeekCloser
			*File : io.ReadSeeker
			*File : io.ReadWriteCloser
			*File : io.ReadWriter
			*File : io.ReadWriteSeeker
			*File : io.Seeker
			*File : io.StringWriter
			*File : io.WriteCloser
			*File : io.Writer
			*File : io.WriterAt
			*File : io.WriteSeeker
			*File : io/fs.File
			*File : io/fs.ReadDirFile
			*File : mime/multipart.File
			*File : net/http.File
			*File : syscall.Conn
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*File : crypto/tls.transcriptHash
			*File : net/http.http2stringWriter
		As Outputs Of (at least 17, in which 10 are exported)
			func Create(name string) (*File, error)
			func CreateTemp(dir, pattern string) (*File, error)
			func NewFile(fd uintptr, name string) *File
			func Open(name string) (*File, error)
			func OpenFile(name string, flag int, perm FileMode) (*File, error)
			func Pipe() (r *File, w *File, err error)
			func Pipe() (r *File, w *File, err error)
			func io/ioutil.TempFile(dir, pattern string) (f *File, err error)
			func net.(*TCPListener).File() (f *File, err error)
			func net.(*UnixListener).File() (f *File, err error)
			/* 7+ unexporteds ... *//* 7+ unexporteds: */
			func net_newUnixFile(fd int, name string) *File
			func newFile(fd int, name string, kind newFileKind) *File
			func openFdAt(dirfd int, name string) (*File, error)
			func openFileNolog(name string, flag int, perm FileMode) (*File, error)
			func net.newUnixFile(fd int, name string) *File
			func net.(*TCPListener).file() (*File, error)
			func net.(*UnixListener).file() (*File, error)
		As Inputs Of (at least 12, in which 3 are exported)
			func net.FileConn(f *File) (c net.Conn, err error)
			func net.FileListener(f *File) (ln net.Listener, err error)
			func net.FilePacketConn(f *File) (c net.PacketConn, err error)
			/* 9+ unexporteds ... *//* 9+ unexporteds: */
			func epipecheck(file *File, e error)
			func genericReadFrom(f *File, r io.Reader) (int64, error)
			func newRawConn(file *File) (*rawConn, error)
			func removeAllFrom(parent *File, base string) error
			func net.dupSocket(f *File) (int, error)
			func net.fileConn(f *File) (net.Conn, error)
			func net.fileListener(f *File) (net.Listener, error)
			func net.filePacketConn(f *File) (net.PacketConn, error)
			func net.newFileFD(f *File) (*net.netFD, error)
		As Types Of (total 3, all are exported)
			  var Stderr *File
			  var Stdin *File
			  var Stdout *File

	 type FileInfo = fs.FileInfo (interface)
		A FileInfo describes a file and is returned by Stat and Lstat.

	 type FileMode = fs.FileMode (basic type)
		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 LinkError (struct)
		LinkError records an error during a link or symlink or rename
		system call and the paths that caused it.

		Fields (total 4, all are exported)
			Err error
			New string
			Old string
			Op string
		Methods (total 2, both are exported)
			(*LinkError) Error() string
			(*LinkError) Unwrap() error
		Implements (at least 2, both are exported)
			*LinkError : error
			*LinkError : github.com/go-faster/errors.Wrapper

	 type PathError = fs.PathError (struct)
		PathError records an error and the operation and file path that caused it.

	 type ProcAttr (struct)
		ProcAttr holds the attributes that will be applied to a new process
		started by StartProcess.

		Fields (total 4, all are exported)
			Dir string
				If Dir is non-empty, the child changes into the directory before
				creating the process.

			Env []string
				If Env is non-nil, it gives the environment variables for the
				new process in the form returned by Environ.
				If it is nil, the result of Environ will be used.

			Files []*File
				Files specifies the open files inherited by the new process. The
				first three entries correspond to standard input, standard output, and
				standard error. An implementation may support additional entries,
				depending on the underlying operating system. A nil entry corresponds
				to that file being closed when the process starts.
				On Unix systems, StartProcess will change these File values
				to blocking mode, which means that SetDeadline will stop working
				and calling Close will not interrupt a Read or Write.

			Sys *syscall.SysProcAttr
				Operating system-specific process creation attributes.
				Note that setting this field means that your program
				may not execute properly or even compile on some
				operating systems.

		As Inputs Of (at least 2, in which 1 is exported)
			func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)
			/* at least one unexported ... *//* at least one unexported: */
			func startProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error)

	 type Process (struct)
		Process stores the information about a process created by StartProcess.

		Fields (total 4, in which 1 is exported)
			Pid int
			/* 3 unexporteds ... *//* 3 unexporteds: */
			handle uintptr
				// handle is accessed atomically on Windows

			isdone atomic.Bool
				// process has been successfully waited on

			sigMu sync.RWMutex
				// avoid race between wait and signal

		Methods (total 11, in which 4 are exported)
			(*Process) Kill() error
				Kill causes the Process to exit immediately. Kill does not wait until
				the Process has actually exited. This only kills the Process itself,
				not any other processes it may have started.

			(*Process) Release() error
				Release releases any resources associated with the Process p,
				rendering it unusable in the future.
				Release only needs to be called if Wait is not.

			(*Process) Signal(sig Signal) error
				Signal sends a signal to the Process.
				Sending Interrupt on Windows is not implemented.

			(*Process) Wait() (*ProcessState, error)
				Wait waits for the Process to exit, and then returns a
				ProcessState describing its status and an error, if any.
				Wait releases any resources associated with the Process.
				On most operating systems, the Process must be a child
				of the current process or an error will be returned.

			/* 7 unexporteds ... *//* 7 unexporteds: */
			(*Process) blockUntilWaitable() (bool, error)
				blockUntilWaitable attempts to block until a call to p.Wait will
				succeed immediately, and reports whether it has done so.
				It does not actually call p.Wait.

			(*Process) done() bool
			(*Process) kill() error
			(*Process) release() error
			(*Process) setDone()
			(*Process) signal(sig Signal) error
			(*Process) wait() (ps *ProcessState, err error)
		As Outputs Of (at least 5, in which 2 are exported)
			func FindProcess(pid int) (*Process, error)
			func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func findProcess(pid int) (p *Process, err error)
			func newProcess(pid int, handle uintptr) *Process
			func startProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error)

	 type ProcessState (struct)
		ProcessState stores information about a process, as reported by Wait.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			pid int
				// The process's id.

			rusage *syscall.Rusage
			status syscall.WaitStatus
				// System-dependent status info.

		Methods (total 15, in which 9 are exported)
			(*ProcessState) ExitCode() int
				ExitCode returns the exit code of the exited process, or -1
				if the process hasn't exited or was terminated by a signal.

			(*ProcessState) Exited() bool
				Exited reports whether the program has exited.
				On Unix systems this reports true if the program exited due to calling exit,
				but false if the program terminated due to a signal.

			(*ProcessState) Pid() int
				Pid returns the process id of the exited process.

			(*ProcessState) String() string
			(*ProcessState) Success() bool
				Success reports whether the program exited successfully,
				such as with exit status 0 on Unix.

			(*ProcessState) Sys() any
				Sys returns system-dependent exit information about
				the process. Convert it to the appropriate underlying
				type, such as syscall.WaitStatus on Unix, to access its contents.

			(*ProcessState) SysUsage() any
				SysUsage returns system-dependent resource usage information about
				the exited process. Convert it to the appropriate underlying
				type, such as *syscall.Rusage on Unix, to access its contents.
				(On Unix, *syscall.Rusage matches struct rusage as defined in the
				getrusage(2) manual page.)

			(*ProcessState) SystemTime() time.Duration
				SystemTime returns the system CPU time of the exited process and its children.

			(*ProcessState) UserTime() time.Duration
				UserTime returns the user CPU time of the exited process and its children.

			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*ProcessState) exited() bool
			(*ProcessState) success() bool
			(*ProcessState) sys() any
			(*ProcessState) sysUsage() any
			(*ProcessState) systemTime() time.Duration
			(*ProcessState) userTime() time.Duration
		Implements (at least 3, in which 1 is exported)
			*ProcessState : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*ProcessState : context.stringer
			*ProcessState : runtime.stringer
		As Outputs Of (at least 2, in which 1 is exported)
			func (*Process).Wait() (*ProcessState, error)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Process).wait() (ps *ProcessState, err error)

	 type Signal (interface)
		A Signal represents an operating system signal.
		The usual underlying implementation is operating system-dependent:
		on Unix it is syscall.Signal.

		Methods (total 2, both are exported)
			( Signal) Signal()
				// to distinguish from other Stringers

			( Signal) String() string
		Implemented By (at least one exported)
			 syscall.Signal
		Implements (at least 3, in which 1 is exported)
			 Signal : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 Signal : context.stringer
			 Signal : runtime.stringer
		As Inputs Of (at least 2, in which 1 is exported)
			func (*Process).Signal(sig Signal) error
			/* at least one unexported ... *//* at least one unexported: */
			func (*Process).signal(sig Signal) error
		As Types Of (total 2, both are exported)
			  var Interrupt
			  var Kill

	 type SyscallError (struct)
		SyscallError records an error from a specific system call.

		Fields (total 2, both are exported)
			Err error
			Syscall string
		Methods (total 3, all are exported)
			(*SyscallError) Error() string
			(*SyscallError) Timeout() bool
				Timeout reports whether this error represents a timeout.

			(*SyscallError) Unwrap() error
		Implements (at least 4, in which 2 are exported)
			*SyscallError : error
			*SyscallError : github.com/go-faster/errors.Wrapper
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*SyscallError : timeout
			*SyscallError : net.timeout

	/* 11 unexporteds ... *//* 11 unexporteds: */
	 type dirFS string (basic type)

		Methods (total 5, in which 4 are exported)
			( dirFS) Open(name string) (fs.File, error)
			( dirFS) ReadDir(name string) ([]DirEntry, error)
				ReadDir reads the named directory, returning all its directory entries sorted
				by filename. Through this method, dirFS implements [io/fs.ReadDirFS].

			( dirFS) ReadFile(name string) ([]byte, error)
				The ReadFile method calls the [ReadFile] function for the file
				with the given name in the directory. The function provides
				robust handling for small files and special file systems.
				Through this method, dirFS implements [io/fs.ReadFileFS].

			( dirFS) Stat(name string) (fs.FileInfo, error)
			/* one unexported ... *//* one unexported: */
			( dirFS) join(name string) (string, error)
				join returns the path for name in dir.

		Implements (at least 4, all are exported)
			 dirFS : io/fs.FS
			 dirFS : io/fs.ReadDirFS
			 dirFS : io/fs.ReadFileFS
			 dirFS : io/fs.StatFS

	 type dirInfo (struct)
		Auxiliary information if the File describes a directory

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			buf *[]byte
				// buffer for directory I/O

			bufp int
				// location of next record in buf.

			nbuf int
				// length of buf; return value from Getdirentries

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*dirInfo) close()

	 type file (struct)
		file is the real representation of *File.
		The extra level of indirection ensures that no clients of os
		can overwrite this data, which could cause the finalizer
		to close the wrong file descriptor.

		Fields (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			appendMode bool
				// whether file is opened for appending

			dirinfo *dirInfo
				// nil unless directory being read

			name string
			nonblock bool
				// whether we set nonblocking mode

			pfd poll.FD
			stdoutOrErr bool
				// whether this is stdout or stderr

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*file) close() error

	 type fileStat (struct)
		A fileStat is the implementation of FileInfo returned by Stat and Lstat.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			modTime time.Time
			mode FileMode
			name string
			size int64
			sys syscall.Stat_t
		Methods (total 6, all are exported)
			(*fileStat) IsDir() bool
			(*fileStat) ModTime() time.Time
			(*fileStat) Mode() FileMode
			(*fileStat) Name() string
			(*fileStat) Size() int64
			(*fileStat) Sys() any
		Implements (at least one exported)
			*fileStat : io/fs.FileInfo
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func fillFileStatFromSys(fs *fileStat, name string)
			func sameFile(fs1, fs2 *fileStat) bool

	 type fileWithoutReadFrom (struct)
		fileWithoutReadFrom implements all the methods of *File other
		than ReadFrom. This is used to permit ReadFrom to call io.Copy
		without leading to a recursive call to ReadFrom.

		Fields (total 8, in which 1 is exported)
			File *File
			/* 7 unexporteds ... *//* 7 unexporteds: */
			File.file *file
				// os specific

			File.file.appendMode bool
				// whether file is opened for appending

			File.file.dirinfo *dirInfo
				// nil unless directory being read

			File.file.name string
			File.file.nonblock bool
				// whether we set nonblocking mode

			File.file.pfd poll.FD
			File.file.stdoutOrErr bool
				// whether this is stdout or stderr

		Methods (total 39, in which 23 are exported)
			( fileWithoutReadFrom) Chdir() error
				Chdir changes the current working directory to the file,
				which must be a directory.
				If there is an error, it will be of type *PathError.

			( fileWithoutReadFrom) Chmod(mode FileMode) error
				Chmod changes the mode of the file to mode.
				If there is an error, it will be of type *PathError.

			( fileWithoutReadFrom) Chown(uid, gid int) error
				Chown changes the numeric uid and gid of the named file.
				If there is an error, it will be of type *PathError.
				
				On Windows, it always returns the syscall.EWINDOWS error, wrapped
				in *PathError.

			( fileWithoutReadFrom) Close() error
				Close closes the File, rendering it unusable for I/O.
				On files that support SetDeadline, any pending I/O operations will
				be canceled and return immediately with an ErrClosed error.
				Close will return an error if it has already been called.

			( fileWithoutReadFrom) Fd() uintptr
				Fd returns the integer Unix file descriptor referencing the open file.
				If f is closed, the file descriptor becomes invalid.
				If f is garbage collected, a finalizer may close the file descriptor,
				making it invalid; see runtime.SetFinalizer for more information on when
				a finalizer might be run. On Unix systems this will cause the SetDeadline
				methods to stop working.
				Because file descriptors can be reused, the returned file descriptor may
				only be closed through the Close method of f, or by its finalizer during
				garbage collection. Otherwise, during garbage collection the finalizer
				may close an unrelated file descriptor with the same (reused) number.
				
				As an alternative, see the f.SyscallConn method.

			( fileWithoutReadFrom) Name() string
				Name returns the name of the file as presented to Open.

			( fileWithoutReadFrom) Read(b []byte) (n int, err error)
				Read reads up to len(b) bytes from the File and stores them in b.
				It returns the number of bytes read and any error encountered.
				At end of file, Read returns 0, io.EOF.

			( fileWithoutReadFrom) ReadAt(b []byte, off int64) (n int, err error)
				ReadAt reads len(b) bytes from the File starting at byte offset off.
				It returns the number of bytes read and the error, if any.
				ReadAt always returns a non-nil error when n < len(b).
				At end of file, that error is io.EOF.

			( fileWithoutReadFrom) ReadDir(n int) ([]DirEntry, error)
				ReadDir reads the contents of the directory associated with the file f
				and returns a slice of DirEntry values in directory order.
				Subsequent calls on the same file will yield later DirEntry records in the directory.
				
				If n > 0, ReadDir returns at most n DirEntry records.
				In this case, if ReadDir returns an empty slice, it will return an error explaining why.
				At the end of a directory, the error is io.EOF.
				
				If n <= 0, ReadDir returns all the DirEntry records remaining in the directory.
				When it succeeds, it returns a nil error (not io.EOF).

			( fileWithoutReadFrom) ReadFrom(fileWithoutReadFrom)
				This ReadFrom method hides the *File ReadFrom method.

			( fileWithoutReadFrom) Readdir(n int) ([]FileInfo, error)
				Readdir reads the contents of the directory associated with file and
				returns a slice of up to n FileInfo values, as would be returned
				by Lstat, in directory order. Subsequent calls on the same file will yield
				further FileInfos.
				
				If n > 0, Readdir returns at most n FileInfo structures. In this case, if
				Readdir returns an empty slice, it will return a non-nil error
				explaining why. At the end of a directory, the error is io.EOF.
				
				If n <= 0, Readdir returns all the FileInfo from the directory in
				a single slice. In this case, if Readdir succeeds (reads all
				the way to the end of the directory), it returns the slice and a
				nil error. If it encounters an error before the end of the
				directory, Readdir returns the FileInfo read until that point
				and a non-nil error.
				
				Most clients are better served by the more efficient ReadDir method.

			( fileWithoutReadFrom) Readdirnames(n int) (names []string, err error)
				Readdirnames reads the contents of the directory associated with file
				and returns a slice of up to n names of files in the directory,
				in directory order. Subsequent calls on the same file will yield
				further names.
				
				If n > 0, Readdirnames returns at most n names. In this case, if
				Readdirnames returns an empty slice, it will return a non-nil error
				explaining why. At the end of a directory, the error is io.EOF.
				
				If n <= 0, Readdirnames returns all the names from the directory in
				a single slice. In this case, if Readdirnames succeeds (reads all
				the way to the end of the directory), it returns the slice and a
				nil error. If it encounters an error before the end of the
				directory, Readdirnames returns the names read until that point and
				a non-nil error.

			( fileWithoutReadFrom) Seek(offset int64, whence int) (ret int64, err error)
				Seek sets the offset for the next Read or Write on file to offset, interpreted
				according to whence: 0 means relative to the origin of the file, 1 means
				relative to the current offset, and 2 means relative to the end.
				It returns the new offset and an error, if any.
				The behavior of Seek on a file opened with O_APPEND is not specified.

			( fileWithoutReadFrom) SetDeadline(t time.Time) error
				SetDeadline sets the read and write deadlines for a File.
				It is equivalent to calling both SetReadDeadline and SetWriteDeadline.
				
				Only some kinds of files support setting a deadline. Calls to SetDeadline
				for files that do not support deadlines will return ErrNoDeadline.
				On most systems ordinary files do not support deadlines, but pipes do.
				
				A deadline is an absolute time after which I/O operations fail with an
				error instead of blocking. The deadline applies to all future and pending
				I/O, not just the immediately following call to Read or Write.
				After a deadline has been exceeded, the connection can be refreshed
				by setting a deadline in the future.
				
				If the deadline is exceeded a call to Read or Write or to other I/O
				methods will return an error that wraps ErrDeadlineExceeded.
				This can be tested using errors.Is(err, os.ErrDeadlineExceeded).
				That error implements the Timeout method, and calling the Timeout
				method will return true, but there are other possible errors for which
				the Timeout will return true even if the deadline has not been exceeded.
				
				An idle timeout can be implemented by repeatedly extending
				the deadline after successful Read or Write calls.
				
				A zero value for t means I/O operations will not time out.

			( fileWithoutReadFrom) SetReadDeadline(t time.Time) error
				SetReadDeadline sets the deadline for future Read calls and any
				currently-blocked Read call.
				A zero value for t means Read will not time out.
				Not all files support setting deadlines; see SetDeadline.

			( fileWithoutReadFrom) SetWriteDeadline(t time.Time) error
				SetWriteDeadline sets the deadline for any future Write calls and any
				currently-blocked Write call.
				Even if Write times out, it may return n > 0, indicating that
				some of the data was successfully written.
				A zero value for t means Write will not time out.
				Not all files support setting deadlines; see SetDeadline.

			( fileWithoutReadFrom) Stat() (FileInfo, error)
				Stat returns the FileInfo structure describing file.
				If there is an error, it will be of type *PathError.

			( fileWithoutReadFrom) Sync() error
				Sync commits the current contents of the file to stable storage.
				Typically, this means flushing the file system's in-memory copy
				of recently written data to disk.

			( fileWithoutReadFrom) SyscallConn() (syscall.RawConn, error)
				SyscallConn returns a raw file.
				This implements the syscall.Conn interface.

			( fileWithoutReadFrom) Truncate(size int64) error
				Truncate changes the size of the file.
				It does not change the I/O offset.
				If there is an error, it will be of type *PathError.

			( fileWithoutReadFrom) Write(b []byte) (n int, err error)
				Write writes len(b) bytes from b to the File.
				It returns the number of bytes written and an error, if any.
				Write returns a non-nil error when n != len(b).

			( fileWithoutReadFrom) WriteAt(b []byte, off int64) (n int, err error)
				WriteAt writes len(b) bytes to the File starting at byte offset off.
				It returns the number of bytes written and an error, if any.
				WriteAt returns a non-nil error when n != len(b).
				
				If file was opened with the O_APPEND flag, WriteAt returns an error.

			( fileWithoutReadFrom) WriteString(s string) (n int, err error)
				WriteString is like Write, but writes the contents of string s rather than
				a slice of bytes.

			/* 16 unexporteds ... *//* 16 unexporteds: */
			( fileWithoutReadFrom) checkValid(op string) error
				checkValid checks whether f is valid for use.
				If not, it returns an appropriate error, perhaps incorporating the operation name op.

			( fileWithoutReadFrom) chmod(mode FileMode) error
				See docs in file.go:(*File).Chmod.

			( fileWithoutReadFrom) close() error
			( fileWithoutReadFrom) copyFileRange(r io.Reader) (written int64, handled bool, err error)
			( fileWithoutReadFrom) pread(b []byte, off int64) (n int, err error)
				pread reads len(b) bytes from the File starting at byte offset off.
				It returns the number of bytes read and the error, if any.
				EOF is signaled by a zero count with err set to nil.

			( fileWithoutReadFrom) pwrite(b []byte, off int64) (n int, err error)
				pwrite writes len(b) bytes to the File starting at byte offset off.
				It returns the number of bytes written and an error, if any.

			( fileWithoutReadFrom) read(b []byte) (n int, err error)
				read reads up to len(b) bytes from the File.
				It returns the number of bytes read and an error, if any.

			( fileWithoutReadFrom) readFrom(r io.Reader) (written int64, handled bool, err error)
			( fileWithoutReadFrom) readdir(n int, mode readdirMode) (names []string, dirents []DirEntry, infos []FileInfo, err error)
			( fileWithoutReadFrom) seek(offset int64, whence int) (ret int64, err error)
				seek sets the offset for the next Read or Write on file to offset, interpreted
				according to whence: 0 means relative to the origin of the file, 1 means
				relative to the current offset, and 2 means relative to the end.
				It returns the new offset and an error, if any.

			( fileWithoutReadFrom) setDeadline(t time.Time) error
				setDeadline sets the read and write deadline.

			( fileWithoutReadFrom) setReadDeadline(t time.Time) error
				setReadDeadline sets the read deadline.

			( fileWithoutReadFrom) setWriteDeadline(t time.Time) error
				setWriteDeadline sets the write deadline.

			( fileWithoutReadFrom) spliceToFile(r io.Reader) (written int64, handled bool, err error)
			( fileWithoutReadFrom) wrapErr(op string, err error) error
				wrapErr wraps an error that occurred during an operation on an open file.
				It passes io.EOF through unchanged, otherwise converts
				poll.ErrFileClosing to ErrClosed and wraps the error in a PathError.

			( fileWithoutReadFrom) write(b []byte) (n int, err error)
				write writes len(b) bytes to the File.
				It returns the number of bytes written and an error, if any.

		Implements (at least 25, in which 23 are exported)
			 fileWithoutReadFrom : go.uber.org/zap.Sink
			 fileWithoutReadFrom : go.uber.org/zap/zapcore.WriteSyncer
			 fileWithoutReadFrom : internal/bisect.Writer
			 fileWithoutReadFrom : io.Closer
			 fileWithoutReadFrom : io.ReadCloser
			 fileWithoutReadFrom : io.Reader
			 fileWithoutReadFrom : io.ReaderAt
			 fileWithoutReadFrom : io.ReadSeekCloser
			 fileWithoutReadFrom : io.ReadSeeker
			 fileWithoutReadFrom : io.ReadWriteCloser
			 fileWithoutReadFrom : io.ReadWriter
			 fileWithoutReadFrom : io.ReadWriteSeeker
			 fileWithoutReadFrom : io.Seeker
			 fileWithoutReadFrom : io.StringWriter
			 fileWithoutReadFrom : io.WriteCloser
			 fileWithoutReadFrom : io.Writer
			 fileWithoutReadFrom : io.WriterAt
			 fileWithoutReadFrom : io.WriteSeeker
			 fileWithoutReadFrom : io/fs.File
			 fileWithoutReadFrom : io/fs.ReadDirFile
			 fileWithoutReadFrom : mime/multipart.File
			 fileWithoutReadFrom : net/http.File
			 fileWithoutReadFrom : syscall.Conn
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 fileWithoutReadFrom : crypto/tls.transcriptHash
			 fileWithoutReadFrom : net/http.http2stringWriter

	 type newFileKind int (basic type)
		newFileKind describes the kind of file to newFile.

		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newFile(fd int, name string, kind newFileKind) *File
		As Types Of (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			const kindNewFile
			const kindNonBlock
			const kindNoPoll
			const kindOpenFile
			const kindPipe

	 type rawConn (struct)
		rawConn implements syscall.RawConn.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			file *File
		Methods (total 3, all are exported)
			(*rawConn) Control(f func(uintptr)) error
			(*rawConn) Read(f func(uintptr) bool) error
			(*rawConn) Write(f func(uintptr) bool) error
		Implements (at least one exported)
			*rawConn : syscall.RawConn
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newRawConn(file *File) (*rawConn, error)

	 type readdirMode int (basic type)

		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*File).readdir(n int, mode readdirMode) (names []string, dirents []DirEntry, infos []FileInfo, err error)
		As Types Of (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			const readdirDirEntry
			const readdirFileInfo
			const readdirName

	 type syscallErrorType = syscall.Errno (basic type)
	 type timeout (interface)

		Methods (only one, which is exported)
			( timeout) Timeout() bool
		Implemented By (at least 23, in which 13 are exported)
			*SyscallError
			*internal/poll.DeadlineExceededError
			*io/fs.PathError
			*net.AddrError
			*net.DNSConfigError
			*net.DNSError
			 net.Error (interface)
			 net.InvalidAddrError
			*net.OpError
			*net.ParseError
			 net.UnknownNetworkError
			*net/url.Error
			 syscall.Errno
			/* 10+ unexporteds ... *//* 10+ unexporteds: */
			 context.deadlineExceededError
			*crypto/tls.permanentError
			 crypto/tls.timeoutError
			 internal/poll.errNetClosing
			 net.addrinfoErrno
			 net.timeout (interface)
			*net.timeoutError
			*net/http.http2httpError
			*net/http.httpError
			 net/http.tlsHandshakeTimeoutError
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 timeout : net.timeout

	 type unixDirent (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			info FileInfo
			name string
			parent string
			typ FileMode
		Methods (total 5, all are exported)
			(*unixDirent) Info() (FileInfo, error)
			(*unixDirent) IsDir() bool
			(*unixDirent) Name() string
			(*unixDirent) String() string
			(*unixDirent) Type() FileMode
		Implements (at least 4, in which 2 are exported)
			*unixDirent : fmt.Stringer
			*unixDirent : io/fs.DirEntry
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*unixDirent : context.stringer
			*unixDirent : runtime.stringer


Package-Level Functions (total 123, in which 60 are exported)

	 func Chdir(dir string) error
		Chdir changes the current working directory to the named directory.
		If there is an error, it will be of type *PathError.

	 func Chmod(name string, mode FileMode) error
		Chmod changes the mode of the named file to mode.
		If the file is a symbolic link, it changes the mode of the link's target.
		If there is an error, it will be of type *PathError.
		
		A different subset of the mode bits are used, depending on the
		operating system.
		
		On Unix, the mode's permission bits, ModeSetuid, ModeSetgid, and
		ModeSticky are used.
		
		On Windows, only the 0200 bit (owner writable) of mode is used; it
		controls whether the file's read-only attribute is set or cleared.
		The other bits are currently unused. For compatibility with Go 1.12
		and earlier, use a non-zero mode. Use mode 0400 for a read-only
		file and 0600 for a readable+writable file.
		
		On Plan 9, the mode's permission bits, ModeAppend, ModeExclusive,
		and ModeTemporary are used.

	 func Chown(name string, uid, gid int) error
		Chown changes the numeric uid and gid of the named file.
		If the file is a symbolic link, it changes the uid and gid of the link's target.
		A uid or gid of -1 means to not change that value.
		If there is an error, it will be of type *PathError.
		
		On Windows or Plan 9, Chown always returns the syscall.EWINDOWS or
		EPLAN9 error, wrapped in *PathError.

	 func Chtimes(name string, atime time.Time, mtime time.Time) error
		Chtimes changes the access and modification times of the named
		file, similar to the Unix utime() or utimes() functions.
		A zero time.Time value will leave the corresponding file time unchanged.
		
		The underlying filesystem may truncate or round the values to a
		less precise time unit.
		If there is an error, it will be of type *PathError.

	 func Clearenv()
		Clearenv deletes all environment variables.

	 func Create(name string) (*File, error)
		Create creates or truncates the named file. If the file already exists,
		it is truncated. If the file does not exist, it is created with mode 0666
		(before umask). If successful, methods on the returned File can
		be used for I/O; the associated file descriptor has mode O_RDWR.
		If there is an error, it will be of type *PathError.

	 func CreateTemp(dir, pattern string) (*File, error)
		CreateTemp creates a new temporary file in the directory dir,
		opens the file for reading and writing, and returns the resulting file.
		The filename is generated by taking pattern and adding a random string to the end.
		If pattern includes a "*", the random string replaces the last "*".
		If dir is the empty string, CreateTemp uses the default directory for temporary files, as returned by TempDir.
		Multiple programs or goroutines calling CreateTemp simultaneously will not choose the same file.
		The caller can use the file's Name method to find the pathname of the file.
		It is the caller's responsibility to remove the file when it is no longer needed.

	 func DirFS(dir string) fs.FS
		DirFS returns a file system (an fs.FS) for the tree of files rooted at the directory dir.
		
		Note that DirFS("/prefix") only guarantees that the Open calls it makes to the
		operating system will begin with "/prefix": DirFS("/prefix").Open("file") is the
		same as os.Open("/prefix/file"). So if /prefix/file is a symbolic link pointing outside
		the /prefix tree, then using DirFS does not stop the access any more than using
		os.Open does. Additionally, the root of the fs.FS returned for a relative path,
		DirFS("prefix"), will be affected by later calls to Chdir. DirFS is therefore not
		a general substitute for a chroot-style security mechanism when the directory tree
		contains arbitrary content.
		
		The directory dir must not be "".
		
		The result implements [io/fs.StatFS], [io/fs.ReadFileFS] and
		[io/fs.ReadDirFS].

	 func Environ() []string
		Environ returns a copy of strings representing the environment,
		in the form "key=value".

	 func Executable() (string, error)
		Executable returns the path name for the executable that started
		the current process. There is no guarantee that the path is still
		pointing to the correct executable. If a symlink was used to start
		the process, depending on the operating system, the result might
		be the symlink or the path it pointed to. If a stable result is
		needed, path/filepath.EvalSymlinks might help.
		
		Executable returns an absolute path unless an error occurred.
		
		The main use case is finding resources located relative to an
		executable.

	 func Exit(code int)
		Exit causes the current program to exit with the given status code.
		Conventionally, code zero indicates success, non-zero an error.
		The program terminates immediately; deferred functions are not run.
		
		For portability, the status code should be in the range [0, 125].

	 func Expand(s string, mapping func(string) string) string
		Expand replaces ${var} or $var in the string based on the mapping function.
		For example, os.ExpandEnv(s) is equivalent to os.Expand(s, os.Getenv).

	 func ExpandEnv(s string) string
		ExpandEnv replaces ${var} or $var in the string according to the values
		of the current environment variables. References to undefined
		variables are replaced by the empty string.

	 func FindProcess(pid int) (*Process, error)
		FindProcess looks for a running process by its pid.
		
		The Process it returns can be used to obtain information
		about the underlying operating system process.
		
		On Unix systems, FindProcess always succeeds and returns a Process
		for the given pid, regardless of whether the process exists. To test whether
		the process actually exists, see whether p.Signal(syscall.Signal(0)) reports
		an error.

	 func Getegid() int
		Getegid returns the numeric effective group id of the caller.
		
		On Windows, it returns -1.

	 func Getenv(key string) string
		Getenv retrieves the value of the environment variable named by the key.
		It returns the value, which will be empty if the variable is not present.
		To distinguish between an empty value and an unset value, use LookupEnv.

	 func Geteuid() int
		Geteuid returns the numeric effective user id of the caller.
		
		On Windows, it returns -1.

	 func Getgid() int
		Getgid returns the numeric group id of the caller.
		
		On Windows, it returns -1.

	 func Getgroups() ([]int, error)
		Getgroups returns a list of the numeric ids of groups that the caller belongs to.
		
		On Windows, it returns syscall.EWINDOWS. See the os/user package
		for a possible alternative.

	 func Getpagesize() int
		Getpagesize returns the underlying system's memory page size.

	 func Getpid() int
		Getpid returns the process id of the caller.

	 func Getppid() int
		Getppid returns the process id of the caller's parent.

	 func Getuid() int
		Getuid returns the numeric user id of the caller.
		
		On Windows, it returns -1.

	 func Getwd() (dir string, err error)
		Getwd returns a rooted path name corresponding to the
		current directory. If the current directory can be
		reached via multiple paths (due to symbolic links),
		Getwd may return any one of them.

	 func Hostname() (name string, err error)
		Hostname returns the host name reported by the kernel.

	 func IsExist(err error) bool
		IsExist returns a boolean indicating whether the error is known to report
		that a file or directory already exists. It is satisfied by ErrExist as
		well as some syscall errors.
		
		This function predates errors.Is. It only supports errors returned by
		the os package. New code should use errors.Is(err, fs.ErrExist).

	 func IsNotExist(err error) bool
		IsNotExist returns a boolean indicating whether the error is known to
		report that a file or directory does not exist. It is satisfied by
		ErrNotExist as well as some syscall errors.
		
		This function predates errors.Is. It only supports errors returned by
		the os package. New code should use errors.Is(err, fs.ErrNotExist).

	 func IsPathSeparator(c uint8) bool
		IsPathSeparator reports whether c is a directory separator character.

	 func IsPermission(err error) bool
		IsPermission returns a boolean indicating whether the error is known to
		report that permission is denied. It is satisfied by ErrPermission as well
		as some syscall errors.
		
		This function predates errors.Is. It only supports errors returned by
		the os package. New code should use errors.Is(err, fs.ErrPermission).

	 func IsTimeout(err error) bool
		IsTimeout returns a boolean indicating whether the error is known
		to report that a timeout occurred.
		
		This function predates errors.Is, and the notion of whether an
		error indicates a timeout can be ambiguous. For example, the Unix
		error EWOULDBLOCK sometimes indicates a timeout and sometimes does not.
		New code should use errors.Is with a value appropriate to the call
		returning the error, such as os.ErrDeadlineExceeded.

	 func Lchown(name string, uid, gid int) error
		Lchown changes the numeric uid and gid of the named file.
		If the file is a symbolic link, it changes the uid and gid of the link itself.
		If there is an error, it will be of type *PathError.
		
		On Windows, it always returns the syscall.EWINDOWS error, wrapped
		in *PathError.

	 func Link(oldname, newname string) error
		Link creates newname as a hard link to the oldname file.
		If there is an error, it will be of type *LinkError.

	 func LookupEnv(key string) (string, bool)
		LookupEnv retrieves the value of the environment variable named
		by the key. If the variable is present in the environment the
		value (which may be empty) is returned and the boolean is true.
		Otherwise the returned value will be empty and the boolean will
		be false.

	 func Lstat(name string) (FileInfo, error)
		Lstat returns a FileInfo describing the named file.
		If the file is a symbolic link, the returned FileInfo
		describes the symbolic link. Lstat makes no attempt to follow the link.
		If there is an error, it will be of type *PathError.

	 func Mkdir(name string, perm FileMode) error
		Mkdir creates a new directory with the specified name and permission
		bits (before umask).
		If there is an error, it will be of type *PathError.

	 func MkdirAll(path string, perm FileMode) error
		MkdirAll creates a directory named path,
		along with any necessary parents, and returns nil,
		or else returns an error.
		The permission bits perm (before umask) are used for all
		directories that MkdirAll creates.
		If path is already a directory, MkdirAll does nothing
		and returns nil.

	 func MkdirTemp(dir, pattern string) (string, error)
		MkdirTemp creates a new temporary directory in the directory dir
		and returns the pathname of the new directory.
		The new directory's name is generated by adding a random string to the end of pattern.
		If pattern includes a "*", the random string replaces the last "*" instead.
		If dir is the empty string, MkdirTemp uses the default directory for temporary files, as returned by TempDir.
		Multiple programs or goroutines calling MkdirTemp simultaneously will not choose the same directory.
		It is the caller's responsibility to remove the directory when it is no longer needed.

	 func NewFile(fd uintptr, name string) *File
		NewFile returns a new File with the given file descriptor and
		name. The returned value will be nil if fd is not a valid file
		descriptor. On Unix systems, if the file descriptor is in
		non-blocking mode, NewFile will attempt to return a pollable File
		(one for which the SetDeadline methods work).
		
		After passing it to NewFile, fd may become invalid under the same
		conditions described in the comments of the Fd method, and the same
		constraints apply.

	 func NewSyscallError(syscall string, err error) error
		NewSyscallError returns, as an error, a new SyscallError
		with the given system call name and error details.
		As a convenience, if err is nil, NewSyscallError returns nil.

	 func Open(name string) (*File, error)
		Open opens the named file for reading. If successful, methods on
		the returned file can be used for reading; the associated file
		descriptor has mode O_RDONLY.
		If there is an error, it will be of type *PathError.

	 func OpenFile(name string, flag int, perm FileMode) (*File, error)
		OpenFile is the generalized open call; most users will use Open
		or Create instead. It opens the named file with specified flag
		(O_RDONLY etc.). If the file does not exist, and the O_CREATE flag
		is passed, it is created with mode perm (before umask). If successful,
		methods on the returned File can be used for I/O.
		If there is an error, it will be of type *PathError.

	 func Pipe() (r *File, w *File, err error)
		Pipe returns a connected pair of Files; reads from r return bytes written to w.
		It returns the files and an error, if any.

	 func ReadDir(name string) ([]DirEntry, error)
		ReadDir reads the named directory,
		returning all its directory entries sorted by filename.
		If an error occurs reading the directory,
		ReadDir returns the entries it was able to read before the error,
		along with the error.

	 func ReadFile(name string) ([]byte, error)
		ReadFile reads the named file and returns the contents.
		A successful call returns err == nil, not err == EOF.
		Because ReadFile reads the whole file, it does not treat an EOF from Read
		as an error to be reported.

	 func Readlink(name string) (string, error)
		Readlink returns the destination of the named symbolic link.
		If there is an error, it will be of type *PathError.

	 func Remove(name string) error
		Remove removes the named file or (empty) directory.
		If there is an error, it will be of type *PathError.

	 func RemoveAll(path string) error
		RemoveAll removes path and any children it contains.
		It removes everything it can but returns the first error
		it encounters. If the path does not exist, RemoveAll
		returns nil (no error).
		If there is an error, it will be of type *PathError.

	 func Rename(oldpath, newpath string) error
		Rename renames (moves) oldpath to newpath.
		If newpath already exists and is not a directory, Rename replaces it.
		OS-specific restrictions may apply when oldpath and newpath are in different directories.
		Even within the same directory, on non-Unix platforms Rename is not an atomic operation.
		If there is an error, it will be of type *LinkError.

	 func SameFile(fi1, fi2 FileInfo) bool
		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 Setenv(key, value string) error
		Setenv sets the value of the environment variable named by the key.
		It returns an error, if any.

	 func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)
		StartProcess starts a new process with the program, arguments and attributes
		specified by name, argv and attr. The argv slice will become os.Args in the
		new process, so it normally starts with the program name.
		
		If the calling goroutine has locked the operating system thread
		with runtime.LockOSThread and modified any inheritable OS-level
		thread state (for example, Linux or Plan 9 name spaces), the new
		process will inherit the caller's thread state.
		
		StartProcess is a low-level interface. The os/exec package provides
		higher-level interfaces.
		
		If there is an error, it will be of type *PathError.

	 func Stat(name string) (FileInfo, error)
		Stat returns a FileInfo describing the named file.
		If there is an error, it will be of type *PathError.

	 func Symlink(oldname, newname string) error
		Symlink creates newname as a symbolic link to oldname.
		On Windows, a symlink to a non-existent oldname creates a file symlink;
		if oldname is later created as a directory the symlink will not work.
		If there is an error, it will be of type *LinkError.

	 func TempDir() string
		TempDir returns the default directory to use for temporary files.
		
		On Unix systems, it returns $TMPDIR if non-empty, else /tmp.
		On Windows, it uses GetTempPath, returning the first non-empty
		value from %TMP%, %TEMP%, %USERPROFILE%, or the Windows directory.
		On Plan 9, it returns /tmp.
		
		The directory is neither guaranteed to exist nor have accessible
		permissions.

	 func Truncate(name string, size int64) error
		Truncate changes the size of the named file.
		If the file is a symbolic link, it changes the size of the link's target.
		If there is an error, it will be of type *PathError.

	 func Unsetenv(key string) error
		Unsetenv unsets a single environment variable.

	 func UserCacheDir() (string, error)
		UserCacheDir returns the default root directory to use for user-specific
		cached data. Users should create their own application-specific subdirectory
		within this one and use that.
		
		On Unix systems, it returns $XDG_CACHE_HOME as specified by
		https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html if
		non-empty, else $HOME/.cache.
		On Darwin, it returns $HOME/Library/Caches.
		On Windows, it returns %LocalAppData%.
		On Plan 9, it returns $home/lib/cache.
		
		If the location cannot be determined (for example, $HOME is not defined),
		then it will return an error.

	 func UserConfigDir() (string, error)
		UserConfigDir returns the default root directory to use for user-specific
		configuration data. Users should create their own application-specific
		subdirectory within this one and use that.
		
		On Unix systems, it returns $XDG_CONFIG_HOME as specified by
		https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html if
		non-empty, else $HOME/.config.
		On Darwin, it returns $HOME/Library/Application Support.
		On Windows, it returns %AppData%.
		On Plan 9, it returns $home/lib.
		
		If the location cannot be determined (for example, $HOME is not defined),
		then it will return an error.

	 func UserHomeDir() (string, error)
		UserHomeDir returns the current user's home directory.
		
		On Unix, including macOS, it returns the $HOME environment variable.
		On Windows, it returns %USERPROFILE%.
		On Plan 9, it returns the $home environment variable.
		
		If the expected variable is not set in the environment, UserHomeDir
		returns either a platform-specific default value or a non-nil error.

	 func WriteFile(name string, data []byte, perm FileMode) error
		WriteFile writes data to the named file, creating it if necessary.
		If the file does not exist, WriteFile creates it with permissions perm (before umask);
		otherwise WriteFile truncates it before writing, without changing permissions.
		Since WriteFile requires multiple system calls to complete, a failure mid-operation
		can leave the file in a partially written state.

	/* 63 unexporteds ... *//* 63 unexporteds: */
	 func atime(fi FileInfo) time.Time
		For testing.

	 func basename(name string) string
		basename removes trailing slashes and the leading directory name from path name.

	 func chmod(name string, mode FileMode) error
		See docs in file.go:Chmod.

	 func containsAny(s, chars string) bool
		containsAny reports whether any bytes in chars are within s.

	 func direntIno(buf []byte) (uint64, bool)
	 func direntNamlen(buf []byte) (uint64, bool)
	 func direntReclen(buf []byte) (uint64, bool)
	 func direntType(buf []byte) FileMode
	 func endsWithDot(path string) bool
		endsWithDot reports whether the final component of path is ".".

	 func epipecheck(file *File, e error)
		epipecheck raises SIGPIPE if we get an EPIPE error on standard
		output or standard error. See the SIGPIPE docs in os/signal, and
		issue 11845.

	 func errDeadlineExceeded() error
		errDeadlineExceeded returns the value for os.ErrDeadlineExceeded.
		This error comes from the internal/poll package, which is also
		used by package net. Doing it this way ensures that the net
		package will return os.ErrDeadlineExceeded for an exceeded deadline,
		as documented by net.Conn.SetDeadline, without requiring any extra
		work in the net package and without requiring the internal/poll
		package to import os (which it can't, because that would be circular).

	 func errNoDeadline() error
	 func executable() (string, error)
	 func fastrand() uint32
		fastrand provided by runtime.
		We generate random temporary file names so that there's a good
		chance the file doesn't exist yet - keeps the number of tries in
		TempFile to a minimum.

	 func fillFileStatFromSys(fs *fileStat, name string)
	 func findProcess(pid int) (p *Process, err error)
	 func fixCount(n int, err error) (int, error)
		Many functions in package syscall return a count of -1 instead of 0.
		Using fixCount(call()) instead of call() corrects the count.

	 func fixLongPath(path string) string
		fixLongPath is a noop on non-Windows platforms.

	 func fixRootDirectory(p string) string
	 func genericReadFrom(f *File, r io.Reader) (int64, error)
	 func getPollFD(r io.Reader) *poll.FD
		getPollFD tries to get the poll.FD from the given io.Reader by expecting
		the underlying type of r to be the implementation of syscall.Conn that contains
		a *net.rawConn.

	 func getShellName(s string) (string, int)
		getShellName returns the name that begins the string and the number of bytes
		consumed to extract it. If the name is enclosed in {}, it's part of a ${}
		expansion and two more bytes are needed than the length of the name.

	 func hostname() (name string, err error)
	 func ignoringEINTR(fn func() error) error
		ignoringEINTR makes a function call and repeats it if it returns an
		EINTR error. This appears to be required even though we install all
		signal handlers with SA_RESTART: see #22838, #38033, #38836, #40846.
		Also #20400 and #36644 are issues in which a signal handler is
		installed without setting SA_RESTART. None of these are the common case,
		but there are enough of them that it seems that we can't avoid
		an EINTR loop.

	 func init()
	 func isAlphaNum(c uint8) bool
		isAlphaNum reports whether the byte is an ASCII letter, number, or underscore.

	 func isShellSpecialVar(c uint8) bool
		isShellSpecialVar reports whether the character identifies a special
		shell variable such as $*.

	 func itox(val int) string
		itox converts val (an int) to a hexadecimal string.

	 func joinPath(dir, name string) string
	 func lastIndex(s string, sep byte) int
		lastIndex from the strings package.

	 func lstatNolog(name string) (FileInfo, error)
		lstatNolog lstats a file with no test logging.

	 func net_newUnixFile(fd int, name string) *File
		net_newUnixFile is a hidden entry point called by net.conn.File.
		This is used so that a nonblocking network connection will become
		blocking if code calls the Fd method. We don't want that for direct
		calls to NewFile: passing a nonblocking descriptor to NewFile should
		remain nonblocking if you get it back using Fd. But for net.conn.File
		the call to NewFile is hidden from the user. Historically in that case
		the Fd method has returned a blocking descriptor, and we want to
		retain that behavior because existing code expects it and depends on it.

	 func newFile(fd int, name string, kind newFileKind) *File
		newFile is like NewFile, but if called from OpenFile or Pipe
		(as passed in the kind parameter) it tries to add the file to
		the runtime poller.

	 func newProcess(pid int, handle uintptr) *Process
	 func newRawConn(file *File) (*rawConn, error)
	 func newUnixDirent(parent, name string, typ FileMode) (DirEntry, error)
	 func nextRandom() string
	 func open(path string, flag int, perm uint32) (int, poll.SysFile, error)
	 func openFdAt(dirfd int, name string) (*File, error)
		openFdAt opens path relative to the directory in fd.
		Other than that this should act like openFileNolog.
		This acts like openFileNolog rather than OpenFile because
		we are going to (try to) remove the file.
		The contents of this file are not relevant for test caching.

	 func openFileNolog(name string, flag int, perm FileMode) (*File, error)
		openFileNolog is the Unix implementation of OpenFile.
		Changes here should be reflected in openFdAt, if relevant.

	 func prefixAndSuffix(pattern string) (prefix, suffix string, err error)
		prefixAndSuffix splits pattern by the last wildcard "*", if applicable,
		returning prefix as the part before "*" and suffix as the part after "*".

	 func readInt(b []byte, off, size uintptr) (u uint64, ok bool)
		readInt returns the size-bytes unsigned integer in native byte order at offset off.

	 func readIntBE(b []byte, size uintptr) uint64
	 func readIntLE(b []byte, size uintptr) uint64
	 func removeAll(path string) error
	 func removeAllFrom(parent *File, base string) error
	 func rename(oldname, newname string) error
	 func runtime_args() []string
	 func runtime_beforeExit(exitCode int)
	 func sameFile(fs1, fs2 *fileStat) bool
	 func setStickyBit(name string) error
		setStickyBit adds ModeSticky to the permission bits of path, non atomic.

	 func sigpipe()
	 func splitPath(path string) (string, string)
		splitPath returns the base name and parent directory.

	 func startProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error)
	 func statNolog(name string) (FileInfo, error)
		statNolog stats a file with no test logging.

	 func stringsTrimSuffix(s, suffix string) string
		stringsTrimSuffix is the same as strings.TrimSuffix.

	 func syscallMode(i FileMode) (o uint32)
		syscallMode returns the syscall-specific mode bits from Go's portable mode bits.

	 func tempDir() string
	 func tryLimitedReader(r io.Reader) (*io.LimitedReader, io.Reader, int64)
		tryLimitedReader tries to assert the io.Reader to io.LimitedReader, it returns the io.LimitedReader,
		the underlying io.Reader and the remaining amount of bytes if the assertion succeeds,
		otherwise it just returns the original io.Reader and the theoretical unlimited remaining amount of bytes.

	 func uitox(val uint) string
		uitox converts val (a uint) to a hexadecimal string.

	 func underlyingError(err error) error
		underlyingError returns the underlying error for known os error types.

	 func underlyingErrorIs(err, target error) bool
	 func wrapSyscallError(name string, err error) error
		wrapSyscallError takes an error and a syscall name. If the error is
		a syscall.Errno, it wraps it in an os.SyscallError using the syscall name.


Package-Level Variables (total 23, in which 14 are exported)

	  var Args []string
		Args hold the command-line arguments, starting with the program name.

	  var ErrClosed error // "file already closed"
		Portable analogs of some common system call errors.
		
		Errors returned from this package may be tested against these errors
		with errors.Is.

	  var ErrDeadlineExceeded error // "i/o timeout"
		Portable analogs of some common system call errors.
		
		Errors returned from this package may be tested against these errors
		with errors.Is.

	  var ErrExist error // "file already exists"
		Portable analogs of some common system call errors.
		
		Errors returned from this package may be tested against these errors
		with errors.Is.

	  var ErrInvalid error // "invalid argument"
		ErrInvalid indicates an invalid argument.
		Methods on File will return this error when the receiver is nil.

	  var ErrNoDeadline error // "file type does not support deadline"
		Portable analogs of some common system call errors.
		
		Errors returned from this package may be tested against these errors
		with errors.Is.

	  var ErrNotExist error // "file does not exist"
		Portable analogs of some common system call errors.
		
		Errors returned from this package may be tested against these errors
		with errors.Is.

	  var ErrPermission error // "permission denied"
		Portable analogs of some common system call errors.
		
		Errors returned from this package may be tested against these errors
		with errors.Is.

	  var ErrProcessDone error
		ErrProcessDone indicates a Process has finished.

	  var Interrupt Signal
		The only signal values guaranteed to be present in the os package on all
		systems are os.Interrupt (send the process an interrupt) and os.Kill (force
		the process to exit). On Windows, sending os.Interrupt to a process with
		os.Process.Signal is not implemented; it will return an error instead of
		sending a signal.

	  var Kill Signal
		The only signal values guaranteed to be present in the os package on all
		systems are os.Interrupt (send the process an interrupt) and os.Kill (force
		the process to exit). On Windows, sending os.Interrupt to a process with
		os.Process.Signal is not implemented; it will return an error instead of
		sending a signal.

	  var Stderr *File
		Stdin, Stdout, and Stderr are open Files pointing to the standard input,
		standard output, and standard error file descriptors.
		
		Note that the Go runtime writes to standard error for panics and crashes;
		closing Stderr may cause those messages to go elsewhere, perhaps
		to a file opened later.

	  var Stdin *File
		Stdin, Stdout, and Stderr are open Files pointing to the standard input,
		standard output, and standard error file descriptors.
		
		Note that the Go runtime writes to standard error for panics and crashes;
		closing Stderr may cause those messages to go elsewhere, perhaps
		to a file opened later.

	  var Stdout *File
		Stdin, Stdout, and Stderr are open Files pointing to the standard input,
		standard output, and standard error file descriptors.
		
		Note that the Go runtime writes to standard error for panics and crashes;
		closing Stderr may cause those messages to go elsewhere, perhaps
		to a file opened later.

	/* 9 unexporteds ... *//* 9 unexporteds: */
	  var checkWrapErr bool
		checkWrapErr is the test hook to enable checking unexpected wrapped errors of poll.ErrFileClosing.
		It is set to true in the export_test.go for tests (including fuzz tests).

	  var dirBufPool sync.Pool
	  var errPatternHasSeparator error
	  var errWriteAtInAppendMode error
	  var getwdCache struct{sync.Mutex; dir string}
	  var lstat func(name string) (fs.FileInfo, error)
		lstat is overridden in tests.

	  var pollCopyFileRange func(dst *poll.FD, src *poll.FD, remain int64) (written int64, handled bool, err error)
	  var pollSplice func(dst *poll.FD, src *poll.FD, remain int64) (written int64, handled bool, sc string, err error)
	  var testingForceReadDirLstat bool
		testingForceReadDirLstat forces ReadDir to call Lstat, for testing that code path.
		This can be difficult to provoke on some Unix systems otherwise.


Package-Level Constants (total 44, in which 29 are exported)

	const DevNull = "/dev/null"
		DevNull is the name of the operating system's “null device.”
		On Unix-like systems, it is "/dev/null"; on Windows, "NUL".

	const ModeAppend fs.FileMode = 1073741824 // a: append-only
		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 ModeCharDevice fs.FileMode = 2097152 // c: Unix character device, when ModeDevice is set
		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 ModeDevice fs.FileMode = 67108864 // D: device file
		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 ModeDir fs.FileMode = 2147483648 // d: is a directory
		The single letters are the abbreviations
		used by the String method's formatting.

	const ModeExclusive fs.FileMode = 536870912 // l: exclusive use
		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 ModeIrregular fs.FileMode = 524288 // ?: non-regular file; nothing else is known about this file
		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 ModeNamedPipe fs.FileMode = 33554432 // p: named pipe (FIFO)
		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 ModePerm fs.FileMode = 511 // Unix permission bits, 0o777
		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 ModeSetgid fs.FileMode = 4194304 // g: setgid
		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 ModeSetuid fs.FileMode = 8388608 // u: setuid
		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 ModeSocket fs.FileMode = 16777216 // S: Unix domain socket
		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 ModeSticky fs.FileMode = 1048576 // t: sticky
		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 ModeSymlink fs.FileMode = 134217728 // L: symbolic link
		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 ModeTemporary fs.FileMode = 268435456 // T: temporary file; Plan 9 only
		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 ModeType fs.FileMode = 2401763328
		Mask for the type bits. For regular files, none will be set.

	const O_APPEND int = 1024 // append data to the file when writing.
		The remaining values may be or'ed in to control behavior.

	const O_CREATE int = 64 // create a new file if none exists.
		Flags to OpenFile wrapping those of the underlying system. Not all
		flags may be implemented on a given system.

	const O_EXCL int = 128 // used with O_CREATE, file must not exist.
		Flags to OpenFile wrapping those of the underlying system. Not all
		flags may be implemented on a given system.

	const O_RDONLY int = 0 // open the file read-only.
		Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.

	const O_RDWR int = 2 // open the file read-write.
		Flags to OpenFile wrapping those of the underlying system. Not all
		flags may be implemented on a given system.

	const O_SYNC int = 1052672 // open for synchronous I/O.
		Flags to OpenFile wrapping those of the underlying system. Not all
		flags may be implemented on a given system.

	const O_TRUNC int = 512 // truncate regular writable file when opened.
		Flags to OpenFile wrapping those of the underlying system. Not all
		flags may be implemented on a given system.

	const O_WRONLY int = 1 // open the file write-only.
		Flags to OpenFile wrapping those of the underlying system. Not all
		flags may be implemented on a given system.

	const PathListSeparator = 58 // OS-specific path list separator
	const PathSeparator = 47 // OS-specific path separator
	const SEEK_CUR int = 1 // seek relative to the current offset
		Seek whence values.
		
		Deprecated: Use io.SeekStart, io.SeekCurrent, and io.SeekEnd.

	const SEEK_END int = 2 // seek relative to the end
		Seek whence values.
		
		Deprecated: Use io.SeekStart, io.SeekCurrent, and io.SeekEnd.

	const SEEK_SET int = 0 // seek relative to the origin of the file
		Seek whence values.
		
		Deprecated: Use io.SeekStart, io.SeekCurrent, and io.SeekEnd.

	/* 15 unexporteds ... *//* 15 unexporteds: */
	const _P_PID = 1
	const _UTIME_OMIT = 1073741822
	const blockSize = 8192
		More than 5760 to work around https://golang.org/issue/24015.

	const hex = "0123456789abcdef"
	const isBigEndian = false
	const kindNewFile newFileKind = 0
		kindNewFile means that the descriptor was passed to us via NewFile.

	const kindNonBlock newFileKind = 3
		kindNonBlock means that the descriptor is already in
		non-blocking mode.

	const kindNoPoll newFileKind = 4
		kindNoPoll means that we should not put the descriptor into
		non-blocking mode, because we know it is not a pipe or FIFO.
		Used by openFdAt for directories.

	const kindOpenFile newFileKind = 1
		kindOpenFile means that the descriptor was opened using
		Open, Create, or OpenFile (without O_NONBLOCK).

	const kindPipe newFileKind = 2
		kindPipe means that the descriptor was opened using Pipe.

	const readdirDirEntry readdirMode = 1
	const readdirFileInfo readdirMode = 2
	const readdirName readdirMode = 0
	const supportsCloseOnExec = true
		supportsCloseOnExec reports whether the platform supports the
		O_CLOEXEC flag.
		On Darwin, the O_CLOEXEC flag was introduced in OS X 10.7 (Darwin 11.0.0).
		See https://support.apple.com/kb/HT1633.
		On FreeBSD, the O_CLOEXEC flag was introduced in version 8.3.

	const supportsCreateWithStickyBit = true

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.