通讯编程

开发平台：
Visual C++

FileSystem.3：源码内容
							'"
'" Copyright (c) 2001 Vincent Darley
'"
'" See the file "license.terms" for information on usage and redistribution
'" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'" 
'" RCS: @(#) $Id: FileSystem.3,v 1.32.2.4 2005/06/20 16:57:43 dgp Exp $
'" 
.so man.macros
.TH Filesystem 3 8.4 Tcl "Tcl Library Procedures"
.BS
.SH 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_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_FSJoinToPath, Tcl_FSConvertToPathType, Tcl_FSGetInternalRep, Tcl_FSGetTranslatedPath, Tcl_FSGetTranslatedStringPath, Tcl_FSNewNativePath, Tcl_FSGetNativePath, Tcl_FSFileSystemInfo, Tcl_AllocStatBuf - procedures to interact with any filesystem
.SH SYNOPSIS
.nf
fB#include <tcl.h>fR
.sp
int
fBTcl_FSRegisterfR(fIclientData, fsPtrfR)
.sp
int
fBTcl_FSUnregisterfR(fIfsPtrfR)
.sp
ClientData
fBTcl_FSDatafR(fIfsPtrfR)
.sp
void
fBTcl_FSMountsChangedfR(fIfsPtrfR)
.sp
Tcl_Filesystem*
fBTcl_FSGetFileSystemForPathfR(fIpathObjPtrfR)
.sp
Tcl_PathType
fBTcl_FSGetPathTypefR(fIpathObjPtrfR)
.sp
int
fBTcl_FSCopyFilefR(fIsrcPathPtr, destPathPtrfR)
.sp
int
fBTcl_FSCopyDirectoryfR(fIsrcPathPtr, destPathPtr, errorPtrfR)
.sp
int
fBTcl_FSCreateDirectoryfR(fIpathPtrfR)
.sp
int
fBTcl_FSDeleteFilefR(fIpathPtrfR)
.sp
int
fBTcl_FSRemoveDirectoryfR(fIpathPtr, int recursive, errorPtrfR)
.sp
int
fBTcl_FSRenameFilefR(fIsrcPathPtr, destPathPtrfR)
.sp
Tcl_Obj*
fBTcl_FSListVolumesfR(fIvoidfR)
.sp
int
fBTcl_FSEvalFilefR(fIinterp, pathPtrfR)
.sp
int
fBTcl_FSLoadFilefR(fIinterp, pathPtr, sym1, sym2, proc1Ptr, proc2Ptr,
               handlePtr, unloadProcPtrfR)
