Provided by: tcl8.6-doc_8.6.14+dfsg-1build1_all bug

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                                                                                                       2
       Tcl_FSUnloadFile(interp, loadHandle)                                                                      2

       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                                                                                               2
       Tcl_GetAccessTimeFromStat(statPtr)                                                                        2

       unsigned                                                                                                  2
       Tcl_GetBlockSizeFromStat(statPtr)                                                                         2

       Tcl_WideUInt                                                                                              2
       Tcl_GetBlocksFromStat(statPtr)                                                                            2

       Tcl_WideInt                                                                                               2
       Tcl_GetChangeTimeFromStat(statPtr)                                                                        2

       int                                                                                                       2
       Tcl_GetDeviceTypeFromStat(statPtr)                                                                        2

       unsigned                                                                                                  2
       Tcl_GetFSDeviceFromStat(statPtr)                                                                          2

       unsigned                                                                                                  2
       Tcl_GetFSInodeFromStat(statPtr)                                                                           2

       int                                                                                                       2
       Tcl_GetGroupIdFromStat(statPtr)                                                                           2

       int                                                                                                       2
       Tcl_GetLinkCountFromStat(statPtr)                                                                         2

       unsigned                                                                                                  2
       Tcl_GetModeFromStat(statPtr)                                                                              2

       Tcl_WideInt                                                                                               2
       Tcl_GetModificationTimeFromStat(statPtr)                                                                  2

       Tcl_WideUInt                                                                                              2
       Tcl_GetSizeFromStat(statPtr)                                                                              2

       int                                                                                                       2
       Tcl_GetUserIdFromStat(statPtr)                                                                            2

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)                    Preallocated    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. Tcl_FSAccess and Tcl_FSStat) rather
       than calling system level functions like access and stat directly. First, they will work  cross-platform,
       so  an  extension  which  calls  them  should  work  unmodified  on Unix and Windows. Second, the Windows
       implementation of some of these functions fixes some  bugs  in  the  system  level  calls.  Third,  these
       function  calls  deal  with  any “Utf to platform-native” path conversions which may be required (and may
       cache the results of such conversions for greater efficiency on subsequent calls).  Fourth,  and  perhaps
       most importantly, all of these functions are “virtual filesystem aware”.  Any virtual filesystem (VFS for
       short) which has been registered (through Tcl_FSRegister) may reroute file access to alternative media or
       access  methods. This means that all of these functions (and therefore the corresponding file, glob, pwd,
       cd, open, etc. Tcl commands) may be operate  on  “files”  which  are  not  native  files  in  the  native
       filesystem.  This  also means that any Tcl extension which accesses the filesystem (FS for short) through
       this API is automatically “virtual filesystem aware”.  Of course, if an  extension  accesses  the  native
       filesystem directly (through platform-specific APIs, for example), then Tcl cannot intercept such calls.

       If  appropriate  VFSes  have  been  registered,  the  “files”  may,  to  give  two  examples,  be  remote
       (e.g. situated on a remote ftp server) or archived (e.g. lying inside a .zip  archive).  Such  registered
       filesystems  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

              Tcl_Obj *path = Tcl_NewStringObj(...);
              Tcl_FSWhatever(path);
              Tcl_DecrRefCount(path);

       is wrong, and may cause memory errors. The path must have its reference count incremented before  passing
       it  in,  or decrementing it. For this reason, 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.

   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”).

       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 2
       operation,  asking for the library indicated by the loadHandle to be removed from the process. Note that, 2
       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.           2

       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
       OR'ed 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. 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
       value type.

       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

   PORTABLE STAT RESULT API
       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 2
       value of the corresponding field listed in the table below. Note that on  some  platforms  there  may  be 2
       other  fields in the Tcl_StatBuf as it is an alias for a suitable system structure, but only the portable 2
       ones are made available here. See your system documentation for a full description of these fields.       2

              Access Function                    Field                                                           2
               Tcl_GetFSDeviceFromStat             st_dev                                                        2
               Tcl_GetFSInodeFromStat              st_ino                                                        2
               Tcl_GetModeFromStat                 st_mode                                                       2
               Tcl_GetLinkCountFromStat            st_nlink                                                      2
               Tcl_GetUserIdFromStat               st_uid                                                        2
               Tcl_GetGroupIdFromStat              st_gid                                                        2
               Tcl_GetDeviceTypeFromStat           st_rdev                                                       2
               Tcl_GetAccessTimeFromStat           st_atime                                                      2
               Tcl_GetModificationTimeFromStat     st_mtime                                                      2
               Tcl_GetChangeTimeFromStat           st_ctime                                                      2
               Tcl_GetSizeFromStat                 st_size                                                       2
               Tcl_GetBlocksFromStat               st_blocks                                                     2
               Tcl_GetBlockSizeFromStat            st_blksize                                                    2

