Index: generic/nsfCmdDefinitions.c
===================================================================
diff -u -r34c49c5a5b485d039577e9b915bde84f8ff35eb0 -r7243f88cec779c0274f22e569790c7ad1216800f
--- generic/nsfCmdDefinitions.c	(.../nsfCmdDefinitions.c)	(revision 34c49c5a5b485d039577e9b915bde84f8ff35eb0)
+++ generic/nsfCmdDefinitions.c	(.../nsfCmdDefinitions.c)	(revision 7243f88cec779c0274f22e569790c7ad1216800f)
@@ -66,8 +66,6 @@
   NsfMutexLock(&cmdDefinitonMutex);
 
   if (cmdDefinitonRefCount == 0) {
-    /* Tcl_InitHashTable(cmdDefinitonHashTablePtr, TCL_ONE_WORD_KEYS); */
-    /* Tcl_InitCustomHashTable(cmdDefinitonHashTablePtr, TCL_CUSTOM_PTR_KEYS, &cmdPtrHashKeyType); */
     Nsf_InitFunPtrHashTable(cmdDefinitonHashTablePtr);
   }
   cmdDefinitonRefCount++;
@@ -124,8 +122,6 @@
 
   nonnull_assert(proc != NULL);
 
-  //fprintf(stderr, "=== Lookup proc %p\n", proc);
-
   NsfMutexLock(&cmdDefinitonMutex);
   hPtr = Nsf_FindFunPtrHashEntry(cmdDefinitonHashTablePtr, (Nsf_AnyFun *)proc);
   NsfMutexUnlock(&cmdDefinitonMutex);
@@ -157,16 +153,12 @@
 Register(Tcl_Interp *interp, Nsf_methodDefinition *methodDefinition) {
   Tcl_HashEntry *hPtr;
   int isNew;
-  /* cmdPtrEntry_t cmdEntry; */
 
   nonnull_assert(interp != NULL);
   nonnull_assert(methodDefinition != NULL);
 
-  /* fprintf(stderr, "=== Register proc %p with name %s\n", 
-     methodDefinition->proc, methodDefinition->methodName); */
-  /* cmdEntry.proc = methodDefinition->proc; */
   NsfMutexLock(&cmdDefinitonMutex);
-  hPtr = Nsf_CreateFunPtrHashEntry(cmdDefinitonHashTablePtr, (Nsf_AnyFun *)methodDefinition->proc, &isNew); /* Tcl_CreateHashEntry(cmdDefinitonHashTablePtr, (const char *)&cmdEntry, &isNew);*/
+  hPtr = Nsf_CreateFunPtrHashEntry(cmdDefinitonHashTablePtr, (Nsf_AnyFun *)methodDefinition->proc, &isNew); 
   NsfMutexUnlock(&cmdDefinitonMutex);
   
   if (isNew != 0) {
Index: generic/nsfEnumerationType.c
===================================================================
diff -u -r34c49c5a5b485d039577e9b915bde84f8ff35eb0 -r7243f88cec779c0274f22e569790c7ad1216800f
--- generic/nsfEnumerationType.c	(.../nsfEnumerationType.c)	(revision 34c49c5a5b485d039577e9b915bde84f8ff35eb0)
+++ generic/nsfEnumerationType.c	(.../nsfEnumerationType.c)	(revision 7243f88cec779c0274f22e569790c7ad1216800f)
@@ -65,7 +65,6 @@
   NsfMutexLock(&enumerationMutex);
 
   if (enumerationTypeRefCount == 0) {
-    /* Tcl_InitHashTable(enumerationHashTablePtr, TCL_STRING_KEYS); */
     Nsf_InitFunPtrHashTable(enumerationHashTablePtr);
   }
   enumerationTypeRefCount++;
@@ -130,16 +129,6 @@
 
   NsfMutexLock(&enumerationMutex);
   hPtr = Nsf_FindFunPtrHashEntry(enumerationHashTablePtr, (Nsf_AnyFun *)converter);
-  /* for (hPtr = Tcl_FirstHashEntry(enumerationHashTablePtr, &hSrch); hPtr != NULL;
-       hPtr = Tcl_NextHashEntry(&hSrch)) {
-    Nsf_TypeConverter *ptr = (Nsf_TypeConverter *)Tcl_GetHashValue(hPtr);
-
-    if (ptr == converter) {
-      domain = Tcl_GetHashKey(enumerationHashTablePtr, hPtr);
-      break;
-    }
-  }
-  */
   NsfMutexUnlock(&enumerationMutex);
 
   if (hPtr != NULL) {
@@ -174,7 +163,6 @@
 
   NsfMutexLock(&enumerationMutex);
   hPtr = Nsf_CreateFunPtrHashEntry(enumerationHashTablePtr, (Nsf_AnyFun *)converter, &isNew);
-  /* hPtr = Tcl_CreateHashEntry(enumerationHashTablePtr, domain, &isNew); */
   NsfMutexUnlock(&enumerationMutex);
 
   if (isNew != 0) {
Index: generic/nsfFunPtrHashTable.c
===================================================================
diff -u -r34c49c5a5b485d039577e9b915bde84f8ff35eb0 -r7243f88cec779c0274f22e569790c7ad1216800f
--- generic/nsfFunPtrHashTable.c	(.../nsfFunPtrHashTable.c)	(revision 34c49c5a5b485d039577e9b915bde84f8ff35eb0)
+++ generic/nsfFunPtrHashTable.c	(.../nsfFunPtrHashTable.c)	(revision 7243f88cec779c0274f22e569790c7ad1216800f)
@@ -93,26 +93,12 @@
   funPtrEntry_t  *e = (funPtrEntry_t *)keyPtr;
   Nsf_AnyFun *value  = e->funPtr;
 
-  /* fprintf(stderr, "=== hash from %p = %u // 0x%x\n", (void *)value, 
-     PTR2UINT(value), PTR2UINT(value)); */
   /*
    * This is a very simple approach for obtaining a hash value. Maybe one
    * needs a more sophisticated approach with wierd endians machines.
    */
   return PTR2UINT(value);
 
-  /*
-    as a reference: tcl's string hash functions
-
-    register unsigned int result;
-    register int c;
-    result = 0;
-
-    for (c=*string++ ; c ; c=*string++) {
-    result += (result<<3) + c;
-    }
-    return result;
-  */
 }
 
 /*
@@ -142,8 +128,6 @@
 
   memcpy(&existingValue, &hPtr->key.oneWordValue, sizeof(Nsf_AnyFun *));
 
-  //fprintf(stderr, "=== compare new %p existing %p\n", (void *)cmdPtr->proc, (void *)existingValue);
-
   return e->funPtr == existingValue;
 }
 
@@ -176,11 +160,8 @@
   if (size < sizeof(Tcl_HashEntry)) {
     size = sizeof(Tcl_HashEntry);
   }
-  /* fprintf(stderr, "=== alloc entry %p\n", (void *)value); */
   hPtr = (Tcl_HashEntry *) ckalloc(size);
 
-  /* fprintf(stderr, "=== trying to copy %ld bytes from %p to %p\n", 
-     sizeof(Nsf_AnyFun *), (void *)value, &hPtr->key.oneWordValue); */
   memcpy(&hPtr->key.oneWordValue, &value, sizeof(Nsf_AnyFun *));
 
   hPtr->clientData = 0;