// Generated by Lisette bindgen
// Source: os (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.12
import "go:io"
import "go:io/fs"
import "go:syscall"
import "go:time"
/// Chdir changes the current working directory to the named directory.
/// If there is an error, it will be of type [*PathError].
pub fn Chdir(dir: string) -> Result<(), 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 0o200 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 0o400 for a read-only
/// file and 0o600 for a readable+writable file.
///
/// On Plan 9, the mode's permission bits, [ModeAppend], [ModeExclusive],
/// and [ModeTemporary] are used.
pub fn Chmod(name: string, mode: fs.FileMode) -> Result<(), 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
/// [syscall.EPLAN9] error, wrapped in [*PathError].
pub fn Chown(name: string, uid: int, gid: int) -> Result<(), 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].
pub fn Chtimes(name: string, atime: time.Time, mtime: time.Time) -> Result<(), error>
/// Clearenv deletes all environment variables.
pub fn Clearenv()
/// CopyFS copies the file system fsys into the directory dir,
/// creating dir if necessary.
///
/// Files are created with mode 0o666 plus any execute permissions
/// from the source, and directories are created with mode 0o777
/// (before umask).
///
/// CopyFS will not overwrite existing files. If a file name in fsys
/// already exists in the destination, CopyFS will return an error
/// such that errors.Is(err, fs.ErrExist) will be true.
///
/// Symbolic links in dir are followed.
///
/// New files added to fsys (including if dir is a subdirectory of fsys)
/// while CopyFS is running are not guaranteed to be copied.
///
/// Copying stops at and returns the first error encountered.
pub fn CopyFS(dir: string, fsys: fs.FS) -> Result<(), error>
pub fn Create(name: string) -> Result<Ref<File>, error>
pub fn CreateTemp(dir: string, pattern: string) -> Result<Ref<File>, error>
/// 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.
///
/// Use [Root.FS] to obtain a fs.FS that prevents escapes from the tree via symbolic links.
///
/// The directory dir must not be "".
///
/// The result implements [io/fs.StatFS], [io/fs.ReadFileFS], [io/fs.ReadDirFS], and
/// [io/fs.ReadLinkFS].
pub fn DirFS(dir: string) -> fs.FS
/// Environ returns a copy of strings representing the environment,
/// in the form "key=value".
pub fn Environ() -> Slice<string>
/// 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.
pub fn Executable() -> Result<string, error>
/// 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].
pub fn Exit(code: int) -> Never
/// 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]).
pub fn Expand(s: string, mapping: fn(string) -> 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.
pub fn ExpandEnv(s: string) -> string
pub fn FindProcess(pid: int) -> Result<Ref<Process>, error>
/// Getegid returns the numeric effective group id of the caller.
///
/// On Windows, it returns -1.
pub fn Getegid() -> int
/// 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].
pub fn Getenv(key: string) -> string
/// Geteuid returns the numeric effective user id of the caller.
///
/// On Windows, it returns -1.
pub fn Geteuid() -> int
/// Getgid returns the numeric group id of the caller.
///
/// On Windows, it returns -1.
pub fn Getgid() -> int
/// 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.
pub fn Getgroups() -> Result<Slice<int>, error>
/// Getpagesize returns the underlying system's memory page size.
pub fn Getpagesize() -> int
/// Getpid returns the process id of the caller.
pub fn Getpid() -> int
/// Getppid returns the process id of the caller's parent.
pub fn Getppid() -> int
/// Getuid returns the numeric user id of the caller.
///
/// On Windows, it returns -1.
pub fn Getuid() -> int
/// Getwd returns an absolute 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.
///
/// On Unix platforms, if the environment variable PWD
/// provides an absolute name, and it is a name of the
/// current directory, it is returned.
pub fn Getwd() -> Result<string, error>
/// Hostname returns the host name reported by the kernel.
pub fn Hostname() -> Result<string, error>
/// IsExist returns a boolean indicating whether its argument 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).
pub fn IsExist(err: error) -> bool
/// IsNotExist returns a boolean indicating whether its argument 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).
pub fn IsNotExist(err: error) -> bool
/// IsPathSeparator reports whether c is a directory separator character.
pub fn IsPathSeparator(c: uint8) -> bool
/// IsPermission returns a boolean indicating whether its argument 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).
pub fn IsPermission(err: error) -> bool
/// IsTimeout returns a boolean indicating whether its argument 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].
pub fn IsTimeout(err: error) -> bool
/// 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].
pub fn Lchown(name: string, uid: int, gid: int) -> Result<(), error>
/// Link creates newname as a hard link to the oldname file.
/// If there is an error, it will be of type *LinkError.
pub fn Link(oldname: string, newname: string) -> Result<(), error>
/// 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.
pub fn LookupEnv(key: string) -> Option<string>
pub fn Lstat(name: string) -> Result<fs.FileInfo, 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].
pub fn Mkdir(name: string, perm: fs.FileMode) -> Result<(), 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.
pub fn MkdirAll(path: string, perm: fs.FileMode) -> Result<(), 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.
/// The directory is created with mode 0o700 (before umask).
/// 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.
pub fn MkdirTemp(dir: string, pattern: string) -> Result<string, error>
pub fn NewFile(fd: uint, name: string) -> Option<Ref<File>>
/// 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.
pub fn NewSyscallError(syscall: string, err: error) -> Option<error>
pub fn Open(name: string) -> Result<Ref<File>, error>
pub fn OpenFile(name: string, flag: int, perm: fs.FileMode) -> Result<Ref<File>, error>
pub fn OpenInRoot(dir: string, name: string) -> Result<Ref<File>, error>
pub fn OpenRoot(name: string) -> Result<Ref<Root>, 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.
pub fn Pipe() -> Result<(Ref<File>, Ref<File>), error>
pub fn ReadDir(name: string) -> Result<Slice<fs.DirEntry>, 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.
pub fn ReadFile(name: string) -> Result<Slice<uint8>, error>
/// Readlink returns the destination of the named symbolic link.
/// If there is an error, it will be of type [*PathError].
///
/// If the link destination is relative, Readlink returns the relative path
/// without resolving it to an absolute one.
pub fn Readlink(name: string) -> Result<string, error>
/// Remove removes the named file or (empty) directory.
/// If there is an error, it will be of type [*PathError].
pub fn Remove(name: string) -> Result<(), 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].
pub fn RemoveAll(path: string) -> Result<(), error>
/// Rename renames (moves) oldpath to newpath.
/// If newpath already exists and is not a directory, Rename replaces it.
/// If newpath already exists and is a directory, Rename returns an error.
/// 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.
pub fn Rename(oldpath: string, newpath: string) -> Result<(), error>
/// 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.
pub fn SameFile(fi1: fs.FileInfo, fi2: fs.FileInfo) -> bool
/// Setenv sets the value of the environment variable named by the key.
/// It returns an error, if any.
pub fn Setenv(key: string, value: string) -> Result<(), error>
pub fn StartProcess(name: string, argv: Slice<string>, attr: Ref<ProcAttr>) -> Result<Ref<Process>, error>
pub fn Stat(name: string) -> Result<fs.FileInfo, 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.
pub fn Symlink(oldname: string, newname: string) -> Result<(), error>
/// 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.
pub fn TempDir() -> string
/// 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].
pub fn Truncate(name: string, size: int64) -> Result<(), error>
/// Unsetenv unsets a single environment variable.
pub fn Unsetenv(key: string) -> Result<(), 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) or
/// the path in $XDG_CACHE_HOME is relative, then it will return an error.
pub fn UserCacheDir() -> Result<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) or
/// the path in $XDG_CONFIG_HOME is relative, then it will return an error.
pub fn UserConfigDir() -> Result<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.
pub fn UserHomeDir() -> Result<string, 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.
pub fn WriteFile(name: string, data: Slice<uint8>, perm: fs.FileMode) -> Result<(), error>
/// A DirEntry is an entry read from a directory
/// (using the [ReadDir] function or a [File.ReadDir] method).
pub type DirEntry = fs.DirEntry
/// File represents an open file descriptor.
///
/// The methods of File are safe for concurrent use.
pub type File
/// A FileInfo describes a file and is returned by [Stat] and [Lstat].
pub type FileInfo = fs.FileInfo
/// 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.
pub type FileMode = fs.FileMode
/// LinkError records an error during a link or symlink or rename
/// system call and the paths that caused it.
pub struct LinkError {
pub Op: string,
pub Old: string,
pub New: string,
pub Err: error,
}
/// PathError records an error and the operation and file path that caused it.
pub type PathError = fs.PathError
/// ProcAttr holds the attributes that will be applied to a new process
/// started by StartProcess.
pub struct ProcAttr {
pub Dir: string,
pub Env: Slice<string>,
pub Files: Slice<Option<Ref<File>>>,
pub Sys: Option<Ref<syscall.SysProcAttr>>,
}
/// Process stores the information about a process created by [StartProcess].
pub struct Process {
pub Pid: int,
}
/// ProcessState stores information about a process, as reported by Wait.
pub type ProcessState
/// Root may be used to only access files within a single directory tree.
///
/// Methods on Root can only access files and directories beneath a root directory.
/// If any component of a file name passed to a method of Root references a location
/// outside the root, the method returns an error.
/// File names may reference the directory itself (.).
///
/// Methods on Root will follow symbolic links, but symbolic links may not
/// reference a location outside the root.
/// Symbolic links must not be absolute.
///
/// Methods on Root do not prohibit traversal of filesystem boundaries,
/// Linux bind mounts, /proc special files, or access to Unix device files.
///
/// Methods on Root are safe to be used from multiple goroutines simultaneously.
///
/// On most platforms, creating a Root opens a file descriptor or handle referencing
/// the directory. If the directory is moved, methods on Root reference the original
/// directory in its new location.
///
/// Root's behavior differs on some platforms:
///
/// - When GOOS=windows, file names may not reference Windows reserved device names
/// such as NUL and COM1.
/// - On Unix, [Root.Chmod], [Root.Chown], and [Root.Chtimes] are vulnerable to a race condition.
/// If the target of the operation is changed from a regular file to a symlink
/// while the operation is in progress, the operation may be performed on the link
/// rather than the link target.
/// - When GOOS=js, Root is vulnerable to TOCTOU (time-of-check-time-of-use)
/// attacks in symlink validation, and cannot ensure that operations will not
/// escape the root.
/// - When GOOS=plan9 or GOOS=js, Root does not track directories across renames.
/// On these platforms, a Root references a directory name, not a file descriptor.
/// - WASI preview 1 (GOOS=wasip1) does not support [Root.Chmod].
pub type Root
/// A Signal represents an operating system signal.
/// The usual underlying implementation is operating system-dependent:
/// on Unix it is syscall.Signal.
pub interface Signal {
fn Signal()
fn String() -> string
}
/// SyscallError records an error from a specific system call.
pub struct SyscallError {
pub Syscall: string,
pub Err: error,
}
/// DevNull is the name of the operating system's “null device.”
/// On Unix-like systems, it is "/dev/null"; on Windows, "NUL".
const DevNull = "/dev/null"
/// 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 ModeAppend: fs.FileMode = 1073741824
/// 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
/// 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
/// 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
/// 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 ModeExclusive: fs.FileMode = 536870912
/// 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
/// 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
/// 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
/// 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
/// 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
/// 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
/// 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
/// 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
/// 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
/// 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
/// Flags to OpenFile wrapping those of the underlying system. Not all
/// flags may be implemented on a given system.
const O_APPEND = 8
/// Flags to OpenFile wrapping those of the underlying system. Not all
/// flags may be implemented on a given system.
const O_CREATE = 512
/// Flags to OpenFile wrapping those of the underlying system. Not all
/// flags may be implemented on a given system.
const O_EXCL = 2048
/// Flags to OpenFile wrapping those of the underlying system. Not all
/// flags may be implemented on a given system.
const O_RDONLY = 0
/// Flags to OpenFile wrapping those of the underlying system. Not all
/// flags may be implemented on a given system.
const O_RDWR = 2
/// Flags to OpenFile wrapping those of the underlying system. Not all
/// flags may be implemented on a given system.
const O_SYNC = 128
/// Flags to OpenFile wrapping those of the underlying system. Not all
/// flags may be implemented on a given system.
const O_TRUNC = 1024
/// Flags to OpenFile wrapping those of the underlying system. Not all
/// flags may be implemented on a given system.
const O_WRONLY = 1
const PathListSeparator = 58
const PathSeparator = 47
/// Seek whence values.
///
/// Deprecated: Use io.SeekStart, io.SeekCurrent, and io.SeekEnd.
const SEEK_CUR = 1
/// Seek whence values.
///
/// Deprecated: Use io.SeekStart, io.SeekCurrent, and io.SeekEnd.
const SEEK_END = 2
/// Seek whence values.
///
/// Deprecated: Use io.SeekStart, io.SeekCurrent, and io.SeekEnd.
const SEEK_SET = 0
/// Args hold the command-line arguments, starting with the program name.
pub var Args: Slice<string>
/// Portable analogs of some common system call errors.
///
/// Errors returned from this package may be tested against these errors
/// with [errors.Is].
pub var ErrClosed: error
/// Portable analogs of some common system call errors.
///
/// Errors returned from this package may be tested against these errors
/// with [errors.Is].
pub var ErrDeadlineExceeded: error
/// Portable analogs of some common system call errors.
///
/// Errors returned from this package may be tested against these errors
/// with [errors.Is].
pub var ErrExist: error
/// Portable analogs of some common system call errors.
///
/// Errors returned from this package may be tested against these errors
/// with [errors.Is].
pub var ErrInvalid: error
/// Portable analogs of some common system call errors.
///
/// Errors returned from this package may be tested against these errors
/// with [errors.Is].
pub var ErrNoDeadline: error
/// Portable analogs of some common system call errors.
///
/// Errors returned from this package may be tested against these errors
/// with [errors.Is].
pub var ErrNotExist: error
/// Portable analogs of some common system call errors.
///
/// Errors returned from this package may be tested against these errors
/// with [errors.Is].
pub var ErrPermission: error
/// ErrProcessDone indicates a [Process] has finished.
pub var ErrProcessDone: error
pub var Interrupt: Signal
pub var Kill: Signal
/// 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.
pub var Stderr: Ref<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.
pub var Stdin: Ref<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.
pub var Stdout: Ref<File>
impl File {
/// 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].
fn Chdir(self: Ref<File>) -> Result<(), error>
/// Chmod changes the mode of the file to mode.
/// If there is an error, it will be of type [*PathError].
fn Chmod(self: Ref<File>, mode: fs.FileMode) -> Result<(), 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].
fn Chown(self: Ref<File>, uid: int, gid: int) -> Result<(), error>
/// Close closes the [File], rendering it unusable for I/O.
/// On files that support [File.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.
#[allow(unused_result)]
fn Close(self: Ref<File>) -> Result<(), error>
/// Fd returns the system file descriptor or handle referencing the open file.
/// If f is closed, the descriptor becomes invalid.
/// If f is garbage collected, a finalizer may close the descriptor,
/// making it invalid; see [runtime.SetFinalizer] for more information on when
/// a finalizer might be run.
///
/// Do not close the returned descriptor; that could cause a later
/// close of f to close an unrelated descriptor.
///
/// Fd's behavior differs on some platforms:
///
/// - On Unix and Windows, [File.SetDeadline] methods will stop working.
/// - On Windows, the file descriptor will be disassociated from the
/// Go runtime I/O completion port if there are no concurrent I/O
/// operations on the file.
///
/// For most uses prefer the f.SyscallConn method.
fn Fd(self: Ref<File>) -> uint
/// Name returns the name of the file as presented to Open.
///
/// It is safe to call Name after [Close].
fn Name(self: Ref<File>) -> string
/// 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.
fn Read(self: Ref<File>, mut b: Slice<uint8>) -> Partial<int, 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.
fn ReadAt(self: Ref<File>, mut b: Slice<uint8>, off: int64) -> Partial<int, 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).
fn ReadDir(self: Ref<File>, n: int) -> Result<Slice<fs.DirEntry>, error>
/// ReadFrom implements io.ReaderFrom.
fn ReadFrom(self: Ref<File>, r: io.Reader) -> Result<int64, 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.
fn Readdir(self: Ref<File>, n: int) -> Result<Slice<fs.FileInfo>, 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.
fn Readdirnames(self: Ref<File>, n: int) -> Result<Slice<string>, 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.
fn Seek(self: Ref<File>, offset: int64, whence: int) -> Result<int64, 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.
fn SetDeadline(self: Ref<File>, t: time.Time) -> Result<(), 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.
fn SetReadDeadline(self: Ref<File>, t: time.Time) -> Result<(), 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.
fn SetWriteDeadline(self: Ref<File>, t: time.Time) -> Result<(), error>
/// Stat returns the [FileInfo] structure describing file.
/// If there is an error, it will be of type [*PathError].
fn Stat(self: Ref<File>) -> Result<fs.FileInfo, 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.
fn Sync(self: Ref<File>) -> Result<(), error>
/// SyscallConn returns a raw file.
/// This implements the syscall.Conn interface.
fn SyscallConn(self: Ref<File>) -> Result<syscall.RawConn, 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].
fn Truncate(self: Ref<File>, size: int64) -> Result<(), 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).
fn Write(self: Ref<File>, b: Slice<uint8>) -> Partial<int, 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.
fn WriteAt(self: Ref<File>, b: Slice<uint8>, off: int64) -> Partial<int, error>
/// WriteString is like Write, but writes the contents of string s rather than
/// a slice of bytes.
fn WriteString(self: Ref<File>, s: string) -> Result<int, error>
/// WriteTo implements io.WriterTo.
fn WriteTo(self: Ref<File>, w: io.Writer) -> Result<int64, error>
}
impl LinkError {
fn Error(self: Ref<LinkError>) -> string
fn Unwrap(self: Ref<LinkError>) -> Option<error>
}
impl Process {
/// 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.
fn Kill(self: Ref<Process>) -> Result<(), error>
/// Release releases any resources associated with the [Process] p,
/// rendering it unusable in the future.
/// Release only needs to be called if [Process.Wait] is not.
fn Release(self: Ref<Process>) -> Result<(), error>
/// Signal sends a signal to the [Process].
/// Sending [Interrupt] on Windows is not implemented.
fn Signal(self: Ref<Process>, sig: Signal) -> Result<(), 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.
fn Wait(self: Ref<Process>) -> Result<Ref<ProcessState>, error>
}
impl ProcessState {
/// ExitCode returns the exit code of the exited process, or -1
/// if the process hasn't exited or was terminated by a signal.
fn ExitCode(self: Ref<ProcessState>) -> int
/// 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.
fn Exited(self: Ref<ProcessState>) -> bool
/// Pid returns the process id of the exited process.
fn Pid(self: Ref<ProcessState>) -> int
fn String(self: Ref<ProcessState>) -> string
/// Success reports whether the program exited successfully,
/// such as with exit status 0 on Unix.
fn Success(self: Ref<ProcessState>) -> bool
/// 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.
fn Sys(self: Ref<ProcessState>) -> Unknown
/// 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.)
fn SysUsage(self: Ref<ProcessState>) -> Unknown
/// SystemTime returns the system CPU time of the exited process and its children.
fn SystemTime(self: Ref<ProcessState>) -> time.Duration
/// UserTime returns the user CPU time of the exited process and its children.
fn UserTime(self: Ref<ProcessState>) -> time.Duration
}
impl Root {
/// Chmod changes the mode of the named file in the root to mode.
/// See [Chmod] for more details.
fn Chmod(self: Ref<Root>, name: string, mode: fs.FileMode) -> Result<(), error>
/// Chown changes the numeric uid and gid of the named file in the root.
/// See [Chown] for more details.
fn Chown(self: Ref<Root>, name: string, uid: int, gid: int) -> Result<(), error>
/// Chtimes changes the access and modification times of the named file in the root.
/// See [Chtimes] for more details.
fn Chtimes(self: Ref<Root>, name: string, atime: time.Time, mtime: time.Time) -> Result<(), error>
/// Close closes the Root.
/// After Close is called, methods on Root return errors.
#[allow(unused_result)]
fn Close(self: Ref<Root>) -> Result<(), error>
/// Create creates or truncates the named file in the root.
/// See [Create] for more details.
fn Create(self: Ref<Root>, name: string) -> Result<Ref<File>, error>
/// FS returns a file system (an fs.FS) for the tree of files in the root.
///
/// The result implements [io/fs.StatFS], [io/fs.ReadFileFS],
/// [io/fs.ReadDirFS], and [io/fs.ReadLinkFS].
fn FS(self: Ref<Root>) -> fs.FS
/// Lchown changes the numeric uid and gid of the named file in the root.
/// See [Lchown] for more details.
fn Lchown(self: Ref<Root>, name: string, uid: int, gid: int) -> Result<(), error>
/// Link creates newname as a hard link to the oldname file.
/// Both paths are relative to the root.
/// See [Link] for more details.
///
/// If oldname is a symbolic link, Link creates new link to oldname and not its target.
/// This behavior may differ from that of [Link] on some platforms.
///
/// When GOOS=js, Link returns an error if oldname is a symbolic link.
fn Link(self: Ref<Root>, oldname: string, newname: string) -> Result<(), error>
/// Lstat returns a [FileInfo] describing the named file in the root.
/// If the file is a symbolic link, the returned FileInfo
/// describes the symbolic link.
/// See [Lstat] for more details.
fn Lstat(self: Ref<Root>, name: string) -> Result<fs.FileInfo, error>
/// Mkdir creates a new directory in the root
/// with the specified name and permission bits (before umask).
/// See [Mkdir] for more details.
///
/// If perm contains bits other than the nine least-significant bits (0o777),
/// Mkdir returns an error.
fn Mkdir(self: Ref<Root>, name: string, perm: fs.FileMode) -> Result<(), error>
/// MkdirAll creates a new directory in the root, along with any necessary parents.
/// See [MkdirAll] for more details.
///
/// If perm contains bits other than the nine least-significant bits (0o777),
/// MkdirAll returns an error.
fn MkdirAll(self: Ref<Root>, name: string, perm: fs.FileMode) -> Result<(), error>
/// Name returns the name of the directory presented to OpenRoot.
///
/// It is safe to call Name after [Close].
fn Name(self: Ref<Root>) -> string
/// Open opens the named file in the root for reading.
/// See [Open] for more details.
fn Open(self: Ref<Root>, name: string) -> Result<Ref<File>, error>
/// OpenFile opens the named file in the root.
/// See [OpenFile] for more details.
///
/// If perm contains bits other than the nine least-significant bits (0o777),
/// OpenFile returns an error.
fn OpenFile(self: Ref<Root>, name: string, flag: int, perm: fs.FileMode) -> Result<Ref<File>, error>
/// OpenRoot opens the named directory in the root.
/// If there is an error, it will be of type [*PathError].
fn OpenRoot(self: Ref<Root>, name: string) -> Result<Ref<Root>, error>
/// ReadFile reads the named file in the root and returns its contents.
/// See [ReadFile] for more details.
fn ReadFile(self: Ref<Root>, name: string) -> Result<Slice<uint8>, error>
/// Readlink returns the destination of the named symbolic link in the root.
/// See [Readlink] for more details.
fn Readlink(self: Ref<Root>, name: string) -> Result<string, error>
/// Remove removes the named file or (empty) directory in the root.
/// See [Remove] for more details.
fn Remove(self: Ref<Root>, name: string) -> Result<(), error>
/// RemoveAll removes the named file or directory and any children that it contains.
/// See [RemoveAll] for more details.
fn RemoveAll(self: Ref<Root>, name: string) -> Result<(), error>
/// Rename renames (moves) oldname to newname.
/// Both paths are relative to the root.
/// See [Rename] for more details.
fn Rename(self: Ref<Root>, oldname: string, newname: string) -> Result<(), error>
/// Stat returns a [FileInfo] describing the named file in the root.
/// See [Stat] for more details.
fn Stat(self: Ref<Root>, name: string) -> Result<fs.FileInfo, error>
/// Symlink creates newname as a symbolic link to oldname.
/// See [Symlink] for more details.
///
/// Symlink does not validate oldname,
/// which may reference a location outside the root.
///
/// On Windows, a directory link is created if oldname references
/// a directory within the root. Otherwise a file link is created.
fn Symlink(self: Ref<Root>, oldname: string, newname: string) -> Result<(), error>
/// WriteFile writes data to the named file in the root, creating it if necessary.
/// See [WriteFile] for more details.
fn WriteFile(
self: Ref<Root>,
name: string,
data: Slice<uint8>,
perm: fs.FileMode,
) -> Result<(), error>
}
impl SyscallError {
fn Error(self: Ref<SyscallError>) -> string
/// Timeout reports whether this error represents a timeout.
fn Timeout(self: Ref<SyscallError>) -> bool
fn Unwrap(self: Ref<SyscallError>) -> Option<error>
}