Minor changes to improve style (C89 declarations, consistent indentation,

clarification of #endifs, reduction of unnecessary casts, use of array syntax
for reading array elements, etc.)

FossilOrigin-Name: 3995dbcf90f781e3ada9e350f501dbb1bf5550be

11 files changed, 746 insertions, 542 deletions

diff --git a/generic/tclCkalloc.c b/generic/tclCkalloc.c
index 6443975..ab977cb 100644
--- a/generic/tclCkalloc.c
+++ b/generic/tclCkalloc.c
@@ -170,11 +170,15 @@ TclInitDbCkalloc(void)
  */
 
 int
-TclDumpMemoryInfo(ClientData clientData, int flags)
+TclDumpMemoryInfo(
+    ClientData clientData,
+    int flags)
 {
     char buf[1024];
 
-    if (clientData == NULL) { return 0; }
+    if (clientData == NULL) {
+        return 0;
+    }
     sprintf(buf,
 	    "total mallocs             %10d\n"
 	    "total frees               %10d\n"
@@ -1255,7 +1259,9 @@ Tcl_ValidateAllMemory(
 }
 
 int
-TclDumpMemoryInfo(ClientData clientData, int flags)
+TclDumpMemoryInfo(
+    ClientData clientData,
+    int flags)
 {
     return 1;
 }
diff --git a/generic/tclIORChan.c b/generic/tclIORChan.c
index a354d60..cb0282a 100644
--- a/generic/tclIORChan.c
+++ b/generic/tclIORChan.c
@@ -1774,7 +1774,9 @@ ReflectBlock(
  */
 
 static void
-ReflectThread(ClientData clientData, int action)
+ReflectThread(
+    ClientData clientData,
+    int action)
 {
     ReflectedChannel *rcPtr = clientData;
 
diff --git a/generic/tclIOUtil.c b/generic/tclIOUtil.c
index 4df7f36..2d6d898 100644
--- a/generic/tclIOUtil.c
+++ b/generic/tclIOUtil.c
@@ -648,23 +648,26 @@ TclFSEpochOk(
 }
 
 static void
-Claim()
+Claim(void)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&fsDataKey);
+
     tsdPtr->claims++;
 }
 
 static void
-Disclaim()
+Disclaim(void)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&fsDataKey);
+
     tsdPtr->claims--;
 }
 
 int
-TclFSEpoch()
+TclFSEpoch(void)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&fsDataKey);
+
     return tsdPtr->filesystemEpoch;
 }
 
diff --git a/generic/tclMain.c b/generic/tclMain.c
index 88b4e51..14139ec 100644
--- a/generic/tclMain.c
+++ b/generic/tclMain.c
@@ -16,11 +16,12 @@
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
-/**
- * On Windows, this file needs to be compiled twice, once with
- * TCL_ASCII_MAIN defined. This way both Tcl_Main and Tcl_MainExW
- * can be implemented, sharing the same source code.
+/*
+ * On Windows, this file needs to be compiled twice, once with TCL_ASCII_MAIN
+ * defined. This way both Tcl_Main and Tcl_MainExW can be implemented, sharing
+ * the same source code.
  */
+
 #if defined(TCL_ASCII_MAIN)
 #   ifdef UNICODE
 #	undef UNICODE
@@ -40,12 +41,12 @@
 #define DEFAULT_PRIMARY_PROMPT	"% "
 
 /*
- * This file can be compiled on Windows in UNICODE mode, as well as
- * on all other platforms using the native encoding. This is done
- * by using the normal Windows functions like _tcscmp, but on
- * platforms which don't have <tchar.h> we have to translate that
- * to strcmp here.
+ * This file can be compiled on Windows in UNICODE mode, as well as on all
+ * other platforms using the native encoding. This is done by using the normal
+ * Windows functions like _tcscmp, but on platforms which don't have <tchar.h>
+ * we have to translate that to strcmp here.
  */
+
 #ifndef __WIN32__
 #   define TCHAR char
 #   define TEXT(arg) arg
@@ -128,10 +129,11 @@ typedef struct InteractiveState {
 MODULE_SCOPE Tcl_MainLoopProc *TclGetMainLoop(void);
 static void		Prompt(Tcl_Interp *interp, InteractiveState *isPtr);
 static void		StdinProc(ClientData clientData, int mask);
-static void     FreeMainInterp(ClientData clientData);
+static void		FreeMainInterp(ClientData clientData);
 
 #ifndef TCL_ASCII_MAIN
 static Tcl_ThreadDataKey dataKey;
+
 /*
  *----------------------------------------------------------------------
  *
@@ -333,8 +335,9 @@ Tcl_MainEx(
 
 	if ((argc > 3) && (0 == _tcscmp(TEXT("-encoding"), argv[1]))
 		&& (TEXT('-') != argv[3][0])) {
-		Tcl_Obj *value = NewNativeObj(argv[2], -1);
-	    Tcl_SetStartupScript(NewNativeObj(argv[3], -1), Tcl_GetString(value));
+	    Tcl_Obj *value = NewNativeObj(argv[2], -1);
+	    Tcl_SetStartupScript(NewNativeObj(argv[3], -1),
+		    Tcl_GetString(value));
 	    Tcl_DecrRefCount(value);
 	    argc -= 3;
 	    argv += 3;
@@ -395,8 +398,9 @@ Tcl_MainEx(
 	/*
 	 * Arrange for final deletion of the main interp
 	 */
-	/* ARGH Munchhausen effect  */
-	Tcl_CreateExitHandler(FreeMainInterp, (ClientData)interp);
+
+	/* ARGH Munchhausen effect */
+	Tcl_CreateExitHandler(FreeMainInterp, interp);
     }
 
     /*
@@ -458,6 +462,7 @@ Tcl_MainEx(
 	mainLoopProc = TclGetMainLoop();
 	if (mainLoopProc == NULL) {
 	    int length;
+
 	    if (is.tty) {
 		Prompt(interp, &is);
 		if (Tcl_InterpDeleted(interp)) {
@@ -523,7 +528,8 @@ Tcl_MainEx(
 
 	    Tcl_GetStringFromObj(is.commandPtr, &length);
 	    Tcl_SetObjLength(is.commandPtr, --length);
-	    code = Tcl_RecordAndEvalObj(interp, is.commandPtr, TCL_EVAL_GLOBAL);
+	    code = Tcl_RecordAndEvalObj(interp, is.commandPtr,
+		    TCL_EVAL_GLOBAL);
 	    is.input = Tcl_GetStdChannel(TCL_STDIN);
 	    Tcl_DecrRefCount(is.commandPtr);
 	    is.commandPtr = Tcl_NewObj();
@@ -557,7 +563,8 @@ Tcl_MainEx(
 		    Prompt(interp, &is);
 		}
 
-		Tcl_CreateChannelHandler(is.input, TCL_READABLE, StdinProc, &is);
+		Tcl_CreateChannelHandler(is.input, TCL_READABLE,
+			StdinProc, &is);
 	    }
 
 	    mainLoopProc();
@@ -568,24 +575,23 @@ Tcl_MainEx(
 	    }
 	    is.input = Tcl_GetStdChannel(TCL_STDIN);
 	}
-#ifdef TCL_MEM_DEBUG
 
 	/*
 	 * This code here only for the (unsupported and deprecated) [checkmem]
 	 * command.
 	 */
 
+#ifdef TCL_MEM_DEBUG
 	if (tclMemDumpFileName != NULL) {
 	    Tcl_SetMainLoop(NULL);
 	    Tcl_DeleteInterp(interp);
 	}
-#endif
+#endif /* TCL_MEM_DEBUG */
     }
 
   done:
     mainLoopProc = TclGetMainLoop();
-    if ((exitCode == 0) && (mainLoopProc != NULL)
-	    && !Tcl_LimitExceeded(interp)) {
+    if ((exitCode == 0) && mainLoopProc && !Tcl_LimitExceeded(interp)) {
 	/*
 	 * If everything has gone OK so far, call the main loop proc, if it
 	 * exists. Packages (like Tk) can set it to start processing events at
@@ -605,21 +611,21 @@ Tcl_MainEx(
      * exit. The Tcl_EvalObjEx call should never return.
      */
 
-    if (!Tcl_InterpDeleted(interp)) {
-	if (!Tcl_LimitExceeded(interp)) {
-	    Tcl_Obj *cmd = Tcl_ObjPrintf("exit %d", exitCode);
+    if (!Tcl_InterpDeleted(interp) && !Tcl_LimitExceeded(interp)) {
+	Tcl_Obj *cmd = Tcl_ObjPrintf("exit %d", exitCode);
 	    
-	    Tcl_IncrRefCount(cmd);
-	    Tcl_EvalObjEx(interp, cmd, TCL_EVAL_GLOBAL);
-	    Tcl_DecrRefCount(cmd);
-	}
+	Tcl_IncrRefCount(cmd);
+	Tcl_EvalObjEx(interp, cmd, TCL_EVAL_GLOBAL);
+	Tcl_DecrRefCount(cmd);
     }
-	/*
-	 * If Tcl_EvalObjEx returns, trying to eval [exit], something unusual
-	 * is happening. Maybe interp has been deleted; maybe [exit] was
-	 * redefined, maybe we've blown up because of an exceeded limit. We
-	 * still want to cleanup and exit.
-	 */
+
+    /*
+     * If Tcl_EvalObjEx returns, trying to eval [exit], something unusual is
+     * happening. Maybe interp has been deleted; maybe [exit] was redefined,
+     * maybe we've blown up because of an exceeded limit. We still want to
+     * cleanup and exit.
+     */
+
     Tcl_Exit(exitCode);
 }
 
@@ -637,7 +643,7 @@ Tcl_Main(
     Tcl_FindExecutable(argv[0]);
     Tcl_MainEx(argc, argv, appInitProc, Tcl_CreateInterp());
 }
-#endif
+#endif /* TCL_MAJOR_VERSION == 8 && !UNICODE */
 
 #ifndef TCL_ASCII_MAIN
 
@@ -711,6 +717,7 @@ TclGetMainLoop(void)
  *
  *----------------------------------------------------------------------
  */
+
 MODULE_SCOPE int
 TclFullFinalizationRequested(void)
 {
@@ -727,7 +734,7 @@ TclFullFinalizationRequested(void)
 	Tcl_DStringFree(&ds);
     }
     return finalize;
-#endif
+#endif /* PURIFY */
 }
 #endif /* !TCL_ASCII_MAIN */
 
@@ -866,9 +873,8 @@ StdinProc(
 static void
 Prompt(
     Tcl_Interp *interp,		/* Interpreter to use for prompting. */
-    InteractiveState *isPtr) /* InteractiveState. Filled
-				 * with PROMPT_NONE after a prompt is
-				 * printed. */
+    InteractiveState *isPtr)	/* InteractiveState. Filled with PROMPT_NONE
+				 * after a prompt is printed. */
 {
     Tcl_Obj *promptCmdPtr;
     int code;
@@ -879,7 +885,7 @@ Prompt(
     }
 
     promptCmdPtr = Tcl_GetVar2Ex(interp,
-	    ((isPtr->prompt == PROMPT_CONTINUE) ? "tcl_prompt2" : "tcl_prompt1"),
+	    (isPtr->prompt==PROMPT_CONTINUE ? "tcl_prompt2" : "tcl_prompt1"),
 	    NULL, TCL_GLOBAL_ONLY);
 
     if (Tcl_InterpDeleted(interp)) {
@@ -920,8 +926,8 @@ Prompt(
  *
  * FreeMainInterp --
  *
- *	Exit handler used to cleanup the main interpreter and ancillary startup
- *	script storage at exit.
+ *	Exit handler used to cleanup the main interpreter and ancillary
+ *	startup script storage at exit.
  *
  *----------------------------------------------------------------------
  */
@@ -930,13 +936,13 @@ static void
 FreeMainInterp(
     ClientData clientData)
 {
-	Tcl_Interp *interp = (Tcl_Interp *) clientData;
+    Tcl_Interp *interp = clientData;
 
-	/*if (TclInExit()) return;*/
+    /*if (TclInExit()) return;*/
 
-	if (!Tcl_InterpDeleted(interp)) {
-	    Tcl_DeleteInterp(interp);
-	}
+    if (!Tcl_InterpDeleted(interp)) {
+	Tcl_DeleteInterp(interp);
+    }
     Tcl_SetStartupScript(NULL, NULL);
     Tcl_Release(interp);
 }
diff --git a/generic/tclResult.c b/generic/tclResult.c
index 17aac74..9707f20 100644
--- a/generic/tclResult.c
+++ b/generic/tclResult.c
@@ -380,12 +380,10 @@ Tcl_DiscardResult(
 
     if (statePtr->result == statePtr->appendResult) {
 	ckfree(statePtr->appendResult);
+    } else if (statePtr->freeProc == TCL_DYNAMIC) {
+        ckfree(statePtr->result);
     } else if (statePtr->freeProc) {
-	if (statePtr->freeProc == TCL_DYNAMIC) {
-	    ckfree(statePtr->result);
-	} else {
-	    statePtr->freeProc(statePtr->result);
-	}
+        statePtr->freeProc(statePtr->result);
     }
 }
 
@@ -585,7 +583,7 @@ Tcl_GetObjResult(
      * result, then reset the string result.
      */
 
-    if (*(iPtr->result) != 0) {
+    if (iPtr->result[0] != 0) {
 	ResetObjResult(iPtr);
 
 	objResultPtr = iPtr->objResultPtr;
@@ -601,7 +599,7 @@ Tcl_GetObjResult(
 	    iPtr->freeProc = 0;
 	}
 	iPtr->result = iPtr->resultSpace;
-	iPtr->resultSpace[0] = 0;
+	iPtr->result[0] = 0;
     }
     return iPtr->objResultPtr;
 }
@@ -1106,9 +1104,7 @@ Tcl_SetObjErrorCode(
  *
  * Tcl_GetErrorLine --
  *
- * Results:
- *
- * Side effects:
+ *      Returns the line number associated with the current error.
  *
  *----------------------------------------------------------------------
  */
@@ -1125,9 +1121,7 @@ Tcl_GetErrorLine(
  *
  * Tcl_SetErrorLine --
  *
- * Results:
- *
- * Side effects:
+ *      Sets the line number associated with the current error.
  *
  *----------------------------------------------------------------------
  */
@@ -1274,7 +1268,8 @@ TclProcessReturn(
 	    Tcl_DecrRefCount(iPtr->errorInfo);
 	    iPtr->errorInfo = NULL;
 	}
-	Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORINFO], &valuePtr);
+	Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORINFO],
+                &valuePtr);
 	if (valuePtr != NULL) {
 	    int infoLen;
 
@@ -1285,7 +1280,8 @@ TclProcessReturn(
 		iPtr->flags |= ERR_ALREADY_LOGGED;
 	    }
 	}
-	Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORSTACK], &valuePtr);
+	Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORSTACK],
+                &valuePtr);
 	if (valuePtr != NULL) {
             int len, valueObjc;
             Tcl_Obj **valueObjv;
@@ -1298,26 +1294,36 @@ TclProcessReturn(
                 Tcl_IncrRefCount(newObj);
                 iPtr->errorStack = newObj;
             }
+
             /*
              * List extraction done after duplication to avoid moving the rug
              * if someone does [return -errorstack [info errorstack]]
              */
-            if (Tcl_ListObjGetElements(interp, valuePtr, &valueObjc, &valueObjv) == TCL_ERROR) {
+
+            if (Tcl_ListObjGetElements(interp, valuePtr, &valueObjc,
+                    &valueObjv) == TCL_ERROR) {
                 return TCL_ERROR;
             }
             iPtr->resetErrorStack = 0;
             Tcl_ListObjLength(interp, iPtr->errorStack, &len);
-            /* reset while keeping the list intrep as much as possible */
-            Tcl_ListObjReplace(interp, iPtr->errorStack, 0, len, valueObjc, valueObjv);
+
+            /*
+             * Reset while keeping the list intrep as much as possible.
+             */
+
+            Tcl_ListObjReplace(interp, iPtr->errorStack, 0, len, valueObjc,
+                    valueObjv);
  	}
-	Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORCODE], &valuePtr);
+	Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORCODE],
+                &valuePtr);
 	if (valuePtr != NULL) {
 	    Tcl_SetObjErrorCode(interp, valuePtr);
 	} else {
 	    Tcl_SetErrorCode(interp, "NONE", NULL);
 	}
 