THE VIRTUAL FILESYSTEM API

       A filesystem provides a Tcl_Filesystem structure that contains pointers to functions that  implement  the
       various  operations  on  a filesystem; these operations are invoked as needed by the generic layer, which
       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
       The Tcl_Filesystem structure contains the following fields:

              typedef struct Tcl_Filesystem {
                  const char *typeName;
                  int structureLength;
                  Tcl_FSVersion version;
                  Tcl_FSPathInFilesystemProc *pathInFilesystemProc;
                  Tcl_FSDupInternalRepProc *dupInternalRepProc;
                  Tcl_FSFreeInternalRepProc *freeInternalRepProc;
                  Tcl_FSInternalToNormalizedProc *internalToNormalizedProc;
                  Tcl_FSCreateInternalRepProc *createInternalRepProc;
                  Tcl_FSNormalizePathProc *normalizePathProc;
                  Tcl_FSFilesystemPathTypeProc *filesystemPathTypeProc;
                  Tcl_FSFilesystemSeparatorProc *filesystemSeparatorProc;
                  Tcl_FSStatProc *statProc;
                  Tcl_FSAccessProc *accessProc;
                  Tcl_FSOpenFileChannelProc *openFileChannelProc;
                  Tcl_FSMatchInDirectoryProc *matchInDirectoryProc;
                  Tcl_FSUtimeProc *utimeProc;
                  Tcl_FSLinkProc *linkProc;
                  Tcl_FSListVolumesProc *listVolumesProc;
                  Tcl_FSFileAttrStringsProc *fileAttrStringsProc;
                  Tcl_FSFileAttrsGetProc *fileAttrsGetProc;
                  Tcl_FSFileAttrsSetProc *fileAttrsSetProc;
                  Tcl_FSCreateDirectoryProc *createDirectoryProc;
                  Tcl_FSRemoveDirectoryProc *removeDirectoryProc;
                  Tcl_FSDeleteFileProc *deleteFileProc;
                  Tcl_FSCopyFileProc *copyFileProc;
                  Tcl_FSRenameFileProc *renameFileProc;
                  Tcl_FSCopyDirectoryProc *copyDirectoryProc;
                  Tcl_FSLstatProc *lstatProc;
                  Tcl_FSLoadFileProc *loadFileProc;
                  Tcl_FSGetCwdProc *getCwdProc;
                  Tcl_FSChdirProc *chdirProc;
              } Tcl_Filesystem;

       Except for the first three fields in this structure which  contain  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.

   EXAMPLE FILESYSTEM DEFINITION
       Here  is  the  filesystem  lookup table used by the “vfs” extension which allows filesystem actions to be
       implemented in Tcl.

              static Tcl_Filesystem vfsFilesystem = {
                  "tclvfs",
                  sizeof(Tcl_Filesystem),
                  TCL_FILESYSTEM_VERSION_1,
                  &VfsPathInFilesystem,
                  &VfsDupInternalRep,
                  &VfsFreeInternalRep,
                  /* No internal to normalized, since we don't create
                   * any pure 'internal' Tcl_Obj path representations */
                  NULL,
                  /* No create native rep function, since we don't use
                   * it and don't choose to support uses of
                   * Tcl_FSNewNativePath */
                  NULL,
                  /* Normalize path isn't needed - we assume paths only
                   * have one representation */
                  NULL,
                  &VfsFilesystemPathType,
                  &VfsFilesystemSeparator,
                  &VfsStat,
                  &VfsAccess,
                  &VfsOpenFileChannel,
                  &VfsMatchInDirectory,
                  &VfsUtime,
                  /* We choose not to support symbolic links inside our
                   * VFS's */
                  NULL,
                  &VfsListVolumes,
                  &VfsFileAttrStrings,
                  &VfsFileAttrsGet,
                  &VfsFileAttrsSet,
                  &VfsCreateDirectory,
                  &VfsRemoveDirectory,
                  &VfsDeleteFile,
                  /* No copy file; use the core fallback mechanism */
                  NULL,
                  /* No rename file; use the core fallback mechanism */
                  NULL,
                  /* No copy directory; use the core fallback mechanism */
                  NULL,
                  /* Core will use stat for lstat */
                  NULL,
                  /* No load; use the core fallback mechanism */
                  NULL,
                  /* We don't need a getcwd or chdir; the core's own
                   * internal value is suitable */
                  NULL,
                  NULL
              };

