go2hx

manual

github

Module: stdgo.path.filepath

(view library index)

Overview

Index

Constants

import stdgo.path.filepath.Filepath
final listSeparator:Int = stdgo._internal.path.filepath.Filepath_listSeparator.listSeparator
final separator:Int = stdgo._internal.path.filepath.Filepath_separator.separator

Variables

import stdgo.path.filepath.Filepath
var errBadPattern:stdgo.Error
var skipAll:stdgo.Error
var skipDir:stdgo.Error

Functions

import stdgo.path.filepath.Filepath

function lstatP

function lstatP()

(view code)

Classes

import stdgo.path.filepath.*

class Filepath

{
    	_ = 0
    	gotoNext = 3944698
    	_ = gotoNext == 3944698
    	if len(pattern) > 0 && pattern[0] == 42 {
    		gotoNext = 3944740
    		_ = gotoNext == 3944740
    		pattern = pattern[1:]
    		star = true
    		gotoNext = 3944698
    	} else {
    		gotoNext = 3944784
}
    	_ = gotoNext == 3944784
    	inrange_3944784 = false
    	gotoNext = 3944812
    	_ = gotoNext == 3944812
    	i_3944806 = 0
    	ScanBreak = false
    	gotoNext = 3944819
    	_ = gotoNext == 3944819
    	if !ScanBreak && (i_3944806 < len(pattern)) {
    		gotoNext = 3944852
    		_ = gotoNext == 3944852
    		_ = 0
    		gotoNext = 3944856
    		_ = gotoNext == 3944856
    		switch pattern[i_3944806] {
    		case 92:
    			gotoNext = 3944878
    			_ = gotoNext == 3944878
    			if true {
    				gotoNext = 3944921
    				_ = gotoNext == 3944921
    				if i_3944806+1 < len(pattern) {
    					gotoNext = 3945004
    					_ = gotoNext == 3945004
    					i_3944806++
    					gotoNext = 3944848
    				} else {
    					gotoNext = 3944848
}
    				gotoNext = 3944848
    			} else {
    				gotoNext = 3944848
}
    			gotoNext = 3944848
    		case 91:
    			gotoNext = 3945028
    			_ = gotoNext == 3945028
    			inrange_3944784 = true
    			gotoNext = 3944848
    		case 93:
    			gotoNext = 3945058
    			_ = gotoNext == 3945058
    			inrange_3944784 = false
    			gotoNext = 3944848
    		case 42:
    			gotoNext = 3945089
    			_ = gotoNext == 3945089
    			if !inrange_3944784 {
    				gotoNext = 3945114
    				_ = gotoNext == 3945114
    				ScanBreak = true
    				gotoNext = 3944819
    				gotoNext = 3944848
    			} else {
    				gotoNext = 3944848
}
    			gotoNext = 3944848
    		default:
    			gotoNext = 3944848
}
    		_ = gotoNext == 3944848
    		i_3944806++
    		gotoNext = 3944819
    	} else {
    		gotoNext = 3945144
}
    	_ = gotoNext == 3945144
    	return star, pattern[0:i_3944806], pattern[i_3944806:]
    	gotoNext = -1
    }

Filepath function abs

function abs(_path:String):stdgo.Tuple<String, stdgo.Error>
Abs returns an absolute representation of path.
        If the path is not absolute it will be joined with the current
        working directory to turn it into an absolute path. The absolute
        path name for a given file is not guaranteed to be unique.
        Abs calls Clean on the result.

(view code)

Filepath function base

function base(_path:String):String
Base returns the last element of path.
        Trailing path separators are removed before extracting the last element.
        If the path is empty, Base returns ".".
        If the path consists entirely of separators, Base returns a single separator.

(view code)

Filepath function clean

function clean(_path:String):String
Clean returns the shortest path name equivalent to path
        by purely lexical processing. It applies the following rules
        iteratively until no further processing can be done:
         1. Replace multiple Separator elements with a single one.
         2. Eliminate each . path name element (the current directory).
         3. Eliminate each inner .. path name element (the parent directory)
            along with the non-.. element that precedes it.
         4. Eliminate .. elements that begin a rooted path:
            that is, replace "/.." by "/" at the beginning of a path,
            assuming Separator is '/'.

The returned path ends in a slash only if it represents a root directory, such as "/" on Unix or \C:\\\ on Windows.

Finally, any occurrences of slash are replaced by Separator.

If the result of this process is an empty string, Clean returns the string ".".

On Windows, Clean does not modify the volume name other than to replace occurrences of "/" with \\\\. For example, Clean("//host/share/../x") returns \\\\\host\\share\\x\.

See also Rob Pike, “Lexical File Names in Plan 9 or Getting Dot-Dot Right,” https://9p.io/sys/doc/lexnames.html

(view code)

Filepath function dir

function dir(_path:String):String
Dir returns all but the last element of path, typically the path's directory.
        After dropping the final element, Dir calls Clean on the path and trailing
        slashes are removed.
        If the path is empty, Dir returns ".".
        If the path consists entirely of separators, Dir returns a single separator.
        The returned path does not end in a separator unless it is the root directory.

(view code)

Filepath function evalSymlinks

function evalSymlinks(_path:String):stdgo.Tuple<String, stdgo.Error>
EvalSymlinks returns the path name after the evaluation of any symbolic
        links.
        If path is relative the result will be relative to the current directory,
        unless one of the components is an absolute symbolic link.
        EvalSymlinks calls Clean on the result.

(view code)

Filepath function ext

function ext(_path:String):String
Ext returns the file name extension used by path.
        The extension is the suffix beginning at the final dot
        in the final element of path; it is empty if there is
        no dot.

(view code)

