Index: generic/gentclAPI.tcl
===================================================================
diff -u -rf209c50ea8cb651d0dea25206301e45202217797 -rce552d49dd2f135f21cefb4b88c9bf1357881c2e
--- generic/gentclAPI.tcl	(.../gentclAPI.tcl)	(revision f209c50ea8cb651d0dea25206301e45202217797)
+++ generic/gentclAPI.tcl	(.../gentclAPI.tcl)	(revision ce552d49dd2f135f21cefb4b88c9bf1357881c2e)
@@ -1,7 +1,4 @@
 
-
-
-
 # objectMethod
 # classMethod
 # infoObjectMethod
@@ -53,11 +50,11 @@
       return TCL_OK;
     }
           }]
-          append post [subst -nocommands {
-    if (${varName}Obj) {
-      Tcl_SetObjResult(interp, returnCode ? ${varName}Obj->cmdName : XOTclGlobalObjects[XOTE_EMPTY]);
-    }
-          }]
+#          append post [subst -nocommands {
+#    if (${varName}Obj) {
+#      Tcl_SetObjResult(interp, returnCode ? ${varName}Obj->cmdName : XOTclGlobalObjects[XOTE_EMPTY]);
+#    }
+#          }]
         }
       }
     }
@@ -73,12 +70,13 @@
 
 
 proc genifds {} {
+  set stubDecls ""
   set decls ""
   set enums [list]
   set ifds [list]
   foreach key [lsort [array names ::definitions]] {
     array set d $::definitions($key)
-    append decls "static int $d(stub)$::objCmdProc\n"
+    append stubDecls "static int $d(stub)$::objCmdProc\n"
     lappend enums $d(idx)
     lappend ifds "{\"$d(methodName)\", $d(stub), {\n  [genifd $d(argDefintions)]}\n}"
 
@@ -120,6 +118,7 @@
 static int getMatchObject3(Tcl_Interp *interp, Tcl_Obj *patternObj,  parseContext *pc,
                            XOTclObject **matchObject, char **pattern);
   }
+  puts $stubDecls
   puts $decls
   set enumString [join $enums ",\n "]
   puts "enum {\n $enumString\n} XOTclMethods;\n"
@@ -192,6 +191,32 @@
   {-argName "filter" -required 1}
 }
 
+infoClassMethod instforward XOTclClassInfoInstforwardMethod {
+  {-argName "class"  -required 1 -nrargs 0 -type class}
+  {-argName "-definition"}
+  {-argName "methodName" -required 1}
+}
 
+infoClassMethod instinvar XOTclClassInfoInstinvarMethod {
+  {-argName "class"  -required 1 -nrargs 0 -type class}
+}
 
+infoClassMethod instmixin XOTclClassInfoInstmixinMethod {
+  {-argName "class"  -required 1 -nrargs 0 -type class}
+  {-argName "-closure"}
+  {-argName "-guards"}
+  {-argName "pattern" -type objpattern}
+}
+
+infoClassMethod instmixinguard XOTclClassInfoInstmixinguardMethod {
+  {-argName "class"  -required 1 -nrargs 0 -type class}
+  {-argName "mixin" -required 1}
+}
+
+infoClassMethod instmixinof XOTclClassInfoInstmixinofMethod {
+  {-argName "class"  -required 1 -nrargs 0 -type class}
+  {-argName "-closure"}
+  {-argName "pattern" -type objpattern}}
+
+
 genifds
\ No newline at end of file
Index: generic/tclAPI.h
===================================================================
diff -u -rf209c50ea8cb651d0dea25206301e45202217797 -rce552d49dd2f135f21cefb4b88c9bf1357881c2e
--- generic/tclAPI.h	(.../tclAPI.h)	(revision f209c50ea8cb651d0dea25206301e45202217797)
+++ generic/tclAPI.h	(.../tclAPI.h)	(revision ce552d49dd2f135f21cefb4b88c9bf1357881c2e)
@@ -11,21 +11,32 @@
                            XOTclObject **matchObject, char **pattern);
   
 static int XOTclClassInfoHeritageMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
-static int XOTclClassInfoHeritageMethod(Tcl_Interp *interp, XOTclClass * class, char * pattern);
 static int XOTclClassInfoInstancesMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
