Tcl_GetLinkCountFromStat (3) - Linux Manuals
Tcl_GetLinkCountFromStat: procedures to interact with any filesystem
NAME
Tcl_FSRegister, Tcl_FSUnregister, Tcl_FSData, Tcl_FSMountsChanged, Tcl_FSGetFileSystemForPath, Tcl_FSGetPathType, Tcl_FSCopyFile, Tcl_FSCopyDirectory, Tcl_FSCreateDirectory, Tcl_FSDeleteFile, Tcl_FSRemoveDirectory, Tcl_FSRenameFile, Tcl_FSListVolumes, Tcl_FSEvalFile, Tcl_FSEvalFileEx, Tcl_FSLoadFile, Tcl_FSUnloadFile, 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_FSJoinToPath, Tcl_FSConvertToPathType, Tcl_FSGetInternalRep, Tcl_FSGetTranslatedPath, Tcl_FSGetTranslatedStringPath, Tcl_FSNewNativePath, Tcl_FSGetNativePath, Tcl_FSFileSystemInfo, Tcl_GetAccessTimeFromStat, Tcl_GetBlockSizeFromStat, Tcl_GetBlocksFromStat, Tcl_GetChangeTimeFromStat, Tcl_GetDeviceTypeFromStat, Tcl_GetFSDeviceFromStat, Tcl_GetFSInodeFromStat, Tcl_GetGroupIdFromStat, Tcl_GetLinkCountFromStat, Tcl_GetModeFromStat, Tcl_GetModificationTimeFromStat, Tcl_GetSizeFromStat, Tcl_GetUserIdFromStat, Tcl_AllocStatBuf - procedures 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) const 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, loadHandlePtr, unloadProcPtr) int Tcl_FSUnloadFile(interp, loadHandle) 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 *const * 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 void * Tcl_FSGetNativePath(pathPtr) Tcl_Obj * Tcl_FSFileSystemInfo(pathPtr) Tcl_StatBuf * Tcl_AllocStatBuf() Tcl_WideInt Tcl_GetAccessTimeFromStat(statPtr) unsigned Tcl_GetBlockSizeFromStat(statPtr) Tcl_WideUInt Tcl_GetBlocksFromStat(statPtr) Tcl_WideInt Tcl_GetChangeTimeFromStat(statPtr) int Tcl_GetDeviceTypeFromStat(statPtr) unsigned Tcl_GetFSDeviceFromStat(statPtr) unsigned Tcl_GetFSInodeFromStat(statPtr) int Tcl_GetGroupIdFromStat(statPtr) int Tcl_GetLinkCountFromStat(statPtr) unsigned Tcl_GetModeFromStat(statPtr) Tcl_WideInt Tcl_GetModificationTimeFromStat(statPtr) Tcl_WideUInt Tcl_GetSizeFromStat(statPtr) int Tcl_GetUserIdFromStat(statPtr)
ARGUMENTS
- const Tcl_Filesystem *fsPtr (in) Points to a structure containing the addresses of procedures that can be called to perform the various filesystem operations.
- Tcl_Obj *pathPtr (in) The path represented by this value is used for the operation in question. If the value does not already have an internal path representation, 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 destination 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 directories matching this pattern will be returned.
- Tcl_GlobTypeData *types (in) Only files or directories 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 messages.
- ClientData clientData (in) The native description of the path value to create.
- Tcl_Obj *firstPtr (in) The first of two path values to compare. The value may be converted to path type.
- Tcl_Obj *secondPtr (in) The second of two path values to compare. The value may be converted to path type.
- Tcl_Obj *listObj (in) The list of path elements to operate on with a join operation.
- int elements (in) If non-negative, the number of elements in the listObj which should be joined together. If negative, then all elements are joined.
- Tcl_Obj **errorPtr (out) In the case of an error, filled with a value containing the name of the file which caused an error in the various copy/rename operations.
- Tcl_Obj **objPtrRef (out) Filled with a value containing the result of the operation.
- Tcl_Obj *resultPtr (out) Pre-allocated value in which to store (using Tcl_ListObjAppendElement) 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 permissions, 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 *loadHandlePtr (out) Filled with an abstract token representing the loaded file.
- Tcl_FSUnloadFileProc **unloadProcPtr (out) Filled with the function to use to unload this piece of code.
- Tcl_LoadHandle loadHandle (in) Handle to the loaded library to be unloaded.
- utimbuf *tval (in) The access and modification 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 permission 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 elements 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_SYMBOLIC_LINK and TCL_CREATE_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.
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 provide
a lookup table of functions to implement all or some of the functionality
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 systems without support for files larger than 2GB in size.
The Tcl_FS API is Tcl_Obj-ified 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 values
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 value, and so one must not assume
that after any of these calls return, the value 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 value being freed part way through the complex value
manipulation required to ensure that the path is fully normalized and
absolute for filesystem determination. The practical lesson to learn
from this is that
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, values with a reference count of zero are
considered not to be valid filesystem paths and calling any Tcl_FS API
function with such a value will result in no action being taken.
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).
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_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 calling 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
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
``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 volumes''
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.
Tcl_FSUnloadFile reverses the operation, asking for the library
indicated by the loadHandle to be removed from the process. Note that,
unlike with the unload command, this does not give the library any
opportunity to clean up.
Both the above functions return a standard Tcl completion code. If an error
occurs, an error message is left in the interp's result.
The token provided via the variable indicated by loadHandlePtr may be
used with Tcl_FindSymbol.
Tcl_FSMatchInDirectory is used by the globbing code to search a
directory for all files which match a given pattern. The appropriate
function 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_CREATE_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 Tcl_StatBuf 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 Tcl_StatBuf
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.
See PORTABLE STAT RESULT API for a description of how to write
portable code to allocate and access the Tcl_StatBuf structure.
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
documentation). 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 a value 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 pathPtr 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 value.
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 permissions 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 Tcl_StatBuf 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 Tcl_StatBuf
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.
See PORTABLE STAT RESULT API for a description of how to write
portable code to allocate and access the Tcl_StatBuf structure.
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 standard 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_FSOpenFileChannel
leaves an error message in interp's result after any error.
The newly created channel is not registered in the supplied interpreter; to
register it, use Tcl_RegisterChannel.
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.
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 decremented. 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
normalized 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
value 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 discarded.
If elements is less than 0, we use the entire list.
It is possible that the returned value 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 value, 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 value before using it. In particular, the
returned value could be an element of the given list, so freeing the
list might free the value prematurely if no reference count has been taken.
If the number of elements is zero, then the returned value 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 value containing each segment of that path as
an element.
It returns a list value 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 value, 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
value may be freed any time the cwd changes) - the caller can of
course increment the reference count if it wishes to maintain a copy for longer.
Tcl_FSJoinToPath takes the given value, which should usually be a
valid path or NULL, and joins onto it the array of paths segments
given.
Returns a value, typically with reference count of zero (but it could be shared
under some conditions), containing the joined path. The caller must
add a reference count to the value before using it. If any of the values
passed into this function (pathPtr or path elements) have
a reference count
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 value 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 value 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 value, in the given filesystem. If the path value 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 value 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 value 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_FSGetNormalizedPath or Tcl_FSGetNativePath 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 dynamically allocated and owned by the caller,
which must store it or call ckfree to ensure it is freed. Again,
Tcl_FSGetNormalizedPath or Tcl_FSGetNativePath are usually
better functions to use for most purposes.
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.
The resulting value is a pure
``path''
value, 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*) representation of a path. This function is a convenience
wrapper around Tcl_FSGetInternalRep. 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 unlimited length. Currently the representation
is simply a character string which may contain either the relative path
or a complete, absolute normalized 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
second element may be empty if the filesystem does not provide a
further categorization of files.
A valid list value is returned, unless the path value is not
recognized, when NULL will be returned.
Tcl_FSGetFileSystemForPath returns 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 portable fields of a Tcl_StatBuf may be read using the following
functions, each of which returns the value of the corresponding field listed
in the table below. Note that on some platforms there may be other fields in
the Tcl_StatBuf as it is an alias for a suitable system structure, but
only the portable ones are made available here. See your system documentation
for a full description of these fields.
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 generally occurs through the functions listed above.
The Tcl_Filesystem structures are manipulated using the following
methods.
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 contains the following fields:
Except for the first three fields in this structure which contain
simple data elements, all entries contain addresses of functions called
by the generic filesystem layer to perform the complete range of
filesystem related actions.
The many functions in this structure are broken down into three
categories: infrastructure functions (almost all of which must be
implemented), 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_FSCopyFileProc followed by
Tcl_FSDeleteFileProc, and if Tcl_FSCopyFileProc is not
implemented there is a further fallback). However, if a
Tcl_FSRenameFileProc 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 representations.
Here is the filesystem lookup table used by the
``vfs''
extension which allows filesystem actions to be implemented in Tcl.
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
representations.
The typeName field contains a null-terminated string that
identifies the type of the filesystem implemented, e.g.
``native'',
``zip''
or
``vfs''.
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.
The version field should be set to TCL_FILESYSTEM_VERSION_1.
The pathInFilesystemProc field contains the address of a function
which is called to determine whether a given path value belongs to this
filesystem or not. Tcl will only call the rest of the filesystem
functions with a path for which this function has returned TCL_OK.
If the path does not belong, -1 should be returned (the behavior 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 value, 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.
This function makes a copy of a path's internal representation, and is
called when Tcl needs to duplicate a path value. If NULL, Tcl will
simply not copy the internal representation, which may then need to be
regenerated later.
Function to convert internal representation to a normalized path. Only
required if the filesystem creates pure path values with no string/path
representation. The return value is a Tcl value whose string
representation is the normalized path.
Function to take a path value, and calculate an internal
representation for it, and store that native representation in the
value. May be NULL if paths have no internal representation, or if
the Tcl_FSPathInFilesystemProc for this filesystem always
immediately creates an internal representation for paths it accepts.
Function to normalize a path. Should be implemented for all
filesystems which can have multiple string representations for the same
path value. 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 value 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.
The fields in this section of the structure contain addresses of
functions which are called to carry out the basic filesystem
operations. A filesystem which expects to be used with the complete
standard Tcl command set must implement all of these. If some of
them are not implemented, then certain Tcl commands may fail when
operating on paths within that filesystem. However, in some instances
this may be desirable (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).
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 reference count of that value if it wishes to retain a reference
to it.
Function to return the separator character(s) for this filesystem.
This need only be implemented if the filesystem wishes to use a
different separator than the standard string
``/''.
Amongst other
uses, it is returned by the file separator command. The
return value should be a value with reference count of zero.
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.
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 directories 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.
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.
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.
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.
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 similar 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 be registered in the supplied interpreter
by a Tcl_FSOpenFileChannelProc; that task is up to the caller of
Tcl_FSOpenFileChannel (if necessary). 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.
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).
The function should return all files or directories (or other filesystem
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 correct 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 value 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:
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.
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.
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.
Function to process a Tcl_FSLink call. Should be implemented
only if the filesystem supports links, and may otherwise be NULL.
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_DecrRefCount 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 reference count manipulations on either end are needed). See
the documentation for Tcl_FSLink for the correct interpretation
of the linkAction flags.
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.
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 value
is considered to be owned by the filesystem (not by Tcl's core), but
should be given a reference count for Tcl. Tcl will use the contents of the
list and then decrement that reference count. 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 reference count of 1 and then forget about the list, if yes, then
they simply increment the reference count 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.
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.
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 a value with a reference count
of at least one.
Function to process a Tcl_FSFileAttrsGet call, used by file
attributes.
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.
Function to process a Tcl_FSFileAttrsSet call, used by file
attributes. If the filesystem is read-only, there is no need
to implement this.
The attribute value of the index'th element in the list returned by
the Tcl_FSFileAttrStringsProc should be set to the objPtr given.
Function to process a Tcl_FSCreateDirectory call. Should be
implemented unless the FS is read-only.
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.
Function to process a Tcl_FSRemoveDirectory call. Should be
implemented unless the FS is read-only.
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.
Function to process a Tcl_FSDeleteFile call. Should be implemented
unless the FS is read-only.
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).
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.
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.
The behavior of this function is very similar to that of the
Tcl_FSStatProc defined above, except that if it is applied
to a symbolic link, it returns information about the link, not
about the target file.
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.
Therefore it need only be implemented if the filesystem can perform
that action more efficiently.
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.
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
efficiently.
The return value is a standard Tcl result indicating whether an error
occurred in the renaming process. If the
filesystem determines it cannot support the file rename action,
calling Tcl_SetErrno(EXDEV) and returning a non-TCL_OK
result will tell Tcl to use its standard fallback mechanisms.
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.
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 function 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.
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.
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.
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.
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.
If the filesystem supports a native notion of a current working
directory (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 permissions on the cwd directory). If NULL is returned, an
error message is left in the interp's result.
Function to process a Tcl_FSChdir call. If filesystems do not
implement 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).
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.
Tcl_Obj *path = Tcl_NewStringObj(...);
Tcl_FSWhatever(path);
Tcl_DecrRefCount(path);
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
filesystem'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'').
PORTABLE STAT RESULT API
Access Function Field
Tcl_GetFSDeviceFromStat st_dev
Tcl_GetFSInodeFromStat st_ino
Tcl_GetModeFromStat st_mode
Tcl_GetLinkCountFromStat st_nlink
Tcl_GetUserIdFromStat st_uid
Tcl_GetGroupIdFromStat st_gid
Tcl_GetDeviceTypeFromStat st_rdev
Tcl_GetAccessTimeFromStat st_atime
Tcl_GetModificationTimeFromStat st_mtime
Tcl_GetChangeTimeFromStat st_ctime
Tcl_GetSizeFromStat st_size
Tcl_GetBlocksFromStat st_blocks
Tcl_GetBlockSizeFromStat st_blksize
THE VIRTUAL FILESYSTEM API
THE TCL_FILESYSTEM STRUCTURE
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;
EXAMPLE FILESYSTEM DEFINITION
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
TYPENAME
STRUCTURE LENGTH
VERSION
PATHINFILESYSTEMPROC
typedef int Tcl_FSPathInFilesystemProc(
Tcl_Obj *pathPtr,
ClientData *clientDataPtr);
DUPINTERNALREPPROC
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
typedef Tcl_Obj *Tcl_FSInternalToNormalizedProc(
ClientData clientData);
CREATEINTERNALREPPROC
typedef ClientData Tcl_FSCreateInternalRepProc(
Tcl_Obj *pathPtr);
NORMALIZEPATHPROC
typedef int Tcl_FSNormalizePathProc(
Tcl_Interp *interp,
Tcl_Obj *pathPtr,
int nextCheckpoint);
FILESYSTEM OPERATIONS
FILESYSTEMPATHTYPEPROC
typedef Tcl_Obj *Tcl_FSFilesystemPathTypeProc(
Tcl_Obj *pathPtr);
FILESYSTEMSEPARATORPROC
typedef Tcl_Obj *Tcl_FSFilesystemSeparatorProc(
Tcl_Obj *pathPtr);
STATPROC
typedef int Tcl_FSStatProc(
Tcl_Obj *pathPtr,
Tcl_StatBuf *statPtr);
ACCESSPROC
typedef int Tcl_FSAccessProc(
Tcl_Obj *pathPtr,
int mode);
OPENFILECHANNELPROC
typedef Tcl_Channel Tcl_FSOpenFileChannelProc(
Tcl_Interp *interp,
Tcl_Obj *pathPtr,
int mode,
int permissions);
MATCHINDIRECTORYPROC
typedef int Tcl_FSMatchInDirectoryProc(
Tcl_Interp *interp,
Tcl_Obj *resultPtr,
Tcl_Obj *pathPtr,
const char *pattern,
Tcl_GlobTypeData *types);
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;
UTIMEPROC
typedef int Tcl_FSUtimeProc(
Tcl_Obj *pathPtr,
struct utimbuf *tval);
LINKPROC
typedef Tcl_Obj *Tcl_FSLinkProc(
Tcl_Obj *linkNamePtr,
Tcl_Obj *toPtr,
int linkAction);
LISTVOLUMESPROC
typedef Tcl_Obj *Tcl_FSListVolumesProc(void);
FILEATTRSTRINGSPROC
typedef const char *const *Tcl_FSFileAttrStringsProc(
Tcl_Obj *pathPtr,
Tcl_Obj **objPtrRef);
FILEATTRSGETPROC
typedef int Tcl_FSFileAttrsGetProc(
Tcl_Interp *interp,
int index,
Tcl_Obj *pathPtr,
Tcl_Obj **objPtrRef);
FILEATTRSSETPROC
typedef int Tcl_FSFileAttrsSetProc(
Tcl_Interp *interp,
int index,
Tcl_Obj *pathPtr,
Tcl_Obj *objPtr);
CREATEDIRECTORYPROC
typedef int Tcl_FSCreateDirectoryProc(
Tcl_Obj *pathPtr);
REMOVEDIRECTORYPROC
typedef int Tcl_FSRemoveDirectoryProc(
Tcl_Obj *pathPtr,
int recursive,
Tcl_Obj **errorPtr);
DELETEFILEPROC
typedef int Tcl_FSDeleteFileProc(
Tcl_Obj *pathPtr);
FILESYSTEM EFFICIENCY
LSTATPROC
typedef int Tcl_FSLstatProc(
Tcl_Obj *pathPtr,
Tcl_StatBuf *statPtr);
COPYFILEPROC
typedef int Tcl_FSCopyFileProc(
Tcl_Obj *srcPathPtr,
Tcl_Obj *destPathPtr);
RENAMEFILEPROC
typedef int Tcl_FSRenameFileProc(
Tcl_Obj *srcPathPtr,
Tcl_Obj *destPathPtr);
COPYDIRECTORYPROC
typedef int Tcl_FSCopyDirectoryProc(
Tcl_Obj *srcPathPtr,
Tcl_Obj *destPathPtr,
Tcl_Obj **errorPtr);
LOADFILEPROC
typedef int Tcl_FSLoadFileProc(
Tcl_Interp *interp,
Tcl_Obj *pathPtr,
Tcl_LoadHandle *handlePtr,
Tcl_FSUnloadFileProc *unloadProcPtr);
UNLOADFILEPROC
typedef void Tcl_FSUnloadFileProc(
Tcl_LoadHandle loadHandle);
GETCWDPROC
typedef Tcl_Obj *Tcl_FSGetCwdProc(
Tcl_Interp *interp);
CHDIRPROC
typedef int Tcl_FSChdirProc(
Tcl_Obj *pathPtr);
KEYWORDS
stat, access, filesystem, vfs, virtual filesystem