FILESYSTEM INFRASTRUCTURE

       These fields contain basic information about the filesystem structure and addresses  of  functions  which
       are  used  to  associate a particular filesystem with a file path, and deal with the internal handling of
       path representations, for example copying and freeing such representations.

   TYPENAME
       The typeName field contains  a  null-terminated  string  that  identifies  the  type  of  the  filesystem
       implemented, e.g.  “native”, “zip” or “vfs”.

   STRUCTURE LENGTH
       The  structureLength  field  is  generally  implemented  as sizeof(Tcl_Filesystem), and is there to allow
       easier binary backwards compatibility if the size of the structure changes in a future Tcl release.

   VERSION
       The version field should be set to TCL_FILESYSTEM_VERSION_1.

   PATHINFILESYSTEMPROC
       The pathInFilesystemProc field contains the address of a function which is called to determine whether  a
       given  path  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.

              typedef int Tcl_FSPathInFilesystemProc(
                      Tcl_Obj *pathPtr,
                      ClientData *clientDataPtr);

   DUPINTERNALREPPROC
       This function makes a copy of a path's internal representation, and is called when Tcl needs to duplicate
       a path value. If NULL, Tcl will simply not copy the internal representation, which may then  need  to  be
       regenerated later.

              typedef ClientData Tcl_FSDupInternalRepProc(
                      ClientData clientData);

   FREEINTERNALREPPROC
       Free  the  internal  representation.  This  must  be implemented if internal representations need freeing
       (i.e. if some memory is allocated when an internal representation is generated),  but  may  otherwise  be
       NULL.

              typedef void Tcl_FSFreeInternalRepProc(
                      ClientData clientData);

   INTERNALTONORMALIZEDPROC
       Function to convert internal representation to a normalized path. Only required if the filesystem creates
       pure  path  values  with  no  string/path  representation.  The  return value is a Tcl value whose string
       representation is the normalized path.

              typedef Tcl_Obj *Tcl_FSInternalToNormalizedProc(
                      ClientData clientData);

   CREATEINTERNALREPPROC
       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.

              typedef ClientData Tcl_FSCreateInternalRepProc(
                      Tcl_Obj *pathPtr);

   NORMALIZEPATHPROC
       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.

              typedef int Tcl_FSNormalizePathProc(
                      Tcl_Interp *interp,
                      Tcl_Obj *pathPtr,
                      int nextCheckpoint);

