1 files changed, 247 insertions, 185 deletions

diff --git a/generic/tclPathObj.c b/generic/tclPathObj.c
index e7e16b4..95c57bf 100644
--- a/generic/tclPathObj.c
+++ b/generic/tclPathObj.c
@@ -35,7 +35,7 @@ static int		MakePathFromNormalized(Tcl_Interp *interp,
  * internally.
  */
 
-static const Tcl_ObjType tclFsPathType = {
+static Tcl_ObjType tclFsPathType = {
     "path",				/* name */
     FreeFsPathInternalRep,		/* freeIntRepProc */
     DupFsPathInternalRep,		/* dupIntRepProc */
@@ -94,7 +94,7 @@ typedef struct FsPath {
 				 * generated during the correct filesystem
 				 * epoch. The epoch changes when
 				 * filesystem-mounts are changed. */
-    const Tcl_Filesystem *fsPtr;/* The Tcl_Filesystem that claims this path */
+    Tcl_Filesystem *fsPtr;	/* The Tcl_Filesystem that claims this path */
 } FsPath;
 
 /*
@@ -109,9 +109,9 @@ typedef struct FsPath {
  * fields.
  */
 
-#define PATHOBJ(pathPtr) ((FsPath *) (pathPtr)->internalRep.otherValuePtr)
+#define PATHOBJ(pathPtr) ((FsPath *) (pathPtr)->internalRep.twoPtrValue.ptr1)
 #define SETPATHOBJ(pathPtr,fsPathPtr) \
-	((pathPtr)->internalRep.otherValuePtr = (void *) (fsPathPtr))
+	((pathPtr)->internalRep.twoPtrValue.ptr1 = (void *) (fsPathPtr))
 #define PATHFLAGS(pathPtr) (PATHOBJ(pathPtr)->flags)
 
 /*
@@ -224,11 +224,10 @@ TclFSNormalizeAbsolutePath(
 		/*
 		 * Need to skip '.' in the path.
 		 */
-		size_t curLen;
+		int curLen;
 
 		if (retVal == NULL) {
 		    const char *path = TclGetString(pathPtr);
-
 		    retVal = Tcl_NewStringObj(path, dirSep - path);
 		    Tcl_IncrRefCount(retVal);
 		}
@@ -244,8 +243,8 @@ TclFSNormalizeAbsolutePath(
 		continue;
 	    }
 	    if (dirSep[2] == '.' && IsSeparatorOrNull(dirSep[3])) {
-		Tcl_Obj *linkObj;
-		size_t curLen;
+		Tcl_Obj *link;
+		int curLen;
 		char *linkStr;
 
 		/*
@@ -263,7 +262,7 @@ TclFSNormalizeAbsolutePath(
 		    Tcl_AppendToObj(retVal, dirSep, 1);
 		}
 		if (!first || (tclPlatform == TCL_PLATFORM_UNIX)) {
-		    linkObj = Tcl_FSLink(retVal, NULL, 0);
+		    link = Tcl_FSLink(retVal, NULL, 0);
 
 		    /* Safety check in case driver caused sharing */
 		    if (Tcl_IsShared(retVal)) {
@@ -272,16 +271,15 @@ TclFSNormalizeAbsolutePath(
 			Tcl_IncrRefCount(retVal);
 		    }
 
-		    if (linkObj != NULL) {
+		    if (link != NULL) {
 			/*
 			 * Got a link. Need to check if the link is relative
 			 * or absolute, for those platforms where relative
 			 * links exist.
 			 */
 
-			if (tclPlatform != TCL_PLATFORM_WINDOWS
-				&& Tcl_FSGetPathType(linkObj)
-					== TCL_PATH_RELATIVE) {
+			if (tclPlatform != TCL_PLATFORM_WINDOWS &&
+				Tcl_FSGetPathType(link) == TCL_PATH_RELATIVE) {
 			    /*
 			     * We need to follow this link which is relative
 			     * to retVal's directory. This means concatenating
@@ -302,8 +300,8 @@ TclFSNormalizeAbsolutePath(
 			     */
 
 			    Tcl_SetObjLength(retVal, curLen+1);
-			    Tcl_AppendObjToObj(retVal, linkObj);
-			    TclDecrRefCount(linkObj);
+			    Tcl_AppendObjToObj(retVal, link);
+			    TclDecrRefCount(link);
 			    linkStr = Tcl_GetStringFromObj(retVal, &curLen);
 			} else {
 			    /*
@@ -311,11 +309,11 @@ TclFSNormalizeAbsolutePath(
 			     */
 
 			    TclDecrRefCount(retVal);
-			    if (Tcl_IsShared(linkObj)) {
-				retVal = Tcl_DuplicateObj(linkObj);
-				TclDecrRefCount(linkObj);
+			    if (Tcl_IsShared(link)) {
+				retVal = Tcl_DuplicateObj(link);
+				TclDecrRefCount(link);
 			    } else {
-				retVal = linkObj;
+				retVal = link;
 			    }
 			    linkStr = Tcl_GetStringFromObj(retVal, &curLen);
 
@@ -338,8 +336,8 @@ TclFSNormalizeAbsolutePath(
 		    }
 
 		    /*
-		     * Either way, we now remove the last path element (but
-		     * not the first character of the path).
+		     * Either way, we now remove the last path element.
+		     * (but not the first character of the path)
 		     */
 
 		    while (--curLen >= 0) {
@@ -400,11 +398,11 @@ TclFSNormalizeAbsolutePath(
     }
 
     /*
-     * Ensure a windows drive like C:/ has a trailing separator.
+     * Ensure a windows drive like C:/ has a trailing separator
      */
 
     if (tclPlatform == TCL_PLATFORM_WINDOWS) {
-	size_t len;
+	int len;
 	const char *path = Tcl_GetStringFromObj(retVal, &len);
 
 	if (len == 2 && path[0] != 0 && path[1] == ':') {
@@ -495,8 +493,8 @@ Tcl_FSGetPathType(
 Tcl_PathType
 TclFSGetPathType(
     Tcl_Obj *pathPtr,
-    const Tcl_Filesystem **filesystemPtrPtr,
-    size_t *driveNameLengthPtr)
+    Tcl_Filesystem **filesystemPtrPtr,
+    int *driveNameLengthPtr)
 {
     FsPath *fsPathPtr;
 
@@ -578,7 +576,7 @@ TclPathPart(
 		 * the standardPath code.
 		 */
 
-		size_t numBytes;
+		int numBytes;
 		const char *rest =
 			Tcl_GetStringFromObj(fsPathPtr->normPathPtr, &numBytes);
 
@@ -616,7 +614,7 @@ TclPathPart(
 		 * we don't, and instead just use the standardPath code.
 		 */
 
-		size_t numBytes;
+		int numBytes;
 		const char *rest =
 			Tcl_GetStringFromObj(fsPathPtr->normPathPtr, &numBytes);
 
@@ -645,7 +643,7 @@ TclPathPart(
 		return GetExtension(fsPathPtr->normPathPtr);
 	    case TCL_PATH_ROOT: {
 		const char *fileName, *extension;
-		size_t length;
+		int length;
 
 		fileName = Tcl_GetStringFromObj(fsPathPtr->normPathPtr,
 			&length);
@@ -688,7 +686,7 @@ TclPathPart(
 	    goto standardPath;
 	}
     } else {
-	size_t splitElements;
+	int splitElements;
 	Tcl_Obj *splitPtr, *resultPtr;
 
     standardPath:
@@ -696,7 +694,7 @@ TclPathPart(
 	if (portion == TCL_PATH_EXTENSION) {
 	    return GetExtension(pathPtr);
 	} else if (portion == TCL_PATH_ROOT) {
-	    size_t length;
+	    int length;
 	    const char *fileName, *extension;
 
 	    fileName = Tcl_GetStringFromObj(pathPtr, &length);
@@ -706,7 +704,7 @@ TclPathPart(
 		return pathPtr;
 	    } else {
 		Tcl_Obj *root = Tcl_NewStringObj(fileName,
-			length - strlen(extension));
+			(int) (length - strlen(extension)));
 
 		Tcl_IncrRefCount(root);
 		return root;
@@ -783,7 +781,7 @@ GetExtension(
     if (extension == NULL) {
 	ret = Tcl_NewObj();
     } else {
-	ret = Tcl_NewStringObj(extension, TCL_STRLEN);
+	ret = Tcl_NewStringObj(extension, -1);
     }
     Tcl_IncrRefCount(ret);
     return ret;
@@ -829,39 +827,44 @@ Tcl_FSJoinPath(
 				 * reference count. */
     int elements)		/* Number of elements to use (-1 = all) */
 {
-    Tcl_Obj *copy, *res;
-    size_t objc;
-    Tcl_Obj **objv;
+    Tcl_Obj *res;
+    int i;
+    Tcl_Filesystem *fsPtr = NULL;
 
-    if (Tcl_ListObjLength(NULL, listObj, &objc) != TCL_OK) {
-	return NULL;
-    }
+    if (elements < 0) {
+	if (Tcl_ListObjLength(NULL, listObj, &elements) != TCL_OK) {
+	    return NULL;
+	}
+    } else {
+	/*
+	 * Just make sure it is a valid list.
+	 */
 
-    elements = ((elements >= 0) && (elements <= objc)) ? elements : objc;
-    copy = TclListObjCopy(NULL, listObj);
-    Tcl_ListObjGetElements(NULL, listObj, &objc, &objv);
-    res = TclJoinPath(elements, objv);
-    Tcl_DecrRefCount(copy);
-    return res;
-}
+	int listTest;
 
-Tcl_Obj *
-TclJoinPath(
-    size_t elements,
-    Tcl_Obj * const objv[])
-{
-    Tcl_Obj *res;
-    size_t i;
-    const Tcl_Filesystem *fsPtr = NULL;
+	if (Tcl_ListObjLength(NULL, listObj, &listTest) != TCL_OK) {
+	    return NULL;
+	}
+
+	/*
+	 * Correct this if it is too large, otherwise we will waste our time
+	 * joining null elements to the path.
+	 */
+
+	if (elements > listTest) {
+	    elements = listTest;
+	}
+    }
 
     res = NULL;
 
     for (i = 0; i < elements; i++) {
-	size_t driveNameLength, strEltLen, length;
+	Tcl_Obj *elt, *driveName = NULL;
+	int driveNameLength, strEltLen, length;
 	Tcl_PathType type;
 	char *strElt, *ptr;
-	Tcl_Obj *driveName = NULL;
-	Tcl_Obj *elt = objv[i];
+
+	Tcl_ListObjIndex(NULL, listObj, i, &elt);
 
 	/*
 	 * This is a special case where we can be much more efficient, where
@@ -872,17 +875,17 @@ TclJoinPath(
 	 * could expand that in the future.
 	 */
 
-	if ((i == (elements-2)) && (i == 0)
-		&& (elt->typePtr == &tclFsPathType)
-		&& !((elt->bytes != NULL) && (elt->bytes[0] == '\0'))) {
-	    Tcl_Obj *tailObj = objv[i+1];
+	if ((i == (elements-2)) && (i == 0) && (elt->typePtr == &tclFsPathType)
+		&& !(elt->bytes != NULL && (elt->bytes[0] == '\0'))) {
+	    Tcl_Obj *tail;
 
-	    type = TclGetPathType(tailObj, NULL, NULL, NULL);
+	    Tcl_ListObjIndex(NULL, listObj, i+1, &tail);
+	    type = TclGetPathType(tail, NULL, NULL, NULL);
 	    if (type == TCL_PATH_RELATIVE) {
 		const char *str;
-		size_t len;
+		int len;
 
-		str = Tcl_GetStringFromObj(tailObj, &len);
+		str = Tcl_GetStringFromObj(tail, &len);
 		if (len == 0) {
 		    /*
 		     * This happens if we try to handle the root volume '/'.
@@ -930,16 +933,16 @@ TclJoinPath(
 		if (res != NULL) {
 		    TclDecrRefCount(res);
 		}
-		return tailObj;
+		return tail;
 	    } else {
-		const char *str = TclGetString(tailObj);
+		const char *str = TclGetString(tail);
 
 		if (tclPlatform == TCL_PLATFORM_WINDOWS) {
 		    if (strchr(str, '\\') == NULL) {
 			if (res != NULL) {
 			    TclDecrRefCount(res);
 			}
-			return tailObj;
+			return tail;
 		    }
 		}
 	    }
@@ -1016,8 +1019,8 @@ TclJoinPath(
 	    }
 
 	    /*
-	     * This element is just what we want to return already; no further
-	     * manipulation is requred.
+	     * This element is just what we want to return already - no
+	     * further manipulation is requred.
 	     */
 
 	    return elt;
@@ -1063,7 +1066,7 @@ TclJoinPath(
 	    int needsSep = 0;
 
 	    if (fsPtr->filesystemSeparatorProc != NULL) {
-		Tcl_Obj *sep = fsPtr->filesystemSeparatorProc(res);
+		Tcl_Obj *sep = (*fsPtr->filesystemSeparatorProc)(res);
 
 		if (sep != NULL) {
 		    separator = TclGetString(sep)[0];
@@ -1078,7 +1081,7 @@ TclJoinPath(
 
 	    if (length > 0 && ptr[length -1] != '/') {
 		Tcl_AppendToObj(res, &separator, 1);
-		(void) Tcl_GetStringFromObj(res, &length);
+		Tcl_GetStringFromObj(res, &length);
 	    }
 	    Tcl_SetObjLength(res, length + (int) strlen(strElt));
 
@@ -1261,7 +1264,7 @@ Tcl_Obj *
 TclNewFSPathObj(
     Tcl_Obj *dirPtr,
     const char *addStrRep,
-    size_t len)
+    int len)
 {
     FsPath *fsPathPtr;
     Tcl_Obj *pathPtr;
@@ -1293,7 +1296,7 @@ TclNewFSPathObj(
     }
 
     pathPtr = Tcl_NewObj();
-    fsPathPtr = ckalloc(sizeof(FsPath));
+    fsPathPtr = (FsPath *) ckalloc(sizeof(FsPath));
 
     /*
      * Set up the path.
@@ -1316,41 +1319,41 @@ TclNewFSPathObj(
 
     /*
      * Look for path components made up of only "."
-     * This is overly conservative analysis to keep simple. It may mark some
-     * things as needing more aggressive normalization that don't actually
-     * need it. No harm done.
+     * This is overly conservative analysis to keep simple.  It may
+     * mark some things as needing more aggressive normalization
+     * that don't actually need it.  No harm done.
      */
     for (p = addStrRep; len > 0; p++, len--) {
-	switch (state) {
-	case 0:		/* So far only "." since last dirsep or start */
-	    switch (*p) {
-	    case '.':
-		count++;
-		break;
-	    case '/':
-	    case '\\':
-	    case ':':
-		if (count) {
-		    PATHFLAGS(pathPtr) |= TCLPATH_NEEDNORM;
-		    len = 1;
-		}
-		break;
-	    default:
-		count = 0;
-		state = 1;
-	    }
-	case 1:		/* Scanning for next dirsep */
-	    switch (*p) {
-	    case '/':
-	    case '\\':
-	    case ':':
-		state = 0;
-		break;
-	    }
-	}
+       switch (state) {
+       case 0: /* So far only "." since last dirsep or start */
+           switch (*p) {
+           case '.':
+               count++;
+               break;
+           case '/':
+           case '\\':
+           case ':':
+               if (count) {
+                   PATHFLAGS(pathPtr) |= TCLPATH_NEEDNORM;
+                   len = 0;
+               }
+               break;
+           default:
+               count = 0;
+               state = 1;
+           }
+       case 1: /* Scanning for next dirsep */
+           switch (*p) {
+           case '/':
+           case '\\':
+           case ':':
+               state = 0;
+               break;
+           }
+       }
     }
     if (len == 0 && count) {
-	PATHFLAGS(pathPtr) |= TCLPATH_NEEDNORM;
+       PATHFLAGS(pathPtr) |= TCLPATH_NEEDNORM;
     }
 
     return pathPtr;
@@ -1361,7 +1364,7 @@ AppendPath(
     Tcl_Obj *head,
     Tcl_Obj *tail)
 {
-    size_t numBytes;
+    int numBytes;
     const char *bytes;
     Tcl_Obj *copy = Tcl_DuplicateObj(head);
 
@@ -1371,7 +1374,7 @@ AppendPath(
      * of no evidence that such a foolish thing exists.  This solution was
      * chosen so that "JoinPath" operations that pass through either path
      * intrep produce the same results; that is, bugward compatibility.  If
-     * we need to fix that bug here, it needs fixing in TclJoinPath() too.
+     * we need to fix that bug here, it needs fixing in Tcl_FSJoinPath() too.
      */
     bytes = Tcl_GetStringFromObj(tail, &numBytes);
     if (numBytes == 0) {
@@ -1410,14 +1413,78 @@ TclFSMakePathRelative(
     Tcl_Obj *pathPtr,		/* The path we have. */
     Tcl_Obj *cwdPtr)		/* Make it relative to this. */
 {
-    size_t cwdLen, len;
+    int cwdLen, len;
     const char *tempStr;
 
     if (pathPtr->typePtr == &tclFsPathType) {
 	FsPath *fsPathPtr = PATHOBJ(pathPtr);
 
-	if (PATHFLAGS(pathPtr) != 0 && fsPathPtr->cwdPtr == cwdPtr) {
-	    return fsPathPtr->normPathPtr;
+	if (PATHFLAGS(pathPtr) != 0
+		&& fsPathPtr->cwdPtr == cwdPtr) {
+	    pathPtr = fsPathPtr->normPathPtr;
+
+	    /* TODO: Determine how much, if any, of this forcing
+	     * the relative path tail into the "path" Tcl_ObjType
+	     * with a recorded cwdPtr context has any actual value.
+	     *
+	     * Nothing is getting cached.  Not normPathPtr, not nativePathPtr,
+	     * nor fsPtr, so storing the cwdPtr context against which such
+	     * cached values might later be validated appears to be of no
+	     * value.  Take that away, and all this code is just a mildly
+	     * optimized equivalent of a call to SetFsPathFromAny().  That
+	     * optimization may have some value, *if* these value in fact
+	     * get used as "path" values before used as something else.
+	     * If not, though, whatever cost we pay below to convert to
+	     * one of the "path" intreps is just a waste, it seems.  The
+	     * usual convention in the core is to delay ObjType conversion
+	     * until it is needed and demanded, and I don't see why this
+	     * section of code should be an exception to that.  Leaving it
+	     * in place for the rest of the 8.5.* releases just for sake
+	     * of stability.
+	     */
+
+	    /*
+	     * Free old representation.
+	     */
+
+	    if (pathPtr->typePtr != NULL) {
+		if (pathPtr->bytes == NULL) {
+		    if (pathPtr->typePtr->updateStringProc == NULL) {
+			if (interp != NULL) {
+			    Tcl_ResetResult(interp);
+			    Tcl_AppendResult(interp, "can't find object"
+				    "string representation", NULL);
+			}
+			return NULL;
+		    }
+		    pathPtr->typePtr->updateStringProc(pathPtr);
+		}
+		TclFreeIntRep(pathPtr);
+	    }
+
+	    /*
+	     * Now pathPtr is a string object.
+	     */
+
+	    fsPathPtr = (FsPath *) ckalloc(sizeof(FsPath));
+
+	    /*
+	     * Circular reference, by design.
+	     */
+
+	    fsPathPtr->translatedPathPtr = pathPtr;
+	    fsPathPtr->normPathPtr = NULL;
+	    fsPathPtr->cwdPtr = cwdPtr;
+	    Tcl_IncrRefCount(cwdPtr);
+	    fsPathPtr->nativePathPtr = NULL;
+	    fsPathPtr->fsPtr = NULL;
+	    fsPathPtr->filesystemEpoch = 0;
+
+	    SETPATHOBJ(pathPtr, fsPathPtr);
+	    PATHFLAGS(pathPtr) = 0;
+	    pathPtr->typePtr = &tclFsPathType;
+
+	    return pathPtr;
 	}
     }
 
@@ -1493,11 +1560,9 @@ MakePathFromNormalized(
 	if (pathPtr->bytes == NULL) {
 	    if (pathPtr->typePtr->updateStringProc == NULL) {
 		if (interp != NULL) {
-		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "can't find object string representation",
-			    TCL_STRLEN));
-		    Tcl_SetErrorCode(interp, "TCL", "VALUE", "PATH", "WTF",
-			    NULL);
+		    Tcl_ResetResult(interp);
+		    Tcl_AppendResult(interp, "can't find object"
+			    "string representation", NULL);
 		}
 		return TCL_ERROR;
 	    }
@@ -1506,7 +1571,7 @@ MakePathFromNormalized(
 	TclFreeIntRep(pathPtr);
     }
 
-    fsPathPtr = ckalloc(sizeof(FsPath));
+    fsPathPtr = (FsPath *) ckalloc(sizeof(FsPath));
 
     /*
      * It's a pure normalized absolute path.
@@ -1559,7 +1624,7 @@ MakePathFromNormalized(
 
 Tcl_Obj *
 Tcl_FSNewNativePath(
-    const Tcl_Filesystem *fromFilesystem,
+    Tcl_Filesystem *fromFilesystem,
     ClientData clientData)
 {
     Tcl_Obj *pathPtr = NULL;
@@ -1588,7 +1653,7 @@ Tcl_FSNewNativePath(
 	TclFreeIntRep(pathPtr);
     }
 
-    fsPathPtr = ckalloc(sizeof(FsPath));
+    fsPathPtr = (FsPath *) ckalloc(sizeof(FsPath));
 
     fsPathPtr->translatedPathPtr = NULL;
 
@@ -1656,7 +1721,7 @@ Tcl_FSGetTranslatedPath(
 	    }
 
 	    retObj = Tcl_FSJoinToPath(translatedCwdPtr, 1,
-		    &srcFsPathPtr->normPathPtr);
+		    &(srcFsPathPtr->normPathPtr));
 	    srcFsPathPtr->translatedPathPtr = retObj;
 	    if (translatedCwdPtr->typePtr == &tclFsPathType) {
 		srcFsPathPtr->filesystemEpoch
@@ -1716,11 +1781,11 @@ Tcl_FSGetTranslatedStringPath(
     Tcl_Obj *transPtr = Tcl_FSGetTranslatedPath(interp, pathPtr);
 
     if (transPtr != NULL) {
-	size_t len;
+	int len;
 	const char *orig = Tcl_GetStringFromObj(transPtr, &len);
-	char *result = ckalloc(len+1);
+	char *result = (char *) ckalloc((unsigned) len+1);
 
-	memcpy(result, orig, len+1);
+	memcpy(result, orig, (size_t) len+1);
 	TclDecrRefCount(transPtr);
 	return result;
     }
@@ -1766,8 +1831,7 @@ Tcl_FSGetNormalizedPath(
 	 */
 
 	Tcl_Obj *dir, *copy;
-	size_t tailLen, cwdLen;
-	int pathType;
+	int tailLen, cwdLen, pathType;
 
 	pathType = Tcl_FSGetPathType(fsPathPtr->cwdPtr);
 	dir = Tcl_FSGetNormalizedPath(interp, fsPathPtr->cwdPtr);
@@ -1779,7 +1843,7 @@ Tcl_FSGetNormalizedPath(
 	    UpdateStringOfFsPath(pathPtr);
 	}
 
-	(void) Tcl_GetStringFromObj(fsPathPtr->normPathPtr, &tailLen);
+	Tcl_GetStringFromObj(fsPathPtr->normPathPtr, &tailLen);
 	if (tailLen) {
 	    copy = AppendPath(dir, fsPathPtr->normPathPtr);
 	} else {
@@ -1799,25 +1863,25 @@ Tcl_FSGetNormalizedPath(
 
 	if (PATHFLAGS(pathPtr) & TCLPATH_NEEDNORM) {
 	    /*
-	     * If the "tail" part has components (like /../) that cause the
-	     * combined path to need more complete normalizing, call on the
-	     * more powerful routine to accomplish that so we avoid [Bug
-	     * 2385549] ...
+	     * If the "tail" part has components (like /../) that cause
+	     * the combined path to need more complete normalizing,
+	     * call on the more powerful routine to accomplish that so
+	     * we avoid [Bug 2385549] ...
 	     */
 
 	    Tcl_Obj *newCopy = TclFSNormalizeAbsolutePath(interp, copy);
-
 	    Tcl_DecrRefCount(copy);
 	    copy = newCopy;
 	} else {
 	    /*
-	     * ... but in most cases where we join a trouble free tail to a
-	     * normalized head, we can more efficiently normalize the combined
-	     * path by passing over only the unnormalized tail portion. When
-	     * this is sufficient, prior developers claim 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.
+	     * ... but in most cases where we join a trouble free tail
+	     * to a normalized head, we can more efficiently normalize the
+	     * combined path by passing over only the unnormalized tail
+	     * portion.  When this is sufficient, prior developers claim
+	     * 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.
 	     */
 
 	    TclFSNormalizeToUniquePath(interp, copy, cwdLen-1);
@@ -1830,11 +1894,11 @@ Tcl_FSGetNormalizedPath(
 
 	    /*
 	     * NOTE: here we are (dangerously?) assuming that origDir points
-	     * to a Tcl_Obj with Tcl_ObjType == &tclFsPathType. The
+	     * to a Tcl_Obj with Tcl_ObjType == &tclFsPathType .  The
 	     *     pathType = Tcl_FSGetPathType(fsPathPtr->cwdPtr);
-	     * above that set the pathType value should have established that,
-	     * but it's far less clear on what basis we know there's been no
-	     * shimmering since then.
+	     * above that set the pathType value should have established
+	     * that, but it's far less clear on what basis we know there's
+	     * been no shimmering since then.
 	     */
 
 	    FsPath *origDirFsPathPtr = PATHOBJ(origDir);
@@ -1881,7 +1945,7 @@ Tcl_FSGetNormalizedPath(
 	    }
 	    fsPathPtr = PATHOBJ(pathPtr);
 	} else if (fsPathPtr->normPathPtr == NULL) {
-	    size_t cwdLen;
+	    int cwdLen;
 	    Tcl_Obj *copy;
 
 	    copy = AppendPath(fsPathPtr->cwdPtr, pathPtr);
@@ -1922,11 +1986,11 @@ Tcl_FSGetNormalizedPath(
 
 	if (path[0] == '\0') {
 	    /*
-	     * Special handling for the empty string value. This one is very
-	     * weird with [file normalize {}] => {}. (The reasoning supporting
-	     * this is unknown to DGP, but he fears changing it.) Attempt here
-	     * to keep the expectations of other parts of Tcl_Filesystem code
-	     * about state of the FsPath fields satisfied.
+	     * Special handling for the empty string value.  This one is
+	     * very weird with [file normalize {}] => {}.  (The reasoning
+	     * supporting this is unknown to DGP, but he fears changing it.)
+	     * Attempt here to keep the expectations of other parts of
+	     * Tcl_Filesystem code about state of the FsPath fields satisfied.
 	     *
 	     * In particular, capture the cwd value and save so it can be
 	     * stored in the cwdPtr field below.
@@ -1989,12 +2053,8 @@ Tcl_FSGetNormalizedPath(
 	 */
 
 	if (pureNormalized) {
-	    size_t normPathLen, pathLen;
-	    const char *normPath;
-
-	    path = TclGetStringFromObj(pathPtr, &pathLen);
-	    normPath = TclGetStringFromObj(fsPathPtr->normPathPtr, &normPathLen);
-	    if ((pathLen == normPathLen) && !memcmp(path, normPath, pathLen)) {
+	    if (!strcmp(TclGetString(fsPathPtr->normPathPtr),
+		    TclGetString(pathPtr))) {
 		/*
 		 * The path was already normalized. Get rid of the duplicate.
 		 */
@@ -2049,7 +2109,7 @@ Tcl_FSGetNormalizedPath(
 ClientData
 Tcl_FSGetInternalRep(
     Tcl_Obj *pathPtr,
-    const Tcl_Filesystem *fsPtr)
+    Tcl_Filesystem *fsPtr)
 {
     FsPath *srcFsPathPtr;
 
@@ -2122,7 +2182,7 @@ Tcl_FSGetInternalRep(
 	    return NULL;
 	}
 
-	nativePathPtr = proc(pathPtr);
+	nativePathPtr = (*proc)(pathPtr);
 	srcFsPathPtr = PATHOBJ(pathPtr);
 	srcFsPathPtr->nativePathPtr = nativePathPtr;
     }
@@ -2151,7 +2211,7 @@ Tcl_FSGetInternalRep(
 int
 TclFSEnsureEpochOk(
     Tcl_Obj *pathPtr,
-    const Tcl_Filesystem **fsPtrPtr)
+    Tcl_Filesystem **fsPtrPtr)
 {
     FsPath *srcFsPathPtr;
 
@@ -2210,7 +2270,7 @@ TclFSEnsureEpochOk(
 void
 TclFSSetPathDetails(
     Tcl_Obj *pathPtr,
-    const Tcl_Filesystem *fsPtr,
+    Tcl_Filesystem *fsPtr,
     ClientData clientData)
 {
     FsPath *srcFsPathPtr;
@@ -2253,9 +2313,8 @@ Tcl_FSEqualPaths(
     Tcl_Obj *firstPtr,
     Tcl_Obj *secondPtr)
 {
-    const char *firstStr, *secondStr;
-    size_t firstLen, secondLen;
-    int tempErrno;
+    char *firstStr, *secondStr;
+    int firstLen, secondLen, tempErrno;
 
     if (firstPtr == secondPtr) {
 	return 1;
@@ -2264,9 +2323,9 @@ Tcl_FSEqualPaths(
     if (firstPtr == NULL || secondPtr == NULL) {
 	return 0;
     }
-    firstStr = TclGetStringFromObj(firstPtr, &firstLen);
-    secondStr = TclGetStringFromObj(secondPtr, &secondLen);
-    if ((firstLen == secondLen) && !memcmp(firstStr, secondStr, firstLen)) {
+    firstStr = Tcl_GetStringFromObj(firstPtr, &firstLen);
+    secondStr = Tcl_GetStringFromObj(secondPtr, &secondLen);
+    if ((firstLen == secondLen) && (strcmp(firstStr, secondStr) == 0)) {
 	return 1;
     }
 
@@ -2284,9 +2343,9 @@ Tcl_FSEqualPaths(
 	return 0;
     }
 
-    firstStr = TclGetStringFromObj(firstPtr, &firstLen);
-    secondStr = TclGetStringFromObj(secondPtr, &secondLen);
-    return ((firstLen == secondLen) && !memcmp(firstStr, secondStr, firstLen));
+    firstStr = Tcl_GetStringFromObj(firstPtr, &firstLen);
+    secondStr = Tcl_GetStringFromObj(secondPtr, &secondLen);
+    return (firstLen == secondLen) && (strcmp(firstStr, secondStr) == 0);
 }
 
 /*
@@ -2314,7 +2373,7 @@ SetFsPathFromAny(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
     Tcl_Obj *pathPtr)		/* The object to convert. */
 {
-    size_t len;
+    int len;
     FsPath *fsPathPtr;
     Tcl_Obj *transPtr;
     char *name;
@@ -2344,6 +2403,7 @@ SetFsPathFromAny(
      */
 
     if (name[0] == '~') {
+	char *expandedUser;
 	Tcl_DString temp;
 	int split;
 	char separator = '/';
@@ -2376,11 +2436,9 @@ SetFsPathFromAny(
 	    dir = TclGetEnv("HOME", &dirString);
 	    if (dir == NULL) {
 		if (interp) {
-		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "couldn't find HOME environment variable to"
-			    " expand path", TCL_STRLEN));
-		    Tcl_SetErrorCode(interp, "TCL", "VALUE", "PATH",
-			    "HOMELESS", NULL);
+		    Tcl_ResetResult(interp);
+		    Tcl_AppendResult(interp, "couldn't find HOME environment "
+			    "variable to expand path", NULL);
 		}
 		return TCL_ERROR;
 	    }
@@ -2395,10 +2453,9 @@ SetFsPathFromAny(
 	    Tcl_DStringInit(&temp);
 	    if (TclpGetUserHome(name+1, &temp) == NULL) {
 		if (interp != NULL) {
-		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-			    "user \"%s\" doesn't exist", name+1));
-		    Tcl_SetErrorCode(interp, "TCL", "VALUE", "PATH", "NOUSER",
-			    NULL);
+		    Tcl_ResetResult(interp);
+		    Tcl_AppendResult(interp, "user \"", name+1,
+			    "\" doesn't exist", NULL);
 		}
 		Tcl_DStringFree(&temp);
 		if (split != len) {
@@ -2411,7 +2468,8 @@ SetFsPathFromAny(
 	    }
 	}
 
-	transPtr = TclDStringToObj(&temp);
+	expandedUser = Tcl_DStringValue(&temp);
+	transPtr = Tcl_NewStringObj(expandedUser, Tcl_DStringLength(&temp));
 
 	if (split != len) {
 	    /*
@@ -2425,7 +2483,7 @@ SetFsPathFromAny(
 		 * beginning with ~ are part of the native filesystem.
 		 */
 
-		size_t objc;
+		int objc;
 		Tcl_Obj **objv;
 		Tcl_Obj *parts = TclpNativeSplitPath(pathPtr, NULL);
 
@@ -2448,7 +2506,7 @@ SetFsPathFromAny(
 		 */
 
 		Tcl_Obj *joined;
-		Tcl_Obj *rest = Tcl_NewStringObj(name+split+1, TCL_STRLEN);
+		Tcl_Obj *rest = Tcl_NewStringObj(name+split+1, -1);
 
 		Tcl_IncrRefCount(transPtr);
 		joined = Tcl_FSJoinToPath(transPtr, 1, &rest);
@@ -2456,8 +2514,12 @@ SetFsPathFromAny(
 		transPtr = joined;
 	    }
 	}
+	Tcl_DStringFree(&temp);
     } else {
-	transPtr = TclJoinPath(1, &pathPtr);
+	/* Bug 3479689: protect 0-refcount pathPth from getting freed */
+	pathPtr->refCount++;
+	transPtr = Tcl_FSJoinToPath(pathPtr, 0, NULL);
+	pathPtr->refCount--;
     }
 
     /*
@@ -2465,7 +2527,7 @@ SetFsPathFromAny(
      * slashes on Windows, and will not contain any ~user sequences.
      */
 
-    fsPathPtr = ckalloc(sizeof(FsPath));
+    fsPathPtr = (FsPath *) ckalloc(sizeof(FsPath));
 
     fsPathPtr->translatedPathPtr = transPtr;
     if (transPtr != pathPtr) {
@@ -2516,12 +2578,12 @@ FreeFsPathInternalRep(
 		fsPathPtr->fsPtr->freeInternalRepProc;
 
 	if (freeProc != NULL) {
-	    freeProc(fsPathPtr->nativePathPtr);
+	    (*freeProc)(fsPathPtr->nativePathPtr);
 	    fsPathPtr->nativePathPtr = NULL;
 	}
     }
 
-    ckfree(fsPathPtr);
+    ckfree((char *) fsPathPtr);
     pathPtr->typePtr = NULL;
 }
 
@@ -2531,7 +2593,7 @@ DupFsPathInternalRep(
     Tcl_Obj *copyPtr)		/* Path obj with internal rep to set. */
 {
     FsPath *srcFsPathPtr = PATHOBJ(srcPtr);
-    FsPath *copyFsPathPtr = ckalloc(sizeof(FsPath));
+    FsPath *copyFsPathPtr = (FsPath *) ckalloc(sizeof(FsPath));
 
     SETPATHOBJ(copyPtr, copyFsPathPtr);
 
@@ -2569,7 +2631,7 @@ DupFsPathInternalRep(
 
 	if (dupProc != NULL) {
 	    copyFsPathPtr->nativePathPtr =
-		    dupProc(srcFsPathPtr->nativePathPtr);
+		    (*dupProc)(srcFsPathPtr->nativePathPtr);
 	} else {
 	    copyFsPathPtr->nativePathPtr = NULL;
 	}
@@ -2603,7 +2665,7 @@ UpdateStringOfFsPath(
     register Tcl_Obj *pathPtr)	/* path obj with string rep to update. */
 {
     FsPath *fsPathPtr = PATHOBJ(pathPtr);
-    size_t cwdLen;
+    int cwdLen;
     Tcl_Obj *copy;
 
     if (PATHFLAGS(pathPtr) == 0 || fsPathPtr->cwdPtr == NULL) {
@@ -2671,7 +2733,7 @@ TclNativePathInFilesystem(
 	 * situation.
 	 */
 
-	size_t len;
+	int len;
 
 	(void) Tcl_GetStringFromObj(pathPtr, &len);
 	if (len == 0) {