merge trunk

15 files changed, 220 insertions, 73 deletions

diff --git a/ChangeLog.2000 b/ChangeLog.2000
index 0d20eaf..5b62351 100644
--- a/ChangeLog.2000
+++ b/ChangeLog.2000
@@ -414,7 +414,7 @@
 	Tcl_IsChannelExisting, and Tcl_ClearChannelHandlers to conform to the
 	new stacked channel implementation. Their stub slots were also moved
 	to give preference to the new 8.3.2 stub functions. This will cause an
-	incompatability with 8.4a1 only.
+	incompatibility with 8.4a1 only.
 	(StopCopy): fixed a bug introduced by a partial fix in 8.3.2 that
 	didn't set nonBlocking correctly when resetting the flags for the
 	write side. [Bug: 6261]
diff --git a/ChangeLog.2002 b/ChangeLog.2002
index 30b8b17..9931657 100644
--- a/ChangeLog.2002
+++ b/ChangeLog.2002
@@ -847,7 +847,7 @@
 	exit.
 
 	* tests/exec.test: marked exec-18.1 unixOnly until the Windows
-	incompatability (in the test, not the core) can be resolved.
+	incompatibility (in the test, not the core) can be resolved.
 
 	* tests/http.test (http-3.11): added close $fp that was causing an
 	error on Windows because the file was not closed before deleting.
@@ -3642,7 +3642,7 @@
 	* compat/strtoll.c (strtoll):
 	* compat/strtoull.c (strtoull):
 	* unix/tclUnixPort.h:
-	* win/tclWinPort.h: Const-ing 64-bit compatability declarations. Note
+	* win/tclWinPort.h: Const-ing 64-bit compatibility declarations. Note
 	that the return pointer is non-const because it is entirely legal for
 	the functions to be called from somewhere that owns the string being
 	passed. Fixes problem reported by Larry Virden.
@@ -3779,7 +3779,7 @@
 
 	There are a lot of changes from this TIP, so please see
 	http://purl.org/tcl/tip/72.html for discussion of
-	backward-compatability issues, but the main ones modifications are in:
+	backward-compatibility issues, but the main ones modifications are in:
 
 	* generic/tcl.h: New types.
 	* generic/tcl.decls: New public functions.
diff --git a/ChangeLog.2003 b/ChangeLog.2003
index c586ba9..3c3ee11 100644
--- a/ChangeLog.2003
+++ b/ChangeLog.2003
@@ -947,7 +947,7 @@
 	declarations match and will end up using the declarations in the
 	public code from now on because of #include ordering. Keeping the old
 	declarations in tclInt.decls; there's no need to gratuitously break
-	compatability for those extensions which are already clients of the
+	compatibility for those extensions which are already clients of the
 	namespace code.
 
 2003-08-23  Zoran Vasiljevic  <zoran@archiwrae.com>
@@ -1278,7 +1278,7 @@
 
 	* generic/tclVar.c (Tcl_ArrayObjCmd, TclArraySet): Made [array get]
 	and [array set] work with dictionaries, producing them and consuming
-	them. Note that for compatability reasons, you will never get a dict
+	them. Note that for compatibility reasons, you will never get a dict
 	from feeding a string literal to [array set] since that alters the
 	trace behaviour of "multi-key" sets. [Bug 759935]
 
diff --git a/ChangeLog.2004 b/ChangeLog.2004
index 82acd5c..daf124f 100644
--- a/ChangeLog.2004
+++ b/ChangeLog.2004
@@ -1356,7 +1356,7 @@
 2004-10-07  Donal K. Fellows  <donal.k.fellows@man.ac.uk>
 
 	* *.3: Convert CONST to const and VOID to void so we document how
-	people should actually use the Tcl API and not the compatability hacks
+	people should actually use the Tcl API and not the compatibility hacks
 	that it has to have.
 
 	* doc/man.macros, *.3: Update .AS macro so it can know how wide to