FILESYSTEM OPERATIONS

       The fields in this section of the structure contain addresses of 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).

   FILESYSTEMPATHTYPEPROC
       Function to determine the type of a path in  this  filesystem.  May  be  NULL,  in  which  case  no  type
       information  will  be  available  to  users  of the filesystem. The “type” is used only for informational
       purposes, and should be returned as the string representation of the Tcl_Obj which is returned. A typical
       return value might be “networked”, “zip” or “ftp”.  The Tcl_Obj result is owned by the filesystem and  so
       Tcl will increment the reference count of that value if it wishes to retain a reference to it.

              typedef Tcl_Obj *Tcl_FSFilesystemPathTypeProc(
                      Tcl_Obj *pathPtr);

   FILESYSTEMSEPARATORPROC
       Function  to return the separator character(s) for this filesystem.  This need only be implemented if the
       filesystem wishes to use a 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.

              typedef Tcl_Obj *Tcl_FSFilesystemSeparatorProc(
                      Tcl_Obj *pathPtr);

   STATPROC
       Function  to process a Tcl_FSStat call. Must be implemented for any reasonable filesystem, since many Tcl
       level commands depend crucially upon it (e.g. file atime, file isdirectory, file size, glob).

              typedef int Tcl_FSStatProc(
                      Tcl_Obj *pathPtr,
                      Tcl_StatBuf *statPtr);

       The Tcl_FSStatProc fills the stat structure statPtr with information about the specified file. You do not
       need any access rights to the file to get this information but you need search rights to all  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.

   ACCESSPROC
       Function to process a Tcl_FSAccess call. Must be implemented for any reasonable  filesystem,  since  many
       Tcl level commands depend crucially upon it (e.g. file exists, file readable).

              typedef int Tcl_FSAccessProc(
                      Tcl_Obj *pathPtr,
                      int mode);

       The  Tcl_FSAccessProc checks whether the process would be allowed to read, write or test for existence of
       the file (or other filesystem object) whose name is in pathPtr. If the  pathname  refers  to  a  symbolic
       link, then the permissions of the file referred by this symbolic link should be tested.

       On  success  (all  requested  permissions  granted), zero is returned. On error (at least one bit in mode
       asked for a permission that is denied, or some other  error occurred), -1 is returned.

   OPENFILECHANNELPROC
       Function to process a Tcl_FSOpenFileChannel call. Must be  implemented  for  any  reasonable  filesystem,
       since  any operations which require open or accessing a file's contents will use it (e.g. open, encoding,
       and many Tk commands).

              typedef Tcl_Channel Tcl_FSOpenFileChannelProc(
                      Tcl_Interp *interp,
                      Tcl_Obj *pathPtr,
                      int mode,
                      int permissions);

       The Tcl_FSOpenFileChannelProc opens a file specified by pathPtr and returns a channel handle that can  be
       used  to  perform input and output on the file. This API is modeled after the fopen procedure of the Unix
       standard I/O library. The syntax and meaning of all arguments is 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.

   MATCHINDIRECTORYPROC
       Function  to  process  a  Tcl_FSMatchInDirectory  call.  If not implemented, then glob and recursive copy
       functionality will be lacking in the filesystem (and this may impact commands like encoding  names  which
       use glob functionality internally).

              typedef int Tcl_FSMatchInDirectoryProc(
                      Tcl_Interp *interp,
                      Tcl_Obj *resultPtr,
                      Tcl_Obj *pathPtr,
                      const char *pattern,
                      Tcl_GlobTypeData *types);

       The  function  should return all files or directories (or other 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:

              typedef struct Tcl_GlobTypeData {
                  /* Corresponds to bcdpfls as in 'find -t' */
                  int type;
                  /* Corresponds to file permissions */
                  int perm;
                  /* Acceptable mac type */
                  Tcl_Obj *macType;
                  /* Acceptable mac creator */
                  Tcl_Obj *macCreator;
              } Tcl_GlobTypeData;

       There  are two specific cases which it is important to handle correctly, both when types is non-NULL. The
       two cases are when types->types & TCL_GLOB_TYPE_DIR or types->types & TCL_GLOB_TYPE_MOUNT are  true  (and
       in  particular  when  the other flags are false). In the first of these cases, the function must list the
       contained directories. Tcl uses this to implement recursive globbing, so it is critical that  filesystems
       implement  directory  matching  correctly.  In  the  second of these cases, with TCL_GLOB_TYPE_MOUNT, the
       filesystem must list the mount points which lie within the given pathPtr (and in this case, pathPtr  need
       not  lie  within  the  same  filesystem - different to all other cases in which this function is called).
       Support for this is critical if Tcl is to have  seamless  transitions  between  from  one  filesystem  to
       another.

   UTIMEPROC
       Function to process a Tcl_FSUtime call. Required to allow setting (not reading) of times with file mtime,
       file atime and the open-r/open-w/fcopy implementation of file copy.

              typedef int Tcl_FSUtimeProc(
                      Tcl_Obj *pathPtr,
                      struct utimbuf *tval);

       The  access and modification times of the file specified by pathPtr should be changed to the values given
       in the tval structure.

       The return value should be 0 on success and -1 on an error, as with the system utime.

   LINKPROC
       Function to process a Tcl_FSLink call. Should be implemented only if the filesystem supports  links,  and
       may otherwise be NULL.

              typedef Tcl_Obj *Tcl_FSLinkProc(
                      Tcl_Obj *linkNamePtr,
                      Tcl_Obj *toPtr,
                      int linkAction);

       If  toPtr  is  NULL,  the function is being asked to read the contents of a link. The result is a Tcl_Obj
       specifying the contents of the link given by linkNamePtr, or NULL if the link  could  not  be  read.  The
       result  is  owned  by  the  caller  (and  should  therefore  have  its ref count incremented before being
       returned). Any callers should call Tcl_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.

   LISTVOLUMESPROC
       Function  to  list  any  filesystem  volumes added by this filesystem.  Should be implemented only if the
       filesystem adds volumes at the head of the filesystem, so that they can be returned by file volumes.

              typedef Tcl_Obj *Tcl_FSListVolumesProc(void);

       The result should be a list of volumes added by this filesystem, or NULL (or an empty list) if no volumes
       are provided. The result 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  “global  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 global
       list and pass it to Tcl which will copy the contents and then decrement the count back to where it was).

       Therefore, Tcl considers return values from this proc to be read-only.

   FILEATTRSTRINGSPROC
       Function to list all attribute strings which are valid  for  this  filesystem.  If  not  implemented  the
       filesystem  will not support the file attributes command. This allows arbitrary additional information to
       be attached to files in the filesystem. If it is not implemented, there is no need to implement  the  get
       and set methods.

              typedef const char *const *Tcl_FSFileAttrStringsProc(
                      Tcl_Obj *pathPtr,
                      Tcl_Obj **objPtrRef);

       The  called  function  may  either return an array of strings, or may instead return NULL and place a Tcl
       list into the given objPtrRef. Tcl will take that list and first increment  its  reference  count  before
       using it.  On completion of that use, Tcl will decrement its reference count. Hence if the list should be
       disposed  of  by  Tcl  when done, it should have a reference count of zero, and if the list should not be
       disposed of, the filesystem should ensure it returns a value with a reference count of at least one.

   FILEATTRSGETPROC
       Function to process a Tcl_FSFileAttrsGet call, used by file attributes.

              typedef int Tcl_FSFileAttrsGetProc(
                      Tcl_Interp *interp,
                      int index,
                      Tcl_Obj *pathPtr,
                      Tcl_Obj **objPtrRef);

       Returns a standard Tcl return code. The attribute value retrieved,  which  corresponds  to  the  index'th
       element  in  the  list  returned  by  the Tcl_FSFileAttrStringsProc, is a Tcl_Obj placed in objPtrRef (if
       TCL_OK was returned) and is likely to have a reference count of zero. Either way we must either store  it
       somewhere (e.g. the Tcl result), or Incr/Decr its reference count to ensure it is properly freed.

   FILEATTRSSETPROC
       Function  to  process a Tcl_FSFileAttrsSet call, used by file attributes. If the filesystem is read-only,
       there is no need to implement this.

              typedef int Tcl_FSFileAttrsSetProc(
                      Tcl_Interp *interp,
                      int index,
                      Tcl_Obj *pathPtr,
                      Tcl_Obj *objPtr);

       The attribute value of the index'th element in the list returned by the Tcl_FSFileAttrStringsProc  should
       be set to the objPtr given.

   CREATEDIRECTORYPROC
       Function to process a Tcl_FSCreateDirectory call. Should be implemented unless the FS is read-only.

              typedef int Tcl_FSCreateDirectoryProc(
                      Tcl_Obj *pathPtr);

       The  return  value  is  a  standard  Tcl  result  indicating whether an error occurred in the process. If
       successful, a new directory should have been added  to  the  filesystem  in  the  location  specified  by
       pathPtr.

   REMOVEDIRECTORYPROC
       Function to process a Tcl_FSRemoveDirectory call. Should be implemented unless the FS is read-only.

              typedef int Tcl_FSRemoveDirectoryProc(
                      Tcl_Obj *pathPtr,
                      int recursive,
                      Tcl_Obj **errorPtr);

       The  return  value  is  a  standard  Tcl  result  indicating whether an error occurred in the process. If
       successful, the directory specified by pathPtr should have been  removed  from  the  filesystem.  If  the
       recursive  flag is given, then a non-empty directory should be deleted without error. If this flag is not
       given, then and the directory is non-empty a POSIX “EEXIST” error should be signaled. If  an  error  does
       occur, the name of the file or directory which caused the error should be placed in errorPtr.

   DELETEFILEPROC
       Function to process a Tcl_FSDeleteFile call. Should be implemented unless the FS is read-only.

              typedef int Tcl_FSDeleteFileProc(
                      Tcl_Obj *pathPtr);

       The  return  value  is  a  standard  Tcl  result  indicating whether an error occurred in the process. If
       successful, the file specified by pathPtr should have been removed from the filesystem. Note that, if the
       filesystem supports symbolic links, Tcl will always call this function and not  Tcl_FSRemoveDirectoryProc
       when needed to delete them (even if they are symbolic links to directories).

