Merge trunk

10 files changed, 325 insertions, 292 deletions

diff --git a/generic/tclCompile.h b/generic/tclCompile.h
index 24bc604..0ad7b58 100644
--- a/generic/tclCompile.h
+++ b/generic/tclCompile.h
@@ -1084,7 +1084,7 @@ MODULE_SCOPE ByteCode *	TclCompileObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
  */
 
 MODULE_SCOPE int	TclAttemptCompileProc(Tcl_Interp *interp,
-			    Tcl_Parse *parsePtr, size_t depth, Command *cmdPtr,
+			    Tcl_Parse *parsePtr, Tcl_Size depth, Command *cmdPtr,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclCleanupStackForBreakContinue(CompileEnv *envPtr,
 			    ExceptionAux *auxPtr);
@@ -1092,7 +1092,7 @@ MODULE_SCOPE void	TclCompileCmdWord(Tcl_Interp *interp,
 			    Tcl_Token *tokenPtr, size_t count,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclCompileExpr(Tcl_Interp *interp, const char *script,
-			    size_t numBytes, CompileEnv *envPtr, int optimize);
+			    Tcl_Size numBytes, CompileEnv *envPtr, int optimize);
 MODULE_SCOPE void	TclCompileExprWords(Tcl_Interp *interp,
 			    Tcl_Token *tokenPtr, size_t numWords,
 			    CompileEnv *envPtr);
@@ -1109,13 +1109,13 @@ MODULE_SCOPE void	TclCompileTokens(Tcl_Interp *interp,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclCompileVarSubst(Tcl_Interp *interp,
 			    Tcl_Token *tokenPtr, CompileEnv *envPtr);
-MODULE_SCOPE size_t	TclCreateAuxData(void *clientData,
+MODULE_SCOPE Tcl_Size	TclCreateAuxData(void *clientData,
 			    const AuxDataType *typePtr, CompileEnv *envPtr);
-MODULE_SCOPE size_t	TclCreateExceptRange(ExceptionRangeType type,
+MODULE_SCOPE Tcl_Size	TclCreateExceptRange(ExceptionRangeType type,
 			    CompileEnv *envPtr);
 MODULE_SCOPE ExecEnv *	TclCreateExecEnv(Tcl_Interp *interp, size_t size);
 MODULE_SCOPE Tcl_Obj *	TclCreateLiteral(Interp *iPtr, const char *bytes,
-			    size_t length, TCL_HASH_TYPE hash, int *newPtr,
+			    size_t length, size_t hash, int *newPtr,
 			    Namespace *nsPtr, int flags,
 			    LiteralEntry **globalPtrPtr);
 MODULE_SCOPE void	TclDeleteExecEnv(ExecEnv *eePtr);
@@ -1129,8 +1129,8 @@ MODULE_SCOPE ExceptionRange * TclGetExceptionRangeForPc(unsigned char *pc,
 MODULE_SCOPE void	TclExpandJumpFixupArray(JumpFixupArray *fixupArrayPtr);
 MODULE_SCOPE int	TclNRExecuteByteCode(Tcl_Interp *interp,
 			    ByteCode *codePtr);
-MODULE_SCOPE Tcl_Obj *	TclFetchLiteral(CompileEnv *envPtr, TCL_HASH_TYPE index);
-MODULE_SCOPE size_t	TclFindCompiledLocal(const char *name, size_t nameChars,
+MODULE_SCOPE Tcl_Obj *	TclFetchLiteral(CompileEnv *envPtr, Tcl_Size index);
+MODULE_SCOPE Tcl_Size	TclFindCompiledLocal(const char *name, Tcl_Size nameChars,
 			    int create, CompileEnv *envPtr);
 MODULE_SCOPE int	TclFixupForwardJump(CompileEnv *envPtr,
 			    JumpFixup *jumpFixupPtr, int jumpDist,
@@ -1171,9 +1171,9 @@ MODULE_SCOPE void	TclPrintByteCodeObj(Tcl_Interp *interp,
 MODULE_SCOPE int	TclPrintInstruction(ByteCode *codePtr,
 			    const unsigned char *pc);
 MODULE_SCOPE void	TclPrintObject(FILE *outFile,
-			    Tcl_Obj *objPtr, size_t maxChars);
+			    Tcl_Obj *objPtr, Tcl_Size maxChars);
 MODULE_SCOPE void	TclPrintSource(FILE *outFile,
-			    const char *string, size_t maxChars);
+			    const char *string, Tcl_Size maxChars);
 MODULE_SCOPE void	TclPushVarName(Tcl_Interp *interp,
 			    Tcl_Token *varTokenPtr, CompileEnv *envPtr,
 			    int flags, int *localIndexPtr,
@@ -1195,13 +1195,13 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime(Tcl_Token *tokenPtr,
 			    Tcl_Obj *valuePtr);
 MODULE_SCOPE void	TclLogCommandInfo(Tcl_Interp *interp,
 			    const char *script, const char *command,
-			    size_t length, const unsigned char *pc,
+			    Tcl_Size length, const unsigned char *pc,
 			    Tcl_Obj **tosPtr);
 MODULE_SCOPE Tcl_Obj	*TclGetInnerContext(Tcl_Interp *interp,
 			    const unsigned char *pc, Tcl_Obj **tosPtr);
 MODULE_SCOPE Tcl_Obj	*TclNewInstNameObj(unsigned char inst);
 MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
-			    Tcl_Interp *interp, size_t objc,
+			    Tcl_Interp *interp, Tcl_Size objc,
 			    Tcl_Obj *const objv[], int isLambda);
 #endif /* TCL_MAJOR_VERSION > 8 */
 
diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index 2a96383..e9b0cce 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -2570,8 +2570,7 @@ UtfToUtfProc(
 		}
 	    } else {
 		/*
-		 * Convert 0xC080 to real nulls when we are in output mode,
-		 * irrespective of the profile.
+		 * For output convert 0xC080 to a real null.
 		 */
 		*dst++ = 0;
 		src += 2;
@@ -2822,6 +2821,11 @@ Utf32ToUtfProc(
 	if ((unsigned)ch - 1 < 0x7F) {
 	    *dst++ = (ch & 0xFF);
 	} else {
+#if TCL_UTF_MAX < 4
+	    if (!HIGH_SURROGATE(prev) && LOW_SURROGATE(ch)) {
+		*dst = 0; /* In case of lower surrogate, don't try to combine */
+	    }
+#endif
 	    dst += Tcl_UniCharToUtf(ch, dst);
 	}
 	src += 4;
diff --git a/generic/tclIO.c b/generic/tclIO.c
index 287a2f2..a45f39a 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -174,6 +174,8 @@ static int		CloseWrite(Tcl_Interp *interp, Channel *chanPtr);
 static void		CommonGetsCleanup(Channel *chanPtr);
 static int		CopyData(CopyState *csPtr, int mask);
 static void		DeleteTimerHandler(ChannelState *statePtr);
+int				Lossless(ChannelState *inStatePtr,
+			    ChannelState *outStatePtr, long long toRead);
 static int		MoveBytes(CopyState *csPtr);
 
 static void		MBCallback(CopyState *csPtr, Tcl_Obj *errObj);
@@ -196,7 +198,7 @@ static void		DiscardOutputQueued(ChannelState *chanPtr);
 static Tcl_Size		DoRead(Channel *chanPtr, char *dst, Tcl_Size bytesToRead,
 			    int allowShortReads);
 static Tcl_Size		DoReadChars(Channel *chan, Tcl_Obj *objPtr, Tcl_Size toRead,
-			    int appendFlag);
+			    int allowShortReads, int appendFlag);
 static int		FilterInputBytes(Channel *chanPtr,
 			    GetsState *statePtr);
 static int		FlushChannel(Tcl_Interp *interp, Channel *chanPtr,
@@ -338,6 +340,9 @@ static const Tcl_ObjType chanObjType = {
     TCL_OBJTYPE_V0
 };
 
+#define GetIso88591() \
+    (binaryEncoding ? Tcl_GetEncoding(NULL, "iso8859-1") : binaryEncoding)
+
 #define ChanSetInternalRep(objPtr, resPtr)					\
     do {								\
 	Tcl_ObjInternalRep ir;						\
@@ -5899,7 +5904,7 @@ Tcl_ReadChars(
 	return TCL_INDEX_NONE;
     }
 
-    return DoReadChars(chanPtr, objPtr, toRead, appendFlag);
+    return DoReadChars(chanPtr, objPtr, toRead, 0, appendFlag);
 }
 /*
  *---------------------------------------------------------------------------
@@ -5930,6 +5935,7 @@ DoReadChars(
     Tcl_Size toRead,		/* Maximum number of characters to store, or
 				 * TCL_INDEX_NONE to read all available data (up to EOF or
 				 * when channel blocks). */
+    int allowShortReads,	/* Allow half-blocking (pipes,sockets) */
     int appendFlag)		/* If non-zero, data read from the channel
 				 * will be appended to the object. Otherwise,
 				 * the data will replace the existing contents
@@ -6070,8 +6076,8 @@ DoReadChars(
 	    if (GotFlag(statePtr, CHANNEL_EOF)) {
 		break;
 	    }
-	    if (GotFlag(statePtr, CHANNEL_NONBLOCKING|CHANNEL_BLOCKED)
-		    == (CHANNEL_NONBLOCKING|CHANNEL_BLOCKED)) {
+	    if ((GotFlag(statePtr, CHANNEL_NONBLOCKING) || allowShortReads)
+		    && GotFlag(statePtr, CHANNEL_BLOCKED)) {
 		break;
 	    }
 	    result = GetInput(chanPtr);
@@ -9363,18 +9369,7 @@ TclCopyChannel(
     ResetFlag(outStatePtr, CHANNEL_LINEBUFFERED);
     SetFlag(outStatePtr, CHANNEL_UNBUFFERED);
 
-    /*
-     * Test for conditions where we know we can just move bytes from input
-     * channel to output channel with no transformation or even examination
-     * of the bytes themselves.
-     */
-
-    moveBytes = inStatePtr->inEofChar == '\0'	/* No eofChar to stop input */
-	    && inStatePtr->inputTranslation == TCL_TRANSLATE_LF
-	    && outStatePtr->outputTranslation == TCL_TRANSLATE_LF
-	    && inStatePtr->encoding == outStatePtr->encoding
-	    && CHANNEL_PROFILE_GET(inStatePtr->inputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8
-	    && CHANNEL_PROFILE_GET(outStatePtr->outputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8;
+    moveBytes = Lossless(inStatePtr, outStatePtr, toRead);
 
     /*
      * Allocate a new CopyState to maintain info about the current copy in
@@ -9681,8 +9676,7 @@ CopyData(
     Tcl_WideInt total;
     Tcl_WideInt size; /* TODO - be careful if total and size are made unsigned  */
     const char *buffer;
-    int inBinary, outBinary, sameEncoding;
-				/* Encoding control */
+    int moveBytes;
     int underflow;		/* Input underflow */
 
     inChan	= (Tcl_Channel) csPtr->readPtr;
@@ -9700,13 +9694,9 @@ CopyData(
      * the bottom of the stack.
      */
 
-    inBinary = (inStatePtr->encoding == NULL);
-    outBinary = (outStatePtr->encoding == NULL);
-    sameEncoding = inStatePtr->encoding == outStatePtr->encoding
-	    && CHANNEL_PROFILE_GET(inStatePtr->inputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8
-	    && CHANNEL_PROFILE_GET(outStatePtr->outputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8;
+    moveBytes = Lossless(inStatePtr, outStatePtr, csPtr->toRead);
 
-    if (!(inBinary || sameEncoding)) {
+    if (!moveBytes) {
 	TclNewObj(bufObj);
 	Tcl_IncrRefCount(bufObj);
     }
@@ -9747,7 +9737,7 @@ CopyData(
 	    underflow = 1;
 	} else {
 	    /*
-	     * Read up to bufSize bytes.
+	     * Read up to bufSize characters.
 	     */
 
 	    if ((csPtr->toRead == (Tcl_WideInt) -1)
@@ -9757,12 +9747,13 @@ CopyData(
 		sizeb = csPtr->toRead;
 	    }
 
-	    if (inBinary || sameEncoding) {
+	    if (moveBytes) {
 		size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb,
                               !GotFlag(inStatePtr, CHANNEL_NONBLOCKING));
 	    } else {
 		size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb,
-			0 /* No append */);
+			!GotFlag(inStatePtr, CHANNEL_NONBLOCKING)
+			,0 /* No append */);
 	    }
 	    underflow = (size >= 0) && ((size_t)size < sizeb);	/* Input underflow */
 	}
@@ -9823,25 +9814,20 @@ CopyData(
 	 * Now write the buffer out.
 	 */
 
-	if (inBinary || sameEncoding) {
+	if (moveBytes) {
 	    buffer = csPtr->buffer;
-	    sizeb = size;
+	    sizeb = WriteBytes(outStatePtr->topChanPtr, buffer, size);
 	} else {
 	    buffer = Tcl_GetStringFromObj(bufObj, &sizeb);
-	}
-
-	if (outBinary || sameEncoding) {
-	    sizeb = WriteBytes(outStatePtr->topChanPtr, buffer, sizeb);
-	} else {
 	    sizeb = WriteChars(outStatePtr->topChanPtr, buffer, sizeb);
 	}
 
 	/*
 	 * [Bug 2895565]. At this point 'size' still contains the number of
-	 * bytes or characters which have been read. We keep this to later to
+	 * characters which have been read. We keep this to later to
 	 * update the totals and toRead information, see marker (UP) below. We
 	 * must not overwrite it with 'sizeb', which is the number of written
-	 * bytes or characters, and both EOL translation and encoding
+	 * characters, and both EOL translation and encoding
 	 * conversion may have changed this number unpredictably in relation
 	 * to 'size' (It can be smaller or larger, in the latter case able to
 	 * drive toRead below -1, causing infinite looping). Completely
@@ -9868,10 +9854,10 @@ CopyData(
 	}
 
 	/*
-	 * Update the current byte count. Do it now so the count is valid
+	 * Update the current character count. Do it now so the count is valid
 	 * before a return or break takes us out of the loop. The invariant at
 	 * the top of the loop should be that csPtr->toRead holds the number
-	 * of bytes left to copy.
+	 * of characters left to copy.
 	 */
 
 	if (csPtr->toRead != -1) {
@@ -9938,8 +9924,8 @@ CopyData(
     }
 
     /*
-     * Make the callback or return the number of bytes transferred. The local
-     * total is used because StopCopy frees csPtr.
+     * Make the callback or return the number of characters transferred. The
+     * local total is used because StopCopy frees csPtr.
      */
 
     total = csPtr->total;
@@ -10262,6 +10248,50 @@ CopyEventProc(
 /*
  *----------------------------------------------------------------------
  *
+ * Lossless --
+ *
+ *	Determines whether copying characters between two channel states would
+ *	be lossless, i.e. whether one byte corresponds to one character, every
+ *	character appears in the Unicode character set, there are no
+ *	translations to be performed, and no inline signals to respond to.
+ *
+ * Result:
+ *	True if copying would be lossless.
+ *
+ *----------------------------------------------------------------------
+ */
+int
+Lossless(
+    ChannelState *inStatePtr,
+    ChannelState *outStatePtr,
+    long long toRead)
+{
+    return inStatePtr->inEofChar == '\0'	/* No eofChar to stop input */
+	&& inStatePtr->inputTranslation == TCL_TRANSLATE_LF
+	&& outStatePtr->outputTranslation == TCL_TRANSLATE_LF
+	&& (
+	    (
+		(inStatePtr->encoding == NULL
+		    || inStatePtr->encoding == GetBinaryEncoding()
+		)
+		&&
+		(outStatePtr->encoding == NULL
+		    || outStatePtr->encoding == GetBinaryEncoding()
+		)
+	    )
+	    ||
+	    (
+		toRead == -1
+		&& inStatePtr->encoding == outStatePtr->encoding
+		&& CHANNEL_PROFILE_GET(inStatePtr->inputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8
+		&& CHANNEL_PROFILE_GET(outStatePtr->inputEncodingFlags) == TCL_ENCODING_PROFILE_TCL8
+	    )
+	);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * StopCopy --
  *
  *	This routine halts a copy that is in progress.
diff --git a/generic/tclIndexObj.c b/generic/tclIndexObj.c
index 66d7f30..c699af7 100644
--- a/generic/tclIndexObj.c
+++ b/generic/tclIndexObj.c
@@ -55,8 +55,8 @@ static const Tcl_ObjType indexType = {
 
 typedef struct {
     void *tablePtr;		/* Pointer to the table of strings */
-    size_t offset;			/* Offset between table entries */
-    size_t index;			/* Selected index into table. */
+    Tcl_Size offset;	/* Offset between table entries */
+    Tcl_Size index;		/* Selected index into table. */
 } IndexRep;
 
 /*
@@ -107,7 +107,7 @@ GetIndexFromObjList(
     int *indexPtr)		/* Place to store resulting integer index. */
 {
 
-    size_t objc, t;
+    Tcl_Size objc, t;
     int result;
     Tcl_Obj **objv;
     const char **tablePtr;
@@ -193,7 +193,7 @@ Tcl_GetIndexFromObjStruct(
     int flags,			/* 0, TCL_EXACT, TCL_NULL_OK or TCL_INDEX_TEMP_TABLE */
     void *indexPtr)		/* Place to store resulting index. */
 {
-    size_t index, idx, numAbbrev;
+    Tcl_Size index, idx, numAbbrev;
     const char *key, *p1;
     const char *p2;
     const char *const *entryPtr;
@@ -505,7 +505,7 @@ PrefixMatchObjCmd(
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     int flags = 0, result, dummy, i;
-    size_t dummyLength, errorLength;
+    Tcl_Size dummyLength, errorLength;
     Tcl_Obj *errorPtr = NULL;
     const char *message = "option";
     Tcl_Obj *tablePtr, *objPtr, *resultPtr;
@@ -629,7 +629,7 @@ PrefixAllObjCmd(
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     int result;
-    size_t length, elemLength, tableObjc, t;
+    Tcl_Size length, elemLength, tableObjc, t;
     const char *string, *elemString;
     Tcl_Obj **tableObjv, *resultPtr;
 
@@ -687,7 +687,7 @@ PrefixLongestObjCmd(
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     int result;
-    size_t i, length, elemLength, resultLength, tableObjc, t;
+    Tcl_Size i, length, elemLength, resultLength, tableObjc, t;
     const char *string, *elemString, *resultString;
     Tcl_Obj **tableObjv;
 
@@ -802,7 +802,7 @@ PrefixLongestObjCmd(
 void
 Tcl_WrongNumArgs(
     Tcl_Interp *interp,		/* Current interpreter. */
-    size_t objc,			/* Number of arguments to print from objv. */
+    Tcl_Size objc,			/* Number of arguments to print from objv. */
     Tcl_Obj *const objv[],	/* Initial argument objects, which should be
 				 * included in the error message. */
     const char *message)	/* Error message to print after the leading
@@ -810,7 +810,7 @@ Tcl_WrongNumArgs(
 				 * NULL. */
 {
     Tcl_Obj *objPtr;
-    size_t i, len, elemLen;
+    Tcl_Size i, len, elemLen;
     char flags;
     Interp *iPtr = (Interp *)interp;
     const char *elementStr;
@@ -830,8 +830,8 @@ Tcl_WrongNumArgs(
      */
 
     if (iPtr->ensembleRewrite.sourceObjs != NULL) {
-	size_t toSkip = iPtr->ensembleRewrite.numInsertedObjs;
-	size_t toPrint = iPtr->ensembleRewrite.numRemovedObjs;
+	Tcl_Size toSkip = iPtr->ensembleRewrite.numInsertedObjs;
+	Tcl_Size toPrint = iPtr->ensembleRewrite.numRemovedObjs;
 	Tcl_Obj *const *origObjv = TclEnsembleGetRewriteValues(interp);
 
 	/*
@@ -889,7 +889,7 @@ Tcl_WrongNumArgs(
 	     * moderately complex condition here).
 	     */
 
-	    if (i+1<toPrint || objc!=0 || message!=NULL) {
+	    if (i + 1 < toPrint || objc!=0 || message!=NULL) {
 		Tcl_AppendStringsToObj(objPtr, " ", NULL);
 	    }
 	}
@@ -997,7 +997,7 @@ Tcl_ParseArgsObjv(
     Tcl_Obj **leftovers;	/* Array to write back to remObjv on
 				 * successful exit. Will include the name of
 				 * the command. */
-    size_t nrem;			/* Size of leftovers.*/
+    Tcl_Size nrem;		/* Size of leftovers.*/
     const Tcl_ArgvInfo *infoPtr;
 				/* Pointer to the current entry in the table
 				 * of argument descriptions. */
@@ -1009,13 +1009,13 @@ Tcl_ParseArgsObjv(
 				 * quick check for matching; use 2nd char.
 				 * because first char. will almost always be
 				 * '-'). */
-    size_t srcIndex;		/* Location from which to read next argument
+    Tcl_Size srcIndex;	/* Location from which to read next argument
 				 * from objv. */
-    size_t dstIndex;		/* Used to keep track of current arguments
+    Tcl_Size dstIndex;	/* Used to keep track of current arguments
 				 * being processed, primarily for error
 				 * reporting. */
-    size_t objc;			/* # arguments in objv still to process. */
-    size_t length;			/* Number of characters in current argument */
+    Tcl_Size objc;		/* # arguments in objv still to process. */
+    Tcl_Size length;		/* Number of characters in current argument */
 
     if (remObjv != NULL) {
 	/*
@@ -1274,13 +1274,13 @@ PrintUsage(
 
     width = 4;
     for (infoPtr = argTable; infoPtr->type != TCL_ARGV_END; infoPtr++) {
-	size_t length;
+	Tcl_Size length;
 
 	if (infoPtr->keyStr == NULL) {
 	    continue;
 	}
 	length = strlen(infoPtr->keyStr);
-	if (length > (size_t)width) {
+	if (length > (Tcl_Size)width) {
 	    width = length;
 	}
     }
diff --git a/generic/tclInt.h b/generic/tclInt.h
index fd6d4177..5e1d763 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -3054,12 +3054,12 @@ struct Tcl_LoadHandle_ {
 
 #if TCL_MAJOR_VERSION > 8
 MODULE_SCOPE void	TclAppendBytesToByteArray(Tcl_Obj *objPtr,
-			    const unsigned char *bytes, size_t len);
+			    const unsigned char *bytes, Tcl_Size len);
 MODULE_SCOPE int	TclNREvalCmd(Tcl_Interp *interp, Tcl_Obj *objPtr,
 			    int flags);
-MODULE_SCOPE void	TclAdvanceContinuations(size_t *line, int **next,
+MODULE_SCOPE void	TclAdvanceContinuations(Tcl_Size *line, int **next,
 			    int loc);
-MODULE_SCOPE void	TclAdvanceLines(size_t *line, const char *start,
+MODULE_SCOPE void	TclAdvanceLines(Tcl_Size *line, const char *start,
 			    const char *end);
 MODULE_SCOPE void	TclArgumentEnter(Tcl_Interp *interp,
 			    Tcl_Obj *objv[], int objc, CmdFrame *cf);
@@ -3067,7 +3067,7 @@ MODULE_SCOPE void	TclArgumentRelease(Tcl_Interp *interp,
 			    Tcl_Obj *objv[], int objc);
 MODULE_SCOPE void	TclArgumentBCEnter(Tcl_Interp *interp,
 			    Tcl_Obj *objv[], int objc,
-			    void *codePtr, CmdFrame *cfPtr, int cmd, size_t pc);
+			    void *codePtr, CmdFrame *cfPtr, int cmd, Tcl_Size pc);
 MODULE_SCOPE void	TclArgumentBCRelease(Tcl_Interp *interp,
 			    CmdFrame *cfPtr);
 MODULE_SCOPE void	TclArgumentGet(Tcl_Interp *interp, Tcl_Obj *obj,
@@ -3077,8 +3077,8 @@ MODULE_SCOPE int	TclAsyncNotifier(int sigNumber, Tcl_ThreadId threadId,
 MODULE_SCOPE void	TclAsyncMarkFromNotifier(void);
 MODULE_SCOPE double	TclBignumToDouble(const void *bignum);
 MODULE_SCOPE int	TclByteArrayMatch(const unsigned char *string,
-			    size_t strLen, const unsigned char *pattern,
-			    size_t ptnLen, int flags);
+			    Tcl_Size strLen, const unsigned char *pattern,
+			    Tcl_Size ptnLen, int flags);
 MODULE_SCOPE double	TclCeil(const void *a);
 MODULE_SCOPE void	TclChannelPreserve(Tcl_Channel chan);
 MODULE_SCOPE void	TclChannelRelease(Tcl_Channel chan);
@@ -3091,14 +3091,14 @@ MODULE_SCOPE Tcl_ObjCmdProc TclChannelNamesCmd;
 MODULE_SCOPE Tcl_NRPostProc TclClearRootEnsemble;
 MODULE_SCOPE int	TclCompareTwoNumbers(Tcl_Obj *valuePtr,
 			    Tcl_Obj *value2Ptr);
-MODULE_SCOPE ContLineLoc *TclContinuationsEnter(Tcl_Obj *objPtr, size_t num,
+MODULE_SCOPE ContLineLoc *TclContinuationsEnter(Tcl_Obj *objPtr, Tcl_Size num,
 			    int *loc);
 MODULE_SCOPE void	TclContinuationsEnterDerived(Tcl_Obj *objPtr,
 			    int start, int *clNext);
 MODULE_SCOPE ContLineLoc *TclContinuationsGet(Tcl_Obj *objPtr);
 MODULE_SCOPE void	TclContinuationsCopy(Tcl_Obj *objPtr,
 			    Tcl_Obj *originObjPtr);
-MODULE_SCOPE size_t	TclConvertElement(const char *src, size_t length,
+MODULE_SCOPE Tcl_Size	TclConvertElement(const char *src, Tcl_Size length,
 			    char *dst, int flags);
 MODULE_SCOPE Tcl_Command TclCreateObjCommandInNs(Tcl_Interp *interp,
 			    const char *cmdName, Tcl_Namespace *nsPtr,
@@ -3110,12 +3110,12 @@ MODULE_SCOPE Tcl_Command TclCreateEnsembleInNs(Tcl_Interp *interp,
 MODULE_SCOPE void	TclDeleteNamespaceVars(Namespace *nsPtr);
 MODULE_SCOPE void	TclDeleteNamespaceChildren(Namespace *nsPtr);
 MODULE_SCOPE int	TclFindDictElement(Tcl_Interp *interp,
-			    const char *dict, size_t dictLength,
+			    const char *dict, Tcl_Size dictLength,
 			    const char **elementPtr, const char **nextPtr,
-			    size_t *sizePtr, int *literalPtr);
+			    Tcl_Size *sizePtr, int *literalPtr);
 /* TIP #280 - Modified token based evaluation, with line information. */
 MODULE_SCOPE int	TclEvalEx(Tcl_Interp *interp, const char *script,
-			    size_t numBytes, int flags, size_t line,
+			    Tcl_Size numBytes, int flags, Tcl_Size line,
 			    int *clNextOuter, const char *outerScript);
 MODULE_SCOPE Tcl_ObjCmdProc TclFileAttrsCmd;
 MODULE_SCOPE Tcl_ObjCmdProc TclFileCopyCmd;
@@ -3137,7 +3137,7 @@ MODULE_SCOPE char *	TclDStringAppendObj(Tcl_DString *dsPtr,
 MODULE_SCOPE char *	TclDStringAppendDString(Tcl_DString *dsPtr,
 			    Tcl_DString *toAppendPtr);
 MODULE_SCOPE Tcl_Obj *const *TclFetchEnsembleRoot(Tcl_Interp *interp,
-			    Tcl_Obj *const *objv, size_t objc, size_t *objcPtr);
+			    Tcl_Obj *const *objv, Tcl_Size objc, Tcl_Size *objcPtr);
 MODULE_SCOPE Tcl_Obj *const *TclEnsembleGetRewriteValues(Tcl_Interp *interp);
 MODULE_SCOPE Tcl_Namespace *TclEnsureNamespace(Tcl_Interp *interp,
 			    Tcl_Namespace *namespacePtr);
@@ -3191,7 +3191,7 @@ MODULE_SCOPE Tcl_Obj *	TclGetProcessGlobalValue(ProcessGlobalValue *pgvPtr);
 MODULE_SCOPE Tcl_Obj *	TclGetSourceFromFrame(CmdFrame *cfPtr, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE char *	TclGetStringStorage(Tcl_Obj *objPtr,
-			    TCL_HASH_TYPE *sizePtr);
+			    Tcl_Size *sizePtr);
 MODULE_SCOPE int	TclGetLoadedLibraries(Tcl_Interp *interp,
 				const char *targetName,
 				const char *packageName);
@@ -3221,7 +3221,7 @@ MODULE_SCOPE void	TclInitObjSubsystem(void);
 MODULE_SCOPE int	TclInterpReady(Tcl_Interp *interp);
 MODULE_SCOPE int	TclIsDigitProc(int byte);
 MODULE_SCOPE int	TclIsBareword(int byte);
-MODULE_SCOPE Tcl_Obj *	TclJoinPath(size_t elements, Tcl_Obj * const objv[],
+MODULE_SCOPE Tcl_Obj *	TclJoinPath(Tcl_Size elements, Tcl_Obj * const objv[],
 			    int forceRelative);
 MODULE_SCOPE int	MakeTildeRelativePath(Tcl_Interp *interp, const char *user,
 			    const char *subPath, Tcl_DString *dsPtr);
@@ -3234,25 +3234,25 @@ MODULE_SCOPE void	TclLimitRemoveAllHandlers(Tcl_Interp *interp);
 MODULE_SCOPE Tcl_Obj *	TclLindexList(Tcl_Interp *interp,
 			    Tcl_Obj *listPtr, Tcl_Obj *argPtr);
 MODULE_SCOPE Tcl_Obj *	TclLindexFlat(Tcl_Interp *interp, Tcl_Obj *listPtr,
-			    size_t indexCount, Tcl_Obj *const indexArray[]);
+			    Tcl_Size indexCount, Tcl_Obj *const indexArray[]);
 /* TIP #280 */
-MODULE_SCOPE void	TclListLines(Tcl_Obj *listObj, size_t line, int n,
+MODULE_SCOPE void	TclListLines(Tcl_Obj *listObj, Tcl_Size line, int n,
 			    int *lines, Tcl_Obj *const *elems);
 MODULE_SCOPE Tcl_Obj *	TclListObjCopy(Tcl_Interp *interp, Tcl_Obj *listPtr);
 MODULE_SCOPE int	TclListObjAppendElements(Tcl_Interp *interp,
-			    Tcl_Obj *toObj, size_t elemCount,
+			    Tcl_Obj *toObj, Tcl_Size elemCount,
 			    Tcl_Obj *const elemObjv[]);
-MODULE_SCOPE Tcl_Obj *	TclListObjRange(Tcl_Obj *listPtr, size_t fromIdx,
-			    size_t toIdx);
+MODULE_SCOPE Tcl_Obj *	TclListObjRange(Tcl_Obj *listPtr, Tcl_Size fromIdx,
+			    Tcl_Size toIdx);
 MODULE_SCOPE Tcl_Obj *	TclLsetList(Tcl_Interp *interp, Tcl_Obj *listPtr,
 			    Tcl_Obj *indexPtr, Tcl_Obj *valuePtr);
 MODULE_SCOPE Tcl_Obj *	TclLsetFlat(Tcl_Interp *interp, Tcl_Obj *listPtr,
-			    size_t indexCount, Tcl_Obj *const indexArray[],
+			    Tcl_Size indexCount, Tcl_Obj *const indexArray[],
 			    Tcl_Obj *valuePtr);
 MODULE_SCOPE Tcl_Command TclMakeEnsemble(Tcl_Interp *interp, const char *name,
 			    const EnsembleImplMap map[]);
 MODULE_SCOPE int TclMakeSafe(Tcl_Interp *interp);
-MODULE_SCOPE int	TclMaxListLength(const char *bytes, size_t numBytes,
+MODULE_SCOPE Tcl_Size TclMaxListLength(const char *bytes, Tcl_Size numBytes,
 			    const char **endPtr);
 MODULE_SCOPE int	TclMergeReturnOptions(Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[], Tcl_Obj **optionsPtrPtr,
@@ -3270,15 +3270,15 @@ MODULE_SCOPE int	TclObjInvokeNamespace(Tcl_Interp *interp,
 MODULE_SCOPE int	TclObjUnsetVar2(Tcl_Interp *interp,
 			    Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, int flags);
 MODULE_SCOPE int	TclParseBackslash(const char *src,
-			    size_t numBytes, size_t *readPtr, char *dst);
-MODULE_SCOPE int	TclParseHex(const char *src, size_t numBytes,
+			    Tcl_Size numBytes, Tcl_Size *readPtr, char *dst);
+MODULE_SCOPE int	TclParseHex(const char *src, Tcl_Size numBytes,
 			    int *resultPtr);
 MODULE_SCOPE int	TclParseNumber(Tcl_Interp *interp, Tcl_Obj *objPtr,
 			    const char *expected, const char *bytes,
-			    size_t numBytes, const char **endPtrPtr, int flags);
+			    Tcl_Size numBytes, const char **endPtrPtr, int flags);
 MODULE_SCOPE void	TclParseInit(Tcl_Interp *interp, const char *string,
-			    size_t numBytes, Tcl_Parse *parsePtr);
-MODULE_SCOPE size_t	TclParseAllWhiteSpace(const char *src, size_t numBytes);
+			    Tcl_Size numBytes, Tcl_Parse *parsePtr);
+MODULE_SCOPE Tcl_Size	TclParseAllWhiteSpace(const char *src, Tcl_Size numBytes);
 MODULE_SCOPE int	TclProcessReturn(Tcl_Interp *interp,
 			    int code, int level, Tcl_Obj *returnOpts);
 MODULE_SCOPE int	TclpObjLstat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf);
@@ -3286,7 +3286,7 @@ MODULE_SCOPE Tcl_Obj *	TclpTempFileName(void);
 MODULE_SCOPE Tcl_Obj *  TclpTempFileNameForLibrary(Tcl_Interp *interp,
 			    Tcl_Obj* pathPtr);
 MODULE_SCOPE Tcl_Obj *	TclNewFSPathObj(Tcl_Obj *dirPtr, const char *addStrRep,
-			    size_t len);
+			    Tcl_Size len);
 MODULE_SCOPE void	TclpAlertNotifier(void *clientData);
 MODULE_SCOPE void *TclpNotifierData(void);
 MODULE_SCOPE void	TclpServiceModeHook(int mode);
@@ -3312,10 +3312,10 @@ MODULE_SCOPE int	TclCreateSocketAddress(Tcl_Interp *interp,
 			    const char **errorMsgPtr);
 MODULE_SCOPE int	TclpThreadCreate(Tcl_ThreadId *idPtr,
 			    Tcl_ThreadCreateProc *proc, void *clientData,
-			    size_t stackSize, int flags);
-MODULE_SCOPE size_t	TclpFindVariable(const char *name, size_t *lengthPtr);
+			    Tcl_Size stackSize, int flags);
+MODULE_SCOPE Tcl_Size TclpFindVariable(const char *name, Tcl_Size *lengthPtr);
 MODULE_SCOPE void	TclpInitLibraryPath(char **valuePtr,
-			    TCL_HASH_TYPE *lengthPtr, Tcl_Encoding *encodingPtr);
+			    Tcl_Size *lengthPtr, Tcl_Encoding *encodingPtr);
 MODULE_SCOPE void	TclpInitLock(void);
 MODULE_SCOPE void *TclpInitNotifier(void);
 MODULE_SCOPE void	TclpInitPlatform(void);
@@ -3328,9 +3328,9 @@ MODULE_SCOPE int	TclpMatchFiles(Tcl_Interp *interp, char *separators,
 MODULE_SCOPE int	TclpObjNormalizePath(Tcl_Interp *interp,
 			    Tcl_Obj *pathPtr, int nextCheckpoint);
 MODULE_SCOPE void	TclpNativeJoinPath(Tcl_Obj *prefix, const char *joining);
-MODULE_SCOPE Tcl_Obj *	TclpNativeSplitPath(Tcl_Obj *pathPtr, size_t *lenPtr);
+MODULE_SCOPE Tcl_Obj *	TclpNativeSplitPath(Tcl_Obj *pathPtr, Tcl_Size *lenPtr);
 MODULE_SCOPE Tcl_PathType TclpGetNativePathType(Tcl_Obj *pathPtr,
-			    size_t *driveNameLengthPtr, Tcl_Obj **driveNameRef);
+			    Tcl_Size *driveNameLengthPtr, Tcl_Obj **driveNameRef);
 MODULE_SCOPE int	TclCrossFilesystemCopy(Tcl_Interp *interp,
 			    Tcl_Obj *source, Tcl_Obj *target);
 MODULE_SCOPE int	TclpMatchInDirectory(Tcl_Interp *interp,
@@ -3361,9 +3361,9 @@ MODULE_SCOPE void	TclRememberJoinableThread(Tcl_ThreadId id);
 MODULE_SCOPE void	TclRememberMutex(Tcl_Mutex *mutex);
 MODULE_SCOPE void	TclRemoveScriptLimitCallbacks(Tcl_Interp *interp);
 MODULE_SCOPE int	TclReToGlob(Tcl_Interp *interp, const char *reStr,
-			    size_t reStrLen, Tcl_DString *dsPtr, int *flagsPtr,
+			    Tcl_Size reStrLen, Tcl_DString *dsPtr, int *flagsPtr,
 			    int *quantifiersFoundPtr);
-MODULE_SCOPE TCL_HASH_TYPE TclScanElement(const char *string, size_t length,
+MODULE_SCOPE Tcl_Size TclScanElement(const char *string, Tcl_Size length,
 			    char *flagPtr);
 MODULE_SCOPE void	TclSetBgErrorHandler(Tcl_Interp *interp,
 			    Tcl_Obj *cmdPrefix);
@@ -3378,44 +3378,44 @@ MODULE_SCOPE void	TclSetProcessGlobalValue(ProcessGlobalValue *pgvPtr,
 			    Tcl_Obj *newValue, Tcl_Encoding encoding);
 MODULE_SCOPE void	TclSignalExitThread(Tcl_ThreadId id, int result);
 MODULE_SCOPE void	TclSpellFix(Tcl_Interp *interp,
-			    Tcl_Obj *const *objv, size_t objc, size_t subIdx,
+			    Tcl_Obj *const *objv, Tcl_Size objc, Tcl_Size subIdx,
 			    Tcl_Obj *bad, Tcl_Obj *fix);
 MODULE_SCOPE void *	TclStackRealloc(Tcl_Interp *interp, void *ptr,
-			    size_t numBytes);
+			    Tcl_Size numBytes);
 typedef int (*memCmpFn_t)(const void*, const void*, size_t);
 MODULE_SCOPE int	TclStringCmp(Tcl_Obj *value1Ptr, Tcl_Obj *value2Ptr,
-			    int checkEq, int nocase, size_t reqlength);
+			    int checkEq, int nocase, Tcl_Size reqlength);
 MODULE_SCOPE int	TclStringCmpOpts(Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[], int *nocase,
 			    int *reqlength);
-MODULE_SCOPE int	TclStringMatch(const char *str, size_t strLen,
+MODULE_SCOPE int	TclStringMatch(const char *str, Tcl_Size strLen,
 			    const char *pattern, int ptnLen, int flags);
 MODULE_SCOPE int	TclStringMatchObj(Tcl_Obj *stringObj,
 			    Tcl_Obj *patternObj, int flags);
 MODULE_SCOPE void	TclSubstCompile(Tcl_Interp *interp, const char *bytes,
-			    size_t numBytes, int flags, size_t line,
+			    Tcl_Size numBytes, int flags, Tcl_Size line,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclSubstOptions(Tcl_Interp *interp, size_t numOpts,
+MODULE_SCOPE int	TclSubstOptions(Tcl_Interp *interp, Tcl_Size numOpts,
 			    Tcl_Obj *const opts[], int *flagPtr);
 MODULE_SCOPE void	TclSubstParse(Tcl_Interp *interp, const char *bytes,
-			    size_t numBytes, int flags, Tcl_Parse *parsePtr,
+			    Tcl_Size numBytes, int flags, Tcl_Parse *parsePtr,
 			    Tcl_InterpState *statePtr);
 MODULE_SCOPE int	TclSubstTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,
-			    size_t count, int *tokensLeftPtr, size_t line,
+			    Tcl_Size count, int *tokensLeftPtr, Tcl_Size line,
 			    int *clNextOuter, const char *outerScript);
-MODULE_SCOPE size_t	TclTrim(const char *bytes, size_t numBytes,
-			    const char *trim, size_t numTrim, size_t *trimRight);
-MODULE_SCOPE size_t	TclTrimLeft(const char *bytes, size_t numBytes,
-			    const char *trim, size_t numTrim);
-MODULE_SCOPE size_t	TclTrimRight(const char *bytes, size_t numBytes,
-			    const char *trim, size_t numTrim);
+MODULE_SCOPE Tcl_Size	TclTrim(const char *bytes, Tcl_Size numBytes,
+			    const char *trim, Tcl_Size numTrim, Tcl_Size *trimRight);
+MODULE_SCOPE Tcl_Size	TclTrimLeft(const char *bytes, Tcl_Size numBytes,
+			    const char *trim, Tcl_Size numTrim);
+MODULE_SCOPE Tcl_Size	TclTrimRight(const char *bytes, Tcl_Size numBytes,
+			    const char *trim, Tcl_Size numTrim);
 MODULE_SCOPE const char*TclGetCommandTypeName(Tcl_Command command);
 MODULE_SCOPE void	TclRegisterCommandTypeName(
 			    Tcl_ObjCmdProc *implementationProc,
 			    const char *nameStr);
 MODULE_SCOPE int	TclUtfCmp(const char *cs, const char *ct);
 MODULE_SCOPE int	TclUtfCasecmp(const char *cs, const char *ct);
-MODULE_SCOPE size_t	TclUtfCount(int ch);
+MODULE_SCOPE Tcl_Size	TclUtfCount(int ch);
 #if TCL_UTF_MAX > 3
 #   define TclUtfToUCS4 Tcl_UtfToUniChar
 #   define TclUniCharToUCS4(src, ptr) (*ptr = *(src),1)
@@ -3462,7 +3462,7 @@ MODULE_SCOPE void	TclpThreadDeleteKey(void *keyPtr);
 MODULE_SCOPE void	TclpThreadSetGlobalTSD(void *tsdKeyPtr, void *ptr);
 MODULE_SCOPE void *	TclpThreadGetGlobalTSD(void *tsdKeyPtr);
 MODULE_SCOPE void	TclErrorStackResetIf(Tcl_Interp *interp,
-			    const char *msg, size_t length);
+			    const char *msg, Tcl_Size length);
 /* Tip 430 */
 MODULE_SCOPE int    TclZipfs_Init(Tcl_Interp *interp);
 
@@ -3511,7 +3511,7 @@ MODULE_SCOPE int	TclDictWithFinish(Tcl_Interp *interp, Var *varPtr,
 			    Tcl_Obj *part2Ptr, int index, int pathc,
 			    Tcl_Obj *const pathv[], Tcl_Obj *keysPtr);
 MODULE_SCOPE Tcl_Obj *	TclDictWithInit(Tcl_Interp *interp, Tcl_Obj *dictPtr,
-			    size_t pathc, Tcl_Obj *const pathv[]);
+			    Tcl_Size pathc, Tcl_Obj *const pathv[]);
 MODULE_SCOPE Tcl_ObjCmdProc Tcl_DisassembleObjCmd;
 
 /* Assemble command function */
@@ -4037,13 +4037,13 @@ MODULE_SCOPE int	TclCompileAssembleCmd(Tcl_Interp *interp,
 MODULE_SCOPE Tcl_Obj *	TclStringCat(Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[], int flags);
 MODULE_SCOPE Tcl_Obj *	TclStringFirst(Tcl_Obj *needle, Tcl_Obj *haystack,
-			    size_t start);
+			    Tcl_Size start);
 MODULE_SCOPE Tcl_Obj *	TclStringLast(Tcl_Obj *needle, Tcl_Obj *haystack,
-			    size_t last);
+			    Tcl_Size last);
 MODULE_SCOPE Tcl_Obj *	TclStringRepeat(Tcl_Interp *interp, Tcl_Obj *objPtr,
-			    size_t count, int flags);
+			    Tcl_Size count, int flags);
 MODULE_SCOPE Tcl_Obj *	TclStringReplace(Tcl_Interp *interp, Tcl_Obj *objPtr,
-			    size_t first, size_t count, Tcl_Obj *insertPtr,
+			    Tcl_Size first, Tcl_Size count, Tcl_Obj *insertPtr,
 			    int flags);
 MODULE_SCOPE Tcl_Obj *	TclStringReverse(Tcl_Obj *objPtr, int flags);
 
@@ -4170,8 +4170,8 @@ MODULE_SCOPE Tcl_Obj *	TclGetArrayDefault(Var *arrayPtr);
  */
 
 MODULE_SCOPE int	TclIndexEncode(Tcl_Interp *interp, Tcl_Obj *objPtr,
-			    size_t before, size_t after, int *indexPtr);
-MODULE_SCOPE size_t	TclIndexDecode(int encoded, size_t endValue);
+			    Tcl_Size before, Tcl_Size after, int *indexPtr);
+MODULE_SCOPE Tcl_Size	TclIndexDecode(int encoded, Tcl_Size endValue);
 #endif /* TCL_MAJOR_VERSION > 8 */
 
 /* Constants used in index value encoding routines. */
diff --git a/generic/tclOO.decls b/generic/tclOO.decls
index 3783adf..2df34d0 100644
--- a/generic/tclOO.decls
+++ b/generic/tclOO.decls
@@ -68,8 +68,8 @@ declare 12 {
 }
 declare 13 {
     Tcl_Object Tcl_NewObjectInstance(Tcl_Interp *interp, Tcl_Class cls,
-	    const char *nameStr, const char *nsNameStr, size_t objc,
-	    Tcl_Obj *const *objv, size_t skip)
+	    const char *nameStr, const char *nsNameStr, Tcl_Size objc,
+	    Tcl_Obj *const *objv, Tcl_Size skip)
 }
 declare 14 {
     int Tcl_ObjectDeleted(Tcl_Object object)
@@ -84,7 +84,7 @@ declare 17 {
     Tcl_Object Tcl_ObjectContextObject(Tcl_ObjectContext context)
 }
 declare 18 {
-    size_t Tcl_ObjectContextSkippedArgs(Tcl_ObjectContext context)
+    Tcl_Size Tcl_ObjectContextSkippedArgs(Tcl_ObjectContext context)
 }
 declare 19 {
     void *Tcl_ClassGetMetadata(Tcl_Class clazz,
@@ -104,8 +104,8 @@ declare 22 {
 }
 declare 23 {
     int Tcl_ObjectContextInvokeNext(Tcl_Interp *interp,
-	    Tcl_ObjectContext context, size_t objc, Tcl_Obj *const *objv,
-	    size_t skip)
+	    Tcl_ObjectContext context, Tcl_Size objc, Tcl_Obj *const *objv,
+	    Tcl_Size skip)
 }
 declare 24 {
     Tcl_ObjectMapMethodNameProc *Tcl_ObjectGetMethodNameMapper(
@@ -184,7 +184,7 @@ declare 4 {
 	    ProcedureMethod **pmPtrPtr)
 }
 declare 5 {
-    int TclOOObjectCmdCore(Object *oPtr, Tcl_Interp *interp, size_t objc,
+    int TclOOObjectCmdCore(Object *oPtr, Tcl_Interp *interp, Tcl_Size objc,
 	    Tcl_Obj *const *objv, int publicOnly, Class *startCls)
 }
 declare 6 {
@@ -214,24 +214,24 @@ declare 10 {
 }
 declare 11 {
     int TclOOInvokeObject(Tcl_Interp *interp, Tcl_Object object,
-	    Tcl_Class startCls, int publicPrivate, size_t objc,
+	    Tcl_Class startCls, int publicPrivate, Tcl_Size objc,
 	    Tcl_Obj *const *objv)
 }
 declare 12 {
-    void TclOOObjectSetFilters(Object *oPtr, size_t numFilters,
+    void TclOOObjectSetFilters(Object *oPtr, Tcl_Size numFilters,
 	    Tcl_Obj *const *filters)
 }
 declare 13 {
     void TclOOClassSetFilters(Tcl_Interp *interp, Class *classPtr,
-	    size_t numFilters, Tcl_Obj *const *filters)
+	    Tcl_Size numFilters, Tcl_Obj *const *filters)
 }
 declare 14 {
-    void TclOOObjectSetMixins(Object *oPtr, size_t numMixins,
+    void TclOOObjectSetMixins(Object *oPtr, Tcl_Size numMixins,
 	    Class *const *mixins)
 }
 declare 15 {
     void TclOOClassSetMixins(Tcl_Interp *interp, Class *classPtr,
-	    size_t numMixins, Class *const *mixins)
+	    Tcl_Size numMixins, Class *const *mixins)
 }
 
 return
diff --git a/generic/tclOODecls.h b/generic/tclOODecls.h
index 0c141fe..cf55478 100644
--- a/generic/tclOODecls.h
+++ b/generic/tclOODecls.h
@@ -69,8 +69,8 @@ TCLAPI Tcl_Method	Tcl_NewMethod(Tcl_Interp *interp, Tcl_Class cls,
 /* 13 */
 TCLAPI Tcl_Object	Tcl_NewObjectInstance(Tcl_Interp *interp,
 				Tcl_Class cls, const char *nameStr,
-				const char *nsNameStr, size_t objc,
-				Tcl_Obj *const *objv, size_t skip);
+				const char *nsNameStr, Tcl_Size objc,
+				Tcl_Obj *const *objv, Tcl_Size skip);
 /* 14 */
 TCLAPI int		Tcl_ObjectDeleted(Tcl_Object object);
 /* 15 */
@@ -81,7 +81,7 @@ TCLAPI Tcl_Method	Tcl_ObjectContextMethod(Tcl_ObjectContext context);
 /* 17 */
 TCLAPI Tcl_Object	Tcl_ObjectContextObject(Tcl_ObjectContext context);
 /* 18 */
-TCLAPI size_t		Tcl_ObjectContextSkippedArgs(
+TCLAPI Tcl_Size		Tcl_ObjectContextSkippedArgs(
 				Tcl_ObjectContext context);
 /* 19 */
 TCLAPI void *		Tcl_ClassGetMetadata(Tcl_Class clazz,
@@ -99,8 +99,8 @@ TCLAPI void		Tcl_ObjectSetMetadata(Tcl_Object object,
 				void *metadata);
 /* 23 */
 TCLAPI int		Tcl_ObjectContextInvokeNext(Tcl_Interp *interp,
-				Tcl_ObjectContext context, size_t objc,
-				Tcl_Obj *const *objv, size_t skip);
+				Tcl_ObjectContext context, Tcl_Size objc,
+				Tcl_Obj *const *objv, Tcl_Size skip);
 /* 24 */
 TCLAPI Tcl_ObjectMapMethodNameProc * Tcl_ObjectGetMethodNameMapper(
 				Tcl_Object object);
@@ -159,17 +159,17 @@ typedef struct TclOOStubs {
     Tcl_Obj * (*tcl_MethodName) (Tcl_Method method); /* 10 */
     Tcl_Method (*tcl_NewInstanceMethod) (Tcl_Interp *interp, Tcl_Object object, Tcl_Obj *nameObj, int flags, const Tcl_MethodType *typePtr, void *clientData); /* 11 */
     Tcl_Method (*tcl_NewMethod) (Tcl_Interp *interp, Tcl_Class cls, Tcl_Obj *nameObj, int flags, const Tcl_MethodType *typePtr, void *clientData); /* 12 */
-    Tcl_Object (*tcl_NewObjectInstance) (Tcl_Interp *interp, Tcl_Class cls, const char *nameStr, const char *nsNameStr, size_t objc, Tcl_Obj *const *objv, size_t skip); /* 13 */
+    Tcl_Object (*tcl_NewObjectInstance) (Tcl_Interp *interp, Tcl_Class cls, const char *nameStr, const char *nsNameStr, Tcl_Size objc, Tcl_Obj *const *objv, Tcl_Size skip); /* 13 */
     int (*tcl_ObjectDeleted) (Tcl_Object object); /* 14 */
     int (*tcl_ObjectContextIsFiltering) (Tcl_ObjectContext context); /* 15 */
     Tcl_Method (*tcl_ObjectContextMethod) (Tcl_ObjectContext context); /* 16 */
     Tcl_Object (*tcl_ObjectContextObject) (Tcl_ObjectContext context); /* 17 */
-    size_t (*tcl_ObjectContextSkippedArgs) (Tcl_ObjectContext context); /* 18 */
+    Tcl_Size (*tcl_ObjectContextSkippedArgs) (Tcl_ObjectContext context); /* 18 */
     void * (*tcl_ClassGetMetadata) (Tcl_Class clazz, const Tcl_ObjectMetadataType *typePtr); /* 19 */
     void (*tcl_ClassSetMetadata) (Tcl_Class clazz, const Tcl_ObjectMetadataType *typePtr, void *metadata); /* 20 */
     void * (*tcl_ObjectGetMetadata) (Tcl_Object object, const Tcl_ObjectMetadataType *typePtr); /* 21 */
     void (*tcl_ObjectSetMetadata) (Tcl_Object object, const Tcl_ObjectMetadataType *typePtr, void *metadata); /* 22 */
-    int (*tcl_ObjectContextInvokeNext) (Tcl_Interp *interp, Tcl_ObjectContext context, size_t objc, Tcl_Obj *const *objv, size_t skip); /* 23 */
+    int (*tcl_ObjectContextInvokeNext) (Tcl_Interp *interp, Tcl_ObjectContext context, Tcl_Size objc, Tcl_Obj *const *objv, Tcl_Size skip); /* 23 */
     Tcl_ObjectMapMethodNameProc * (*tcl_ObjectGetMethodNameMapper) (Tcl_Object object); /* 24 */
     void (*tcl_ObjectSetMethodNameMapper) (Tcl_Object object, Tcl_ObjectMapMethodNameProc *mapMethodNameProc); /* 25 */
     void (*tcl_ClassSetConstructor) (Tcl_Interp *interp, Tcl_Class clazz, Tcl_Method method); /* 26 */
diff --git a/generic/tclOOIntDecls.h b/generic/tclOOIntDecls.h
index 53c2a6f..730a73a 100644
--- a/generic/tclOOIntDecls.h
+++ b/generic/tclOOIntDecls.h
@@ -42,7 +42,7 @@ TCLAPI Method *		TclOONewProcMethod(Tcl_Interp *interp, Class *clsPtr,
 				ProcedureMethod **pmPtrPtr);
 /* 5 */
 TCLAPI int		TclOOObjectCmdCore(Object *oPtr, Tcl_Interp *interp,
-				size_t objc, Tcl_Obj *const *objv,
+				Tcl_Size objc, Tcl_Obj *const *objv,
 				int publicOnly, Class *startCls);
 /* 6 */
 TCLAPI int		TclOOIsReachable(Class *targetPtr, Class *startPtr);
@@ -75,21 +75,21 @@ TCLAPI Tcl_Method	TclOONewProcMethodEx(Tcl_Interp *interp,
 /* 11 */
 TCLAPI int		TclOOInvokeObject(Tcl_Interp *interp,
 				Tcl_Object object, Tcl_Class startCls,
-				int publicPrivate, size_t objc,
+				int publicPrivate, Tcl_Size objc,
 				Tcl_Obj *const *objv);
 /* 12 */
 TCLAPI void		TclOOObjectSetFilters(Object *oPtr,
-				size_t numFilters, Tcl_Obj *const *filters);
+				Tcl_Size numFilters, Tcl_Obj *const *filters);
 /* 13 */
 TCLAPI void		TclOOClassSetFilters(Tcl_Interp *interp,
-				Class *classPtr, size_t numFilters,
+				Class *classPtr, Tcl_Size numFilters,
 				Tcl_Obj *const *filters);
 /* 14 */
-TCLAPI void		TclOOObjectSetMixins(Object *oPtr, size_t numMixins,
-				Class *const *mixins);
+TCLAPI void		TclOOObjectSetMixins(Object *oPtr,
+				Tcl_Size numMixins, Class *const *mixins);
 /* 15 */
 TCLAPI void		TclOOClassSetMixins(Tcl_Interp *interp,
-				Class *classPtr, size_t numMixins,
+				Class *classPtr, Tcl_Size numMixins,
 				Class *const *mixins);
 
 typedef struct TclOOIntStubs {
@@ -101,17 +101,17 @@ typedef struct TclOOIntStubs {
     Tcl_Method (*tclOOMakeProcMethod) (Tcl_Interp *interp, Class *clsPtr, int flags, Tcl_Obj *nameObj, const char *namePtr, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, const Tcl_MethodType *typePtr, void *clientData, Proc **procPtrPtr); /* 2 */
     Method * (*tclOONewProcInstanceMethod) (Tcl_Interp *interp, Object *oPtr, int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, ProcedureMethod **pmPtrPtr); /* 3 */
     Method * (*tclOONewProcMethod) (Tcl_Interp *interp, Class *clsPtr, int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, ProcedureMethod **pmPtrPtr); /* 4 */
-    int (*tclOOObjectCmdCore) (Object *oPtr, Tcl_Interp *interp, size_t objc, Tcl_Obj *const *objv, int publicOnly, Class *startCls); /* 5 */
+    int (*tclOOObjectCmdCore) (Object *oPtr, Tcl_Interp *interp, Tcl_Size objc, Tcl_Obj *const *objv, int publicOnly, Class *startCls); /* 5 */
     int (*tclOOIsReachable) (Class *targetPtr, Class *startPtr); /* 6 */
     Method * (*tclOONewForwardMethod) (Tcl_Interp *interp, Class *clsPtr, int isPublic, Tcl_Obj *nameObj, Tcl_Obj *prefixObj); /* 7 */
     Method * (*tclOONewForwardInstanceMethod) (Tcl_Interp *interp, Object *oPtr, int isPublic, Tcl_Obj *nameObj, Tcl_Obj *prefixObj); /* 8 */
     Tcl_Method (*tclOONewProcInstanceMethodEx) (Tcl_Interp *interp, Tcl_Object oPtr, TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc, void *clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags, void **internalTokenPtr); /* 9 */
     Tcl_Method (*tclOONewProcMethodEx) (Tcl_Interp *interp, Tcl_Class clsPtr, TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc, void *clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags, void **internalTokenPtr); /* 10 */
-    int (*tclOOInvokeObject) (Tcl_Interp *interp, Tcl_Object object, Tcl_Class startCls, int publicPrivate, size_t objc, Tcl_Obj *const *objv); /* 11 */
-    void (*tclOOObjectSetFilters) (Object *oPtr, size_t numFilters, Tcl_Obj *const *filters); /* 12 */
-    void (*tclOOClassSetFilters) (Tcl_Interp *interp, Class *classPtr, size_t numFilters, Tcl_Obj *const *filters); /* 13 */
-    void (*tclOOObjectSetMixins) (Object *oPtr, size_t numMixins, Class *const *mixins); /* 14 */
-    void (*tclOOClassSetMixins) (Tcl_Interp *interp, Class *classPtr, size_t numMixins, Class *const *mixins); /* 15 */
+    int (*tclOOInvokeObject) (Tcl_Interp *interp, Tcl_Object object, Tcl_Class startCls, int publicPrivate, Tcl_Size objc, Tcl_Obj *const *objv); /* 11 */
+    void (*tclOOObjectSetFilters) (Object *oPtr, Tcl_Size numFilters, Tcl_Obj *const *filters); /* 12 */
+    void (*tclOOClassSetFilters) (Tcl_Interp *interp, Class *classPtr, Tcl_Size numFilters, Tcl_Obj *const *filters); /* 13 */
+    void (*tclOOObjectSetMixins) (Object *oPtr, Tcl_Size numMixins, Class *const *mixins); /* 14 */
+    void (*tclOOClassSetMixins) (Tcl_Interp *interp, Class *classPtr, Tcl_Size numMixins, Class *const *mixins); /* 15 */
 } TclOOIntStubs;
 
 extern const TclOOIntStubs *tclOOIntStubsPtr;
diff --git a/generic/tclTestObj.c b/generic/tclTestObj.c
index 1caa52b..2936345 100644
--- a/generic/tclTestObj.c
+++ b/generic/tclTestObj.c
@@ -31,10 +31,10 @@
  * Forward declarations for functions defined later in this file:
  */
 
-static int		CheckIfVarUnset(Tcl_Interp *interp, Tcl_Obj **varPtr, size_t varIndex);
+static int		CheckIfVarUnset(Tcl_Interp *interp, Tcl_Obj **varPtr, Tcl_Size varIndex);
 static int		GetVariableIndex(Tcl_Interp *interp,
-			    Tcl_Obj *obj, size_t *indexPtr);
-static void		SetVarToObj(Tcl_Obj **varPtr, size_t varIndex, Tcl_Obj *objPtr);
+			    Tcl_Obj *obj, Tcl_Size *indexPtr);
+static void		SetVarToObj(Tcl_Obj **varPtr, Tcl_Size varIndex, Tcl_Obj *objPtr);
 static Tcl_ObjCmdProc	TestbignumobjCmd;
 static Tcl_ObjCmdProc	TestbooleanobjCmd;
 static Tcl_ObjCmdProc	TestdoubleobjCmd;
@@ -157,7 +157,7 @@ TestbignumobjCmd(
 	BIGNUM_RADIXSIZE
     } idx;
     int index;
-    size_t varIndex;
+    Tcl_Size varIndex;
     const char *string;
     mp_int bignumValue;
     Tcl_Obj **varPtr;
@@ -348,7 +348,7 @@ TestbooleanobjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t varIndex;
+    Tcl_Size varIndex;
     int boolValue;
     const char *subCmd;
     Tcl_Obj **varPtr;
@@ -448,7 +448,7 @@ TestdoubleobjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t varIndex;
+    Tcl_Size varIndex;
     double doubleValue;
     const char *subCmd;
     Tcl_Obj **varPtr;
@@ -565,7 +565,7 @@ TestindexobjCmd(
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     int allowAbbrev, index, setError, i, result;
-    Tcl_WideInt index2;
+    Tcl_Size index2;
     const char **argv;
     static const char *const tablePtr[] = {"a", "b", "check", NULL};
 
@@ -574,8 +574,8 @@ TestindexobjCmd(
      */
     struct IndexRep {
 	void *tablePtr;		/* Pointer to the table of strings. */
-	TCL_HASH_TYPE offset;		/* Offset between table entries. */
-	TCL_HASH_TYPE index;		/* Selected index into table. */
+	Tcl_Size offset;		/* Offset between table entries. */
+	Tcl_Size index;		/* Selected index into table. */
     } *indexRep;
 
     if ((objc == 3) && (strcmp(Tcl_GetString(objv[1]),
@@ -586,7 +586,7 @@ TestindexobjCmd(
 	 * lookups.
 	 */
 
-	if (Tcl_GetWideIntFromObj(interp, objv[2], &index2) != TCL_OK) {
+	if (Tcl_GetIntForIndex(interp, objv[2], TCL_INDEX_NONE, &index2) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 
@@ -596,7 +596,7 @@ TestindexobjCmd(
 	result = Tcl_GetIndexFromObj(NULL, objv[1],
 		tablePtr, "token", 0, &index);
 	if (result == TCL_OK) {
-	    Tcl_SetWideIntObj(Tcl_GetObjResult(interp), index);
+	    Tcl_SetWideIntObj(Tcl_GetObjResult(interp), (Tcl_WideInt)((Tcl_WideUInt)(index + 1U)) - 1);
 	}
 	return result;
     }
@@ -624,7 +624,7 @@ TestindexobjCmd(
 	    &index);
     Tcl_Free((void *)argv);
     if (result == TCL_OK) {
-	Tcl_SetWideIntObj(Tcl_GetObjResult(interp), index);
+	Tcl_SetWideIntObj(Tcl_GetObjResult(interp), (Tcl_WideInt)((Tcl_WideUInt)(index + 1U)) - 1);
     }
     return result;
 }
@@ -654,7 +654,7 @@ TestintobjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t varIndex;
+    Tcl_Size varIndex;
 #if (INT_MAX != LONG_MAX)   /* int is not the same size as long */
     int i;
 #endif
@@ -899,9 +899,9 @@ TestlistobjCmd(
 	LISTOBJ_GETELEMENTSMEMCHECK,
     } cmdIndex;
 
-    size_t varIndex;		/* Variable number converted to binary */
-    Tcl_WideInt first;			/* First index in the list */
-    Tcl_WideInt count;			/* Count of elements in a list */
+    Tcl_Size varIndex;		/* Variable number converted to binary */
+    Tcl_Size first;			/* First index in the list */
+    Tcl_Size count;			/* Count of elements in a list */
     Tcl_Obj **varPtr;
     int i, len;
 
@@ -917,7 +917,7 @@ TestlistobjCmd(
 			    0, &cmdIndex) != TCL_OK) {
 	return TCL_ERROR;
     }
-    switch (cmdIndex) {
+    switch(cmdIndex) {
     case LISTOBJ_SET:
 	if ((varPtr[varIndex] != NULL) && !Tcl_IsShared(varPtr[varIndex])) {
 	    Tcl_SetListObj(varPtr[varIndex], objc-3, objv+3);
@@ -944,8 +944,8 @@ TestlistobjCmd(
 			     "varIndex start count ?element...?");
 	    return TCL_ERROR;
 	}
-	if (Tcl_GetWideIntFromObj(interp, objv[3], &first) != TCL_OK
-	    || Tcl_GetWideIntFromObj(interp, objv[4], &count) != TCL_OK) {
+	if (Tcl_GetIntForIndex(interp, objv[3], TCL_INDEX_NONE, &first) != TCL_OK
+	    || Tcl_GetIntForIndex(interp, objv[4], TCL_INDEX_NONE, &count) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 	if (Tcl_IsShared(varPtr[varIndex])) {
@@ -1032,7 +1032,7 @@ TestobjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t varIndex, destIndex;
+    Tcl_Size varIndex, destIndex;
     int i;
     const Tcl_ObjType *targetType;
     Tcl_Obj **varPtr;
@@ -1203,7 +1203,7 @@ TestobjCmd(
 	if (objc != 3) {
 	    goto wrongNumArgs;
 	}
-	Tcl_SetObjResult(interp, Tcl_NewWideIntObj(varPtr[varIndex]->refCount));
+	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt)((Tcl_WideUInt)(varPtr[varIndex]->refCount + 1U)) - 1));
 	break;
     case TESTOBJ_TYPE:
 	if (objc != 3) {
@@ -1254,9 +1254,9 @@ TeststringobjCmd(
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Tcl_UniChar *unicode;
-    size_t size, varIndex;
+    Tcl_Size size, varIndex;
     int option, i;
-    Tcl_WideInt length;
+    Tcl_Size length;
 #define MAX_STRINGS 11
     const char *string, *strings[MAX_STRINGS+1];
     String *strPtr;
@@ -1287,7 +1287,7 @@ TeststringobjCmd(
 	    if (objc != 5) {
 		goto wrongNumArgs;
 	    }
-	    if (Tcl_GetWideIntFromObj(interp, objv[4], &length) != TCL_OK) {
+	    if (Tcl_GetIntForIndex(interp, objv[4], TCL_INDEX_NONE, &length) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	    if (varPtr[varIndex] == NULL) {
@@ -1368,9 +1368,9 @@ TeststringobjCmd(
 		strPtr = (String *)varPtr[varIndex]->internalRep.twoPtrValue.ptr1;
 		length = strPtr->allocated;
 	    } else {
-		length = -1;
+		length = TCL_INDEX_NONE;
 	    }
-	    Tcl_SetWideIntObj(Tcl_GetObjResult(interp), length);
+	    Tcl_SetWideIntObj(Tcl_GetObjResult(interp), (Tcl_WideInt)((Tcl_WideUInt)(length + 1U)) - 1);
 	    break;
 	case 6:				/* set */
 	    if (objc != 4) {
@@ -1405,7 +1405,7 @@ TeststringobjCmd(
 	    if (objc != 4) {
 		goto wrongNumArgs;
 	    }
-	    if (Tcl_GetWideIntFromObj(interp, objv[3], &length) != TCL_OK) {
+	    if (Tcl_GetIntForIndex(interp, objv[3], TCL_INDEX_NONE, &length) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	    if (varPtr[varIndex] != NULL) {
@@ -1422,17 +1422,17 @@ TeststringobjCmd(
 		strPtr = (String *)varPtr[varIndex]->internalRep.twoPtrValue.ptr1;
 		length = strPtr->maxChars;
 	    } else {
-		length = -1;
+		length = TCL_INDEX_NONE;
 	    }
-	    Tcl_SetWideIntObj(Tcl_GetObjResult(interp), length);
+	    Tcl_SetWideIntObj(Tcl_GetObjResult(interp), (Tcl_WideInt)((Tcl_WideUInt)(length + 1U)) - 1);
 	    break;
 	case 10: {				/* range */
-	    Tcl_WideInt first, last;
+	    Tcl_Size first, last;
 	    if (objc != 5) {
 		goto wrongNumArgs;
 	    }
-	    if ((Tcl_GetWideIntFromObj(interp, objv[3], &first) != TCL_OK)
-		    || (Tcl_GetWideIntFromObj(interp, objv[4], &last) != TCL_OK)) {
+	    if ((Tcl_GetIntForIndex(interp, objv[3], TCL_INDEX_NONE, &first) != TCL_OK)
+		    || (Tcl_GetIntForIndex(interp, objv[4], TCL_INDEX_NONE, &last) != TCL_OK)) {
 		return TCL_ERROR;
 	    }
 	    Tcl_SetObjResult(interp, Tcl_GetRange(varPtr[varIndex], first, last));
@@ -1457,10 +1457,10 @@ TeststringobjCmd(
 
 	    string = Tcl_GetStringFromObj(varPtr[varIndex], &size);
 
-	    if (Tcl_GetWideIntFromObj(interp, objv[3], &length) != TCL_OK) {
+	    if (Tcl_GetIntForIndex(interp, objv[3], size-1, &length) != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    if ((length < 0) || ((Tcl_WideUInt)length > (Tcl_WideUInt)size)) {
+	    if (length == TCL_INDEX_NONE) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"index value out of range", TCL_INDEX_NONE));
 		return TCL_ERROR;
@@ -1488,10 +1488,10 @@ TeststringobjCmd(
 
 	    unicode = Tcl_GetUnicodeFromObj(varPtr[varIndex], &size);
 
-	    if (Tcl_GetWideIntFromObj(interp, objv[3], &length) != TCL_OK) {
+	    if (Tcl_GetIntForIndex(interp, objv[3], size-1, &length) != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    if ((length < 0) || ((Tcl_WideUInt)length > (Tcl_WideUInt)size)) {
+	    if (length == TCL_INDEX_NONE) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"index value out of range", TCL_INDEX_NONE));
 		return TCL_ERROR;
@@ -1673,7 +1673,7 @@ TestbigdataCmd (
 static void
 SetVarToObj(
     Tcl_Obj **varPtr,
-    size_t varIndex,		/* Designates the assignment variable. */
+    Tcl_Size varIndex,		/* Designates the assignment variable. */
     Tcl_Obj *objPtr)		/* Points to object to assign to var. */
 {
     if (varPtr[varIndex] != NULL) {
@@ -1707,14 +1707,14 @@ GetVariableIndex(
     Tcl_Obj *obj,		/* The variable index
 				 * specified as a nonnegative number less than
 				 * NUMBER_OF_OBJECT_VARS. */
-    size_t *indexPtr)		/* Place to store converted result. */
+    Tcl_Size *indexPtr)		/* Place to store converted result. */
 {
-    Tcl_WideInt index;
+    Tcl_Size index;
 
-    if (Tcl_GetWideIntFromObj(interp, obj, &index) != TCL_OK) {
+    if (Tcl_GetIntForIndex(interp, obj, NUMBER_OF_OBJECT_VARS - 1, &index) != TCL_OK) {
 	return TCL_ERROR;
     }
-    if (index < 0 || index >= NUMBER_OF_OBJECT_VARS) {
+    if (index == TCL_INDEX_NONE) {
 	Tcl_ResetResult(interp);
 	Tcl_AppendToObj(Tcl_GetObjResult(interp), "bad variable index", TCL_INDEX_NONE);
 	return TCL_ERROR;
@@ -1746,7 +1746,7 @@ static int
 CheckIfVarUnset(
     Tcl_Interp *interp,		/* Interpreter for error reporting. */
     Tcl_Obj ** varPtr,
-    size_t varIndex)		/* Index of the test variable to check. */
+    Tcl_Size varIndex)		/* Index of the test variable to check. */
 {
     if (varPtr[varIndex] == NULL) {
 	char buf[32 + TCL_INTEGER_SPACE];
diff --git a/generic/tclUtil.c b/generic/tclUtil.c
index c03ead9..88673ee 100644
--- a/generic/tclUtil.c
+++ b/generic/tclUtil.c
@@ -102,14 +102,14 @@ static void		ClearHash(Tcl_HashTable *tablePtr);
 static void		FreeProcessGlobalValue(void *clientData);
 static void		FreeThreadHash(void *clientData);
 static int		GetEndOffsetFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
-			    size_t endValue, Tcl_WideInt *indexPtr);
+			    Tcl_Size endValue, Tcl_WideInt *indexPtr);
 static Tcl_HashTable *	GetThreadHash(Tcl_ThreadDataKey *keyPtr);
 static int		GetWideForIndex(Tcl_Interp *interp, Tcl_Obj *objPtr,
-			    size_t endValue, Tcl_WideInt *widePtr);
+			    Tcl_Size endValue, Tcl_WideInt *widePtr);
 static int		FindElement(Tcl_Interp *interp, const char *string,
-			    size_t stringLength, const char *typeStr,
+			    Tcl_Size stringLength, const char *typeStr,
 			    const char *typeCode, const char **elementPtr,
-			    const char **nextPtr, size_t *sizePtr,
+			    const char **nextPtr, Tcl_Size *sizePtr,
 			    int *literalPtr);
 /*
  * The following is the Tcl object type definition for an object that
@@ -394,13 +394,13 @@ TclLengthOne(
  *----------------------------------------------------------------------
  */
 
-int
+Tcl_Size
 TclMaxListLength(
     const char *bytes,
-    size_t numBytes,
+    Tcl_Size numBytes,
     const char **endPtr)
 {
-    size_t count = 0;
+    Tcl_Size count = 0;
 
     if ((numBytes == 0) || ((numBytes == TCL_INDEX_NONE) && (*bytes == '\0'))) {
 	/* Empty string case - quick exit */
@@ -503,13 +503,13 @@ TclFindElement(
     const char *list,		/* Points to the first byte of a string
 				 * containing a Tcl list with zero or more
 				 * elements (possibly in braces). */
-    size_t listLength,		/* Number of bytes in the list's string. */
+    Tcl_Size listLength,	/* Number of bytes in the list's string. */
     const char **elementPtr,	/* Where to put address of first significant
 				 * character in first element of list. */
     const char **nextPtr,	/* Fill in with location of character just
 				 * after all white space following end of
 				 * argument (next arg or end of list). */
-    size_t *sizePtr,		/* If non-zero, fill in with size of
+    Tcl_Size *sizePtr,		/* If non-zero, fill in with size of
 				 * element. */
     int *literalPtr)		/* If non-zero, fill in with non-zero/zero to
 				 * indicate that the substring of *sizePtr
@@ -531,14 +531,14 @@ TclFindDictElement(
 				 * containing a Tcl dictionary with zero or
 				 * more keys and values (possibly in
 				 * braces). */
-    size_t dictLength,		/* Number of bytes in the dict's string. */
+    Tcl_Size dictLength,	/* Number of bytes in the dict's string. */
     const char **elementPtr,	/* Where to put address of first significant
 				 * character in the first element (i.e., key
 				 * or value) of dict. */
     const char **nextPtr,	/* Fill in with location of character just
 				 * after all white space following end of
 				 * element (next arg or end of list). */
-    size_t *sizePtr,		/* If non-zero, fill in with size of
+    Tcl_Size *sizePtr,		/* If non-zero, fill in with size of
 				 * element. */
     int *literalPtr)		/* If non-zero, fill in with non-zero/zero to
 				 * indicate that the substring of *sizePtr
@@ -560,7 +560,7 @@ FindElement(
 				 * containing a Tcl list or dictionary with
 				 * zero or more elements (possibly in
 				 * braces). */
-    size_t stringLength,		/* Number of bytes in the string. */
+    Tcl_Size stringLength,	/* Number of bytes in the string. */
     const char *typeStr,	/* The name of the type of thing we are
 				 * parsing, for error messages. */
     const char *typeCode,	/* The type code for thing we are parsing, for
@@ -570,7 +570,7 @@ FindElement(
     const char **nextPtr,	/* Fill in with location of character just
 				 * after all white space following end of
 				 * argument (next arg or end of list/dict). */
-    size_t *sizePtr,		/* If non-zero, fill in with size of
+    Tcl_Size *sizePtr,		/* If non-zero, fill in with size of
 				 * element. */
     int *literalPtr)		/* If non-zero, fill in with non-zero/zero to
 				 * indicate that the substring of *sizePtr
@@ -582,10 +582,10 @@ FindElement(
     const char *p = string;
     const char *elemStart;	/* Points to first byte of first element. */
     const char *limit;		/* Points just after list/dict's last byte. */
-    size_t openBraces = 0;		/* Brace nesting level during parse. */
+    Tcl_Size openBraces = 0;	/* Brace nesting level during parse. */
     int inQuotes = 0;
-    size_t size = 0;
-    size_t numChars;
+    Tcl_Size size = 0;
+    Tcl_Size numChars;
     int literal = 1;
     const char *p2;
 
@@ -793,21 +793,21 @@ FindElement(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 TclCopyAndCollapse(
-    size_t count,			/* Number of byte to copy from src. */
+    Tcl_Size count,		/* Number of byte to copy from src. */
     const char *src,		/* Copy from here... */
     char *dst)			/* ... to here. */
 {
-    size_t newCount = 0;
+    Tcl_Size newCount = 0;
 
     while (count > 0) {
 	char c = *src;
 
 	if (c == '\\') {
 	    char buf[4] = "";
-	    size_t numRead;
-	    size_t backslashCount = TclParseBackslash(src, count, &numRead, buf);
+	    Tcl_Size numRead;
+	    Tcl_Size backslashCount = TclParseBackslash(src, count, &numRead, buf);
 
 	    memcpy(dst, buf, backslashCount);
 	    dst += backslashCount;
@@ -868,7 +868,7 @@ Tcl_SplitList(
     const char **argv, *end, *element;
     char *p;
     int result;
-    size_t length, size, i, elSize;
+    Tcl_Size length, size, i, elSize;
 
     /*
      * Allocate enough space to work in. A (const char *) for each (possible)
@@ -945,7 +945,7 @@ Tcl_SplitList(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 Tcl_ScanElement(
     const char *src,	/* String to convert to list element. */
     int *flagPtr)	/* Where to store information to guide
@@ -977,15 +977,15 @@ Tcl_ScanElement(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 Tcl_ScanCountedElement(
     const char *src,		/* String to convert to Tcl list element. */
-    size_t length,		/* Number of bytes in src, or TCL_INDEX_NONE. */
+    Tcl_Size length,		/* Number of bytes in src, or TCL_INDEX_NONE. */
     int *flagPtr)		/* Where to store information to guide
 				 * Tcl_ConvertElement. */
 {
     char flags = CONVERT_ANY;
-    size_t numBytes = TclScanElement(src, length, &flags);
+    Tcl_Size numBytes = TclScanElement(src, length, &flags);
 
     *flagPtr = flags;
     return numBytes;
@@ -1021,15 +1021,15 @@ Tcl_ScanCountedElement(
  *----------------------------------------------------------------------
  */
 
-TCL_HASH_TYPE
+Tcl_Size
 TclScanElement(
     const char *src,		/* String to convert to Tcl list element. */
-    size_t length,		/* Number of bytes in src, or TCL_INDEX_NONE. */
+    Tcl_Size length,		/* Number of bytes in src, or TCL_INDEX_NONE. */
     char *flagPtr)		/* Where to store information to guide
 				 * Tcl_ConvertElement. */
 {
     const char *p = src;
-    size_t nestingLevel = 0;	/* Brace nesting count */
+    Tcl_Size nestingLevel = 0;	/* Brace nesting count */
     int forbidNone = 0;		/* Do not permit CONVERT_NONE mode. Something
 				 * needs protection or escape. */
     int requireEscape = 0;	/* Force use of CONVERT_ESCAPE mode.  For some
@@ -1322,7 +1322,7 @@ TclScanElement(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 Tcl_ConvertElement(
     const char *src,	/* Source information for list element. */
     char *dst,		/* Place to put list-ified element. */
@@ -1352,14 +1352,14 @@ Tcl_ConvertElement(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 Tcl_ConvertCountedElement(
     const char *src,	/* Source information for list element. */
-    size_t length,		/* Number of bytes in src, or TCL_INDEX_NONE. */
+    Tcl_Size length,		/* Number of bytes in src, or TCL_INDEX_NONE. */
     char *dst,			/* Place to put list-ified element. */
     int flags)			/* Flags produced by Tcl_ScanElement. */
 {
-    size_t numBytes = TclConvertElement(src, length, dst, flags);
+    Tcl_Size numBytes = TclConvertElement(src, length, dst, flags);
     dst[numBytes] = '\0';
     return numBytes;
 }
@@ -1385,10 +1385,10 @@ Tcl_ConvertCountedElement(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 TclConvertElement(
     const char *src,	/* Source information for list element. */
-    size_t length,		/* Number of bytes in src, or TCL_INDEX_NONE. */
+    Tcl_Size length,		/* Number of bytes in src, or TCL_INDEX_NONE. */
     char *dst,			/* Place to put list-ified element. */
     int flags)			/* Flags produced by Tcl_ScanElement. */
 {
@@ -1464,7 +1464,7 @@ TclConvertElement(
 	}
 	*p = '}';
 	p++;
-	return (size_t)(p - dst);
+	return (Tcl_Size)(p - dst);
     }
 
     /* conversion == CONVERT_ESCAPE or CONVERT_MASK */
@@ -1527,7 +1527,7 @@ TclConvertElement(
 	    continue;
 	case '\0':
 	    if (length == TCL_INDEX_NONE) {
-		return (size_t)(p - dst);
+		return (Tcl_Size)(p - dst);
 	    }
 
 	    /*
@@ -1543,7 +1543,7 @@ TclConvertElement(
 	*p = *src;
 	p++;
     }
-    return (size_t)(p - dst);
+    return (Tcl_Size)(p - dst);
 }
 
 /*
@@ -1568,12 +1568,12 @@ TclConvertElement(
 
 char *
 Tcl_Merge(
-    size_t argc,			/* How many strings to merge. */
+    Tcl_Size argc,			/* How many strings to merge. */
     const char *const *argv)	/* Array of string values. */
 {
 #define LOCAL_SIZE 64
     char localFlags[LOCAL_SIZE], *flagPtr = NULL;
-    size_t i, bytesNeeded = 0;
+    Tcl_Size i, bytesNeeded = 0;
     char *result, *dst;
 
     /*
@@ -1639,14 +1639,14 @@ Tcl_Merge(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 TclTrimRight(
     const char *bytes,	/* String to be trimmed... */
-    size_t numBytes,	/* ...and its length in bytes */
+    Tcl_Size numBytes,	/* ...and its length in bytes */
 			/* Calls to TclUtfToUniChar() in this routine
 			 * rely on (bytes[numBytes] == '\0'). */
     const char *trim,	/* String of trim characters... */
-    size_t numTrim)	/* ...and its length in bytes */
+    Tcl_Size numTrim)	/* ...and its length in bytes */
 			/* Calls to TclUtfToUniChar() in this routine
 			 * rely on (trim[numTrim] == '\0'). */
 {
@@ -1664,7 +1664,7 @@ TclTrimRight(
 
     do {
 	const char *q = trim;
-	size_t pInc = 0, bytesLeft = numTrim;
+	Tcl_Size pInc = 0, bytesLeft = numTrim;
 
 	pp = Tcl_UtfPrev(p, bytes);
 	do {
@@ -1718,14 +1718,14 @@ TclTrimRight(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 TclTrimLeft(
     const char *bytes,	/* String to be trimmed... */
-    size_t numBytes,	/* ...and its length in bytes */
+    Tcl_Size numBytes,	/* ...and its length in bytes */
 			/* Calls to TclUtfToUniChar() in this routine
 			 * rely on (bytes[numBytes] == '\0'). */
     const char *trim,	/* String of trim characters... */
-    size_t numTrim)	/* ...and its length in bytes */
+    Tcl_Size numTrim)	/* ...and its length in bytes */
 			/* Calls to TclUtfToUniChar() in this routine
 			 * rely on (trim[numTrim] == '\0'). */
 {
@@ -1742,16 +1742,16 @@ TclTrimLeft(
      */
 
     do {
-	size_t pInc = TclUtfToUCS4(p, &ch1);
+	Tcl_Size pInc = TclUtfToUCS4(p, &ch1);
 	const char *q = trim;
-	size_t bytesLeft = numTrim;
+	Tcl_Size bytesLeft = numTrim;
 
 	/*
 	 * Inner loop: scan trim string for match to current character.
 	 */
 
 	do {
-	    size_t qInc = TclUtfToUCS4(q, &ch2);
+	    Tcl_Size qInc = TclUtfToUCS4(q, &ch2);
 
 	    if (ch1 == ch2) {
 		break;
@@ -1792,19 +1792,19 @@ TclTrimLeft(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 TclTrim(
     const char *bytes,	/* String to be trimmed... */
-    size_t numBytes,	/* ...and its length in bytes */
+    Tcl_Size numBytes,	/* ...and its length in bytes */
 			/* Calls in this routine
 			 * rely on (bytes[numBytes] == '\0'). */
     const char *trim,	/* String of trim characters... */
-    size_t numTrim,	/* ...and its length in bytes */
+    Tcl_Size numTrim,	/* ...and its length in bytes */
 			/* Calls in this routine
 			 * rely on (trim[numTrim] == '\0'). */
-    size_t *trimRightPtr)	/* Offset from the end of the string. */
+    Tcl_Size *trimRightPtr)	/* Offset from the end of the string. */
 {
-    size_t trimLeft = 0, trimRight = 0;
+    Tcl_Size trimLeft = 0, trimRight = 0;
 
     /* Empty strings -> nothing to do */
     if ((numBytes > 0) && (numTrim > 0)) {
@@ -1856,10 +1856,10 @@ TclTrim(
 
 char *
 Tcl_Concat(
-    size_t argc,			/* Number of strings to concatenate. */
+    Tcl_Size argc,			/* Number of strings to concatenate. */
     const char *const *argv)	/* Array of strings to concatenate. */
 {
-    size_t i, needSpace = 0, bytesNeeded = 0;
+    Tcl_Size i, needSpace = 0, bytesNeeded = 0;
     char *result, *p;
 
     /*
@@ -1887,7 +1887,7 @@ Tcl_Concat(
     result = (char *)Tcl_Alloc(bytesNeeded + argc);
 
     for (p = result, i = 0;  i < argc;  i++) {
-	size_t triml, trimr, elemLength;
+	Tcl_Size triml, trimr, elemLength;
 	const char *element;
 
 	element = argv[i];
@@ -1945,11 +1945,11 @@ Tcl_Concat(
 
 Tcl_Obj *
 Tcl_ConcatObj(
-    size_t objc,			/* Number of objects to concatenate. */
+    Tcl_Size objc,		/* Number of objects to concatenate. */
     Tcl_Obj *const objv[])	/* Array of objects to concatenate. */
 {
     int needSpace = 0;
-    size_t i, bytesNeeded = 0, elemLength;
+    Tcl_Size i, bytesNeeded = 0, elemLength;
     const char *element;
     Tcl_Obj *objPtr, *resPtr;
 
@@ -1960,7 +1960,7 @@ Tcl_ConcatObj(
      */
 
     for (i = 0;  i < objc;  i++) {
-	size_t length;
+	Tcl_Size length;
 
 	objPtr = objv[i];
 	if (TclListObjIsCanonical(objPtr)) {
@@ -2025,7 +2025,7 @@ Tcl_ConcatObj(
     Tcl_SetObjLength(resPtr, 0);
 
     for (i = 0;  i < objc;  i++) {
-	size_t triml, trimr;
+	Tcl_Size triml, trimr;
 
 	element = Tcl_GetStringFromObj(objv[i], &elemLength);
 
@@ -2316,11 +2316,11 @@ Tcl_StringCaseMatch(
 int
 TclByteArrayMatch(
     const unsigned char *string,/* String. */
-    size_t strLen,			/* Length of String */
+    Tcl_Size strLen,			/* Length of String */
     const unsigned char *pattern,
 				/* Pattern, which may contain special
 				 * characters. */
-    size_t ptnLen,			/* Length of Pattern */
+    Tcl_Size ptnLen,			/* Length of Pattern */
     TCL_UNUSED(int) /*flags*/)
 {
     const unsigned char *stringEnd, *patternEnd;
@@ -2498,7 +2498,7 @@ TclStringMatchObj(
 				 * 0. */
 {
     int match;
-    size_t length = 0, plen = 0;
+    Tcl_Size length = 0, plen = 0;
 
     /*
      * Promote based on the type of incoming object.
@@ -2578,11 +2578,11 @@ Tcl_DStringAppend(
     Tcl_DString *dsPtr,		/* Structure describing dynamic string. */
     const char *bytes,		/* String to append. If length is
 				 * TCL_INDEX_NONE then this must be null-terminated. */
-    size_t length)			/* Number of bytes from "bytes" to append. If
+    Tcl_Size length)		/* Number of bytes from "bytes" to append. If
 				 * TCL_INDEX_NONE, then append all of bytes, up to null
 				 * at end. */
 {
-    size_t newSize;
+    Tcl_Size newSize;
 
     if (length == TCL_INDEX_NONE) {
 	length = strlen(bytes);
@@ -2603,7 +2603,7 @@ Tcl_DStringAppend(
 	    memcpy(newString, dsPtr->string, dsPtr->length);
 	    dsPtr->string = newString;
 	} else {
-	    size_t index = TCL_INDEX_NONE;
+	    Tcl_Size index = TCL_INDEX_NONE;
 
 	    /* See [16896d49fd] */
 	    if (bytes >= dsPtr->string
@@ -2645,7 +2645,7 @@ TclDStringAppendObj(
     Tcl_DString *dsPtr,
     Tcl_Obj *objPtr)
 {
-    size_t length;
+    Tcl_Size length;
     const char *bytes = Tcl_GetStringFromObj(objPtr, &length);
 
     return Tcl_DStringAppend(dsPtr, bytes, length);
@@ -2688,7 +2688,7 @@ Tcl_DStringAppendElement(
     int needSpace = TclNeedSpace(dsPtr->string, dst);
     char flags = 0;
     int quoteHash = 1;
-    size_t newSize;
+    Tcl_Size newSize;
 
     if (needSpace) {
 	/*
@@ -2789,9 +2789,9 @@ Tcl_DStringAppendElement(
 void
 Tcl_DStringSetLength(
     Tcl_DString *dsPtr,		/* Structure describing dynamic string. */
-    size_t length)			/* New length for dynamic string. */
+    Tcl_Size length)			/* New length for dynamic string. */
 {
-    size_t newsize;
+    Tcl_Size newsize;
 
     if (length >= dsPtr->spaceAvl) {
 	/*
@@ -3268,14 +3268,14 @@ TclNeedSpace(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 TclFormatInt(
     char *buffer,		/* Points to the storage into which the
 				 * formatted characters are written. */
     Tcl_WideInt n)			/* The integer to format. */
 {
     Tcl_WideUInt intVal;
-    size_t i = 0, numFormatted, j;
+    Tcl_Size i = 0, numFormatted, j;
     static const char digits[] = "0123456789";
 
     /*
@@ -3338,7 +3338,7 @@ GetWideForIndex(
 				 * NULL, then no error message is left after
 				 * errors. */
     Tcl_Obj *objPtr,            /* Points to the value to be parsed */
-    size_t endValue,            /* The value to be stored at *widePtr if
+    Tcl_Size endValue,            /* The value to be stored at *widePtr if
 				 * objPtr holds "end".
                                  * NOTE: this value may be TCL_INDEX_NONE. */
     Tcl_WideInt *widePtr)       /* Location filled in with a wide integer
@@ -3402,9 +3402,8 @@ Tcl_GetIntForIndex(
 				 * errors. */
     Tcl_Obj *objPtr,		/* Points to an object containing either "end"
 				 * or an integer. */
-    size_t endValue,		/* The value to be stored at "indexPtr" if
-				 * "objPtr" holds "end". */
-    size_t *indexPtr)		/* Location filled in with an integer
+    Tcl_Size endValue,		/* The value corresponding to the "end" index */
+    Tcl_Size *indexPtr)		/* Location filled in with an integer
 				 * representing an index. May be NULL.*/
 {
     Tcl_WideInt wide;
@@ -3418,7 +3417,7 @@ Tcl_GetIntForIndex(
 	} else if ((Tcl_WideUInt)wide > TCL_INDEX_END && (endValue < TCL_INDEX_END)) {
 	    *indexPtr = TCL_INDEX_END;
 	} else {
-	    *indexPtr = (size_t) wide;
+	    *indexPtr = (Tcl_Size) wide;
 	}
     }
     return TCL_OK;
@@ -3455,7 +3454,7 @@ static int
 GetEndOffsetFromObj(
     Tcl_Interp *interp,
     Tcl_Obj *objPtr,            /* Pointer to the object to parse */
-    size_t endValue,            /* The value to be stored at "indexPtr" if
+    Tcl_Size endValue,          /* The value to be stored at "widePtr" if
                                  * "objPtr" holds "end". */
     Tcl_WideInt *widePtr)       /* Location filled in with an integer
                                  * representing an index. */
@@ -3466,7 +3465,7 @@ GetEndOffsetFromObj(
 
     while ((irPtr = TclFetchInternalRep(objPtr, &endOffsetType.objType)) == NULL) {
 	Tcl_ObjInternalRep ir;
-	size_t length;
+	Tcl_Size length;
 	const char *bytes = Tcl_GetStringFromObj(objPtr, &length);
 
 	if (*bytes != 'e') {
@@ -3744,8 +3743,8 @@ int
 TclIndexEncode(
     Tcl_Interp *interp,	/* For error reporting, may be NULL */
     Tcl_Obj *objPtr,	/* Index value to parse */
-    size_t before,		/* Value to return for index before beginning */
-    size_t after,		/* Value to return for index after end */
+    Tcl_Size before,		/* Value to return for index before beginning */
+    Tcl_Size after,		/* Value to return for index after end */
     int *indexPtr)	/* Where to write the encoded answer, not NULL */
 {
     Tcl_WideInt wide;
@@ -3761,8 +3760,8 @@ TclIndexEncode(
 	 * We parsed an end+offset index value.
 	 * wide holds the offset value in the range WIDE_MIN...WIDE_MAX.
 	 */
-	if ((irPtr ? ((wide < INT_MIN) && ((size_t)-wide <= LIST_MAX))
-		: ((wide > INT_MAX) && ((size_t)wide <= LIST_MAX))) && (sizeof(int) != sizeof(size_t))) {
+	if ((irPtr ? ((wide < INT_MIN) && ((Tcl_Size)-wide <= LIST_MAX))
+		: ((wide > INT_MAX) && ((Tcl_Size)wide <= LIST_MAX))) && (sizeof(int) != sizeof(Tcl_Size))) {
 	    if (interp) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"index \"%s\" out of range",
@@ -3806,10 +3805,10 @@ TclIndexEncode(
  *----------------------------------------------------------------------
  */
 
-size_t
+Tcl_Size
 TclIndexDecode(
     int encoded,	/* Value to decode */
-    size_t endValue)	/* Meaning of "end" to use, > TCL_INDEX_END */
+    Tcl_Size endValue)	/* Meaning of "end" to use, > TCL_INDEX_END */
 {
     if (encoded > (int)TCL_INDEX_END) {
 	return encoded;
@@ -4010,7 +4009,7 @@ TclGetProcessGlobalValue(
     Tcl_Obj *value = NULL;
     Tcl_HashTable *cacheMap;
     Tcl_HashEntry *hPtr;
-    size_t epoch = pgvPtr->epoch;
+    Tcl_Size epoch = pgvPtr->epoch;
 
     if (pgvPtr->encoding) {
 	Tcl_Encoding current = Tcl_GetEncoding(NULL, NULL);
@@ -4217,7 +4216,7 @@ int
 TclReToGlob(
     Tcl_Interp *interp,
     const char *reStr,
-    size_t reStrLen,
+    Tcl_Size reStrLen,
     Tcl_DString *dsPtr,
     int *exactPtr,
     int *quantifiersFoundPtr)