Index: TODO
===================================================================
diff -u -rf2e0d31e0f3527f2e1155c3cd3921b1af0369af4 -r5bf6fcf6449ad27d4f3df580f2f5b9521435e8b0
--- TODO	(.../TODO)	(revision f2e0d31e0f3527f2e1155c3cd3921b1af0369af4)
+++ TODO	(.../TODO)	(revision 5bf6fcf6449ad27d4f3df580f2f5b9521435e8b0)
@@ -1460,6 +1460,8 @@
 - runs now full regression test NRE enabled, but still much debugging and
   options for less conservative behaviour
 
+- some cleanup concerning TCL_STACK_ALLOC_TRACE
+
 TODO: 
 - IMMEDIATE in next needed?
 - major coro cleanup, when working
Index: generic/nsf.c
===================================================================
diff -u -rf2e0d31e0f3527f2e1155c3cd3921b1af0369af4 -r5bf6fcf6449ad27d4f3df580f2f5b9521435e8b0
--- generic/nsf.c	(.../nsf.c)	(revision f2e0d31e0f3527f2e1155c3cd3921b1af0369af4)
+++ generic/nsf.c	(.../nsf.c)	(revision 5bf6fcf6449ad27d4f3df580f2f5b9521435e8b0)
@@ -5839,7 +5839,8 @@
  */
 // prototype
 //TODO remove string, methodName
-NSF_INLINE static void ObjectDispatchFinalize(NsfObject *object, int flags, char *string, char *methodName);
+NSF_INLINE static void ObjectDispatchFinalize(NsfObject *object, int flags, 
+					      char *string, CONST char *methodName);
 
 #if defined(NRE)
 static int
@@ -5908,23 +5909,15 @@
 #endif
 
   if (pcPtr) {
-# if defined(TCL_STACK_ALLOC_TRACE)
-    fprintf(stderr, "---- ProcMethodDispatchFinalize calls releasePc, stackFree %p\n", pcPtr);
-# endif
     ParseContextRelease(pcPtr);
-    TclStackFree(interp, pcPtr);
+    NsfTclStackFree(interp, pcPtr, "release parse context");
   }
 
-# if defined(TCL_STACK_ALLOC_TRACE)
-  fprintf(stderr, "---- ProcMethodDispatchFinalize calls pop, csc free %p method %s\n", cscPtr, methodName);
-# endif
+  ObjectDispatchFinalize(object, flags, "NRE", methodName);
 
   CscFinish(interp, cscPtr);
-  TclStackFree(interp, cscPtr);
+  NsfTclStackFree(interp, cscPtr, "csc");
 
-  // any dependencies on cscPtr?
-  ObjectDispatchFinalize(object, flags, "NRE", methodName);
-
   return result;
 }
 #endif
@@ -5995,11 +5988,8 @@
           /*fprintf(stderr, "... after nextmethod result %d\n", result);*/
         }
 #if defined(NRE)
-# if defined(TCL_STACK_ALLOC_TRACE)
-        fprintf(stderr, "---- GuardFailed calls pop, cscPtr free %p method %s\n", cscPtr, methodName);
-# endif
         CscFinish(interp, cscPtr);
-        TclStackFree(interp, cscPtr);
+	NsfTclStackFree(interp, cscPtr, "csc (guard failed)");
         /* todo check mixin guards for same case? */
 #endif
         return result;
@@ -6029,10 +6019,7 @@
   
   if (paramDefs && paramDefs->paramsPtr) {
 #if defined(NRE)
-    pcPtr = (ParseContext *) TclStackAlloc(interp, sizeof(ParseContext));
-# if defined(TCL_STACK_ALLOC_TRACE)
-    fprintf(stderr, "---- ParseContext alloc %p\n", pcPtr);
-# endif
+    pcPtr = (ParseContext *) NsfTclStackAlloc(interp, sizeof(ParseContext), "parse context");
 #endif
     result = ProcessMethodArguments(pcPtr, interp, object, 1, paramDefs, methodName, objc, objv);
     cscPtr->objc = objc;
@@ -6053,12 +6040,11 @@
 
   if (result != TCL_OK) {
 #if defined(NRE)
-    if (pcPtr) TclStackFree(interp, pcPtr);
-# if defined(TCL_STACK_ALLOC_TRACE)
-    fprintf(stderr, "---- ProcPrep fails and calls pop, cscPtr free %p method %s\n", cscPtr, methodName);
-# endif
+    if (pcPtr) {
+      NsfTclStackFree(interp, pcPtr, "parse context (proc prep failed)");
+    }
     CscFinish(interp, cscPtr);
-    TclStackFree(interp, cscPtr);
+    NsfTclStackFree(interp, cscPtr, "csc (proc prep failed)");
 #endif
   }
 
@@ -6602,10 +6588,7 @@
 
 #if defined(NRE)
   if (proc == TclObjInterpProc) {
-    cscPtr = (NsfCallStackContent *) TclStackAlloc(interp, sizeof(NsfCallStackContent));
-# if defined(TCL_STACK_ALLOC_TRACE)
-    fprintf(stderr, "---- csc alloc %p method %s\n", cscPtr, methodName);
-# endif
+    cscPtr = (NsfCallStackContent *) NsfTclStackAlloc(interp, sizeof(NsfCallStackContent), "csc");
     cscPtr->callType = NSF_CSC_CALL_IS_NRE;
   } else {
     cscPtr->callType = 0;
@@ -6871,7 +6854,7 @@
 
 
 NSF_INLINE static void
-ObjectDispatchFinalize(NsfObject *object, int flags, char *string, char *methodName) {
+ObjectDispatchFinalize(NsfObject *object, int flags, char *string, CONST char *methodName) {
 
   if (!object->id) {
     fprintf(stderr, "ObjectDispatchFinalize %p flags %.6x id %p %s\n", 
Index: generic/nsfInt.h
===================================================================
diff -u -rd1ed482555d4d28dbb41fb9ca2723eabb5e01221 -r5bf6fcf6449ad27d4f3df580f2f5b9521435e8b0
--- generic/nsfInt.h	(.../nsfInt.h)	(revision d1ed482555d4d28dbb41fb9ca2723eabb5e01221)
+++ generic/nsfInt.h	(.../nsfInt.h)	(revision 5bf6fcf6449ad27d4f3df580f2f5b9521435e8b0)
@@ -738,6 +738,25 @@
 #endif /* NSF_MEM_COUNT */
 
 /*
+ * TCL_STACK_ALLOC_TRACE
+ */
+#if defined(TCL_STACK_ALLOC_TRACE)
+# define NsfTclStackFree(interp,ptr,msg) \
+  fprintf(stderr, "---- TclStackFree %p %s\n", ptr, msg);\
+  TclStackFree(interp,ptr)
+
+static char *
+NsfTclStackAlloc(Tcl_Interp *interp, size_t size, char *msg) {
+  char *ptr = TclStackAlloc(interp, size);
+  fprintf(stderr, "---- TclStackAlloc %p %s\n", ptr, msg);
+  return ptr;
+}
+#else
+# define NsfTclStackFree(interp,ptr,msg) TclStackFree(interp,ptr)
+# define NsfTclStackAlloc(interp,size,msg) TclStackAlloc(interp,size)
+#endif
+
+/*
  * bytecode support
  */
 #ifdef NSF_BYTECODE