Index: generic/nsf.c
===================================================================
diff -u -rea2dfe7e47f6773bf21bb23f1fa1cb8aa3be392c -rabcee3a1d292192180380901b5c44f83b719c8c8
--- generic/nsf.c	(.../nsf.c)	(revision ea2dfe7e47f6773bf21bb23f1fa1cb8aa3be392c)
+++ generic/nsf.c	(.../nsf.c)	(revision abcee3a1d292192180380901b5c44f83b719c8c8)
@@ -334,7 +334,7 @@
 /* prototypes for call stack specific calls */
 NSF_INLINE static void CscInit_(NsfCallStackContent *cscPtr, NsfObject *object, NsfClass *cl,
 			       Tcl_Command cmd, int frameType, int flags)
-  nonnull(1) nonnull(2) nonnull(3);
+  nonnull(1) nonnull(2);
 
 NSF_INLINE static void CscFinish_(Tcl_Interp *interp, NsfCallStackContent *cscPtr)
   nonnull(1) nonnull(2);
@@ -470,6 +470,9 @@
 NsfErrorContext(Tcl_Interp *interp, CONST char *context) {
   Tcl_DString ds, *dsPtr = &ds;
 
+  assert(interp); // autoadded
+  assert(context); // autoadded
+
   Tcl_DStringInit(dsPtr);
   Tcl_DStringAppend(dsPtr, "puts stderr \"Error in ", -1);
   Tcl_DStringAppend(dsPtr, context, -1);
@@ -498,6 +501,11 @@
 
 static int
 NsfDStringEval(Tcl_Interp *interp, Tcl_DString *dsPtr, CONST char *context) {
+
+  assert(interp); // autoadded
+  assert(dsPtr); // autoadded
+  assert(context); // autoadded
+
   int result = Tcl_EvalEx(interp, Tcl_DStringValue(dsPtr), Tcl_DStringLength(dsPtr), 0);
   if (result == TCL_ERROR) {
     NsfErrorContext(interp, context);
@@ -603,10 +611,15 @@
  *
  *----------------------------------------------------------------------
  */
-static void ParseContextInit(ParseContext *pcPtr, int objc, NsfObject *object, Tcl_Obj *procName) nonnull(1) nonnull(3) nonnull(4);
+static void ParseContextInit(ParseContext *pcPtr, int objc, NsfObject *object, Tcl_Obj *procName) 
+  nonnull(1) nonnull(4);
 
 static void
 ParseContextInit(ParseContext *pcPtr, int objc, NsfObject *object, Tcl_Obj *procName) {
+
+  assert(pcPtr); // autoadded
+  assert(procName); // autoadded
+
   if (likely(objc < PARSE_CONTEXT_PREALLOC)) {
     /* the single larger memset below .... */
     memset(pcPtr, 0, sizeof(ParseContext));
@@ -657,6 +670,9 @@
 ParseContextExtendObjv(ParseContext *pcPtr, int from, int elts, Tcl_Obj *CONST source[]) {
   int requiredSize = from + elts + 1;
 
+  assert(pcPtr); // autoadded
+  assert(source); // autoadded
+
   /*NsfPrintObjv("BEFORE: ", pcPtr->objc, pcPtr->full_objv);*/
 
   if (unlikely(requiredSize >= PARSE_CONTEXT_PREALLOC)) {
@@ -711,6 +727,8 @@
 ParseContextRelease(ParseContext *pcPtr) {
   int status = pcPtr->status;
 
+  assert(pcPtr); // autoadded
+
   /*fprintf(stderr, "ParseContextRelease %p status %.6x %d elements\n",
     pcPtr, status, pcPtr->objc);*/
 
@@ -839,7 +857,7 @@
  *
  * NsfCallMethodWithArgs --
  *
- *      Call method (passed in methodObj) on the object, with the always
+ *      Call method (passed in methodObj) on the object, with the often
  *      provided arg1 and the optional remaining args (passed vis objv).  This
  *      way, we save the memcpy in case no argument or an single argument are
  *      provided (common cases).
@@ -855,7 +873,7 @@
 
 int NsfCallMethodWithArgs(Tcl_Interp *interp, Nsf_Object *object, Tcl_Obj *methodObj,
 		      Tcl_Obj *arg1, int givenObjc, Tcl_Obj *CONST objv[], int flags) 
-  nonnull(1) nonnull(2) nonnull(3) nonnull(4);
+  nonnull(1) nonnull(2) nonnull(3);
 
 int
 NsfCallMethodWithArgs(Tcl_Interp *interp, Nsf_Object *object, Tcl_Obj *methodObj,
@@ -864,6 +882,10 @@
   int result;
   ALLOC_ON_STACK(Tcl_Obj*, objc, tov);
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+  assert(methodObj); // autoadded
+
   assert(objc > 1);
   tov[0] = object->cmdName;
   tov[1] = methodObj;
@@ -913,6 +935,10 @@
 
 static Tcl_HashEntry *
 Nsf_NextHashEntry(Tcl_HashTable *tablePtr, int expected, Tcl_HashSearch *hSrchPtr) {
+
+  assert(tablePtr); // autoadded
+  assert(hSrchPtr); // autoadded
+
   /*fprintf(stderr, "Nsf_NextHashEntry %p expected %d numEntries %d\n",
     tablePtr, expected, tablePtr->numEntries);*/
   if (tablePtr->numEntries < 1) {
@@ -1017,6 +1043,10 @@
 
 void
 NsfRequireObjNamespace(Tcl_Interp *interp, Nsf_Object *object) {
+
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   RequireObjNamespace(interp, (NsfObject *) object);
 }
 
@@ -1059,6 +1089,11 @@
   int result;
   CallFrame frame, *framePtr = &frame;
 
+  assert(object1); // autoadded
+  assert(interp); // autoadded
+  assert(name1); // autoadded
+  assert(name2); // autoadded
+
   Nsf_PushFrameObj(interp, object, framePtr);
   if (object->nsPtr) {
     flags |= TCL_NAMESPACE_ONLY;
@@ -1075,6 +1110,11 @@
   int result;
   ALLOC_ON_STACK(Tcl_Obj *, objc+2, ov);
 
+  assert(interp); // autoadded
+  assert(class); // autoadded
+  assert(nameObj); // autoadded
+  assert(objv); // autoadded
+
   INCR_REF_COUNT2("nameObj", nameObj);
 
   ov[0] = NULL;
@@ -1093,6 +1133,10 @@
 
 int
 NsfDeleteObject(Tcl_Interp *interp, Nsf_Object *object) {
+
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   return DispatchDestroyMethod(interp, (NsfObject *)object, 0);
 }
 
@@ -1185,6 +1229,9 @@
 
 static CONST char *
 NSTail(CONST char *string) {
+
+  assert(string); // autoadded
+
   register char *p = (char *)string+strlen(string);
   while (p > string) {
     if (unlikely(*p == ':' && *(p-1) == ':')) {
@@ -1308,6 +1355,10 @@
 DStringAppendQualName(Tcl_DString *dsPtr, Tcl_Namespace *nsPtr, CONST char *name) {
   int oldLength = Tcl_DStringLength(dsPtr);
 
+  assert(dsPtr); // autoadded
+  assert(nsPtr); // autoadded
+  assert(name); // autoadded
+
   Tcl_DStringAppend(dsPtr, nsPtr->fullName, -1);
   if (Tcl_DStringLength(dsPtr) > (oldLength + 2)) {
     Tcl_DStringAppend(dsPtr, "::", 2);
@@ -1488,6 +1539,9 @@
   int result;
   Tcl_Obj *ov[3];
 
+  assert(interp); // autoadded
+  assert(nameObj); // autoadded
+
   /*fprintf(stderr, "try ::nsf::object::unknown for '%s'\n", ObjStr(nameObj));*/
 
   ov[0] = NsfGlobalObjs[NSF_OBJECT_UNKNOWN_HANDLER];
@@ -1680,6 +1734,12 @@
   NsfClass *cl;
   Tcl_DString ds, *dsPtr = &ds;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+  assert(what); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+
   if (unlikely(pPtr->flags & NSF_ARG_BASECLASS) && !IsBaseClass(object)) {
     what = "baseclass";
     goto type_error;
@@ -1766,6 +1826,9 @@
   int prefixLength = dsPtr->length;
   NsfStringIncrStruct *iss = &RUNTIME_STATE(interp)->iss;
 
+  assert(interp); // autoadded
+  assert(dsPtr); // autoadded
+
   while (1) {
 
     (void)NsfStringIncr(iss);
@@ -1834,6 +1897,8 @@
 NsfClassListFree(NsfClasses *classList) {
   NsfClasses *nextPtr;
 
+  assert(classList); // autoadded
+
   for (; classList; classList = nextPtr) {
     nextPtr = classList->nextPtr;
     FREE(NsfClasses, classList);
@@ -1900,6 +1965,9 @@
 NsfClassListAddNoDup(NsfClasses **firstPtrPtr, NsfClass *cl, ClientData clientData, int *isNewPtr) {
   NsfClasses *clPtr = *firstPtrPtr, **nextPtr;
 
+  assert(firstPtrPtr); // autoadded
+  assert(cl); // autoadded
+
   if (clPtr) {
     for (; clPtr->nextPtr && clPtr->cl != cl; clPtr = clPtr->nextPtr);
     nextPtr = &clPtr->nextPtr;
@@ -2087,6 +2155,9 @@
   NsfClasses *sl = direction == SUPER_CLASSES ? cl->super : cl->sub;
   NsfClasses *pl;
 
+  assert(cl); // autoadded
+  assert(baseClass); // autoadded
+
   /*
    * Be careful to reset the color of unreported classes to
    * white in case we unwind with error, and on final exit
@@ -2417,7 +2488,7 @@
     NsfClassListFree(sl->clientData);
   }
 
-  NsfClassListFree(deletionList);
+  if (deletionList) NsfClassListFree(deletionList);
   NsfClassListFree(superClasses);
 
   return pl;
@@ -2636,7 +2707,7 @@
   if (likely(TopoSort(cl, cl, SUB_CLASSES))) {
     order = cl->order;
   } else {
-    NsfClassListFree(cl->order);
+    if (cl->order) NsfClassListFree(cl->order);
     order = NULL;
   }
 
@@ -2667,7 +2738,7 @@
   assert(clPtr != NULL);
 
   for (; clPtr; clPtr = clPtr->nextPtr) {
-    NsfClassListFree(clPtr->cl->order);
+    if (clPtr->cl->order) NsfClassListFree(clPtr->cl->order);
     clPtr->cl->order = NULL;
   }
 }
@@ -2821,7 +2892,7 @@
 
 /*
  *----------------------------------------------------------------------
- * GetEnsembeObjectFromName --
+ * GetEnsembleObjectFromName --
  *
  *    Get an ensemble object from a method name.  If the method name
  *    is fully qualified, just use a Tcl lookup, otherwise get it from
@@ -2835,15 +2906,21 @@
  *
  *----------------------------------------------------------------------
  */
-static NsfObject * GetEnsembeObjectFromName(Tcl_Interp *interp, Tcl_Namespace *nsPtr, Tcl_Obj *name,
-			 Tcl_Command *cmdPtr, int *fromClassNS) nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(5);
+static NsfObject * GetEnsembleObjectFromName(Tcl_Interp *interp, Tcl_Namespace *nsPtr, Tcl_Obj *name,
+			 Tcl_Command *cmdPtr, int *fromClassNS) 
+  nonnull(1) nonnull(3) nonnull(4) nonnull(5);
 
 static NsfObject *
-GetEnsembeObjectFromName(Tcl_Interp *interp, Tcl_Namespace *nsPtr, Tcl_Obj *name,
+GetEnsembleObjectFromName(Tcl_Interp *interp, Tcl_Namespace *nsPtr, Tcl_Obj *name,
 			 Tcl_Command *cmdPtr, int *fromClassNS) {
   Tcl_Command cmd;
   char *nameString = ObjStr(name);
 
+  assert(interp); // autoadded
+  assert(name); // autoadded
+  assert(cmdPtr); // autoadded
+  assert(fromClassNS); // autoadded
+
   if (*nameString == ':') {
     cmd = Tcl_GetCommandFromObj(interp, name);
     *fromClassNS = IsClassNsName(nameString, NULL);
@@ -2884,6 +2961,10 @@
   CONST char *procName;
   size_t objNameLength;
 
+  assert(interp); // autoadded
+  assert(methodName); // autoadded
+  assert(fromClassNS); // autoadded
+
   assert(methodName && *methodName == ':');
   assert(cmd);
 
@@ -2943,7 +3024,11 @@
   int containsSpace;
   Tcl_Command cmd;
 
+  assert(interp); // autoadded
+  assert(methodObj); // autoadded
+  assert(fromClassNS); // autoadded
 
+
   /*fprintf(stderr,"methodName '%s' comp %d type %s\n",
     methodName, strchr(methodName, ' ')>0, methodObj->typePtr ? methodObj->typePtr->name : "(none)");*/
 
@@ -2981,8 +3066,8 @@
     /*fprintf(stderr, "name '%s' contains space \n", methodName);*/
 
     if ((Tcl_ListObjGetElements(interp, methodObj, &oc, &ov) != TCL_OK)
-	|| ((referencedObject = GetEnsembeObjectFromName(interp, nsPtr, ov[0],
-							 &cmd, fromClassNS)) == NULL)
+	|| ((referencedObject = GetEnsembleObjectFromName(interp, nsPtr, ov[0],
+                                                          &cmd, fromClassNS)) == NULL)
 	) {
       if (methodName1) {*methodName1 = NULL;}
       if (regObject) {*regObject = NULL;}
@@ -3244,6 +3329,10 @@
 static NsfClass *
 SearchPLMethod0(register NsfClasses *pl, CONST char *methodName, Tcl_Command *cmdPtr) {
 
+  assert(pl); // autoadded
+  assert(methodName); // autoadded
+  assert(cmdPtr); // autoadded
+
   /* Search the precedence list (class hierarchy) */
   for (; pl;  pl = pl->nextPtr) {
     register Tcl_HashEntry *entryPtr =
@@ -3471,6 +3560,9 @@
 ObjectSystemFree(Tcl_Interp *interp, NsfObjectSystem *osPtr) {
   int idx;
 
+  assert(interp); // autoadded
+  assert(osPtr); // autoadded
+
   for (idx = 0; idx <= NSF_o_unknown_idx; idx++) {
     if (osPtr->methods[idx]) { DECR_REF_COUNT(osPtr->methods[idx]); }
     if (osPtr->handles[idx]) { DECR_REF_COUNT(osPtr->handles[idx]); }
@@ -3506,6 +3598,10 @@
 
 static void
 ObjectSystemAdd(Tcl_Interp *interp, NsfObjectSystem *osPtr) {
+
+  assert(interp); // autoadded
+  assert(osPtr); // autoadded
+
   osPtr->nextPtr = RUNTIME_STATE(interp)->objectSystems;
   RUNTIME_STATE(interp)->objectSystems = osPtr;
 }
@@ -3643,6 +3739,8 @@
   NsfCmdList *instances = NULL, *entryPtr;
   NsfObjectSystem *osPtr, *nPtr;
 
+  assert(interp); // autoadded
+
   /* Deletion is performed in two rounds:
    *  (a) SOFT DESTROY: invoke all user-defined destroy methods
    *      without destroying objects
@@ -3753,6 +3851,10 @@
   int callDirectly = 1;
   Tcl_Obj *methodObj;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+  assert(methodObjPtr); // autoadded
+
   methodObj = osPtr->methods[methodIdx];
   /*fprintf(stderr, "OS of %s is %s, method %s methodObj %p osPtr %p defined %.8x %.8x overloaded %.8x %.8x flags %.8x\n",
 	  ObjectName(object), ObjectName(&osPtr->rootClass->object),
@@ -3838,6 +3940,9 @@
 
 static NsfObjectOpt *
 NsfRequireObjectOpt(NsfObject *object) {
+
+  assert(object); // autoadded
+
   if (object->opt == NULL) {
     object->opt = NEW(NsfObjectOpt);
     memset(object->opt, 0, sizeof(NsfObjectOpt));
@@ -3866,6 +3971,9 @@
 static void
 MakeObjNamespace(Tcl_Interp *interp, NsfObject *object) {
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
 #ifdef NAMESPACE_TRACE
   fprintf(stderr, "+++ MakeObjNamespace for %s\n", ObjectName(object));
 #endif
@@ -3910,6 +4018,9 @@
   int i, localCt = varFramePtr->numCompiledLocals;
   Tcl_Obj **objPtrPtr = &varFramePtr->localCachePtr->varName0;
 
+  assert(varFramePtr); // autoadded
+  assert(varName); // autoadded
+
   /* fprintf(stderr, ".. search #local vars %d for %s\n", localCt, varName);*/
   for (i = 0 ; i < localCt ; i++, objPtrPtr++) {
     Tcl_Obj *objPtr = *objPtrPtr;
@@ -3944,6 +4055,11 @@
 
 static void
 GetVarAndNameFromHash(Tcl_HashEntry *hPtr, Var **val, Tcl_Obj **varNameObj) {
+
+  assert(hPtr); // autoadded
+  assert(val); // autoadded
+  assert(varNameObj); // autoadded
+
   *val = TclVarHashGetValue(hPtr);
   *varNameObj = TclVarHashGetKey(*val);
 }
@@ -4062,6 +4178,10 @@
   int new, frameFlags;
   Tcl_Obj *key;
 
+  assert(interp); // autoadded
+  assert(varName); // autoadded
+  assert(varPtr); // autoadded
+
 #if defined (VAR_RESOLVER_TRACE)
   fprintf(stderr, "NsColonVarResolver '%s' flags %.6x\n", varName, flags);
 #endif
@@ -4253,6 +4373,9 @@
   Tcl_Var var = resVarInfo->var;
   int new;
 
+  assert(interp); // autoadded
+  assert(vinfoPtr); // autoadded
+
 #if defined(VAR_RESOLVER_TRACE)
   int flags = var ? ((Var *)var)->flags : 0;
   fprintf(stderr,"CompiledColonVarFetch var '%s' var %p flags = %.4x dead? %.4x\n",
@@ -4352,6 +4475,8 @@
 CompiledColonVarFree(Tcl_ResolvedVarInfo *vInfoPtr) {
   NsfResolvedVarInfo *resVarInfo = (NsfResolvedVarInfo *)vInfoPtr;
 
+  assert(vInfoPtr); // autoadded
+
 #if defined(VAR_RESOLVER_TRACE)
   fprintf(stderr, "CompiledColonVarFree %p for variable '%s'\n",
 	  resVarInfo, ObjStr(resVarInfo->nameObj));
@@ -4407,6 +4532,10 @@
    */
   NsfObject *object = GetSelfObj(interp);
 
+  assert(interp); // autoadded
+  assert(name); // autoadded
+  assert(rPtr); // autoadded
+
 #if defined(VAR_RESOLVER_TRACE)
   fprintf(stderr, "compiled var resolver for %s, obj %p\n", name, object);
 #endif
@@ -4519,6 +4648,10 @@
   Tcl_Obj *keyObj;
   Tcl_Var var;
 
+  assert(interp); // autoadded
+  assert(varName); // autoadded
+  assert(varPtr); // autoadded
+
   /*
    * TCL_GLOBAL_ONLY is removed, since "vwait :varName" is called with
    * with this flag.
@@ -4677,6 +4810,10 @@
   CallFrame *varFramePtr;
   int frameFlags;
 
+  assert(interp); // autoadded
+  assert(cmdName); // autoadded
+  assert(cmdPtr); // autoadded
+
   /* fprintf(stderr, "InterpColonCmdResolver %s flags %.6x\n", cmdName, flags); */
 
   if (likely((*cmdName == ':' && *(cmdName + 1) == ':') || flags & TCL_GLOBAL_ONLY)) {
@@ -4883,6 +5020,10 @@
 SlotContainerCmdResolver(Tcl_Interp *interp, CONST char *cmdName,
 			 Tcl_Namespace *nsPtr, int flags, Tcl_Command *cmdPtr) {
 
+  assert(cmdName); // autoadded
+  assert(nsPtr); // autoadded
+  assert(cmdPtr); // autoadded
+
   if (*cmdName == ':' || (flags & TCL_GLOBAL_ONLY)) {
     /* colon names (InterpColonCmdResolver) and global lookups are not for us */
     return TCL_CONTINUE;
@@ -5057,6 +5198,8 @@
 static int
 NSDeleteChild(Tcl_Interp *interp, Tcl_Command cmd, int deleteObjectsOnly) {
 
+  assert(interp); // autoadded
+
   /*fprintf(stderr, "NSDeleteChildren child %p flags %.6x epoch %d\n",
 	  cmd, Tcl_Command_flags(cmd), Tcl_Command_cmdEpoch(cmd));*/
 
@@ -5149,6 +5292,9 @@
   Tcl_HashEntry *hPtr;
   int expected;
 
+  assert(interp); // autoadded
+  assert(nsPtr); // autoadded
+
 #ifdef OBJDELETION_TRACE
   fprintf(stderr, "NSDeleteChildren %p %s activationCount %d\n",
 	  nsPtr, nsPtr->fullName, Tcl_Namespace_activationCount(nsPtr));
@@ -5214,6 +5360,9 @@
   Tcl_HashSearch hSrch;
   Tcl_HashEntry *hPtr;
 
+  assert(interp); // autoadded
+  assert(nsPtr); // autoadded
+
 #ifdef OBJDELETION_TRACE
   fprintf(stderr, "NSCleanupNamespace %p flags %.6x\n", nsPtr, Tcl_Namespace_flags(nsPtr));
   fprintf(stderr, "NSCleanupNamespace %p %.6x varTablePtr %p\n", nsPtr, ((Namespace *)nsPtr)->flags, varTablePtr);
@@ -5279,6 +5428,9 @@
   int activationCount = 0;
   Tcl_CallFrame *f = (Tcl_CallFrame *)Tcl_Interp_framePtr(interp);
 
+  assert(interp); // autoadded
+  assert(nsPtr); // autoadded
+
   /*fprintf(stderr, "Nsf_DeleteNamespace %p ", nsPtr);*/
 
   while (f) {
@@ -5418,6 +5570,9 @@
 NSRequireParentObject(Tcl_Interp *interp, CONST char *parentName) {
   int result;
 
+  assert(interp); // autoadded
+  assert(parentName); // autoadded
+
   result = NsfCallObjectUnknownHandler(interp, Tcl_NewStringObj(parentName, -1));
 
   if (result == TCL_OK) {
@@ -5458,7 +5613,8 @@
  *
  *----------------------------------------------------------------------
  */
-NSF_INLINE static Tcl_Namespace * NSCheckNamespace(Tcl_Interp *interp, CONST char *nameString, Tcl_Namespace *parentNsPtr1) nonnull(1) nonnull(2) nonnull(3);
+NSF_INLINE static Tcl_Namespace *NSCheckNamespace(Tcl_Interp *interp, CONST char *nameString, Tcl_Namespace *parentNsPtr1) 
+  nonnull(1) nonnull(2);
 
 NSF_INLINE static Tcl_Namespace *
 NSCheckNamespace(Tcl_Interp *interp, CONST char *nameString, Tcl_Namespace *parentNsPtr1) {
@@ -5912,6 +6068,10 @@
   int flogs = TCL_LEAVE_ERR_MSG;
   CallFrame frame, *framePtr = &frame;
 
+  assert(interp); // autoadded
+  assert(nameObj); // autoadded
+  assert(object); // autoadded
+
   Nsf_PushFrameObj(interp, object, framePtr);
   if (object->nsPtr) {
     flogs |= TCL_NAMESPACE_ONLY;
@@ -6138,6 +6298,8 @@
 CmdListAdd(NsfCmdList **cList, Tcl_Command c, NsfClass *clorobj, int noDuplicates, int atEnd) {
   NsfCmdList *l, *nextPtr, *new;
 
+  assert(cList); // autoadded
+
   if (unlikely(atEnd)) {
     l = *cList;
     nextPtr = NULL;
@@ -6217,6 +6379,8 @@
 CmdListAddSorted(NsfCmdList **cList, Tcl_Command c, NsfClass *clorobj) {
   NsfCmdList *prev, *new, *h;
 
+  assert(cList); // autoadded
+
   for (h = *cList, prev = NULL; h; prev = h, h = h->nextPtr) {
     if (h->cmdPtr == c) {
       return h;
@@ -6279,6 +6443,9 @@
 
 static void
 CmdListDeleteCmdListEntry(NsfCmdList *del, NsfFreeCmdListClientData *freeFct) {
+
+  assert(del); // autoadded
+
   if (unlikely(freeFct != NULL)) {
     (*freeFct)(del);
   }
@@ -6297,6 +6464,8 @@
 CmdListRemoveFromList(NsfCmdList **cmdList, NsfCmdList *delCL) {
   register NsfCmdList *c = *cmdList, *del = NULL;
 
+  assert(cmdList); // autoadded
+
   assert(delCL);
 
   if (c == NULL) {
@@ -6340,6 +6509,10 @@
 
 static void
 CmdListRemoveDeleted(NsfCmdList **cmdList, NsfFreeCmdListClientData *freeFct) {
+
+  assert(cmdList); // autoadded
+  assert(freeFct); // autoadded
+
   NsfCmdList *f = *cmdList, *del;
   while (f) {
     /*
@@ -6382,6 +6555,10 @@
     c = *cmdList;
   }
 
+  assert(cmdList); // autoadded
+  assert(clorobj); // autoadded
+  assert(freeFct); // autoadded
+
   while (c) {
     if (c->clorobj == clorobj) {
       del = c;
@@ -6421,6 +6598,9 @@
 
 static NsfCmdList *
 CmdListFindCmdInList(Tcl_Command cmd, NsfCmdList *l) {
+
+  assert(l); // autoadded
+
   register NsfCmdList *h;
   for (h = l; h; h = h->nextPtr) {
     if (h->cmdPtr == cmd) return h;
@@ -6436,6 +6616,11 @@
 
 static NsfCmdList *
 CmdListFindNameInList(Tcl_Interp *interp, CONST char *name, NsfCmdList *l) {
+
+  assert(interp); // autoadded
+  assert(name); // autoadded
+  assert(l); // autoadded
+
   register NsfCmdList *h;
   for (h = l; h; h = h->nextPtr) {
     CONST char *cmdName = Tcl_GetCommandName(interp, h->cmdPtr);
@@ -6466,6 +6651,9 @@
   int result, success;
   Tcl_Obj *ov[2] = {NULL, condition};
 
+  assert(interp); // autoadded
+  assert(condition); // autoadded
+
   INCR_REF_COUNT(condition);
   result = Nsf_ExprObjCmd(NULL, interp, 2, ov);
   DECR_REF_COUNT(condition);
@@ -6501,6 +6689,9 @@
 
 static void
 TclObjListFreeList(NsfTclObjList *list) {
+
+  assert(list); // autoadded
+
   while (list) {
     NsfTclObjList *del = list;
     list = list->nextPtr;
@@ -6529,6 +6720,10 @@
 
 static Tcl_Obj *
 TclObjListNewElement(NsfTclObjList **list, Tcl_Obj *obj, Tcl_Obj *value) {
+
+  assert(list); // autoadded
+  assert(obj); // autoadded
+
   NsfTclObjList *elt = NEW(NsfTclObjList);
   INCR_REF_COUNT2("listContent", obj);
   elt->content = obj;
@@ -6564,6 +6759,11 @@
   NsfTclObjList *elt, **prevPtr;
   CONST char *keyString = ObjStr(key);
 
+  assert(interp); // autoadded
+  assert(list); // autoadded
+  assert(key); // autoadded
+  assert(value); // autoadded
+
   for (elt = *list, prevPtr = list; elt; prevPtr = &elt->nextPtr, elt = elt->nextPtr) {
     CONST char *eltString = ObjStr(elt->content);
     if (key == elt->content || strcmp(keyString, eltString) == 0) {
@@ -6599,7 +6799,7 @@
  * Assertions
  **********************************************************************/
 
-static NsfTclObjList * AssertionNewList(Tcl_Interp *interp, Tcl_Obj *aObj) nonnull(1) nonnull(2);
+static NsfTclObjList * AssertionNewList(Tcl_Interp *interp, Tcl_Obj *aObj) nonnull(1);
 
 static NsfTclObjList *
 AssertionNewList(Tcl_Interp *interp, Tcl_Obj *aObj) {
@@ -6671,8 +6871,8 @@
     if (hPtr) {
       NsfProcAssertion *procAss =
         (NsfProcAssertion *) Tcl_GetHashValue(hPtr);
-      TclObjListFreeList(procAss->pre);
-      TclObjListFreeList(procAss->post);
+      if (procAss->pre)  TclObjListFreeList(procAss->pre);
+      if (procAss->post) TclObjListFreeList(procAss->post);
       FREE(NsfProcAssertion, procAss);
       Tcl_DeleteHashEntry(hPtr);
     }
@@ -6726,7 +6926,7 @@
     }
     Tcl_DeleteHashTable(&aStore->procs);
     MEM_COUNT_FREE("Tcl_InitHashTable", &aStore->procs);
-    TclObjListFreeList(aStore->invariants);
+    if (aStore->invariants) TclObjListFreeList(aStore->invariants);
     FREE(NsfAssertionStore, aStore);
   }
 }
@@ -6968,6 +7168,8 @@
 MixinStackPush(NsfObject *object) {
   register NsfMixinStack *h = NEW(NsfMixinStack);
 
+  assert(object); // autoadded
+
   h->currentCmdPtr = NULL;
   h->nextPtr = object->mixinStack;
   object->mixinStack = h;
@@ -6982,6 +7184,9 @@
 
 static void
 MixinStackPop(NsfObject *object) {
+
+  assert(object); // autoadded
+
   register NsfMixinStack *h = object->mixinStack;
   /*fprintf(stderr, "MixinStackPop %p %s\n", object, ObjectName(object));*/
   object->mixinStack = h->nextPtr;
@@ -7003,6 +7208,11 @@
   NsfCmdList *m;
   NsfClasses *pl, **clPtr = mixinClasses;
 
+  assert(interp); // autoadded
+  assert(mixinList); // autoadded
+  assert(mixinClasses); // autoadded
+  assert(checkList); // autoadded
+
   CmdListRemoveDeleted(mixinList, GuardDel);
 
   for (m = *mixinList; m; m = m->nextPtr) {
@@ -7061,6 +7271,9 @@
 
 static void
 MixinResetOrder(NsfObject *object) {
+
+  assert(object); // autoadded
+
   /*fprintf(stderr, "MixinResetOrder for object %s \n", ObjectName(object));*/
   CmdListFree(&object->mixinOrder, NULL /*GuardDel*/);
   object->mixinOrder = NULL;
@@ -7089,6 +7302,11 @@
 			      NsfClasses **classList, NsfClasses **checkList) {
   NsfClasses *pl;
 
+  assert(interp); // autoadded
+  assert(cl); // autoadded
+  assert(classList); // autoadded
+  assert(checkList); // autoadded
+
   for (pl = PrecedenceOrder(cl); pl; pl = pl->nextPtr) {
     NsfClassOpt *clopt = pl->cl->opt;
     if (clopt && clopt->classMixins) {
@@ -7120,6 +7338,9 @@
 MixinComputeOrder(Tcl_Interp *interp, NsfObject *object) {
   NsfClasses *fullList, *checkList = NULL, *mixinClasses = NULL, *clPtr;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   if (object->mixinOrder) {
     MixinResetOrder(object);
   }
@@ -7155,7 +7376,9 @@
   NsfClassListPrint("MixinComputeOrder poms+pcms", mixinClasses);
   CmdListPrint(interp, "mixinOrder", object->mixinOrder);*/
 
-  NsfClassListFree(checkList);
+  if (checkList) {
+    NsfClassListFree(checkList);
+  }
 
   fullList = mixinClasses;
 
@@ -7205,7 +7428,9 @@
   }
 
   /* ... and free the memory of the full list */
-  NsfClassListFree(fullList);
+  if (fullList) {
+    NsfClassListFree(fullList);
+  }
 
   /*CmdListPrint(interp, "mixin order\n", obj->mixinOrder);*/
 }
@@ -7234,6 +7459,11 @@
   Tcl_Obj *guardObj;
   NsfCmdList *new;
 
+  assert(interp); // autoadded
+  assert(mixinList); // autoadded
+  assert(nameObj); // autoadded
+  assert(baseClass); // autoadded
+
   /*fprintf(stderr, "MixinAdd gets obj %p type %p %s\n", nameObj, nameObj->typePtr,
     nameObj->typePtr?nameObj->typePtr->name : "NULL");*/
   /*
@@ -7273,10 +7503,16 @@
  *
  *----------------------------------------------------------------------
  */
-static void AppendMatchingElement(Tcl_Interp *interp, Tcl_Obj *resultObj, Tcl_Obj *nameObj, CONST char *pattern) nonnull(1) nonnull(2) nonnull(3) nonnull(4);
+static void AppendMatchingElement(Tcl_Interp *interp, Tcl_Obj *resultObj, Tcl_Obj *nameObj, CONST char *pattern) 
+  nonnull(1) nonnull(2) nonnull(3);
 
 static void
 AppendMatchingElement(Tcl_Interp *interp, Tcl_Obj *resultObj, Tcl_Obj *nameObj, CONST char *pattern) {
+
+  assert(interp); // autoadded
+  assert(resultObj); // autoadded
+  assert(nameObj); // autoadded
+
   if (pattern == NULL || Tcl_StringMatch( ObjStr(nameObj), pattern)) {
     Tcl_ListObjAppendElement(interp, resultObj, nameObj);
   }
@@ -7299,14 +7535,19 @@
  */
 static int AppendMatchingElementsFromCmdList(Tcl_Interp *interp, NsfCmdList *cmdl,
 				  Tcl_Obj *resultObj,
-                                  CONST char *pattern, NsfObject *matchObject) nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(5);
+                                  CONST char *pattern, NsfObject *matchObject) 
+  nonnull(1) nonnull(2) nonnull(3);
 
 static int
 AppendMatchingElementsFromCmdList(Tcl_Interp *interp, NsfCmdList *cmdl,
 				  Tcl_Obj *resultObj,
                                   CONST char *pattern, NsfObject *matchObject) {
   int rc = 0;
 
+  assert(interp); // autoadded
+  assert(cmdl); // autoadded
+  assert(resultObj); // autoadded
+
   for ( ; cmdl; cmdl = cmdl->nextPtr) {
     NsfObject *object = NsfGetObjectFromCmdPtr(cmdl->cmdPtr);
     if (object) {
@@ -7337,14 +7578,16 @@
  */
 static int AppendMatchingElementsFromClasses(Tcl_Interp *interp, NsfClasses *cls,
                                              CONST char *pattern, NsfObject *matchObject) 
-  nonnull(1) nonnull(3) nonnull(4);
+  nonnull(1);
 
 static int
 AppendMatchingElementsFromClasses(Tcl_Interp *interp, NsfClasses *cls,
 				  CONST char *pattern, NsfObject *matchObject) {
   int rc = 0;
   Tcl_Obj *resultObj = Tcl_GetObjResult(interp);
 
+  assert(interp); // autoadded
+
   for ( ; cls; cls = cls->nextPtr) {
     NsfObject *object = (NsfObject *)cls->cl;
     if (object) {
@@ -7439,7 +7682,7 @@
     }
   }
 
-  NsfClassListFree(subClasses);
+  if (subClasses) NsfClassListFree(subClasses);
 }
 
 /*
@@ -7459,12 +7702,20 @@
  */
 static int AddToResultSet(Tcl_Interp *interp, Tcl_HashTable *destTablePtr,
 	       Tcl_Obj *resultSet, NsfObject *object, int *new,
-	       int appendResult, CONST char *pattern, NsfObject *matchObject) nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(5) nonnull(7) nonnull(8);
+	       int appendResult, CONST char *pattern, NsfObject *matchObject) 
+  nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(5);
 
 static int
 AddToResultSet(Tcl_Interp *interp, Tcl_HashTable *destTablePtr,
 	       Tcl_Obj *resultSet, NsfObject *object, int *new,
 	       int appendResult, CONST char *pattern, NsfObject *matchObject) {
+
+  assert(interp); // autoadded
+  assert(destTablePtr); // autoadded
+  assert(resultSet); // autoadded
+  assert(object); // autoadded
+  assert(new); // autoadded
+
   Tcl_CreateHashEntry(destTablePtr, (char *)object, new);
   if (*new) {
     if (matchObject && matchObject == object) {
@@ -7496,14 +7747,20 @@
 static int AddToResultSetWithGuards(Tcl_Interp *interp, Tcl_HashTable *destTablePtr,
 			 Tcl_Obj *resultSet, NsfClass *cl,
 			 ClientData clientData, int *new, int appendResult,
-			 CONST char *pattern, NsfObject *matchObject) nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(6) nonnull(8) nonnull(9);
+			 CONST char *pattern, NsfObject *matchObject) 
+  nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(6);
 
 static int
 AddToResultSetWithGuards(Tcl_Interp *interp, Tcl_HashTable *destTablePtr,
 			 Tcl_Obj *resultSet, NsfClass *cl,
 			 ClientData clientData, int *new, int appendResult,
 			 CONST char *pattern, NsfObject *matchObject) {
 
+  assert(interp); // autoadded
+  assert(destTablePtr); // autoadded
+  assert(resultSet); // autoadded
+  assert(new); // autoadded
+
   assert(cl);
 
   Tcl_CreateHashEntry(destTablePtr, (char *)cl, new);
@@ -7548,7 +7805,8 @@
  */
 static int GetAllObjectMixinsOf(Tcl_Interp *interp, Tcl_HashTable *destTablePtr,
 		     Tcl_Obj *resultSet, NsfClass *startCl, int isMixin,
-		     int appendResult, CONST char *pattern, NsfObject *matchObject) nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(7) nonnull(8);
+		     int appendResult, CONST char *pattern, NsfObject *matchObject) 
+  nonnull(1) nonnull(2) nonnull(3) nonnull(4);
 
 static int
 GetAllObjectMixinsOf(Tcl_Interp *interp, Tcl_HashTable *destTablePtr,
@@ -7557,6 +7815,11 @@
   int rc = 0, new = 0;
   NsfClasses *sc;
 
+  assert(interp); // autoadded
+  assert(destTablePtr); // autoadded
+  assert(resultSet); // autoadded
+  assert(startCl); // autoadded
+
   /*fprintf(stderr, "startCl = %s, opt %p, isMixin %d, pattern '%s', matchObject %p\n",
     ClassName(startCl), startCl->opt, isMixin, pattern, matchObject);*/
 
@@ -7649,6 +7912,10 @@
   NsfClass *cl;
   NsfClasses *sc;
 
+  assert(interp); // autoadded
+  assert(destTablePtr); // autoadded
+  assert(resultSet); // autoadded
+
   assert(startCl);
 
   /*fprintf(stderr, "startCl = %p %s, opt %p, isMixin %d\n",
@@ -7738,7 +8005,8 @@
 
 static int GetAllClassMixins(Tcl_Interp *interp, Tcl_HashTable *destTablePtr,
 		  Tcl_Obj *resultObj, NsfClass *startCl,
-		  int withGuards, CONST char *pattern, NsfObject *matchObject) nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(6) nonnull(7);
+		  int withGuards, CONST char *pattern, NsfObject *matchObject) 
+  nonnull(1) nonnull(2) nonnull(3) nonnull(4);
 
 static int
 GetAllClassMixins(Tcl_Interp *interp, Tcl_HashTable *destTablePtr,
@@ -7748,6 +8016,11 @@
   NsfClass *cl;
   NsfClasses *sc;
 
+  assert(interp); // autoadded
+  assert(destTablePtr); // autoadded
+  assert(resultObj); // autoadded
+  assert(startCl); // autoadded
+
   /*
    * check this class for class mixins.
    */
@@ -7819,11 +8092,14 @@
  *----------------------------------------------------------------------
  */
 
-static void RemoveFromClassMixinsOf(Tcl_Command cmd, NsfCmdList *cmdlist) nonnull(2);
+static void RemoveFromClassMixinsOf(Tcl_Command cmd, NsfCmdList *cmdlist) nonnull(1) nonnull(2);
 
 static void
 RemoveFromClassMixinsOf(Tcl_Command cmd, NsfCmdList *cmdlist) {
 
+  assert(cmd);
+  assert(cmdlist);
+
   for ( ; cmdlist; cmdlist = cmdlist->nextPtr) {
     NsfClass *ncl = NsfGetClassFromCmdPtr(cmdlist->cmdPtr);
     NsfClassOpt *nclopt = ncl ? ncl->opt : NULL;
@@ -7855,10 +8131,14 @@
  *----------------------------------------------------------------------
  */
 
-static void RemoveFromObjectMixinsOf(Tcl_Command cmd, NsfCmdList *cmdlist) nonnull(2);
+static void RemoveFromObjectMixinsOf(Tcl_Command cmd, NsfCmdList *cmdlist) nonnull(1) nonnull(2);
 
 static void
 RemoveFromObjectMixinsOf(Tcl_Command cmd, NsfCmdList *cmdlist) {
+
+  assert(cmd); 
+  assert(cmdlist); // autoadded
+
   for ( ; cmdlist; cmdlist = cmdlist->nextPtr) {
     NsfClass *cl = NsfGetClassFromCmdPtr(cmdlist->cmdPtr);
     NsfClassOpt *clopt = cl ? cl->opt : NULL;
@@ -7890,10 +8170,14 @@
  *----------------------------------------------------------------------
  */
 
-static void RemoveFromClassmixins(Tcl_Command cmd, NsfCmdList *cmdlist) nonnull(2);
+static void RemoveFromClassmixins(Tcl_Command cmd, NsfCmdList *cmdlist) nonnull(1) nonnull(2);
 
 static void
 RemoveFromClassmixins(Tcl_Command cmd, NsfCmdList *cmdlist) {
+
+  assert(cmd); 
+  assert(cmdlist); // autoadded
+
   for ( ; cmdlist; cmdlist = cmdlist->nextPtr) {
     NsfClass *cl = NsfGetClassFromCmdPtr(cmdlist->cmdPtr);
     NsfClassOpt *clopt = cl ? cl->opt : NULL;
@@ -7925,10 +8209,14 @@
  *
  *----------------------------------------------------------------------
  */
-static void RemoveFromObjectMixins(Tcl_Command cmd, NsfCmdList *cmdlist) nonnull(2);
+static void RemoveFromObjectMixins(Tcl_Command cmd, NsfCmdList *cmdlist) nonnull(1) nonnull(2);
 
 static void
 RemoveFromObjectMixins(Tcl_Command cmd, NsfCmdList *cmdlist) {
+
+  assert(cmd);
+  assert(cmdlist); // autoadded
+
   for ( ; cmdlist; cmdlist = cmdlist->nextPtr) {
     NsfObject *nobj = NsfGetObjectFromCmdPtr(cmdlist->cmdPtr);
     NsfObjectOpt *objopt = nobj ? nobj->opt : NULL;
@@ -7969,6 +8257,8 @@
   Tcl_HashSearch hSrch;
   Tcl_HashEntry *hPtr;
 
+  assert(cl); // autoadded
+
   /*fprintf(stderr, "invalidating instances of class %s\n", ClassName(clPtr->cl));*/
 
   /* Here we should check, whether this class is used as an object or
@@ -8009,6 +8299,8 @@
   /*fprintf(stderr, "ResetOrderOfClassesUsedAsMixins %s - %p\n",
     ClassName(cl), cl->opt);*/
 
+  assert(cl); // autoadded
+
   if (cl->opt) {
     NsfCmdList *ml;
     for (ml = cl->opt->isObjectMixinOf; ml; ml = ml->nextPtr) {
@@ -8048,6 +8340,10 @@
   Tcl_HashEntry *hPtr;
   Tcl_HashTable objTable, *commandTable = &objTable;
 
+  assert(interp); // autoadded
+  assert(cl); // autoadded
+  assert(subClasses); // autoadded
+
   /*
    * Iterate over the subclass hierarchy.
    */
@@ -8158,14 +8454,17 @@
 
 static NsfClasses *ComputePrecedenceList(Tcl_Interp *interp, NsfObject *object,
                                          CONST char *pattern, int withMixins, int withRootClass) 
-  nonnull(1) nonnull(2);
+  nonnull(1) nonnull(2) returns_nonnull;
 
 static NsfClasses *
 ComputePrecedenceList(Tcl_Interp *interp, NsfObject *object,
 		      CONST char *pattern,
 		      int withMixins, int withRootClass) {
   NsfClasses *precedenceList = NULL, *pcl, **npl = &precedenceList;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   if (withMixins) {
     if (!(object->flags & NSF_MIXIN_ORDER_VALID)) {
       MixinComputeDefined(interp, object);
@@ -8213,7 +8512,7 @@
  *
  *----------------------------------------------------------------------
  */
-static NsfCmdList * SeekCurrent(Tcl_Command cmd, register NsfCmdList *cmdListPtr) nonnull(2);
+static NsfCmdList * SeekCurrent(Tcl_Command cmd, register NsfCmdList *cmdListPtr);
 
 static NsfCmdList *
 SeekCurrent(Tcl_Command cmd, register NsfCmdList *cmdListPtr) {
@@ -8300,6 +8599,11 @@
   NsfClass *cl = NULL;
   int result = TCL_OK;
 
+  assert(interp); // autoadded
+  assert(clPtr); // autoadded
+  assert(currentCmdPtr); // autoadded
+  assert(cmdPtr); // autoadded
+
   assert(object);
   assert(object->mixinStack);
   assert(methodName);
@@ -8423,13 +8727,15 @@
  */
 static int MixinInfo(Tcl_Interp *interp, NsfCmdList *m, CONST char *pattern,
                      int withGuards, NsfObject *matchObject) 
-  nonnull(1) nonnull(2);
+  nonnull(1);
 
 static int
 MixinInfo(Tcl_Interp *interp, NsfCmdList *m, CONST char *pattern,
           int withGuards, NsfObject *matchObject) {
   Tcl_Obj *list = Tcl_NewListObj(0, NULL);
 
+  assert(interp); // autoadded
+
   /*fprintf(stderr, "   mixin info m=%p, pattern %s, matchObject %p\n",
     m, pattern, matchObject);*/
 
@@ -8472,6 +8778,10 @@
 MixinSearchMethodByName(NsfCmdList *mixinList, CONST char *name, NsfClass **cl) {
   Tcl_Command cmd;
 
+  assert(mixinList); // autoadded
+  assert(name); // autoadded
+  assert(cl); // autoadded
+
   for (; mixinList;  mixinList = mixinList->nextPtr) {
     NsfClass *foundCl = NsfGetClassFromCmdPtr(mixinList->cmdPtr);
     if (foundCl && SearchCMethod(foundCl, name, &cmd)) {
@@ -8496,13 +8806,17 @@
  */
 
 static Tcl_Command FilterSearch(CONST char *name, NsfObject *startingObject,
-             NsfClass *startingClass, NsfClass **cl) nonnull(1) nonnull(2) nonnull(3) nonnull(4);
+             NsfClass *startingClass, NsfClass **cl) 
+  nonnull(1) nonnull(4);
 
 static Tcl_Command
 FilterSearch(CONST char *name, NsfObject *startingObject,
              NsfClass *startingClass, NsfClass **cl) {
   Tcl_Command cmd = NULL;
 
+  assert(name); // autoadded
+  assert(cl); // autoadded
+
   if (startingObject) {
     NsfObjectOpt *opt = startingObject->opt;
     /*
@@ -8571,6 +8885,9 @@
 GuardCheck(Tcl_Interp *interp, Tcl_Obj *guardObj) {
   NsfRuntimeState *rst = RUNTIME_STATE(interp);
 
+  assert(interp); // autoadded
+  assert(guardObj); // autoadded
+
   if (guardObj) {
     int result;
     /*
@@ -8694,6 +9011,9 @@
   if (interceptorDefList) {
     NsfCmdList *h = CmdListFindCmdInList(interceptorCmd, interceptorDefList);
 
+  assert(dest); // autoadded
+  assert(interceptorDefList); // autoadded
+
     if (h) {
       GuardAdd(dest, (Tcl_Obj *) h->clientData);
       /*
@@ -8718,6 +9038,10 @@
   int guardAdded = 0;
   NsfObjectOpt *opt;
 
+  assert(interp); // autoadded
+  assert(dest); // autoadded
+  assert(object); // autoadded
+
   /* search guards for class filters registered on mixins */
   if (!(object->flags & NSF_MIXIN_ORDER_VALID)) {
     MixinComputeDefined(interp, object);
@@ -8775,6 +9099,11 @@
 
 static int
 GuardList(Tcl_Interp *interp, NsfCmdList *frl, CONST char *interceptorName) {
+
+  assert(interp); // autoadded
+  assert(frl); // autoadded
+  assert(interceptorName); // autoadded
+
   if (frl) {
     /* try to find simple name first */
     NsfCmdList *h = CmdListFindNameInList(interp, interceptorName, frl);
@@ -8822,6 +9151,9 @@
   Tcl_HashEntry *hPtr;
   int newItem;
 
+  assert(interp); // autoadded
+  assert(methodName); // autoadded
+
   hPtr = Tcl_CreateHashEntry(&rst->activeFilterTablePtr, methodName, &newItem);
   if (newItem) {
     Tcl_SetHashValue(hPtr, INT2PTR(1));
@@ -8853,6 +9185,9 @@
   NsfRuntimeState *rst = RUNTIME_STATE(interp);
   Tcl_HashEntry *hPtr;
 
+  assert(interp); // autoadded
+  assert(methodName); // autoadded
+
   hPtr = Tcl_CreateHashEntry(&rst->activeFilterTablePtr, methodName, NULL);
   return (hPtr != NULL);
 }
@@ -8877,6 +9212,8 @@
 FiltersDefined(Tcl_Interp *interp) {
   NsfRuntimeState *rst = RUNTIME_STATE(interp);
 
+  assert(interp); // autoadded
+
   return Tcl_HashSize(&rst->activeFilterTablePtr);
 }
 
@@ -8896,6 +9233,10 @@
   NsfCmdList *new;
   NsfClass *cl;
 
+  assert(interp); // autoadded
+  assert(filterList); // autoadded
+  assert(filterregObj); // autoadded
+
   /*
    * When the provided nameObj is of type NsfFilterregObjType, the nsf specific
    * converter was called already; otherwise call the converter here.
@@ -8942,6 +9283,9 @@
 
 static void
 FilterResetOrder(NsfObject *object) {
+
+  assert(object); // autoadded
+
   CmdListFree(&object->filterOrder, GuardDel);
   object->filterOrder = NULL;
 }
@@ -8960,6 +9304,9 @@
   NsfCmdList *cmdList, *del;
   NsfClass *cl = NULL;
 
+  assert(interp); // autoadded
+  assert(filters); // autoadded
+
   CmdListRemoveDeleted(filters, GuardDel);
   for (cmdList = *filters; cmdList; ) {
     char *simpleName = (char *) Tcl_GetCommandName(interp, cmdList->cmdPtr);
@@ -8988,12 +9335,17 @@
  * invalidate filter entries in all dependent instances
  *
  */
-static void FilterInvalidateObjOrders(Tcl_Interp *interp, NsfClass *cl, NsfClasses *subClasses) nonnull(1) nonnull(2) nonnull(3);
+static void FilterInvalidateObjOrders(Tcl_Interp *interp, NsfClass *cl, NsfClasses *subClasses) 
+  nonnull(1) nonnull(2) nonnull(3);
 
 static void
 FilterInvalidateObjOrders(Tcl_Interp *interp, NsfClass *cl, NsfClasses *subClasses) {
   NsfClasses *clPtr;
 
+  assert(interp); // autoadded
+  assert(cl); // autoadded
+  assert(subClasses); // autoadded
+
   for (clPtr = subClasses; clPtr; clPtr = clPtr->nextPtr) {
     Tcl_HashSearch hSrch;
     Tcl_HashEntry *hPtr;
@@ -9032,6 +9384,10 @@
 FilterRemoveDependentFilterCmds(NsfClass *cl, NsfClass *removeClass, NsfClasses *subClasses) {
   NsfClasses *clPtr;
 
+  assert(cl); // autoadded
+  assert(removeClass); // autoadded
+  assert(subClasses); // autoadded
+
   /*fprintf(stderr, "FilterRemoveDependentFilterCmds cl %p %s, removeClass %p %s\n",
     cl, ClassName(cl), removeClass, ObjStr(removeClass->object.cmdName));*/
 
@@ -9077,6 +9433,8 @@
 MethodHandleObj(NsfObject *object, int withPer_object, CONST char *methodName) {
   Tcl_Obj *resultObj;
 
+  assert(methodName); // autoadded
+
   assert(object);
   assert(*methodName != ':');
 
@@ -9093,13 +9451,15 @@
  * withMethodHandles -> if not 0 => return method handles
  */
 static int FilterInfo(Tcl_Interp *interp, NsfCmdList *f, CONST char *pattern,
-           int withGuards, int withMethodHandles) nonnull(1) nonnull(2);
+           int withGuards, int withMethodHandles) nonnull(1);
 
 static int
 FilterInfo(Tcl_Interp *interp, NsfCmdList *f, CONST char *pattern,
            int withGuards, int withMethodHandles) {
   Tcl_Obj *list = Tcl_NewListObj(0, NULL);
 
+  assert(interp); // autoadded
+
   /*fprintf(stderr, "FilterInfo %p %s %d %d\n", pattern, pattern,
     withGuards, withMethodHandles);*/
   /*
@@ -9155,6 +9515,10 @@
   NsfClass *fcl;
   NsfClasses *pl;
 
+  assert(interp); // autoadded
+  assert(filters); // autoadded
+  assert(filterList); // autoadded
+
   /*
    * Ensure that no epoched command is in the filters list.
    */
@@ -9205,6 +9569,9 @@
   NsfCmdList *filterList = NULL, *next, *checker, *newList;
   NsfClasses *pl;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   if (object->filterOrder) FilterResetOrder(object);
   /*
     fprintf(stderr, "<Filter Order obj=%s> List: ", ObjectName(object));
@@ -9312,6 +9679,9 @@
 FilterStackPush(NsfObject *object, Tcl_Obj *calledProc) {
   register NsfFilterStack *h = NEW(NsfFilterStack);
 
+  assert(object); // autoadded
+  assert(calledProc); // autoadded
+
   h->currentCmdPtr = NULL;
   h->calledProc = calledProc;
   INCR_REF_COUNT(h->calledProc);
@@ -9330,6 +9700,8 @@
   register NsfFilterStack *h = object->filterStack;
   object->filterStack = h->nextPtr;
 
+  assert(object); // autoadded
+
   /* free stack entry */
   DECR_REF_COUNT(h->calledProc);
   FREE(NsfFilterStack, h);
@@ -9351,8 +9723,12 @@
   Tcl_Obj *list = Tcl_NewListObj(0, NULL);
   NsfClasses *pl;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   /* search per-object filters */
-  if (object->opt && CmdListFindCmdInList(cmd, object->opt->objFilters)) {
+  if (object->opt && object->opt->objFilters &&
+      CmdListFindCmdInList(cmd, object->opt->objFilters)) {
     Tcl_ListObjAppendElement(interp, list, object->cmdName);
     Tcl_ListObjAppendElement(interp, list, NsfGlobalObjs[NSF_OBJECT]);
     Tcl_ListObjAppendElement(interp, list, NsfGlobalObjs[NSF_FILTER]);
@@ -9389,6 +9765,10 @@
                  Tcl_Command *currentCmd, NsfClass **cl) {
   NsfCmdList *cmdList;
 
+  assert(interp); // autoadded
+  assert(currentCmd); // autoadded
+  assert(cl); // autoadded
+
   assert(object);
   assert(object->filterStack);
 
@@ -9455,6 +9835,12 @@
   NsfClass **scl;
   int i, j;
 
+  assert(interp); // autoadded
+  assert(cl); // autoadded
+  assert(ov); // autoadded
+  assert(arg); // autoadded
+  assert(baseClass); // autoadded
+
   superClasses = PrecedenceOrder(cl);
   subClasses = TransitiveSubClasses(cl);
 
@@ -9556,12 +9942,12 @@
     for (l = osl; l; l = l->nextPtr) {
       AddSuper(cl, l->cl);
     }
-    NsfClassListFree(osl);
+    if (osl) NsfClassListFree(osl);
 
     return NsfObjErrType(interp, "superclass", arg, "a cycle-free graph", NULL);
   }
 
-  NsfClassListFree(osl);
+  if (osl) NsfClassListFree(osl);
 
   assert(cl->super);
 
@@ -9587,6 +9973,10 @@
 
 static int
 CheckVarName(Tcl_Interp *interp, const char *varNameString) {
+
+  assert(interp); // autoadded
+  assert(varNameString); // autoadded
+
   /*
    * We want to have a plain variable name, since we do not want to
    * get interferences with namespace resolver and such.  In an first
@@ -9615,6 +10005,10 @@
   Var *varPtr, *arrayPtr;
   int result;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+  assert(varName); // autoadded
+
   Nsf_PushFrameObj(interp, object, framePtr);
 
   if (flags & NSF_VAR_TRIGGER_TRACE) {
@@ -9674,6 +10068,11 @@
   Namespace *nsPtr = procPtr->cmdPtr->nsPtr;
   Tcl_Obj *bodyObj = procPtr->bodyPtr;
 
+  assert(interp); // autoadded
+  assert(flagsPtr); // autoadded
+  assert(procPtr); // autoadded
+  assert(procName); // autoadded
+
   if (likely(bodyObj->typePtr == Nsf_OT_byteCodeType)) {
 #if defined(HAVE_TCL_COMPILE_H)
     ByteCode *codePtr;
@@ -9760,6 +10159,11 @@
   Tcl_CallFrame *framePtr;
   int result;
 
+  assert(procPtr); // autoadded
+  assert(interp); // autoadded
+  assert(objv); // autoadded
+  assert(cscPtr); // autoadded
+
   /*
    * Set up and push a new call frame for the new procedure invocation.
    * This call frame will execute in the proc's namespace, which might be
@@ -9828,6 +10232,9 @@
 
 static void
 ParamFree(Nsf_Param *paramPtr) {
+
+  assert(paramPtr); // autoadded
+
   /*fprintf(stderr, "ParamFree %p\n", paramPtr);*/
   if (paramPtr->name) {STRING_FREE("paramPtr->name", paramPtr->name);}
   if (paramPtr->nameObj) {DECR_REF_COUNT(paramPtr->nameObj);}
@@ -9858,6 +10265,8 @@
 ParamsFree(Nsf_Param *paramsPtr) {
   Nsf_Param *paramPtr;
 
+  assert(paramsPtr); // autoadded
+
   /*fprintf(stderr, "ParamsFree %p\n", paramsPtr);*/
   for (paramPtr=paramsPtr; paramPtr->name; paramPtr++) {
     ParamFree(paramPtr);
@@ -9944,12 +10353,15 @@
  *
  *----------------------------------------------------------------------
  */
-static int ParamDefsStore(Tcl_Command cmd, NsfParamDefs *paramDefs, int checkAlwaysFlag) nonnull(2);
+static int ParamDefsStore(Tcl_Command cmd, NsfParamDefs *paramDefs, int checkAlwaysFlag) nonnull(1);
 
 static int
 ParamDefsStore(Tcl_Command cmd, NsfParamDefs *paramDefs, int checkAlwaysFlag) {
   Command *cmdPtr = (Command *)cmd;
 
+  assert(cmd);
+  // TODO might store empty paramDefs. needed?
+
   if (cmdPtr->deleteProc != NsfProcDeleteProc) {
     NsfProcContext *ctxPtr = NEW(NsfProcContext);
 
@@ -10036,6 +10448,8 @@
   /*fprintf(stderr, "ParamDefsFree %p slotObj %p returns %p\n",
     paramDefs, paramDefs->slotObj, paramDefs->returns);*/
 
+  assert(paramDefs); // autoadded
+
   if (paramDefs->paramsPtr) {
     ParamsFree(paramDefs->paramsPtr);
   }
@@ -10103,6 +10517,12 @@
 static void
 ParamDefsFormatOption(Tcl_Obj *nameStringObj, CONST char *option,
                       int *colonWritten, int *firstOption) {
+
+  assert(nameStringObj); // autoadded
+  assert(option); // autoadded
+  assert(colonWritten); // autoadded
+  assert(firstOption); // autoadded
+
   if (!*colonWritten) {
     Tcl_AppendLimitedToObj(nameStringObj, ":", 1, INT_MAX, NULL);
     *colonWritten = 1;
@@ -10138,6 +10558,9 @@
   Tcl_Obj *listObj = Tcl_NewListObj(0, NULL), *innerListObj, *nameStringObj;
   Nsf_Param CONST *paramPtr;
 
+  assert(interp); // autoadded
+  assert(paramsPtr); // autoadded
+
   INCR_REF_COUNT2("paramDefsObj", listObj);
 
   for (paramPtr = paramsPtr; paramPtr->name; paramPtr++) {
@@ -10234,6 +10657,9 @@
   Tcl_Obj *listObj = Tcl_NewListObj(0, NULL);
   Nsf_Param CONST *paramPtr;
 
+  assert(interp); // autoadded
+  assert(paramsPtr); // autoadded
+
   INCR_REF_COUNT2("paramDefsObj", listObj);
   for (paramPtr = paramsPtr; paramPtr->name; paramPtr++) {
     if ((paramPtr->flags & NSF_ARG_NOCONFIG) == 0) {
@@ -10266,6 +10692,9 @@
   Tcl_Obj *listObj = Tcl_NewListObj(0, NULL);
   Nsf_Param CONST *paramPtr;
 
+  assert(interp); // autoadded
+  assert(paramsPtr); // autoadded
+
   INCR_REF_COUNT2("paramDefsObj", listObj);
   for (paramPtr = paramsPtr; paramPtr->name; paramPtr++) {
     if ((paramPtr->flags & NSF_ARG_NOCONFIG) == 0) {
@@ -10369,6 +10798,10 @@
 
 static void
 NsfParamDefsSyntaxOne(Tcl_Obj *argStringObj, Nsf_Param CONST *pPtr) {
+
+  assert(argStringObj); // autoadded
+  assert(pPtr); // autoadded
+
   if (pPtr->nrArgs > 0 && *pPtr->name == '-') {
     Tcl_AppendLimitedToObj(argStringObj, pPtr->name, -1, INT_MAX, NULL);
     Tcl_AppendLimitedToObj(argStringObj, " ", 1, INT_MAX, NULL);
@@ -10474,6 +10907,9 @@
 
 static void
 ParsedParamFree(NsfParsedParam *parsedParamPtr) {
+
+  assert(parsedParamPtr); // autoadded
+
   /*fprintf(stderr, "ParsedParamFree %p, npargs %p\n",
     parsedParamPtr, parsedParamPtr->paramDefs);*/
   if (parsedParamPtr->paramDefs) {
@@ -10519,6 +10955,9 @@
   NsfObjectOpt *opt = object->opt;
 #endif
 
+  assert(data); // autoadded
+  assert(interp); // autoadded
+
   /*fprintf(stderr, "ProcMethodDispatchFinalize %s %s flags %.6x isNRE %d pcPtr %p result %d\n",
 	  ObjectName(object), methodName,
 	  cscPtr->flags, (cscPtr->flags & NSF_CSC_CALL_IS_NRE), pcPtr, result);*/
@@ -10574,6 +11013,9 @@
   ParseContext *pcPtr = data[1];
   /*CONST char *methodName = data[0];
 
+  assert(data); // autoadded
+  assert(interp); // autoadded
+
     fprintf(stderr, "ProcDispatchFinalize of method %s\n", methodName);*/
 
 # if defined(NSF_PROFILE)
@@ -10609,7 +11051,7 @@
  */
 static int ProcMethodDispatch(ClientData cp, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[],
          CONST char *methodName, NsfObject *object, NsfClass *cl, Tcl_Command cmdPtr,
-         NsfCallStackContent *cscPtr) nonnull(2) nonnull(4) nonnull(5) nonnull(6) nonnull(7) nonnull(9);
+         NsfCallStackContent *cscPtr) nonnull(2) nonnull(4) nonnull(5) nonnull(6) nonnull(8) nonnull(9);
 
 static int
 ProcMethodDispatch(ClientData cp, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[],
@@ -10626,7 +11068,13 @@
   ParseContext pc, *pcPtr = &pc;
 #endif
 
+  assert(interp); // autoadded
+  assert(objv); // autoadded
+  assert(methodName); // autoadded
   assert(object);
+  assert(cmdPtr);
+  assert(cscPtr); // autoadded
+
   assert(object->teardown);
 #if defined(NRE)
   /*fprintf(stderr, "ProcMethodDispatch cmd %s\n", Tcl_GetCommandName(interp, cmdPtr));*/
@@ -10797,6 +11245,9 @@
   CallFrame frame, *framePtr = &frame;
   int result;
 
+  assert(interp); // autoadded
+  assert(objv); // autoadded
+
   assert(cmd);
   assert(object);
   assert(object->teardown);
@@ -10870,6 +11321,12 @@
   NsfClass *actualClass;
   int result;
 
+  assert(interp); // autoadded
+  assert(objv); // autoadded
+  assert(methodName); // autoadded
+  assert(callerSelf); // autoadded
+  assert(cscPtr); // autoadded
+
   /*fprintf(stderr, "ObjectCmdMethodDispatch %p %s\n", cmd, Tcl_GetCommandName(interp, cmd));*/
 
   assert(invokedObject);
@@ -11205,6 +11662,12 @@
   Tcl_ObjCmdProc *proc = Tcl_Command_objProc(cmd);
   NsfCallStackContent *cscPtr1;
 
+  assert(interp); // autoadded
+  assert(objv); // autoadded
+  assert(cscPtr); // autoadded
+  assert(methodName); // autoadded
+  assert(validCscPtr); // autoadded
+
   /*
    * Privide DTrace with calling info
    */
@@ -12398,6 +12861,9 @@
 AddPrefixToBody(Tcl_Obj *body, int paramDefs, NsfParsedParam *paramPtr) {
   Tcl_Obj *resultBody = Tcl_NewObj();
 
+  assert(body); // autoadded
+  assert(paramPtr); // autoadded
+
   INCR_REF_COUNT2("resultBody", resultBody);
 
   if (paramDefs && paramPtr->possibleUnknowns > 0) {
@@ -12450,7 +12916,12 @@
 
 int
 Nsf_ConvertToString(Tcl_Interp *UNUSED(interp), Tcl_Obj *objPtr, Nsf_Param CONST *UNUSED(pPtr),
-			   ClientData *clientData, Tcl_Obj **outObjPtr) {
+                    ClientData *clientData, Tcl_Obj **outObjPtr) {
+
+  assert(objPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   *clientData = (char *)ObjStr(objPtr);
   assert(*outObjPtr == objPtr);
   return TCL_OK;
@@ -12479,6 +12950,10 @@
 static int
 ConvertToNothing(Tcl_Interp *UNUSED(interp), Tcl_Obj *objPtr,  Nsf_Param CONST *UNUSED(pPtr),
 		 ClientData *UNUSED(clientData), Tcl_Obj **outObjPtr) {
+
+  assert(objPtr); // autoadded
+  assert(outObjPtr); // autoadded
+
   assert(*outObjPtr == objPtr);
   *outObjPtr = objPtr;
   return TCL_OK;
@@ -12518,6 +12993,12 @@
 			   ClientData *clientData, Tcl_Obj **outObjPtr) {
   int result;
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   if (unlikely(pPtr->converterArg != NULL)) {
     Tcl_Obj *objv[3];
     /*fprintf(stderr, "ConvertToTclobj %s (must be %s)\n", ObjStr(objPtr), ObjStr(pPtr->converterArg));*/
@@ -12588,6 +13069,12 @@
   int result, bool;
   result = Tcl_GetBooleanFromObj(interp, objPtr, &bool);
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   if (result == TCL_OK) {
     *clientData = (ClientData)INT2PTR(bool);
   } else {
@@ -12623,6 +13110,12 @@
   int result;
   int i;
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   result = Tcl_GetIntFromObj(interp, objPtr, &i);
 
   if (likely(result == TCL_OK)) {
@@ -12661,6 +13154,12 @@
 		     ClientData *clientData, Tcl_Obj **outObjPtr) {
   int result;
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   /*
    * Try to short_cut common cases to avoid conversion to bignums, since
    * Tcl_GetBignumFromObj returns a value, which has to be freed.
@@ -12729,6 +13228,13 @@
 int
 Nsf_ConvertToSwitch(Tcl_Interp *interp, Tcl_Obj *objPtr, Nsf_Param CONST *pPtr,
 			   ClientData *clientData, Tcl_Obj **outObjPtr) {
+
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   return Nsf_ConvertToBoolean(interp, objPtr, pPtr, clientData, outObjPtr);
 }
 
@@ -12755,6 +13261,13 @@
 int
 Nsf_ConvertToObject(Tcl_Interp *interp, Tcl_Obj *objPtr, Nsf_Param CONST *pPtr,
 		ClientData *clientData, Tcl_Obj **outObjPtr) {
+
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   assert(*outObjPtr == objPtr);
   if (likely(GetObjectFromObj(interp, objPtr, (NsfObject **)clientData) == TCL_OK)) {
     return IsObjectOfType(interp, (NsfObject *)*clientData, "object", objPtr, pPtr);
@@ -12785,6 +13298,13 @@
 int
 Nsf_ConvertToClass(Tcl_Interp *interp, Tcl_Obj *objPtr,  Nsf_Param CONST *pPtr,
 	       ClientData *clientData, Tcl_Obj **outObjPtr) {
+
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   assert(*outObjPtr == objPtr);
   if (likely(GetClassFromObj(interp, objPtr, (NsfClass **)clientData, 0) == TCL_OK)) {
     return IsObjectOfType(interp, (NsfObject *)*clientData, "class", objPtr, pPtr);
@@ -12820,6 +13340,12 @@
 	       ClientData *clientData, Tcl_Obj **outObjPtr) {
   int result;
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   assert(*outObjPtr == objPtr);
   result = Tcl_ConvertToType(interp, objPtr, &NsfFilterregObjType);
   if (likely(result == TCL_OK)) {
@@ -12855,6 +13381,12 @@
 	       ClientData *clientData, Tcl_Obj **outObjPtr) {
   int result;
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   assert(*outObjPtr == objPtr);
   result = Tcl_ConvertToType(interp, objPtr, &NsfMixinregObjType);
   if (likely(result == TCL_OK)) {
@@ -12890,6 +13422,12 @@
 		   ClientData *clientData, Tcl_Obj **outObjPtr) {
   CONST char *value = ObjStr(objPtr);
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   assert(*outObjPtr == objPtr);
   /*fprintf(stderr, "convert to parameter '%s' t '%s'\n", value, pPtr->type);*/
   if (*value == ':' ||  (*value == '-' && *(value + 1) == ':')) {
@@ -13030,6 +13568,11 @@
   Tcl_Obj *patternObj = objPtr;
   CONST char *pattern = ObjStr(objPtr);
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   if (NoMetaChars(pattern)) {
     /*
      * We have no meta characters, we try to check for an existing object
@@ -13067,6 +13610,9 @@
 
 static Tcl_Obj *
 ParamCheckObj(CONST char *start, size_t len) {
+
+  assert(start); // autoadded
+
   Tcl_Obj *checker = Tcl_NewStringObj("type=", 5);
   Tcl_AppendLimitedToObj(checker, start, len, INT_MAX, NULL);
   return checker;
@@ -13078,6 +13624,12 @@
 static int
 ParamOptionSetConverter(Tcl_Interp *interp, Nsf_Param *paramPtr,
                         CONST char *typeName, Nsf_TypeConverter *converter) {
+
+  assert(interp); // autoadded
+  assert(paramPtr); // autoadded
+  assert(typeName); // autoadded
+  assert(converter); // autoadded
+
   if (paramPtr->converter) {
     return NsfPrintError(interp, "refuse to redefine parameter type of '%s' from type '%s' to type '%s'",
 			 paramPtr->name, paramPtr->type, typeName);
@@ -13111,6 +13663,8 @@
   int i, j, l = Tcl_GetCharLength(objPtr);
   char *string = ObjStr(objPtr);
 
+  assert(objPtr); // autoadded
+
   for (i = 0; i < l; i++) {
     if (string[i] == ',' && string[i+1] == ',') {
       for (j = i+1; j < l; j++) {
@@ -13152,6 +13706,10 @@
   CONST char *dotdot, *option = argString + start;
   int result = TCL_OK;
 
+  assert(interp); // autoadded
+  assert(argString); // autoadded
+  assert(paramPtr); // autoadded
+
   /* fprintf(stderr, "ParamOptionParse name %s, option '%s' (%ld) disallowed %.6x\n",
      paramPtr->name, option, start, disallowedOptions);*/
 
@@ -13434,7 +13992,8 @@
  */
 
 static int ParamParse(Tcl_Interp *interp, Tcl_Obj *procNameObj, Tcl_Obj *arg, int disallowedFlags,
-           Nsf_Param *paramPtr, int *possibleUnknowns, int *plainParams, int *nrNonposArgs) nonnull(1) nonnull(2) nonnull(3) nonnull(5) nonnull(6) nonnull(7) nonnull(8);
+           Nsf_Param *paramPtr, int *possibleUnknowns, int *plainParams, int *nrNonposArgs) 
+  nonnull(1) nonnull(3) nonnull(5) nonnull(6) nonnull(7) nonnull(8);
 
 static int
 ParamParse(Tcl_Interp *interp, Tcl_Obj *procNameObj, Tcl_Obj *arg, int disallowedFlags,
@@ -13444,6 +14003,13 @@
   CONST char *argString, *argName;
   Tcl_Obj **npav;
 
+  assert(interp); // autoadded
+  assert(arg); // autoadded
+  assert(paramPtr); // autoadded
+  assert(possibleUnknowns); // autoadded
+  assert(plainParams); // autoadded
+  assert(nrNonposArgs); // autoadded
+
   paramPtr->paramObj = arg;
   INCR_REF_COUNT(paramPtr->paramObj);
 
@@ -13722,6 +14288,10 @@
   Tcl_Obj **argsv;
   int result, argsc;
 
+  assert(interp); // autoadded
+  assert(paramSpecObjs); // autoadded
+  assert(parsedParamPtr); // autoadded
+
   parsedParamPtr->paramDefs = NULL;
   parsedParamPtr->possibleUnknowns = 0;
 
@@ -13830,6 +14400,10 @@
 			       Nsf_Param *paramPtr, Tcl_Obj *newValue,
 			       NsfCallStackContent *cscPtr) {
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+  assert(paramPtr); // autoadded
+
   Tcl_Obj **nobjv, *ov[3], *methodObj, *forwardSpec;
   ForwardCmdClientData *tcd = NULL;
   int result, oc, nobjc;
@@ -13909,7 +14483,8 @@
 			CallFrame *uplevelVarFramePtr,
 			CONST char *initString,
 			Tcl_Obj *lastObj, Tcl_Obj **nextObjPtr,
-			int nrRemainingArgs) nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(5) nonnull(6) nonnull(7) nonnull(8);
+			int nrRemainingArgs) 
+  nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(6) nonnull(7) nonnull(8);
 
 static int
 ParameterMethodDispatch(Tcl_Interp *interp, NsfObject *object,
@@ -13923,6 +14498,14 @@
   CallFrame frame2, *framePtr2 = &frame2;
   int result = TCL_OK;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+  assert(paramPtr); // autoadded
+  assert(newValue); // autoadded
+  assert(initString); // autoadded
+  assert(lastObj); // autoadded
+  assert(nextObjPtr); // autoadded
+
   /*
    * The current call-frame of configure uses an obj-frame, such
    * that setvar etc.  are able to access variables like "a" as a
@@ -14070,7 +14653,8 @@
 static int MakeProc(Tcl_Namespace *nsPtr, NsfAssertionStore *aStore, Tcl_Interp *interp,
          Tcl_Obj *nameObj, Tcl_Obj *args, Tcl_Obj *body, Tcl_Obj *precondition,
          Tcl_Obj *postcondition, NsfObject *defObject, NsfObject *regObject,
-         int withPer_object, int withInner_namespace, int checkAlwaysFlag) nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(5) nonnull(6) nonnull(7) nonnull(8) nonnull(9) nonnull(10);
+         int withPer_object, int withInner_namespace, int checkAlwaysFlag) 
+  nonnull(1) nonnull(3) nonnull(4) nonnull(5) nonnull(6) nonnull(9);
 
 static int
 MakeProc(Tcl_Namespace *nsPtr, NsfAssertionStore *aStore, Tcl_Interp *interp,
@@ -14083,6 +14667,13 @@
   Tcl_Obj *ov[4];
   int result;
 
+  assert(nsPtr); // autoadded
+  assert(interp); // autoadded
+  assert(nameObj); // autoadded
+  assert(args); // autoadded
+  assert(body); // autoadded
+  assert(defObject); // autoadded
+
   assert(*methodName != ':');
 
   if (regObject == NULL) {regObject = defObject;}
@@ -14243,8 +14834,10 @@
     /* could be a filter or filter inheritance ... update filter orders */
     if (FilterIsActive(interp, nameStr)) {
       NsfClasses *subClasses = TransitiveSubClasses(cl);
-      FilterInvalidateObjOrders(interp, cl, subClasses);
-      NsfClassListFree(subClasses);
+      if (subClasses) {
+        FilterInvalidateObjOrders(interp, cl, subClasses);
+        NsfClassListFree(subClasses);
+      }
     }
   } else {
     NsfObjectMethodEpochIncr("MakeMethod");
@@ -14314,6 +14907,10 @@
   Tcl_CallFrame *framePtr;
   Proc *procPtr;
 
+  assert(interp); // autoadded
+  assert(procNameObj); // autoadded
+  assert(pcPtr); // autoadded
+
 #if defined(NSF_PROFILE)
   struct timeval trt;
   NsfRuntimeState *rst = RUNTIME_STATE(interp);
@@ -14436,6 +15033,9 @@
   NsfProcClientData *tcd = clientData;
   int result;
 
+  assert(interp); // autoadded
+  assert(objv); // autoadded
+
   assert(tcd);
   /*fprintf(stderr, "NsfProcStub %s is called, tcd %p\n", ObjStr(objv[0]), tcd);*/
 
@@ -14519,6 +15119,11 @@
   int result, checkAlwaysFlag;
   Tcl_Command cmd;
 
+  assert(interp); // autoadded
+  assert(parsedParamPtr); // autoadded
+  assert(procName); // autoadded
+  assert(body); // autoadded
+
   Tcl_DStringInit(dsPtr);
 
   /*
@@ -14894,18 +15499,18 @@
 
 static int
 GetMatchObject(Tcl_Interp *interp, Tcl_Obj *patternObj, Tcl_Obj *origObj,
-                NsfObject **matchObject, CONST char **pattern) {
+                NsfObject **matchObjectPtr, CONST char **patternPtr) {
 
   assert(interp); // autoadded
-  assert(matchObject); // autoadded
-  assert(pattern); // autoadded
+  assert(matchObjectPtr); // autoadded
+  assert(patternPtr); // autoadded
 
   if (patternObj) {
-    *pattern = ObjStr(patternObj);
-    if (TclObjIsNsfObject(interp, patternObj, matchObject)) {
+    *patternPtr = ObjStr(patternObj);
+    if (TclObjIsNsfObject(interp, patternObj, matchObjectPtr)) {
       return 1;
     }
-    if (patternObj == origObj && **pattern != ':') {
+    if (patternObj == origObj && **patternPtr != ':') {
       return -1;
     }
   }
@@ -15061,6 +15666,9 @@
 
 static CONST char *
 StripBodyPrefix(CONST char *body) {
+
+  assert(body); // autoadded
+
   if (strncmp(body, "::nsf::__unset_unknown_args\n", 28) == 0) {
     body += 28;
   }
@@ -15086,7 +15694,7 @@
 static void AddSlotObjects(Tcl_Interp *interp, NsfObject *parent, CONST char *prefix,
                            Tcl_HashTable *slotTablePtr, int withSource, NsfClass *type, 
                            CONST char *pattern, Tcl_Obj *listObj) 
-  nonnull(1) nonnull(2) nonnull(3) nonnull(6) nonnull(8);
+  nonnull(1) nonnull(2) nonnull(3) nonnull(8);
 
 static void
 AddSlotObjects(Tcl_Interp *interp, NsfObject *parent, CONST char *prefix,
@@ -15097,6 +15705,11 @@
   Tcl_DString ds, *dsPtr = &ds;
   int fullQualPattern = (pattern && *pattern == ':' && *(pattern+1) == ':');
 
+  assert(interp); // autoadded
+  assert(parent); // autoadded
+  assert(prefix); // autoadded
+  assert(listObj); // autoadded
+
   /* fprintf(stderr, "AddSlotObjects parent %s prefix %s type %p %s\n",
      ObjectName(parent), prefix, type, type ? ClassName(type) : "");*/
 
@@ -15200,6 +15813,9 @@
   CONST char *methodName;
   Tcl_Command cmd;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   if (cscPtr->frameType == NSF_CSC_TYPE_PLAIN) {
     return cscPtr->cl;
   }
@@ -15382,7 +15998,8 @@
  */
 static int NextGetArguments(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[],
 		 NsfCallStackContent **cscPtrPtr, CONST char **methodNamePtr,
-		 int *outObjc, Tcl_Obj ***outObjv, int *freeArgumentVector) nonnull(1) nonnull(3) nonnull(4) nonnull(5) nonnull(6) nonnull(7) nonnull(8);
+		 int *outObjc, Tcl_Obj ***outObjv, int *freeArgumentVector) 
+  nonnull(1) nonnull(4) nonnull(5) nonnull(6) nonnull(7) nonnull(8);
 
 static int
 NextGetArguments(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[],
@@ -15393,6 +16010,13 @@
   Tcl_CallFrame *framePtr;
   NsfCallStackContent *cscPtr = CallStackGetTopFrame(interp, &framePtr);
 
+  assert(interp); // autoadded
+  assert(cscPtrPtr); // autoadded
+  assert(methodNamePtr); // autoadded
+  assert(outObjc); // autoadded
+  assert(outObjv); // autoadded
+  assert(freeArgumentVector); // autoadded
+
   /* always make sure, we only decrement when necessary */
   *freeArgumentVector = 0;
 
@@ -15791,6 +16415,8 @@
   NsfObject *object = cscPtr->self;
   CONST char *methodName;
 
+  assert(interp); // autoadded
+
   Tcl_ResetResult(interp);
 
   methodName = (char *)Tcl_GetCommandName(interp, cscPtr->cmdPtr);
@@ -15830,6 +16456,8 @@
   Tcl_CallFrame *framePtr;
   Tcl_Obj *resultObj;
 
+  assert(interp); // autoadded
+
   switch (level) {
   case CALLING_LEVEL: NsfCallStackFindLastInvocation(interp, 1, &framePtr); break;
   case ACTIVE_LEVEL:  NsfCallStackFindActiveFrame(interp,    1, &framePtr); break;
@@ -15875,6 +16503,10 @@
   /*fprintf(stderr, "### UnsetInAllNamespaces variable '%s', current namespace '%s'\n",
           name, nsPtr ? nsPtr->fullName : "NULL");*/
 
+  assert(interp); // autoadded
+  assert(nsPtr); // autoadded
+  assert(name); // autoadded
+
   if (nsPtr) {
     Tcl_HashSearch search;
     Tcl_HashEntry *entryPtr = Tcl_FirstHashEntry(Tcl_Namespace_childTablePtr(nsPtr), &search);
@@ -15925,6 +16557,9 @@
      */
     /* fprintf(stderr, "### FreeUnsetTraceVariable %s\n", object->opt->volatileVarName);*/
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
     int result = Tcl_UnsetVar2(interp, object->opt->volatileVarName, NULL, 0);
     if (result != TCL_OK) {
       int result = Tcl_UnsetVar2(interp, object->opt->volatileVarName, NULL, TCL_GLOBAL_ONLY);
@@ -15959,6 +16594,9 @@
   NsfObject *object;
   char *resultMsg = NULL;
 
+  assert(clientData); // autoadded
+  assert(interp); // autoadded
+
   /*fprintf(stderr, "NsfUnsetTrace %s flags %.4x %.4x\n", name, flags,
     flags & TCL_INTERP_DESTROYED);*/
 
@@ -16009,6 +16647,9 @@
 static void
 CleanupDestroyObject(Tcl_Interp *interp, NsfObject *object, int softrecreate) {
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   /*fprintf(stderr, "CleanupDestroyObject obj %p softrecreate %d nsPtr %p\n",
     object, softrecreate, object->nsPtr);*/
 
@@ -16063,7 +16704,7 @@
        * Remove this object from all per object mixin lists and clear the
        * mixin list.
        */
-      RemoveFromObjectMixinsOf(object->id, opt->objMixins);
+      if (opt->objMixins) RemoveFromObjectMixinsOf(object->id, opt->objMixins);
 
       CmdListFree(&opt->objMixins, GuardDel);
       CmdListFree(&opt->objFilters, GuardDel);
@@ -16082,12 +16723,16 @@
  * do obj initialization & namespace creation
  */
 static void CleanupInitObject(Tcl_Interp *interp, NsfObject *object,
-                  NsfClass *cl, Tcl_Namespace *nsPtr, int softrecreate) nonnull(1) nonnull(2) nonnull(3) nonnull(4);
+                  NsfClass *cl, Tcl_Namespace *nsPtr, int softrecreate) 
+  nonnull(1) nonnull(2);
 
 static void
 CleanupInitObject(Tcl_Interp *interp, NsfObject *object,
                   NsfClass *cl, Tcl_Namespace *nsPtr, int softrecreate) {
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
 #ifdef OBJDELETION_TRACE
   fprintf(stderr, "+++ CleanupInitObject\n");
 #endif
@@ -16242,6 +16887,9 @@
 DoDealloc(Tcl_Interp *interp, NsfObject *object) {
   int result;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   /*fprintf(stderr, "DoDealloc obj= %s %p flags %.6x activation %d cmd %p opt=%p\n",
           ObjectName(object), object, object->flags, object->activationCount,
           object->id, object->opt);*/
@@ -16269,6 +16917,9 @@
 
 static void
 MarkUndestroyed(NsfObject *object) {
+
+  assert(object); // autoadded
+
   object->flags &= ~NSF_DESTROY_CALLED;
 }
 
@@ -16280,6 +16931,10 @@
 PrimitiveOInit(NsfObject *object, Tcl_Interp *interp, CONST char *name,
 	       Tcl_Namespace *nsPtr, NsfClass *cl) {
 
+  assert(object); // autoadded
+  assert(interp); // autoadded
+  assert(name); // autoadded
+
 #ifdef OBJDELETION_TRACE
   fprintf(stderr, "+++ PrimitiveOInit\n");
 #endif
@@ -16330,14 +16985,19 @@
 /*
  * Object creation: create object name (full name) and Tcl command
  */
-static NsfObject * PrimitiveOCreate(Tcl_Interp *interp, Tcl_Obj *nameObj, Tcl_Namespace *parentNsPtr, NsfClass *cl) nonnull(1) nonnull(2) nonnull(3) nonnull(4);
+static NsfObject * PrimitiveOCreate(Tcl_Interp *interp, Tcl_Obj *nameObj, Tcl_Namespace *parentNsPtr, NsfClass *cl) 
+  nonnull(1) nonnull(2) nonnull(4);
 
 static NsfObject *
 PrimitiveOCreate(Tcl_Interp *interp, Tcl_Obj *nameObj, Tcl_Namespace *parentNsPtr, NsfClass *cl) {
   NsfObject *object = (NsfObject *)ckalloc(sizeof(NsfObject));
   CONST char *nameString = ObjStr(nameObj);
   Tcl_Namespace *nsPtr;
 
+  assert(interp); // autoadded
+  assert(nameObj); // autoadded
+  assert(cl); // autoadded
+
   /*fprintf(stderr, "PrimitiveOCreate %s parentNs %p\n", nameString, parentNsPtr);*/
 
 #if defined(NSFOBJ_TRACE)
@@ -16501,6 +17161,9 @@
   NsfClass *baseClass = NULL;
   NsfClasses *subClasses;
 
+  assert(interp); // autoadded
+  assert(cl); // autoadded
+
   PRINTOBJ("CleanupDestroyClass", (NsfObject *)cl);
   assert(softrecreate ? recreate == 1 : 1);
 
@@ -16509,23 +17172,25 @@
 	  softrecreate, recreate, clopt);*/
 
   subClasses = TransitiveSubClasses(cl);
+  if (subClasses) {
 
-  /*
-   * Perform the next steps even with clopt == NULL, since the class
-   * might be used as a superclass of a per object mixin, so it might
-   * have no clopt...
-   */
-  MixinInvalidateObjOrders(interp, cl, subClasses);
-  if (FiltersDefined(interp) > 0) {
-    FilterInvalidateObjOrders(interp, cl, subClasses);
+    /*
+     * Perform the next steps even with clopt == NULL, since the class
+     * might be used as a superclass of a per object mixin, so it might
+     * have no clopt...
+     */
+    MixinInvalidateObjOrders(interp, cl, subClasses);
+    if (FiltersDefined(interp) > 0) {
+      FilterInvalidateObjOrders(interp, cl, subClasses);
+    }
   }
 
   if (clopt) {
     /*
      *  Remove this class from all isClassMixinOf lists and clear the
      *  class mixin list
      */
-    RemoveFromClassMixinsOf(clopt->id, clopt->classMixins);
+    if (clopt->classMixins) RemoveFromClassMixinsOf(clopt->id, clopt->classMixins);
 
     CmdListFree(&clopt->classMixins, GuardDel);
     CmdListFree(&clopt->classFilters, GuardDel);
@@ -16534,14 +17199,14 @@
       /*
        *  Remove this class from all mixin lists and clear the isObjectMixinOf list
        */
-      RemoveFromObjectMixins(clopt->id, clopt->isObjectMixinOf);
+      if (clopt->isObjectMixinOf) RemoveFromObjectMixins(clopt->id, clopt->isObjectMixinOf);
       CmdListFree(&clopt->isObjectMixinOf, GuardDel);
 
       /*
        *  Remove this class from all class mixin lists and clear the
        *  isClassMixinOf list
        */
-      RemoveFromClassmixins(clopt->id, clopt->isClassMixinOf);
+      if (clopt->isClassMixinOf) RemoveFromClassmixins(clopt->id, clopt->isClassMixinOf);
       CmdListFree(&clopt->isClassMixinOf, GuardDel);
     }
 
@@ -16664,6 +17329,10 @@
                  int softrecreate, int recreate) {
   NsfClass *defaultSuperclass;
 
+  assert(interp); // autoadded
+  assert(cl); // autoadded
+  assert(nsPtr); // autoadded
+
   assert(softrecreate ? recreate == 1 : 1);
 
 #ifdef OBJDELETION_TRACE
@@ -16767,6 +17436,10 @@
   Tcl_CallFrame frame, *framePtr = &frame;
   Tcl_Namespace *nsPtr;
 
+  assert(cl); // autoadded
+  assert(interp); // autoadded
+  assert(name); // autoadded
+
   /*
    * ensure that namespace is newly created during CleanupInitClass
    * ie. kill it, if it exists already
@@ -16796,6 +17469,9 @@
   CONST char *nameString = ObjStr(nameObj);
   NsfObject *object = (NsfObject *)cl;
 
+  assert(interp); // autoadded
+  assert(nameObj); // autoadded
+
   /* fprintf(stderr, "PrimitiveCCreate %s parentNs %p\n", nameString, parentNsPtr); */
 
 #if defined(NSFOBJ_TRACE)
@@ -16929,6 +17605,10 @@
   Tcl_Obj *methodObj, *savedObjResult;
   int result;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+  assert(objv); // autoadded
+
   /*
    * Save the result we have so far to return it in case of success
    */
@@ -17002,6 +17682,9 @@
 
 static int
 HasMetaProperty(NsfClass *cl) {
+
+  assert(cl); // autoadded
+
   return cl->object.flags & NSF_IS_ROOT_META_CLASS;
 }
 
@@ -17047,8 +17730,8 @@
 	break;
       }
     }
-    NsfClassListFree(mixinClasses);
-    NsfClassListFree(checkList);
+    if (mixinClasses) NsfClassListFree(mixinClasses);
+    if (checkList)    NsfClassListFree(checkList);
     /*fprintf(stderr, "has MC returns %d, mixinClasses = %p\n",
       hasMCM, mixinClasses);*/
 
@@ -17078,6 +17761,10 @@
 static int
 HasMixin(Tcl_Interp *interp, NsfObject *object, NsfClass *cl) {
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+  assert(cl); // autoadded
+
   if (!(object->flags & NSF_MIXIN_ORDER_VALID)) {
     MixinComputeDefined(interp, object);
   }
@@ -17094,7 +17781,8 @@
 }
 
 static int GetInstVarIntoCurrentScope(Tcl_Interp *interp, const char *cmdName, NsfObject *object,
-                           Tcl_Obj *varName, Tcl_Obj *newName) nonnull(1) nonnull(2) nonnull(3) nonnull(4) nonnull(5);
+                           Tcl_Obj *varName, Tcl_Obj *newName) 
+  nonnull(1) nonnull(2) nonnull(3) nonnull(4);
 
 static int
 GetInstVarIntoCurrentScope(Tcl_Interp *interp, const char *cmdName, NsfObject *object,
@@ -17105,6 +17793,11 @@
   CallFrame frame, *framePtr = &frame;
   char *varNameString;
 
+  assert(interp); // autoadded
+  assert(cmdName); // autoadded
+  assert(object); // autoadded
+  assert(varName); // autoadded
+
   if (CheckVarName(interp, ObjStr(varName)) != TCL_OK) {
     return TCL_ERROR;
   }
@@ -17232,6 +17925,10 @@
 
 void
 NsfSetObjClientData(Tcl_Interp *interp, Nsf_Object *object1, ClientData data) {
+
+  assert(interp); // autoadded
+  assert(object1); // autoadded
+
   NsfObject *object = (NsfObject *) object1;
   NsfObjectOpt *opt = NsfRequireObjectOpt(object);
   opt->clientData = data;
@@ -17247,6 +17944,10 @@
 
 void
 NsfSetClassClientData(Tcl_Interp *interp, Nsf_Class *cli, ClientData data) {
+
+  assert(interp); // autoadded
+  assert(cli); // autoadded
+
   NsfClass *cl = (NsfClass *) cli;
   NsfRequireClassOpt(cl);
   cl->opt->clientData = data;
@@ -17317,14 +18018,18 @@
  *
  *----------------------------------------------------------------------
  */
-static int SetInstArray(Tcl_Interp *interp, NsfObject *object, Tcl_Obj *arrayNameObj, Tcl_Obj *valueObj) nonnull(1) nonnull(2) nonnull(3) nonnull(4);
+static int SetInstArray(Tcl_Interp *interp, NsfObject *object, Tcl_Obj *arrayNameObj, Tcl_Obj *valueObj) 
+  nonnull(1) nonnull(2) nonnull(3);
 
 static int
 SetInstArray(Tcl_Interp *interp, NsfObject *object, Tcl_Obj *arrayNameObj, Tcl_Obj *valueObj) {
   CallFrame frame, *framePtr = &frame;
   int result;
   Tcl_Obj *ov[4];
 
+  assert(interp); // autoadded
+  assert(arrayNameObj); // autoadded
+
   assert(object);
   Nsf_PushFrameObj(interp, object, framePtr);
 
@@ -17376,6 +18081,9 @@
   CallFrame frame, *framePtr = &frame;
   int flags, result;
 
+  assert(interp); // autoadded
+  assert(name); // autoadded
+
   assert(object);
   flags = withNocomplain ? 0 : TCL_LEAVE_ERR_MSG;
   if (object->nsPtr) {flags |= TCL_NAMESPACE_ONLY;}
@@ -17467,6 +18175,16 @@
   int totalargs = objc + tcd->nr_args - 1;
   char c = *ForwardArgString;
 
+  assert(interp); // autoadded
+  assert(objv); // autoadded
+  assert(ForwardArgObj); // autoadded
+  assert(tcd); // autoadded
+  assert(out); // autoadded
+  assert(freeList); // autoadded
+  assert(inputArg); // autoadded
+  assert(mapvalue); // autoadded
+  assert(outputincr); // autoadded
+
   /*
    * Per default every ForwardArgString from the processed list corresponds to
    * exactly one ForwardArgString in the computed final list.
@@ -17705,6 +18423,10 @@
   NsfObject *object = tcd->object;
   CallFrame frame, *framePtr = &frame;
 
+  assert(tcd); // autoadded
+  assert(interp); // autoadded
+  assert(objv); // autoadded
+
   tcd->object = NULL;
 
   if (unlikely(tcd->verbose)) {
@@ -18054,6 +18776,11 @@
   CONST char *flag;
   assert(obj);
 
+  assert(interp); // autoadded
+  assert(methodName); // autoadded
+  assert(objc); // autoadded
+  assert(objv); // autoadded
+
   if (obj->typePtr == Nsf_OT_listType) {
     if (Tcl_ListObjGetElements(interp, obj, objc, objv) == TCL_OK && *objc > 1) {
       flag = ObjStr(*objv[0]);
@@ -18169,6 +18896,9 @@
 IsRootNamespace(Tcl_Interp *interp, Tcl_Namespace *nsPtr) {
   NsfObjectSystem *osPtr;
 
+  assert(interp); // autoadded
+  assert(nsPtr); // autoadded
+
   for (osPtr = RUNTIME_STATE(interp)->objectSystems; osPtr; osPtr = osPtr->nextPtr) {
     Tcl_Command cmd = osPtr->rootClass->object.id;
     if ((Tcl_Namespace *)((Command *)cmd)->nsPtr == nsPtr) {
@@ -18236,6 +18966,10 @@
 
 static void
 ArgumentResetRefCounts(struct Nsf_Param CONST *pPtr, Tcl_Obj *valueObj) {
+
+  assert(pPtr); // autoadded
+  assert(valueObj); // autoadded
+
   if ((pPtr->flags & NSF_ARG_IS_CONVERTER)) {
     DECR_REF_COUNT2("valueObj", valueObj);
   }
@@ -18250,6 +18984,13 @@
   int objc, i, result;
   Tcl_Obj **ov;
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+  assert(pPtr); // autoadded
+  assert(flags); // autoadded
+  assert(clientData); // autoadded
+  assert(outObjPtr); // autoadded
+
   /*fprintf(stderr, "ArgumentCheckHelper\n");*/
   assert(pPtr->flags & NSF_ARG_MULTIVALUED);
   assert(*flags & NSF_PC_MUST_DECR);
@@ -18420,6 +19161,10 @@
   Nsf_Param CONST *pPtr;
   int i;
 
+  assert(pcPtr); // autoadded
+  assert(interp); // autoadded
+  assert(ifd); // autoadded
+
   for (pPtr = ifd, i = 0; i < nrParams; pPtr++, i++) {
     /*fprintf(stderr, "ArgumentDefaults got for arg %s (req %d, nrArgs %d) %p => %p %p, default '%s' \n",
             pPtr->name, pPtr->flags & NSF_ARG_REQUIRED, pPtr->nrArgs, pPtr,
@@ -18604,6 +19349,10 @@
 
 static Nsf_Param CONST *
 NextParam(Nsf_Param CONST *paramPtr, Nsf_Param CONST *lastParamPtr) {
+
+  assert(paramPtr); // autoadded
+  assert(lastParamPtr); // autoadded
+
   for (; ++paramPtr <= lastParamPtr && *paramPtr->name == '-'; );
   return paramPtr;
 }
@@ -19014,12 +19763,15 @@
  * Begin result setting commands
  * (essentially List*() and support
  ***********************************/
-static int ListVarKeys(Tcl_Interp *interp, Tcl_HashTable *tablePtr, CONST char *pattern) nonnull(1) nonnull(2) nonnull(3);
+static int ListVarKeys(Tcl_Interp *interp, Tcl_HashTable *tablePtr, CONST char *pattern) 
+  nonnull(1);
 
 static int
 ListVarKeys(Tcl_Interp *interp, Tcl_HashTable *tablePtr, CONST char *pattern) {
   Tcl_HashEntry *hPtr;
 
+  assert(interp); // autoadded
+
   if (pattern && NoMetaChars(pattern)) {
     Tcl_Obj *patternObj = Tcl_NewStringObj(pattern, -1);
     INCR_REF_COUNT(patternObj);
@@ -19077,6 +19829,11 @@
 
 static int
 ListProcBody(Tcl_Interp *interp, Proc *procPtr, CONST char *methodName) {
+
+  assert(interp); // autoadded
+  assert(procPtr); // autoadded
+  assert(methodName); // autoadded
+
   Tcl_Obj *methodObj;
   if (procPtr) {
     CONST char *body = ObjStr(procPtr->bodyPtr);
@@ -19096,6 +19853,9 @@
 ListParamDefs(Tcl_Interp *interp, Nsf_Param CONST *paramsPtr, NsfParamsPrintStyle style) {
   Tcl_Obj *listObj;
 
+  assert(interp); // autoadded
+  assert(paramsPtr); // autoadded
+
   switch (style) {
   case NSF_PARAMS_PARAMETER: listObj = ParamDefsFormat(interp, paramsPtr); break;
   case NSF_PARAMS_LIST:      listObj = ParamDefsList(interp, paramsPtr); break;
@@ -19135,6 +19895,8 @@
   Tcl_Obj *listObj;
   Proc *procPtr;
 
+  assert(interp); // autoadded
+
   assert(methodName);
   assert(cmd);
 
@@ -19288,6 +20050,11 @@
 
 static void
 AppendForwardDefinition(Tcl_Interp *interp, Tcl_Obj *listObj, ForwardCmdClientData *tcd) {
+
+  assert(interp); // autoadded
+  assert(listObj); // autoadded
+  assert(tcd); // autoadded
+
   if (tcd->prefix) {
     Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("-prefix", -1));
     Tcl_ListObjAppendElement(interp, listObj, tcd->prefix);
@@ -19332,6 +20099,12 @@
 			     : Tcl_NewStringObj("public", 6));
   }
 
+  assert(interp); // autoadded
+  assert(listObj); // autoadded
+  assert(registerCmdName); // autoadded
+  assert(object); // autoadded
+  assert(methodName); // autoadded
+
   if (!NsfObjectIsClass(object) || withPer_object) {
     Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj("object", 6));
   }
@@ -19354,6 +20127,9 @@
 AppendReturnsClause(Tcl_Interp *interp, Tcl_Obj *listObj, Tcl_Command cmd) {
   NsfParamDefs *paramDefs;
 
+  assert(interp); // autoadded
+  assert(listObj); // autoadded
+
   paramDefs = ParamDefsGet(cmd, NULL);
   if (paramDefs && paramDefs->returns) {
     /* TODO: avoid hard-coding the script-level/NX-specific keyword "returns" */
@@ -19775,8 +20551,9 @@
  */
 
 static int MethodTypeMatches(Tcl_Interp *interp, int methodType, Tcl_Command cmd,
-                  NsfObject *object, CONST char *methodName, int withPer_object,
-		  int *isObject) nonnull(1) nonnull(4) nonnull(5) nonnull(7);
+                             NsfObject *object, CONST char *methodName, int withPer_object,
+                             int *isObject) 
+  nonnull(1) nonnull(5) nonnull(7);
 
 static int
 MethodTypeMatches(Tcl_Interp *interp, int methodType, Tcl_Command cmd,
@@ -19785,6 +20562,9 @@
   Tcl_Command importedCmd;
   Tcl_ObjCmdProc *proc, *resolvedProc;
 
+  assert(interp); // autoadded
+  assert(methodName); // autoadded
+
   assert(isObject);
   proc = Tcl_Command_objProc(cmd);
   importedCmd = GetOriginalCommand(cmd);
@@ -19901,6 +20681,8 @@
   int prefixLength = prefix ? Tcl_DStringLength(prefix) : 0;
   Tcl_Obj *resultObj = Tcl_GetObjResult(interp);
 
+  assert(interp); // autoadded
+
   assert(tablePtr);
 
   if (pattern && NoMetaChars(pattern) && strchr(pattern, ' ') == NULL) {
@@ -20060,13 +20842,17 @@
 }
 
 static int ListChildren(Tcl_Interp *interp, NsfObject *object, CONST char *pattern,
-	     int classesOnly, NsfClass *type) nonnull(1) nonnull(2) nonnull(3) nonnull(5);
+                        int classesOnly, NsfClass *type) 
+  nonnull(1) nonnull(2);
 
 static int
 ListChildren(Tcl_Interp *interp, NsfObject *object, CONST char *pattern,
 	     int classesOnly, NsfClass *type) {
   NsfObject *childObject;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+
   if (object->nsPtr == NULL) {
     return TCL_OK;
   }
@@ -20126,12 +20912,16 @@
 }
 
 static int ListForward(Tcl_Interp *interp, Tcl_HashTable *tablePtr,
-	    CONST char *pattern, int withDefinition) nonnull(1) nonnull(2) nonnull(3);
+	    CONST char *pattern, int withDefinition) 
+  nonnull(1) nonnull(2);
 
 static int
 ListForward(Tcl_Interp *interp, Tcl_HashTable *tablePtr,
 	    CONST char *pattern, int withDefinition) {
 
+  assert(interp); // autoadded
+  assert(tablePtr); // autoadded
+
   if (tablePtr == NULL) {
     return TCL_OK;
   }
@@ -20241,6 +21031,8 @@
   ClientData clientData;
   int rc;
 
+  assert(interp); // autoadded
+
   assert(cl != NULL);
 
   if (cl->super == NULL) {
@@ -20291,6 +21083,11 @@
 
 static CONST char *
 AliasIndex(Tcl_DString *dsPtr, Tcl_Obj *cmdName, CONST char *methodName, int withPer_object) {
+
+  assert(dsPtr); // autoadded
+  assert(cmdName); // autoadded
+  assert(methodName); // autoadded
+
   Tcl_DStringInit(dsPtr);
   Tcl_DStringAppend(dsPtr,  ObjStr(cmdName), -1);
   Tcl_DStringAppend(dsPtr,  ",", 1);
@@ -20310,6 +21107,12 @@
 static int
 AliasAdd(Tcl_Interp *interp, Tcl_Obj *cmdName, CONST char *methodName, int withPer_object,
 	 CONST char *cmd) {
+
+  assert(interp); // autoadded
+  assert(cmdName); // autoadded
+  assert(methodName); // autoadded
+  assert(cmd); // autoadded
+
   Tcl_DString ds, *dsPtr = &ds;
   Tcl_SetVar2Ex(interp, NsfGlobalStrings[NSF_ARRAY_ALIAS],
                 AliasIndex(dsPtr, cmdName, methodName, withPer_object),
@@ -20562,6 +21365,10 @@
 SetBooleanFlag(Tcl_Interp *interp, unsigned int *flagsPtr, unsigned int flag, Tcl_Obj *valueObj, int *flagValue) {
   int result;
 
+  assert(interp); // autoadded
+  assert(valueObj); // autoadded
+  assert(flagValue); // autoadded
+
   assert(flagsPtr);
   result = Tcl_GetBooleanFromObj(interp, valueObj, flagValue);
   if (result != TCL_OK) {
@@ -20588,6 +21395,8 @@
 NsfDebugCompileEpoch(Tcl_Interp *interp) {
   Interp *iPtr = (Interp *) interp;
 
+  assert(interp); // autoadded
+
   Tcl_SetObjResult(interp, Tcl_NewIntObj(iPtr->compileEpoch));
   return TCL_OK;
 }
@@ -20602,6 +21411,9 @@
 static int
 NsfDebugShowObj(Tcl_Interp *interp, Tcl_Obj *objPtr) {
 
+  assert(interp); // autoadded
+  assert(objPtr); // autoadded
+
   fprintf(stderr, "*** obj %p refCount %d type <%s>\n",
 	  objPtr, objPtr->refCount,
 	  objPtr->typePtr ? objPtr->typePtr->name : "");
@@ -20711,6 +21523,9 @@
 
 static int
 NsfProfileClearDataStub(Tcl_Interp *interp) {
+
+  assert(interp); // autoadded
+
 #if defined(NSF_PROFILE)
   NsfProfileClearData(interp);
 #endif
@@ -20724,6 +21539,9 @@
 
 static int
 NsfProfileGetDataStub(Tcl_Interp *interp) {
+
+  assert(interp); // autoadded
+
 #if defined(NSF_PROFILE)
   NsfProfileGetData(interp);
 #endif
@@ -22603,22 +23421,25 @@
        MEM_COUNT_FREE("Tcl_InitHashTable", commandTable);
 
     } else {
-      NsfClasses *subClasses = TransitiveSubClasses(cl), *clPtr;
+      NsfClasses *subClasses = TransitiveSubClasses(cl);
 
-       /* 
-        * The current class is NOT mixed into some other class and is just a
-        * potential superclass of some other classes. In this case, we have to
-        * invalidate cached parameters in subclasses.
-        */
-      for (clPtr = subClasses; clPtr; clPtr = clPtr->nextPtr) {
-        NsfClass *subClass = clPtr->cl;
-        
-        if (subClass->parsedParamPtr) {
-          ParsedParamFree(subClass->parsedParamPtr);
-          subClass->parsedParamPtr = NULL;
+      if (subClasses != NULL) {
+        NsfClasses *clPtr;
+        /* 
+         * The current class is NOT mixed into some other class and is just a
+         * potential superclass of some other classes. In this case, we have to
+         * invalidate cached parameters in subclasses.
+         */
+        for (clPtr = subClasses; clPtr; clPtr = clPtr->nextPtr) {
+          NsfClass *subClass = clPtr->cl;
+          
+          if (subClass->parsedParamPtr) {
+            ParsedParamFree(subClass->parsedParamPtr);
+            subClass->parsedParamPtr = NULL;
+          }
         }
+        NsfClassListFree(subClasses);
       }
-      NsfClassListFree(subClasses);
     }
   }
 
@@ -23019,7 +23840,7 @@
         }
       }
       if (clopt->classMixins) {
-        RemoveFromClassMixinsOf(cl->object.id, clopt->classMixins);
+        if (clopt->classMixins) RemoveFromClassMixinsOf(cl->object.id, clopt->classMixins);
         CmdListFree(&clopt->classMixins, GuardDel);
       }
 
@@ -23070,8 +23891,10 @@
 
       if (FiltersDefined(interp) > 0) {
 	NsfClasses *subClasses = TransitiveSubClasses(cl);
-	FilterInvalidateObjOrders(interp, cl, subClasses);
-	NsfClassListFree(subClasses);
+        if (subClasses) {
+          FilterInvalidateObjOrders(interp, cl, subClasses);
+          NsfClassListFree(subClasses);
+        }
       }
 
       clopt->classFilters = newFilterCmdList;
@@ -23295,6 +24118,11 @@
 NsfVarImport(Tcl_Interp *interp, NsfObject *object, const char *cmdName, int objc, Tcl_Obj *CONST objv[]) {
   int i, result = TCL_OK;
 
+  assert(interp); // autoadded
+  assert(object); // autoadded
+  assert(cmdName); // autoadded
+  assert(objv); // autoadded
+
   for (i = 0; i < objc && result == TCL_OK; i++) {
     Tcl_Obj **ov;
     int oc;
@@ -23385,6 +24213,9 @@
 
 static void
 ParamUpdateString(Tcl_Obj *objPtr) {
+
+  assert(objPtr); // autoadded
+
     Tcl_Panic("%s of type %s should not be called", "updateStringProc",
 	    objPtr->typePtr->name);
 }
@@ -23395,6 +24226,8 @@
 static void
 ParamDupInteralRep(Tcl_Obj *srcPtr, Tcl_Obj *UNUSED(dupPtr)) {
 
+  assert(srcPtr); // autoadded
+
   Tcl_Panic("%s of type %s should not be called", "dupStringProc",
 	    srcPtr->typePtr->name);
 }
@@ -23537,6 +24370,10 @@
   int result;
   NsfClass *class;
 
+  assert(interp); // autoadded
+  assert(procNameObj); // autoadded
+  assert(parsedParamPtr); // autoadded
+
   assert(object);
   if ((object->flags & NSF_HAS_PER_OBJECT_SLOTS)
       || (object->opt && object->opt->objMixins)
@@ -23810,6 +24647,8 @@
 GetSlotObject(Tcl_Interp *interp, Tcl_Obj *slotObj) {
   NsfObject *slotObject = NULL;
 
+  assert(interp); // autoadded
+
   assert(slotObj != NULL);
   GetObjectFromObj(interp, slotObj, &slotObject);
   if (unlikely(slotObject == NULL)) {
@@ -25035,8 +25874,10 @@
       }
       GuardAdd(h, guardObj);
 
-      FilterInvalidateObjOrders(interp, cl, subClasses);
-      NsfClassListFree(subClasses);
+      if (subClasses) {
+        FilterInvalidateObjOrders(interp, cl, subClasses);
+        NsfClassListFree(subClasses);
+      }
 
       return TCL_OK;
     }
@@ -25504,7 +26345,8 @@
 			int withSource, CONST char *pattern,
 			int methodType, int withCallprotection,
 			int withPath, Tcl_HashTable *dups,
-			NsfObject *object, int withPer_object) nonnull(1) nonnull(2) nonnull(4) nonnull(8) nonnull(9);
+			NsfObject *object, int withPer_object) 
+  nonnull(1) nonnull(8) nonnull(9);
 
 static int
 ListMethodKeysClassList(Tcl_Interp *interp, NsfClasses *classList,
@@ -25514,6 +26356,10 @@
 			NsfObject *object, int withPer_object) {
   NsfClasses *pl;
 
+  assert(interp); // autoadded
+  assert(dups); // autoadded
+  assert(object); // autoadded
+
   /* append method keys from inheritance order */
   for (pl = classList; pl; pl = pl->nextPtr) {
     Tcl_HashTable *cmdTablePtr = Tcl_Namespace_cmdTablePtr(pl->cl->nsPtr);
@@ -25618,6 +26464,8 @@
   Tcl_HashTable slotTable;
 
   precendenceList = ComputePrecedenceList(interp, object, NULL /* pattern*/, 1, 1);
+  assert(precendenceList);
+
   if (withSource == 0) {withSource = 1;}
 
   Tcl_InitHashTable(&slotTable, TCL_STRING_KEYS);
@@ -25858,7 +26706,7 @@
   for (pl = precedenceList; pl; pl = pl->nextPtr) {
     Tcl_ListObjAppendElement(interp, resultObj, pl->cl->object.cmdName);
   }
-  NsfClassListFree(precedenceList);
+  if (precedenceList) NsfClassListFree(precedenceList);
 
   Tcl_SetObjResult(interp, resultObj);
   return TCL_OK;
@@ -25982,8 +26830,8 @@
     }
   }
 
-  NsfClassListFree(mixinClasses);
-  NsfClassListFree(checkList);
+  if (mixinClasses) NsfClassListFree(mixinClasses);
+  if (checkList) NsfClassListFree(checkList);
 
   Tcl_SetObjResult(interp, resultObj);
   return TCL_OK;
@@ -26008,14 +26856,18 @@
  */
 
 static Tcl_Obj * InstancesFromClassList(Tcl_Interp *interp, NsfClasses *subClasses,
-		       CONST char *pattern, NsfObject *matchObject) nonnull(1) nonnull(2) nonnull(3) nonnull(4);
+		       CONST char *pattern, NsfObject *matchObject) 
+  nonnull(1) nonnull(2);
 
 static Tcl_Obj *
 InstancesFromClassList(Tcl_Interp *interp, NsfClasses *subClasses,
 		       CONST char *pattern, NsfObject *matchObject) {
   NsfClasses *clPtr;
   Tcl_Obj *resultObj = Tcl_NewObj();
 
+  assert(interp); // autoadded
+  assert(subClasses); // autoadded
+
   for (clPtr = subClasses; clPtr; clPtr = clPtr->nextPtr) {
     Tcl_HashTable *tablePtr = &clPtr->cl->instances;
     Tcl_HashEntry *hPtr;
@@ -26134,8 +26986,8 @@
 				   withSource, pattern,
 				   AggregatedMethodType(withMethodtype), withCallprotection,
 				   withPath, dups, &class->object, 0);
-    NsfClassListFree(checkList);
-    NsfClassListFree(mixinClasses);
+    if (checkList) NsfClassListFree(checkList);
+    if (mixinClasses) NsfClassListFree(mixinClasses);
 
     result = ListMethodKeysClassList(interp, PrecedenceOrder(class),
 				     withSource, pattern,
@@ -26186,8 +27038,8 @@
       AppendMatchingElement(interp, resultObj, clPtr->cl->object.cmdName, patternString);
     }
 
-    NsfClassListFree(checkList);
-    NsfClassListFree(mixinClasses);
+    if (checkList) NsfClassListFree(checkList);
+    if (mixinClasses) NsfClassListFree(mixinClasses);
 
   } else if (withClosure) {
     Tcl_HashTable objTable, *commandTable = &objTable;
@@ -26250,12 +27102,12 @@
   }
 
   if (opt && !withClosure) {
-    if (perClass) {
+    if (perClass && opt->isClassMixinOf) {
       rc = AppendMatchingElementsFromCmdList(interp, opt->isClassMixinOf, resultObj,
 					     patternString, patternObj);
       if (rc && patternObj) {goto finished;}
     }
-    if (perObject) {
+    if (perObject && opt->isObjectMixinOf) {
       rc = AppendMatchingElementsFromCmdList(interp, opt->isObjectMixinOf, resultObj,
 					     patternString, patternObj);
     }
@@ -26323,8 +27175,8 @@
     for (clPtr = intrinsicClasses->nextPtr; clPtr; clPtr = clPtr->nextPtr) {
       NsfClassListAdd(&precedenceList, clPtr->cl, NULL);
     }
-    NsfClassListFree(checkList);
-    NsfClassListFree(mixinClasses);
+    if (checkList) NsfClassListFree(checkList);
+    if (mixinClasses) NsfClassListFree(mixinClasses);
 
   } else {
     NsfClassListAdd(&precedenceList, class, NULL);
@@ -26348,7 +27200,7 @@
   Tcl_DeleteHashTable(&slotTable);
   MEM_COUNT_FREE("Tcl_InitHashTable", &slotTable);
 
-  NsfClassListFree(precedenceList);
+  if (precedenceList) NsfClassListFree(precedenceList);
   Tcl_SetObjResult(interp, listObj);
 
   return TCL_OK;
@@ -26369,7 +27221,7 @@
     NsfClasses *subClasses = TransitiveSubClasses(class);
     rc = AppendMatchingElementsFromClasses(interp, subClasses ? subClasses->nextPtr : NULL,
 					   patternString, patternObj);
-    NsfClassListFree(subClasses);
+    if (subClasses) NsfClassListFree(subClasses);
   } else {
     rc = AppendMatchingElementsFromClasses(interp, class->sub, patternString, patternObj);
   }
@@ -27054,6 +27906,8 @@
   static int stubsInitialized = 0;
 #endif
 
+  assert(interp); // autoadded
+
 #if 0
   ProfilerStart("profiler");
 #endif
@@ -27343,6 +28197,9 @@
 
 EXTERN int
 Nsf_SafeInit(Tcl_Interp *interp) {
+
+  assert(interp); // autoadded
+
   /*** dummy for now **/
   return Nsf_Init(interp);
 }