-static int XOTclClassInfoInstancesMethod(Tcl_Interp *interp, XOTclClass * class, int withClosure, char *patternString, XOTclObject *patternObj);
 static int XOTclClassInfoInstargsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
-static int XOTclClassInfoInstargsMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName);
 static int XOTclClassInfoInstbodyMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
-static int XOTclClassInfoInstbodyMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName);
 static int XOTclClassInfoInstcommandsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
-static int XOTclClassInfoInstcommandsMethod(Tcl_Interp *interp, XOTclClass * class, char * pattern);
 static int XOTclClassInfoInstdefaultMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
-static int XOTclClassInfoInstdefaultMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName, char * arg, Tcl_Obj * var);
 static int XOTclClassInfoInstfilterMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
-static int XOTclClassInfoInstfilterMethod(Tcl_Interp *interp, XOTclClass * class, int withGuards, char * pattern);
 static int XOTclClassInfoInstfilterguardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
+static int XOTclClassInfoInstforwardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
+static int XOTclClassInfoInstinvarMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
+static int XOTclClassInfoInstmixinMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
+static int XOTclClassInfoInstmixinguardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
+static int XOTclClassInfoInstmixinofMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []);
+
+static int XOTclClassInfoHeritageMethod(Tcl_Interp *interp, XOTclClass * class, char * pattern);
+static int XOTclClassInfoInstancesMethod(Tcl_Interp *interp, XOTclClass * class, int withClosure, char *patternString, XOTclObject *patternObj);
+static int XOTclClassInfoInstargsMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName);
+static int XOTclClassInfoInstbodyMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName);
+static int XOTclClassInfoInstcommandsMethod(Tcl_Interp *interp, XOTclClass * class, char * pattern);
+static int XOTclClassInfoInstdefaultMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName, char * arg, Tcl_Obj * var);
+static int XOTclClassInfoInstfilterMethod(Tcl_Interp *interp, XOTclClass * class, int withGuards, char * pattern);
 static int XOTclClassInfoInstfilterguardMethod(Tcl_Interp *interp, XOTclClass * class, char * filter);
+static int XOTclClassInfoInstforwardMethod(Tcl_Interp *interp, XOTclClass * class, int withDefinition, char * methodName);
+static int XOTclClassInfoInstinvarMethod(Tcl_Interp *interp, XOTclClass * class);
+static int XOTclClassInfoInstmixinMethod(Tcl_Interp *interp, XOTclClass * class, int withClosure, int withGuards, char *patternString, XOTclObject *patternObj);
+static int XOTclClassInfoInstmixinguardMethod(Tcl_Interp *interp, XOTclClass * class, char * mixin);
+static int XOTclClassInfoInstmixinofMethod(Tcl_Interp *interp, XOTclClass * class, int withClosure, char *patternString, XOTclObject *patternObj);
 
 enum {
  XOTclClassInfoHeritageMethodIdx,
@@ -35,7 +46,12 @@
  XOTclClassInfoInstcommandsMethodIdx,
  XOTclClassInfoInstdefaultMethodIdx,
  XOTclClassInfoInstfilterMethodIdx,
- XOTclClassInfoInstfilterguardMethodIdx
+ XOTclClassInfoInstfilterguardMethodIdx,
+ XOTclClassInfoInstforwardMethodIdx,
+ XOTclClassInfoInstinvarMethodIdx,
+ XOTclClassInfoInstmixinMethodIdx,
+ XOTclClassInfoInstmixinguardMethodIdx,
+ XOTclClassInfoInstmixinofMethodIdx
 } XOTclMethods;
 
 
@@ -64,18 +80,13 @@
     char *patternString = NULL;
     XOTclObject *patternObj = NULL;
     Tcl_Obj * pattern = (Tcl_Obj *)pc.clientData[2];
-    int returnCode;
 
     if (getMatchObject3(interp, pattern,  &pc, &patternObj, &patternString) == -1) {
       return TCL_OK;
     }
           
-    returnCode = XOTclClassInfoInstancesMethod(interp, class, withClosure, patternString, patternObj);
+    return XOTclClassInfoInstancesMethod(interp, class, withClosure, patternString, patternObj);
 
