Formatting and pure ANSI function decls

1 files changed, 161 insertions, 152 deletions

diff --git a/generic/tclPathObj.c b/generic/tclPathObj.c
index 422aeae..9878f73 100644
--- a/generic/tclPathObj.c
+++ b/generic/tclPathObj.c
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclPathObj.c,v 1.46 2005/10/12 22:05:46 dkf Exp $
+ * RCS: @(#) $Id: tclPathObj.c,v 1.47 2005/10/12 22:21:25 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -20,15 +20,13 @@
  * Prototypes for functions defined later in this file.
  */
 
-static void	DupFsPathInternalRep _ANSI_ARGS_((Tcl_Obj *srcPtr,
-		    Tcl_Obj *copyPtr));
-static void	FreeFsPathInternalRep _ANSI_ARGS_((Tcl_Obj *pathPtr));
-static void	UpdateStringOfFsPath  _ANSI_ARGS_((Tcl_Obj *pathPtr));
-static int	SetFsPathFromAny _ANSI_ARGS_((Tcl_Interp *interp,
-		    Tcl_Obj *pathPtr));
-static int	FindSplitPos _ANSI_ARGS_((CONST char *path, int separator));
-static int	IsSeparatorOrNull _ANSI_ARGS_((int ch));
-static Tcl_Obj* GetExtension _ANSI_ARGS_((Tcl_Obj *pathPtr));
+static void	DupFsPathInternalRep(Tcl_Obj *srcPtr, Tcl_Obj *copyPtr);
+static void	FreeFsPathInternalRep(Tcl_Obj *pathPtr);
+static void	UpdateStringOfFsPath(Tcl_Obj *pathPtr);
+static int	SetFsPathFromAny(Tcl_Interp *interp, Tcl_Obj *pathPtr);
+static int	FindSplitPos(CONST char *path, int separator);
+static int	IsSeparatorOrNull(int ch);
+static Tcl_Obj* GetExtension(Tcl_Obj *pathPtr);
 
 /*
  * Define the 'path' object type, which Tcl uses to represent file paths
@@ -46,7 +44,7 @@ Tcl_ObjType tclFsPathType = {
 /*
  * struct FsPath --
  *
- * Internal representation of a Tcl_Obj of "path" type.  This can be used to
+ * Internal representation of a Tcl_Obj of "path" type. This can be used to
  * represent relative or absolute paths, and has certain optimisations when
  * used to represent paths which are already normalized and absolute.
  *
@@ -58,8 +56,8 @@ Tcl_ObjType tclFsPathType = {
  * (i) flags == 0, => Ordinary path.
  *
  * translatedPathPtr contains the translated path (which may be a circular
- * reference to the object itself).  If it is NULL then the path is pure
- * normalized (and the normPathPtr will be a circular reference).  cwdPtr is
+ * reference to the object itself). If it is NULL then the path is pure
+ * normalized (and the normPathPtr will be a circular reference). cwdPtr is
  * null for an absolute path, and non-null for a relative path (unless the cwd
  * has never been set, in which case the cwdPtr may also be null for a
  * relative path).
@@ -72,7 +70,7 @@ Tcl_ObjType tclFsPathType = {
  */
 
 typedef struct FsPath {
-    Tcl_Obj *translatedPathPtr; /* Name without any ~user sequences.  If this
+    Tcl_Obj *translatedPathPtr; /* Name without any ~user sequences. If this
 				 * is NULL, then this is a pure normalized,
 				 * absolute path object, in which the parent
 				 * Tcl_Obj's string rep is already both
@@ -84,11 +82,11 @@ typedef struct FsPath {
 				 * container. If that is NOT the case, we have
 				 * a refCount on the object. */
     Tcl_Obj *cwdPtr;		/* If null, path is absolute, else this points
-				 * to the cwd object used for this path.  We
+				 * to the cwd object used for this path. We
 				 * have a refCount on the object. */
     int flags;			/* Flags to describe interpretation - see
 				 * below. */
-    ClientData nativePathPtr;   /* Native representation of this path, which
+    ClientData nativePathPtr;	/* Native representation of this path, which
 				 * is filesystem dependent. */
     int filesystemEpoch;	/* Used to ensure the path representation was
 				 * generated during the correct filesystem
@@ -113,7 +111,6 @@ typedef struct FsPath {
 #define PATHOBJ(pathPtr) (pathPtr->internalRep.otherValuePtr)
 #define PATHFLAGS(pathPtr) \
 	(((FsPath*)(pathPtr->internalRep.otherValuePtr))->flags)
-
 
 /*
  *---------------------------------------------------------------------------
@@ -123,8 +120,8 @@ typedef struct FsPath {
  *	Takes an absolute path specification and computes a 'normalized' path
  *	from it.
  *
- *	A normalized path is one which has all '../', './' removed.  Also it
- *	is one which is in the 'standard' format for the native platform.  On
+ *	A normalized path is one which has all '../', './' removed. Also it is
+ *	one which is in the 'standard' format for the native 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).
@@ -150,12 +147,12 @@ typedef struct FsPath {
  *---------------------------------------------------------------------------
  */
 
-Tcl_Obj*
-TclFSNormalizeAbsolutePath(interp, pathPtr, clientDataPtr)
-    Tcl_Interp* interp;		/* Interpreter to use */
-    Tcl_Obj *pathPtr;		/* Absolute path to normalize */
-    ClientData *clientDataPtr;	/* If non-NULL, then may be set to the
-				 * fs-specific clientData for this path.  This
+Tcl_Obj *
+TclFSNormalizeAbsolutePath(
+    Tcl_Interp *interp,		/* Interpreter to use */
+    Tcl_Obj *pathPtr,		/* Absolute path to normalize */
+    ClientData *clientDataPtr)	/* If non-NULL, then may be set to the
+				 * fs-specific clientData for this path. This
 				 * will happen when that extra information can
 				 * be calculated efficiently as a side-effect
 				 * of normalization. */
@@ -189,7 +186,7 @@ TclFSNormalizeAbsolutePath(interp, pathPtr, clientDataPtr)
 
     /*
      * Scan forward from one directory separator to the next, checking for
-     * '..' and '.' sequences which must be handled specially.  In particular
+     * '..' and '.' sequences which must be handled specially. In particular
      * handling of '..' can be complicated if the directory before is a link,
      * since we will have to expand the link to be able to back up one level.
      */
@@ -345,9 +342,9 @@ TclFSNormalizeAbsolutePath(interp, pathPtr, clientDataPtr)
 	    /*
 	     * Unfortunately, the platform-specific normalization code which
 	     * will be called below has no way of dealing with the case where
-	     * an object is shared.  It is expecting to modify an object in
-	     * place.  So, we must duplicate this here to ensure an object
-	     * with a single ref-count.
+	     * an object is shared. It is expecting to modify an object in
+	     * place. So, we must duplicate this here to ensure an object with
+	     * a single ref-count.
 	     *
 	     * If that changes in the future (e.g. the normalize proc is given
 	     * one object and is able to return a different one), then we
@@ -380,7 +377,7 @@ TclFSNormalizeAbsolutePath(interp, pathPtr, clientDataPtr)
 
     /*
      * Now we have an absolute path, with no '..', '.' sequences, but it still
-     * may not be in 'unique' form, depending on the platform.  For instance,
+     * may not be in 'unique' form, depending on the platform. For instance,
      * Unix is case-sensitive, so the path is ok. Windows is case-insensitive,
      * and also has the weird 'longname/shortname' thing (e.g. C:/Program
      * Files/ and C:/Progra~1/ are equivalent).
@@ -427,8 +424,8 @@ TclFSNormalizeAbsolutePath(interp, pathPtr, clientDataPtr)
  */
 
 Tcl_PathType
-Tcl_FSGetPathType(pathPtr)
-    Tcl_Obj *pathPtr;
+Tcl_FSGetPathType(
+    Tcl_Obj *pathPtr)
 {
     return TclFSGetPathType(pathPtr, NULL, NULL);
 }
@@ -457,10 +454,10 @@ Tcl_FSGetPathType(pathPtr)
  */
 
 Tcl_PathType
-TclFSGetPathType(pathPtr, filesystemPtrPtr, driveNameLengthPtr)
-    Tcl_Obj *pathPtr;
-    Tcl_Filesystem **filesystemPtrPtr;
-    int *driveNameLengthPtr;
+TclFSGetPathType(
+    Tcl_Obj *pathPtr,
+    Tcl_Filesystem **filesystemPtrPtr,
+    int *driveNameLengthPtr)
 {
     if (Tcl_FSConvertToPathType(NULL, pathPtr) != TCL_OK) {
 	return TclGetPathType(pathPtr, filesystemPtrPtr,
@@ -494,7 +491,7 @@ TclFSGetPathType(pathPtr, filesystemPtrPtr, driveNameLengthPtr)
  *	- the extension       ('file extension')
  *	- the root            ('file root')
  *
- *	The 'portion' parameter dictates which of these to calculate.  There
+ *	The 'portion' parameter dictates which of these to calculate. There
  *	are a number of special cases both to be more efficient, and because
  *	the behaviour when given a path with only a single element is defined
  *	to require the expansion of that single element, where possible.
@@ -512,11 +509,11 @@ TclFSGetPathType(pathPtr, filesystemPtrPtr, driveNameLengthPtr)
  *---------------------------------------------------------------------------
  */
 
-Tcl_Obj*
-TclPathPart(interp, pathPtr, portion)
-    Tcl_Interp *interp;		/* Used for error reporting */
-    Tcl_Obj *pathPtr;		/* Path to take dirname of */
-    Tcl_PathPart portion;	/* Requested portion of name */
+Tcl_Obj *
+TclPathPart(
+    Tcl_Interp *interp,		/* Used for error reporting */
+    Tcl_Obj *pathPtr,		/* Path to take dirname of */
+    Tcl_PathPart portion)	/* Requested portion of name */
 {
     if (pathPtr->typePtr == &tclFsPathType) {
 	FsPath *fsPathPtr = (FsPath*) PATHOBJ(pathPtr);
@@ -715,9 +712,9 @@ TclPathPart(interp, pathPtr, portion)
  * Simple helper function
  */
 
-static Tcl_Obj*
-GetExtension(pathPtr)
-    Tcl_Obj *pathPtr;
+static Tcl_Obj *
+GetExtension(
+    Tcl_Obj *pathPtr)
 {
     CONST char *tail, *extension;
     Tcl_Obj *ret;
@@ -767,11 +764,11 @@ GetExtension(pathPtr)
  *---------------------------------------------------------------------------
  */
 
-Tcl_Obj*
-Tcl_FSJoinPath(listObj, elements)
-    Tcl_Obj *listObj;		/* Path elements to join, may have a zero
+Tcl_Obj *
+Tcl_FSJoinPath(
+    Tcl_Obj *listObj,		/* Path elements to join, may have a zero
 				 * reference count. */
-    int elements;		/* Number of elements to use (-1 = all) */
+    int elements)		/* Number of elements to use (-1 = all) */
 {
     Tcl_Obj *res;
     int i;
@@ -851,7 +848,7 @@ Tcl_FSJoinPath(listObj, elements)
 		}
 
 		/*
-		 * If it doesn't begin with '.'  and is a unix path or it a
+		 * If it doesn't begin with '.' and is a unix path or it a
 		 * windows path without backslashes, then we can be very
 		 * efficient here. (In fact even a windows path with
 		 * backslashes can be joined efficiently, but the path object
@@ -937,14 +934,14 @@ Tcl_FSJoinPath(listObj, elements)
 	 * Optimisation block: if this is the last element to be examined, and
 	 * it is absolute or the only element, and the drive-prefix was ok (if
 	 * there is one), it might be that the path is already in a suitable
-	 * form to be returned.  Then we can short-cut the rest of this
+	 * form to be returned. Then we can short-cut the rest of this
 	 * function.
 	 */
 
 	if ((driveName == NULL) && (i == (elements - 1))
 		&& (type != TCL_PATH_RELATIVE || res == NULL)) {
 	    /*
-	     * It's the last path segment.  Perform a quick check if the path
+	     * It's the last path segment. Perform a quick check if the path
 	     * is already in a suitable form.
 	     */
 
@@ -960,6 +957,7 @@ Tcl_FSJoinPath(listObj, elements)
 		     * We have a repeated file separator, which means the path
 		     * is not in normalized form
 		     */
+
 		    goto noQuickReturn;
 		}
 		ptr++;
@@ -1077,19 +1075,19 @@ Tcl_FSJoinPath(listObj, elements)
  */
 
 int
-Tcl_FSConvertToPathType(interp, pathPtr)
-    Tcl_Interp *interp;		/* Interpreter in which to store error message
+Tcl_FSConvertToPathType(
+    Tcl_Interp *interp,		/* Interpreter in which to store error message
 				 * (if necessary). */
-    Tcl_Obj *pathPtr;		/* Object to convert to a valid, current path
+    Tcl_Obj *pathPtr)		/* Object to convert to a valid, current path
 				 * type. */
 {
     /*
      * While it is bad practice to examine an object's type directly, this is
-     * actually the best thing to do here.  The reason is that if we are
+     * actually the best thing to do here. The reason is that if we are
      * converting this object to FsPath type for the first time, we don't need
-     * to worry whether the 'cwd' has changed.  On the other hand, if this
+     * to worry whether the 'cwd' has changed. On the other hand, if this
      * object is already of FsPath type, and is a relative path, we do have to
-     * worry about the cwd.  If the cwd has changed, we must recompute the
+     * worry about the cwd. If the cwd has changed, we must recompute the
      * path.
      */
 
@@ -1104,6 +1102,7 @@ Tcl_FSConvertToPathType(interp, pathPtr)
 	    return Tcl_ConvertToType(interp, pathPtr, &tclFsPathType);
 	}
 	return TCL_OK;
+
 	/*
 	 * We used to have more complex code here:
 	 *
@@ -1134,8 +1133,8 @@ Tcl_FSConvertToPathType(interp, pathPtr)
  */
 
 static int
-IsSeparatorOrNull(ch)
-    int ch;
+IsSeparatorOrNull(
+    int ch)
 {
     if (ch == 0) {
 	return 1;
@@ -1150,15 +1149,15 @@ IsSeparatorOrNull(ch)
 }
 
 /*
- * Helper function for SetFsPathFromAny.  Returns position of first directory
- * delimiter in the path.  If no separator is found, then returns the position
+ * Helper function for SetFsPathFromAny. Returns position of first directory
+ * delimiter in the path. If no separator is found, then returns the position
  * of the end of the string.
  */
 
 static int
-FindSplitPos(path, separator)
-    CONST char *path;
-    int separator;
+FindSplitPos(
+    CONST char *path,
+    int separator)
 {
     int count = 0;
     switch (tclPlatform) {
@@ -1194,19 +1193,22 @@ FindSplitPos(path, separator)
  *	'file dirname', 'file tail', etc.
  *
  * Assumptions:
- *	'dirPtr' must be an absolute path.  'len' may not be zero.
+ *	'dirPtr' must be an absolute path. 'len' may not be zero.
  *
  * Results:
  *	The new Tcl object, with refCount zero.
  *
  * Side effects:
- *	Memory is allocated.  'dirPtr' gets an additional refCount.
+ *	Memory is allocated. 'dirPtr' gets an additional refCount.
  *
  *---------------------------------------------------------------------------
  */
 
-Tcl_Obj*
-TclNewFSPathObj(Tcl_Obj *dirPtr, CONST char *addStrRep, int len)
+Tcl_Obj *
+TclNewFSPathObj(
+    Tcl_Obj *dirPtr,
+    CONST char *addStrRep,
+    int len)
 {
     FsPath *fsPathPtr;
     Tcl_Obj *pathPtr;
@@ -1248,14 +1250,13 @@ TclNewFSPathObj(Tcl_Obj *dirPtr, CONST char *addStrRep, int len)
  *
  *	Takes a path and a directory, where we _assume_ both path and
  *	directory are absolute, normalized and that the path lies inside the
- *	directory.  Returns a Tcl_Obj representing filename of the path
+ *	directory. Returns a Tcl_Obj representing filename of the path
  *	relative to the directory.
  *
  *	In the case where the resulting path would start with a '~', we take
- *	special care to return an ordinary string.  This means to use that
- *	path (and not have it interpreted as a user name), one must prepend
- *	'./'.  This may seem strange, but that is how 'glob' is currently
- *	defined.
+ *	special care to return an ordinary string. This means to use that path
+ *	(and not have it interpreted as a user name), one must prepend './'.
+ *	This may seem strange, but that is how 'glob' is currently defined.
  *
  * Results:
  *	NULL on error, otherwise a valid object, typically with refCount of
@@ -1267,11 +1268,11 @@ TclNewFSPathObj(Tcl_Obj *dirPtr, CONST char *addStrRep, int len)
  *---------------------------------------------------------------------------
  */
 
-Tcl_Obj*
-TclFSMakePathRelative(interp, pathPtr, cwdPtr)
-    Tcl_Interp *interp;		/* Used for error reporting if not NULL. */
-    Tcl_Obj *pathPtr;		/* The path we have. */
-    Tcl_Obj *cwdPtr;		/* Make it relative to this. */
+Tcl_Obj *
+TclFSMakePathRelative(
+    Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
+    Tcl_Obj *pathPtr,		/* The path we have. */
+    Tcl_Obj *cwdPtr)		/* Make it relative to this. */
 {
     int cwdLen, len;
     CONST char *tempStr;
@@ -1312,6 +1313,7 @@ TclFSMakePathRelative(interp, pathPtr, cwdPtr)
 		 * return the path as is, to agree with the defined behaviour
 		 * of 'glob'.
 		 */
+
 		return pathPtr;
 	    }
 
@@ -1391,10 +1393,10 @@ TclFSMakePathRelative(interp, pathPtr, cwdPtr)
  */
 
 int
-TclFSMakePathFromNormalized(interp, pathPtr, nativeRep)
-    Tcl_Interp *interp;		/* Used for error reporting if not NULL. */
-    Tcl_Obj *pathPtr;		/* The object to convert. */
-    ClientData nativeRep;	/* The native rep for the object, if known
+TclFSMakePathFromNormalized(
+    Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
+    Tcl_Obj *pathPtr,		/* The object to convert. */
+    ClientData nativeRep)	/* The native rep for the object, if known
 				 * else NULL. */
 {
     FsPath *fsPathPtr;
@@ -1474,9 +1476,9 @@ TclFSMakePathFromNormalized(interp, pathPtr, nativeRep)
  */
 
 Tcl_Obj *
-Tcl_FSNewNativePath(fromFilesystem, clientData)
-    Tcl_Filesystem* fromFilesystem;
-    ClientData clientData;
+Tcl_FSNewNativePath(
+    Tcl_Filesystem *fromFilesystem,
+    ClientData clientData)
 {
     Tcl_Obj *pathPtr;
     FsPath *fsPathPtr;
@@ -1546,10 +1548,10 @@ Tcl_FSNewNativePath(fromFilesystem, clientData)
  *---------------------------------------------------------------------------
  */
 
-Tcl_Obj*
-Tcl_FSGetTranslatedPath(interp, pathPtr)
-    Tcl_Interp *interp;
-    Tcl_Obj* pathPtr;
+Tcl_Obj *
+Tcl_FSGetTranslatedPath(
+    Tcl_Interp *interp,
+    Tcl_Obj *pathPtr)
 {
     Tcl_Obj *retObj = NULL;
     FsPath *srcFsPathPtr;
@@ -1563,8 +1565,8 @@ Tcl_FSGetTranslatedPath(interp, pathPtr)
 	    retObj = Tcl_FSGetNormalizedPath(interp, pathPtr);
 	} else {
 	    /*
-	     * It is a pure absolute, normalized path object.  This is
-	     * something like being a 'pure list'.  The object's string,
+	     * It is a pure absolute, normalized path object. This is
+	     * something like being a 'pure list'. The object's string,
 	     * translatedPath and normalizedPath are all identical.
 	     */
 
@@ -1601,10 +1603,10 @@ Tcl_FSGetTranslatedPath(interp, pathPtr)
  *---------------------------------------------------------------------------
  */
 
-CONST char*
-Tcl_FSGetTranslatedStringPath(interp, pathPtr)
-    Tcl_Interp *interp;
-    Tcl_Obj* pathPtr;
+CONST char *
+Tcl_FSGetTranslatedStringPath(
+    Tcl_Interp *interp,
+    Tcl_Obj *pathPtr)
 {
     Tcl_Obj *transPtr = Tcl_FSGetTranslatedPath(interp, pathPtr);
 
@@ -1635,16 +1637,16 @@ Tcl_FSGetTranslatedStringPath(interp, pathPtr)
  *	NULL or a valid path object pointer.
  *
  * Side effects:
- *	New memory may be allocated.  The Tcl 'errno' may be modified in the
+ *	New memory may be allocated. The Tcl 'errno' may be modified in the
  *	process of trying to examine various path possibilities.
  *
  *---------------------------------------------------------------------------
  */
 
-Tcl_Obj*
-Tcl_FSGetNormalizedPath(interp, pathPtr)
-    Tcl_Interp *interp;
-    Tcl_Obj* pathPtr;
+Tcl_Obj *
+Tcl_FSGetNormalizedPath(
+    Tcl_Interp *interp,
+    Tcl_Obj *pathPtr)
 {
     FsPath *fsPathPtr;
 
@@ -1684,9 +1686,9 @@ Tcl_FSGetNormalizedPath(interp, pathPtr)
 	cwdStr = Tcl_GetStringFromObj(copy, &cwdLen);
 
 	/*
-	 * Should we perhaps use 'Tcl_FSPathSeparator'?  But then what about
-	 * the Windows special case?  Perhaps we should just check if cwd is a
-	 * root volume.  We should never get cwdLen == 0 in this code path.
+	 * Should we perhaps use 'Tcl_FSPathSeparator'? But then what about
+	 * the Windows special case? Perhaps we should just check if cwd is a
+	 * root volume. We should never get cwdLen == 0 in this code path.
 	 */
 
 	switch (tclPlatform) {
@@ -1707,9 +1709,9 @@ Tcl_FSGetNormalizedPath(interp, pathPtr)
 
 	/*
 	 * Normalize the combined string, but only starting after the end of
-	 * the previously normalized 'dir'.  This should be much faster!  We
-	 * use 'cwdLen-1' so that we are already pointing at the dir-separator
-	 * that we know about.  The normalization code will actually start off
+	 * the previously normalized 'dir'. This should be much faster! We use
+	 * 'cwdLen-1' so that we are already pointing at the dir-separator
+	 * that we know about. The normalization code will actually start off
 	 * directly after that separator.
 	 */
 
@@ -1781,10 +1783,10 @@ Tcl_FSGetNormalizedPath(interp, pathPtr)
 	    cwdStr = Tcl_GetStringFromObj(copy, &cwdLen);
 
 	    /*
-	     * Should we perhaps use 'Tcl_FSPathSeparator'?  But then what
-	     * about the Windows special case?  Perhaps we should just check
-	     * if cwd is a root volume.  We should never get cwdLen == 0 in
-	     * this code path.
+	     * Should we perhaps use 'Tcl_FSPathSeparator'? But then what
+	     * about the Windows special case? Perhaps we should just check if
+	     * cwd is a root volume. We should never get cwdLen == 0 in this
+	     * code path.
 	     */
 
 	    switch (tclPlatform) {
@@ -1864,6 +1866,7 @@ Tcl_FSGetNormalizedPath(interp, pathPtr)
 		/*
 		 * Only Windows has volume-relative paths.
 		 */
+
 		absolutePath = TclWinVolumeRelativeNormalize(interp,
 			path, &useThisCwd);
 		if (absolutePath == NULL) {
@@ -1927,7 +1930,7 @@ Tcl_FSGetNormalizedPath(interp, pathPtr)
  * Tcl_FSGetInternalRep --
  *
  *	Extract the internal representation of a given path object, in the
- *	given filesystem.  If the path object belongs to a different
+ *	given filesystem. If the path object belongs to a different
  *	filesystem, we return NULL.
  *
  *	If the internal representation is currently NULL, we attempt to
@@ -1944,9 +1947,9 @@ Tcl_FSGetNormalizedPath(interp, pathPtr)
  */
 
 ClientData
-Tcl_FSGetInternalRep(pathPtr, fsPtr)
-    Tcl_Obj* pathPtr;
-    Tcl_Filesystem *fsPtr;
+Tcl_FSGetInternalRep(
+    Tcl_Obj *pathPtr,
+    Tcl_Filesystem *fsPtr)
 {
     FsPath* srcFsPathPtr;
 
@@ -1957,12 +1960,12 @@ Tcl_FSGetInternalRep(pathPtr, fsPtr)
 
     /*
      * We will only return the native representation for the caller's
-     * filesystem.  Otherwise we will simply return NULL. This means that
-     * there must be a unique bi-directional mapping between paths and
-     * filesystems, and that this mapping will not allow 'remapped' files --
-     * files which are in one filesystem but mapped into another.  Another way
-     * of putting this is that 'stacked' filesystems are not allowed.  We
-     * recognise that this is a potentially useful feature for the future.
+     * filesystem. Otherwise we will simply return NULL. This means that there
+     * must be a unique bi-directional mapping between paths and filesystems,
+     * and that this mapping will not allow 'remapped' files -- files which
+     * are in one filesystem but mapped into another. Another way of putting
+     * this is that 'stacked' filesystems are not allowed. We recognise that
+     * this is a potentially useful feature for the future.
      *
      * Even something simple like a 'pass through' filesystem which logs all
      * activity and passes the calls onto the native system would be nice, but
@@ -1975,7 +1978,7 @@ Tcl_FSGetInternalRep(pathPtr, fsPtr)
 	 * string object and pass it to TclpObjStat. Code which calls the
 	 * Tcl_FS.. functions should always have a filesystem already set.
 	 * Whether this code path is legal or not depends on whether we decide
-	 * to allow external code to call the native filesystem directly.  It
+	 * to allow external code to call the native filesystem directly. It
 	 * is at least safer to allow this sub-optimal routing.
 	 */
 
@@ -1997,8 +2000,8 @@ Tcl_FSGetInternalRep(pathPtr, fsPtr)
     /*
      * There is still one possibility we should consider; if the file belongs
      * to a different filesystem, perhaps it is actually linked through to a
-     * file in our own filesystem which we do care about.  The way we can
-     * check for this is we ask what filesystem this path belongs to.
+     * file in our own filesystem which we do care about. The way we can check
+     * for this is we ask what filesystem this path belongs to.
      */
 
     if (fsPtr != srcFsPathPtr->fsRecPtr->fsPtr) {
@@ -2042,9 +2045,9 @@ Tcl_FSGetInternalRep(pathPtr, fsPtr)
  */
 
 int
-TclFSEnsureEpochOk(pathPtr, fsPtrPtr)
-    Tcl_Obj* pathPtr;
-    Tcl_Filesystem **fsPtrPtr;
+TclFSEnsureEpochOk(
+    Tcl_Obj *pathPtr,
+    Tcl_Filesystem **fsPtrPtr)
 {
     FsPath* srcFsPathPtr;
 
@@ -2102,10 +2105,10 @@ TclFSEnsureEpochOk(pathPtr, fsPtrPtr)
  */
 
 void
-TclFSSetPathDetails(pathPtr, fsRecPtr, clientData)
-    Tcl_Obj *pathPtr;
-    FilesystemRecord *fsRecPtr;
-    ClientData clientData;
+TclFSSetPathDetails(
+    Tcl_Obj *pathPtr,
+    FilesystemRecord *fsRecPtr,
+    ClientData clientData)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&tclFsDataKey);
     FsPath* srcFsPathPtr;
@@ -2145,9 +2148,9 @@ TclFSSetPathDetails(pathPtr, fsRecPtr, clientData)
  */
 
 int
-Tcl_FSEqualPaths(firstPtr, secondPtr)
-    Tcl_Obj* firstPtr;
-    Tcl_Obj* secondPtr;
+Tcl_FSEqualPaths(
+    Tcl_Obj *firstPtr,
+    Tcl_Obj *secondPtr)
 {
     char *firstStr, *secondStr;
     int firstLen, secondLen, tempErrno;
@@ -2159,7 +2162,7 @@ Tcl_FSEqualPaths(firstPtr, secondPtr)
     if (firstPtr == NULL || secondPtr == NULL) {
 	return 0;
     }
-    firstStr  = Tcl_GetStringFromObj(firstPtr, &firstLen);
+    firstStr = Tcl_GetStringFromObj(firstPtr, &firstLen);
     secondStr = Tcl_GetStringFromObj(secondPtr, &secondLen);
     if ((firstLen == secondLen) && (strcmp(firstStr, secondStr) == 0)) {
 	return 1;
@@ -2205,9 +2208,9 @@ Tcl_FSEqualPaths(firstPtr, secondPtr)
  */
 
 static int
-SetFsPathFromAny(interp, pathPtr)
-    Tcl_Interp *interp;		/* Used for error reporting if not NULL. */
-    Tcl_Obj *pathPtr;		/* The object to convert. */
+SetFsPathFromAny(
+    Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
+    Tcl_Obj *pathPtr)		/* The object to convert. */
 {
     int len;
     FsPath *fsPathPtr;
@@ -2247,7 +2250,10 @@ SetFsPathFromAny(interp, pathPtr)
 
 	split = FindSplitPos(name, separator);
 	if (split != len) {
-	    /* We have multiple pieces '~user/foo/bar...' */
+	    /*
+	     * We have multiple pieces '~user/foo/bar...'
+	     */
+
 	    name[split] = '\0';
 	}
 
@@ -2403,8 +2409,8 @@ SetFsPathFromAny(interp, pathPtr)
 }
 
 static void
-FreeFsPathInternalRep(pathPtr)
-    Tcl_Obj *pathPtr;		/* Path object with internal rep to free. */
+FreeFsPathInternalRep(
+    Tcl_Obj *pathPtr)		/* Path object with internal rep to free. */
 {
     FsPath* fsPathPtr = (FsPath*) PATHOBJ(pathPtr);
 
@@ -2445,9 +2451,9 @@ FreeFsPathInternalRep(pathPtr)
 }
 
 static void
-DupFsPathInternalRep(srcPtr, copyPtr)
-    Tcl_Obj *srcPtr;		/* Path obj with internal rep to copy. */
-    Tcl_Obj *copyPtr;		/* Path obj with internal rep to set. */
+DupFsPathInternalRep(
+    Tcl_Obj *srcPtr,		/* Path obj with internal rep to copy. */
+    Tcl_Obj *copyPtr)		/* Path obj with internal rep to set. */
 {
     FsPath* srcFsPathPtr = (FsPath*) PATHOBJ(srcPtr);
     FsPath* copyFsPathPtr = (FsPath*) ckalloc((unsigned)sizeof(FsPath));
@@ -2520,8 +2526,8 @@ DupFsPathInternalRep(srcPtr, copyPtr)
  */
 
 static void
-UpdateStringOfFsPath(pathPtr)
-    register Tcl_Obj *pathPtr;	/* path obj with string rep to update. */
+UpdateStringOfFsPath(
+    register Tcl_Obj *pathPtr)	/* path obj with string rep to update. */
 {
     FsPath* fsPathPtr = (FsPath*) PATHOBJ(pathPtr);
     CONST char *cwdStr;
@@ -2538,9 +2544,9 @@ UpdateStringOfFsPath(pathPtr)
     cwdStr = Tcl_GetStringFromObj(copy, &cwdLen);
 
     /*
-     * Should we perhaps use 'Tcl_FSPathSeparator'?  But then what about the
-     * Windows special case?  Perhaps we should just check if cwd is a root
-     * volume.  We should never get cwdLen == 0 in this code path.
+     * Should we perhaps use 'Tcl_FSPathSeparator'? But then what about the
+     * Windows special case? Perhaps we should just check if cwd is a root
+     * volume. We should never get cwdLen == 0 in this code path.
      */
 
     switch (tclPlatform) {
@@ -2597,9 +2603,9 @@ UpdateStringOfFsPath(pathPtr)
  */
 
 int
-TclNativePathInFilesystem(pathPtr, clientDataPtr)
-    Tcl_Obj *pathPtr;
-    ClientData *clientDataPtr;
+TclNativePathInFilesystem(
+    Tcl_Obj *pathPtr,
+    ClientData *clientDataPtr)
 {
     /*
      * A special case is required to handle the empty path "". This is a valid
@@ -2613,8 +2619,10 @@ TclNativePathInFilesystem(pathPtr, clientDataPtr)
 	    /*
 	     * We reject the empty path "".
 	     */
+
 	    return -1;
 	}
+
 	/*
 	 * Otherwise there is no way this path can be empty.
 	 */
@@ -2632,6 +2640,7 @@ TclNativePathInFilesystem(pathPtr, clientDataPtr)
 	    /*
 	     * We reject the empty path "".
 	     */
+
 	    return -1;
 	}
     }