Index: generic/nsf.c
===================================================================
diff -u -r042715c36e6ca53a9712922a03de958476258e02 -r3c3b37a34bbdbf3b0b5e2300bb577bc9b6fd40cc
--- generic/nsf.c	(.../nsf.c)	(revision 042715c36e6ca53a9712922a03de958476258e02)
+++ generic/nsf.c	(.../nsf.c)	(revision 3c3b37a34bbdbf3b0b5e2300bb577bc9b6fd40cc)
@@ -1673,17 +1673,11 @@
  */
 
 enum colors { WHITE, GRAY, BLACK };
+typedef enum { SUPER_CLASSES, SUB_CLASSES } ClassDirection;
 
-static NsfClasses *
-Super(NsfClass *cl) { return cl->super; }
-
-static NsfClasses *
-Sub(NsfClass *cl) { return cl->sub; }
-
 static int
-TopoSort(NsfClass *cl, NsfClass *baseClass, NsfClasses *(*next)(NsfClass *)) {
-  /*NsfClasses *sl = (*next)(cl);*/
-  NsfClasses *sl = next == Super ? cl->super : cl->sub;
+TopoSort(NsfClass *cl, NsfClass *baseClass, ClassDirection direction) {
+  NsfClasses *sl = direction == SUPER_CLASSES ? cl->super : cl->sub;
   NsfClasses *pl;
 
   /*
@@ -1696,7 +1690,7 @@
   for (; sl; sl = sl->nextPtr) {
     NsfClass *sc = sl->cl;
     if (sc->color == GRAY) { cl->color = WHITE; return 0; }
-    if (sc->color == WHITE && !TopoSort(sc, baseClass, next)) {
+    if (sc->color == WHITE && !TopoSort(sc, baseClass, direction)) {
       cl->color = WHITE;
       if (cl == baseClass) {
         register NsfClasses *pc;
@@ -1717,19 +1711,19 @@
   return 1;
 }
 
-static NsfClasses *
-TopoOrder(NsfClass *cl, NsfClasses *(*next)(NsfClass *)) {
-  if (TopoSort(cl, cl, next)) {
+NSF_INLINE static NsfClasses *
+TopoOrder(NsfClass *cl, ClassDirection direction) {
+  if (TopoSort(cl, cl, direction)) {
     return cl->order;
   }
   NsfClassListFree(cl->order);
   return cl->order = NULL;
 }
 
 NSF_INLINE static NsfClasses *
-ComputeOrder(NsfClass *cl, NsfClasses *order, NsfClasses *(*direction)(NsfClass *)) {
-  if (likely(order != NULL)) {
-    return order;
+ComputeOrder(NsfClass *cl, ClassDirection direction) {
+  if (likely(cl->order != NULL)) {
+    return cl->order;
   }
   return cl->order = TopoOrder(cl, direction);
 }
@@ -1740,7 +1734,7 @@
 
   NsfClassListFree(cl->order);
   cl->order = NULL;
-  pc = ComputeOrder(cl, cl->order, Sub);
+  pc = ComputeOrder(cl, SUB_CLASSES);
 
   /*
    * ordering doesn't matter here - we're just using TopoSort
@@ -2258,7 +2252,7 @@
 static NsfClass *
 SearchCMethod(/*@notnull@*/ NsfClass *cl, CONST char *methodName, Tcl_Command *cmdPtr) {
   assert(cl);
-  return SearchPLMethod0(ComputeOrder(cl, cl->order, Super), methodName, cmdPtr);
+  return SearchPLMethod0(ComputeOrder(cl, SUPER_CLASSES), methodName, cmdPtr);
 }
 
 /*
@@ -2282,7 +2276,7 @@
 SearchSimpleCMethod(Tcl_Interp *interp, /*@notnull@*/ NsfClass *cl,
 		    Tcl_Obj *methodObj, Tcl_Command *cmdPtr) {
   assert(cl);
-  return SearchPLMethod0(ComputeOrder(cl, cl->order, Super), ObjStr(methodObj), cmdPtr);
+  return SearchPLMethod0(ComputeOrder(cl, SUPER_CLASSES), ObjStr(methodObj), cmdPtr);
 }
 
 /*
@@ -2312,7 +2306,7 @@
 
   assert(cl);
 
-  for (pl = ComputeOrder(cl, cl->order, Super); pl;  pl = pl->nextPtr) {
+  for (pl = ComputeOrder(cl, SUPER_CLASSES); pl;  pl = pl->nextPtr) {
     NsfObject *regObject, *defObject;
     Tcl_Command cmd;
 
@@ -5360,7 +5354,7 @@
 
   if (result != TCL_ERROR && checkoptions & CHECK_CLINVAR) {
     NsfClasses *clPtr;
-    clPtr = ComputeOrder(object->cl, object->cl->order, Super);
+    clPtr = ComputeOrder(object->cl, SUPER_CLASSES);
     while (clPtr && result != TCL_ERROR) {
       NsfAssertionStore *aStore = (clPtr->cl->opt) ? clPtr->cl->opt->assertions : NULL;
       if (aStore) {
@@ -5513,7 +5507,7 @@
     NsfClass *mCl = NsfGetClassFromCmdPtr(m->cmdPtr);
 
     if (mCl) {
-      for (pl = ComputeOrder(mCl, mCl->order, Super); pl; pl = pl->nextPtr) {
+      for (pl = ComputeOrder(mCl, SUPER_CLASSES); pl; pl = pl->nextPtr) {
         if ((pl->cl->object.flags & NSF_IS_ROOT_CLASS) == 0) {
           NsfClassOpt *opt = pl->cl->opt;
 
@@ -5588,7 +5582,7 @@
 			      NsfClasses **classList, NsfClasses **checkList) {
   NsfClasses *pl;
 
-  for (pl = ComputeOrder(cl, cl->order, Super); pl; pl = pl->nextPtr) {
+  for (pl = ComputeOrder(cl, SUPER_CLASSES); pl; pl = pl->nextPtr) {
     NsfClassOpt *clopt = pl->cl->opt;
     if (clopt && clopt->classmixins) {
       MixinComputeOrderFullList(interp, &clopt->classmixins,
@@ -5671,7 +5665,7 @@
      */
     if (checker == NULL) {
       /* check object->cl hierachy */
-      checker = NsfClassListFind(ComputeOrder(object->cl, object->cl->order, Super), cl);
+      checker = NsfClassListFind(ComputeOrder(object->cl, SUPER_CLASSES), cl);
       /*
        * if checker is set, it was found in the class hierarchy and it is ignored
        */
@@ -6502,7 +6496,7 @@
   /*
    * Iterate over the subclass hierarchy.
    */
-  for (clPtr = ComputeOrder(cl, cl->order, Sub); clPtr; clPtr = clPtr->nextPtr) {
+  for (clPtr = ComputeOrder(cl, SUB_CLASSES); clPtr; clPtr = clPtr->nextPtr) {
     Tcl_HashSearch hSrch;
     Tcl_HashEntry *hPtr;
 
@@ -6629,7 +6623,7 @@
     }
   }
 
-  pcl = ComputeOrder(object->cl, object->cl->order, Super);
+  pcl = ComputeOrder(object->cl, SUPER_CLASSES);
   for (; pcl; pcl = pcl->nextPtr) {
     if (withRootClass == 0 && pcl->cl->object.flags & NSF_IS_ROOT_CLASS) {
       continue;
@@ -7160,7 +7154,7 @@
 
   if (!guardAdded) {
     /* search per-class filters */
-    for (pl = ComputeOrder(object->cl, object->cl->order, Super); !guardAdded && pl; pl = pl->nextPtr) {
+    for (pl = ComputeOrder(object->cl, SUPER_CLASSES); !guardAdded && pl; pl = pl->nextPtr) {
       NsfClassOpt *clopt = pl->cl->opt;
       if (clopt) {
         guardAdded = GuardAddFromDefinitionList(dest, filterCmd,
@@ -7318,7 +7312,7 @@
   NsfClasses *saved = cl->order, *clPtr, *savePtr;
 
   cl->order = NULL;
-  savePtr = clPtr = ComputeOrder(cl, cl->order, Sub);
+  savePtr = clPtr = ComputeOrder(cl, SUB_CLASSES);
   cl->order = saved;
 
   for ( ; clPtr; clPtr = clPtr->nextPtr) {
@@ -7359,7 +7353,7 @@
     cl, ClassName(cl),
     removeClass, ObjStr(removeClass->object.cmdName));*/
 
-  for (clPtr = ComputeOrder(cl, cl->order, Sub); clPtr; clPtr = clPtr->nextPtr) {
+  for (clPtr = ComputeOrder(cl, SUB_CLASSES); clPtr; clPtr = clPtr->nextPtr) {
     Tcl_HashSearch hSrch;
     Tcl_HashEntry *hPtr = &clPtr->cl->instances ?
       Tcl_FirstHashEntry(&clPtr->cl->instances, &hSrch) : NULL;
@@ -7491,7 +7485,7 @@
 
     /* if we have a filter class -> search up the inheritance hierarchy*/
     if (fcl) {
-      pl = ComputeOrder(fcl, fcl->order, Super);
+      pl = ComputeOrder(fcl, SUPER_CLASSES);
       if (pl && pl->nextPtr) {
         /* don't search on the start class again */
         pl = pl->nextPtr;
@@ -7548,7 +7542,7 @@
     FilterComputeOrderFullList(interp, &object->opt->filters, &filterList);
   }
   /* append per-class filters */
-  for (pl = ComputeOrder(object->cl, object->cl->order, Super); pl; pl = pl->nextPtr) {
+  for (pl = ComputeOrder(object->cl, SUPER_CLASSES); pl; pl = pl->nextPtr) {
     NsfClassOpt *clopt = pl->cl->opt;
     if (clopt && clopt->classfilters) {
       FilterComputeOrderFullList(interp, &clopt->classfilters, &filterList);
@@ -7661,7 +7655,7 @@
   }
 
   /* search per-class filters */
-  for (pl = ComputeOrder(object->cl, object->cl->order, Super); pl; pl = pl->nextPtr) {
+  for (pl = ComputeOrder(object->cl, SUPER_CLASSES); pl; pl = pl->nextPtr) {
     NsfClassOpt *opt = pl->cl->opt;
     if (opt && opt->classfilters) {
       if (CmdListFindCmdInList(cmd, opt->classfilters)) {
@@ -7735,7 +7729,7 @@
   int reversed = 0;
   int i, j;
 
-  filterCheck = ComputeOrder(cl, cl->order, Super);
+  filterCheck = ComputeOrder(cl, SUPER_CLASSES);
   /*
    * we have to remove all dependent superclass filter referenced
    * by class or one of its subclasses
@@ -7770,7 +7764,7 @@
   for (i = 0; i < oc; i++) {
     if (reversed) break;
     for (j = i+1; j < oc; j++) {
-      NsfClasses *dl = ComputeOrder(scl[j], scl[j]->order, Super);
+      NsfClasses *dl = ComputeOrder(scl[j], SUPER_CLASSES);
       if (reversed) break;
       dl = NsfClassListFind(dl, scl[i]);
       if (dl) reversed = 1;
@@ -7812,7 +7806,7 @@
   FREE(NsfClass**, scl);
   FlushPrecedencesOnSubclasses(cl);
 
-  if (!ComputeOrder(cl, cl->order, Super)) {
+  if (!ComputeOrder(cl, SUPER_CLASSES)) {
     NsfClasses *l;
     /*
      * cycle in the superclass graph, backtrack
@@ -9385,9 +9379,7 @@
   NsfClasses *p;
 
   /*fprintf(stderr, "NsfFindClassMethod %s %s\n", ClassName(cl), methodName);*/
-  if (cl->order == NULL) cl->order = TopoOrder(cl, Super);
-
-  for(p = cl->order; p; p = p->nextPtr) {
+  for(p = ComputeOrder(cl, SUPER_CLASSES); p; p = p->nextPtr) {
     NsfClass *currentClass = p->cl;
     Tcl_Namespace *nsPtr = currentClass->object.nsPtr;
 
@@ -9670,7 +9662,7 @@
       /* check for a method inherited from a class */
       NsfClass *currentClass = object->cl;
       if (unlikely(currentClass->order == NULL)) {
-	currentClass->order = TopoOrder(currentClass, Super);
+	currentClass->order = TopoOrder(currentClass, SUPER_CLASSES);
       }
       if (unlikely(flags & NSF_CM_SYSTEM_METHOD)) {
 	NsfClasses *classList = currentClass->order;
@@ -9680,7 +9672,7 @@
 	for (; classList;  classList = classList->nextPtr) {
 	  if (IsBaseClass(classList->cl)) {break;}
 	}
-	cl = SearchPLMethod(classList, methodName, &cmd, NSF_CMD_CALL_PROTECTED_METHOD);
+	cl = SearchPLMethod(classList, methodName, &cmd, NSF_CMD_CALL_PRIVATE_METHOD);
       } else {
 	cl = SearchPLMethod(currentClass->order, methodName, &cmd, NSF_CMD_CALL_PRIVATE_METHOD);
       }
@@ -12550,7 +12542,7 @@
    *methodNamePtr, *clPtr, ClassName((*clPtr)), *cmdPtr, cscPtr->flags); */
 
   if (!*cmdPtr) {
-    NsfClasses *pl = ComputeOrder(object->cl, object->cl->order, Super);
+    NsfClasses *pl = ComputeOrder(object->cl, SUPER_CLASSES);
     NsfClass *cl = *clPtr;
 
     if (cl) {
@@ -13035,6 +13027,7 @@
   switch (level) {
   case CALLING_LEVEL: NsfCallStackFindLastInvocation(interp, 1, &framePtr); break;
   case ACTIVE_LEVEL:  NsfCallStackFindActiveFrame(interp,    1, &framePtr); break;
+  default: framePtr = NULL; /* silence compiler */
   }
 
   if (framePtr) {
@@ -14100,7 +14093,7 @@
   }
 
   /* is the class a subclass of a meta-class? */
-  for (pl = ComputeOrder(cl, cl->order, Super); pl; pl = pl->nextPtr) {
+  for (pl = ComputeOrder(cl, SUPER_CLASSES); pl; pl = pl->nextPtr) {
     if (HasMetaProperty(pl->cl)) {
       return 1;
     }
@@ -14137,7 +14130,7 @@
   assert(cl && subcl);
 
   if (cl != subcl) {
-    return NsfClassListFind(ComputeOrder(subcl, subcl->order, Super), cl) != NULL;
+    return NsfClassListFind(ComputeOrder(subcl, SUPER_CLASSES), cl) != NULL;
   }
   return 1;
 }
@@ -17025,7 +17018,7 @@
   }
 
   if (withClosure) {
-    NsfClasses *pl = ComputeOrder(cl, cl->order, Super);
+    NsfClasses *pl = ComputeOrder(cl, SUPER_CLASSES);
     if (pl) pl=pl->nextPtr;
     rc = AppendMatchingElementsFromClasses(interp, pl, patternString, matchObject);
   } else {
@@ -21456,7 +21449,7 @@
   }
 
   /* append method keys from inheritance order */
-  for (pl = ComputeOrder(object->cl, object->cl->order, Super); pl; pl = pl->nextPtr) {
+  for (pl = ComputeOrder(object->cl, SUPER_CLASSES); pl; pl = pl->nextPtr) {
     Tcl_HashTable *cmdTablePtr = Tcl_Namespace_cmdTablePtr(pl->cl->nsPtr);
     if (!MethodSourceMatches(withSource, pl->cl, NULL)) continue;
     ListMethodKeys(interp, cmdTablePtr, NULL, pattern, methodType,
@@ -21735,7 +21728,7 @@
   Tcl_Obj *resultObj;
 
   resultObj = Tcl_NewObj();
-  intrinsic = ComputeOrder(cl, cl->order, Super);
+  intrinsic = ComputeOrder(cl, SUPER_CLASSES);
 
   NsfClassListAddPerClassMixins(interp, cl, &mixinClasses, &checkList);
   for (pl = mixinClasses; pl; pl = pl->nextPtr) {
@@ -22079,7 +22072,7 @@
   Tcl_HashTable slotTable;
 
   Tcl_ResetResult(interp);
-  intrinsic = ComputeOrder(class, class->order, Super);
+  intrinsic = ComputeOrder(class, SUPER_CLASSES);
 
   if (withClosure) {
     NsfClasses *checkList = NULL, *mixinClasses = NULL;
@@ -22145,7 +22138,7 @@
   if (withClosure) {
     NsfClasses *saved = class->order, *subclasses;
     class->order = NULL;
-    subclasses = ComputeOrder(class, class->order, Sub);
+    subclasses = ComputeOrder(class, SUB_CLASSES);
     class->order = saved;
     rc = AppendMatchingElementsFromClasses(interp, subclasses ? subclasses->nextPtr : NULL,
 					   patternString, patternObj);