Backport spacing-related changes from 9.0

1 files changed, 553 insertions, 556 deletions

diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index 45072bd..774ac80 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -63,7 +63,6 @@
 /* actually there is no fallback to builtin fpclassify */
 #endif /* !TCL_FPCLASSIFY_MODE */
 
-
 /*
  * Bug 7371b6270b: to check C call stack depth, prefer an approach which is
  * compatible with AddressSanitizer (ASan) use-after-return detection.
@@ -85,17 +84,17 @@ void *
 TclGetCStackPtr(void)
 {
 #if defined( __GNUC__ ) || __has_builtin(__builtin_frame_address)
-  return __builtin_frame_address(0);
+    return __builtin_frame_address(0);
 #elif defined(_MSC_VER) && defined(HAVE_INTRIN_H)
-  return _AddressOfReturnAddress();
+    return _AddressOfReturnAddress();
 #else
-  ptrdiff_t unused = 0;
-  /*
-   * LLVM recommends using volatile:
-   * https://github.com/llvm/llvm-project/blob/llvmorg-10.0.0-rc1/clang/lib/Basic/Stack.cpp#L31
-   */
-  ptrdiff_t *volatile stackLevel = &unused;
-  return (void *)stackLevel;
+    ptrdiff_t unused = 0;
+    /*
+     * LLVM recommends using volatile:
+     * https://github.com/llvm/llvm-project/blob/llvmorg-10.0.0-rc1/clang/lib/Basic/Stack.cpp#L31
+     */
+    ptrdiff_t *volatile stackLevel = &unused;
+    return (void *)stackLevel;
 #endif
 }
 
@@ -180,7 +179,7 @@ TCL_DECLARE_MUTEX(commandTypeLock);
  * Static functions in this file:
  */
 
-static Tcl_ObjCmdProc   BadEnsembleSubcommand;
+static Tcl_ObjCmdProc	BadEnsembleSubcommand;
 static char *		CallCommandTraces(Interp *iPtr, Command *cmdPtr,
 			    const char *oldName, const char *newName,
 			    int flags);
@@ -204,12 +203,12 @@ static Tcl_ObjCmdProc	ExprDoubleFunc;
 static Tcl_ObjCmdProc	ExprFloorFunc;
 static Tcl_ObjCmdProc	ExprIntFunc;
 static Tcl_ObjCmdProc	ExprIsqrtFunc;
-static Tcl_ObjCmdProc   ExprIsFiniteFunc;
-static Tcl_ObjCmdProc   ExprIsInfinityFunc;
-static Tcl_ObjCmdProc   ExprIsNaNFunc;
-static Tcl_ObjCmdProc   ExprIsNormalFunc;
-static Tcl_ObjCmdProc   ExprIsSubnormalFunc;
-static Tcl_ObjCmdProc   ExprIsUnorderedFunc;
+static Tcl_ObjCmdProc	ExprIsFiniteFunc;
+static Tcl_ObjCmdProc	ExprIsInfinityFunc;
+static Tcl_ObjCmdProc	ExprIsNaNFunc;
+static Tcl_ObjCmdProc	ExprIsNormalFunc;
+static Tcl_ObjCmdProc	ExprIsSubnormalFunc;
+static Tcl_ObjCmdProc	ExprIsUnorderedFunc;
 static Tcl_ObjCmdProc	ExprMaxFunc;
 static Tcl_ObjCmdProc	ExprMinFunc;
 static Tcl_ObjCmdProc	ExprRandFunc;
@@ -218,7 +217,7 @@ static Tcl_ObjCmdProc	ExprSqrtFunc;
 static Tcl_ObjCmdProc	ExprSrandFunc;
 static Tcl_ObjCmdProc	ExprUnaryFunc;
 static Tcl_ObjCmdProc	ExprWideFunc;
-static Tcl_ObjCmdProc   FloatClassifyObjCmd;
+static Tcl_ObjCmdProc	FloatClassifyObjCmd;
 static void		MathFuncWrongNumArgs(Tcl_Interp *interp, int expected,
 			    int actual, Tcl_Obj *const *objv);
 static Tcl_NRPostProc	NRCoroutineCallerCallback;
@@ -268,11 +267,11 @@ MODULE_SCOPE const TclStubs tclStubs;
  * after particular kinds of [yield].
  */
 
-#define CORO_ACTIVATE_YIELD    NULL
-#define CORO_ACTIVATE_YIELDM   INT2PTR(1)
+#define CORO_ACTIVATE_YIELD	NULL
+#define CORO_ACTIVATE_YIELDM	INT2PTR(1)
 
-#define COROUTINE_ARGUMENTS_SINGLE_OPTIONAL     (-1)
-#define COROUTINE_ARGUMENTS_ARBITRARY           (-2)
+#define COROUTINE_ARGUMENTS_SINGLE_OPTIONAL	(-1)
+#define COROUTINE_ARGUMENTS_ARBITRARY		(-2)
 
 /*
  * The following structure define the commands in the Tcl core.
@@ -286,9 +285,9 @@ typedef struct {
     int flags;			/* Various flag bits, as defined below. */
 } CmdInfo;
 
-#define CMD_IS_SAFE         1   /* Whether this command is part of the set of
-                                 * commands present by default in a safe
-                                 * interpreter. */
+#define CMD_IS_SAFE 1		/* Whether this command is part of the set of
+				 * commands present by default in a safe
+				 * interpreter. */
 /* CMD_COMPILES_EXPANDED - Whether the compiler for this command can handle
  * expansion for itself rather than needing the generic layer to take care of
  * it for it. Defined in tclInt.h. */
@@ -302,13 +301,13 @@ typedef struct {
  */
 
 typedef struct {
-    const char *ensembleNsName; /* The ensemble's name within ::tcl. NULL for
-                                 * the end of the list of commands to hide. */
-    const char *commandName;    /* The name of the command within the
-                                 * ensemble. If this is NULL, we want to also
-                                 * make the overall command be hidden, an ugly
-                                 * hack because it is expected by security
-                                 * policies in the wild. */
+    const char *ensembleNsName;	/* The ensemble's name within ::tcl. NULL for
+				 * the end of the list of commands to hide. */
+    const char *commandName;	/* The name of the command within the
+				 * ensemble. If this is NULL, we want to also
+				 * make the overall command be hidden, an ugly
+				 * hack because it is expected by security
+				 * policies in the wild. */
 } UnsafeEnsembleInfo;
 
 /*
@@ -329,8 +328,8 @@ static const CmdInfo builtInCmds[] = {
     {"catch",		Tcl_CatchObjCmd,	TclCompileCatchCmd,	TclNRCatchObjCmd,	CMD_IS_SAFE},
     {"concat",		Tcl_ConcatObjCmd,	TclCompileConcatCmd,	NULL,	CMD_IS_SAFE},
     {"continue",	Tcl_ContinueObjCmd,	TclCompileContinueCmd,	NULL,	CMD_IS_SAFE},
-    {"coroinject",	NULL,			NULL,                   TclNRCoroInjectObjCmd,	CMD_IS_SAFE},
-    {"coroprobe",	NULL,			NULL,                   TclNRCoroProbeObjCmd,	CMD_IS_SAFE},
+    {"coroinject",	NULL,			NULL,			TclNRCoroInjectObjCmd,	CMD_IS_SAFE},
+    {"coroprobe",	NULL,			NULL,			TclNRCoroProbeObjCmd,	CMD_IS_SAFE},
     {"coroutine",	NULL,			NULL,			TclNRCoroutineObjCmd,	CMD_IS_SAFE},
     {"error",		Tcl_ErrorObjCmd,	TclCompileErrorCmd,	NULL,	CMD_IS_SAFE},
     {"eval",		Tcl_EvalObjCmd,		NULL,			TclNREvalObjCmd,	CMD_IS_SAFE},
@@ -338,14 +337,14 @@ static const CmdInfo builtInCmds[] = {
     {"for",		Tcl_ForObjCmd,		TclCompileForCmd,	TclNRForObjCmd,	CMD_IS_SAFE},
     {"foreach",		Tcl_ForeachObjCmd,	TclCompileForeachCmd,	TclNRForeachCmd,	CMD_IS_SAFE},
     {"format",		Tcl_FormatObjCmd,	TclCompileFormatCmd,	NULL,	CMD_IS_SAFE},
-    {"fpclassify",      FloatClassifyObjCmd,    NULL,                   NULL,   CMD_IS_SAFE},
+    {"fpclassify",	FloatClassifyObjCmd,    NULL,			NULL,	CMD_IS_SAFE},
     {"global",		Tcl_GlobalObjCmd,	TclCompileGlobalCmd,	NULL,	CMD_IS_SAFE},
     {"if",		Tcl_IfObjCmd,		TclCompileIfCmd,	TclNRIfObjCmd,	CMD_IS_SAFE},
     {"incr",		Tcl_IncrObjCmd,		TclCompileIncrCmd,	NULL,	CMD_IS_SAFE},
     {"join",		Tcl_JoinObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
     {"lappend",		Tcl_LappendObjCmd,	TclCompileLappendCmd,	NULL,	CMD_IS_SAFE},
     {"lassign",		Tcl_LassignObjCmd,	TclCompileLassignCmd,	NULL,	CMD_IS_SAFE},
-    {"ledit",		Tcl_LeditObjCmd,	NULL,	NULL,	CMD_IS_SAFE},
+    {"ledit",		Tcl_LeditObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
     {"lindex",		Tcl_LindexObjCmd,	TclCompileLindexCmd,	NULL,	CMD_IS_SAFE},
     {"linsert",		Tcl_LinsertObjCmd,	TclCompileLinsertCmd,	NULL,	CMD_IS_SAFE},
     {"list",		Tcl_ListObjCmd,		TclCompileListCmd,	NULL,	CMD_IS_SAFE|CMD_COMPILES_EXPANDED},
@@ -353,12 +352,12 @@ static const CmdInfo builtInCmds[] = {
     {"lmap",		Tcl_LmapObjCmd,		TclCompileLmapCmd,	TclNRLmapCmd,	CMD_IS_SAFE},
     {"lpop",		Tcl_LpopObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
     {"lrange",		Tcl_LrangeObjCmd,	TclCompileLrangeCmd,	NULL,	CMD_IS_SAFE},
-    {"lremove", 	Tcl_LremoveObjCmd,	NULL,           	NULL,	CMD_IS_SAFE},
+    {"lremove", 	Tcl_LremoveObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
     {"lrepeat",		Tcl_LrepeatObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
     {"lreplace",	Tcl_LreplaceObjCmd,	TclCompileLreplaceCmd,	NULL,	CMD_IS_SAFE},
     {"lreverse",	Tcl_LreverseObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
     {"lsearch",		Tcl_LsearchObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
-    {"lseq",		Tcl_LseqObjCmd,         NULL,                   NULL,   CMD_IS_SAFE},
+    {"lseq",		Tcl_LseqObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
     {"lset",		Tcl_LsetObjCmd,		TclCompileLsetCmd,	NULL,	CMD_IS_SAFE},
     {"lsort",		Tcl_LsortObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
     {"package",		Tcl_PackageObjCmd,	NULL,			TclNRPackageObjCmd,	CMD_IS_SAFE},
@@ -509,13 +508,13 @@ static const BuiltinFuncDef BuiltinFuncTable[] = {
     { "fmod",	ExprBinaryFunc,	(double (*)(double))(void *)(double (*)(double, double)) fmod},
     { "hypot",	ExprBinaryFunc,	(double (*)(double))(void *)(double (*)(double, double)) hypot},
     { "int",	ExprIntFunc,	NULL			},
-    { "isfinite", ExprIsFiniteFunc, NULL        	},
-    { "isinf",	ExprIsInfinityFunc, NULL        	},
-    { "isnan",	ExprIsNaNFunc,	NULL            	},
-    { "isnormal", ExprIsNormalFunc, NULL        	},
+    { "isfinite", ExprIsFiniteFunc, NULL		},
+    { "isinf",	ExprIsInfinityFunc, NULL		},
+    { "isnan",	ExprIsNaNFunc,	NULL	    	},
+    { "isnormal", ExprIsNormalFunc, NULL		},
     { "isqrt",	ExprIsqrtFunc,	NULL			},
-    { "issubnormal", ExprIsSubnormalFunc, NULL,         },
-    { "isunordered", ExprIsUnorderedFunc, NULL,         },
+    { "issubnormal", ExprIsSubnormalFunc, NULL,	 },
+    { "isunordered", ExprIsUnorderedFunc, NULL,	 },
     { "log",	ExprUnaryFunc,	log				},
     { "log10",	ExprUnaryFunc,	log10			},
     { "max",	ExprMaxFunc,	NULL			},
@@ -635,8 +634,8 @@ TclFinalizeEvaluation(void)
 
     Tcl_MutexLock(&commandTypeLock);
     if (commandTypeInit) {
-        Tcl_DeleteHashTable(&commandTypeTable);
-        commandTypeInit = 0;
+	Tcl_DeleteHashTable(&commandTypeTable);
+	commandTypeInit = 0;
     }
     Tcl_MutexUnlock(&commandTypeLock);
 }
@@ -845,16 +844,16 @@ Tcl_CreateInterp(void)
 
 #undef TclObjInterpProc
     if (commandTypeInit == 0) {
-        TclRegisterCommandTypeName(TclObjInterpProc, "proc");
-        TclRegisterCommandTypeName(TclEnsembleImplementationCmd, "ensemble");
-        TclRegisterCommandTypeName(TclAliasObjCmd, "alias");
-        TclRegisterCommandTypeName(TclLocalAliasObjCmd, "alias");
-        TclRegisterCommandTypeName(TclChildObjCmd, "interp");
-        TclRegisterCommandTypeName(TclInvokeImportedCmd, "import");
-        TclRegisterCommandTypeName(TclOOPublicObjectCmd, "object");
-        TclRegisterCommandTypeName(TclOOPrivateObjectCmd, "privateObject");
-        TclRegisterCommandTypeName(TclOOMyClassObjCmd, "privateClass");
-        TclRegisterCommandTypeName(TclNRInterpCoroutine, "coroutine");
+	TclRegisterCommandTypeName(TclObjInterpProc, "proc");
+	TclRegisterCommandTypeName(TclEnsembleImplementationCmd, "ensemble");
+	TclRegisterCommandTypeName(TclAliasObjCmd, "alias");
+	TclRegisterCommandTypeName(TclLocalAliasObjCmd, "alias");
+	TclRegisterCommandTypeName(TclChildObjCmd, "interp");
+	TclRegisterCommandTypeName(TclInvokeImportedCmd, "import");
+	TclRegisterCommandTypeName(TclOOPublicObjectCmd, "object");
+	TclRegisterCommandTypeName(TclOOPrivateObjectCmd, "privateObject");
+	TclRegisterCommandTypeName(TclOOMyClassObjCmd, "privateClass");
+	TclRegisterCommandTypeName(TclNRInterpCoroutine, "coroutine");
     }
 
     /*
@@ -979,7 +978,7 @@ Tcl_CreateInterp(void)
     iPtr->flags |= INTERP_DEBUG_FRAME;
 #else
     if (getenv("TCL_INTERP_DEBUG_FRAME") != NULL) {
-        iPtr->flags |= INTERP_DEBUG_FRAME;
+	iPtr->flags |= INTERP_DEBUG_FRAME;
     }
 #endif
 
@@ -1136,9 +1135,9 @@ Tcl_CreateInterp(void)
 	    cmdPtr->deleteProc = NULL;
 	    cmdPtr->deleteData = NULL;
 	    cmdPtr->flags = 0;
-            if (cmdInfoPtr->flags & CMD_COMPILES_EXPANDED) {
-                cmdPtr->flags |= CMD_COMPILES_EXPANDED;
-            }
+	    if (cmdInfoPtr->flags & CMD_COMPILES_EXPANDED) {
+		cmdPtr->flags |= CMD_COMPILES_EXPANDED;
+	    }
 	    cmdPtr->importRefPtr = NULL;
 	    cmdPtr->tracePtr = NULL;
 	    cmdPtr->nreProc = cmdInfoPtr->nreProc;
@@ -1198,15 +1197,15 @@ Tcl_CreateInterp(void)
 
     /* Adding the bytecode assembler command */
     cmdPtr = (Command *) Tcl_NRCreateCommand(interp,
-            "::tcl::unsupported::assemble", Tcl_AssembleObjCmd,
-            TclNRAssembleObjCmd, NULL, NULL);
+	    "::tcl::unsupported::assemble", Tcl_AssembleObjCmd,
+	    TclNRAssembleObjCmd, NULL, NULL);
     cmdPtr->compileProc = &TclCompileAssembleCmd;
 
     /* Coroutine monkeybusiness */
     Tcl_NRCreateCommand(interp, "::tcl::unsupported::inject", NULL,
 	    NRInjectObjCmd, NULL, NULL);
     Tcl_CreateObjCommand(interp, "::tcl::unsupported::corotype",
-            CoroTypeObjCmd, NULL, NULL);
+	    CoroTypeObjCmd, NULL, NULL);
 
     /* Export unsupported commands */
     nsPtr = Tcl_FindNamespace(interp, "::tcl::unsupported", NULL, 0);
