Fully functional now, with a lot of examples for the improvement. Also, merge trunk

27 files changed, 107 insertions, 129 deletions

diff --git a/generic/tclAssembly.c b/generic/tclAssembly.c
index 6575934..6d436ef 100644
--- a/generic/tclAssembly.c
+++ b/generic/tclAssembly.c
@@ -3088,7 +3088,6 @@ ResolveJumpTableTargets(
 				 * the actual code */
     BasicBlock* jumpTargetBBPtr;
 				/* Basic block that the jump proceeds to */
-    int junk;
 
     auxDataIndex = TclGetInt4AtPtr(envPtr->codeStart + bbPtr->jumpOffset + 1);
     DEBUG_PRINT("bbPtr = %p jumpOffset = %d auxDataIndex = %d\n",
@@ -3112,7 +3111,7 @@ ResolveJumpTableTargets(
 	jumpTargetBBPtr = (BasicBlock*)Tcl_GetHashValue(valEntryPtr);
 
 	realJumpEntryPtr = Tcl_CreateHashEntry(realJumpHashPtr,
-		Tcl_GetHashKey(symHash, symEntryPtr), &junk);
+		Tcl_GetHashKey(symHash, symEntryPtr), NULL);
 	DEBUG_PRINT("  %s -> %s -> bb %p (pc %d)    hash entry %p\n",
 		(char *)Tcl_GetHashKey(symHash, symEntryPtr),
 		TclGetString(symbolObj), jumpTargetBBPtr,
diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index 3cbf091..e82c4d9 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -9707,11 +9707,10 @@ TclNRCoroutineObjCmd(
 
 	for (hePtr = Tcl_FirstHashEntry(iPtr->lineLABCPtr,&hSearch);
 		hePtr; hePtr = Tcl_NextHashEntry(&hSearch)) {
-	    int isNew;
 	    Tcl_HashEntry *newPtr =
 		    Tcl_CreateHashEntry(corPtr->lineLABCPtr,
 		    Tcl_GetHashKey(iPtr->lineLABCPtr, hePtr),
-		    &isNew);
+		    NULL);
 
 	    Tcl_SetHashValue(newPtr, Tcl_GetHashValue(hePtr));
 	}
diff --git a/generic/tclCmdIL.c b/generic/tclCmdIL.c
index 429daec..6184a43 100644
--- a/generic/tclCmdIL.c
+++ b/generic/tclCmdIL.c
@@ -818,7 +818,7 @@ InfoCommandsCmd(
 		elemObjPtr = Tcl_NewStringObj(cmdName, -1);
 		Tcl_ListObjAppendElement(interp, listPtr, elemObjPtr);
 		(void) Tcl_CreateHashEntry(&addedCommandsTable,
-			elemObjPtr, &isNew);
+			elemObjPtr, NULL);
 	    }
 	    entryPtr = Tcl_NextHashEntry(&search);
 	}
diff --git a/generic/tclCompCmdsSZ.c b/generic/tclCompCmdsSZ.c
index 313cb58..f84547e 100644
--- a/generic/tclCompCmdsSZ.c
+++ b/generic/tclCompCmdsSZ.c
@@ -2558,13 +2558,12 @@ DupJumptableInfo(
     JumptableInfo *newJtPtr = (JumptableInfo *)Tcl_Alloc(sizeof(JumptableInfo));
     Tcl_HashEntry *hPtr, *newHPtr;
     Tcl_HashSearch search;
-    int isNew;
 
     Tcl_InitHashTable(&newJtPtr->hashTable, TCL_STRING_KEYS);
     hPtr = Tcl_FirstHashEntry(&jtPtr->hashTable, &search);
     for (; hPtr ; hPtr = Tcl_NextHashEntry(&search)) {
 	newHPtr = Tcl_CreateHashEntry(&newJtPtr->hashTable,
-		Tcl_GetHashKey(&jtPtr->hashTable, hPtr), &isNew);
+		Tcl_GetHashKey(&jtPtr->hashTable, hPtr), NULL);
 	Tcl_SetHashValue(newHPtr, Tcl_GetHashValue(hPtr));
     }
     return newJtPtr;
diff --git a/generic/tclCompile.c b/generic/tclCompile.c
index be38697..6d1946a 100644
--- a/generic/tclCompile.c
+++ b/generic/tclCompile.c
@@ -1045,8 +1045,8 @@ CleanupByteCode(
 {
     Tcl_Interp *interp = (Tcl_Interp *) *codePtr->interpHandle;
     Interp *iPtr = (Interp *) interp;
-    int numLitObjects = codePtr->numLitObjects;
-    int numAuxDataItems = codePtr->numAuxDataItems;
+    Tcl_Size numLitObjects = codePtr->numLitObjects;
+    Tcl_Size numAuxDataItems = codePtr->numAuxDataItems;
     Tcl_Obj **objArrayPtr, *objPtr;
     const AuxData *auxDataPtr;
     int i;
@@ -1055,7 +1055,7 @@ CleanupByteCode(
     if (interp != NULL) {
 	ByteCodeStats *statsPtr;
 	Tcl_Time destroyTime;
-	int lifetimeSec, lifetimeMicroSec, log2;
+	long long lifetimeSec, lifetimeMicroSec;
 
 	statsPtr = &iPtr->stats;
 
@@ -1065,7 +1065,7 @@ CleanupByteCode(
 
 	statsPtr->currentInstBytes -= (double) codePtr->numCodeBytes;
 	statsPtr->currentLitBytes -= (double)
-		codePtr->numLitObjects * sizeof(Tcl_Obj *);
+		numLitObjects * sizeof(Tcl_Obj *);
 	statsPtr->currentExceptBytes -= (double)
 		codePtr->numExceptRanges * sizeof(ExceptionRange);
 	statsPtr->currentAuxBytes -= (double)
@@ -1074,17 +1074,9 @@ CleanupByteCode(
 
 	Tcl_GetTime(&destroyTime);
 	lifetimeSec = destroyTime.sec - codePtr->createTime.sec;
-	if (lifetimeSec > 2000) {	/* avoid overflow */
-	    lifetimeSec = 2000;
-	}
 	lifetimeMicroSec = 1000000 * lifetimeSec +
 		(destroyTime.usec - codePtr->createTime.usec);
-
-	log2 = TclLog2(lifetimeMicroSec);
-	if (log2 > 31) {
-	    log2 = 31;
-	}
-	statsPtr->lifetimeCount[log2]++;
+	statsPtr->lifetimeCount[TclLog2(lifetimeMicroSec)]++;
     }
 #endif /* TCL_COMPILE_STATS */
 
@@ -2757,10 +2749,10 @@ TclCompileNoOp(
     CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
     Tcl_Token *tokenPtr;
-    int i;
+    Tcl_Size i;
 
     tokenPtr = parsePtr->tokenPtr;
-    for (i = 1; i < (int)parsePtr->numWords; i++) {
+    for (i = 1; i < parsePtr->numWords; i++) {
 	tokenPtr = tokenPtr + tokenPtr->numComponents + 1;
 
 	if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
@@ -2841,9 +2833,8 @@ TclInitByteCode(
 #ifdef TCL_COMPILE_DEBUG
     unsigned char *nextPtr;
 #endif
-    int numLitObjects = envPtr->literalArrayNext;
+    Tcl_Size i, numLitObjects = envPtr->literalArrayNext;
     Namespace *namespacePtr;
-    int i, isNew;
     Interp *iPtr;
 
     if (envPtr->iPtr == NULL) {
@@ -2960,7 +2951,7 @@ TclInitByteCode(
      */
 
     Tcl_SetHashValue(Tcl_CreateHashEntry(iPtr->lineBCPtr, codePtr,
-	    &isNew), envPtr->extCmdMapPtr);
+	    NULL), envPtr->extCmdMapPtr);
     envPtr->extCmdMapPtr = NULL;
 
     /* We've used up the CompileEnv.  Mark as uninitialized. */
@@ -4573,8 +4564,8 @@ RecordByteCodeStats(
     statsPtr->currentSrcBytes += (double) (int)codePtr->numSrcBytes;
     statsPtr->currentByteCodeBytes += (double) codePtr->structureSize;
 
-    statsPtr->srcCount[TclLog2((int)codePtr->numSrcBytes)]++;
-    statsPtr->byteCodeCount[TclLog2((int) codePtr->structureSize)]++;
+    statsPtr->srcCount[TclLog2(codePtr->numSrcBytes)]++;
+    statsPtr->byteCodeCount[TclLog2(codePtr->structureSize)]++;
 
     statsPtr->currentInstBytes += (double) codePtr->numCodeBytes;
     statsPtr->currentLitBytes += (double)
diff --git a/generic/tclCompile.h b/generic/tclCompile.h
index f0d26dd..c4b6f65 100644
--- a/generic/tclCompile.h
+++ b/generic/tclCompile.h
@@ -873,7 +873,7 @@ typedef enum InstOperandType {
 
 typedef struct InstructionDesc {
     const char *name;		/* Name of instruction. */
-    Tcl_Size numBytes;		/* Total number of bytes for instruction. */
+    int numBytes;		/* Total number of bytes for instruction. */
     int stackEffect;		/* The worst-case balance stack effect of the
 				 * instruction, used for stack requirements
 				 * computations. The value INT_MIN signals
@@ -1154,7 +1154,7 @@ MODULE_SCOPE void	TclFinalizeLoopExceptionRange(CompileEnv *envPtr,
 			    int range);
 #ifdef TCL_COMPILE_STATS
 MODULE_SCOPE char *	TclLiteralStats(LiteralTable *tablePtr);
-MODULE_SCOPE int	TclLog2(int value);
+MODULE_SCOPE int	TclLog2(long long value);
 #endif
 MODULE_SCOPE size_t	TclLocalScalar(const char *bytes, size_t numBytes,
 			    CompileEnv *envPtr);
diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index 0f7a6c5..877a950 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -881,7 +881,7 @@ Tcl_GetEncodingNames(
     Tcl_HashEntry *hPtr;
     Tcl_Obj *map, *name, *result;
     Tcl_DictSearch mapSearch;
-    int dummy, done = 0;
+    int done = 0;
 
     TclNewObj(result);
     Tcl_InitObjHashTable(&table);
@@ -896,7 +896,7 @@ Tcl_GetEncodingNames(
 	Encoding *encodingPtr = (Encoding *)Tcl_GetHashValue(hPtr);
 
 	Tcl_CreateHashEntry(&table,
-		Tcl_NewStringObj(encodingPtr->name, TCL_INDEX_NONE), &dummy);
+		Tcl_NewStringObj(encodingPtr->name, TCL_INDEX_NONE), NULL);
     }
     Tcl_MutexUnlock(&encodingMutex);
 
@@ -909,7 +909,7 @@ Tcl_GetEncodingNames(
 
     Tcl_DictObjFirst(NULL, map, &mapSearch, &name, NULL, &done);
     for (; !done; Tcl_DictObjNext(&mapSearch, &name, NULL, &done)) {
-	Tcl_CreateHashEntry(&table, name, &dummy);
+	Tcl_CreateHashEntry(&table, name, NULL);
     }
 
     /*
diff --git a/generic/tclEnsemble.c b/generic/tclEnsemble.c
index c3e26e2..9dae910 100644
--- a/generic/tclEnsemble.c
+++ b/generic/tclEnsemble.c
@@ -2744,7 +2744,7 @@ BuildEnsembleConfig(
 	while (!done) {
 	    const char *name = TclGetString(keyObj);
 
-	    hPtr = Tcl_CreateHashEntry(hash, name, &isNew);
+	    hPtr = Tcl_CreateHashEntry(hash, name, NULL);
 	    Tcl_SetHashValue(hPtr, valueObj);
 	    Tcl_IncrRefCount(valueObj);
 	    Tcl_DictObjNext(&dictSearch, &keyObj, &valueObj, &done);
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index 0cee5fa..a1f2056 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -170,7 +170,7 @@ VarHashCreateVar(
 }
 
 #define VarHashFindVar(tablePtr, key) \
-    VarHashCreateVar((tablePtr), (key), NULL)
+    VarHashCreateVar((tablePtr), (key), TCL_HASH_FIND)
 
 /*
  * The new macro for ending an instruction; note that a reasonable C-optimiser
@@ -378,8 +378,8 @@ VarHashCreateVar(
 #ifdef TCL_COMPILE_DEBUG
 #   define TRACE(a) \
     while (traceInstructions) {						\
-	fprintf(stdout, "%2" TCL_SIZE_MODIFIER "d: %2" TCL_T_MODIFIER	\
-		"d (%" TCL_T_MODIFIER "d) %s ", iPtr->numLevels,	\
+	fprintf(stdout, "%2" TCL_SIZE_MODIFIER "d: %2" TCL_SIZE_MODIFIER	\
+		"d (%" TCL_SIZE_MODIFIER "d) %s ", iPtr->numLevels,	\
 		CURR_DEPTH,						\
 		(pc - codePtr->codeStart),				\
 		GetOpcodeName(pc));					\
@@ -395,8 +395,8 @@ VarHashCreateVar(
     TRACE_APPEND(("ERROR: %.30s\n", O2S(Tcl_GetObjResult(interp))));
 #   define TRACE_WITH_OBJ(a, objPtr) \
     while (traceInstructions) {						\
-	fprintf(stdout, "%2" TCL_SIZE_MODIFIER "d: %2" TCL_T_MODIFIER	\
-		"d (%" TCL_T_MODIFIER "d) %s ", iPtr->numLevels,	\
+	fprintf(stdout, "%2" TCL_SIZE_MODIFIER "d: %2" TCL_SIZE_MODIFIER	\
+		"d (%" TCL_SIZE_MODIFIER "d) %s ", iPtr->numLevels,	\
 		CURR_DEPTH,						\
 		(pc - codePtr->codeStart),				\
 		GetOpcodeName(pc));					\
@@ -423,23 +423,23 @@ VarHashCreateVar(
     do {								\
 	if (TCL_DTRACE_INST_DONE_ENABLED()) {				\
 	    if (curInstName) {						\
-		TCL_DTRACE_INST_DONE(curInstName, (int) CURR_DEPTH,	\
+		TCL_DTRACE_INST_DONE(curInstName, CURR_DEPTH,	\
 			tosPtr);					\
 	    }								\
 	    curInstName = tclInstructionTable[*pc].name;		\
 	    if (TCL_DTRACE_INST_START_ENABLED()) {			\
-		TCL_DTRACE_INST_START(curInstName, (int) CURR_DEPTH,	\
+		TCL_DTRACE_INST_START(curInstName, CURR_DEPTH,	\
 			tosPtr);					\
 	    }								\
 	} else if (TCL_DTRACE_INST_START_ENABLED()) {			\
 	    TCL_DTRACE_INST_START(tclInstructionTable[*pc].name,	\
-			(int) CURR_DEPTH, tosPtr);			\
+			CURR_DEPTH, tosPtr);			\
 	}								\
     } while (0)
 #define TCL_DTRACE_INST_LAST() \
     do {								\
 	if (TCL_DTRACE_INST_DONE_ENABLED() && curInstName) {		\
-	    TCL_DTRACE_INST_DONE(curInstName, (int) CURR_DEPTH, tosPtr);\
+	    TCL_DTRACE_INST_DONE(curInstName, CURR_DEPTH, tosPtr);\
 	}								\
     } while (0)
 
@@ -2061,7 +2061,7 @@ TEBCresume(
 #ifdef TCL_COMPILE_DEBUG
     if (!pc && (tclTraceExec >= 2)) {
 	PrintByteCodeInfo(codePtr);
-	fprintf(stdout, "  Starting stack top=%" TCL_T_MODIFIER "d\n", CURR_DEPTH);
+	fprintf(stdout, "  Starting stack top=%" TCL_SIZE_MODIFIER "d\n", CURR_DEPTH);
 	fflush(stdout);
     }
 #endif
@@ -2265,7 +2265,7 @@ TEBCresume(
 
     CHECK_STACK();
     if (traceInstructions) {
-	fprintf(stdout, "%2" TCL_SIZE_MODIFIER "d: %2" TCL_T_MODIFIER "d ", iPtr->numLevels, CURR_DEPTH);
+	fprintf(stdout, "%2" TCL_SIZE_MODIFIER "d: %2" TCL_SIZE_MODIFIER "d ", iPtr->numLevels, CURR_DEPTH);
 	TclPrintInstruction(codePtr, pc);
 	fflush(stdout);
     }
@@ -2639,7 +2639,7 @@ TEBCresume(
 	objPtr->internalRep.twoPtrValue.ptr2 = INT2PTR(CURR_DEPTH);
 	objPtr->length = 0;
 	PUSH_TAUX_OBJ(objPtr);
-	TRACE(("=> mark depth as %" TCL_T_MODIFIER "d\n", CURR_DEPTH));
+	TRACE(("=> mark depth as %" TCL_SIZE_MODIFIER "d\n", CURR_DEPTH));
 	NEXT_INST_F(1, 0, 0);
     break;
 
@@ -2843,10 +2843,10 @@ TEBCresume(
 
 	    if (traceInstructions) {
 		strncpy(cmdNameBuf, TclGetString(objv[0]), 20);
-		TRACE(("%" TCL_Z_MODIFIER "u => call (implementation %s) ", objc, O2S(objPtr)));
+		TRACE(("%" TCL_SIZE_MODIFIER "u => call (implementation %s) ", objc, O2S(objPtr)));
 	    } else {
 		fprintf(stdout,
-			"%" TCL_Z_MODIFIER "d: (%" TCL_T_MODIFIER "u) invoking (using implementation %s) ",
+			"%" TCL_SIZE_MODIFIER "d: (%" TCL_T_MODIFIER "u) invoking (using implementation %s) ",
 			iPtr->numLevels, (pc - codePtr->codeStart),
 			O2S(objPtr));
 	    }
@@ -4298,7 +4298,7 @@ TEBCresume(
 	TRACE(("%d \"%.20s\" => ", opnd, O2S(OBJ_AT_TOS)));
 	hPtr = Tcl_FindHashEntry(&jtPtr->hashTable, TclGetString(OBJ_AT_TOS));
 	if (hPtr != NULL) {
-	    int jumpOffset = PTR2INT(Tcl_GetHashValue(hPtr));
+	    Tcl_Size jumpOffset = PTR2INT(Tcl_GetHashValue(hPtr));
 
 	    TRACE_APPEND(("found in table, new pc %" TCL_Z_MODIFIER "u\n",
 		    (size_t)(pc - codePtr->codeStart + jumpOffset)));
@@ -6692,7 +6692,7 @@ TEBCresume(
 	 */
 
 	*(++catchTop) = (Tcl_Obj *)INT2PTR(CURR_DEPTH);
-	TRACE(("%u => catchTop=%" TCL_T_MODIFIER "d, stackTop=%" TCL_T_MODIFIER "d\n",
+	TRACE(("%u => catchTop=%" TCL_T_MODIFIER "d, stackTop=%" TCL_SIZE_MODIFIER "d\n",
 		TclGetUInt4AtPtr(pc+1), (catchTop - initCatchTop - 1),
 		CURR_DEPTH));
 	NEXT_INST_F(5, 0, 0);
@@ -7727,7 +7727,7 @@ TEBCresume(
 	if (tosPtr < initTosPtr) {
 	    fprintf(stderr,
 		    "\nTclNRExecuteByteCode: abnormal return at pc %" TCL_T_MODIFIER "d: "
-		    "stack top %" TCL_T_MODIFIER "d < entry stack top %d\n",
+		    "stack top %" TCL_SIZE_MODIFIER "d < entry stack top %d\n",
 		    (pc - codePtr->codeStart),
 		    CURR_DEPTH, 0);
 	    Tcl_Panic("TclNRExecuteByteCode execution failure: end stack top < start stack top");
@@ -9560,14 +9560,32 @@ TclExprFloatError(
 
 int
 TclLog2(
-    int value)			/* The integer for which to compute the log
-				 * base 2. */
+    long long value)			/* The integer for which to compute the log
+				 * base 2. The maximum output is 31 */
 {
-    int n = value;
     int result = 0;
 
-    while (n > 1) {
-	n = n >> 1;
+    if (value > 0x7FFFFF) {
+	return 31;
+    }
+    if (value > 0xFFFF) {
+	value >>= 16;
+	result += 16;
+    }
+    if (value > 0xFF) {
+	value >>= 8;
+	result += 8;
+    }
+    if (value > 0xF) {
+	value >>= 4;
+	result += 4;
+    }
+    if (value > 0x3) {
+	value >>= 2;
+	result += 2;
+    }
+    if (value > 0x1) {
+	value >>= 1;
 	result++;
     }
     return result;
diff --git a/generic/tclHash.c b/generic/tclHash.c
index 6cce4c0..518ba93 100644
--- a/generic/tclHash.c
+++ b/generic/tclHash.c
@@ -209,7 +209,7 @@ FindHashEntry(
     Tcl_HashTable *tablePtr,	/* Table in which to lookup entry. */
     const char *key)		/* Key to use to find matching entry. */
 {
-    return tablePtr->createProc(tablePtr, key, (int *)-1);
+    return tablePtr->createProc(tablePtr, key, TCL_HASH_FIND);
 }
 
 /*
@@ -244,9 +244,6 @@ CreateHashEntry(
     Tcl_HashEntry *hPtr;
     const Tcl_HashKeyType *typePtr;
     size_t hash, index;
-    if (newPtr == NULL) {
-    	Tcl_Panic("newPtr == NULL");
-    }
 
     if (tablePtr->keyType == TCL_STRING_KEYS) {
 	typePtr = &tclStringHashKeyType;
@@ -286,7 +283,7 @@ CreateHashEntry(
 		/* if keys pointers or values are equal */
 		if ((key == hPtr->key.oneWordValue)
 		    || compareKeysProc((void *) key, hPtr)) {
-		    if (newPtr && (newPtr != (int *)-1)) {
+		    if (newPtr && (newPtr != TCL_HASH_FIND)) {
 			*newPtr = 0;
 		    }
 		    return hPtr;
@@ -301,7 +298,7 @@ CreateHashEntry(
 		/* if needle pointer equals content pointer or values equal */
 		if ((key == hPtr->key.string)
 			|| compareKeysProc((void *) key, hPtr)) {
-		    if (newPtr && (newPtr != (int *)-1)) {
+		    if (newPtr && (newPtr != TCL_HASH_FIND)) {
 			*newPtr = 0;
 		    }
 		    return hPtr;
@@ -315,7 +312,7 @@ CreateHashEntry(
 		continue;
 	    }
 	    if (key == hPtr->key.oneWordValue) {
-		if (newPtr && (newPtr != (int *)-1)) {
+		if (newPtr && (newPtr != TCL_HASH_FIND)) {
 		    *newPtr = 0;
 		}
 		return hPtr;
@@ -323,7 +320,7 @@ CreateHashEntry(
 	}
     }
 
-    if (newPtr == (int *)-1) {
+    if (newPtr == TCL_HASH_FIND) {
 	/* This is the findProc functionality, so we are done. */
 	return NULL;
     }
@@ -904,7 +901,7 @@ BogusCreate(
     int *isNew)
 {
     Tcl_Panic("called %s on deleted table",
-	    (isNew && (isNew != (int *)-1))? "Tcl_CreateHashEntry" : "Tcl_FindHashEntry");
+	    (isNew != TCL_HASH_FIND)? "Tcl_CreateHashEntry" : "Tcl_FindHashEntry");
     return NULL;
 }
 
diff --git a/generic/tclIORChan.c b/generic/tclIORChan.c
index 5fc414a..742aae8 100644
--- a/generic/tclIORChan.c
+++ b/generic/tclIORChan.c
@@ -722,7 +722,7 @@ TclChanCreateObjCmd(
 #if TCL_THREADS
     rcmPtr = GetThreadReflectedChannelMap();
     hPtr = Tcl_CreateHashEntry(&rcmPtr->map, chanPtr->state->channelName,
-	    &isNew);
+	    NULL);
     Tcl_SetHashValue(hPtr, chan);
 #endif
 
diff --git a/generic/tclIORTrans.c b/generic/tclIORTrans.c
index ad55a39..10b5074 100644
--- a/generic/tclIORTrans.c
+++ b/generic/tclIORTrans.c
@@ -695,7 +695,7 @@ TclChanPushObjCmd(
     Tcl_SetHashValue(hPtr, rtPtr);
 #if TCL_THREADS
     rtmPtr = GetThreadReflectedTransformMap();
-    hPtr = Tcl_CreateHashEntry(&rtmPtr->map, TclGetString(rtId), &isNew);
+    hPtr = Tcl_CreateHashEntry(&rtmPtr->map, TclGetString(rtId), NULL);
     Tcl_SetHashValue(hPtr, rtPtr);
 #endif /* TCL_THREADS */
 
diff --git a/generic/tclInt.h b/generic/tclInt.h
index c124219..8a1d30a 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -222,20 +222,6 @@ typedef struct TclVarHashTable {
 				 * are variables in an array at all. */
 } TclVarHashTable;
 
-/*
- * This is for itcl - it likes to search our varTables directly :(
- */
-
-#define TclVarHashFindVar(tablePtr, key) \
-    TclVarHashCreateVar((tablePtr), (key), NULL)
-
-/*
- * Define this to reduce the amount of space that the average namespace
- * consumes by only allocating the table of child namespaces when necessary.
- * Defining it breaks compatibility for Tcl extensions (e.g., itcl) which
- * reach directly into the Namespace structure.
- */
-
 #undef BREAK_NAMESPACE_COMPAT
 
 /*
@@ -752,6 +738,8 @@ typedef struct VarInHash {
 #define VAR_IS_ARGS		0x400
 #define VAR_RESOLVED		0x8000
 
+#define TCL_HASH_FIND	((int *)-1)
+
 /*
  * Macros to ensure that various flag bits are set properly for variables.
  * The ANSI C "prototypes" for these macros are:
diff --git a/generic/tclNamesp.c b/generic/tclNamesp.c
index 8e95f89..80c5584 100644
--- a/generic/tclNamesp.c
+++ b/generic/tclNamesp.c
@@ -199,18 +199,17 @@ static const EnsembleImplMap defaultNamespaceMap[] = {
 static inline Tcl_HashEntry *
 CreateChildEntry(
     Namespace *nsPtr,		/* Parent namespace. */
-    const char *name,		/* Simple name to look for. */
-    int *isNewPtr)		/* Pointer to var with whether this is new. */
+    const char *name)		/* Simple name to look for. */
 {
 #ifndef BREAK_NAMESPACE_COMPAT
-    return Tcl_CreateHashEntry(&nsPtr->childTable, name, isNewPtr);
+    return Tcl_CreateHashEntry(&nsPtr->childTable, name, NULL);
 #else
     if )nsPtr->childTablePtr == NULL) {
 	nsPtr->childTablePtr = (Tcl_HashTable *)
 		Tcl_Alloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(nsPtr->childTablePtr, TCL_STRING_KEYS);
     }
-    return Tcl_CreateHashEntry(nsPtr->childTablePtr, name, isNewPtr);
+    return Tcl_CreateHashEntry(nsPtr->childTablePtr, name, NULL);
 #endif
 }
 
@@ -786,7 +785,6 @@ Tcl_CreateNamespace(
     Tcl_HashEntry *entryPtr;
     Tcl_DString buffer1, buffer2;
     Tcl_DString *namePtr, *buffPtr;
-    int newEntry;
     size_t nameLen;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     const char *nameStr;
@@ -916,7 +914,7 @@ Tcl_CreateNamespace(
     nsPtr->earlyDeleteProc = NULL;
 
     if (parentPtr != NULL) {
-	entryPtr = CreateChildEntry(parentPtr, simpleName, &newEntry);
+	entryPtr = CreateChildEntry(parentPtr, simpleName);
 	Tcl_SetHashValue(entryPtr, nsPtr);
     } else {
 	/*
diff --git a/generic/tclOOCall.c b/generic/tclOOCall.c
index 04d53fc..78a2610 100644
--- a/generic/tclOOCall.c
+++ b/generic/tclOOCall.c
@@ -776,9 +776,7 @@ AddPrivateMethodNames(
 
     FOREACH_HASH(namePtr, mPtr, methodsTablePtr) {
 	if (IS_PRIVATE(mPtr)) {
-	    int isNew;
-
-	    hPtr = Tcl_CreateHashEntry(namesPtr, namePtr, &isNew);
+	    hPtr = Tcl_CreateHashEntry(namesPtr, namePtr, NULL);
 	    Tcl_SetHashValue(hPtr, INT2PTR(IN_LIST));
 	}
     }
@@ -1554,14 +1552,13 @@ TclOOGetStereotypeCallChain(
 	}
     } else {
 	if (hPtr == NULL) {
-	    int isNew;
 	    if (clsPtr->classChainCache == NULL) {
 		clsPtr->classChainCache = (Tcl_HashTable *)
 			Tcl_Alloc(sizeof(Tcl_HashTable));
 		Tcl_InitObjHashTable(clsPtr->classChainCache);
 	    }
 	    hPtr = Tcl_CreateHashEntry(clsPtr->classChainCache,
-		    methodNameObj, &isNew);
+		    methodNameObj, NULL);
 	}
 	callPtr->refCount++;
 	Tcl_SetHashValue(hPtr, callPtr);
diff --git a/generic/tclOOMethod.c b/generic/tclOOMethod.c
index 2c06822..1e219c1 100644
--- a/generic/tclOOMethod.c
+++ b/generic/tclOOMethod.c
@@ -555,7 +555,6 @@ InitCmdFrame(
 
 	    if (context.line && context.nline > 1
 		    && (context.line[context.nline - 1] >= 0)) {
-		int isNew;
 		CmdFrame *cfPtr = (CmdFrame *) Tcl_Alloc(sizeof(CmdFrame));
 		Tcl_HashEntry *hPtr;
 
@@ -574,7 +573,7 @@ InitCmdFrame(
 		cfPtr->len = 0;
 
 		hPtr = Tcl_CreateHashEntry(iPtr->linePBodyPtr,
-			procPtr, &isNew);
+			procPtr, NULL);
 		Tcl_SetHashValue(hPtr, cfPtr);
 	    }
 
diff --git a/generic/tclOOProp.c b/generic/tclOOProp.c
index 8d75aaf..bf40c2f 100644
--- a/generic/tclOOProp.c
+++ b/generic/tclOOProp.c
@@ -542,18 +542,18 @@ FindClassProps(
 				 * property set. */
     Tcl_HashTable *accumulator)	/* Where to gather the names. */
 {
-    int i, dummy;
+    int i;
     Tcl_Obj *propName;
     Class *mixin, *sup;
 
   tailRecurse:
     if (writable) {
 	FOREACH(propName, clsPtr->properties.writable) {
-	    Tcl_CreateHashEntry(accumulator, (void *) propName, &dummy);
+	    Tcl_CreateHashEntry(accumulator, (void *) propName, NULL);
 	}
     } else {
 	FOREACH(propName, clsPtr->properties.readable) {
-	    Tcl_CreateHashEntry(accumulator, (void *) propName, &dummy);
+	    Tcl_CreateHashEntry(accumulator, (void *) propName, NULL);
 	}
     }
     if (clsPtr->thisPtr->flags & ROOT_OBJECT) {
@@ -593,17 +593,17 @@ FindObjectProps(
 				 * property set. */
     Tcl_HashTable *accumulator)	/* Where to gather the names. */
 {
-    int i, dummy;
+    int i;
     Tcl_Obj *propName;
     Class *mixin;
 
     if (writable) {
 	FOREACH(propName, oPtr->properties.writable) {
-	    Tcl_CreateHashEntry(accumulator, (void *) propName, &dummy);
+	    Tcl_CreateHashEntry(accumulator, (void *) propName, NULL);
 	}
     } else {
 	FOREACH(propName, oPtr->properties.readable) {
-	    Tcl_CreateHashEntry(accumulator, (void *) propName, &dummy);
+	    Tcl_CreateHashEntry(accumulator, (void *) propName, NULL);
 	}
     }
     FOREACH(mixin, oPtr->mixins) {
diff --git a/generic/tclObj.c b/generic/tclObj.c
index 8c58c00..e086c87 100644
--- a/generic/tclObj.c
+++ b/generic/tclObj.c
@@ -810,11 +810,9 @@ Tcl_RegisterObjType(
 				 * be statically allocated (must live
 				 * forever). */
 {
-    int isNew;
-
     Tcl_MutexLock(&tableMutex);
     Tcl_SetHashValue(
-	    Tcl_CreateHashEntry(&typeTable, typePtr->name, &isNew), typePtr);
+	    Tcl_CreateHashEntry(&typeTable, typePtr->name, NULL), typePtr);
     Tcl_MutexUnlock(&tableMutex);
 }
 
diff --git a/generic/tclOptimize.c b/generic/tclOptimize.c
index cf5177a..9113fb3 100644
--- a/generic/tclOptimize.c
+++ b/generic/tclOptimize.c
@@ -387,7 +387,7 @@ AdvanceJumps(
 	case INST_JUMP_TRUE4:
 	case INST_JUMP_FALSE4:
 	    Tcl_InitHashTable(&jumps, TCL_ONE_WORD_KEYS);
-	    Tcl_CreateHashEntry(&jumps, INT2PTR(0), &isNew);
+	    Tcl_CreateHashEntry(&jumps, INT2PTR(0), NULL);
 	    for (offset = TclGetInt4AtPtr(currentInstPtr + 1); offset!=0 ;) {
 		Tcl_CreateHashEntry(&jumps, INT2PTR(offset), &isNew);
 		if (!isNew) {
diff --git a/generic/tclProc.c b/generic/tclProc.c
index d0f4cb9..59de9be 100644
--- a/generic/tclProc.c
+++ b/generic/tclProc.c
@@ -2443,7 +2443,7 @@ SetLambdaFromAny(
     Interp *iPtr = (Interp *) interp;
     const char *name;
     Tcl_Obj *argsPtr, *bodyPtr, *nsObjPtr, **objv;
-    int isNew, result;
+    int result;
     Tcl_Size objc;
     CmdFrame *cfPtr = NULL;
     Proc *procPtr;
@@ -2583,7 +2583,7 @@ SetLambdaFromAny(
 	TclStackFree(interp, contextPtr);
     }
     Tcl_SetHashValue(Tcl_CreateHashEntry(iPtr->linePBodyPtr, procPtr,
-	    &isNew), cfPtr);
+	    NULL), cfPtr);
 
     /*
      * Set the namespace for this lambda: given by objv[2] understood as a
diff --git a/generic/tclProcess.c b/generic/tclProcess.c
index bed3a60..3b7d938 100644
--- a/generic/tclProcess.c
+++ b/generic/tclProcess.c
@@ -858,7 +858,7 @@ TclProcessCreated(
 
     Tcl_SetHashValue(entry, info);
     entry = Tcl_CreateHashEntry(&infoTablePerResolvedPid, INT2PTR(resolvedPid),
-	    &isNew);
+	    NULL);
     Tcl_SetHashValue(entry, info);
 
     Tcl_MutexUnlock(&infoTablesMutex);
diff --git a/generic/tclStubInit.c b/generic/tclStubInit.c
index 74c709e..7e7c553 100644
--- a/generic/tclStubInit.c
+++ b/generic/tclStubInit.c
@@ -45,8 +45,6 @@
 #undef Tcl_SetUnicodeObj
 #undef Tcl_DumpActiveMemory
 #undef Tcl_ValidateAllMemory
-#undef Tcl_FindHashEntry
-#undef Tcl_CreateHashEntry
 #undef Tcl_Panic
 #undef Tcl_FindExecutable
 #undef Tcl_SetExitProc
diff --git a/generic/tclStubLib.c b/generic/tclStubLib.c
index bc14820..9b02c46 100644
--- a/generic/tclStubLib.c
+++ b/generic/tclStubLib.c
@@ -100,6 +100,9 @@ Tcl_InitStubs(
 
     actualVersion = stubsPtr->tcl_PkgRequireEx(interp, tclName, version, 0, &pkgData);
     if (actualVersion == NULL) {
+	/* Even when the Tcl version does not match, the caller should at least be
+	 * able to use Tcl_GetObjResult/Tcl_GetString/Tcl_Panic for error-handling */
+	tclStubsPtr = stubsPtr; /* See: [fd8341e496] */
 	return NULL;
     }
     if (exact&1) {
diff --git a/generic/tclTest.c b/generic/tclTest.c
index 3c30af5..4429454 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -8464,7 +8464,6 @@ MyCompiledVarFetch(
 {
     MyResolvedVarInfo *resVarInfo = (MyResolvedVarInfo *) vinfoPtr;
     Tcl_Var var = resVarInfo->var;
-    int isNewVar;
     Interp *iPtr = (Interp *) interp;
     Tcl_HashEntry *hPtr;
 
@@ -8485,7 +8484,7 @@ MyCompiledVarFetch(
     }
 
     hPtr = Tcl_CreateHashEntry((Tcl_HashTable *) &iPtr->globalNsPtr->varTable,
-	    resVarInfo->nameObj, &isNewVar);
+	    resVarInfo->nameObj, NULL);
     if (hPtr) {
 	var = (Tcl_Var) TclVarHashGetValue(hPtr);
     } else {
diff --git a/generic/tclUtil.c b/generic/tclUtil.c
index c28056d..be117a5 100644
--- a/generic/tclUtil.c
+++ b/generic/tclUtil.c
@@ -4135,7 +4135,6 @@ TclSetProcessGlobalValue(
     const char *bytes;
     Tcl_HashTable *cacheMap;
     Tcl_HashEntry *hPtr;
-    int dummy;
     Tcl_DString ds;
 
     Tcl_MutexLock(&pgvPtr->mutex);
@@ -4172,7 +4171,7 @@ TclSetProcessGlobalValue(
     Tcl_IncrRefCount(newValue);
     cacheMap = GetThreadHash(&pgvPtr->key);
     ClearHash(cacheMap);
-    hPtr = Tcl_CreateHashEntry(cacheMap, INT2PTR(pgvPtr->epoch), &dummy);
+    hPtr = Tcl_CreateHashEntry(cacheMap, INT2PTR(pgvPtr->epoch), NULL);
     Tcl_SetHashValue(hPtr, newValue);
     Tcl_MutexUnlock(&pgvPtr->mutex);
 }
@@ -4236,7 +4235,6 @@ TclGetProcessGlobalValue(
     cacheMap = GetThreadHash(&pgvPtr->key);
     hPtr = Tcl_FindHashEntry(cacheMap, INT2PTR(epoch));
     if (NULL == hPtr) {
-	int dummy;
 
 	/*
 	 * No cache for the current epoch - must be a new one.
@@ -4269,7 +4267,7 @@ TclGetProcessGlobalValue(
 	Tcl_ExternalToUtfDString(NULL, pgvPtr->value, pgvPtr->numBytes, &newValue);
 	value = Tcl_DStringToObj(&newValue);
 	hPtr = Tcl_CreateHashEntry(cacheMap,
-		INT2PTR(pgvPtr->epoch), &dummy);
+		INT2PTR(pgvPtr->epoch), NULL);
 	Tcl_MutexUnlock(&pgvPtr->mutex);
 	Tcl_SetHashValue(hPtr, value);
 	Tcl_IncrRefCount(value);
diff --git a/generic/tclVar.c b/generic/tclVar.c
index a94744f..955e4f3 100644
--- a/generic/tclVar.c
+++ b/generic/tclVar.c
@@ -69,7 +69,7 @@ VarHashCreateVar(
 }
 
 #define VarHashFindVar(tablePtr, key) \
-    VarHashCreateVar((tablePtr), (key), NULL)
+    VarHashCreateVar((tablePtr), (key), TCL_HASH_FIND)
 
 #define VarHashInvalidateEntry(varPtr) \
     ((varPtr)->flags |= VAR_DEAD_HASH)
@@ -2598,15 +2598,13 @@ UnsetVarStruct(
 	     * Otherwise just delete them.
 	     */
 
-	    int isNew;
-
 	    tPtr = Tcl_FindHashEntry(&iPtr->varTraces, varPtr);
 	    tracePtr = (VarTrace *)Tcl_GetHashValue(tPtr);
 	    varPtr->flags &= ~VAR_ALL_TRACES;
 	    Tcl_DeleteHashEntry(tPtr);
 	    if (dummyVar.flags & VAR_TRACED_UNSET) {
 		tPtr = Tcl_CreateHashEntry(&iPtr->varTraces,
-			&dummyVar, &isNew);
+			&dummyVar, NULL);
 		Tcl_SetHashValue(tPtr, tracePtr);
 	    }
 	}
@@ -3965,13 +3963,12 @@ TclFindArrayPtrElements(
 	    varPtr!=NULL ; varPtr=VarHashNextVar(&search)) {
 	Tcl_HashEntry *hPtr;
 	Tcl_Obj *nameObj;
-	int dummy;
 
 	if (TclIsVarUndefined(varPtr)) {
 	    continue;
 	}
 	nameObj = VarHashGetKey(varPtr);
-	hPtr = Tcl_CreateHashEntry(tablePtr, nameObj, &dummy);
+	hPtr = Tcl_CreateHashEntry(tablePtr, nameObj, NULL);
 	Tcl_SetHashValue(hPtr, nameObj);
     }
 }
diff --git a/unix/tclEpollNotfy.c b/unix/tclEpollNotfy.c
index 0138a00..1446903 100644
--- a/unix/tclEpollNotfy.c
+++ b/unix/tclEpollNotfy.c
@@ -223,15 +223,15 @@ PlatformEventsControl(
      */
 
     if (TclOSfstat(filePtr->fd, &fdStat) == -1) {
-		/*
-		 * The tclEpollNotfy PlatformEventsControl function panics if the TclOSfstat
-		 * call returns -1, which occurs when using a websocket to a browser and the
-		 * browser page is refreshed. It seems the fstat call isn't doing anything
-		 * useful, in particular the contents of the statbuf aren't examined afterwards
-		 * on success and at best it changes the panic message. Instead we avoid the
-		 * panic at the cost of a memory leak.
-		 */
-	    return;
+	/*
+	 * The tclEpollNotfy PlatformEventsControl function panics if the TclOSfstat
+	 * call returns -1, which occurs when using a websocket to a browser and the
+	 * browser page is refreshed. It seems the fstat call isn't doing anything
+	 * useful, in particular the contents of the statbuf aren't examined afterwards
+	 * on success and at best it changes the panic message. Instead we avoid the
+	 * panic at the cost of a memory leak. See [010d8f38]
+	 */
+	return;
     } else if (epoll_ctl(tsdPtr->eventsFd, op, filePtr->fd, &newEvent) == -1) {
        switch (errno) {
 	    case EPERM: