type buffer[link]

type buffer = struct {
	buf: [PATH_MAX]u8,
	end: size,
};

type iterator[link]

type iterator = struct {
	cur: []u8,
	reverse: bool,
};

type cant_extend[link]

type cant_extend = !void;

Returned when adding an extension if the path is root, or the final path segment consists entirely of dots.

type error[link]

type error = !(cant_extend | too_long | not_prefix);

Represents an error during a path manipulation

type not_prefix[link]

type not_prefix = !void;

Returned when trimprefix receives a prefix that is not present.

type too_long[link]

type too_long = !void;

Returned when a path buffer would have overflowed.

def PATHSEP[link]

def PATHSEP: u8;

Platform-specific path separator byte.

def PATH_MAX[link]

def PATH_MAX: size;

Maximum length of a file path for this platform.

fn abs[link]

fn abs(path: (*buffer | str)) bool;

Check if a path is an absolute path.

fn basename[link]

fn basename(path: const str) const str;

A POSIX-compliant implementation of basename. See the POSIX specification for more information. Note that this function does *not* normalize the input. The return value is either borrowed from the input or statically allocated; use strings::dup to extend its lifetime.

fn dirname[link]

fn dirname(path: const str) const str;

A POSIX-compliant implementation of dirname. See the POSIX specification for more information. Note that this function does *not* normalize the input. The return value is either borrowed from the input or statically allocated; use strings::dup to extend its lifetime.

fn init[link]

fn init(items: str...) (buffer | error);

Initializes a new path buffer.

fn isroot[link]

fn isroot(path: (*buffer | str)) bool;

Check if a path is the root directory.

fn iter[link]

fn iter(buf: *buffer) iterator;

Returns an iterator which yields each component of a path, moving down through child dirs. If the path is absolute, the first component will be the root. The iterator can be copied to save its state.

fn iterrem[link]

fn iterrem(it: *iterator) str;

get the remaining path from an iterator, without advancing the iterator.

fn local[link]

fn local(path: str) str;

Replace '/' with system-dependent path separator in a string. Modifies the original string, but is idempotent. The result is borrowed from the input.

fn nextiter[link]

fn nextiter(it: *iterator) (str | void);

Returns the next path component from an iterator, or void if none remain. Advances the iterator.

fn parent[link]

fn parent(buf: *const buffer) (str | error);

Returns the parent directory for a given path, without modifying the buffer. If the path is the root directory, the root directory is returned. The value is either borrowed from the input or statically allocated; use strings::dup to extend its lifetime or modify it.

fn peek[link]

fn peek(buf: *const buffer) (str | void);

Examine the final path segment in a buffer. Returns void if the path is empty or is the root dir.

fn peek_ext[link]

fn peek_ext(buf: *buffer) (str | void);

Examine the final extension in a path. The result will not include the leading '.'. The result is borrowed from the buffer. Leading dots will be ignored when looking for extensions, such that ".ssh" isn't considered to have any extensions.

fn peek_exts[link]

fn peek_exts(buf: *buffer) (str | void);

Examine all the extensions in a path. The result will not include the leading '.', but will include separating dots. Leading dots will be ignored when looking for extensions, such that ".ssh" isn't considered to have any extensions. The result is borrowed from the buffer.

fn peekiter[link]

fn peekiter(it: *iterator) (str | void);

Returns the next path component from an iterator, or void if none remain. Does not advance the iterator.

fn pop[link]

fn pop(buf: *buffer) (str | void);

Remove and return the final path segment in a buffer. Returns void if the path is empty or is the root dir.

fn pop_ext[link]

fn pop_ext(buf: *buffer) (str | void);

Remove and return the final extension in a path. The result will not include the leading '.'. The result is borrowed from the buffer. Leading dots will be ignored when looking for extensions, such that ".ssh" isn't considered to have any extensions.

fn pop_exts[link]

fn pop_exts(buf: *buffer) (str | void);

Remove and return all the extensions in a path. The result will not include the leading '.', but will include separating dots. Leading dots will be ignored when looking for extensions, such that ".ssh" isn't considered to have any extensions. The result is borrowed from the buffer.

fn popprefix[link]

fn popprefix(buf: *buffer, prefix: str) (str | error);

Equivalent to trimprefix, but modifies the buffer in the process.

fn prepend[link]

fn prepend(buf: *buffer, prefix: str...) (str | error);

Add a prefix to a buffer. The buffer will be modified, and it will remain normalized, so any ".." components in the original buffer may be collapsed.

fn push[link]

fn push(buf: *buffer, items: str...) (str | error);

Appends path elements onto the end of a path buffer. Returns the new string value of the path.

fn push_ext[link]

fn push_ext(buf: *buffer, ext: str...) (str | error);

Add extensions onto the end of the final path segment. The separating '.' will be inserted for you. If the final path segment consists entirely of dots or the path is root, this function will return cant_extend.

fn riter[link]

fn riter(buf: *buffer) iterator;

Returns an iterator which yields each component of a path, moving up through parent dirs. If the path is absolute, the last component will be the root. The iterator can be copied to save its state.

fn set[link]

fn set(buf: *buffer, items: str...) (str | error);

Sets the value of a path buffer to a list of components, overwriting any previous value. Returns the new string value of the path.

fn strerror[link]

fn strerror(e: error) str;

Convert an error into a descriptive string.

fn string[link]

fn string(buf: *buffer) str;

Returns the current path stored in this buffer. The return value is borrowed from the buffer. Use strings::dup to extend the lifetime of the string.

fn trimprefix[link]

fn trimprefix(buf: *buffer, prefix: str) (str | error);

Returns a buffer without a prefix. The prefix is normalized before processing, and this function will return too_long if the prefix is longer than PATH_MAX. If the prefix is not present, returns not_prefix. The resulting path will always be relative.

This function does not modify the buffer. See popprefix.