@@ -1214,7 +1213,6 @@ Tcl_CreateInterp(void)
 	Tcl_Export(interp, nsPtr, "*", 1);
     }
 
-
 #ifdef USE_DTRACE
     /*
      * Register the tcl::dtrace command.
@@ -1235,7 +1233,7 @@ Tcl_CreateInterp(void)
     memcpy(mathFuncName, "::tcl::mathfunc::", MATH_FUNC_PREFIX_LEN);
     for (builtinFuncPtr = BuiltinFuncTable; builtinFuncPtr->name != NULL;
 	    builtinFuncPtr++) {
-	strcpy(mathFuncName+MATH_FUNC_PREFIX_LEN, builtinFuncPtr->name);
+	strcpy(mathFuncName + MATH_FUNC_PREFIX_LEN, builtinFuncPtr->name);
 	Tcl_CreateObjCommand(interp, mathFuncName,
 		builtinFuncPtr->objCmdProc, (void *)builtinFuncPtr->fn, NULL);
 	Tcl_Export(interp, nsPtr, builtinFuncPtr->name, 0);
@@ -1380,10 +1378,10 @@ DeleteOpCmdClientData(
  *
  * TclRegisterCommandTypeName, TclGetCommandTypeName --
  *
- *      Command type registration and lookup mechanism. Everything is keyed by
- *      the Tcl_ObjCmdProc for the command, and that is used as the *key* into
- *      the hash table that maps to constant strings that are names. (It is
- *      recommended that those names be ASCII.)
+ *	Command type registration and lookup mechanism. Everything is keyed by
+ *	the Tcl_ObjCmdProc for the command, and that is used as the *key* into
+ *	the hash table that maps to constant strings that are names. (It is
+ *	recommended that those names be ASCII.)
  *
  * ---------------------------------------------------------------------
  */
@@ -1397,21 +1395,21 @@ TclRegisterCommandTypeName(
 
     Tcl_MutexLock(&commandTypeLock);
     if (commandTypeInit == 0) {
-        Tcl_InitHashTable(&commandTypeTable, TCL_ONE_WORD_KEYS);
-        commandTypeInit = 1;
+	Tcl_InitHashTable(&commandTypeTable, TCL_ONE_WORD_KEYS);
+	commandTypeInit = 1;
     }
     if (nameStr != NULL) {
-        int isNew;
+	int isNew;
 
-        hPtr = Tcl_CreateHashEntry(&commandTypeTable,
-                implementationProc, &isNew);
-        Tcl_SetHashValue(hPtr, (void *) nameStr);
+	hPtr = Tcl_CreateHashEntry(&commandTypeTable,
+		implementationProc, &isNew);
+	Tcl_SetHashValue(hPtr, (void *) nameStr);
     } else {
-        hPtr = Tcl_FindHashEntry(&commandTypeTable,
-                implementationProc);
-        if (hPtr != NULL) {
-            Tcl_DeleteHashEntry(hPtr);
-        }
+	hPtr = Tcl_FindHashEntry(&commandTypeTable,
+		implementationProc);
+	if (hPtr != NULL) {
+	    Tcl_DeleteHashEntry(hPtr);
+	}
     }
     Tcl_MutexUnlock(&commandTypeLock);
 }
@@ -1425,15 +1423,15 @@ TclGetCommandTypeName(
     const char *name = "native";
 
     if (procPtr == NULL) {
-        procPtr = cmdPtr->nreProc;
+	procPtr = cmdPtr->nreProc;
     }
     Tcl_MutexLock(&commandTypeLock);
     if (commandTypeInit) {
-        Tcl_HashEntry *hPtr = Tcl_FindHashEntry(&commandTypeTable, procPtr);
+	Tcl_HashEntry *hPtr = Tcl_FindHashEntry(&commandTypeTable, procPtr);
 
-        if (hPtr && Tcl_GetHashValue(hPtr)) {
-            name = (const char *) Tcl_GetHashValue(hPtr);
-        }
+	if (hPtr && Tcl_GetHashValue(hPtr)) {
+	    name = (const char *) Tcl_GetHashValue(hPtr);
+	}
     }
     Tcl_MutexUnlock(&commandTypeLock);
 
@@ -1473,41 +1471,41 @@ TclHideUnsafeCommands(
     }
 
     for (unsafePtr = unsafeEnsembleCommands;
-            unsafePtr->ensembleNsName; unsafePtr++) {
-        if (unsafePtr->commandName) {
-            /*
-             * Hide an ensemble subcommand.
-             */
-
-            Tcl_Obj *cmdName = Tcl_ObjPrintf("::tcl::%s::%s",
-                    unsafePtr->ensembleNsName, unsafePtr->commandName);
-            Tcl_Obj *hideName = Tcl_ObjPrintf("tcl:%s:%s",
-                    unsafePtr->ensembleNsName, unsafePtr->commandName);
-
-            if (TclRenameCommand(interp, TclGetString(cmdName),
-                        "___tmp") != TCL_OK
-                    || Tcl_HideCommand(interp, "___tmp",
-                            TclGetString(hideName)) != TCL_OK) {
-                Tcl_Panic("problem making '%s %s' safe: %s",
-                        unsafePtr->ensembleNsName, unsafePtr->commandName,
-                        Tcl_GetStringResult(interp));
-            }
-            Tcl_CreateObjCommand(interp, TclGetString(cmdName),
-                    BadEnsembleSubcommand, (void *)unsafePtr, NULL);
-            TclDecrRefCount(cmdName);
-            TclDecrRefCount(hideName);
-        } else {
-            /*
-             * Hide an ensemble main command (for compatibility).
-             */
-
-            if (Tcl_HideCommand(interp, unsafePtr->ensembleNsName,
-                    unsafePtr->ensembleNsName) != TCL_OK) {
-                Tcl_Panic("problem making '%s' safe: %s",
-                        unsafePtr->ensembleNsName,
-                        Tcl_GetStringResult(interp));
-            }
-        }
+	    unsafePtr->ensembleNsName; unsafePtr++) {
+	if (unsafePtr->commandName) {
+	    /*
+	     * Hide an ensemble subcommand.
+	     */
+
+	    Tcl_Obj *cmdName = Tcl_ObjPrintf("::tcl::%s::%s",
+		    unsafePtr->ensembleNsName, unsafePtr->commandName);
+	    Tcl_Obj *hideName = Tcl_ObjPrintf("tcl:%s:%s",
+		    unsafePtr->ensembleNsName, unsafePtr->commandName);
+
+	    if (TclRenameCommand(interp, TclGetString(cmdName),
+			"___tmp") != TCL_OK
+		    || Tcl_HideCommand(interp, "___tmp",
+			    TclGetString(hideName)) != TCL_OK) {
+		Tcl_Panic("problem making '%s %s' safe: %s",
+			unsafePtr->ensembleNsName, unsafePtr->commandName,
+			Tcl_GetStringResult(interp));
+	    }
+	    Tcl_CreateObjCommand(interp, TclGetString(cmdName),
+		    BadEnsembleSubcommand, (void *)unsafePtr, NULL);
+	    TclDecrRefCount(cmdName);
+	    TclDecrRefCount(hideName);
+	} else {
+	    /*
+	     * Hide an ensemble main command (for compatibility).
+	     */
+
+	    if (Tcl_HideCommand(interp, unsafePtr->ensembleNsName,
+		    unsafePtr->ensembleNsName) != TCL_OK) {
+		Tcl_Panic("problem making '%s' safe: %s",
+			unsafePtr->ensembleNsName,
+			Tcl_GetStringResult(interp));
+	    }
+	}
     }
 
     return TCL_OK;
@@ -1541,8 +1539,8 @@ BadEnsembleSubcommand(
     const UnsafeEnsembleInfo *infoPtr = (const UnsafeEnsembleInfo *)clientData;
 
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-            "not allowed to invoke subcommand %s of %s",
-            infoPtr->commandName, infoPtr->ensembleNsName));
+	    "not allowed to invoke subcommand %s of %s",
+	    infoPtr->commandName, infoPtr->ensembleNsName));
     Tcl_SetErrorCode(interp, "TCL", "SAFE", "SUBCOMMAND", (char *)NULL);
     return TCL_ERROR;
 }