diff --git a/generic/tcl.h b/generic/tcl.h
index 00bd9dd..e8326b8 100644
--- a/generic/tcl.h
+++ b/generic/tcl.h
@@ -1323,9 +1323,9 @@ typedef struct Tcl_HashSearch {
  * TCL_CUSTOM_PTR_KEYS:		The keys are pointers to arbitrary types, the
  *				pointer is stored in the entry.
  *
- * While maintaining binary compatability the above have to be distinct values
+ * While maintaining binary compatibility the above have to be distinct values
  * as they are used to differentiate between old versions of the hash table
- * which don't have a typePtr and new ones which do. Once binary compatability
+ * which don't have a typePtr and new ones which do. Once binary compatibility
  * is discarded in favour of making more wide spread changes TCL_STRING_KEYS
  * can be the same as TCL_CUSTOM_TYPE_KEYS, and TCL_ONE_WORD_KEYS can be the
  * same as TCL_CUSTOM_PTR_KEYS because they simply determine how the key is
diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index f60c9cc..9d5147b 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -3024,13 +3024,6 @@ Tcl_DeleteCommandFromToken(
     Tcl_Command importCmd;
 
     /*
-     * Bump the command epoch counter. This will invalidate all cached
-     * references that point to this command.
-     */
-
-    cmdPtr->cmdEpoch++;
-
-    /*
      * The code here is tricky. We can't delete the hash table entry before
      * invoking the deletion callback because there are cases where the
      * deletion callback needs to invoke the command (e.g. object systems such
@@ -3052,6 +3045,14 @@ Tcl_DeleteCommandFromToken(
 	    Tcl_DeleteHashEntry(cmdPtr->hPtr);
 	    cmdPtr->hPtr = NULL;
 	}
+
+	/*
+	 * Bump the command epoch counter. This will invalidate all cached
+	 * references that point to this command.
+	 */
+
+	cmdPtr->cmdEpoch++;
+
 	return 0;
     }
 
@@ -3154,6 +3155,13 @@ Tcl_DeleteCommandFromToken(
     if (cmdPtr->hPtr != NULL) {
 	Tcl_DeleteHashEntry(cmdPtr->hPtr);
 	cmdPtr->hPtr = NULL;
+
+	/*
+	 * Bump the command epoch counter. This will invalidate all cached
+	 * references that point to this command.
+	 */
+
+	cmdPtr->cmdEpoch++;
     }
 
     /*
diff --git a/generic/tclBinary.c b/generic/tclBinary.c
index ea863cc..1576752 100644
--- a/generic/tclBinary.c
+++ b/generic/tclBinary.c
@@ -57,9 +57,12 @@
 
 static void		DupByteArrayInternalRep(Tcl_Obj *srcPtr,
 			    Tcl_Obj *copyPtr);
+static void		DupProperByteArrayInternalRep(Tcl_Obj *srcPtr,
+			    Tcl_Obj *copyPtr);
 static int		FormatNumber(Tcl_Interp *interp, int type,
 			    Tcl_Obj *src, unsigned char **cursorPtr);
 static void		FreeByteArrayInternalRep(Tcl_Obj *objPtr);
+static void		FreeProperByteArrayInternalRep(Tcl_Obj *objPtr);
 static int		GetFormatSpec(const char **formatPtr, char *cmdPtr,
 			    int *countPtr, int *flagsPtr);
 static Tcl_Obj *	ScanNumber(unsigned char *buffer, int type,
@@ -156,35 +159,108 @@ static const EnsembleImplMap decodeMap[] = {
 };
 
 /*
- * The following object type represents an array of bytes. An array of bytes
- * is not equivalent to an internationalized string. Conceptually, a string is
- * an array of 16-bit quantities organized as a sequence of properly formed
- * UTF-8 characters, while a ByteArray is an array of 8-bit quantities.
- * Accessor functions are provided to convert a ByteArray to a String or a
- * String to a ByteArray. Two or more consecutive bytes in an array of bytes
- * may look like a single UTF-8 character if the array is casually treated as
- * a string. But obtaining the String from a ByteArray is guaranteed to
- * produced properly formed UTF-8 sequences so that there is a one-to-one map
- * between bytes and characters.
- *
- * Converting a ByteArray to a String proceeds by casting each byte in the
- * array to a 16-bit quantity, treating that number as a Unicode character,
- * and storing the UTF-8 version of that Unicode character in the String. For
- * ByteArrays consisting entirely of values 1..127, the corresponding String
- * representation is the same as the ByteArray representation.
- *
- * Converting a String to a ByteArray proceeds by getting the Unicode
- * representation of each character in the String, casting it to a byte by
- * truncating the upper 8 bits, and then storing the byte in the ByteArray.
- * Converting from ByteArray to String and back to ByteArray is not lossy, but
- * converting an arbitrary String to a ByteArray may be.
+ * The following object types represent an array of bytes. The intent is
+ * to allow arbitrary binary data to pass through Tcl as a Tcl value
+ * without loss or damage. Such values are useful for things like
+ * encoded strings or Tk images to name just two.
+ *
+ * It's strange to have two Tcl_ObjTypes in place for this task when
+ * one would do, so a bit of detail and history how we got to this point
+ * and where we might go from here.
+ *
+ * A bytearray is an ordered sequence of bytes. Each byte is an integer
+ * value in the range [0-255].  To be a Tcl value type, we need a way to
+ * encode each value in the value set as a Tcl string.  The simplest
+ * encoding is to represent each byte value as the same codepoint value.
+ * A bytearray of N bytes is encoded into a Tcl string of N characters
+ * where the codepoint of each character is the value of corresponding byte.
+ * This approach creates a one-to-one map between all bytearray values
+ * and a subset of Tcl string values.
+ * 
+ * When converting a Tcl string value to the bytearray internal rep, the
+ * question arises what to do with strings outside that subset?  That is,
+ * those Tcl strings containing at least one codepoint greater than 255?
+ * The obviously correct answer is to raise an error!  That string value
+ * does not represent any valid bytearray value. Full Stop.  The
+ * setFromAnyProc signature has a completion code return value for just
+ * this reason, to reject invalid inputs.
+ * 
+ * Unfortunately this was not the path taken by the authors of the
+ * original tclByteArrayType.  They chose to accept all Tcl string values
+ * as acceptable string encodings of the bytearray values that result
+ * from masking away the high bits of any codepoint value at all. This
+ * meant that every bytearray value had multiple accepted string
+ * representations.
+ *
+ * The implications of this choice are truly ugly.  When a Tcl value has
+ * a string representation, we are required to accept that as the true
+ * value.  Bytearray values that possess a string representation cannot
+ * be processed as bytearrays because we cannot know which true value
+ * that bytearray represents.  The consequence is that we drag around
+ * an internal rep that we cannot make any use of.  This painful price
+ * is extracted at any point after a string rep happens to be generated
+ * for the value.  This happens even when the troublesome codepoints
+ * outside the byte range never show up.  This happens rather routinely
+ * in normal Tcl operations unless we burden the script writer with the
+ * cognitive burden of avoiding it.  The price is also paid by callers
+ * of the C interface.  The routine
+ *
+ *	unsigned char *Tcl_GetByteArrayFromObj(objPtr, lenPtr)
+ *
+ * has a guarantee to always return a non-NULL value, but that value
+ * points to a byte sequence that cannot be used by the caller to  
+ * process the Tcl value absent some sideband testing that objPtr
+ * is "pure".  Tcl offers no public interface to perform this test,
+ * so callers either break encapsulation or are unavoidably buggy.  Tcl
+ * has defined a public interface that cannot be used correctly. The
+ * Tcl source code itself suffers the same problem, and has been buggy,
+ * but progressively less so as more and more portions of the code have
+ * been retrofitted with the required "purity testing".  The set of values
+ * able to pass the purity test can be increased via the introduction of
+ * a "canonical" flag marker, but the only way the broken interface itself
+ * can be discarded is to start over and define the Tcl_ObjType properly.
+ * Bytearrays should simply be usable as bytearrays without a kabuki
+ * dance of testing.
+ *
+ * The Tcl_ObjType "properByteArrayType" is (nearly) a correct 
+ * implementation of bytearrays.  Any Tcl value with the type
+ * properByteArrayType can have its bytearray value fetched and
+ * used with confidence that acting on that value is equivalent to
+ * acting on the true Tcl string value.  This still implies a side
+ * testing burden -- past mistakes will not let us avoid that
+ * immediately, but it is at least a conventional test of type, and
+ * can be implemented entirely by examining the objPtr fields, with
+ * no need to query the intrep, as a canonical flag would require.
+ *
+ * Until Tcl_GetByteArrayFromObj() and Tcl_SetByteArrayLength() can
+ * be revised to admit the possibility of returning NULL when the true
+ * value is not a valid bytearray, we need a mechanism to retain
+ * compatibility with the deployed callers of the broken interface.
+ * That's what the retained "tclByteArrayType" provides.  In those
+ * unusual circumstances where we convert an invalid bytearray value
+ * to a bytearray type, it is to this legacy type.  Essentially any
+ * time this legacy type gets used, it's a signal of a bug being ignored.
+ * A TIP should be drafted to remove this connection to the broken past
+ * so that Tcl 9 will no longer have any trace of it.  Prescribing a
+ * migration path will be the key element of that work.  The internal
+ * changes now in place are the limit of what can be done short of
+ * interface repair.  They provide a great expansion of the histories
+ * over which bytearray values can be useful in the meanwhile.
  */
 
+static const Tcl_ObjType properByteArrayType = {
+    "bytearray",
+    FreeProperByteArrayInternalRep,
+    DupProperByteArrayInternalRep,
+    UpdateStringOfByteArray,
+    NULL
+};
+
 const Tcl_ObjType tclByteArrayType = {
     "bytearray",
     FreeByteArrayInternalRep,
     DupByteArrayInternalRep,
-    UpdateStringOfByteArray,
+    NULL,
     SetByteArrayFromAny
 };
 
@@ -211,6 +287,12 @@ typedef struct ByteArray {
 #define SET_BYTEARRAY(irPtr, baPtr) \
 		(irPtr)->twoPtrValue.ptr1 = (void *) (baPtr)
 
+int
+TclIsPureByteArray(
+    Tcl_Obj * objPtr)
+{
+    return (NULL != Tcl_FetchIntRep(objPtr, &properByteArrayType));
+}
 
 /*
  *----------------------------------------------------------------------
@@ -343,7 +425,7 @@ Tcl_SetByteArrayObj(
     }
     SET_BYTEARRAY(&ir, byteArrayPtr);
 
-    Tcl_StoreIntRep(objPtr, &tclByteArrayType, &ir);
+    Tcl_StoreIntRep(objPtr, &properByteArrayType, &ir);
 }
 
 /*
@@ -371,11 +453,17 @@ Tcl_GetByteArrayFromObj(
 				 * array of bytes in the ByteArray object. */
 {
     ByteArray *baPtr;
-    const Tcl_ObjIntRep *irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+    const Tcl_ObjIntRep *irPtr = Tcl_FetchIntRep(objPtr, &properByteArrayType);
 
     if (irPtr == NULL) {
-	SetByteArrayFromAny(NULL, objPtr);
 	irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+	if (irPtr == NULL) {
+	    SetByteArrayFromAny(NULL, objPtr);
+	    irPtr = Tcl_FetchIntRep(objPtr, &properByteArrayType);
+	    if (irPtr == NULL) {
+		irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+	    }
+	}
     }
     baPtr = GET_BYTEARRAY(irPtr);
 
@@ -422,10 +510,17 @@ Tcl_SetByteArrayLength(
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetByteArrayLength");
     }
-    irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+
+    irPtr = Tcl_FetchIntRep(objPtr, &properByteArrayType);
     if (irPtr == NULL) {
-	SetByteArrayFromAny(NULL, objPtr);
 	irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+	if (irPtr == NULL) {
+	    SetByteArrayFromAny(NULL, objPtr);
+	    irPtr = Tcl_FetchIntRep(objPtr, &properByteArrayType);
+	    if (irPtr == NULL) {
+		irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+	    }
+	}
     }
 
     byteArrayPtr = GET_BYTEARRAY(irPtr);
@@ -460,13 +555,18 @@ SetByteArrayFromAny(
     Tcl_Interp *interp,		/* Not used. */
     Tcl_Obj *objPtr)		/* The object to convert to type ByteArray. */
 {
-    int length;
+    int length, improper = 0;
     const char *src, *srcEnd;
     unsigned char *dst;
     ByteArray *byteArrayPtr;
     Tcl_ObjIntRep ir;
 
-    assert (NULL == Tcl_FetchIntRep(objPtr, &tclByteArrayType));
+    if (Tcl_FetchIntRep(objPtr, &properByteArrayType)) {
+	return TCL_OK;
+    }
+    if (Tcl_FetchIntRep(objPtr, &tclByteArrayType)) {
+	return TCL_OK;
+    }
 
     src = TclGetStringFromObj(objPtr, &length);
     srcEnd = src + length;
@@ -474,8 +574,8 @@ SetByteArrayFromAny(
     byteArrayPtr = ckalloc(BYTEARRAY_SIZE(length));
     for (dst = byteArrayPtr->bytes; src < srcEnd; ) {
 	Tcl_UniChar ch;
-
 	src += Tcl_UtfToUniChar(src, &ch);
+	improper = improper || (ch > 255);
 	*dst++ = UCHAR(ch);
     }
 
@@ -483,7 +583,8 @@ SetByteArrayFromAny(
     byteArrayPtr->allocated = length;
 
     SET_BYTEARRAY(&ir, byteArrayPtr);
-    Tcl_StoreIntRep(objPtr, &tclByteArrayType, &ir);
+    Tcl_StoreIntRep(objPtr,
+	    improper ? &tclByteArrayType : &properByteArrayType, &ir);
     return TCL_OK;
 }
 
@@ -510,6 +611,13 @@ FreeByteArrayInternalRep(
 {
     ckfree(GET_BYTEARRAY(Tcl_FetchIntRep(objPtr, &tclByteArrayType)));
 }
+
+static void
+FreeProperByteArrayInternalRep(
+    Tcl_Obj *objPtr)		/* Object with internal rep to free. */
+{
+    ckfree(GET_BYTEARRAY(Tcl_FetchIntRep(objPtr, &properByteArrayType)));
+}
 
 /*
  *----------------------------------------------------------------------
@@ -548,6 +656,27 @@ DupByteArrayInternalRep(
     SET_BYTEARRAY(&ir, copyArrayPtr);
     Tcl_StoreIntRep(copyPtr, &tclByteArrayType, &ir);
 }
+
+static void
+DupProperByteArrayInternalRep(
+    Tcl_Obj *srcPtr,		/* Object with internal rep to copy. */
+    Tcl_Obj *copyPtr)		/* Object with internal rep to set. */
+{
+    unsigned int length;
+    ByteArray *srcArrayPtr, *copyArrayPtr;
+    Tcl_ObjIntRep ir;
+
+    srcArrayPtr = GET_BYTEARRAY(Tcl_FetchIntRep(srcPtr, &properByteArrayType));
+    length = srcArrayPtr->used;
+
+    copyArrayPtr = ckalloc(BYTEARRAY_SIZE(length));
+    copyArrayPtr->used = length;
+    copyArrayPtr->allocated = length;
+    memcpy(copyArrayPtr->bytes, srcArrayPtr->bytes, (size_t) length);
+
+    SET_BYTEARRAY(&ir, copyArrayPtr);
+    Tcl_StoreIntRep(copyPtr, &properByteArrayType, &ir);
+}
 
 /*
  *----------------------------------------------------------------------
@@ -571,7 +700,7 @@ UpdateStringOfByteArray(
     Tcl_Obj *objPtr)		/* ByteArray object whose string rep to
 				 * update. */
 {
-    const Tcl_ObjIntRep *irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+    const Tcl_ObjIntRep *irPtr = Tcl_FetchIntRep(objPtr, &properByteArrayType);
     ByteArray *byteArrayPtr = GET_BYTEARRAY(irPtr);
     unsigned char *src = byteArrayPtr->bytes;
     unsigned int i, length = byteArrayPtr->used;
@@ -643,12 +772,19 @@ TclAppendBytesToByteArray(
 	/* Append zero bytes is a no-op. */
 	return;
     }
+
     length = (unsigned int)len;
 
-    irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+    irPtr = Tcl_FetchIntRep(objPtr, &properByteArrayType);
     if (irPtr == NULL) {
-	SetByteArrayFromAny(NULL, objPtr);
 	irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+	if (irPtr == NULL) {
+	    SetByteArrayFromAny(NULL, objPtr);
+	    irPtr = Tcl_FetchIntRep(objPtr, &properByteArrayType);
+	    if (irPtr == NULL) {
+		irPtr = Tcl_FetchIntRep(objPtr, &tclByteArrayType);
+	    }
+	}
     }
     byteArrayPtr = GET_BYTEARRAY(irPtr);
 
diff --git a/generic/tclIO.c b/generic/tclIO.c
index 5f479f4..291c13d 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -7141,7 +7141,7 @@ Tcl_Tell(
  *
  * Tcl_SeekOld, Tcl_TellOld --
  *
- *	Backward-compatability versions of the seek/tell interface that do not
+ *	Backward-compatibility versions of the seek/tell interface that do not
  *	support 64-bit offsets. This interface is not documented or expected
  *	to be supported indefinitely.
  *
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 56abbd8..0f2494a 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -4441,8 +4441,7 @@ MODULE_SCOPE void	TclDbInitNewObj(Tcl_Obj *objPtr, const char *file,
  *----------------------------------------------------------------
  */
 
-#define TclIsPureByteArray(objPtr) \
-	(((objPtr)->typePtr==&tclByteArrayType) && ((objPtr)->bytes==NULL))
+MODULE_SCOPE int	TclIsPureByteArray(Tcl_Obj *objPtr);
 
 /*
  *----------------------------------------------------------------
diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c
index 3bd2d63..eb53468 100644
--- a/generic/tclStringObj.c
+++ b/generic/tclStringObj.c
@@ -2472,6 +2472,10 @@ AppendPrintfToObjVA(
 		    Tcl_ListObjAppendElement(NULL, list, Tcl_NewLongObj(
 			    va_arg(argList, long)));
 		    break;
+		case 2:
+		    Tcl_ListObjAppendElement(NULL, list, Tcl_NewWideIntObj(
+			    va_arg(argList, Tcl_WideInt)));
+		    break;
 		}
 		break;
 	    case 'e':
@@ -2500,9 +2504,9 @@ AppendPrintfToObjVA(
 		gotPrecision = 1;
 		p++;
 		break;
-	    /* TODO: support for wide (and bignum?) arguments */
+	    /* TODO: support for bignum arguments */
 	    case 'l':
-		size = 1;
+		++size;
 		p++;
 		break;
 	    case 'h':
@@ -2708,8 +2712,8 @@ TclStringRepeat(
         if (0 == Tcl_AttemptSetObjLength(objResultPtr, count*length)) {
 	    if (interp) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-			"string size overflow: unable to alloc %lu bytes",
-			STRING_SIZE(count*length)));
+			"string size overflow: unable to alloc %llu bytes",
+			(Tcl_WideUInt)STRING_SIZE(count*length)));
 		Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 	    }
 	    return TCL_ERROR;
@@ -2895,7 +2899,7 @@ TclStringCatObjv(
 	 * Broken interface! Byte array value routines offer no way
 	 * to handle failure to allocate enough space. Following
 	 * stanza may panic.
-	 */ 
+	 */
 	if (inPlace && !Tcl_IsShared(*objv)) {
 	    int start;
 
@@ -2931,8 +2935,8 @@ TclStringCatObjv(
 	    if (0 == Tcl_AttemptSetObjLength(objResultPtr, length)) {
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		    	"concatenation failed: unable to alloc %lu bytes",
-			STRING_SIZE(length)));
+		    	"concatenation failed: unable to alloc %llu bytes",
+			(Tcl_WideUInt)STRING_SIZE(length)));
 		    Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 		}
 		return TCL_ERROR;
@@ -2946,8 +2950,8 @@ TclStringCatObjv(
 	    if (0 == Tcl_AttemptSetObjLength(objResultPtr, length)) {
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		    	"concatenation failed: unable to alloc %lu bytes",
-			STRING_SIZE(length)));
+		    	"concatenation failed: unable to alloc %llu bytes",
+			(Tcl_WideUInt)STRING_SIZE(length)));
 		    Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 		}
 		return TCL_ERROR;
diff --git a/generic/tclStringRep.h b/generic/tclStringRep.h
index db6f7e4..1ef1957 100644
--- a/generic/tclStringRep.h
+++ b/generic/tclStringRep.h
@@ -72,17 +72,17 @@ typedef struct {
     do {								\
 	if ((numChars) < 0 || (numChars) > STRING_MAXCHARS) {		\
 	    Tcl_Panic("max length for a Tcl unicode value (%d chars) exceeded", \
-		      STRING_MAXCHARS);					\
+		      (int)STRING_MAXCHARS);					\
 	}								\
     } while (0)
 #define stringAttemptAlloc(numChars) \
-    (String *) attemptckalloc((unsigned) STRING_SIZE(numChars))
+    (String *) attemptckalloc(STRING_SIZE(numChars))
 #define stringAlloc(numChars) \
-    (String *) ckalloc((unsigned) STRING_SIZE(numChars))
+    (String *) ckalloc(STRING_SIZE(numChars))
 #define stringRealloc(ptr, numChars) \
-    (String *) ckrealloc((ptr), (unsigned) STRING_SIZE(numChars))
+    (String *) ckrealloc((ptr), STRING_SIZE(numChars))
 #define stringAttemptRealloc(ptr, numChars) \
-    (String *) attemptckrealloc((ptr), (unsigned) STRING_SIZE(numChars))
+    (String *) attemptckrealloc((ptr), STRING_SIZE(numChars))
 #define GET_STRING(objPtr) \
     ((String *) (objPtr)->internalRep.twoPtrValue.ptr1)
 #define SET_STRING(objPtr, stringPtr) \
diff --git a/generic/tclVar.c b/generic/tclVar.c
index 92ca81c..0188c39 100644
--- a/generic/tclVar.c
+++ b/generic/tclVar.c
@@ -2786,7 +2786,7 @@ TclArraySet(
     } else {
 	/*
 	 * Not a dictionary, so assume (and convert to, for backward-
-	 * -compatability reasons) a list.
+	 * -compatibility reasons) a list.
 	 */
 
 	int elemLen;
diff --git a/library/http/http.tcl b/library/http/http.tcl
index d105886..ccd4cd1 100644
--- a/library/http/http.tcl
+++ b/library/http/http.tcl
@@ -1447,7 +1447,7 @@ proc http::mapReply {string} {
     set converted [string map $formMap $string]
     if {[string match "*\[\u0100-\uffff\]*" $converted]} {
 	regexp "\[\u0100-\uffff\]" $converted badChar
-	# Return this error message for maximum compatability... :^/
+	# Return this error message for maximum compatibility... :^/
 	return -code error \
 	    "can't read \"formMap($badChar)\": no such element in array"
     }
diff --git a/unix/tcl.m4 b/unix/tcl.m4
index f5aa84e..3189960 100644
--- a/unix/tcl.m4
+++ b/unix/tcl.m4
@@ -2706,7 +2706,7 @@ AC_DEFUN([SC_TCL_CFG_ENCODING], [
 #	advancedTest - the advanced test to run if the function is present
 #
 # Results:
-#	Might cause compatability versions of the function to be used.
+#	Might cause compatibility versions of the function to be used.
 #	Might affect the following vars:
 #		USE_COMPAT	(implicit)
 #
diff --git a/win/makefile.vc b/win/makefile.vc
index c10b196..d6de5e1 100644
--- a/win/makefile.vc
+++ b/win/makefile.vc
@@ -113,12 +113,12 @@ the build instructions.
 #		memdbg   = Enables the debugging memory allocator.

 #

 #	CHECKS=64bit,fullwarn,nodep,none

-#		Sets special macros for checking compatability.

+#		Sets special macros for checking compatibility.

 #

 #		64bit    = Enable 64bit portability warnings (if available)

 #		fullwarn = Builds with full compiler and link warnings enabled.

 #			    Very verbose.

-#		nodep	 = Turns off compatability macros to ensure the core

+#		nodep	 = Turns off compatibility macros to ensure the core

 #			    isn't being built with deprecated functions.

 #

 #	MACHINE=(ALPHA|AMD64|IA64|IX86)