.sp
int
fBTcl_FSMatchInDirectoryfR(fIinterp, result, pathPtr, pattern, typesfR)
.sp
Tcl_Obj*
fBTcl_FSLinkfR(fIlinkNamePtr, toPtr, linkActionfR)
.sp
int
fBTcl_FSLstatfR(fIpathPtr, statPtrfR)
.sp
int
fBTcl_FSUtimefR(fIpathPtr, tvalfR)
.sp
int
fBTcl_FSFileAttrsGetfR(fIinterp, int index, pathPtr, objPtrReffR)
.sp
int
fBTcl_FSFileAttrsSetfR(fIinterp, int index, pathPtr, Tcl_Obj *objPtrfR)
.sp
CONST char**      
fBTcl_FSFileAttrStringsfR(fIpathPtr, objPtrReffR)
.sp
int
fBTcl_FSStatfR(fIpathPtr, statPtrfR)
.sp
int
fBTcl_FSAccessfR(fIpathPtr, modefR)
.sp
Tcl_Channel 
fBTcl_FSOpenFileChannelfR(fIinterp, pathPtr, modeString, permissionsfR)
.sp
Tcl_Obj*
fBTcl_FSGetCwdfR(fIinterpfR)
.sp
int
fBTcl_FSChdirfR(fIpathPtrfR)
.sp
Tcl_Obj*
fBTcl_FSPathSeparatorfR(fIpathPtrfR)
.sp
Tcl_Obj*
fBTcl_FSJoinPathfR(fIlistObj, elementsfR)
.sp
Tcl_Obj*
fBTcl_FSSplitPathfR(fIpathPtr, lenPtrfR)
.sp
int
fBTcl_FSEqualPathsfR(fIfirstPtr, secondPtrfR)
.sp
Tcl_Obj*
fBTcl_FSGetNormalizedPathfR(fIinterp, pathPtrfR)
.sp
Tcl_Obj*
fBTcl_FSJoinToPathfR(fIbasePtr, objc, objvfR)
.sp
int
fBTcl_FSConvertToPathTypefR(fIinterp, pathPtrfR)
.sp
ClientData 
fBTcl_FSGetInternalRepfR(fIpathPtr, fsPtrfR)
.sp
Tcl_Obj* 
fBTcl_FSGetTranslatedPathfR(fIinterp, pathPtrfR)
.sp
CONST char* 
fBTcl_FSGetTranslatedStringPathfR(fIinterp, pathPtrfR)
.sp
Tcl_Obj*
fBTcl_FSNewNativePathfR(fIfsPtr, clientDatafR)
.sp
CONST char* 
fBTcl_FSGetNativePathfR(fIpathPtrfR)
.sp
Tcl_Obj*
fBTcl_FSFileSystemInfofR(fIpathPtrfR)
.sp
Tcl_StatBuf*
fBTcl_AllocStatBuffR()
.SH ARGUMENTS
.AS Tcl_Filesystem *fsPtr in
.AP Tcl_Filesystem *fsPtr in
Points to a structure containing the addresses of procedures that
can be called to perform the various filesystem operations.
.AP Tcl_Obj *pathPtr in
The path represented by this object is used for the operation in
question.  If the object does not already have an internal fBpathfR
representation, it will be converted to have one.
.AP Tcl_Obj *srcPathPtr in
As for fBpathPtrfR, but used for the source file for a copy or
rename operation.
.AP Tcl_Obj *destPathPtr in
As for fBpathPtrfR, but used for the destination filename for a copy or
rename operation.
.AP "CONST char" *pattern in
Only files or directories matching this pattern will be returned by
fBTcl_FSMatchInDirectoryfR.
.AP GlobTypeData *types in
Only files or directories matching the type descriptions contained in
this structure will be returned by fBTcl_FSMatchInDirectoryfR.  It
is very important that the 'directory' flag is properly handled.
This parameter may be NULL.
.AP Tcl_Interp *interp in
Interpreter to use either for results, evaluation, or reporting error 
messages.
.AP ClientData clientData in
The native description of the path object to create.
.AP Tcl_Obj *firstPtr in
The first of two path objects to compare.  The object may be converted
to fBpathfR type.
.AP Tcl_Obj *secondPtr in
The second of two path objects to compare.  The object may be converted
to fBpathfR type.
.AP Tcl_Obj *listObj in
The list of path elements to operate on with a fBjoinfR operation.
.AP 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.
.AP 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 operations.
.AP Tcl_Obj **objPtrRef out
Filled with an object containing the result of the operation.
.AP Tcl_Obj *result out
Pre-allocated object in which to store (by lappending) the list of
files or directories which are successfully matched in
fBTcl_FSMatchInDirectoryfR.
.AP 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.
.AP Tcl_StatBuf *statPtr out
The structure that contains the result of a stat or lstat operation.
.AP "CONST char" *sym1 in
Name of a procedure to look up in the file's symbol table
.AP "CONST char" *sym2 in
Name of a procedure to look up in the file's symbol table
.AP Tcl_PackageInitProc **proc1Ptr out
Filled with the init function for this code.
.AP Tcl_PackageInitProc **proc2Ptr out
Filled with the safe-init function for this code.
.AP Tcl_LoadHandle *handlePtr out
Filled with an abstract token representing the loaded file.
.AP ClientData *clientDataPtr out
Filled with the clientData value to pass to this code's unload
function when it is called.
.AP TclfsUnloadFileProc_ **unloadProcPtr out
Filled with the function to use to unload this piece of code.
.AP utimbuf *tval in
The access and modification times in this structure are read and 
used to set those values for a given file.
.AP "CONST char" *modeString in
Specifies how the file is to be accessed.  May have any of the values
allowed for the fImodefR argument to the Tcl fBopenfR command.
.AP 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.
.AP int *lenPtr out
If non-NULL, filled with the number of elements in the split path.
.AP Tcl_Obj *basePtr in
The base path on to which to join the given elements.  May be NULL.
.AP int objc in
The number of elements in fIobjvfR.
.AP "Tcl_Obj *CONST" objv[] in
The elements to join to the given base path.
.BE
.SH DESCRIPTION
.PP
There are several reasons for calling the fBTcl_FS...fR functions
rather than calling system level functions like fBaccessfR and
fBstatfR directly.  First, they will work cross-platform, so an
extension which calls them should work unmodified on Unix, MacOS 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 which has been registered (through
fBTcl_FSRegisterfR) may reroute file access to alternative
media or access methods.  This means that all of these functions (and
therefore the corresponding fBfilefR, fBglobfR, fBpwdfR, fBcdfR,
fBopenfR, 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 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.  
.PP
If appropriate vfs's 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 fBTcl_FSStatfR and fBTcl_FSLstatfR calls
abstract away from what the 'struct stat' buffer 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.
.PP
The fBTcl_FS...fR are 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 refCount 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 refCount of
zero - it may have been incremented), or in a direct segfault
due to the object being freed part way through the complex object
manipulation required to ensure that the path is fully normalized and
absolute for filesystem determination.  The practical lesson to learn
from this is that fBTcl_Obj *path = Tcl_NewStringObj(...)  ;
Tcl_FS...(path) ; Tcl_DecrRefCount(path)fR is wrong, and may segfault.
The 'path' must have its refCount incremented before passing it in, or
decrementing it.  For this reason, objects with a refCount of zero are
considered not to be valid filesystem paths and calling any Tcl_FS API
with such an object will result in no action being taken.
.PP
fBTcl_FSCopyFilefR 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 fBTcl_FSGetFileSystemForPathfR) then that
filesystem's 'copy file' function is called (if it is non-NULL).
Otherwise the function returns -1 and sets Tcl's errno to the 'EXDEV'
posix error code (which signifies a 'cross-domain link').
.PP
fBTcl_FSCopyDirectoryfR 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 fBTcl_FSGetFileSystemForPathfR) then that
filesystem's 'copy file' function is called (if it is non-NULL).
Otherwise the function returns -1 and sets Tcl's errno to the 'EXDEV'
posix error code (which signifies a 'cross-domain link').
.PP
fBTcl_FSCreateDirectoryfR attempts to create the directory given by
pathPtr by calling the owning filesystem's 'create directory'
function.
.PP
fBTcl_FSDeleteFilefR attempts to delete the file given by
pathPtr by calling the owning filesystem's 'delete file'
function.
.PP
fBTcl_FSRemoveDirectoryfR attempts to remove the directory given by
pathPtr by calling the owning filesystem's 'remove directory'
function.
.PP
fBTcl_FSRenameFilefR 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
fBTcl_FSGetFileSystemForPathfR) then that filesystem's 'rename file'
function is called (if it is non-NULL).  Otherwise the function returns -1
and sets Tcl's errno to the 'EXDEV' posix error code (which signifies
a ``cross-domain link'').
.PP
fBTcl_FSListVolumesfR 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 refCount of 0).
.PP
fBTcl_FSEvalFilefR reads the file given by fIpathPtrfR and evaluates
its contents as a Tcl script.  It returns the same information as
fBTcl_EvalObjExfR.
If the file couldn't be read then a Tcl error is returned to describe
why the file couldn't 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''.
.PP
fBTcl_FSLoadFilefR 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.
.PP
Returns a standard Tcl completion code.  If an error occurs, an error
message is left in the interp's result.
.PP
fBTcl_FSMatchInDirectoryfR 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.
.PP
The return value is a standard Tcl result indicating whether an error
occurred in globbing.  Error messages are placed in interp, 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.
.PP
fBTcl_FSLinkfR 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.
.PP
If the fItoPtrfR is NULL, a readlink action is performed.  The result
is a Tcl_Obj specifying the contents of the symbolic link given by
fIlinkNamePtrfR, 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 fItoPtrfR is not NULL, Tcl should create a link
of one of the types passed in in the fIlinkActionfR flag.  This flag is
an or'd 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 fItoPtrfR (which is therefore
already owned by the caller).  If unsuccessful, NULL should be
returned.
.PP
fBTcl_FSLstatfR fills the stat structure fIstatPtrfR 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 creation
time.
.PP
If fIpathfR exists, fBTcl_FSLstatfR returns 0 and the stat structure
is filled with data.  Otherwise, -1 is returned, and no stat info is
given.
.PP
fBTcl_FSUtimefR replaces the library version of utime.  
.PP
For results see 'utime' documentation.  If successful, the function
will update the 'atime' and 'mtime' values of the file given.
.PP
fBTcl_FSFileAttrsGetfR implements read access for the hookable 'file
attributes' subcommand.  The appropriate function for the filesystem to
which pathPtr belongs will be called.
.PP
If the result is TCL_OK, then an object was placed in objPtrRef, which
will only be temporarily valid (unless Tcl_IncrRefCount is called).
.PP
fBTcl_FSFileAttrsSetfR implements write access for the hookable 'file
attributes' subcommand.  The appropriate function for the filesystem to
which pathPtr belongs will be called.
.PP
fBTcl_FSFileAttrStringsfR implements part of the hookable 'file attributes'
subcommand.  The appropriate function for the filesystem to which
pathPtr belongs will be called.
.PP 
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 refCount before using it.
On completion of that use, Tcl will decrement its refCount.  Hence if
the list should be disposed of by Tcl when done, it should have a
refCount of zero, and if the list should not be disposed of, the
filesystem should ensure it retains a refCount on the object.
.PP
fBTcl_FSAccessfR checks whether the process would be allowed to read,
write or test for existence of the file (or other file system 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.
.PP
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.
.PP
fBTcl_FSStatfR fills the stat structure fIstatPtrfR 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 creation
time.
.PP
If fIpathfR exists, fBTcl_FSStatfR returns 0 and the stat structure
is filled with data.  Otherwise, -1 is returned, and no stat info is
given.
.PP
fBTcl_FSOpenFileChannelfR opens a file specified by fIpathPtrfR and
returns a channel handle that can be used to perform input and output on
the file. This API is modeled after the fBfopenfR procedure of
the Unix standard I/O library.
The syntax and meaning of all arguments is similar to those
given in the Tcl fBopenfR command when opening a file.
If an error occurs while opening the channel, fBTcl_FSOpenFileChannelfR
returns NULL and records a POSIX error code that can be
retrieved with fBTcl_GetErrnofR.
In addition, if fIinterpfR is non-NULL, fBTcl_FSOpenFileChannelfR
leaves an error message in fIinterpfR's result after any error.
.PP
The newly created channel is not registered in the supplied interpreter; to
register it, use fBTcl_RegisterChannelfR, described below.
If one of the standard channels, fBstdin, stdoutfR or fBstderrfR was
previously closed, the act of creating the new channel also assigns it as a
replacement for the standard channel.
.PP
fBTcl_FSGetCwdfR replaces the library version of getcwd().
.PP
It returns the Tcl library's current working directory.  This may be
different to the native platform's working directory, in the case for 
which the cwd is not in the native filesystem.
.PP
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 refCount incremented for the caller.  When
it is no longer needed, that refCount 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.
.PP
fBTcl_FSChdirfR 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.
.PP 
For results, see chdir() documentation.  If successful, we keep a
record of the successful path in cwdPathPtr for subsequent calls to
getcwd.
.PP
fBTcl_FSPathSeparatorfR 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).
.PP
The separator is returned as a Tcl_Obj containing a string of length
1.  If the path is invalid, NULL is returned.
.PP
fBTcl_FSJoinPathfR takes the given Tcl_Obj, which should be a valid list,
and returns the path object given by considering the first 'elements'
elements as valid path segments.  If elements < 0, we use the entire
list.
.PP
Returns object with refCount of zero, containing the joined path.
.PP
fBTcl_FSSplitPathfR 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.
.PP
Returns list object with refCount of zero.  If the passed in lenPtr is
non-NULL, we use it to return the number of elements in the returned
list.
.PP
fBTcl_FSEqualPathsfR tests whether the two paths given represent the same
filesystem object
.PP
It returns 1 if the paths are equal, and 0 if they are different.  If 
either path is NULL, 0 is always returned.
.PP
fBTcl_FSGetNormalizedPathfR 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.
.PP
It returns the normalized path object, with refCount of zero, 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.
.PP
fBTcl_FSJoinToPathfR takes the given object, which should usually be a
valid path or NULL, and joins onto it the array of paths segments
given.
.PP
Returns object with refCount of zero, containing the joined path.
.PP
fBTcl_FSConvertToPathTypefR 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).
.PP
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.
.PP
fBTcl_FSGetInternalRepfR 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
fBTcl_FSCreateInternalRepProcfR.
.PP
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.
.PP
fBTcl_FSGetTranslatedPathfR attempts to extract the translated path
from the given Tcl_Obj.  
.PP
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
fBTcl_FSGetNormalizedPathfR or fBTcl_GetNativePathfR are usually
better functions to use for most purposes.
.PP
fBTcl_FSGetTranslatedStringPathfR does the same as
fBTcl_FSGetTranslatedPathfR, 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,
fBTcl_FSGetNormalizedPathfR or fBTcl_GetNativePathfR are usually
better functions to use for most purposes.
.PP
fBTcl_FSNewNativePathfR performs something like that 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.
.PP
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.
.PP
fBTcl_FSGetNativePathfR is for use by the Win/Unix/MacOS native
filesystems, so that they can easily retrieve the native (char* or
TCHAR*) representation of a path.  This function is a convenience
wrapper around fBTcl_FSGetInternalRepfR, 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
MacOS, 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 containing the
complete, absolute path in the native encoding.
.PP
The native representation is cached so that repeated calls to this
function will not require additional conversions.
.PP
fBTcl_FSFileSystemInfofR returns a list of two elements.  The first
element is the name of the filesystem (e.g. "native" or "vfs" or "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.
.PP
A valid list object is returned, unless the path object is not
recognized, when NULL will be returned.
.PP
fBTcl_FSGetFileSystemForPathfR returns the a pointer to the
fBTcl_FilesystemfR which accepts this path as valid.
.PP
If no filesystem will accept the path, NULL is returned.
.PP
fBTcl_FSGetPathTypefR determines whether the given path is relative 
to the current directory, relative to the current volume, or
absolute.
.PP
It returns one of TCL_PATH_ABSOLUTE, TCL_PATH_RELATIVE, or
TCL_PATH_VOLUME_RELATIVE
.PP
fBTcl_AllocStatBuffR allocates a fITcl_StatBuffR on the system
heap (which may be deallocated by being passed to fBckfreefR.)  This
allows extensions to invoke fBTcl_FSStatfR and fBTcl_FSLStatfR
without being dependent on the size of the buffer.  That in turn
depends on the flags used to build Tcl.
.PP
.SH TCL_FILESYSTEM
.PP
A filesystem provides a fBTcl_FilesystemfR 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.  
.PP
The fBTcl_FilesystemfR structures are manipulated using the following
methods.
.PP
fBTcl_FSRegisterfR 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.
.PP
fBTcl_FSUnregisterfR 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.
.PP
fBTcl_FSDatafR will return the ClientData associated with the given 
filesystem, if that filesystem is registered.  Otherwise it will
return NULL.
.PP
fBTcl_FSMountsChangedfR 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.
.PP
The fBTcl_FilesystemfR structure contains the following fields:
.CS
typedef struct Tcl_Filesystem {
    CONST char *fItypeNamefR;  
    int fIstructureLengthfR;   
    Tcl_FSVersion fIversionfR;  
    Tcl_FSPathInFilesystemProc *fIpathInFilesystemProcfR;
    Tcl_FSDupInternalRepProc *fIdupInternalRepProcfR;
    Tcl_FSFreeInternalRepProc *fIfreeInternalRepProcfR;
    Tcl_FSInternalToNormalizedProc *fIinternalToNormalizedProcfR;
    Tcl_FSCreateInternalRepProc *fIcreateInternalRepProcfR;
    Tcl_FSNormalizePathProc *fInormalizePathProcfR;       
    Tcl_FSFilesystemPathTypeProc *fIfilesystemPathTypeProcfR;
    Tcl_FSFilesystemSeparatorProc *fIfilesystemSeparatorProcfR;
    Tcl_FSStatProc *fIstatProcfR; 
    Tcl_FSAccessProc *fIaccessProcfR;	    
    Tcl_FSOpenFileChannelProc *fIopenFileChannelProcfR; 
    Tcl_FSMatchInDirectoryProc *fImatchInDirectoryProcfR;  
    Tcl_FSUtimeProc *fIutimeProcfR;       
    Tcl_FSLinkProc *fIlinkProcfR; 
    Tcl_FSListVolumesProc *fIlistVolumesProcfR;	    
    Tcl_FSFileAttrStringsProc *fIfileAttrStringsProcfR;
    Tcl_FSFileAttrsGetProc *fIfileAttrsGetProcfR;
    Tcl_FSFileAttrsSetProc *fIfileAttrsSetProcfR;
    Tcl_FSCreateDirectoryProc *fIcreateDirectoryProcfR;	    
    Tcl_FSRemoveDirectoryProc *fIremoveDirectoryProcfR;	    
    Tcl_FSDeleteFileProc *fIdeleteFileProcfR;	    
    Tcl_FSCopyFileProc *fIcopyFileProcfR; 
    Tcl_FSRenameFileProc *fIrenameFileProcfR;	    
    Tcl_FSCopyDirectoryProc *fIcopyDirectoryProcfR;	    
    Tcl_FSLstatProc *fIlstatProcfR;	    
    Tcl_FSLoadFileProc *fIloadFileProcfR; 
    Tcl_FSGetCwdProc *fIgetCwdProcfR;     
    Tcl_FSChdirProc *fIchdirProcfR;	    
} Tcl_Filesystem;
.CE
.PP
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.
.PP
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 fITcl_FSRenameFileProcfR, Tcl's
core will instead fallback on a combination of other filesystem
functions (it will use fITcl_FSCopyFileProcfR followed by
fITcl_FSDeleteFileProcfR, and if fITcl_FSCopyFileProcfR is not
implemented there is a further fallback).  However, if a
fITcl_FSRenameFilefR 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.
.PP
As an example, here is the filesystem lookup table used by the
"vfs" extension which allows filesystem actions to be implemented
in Tcl.
.CS
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 - fallback will occur at Tcl level */
    NULL,
    /* No rename file - fallback will occur at Tcl level */
    NULL,
    /* No copy directory - fallback will occur at Tcl level */
    NULL, 
    /* Core will use stat for lstat */
    NULL,
    /* No load - fallback on core implementation */
    NULL,
    /* We don't need a getcwd or chdir - fallback on Tcl's versions */
    NULL,
    NULL
};
.CE
.PP
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.
.SH TYPENAME
.PP
The fItypeNamefR field contains a null-terminated string that
identifies the type of the filesystem implemented, e.g.
fBnativefR or fBzipfR or fBvfsfR.
.PP
.SH "STRUCTURE LENGTH"
.PP
The fIstructureLengthfR field is generally implemented as
fIsizeof(Tcl_Filesystem)fR, and is there to allow easier
binary backwards compatibility if the size of the structure
changes in a future Tcl release.
.SH VERSION
.PP
The fIversionfR field should be set to fBTCL_FILESYSTEM_VERSION_1fR.
.SH "FILESYSTEM INFRASTRUCTURE"
.PP
These fields contain 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.
.SH PATHINFILESYSTEMPROC
.PP
The fIpathInFilesystemProcfR 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
functions with a path for which this function has returned fBTCL_OKfR.
If the path does not belong, -1 should be returned (the behaviour of Tcl
for any other return value is not defined).  If fBTCL_OKfR is returned,
then the optional fBclientDataPtrfR 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.
.PP
.CS
typedef int Tcl_FSPathInFilesystemProc(
	Tcl_Obj *fIpathPtrfR, 
	ClientData *fIclientDataPtrfR);