-    if (patternObj) {
-      Tcl_SetObjResult(interp, returnCode ? patternObj->cmdName : XOTclGlobalObjects[XOTE_EMPTY]);
-    }
-    return TCL_OK;
   }
 }
   
@@ -166,6 +177,91 @@
   }
 }
   
+static int
+XOTclClassInfoInstforwardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
+  parseContext pc;
+  if (parse2(clientData, interp, objc, objv, XOTclClassInfoInstforwardMethodIdx, &pc) != TCL_OK) {
+    return TCL_ERROR;
+  } else {
+    XOTclClass * class = (XOTclClass *)pc.clientData[0];
+    int withDefinition = (int)pc.clientData[1];
+    char * methodName = (char *)pc.clientData[2];
+
+    return XOTclClassInfoInstforwardMethod(interp, class, withDefinition, methodName);
+
+  }
+}
+  
+static int
+XOTclClassInfoInstinvarMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
+  parseContext pc;
+  if (parse2(clientData, interp, objc, objv, XOTclClassInfoInstinvarMethodIdx, &pc) != TCL_OK) {
+    return TCL_ERROR;
+  } else {
+    XOTclClass * class = (XOTclClass *)pc.clientData[0];
+
+    return XOTclClassInfoInstinvarMethod(interp, class);
+
+  }
+}
+  
+static int
+XOTclClassInfoInstmixinMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
+  parseContext pc;
+  if (parse2(clientData, interp, objc, objv, XOTclClassInfoInstmixinMethodIdx, &pc) != TCL_OK) {
+    return TCL_ERROR;
+  } else {
+    XOTclClass * class = (XOTclClass *)pc.clientData[0];
+    int withClosure = (int)pc.clientData[1];
+    int withGuards = (int)pc.clientData[2];
+    char *patternString = NULL;
+    XOTclObject *patternObj = NULL;
+    Tcl_Obj * pattern = (Tcl_Obj *)pc.clientData[3];
+
+    if (getMatchObject3(interp, pattern,  &pc, &patternObj, &patternString) == -1) {
+      return TCL_OK;
+    }
+          
+    return XOTclClassInfoInstmixinMethod(interp, class, withClosure, withGuards, patternString, patternObj);
+
+  }
+}
+  
+static int
+XOTclClassInfoInstmixinguardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
+  parseContext pc;
+  if (parse2(clientData, interp, objc, objv, XOTclClassInfoInstmixinguardMethodIdx, &pc) != TCL_OK) {
+    return TCL_ERROR;
+  } else {
+    XOTclClass * class = (XOTclClass *)pc.clientData[0];
+    char * mixin = (char *)pc.clientData[1];
+
+    return XOTclClassInfoInstmixinguardMethod(interp, class, mixin);
+
+  }
+}
+  
+static int
+XOTclClassInfoInstmixinofMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
+  parseContext pc;
+  if (parse2(clientData, interp, objc, objv, XOTclClassInfoInstmixinofMethodIdx, &pc) != TCL_OK) {
+    return TCL_ERROR;
+  } else {
+    XOTclClass * class = (XOTclClass *)pc.clientData[0];
+    int withClosure = (int)pc.clientData[1];
+    char *patternString = NULL;
+    XOTclObject *patternObj = NULL;
+    Tcl_Obj * pattern = (Tcl_Obj *)pc.clientData[2];
+
+    if (getMatchObject3(interp, pattern,  &pc, &patternObj, &patternString) == -1) {
+      return TCL_OK;
+    }
+          
+    return XOTclClassInfoInstmixinofMethod(interp, class, withClosure, patternString, patternObj);
+
+  }
+}
+  
 static methodDefinition2 methodDefinitons[] = {
 {"instances", XOTclClassInfoHeritageMethodStub, {
   {"class", 1, 0, "class"},
@@ -202,6 +298,29 @@
 {"instfilterguard", XOTclClassInfoInstfilterguardMethodStub, {
   {"class", 1, 0, "class"},
   {"filter", 1, 0, NULL}}
+},
+{"instforward", XOTclClassInfoInstforwardMethodStub, {
+  {"class", 1, 0, "class"},
+  {"-definition", 0, 0, NULL},
+  {"methodName", 1, 0, NULL}}
+},
+{"instinvar", XOTclClassInfoInstinvarMethodStub, {
+  {"class", 1, 0, "class"}}
+},
+{"instmixin", XOTclClassInfoInstmixinMethodStub, {
+  {"class", 1, 0, "class"},
+  {"-closure", 0, 0, NULL},
+  {"-guards", 0, 0, NULL},
+  {"pattern", 0, 0, "objpattern"}}
+},
+{"instmixinguard", XOTclClassInfoInstmixinguardMethodStub, {
+  {"class", 1, 0, "class"},
+  {"mixin", 1, 0, NULL}}
+},
+{"instmixinof", XOTclClassInfoInstmixinofMethodStub, {
+  {"class", 1, 0, "class"},
+  {"-closure", 0, 0, NULL},
+  {"pattern", 0, 0, "objpattern"}}
 }
 };
 
Index: generic/xotcl.c
===================================================================
diff -u -rf209c50ea8cb651d0dea25206301e45202217797 -rce552d49dd2f135f21cefb4b88c9bf1357881c2e
--- generic/xotcl.c	(.../xotcl.c)	(revision f209c50ea8cb651d0dea25206301e45202217797)
+++ generic/xotcl.c	(.../xotcl.c)	(revision ce552d49dd2f135f21cefb4b88c9bf1357881c2e)
@@ -3431,7 +3431,7 @@
  * String key hashtable
  */
 static int
-XOTclClassInfoInstancesMethod(Tcl_Interp *interp, XOTclClass *startCl, 
+XOTclClassInfoInstancesMethod1(Tcl_Interp *interp, XOTclClass *startCl, 
                               int withClosure, char *pattern, XOTclObject *matchObject) {
   Tcl_HashTable *table = &startCl->instances;
   XOTclClasses *sc;
@@ -3440,27 +3440,35 @@
   int rc = 0;
 
   /*fprintf(stderr,"XOTclClassInfoInstancesMethod: clo %d pattern %s match %p\n", 
-    withClosure, pattern, matchObject);*/
+    withClosure, pattern, matchObject); */
 
   for (hPtr = Tcl_FirstHashEntry(table, &search);  hPtr;
        hPtr = Tcl_NextHashEntry(&search)) {
     XOTclObject *inst = (XOTclObject*) Tcl_GetHashKey(table, hPtr);
     /*fprintf(stderr, "match '%s' %p %p '%s'\n", 
       matchObject ? objectName(matchObject) : "NULL" ,matchObject, inst, objectName(inst));*/
     if (matchObject && inst == matchObject) {
+      Tcl_SetObjResult(interp, matchObject->cmdName);
       return 1;
     }
     AppendMatchingElement(interp, inst->cmdName, pattern);
   }
   if (withClosure) {
     for (sc = startCl->sub; sc; sc = sc->nextPtr) {
-      rc = XOTclClassInfoInstancesMethod(interp, sc->cl, withClosure, pattern, matchObject);
+      rc = XOTclClassInfoInstancesMethod1(interp, sc->cl, withClosure, pattern, matchObject);
       if (rc) break;
     }
   }
   return rc;
 }
 
+static int
+XOTclClassInfoInstancesMethod(Tcl_Interp *interp, XOTclClass *startCl, 
+                              int withClosure, char *pattern, XOTclObject *matchObject) {
+  XOTclClassInfoInstancesMethod1(interp, startCl, withClosure, pattern, matchObject);
+  return TCL_OK;
+}
+
 /*
  * get all instances of a class recursively into an initialized
  * String key hashtable
@@ -12352,63 +12360,48 @@
   return class->opt ? GuardList(interp, class->opt->instfilters, filter) : TCL_OK;
 }
 
-#if 0
-static int
-XOTclClassInfoInstfilterguardMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
-  parseContext pc;
-  if (parse2(clientData, interp, objc, objv, XOTclClassInfoInstfilterguardMethodIdx, &pc) != TCL_OK) {
-    return TCL_ERROR;
-  } else {
-    XOTclClass *cl   = (XOTclClass *)pc.clientData[0];
-    char *filter     = (char *)pc.clientData[1];
-    XOTclClassOpt *opt = cl->opt;
-  
-    return opt ? GuardList(interp, opt->instfilters, filter) : TCL_OK;
-  }
+static int 
+XOTclClassInfoInstforwardMethod(Tcl_Interp *interp, XOTclClass *class, 
+				int withDefinition, char *methodName) {
+  return forwardList(interp, Tcl_Namespace_cmdTable(class->nsPtr), methodName, withDefinition);
 }
-#endif
 
-static int
-XOTclClassInfoInstforwardMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
-  XOTclClass *cl;
-  Tcl_Namespace *nsp;
-  int withDefinition = 0;
-  char *name = NULL;
+static int 
+XOTclClassInfoInstinvarMethod(Tcl_Interp *interp, XOTclClass * class) {
+  XOTclClassOpt *opt = class->opt;
 
-  if (objc < 2 || objc > 4) return XOTclObjErrArgCnt(interp, objv[0],  NULL, "<class> ?-definition? ?name?");  
-  if (GetXOTclClassFromObj(interp, objv[1], &cl, 0) != TCL_OK)
-    return XOTclObjErrType(interp, objv[1], "Class");
-
-  if (objc > 2) {
-    name = ObjStr(objv[2]);
-    if (*name == '-' && !strcmp("-definition", name)) {
-      withDefinition = 1;
-      name = ObjStr(objv[3]);
-    }
+  if (opt && opt->assertions) {
+    Tcl_SetObjResult(interp, AssertionList(interp, opt->assertions->invariants));
   }
-
-  nsp = cl->nsPtr;
-  return forwardList(interp, Tcl_Namespace_cmdTable(cl->nsPtr), name, withDefinition);
+  return TCL_OK;
 }
 
-static int
-XOTclClassInfoInstinvarMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
-  parseContext pc;
-  XOTclClassOpt *opt;
+static int 
+XOTclClassInfoInstmixinMethod(Tcl_Interp *interp, XOTclClass * class, int withClosure, int withGuards,
+			      char *patternString, XOTclObject *patternObj) {
+  XOTclClassOpt *opt = class->opt;
   int rc;
 
-  if ((rc = parse(clientData, interp, objc, objv, NULL, parseClass, &pc)) != TCL_OK) {
-    return rc;
+  /*fprintf(stderr, "XOTclClassInfoInstmixinMethod guard %d clo %d set %.4x pattern '%s'\n",
+    withGuards,withClosure,patternString);*/
+
+  if (withClosure) {
+    Tcl_HashTable objTable, *commandTable = &objTable;
+    MEM_COUNT_ALLOC("Tcl_InitHashTable", commandTable);
+    Tcl_InitHashTable(commandTable, TCL_ONE_WORD_KEYS);
+    rc = getAllClassMixins(interp, commandTable, class, withGuards, patternString, patternObj);
+    if (patternObj && rc && !withGuards) {
+      Tcl_SetObjResult(interp, rc ? patternObj->cmdName : XOTclGlobalObjects[XOTE_EMPTY]);
+    }
+    MEM_COUNT_FREE("Tcl_InitHashTable", commandTable);
+  } else {
+    rc = opt ? MixinInfo(interp, opt->instmixins, patternString, withGuards, patternObj) : TCL_OK;
   }
-  opt = pc.cl->opt;
-  if (opt && opt->assertions) {
-    Tcl_SetObjResult(interp, AssertionList(interp, opt->assertions->invariants));
-  }
-  
+
   return TCL_OK;
 }
 
-
+#if 0
 static int
 XOTclClassInfoInstmixinMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
   parseContext pc;
@@ -12442,20 +12435,40 @@
   DSTRING_FREE(&pc.ds);
   return TCL_OK;
 }
