Code style cleanup

2 files changed, 619 insertions, 575 deletions

diff --git a/generic/tclCompile.h b/generic/tclCompile.h
index 5bbbb8f..18d5ed7 100644
--- a/generic/tclCompile.h
+++ b/generic/tclCompile.h
@@ -89,20 +89,20 @@ typedef enum {
 
 typedef struct {
     ExceptionRangeType type;	/* The kind of ExceptionRange. */
-    Tcl_Size nestingLevel;		/* Static depth of the exception range. Used
+    Tcl_Size nestingLevel;	/* Static depth of the exception range. Used
 				 * to find the most deeply-nested range
 				 * surrounding a PC at runtime. */
-    Tcl_Size codeOffset;		/* Offset of the first instruction byte of the
+    Tcl_Size codeOffset;	/* Offset of the first instruction byte of the
 				 * code range. */
-    Tcl_Size numCodeBytes;		/* Number of bytes in the code range. */
-    Tcl_Size breakOffset;		/* If LOOP_EXCEPTION_RANGE, the target PC
+    Tcl_Size numCodeBytes;	/* Number of bytes in the code range. */
+    Tcl_Size breakOffset;	/* If LOOP_EXCEPTION_RANGE, the target PC
 				 * offset for a break command in the range. */
-    Tcl_Size continueOffset;		/* If LOOP_EXCEPTION_RANGE and not TCL_INDEX_NONE, the
-				 * target PC offset for a continue command in
-				 * the code range. Otherwise, ignore this
+    Tcl_Size continueOffset;	/* If LOOP_EXCEPTION_RANGE and not TCL_INDEX_NONE,
+				 * the target PC offset for a continue command
+				 * in the code range. Otherwise, ignore this
 				 * range when processing a continue
 				 * command. */
-    Tcl_Size catchOffset;		/* If a CATCH_EXCEPTION_RANGE, the target PC
+    Tcl_Size catchOffset;	/* If a CATCH_EXCEPTION_RANGE, the target PC
 				 * offset for any "exception" in range. */
 } ExceptionRange;
 
@@ -118,11 +118,11 @@ typedef struct ExceptionAux {
 				 * one (see [for] next-clause) then we must
 				 * not pick up the range when scanning for a
 				 * target to continue to. */
-    Tcl_Size stackDepth;		/* The stack depth at the point where the
+    Tcl_Size stackDepth;	/* The stack depth at the point where the
 				 * exception range was created. This is used
 				 * to calculate the number of POPs required to
 				 * restore the stack to its prior state. */
-    Tcl_Size expandTarget;		/* The number of expansions expected on the
+    Tcl_Size expandTarget;	/* The number of expansions expected on the
 				 * auxData stack at the time the loop starts;
 				 * we can't currently discard them except by
 				 * doing INST_INVOKE_EXPANDED; this is a known
@@ -135,23 +135,25 @@ typedef struct ExceptionAux {
     Tcl_Size numBreakTargets;	/* The number of [break]s that want to be
 				 * targeted to the place where this loop
 				 * exception will be bound to. */
-    TCL_HASH_TYPE *breakTargets;	/* The offsets of the INST_JUMP4 instructions
+    TCL_HASH_TYPE *breakTargets;/* The offsets of the INST_JUMP4 instructions
 				 * issued by the [break]s that we must
 				 * update. Note that resizing a jump (via
 				 * TclFixupForwardJump) can cause the contents
 				 * of this array to be updated. When
 				 * numBreakTargets==0, this is NULL. */
     Tcl_Size allocBreakTargets;	/* The size of the breakTargets array. */
-    Tcl_Size numContinueTargets;	/* The number of [continue]s that want to be
+    Tcl_Size numContinueTargets;/* The number of [continue]s that want to be
 				 * targeted to the place where this loop
 				 * exception will be bound to. */
-    TCL_HASH_TYPE *continueTargets; /* The offsets of the INST_JUMP4 instructions
+    TCL_HASH_TYPE *continueTargets;
+				/* The offsets of the INST_JUMP4 instructions
 				 * issued by the [continue]s that we must
 				 * update. Note that resizing a jump (via
 				 * TclFixupForwardJump) can cause the contents
 				 * of this array to be updated. When
 				 * numContinueTargets==0, this is NULL. */
-    Tcl_Size allocContinueTargets;	/* The size of the continueTargets array. */
+    Tcl_Size allocContinueTargets;
+				/* The size of the continueTargets array. */
 } ExceptionAux;
 
 /*
@@ -163,10 +165,10 @@ typedef struct ExceptionAux {
  */
 
 typedef struct {
-    Tcl_Size codeOffset;		/* Offset of first byte of command code. */
-    Tcl_Size numCodeBytes;		/* Number of bytes for command's code. */
+    Tcl_Size codeOffset;	/* Offset of first byte of command code. */
+    Tcl_Size numCodeBytes;	/* Number of bytes for command's code. */
     Tcl_Size srcOffset;		/* Offset of first char of the command. */
-    Tcl_Size numSrcBytes;		/* Number of command source chars. */
+    Tcl_Size numSrcBytes;	/* Number of command source chars. */
 } CmdLocation;
 
 /*
@@ -182,10 +184,10 @@ typedef struct {
 
 typedef struct {
     Tcl_Size srcOffset;		/* Command location to find the entry. */
-    Tcl_Size nline;			/* Number of words in the command */
-    Tcl_Size *line;			/* Line information for all words in the
+    Tcl_Size nline;		/* Number of words in the command */
+    Tcl_Size *line;		/* Line information for all words in the
 				 * command. */
-    Tcl_Size **next;			/* Transient information used by the compiler
+    Tcl_Size **next;		/* Transient information used by the compiler
 				 * for tracking of hidden continuation
 				 * lines. */
 } ECL;
@@ -198,8 +200,8 @@ typedef struct {
     Tcl_Obj *path;		/* Path of the sourced file the command is
 				 * in. */
     ECL *loc;			/* Command word locations (lines). */
-    Tcl_Size nloc;			/* Number of allocated entries in 'loc'. */
-    Tcl_Size nuloc;			/* Number of used entries in 'loc'. */
+    Tcl_Size nloc;		/* Number of allocated entries in 'loc'. */
+    Tcl_Size nuloc;		/* Number of used entries in 'loc'. */
 } ExtCmdLoc;
 
 /*
@@ -217,11 +219,11 @@ typedef struct {
  * the AuxData structure.
  */
 
-typedef void *(AuxDataDupProc)  (void *clientData);
-typedef void	   (AuxDataFreeProc) (void *clientData);
-typedef void	   (AuxDataPrintProc)(void *clientData,
-			    Tcl_Obj *appendObj, struct ByteCode *codePtr,
-			    TCL_HASH_TYPE pcOffset);
+typedef void *	(AuxDataDupProc) (void *clientData);
+typedef void	(AuxDataFreeProc) (void *clientData);
+typedef void	(AuxDataPrintProc) (void *clientData,
+	Tcl_Obj *appendObj, struct ByteCode *codePtr,
+	TCL_HASH_TYPE pcOffset);
 
 /*
  * We define a separate AuxDataType struct to hold type-related information
@@ -266,7 +268,7 @@ typedef struct AuxDataType {
 typedef struct AuxData {
     const AuxDataType *type;	/* Pointer to the AuxData type associated with
 				 * this ClientData. */
-    void *clientData;	/* The compilation data itself. */
+    void *clientData;		/* The compilation data itself. */
 } AuxData;
 
 /*
@@ -290,21 +292,23 @@ typedef struct CompileEnv {
 				 * SetByteCodeFromAny. This pointer is not
 				 * owned by the CompileEnv and must not be
 				 * freed or changed by it. */
-    Tcl_Size numSrcBytes;		/* Number of bytes in source. */
+    Tcl_Size numSrcBytes;	/* Number of bytes in source. */
     Proc *procPtr;		/* If a procedure is being compiled, a pointer
 				 * to its Proc structure; otherwise NULL. Used
 				 * to compile local variables. Set from
 				 * information provided by ObjInterpProc in
 				 * tclProc.c. */
-    Tcl_Size numCommands;		/* Number of commands compiled. */
-    Tcl_Size exceptDepth;		/* Current exception range nesting level; TCL_INDEX_NONE
-				 * if not in any range currently. */
-    Tcl_Size maxExceptDepth;		/* Max nesting level of exception ranges; TCL_INDEX_NONE
-				 * if no ranges have been compiled. */
-    Tcl_Size maxStackDepth;		/* Maximum number of stack elements needed to
+    Tcl_Size numCommands;	/* Number of commands compiled. */
+    Tcl_Size exceptDepth;	/* Current exception range nesting level;
+				 * TCL_INDEX_NONE if not in any range
+				 * currently. */
+    Tcl_Size maxExceptDepth;	/* Max nesting level of exception ranges;
+				 * TCL_INDEX_NONE if no ranges have been
+				 * compiled. */
+    Tcl_Size maxStackDepth;	/* Maximum number of stack elements needed to
 				 * execute the code. Set by compilation
 				 * procedures before returning. */
-    Tcl_Size currStackDepth;		/* Current stack depth. */
+    Tcl_Size currStackDepth;	/* Current stack depth. */
     LiteralTable localLitTable;	/* Contains LiteralEntry's describing all Tcl
 				 * objects referenced by this compiled code.
 				 * Indexed by the string representations of
@@ -333,7 +337,7 @@ typedef struct CompileEnv {
 				 * exceptArrayNext is the number of ranges and
 				 * (exceptArrayNext-1) is the index of the
 				 * current range's array entry. */
-    Tcl_Size exceptArrayEnd;		/* Index after the last ExceptionRange array
+    Tcl_Size exceptArrayEnd;	/* Index after the last ExceptionRange array
 				 * entry. */
 #if TCL_MAJOR_VERSION < 9
     int mallocedExceptArray;
@@ -379,7 +383,7 @@ typedef struct CompileEnv {
     /* TIP #280 */
     ExtCmdLoc *extCmdMapPtr;	/* Extended command location information for
 				 * 'info frame'. */
-    Tcl_Size line;			/* First line of the script, based on the
+    Tcl_Size line;		/* First line of the script, based on the
 				 * invoking context, then the line of the
 				 * command currently compiled. */
     int atCmdStart;		/* Flag to say whether an INST_START_CMD
@@ -388,11 +392,11 @@ typedef struct CompileEnv {
 				 * inefficient. If set to 2, that instruction
 				 * should not be issued at all (by the generic
 				 * part of the command compiler). */
-    Tcl_Size expandCount;		/* Number of INST_EXPAND_START instructions
+    Tcl_Size expandCount;	/* Number of INST_EXPAND_START instructions
 				 * encountered that have not yet been paired
 				 * with a corresponding
 				 * INST_INVOKE_EXPANDED. */
-    Tcl_Size *clNext;	/* If not NULL, it refers to the next slot in
+    Tcl_Size *clNext;		/* If not NULL, it refers to the next slot in
 				 * clLoc to check for an invisible
 				 * continuation line. */
 } CompileEnv;
