Style and whitespace fixes

1 files changed, 544 insertions, 443 deletions

diff --git a/generic/tclThreadStorage.c b/generic/tclThreadStorage.c
index 81c1e61..bf41adb 100644
--- a/generic/tclThreadStorage.c
+++ b/generic/tclThreadStorage.c
@@ -8,7 +8,7 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclThreadStorage.c,v 1.2 2004/06/24 04:13:30 dgp Exp $
+ * RCS: @(#) $Id: tclThreadStorage.c,v 1.3 2004/06/24 08:58:40 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -23,21 +23,24 @@
  * the number of hash table lookups in the master thread storage hash
  * table.
  */
+
 static Tcl_Mutex threadStorageLock;
 
 /*
  * This is the struct used for a thread storage cache slot. It contains
  * the owning thread Id and the associated hash table pointer.
  */
+
 typedef struct ThreadStorage {
-  Tcl_ThreadId id;             /* the owning thread id */
-  Tcl_HashTable *hashTablePtr; /* the hash table for the thread */
+    Tcl_ThreadId id;			/* the owning thread id */
+    Tcl_HashTable *hashTablePtr;	/* the hash table for the thread */
 } ThreadStorage;
 
 /*
  * These are the prototypes for the custom hash table allocation
  * functions used by the thread storage subsystem.
  */
+
 static Tcl_HashEntry *	AllocThreadStorageEntry _ANSI_ARGS_((
 			    Tcl_HashTable *tablePtr, void *keyPtr));
 static void		FreeThreadStorageEntry _ANSI_ARGS_((
@@ -49,41 +52,46 @@ static void		FreeThreadStorageEntry _ANSI_ARGS_((
  * because these hash tables MAY be used by the threaded memory allocator.
  */
 Tcl_HashKeyType tclThreadStorageHashKeyType = {
-    TCL_HASH_KEY_TYPE_VERSION,          /* version */
-    TCL_HASH_KEY_SYSTEM_HASH,           /* flags */
-    NULL,                               /* hashKeyProc */
-    NULL,                               /* compareKeysProc */
-    AllocThreadStorageEntry,            /* allocEntryProc */
-    FreeThreadStorageEntry              /* freeEntryProc */
+    TCL_HASH_KEY_TYPE_VERSION,		/* version */
+    TCL_HASH_KEY_SYSTEM_HASH,		/* flags */
+    NULL,				/* hashKeyProc */
+    NULL,				/* compareKeysProc */
+    AllocThreadStorageEntry,		/* allocEntryProc */
+    FreeThreadStorageEntry		/* freeEntryProc */
 };
 
 /*
  * This is an invalid thread value.
  */
+
 #define STORAGE_INVALID_THREAD  (Tcl_ThreadId)0
 
 /*
  * This is the value for an invalid thread storage key.
  */
-#define STORAGE_INVALID_KEY     0
+
+#define STORAGE_INVALID_KEY	0
 
 /*
  * This is the first valid key for use by external callers.
  * All the values below this are RESERVED for future use.
  */
-#define STORAGE_FIRST_KEY       101
+
+#define STORAGE_FIRST_KEY	101
 
 /*
  * This is the default number of thread storage cache slots.
  * This define may need to be fine tuned for maximum performance.
  */
-#define STORAGE_CACHE_SLOTS     97
+
+#define STORAGE_CACHE_SLOTS	97
 
 /*
  * This is the master thread storage hash table. It is keyed on
  * thread Id and contains values that are hash tables for each thread.
  * The thread specific hash tables contain the actual thread storage.
  */
+
 static Tcl_HashTable *threadStorageHashTablePtr = NULL;
 
 /*
@@ -91,11 +99,13 @@ static Tcl_HashTable *threadStorageHashTablePtr = NULL;
  * everytime we "allocate" one. It is initially set to 1 in
  * TclThreadStorageInit.
  */
+
 static int nextThreadStorageKey = STORAGE_INVALID_KEY;
 
 /*
  * Have we initialized the thread storage mutex yet?
  */
+
 static int initThreadStorage = 0;
 
 /*
@@ -103,23 +113,23 @@ static int initThreadStorage = 0;
  * prevents unnecessary lookups for threads that use a lot of thread
  * storage.
  */
-static volatile ThreadStorage threadStorageCache[STORAGE_CACHE_SLOTS];
 
+static volatile ThreadStorage threadStorageCache[STORAGE_CACHE_SLOTS];
 
 /*
  *----------------------------------------------------------------------
  *
  * TclThreadStorageLockInit
  *
- *      This procedure is used to initialize the lock that serializes
- *      creation of thread storage.
+ *	This procedure is used to initialize the lock that serializes
+ *	creation of thread storage.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      The master lock is acquired and possibly initialized for the
- *      first time.
+ *	The master lock is acquired and possibly initialized for the
+ *	first time.
  *
  *----------------------------------------------------------------------
  */
@@ -128,12 +138,12 @@ void
 TclThreadStorageLockInit()
 {
     if (!initThreadStorage) {
-        /*
-         * Mutexes in Tcl are self initializing, and we are taking
-         * advantage of that fact since this file cannot contain
-         * platform specific calls.
-         */
-        initThreadStorage = 1;
+	/*
+	 * Mutexes in Tcl are self initializing, and we are taking
+	 * advantage of that fact since this file cannot contain
+	 * platform specific calls.
+	 */
+	initThreadStorage = 1;
     }
 }
 
@@ -142,17 +152,17 @@ TclThreadStorageLockInit()
  *
  * TclThreadStorageLock
  *
- *      This procedure is used to grab a lock that serializes creation
- *      of thread storage.
+ *	This procedure is used to grab a lock that serializes creation
+ *	of thread storage.
  *
- *      This lock must be different than the initLock because the
- *      initLock is held during creation of syncronization objects.
+ *	This lock must be different than the initLock because the
+ *	initLock is held during creation of syncronization objects.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      Acquire the thread storage mutex.
+ *	Acquire the thread storage mutex.
  *
  *----------------------------------------------------------------------
  */
@@ -169,14 +179,14 @@ TclThreadStorageLock()
  *
  * TclThreadStorageUnlock
  *
- *      This procedure is used to release a lock that serializes creation
- *      of thread storage.
+ *	This procedure is used to release a lock that serializes creation
+ *	of thread storage.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      Release the thread storage mutex.
+ *	Release the thread storage mutex.
  *
  *----------------------------------------------------------------------
  */
@@ -192,15 +202,15 @@ TclThreadStorageUnlock()
  *
  * AllocThreadStorageEntry --
  *
- *	    Allocate space for a Tcl_HashEntry using TclpSysAlloc (not 
- *      ckalloc). We do this because the threaded memory allocator MAY 
- *      use the thread storage hash tables.
+ *	Allocate space for a Tcl_HashEntry using TclpSysAlloc (not
+ *	ckalloc). We do this because the threaded memory allocator MAY
+ *	use the thread storage hash tables.
  *
  * Results:
- *	    The return value is a pointer to the created entry.
+ *	The return value is a pointer to the created entry.
  *
  * Side effects:
- *	    None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
@@ -223,15 +233,15 @@ AllocThreadStorageEntry(tablePtr, keyPtr)
  *
  * FreeThreadStorageEntry --
  *
- *	    Frees space for a Tcl_HashEntry using TclpSysFree (not ckfree). 
- *      We do this because the threaded memory allocator MAY use the 
- *      thread storage hash tables.
+ *	Frees space for a Tcl_HashEntry using TclpSysFree (not ckfree).
+ *	We do this because the threaded memory allocator MAY use the
+ *	thread storage hash tables.
  *
  * Results:
- *	    None.
+ *	None.
  *
  * Side effects:
- *	    None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
@@ -248,88 +258,96 @@ FreeThreadStorageEntry(hPtr)
  *
  *  TclThreadStoragePrint --
  *
- *      This procedure prints out the contents of the master thread
- *      storage hash table, the thread storage cache, and the next key
- *      value to the specified file.
+ *	This procedure prints out the contents of the master thread
+ *	storage hash table, the thread storage cache, and the next key
+ *	value to the specified file.
  *
- *      This assumes that thread storage lock is held.
+ *	This assumes that thread storage lock is held.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      The thread storage lock is acquired and released.
+ *	The thread storage lock is acquired and released.
  *
  *----------------------------------------------------------------------
  */
 
 void
 TclThreadStoragePrint(outFile, flags)
-    FILE *outFile;              /* The file to print the information to. */
-    int flags;                  /* Reserved for future use. */
+    FILE *outFile;		/* The file to print the information to. */
+    int flags;			/* Reserved for future use. */
 {
     Tcl_HashEntry *hPtr;
     Tcl_HashSearch search;
-#if 0
-    /* Please see comment regarding Tcl_HashStats below. */
-    CONST char *stats;
-#endif
-    int header;
-    int index;
+    int header, index;
 
     if (threadStorageHashTablePtr != NULL) {
-        hPtr = Tcl_FirstHashEntry(threadStorageHashTablePtr, &search);
-
-        if (hPtr != NULL) {
-            fprintf(outFile, "master thread storage hash table:\n");
-            for (; hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
-                fprintf(outFile, "master entry ptr %p, thread %p, thread table ptr %p\n",
-                    hPtr, Tcl_GetHashKey(threadStorageHashTablePtr, hPtr), Tcl_GetHashValue(hPtr));
-            }
-        } else {
-            fprintf(outFile, "master thread storage hash table has no entries\n");
-        }
+	hPtr = Tcl_FirstHashEntry(threadStorageHashTablePtr, &search);
+
+	if (hPtr != NULL) {
+	    fprintf(outFile, "master thread storage hash table:\n");
+	    for (; hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
+		fprintf(outFile,
+			"master entry ptr %p, thread %p, thread table ptr %p\n",
+			hPtr, Tcl_GetHashKey(threadStorageHashTablePtr, hPtr),
+			Tcl_GetHashValue(hPtr));
+	    }
+	} else {
+	    fprintf(outFile,
+		    "master thread storage hash table has no entries\n");
+	}
     } else {
-        fprintf(outFile, "master thread storage hash table not initialized\n");
+	fprintf(outFile,
+		"master thread storage hash table not initialized\n");
     }
 
     header = 0; /* we have not output the header yet. */
     for (index = 0; index < STORAGE_CACHE_SLOTS; index++) {
-        if (threadStorageCache[index].id != STORAGE_INVALID_THREAD) {
-            if (!header) {
-                fprintf(outFile, "thread storage cache (%d total slots):\n", STORAGE_CACHE_SLOTS);
-                header = 1;
-            }
-
-            fprintf(outFile, "slot %d, thread %p, thread table ptr %p\n",
-                index, threadStorageCache[index].id,
-                threadStorageCache[index].hashTablePtr);
-#if 0
-            /*
-             * Currently disabled due to Tcl_HashStats use of ckalloc and ckfree.
-             * Please note that this can produce a LOT of output.
-             */
-            if (threadStorageCache[index].hashTablePtr != NULL) {
-                stats = Tcl_HashStats(threadStorageCache[index].hashTablePtr);
-                if (stats != NULL) {
-                    fprintf(outFile, "%s\n", stats);
-                    ckfree((void *)stats);
-                } else {
-                    fprintf(outFile, "could not get table statistics for slot %d\n", index);
-                }
-            }
+	if (threadStorageCache[index].id != STORAGE_INVALID_THREAD) {
+	    if (!header) {
+		fprintf(outFile, "thread storage cache (%d total slots):\n",
+			STORAGE_CACHE_SLOTS);
+		header = 1;
+	    }
+
+	    fprintf(outFile, "slot %d, thread %p, thread table ptr %p\n",
+		    index, threadStorageCache[index].id,
+		    threadStorageCache[index].hashTablePtr);
+#ifdef VERBOSE_THREAD_STORAGE_DEBUGGING
+	    /*
+	     * Currently not enabled by default due to Tcl_HashStats
+	     * use of ckalloc and ckfree.  Please note that this can
+	     * produce a LOT of output.
+	     */
+	    if (threadStorageCache[index].hashTablePtr != NULL) {
+		CONST char *stats =
+			Tcl_HashStats(threadStorageCache[index].hashTablePtr);
+		if (stats != NULL) {
+		    fprintf(outFile, "%s\n", stats);
+		    ckfree((void *)stats);
+		} else {
+		    fprintf(outFile,
+			    "could not get table statistics for slot %d\n",
+			    index);
+		}
+	    }
 #endif
-        } else {
-            /* fprintf(outFile, "cache slot %d not used\n", index); */
-        }
+	} else {
+	    /* fprintf(outFile, "cache slot %d not used\n", index); */
+	}
     }
 
     if (!header) {
-        fprintf(outFile, "thread storage cache is empty (%d total slots)\n", STORAGE_CACHE_SLOTS);
-        header = 1;
+	fprintf(outFile, "thread storage cache is empty (%d total slots)\n",
+		STORAGE_CACHE_SLOTS);
+	header = 1;
     }
 
-    /* Show the next data key value. */
+    /*
+     * Show the next data key value.
+     */
+
     fprintf(outFile, "next data key value is: %d\n", nextThreadStorageKey);
 }
 
@@ -338,25 +356,25 @@ TclThreadStoragePrint(outFile, flags)
  *
  * TclThreadStorageGetHashTable --
  *
- *      This procedure returns a hash table pointer to be used for thread
- *      storage for the specified thread.
+ *	This procedure returns a hash table pointer to be used for thread
+ *	storage for the specified thread.
  *
- * Results:
- *      A hash table pointer for the specified thread, or NULL
- *      if the hash table has not been created yet.
+ *	This assumes that thread storage lock is held.
  *
- *      This assumes that thread storage lock is held.
+ * Results:
+ *	A hash table pointer for the specified thread, or NULL
+ *	if the hash table has not been created yet.
  *
  * Side effects:
- *      May change an entry in the master thread storage cache to point
- *      to the specified thread and it's associated hash table.
+ *	May change an entry in the master thread storage cache to point
+ *	to the specified thread and it's associated hash table.
  *
  *----------------------------------------------------------------------
  */
 
 Tcl_HashTable *
 TclThreadStorageGetHashTable(id)
-    Tcl_ThreadId id;    /* Id of the thread to get the hash table for */
+    Tcl_ThreadId id;		/* Id of thread to get hash table for */
 {
     int index = (unsigned int)id % STORAGE_CACHE_SLOTS;
     Tcl_HashEntry *hPtr;
@@ -367,54 +385,79 @@ TclThreadStorageGetHashTable(id)
      * comparing thread Id in case another thread is in the critical
      * region changing things out from under you.
      */
+
     Tcl_HashTable *hashTablePtr = threadStorageCache[index].hashTablePtr;
 
     if (threadStorageCache[index].id != id) {
-        TclThreadStorageLock();
-
-        /* make sure the master hash table is initialized. */
-        TclThreadStorageInit(STORAGE_INVALID_THREAD, NULL);
-
-        if (threadStorageHashTablePtr != NULL) {
-            /* it's not in the cache, so we look it up... */
-            hPtr = Tcl_FindHashEntry(threadStorageHashTablePtr, (char *)id);
-
-            if (hPtr != NULL) {
-                /* we found it, extract the hash table pointer. */
-                hashTablePtr = Tcl_GetHashValue(hPtr);
-            } else {
-                /* the thread specific hash table is not found. */
-                hashTablePtr = NULL;
-            }
-
-            if (hashTablePtr == NULL) {          
-                hashTablePtr = (Tcl_HashTable *)TclpSysAlloc(sizeof(Tcl_HashTable), 0);
-          
-                if (hashTablePtr != NULL) {
-                    Tcl_InitCustomHashTable(hashTablePtr, TCL_CUSTOM_TYPE_KEYS, &tclThreadStorageHashKeyType);
-          
-                    /* add new thread storage hash table to the master hash table */
-                    hPtr = Tcl_CreateHashEntry(threadStorageHashTablePtr, (char *)id, &new);
-          
-                    if (hPtr != NULL) {
-                        Tcl_SetHashValue(hPtr, hashTablePtr);
-                    } else {
-                        Tcl_Panic("Tcl_CreateHashEntry failed from TclThreadStorageInit!");
-                    }
-                } else {
-                    Tcl_Panic("could not allocate thread specific hash table, TclpSysAlloc failed from TclThreadStorageGetHashTable!");
-                }
-            }
-
-            /* now, we put it in the cache since it is highly likely it will
-               be needed again shortly. */
-            threadStorageCache[index].id = id;
-            threadStorageCache[index].hashTablePtr = hashTablePtr;
-        } else {
-            /* we cannot look it up, the master hash table has not been initialized. */
-            hashTablePtr = NULL;
-        }
-        TclThreadStorageUnlock();
+	TclThreadStorageLock();
+
+	/*
+	 * Make sure the master hash table is initialized.
+	 */
+
+	TclThreadStorageInit(STORAGE_INVALID_THREAD, NULL);
+
+	if (threadStorageHashTablePtr != NULL) {
+	    /*
+	     * It's not in the cache, so we look it up...
+	     */
+
+	    hPtr = Tcl_FindHashEntry(threadStorageHashTablePtr, (char *)id);
+
+	    if (hPtr != NULL) {
+		/*
+		 * We found it, extract the hash table pointer.
+		 */
+		hashTablePtr = Tcl_GetHashValue(hPtr);
+	    } else {
+		/*
+		 * The thread specific hash table is not found.
+		 */
+		hashTablePtr = NULL;
+	    }
+
+	    if (hashTablePtr == NULL) {
+		hashTablePtr = (Tcl_HashTable *)
+			TclpSysAlloc(sizeof(Tcl_HashTable), 0);
+
+		if (hashTablePtr == NULL) {
+		    Tcl_Panic("could not allocate thread specific hash "
+			    "table, TclpSysAlloc failed from "
+			    "TclThreadStorageGetHashTable!");
+		}
+		Tcl_InitCustomHashTable(hashTablePtr, TCL_CUSTOM_TYPE_KEYS,
+			&tclThreadStorageHashKeyType);
+
+		/*
+		 * Add new thread storage hash table to the master
+		 * hash table.
+		 */
+
+		hPtr = Tcl_CreateHashEntry(threadStorageHashTablePtr,
+			(char *)id, &new);
+
+		if (hPtr == NULL) {
+		    Tcl_Panic("Tcl_CreateHashEntry failed from "
+			    "TclThreadStorageInit!");
+		}
+		Tcl_SetHashValue(hPtr, hashTablePtr);
+	    }
+
+	    /*
+	     * Now, we put it in the cache since it is highly likely
+	     * it will be needed again shortly.
+	     */
+
+	    threadStorageCache[index].id = id;
+	    threadStorageCache[index].hashTablePtr = hashTablePtr;
+	} else {
+	    /*
+	     * We cannot look it up, the master hash table has not
+	     * been initialized.
+	     */
+	    hashTablePtr = NULL;
+	}
+	TclThreadStorageUnlock();
     }
 
     return hashTablePtr;
@@ -425,49 +468,59 @@ TclThreadStorageGetHashTable(id)
  *
  * TclThreadStorageInit --
  *
- *      This procedure initializes a thread specific hash table for the
- *      current thread. It may also initialize the master hash table which
- *      stores all the thread specific hash tables.
+ *	This procedure initializes a thread specific hash table for the
+ *	current thread. It may also initialize the master hash table which
+ *	stores all the thread specific hash tables.
  *
- *      This assumes that thread storage lock is held.
+ *	This assumes that thread storage lock is held.
  *
  * Results:
- *      A hash table pointer for the specified thread, or NULL if we are
- *      be called to initialize the master hash table only.
+ *	A hash table pointer for the specified thread, or NULL if we are
+ *	be called to initialize the master hash table only.
  *
  * Side effects:
- *      The thread specific hash table may be initialized and added to the
- *      master hash table.
+ *	The thread specific hash table may be initialized and added to the
+ *	master hash table.
  *
  *----------------------------------------------------------------------
  */
 
 Tcl_HashTable *
 TclThreadStorageInit(id, reserved)
-    Tcl_ThreadId id;    /* Id of the thread to get the hash table for */
-    void *reserved;     /* reserved for future use */
+    Tcl_ThreadId id;		/* Id of thread to get hash table for */
+    void *reserved;		/* reserved for future use */
 {
 #if 0 /* #ifdef TCL_THREAD_STORAGE_DEBUG */
     TclThreadStoragePrint(stderr, 0);
 #endif
 
     if (threadStorageHashTablePtr == NULL) {
-        /* looks like we haven't created the outer hash table yet
-           we can just do that now. */
-        threadStorageHashTablePtr = (Tcl_HashTable *)TclpSysAlloc(sizeof(Tcl_HashTable), 0);
-
-        if (threadStorageHashTablePtr != NULL) {
-            /* initialize the hash table */
-            Tcl_InitCustomHashTable(threadStorageHashTablePtr, TCL_CUSTOM_TYPE_KEYS, &tclThreadStorageHashKeyType);
-        } else {
-            Tcl_Panic("could not allocate master thread storage hash table, TclpSysAlloc failed from TclThreadStorageInit!");
-        }
-
-        /* we also initialize the cache. */
-        memset((ThreadStorage *)&threadStorageCache, 0, sizeof(ThreadStorage) * STORAGE_CACHE_SLOTS);
-
-        /* now, we set the first value to be used for a thread data key. */
-        nextThreadStorageKey = STORAGE_FIRST_KEY;
+	/*
+	 * Looks like we haven't created the outer hash table yet we
+	 * can just do that now.
+	 */
+
+	threadStorageHashTablePtr = (Tcl_HashTable *)
+		TclpSysAlloc(sizeof(Tcl_HashTable), 0);
+	if (threadStorageHashTablePtr == NULL) {
+	    Tcl_Panic("could not allocate master thread storage hash table, "
+		    "TclpSysAlloc failed from TclThreadStorageInit!");
+	}
+	Tcl_InitCustomHashTable(threadStorageHashTablePtr,
+		TCL_CUSTOM_TYPE_KEYS, &tclThreadStorageHashKeyType);
+
+	/*
+	 * We also initialize the cache.
+	 */
+
+	memset((ThreadStorage *)&threadStorageCache, 0,
+		sizeof(ThreadStorage) * STORAGE_CACHE_SLOTS);
+
+	/*
+	 * Now, we set the first value to be used for a thread data key.
+	 */
+
+	nextThreadStorageKey = STORAGE_FIRST_KEY;
     }
 
     return NULL;
@@ -478,67 +531,67 @@ TclThreadStorageInit(id, reserved)
  *
  * TclThreadStorageDataKeyInit --
  *
- *      This procedure initializes a thread specific data block key.
- *      Each thread has table of pointers to thread specific data.
- *      all threads agree on which table entry is used by each module.
- *      this is remembered in a "data key", that is just an index into
- *      this table.  To allow self initialization, the interface
- *      passes a pointer to this key and the first thread to use
- *      the key fills in the pointer to the key.  The key should be
- *      a process-wide static.
+ *	This procedure initializes a thread specific data block key.
+ *	Each thread has table of pointers to thread specific data.
+ *	all threads agree on which table entry is used by each module.
+ *	this is remembered in a "data key", that is just an index into
+ *	this table.  To allow self initialization, the interface
+ *	passes a pointer to this key and the first thread to use
+ *	the key fills in the pointer to the key.  The key should be
+ *	a process-wide static.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      Will allocate memory the first time this process calls for
- *      this key.  In this case it modifies its argument
- *      to hold the pointer to information about the key.
+ *	Will allocate memory the first time this process calls for
+ *	this key.  In this case it modifies its argument
+ *	to hold the pointer to information about the key.
  *
  *----------------------------------------------------------------------
  */
 
 void
 TclThreadStorageDataKeyInit(keyPtr)
-    Tcl_ThreadDataKey *keyPtr;  /* Identifier for the data chunk,
-                                 * really (int **) */
+    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,
+				 * really (int **) */
 {
     int *indexPtr;
     int newKey;
 
     if (*keyPtr == NULL) {
-        indexPtr = (int *)TclpSysAlloc(sizeof(int), 0);
-
-        if (indexPtr != NULL) {
-            /*
-             * We must call this now to make sure
-             * that nextThreadStorageKey has a well defined
-             * value.
-             */
-            TclThreadStorageLock();
-
-            /* make sure the master hash table is initialized. */
-            TclThreadStorageInit(STORAGE_INVALID_THREAD, NULL);
-
-            /*
-             * These data key values are sequentially
-             * assigned and we must use the storage
-             * lock to prevent serious problems here.
-             * Also note that the caller should
-             * NOT make any assumptions about the
-             * provided values. In particular, we may
-             * need to reserve some values in the
-             * future.
-             */
-            newKey = nextThreadStorageKey++;
-            TclThreadStorageUnlock();
-
-            *indexPtr = newKey;
-            *keyPtr = (Tcl_ThreadDataKey)indexPtr;
-            TclRememberDataKey(keyPtr);
-        } else {
-            Tcl_Panic("TclpSysAlloc failed from TclThreadStorageDataKeyInit!"); /* this should also be a fatal error */
-        }
+	indexPtr = (int *)TclpSysAlloc(sizeof(int), 0);
+	if (indexPtr == NULL) {
+	    Tcl_Panic("TclpSysAlloc failed from TclThreadStorageDataKeyInit!");
+	}
+
+	/*
+	 * We must call this now to make sure that
+	 * nextThreadStorageKey has a well defined value.
+	 */
+
+	TclThreadStorageLock();
+
+	/*
+	 * Make sure the master hash table is initialized.
+	 */
+
+	TclThreadStorageInit(STORAGE_INVALID_THREAD, NULL);
+
+	/*
+	 * These data key values are sequentially assigned and we must
+	 * use the storage lock to prevent serious problems here.
+	 * Also note that the caller should NOT make any assumptions
+	 * about the provided values. In particular, we may need to
+	 * reserve some values in the future.
+	 */
+
+	newKey = nextThreadStorageKey++;
+	TclThreadStorageUnlock();
+
+	*indexPtr = newKey;
+	*keyPtr = (Tcl_ThreadDataKey)indexPtr;
+	TclRememberDataKey(keyPtr);
     }
 }
 
@@ -547,46 +600,44 @@ TclThreadStorageDataKeyInit(keyPtr)
  *
  * TclThreadStorageDataKeyGet --
  *
- *      This procedure returns a pointer to a block of thread local storage.
+ *	This procedure returns a pointer to a block of thread local storage.
  *
  * Results:
- *      A thread-specific pointer to the data structure, or NULL
- *      if the memory has not been assigned to this key for this thread.
+ *	A thread-specific pointer to the data structure, or NULL
+ *	if the memory has not been assigned to this key for this thread.
  *
  * Side effects:
- *      None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 void *
 TclThreadStorageDataKeyGet(keyPtr)
-    Tcl_ThreadDataKey *keyPtr;  /* Identifier for the data chunk,
-                                 * really (int **) */
+    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,
+				 * really (int **) */
 {
     int *indexPtr = *(int **)keyPtr;
     void *result;
-    Tcl_ThreadId id = Tcl_GetCurrentThread();
-    Tcl_HashTable *hashTablePtr;
-    Tcl_HashEntry *hPtr;
 
     if (indexPtr == NULL) {
-        result = NULL;
+	return NULL;
     } else {
-        hashTablePtr = TclThreadStorageGetHashTable(id);
-
-        if (hashTablePtr != NULL) {
-            hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr);
-
-            if (hPtr != NULL) {
-                result = (void *)Tcl_GetHashValue(hPtr);
-            } else {
-                result = NULL;
-            }
-        } else {
-            Tcl_Panic("TclThreadStorageGetHashTable failed from TclThreadStorageDataKeyGet!");
-            result = NULL;
-        }
+	Tcl_HashTable *hashTablePtr =
+		TclThreadStorageGetHashTable(Tcl_GetCurrentThread(););
+	Tcl_HashEntry *hPtr;
+
+	if (hashTablePtr != NULL) {
+	    Tcl_Panic("TclThreadStorageGetHashTable failed from "
+		    "TclThreadStorageDataKeyGet!");
+	}
+
+	hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr);
+
+	if (hPtr == NULL) {
+	    return NULL;
+	}
+	return (void *)Tcl_GetHashValue(hPtr);
     }
     return result;
 }
@@ -596,48 +647,49 @@ TclThreadStorageDataKeyGet(keyPtr)
  *
  * TclThreadStorageDataKeySet --
  *
- *      This procedure sets the pointer to a block of thread local storage.
+ *	This procedure sets the pointer to a block of thread local storage.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      Sets up the thread so future calls to TclThreadStorageDataKeyGet
- *      with this key will return the data pointer.
+ *	Sets up the thread so future calls to TclThreadStorageDataKeyGet
+ *	with this key will return the data pointer.
  *
  *----------------------------------------------------------------------
  */
 
 void
 TclThreadStorageDataKeySet(keyPtr, data)
-    Tcl_ThreadDataKey *keyPtr;  /* Identifier for the data chunk,
-                                 * really (pthread_key_t **) */
-    void *data;                 /* Thread local storage */
+    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,
+				 * really (pthread_key_t **) */
+    void *data;			/* Thread local storage */
 {
     int *indexPtr = *(int **)keyPtr;
-    Tcl_ThreadId id = Tcl_GetCurrentThread();
     Tcl_HashTable *hashTablePtr;
     Tcl_HashEntry *hPtr;
-    int new;
-
-    hashTablePtr = TclThreadStorageGetHashTable(id);
 
-    if (hashTablePtr != NULL) {
-        hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr);
+    hashTablePtr = TclThreadStorageGetHashTable(Tcl_GetCurrentThread());
+    if (hashTablePtr == NULL) {
+	Tcl_Panic("TclThreadStorageGetHashTable failed from "
+		"TclThreadStorageDataKeySet!");
+    }
 
-        /* does the item need to be created? */
-        if (hPtr == NULL) {
-            hPtr = Tcl_CreateHashEntry(hashTablePtr, (char *)*indexPtr, &new);
-        }
+    hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr);
 
-        if (hPtr != NULL) {
-            Tcl_SetHashValue(hPtr, data);
-        } else {
-            Tcl_Panic("could not set hash entry value from TclThreadStorageDataKeySet");
-        }
-    } else {
-        Tcl_Panic("TclThreadStorageGetHashTable failed from TclThreadStorageDataKeySet!");
+    /*
+     * Does the item need to be created?
+     */
+    if (hPtr == NULL) {
+	int new;
+	hPtr = Tcl_CreateHashEntry(hashTablePtr, (char *)*indexPtr, &new);
+	if (hPtr == NULL) {
+	    Tcl_Panic("could not create hash entry value from "
+		    "TclThreadStorageDataKeySet");
+	}
     }
+
+    Tcl_SetHashValue(hPtr, data);
 }
 
 /*
@@ -645,56 +697,72 @@ TclThreadStorageDataKeySet(keyPtr, data)
  *
  * TclFinalizeThreadStorageThread --
  *
- *      This procedure cleans up the thread storage hash table for the
- *      specified thread.
+ *	This procedure cleans up the thread storage hash table for the
+ *	specified thread.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
+
 void
 TclFinalizeThreadStorageThread(id)
-    Tcl_ThreadId id;    /* Id of the thread to finalize */
+    Tcl_ThreadId id;		/* Id of the thread to finalize */
 {
     int index = (unsigned int)id % STORAGE_CACHE_SLOTS;
-    Tcl_HashTable *hashTablePtr; /* hash table for current thread */
-    Tcl_HashEntry *hPtr;  /* hash entry for current thread in master table */
+    Tcl_HashTable *hashTablePtr; /* Hash table for current thread */
+    Tcl_HashEntry *hPtr;	/* Hash entry for current thread in master
+				 * table */
 
     TclThreadStorageLock();
+
     if (threadStorageHashTablePtr != NULL) {
-        hPtr = Tcl_FindHashEntry(threadStorageHashTablePtr, (char *)id);
+	hPtr = Tcl_FindHashEntry(threadStorageHashTablePtr, (char *)id);
+
+	if (hPtr != NULL) {
+	    /*
+	     * We found it, extract the hash table pointer.
+	     */
+
+	    hashTablePtr = Tcl_GetHashValue(hPtr);
 
-        if (hPtr != NULL) {
-            /* we found it, extract the hash table pointer. */
-            hashTablePtr = Tcl_GetHashValue(hPtr);
+	    if (hashTablePtr != NULL) {
+		/*
+		 * Delete thread specific hash table and free the
+		 * struct.
+		 */
 
-            if (hashTablePtr != NULL) {
-                /* delete thread specific hash table and free the struct. */
-                Tcl_DeleteHashTable(hashTablePtr);
-                TclpSysFree((char *)hashTablePtr);
-            }
+		Tcl_DeleteHashTable(hashTablePtr);
+		TclpSysFree((char *)hashTablePtr);
+	    }
 
-            /* delete thread specific entry from master hash table. */
-            Tcl_DeleteHashEntry(hPtr);
-        }
+	    /*
+	     * Delete thread specific entry from master hash table.
+	     */
+
+	    Tcl_DeleteHashEntry(hPtr);
+	}
     }
 
     /*
      * Make sure cache entry for this thread is NULL.
      */
+
     if (threadStorageCache[index].id == id) {
-        /*
-         * We do not step on another thread's cache entry.
-         * This is especially important if we are creating
-         * and exiting a lot of threads.
-         */
-        threadStorageCache[index].id = STORAGE_INVALID_THREAD;
-        threadStorageCache[index].hashTablePtr = NULL;
+	/*
+	 * We do not step on another thread's cache entry.  This is
+	 * especially important if we are creating and exiting a lot
+	 * of threads.
+	 */
+
+	threadStorageCache[index].id = STORAGE_INVALID_THREAD;
+	threadStorageCache[index].hashTablePtr = NULL;
     }
+
     TclThreadStorageUnlock();
 }
 
@@ -703,15 +771,15 @@ TclFinalizeThreadStorageThread(id)
  *
  * TclFinalizeThreadStorage --
  *
- *      This procedure cleans up the master thread storage hash table,
- *      all thread specific hash tables, and the thread storage cache.
+ *	This procedure cleans up the master thread storage hash table,
+ *	all thread specific hash tables, and the thread storage cache.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      The master thread storage hash table and thread storage cache are
- *      reset to their initial (empty) state.
+ *	The master thread storage hash table and thread storage cache are
+ *	reset to their initial (empty) state.
  *
  *----------------------------------------------------------------------
  */
@@ -719,45 +787,63 @@ TclFinalizeThreadStorageThread(id)
 void
 TclFinalizeThreadStorage()
 {
-    Tcl_HashTable *hashTablePtr; /* hash table for current thread */
-    Tcl_HashSearch search; /* we need to hit every thread with this search */
-    Tcl_HashEntry *hPtr;  /* hash entry for current thread in master table */
-
     TclThreadStorageLock();
+
     if (threadStorageHashTablePtr != NULL) {
-        /*
-         * We are going to delete the hash table for every thread now. This
-         * hash table should be empty at this point, except for one entry
-         * for the current thread.
-         */
-        for (hPtr = Tcl_FirstHashEntry(threadStorageHashTablePtr, &search);
-                hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
-
-            /* get the hash table corresponding to the thread in question. */
-            hashTablePtr = Tcl_GetHashValue(hPtr);
-
-            if (hashTablePtr != NULL) {
-                /* delete thread specific hash table and free the struct. */
-                Tcl_DeleteHashTable(hashTablePtr);
-                TclpSysFree((char *)hashTablePtr);
-            }
-
-            /* delete thread specific entry from master hash table. */
-            Tcl_SetHashValue(hPtr, NULL);
-        }
-
-        Tcl_DeleteHashTable(threadStorageHashTablePtr);
-        TclpSysFree((char *)threadStorageHashTablePtr);
-
-        /* reset this so that next time around we know it's not valid. */
-        threadStorageHashTablePtr = NULL;
+	Tcl_HashSearch search;		/* We need to hit every thread with
+					 * this search. */
+	Tcl_HashEntry *hPtr;		/* Hash entry for current thread in
+					 * master table. */
+
+	/*
+	 * We are going to delete the hash table for every thread now.
+	 * This hash table should be empty at this point, except for
+	 * one entry for the current thread.
+	 */
+
+	for (hPtr = Tcl_FirstHashEntry(threadStorageHashTablePtr, &search);
+		hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
+	    Tcl_HashTable *hashTablePtr = Tcl_GetHashValue(hPtr);
+
+	    if (hashTablePtr != NULL) {
+		/*
+		 * Delete thread specific hash table for the thread in
+		 * question and free the struct.
+		 */
+
+		Tcl_DeleteHashTable(hashTablePtr);
+		TclpSysFree((char *)hashTablePtr);
+	    }
+
+	    /*
+	     * Delete thread specific entry from master hash table.
+	     */
+
+	    Tcl_SetHashValue(hPtr, NULL);
+	}
+
+	Tcl_DeleteHashTable(threadStorageHashTablePtr);
+	TclpSysFree((char *)threadStorageHashTablePtr);
+
+	/*
+	 * Reset this so that next time around we know it's not valid.
+	 */
+
+	threadStorageHashTablePtr = NULL;
     }
 
-    /* clear out the thread storage cache as well */
-    memset((ThreadStorage *)&threadStorageCache, 0, sizeof(ThreadStorage) * STORAGE_CACHE_SLOTS);
+    /*
+     * Clear out the thread storage cache as well.
+     */
+
+    memset((ThreadStorage *)&threadStorageCache, 0,
+	    sizeof(ThreadStorage) * STORAGE_CACHE_SLOTS);
+
+    /*
+     * Reset this to zero, it will be set to STORAGE_FIRST_KEY if the
+     * thread storage subsystem gets reinitialized
+     */
 
-    /* reset this to zero, it will be set to STORAGE_FIRST_KEY if the 
-       thread storage subsystem gets reinitialized */       
     nextThreadStorageKey = STORAGE_INVALID_KEY;
 
     TclThreadStorageUnlock();
@@ -768,14 +854,14 @@ TclFinalizeThreadStorage()
  *
  * TclFinalizeThreadStorageData --
  *
- *      This procedure cleans up the thread-local storage.  This is
- *      called once for each thread.
+ *	This procedure cleans up the thread-local storage.  This is
+ *	called once for each thread.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      Frees up the memory.
+ *	Frees up the memory.
  *
  *----------------------------------------------------------------------
  */
@@ -784,34 +870,33 @@ void
 TclFinalizeThreadStorageData(keyPtr)
     Tcl_ThreadDataKey *keyPtr;
 {
-    void *result;
-    int *indexPtr;
-    Tcl_ThreadId id = Tcl_GetCurrentThread();
-    Tcl_HashTable *hashTablePtr; /* hash table for current thread */
-    Tcl_HashEntry *hPtr; /* hash entry for data key in current thread */
-
     if (*keyPtr != NULL) {
-        indexPtr = *(int **)keyPtr;
-
-        hashTablePtr = TclThreadStorageGetHashTable(id);
-
-        if (hashTablePtr != NULL) {
-            hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr);
-
-            if (hPtr != NULL) {
-                result = Tcl_GetHashValue(hPtr);
-
-                if (result != NULL) {
-                    /* this must be ckfree because tclThread.c 
-                       allocates these using ckalloc. */
-                    ckfree((char *)result);
-                }
-
-                Tcl_SetHashValue(hPtr, NULL);
-            }
-        } else {
-            Tcl_Panic("TclThreadStorageGetHashTable failed from TclFinalizeThreadStorageData!");
-        }
+	Tcl_ThreadId id = Tcl_GetCurrentThread();
+	Tcl_HashTable *hashTablePtr;	/* Hash table for current thread */
+	Tcl_HashEntry *hPtr;		/* Hash entry for data key in current
+					 * thread. */
+	int *indexPtr = *(int **)keyPtr;
+
+	hashTablePtr = TclThreadStorageGetHashTable(id);
+	if (hashTablePtr == NULL) {
+	    Tcl_Panic("TclThreadStorageGetHashTable failed from "
+		    "TclFinalizeThreadStorageData!");
+	}
+
+	hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr);
+	if (hPtr != NULL) {
+	    void *result = Tcl_GetHashValue(hPtr);
+
+	    if (result != NULL) {
+		/*
+		 * This must be ckfree because tclThread.c allocates
+		 * these using ckalloc.
+		 */
+		ckfree((char *)result);
+	    }
+
+	    Tcl_SetHashValue(hPtr, NULL);
+	}
     }
 }
 
@@ -820,17 +905,17 @@ TclFinalizeThreadStorageData(keyPtr)
  *
  * TclFinalizeThreadStorageDataKey --
  *
- *      This procedure is invoked to clean up one key.  This is a
- *      process-wide storage identifier.  The thread finalization code
- *      cleans up the thread local storage itself.
+ *	This procedure is invoked to clean up one key.  This is a
+ *	process-wide storage identifier.  The thread finalization code
+ *	cleans up the thread local storage itself.
  *
- *      This assumes the master lock is held.
+ *	This assumes the master lock is held.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      The key is deallocated.
+ *	The key is deallocated.
  *
  *----------------------------------------------------------------------
  */
@@ -840,55 +925,66 @@ TclFinalizeThreadStorageDataKey(keyPtr)
     Tcl_ThreadDataKey *keyPtr;
 {
     int *indexPtr;
-    Tcl_HashTable *hashTablePtr; /* hash table for current thread */
-    Tcl_HashSearch search; /* we need to hit every thread with this search */
-    Tcl_HashEntry *hPtr; /* hash entry for current thread in master table */
-    Tcl_HashEntry *hDataPtr; /* hash entry for data key in current thread */
+    Tcl_HashTable *hashTablePtr;/* Hash table for current thread */
+    Tcl_HashSearch search;	/* Need to hit every thread with this search */
+    Tcl_HashEntry *hPtr;	/* Hash entry for current thread in master
+				 * table. */
+    Tcl_HashEntry *hDataPtr;	/* Hash entry for data key in current thread */
 
     if (*keyPtr != NULL) {
-        indexPtr = *(int **)keyPtr;
-
-        TclThreadStorageLock();
-        if (threadStorageHashTablePtr != NULL) {
-            /*
-             * We are going to delete the specified data key entry from every thread.
-             */
-            for (hPtr = Tcl_FirstHashEntry(threadStorageHashTablePtr, &search);
-                    hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
-
-                /* get the hash table corresponding to the thread in question. */
-                hashTablePtr = Tcl_GetHashValue(hPtr);
-
-                if (hashTablePtr != NULL) {
-                    /* now find the entry for the specified data key. */
-                    hDataPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr);
-
-                    if (hDataPtr != NULL) {
-                        /* delete the data key for this thread. */
-                        Tcl_DeleteHashEntry(hDataPtr);
-                    }
-                }
-            }
-        }
-        TclThreadStorageUnlock();
-
-        TclpSysFree((char *)indexPtr);
-        *keyPtr = NULL;
+	indexPtr = *(int **)keyPtr;
+
+	TclThreadStorageLock();
+
+	if (threadStorageHashTablePtr != NULL) {
+	    /*
+	     * We are going to delete the specified data key entry
+	     * from every thread.
+	     */
+
+	    for (hPtr = Tcl_FirstHashEntry(threadStorageHashTablePtr, &search);
+		    hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
+
+		/*
+		 * Get the hash table corresponding to the thread in question.
+		 */
+		hashTablePtr = Tcl_GetHashValue(hPtr);
+
+		if (hashTablePtr != NULL) {
+		    /*
+		     * Now find the entry for the specified data key.
+		     */
+		    hDataPtr = Tcl_FindHashEntry(hashTablePtr,
+			    (char *)*indexPtr);
+
+		    if (hDataPtr != NULL) {
+			/*
+			 * Delete the data key for this thread.
+			 */
+			Tcl_DeleteHashEntry(hDataPtr);
+		    }
+		}
+	    }
+	}
+
+	TclThreadStorageUnlock();
+
+	TclpSysFree((char *)indexPtr);
+	*keyPtr = NULL;
     }
 }
 
-#else /* !defined(TCL_THREADS) || !defined(USE_THREAD_STORAGE) */ 
+#else /* !defined(TCL_THREADS) || !defined(USE_THREAD_STORAGE) */
 
-static void ThreadStoragePanic _ANSI_ARGS_((
-          CONST char *message));
+static void ThreadStoragePanic _ANSI_ARGS_((CONST char *message));
 
 /*
  *----------------------------------------------------------------------
  *
  * ThreadStoragePanic --
  *
- *      Panic if Tcl was compiled without TCL_THREADS or without 
- *      USE_THREAD_STORAGE and a thread storage function has been 
+ *      Panic if Tcl was compiled without TCL_THREADS or without
+ *      USE_THREAD_STORAGE and a thread storage function has been
  *      called.
  *
  * Results:
@@ -900,49 +996,54 @@ static void ThreadStoragePanic _ANSI_ARGS_((
  *----------------------------------------------------------------------
  */
 static void ThreadStoragePanic(message)
-    CONST char *message; /* currently ignored */
+    CONST char *message;	/* currently ignored */
 {
 #ifdef TCL_THREADS
-  #ifdef USE_THREAD_STORAGE
-    /* 
-     * Do nothing, everything is OK. However, this should never happen 
-     * because this function only gets called by the dummy thread storage 
-     * functions (used when one or both of these DEFINES are not present).
+#   ifdef USE_THREAD_STORAGE
+    /*
+     * Do nothing, everything is OK. However, this should never happen
+     * because this function only gets called by the dummy thread
+     * storage functions (used when one or both of these DEFINES are
+     * not present).
      */
-  #else
+#   else
     Tcl_Panic("Tcl was not compiled with thread storage enabled.");
-  #endif
+#   endif /* USE_THREAD_STORAGE */
 #else
     Tcl_Panic("Tcl was not compiled with threads enabled.");
-#endif
+#endif /* TCL_THREADS */
 }
 
+/*
+ * Stub functions that just call ThreadStoragePanic.
+ */
+
 void
 TclThreadStorageLockInit()
 {
     ThreadStoragePanic(NULL);
 }
-
+
 void
 TclThreadStorageLock()
 {
     ThreadStoragePanic(NULL);
 }
-
+
 void
 TclThreadStorageUnlock()
 {
     ThreadStoragePanic(NULL);
 }
-
+
 void
 TclThreadStoragePrint(outFile, flags)
-    FILE *outFile;              
-    int flags;                  
+    FILE *outFile;
+    int flags;
 {
     ThreadStoragePanic(NULL);
 }
-
+
 Tcl_HashTable *
 TclThreadStorageGetHashTable(id)
     Tcl_ThreadId id;
@@ -950,59 +1051,59 @@ TclThreadStorageGetHashTable(id)
     ThreadStoragePanic(NULL);
     return NULL;
 }
-
+
 Tcl_HashTable *
 TclThreadStorageInit(id, reserved)
-    Tcl_ThreadId id;    
+    Tcl_ThreadId id;
     void *reserved;
 {
     ThreadStoragePanic(NULL);
     return NULL;
 }
-
+
 void
 TclThreadStorageDataKeyInit(keyPtr)
-    Tcl_ThreadDataKey *keyPtr;  
+    Tcl_ThreadDataKey *keyPtr;
 {
     ThreadStoragePanic(NULL);
-}                                
-
+}
+
 void *
 TclThreadStorageDataKeyGet(keyPtr)
-    Tcl_ThreadDataKey *keyPtr;  
+    Tcl_ThreadDataKey *keyPtr;
 {
     ThreadStoragePanic(NULL);
     return NULL;
-}                                
-
+}
+
 void
 TclThreadStorageDataKeySet(keyPtr, data)
-    Tcl_ThreadDataKey *keyPtr;                                 
-    void *data;                 
+    Tcl_ThreadDataKey *keyPtr;
+    void *data;
 {
     ThreadStoragePanic(NULL);
 }
-
+
 void
 TclFinalizeThreadStorageThread(id)
-    Tcl_ThreadId id;    
+    Tcl_ThreadId id;
 {
     ThreadStoragePanic(NULL);
 }
-
+
 void
 TclFinalizeThreadStorage()
 {
     ThreadStoragePanic(NULL);
 }
-
+
 void
 TclFinalizeThreadStorageData(keyPtr)
     Tcl_ThreadDataKey *keyPtr;
 {
     ThreadStoragePanic(NULL);
 }
-
+
 void
 TclFinalizeThreadStorageDataKey(keyPtr)
     Tcl_ThreadDataKey *keyPtr;