+#endif
 
-static int
-XOTclClassInfoInstmixinguardMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
-  XOTclClass *cl;
-  XOTclClassOpt *opt;
-  
-  if (objc != 3) return XOTclObjErrArgCnt(interp, objv[0],  NULL, "<class> mixin");  
-  if (GetXOTclClassFromObj(interp, objv[1], &cl, 0) != TCL_OK)
-    return XOTclObjErrType(interp, objv[1], "Class");
+static int 
+XOTclClassInfoInstmixinguardMethod(Tcl_Interp *interp, XOTclClass * class, char * mixin) {
+  return class->opt ? GuardList(interp, class->opt->instmixins, mixin) : TCL_OK;
+}
 
-  opt = cl->opt;
-  return opt ? GuardList(interp, opt->instmixins, ObjStr(objv[2])) : TCL_OK;
+static int 
+XOTclClassInfoInstmixinofMethod(Tcl_Interp *interp, XOTclClass * class, int withClosure, 
+				char *patternString, XOTclObject *patternObj) {
+  XOTclClassOpt *opt = class->opt;
+  int rc;
+
+  if (opt) {
+    if (withClosure) {
+      Tcl_HashTable objTable, *commandTable = &objTable;
+      MEM_COUNT_ALLOC("Tcl_InitHashTable", commandTable);
+      Tcl_InitHashTable(commandTable, TCL_ONE_WORD_KEYS);
+      rc = getAllClassMixinsOf(interp, commandTable, class, 0, 1, patternString, patternObj);
+      MEM_COUNT_FREE("Tcl_InitHashTable", commandTable);
+    } else {
+      rc = AppendMatchingElementsFromCmdList(interp, opt->isClassMixinOf, 
+                                             patternString, patternObj);
+    }
+    if (patternObj) {
+      Tcl_SetObjResult(interp, rc ? patternObj->cmdName : XOTclGlobalObjects[XOTE_EMPTY]);
+    }
+  }
+  return TCL_OK;
 }
 
