17 files changed, 198 insertions, 241 deletions

diff --git a/generic/tcl.h b/generic/tcl.h
index f540f3e..7acc13b 100644
--- a/generic/tcl.h
+++ b/generic/tcl.h
@@ -561,7 +561,7 @@ typedef int (Tcl_CmdObjTraceProc) (void *clientData, Tcl_Interp *interp,
 	int level, const char *command, Tcl_Command commandInfo, int objc,
 	struct Tcl_Obj *const *objv);
 typedef int (Tcl_CmdObjTraceProc2) (void *clientData, Tcl_Interp *interp,
-	ptrdiff_t level, const char *command, Tcl_Command commandInfo, ptrdiff_t objc,
+	Tcl_Size level, const char *command, Tcl_Command commandInfo, Tcl_Size objc,
 	struct Tcl_Obj *const *objv);
 typedef void (Tcl_CmdObjTraceDeleteProc) (void *clientData);
 typedef void (Tcl_DupInternalRepProc) (struct Tcl_Obj *srcPtr,
@@ -586,7 +586,7 @@ typedef void (Tcl_NamespaceDeleteProc) (void *clientData);
 typedef int (Tcl_ObjCmdProc) (void *clientData, Tcl_Interp *interp,
 	int objc, struct Tcl_Obj *const *objv);
 typedef int (Tcl_ObjCmdProc2) (void *clientData, Tcl_Interp *interp,
-	ptrdiff_t objc, struct Tcl_Obj *const *objv);
+	Tcl_Size objc, struct Tcl_Obj *const *objv);
 typedef int (Tcl_LibraryInitProc) (Tcl_Interp *interp);
 typedef int (Tcl_LibraryUnloadProc) (Tcl_Interp *interp, int flags);
 typedef void (Tcl_PanicProc) (const char *format, ...);
@@ -2018,15 +2018,18 @@ typedef struct Tcl_EncodingType {
 #define TCL_ENCODING_CHAR_LIMIT		0x10
 /* Internal use bits, do not define bits in this space. See above comment */
 #define TCL_ENCODING_INTERNAL_USE_MASK  0xFF00
-/* Reserve top byte for profile values (disjoint, not a mask) */
+/*
+ * Reserve top byte for profile values (disjoint, not a mask). In case of
+ * changes, ensure ENCODING_PROFILE_* macros in tclInt.h are modified if
+ * necessary.
+ */
 #define TCL_ENCODING_PROFILE_TCL8     0x01000000
 #define TCL_ENCODING_PROFILE_STRICT   0x02000000
 #define TCL_ENCODING_PROFILE_REPLACE  0x03000000
-/* Still being argued - For Tcl9, is the default strict? TODO */
 #if TCL_MAJOR_VERSION < 9
 #define TCL_ENCODING_PROFILE_DEFAULT  TCL_ENCODING_PROFILE_TCL8
 #else
-#define TCL_ENCODING_PROFILE_DEFAULT  TCL_ENCODING_PROFILE_TCL8 /* STRICT? REPLACE? TODO */
+#define TCL_ENCODING_PROFILE_DEFAULT  TCL_ENCODING_PROFILE_TCL8
 #endif
 
 /*
@@ -2392,7 +2395,7 @@ EXTERN const char *TclZipfs_AppHook(int *argc, char ***argv);
 	TclStubCall((void *)4))(argc, argv, appInitProc, interp)
 #if !defined(_WIN32) || !defined(UNICODE)
 #define Tcl_MainEx(argc, argv, appInitProc, interp) \
-	(void)((const char *(*)(size_t, const void *, Tcl_AppInitProc *, Tcl_Interp *)) \
+	(void)((const char *(*)(Tcl_Size, const void *, Tcl_AppInitProc *, Tcl_Interp *)) \
 	TclStubCall((void *)5))(argc, argv, appInitProc, interp)
 #endif
 #define Tcl_StaticLibrary(interp, pkgName, initProc, safeInitProc) \
diff --git a/generic/tclArithSeries.c b/generic/tclArithSeries.c
index 92d4352..3f980c4 100755
--- a/generic/tclArithSeries.c
+++ b/generic/tclArithSeries.c
@@ -1090,52 +1090,6 @@ UpdateStringOfArithSeries(Tcl_Obj *arithSeriesObjPtr)
     if (bytlen > 0) arithSeriesObjPtr->bytes[bytlen-1] = '\0';
     arithSeriesObjPtr->length = bytlen-1;
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * TclArithSeriesObjCopy --
- *
- *	Makes a "pure arithSeries" copy of an ArithSeries value. This provides for the C
- *	level a counterpart of the [lrange $list 0 end] command, while using
- *	internals details to be as efficient as possible.
- *
- * Results:
- *
- *	Normally returns a pointer to a new Tcl_Obj, that contains the same
- *	arithSeries value as *arithSeriesObj does. The returned Tcl_Obj has a
- *	refCount of zero. If *arithSeriesObj does not hold an arithSeries,
- *	NULL is returned, and if interp is non-NULL, an error message is
- *	recorded there.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-Tcl_Obj *
-TclArithSeriesObjCopy(
-    Tcl_Interp *interp,		/* Used to report errors if not NULL. */
-    Tcl_Obj *arithSeriesObj)	/* List object for which an element array is
-				 * to be returned. */
-{
-    Tcl_Obj *copyPtr;
-    ArithSeries *arithSeriesRepPtr;
-
-    arithSeriesRepPtr = ArithSeriesGetInternalRep(arithSeriesObj);
-    if (NULL == arithSeriesRepPtr) {
-	if (SetArithSeriesFromAny(interp, arithSeriesObj) != TCL_OK) {
-	    /* We know this is going to panic, but it's the message we want */
-	    return NULL;
-	}
-    }
-
-    TclNewObj(copyPtr);
-    TclInvalidateStringRep(copyPtr);
-    DupArithSeriesInternalRep(arithSeriesObj, copyPtr);
-    return copyPtr;
-}
 
 /*
  * Local Variables:
diff --git a/generic/tclAssembly.c b/generic/tclAssembly.c
index 910532e..4aa241a 100644
--- a/generic/tclAssembly.c
+++ b/generic/tclAssembly.c
@@ -2247,7 +2247,7 @@ static int
 GetListIndexOperand(
     AssemblyEnv* assemEnvPtr,	/* Assembly environment */
     Tcl_Token** tokenPtrPtr,	/* Current token from the parser */