.CE
.SH DUPINTERNALREPPROC
.PP
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.
.PP
.CS
typedef ClientData Tcl_FSDupInternalRepProc(
	ClientData fIclientDatafR);
.CE
.SH 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.
.PP
.CS
typedef void Tcl_FSFreeInternalRepProc(
	ClientData fIclientDatafR);
.CE
.SH INTERNALTONORMALIZEDPROC
.PP
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.
.PP
.CS
typedef Tcl_Obj* Tcl_FSInternalToNormalizedProc(
	ClientData fIclientDatafR);
.CE
.SH CREATEINTERNALREPPROC
.PP
Function to take a path object, and calculate an internal
representation for it, and store that native representation in the
object.  May be NULL if paths have no internal representation, or if
the fITcl_FSPathInFilesystemProcfR for this filesystem always
immediately creates an internal representation for paths it accepts.
.PP
.CS
typedef ClientData Tcl_FSCreateInternalRepProc(
	Tcl_Obj *fIpathPtrfR);
.CE
.SH NORMALIZEPATHPROC       
.PP
Function to normalize a path.  Should be implemented for all
filesystems 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.
.PP
.CS
typedef int Tcl_FSNormalizePathProc(
	Tcl_Interp *fIinterpfR, 
	Tcl_Obj *fIpathPtrfR, 
	int fInextCheckpointfR);