+
+
+
 static int
 XOTclClassInfoMixinofMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
   parseContext pc;
@@ -12487,37 +12500,7 @@
 }
 
 
-static int
-XOTclClassInfoInstmixinofMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
-  parseContext pc;
-  static CONST char *options[] = {"-closure", NULL};
-  int rc, withClosure;
 
-  if ((rc = parse(clientData, interp, objc, objv, options, 
-                  parseClass|parsePattern|parseMatchObject, &pc)) != TCL_OK || pc.resultIsSet) {
-    return rc;
-  }
-  withClosure = pc.set & 1 << 0;
-  
-  if (pc.cl->opt) {
-    if (withClosure) {
-      Tcl_HashTable objTable, *commandTable = &objTable;
-      MEM_COUNT_ALLOC("Tcl_InitHashTable", commandTable);
-      Tcl_InitHashTable(commandTable, TCL_ONE_WORD_KEYS);
-      rc = getAllClassMixinsOf(interp, commandTable, pc.cl, 0, 1, pc.pattern, pc.matchObject);
-      MEM_COUNT_FREE("Tcl_InitHashTable", commandTable);
-    } else {
-      rc = AppendMatchingElementsFromCmdList(interp, pc.cl->opt->isClassMixinOf, 
-                                             pc.pattern, pc.matchObject);
-    }
-    if (pc.matchObject) {
-      Tcl_SetObjResult(interp, rc ? pc.matchObject->cmdName : XOTclGlobalObjects[XOTE_EMPTY]);
-    }
-    DSTRING_FREE(&pc.ds);
-  }
-  return TCL_OK;
-}
-
 static int
 XOTclClassInfoInstnonposargsMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
   XOTclClass *cl;