-	Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORLINE], &valuePtr);
+	Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORLINE],
+                &valuePtr);
 	if (valuePtr != NULL) {
 	    TclGetIntFromObj(NULL, valuePtr, &iPtr->errorLine);
 	}
@@ -1421,7 +1427,8 @@ TclMergeReturnOptions(
 
     Tcl_DictObjGet(NULL, returnOpts, keys[KEY_CODE], &valuePtr);
     if (valuePtr != NULL) {
-	if (TCL_ERROR == TclGetCompletionCodeFromObj(interp, valuePtr, &code)) {
+	if (TclGetCompletionCodeFromObj(interp, valuePtr,
+                &code) == TCL_ERROR) {
 	    goto error;
 	}
 	Tcl_DictObjRemove(NULL, returnOpts, keys[KEY_CODE]);
@@ -1599,7 +1606,8 @@ Tcl_GetReturnOptions(
  *
  * TclNoErrorStack --
  *
- *	Removes the -errorstack entry from an options dict to avoid reference cycles
+ *	Removes the -errorstack entry from an options dict to avoid reference
+ *	cycles.
  *
  * Results:
  *	The (unshared) argument options dict, modified in -place.
@@ -1608,12 +1616,13 @@ Tcl_GetReturnOptions(
  */
 
 Tcl_Obj *
-TclNoErrorStack(Tcl_Interp *interp, Tcl_Obj *options)
+TclNoErrorStack(
+    Tcl_Interp *interp,
+    Tcl_Obj *options)
 {
     Tcl_Obj **keys = GetKeys();
     
     Tcl_DictObjRemove(interp, options, keys[KEY_ERRORSTACK]);
-
     return options;
 }
 
diff --git a/generic/tclUtil.c b/generic/tclUtil.c
index 6d42080..13e54ec 100644
--- a/generic/tclUtil.c
+++ b/generic/tclUtil.c
@@ -26,9 +26,9 @@ static ProcessGlobalValue executableName = {
 };
 
 /*
- * The following values are used in the flags arguments of Tcl*Scan*Element and
- * Tcl*Convert*Element. The values TCL_DONT_USE_BRACES and TCL_DONT_QUOTE_HASH
- * are defined in tcl.h, like so:
+ * The following values are used in the flags arguments of Tcl*Scan*Element
+ * and Tcl*Convert*Element.  The values TCL_DONT_USE_BRACES and
+ * TCL_DONT_QUOTE_HASH are defined in tcl.h, like so:
  *
 #define TCL_DONT_USE_BRACES     1
 #define TCL_DONT_QUOTE_HASH     8
@@ -54,8 +54,8 @@ static ProcessGlobalValue executableName = {
  * conversion is most appropriate for Tcl*Convert*Element() to perform, and
  * sets two bits of the flags value to indicate the mode selected.
  *
- * CONVERT_NONE		The element needs no quoting.  Its literal string
- *			is suitable as is.
+ * CONVERT_NONE		The element needs no quoting. Its literal string is
+ *			suitable as is.
  * CONVERT_BRACE	The conversion should be enclosing the literal string
  *			in braces.
  * CONVERT_ESCAPE	The conversion should be using backslashes to escape
@@ -63,19 +63,19 @@ static ProcessGlobalValue executableName = {
  * CONVERT_MASK		A mask value used to extract the conversion mode from
  *			the flags argument.
  *			Also indicates a strange conversion mode where all
- *			special characters are escaped with backslashes 
- *			*except for braces*.  This is a strange and unnecessary
+ *			special characters are escaped with backslashes
+ *			*except for braces*. This is a strange and unnecessary
  *			case, but it's part of the historical way in which
- *			lists have been formatted in Tcl.  To experiment with
+ *			lists have been formatted in Tcl. To experiment with
  *			removing this case, set the value of COMPAT to 0.
  *
- * One last flag value is used only by callers of TclScanElement().  The flag
+ * One last flag value is used only by callers of TclScanElement(). The flag
  * value produced by a call to Tcl*Scan*Element() will never leave this bit
  * set.
  *
- * CONVERT_ANY		The caller of TclScanElement() declares it can make
- *			no promise about what public flags will be passed to
- *			the matching call of TclConvertElement().  As such,
+ * CONVERT_ANY		The caller of TclScanElement() declares it can make no
+ *			promise about what public flags will be passed to the
+ *			matching call of TclConvertElement(). As such,
  *			TclScanElement() has to determine the worst case
  *			destination buffer length over all possibilities, and
  *			in other cases this means an overestimate of the
@@ -129,17 +129,17 @@ const Tcl_ObjType tclEndOffsetType = {
 /*
  *	*	STRING REPRESENTATION OF LISTS	*	*	*
  *
- * The next several routines implement the conversions of strings to and
- * from Tcl lists.  To understand their operation, the rules of parsing
- * and generating the string representation of lists must be known.  Here
- * we describe them in one place.
+ * The next several routines implement the conversions of strings to and from
+ * Tcl lists. To understand their operation, the rules of parsing and
+ * generating the string representation of lists must be known.  Here we
+ * describe them in one place.
  *
- * A list is made up of zero or more elements.  Any string is a list if
- * it is made up of alternating substrings of element-separating ASCII
- * whitespace and properly formatted elements.
+ * A list is made up of zero or more elements. Any string is a list if it is
+ * made up of alternating substrings of element-separating ASCII whitespace
+ * and properly formatted elements.
  *
- * The ASCII characters which can make up the whitespace between list
- * elements are:
+ * The ASCII characters which can make up the whitespace between list elements
+ * are:
  *
  *	\u0009	\t	TAB
  *	\u000A	\n	NEWLINE
@@ -158,69 +158,68 @@ const Tcl_ObjType tclEndOffsetType = {
  *	* Unlike command parsing, the BACKSLASH NEWLINE sequence is not
  *	  considered to be a whitespace character.
  *
- *	* Other Unicode whitespace characters (recognized by
- *	  [string is space] or Tcl_UniCharIsSpace()) do not play any role
- *	  as element separators in Tcl lists.
+ *	* Other Unicode whitespace characters (recognized by [string is space]
+ *	  or Tcl_UniCharIsSpace()) do not play any role as element separators
+ *	  in Tcl lists.
  *
  *	* The NUL byte ought not appear, as it is not in strings properly
  *	  encoded for Tcl, but if it is present, it is not treated as
- *	  separating whitespace, or a string terminator.  It is just
- *	  another character in a list element.
- *
- * The interpretaton of a formatted substring as a list element follows
- * rules similar to the parsing of the words of a command in a Tcl script.
- * Backslash substitution plays a key role, and is defined exactly as it is
- * in command parsing.  The same routine, TclParseBackslash() is used in both
- * command parsing and list parsing.  
- *
- * NOTE:  This means that if and when backslash substitution rules ever
- * change for command parsing, the interpretation of strings as lists also
- * changes.
+ *	  separating whitespace, or a string terminator. It is just another
+ *	  character in a list element.
+ *
+ * The interpretaton of a formatted substring as a list element follows rules
+ * similar to the parsing of the words of a command in a Tcl script. Backslash
+ * substitution plays a key role, and is defined exactly as it is in command
+ * parsing. The same routine, TclParseBackslash() is used in both command
+ * parsing and list parsing.
+ *
+ * NOTE: This means that if and when backslash substitution rules ever change
+ * for command parsing, the interpretation of strings as lists also changes.
  * 
  * Backslash substitution replaces an "escape sequence" of one or more
  * characters starting with
  *		\u005c	\	BACKSLASH
- * with a single character.  The one character escape sequent case happens
- * only when BACKSLASH is the last character in the string.  In all other
- * cases, the escape sequence is at least two characters long.
+ * with a single character. The one character escape sequent case happens only
+ * when BACKSLASH is the last character in the string. In all other cases, the
+ * escape sequence is at least two characters long.
  *
- * The formatted substrings are interpreted as element values according to
- * the following cases:
+ * The formatted substrings are interpreted as element values according to the
+ * following cases:
  *
  * * If the first character of a formatted substring is
  *		\u007b	{	OPEN BRACE
  *   then the end of the substring is the matching 
  *		\u007d	}	CLOSE BRACE
- *   character, where matching is determined by counting nesting levels,
- *   and not including any brace characters that are contained within a
- *   backslash escape sequence in the nesting count.  Having found the
- *   matching brace, all characters between the braces are the string
- *   value of the element.  If no matching close brace is found before the
- *   end of the string, the string is not a Tcl list.  If the character
- *   following the close brace is not an element separating whitespace
- *   character, or the end of the string, then the string is not a Tcl list.
- *
- *   NOTE: this differs from a brace-quoted word in the parsing of a
- *   Tcl command only in its treatment of the backslash-newline sequence.
- *   In a list element, the literal characters in the backslash-newline
- *   sequence become part of the element value.  In a script word,
- *   conversion to a single SPACE character is done.
+ *   character, where matching is determined by counting nesting levels, and
+ *   not including any brace characters that are contained within a backslash
+ *   escape sequence in the nesting count. Having found the matching brace,
+ *   all characters between the braces are the string value of the element.
+ *   If no matching close brace is found before the end of the string, the
+ *   string is not a Tcl list. If the character following the close brace is
+ *   not an element separating whitespace character, or the end of the string,
+ *   then the string is not a Tcl list.
+ *
+ *   NOTE: this differs from a brace-quoted word in the parsing of a Tcl
+ *   command only in its treatment of the backslash-newline sequence. In a
+ *   list element, the literal characters in the backslash-newline sequence
+ *   become part of the element value. In a script word, conversion to a
+ *   single SPACE character is done.
  *
  *   NOTE: Most list element values can be represented by a formatted
- *   substring using brace quoting.  The exceptions are any element value
- *   that includes an unbalanced brace not in a backslash escape sequence,
- *   and any value that ends with a backslash not itself in a backslash
- *   escape sequence.
+ *   substring using brace quoting. The exceptions are any element value that
+ *   includes an unbalanced brace not in a backslash escape sequence, and any
+ *   value that ends with a backslash not itself in a backslash escape
+ *   sequence.
  * 
  * * If the first character of a formatted substring is
  *		\u0022	"	QUOTE
  *   then the end of the substring is the next QUOTE character, not counting
  *   any QUOTE characters that are contained within a backslash escape
- *   sequence.  If no next QUOTE is found before the end of the string, the
- *   string is not a Tcl list.  If the character following the closing QUOTE
- *   is not an element separating whitespace character, or the end of the
- *   string, then the string is not a Tcl list.  Having found the limits
- *   of the substring, the element value is produced by performing backslash
+ *   sequence. If no next QUOTE is found before the end of the string, the
+ *   string is not a Tcl list. If the character following the closing QUOTE is
+ *   not an element separating whitespace character, or the end of the string,
+ *   then the string is not a Tcl list. Having found the limits of the
+ *   substring, the element value is produced by performing backslash
  *   substitution on the character sequence between the open and close QUOTEs.
  *
  *   NOTE: Any element value can be represented by this style of formatting,
@@ -231,7 +230,7 @@ const Tcl_ObjType tclEndOffsetType = {
  *   of the substring, the element value is produced by performing backslash
  *   substitution on it.
  *
- *   NOTE:  Any element value can be represented by this style of formatting,
+ *   NOTE: Any element value can be represented by this style of formatting,
  *   given suitable choice of backslash escape sequences, with one exception.
  *   The empty string cannot be represented as a list element without the use
  *   of either braces or quotes to delimit it.
@@ -239,32 +238,32 @@ const Tcl_ObjType tclEndOffsetType = {
  * This collection of parsing rules is implemented in the routine
  * TclFindElement().
  *
- * In order to produce lists that can be parsed by these rules, we need
- * the ability to distinguish between characters that are part of a list
- * element value from characters providing syntax that define the structure
- * of the list.  This means that our code that generates lists must at a
- * minimum be able to produce escape sequences for the 10 characters
- * identified above that have significance to a list parser.
+ * In order to produce lists that can be parsed by these rules, we need the
+ * ability to distinguish between characters that are part of a list element
+ * value from characters providing syntax that define the structure of the
+ * list. This means that our code that generates lists must at a minimum be
+ * able to produce escape sequences for the 10 characters identified above
+ * that have significance to a list parser.
  *
- *	*	*	CANONICAL LISTS	*	*	*	*	*	
+ *	*	*	CANONICAL LISTS	*	*	*	*	*
  *
  * In addition to the basic rules for parsing strings into Tcl lists, there
  * are additional properties to be met by the set of list values that are
  * generated by Tcl.  Such list values are often said to be in "canonical
  * form":
  *
- * * When any canonical list is evaluated as a Tcl script, it is a script
- *   of either zero commands (an empty list) or exactly one command.  The
- *   command word is exactly the first element of the list, and each argument
- *   word is exactly one of the following elements of the list.  This means
- *   that any characters that have special meaning during script evaluation
- *   need special treatment when canonical lists are produced:
+ * * When any canonical list is evaluated as a Tcl script, it is a script of
+ *   either zero commands (an empty list) or exactly one command. The command
+ *   word is exactly the first element of the list, and each argument word is
+ *   exactly one of the following elements of the list. This means that any
+ *   characters that have special meaning during script evaluation need
+ *   special treatment when canonical lists are produced:
  *
  *	* Whitespace between elements may not include NEWLINE.
  *	* The command terminating character,
  *		\u003b	;	SEMICOLON
- *	  must be BRACEd, QUOTEd, or escaped so that it does not terminate
- * 	  the command prematurely.
+ *	  must be BRACEd, QUOTEd, or escaped so that it does not terminate the
+ * 	  command prematurely.
  *	* Any of the characters that begin substitutions in scripts,
  *		\u0024	$	DOLLAR
  *		\u005b	[	OPEN BRACKET
@@ -274,11 +273,10 @@ const Tcl_ObjType tclEndOffsetType = {
  *		\u0023	#	HASH
  *	  that HASH character must be BRACEd, QUOTEd, or escaped so that it
  *	  does not convert the command into a comment.
- *	* Any list element that contains the character sequence
- *	  BACKSLASH NEWLINE cannot be formatted with BRACEs.  The
- *	  BACKSLASH character must be represented by an escape
- *	  sequence, and unless QUOTEs are used, the NEWLINE must
- *	  be as well.
+ *	* Any list element that contains the character sequence BACKSLASH
+ *	  NEWLINE cannot be formatted with BRACEs. The BACKSLASH character
+ *	  must be represented by an escape sequence, and unless QUOTEs are
+ *	  used, the NEWLINE must be as well.
  *
  * * It is also guaranteed that one can use a canonical list as a building
  *   block of a larger script within command substitution, as in this example:
@@ -289,66 +287,66 @@ const Tcl_ObjType tclEndOffsetType = {
  *
  * * Finally it is guaranteed that enclosing a canonical list in braces
  *   produces a new value that is also a canonical list.  This new list has
- *   length 1, and its only element is the original canonical list.  This
- *   same guarantee also makes it possible to construct scripts where an
- *   argument word is given a list value by enclosing the canonical form
- *   of that list in braces:
+ *   length 1, and its only element is the original canonical list.  This same
+ *   guarantee also makes it possible to construct scripts where an argument
+ *   word is given a list value by enclosing the canonical form of that list
+ *   in braces:
  *	set script "puts {[list $one $two $three]}"; eval $script
  *   This sort of coding was once fairly common, though it's become more
  *   idiomatic to see the following instead:
  *	set script [list puts [list $one $two $three]]; eval $script
- *   In order to support this guarantee, every canonical list must have 
+ *   In order to support this guarantee, every canonical list must have
  *   balance when counting those braces that are not in escape sequences.
  *
  * Within these constraints, the canonical list generation routines
- * TclScanElement() and TclConvertElement() attempt to generate the string
- * for any list that is easiest to read.  When an element value is itself
+ * TclScanElement() and TclConvertElement() attempt to generate the string for
+ * any list that is easiest to read. When an element value is itself
  * acceptable as the formatted substring, it is usually used (CONVERT_NONE).
- * When some quoting or escaping is required, use of BRACEs (CONVERT_BRACE)
- * is usually preferred over the use of escape sequences (CONVERT_ESCAPE).
- * There are some exceptions to both of these preferences for reasons of
- * code simplicity, efficiency, and continuation of historical habits.
- * Canonical lists never use the QUOTE formatting to delimit their elements
- * because that form of quoting does not nest, which makes construction of
- * nested lists far too much trouble.  Canonical lists always use only a
- * single SPACE character for element-separating whitespace.
+ * When some quoting or escaping is required, use of BRACEs (CONVERT_BRACE) is
+ * usually preferred over the use of escape sequences (CONVERT_ESCAPE). There
+ * are some exceptions to both of these preferences for reasons of code
+ * simplicity, efficiency, and continuation of historical habits. Canonical
+ * lists never use the QUOTE formatting to delimit their elements because that
+ * form of quoting does not nest, which makes construction of nested lists far
+ * too much trouble.  Canonical lists always use only a single SPACE character
+ * for element-separating whitespace.
  *
  *	*	*	FUTURE CONSIDERATIONS	*	*	*
  *
  * When a list element requires quoting or escaping due to a CLOSE BRACKET
  * character or an internal QUOTE character, a strange formatting mode is
- * recommended.  For example, if the value "a{b]c}d" is converted by the
- * usual modes:
+ * recommended. For example, if the value "a{b]c}d" is converted by the usual
+ * modes:
  *
  *	CONVERT_BRACE:	a{b]c}d		=> {a{b]c}d}
  *	CONVERT_ESCAPE:	a{b]c}d		=> a\{b\]c\}d
  *
- * we get perfectly usable formatted list elements.  However, this is not
- * what Tcl releases have been producing.  Instead, we have:
+ * we get perfectly usable formatted list elements. However, this is not what
+ * Tcl releases have been producing. Instead, we have:
  *
  *	CONVERT_MASK:	a{b]c}d		=> a{b\]c}d
  *
- * where the CLOSE BRACKET is escaped, but the BRACEs are not.  The same
- * effect can be seen replacing ] with " in this example.  There does not
- * appear to be any functional or aesthetic purpose for this strange
- * additional mode.  The sole purpose I can see for preserving it is to
- * keep generating the same formatted lists programmers have become accustomed
- * to, and perhaps written tests to expect.  That is, compatibility only.
- * The additional code complexity required to support this mode is significant.
- * The lines of code supporting it are delimited in the routines below with
- * #if COMPAT directives.  This makes it easy to experiment with eliminating
- * this formatting mode simply with "#define COMPAT 0" above.  I believe
- * this is worth considering.
+ * where the CLOSE BRACKET is escaped, but the BRACEs are not. The same effect
+ * can be seen replacing ] with " in this example. There does not appear to be
+ * any functional or aesthetic purpose for this strange additional mode. The
+ * sole purpose I can see for preserving it is to keep generating the same
+ * formatted lists programmers have become accustomed to, and perhaps written
+ * tests to expect. That is, compatibility only. The additional code
+ * complexity required to support this mode is significant. The lines of code
+ * supporting it are delimited in the routines below with #if COMPAT
+ * directives. This makes it easy to experiment with eliminating this
+ * formatting mode simply with "#define COMPAT 0" above. I believe this is
+ * worth considering.
  * 
- * Another consideration is the treatment of QUOTE characters in list elements.
- * TclConvertElement() must have the ability to produce the escape sequence
- * \" so that when a list element begins with a QUOTE we do not confuse
- * that first character with a QUOTE used as list syntax to define list
- * structure.  However, that is the only place where QUOTE characters need
- * quoting.  In this way, handling QUOTE could really be much more like
- * the way we handle HASH which also needs quoting and escaping only in
- * particular situations.  Following up this could increase the set of
- * list elements that can use the CONVERT_NONE formatting mode.
+ * Another consideration is the treatment of QUOTE characters in list
+ * elements. TclConvertElement() must have the ability to produce the escape
+ * sequence \" so that when a list element begins with a QUOTE we do not
+ * confuse that first character with a QUOTE used as list syntax to define
+ * list structure. However, that is the only place where QUOTE characters need
+ * quoting. In this way, handling QUOTE could really be much more like the way
+ * we handle HASH which also needs quoting and escaping only in particular
+ * situations. Following up this could increase the set of list elements that
+ * can use the CONVERT_NONE formatting mode.
  *
  * More speculative is that the demands of canonical list form require brace
  * balance for the list as a whole, while the current implementation achieves
@@ -366,15 +364,15 @@ const Tcl_ObjType tclEndOffsetType = {
  *
  *	Given 'bytes' pointing to 'numBytes' bytes, scan through them and
  *	count the number of whitespace runs that could be list element
- *	separators.  If 'numBytes' is -1, scan to the terminating '\0'.
- *	Not a full list parser.  Typically used to get a quick and dirty
- *	overestimate of length size in order to allocate space for an
- *	actual list parser to operate with.
+ *	separators. If 'numBytes' is -1, scan to the terminating '\0'. Not a
+ *	full list parser. Typically used to get a quick and dirty overestimate
+ *	of length size in order to allocate space for an actual list parser to
+ *	operate with.
  *
  * Results:
- *	Returns the largest number of list elements that could possibly
- *	be in this string, interpreted as a Tcl list.  If 'endPtr' is not
- *	NULL, writes a pointer to the end of the string scanned there.
+ *	Returns the largest number of list elements that could possibly be in
+ *	this string, interpreted as a Tcl list. If 'endPtr' is not NULL,
+ *	writes a pointer to the end of the string scanned there.
  *
  * Side effects:
  *	None.
@@ -395,16 +393,25 @@ TclMaxListLength(
 	goto done;
     }
 
-    /* No list element before leading white space */
+    /*
+     * No list element before leading white space.
+     */
+
     count += 1 - TclIsSpaceProc(*bytes); 
 
-    /* Count white space runs as potential element separators */
+    /*
+     * Count white space runs as potential element separators.
+     */
+
     while (numBytes) {
 	if ((numBytes == -1) && (*bytes == '\0')) {
 	    break;
 	}
 	if (TclIsSpaceProc(*bytes)) {
-	    /* Space run started; bump count */
+	    /*
+	     * Space run started; bump count.
+	     */
+
 	    count++;
 	    do {
 		bytes++;
@@ -413,16 +420,22 @@ TclMaxListLength(
 	    if ((numBytes == 0) || ((numBytes == -1) && (*bytes == '\0'))) {
 		break;
 	    }
-	    /* (*bytes) is non-space; return to counting state */
+
+	    /*
+	     * (*bytes) is non-space; return to counting state.
+	     */
 	}
 	bytes++;
 	numBytes -= (numBytes != -1);
     }
 
-    /* No list element following trailing white space */
+    /*
+     * No list element following trailing white space.
+     */
+
     count -= TclIsSpaceProc(bytes[-1]); 
 
-    done:
+  done:
     if (endPtr) {
 	*endPtr = bytes;
     }
@@ -449,18 +462,18 @@ TclMaxListLength(
  *	that's part of the element. If this is the last argument in the list,
  *	then *nextPtr will point just after the last character in the list
  *	(i.e., at the character at list+listLength). If sizePtr is non-NULL,
- *	*sizePtr is filled in with the number of bytes in the element. If
- *	the element is in braces, then *elementPtr will point to the character
+ *	*sizePtr is filled in with the number of bytes in the element. If the
+ *	element is in braces, then *elementPtr will point to the character
  *	after the opening brace and *sizePtr will not include either of the
  *	braces. If there isn't an element in the list, *sizePtr will be zero,
  *	and both *elementPtr and *nextPtr will point just after the last
  *	character in the list. If literalPtr is non-NULL, *literalPtr is set
- *	to a boolean value indicating whether the substring returned as
- *	the values of **elementPtr and *sizePtr is the literal value of
- *	a list element.  If not, a call to TclCopyAndCollapse() is needed
- *	to produce the actual value of the list element.  Note: this function
- *	does NOT collapse backslash sequences, but uses *literalPtr to tell
- * 	callers when it is required for them to do so.
+ *	to a boolean value indicating whether the substring returned as the
+ *	values of **elementPtr and *sizePtr is the literal value of a list
+ *	element. If not, a call to TclCopyAndCollapse() is needed to produce
+ *	the actual value of the list element. Note: this function does NOT
+ *	collapse backslash sequences, but uses *literalPtr to tell callers
+ *	when it is required for them to do so.
  *
  * Side effects:
  *	None.
@@ -587,9 +600,10 @@ TclFindElement(
 		/*
 		 * A backslash sequence not within a brace quoted element
 		 * means the value of the element is different from the
-		 * substring we are parsing.  A call to TclCopyAndCollapse()
-		 * is needed to produce the element value.  Inform the caller.
+		 * substring we are parsing. A call to TclCopyAndCollapse() is
+		 * needed to produce the element value. Inform the caller.
 		 */
+
 		literal = 0;
 	    }
 	    TclParseBackslash(p, limit - p, &numChars, NULL);
@@ -697,9 +711,9 @@ TclFindElement(
  *
  * Results:
  *	Count bytes get copied from src to dst. Along the way, backslash
- *	sequences are substituted in the copy.  After scanning count bytes
- *	from src, a null character is placed at the end of dst.  Returns
- *	the number of bytes that got written to dst.
+ *	sequences are substituted in the copy. After scanning count bytes from
+ *	src, a null character is placed at the end of dst. Returns the number
+ *	of bytes that got written to dst.
  *
  * Side effects:
  *	None.
@@ -717,6 +731,7 @@ TclCopyAndCollapse(
 
     while (count > 0) {
 	char c = *src;
+
 	if (c == '\\') {
 	    int numRead;
 	    int backslashCount = TclParseBackslash(src, count, &numRead, dst);
@@ -780,12 +795,11 @@ Tcl_SplitList(
     int length, size, i, result, elSize;
 
     /*
-     * Allocate enough space to work in. A (const char *) for each
-     * (possible) list element plus one more for terminating NULL,
-     * plus as many bytes as in the original string value, plus one
-     * more for a terminating '\0'.  Space used to hold element separating
-     * white space in the original string gets re-purposed to hold '\0'
-     * characters in the argv array.
+     * Allocate enough space to work in. A (const char *) for each (possible)
+     * list element plus one more for terminating NULL, plus as many bytes as
+     * in the original string value, plus one more for a terminating '\0'.
+     * Space used to hold element separating white space in the original
+     * string gets re-purposed to hold '\0' characters in the argv array.
      */
 
     size = TclMaxListLength(list, -1, &end) + 1;
@@ -844,9 +858,9 @@ Tcl_SplitList(
  *	enclosing braces) to make the string into a valid Tcl list element.
  *
  * Results:
- *	The return value is an overestimate of the number of bytes that
- *	will be needed by Tcl_ConvertElement to produce a valid list element
- *	from src. The word at *flagPtr is filled in with a value needed by
+ *	The return value is an overestimate of the number of bytes that will
+ *	be needed by Tcl_ConvertElement to produce a valid list element from
+ *	src. The word at *flagPtr is filled in with a value needed by
  *	Tcl_ConvertElement when doing the actual conversion.
  *
  * Side effects:
@@ -876,10 +890,10 @@ Tcl_ScanElement(
  *	to the first null byte.
  *
  * Results:
- *	The return value is an overestimate of the number of bytes that
- *	will be needed by Tcl_ConvertCountedElement to produce a valid list
- *	element from src. The word at *flagPtr is filled in with a value
- *	needed by Tcl_ConvertCountedElement when doing the actual conversion.
+ *	The return value is an overestimate of the number of bytes that will
+ *	be needed by Tcl_ConvertCountedElement to produce a valid list element
+ *	from src. The word at *flagPtr is filled in with a value needed by
+ *	Tcl_ConvertCountedElement when doing the actual conversion.
  *
  * Side effects:
  *	None.
@@ -906,24 +920,24 @@ Tcl_ScanCountedElement(
  *
  * TclScanElement --
  *
- *	This function is a companion function to TclConvertElement. It
- *	scans a string to see what needs to be done to it (e.g. add
- *	backslashes or enclosing braces) to make the string into a valid Tcl
- *	list element. If length is -1, then the string is scanned from src up
- *	to the first null byte.  A NULL value for src is treated as an
- *	empty string.  The incoming value of *flagPtr is a report from the
- *	caller what additional flags it will pass to TclConvertElement().
+ *	This function is a companion function to TclConvertElement. It scans a
+ *	string to see what needs to be done to it (e.g. add backslashes or
+ *	enclosing braces) to make the string into a valid Tcl list element. If
+ *	length is -1, then the string is scanned from src up to the first null
+ *	byte. A NULL value for src is treated as an empty string. The incoming
+ *	value of *flagPtr is a report from the caller what additional flags it
+ *	will pass to TclConvertElement().
  *
  * Results:
- *	The recommended formatting mode for the element is determined and
- *	a value is written to *flagPtr indicating that recommendation.  This
+ *	The recommended formatting mode for the element is determined and a
+ *	value is written to *flagPtr indicating that recommendation. This
  *	recommendation is combined with the incoming flag values in *flagPtr
  *	set by the caller to determine how many bytes will be needed by
  *	TclConvertElement() in which to write the formatted element following
- *	the recommendation modified by the flag values.  This number of bytes
- *	is the return value of the routine.  In some situations it may be
- *	an overestimate, but so long as the caller passes the same flags
- *	to TclConvertElement(), it will be large enough.
+ *	the recommendation modified by the flag values. This number of bytes
+ *	is the return value of the routine.  In some situations it may be an
+ *	overestimate, but so long as the caller passes the same flags to
+ *	TclConvertElement(), it will be large enough.
  *
  * Side effects:
  *	None.
@@ -941,7 +955,7 @@ TclScanElement(
     const char *p = src;
     int nestingLevel = 0;	/* Brace nesting count */
     int forbidNone = 0;		/* Do not permit CONVERT_NONE mode. Something
-				   needs protection or escape. */
+				 * needs protection or escape. */
     int requireEscape = 0;	/* Force use of CONVERT_ESCAPE mode.  For some
 				 * reason bare or brace-quoted form fails. */
     int extra = 0;		/* Count of number of extra bytes needed for
@@ -953,10 +967,13 @@ TclScanElement(
     int preferEscape = 0;	/* Use preferences to track whether to use */
     int preferBrace = 0;	/* CONVERT_MASK mode. */
     int braceCount = 0;		/* Count of all braces '{' '}' seen. */
-#endif
+#endif /* COMPAT */
     
     if ((p == NULL) || (length == 0) || ((*p == '\0') && (length == -1))) {
-	/* Empty string element must be brace quoted. */
+	/*
+	 * Empty string element must be brace quoted.
+	 */
+
 	*flagPtr = CONVERT_BRACE;
 	return 2;
     }
@@ -966,10 +983,11 @@ TclScanElement(
 	 * Must escape or protect so leading character of value is not
 	 * misinterpreted as list element delimiting syntax.
 	 */
+
 	forbidNone = 1;
 #if COMPAT
 	preferBrace = 1;
-#endif
+#endif /* COMPAT */
     }
 
     while (length) {
@@ -978,18 +996,21 @@ TclScanElement(
 	case '{':	/* TYPE_BRACE */
 #if COMPAT
 	    braceCount++;
-#endif
+#endif /* COMPAT */
 	    extra++;				/* Escape '{' => '\{' */
 	    nestingLevel++;
 	    break;
 	case '}':	/* TYPE_BRACE */
 #if COMPAT
 	    braceCount++;
-#endif
+#endif /* COMPAT */
 	    extra++;				/* Escape '}' => '\}' */
 	    nestingLevel--;
 	    if (nestingLevel < 0) {
-		/* Unbalanced braces!  Cannot format with brace quoting. */
+		/*
+		 * Unbalanced braces!  Cannot format with brace quoting.
+		 */
+
 		requireEscape = 1;
 	    }
 	    break;
@@ -1002,7 +1023,7 @@ TclScanElement(
 	    break;
 #else
 	    /* FLOW THROUGH */
-#endif
+#endif /* COMPAT */
 	case '[':	/* TYPE_SUBS */
 	case '$':	/* TYPE_SUBS */
 	case ';':	/* TYPE_COMMAND_END */
@@ -1016,18 +1037,25 @@ TclScanElement(
 	    extra++;		/* Escape sequences all one byte longer. */
 #if COMPAT
 	    preferBrace = 1;
-#endif
+#endif /* COMPAT */
 	    break;
 	case '\\':	/* TYPE_SUBS */
 	    extra++;				/* Escape '\' => '\\' */
 	    if ((length == 1) || ((length == -1) && (p[1] == '\0'))) {
-		/* Final backslash. Cannot format with brace quoting. */
+		/*
+		 * Final backslash. Cannot format with brace quoting.
+		 */
+
 		requireEscape = 1;		
 		break;
 	    }
 	    if (p[1] == '\n') {
 		extra++;	/* Escape newline => '\n', one byte longer */
-		/* Backslash newline sequence.  Brace quoting not permitted. */
+
+		/*
+		 * Backslash newline sequence.  Brace quoting not permitted.
+		 */
+
 		requireEscape = 1;
 		length -= (length > 0);
 		p++;
@@ -1041,7 +1069,7 @@ TclScanElement(
 	    forbidNone = 1;
 #if COMPAT
 	    preferBrace = 1;
-#endif
+#endif /* COMPAT */
 	    break;
 	case '\0':	/* TYPE_SUBS */
 	    if (length == -1) {
@@ -1055,22 +1083,33 @@ TclScanElement(
 	p++;
     }
 
-    endOfString:
+  endOfString:
     if (nestingLevel != 0) {
-	/* Unbalanced braces!  Cannot format with brace quoting. */
+	/*
+	 * Unbalanced braces!  Cannot format with brace quoting.
+	 */
+
 	requireEscape = 1;
     }
 
-    /* We need at least as many bytes as are in the element value... */
+    /*
+     * We need at least as many bytes as are in the element value...
+     */
+
     bytesNeeded = p - src;
 
     if (requireEscape) {
 	/*
-	 * We must use escape sequences.  Add all the extra bytes needed
-	 * to have room to create them.
+	 * We must use escape sequences.  Add all the extra bytes needed to
+	 * have room to create them.
 	 */
+
 	bytesNeeded += extra;
-	/* Make room to escape leading #, if needed. */
+
+	/*
+	 * Make room to escape leading #, if needed.
+	 */
+
 	if ((*src == '#') && !(*flagPtr & TCL_DONT_QUOTE_HASH)) {
 	    bytesNeeded++;
 	}
@@ -1080,12 +1119,13 @@ TclScanElement(
     if (*flagPtr & CONVERT_ANY) {
 	/*
 	 * The caller has not let us know what flags it will pass to
-	 * TclConvertElement() so compute the max size we might need for
-	 * any possible choice.  Normally the formatting using escape
-	 * sequences is the longer one, and a minimum "extra" value of 2
-	 * makes sure we don't request too small a buffer in those edge
-	 * cases where that's not true.
+	 * TclConvertElement() so compute the max size we might need for any
+	 * possible choice.  Normally the formatting using escape sequences is
+	 * the longer one, and a minimum "extra" value of 2 makes sure we
+	 * don't request too small a buffer in those edge cases where that's
+	 * not true.
 	 */
+
 	if (extra < 2) {
 	    extra = 2;
 	}
@@ -1093,59 +1133,78 @@ TclScanElement(
 	*flagPtr |= TCL_DONT_USE_BRACES;
     }
     if (forbidNone) {
-	/* We must request some form of quoting of escaping... */
+	/*
+	 * We must request some form of quoting of escaping...
+	 */
+
 #if COMPAT
 	if (preferEscape && !preferBrace) {
 	    /*
-	     * If we are quoting solely due to ] or internal " characters
-	     * use the CONVERT_MASK mode where we escape all special 
-	     * characters except for braces.  "extra" counted space needed
-	     * to escape braces too, so substract "braceCount" to get our
-	     * actual needs.
+	     * If we are quoting solely due to ] or internal " characters use
+	     * the CONVERT_MASK mode where we escape all special characters
+	     * except for braces. "extra" counted space needed to escape
+	     * braces too, so substract "braceCount" to get our actual needs.
 	     */
+
 	    bytesNeeded += (extra - braceCount);
 	    /* Make room to escape leading #, if needed. */
 	    if ((*src == '#') && !(*flagPtr & TCL_DONT_QUOTE_HASH)) {
 		bytesNeeded++;
 	    }
+
 	    /*
 	     * If the caller reports it will direct TclConvertElement() to
 	     * use full escapes on the element, add back the bytes needed to
 	     * escape the braces.
 	     */
+
 	    if (*flagPtr & TCL_DONT_USE_BRACES) {
 		bytesNeeded += braceCount;
 	    }
 	    *flagPtr = CONVERT_MASK;
 	    goto overflowCheck;
 	}
-#endif
+#endif /* COMPAT */
 	if (*flagPtr & TCL_DONT_USE_BRACES) {
 	    /*
 	     * If the caller reports it will direct TclConvertElement() to
 	     * use escapes, add the extra bytes needed to have room for them.
 	     */
+
 	    bytesNeeded += extra;
-	    /* Make room to escape leading #, if needed. */
+
+	    /*
+	     * Make room to escape leading #, if needed.
+	     */
+
 	    if ((*src == '#') && !(*flagPtr & TCL_DONT_QUOTE_HASH)) {
 		bytesNeeded++;
 	    }
 	} else {
-	    /* Add 2 bytes for room for the enclosing braces. */
+	    /*
+	     * Add 2 bytes for room for the enclosing braces.
+	     */
+
 	    bytesNeeded += 2;
 	}
 	*flagPtr = CONVERT_BRACE;
 	goto overflowCheck;
     }
 
-    /* So far, no need to quote or escape anything. */
+    /*
+     * So far, no need to quote or escape anything.
+     */
+
     if ((*src == '#') && !(*flagPtr & TCL_DONT_QUOTE_HASH)) {
-	/* If we need to quote a leading #, make room to enclose in braces. */
+	/*
+	 * If we need to quote a leading #, make room to enclose in braces.
+	 */
+
 	bytesNeeded += 2;
     }
     *flagPtr = CONVERT_NONE;
 
-    overflowCheck:
+  overflowCheck:
     if (bytesNeeded < 0) {
 	Tcl_Panic("TclScanElement: string length overflow");
     }
@@ -1220,9 +1279,9 @@ Tcl_ConvertCountedElement(
  *
  * TclConvertElement --
  *
- *	This is a companion function to TclScanElement. Given the
- *	information produced by TclScanElement, this function converts
- *	a string to a list element equal to that string.
+ *	This is a companion function to TclScanElement. Given the information
+ *	produced by TclScanElement, this function converts a string to a list
+ *	element equal to that string.
  *
  * Results:
  *	Information is copied to *dst in the form of a list element identical
@@ -1236,7 +1295,8 @@ Tcl_ConvertCountedElement(
  *----------------------------------------------------------------------
  */
 
-int TclConvertElement(
+int
+TclConvertElement(
     register const char *src,	/* Source information for list element. */
     int length,			/* Number of bytes in src, or -1. */
     char *dst,			/* Place to put list-ified element. */
@@ -1245,19 +1305,28 @@ int TclConvertElement(
     int conversion = flags & CONVERT_MASK;
     char *p = dst;
 
-    /* Let the caller demand we use escape sequences rather than braces. */
+    /*
+     * Let the caller demand we use escape sequences rather than braces.
+     */
+
     if ((flags & TCL_DONT_USE_BRACES) && (conversion & CONVERT_BRACE)) {
 	conversion = CONVERT_ESCAPE;
     }
 
-    /* No matter what the caller demands, empty string must be braced! */
-    if ((src == NULL) || (length == 0) || ((*src == '\0') && (length == -1))) {
+    /*
+     * No matter what the caller demands, empty string must be braced!
+     */
+
+    if ((src == NULL) || (length == 0) || (*src == '\0' && length == -1)) {
 	src = tclEmptyStringRep;
 	length = 0;
 	conversion = CONVERT_BRACE;
     }
 
-    /* Escape leading hash as needed and requested. */
+    /*
+     * Escape leading hash as needed and requested.
+     */
+
     if ((*src == '#') && !(flags & TCL_DONT_QUOTE_HASH)) {
 	if (conversion == CONVERT_ESCAPE) {
 	    p[0] = '\\';
@@ -1270,7 +1339,10 @@ int TclConvertElement(
 	}
     }
 
-    /* No escape or quoting needed.  Copy the literal string value. */
+    /*
+     * No escape or quoting needed.  Copy the literal string value.
+     */
+
     if (conversion == CONVERT_NONE) {
 	if (length == -1) {
 	    /* TODO: INT_MAX overflow? */
@@ -1284,7 +1356,10 @@ int TclConvertElement(
 	}
     }
 
-    /* Formatted string is original string enclosed in braces. */
+    /*
+     * Formatted string is original string enclosed in braces.
+     */
+
     if (conversion == CONVERT_BRACE) {
 	*p = '{';
 	p++;
@@ -1304,7 +1379,10 @@ int TclConvertElement(
 
     /* conversion == CONVERT_ESCAPE or CONVERT_MASK */
 
-    /* Formatted string is original string converted to escape sequences. */
+    /*
+     * Formatted string is original string converted to escape sequences.
+     */
+
     for ( ; length; src++, length -= (length > 0)) {
 	switch (*src) {
 	case ']':
@@ -1320,13 +1398,12 @@ int TclConvertElement(
 	case '{':
 	case '}':
 #if COMPAT
-	    if (conversion == CONVERT_ESCAPE) {
-#endif
+	    if (conversion == CONVERT_ESCAPE)
+#endif /* COMPAT */
+	    {
 		*p = '\\';
 		p++;
-#if COMPAT
 	    }
-#endif
 	    break;
 	case '\f':
 	    *p = '\\';
@@ -1362,13 +1439,15 @@ int TclConvertElement(
 	    if (length == -1) {
 		return p - dst;
 	    }
+
 	    /* 
-	     * If we reach this point, there's an embedded NULL in the
-	     * string range being processed, which should not happen when
-	     * the encoding rules for Tcl strings are properly followed.
-	     * If the day ever comes when we stop tolerating such things,
-	     * this is where to put the Tcl_Panic().
+	     * If we reach this point, there's an embedded NULL in the string
+	     * range being processed, which should not happen when the
+	     * encoding rules for Tcl strings are properly followed.  If the
+	     * day ever comes when we stop tolerating such things, this is
+	     * where to put the Tcl_Panic().
 	     */
+
 	    break;
 	}
 	*p = *src;
@@ -1402,17 +1481,18 @@ Tcl_Merge(
     int argc,			/* How many strings to merge. */
     const char *const *argv)	/* Array of string values. */
 {
-#   define LOCAL_SIZE 20
+#define LOCAL_SIZE 20
     int localFlags[LOCAL_SIZE], *flagPtr = NULL;
     int i, bytesNeeded = 0;
     char *result, *dst;
     const int maxFlags = UINT_MAX / sizeof(int);
 
+    /*
+     * Handle empty list case first, so logic of the general case can be
+     * simpler.
+     */
+
     if (argc == 0) {
-	/*
-	 * Handle empty list case first, so logic of the general case
-	 * can be simpler.
-	 */
 	result = ckalloc(1);
 	result[0] = '\0';
 	return result;
@@ -1426,17 +1506,17 @@ Tcl_Merge(
 	flagPtr = localFlags;
     } else if (argc > maxFlags) {
 	/*
-	 * We cannot allocate a large enough flag array to format this
-	 * list in one pass.  We could imagine converting this routine
-	 * to a multi-pass implementation, but for sizeof(int) == 4, 
-	 * the limit is a max of 2^30 list elements and since each element
-	 * is at least one byte formatted, and requires one byte space
-	 * between it and the next one, that a minimum space requirement
-	 * of 2^31 bytes, which is already INT_MAX. If we tried to format
-	 * a list of > maxFlags elements, we're just going to overflow
-	 * the size limits on the formatted string anyway, so just issue
-	 * that same panic early.
+	 * We cannot allocate a large enough flag array to format this list in
+	 * one pass.  We could imagine converting this routine to a multi-pass
+	 * implementation, but for sizeof(int) == 4, the limit is a max of
+	 * 2^30 list elements and since each element is at least one byte
+	 * formatted, and requires one byte space between it and the next one,
+	 * that a minimum space requirement of 2^31 bytes, which is already
+	 * INT_MAX. If we tried to format a list of > maxFlags elements, we're
+	 * just going to overflow the size limits on the formatted string
+	 * anyway, so just issue that same panic early.
 	 */
+
 	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
     } else {
 	flagPtr = ckalloc(argc * sizeof(int));
@@ -1511,9 +1591,10 @@ Tcl_Backslash(
  *----------------------------------------------------------------------
  *
  * TclTrimRight --
- *	Takes two counted strings in the Tcl encoding which must both be
- *	null terminated.  Conceptually trims from the right side of the
- *	first string all characters found in the second string.
+ *
+ *	Takes two counted strings in the Tcl encoding which must both be null
+ *	terminated. Conceptually trims from the right side of the first string
+ *	all characters found in the second string.
  *
  * Results:
  *	The number of bytes to be removed from the end of the string.
@@ -1526,10 +1607,10 @@ Tcl_Backslash(
 
 int
 TclTrimRight(
-    const char *bytes,	/* String to be trimmed... */
-    int numBytes,	/* ...and its length in bytes */
-    const char *trim,	/* String of trim characters... */
-    int numTrim)	/* ...and its length in bytes */
+    const char *bytes,		/* String to be trimmed... */
+    int numBytes,		/* ...and its length in bytes */
+    const char *trim,		/* String of trim characters... */
+    int numTrim)		/* ...and its length in bytes */
 {
     const char *p = bytes + numBytes;
     int pInc;
@@ -1538,12 +1619,18 @@ TclTrimRight(
 	Tcl_Panic("TclTrimRight works only on null-terminated strings");
     }
 
-    /* Empty strings -> nothing to do */
+    /*
+     * Empty strings -> nothing to do.
+     */
+
     if ((numBytes == 0) || (numTrim == 0)) {
 	return 0;
     }
 
-    /* Outer loop: iterate over string to be trimmed */
+    /*
+     * Outer loop: iterate over string to be trimmed.
+     */
+
     do {
 	Tcl_UniChar ch1;
 	const char *q = trim;
@@ -1552,7 +1639,10 @@ TclTrimRight(
 	p = Tcl_UtfPrev(p, bytes);
  	pInc = TclUtfToUniChar(p, &ch1);
 
-	/* Inner loop: scan trim string for match to current character */
+	/*
+	 * Inner loop: scan trim string for match to current character.
+	 */
+
 	do {
 	    Tcl_UniChar ch2;
 	    int qInc = TclUtfToUniChar(q, &ch2);
@@ -1566,7 +1656,10 @@ TclTrimRight(
 	} while (bytesLeft);
 
 	if (bytesLeft == 0) {
-	    /* No match; trim task done; *p is last non-trimmed char */
+	    /*
+	     * No match; trim task done; *p is last non-trimmed char.
+	     */
+
 	    p += pInc;
 	    break;
 	}
@@ -1579,9 +1672,10 @@ TclTrimRight(
  *----------------------------------------------------------------------
  *
  * TclTrimLeft --
- *	Takes two counted strings in the Tcl encoding which must both be
- *	null terminated.  Conceptually trims from the left side of the
- *	first string all characters found in the second string.
+ *
+ *	Takes two counted strings in the Tcl encoding which must both be null
+ *	terminated. Conceptually trims from the left side of the first string
+ *	all characters found in the second string.
  *
  * Results:
  *	The number of bytes to be removed from the start of the string.
@@ -1594,10 +1688,10 @@ TclTrimRight(
 
 int
 TclTrimLeft(
-    const char *bytes,	/* String to be trimmed... */
-    int numBytes,	/* ...and its length in bytes */
-    const char *trim,	/* String of trim characters... */
-    int numTrim)	/* ...and its length in bytes */
+    const char *bytes,		/* String to be trimmed... */
+    int numBytes,		/* ...and its length in bytes */
+    const char *trim,		/* String of trim characters... */
+    int numTrim)		/* ...and its length in bytes */
 {
     const char *p = bytes;
 
@@ -1605,19 +1699,28 @@ TclTrimLeft(
 	Tcl_Panic("TclTrimLeft works only on null-terminated strings");
     }
 
-    /* Empty strings -> nothing to do */
+    /*
+     * Empty strings -> nothing to do.
+     */
+
     if ((numBytes == 0) || (numTrim == 0)) {
 	return 0;
     }
 
-    /* Outer loop: iterate over string to be trimmed */
+    /*
+     * Outer loop: iterate over string to be trimmed.
+     */
+
     do {
 	Tcl_UniChar ch1;
 	int pInc = TclUtfToUniChar(p, &ch1);
 	const char *q = trim;
 	int bytesLeft = numTrim;
 
-	/* Inner loop: scan trim string for match to current character */
+	/*
+	 * Inner loop: scan trim string for match to current character.
+	 */
+
 	do {
 	    Tcl_UniChar ch2;
 	    int qInc = TclUtfToUniChar(q, &ch2);
@@ -1631,7 +1734,10 @@ TclTrimLeft(
 	} while (bytesLeft);
 
 	if (bytesLeft == 0) {
-	    /* No match; trim task done; *p is first non-trimmed char */
+	    /*
+	     * No match; trim task done; *p is first non-trimmed char.
+	     */
+
 	    break;
 	}
 
@@ -1673,14 +1779,20 @@ Tcl_Concat(
     int i, needSpace = 0, bytesNeeded = 0;
     char *result, *p;
 
-    /* Dispose of the empty result corner case first to simplify later code */
+    /*
+     * Dispose of the empty result corner case first to simplify later code.
+     */
+
     if (argc == 0) {
 	result = (char *) ckalloc(1);
 	result[0] = '\0';
 	return result;
     }
 
-    /* First allocate the result buffer at the size required */
+    /*
+     * First allocate the result buffer at the size required.
+     */
+
     for (i = 0;  i < argc;  i++) {
 	bytesNeeded += strlen(argv[i]);
 	if (bytesNeeded < 0) {
@@ -1689,13 +1801,18 @@ Tcl_Concat(
     }
     if (bytesNeeded + argc - 1 < 0) {
 	/*
-	 * Panic test could be tighter, but not going to bother for 
-	 * this legacy routine.
+	 * Panic test could be tighter, but not going to bother for this
+	 * legacy routine.
 	 */
+
 	Tcl_Panic("Tcl_Concat: max size of Tcl value exceeded");
     }
-    /* All element bytes + (argc - 1) spaces + 1 terminating NULL */
-    result = (char *) ckalloc((unsigned) (bytesNeeded + argc));
+
+    /*
+     * All element bytes + (argc - 1) spaces + 1 terminating NULL.
+     */
+
+    result = ckalloc((unsigned) (bytesNeeded + argc));
 
     for (p = result, i = 0;  i < argc;  i++) {
 	int trim, elemLength;
@@ -1704,26 +1821,35 @@ Tcl_Concat(
 	element = argv[i];
 	elemLength = strlen(argv[i]);
 
-	/* Trim away the leading whitespace */
+	/*
+	 * Trim away the leading whitespace.
+	 */
+
 	trim = TclTrimLeft(element, elemLength, CONCAT_WS, CONCAT_WS_SIZE);
 	element += trim;
 	elemLength -= trim;
 
 	/*
-	 * Trim away the trailing whitespace.  Do not permit trimming
-	 * to expose a final backslash character.
+	 * Trim away the trailing whitespace. Do not permit trimming to expose
+	 * a final backslash character.
 	 */
 
 	trim = TclTrimRight(element, elemLength, CONCAT_WS, CONCAT_WS_SIZE);
 	trim -= trim && (element[elemLength - trim - 1] == '\\');
 	elemLength -= trim;
 
-	/* If we're left with empty element after trimming, do nothing */
+	/*
+	 * If we're left with empty element after trimming, do nothing.
+	 */
+
 	if (elemLength == 0) {
 	    continue;
 	}
 
-	/* Append to the result with space if needed */
+	/*
+	 * Append to the result with space if needed.
+	 */
+
 	if (needSpace) {
 	    *p++ = ' ';
 	}
@@ -1802,9 +1928,10 @@ Tcl_ConcatObj(
     /*
      * Something cannot be determined to be safe, so build the concatenation
      * the slow way, using the string representations.
+     *
+     * First try to pre-allocate the size required.
      */
 
-    /* First try to pre-allocate the size required */
     for (i = 0;  i < objc;  i++) {
 	element = TclGetStringFromObj(objv[i], &elemLength);
 	bytesNeeded += elemLength;
@@ -1812,11 +1939,13 @@ Tcl_ConcatObj(
 	    break;
 	}
     }
+
     /*
-     * Does not matter if this fails, will simply try later to build up
-     * the string with each Append reallocating as needed with the usual
-     * string append algorithm.  When that fails it will report the error.
+     * Does not matter if this fails, will simply try later to build up the
+     * string with each Append reallocating as needed with the usual string
+     * append algorithm.  When that fails it will report the error.
      */
+
     TclNewObj(resPtr);
     Tcl_AttemptSetObjLength(resPtr, bytesNeeded + objc - 1);
     Tcl_SetObjLength(resPtr, 0);
@@ -1826,26 +1955,35 @@ Tcl_ConcatObj(
 	
 	element = TclGetStringFromObj(objv[i], &elemLength);
 
-	/* Trim away the leading whitespace */
+	/*
+	 * Trim away the leading whitespace.
+	 */
+
 	trim = TclTrimLeft(element, elemLength, CONCAT_WS, CONCAT_WS_SIZE);
 	element += trim;
 	elemLength -= trim;
 
 	/*
-	 * Trim away the trailing whitespace.  Do not permit trimming
-	 * to expose a final backslash character.
+	 * Trim away the trailing whitespace. Do not permit trimming to expose
+	 * a final backslash character.
 	 */
 
 	trim = TclTrimRight(element, elemLength, CONCAT_WS, CONCAT_WS_SIZE);
 	trim -= trim && (element[elemLength - trim - 1] == '\\');
 	elemLength -= trim;
 
-	/* If we're left with empty element after trimming, do nothing */
+	/*
+	 * If we're left with empty element after trimming, do nothing.
+	 */
+
 	if (elemLength == 0) {
 	    continue;
 	}
 
-	/* Append to the result with space if needed */
+	/*
+	 * Append to the result with space if needed.
+	 */
+
 	if (needSpace) {
 	    Tcl_AppendToObj(resPtr, " ", 1);
 	}
@@ -2249,6 +2387,7 @@ TclByteArrayMatch(
 			/*
 			 * Matches ranges of form [a-z] or [z-a].
 			 */
+
 			break;
 		    }
 		} else if (startChar == ch1) {
@@ -2295,9 +2434,9 @@ TclByteArrayMatch(
  *
  * TclStringMatchObj --
  *
- *	See if a particular string matches a particular pattern.
- *	Allows case insensitivity.  This is the generic multi-type handler
- *	for the various matching algorithms.
+ *	See if a particular string matches a particular pattern. Allows case
+ *	insensitivity. This is the generic multi-type handler for the various
+ *	matching algorithms.
  *
  * Results:
  *	The return value is 1 if string matches pattern, and 0 otherwise. The
@@ -2657,24 +2796,8 @@ Tcl_DStringResult(
     Tcl_DString *dsPtr)		/* Dynamic string that is to become the
 				 * result of interp. */
 {
-    Interp *iPtr = (Interp *) interp;
-
     Tcl_ResetResult(interp);
-
-    if (dsPtr->string != dsPtr->staticSpace) {
-	iPtr->result = dsPtr->string;
-	iPtr->freeProc = TCL_DYNAMIC;
-    } else if (dsPtr->length < TCL_RESULT_SIZE) {
-	iPtr->result = iPtr->resultSpace;
-	memcpy(iPtr->result, dsPtr->string, dsPtr->length + 1);
-    } else {
-	Tcl_SetResult(interp, dsPtr->string, TCL_VOLATILE);
-    }
-
-    dsPtr->string = dsPtr->staticSpace;
-    dsPtr->length = 0;
-    dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
-    dsPtr->staticSpace[0] = '\0';
+    Tcl_SetObjResult(interp, TclDStringToObj(dsPtr));
 }
 
 /*
@@ -2710,6 +2833,39 @@ Tcl_DStringGetResult(
     }
 
     /*
+     * Do more efficient transfer when we know the result is a Tcl_Obj. When
+     * there's no st`ring result, we only have to deal with two cases:
+     *
+     *  1. When the string rep is the empty string, when we don't copy but
+     *     instead use the staticSpace in the DString to hold an empty string.
+
+     *  2. When the string rep is not there or there's a real string rep, when
+     *     we use Tcl_GetString to fetch (or generate) the string rep - which
+     *     we know to have been allocated with ckalloc() - and use it to
+     *     populate the DString space. Then, we free the internal rep. and set
+     *     the object's string representation back to the canonical empty
+     *     string.
+     */
+
+    if (!iPtr->result[0] && iPtr->objResultPtr
+	    && !Tcl_IsShared(iPtr->objResultPtr)) {
+	if (iPtr->objResultPtr->bytes == tclEmptyStringRep) {
+	    dsPtr->string = dsPtr->staticSpace;
+	    dsPtr->string[0] = 0;
+	    dsPtr->length = 0;
+	    dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
+	} else {
+	    dsPtr->string = Tcl_GetString(iPtr->objResultPtr);
+	    dsPtr->length = iPtr->objResultPtr->length;
+	    dsPtr->spaceAvl = dsPtr->length + 1;
+	    TclFreeIntRep(iPtr->objResultPtr);
+	    iPtr->objResultPtr->bytes = tclEmptyStringRep;
+	    iPtr->objResultPtr->length = 0;
+	}
+	return;
+    }
+
+    /*
      * If the string result is empty, move the object result to the string
      * result, then reset the object result.
      */
@@ -2947,12 +3103,12 @@ Tcl_PrintDouble(
 	 * Tcl 8.4 implements the first of these, which gives rise to
 	 * anomalies in formatting:
 	 *
-	 * % expr 0.1
-	 * 0.10000000000000001
-	 * % expr 0.01
-	 * 0.01
-	 * % expr 1e-7
-	 * 9.9999999999999995e-08
+	 *	% expr 0.1
+	 *	0.10000000000000001
+	 *	% expr 0.01
+	 *	0.01
+	 *	% expr 1e-7
+	 *	9.9999999999999995e-08
 	 *
 	 * For human readability, it appears better to choose the second rule,
 	 * and let [expr 0.1] return 0.1. But for 8.4 compatibility, we prefer
@@ -2965,8 +3121,8 @@ Tcl_PrintDouble(
 	 */
 
 	digits = TclDoubleDigits(value, *precisionPtr,
-				 TCL_DD_E_FORMAT /* | TCL_DD_SHORTEN_FLAG */, 
-				 &exponent, &signum, &end);
+		TCL_DD_E_FORMAT /* | TCL_DD_SHORTEN_FLAG */, 
+		&exponent, &signum, &end);
     }
     if (signum) {
 	*dst++ = '-';
@@ -3222,10 +3378,10 @@ TclNeedSpace(
  */
 
 int
-TclFormatInt(buffer, n)
-    char *buffer;		/* Points to the storage into which the
+TclFormatInt(
+    char *buffer,		/* Points to the storage into which the
 				 * formatted characters are written. */
-    long n;			/* The integer to format. */
+    long n)			/* The integer to format. */
 {
     long intVal;
     int i;
@@ -3243,9 +3399,9 @@ TclFormatInt(buffer, n)
     }
 
     /*
-     * Check whether "n" is the maximum negative value. This is
-     * -2^(m-1) for an m-bit word, and has no positive equivalent;
-     * negating it produces the same value.
+     * Check whether "n" is the maximum negative value. This is -2^(m-1) for
+     * an m-bit word, and has no positive equivalent; negating it produces the
+     * same value.
      */
 
     intVal = -n;			/* [Bug 3390638] Workaround for*/
@@ -3277,6 +3433,7 @@ TclFormatInt(buffer, n)
 
     for (j = 0;  j < i;  j++, i--) {
 	char tmp = buffer[i];
+
 	buffer[i] = buffer[j];
 	buffer[j] = tmp;
     }
@@ -3742,7 +3899,7 @@ TclSetProcessGlobalValue(
     if (NULL != pgvPtr->value) {
 	ckfree(pgvPtr->value);
     } else {
-	Tcl_CreateExitHandler(FreeProcessGlobalValue, (ClientData) pgvPtr);
+	Tcl_CreateExitHandler(FreeProcessGlobalValue, pgvPtr);
     }
     bytes = Tcl_GetStringFromObj(newValue, &pgvPtr->numBytes);
     pgvPtr->value = ckalloc(pgvPtr->numBytes + 1);
diff --git a/unix/tclLoadOSF.c b/unix/tclLoadOSF.c
index 6515b89..6e76b55 100644
--- a/unix/tclLoadOSF.c
+++ b/unix/tclLoadOSF.c
@@ -35,12 +35,14 @@
 #include "tclInt.h"
 #include <sys/types.h>
 #include <loader.h>
-
-/* Static functions defined within this file */
 
-static void* FindSymbol(Tcl_Interp* interp, Tcl_LoadHandle loadHandle,
-		       const char* symbol);
-static void UnloadFile(Tcl_LoadHandle handle);
+/*
+ * Static functions defined within this file.
+ */
+
+static void *		FindSymbol(Tcl_Interp *interp,
+			    Tcl_LoadHandle loadHandle, const char* symbol);
+static void		UnloadFile(Tcl_LoadHandle handle);
 
 /*
  *----------------------------------------------------------------------
@@ -105,7 +107,7 @@ TclpDlopen(
     if (lm == LDR_NULL_MODULE) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't load file \"%s\": %s",
-		fileName, Tcl_PosixError(interp));
+		fileName, Tcl_PosixError(interp)));
 	return TCL_ERROR;
     }
 
diff --git a/unix/tclLoadShl.c b/unix/tclLoadShl.c
index 968f232..7b80bcc 100644
--- a/unix/tclLoadShl.c
+++ b/unix/tclLoadShl.c
@@ -22,14 +22,14 @@
 #endif
 
 #include "tclInt.h"
-
-/* Static functions defined within this file */
 
-static void* FindSymbol(Tcl_Interp* interp, Tcl_LoadHandle loadHandle,
-			const char* symbol);
-static void
-UnloadFile(Tcl_LoadHandle handle);
+/*
+ * Static functions defined within this file.
+ */
 
+static void *		FindSymbol(Tcl_Interp *interp,
+			    Tcl_LoadHandle loadHandle, const char *symbol);
+static void		UnloadFile(Tcl_LoadHandle handle);
 
 /*
  *----------------------------------------------------------------------
@@ -137,7 +137,7 @@ FindSymbol(
 {
     Tcl_DString newName;
     Tcl_PackageInitProc *proc = NULL;
-    shl_t handle = (shl_t)(loadHandle->clientData);
+    shl_t handle = (shl_t) loadHandle->clientData;
 
     /*
      * Some versions of the HP system software still use "_" at the beginning
@@ -187,9 +187,8 @@ UnloadFile(
 				 * TclpDlopen(). The loadHandle is a token
 				 * that represents the loaded file. */
 {
-    shl_t handle;
+    shl_t handle = (shl_t) loadHandle->clientData;
 
-    handle = (shl_t) (loadHandle -> clientData);
     shl_unload(handle);
     ckfree(loadHandle);
 }
diff --git a/unix/tclUnixFile.c b/unix/tclUnixFile.c
index 01fc6fe..38504d9 100644
--- a/unix/tclUnixFile.c
+++ b/unix/tclUnixFile.c
@@ -470,7 +470,7 @@ NativeMatchType(
 #ifndef MAC_OSX_TCL
 	    || ((types->perm & TCL_GLOB_PERM_HIDDEN) &&
 		(*nativeName != '.'))
-#endif
+#endif /* MAC_OSX_TCL */
 		) {
 	    return 0;
 	}
@@ -488,12 +488,10 @@ NativeMatchType(
 		 * check that here:
 		 */
 
-		if (types->type & TCL_GLOB_TYPE_LINK) {
-		    if (TclOSlstat(nativeEntry, &buf) == 0) {
-			if (S_ISLNK(buf.st_mode)) {
-			    return 1;
-			}
-		    }
+		if ((types->type & TCL_GLOB_TYPE_LINK)
+			&& (TclOSlstat(nativeEntry, &buf) == 0)
+			&& S_ISLNK(buf.st_mode)) {
+		    return 1;
 		}
 		return 0;
 	    }
@@ -516,12 +514,10 @@ NativeMatchType(
 	     */
 	} else {
 #ifdef S_ISLNK
-	    if (types->type & TCL_GLOB_TYPE_LINK) {
-		if (TclOSlstat(nativeEntry, &buf) == 0) {
-		    if (S_ISLNK(buf.st_mode)) {
-			goto filetypeOK;
-		    }
-		}
+	    if ((types->type & TCL_GLOB_TYPE_LINK)
+		    && (TclOSlstat(nativeEntry, &buf) == 0)
+		    && S_ISLNK(buf.st_mode)) {
+		goto filetypeOK;
 	    }
 #endif /* S_ISLNK */
 	    return 0;
@@ -717,9 +713,9 @@ TclpGetNativeCwd(
     if (getcwd(buffer, MAXPATHLEN+1) == NULL) {		/* INTL: Native. */
 	return NULL;
     }
-#endif
+#endif /* USEGETWD */
 
-    if ((clientData == NULL) || strcmp(buffer, (const char*)clientData)) {
+    if ((clientData == NULL) || strcmp(buffer, (const char *) clientData)) {
 	char *newCd = ckalloc(strlen(buffer) + 1);
 
 	strcpy(newCd, buffer);
@@ -767,7 +763,7 @@ TclpGetCwd(
     if (getwd(buffer) == NULL)				/* INTL: Native. */
 #else
     if (getcwd(buffer, MAXPATHLEN+1) == NULL)		/* INTL: Native. */
-#endif
+#endif /* USEGETWD */
     {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
@@ -823,7 +819,7 @@ TclpReadlink(
     return Tcl_DStringValue(linkPtr);
 #else
     return NULL;
-#endif
+#endif /* !DJGPP */
 }
 
 /*
@@ -857,7 +853,7 @@ TclpObjStat(
 
 #ifdef S_IFLNK
 
-Tcl_Obj*
+Tcl_Obj *
 TclpObjLink(
     Tcl_Obj *pathPtr,
     Tcl_Obj *toPtr,
@@ -1179,10 +1175,17 @@ TclpUtime(
 {
     return utime(Tcl_FSGetNativePath(pathPtr), tval);
 }
+
 #ifdef __CYGWIN__
-int TclOSstat(const char *name, Tcl_StatBuf *statBuf) {
+
+int
+TclOSstat(
+    const char *name,
+    Tcl_StatBuf *statBuf)
+{
     struct stat buf;
     int result = stat(name, &buf);
+
     statBuf->st_mode = buf.st_mode;
     statBuf->st_ino = buf.st_ino;
     statBuf->st_dev = buf.st_dev;
@@ -1196,9 +1199,15 @@ int TclOSstat(const char *name, Tcl_StatBuf *statBuf) {
     statBuf->st_ctime = buf.st_ctime;
     return result;
 }
-int TclOSlstat(const char *name, Tcl_StatBuf *statBuf) {
+
+int
+TclOSlstat(
+    const char *name,
+    Tcl_StatBuf *statBuf)
+{
     struct stat buf;
     int result = lstat(name, &buf);
+
     statBuf->st_mode = buf.st_mode;
     statBuf->st_ino = buf.st_ino;
     statBuf->st_dev = buf.st_dev;
@@ -1212,7 +1221,7 @@ int TclOSlstat(const char *name, Tcl_StatBuf *statBuf) {
     statBuf->st_ctime = buf.st_ctime;
     return result;
 }
-#endif
+#endif /* CYGWIN */
 
 /*
  * Local Variables:
diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index ca95f40..b87af1b 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -96,7 +96,7 @@ typedef struct ThreadSpecificData {
 	 * that an event is ready to be processed
 	 * by sending this event. */
     void *hwnd;			/* Messaging window. */
-#else /* !__CYGWIN__ */
+#else
     Tcl_Condition waitCV;	/* Any other thread alerts a notifier that an
 				 * event is ready to be processed by signaling
 				 * this condition variable. */
@@ -104,7 +104,7 @@ typedef struct ThreadSpecificData {
     int eventReady;		/* True if an event is ready to be processed.
 				 * Used as condition flag together with waitCV
 				 * above. */
-#endif
+#endif /* TCL_THREADS */
 } ThreadSpecificData;
 
 static Tcl_ThreadDataKey dataKey;
@@ -187,25 +187,12 @@ static Tcl_ThreadId notifierThread;
 static void		NotifierThreadProc(ClientData clientData);
 #endif
 static int		FileHandlerEventProc(Tcl_Event *evPtr, int flags);
-
+
 /*
- *----------------------------------------------------------------------
- *
- * Tcl_InitNotifier --
- *
- *	Initializes the platform specific notifier state.
- *
- * Results:
- *	Returns a handle to the notifier state for this thread.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
+ * Import of Windows API when building threaded with Cygwin.
  */
 
 #if defined(TCL_THREADS) && defined(__CYGWIN__)
-
 typedef struct {
     void *hwnd;
     unsigned int *message;
@@ -217,34 +204,60 @@ typedef struct {
 } MSG;
 
 typedef struct {
-  unsigned int style;
-  void *lpfnWndProc;
-  int cbClsExtra;
-  int cbWndExtra;
-  void *hInstance;
-  void *hIcon;
-  void *hCursor;
-  void *hbrBackground;
-  void *lpszMenuName;
-  void *lpszClassName;
+    unsigned int style;
+    void *lpfnWndProc;
+    int cbClsExtra;
+    int cbWndExtra;
+    void *hInstance;
+    void *hIcon;
+    void *hCursor;
+    void *hbrBackground;
+    void *lpszMenuName;
+    void *lpszClassName;
 } WNDCLASS;
 
-extern unsigned char __stdcall PeekMessageW(MSG *, void *, int, int, int);
-extern unsigned char __stdcall GetMessageW(MSG *, void *, int, int);
-extern unsigned char __stdcall TranslateMessage(const MSG *);
-extern int __stdcall DispatchMessageW(const MSG *);
-extern void __stdcall PostQuitMessage(int);
-extern void * __stdcall CreateWindowExW(void *, void *, void *, DWORD, int, int, int, int, void *, void *, void *, void *);
-extern unsigned char __stdcall DestroyWindow(void *);
-extern unsigned char __stdcall PostMessageW(void *, unsigned int, void *, void *);
-extern void *__stdcall RegisterClassW(const WNDCLASS *);
-extern DWORD __stdcall DefWindowProcW(void *, int, void *, void *);
-extern void *__stdcall CreateEventW(void *, unsigned char, unsigned char, void *);
-extern void __stdcall CloseHandle(void *);
-extern void __stdcall MsgWaitForMultipleObjects(DWORD, void *, unsigned char, DWORD, DWORD);
-extern unsigned char __stdcall ResetEvent(void *);
+extern void __stdcall	CloseHandle(void *);
+extern void *__stdcall	CreateEventW(void *, unsigned char, unsigned char,
+			    void *);
+extern void * __stdcall	CreateWindowExW(void *, void *, void *, DWORD, int,
+			    int, int, int, void *, void *, void *, void *);
+extern DWORD __stdcall	DefWindowProcW(void *, int, void *, void *);
+extern unsigned char __stdcall	DestroyWindow(void *);
+extern int __stdcall	DispatchMessageW(const MSG *);
+extern unsigned char __stdcall	GetMessageW(MSG *, void *, int, int);
+extern void __stdcall	MsgWaitForMultipleObjects(DWORD, void *,
+			    unsigned char, DWORD, DWORD);
+extern unsigned char __stdcall	PeekMessageW(MSG *, void *, int, int, int);
+extern unsigned char __stdcall	PostMessageW(void *, unsigned int, void *,
+				    void *);
+extern void __stdcall	PostQuitMessage(int);
+extern void *__stdcall	RegisterClassW(const WNDCLASS *);
+extern unsigned char __stdcall	ResetEvent(void *);
+extern unsigned char __stdcall	TranslateMessage(const MSG *);
 
-#endif
+/*
+ * Threaded-cygwin specific functions in this file:
+ */
+
+static DWORD __stdcall	NotifierProc(void *hwnd, unsigned int message,
+			    void *wParam, void *lParam);
+#endif /* TCL_THREADS && __CYGWIN__ */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_InitNotifier --
+ *
+ *	Initializes the platform specific notifier state.
+ *
+ * Results:
+ *	Returns a handle to the notifier state for this thread.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
 
 ClientData
 Tcl_InitNotifier(void)
@@ -403,11 +416,11 @@ Tcl_AlertNotifier(
 
 	Tcl_MutexLock(&notifierMutex);
 	tsdPtr->eventReady = 1;
-#ifdef __CYGWIN__
+#   ifdef __CYGWIN__
 	PostMessageW(tsdPtr->hwnd, 1024, 0, 0);
-#else
+#   else
 	Tcl_ConditionNotify(&tsdPtr->waitCV);
-#endif
+#   endif /* __CYGWIN__ */
 	Tcl_MutexUnlock(&notifierMutex);
 #endif /* TCL_THREADS */
     }
@@ -732,12 +745,12 @@ NotifierProc(
      * Process all of the runnable events.
      */
 
-	tsdPtr->eventReady = 1;
+    tsdPtr->eventReady = 1;
     Tcl_ServiceAll();
     return 0;
 }
-#endif /* __CYGWIN__ */
-
+#endif /* TCL_THREADS && __CYGWIN__ */
+
 /*
  *----------------------------------------------------------------------
  *
@@ -768,9 +781,9 @@ Tcl_WaitForEvent(
 	Tcl_Time vTime;
 #ifdef TCL_THREADS
 	int waitForFiles;
-# ifdef __CYGWIN__
-    MSG msg;
-# endif
+#   ifdef __CYGWIN__
+	MSG msg;
+#   endif /* __CYGWIN__ */
 #else
 	/*
 	 * Impl. notes: timeout & timeoutPtr are used if, and only if threads
@@ -792,8 +805,8 @@ Tcl_WaitForEvent(
 	if (timePtr != NULL) {
 	    /*
 	     * TIP #233 (Virtualized Time). Is virtual time in effect? And do
-	     * we actually have something to scale? If yes to both then we call
-	     * the handler to do this scaling.
+	     * we actually have something to scale? If yes to both then we
+	     * call the handler to do this scaling.
 	     */
 
 	    if (timePtr->sec != 0 || timePtr->usec != 0) {
@@ -807,17 +820,17 @@ Tcl_WaitForEvent(
 	    timeoutPtr = &timeout;
 	} else if (tsdPtr->numFdBits == 0) {
 	    /*
-	     * If there are no threads, no timeout, and no fds registered, then
-	     * there are no events possible and we must avoid deadlock. Note
-	     * that this is not entirely correct because there might be a
-	     * signal that could interrupt the select call, but we don't handle
-	     * that case if we aren't using threads.
+	     * If there are no threads, no timeout, and no fds registered,
+	     * then there are no events possible and we must avoid deadlock.
+	     * Note that this is not entirely correct because there might be a
+	     * signal that could interrupt the select call, but we don't
+	     * handle that case if we aren't using threads.
 	     */
 
 	    return -1;
 	} else {
 	    timeoutPtr = NULL;
-#endif /* TCL_THREADS */
+#endif /* !TCL_THREADS */
 	}
 
 #ifdef TCL_THREADS
@@ -828,7 +841,7 @@ Tcl_WaitForEvent(
 
 #ifdef __CYGWIN__
 	if (!tsdPtr->hwnd) {
-		WNDCLASS class;
+	    WNDCLASS class;
 
 	    class.style = 0;
 	    class.cbClsExtra = 0;
@@ -842,24 +855,24 @@ Tcl_WaitForEvent(
 	    class.hCursor = NULL;
 
 	    RegisterClassW(&class);
-	    tsdPtr->hwnd = CreateWindowExW(NULL, class.lpszClassName, class.lpszClassName,
-		    0, 0, 0, 0, 0, NULL, NULL, TclWinGetTclInstance(), NULL);
+	    tsdPtr->hwnd = CreateWindowExW(NULL, class.lpszClassName,
+		    class.lpszClassName, 0, 0, 0, 0, 0, NULL, NULL,
+		    TclWinGetTclInstance(), NULL);
 	    tsdPtr->event = CreateEventW(NULL, 1 /* manual */,
 		    0 /* !signaled */, NULL);
-    }
-
-#endif
+	}
+#endif /* __CYGWIN */
 
 	Tcl_MutexLock(&notifierMutex);
 
 	if (timePtr != NULL && timePtr->sec == 0 && (timePtr->usec == 0
 #if defined(__APPLE__) && defined(__LP64__)
 		/*
-		 * On 64-bit Darwin, pthread_cond_timedwait() appears to have a
-		 * bug that causes it to wait forever when passed an absolute
-		 * time which has already been exceeded by the system time; as
-		 * a workaround, when given a very brief timeout, just do a
-		 * poll. [Bug 1457797]
+		 * On 64-bit Darwin, pthread_cond_timedwait() appears to have
+		 * a bug that causes it to wait forever when passed an
+		 * absolute time which has already been exceeded by the system
+		 * time; as a workaround, when given a very brief timeout,
+		 * just do a poll. [Bug 1457797]
 		 */
 		|| timePtr->usec < 10
 #endif /* __APPLE__ && __LP64__ */
@@ -883,8 +896,8 @@ Tcl_WaitForEvent(
 	if (waitForFiles) {
 	    /*
 	     * Add the ThreadSpecificData structure of this thread to the list
-	     * of ThreadSpecificData structures of all threads that are waiting
-	     * on file events.
+	     * of ThreadSpecificData structures of all threads that are
+	     * waiting on file events.
 	     */
 
 	    tsdPtr->nextPtr = waitingListPtr;
@@ -909,6 +922,7 @@ Tcl_WaitForEvent(
 #ifdef __CYGWIN__
 	    if (!PeekMessageW(&msg, NULL, 0, 0, 0)) {
 		DWORD timeout;
+
 		if (timePtr) {
 		    timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
 		} else {
@@ -920,7 +934,7 @@ Tcl_WaitForEvent(
 	    }
 #else
 	    Tcl_ConditionWait(&tsdPtr->waitCV, &notifierMutex, timePtr);
-#endif
+#endif /* __CYGWIN__ */
 	}
 	tsdPtr->eventReady = 0;
 
@@ -929,17 +943,20 @@ Tcl_WaitForEvent(
 	    /*
 	     * Retrieve and dispatch the message.
 	     */
+
 	    DWORD result = GetMessageW(&msg, NULL, 0, 0);
+
 	    if (result == 0) {
 		PostQuitMessage(msg.wParam);
 		/* What to do here? */
-	    } else if (result != (DWORD)-1) {
+	    } else if (result != (DWORD) -1) {
 		TranslateMessage(&msg);
 		DispatchMessageW(&msg);
 	    }
 	}
 	ResetEvent(tsdPtr->event);
-#endif
+#endif /* __CYGWIN__ */
+
 	if (waitForFiles && tsdPtr->onList) {
 	    /*
 	     * Remove the ThreadSpecificData structure of this thread from the
@@ -1211,9 +1228,9 @@ NotifierThreadProc(
 		    tsdPtr->pollState = 0;
 		}
 #ifdef __CYGWIN__
-	    PostMessageW(tsdPtr->hwnd, 1024, 0, 0);
-#else /* __CYGWIN__ */
-	    Tcl_ConditionNotify(&tsdPtr->waitCV);
+		PostMessageW(tsdPtr->hwnd, 1024, 0, 0);
+#else
+		Tcl_ConditionNotify(&tsdPtr->waitCV);
 #endif /* __CYGWIN__ */
 	    }
 	}
@@ -1255,7 +1272,7 @@ NotifierThreadProc(
 }
 #endif /* TCL_THREADS */
 
-#endif /* HAVE_COREFOUNDATION */
+#endif /* !HAVE_COREFOUNDATION */
 
 /*
  * Local Variables:
diff --git a/win/tclWinReg.c b/win/tclWinReg.c
index c4a89e6..6ac5caf 100644
--- a/win/tclWinReg.c
+++ b/win/tclWinReg.c
@@ -15,6 +15,7 @@
 #undef STATIC_BUILD
 #undef USE_TCL_STUBS
 #define USE_TCL_STUBS
+
 #include "tclInt.h"
 #ifdef _MSC_VER
 #   pragma comment (lib, "advapi32.lib")
@@ -23,20 +24,20 @@
 
 #ifndef UNICODE
 #   undef Tcl_WinTCharToUtf
-#   define Tcl_WinTCharToUtf(a,b,c) Tcl_ExternalToUtfDString(NULL,a,b,c)
+#   define Tcl_WinTCharToUtf(a,b,c)	Tcl_ExternalToUtfDString(NULL,a,b,c)
 #   undef Tcl_WinUtfToTChar
-#   define Tcl_WinUtfToTChar(a,b,c) Tcl_UtfToExternalDString(NULL,a,b,c)
-#endif
+#   define Tcl_WinUtfToTChar(a,b,c)	Tcl_UtfToExternalDString(NULL,a,b,c)
+#endif /* !UNICODE */
 
 /*
  * Ensure that we can say which registry is being accessed.
  */
 
 #ifndef KEY_WOW64_64KEY
-#define KEY_WOW64_64KEY		(0x0100)
+#   define KEY_WOW64_64KEY	(0x0100)
 #endif
 #ifndef KEY_WOW64_32KEY
-#define KEY_WOW64_32KEY		(0x0200)
+#   define KEY_WOW64_32KEY	(0x0200)
 #endif
 
 /*
@@ -44,7 +45,7 @@
  */
 
 #ifndef MAX_KEY_LENGTH
-#define MAX_KEY_LENGTH		256
+#   define MAX_KEY_LENGTH	256
 #endif
 
 /*
@@ -57,14 +58,6 @@
 #define TCL_STORAGE_CLASS DLLEXPORT
 
 /*
- * The maximum length of a sub-key name.
- */
-
-#ifndef MAX_KEY_LENGTH
-#define MAX_KEY_LENGTH		256
-#endif
-
-/*
  * The following macros convert between different endian ints.
  */
 
@@ -817,16 +810,16 @@ GetValue(
 	 * we get bogus data.
 	 */
 
-	while ((p < end)
-		&& (*((Tcl_UniChar *) p)) != 0) {
+	while ((p < end) && *((Tcl_UniChar *) p) != 0) {
 	    Tcl_UniChar *up;
+
 	    Tcl_WinTCharToUtf((TCHAR *) p, -1, &buf);
 	    Tcl_ListObjAppendElement(interp, resultPtr,
 		    Tcl_NewStringObj(Tcl_DStringValue(&buf),
 			    Tcl_DStringLength(&buf)));
 	    up = (Tcl_UniChar *) p;
 
-	    while (*up++ != 0) {}
+	    while (*up++ != 0) {/* empty body */}
 	    p = (char *) up;
 	    Tcl_DStringFree(&buf);
 	}
@@ -1226,8 +1219,8 @@ RecursiveDeleteKey(
 	    }
 	    break;
 	} else if (result == ERROR_SUCCESS) {
-	    result = RecursiveDeleteKey(hKey, (const TCHAR *) Tcl_DStringValue(&subkey),
-		    mode);
+	    result = RecursiveDeleteKey(hKey,
+		    (const TCHAR *) Tcl_DStringValue(&subkey), mode);
 	}
     }
     Tcl_DStringFree(&subkey);
@@ -1294,8 +1287,8 @@ SetValue(
 	    return TCL_ERROR;
 	}
 
-	value = ConvertDWORD((DWORD)type, (DWORD)value);
-	result = RegSetValueEx(key, (TCHAR *)valueName, 0,
+	value = ConvertDWORD((DWORD) type, (DWORD) value);
+	result = RegSetValueEx(key, (TCHAR *) valueName, 0,
 		(DWORD) type, (BYTE *) &value, sizeof(DWORD));
     } else if (type == REG_MULTI_SZ) {
 	Tcl_DString data, buf;
@@ -1329,7 +1322,7 @@ SetValue(
 
 	Tcl_WinUtfToTChar(Tcl_DStringValue(&data), Tcl_DStringLength(&data)+1,
 		&buf);
-	result = RegSetValueEx(key, (TCHAR *)valueName, 0,
+	result = RegSetValueEx(key, (TCHAR *) valueName, 0,
 		(DWORD) type, (BYTE *) Tcl_DStringValue(&buf),
 		(DWORD) Tcl_DStringLength(&buf));
 	Tcl_DStringFree(&data);
@@ -1338,7 +1331,7 @@ SetValue(
 	Tcl_DString buf;
 	const char *data = Tcl_GetStringFromObj(dataObj, &length);
 
-	data = (char *)Tcl_WinUtfToTChar(data, length, &buf);
+	data = (char *) Tcl_WinUtfToTChar(data, length, &buf);
 
 	/*
 	 * Include the null in the length, padding if needed for Unicode.
@@ -1347,7 +1340,7 @@ SetValue(
 	Tcl_DStringSetLength(&buf, Tcl_DStringLength(&buf)+1);
 	length = Tcl_DStringLength(&buf) + 1;
 
-	result = RegSetValueEx(key, (TCHAR *)valueName, 0,
+	result = RegSetValueEx(key, (TCHAR *) valueName, 0,
 		(DWORD) type, (BYTE *) data, (DWORD) length);
 	Tcl_DStringFree(&buf);
     } else {
@@ -1358,7 +1351,7 @@ SetValue(
 	 */
 
 	data = (BYTE *) Tcl_GetByteArrayFromObj(dataObj, &length);
-	result = RegSetValueEx(key, (TCHAR *)valueName, 0,
+	result = RegSetValueEx(key, (TCHAR *) valueName, 0,
 		(DWORD) type, data, (DWORD) length);
     }
 
@@ -1529,14 +1522,15 @@ ConvertDWORD(
     DWORD type,			/* Either REG_DWORD or REG_DWORD_BIG_ENDIAN */
     DWORD value)		/* The value to be converted. */
 {
-    DWORD order = 1;
+    const DWORD order = 1;
     DWORD localType;
 
     /*
      * Check to see if the low bit is in the first byte.
      */
 
-    localType = (*((char *) &order) == 1) ? REG_DWORD : REG_DWORD_BIG_ENDIAN;
+    localType = (*((const char *) &order) == 1)
+	    ? REG_DWORD : REG_DWORD_BIG_ENDIAN;
     return (type != localType) ? (DWORD) SWAPLONG(value) : value;
 }