FILESYSTEM EFFICIENCY

       These  functions  need  not  be  implemented  for a particular filesystem because the core has a fallback
       implementation available. See each individual description for the consequences of leaving the field NULL.

   LSTATPROC
       Function to process a Tcl_FSLstat call. If not implemented, Tcl will attempt to use the statProc  defined
       above  instead.  Therefore it need only be implemented if a filesystem can differentiate between stat and
       lstat calls.

              typedef int Tcl_FSLstatProc(
                      Tcl_Obj *pathPtr,
                      Tcl_StatBuf *statPtr);

       The behavior of this function is very similar to that of the Tcl_FSStatProc defined above, except that if
       it is applied to a symbolic link, it returns information about the link, not about the target file.

   COPYFILEPROC
       Function to process a Tcl_FSCopyFile call. If not implemented Tcl will fall back on  open-r,  open-w  and
       fcopy  as  a copying mechanism.  Therefore it need only be implemented if the filesystem can perform that
       action more efficiently.

              typedef int Tcl_FSCopyFileProc(
                      Tcl_Obj *srcPathPtr,
                      Tcl_Obj *destPathPtr);

       The return value is a standard Tcl result indicating whether an error occurred in  the  copying  process.
       Note  that,  destPathPtr  is the name of the file which should become the copy of srcPathPtr. It is never
       the name of a directory into which srcPathPtr could be copied (i.e. the function is much simpler than the
       Tcl level file copy subcommand). Note that, if the filesystem supports symbolic links,  Tcl  will  always
       call this function and not copyDirectoryProc when needed to copy them (even if they are symbolic links to
       directories).  Finally,  if  the  filesystem  determines  it cannot support the file copy action, calling
       Tcl_SetErrno(EXDEV) and returning a non-TCL_OK  result  will  tell  Tcl  to  use  its  standard  fallback
       mechanisms.

   RENAMEFILEPROC
       Function  to process a Tcl_FSRenameFile call. If not implemented, Tcl will fall back on a copy and delete
       mechanism. Therefore it need only  be  implemented  if  the  filesystem  can  perform  that  action  more
       efficiently.

              typedef int Tcl_FSRenameFileProc(
                      Tcl_Obj *srcPathPtr,
                      Tcl_Obj *destPathPtr);

       The  return  value is a standard Tcl result indicating whether an error occurred in the renaming process.
       If the filesystem determines it 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.

   COPYDIRECTORYPROC
       Function  to  process  a  Tcl_FSCopyDirectory call. If not implemented, Tcl will fall back on a recursive
       file mkdir, file copy mechanism. Therefore it need only be implemented if the filesystem can perform that
       action more efficiently.

              typedef int Tcl_FSCopyDirectoryProc(
                      Tcl_Obj *srcPathPtr,
                      Tcl_Obj *destPathPtr,
                      Tcl_Obj **errorPtr);

       The return value is a standard Tcl result indicating whether an error occurred in the copying process. If
       an error does occur, the name of the file or directory  which  caused  the  error  should  be  placed  in
       errorPtr.  Note  that, destPathPtr is the name of the directory-name which should become the mirror-image
       of srcPathPtr. It is not the name of a  directory  into  which  srcPathPtr  should  be  copied  (i.e. the
       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.

   LOADFILEPROC
       Function  to  process  a Tcl_FSLoadFile call. If not implemented, Tcl will fall back on a copy to native-
       temp followed by a Tcl_FSLoadFile on that temporary copy. Therefore it need only be  implemented  if  the
       filesystem  can  load  code directly, or it can be implemented simply to return TCL_ERROR to disable load
       functionality in this filesystem entirely.

              typedef int Tcl_FSLoadFileProc(
                      Tcl_Interp *interp,
                      Tcl_Obj *pathPtr,
                      Tcl_LoadHandle *handlePtr,
                      Tcl_FSUnloadFileProc *unloadProcPtr);

       Returns a standard Tcl completion code. If an error occurs, an error message  is  left  in  the  interp's
       result.  The  function  dynamically  loads  a  binary  code  file  into memory. On a successful load, the
       handlePtr should be filled with a token for the dynamically loaded file, and the unloadProcPtr should  be
       filled  in  with  the  address  of  a  procedure.   The  unload  procedure  will be called with the given
       Tcl_LoadHandle as its only parameter when Tcl needs to unload the  file.  For  example,  for  the  native
       filesystem,  the  Tcl_LoadHandle  returned  is  currently  a  token  which  can  be  used  in the private
       TclpFindSymbol to access functions in the new code. Each filesystem is free to define the  Tcl_LoadHandle
       as  it  requires.  Finally,  if the filesystem determines it cannot support the file load action, calling
       Tcl_SetErrno(EXDEV) and returning a non-TCL_OK  result  will  tell  Tcl  to  use  its  standard  fallback
       mechanisms.

   UNLOADFILEPROC
       Function  to unload a previously successfully loaded file. If load was implemented, then this should also
       be implemented, if there is any cleanup action required.

              typedef void Tcl_FSUnloadFileProc(
                      Tcl_LoadHandle loadHandle);

   GETCWDPROC
       Function to process a Tcl_FSGetCwd call. Most filesystems need not implement this. It will  usually  only
       be called once, if getcwd is called before chdir. May be NULL.

              typedef Tcl_Obj *Tcl_FSGetCwdProc(
                      Tcl_Interp *interp);

       If  the  filesystem  supports  a native notion of a current working 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.

   CHDIRPROC
       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).

              typedef int Tcl_FSChdirProc(
                      Tcl_Obj *pathPtr);

       The Tcl_FSChdirProc changes the applications current working directory to the value specified in pathPtr.
       The function returns -1 on error or 0 on success.

SEE ALSO

       cd(3tcl), file(3tcl), filename(3tcl), load(3tcl), open(3tcl), pwd(3tcl), source(3tcl), unload(3tcl)

KEYWORDS

       stat, access, filesystem, vfs, virtual filesystem

Tcl                                                    8.4                                      Filesystem(3tcl)