@@ -14596,11 +14579,11 @@
        {"instdefault",     XOTclClassInfoInstdefaultMethodStub},
        {"instfilter",      XOTclClassInfoInstfilterMethodStub},
        {"instfilterguard", XOTclClassInfoInstfilterguardMethodStub},
-       {"instforward",     XOTclClassInfoInstforwardMethod},
-       {"instinvar",       XOTclClassInfoInstinvarMethod},
-       {"instmixin",       XOTclClassInfoInstmixinMethod},
-       {"instmixinguard",  XOTclClassInfoInstmixinguardMethod},
-       {"instmixinof",     XOTclClassInfoInstmixinofMethod},
+       {"instforward",     XOTclClassInfoInstforwardMethodStub},
+       {"instinvar",       XOTclClassInfoInstinvarMethodStub},
+       {"instmixin",       XOTclClassInfoInstmixinMethodStub},
+       {"instmixinguard",  XOTclClassInfoInstmixinguardMethodStub},
+       {"instmixinof",     XOTclClassInfoInstmixinofMethodStub},
        {"instprocs",       XOTclClassInfoInstprocsMethod},
        {"instnonposargs",  XOTclClassInfoInstnonposargsMethod},
        {"instparametercmd",XOTclClassInfoInstparametercmdMethod},