.CE
.SH "FILESYSTEM OPERATIONS"
.PP
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 fBreadlinkfR function,
etc.  The Tcl core expects filesystems to behave in this way).
.SH FILESYSTEMPATHTYPEPROC
.PP
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.
.PP
.CS
typedef Tcl_Obj* Tcl_FSFilesystemPathTypeProc(
	Tcl_Obj *fIpathPtrfR);
.CE
.SH FILESYSTEMSEPARATORPROC
.PP
Function to return the separator character(s) for this filesystem.
Must be implemented, otherwise the fBfile separatorfR command will not
function correctly.  The usual return value will be a Tcl_Obj
containing the string "/".
.PP
.CS
typedef Tcl_Obj* Tcl_FSFilesystemSeparatorProc(
	Tcl_Obj *fIpathPtrfR);
.CE
.SH STATPROC 
.PP
Function to process a fBTcl_FSStat()fR call.  Must be implemented for any
reasonable filesystem, since many Tcl level commands depend crucially 
upon it (e.g. fBfile atimefR, fBfile isdirectoryfR, fBfile sizefR,
fBglobfR).
.PP
.CS
typedef int Tcl_FSStatProc(
	Tcl_Obj *fIpathPtrfR,
	Tcl_StatBuf *fIstatPtrfR);
.CE
.PP
The fBTcl_FSStatProcfR fills the stat structure fIstatPtrfR 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 creation
time.
.PP
If the file represented by fIpathPtrfR exists, the
fBTcl_FSStatProcfR returns 0 and the stat structure is filled with
data.  Otherwise, -1 is returned, and no stat info is given.
.SH ACCESSPROC	    
.PP
Function to process a fBTcl_FSAccess()fR call.  Must be implemented for
any reasonable filesystem, since many Tcl level commands depend crucially 
upon it (e.g. fBfile existsfR, fBfile readablefR).
.PP
.CS
typedef int Tcl_FSAccessProc(
	Tcl_Obj *fIpathPtrfR,
	int fImodefR);
.CE
.PP
The fBTcl_FSAccessProcfR checks whether the process would be allowed
to read, write or test for existence of the file (or other file system
object) whose name is pathname.  If pathname is a symbolic link, then
permissions of the file referred by this symbolic link should be tested.
.PP
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.
.PP
.SH OPENFILECHANNELPROC 
.PP
Function to process a fBTcl_FSOpenFileChannel()fR 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. fBopenfR, fBencodingfR, and many Tk commands).
.PP
.CS
typedef Tcl_Channel Tcl_FSOpenFileChannelProc(
	Tcl_Interp *fIinterpfR,
	Tcl_Obj *fIpathPtrfR,
	int fImodefR,
	int fIpermissionsfR);
