Small clarifications that code a bit nicer to read.

8 files changed, 206 insertions, 222 deletions

diff --git a/generic/tclCmdAH.c b/generic/tclCmdAH.c
index 1ac8764..d6127b0 100644
--- a/generic/tclCmdAH.c
+++ b/generic/tclCmdAH.c
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclCmdAH.c,v 1.94 2008/04/27 22:21:29 dkf Exp $
+ * RCS: @(#) $Id: tclCmdAH.c,v 1.95 2008/05/30 22:54:27 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -273,6 +273,7 @@ Tcl_CatchObjCmd(
     }
     if (objc == 4) {
 	Tcl_Obj *options = Tcl_GetReturnOptions(interp, result);
+
 	if (NULL == Tcl_ObjSetVar2(interp, optionVarNamePtr, NULL,
 		options, 0)) {
 	    Tcl_ResetResult(interp);
@@ -769,6 +770,7 @@ Tcl_ExprObjCmd(
 	result = Tcl_ExprObj(interp, objv[1], &resultPtr);
     } else {
 	Tcl_Obj *objPtr = Tcl_ConcatObj(objc-1, objv+1);
+
 	Tcl_IncrRefCount(objPtr);
 	result = Tcl_ExprObj(interp, objPtr, &resultPtr);
 	Tcl_DecrRefCount(objPtr);
diff --git a/generic/tclCmdIL.c b/generic/tclCmdIL.c
index b740531..f18a14a 100644
--- a/generic/tclCmdIL.c
+++ b/generic/tclCmdIL.c
@@ -16,7 +16,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclCmdIL.c,v 1.138 2008/04/27 22:21:29 dkf Exp $
+ * RCS: @(#) $Id: tclCmdIL.c,v 1.139 2008/05/30 22:54:27 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -31,7 +31,7 @@
 typedef struct SortElement {
     union {
 	char *strValuePtr;
-	long   intValue;
+	long intValue;
 	double doubleValue;
 	Tcl_Obj *objValuePtr;
     } index;
@@ -513,7 +513,7 @@ InfoBodyCmd(
 	 * run before. [Bug #545644]
 	 */
 
-	(void) TclGetString(bodyPtr);
+	TclGetString(bodyPtr);
     }
     resultPtr = Tcl_NewStringObj(bodyPtr->bytes, bodyPtr->length);
 
@@ -661,7 +661,7 @@ InfoCommandsCmd(
 	entryPtr = Tcl_FindHashEntry(&nsPtr->cmdTable, simplePattern);
 	if (entryPtr != NULL) {
 	    if (specificNsInPattern) {
-		cmd = (Tcl_Command) Tcl_GetHashValue(entryPtr);
+		cmd = Tcl_GetHashValue(entryPtr);
 		elemObjPtr = Tcl_NewObj();
 		Tcl_GetCommandFullName(interp, cmd, elemObjPtr);
 	    } else {
@@ -712,7 +712,7 @@ InfoCommandsCmd(
 	    if ((simplePattern == NULL)
 		    || Tcl_StringMatch(cmdName, simplePattern)) {
 		if (specificNsInPattern) {
-		    cmd = (Tcl_Command) Tcl_GetHashValue(entryPtr);
+		    cmd = Tcl_GetHashValue(entryPtr);
 		    elemObjPtr = Tcl_NewObj();
 		    Tcl_GetCommandFullName(interp, cmd, elemObjPtr);
 		} else {
@@ -1724,7 +1724,7 @@ InfoProcsCmd(
     if (simplePattern != NULL && TclMatchIsTrivial(simplePattern)) {
 	entryPtr = Tcl_FindHashEntry(&nsPtr->cmdTable, simplePattern);
 	if (entryPtr != NULL) {
-	    cmdPtr = (Command *) Tcl_GetHashValue(entryPtr);
+	    cmdPtr = Tcl_GetHashValue(entryPtr);
 
 	    if (!TclIsProc(cmdPtr)) {
 		realCmdPtr = (Command *)
@@ -1752,7 +1752,7 @@ InfoProcsCmd(
 	    cmdName = Tcl_GetHashKey(&nsPtr->cmdTable, entryPtr);
 	    if ((simplePattern == NULL)
 		    || Tcl_StringMatch(cmdName, simplePattern)) {
-		cmdPtr = (Command *) Tcl_GetHashValue(entryPtr);
+		cmdPtr = Tcl_GetHashValue(entryPtr);
 
 		if (!TclIsProc(cmdPtr)) {
 		    realCmdPtr = (Command *)
@@ -1799,7 +1799,7 @@ InfoProcsCmd(
 		if ((simplePattern == NULL)
 			|| Tcl_StringMatch(cmdName, simplePattern)) {
 		    if (Tcl_FindHashEntry(&nsPtr->cmdTable,cmdName) == NULL) {
-			cmdPtr = (Command *) Tcl_GetHashValue(entryPtr);
+			cmdPtr = Tcl_GetHashValue(entryPtr);
 			realCmdPtr = (Command *) TclGetOriginalCommand(
 				(Tcl_Command) cmdPtr);
 
diff --git a/generic/tclCmdMZ.c b/generic/tclCmdMZ.c
index 6c0a419..c5a1cb6 100644
--- a/generic/tclCmdMZ.c
+++ b/generic/tclCmdMZ.c
@@ -15,7 +15,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclCmdMZ.c,v 1.164 2008/04/27 22:21:29 dkf Exp $
+ * RCS: @(#) $Id: tclCmdMZ.c,v 1.165 2008/05/30 22:54:27 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -1871,8 +1871,8 @@ StringMapCmd(
 	 * case.
 	 */
 
-	mapStrings = (Tcl_UniChar **) TclStackAlloc(interp,
-		mapElemc * 2 * sizeof(Tcl_UniChar *));
+	mapStrings = (Tcl_UniChar **)
+		TclStackAlloc(interp, mapElemc * 2 * sizeof(Tcl_UniChar *));
 	mapLens = (int *) TclStackAlloc(interp, mapElemc * 2 * sizeof(int));
 	if (nocase) {
 	    u2lc = (Tcl_UniChar *) TclStackAlloc(interp,
diff --git a/generic/tclCompile.c b/generic/tclCompile.c
index ec94d6b..fd6f25e 100644
--- a/generic/tclCompile.c
+++ b/generic/tclCompile.c
@@ -11,7 +11,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclCompile.c,v 1.147 2008/05/16 14:13:33 msofer Exp $
+ * RCS: @(#) $Id: tclCompile.c,v 1.148 2008/05/30 22:54:28 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -521,7 +521,7 @@ TclSetByteCodeFromAny(
      */
 
     if (hookProc) {
-	result = (*hookProc)(interp, &compEnv, clientData);
+	result = hookProc(interp, &compEnv, clientData);
     }
 
     /*
@@ -597,7 +597,7 @@ SetByteCodeFromAny(
 				 * compiled. Must not be NULL. */
     Tcl_Obj *objPtr)		/* The object to make a ByteCode object. */
 {
-    (void) TclSetByteCodeFromAny(interp, objPtr, NULL, (ClientData) NULL);
+    TclSetByteCodeFromAny(interp, objPtr, NULL, NULL);
     return TCL_OK;
 }
 
@@ -652,8 +652,7 @@ static void
 FreeByteCodeInternalRep(
     register Tcl_Obj *objPtr)	/* Object whose internal rep to free. */
 {
-    register ByteCode *codePtr = (ByteCode *)
-	    objPtr->internalRep.otherValuePtr;
+    register ByteCode *codePtr = objPtr->internalRep.otherValuePtr;
 
     codePtr->refCount--;
     if (codePtr->refCount <= 0) {
@@ -783,7 +782,7 @@ TclCleanupByteCode(
     auxDataPtr = codePtr->auxDataArrayPtr;
     for (i = 0;  i < numAuxDataItems;  i++) {
 	if (auxDataPtr->type->freeProc != NULL) {
-	    (auxDataPtr->type->freeProc)(auxDataPtr->clientData);
+	    auxDataPtr->type->freeProc(auxDataPtr->clientData);
 	}
 	auxDataPtr++;
     }
@@ -1884,7 +1883,7 @@ TclCompileNoOp(
     int savedStackDepth = envPtr->currStackDepth;
 
     tokenPtr = parsePtr->tokenPtr;
-    for(i = 1; i < parsePtr->numWords; i++) {
+    for (i = 1; i < parsePtr->numWords; i++) {
 	tokenPtr = tokenPtr + tokenPtr->numComponents + 1;
 	envPtr->currStackDepth = savedStackDepth;
 
@@ -1946,10 +1945,10 @@ TclInitByteCodeObj(
 
     iPtr = envPtr->iPtr;
 
-    codeBytes = (envPtr->codeNext - envPtr->codeStart);
-    objArrayBytes = (envPtr->literalArrayNext * sizeof(Tcl_Obj *));
-    exceptArrayBytes = (envPtr->exceptArrayNext * sizeof(ExceptionRange));
-    auxDataArrayBytes = (envPtr->auxDataArrayNext * sizeof(AuxData));
+    codeBytes = envPtr->codeNext - envPtr->codeStart;
+    objArrayBytes = envPtr->literalArrayNext * sizeof(Tcl_Obj *);
+    exceptArrayBytes = envPtr->exceptArrayNext * sizeof(ExceptionRange);
+    auxDataArrayBytes = envPtr->auxDataArrayNext * sizeof(AuxData);
     cmdLocBytes = GetCmdLocEncodingSize(envPtr);
 
     /*
@@ -2049,7 +2048,7 @@ TclInitByteCodeObj(
      */
 
     TclFreeIntRep(objPtr);
-    objPtr->internalRep.otherValuePtr = (void *) codePtr;
+    objPtr->internalRep.otherValuePtr = codePtr;
     objPtr->typePtr = &tclByteCodeType;
 
     /*
@@ -2184,7 +2183,7 @@ TclExpandCodeArray(
     void *envArgPtr)		/* Points to the CompileEnv whose code array
 				 * must be enlarged. */
 {
-    CompileEnv *envPtr = (CompileEnv *) envArgPtr;
+    CompileEnv *envPtr = envArgPtr;
 				/* The CompileEnv containing the code array to
 				 * be doubled in size. */
 
@@ -2194,25 +2193,27 @@ TclExpandCodeArray(
      * [inclusive].
      */
 
-    size_t currBytes = (envPtr->codeNext - envPtr->codeStart);
+    size_t currBytes = envPtr->codeNext - envPtr->codeStart;
     size_t newBytes = 2*(envPtr->codeEnd - envPtr->codeStart);
 
     if (envPtr->mallocedCodeArray) {
 	envPtr->codeStart = (unsigned char *)
-		ckrealloc((char *)envPtr->codeStart, newBytes);
+		ckrealloc((char *) envPtr->codeStart, newBytes);
     } else {
 	/*
 	 * envPtr->codeStart isn't a ckalloc'd pointer, so we must
 	 * code a ckrealloc equivalent for ourselves.
 	 */
-	unsigned char *newPtr = (unsigned char *) ckalloc((unsigned) newBytes);
+	unsigned char *newPtr = (unsigned char *)
+		ckalloc((unsigned) newBytes);
+
 	memcpy(newPtr, envPtr->codeStart, currBytes);
 	envPtr->codeStart = newPtr;
 	envPtr->mallocedCodeArray = 1;
     }
 
-    envPtr->codeNext = (envPtr->codeStart + currBytes);
-    envPtr->codeEnd = (envPtr->codeStart + newBytes);
+    envPtr->codeNext = envPtr->codeStart + currBytes;
+    envPtr->codeEnd = envPtr->codeStart + newBytes;
 }
 
 /*
diff --git a/generic/tclDictObj.c b/generic/tclDictObj.c
index a33802d..d3d30d3 100644
--- a/generic/tclDictObj.c
+++ b/generic/tclDictObj.c
@@ -9,7 +9,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclDictObj.c,v 1.56 2007/12/13 15:23:16 dgp Exp $
+ * RCS: @(#) $Id: tclDictObj.c,v 1.57 2008/05/30 22:54:29 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -354,7 +354,7 @@ DupDictInternalRep(
 	 * Fill in the contents.
 	 */
 
-	Tcl_SetHashValue(hPtr, (ClientData) valuePtr);
+	Tcl_SetHashValue(hPtr, valuePtr);
 	Tcl_IncrRefCount(valuePtr);
     }
 
@@ -840,7 +840,7 @@ TclTraceDictPath(
 		TclDecrRefCount(tmpObj);
 		tmpObj = Tcl_DuplicateObj(tmpObj);
 		Tcl_IncrRefCount(tmpObj);
-		Tcl_SetHashValue(hPtr, (ClientData) tmpObj);
+		Tcl_SetHashValue(hPtr, tmpObj);
 		dict->epoch++;
 		newDict = tmpObj->internalRep.otherValuePtr;
 	    }
diff --git a/generic/tclInterp.c b/generic/tclInterp.c
index 1f2921a..8de5983 100644
--- a/generic/tclInterp.c
+++ b/generic/tclInterp.c
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclInterp.c,v 1.83 2008/01/30 10:45:55 msofer Exp $
+ * RCS: @(#) $Id: tclInterp.c,v 1.84 2008/05/30 22:54:29 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -1305,7 +1305,7 @@ TclPreventAliasLoop(
      * chain then we have a loop.
      */
 
-    aliasPtr = (Alias *) cmdPtr->objClientData;
+    aliasPtr = cmdPtr->objClientData;
     nextAliasPtr = aliasPtr;
     while (1) {
 	Tcl_Obj *cmdNamePtr;
@@ -1351,7 +1351,7 @@ TclPreventAliasLoop(
 	if (aliasCmdPtr->objProc != AliasObjCmd) {
 	    return TCL_OK;
 	}
-	nextAliasPtr = (Alias *) aliasCmdPtr->objClientData;
+	nextAliasPtr = aliasCmdPtr->objClientData;
     }
 
     /* NOTREACHED */
@@ -2717,7 +2717,7 @@ SlaveInvokeHidden(
 		| TCL_CREATE_NS_IF_UNKNOWN, &nsPtr, &dummy1, &dummy2, &tail);
 	if (result == TCL_OK) {
 	    result = TclObjInvokeNamespace(slaveInterp, objc, objv,
-		    (Tcl_Namespace *)nsPtr, TCL_INVOKE_HIDDEN);
+		    (Tcl_Namespace *) nsPtr, TCL_INVOKE_HIDDEN);
 	}
     }
 
@@ -3071,7 +3071,7 @@ RunLimitHandlers(
 	 */
 
 	handlerPtr->flags |= LIMIT_HANDLER_ACTIVE;
-	(handlerPtr->handlerProc)(handlerPtr->clientData, interp);
+	handlerPtr->handlerProc(handlerPtr->clientData, interp);
 	handlerPtr->flags &= ~LIMIT_HANDLER_ACTIVE;
 
 	/*
@@ -3092,7 +3092,7 @@ RunLimitHandlers(
 
 	if (handlerPtr->flags & LIMIT_HANDLER_DELETED) {
 	    if (handlerPtr->deleteProc != NULL) {
-		(handlerPtr->deleteProc)(handlerPtr->clientData);
+		handlerPtr->deleteProc(handlerPtr->clientData);
 	    }
 	    ckfree((char *) handlerPtr);
 	}
@@ -3258,7 +3258,7 @@ Tcl_LimitRemoveHandler(
 
 	if (!(handlerPtr->flags & LIMIT_HANDLER_ACTIVE)) {
 	    if (handlerPtr->deleteProc != NULL) {
-		(handlerPtr->deleteProc)(handlerPtr->clientData);
+		handlerPtr->deleteProc(handlerPtr->clientData);
 	    }
 	    ckfree((char *) handlerPtr);
 	}
@@ -3318,7 +3318,7 @@ TclLimitRemoveAllHandlers(
 
 	if (!(handlerPtr->flags & LIMIT_HANDLER_ACTIVE)) {
 	    if (handlerPtr->deleteProc != NULL) {
-		(handlerPtr->deleteProc)(handlerPtr->clientData);
+		handlerPtr->deleteProc(handlerPtr->clientData);
 	    }
 	    ckfree((char *) handlerPtr);
 	}
@@ -3351,7 +3351,7 @@ TclLimitRemoveAllHandlers(
 
 	if (!(handlerPtr->flags & LIMIT_HANDLER_ACTIVE)) {
 	    if (handlerPtr->deleteProc != NULL) {
-		(handlerPtr->deleteProc)(handlerPtr->clientData);
+		handlerPtr->deleteProc(handlerPtr->clientData);
 	    }
 	    ckfree((char *) handlerPtr);
 	}
@@ -3602,7 +3602,7 @@ TimeLimitCallback(
     int code;
 
     Tcl_Preserve(interp);
-    ((Interp *)interp)->limit.timeEvent = NULL;
+    ((Interp *) interp)->limit.timeEvent = NULL;
     code = Tcl_LimitCheck(interp);
     if (code != TCL_OK) {
 	Tcl_AddErrorInfo(interp, "\n    (while waiting for event)");
diff --git a/generic/tclLoad.c b/generic/tclLoad.c
index 29e2d01..7ed2ee7 100644
--- a/generic/tclLoad.c
+++ b/generic/tclLoad.c
@@ -9,7 +9,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclLoad.c,v 1.16 2007/02/20 23:24:03 nijtmans Exp $
+ * RCS: @(#) $Id: tclLoad.c,v 1.17 2008/05/30 22:54:29 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -252,8 +252,7 @@ Tcl_LoadObjCmd(
      */
 
     if (pkgPtr != NULL) {
-	ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target,
-		"tclLoad", NULL);
+	ipFirstPtr = Tcl_GetAssocData(target, "tclLoad", NULL);
 	for (ipPtr = ipFirstPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr) {
 	    if (ipPtr->pkgPtr == pkgPtr) {
 		code = TCL_OK;
@@ -372,7 +371,7 @@ Tcl_LoadObjCmd(
 	code = TclLoadFile(interp, objv[1], 4, symbols, procPtrs,
 		&loadHandle, &clientData, &unLoadProcPtr);
 	Tcl_MutexUnlock(&packageMutex);
-	loadHandle = (Tcl_LoadHandle) clientData;
+	loadHandle = clientData;
 	if (code != TCL_OK) {
 	    goto done;
 	}
@@ -381,7 +380,7 @@ Tcl_LoadObjCmd(
 	    Tcl_AppendResult(interp, "couldn't find procedure ",
 		    Tcl_DStringValue(&initName), NULL);
 	    if (unLoadProcPtr != NULL) {
-		(*unLoadProcPtr)(loadHandle);
+		unLoadProcPtr(loadHandle);
 	    }
 	    code = TCL_ERROR;
 	    goto done;
@@ -392,18 +391,18 @@ Tcl_LoadObjCmd(
 	 */
 
 	pkgPtr = (LoadedPackage *) ckalloc(sizeof(LoadedPackage));
-	pkgPtr->fileName	   = (char *) ckalloc((unsigned)
-		(strlen(fullFileName) + 1));
+	pkgPtr->fileName	   =
+		ckalloc((unsigned) (strlen(fullFileName) + 1));
 	strcpy(pkgPtr->fileName, fullFileName);
-	pkgPtr->packageName	   = (char *) ckalloc((unsigned)
-		(Tcl_DStringLength(&pkgName) + 1));
+	pkgPtr->packageName	   =
+		ckalloc((unsigned) (Tcl_DStringLength(&pkgName) + 1));
 	strcpy(pkgPtr->packageName, Tcl_DStringValue(&pkgName));
 	pkgPtr->loadHandle	   = loadHandle;
 	pkgPtr->unLoadProcPtr	   = unLoadProcPtr;
 	pkgPtr->initProc	   = *procPtrs[0];
 	pkgPtr->safeInitProc	   = *procPtrs[1];
-	pkgPtr->unloadProc	   = (Tcl_PackageUnloadProc*) *procPtrs[2];
-	pkgPtr->safeUnloadProc	   = (Tcl_PackageUnloadProc*) *procPtrs[3];
+	pkgPtr->unloadProc	   = (Tcl_PackageUnloadProc *) *procPtrs[2];
+	pkgPtr->safeUnloadProc	   = (Tcl_PackageUnloadProc *) *procPtrs[3];
 	pkgPtr->interpRefCount	   = 0;
 	pkgPtr->safeInterpRefCount = 0;
 
@@ -420,7 +419,7 @@ Tcl_LoadObjCmd(
 
     if (Tcl_IsSafe(target)) {
 	if (pkgPtr->safeInitProc != NULL) {
-	    code = (*pkgPtr->safeInitProc)(target);
+	    code = pkgPtr->safeInitProc(target);
 	} else {
 	    Tcl_AppendResult(interp,
 		    "can't use package in a safe interpreter: no ",
@@ -429,7 +428,7 @@ Tcl_LoadObjCmd(
 	    goto done;
 	}
     } else {
-	code = (*pkgPtr->initProc)(target);
+	code = pkgPtr->initProc(target);
     }
 
     /*
@@ -455,13 +454,11 @@ Tcl_LoadObjCmd(
 	 * additional static packages at the head of the linked list!
 	 */
 
-	ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target,
-		"tclLoad", NULL);
+	ipFirstPtr = Tcl_GetAssocData(target, "tclLoad", NULL);
 	ipPtr = (InterpPackage *) ckalloc(sizeof(InterpPackage));
 	ipPtr->pkgPtr = pkgPtr;
 	ipPtr->nextPtr = ipFirstPtr;
-	Tcl_SetAssocData(target, "tclLoad", LoadCleanupProc,
-		(ClientData) ipPtr);
+	Tcl_SetAssocData(target, "tclLoad", LoadCleanupProc, ipPtr);
     } else {
 	TclTransferResult(target, code, interp);
     }
@@ -584,8 +581,8 @@ Tcl_UnloadObjCmd(
 
     target = interp;
     if (objc - i == 3) {
-	char *slaveIntName;
-	slaveIntName = Tcl_GetString(objv[i+2]);
+	char *slaveIntName = Tcl_GetString(objv[i + 2]);
+
 	target = Tcl_GetSlave(interp, slaveIntName);
 	if (target == NULL) {
 	    return TCL_ERROR;
@@ -667,8 +664,7 @@ Tcl_UnloadObjCmd(
 
     code = TCL_ERROR;
     if (pkgPtr != NULL) {
-	ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target,
-		"tclLoad", NULL);
+	ipFirstPtr = Tcl_GetAssocData(target, "tclLoad", NULL);
 	for (ipPtr = ipFirstPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr) {
 	    if (ipPtr->pkgPtr == pkgPtr) {
 		code = TCL_OK;
@@ -738,7 +734,7 @@ Tcl_UnloadObjCmd(
 	    code = TCL_UNLOAD_DETACH_FROM_PROCESS;
 	}
     }
-    code = (*unloadProc)(target, code);
+    code = unloadProc(target, code);
     if (code != TCL_OK) {
 	TclTransferResult(target, code, interp);
 	goto done;
@@ -795,7 +791,7 @@ Tcl_UnloadObjCmd(
 
 	    if (unLoadProcPtr != NULL) {
 		Tcl_MutexLock(&packageMutex);
-		(*unLoadProcPtr)(pkgPtr->loadHandle);
+		unLoadProcPtr(pkgPtr->loadHandle);
 
 		/*
 		 * Remove this library from the loaded library cache.
@@ -818,8 +814,7 @@ Tcl_UnloadObjCmd(
 		 * Remove this library from the interpreter's library cache.
 		 */
 
-		ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(target,
-			"tclLoad", NULL);
+		ipFirstPtr = Tcl_GetAssocData(target, "tclLoad", NULL);
 		ipPtr = ipFirstPtr;
 		if (ipPtr->pkgPtr == defaultPtr) {
 		    ipFirstPtr = ipFirstPtr->nextPtr;
@@ -835,7 +830,7 @@ Tcl_UnloadObjCmd(
 		    }
 		}
 		Tcl_SetAssocData(target, "tclLoad", LoadCleanupProc,
-			(ClientData) ipFirstPtr);
+			ipFirstPtr);
 		ckfree(defaultPtr->fileName);
 		ckfree(defaultPtr->packageName);
 		ckfree((char *) defaultPtr);
@@ -955,12 +950,11 @@ Tcl_StaticPackage(
      * to the list now.
      */
 
-    if ( pkgPtr == NULL ) {
+    if (pkgPtr == NULL) {
 	pkgPtr = (LoadedPackage *) ckalloc(sizeof(LoadedPackage));
-	pkgPtr->fileName	= (char *) ckalloc((unsigned) 1);
+	pkgPtr->fileName	= ckalloc((unsigned) 1);
 	pkgPtr->fileName[0]	= 0;
-	pkgPtr->packageName	= (char *)
-		ckalloc((unsigned) (strlen(pkgName) + 1));
+	pkgPtr->packageName	= ckalloc((unsigned) (strlen(pkgName) + 1));
 	strcpy(pkgPtr->packageName, pkgName);
 	pkgPtr->loadHandle	= NULL;
 	pkgPtr->initProc	= initProc;
@@ -978,10 +972,9 @@ Tcl_StaticPackage(
 	 * it's already loaded.
 	 */
 
-	ipFirstPtr = (InterpPackage *) Tcl_GetAssocData(interp,
-		"tclLoad", NULL);
-	for ( ipPtr = ipFirstPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr ) {
-	    if ( ipPtr->pkgPtr == pkgPtr ) {
+	ipFirstPtr = Tcl_GetAssocData(interp, "tclLoad", NULL);
+	for (ipPtr = ipFirstPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr) {
+	    if (ipPtr->pkgPtr == pkgPtr) {
 		return;
 	    }
 	}
@@ -994,8 +987,7 @@ Tcl_StaticPackage(
 	ipPtr = (InterpPackage *) ckalloc(sizeof(InterpPackage));
 	ipPtr->pkgPtr = pkgPtr;
 	ipPtr->nextPtr = ipFirstPtr;
-	Tcl_SetAssocData(interp, "tclLoad", LoadCleanupProc,
-		(ClientData) ipPtr);
+	Tcl_SetAssocData(interp, "tclLoad", LoadCleanupProc, ipPtr);
     }
 }
 
@@ -1029,6 +1021,7 @@ TclGetLoadedPackages(
 				 * otherwise, just return info about this
 				 * interpreter. */
 {
+    /* TODO: Use Tcl_Obj APIs to generate this info for cleanliness. */
     Tcl_Interp *target;
     LoadedPackage *pkgPtr;
     InterpPackage *ipPtr;
@@ -1062,9 +1055,9 @@ TclGetLoadedPackages(
     if (target == NULL) {
 	return TCL_ERROR;
     }
-    ipPtr = (InterpPackage *) Tcl_GetAssocData(target, "tclLoad", NULL);
+    ipPtr = Tcl_GetAssocData(target, "tclLoad", NULL);
     prefix = "{";
-    for ( ; ipPtr != NULL; ipPtr = ipPtr->nextPtr) {
+    for (; ipPtr != NULL; ipPtr = ipPtr->nextPtr) {
 	pkgPtr = ipPtr->pkgPtr;
 	Tcl_AppendResult(interp, prefix, NULL);
 	Tcl_AppendElement(interp, pkgPtr->fileName);
@@ -1101,7 +1094,7 @@ LoadCleanupProc(
 {
     InterpPackage *ipPtr, *nextPtr;
 
-    ipPtr = (InterpPackage *) clientData;
+    ipPtr = clientData;
     while (ipPtr != NULL) {
 	nextPtr = ipPtr->nextPtr;
 	ckfree((char *) ipPtr);
@@ -1134,8 +1127,8 @@ TclFinalizeLoad(void)
     /*
      * No synchronization here because there should just be one thread alive
      * at this point. Logically, packageMutex should be grabbed at this point,
-     * but the Mutexes get finalized before the call to this routine. The
-     * only subsystem left alive at this point is the memory allocator.
+     * but the Mutexes get finalized before the call to this routine. The only
+     * subsystem left alive at this point is the memory allocator.
      */
 
     while (firstPackagePtr != NULL) {
@@ -1151,9 +1144,8 @@ TclFinalizeLoad(void)
 	 */
 
 	if (pkgPtr->fileName[0] != '\0') {
-	    Tcl_FSUnloadFileProc *unLoadProcPtr = pkgPtr->unLoadProcPtr;
-	    if (unLoadProcPtr != NULL) {
-		(*unLoadProcPtr)(pkgPtr->loadHandle);
+	    if (pkgPtr->unLoadProcPtr != NULL) {
+		pkgPtr->unLoadProcPtr(pkgPtr->loadHandle);
 	    }
 	}
 #endif
diff --git a/generic/tclTrace.c b/generic/tclTrace.c
index dfcac43..c7aa4d2 100644
--- a/generic/tclTrace.c
+++ b/generic/tclTrace.c
@@ -11,7 +11,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclTrace.c,v 1.47 2007/12/13 15:23:20 dgp Exp $
+ * RCS: @(#) $Id: tclTrace.c,v 1.48 2008/05/30 22:54:29 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -149,6 +149,21 @@ typedef struct StringTraceData {
     ClientData clientData;	/* Client data from Tcl_CreateTrace */
     Tcl_CmdTraceProc *proc;	/* Trace function from Tcl_CreateTrace */
 } StringTraceData;
+
+/*
+ * Convenience macros for iterating over the list of traces. Note that each of
+ * these *must* be treated as a command, and *must* have a block following it.
+ */
+
+#define FOREACH_VAR_TRACE(interp, name, clientData) \
+    (clientData) = NULL; \
+    while (((clientData) = Tcl_VarTraceInfo((interp), (name), 0, \
+	    TraceVarProc, (clientData))) != NULL)
+
+#define FOREACH_COMMAND_TRACE(interp, name, clientData) \
+    (clientData) = NULL; \
+    while ((clientData = Tcl_CommandTraceInfo(interp, name, 0, \
+	    TraceCommandProc, clientData)) != NULL)
 
 /*
  *----------------------------------------------------------------------
@@ -200,8 +215,8 @@ Tcl_TraceObjCmd(
 	return TCL_ERROR;
     }
 
-    if (Tcl_GetIndexFromObj(interp, objv[1], traceOptions,
-		"option", 0, &optionIndex) != TCL_OK) {
+    if (Tcl_GetIndexFromObj(interp, objv[1], traceOptions, "option", 0,
+	    &optionIndex) != TCL_OK) {
 	return TCL_ERROR;
     }
     switch ((enum traceOptions) optionIndex) {
@@ -307,12 +322,9 @@ Tcl_TraceObjCmd(
 	    return TCL_ERROR;
 	}
 	resultListPtr = Tcl_NewObj();
-	clientData = 0;
 	name = Tcl_GetString(objv[2]);
-	while ((clientData = Tcl_VarTraceInfo(interp, name, 0,
-		TraceVarProc, clientData)) != 0) {
-
-	    TraceVarInfo *tvarPtr = (TraceVarInfo *) clientData;
+	FOREACH_VAR_TRACE(interp, name, clientData) {
+	    TraceVarInfo *tvarPtr = clientData;
 
 	    pairObjPtr = Tcl_NewListObj(0, NULL);
 	    p = ops;
@@ -450,11 +462,10 @@ TraceExecutionObjCmd(
 	command = Tcl_GetStringFromObj(objv[5], &commandLength);
 	length = (size_t) commandLength;
 	if ((enum traceOptions) optionIndex == TRACE_ADD) {
-	    TraceCommandInfo *tcmdPtr;
+	    TraceCommandInfo *tcmdPtr = (TraceCommandInfo *)
+		    ckalloc((unsigned) (sizeof(TraceCommandInfo)
+			    - sizeof(tcmdPtr->command) + length + 1));
 
-	    tcmdPtr = (TraceCommandInfo *) ckalloc((unsigned)
-		    (sizeof(TraceCommandInfo) - sizeof(tcmdPtr->command)
-			    + length + 1));
 	    tcmdPtr->flags = flags;
 	    tcmdPtr->stepTrace = NULL;
 	    tcmdPtr->startLevel = 0;
@@ -469,7 +480,7 @@ TraceExecutionObjCmd(
 	    strcpy(tcmdPtr->command, command);
 	    name = Tcl_GetString(objv[3]);
 	    if (Tcl_TraceCommand(interp, name, flags, TraceCommandProc,
-		    (ClientData) tcmdPtr) != TCL_OK) {
+		    tcmdPtr) != TCL_OK) {
 		ckfree((char *) tcmdPtr);
 		return TCL_ERROR;
 	    }
@@ -480,21 +491,19 @@ TraceExecutionObjCmd(
 	     * first one that matches.
 	     */
 
-	    TraceCommandInfo *tcmdPtr;
-	    ClientData clientData = NULL;
-	    name = Tcl_GetString(objv[3]);
+	    ClientData clientData;
 
 	    /*
 	     * First ensure the name given is valid.
 	     */
 
+	    name = Tcl_GetString(objv[3]);
 	    if (Tcl_FindCommand(interp,name,NULL,TCL_LEAVE_ERR_MSG) == NULL) {
 		return TCL_ERROR;
 	    }
 
-	    while ((clientData = Tcl_CommandTraceInfo(interp, name, 0,
-		    TraceCommandProc, clientData)) != NULL) {
-		tcmdPtr = (TraceCommandInfo *) clientData;
+	    FOREACH_COMMAND_TRACE(interp, name, clientData) {
+		TraceCommandInfo *tcmdPtr = clientData;
 
 		/*
 		 * In checking the 'flags' field we must remove any extraneous
@@ -544,14 +553,13 @@ TraceExecutionObjCmd(
     }
     case TRACE_INFO: {
 	ClientData clientData;
-	Tcl_Obj *resultListPtr, *eachTraceObjPtr, *elemObjPtr;
+	Tcl_Obj *resultListPtr;
 
 	if (objc != 4) {
 	    Tcl_WrongNumArgs(interp, 3, objv, "name");
 	    return TCL_ERROR;
 	}
 
-	clientData = NULL;
 	name = Tcl_GetString(objv[3]);
 
 	/*
@@ -563,11 +571,10 @@ TraceExecutionObjCmd(
 	}
 
 	resultListPtr = Tcl_NewListObj(0, NULL);
-	while ((clientData = Tcl_CommandTraceInfo(interp, name, 0,
-		TraceCommandProc, clientData)) != NULL) {
+	FOREACH_COMMAND_TRACE(interp, name, clientData) {
 	    int numOps = 0;
-	    Tcl_Obj *opObj;
-	    TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData;
+	    Tcl_Obj *opObj, *eachTraceObjPtr, *elemObjPtr;
+	    TraceCommandInfo *tcmdPtr = clientData;
 
 	    /*
 	     * Build a list with the ops list as the first obj element and the
@@ -692,11 +699,10 @@ TraceCommandObjCmd(
 	command = Tcl_GetStringFromObj(objv[5], &commandLength);
 	length = (size_t) commandLength;
 	if ((enum traceOptions) optionIndex == TRACE_ADD) {
-	    TraceCommandInfo *tcmdPtr;
+	    TraceCommandInfo *tcmdPtr = (TraceCommandInfo *)
+		    ckalloc((unsigned) (sizeof(TraceCommandInfo)
+			    - sizeof(tcmdPtr->command) + length + 1));
 
-	    tcmdPtr = (TraceCommandInfo *) ckalloc((unsigned)
-		    (sizeof(TraceCommandInfo) - sizeof(tcmdPtr->command)
-			    + length + 1));
 	    tcmdPtr->flags = flags;
 	    tcmdPtr->stepTrace = NULL;
 	    tcmdPtr->startLevel = 0;
@@ -707,7 +713,7 @@ TraceCommandObjCmd(
 	    strcpy(tcmdPtr->command, command);
 	    name = Tcl_GetString(objv[3]);
 	    if (Tcl_TraceCommand(interp, name, flags, TraceCommandProc,
-		    (ClientData) tcmdPtr) != TCL_OK) {
+		    tcmdPtr) != TCL_OK) {
 		ckfree((char *) tcmdPtr);
 		return TCL_ERROR;
 	    }
@@ -718,23 +724,21 @@ TraceCommandObjCmd(
 	     * first one that matches.
 	     */
 
-	    TraceCommandInfo *tcmdPtr;
-	    ClientData clientData = NULL;
-	    name = Tcl_GetString(objv[3]);
+	    ClientData clientData;
 
 	    /*
 	     * First ensure the name given is valid.
 	     */
 
+	    name = Tcl_GetString(objv[3]);
 	    if (Tcl_FindCommand(interp,name,NULL,TCL_LEAVE_ERR_MSG) == NULL) {
 		return TCL_ERROR;
 	    }
 
-	    while ((clientData = Tcl_CommandTraceInfo(interp, name, 0,
-		    TraceCommandProc, clientData)) != NULL) {
-		tcmdPtr = (TraceCommandInfo *) clientData;
-		if ((tcmdPtr->length == length)
-			&& (tcmdPtr->flags == flags)
+	    FOREACH_COMMAND_TRACE(interp, name, clientData) {
+		TraceCommandInfo *tcmdPtr = clientData;
+
+		if ((tcmdPtr->length == length) && (tcmdPtr->flags == flags)
 			&& (strncmp(command, tcmdPtr->command,
 				(size_t) length) == 0)) {
 		    Tcl_UntraceCommand(interp, name, flags | TCL_TRACE_DELETE,
@@ -751,30 +755,27 @@ TraceCommandObjCmd(
     }
     case TRACE_INFO: {
 	ClientData clientData;
-	Tcl_Obj *resultListPtr, *eachTraceObjPtr, *elemObjPtr;
+	Tcl_Obj *resultListPtr;
 
 	if (objc != 4) {
 	    Tcl_WrongNumArgs(interp, 3, objv, "name");
 	    return TCL_ERROR;
 	}
 
-	clientData = NULL;
-	name = Tcl_GetString(objv[3]);
-
 	/*
 	 * First ensure the name given is valid.
 	 */
 
+	name = Tcl_GetString(objv[3]);
 	if (Tcl_FindCommand(interp, name, NULL, TCL_LEAVE_ERR_MSG) == NULL) {
 	    return TCL_ERROR;
 	}
 
 	resultListPtr = Tcl_NewListObj(0, NULL);
-	while ((clientData = Tcl_CommandTraceInfo(interp, name, 0,
-		TraceCommandProc, clientData)) != NULL) {
+	FOREACH_COMMAND_TRACE(interp, name, clientData) {
 	    int numOps = 0;
-	    Tcl_Obj *opObj;
-	    TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData;
+	    Tcl_Obj *opObj, *eachTraceObjPtr, *elemObjPtr;
+	    TraceCommandInfo *tcmdPtr = clientData;
 
 	    /*
 	     * Build a list with the ops list as the first obj element and the
@@ -898,11 +899,9 @@ TraceVariableObjCmd(
 	command = Tcl_GetStringFromObj(objv[5], &commandLength);
 	length = (size_t) commandLength;
 	if ((enum traceOptions) optionIndex == TRACE_ADD) {
-	    CombinedTraceVarInfo *ctvarPtr;
-
-	    ctvarPtr = (CombinedTraceVarInfo *) ckalloc((unsigned)
-		    (sizeof(CombinedTraceVarInfo) + length + 1
-		    - sizeof(ctvarPtr->traceCmdInfo.command)));
+	    CombinedTraceVarInfo *ctvarPtr = (CombinedTraceVarInfo *)
+		    ckalloc((unsigned) (sizeof(CombinedTraceVarInfo)
+		    + length + 1 - sizeof(ctvarPtr->traceCmdInfo.command)));
 	    ctvarPtr->traceCmdInfo.flags = flags;
 	    if (objv[0] == NULL) {
 		ctvarPtr->traceCmdInfo.flags |= TCL_TRACE_OLD_STYLE;
@@ -911,11 +910,11 @@ TraceVariableObjCmd(
 	    flags |= TCL_TRACE_UNSETS | TCL_TRACE_RESULT_OBJECT;
 	    strcpy(ctvarPtr->traceCmdInfo.command, command);
 	    ctvarPtr->traceInfo.traceProc = TraceVarProc;
-	    ctvarPtr->traceInfo.clientData = (ClientData)
-		    &ctvarPtr->traceCmdInfo;
+	    ctvarPtr->traceInfo.clientData = &ctvarPtr->traceCmdInfo;
 	    ctvarPtr->traceInfo.flags = flags;
 	    name = Tcl_GetString(objv[3]);
-	    if (TraceVarEx(interp,name,NULL,(VarTrace*)ctvarPtr) != TCL_OK) {
+	    if (TraceVarEx(interp, name, NULL, (VarTrace *) ctvarPtr)
+		    != TCL_OK) {
 		ckfree((char *) ctvarPtr);
 		return TCL_ERROR;
 	    }
@@ -926,12 +925,12 @@ TraceVariableObjCmd(
 	     * first one that matches.
 	     */
 
-	    TraceVarInfo *tvarPtr;
-	    ClientData clientData = 0;
+	    ClientData clientData;
+
 	    name = Tcl_GetString(objv[3]);
-	    while ((clientData = Tcl_VarTraceInfo(interp, name, 0,
-		    TraceVarProc, clientData)) != 0) {
-		tvarPtr = (TraceVarInfo *) clientData;
+	    FOREACH_VAR_TRACE(interp, name, clientData) {
+		TraceVarInfo *tvarPtr = clientData;
+
 		if ((tvarPtr->length == length)
 			&& ((tvarPtr->flags & ~TCL_TRACE_OLD_STYLE)==flags)
 			&& (strncmp(command, tvarPtr->command,
@@ -947,7 +946,7 @@ TraceVariableObjCmd(
     }
     case TRACE_INFO: {
 	ClientData clientData;
-	Tcl_Obj *resultListPtr, *eachTraceObjPtr, *elemObjPtr;
+	Tcl_Obj *resultListPtr;
 
 	if (objc != 4) {
 	    Tcl_WrongNumArgs(interp, 3, objv, "name");
@@ -955,12 +954,10 @@ TraceVariableObjCmd(
 	}
 
 	resultListPtr = Tcl_NewObj();
-	clientData = 0;
 	name = Tcl_GetString(objv[3]);
-	while ((clientData = Tcl_VarTraceInfo(interp, name, 0, TraceVarProc,
-		clientData)) != 0) {
-	    Tcl_Obj *opObj;
-	    TraceVarInfo *tvarPtr = (TraceVarInfo *) clientData;
+	FOREACH_VAR_TRACE(interp, name, clientData) {
+	    Tcl_Obj *opObjPtr, *eachTraceObjPtr, *elemObjPtr;
+	    TraceVarInfo *tvarPtr = clientData;
 
 	    /*
 	     * Build a list with the ops list as the first obj element and the
@@ -970,20 +967,20 @@ TraceVariableObjCmd(
 
 	    elemObjPtr = Tcl_NewListObj(0, NULL);
 	    if (tvarPtr->flags & TCL_TRACE_ARRAY) {
-		TclNewLiteralStringObj(opObj, "array");
-		Tcl_ListObjAppendElement(NULL, elemObjPtr, opObj);
+		TclNewLiteralStringObj(opObjPtr, "array");
+		Tcl_ListObjAppendElement(NULL, elemObjPtr, opObjPtr);
 	    }
 	    if (tvarPtr->flags & TCL_TRACE_READS) {
-		TclNewLiteralStringObj(opObj, "read");
-		Tcl_ListObjAppendElement(NULL, elemObjPtr, opObj);
+		TclNewLiteralStringObj(opObjPtr, "read");
+		Tcl_ListObjAppendElement(NULL, elemObjPtr, opObjPtr);
 	    }
 	    if (tvarPtr->flags & TCL_TRACE_WRITES) {
-		TclNewLiteralStringObj(opObj, "write");
-		Tcl_ListObjAppendElement(NULL, elemObjPtr, opObj);
+		TclNewLiteralStringObj(opObjPtr, "write");
+		Tcl_ListObjAppendElement(NULL, elemObjPtr, opObjPtr);
 	    }
 	    if (tvarPtr->flags & TCL_TRACE_UNSETS) {
-		TclNewLiteralStringObj(opObj, "unset");
-		Tcl_ListObjAppendElement(NULL, elemObjPtr, opObj);
+		TclNewLiteralStringObj(opObjPtr, "unset");
+		Tcl_ListObjAppendElement(NULL, elemObjPtr, opObjPtr);
 	    }
 	    eachTraceObjPtr = Tcl_NewListObj(0, NULL);
 	    Tcl_ListObjAppendElement(NULL, eachTraceObjPtr, elemObjPtr);
@@ -1261,7 +1258,7 @@ TraceCommandProc(
     int flags)			/* OR-ed bits giving operation and other
 				 * information. */
 {
-    TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData;
+    TraceCommandInfo *tcmdPtr = clientData;
     int code;
     Tcl_DString cmd;
 
@@ -1357,7 +1354,7 @@ TraceCommandProc(
 	state = Tcl_SaveInterpState(interp, TCL_OK);
 	Tcl_UntraceCommand(interp, oldName, untraceFlags,
 		TraceCommandProc, clientData);
-	(void) Tcl_RestoreInterpState(interp, state);
+	Tcl_RestoreInterpState(interp, state);
 	tcmdPtr->refCount--;
     }
     if ((--tcmdPtr->refCount) <= 0) {
@@ -1441,8 +1438,7 @@ TclCheckExecutionTraces(
 	    active.nextTracePtr = tracePtr->nextPtr;
 	}
 	if (tracePtr->traceProc == TraceCommandProc) {
-	    TraceCommandInfo *tcmdPtr = (TraceCommandInfo *)
-		    tracePtr->clientData;
+	    TraceCommandInfo *tcmdPtr = tracePtr->clientData;
 
 	    if (tcmdPtr->flags != 0) {
 		tcmdPtr->curFlags = traceFlags | TCL_TRACE_EXEC_DIRECT;
@@ -1451,8 +1447,8 @@ TclCheckExecutionTraces(
 		if (state == NULL) {
 		    state = Tcl_SaveInterpState(interp, code);
 		}
-		traceCode = TraceExecutionProc((ClientData) tcmdPtr, interp,
-			curLevel, command, (Tcl_Command) cmdPtr, objc, objv);
+		traceCode = TraceExecutionProc(tcmdPtr, interp, curLevel,
+			command, (Tcl_Command) cmdPtr, objc, objv);
 		if ((--tcmdPtr->refCount) <= 0) {
 		    ckfree((char *) tcmdPtr);
 		}
@@ -1464,10 +1460,10 @@ TclCheckExecutionTraces(
     }
     iPtr->activeCmdTracePtr = active.nextPtr;
     if (state) {
-	(void) Tcl_RestoreInterpState(interp, state);
+	Tcl_RestoreInterpState(interp, state);
     }
 
-    return(traceCode);
+    return traceCode;
 }
 
 /*
@@ -1565,7 +1561,7 @@ TclCheckInterpTraces(
 	     * it.
 	     */
 
-	    Tcl_Preserve((ClientData) tracePtr);
+	    Tcl_Preserve(tracePtr);
 	    tracePtr->flags |= TCL_TRACE_EXEC_IN_PROGRESS;
 	    if (state == NULL) {
 		state = Tcl_SaveInterpState(interp, code);
@@ -1579,8 +1575,7 @@ TclCheckInterpTraces(
 
 		if (tracePtr->flags & traceFlags) {
 		    if (tracePtr->proc == TraceExecutionProc) {
-			TraceCommandInfo *tcmdPtr = (TraceCommandInfo *)
-				tracePtr->clientData;
+			TraceCommandInfo *tcmdPtr = tracePtr->clientData;
 
 			tcmdPtr->curFlags = traceFlags;
 			tcmdPtr->curCode = code;
@@ -1605,19 +1600,19 @@ TclCheckInterpTraces(
 		}
 	    }
 	    tracePtr->flags &= ~TCL_TRACE_EXEC_IN_PROGRESS;
-	    Tcl_Release((ClientData) tracePtr);
+	    Tcl_Release(tracePtr);
 	}
     }
     iPtr->activeInterpTracePtr = active.nextPtr;
     if (state) {
 	if (traceCode == TCL_OK) {
-	    (void) Tcl_RestoreInterpState(interp, state);
+	    Tcl_RestoreInterpState(interp, state);
 	} else {
 	    Tcl_DiscardInterpState(state);
 	}
     }
 
-    return(traceCode);
+    return traceCode;
 }
 
 /*
@@ -1659,7 +1654,7 @@ CallTraceFunction(
      * Copy the command characters into a new string.
      */
 
-    commandCopy = TclStackAlloc(interp, (unsigned) (numChars + 1));
+    commandCopy = TclStackAlloc(interp, (unsigned) numChars + 1);
     memcpy(commandCopy, command, (size_t) numChars);
     commandCopy[numChars] = '\0';
 
@@ -1667,7 +1662,7 @@ CallTraceFunction(
      * Call the trace function then free allocated storage.
      */
 
-    traceCode = (tracePtr->proc)(tracePtr->clientData, (Tcl_Interp *) iPtr,
+    traceCode = tracePtr->proc(tracePtr->clientData, (Tcl_Interp *) iPtr,
 	    iPtr->numLevels, commandCopy, (Tcl_Command) cmdPtr, objc, objv);
 
     TclStackFree(interp, commandCopy);
@@ -1695,7 +1690,7 @@ static void
 CommandObjTraceDeleted(
     ClientData clientData)
 {
-    TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData;
+    TraceCommandInfo *tcmdPtr = clientData;
 
     if ((--tcmdPtr->refCount) <= 0) {
 	ckfree((char *) tcmdPtr);
@@ -1739,7 +1734,7 @@ TraceExecutionProc(
 {
     int call = 0;
     Interp *iPtr = (Interp *) interp;
-    TraceCommandInfo *tcmdPtr = (TraceCommandInfo *) clientData;
+    TraceCommandInfo *tcmdPtr = clientData;
     int flags = tcmdPtr->curFlags;
     int code = tcmdPtr->curCode;
     int traceCode = TCL_OK;
@@ -1790,8 +1785,7 @@ TraceExecutionProc(
 	 */
 
 	if (call) {
-	    Tcl_DString cmd;
-	    Tcl_DString sub;
+	    Tcl_DString cmd, sub;
 	    int i, saveInterpFlags;
 
 	    Tcl_DStringInit(&cmd);
@@ -1900,8 +1894,7 @@ TraceExecutionProc(
 	    tcmdPtr->refCount++;
 	    tcmdPtr->stepTrace = Tcl_CreateObjTrace(interp, 0,
 		   (tcmdPtr->flags & TCL_TRACE_ANY_EXEC) >> 2,
-		   TraceExecutionProc, (ClientData)tcmdPtr,
-		   CommandObjTraceDeleted);
+		   TraceExecutionProc, tcmdPtr, CommandObjTraceDeleted);
 	}
     }
     if (flags & TCL_TRACE_DESTROYED) {
@@ -1950,7 +1943,7 @@ TraceVarProc(
     int flags)			/* OR-ed bits giving operation and other
 				 * information. */
 {
-    TraceVarInfo *tvarPtr = (TraceVarInfo *) clientData;
+    TraceVarInfo *tvarPtr = clientData;
     char *result;
     int code, destroy = 0;
     Tcl_DString cmd;
@@ -2197,7 +2190,7 @@ Tcl_CreateTrace(
     data->clientData = clientData;
     data->proc = proc;
     return Tcl_CreateObjTrace(interp, level, 0, StringTraceProc,
-	    (ClientData) data, StringTraceDeleteProc);
+	    data, StringTraceDeleteProc);
 }
 
 /*
@@ -2226,7 +2219,7 @@ StringTraceProc(
     int objc,
     Tcl_Obj *const *objv)
 {
-    StringTraceData *data = (StringTraceData *) clientData;
+    StringTraceData *data = clientData;
     Command *cmdPtr = (Command *) commandInfo;
     const char **argv;		/* Args to pass to string trace proc */
     int i;
@@ -2249,7 +2242,7 @@ StringTraceProc(
      * either command or argv.
      */
 
-    (data->proc)(data->clientData, interp, level, (char *) command,
+    data->proc(data->clientData, interp, level, (char *) command,
 	    cmdPtr->proc, cmdPtr->clientData, objc, argv);
     TclStackFree(interp, (void *) argv);
 
@@ -2392,8 +2385,7 @@ TclVarTraceExists(
     Tcl_Interp *interp,		/* The interpreter */
     const char *varName)	/* The variable name */
 {
-    Var *varPtr;
-    Var *arrayPtr;
+    Var *varPtr, *arrayPtr;
 
     /*
      * The choice of "create" flag values is delicate here, and matches the
@@ -2413,7 +2405,7 @@ TclVarTraceExists(
 
     if ((varPtr->flags & VAR_TRACED_READ)
 	    || (arrayPtr && (arrayPtr->flags & VAR_TRACED_READ))) {
-	TclCallVarTraces((Interp *)interp, arrayPtr, varPtr, varName, NULL,
+	TclCallVarTraces((Interp *) interp, arrayPtr, varPtr, varName, NULL,
 		TCL_TRACE_READS, /* leaveErrMsg */ 0);
     }
 
@@ -2576,25 +2568,25 @@ TclCallVarTraces(
     result = NULL;
     active.nextPtr = iPtr->activeVarTracePtr;
     iPtr->activeVarTracePtr = &active;
-    Tcl_Preserve((ClientData) iPtr);
+    Tcl_Preserve(iPtr);
     if (arrayPtr && !TclIsVarTraceActive(arrayPtr)
 	    && (arrayPtr->flags & traceflags)) {
 	hPtr = Tcl_FindHashEntry(&iPtr->varTraces, (char *) arrayPtr);
 	active.varPtr = arrayPtr;
-	for (tracePtr = (VarTrace *) Tcl_GetHashValue(hPtr);
-	     tracePtr != NULL; tracePtr = active.nextTracePtr) {
+	for (tracePtr = Tcl_GetHashValue(hPtr);
+		tracePtr != NULL; tracePtr = active.nextTracePtr) {
 	    active.nextTracePtr = tracePtr->nextPtr;
 	    if (!(tracePtr->flags & flags)) {
 		continue;
 	    }
-	    Tcl_Preserve((ClientData) tracePtr);
+	    Tcl_Preserve(tracePtr);
 	    if (state == NULL) {
-		state = Tcl_SaveInterpState((Tcl_Interp *)iPtr, code);
+		state = Tcl_SaveInterpState((Tcl_Interp *) iPtr, code);
 	    }
-	    if (Tcl_InterpDeleted((Tcl_Interp *)iPtr)) {
+	    if (Tcl_InterpDeleted((Tcl_Interp *) iPtr)) {
 		flags |= TCL_INTERP_DESTROYED;
 	    }
-	    result = (*tracePtr->traceProc)(tracePtr->clientData,
+	    result = tracePtr->traceProc(tracePtr->clientData,
 		    (Tcl_Interp *) iPtr, part1, part2, flags);
 	    if (result != NULL) {
 		if (flags & TCL_TRACE_UNSETS) {
@@ -2608,7 +2600,7 @@ TclCallVarTraces(
 		    code = TCL_ERROR;
 		}
 	    }
-	    Tcl_Release((ClientData) tracePtr);
+	    Tcl_Release(tracePtr);
 	    if (code == TCL_ERROR) {
 		goto done;
 	    }
@@ -2625,20 +2617,20 @@ TclCallVarTraces(
     active.varPtr = varPtr;
     if (varPtr->flags & traceflags) {
 	hPtr = Tcl_FindHashEntry(&iPtr->varTraces, (char *) varPtr);
-	for (tracePtr = (VarTrace *) Tcl_GetHashValue(hPtr);
-	     tracePtr != NULL; tracePtr = active.nextTracePtr) {
+	for (tracePtr = Tcl_GetHashValue(hPtr);
+		tracePtr != NULL; tracePtr = active.nextTracePtr) {
 	    active.nextTracePtr = tracePtr->nextPtr;
 	    if (!(tracePtr->flags & flags)) {
 		continue;
 	    }
-	    Tcl_Preserve((ClientData) tracePtr);
+	    Tcl_Preserve(tracePtr);
 	    if (state == NULL) {
-		state = Tcl_SaveInterpState((Tcl_Interp *)iPtr, code);
+		state = Tcl_SaveInterpState((Tcl_Interp *) iPtr, code);
 	    }
-	    if (Tcl_InterpDeleted((Tcl_Interp *)iPtr)) {
+	    if (Tcl_InterpDeleted((Tcl_Interp *) iPtr)) {
 		flags |= TCL_INTERP_DESTROYED;
 	    }
-	    result = (*tracePtr->traceProc)(tracePtr->clientData,
+	    result = tracePtr->traceProc(tracePtr->clientData,
 		    (Tcl_Interp *) iPtr, part1, part2, flags);
 	    if (result != NULL) {
 		if (flags & TCL_TRACE_UNSETS) {
@@ -2652,7 +2644,7 @@ TclCallVarTraces(
 		    code = TCL_ERROR;
 		}
 	    }
-	    Tcl_Release((ClientData) tracePtr);
+	    Tcl_Release(tracePtr);
 	    if (code == TCL_ERROR) {
 		goto done;
 	    }
@@ -2713,16 +2705,16 @@ TclCallVarTraces(
 	    Tcl_DictObjPut(NULL, options, errorInfoKey, errorInfo);
 	    Tcl_DecrRefCount(errorInfoKey);
 	    Tcl_DecrRefCount(errorInfo);
-	    code = Tcl_SetReturnOptions((Tcl_Interp *)iPtr, options);
+	    code = Tcl_SetReturnOptions((Tcl_Interp *) iPtr, options);
 	    iPtr->flags &= ~(ERR_ALREADY_LOGGED);
 	    Tcl_DiscardInterpState(state);
 	} else {
-	    (void) Tcl_RestoreInterpState((Tcl_Interp *)iPtr, state);
+	    Tcl_RestoreInterpState((Tcl_Interp *) iPtr, state);
 	}
 	DisposeTraceResult(disposeFlags,result);
     } else if (state) {
 	if (code == TCL_OK) {
-	    code = Tcl_RestoreInterpState((Tcl_Interp *)iPtr, state);
+	    code = Tcl_RestoreInterpState((Tcl_Interp *) iPtr, state);
 	} else {
 	    Tcl_DiscardInterpState(state);
 	}
@@ -2739,7 +2731,7 @@ TclCallVarTraces(
 	VarHashRefCount(varPtr)--;
     }
     iPtr->activeVarTracePtr = active.nextPtr;
-    Tcl_Release((ClientData) iPtr);
+    Tcl_Release(iPtr);
     return code;
 }
 
@@ -2870,9 +2862,8 @@ Tcl_UntraceVar2(
 #endif
     flags &= flagMask;
 
-    hPtr = Tcl_FindHashEntry(&iPtr->varTraces,
-	    (char *) varPtr);
-    for (tracePtr = (VarTrace *) Tcl_GetHashValue(hPtr), prevPtr = NULL; ;
+    hPtr = Tcl_FindHashEntry(&iPtr->varTraces, (char *) varPtr);
+    for (tracePtr = Tcl_GetHashValue(hPtr), prevPtr = NULL; ;
 	    prevPtr = tracePtr, tracePtr = tracePtr->nextPtr) {
 	if (tracePtr == NULL) {
 	    goto updateFlags;
@@ -2906,7 +2897,7 @@ Tcl_UntraceVar2(
     } else {
 	prevPtr->nextPtr = nextPtr;
     }
-    Tcl_EventuallyFree((ClientData) tracePtr, TCL_DYNAMIC);
+    Tcl_EventuallyFree(tracePtr, TCL_DYNAMIC);
 
     for (tracePtr = nextPtr; tracePtr != NULL;
 	    tracePtr = tracePtr->nextPtr) {
@@ -3000,7 +2991,6 @@ Tcl_VarTraceInfo2(
 				 * call will return the first trace. */
 {
     Interp *iPtr = (Interp *) interp;
-    register VarTrace *tracePtr;
     Var *varPtr, *arrayPtr;
     Tcl_HashEntry *hPtr;
 
@@ -3015,14 +3005,13 @@ Tcl_VarTraceInfo2(
      * Find the relevant trace, if any, and return its clientData.
      */
 
-    hPtr = Tcl_FindHashEntry(&iPtr->varTraces,
-	    (char *) varPtr);
+    hPtr = Tcl_FindHashEntry(&iPtr->varTraces, (char *) varPtr);
 
     if (hPtr) {
-	tracePtr = Tcl_GetHashValue(hPtr);
+	register VarTrace *tracePtr = Tcl_GetHashValue(hPtr);
 
 	if (prevClientData != NULL) {
-	    for ( ;  tracePtr != NULL;  tracePtr = tracePtr->nextPtr) {
+	    for (; tracePtr != NULL; tracePtr = tracePtr->nextPtr) {
 		if ((tracePtr->clientData == prevClientData)
 			&& (tracePtr->traceProc == proc)) {
 		    tracePtr = tracePtr->nextPtr;
@@ -3030,7 +3019,7 @@ Tcl_VarTraceInfo2(
 		}
 	    }
 	}
-	for (; tracePtr!=NULL ; tracePtr=tracePtr->nextPtr) {
+	for (; tracePtr != NULL ; tracePtr = tracePtr->nextPtr) {
 	    if (tracePtr->traceProc == proc) {
 		return tracePtr->clientData;
 	    }
@@ -3191,8 +3180,8 @@ TraceVarEx(
      * because there should be no code path that ever sets both flags.
      */
 
-    if ((tracePtr->flags&TCL_TRACE_RESULT_DYNAMIC)
-	    && (tracePtr->flags&TCL_TRACE_RESULT_OBJECT)) {
+    if ((tracePtr->flags & TCL_TRACE_RESULT_DYNAMIC)
+	    && (tracePtr->flags & TCL_TRACE_RESULT_OBJECT)) {
 	Tcl_Panic("bad result flag combination");
     }
 
@@ -3211,9 +3200,9 @@ TraceVarEx(
     if (isNew) {
 	tracePtr->nextPtr = NULL;
     } else {
-	tracePtr->nextPtr = (VarTrace *) Tcl_GetHashValue(hPtr);
+	tracePtr->nextPtr = Tcl_GetHashValue(hPtr);
     }
-    Tcl_SetHashValue(hPtr, (char *) tracePtr);
+    Tcl_SetHashValue(hPtr, tracePtr);
 
     /*
      * Mark the variable as traced so we know to call them.