@@ -1573,7 +1571,7 @@ Tcl_CallWhenDeleted(
     Tcl_Interp *interp,		/* Interpreter to watch. */
     Tcl_InterpDeleteProc *proc,	/* Function to call when interpreter is about
 				 * to be deleted. */
-    void *clientData)	/* One-word value to pass to proc. */
+    void *clientData)		/* One-word value to pass to proc. */
 {
     Interp *iPtr = (Interp *) interp;
     static Tcl_ThreadDataKey assocDataCounterKey;
@@ -1621,7 +1619,7 @@ Tcl_DontCallWhenDeleted(
     Tcl_Interp *interp,		/* Interpreter to watch. */
     Tcl_InterpDeleteProc *proc,	/* Function to call when interpreter is about
 				 * to be deleted. */
-    void *clientData)	/* One-word value to pass to proc. */
+    void *clientData)		/* One-word value to pass to proc. */
 {
     Interp *iPtr = (Interp *) interp;
     Tcl_HashTable *hTablePtr;
@@ -1669,7 +1667,7 @@ Tcl_SetAssocData(
     const char *name,		/* Name for association. */
     Tcl_InterpDeleteProc *proc,	/* Proc to call when interpreter is about to
 				 * be deleted. */
-    void *clientData)	/* One-word value to pass to proc. */
+    void *clientData)		/* One-word value to pass to proc. */
 {
     Interp *iPtr = (Interp *) interp;
     AssocData *dPtr;
@@ -2249,7 +2247,7 @@ Tcl_HideCommand(
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"cannot use namespace qualifiers in hidden command"
 		" token (rename)", TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "VALUE", "HIDDENTOKEN", (char *)NULL);
+	Tcl_SetErrorCode(interp, "TCL", "VALUE", "HIDDENTOKEN", (char *)NULL);
 	return TCL_ERROR;
     }
 
@@ -2272,9 +2270,9 @@ Tcl_HideCommand(
 
     if (cmdPtr->nsPtr != iPtr->globalNsPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "can only hide global namespace commands (use rename then hide)",
-                TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "HIDE", "NON_GLOBAL", (char *)NULL);
+		"can only hide global namespace commands (use rename then hide)",
+		TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "HIDE", "NON_GLOBAL", (char *)NULL);
 	return TCL_ERROR;
     }
 
@@ -2298,9 +2296,9 @@ Tcl_HideCommand(
     hPtr = Tcl_CreateHashEntry(hiddenCmdTablePtr, hiddenCmdToken, &isNew);
     if (!isNew) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "hidden command named \"%s\" already exists",
-                hiddenCmdToken));
-        Tcl_SetErrorCode(interp, "TCL", "HIDE", "ALREADY_HIDDEN", (char *)NULL);
+		"hidden command named \"%s\" already exists",
+		hiddenCmdToken));
+	Tcl_SetErrorCode(interp, "TCL", "HIDE", "ALREADY_HIDDEN", (char *)NULL);
 	return TCL_ERROR;
     }
 
@@ -2402,9 +2400,9 @@ Tcl_ExposeCommand(
 
     if (strstr(cmdName, "::") != NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "cannot expose to a namespace (use expose to toplevel, then rename)",
-                TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "EXPOSE", "NON_GLOBAL", (char *)NULL);
+		"cannot expose to a namespace (use expose to toplevel, then rename)",
+		TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "EXPOSE", "NON_GLOBAL", (char *)NULL);
 	return TCL_ERROR;
     }
 
@@ -2419,9 +2417,9 @@ Tcl_ExposeCommand(
     }
     if (hPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "unknown hidden command \"%s\"", hiddenCmdToken));
-        Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "HIDDENTOKEN",
-                hiddenCmdToken, (char *)NULL);
+		"unknown hidden command \"%s\"", hiddenCmdToken));
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "HIDDENTOKEN",
+		hiddenCmdToken, (char *)NULL);
 	return TCL_ERROR;
     }
     cmdPtr = (Command *)Tcl_GetHashValue(hPtr);
@@ -2458,8 +2456,8 @@ Tcl_ExposeCommand(
     hPtr = Tcl_CreateHashEntry(&nsPtr->cmdTable, cmdName, &isNew);
     if (!isNew) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "exposed command \"%s\" already exists", cmdName));
-        Tcl_SetErrorCode(interp, "TCL", "EXPOSE", "COMMAND_EXISTS", (char *)NULL);
+		"exposed command \"%s\" already exists", cmdName));
+	Tcl_SetErrorCode(interp, "TCL", "EXPOSE", "COMMAND_EXISTS", (char *)NULL);
 	return TCL_ERROR;
     }
 
@@ -2556,7 +2554,7 @@ Tcl_CreateCommand(
 				 * specified namespace; otherwise it is put in
 				 * the global namespace. */
     Tcl_CmdProc *proc,		/* Function to associate with cmdName. */
-    void *clientData,	/* Arbitrary value passed to string proc. */
+    void *clientData,		/* Arbitrary value passed to string proc. */
     Tcl_CmdDeleteProc *deleteProc)
 				/* If not NULL, gives a function to call when
 				 * this command is deleted. */
@@ -2587,26 +2585,26 @@ Tcl_CreateCommand(
      */
 
     while (1) {
-        /*
-         * Determine where the command should reside. If its name contains
-         * namespace qualifiers, we put it in the specified namespace;
+	/*
+	 * Determine where the command should reside. If its name contains
+	 * namespace qualifiers, we put it in the specified namespace;
 	 * otherwise, we always put it in the global namespace.
-         */
+	 */
 
-        if (strstr(cmdName, "::") != NULL) {
+	if (strstr(cmdName, "::") != NULL) {
 	    Namespace *dummy1, *dummy2;
 
 	    TclGetNamespaceForQualName(interp, cmdName, NULL,
 		    TCL_CREATE_NS_IF_UNKNOWN, &nsPtr, &dummy1, &dummy2, &tail);
 	    if ((nsPtr == NULL) || (tail == NULL)) {
-	        return (Tcl_Command) NULL;
+		return (Tcl_Command) NULL;
 	    }
-        } else {
+	} else {
 	    nsPtr = iPtr->globalNsPtr;
 	    tail = cmdName;
-        }
+	}
 
-        hPtr = Tcl_CreateHashEntry(&nsPtr->cmdTable, tail, &isNew);
+	hPtr = Tcl_CreateHashEntry(&nsPtr->cmdTable, tail, &isNew);
 
 	if (isNew || deleted) {
 	    /*
@@ -2617,8 +2615,8 @@ Tcl_CreateCommand(
 	}
 
 	/*
-         * An existing command conflicts. Try to delete it...
-         */
+	 * An existing command conflicts. Try to delete it...
+	 */
 
 	cmdPtr = (Command *)Tcl_GetHashValue(hPtr);
 
@@ -2754,12 +2752,11 @@ Tcl_CreateObjCommand(
 				 * the global namespace. */
     Tcl_ObjCmdProc *proc,	/* Object-based function to associate with
 				 * name. */
-    void *clientData,	/* Arbitrary value to pass to object
+    void *clientData,		/* Arbitrary value to pass to object
 				 * function. */
-    Tcl_CmdDeleteProc *deleteProc
+    Tcl_CmdDeleteProc *deleteProc)
 				/* If not NULL, gives a function to call when
 				 * this command is deleted. */
-)
 {
     Interp *iPtr = (Interp *) interp;
     Namespace *nsPtr;
@@ -2800,11 +2797,11 @@ Tcl_Command
 TclCreateObjCommandInNs(
     Tcl_Interp *interp,
     const char *cmdName,	/* Name of command, without any namespace
-                                 * components. */
-    Tcl_Namespace *namesp,   /* The namespace to create the command in */
+				 * components. */
+    Tcl_Namespace *namesp,	/* The namespace to create the command in */
     Tcl_ObjCmdProc *proc,	/* Object-based function to associate with
 				 * name. */
-    void *clientData,	/* Arbitrary value to pass to object
+    void *clientData,		/* Arbitrary value to pass to object
 				 * function. */
     Tcl_CmdDeleteProc *deleteProc)
 				/* If not NULL, gives a function to call when
@@ -2836,8 +2833,8 @@ TclCreateObjCommandInNs(
 	}
 
 	/*
-         * An existing command conflicts. Try to delete it...
-         */
+	 * An existing command conflicts. Try to delete it...
+	 */
 
 	cmdPtr = (Command *)Tcl_GetHashValue(hPtr);
 
@@ -2871,14 +2868,14 @@ TclCreateObjCommandInNs(
 	}
 
 	/*
-         * Make sure namespace doesn't get deallocated.
-         */
+	 * Make sure namespace doesn't get deallocated.
+	 */
 
 	cmdPtr->nsPtr->refCount++;
 
 	Tcl_DeleteCommandFromToken(interp, (Tcl_Command) cmdPtr);
 	nsPtr = (Namespace *) TclEnsureNamespace(interp,
-                (Tcl_Namespace *) cmdPtr->nsPtr);
+		(Tcl_Namespace *) cmdPtr->nsPtr);
 	TclNsDecrRefCount(cmdPtr->nsPtr);
 
 	if (cmdPtr->flags & CMD_REDEF_IN_PROGRESS) {
@@ -3136,10 +3133,10 @@ TclRenameCommand(
     cmdPtr = (Command *) cmd;
     if (cmdPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "can't %s \"%s\": command doesn't exist",
-		((newName == NULL)||(*newName == '\0'))? "delete":"rename",
+		"can't %s \"%s\": command doesn't exist",
+		((newName == NULL) || (*newName == '\0')) ? "delete" : "rename",
 		oldName));
-        Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COMMAND", oldName, (char *)NULL);
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COMMAND", oldName, (char *)NULL);
 	return TCL_ERROR;
     }
 
@@ -3169,16 +3166,16 @@ TclRenameCommand(
 
     if ((newNsPtr == NULL) || (newTail == NULL)) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "can't rename to \"%s\": bad command name", newName));
-        Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMMAND", (char *)NULL);
+		"can't rename to \"%s\": bad command name", newName));
+	Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMMAND", (char *)NULL);
 	result = TCL_ERROR;
 	goto done;
     }
     if (Tcl_FindHashEntry(&newNsPtr->cmdTable, newTail) != NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "can't rename to \"%s\": command already exists", newName));
-        Tcl_SetErrorCode(interp, "TCL", "OPERATION", "RENAME",
-                "TARGET_EXISTS", (char *)NULL);
+		"can't rename to \"%s\": command already exists", newName));
+	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "RENAME",
+		"TARGET_EXISTS", (char *)NULL);
 	result = TCL_ERROR;
 	goto done;
     }
@@ -4293,8 +4290,8 @@ Tcl_GetMathFuncInfo(
      */
 
     if (cmdPtr == NULL) {
-        Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "unknown math function \"%s\"", name));
+	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+		"unknown math function \"%s\"", name));
 	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "MATHFUNC", name, (char *)NULL);
 	*numArgsPtr = -1;
 	*argTypesPtr = NULL;