.CE
.PP
The fBTcl_FSOpenFileChannelProcfR opens a file specified by
fIpathPtrfR and returns a channel handle that can be used to perform
input and output on the file.  This API is modeled after the fBfopenfR
procedure of the Unix standard I/O library.  The syntax and meaning of
all arguments is similar to those given in the Tcl fBopenfR command
when opening a file, where the fImodefR argument is a combination of
the POSIX flags O_RDONLY, O_WRONLY, etc.  If an error occurs while
opening the channel, the fBTcl_FSOpenFileChannelProcfR returns NULL and
records a POSIX error code that can be retrieved with fBTcl_GetErrnofR.
In addition, if fIinterpfR is non-NULL, the
fBTcl_FSOpenFileChannelProcfR leaves an error message in fIinterpfR's
result after any error.
.PP
The newly created channel is not registered in the supplied
interpreter; to register it, use fBTcl_RegisterChannelfR. If one of
the standard channels, fBstdin, stdoutfR or fBstderrfR was
previously closed, the act of creating the new channel also assigns it
as a replacement for the standard channel.
.SH MATCHINDIRECTORYPROC  
.PP
Function to process a fBTcl_FSMatchInDirectory()fR 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).
.PP
.CS
typedef int Tcl_FSMatchInDirectoryProc(
	Tcl_Interp* fIinterpfR, 
	Tcl_Obj *fIresultfR,
	Tcl_Obj *fIpathPtrfR, 
	CONST char *fIpatternfR, 
	Tcl_GlobTypeData * fItypesfR);
