diff options
Diffstat (limited to 'generic/tclIOUtil.c')
| -rw-r--r-- | generic/tclIOUtil.c | 1749 |
1 files changed, 884 insertions, 865 deletions
diff --git a/generic/tclIOUtil.c b/generic/tclIOUtil.c index 124da3a..78cc0ff 100644 --- a/generic/tclIOUtil.c +++ b/generic/tclIOUtil.c @@ -5,7 +5,7 @@ * code, which supports a pluggable filesystem architecture allowing both * platform specific filesystems and 'virtual filesystems'. All * filesystem access should go through the functions defined in this - * file. Most of this code was contributed by Vince Darley. + * file. Most of this code was contributed by Vince Darley. * * Parts of this file are based on code contributed by Karl Lehenbauer, * Mark Diekhans and Peter da Silva. @@ -17,7 +17,7 @@ * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclIOUtil.c,v 1.123 2005/09/14 17:13:18 dgp Exp $ + * RCS: @(#) $Id: tclIOUtil.c,v 1.124 2005/11/01 15:30:52 dkf Exp $ */ #include "tclInt.h" @@ -27,29 +27,26 @@ #include "tclFileSystem.h" /* - * Prototypes for procedures defined later in this file. + * Prototypes for functions defined later in this file. */ -static FilesystemRecord * FsGetFirstFilesystem _ANSI_ARGS_((void)); -static void FsThrExitProc _ANSI_ARGS_((ClientData cd)); -static Tcl_Obj* FsListMounts _ANSI_ARGS_((Tcl_Obj *pathPtr, - CONST char *pattern)); -static void FsAddMountsToGlobResult _ANSI_ARGS_(( - Tcl_Obj *resultPtr, Tcl_Obj *pathPtr, - CONST char *pattern, - Tcl_GlobTypeData *types)); -static void FsUpdateCwd _ANSI_ARGS_((Tcl_Obj *cwdObj, - ClientData clientData)); +static FilesystemRecord*FsGetFirstFilesystem(void); +static void FsThrExitProc(ClientData cd); +static Tcl_Obj * FsListMounts(Tcl_Obj *pathPtr, CONST char *pattern); +static void FsAddMountsToGlobResult(Tcl_Obj *resultPtr, + Tcl_Obj *pathPtr, CONST char *pattern, + Tcl_GlobTypeData *types); +static void FsUpdateCwd(Tcl_Obj *cwdObj, ClientData clientData); #ifdef TCL_THREADS -static void FsRecacheFilesystemList(void); +static void FsRecacheFilesystemList(void); #endif /* - * These form part of the native filesystem support. They are needed here + * These form part of the native filesystem support. They are needed here * because we have a few native filesystem functions (which are the same for - * win/unix) in this file. There is no need to place them in tclInt.h, - * because they are not (and should not be) used anywhere else. + * win/unix) in this file. There is no need to place them in tclInt.h, because + * they are not (and should not be) used anywhere else. */ extern CONST char * tclpFileAttrStrings[]; @@ -59,12 +56,13 @@ extern CONST TclFileAttrProcs tclpFileAttrProcs[]; * The following functions are obsolete string based APIs, and should be * removed in a future release (Tcl 9 would be a good time). */ + /* Obsolete */ int -Tcl_Stat(path, oldStyleBuf) - CONST char *path; /* Path of file to stat (in current CP). */ - struct stat *oldStyleBuf; /* Filled with results of stat call. */ +Tcl_Stat( + CONST char *path, /* Path of file to stat (in current CP). */ + struct stat *oldStyleBuf) /* Filled with results of stat call. */ { int ret; Tcl_StatBuf buf; @@ -98,7 +96,7 @@ Tcl_Stat(path, oldStyleBuf) # ifdef EOVERFLOW errno = EOVERFLOW; # else -# error "What status should be returned for file size out of range?" +# error "What status should be returned for file size out of range?" # endif #endif return -1; @@ -111,7 +109,7 @@ Tcl_Stat(path, oldStyleBuf) /* * Copy across all supported fields, with possible type coercions on * those fields that change between the normal and lf64 versions of - * the stat structure (on Solaris at least.) This is slow when the + * the stat structure (on Solaris at least). This is slow when the * structure sizes coincide, but that's what you get for using an * obsolete interface. */ @@ -137,9 +135,9 @@ Tcl_Stat(path, oldStyleBuf) /* Obsolete */ int -Tcl_Access(path, mode) - CONST char *path; /* Path of file to access (in current CP). */ - int mode; /* Permission setting. */ +Tcl_Access( + CONST char *path, /* Path of file to access (in current CP). */ + int mode) /* Permission setting. */ { int ret; Tcl_Obj *pathPtr = Tcl_NewStringObj(path,-1); @@ -153,13 +151,13 @@ Tcl_Access(path, mode) /* Obsolete */ Tcl_Channel -Tcl_OpenFileChannel(interp, path, modeString, permissions) - Tcl_Interp *interp; /* Interpreter for error reporting; can be +Tcl_OpenFileChannel( + Tcl_Interp *interp, /* Interpreter for error reporting; can be * NULL. */ - CONST char *path; /* Name of file to open. */ - CONST char *modeString; /* A list of POSIX open modes or a string such + CONST char *path, /* Name of file to open. */ + CONST char *modeString, /* A list of POSIX open modes or a string such * as "rw". */ - int permissions; /* If the open involves creating a file, with + int permissions) /* If the open involves creating a file, with * what modes to create it? */ { Tcl_Channel ret; @@ -174,8 +172,8 @@ Tcl_OpenFileChannel(interp, path, modeString, permissions) /* Obsolete */ int -Tcl_Chdir(dirName) - CONST char *dirName; +Tcl_Chdir( + CONST char *dirName) { int ret; Tcl_Obj *pathPtr = Tcl_NewStringObj(dirName,-1); @@ -187,9 +185,9 @@ Tcl_Chdir(dirName) /* Obsolete */ char * -Tcl_GetCwd(interp, cwdPtr) - Tcl_Interp *interp; - Tcl_DString *cwdPtr; +Tcl_GetCwd( + Tcl_Interp *interp, + Tcl_DString *cwdPtr) { Tcl_Obj *cwd; cwd = Tcl_FSGetCwd(interp); @@ -205,9 +203,9 @@ Tcl_GetCwd(interp, cwdPtr) /* Obsolete */ int -Tcl_EvalFile(interp, fileName) - Tcl_Interp *interp; /* Interpreter in which to process file. */ - CONST char *fileName; /* Name of file to process. Tilde-substitution +Tcl_EvalFile( + Tcl_Interp *interp, /* Interpreter in which to process file. */ + CONST char *fileName) /* Name of file to process. Tilde-substitution * will be performed on this name. */ { int ret; @@ -219,11 +217,11 @@ Tcl_EvalFile(interp, fileName) } /* - * The 3 hooks for Stat, Access and OpenFileChannel are obsolete. The - * complete, general hooked filesystem APIs should be used instead. This - * define decides whether to include the obsolete hooks and related code. If - * these are removed, we'll also want to remove them from stubs/tclInt. The - * only known users of these APIs are prowrap and mktclapp. New + * The 3 hooks for Stat, Access and OpenFileChannel are obsolete. The + * complete, general hooked filesystem APIs should be used instead. This + * define decides whether to include the obsolete hooks and related code. If + * these are removed, we'll also want to remove them from stubs/tclInt. The + * only known users of these APIs are prowrap and mktclapp. New * code/extensions should not use them, since they do not provide as full * support as the full filesystem API. * @@ -238,26 +236,27 @@ Tcl_EvalFile(interp, fileName) /* * The following typedef declarations allow for hooking into the chain of * functions maintained for 'Tcl_Stat(...)', 'Tcl_Access(...)' & - * 'Tcl_OpenFileChannel(...)'. Basically for each hookable function a linked + * 'Tcl_OpenFileChannel(...)'. Basically for each hookable function a linked * list is defined. */ typedef struct StatProc { - TclStatProc_ *proc; /* Function to process a 'stat()' call */ - struct StatProc *nextPtr; /* The next 'stat()' function to call */ + TclStatProc_ *proc; /* Function to process a 'stat()' call */ + struct StatProc *nextPtr; /* The next 'stat()' function to call */ } StatProc; typedef struct AccessProc { - TclAccessProc_ *proc; /* Function to process a 'access()' call */ - struct AccessProc *nextPtr; /* The next 'access()' function to call */ + TclAccessProc_ *proc; /* Function to process a 'access()' call */ + struct AccessProc *nextPtr; /* The next 'access()' function to call */ } AccessProc; typedef struct OpenFileChannelProc { - TclOpenFileChannelProc_ *proc; /* Function to process a - * 'Tcl_OpenFileChannel()' call */ + TclOpenFileChannelProc_ *proc; + /* Function to process a + * 'Tcl_OpenFileChannel()' call */ struct OpenFileChannelProc *nextPtr; - /* The next 'Tcl_OpenFileChannel()' - * function to call */ + /* The next 'Tcl_OpenFileChannel()' function + * to call */ } OpenFileChannelProc; /* @@ -282,11 +281,11 @@ TCL_DECLARE_MUTEX(obsoleteFsHookMutex) #endif /* USE_OBSOLETE_FS_HOOKS */ /* - * Declare the native filesystem support. These functions should be - * considered private to Tcl, and should really not be called directly by any - * code other than this file (i.e. neither by Tcl's core nor by extensions). - * Similarly, the old string-based Tclp... native filesystem functions should - * not be called. + * Declare the native filesystem support. These functions should be considered + * private to Tcl, and should really not be called directly by any code other + * than this file (i.e. neither by Tcl's core nor by extensions). Similarly, + * the old string-based Tclp... native filesystem functions should not be + * called. * * The correct API to use now is the Tcl_FS... set of functions, which ensure * correct and complete virtual filesystem support. @@ -298,8 +297,8 @@ TCL_DECLARE_MUTEX(obsoleteFsHookMutex) static Tcl_FSFilesystemSeparatorProc NativeFilesystemSeparator; static Tcl_FSFreeInternalRepProc NativeFreeInternalRep; static Tcl_FSFileAttrStringsProc NativeFileAttrStrings; -static Tcl_FSFileAttrsGetProc NativeFileAttrsGet; -static Tcl_FSFileAttrsSetProc NativeFileAttrsSet; +static Tcl_FSFileAttrsGetProc NativeFileAttrsGet; +static Tcl_FSFileAttrsSetProc NativeFileAttrsSet; /* * The only reason these functions are not static is that they are either @@ -310,29 +309,29 @@ static Tcl_FSFileAttrsSetProc NativeFileAttrsSet; * support into a separate code library, this could actually be enforced). */ -Tcl_FSFilesystemPathTypeProc TclpFilesystemPathType; -Tcl_FSInternalToNormalizedProc TclpNativeToNormalized; -Tcl_FSStatProc TclpObjStat; -Tcl_FSAccessProc TclpObjAccess; -Tcl_FSMatchInDirectoryProc TclpMatchInDirectory; -Tcl_FSChdirProc TclpObjChdir; -Tcl_FSLstatProc TclpObjLstat; -Tcl_FSCopyFileProc TclpObjCopyFile; -Tcl_FSDeleteFileProc TclpObjDeleteFile; -Tcl_FSRenameFileProc TclpObjRenameFile; -Tcl_FSCreateDirectoryProc TclpObjCreateDirectory; -Tcl_FSCopyDirectoryProc TclpObjCopyDirectory; -Tcl_FSRemoveDirectoryProc TclpObjRemoveDirectory; -Tcl_FSUnloadFileProc TclpUnloadFile; -Tcl_FSLinkProc TclpObjLink; -Tcl_FSListVolumesProc TclpObjListVolumes; +Tcl_FSFilesystemPathTypeProc TclpFilesystemPathType; +Tcl_FSInternalToNormalizedProc TclpNativeToNormalized; +Tcl_FSStatProc TclpObjStat; +Tcl_FSAccessProc TclpObjAccess; +Tcl_FSMatchInDirectoryProc TclpMatchInDirectory; +Tcl_FSChdirProc TclpObjChdir; +Tcl_FSLstatProc TclpObjLstat; +Tcl_FSCopyFileProc TclpObjCopyFile; +Tcl_FSDeleteFileProc TclpObjDeleteFile; +Tcl_FSRenameFileProc TclpObjRenameFile; +Tcl_FSCreateDirectoryProc TclpObjCreateDirectory; +Tcl_FSCopyDirectoryProc TclpObjCopyDirectory; +Tcl_FSRemoveDirectoryProc TclpObjRemoveDirectory; +Tcl_FSUnloadFileProc TclpUnloadFile; +Tcl_FSLinkProc TclpObjLink; +Tcl_FSListVolumesProc TclpObjListVolumes; /* - * Define the native filesystem dispatch table. If necessary, it is ok to - * make this non-static, but it should only be accessed by the functions - * actually listed within it (or perhaps other helper functions of them). - * Anything which is not part of this 'native filesystem implementation' - * should not be delving inside here! + * Define the native filesystem dispatch table. If necessary, it is ok to make + * this non-static, but it should only be accessed by the functions actually + * listed within it (or perhaps other helper functions of them). Anything + * which is not part of this 'native filesystem implementation' should not be + * delving inside here! */ Tcl_Filesystem tclNativeFilesystem = { @@ -370,17 +369,17 @@ Tcl_Filesystem tclNativeFilesystem = { &TclpObjLstat, &TclpDlopen, /* Needs a cast since we're using version_2 */ - (Tcl_FSGetCwdProc*)&TclpGetNativeCwd, + (Tcl_FSGetCwdProc *) &TclpGetNativeCwd, &TclpObjChdir }; /* - * Define the tail of the linked list. Note that for unconventional uses of + * Define the tail of the linked list. Note that for unconventional uses of * Tcl without a native filesystem, we may in the future wish to modify the * current approach of hard-coding the native filesystem in the lookup list * 'filesystemList' below. * - * We initialize the record so that it thinks one file uses it. This means it + * We initialize the record so that it thinks one file uses it. This means it * will never be freed. */ @@ -392,10 +391,10 @@ static FilesystemRecord nativeFilesystemRecord = { }; /* - * This is incremented each time we modify the linked list of filesystems. - * Any time it changes, all cached filesystem representations are suspect and - * must be freed. For multithreading builds, change of the filesystem epoch - * will trigger cache cleanup in all threads. + * This is incremented each time we modify the linked list of filesystems. Any + * time it changes, all cached filesystem representations are suspect and must + * be freed. For multithreading builds, change of the filesystem epoch will + * trigger cache cleanup in all threads. */ static int theFilesystemEpoch = 0; @@ -424,12 +423,12 @@ Tcl_ThreadDataKey tclFsDataKey; * Declare fallback support function and information for Tcl_FSLoadFile */ -static Tcl_FSUnloadFileProc FSUnloadTempFile; +static Tcl_FSUnloadFileProc FSUnloadTempFile; /* * One of these structures is used each time we successfully load a file from * a file system by way of making a temporary copy of the file on the native - * filesystem. We need to store both the actual unloadProc/clientData + * filesystem. We need to store both the actual unloadProc/clientData * combination which was used, and the original and modified filenames, so * that we can correctly undo the entire operation when we want to unload the * code. @@ -448,8 +447,8 @@ typedef struct FsDivertLoad { */ static void -FsThrExitProc(cd) - ClientData cd; +FsThrExitProc( + ClientData cd) { ThreadSpecificData *tsdPtr = (ThreadSpecificData *) cd; FilesystemRecord *fsRecPtr = NULL, *tmpFsRecPtr = NULL; @@ -480,7 +479,7 @@ FsThrExitProc(cd) } int -TclFSCwdIsNative() +TclFSCwdIsNative(void) { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&tclFsDataKey); @@ -504,7 +503,7 @@ TclFSCwdIsNative() * * Side effects: * If the paths are equal, but are not the same object, this method will - * modify the given pathPtrPtr to refer to the same object. In this case + * modify the given pathPtrPtr to refer to the same object. In this case * the object pointed to by pathPtrPtr will have its refCount * decremented, and it will be adjusted to point to the cwd (with a new * refCount). @@ -513,8 +512,8 @@ TclFSCwdIsNative() */ int -TclFSCwdPointerEquals(pathPtrPtr) - Tcl_Obj** pathPtrPtr; +TclFSCwdPointerEquals( + Tcl_Obj** pathPtrPtr) { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&tclFsDataKey); @@ -561,7 +560,7 @@ TclFSCwdPointerEquals(pathPtrPtr) str2 = Tcl_GetStringFromObj(*pathPtrPtr, &len2); if (len1 == len2 && !strcmp(str1,str2)) { /* - * They are equal, but different objects. Update so they will be + * They are equal, but different objects. Update so they will be * the same object in the future. */ @@ -638,7 +637,8 @@ FsRecacheFilesystemList(void) #endif /* TCL_THREADS */ static FilesystemRecord * -FsGetFirstFilesystem(void) { +FsGetFirstFilesystem(void) +{ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&tclFsDataKey); FilesystemRecord *fsRecPtr; #ifndef TCL_THREADS @@ -663,8 +663,8 @@ FsGetFirstFilesystem(void) { */ int -TclFSEpochOk(filesystemEpoch) - int filesystemEpoch; +TclFSEpochOk( + int filesystemEpoch) { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&tclFsDataKey); (void) FsGetFirstFilesystem(); @@ -676,9 +676,9 @@ TclFSEpochOk(filesystemEpoch) */ static void -FsUpdateCwd(cwdObj, clientData) - Tcl_Obj *cwdObj; - ClientData clientData; +FsUpdateCwd( + Tcl_Obj *cwdObj, + ClientData clientData) { int len; char *str = NULL; @@ -735,8 +735,8 @@ FsUpdateCwd(cwdObj, clientData) * * TclFinalizeFilesystem -- * - * Clean up the filesystem. After this, calls to all Tcl_FS... - * functions will fail. + * Clean up the filesystem. After this, calls to all Tcl_FS... functions + * will fail. * * We will later call TclResetFilesystem to restore the FS to a pristine * state. @@ -751,12 +751,12 @@ FsUpdateCwd(cwdObj, clientData) */ void -TclFinalizeFilesystem() +TclFinalizeFilesystem(void) { FilesystemRecord *fsRecPtr; /* - * Assumption that only one thread is active now. Otherwise we would need + * Assumption that only one thread is active now. Otherwise we would need * to put various mutexes around this code. */ @@ -821,7 +821,7 @@ TclFinalizeFilesystem() */ void -TclResetFilesystem() +TclResetFilesystem(void) { filesystemList = &nativeFilesystemRecord; @@ -851,7 +851,7 @@ TclResetFilesystem() * can use Tcl_FSData to check if it is in the list, provided the * ClientData used was not NULL). * - * Note that the filesystem handling is head-to-tail of the list. Each + * Note that the filesystem handling is head-to-tail of the list. Each * filesystem is asked in turn whether it can handle a particular * request, until one of them says 'yes'. At that point no further * filesystems are asked. @@ -871,9 +871,9 @@ TclResetFilesystem() */ int -Tcl_FSRegister(clientData, fsPtr) - ClientData clientData; /* Client specific data for this fs */ - Tcl_Filesystem *fsPtr; /* The filesystem record for the new fs. */ +Tcl_FSRegister( + ClientData clientData, /* Client specific data for this fs */ + Tcl_Filesystem *fsPtr) /* The filesystem record for the new fs. */ { FilesystemRecord *newFilesystemPtr; @@ -887,17 +887,17 @@ Tcl_FSRegister(clientData, fsPtr) newFilesystemPtr->fsPtr = fsPtr; /* - * We start with a refCount of 1. If this drops to zero, then anyone is + * We start with a refCount of 1. If this drops to zero, then anyone is * welcome to ckfree us. */ newFilesystemPtr->fileRefCount = 1; /* - * Is this lock and wait strictly speaking necessary? Since any iterators + * Is this lock and wait strictly speaking necessary? Since any iterators * out there will have grabbed a copy of the head of the list and be * iterating away from that, if we add a new element to the head of the - * list, it can't possibly have any effect on any of their loops. In fact + * list, it can't possibly have any effect on any of their loops. In fact * it could be better not to wait, since we are adjusting the filesystem * epoch, any cached representations calculated by existing iterators are * going to have to be thrown away anyway. @@ -932,14 +932,14 @@ Tcl_FSRegister(clientData, fsPtr) * Tcl_FSUnregister -- * * Remove the passed filesystem from the list of filesystem function - * tables. It also ensures that the built-in (native) filesystem is not + * tables. It also ensures that the built-in (native) filesystem is not * removable, although we may wish to change that decision in the future * to allow a smaller Tcl core, in which the native filesystem is not * used at all (we could, say, initialise Tcl completely over a network * connection). * * Results: - * TCL_OK if the procedure pointer was successfully removed, TCL_ERROR + * TCL_OK if the function pointer was successfully removed, TCL_ERROR * otherwise. * * Side effects: @@ -951,8 +951,8 @@ Tcl_FSRegister(clientData, fsPtr) */ int -Tcl_FSUnregister(fsPtr) - Tcl_Filesystem *fsPtr; /* The filesystem record to remove. */ +Tcl_FSUnregister( + Tcl_Filesystem *fsPtr) /* The filesystem record to remove. */ { int retVal = TCL_ERROR; FilesystemRecord *fsRecPtr; @@ -979,7 +979,7 @@ Tcl_FSUnregister(fsPtr) /* * Increment the filesystem epoch counter, since existing paths - * might conceivably now belong to different filesystems. This + * might conceivably now belong to different filesystems. This * should also ensure that paths which have cached the filesystem * which is about to be deleted do not reference that filesystem * (which would of course lead to memory exceptions). @@ -1008,17 +1008,17 @@ Tcl_FSUnregister(fsPtr) * Tcl_FSMatchInDirectory -- * * This routine 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. If pathPtr + * all files which match a given pattern. The appropriate function for + * the filesystem to which pathPtr belongs will be called. If pathPtr * does not belong to any filesystem and if it is NULL or the empty * string, then we assume the pattern is to be matched in the current - * working directory. To avoid have the Tcl_FSMatchInDirectoryProc for + * working directory. To avoid have the Tcl_FSMatchInDirectoryProc for * each filesystem from having to deal with this issue, we create a * pathPtr on the fly (equal to the cwd), and then remove it from the - * results returned. This makes filesystems easy to write, since they - * can assume the pathPtr passed to them is an ordinary path. In fact - * this means we could remove such special case handling from Tcl's - * native filesystems. + * results returned. This makes filesystems easy to write, since they can + * assume the pathPtr passed to them is an ordinary path. In fact this + * means we could remove such special case handling from Tcl's native + * filesystems. * * If 'pattern' is NULL, then pathPtr is assumed to be a fully specified * path of a single file/directory which must be checked for existence @@ -1027,14 +1027,14 @@ Tcl_FSUnregister(fsPtr) * Results: * * The return value is a standard Tcl result indicating whether an error - * occurred in globbing. Error messages are placed in interp, but good + * occurred in globbing. Error messages are placed in interp, but good * results are placed in the resultPtr given. * * Recursive searches, e.g. * glob -dir $dir -join * pkgIndex.tcl * which must recurse through each directory matching '*' are handled * internally by Tcl, by passing specific flags in a modified 'types' - * parameter. This means the actual filesystem only ever sees patterns + * parameter. This means the actual filesystem only ever sees patterns * which match in a single directory. * * Side effects: @@ -1044,13 +1044,13 @@ Tcl_FSUnregister(fsPtr) */ int -Tcl_FSMatchInDirectory(interp, resultPtr, pathPtr, pattern, types) - Tcl_Interp *interp; /* Interpreter to receive error - * messages, but may be NULL. */ - Tcl_Obj *resultPtr; /* List object to receive results. */ - Tcl_Obj *pathPtr; /* Contains path to directory to search. */ - CONST char *pattern; /* Pattern to match against. */ - Tcl_GlobTypeData *types; /* Object containing list of acceptable types. +Tcl_FSMatchInDirectory( + Tcl_Interp *interp, /* Interpreter to receive error messages, but + * may be NULL. */ + Tcl_Obj *resultPtr, /* List object to receive results. */ + Tcl_Obj *pathPtr, /* Contains path to directory to search. */ + CONST char *pattern, /* Pattern to match against. */ + Tcl_GlobTypeData *types) /* Object containing list of acceptable types. * May be NULL. In particular the directory * flag is very important. */ { @@ -1063,7 +1063,7 @@ Tcl_FSMatchInDirectory(interp, resultPtr, pathPtr, pattern, types) * We don't currently allow querying of mounts by external code (a * valuable future step), so since we're the only function that * actually knows about mounts, this means we're being called - * recursively by ourself. Return no matches. + * recursively by ourself. Return no matches. */ return TCL_OK; @@ -1154,7 +1154,7 @@ Tcl_FSMatchInDirectory(interp, resultPtr, pathPtr, pattern, types) * FsAddMountsToGlobResult -- * * This routine is used by the globbing code to take the results of a - * directory listing and add any mounted paths to that listing. This is + * directory listing and add any mounted paths to that listing. This is * required so that simple things like 'glob *' merge mounts and listings * correctly. * @@ -1168,12 +1168,12 @@ Tcl_FSMatchInDirectory(interp, resultPtr, pathPtr, pattern, types) */ static void -FsAddMountsToGlobResult(resultPtr, pathPtr, pattern, types) - Tcl_Obj *resultPtr; /* The current list of matching paths; must +FsAddMountsToGlobResult( + Tcl_Obj *resultPtr, /* The current list of matching paths; must * not be shared! */ - Tcl_Obj *pathPtr; /* The directory in question */ - CONST char *pattern; /* Pattern to match against. */ - Tcl_GlobTypeData *types; /* Object containing list of acceptable types. + Tcl_Obj *pathPtr, /* The directory in question */ + CONST char *pattern, /* Pattern to match against. */ + Tcl_GlobTypeData *types) /* Object containing list of acceptable types. * May be NULL. In particular the directory * flag is very important. */ { @@ -1268,7 +1268,7 @@ FsAddMountsToGlobResult(resultPtr, pathPtr, pattern, types) * Clearly it should only therefore be called when it is really required! * There are a few circumstances when it should be called: * - * (1) when a new filesystem is registered or unregistered. Strictly + * (1) when a new filesystem is registered or unregistered. Strictly * speaking this is only necessary if the new filesystem accepts file * paths as is (normally the filesystem itself is really a shell which * hasn't yet had any mount points established and so its @@ -1298,11 +1298,11 @@ FsAddMountsToGlobResult(resultPtr, pathPtr, pattern, types) */ void -Tcl_FSMountsChanged(fsPtr) - Tcl_Filesystem *fsPtr; +Tcl_FSMountsChanged( + Tcl_Filesystem *fsPtr) { /* - * We currently don't do anything with this parameter. We could in the + * We currently don't do anything with this parameter. We could in the * future only invalidate files for this filesystem or otherwise take more * advanced action. */ @@ -1328,7 +1328,7 @@ Tcl_FSMountsChanged(fsPtr) * that filesystem is not registered. * * Results: - * A clientData value, or NULL. Note that if the filesystem was + * A clientData value, or NULL. Note that if the filesystem was * registered with a NULL clientData field, this function will return * that NULL value. * @@ -1339,14 +1339,14 @@ Tcl_FSMountsChanged(fsPtr) */ ClientData -Tcl_FSData(fsPtr) - Tcl_Filesystem *fsPtr; /* The filesystem record to query. */ +Tcl_FSData( + Tcl_Filesystem *fsPtr) /* The filesystem record to query. */ { ClientData retVal = NULL; FilesystemRecord *fsRecPtr = FsGetFirstFilesystem(); /* - * Traverse the list of filesystems look for a particular one. If found, + * Traverse the list of filesystems look for a particular one. If found, * return that filesystem's clientData (originally provided when calling * Tcl_FSRegister). */ @@ -1367,13 +1367,13 @@ Tcl_FSData(fsPtr) * TclFSNormalizeToUniquePath -- * * Takes a path specification containing no ../, ./ sequences, and - * converts it into a unique path for the given platform. On Unix, this + * converts it into a unique path for the given platform. On Unix, this * means the path must be free of symbolic links/aliases, and on Windows * it means we want the long form, with that long form's case-dependence * (which gives us a unique, case-dependent path). * * Results: - * The pathPtr is modified in place. The return value is the last byte + * The pathPtr is modified in place. The return value is the last byte * offset which was recognised in the path string. * * Side effects: @@ -1382,7 +1382,7 @@ Tcl_FSData(fsPtr) * Special notes: * If the filesystem-specific normalizePathProcs can re-introduce ../, ./ * sequences into the path, then this function will not return the - * correct result. This may be possible with symbolic links on unix. + * correct result. This may be possible with symbolic links on unix. * * Important assumption: if startAt is non-zero, it must point to a * directory separator that we know exists and is already normalized (so @@ -1392,11 +1392,11 @@ Tcl_FSData(fsPtr) */ int -TclFSNormalizeToUniquePath(interp, pathPtr, startAt, clientDataPtr) - Tcl_Interp *interp; /* Used for error messages. */ - Tcl_Obj *pathPtr; /* The path to normalize in place */ - int startAt; /* Start at this char-offset */ - ClientData *clientDataPtr; /* If we generated a complete normalized path +TclFSNormalizeToUniquePath( + Tcl_Interp *interp, /* Used for error messages. */ + Tcl_Obj *pathPtr, /* The path to normalize in place */ + int startAt, /* Start at this char-offset */ + ClientData *clientDataPtr) /* If we generated a complete normalized path * for a given filesystem, we can optionally * return an fs-specific clientdata here. */ { @@ -1407,7 +1407,7 @@ TclFSNormalizeToUniquePath(interp, pathPtr, startAt, clientDataPtr) /* * Call each of the "normalise path" functions in succession. This is a * special case, in which if we have a native filesystem handler, we call - * it first. This is because the root of Tcl's filesystem is always a + * it first. This is because the root of Tcl's filesystem is always a * native filesystem (i.e. '/' on unix is native). */ @@ -1455,7 +1455,7 @@ TclFSNormalizeToUniquePath(interp, pathPtr, startAt, clientDataPtr) * TclGetOpenMode -- * * This routine is an obsolete, limited version of TclGetOpenModeEx() - * below. It exists only to satisfy any extensions imprudently using it + * below. It exists only to satisfy any extensions imprudently using it * via Tcl's internal stubs table. * * Results: @@ -1468,14 +1468,12 @@ TclFSNormalizeToUniquePath(interp, pathPtr, startAt, clientDataPtr) */ int -TclGetOpenMode(interp, modeString, seekFlagPtr) - Tcl_Interp *interp; /* Interpreter to use for error - * reporting - may be NULL. */ - CONST char *modeString; /* Mode string, e.g. "r+" or "RDONLY - * CREAT". */ - int *seekFlagPtr; /* Set this to 1 if the caller should - * seek to EOF during the opening of - * the file. */ +TclGetOpenMode( + Tcl_Interp *interp, /* Interpreter to use for error reporting - + * may be NULL. */ + CONST char *modeString, /* Mode string, e.g. "r+" or "RDONLY CREAT" */ + int *seekFlagPtr) /* Set this to 1 if the caller should seek to + * EOF during the opening of the file. */ { int binary = 0; return TclGetOpenModeEx(interp, modeString, seekFlagPtr, &binary); @@ -1498,7 +1496,7 @@ TclGetOpenMode(interp, modeString, seekFlagPtr) * * Side effects: * Sets the integer referenced by seekFlagPtr to 1 to tell the caller to - * seek to EOF after opening the file, or to 0 otherwise. Sets the + * seek to EOF after opening the file, or to 0 otherwise. Sets the * integer referenced by binaryPtr to 1 to tell the caller to seek to * configure the channel for binary data, or to 0 otherwise. * @@ -1510,24 +1508,22 @@ TclGetOpenMode(interp, modeString, seekFlagPtr) */ int -TclGetOpenModeEx(interp, modeString, seekFlagPtr, binaryPtr) - Tcl_Interp *interp; /* Interpreter to use for error - * reporting - may be NULL. */ - CONST char *modeString; /* Mode string, e.g. "r+" or "RDONLY - * CREAT". */ - int *seekFlagPtr; /* Set this to 1 if the caller should - * seek to EOF during the opening of - * the file. */ - int *binaryPtr; /* Set this to 1 if the caller should - * configure the opened channel for - * binary operations */ +TclGetOpenModeEx( + Tcl_Interp *interp, /* Interpreter to use for error reporting - + * may be NULL. */ + CONST char *modeString, /* Mode string, e.g. "r+" or "RDONLY CREAT" */ + int *seekFlagPtr, /* Set this to 1 if the caller should seek to + * EOF during the opening of the file. */ + int *binaryPtr) /* Set this to 1 if the caller should + * configure the opened channel for binary + * operations */ { int mode, modeArgc, c, i, gotRW; CONST char **modeArgv, *flag; #define RW_MODES (O_RDONLY|O_WRONLY|O_RDWR) /* - * Check for the simpler fopen-like access modes (e.g. "r"). They are + * Check for the simpler fopen-like access modes (e.g. "r"). They are * distinguished from the POSIX access modes by the presence of a * lower-case first letter. */ @@ -1558,9 +1554,9 @@ TclGetOpenModeEx(interp, modeString, seekFlagPtr, binaryPtr) error: *seekFlagPtr = 0; *binaryPtr = 0; - if (interp != (Tcl_Interp *) NULL) { + if (interp != NULL) { Tcl_AppendResult(interp, "illegal access mode \"", modeString, - "\"", (char *) NULL); + "\"", NULL); } return -1; } @@ -1596,7 +1592,7 @@ TclGetOpenModeEx(interp, modeString, seekFlagPtr, binaryPtr) */ if (Tcl_SplitList(interp, modeString, &modeArgc, &modeArgv) != TCL_OK) { - if (interp != (Tcl_Interp *) NULL) { + if (interp != NULL) { Tcl_AddErrorInfo(interp, "\n while processing open access modes \""); Tcl_AddErrorInfo(interp, modeString); @@ -1630,9 +1626,9 @@ TclGetOpenModeEx(interp, modeString, seekFlagPtr, binaryPtr) #ifdef O_NOCTTY mode |= O_NOCTTY; #else - if (interp != (Tcl_Interp *) NULL) { + if (interp != NULL) { Tcl_AppendResult(interp, "access mode \"", flag, - "\" not supported by this system", (char *) NULL); + "\" not supported by this system", NULL); } ckfree((char *) modeArgv); return -1; @@ -1647,9 +1643,9 @@ TclGetOpenModeEx(interp, modeString, seekFlagPtr, binaryPtr) # endif #else - if (interp != (Tcl_Interp *) NULL) { + if (interp != NULL) { Tcl_AppendResult(interp, "access mode \"", flag, - "\" not supported by this system", (char *) NULL); + "\" not supported by this system", NULL); } ckfree((char *) modeArgv); return -1; @@ -1661,11 +1657,10 @@ TclGetOpenModeEx(interp, modeString, seekFlagPtr, binaryPtr) *binaryPtr = 1; } else { - if (interp != (Tcl_Interp *) NULL) { + if (interp != NULL) { Tcl_AppendResult(interp, "invalid access mode \"", flag, "\": must be RDONLY, WRONLY, RDWR, APPEND, BINARY, " - "CREAT, EXCL, NOCTTY, NONBLOCK, or TRUNC", - (char *) NULL); + "CREAT, EXCL, NOCTTY, NONBLOCK, or TRUNC", NULL); } ckfree((char *) modeArgv); return -1; @@ -1675,9 +1670,9 @@ TclGetOpenModeEx(interp, modeString, seekFlagPtr, binaryPtr) ckfree((char *) modeArgv); if (!gotRW) { - if (interp != (Tcl_Interp *) NULL) { + if (interp != NULL) { Tcl_AppendResult(interp, "access mode must include either", - " RDONLY, WRONLY, or RDWR", (char *) NULL); + " RDONLY, WRONLY, or RDWR", NULL); } return -1; } @@ -1689,9 +1684,9 @@ TclGetOpenModeEx(interp, modeString, seekFlagPtr, binaryPtr) */ int -Tcl_FSEvalFile(interp, pathPtr) - Tcl_Interp *interp; /* Interpreter in which to process file. */ - Tcl_Obj *pathPtr; /* Path of file to process. Tilde-substitution +Tcl_FSEvalFile( + Tcl_Interp *interp, /* Interpreter in which to process file. */ + Tcl_Obj *pathPtr) /* Path of file to process. Tilde-substitution * will be performed on this name. */ { return Tcl_FSEvalFileEx(interp, pathPtr, NULL); @@ -1710,7 +1705,7 @@ Tcl_FSEvalFile(interp, pathPtr) * file or an error indicating why the file couldn't be read. * * Side effects: - * Depends on the commands in the file. During the evaluation of the + * Depends on the commands in the file. During the evaluation of the * contents of the file, iPtr->scriptFile is made to point to pathPtr * (the old value is cached and replaced when this function returns). * @@ -1718,12 +1713,12 @@ Tcl_FSEvalFile(interp, pathPtr) */ int -Tcl_FSEvalFileEx(interp, pathPtr, encodingName) - Tcl_Interp *interp; /* Interpreter in which to process file. */ - Tcl_Obj *pathPtr; /* Path of file to process. Tilde-substitution +Tcl_FSEvalFileEx( + Tcl_Interp *interp, /* Interpreter in which to process file. */ + Tcl_Obj *pathPtr, /* Path of file to process. Tilde-substitution * will be performed on this name. */ - CONST char *encodingName; /* If non-NULL, then use this encoding for the - * file. */ + CONST char *encodingName) /* If non-NULL, then use this encoding for the + * file. NULL means use the system encoding. */ { int result, length; Tcl_StatBuf statBuf; @@ -1743,28 +1738,26 @@ Tcl_FSEvalFileEx(interp, pathPtr, encodingName) if (Tcl_FSStat(pathPtr, &statBuf) == -1) { Tcl_SetErrno(errno); Tcl_AppendResult(interp, "couldn't read file \"", - Tcl_GetString(pathPtr), - "\": ", Tcl_PosixError(interp), (char *) NULL); + Tcl_GetString(pathPtr), "\": ", Tcl_PosixError(interp), NULL); goto end; } chan = Tcl_FSOpenFileChannel(interp, pathPtr, "r", 0644); if (chan == (Tcl_Channel) NULL) { Tcl_ResetResult(interp); Tcl_AppendResult(interp, "couldn't read file \"", - Tcl_GetString(pathPtr), - "\": ", Tcl_PosixError(interp), (char *) NULL); + Tcl_GetString(pathPtr), "\": ", Tcl_PosixError(interp), NULL); goto end; } /* - * The eofchar is \32 (^Z). This is the usual on Windows, but we effect - * this cross-platform to allow for scripted documents. [Bug: 2040] + * The eofchar is \32 (^Z). This is the usual on Windows, but we effect + * this cross-platform to allow for scripted documents. [Bug: 2040] */ Tcl_SetChannelOption(interp, chan, "-eofchar", "\32"); /* - * If the encoding is specified, set it for the channel. Else don't touch + * If the encoding is specified, set it for the channel. Else don't touch * it (and use the system encoding) Report error on unknown encoding. */ @@ -1779,8 +1772,7 @@ Tcl_FSEvalFileEx(interp, pathPtr, encodingName) if (Tcl_ReadChars(chan, objPtr, -1, 0) < 0) { Tcl_Close(interp, chan); Tcl_AppendResult(interp, "couldn't read file \"", - Tcl_GetString(pathPtr), - "\": ", Tcl_PosixError(interp), (char *) NULL); + Tcl_GetString(pathPtr), "\": ", Tcl_PosixError(interp), NULL); goto end; } @@ -1812,6 +1804,7 @@ Tcl_FSEvalFileEx(interp, pathPtr, encodingName) /* * Record information telling where the error occurred. */ + CONST char *pathString = Tcl_GetStringFromObj(pathPtr, &length); int limit = 150; int overflow = (length > limit); @@ -1846,7 +1839,7 @@ Tcl_FSEvalFileEx(interp, pathPtr, encodingName) */ int -Tcl_GetErrno() +Tcl_GetErrno(void) { return errno; } @@ -1868,8 +1861,8 @@ Tcl_GetErrno() */ void -Tcl_SetErrno(err) - int err; /* The new value. */ +Tcl_SetErrno( + int err) /* The new value. */ { errno = err; } @@ -1879,8 +1872,8 @@ Tcl_SetErrno(err) * * Tcl_PosixError -- * - * This procedure is typically called after UNIX kernel calls return - * errors. It stores machine-readable information about the error in + * This function is typically called after UNIX kernel calls return + * errors. It stores machine-readable information about the error in * errorCode field of interp and returns an information string for the * caller's use. * @@ -1894,15 +1887,15 @@ Tcl_SetErrno(err) */ CONST char * -Tcl_PosixError(interp) - Tcl_Interp *interp; /* Interpreter whose errorCode field - * is to be set. */ +Tcl_PosixError( + Tcl_Interp *interp) /* Interpreter whose errorCode field is to be + * set. */ { CONST char *id, *msg; msg = Tcl_ErrnoMsg(errno); id = Tcl_ErrnoId(); - Tcl_SetErrorCode(interp, "POSIX", id, msg, (char *) NULL); + Tcl_SetErrorCode(interp, "POSIX", id, msg, NULL); return msg; } @@ -1911,7 +1904,7 @@ Tcl_PosixError(interp) * * Tcl_FSStat -- * - * This procedure replaces the library version of stat and lsat. + * This function replaces the library version of stat and lsat. * * The appropriate function for the filesystem to which pathPtr belongs * will be called. @@ -1926,9 +1919,9 @@ Tcl_PosixError(interp) */ int -Tcl_FSStat(pathPtr, buf) - Tcl_Obj *pathPtr; /* Path of file to stat (in current CP). */ - Tcl_StatBuf *buf; /* Filled with results of stat call. */ +Tcl_FSStat( + Tcl_Obj *pathPtr, /* Path of file to stat (in current CP). */ + Tcl_StatBuf *buf) /* Filled with results of stat call. */ { Tcl_Filesystem *fsPtr; #ifdef USE_OBSOLETE_FS_HOOKS @@ -1936,7 +1929,7 @@ Tcl_FSStat(pathPtr, buf) int retVal = -1; /* - * Call each of the "stat" function in succession. A non-return value of + * Call each of the "stat" function in succession. A non-return value of * -1 indicates the particular function has succeeded. */ @@ -2004,7 +1997,7 @@ Tcl_FSStat(pathPtr, buf) * * Tcl_FSLstat -- * - * This procedure replaces the library version of lstat. The appropriate + * This function replaces the library version of lstat. The appropriate * function for the filesystem to which pathPtr belongs will be called. * If no 'lstat' function is listed, but a 'stat' function is, then Tcl * will fall back on the stat function. @@ -2019,9 +2012,9 @@ Tcl_FSStat(pathPtr, buf) */ int -Tcl_FSLstat(pathPtr, buf) - Tcl_Obj *pathPtr; /* Path of file to stat (in current CP). */ - Tcl_StatBuf *buf; /* Filled with results of stat call. */ +Tcl_FSLstat( + Tcl_Obj *pathPtr, /* Path of file to stat (in current CP). */ + Tcl_StatBuf *buf) /* Filled with results of stat call. */ { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); if (fsPtr != NULL) { @@ -2044,9 +2037,8 @@ Tcl_FSLstat(pathPtr, buf) * * Tcl_FSAccess -- * - * This procedure replaces the library version of access. The - * appropriate function for the filesystem to which pathPtr belongs will - * be called. + * This function replaces the library version of access. The appropriate + * function for the filesystem to which pathPtr belongs will be called. * * Results: * See access documentation. @@ -2058,17 +2050,17 @@ Tcl_FSLstat(pathPtr, buf) */ int -Tcl_FSAccess(pathPtr, mode) - Tcl_Obj *pathPtr; /* Path of file to access (in current CP). */ - int mode; /* Permission setting. */ +Tcl_FSAccess( + Tcl_Obj *pathPtr, /* Path of file to access (in current CP). */ + int mode) /* Permission setting. */ { Tcl_Filesystem *fsPtr; #ifdef USE_OBSOLETE_FS_HOOKS int retVal = -1; /* - * Call each of the "access" function in succession. A non-return value - * of -1 indicates the particular function has succeeded. + * Call each of the "access" function in succession. A non-return value of + * -1 indicates the particular function has succeeded. */ Tcl_MutexLock(&obsoleteFsHookMutex); @@ -2130,13 +2122,13 @@ Tcl_FSAccess(pathPtr, mode) */ Tcl_Channel -Tcl_FSOpenFileChannel(interp, pathPtr, modeString, permissions) - Tcl_Interp *interp; /* Interpreter for error reporting; can be +Tcl_FSOpenFileChannel( + Tcl_Interp *interp, /* Interpreter for error reporting; can be * NULL. */ - Tcl_Obj *pathPtr; /* Name of file to open. */ - CONST char *modeString; /* A list of POSIX open modes or a string such + Tcl_Obj *pathPtr, /* Name of file to open. */ + CONST char *modeString, /* A list of POSIX open modes or a string such * as "rw". */ - int permissions; /* If the open involves creating a file, with + int permissions) /* If the open involves creating a file, with * what modes to create it? */ { Tcl_Filesystem *fsPtr; @@ -2144,7 +2136,7 @@ Tcl_FSOpenFileChannel(interp, pathPtr, modeString, permissions) Tcl_Channel retVal = NULL; /* - * Call each of the "Tcl_OpenFileChannel" functions in succession. A + * Call each of the "Tcl_OpenFileChannel" functions in succession. A * non-NULL return value indicates the particular function has succeeded. */ @@ -2192,30 +2184,41 @@ Tcl_FSOpenFileChannel(interp, pathPtr, modeString, permissions) if (proc != NULL) { int mode, seekFlag, binary; + /* + * Parse the mode, picking up whether we want to seek to start + * with and/or set the channel automatically into binary mode. + */ + mode = TclGetOpenModeEx(interp, modeString, &seekFlag, &binary); if (mode == -1) { return NULL; } + /* + * Do the actual open() call. + */ + retVal = (*proc)(interp, pathPtr, mode, permissions); - if (retVal != NULL) { - if (seekFlag) { - if (Tcl_Seek(retVal, (Tcl_WideInt)0, - SEEK_END) < (Tcl_WideInt)0) { - if (interp != (Tcl_Interp *) NULL) { - Tcl_AppendResult(interp, - "could not seek to end of file while opening \"", - Tcl_GetString(pathPtr), "\": ", - Tcl_PosixError(interp), (char *) NULL); - } - Tcl_Close(NULL, retVal); - return NULL; - } - } - if (binary) { - Tcl_SetChannelOption(interp, retVal, - "-translation", "binary"); + if (retVal == NULL) { + return NULL; + } + + /* + * Apply appropriate flags parsed out above. + */ + + if (seekFlag && Tcl_Seek(retVal, (Tcl_WideInt)0, + SEEK_END) < (Tcl_WideInt)0) { + if (interp != NULL) { + Tcl_AppendResult(interp, "could not seek to end ", + "of file while opening \"", Tcl_GetString(pathPtr), + "\": ", Tcl_PosixError(interp), NULL); } + Tcl_Close(NULL, retVal); + return NULL; + } + if (binary) { + Tcl_SetChannelOption(interp, retVal, "-translation", "binary"); } return retVal; } @@ -2228,7 +2231,7 @@ Tcl_FSOpenFileChannel(interp, pathPtr, modeString, permissions) Tcl_SetErrno(ENOENT); if (interp != NULL) { Tcl_AppendResult(interp, "couldn't open \"", Tcl_GetString(pathPtr), - "\": ", Tcl_PosixError(interp), (char *) NULL); + "\": ", Tcl_PosixError(interp), NULL); } return NULL; } @@ -2238,7 +2241,7 @@ Tcl_FSOpenFileChannel(interp, pathPtr, modeString, permissions) * * Tcl_FSUtime -- * - * This procedure replaces the library version of utime. The appropriate + * This function replaces the library version of utime. The appropriate * function for the filesystem to which pathPtr belongs will be called. * * Results: @@ -2251,10 +2254,10 @@ Tcl_FSOpenFileChannel(interp, pathPtr, modeString, permissions) */ int -Tcl_FSUtime(pathPtr, tval) - Tcl_Obj *pathPtr; /* File to change access/modification times */ - struct utimbuf *tval; /* Structure containing access/modification - * times to use. Should not be modified. */ +Tcl_FSUtime( + Tcl_Obj *pathPtr, /* File to change access/modification times */ + struct utimbuf *tval) /* Structure containing access/modification + * times to use. Should not be modified. */ { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); if (fsPtr != NULL) { @@ -2271,9 +2274,9 @@ Tcl_FSUtime(pathPtr, tval) * * NativeFileAttrStrings -- * - * This procedure implements the platform dependent 'file attributes' + * This function implements the platform dependent 'file attributes' * subcommand, for the native filesystem, for listing the set of possible - * attribute strings. This function is part of Tcl's native filesystem + * attribute strings. This function is part of Tcl's native filesystem * support, and is placed here because it is shared by Unix and Windows * code. * @@ -2286,10 +2289,10 @@ Tcl_FSUtime(pathPtr, tval) *---------------------------------------------------------------------- */ -static CONST char** -NativeFileAttrStrings(pathPtr, objPtrRef) - Tcl_Obj *pathPtr; - Tcl_Obj** objPtrRef; +static CONST char ** +NativeFileAttrStrings( + Tcl_Obj *pathPtr, + Tcl_Obj **objPtrRef) { return tclpFileAttrStrings; } @@ -2299,15 +2302,15 @@ NativeFileAttrStrings(pathPtr, objPtrRef) * * NativeFileAttrsGet -- * - * This procedure implements the platform dependent 'file attributes' - * subcommand, for the native filesystem, for 'get' operations. This + * This function implements the platform dependent 'file attributes' + * subcommand, for the native filesystem, for 'get' operations. This * function is part of Tcl's native filesystem support, and is placed * here because it is shared by Unix and Windows code. * * Results: - * Standard Tcl return code. The object placed in objPtrRef (if TCL_OK - * was returned) 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 + * Standard Tcl return code. The object placed in objPtrRef (if TCL_OK + * was returned) 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. * * Side effects: @@ -2317,13 +2320,13 @@ NativeFileAttrStrings(pathPtr, objPtrRef) */ static int -NativeFileAttrsGet(interp, index, pathPtr, objPtrRef) - Tcl_Interp *interp; /* The interpreter for error reporting. */ - int index; /* index of the attribute command. */ - Tcl_Obj *pathPtr; /* path of file we are operating on. */ - Tcl_Obj **objPtrRef; /* for output. */ +NativeFileAttrsGet( + Tcl_Interp *interp, /* The interpreter for error reporting. */ + int index, /* index of the attribute command. */ + Tcl_Obj *pathPtr, /* path of file we are operating on. */ + Tcl_Obj **objPtrRef) /* for output. */ { - return (*tclpFileAttrProcs[index].getProc)(interp, index, pathPtr, + return (tclpFileAttrProcs[index]->getProc)(interp, index, pathPtr, objPtrRef); } @@ -2332,7 +2335,7 @@ NativeFileAttrsGet(interp, index, pathPtr, objPtrRef) * * NativeFileAttrsSet -- * - * This procedure implements the platform dependent 'file attributes' + * This function implements the platform dependent 'file attributes' * subcommand, for the native filesystem, for 'set' operations. This * function is part of Tcl's native filesystem support, and is placed * here because it is shared by Unix and Windows code. @@ -2347,13 +2350,13 @@ NativeFileAttrsGet(interp, index, pathPtr, objPtrRef) */ static int -NativeFileAttrsSet(interp, index, pathPtr, objPtr) - Tcl_Interp *interp; /* The interpreter for error reporting. */ - int index; /* index of the attribute command. */ - Tcl_Obj *pathPtr; /* path of file we are operating on. */ - Tcl_Obj *objPtr; /* set to this value. */ +NativeFileAttrsSet( + Tcl_Interp *interp, /* The interpreter for error reporting. */ + int index, /* index of the attribute command. */ + Tcl_Obj *pathPtr, /* path of file we are operating on. */ + Tcl_Obj *objPtr) /* set to this value. */ { - return (*tclpFileAttrProcs[index].setProc)(interp, index, pathPtr, objPtr); + return (tclpFileAttrProcs[index]->setProc)(interp, index, pathPtr, objPtr); } /* @@ -2361,12 +2364,12 @@ NativeFileAttrsSet(interp, index, pathPtr, objPtr) * * Tcl_FSFileAttrStrings -- * - * This procedure implements part of the hookable 'file attributes' - * subcommand. The appropriate function for the filesystem to which + * This function implements part of the hookable 'file attributes' + * subcommand. The appropriate function for the filesystem to which * pathPtr belongs will be called. * * Results: - * The called procedure may either return an array of strings, or may + * 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 @@ -2381,11 +2384,12 @@ NativeFileAttrsSet(interp, index, pathPtr, objPtr) */ CONST char ** -Tcl_FSFileAttrStrings(pathPtr, objPtrRef) - Tcl_Obj *pathPtr; - Tcl_Obj **objPtrRef; +Tcl_FSFileAttrStrings( + Tcl_Obj *pathPtr, + Tcl_Obj **objPtrRef) { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); + if (fsPtr != NULL) { Tcl_FSFileAttrStringsProc *proc = fsPtr->fileAttrStringsProc; if (proc != NULL) { @@ -2414,11 +2418,11 @@ Tcl_FSFileAttrStrings(pathPtr, objPtrRef) */ int -TclFSFileAttrIndex(pathPtr, attributeName, indexPtr) - Tcl_Obj *pathPtr; /* File whose attributes are to be - * indexed into. */ - CONST char *attributeName; /* The attribute being looked for. */ - int *indexPtr; /* Where to write the found index. */ +TclFSFileAttrIndex( + Tcl_Obj *pathPtr, /* File whose attributes are to be indexed + * into. */ + CONST char *attributeName, /* The attribute being looked for. */ + int *indexPtr) /* Where to write the found index. */ { Tcl_Obj *listObj = NULL; CONST char **attrTable; @@ -2478,14 +2482,14 @@ TclFSFileAttrIndex(pathPtr, attributeName, indexPtr) * * Tcl_FSFileAttrsGet -- * - * This procedure implements read access for the hookable 'file - * attributes' subcommand. The appropriate function for the filesystem - * to which pathPtr belongs will be called. + * This function implements read access for the hookable 'file + * attributes' subcommand. The appropriate function for the filesystem to + * which pathPtr belongs will be called. * * Results: - * Standard Tcl return code. The object placed in objPtrRef (if TCL_OK - * was returned) 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 + * Standard Tcl return code. The object placed in objPtrRef (if TCL_OK + * was returned) 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. * * Side effects: @@ -2495,13 +2499,14 @@ TclFSFileAttrIndex(pathPtr, attributeName, indexPtr) */ int -Tcl_FSFileAttrsGet(interp, index, pathPtr, objPtrRef) - Tcl_Interp *interp; /* The interpreter for error reporting. */ - int index; /* index of the attribute command. */ - Tcl_Obj *pathPtr; /* filename we are operating on. */ - Tcl_Obj **objPtrRef; /* for output. */ +Tcl_FSFileAttrsGet( + Tcl_Interp *interp, /* The interpreter for error reporting. */ + int index, /* index of the attribute command. */ + Tcl_Obj *pathPtr, /* filename we are operating on. */ + Tcl_Obj **objPtrRef) /* for output. */ { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); + if (fsPtr != NULL) { Tcl_FSFileAttrsGetProc *proc = fsPtr->fileAttrsGetProc; if (proc != NULL) { @@ -2517,9 +2522,9 @@ Tcl_FSFileAttrsGet(interp, index, pathPtr, objPtrRef) * * Tcl_FSFileAttrsSet -- * - * This procedure implements write access for the hookable 'file - * attributes' subcommand. The appropriate function for the filesystem - * to which pathPtr belongs will be called. + * This function implements write access for the hookable 'file + * attributes' subcommand. The appropriate function for the filesystem to + * which pathPtr belongs will be called. * * Results: * Standard Tcl return code. @@ -2531,13 +2536,14 @@ Tcl_FSFileAttrsGet(interp, index, pathPtr, objPtrRef) */ int -Tcl_FSFileAttrsSet(interp, index, pathPtr, objPtr) - Tcl_Interp *interp; /* The interpreter for error reporting. */ - int index; /* index of the attribute command. */ - Tcl_Obj *pathPtr; /* filename we are operating on. */ - Tcl_Obj *objPtr; /* Input value. */ +Tcl_FSFileAttrsSet( + Tcl_Interp *interp, /* The interpreter for error reporting. */ + int index, /* index of the attribute command. */ + Tcl_Obj *pathPtr, /* filename we are operating on. */ + Tcl_Obj *objPtr) /* Input value. */ { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); + if (fsPtr != NULL) { Tcl_FSFileAttrsSetProc *proc = fsPtr->fileAttrsSetProc; if (proc != NULL) { @@ -2555,10 +2561,10 @@ Tcl_FSFileAttrsSet(interp, index, pathPtr, objPtr) * * This function replaces the library version of getcwd(). * - * Most VFS's will *not* implement a 'cwdProc'. Tcl now maintains its - * own record (in a Tcl_Obj) of the cwd, and an attempt is made to - * synchronise this with the cwd's containing filesystem, if that - * filesystem provides a cwdProc (e.g. the native filesystem). + * Most VFS's will *not* implement a 'cwdProc'. Tcl now maintains its own + * record (in a Tcl_Obj) of the cwd, and an attempt is made to synch this + * with the cwd's containing filesystem, if that filesystem provides a + * cwdProc (e.g. the native filesystem). * * Note that if Tcl's cwd is not in the native filesystem, then of course * Tcl's cwd and the native cwd are different: extensions should @@ -2575,10 +2581,10 @@ Tcl_FSFileAttrsSet(interp, index, pathPtr, objPtr) * * Results: * 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 + * 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 + * The result already has its refCount incremented for the caller. When * it is no longer needed, that refCount should be decremented. * * Side effects: @@ -2587,9 +2593,9 @@ Tcl_FSFileAttrsSet(interp, index, pathPtr, objPtr) *---------------------------------------------------------------------- */ -Tcl_Obj* -Tcl_FSGetCwd(interp) - Tcl_Interp *interp; +Tcl_Obj * +Tcl_FSGetCwd( + Tcl_Interp *interp) { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&tclFsDataKey); @@ -2598,8 +2604,8 @@ Tcl_FSGetCwd(interp) Tcl_Obj *retVal = NULL; /* - * We've never been called before, try to find a cwd. Call each of - * the "Tcl_GetCwd" function in succession. A non-NULL return value + * We've never been called before, try to find a cwd. Call each of the + * "Tcl_GetCwd" function in succession. A non-NULL return value * indicates the particular function has succeeded. */ @@ -2622,15 +2628,15 @@ Tcl_FSGetCwd(interp) if (norm != NULL) { /* * We found a cwd, which is now in our global - * storage. We must make a copy. Norm already has + * storage. We must make a copy. Norm already has * a refCount of 1. * * Threading issue: note that multiple threads at * system startup could in principle call this - * procedure simultaneously. They will therefore - * each set the cwdPathPtr independently. That + * function simultaneously. They will therefore + * each set the cwdPathPtr independently. That * behaviour is a bit peculiar, but should be - * fine. Once we have a cwd, we'll always be in + * fine. Once we have a cwd, we'll always be in * the 'else' branch below which is simpler. */ @@ -2642,12 +2648,10 @@ Tcl_FSGetCwd(interp) Tcl_DecrRefCount(retVal); retVal = NULL; goto cdDidNotChange; - } else { - if (interp != NULL) { - Tcl_AppendResult(interp, - "error getting working directory name: ", - Tcl_PosixError(interp), (char *) NULL); - } + } else if (interp != NULL) { + Tcl_AppendResult(interp, + "error getting working directory name: ", + Tcl_PosixError(interp), NULL); } } else { retVal = (*proc)(interp); @@ -2669,15 +2673,15 @@ Tcl_FSGetCwd(interp) Tcl_Obj *norm = TclFSNormalizeAbsolutePath(interp, retVal, NULL); if (norm != NULL) { /* - * We found a cwd, which is now in our global storage. We - * must make a copy. Norm already has a refCount of 1. + * We found a cwd, which is now in our global storage. We must + * make a copy. Norm already has a refCount of 1. * * Threading issue: note that multiple threads at system - * startup could in principle call this procedure - * simultaneously. They will therefore each set the - * cwdPathPtr independently. That behaviour is a bit - * peculiar, but should be fine. Once we have a cwd, we'll - * always be in the 'else' branch below which is simpler. + * startup could in principle call this function + * simultaneously. They will therefore each set the cwdPathPtr + * independently. That behaviour is a bit peculiar, but should + * be fine. Once we have a cwd, we'll always be in the 'else' + * branch below which is simpler. */ ClientData cd = (ClientData) Tcl_FSGetNativePath(norm); @@ -2690,7 +2694,7 @@ Tcl_FSGetCwd(interp) /* * We already have a cwd cached, but we want to give the filesystem it * is in a chance to check whether that cwd has changed, or is perhaps - * no longer accessible. This allows an error to be thrown if, say, + * no longer accessible. This allows an error to be thrown if, say, * the permissions on that directory have changed. */ @@ -2700,7 +2704,7 @@ Tcl_FSGetCwd(interp) * If the filesystem couldn't be found, or if no cwd function exists * for this filesystem, then we simply assume the cached cwd is ok. * If we do call a cwd, we must watch for errors (if the cwd returns - * NULL). This ensures that, say, on Unix if the permissions of the + * NULL). This ensures that, say, on Unix if the permissions of the * cwd change, 'pwd' does actually throw the correct error in Tcl. * (This is tested for in the test suite on unix). */ @@ -2717,7 +2721,7 @@ Tcl_FSGetCwd(interp) if (retCd == NULL && interp != NULL) { Tcl_AppendResult(interp, "error getting working directory name: ", - Tcl_PosixError(interp), (char *) NULL); + Tcl_PosixError(interp), NULL); } if (retCd == tsdPtr->cwdClientData) { @@ -2739,7 +2743,7 @@ Tcl_FSGetCwd(interp) /* * Check whether cwd has changed from the value previously - * stored in cwdPathPtr. Really 'norm' shouldn't be null, + * stored in cwdPathPtr. Really 'norm' shouldn't be NULL, * but we are careful. */ @@ -2753,7 +2757,7 @@ Tcl_FSGetCwd(interp) } else { /* * Note that both 'norm' and 'tsdPtr->cwdPathPtr' are - * normalized paths. Therefore we can be more + * normalized paths. Therefore we can be more * efficient than calling 'Tcl_FSEqualPaths', and in * addition avoid a nasty infinite loop bug when * trying to normalize tsdPtr->cwdPathPtr. @@ -2768,7 +2772,7 @@ Tcl_FSGetCwd(interp) /* * If the paths were equal, we can be more * efficient and retain the old path object which - * will probably already be shared. In this case + * will probably already be shared. In this case * we can simply free the normalized path we just * calculated. */ @@ -2785,7 +2789,10 @@ Tcl_FSGetCwd(interp) } Tcl_DecrRefCount(retVal); } else { - /* The 'cwd' function returned an error; reset the cwd */ + /* + * The 'cwd' function returned an error; reset the cwd. + */ + FsUpdateCwd(NULL, NULL); } } @@ -2811,18 +2818,18 @@ Tcl_FSGetCwd(interp) * it. * * Results: - * See chdir() documentation. If successful, we keep a record of the + * See chdir() documentation. If successful, we keep a record of the * successful path in cwdPathPtr for subsequent calls to getcwd. * * Side effects: - * See chdir() documentation. The global cwdPathPtr may change value. + * See chdir() documentation. The global cwdPathPtr may change value. * *---------------------------------------------------------------------- */ int -Tcl_FSChdir(pathPtr) - Tcl_Obj *pathPtr; +Tcl_FSChdir( + Tcl_Obj *pathPtr) { Tcl_Filesystem *fsPtr; int retVal = -1; @@ -2851,7 +2858,7 @@ Tcl_FSChdir(pathPtr) /* * If the file can be stat'ed and is a directory and is readable, - * then we can chdir. If any of these actions fail, then + * then we can chdir. If any of these actions fail, then * 'Tcl_SetErrno()' should automatically have been called to set * an appropriate error code */ @@ -2870,22 +2877,22 @@ Tcl_FSChdir(pathPtr) } /* - * The cwd changed, or an error was thrown. If an error was thrown, we - * can just continue (and that will report the error to the user). If - * there was no error we must assume that the cwd was actually changed to - * the normalized value we calculated above, and we must therefore cache - * that information. + * The cwd changed, or an error was thrown. If an error was thrown, we can + * just continue (and that will report the error to the user). If there + * was no error we must assume that the cwd was actually changed to the + * normalized value we calculated above, and we must therefore cache that + * information. */ /* * If the filesystem in question has a getCwdProc, then the correct logic * which performs the part below is already part of the Tcl_FSGetCwd() - * call, so no need to replicate it again. This will have a side effect - * though. The private authoritative representation of the current - * working directory stored in cwdPathPtr in static memory will be - * out-of-sync with the real OS-maintained value. The first call to - * Tcl_FSGetCwd will however recalculate the private copy to match the - * OS-value so everything will work right. + * call, so no need to replicate it again. This will have a side effect + * though. The private authoritative representation of the current working + * directory stored in cwdPathPtr in static memory will be out-of-sync + * with the real OS-maintained value. The first call to Tcl_FSGetCwd will + * however recalculate the private copy to match the OS-value so + * everything will work right. * * However, if there is no getCwdProc, then we _must_ update our private * storage of the cwd, since this is the only opportunity to do that! @@ -2899,8 +2906,8 @@ Tcl_FSChdir(pathPtr) /* * Note that this normalized path may be different to what we found * above (or at least a different object), if the filesystem epoch - * changed recently. This can actually happen with scripted documents - * very easily. Therefore we ask for the normalized path again (the + * changed recently. This can actually happen with scripted documents + * very easily. Therefore we ask for the normalized path again (the * correct value will have been cached as a result of the * Tcl_FSGetFileSystemForPath call above anyway). */ @@ -2916,17 +2923,17 @@ Tcl_FSChdir(pathPtr) if (fsPtr == &tclNativeFilesystem) { /* * For the native filesystem, we keep a cache of the native - * representation of the cwd. But, we want to do that for the + * representation of the cwd. But, we want to do that for the * exact format that is returned by 'getcwd' (so that we can later * compare the two representations for equality), which might not * be exactly the same char-string as the native representation of * the fully normalized path (e.g. on Windows there's a - * forward-slash vs backslash difference). Hence we ask for this - * again here. On Unix it might actually be true that we always + * forward-slash vs backslash difference). Hence we ask for this + * again here. On Unix it might actually be true that we always * have the correct form in the native rep in which case we could * simply use: * cd = Tcl_FSGetNativePath(pathPtr); - * instead. This should be examined by someone on Unix. + * instead. This should be examined by someone on Unix. */ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&tclFsDataKey); @@ -2953,43 +2960,43 @@ Tcl_FSChdir(pathPtr) * 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. + * addresses of two functions within that file, if they are defined. The + * appropriate function for the filesystem to which pathPtr belongs will + * be called. * * Note that the native filesystem doesn't actually assume 'pathPtr' is a - * path. Rather it assumes pathPtr is either a path or just the name + * path. Rather it assumes pathPtr is either a path or just the name * (tail) of a file which can be found somewhere in the environment's - * loadable path. This behaviour is not very compatible with virtual + * loadable path. This behaviour is not very compatible with virtual * filesystems (and has other problems documented in the load man-page), * so it is advised that full paths are always used. * * Results: - * A standard Tcl completion code. If an error occurs, an error message + * A standard Tcl completion code. If an error occurs, an error message * is left in the interp's result. * * Side effects: - * New code suddenly appears in memory. This may later be unloaded by + * New code suddenly appears in memory. This may later be unloaded by * passing the clientData to the unloadProc. * *---------------------------------------------------------------------- */ int -Tcl_FSLoadFile(interp, pathPtr, sym1, sym2, proc1Ptr, proc2Ptr, - handlePtr, unloadProcPtr) - Tcl_Interp *interp; /* Used for error reporting. */ - Tcl_Obj *pathPtr; /* Name of the file containing the desired +Tcl_FSLoadFile( + Tcl_Interp *interp, /* Used for error reporting. */ + Tcl_Obj *pathPtr, /* Name of the file containing the desired * code. */ - CONST char *sym1, *sym2; /* Names of two procedures to look up in the + CONST char *sym1, CONST char *sym2, + /* Names of two functions to look up in the * file's symbol table. */ - Tcl_PackageInitProc **proc1Ptr, **proc2Ptr; + Tcl_PackageInitProc **proc1Ptr, Tcl_PackageInitProc **proc2Ptr, /* Where to return the addresses corresponding * to sym1 and sym2. */ - Tcl_LoadHandle *handlePtr; /* Filled with token for dynamically loaded + Tcl_LoadHandle *handlePtr, /* Filled with token for dynamically loaded * file which will be passed back to * (*unloadProcPtr)() to unload the file. */ - Tcl_FSUnloadFileProc **unloadProcPtr; + Tcl_FSUnloadFileProc **unloadProcPtr) /* Filled with address of Tcl_FSUnloadFileProc * function which should be used for this * file. */ @@ -2999,21 +3006,27 @@ Tcl_FSLoadFile(interp, pathPtr, sym1, sym2, proc1Ptr, proc2Ptr, ClientData clientData; int res; - /* Initialize the arrays */ + /* + * Initialize the arrays. + */ + symbols[0] = sym1; symbols[1] = sym2; procPtrs[0] = proc1Ptr; procPtrs[1] = proc2Ptr; - /* Perform the load */ - res = TclLoadFile(interp, pathPtr, 2, symbols, procPtrs, - handlePtr, &clientData, unloadProcPtr); + /* + * Perform the load. + */ + + res = TclLoadFile(interp, pathPtr, 2, symbols, procPtrs, handlePtr, + &clientData, unloadProcPtr); /* * Due to an unfortunate mis-design in Tcl 8.4 fs, when loading a shared * library, we don't keep the loadHandle (for TclpFindSymbol) and the - * clientData (for the unloadProc) separately. In fact we effectively - * throw away the loadHandle and only use the clientData. It just so + * clientData (for the unloadProc) separately. In fact we effectively + * throw away the loadHandle and only use the clientData. It just so * happens, for the native filesystem only, that these two are identical. * * This also means that the signatures Tcl_FSUnloadFileProc and @@ -3030,318 +3043,321 @@ Tcl_FSLoadFile(interp, pathPtr, sym1, sym2, proc1Ptr, proc2Ptr, * TclLoadFile -- * * Dynamically loads a binary code file into memory and returns the - * addresses of a number of given procedures within that file, if they - * are defined. The appropriate function for the filesystem to which - * pathPtr belongs will be called. + * addresses of a number of given functions within that file, if they are + * defined. The appropriate function for the filesystem to which pathPtr + * belongs will be called. * * Note that the native filesystem doesn't actually assume 'pathPtr' is a - * path. Rather it assumes pathPtr is either a path or just the name + * path. Rather it assumes pathPtr is either a path or just the name * (tail) of a file which can be found somewhere in the environment's - * loadable path. This behaviour is not very compatible with virtual + * loadable path. This behaviour is not very compatible with virtual * filesystems (and has other problems documented in the load man-page), * so it is advised that full paths are always used. * - * This function is currently private to Tcl. It may be exported in the + * This function is currently private to Tcl. It may be exported in the * future and its interface fixed (but we should clean up the * loadHandle/clientData confusion at that time -- see the above comments - * in Tcl_FSLoadFile for details). For a public function, see + * in Tcl_FSLoadFile for details). For a public function, see * Tcl_FSLoadFile. * * Results: - * A standard Tcl completion code. If an error occurs, an error message + * A standard Tcl completion code. If an error occurs, an error message * is left in the interp's result. * * Side effects: - * New code suddenly appears in memory. This may later be unloaded by + * New code suddenly appears in memory. This may later be unloaded by * passing the clientData to the unloadProc. * *---------------------------------------------------------------------- */ int -TclLoadFile(interp, pathPtr, symc, symbols, procPtrs, - handlePtr, clientDataPtr, unloadProcPtr) - Tcl_Interp *interp; /* Used for error reporting. */ - Tcl_Obj *pathPtr; /* Name of the file containing the desired +TclLoadFile( + Tcl_Interp *interp, /* Used for error reporting. */ + Tcl_Obj *pathPtr, /* Name of the file containing the desired * code. */ - int symc; /* Number of symbols/procPtrs in the next two + int symc, /* Number of symbols/procPtrs in the next two * arrays. */ - CONST char *symbols[]; /* Names of procedures to look up in the - * file's symbol table. */ - Tcl_PackageInitProc **procPtrs[]; + CONST char *symbols[], /* Names of functions to look up in the file's + * symbol table. */ + Tcl_PackageInitProc **procPtrs[], /* Where to return the addresses corresponding - * to symbols[]. */ - Tcl_LoadHandle *handlePtr; /* Filled with token for shared library + * to symbols[]. */ + Tcl_LoadHandle *handlePtr, /* Filled with token for shared library * information which can be used in * TclpFindSymbol. */ - ClientData *clientDataPtr; /* Filled with token for dynamically loaded + ClientData *clientDataPtr, /* Filled with token for dynamically loaded * file which will be passed back to * (*unloadProcPtr)() to unload the file. */ - Tcl_FSUnloadFileProc **unloadProcPtr; + Tcl_FSUnloadFileProc **unloadProcPtr) /* Filled with address of Tcl_FSUnloadFileProc * function which should be used for this * file. */ { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); - if (fsPtr != NULL) { - Tcl_FSLoadFileProc *proc = fsPtr->loadFileProc; - Tcl_Filesystem *copyFsPtr; - Tcl_Obj *copyToPtr; + Tcl_FSLoadFileProc *proc; + Tcl_Filesystem *copyFsPtr; + Tcl_Obj *copyToPtr; + Tcl_LoadHandle newLoadHandle = NULL; + ClientData newClientData = NULL; + Tcl_FSUnloadFileProc *newUnloadProcPtr = NULL; + FsDivertLoad *tvdlPtr; + int retVal; - if (proc != NULL) { - int retVal = (*proc)(interp, pathPtr, handlePtr, unloadProcPtr); - if (retVal == TCL_OK) { - int i; - if (*handlePtr == NULL) { - return TCL_ERROR; - } - for (i=0 ; i<symc ; i++) { - if (symbols[i] != NULL) { - *procPtrs[i] = TclpFindSymbol(interp, *handlePtr, - symbols[i]); - } - } - - /* - * Copy this across, since both are equal for the native fs. - */ + if (fsPtr == NULL) { + Tcl_SetErrno(ENOENT); + return TCL_ERROR; + } - *clientDataPtr = (ClientData)*handlePtr; - Tcl_ResetResult(interp); - return TCL_OK; - } - if (Tcl_GetErrno() != EXDEV) { - return retVal; + proc = fsPtr->loadFileProc; + if (proc != NULL) { + int retVal = (*proc)(interp, pathPtr, handlePtr, unloadProcPtr); + if (retVal == TCL_OK) { + if (*handlePtr == NULL) { + return TCL_ERROR; } - } - /* - * The filesystem doesn't support 'load', so we fall back on the - * following technique: - * - * First check if it is readable -- and exists! - */ + /* + * Copy this across, since both are equal for the native fs. + */ - if (Tcl_FSAccess(pathPtr, R_OK) != 0) { - Tcl_AppendResult(interp, "couldn't load library \"", - Tcl_GetString(pathPtr), "\": ", - Tcl_PosixError(interp), (char *) NULL); - return TCL_ERROR; + *clientDataPtr = (ClientData)*handlePtr; + Tcl_ResetResult(interp); + goto resolveSymbols; + } + if (Tcl_GetErrno() != EXDEV) { + return retVal; } + } + + /* + * The filesystem doesn't support 'load', so we fall back on the following + * technique: + * + * First check if it is readable -- and exists! + */ + + if (Tcl_FSAccess(pathPtr, R_OK) != 0) { + Tcl_AppendResult(interp, "couldn't load library \"", + Tcl_GetString(pathPtr), "\": ", Tcl_PosixError(interp), NULL); + return TCL_ERROR; + } #ifdef TCL_LOAD_FROM_MEMORY - /* - * The platform supports loading code from memory, so ask for a buffer - * of the appropriate size, read the file into it and load the code - * from the buffer: - */ + /* + * The platform supports loading code from memory, so ask for a buffer of + * the appropriate size, read the file into it and load the code from the + * buffer: + */ - do { - int ret, size; - void *buffer; - Tcl_StatBuf statBuf; - Tcl_Channel data; + { + int ret, size; + void *buffer; + Tcl_StatBuf statBuf; + Tcl_Channel data; - ret = Tcl_FSStat(pathPtr, &statBuf); - if (ret < 0) { - break; - } - size = (int) statBuf.st_size; + ret = Tcl_FSStat(pathPtr, &statBuf); + if (ret < 0) { + goto mustCopyToTempAnyway; + } + size = (int) statBuf.st_size; - /* - * Tcl_Read takes an int: check that file size isn't wide. - */ + /* + * Tcl_Read takes an int: check that file size isn't wide. + */ - if (size != (Tcl_WideInt) statBuf.st_size) { - break; - } - data = Tcl_FSOpenFileChannel(interp, pathPtr, "r", 0666); - if (!data) { - break; - } - buffer = TclpLoadMemoryGetBuffer(interp, size); - if (!buffer) { - Tcl_Close(interp, data); - break; - } - Tcl_SetChannelOption(interp, data, "-translation", "binary"); - ret = Tcl_Read(data, buffer, size); + if (size != (Tcl_WideInt) statBuf.st_size) { + goto mustCopyToTempAnyway; + } + data = Tcl_FSOpenFileChannel(interp, pathPtr, "rb", 0666); + if (!data) { + goto mustCopyToTempAnyway; + } + buffer = TclpLoadMemoryGetBuffer(interp, size); + if (!buffer) { Tcl_Close(interp, data); - ret = TclpLoadMemory(interp, buffer, size, ret, handlePtr, - unloadProcPtr); - if (ret == TCL_OK) { - int i; - if (*handlePtr == NULL) { - break; - } - for (i = 0;i < symc;i++) { - if (symbols[i] != NULL) { - *procPtrs[i] = TclpFindSymbol(interp, *handlePtr, - symbols[i]); - } - } - *clientDataPtr = (ClientData) *handlePtr; - return TCL_OK; - } - } while (0); - Tcl_ResetResult(interp); + goto mustCopyToTempAnyway; + } + ret = Tcl_Read(data, buffer, size); + Tcl_Close(interp, data); + ret = TclpLoadMemory(interp, buffer, size, ret, handlePtr, + unloadProcPtr); + if (ret == TCL_OK && *handlePtr != NULL) { + *clientDataPtr = (ClientData) *handlePtr; + goto resolveSymbols; + } + } + + mustCopyToTempAnyway: + Tcl_ResetResult(interp); #endif + /* + * Get a temporary filename to use, first to copy the file into, and then + * to load. + */ + + copyToPtr = TclpTempFileName(); + if (copyToPtr == NULL) { + Tcl_AppendResult(interp, "couldn't create temporary file: ", + Tcl_PosixError(interp), NULL); + return TCL_ERROR; + } + Tcl_IncrRefCount(copyToPtr); + + copyFsPtr = Tcl_FSGetFileSystemForPath(copyToPtr); + if ((copyFsPtr == NULL) || (copyFsPtr == fsPtr)) { /* - * Get a temporary filename to use, first to copy the file into, and - * then to load. + * We already know we can't use Tcl_FSLoadFile from this filesystem, + * and we must avoid a possible infinite loop. Try to delete the file + * we probably created, and then exit. */ - copyToPtr = TclpTempFileName(); - if (copyToPtr == NULL) { - Tcl_AppendResult(interp, "couldn't create temporary file: ", - Tcl_PosixError(interp), (char *) NULL); - return TCL_ERROR; - } - Tcl_IncrRefCount(copyToPtr); - - copyFsPtr = Tcl_FSGetFileSystemForPath(copyToPtr); - if ((copyFsPtr == NULL) || (copyFsPtr == fsPtr)) { - /* - * We already know we can't use Tcl_FSLoadFile from this - * filesystem, and we must avoid a possible infinite loop. Try to - * delete the file we probably created, and then exit. - */ + Tcl_FSDeleteFile(copyToPtr); + Tcl_DecrRefCount(copyToPtr); + Tcl_AppendResult(interp, "couldn't load from current filesystem",NULL); + return TCL_ERROR; + } - Tcl_FSDeleteFile(copyToPtr); - Tcl_DecrRefCount(copyToPtr); - Tcl_AppendResult(interp, "couldn't load from current filesystem", - (char *) NULL); - return TCL_ERROR; - } + if (TclCrossFilesystemCopy(interp, pathPtr, copyToPtr) != TCL_OK) { + /* + * Cross-platform copy failed. + */ - if (TclCrossFilesystemCopy(interp, pathPtr, copyToPtr) == TCL_OK) { - Tcl_LoadHandle newLoadHandle = NULL; - ClientData newClientData = NULL; - Tcl_FSUnloadFileProc *newUnloadProcPtr = NULL; - FsDivertLoad *tvdlPtr; - int retVal; + Tcl_FSDeleteFile(copyToPtr); + Tcl_DecrRefCount(copyToPtr); + return TCL_ERROR; + } #if !defined(__WIN32__) - /* - * Do we need to set appropriate permissions on the file? This - * may be required on some systems. On Unix we could loop over - * the file attributes, and set any that are called "-permissions" - * to 0700. However, we just do this directly, like this: - */ + /* + * Do we need to set appropriate permissions on the file? This may be + * required on some systems. On Unix we could loop over the file + * attributes, and set any that are called "-permissions" to 0700. However + * we just do this directly, like this: + */ - int index; - Tcl_Obj* perm = Tcl_NewStringObj("0700",-1); - Tcl_IncrRefCount(perm); - if (TclFSFileAttrIndex(copyToPtr, "-permissions", - &index) == TCL_OK) { - Tcl_FSFileAttrsSet(NULL, index, copyToPtr, perm); - } - Tcl_DecrRefCount(perm); + { + int index; + Tcl_Obj* perm = Tcl_NewStringObj("0700",-1); + + Tcl_IncrRefCount(perm); + if (TclFSFileAttrIndex(copyToPtr, "-permissions", &index) == TCL_OK) { + Tcl_FSFileAttrsSet(NULL, index, copyToPtr, perm); + } + Tcl_DecrRefCount(perm); + } #endif - /* - * We need to reset the result now, because the cross- filesystem - * copy may have stored the number of bytes in the result. - */ + /* + * We need to reset the result now, because the cross-filesystem copy may + * have stored the number of bytes in the result. + */ - Tcl_ResetResult(interp); + Tcl_ResetResult(interp); - retVal = TclLoadFile(interp, copyToPtr, symc, symbols, procPtrs, - &newLoadHandle, &newClientData, &newUnloadProcPtr); - if (retVal != TCL_OK) { - /* The file didn't load successfully */ - Tcl_FSDeleteFile(copyToPtr); - Tcl_DecrRefCount(copyToPtr); - return retVal; - } + retVal = TclLoadFile(interp, copyToPtr, symc, symbols, procPtrs, + &newLoadHandle, &newClientData, &newUnloadProcPtr); + if (retVal != TCL_OK) { + /* + * The file didn't load successfully. + */ - /* - * Try to delete the file immediately - this is possible in some - * OSes, and avoids any worries about leaving the copy laying - * around on exit. - */ + Tcl_FSDeleteFile(copyToPtr); + Tcl_DecrRefCount(copyToPtr); + return retVal; + } - if (Tcl_FSDeleteFile(copyToPtr) == TCL_OK) { - Tcl_DecrRefCount(copyToPtr); + /* + * Try to delete the file immediately - this is possible in some OSes, and + * avoids any worries about leaving the copy laying around on exit. + */ - /* - * We tell our caller about the real shared library which was - * loaded. Note that this does mean that the package list - * maintained by 'load' will store the original (vfs) path - * alongside the temporary load handle and unload proc ptr. - */ + if (Tcl_FSDeleteFile(copyToPtr) == TCL_OK) { + Tcl_DecrRefCount(copyToPtr); - (*handlePtr) = newLoadHandle; - (*clientDataPtr) = newClientData; - (*unloadProcPtr) = newUnloadProcPtr; - Tcl_ResetResult(interp); - return TCL_OK; - } + /* + * We tell our caller about the real shared library which was loaded. + * Note that this does mean that the package list maintained by 'load' + * will store the original (vfs) path alongside the temporary load + * handle and unload proc ptr. + */ - /* - * When we unload this file, we need to divert the unloading so we - * can unload and cleanup the temporary file correctly. - */ + (*handlePtr) = newLoadHandle; + (*clientDataPtr) = newClientData; + (*unloadProcPtr) = newUnloadProcPtr; + Tcl_ResetResult(interp); + return TCL_OK; + } - tvdlPtr = (FsDivertLoad *) ckalloc(sizeof(FsDivertLoad)); + /* + * When we unload this file, we need to divert the unloading so we can + * unload and cleanup the temporary file correctly. + */ - /* - * Remember three pieces of information. This allows us to - * cleanup the diverted load completely, on platforms which allow - * proper unloading of code. - */ + tvdlPtr = (FsDivertLoad *) ckalloc(sizeof(FsDivertLoad)); - tvdlPtr->loadHandle = newLoadHandle; - tvdlPtr->unloadProcPtr = newUnloadProcPtr; + /* + * Remember three pieces of information. This allows us to cleanup the + * diverted load completely, on platforms which allow proper unloading of + * code. + */ - if (copyFsPtr != &tclNativeFilesystem) { - /* copyToPtr is already incremented for this reference */ - tvdlPtr->divertedFile = copyToPtr; + tvdlPtr->loadHandle = newLoadHandle; + tvdlPtr->unloadProcPtr = newUnloadProcPtr; - /* - * This is the filesystem we loaded it into. Since we have a - * reference to 'copyToPtr', we already have a refCount on - * this filesystem, so we don't need to worry about it - * disappearing on us. - */ + if (copyFsPtr != &tclNativeFilesystem) { + /* + * copyToPtr is already incremented for this reference. + */ - tvdlPtr->divertedFilesystem = copyFsPtr; - tvdlPtr->divertedFileNativeRep = NULL; - } else { - /* We need the native rep */ - tvdlPtr->divertedFileNativeRep = TclNativeDupInternalRep( - Tcl_FSGetInternalRep(copyToPtr, copyFsPtr)); + tvdlPtr->divertedFile = copyToPtr; - /* - * We don't need or want references to the copied Tcl_Obj or - * the filesystem if it is the native one. - */ + /* + * This is the filesystem we loaded it into. Since we have a reference + * to 'copyToPtr', we already have a refCount on this filesystem, so + * we don't need to worry about it disappearing on us. + */ - tvdlPtr->divertedFile = NULL; - tvdlPtr->divertedFilesystem = NULL; - Tcl_DecrRefCount(copyToPtr); - } + tvdlPtr->divertedFilesystem = copyFsPtr; + tvdlPtr->divertedFileNativeRep = NULL; + } else { + /* + * We need the native rep. + */ - copyToPtr = NULL; - (*handlePtr) = newLoadHandle; - (*clientDataPtr) = (ClientData) tvdlPtr; - (*unloadProcPtr) = &FSUnloadTempFile; - Tcl_ResetResult(interp); - return retVal; + tvdlPtr->divertedFileNativeRep = TclNativeDupInternalRep( + Tcl_FSGetInternalRep(copyToPtr, copyFsPtr)); - } else { - /* - * Cross-platform copy failed. - */ + /* + * We don't need or want references to the copied Tcl_Obj or the + * filesystem if it is the native one. + */ - Tcl_FSDeleteFile(copyToPtr); - Tcl_DecrRefCount(copyToPtr); - return TCL_ERROR; + tvdlPtr->divertedFile = NULL; + tvdlPtr->divertedFilesystem = NULL; + Tcl_DecrRefCount(copyToPtr); + } + + copyToPtr = NULL; + (*handlePtr) = newLoadHandle; + (*clientDataPtr) = (ClientData) tvdlPtr; + (*unloadProcPtr) = &FSUnloadTempFile; + + Tcl_ResetResult(interp); + return retVal; + + resolveSymbols: + { + int i; + + for (i=0 ; i<symc ; i++) { + if (symbols[i] != NULL) { + *procPtrs[i] = TclpFindSymbol(interp, *handlePtr, symbols[i]); + } } } - Tcl_SetErrno(ENOENT); - return TCL_ERROR; + return TCL_OK; } /* * This function used to be in the platform specific directories, but it has @@ -3349,20 +3365,20 @@ TclLoadFile(interp, pathPtr, symc, symbols, procPtrs, */ int -TclpLoadFile(interp, pathPtr, sym1, sym2, proc1Ptr, proc2Ptr, - clientDataPtr, unloadProcPtr) - Tcl_Interp *interp; /* Used for error reporting. */ - Tcl_Obj *pathPtr; /* Name of the file containing the desired +TclpLoadFile( + Tcl_Interp *interp, /* Used for error reporting. */ + Tcl_Obj *pathPtr, /* Name of the file containing the desired * code (UTF-8). */ - CONST char *sym1, *sym2; /* Names of two procedures to look up in the + CONST char *sym1, CONST char *sym2, + /* Names of two functions to look up in the * file's symbol table. */ - Tcl_PackageInitProc **proc1Ptr, **proc2Ptr; + Tcl_PackageInitProc **proc1Ptr, Tcl_PackageInitProc **proc2Ptr, /* Where to return the addresses corresponding * to sym1 and sym2. */ - ClientData *clientDataPtr; /* Filled with token for dynamically loaded + ClientData *clientDataPtr, /* Filled with token for dynamically loaded * file which will be passed back to * (*unloadProcPtr)() to unload the file. */ - Tcl_FSUnloadFileProc **unloadProcPtr; + Tcl_FSUnloadFileProc **unloadProcPtr) /* Filled with address of Tcl_FSUnloadFileProc * function which should be used for this * file. */ @@ -3380,7 +3396,7 @@ TclpLoadFile(interp, pathPtr, sym1, sym2, proc1Ptr, proc2Ptr, return TCL_ERROR; } - *clientDataPtr = (ClientData)handle; + *clientDataPtr = (ClientData) handle; *proc1Ptr = TclpFindSymbol(interp, handle, sym1); *proc2Ptr = TclpFindSymbol(interp, handle, sym2); @@ -3393,7 +3409,7 @@ TclpLoadFile(interp, pathPtr, sym1, sym2, proc1Ptr, proc2Ptr, * FSUnloadTempFile -- * * This function is called when we loaded a library of code via an - * intermediate temporary file. This function ensures the library is + * intermediate temporary file. This function ensures the library is * correctly unloaded and the temporary file is correctly deleted. * * Results: @@ -3405,25 +3421,28 @@ TclpLoadFile(interp, pathPtr, sym1, sym2, proc1Ptr, proc2Ptr, * *--------------------------------------------------------------------------- */ + static void -FSUnloadTempFile(loadHandle) - Tcl_LoadHandle loadHandle; /* loadHandle returned by a previous call to - * Tcl_FSLoadFile(). The loadHandle is a token - * that represents the loaded file. */ +FSUnloadTempFile( + Tcl_LoadHandle loadHandle) /* loadHandle returned by a previous call to + * Tcl_FSLoadFile(). The loadHandle is a token + * that represents the loaded file. */ { - FsDivertLoad *tvdlPtr = (FsDivertLoad*)loadHandle; + FsDivertLoad *tvdlPtr = (FsDivertLoad *) loadHandle; /* * This test should never trigger, since we give the client data in the * function above. */ - if (tvdlPtr == NULL) { return; } + if (tvdlPtr == NULL) { + return; + } /* * Call the real 'unloadfile' proc we actually used. It is very important * that we call this first, so that the shared library is actually - * unloaded by the OS. Otherwise, the following 'delete' may well fail + * unloaded by the OS. Otherwise, the following 'delete' may well fail * because the shared library is still in use. */ @@ -3443,7 +3462,7 @@ FSUnloadTempFile(loadHandle) } else { /* - * Remove the temporary file we created. Note, we may crash here + * Remove the temporary file we created. Note, we may crash here * because encodings have been taken down already. */ @@ -3467,7 +3486,7 @@ FSUnloadTempFile(loadHandle) } /* - * And free up the allocations. This will also of course remove a + * And free up the allocations. This will also of course remove a * refCount from the Tcl_Filesystem to which this file belongs, which * could then free up the filesystem if we are exiting. */ @@ -3484,18 +3503,18 @@ FSUnloadTempFile(loadHandle) * Tcl_FSLink -- * * This function replaces the library version of readlink() and can also - * be used to make links. The appropriate function for the filesystem to + * be used to make links. The appropriate function for the filesystem to * which pathPtr belongs will be called. * * Results: * If toPtr is NULL, then the result is a Tcl_Obj specifying the contents * of the symbolic link given by 'pathPtr', or NULL if the symbolic link - * could not be read. The result is owned by the caller, which should + * could not be read. The result is owned by the caller, which should * call Tcl_DecrRefCount when the result is no longer needed. * * If toPtr is non-NULL, then the result is toPtr if the link action was - * successful, or NULL if not. In this case the result has no additional - * reference count, and need not be freed. The actual action to perform + * successful, or NULL if not. In this case the result has no additional + * reference count, and need not be freed. The actual action to perform * is given by the 'linkAction' flags, which is an or'd combination of: * * TCL_CREATE_SYMBOLIC_LINK @@ -3506,20 +3525,22 @@ FSUnloadTempFile(loadHandle) * is in the same FS as pathPtr. * * Side effects: - * See readlink() documentation. A new filesystem link object may appear + * See readlink() documentation. A new filesystem link object may appear. * *--------------------------------------------------------------------------- */ Tcl_Obj * -Tcl_FSLink(pathPtr, toPtr, linkAction) - Tcl_Obj *pathPtr; /* Path of file to readlink or link */ - Tcl_Obj *toPtr; /* NULL or path to be linked to */ - int linkAction; /* Action to perform */ +Tcl_FSLink( + Tcl_Obj *pathPtr, /* Path of file to readlink or link */ + Tcl_Obj *toPtr, /* NULL or path to be linked to */ + int linkAction) /* Action to perform */ { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); + if (fsPtr != NULL) { Tcl_FSLinkProc *proc = fsPtr->linkProc; + if (proc != NULL) { return (*proc)(pathPtr, toPtr, linkAction); } @@ -3527,10 +3548,10 @@ Tcl_FSLink(pathPtr, toPtr, linkAction) /* * If S_IFLNK isn't defined it means that the machine doesn't support - * symbolic links, so the file can't possibly be a symbolic link. - * Generate an EINVAL error, which is what happens on machines that do - * support symbolic links when you invoke readlink on a file that isn't a - * symbolic link. + * symbolic links, so the file can't possibly be a symbolic link. Generate + * an EINVAL error, which is what happens on machines that do support + * symbolic links when you invoke readlink on a file that isn't a symbolic + * link. */ #ifndef S_IFLNK @@ -3546,15 +3567,15 @@ Tcl_FSLink(pathPtr, toPtr, linkAction) * * Tcl_FSListVolumes -- * - * Lists the currently mounted volumes. The chain of functions that have + * Lists the currently mounted volumes. The chain of functions that have * been "inserted" into the filesystem will be called in succession; each * may return a list of volumes, all of which are added to the result * until all mounted file systems are listed. * * Notice that we assume the lists returned by each filesystem (if non - * NULL) have been given a refCount for us already. However, we are NOT + * NULL) have been given a refCount for us already. However, we are NOT * allowed to hang on to the list itself (it belongs to the filesystem we - * called). Therefore we quite naturally add its contents to the result + * called). Therefore we quite naturally add its contents to the result * we are building, and then decrement the refCount. * * Results: @@ -3573,8 +3594,8 @@ Tcl_FSListVolumes(void) Tcl_Obj *resultPtr = Tcl_NewObj(); /* - * Call each of the "listVolumes" function in succession. A non-NULL - * return value indicates the particular function has succeeded. We call + * Call each of the "listVolumes" function in succession. A non-NULL + * return value indicates the particular function has succeeded. We call * all the functions registered, since we want a list of all drives from * all filesystems. */ @@ -3613,10 +3634,10 @@ Tcl_FSListVolumes(void) *--------------------------------------------------------------------------- */ -static Tcl_Obj* -FsListMounts(pathPtr, pattern) - Tcl_Obj *pathPtr; /* Contains path to directory to search. */ - CONST char *pattern; /* Pattern to match against. */ +static Tcl_Obj * +FsListMounts( + Tcl_Obj *pathPtr, /* Contains path to directory to search. */ + CONST char *pattern) /* Pattern to match against. */ { FilesystemRecord *fsRecPtr; Tcl_GlobTypeData mountsOnly = { TCL_GLOB_TYPE_MOUNT, 0, NULL, NULL }; @@ -3624,8 +3645,8 @@ FsListMounts(pathPtr, pattern) /* * Call each of the "matchInDirectory" functions in succession, with the - * specific type information 'mountsOnly'. A non-NULL return value - * indicates the particular function has succeeded. We call all the + * specific type information 'mountsOnly'. A non-NULL return value + * indicates the particular function has succeeded. We call all the * functions registered, since we want a list from each filesystems. */ @@ -3657,7 +3678,7 @@ FsListMounts(pathPtr, pattern) * an element. * * Results: - * Returns list object with refCount of zero. If the passed in lenPtr is + * 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. * @@ -3667,10 +3688,10 @@ FsListMounts(pathPtr, pattern) *--------------------------------------------------------------------------- */ -Tcl_Obj* -Tcl_FSSplitPath(pathPtr, lenPtr) - Tcl_Obj *pathPtr; /* Path to split. */ - int *lenPtr; /* int to store number of path elements. */ +Tcl_Obj * +Tcl_FSSplitPath( + Tcl_Obj *pathPtr, /* Path to split. */ + int *lenPtr) /* int to store number of path elements. */ { Tcl_Obj *result = NULL; /* Needed only to prevent gcc warnings. */ Tcl_Filesystem *fsPtr; @@ -3705,7 +3726,7 @@ Tcl_FSSplitPath(pathPtr, lenPtr) } /* - * Place the drive name as first element of the result list. The drive + * Place the drive name as first element of the result list. The drive * name may contain strange characters, like colons and multiple forward * slashes (for example 'ftp://' is a valid vfs drive name) */ @@ -3753,11 +3774,11 @@ Tcl_FSSplitPath(pathPtr, lenPtr) } /* Simple helper function */ -Tcl_Obj* -TclFSInternalToNormalized(fromFilesystem, clientData, fsRecPtrPtr) - Tcl_Filesystem *fromFilesystem; - ClientData clientData; - FilesystemRecord **fsRecPtrPtr; +Tcl_Obj * +TclFSInternalToNormalized( + Tcl_Filesystem *fromFilesystem, + ClientData clientData, + FilesystemRecord **fsRecPtrPtr) { FilesystemRecord *fsRecPtr = FsGetFirstFilesystem(); @@ -3786,7 +3807,7 @@ TclFSInternalToNormalized(fromFilesystem, clientData, fsRecPtrPtr) * * Results: * Returns one of TCL_PATH_ABSOLUTE, TCL_PATH_RELATIVE, or - * TCL_PATH_VOLUME_RELATIVE. The filesystem reference will be set if and + * TCL_PATH_VOLUME_RELATIVE. The filesystem reference will be set if and * only if it is non-NULL and the function's return value is * TCL_PATH_ABSOLUTE. * @@ -3797,19 +3818,20 @@ TclFSInternalToNormalized(fromFilesystem, clientData, fsRecPtrPtr) */ Tcl_PathType -TclGetPathType(pathPtr, filesystemPtrPtr, driveNameLengthPtr, driveNameRef) - Tcl_Obj *pathPtr; /* Path to determine type for */ - Tcl_Filesystem **filesystemPtrPtr; /* If absolute path and this is not - * NULL, then set to the filesystem - * which claims this path. */ - int *driveNameLengthPtr; /* If the path is absolute, and this - * is non-NULL, then set to the length - * of the driveName. */ - Tcl_Obj **driveNameRef; /* If the path is absolute, and this - * is non-NULL, then set to the name - * of the drive, network-volume which - * contains the path, already with a - * refCount for the caller. */ +TclGetPathType( + Tcl_Obj *pathPtr, /* Path to determine type for */ + Tcl_Filesystem **filesystemPtrPtr, + /* If absolute path and this is not NULL, then + * set to the filesystem which claims this + * path. */ + int *driveNameLengthPtr, /* If the path is absolute, and this is + * non-NULL, then set to the length of the + * driveName. */ + Tcl_Obj **driveNameRef) /* If the path is absolute, and this is + * non-NULL, then set to the name of the + * drive, network-volume which contains the + * path, already with a refCount for the + * caller. */ { int pathLen; char *path; @@ -3835,14 +3857,14 @@ TclGetPathType(pathPtr, filesystemPtrPtr, driveNameLengthPtr, driveNameRef) * * TclFSNonnativePathType -- * - * Helper function used by TclGetPathType. Its purpose is to check + * Helper function used by TclGetPathType. Its purpose is to check * whether the given path starts with a string which corresponds to a - * file volume in any registered filesystem except the native one. For + * file volume in any registered filesystem except the native one. For * speed and historical reasons the native filesystem has special * hard-coded checks dotted here and there in the filesystem code. * * Results: - * Returns one of TCL_PATH_ABSOLUTE or TCL_PATH_RELATIVE. The filesystem + * Returns one of TCL_PATH_ABSOLUTE or TCL_PATH_RELATIVE. The filesystem * reference will be set if and only if it is non-NULL and the function's * return value is TCL_PATH_ABSOLUTE. * @@ -3853,21 +3875,21 @@ TclGetPathType(pathPtr, filesystemPtrPtr, driveNameLengthPtr, driveNameRef) */ Tcl_PathType -TclFSNonnativePathType(path, pathLen, filesystemPtrPtr, driveNameLengthPtr, - driveNameRef) - CONST char *path; /* Path to determine type for */ - int pathLen; /* Length of the path */ - Tcl_Filesystem **filesystemPtrPtr; /* If absolute path and this is not - * NULL, then set to the filesystem - * which claims this path. */ - int *driveNameLengthPtr; /* If the path is absolute, and this - * is non-NULL, then set to the length - * of the driveName. */ - Tcl_Obj **driveNameRef; /* If the path is absolute, and this - * is non-NULL, then set to the name - * of the drive, network-volume which - * contains the path, already with a - * refCount for the caller. */ +TclFSNonnativePathType( + CONST char *path, /* Path to determine type for */ + int pathLen, /* Length of the path */ + Tcl_Filesystem **filesystemPtrPtr, + /* If absolute path and this is not NULL, then + * set to the filesystem which claims this + * path. */ + int *driveNameLengthPtr, /* If the path is absolute, and this is + * non-NULL, then set to the length of the + * driveName. */ + Tcl_Obj **driveNameRef) /* If the path is absolute, and this is + * non-NULL, then set to the name of the + * drive, network-volume which contains the + * path, already with a refCount for the + * caller. */ { FilesystemRecord *fsRecPtr; Tcl_PathType type = TCL_PATH_RELATIVE; @@ -3888,7 +3910,7 @@ TclFSNonnativePathType(path, pathLen, filesystemPtrPtr, driveNameLengthPtr, * is because some of the tests artificially change the current * platform (between win, unix) but the list of volumes we get by * calling (*proc) will reflect the current (real) platform only and - * this may cause some tests to fail. In particular, on unix '/' will + * this may cause some tests to fail. In particular, on unix '/' will * match the beginning of certain absolute Windows paths starting '//' * and those tests will go wrong. * @@ -3904,12 +3926,13 @@ TclFSNonnativePathType(path, pathLen, filesystemPtrPtr, driveNameLengthPtr, if ((fsRecPtr->fsPtr != &tclNativeFilesystem) && (proc != NULL)) { int numVolumes; Tcl_Obj *thisFsVolumes = (*proc)(); + if (thisFsVolumes != NULL) { - if (Tcl_ListObjLength(NULL, thisFsVolumes, - &numVolumes) != TCL_OK) { + if (Tcl_ListObjLength(NULL, thisFsVolumes, &numVolumes) + != TCL_OK) { /* * This is VERY bad; the Tcl_FSListVolumesProc didn't - * return a valid list. Set numVolumes to -1 so that we + * return a valid list. Set numVolumes to -1 so that we * skip the while loop below and just return with the * current value of 'type'. * @@ -3947,7 +3970,9 @@ TclFSNonnativePathType(path, pathLen, filesystemPtrPtr, driveNameLengthPtr, } Tcl_DecrRefCount(thisFsVolumes); if (type == TCL_PATH_ABSOLUTE) { - /* We don't need to examine any more filesystems */ + /* + * We don't need to examine any more filesystems. + */ break; } } @@ -3963,7 +3988,7 @@ TclFSNonnativePathType(path, pathLen, filesystemPtrPtr, driveNameLengthPtr, * Tcl_FSRenameFile -- * * If the two paths given belong to the same filesystem, we call that - * filesystems rename function. Otherwise we simply return the posix + * filesystems rename function. Otherwise we simply return the POSIX * error 'EXDEV', and -1. * * Results: @@ -3976,10 +4001,10 @@ TclFSNonnativePathType(path, pathLen, filesystemPtrPtr, driveNameLengthPtr, */ int -Tcl_FSRenameFile(srcPathPtr, destPathPtr) - Tcl_Obj* srcPathPtr; /* Pathname of file or dir to be renamed +Tcl_FSRenameFile( + Tcl_Obj* srcPathPtr, /* Pathname of file or dir to be renamed * (UTF-8). */ - Tcl_Obj *destPathPtr; /* New pathname of file or directory + Tcl_Obj *destPathPtr) /* New pathname of file or directory * (UTF-8). */ { int retVal = -1; @@ -3987,10 +4012,10 @@ Tcl_FSRenameFile(srcPathPtr, destPathPtr) fsPtr = Tcl_FSGetFileSystemForPath(srcPathPtr); fsPtr2 = Tcl_FSGetFileSystemForPath(destPathPtr); - if (fsPtr == fsPtr2 && fsPtr != NULL) { + if ((fsPtr == fsPtr2) && (fsPtr != NULL)) { Tcl_FSRenameFileProc *proc = fsPtr->renameFileProc; if (proc != NULL) { - retVal = (*proc)(srcPathPtr, destPathPtr); + retVal = (*proc)(srcPathPtr, destPathPtr); } } if (retVal == -1) { @@ -4005,8 +4030,8 @@ Tcl_FSRenameFile(srcPathPtr, destPathPtr) * Tcl_FSCopyFile -- * * If the two paths given belong to the same filesystem, we call that - * filesystem's copy function. Otherwise we simply return the posix - * error 'EXDEV', and -1. + * filesystem's copy function. Otherwise we simply return the POSIX error + * 'EXDEV', and -1. * * Note that in the native filesystems, 'copyFileProc' is defined to copy * soft links (i.e. it copies the links themselves, not the things they @@ -4022,9 +4047,9 @@ Tcl_FSRenameFile(srcPathPtr, destPathPtr) */ int -Tcl_FSCopyFile(srcPathPtr, destPathPtr) - Tcl_Obj* srcPathPtr; /* Pathname of file to be copied (UTF-8). */ - Tcl_Obj *destPathPtr; /* Pathname of file to copy to (UTF-8). */ +Tcl_FSCopyFile( + Tcl_Obj *srcPathPtr, /* Pathname of file to be copied (UTF-8). */ + Tcl_Obj *destPathPtr) /* Pathname of file to copy to (UTF-8). */ { int retVal = -1; Tcl_Filesystem *fsPtr, *fsPtr2; @@ -4049,7 +4074,7 @@ Tcl_FSCopyFile(srcPathPtr, destPathPtr) * TclCrossFilesystemCopy -- * * Helper for above function, and for Tcl_FSLoadFile, to copy files from - * one filesystem to another. This function will overwrite the target + * one filesystem to another. This function will overwrite the target * file if it already exists. * * Results: @@ -4061,64 +4086,62 @@ Tcl_FSCopyFile(srcPathPtr, destPathPtr) *--------------------------------------------------------------------------- */ int -TclCrossFilesystemCopy(interp, source, target) - Tcl_Interp *interp; /* For error messages */ - Tcl_Obj *source; /* Pathname of file to be copied (UTF-8). */ - Tcl_Obj *target; /* Pathname of file to copy to (UTF-8). */ +TclCrossFilesystemCopy( + Tcl_Interp *interp, /* For error messages */ + Tcl_Obj *source, /* Pathname of file to be copied (UTF-8). */ + Tcl_Obj *target) /* Pathname of file to copy to (UTF-8). */ { int result = TCL_ERROR; int prot = 0666; + Tcl_Channel in, out; + Tcl_StatBuf sourceStatBuf; + struct utimbuf tval; - Tcl_Channel out = Tcl_FSOpenFileChannel(interp, target, "w", prot); - if (out != NULL) { + out = Tcl_FSOpenFileChannel(interp, target, "wb", prot); + if (out == NULL) { /* - * It looks like we can copy it over. + * It looks like we cannot copy it over. Bail out... */ + goto done; + } - Tcl_Channel in = Tcl_FSOpenFileChannel(interp, source, "r", prot); - - if (in == NULL) { - /* - * This is very strange, we checked this above - */ - - Tcl_Close(interp, out); - - } else { - Tcl_StatBuf sourceStatBuf; - struct utimbuf tval; + in = Tcl_FSOpenFileChannel(interp, source, "rb", prot); + if (in == NULL) { + /* + * This is very strange, caller should have checked this... + */ - /* - * Copy it synchronously. We might wish to add an asynchronous - * option to support vfs's which are slow (e.g. network sockets). - */ + Tcl_Close(interp, out); + goto done; + } - Tcl_SetChannelOption(interp, in, "-translation", "binary"); - Tcl_SetChannelOption(interp, out, "-translation", "binary"); + /* + * Copy it synchronously. We might wish to add an asynchronous option to + * support vfs's which are slow (e.g. network sockets). + */ - if (TclCopyChannel(interp, in, out, -1, NULL) == TCL_OK) { - result = TCL_OK; - } + if (TclCopyChannel(interp, in, out, -1, NULL) == TCL_OK) { + result = TCL_OK; + } - /* - * If the copy failed, assume that copy channel left a good error - * message. - */ + /* + * If the copy failed, assume that copy channel left a good error message. + */ - Tcl_Close(interp, in); - Tcl_Close(interp, out); + Tcl_Close(interp, in); + Tcl_Close(interp, out); - /* - * Set modification date of copied file. - */ + /* + * Set modification date of copied file. + */ - if (Tcl_FSLstat(source, &sourceStatBuf) == 0) { - tval.actime = sourceStatBuf.st_atime; - tval.modtime = sourceStatBuf.st_mtime; - Tcl_FSUtime(target, &tval); - } - } + if (Tcl_FSLstat(source, &sourceStatBuf) == 0) { + tval.actime = sourceStatBuf.st_atime; + tval.modtime = sourceStatBuf.st_mtime; + Tcl_FSUtime(target, &tval); } + + done: return result; } @@ -4140,8 +4163,8 @@ TclCrossFilesystemCopy(interp, source, target) */ int -Tcl_FSDeleteFile(pathPtr) - Tcl_Obj *pathPtr; /* Pathname of file to be removed (UTF-8). */ +Tcl_FSDeleteFile( + Tcl_Obj *pathPtr) /* Pathname of file to be removed (UTF-8). */ { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); if (fsPtr != NULL) { @@ -4172,8 +4195,8 @@ Tcl_FSDeleteFile(pathPtr) */ int -Tcl_FSCreateDirectory(pathPtr) - Tcl_Obj *pathPtr; /* Pathname of directory to create (UTF-8). */ +Tcl_FSCreateDirectory( + Tcl_Obj *pathPtr) /* Pathname of directory to create (UTF-8). */ { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); if (fsPtr != NULL) { @@ -4192,8 +4215,8 @@ Tcl_FSCreateDirectory(pathPtr) * Tcl_FSCopyDirectory -- * * If the two paths given belong to the same filesystem, we call that - * filesystems copy-directory function. Otherwise we simply return the - * posix error 'EXDEV', and -1. + * filesystems copy-directory function. Otherwise we simply return the + * POSIX error 'EXDEV', and -1. * * Results: * Standard Tcl error code if a function was called. @@ -4205,11 +4228,11 @@ Tcl_FSCreateDirectory(pathPtr) */ int -Tcl_FSCopyDirectory(srcPathPtr, destPathPtr, errorPtr) - Tcl_Obj* srcPathPtr; /* Pathname of directory to be copied +Tcl_FSCopyDirectory( + Tcl_Obj* srcPathPtr, /* Pathname of directory to be copied * (UTF-8). */ - Tcl_Obj *destPathPtr; /* Pathname of target directory (UTF-8). */ - Tcl_Obj **errorPtr; /* If non-NULL, then will be set to a new + Tcl_Obj *destPathPtr, /* Pathname of target directory (UTF-8). */ + Tcl_Obj **errorPtr) /* If non-NULL, then will be set to a new * object containing name of file causing * error, with refCount 1. */ { @@ -4248,13 +4271,13 @@ Tcl_FSCopyDirectory(srcPathPtr, destPathPtr, errorPtr) */ int -Tcl_FSRemoveDirectory(pathPtr, recursive, errorPtr) - Tcl_Obj *pathPtr; /* Pathname of directory to be removed +Tcl_FSRemoveDirectory( + Tcl_Obj *pathPtr, /* Pathname of directory to be removed * (UTF-8). */ - int recursive; /* If non-zero, removes directories that are - * nonempty. Otherwise, will only remove - * empty directories. */ - Tcl_Obj **errorPtr; /* If non-NULL, then will be set to a new + int recursive, /* If non-zero, removes directories that are + * nonempty. Otherwise, will only remove empty + * directories. */ + Tcl_Obj **errorPtr) /* If non-NULL, then will be set to a new * object containing name of file causing * error, with refCount 1. */ { @@ -4306,7 +4329,7 @@ Tcl_FSRemoveDirectory(pathPtr, recursive, errorPtr) * Tcl_FSGetFileSystemForPath -- * * This function determines which filesystem to use for a particular path - * object, and returns the filesystem which accepts this file. If no + * object, and returns the filesystem which accepts this file. If no * filesystem will accept this object as a valid file path, then NULL is * returned. * @@ -4319,9 +4342,9 @@ Tcl_FSRemoveDirectory(pathPtr, recursive, errorPtr) *--------------------------------------------------------------------------- */ -Tcl_Filesystem* -Tcl_FSGetFileSystemForPath(pathPtr) - Tcl_Obj* pathPtr; +Tcl_Filesystem * +Tcl_FSGetFileSystemForPath( + Tcl_Obj* pathPtr) { FilesystemRecord *fsRecPtr; Tcl_Filesystem* retVal = NULL; @@ -4332,7 +4355,7 @@ Tcl_FSGetFileSystemForPath(pathPtr) } /* - * If the object has a refCount of zero, we reject it. This is to avoid + * If the object has a refCount of zero, we reject it. This is to avoid * possible segfaults or nondeterministic memory leaks (i.e. the user * doesn't know if they should decrement the ref count on return or not). */ @@ -4344,7 +4367,7 @@ Tcl_FSGetFileSystemForPath(pathPtr) /* * Check if the filesystem has changed in some way since this object's - * internal representation was calculated. Before doing that, assure we + * internal representation was calculated. Before doing that, assure we * have the most up-to-date copy of the master filesystem. This is * accomplished by the FsGetFirstFilesystem() call. */ @@ -4356,7 +4379,7 @@ Tcl_FSGetFileSystemForPath(pathPtr) } /* - * Call each of the "pathInFilesystem" functions in succession. A + * Call each of the "pathInFilesystem" functions in succession. A * non-return value of -1 indicates the particular function has succeeded. */ @@ -4366,8 +4389,7 @@ Tcl_FSGetFileSystemForPath(pathPtr) if (proc != NULL) { ClientData clientData = NULL; - int ret = (*proc)(pathPtr, &clientData); - if (ret != -1) { + if ((*proc)(pathPtr, &clientData) != -1) { /* * We assume the type of pathPtr hasn't been changed by the * above call to the pathInFilesystemProc. @@ -4390,17 +4412,17 @@ Tcl_FSGetFileSystemForPath(pathPtr) * * This function is for use by the Win/Unix native filesystems, so that * they can easily retrieve the native (char* or TCHAR*) representation - * of a path. Other filesystems will probably want to implement similar - * functions. They basically act as a safety net around - * Tcl_FSGetInternalRep. Normally your file- system procedures will - * always be called with path objects already converted to the correct + * of a path. Other filesystems will probably want to implement similar + * functions. They basically act as a safety net around + * Tcl_FSGetInternalRep. Normally your file-system functions will always + * be called with path objects already converted to the correct * filesystem, but if for some reason they are called directly (i.e. by - * procedures not in this file), then one cannot necessarily guarantee + * functions not in this file), then one cannot necessarily guarantee * that the path object pointer is from the correct filesystem. * * Note: in the future it might be desireable to have separate versions * of this function with different signatures, for example - * Tcl_FSGetNativeWinPath, Tcl_FSGetNativeUnixPath etc. Right now, since + * Tcl_FSGetNativeWinPath, Tcl_FSGetNativeUnixPath etc. Right now, since * native paths are all string based, we use just one function. * * Results: @@ -4413,8 +4435,8 @@ Tcl_FSGetFileSystemForPath(pathPtr) */ CONST char * -Tcl_FSGetNativePath(pathPtr) - Tcl_Obj *pathPtr; +Tcl_FSGetNativePath( + Tcl_Obj *pathPtr) { return (CONST char *) Tcl_FSGetInternalRep(pathPtr, &tclNativeFilesystem); } @@ -4436,8 +4458,8 @@ Tcl_FSGetNativePath(pathPtr) */ static void -NativeFreeInternalRep(clientData) - ClientData clientData; +NativeFreeInternalRep( + ClientData clientData) { ckfree((char *) clientData); } @@ -4447,9 +4469,9 @@ NativeFreeInternalRep(clientData) * * Tcl_FSFileSystemInfo -- * - * This function returns a list of two elements. The first element is - * the name of the filesystem (e.g. "native" or "vfs"), and the second is - * the particular type of the given path within that filesystem. + * This function returns a list of two elements. The first element is the + * name of the filesystem (e.g. "native" or "vfs"), and the second is the + * particular type of the given path within that filesystem. * * Results: * A list of two elements. @@ -4460,9 +4482,9 @@ NativeFreeInternalRep(clientData) *--------------------------------------------------------------------------- */ -Tcl_Obj* -Tcl_FSFileSystemInfo(pathPtr) - Tcl_Obj* pathPtr; +Tcl_Obj * +Tcl_FSFileSystemInfo( + Tcl_Obj *pathPtr) { Tcl_Obj *resPtr; Tcl_FSFilesystemPathTypeProc *proc; @@ -4472,10 +4494,8 @@ Tcl_FSFileSystemInfo(pathPtr) return NULL; } - resPtr = Tcl_NewListObj(0,NULL); - - Tcl_ListObjAppendElement(NULL, resPtr, - Tcl_NewStringObj(fsPtr->typeName,-1)); + resPtr = Tcl_NewListObj(0, NULL); + Tcl_ListObjAppendElement(NULL,resPtr,Tcl_NewStringObj(fsPtr->typeName,-1)); proc = fsPtr->filesystemPathTypeProc; if (proc != NULL) { @@ -4493,7 +4513,7 @@ Tcl_FSFileSystemInfo(pathPtr) * * Tcl_FSPathSeparator -- * - * This function returns the separator to be used for a given path. The + * This function returns the separator to be used for a given path. The * object returned should have a refCount of zero * * Results: @@ -4507,9 +4527,9 @@ Tcl_FSFileSystemInfo(pathPtr) *--------------------------------------------------------------------------- */ -Tcl_Obj* -Tcl_FSPathSeparator(pathPtr) - Tcl_Obj* pathPtr; +Tcl_Obj * +Tcl_FSPathSeparator( + Tcl_Obj *pathPtr) { Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(pathPtr); @@ -4545,9 +4565,9 @@ Tcl_FSPathSeparator(pathPtr) *--------------------------------------------------------------------------- */ -static Tcl_Obj* -NativeFilesystemSeparator(pathPtr) - Tcl_Obj* pathPtr; +static Tcl_Obj * +NativeFilesystemSeparator( + Tcl_Obj *pathPtr) { char *separator = NULL; /* lint */ switch (tclPlatform) { @@ -4569,10 +4589,10 @@ NativeFilesystemSeparator(pathPtr) * * TclStatInsertProc -- * - * Insert the passed procedure pointer at the head of the list of + * Insert the passed function pointer at the head of the list of * functions which are used during a call to 'TclStat(...)'. The passed * function should behave exactly like 'TclStat' when called during that - * time (see 'TclStat(...)' for more information). The function will be + * time (see 'TclStat(...)' for more information). The function will be * added even if it already in the list. * * Results: @@ -4586,8 +4606,8 @@ NativeFilesystemSeparator(pathPtr) */ int -TclStatInsertProc (proc) - TclStatProc_ *proc; +TclStatInsertProc( + TclStatProc_ *proc) { int retVal = TCL_ERROR; @@ -4616,10 +4636,10 @@ TclStatInsertProc (proc) * TclStatDeleteProc -- * * Removed the passed function pointer from the list of 'TclStat' - * functions. Ensures that the built-in stat function is not removvable. + * functions. Ensures that the built-in stat function is not removable. * * Results: - * TCL_OK if the procedure pointer was successfully removed, TCL_ERROR + * TCL_OK if the function pointer was successfully removed, TCL_ERROR * otherwise. * * Side effects: @@ -4629,8 +4649,8 @@ TclStatInsertProc (proc) */ int -TclStatDeleteProc (proc) - TclStatProc_ *proc; +TclStatDeleteProc( + TclStatProc_ *proc) { int retVal = TCL_ERROR; StatProc *tmpStatProcPtr; @@ -4641,7 +4661,7 @@ TclStatDeleteProc (proc) /* * Traverse the 'statProcList' looking for the particular node whose - * 'proc' member matches 'proc' and remove that one from the list. Ensure + * 'proc' member matches 'proc' and remove that one from the list. Ensure * that the "default" node cannot be removed. */ @@ -4672,11 +4692,11 @@ TclStatDeleteProc (proc) * * TclAccessInsertProc -- * - * Insert the passed procedure pointer at the head of the list of - * functions which are used during a call to 'TclAccess(...)'. The - * passed function should behave exactly like 'TclAccess' when called - * during that time (see 'TclAccess(...)' for more information). The - * function will be added even if it already in the list. + * Insert the passed function pointer at the head of the list of + * functions which are used during a call to 'TclAccess(...)'. The passed + * function should behave exactly like 'TclAccess' when called during + * that time (see 'TclAccess(...)' for more information). The function + * will be added even if it already in the list. * * Results: * Normally TCL_OK; TCL_ERROR if memory for a new node in the list could @@ -4689,8 +4709,8 @@ TclStatDeleteProc (proc) */ int -TclAccessInsertProc(proc) - TclAccessProc_ *proc; +TclAccessInsertProc( + TclAccessProc_ *proc) { int retVal = TCL_ERROR; @@ -4719,11 +4739,10 @@ TclAccessInsertProc(proc) * TclAccessDeleteProc -- * * Removed the passed function pointer from the list of 'TclAccess' - * functions. Ensures that the built-in access function is not - * removvable. + * functions. Ensures that the built-in access function is not removable. * * Results: - * TCL_OK if the procedure pointer was successfully removed, TCL_ERROR + * TCL_OK if the function pointer was successfully removed, TCL_ERROR * otherwise. * * Side effects: @@ -4733,8 +4752,8 @@ TclAccessInsertProc(proc) */ int -TclAccessDeleteProc(proc) - TclAccessProc_ *proc; +TclAccessDeleteProc( + TclAccessProc_ *proc) { int retVal = TCL_ERROR; AccessProc *tmpAccessProcPtr; @@ -4742,7 +4761,7 @@ TclAccessDeleteProc(proc) /* * Traverse the 'accessProcList' looking for the particular node whose - * 'proc' member matches 'proc' and remove that one from the list. Ensure + * 'proc' member matches 'proc' and remove that one from the list. Ensure * that the "default" node cannot be removed. */ @@ -4774,12 +4793,12 @@ TclAccessDeleteProc(proc) * * TclOpenFileChannelInsertProc -- * - * Insert the passed procedure pointer at the head of the list of - * functions which are used during a call to - * 'Tcl_OpenFileChannel(...)'. The passed function should behave exactly - * like 'Tcl_OpenFileChannel' when called during that time (see - * 'Tcl_OpenFileChannel(...)' for more information). The function will be - * added even if it already in the list. + * Insert the passed function pointer at the head of the list of + * functions which are used during a call to 'Tcl_OpenFileChannel(...)'. + * The passed function should behave exactly like 'Tcl_OpenFileChannel' + * when called during that time (see 'Tcl_OpenFileChannel(...)' for more + * information). The function will be added even if it already in the + * list. * * Results: * Normally TCL_OK; TCL_ERROR if memory for a new node in the list could @@ -4793,8 +4812,8 @@ TclAccessDeleteProc(proc) */ int -TclOpenFileChannelInsertProc(proc) - TclOpenFileChannelProc_ *proc; +TclOpenFileChannelInsertProc( + TclOpenFileChannelProc_ *proc) { int retVal = TCL_ERROR; @@ -4822,11 +4841,11 @@ TclOpenFileChannelInsertProc(proc) * TclOpenFileChannelDeleteProc -- * * Removed the passed function pointer from the list of - * 'Tcl_OpenFileChannel' functions. Ensures that the built-in open file + * 'Tcl_OpenFileChannel' functions. Ensures that the built-in open file * channel function is not removable. * * Results: - * TCL_OK if the procedure pointer was successfully removed, TCL_ERROR + * TCL_OK if the function pointer was successfully removed, TCL_ERROR * otherwise. * * Side effects: @@ -4836,8 +4855,8 @@ TclOpenFileChannelInsertProc(proc) */ int -TclOpenFileChannelDeleteProc(proc) - TclOpenFileChannelProc_ *proc; +TclOpenFileChannelDeleteProc( + TclOpenFileChannelProc_ *proc) { int retVal = TCL_ERROR; OpenFileChannelProc *tmpOpenFileChannelProcPtr = openFileChannelProcList; |