@@ -427,7 +431,7 @@ typedef struct ByteCode {
 				 * procs are specific to an interpreter so the
 				 * code emitted will depend on the
 				 * interpreter. */
-    Tcl_Size compileEpoch;		/* Value of iPtr->compileEpoch when this
+    Tcl_Size compileEpoch;	/* Value of iPtr->compileEpoch when this
 				 * ByteCode was compiled. Used to invalidate
 				 * code when, e.g., commands with compile
 				 * procs are redefined. */
@@ -459,17 +463,17 @@ typedef struct ByteCode {
 				 * itself. Does not include heap space for
 				 * literal Tcl objects or storage referenced
 				 * by AuxData entries. */
-    Tcl_Size numCommands;		/* Number of commands compiled. */
-    Tcl_Size numSrcBytes;		/* Number of source bytes compiled. */
-    Tcl_Size numCodeBytes;		/* Number of code bytes. */
-    Tcl_Size numLitObjects;		/* Number of objects in literal array. */
+    Tcl_Size numCommands;	/* Number of commands compiled. */
+    Tcl_Size numSrcBytes;	/* Number of source bytes compiled. */
+    Tcl_Size numCodeBytes;	/* Number of code bytes. */
+    Tcl_Size numLitObjects;	/* Number of objects in literal array. */
     Tcl_Size numExceptRanges;	/* Number of ExceptionRange array elems. */
     Tcl_Size numAuxDataItems;	/* Number of AuxData items. */
-    Tcl_Size numCmdLocBytes;		/* Number of bytes needed for encoded command
+    Tcl_Size numCmdLocBytes;	/* Number of bytes needed for encoded command
 				 * location information. */
-    Tcl_Size maxExceptDepth;		/* Maximum nesting level of ExceptionRanges;
+    Tcl_Size maxExceptDepth;	/* Maximum nesting level of ExceptionRanges;
 				 * TCL_INDEX_NONE if no ranges were compiled. */
-    Tcl_Size maxStackDepth;		/* Maximum number of stack elements needed to
+    Tcl_Size maxStackDepth;	/* Maximum number of stack elements needed to
 				 * execute the code. */
     unsigned char *codeStart;	/* Points to the first byte of the code. This
 				 * is just after the final ByteCode member
@@ -525,7 +529,7 @@ typedef struct ByteCode {
 #endif /* TCL_COMPILE_STATS */
 } ByteCode;
 
-#define ByteCodeSetInternalRep(objPtr, typePtr, codePtr)			\
+#define ByteCodeSetInternalRep(objPtr, typePtr, codePtr) \
     do {								\
 	Tcl_ObjInternalRep ir;						\
 	ir.twoPtrValue.ptr1 = (codePtr);				\
@@ -533,13 +537,11 @@ typedef struct ByteCode {
 	Tcl_StoreInternalRep((objPtr), (typePtr), &ir);			\
     } while (0)
 
-
-
-#define ByteCodeGetInternalRep(objPtr, typePtr, codePtr)			\
+#define ByteCodeGetInternalRep(objPtr, typePtr, codePtr) \
     do {								\
-	const Tcl_ObjInternalRep *irPtr;					\
-	irPtr = TclFetchInternalRep((objPtr), (typePtr));			\
-	(codePtr) = irPtr ? (ByteCode*)irPtr->twoPtrValue.ptr1 : NULL;		\
+	const Tcl_ObjInternalRep *irPtr;				\
+	irPtr = TclFetchInternalRep((objPtr), (typePtr));		\
+	(codePtr) = irPtr ? (ByteCode*)irPtr->twoPtrValue.ptr1 : NULL;	\
     } while (0)
 
 /*
@@ -829,11 +831,11 @@ enum TclInstruction {
 
     INST_DICT_GET_DEF,
 
-	/* TIP 461 */
-	INST_STR_LT,
-	INST_STR_GT,
-	INST_STR_LE,
-	INST_STR_GE,
+    /* TIP 461 */
+    INST_STR_LT,
+    INST_STR_GT,
+    INST_STR_LE,
+    INST_STR_GE,
 
     INST_LREPLACE4,
 
@@ -968,8 +970,8 @@ typedef struct JumpFixup {
 
 typedef struct JumpFixupArray {
     JumpFixup *fixup;		/* Points to start of jump fixup array. */
-    Tcl_Size next;			/* Index of next free array entry. */
-    Tcl_Size end;			/* Index of last usable entry in array. */
+    Tcl_Size next;		/* Index of next free array entry. */
+    Tcl_Size end;		/* Index of last usable entry in array. */
     int mallocedArray;		/* 1 if array was expanded and fixups points
 				 * into the heap, else 0. */
     JumpFixup staticFixupSpace[JUMPFIXUP_INIT_ENTRIES];
@@ -985,7 +987,8 @@ typedef struct JumpFixupArray {
 
 typedef struct ForeachVarList {
     Tcl_Size numVars;		/* The number of variables in the list. */
-    Tcl_Size varIndexes[TCLFLEXARRAY];/* An array of the indexes ("slot numbers")
+    Tcl_Size varIndexes[TCLFLEXARRAY];
+				/* An array of the indexes ("slot numbers")
 				 * for each variable in the procedure's array
 				 * of local variables. Only scalar variables
 				 * are supported. The actual size of this
@@ -1003,13 +1006,14 @@ typedef struct ForeachVarList {
 typedef struct ForeachInfo {
     Tcl_Size numLists;		/* The number of both the variable and value
 				 * lists of the foreach command. */
-    Tcl_Size firstValueTemp;		/* Index of the first temp var in a proc frame
+    Tcl_Size firstValueTemp;	/* Index of the first temp var in a proc frame
 				 * used to point to a value list. */
-    Tcl_Size loopCtTemp;		/* Index of temp var in a proc frame holding
+    Tcl_Size loopCtTemp;	/* Index of temp var in a proc frame holding
 				 * the loop's iteration count. Used to
 				 * determine next value list element to assign
 				 * each loop var. */
-    ForeachVarList *varLists[TCLFLEXARRAY];/* An array of pointers to ForeachVarList
+    ForeachVarList *varLists[TCLFLEXARRAY];
+				/* An array of pointers to ForeachVarList
 				 * structures describing each var list. The
 				 * actual size of this field will be large
 				 * enough to numVars indexes. THIS MUST BE THE
@@ -1040,7 +1044,8 @@ MODULE_SCOPE const AuxDataType tclJumptableInfoType;
 
 typedef struct {
     Tcl_Size length;		/* Size of array */
-    Tcl_Size varIndices[TCLFLEXARRAY];		/* Array of variable indices to manage when
+    Tcl_Size varIndices[TCLFLEXARRAY];
+				/* Array of variable indices to manage when
 				 * processing the start and end of a [dict
 				 * update]. There is really more than one
 				 * entry, and the structure is allocated to
@@ -1200,14 +1205,13 @@ MODULE_SCOPE void	TclLogCommandInfo(Tcl_Interp *interp,
 			    const char *script, const char *command,
 			    Tcl_Size length, const unsigned char *pc,
 			    Tcl_Obj **tosPtr);
-MODULE_SCOPE Tcl_Obj	*TclGetInnerContext(Tcl_Interp *interp,
+MODULE_SCOPE Tcl_Obj *	TclGetInnerContext(Tcl_Interp *interp,
 			    const unsigned char *pc, Tcl_Obj **tosPtr);
-MODULE_SCOPE Tcl_Obj	*TclNewInstNameObj(unsigned char inst);
+MODULE_SCOPE Tcl_Obj *	TclNewInstNameObj(unsigned char inst);
 MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
 			    Tcl_Interp *interp, Tcl_Size objc,
 			    Tcl_Obj *const objv[], int isLambda);
 #endif /* TCL_MAJOR_VERSION > 8 */
-
 
 /*
  *----------------------------------------------------------------
@@ -1230,58 +1234,66 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
 #define LITERAL_UNSHARED	0x04
 
 /*
- * Macro used to manually adjust the stack requirements; used in cases where
- * the stack effect cannot be computed from the opcode and its operands, but
- * is still known at compile time.
- *
- * void TclAdjustStackDepth(int delta, CompileEnv *envPtr);
+ * Adjust the stack requirements. Manually used in cases where the stack
+ * effect cannot be computed from the opcode and its operands, but is still
+ * known at compile time.
  */
+static inline void
+TclAdjustStackDepth(
+    int delta,
+    CompileEnv *envPtr)
+{
+    if (delta < 0) {
+	if ((int) envPtr->maxStackDepth < (int) envPtr->currStackDepth) {
+	    envPtr->maxStackDepth = envPtr->currStackDepth;
+	}
+    }
+    envPtr->currStackDepth += delta;
+}
 
-#define TclAdjustStackDepth(delta, envPtr) \
-    do {								\
-	if ((delta) < 0) {						\
-	    if ((int)(envPtr)->maxStackDepth < (int)(envPtr)->currStackDepth) {	\
-		(envPtr)->maxStackDepth = (envPtr)->currStackDepth;	\
-	    }								\
-	}								\
-	(envPtr)->currStackDepth += (delta);				\
-    } while (0)
-
-#define TclGetStackDepth(envPtr)		\
+#define TclGetStackDepth(envPtr) \
     ((envPtr)->currStackDepth)
 
-#define TclSetStackDepth(depth, envPtr)		\
+#define TclSetStackDepth(depth, envPtr) \
     (envPtr)->currStackDepth = (depth)
 
-#define TclCheckStackDepth(depth, envPtr)				\
-    do {								\
-	size_t _dd = (depth);						\
-	if (_dd != (size_t)(envPtr)->currStackDepth) {				\
-	    Tcl_Panic("bad stack depth computations: is %" TCL_Z_MODIFIER "u, should be %" TCL_Z_MODIFIER "u", \
-		    (size_t)(envPtr)->currStackDepth, _dd);		\
-	}								\
-    } while (0)
+/*
+ * Verify that the current stack depth is what we think it should be. When
+ * this is wrong, code generation is broken!
+ */
+static inline void
+TclCheckStackDepth(
+    size_t depth,
+    CompileEnv *envPtr)
+{
+    if (depth != (size_t) envPtr->currStackDepth) {
+	Tcl_Panic("bad stack depth computations: "
+		"is %" TCL_Z_MODIFIER "u, should be %" TCL_Z_MODIFIER "u",
+		(size_t) envPtr->currStackDepth, depth);
+    }
+}
 
 /*
- * Macro used to update the stack requirements. It is called by the macros
- * TclEmitOpCode, TclEmitInst1 and TclEmitInst4.
+ * Update the stack requirements based on the instruction definition. It is
+ * called by the macros TclEmitOpCode, TclEmitInst1 and TclEmitInst4.
  * Remark that the very last instruction of a bytecode always reduces the
  * stack level: INST_DONE or INST_POP, so that the maxStackdepth is always
  * updated.
- *
- * void TclUpdateStackReqs(unsigned char op, int i, CompileEnv *envPtr);
  */
-
-#define TclUpdateStackReqs(op, i, envPtr) \
-    do {							\
-	int _delta = tclInstructionTable[(op)].stackEffect;	\
-	if (_delta) {						\
-	    if (_delta == INT_MIN) {				\
-		_delta = 1 - (i);				\
-	    }							\
-	    TclAdjustStackDepth(_delta, envPtr);			\
-	}							\
-    } while (0)
+static inline void
+TclUpdateStackReqs(
+    unsigned char op,
+    int i,
+    CompileEnv *envPtr)
+{
+    int delta = tclInstructionTable[op].stackEffect;
+    if (delta) {
+	if (delta == INT_MIN) {
+	    delta = 1 - i;
+	}
+	TclAdjustStackDepth(delta, envPtr);
+    }
+}
 
 /*
  * Macros used to update the flag that indicates if we are at the start of a
@@ -1291,8 +1303,8 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
  */
 
 #define TclUpdateAtCmdStart(op, envPtr) \
-    if ((envPtr)->atCmdStart < 2) {				     \
-	(envPtr)->atCmdStart = ((op) == INST_START_CMD ? 1 : 0);     \
+    if ((envPtr)->atCmdStart < 2) {					\
+	(envPtr)->atCmdStart = ((op) == INST_START_CMD ? 1 : 0);	\
     }
 
 /*
@@ -1303,13 +1315,13 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
  */
 
 #define TclEmitOpcode(op, envPtr) \
-    do {							\
-	if ((envPtr)->codeNext == (envPtr)->codeEnd) {		\
-	    TclExpandCodeArray(envPtr);				\
-	}							\
-	*(envPtr)->codeNext++ = (unsigned char) (op);		\
-	TclUpdateAtCmdStart(op, envPtr);			\
-	TclUpdateStackReqs(op, 0, envPtr);			\
+    do {								\
+	if ((envPtr)->codeNext == (envPtr)->codeEnd) {			\
+	    TclExpandCodeArray(envPtr);					\
+	}								\
+	*(envPtr)->codeNext++ = (unsigned char) (op);			\
+	TclUpdateAtCmdStart(op, envPtr);				\
+	TclUpdateStackReqs(op, 0, envPtr);				\
     } while (0)
 
 /*
@@ -1365,21 +1377,21 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
     } while (0)
 
 #define TclEmitInstInt4(op, i, envPtr) \
-    do {							\
-	if (((envPtr)->codeNext + 5) > (envPtr)->codeEnd) {	\
-	    TclExpandCodeArray(envPtr);				\
-	}							\
-	*(envPtr)->codeNext++ = (unsigned char) (op);		\
-	*(envPtr)->codeNext++ =					\
-		(unsigned char) ((unsigned int) (i) >> 24);	\
-	*(envPtr)->codeNext++ =					\
-		(unsigned char) ((unsigned int) (i) >> 16);	\
-	*(envPtr)->codeNext++ =					\
-		(unsigned char) ((unsigned int) (i) >>  8);	\
-	*(envPtr)->codeNext++ =					\
-		(unsigned char) ((unsigned int) (i)      );	\
-	TclUpdateAtCmdStart(op, envPtr);			\
-	TclUpdateStackReqs(op, i, envPtr);			\
+    do {								\
+	if (((envPtr)->codeNext + 5) > (envPtr)->codeEnd) {		\
+	    TclExpandCodeArray(envPtr);					\
+	}								\
+	*(envPtr)->codeNext++ = (unsigned char) (op);			\
+	*(envPtr)->codeNext++ =						\
+		(unsigned char) ((unsigned int) (i) >> 24);		\
+	*(envPtr)->codeNext++ =						\
+		(unsigned char) ((unsigned int) (i) >> 16);		\
+	*(envPtr)->codeNext++ =						\
+		(unsigned char) ((unsigned int) (i) >>  8);		\
+	*(envPtr)->codeNext++ =						\
+		(unsigned char) ((unsigned int) (i)      );		\
+	TclUpdateAtCmdStart(op, envPtr);				\
+	TclUpdateStackReqs(op, i, envPtr);				\
     } while (0)
 
 /*
@@ -1392,13 +1404,13 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
  */
 
 #define TclEmitPush(objIndex, envPtr) \
-    do {							 \
-	int _objIndexCopy = (objIndex);			 \
-	if (_objIndexCopy <= 255) {				 \
-	    TclEmitInstInt1(INST_PUSH1, _objIndexCopy, (envPtr)); \
-	} else {						 \
-	    TclEmitInstInt4(INST_PUSH4, _objIndexCopy, (envPtr)); \
-	}							 \
+    do {								\
+	int _objIndexCopy = (objIndex);					\
+	if (_objIndexCopy <= 255) {					\
+	    TclEmitInstInt1(INST_PUSH1, _objIndexCopy, (envPtr));	\
+	} else {							\
+	    TclEmitInstInt4(INST_PUSH4, _objIndexCopy, (envPtr));	\
+	}								\
     } while (0)
 
 /*
@@ -1414,11 +1426,11 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
     *(p)   = (unsigned char) ((unsigned int) (i))
 
 #define TclStoreInt4AtPtr(i, p) \
-    do {							\
-	*(p)   = (unsigned char) ((unsigned int) (i) >> 24);	\
-	*(p+1) = (unsigned char) ((unsigned int) (i) >> 16);	\
-	*(p+2) = (unsigned char) ((unsigned int) (i) >>  8);	\
-	*(p+3) = (unsigned char) ((unsigned int) (i)      );	\
+    do {								\
+	*(p)   = (unsigned char) ((unsigned int) (i) >> 24);		\
+	*(p+1) = (unsigned char) ((unsigned int) (i) >> 16);		\
+	*(p+2) = (unsigned char) ((unsigned int) (i) >>  8);		\
+	*(p+3) = (unsigned char) ((unsigned int) (i)      );		\
     } while (0)
 
 /*
@@ -1431,15 +1443,15 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
  */
 
 #define TclUpdateInstInt1AtPc(op, i, pc) \
-    do {					\
-	*(pc) = (unsigned char) (op);		\
-	TclStoreInt1AtPtr((i), ((pc)+1));	\
+    do {								\
+	*(pc) = (unsigned char) (op);					\
+	TclStoreInt1AtPtr((i), ((pc)+1));				\
     } while (0)
 
 #define TclUpdateInstInt4AtPc(op, i, pc) \
-    do {					\
-	*(pc) = (unsigned char) (op);		\
-	TclStoreInt4AtPtr((i), ((pc)+1));	\
+    do {								\
+	*(pc) = (unsigned char) (op);					\
+	TclStoreInt4AtPtr((i), ((pc)+1));				\
     } while (0)
 
 /*
@@ -1486,17 +1498,17 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
 #endif
 
 #define TclGetInt4AtPtr(p) \
-    ((int) ((TclGetUInt1AtPtr(p) << 24) |			\
-		       (*((p)+1) << 16) |			\
-		       (*((p)+2) <<  8) |			\
+    ((int) ((TclGetUInt1AtPtr(p) << 24) |				\
+		       (*((p)+1) << 16) |				\
+		       (*((p)+2) <<  8) |				\
 		       (*((p)+3))))
 
 #define TclGetUInt1AtPtr(p) \
     ((unsigned int) *(p))
 #define TclGetUInt4AtPtr(p) \
-    ((unsigned int) ((*(p)     << 24) |				\
-		     (*((p)+1) << 16) |				\
-		     (*((p)+2) <<  8) |				\
+    ((unsigned int) ((*(p)     << 24) |					\
+		     (*((p)+1) << 16) |					\
+		     (*((p)+2) <<  8) |					\
 		     (*((p)+3))))
 
 /*
@@ -1517,7 +1529,7 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
  * static void		BODY(Tcl_Token *tokenPtr, int word);
  */
 
-#define BODY(tokenPtr, word)						\
+#define BODY(tokenPtr, word) \
     SetLineInformation((word));						\
     TclCompileCmdWord(interp, (tokenPtr)+1, (tokenPtr)->numComponents,	\
 	    envPtr)
@@ -1815,14 +1827,14 @@ MODULE_SCOPE void TclDTraceOpenDebugLog(void);
 MODULE_SCOPE void TclDTraceInfo(Tcl_Obj *info, const char **args, Tcl_Size *argsi);
 
 #define TCL_DTRACE_DEBUG_LOG() \
-    int tclDTraceDebugEnabled = TCL_DTRACE_DEBUG_LOG_ENABLED;	\
-    int tclDTraceDebugIndent = 0;				\
-    FILE *tclDTraceDebugLog = NULL;				\
-    void TclDTraceOpenDebugLog(void) {				\
-	char n[35];						\
+    int tclDTraceDebugEnabled = TCL_DTRACE_DEBUG_LOG_ENABLED;		\
+    int tclDTraceDebugIndent = 0;					\
+    FILE *tclDTraceDebugLog = NULL;					\
+    void TclDTraceOpenDebugLog(void) {					\
+	char n[35];							\
 	snprintf(n, sizeof(n), "/tmp/tclDTraceDebug-%" TCL_Z_MODIFIER "u.log", \
-		(size_t) getpid());			\
-	tclDTraceDebugLog = fopen(n, "a");			\
+		(size_t) getpid());					\
+	tclDTraceDebugLog = fopen(n, "a");				\
     }
 
 #define TclDTraceDbgMsg(p, m, ...) \
@@ -1849,10 +1861,10 @@ MODULE_SCOPE void TclDTraceInfo(Tcl_Obj *info, const char **args, Tcl_Size *args
 #define TCL_DTRACE_PROC_ARGS_ENABLED()	    1
 #define TCL_DTRACE_PROC_INFO_ENABLED()	    1
 #define TCL_DTRACE_PROC_ENTRY(a0, a1, a2) \
-	tclDTraceDebugIndent++; \
+	tclDTraceDebugIndent++;						\
 	TclDTraceDbgMsg("-> proc-entry", "%s %" TCL_SIZE_MODIFIER "d %p", a0, a1, a2)
 #define TCL_DTRACE_PROC_RETURN(a0, a1) \
-	TclDTraceDbgMsg("<- proc-return", "%s %d", a0, a1); \
+	TclDTraceDbgMsg("<- proc-return", "%s %d", a0, a1);		\
 	tclDTraceDebugIndent--
 #define TCL_DTRACE_PROC_RESULT(a0, a1, a2, a3) \
 	TclDTraceDbgMsg(" | proc-result", "%s %d %s %p", a0, a1, a2, a3)
@@ -1869,10 +1881,10 @@ MODULE_SCOPE void TclDTraceInfo(Tcl_Obj *info, const char **args, Tcl_Size *args
 #define TCL_DTRACE_CMD_ARGS_ENABLED()	    1
 #define TCL_DTRACE_CMD_INFO_ENABLED()	    1
 #define TCL_DTRACE_CMD_ENTRY(a0, a1, a2) \
-	tclDTraceDebugIndent++; \
+	tclDTraceDebugIndent++;						\
 	TclDTraceDbgMsg("-> cmd-entry", "%s %" TCL_SIZE_MODIFIER "d %p", a0, a1, a2)
 #define TCL_DTRACE_CMD_RETURN(a0, a1) \
-	TclDTraceDbgMsg("<- cmd-return", "%s %d", a0, a1); \
+	TclDTraceDbgMsg("<- cmd-return", "%s %d", a0, a1);		\
 	tclDTraceDebugIndent--
 #define TCL_DTRACE_CMD_RESULT(a0, a1, a2, a3) \
 	TclDTraceDbgMsg(" | cmd-result", "%s %d %s %p", a0, a1, a2, a3)
diff --git a/generic/tclInt.h b/generic/tclInt.h
index c714cb8..d6fdb88 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -257,7 +257,7 @@ typedef struct Namespace {
 				 * synonym. */
     char *fullName;		/* The namespace's fully qualified name. This
 				 * starts with ::. */
-    void *clientData;	/* An arbitrary value associated with this
+    void *clientData;		/* An arbitrary value associated with this
 				 * namespace. */
     Tcl_NamespaceDeleteProc *deleteProc;
 				/* Procedure invoked when deleting the
@@ -279,7 +279,7 @@ typedef struct Namespace {
 #else
     unsigned long nsId;
 #endif
-    Tcl_Interp *interp;	/* The interpreter containing this
+    Tcl_Interp *interp;		/* The interpreter containing this
 				 * namespace. */
     int flags;			/* OR-ed combination of the namespace status
 				 * flags NS_DYING and NS_DEAD listed below. */
@@ -312,12 +312,12 @@ typedef struct Namespace {
 				 * registered using "namespace export". */
     Tcl_Size maxExportPatterns;	/* Number of export patterns for which space
 				 * is currently allocated. */
-    Tcl_Size cmdRefEpoch;		/* Incremented if a newly added command
+    Tcl_Size cmdRefEpoch;	/* Incremented if a newly added command
 				 * shadows a command for which this namespace
 				 * has already cached a Command* pointer; this
 				 * causes all its cached Command* pointers to
 				 * be invalidated. */
-    Tcl_Size resolverEpoch;		/* Incremented whenever (a) the name
+    Tcl_Size resolverEpoch;	/* Incremented whenever (a) the name
 				 * resolution rules change for this namespace
 				 * or (b) a newly added command shadows a
 				 * command that is compiled to bytecodes. This
@@ -424,8 +424,8 @@ struct NamespacePathEntry {
  * TCL_NAMESPACE_ONLY		- (see tcl.h) Look only in the context ns.
  * TCL_CREATE_NS_IF_UNKNOWN	- Create unknown namespaces.
  * TCL_FIND_ONLY_NS		- The name sought is a namespace name.
- * TCL_FIND_IF_NOT_SIMPLE       - Retrieve last namespace even if the rest of
- *                                name is not simple name (contains ::).
+ * TCL_FIND_IF_NOT_SIMPLE	- Retrieve last namespace even if the rest of
+ *				  name is not simple name (contains ::).
  */
 
 #define TCL_CREATE_NS_IF_UNKNOWN	0x800
@@ -447,7 +447,7 @@ typedef struct EnsembleConfig {
 				 * if the command has been deleted (or never
 				 * existed; the global namespace never has an
 				 * ensemble command.) */
-    Tcl_Size epoch;			/* The epoch at which this ensemble's table of
+    Tcl_Size epoch;		/* The epoch at which this ensemble's table of
 				 * exported commands is valid. */
     char **subcommandArrayPtr;	/* Array of ensemble subcommand names. At all
 				 * consistent points, this will have the same
@@ -504,7 +504,7 @@ typedef struct EnsembleConfig {
 				 * core, presumably because the ensemble
 				 * itself has been updated. */
     Tcl_Obj *parameterList;	/* List of ensemble parameter names. */
-    Tcl_Size numParameters;		/* Cached number of parameters. This is either
+    Tcl_Size numParameters;	/* Cached number of parameters. This is either
 				 * 0 (if the parameterList field is NULL) or
 				 * the length of the list in the parameterList
 				 * field. */
@@ -534,7 +534,7 @@ typedef struct EnsembleConfig {
 typedef struct VarTrace {
     Tcl_VarTraceProc *traceProc;/* Procedure to call when operations given by
 				 * flags are performed on variable. */
-    void *clientData;	/* Argument to pass to proc. */
+    void *clientData;		/* Argument to pass to proc. */
     int flags;			/* What events the trace procedure is
 				 * interested in: OR-ed combination of
 				 * TCL_TRACE_READS, TCL_TRACE_WRITES,
@@ -553,7 +553,7 @@ typedef struct CommandTrace {
     Tcl_CommandTraceProc *traceProc;
 				/* Procedure to call when operations given by
 				 * flags are performed on command. */
-    void *clientData;	/* Argument to pass to proc. */
+    void *clientData;		/* Argument to pass to proc. */
     int flags;			/* What events the trace procedure is
 				 * interested in: OR-ed combination of
 				 * TCL_TRACE_RENAME, TCL_TRACE_DELETE. */
@@ -834,10 +834,10 @@ typedef struct VarInHash {
 
 #define TclVarFindHiddenArray(varPtr,arrayPtr)				\
     do {								\
-        if ((arrayPtr == NULL) && TclIsVarInHash(varPtr) &&		\
-              (TclVarParentArray(varPtr) != NULL)) {			\
-            arrayPtr = TclVarParentArray(varPtr);			\
-        }								\
+	if ((arrayPtr == NULL) && TclIsVarInHash(varPtr) &&		\
+		(TclVarParentArray(varPtr) != NULL)) {			\
+	    arrayPtr = TclVarParentArray(varPtr);			\
+	}								\
     } while(0)
 
 #define TclIsVarScalar(varPtr) \
@@ -903,13 +903,13 @@ typedef struct VarInHash {
 
 #define TclIsVarTricky(varPtr,trickyFlags)				\
     (   ((varPtr)->flags & (VAR_ARRAY|VAR_LINK|trickyFlags))		\
-          || (TclIsVarInHash(varPtr)					\
-                && (TclVarParentArray(varPtr) != NULL)			\
-                && (TclVarParentArray(varPtr)->flags & (trickyFlags))))
+	  || (TclIsVarInHash(varPtr)					\
+		&& (TclVarParentArray(varPtr) != NULL)			\
+		&& (TclVarParentArray(varPtr)->flags & (trickyFlags))))
 
 #define TclIsVarDirectReadable(varPtr)					\
     (   (!TclIsVarTricky(varPtr,VAR_TRACED_READ))			\
-          && (varPtr)->value.objPtr)
+	&& (varPtr)->value.objPtr)
 
 #define TclIsVarDirectWritable(varPtr) \
     (!TclIsVarTricky(varPtr,VAR_TRACED_WRITE|VAR_DEAD_HASH|VAR_CONSTANT))
@@ -919,7 +919,7 @@ typedef struct VarInHash {
 
 #define TclIsVarDirectModifyable(varPtr) \
     (   (!TclIsVarTricky(varPtr,VAR_TRACED_READ|VAR_TRACED_WRITE|VAR_CONSTANT))	\
-          &&  (varPtr)->value.objPtr)
+	&&  (varPtr)->value.objPtr)
 
 #define TclIsVarDirectReadable2(varPtr, arrayPtr) \
     (TclIsVarDirectReadable(varPtr) &&\
@@ -973,9 +973,9 @@ typedef struct CompiledLocal {
 				/* Next compiler-recognized local variable for
 				 * this procedure, or NULL if this is the last
 				 * local. */
-    Tcl_Size nameLength;		/* The number of bytes in local variable's name.
+    Tcl_Size nameLength;	/* The number of bytes in local variable's name.
 				 * Among others used to speed up var lookups. */
-    Tcl_Size frameIndex;		/* Index in the array of compiler-assigned
+    Tcl_Size frameIndex;	/* Index in the array of compiler-assigned
 				 * variables in the procedure call frame. */
 #if TCL_MAJOR_VERSION < 9
     int flags;
@@ -996,7 +996,7 @@ typedef struct CompiledLocal {
 				 * although only VAR_ARGUMENT, VAR_TEMPORARY,
 				 * and VAR_RESOLVED make sense. */
 #endif
-    char name[TCLFLEXARRAY];		/* Name of the local variable starts here. If
+    char name[TCLFLEXARRAY];	/* Name of the local variable starts here. If
 				 * the name is NULL, this will just be '\0'.
 				 * The actual size of this field will be large
 				 * enough to hold the name. MUST BE THE LAST
@@ -1058,7 +1058,7 @@ typedef struct Trace {
 #else
     Tcl_CmdObjTraceProc *proc;	/* Procedure to call to trace command. */
 #endif
-    void *clientData;	/* Arbitrary value to pass to proc. */
+    void *clientData;		/* Arbitrary value to pass to proc. */
     struct Trace *nextPtr;	/* Next in list of traces for this interp. */
     int flags;			/* Flags governing the trace - see
 				 * Tcl_CreateObjTrace for details. */
@@ -1113,13 +1113,13 @@ MODULE_SCOPE Tcl_Size TclLengthOne(Tcl_Obj *);
 /*
  * Abstract List
  *
- *  This structure provides the functions used in List operations to emulate a
- *  List for AbstractList types.
+ * This structure provides the functions used in List operations to emulate a
+ * List for AbstractList types.
  */
 
-
 static inline Tcl_Size
-TclObjTypeLength(Tcl_Obj *objPtr)
+TclObjTypeLength(
+    Tcl_Obj *objPtr)
 {
     Tcl_ObjTypeLengthProc *proc = TclObjTypeHasProc(objPtr, lengthProc);
     return proc(objPtr);
@@ -1188,15 +1188,17 @@ TclObjTypeReplace(
     return proc(interp, objPtr, first, numToDelete, numToInsert, insertObjs);
 }
 static inline int
-TclObjTypeInOperator(Tcl_Interp *interp, struct Tcl_Obj *valueObj,
-		     struct Tcl_Obj *listObj, int *boolResult)
+TclObjTypeInOperator(
+    Tcl_Interp *interp,
+    Tcl_Obj *valueObj,
+    Tcl_Obj *listObj,
+    int *boolResult)
 {
     Tcl_ObjTypeInOperatorProc *proc = TclObjTypeHasProc(listObj, inOperProc);
     return proc(interp, valueObj, listObj, boolResult);
 }
 #endif /* TCL_MAJOR_VERSION > 8 */
 
-
 /*
  * The structure below defines an entry in the assocData hash table which is
  * associated with an interpreter. The entry contains a pointer to a function
@@ -1206,7 +1208,7 @@ TclObjTypeInOperator(Tcl_Interp *interp, struct Tcl_Obj *valueObj,
 
 typedef struct AssocData {
     Tcl_InterpDeleteProc *proc;	/* Proc to call when deleting. */
-    void *clientData;	/* Value to pass to proc. */
+    void *clientData;		/* Value to pass to proc. */
 } AssocData;
 
 /*
@@ -1250,11 +1252,10 @@ typedef struct CallFrame {
 				 * If FRAME_IS_PROC is set, the frame was
 				 * pushed to execute a Tcl procedure and may
 				 * have local vars. */
-    Tcl_Size objc;			/* This and objv below describe the arguments
+    Tcl_Size objc;		/* This and objv below describe the arguments
 				 * for this procedure call. */
     Tcl_Obj *const *objv;	/* Array of argument objects. */
-    struct CallFrame *callerPtr;
-				/* Value of interp->framePtr when this
+    struct CallFrame *callerPtr;/* Value of interp->framePtr when this
 				 * procedure was invoked (i.e. next higher in
 				 * stack of all active procedures). */
     struct CallFrame *callerVarPtr;
@@ -1264,7 +1265,7 @@ typedef struct CallFrame {
 				 * callerPtr unless an "uplevel" command or
 				 * something equivalent was active in the
 				 * caller). */
-    Tcl_Size level;			/* Level of this procedure, for "uplevel"
+    Tcl_Size level;		/* Level of this procedure, for "uplevel"
 				 * purposes (i.e. corresponds to nesting of
 				 * callerVarPtr's, not callerPtr's). 1 for
 				 * outermost procedure, 0 for top-level. */
@@ -1284,7 +1285,7 @@ typedef struct CallFrame {
 				 * recognized by the compiler. The compiler
 				 * emits code that refers to these variables
 				 * using an index into this array. */
-    void *clientData;	/* Pointer to some context that is used by
+    void *clientData;		/* Pointer to some context that is used by
 				 * object systems. The meaning of the contents
 				 * of this field is defined by the code that
 				 * sets it, and it should only ever be set by
@@ -1294,8 +1295,7 @@ typedef struct CallFrame {
 				 * meaning of the value is, which we do not
 				 * specify. */
     LocalCache *localCachePtr;
-    Tcl_Obj    *tailcallPtr;
-				/* NULL if no tailcall is scheduled */
+    Tcl_Obj *tailcallPtr;	/* NULL if no tailcall is scheduled */
 } CallFrame;
 
 #define FRAME_IS_PROC	0x1
@@ -1384,7 +1384,7 @@ typedef struct CmdFrame {
     } data;
     Tcl_Obj *cmdObj;
     const char *cmd;		/* The executed command, if possible... */
-    Tcl_Size len;			/* ... and its length. */
+    Tcl_Size len;		/* ... and its length. */
     const struct CFWordBC *litarg;
 				/* Link to set of literal arguments which have
 				 * ben pushed on the lineLABCPtr stack by
@@ -1394,16 +1394,16 @@ typedef struct CmdFrame {
 
 typedef struct CFWord {
     CmdFrame *framePtr;		/* CmdFrame to access. */
-    Tcl_Size word;			/* Index of the word in the command. */
+    Tcl_Size word;		/* Index of the word in the command. */
     Tcl_Size refCount;		/* Number of times the word is on the
 				 * stack. */
 } CFWord;
 
 typedef struct CFWordBC {
     CmdFrame *framePtr;		/* CmdFrame to access. */
-    Tcl_Size pc;			/* Instruction pointer of a command in
+    Tcl_Size pc;		/* Instruction pointer of a command in
 				 * ExtCmdLoc.loc[.] */
-    Tcl_Size word;			/* Index of word in
+    Tcl_Size word;		/* Index of word in
 				 * ExtCmdLoc.loc[cmd]->line[.] */
     struct CFWordBC *prevPtr;	/* Previous entry in stack for same Tcl_Obj. */
     struct CFWordBC *nextPtr;	/* Next entry for same command call. See
@@ -1432,7 +1432,7 @@ typedef struct CFWordBC {
 #define CLL_END		(-1)
 
 typedef struct ContLineLoc {
-    Tcl_Size num;			/* Number of entries in loc, not counting the
+    Tcl_Size num;		/* Number of entries in loc, not counting the
 				 * final -1 marker entry. */
     Tcl_Size loc[TCLFLEXARRAY];/* Table of locations, as character offsets.
 				 * The table is allocated as part of the
@@ -1475,14 +1475,14 @@ typedef struct ContLineLoc {
 typedef Tcl_Obj * (GetFrameInfoValueProc)(void *clientData);
 typedef struct {
     const char *name;		/* Name of this field. */
-    GetFrameInfoValueProc *proc;	/* Function to generate a Tcl_Obj* from the
+    GetFrameInfoValueProc *proc;/* Function to generate a Tcl_Obj* from the
 				 * clientData, or just use the clientData
 				 * directly (after casting) if NULL. */
-    void *clientData;	/* Context for above function, or Tcl_Obj* if
+    void *clientData;		/* Context for above function, or Tcl_Obj* if
 				 * proc field is NULL. */
 } ExtraFrameInfoField;
 typedef struct {
-    Tcl_Size length;			/* Length of array. */
+    Tcl_Size length;		/* Length of array. */
     ExtraFrameInfoField fields[2];
 				/* Really as long as necessary, but this is
 				 * long enough for nearly anything. */
@@ -1605,22 +1605,22 @@ typedef struct CoroutineData {
 				 * the coroutine, which might be the
 				 * interpreter global environment or another
 				 * coroutine. */
-    CorContext caller;
-    CorContext running;
-    Tcl_HashTable *lineLABCPtr;    /* See Interp.lineLABCPtr */
+    CorContext caller;		/* Caller's saved execution context. */
+    CorContext running;		/* This coroutine's saved execution context. */
+    Tcl_HashTable *lineLABCPtr;	/* See Interp.lineLABCPtr */
     void *stackLevel;
-    Tcl_Size auxNumLevels;		/* While the coroutine is running the
+    Tcl_Size auxNumLevels;	/* While the coroutine is running the
 				 * numLevels of the create/resume command is
 				 * stored here; for suspended coroutines it
 				 * holds the nesting numLevels at yield. */
-    Tcl_Size nargs;                  /* Number of args required for resuming this
-				 * coroutine; COROUTINE_ARGUMENTS_SINGLE_OPTIONAL means "0 or 1"
-				 * (default), COROUTINE_ARGUMENTS_ARBITRARY means "any" */
+    Tcl_Size nargs;		/* Number of args required for resuming this
+				 * coroutine; COROUTINE_ARGUMENTS_SINGLE_OPTIONAL
+				 * means "0 or 1" (default),
+				 * COROUTINE_ARGUMENTS_ARBITRARY means "any" */
     Tcl_Obj *yieldPtr;		/* The command to yield to.  Stored here in
 				 * order to reset splice point in
 				 * TclNRCoroutineActivateCallback if the
-				 * coroutine is busy.
-				*/
+				 * coroutine is busy. */
 } CoroutineData;
 
 typedef struct ExecEnv {
@@ -1677,11 +1677,11 @@ typedef struct LiteralTable {
     LiteralEntry *staticBuckets[TCL_SMALL_HASH_TABLE];
 				/* Bucket array used for small tables to avoid
 				 * mallocs and frees. */
-    TCL_HASH_TYPE numBuckets; /* Total number of buckets allocated at
+    TCL_HASH_TYPE numBuckets;	/* Total number of buckets allocated at
 				 * **buckets. */
-    TCL_HASH_TYPE numEntries; /* Total number of entries present in
+    TCL_HASH_TYPE numEntries;	/* Total number of entries present in
 				 * table. */
-    TCL_HASH_TYPE rebuildSize; /* Enlarge table when numEntries gets to be
+    TCL_HASH_TYPE rebuildSize;	/* Enlarge table when numEntries gets to be
 				 * this large. */
     TCL_HASH_TYPE mask;		/* Mask value used in hashing function. */
 } LiteralTable;
@@ -1694,10 +1694,11 @@ typedef struct LiteralTable {
 
 #ifdef TCL_COMPILE_STATS
 typedef struct ByteCodeStats {
-    size_t numExecutions;		/* Number of ByteCodes executed. */
+    size_t numExecutions;	/* Number of ByteCodes executed. */
     size_t numCompilations;	/* Number of ByteCodes created. */
     size_t numByteCodesFreed;	/* Number of ByteCodes destroyed. */
-    size_t instructionCount[256];	/* Number of times each instruction was
+    size_t instructionCount[256];
+				/* Number of times each instruction was
 				 * executed. */
 
     double totalSrcBytes;	/* Total source bytes ever compiled. */
@@ -1705,7 +1706,7 @@ typedef struct ByteCodeStats {
     double currentSrcBytes;	/* Src bytes for all current ByteCodes. */
     double currentByteCodeBytes;/* Code bytes in all current ByteCodes. */
 
-    size_t srcCount[32];		/* Source size distribution: # of srcs of
+    size_t srcCount[32];	/* Source size distribution: # of srcs of
 				 * size [2**(n-1)..2**n), n in [0..32). */
     size_t byteCodeCount[32];	/* ByteCode size distribution. */
     size_t lifetimeCount[32];	/* ByteCode lifetime distribution (ms). */
@@ -1735,7 +1736,7 @@ typedef struct {
     Tcl_ObjCmdProc *proc;	/* The implementation of the subcommand. */
     CompileProc *compileProc;	/* The compiler for the subcommand. */
     Tcl_ObjCmdProc *nreProc;	/* NRE implementation of this command. */
-    void *clientData;	/* Any clientData to give the command. */
+    void *clientData;		/* Any clientData to give the command. */
     int unsafe;			/* Whether this command is to be hidden by
 				 * default in a safe interpreter. */
 } EnsembleImplMap;
@@ -1814,11 +1815,11 @@ typedef struct Command {
     Tcl_ObjCmdProc *objProc;	/* Object-based command procedure. */
     void *objClientData;	/* Arbitrary value passed to object proc. */
     Tcl_CmdProc *proc;		/* String-based command procedure. */
-    void *clientData;	/* Arbitrary value passed to string proc. */
+    void *clientData;		/* Arbitrary value passed to string proc. */
     Tcl_CmdDeleteProc *deleteProc;
 				/* Procedure invoked when deleting command to,
 				 * e.g., free all client data. */
-    void *deleteData;	/* Arbitrary value passed to deleteProc. */
+    void *deleteData;		/* Arbitrary value passed to deleteProc. */
     int flags;			/* Miscellaneous bits of information about
 				 * command. See below for definitions. */
     ImportRef *importRefPtr;	/* List of each imported Command created in
@@ -1857,14 +1858,13 @@ typedef struct Command {
  * (these last two flags are defined in tcl.h)
  */
 
-#define CMD_DYING		    0x01
-#define CMD_TRACE_ACTIVE	    0x02
-#define CMD_HAS_EXEC_TRACES	    0x04
-#define CMD_COMPILES_EXPANDED	    0x08
-#define CMD_REDEF_IN_PROGRESS	    0x10
-#define CMD_VIA_RESOLVER	    0x20
-#define CMD_DEAD                    0x40
-
+#define CMD_DYING		0x01
+#define CMD_TRACE_ACTIVE	0x02
+#define CMD_HAS_EXEC_TRACES	0x04
+#define CMD_COMPILES_EXPANDED	0x08
+#define CMD_REDEF_IN_PROGRESS	0x10
+#define CMD_VIA_RESOLVER	0x20
+#define CMD_DEAD		0x40
 
 /*
  *----------------------------------------------------------------
@@ -1964,8 +1964,7 @@ typedef struct Interp {
 				 * enabled extensions check for a NULL pointer value
 				 * and for a TCL_STUBS_MAGIC value to verify they
 				 * are not [load]ing into one of those pre-stubs
-				 * interps.
-				 */
+				 * interps. */
 
     TclHandle handle;		/* Handle used to keep track of when this
 				 * interp is deleted. */
@@ -1975,7 +1974,7 @@ typedef struct Interp {
 				/* Hash table used by tclBasic.c to keep track
 				 * of hidden commands on a per-interp
 				 * basis. */
-    void *interpInfo;	/* Information used by tclInterp.c to keep
+    void *interpInfo;		/* Information used by tclInterp.c to keep
 				 * track of parent/child interps on a
 				 * per-interp basis. */
 #if TCL_MAJOR_VERSION > 8
@@ -2054,7 +2053,7 @@ typedef struct Interp {
 				 * compiled by the interpreter. Indexed by the
 				 * string representations of literals. Used to
 				 * avoid creating duplicate objects. */
-    Tcl_Size compileEpoch;		/* Holds the current "compilation epoch" for
+    Tcl_Size compileEpoch;	/* Holds the current "compilation epoch" for
 				 * this interpreter. This is incremented to
 				 * invalidate existing ByteCodes when, e.g., a
 				 * command with a compile procedure is
@@ -2064,8 +2063,7 @@ typedef struct Interp {
 				 * NULL. Set by ObjInterpProc in tclProc.c and
 				 * used by tclCompile.c to process local
 				 * variables appropriately. */
-    ResolverScheme *resolverPtr;
-				/* Linked list of name resolution schemes
+    ResolverScheme *resolverPtr;/* Linked list of name resolution schemes
 				 * added to this interpreter. Schemes are
 				 * added and removed by calling
 				 * Tcl_AddInterpResolvers and
@@ -2100,8 +2098,8 @@ typedef struct Interp {
     ActiveInterpTrace *activeInterpTracePtr;
 				/* First in list of active traces for interp,
 				 * or NULL if no active traces. */
-
-    Tcl_Size tracesForbiddingInline;	/* Count of traces (in the list headed by
+    Tcl_Size tracesForbiddingInline;
+				/* Count of traces (in the list headed by
 				 * tracePtr) that forbid inline bytecode
 				 * compilation. */
 
@@ -2131,7 +2129,7 @@ typedef struct Interp {
 				 * as flag values the same as the 'active'
 				 * field. */
 
-	Tcl_Size cmdCount;		/* Limit for how many commands to execute in
+	Tcl_Size cmdCount;	/* Limit for how many commands to execute in
 				 * the interpreter. */
 	LimitHandler *cmdHandlers;
 				/* Handlers to execute when the limit is
@@ -2167,9 +2165,9 @@ typedef struct Interp {
 				 * *root* ensemble command? (Nested ensembles
 				 * don't rewrite this.) NULL if we're not
 				 * processing an ensemble. */
-	Tcl_Size numRemovedObjs;	/* How many arguments have been stripped off
+	Tcl_Size numRemovedObjs;/* How many arguments have been stripped off
 				 * because of ensemble processing. */
-	Tcl_Size numInsertedObjs;	/* How many of the current arguments were
+	Tcl_Size numInsertedObjs;/* How many of the current arguments were
 				 * inserted by an ensemble. */
     } ensembleRewrite;
 
@@ -2208,7 +2206,7 @@ typedef struct Interp {
 				 * Proc structure for a procedure. The values
 				 * are "struct ExtCmdLoc*". (See
 				 * tclCompile.h) */
-    Tcl_HashTable *lineLABCPtr;
+    Tcl_HashTable *lineLABCPtr;	/* Tcl_Obj* (by exact pointer) -> CFWordBC* */
     Tcl_HashTable *lineLAPtr;	/* This table remembers for each argument of a
 				 * command on the execution stack the index of
 				 * the argument in the command, and the
@@ -2229,8 +2227,7 @@ typedef struct Interp {
 				 * used by function ...() in the same file.
 				 * It does for the eval/direct path of script
 				 * execution what CompileEnv.clLoc does for
-				 * the bytecode compiler.
-				 */
+				 * the bytecode compiler. */
     /*
      * TIP #268. The currently active selection mode, i.e. the package require
      * preferences.
@@ -2302,7 +2299,7 @@ typedef struct Interp {
     Tcl_Obj *callLiteral;	/* "CALL" literal for [info errorstack] */
     Tcl_Obj *innerLiteral;	/* "INNER" literal for [info errorstack] */
     Tcl_Obj *innerContext;	/* cached list for fast reallocation */
-    int resetErrorStack;        /* controls cleaning up of ::errorStack */
+    int resetErrorStack;	/* controls cleaning up of ::errorStack */
 
 #ifdef TCL_COMPILE_STATS
     /*
@@ -2329,10 +2326,10 @@ typedef struct Interp {
 #define TclCanceled(iPtr) \
     (((iPtr)->flags & CANCELED) || ((iPtr)->flags & TCL_CANCEL_UNWIND))
 
-#define TclSetCancelFlags(iPtr, cancelFlags)   \
-    (iPtr)->flags |= CANCELED;                 \
-    if ((cancelFlags) & TCL_CANCEL_UNWIND) {   \
-        (iPtr)->flags |= TCL_CANCEL_UNWIND;    \
+#define TclSetCancelFlags(iPtr, cancelFlags) \
+    (iPtr)->flags |= CANCELED;			\
+    if ((cancelFlags) & TCL_CANCEL_UNWIND) {	\
+	(iPtr)->flags |= TCL_CANCEL_UNWIND;	\
     }
 
 #define TclUnsetCancelFlags(iPtr) \
@@ -2494,7 +2491,8 @@ struct TclMaxAlignment {
  */
 
 #define TclOOM(ptr, size) \
-	((size) && ((ptr)||(Tcl_Panic("unable to alloc %" TCL_Z_MODIFIER "u bytes", (size_t)(size)),1)))
+    ((size) && ((ptr) || (Tcl_Panic(					\
+	"unable to alloc %" TCL_Z_MODIFIER "u bytes", (size_t)(size)), 1)))
 
 /*
  * The following enum values are used to specify the runtime platform setting
@@ -2564,36 +2562,38 @@ typedef enum TclEolTranslation {
  *
  */
 typedef struct ListStore {
-    Tcl_Size firstUsed;    /* Index of first slot in use within slots[] */
-    Tcl_Size numUsed;      /* Number of slots in use (starting firstUsed) */
-    Tcl_Size numAllocated; /* Total number of slots[] array slots. */
-    size_t refCount;           /* Number of references to this instance */
-    int flags;              /* LISTSTORE_* flags */
-    Tcl_Obj *slots[TCLFLEXARRAY];      /* Variable size array. Grown as needed */
+    Tcl_Size firstUsed;		/* Index of first slot in use within slots[] */
+    Tcl_Size numUsed;		/* Number of slots in use (starting firstUsed) */
+    Tcl_Size numAllocated;	/* Total number of slots[] array slots. */
+    size_t refCount;		/* Number of references to this instance. */
+    int flags;			/* LISTSTORE_* flags */
+    Tcl_Obj *slots[TCLFLEXARRAY];
+				/* Variable size array. Grown as needed */
 } ListStore;
 
 #define LISTSTORE_CANONICAL 0x1 /* All Tcl_Obj's referencing this
-                                   store have their string representation
-                                   derived from the list representation */
+				 * store have their string representation
+				 * derived from the list representation */
 
 /* Max number of elements that can be contained in a list */
-#define LIST_MAX                                               \
-    ((Tcl_Size)(((size_t)TCL_SIZE_MAX - offsetof(ListStore, slots)) \
-		   / sizeof(Tcl_Obj *)))
+#define LIST_MAX \
+    ((Tcl_Size)(((size_t)TCL_SIZE_MAX - offsetof(ListStore, slots))	\
+	    / sizeof(Tcl_Obj *)))
 /* Memory size needed for a ListStore to hold numSlots_ elements */
 #define LIST_SIZE(numSlots_) \
-	((Tcl_Size)(offsetof(ListStore, slots) + ((numSlots_) * sizeof(Tcl_Obj *))))
+    ((Tcl_Size)(offsetof(ListStore, slots)				\
+	    + ((numSlots_) * sizeof(Tcl_Obj *))))
 
 /*
  * ListSpan --
  * See comments above for ListStore
  */
 typedef struct ListSpan {
-    Tcl_Size spanStart;    /* Starting index of the span */
-    Tcl_Size spanLength;   /* Number of elements in the span */
-    size_t refCount;     /* Count of references to this span record */
+    Tcl_Size spanStart;		/* Starting index of the span. */
+    Tcl_Size spanLength;	/* Number of elements in the span. */
+    size_t refCount;		/* Count of references to this span record. */
 } ListSpan;
-#ifndef LIST_SPAN_THRESHOLD /* May be set on build line */
+#ifndef LIST_SPAN_THRESHOLD	/* May be set on build line */
 #define LIST_SPAN_THRESHOLD 101
 #endif
 
@@ -2602,9 +2602,11 @@ typedef struct ListSpan {
  * See comments above for ListStore
  */
 typedef struct ListRep {
-    ListStore *storePtr;/* element array shared amongst different lists */
-    ListSpan *spanPtr;  /* If not NULL, the span holds the range of slots
-                           within *storePtr that contain this list elements. */
+    ListStore *storePtr;	/* element array shared amongst different
+				 * lists */
+    ListSpan *spanPtr;		/* If not NULL, the span holds the range of
+				 * slots within *storePtr that contain this
+				 * list elements. */
 } ListRep;
 
 /*
@@ -2620,14 +2622,16 @@ typedef struct ListRep {
  */
 
 /* Returns the starting slot for this listRep in the contained ListStore */
-#define ListRepStart(listRepPtr_)                               \
-    ((listRepPtr_)->spanPtr ? (listRepPtr_)->spanPtr->spanStart \
-			    : (listRepPtr_)->storePtr->firstUsed)
+#define ListRepStart(listRepPtr_) \
+    ((listRepPtr_)->spanPtr						\
+	? (listRepPtr_)->spanPtr->spanStart				\
+	: (listRepPtr_)->storePtr->firstUsed)
 
 /* Returns the number of elements in this listRep */
-#define ListRepLength(listRepPtr_)                               \
-    ((listRepPtr_)->spanPtr ? (listRepPtr_)->spanPtr->spanLength \
-			    : (listRepPtr_)->storePtr->numUsed)
+#define ListRepLength(listRepPtr_) \
+    ((listRepPtr_)->spanPtr						\
+	? (listRepPtr_)->spanPtr->spanLength				\
+	: (listRepPtr_)->storePtr->numUsed)
 
 /* Returns a pointer to the first slot containing this ListRep elements */
 #define ListRepElementsBase(listRepPtr_) \
@@ -2635,7 +2639,7 @@ typedef struct ListRep {
 
 /* Stores the number of elements and base address of the element array */
 #define ListRepElements(listRepPtr_, objc_, objv_) \
-    (((objv_) = ListRepElementsBase(listRepPtr_)), \
+    (((objv_) = ListRepElementsBase(listRepPtr_)),			\
      ((objc_) = ListRepLength(listRepPtr_)))
 
 /* Returns 1/0 whether the ListRep's ListStore is shared. */
@@ -2650,34 +2654,36 @@ typedef struct ListRep {
     ((ListSpan *)((listObj_)->internalRep.twoPtrValue.ptr2))
 
 /* Returns the ListRep internal representaton in a Tcl_Obj */
-#define ListObjGetRep(listObj_, listRepPtr_)                 \
-    do {                                                     \
-	(listRepPtr_)->storePtr = ListObjStorePtr(listObj_); \
-	(listRepPtr_)->spanPtr = ListObjSpanPtr(listObj_);   \
+#define ListObjGetRep(listObj_, listRepPtr_) \
+    do {								\
+	(listRepPtr_)->storePtr = ListObjStorePtr(listObj_);		\
+	(listRepPtr_)->spanPtr = ListObjSpanPtr(listObj_);		\
     } while (0)
 
 /* Returns the length of the list */
-#define ListObjLength(listObj_, len_)                                         \
-    ((len_) = ListObjSpanPtr(listObj_) ? ListObjSpanPtr(listObj_)->spanLength \
-				       : ListObjStorePtr(listObj_)->numUsed)
+#define ListObjLength(listObj_, len_) \
+    ((len_) = ListObjSpanPtr(listObj_)					\
+	? ListObjSpanPtr(listObj_)->spanLength				\
+	: ListObjStorePtr(listObj_)->numUsed)
 
 /* Returns the starting slot index of this list's elements in the ListStore */
-#define ListObjStart(listObj_)                                      \
-    (ListObjSpanPtr(listObj_) ? ListObjSpanPtr(listObj_)->spanStart \
-			      : ListObjStorePtr(listObj_)->firstUsed)
+#define ListObjStart(listObj_) \
+    (ListObjSpanPtr(listObj_)						\
+	? ListObjSpanPtr(listObj_)->spanStart				\
+	: ListObjStorePtr(listObj_)->firstUsed)
 
 /* Stores the element count and base address of this list's elements */
 #define ListObjGetElements(listObj_, objc_, objv_) \
     (((objv_) = &ListObjStorePtr(listObj_)->slots[ListObjStart(listObj_)]), \
      (ListObjLength(listObj_, (objc_))))
 
-
 /*
  * Returns 1/0 whether the internal representation (not the Tcl_Obj itself)
  * is shared.  Note by intent this only checks for sharing of ListStore,
  * not spans.
  */
-#define ListObjRepIsShared(listObj_) (ListObjStorePtr(listObj_)->refCount > 1)
+#define ListObjRepIsShared(listObj_) \
+    (ListObjStorePtr(listObj_)->refCount > 1)
 
 /*
  * Certain commands like concat are optimized if an existing string
@@ -2694,10 +2700,10 @@ typedef struct ListRep {
  * and never from strings (see SetListFromAny) and thus their string
  * representation will always be canonical.
  */
-#define ListObjIsCanonical(listObj_)                             \
-    (((listObj_)->bytes == NULL)                                 \
-     || (ListObjStorePtr(listObj_)->flags & LISTSTORE_CANONICAL) \
-     || ListObjSpanPtr(listObj_) != NULL)
+#define ListObjIsCanonical(listObj_) \
+    (((listObj_)->bytes == NULL)					\
+	|| (ListObjStorePtr(listObj_)->flags & LISTSTORE_CANONICAL)	\
+	|| ListObjSpanPtr(listObj_) != NULL)
 
 /*
  * Converts the Tcl_Obj to a list if it isn't one and stores the element
@@ -2705,25 +2711,27 @@ typedef struct ListRep {
  * Return TCL_OK on success or TCL_ERROR if the Tcl_Obj cannot be
  * converted to a list.
  */
-#define TclListObjGetElements(interp_, listObj_, objcPtr_, objvPtr_)    \
-    ((TclHasInternalRep((listObj_), &tclListType))                              \
-	 ? ((ListObjGetElements((listObj_), *(objcPtr_), *(objvPtr_))), \
-	    TCL_OK)                                                     \
-	 : Tcl_ListObjGetElements(                                      \
-	     (interp_), (listObj_), (objcPtr_), (objvPtr_)))
+#define TclListObjGetElements(interp_, listObj_, objcPtr_, objvPtr_) \
+    ((TclHasInternalRep((listObj_), &tclListType))			\
+	? ((ListObjGetElements((listObj_), *(objcPtr_), *(objvPtr_))),	\
+	    TCL_OK)							\
+	: Tcl_ListObjGetElements(					\
+	    (interp_), (listObj_), (objcPtr_), (objvPtr_)))
 
 /*
  * Converts the Tcl_Obj to a list if it isn't one and stores the element
  * count in lenPtr_.  Returns TCL_OK on success or TCL_ERROR if the
  * Tcl_Obj cannot be converted to a list.
  */
-#define TclListObjLength(interp_, listObj_, lenPtr_)         \
-    ((TclHasInternalRep((listObj_), &tclListType))                   \
-	 ? ((ListObjLength((listObj_), *(lenPtr_))), TCL_OK) \
-	 : Tcl_ListObjLength((interp_), (listObj_), (lenPtr_)))
+#define TclListObjLength(interp_, listObj_, lenPtr_) \
+    ((TclHasInternalRep((listObj_), &tclListType))			\
+	? ((ListObjLength((listObj_), *(lenPtr_))), TCL_OK)		\
+	: Tcl_ListObjLength((interp_), (listObj_), (lenPtr_)))
 
 #define TclListObjIsCanonical(listObj_) \
-    ((TclHasInternalRep((listObj_), &tclListType)) ? ListObjIsCanonical((listObj_)) : 0)
+    ((TclHasInternalRep((listObj_), &tclListType))			\
+	? ListObjIsCanonical((listObj_))				\
+	: 0)
 
 /*
  * Modes for collecting (or not) in the implementations of TclNRForeachCmd,
@@ -2743,44 +2751,45 @@ typedef struct ListRep {
 
 #if TCL_MAJOR_VERSION > 8
 #define TclGetBooleanFromObj(interp, objPtr, intPtr) \
-    ((TclHasInternalRep((objPtr), &tclIntType) \
-	    || TclHasInternalRep((objPtr), &tclBooleanType)) \
+    ((TclHasInternalRep((objPtr), &tclIntType)				\
+	    || TclHasInternalRep((objPtr), &tclBooleanType))		\
 	? (*(intPtr) = ((objPtr)->internalRep.wideValue!=0), TCL_OK)	\
 	: Tcl_GetBooleanFromObj((interp), (objPtr), (intPtr)))
 #else
 #define TclGetBooleanFromObj(interp, objPtr, intPtr) \
-    ((TclHasInternalRep((objPtr), &tclIntType))			\
+    ((TclHasInternalRep((objPtr), &tclIntType))				\
 	? (*(intPtr) = ((objPtr)->internalRep.wideValue!=0), TCL_OK)	\
-	: (TclHasInternalRep((objPtr), &tclBooleanType))			\
+	: (TclHasInternalRep((objPtr), &tclBooleanType))		\
 	? (*(intPtr) = ((objPtr)->internalRep.longValue!=0), TCL_OK)	\
 	: Tcl_GetBooleanFromObj((interp), (objPtr), (intPtr)))
 #endif
 
 #ifdef TCL_WIDE_INT_IS_LONG
 #define TclGetLongFromObj(interp, objPtr, longPtr) \
-    ((TclHasInternalRep((objPtr), &tclIntType))	\
-	    ? ((*(longPtr) = (objPtr)->internalRep.wideValue), TCL_OK) \
-	    : Tcl_GetLongFromObj((interp), (objPtr), (longPtr)))
+    ((TclHasInternalRep((objPtr), &tclIntType))				\
+	? ((*(longPtr) = (objPtr)->internalRep.wideValue), TCL_OK)	\
+	: Tcl_GetLongFromObj((interp), (objPtr), (longPtr)))
 #else
 #define TclGetLongFromObj(interp, objPtr, longPtr) \
-    ((TclHasInternalRep((objPtr), &tclIntType) \
+    ((TclHasInternalRep((objPtr), &tclIntType)				\
 	    && (objPtr)->internalRep.wideValue >= (Tcl_WideInt)(LONG_MIN) \
 	    && (objPtr)->internalRep.wideValue <= (Tcl_WideInt)(LONG_MAX)) \
-	    ? ((*(longPtr) = (long)(objPtr)->internalRep.wideValue), TCL_OK) \
-	    : Tcl_GetLongFromObj((interp), (objPtr), (longPtr)))
+	? ((*(longPtr) = (long)(objPtr)->internalRep.wideValue), TCL_OK) \
+	: Tcl_GetLongFromObj((interp), (objPtr), (longPtr)))
 #endif
 
 #define TclGetIntFromObj(interp, objPtr, intPtr) \
-    ((TclHasInternalRep((objPtr), &tclIntType) \
+    ((TclHasInternalRep((objPtr), &tclIntType)				\
 	    && (objPtr)->internalRep.wideValue >= (Tcl_WideInt)(INT_MIN) \
 	    && (objPtr)->internalRep.wideValue <= (Tcl_WideInt)(INT_MAX)) \
-	    ? ((*(intPtr) = (int)(objPtr)->internalRep.wideValue), TCL_OK) \
-	    : Tcl_GetIntFromObj((interp), (objPtr), (intPtr)))
+	? ((*(intPtr) = (int)(objPtr)->internalRep.wideValue), TCL_OK)	\
+	: Tcl_GetIntFromObj((interp), (objPtr), (intPtr)))
 #define TclGetIntForIndexM(interp, objPtr, endValue, idxPtr) \
-    (((TclHasInternalRep((objPtr), &tclIntType)) && ((objPtr)->internalRep.wideValue >= 0) \
-	    && ((objPtr)->internalRep.wideValue <= endValue)) \
-	    ? ((*(idxPtr) = (objPtr)->internalRep.wideValue), TCL_OK) \
-	    : Tcl_GetIntForIndex((interp), (objPtr), (endValue), (idxPtr)))
+    (((TclHasInternalRep((objPtr), &tclIntType))			\
+	    && ((objPtr)->internalRep.wideValue >= 0)			\
+	    && ((objPtr)->internalRep.wideValue <= endValue))		\
+	? ((*(idxPtr) = (objPtr)->internalRep.wideValue), TCL_OK)	\
+	: Tcl_GetIntForIndex((interp), (objPtr), (endValue), (idxPtr)))
 
 /*
  * Macro used to save a function call for common uses of
@@ -2791,10 +2800,9 @@ typedef struct ListRep {
  */
 
 #define TclGetWideIntFromObj(interp, objPtr, wideIntPtr) \
-    ((TclHasInternalRep((objPtr), &tclIntType))					\
-	? (*(wideIntPtr) =						\
-		((objPtr)->internalRep.wideValue), TCL_OK) :		\
-	Tcl_GetWideIntFromObj((interp), (objPtr), (wideIntPtr)))
+    ((TclHasInternalRep((objPtr), &tclIntType))				\
+	? (*(wideIntPtr) = ((objPtr)->internalRep.wideValue), TCL_OK)	\
+	: Tcl_GetWideIntFromObj((interp), (objPtr), (wideIntPtr)))
 
 /*
  * Flag values for TclTraceDictPath().
@@ -2839,7 +2847,8 @@ typedef struct ListRep {
 #define TCL_FILESYSTEM_VERSION_2	((Tcl_FSVersion) 0x2)
 typedef void *(TclFSGetCwdProc2)(void *clientData);
 typedef int (Tcl_FSLoadFileProc2) (Tcl_Interp *interp, Tcl_Obj *pathPtr,
-	Tcl_LoadHandle *handlePtr, Tcl_FSUnloadFileProc **unloadProcPtr, int flags);
+	Tcl_LoadHandle *handlePtr, Tcl_FSUnloadFileProc **unloadProcPtr,
+	int flags);
 
 /*
  * The following types are used for getting and storing platform-specific file
@@ -2890,13 +2899,14 @@ typedef Tcl_Channel (TclOpenFileChannelProc_)(Tcl_Interp *interp,
  *----------------------------------------------------------------
  */
 
-typedef void (TclInitProcessGlobalValueProc)(char **valuePtr, TCL_HASH_TYPE *lengthPtr,
+typedef void (TclInitProcessGlobalValueProc)(char **valuePtr,
+	TCL_HASH_TYPE *lengthPtr,
 	Tcl_Encoding *encodingPtr);
 
 #ifdef _WIN32
 #   define TCLFSENCODING tclUtf8Encoding /* On Windows, all Unicode (except surrogates) are valid */
 #else
-#   define TCLFSENCODING NULL /* On Non-Windows, use the system encoding for validation checks */
+#   define TCLFSENCODING NULL	/* On Non-Windows, use the system encoding for validation checks */
 #endif
 
 /*
@@ -2908,7 +2918,7 @@ typedef void (TclInitProcessGlobalValueProc)(char **valuePtr, TCL_HASH_TYPE *len
  */
 
 typedef struct ProcessGlobalValue {
-    Tcl_Size epoch;			/* Epoch counter to detect changes in the
+    Tcl_Size epoch;		/* Epoch counter to detect changes in the
 				 * global value. */
     TCL_HASH_TYPE numBytes;	/* Length of the global string. */
     char *value;		/* The global string value. */
@@ -2930,26 +2940,25 @@ typedef struct ProcessGlobalValue {
  *----------------------------------------------------------------------
  */
 
-#define TCL_PARSE_DECIMAL_ONLY		1
+#define TCL_PARSE_DECIMAL_ONLY	1
 				/* Leading zero doesn't denote octal or
 				 * hex. */
-#define TCL_PARSE_OCTAL_ONLY		2
+#define TCL_PARSE_OCTAL_ONLY	2
 				/* Parse octal even without prefix. */
 #define TCL_PARSE_HEXADECIMAL_ONLY	4
 				/* Parse hexadecimal even without prefix. */
-#define TCL_PARSE_INTEGER_ONLY		8
+#define TCL_PARSE_INTEGER_ONLY	8
 				/* Disable floating point parsing. */
-#define TCL_PARSE_SCAN_PREFIXES		16
+#define TCL_PARSE_SCAN_PREFIXES	16
 				/* Use [scan] rules dealing with 0?
 				 * prefixes. */
-#define TCL_PARSE_NO_WHITESPACE		32
+#define TCL_PARSE_NO_WHITESPACE	32
 				/* Reject leading/trailing whitespace. */
 #define TCL_PARSE_BINARY_ONLY	64
 				/* Parse binary even without prefix. */
 #define TCL_PARSE_NO_UNDERSCORE	128
 				/* Reject underscore digit separator */
 
-
 /*
  *----------------------------------------------------------------------
  * Internal convenience macros for manipulating encoding flags. See
@@ -2958,11 +2967,12 @@ typedef struct ProcessGlobalValue {
  */
 
 #define ENCODING_PROFILE_MASK     0xFF000000
-#define ENCODING_PROFILE_GET(flags_)  ((flags_) & ENCODING_PROFILE_MASK)
-#define ENCODING_PROFILE_SET(flags_, profile_)       \
-    do {                                             \
-	(flags_) &= ~ENCODING_PROFILE_MASK;              \
-	(flags_) |= ((profile_) & ENCODING_PROFILE_MASK);\
+#define ENCODING_PROFILE_GET(flags_) \
+    ((flags_) & ENCODING_PROFILE_MASK)
+#define ENCODING_PROFILE_SET(flags_, profile_) \
+    do {								\
+	(flags_) &= ~ENCODING_PROFILE_MASK;				\
+	(flags_) |= ((profile_) & ENCODING_PROFILE_MASK);		\
     } while (0)
 
 /*
@@ -2977,22 +2987,26 @@ typedef struct ProcessGlobalValue {
  *----------------------------------------------------------------------
  */
 static inline Tcl_Size
-TclUpsizeAlloc(TCL_UNUSED(Tcl_Size) /* oldSize. For future experiments with
-				     * some growth algorithms that use this
-				     * information. */,
-	       Tcl_Size needed,
-	       Tcl_Size limit)
+TclUpsizeAlloc(
+    TCL_UNUSED(Tcl_Size),	/* oldSize. For future experiments with
+				 * some growth algorithms that use this
+				 * information. */
+    Tcl_Size needed,
+    Tcl_Size limit)
 {
     /* assert (oldCapacity < needed <= limit) */
     if (needed < (limit - needed/2)) {
 	return needed + needed / 2;
-    }
-    else {
+    } else {
 	return limit;
     }
 }
-static inline Tcl_Size TclUpsizeRetry(Tcl_Size needed, Tcl_Size lastAttempt) {
-	/* assert (needed < lastAttempt) */
+static inline Tcl_Size
+TclUpsizeRetry(
+    Tcl_Size needed,
+    Tcl_Size lastAttempt)
+{
+    /* assert(needed < lastAttempt); */
     if (needed < lastAttempt - 1) {
 	/* (needed+lastAttempt)/2 but that formula may overflow Tcl_Size */
 	return needed + (lastAttempt - needed) / 2;
@@ -3000,37 +3014,58 @@ static inline Tcl_Size TclUpsizeRetry(Tcl_Size needed, Tcl_Size lastAttempt) {
 	return needed;
     }
 }
-MODULE_SCOPE void *TclAllocElemsEx(Tcl_Size elemCount, Tcl_Size elemSize,
-			Tcl_Size leadSize, Tcl_Size *capacityPtr);
-MODULE_SCOPE void *TclReallocElemsEx(void *oldPtr, Tcl_Size elemCount,
-			Tcl_Size elemSize, Tcl_Size leadSize,
-			Tcl_Size *capacityPtr);
-MODULE_SCOPE void *TclAttemptReallocElemsEx(void *oldPtr,
-			Tcl_Size elemCount, Tcl_Size elemSize,
-			Tcl_Size leadSize, Tcl_Size *capacityPtr);
+MODULE_SCOPE void *	TclAllocElemsEx(Tcl_Size elemCount, Tcl_Size elemSize,
+			    Tcl_Size leadSize, Tcl_Size *capacityPtr);
+MODULE_SCOPE void *	TclReallocElemsEx(void *oldPtr, Tcl_Size elemCount,
+			    Tcl_Size elemSize, Tcl_Size leadSize,
+			    Tcl_Size *capacityPtr);
+MODULE_SCOPE void *	TclAttemptReallocElemsEx(void *oldPtr,
+			    Tcl_Size elemCount, Tcl_Size elemSize,
+			    Tcl_Size leadSize, Tcl_Size *capacityPtr);
 /* Alloc elemCount elements of size elemSize with leadSize header
  * returning actual capacity (in elements) in *capacityPtr. */
-static inline void *TclAttemptAllocElemsEx(Tcl_Size elemCount, Tcl_Size elemSize,
-			Tcl_Size leadSize, Tcl_Size *capacityPtr) {
+static inline void *
+TclAttemptAllocElemsEx(
+    Tcl_Size elemCount,
+    Tcl_Size elemSize,
+    Tcl_Size leadSize,
+    Tcl_Size *capacityPtr)
+{
     return TclAttemptReallocElemsEx(
-	NULL, elemCount, elemSize, leadSize, capacityPtr);
+	    NULL, elemCount, elemSize, leadSize, capacityPtr);
 }
 /* Alloc numByte bytes, returning actual capacity in *capacityPtr. */
-static inline void *TclAllocEx(Tcl_Size numBytes, Tcl_Size *capacityPtr) {
+static inline void *
+TclAllocEx(
+    Tcl_Size numBytes,
+    Tcl_Size *capacityPtr)
+{
     return TclAllocElemsEx(numBytes, 1, 0, capacityPtr);
 }
 /* Alloc numByte bytes, returning actual capacity in *capacityPtr. */
 static inline void *
-TclAttemptAllocEx(Tcl_Size numBytes, Tcl_Size *capacityPtr)
+TclAttemptAllocEx(
+    Tcl_Size numBytes,
+    Tcl_Size *capacityPtr)
 {
     return TclAttemptAllocElemsEx(numBytes, 1, 0, capacityPtr);
 }
 /* Realloc numByte bytes, returning actual capacity in *capacityPtr. */
-static inline void *TclReallocEx(void *oldPtr, Tcl_Size numBytes, Tcl_Size *capacityPtr) {
+static inline void *
+TclReallocEx(
+    void *oldPtr,
+    Tcl_Size numBytes,
+    Tcl_Size *capacityPtr)
+{
     return TclReallocElemsEx(oldPtr, numBytes, 1, 0, capacityPtr);
 }
 /* Realloc numByte bytes, returning actual capacity in *capacityPtr. */
-static inline void *TclAttemptReallocEx(void *oldPtr, Tcl_Size numBytes, Tcl_Size *capacityPtr) {
+static inline void *
+TclAttemptReallocEx(
+    void *oldPtr,
+    Tcl_Size numBytes,
+    Tcl_Size *capacityPtr)
+{
     return TclAttemptReallocElemsEx(oldPtr, numBytes, 1, 0, capacityPtr);
 }
 
@@ -3051,13 +3086,12 @@ MODULE_SCOPE TclPlatformType tclPlatform;
 
 MODULE_SCOPE Tcl_Encoding tclIdentityEncoding;
 MODULE_SCOPE Tcl_Encoding tclUtf8Encoding;
-MODULE_SCOPE int
-TclEncodingProfileNameToId(Tcl_Interp *interp,
-			   const char *profileName,
-			   int *profilePtr);
+MODULE_SCOPE int	TclEncodingProfileNameToId(Tcl_Interp *interp,
+			    const char *profileName,
+			    int *profilePtr);
 MODULE_SCOPE const char *TclEncodingProfileIdToName(Tcl_Interp *interp,
-						    int profileId);
-MODULE_SCOPE void TclGetEncodingProfiles(Tcl_Interp *interp);
+			    int profileId);
+MODULE_SCOPE void	TclGetEncodingProfiles(Tcl_Interp *interp);
 
 /*
  * TIP #233 (Virtualized Time)
@@ -3155,12 +3189,13 @@ MODULE_SCOPE Tcl_ObjCmdProc TclNRYieldToObjCmd;
 MODULE_SCOPE Tcl_ObjCmdProc TclNRInvoke;
 MODULE_SCOPE Tcl_NRPostProc TclNRReleaseValues;
 
-MODULE_SCOPE void  TclSetTailcall(Tcl_Interp *interp, Tcl_Obj *tailcallPtr);
-MODULE_SCOPE void  TclPushTailcallPoint(Tcl_Interp *interp);
+MODULE_SCOPE void	TclSetTailcall(Tcl_Interp *interp,
+			    Tcl_Obj *tailcallPtr);
+MODULE_SCOPE void	TclPushTailcallPoint(Tcl_Interp *interp);
 
 /* These two can be considered for the public api */
-MODULE_SCOPE void  TclMarkTailcall(Tcl_Interp *interp);
-MODULE_SCOPE void  TclSkipTailcall(Tcl_Interp *interp);
+MODULE_SCOPE void	TclMarkTailcall(Tcl_Interp *interp);
+MODULE_SCOPE void	TclSkipTailcall(Tcl_Interp *interp);
 
 /*
  * This structure holds the data for the various iteration callbacks used to
@@ -3177,7 +3212,7 @@ typedef struct ForIterData {
     Tcl_Obj *body;		/* Loop body. */
     Tcl_Obj *next;		/* Loop step script, NULL for 'while'. */
     const char *msg;		/* Error message part. */
-    Tcl_Size word;			/* Index of the body script in the command */
+    Tcl_Size word;		/* Index of the body script in the command */
 } ForIterData;
 
 /* TIP #357 - Structure doing the bookkeeping of handles for Tcl_LoadFile
@@ -3185,9 +3220,9 @@ typedef struct ForIterData {
  *            typedef in tcl.h */
 
 typedef void* TclFindSymbolProc(Tcl_Interp* interp, Tcl_LoadHandle loadHandle,
-				const char* symbol);
+	const char* symbol);
 struct Tcl_LoadHandle_ {
-    void *clientData;	/* Client data is the load handle in the
+    void *clientData;		/* Client data is the load handle in the
 				 * native filesystem if a module was loaded
 				 * there, or an opaque pointer to a structure
 				 * for further bookkeeping on load-from-VFS
@@ -3201,16 +3236,12 @@ struct Tcl_LoadHandle_ {
 
 /* Flags for conversion of doubles to digit strings */
 
-#define TCL_DD_E_FORMAT 		0x2
-				/* Use a fixed-length string of digits,
+#define TCL_DD_E_FORMAT 0x2	/* Use a fixed-length string of digits,
 				 * suitable for E format*/
-#define TCL_DD_F_FORMAT 		0x3
-				/* Use a fixed number of digits after the
+#define TCL_DD_F_FORMAT 0x3	/* Use a fixed number of digits after the
 				 * decimal point, suitable for F format */
-#define TCL_DD_SHORTEST 		0x4
-				/* Use the shortest possible string */
-#define TCL_DD_NO_QUICK 		0x8
-				/* Debug flag: forbid quick FP conversion */
+#define TCL_DD_SHORTEST 0x4	/* Use the shortest possible string */
+#define TCL_DD_NO_QUICK 0x8	/* Debug flag: forbid quick FP conversion */
 
 #define TCL_DD_CONVERSION_TYPE_MASK	0x3
 				/* Mask to isolate the conversion type */
@@ -3236,7 +3267,8 @@ MODULE_SCOPE void	TclArgumentRelease(Tcl_Interp *interp,
 			    Tcl_Obj *objv[], int objc);
 MODULE_SCOPE void	TclArgumentBCEnter(Tcl_Interp *interp,
 			    Tcl_Obj *objv[], int objc,
-			    void *codePtr, CmdFrame *cfPtr, Tcl_Size cmd, Tcl_Size pc);
+			    void *codePtr, CmdFrame *cfPtr, Tcl_Size cmd,
+			    Tcl_Size pc);
 MODULE_SCOPE void	TclArgumentBCRelease(Tcl_Interp *interp,
 			    CmdFrame *cfPtr);
 MODULE_SCOPE void	TclArgumentGet(Tcl_Interp *interp, Tcl_Obj *obj,
@@ -3309,7 +3341,8 @@ MODULE_SCOPE char *	TclDStringAppendObj(Tcl_DString *dsPtr,
 MODULE_SCOPE char *	TclDStringAppendDString(Tcl_DString *dsPtr,
 			    Tcl_DString *toAppendPtr);
 MODULE_SCOPE Tcl_Obj *const *TclFetchEnsembleRoot(Tcl_Interp *interp,
-			    Tcl_Obj *const *objv, Tcl_Size objc, Tcl_Size *objcPtr);
+			    Tcl_Obj *const *objv, Tcl_Size objc,
+			    Tcl_Size *objcPtr);
 MODULE_SCOPE Tcl_Obj *const *TclEnsembleGetRewriteValues(Tcl_Interp *interp);
 MODULE_SCOPE Tcl_Namespace *TclEnsureNamespace(Tcl_Interp *interp,
 			    Tcl_Namespace *namespacePtr);
@@ -3424,7 +3457,7 @@ MODULE_SCOPE Tcl_Size	TclMaxListLength(const char *bytes, Tcl_Size numBytes,
 MODULE_SCOPE int	TclMergeReturnOptions(Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[], Tcl_Obj **optionsPtrPtr,
 			    int *codePtr, int *levelPtr);
-MODULE_SCOPE Tcl_Obj *  TclNoErrorStack(Tcl_Interp *interp, Tcl_Obj *options);
+MODULE_SCOPE Tcl_Obj *	TclNoErrorStack(Tcl_Interp *interp, Tcl_Obj *options);
 MODULE_SCOPE int	TclNokia770Doubles(void);
 MODULE_SCOPE void	TclNsDecrRefCount(Namespace *nsPtr);
 MODULE_SCOPE int	TclNamespaceDeleted(Namespace *nsPtr);
@@ -3449,15 +3482,16 @@ MODULE_SCOPE int	TclProcessReturn(Tcl_Interp *interp,
 MODULE_SCOPE void 	TclUndoRefCount(Tcl_Obj *objPtr);
 MODULE_SCOPE int	TclpObjLstat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf);
 MODULE_SCOPE Tcl_Obj *	TclpTempFileName(void);
-MODULE_SCOPE Tcl_Obj *  TclpTempFileNameForLibrary(Tcl_Interp *interp,
+MODULE_SCOPE Tcl_Obj *	TclpTempFileNameForLibrary(Tcl_Interp *interp,
 			    Tcl_Obj* pathPtr);
-MODULE_SCOPE int	TclNewArithSeriesObj(Tcl_Interp *interp, Tcl_Obj **arithSeriesPtr,
-                            int useDoubles, Tcl_Obj *startObj, Tcl_Obj *endObj,
-                            Tcl_Obj *stepObj, Tcl_Obj *lenObj);
+MODULE_SCOPE int	TclNewArithSeriesObj(Tcl_Interp *interp,
+			    Tcl_Obj **arithSeriesPtr,
+			    int useDoubles, Tcl_Obj *startObj, Tcl_Obj *endObj,
+			    Tcl_Obj *stepObj, Tcl_Obj *lenObj);
 MODULE_SCOPE Tcl_Obj *	TclNewFSPathObj(Tcl_Obj *dirPtr, const char *addStrRep,
 			    Tcl_Size len);
 MODULE_SCOPE void	TclpAlertNotifier(void *clientData);
-MODULE_SCOPE void *TclpNotifierData(void);
+MODULE_SCOPE void *	TclpNotifierData(void);
 MODULE_SCOPE void	TclpServiceModeHook(int mode);
 MODULE_SCOPE void	TclpSetTimer(const Tcl_Time *timePtr);
 MODULE_SCOPE int	TclpWaitForEvent(const Tcl_Time *timePtr);
@@ -3487,7 +3521,7 @@ MODULE_SCOPE Tcl_Size	TclpFindVariable(const char *name, Tcl_Size *lengthPtr);
 MODULE_SCOPE void	TclpInitLibraryPath(char **valuePtr,
 			    TCL_HASH_TYPE *lengthPtr, Tcl_Encoding *encodingPtr);
 MODULE_SCOPE void	TclpInitLock(void);
-MODULE_SCOPE void *TclpInitNotifier(void);
+MODULE_SCOPE void *	TclpInitNotifier(void);
 MODULE_SCOPE void	TclpInitPlatform(void);
 MODULE_SCOPE void	TclpInitUnlock(void);
 MODULE_SCOPE Tcl_Obj *	TclpObjListVolumes(void);
@@ -3569,13 +3603,14 @@ MODULE_SCOPE int	TclSubstTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,
 			    Tcl_Size count, int *tokensLeftPtr, Tcl_Size line,
 			    Tcl_Size *clNextOuter, const char *outerScript);
 MODULE_SCOPE Tcl_Size	TclTrim(const char *bytes, Tcl_Size numBytes,
-			    const char *trim, Tcl_Size numTrim, Tcl_Size *trimRight);
+			    const char *trim, Tcl_Size numTrim,
+			    Tcl_Size *trimRight);
 MODULE_SCOPE Tcl_Size	TclTrimLeft(const char *bytes, Tcl_Size numBytes,
 			    const char *trim, Tcl_Size numTrim);
 MODULE_SCOPE Tcl_Size	TclTrimRight(const char *bytes, Tcl_Size numBytes,
 			    const char *trim, Tcl_Size numTrim);
 MODULE_SCOPE const char*TclGetCommandTypeName(Tcl_Command command);
-MODULE_SCOPE int TclObjInterpProc(void *clientData,
+MODULE_SCOPE int	TclObjInterpProc(void *clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE void	TclRegisterCommandTypeName(
@@ -3601,16 +3636,16 @@ MODULE_SCOPE void	TclFinalizeThreadDataThread(void);
 MODULE_SCOPE void	TclFinalizeThreadStorage(void);
 
 #ifdef TCL_WIDE_CLICKS
-MODULE_SCOPE long long TclpGetWideClicks(void);
+MODULE_SCOPE long long	TclpGetWideClicks(void);
 MODULE_SCOPE double	TclpWideClicksToNanoseconds(long long clicks);
 MODULE_SCOPE double	TclpWideClickInMicrosec(void);
 #else
 #   ifdef _WIN32
 #	define TCL_WIDE_CLICKS 1
-MODULE_SCOPE long long TclpGetWideClicks(void);
+MODULE_SCOPE long long	TclpGetWideClicks(void);
 MODULE_SCOPE double	TclpWideClickInMicrosec(void);
-#	define		TclpWideClicksToNanoseconds(clicks) \
-				((double)(clicks) * TclpWideClickInMicrosec() * 1000)
+#	define TclpWideClicksToNanoseconds(clicks) \
+		((double)(clicks) * TclpWideClickInMicrosec() * 1000)
 #   endif
 #endif
 MODULE_SCOPE long long TclpGetMicroseconds(void);
@@ -3634,8 +3669,8 @@ MODULE_SCOPE void	TclZipfsFinalize(void);
  */
 
 MODULE_SCOPE int	TclIsSpaceProc(int byte);
-#	define TclIsSpaceProcM(byte) \
-		(((byte) > 0x20) ? 0 : TclIsSpaceProc(byte))
+#define TclIsSpaceProcM(byte) \
+    (((byte) > 0x20) ? 0 : TclIsSpaceProc(byte))
 
 /*
  *----------------------------------------------------------------
@@ -4004,14 +4039,13 @@ MODULE_SCOPE int	TclFullFinalizationRequested(void);
  * TIP #542
  */
 
-MODULE_SCOPE size_t TclUniCharLen(const Tcl_UniChar *uniStr);
-MODULE_SCOPE int TclUniCharNcmp(const Tcl_UniChar *ucs,
-				const Tcl_UniChar *uct, size_t numChars);
-MODULE_SCOPE int TclUniCharNcasecmp(const Tcl_UniChar *ucs,
-				const Tcl_UniChar *uct, size_t numChars);
-MODULE_SCOPE int TclUniCharCaseMatch(const Tcl_UniChar *uniStr,
-				const Tcl_UniChar *uniPattern, int nocase);
-
+MODULE_SCOPE size_t	TclUniCharLen(const Tcl_UniChar *uniStr);
+MODULE_SCOPE int	TclUniCharNcmp(const Tcl_UniChar *ucs,
+			    const Tcl_UniChar *uct, size_t numChars);
+MODULE_SCOPE int	TclUniCharNcasecmp(const Tcl_UniChar *ucs,
+			    const Tcl_UniChar *uct, size_t numChars);
+MODULE_SCOPE int	TclUniCharCaseMatch(const Tcl_UniChar *uniStr,
+			    const Tcl_UniChar *uniPattern, int nocase);
 
 /*
  * Just for the purposes of command-type registration.
@@ -4070,13 +4104,14 @@ MODULE_SCOPE Tcl_Size	TclIndexDecode(int encoded, Tcl_Size endValue);
 /*
  * Error message utility functions
  */
-MODULE_SCOPE int TclCommandWordLimitError(Tcl_Interp *interp, Tcl_Size count);
+MODULE_SCOPE int	TclCommandWordLimitError(Tcl_Interp *interp,
+			    Tcl_Size count);
 
 #endif /* TCL_MAJOR_VERSION > 8 */
 
 /* Constants used in index value encoding routines. */
-#define TCL_INDEX_END           ((Tcl_Size)-2)
-#define TCL_INDEX_START         ((Tcl_Size)0)
+#define TCL_INDEX_END	((Tcl_Size)-2)
+#define TCL_INDEX_START	((Tcl_Size)0)
 
 /*
  *----------------------------------------------------------------------
@@ -4155,20 +4190,20 @@ TclScaleTime(
 #  define TclIncrObjsFreed()
 #endif /* TCL_COMPILE_STATS */
 
-#  define TclAllocObjStorage(objPtr)		\
+#  define TclAllocObjStorage(objPtr) \
 	TclAllocObjStorageEx(NULL, (objPtr))
 
-#  define TclFreeObjStorage(objPtr)		\
+#  define TclFreeObjStorage(objPtr) \
 	TclFreeObjStorageEx(NULL, (objPtr))
 
 #ifndef TCL_MEM_DEBUG
 # define TclNewObj(objPtr) \
-    TclIncrObjsAllocated(); \
-    TclAllocObjStorage(objPtr); \
-    (objPtr)->refCount = 0; \
-    (objPtr)->bytes    = &tclEmptyString; \
-    (objPtr)->length   = 0; \
-    (objPtr)->typePtr  = NULL; \
+    TclIncrObjsAllocated();						\
+    TclAllocObjStorage(objPtr);						\
+    (objPtr)->refCount = 0;						\
+    (objPtr)->bytes    = &tclEmptyString;				\
+    (objPtr)->length   = 0;						\
+    (objPtr)->typePtr  = NULL;						\
     TCL_DTRACE_OBJ_CREATE(objPtr)
 
 /*
@@ -4179,19 +4214,19 @@ TclScaleTime(
  */
 
 # define TclDecrRefCount(objPtr) \
-    if ((objPtr)->refCount-- > 1) ; else { \
-	if (!(objPtr)->typePtr || !(objPtr)->typePtr->freeIntRepProc) { \
-	    TCL_DTRACE_OBJ_FREE(objPtr); \
-	    if ((objPtr)->bytes \
-		    && ((objPtr)->bytes != &tclEmptyString)) { \
-		Tcl_Free((objPtr)->bytes); \
-	    } \
-	    (objPtr)->length = TCL_INDEX_NONE; \
-	    TclFreeObjStorage(objPtr); \
-	    TclIncrObjsFreed(); \
-	} else { \
-	    TclFreeObj(objPtr); \
-	} \
+    if ((objPtr)->refCount-- > 1) ; else {				\
+	if (!(objPtr)->typePtr || !(objPtr)->typePtr->freeIntRepProc) {	\
+	    TCL_DTRACE_OBJ_FREE(objPtr);				\
+	    if ((objPtr)->bytes						\
+		    && ((objPtr)->bytes != &tclEmptyString)) {		\
+		Tcl_Free((objPtr)->bytes);				\
+	    }								\
+	    (objPtr)->length = TCL_INDEX_NONE;				\
+	    TclFreeObjStorage(objPtr);					\
+	    TclIncrObjsFreed();						\
+	} else {							\
+	    TclFreeObj(objPtr);						\
+	}								\
     }
 
 #if TCL_THREADS && !defined(USE_THREAD_ALLOC)
@@ -4298,11 +4333,11 @@ MODULE_SCOPE Tcl_Mutex	tclObjMutex;
     } while (0)
 
 #  define TclFreeObjStorageEx(interp, objPtr) \
-    do {							       \
-	Tcl_MutexLock(&tclObjMutex);				       \
+    do {								\
+	Tcl_MutexLock(&tclObjMutex);					\
 	(objPtr)->internalRep.twoPtrValue.ptr1 = (void *) tclFreeObjList; \
-	tclFreeObjList = (objPtr);				       \
-	Tcl_MutexUnlock(&tclObjMutex);				       \
+	tclFreeObjList = (objPtr);					\
+	Tcl_MutexUnlock(&tclObjMutex);					\
     } while (0)
 #endif
 
@@ -4353,27 +4388,26 @@ MODULE_SCOPE void	TclDbInitNewObj(Tcl_Obj *objPtr, const char *file,
  */
 
 #define TclInitEmptyStringRep(objPtr) \
-	((objPtr)->length = (((objPtr)->bytes = &tclEmptyString), 0))
-
+    ((objPtr)->length = (((objPtr)->bytes = &tclEmptyString), 0))
 
 #define TclInitStringRep(objPtr, bytePtr, len) \
-    if ((len) == 0) { \
-	TclInitEmptyStringRep(objPtr); \
-    } else { \
-	(objPtr)->bytes = (char *)Tcl_Alloc((len) + 1U); \
+    if ((len) == 0) {							\
+	TclInitEmptyStringRep(objPtr);					\
+    } else {								\
+	(objPtr)->bytes = (char *)Tcl_Alloc((len) + 1U);		\
 	memcpy((objPtr)->bytes, (bytePtr) ? (bytePtr) : &tclEmptyString, (len)); \
-	(objPtr)->bytes[len] = '\0'; \
-	(objPtr)->length = (len); \
+	(objPtr)->bytes[len] = '\0';					\
+	(objPtr)->length = (len);					\
     }
 
 #define TclAttemptInitStringRep(objPtr, bytePtr, len) \
-    ((((len) == 0) ? ( \
-	TclInitEmptyStringRep(objPtr) \
-    ) : ( \
-	(objPtr)->bytes = (char *)Tcl_AttemptAlloc((len) + 1U), \
-	(objPtr)->length = ((objPtr)->bytes) ? \
+    ((((len) == 0) ? (							\
+	TclInitEmptyStringRep(objPtr)					\
+    ) : (								\
+	(objPtr)->bytes = (char *)Tcl_AttemptAlloc((len) + 1U),		\
+	(objPtr)->length = ((objPtr)->bytes) ?				\
 		(memcpy((objPtr)->bytes, (bytePtr) ? (bytePtr) : &tclEmptyString, (len)), \
-		(objPtr)->bytes[len] = '\0', (len)) : (-1) \
+		(objPtr)->bytes[len] = '\0', (len)) : (-1)		\
     )), (objPtr)->bytes)
 
 /*
@@ -4392,8 +4426,8 @@ MODULE_SCOPE void	TclDbInitNewObj(Tcl_Obj *objPtr, const char *file,
     ((objPtr)->bytes? (objPtr)->bytes : Tcl_GetString(objPtr))
 
 #define TclGetStringFromObj(objPtr, lenPtr) \
-    ((objPtr)->bytes \
-	    ? (*(lenPtr) = (objPtr)->length, (objPtr)->bytes)	\
+    ((objPtr)->bytes							\
+	    ? (*(lenPtr) = (objPtr)->length, (objPtr)->bytes)		\
 	    : (Tcl_GetStringFromObj)((objPtr), (lenPtr)))
 
 /*
@@ -4407,11 +4441,11 @@ MODULE_SCOPE void	TclDbInitNewObj(Tcl_Obj *objPtr, const char *file,
  */
 
 #define TclFreeInternalRep(objPtr) \
-    if ((objPtr)->typePtr != NULL) { \
-	if ((objPtr)->typePtr->freeIntRepProc != NULL) { \
-	    (objPtr)->typePtr->freeIntRepProc(objPtr); \
-	} \
-	(objPtr)->typePtr = NULL; \
+    if ((objPtr)->typePtr != NULL) {					\
+	if ((objPtr)->typePtr->freeIntRepProc != NULL) {		\
+	    (objPtr)->typePtr->freeIntRepProc(objPtr);			\
+	}								\
+	(objPtr)->typePtr = NULL;					\
     }
 
 /*
@@ -4424,14 +4458,14 @@ MODULE_SCOPE void	TclDbInitNewObj(Tcl_Obj *objPtr, const char *file,
  */
 
 #define TclInvalidateStringRep(objPtr) \
-    do { \
-	Tcl_Obj *_isobjPtr = (Tcl_Obj *)(objPtr); \
-	if (_isobjPtr->bytes != NULL) { \
-	    if (_isobjPtr->bytes != &tclEmptyString) { \
-		Tcl_Free((char *)_isobjPtr->bytes); \
-	    } \
-	    _isobjPtr->bytes = NULL; \
-	} \
+    do {								\
+	Tcl_Obj *_isobjPtr = (Tcl_Obj *)(objPtr);			\
+	if (_isobjPtr->bytes != NULL) {					\
+	    if (_isobjPtr->bytes != &tclEmptyString) {			\
+		Tcl_Free((char *)_isobjPtr->bytes);			\
+	    }								\
+	    _isobjPtr->bytes = NULL;					\
+	}								\
     } while (0)
 
 /*
@@ -4474,8 +4508,8 @@ MODULE_SCOPE const TclFileAttrProcs	tclpFileAttrProcs[];
 
 #define TclUnpackBignum(objPtr, bignum) \
     do {								\
-	Tcl_Obj *bignumObj = (objPtr);				\
-	int bignumPayload =					\
+	Tcl_Obj *bignumObj = (objPtr);					\
+	int bignumPayload =						\
 		PTR2INT(bignumObj->internalRep.twoPtrValue.ptr2);	\
 	if (bignumPayload == -1) {					\
 	    (bignum) = *((mp_int *) bignumObj->internalRep.twoPtrValue.ptr1); \
@@ -4528,16 +4562,16 @@ MODULE_SCOPE const TclFileAttrProcs	tclpFileAttrProcs[];
 		oldPtr = NULL;						\
 	    }								\
 	    newPtr = (Tcl_Token *)Tcl_AttemptRealloc((char *) oldPtr,	\
-		    allocated * sizeof(Tcl_Token));	\
+		    allocated * sizeof(Tcl_Token));			\
 	    if (newPtr == NULL) {					\
 		allocated = _needed + (append) + TCL_MIN_TOKEN_GROWTH;	\
 		newPtr = (Tcl_Token *)Tcl_Realloc((char *) oldPtr,	\
-			allocated * sizeof(Tcl_Token)); \
+			allocated * sizeof(Tcl_Token));			\
 	    }								\
 	    (available) = allocated;					\
 	    if (oldPtr == NULL) {					\
 		memcpy(newPtr, staticPtr,				\
-			(used) * sizeof(Tcl_Token));		\
+			(used) * sizeof(Tcl_Token));			\
 	    }								\
 	    (tokenPtr) = newPtr;					\
 	}								\
@@ -4561,8 +4595,8 @@ MODULE_SCOPE const TclFileAttrProcs	tclpFileAttrProcs[];
  */
 
 #define TclUtfToUniChar(str, chPtr) \
-	(((UCHAR(*(str))) < 0x80) ?		\
-	    ((*(chPtr) = UCHAR(*(str))), 1)	\
+	(((UCHAR(*(str))) < 0x80) ?					\
+	    ((*(chPtr) = UCHAR(*(str))), 1)				\
 	    : Tcl_UtfToUniChar(str, chPtr))
 
 /*
@@ -4579,15 +4613,15 @@ MODULE_SCOPE const TclFileAttrProcs	tclpFileAttrProcs[];
  */
 
 #define TclNumUtfCharsM(numChars, bytes, numBytes) \
-    do { \
-	Tcl_Size _count, _i = (numBytes); \
-	unsigned char *_str = (unsigned char *) (bytes); \
-	while (_i > 0 && (*_str < 0xC0)) { _i--; _str++; } \
-	_count = (numBytes) - _i; \
-	if (_i) { \
-	    _count += Tcl_NumUtfChars((bytes) + _count, _i); \
-	} \
-	(numChars) = _count; \
+    do {								\
+	Tcl_Size _count, _i = (numBytes);				\
+	unsigned char *_str = (unsigned char *) (bytes);		\
+	while (_i > 0 && (*_str < 0xC0)) { _i--; _str++; }		\
+	_count = (numBytes) - _i;					\
+	if (_i) {							\
+	    _count += Tcl_NumUtfChars((bytes) + _count, _i);		\
+	}								\
+	(numChars) = _count;						\
     } while (0);
 
 /*
@@ -4607,12 +4641,11 @@ MODULE_SCOPE const TclFileAttrProcs	tclpFileAttrProcs[];
 
 MODULE_SCOPE int	TclIsPureByteArray(Tcl_Obj *objPtr);
 #define TclIsPureDict(objPtr) \
-	(((objPtr)->bytes==NULL) && TclHasInternalRep((objPtr), &tclDictType))
+    (((objPtr)->bytes == NULL) && TclHasInternalRep((objPtr), &tclDictType))
 #define TclHasInternalRep(objPtr, type) \
-	((objPtr)->typePtr == (type))
+    ((objPtr)->typePtr == (type))
 #define TclFetchInternalRep(objPtr, type) \
-	(TclHasInternalRep((objPtr), (type)) ? &((objPtr)->internalRep) : NULL)
-
+    (TclHasInternalRep((objPtr), (type)) ? &(objPtr)->internalRep : NULL)
 
 /*
  *----------------------------------------------------------------
@@ -4658,7 +4691,6 @@ MODULE_SCOPE Tcl_LibraryInitProc Procbodytest_Init;
 MODULE_SCOPE Tcl_LibraryInitProc Procbodytest_SafeInit;
 MODULE_SCOPE Tcl_LibraryInitProc Tcl_ABSListTest_Init;
 
-
 /*
  *----------------------------------------------------------------
  * Macro used by the Tcl core to check whether a pattern has any characters
@@ -4684,18 +4716,18 @@ MODULE_SCOPE Tcl_LibraryInitProc Tcl_ABSListTest_Init;
  */
 
 #define TclSetIntObj(objPtr, i) \
-    do {						\
-	Tcl_ObjInternalRep ir;				\
-	ir.wideValue = (Tcl_WideInt) i;			\
-	TclInvalidateStringRep(objPtr);			\
-	Tcl_StoreInternalRep(objPtr, &tclIntType, &ir);	\
+    do {							\
+	Tcl_ObjInternalRep ir;					\
+	ir.wideValue = (Tcl_WideInt) i;				\
+	TclInvalidateStringRep(objPtr);				\
+	Tcl_StoreInternalRep(objPtr, &tclIntType, &ir);		\
     } while (0)
 
 #define TclSetDoubleObj(objPtr, d) \
-    do {						\
-	Tcl_ObjInternalRep ir;				\
-	ir.doubleValue = (double) d;			\
-	TclInvalidateStringRep(objPtr);			\
+    do {							\
+	Tcl_ObjInternalRep ir;					\
+	ir.doubleValue = (double) d;				\
+	TclInvalidateStringRep(objPtr);				\
 	Tcl_StoreInternalRep(objPtr, &tclDoubleType, &ir);	\
     } while (0)
 
@@ -4715,58 +4747,58 @@ MODULE_SCOPE Tcl_LibraryInitProc Tcl_ABSListTest_Init;
 
 #ifndef TCL_MEM_DEBUG
 #define TclNewIntObj(objPtr, w) \
-    do {						\
-	TclIncrObjsAllocated();				\
-	TclAllocObjStorage(objPtr);			\
-	(objPtr)->refCount = 0;				\
-	(objPtr)->bytes = NULL;				\
-	(objPtr)->internalRep.wideValue = (Tcl_WideInt)(w);	\
-	(objPtr)->typePtr = &tclIntType;		\
-	TCL_DTRACE_OBJ_CREATE(objPtr);			\
+    do {								\
+	TclIncrObjsAllocated();						\
+	TclAllocObjStorage(objPtr);					\
+	(objPtr)->refCount = 0;						\
+	(objPtr)->bytes = NULL;						\
+	(objPtr)->internalRep.wideValue = (Tcl_WideInt)(w);		\
+	(objPtr)->typePtr = &tclIntType;				\
+	TCL_DTRACE_OBJ_CREATE(objPtr);					\
     } while (0)
 
 #define TclNewUIntObj(objPtr, uw) \
-    do {						\
-	TclIncrObjsAllocated();				\
-	TclAllocObjStorage(objPtr);			\
-	(objPtr)->refCount = 0;				\
-	(objPtr)->bytes = NULL;				\
-	Tcl_WideUInt uw_ = (uw);		\
-	if (uw_ > WIDE_MAX) {			\
-	    mp_int bignumValue_;		\
-	    if (mp_init_u64(&bignumValue_, uw_) != MP_OKAY) {	\
+    do {								\
+	TclIncrObjsAllocated();						\
+	TclAllocObjStorage(objPtr);					\
+	(objPtr)->refCount = 0;						\
+	(objPtr)->bytes = NULL;						\
+	Tcl_WideUInt uw_ = (uw);					\
+	if (uw_ > WIDE_MAX) {						\
+	    mp_int bignumValue_;					\
+	    if (mp_init_u64(&bignumValue_, uw_) != MP_OKAY) {		\
 		Tcl_Panic("%s: memory overflow", "TclNewUIntObj");	\
-	    }	\
-	    TclSetBignumInternalRep((objPtr), &bignumValue_);	\
-	} else {	\
+	    }								\
+	    TclSetBignumInternalRep((objPtr), &bignumValue_);		\
+	} else {							\
 	    (objPtr)->internalRep.wideValue = (Tcl_WideInt)(uw_);	\
-	    (objPtr)->typePtr = &tclIntType;		\
-	}	\
-	TCL_DTRACE_OBJ_CREATE(objPtr);			\
+	    (objPtr)->typePtr = &tclIntType;				\
+	}								\
+	TCL_DTRACE_OBJ_CREATE(objPtr);					\
     } while (0)
 
 #define TclNewIndexObj(objPtr, w) \
     TclNewIntObj(objPtr, w)
 
 #define TclNewDoubleObj(objPtr, d) \
-    do {							\
-	TclIncrObjsAllocated();					\
-	TclAllocObjStorage(objPtr);				\
-	(objPtr)->refCount = 0;					\
-	(objPtr)->bytes = NULL;					\
-	(objPtr)->internalRep.doubleValue = (double)(d);	\
-	(objPtr)->typePtr = &tclDoubleType;			\
-	TCL_DTRACE_OBJ_CREATE(objPtr);				\
+    do {								\
+	TclIncrObjsAllocated();						\
+	TclAllocObjStorage(objPtr);					\
+	(objPtr)->refCount = 0;						\
+	(objPtr)->bytes = NULL;						\
+	(objPtr)->internalRep.doubleValue = (double)(d);		\
+	(objPtr)->typePtr = &tclDoubleType;				\
+	TCL_DTRACE_OBJ_CREATE(objPtr);					\
     } while (0)
 
 #define TclNewStringObj(objPtr, s, len) \
-    do {							\
-	TclIncrObjsAllocated();					\
-	TclAllocObjStorage(objPtr);				\
-	(objPtr)->refCount = 0;					\
-	TclInitStringRep((objPtr), (s), (len));			\
-	(objPtr)->typePtr = NULL;				\
-	TCL_DTRACE_OBJ_CREATE(objPtr);				\
+    do {								\
+	TclIncrObjsAllocated();						\
+	TclAllocObjStorage(objPtr);					\
+	(objPtr)->refCount = 0;						\
+	TclInitStringRep((objPtr), (s), (len));				\
+	(objPtr)->typePtr = NULL;					\
+	TCL_DTRACE_OBJ_CREATE(objPtr);					\
     } while (0)
 
 #else /* TCL_MEM_DEBUG */
@@ -4774,18 +4806,18 @@ MODULE_SCOPE Tcl_LibraryInitProc Tcl_ABSListTest_Init;
     (objPtr) = Tcl_NewWideIntObj(w)
 
 #define TclNewUIntObj(objPtr, uw) \
-    do {						\
-	Tcl_WideUInt uw_ = (uw);		\
-	if (uw_ > WIDE_MAX) {			\
-	    mp_int bignumValue_;		\
-	    if (mp_init_u64(&bignumValue_, uw_) == MP_OKAY) {	\
-		(objPtr) = Tcl_NewBignumObj(&bignumValue_);	\
-	    } else {	\
-		(objPtr) = NULL; \
-	    } \
-	} else {	\
-	    (objPtr) = Tcl_NewWideIntObj(uw_);	\
-	}	\
+    do {								\
+	Tcl_WideUInt uw_ = (uw);					\
+	if (uw_ > WIDE_MAX) {						\
+	    mp_int bignumValue_;					\
+	    if (mp_init_u64(&bignumValue_, uw_) == MP_OKAY) {		\
+		(objPtr) = Tcl_NewBignumObj(&bignumValue_);		\
+	    } else {							\
+		(objPtr) = NULL;					\
+	    }								\
+	} else {							\
+	    (objPtr) = Tcl_NewWideIntObj(uw_);				\
+	}								\
     } while (0)
 
 #define TclNewIndexObj(objPtr, w) \
@@ -4837,28 +4869,26 @@ MODULE_SCOPE Tcl_LibraryInitProc Tcl_ABSListTest_Init;
  * the internal stubs, but the core can use the macro instead.
  */
 
-#define TclCleanupCommandMacro(cmdPtr)		\
+#define TclCleanupCommandMacro(cmdPtr) \
     do {					\
 	if ((cmdPtr)->refCount-- <= 1) {	\
 	    Tcl_Free(cmdPtr);			\
 	}					\
     } while (0)
 
-
 /*
  * inside this routine crement refCount first incase cmdPtr is replacing itself
  */
-#define TclRoutineAssign(location, cmdPtr)	    \
-    do {					    \
-	(cmdPtr)->refCount++;			    \
-	if ((location) != NULL			    \
-	    && (location--) <= 1) {		    \
-	    Tcl_Free(((location)));		    \
-	}					    \
-	(location) = (cmdPtr);			    \
+#define TclRoutineAssign(location, cmdPtr) \
+    do {								\
+	(cmdPtr)->refCount++;						\
+	if ((location) != NULL						\
+		&& (location--) <= 1) {					\
+	    Tcl_Free(((location)));					\
+	}								\
+	(location) = (cmdPtr);						\
     } while (0)
 
-
 #define TclRoutineHasName(cmdPtr) \
     ((cmdPtr)->hPtr != NULL)
 
@@ -4871,9 +4901,10 @@ MODULE_SCOPE Tcl_LibraryInitProc Tcl_ABSListTest_Init;
  * to the non-inline version.
  */
 
-#define TclLimitExceeded(limit) ((limit).exceeded != 0)
+#define TclLimitExceeded(limit) \
+    ((limit).exceeded != 0)
 
-#define TclLimitReady(limit)						\
+#define TclLimitReady(limit) \
     (((limit).active == 0) ? 0 :					\
     (++(limit).granularityTicker,					\
     ((((limit).active & TCL_LIMIT_COMMANDS) &&				\
@@ -4991,7 +5022,8 @@ typedef struct NRE_callback {
     struct NRE_callback *nextPtr;
 } NRE_callback;
 
-#define TOP_CB(iPtr) (((Interp *)(iPtr))->execEnvPtr->callbackPtr)
+#define TOP_CB(iPtr) \
+    (((Interp *)(iPtr))->execEnvPtr->callbackPtr)
 
 /*
  * Inline version of Tcl_NRAddCallback.
@@ -5030,9 +5062,9 @@ typedef struct NRE_callback {
 #include "tclIntPlatDecls.h"
 
 #if !defined(USE_TCL_STUBS) && !defined(TCL_MEM_DEBUG)
-#define Tcl_AttemptAlloc        TclpAlloc
-#define Tcl_AttemptRealloc      TclpRealloc
-#define Tcl_Free                TclpFree
+#define Tcl_AttemptAlloc	TclpAlloc
+#define Tcl_AttemptRealloc	TclpRealloc
+#define Tcl_Free		TclpFree
 #endif
 
 /*