.CE
.PP
The function should return all files or directories (or other filesystem
objects) which match the given pattern and accord with the fItypesfR
specification given.  There are two ways in which this function may be
called.  If fIpatternfR is NULL, then fIpathPtrfR is a full path
specification of a single file or directory which should be checked for
existence and correct type.  Otherwise, fIpathPtrfR is a directory, the
contents of which the function should search for files or directories
which have the correct type.  In either case, fIpathPtrfR can be
assumed to be both non-NULL and non-empty.  It is not currently
documented whether fIpathPtrfR will have a file separator at its end of
not, so code should be flexible to both possibilities.
.PP
The return value is a standard Tcl result indicating whether an error
occurred in the matching process.  Error messages are placed in
fIinterpfR; on a fBTCL_OKfR result, results should be added to the
fIresultfR object given (which can be assumed to be a valid
unshared Tcl list).  The matches added
to fIresultfR should include any path prefix given in fIpathPtrfR 
(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.
.PP
The fBTcl_GlobTypeDatafR structure passed in the fItypesfR 
parameter contains the following fields:
.CS
typedef struct Tcl_GlobTypeData {
      /* Corresponds to bcdpfls as in 'find -t' */
      int fItypefR;
      /* Corresponds to file permissions */
      int fIpermfR;
      /* Acceptable mac type */
      Tcl_Obj *fImacTypefR;
      /* Acceptable mac creator */
      Tcl_Obj *fImacCreatorfR;
} Tcl_GlobTypeData;
.CE
.PP
There are two specific cases which it is important to handle correctly,
both when fItypesfR is non-NULL. The two cases are when fItypes->types
& TCL_GLOB_TYPE_DIRfR or fItypes->types & TCL_GLOB_TYPE_MOUNTfR 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 fBTCL_GLOB_TYPE_MOUNTfR, the filesystem must list the mount points
which lie within the given fIpathPtrfR (and in this case, fIpathPtrfR
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.
.SH UTIMEPROC       
.PP
Function to process a fBTcl_FSUtime()fR 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'.
.PP
.CS
typedef int Tcl_FSUtimeProc(
	Tcl_Obj *fIpathPtrfR, 
	struct utimbuf *fItvalfR);
.CE
.PP
The access and modification times of the file specified by fIpathPtrfR
should be changed to the values given in the fItvalfR structure.
.PP
The return value is a standard Tcl result indicating whether an error
occurred in the process.
.SH LINKPROC 
.PP
Function to process a fBTcl_FSLink()fR call.  Should be implemented
only if the filesystem supports links, and may otherwise be NULL.
.PP
.CS
typedef Tcl_Obj* Tcl_FSLinkProc(
	Tcl_Obj *fIlinkNamePtrfR,
	Tcl_Obj *fItoPtrfR,
	int fIlinkActionfR);
.CE
.PP
If fItoPtrfR 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 fIlinkNamePtrfR, 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 fItoPtrfR 
is not NULL, the function should attempt to create a link.  The result
in this case should be fItoPtrfR if the link was successful and NULL
otherwise.  In this case the result is not owned by the caller. See
the documentation for fBTcl_FSLinkfR for the correct interpretation
of the fIlinkActionfR flags.
.SH LISTVOLUMESPROC	    
.PP
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'.
.PP
.CS
typedef Tcl_Obj* Tcl_FSListVolumesProc(void);
.CE
.PP
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).
.PP
Therefore, Tcl considers return values from this proc to be read-only.
.PP
.SH FILEATTRSTRINGSPROC
.PP
Function to list all attribute strings which are valid for this
filesystem.  If not implemented the filesystem will not support
the fBfile attributesfR 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 fBgetfR and fBsetfR
methods.
.PP
.CS
typedef CONST char** Tcl_FSFileAttrStringsProc(
	Tcl_Obj *fIpathPtrfR, 
	Tcl_Obj** fIobjPtrReffR);
.CE
.PP
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 refCount before using it.
On completion of that use, Tcl will decrement its refCount.  Hence if
the list should be disposed of by Tcl when done, it should have a
refCount of zero, and if the list should not be disposed of, the
filesystem should ensure it retains a refCount on the object.
.SH FILEATTRSGETPROC
.PP
Function to process a fBTcl_FSFileAttrsGet()fR call, used by 'file
attributes'.
.PP
.CS
typedef int Tcl_FSFileAttrsGetProc(
	Tcl_Interp *fIinterpfR,
	int fIindexfR, 
	Tcl_Obj *fIpathPtrfR,
	Tcl_Obj **fIobjPtrReffR);
.CE
.PP
Returns a standard Tcl return code.  The attribute value retrieved,
which corresponds to the fIindexfR'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 refCount of zero.  Either
way we must either store it somewhere (e.g. the Tcl result), or
Incr/Decr its refCount to ensure it is properly freed.
.SH FILEATTRSSETPROC
.PP
Function to process a fBTcl_FSFileAttrsSet()fR call, used by 'file
attributes'.  If the filesystem is read-only, there is no need
to implement this.
.PP
.CS
typedef int Tcl_FSFileAttrsSetProc(
	Tcl_Interp *fIinterpfR,
	int fIindexfR, 
	Tcl_Obj *fIpathPtrfR,
	Tcl_Obj *fIobjPtrfR);
.CE
.PP
The attribute value of the fIindexfR'th element in the list returned by
the Tcl_FSFileAttrStringsProc should be set to the fIobjPtrfR given.
.SH CREATEDIRECTORYPROC	    
.PP
Function to process a fBTcl_FSCreateDirectory()fR call.  Should be
implemented unless the FS is read-only.
.PP
.CS
typedef int Tcl_FSCreateDirectoryProc(
	Tcl_Obj *fIpathPtrfR);
.CE
.PP
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
fIpathPtrfR.
.SH REMOVEDIRECTORYPROC	    
.PP
Function to process a 'Tcl_FSRemoveDirectory()' call.  Should be
implemented unless the FS is read-only.
.PP
.CS
typedef int Tcl_FSRemoveDirectoryProc(
	Tcl_Obj *fIpathPtrfR,
	int fIrecursivefR, 
	Tcl_Obj **fIerrorPtrfR);
.CE
.PP
The return value is a standard Tcl result indicating whether an error
occurred in the process.  If successful, the directory specified by
fIpathPtrfR should have been removed from the filesystem.  If the
fIrecursivefR flag is given, then a non-empty directory should
be deleted without error.  If an error does occur, the name of
the file or directory which caused the error should be placed in
fIerrorPtrfR.
.SH DELETEFILEPROC	    
.PP
Function to process a fBTcl_FSDeleteFile()fR call.  Should be implemented
unless the FS is read-only.
.PP
.CS
typedef int Tcl_FSDeleteFileProc(
	Tcl_Obj *fIpathPtrfR);
.CE
.PP
The return value is a standard Tcl result indicating whether an error
occurred in the process.  If successful, the file specified by
fIpathPtrfR 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).
.SH "FILESYSTEM EFFICIENCY"
.PP
.SH LSTATPROC	    
.PP
Function to process a fBTcl_FSLstat()fR call.  If not implemented, Tcl
will attempt to use the fIstatProcfR defined above instead.  Therefore
it need only be implemented if a filesystem can differentiate between
fBstatfR and fBlstatfR calls.
.PP
.CS
typedef int Tcl_FSLstatProc(
	Tcl_Obj *fIpathPtrfR, 
	Tcl_StatBuf *fIstatPtrfR);
