package core:path/filepath

Source

Get the absolute path to path with respect to the process's current directory.

Allocates Using Provided Allocator

Gets the file name and extension from a path.

e.g.

'path/to/name.tar.gz' -> 'name.tar.gz'
'path/to/name.txt'    -> 'name.txt'
'path/to/name'        -> 'name'

Returns "." if the path is an empty string.

Returns the shortest path name equivalent to path through solely lexical processing. It applies the folliwng rules until none of them can be applied:

• Replace multiple separators with a single one
• Remove each current directory (.) path name element
• Remove each inner parent directory (..) path and the preceding paths
• Remove .. that begin at the root of a path
• All possible separators are replaced with the OS specific separator

The return path ends in a slash only if it represents the root of a directory (C:\ on Windows and / on *nix systems).

If the result of the path is an empty string, the returned path with be ".".

Gets the parent directory path from a path.

e.g.

'/home/foo/bar.tar.gz' -> '/home/foo'
'path/to/name.tar.gz'  -> 'path/to'

Returns "." if the path is an empty string.

Gets the file extension from a path, including the dot.

The file extension is such that stem_path(path) + ext(path) = base(path).

Only the last dot is considered when splitting the file extension. See long_ext.

e.g.

'name.tar.gz' -> '.gz'
'name.txt'    -> '.txt'

Returns an empty string if there is no dot. Returns an empty string if there is a trailing path separator.

glob returns the names of all files matching pattern or nil if there are no matching files The syntax of patterns is the same as "match". The pattern may describe hierarchical names such as /usr/*/bin (assuming '/' is a separator)

glob ignores file system errors

Return true if path is an absolute path as opposed to a relative one.

Return true if c is a character used to separate paths into directory and file hierarchies on the current system.

Join all elems with the system's path separator and normalize the result.

Allocates Using Provided Allocator

For example, join_path({"/home", "foo", "bar.txt"}) will result in "/home/foo/bar.txt".

Gets the file extension from a path, including the dot.

The long file extension is such that short_stem(path) + long_ext(path) = base(path).

The first dot is used to split off the file extension, unlike ext which uses the last dot.

e.g.

'name.tar.gz' -> '.tar.gz'
'name.txt'    -> '.txt'

Returns an empty string if there is no dot. Returns an empty string if there is a trailing path separator.

match states whether "name" matches the shell pattern

Pattern syntax is:

pattern:
	{term}
term:
	'*'	        matches any sequence of non-/ characters
	'?'             matches any single non-/ character
	'[' ['^']  { character-range } ']'
									character classification (cannot be empty)
	c               matches character c (c != '*', '?', '\\', '[')
	'\\' c          matches character c

character-range
	c               matches character c (c != '\\', '-', ']')
	'\\' c          matches character c
	lo '-' hi       matches character c for lo <= c <= hi

match requires that the pattern matches the entirety of the name, not just a substring. The only possible error returned is .Syntax_Error or an allocation error.

NOTE(bill): This is effectively the shell pattern matching system found

Reads the file f (assuming it is a directory) and returns all of the unsorted directory entries.

Reads the named directory by path (assuming it is a directory) and returns all of the unsorted directory entries.

Reads the file f (assuming it is a directory) and returns the unsorted directory entries. This returns up to n entries OR all of them if n <= 0.

Reads the named directory by path (assuming it is a directory) and returns the unsorted directory entries. This returns up to n entries OR all of them if n <= 0.

Returns a relative path that is lexically equivalent to the target_path when joined with the base_path with an OS specific separator.

e.g. join(base_path, rel(base_path, target_path)) is equivalent to target_path

On failure, the Relative_Error will be state it cannot compute the necessary relative path.

Returns the result of replacing each path separator character in the path with the specific character new_sep.

Allocates Using Provided Allocator

Gets the name of a file from a path.

The short stem is such that short_stem(path) + long_ext(path) = base(path), where long_ext is the extension returned by split_filename_all.

The first dot is used to split off the file extension, unlike stem which uses the last dot.

e.g.

'name.tar.gz' -> 'name'
'name.txt'    -> 'name'

Returns an empty string if there is no stem. e.g: '.gitignore'. Returns an empty string if there's a trailing path separator.

Split a path into a directory hierarchy and a filename.

For example, split_path("/home/foo/bar.tar.gz") will return "/home/foo" and "bar.tar.gz".

Split a string that is separated by a system-specific separator, typically used for environment variables specifying multiple directories.

Allocates Using Provided Allocator

For example, there is the "PATH" environment variable on POSIX systems which this procedure can split into separate entries.

Gets the name of a file from a path.

The stem of a file is such that stem(path) + ext(path) = base(path).

Only the last dot is considered when splitting the file extension. See short_stem.

e.g.

'name.tar.gz' -> 'name.tar'
'name.txt'    -> 'name'

Returns an empty string if the path is empty Returns an empty string if there is no stem. e.g: '.gitignore'. Returns an empty string if there's a trailing path separator.

Returns leading volume name.

e.g.

"C:\foo\bar\baz" will return "C:" on Windows.
Everything else will be "".

Returns the last error that occurred during the walker's operations.

Can be called while iterating, or only at the end to check if anything failed.

Marks the current directory to be skipped (not entered into).

Returns the next file info in the iterator, files are iterated in breadth-first order.

If an error occurred opening a directory, you may get zero'd info struct and walker_error will return the error.

package main

import "core:fmt"
import "core:strings"
import "core:os"

main :: proc() {
	w := os.walker_create("core")
	defer os.walker_destroy(&w)

	for info in os.walker_walk(&w) {
		// Optionally break on the first error:
		// _ = walker_error(&w) or_break

		// Or, handle error as we go:
		if path, err := os.walker_error(&w); err != nil {
			fmt.eprintfln("failed walking %s: %s", path, err)
			continue
		}

		// Or, do not handle errors during iteration, and just check the error at the end.



		// Skip a directory:
		if strings.has_suffix(info.fullpath, ".git") {
			os.walker_skip_dir(&w)
			continue
		}

		fmt.printfln("%#v", info)
	}

	// Handle error if one happened during iteration at the end:
	if path, err := os.walker_error(&w); err != nil {
		fmt.eprintfln("failed walking %s: %v", path, err)
	}
}

Creates a walker, either using a path or a file pointer to a directory the walker will start at.

For an example on how to use the walker, see walker_walk.

Initializes a walker, either using a path or a file pointer to a directory the walker will start at.

You are allowed to repeatedly call this to reuse it for later walks.

For an example on how to use the walker, see walker_walk.