Style improvements - invoking callbacks without visual junk.

26 files changed, 948 insertions, 953 deletions

diff --git a/generic/regexec.c b/generic/regexec.c
index 24edb41..ed6ceec 100644
--- a/generic/regexec.c
+++ b/generic/regexec.c
@@ -1132,7 +1132,7 @@ cbrdissect(
 
     i = 0;
     for (p = begin; p <= stop && (i < max || max == INFINITY); p += len) {
-	if ((*v->g->compare)(paren, p, len) != 0) {
+	if (v->g->compare(paren, p, len) != 0) {
 	    break;
 	}
 	i++;
diff --git a/generic/tclAsync.c b/generic/tclAsync.c
index 1e5733e..175eaad 100644
--- a/generic/tclAsync.c
+++ b/generic/tclAsync.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: tclAsync.c,v 1.16 2008/05/03 19:31:07 das Exp $
+ * RCS: @(#) $Id: tclAsync.c,v 1.17 2008/10/26 18:34:03 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -237,7 +237,7 @@ Tcl_AsyncInvoke(
 	}
 	asyncPtr->ready = 0;
 	Tcl_MutexUnlock(&tsdPtr->asyncMutex);
-	code = (*asyncPtr->proc)(asyncPtr->clientData, interp, code);
+	code = asyncPtr->proc(asyncPtr->clientData, interp, code);
 	Tcl_MutexLock(&tsdPtr->asyncMutex);
     }
     tsdPtr->asyncActive = 0;
diff --git a/generic/tclBinary.c b/generic/tclBinary.c
index 4073a61..680ef41 100644
--- a/generic/tclBinary.c
+++ b/generic/tclBinary.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: tclBinary.c,v 1.48 2008/10/15 06:17:04 nijtmans Exp $
+ * RCS: @(#) $Id: tclBinary.c,v 1.49 2008/10/26 18:34:03 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -71,7 +71,7 @@ static void		UpdateStringOfByteArray(Tcl_Obj *listPtr);
 static void		DeleteScanNumberCache(Tcl_HashTable *numberCachePtr);
 static int		NeedReversing(int format);
 static void		CopyNumber(const void *from, void *to,
-			    unsigned int length, int type);
+			    unsigned length, int type);
 /* Binary ensemble commands */
 static int		BinaryFormatCmd(ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
@@ -452,7 +452,7 @@ SetByteArrayFromAny(
 	byteArrayPtr = (ByteArray *) ckalloc(BYTEARRAY_SIZE(length));
 	for (dst = byteArrayPtr->bytes; src < srcEnd; ) {
 	    src += Tcl_UtfToUniChar(src, &ch);
-	    *dst++ = (unsigned char) ch;
+	    *dst++ = UCHAR(ch);
 	}
 
 	byteArrayPtr->used = dst - byteArrayPtr->bytes;
@@ -977,7 +977,7 @@ BinaryFormatCmd(
 			    goto badValue;
 			}
 			if (((offset + 1) % 8) == 0) {
-			    *cursor++ = (unsigned char) value;
+			    *cursor++ = UCHAR(value);
 			    value = 0;
 			}
 		    }
@@ -992,7 +992,7 @@ BinaryFormatCmd(
 			    goto badValue;
 			}
 			if (!((offset + 1) % 8)) {
-			    *cursor++ = (unsigned char) value;
+			    *cursor++ = UCHAR(value);
 			    value = 0;
 			}
 		    }
@@ -1003,7 +1003,7 @@ BinaryFormatCmd(
 		    } else {
 			value >>= 8 - (offset % 8);
 		    }
-		    *cursor++ = (unsigned char) value;
+		    *cursor++ = UCHAR(value);
 		}
 		while (cursor < last) {
 		    *cursor++ = '\0';
@@ -1067,7 +1067,7 @@ BinaryFormatCmd(
 			}
 			value |= ((c << 4) & 0xf0);
 			if (offset % 2) {
-			    *cursor++ = (unsigned char)(value & 0xff);
+			    *cursor++ = UCHAR(value & 0xff);
 			    value = 0;
 			}
 		    }
@@ -1078,7 +1078,7 @@ BinaryFormatCmd(
 		    } else {
 			value >>= 4;
 		    }
-		    *cursor++ = (unsigned char) value;
+		    *cursor++ = UCHAR(value);
 		}
 
 		while (cursor < last) {
@@ -1751,7 +1751,7 @@ static void
 CopyNumber(
     const void *from,		/* source */
     void *to,			/* destination */
-    unsigned int length,	/* Number of bytes to copy */
+    unsigned length,		/* Number of bytes to copy */
     int type)			/* What type of thing are we copying? */
 {
     switch (NeedReversing(type)) {
@@ -1904,23 +1904,23 @@ FormatNumber(
 	    return TCL_ERROR;
 	}
 	if (NeedReversing(type)) {
-	    *(*cursorPtr)++ = (unsigned char) wvalue;
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 8);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 16);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 24);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 32);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 40);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 48);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 56);
+	    *(*cursorPtr)++ = UCHAR(wvalue);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 8);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 16);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 24);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 32);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 40);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 48);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 56);
 	} else {
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 56);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 48);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 40);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 32);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 24);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 16);
-	    *(*cursorPtr)++ = (unsigned char) (wvalue >> 8);
-	    *(*cursorPtr)++ = (unsigned char) wvalue;
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 56);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 48);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 40);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 32);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 24);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 16);
+	    *(*cursorPtr)++ = UCHAR(wvalue >> 8);
+	    *(*cursorPtr)++ = UCHAR(wvalue);
 	}
 	return TCL_OK;
 
@@ -1934,15 +1934,15 @@ FormatNumber(
 	    return TCL_ERROR;
 	}
 	if (NeedReversing(type)) {
-	    *(*cursorPtr)++ = (unsigned char) value;
-	    *(*cursorPtr)++ = (unsigned char) (value >> 8);
-	    *(*cursorPtr)++ = (unsigned char) (value >> 16);
-	    *(*cursorPtr)++ = (unsigned char) (value >> 24);
+	    *(*cursorPtr)++ = UCHAR(value);
+	    *(*cursorPtr)++ = UCHAR(value >> 8);
+	    *(*cursorPtr)++ = UCHAR(value >> 16);
+	    *(*cursorPtr)++ = UCHAR(value >> 24);
 	} else {
-	    *(*cursorPtr)++ = (unsigned char) (value >> 24);
-	    *(*cursorPtr)++ = (unsigned char) (value >> 16);
-	    *(*cursorPtr)++ = (unsigned char) (value >> 8);
-	    *(*cursorPtr)++ = (unsigned char) value;
+	    *(*cursorPtr)++ = UCHAR(value >> 24);
+	    *(*cursorPtr)++ = UCHAR(value >> 16);
+	    *(*cursorPtr)++ = UCHAR(value >> 8);
+	    *(*cursorPtr)++ = UCHAR(value);
 	}
 	return TCL_OK;
 
@@ -1956,11 +1956,11 @@ FormatNumber(
 	    return TCL_ERROR;
 	}
 	if (NeedReversing(type)) {
-	    *(*cursorPtr)++ = (unsigned char) value;
-	    *(*cursorPtr)++ = (unsigned char) (value >> 8);
+	    *(*cursorPtr)++ = UCHAR(value);
+	    *(*cursorPtr)++ = UCHAR(value >> 8);
 	} else {
-	    *(*cursorPtr)++ = (unsigned char) (value >> 8);
-	    *(*cursorPtr)++ = (unsigned char) value;
+	    *(*cursorPtr)++ = UCHAR(value >> 8);
+	    *(*cursorPtr)++ = UCHAR(value);
 	}
 	return TCL_OK;
 