-    int* result)		/* OUTPUT: Integer extracted from the token */
+    int* result)		/* OUTPUT: encoded index derived from the token */
 {
     CompileEnv* envPtr = assemEnvPtr->envPtr;
 				/* Compilation environment */
diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index d18ddaf..f87e31c 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -5387,12 +5387,12 @@ TclEvalEx(
 		    expand[objectsUsed] = 1;
 
 		    additionalObjsCount = (numElements ? numElements : 1);
-		    
+
 		} else {
 		    expand[objectsUsed] = 0;
 		    additionalObjsCount = 1;
 		}
-		
+
 		/* Currently max command words in INT_MAX */
 		if (additionalObjsCount > INT_MAX ||
 		    objectsNeeded > (INT_MAX - additionalObjsCount)) {
diff --git a/generic/tclCmdAH.c b/generic/tclCmdAH.c
index cefd74e..6186ae5 100644
--- a/generic/tclCmdAH.c
+++ b/generic/tclCmdAH.c
@@ -2809,7 +2809,6 @@ EachloopCmd(
 
 	/* Values */
 	if (!TclHasInternalRep(objv[2+i*2], &tclListType) &&
-	    ABSTRACTLIST_PROC(objv[2+i*2],dupIntRepProc) &&
 	    ABSTRACTLIST_PROC(objv[2+i*2],indexProc)) {
 	    /* Special case for AbstractList */
 	    statePtr->aCopyList[i] = Tcl_DuplicateObj(objv[2+i*2]);
diff --git a/generic/tclCompile.c b/generic/tclCompile.c
index 926c492..b974c30 100644
--- a/generic/tclCompile.c
+++ b/generic/tclCompile.c
@@ -720,8 +720,8 @@ const Tcl_ObjType tclByteCodeType = {
 };
 
 /*
- * subtCodeType provides the standard type managemnt procedures for the
- * substcode type, which represents substiution within a Tcl value.
+ * substCodeType provides the standard type management procedures for the
+ * substcode type, which represents substitution within a Tcl value.
  */
 
 static const Tcl_ObjType substCodeType = {
diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index f067d92..3ab3de9 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -10,7 +10,6 @@
  */
 
 #include "tclInt.h"
-#include "tclIO.h"
 
 typedef size_t (LengthProc)(const char *src);
 
@@ -200,16 +199,16 @@ static struct TclEncodingProfiles {
     {"tcl8", TCL_ENCODING_PROFILE_TCL8},
 };
 #define PROFILE_TCL8(flags_)                                           \
-    ((CHANNEL_PROFILE_GET(flags_) == TCL_ENCODING_PROFILE_TCL8)   \
-     || (CHANNEL_PROFILE_GET(flags_) == 0                         \
+    ((ENCODING_PROFILE_GET(flags_) == TCL_ENCODING_PROFILE_TCL8)   \
+     || (ENCODING_PROFILE_GET(flags_) == 0                         \
 	 && TCL_ENCODING_PROFILE_DEFAULT == TCL_ENCODING_PROFILE_TCL8))
 #define PROFILE_STRICT(flags_)                                         \
-    ((CHANNEL_PROFILE_GET(flags_) == TCL_ENCODING_PROFILE_STRICT) \
-     || (CHANNEL_PROFILE_GET(flags_) == 0                         \
+    ((ENCODING_PROFILE_GET(flags_) == TCL_ENCODING_PROFILE_STRICT) \
+     || (ENCODING_PROFILE_GET(flags_) == 0                         \
 	 && TCL_ENCODING_PROFILE_DEFAULT == TCL_ENCODING_PROFILE_STRICT))
 #define PROFILE_REPLACE(flags_)                                         \
-    ((CHANNEL_PROFILE_GET(flags_) == TCL_ENCODING_PROFILE_REPLACE) \
-     || (CHANNEL_PROFILE_GET(flags_) == 0                          \
+    ((ENCODING_PROFILE_GET(flags_) == TCL_ENCODING_PROFILE_REPLACE) \
+     || (ENCODING_PROFILE_GET(flags_) == 0                          \
 	 && TCL_ENCODING_PROFILE_DEFAULT == TCL_ENCODING_PROFILE_REPLACE))
 
 #define UNICODE_REPLACE_CHAR ((Tcl_UniChar)0xFFFD)
@@ -1166,7 +1165,7 @@ Tcl_ExternalToUtfDString(
  * Tcl_ExternalToUtfDStringEx --
  *
  *	Convert a source buffer from the specified encoding into UTF-8.
- *	The parameter flags controls the behavior, if any of the bytes in
+ *	"flags" controls the behavior if any of the bytes in
  *	the source buffer are invalid or cannot be represented in utf-8.
  *	Possible flags values:
  *	target encoding. It should be composed by OR-ing the following:
@@ -2542,7 +2541,7 @@ UtfToUtfProc(
     memset(dst, 0xff, dstLen);
 #endif
 
-    profile = CHANNEL_PROFILE_GET(flags);
+    profile = ENCODING_PROFILE_GET(flags);
     for (numChars = 0; src < srcEnd && numChars <= charLimit; numChars++) {
 
 	if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
@@ -2589,10 +2588,10 @@ UtfToUtfProc(
 	} else if (!Tcl_UtfCharComplete(src, srcEnd - src)) {
 	    /*
 	     * Incomplete byte sequence.
-	     * Always check before using TclUtfToUCS4. Not doing can so
-	     * cause it run beyond the end of the buffer! If we happen such an
-	     * incomplete char its bytes are made to represent themselves
-	     * unless the user has explicitly asked to be told.
+		 * Always check before using TclUtfToUCS4. Not doing so can cause it
+		 * run beyond the end of the buffer! If we happen on such an incomplete
+		 * char its bytes are made to represent themselves unless the user has
+		 * explicitly asked to be told.
 	     */
 
 	    if (flags & ENCODING_INPUT) {
@@ -4642,9 +4641,9 @@ TclEncodingProfileIdToName(
 int TclEncodingSetProfileFlags(int flags)
 {
     if (flags & TCL_ENCODING_STOPONERROR) {
-	CHANNEL_PROFILE_SET(flags, TCL_ENCODING_PROFILE_STRICT);
+	ENCODING_PROFILE_SET(flags, TCL_ENCODING_PROFILE_STRICT);
     } else {
-	int profile = CHANNEL_PROFILE_GET(flags);
+	int profile = ENCODING_PROFILE_GET(flags);
 	switch (profile) {
 	case TCL_ENCODING_PROFILE_TCL8:
 	case TCL_ENCODING_PROFILE_STRICT:
@@ -4652,7 +4651,7 @@ int TclEncodingSetProfileFlags(int flags)
 	    break;
 	case 0: /* Unspecified by caller */
 	default:
-	    CHANNEL_PROFILE_SET(flags, TCL_ENCODING_PROFILE_DEFAULT);
+	    ENCODING_PROFILE_SET(flags, TCL_ENCODING_PROFILE_DEFAULT);
 	    break;
 	}
     }
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index c2cb43b..09597e9 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -112,9 +112,8 @@ typedef struct {
     ByteCode *codePtr;		/* Constant until the BC returns */
 				/* -----------------------------------------*/
     Tcl_Obj **catchTop;		/* These fields are used on return TO this */
-    Tcl_Obj *auxObjList;	/* this level: they record the state when a */
-    CmdFrame cmdFrame;		/* new codePtr was received for NR */
-                                /* execution. */
+    Tcl_Obj *auxObjList;	/* level: they record the state when a new */
+    CmdFrame cmdFrame;		/* codePtr was received for NR execution. */
     Tcl_Obj *stack[1];		/* Start of the actual combined catch and obj
 				 * stacks; the struct will be expanded as
 				 * necessary */
diff --git a/generic/tclIO.c b/generic/tclIO.c
index a7014e2..987f6b9 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -1679,11 +1679,11 @@ Tcl_CreateChannel(
     statePtr->encoding = Tcl_GetEncoding(NULL, name);
     statePtr->inputEncodingState  = NULL;
     statePtr->inputEncodingFlags  = TCL_ENCODING_START;
-    CHANNEL_PROFILE_SET(statePtr->inputEncodingFlags,
+    ENCODING_PROFILE_SET(statePtr->inputEncodingFlags,
 			     TCL_ENCODING_PROFILE_DEFAULT);
     statePtr->outputEncodingState = NULL;
     statePtr->outputEncodingFlags = TCL_ENCODING_START;
-    CHANNEL_PROFILE_SET(statePtr->outputEncodingFlags,
+    ENCODING_PROFILE_SET(statePtr->outputEncodingFlags,
 			     TCL_ENCODING_PROFILE_DEFAULT);
 
     /*
@@ -4347,7 +4347,7 @@ Write(
     Tcl_Size saved = 0, total = 0, flushed = 0;
     char safe[BUFFER_PADDING];
     int encodingError = 0;
-    
+
     if (srcLen) {
         WillWrite(chanPtr);
     }
@@ -5931,7 +5931,7 @@ DoReadChars(
 
     if (GotFlag(statePtr, CHANNEL_ENCODING_ERROR)) {
 	ResetFlag(statePtr, CHANNEL_EOF|CHANNEL_ENCODING_ERROR);
-	/* TODO: We don't need this call? */
+	/* TODO: UpdateInterest not needed here? */
 	UpdateInterest(chanPtr);
 	Tcl_SetErrno(EILSEQ);
 	return -1;
@@ -5948,7 +5948,7 @@ DoReadChars(
 	assert(statePtr->inputEncodingFlags & TCL_ENCODING_END);
 	assert(!GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR));
 
-	/* TODO: We don't need this call? */
+	/* TODO: UpdateInterest not needed here? */
 	UpdateInterest(chanPtr);
 	return 0;
     }
@@ -5962,7 +5962,7 @@ DoReadChars(
 	}
 	ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF);
 	statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
-	/* TODO: We don't need this call? */
+	/* TODO: UpdateInterest not needed here? */
 	UpdateInterest(chanPtr);
 	return 0;
     }
@@ -6009,7 +6009,7 @@ DoReadChars(
 	    }
 
 	    /*
-	     * If the current buffer is empty recycle it.
+	     * Recycle current buffer if empty.
 	     */
 
 	    bufPtr = statePtr->inQueueHead;
@@ -7974,7 +7974,7 @@ Tcl_GetChannelOption(
 	    Tcl_DStringAppendElement(dsPtr, "-profile");
 	}
 	/* Note currently input and output profiles are same */
-	profile = CHANNEL_PROFILE_GET(statePtr->inputEncodingFlags);
+	profile = ENCODING_PROFILE_GET(statePtr->inputEncodingFlags);
 	profileName = TclEncodingProfileIdToName(interp, profile);
 	if (profileName == NULL) {
 	    return TCL_ERROR;
@@ -8169,11 +8169,11 @@ Tcl_SetChannelOption(
 
 	if ((newValue[0] == '\0') || (strcmp(newValue, "binary") == 0)) {
 	    encoding = Tcl_GetEncoding(NULL, "iso8859-1");
-	    CHANNEL_PROFILE_SET(statePtr->inputEncodingFlags
-		    ,CHANNEL_PROFILE_GET(statePtr->inputEncodingFlags)
+	    ENCODING_PROFILE_SET(statePtr->inputEncodingFlags
+		    ,ENCODING_PROFILE_GET(statePtr->inputEncodingFlags)
 			|TCL_ENCODING_PROFILE_STRICT);
-	    CHANNEL_PROFILE_SET(statePtr->outputEncodingFlags
-		    ,CHANNEL_PROFILE_GET(statePtr->outputEncodingFlags)
+	    ENCODING_PROFILE_SET(statePtr->outputEncodingFlags
+		    ,ENCODING_PROFILE_GET(statePtr->outputEncodingFlags)
 			|TCL_ENCODING_PROFILE_STRICT);
 	} else {
 	    encoding = Tcl_GetEncoding(interp, newValue);
@@ -8196,12 +8196,12 @@ Tcl_SetChannelOption(
 	Tcl_FreeEncoding(statePtr->encoding);
 	statePtr->encoding = encoding;
 	statePtr->inputEncodingState = NULL;
-	profile = CHANNEL_PROFILE_GET(statePtr->inputEncodingFlags);
+	profile = ENCODING_PROFILE_GET(statePtr->inputEncodingFlags);
 	statePtr->inputEncodingFlags = TCL_ENCODING_START;
-	CHANNEL_PROFILE_SET(statePtr->inputEncodingFlags, profile);
+	ENCODING_PROFILE_SET(statePtr->inputEncodingFlags, profile);
 	statePtr->outputEncodingState = NULL;
 	statePtr->outputEncodingFlags = TCL_ENCODING_START;
-	CHANNEL_PROFILE_SET(statePtr->outputEncodingFlags, profile); /* Same as input */
+	ENCODING_PROFILE_SET(statePtr->outputEncodingFlags, profile); /* Same as input */
 	ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA|CHANNEL_ENCODING_ERROR);
 	UpdateInterest(chanPtr);
 	return TCL_OK;
@@ -8244,8 +8244,8 @@ Tcl_SetChannelOption(
 	if (TclEncodingProfileNameToId(interp, newValue, &profile) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	CHANNEL_PROFILE_SET(statePtr->inputEncodingFlags, profile);
-	CHANNEL_PROFILE_SET(statePtr->outputEncodingFlags, profile);
+	ENCODING_PROFILE_SET(statePtr->inputEncodingFlags, profile);
+	ENCODING_PROFILE_SET(statePtr->outputEncodingFlags, profile);
 	ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA|CHANNEL_ENCODING_ERROR);
 	return TCL_OK;
     } else if (HaveOpt(1, "-translation")) {
@@ -8283,11 +8283,11 @@ Tcl_SetChannelOption(
 		statePtr->inEofChar = 0;
 		Tcl_FreeEncoding(statePtr->encoding);
 		statePtr->encoding = Tcl_GetEncoding(NULL, "iso8859-1");
-		CHANNEL_PROFILE_SET(statePtr->inputEncodingFlags
-			,CHANNEL_PROFILE_GET(statePtr->inputEncodingFlags)
+		ENCODING_PROFILE_SET(statePtr->inputEncodingFlags
+			,ENCODING_PROFILE_GET(statePtr->inputEncodingFlags)
 			    |TCL_ENCODING_PROFILE_STRICT);
-		CHANNEL_PROFILE_SET(statePtr->outputEncodingFlags
-			,CHANNEL_PROFILE_GET(statePtr->outputEncodingFlags)
+		ENCODING_PROFILE_SET(statePtr->outputEncodingFlags
+			,ENCODING_PROFILE_GET(statePtr->outputEncodingFlags)
 			    |TCL_ENCODING_PROFILE_STRICT);
 	    } else if (strcmp(readMode, "lf") == 0) {
 		translation = TCL_TRANSLATE_LF;
@@ -8338,11 +8338,11 @@ Tcl_SetChannelOption(
 		statePtr->outputTranslation = TCL_TRANSLATE_LF;
 		Tcl_FreeEncoding(statePtr->encoding);
 		statePtr->encoding = Tcl_GetEncoding(NULL, "iso8859-1");
-		CHANNEL_PROFILE_SET(statePtr->inputEncodingFlags
-			,CHANNEL_PROFILE_GET(statePtr->inputEncodingFlags)
+		ENCODING_PROFILE_SET(statePtr->inputEncodingFlags
+			,ENCODING_PROFILE_GET(statePtr->inputEncodingFlags)
 			    |TCL_ENCODING_PROFILE_STRICT);
-		CHANNEL_PROFILE_SET(statePtr->outputEncodingFlags
-			,CHANNEL_PROFILE_GET(statePtr->outputEncodingFlags)
+		ENCODING_PROFILE_SET(statePtr->outputEncodingFlags
+			,ENCODING_PROFILE_GET(statePtr->outputEncodingFlags)
 			    |TCL_ENCODING_PROFILE_STRICT);
 	    } else if (strcmp(writeMode, "lf") == 0) {
 		statePtr->outputTranslation = TCL_TRANSLATE_LF;
@@ -10269,8 +10269,8 @@ Lossless(
 	    (
 		toRead == -1
 		&& inStatePtr->encoding == outStatePtr->encoding
-		&& CHANNEL_PROFILE_GET(inStatePtr->inputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8
-		&& CHANNEL_PROFILE_GET(outStatePtr->inputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8
+		&& ENCODING_PROFILE_GET(inStatePtr->inputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8
+		&& ENCODING_PROFILE_GET(outStatePtr->inputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8
 	    )
 	);
 }
diff --git a/generic/tclIO.h b/generic/tclIO.h
index 6b166b0..145296a 100644
--- a/generic/tclIO.h
+++ b/generic/tclIO.h
@@ -288,13 +288,6 @@ typedef struct ChannelState {
 #define CHANNEL_CLOSEDWRITE	(1<<21)	/* Channel write side has been closed.
 					 * No further Tcl-level write IO on
 					 * the channel is allowed. */
-#define CHANNEL_PROFILE_MASK     0xFF000000
-#define CHANNEL_PROFILE_GET(flags_)  ((flags_) & CHANNEL_PROFILE_MASK)
-#define CHANNEL_PROFILE_SET(flags_, profile_) \
-    do {                                           \
-	(flags_) &= ~CHANNEL_PROFILE_MASK;    \
-	(flags_) |= profile_;                      \
-    } while (0)
 
 /*
  * The length of time to wait between synthetic timer events. Must be zero or
diff --git a/generic/tclInt.h b/generic/tclInt.h
index fde07c8..34e9383 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -2892,6 +2892,22 @@ typedef struct ProcessGlobalValue {
 #define TCL_PARSE_NO_UNDERSCORE	128
 				/* Reject underscore digit separator */
 
+
+/*
+ *----------------------------------------------------------------------
+ * Internal convenience macros for manipulating encoding flags. See
+ * TCL_ENCODING_PROFILE_* in tcl.h
+ *----------------------------------------------------------------------
+ */
+
+#define ENCODING_PROFILE_MASK     0xFF000000
+#define ENCODING_PROFILE_GET(flags_)  ((flags_) & ENCODING_PROFILE_MASK)
+#define ENCODING_PROFILE_SET(flags_, profile_) \
+    do {                                       \
+	(flags_) &= ~ENCODING_PROFILE_MASK;    \
+	(flags_) |= profile_;                  \
+    } while (0)
+
 /*
  *----------------------------------------------------------------
  * Variables shared among Tcl modules but not used by the outside world.
diff --git a/generic/tclListObj.c b/generic/tclListObj.c
index d15a3ed..3c4c4d2 100644
--- a/generic/tclListObj.c
+++ b/generic/tclListObj.c
@@ -39,7 +39,7 @@
 
 #ifdef ENABLE_LIST_ASSERTS
 
-#define LIST_ASSERT(cond_) assert(cond_) /* TODO - is there a Tcl-specific one? */
+#define LIST_ASSERT(cond_) assert(cond_)
 /*
  * LIST_INDEX_ASSERT is to catch errors with negative indices and counts
  * being passed AFTER validation. On Tcl9 length types are unsigned hence
@@ -68,8 +68,7 @@
 
 /* Checks for when caller should have already converted to internal list type */
 #define LIST_ASSERT_TYPE(listObj_) \
-    LIST_ASSERT((listObj_)->typePtr == &tclListType);
-
+    LIST_ASSERT(TclHasInternalRep((listObj_), &tclListType))
 
 /*
  * If ENABLE_LIST_INVARIANTS is enabled (-DENABLE_LIST_INVARIANTS from the
@@ -311,12 +310,12 @@ ListSpanMerited(
     Tcl_Size allocatedStorageLength) /* Length of the currently allocation */
 {
     /*
-     TODO
-     - heuristics thresholds need to be determined
-     - currently, information about the sharing (ref count) of existing
-       storage is not passed. Perhaps it should be. For example if the
-       existing storage has a "large" ref count, then it might make sense
-       to do even a small span.
+     * Possible optimizations for future consideration
+     * - heuristic LIST_SPAN_THRESHOLD
+     * - currently, information about the sharing (ref count) of existing
+     * storage is not passed. Perhaps it should be. For example if the
+     * existing storage has a "large" ref count, then it might make sense
+     * to do even a small span.
      */
 
     if (length < LIST_SPAN_THRESHOLD) {
@@ -777,14 +776,16 @@ ListStoreNew(
     }
 
     if (flags & LISTREP_SPACE_FLAGS) {
+	/* Caller requests extra space front, back or both */
 	capacity = ListStoreUpSize(objc);
     } else {
 	capacity = objc;
     }
 
     storePtr = (ListStore *)Tcl_AttemptAlloc(LIST_SIZE(capacity));
-    if (storePtr == NULL && capacity != objc) {
-	capacity = objc; /* Try allocating exact size */
+    while (storePtr == NULL && (capacity > (objc+1))) {
+	/* Because of loop condition capacity won't overflow */
+	capacity = objc + ((capacity - objc) / 2);
 	storePtr = (ListStore *)Tcl_AttemptAlloc(LIST_SIZE(capacity));
     }
     if (storePtr == NULL) {
@@ -833,7 +834,8 @@ ListStoreNew(
  *
  * ListStoreReallocate --
  *
- *    Reallocates the memory for a ListStore.
+ *    Reallocates the memory for a ListStore allocating extra for
+ *    possible future growth.
  *
  * Results:
  *    Pointer to the ListStore which may be the same as storePtr or pointer
@@ -862,7 +864,7 @@ ListStoreReallocate (ListStore *storePtr, Tcl_Size numSlots)
      * by half every time.
      */
     while (newStorePtr == NULL && (newCapacity > (numSlots+1))) {
-	/* Because of loop condition newCapacity can't overflow */
+	/* Because of loop condition newCapacity won't overflow */
 	newCapacity = numSlots + ((newCapacity - numSlots) / 2);
 	newStorePtr =
 	    (ListStore *)Tcl_AttemptRealloc(storePtr, LIST_SIZE(newCapacity));
@@ -1974,19 +1976,18 @@ int
 Tcl_ListObjIndex(
     Tcl_Interp *interp,  /* Used to report errors if not NULL. */
     Tcl_Obj *listObj,    /* List object to index into. */
-    Tcl_Size index,           /* Index of element to return. */
+    Tcl_Size index,      /* Index of element to return. */
     Tcl_Obj **objPtrPtr) /* The resulting Tcl_Obj* is stored here. */
 {
     Tcl_Obj **elemObjs;
     Tcl_Size numElems;
 
-    /*
-     * TODO
-     * Unlike the original list code, this does not optimize for lindex'ing
-     * an empty string when the internal rep is not already a list. On the
-     * other hand, this code will be faster for the case where the object
-     * is currently a dict. Benchmark the two cases.
-     */
+    /* Empty string => empty list. Avoid unnecessary shimmering */
+    if (listObj->bytes == &tclEmptyString) {
+	*objPtrPtr = NULL;
+	return TCL_OK;
+    }
+
     if (TclListObjGetElementsM(interp, listObj, &numElems, &elemObjs)
 	!= TCL_OK) {
 	return TCL_ERROR;
@@ -2031,19 +2032,19 @@ Tcl_ListObjLength(
 {
     ListRep listRep;
 
+    /* Empty string => empty list. Avoid unnecessary shimmering */
+    if (listObj->bytes == &tclEmptyString) {
+	*lenPtr = 0;
+	return TCL_OK;
+    }
+
     Tcl_Size (*lengthProc)(Tcl_Obj *obj) =  ABSTRACTLIST_PROC(listObj, lengthProc);
     if (lengthProc) {
 	*lenPtr = lengthProc(listObj);
 	return TCL_OK;
     }
 
-    /*
-     * TODO
-     * Unlike the original list code, this does not optimize for lindex'ing
-     * an empty string when the internal rep is not already a list. On the
-     * other hand, this code will be faster for the case where the object
-     * is currently a dict. Benchmark the two cases.
-     */
+
     if (TclListObjGetRep(interp, listObj, &listRep) != TCL_OK) {
 	return TCL_ERROR;
     }
@@ -2108,12 +2109,12 @@ Tcl_ListObjReplace(
 {
     ListRep listRep;
     Tcl_Size origListLen;
-    ptrdiff_t lenChange;
-    ptrdiff_t leadSegmentLen;
-    ptrdiff_t tailSegmentLen;
+    Tcl_Size lenChange;
+    Tcl_Size leadSegmentLen;
+    Tcl_Size tailSegmentLen;
     Tcl_Size numFreeSlots;
-    ptrdiff_t leadShift;
-    ptrdiff_t tailShift;
+    Tcl_Size leadShift;
+    Tcl_Size tailShift;
     Tcl_Obj **listObjs;
     int favor;
 
@@ -2129,8 +2130,6 @@ Tcl_ListObjReplace(
     if (TclListObjGetRep(interp, listObj, &listRep) != TCL_OK)
 	return TCL_ERROR; /* Cannot be converted to a list */
 
-    /* TODO - will need modification if Tcl9 sticks to unsigned indices */
-
     /* Make limits sane */
     origListLen = ListRepLength(&listRep);
     if (first < 0) {
@@ -2279,7 +2278,7 @@ Tcl_ListObjReplace(
      * be an explicit alloc and memmove which would let us redistribute
      * free space.
      */
-    if ((ptrdiff_t)numFreeSlots < lenChange && !ListRepIsShared(&listRep)) {
+    if (numFreeSlots < lenChange && !ListRepIsShared(&listRep)) {
 	/* T:listrep-1.{1,3,14,18,21},3.{3,10,11,14,27,32,41} */
 	ListStore *newStorePtr =
 	    ListStoreReallocate(listRep.storePtr, origListLen + lenChange);
@@ -2306,7 +2305,7 @@ Tcl_ListObjReplace(
      * TODO - for unshared case ONLY, consider a "move" based implementation
      */
     if (ListRepIsShared(&listRep) || /* 3a */
-	(ptrdiff_t)numFreeSlots < lenChange ||  /* 3b */
+	numFreeSlots < lenChange ||  /* 3b */
 	(origListLen + lenChange) < (listRep.storePtr->numAllocated / 4) /* 3c */
     ) {
 	ListRep newRep;
@@ -2421,9 +2420,9 @@ Tcl_ListObjReplace(
 	 * or need to shift both. In the former case, favor shifting the
 	 * smaller segment.
 	 */
-	ptrdiff_t leadSpace = ListRepNumFreeHead(&listRep);
-	ptrdiff_t tailSpace = ListRepNumFreeTail(&listRep);
-	ptrdiff_t finalFreeSpace = leadSpace + tailSpace - lenChange;
+	Tcl_Size leadSpace = ListRepNumFreeHead(&listRep);
+	Tcl_Size tailSpace = ListRepNumFreeTail(&listRep);
+	Tcl_Size finalFreeSpace = leadSpace + tailSpace - lenChange;
 
 	LIST_ASSERT((leadSpace + tailSpace) >= lenChange);
 	if (leadSpace >= lenChange
@@ -2440,7 +2439,7 @@ Tcl_ListObjReplace(
 	     * insertions.
 	     */
 	    if (finalFreeSpace > 1 && (tailSpace == 0 || tailSegmentLen == 0)) {
-		ptrdiff_t postShiftLeadSpace = leadSpace - lenChange;
+		Tcl_Size postShiftLeadSpace = leadSpace - lenChange;
 		if (postShiftLeadSpace > (finalFreeSpace/2)) {
 		    Tcl_Size extraShift = postShiftLeadSpace - (finalFreeSpace / 2);
 		    leadShift -= extraShift;
@@ -2457,7 +2456,7 @@ Tcl_ListObjReplace(
 	     * See comments above. This is analogous.
 	     */
 	    if (finalFreeSpace > 1 && (leadSpace == 0 || leadSegmentLen == 0)) {
-		ptrdiff_t postShiftTailSpace = tailSpace - lenChange;
+		Tcl_Size postShiftTailSpace = tailSpace - lenChange;
 		if (postShiftTailSpace > (finalFreeSpace/2)) {
 		    /* T:listrep-1.{1,3,14,18,21},3.{2,3,26,27} */
 		    Tcl_Size extraShift = postShiftTailSpace - (finalFreeSpace / 2);
@@ -2632,7 +2631,7 @@ TclLindexList(
 	/*
 	 * The argument is neither an index nor a well-formed list.
 	 * Report the error via TclLindexFlat.
-	 * TODO - This is as original. why not directly return an error?
+	 * TODO - This is as original code. why not directly return an error?
 	 */
 	return TclLindexFlat(interp, listObj, 1, &argObj);
     }
@@ -2676,6 +2675,7 @@ TclLindexFlat(
     Tcl_Obj *const indexArray[])/* Array of pointers to Tcl objects that
 				 * represent the indices in the list. */
 {
+    int status;
     Tcl_Size i;
 
     /* Handle AbstractList as special case */
@@ -2706,24 +2706,13 @@ TclLindexFlat(
 
     for (i=0 ; i<indexCount && listObj ; i++) {
 	Tcl_Size index, listLen = 0;
-	Tcl_Obj **elemPtrs = NULL, *sublistCopy;
+	Tcl_Obj **elemPtrs = NULL;
 
-	/*
-	 * Here we make a private copy of the current sublist, so we avoid any
-	 * shimmering issues that might invalidate the elemPtr array below
-	 * while we are still using it. See test lindex-8.4.
-	 */
-
-	sublistCopy = TclListObjCopy(interp, listObj);
-	Tcl_DecrRefCount(listObj);
-	listObj = NULL;
-
-	if (sublistCopy == NULL) {
-	    /* The sublist is not a list at all => error.  */
-	    break;
+	status = Tcl_ListObjLength(interp, listObj, &listLen);
+	if (status != TCL_OK) {
+	    Tcl_DecrRefCount(listObj);
+	    return NULL;
 	}
-	LIST_ASSERT_TYPE(sublistCopy);
-	ListObjGetElements(sublistCopy, listLen, elemPtrs);
 
 	if (TclGetIntForIndexM(interp, indexArray[i], /*endValue*/ listLen-1,
 		&index) == TCL_OK) {
@@ -2737,20 +2726,43 @@ TclLindexFlat(
 		    if (TclGetIntForIndexM(
 			    interp, indexArray[i], TCL_SIZE_MAX - 1, &index)
 			!= TCL_OK) {
-			Tcl_DecrRefCount(sublistCopy);
+			Tcl_DecrRefCount(listObj);
 			return NULL;
 		    }
 		}
+		Tcl_DecrRefCount(listObj);
 		TclNewObj(listObj);
+		Tcl_IncrRefCount(listObj);
 	    } else {
+		Tcl_Obj *itemObj;
+		/*
+		 * Must set the internal rep again because it may have been
+		 * changed by TclGetIntForIndexM. See test lindex-8.4.
+		 */
+		if (!TclHasInternalRep(listObj, &tclListType)) {
+		    status = SetListFromAny(interp, listObj);
+		    if (status != TCL_OK) {
+			/* The list is not a list at all => error.  */
+			Tcl_DecrRefCount(listObj);
+			return NULL;
+		    }
+		}
+
+		ListObjGetElements(listObj, listLen, elemPtrs);
+		/* increment this reference count first before decrementing
+		 * just in case they are the same Tcl_Obj
+		 */
+		itemObj = elemPtrs[index];
+		Tcl_IncrRefCount(itemObj);
+		Tcl_DecrRefCount(listObj);
 		/* Extract the pointer to the appropriate element. */
-		listObj = elemPtrs[index];
+		listObj = itemObj;
 	    }
-	    Tcl_IncrRefCount(listObj);
+	} else {
+	    Tcl_DecrRefCount(listObj);
+	    listObj = NULL;
 	}
-	Tcl_DecrRefCount(sublistCopy);
     }
-
     return listObj;
 }
 
@@ -3595,7 +3607,7 @@ TclListTestObj(size_t length, size_t leadingSpace, size_t endSpace)
 	return NULL;
     }
 
-    ListRepInit(capacity, NULL, 0, &listRep);
+    ListRepInit(capacity, NULL, LISTREP_PANIC_ON_FAIL, &listRep);
 
     ListStore *storePtr = listRep.storePtr;
     size_t i;
diff --git a/generic/tclOO.h b/generic/tclOO.h
index 775bd32..524acb9 100644
--- a/generic/tclOO.h
+++ b/generic/tclOO.h
@@ -63,7 +63,7 @@ typedef struct Tcl_ObjectContext_ *Tcl_ObjectContext;
 typedef int (Tcl_MethodCallProc)(void *clientData, Tcl_Interp *interp,
 	Tcl_ObjectContext objectContext, int objc, Tcl_Obj *const *objv);
 typedef int (Tcl_MethodCallProc2)(void *clientData, Tcl_Interp *interp,
-	Tcl_ObjectContext objectContext, ptrdiff_t objc, Tcl_Obj *const *objv);
+	Tcl_ObjectContext objectContext, Tcl_Size objc, Tcl_Obj *const *objv);
 typedef void (Tcl_MethodDeleteProc)(void *clientData);
 typedef int (Tcl_CloneProc)(Tcl_Interp *interp, void *oldClientData,
 	void **newClientData);
diff --git a/generic/tclOOInt.h b/generic/tclOOInt.h
index c3f6fc2..0e666e9 100644
--- a/generic/tclOOInt.h
+++ b/generic/tclOOInt.h
@@ -589,12 +589,12 @@ MODULE_SCOPE void	TclOOSetupVariableResolver(Tcl_Namespace *nsPtr);
 /*
  * A variation where the array is an array of structs. There's no issue with
  * possible NULLs; every element of the array will be iterated over and the
- * varable set to a pointer to each of those elements in turn.
- * REQUIRES DECLARATION: Tcl_Size i;
+ * variable set to a pointer to each of those elements in turn.
+ * REQUIRES DECLARATION: Tcl_Size i; See [96551aca55] for more FOREACH_STRUCT details.
  */
 
 #define FOREACH_STRUCT(var,ary) \
-    for(i=0 ; var=&((ary).list[i]), i<(ary).num; i++)
+    if (i=0, (ary).num>0) for(; var=&((ary).list[i]), i<(ary).num; i++)
 
 /*
  * Convenience macros for iterating through hash tables. FOREACH_HASH_DECLS
diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c
index 63e38bb..d0703b3 100644
--- a/generic/tclStringObj.c
+++ b/generic/tclStringObj.c
@@ -1,29 +1,27 @@
 /*
  * tclStringObj.c --
  *
- *	This file contains functions that implement string operations on Tcl
- *	objects. Some string operations work with UTF strings and others
- *	require Unicode format. Functions that require knowledge of the width
- *	of each character, such as indexing, operate on Unicode data.
- *
- *	A Unicode string is an internationalized string. Conceptually, a
- *	Unicode string is an array of 16-bit quantities organized as a
- *	sequence of properly formed UTF-8 characters. There is a one-to-one
- *	map between Unicode and UTF characters. Because Unicode characters
- *	have a fixed width, operations such as indexing operate on Unicode
- *	data. The String object is optimized for the case where each UTF char
+ *      This file contains functions that implement string operations on Tcl
+ *      objects. Some string operations work with UTF-8 encoding forms.
+ *      Functions that require knowledge of the width of each character,
+ * 	such as indexing, operate on fixed width encoding forms such as UTF-32.
+ *
+ * 	Conceptually, a string is a sequence of Unicode code points. Internally
+ * 	it may be stored in an encoding form such as a modified version of
+ * 	UTF-8 or UTF-16 (when TCL_UTF_MAX=3) or UTF-32.
+ *
+ *	The String object is optimized for the case where each UTF char
  *	in a string is only one byte. In this case, we store the value of
- *	numChars, but we don't store the Unicode data (unless Tcl_GetUnicode
- *	is explicitly called).
+ *	numChars, but we don't store the fixed form encoding (unless
+ * 	Tcl_GetUnicode is explicitly called).
  *
- *	The String object type stores one or both formats. The default
- *	behavior is to store UTF. Once Unicode is calculated by a function, it
- *	is stored in the internal rep for future access (without an additional
- *	O(n) cost).
+ *      The String object type stores one or both formats. The default
+ *      behavior is to store UTF-8. Once UTF-16/UTF32 is calculated, it is
+ *      stored in the internal rep for future access (without an additional
+ *      O(n) cost).
  *
  *	To allow many appends to be done to an object without constantly
- *	reallocating the space for the string or Unicode representation, we
- *	allocate double the space for the string or Unicode and use the
+ *	reallocating space, we allocate double the space and use the
  *	internal representation to keep track of how much space is used vs.
  *	allocated.
  *
@@ -2753,12 +2751,16 @@ AppendPrintfToObjVA(
 
 		break;
 	    }
+	    case 'p':
+		if (sizeof(size_t) == sizeof(Tcl_WideInt)) {
+		    size = 2;
+		}
+		/* FALLTHRU */
 	    case 'c':
 	    case 'i':
 	    case 'u':
 	    case 'd':
 	    case 'o':
-	    case 'p':
 	    case 'x':
 	    case 'X':
 		seekingConversion = 0;
@@ -3139,8 +3141,7 @@ TclStringCat(
 {
     Tcl_Obj *objResultPtr, * const *ov;
     int binary = 1;
-    Tcl_Size oc;
-    Tcl_Size length = 0;
+    Tcl_Size oc, length = 0;
     int allowUniChar = 1, requestUniChar = 0, forceUniChar = 0;
     Tcl_Size first = objc - 1;	/* Index of first value possibly not empty */
     Tcl_Size last = 0;		/* Index of last value possibly not empty */
diff --git a/generic/tclStringRep.h b/generic/tclStringRep.h
index d0c76cb..768c1ee 100644
--- a/generic/tclStringRep.h
+++ b/generic/tclStringRep.h
@@ -1,29 +1,12 @@
 /*
  * tclStringRep.h --
  *
- *	This file contains the definition of the Unicode string internal
- *	representation and macros to access it.
+ *  This file contains the definition of internal representations of a string
+ *  and macros to access it.
  *
- *	A Unicode string is an internationalized string. Conceptually, a
- *	Unicode string is an array of 16-bit quantities organized as a
- *	sequence of properly formed UTF-8 characters. There is a one-to-one
- *	map between Unicode and UTF characters. Because Unicode characters
- *	have a fixed width, operations such as indexing operate on Unicode
- *	data. The String object is optimized for the case where each UTF char
- *	in a string is only one byte. In this case, we store the value of
- *	numChars, but we don't store the Unicode data (unless Tcl_GetUnicode
- *	is explicitly called).
- *
- *	The String object type stores one or both formats. The default
- *	behavior is to store UTF. Once Unicode is calculated by a function, it
- *	is stored in the internal rep for future access (without an additional
- *	O(n) cost).
- *
- *	To allow many appends to be done to an object without constantly
- *	reallocating the space for the string or Unicode representation, we
- *	allocate double the space for the string or Unicode and use the
- *	internal representation to keep track of how much space is used vs.
- *	allocated.
+ *  Conceptually, a string is a sequence of Unicode code points. Internally
+ *  it may be stored in an encoding form such as a modified version of UTF-8
+ *  or UTF-16 (when TCL_UTF_MAX=3) or UTF-32.
  *
  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  * Copyright (c) 1999 by Scriptics Corporation.
@@ -39,15 +22,10 @@
 /*
  * The following structure is the internal rep for a String object. It keeps
  * track of how much memory has been used and how much has been allocated for
- * the Unicode and UTF string to enable growing and shrinking of the UTF and
- * Unicode reps of the String object with fewer mallocs. To optimize string
+ * the various representations to enable growing and shrinking of
+ * the String object with fewer mallocs. To optimize string
  * length and indexing operations, this structure also stores the number of
- * characters (same of UTF and Unicode!) once that value has been computed.
- *
- * Under normal configurations, what Tcl calls "Unicode" is actually UTF-16
- * restricted to the Basic Multilingual Plane (i.e. U+00000 to U+0FFFF). This
- * can be officially modified by altering the definition of Tcl_UniChar in
- * tcl.h, but do not do that unless you are sure what you're doing!
+ * code points (independent of encoding form) once that value has been computed.
  */
 
 typedef struct {
@@ -57,15 +35,15 @@ typedef struct {
 				 * Unicode rep, or that the number of UTF bytes ==
 				 * the number of chars. */
     Tcl_Size allocated;		/* The amount of space actually allocated for
-				 * the UTF string (minus 1 byte for the
+				 * the UTF-8 string (minus 1 byte for the
 				 * termination char). */
     Tcl_Size maxChars;		/* Max number of chars that can fit in the
 				 * space allocated for the Unicode array. */
     int hasUnicode;		/* Boolean determining whether the string has
-				 * a Unicode representation. */
-    Tcl_UniChar unicode[TCLFLEXARRAY];	/* The array of Unicode chars. The actual size
-				 * of this field depends on the 'maxChars'
-				 * field above. */
+				 * a Tcl_UniChar representation. */
+    Tcl_UniChar unicode[TCLFLEXARRAY];	/* The array of Tcl_UniChar units.
+				 * The actual size of this field depends on
+				 * the maxChars field above. */
 } String;
 
 /* Limit on string lengths. The -1 because limit does not include the nul */
diff --git a/generic/tclUtil.c b/generic/tclUtil.c
index 10c9bd2..8c34435 100644
--- a/generic/tclUtil.c
+++ b/generic/tclUtil.c
@@ -2815,6 +2815,9 @@ Tcl_DStringSetLength(
 {
     Tcl_Size newsize;
 
+    if (length < 0) {
+	length = 0;
+    }
     if (length >= dsPtr->spaceAvl) {
 	/*
 	 * There are two interesting cases here. In the first case, the user
@@ -3803,8 +3806,8 @@ TclIndexEncode(
     }
     /*
      * We passed 2*INT_MAX as the "end value" to GetWideForIndex. The computed
-     * index will in one of the following ranges that need to be distinguished
-     * for encoding purposes in the following code.
+     * index will be in one of the following ranges that need to be
+     * distinguished for encoding purposes in the following code.
      * (1) 0:INT_MAX when
      *     (a) objPtr was a pure non-negative numeric value in that range
      *     (b) objPtr was a numeric computation M+/-N with a result in that range
@@ -3853,7 +3856,7 @@ TclIndexEncode(
 	 * error is raised. On 32-bit systems, indices in that range indicate
 	 * the position after the end and so do not raise an error.
 	 */
-	if ((sizeof(int) != sizeof(size_t)) &&
+	if ((sizeof(int) != sizeof(Tcl_Size)) &&
 	    (wide > INT_MAX) && (wide < WIDE_MAX-1)) {
 	    /* 2(a,b) on 64-bit systems*/
 	    goto rangeerror;
@@ -3883,7 +3886,7 @@ TclIndexEncode(
 	 * indices in that range indicate the position before the beginning
 	 * and so do not raise an error.
 	 */
-	if ((sizeof(int) != sizeof(size_t)) &&
+	if ((sizeof(int) != sizeof(Tcl_Size)) &&
 	    (wide > (ENDVALUE - LIST_MAX)) && (wide <= INT_MAX)) {
 	    /* 1(c), 4(a,b) on 64-bit systems */
 	    goto rangeerror;