Filesystem(3) Tcl Library Procedures Filesystem(3)______________________________________________________________________________NAME
Tcl_FSRegister, Tcl_FSUnregister, Tcl_FSData, Tcl_FSMountsChanged,
Tcl_FSGetFileSystemForPath, Tcl_FSGetPathType, Tcl_FSCopyFile,
Tcl_FSCopyDirectory, Tcl_FSCreateDirectory, Tcl_FSDeleteFile, Tcl_FSRe‐
moveDirectory, Tcl_FSRenameFile, Tcl_FSListVolumes, Tcl_FSEvalFile,
Tcl_FSEvalFileEx, Tcl_FSLoadFile, Tcl_FSMatchInDirectory, Tcl_FSLink,
Tcl_FSLstat, Tcl_FSUtime, Tcl_FSFileAttrsGet, Tcl_FSFileAttrsSet,
Tcl_FSFileAttrStrings, Tcl_FSStat, Tcl_FSAccess, Tcl_FSOpenFileChannel,
Tcl_FSGetCwd, Tcl_FSChdir, Tcl_FSPathSeparator, Tcl_FSJoinPath,
Tcl_FSSplitPath, Tcl_FSEqualPaths, Tcl_FSGetNormalizedPath, Tcl_FSJoin‐
ToPath, Tcl_FSConvertToPathType, Tcl_FSGetInternalRep, Tcl_FSGetTrans‐
latedPath, Tcl_FSGetTranslatedStringPath, Tcl_FSNewNativePath,
Tcl_FSGetNativePath, Tcl_FSFileSystemInfo, Tcl_AllocStatBuf - proce‐
dures to interact with any filesystem
SYNOPSIS
#include <tcl.h>
int
Tcl_FSRegister(clientData, fsPtr)
int
Tcl_FSUnregister(fsPtr)
ClientData
Tcl_FSData(fsPtr)
void
Tcl_FSMountsChanged(fsPtr)
Tcl_Filesystem*
Tcl_FSGetFileSystemForPath(pathPtr)
Tcl_PathType
Tcl_FSGetPathType(pathPtr)
int
Tcl_FSCopyFile(srcPathPtr, destPathPtr)
int
Tcl_FSCopyDirectory(srcPathPtr, destPathPtr, errorPtr)
int
Tcl_FSCreateDirectory(pathPtr)
int
Tcl_FSDeleteFile(pathPtr)
int
Tcl_FSRemoveDirectory(pathPtr, int recursive, errorPtr)
int
Tcl_FSRenameFile(srcPathPtr, destPathPtr)
Tcl_Obj*
Tcl_FSListVolumes(void)
int │
Tcl_FSEvalFileEx(interp, pathPtr, encodingName) │
int
Tcl_FSEvalFile(interp, pathPtr)
int
Tcl_FSLoadFile(interp, pathPtr, sym1, sym2, proc1Ptr, proc2Ptr,
handlePtr, unloadProcPtr)
int
Tcl_FSMatchInDirectory(interp, resultPtr, pathPtr, pattern, types)
Tcl_Obj*
Tcl_FSLink(linkNamePtr, toPtr, linkAction)
int
Tcl_FSLstat(pathPtr, statPtr)
int
Tcl_FSUtime(pathPtr, tval)
int
Tcl_FSFileAttrsGet(interp, int index, pathPtr, objPtrRef)
int
Tcl_FSFileAttrsSet(interp, int index, pathPtr, Tcl_Obj *objPtr)
const char**
Tcl_FSFileAttrStrings(pathPtr, objPtrRef)
int
Tcl_FSStat(pathPtr, statPtr)
int
Tcl_FSAccess(pathPtr, mode)
Tcl_Channel
Tcl_FSOpenFileChannel(interp, pathPtr, modeString, permissions)
Tcl_Obj*
Tcl_FSGetCwd(interp)
int
Tcl_FSChdir(pathPtr)
Tcl_Obj*
Tcl_FSPathSeparator(pathPtr)
Tcl_Obj*
Tcl_FSJoinPath(listObj, elements)
Tcl_Obj*
Tcl_FSSplitPath(pathPtr, lenPtr)
int
Tcl_FSEqualPaths(firstPtr, secondPtr)
Tcl_Obj*
Tcl_FSGetNormalizedPath(interp, pathPtr)
Tcl_Obj*
Tcl_FSJoinToPath(basePtr, objc, objv)
int
Tcl_FSConvertToPathType(interp, pathPtr)
ClientData
Tcl_FSGetInternalRep(pathPtr, fsPtr)
Tcl_Obj *
Tcl_FSGetTranslatedPath(interp, pathPtr)
const char *
Tcl_FSGetTranslatedStringPath(interp, pathPtr)
Tcl_Obj*
Tcl_FSNewNativePath(fsPtr, clientData)
const char *
Tcl_FSGetNativePath(pathPtr)
Tcl_Obj*
Tcl_FSFileSystemInfo(pathPtr)
Tcl_StatBuf*
Tcl_AllocStatBuf()ARGUMENTS
Tcl_Filesystem *fsPtr (in) Points to a struc‐
ture containing the
addresses of proce‐
dures that can be
called to perform
the various filesys‐
tem operations.
Tcl_Obj *pathPtr (in) The path represented
by this object is
used for the opera‐
tion in question.
If the object does
not already have an
internal path repre‐
sentation, it will
be converted to have
one.
Tcl_Obj *srcPathPtr (in) As for pathPtr, but
used for the source
file for a copy or
rename operation.
Tcl_Obj *destPathPtr (in) As for pathPtr, but
used for the desti‐
nation filename for
a copy or rename
operation.
const char *encodingName (in) The encoding of the
data stored in the
file identified by
pathPtr and to be
evaluated.
const char *pattern (in) Only files or direc‐
tories matching this
pattern will be
returned.
Tcl_GlobTypeData *types (in) Only files or direc‐
tories matching the
type descriptions
contained in this
structure will be
returned. This
parameter may be
NULL.
Tcl_Interp *interp (in) Interpreter to use
either for results,
evaluation, or
reporting error mes‐
sages.
ClientData clientData (in) The native descrip‐
tion of the path
object to create.
Tcl_Obj *firstPtr (in) The first of two
path objects to com‐
pare. The object
may be converted to
path type.
Tcl_Obj *secondPtr (in) The second of two
path objects to com‐
pare. The object
may be converted to
path type.
Tcl_Obj *listObj (in) The list of path
elements to operate
on with a join oper‐
ation.
int elements (in) If non-negative, the
number of elements
in the listObj which
should be joined
together. If nega‐
tive, then all ele‐
ments are joined.
Tcl_Obj **errorPtr (out) In the case of an
error, filled with
an object containing
the name of the file
which caused an
error in the various
copy/rename opera‐
tions.
Tcl_Obj **objPtrRef (out) Filled with an
object containing
the result of the
operation.
Tcl_Obj *resultPtr (out) Pre-allocated object
in which to store
(using Tcl_ListOb‐
jAppendElement) the
list of files or
directories which
are successfully
matched.
int mode (in) Mask consisting of
one or more of R_OK,
W_OK, X_OK and F_OK.
R_OK, W_OK and X_OK
request checking
whether the file
exists and has
read, write and
execute permis‐
sions, respectively.
F_OK just requests
checking for the
existence of the
file.
Tcl_StatBuf *statPtr (out) The structure that
contains the result
of a stat or lstat
operation.
const char *sym1 (in) Name of a procedure
to look up in the
file's symbol table
const char *sym2 (in) Name of a procedure
to look up in the
file's symbol table
Tcl_PackageInitProc **proc1Ptr (out) Filled with the init
function for this
code.
Tcl_PackageInitProc **proc2Ptr (out) Filled with the
safe-init function
for this code.
ClientData *clientDataPtr (out) Filled with the
clientData value to
pass to this code's
unload function when
it is called.
Tcl_LoadHandle *handlePtr (out) Filled with an
abstract token rep‐
resenting the loaded
file.
Tcl_FSUnloadFileProc **unloadProcPtr (out) Filled with the
function to use to
unload this piece of
code.
utimbuf *tval (in) The access and modi‐
fication times in
this structure are
read and used to set
those values for a
given file.
const char *modeString (in) Specifies how the
file is to be
accessed. May have
any of the values
allowed for the mode
argument to the Tcl
open command.
int permissions (in) POSIX-style permis‐
sion flags such as
0644. If a new file
is created, these
permissions will be
set on the created
file.
int *lenPtr (out) If non-NULL, filled
with the number of
elements in the
split path.
Tcl_Obj *basePtr (in) The base path on to
which to join the
given elements. May
be NULL.
int objc (in) The number of ele‐
ments in objv.
Tcl_Obj *const objv[] (in) The elements to join
to the given base
path.
Tcl_Obj *linkNamePtr (in) The name of the link
to be created or
read.
Tcl_Obj *toPtr (in) What the link called
linkNamePtr should
be linked to, or
NULL if the symbolic
link specified by
linkNamePtr is to be
read.
int linkAction (in) OR-ed combination of
flags indicating
what kind of link
should be created
(will be ignored if
toPtr is NULL).
Valid bits to set
are TCL_CREATE_SYM‐
BOLIC_LINK and
TCL_CRE‐
ATE_HARD_LINK. When
both flags are set
and the underlying
filesystem can do
either, symbolic
links are preferred.
_________________________________________________________________DESCRIPTION
There are several reasons for calling the Tcl_FS API functions (e.g.
Tcl_FSAccess and Tcl_FSStat) rather than calling system level functions
like access and stat directly. First, they will work cross-platform,
so an extension which calls them should work unmodified on Unix and
Windows. Second, the Windows implementation of some of these functions
fixes some bugs in the system level calls. Third, these function calls
deal with any “Utf to platform-native” path conversions which may be
required (and may cache the results of such conversions for greater
efficiency on subsequent calls). Fourth, and perhaps most importantly,
all of these functions are “virtual filesystem aware”. Any virtual
filesystem (VFS for short) which has been registered (through
Tcl_FSRegister) may reroute file access to alternative media or access
methods. This means that all of these functions (and therefore the
corresponding file, glob, pwd, cd, open, etc. Tcl commands) may be
operate on “files” which are not native files in the native filesystem.
This also means that any Tcl extension which accesses the filesystem
(FS for short) through this API is automatically “virtual filesystem
aware”. Of course, if an extension accesses the native filesystem
directly (through platform-specific APIs, for example), then Tcl cannot
intercept such calls.
If appropriate VFSes have been registered, the “files” may, to give two
examples, be remote (e.g. situated on a remote ftp server) or archived
(e.g. lying inside a .zip archive). Such registered filesystems pro‐
vide a lookup table of functions to implement all or some of the func‐
tionality listed here. Finally, the Tcl_FSStat and Tcl_FSLstat calls
abstract away from what the “struct stat” buffer is actually declared
to be, allowing the same code to be used both on systems with and sys‐
tems without support for files larger than 2GB in size.
The Tcl_FS API is objectified and may cache internal representations
and other path-related strings (e.g. the current working directory).
One side-effect of this is that one must not pass in objects with a
reference count of zero to any of these functions. If such calls were
handled, they might result in memory leaks (under some circumstances,
the filesystem code may wish to retain a reference to the passed in
object, and so one must not assume that after any of these calls
return, the object still has a reference count of zero - it may have
been incremented) or in a direct segmentation fault (or other memory
access error) due to the object being freed part way through the com‐
plex object manipulation required to ensure that the path is fully nor‐
malized and absolute for filesystem determination. The practical les‐
son to learn from this is that
Tcl_Obj *path = Tcl_NewStringObj(...);
Tcl_FSWhatever(path);
Tcl_DecrRefCount(path);
is wrong, and may cause memory errors. The path must have its reference
count incremented before passing it in, or decrementing it. For this
reason, objects with a reference count of zero are considered not to be
valid filesystem paths and calling any Tcl_FS API function with such an
object will result in no action being taken.
FS API FUNCTIONS
Tcl_FSCopyFile attempts to copy the file given by srcPathPtr to the
path name given by destPathPtr. If the two paths given lie in the same
filesystem (according to Tcl_FSGetFileSystemForPath) then that filesys‐
tem's “copy file” function is called (if it is non-NULL). Otherwise
the function returns -1 and sets the errno global C variable to the
“EXDEV” POSIX error code (which signifies a “cross-domain link”).
Tcl_FSCopyDirectory attempts to copy the directory given by srcPathPtr
to the path name given by destPathPtr. If the two paths given lie in
the same filesystem (according to Tcl_FSGetFileSystemForPath) then that
filesystem's “copy file” function is called (if it is non-NULL). Oth‐
erwise the function returns -1 and sets the errno global C variable to
the “EXDEV” POSIX error code (which signifies a “cross-domain link”).
Tcl_FSCreateDirectory attempts to create the directory given by pathPtr
by calling the owning filesystem's “create directory” function.
Tcl_FSDeleteFile attempts to delete the file given by pathPtr by call‐
ing the owning filesystem's “delete file” function.
Tcl_FSRemoveDirectory attempts to remove the directory given by pathPtr
by calling the owning filesystem's “remove directory” function.
Tcl_FSRenameFile attempts to rename the file or directory given by src‐
PathPtr to the path name given by destPathPtr. If the two paths given
lie in the same filesystem (according to Tcl_FSGetFileSystemForPath)
then that filesystem's “rename file” function is called (if it is non-
NULL). Otherwise the function returns -1 and sets the errno global C
variable to the “EXDEV” POSIX error code (which signifies a “cross-
domain link”).
Tcl_FSListVolumes calls each filesystem which has a non-NULL “list vol‐
umes” function and asks them to return their list of root volumes. It
accumulates the return values in a list which is returned to the caller
(with a reference count of 0).
Tcl_FSEvalFileEx reads the file given by pathPtr using the encoding │
identified by encodingName and evaluates its contents as a Tcl script. │
It returns the same information as Tcl_EvalObjEx. If encodingName is │
NULL, the system encoding is used for reading the file contents. If │
the file could not be read then a Tcl error is returned to describe why │
the file could not be read. The eofchar for files is “\32” (^Z) for │
all platforms. If you require a “^Z” in code for string comparison, │
you can use “\032” or “\u001a”, which will be safely substituted by the │
Tcl interpreter into “^Z”. Tcl_FSEvalFile is a simpler version of │
Tcl_FSEvalFileEx that always uses the system encoding when reading the │
file.
Tcl_FSLoadFile dynamically loads a binary code file into memory and
returns the addresses of two procedures within that file, if they are
defined. The appropriate function for the filesystem to which pathPtr
belongs will be called. If that filesystem does not implement this
function (most virtual filesystems will not, because of OS limitations
in dynamically loading binary code), Tcl will attempt to copy the file
to a temporary directory and load that temporary file.
Returns a standard Tcl completion code. If an error occurs, an error
message is left in the interp's result.
Tcl_FSMatchInDirectory is used by the globbing code to search a direc‐
tory for all files which match a given pattern. The appropriate func‐
tion for the filesystem to which pathPtr belongs will be called.
The return value is a standard Tcl result indicating whether an error
occurred in globbing. Error messages are placed in interp (unless
interp is NULL, which is allowed), but good results are placed in the
resultPtr given.
Note that the glob code implements recursive patterns internally, so
this function will only ever be passed simple patterns, which can be
matched using the logic of string match. To handle recursion, Tcl will
call this function frequently asking only for directories to be
returned. A special case of being called with a NULL pattern indicates
that the path needs to be checked only for the correct type.
Tcl_FSLink replaces the library version of readlink, and extends it to
support the creation of links. The appropriate function for the
filesystem to which linkNamePtr belongs will be called.
If the toPtr is NULL, a “read link” action is performed. The result is
a Tcl_Obj specifying the contents of the symbolic link given by
linkNamePtr, or NULL if the link could not be read. The result is
owned by the caller, which should call Tcl_DecrRefCount when the result
is no longer needed. If the toPtr is not NULL, Tcl should create a
link of one of the types passed in in the linkAction flag. This flag
is an ORed combination of TCL_CREATE_SYMBOLIC_LINK and TCL_CRE‐
ATE_HARD_LINK. Where a choice exists (i.e. more than one flag is
passed in), the Tcl convention is to prefer symbolic links. When a
link is successfully created, the return value should be toPtr (which
is therefore already owned by the caller). If unsuccessful, NULL is
returned.
Tcl_FSLstat fills the stat structure statPtr with information about the
specified file. You do not need any access rights to the file to get
this information but you need search rights to all directories named in
the path leading to the file. The stat structure includes info regard‐
ing device, inode (always 0 on Windows), privilege mode, nlink (always
1 on Windows), user id (always 0 on Windows), group id (always 0 on
Windows), rdev (same as device on Windows), size, last access time,
last modification time, and last metadata change time.
If path exists, Tcl_FSLstat returns 0 and the stat structure is filled
with data. Otherwise, -1 is returned, and no stat info is given.
Tcl_FSUtime replaces the library version of utime.
This returns 0 on success and -1 on error (as per the utime documenta‐
tion). If successful, the function will update the “atime” and “mtime”
values of the file given.
Tcl_FSFileAttrsGet implements read access for the hookable file
attributes subcommand. The appropriate function for the filesystem to
which pathPtr belongs will be called.
If the result is TCL_OK, then an object was placed in objPtrRef, which
will only be temporarily valid (unless Tcl_IncrRefCount is called).
Tcl_FSFileAttrsSet implements write access for the hookable file
attributes subcommand. The appropriate function for the filesystem to
which pathPtr belongs will be called.
Tcl_FSFileAttrStrings implements part of the hookable file attributes
subcommand. The appropriate function for the filesystem to which path‐
Ptr belongs will be called.
The called procedure may either return an array of strings, or may
instead return NULL and place a Tcl list into the given objPtrRef. Tcl
will take that list and first increment its reference count before
using it. On completion of that use, Tcl will decrement its reference
count. Hence if the list should be disposed of by Tcl when done, it
should have a reference count of zero, and if the list should not be
disposed of, the filesystem should ensure it retains a reference count
to the object.
Tcl_FSAccess checks whether the process would be allowed to read, write
or test for existence of the file (or other filesystem object) whose
name is pathname. If pathname is a symbolic link on Unix, then per‐
missions of the file referred by this symbolic link are tested.
On success (all requested permissions granted), zero is returned. On
error (at least one bit in mode asked for a permission that is denied,
or some other error occurred), -1 is returned.
Tcl_FSStat fills the stat structure statPtr with information about the
specified file. You do not need any access rights to the file to get
this information but you need search rights to all directories named in
the path leading to the file. The stat structure includes info regard‐
ing device, inode (always 0 on Windows), privilege mode, nlink (always
1 on Windows), user id (always 0 on Windows), group id (always 0 on
Windows), rdev (same as device on Windows), size, last access time,
last modification time, and last metadata change time.
If path exists, Tcl_FSStat returns 0 and the stat structure is filled
with data. Otherwise, -1 is returned, and no stat info is given.
Tcl_FSOpenFileChannel opens a file specified by pathPtr and returns a
channel handle that can be used to perform input and output on the
file. This API is modeled after the fopen procedure of the Unix stan‐
dard I/O library. The syntax and meaning of all arguments is similar
to those given in the Tcl open command when opening a file. If an
error occurs while opening the channel, Tcl_FSOpenFileChannel returns
NULL and records a POSIX error code that can be retrieved with
Tcl_GetErrno. In addition, if interp is non-NULL, Tcl_FSOpenFileChan‐
nel leaves an error message in interp's result after any error.
The newly created channel is not registered in the supplied inter‐
preter; to register it, use Tcl_RegisterChannel. If one of the stan‐
dard channels, stdin, stdout or stderr was previously closed, the act
of creating the new channel also assigns it as a replacement for the
standard channel.
Tcl_FSGetCwd replaces the library version of getcwd.
It returns the Tcl library's current working directory. This may be
different to the native platform's working directory, which happens
when the current working directory is not in the native filesystem.
The result is a pointer to a Tcl_Obj specifying the current directory,
or NULL if the current directory could not be determined. If NULL is
returned, an error message is left in the interp's result.
The result already has its reference count incremented for the caller.
When it is no longer needed, that reference count should be decre‐
mented. This is needed for thread-safety purposes, to allow multiple
threads to access this and related functions, while ensuring the
results are always valid.
Tcl_FSChdir replaces the library version of chdir. The path is normal‐
ized and then passed to the filesystem which claims it. If that
filesystem does not implement this function, Tcl will fallback to a
combination of stat and access to check whether the directory exists
and has appropriate permissions.
For results, see chdir documentation. If successful, we keep a record
of the successful path in cwdPathPtr for subsequent calls to
Tcl_FSGetCwd.
Tcl_FSPathSeparator returns the separator character to be used for most
specific element of the path specified by pathPtr (i.e. the last part
of the path).
The separator is returned as a Tcl_Obj containing a string of length 1.
If the path is invalid, NULL is returned.
Tcl_FSJoinPath takes the given Tcl_Obj, which must be a valid list
(which is allowed to have a reference count of zero), and returns the
path object given by considering the first elements elements as valid
path segments (each path segment may be a complete path, a partial path
or just a single possible directory or file name). If any path segment
is actually an absolute path, then all prior path segments are dis‐
carded. If elements is less than 0, we use the entire list.
It is possible that the returned object is actually an element of the
given list, so the caller should be careful to increment the reference
count of the result before freeing the list.
The returned object, typically with a reference count of zero (but it
could be shared under some conditions), contains the joined path. The
caller must add a reference count to the object before using it. In
particular, the returned object could be an element of the given list,
so freeing the list might free the object prematurely if no reference
count has been taken. If the number of elements is zero, then the
returned object will be an empty-string Tcl_Obj.
Tcl_FSSplitPath takes the given Tcl_Obj, which should be a valid path,
and returns a Tcl list object containing each segment of that path as
an element. It returns a list object with a reference count of zero.
If the passed in lenPtr is non-NULL, the variable it points to will be
updated to contain the number of elements in the returned list.
Tcl_FSEqualPaths tests whether the two paths given represent the same
filesystem object
It returns 1 if the paths are equal, and 0 if they are different. If
either path is NULL, 0 is always returned.
Tcl_FSGetNormalizedPath this important function attempts to extract
from the given Tcl_Obj a unique normalized path representation, whose
string value can be used as a unique identifier for the file.
It returns the normalized path object, owned by Tcl, or NULL if the
path was invalid or could otherwise not be successfully converted.
Extraction of absolute, normalized paths is very efficient (because the
filesystem operates on these representations internally), although the
result when the filesystem contains numerous symbolic links may not be
the most user-friendly version of a path. The return value is owned by
Tcl and has a lifetime equivalent to that of the pathPtr passed in
(unless that is a relative path, in which case the normalized path
object may be freed any time the cwd changes) - the caller can of
course increment the refCount if it wishes to maintain a copy for
longer.
Tcl_FSJoinToPath takes the given object, which should usually be a
valid path or NULL, and joins onto it the array of paths segments
given.
Returns object, typically with refCount of zero (but it could be shared
under some conditions), containing the joined path. The caller must
add a refCount to the object before using it. If any of the objects
passed into this function (pathPtr or path elements) have a refCount of
zero, they will be freed when this function returns.
Tcl_FSConvertToPathType tries to convert the given Tcl_Obj to a valid
Tcl path type, taking account of the fact that the cwd may have changed
even if this object is already supposedly of the correct type. The
filename may begin with “~” (to indicate current user's home directory)
or “~<user>” (to indicate any user's home directory).
If the conversion succeeds (i.e. the object is a valid path in one of
the current filesystems), then TCL_OK is returned. Otherwise TCL_ERROR
is returned, and an error message may be left in the interpreter.
Tcl_FSGetInternalRep extracts the internal representation of a given
path object, in the given filesystem. If the path object belongs to a
different filesystem, we return NULL. If the internal representation is
currently NULL, we attempt to generate it, by calling the filesystem's
Tcl_FSCreateInternalRepProc.
Returns NULL or a valid internal path representation. This internal
representation is cached, so that repeated calls to this function will
not require additional conversions.
Tcl_FSGetTranslatedPath attempts to extract the translated path from
the given Tcl_Obj.
If the translation succeeds (i.e. the object is a valid path), then it
is returned. Otherwise NULL will be returned, and an error message may
be left in the interpreter. A “translated” path is one which contains
no “~” or “~user” sequences (these have been expanded to their current
representation in the filesystem). The object returned is owned by the
caller, which must store it or call Tcl_DecrRefCount to ensure memory
is freed. This function is of little practical use, and Tcl_FSGetNor‐
malizedPath or Tcl_GetNativePath are usually better functions to use
for most purposes.
Tcl_FSGetTranslatedStringPath does the same as Tcl_FSGetTranslatedPath,
but returns a character string or NULL. The string returned is dynami‐
cally allocated and owned by the caller, which must store it or call
ckfree to ensure it is freed. Again, Tcl_FSGetNormalizedPath or
Tcl_GetNativePath are usually better functions to use for most pur‐
poses.
Tcl_FSNewNativePath performs something like the reverse of the usual
obj->path->nativerep conversions. If some code retrieves a path in
native form (from, e.g. readlink or a native dialog), and that path is
to be used at the Tcl level, then calling this function is an efficient
way of creating the appropriate path object type.
The resulting object is a pure “path” object, which will only receive a
UTF-8 string representation if that is required by some Tcl code.
Tcl_FSGetNativePath is for use by the Win/Unix native filesystems, so
that they can easily retrieve the native (char* or TCHAR*) representa‐
tion of a path. This function is a convenience wrapper around
Tcl_FSGetInternalRep, and assumes the native representation is string-
based. It may be desirable in the future to have non-string-based
native representations (for example, on MacOSX, a representation using
a fileSpec of FSRef structure would probably be more efficient). On
Windows a full Unicode representation would allow for paths of unlim‐
ited length. Currently the representation is simply a character string
which may contain either the relative path or a complete, absolute nor‐
malized path in the native encoding (complex conditions dictate which
of these will be provided, so neither can be relied upon, unless the
path is known to be absolute). If you need a native path which must be
absolute, then you should ask for the native version of a normalized
path. If for some reason a non-absolute, non-normalized version of the
path is needed, that must be constructed separately (e.g. using
Tcl_FSGetTranslatedPath).
The native representation is cached so that repeated calls to this
function will not require additional conversions. The return value is
owned by Tcl and has a lifetime equivalent to that of the pathPtr
passed in (unless that is a relative path, in which case the native
representation may be freed any time the cwd changes).
Tcl_FSFileSystemInfo returns a list of two elements. The first element
is the name of the filesystem (e.g. “native”, “vfs”, “zip”, or
“prowrap”, perhaps), and the second is the particular type of the given
path within that filesystem (which is filesystem dependent). The sec‐
ond element may be empty if the filesystem does not provide a further
categorization of files.
A valid list object is returned, unless the path object is not recog‐
nized, when NULL will be returned.
Tcl_FSGetFileSystemForPath returns the a pointer to the Tcl_Filesystem
which accepts this path as valid.
If no filesystem will accept the path, NULL is returned.
Tcl_FSGetPathType determines whether the given path is relative to the
current directory, relative to the current volume, or absolute.
It returns one of TCL_PATH_ABSOLUTE, TCL_PATH_RELATIVE, or
TCL_PATH_VOLUME_RELATIVE
Tcl_AllocStatBuf allocates a Tcl_StatBuf on the system heap (which may
be deallocated by being passed to ckfree.) This allows extensions to
invoke Tcl_FSStat and Tcl_FSLStat without being dependent on the size
of the buffer. That in turn depends on the flags used to build Tcl.
THE VIRTUAL FILESYSTEM API
A filesystem provides a Tcl_Filesystem structure that contains pointers
to functions that implement the various operations on a filesystem;
these operations are invoked as needed by the generic layer, which gen‐
erally occurs through the functions listed above.
The Tcl_Filesystem structures are manipulated using the following meth‐
ods.
Tcl_FSRegister takes a pointer to a filesystem structure and an
optional piece of data to associated with that filesystem. On calling
this function, Tcl will attach the filesystem to the list of known
filesystems, and it will become fully functional immediately. Tcl does
not check if the same filesystem is registered multiple times (and in
general that is not a good thing to do). TCL_OK will be returned.
Tcl_FSUnregister removes the given filesystem structure from the list
of known filesystems, if it is known, and returns TCL_OK. If the
filesystem is not currently registered, TCL_ERROR is returned.
Tcl_FSData will return the ClientData associated with the given
filesystem, if that filesystem is registered. Otherwise it will return
NULL.
Tcl_FSMountsChanged is used to inform the Tcl's core that the set of
mount points for the given (already registered) filesystem have
changed, and that cached file representations may therefore no longer
be correct.
THE TCL_FILESYSTEM STRUCTURE
The Tcl_Filesystem structure contains the following fields:
typedef struct Tcl_Filesystem {
const char *typeName;
int structureLength;
Tcl_FSVersion version;
Tcl_FSPathInFilesystemProc *pathInFilesystemProc;
Tcl_FSDupInternalRepProc *dupInternalRepProc;
Tcl_FSFreeInternalRepProc *freeInternalRepProc;
Tcl_FSInternalToNormalizedProc *internalToNormalizedProc;
Tcl_FSCreateInternalRepProc *createInternalRepProc;
Tcl_FSNormalizePathProc *normalizePathProc;
Tcl_FSFilesystemPathTypeProc *filesystemPathTypeProc;
Tcl_FSFilesystemSeparatorProc *filesystemSeparatorProc;
Tcl_FSStatProc *statProc;
Tcl_FSAccessProc *accessProc;
Tcl_FSOpenFileChannelProc *openFileChannelProc;
Tcl_FSMatchInDirectoryProc *matchInDirectoryProc;
Tcl_FSUtimeProc *utimeProc;
Tcl_FSLinkProc *linkProc;
Tcl_FSListVolumesProc *listVolumesProc;
Tcl_FSFileAttrStringsProc *fileAttrStringsProc;
Tcl_FSFileAttrsGetProc *fileAttrsGetProc;
Tcl_FSFileAttrsSetProc *fileAttrsSetProc;
Tcl_FSCreateDirectoryProc *createDirectoryProc;
Tcl_FSRemoveDirectoryProc *removeDirectoryProc;
Tcl_FSDeleteFileProc *deleteFileProc;
Tcl_FSCopyFileProc *copyFileProc;
Tcl_FSRenameFileProc *renameFileProc;
Tcl_FSCopyDirectoryProc *copyDirectoryProc;
Tcl_FSLstatProc *lstatProc;
Tcl_FSLoadFileProc *loadFileProc;
Tcl_FSGetCwdProc *getCwdProc;
Tcl_FSChdirProc *chdirProc;
} Tcl_Filesystem;
Except for the first three fields in this structure which contain sim‐
ple data elements, all entries contain addresses of functions called by
the generic filesystem layer to perform the complete range of filesys‐
tem related actions.
The many functions in this structure are broken down into three cate‐
gories: infrastructure functions (almost all of which must be imple‐
mented), operational functions (which must be implemented if a complete
filesystem is provided), and efficiency functions (which need only be
implemented if they can be done so efficiently, or if they have side-
effects which are required by the filesystem; Tcl has less efficient
emulations it can fall back on). It is important to note that, in the
current version of Tcl, most of these fallbacks are only used to handle
commands initiated in Tcl, not in C. What this means is, that if a file
rename command is issued in Tcl, and the relevant filesystem(s) do not
implement their Tcl_FSRenameFileProc, Tcl's core will instead fallback
on a combination of other filesystem functions (it will use Tcl_FSCopy‐
FileProc followed by Tcl_FSDeleteFileProc, and if Tcl_FSCopyFileProc is
not implemented there is a further fallback). However, if a Tcl_FSRe‐
nameFileProc command is issued at the C level, no such fallbacks occur.
This is true except for the last four entries in the filesystem table
(lstat, load, getcwd and chdir) for which fallbacks do in fact occur at
the C level.
Any functions which take path names in Tcl_Obj form take those names in
UTF-8 form. The filesystem infrastructure API is designed to support
efficient, cached conversion of these UTF-8 paths to other native rep‐
resentations.
EXAMPLE FILESYSTEM DEFINITION
Here is the filesystem lookup table used by the “vfs” extension which
allows filesystem actions to be implemented in Tcl.
static Tcl_Filesystem vfsFilesystem = {
"tclvfs",
sizeof(Tcl_Filesystem),
TCL_FILESYSTEM_VERSION_1,
&VfsPathInFilesystem,
&VfsDupInternalRep,
&VfsFreeInternalRep,
/* No internal to normalized, since we don't create
* any pure 'internal' Tcl_Obj path representations */
NULL,
/* No create native rep function, since we don't use
* it and don't choose to support uses of
* Tcl_FSNewNativePath */
NULL,
/* Normalize path isn't needed - we assume paths only
* have one representation */
NULL,
&VfsFilesystemPathType,
&VfsFilesystemSeparator,
&VfsStat,
&VfsAccess,
&VfsOpenFileChannel,
&VfsMatchInDirectory,
&VfsUtime,
/* We choose not to support symbolic links inside our
* VFS's */
NULL,
&VfsListVolumes,
&VfsFileAttrStrings,
&VfsFileAttrsGet,
&VfsFileAttrsSet,
&VfsCreateDirectory,
&VfsRemoveDirectory,
&VfsDeleteFile,
/* No copy file; use the core fallback mechanism */
NULL,
/* No rename file; use the core fallback mechanism */
NULL,
/* No copy directory; use the core fallback mechanism */
NULL,
/* Core will use stat for lstat */
NULL,
/* No load; use the core fallback mechanism */
NULL,
/* We don't need a getcwd or chdir; the core's own
* internal value is suitable */
NULL,
NULL
};
FILESYSTEM INFRASTRUCTURE
These fields contain basic information about the filesystem structure
and addresses of functions which are used to associate a particular
filesystem with a file path, and deal with the internal handling of
path representations, for example copying and freeing such representa‐
tions.
TYPENAME
The typeName field contains a null-terminated string that identifies
the type of the filesystem implemented, e.g. “native”, “zip” or “vfs”.
STRUCTURE LENGTH
The structureLength field is generally implemented as
sizeof(Tcl_Filesystem), and is there to allow easier binary backwards
compatibility if the size of the structure changes in a future Tcl
release.
VERSION
The version field should be set to TCL_FILESYSTEM_VERSION_1.
PATHINFILESYSTEMPROC
The pathInFilesystemProc field contains the address of a function which
is called to determine whether a given path object belongs to this
filesystem or not. Tcl will only call the rest of the filesystem func‐
tions with a path for which this function has returned TCL_OK. If the
path does not belong, -1 should be returned (the behaviour of Tcl for
any other return value is not defined). If TCL_OK is returned, then
the optional clientDataPtr output parameter can be used to return an
internal (filesystem specific) representation of the path, which will
be cached inside the path object, and may be retrieved efficiently by
the other filesystem functions. Tcl will simultaneously cache the fact
that this path belongs to this filesystem. Such caches are invalidated
when filesystem structures are added or removed from Tcl's internal
list of known filesystems.
typedef int Tcl_FSPathInFilesystemProc(
Tcl_Obj *pathPtr,
ClientData *clientDataPtr);
DUPINTERNALREPPROC
This function makes a copy of a path's internal representation, and is
called when Tcl needs to duplicate a path object. If NULL, Tcl will
simply not copy the internal representation, which may then need to be
regenerated later.
typedef ClientData Tcl_FSDupInternalRepProc(
ClientData clientData);
FREEINTERNALREPPROC
Free the internal representation. This must be implemented if internal
representations need freeing (i.e. if some memory is allocated when an
internal representation is generated), but may otherwise be NULL.
typedef void Tcl_FSFreeInternalRepProc(
ClientData clientData);
INTERNALTONORMALIZEDPROC
Function to convert internal representation to a normalized path. Only
required if the filesystem creates pure path objects with no
string/path representation. The return value is a Tcl object whose
string representation is the normalized path.
typedef Tcl_Obj* Tcl_FSInternalToNormalizedProc(
ClientData clientData);
CREATEINTERNALREPPROC
Function to take a path object, and calculate an internal representa‐
tion for it, and store that native representation in the object. May
be NULL if paths have no internal representation, or if the
Tcl_FSPathInFilesystemProc for this filesystem always immediately cre‐
ates an internal representation for paths it accepts.
typedef ClientData Tcl_FSCreateInternalRepProc(
Tcl_Obj *pathPtr);
NORMALIZEPATHPROC
Function to normalize a path. Should be implemented for all filesys‐
tems which can have multiple string representations for the same path
object. In Tcl, every “path” must have a single unique “normalized”
string representation. Depending on the filesystem, there may be more
than one unnormalized string representation which refers to that path
(e.g. a relative path, a path with different character case if the
filesystem is case insensitive, a path contain a reference to a home
directory such as “~”, a path containing symbolic links, etc). If the
very last component in the path is a symbolic link, it should not be
converted into the object it points to (but its case or other aspects
should be made unique). All other path components should be converted
from symbolic links. This one exception is required to agree with
Tcl's semantics with file delete, file rename, file copy operating on
symbolic links. This function may be called with nextCheckpoint either
at the beginning of the path (i.e. zero), at the end of the path, or at
any intermediate file separator in the path. It will never point to
any other arbitrary position in the path. In the last of the three
valid cases, the implementation can assume that the path up to and
including the file separator is known and normalized.
typedef int Tcl_FSNormalizePathProc(
Tcl_Interp *interp,
Tcl_Obj *pathPtr,
int nextCheckpoint);
FILESYSTEM OPERATIONS
The fields in this section of the structure contain addresses of func‐
tions which are called to carry out the basic filesystem operations. A
filesystem which expects to be used with the complete standard Tcl com‐
mand set must implement all of these. If some of them are not imple‐
mented, then certain Tcl commands may fail when operating on paths
within that filesystem. However, in some instances this may be desir‐
able (for example, a read-only filesystem should not implement the last
four functions, and a filesystem which does not support symbolic links
need not implement the readlink function, etc. The Tcl core expects
filesystems to behave in this way).
FILESYSTEMPATHTYPEPROC
Function to determine the type of a path in this filesystem. May be
NULL, in which case no type information will be available to users of
the filesystem. The “type” is used only for informational purposes,
and should be returned as the string representation of the Tcl_Obj
which is returned. A typical return value might be “networked”, “zip”
or “ftp”. The Tcl_Obj result is owned by the filesystem and so Tcl
will increment the refCount of that object if it wishes to retain a
reference to it.
typedef Tcl_Obj* Tcl_FSFilesystemPathTypeProc(
Tcl_Obj *pathPtr);
FILESYSTEMSEPARATORPROC
Function to return the separator character(s) for this filesystem.
This need only be implemented if the filesystem wishes to use a differ‐
ent separator than the standard string “/”. Amongst other uses, it is
returned by the file separator command. The return value should be an
object with refCount of zero.
typedef Tcl_Obj* Tcl_FSFilesystemSeparatorProc(
Tcl_Obj *pathPtr);
STATPROC
Function to process a Tcl_FSStat call. Must be implemented for any
reasonable filesystem, since many Tcl level commands depend crucially
upon it (e.g. file atime, file isdirectory, file size, glob).
typedef int Tcl_FSStatProc(
Tcl_Obj *pathPtr,
Tcl_StatBuf *statPtr);
The Tcl_FSStatProc fills the stat structure statPtr with information
about the specified file. You do not need any access rights to the
file to get this information but you need search rights to all directo‐
ries named in the path leading to the file. The stat structure
includes info regarding device, inode (always 0 on Windows), privilege
mode, nlink (always 1 on Windows), user id (always 0 on Windows), group
id (always 0 on Windows), rdev (same as device on Windows), size, last
access time, last modification time, and last metadata change time.
If the file represented by pathPtr exists, the Tcl_FSStatProc returns 0
and the stat structure is filled with data. Otherwise, -1 is returned,
and no stat info is given.
ACCESSPROC
Function to process a Tcl_FSAccess call. Must be implemented for any
reasonable filesystem, since many Tcl level commands depend crucially
upon it (e.g. file exists, file readable).
typedef int Tcl_FSAccessProc(
Tcl_Obj *pathPtr,
int mode);
The Tcl_FSAccessProc checks whether the process would be allowed to
read, write or test for existence of the file (or other filesystem
object) whose name is in pathPtr. If the pathname refers to a symbolic
link, then the permissions of the file referred by this symbolic link
should be tested.
On success (all requested permissions granted), zero is returned. On
error (at least one bit in mode asked for a permission that is denied,
or some other error occurred), -1 is returned.
OPENFILECHANNELPROC
Function to process a Tcl_FSOpenFileChannel call. Must be implemented
for any reasonable filesystem, since any operations which require open
or accessing a file's contents will use it (e.g. open, encoding, and
many Tk commands).
typedef Tcl_Channel Tcl_FSOpenFileChannelProc(
Tcl_Interp *interp,
Tcl_Obj *pathPtr,
int mode,
int permissions);
The Tcl_FSOpenFileChannelProc opens a file specified by pathPtr and
returns a channel handle that can be used to perform input and output
on the file. This API is modeled after the fopen procedure of the Unix
standard I/O library. The syntax and meaning of all arguments is simi‐
lar to those given in the Tcl open command when opening a file, where
the mode argument is a combination of the POSIX flags O_RDONLY,
O_WRONLY, etc. If an error occurs while opening the channel, the
Tcl_FSOpenFileChannelProc returns NULL and records a POSIX error code
that can be retrieved with Tcl_GetErrno. In addition, if interp is
non-NULL, the Tcl_FSOpenFileChannelProc leaves an error message in
interp's result after any error.
The newly created channel must not registered in the supplied inter‐
preter; that task is up to the caller of Tcl_FSOpenFileChannel (if nec‐
essary). If one of the standard channels, stdin, stdout or stderr was
previously closed, the act of creating the new channel also assigns it
as a replacement for the standard channel.
MATCHINDIRECTORYPROC
Function to process a Tcl_FSMatchInDirectory call. If not implemented,
then glob and recursive copy functionality will be lacking in the
filesystem (and this may impact commands like encoding names which use
glob functionality internally).
typedef int Tcl_FSMatchInDirectoryProc(
Tcl_Interp* interp,
Tcl_Obj *resultPtr,
Tcl_Obj *pathPtr,
const char *pattern,
Tcl_GlobTypeData *types);
The function should return all files or directories (or other filesys‐
tem objects) which match the given pattern and accord with the types
specification given. There are two ways in which this function may be
called. If pattern is NULL, then pathPtr is a full path specification
of a single file or directory which should be checked for existence and
correct type. Otherwise, pathPtr is a directory, the contents of which
the function should search for files or directories which have the cor‐
rect type. In either case, pathPtr can be assumed to be both non-NULL
and non-empty. It is not currently documented whether pathPtr will
have a file separator at its end of not, so code should be flexible to
both possibilities.
The return value is a standard Tcl result indicating whether an error
occurred in the matching process. Error messages are placed in interp,
unless interp in NULL in which case no error message need be generated;
on a TCL_OK result, results should be added to the resultPtr object
given (which can be assumed to be a valid unshared Tcl list). The
matches added to resultPtr should include any path prefix given in
pathPtr (this usually means they will be absolute path specifications).
Note that if no matches are found, that simply leads to an empty
result; errors are only signaled for actual file or filesystem problems
which may occur during the matching process.
The Tcl_GlobTypeData structure passed in the types parameter contains
the following fields:
typedef struct Tcl_GlobTypeData {
/* Corresponds to bcdpfls as in 'find -t' */
int type;
/* Corresponds to file permissions */
int perm;
/* Acceptable mac type */
Tcl_Obj *macType;
/* Acceptable mac creator */
Tcl_Obj *macCreator;
} Tcl_GlobTypeData;
There are two specific cases which it is important to handle correctly,
both when types is non-NULL. The two cases are when types->types &
TCL_GLOB_TYPE_DIR or types->types & TCL_GLOB_TYPE_MOUNT are true (and
in particular when the other flags are false). In the first of these
cases, the function must list the contained directories. Tcl uses this
to implement recursive globbing, so it is critical that filesystems
implement directory matching correctly. In the second of these cases,
with TCL_GLOB_TYPE_MOUNT, the filesystem must list the mount points
which lie within the given pathPtr (and in this case, pathPtr need not
lie within the same filesystem - different to all other cases in which
this function is called). Support for this is critical if Tcl is to
have seamless transitions between from one filesystem to another.
UTIMEPROC
Function to process a Tcl_FSUtime call. Required to allow setting (not
reading) of times with file mtime, file atime and the open-r/open-
w/fcopy implementation of file copy.
typedef int Tcl_FSUtimeProc(
Tcl_Obj *pathPtr,
struct utimbuf *tval);
The access and modification times of the file specified by pathPtr
should be changed to the values given in the tval structure.
The return value should be 0 on success and -1 on an error, as with the
system utime.
LINKPROC
Function to process a Tcl_FSLink call. Should be implemented only if
the filesystem supports links, and may otherwise be NULL.
typedef Tcl_Obj* Tcl_FSLinkProc(
Tcl_Obj *linkNamePtr,
Tcl_Obj *toPtr,
int linkAction);
If toPtr is NULL, the function is being asked to read the contents of a
link. The result is a Tcl_Obj specifying the contents of the link
given by linkNamePtr, or NULL if the link could not be read. The
result is owned by the caller (and should therefore have its ref count
incremented before being returned). Any callers should call Tcl_Decr‐
RefCount on this result when it is no longer needed. If toPtr is not
NULL, the function should attempt to create a link. The result in this
case should be toPtr if the link was successful and NULL otherwise. In
this case the result is not owned by the caller (i.e. no ref count
manipulation on either end is needed). See the documentation for
Tcl_FSLink for the correct interpretation of the linkAction flags.
LISTVOLUMESPROC
Function to list any filesystem volumes added by this filesystem.
Should be implemented only if the filesystem adds volumes at the head
of the filesystem, so that they can be returned by file volumes.
typedef Tcl_Obj* Tcl_FSListVolumesProc(void);
The result should be a list of volumes added by this filesystem, or
NULL (or an empty list) if no volumes are provided. The result object
is considered to be owned by the filesystem (not by Tcl's core), but
should be given a refCount for Tcl. Tcl will use the contents of the
list and then decrement that refCount. This allows filesystems to
choose whether they actually want to retain a “master list” of volumes
or not (if not, they generate the list on the fly and pass it to Tcl
with a refCount of 1 and then forget about the list, if yes, then they
simply increment the refCount of their master list and pass it to Tcl
which will copy the contents and then decrement the count back to where
it was).
Therefore, Tcl considers return values from this proc to be read-only.
FILEATTRSTRINGSPROC
Function to list all attribute strings which are valid for this
filesystem. If not implemented the filesystem will not support the
file attributes command. This allows arbitrary additional information
to be attached to files in the filesystem. If it is not implemented,
there is no need to implement the get and set methods.
typedef const char** Tcl_FSFileAttrStringsProc(
Tcl_Obj *pathPtr,
Tcl_Obj** objPtrRef);
The called function may either return an array of strings, or may
instead return NULL and place a Tcl list into the given objPtrRef. Tcl
will take that list and first increment its reference count before
using it. On completion of that use, Tcl will decrement its reference
count. Hence if the list should be disposed of by Tcl when done, it
should have a reference count of zero, and if the list should not be
disposed of, the filesystem should ensure it returns an object with a
reference count of at least one.
FILEATTRSGETPROC
Function to process a Tcl_FSFileAttrsGet call, used by file attributes.
typedef int Tcl_FSFileAttrsGetProc(
Tcl_Interp *interp,
int index,
Tcl_Obj *pathPtr,
Tcl_Obj **objPtrRef);
Returns a standard Tcl return code. The attribute value retrieved,
which corresponds to the index'th element in the list returned by the
Tcl_FSFileAttrStringsProc, is a Tcl_Obj placed in objPtrRef (if TCL_OK
was returned) and is likely to have a reference count of zero. Either
way we must either store it somewhere (e.g. the Tcl result), or
Incr/Decr its reference count to ensure it is properly freed.
FILEATTRSSETPROC
Function to process a Tcl_FSFileAttrsSet call, used by file attributes.
If the filesystem is read-only, there is no need to implement this.
typedef int Tcl_FSFileAttrsSetProc(
Tcl_Interp *interp,
int index,
Tcl_Obj *pathPtr,
Tcl_Obj *objPtr);
The attribute value of the index'th element in the list returned by the
Tcl_FSFileAttrStringsProc should be set to the objPtr given.
CREATEDIRECTORYPROC
Function to process a Tcl_FSCreateDirectory call. Should be imple‐
mented unless the FS is read-only.
typedef int Tcl_FSCreateDirectoryProc(
Tcl_Obj *pathPtr);
The return value is a standard Tcl result indicating whether an error
occurred in the process. If successful, a new directory should have
been added to the filesystem in the location specified by pathPtr.
REMOVEDIRECTORYPROC
Function to process a Tcl_FSRemoveDirectory call. Should be imple‐
mented unless the FS is read-only.
typedef int Tcl_FSRemoveDirectoryProc(
Tcl_Obj *pathPtr,
int recursive,
Tcl_Obj **errorPtr);
The return value is a standard Tcl result indicating whether an error
occurred in the process. If successful, the directory specified by
pathPtr should have been removed from the filesystem. If the recursive
flag is given, then a non-empty directory should be deleted without
error. If this flag is not given, then and the directory is non-empty
a POSIX “EEXIST” error should be signaled. If an error does occur, the
name of the file or directory which caused the error should be placed
in errorPtr.
DELETEFILEPROC
Function to process a Tcl_FSDeleteFile call. Should be implemented
unless the FS is read-only.
typedef int Tcl_FSDeleteFileProc(
Tcl_Obj *pathPtr);
The return value is a standard Tcl result indicating whether an error
occurred in the process. If successful, the file specified by pathPtr
should have been removed from the filesystem. Note that, if the
filesystem supports symbolic links, Tcl will always call this function
and not Tcl_FSRemoveDirectoryProc when needed to delete them (even if
they are symbolic links to directories).
FILESYSTEM EFFICIENCY
These functions need not be implemented for a particular filesystem
because the core has a fallback implementation available. See each
individual description for the consequences of leaving the field NULL.
LSTATPROC
Function to process a Tcl_FSLstat call. If not implemented, Tcl will
attempt to use the statProc defined above instead. Therefore it need
only be implemented if a filesystem can differentiate between stat and
lstat calls.
typedef int Tcl_FSLstatProc(
Tcl_Obj *pathPtr,
Tcl_StatBuf *statPtr);
The behavior of this function is very similar to that of the
Tcl_FSStatProc defined above, except that if it is applied to a sym‐
bolic link, it returns information about the link, not about the target
file.
COPYFILEPROC
Function to process a Tcl_FSCopyFile call. If not implemented Tcl will
fall back on open-r, open-w and fcopy as a copying mechanism. There‐
fore it need only be implemented if the filesystem can perform that
action more efficiently.
typedef int Tcl_FSCopyFileProc(
Tcl_Obj *srcPathPtr,
Tcl_Obj *destPathPtr);
The return value is a standard Tcl result indicating whether an error
occurred in the copying process. Note that, destPathPtr is the name of
the file which should become the copy of srcPathPtr. It is never the
name of a directory into which srcPathPtr could be copied (i.e. the
function is much simpler than the Tcl level file copy subcommand).
Note that, if the filesystem supports symbolic links, Tcl will always
call this function and not copyDirectoryProc when needed to copy them
(even if they are symbolic links to directories). Finally, if the
filesystem determines it cannot support the file copy action, calling
Tcl_SetErrno(EXDEV) and returning a non-TCL_OK result will tell Tcl to
use its standard fallback mechanisms.
RENAMEFILEPROC
Function to process a Tcl_FSRenameFile call. If not implemented, Tcl
will fall back on a copy and delete mechanism. Therefore it need only
be implemented if the filesystem can perform that action more effi‐
ciently.
typedef int Tcl_FSRenameFileProc(
Tcl_Obj *srcPathPtr,
Tcl_Obj *destPathPtr);
The return value is a standard Tcl result indicating whether an error
occurred in the renaming process. If the filesystem determines it can‐
not support the file rename action, calling Tcl_SetErrno(EXDEV) and
returning a non-TCL_OK result will tell Tcl to use its standard fall‐
back mechanisms.
COPYDIRECTORYPROC
Function to process a Tcl_FSCopyDirectory call. If not implemented,
Tcl will fall back on a recursive file mkdir, file copy mechanism.
Therefore it need only be implemented if the filesystem can perform
that action more efficiently.
typedef int Tcl_FSCopyDirectoryProc(
Tcl_Obj *srcPathPtr,
Tcl_Obj *destPathPtr,
Tcl_Obj **errorPtr);
The return value is a standard Tcl result indicating whether an error
occurred in the copying process. If an error does occur, the name of
the file or directory which caused the error should be placed in
errorPtr. Note that, destPathPtr is the name of the directory-name
which should become the mirror-image of srcPathPtr. It is not the name
of a directory into which srcPathPtr should be copied (i.e. the func‐
tion is much simpler than the Tcl level file copy subcommand).
Finally, if the filesystem determines it cannot support the directory
copy action, calling Tcl_SetErrno(EXDEV) and returning a non-TCL_OK
result will tell Tcl to use its standard fallback mechanisms.
LOADFILEPROC
Function to process a Tcl_FSLoadFile call. If not implemented, Tcl
will fall back on a copy to native-temp followed by a Tcl_FSLoadFile on
that temporary copy. Therefore it need only be implemented if the
filesystem can load code directly, or it can be implemented simply to
return TCL_ERROR to disable load functionality in this filesystem
entirely.
typedef int Tcl_FSLoadFileProc(
Tcl_Interp *interp,
Tcl_Obj *pathPtr,
Tcl_LoadHandle *handlePtr,
Tcl_FSUnloadFileProc *unloadProcPtr);
Returns a standard Tcl completion code. If an error occurs, an error
message is left in the interp's result. The function dynamically loads
a binary code file into memory. On a successful load, the handlePtr
should be filled with a token for the dynamically loaded file, and the
unloadProcPtr should be filled in with the address of a procedure. The
unload procedure will be called with the given Tcl_LoadHandle as its
only parameter when Tcl needs to unload the file. For example, for the
native filesystem, the Tcl_LoadHandle returned is currently a token
which can be used in the private TclpFindSymbol to access functions in
the new code. Each filesystem is free to define the Tcl_LoadHandle as
it requires. Finally, if the filesystem determines it cannot support
the file load action, calling Tcl_SetErrno(EXDEV) and returning a non-
TCL_OK result will tell Tcl to use its standard fallback mechanisms.
UNLOADFILEPROC
Function to unload a previously successfully loaded file. If load was
implemented, then this should also be implemented, if there is any
cleanup action required.
typedef void Tcl_FSUnloadFileProc(
Tcl_LoadHandle loadHandle);
GETCWDPROC
Function to process a Tcl_FSGetCwd call. Most filesystems need not
implement this. It will usually only be called once, if getcwd is
called before chdir. May be NULL.
typedef Tcl_Obj* Tcl_FSGetCwdProc(
Tcl_Interp *interp);
If the filesystem supports a native notion of a current working direc‐
tory (which might perhaps change independent of Tcl), this function
should return that cwd as the result, or NULL if the current directory
could not be determined (e.g. the user does not have appropriate per‐
missions on the cwd directory). If NULL is returned, an error message
is left in the interp's result.
CHDIRPROC
Function to process a Tcl_FSChdir call. If filesystems do not imple‐
ment this, it will be emulated by a series of directory access checks.
Otherwise, virtual filesystems which do implement it need only respond
with a positive return result if the pathPtr is a valid, accessible
directory in their filesystem. They need not remember the result,
since that will be automatically remembered for use by Tcl_FSGetCwd.
Real filesystems should carry out the correct action (i.e. call the
correct system chdir API).
typedef int Tcl_FSChdirProc(
Tcl_Obj *pathPtr);
The Tcl_FSChdirProc changes the applications current working directory
to the value specified in pathPtr. The function returns -1 on error or
0 on success.
SEE ALSOcd(n), file(n), load(n), open(n), pwd(n), unload(n)KEYWORDS
stat, access, filesystem, vfs, virtual
Tcl 8.4 Filesystem(3)