@@ -1971,7 +1971,7 @@ FormatNumber(
 	if (TclGetLongFromObj(interp, src, &value) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	*(*cursorPtr)++ = (unsigned char) value;
+	*(*cursorPtr)++ = UCHAR(value);
 	return TCL_OK;
 
     default:
@@ -2076,7 +2076,7 @@ ScanNumber(
 	    value = (long) (buffer[3]
 		    + (buffer[2] << 8)
 		    + (buffer[1] << 16)
-		    + (((long)buffer[0]) << 24));
+		    + (((long) buffer[0]) << 24));
 	}
 
 	/*
@@ -2089,9 +2089,9 @@ ScanNumber(
 	if (flags & BINARY_UNSIGNED) {
 	    return Tcl_NewWideIntObj((Tcl_WideInt)(unsigned long)value);
 	}
-	if ((value & (((unsigned int)1)<<31)) && (value > 0)) {
-	    value -= (((unsigned int)1)<<31);
-	    value -= (((unsigned int)1)<<31);
+	if ((value & (((unsigned) 1)<<31)) && (value > 0)) {
+	    value -= (((unsigned) 1)<<31);
+	    value -= (((unsigned) 1)<<31);
 	}
 
     returnNumericObject:
@@ -2104,13 +2104,13 @@ ScanNumber(
 
 	    hPtr = Tcl_CreateHashEntry(tablePtr, (char *)value, &isNew);
 	    if (!isNew) {
-		return (Tcl_Obj *) Tcl_GetHashValue(hPtr);
+		return Tcl_GetHashValue(hPtr);
 	    }
 	    if (tablePtr->numEntries <= BINARY_SCAN_MAX_CACHE) {
 		register Tcl_Obj *objPtr = Tcl_NewLongObj(value);
 
 		Tcl_IncrRefCount(objPtr);
-		Tcl_SetHashValue(hPtr, (ClientData) objPtr);
+		Tcl_SetHashValue(hPtr, objPtr);
 		return objPtr;
 	    }
 
@@ -2360,10 +2360,9 @@ BinaryDecodeHex(
 		if (!isxdigit((int) c)) {
 		    if (strict) {
 			goto badChar;
-		    } else {
-			i--;
-			continue;
 		    }
+		    i--;
+		    continue;
 		}
 		value <<= 4;
 		c -= '0';
@@ -2572,10 +2571,9 @@ BinaryDecodeUu(
 		if (c < 33 || c > 96) {
 		    if (strict) {
 			goto badUu;
-		    } else {
-			i--;
-			continue;
 		    }
+		    i--;
+		    continue;
 		}
 	    } else {
 		++cut;
diff --git a/generic/tclClock.c b/generic/tclClock.c
index 8b2e259..7b445ca 100644
--- a/generic/tclClock.c
+++ b/generic/tclClock.c
@@ -7,12 +7,12 @@
  *
  * Copyright 1991-1995 Karl Lehenbauer and Mark Diekhans.
  * Copyright (c) 1995 Sun Microsystems, Inc.
- * Copyright (c) 2004 by Kevin B. Kenny.  All rights reserved.
+ * Copyright (c) 2004 by Kevin B. Kenny. All rights reserved.
  *
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclClock.c,v 1.71 2008/10/16 22:34:19 nijtmans Exp $
+ * RCS: @(#) $Id: tclClock.c,v 1.72 2008/10/26 18:34:03 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -33,12 +33,12 @@
 #define SECONDS_PER_DAY			86400
 #define JULIAN_SEC_POSIX_EPOCH	      (((Tcl_WideInt) JULIAN_DAY_POSIX_EPOCH) \
 					* SECONDS_PER_DAY)
-#define FOUR_CENTURIES			146097 /* days */
+#define FOUR_CENTURIES			146097	/* days */
 #define JDAY_1_JAN_1_CE_JULIAN		1721424
 #define JDAY_1_JAN_1_CE_GREGORIAN	1721426
-#define ONE_CENTURY_GREGORIAN		36524  /* days */
-#define FOUR_YEARS			1461   /* days */
-#define ONE_YEAR			365    /* days */
+#define ONE_CENTURY_GREGORIAN		36524	/* days */
+#define FOUR_YEARS			1461	/* days */
+#define ONE_YEAR			365	/* days */
 
 /*
  * Table of the days in each month, leap and common years
@@ -94,8 +94,8 @@ static const char *const literals[] = {
  */
 
 typedef struct ClockClientData {
-    int refCount;		/* Number of live references */
-    Tcl_Obj** literals;		/* Pool of object literals */
+    int refCount;		/* Number of live references. */
+    Tcl_Obj **literals;		/* Pool of object literals. */
 } ClockClientData;
 
 /*
@@ -109,7 +109,7 @@ typedef struct TclDateFields {
 				 * from the Posix epoch */
     int tzOffset;		/* Time zone offset in seconds east of
 				 * Greenwich */
-    Tcl_Obj* tzName;		/* Time zone name */
+    Tcl_Obj *tzName;		/* Time zone name */
     int julianDay;		/* Julian Day Number in local time zone */
     enum {BCE=1, CE=0} era;	/* Era */
     int gregorian;		/* Flag == 1 if the date is Gregorian */
@@ -141,26 +141,26 @@ TCL_DECLARE_MUTEX(clockMutex)
  * Function prototypes for local procedures in this file:
  */
 
-static int		ConvertUTCToLocal(Tcl_Interp*,
-			    TclDateFields*, Tcl_Obj*, int);
-static int		ConvertUTCToLocalUsingTable(Tcl_Interp*,
-			    TclDateFields*, int, Tcl_Obj *const[]);
-static int		ConvertUTCToLocalUsingC(Tcl_Interp*,
-			    TclDateFields*, int);
-static int		ConvertLocalToUTC(Tcl_Interp*,
-			    TclDateFields*, Tcl_Obj*, int);
-static int		ConvertLocalToUTCUsingTable(Tcl_Interp*,
-			    TclDateFields*, int, Tcl_Obj *const[]);
-static int		ConvertLocalToUTCUsingC(Tcl_Interp*,
-			    TclDateFields*, int);
-static Tcl_Obj*		LookupLastTransition(Tcl_Interp*, Tcl_WideInt,
+static int		ConvertUTCToLocal(Tcl_Interp *,
+			    TclDateFields *, Tcl_Obj *, int);
+static int		ConvertUTCToLocalUsingTable(Tcl_Interp *,
+			    TclDateFields *, int, Tcl_Obj *const[]);
+static int		ConvertUTCToLocalUsingC(Tcl_Interp *,
+			    TclDateFields *, int);
+static int		ConvertLocalToUTC(Tcl_Interp *,
+			    TclDateFields *, Tcl_Obj *, int);
+static int		ConvertLocalToUTCUsingTable(Tcl_Interp *,
+			    TclDateFields *, int, Tcl_Obj *const[]);
+static int		ConvertLocalToUTCUsingC(Tcl_Interp *,
+			    TclDateFields *, int);
+static Tcl_Obj *	LookupLastTransition(Tcl_Interp *, Tcl_WideInt,
 			    int, Tcl_Obj *const *);
-static void		GetYearWeekDay(TclDateFields*, int);
-static void		GetGregorianEraYearDay(TclDateFields*, int);
-static void		GetMonthDay(TclDateFields*);
-static void		GetJulianDayFromEraYearWeekDay(TclDateFields*, int);
-static void		GetJulianDayFromEraYearMonthDay(TclDateFields*, int);
-static int		IsGregorianLeapYear(TclDateFields*);
+static void		GetYearWeekDay(TclDateFields *, int);
+static void		GetGregorianEraYearDay(TclDateFields *, int);
+static void		GetMonthDay(TclDateFields *);
+static void		GetJulianDayFromEraYearWeekDay(TclDateFields *, int);
+static void		GetJulianDayFromEraYearMonthDay(TclDateFields *, int);
+static int		IsGregorianLeapYear(TclDateFields *);
 static int		WeekdayOnOrBefore(int, int);
 static int		ClockClicksObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
@@ -187,7 +187,7 @@ static int		ClockMillisecondsObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
 static int		ClockParseformatargsObjCmd(
-			    ClientData clientData, Tcl_Interp* interp,
+			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
 static int		ClockSecondsObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
@@ -225,7 +225,7 @@ static const struct ClockCommand clockCommands[] = {
     { "ParseFormatArgs",	ClockParseformatargsObjCmd },
     { NULL, NULL }
 };
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -261,7 +261,7 @@ TclClockInit(
 
     data = (ClockClientData *) ckalloc(sizeof(ClockClientData));
     data->refCount = 0;
-    data->literals = (Tcl_Obj**) ckalloc(LIT__END * sizeof(Tcl_Obj*));
+    data->literals = (Tcl_Obj **) ckalloc(LIT__END * sizeof(Tcl_Obj*));
     for (i = 0; i < LIT__END; ++i) {
 	data->literals[i] = Tcl_NewStringObj(literals[i], -1);
 	Tcl_IncrRefCount(data->literals[i]);
@@ -280,7 +280,7 @@ TclClockInit(
 		ClockDeleteCmdProc);
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -310,15 +310,15 @@ TclClockInit(
 
 static int
 ClockConvertlocaltoutcObjCmd(
-    ClientData clientData,	/* Client data  */
-    Tcl_Interp* interp,		/* Tcl interpreter */
+    ClientData clientData,	/* Client data */
+    Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter vector */
 {
-    ClockClientData* data = (ClockClientData*) clientData;
-    Tcl_Obj* const * literals = data->literals;
-    Tcl_Obj* secondsObj;
-    Tcl_Obj* dict;
+    ClockClientData *data = clientData;
+    Tcl_Obj *const *literals = data->literals;
+    Tcl_Obj *secondsObj;
+    Tcl_Obj *dict;
     int changeover;
     TclDateFields fields;
     int created = 0;
@@ -334,16 +334,16 @@ ClockConvertlocaltoutcObjCmd(
     }
     dict = objv[1];
     if (Tcl_DictObjGet(interp, dict, literals[LIT_LOCALSECONDS],
-		       &secondsObj)!= TCL_OK) {
+	    &secondsObj)!= TCL_OK) {
 	return TCL_ERROR;
     }
     if (secondsObj == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj("key \"localseconds\" not "
-						  "found in dictionary", -1));
+		"found in dictionary", -1));
 	return TCL_ERROR;
     }
     if ((Tcl_GetWideIntFromObj(interp, secondsObj,
-			      &(fields.localSeconds)) != TCL_OK)
+	    &fields.localSeconds) != TCL_OK)
 	|| (TclGetIntFromObj(interp, objv[3], &changeover) != TCL_OK)
 	|| ConvertLocalToUTC(interp, &fields, objv[2], changeover)) {
 	return TCL_ERROR;
@@ -369,7 +369,7 @@ ClockConvertlocaltoutcObjCmd(
     }
     return status;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -383,16 +383,16 @@ ClockConvertlocaltoutcObjCmd(
  *
  * Parameters:
  *	seconds - Time expressed in seconds from the Posix epoch.
- *	tzdata - Time zone data of the time zone in which time is to
- *                 be expressed.
+ *	tzdata - Time zone data of the time zone in which time is to be
+ *		 expressed.
  *	changeover - Julian Day Number at which the current locale adopted
  *		     the Gregorian calendar
  *
  * Results:
  *	Returns a dictonary populated with the fields:
  *		seconds - Seconds from the Posix epoch
- *		localSeconds - Nominal seconds from the Posix epoch in
- *			       the local time zone.
+ *		localSeconds - Nominal seconds from the Posix epoch in the
+ *			       local time zone.
  *		tzOffset - Time zone offset in seconds east of Greenwich
  *		tzName - Time zone name
  *		julianDay - Julian Day Number in the local time zone
@@ -403,14 +403,14 @@ ClockConvertlocaltoutcObjCmd(
 int
 ClockGetdatefieldsObjCmd(
     ClientData clientData,	/* Opaque pointer to literal pool, etc. */
-    Tcl_Interp* interp,		/* Tcl interpreter */
+    Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter vector */
 {
     TclDateFields fields;
-    Tcl_Obj* dict;
-    ClockClientData* data = (ClockClientData*) clientData;
-    Tcl_Obj* const * literals = data->literals;
+    Tcl_Obj *dict;
+    ClockClientData *data = clientData;
+    Tcl_Obj *const *literals = data->literals;
     int changeover;
 
     /*
@@ -421,14 +421,14 @@ ClockGetdatefieldsObjCmd(
 	Tcl_WrongNumArgs(interp, 1, objv, "seconds tzdata changeover");
 	return TCL_ERROR;
     }
-    if (Tcl_GetWideIntFromObj(interp, objv[1], &(fields.seconds)) != TCL_OK
+    if (Tcl_GetWideIntFromObj(interp, objv[1], &fields.seconds) != TCL_OK
 	    || TclGetIntFromObj(interp, objv[3], &changeover) != TCL_OK) {
 	return TCL_ERROR;
     }
 
     /*
-     * fields.seconds could be an unsigned number that overflowed.  Make
-     * sure that it isn't.
+     * fields.seconds could be an unsigned number that overflowed. Make sure
+     * that it isn't.
      */
 
     if (objv[1]->typePtr == &tclBignumType) {
@@ -492,7 +492,7 @@ ClockGetdatefieldsObjCmd(
 
     return TCL_OK;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -515,17 +515,17 @@ ClockGetdatefieldsObjCmd(
  */
 
 static int
-ClockGetjuliandayfromerayearmonthdayObjCmd (
+ClockGetjuliandayfromerayearmonthdayObjCmd(
     ClientData clientData,	/* Opaque pointer to literal pool, etc. */
-    Tcl_Interp* interp,		/* Tcl interpreter */
+    Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter vector */
 {
     TclDateFields fields;
-    Tcl_Obj* dict;
-    ClockClientData* data = (ClockClientData*) clientData;
-    Tcl_Obj* const * literals = data->literals;
-    Tcl_Obj* fieldPtr;
+    Tcl_Obj *dict;
+    ClockClientData *data = clientData;
+    Tcl_Obj *const *literals = data->literals;
+    Tcl_Obj *fieldPtr;
     int changeover;
     int copied = 0;
     int status;
@@ -545,14 +545,13 @@ ClockGetjuliandayfromerayearmonthdayObjCmd (
 		&era) != TCL_OK
 	    || Tcl_DictObjGet(interp, dict, literals[LIT_YEAR],
 		&fieldPtr) != TCL_OK
-	    || TclGetIntFromObj(interp, fieldPtr, &(fields.year)) != TCL_OK
+	    || TclGetIntFromObj(interp, fieldPtr, &fields.year) != TCL_OK
 	    || Tcl_DictObjGet(interp, dict, literals[LIT_MONTH],
 		&fieldPtr) != TCL_OK
-	    || TclGetIntFromObj(interp, fieldPtr, &(fields.month)) != TCL_OK
+	    || TclGetIntFromObj(interp, fieldPtr, &fields.month) != TCL_OK
 	    || Tcl_DictObjGet(interp, dict, literals[LIT_DAYOFMONTH],
 		&fieldPtr) != TCL_OK
-	    || TclGetIntFromObj(interp, fieldPtr,
-		&(fields.dayOfMonth)) != TCL_OK
+	    || TclGetIntFromObj(interp, fieldPtr, &fields.dayOfMonth)!=TCL_OK
 	    || TclGetIntFromObj(interp, objv[2], &changeover) != TCL_OK) {
 	return TCL_ERROR;
     }
@@ -583,7 +582,7 @@ ClockGetjuliandayfromerayearmonthdayObjCmd (
     }
     return status;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -606,17 +605,17 @@ ClockGetjuliandayfromerayearmonthdayObjCmd (
  */
 
 static int
-ClockGetjuliandayfromerayearweekdayObjCmd (
+ClockGetjuliandayfromerayearweekdayObjCmd(
     ClientData clientData,	/* Opaque pointer to literal pool, etc. */
-    Tcl_Interp* interp,		/* Tcl interpreter */
+    Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter vector */
 {
     TclDateFields fields;
-    Tcl_Obj* dict;
-    ClockClientData* data = (ClockClientData*) clientData;
-    Tcl_Obj* const * literals = data->literals;
-    Tcl_Obj* fieldPtr;
+    Tcl_Obj *dict;
+    ClockClientData *data = clientData;
+    Tcl_Obj *const *literals = data->literals;
+    Tcl_Obj *fieldPtr;
     int changeover;
     int copied = 0;
     int status;
@@ -636,16 +635,13 @@ ClockGetjuliandayfromerayearweekdayObjCmd (
 		&era) != TCL_OK
 	    || Tcl_DictObjGet(interp, dict, literals[LIT_ISO8601YEAR],
 		&fieldPtr) != TCL_OK
-	    || TclGetIntFromObj(interp, fieldPtr,
-		&(fields.iso8601Year)) != TCL_OK
+	    || TclGetIntFromObj(interp, fieldPtr, &fields.iso8601Year)!=TCL_OK
 	    || Tcl_DictObjGet(interp, dict, literals[LIT_ISO8601WEEK],
 		&fieldPtr) != TCL_OK
-	    || TclGetIntFromObj(interp, fieldPtr,
-		&(fields.iso8601Week)) != TCL_OK
+	    || TclGetIntFromObj(interp, fieldPtr, &fields.iso8601Week)!=TCL_OK
 	    || Tcl_DictObjGet(interp, dict, literals[LIT_DAYOFWEEK],
 		&fieldPtr) != TCL_OK
-	    || TclGetIntFromObj(interp, fieldPtr,
-		&(fields.dayOfWeek)) != TCL_OK
+	    || TclGetIntFromObj(interp, fieldPtr, &fields.dayOfWeek) != TCL_OK
 	    || TclGetIntFromObj(interp, objv[2], &changeover) != TCL_OK) {
 	return TCL_ERROR;
     }
@@ -676,7 +672,7 @@ ClockGetjuliandayfromerayearweekdayObjCmd (
     }
     return status;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -697,13 +693,13 @@ ClockGetjuliandayfromerayearweekdayObjCmd (
 
 static int
 ConvertLocalToUTC(
-    Tcl_Interp* interp,		/* Tcl interpreter */
-    TclDateFields* fields,	/* Fields of the time */
-    Tcl_Obj* tzdata,		/* Time zone data */
+    Tcl_Interp *interp,		/* Tcl interpreter */
+    TclDateFields *fields,	/* Fields of the time */
+    Tcl_Obj *tzdata,		/* Time zone data */
     int changeover)		/* Julian Day of the Gregorian transition */
 {
     int rowc;			/* Number of rows in tzdata */
-    Tcl_Obj** rowv;		/* Pointers to the rows */
+    Tcl_Obj **rowv;		/* Pointers to the rows */
 
     /*
      * Unpack the tz data.
@@ -724,7 +720,7 @@ ConvertLocalToUTC(
 	return ConvertLocalToUTCUsingTable(interp, fields, rowc, rowv);
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -745,14 +741,14 @@ ConvertLocalToUTC(
 
 static int
 ConvertLocalToUTCUsingTable(
-    Tcl_Interp* interp,		/* Tcl interpreter */
-    TclDateFields* fields,	/* Time to convert, with 'seconds' filled in */
+    Tcl_Interp *interp,		/* Tcl interpreter */
+    TclDateFields *fields,	/* Time to convert, with 'seconds' filled in */
     int rowc,			/* Number of points at which time changes */
     Tcl_Obj *const rowv[])	/* Points at which time changes */
 {
-    Tcl_Obj* row;
+    Tcl_Obj *row;
     int cellc;
-    Tcl_Obj** cellv;
+    Tcl_Obj **cellv;
     int have[8];
     int nHave = 0;
     int i;
@@ -777,7 +773,7 @@ ConvertLocalToUTCUsingTable(
 		|| TclListObjGetElements(interp, row, &cellc,
 		    &cellv) != TCL_OK
 		|| TclGetIntFromObj(interp, cellv[1],
-		    &(fields->tzOffset)) != TCL_OK) {
+		    &fields->tzOffset) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 	found = 0;
@@ -800,7 +796,7 @@ ConvertLocalToUTCUsingTable(
     fields->seconds = fields->localSeconds - fields->tzOffset;
     return TCL_OK;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -821,8 +817,8 @@ ConvertLocalToUTCUsingTable(
 
 static int
 ConvertLocalToUTCUsingC(
-    Tcl_Interp* interp,		/* Tcl interpreter */
-    TclDateFields* fields,	/* Time to convert, with 'seconds' filled in */
+    Tcl_Interp *interp,		/* Tcl interpreter */
+    TclDateFields *fields,	/* Time to convert, with 'seconds' filled in */
     int changeover)		/* Julian Day of the Gregorian transition */
 {
     struct tm timeVal;
@@ -882,7 +878,7 @@ ConvertLocalToUTCUsingC(
     }
     return TCL_OK;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -901,13 +897,13 @@ ConvertLocalToUTCUsingC(
 
 static int
 ConvertUTCToLocal(
-    Tcl_Interp* interp,		/* Tcl interpreter */
-    TclDateFields* fields,	/* Fields of the time */
-    Tcl_Obj* tzdata,		/* Time zone data */
+    Tcl_Interp *interp,		/* Tcl interpreter */
+    TclDateFields *fields,	/* Fields of the time */
+    Tcl_Obj *tzdata,		/* Time zone data */
     int changeover)		/* Julian Day of the Gregorian transition */
 {
     int rowc;			/* Number of rows in tzdata */
-    Tcl_Obj** rowv;		/* Pointers to the rows */
+    Tcl_Obj **rowv;		/* Pointers to the rows */
 
     /*
      * Unpack the tz data.
@@ -928,7 +924,7 @@ ConvertUTCToLocal(
 	return ConvertUTCToLocalUsingTable(interp, fields, rowc, rowv);
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -949,15 +945,15 @@ ConvertUTCToLocal(
 
 static int
 ConvertUTCToLocalUsingTable(
-    Tcl_Interp* interp,		/* Tcl interpreter */
-    TclDateFields* fields,	/* Fields of the date */
+    Tcl_Interp *interp,		/* Tcl interpreter */
+    TclDateFields *fields,	/* Fields of the date */
     int rowc,			/* Number of rows in the conversion table
 				 * (>= 1) */
     Tcl_Obj *const rowv[])	/* Rows of the conversion table */
 {
-    Tcl_Obj* row;		/* Row containing the current information */
+    Tcl_Obj *row;		/* Row containing the current information */
     int cellc;			/* Count of cells in the row (must be 4) */
-    Tcl_Obj** cellv;		/* Pointers to the cells */
+    Tcl_Obj **cellv;		/* Pointers to the cells */
 
     /*
      * Look up the nearest transition time.
@@ -966,7 +962,7 @@ ConvertUTCToLocalUsingTable(
     row = LookupLastTransition(interp, fields->seconds, rowc, rowv);
     if (row == NULL ||
 	    TclListObjGetElements(interp, row, &cellc, &cellv) != TCL_OK ||
-	    TclGetIntFromObj(interp,cellv[1],&(fields->tzOffset)) != TCL_OK) {
+	    TclGetIntFromObj(interp, cellv[1], &fields->tzOffset) != TCL_OK) {
 	return TCL_ERROR;
     }
 
@@ -979,7 +975,7 @@ ConvertUTCToLocalUsingTable(
     fields->localSeconds = fields->seconds + fields->tzOffset;
     return TCL_OK;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1001,12 +997,12 @@ ConvertUTCToLocalUsingTable(
 
 static int
 ConvertUTCToLocalUsingC(
-    Tcl_Interp* interp,		/* Tcl interpreter */
-    TclDateFields* fields,	/* Time to convert, with 'seconds' filled in */
+    Tcl_Interp *interp,		/* Tcl interpreter */
+    TclDateFields *fields,	/* Time to convert, with 'seconds' filled in */
     int changeover)		/* Julian Day of the Gregorian transition */
 {
     time_t tock;
-    struct tm* timeVal;		/* Time after conversion */
+    struct tm *timeVal;		/* Time after conversion */
     int diff;			/* Time zone diff local-Greenwich */
     char buffer[8];		/* Buffer for time zone name */
 
@@ -1072,7 +1068,7 @@ ConvertUTCToLocalUsingC(
     Tcl_IncrRefCount(fields->tzName);
     return TCL_OK;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1087,16 +1083,16 @@ ConvertUTCToLocalUsingC(
  *----------------------------------------------------------------------
  */
 
-static Tcl_Obj*
+static Tcl_Obj *
 LookupLastTransition(
-    Tcl_Interp* interp,		/* Interpreter for error messages */
+    Tcl_Interp *interp,		/* Interpreter for error messages */
     Tcl_WideInt tick,		/* Time from the epoch */
     int rowc,			/* Number of rows of tzdata */
     Tcl_Obj *const *rowv)	/* Rows in tzdata */
 {
     int l;
     int u;
-    Tcl_Obj* compObj;
+    Tcl_Obj *compObj;
     Tcl_WideInt compVal;
 
     /*
@@ -1138,7 +1134,7 @@ LookupLastTransition(
     }
     return rowv[l];
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1159,7 +1155,7 @@ LookupLastTransition(
 
 static void
 GetYearWeekDay(
-    TclDateFields* fields,	/* Date to convert, must have 'julianDay' */
+    TclDateFields *fields,	/* Date to convert, must have 'julianDay' */
     int changeover)		/* Julian Day Number of the Gregorian
 				 * transition */
 {
@@ -1205,7 +1201,7 @@ GetYearWeekDay(
 	fields->dayOfWeek += 7;
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1226,7 +1222,7 @@ GetYearWeekDay(
 
 static void
 GetGregorianEraYearDay(
-    TclDateFields* fields,	/* Date fields containing 'julianDay' */
+    TclDateFields *fields,	/* Date fields containing 'julianDay' */
     int changeover)		/* Gregorian transition date */
 {
     int jday = fields->julianDay;
@@ -1272,7 +1268,6 @@ GetGregorianEraYearDay(
 	    day += ONE_CENTURY_GREGORIAN;
 	}
 	year += 100 * n;
-
     } else {
 	/*
 	 * Julian calendar.
@@ -1281,7 +1276,6 @@ GetGregorianEraYearDay(
 	fields->gregorian = 0;
 	year = 1;
 	day = jday - JDAY_1_JAN_1_CE_JULIAN;
-
     }
 
     /*
@@ -1325,7 +1319,7 @@ GetGregorianEraYearDay(
     }
     fields->dayOfYear = day + 1;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1344,11 +1338,11 @@ GetGregorianEraYearDay(
 
 static void
 GetMonthDay(
-    TclDateFields* fields)	/* Date to convert */
+    TclDateFields *fields)	/* Date to convert */
 {
     int day = fields->dayOfYear;
     int month;
-    const int* h = hath[IsGregorianLeapYear(fields)];
+    const int *h = hath[IsGregorianLeapYear(fields)];
 
     for (month = 0; month < 12 && day > h[month]; ++month) {
 	day -= h[month];
@@ -1356,7 +1350,7 @@ GetMonthDay(
     fields->month = month+1;
     fields->dayOfMonth = day;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1376,18 +1370,18 @@ GetMonthDay(
 
 static void
 GetJulianDayFromEraYearWeekDay(
-    TclDateFields* fields,	/* Date to convert */
+    TclDateFields *fields,	/* Date to convert */
     int changeover)		/* Julian Day Number of the Gregorian
 				 * transition */
 {
     int firstMonday;		/* Julian day number of week 1, day 1 in the
 				 * given year */
+    TclDateFields firstWeek;
 
     /*
      * Find January 4 in the ISO8601 year, which will always be in week 1.
      */
 
-    TclDateFields firstWeek;
     firstWeek.era = fields->era;
     firstWeek.year = fields->iso8601Year;
     firstWeek.month = 1;
@@ -1407,7 +1401,7 @@ GetJulianDayFromEraYearWeekDay(
     fields->julianDay = firstMonday + 7 * (fields->iso8601Week - 1)
 	    + fields->dayOfWeek - 1;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1427,13 +1421,10 @@ GetJulianDayFromEraYearWeekDay(
 
 static void
 GetJulianDayFromEraYearMonthDay(
-    TclDateFields* fields,	/* Date to convert */
+    TclDateFields *fields,	/* Date to convert */
     int changeover)		/* Gregorian transition date as a Julian Day */
 {
-    int year;  int ym1;
-    int month; int mm1;
-    int q; int r;
-    int ym1o4; int ym1o100; int ym1o400;
+    int year, ym1, month, mm1, q, r, ym1o4, ym1o100, ym1o400;
 
     if (fields->era == BCE) {
 	year = 1 - fields->year;
@@ -1505,10 +1496,10 @@ GetJulianDayFromEraYearMonthDay(
 		+ fields->dayOfMonth
 		+ daysInPriorMonths[year%4 == 0][month - 1]
 		+ (365 * ym1)
-	        + ym1o4;
+		+ ym1o4;
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1525,7 +1516,7 @@ GetJulianDayFromEraYearMonthDay(
 
 static int
 IsGregorianLeapYear(
-    TclDateFields* fields)	/* Date to test */
+    TclDateFields *fields)	/* Date to test */
 {
     int year;
 
@@ -1546,7 +1537,7 @@ IsGregorianLeapYear(
 	return 1;
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1572,7 +1563,7 @@ WeekdayOnOrBefore(
     }
     return julianDay - ((julianDay - k) % 7);
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1597,12 +1588,12 @@ WeekdayOnOrBefore(
 int
 ClockGetenvObjCmd(
     ClientData clientData,
-    Tcl_Interp* interp,
+    Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const objv[])
 {
-    const char* varName;
-    const char* varValue;
+    const char *varName;
+    const char *varValue;
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "name");
@@ -1616,7 +1607,7 @@ ClockGetenvObjCmd(
     Tcl_SetObjResult(interp, Tcl_NewStringObj(varValue, -1));
     return TCL_OK;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1643,8 +1634,7 @@ ThreadSafeLocalTime(
      * Get a thread-local buffer to hold the returned time.
      */
 
-    struct tm *tmPtr = (struct tm *)
-	    Tcl_GetThreadData(&tmKey, (int) sizeof(struct tm));
+    struct tm *tmPtr = Tcl_GetThreadData(&tmKey, (int) sizeof(struct tm));
 #ifdef HAVE_LOCALTIME_R
     localtime_r(timePtr, tmPtr);
 #else
@@ -1655,14 +1645,13 @@ ThreadSafeLocalTime(
     if (sysTmPtr == NULL) {
 	Tcl_MutexUnlock(&clockMutex);
 	return NULL;
-    } else {
-	memcpy((void *) tmPtr, (void *) localtime(timePtr), sizeof(struct tm));
-	Tcl_MutexUnlock(&clockMutex);
     }
+    memcpy(tmPtr, localtime(timePtr), sizeof(struct tm));
+    Tcl_MutexUnlock(&clockMutex);
 #endif
     return tmPtr;
 }
-
+
 /*----------------------------------------------------------------------
  *
  * ClockClicksObjCmd --
@@ -1684,18 +1673,19 @@ ThreadSafeLocalTime(
 int
 ClockClicksObjCmd(
     ClientData clientData,	/* Client data is unused */
-    Tcl_Interp* interp,		/* Tcl interpreter */
+    Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
-    Tcl_Obj* const* objv)	/* Parameter values */
+    Tcl_Obj *const *objv)	/* Parameter values */
 {
     static const char *const clicksSwitches[] = {
 	"-milliseconds", "-microseconds", NULL
     };
     enum ClicksSwitch {
-	CLICKS_MILLIS,   CLICKS_MICROS,   CLICKS_NATIVE
+	CLICKS_MILLIS, CLICKS_MICROS, CLICKS_NATIVE
     };
     int index = CLICKS_NATIVE;
     Tcl_Time now;
+    Tcl_WideInt clicks = 0;
 
     switch (objc) {
     case 1:
@@ -1714,28 +1704,25 @@ ClockClicksObjCmd(
     switch (index) {
     case CLICKS_MILLIS:
 	Tcl_GetTime(&now);
-	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt)
-		now.sec * 1000 + now.usec / 1000));
+	clicks = (Tcl_WideInt) now.sec * 1000 + now.usec / 1000;
 	break;
-    case CLICKS_NATIVE: {
-#ifndef TCL_WIDE_CLICKS
-	unsigned long clicks = TclpGetClicks();
+    case CLICKS_NATIVE:
+#ifdef TCL_WIDE_CLICKS
+	clicks = TclpGetWideClicks();
 #else
-	Tcl_WideInt clicks = TclpGetWideClicks();
+	clicks = (Tcl_WideInt) TclpGetClicks();
 #endif
-	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt) clicks));
 	break;
-    }
     case CLICKS_MICROS:
 	Tcl_GetTime(&now);
-	Tcl_SetObjResult(interp, Tcl_NewWideIntObj(
-		((Tcl_WideInt) now.sec * 1000000) + now.usec));
+	clicks = ((Tcl_WideInt) now.sec * 1000000) + now.usec;
 	break;
     }
 
+    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(clicks));
     return TCL_OK;
 }
-
+
 /*----------------------------------------------------------------------
  *
  * ClockMillisecondsObjCmd -
@@ -1757,9 +1744,9 @@ ClockClicksObjCmd(
 int
 ClockMillisecondsObjCmd(
     ClientData clientData,	/* Client data is unused */
-    Tcl_Interp* interp,		/* Tcl interpreter */
+    Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
-    Tcl_Obj* const* objv)	/* Parameter values */
+    Tcl_Obj *const *objv)	/* Parameter values */
 {
     Tcl_Time now;
 
@@ -1768,11 +1755,11 @@ ClockMillisecondsObjCmd(
 	return TCL_ERROR;
     }
     Tcl_GetTime(&now);
-    Tcl_SetObjResult(interp, Tcl_NewWideIntObj( (Tcl_WideInt)
+    Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt)
 	    now.sec * 1000 + now.usec / 1000));
     return TCL_OK;
 }
-
+
 /*----------------------------------------------------------------------
  *
  * ClockMicrosecondsObjCmd -
@@ -1794,9 +1781,9 @@ ClockMillisecondsObjCmd(
 int
 ClockMicrosecondsObjCmd(
     ClientData clientData,	/* Client data is unused */
-    Tcl_Interp* interp,		/* Tcl interpreter */
+    Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
-    Tcl_Obj* const* objv)	/* Parameter values */
+    Tcl_Obj *const *objv)	/* Parameter values */
 {
     Tcl_Time now;
 
@@ -1809,7 +1796,7 @@ ClockMicrosecondsObjCmd(
 	    ((Tcl_WideInt) now.sec * 1000000) + now.usec));
     return TCL_OK;
 }
-
+
 /*
  *-----------------------------------------------------------------------------
  *
@@ -1818,12 +1805,12 @@ ClockMicrosecondsObjCmd(
  *	Parses the arguments for [clock format].
  *
  * Results:
- *	Returns a standard Tcl result, whose value is a four-element
- *	list comprising the time format, the locale, and the timezone.
+ *	Returns a standard Tcl result, whose value is a four-element list
+ *	comprising the time format, the locale, and the timezone.
  *
  * This function exists because the loop that parses the [clock format]
- * options is a known performance "hot spot", and is implemented in an
- * effort to speed that particular code up.
+ * options is a known performance "hot spot", and is implemented in an effort
+ * to speed that particular code up.
  *
  *-----------------------------------------------------------------------------
  */
@@ -1831,56 +1818,53 @@ ClockMicrosecondsObjCmd(
 static int
 ClockParseformatargsObjCmd(
     ClientData clientData,	/* Client data containing literal pool */
-    Tcl_Interp* interp,		/* Tcl interpreter */
+    Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
-    Tcl_Obj *const objv[]	/* Parameter vector */
-) {
-
-    ClockClientData* dataPtr = (ClockClientData*) clientData;
-    Tcl_Obj** litPtr = dataPtr->literals;
-
-    /* Format, locale and timezone */
-
-    Tcl_Obj* results[3];
+    Tcl_Obj *const objv[])	/* Parameter vector */
+{
+    ClockClientData *dataPtr = clientData;
+    Tcl_Obj **litPtr = dataPtr->literals;
+    Tcl_Obj *results[3];	/* Format, locale and timezone */
 #define formatObj results[0]
 #define localeObj results[1]
 #define timezoneObj results[2]
     int gmtFlag = 0;
-
-    /* Command line options expected */
-
-    static const char *const options[] = {
-	"-format",		"-gmt",			"-locale",
-	"-timezone",		NULL };
+    static const char *const options[] = { /* Command line options expected */
+	"-format",	"-gmt",		"-locale",
+	"-timezone",	NULL };
     enum optionInd {
 	CLOCK_FORMAT_FORMAT,	CLOCK_FORMAT_GMT,	CLOCK_FORMAT_LOCALE,
 	CLOCK_FORMAT_TIMEZONE
     };
-    int optionIndex;		/* Index of an option */
-    int saw = 0;		/* Flag == 1 if option was seen already */
-    Tcl_WideInt clockVal;	/* Clock value - just used to parse */
+    int optionIndex;		/* Index of an option. */
+    int saw = 0;		/* Flag == 1 if option was seen already. */
+    Tcl_WideInt clockVal;	/* Clock value - just used to parse. */
     int i;
 
-    /* Args consist of a time followed by keyword-value pairs */
+    /*
+     * Args consist of a time followed by keyword-value pairs.
+     */
 
     if (objc < 2 || (objc % 2) != 0) {
 	Tcl_WrongNumArgs(interp, 0, objv,
-			 "clock format clockval ?-format string? "
-			 "?-gmt boolean? ?-locale LOCALE? ?-timezone ZONE?");
+		"clock format clockval ?-format string? "
+		"?-gmt boolean? ?-locale LOCALE? ?-timezone ZONE?");
 	Tcl_SetErrorCode(interp, "CLOCK", "wrongNumArgs", NULL);
 	return TCL_ERROR;
     }
 
-    /* Extract values for the keywords */
+    /*
+     * Extract values for the keywords.
+     */
 
     formatObj = litPtr[LIT__DEFAULT_FORMAT];
     localeObj = litPtr[LIT_C];
     timezoneObj = litPtr[LIT__NIL];
     for (i = 2; i < objc; i+=2) {
 	if (Tcl_GetIndexFromObj(interp, objv[i], options, "switch", 0,
-				&optionIndex) != TCL_OK) {
+		&optionIndex) != TCL_OK) {
 	    Tcl_SetErrorCode(interp, "CLOCK", "badSwitch",
-			     Tcl_GetString(objv[i]), NULL);
+		    Tcl_GetString(objv[i]), NULL);
 	    return TCL_ERROR;
 	}
 	switch (optionIndex) {
@@ -1888,7 +1872,7 @@ ClockParseformatargsObjCmd(
 	    formatObj = objv[i+1];
 	    break;
 	case CLOCK_FORMAT_GMT:
-	    if (Tcl_GetBooleanFromObj(interp, objv[i+1], &gmtFlag) != TCL_OK) {
+	    if (Tcl_GetBooleanFromObj(interp, objv[i+1], &gmtFlag) != TCL_OK){
 		return TCL_ERROR;
 	    }
 	    break;
@@ -1899,16 +1883,18 @@ ClockParseformatargsObjCmd(
 	    timezoneObj = objv[i+1];
 	    break;
 	}
-	saw |= (1 << optionIndex);
+	saw |= 1 << optionIndex;
     }
 
-    /* Check options */
+    /*
+     * Check options.
+     */
 
     if (Tcl_GetWideIntFromObj(interp, objv[1], &clockVal) != TCL_OK) {
 	return TCL_ERROR;
     }
     if ((saw & (1 << CLOCK_FORMAT_GMT))
-	&& (saw & (1 << CLOCK_FORMAT_TIMEZONE))) {
+	    && (saw & (1 << CLOCK_FORMAT_TIMEZONE))) {
 	Tcl_SetObjResult(interp, litPtr[LIT_CANNOT_USE_GMT_AND_TIMEZONE]);
 	Tcl_SetErrorCode(interp, "CLOCK", "gmtWithTimezone", NULL);
 	return TCL_ERROR;
@@ -1917,7 +1903,9 @@ ClockParseformatargsObjCmd(
 	timezoneObj = litPtr[LIT_GMT];
     }
 
-    /* Return options as a list */
+    /*
+     * Return options as a list.
+     */
 
     Tcl_SetObjResult(interp, Tcl_NewListObj(3, results));
     return TCL_OK;
@@ -1925,9 +1913,8 @@ ClockParseformatargsObjCmd(
 #undef timezoneObj
 #undef localeObj
 #undef formatObj
-
 }
-
+
 /*----------------------------------------------------------------------
  *
  * ClockSecondsObjCmd -
@@ -1949,9 +1936,9 @@ ClockParseformatargsObjCmd(
 int
 ClockSecondsObjCmd(
     ClientData clientData,	/* Client data is unused */
-    Tcl_Interp* interp,		/* Tcl interpreter */
+    Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
-    Tcl_Obj* const* objv)	/* Parameter values */
+    Tcl_Obj *const *objv)	/* Parameter values */
 {
     Tcl_Time now;
 
@@ -1963,7 +1950,7 @@ ClockSecondsObjCmd(
     Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt) now.sec));
     return TCL_OK;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1984,9 +1971,9 @@ ClockSecondsObjCmd(
 static void
 TzsetIfNecessary(void)
 {
-    static char* tzWas = NULL;	/* Previous value of TZ, protected by
+    static char *tzWas = NULL;	/* Previous value of TZ, protected by
 				 * clockMutex. */
-    const char* tzIsNow;	/* Current value of TZ */
+    const char *tzIsNow;	/* Current value of TZ */
 
     Tcl_MutexLock(&clockMutex);
     tzIsNow = getenv("TZ");
@@ -2004,7 +1991,7 @@ TzsetIfNecessary(void)
     }
     Tcl_MutexUnlock(&clockMutex);
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -2023,19 +2010,19 @@ static void
 ClockDeleteCmdProc(
     ClientData clientData)	/* Opaque pointer to the client data */
 {
-    ClockClientData *data = (ClockClientData*) clientData;
+    ClockClientData *data = clientData;
     int i;
 
-    --(data->refCount);
+    --data->refCount;
     if (data->refCount == 0) {
 	for (i = 0; i < LIT__END; ++i) {
 	    Tcl_DecrRefCount(data->literals[i]);
 	}
-	ckfree((char*) (data->literals));
-	ckfree((char*) data);
+	ckfree((char *) data->literals);
+	ckfree((char *) data);
     }
 }
-
+
 /*
  * Local Variables:
  * mode: c
diff --git a/generic/tclCmdAH.c b/generic/tclCmdAH.c
index 724e80b..df24e16 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.108 2008/10/23 03:28:09 msofer Exp $
+ * RCS: @(#) $Id: tclCmdAH.c,v 1.109 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -1506,7 +1506,7 @@ GetStatBuf(
 	return TCL_ERROR;
     }
 
-    status = (*statProc)(pathPtr, statPtr);
+    status = statProc(pathPtr, statPtr);
 
     if (status < 0) {
 	if (interp != NULL) {
diff --git a/generic/tclCompExpr.c b/generic/tclCompExpr.c
index f6ef042..9c1ee74 100644
--- a/generic/tclCompExpr.c
+++ b/generic/tclCompExpr.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: tclCompExpr.c,v 1.97 2008/02/28 20:40:24 dgp Exp $
+ * RCS: @(#) $Id: tclCompExpr.c,v 1.98 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -1823,7 +1823,7 @@ ParseLexeme(
 	*lexemePtr = END;
 	return 0;
     }
-    byte = (unsigned char)(*start);
+    byte = UCHAR(*start);
     if (byte < sizeof(Lexeme) && Lexeme[byte] != 0) {
 	*lexemePtr = Lexeme[byte];
 	return 1;
diff --git a/generic/tclCompile.c b/generic/tclCompile.c
index ddf3818..adaa38b 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.159 2008/10/15 06:17:04 nijtmans Exp $
+ * RCS: @(#) $Id: tclCompile.c,v 1.160 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -1396,8 +1396,8 @@ TclCompileScript(
 			    update = 1;
 			}
 
-			code = (cmdPtr->compileProc)(interp, parsePtr,
-				cmdPtr, envPtr);
+			code = cmdPtr->compileProc(interp, parsePtr, cmdPtr,
+				envPtr);
 
 			if (code == TCL_OK) {
 			    if (update) {
@@ -1457,7 +1457,7 @@ TclCompileScript(
 			/*
 			 * Single word script: unshare the command name to
 			 * avoid shimmering between bytecode and cmdName
-			 * representations [Bug 458361]
+			 * representations. [Bug 458361]
 			 */
 
 			TclHideLiteral(interp, envPtr, objIndex);
@@ -2452,7 +2452,7 @@ EnterCmdWordData(
 	size_t newElems = (currElems ? 2*currElems : 1);
 	size_t newBytes = newElems * sizeof(ECL);
 
-	eclPtr->loc = (ECL *) ckrealloc((char *)(eclPtr->loc), newBytes);
+	eclPtr->loc = (ECL *) ckrealloc((char *) eclPtr->loc, newBytes);
 	eclPtr->nloc = newElems;
     }
 
@@ -2553,7 +2553,7 @@ TclCreateExceptRange(
 
 	if (envPtr->mallocedExceptArray) {
 	    envPtr->exceptArrayPtr = (ExceptionRange *)
-		    ckrealloc((char *)(envPtr->exceptArrayPtr), newBytes);
+		    ckrealloc((char *) envPtr->exceptArrayPtr, newBytes);
 	} else {
 	    /*
 	     * envPtr->exceptArrayPtr isn't a ckalloc'd pointer, so we must
@@ -2630,7 +2630,7 @@ TclCreateAuxData(
 
 	if (envPtr->mallocedAuxDataArray) {
 	    envPtr->auxDataArrayPtr = (AuxData *)
-		    ckrealloc((char *)(envPtr->auxDataArrayPtr), newBytes);
+		    ckrealloc((char *) envPtr->auxDataArrayPtr, newBytes);
 	} else {
 	    /*
 	     * envPtr->auxDataArrayPtr isn't a ckalloc'd pointer, so we must
@@ -2718,7 +2718,7 @@ TclExpandJumpFixupArray(
 
     if (fixupArrayPtr->mallocedArray) {
 	fixupArrayPtr->fixup = (JumpFixup *)
-		ckrealloc((char *)(fixupArrayPtr->fixup), newBytes);
+		ckrealloc((char *) fixupArrayPtr->fixup, newBytes);
     } else {
 	/*
 	 * fixupArrayPtr->fixup isn't a ckalloc'd pointer, so we must
@@ -3952,7 +3952,7 @@ RecordByteCodeStats(
     statsPtr->currentByteCodeBytes += (double) codePtr->structureSize;
 
     statsPtr->srcCount[TclLog2(codePtr->numSrcBytes)]++;
-    statsPtr->byteCodeCount[TclLog2((int)(codePtr->structureSize))]++;
+    statsPtr->byteCodeCount[TclLog2((int) codePtr->structureSize)]++;
 
     statsPtr->currentInstBytes += (double) codePtr->numCodeBytes;
     statsPtr->currentLitBytes += (double)
diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index 7378e49..9ef937f 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -8,7 +8,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclEncoding.c,v 1.63 2008/10/22 20:23:59 nijtmans Exp $
+ * RCS: @(#) $Id: tclEncoding.c,v 1.64 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -94,7 +94,7 @@ typedef struct TableEncodingData {
  */
 
 typedef struct EscapeSubTable {
-    unsigned int sequenceLen;	/* Length of following string. */
+    unsigned sequenceLen;	/* Length of following string. */
     char sequence[16];		/* Escape code that marks this encoding. */
     char name[32];		/* Name for encoding. */
     Encoding *encodingPtr;	/* Encoding loaded using above name, or NULL
@@ -106,10 +106,10 @@ typedef struct EscapeEncodingData {
     int fallback;		/* Character (in this encoding) to substitute
 				 * when this encoding cannot represent a UTF-8
 				 * character. */
-    unsigned int initLen;	/* Length of following string. */
+    unsigned initLen;		/* Length of following string. */
     char init[16];		/* String to emit or expect before first char
 				 * in conversion. */
-    unsigned int finalLen;	/* Length of following string. */
+    unsigned finalLen;		/* Length of following string. */
     char final[16];		/* String to emit or expect after last char in
 				 * conversion. */
     char prefixBytes[256];	/* If a byte in the input stream is the first
@@ -848,7 +848,7 @@ FreeEncoding(
     encodingPtr->refCount--;
     if (encodingPtr->refCount == 0) {
 	if (encodingPtr->freeProc != NULL) {
-	    (*encodingPtr->freeProc)(encodingPtr->clientData);
+	    encodingPtr->freeProc(encodingPtr->clientData);
 	}
 	if (encodingPtr->hPtr != NULL) {
 	    Tcl_DeleteHashEntry(encodingPtr->hPtr);
@@ -1128,15 +1128,14 @@ Tcl_ExternalToUtfDString(
     if (src == NULL) {
 	srcLen = 0;
     } else if (srcLen < 0) {
-	srcLen = (*encodingPtr->lengthProc)(src);
+	srcLen = encodingPtr->lengthProc(src);
     }
 
     flags = TCL_ENCODING_START | TCL_ENCODING_END;
 
     while (1) {
-	result = (*encodingPtr->toUtfProc)(encodingPtr->clientData, src,
-		srcLen, flags, &state, dst, dstLen, &srcRead, &dstWrote,
-		&dstChars);
+	result = encodingPtr->toUtfProc(encodingPtr->clientData, src, srcLen,
+		flags, &state, dst, dstLen, &srcRead, &dstWrote, &dstChars);
 	soFar = dst + dstWrote - Tcl_DStringValue(dstPtr);
 
 	if (result != TCL_CONVERT_NOSPACE) {
@@ -1216,7 +1215,7 @@ Tcl_ExternalToUtf(
     if (src == NULL) {
 	srcLen = 0;
     } else if (srcLen < 0) {
-	srcLen = (*encodingPtr->lengthProc)(src);
+	srcLen = encodingPtr->lengthProc(src);
     }
     if (statePtr == NULL) {
 	flags |= TCL_ENCODING_START | TCL_ENCODING_END;
@@ -1239,7 +1238,7 @@ Tcl_ExternalToUtf(
      */
 
     dstLen--;
-    result = (*encodingPtr->toUtfProc)(encodingPtr->clientData, src, srcLen,
+    result = encodingPtr->toUtfProc(encodingPtr->clientData, src, srcLen,
 	    flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr,
 	    dstCharsPtr);
     dst[*dstWrotePtr] = '\0';
@@ -1299,7 +1298,7 @@ Tcl_UtfToExternalDString(
     }
     flags = TCL_ENCODING_START | TCL_ENCODING_END;
     while (1) {
-	result = (*encodingPtr->fromUtfProc)(encodingPtr->clientData, src,
+	result = encodingPtr->fromUtfProc(encodingPtr->clientData, src,
 		srcLen, flags, &state, dst, dstLen, &srcRead, &dstWrote,
 		&dstChars);
 	soFar = dst + dstWrote - Tcl_DStringValue(dstPtr);
@@ -1401,7 +1400,7 @@ Tcl_UtfToExternal(
     }
 
     dstLen -= encodingPtr->nullSize;
-    result = (*encodingPtr->fromUtfProc)(encodingPtr->clientData, src, srcLen,
+    result = encodingPtr->fromUtfProc(encodingPtr->clientData, src, srcLen,
 	    flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr,
 	    dstCharsPtr);
     if (encodingPtr->nullSize == 2) {
@@ -1660,7 +1659,7 @@ LoadTableEncoding(
     char *line;
     int i, hi, lo, numPages, symbol, fallback;
     unsigned char used[256];
-    unsigned int size;
+    unsigned size;
     TableEncodingData *dataPtr;
     unsigned short *pageMemPtr;
     Tcl_EncodingType encType;
@@ -1937,7 +1936,7 @@ LoadEscapeEncoding(
     Tcl_Channel chan)		/* File containing new encoding. */
 {
     int i;
-    unsigned int size;
+    unsigned size;
     Tcl_DString escapeData;
     char init[16], final[16];
     EscapeEncodingData *dataPtr;
@@ -2981,7 +2980,7 @@ EscapeToUtfProc(
 				 * correspond to the bytes stored in the
 				 * output buffer. */
 {
-    EscapeEncodingData *dataPtr;
+    EscapeEncodingData *dataPtr = clientData;
     char *prefixBytes, *tablePrefixBytes;
     unsigned short **tableToUnicode;
     Encoding *encodingPtr;
@@ -2990,11 +2989,8 @@ EscapeToUtfProc(
     char *dstStart, *dstEnd;
 
     result = TCL_OK;
-
     tablePrefixBytes = NULL;	/* lint. */
     tableToUnicode = NULL;	/* lint. */
-
-    dataPtr = (EscapeEncodingData *) clientData;
     prefixBytes = dataPtr->prefixBytes;
     encodingPtr = NULL;
 
@@ -3018,7 +3014,7 @@ EscapeToUtfProc(
 	}
 	byte = *((unsigned char *) src);
 	if (prefixBytes[byte]) {
-	    unsigned int left, len, longest;
+	    unsigned left, len, longest;
 	    int checked, i;
 	    EscapeSubTable *subTablePtr;
 
@@ -3118,7 +3114,7 @@ EscapeToUtfProc(
 	    TableEncodingData *tableDataPtr;
 
 	    encodingPtr = GetTableEncoding(dataPtr, state);
-	    tableDataPtr = (TableEncodingData *) encodingPtr->clientData;
+	    tableDataPtr = encodingPtr->clientData;
 	    tablePrefixBytes = tableDataPtr->prefixBytes;
 	    tableToUnicode = tableDataPtr->toUnicode;
 	}
@@ -3195,7 +3191,7 @@ EscapeFromUtfProc(
 				 * correspond to the bytes stored in the
 				 * output buffer. */
 {
-    EscapeEncodingData *dataPtr;
+    EscapeEncodingData *dataPtr = clientData;
     Encoding *encodingPtr;
     const char *srcStart, *srcEnd, *srcClose;
     char *dstStart, *dstEnd;
@@ -3206,8 +3202,6 @@ EscapeFromUtfProc(
 
     result = TCL_OK;
 
-    dataPtr = (EscapeEncodingData *) clientData;
-
     srcStart = src;
     srcEnd = src + srcLen;
     srcClose = srcEnd;
@@ -3219,7 +3213,7 @@ EscapeFromUtfProc(
     dstEnd = dst + dstLen - 1;
 
     /*
-     * RFC1468 states that the text starts in ASCII, and switches to Japanese
+     * RFC 1468 states that the text starts in ASCII, and switches to Japanese
      * characters, and that the text must end in ASCII. [Patch 474358]
      */
 
@@ -3237,12 +3231,12 @@ EscapeFromUtfProc(
     }
 
     encodingPtr = GetTableEncoding(dataPtr, state);
-    tableDataPtr = (TableEncodingData *) encodingPtr->clientData;
+    tableDataPtr = encodingPtr->clientData;
     tablePrefixBytes = tableDataPtr->prefixBytes;
     tableFromUnicode = tableDataPtr->fromUnicode;
 
     for (numChars = 0; src < srcEnd; numChars++) {
-	unsigned int len;
+	unsigned len;
 	int word;
 	Tcl_UniChar ch;
 
@@ -3265,7 +3259,7 @@ EscapeFromUtfProc(
 	    oldState = state;
 	    for (state = 0; state < dataPtr->numSubTables; state++) {
 		encodingPtr = GetTableEncoding(dataPtr, state);
-		tableDataPtr = (TableEncodingData *) encodingPtr->clientData;
+		tableDataPtr = encodingPtr->clientData;
 	    	word = tableDataPtr->fromUnicode[(ch >> 8)][ch & 0xff];
 		if (word != 0) {
 		    break;
@@ -3279,7 +3273,7 @@ EscapeFromUtfProc(
 		    break;
 		}
 		encodingPtr = GetTableEncoding(dataPtr, state);
-		tableDataPtr = (TableEncodingData *) encodingPtr->clientData;
+		tableDataPtr = encodingPtr->clientData;
 		word = tableDataPtr->fallback;
 	    }
 
@@ -3332,22 +3326,22 @@ EscapeFromUtfProc(
     }
 
     if ((result == TCL_OK) && (flags & TCL_ENCODING_END)) {
-	unsigned int len = dataPtr->subTables[0].sequenceLen;
+	unsigned len = dataPtr->subTables[0].sequenceLen;
+
 	/*
-	 * Certain encodings like iso2022-jp need to write
-	 * an escape sequence after all characters have
-	 * been converted. This logic checks that enough
-	 * room is available in the buffer for the escape bytes.
-	 * The TCL_ENCODING_END flag is cleared after a final
-	 * escape sequence has been added to the buffer so
-	 * that another call to this method does not attempt
-	 * to append escape bytes a second time.
+	 * Certain encodings like iso2022-jp need to write an escape sequence
+	 * after all characters have been converted. This logic checks that
+	 * enough room is available in the buffer for the escape bytes. The
+	 * TCL_ENCODING_END flag is cleared after a final escape sequence has
+	 * been added to the buffer so that another call to this method does
+	 * not attempt to append escape bytes a second time.
 	 */
+
 	if ((dst + dataPtr->finalLen + (state?len:0)) > dstEnd) {
 	    result = TCL_CONVERT_NOSPACE;
 	} else {
 	    if (state) {
-		memcpy(dst, dataPtr->subTables[0].sequence, (size_t) len);
+		memcpy(dst, dataPtr->subTables[0].sequence, len);
 		dst += len;
 	    }
 	    memcpy(dst, dataPtr->final, (size_t) dataPtr->finalLen);
@@ -3385,11 +3379,10 @@ EscapeFreeProc(
     ClientData clientData)	/* EscapeEncodingData that specifies
 				 * encoding. */
 {
-    EscapeEncodingData *dataPtr;
+    EscapeEncodingData *dataPtr = clientData;
     EscapeSubTable *subTablePtr;
     int i;
 
-    dataPtr = (EscapeEncodingData *) clientData;
     if (dataPtr == NULL) {
 	return;
     }
@@ -3426,11 +3419,8 @@ GetTableEncoding(
     EscapeEncodingData *dataPtr,/* Contains names of encodings. */
     int state)			/* Index in dataPtr of desired Encoding. */
 {
-    EscapeSubTable *subTablePtr;
-    Encoding *encodingPtr;
-
-    subTablePtr = &dataPtr->subTables[state];
-    encodingPtr = subTablePtr->encodingPtr;
+    EscapeSubTable *subTablePtr = &dataPtr->subTables[state];
+    Encoding *encodingPtr = subTablePtr->encodingPtr;
 
     if (encodingPtr == NULL) {
 	encodingPtr = (Encoding *) Tcl_GetEncoding(NULL, subTablePtr->name);
@@ -3539,7 +3529,7 @@ InitializeEncodingSearchPath(
     bytes = Tcl_GetStringFromObj(searchPath, &numBytes);
 
     *lengthPtr = numBytes;
-    *valuePtr = ckalloc((unsigned int) numBytes + 1);
+    *valuePtr = ckalloc((unsigned) numBytes + 1);
     memcpy(*valuePtr, bytes, (size_t) numBytes + 1);
     Tcl_DecrRefCount(searchPath);
 }
diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 3d29cb5..203dc5a 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -12,7 +12,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclEvent.c,v 1.84 2008/10/16 22:34:19 nijtmans Exp $
+ * RCS: @(#) $Id: tclEvent.c,v 1.85 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -947,7 +947,7 @@ Tcl_Finalize(void)
 
 	firstExitPtr = exitPtr->nextPtr;
 	Tcl_MutexUnlock(&exitMutex);
-	(*exitPtr->proc)(exitPtr->clientData);
+	exitPtr->proc(exitPtr->clientData);
 	ckfree((char *) exitPtr);
 	Tcl_MutexLock(&exitMutex);
     }
@@ -1135,7 +1135,7 @@ Tcl_FinalizeThread(void)
 	     */
 
 	    tsdPtr->firstExitPtr = exitPtr->nextPtr;
-	    (*exitPtr->proc)(exitPtr->clientData);
+	    exitPtr->proc(exitPtr->clientData);
 	    ckfree((char *) exitPtr);
 	}
 	TclFinalizeIOSubsystem();
@@ -1388,16 +1388,15 @@ static Tcl_ThreadCreateType
 NewThreadProc(
     ClientData clientData)
 {
-    ThreadClientData *cdPtr;
+    ThreadClientData *cdPtr = clientData;
     ClientData threadClientData;
     Tcl_ThreadCreateProc *threadProc;
 
-    cdPtr = (ThreadClientData *) clientData;
     threadProc = cdPtr->proc;
     threadClientData = cdPtr->clientData;
     ckfree((char *) clientData);	/* Allocated in Tcl_CreateThread() */
 
-    (*threadProc)(threadClientData);
+    threadProc(threadClientData);
 
     TCL_THREAD_CREATE_RETURN;
 }
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index 99f16db..d1ff368 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -14,7 +14,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclExecute.c,v 1.418 2008/10/17 16:32:58 dgp Exp $
+ * RCS: @(#) $Id: tclExecute.c,v 1.419 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -6208,6 +6208,7 @@ TclExecuteByteCode(
 				/ sizeof(unsigned short)) - 1)) {
 		    unsigned short base = Exp32Index[l1-3]
 			    + (unsigned short) l2 - 9;
+
 		    if (base < Exp32Index[l1-2]) {
 			/*
 			 * 32-bit number raised to intermediate power, done by
@@ -6225,14 +6226,14 @@ TclExecuteByteCode(
 			NEXT_INST_F(1, 1, 0);
 		    }
 		}
-		if (-l1 >= 3
-		    && (unsigned long)(-l1) < (sizeof(Exp32Index)
-			     / sizeof(unsigned short)) - 1) {
-		    unsigned short base
-			= Exp32Index[-l1-3] + (unsigned short) l2 - 9;
+		if (-l1 >= 3 && (unsigned long)(-l1) <
+			(sizeof(Exp32Index) / sizeof(unsigned short)) - 1) {
+		    unsigned short base =
+			    Exp32Index[-l1-3] + (unsigned short) l2 - 9;
+
 		    if (base < Exp32Index[-l1-2]) {
 			long lResult = (oddExponent) ?
-			    -Exp32Value[base] : Exp32Value[base];
+				-Exp32Value[base] : Exp32Value[base];
 
 			/*
 			 * 32-bit number raised to intermediate power, done by
diff --git a/generic/tclHistory.c b/generic/tclHistory.c
index ea1a8ff..48739ad 100644
--- a/generic/tclHistory.c
+++ b/generic/tclHistory.c
@@ -12,7 +12,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclHistory.c,v 1.12 2008/07/13 09:03:33 msofer Exp $
+ * RCS: @(#) $Id: tclHistory.c,v 1.13 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -124,7 +124,7 @@ Tcl_RecordAndEvalObj(
     result = Tcl_GetCommandInfo(interp, "history", &info);
 
     if (result && (info.deleteProc == TclProcDeleteProc)) {
-	Proc *procPtr = (Proc *)(info.objClientData);
+	Proc *procPtr = (Proc *) info.objClientData;
 	call = (procPtr->cmdPtr->compileProc != TclCompileNoOp);
     }
 
diff --git a/generic/tclIO.c b/generic/tclIO.c
index 7ec28c8..d7524fe 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.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: tclIO.c,v 1.145 2008/10/16 22:34:19 nijtmans Exp $
+ * RCS: @(#) $Id: tclIO.c,v 1.146 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -350,10 +350,10 @@ TclFinalizeIOSubsystem(void)
 		 */
 
 		if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
-		    (chanPtr->typePtr->closeProc)(chanPtr->instanceData, NULL);
+		    chanPtr->typePtr->closeProc(chanPtr->instanceData, NULL);
 		} else {
-		    (chanPtr->typePtr->close2Proc)(chanPtr->instanceData,
-			    NULL, 0);
+		    chanPtr->typePtr->close2Proc(chanPtr->instanceData, NULL,
+			    0);
 		}
 
 		/*
@@ -932,7 +932,7 @@ Tcl_UnregisterChannel(
 		IsBufferReady(statePtr->curOutPtr)) {
 	    SetFlag(statePtr, BUFFER_READY);
 	}
-	Tcl_Preserve((ClientData)statePtr);
+	Tcl_Preserve(statePtr);
 	if (!(statePtr->flags & BG_FLUSH_SCHEDULED)) {
 	    /*
 	     * We don't want to re-enter Tcl_Close().
@@ -941,13 +941,13 @@ Tcl_UnregisterChannel(
 	    if (!(statePtr->flags & CHANNEL_CLOSED)) {
 		if (Tcl_Close(interp, chan) != TCL_OK) {
 		    SetFlag(statePtr, CHANNEL_CLOSED);
-		    Tcl_Release((ClientData)statePtr);
+		    Tcl_Release(statePtr);
 		    return TCL_ERROR;
 		}
 	    }
 	}
 	SetFlag(statePtr, CHANNEL_CLOSED);
-	Tcl_Release((ClientData)statePtr);
+	Tcl_Release(statePtr);
     }
     return TCL_OK;
 }
@@ -1573,7 +1573,7 @@ Tcl_StackChannel(
 
     threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
     if (threadActionProc != NULL) {
-	(*threadActionProc)(chanPtr->instanceData, TCL_CHANNEL_THREAD_INSERT);
+	threadActionProc(chanPtr->instanceData, TCL_CHANNEL_THREAD_INSERT);
     }
 
     return (Tcl_Channel) chanPtr;
@@ -1710,8 +1710,7 @@ Tcl_UnstackChannel(
 
 	threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
 	if (threadActionProc != NULL) {
-	    (*threadActionProc)(chanPtr->instanceData,
-		    TCL_CHANNEL_THREAD_REMOVE);
+	    threadActionProc(chanPtr->instanceData,TCL_CHANNEL_THREAD_REMOVE);
 	}
 
 	statePtr->topChanPtr = downChanPtr;
@@ -1727,10 +1726,10 @@ Tcl_UnstackChannel(
 	 */
 
 	if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
-	    result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData,
+	    result = chanPtr->typePtr->closeProc(chanPtr->instanceData,
 		    interp);
 	} else {
-	    result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData,
+	    result = chanPtr->typePtr->close2Proc(chanPtr->instanceData,
 		    interp, 0);
 	}
 
@@ -2002,8 +2001,8 @@ Tcl_GetChannelHandle(
     int result;
 
     chanPtr = ((Channel *) chan)->state->bottomChanPtr;
-    result = (chanPtr->typePtr->getHandleProc)(chanPtr->instanceData,
-	    direction, &handle);
+    result = chanPtr->typePtr->getHandleProc(chanPtr->instanceData, direction,
+	    &handle);
     if (handlePtr) {
 	*handlePtr = handle;
     }
@@ -2302,7 +2301,7 @@ FlushChannel(
 	 */
 
 	toWrite = BytesLeft(bufPtr);
-	written = (chanPtr->typePtr->outputProc)(chanPtr->instanceData,
+	written = chanPtr->typePtr->outputProc(chanPtr->instanceData,
 		RemovePoint(bufPtr), toWrite, &errorCode);
 
 	/*
@@ -2438,7 +2437,7 @@ FlushChannel(
 	    return errorCode;
 	} else if (statePtr->outQueueHead == NULL) {
 	    ResetFlag(statePtr, BG_FLUSH_SCHEDULED);
-	    (chanPtr->typePtr->watchProc)(chanPtr->instanceData,
+	    chanPtr->typePtr->watchProc(chanPtr->instanceData,
 		    statePtr->interestMask);
 	}
     }
@@ -2529,7 +2528,7 @@ CloseChannel(
 	int dummy;
 	char c = (char) statePtr->outEofChar;
 
-	(chanPtr->typePtr->outputProc)(chanPtr->instanceData, &c, 1, &dummy);
+	chanPtr->typePtr->outputProc(chanPtr->instanceData, &c, 1, &dummy);
     }
 
     /*
@@ -2558,10 +2557,10 @@ CloseChannel(
      */
 
     if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
-	result = (chanPtr->typePtr->closeProc)(chanPtr->instanceData, interp);
+	result = chanPtr->typePtr->closeProc(chanPtr->instanceData, interp);
     } else {
-	result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData,
-		interp, 0);
+	result = chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp,
+		0);
     }
 
     /*
@@ -2715,7 +2714,7 @@ CutChannel(
 
     threadActionProc = Tcl_ChannelThreadActionProc(Tcl_GetChannelType(chan));
     if (threadActionProc != NULL) {
-	(*threadActionProc)(Tcl_GetChannelInstanceData(chan),
+	threadActionProc(Tcl_GetChannelInstanceData(chan),
 		TCL_CHANNEL_THREAD_REMOVE);
     }
 }
@@ -2763,8 +2762,7 @@ Tcl_CutChannel(
     while (chanPtr) {
 	threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
 	if (threadActionProc != NULL) {
-	    (*threadActionProc)(chanPtr->instanceData,
-		    TCL_CHANNEL_THREAD_REMOVE);
+	    threadActionProc(chanPtr->instanceData,TCL_CHANNEL_THREAD_REMOVE);
 	}
 	chanPtr= chanPtr->upChanPtr;
     }
@@ -2826,7 +2824,7 @@ SpliceChannel(
 
     threadActionProc = Tcl_ChannelThreadActionProc(Tcl_GetChannelType(chan));
     if (threadActionProc != NULL) {
-	(*threadActionProc) (Tcl_GetChannelInstanceData(chan),
+	threadActionProc(Tcl_GetChannelInstanceData(chan),
 		TCL_CHANNEL_THREAD_INSERT);
     }
 }
@@ -2864,8 +2862,7 @@ Tcl_SpliceChannel(
     while (chanPtr) {
 	threadActionProc = Tcl_ChannelThreadActionProc(chanPtr->typePtr);
 	if (threadActionProc != NULL) {
-	    (*threadActionProc)(chanPtr->instanceData,
-		    TCL_CHANNEL_THREAD_INSERT);
+	    threadActionProc(chanPtr->instanceData,TCL_CHANNEL_THREAD_INSERT);
 	}
 	chanPtr= chanPtr->upChanPtr;
     }
@@ -2976,7 +2973,7 @@ Tcl_Close(
     while (statePtr->closeCbPtr != NULL) {
 	cbPtr = statePtr->closeCbPtr;
 	statePtr->closeCbPtr = cbPtr->nextPtr;
-	(cbPtr->proc)(cbPtr->clientData);
+	cbPtr->proc(cbPtr->clientData);
 	ckfree((char *) cbPtr);
     }
 
@@ -2996,7 +2993,7 @@ Tcl_Close(
      */
 
     if (chanPtr->typePtr->closeProc == TCL_CLOSE2PROC) {
-	result = (chanPtr->typePtr->close2Proc)(chanPtr->instanceData, interp,
+	result = chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp,
 		TCL_CLOSE_READ);
     } else {
 	result = 0;
@@ -3229,8 +3226,8 @@ Tcl_WriteRaw(
      * The code was stolen from 'FlushChannel'.
      */
 
-    written = (chanPtr->typePtr->outputProc) (chanPtr->instanceData,
-	    src, srcLen, &errorCode);
+    written = chanPtr->typePtr->outputProc(chanPtr->instanceData, src,
+	    srcLen, &errorCode);
 
     if (written < 0) {
 	Tcl_SetErrno(errorCode);
@@ -5036,7 +5033,7 @@ Tcl_ReadRaw(
 		 * The case of 'bytesToRead == 0' at this point cannot happen.
 		 */
 
-		nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
+		nread = chanPtr->typePtr->inputProc(chanPtr->instanceData,
 			bufPtr + copied, bytesToRead - copied, &result);
 
 #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
@@ -6196,7 +6193,7 @@ GetInput(
     } else {
 #endif /* TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING */
 
-	nread = (chanPtr->typePtr->inputProc)(chanPtr->instanceData,
+	nread = chanPtr->typePtr->inputProc(chanPtr->instanceData,
 		InsertPoint(bufPtr), toRead, &result);
 
 #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
@@ -6394,14 +6391,14 @@ Tcl_Seek(
 
 	if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) &&
 		chanPtr->typePtr->wideSeekProc != NULL) {
-	    curPos = (chanPtr->typePtr->wideSeekProc) (chanPtr->instanceData,
+	    curPos = chanPtr->typePtr->wideSeekProc(chanPtr->instanceData,
 		    offset, mode, &result);
 	} else if (offset < Tcl_LongAsWide(LONG_MIN) ||
 		offset > Tcl_LongAsWide(LONG_MAX)) {
 	    result = EOVERFLOW;
 	    curPos = Tcl_LongAsWide(-1);
 	} else {
-	    curPos = Tcl_LongAsWide((chanPtr->typePtr->seekProc) (
+	    curPos = Tcl_LongAsWide(chanPtr->typePtr->seekProc(
 		    chanPtr->instanceData, Tcl_WideAsLong(offset), mode,
 		    &result));
 	}
@@ -6512,10 +6509,10 @@ Tcl_Tell(
 
     if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) &&
 	    chanPtr->typePtr->wideSeekProc != NULL) {
-	curPos = (chanPtr->typePtr->wideSeekProc) (chanPtr->instanceData,
+	curPos = chanPtr->typePtr->wideSeekProc(chanPtr->instanceData,
 		Tcl_LongAsWide(0), SEEK_CUR, &result);
     } else {
-	curPos = Tcl_LongAsWide((chanPtr->typePtr->seekProc) (
+	curPos = Tcl_LongAsWide(chanPtr->typePtr->seekProc(
 		chanPtr->instanceData, 0, SEEK_CUR, &result));
     }
     if (curPos == Tcl_LongAsWide(-1)) {
@@ -7275,8 +7272,8 @@ Tcl_GetChannelOption(
 	 * and message.
 	 */
 
-	return (chanPtr->typePtr->getOptionProc) (chanPtr->instanceData,
-		interp, optionName, dsPtr);
+	return chanPtr->typePtr->getOptionProc(chanPtr->instanceData, interp,
+		optionName, dsPtr);
     } else {
 	/*
 	 * No driver specific options case.
@@ -7577,8 +7574,8 @@ Tcl_SetChannelOption(
 	ckfree((char *) argv);
 	return TCL_OK;
     } else if (chanPtr->typePtr->setOptionProc != NULL) {
-	return (*chanPtr->typePtr->setOptionProc)(chanPtr->instanceData,
-		interp, optionName, newValue);
+	return chanPtr->typePtr->setOptionProc(chanPtr->instanceData, interp,
+		optionName, newValue);
     } else {
 	return Tcl_BadChannelOption(interp, optionName, NULL);
     }
@@ -7735,7 +7732,7 @@ Tcl_NotifyChannel(
 	upTypePtr = upChanPtr->typePtr;
 	upHandlerProc = Tcl_ChannelHandlerProc(upTypePtr);
 	if (upHandlerProc != NULL) {
-	    mask = (*upHandlerProc) (upChanPtr->instanceData, mask);
+	    mask = upHandlerProc(upChanPtr->instanceData, mask);
 	}
 
 	/*
@@ -7796,7 +7793,7 @@ Tcl_NotifyChannel(
 
 	if ((chPtr->mask & mask) != 0) {
 	    nh.nextHandlerPtr = chPtr->nextPtr;
-	    (*(chPtr->proc))(chPtr->clientData, mask);
+	    chPtr->proc(chPtr->clientData, mask);
 	    chPtr = nh.nextHandlerPtr;
 	} else {
 	    chPtr = chPtr->nextPtr;
@@ -7912,7 +7909,7 @@ UpdateInterest(
 	    }
 	}
     }
-    (chanPtr->typePtr->watchProc)(chanPtr->instanceData, mask);
+    chanPtr->typePtr->watchProc(chanPtr->instanceData, mask);
 }
 
 /*
@@ -9508,7 +9505,7 @@ StackSetBlockMode(
     while (chanPtr != NULL) {
 	blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr);
 	if (blockModeProc != NULL) {
-	    result = (*blockModeProc) (chanPtr->instanceData, mode);
+	    result = blockModeProc(chanPtr->instanceData, mode);
 	    if (result != 0) {
 		Tcl_SetErrno(result);
 		return result;
@@ -9935,7 +9932,7 @@ Tcl_ChannelBlockModeProc(
 	 * The v1 structure had the blockModeProc in a different place.
 	 */
 
-	return (Tcl_DriverBlockModeProc *) (chanTypePtr->version);
+	return (Tcl_DriverBlockModeProc *) chanTypePtr->version;
     }
 }
 
@@ -10610,8 +10607,9 @@ DupChannelIntRep(
 				 * currently have an internal rep.*/
 {
     ChannelState *statePtr = GET_CHANNELSTATE(srcPtr);
+
     SET_CHANNELSTATE(copyPtr, statePtr);
-    Tcl_Preserve((ClientData) statePtr);
+    Tcl_Preserve(statePtr);
     copyPtr->typePtr = &tclChannelType;
 }
 
@@ -10647,7 +10645,7 @@ SetChannelFromAny(
 	statePtr = GET_CHANNELSTATE(objPtr);
 	if (statePtr->flags & (CHANNEL_TAINTED|CHANNEL_CLOSED)) {
 	    ResetFlag(statePtr, CHANNEL_TAINTED);
-	    Tcl_Release((ClientData) statePtr);
+	    Tcl_Release(statePtr);
 	    UpdateStringOfChannel(objPtr);
 	    objPtr->typePtr = NULL;
 	}
@@ -10669,8 +10667,8 @@ SetChannelFromAny(
 	}
 
 	TclFreeIntRep(objPtr);
-	statePtr = ((Channel *)chan)->state;
-	Tcl_Preserve((ClientData) statePtr);
+	statePtr = ((Channel *) chan)->state;
+	Tcl_Preserve(statePtr);
 	SET_CHANNELSTATE(objPtr, statePtr);
 	objPtr->typePtr = &tclChannelType;
     }
@@ -10734,7 +10732,7 @@ static void
 FreeChannelIntRep(
     Tcl_Obj *objPtr)		/* Object with internal rep to free. */
 {
-    Tcl_Release((ClientData) GET_CHANNELSTATE(objPtr));
+    Tcl_Release(GET_CHANNELSTATE(objPtr));
 }
 
 #if 0
diff --git a/generic/tclIORTrans.c b/generic/tclIORTrans.c
index 55d0807..b550675 100644
--- a/generic/tclIORTrans.c
+++ b/generic/tclIORTrans.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: tclIORTrans.c,v 1.5 2008/10/17 18:06:08 andreas_kupries Exp $
+ * RCS: @(#) $Id: tclIORTrans.c,v 1.6 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include <tclInt.h>
@@ -56,32 +56,32 @@ static int		ReflectSetOption(ClientData clientData,
 			    Tcl_Interp *interp, const char *optionName,
 			    const char *newValue);
 static int		ReflectHandle(ClientData clientData, int direction,
-				      ClientData* handle);
+			    ClientData *handle);
 static int		ReflectNotify(ClientData clientData, int mask);
 
 /*
- * The C layer channel type/driver definition used by the reflection. This is
- * a version 3 structure.
+ * The C layer channel type/driver definition used by the reflection.
  */
 
 static Tcl_ChannelType tclRTransformType = {
-    "tclrtransform",       /* Type name.                                  */
-    TCL_CHANNEL_VERSION_5, /* v5 channel */
-    ReflectClose,          /* Close channel, clean instance data          */
-    ReflectInput,          /* Handle read request                         */
-    ReflectOutput,         /* Handle write request                        */
-    ReflectSeek,           /* Move location of access point.              */
-    ReflectSetOption,      /* Set options.                                */
-    ReflectGetOption,      /* Get options.                                */
-    ReflectWatch,          /* Initialize notifier                         */
-    ReflectHandle,         /* Get OS handle from the channel.             */
-    NULL,                  /* No close2 support.               NULL'able  */
-    ReflectBlock,          /* Set blocking/nonblocking.                   */
-    NULL,                  /* Flush channel. Not used by core. NULL'able  */
-    ReflectNotify,         /* Handle events.                              */
-    ReflectSeekWide,       /* Move access point (64 bit).                 */
-    NULL,                  /* thread action */
-    NULL,                  /* truncate */
+    "tclrtransform",		/* Type name. */
+    TCL_CHANNEL_VERSION_5,	/* v5 channel. */
+    ReflectClose,		/* Close channel, clean instance data. */
+    ReflectInput,		/* Handle read request. */
+    ReflectOutput,		/* Handle write request. */
+    ReflectSeek,		/* Move location of access point. */
+    ReflectSetOption,		/* Set options. */
+    ReflectGetOption,		/* Get options. */
+    ReflectWatch,		/* Initialize notifier. */
+    ReflectHandle,		/* Get OS handle from the channel. */
+    NULL,			/* No close2 support. NULL'able  */
+    ReflectBlock,		/* Set blocking/nonblocking. */
+    NULL,			/* Flush channel. Not used by core.
+				 * NULL'able. */
+    ReflectNotify,		/* Handle events. */
+    ReflectSeekWide,		/* Move access point (64 bit). */
+    NULL,			/* thread action */
+    NULL,			/* truncate */
 };
 
 /*
@@ -90,18 +90,21 @@ static Tcl_ChannelType tclRTransformType = {
  */
 
 typedef struct _ResultBuffer_ {
-  unsigned char* buf;       /* Reference to the buffer area */
-  int            allocated; /* Allocated size of the buffer area */
-  int            used;      /* Number of bytes in the buffer, <= allocated */
+  unsigned char *buf;		/* Reference to the buffer area. */
+  int allocated;		/* Allocated size of the buffer area. */
+  int used;			/* Number of bytes in the buffer,
+				 * <= allocated. */
 } ResultBuffer;
 
 #define ResultLength(r) ((r)->used)
-/* static int ResultLength        (ResultBuffer* r); */
+/* static int ResultLength        (ResultBuffer *r); */
 
-static void  ResultClear          (ResultBuffer* r);
-static void  ResultInit           (ResultBuffer* r);
-static void  ResultAdd            (ResultBuffer* r, unsigned char* buf, int toWrite);
-static int   ResultCopy           (ResultBuffer* r, unsigned char* buf, int toRead);
+static void		ResultClear(ResultBuffer *r);
+static void		ResultInit(ResultBuffer *r);
+static void		ResultAdd(ResultBuffer *r, unsigned char *buf,
+			    int toWrite);
+static int		ResultCopy(ResultBuffer *r, unsigned char *buf,
+			    int toRead);
 
 #define RB_INCREMENT (512)
 
@@ -118,15 +121,14 @@ static int   ResultCopy           (ResultBuffer* r, unsigned char* buf, int toRe
 typedef struct {
     Tcl_Channel chan;		/* Back reference to the channel of the
 				 * transformation itself. */
-    Tcl_Channel parent;         /* Reference to the channel the transformation
+    Tcl_Channel parent;		/* Reference to the channel the transformation
 				 * was pushed on. */
     Tcl_Interp *interp;		/* Reference to the interpreter containing the
 				 * Tcl level part of the channel. */
-    Tcl_Obj    *handle;         /* Reference to transform handle. Also stored
+    Tcl_Obj *handle;		/* Reference to transform handle. Also stored
 				 * in the argv, see below. The separate field
 				 * gives us direct access, needed when working
-				 * with the reflection maps.
-				 */
+				 * with the reflection maps. */
 #ifdef TCL_THREADS
     Tcl_ThreadId thread;	/* Thread the 'interp' belongs to. */
 #endif
@@ -144,14 +146,14 @@ typedef struct {
      * CT = Belongs to the 'Command handler Thread'.
      */
 
-    int argc;			/* Number of preallocated words - 2 */
+    int argc;			/* Number of preallocated words - 2. */
     Tcl_Obj **argv;		/* Preallocated array for calling the handler.
 				 * args[0] is placeholder for cmd word.
 				 * Followed by the arguments in the prefix,
 				 * plus 4 placeholders for method, channel,
 				 * and at most two varying (method specific)
 				 * words. */
-    int methods;		/* Bitmask of supported methods */
+    int methods;		/* Bitmask of supported methods. */
 
     /*
      * NOTE (9): Should we have predefined shared literals for the method
@@ -159,11 +161,9 @@ typedef struct {
      */
 
     int mode;			/* Mask of R/W mode */
-    int nonblocking;            /* Flag: Channel is blocking or not */
-    int readIsDrained;          /* Flag: Read buffers are flushed*/
-
+    int nonblocking;		/* Flag: Channel is blocking or not. */
+    int readIsDrained;		/* Flag: Read buffers are flushed. */
     ResultBuffer result;
-
 } ReflectedTransform;
 
 /*
@@ -243,9 +243,9 @@ typedef enum {
 
 /*
  * Event used to forward driver invocations to the thread actually managing
- * the channel. We cannot construct the command to execute and forward
- * that. Because then it will contain a mixture of Tcl_Obj's belonging to both
- * the command handler thread (CT), and the thread managing the channel (MT),
+ * the channel. We cannot construct the command to execute and forward that.
+ * Because then it will contain a mixture of Tcl_Obj's belonging to both the
+ * command handler thread (CT), and the thread managing the channel (MT),
  * executed in CT. Tcl_Obj's are not allowed to cross thread boundaries. So we
  * forward an operation code, the argument details, and reference to results.
  * The command is assembled in the CT and belongs fully to that thread. No
@@ -284,7 +284,7 @@ struct ForwardParamLimit {
 typedef union ForwardParam {
     ForwardParamBase base;
     struct ForwardParamTransform transform;
-    struct ForwardParamLimit     limit;
+    struct ForwardParamLimit limit;
 } ForwardParam;
 
 /*
@@ -333,7 +333,7 @@ typedef struct ThreadSpecificData {
      * Table of all reflected transformations owned by this thread.
      */
 
-    ReflectedTransformMap* rtmPtr;
+    ReflectedTransformMap *rtmPtr;
 } ThreadSpecificData;
 
 static Tcl_ThreadDataKey dataKey;
@@ -358,7 +358,7 @@ TCL_DECLARE_MUTEX(rtForwardMutex)
  */
 
 static void		ForwardOpToOwnerThread(ReflectedTransform *rtPtr,
-			    ForwardedOperation op, const VOID *param);
+			    ForwardedOperation op, const void *param);
 static int		ForwardProc(Tcl_Event *evPtr, int mask);
 static void		SrcExitProc(ClientData clientData);
 
@@ -424,41 +424,50 @@ static void		DeleteReflectedTransformMap(ClientData clientData,
  * list-quoting to keep the words of the message together. See also [x].
  */
 
-static const char *msg_read_badlimit = "{Tcl driver returned bad read limit '0'}";
+static const char *msg_read_badlimit =
+	"{Tcl driver returned bad read limit '0'}";
 static const char *msg_read_unsup = "{read not supported by Tcl driver}";
 static const char *msg_write_unsup = "{write not supported by Tcl driver}";
 #ifdef TCL_THREADS
 static const char *msg_send_originlost = "{Channel thread lost}";
 static const char *msg_send_dstlost = "{Owner lost}";
 #endif /* TCL_THREADS */
-static const char *msg_dstlost    = "-code 1 -level 0 -errorcode NONE -errorinfo {} -errorline 1 {Owner lost}";
+static const char *msg_dstlost =
+    "-code 1 -level 0 -errorcode NONE -errorinfo {} -errorline 1 {Owner lost}";
 
 /*
  * Timer management (flushing out buffered data via artificial events).
  */
 
 /*
- * Number of milliseconds to wait before firing an event to try to
- * flush out information waiting in buffers (fileevent support).
+ * Number of milliseconds to wait before firing an event to try to flush out
+ * information waiting in buffers (fileevent support).
  */
 
 #define FLUSH_DELAY (5)
 
-static void TimerKill  (ReflectedTransform* rtPtr);
-static void TimerSetup (ReflectedTransform* rtPtr);
-static void TimerRun   (ClientData clientData);
+static void TimerKill(ReflectedTransform* rtPtr);
+static void TimerSetup(ReflectedTransform* rtPtr);
+static void TimerRun(ClientData clientData);
 
 /*
  * Helper functions encapsulating some of the thread forwarding to make the
  * control flow in callers easier.
  */
 
-static int  TransformRead  (ReflectedTransform* rtPtr, int* errorCodePtr, unsigned char* buf, int toRead);
-static int  TransformWrite (ReflectedTransform* rtPtr, int* errorCodePtr, unsigned char* buf, int toWrite);
-static int  TransformDrain (ReflectedTransform* rtPtr, int* errorCodePtr);
-static int  TransformFlush (ReflectedTransform* rtPtr, int* errorCodePtr, int op);
-static void TransformClear (ReflectedTransform* rtPtr);
-static int  TransformLimit (ReflectedTransform* rtPtr, int* errorCodePtr, int* maxPtr);
+static int		TransformRead(ReflectedTransform *rtPtr,
+			    int *errorCodePtr, unsigned char *buf,
+			    int toRead);
+static int		TransformWrite(ReflectedTransform *rtPtr,
+			    int *errorCodePtr, unsigned char *buf,
+			    int toWrite);
+static int		TransformDrain(ReflectedTransform *rtPtr,
+			    int *errorCodePtr);
+static int		TransformFlush(ReflectedTransform *rtPtr,
+			    int *errorCodePtr, int op);
+static void		TransformClear(ReflectedTransform *rtPtr);
+static int		TransformLimit(ReflectedTransform *rtPtr,
+			    int *errorCodePtr, int *maxPtr);
 
 /* op'codes for TransformFlush */
 #define FLUSH_WRITE   1
@@ -467,14 +476,14 @@ static int  TransformLimit (ReflectedTransform* rtPtr, int* errorCodePtr, int* m
 /*
  * Main methods to plug into the 'chan' ensemble'. ==================
  */
-
+
 /*
  *----------------------------------------------------------------------
  *
  * TclChanPushObjCmd --
  *
- *	This function is invoked to process the "chan push" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "chan push" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result. The handle of the new channel is placed in the
@@ -493,17 +502,17 @@ TclChanPushObjCmd(
     int objc,
     Tcl_Obj *const *objv)
 {
-    ReflectedTransform *rtPtr;	/* Instance data of the new (transform) channel */
-    Tcl_Obj*    chanObj;        /* Handle of parent channel */
-    Tcl_Channel parentChan;     /* Token of parent channel */
-    int mode;			/* R/W mode of parent, later the new
-				 * channel. Has to match the abilities of the
-				 * handler commands */
+    ReflectedTransform *rtPtr;	/* Instance data of the new (transform)
+				 * channel. */
+    Tcl_Obj *chanObj;		/* Handle of parent channel */
+    Tcl_Channel parentChan;	/* Token of parent channel */
+    int mode;			/* R/W mode of parent, later the new channel.
+				 * Has to match the abilities of the handler
+				 * commands */
     Tcl_Obj *cmdObj;		/* Command prefix, list of words */
     Tcl_Obj *cmdNameObj;	/* Command name */
     Tcl_Obj *rtId;		/* Handle of the new transform (channel) */
     Tcl_Obj *modeObj;		/* mode in obj form for method call */
-
     int listc;			/* Result of 'initialize', and of */
     Tcl_Obj **listv;		/* its sublist in the 2nd element */
     int methIndex;		/* Encoded method name */
@@ -512,8 +521,8 @@ TclChanPushObjCmd(
     int methods;		/* Bitmask for supported methods. */
     Tcl_Obj *err;		/* Error message */
     ReflectedTransformMap *rtmPtr;
-				/* Map of reflected transforms with handlers in
-				 * this interp. */
+				/* Map of reflected transforms with handlers
+				 * in this interp. */
     Tcl_HashEntry *hPtr;	/* Entry in the above map */
     int isNew;			/* Placeholder. */
 
@@ -541,16 +550,16 @@ TclChanPushObjCmd(
      * First argument is a channel handle.
      */
 
-    chanObj    = objv[CHAN];
-    parentChan = Tcl_GetChannel (interp, Tcl_GetString (chanObj), &mode);
+    chanObj = objv[CHAN];
+    parentChan = Tcl_GetChannel(interp, Tcl_GetString(chanObj), &mode);
     if (parentChan == NULL) {
 	return TCL_ERROR;
     }
-    parentChan = Tcl_GetTopChannel (parentChan);
+    parentChan = Tcl_GetTopChannel(parentChan);
 
     /*
      * Second argument is command prefix, i.e. list of words, first word is
-     * name of handler command, other words are fixed arguments. Run
+     * name of handler command, other words are fixed arguments. Run the
      * 'initialize' method to get the list of supported methods. Validate
      * this.
      */
@@ -588,9 +597,8 @@ TclChanPushObjCmd(
 
     /*
      * Verify the result.
-     * - List, of method names. Convert to mask.
-     *   Check for non-optionals through the mask.
-     *   Compare open mode against optional r/w.
+     * - List, of method names. Convert to mask. Check for non-optionals
+     *   through the mask. Compare open mode against optional r/w.
      */
 
     if (Tcl_ListObjGetElements(NULL, resObj, &listc, &listv) != TCL_OK) {
@@ -637,8 +645,12 @@ TclChanPushObjCmd(
      * also be supported by the handler, by design of the check.
      */
 
-    if (!HAS(methods, METH_READ))  { mode &= ~TCL_READABLE; }
-    if (!HAS(methods, METH_WRITE)) { mode &= ~TCL_WRITABLE; }
+    if (!HAS(methods, METH_READ)) {
+	mode &= ~TCL_READABLE;
+    }
+    if (!HAS(methods, METH_WRITE)) {
+	mode &= ~TCL_WRITABLE;
+    }
 
     if (!mode) {
 	TclNewLiteralStringObj(err, "chan handler \"");
@@ -675,27 +687,24 @@ TclChanPushObjCmd(
      */
 
     rtPtr->methods = methods;
-    rtPtr->mode    = mode;
-    rtPtr->chan    = Tcl_StackChannel (interp, &tclRTransformType,
-				       (ClientData) rtPtr, mode,
-				       rtPtr->parent);
+    rtPtr->mode = mode;
+    rtPtr->chan = Tcl_StackChannel(interp, &tclRTransformType, rtPtr, mode,
+	    rtPtr->parent);
 
     /*
      * Register the transform in our our map for proper handling of deleted
      * interpreters and/or threads.
      */
 
-    rtmPtr = GetReflectedTransformMap (interp);
-    hPtr = Tcl_CreateHashEntry(&rtmPtr->map, Tcl_GetString(rtId),
-	    &isNew);
+    rtmPtr = GetReflectedTransformMap(interp);
+    hPtr = Tcl_CreateHashEntry(&rtmPtr->map, Tcl_GetString(rtId), &isNew);
     if (!isNew && rtPtr != Tcl_GetHashValue(hPtr)) {
 	Tcl_Panic("TclChanPushObjCmd: duplicate transformation handle");
     }
     Tcl_SetHashValue(hPtr, rtPtr);
 #ifdef TCL_THREADS
     rtmPtr = GetThreadReflectedTransformMap();
-    hPtr = Tcl_CreateHashEntry(&rtmPtr->map, Tcl_GetString(rtId),
-	    &isNew);
+    hPtr = Tcl_CreateHashEntry(&rtmPtr->map, Tcl_GetString(rtId), &isNew);
     Tcl_SetHashValue(hPtr, rtPtr);
 #endif
 
@@ -703,11 +712,10 @@ TclChanPushObjCmd(
      * Return the channel as the result of the command.
      */
 
-    Tcl_AppendResult (interp, Tcl_GetChannelName (rtPtr->chan),
-		    (char*) NULL);
+    Tcl_AppendResult(interp, Tcl_GetChannelName(rtPtr->chan), NULL);
     return TCL_OK;
 
- error:
+  error:
     /*
      * We are not going through ReflectClose as we never had a channel
      * structure.
@@ -725,8 +733,8 @@ TclChanPushObjCmd(
  *
  * TclChanPopObjCmd --
  *
- *	This function is invoked to process the "chan pop" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "chan pop" Tcl command. See
+ *	the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -757,7 +765,7 @@ TclChanPopObjCmd(
 
     const char *chanId;		/* Tcl level channel handle */
     Tcl_Channel chan;		/* Channel associated to the handle */
-    int         mode;           /* Channel r/w mode */
+    int mode;			/* Channel r/w mode */
 
     /*
      * Number of arguments...
@@ -774,13 +782,14 @@ TclChanPopObjCmd(
      */
 
     chanId = TclGetString(objv[CHAN]);
-    chan   = Tcl_GetChannel(interp, chanId, &mode);
+    chan = Tcl_GetChannel(interp, chanId, &mode);
 
     if (chan == NULL) {
 	return TCL_ERROR;
     }
 
-    /* Removing transformations is generic, and not restricted to reflected
+    /*
+     * Removing transformations is generic, and not restricted to reflected
      * transformations.
      */
 
@@ -794,7 +803,7 @@ TclChanPopObjCmd(
  * Channel error message marshalling utilities.
  */
 
-static Tcl_Obj*
+static Tcl_Obj *
 MarshallError(
     Tcl_Interp *interp)
 {
@@ -848,8 +857,8 @@ UnmarshallErrorResult(
 	Tcl_SetObjResult(interp, lv[lc-1]);
     }
 
-    (void) Tcl_SetReturnOptions(interp, Tcl_NewListObj(numOptions, lv));
-    ((Interp *)interp)->flags &= ~ERR_ALREADY_LOGGED;
+    Tcl_SetReturnOptions(interp, Tcl_NewListObj(numOptions, lv));
+    ((Interp *) interp)->flags &= ~ERR_ALREADY_LOGGED;
 }
 
 /*
@@ -878,11 +887,12 @@ ReflectClose(
     ClientData clientData,
     Tcl_Interp *interp)
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+    ReflectedTransform *rtPtr = clientData;
     int result;			/* Result code for 'close' */
     Tcl_Obj *resObj;		/* Result data for 'close' */
-    ReflectedTransformMap *rtmPtr;/* Map of reflected transforms with handlers in
-				 * this interp */
+    ReflectedTransformMap *rtmPtr;
+				/* Map of reflected transforms with handlers
+				 * in this interp. */
     Tcl_HashEntry *hPtr;	/* Entry in the above map */
 
     if (interp == NULL) {
@@ -933,16 +943,18 @@ ReflectClose(
      * that check is not necessary. We always go through 'finalize'.
      */
 
-    if (HAS(rtPtr->methods, METH_DRAIN) && (!rtPtr->readIsDrained)) {
+    if (HAS(rtPtr->methods, METH_DRAIN) && !rtPtr->readIsDrained) {
 	int errorCode;
-	if (!TransformDrain (rtPtr, &errorCode)) {
+
+	if (!TransformDrain(rtPtr, &errorCode)) {
 	    return errorCode;
 	}
     }
 
     if (HAS(rtPtr->methods, METH_FLUSH)) {
 	int errorCode;
-	if (!TransformFlush (rtPtr, &errorCode, FLUSH_WRITE)) {
+
+	if (!TransformFlush(rtPtr, &errorCode, FLUSH_WRITE)) {
 	    return errorCode;
 	}
     }
@@ -965,52 +977,55 @@ ReflectClose(
 
 	if (result != TCL_OK) {
 	    PassReceivedErrorInterp(interp, &p);
+	    return EINVAL;
 	}
-    } else {
+	return EOK;
+    }
 #endif
-	result = InvokeTclMethod(rtPtr, "finalize", NULL, NULL, &resObj);
-	if ((result != TCL_OK) && (interp != NULL)) {
-	    Tcl_SetChannelErrorInterp(interp, resObj);
-	}
 
-	Tcl_DecrRefCount(resObj);	/* Remove reference we held from the
-					 * invoke */
+    /*
+     * Do the actual invokation of "finalize" now; we're in the right thread.
+     */
 
-	/*
-	 * Remove the transform from the map before releasing the memory, to
-	 * prevent future accesses from finding and dereferencing a dangling
-	 * pointer.
-	 *
-	 * NOTE: The transform may not be in the map. This is ok, that happens
-	 * when the transform was created in a different interpreter and/or
-	 * thread and then was moved here.
-	 */
+    result = InvokeTclMethod(rtPtr, "finalize", NULL, NULL, &resObj);
+    if ((result != TCL_OK) && (interp != NULL)) {
+	Tcl_SetChannelErrorInterp(interp, resObj);
+    }
 
-	rtmPtr = GetReflectedTransformMap(interp);
- 	hPtr = Tcl_FindHashEntry (&rtmPtr->map,
- 				  Tcl_GetString(rtPtr->handle));
-	if (hPtr) {
-	    Tcl_DeleteHashEntry (hPtr);
-	}
-#ifdef TCL_THREADS
-	/*
-	 * In a threaded interpreter we manage a per-thread map as well, to
-	 * allow us to survive if the script level pulls the rug out under a
-	 * channel by deleting the owning thread.
-	 */
+    Tcl_DecrRefCount(resObj);	/* Remove reference we held from the
+				 * invoke. */
 
-        rtmPtr = GetThreadReflectedTransformMap();
-	hPtr = Tcl_FindHashEntry (&rtmPtr->map,
-				  Tcl_GetString(rtPtr->handle));
-	if (hPtr) {
-	    Tcl_DeleteHashEntry (hPtr);
-	}
-#endif
+    /*
+     * Remove the transform from the map before releasing the memory, to
+     * prevent future accesses from finding and dereferencing a dangling
+     * pointer.
+     *
+     * NOTE: The transform may not be in the map. This is ok, that happens
+     * when the transform was created in a different interpreter and/or thread
+     * and then was moved here.
+     */
+
+    rtmPtr = GetReflectedTransformMap(interp);
+    hPtr = Tcl_FindHashEntry(&rtmPtr->map, Tcl_GetString(rtPtr->handle));
+    if (hPtr) {
+	Tcl_DeleteHashEntry(hPtr);
+    }
+
+    /*
+     * In a threaded interpreter we manage a per-thread map as well, to allow
+     * us to survive if the script level pulls the rug out under a channel by
+     * deleting the owning thread.
+     */
 
-	FreeReflectedTransform(rtPtr);
 #ifdef TCL_THREADS
+    rtmPtr = GetThreadReflectedTransformMap();
+    hPtr = Tcl_FindHashEntry(&rtmPtr->map, Tcl_GetString(rtPtr->handle));
+    if (hPtr) {
+	Tcl_DeleteHashEntry(hPtr);
     }
 #endif
+
+    FreeReflectedTransform(rtPtr);
     return (result == TCL_OK) ? EOK : EINVAL;
 }
 
@@ -1032,12 +1047,12 @@ ReflectClose(
 
 static int
 ReflectInput(
-	     ClientData clientData,
-	     char *buf,
-	     int toRead,
-	     int *errorCodePtr)
+    ClientData clientData,
+    char *buf,
+    int toRead,
+    int *errorCodePtr)
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+    ReflectedTransform *rtPtr = clientData;
     int gotBytes, copied, read;
 
     /*
@@ -1055,13 +1070,14 @@ ReflectInput(
     gotBytes = 0;
 
     while (toRead > 0) {
-	/* Loop until the request is satisfied (or no data available from
+	/*
+	 * Loop until the request is satisfied (or no data available from
 	 * below, possibly EOF).
 	 */
 
-	copied    = ResultCopy (&rtPtr->result, UCHARP(buf), toRead);
-	toRead   -= copied;
-	buf      += copied;
+	copied = ResultCopy(&rtPtr->result, UCHARP(buf), toRead);
+	toRead -= copied;
+	buf += copied;
 	gotBytes += copied;
 
 	if (toRead == 0) {
@@ -1073,9 +1089,7 @@ ReflectInput(
 	 * have to go to the underlying channel, get more bytes and then
 	 * transform them for delivery. We may not get what we want (full EOF
 	 * or temporarily out of data).
-	 */
-
-	/*
+	 *
 	 * Length (rtPtr->result) == 0, toRead > 0 here. Use 'buf'! as target
 	 * to store the intermediary information read from the parent channel.
 	 *
@@ -1088,7 +1102,8 @@ ReflectInput(
 
 	if ((rtPtr->methods & FLAG(METH_LIMIT))) {
 	    int maxRead = -1;
-	    if (!TransformLimit (rtPtr, errorCodePtr, &maxRead)) {
+
+	    if (!TransformLimit(rtPtr, errorCodePtr, &maxRead)) {
 		return -1;
 	    }
 	    if (maxRead == 0) {
@@ -1105,22 +1120,24 @@ ReflectInput(
 	    return gotBytes;
 	}
 
-	read = Tcl_ReadRaw (rtPtr->parent, buf, toRead);
+	read = Tcl_ReadRaw(rtPtr->parent, buf, toRead);
 	if (read < 0) {
-	    /* Report errors to caller.
-	     * The state of the seek system is unchanged!
+	    /*
+	     * Report errors to caller. The state of the seek system is
+	     * unchanged!
 	     */
 
-	    if ((Tcl_GetErrno () == EAGAIN) && (gotBytes > 0)) {
-		/* EAGAIN is a special situation.  If we had some data
-		 * before we report that instead of the request to re-try.
+	    if ((Tcl_GetErrno() == EAGAIN) && (gotBytes > 0)) {
+		/*
+		 * EAGAIN is a special situation. If we had some data before
+		 * we report that instead of the request to re-try.
 		 */
 
 		return gotBytes;
 	    }
 
-	    *errorCodePtr = Tcl_GetErrno ();
-	    return -1;
+	    *errorCodePtr = Tcl_GetErrno();
+	    return -1;      
 	}
 
 	if (read == 0) {
@@ -1134,17 +1151,21 @@ ReflectInput(
 	     * convert and flush all waiting partial data.
 	     */
 
-	    if (!Tcl_Eof (rtPtr->parent)) {
-		/* The state of the seek system is unchanged! */
+	    if (!Tcl_Eof(rtPtr->parent)) {
+		/*
+		 * The state of the seek system is unchanged!
+		 */
 
 		if ((gotBytes == 0) && rtPtr->nonblocking) {
 		    *errorCodePtr = EWOULDBLOCK;
 		    return -1;
-		} else {
-		    return gotBytes;
 		}
+		return gotBytes;
 	    } else {
-		/* Eof in parent */
+		/*
+		 * Eof in parent.
+		 */
+
 		if (rtPtr->readIsDrained) {
 		    return gotBytes;
 		}
@@ -1155,18 +1176,24 @@ ReflectInput(
 		 */
 
 		if (HAS(rtPtr->methods, METH_DRAIN)) {
-		    if(!TransformDrain (rtPtr, errorCodePtr)) {
+		    if (!TransformDrain(rtPtr, errorCodePtr)) {
 			return -1;
 		    }
 		}
 
-		if (ResultLength (&rtPtr->result) == 0) {
-		    /* The drain delivered nothing */
+		if (ResultLength(&rtPtr->result) == 0) {
+		    /*
+		     * The drain delivered nothing.
+		     */
+
 		    return gotBytes;
 		}
 
-		/* Reset eof, force caller to drain result buffer */
-                ((Channel*) rtPtr->parent)->state->flags &= ~CHANNEL_EOF;
+		/*
+		 * Reset eof, force caller to drain result buffer.
+		 */
+
+                ((Channel *) rtPtr->parent)->state->flags &= ~CHANNEL_EOF;
 		continue; /* at: while (toRead > 0) */
 	    }
 	} /* read == 0 */
@@ -1177,13 +1204,12 @@ ReflectInput(
 	 * iteration will put it into the result.
 	 */
 
-	if (!TransformRead (rtPtr, errorCodePtr, UCHARP(buf), read)) {
+	if (!TransformRead(rtPtr, errorCodePtr, UCHARP(buf), read)) {
 	    return -1;
 	}
     } /* while toRead > 0 */
 
     return gotBytes;
-
 }
 
 /*
@@ -1209,7 +1235,7 @@ ReflectOutput(
     int toWrite,
     int *errorCodePtr)
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+    ReflectedTransform *rtPtr = clientData;
 
     /*
      * The following check can be done before thread redirection, because we
@@ -1224,8 +1250,10 @@ ReflectOutput(
     }
 
     if (toWrite == 0) {
-	/* Nothing came in to write, ignore the call
+	/*
+	 * Nothing came in to write, ignore the call
 	 */
+
 	return 0;
     }
 
@@ -1235,7 +1263,7 @@ ReflectOutput(
      */
 
     if ((rtPtr->methods & FLAG(METH_CLEAR))) {
-	TransformClear (rtPtr);
+	TransformClear(rtPtr);
     }
 
     /*
@@ -1244,7 +1272,7 @@ ReflectOutput(
      * parent channel for further processing.
      */
 
-    if (!TransformWrite (rtPtr, errorCodePtr, UCHARP(buf), toWrite)) {
+    if (!TransformWrite(rtPtr, errorCodePtr, UCHARP(buf), toWrite)) {
 	return -1;
     }
 
@@ -1263,7 +1291,8 @@ ReflectOutput(
  *	The new location of the access point.
  *
  * Side effects:
- *	Allocates memory. Arbitrary, per the parent channel, and the called scripts.
+ *	Allocates memory. Arbitrary, per the parent channel, and the called
+ *	scripts.
  *
  *----------------------------------------------------------------------
  */
@@ -1275,12 +1304,12 @@ ReflectSeekWide(
     int seekMode,
     int *errorCodePtr)
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
-    Channel* parent = (Channel*) rtPtr->parent;
+    ReflectedTransform *rtPtr = clientData;
+    Channel *parent = (Channel *) rtPtr->parent;
     Tcl_WideInt curPos;		/* Position on the device. */
 
-    Tcl_DriverSeekProc *seekProc      =
-	Tcl_ChannelSeekProc(Tcl_GetChannelType (rtPtr->parent));
+    Tcl_DriverSeekProc *seekProc =
+	    Tcl_ChannelSeekProc(Tcl_GetChannelType(rtPtr->parent));
 
     /*
      * Fail if the parent channel is not seekable.
@@ -1298,19 +1327,16 @@ ReflectSeekWide(
      * request down and the result back up unchanged.
      */
 
-    if (
-	((seekMode != SEEK_CUR) || (offset != 0)) &&
-	(HAS(rtPtr->methods, METH_CLEAR) ||
-	 HAS(rtPtr->methods, METH_FLUSH))
-	) {
+    if (((seekMode != SEEK_CUR) || (offset != 0)) &&
+	  (HAS(rtPtr->methods,METH_CLEAR) || HAS(rtPtr->methods,METH_FLUSH))){
 	/*
-	 * Neither a tell request, nor clear/flush both not supported.  We
-	 * have to go through the Tcl level to clear and/or flush the
+	 * Neither a tell request, nor clear/flush both not supported. We have
+	 * to go through the Tcl level to clear and/or flush the
 	 * transformation.
 	 */
 
 	if ((rtPtr->methods & FLAG(METH_CLEAR))) {
-	    TransformClear (rtPtr);
+	    TransformClear(rtPtr);
 	}
 
 	/*
@@ -1321,7 +1347,7 @@ ReflectSeekWide(
 	 */
 
 	if (HAS(rtPtr->methods, METH_FLUSH)) {
-	    if (!TransformFlush (rtPtr, errorCodePtr, FLUSH_DISCARD)) {
+	    if (!TransformFlush(rtPtr, errorCodePtr, FLUSH_DISCARD)) {
 		return -1;
 	    }
 	}
@@ -1335,14 +1361,14 @@ ReflectSeekWide(
 
     if (HaveVersion(parent->typePtr, TCL_CHANNEL_VERSION_3) &&
 	parent->typePtr->wideSeekProc != NULL) {
-	curPos = (parent->typePtr->wideSeekProc) (parent->instanceData,
-						  offset, seekMode, errorCodePtr);
+	curPos = parent->typePtr->wideSeekProc(parent->instanceData, offset,
+		seekMode, errorCodePtr);
     } else if (offset < Tcl_LongAsWide(LONG_MIN) ||
 	       offset > Tcl_LongAsWide(LONG_MAX)) {
 	*errorCodePtr = EOVERFLOW;
 	curPos = Tcl_LongAsWide(-1);
     } else {
-	curPos = Tcl_LongAsWide((parent->typePtr->seekProc) (
+	curPos = Tcl_LongAsWide(parent->typePtr->seekProc(
 		parent->instanceData, Tcl_WideAsLong(offset), seekMode,
 		errorCodePtr));
     }
@@ -1394,12 +1420,11 @@ ReflectWatch(
     ClientData clientData,
     int mask)
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
-    Tcl_DriverWatchProc* watchProc;
+    ReflectedTransform *rtPtr = clientData;
+    Tcl_DriverWatchProc *watchProc;
 
-    watchProc = Tcl_ChannelWatchProc (Tcl_GetChannelType (rtPtr->parent));
-    (*watchProc) (Tcl_GetChannelInstanceData(rtPtr->parent),
-		  mask);
+    watchProc = Tcl_ChannelWatchProc(Tcl_GetChannelType(rtPtr->parent));
+    watchProc(Tcl_GetChannelInstanceData(rtPtr->parent), mask);
 
     /*
      * Management of the internal timer.
@@ -1408,11 +1433,11 @@ ReflectWatch(
     if (!(mask & TCL_READABLE) || (ResultLength(&rtPtr->result) == 0)) {
 	/*
 	 * A pending timer may exist, but either is there no (more) interest
-	 * in the events it generates or nothing is available for
-	 * reading. Remove it, if existing.
+	 * in the events it generates or nothing is available for reading.
+	 * Remove it, if existing.
 	 */
 
-	TimerKill (rtPtr);
+	TimerKill(rtPtr);
     } else {
 	/*
 	 * There might be no pending timer, but there is interest in readable
@@ -1420,7 +1445,7 @@ ReflectWatch(
 	 * flush that if it does not exist.
 	 */
 
-	TimerSetup (rtPtr);
+	TimerSetup(rtPtr);
     }
 }
 
@@ -1446,7 +1471,7 @@ ReflectBlock(
     ClientData clientData,
     int nonblocking)
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+    ReflectedTransform *rtPtr = clientData;
 
     /*
      * Transformations simply record the blocking mode in their C level
@@ -1481,7 +1506,7 @@ ReflectSetOption(
     const char *optionName,	/* Name of requested option */
     const char *newValue)	/* The new value */
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+    ReflectedTransform *rtPtr = clientData;
 
     /*
      * Transformations have no options. Thus the call is passed down unchanged
@@ -1490,15 +1515,14 @@ ReflectSetOption(
      * level is not involved there is no need for thread forwarding.
      */
 
-    Tcl_DriverSetOptionProc *setOptionProc =
-      Tcl_ChannelSetOptionProc (Tcl_GetChannelType (rtPtr->parent));
+    Tcl_DriverSetOptionProc *setOptionProc = 
+	    Tcl_ChannelSetOptionProc(Tcl_GetChannelType(rtPtr->parent));
 
-    if (setOptionProc != NULL) {
-      return (*setOptionProc) (Tcl_GetChannelInstanceData (rtPtr->parent),
-			       interp, optionName, newValue);
-    } else {
-      return TCL_ERROR;
+    if (setOptionProc == NULL) {
+	return TCL_ERROR;
     }
+    return setOptionProc(Tcl_GetChannelInstanceData(rtPtr->parent), interp,
+	    optionName, newValue);
 }
 
 /*
@@ -1524,7 +1548,7 @@ ReflectGetOption(
     const char *optionName,	/* Name of reuqested option */
     Tcl_DString *dsPtr)		/* String to place the result into */
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+    ReflectedTransform *rtPtr = clientData;
 
     /*
      * Transformations have no options. Thus the call is passed down unchanged
@@ -1537,16 +1561,16 @@ ReflectGetOption(
      * specific option has to fail.
      */
 
-    Tcl_DriverGetOptionProc *getOptionProc =
-      Tcl_ChannelGetOptionProc (Tcl_GetChannelType (rtPtr->parent));
+    Tcl_DriverGetOptionProc *getOptionProc = 
+	    Tcl_ChannelGetOptionProc(Tcl_GetChannelType(rtPtr->parent));
 
     if (getOptionProc != NULL) {
-      return (*getOptionProc) (Tcl_GetChannelInstanceData (rtPtr->parent),
-			       interp, optionName, dsPtr);
-    } else if (optionName == (char*) NULL) {
-      return TCL_OK;
+	return getOptionProc(Tcl_GetChannelInstanceData(rtPtr->parent),
+		interp, optionName, dsPtr);
+    } else if (optionName == NULL) {
+	return TCL_OK;
     } else {
-      return TCL_ERROR;
+	return TCL_ERROR;
     }
 }
 
@@ -1568,11 +1592,11 @@ ReflectGetOption(
 
 static int
 ReflectHandle(
-	      ClientData  clientData,
-	      int         direction,
-	      ClientData* handlePtr)
+    ClientData clientData,
+    int direction,
+    ClientData *handlePtr)
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+    ReflectedTransform *rtPtr = clientData;
 
     /*
      * Transformations have no handle of their own. As such we simply query
@@ -1584,7 +1608,7 @@ ReflectHandle(
      * involved no forwarding is required.
      */
 
-    return Tcl_GetChannelHandle (rtPtr->parent, direction, handlePtr);
+    return Tcl_GetChannelHandle(rtPtr->parent, direction, handlePtr);
 }
 /*
  *----------------------------------------------------------------------
@@ -1604,10 +1628,10 @@ ReflectHandle(
 
 static int
 ReflectNotify(
-	      ClientData clientData,
-	      int mask)
+    ClientData clientData,
+    int mask)
 {
-    ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+    ReflectedTransform *rtPtr = clientData;
 
     /*
      * An event occured in the underlying channel.
@@ -1618,7 +1642,7 @@ ReflectNotify(
      * us to recreate the timer (in ReflectWatch).
      */
 
-    TimerKill (rtPtr);
+    TimerKill(rtPtr);
 
     /*
      * Pass to higher layers.
@@ -1722,14 +1746,17 @@ NewReflectedTransform(
     rtPtr->interp = interp;
     rtPtr->handle = handleObj;
     Tcl_IncrRefCount(handleObj);
-    rtPtr->timer  = (Tcl_TimerToken) NULL;
+    rtPtr->timer = NULL;
     rtPtr->mode = 0;
     rtPtr->readIsDrained = 0;
-    rtPtr->nonblocking =
-	(((Channel*) parentChan)->state->flags & CHANNEL_NONBLOCKING);
-    /* Query parent for current blocking mode. */
+    rtPtr->nonblocking = 
+	    (((Channel *) parentChan)->state->flags & CHANNEL_NONBLOCKING);
 
-    ResultInit (&rtPtr->result);
+    /*
+     * Query parent for current blocking mode.
+     */
+
+    ResultInit(&rtPtr->result);
 
     /*
      * Method placeholder.
@@ -1750,7 +1777,7 @@ NewReflectedTransform(
      */
 
     rtPtr->argc = listc + 2;
-    rtPtr->argv = (Tcl_Obj**) ckalloc(sizeof(Tcl_Obj*) * (listc+4));
+    rtPtr->argv = (Tcl_Obj **) ckalloc(sizeof(Tcl_Obj *) * (listc+4));
 
     /*
      * Duplicate object references.
@@ -1758,6 +1785,7 @@ NewReflectedTransform(
 
     for (i=0; i<listc ; i++) {
 	Tcl_Obj *word = rtPtr->argv[i] = listv[i];
+
 	Tcl_IncrRefCount(word);
     }
 
@@ -1828,8 +1856,8 @@ FreeReflectedTransform(
 {
     int i, n;
 
-    TimerKill   (rtPtr);
-    ResultClear (&rtPtr->result);
+    TimerKill(rtPtr);
+    ResultClear(&rtPtr->result);
 
     Tcl_DecrRefCount(rtPtr->handle);
     rtPtr->handle = NULL;
@@ -2039,7 +2067,8 @@ GetReflectedTransformMap(
     ReflectedTransformMap *rtmPtr = Tcl_GetAssocData(interp, RTMKEY, NULL);
 
     if (rtmPtr == NULL) {
-	rtmPtr = (ReflectedTransformMap *) ckalloc(sizeof(ReflectedTransformMap));
+	rtmPtr = (ReflectedTransformMap *)
+		ckalloc(sizeof(ReflectedTransformMap));
 	Tcl_InitHashTable(&rtmPtr->map, TCL_STRING_KEYS);
 	Tcl_SetAssocData(interp, RTMKEY,
 		(Tcl_InterpDeleteProc *) DeleteReflectedTransformMap, rtmPtr);
@@ -2076,7 +2105,6 @@ DeleteReflectedTransformMap(
     Tcl_HashSearch hSearch;	 /* Search variable. */
     Tcl_HashEntry *hPtr;	 /* Search variable. */
     ReflectedTransform *rtPtr;
-
 #ifdef TCL_THREADS
     ForwardingResult *resultPtr;
     ForwardingEvent *evPtr;
@@ -2099,7 +2127,7 @@ DeleteReflectedTransformMap(
     for (hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch);
 	    hPtr != NULL;
 	    hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch)) {
-	rtPtr = (ReflectedTransform *) Tcl_GetHashValue (hPtr);
+	rtPtr = Tcl_GetHashValue(hPtr);
 	rtPtr->interp = NULL;
 	Tcl_DeleteHashEntry(hPtr);
     }
@@ -2119,8 +2147,7 @@ DeleteReflectedTransformMap(
 
     Tcl_MutexLock(&rtForwardMutex);
 
-    for (resultPtr = forwardList;
-	    resultPtr != NULL;
+    for (resultPtr = forwardList; resultPtr != NULL;
 	    resultPtr = resultPtr->nextPtr) {
 	if (resultPtr->dsti != interp) {
 	    /*
@@ -2158,7 +2185,7 @@ DeleteReflectedTransformMap(
     for (hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch);
 	    hPtr != NULL;
 	    hPtr = Tcl_NextHashEntry(&hSearch)) {
-	rtPtr = (ReflectedTransform *) Tcl_GetHashValue (hPtr);
+	rtPtr = Tcl_GetHashValue(hPtr);
 
 	if (rtPtr->interp != interp) {
 	    /*
@@ -2250,8 +2277,7 @@ DeleteThreadReflectedTransformMap(
 
     Tcl_MutexLock(&rtForwardMutex);
 
-    for (resultPtr = forwardList;
-	    resultPtr != NULL;
+    for (resultPtr = forwardList; resultPtr != NULL;
 	    resultPtr = resultPtr->nextPtr) {
 	ForwardingEvent *evPtr;
 	ForwardParam *paramPtr;
@@ -2291,7 +2317,7 @@ DeleteThreadReflectedTransformMap(
     for (hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch);
 	    hPtr != NULL;
 	    hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch)) {
-	ReflectedTransform *rtPtr = (ReflectedTransform *) Tcl_GetHashValue(hPtr);
+	ReflectedTransform *rtPtr = Tcl_GetHashValue(hPtr);
 
 	rtPtr->interp = NULL;
 	Tcl_DeleteHashEntry(hPtr);
@@ -2304,7 +2330,7 @@ static void
 ForwardOpToOwnerThread(
     ReflectedTransform *rtPtr,	/* Channel instance */
     ForwardedOperation op,	/* Forwarded driver operation */
-    const VOID *param)		/* Arguments */
+    const void *param)		/* Arguments */
 {
     Tcl_ThreadId dst = rtPtr->thread;
     ForwardingEvent *evPtr;
@@ -2363,13 +2389,13 @@ ForwardOpToOwnerThread(
      * (see above) for.
      */
 
-    Tcl_CreateThreadExitHandler(SrcExitProc, (ClientData) evPtr);
+    Tcl_CreateThreadExitHandler(SrcExitProc, evPtr);
 
     /*
      * Queue the event and poke the other thread's notifier.
      */
 
-    Tcl_ThreadQueueEvent(dst, (Tcl_Event *)evPtr, TCL_QUEUE_TAIL);
+    Tcl_ThreadQueueEvent(dst, (Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
     Tcl_ThreadAlert(dst);
 
     /*
@@ -2411,7 +2437,7 @@ ForwardOpToOwnerThread(
      * notifier, after it serviced the event.
      */
 
-    Tcl_DeleteThreadExitHandler(SrcExitProc, (ClientData) evPtr);
+    Tcl_DeleteThreadExitHandler(SrcExitProc, evPtr);
 
     result = resultPtr->result;
     ckfree((char*) resultPtr);
@@ -2441,8 +2467,10 @@ ForwardProc(
     Tcl_Interp *interp = rtPtr->interp;
     ForwardParam *paramPtr = evPtr->param;
     Tcl_Obj *resObj = NULL;	/* Interp result of InvokeTclMethod */
-    ReflectedTransformMap* rtmPtr; /* Map of reflected channels with handlers in this interp */
-    Tcl_HashEntry* hPtr;         /* Entry in the above map */
+    ReflectedTransformMap *rtmPtr;
+				/* Map of reflected channels with handlers in
+				 * this interp. */
+    Tcl_HashEntry *hPtr;	/* Entry in the above map */
 
     /*
      * Ignore the event if no one is waiting for its result anymore.
@@ -2468,7 +2496,8 @@ ForwardProc(
 	 * No parameters/results.
 	 */
 
-	if (InvokeTclMethod(rtPtr, "finalize", NULL, NULL, &resObj) != TCL_OK) {
+	if (InvokeTclMethod(rtPtr, "finalize", NULL, NULL,
+		&resObj) != TCL_OK) {
 	    ForwardSetObjError(paramPtr, resObj);
 	}
 
@@ -2484,10 +2513,9 @@ ForwardProc(
 	 * dereferencing a dangling pointer.
 	 */
 
-	rtmPtr = GetReflectedTransformMap (interp);
-	hPtr = Tcl_FindHashEntry (&rtmPtr->map,
-				  Tcl_GetString(rtPtr->handle));
-	Tcl_DeleteHashEntry (hPtr);
+	rtmPtr = GetReflectedTransformMap(interp);
+	hPtr = Tcl_FindHashEntry(&rtmPtr->map, Tcl_GetString(rtPtr->handle));
+	Tcl_DeleteHashEntry(hPtr);
 
 	/*
 	 * In a threaded interpreter we manage a per-thread map as well, to
@@ -2496,15 +2524,14 @@ ForwardProc(
 	 */
 
         rtmPtr = GetThreadReflectedTransformMap();
-	hPtr = Tcl_FindHashEntry (&rtmPtr->map,
-				  Tcl_GetString(rtPtr->handle));
-	Tcl_DeleteHashEntry (hPtr);
+	hPtr = Tcl_FindHashEntry(&rtmPtr->map, Tcl_GetString(rtPtr->handle));
+	Tcl_DeleteHashEntry(hPtr);
 	FreeReflectedTransform(rtPtr);
 	break;
 
     case ForwardedInput: {
-	Tcl_Obj *bufObj = Tcl_NewByteArrayObj((unsigned char *) paramPtr->transform.buf,
-					      paramPtr->transform.size);
+	Tcl_Obj *bufObj = Tcl_NewByteArrayObj((unsigned char *)
+		paramPtr->transform.buf, paramPtr->transform.size);
 
 	if (InvokeTclMethod(rtPtr, "read", bufObj, NULL, &resObj) != TCL_OK) {
 	    ForwardSetObjError(paramPtr, resObj);
@@ -2516,14 +2543,15 @@ ForwardProc(
 	     */
 
 	    int bytec;		/* Number of returned bytes */
-	    unsigned char *bytev; /* Array of returned bytes */
+	    unsigned char *bytev;
+				/* Array of returned bytes */
 
 	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
 	    paramPtr->transform.size = bytec;
 
 	    if (bytec > 0) {
-		paramPtr->transform.buf = ckalloc (bytec);
+		paramPtr->transform.buf = ckalloc(bytec);
 		memcpy(paramPtr->transform.buf, bytev, (size_t)bytec);
 	    } else {
 		paramPtr->transform.buf = NULL;
@@ -2533,8 +2561,8 @@ ForwardProc(
     }
 
     case ForwardedOutput: {
-	Tcl_Obj *bufObj = Tcl_NewByteArrayObj((unsigned char *) paramPtr->transform.buf,
-					      paramPtr->transform.size);
+	Tcl_Obj *bufObj = Tcl_NewByteArrayObj((unsigned char *)
+		paramPtr->transform.buf, paramPtr->transform.size);
 
 	if (InvokeTclMethod(rtPtr, "write", bufObj, NULL, &resObj) != TCL_OK) {
 	    ForwardSetObjError(paramPtr, resObj);
@@ -2546,14 +2574,15 @@ ForwardProc(
 	     */
 
 	    int bytec;		/* Number of returned bytes */
-	    unsigned char *bytev; /* Array of returned bytes */
+	    unsigned char *bytev;
+				/* Array of returned bytes */
 
 	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
 	    paramPtr->transform.size = bytec;
 
 	    if (bytec > 0) {
-		paramPtr->transform.buf = ckalloc (bytec);
+		paramPtr->transform.buf = ckalloc(bytec);
 		memcpy(paramPtr->transform.buf, bytev, (size_t)bytec);
 	    } else {
 		paramPtr->transform.buf = NULL;
@@ -2580,7 +2609,7 @@ ForwardProc(
 	    paramPtr->transform.size = bytec;
 
 	    if (bytec > 0) {
-		paramPtr->transform.buf = ckalloc (bytec);
+		paramPtr->transform.buf = ckalloc(bytec);
 		memcpy(paramPtr->transform.buf, bytev, (size_t)bytec);
 	    } else {
 		paramPtr->transform.buf = NULL;
@@ -2600,14 +2629,15 @@ ForwardProc(
 	     */
 
 	    int bytec;		/* Number of returned bytes */
-	    unsigned char *bytev; /* Array of returned bytes */
+	    unsigned char *bytev;
+				/* Array of returned bytes */
 
 	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
 	    paramPtr->transform.size = bytec;
 
 	    if (bytec > 0) {
-		paramPtr->transform.buf = ckalloc (bytec);
+		paramPtr->transform.buf = ckalloc(bytec);
 		memcpy(paramPtr->transform.buf, bytev, (size_t)bytec);
 	    } else {
 		paramPtr->transform.buf = NULL;
@@ -2627,7 +2657,8 @@ ForwardProc(
 	if (InvokeTclMethod(rtPtr, "limit?", NULL, NULL, &resObj) != TCL_OK) {
 	    ForwardSetObjError(paramPtr, resObj);
 	    paramPtr->limit.max = -1;
-	} else if (Tcl_GetIntFromObj(interp, resObj, &paramPtr->limit.max) != TCL_OK) {
+	} else if (Tcl_GetIntFromObj(interp, resObj,
+		&paramPtr->limit.max) != TCL_OK) {
 	    ForwardSetObjError(paramPtr, MarshallError(interp));
 	    paramPtr->limit.max = -1;
 	}
@@ -2673,7 +2704,7 @@ static void
 SrcExitProc(
     ClientData clientData)
 {
-    ForwardingEvent *evPtr = (ForwardingEvent *) clientData;
+    ForwardingEvent *evPtr = clientData;
     ForwardingResult *resultPtr;
     ForwardParam *paramPtr;
 
@@ -2734,265 +2765,270 @@ ForwardSetObjError(
 /*
  *----------------------------------------------------------------------
  *
- *	TimerKill --
+ * TimerKill --
  *
- *	Timer management. Removes the internal timer
- *	if it exists.
+ *	Timer management. Removes the internal timer if it exists.
  *
- *	Sideeffects:
- *		See above.
+ * Side effects:
+ *	See above.
  *
- *	Result:
- *		None.
+ * Result:
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-TimerKill (ReflectedTransform* rtPtr)
+TimerKill(
+    ReflectedTransform *rtPtr)
 {
-    if (rtPtr->timer == (Tcl_TimerToken) NULL) return;
+    if (rtPtr->timer == NULL) {
+	return;
+    }
 
-    /* Delete an existing flush-out timer, prevent it from firing on a
+    /*
+     * Delete an existing flush-out timer, prevent it from firing on a
      * removed/dead channel.
      */
 
-    Tcl_DeleteTimerHandler (rtPtr->timer);
-    rtPtr->timer = (Tcl_TimerToken) NULL;
+    Tcl_DeleteTimerHandler(rtPtr->timer);
+    rtPtr->timer = NULL;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- *	TimerSetup --
+ * TimerSetup --
  *
- *	Timer management. Creates the internal timer
- *	if it does not exist.
+ *	Timer management. Creates the internal timer if it does not exist.
  *
- *	Sideeffects:
- *		See above.
+ * Side effects:
+ *	See above.
  *
- *	Result:
- *		None.
+ * Result:
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-TimerSetup (ReflectedTransform* rtPtr)
+TimerSetup(
+    ReflectedTransform *rtPtr)
 {
-    if (rtPtr->timer != (Tcl_TimerToken) NULL) return;
+    if (rtPtr->timer != NULL) {
+	return;
+    }
 
-    rtPtr->timer = Tcl_CreateTimerHandler (FLUSH_DELAY, TimerRun,
-					   (ClientData) rtPtr);
+    rtPtr->timer = Tcl_CreateTimerHandler(FLUSH_DELAY, TimerRun, rtPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
- *	TimerRun --
+ * TimerRun --
  *
- *	Called by the notifier (-> timer) to flush out
- *	information waiting in channel buffers.
+ *	Called by the notifier (-> timer) to flush out information waiting in
+ *	channel buffers.
  *
- *	Sideeffects:
- *		As of 'Tcl_NotifyChannel'.
+ * Side effects:
+ *	As of 'Tcl_NotifyChannel'.
  *
- *	Result:
- *		None.
+ * Result:
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-TimerRun (ClientData clientData)
+TimerRun(
+    ClientData clientData)
 {
-    ReflectedTransform* rtPtr = (ReflectedTransform*) clientData;
+    ReflectedTransform *rtPtr = clientData;
 
-    rtPtr->timer = (Tcl_TimerToken) NULL;
-    Tcl_NotifyChannel (rtPtr->chan, TCL_READABLE);
+    rtPtr->timer = NULL;
+    Tcl_NotifyChannel(rtPtr->chan, TCL_READABLE);
 }
 
-
 /*
  *----------------------------------------------------------------------
  *
- *	ResultInit --
+ * ResultInit --
  *
- *	Initializes the specified buffer structure. The
- *	structure will contain valid information for an
- *	emtpy buffer.
+ *	Initializes the specified buffer structure. The structure will contain
+ *	valid information for an emtpy buffer.
  *
- *	Sideeffects:
- *		See above.
+ * Side effects:
+ *	See above.
  *
- *	Result:
- *		None.
+ * Result:
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-ResultInit (ResultBuffer* r) /* Reference to the structure to initialize */
+ResultInit(
+    ResultBuffer *rPtr)		/* Reference to the structure to
+				 * initialize. */
 {
-    r->used      = 0;
-    r->allocated = 0;
-    r->buf       = NULL;
+    rPtr->used = 0;
+    rPtr->allocated = 0;
+    rPtr->buf = NULL;
 }
 /*
  *----------------------------------------------------------------------
  *
- *	ResultClear --
+ * ResultClear --
  *
  *	Deallocates any memory allocated by 'ResultAdd'.
  *
- *	Sideeffects:
- *		See above.
+ * Side effects:
+ *	See above.
  *
- *	Result:
- *		None.
+ * Result:
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-ResultClear (ResultBuffer* r) /* Reference to the buffer to clear out */
+ResultClear(
+    ResultBuffer *rPtr)		/* Reference to the buffer to clear out */
 {
-    r->used = 0;
+    rPtr->used = 0;
 
-    if (!r->allocated) return;
+    if (!rPtr->allocated) {
+	return;
+    }
 
-    Tcl_Free ((char*) r->buf);
-    r->buf       = NULL;
-    r->allocated = 0;
+    Tcl_Free((char *) rPtr->buf);
+    rPtr->buf = NULL;
+    rPtr->allocated = 0;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- *	ResultAdd --
+ * ResultAdd --
  *
- *	Adds the bytes in the specified array to the
- *	buffer, by appending it.
+ *	Adds the bytes in the specified array to the buffer, by appending it.
  *
- *	Sideeffects:
- *		See above.
+ * Side effects:
+ *	See above.
  *
- *	Result:
- *		None.
+ * Result:
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-ResultAdd (r, buf, toWrite)
-     ResultBuffer*  r;       /* The buffer to extend */
-     unsigned char* buf;     /* The buffer to read from */
-     int            toWrite; /* The number of bytes in 'buf' */
+ResultAdd(
+    ResultBuffer *rPtr,		/* The buffer to extend */
+    unsigned char *buf,		/* The buffer to read from */
+    int toWrite)		/* The number of bytes in 'buf' */
 {
-    if ((r->used + toWrite + 1) > r->allocated) {
-	/* Extension of the internal buffer is required.
+    if ((rPtr->used + toWrite + 1) > rPtr->allocated) {
+	/*
+	 * Extension of the internal buffer is required.
 	 * NOTE: Currently linear. Should be doubling to amortize.
 	 */
 
-	if (r->allocated == 0) {
-	    r->allocated = toWrite + RB_INCREMENT;
-	    r->buf       = UCHARP(Tcl_Alloc (r->allocated));
+	if (rPtr->allocated == 0) {
+	    rPtr->allocated = toWrite + RB_INCREMENT;
+	    rPtr->buf = UCHARP(Tcl_Alloc(rPtr->allocated));
 	} else {
-	    r->allocated += toWrite + RB_INCREMENT;
-	    r->buf        = UCHARP(Tcl_Realloc((char*) r->buf, r->allocated));
+	    rPtr->allocated += toWrite + RB_INCREMENT;
+	    rPtr->buf = UCHARP(Tcl_Realloc((char *) rPtr->buf,
+		    rPtr->allocated));
 	}
     }
 
-    /* now copy data */
-    memcpy (r->buf + r->used, buf, toWrite);
-    r->used += toWrite;
+    /*
+     * Now copy data.
+     */
+
+    memcpy(rPtr->buf + rPtr->used, buf, toWrite);
+    rPtr->used += toWrite;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- *	ResultCopy --
+ * ResultCopy --
  *
- *	Copies the requested number of bytes from the
- *	buffer into the specified array and removes them
- *	from the buffer afterward. Copies less if there
- *	is not enough data in the buffer.
+ *	Copies the requested number of bytes from the buffer into the
+ *	specified array and removes them from the buffer afterward. Copies
+ *	less if there is not enough data in the buffer.
  *
- *	Sideeffects:
- *		See above.
+ * Side effects:
+ *	See above.
  *
- *	Result:
- *		The number of actually copied bytes,
- *		possibly less than 'toRead'.
+ * Result:
+ *	The number of actually copied bytes, possibly less than 'toRead'.
  *
  *----------------------------------------------------------------------
  */
 
 static int
-ResultCopy (ResultBuffer*  r,      /* The buffer to read from */
-	    unsigned char* buf,    /* The buffer to copy into */
-	    int            toRead) /* Number of requested bytes */
+ResultCopy(
+    ResultBuffer *rPtr,		/* The buffer to read from */
+    unsigned char *buf,		/* The buffer to copy into */
+    int toRead)			/* Number of requested bytes */
 {
     int copied;
 
-    if (r->used == 0) {
-	/* Nothing to copy in the case of an empty buffer.
+    if (rPtr->used == 0) {
+	/*
+	 * Nothing to copy in the case of an empty buffer.
 	 */
 
 	copied = 0;
-	goto done;
-    }
+    } else if (rPtr->used == toRead) {
+	/*
+	 * We have just enough. Copy everything to the caller.
+	 */
 
-    if (r->used == toRead) {
-	/* We have just enough. Copy everything to the caller.
+	memcpy(buf, rPtr->buf, toRead);
+	rPtr->used = 0;
+	copied = toRead;
+    } else if (rPtr->used > toRead) {
+	/*
+	 * The internal buffer contains more than requested. Copy the
+	 * requested subset to the caller, and shift the remaining bytes down.
 	 */
 
-	memcpy ((VOID*) buf, (VOID*) r->buf, toRead);
-	r->used = 0;
-	copied  = toRead;
-	goto done;
-    }
+	memcpy(buf, rPtr->buf, toRead);
+	memmove(rPtr->buf, rPtr->buf + toRead, rPtr->used - toRead);
 
-    if (r->used > toRead) {
-	/* The internal buffer contains more than requested.
-	 * Copy the requested subset to the caller, and shift
-	 * the remaining bytes down.
+	rPtr->used -= toRead;
+	copied = toRead;
+    } else {
+	/*
+	 * There is not enough in the buffer to satisfy the caller, so take
+	 * everything.
 	 */
 
-	memcpy  ((VOID*) buf,    (VOID*) r->buf,            toRead);
-	memmove ((VOID*) r->buf, (VOID*) (r->buf + toRead), r->used - toRead);
-
-	r->used -= toRead;
-	copied   = toRead;
-	goto done;
+	memcpy(buf, rPtr->buf, rPtr->used);
+	toRead = rPtr->used;
+	rPtr->used = 0;
+	copied = toRead;
     }
 
-    /* There is not enough in the buffer to satisfy the caller, so
-     * take everything.
-     */
-
-    memcpy ((VOID*) buf, (VOID*) r->buf, r->used);
-    toRead  = r->used;
-    r->used = 0;
-    copied  = toRead;
-
     /* -- common postwork code ------- */
 
- done:
     return copied;
 }
 
-
 static int
-TransformRead (
-       ReflectedTransform* rtPtr,
-       int* errorCodePtr,
-       unsigned char* buf,
-       int toRead)
+TransformRead(
+    ReflectedTransform *rtPtr,
+    int *errorCodePtr,
+    unsigned char *buf,
+    int toRead)
 {
-    Tcl_Obj* bufObj;
-    Tcl_Obj* resObj;
+    Tcl_Obj *bufObj;
+    Tcl_Obj *resObj;
     int bytec;			/* Number of returned bytes */
     unsigned char *bytev;	/* Array of returned bytes */
 
@@ -3004,7 +3040,7 @@ TransformRead (
     if (rtPtr->thread != Tcl_GetCurrentThread()) {
 	ForwardParam p;
 
-	p.transform.buf  = (char*) buf;
+	p.transform.buf = (char *) buf;
 	p.transform.size = toRead;
 
 	ForwardOpToOwnerThread(rtPtr, ForwardedInput, &p);
@@ -3013,41 +3049,38 @@ TransformRead (
 	    PassReceivedError(rtPtr->chan, &p);
 	    *errorCodePtr = EINVAL;
 	    return 0;
-	} else {
-	    *errorCodePtr = EOK;
 	}
 
-	ResultAdd (&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
-	ckfree (p.transform.buf);
-    } else {
+	*errorCodePtr = EOK;
+	ResultAdd(&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
+	ckfree(p.transform.buf);
+	return 1;
+    }
 #endif
-	/* ASSERT: rtPtr->method & FLAG(METH_READ) */
-	/* ASSERT: rtPtr->mode & TCL_READABLE */
 
-	bufObj = Tcl_NewByteArrayObj((unsigned char *) buf, toRead);
-	if (InvokeTclMethod(rtPtr, "read", bufObj, NULL, &resObj) != TCL_OK) {
-	    Tcl_SetChannelError(rtPtr->chan, resObj);
-	    Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
-	    *errorCodePtr = EINVAL;
-	    return 0;
-	}
+    /* ASSERT: rtPtr->method & FLAG(METH_READ) */
+    /* ASSERT: rtPtr->mode & TCL_READABLE */
 
-	bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
-	ResultAdd (&rtPtr->result, bytev, bytec);
+    bufObj = Tcl_NewByteArrayObj((unsigned char *) buf, toRead);
+    if (InvokeTclMethod(rtPtr, "read", bufObj, NULL, &resObj) != TCL_OK) {
+	Tcl_SetChannelError(rtPtr->chan, resObj);
 	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
-#ifdef TCL_THREADS
+	*errorCodePtr = EINVAL;
+	return 0;
     }
-#endif
 
+    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
+    ResultAdd(&rtPtr->result, bytev, bytec);
+    Tcl_DecrRefCount(resObj);		/* Remove reference held from invoke */
     return 1;
 }
 
 static int
-TransformWrite (
-	ReflectedTransform* rtPtr,
-	int* errorCodePtr,
-	unsigned char* buf,
-	int toWrite)
+TransformWrite(
+    ReflectedTransform *rtPtr,
+    int *errorCodePtr,
+    unsigned char *buf,
+    int toWrite)
 {
     Tcl_Obj *bufObj;
     Tcl_Obj *resObj;
@@ -3063,7 +3096,7 @@ TransformWrite (
     if (rtPtr->thread != Tcl_GetCurrentThread()) {
 	ForwardParam p;
 
-	p.transform.buf  = (char*) buf;
+	p.transform.buf = (char *) buf;
 	p.transform.size = toWrite;
 
 	ForwardOpToOwnerThread(rtPtr, ForwardedOutput, &p);
@@ -3072,15 +3105,15 @@ TransformWrite (
 	    PassReceivedError(rtPtr->chan, &p);
 	    *errorCodePtr = EINVAL;
 	    return 0;
-	} else {
-	    *errorCodePtr = EOK;
 	}
 
-	res = Tcl_WriteRaw (rtPtr->parent,
-			    (char*) p.transform.buf, p.transform.size);
-	ckfree (p.transform.buf);
-    } else {
+	*errorCodePtr = EOK;
+	res = Tcl_WriteRaw(rtPtr->parent, (char *) p.transform.buf,
+		p.transform.size);
+	ckfree(p.transform.buf);
+    } else
 #endif
+    {
 	/* ASSERT: rtPtr->method & FLAG(METH_WRITE) */
 	/* ASSERT: rtPtr->mode & TCL_WRITABLE */
 
@@ -3095,11 +3128,9 @@ TransformWrite (
 	*errorCodePtr = EOK;
 
 	bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
-	res   = Tcl_WriteRaw (rtPtr->parent,  (char*) bytev, bytec);
-	Tcl_DecrRefCount(resObj);		/* Remove reference held from invoke */
-#ifdef TCL_THREADS
+	res = Tcl_WriteRaw(rtPtr->parent, (char *) bytev, bytec);
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
     }
-#endif
 
     if (res < 0) {
 	*errorCodePtr = EINVAL;
@@ -3109,14 +3140,12 @@ TransformWrite (
     return 1;
 }
 
-
-
 static int
 TransformDrain(
-      ReflectedTransform* rtPtr,
-      int* errorCodePtr)
+    ReflectedTransform *rtPtr,
+    int *errorCodePtr)
 {
-    Tcl_Obj* resObj;
+    Tcl_Obj *resObj;
     int bytec;			/* Number of returned bytes */
     unsigned char *bytev;	/* Array of returned bytes */
 
@@ -3134,14 +3163,14 @@ TransformDrain(
 	    PassReceivedError(rtPtr->chan, &p);
 	    *errorCodePtr = EINVAL;
 	    return 0;
-	} else {
-	    *errorCodePtr = EOK;
 	}
 
-	ResultAdd (&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
-	ckfree (p.transform.buf);
-    } else {
+	*errorCodePtr = EOK;
+	ResultAdd(&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
+	ckfree(p.transform.buf);
+    } else
 #endif
+    {
 	if (InvokeTclMethod(rtPtr, "drain", NULL, NULL, &resObj)!=TCL_OK) {
 	    Tcl_SetChannelError(rtPtr->chan, resObj);
 	    Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
@@ -3150,24 +3179,20 @@ TransformDrain(
 	}
 
 	bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
-	ResultAdd (&rtPtr->result, bytev, bytec);
+	ResultAdd(&rtPtr->result, bytev, bytec);
 
 	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
-
-#ifdef TCL_THREADS
     }
-#endif
 
     rtPtr->readIsDrained = 1;
     return 1;
 }
 
-
 static int
 TransformFlush(
-      ReflectedTransform* rtPtr,
-      int* errorCodePtr,
-      int  op)
+    ReflectedTransform *rtPtr,
+    int *errorCodePtr,
+    int op)
 {
     Tcl_Obj* resObj;
     int bytec;			/* Number of returned bytes */
@@ -3188,19 +3213,19 @@ TransformFlush(
 	    PassReceivedError(rtPtr->chan, &p);
 	    *errorCodePtr = EINVAL;
 	    return 0;
-	} else {
-	    *errorCodePtr = EOK;
 	}
 
+	*errorCodePtr = EOK;
 	if (op == FLUSH_WRITE) {
-	    res = Tcl_WriteRaw (rtPtr->parent,
-				(char*) p.transform.buf, p.transform.size);
+	    res = Tcl_WriteRaw(rtPtr->parent, (char *) p.transform.buf,
+		    p.transform.size);
 	} else {
 	    res = 0;
 	}
 	ckfree(p.transform.buf);
-    } else {
+    } else
 #endif
+    {
 	if (InvokeTclMethod(rtPtr, "flush", NULL, NULL, &resObj)!=TCL_OK) {
 	    Tcl_SetChannelError(rtPtr->chan, resObj);
 	    Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
@@ -3210,15 +3235,13 @@ TransformFlush(
 
 	if (op == FLUSH_WRITE) {
 	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
-	    res   = Tcl_WriteRaw (rtPtr->parent,  (char*) bytev, bytec);
+	    res = Tcl_WriteRaw(rtPtr->parent, (char *) bytev, bytec);
 	} else {
 	    res = 0;
 	}
 	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
-
-#ifdef TCL_THREADS
     }
-#endif
+
     if (res < 0) {
 	*errorCodePtr = EINVAL;
 	return 0;
@@ -3228,8 +3251,8 @@ TransformFlush(
 }
 
 static void
-TransformClear (
-	ReflectedTransform* rtPtr)
+TransformClear(
+    ReflectedTransform *rtPtr)
 {
     /*
      * Are we in the correct thread?
@@ -3241,28 +3264,25 @@ TransformClear (
 
 	ForwardOpToOwnerThread(rtPtr, ForwardedClear, &p);
 	return;
-    } else {
+    }
 #endif
-	/* ASSERT: rtPtr->method & FLAG(METH_READ) */
-	/* ASSERT: rtPtr->mode & TCL_READABLE */
 
-	(void) InvokeTclMethod(rtPtr, "clear", NULL, NULL, NULL);
+    /* ASSERT: rtPtr->method & FLAG(METH_READ) */
+    /* ASSERT: rtPtr->mode & TCL_READABLE */
 
-#ifdef TCL_THREADS
-    }
-#endif
+    (void) InvokeTclMethod(rtPtr, "clear", NULL, NULL, NULL);
 
     rtPtr->readIsDrained = 0;
-    ResultClear (&rtPtr->result);
+    ResultClear(&rtPtr->result);
 }
 
 static int
-TransformLimit (
-	ReflectedTransform* rtPtr,
-	int* errorCodePtr,
-	int* maxPtr)
+TransformLimit(
+    ReflectedTransform *rtPtr,
+    int *errorCodePtr,
+    int *maxPtr)
 {
-    Tcl_Obj* resObj;
+    Tcl_Obj *resObj;
     Tcl_InterpState sr;		/* State of handler interp */
 
     /*
@@ -3279,11 +3299,11 @@ TransformLimit (
 	    PassReceivedError(rtPtr->chan, &p);
 	    *errorCodePtr = EINVAL;
 	    return 0;
-	} else {
-	    *errorCodePtr = EOK;
-	    *maxPtr = p.limit.max;
-	    return 1;
 	}
+
+	*errorCodePtr = EOK;
+	*maxPtr = p.limit.max;
+	return 1;
     }
 #endif
 
@@ -3337,7 +3357,7 @@ HaveVersion(
 {
     Tcl_ChannelTypeVersion actualVersion = Tcl_ChannelVersion(chanTypePtr);
 
-    return (PTR2INT(actualVersion)) >= (PTR2INT(minimumVersion));
+    return PTR2INT(actualVersion) >= PTR2INT(minimumVersion);
 }
 
 /*
diff --git a/generic/tclNamesp.c b/generic/tclNamesp.c
index 5ce7858..6485831 100644
--- a/generic/tclNamesp.c
+++ b/generic/tclNamesp.c
@@ -23,7 +23,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclNamesp.c,v 1.179 2008/10/15 06:17:04 nijtmans Exp $
+ * RCS: @(#) $Id: tclNamesp.c,v 1.180 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -1182,7 +1182,7 @@ TclTeardownNamespace(
      */
 
     if (nsPtr->deleteProc != NULL) {
-	(*nsPtr->deleteProc)(nsPtr->clientData);
+	nsPtr->deleteProc(nsPtr->clientData);
     }
     nsPtr->deleteProc = NULL;
     nsPtr->clientData = NULL;
@@ -2425,7 +2425,7 @@ Tcl_FindCommand(
 	Tcl_Command cmd;
 
 	if (cxtNsPtr->cmdResProc) {
-	    result = (*cxtNsPtr->cmdResProc)(interp, name,
+	    result = cxtNsPtr->cmdResProc(interp, name,
 		    (Tcl_Namespace *) cxtNsPtr, flags, &cmd);
 	} else {
 	    result = TCL_CONTINUE;
@@ -2433,7 +2433,7 @@ Tcl_FindCommand(
 
 	while (result == TCL_CONTINUE && resPtr) {
 	    if (resPtr->cmdResProc) {
-		result = (*resPtr->cmdResProc)(interp, name,
+		result = resPtr->cmdResProc(interp, name,
 			(Tcl_Namespace *) cxtNsPtr, flags, &cmd);
 	    }
 	    resPtr = resPtr->nextPtr;
diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index e6c4d40..53ef23e 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -14,7 +14,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclNotify.c,v 1.28 2008/07/24 21:54:38 nijtmans Exp $
+ * RCS: @(#) $Id: tclNotify.c,v 1.29 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -535,7 +535,7 @@ Tcl_DeleteEvents(
     prevPtr = NULL;
     evPtr = tsdPtr->firstEventPtr;
     while (evPtr != NULL) {
-	if ((*proc)(evPtr, clientData) == 1) {
+	if (proc(evPtr, clientData) == 1) {
 	    /*
 	     * This event should be deleted. Unlink it.
 	     */
@@ -667,7 +667,7 @@ Tcl_ServiceEvent(
 	 */
 
 	Tcl_MutexUnlock(&(tsdPtr->queueMutex));
-	result = (*proc)(evPtr, flags);
+	result = proc(evPtr, flags);
 	Tcl_MutexLock(&(tsdPtr->queueMutex));
 
 	if (result) {
@@ -931,7 +931,7 @@ Tcl_DoOneEvent(
 	for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
 		sourcePtr = sourcePtr->nextPtr) {
 	    if (sourcePtr->setupProc) {
-		(sourcePtr->setupProc)(sourcePtr->clientData, flags);
+		sourcePtr->setupProc(sourcePtr->clientData, flags);
 	    }
 	}
 	tsdPtr->inTraversal = 0;
@@ -960,7 +960,7 @@ Tcl_DoOneEvent(
 	for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
 		sourcePtr = sourcePtr->nextPtr) {
 	    if (sourcePtr->checkProc) {
-		(sourcePtr->checkProc)(sourcePtr->clientData, flags);
+		sourcePtr->checkProc(sourcePtr->clientData, flags);
 	    }
 	}
 
@@ -1070,13 +1070,13 @@ Tcl_ServiceAll(void)
     for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
 	    sourcePtr = sourcePtr->nextPtr) {
 	if (sourcePtr->setupProc) {
-	    (sourcePtr->setupProc)(sourcePtr->clientData, TCL_ALL_EVENTS);
+	    sourcePtr->setupProc(sourcePtr->clientData, TCL_ALL_EVENTS);
 	}
     }
     for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
 	    sourcePtr = sourcePtr->nextPtr) {
 	if (sourcePtr->checkProc) {
-	    (sourcePtr->checkProc)(sourcePtr->clientData, TCL_ALL_EVENTS);
+	    sourcePtr->checkProc(sourcePtr->clientData, TCL_ALL_EVENTS);
 	}
     }
 
diff --git a/generic/tclObj.c b/generic/tclObj.c
index c5fef11..ae3f909 100644
--- a/generic/tclObj.c
+++ b/generic/tclObj.c
@@ -13,7 +13,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclObj.c,v 1.144 2008/10/16 22:34:19 nijtmans Exp $
+ * RCS: @(#) $Id: tclObj.c,v 1.145 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -1024,7 +1024,7 @@ Tcl_DuplicateObj(
 	    dupPtr->internalRep = objPtr->internalRep;
 	    dupPtr->typePtr = typePtr;
 	} else {
-	    (*typePtr->dupIntRepProc)(objPtr, dupPtr);
+	    typePtr->dupIntRepProc(objPtr, dupPtr);
 	}
     }
     return dupPtr;
@@ -1064,7 +1064,7 @@ Tcl_GetString(
 	Tcl_Panic("UpdateStringProc should not be invoked for type %s",
 		objPtr->typePtr->name);
     }
-    (*objPtr->typePtr->updateStringProc)(objPtr);
+    objPtr->typePtr->updateStringProc(objPtr);
     return objPtr->bytes;
 }
 
@@ -1104,7 +1104,7 @@ Tcl_GetStringFromObj(
 	    Tcl_Panic("UpdateStringProc should not be invoked for type %s",
 		    objPtr->typePtr->name);
 	}
-	(*objPtr->typePtr->updateStringProc)(objPtr);
+	objPtr->typePtr->updateStringProc(objPtr);
     }
 
     if (lengthPtr != NULL) {
@@ -2206,7 +2206,7 @@ Tcl_GetLongFromObj(
 	    mp_int big;
 
 	    UNPACK_BIGNUM(objPtr, big);
-	    if ((size_t)(big.used) <= (CHAR_BIT * sizeof(long) + DIGIT_BIT - 1)
+	    if ((size_t) big.used <= (CHAR_BIT * sizeof(long) + DIGIT_BIT - 1)
 		    / DIGIT_BIT) {
 		unsigned long value = 0, numBytes = sizeof(long);
 		long scratch;
@@ -2506,7 +2506,7 @@ Tcl_GetWideIntFromObj(
 	    mp_int big;
 
 	    UNPACK_BIGNUM(objPtr, big);
-	    if ((size_t)(big.used) <= (CHAR_BIT * sizeof(Tcl_WideInt)
+	    if ((size_t) big.used <= (CHAR_BIT * sizeof(Tcl_WideInt)
 		     + DIGIT_BIT - 1) / DIGIT_BIT) {
 		Tcl_WideUInt value = 0;
 		unsigned long numBytes = sizeof(Tcl_WideInt);
@@ -2587,7 +2587,7 @@ FreeBignum(
 
     UNPACK_BIGNUM(objPtr, toFree);
     mp_clear(&toFree);
-    if ((long)(objPtr->internalRep.ptrAndLongRep.value) < 0) {
+    if ((long) objPtr->internalRep.ptrAndLongRep.value < 0) {
 	ckfree((char *) objPtr->internalRep.ptrAndLongRep.ptr);
     }
 }
@@ -2927,11 +2927,12 @@ Tcl_SetBignumObj(
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetBignumObj");
     }
-    if ((size_t)(bignumValue->used)
+    if ((size_t) bignumValue->used
 	    <= (CHAR_BIT * sizeof(long) + DIGIT_BIT - 1) / DIGIT_BIT) {
 	unsigned long value = 0, numBytes = sizeof(long);
 	long scratch;
-	unsigned char *bytes = (unsigned char *)&scratch;
+	unsigned char *bytes = (unsigned char *) &scratch;
+
 	if (mp_to_unsigned_bin_n(bignumValue, bytes, &numBytes) != MP_OKAY) {
 	    goto tooLargeForLong;
 	}
@@ -2951,12 +2952,13 @@ Tcl_SetBignumObj(
     }
   tooLargeForLong:
 #ifndef NO_WIDE_TYPE
-    if ((size_t)(bignumValue->used)
+    if ((size_t) bignumValue->used
 	    <= (CHAR_BIT * sizeof(Tcl_WideInt) + DIGIT_BIT - 1) / DIGIT_BIT) {
 	Tcl_WideUInt value = 0;
 	unsigned long numBytes = sizeof(Tcl_WideInt);
 	Tcl_WideInt scratch;
 	unsigned char *bytes = (unsigned char *)&scratch;
+
 	if (mp_to_unsigned_bin_n(bignumValue, bytes, &numBytes) != MP_OKAY) {
 	    goto tooLargeForWide;
 	}
diff --git a/generic/tclPanic.c b/generic/tclPanic.c
index dec5ed4..0a63076 100644
--- a/generic/tclPanic.c
+++ b/generic/tclPanic.c
@@ -12,7 +12,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclPanic.c,v 1.11 2008/04/27 22:21:31 dkf Exp $
+ * RCS: @(#) $Id: tclPanic.c,v 1.12 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -90,9 +90,9 @@ Tcl_PanicVA(
     arg8 = va_arg(argList, char *);
 
     if (panicProc != NULL) {
-	(*panicProc)(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+	panicProc(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
     } else if (platformPanicProc != NULL) {
-	(*platformPanicProc)(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7,
+	platformPanicProc(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7,
 		arg8);
     } else {
 	fprintf(stderr, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7,
diff --git a/generic/tclParse.c b/generic/tclParse.c
index 787b556..c730eaa 100644
--- a/generic/tclParse.c
+++ b/generic/tclParse.c
@@ -12,7 +12,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclParse.c,v 1.72 2008/09/17 02:15:32 mistachkin Exp $
+ * RCS: @(#) $Id: tclParse.c,v 1.73 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -878,21 +878,21 @@ TclParseBackslash(
 	 */
 
 	if (isdigit(UCHAR(*p)) && (UCHAR(*p) < '8')) {	/* INTL: digit */
-	    result = (unsigned char)(*p - '0');
+	    result = UCHAR(*p - '0');
 	    p++;
 	    if ((numBytes == 2) || !isdigit(UCHAR(*p))	/* INTL: digit */
 		    || (UCHAR(*p) >= '8')) {
 		break;
 	    }
 	    count = 3;
-	    result = (unsigned char)((result << 3) + (*p - '0'));
+	    result = UCHAR((result << 3) + (*p - '0'));
 	    p++;
 	    if ((numBytes == 3) || !isdigit(UCHAR(*p))	/* INTL: digit */
 		    || (UCHAR(*p) >= '8')) {
 		break;
 	    }
 	    count = 4;
-	    result = (unsigned char)((result << 3) + (*p - '0'));
+	    result = UCHAR((result << 3) + (*p - '0'));
 	    break;
 	}
 
diff --git a/generic/tclPathObj.c b/generic/tclPathObj.c
index 3839429..436eea4 100644
--- a/generic/tclPathObj.c
+++ b/generic/tclPathObj.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: tclPathObj.c,v 1.74 2008/10/16 22:34:19 nijtmans Exp $
+ * RCS: @(#) $Id: tclPathObj.c,v 1.75 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -1047,7 +1047,7 @@ Tcl_FSJoinPath(
 	    int needsSep = 0;
 
 	    if (fsPtr->filesystemSeparatorProc != NULL) {
-		Tcl_Obj *sep = (*fsPtr->filesystemSeparatorProc)(res);
+		Tcl_Obj *sep = fsPtr->filesystemSeparatorProc(res);
 
 		if (sep != NULL) {
 		    separator = TclGetString(sep)[0];
@@ -1961,7 +1961,7 @@ Tcl_FSGetNormalizedPath(
 		(fsPathPtr->nativePathPtr == NULL ? &clientData : NULL));
 	if (0 && (clientData != NULL)) {
 	    fsPathPtr->nativePathPtr =
-		(*fsPathPtr->fsRecPtr->fsPtr->dupInternalRepProc)(clientData);
+		fsPathPtr->fsRecPtr->fsPtr->dupInternalRepProc(clientData);
 	}
 
 	/*
@@ -2099,7 +2099,7 @@ Tcl_FSGetInternalRep(
 	    return NULL;
 	}
 
-	nativePathPtr = (*proc)(pathPtr);
+	nativePathPtr = proc(pathPtr);
 	srcFsPathPtr = PATHOBJ(pathPtr);
 	srcFsPathPtr->nativePathPtr = nativePathPtr;
     }
@@ -2512,8 +2512,9 @@ FreeFsPathInternalRep(
     if (fsPathPtr->nativePathPtr != NULL && fsPathPtr->fsRecPtr != NULL) {
 	Tcl_FSFreeInternalRepProc *freeProc =
 		fsPathPtr->fsRecPtr->fsPtr->freeInternalRepProc;
+
 	if (freeProc != NULL) {
-	    (*freeProc)(fsPathPtr->nativePathPtr);
+	    freeProc(fsPathPtr->nativePathPtr);
 	    fsPathPtr->nativePathPtr = NULL;
 	}
     }
@@ -2572,9 +2573,10 @@ DupFsPathInternalRep(
 	    && srcFsPathPtr->nativePathPtr != NULL) {
 	Tcl_FSDupInternalRepProc *dupProc =
 		srcFsPathPtr->fsRecPtr->fsPtr->dupInternalRepProc;
+
 	if (dupProc != NULL) {
 	    copyFsPathPtr->nativePathPtr =
-		    (*dupProc)(srcFsPathPtr->nativePathPtr);
+		    dupProc(srcFsPathPtr->nativePathPtr);
 	} else {
 	    copyFsPathPtr->nativePathPtr = NULL;
 	}
diff --git a/generic/tclPreserve.c b/generic/tclPreserve.c
index 3c991ea..9cc79a5 100644
--- a/generic/tclPreserve.c
+++ b/generic/tclPreserve.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: tclPreserve.c,v 1.10 2007/03/21 18:02:51 dgp Exp $
+ * RCS: @(#) $Id: tclPreserve.c,v 1.11 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -229,7 +229,7 @@ Tcl_Release(
 	    if (freeProc == TCL_DYNAMIC) {
 		ckfree((char *) clientData);
 	    } else {
-		(*freeProc)((char *) clientData);
+		freeProc((char *) clientData);
 	    }
 	}
 	return;
@@ -297,7 +297,7 @@ Tcl_EventuallyFree(
     if (freeProc == TCL_DYNAMIC) {
 	ckfree((char *) clientData);
     } else {
-	(*freeProc)((char *)clientData);
+	freeProc((char *)clientData);
     }
 }
 
diff --git a/generic/tclResult.c b/generic/tclResult.c
index b0a8836..40f0cba 100644
--- a/generic/tclResult.c
+++ b/generic/tclResult.c
@@ -8,7 +8,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclResult.c,v 1.50 2008/10/16 22:34:19 nijtmans Exp $
+ * RCS: @(#) $Id: tclResult.c,v 1.51 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -368,7 +368,7 @@ Tcl_DiscardResult(
 	if (statePtr->freeProc == TCL_DYNAMIC) {
 	    ckfree(statePtr->result);
 	} else {
-	    (*statePtr->freeProc)(statePtr->result);
+	    statePtr->freeProc(statePtr->result);
 	}
     }
 }
@@ -434,7 +434,7 @@ Tcl_SetResult(
 	if (oldFreeProc == TCL_DYNAMIC) {
 	    ckfree(oldResult);
 	} else {
-	    (*oldFreeProc)(oldResult);
+	    oldFreeProc(oldResult);
 	}
     }
 
@@ -526,7 +526,7 @@ Tcl_SetObjResult(
 	if (iPtr->freeProc == TCL_DYNAMIC) {
 	    ckfree(iPtr->result);
 	} else {
-	    (*iPtr->freeProc)(iPtr->result);
+	    iPtr->freeProc(iPtr->result);
 	}
 	iPtr->freeProc = 0;
     }
@@ -579,7 +579,7 @@ Tcl_GetObjResult(
 	    if (iPtr->freeProc == TCL_DYNAMIC) {
 		ckfree(iPtr->result);
 	    } else {
-		(*iPtr->freeProc)(iPtr->result);
+		iPtr->freeProc(iPtr->result);
 	    }
 	    iPtr->freeProc = 0;
 	}
@@ -861,7 +861,7 @@ Tcl_FreeResult(
 	if (iPtr->freeProc == TCL_DYNAMIC) {
 	    ckfree(iPtr->result);
 	} else {
-	    (*iPtr->freeProc)(iPtr->result);
+	    iPtr->freeProc(iPtr->result);
 	}
 	iPtr->freeProc = 0;
     }
@@ -899,7 +899,7 @@ Tcl_ResetResult(
 	if (iPtr->freeProc == TCL_DYNAMIC) {
 	    ckfree(iPtr->result);
 	} else {
-	    (*iPtr->freeProc)(iPtr->result);
+	    iPtr->freeProc(iPtr->result);
 	}
 	iPtr->freeProc = 0;
     }
diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c
index b017347..6d5f96a 100644
--- a/generic/tclStringObj.c
+++ b/generic/tclStringObj.c
@@ -33,7 +33,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclStringObj.c,v 1.73 2008/10/16 22:34:19 nijtmans Exp $ */
+ * RCS: @(#) $Id: tclStringObj.c,v 1.74 2008/10/26 18:34:04 dkf Exp $ */
 
 #include "tclInt.h"
 #include "tommath.h"
@@ -883,13 +883,12 @@ Tcl_AttemptSetObjLength(
 	 */
 
 	if (objPtr->bytes != tclEmptyStringRep) {
-	    newBytes = attemptckrealloc(objPtr->bytes,
-		    (unsigned)(length + 1));
+	    newBytes = attemptckrealloc(objPtr->bytes, (unsigned) length+1);
 	    if (newBytes == NULL) {
 		return 0;
 	    }
 	} else {
-	    newBytes = attemptckalloc((unsigned) (length + 1));
+	    newBytes = attemptckalloc((unsigned) length+1);
 	    if (newBytes == NULL) {
 		return 0;
 	    }
@@ -2027,7 +2026,7 @@ Tcl_AppendFormatToObj(
 		const char *bytes;
 
 		if (useShort) {
-		    pure = Tcl_NewIntObj((int)(s));
+		    pure = Tcl_NewIntObj((int) s);
 		} else if (useWide) {
 		    pure = Tcl_NewWideIntObj(w);
 		} else if (useBig) {
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index 1e1fd73..e254830 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.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: tclTimer.c,v 1.35 2008/10/16 22:34:19 nijtmans Exp $
+ * RCS: @(#) $Id: tclTimer.c,v 1.36 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -584,8 +584,8 @@ TimerHandlerEventProc(
 	 * potential reentrancy problems.
 	 */
 
-	(*nextPtrPtr) = timerHandlerPtr->nextPtr;
-	(*timerHandlerPtr->proc)(timerHandlerPtr->clientData);
+	*nextPtrPtr = timerHandlerPtr->nextPtr;
+	timerHandlerPtr->proc(timerHandlerPtr->clientData);
 	ckfree((char *) timerHandlerPtr);
     }
     TimerSetupProc(NULL, TCL_TIMER_EVENTS);
@@ -743,7 +743,7 @@ TclServiceIdle(void)
 	if (tsdPtr->idleList == NULL) {
 	    tsdPtr->lastIdlePtr = NULL;
 	}
-	(*idlePtr->proc)(idlePtr->clientData);
+	idlePtr->proc(idlePtr->clientData);
 	ckfree((char *) idlePtr);
     }
     if (tsdPtr->idleList) {
diff --git a/generic/tclTrace.c b/generic/tclTrace.c
index 7876eab..e411488 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.53 2008/10/16 22:34:19 nijtmans Exp $
+ * RCS: @(#) $Id: tclTrace.c,v 1.54 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -238,7 +238,7 @@ Tcl_TraceObjCmd(
 		0, &typeIndex) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	return (traceSubCmds[typeIndex])(interp, optionIndex, objc, objv);
+	return traceSubCmds[typeIndex](interp, optionIndex, objc, objv);
     }
     case TRACE_INFO: {
 	/*
@@ -261,7 +261,7 @@ Tcl_TraceObjCmd(
 		0, &typeIndex) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	return (traceSubCmds[typeIndex])(interp, optionIndex, objc, objv);
+	return traceSubCmds[typeIndex](interp, optionIndex, objc, objv);
 	break;
     }
 
@@ -305,9 +305,9 @@ Tcl_TraceObjCmd(
 	memcpy(copyObjv+1, objv, objc*sizeof(Tcl_Obj *));
 	copyObjv[4] = opsList;
 	if (optionIndex == TRACE_OLD_VARIABLE) {
-	    code = (traceSubCmds[2])(interp, TRACE_ADD, objc+1, copyObjv);
+	    code = traceSubCmds[2](interp, TRACE_ADD, objc+1, copyObjv);
 	} else {
-	    code = (traceSubCmds[2])(interp, TRACE_REMOVE, objc+1, copyObjv);
+	    code = traceSubCmds[2](interp, TRACE_REMOVE, objc+1, copyObjv);
 	}
 	Tcl_DecrRefCount(opsList);
 	return code;
@@ -1580,9 +1580,9 @@ TclCheckInterpTraces(
 			tcmdPtr->curFlags = traceFlags;
 			tcmdPtr->curCode = code;
 		    }
-		    traceCode = (tracePtr->proc)(tracePtr->clientData,
-			    interp, curLevel, command, (Tcl_Command) cmdPtr,
-			    objc, objv);
+		    traceCode = tracePtr->proc(tracePtr->clientData, interp,
+			    curLevel, command, (Tcl_Command) cmdPtr, objc,
+			    objv);
 		}
 	    } else {
 		/*
@@ -2365,7 +2365,7 @@ Tcl_DeleteTrace(
      */
 
     if (tracePtr->delProc != NULL) {
-	(tracePtr->delProc)(tracePtr->clientData);
+	tracePtr->delProc(tracePtr->clientData);
     }
 
     /*
diff --git a/generic/tclUtil.c b/generic/tclUtil.c
index 27a9248..3b8ddf5 100644
--- a/generic/tclUtil.c
+++ b/generic/tclUtil.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: tclUtil.c,v 1.106 2008/10/15 06:17:04 nijtmans Exp $
+ * RCS: @(#) $Id: tclUtil.c,v 1.107 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -2129,9 +2129,9 @@ Tcl_DStringGetResult(
 	    dsPtr->string = iPtr->result;
 	    dsPtr->spaceAvl = dsPtr->length+1;
 	} else {
-	    dsPtr->string = (char *) ckalloc((unsigned) (dsPtr->length+1));
+	    dsPtr->string = (char *) ckalloc((unsigned) dsPtr->length+1);
 	    memcpy(dsPtr->string, iPtr->result, (unsigned) dsPtr->length+1);
-	    (*iPtr->freeProc)(iPtr->result);
+	    iPtr->freeProc(iPtr->result);
 	}
 	dsPtr->spaceAvl = dsPtr->length+1;
 	iPtr->freeProc = NULL;
@@ -2140,7 +2140,7 @@ Tcl_DStringGetResult(
 	    dsPtr->string = dsPtr->staticSpace;
 	    dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
 	} else {
-	    dsPtr->string = (char *) ckalloc((unsigned) (dsPtr->length + 1));
+	    dsPtr->string = (char *) ckalloc((unsigned) dsPtr->length+1);
 	    dsPtr->spaceAvl = dsPtr->length + 1;
 	}
 	memcpy(dsPtr->string, iPtr->result, (unsigned) dsPtr->length+1);
@@ -3052,7 +3052,7 @@ TclGetProcessGlobalValue(
 	    Tcl_DStringLength(&native), &newValue);
 	    Tcl_DStringFree(&native);
 	    ckfree(pgvPtr->value);
-	    pgvPtr->value = ckalloc((unsigned int)
+	    pgvPtr->value = ckalloc((unsigned)
 		    Tcl_DStringLength(&newValue) + 1);
 	    memcpy(pgvPtr->value, Tcl_DStringValue(&newValue),
 		    (size_t) Tcl_DStringLength(&newValue) + 1);
@@ -3085,12 +3085,11 @@ TclGetProcessGlobalValue(
 	Tcl_MutexLock(&pgvPtr->mutex);
 	if ((NULL == pgvPtr->value) && (pgvPtr->proc)) {
 	    pgvPtr->epoch++;
-	    (*(pgvPtr->proc))(&pgvPtr->value, &pgvPtr->numBytes,
-		    &pgvPtr->encoding);
+	    pgvPtr->proc(&pgvPtr->value,&pgvPtr->numBytes,&pgvPtr->encoding);
 	    if (pgvPtr->value == NULL) {
 		Tcl_Panic("PGV Initializer did not initialize");
 	    }
-	    Tcl_CreateExitHandler(FreeProcessGlobalValue, (ClientData)pgvPtr);
+	    Tcl_CreateExitHandler(FreeProcessGlobalValue, pgvPtr);
 	}
 
 	/*
@@ -3101,10 +3100,10 @@ TclGetProcessGlobalValue(
 	hPtr = Tcl_CreateHashEntry(cacheMap,
 		(char *) INT2PTR(pgvPtr->epoch), &dummy);
 	Tcl_MutexUnlock(&pgvPtr->mutex);
-	Tcl_SetHashValue(hPtr, (ClientData) value);
+	Tcl_SetHashValue(hPtr, value);
 	Tcl_IncrRefCount(value);
     }
-    return (Tcl_Obj *) Tcl_GetHashValue(hPtr);
+    return Tcl_GetHashValue(hPtr);
 }
 
 /*
diff --git a/generic/tclVar.c b/generic/tclVar.c
index a68c5d2..dc35f69 100644
--- a/generic/tclVar.c
+++ b/generic/tclVar.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: tclVar.c,v 1.170 2008/10/15 06:17:03 nijtmans Exp $
+ * RCS: @(#) $Id: tclVar.c,v 1.171 2008/10/26 18:34:04 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -894,7 +894,7 @@ TclLookupSimpleVar(
 	    && !(flags & AVOID_RESOLVERS)) {
 	resPtr = iPtr->resolverPtr;
 	if (cxtNsPtr->varResProc) {
-	    result = (*cxtNsPtr->varResProc)(interp, varName,
+	    result = cxtNsPtr->varResProc(interp, varName,
 		    (Tcl_Namespace *) cxtNsPtr, flags, &var);
 	} else {
 	    result = TCL_CONTINUE;
@@ -902,7 +902,7 @@ TclLookupSimpleVar(
 
 	while (result == TCL_CONTINUE && resPtr) {
 	    if (resPtr->varResProc) {
-		result = (*resPtr->varResProc)(interp, varName,
+		result = resPtr->varResProc(interp, varName,
 			(Tcl_Namespace *) cxtNsPtr, flags, &var);
 	    }
 	    resPtr = resPtr->nextPtr;
@@ -4941,7 +4941,7 @@ ObjFindNamespaceVar(
 	resPtr = iPtr->resolverPtr;
 
 	if (cxtNsPtr->varResProc) {
-	    result = (*cxtNsPtr->varResProc)(interp, name,
+	    result = cxtNsPtr->varResProc(interp, name,
 		    (Tcl_Namespace *) cxtNsPtr, flags, &var);
 	} else {
 	    result = TCL_CONTINUE;
@@ -4949,7 +4949,7 @@ ObjFindNamespaceVar(
 
 	while (result == TCL_CONTINUE && resPtr) {
 	    if (resPtr->varResProc) {
-		result = (*resPtr->varResProc)(interp, name,
+		result = resPtr->varResProc(interp, name,
 			(Tcl_Namespace *) cxtNsPtr, flags, &var);
 	    }
 	    resPtr = resPtr->nextPtr;