.CE
.PP
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.
.PP
.SH COPYFILEPROC 
.PP
Function to process a fBTcl_FSCopyFile()fR 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.
.PP
.CS
typedef int Tcl_FSCopyFileProc(
	Tcl_Obj *fIsrcPathPtrfR,
	Tcl_Obj *fIdestPathPtrfR);
.CE
.PP
The return value is a standard Tcl result indicating whether an error
occurred in the copying process.  Note that, fIdestPathPtrfR is the
name of the file which should become the copy of fIsrcPathPtrfR. It
is never the name of a directory into which fIsrcPathPtrfR 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 Tcl_FSCopyDirectoryProc when needed to copy them
(even if they are symbolic links to directories).
.SH RENAMEFILEPROC	    
.PP
Function to process a fBTcl_FSRenameFile()fR 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.
.PP
.CS
typedef int Tcl_FSRenameFileProc(
	Tcl_Obj *fIsrcPathPtrfR,
	Tcl_Obj *fIdestPathPtrfR);
.CE
.PP
The return value is a standard Tcl result indicating whether an error
occurred in the renaming process.
.SH COPYDIRECTORYPROC	    
.PP
Function to process a fBTcl_FSCopyDirectory()fR call.  If not
implemented, Tcl will fall back on a recursive create-dir, file copy
mechanism.  Therefore it need only be implemented if the filesystem can
perform that action more efficiently.
.PP
.CS
typedef int Tcl_FSCopyDirectoryProc(
	Tcl_Obj *fIsrcPathPtrfR,
	Tcl_Obj *fIdestPathPtrfR, 
	Tcl_Obj **fIerrorPtrfR);
.CE
.PP
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
fIerrorPtrfR. Note that, fIdestPathPtrfR is the name of the
directory-name which should become the mirror-image of
fIsrcPathPtrfR. It is not the name of a directory into which
fIsrcPathPtrfR should be copied (i.e. the function is much simpler
than the Tcl level 'file copy' subcommand).
.SH LOADFILEPROC 
.PP
Function to process a fBTcl_FSLoadFile()fR 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.
.PP
.CS
typedef int Tcl_FSLoadFileProc(
	Tcl_Interp * fIinterpfR, 
	Tcl_Obj *fIpathPtrfR, 
	Tcl_LoadHandle * fIhandlePtrfR,
	Tcl_FSUnloadFileProc * fIunloadProcPtrfR);
.CE
.PP
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 fIhandlePtrfR should be filled with a token for 
the dynamically loaded file, and the fIunloadProcPtrfR should be
filled in with the address of a procedure.  The procedure will be
called with the given Tcl_LoadHandle as its only parameter when Tcl 
needs to unload the file.
.SH UNLOADFILEPROC	    
.PP
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.
.PP
.CS
typedef void Tcl_FSUnloadFileProc(
	Tcl_LoadHandle fIloadHandlefR);
.CE
.SH GETCWDPROC     
.PP
Function to process a fBTcl_FSGetCwd()fR call.  Most filesystems need not
implement this.  It will usually only be called once, if 'getcwd' is
called before 'chdir'.  May be NULL.
.PP
.CS
typedef Tcl_Obj* Tcl_FSGetCwdProc(
	Tcl_Interp *fIinterpfR);
.CE
.PP
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.
.PP
.SH CHDIRPROC	    
.PP
Function to process a fBTcl_FSChdir()fR 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 dirName is a valid,
accessible directory in their filesystem.  They need not remember the
result, since that will be automatically remembered for use by GetCwd.
Real filesystems should carry out the correct action (i.e. call the
correct system 'chdir' api).
.PP
.CS
typedef int Tcl_FSChdirProc(
	Tcl_Obj *fIpathPtrfR);
.CE
.PP
The fBTcl_FSChdirProcfR changes the applications current working
directory to the value specified in fIpathPtrfR. The function returns
-1 on error or 0 on success.
.SH KEYWORDS
stat access filesystem vfs

						