@@ -4519,7 +4516,7 @@ Tcl_Canceled(
      */
 
     if (!TclCanceled(iPtr)) {
-        return TCL_OK;
+	return TCL_OK;
     }
 
     /*
@@ -4540,7 +4537,7 @@ Tcl_Canceled(
      */
 
     if ((flags & TCL_CANCEL_UNWIND) && !(iPtr->flags & TCL_CANCEL_UNWIND)) {
-        return TCL_OK;
+	return TCL_OK;
     }
 
     /*
@@ -4549,34 +4546,34 @@ Tcl_Canceled(
      */
 
     if (flags & TCL_LEAVE_ERR_MSG) {
-        const char *id, *message = NULL;
-        Tcl_Size length;
+	const char *id, *message = NULL;
+	Tcl_Size length;
 
-        /*
-         * Setup errorCode variables so that we can differentiate between
-         * being canceled and unwound.
-         */
+	/*
+	 * Setup errorCode variables so that we can differentiate between
+	 * being canceled and unwound.
+	 */
 
-        if (iPtr->asyncCancelMsg != NULL) {
-            message = TclGetStringFromObj(iPtr->asyncCancelMsg, &length);
-        } else {
-            length = 0;
-        }
+	if (iPtr->asyncCancelMsg != NULL) {
+	    message = TclGetStringFromObj(iPtr->asyncCancelMsg, &length);
+	} else {
+	    length = 0;
+	}
 
-        if (iPtr->flags & TCL_CANCEL_UNWIND) {
-            id = "IUNWIND";
-            if (length == 0) {
-                message = "eval unwound";
-            }
-        } else {
-            id = "ICANCEL";
-            if (length == 0) {
-                message = "eval canceled";
-            }
-        }
+	if (iPtr->flags & TCL_CANCEL_UNWIND) {
+	    id = "IUNWIND";
+	    if (length == 0) {
+		message = "eval unwound";
+	    }
+	} else {
+	    id = "ICANCEL";
+	    if (length == 0) {
+		message = "eval canceled";
+	    }
+	}
 
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(message, TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "CANCEL", id, message, (char *)NULL);
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(message, TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "CANCEL", id, message, (char *)NULL);
     }
 
     /*
@@ -4615,7 +4612,7 @@ Tcl_CancelEval(
 				 * script. */
     Tcl_Obj *resultObjPtr,	/* The script cancellation error message or
 				 * NULL for a default error message. */
-    void *clientData,	/* Passed to CancelEvalProc. */
+    void *clientData,		/* Passed to CancelEvalProc. */
     int flags)			/* Collection of OR-ed bits that control
 				 * the cancellation of the script. Only
 				 * TCL_CANCEL_UNWIND is currently
@@ -4658,7 +4655,7 @@ Tcl_CancelEval(
 
     if (resultObjPtr != NULL) {
 	result = TclGetStringFromObj(resultObjPtr, &cancelInfo->length);
-	cancelInfo->result = (char *)ckrealloc(cancelInfo->result,cancelInfo->length);
+	cancelInfo->result = (char *)ckrealloc(cancelInfo->result, cancelInfo->length);
 	memcpy(cancelInfo->result, result, cancelInfo->length);
 	TclDecrRefCount(resultObjPtr);	/* Discard their result object. */
     } else {
@@ -4761,7 +4758,7 @@ TclNREvalObjv(
      */
 
     if (iPtr->deferredCallbacks) {
-        iPtr->deferredCallbacks = NULL;
+	iPtr->deferredCallbacks = NULL;
     } else {
 	TclNRAddCallback(interp, NRCommand, NULL, NULL, NULL, NULL);
     }
@@ -4849,13 +4846,13 @@ EvalObjvCore(
     assert(cmdPtr == NULL);
     if (preCmdPtr) {
 	/*
-         * Caller gave it to us.
-         */
+	 * Caller gave it to us.
+	 */
 
 	if (!(preCmdPtr->flags & CMD_DEAD)) {
 	    /*
-             * So long as it exists, use it.
-             */
+	     * So long as it exists, use it.
+	     */
 
 	    cmdPtr = preCmdPtr;
 	} else if (flags & TCL_EVAL_NORESOLVE) {
@@ -4880,7 +4877,7 @@ EvalObjvCore(
     if (enterTracesDone || iPtr->tracePtr
 	    || (cmdPtr->flags & CMD_HAS_EXEC_TRACES)) {
 	Tcl_Obj *commandPtr = TclGetSourceFromFrame(
-		flags & TCL_EVAL_SOURCE_IN_FRAME ?  iPtr->cmdFramePtr : NULL,
+		flags & TCL_EVAL_SOURCE_IN_FRAME ? iPtr->cmdFramePtr : NULL,
 		objc, objv);
 
 	Tcl_IncrRefCount(commandPtr);
@@ -4923,7 +4920,7 @@ EvalObjvCore(
 
 	cmdPtr->refCount++;
 	TclNRAddCallback(interp, TEOV_RunLeaveTraces, INT2PTR(objc),
-		    commandPtr, cmdPtr, objv);
+		commandPtr, cmdPtr, objv);
     }
 
     TclNRAddCallback(interp, Dispatch,
@@ -5010,8 +5007,8 @@ TclNRRunCallbacks(
      */
 
     while (TOP_CB(interp) != rootPtr) {
-        NRE_callback *callbackPtr = TOP_CB(interp);
-        Tcl_NRPostProc *procPtr = callbackPtr->procPtr;
+	NRE_callback *callbackPtr = TOP_CB(interp);
+	Tcl_NRPostProc *procPtr = callbackPtr->procPtr;
 
 	TOP_CB(interp) = callbackPtr->nextPtr;
 	result = procPtr(callbackPtr->data, interp, result);
@@ -5031,9 +5028,9 @@ NRCommand(
 
     iPtr->numLevels--;
 
-     /*
-      * If there is a tailcall, schedule it next
-      */
+    /*
+     * If there is a tailcall, schedule it next
+     */
 
     if (data[1] && (data[1] != INT2PTR(1))) {
 	listPtr = (Tcl_Obj *)data[1];
@@ -5248,7 +5245,7 @@ TEOV_NotFound(
 	newObjv[i] = handlerObjv[i];
 	Tcl_IncrRefCount(newObjv[i]);
     }
-    memcpy(newObjv+handlerObjc, objv, sizeof(Tcl_Obj *) * objc);
+    memcpy(newObjv + handlerObjc, objv, sizeof(Tcl_Obj *) * objc);
 
     /*
      * Look up and invoke the handler (by recursive call to this function). If
@@ -5263,9 +5260,9 @@ TEOV_NotFound(
     cmdPtr = TEOV_LookupCmdFromObj(interp, newObjv[0], lookupNsPtr);
     if (cmdPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "invalid command name \"%s\"", TclGetString(objv[0])));
-        Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COMMAND",
-                TclGetString(objv[0]), (char *)NULL);
+		"invalid command name \"%s\"", TclGetString(objv[0])));
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COMMAND",
+		TclGetString(objv[0]), (char *)NULL);
 
 	/*
 	 * Release any resources we locked and allocated during the handler
@@ -5464,7 +5461,7 @@ Tcl_EvalTokensStandard(
 				 * errors. */
     Tcl_Token *tokenPtr,	/* Pointer to first in an array of tokens to
 				 * evaluate and concatenate. */
-    Tcl_Size count)			/* Number of tokens to consider at tokenPtr.
+    Tcl_Size count)		/* Number of tokens to consider at tokenPtr.
 				 * Must be at least 1. */
 {
     return TclSubstTokens(interp, tokenPtr, count, /* numLeftPtr */ NULL, 1,
@@ -5569,7 +5566,7 @@ TclEvalEx(
 				 * evaluation of the script. Only
 				 * TCL_EVAL_GLOBAL is currently supported. */
     Tcl_Size line,		/* The line the script starts on. */
-    Tcl_Size *clNextOuter,		/* Information about an outer context for */
+    Tcl_Size *clNextOuter,	/* Information about an outer context for */
     const char *outerScript)	/* continuation line data. This is set only in
 				 * TclSubstTokens(), to properly handle
 				 * [...]-nested commands. The 'outerScript'
@@ -5607,13 +5604,12 @@ TclEvalEx(
 				 * properly if an error occurs. */
     Tcl_Parse *parsePtr = (Tcl_Parse *)TclStackAlloc(interp, sizeof(Tcl_Parse));
     CmdFrame *eeFramePtr = (CmdFrame *)TclStackAlloc(interp, sizeof(CmdFrame));
-    Tcl_Obj **stackObjArray = (Tcl_Obj **)
-	    TclStackAlloc(interp, minObjs * sizeof(Tcl_Obj *));
+    Tcl_Obj **stackObjArray = (Tcl_Obj **)TclStackAlloc(interp, minObjs * sizeof(Tcl_Obj *));
     int *expandStack = (int *)TclStackAlloc(interp, minObjs * sizeof(int));
     Tcl_Size *linesStack = (Tcl_Size *)TclStackAlloc(interp, minObjs * sizeof(Tcl_Size));
 				/* TIP #280 Structures for tracking of command
 				 * locations. */
-    Tcl_Size *clNext = NULL;		/* Pointer for the tracking of invisible
+    Tcl_Size *clNext = NULL;	/* Pointer for the tracking of invisible
 				 * continuation lines. Initialized only if the
 				 * caller gave us a table of locations to
 				 * track, via scriptCLLocPtr. It always refers
@@ -5746,9 +5742,11 @@ TclEvalEx(
 	     */
 
 	    if (numWords > minObjs) {
-		expand =    (int *)ckalloc(numWords * sizeof(int));
-		objvSpace = (Tcl_Obj **)ckalloc(numWords * sizeof(Tcl_Obj *));
-		lineSpace = (Tcl_Size *)ckalloc(numWords * sizeof(Tcl_Size));
+		expand = (int *) ckalloc(numWords * sizeof(int));
+		objvSpace = (Tcl_Obj **)
+			ckalloc(numWords * sizeof(Tcl_Obj *));
+		lineSpace = (Tcl_Size *)
+			ckalloc(numWords * sizeof(Tcl_Size));
 	    }
 	    expandRequested = 0;
 	    objv = objvSpace;
@@ -5757,7 +5755,7 @@ TclEvalEx(
 	    iPtr->cmdFramePtr = eeFramePtr->nextPtr;
 	    for (objectsUsed = 0, tokenPtr = parsePtr->tokenPtr;
 		    objectsUsed < numWords;
-		    objectsUsed++, tokenPtr += tokenPtr->numComponents+1) {
+		    objectsUsed++, tokenPtr += tokenPtr->numComponents + 1) {
 		/*
 		 * TIP #280. Track lines to current word. Save the information
 		 * on a per-word basis, signaling dynamic words as needed.
@@ -5778,7 +5776,7 @@ TclEvalEx(
 		    iPtr->evalFlags |= TCL_EVAL_FILE;
 		}
 
-		code = TclSubstTokens(interp, tokenPtr+1,
+		code = TclSubstTokens(interp, tokenPtr + 1,
 			tokenPtr->numComponents, NULL, wordLine,
 			wordCLNext, outerScript);
 
@@ -5833,9 +5831,10 @@ TclEvalEx(
 		Tcl_Size objIdx = objectsNeeded - 1;
 
 		if ((numWords > minObjs) || (objectsNeeded > minObjs)) {
-		    objv = objvSpace =
-			    (Tcl_Obj **)ckalloc(objectsNeeded * sizeof(Tcl_Obj *));
-		    lines = lineSpace = (Tcl_Size *)ckalloc(objectsNeeded * sizeof(Tcl_Size));
+		    objv = objvSpace = (Tcl_Obj **)
+			    ckalloc(objectsNeeded * sizeof(Tcl_Obj *));
+		    lines = lineSpace = (Tcl_Size *)
+			    ckalloc(objectsNeeded * sizeof(Tcl_Size));
 		}
 
 		objectsUsed = 0;
@@ -5859,7 +5858,7 @@ TclEvalEx(
 			objectsUsed++;
 		    }
 		}
-		objv += objIdx+1;
+		objv += objIdx + 1;
 
 		if (copy != stackObjArray) {
 		    ckfree(copy);
@@ -6205,8 +6204,7 @@ TclArgumentRelease(
 
     for (i = 1; i < objc; i++) {
 	CFWord *cfwPtr;
-	Tcl_HashEntry *hPtr =
-		Tcl_FindHashEntry(iPtr->lineLAPtr, objv[i]);
+	Tcl_HashEntry *hPtr = Tcl_FindHashEntry(iPtr->lineLAPtr, objv[i]);
 
 	if (!hPtr) {
 	    continue;
@@ -6257,8 +6255,7 @@ TclArgumentBCEnter(
     ECL *ePtr;
     CFWordBC *lastPtr = NULL;
     Interp *iPtr = (Interp *) interp;
-    Tcl_HashEntry *hePtr =
-	    Tcl_FindHashEntry(iPtr->lineBCPtr, codePtr);
+    Tcl_HashEntry *hePtr = Tcl_FindHashEntry(iPtr->lineBCPtr, codePtr);
 
     if (!hePtr) {
 	return;
@@ -6280,7 +6277,7 @@ TclArgumentBCEnter(
      */
 
     if (ePtr->nline != objc) {
-        return;
+	return;
     }
 
     /*
@@ -6298,7 +6295,7 @@ TclArgumentBCEnter(
 	if (ePtr->line[word] >= 0) {
 	    int isNew;
 	    Tcl_HashEntry *hPtr = Tcl_CreateHashEntry(iPtr->lineLABCPtr,
-		objv[word], &isNew);
+		    objv[word], &isNew);
 	    CFWordBC *cfwPtr = (CFWordBC *)ckalloc(sizeof(CFWordBC));
 
 	    cfwPtr->framePtr = cfPtr;
@@ -6565,7 +6562,7 @@ int
 Tcl_EvalObjEx(
     Tcl_Interp *interp,		/* Token for command interpreter (returned by
 				 * a previous call to Tcl_CreateInterp). */
-    Tcl_Obj *objPtr,	/* Pointer to object containing commands to
+    Tcl_Obj *objPtr,		/* Pointer to object containing commands to
 				 * execute. */
     int flags)			/* Collection of OR-ed bits that control the
 				 * evaluation of the script. Supported values
@@ -6578,7 +6575,7 @@ int
 TclEvalObjEx(
     Tcl_Interp *interp,		/* Token for command interpreter (returned by
 				 * a previous call to Tcl_CreateInterp). */
-    Tcl_Obj *objPtr,	/* Pointer to object containing commands to
+    Tcl_Obj *objPtr,		/* Pointer to object containing commands to
 				 * execute. */
     int flags,			/* Collection of OR-ed bits that control the
 				 * evaluation of the script. Supported values
@@ -6597,7 +6594,7 @@ int
 TclNREvalObjEx(
     Tcl_Interp *interp,		/* Token for command interpreter (returned by
 				 * a previous call to Tcl_CreateInterp). */
-    Tcl_Obj *objPtr,	/* Pointer to object containing commands to
+    Tcl_Obj *objPtr,		/* Pointer to object containing commands to
 				 * execute. */
     int flags,			/* Collection of OR-ed bits that control the
 				 * evaluation of the script. Supported values
@@ -6682,7 +6679,7 @@ TclNREvalObjEx(
 	}
 
 	TclMarkTailcall(interp);
-        TclNRAddCallback(interp, TEOEx_ListCallback, listPtr, eoFramePtr,
+	TclNRAddCallback(interp, TEOEx_ListCallback, listPtr, eoFramePtr,
 		objPtr, NULL);
 
 	TclListObjGetElements(NULL, listPtr, &objc, &objv);
@@ -6703,9 +6700,9 @@ TclNREvalObjEx(
 						 * iPtr->varFramePtr in case
 						 * TCL_EVAL_GLOBAL was set. */
 
-        if (TclInterpReady(interp) != TCL_OK) {
-            return TCL_ERROR;
-        }
+	if (TclInterpReady(interp) != TCL_OK) {
+	    return TCL_ERROR;
+	}
 	if (flags & TCL_EVAL_GLOBAL) {
 	    savedVarFramePtr = iPtr->varFramePtr;
 	    iPtr->varFramePtr = iPtr->rootFramePtr;
@@ -6715,7 +6712,7 @@ TclNREvalObjEx(
 
 	TclNRAddCallback(interp, TEOEx_ByteCodeCallback, savedVarFramePtr,
 		objPtr, INT2PTR(allowExceptions), NULL);
-        return TclNRExecuteByteCode(interp, codePtr);
+	return TclNRExecuteByteCode(interp, codePtr);
     }
 
     {
@@ -7012,7 +7009,7 @@ int
 Tcl_ExprLongObj(
     Tcl_Interp *interp,		/* Context in which to evaluate the
 				 * expression. */
-    Tcl_Obj *objPtr,	/* Expression to evaluate. */
+    Tcl_Obj *objPtr,		/* Expression to evaluate. */
     long *ptr)			/* Where to store long result. */
 {
     Tcl_Obj *resultPtr;
@@ -7025,7 +7022,7 @@ Tcl_ExprLongObj(
 	return TCL_ERROR;
     }
 
-    if (Tcl_GetNumberFromObj(interp, resultPtr, &internalPtr, &type)!=TCL_OK) {
+    if (Tcl_GetNumberFromObj(interp, resultPtr, &internalPtr, &type) != TCL_OK) {
 	return TCL_ERROR;
     }
 
@@ -7059,7 +7056,7 @@ int
 Tcl_ExprDoubleObj(
     Tcl_Interp *interp,		/* Context in which to evaluate the
 				 * expression. */
-    Tcl_Obj *objPtr,	/* Expression to evaluate. */
+    Tcl_Obj *objPtr,		/* Expression to evaluate. */
     double *ptr)		/* Where to store double result. */
 {
     Tcl_Obj *resultPtr;
@@ -7095,7 +7092,7 @@ int
 Tcl_ExprBooleanObj(
     Tcl_Interp *interp,		/* Context in which to evaluate the
 				 * expression. */
-    Tcl_Obj *objPtr,	/* Expression to evaluate. */
+    Tcl_Obj *objPtr,		/* Expression to evaluate. */
     int *ptr)			/* Where to store 0/1 result. */
 {
     Tcl_Obj *resultPtr;
@@ -7135,7 +7132,7 @@ int
 TclObjInvokeNamespace(
     Tcl_Interp *interp,		/* Interpreter in which command is to be
 				 * invoked. */
-    Tcl_Size objc,			/* Count of arguments. */
+    Tcl_Size objc,		/* Count of arguments. */
     Tcl_Obj *const objv[],	/* Argument objects; objv[0] points to the
 				 * name of the command to invoke. */
     Tcl_Namespace *nsPtr,	/* The namespace to use. */
@@ -7179,7 +7176,7 @@ int
 TclObjInvoke(
     Tcl_Interp *interp,		/* Interpreter in which command is to be
 				 * invoked. */
-    Tcl_Size objc,			/* Count of arguments. */
+    Tcl_Size objc,		/* Count of arguments. */
     Tcl_Obj *const objv[],	/* Argument objects; objv[0] points to the
 				 * name of the command to invoke. */
     int flags)			/* Combination of flags controlling the call:
@@ -7191,7 +7188,7 @@ TclObjInvoke(
     }
     if ((objc < 1) || (objv == NULL)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "illegal argument vector", TCL_INDEX_NONE));
+		"illegal argument vector", TCL_INDEX_NONE));
 	return TCL_ERROR;
     }
     if ((flags & TCL_INVOKE_HIDDEN) == 0) {
@@ -7220,9 +7217,9 @@ TclNRInvoke(
     }
     if (hPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "invalid hidden command name \"%s\"", cmdName));
-        Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "HIDDENTOKEN", cmdName,
-                (char *)NULL);
+		"invalid hidden command name \"%s\"", cmdName));
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "HIDDENTOKEN", cmdName,
+		(char *)NULL);
 	return TCL_ERROR;
     }
     cmdPtr = (Command *)Tcl_GetHashValue(hPtr);
@@ -7864,7 +7861,7 @@ ExprIsqrtFunc(
 
   negarg:
     Tcl_SetObjResult(interp, Tcl_NewStringObj(
-            "square root of negative argument", TCL_INDEX_NONE));
+	    "square root of negative argument", TCL_INDEX_NONE));
     Tcl_SetErrorCode(interp, "ARITH", "DOMAIN",
 	    "domain error: argument not in valid range", (char *)NULL);
     return TCL_ERROR;
@@ -8292,20 +8289,20 @@ ExprMaxMinFunc(
     }
     res = objv[1];
     for (i = 1; i < objc; i++) {
-        if (Tcl_GetNumberFromObj(interp, objv[i], &ptr, &type) != TCL_OK) {
-            return TCL_ERROR;
-        }
-        if (type == TCL_NUMBER_NAN) {
-            /*
-             * Get the error message for NaN.
-             */
-
-            Tcl_GetDoubleFromObj(interp, objv[i], &d);
-            return TCL_ERROR;
-        }
-        if (TclCompareTwoNumbers(objv[i], res) == op)  {
-            res = objv[i];
-        }
+	if (Tcl_GetNumberFromObj(interp, objv[i], &ptr, &type) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	if (type == TCL_NUMBER_NAN) {
+	    /*
+	     * Get the error message for NaN.
+	     */
+
+	    Tcl_GetDoubleFromObj(interp, objv[i], &d);
+	    return TCL_ERROR;
+	}
+	if (TclCompareTwoNumbers(objv[i], res) == op) {
+	    res = objv[i];
+	}
     }
 
     Tcl_SetObjResult(interp, res);
@@ -8361,7 +8358,7 @@ ExprRandFunc(
 	 * take into consideration the thread this interp is running in.
 	 */
 
-	iPtr->randSeed = TclpGetClicks() + PTR2UINT(Tcl_GetCurrentThread())*4093U;
+	iPtr->randSeed = TclpGetClicks() + PTR2UINT(Tcl_GetCurrentThread()) * 4093U;
 
 	/*
 	 * Make sure 1 <= randSeed <= (2^31) - 2. See below.
@@ -8558,8 +8555,8 @@ ExprSrandFunc(
  *	This page contains the functions that implement all of the built-in
  *	math functions for classifying IEEE doubles.
  *
- *      These have to be a little bit careful while Tcl_GetDoubleFromObj()
- *      rejects NaN values, which these functions *explicitly* accept.
+ *	These have to be a little bit careful while Tcl_GetDoubleFromObj()
+ *	rejects NaN values, which these functions *explicitly* accept.
  *
  * Results:
  *	Each function returns TCL_OK if it succeeds and pushes an Tcl object
@@ -8593,16 +8590,16 @@ ClassifyDouble(
      * Hence we define those here.
      */
 #ifndef FP_NAN
-#   define FP_NAN          1	/* Value is NaN */
-#   define FP_INFINITE     2	/* Value is an infinity */
-#   define FP_ZERO         3	/* Value is a zero */
-#   define FP_NORMAL       4	/* Value is a normal float */
-#   define FP_SUBNORMAL    5	/* Value has lost accuracy */
+#   define FP_NAN	1	/* Value is NaN */
+#   define FP_INFINITE	2	/* Value is an infinity */
+#   define FP_ZERO	3	/* Value is a zero */
+#   define FP_NORMAL	4	/* Value is a normal float */
+#   define FP_SUBNORMAL	5	/* Value has lost accuracy */
 #endif /* !FP_NAN */
 
 #if TCL_FPCLASSIFY_MODE == 3
     return __builtin_fpclassify(
-            FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, d);
+	    FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, d);
 #elif TCL_FPCLASSIFY_MODE == 2
     /*
      * We assume this hack is only needed on little-endian systems.
@@ -8612,27 +8609,27 @@ ClassifyDouble(
      */
 
     union {
-        double d;               /* Interpret as double */
-        struct {
-            unsigned int low;   /* Lower 32 bits */
-            unsigned int high;  /* Upper 32 bits */
-        } w;                    /* Interpret as unsigned integer words */
-    } doubleMeaning;            /* So we can look at the representation of a
-                                 * double directly. Platform (i.e., processor)
-                                 * specific; this is for x86 (and most other
-                                 * little-endian processors, but those are
-                                 * untested). */
+	double d;		/* Interpret as double */
+	struct {
+	    unsigned int low;	/* Lower 32 bits */
+	    unsigned int high;	/* Upper 32 bits */
+	} w;			/* Interpret as unsigned integer words */
+    } doubleMeaning;		/* So we can look at the representation of a
+				 * double directly. Platform (i.e., processor)
+				 * specific; this is for x86 (and most other
+				 * little-endian processors, but those are
+				 * untested). */
     unsigned int exponent, mantissaLow, mantissaHigh;
-                                /* The pieces extracted from the double. */
-    int zeroMantissa;           /* Was the mantissa zero? That's special. */
+				/* The pieces extracted from the double. */
+    int zeroMantissa;		/* Was the mantissa zero? That's special. */
 
     /*
      * Shifts and masks to use with the doubleMeaning variable above.
      */
 
-#define EXPONENT_MASK   0x7FF   /* 11 bits (after shifting) */
-#define EXPONENT_SHIFT  20      /* Moves exponent to bottom of word */
-#define MANTISSA_MASK   0xFFFFF /* 20 bits (plus 32 from other word) */
+#define EXPONENT_MASK   0x7FF	/* 11 bits (after shifting) */
+#define EXPONENT_SHIFT  20	/* Moves exponent to bottom of word */
+#define MANTISSA_MASK   0xFFFFF	/* 20 bits (plus 32 from other word) */
 
     /*
      * Extract the exponent (11 bits) and mantissa (52 bits).  Note that we
@@ -8651,43 +8648,43 @@ ClassifyDouble(
 
     switch (exponent) {
     case 0:
-        /*
-         * When the exponent is all zeros, it's a ZERO or a SUBNORMAL.
-         */
+	/*
+	 * When the exponent is all zeros, it's a ZERO or a SUBNORMAL.
+	 */
 
-        return zeroMantissa ? FP_ZERO : FP_SUBNORMAL;
+	return zeroMantissa ? FP_ZERO : FP_SUBNORMAL;
     case EXPONENT_MASK:
-        /*
-         * When the exponent is all ones, it's an INF or a NAN.
-         */
+	/*
+	 * When the exponent is all ones, it's an INF or a NAN.
+	 */
 
-        return zeroMantissa ? FP_INFINITE : FP_NAN;
+	return zeroMantissa ? FP_INFINITE : FP_NAN;
     default:
-        /*
-         * Everything else is a NORMAL double precision float.
-         */
+	/*
+	 * Everything else is a NORMAL double precision float.
+	 */
 
-        return FP_NORMAL;
+	return FP_NORMAL;
     }
 #elif TCL_FPCLASSIFY_MODE == 1
     switch (_fpclass(d)) {
     case _FPCLASS_NZ:
     case _FPCLASS_PZ:
-        return FP_ZERO;
+	return FP_ZERO;
     case _FPCLASS_NN:
     case _FPCLASS_PN:
-        return FP_NORMAL;
+	return FP_NORMAL;
     case _FPCLASS_ND:
     case _FPCLASS_PD:
-        return FP_SUBNORMAL;
+	return FP_SUBNORMAL;
     case _FPCLASS_NINF:
     case _FPCLASS_PINF:
-        return FP_INFINITE;
+	return FP_INFINITE;
     default:
-        Tcl_Panic("result of _fpclass() outside documented range!");
+	Tcl_Panic("result of _fpclass() outside documented range!");
     case _FPCLASS_QNAN:
     case _FPCLASS_SNAN:
-        return FP_NAN;
+	return FP_NAN;
     }
 #else /* TCL_FPCLASSIFY_MODE not in (0..3) */
 #error "unknown or unexpected TCL_FPCLASSIFY_MODE"
@@ -8713,14 +8710,14 @@ ExprIsFiniteFunc(
     }
 
     if (Tcl_GetNumberFromObj(interp, objv[1], &ptr, &type) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (type != TCL_NUMBER_NAN) {
-        if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
-            return TCL_ERROR;
-        }
-        type = ClassifyDouble(d);
-        result = (type != FP_INFINITE && type != FP_NAN);
+	if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	type = ClassifyDouble(d);
+	result = (type != FP_INFINITE && type != FP_NAN);
     }
     Tcl_SetObjResult(interp, Tcl_NewBooleanObj(result));
     return TCL_OK;
@@ -8744,13 +8741,13 @@ ExprIsInfinityFunc(
     }
 
     if (Tcl_GetNumberFromObj(interp, objv[1], &ptr, &type) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (type != TCL_NUMBER_NAN) {
-        if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
-            return TCL_ERROR;
-        }
-        result = (ClassifyDouble(d) == FP_INFINITE);
+	if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	result = (ClassifyDouble(d) == FP_INFINITE);
     }
     Tcl_SetObjResult(interp, Tcl_NewBooleanObj(result));
     return TCL_OK;
@@ -8774,13 +8771,13 @@ ExprIsNaNFunc(
     }
 
     if (Tcl_GetNumberFromObj(interp, objv[1], &ptr, &type) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (type != TCL_NUMBER_NAN) {
-        if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
-            return TCL_ERROR;
-        }
-        result = (ClassifyDouble(d) == FP_NAN);
+	if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	result = (ClassifyDouble(d) == FP_NAN);
     }
     Tcl_SetObjResult(interp, Tcl_NewBooleanObj(result));
     return TCL_OK;
@@ -8804,13 +8801,13 @@ ExprIsNormalFunc(
     }
 
     if (Tcl_GetNumberFromObj(interp, objv[1], &ptr, &type) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (type != TCL_NUMBER_NAN) {
-        if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
-            return TCL_ERROR;
-        }
-        result = (ClassifyDouble(d) == FP_NORMAL);
+	if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	result = (ClassifyDouble(d) == FP_NORMAL);
     }
     Tcl_SetObjResult(interp, Tcl_NewBooleanObj(result));
     return TCL_OK;
@@ -8834,13 +8831,13 @@ ExprIsSubnormalFunc(
     }
 
     if (Tcl_GetNumberFromObj(interp, objv[1], &ptr, &type) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (type != TCL_NUMBER_NAN) {
-        if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
-            return TCL_ERROR;
-        }
-        result = (ClassifyDouble(d) == FP_SUBNORMAL);
+	if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	result = (ClassifyDouble(d) == FP_SUBNORMAL);
     }
     Tcl_SetObjResult(interp, Tcl_NewBooleanObj(result));
     return TCL_OK;
@@ -8864,23 +8861,23 @@ ExprIsUnorderedFunc(
     }
 
     if (Tcl_GetNumberFromObj(interp, objv[1], &ptr, &type) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (type == TCL_NUMBER_NAN) {
-        result = 1;
+	result = 1;
     } else {
-        d = *((const double *) ptr);
-        result = (ClassifyDouble(d) == FP_NAN);
+	d = *((const double *) ptr);
+	result = (ClassifyDouble(d) == FP_NAN);
     }
 
     if (Tcl_GetNumberFromObj(interp, objv[2], &ptr, &type) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (type == TCL_NUMBER_NAN) {
-        result |= 1;
+	result |= 1;
     } else {
-        d = *((const double *) ptr);
-        result |= (ClassifyDouble(d) == FP_NAN);
+	d = *((const double *) ptr);
+	result |= (ClassifyDouble(d) == FP_NAN);
     }
 
     Tcl_SetObjResult(interp, Tcl_NewBooleanObj(result));
@@ -8901,39 +8898,39 @@ FloatClassifyObjCmd(
     int type;
 
     if (objc != 2) {
-        Tcl_WrongNumArgs(interp, 1, objv, "floatValue");
+	Tcl_WrongNumArgs(interp, 1, objv, "floatValue");
 	return TCL_ERROR;
     }
 
     if (Tcl_GetNumberFromObj(interp, objv[1], &ptr, &type) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (type == TCL_NUMBER_NAN) {
-        goto gotNaN;
+	goto gotNaN;
     } else if (Tcl_GetDoubleFromObj(interp, objv[1], &d) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     switch (ClassifyDouble(d)) {
     case FP_INFINITE:
-        TclNewLiteralStringObj(objPtr, "infinite");
-        break;
+	TclNewLiteralStringObj(objPtr, "infinite");
+	break;
     case FP_NAN:
     gotNaN:
-        TclNewLiteralStringObj(objPtr, "nan");
-        break;
+	TclNewLiteralStringObj(objPtr, "nan");
+	break;
     case FP_NORMAL:
-        TclNewLiteralStringObj(objPtr, "normal");
-        break;
+	TclNewLiteralStringObj(objPtr, "normal");
+	break;
     case FP_SUBNORMAL:
-        TclNewLiteralStringObj(objPtr, "subnormal");
-        break;
+	TclNewLiteralStringObj(objPtr, "subnormal");
+	break;
     case FP_ZERO:
-        TclNewLiteralStringObj(objPtr, "zero");
-        break;
+	TclNewLiteralStringObj(objPtr, "zero");
+	break;
     default:
-        Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "unable to classify number: %f", d));
-        return TCL_ERROR;
+	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+		"unable to classify number: %f", d));
+	return TCL_ERROR;
     }
     Tcl_SetObjResult(interp, objPtr);
     return TCL_OK;
@@ -8966,10 +8963,10 @@ MathFuncWrongNumArgs(
     const char *name = TclGetString(objv[0]);
     const char *tail = name + strlen(name);
 
-    while (tail > name+1) {
+    while (tail > name + 1) {
 	tail--;
 	if (*tail == ':' && tail[-1] == ':') {
-	    name = tail+1;
+	    name = tail + 1;
 	    break;
 	}
     }
@@ -9198,7 +9195,7 @@ Tcl_NRCreateCommand(
 				 * calls. */
     Tcl_ObjCmdProc *nreProc,	/* Object-based function to associate with
 				 * name, provides NR implementation */
-    void *clientData,	/* Arbitrary value to pass to object
+    void *clientData,		/* Arbitrary value to pass to object
 				 * function. */
     Tcl_CmdDeleteProc *deleteProc)
 				/* If not NULL, gives a function to call when
@@ -9206,7 +9203,7 @@ Tcl_NRCreateCommand(
 {
     Command *cmdPtr = (Command *)
 	    Tcl_CreateObjCommand(interp, cmdName, proc, clientData,
-                    deleteProc);
+		    deleteProc);
 
     cmdPtr->nreProc = nreProc;
     return (Tcl_Command) cmdPtr;
@@ -9223,8 +9220,8 @@ TclNRCreateCommandInNs(
     Tcl_CmdDeleteProc *deleteProc)
 {
     Command *cmdPtr = (Command *)
-            TclCreateObjCommandInNs(interp, cmdName, nsPtr, proc, clientData,
-                    deleteProc);
+	    TclCreateObjCommandInNs(interp, cmdName, nsPtr, proc, clientData,
+		    deleteProc);
 
     cmdPtr->nreProc = nreProc;
     return (Tcl_Command) cmdPtr;
@@ -9247,7 +9244,7 @@ int
 Tcl_NREvalObjv(
     Tcl_Interp *interp,		/* Interpreter in which to evaluate the
 				 * command. Also used for error reporting. */
-    Tcl_Size objc,			/* Number of words in command. */
+    Tcl_Size objc,		/* Number of words in command. */
     Tcl_Obj *const objv[],	/* An array of pointers to objects that are
 				 * the words that make up the command. */
     int flags)			/* Collection of OR-ed bits that control the
@@ -9288,14 +9285,14 @@ Tcl_NRCmdSwap(
  *   will execute. There are functions whose purpose is to help define the
  *   precise spot:
  *     TclMarkTailcall: if the NEXT command to be pushed tailcalls, execution
- *         should continue right here
+ *	 should continue right here
  *     TclSkipTailcall:  if the NEXT command to be pushed tailcalls, execution
- *         should continue after the CURRENT command is fully returned ("skip
- *         the next command: we are redirecting to it, tailcalls should run
- *         after WE return")
+ *	 should continue after the CURRENT command is fully returned ("skip
+ *	 the next command: we are redirecting to it, tailcalls should run
+ *	 after WE return")
  *     TclPushTailcallPoint: the search for a tailcalling spot cannot traverse
- *         this point. This is special for OO, as some of the oo constructs
- *         that behave like commands may not push an NRCommand callback.
+ *	 this point. This is special for OO, as some of the oo constructs
+ *	 that behave like commands may not push an NRCommand callback.
  */
 
 void
@@ -9306,8 +9303,8 @@ TclMarkTailcall(
 
     if (iPtr->deferredCallbacks == NULL) {
 	TclNRAddCallback(interp, NRCommand, NULL, NULL,
-                NULL, NULL);
-        iPtr->deferredCallbacks = TOP_CB(interp);
+		NULL, NULL);
+	iPtr->deferredCallbacks = TOP_CB(interp);
     }
 }
 
@@ -9354,12 +9351,12 @@ TclSetTailcall(
     NRE_callback *runPtr;
 
     for (runPtr = TOP_CB(interp); runPtr; runPtr = runPtr->nextPtr) {
-        if (((runPtr->procPtr) == NRCommand) && !runPtr->data[1]) {
-            break;
-        }
+	if (((runPtr->procPtr) == NRCommand) && !runPtr->data[1]) {
+	    break;
+	}
     }
     if (!runPtr) {
-        Tcl_Panic("tailcall cannot find the right splicing spot: should not happen!");
+	Tcl_Panic("tailcall cannot find the right splicing spot: should not happen!");
     }
     runPtr->data[1] = listPtr;
 }
@@ -9395,9 +9392,9 @@ TclNRTailcallObjCmd(
     }
 
     if (!(iPtr->varFramePtr->isProcCallFrame & 1)) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "tailcall can only be called from a proc, lambda or method", TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "TAILCALL", "ILLEGAL", (char *)NULL);
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"tailcall can only be called from a proc, lambda or method", TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "TAILCALL", "ILLEGAL", (char *)NULL);
 	return TCL_ERROR;
     }
 
@@ -9407,8 +9404,8 @@ TclNRTailcallObjCmd(
      */
 
     if (iPtr->varFramePtr->tailcallPtr) {
-        Tcl_DecrRefCount(iPtr->varFramePtr->tailcallPtr);
-        iPtr->varFramePtr->tailcallPtr = NULL;
+	Tcl_DecrRefCount(iPtr->varFramePtr->tailcallPtr);
+	iPtr->varFramePtr->tailcallPtr = NULL;
     }
 
     /*
@@ -9418,19 +9415,19 @@ TclNRTailcallObjCmd(
      */
 
     if (objc > 1) {
-        Tcl_Obj *listPtr, *nsObjPtr;
-        Tcl_Namespace *nsPtr = (Tcl_Namespace *) iPtr->varFramePtr->nsPtr;
+	Tcl_Obj *listPtr, *nsObjPtr;
+	Tcl_Namespace *nsPtr = (Tcl_Namespace *) iPtr->varFramePtr->nsPtr;
 
-        /*
-         * The tailcall data is in a Tcl list: the first element is the
-         * namespace, the rest the command to be tailcalled.
-         */
+	/*
+	 * The tailcall data is in a Tcl list: the first element is the
+	 * namespace, the rest the command to be tailcalled.
+	 */
 
-        nsObjPtr = Tcl_NewStringObj(nsPtr->fullName, TCL_INDEX_NONE);
-        listPtr = Tcl_NewListObj(objc, objv);
+	nsObjPtr = Tcl_NewStringObj(nsPtr->fullName, TCL_INDEX_NONE);
+	listPtr = Tcl_NewListObj(objc, objv);
  	TclListObjSetElement(interp, listPtr, 0, nsObjPtr);
 
-        iPtr->varFramePtr->tailcallPtr = listPtr;
+	iPtr->varFramePtr->tailcallPtr = listPtr;
     }
     return TCL_RETURN;
 }
@@ -9465,13 +9462,13 @@ TclNRTailcallEval(
     }
 
     if (result != TCL_OK) {
-        /*
-         * Tailcall execution was preempted, eg by an intervening catch or by
-         * a now-gone namespace: cleanup and return.
-         */
+	/*
+	 * Tailcall execution was preempted, eg by an intervening catch or by
+	 * a now-gone namespace: cleanup and return.
+	 */
 
 	Tcl_DecrRefCount(listPtr);
-        return result;
+	return result;
     }
 
     /*
@@ -9558,7 +9555,7 @@ TclNRYieldObjCmd(
 
     if (!corPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "yield can only be called in a coroutine", TCL_INDEX_NONE));
+		"yield can only be called in a coroutine", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ILLEGAL_YIELD", (char *)NULL);
 	return TCL_ERROR;
     }
@@ -9569,7 +9566,7 @@ TclNRYieldObjCmd(
 
     NRE_ASSERT(!COR_IS_SUSPENDED(corPtr));
     TclNRAddCallback(interp, TclNRCoroutineActivateCallback, corPtr,
-            clientData, NULL, NULL);
+	    clientData, NULL, NULL);
     return TCL_OK;
 }
 
@@ -9591,17 +9588,17 @@ TclNRYieldToObjCmd(
 
     if (!corPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "yieldto can only be called in a coroutine", TCL_INDEX_NONE));
+		"yieldto can only be called in a coroutine", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ILLEGAL_YIELD", (char *)NULL);
 	return TCL_ERROR;
     }
 
     if (((Namespace *) nsPtr)->flags & NS_DYING) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"yieldto called in deleted namespace", TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "YIELDTO_IN_DELETED",
+	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "YIELDTO_IN_DELETED",
 		(char *)NULL);
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
 
     /*
@@ -9766,14 +9763,14 @@ NRCoroutineExitCallback(
  *
  * TclNRCoroutineActivateCallback --
  *
- *      This is the workhorse for coroutines: it implements both yield and
- *      resume.
+ *	This is the workhorse for coroutines: it implements both yield and
+ *	resume.
  *
- *      It is important that both be implemented in the same callback: the
- *      detection of the impossibility to suspend due to a busy C-stack relies
- *      on the precise position of a local variable in the stack. We do not
- *      want the compiler to play tricks on us, either by moving things around
- *      or inlining.
+ *	It is important that both be implemented in the same callback: the
+ *	detection of the impossibility to suspend due to a busy C-stack relies
+ *	on the precise position of a local variable in the stack. We do not
+ *	want the compiler to play tricks on us, either by moving things around
+ *	or inlining.
  *
  *----------------------------------------------------------------------
  */
@@ -9788,35 +9785,35 @@ TclNRCoroutineActivateCallback(
     void *stackLevel = TclGetCStackPtr();
 
     if (!corPtr->stackLevel) {
-        /*
-         * -- Coroutine is suspended --
-         * Push the callback to restore the caller's context on yield or
-         * return.
-         */
-
-        TclNRAddCallback(interp, NRCoroutineCallerCallback, corPtr,
-                NULL, NULL, NULL);
-
-        /*
-         * Record the stackLevel at which the resume is happening, then swap
-         * the interp's environment to make it suitable to run this coroutine.
-         */
-
-        corPtr->stackLevel = stackLevel;
-        Tcl_Size numLevels = corPtr->auxNumLevels;
-        corPtr->auxNumLevels = iPtr->numLevels;
-
-        SAVE_CONTEXT(corPtr->caller);
-        corPtr->callerEEPtr = iPtr->execEnvPtr;
-        RESTORE_CONTEXT(corPtr->running);
-        iPtr->execEnvPtr = corPtr->eePtr;
-        iPtr->numLevels += numLevels;
+	/*
+	 * -- Coroutine is suspended --
+	 * Push the callback to restore the caller's context on yield or
+	 * return.
+	 */
+
+	TclNRAddCallback(interp, NRCoroutineCallerCallback, corPtr,
+		NULL, NULL, NULL);
+
+	/*
+	 * Record the stackLevel at which the resume is happening, then swap
+	 * the interp's environment to make it suitable to run this coroutine.
+	 */
+
+	corPtr->stackLevel = stackLevel;
+	Tcl_Size numLevels = corPtr->auxNumLevels;
+	corPtr->auxNumLevels = iPtr->numLevels;
+
+	SAVE_CONTEXT(corPtr->caller);
+	corPtr->callerEEPtr = iPtr->execEnvPtr;
+	RESTORE_CONTEXT(corPtr->running);
+	iPtr->execEnvPtr = corPtr->eePtr;
+	iPtr->numLevels += numLevels;
     } else {
-        /*
-         * Coroutine is active: yield
-         */
+	/*
+	 * Coroutine is active: yield
+	 */
 
-        if (corPtr->stackLevel != stackLevel) {
+	if (corPtr->stackLevel != stackLevel) {
 	    NRE_callback *runPtr;
 
 	    iPtr->execEnvPtr = corPtr->callerEEPtr;
@@ -9833,30 +9830,30 @@ TclNRCoroutineActivateCallback(
 	    iPtr->execEnvPtr = corPtr->eePtr;
 
 
-            Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                    "cannot yield: C stack busy", TCL_INDEX_NONE));
-            Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "CANT_YIELD",
-                    (char *)NULL);
-            return TCL_ERROR;
-        }
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		    "cannot yield: C stack busy", TCL_INDEX_NONE));
+	    Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "CANT_YIELD",
+		    (char *)NULL);
+	    return TCL_ERROR;
+	}
 
-        void *type = data[1];
-        if (type == CORO_ACTIVATE_YIELD) {
-            corPtr->nargs = COROUTINE_ARGUMENTS_SINGLE_OPTIONAL;
-        } else if (type == CORO_ACTIVATE_YIELDM) {
-            corPtr->nargs = COROUTINE_ARGUMENTS_ARBITRARY;
-        } else {
-            Tcl_Panic("Yield received an option which is not implemented");
-        }
+	void *type = data[1];
+	if (type == CORO_ACTIVATE_YIELD) {
+	    corPtr->nargs = COROUTINE_ARGUMENTS_SINGLE_OPTIONAL;
+	} else if (type == CORO_ACTIVATE_YIELDM) {
+	    corPtr->nargs = COROUTINE_ARGUMENTS_ARBITRARY;
+	} else {
+	    Tcl_Panic("Yield received an option which is not implemented");
+	}
 
 	corPtr->yieldPtr = NULL;
-        corPtr->stackLevel = NULL;
+	corPtr->stackLevel = NULL;
 
-        Tcl_Size numLevels = iPtr->numLevels;
-        iPtr->numLevels = corPtr->auxNumLevels;
-        corPtr->auxNumLevels = numLevels - corPtr->auxNumLevels;
+	Tcl_Size numLevels = iPtr->numLevels;
+	iPtr->numLevels = corPtr->auxNumLevels;
+	corPtr->auxNumLevels = numLevels - corPtr->auxNumLevels;
 
-        iPtr->execEnvPtr = corPtr->callerEEPtr;
+	iPtr->execEnvPtr = corPtr->callerEEPtr;
     }
 
     return TCL_OK;
@@ -9922,11 +9919,11 @@ CoroTypeObjCmd(
 
     cmdPtr = (Command *) Tcl_GetCommandFromObj(interp, objv[1]);
     if ((!cmdPtr) || (cmdPtr->nreProc != TclNRInterpCoroutine)) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "can only get coroutine type of a coroutine", TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COROUTINE",
-                TclGetString(objv[1]), (char *)NULL);
-        return TCL_ERROR;
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"can only get coroutine type of a coroutine", TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COROUTINE",
+		TclGetString(objv[1]), (char *)NULL);
+	return TCL_ERROR;
     }
 
     /*
@@ -9936,8 +9933,8 @@ CoroTypeObjCmd(
 
     corPtr = (CoroutineData *)cmdPtr->objClientData;
     if (!COR_IS_SUSPENDED(corPtr)) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj("active", TCL_INDEX_NONE));
-        return TCL_OK;
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("active", TCL_INDEX_NONE));
+	return TCL_OK;
     }
 
     /*
@@ -9947,16 +9944,16 @@ CoroTypeObjCmd(
 
     switch (corPtr->nargs) {
     case COROUTINE_ARGUMENTS_SINGLE_OPTIONAL:
-        Tcl_SetObjResult(interp, Tcl_NewStringObj("yield", TCL_INDEX_NONE));
-        return TCL_OK;
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("yield", TCL_INDEX_NONE));
+	return TCL_OK;
     case COROUTINE_ARGUMENTS_ARBITRARY:
-        Tcl_SetObjResult(interp, Tcl_NewStringObj("yieldto", TCL_INDEX_NONE));
-        return TCL_OK;
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("yieldto", TCL_INDEX_NONE));
+	return TCL_OK;
     default:
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "unknown coroutine type", TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "BAD_TYPE", (char *)NULL);
-        return TCL_ERROR;
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"unknown coroutine type", TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "BAD_TYPE", (char *)NULL);
+	return TCL_ERROR;
     }
 }
 
@@ -9983,10 +9980,10 @@ GetCoroutineFromObj(
     Command *cmdPtr = (Command *) Tcl_GetCommandFromObj(interp, objPtr);
 
     if ((!cmdPtr) || (cmdPtr->nreProc != TclNRInterpCoroutine)) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(errMsg, TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COROUTINE",
-                TclGetString(objPtr), (char *)NULL);
-        return NULL;
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(errMsg, TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COROUTINE",
+		TclGetString(objPtr), (char *)NULL);
+	return NULL;
     }
     return (CoroutineData *)cmdPtr->objClientData;
 }
@@ -10011,15 +10008,15 @@ TclNRCoroInjectObjCmd(
     }
 
     corPtr = GetCoroutineFromObj(interp, objv[1],
-            "can only inject a command into a coroutine");
+	    "can only inject a command into a coroutine");
     if (!corPtr) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (!COR_IS_SUSPENDED(corPtr)) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "can only inject a command into a suspended coroutine", TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ACTIVE", (char *)NULL);
-        return TCL_ERROR;
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"can only inject a command into a suspended coroutine", TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ACTIVE", (char *)NULL);
+	return TCL_ERROR;
     }
 
     /*
@@ -10030,7 +10027,7 @@ TclNRCoroInjectObjCmd(
     ExecEnv *savedEEPtr = iPtr->execEnvPtr;
     iPtr->execEnvPtr = corPtr->eePtr;
     TclNRAddCallback(interp, InjectHandler, corPtr,
-            Tcl_NewListObj(objc - 2, objv + 2), INT2PTR(corPtr->nargs), NULL);
+	    Tcl_NewListObj(objc - 2, objv + 2), INT2PTR(corPtr->nargs), NULL);
     iPtr->execEnvPtr = savedEEPtr;
 
     return TCL_OK;
@@ -10056,16 +10053,16 @@ TclNRCoroProbeObjCmd(
     }
 
     corPtr = GetCoroutineFromObj(interp, objv[1],
-            "can only inject a probe command into a coroutine");
+	    "can only inject a probe command into a coroutine");
     if (!corPtr) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (!COR_IS_SUSPENDED(corPtr)) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "can only inject a probe command into a suspended coroutine",
-                TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ACTIVE", (char *)NULL);
-        return TCL_ERROR;
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"can only inject a probe command into a suspended coroutine",
+		TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ACTIVE", (char *)NULL);
+	return TCL_ERROR;
     }
 
     /*
@@ -10076,7 +10073,7 @@ TclNRCoroProbeObjCmd(
     ExecEnv *savedEEPtr = iPtr->execEnvPtr;
     iPtr->execEnvPtr = corPtr->eePtr;
     TclNRAddCallback(interp, InjectHandler, corPtr,
-            Tcl_NewListObj(objc - 2, objv + 2), INT2PTR(corPtr->nargs), corPtr);
+	    Tcl_NewListObj(objc - 2, objv + 2), INT2PTR(corPtr->nargs), corPtr);
     iPtr->execEnvPtr = savedEEPtr;
 
     /*
@@ -10087,7 +10084,7 @@ TclNRCoroProbeObjCmd(
      */
 
     TclNRAddCallback(interp, NRCoroutineCallerCallback, corPtr,
-            NULL, NULL, NULL);
+	    NULL, NULL, NULL);
 
     /*
      * Record the stackLevel at which the resume is happening, then swap
@@ -10115,18 +10112,18 @@ TclNRCoroProbeObjCmd(
  *
  * InjectHandler, InjectHandlerPostProc --
  *
- *      Part of the implementation of [coroinject] and [coroprobe]. These are
- *      run inside the context of the coroutine being injected/probed into.
+ *	Part of the implementation of [coroinject] and [coroprobe]. These are
+ *	run inside the context of the coroutine being injected/probed into.
  *
- *      InjectHandler runs a script (possibly adding arguments) in the context
- *      of the coroutine. The script is specified as a one-shot list (with
- *      reference count equal to 1) in data[1]. This function also arranges
- *      for InjectHandlerPostProc to be the part that runs after the script
- *      completes.
+ *	InjectHandler runs a script (possibly adding arguments) in the context
+ *	of the coroutine. The script is specified as a one-shot list (with
+ *	reference count equal to 1) in data[1]. This function also arranges
+ *	for InjectHandlerPostProc to be the part that runs after the script
+ *	completes.
  *
- *      InjectHandlerPostProc cleans up after InjectHandler (deleting the
- *      list) and, for the [coroprobe] command *only*, yields back to the
- *      caller context (i.e., where [coroprobe] was run).
+ *	InjectHandlerPostProc cleans up after InjectHandler (deleting the
+ *	list) and, for the [coroprobe] command *only*, yields back to the
+ *	caller context (i.e., where [coroprobe] was run).
  *s
  *----------------------------------------------------------------------
  */
@@ -10173,7 +10170,7 @@ InjectHandler(
     Tcl_IncrRefCount(listPtr);
     TclMarkTailcall(interp);
     TclNRAddCallback(interp, InjectHandlerPostCall, corPtr, listPtr,
-            INT2PTR(nargs), isProbe);
+	    INT2PTR(nargs), isProbe);
     TclListObjGetElements(NULL, listPtr, &objc, &objv);
     return TclNREvalObjv(interp, objc, objv, 0, NULL);
 }
@@ -10203,16 +10200,16 @@ InjectHandlerPostCall(
      */
 
     if (isProbe) {
-        if (result == TCL_ERROR) {
-            Tcl_AddErrorInfo(interp,
-                    "\n    (injected coroutine probe command)");
-        }
-        corPtr->nargs = nargs;
-        corPtr->stackLevel = NULL;
-        Tcl_Size numLevels = iPtr->numLevels;
-        iPtr->numLevels = corPtr->auxNumLevels;
-        corPtr->auxNumLevels = numLevels - corPtr->auxNumLevels;
-        iPtr->execEnvPtr = corPtr->callerEEPtr;
+	if (result == TCL_ERROR) {
+	    Tcl_AddErrorInfo(interp,
+		    "\n    (injected coroutine probe command)");
+	}
+	corPtr->nargs = nargs;
+	corPtr->stackLevel = NULL;
+	Tcl_Size numLevels = iPtr->numLevels;
+	iPtr->numLevels = corPtr->auxNumLevels;
+	corPtr->auxNumLevels = numLevels - corPtr->auxNumLevels;
+	iPtr->execEnvPtr = corPtr->callerEEPtr;
     }
     return result;
 }
@@ -10222,7 +10219,7 @@ InjectHandlerPostCall(
  *
  * NRInjectObjCmd --
  *
- *      Implementation of [::tcl::unsupported::inject] command.
+ *	Implementation of [::tcl::unsupported::inject] command.
  *
  *----------------------------------------------------------------------
  */
@@ -10248,15 +10245,15 @@ NRInjectObjCmd(
     }
 
     corPtr = GetCoroutineFromObj(interp, objv[1],
-            "can only inject a command into a coroutine");
+	    "can only inject a command into a coroutine");
     if (!corPtr) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
     if (!COR_IS_SUSPENDED(corPtr)) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "can only inject a command into a suspended coroutine", TCL_INDEX_NONE));
-        Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ACTIVE", (char *)NULL);
-        return TCL_ERROR;
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"can only inject a command into a suspended coroutine", TCL_INDEX_NONE));
+	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ACTIVE", (char *)NULL);
+	return TCL_ERROR;
     }
 
     /*
@@ -10265,8 +10262,8 @@ NRInjectObjCmd(
      */
 
     iPtr->execEnvPtr = corPtr->eePtr;
-    TclNRAddCallback(interp, TclNREvalList, Tcl_NewListObj(objc-2, objv+2),
-	NULL, NULL, NULL);
+    TclNRAddCallback(interp, TclNREvalList, Tcl_NewListObj(objc - 2, objv + 2),
+	    NULL, NULL, NULL);
     iPtr->execEnvPtr = savedEEPtr;
 
     return TCL_OK;
@@ -10283,8 +10280,8 @@ TclNRInterpCoroutine(
 
     if (!COR_IS_SUSPENDED(corPtr)) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "coroutine \"%s\" is already running",
-                TclGetString(objv[0])));
+		"coroutine \"%s\" is already running",
+		TclGetString(objv[0])));
 	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "BUSY", (char *)NULL);
 	return TCL_ERROR;
     }