Filepath function fromSlash

function fromSlash(_path:String):String
FromSlash returns the result of replacing each slash ('/') character
        in path with a separator character. Multiple slashes are replaced
        by multiple separators.

(view code)

Filepath function glob

function glob(_pattern:String):stdgo.Tuple<Array<String>, stdgo.Error>
Glob returns the names of all files matching pattern or nil
        if there is no matching file. The syntax of patterns is the same
        as in Match. The pattern may describe hierarchical names such as
        /usr/|*|/bin/ed (assuming the Separator is '/').

Glob ignores file system errors such as I/O errors reading directories. The only possible returned error is ErrBadPattern, when pattern is malformed.

(view code)

Filepath function hasPrefix

function hasPrefix(_p:String, _prefix:String):Bool

HasPrefix exists for historical compatibility and should not be used.

Deprecated: HasPrefix does not respect path boundaries and does not ignore case when required.

(view code)

Filepath function isAbs

function isAbs(_path:String):Bool

IsAbs reports whether the path is absolute.

(view code)

Filepath function isLocal

function isLocal(_path:String):Bool

IsLocal reports whether path, using lexical analysis only, has all of these properties:

- is within the subtree rooted at the directory in which path is evaluated - is not an absolute path - is not empty - on Windows, is not a reserved name such as "NUL" 

        If IsLocal(path) returns true, then
        Join(base, path) will always produce a path contained within base and
        Clean(path) will always produce an unrooted path with no ".." path elements.

IsLocal is a purely lexical operation. In particular, it does not account for the effect of any symbolic links that may exist in the filesystem.

(view code)

Filepath function join

function join(_elem:haxe.Rest<String>):String
Join joins any number of path elements into a single path,
        separating them with an OS specific Separator. Empty elements
        are ignored. The result is Cleaned. However, if the argument
        list is empty or all its elements are empty, Join returns
        an empty string.
        On Windows, the result will only be a UNC path if the first
        non-empty element is a UNC path.

(view code)

Filepath function match

function match(_pattern:String, _name:String):stdgo.Tuple<Bool, stdgo.Error>
Match reports whether name matches the shell file name pattern.
        The pattern syntax is:
        	pattern:
        		{ term }
        	term:
        		'*'         matches any sequence of non-Separator characters
        		'?'         matches any single non-Separator character
        		'[' [ '^' ] { character-range } ']'
        		            character class (must be non-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 pattern to match all of name, not just a substring. The only possible returned error is ErrBadPattern, when pattern is malformed.

On Windows, escaping is disabled. Instead, '\' is treated as path separator.

(view code)

Filepath function rel

function rel(_basepath:String, _targpath:String):stdgo.Tuple<String, stdgo.Error>
Rel returns a relative path that is lexically equivalent to targpath when
        joined to basepath with an intervening separator. That is,
        Join(basepath, Rel(basepath, targpath)) is equivalent to targpath itself.
        On success, the returned path will always be relative to basepath,
        even if basepath and targpath share no elements.
        An error is returned if targpath can't be made relative to basepath or if
        knowing the current working directory would be necessary to compute it.
        Rel calls Clean on the result.

(view code)

Filepath function split

function split(_path:String):stdgo.Tuple<String, String>
Split splits path immediately following the final Separator,
        separating it into a directory and file name component.
        If there is no Separator in path, Split returns an empty dir
        and file set to path.
        The returned values have the property that path = dir+file.

(view code)

Filepath function splitList

function splitList(_path:String):Array<String>
SplitList splits a list of paths joined by the OS-specific ListSeparator,
        usually found in PATH or GOPATH environment variables.
        Unlike strings.Split, SplitList returns an empty slice when passed an empty
        string.

(view code)

Filepath function toSlash

function toSlash(_path:String):String
ToSlash returns the result of replacing each separator character
        in path with a slash ('/') character. Multiple separators are
        replaced by multiple slashes.

(view code)

Filepath function volumeName

function volumeName(_path:String):String
VolumeName returns leading volume name.
        Given "C:\foo\bar" it returns "C:" on Windows.
        Given "\\host\share\foo" it returns "\\host\share".
        On other platforms it returns "".

(view code)

Filepath function walk

function walk(_root:String, _fn:stdgo.path.filepath.WalkFunc):stdgo.Error
Walk walks the file tree rooted at root, calling fn for each file or
        directory in the tree, including root.

All errors that arise visiting files and directories are filtered by fn: see the WalkFunc documentation for details.

The files are walked in lexical order, which makes the output deterministic but requires Walk to read an entire directory into memory before proceeding to walk that directory.

Walk does not follow symbolic links.

Walk is less efficient than WalkDir, introduced in Go 1.16, which avoids calling os.Lstat on every visited file or directory.

(view code)

Filepath function walkDir

function walkDir(_root:String, _fn:stdgo._internal.io.fs.WalkDirFunc):stdgo.Error
WalkDir walks the file tree rooted at root, calling fn for each file or
        directory in the tree, including root.

All errors that arise visiting files and directories are filtered by fn: see the fs.WalkDirFunc documentation for details.

The files are walked in lexical order, which makes the output deterministic but requires WalkDir to read an entire directory into memory before proceeding to walk that directory.

WalkDir does not follow symbolic links.

WalkDir calls fn with paths that use the separator character appropriate for the operating system. This is unlike [io/fs.WalkDir], which always uses slash separated paths.

(view code)

Typedefs

import stdgo.path.filepath.*

typedef WalkFunc

typedef WalkFunc = stdgo._internal.path.filepath.WalkFunc;

Abstracts

abstract T_lazybuf

(view file containing code)

abstract T_statDirEntry

(view file containing code)