@@ -10297,31 +10294,31 @@ TclNRInterpCoroutine(
 
     switch (corPtr->nargs) {
     case COROUTINE_ARGUMENTS_SINGLE_OPTIONAL:
-        if (objc == 2) {
-            Tcl_SetObjResult(interp, objv[1]);
-        } else if (objc > 2) {
-            Tcl_WrongNumArgs(interp, 1, objv, "?arg?");
-            return TCL_ERROR;
-        }
-        break;
+	if (objc == 2) {
+	    Tcl_SetObjResult(interp, objv[1]);
+	} else if (objc > 2) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "?arg?");
+	    return TCL_ERROR;
+	}
+	break;
     default:
-        if (corPtr->nargs + 1 != objc) {
-            Tcl_SetObjResult(interp,
-                    Tcl_NewStringObj("wrong coro nargs; how did we get here? "
-                    "not implemented!", TCL_INDEX_NONE));
-            Tcl_SetErrorCode(interp, "TCL", "WRONGARGS", (char *)NULL);
-            return TCL_ERROR;
-        }
-        /* fallthrough */
+	if (corPtr->nargs + 1 != objc) {
+	    Tcl_SetObjResult(interp,
+		    Tcl_NewStringObj("wrong coro nargs; how did we get here? "
+		    "not implemented!", TCL_INDEX_NONE));
+	    Tcl_SetErrorCode(interp, "TCL", "WRONGARGS", (char *)NULL);
+	    return TCL_ERROR;
+	}
+	/* fallthrough */
     case COROUTINE_ARGUMENTS_ARBITRARY:
-        if (objc > 1) {
-            Tcl_SetObjResult(interp, Tcl_NewListObj(objc-1, objv+1));
-        }
-        break;
+	if (objc > 1) {
+	    Tcl_SetObjResult(interp, Tcl_NewListObj(objc - 1, objv + 1));
+	}
+	break;
     }
 
     TclNRAddCallback(interp, TclNRCoroutineActivateCallback, corPtr,
-            NULL, NULL, NULL);
+	    NULL, NULL, NULL);
     return TCL_OK;
 }
 
@@ -10330,8 +10327,8 @@ TclNRInterpCoroutine(
  *
  * TclNRCoroutineObjCmd --
  *
- *      Implementation of [coroutine] command; see documentation for
- *      description of what this does.
+ *	Implementation of [coroutine] command; see documentation for
+ *	description of what this does.
  *
  *----------------------------------------------------------------------
  */
@@ -10361,16 +10358,16 @@ TclNRCoroutineObjCmd(
 
     if (nsPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "can't create procedure \"%s\": unknown namespace",
-                procName));
-        Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "NAMESPACE", (char *)NULL);
+		"can't create procedure \"%s\": unknown namespace",
+		procName));
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "NAMESPACE", (char *)NULL);
 	return TCL_ERROR;
     }
     if (simpleName == NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                "can't create procedure \"%s\": bad procedure name",
-                procName));
-        Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMMAND", procName, (char *)NULL);
+		"can't create procedure \"%s\": bad procedure name",
+		procName));
+	Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMMAND", procName, (char *)NULL);
 	return TCL_ERROR;
     }
 
@@ -10462,7 +10459,7 @@ TclNRCoroutineObjCmd(
      */
 
     TclNRAddCallback(interp, TclNRCoroutineActivateCallback, corPtr,
-            NULL, NULL, NULL);
+	    NULL, NULL, NULL);
     return TCL_OK;
 }