Index: ChangeLog =================================================================== diff -u -r5003fb8069bfd0d2de1482c68a7ab68782c4b328 -r80dbbc5075b96ca2d25ebf426204398f68411e17 --- ChangeLog (.../ChangeLog) (revision 5003fb8069bfd0d2de1482c68a7ab68782c4b328) +++ ChangeLog (.../ChangeLog) (revision 80dbbc5075b96ca2d25ebf426204398f68411e17) @@ -65,6 +65,9 @@ 2009-06-28 - objv-stubs for all 23 class info methods + - changed " info hasNamespace" to " info hasnamespace" + (all commands and info options are lowercase only, no underscore) + - 11 " info" commands generated 2009-06-27 - changed method name "instdestroy" into "dealloc" Index: generic/gentclAPI.tcl =================================================================== diff -u -r5003fb8069bfd0d2de1482c68a7ab68782c4b328 -r80dbbc5075b96ca2d25ebf426204398f68411e17 --- generic/gentclAPI.tcl (.../gentclAPI.tcl) (revision 5003fb8069bfd0d2de1482c68a7ab68782c4b328) +++ generic/gentclAPI.tcl (.../gentclAPI.tcl) (revision 80dbbc5075b96ca2d25ebf426204398f68411e17) @@ -31,13 +31,14 @@ if {[regexp {^-(.*)$} $(-argName) _ switchName]} { set varName with[string totitle $switchName] set calledArg $varName - set type int + set type "int " } else { set varName $(-argName) set calledArg $varName switch $(-type) { "" {set type "char *"} "class" {set type "XOTclClass *"} + "object" {set type "XOTclObject *"} "tclobj" {set type "Tcl_Obj *"} "objpattern" { set type "Tcl_Obj *" @@ -58,7 +59,7 @@ } } } - if {!$ifSet} {lappend if "$type $varName"} + if {!$ifSet} {lappend if "$type$varName"} lappend c [subst -nocommands {$type $varName = ($type)pc.clientData[$i];}] lappend a $calledArg incr i @@ -147,13 +148,71 @@ methodDefinition $methodName infoClassMethod $implementation $argDefinitions } +proc infoObjectMethod {methodName implementation argDefinitions} { + methodDefinition $methodName infoObjectMethod $implementation $argDefinitions +} + +# +# info object methods +# +infoObjectMethod args XOTclObjInfoArgsMethod { + {-argName "object" -required 1 -type object} + {-argName "methodName" -required 1} +} +infoObjectMethod body XOTclObjInfoBodyMethod { + {-argName "object" -required 1 -type object} + {-argName "methodName" -required 1} +} +infoObjectMethod check XOTclObjInfoCheckMethod { + {-argName "object" -required 1 -type object} +} +infoObjectMethod children XOTclObjInfoChildrenMethod { + {-argName "object" -required 1 -type object} + {-argName "pattern" -required 0} +} +infoObjectMethod class XOTclObjInfoClassMethod { + {-argName "object" -required 1 -type object} +} +infoObjectMethod commands XOTclObjInfoCommandsMethod { + {-argName "object" -required 1 -type object} + {-argName "pattern" -required 0} +} +infoObjectMethod default XOTclObjInfoDefaultMethod { + {-argName "object" -required 1 -type object} + {-argName "methodName" -required 1} + {-argName "arg" -required 1} + {-argName "var" -required 1 -type tclobj} +} +infoObjectMethod filter XOTclObjInfoFilterMethod { + {-argName "object" -required 1 -type object} + {-argName "-order"} + {-argName "-guards"} + {-argName "pattern"} +} +infoObjectMethod filterguard XOTclObjInfoFilterguardMethod { + {-argName "object" -required 1 -type object} + {-argName "filter" -required 1} +} +infoObjectMethod forward XOTclObjInfoForwardMethod { + {-argName "object" -required 1 -type object} + {-argName "-definition"} + {-argName "methodName" -required 1} +} +infoObjectMethod hasnamespace XOTclObjInfoHasnamespaceMethod { + {-argName "object" -required 1 -type object} +} + + +# +# info class methods +# infoClassMethod instances XOTclClassInfoHeritageMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "pattern"} } infoClassMethod instances XOTclClassInfoInstancesMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "-closure"} {-argName "pattern" -type objpattern} } @@ -169,103 +228,103 @@ } infoClassMethod instances XOTclClassInfoInstcommandsMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "pattern"} } infoClassMethod instdefault XOTclClassInfoInstdefaultMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "methodName" -required 1} {-argName "arg" -required 1} {-argName "var" -required 1 -type tclobj} } infoClassMethod instfilter XOTclClassInfoInstfilterMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "-guards"} {-argName "pattern"} } infoClassMethod instfilterguard XOTclClassInfoInstfilterguardMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "filter" -required 1} } infoClassMethod instforward XOTclClassInfoInstforwardMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "-definition"} {-argName "methodName" -required 1} } infoClassMethod instinvar XOTclClassInfoInstinvarMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} } infoClassMethod instmixin XOTclClassInfoInstmixinMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "-closure"} {-argName "-guards"} {-argName "pattern" -type objpattern} } infoClassMethod instmixinguard XOTclClassInfoInstmixinguardMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "mixin" -required 1} } infoClassMethod instmixinof XOTclClassInfoInstmixinofMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "-closure"} {-argName "pattern" -type objpattern} } infoClassMethod instnonposargs XOTclClassInfoInstnonposargsMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "methodName" -required 1} } infoClassMethod instparametercmd XOTclClassInfoInstparametercmdMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "pattern"} } infoClassMethod instpost XOTclClassInfoInstpostMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "methodName" -required 1} } infoClassMethod instpre XOTclClassInfoInstpreMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "methodName" -required 1} } infoClassMethod instprocs XOTclClassInfoInstprocsMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "pattern"} } infoClassMethod mixinof XOTclClassInfoMixinofMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "-closure"} {-argName "pattern" -type objpattern} } infoClassMethod parameter XOTclClassInfoParameterMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} } infoClassMethod slots XOTclClassInfoSlotsMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} } infoClassMethod subclass XOTclClassInfoSubclassMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "-closure"} {-argName "pattern" -type objpattern} } infoClassMethod superclass XOTclClassInfoSuperclassMethod { - {-argName "class" -required 1 -nrargs 0 -type class} + {-argName "class" -required 1 -type class} {-argName "-closure"} {-argName "pattern"} } Index: generic/predefined.h =================================================================== diff -u -rdc0040a6ddddf73e61c2a7d733ad7e15127e6bc1 -r80dbbc5075b96ca2d25ebf426204398f68411e17 --- generic/predefined.h (.../predefined.h) (revision dc0040a6ddddf73e61c2a7d733ad7e15127e6bc1) +++ generic/predefined.h (.../predefined.h) (revision 80dbbc5075b96ca2d25ebf426204398f68411e17) @@ -354,7 +354,7 @@ "::xotcl::Object::CopyHandler instproc makeTargetList t {\n" "::xotcl::my lappend targetList $t\n" "if {[::xotcl::my isobject $t]} {\n" -"if {[$t info hasNamespace]} {\n" +"if {[$t info hasnamespace]} {\n" "set children [$t info children]} else {\n" "return}}\n" "foreach c [namespace children $t] {\n" @@ -385,7 +385,7 @@ "$obj check [$origin info check]\n" "$obj mixin [$origin info mixin]\n" "$obj filter [$origin info filter -guards]\n" -"if {[$origin info hasNamespace]} {\n" +"if {[$origin info hasnamespace]} {\n" "$obj requireNamespace}} else {\n" "namespace eval $dest {}}\n" "::xotcl::my copyNSVarsAndCmds $origin $dest\n" Index: generic/predefined.xotcl =================================================================== diff -u -rdc0040a6ddddf73e61c2a7d733ad7e15127e6bc1 -r80dbbc5075b96ca2d25ebf426204398f68411e17 --- generic/predefined.xotcl (.../predefined.xotcl) (revision dc0040a6ddddf73e61c2a7d733ad7e15127e6bc1) +++ generic/predefined.xotcl (.../predefined.xotcl) (revision 80dbbc5075b96ca2d25ebf426204398f68411e17) @@ -661,7 +661,7 @@ ::xotcl::my lappend targetList $t # if it is an object without namespace, it is a leaf if {[::xotcl::my isobject $t]} { - if {[$t info hasNamespace]} { + if {[$t info hasnamespace]} { # make target list from all children set children [$t info children] } else { @@ -724,7 +724,7 @@ # set md [$origin info metadata] # $obj metadata add $md # foreach m $md { $obj metadata $m [$origin metadata $m] } - if {[$origin info hasNamespace]} { + if {[$origin info hasnamespace]} { $obj requireNamespace } } else { Index: generic/tclAPI.h =================================================================== diff -u -r5003fb8069bfd0d2de1482c68a7ab68782c4b328 -r80dbbc5075b96ca2d25ebf426204398f68411e17 --- generic/tclAPI.h (.../tclAPI.h) (revision 5003fb8069bfd0d2de1482c68a7ab68782c4b328) +++ generic/tclAPI.h (.../tclAPI.h) (revision 80dbbc5075b96ca2d25ebf426204398f68411e17) @@ -33,30 +33,52 @@ static int XOTclClassInfoSlotsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); static int XOTclClassInfoSubclassMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); static int XOTclClassInfoSuperclassMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoArgsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoBodyMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoCheckMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoChildrenMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoClassMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoCommandsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoDefaultMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoFilterMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoFilterguardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoForwardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv []); +static int XOTclObjInfoHasnamespaceMethodStub(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); -static int XOTclClassInfoInstnonposargsMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName); -static int XOTclClassInfoInstparametercmdMethod(Tcl_Interp *interp, XOTclClass * class, char * pattern); -static int XOTclClassInfoInstpostMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName); -static int XOTclClassInfoInstpreMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName); -static int XOTclClassInfoInstprocsMethod(Tcl_Interp *interp, XOTclClass * class, char * pattern); -static int XOTclClassInfoMixinofMethod(Tcl_Interp *interp, XOTclClass * class, int withClosure, char *patternString, XOTclObject *patternObj); -static int XOTclClassInfoParameterMethod(Tcl_Interp *interp, XOTclClass * class); -static int XOTclClassInfoSlotsMethod(Tcl_Interp *interp, XOTclClass * class); -static int XOTclClassInfoSubclassMethod(Tcl_Interp *interp, XOTclClass * class, int withClosure, char *patternString, XOTclObject *patternObj); -static int XOTclClassInfoSuperclassMethod(Tcl_Interp *interp, XOTclClass * class, int withClosure, char * pattern); +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); +static int XOTclClassInfoInstnonposargsMethod(Tcl_Interp *interp, XOTclClass *class, char *methodName); +static int XOTclClassInfoInstparametercmdMethod(Tcl_Interp *interp, XOTclClass *class, char *pattern); +static int XOTclClassInfoInstpostMethod(Tcl_Interp *interp, XOTclClass *class, char *methodName); +static int XOTclClassInfoInstpreMethod(Tcl_Interp *interp, XOTclClass *class, char *methodName); +static int XOTclClassInfoInstprocsMethod(Tcl_Interp *interp, XOTclClass *class, char *pattern); +static int XOTclClassInfoMixinofMethod(Tcl_Interp *interp, XOTclClass *class, int withClosure, char *patternString, XOTclObject *patternObj); +static int XOTclClassInfoParameterMethod(Tcl_Interp *interp, XOTclClass *class); +static int XOTclClassInfoSlotsMethod(Tcl_Interp *interp, XOTclClass *class); +static int XOTclClassInfoSubclassMethod(Tcl_Interp *interp, XOTclClass *class, int withClosure, char *patternString, XOTclObject *patternObj); +static int XOTclClassInfoSuperclassMethod(Tcl_Interp *interp, XOTclClass *class, int withClosure, char *pattern); +static int XOTclObjInfoArgsMethod(Tcl_Interp *interp, XOTclObject *object, char *methodName); +static int XOTclObjInfoBodyMethod(Tcl_Interp *interp, XOTclObject *object, char *methodName); +static int XOTclObjInfoCheckMethod(Tcl_Interp *interp, XOTclObject *object); +static int XOTclObjInfoChildrenMethod(Tcl_Interp *interp, XOTclObject *object, char *pattern); +static int XOTclObjInfoClassMethod(Tcl_Interp *interp, XOTclObject *object); +static int XOTclObjInfoCommandsMethod(Tcl_Interp *interp, XOTclObject *object, char *pattern); +static int XOTclObjInfoDefaultMethod(Tcl_Interp *interp, XOTclObject *object, char *methodName, char *arg, Tcl_Obj *var); +static int XOTclObjInfoFilterMethod(Tcl_Interp *interp, XOTclObject *object, int withOrder, int withGuards, char *pattern); +static int XOTclObjInfoFilterguardMethod(Tcl_Interp *interp, XOTclObject *object, char *filter); +static int XOTclObjInfoForwardMethod(Tcl_Interp *interp, XOTclObject *object, int withDefinition, char *methodName); +static int XOTclObjInfoHasnamespaceMethod(Tcl_Interp *interp, XOTclObject *object); enum { XOTclClassInfoHeritageMethodIdx, @@ -81,7 +103,18 @@ XOTclClassInfoParameterMethodIdx, XOTclClassInfoSlotsMethodIdx, XOTclClassInfoSubclassMethodIdx, - XOTclClassInfoSuperclassMethodIdx + XOTclClassInfoSuperclassMethodIdx, + XOTclObjInfoArgsMethodIdx, + XOTclObjInfoBodyMethodIdx, + XOTclObjInfoCheckMethodIdx, + XOTclObjInfoChildrenMethodIdx, + XOTclObjInfoClassMethodIdx, + XOTclObjInfoCommandsMethodIdx, + XOTclObjInfoDefaultMethodIdx, + XOTclObjInfoFilterMethodIdx, + XOTclObjInfoFilterguardMethodIdx, + XOTclObjInfoForwardMethodIdx, + XOTclObjInfoHasnamespaceMethodIdx } XOTclMethods; @@ -106,7 +139,7 @@ return TCL_ERROR; } else { XOTclClass * class = (XOTclClass *)pc.clientData[0]; - int withClosure = (int)pc.clientData[1]; + int withClosure = (int )pc.clientData[1]; char *patternString = NULL; XOTclObject *patternObj = NULL; Tcl_Obj * pattern = (Tcl_Obj *)pc.clientData[2]; @@ -185,7 +218,7 @@ return TCL_ERROR; } else { XOTclClass * class = (XOTclClass *)pc.clientData[0]; - int withGuards = (int)pc.clientData[1]; + int withGuards = (int )pc.clientData[1]; char * pattern = (char *)pc.clientData[2]; return XOTclClassInfoInstfilterMethod(interp, class, withGuards, pattern); @@ -214,7 +247,7 @@ return TCL_ERROR; } else { XOTclClass * class = (XOTclClass *)pc.clientData[0]; - int withDefinition = (int)pc.clientData[1]; + int withDefinition = (int )pc.clientData[1]; char * methodName = (char *)pc.clientData[2]; return XOTclClassInfoInstforwardMethod(interp, class, withDefinition, methodName); @@ -242,8 +275,8 @@ return TCL_ERROR; } else { XOTclClass * class = (XOTclClass *)pc.clientData[0]; - int withClosure = (int)pc.clientData[1]; - int withGuards = (int)pc.clientData[2]; + 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]; @@ -278,7 +311,7 @@ return TCL_ERROR; } else { XOTclClass * class = (XOTclClass *)pc.clientData[0]; - int withClosure = (int)pc.clientData[1]; + int withClosure = (int )pc.clientData[1]; char *patternString = NULL; XOTclObject *patternObj = NULL; Tcl_Obj * pattern = (Tcl_Obj *)pc.clientData[2]; @@ -369,7 +402,7 @@ return TCL_ERROR; } else { XOTclClass * class = (XOTclClass *)pc.clientData[0]; - int withClosure = (int)pc.clientData[1]; + int withClosure = (int )pc.clientData[1]; char *patternString = NULL; XOTclObject *patternObj = NULL; Tcl_Obj * pattern = (Tcl_Obj *)pc.clientData[2]; @@ -416,7 +449,7 @@ return TCL_ERROR; } else { XOTclClass * class = (XOTclClass *)pc.clientData[0]; - int withClosure = (int)pc.clientData[1]; + int withClosure = (int )pc.clientData[1]; char *patternString = NULL; XOTclObject *patternObj = NULL; Tcl_Obj * pattern = (Tcl_Obj *)pc.clientData[2]; @@ -437,14 +470,170 @@ return TCL_ERROR; } else { XOTclClass * class = (XOTclClass *)pc.clientData[0]; - int withClosure = (int)pc.clientData[1]; + int withClosure = (int )pc.clientData[1]; char * pattern = (char *)pc.clientData[2]; return XOTclClassInfoSuperclassMethod(interp, class, withClosure, pattern); } } +static int +XOTclObjInfoArgsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoArgsMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + char * methodName = (char *)pc.clientData[1]; + + return XOTclObjInfoArgsMethod(interp, object, methodName); + + } +} + +static int +XOTclObjInfoBodyMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoBodyMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + char * methodName = (char *)pc.clientData[1]; + + return XOTclObjInfoBodyMethod(interp, object, methodName); + + } +} + +static int +XOTclObjInfoCheckMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoCheckMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + + return XOTclObjInfoCheckMethod(interp, object); + + } +} + +static int +XOTclObjInfoChildrenMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoChildrenMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + char * pattern = (char *)pc.clientData[1]; + + return XOTclObjInfoChildrenMethod(interp, object, pattern); + + } +} + +static int +XOTclObjInfoClassMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoClassMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + + return XOTclObjInfoClassMethod(interp, object); + + } +} + +static int +XOTclObjInfoCommandsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoCommandsMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + char * pattern = (char *)pc.clientData[1]; + + return XOTclObjInfoCommandsMethod(interp, object, pattern); + + } +} + +static int +XOTclObjInfoDefaultMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoDefaultMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + char * methodName = (char *)pc.clientData[1]; + char * arg = (char *)pc.clientData[2]; + Tcl_Obj * var = (Tcl_Obj *)pc.clientData[3]; + + return XOTclObjInfoDefaultMethod(interp, object, methodName, arg, var); + + } +} + +static int +XOTclObjInfoFilterMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoFilterMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + int withOrder = (int )pc.clientData[1]; + int withGuards = (int )pc.clientData[2]; + char * pattern = (char *)pc.clientData[3]; + + return XOTclObjInfoFilterMethod(interp, object, withOrder, withGuards, pattern); + + } +} + +static int +XOTclObjInfoFilterguardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoFilterguardMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + char * filter = (char *)pc.clientData[1]; + + return XOTclObjInfoFilterguardMethod(interp, object, filter); + + } +} + +static int +XOTclObjInfoForwardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoForwardMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + int withDefinition = (int )pc.clientData[1]; + char * methodName = (char *)pc.clientData[2]; + + return XOTclObjInfoForwardMethod(interp, object, withDefinition, methodName); + + } +} + +static int +XOTclObjInfoHasnamespaceMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + parseContext pc; + if (parse2(clientData, interp, objc, objv, XOTclObjInfoHasnamespaceMethodIdx, &pc) != TCL_OK) { + return TCL_ERROR; + } else { + XOTclObject * object = (XOTclObject *)pc.clientData[0]; + + return XOTclObjInfoHasnamespaceMethod(interp, object); + + } +} + static methodDefinition2 methodDefinitons[] = { {"instances", XOTclClassInfoHeritageMethodStub, { {"class", 1, 0, "class"}, @@ -545,6 +734,52 @@ {"class", 1, 0, "class"}, {"-closure", 0, 0, NULL}, {"pattern", 0, 0, NULL}} +}, +{"args", XOTclObjInfoArgsMethodStub, { + {"object", 1, 0, "object"}, + {"methodName", 1, 0, NULL}} +}, +{"body", XOTclObjInfoBodyMethodStub, { + {"object", 1, 0, "object"}, + {"methodName", 1, 0, NULL}} +}, +{"check", XOTclObjInfoCheckMethodStub, { + {"object", 1, 0, "object"}} +}, +{"children", XOTclObjInfoChildrenMethodStub, { + {"object", 1, 0, "object"}, + {"pattern", 0, 0, NULL}} +}, +{"class", XOTclObjInfoClassMethodStub, { + {"object", 1, 0, "object"}} +}, +{"commands", XOTclObjInfoCommandsMethodStub, { + {"object", 1, 0, "object"}, + {"pattern", 0, 0, NULL}} +}, +{"default", XOTclObjInfoDefaultMethodStub, { + {"object", 1, 0, "object"}, + {"methodName", 1, 0, NULL}, + {"arg", 1, 0, NULL}, + {"var", 1, 0, "tclobj"}} +}, +{"filter", XOTclObjInfoFilterMethodStub, { + {"object", 1, 0, "object"}, + {"-order", 0, 0, NULL}, + {"-guards", 0, 0, NULL}, + {"pattern", 0, 0, NULL}} +}, +{"filterguard", XOTclObjInfoFilterguardMethodStub, { + {"object", 1, 0, "object"}, + {"filter", 1, 0, NULL}} +}, +{"forward", XOTclObjInfoForwardMethodStub, { + {"object", 1, 0, "object"}, + {"-definition", 0, 0, NULL}, + {"methodName", 1, 0, NULL}} +}, +{"hasnamespace", XOTclObjInfoHasnamespaceMethodStub, { + {"object", 1, 0, "object"}} } }; Index: generic/xotcl.c =================================================================== diff -u -r5003fb8069bfd0d2de1482c68a7ab68782c4b328 -r80dbbc5075b96ca2d25ebf426204398f68411e17 --- generic/xotcl.c (.../xotcl.c) (revision 5003fb8069bfd0d2de1482c68a7ab68782c4b328) +++ generic/xotcl.c (.../xotcl.c) (revision 80dbbc5075b96ca2d25ebf426204398f68411e17) @@ -8920,76 +8920,96 @@ return TCL_OK; } -/************ info commands xxx ******/ -static int -XOTclObjInfoArgsMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; - Tcl_Namespace *nsp; - - if (objc != 3) return XOTclObjErrArgCnt(interp, objv[0], NULL, " "); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); +/*************************** + * Begin Object Info Methods + ***************************/ - if (obj->nonposArgsTable) { - XOTclNonposArgs *nonposArgs = NonposArgsGet(obj->nonposArgsTable, ObjStr(objv[2])); - if (nonposArgs && nonposArgs->ordinaryArgs) { - return ListArgsFromOrdinaryArgs(interp, nonposArgs); - } +static int +XOTclObjInfoArgsMethod(Tcl_Interp *interp, XOTclObject *object, char *methodName) { + if (object->nonposArgsTable) { + XOTclNonposArgs *nonposArgs = NonposArgsGet(object->nonposArgsTable, methodName); + if (nonposArgs && nonposArgs->ordinaryArgs) { + return ListArgsFromOrdinaryArgs(interp, nonposArgs); } + } + return object->nsPtr ? ListProcArgs(interp, Tcl_Namespace_cmdTable(object->nsPtr), methodName) : TCL_OK; +} - nsp = obj->nsPtr; - return nsp ? ListProcArgs(interp, Tcl_Namespace_cmdTable(nsp), ObjStr(objv[2])) : TCL_OK; +static int +XOTclObjInfoBodyMethod(Tcl_Interp *interp, XOTclObject *object, char *methodName) { + return object->nsPtr ? ListProcBody(interp, Tcl_Namespace_cmdTable( object->nsPtr), methodName) : TCL_OK; } -static int -XOTclObjInfoBodyMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; - Tcl_Namespace *nsp; - - if (objc != 3) return XOTclObjErrArgCnt(interp, objv[0], NULL, " "); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); - - nsp = obj->nsPtr; - return nsp ? ListProcBody(interp, Tcl_Namespace_cmdTable(nsp), ObjStr(objv[2])) : TCL_OK; +static int +XOTclObjInfoCheckMethod(Tcl_Interp *interp, XOTclObject *object) { + return AssertionListCheckOption(interp, object); } -static int -XOTclObjInfoClassMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; +static int +XOTclObjInfoChildrenMethod(Tcl_Interp *interp, XOTclObject *object, char *pattern) { + return ListChildren(interp, object, pattern, 0); +} - if (objc != 2) return XOTclObjErrArgCnt(interp, objv[0], NULL, ""); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); - - Tcl_SetObjResult(interp, obj->cl->object.cmdName); +static int +XOTclObjInfoClassMethod(Tcl_Interp *interp, XOTclObject *object) { + Tcl_SetObjResult(interp, object->cl->object.cmdName); return TCL_OK; } -static int -XOTclObjInfoCommandsMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; - Tcl_Namespace *nsp; +static int +XOTclObjInfoCommandsMethod(Tcl_Interp *interp, XOTclObject *object, char *pattern) { + return ListKeys(interp, Tcl_Namespace_cmdTable(object->nsPtr), pattern); +} - if (objc < 2 || objc > 3) return XOTclObjErrArgCnt(interp, objv[0], NULL, " ?pattern?"); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); +static int +XOTclObjInfoDefaultMethod(Tcl_Interp *interp, XOTclObject *object, char *methodName, char *arg, Tcl_Obj *var) { + if (object->nonposArgsTable) { + XOTclNonposArgs *nonposArgs = NonposArgsGet(object->nonposArgsTable, methodName); + if (nonposArgs && nonposArgs->ordinaryArgs) { + return ListDefaultFromOrdinaryArgs(interp, methodName, nonposArgs, arg, var); + } + } + return object->nsPtr ? + ListProcDefault(interp, Tcl_Namespace_cmdTable(object->nsPtr), methodName, arg, var) : + TCL_OK; +} - nsp = obj->nsPtr; - return ListKeys(interp, Tcl_Namespace_cmdTable(nsp), objc == 3 ? ObjStr(objv[2]) : NULL); +static int +XOTclObjInfoFilterMethod(Tcl_Interp *interp, XOTclObject *object, int withOrder, int withGuards, + char *pattern) { + XOTclObjectOpt *opt = object->opt; + if (withOrder) { + if (!(object->flags & XOTCL_FILTER_ORDER_VALID)) + FilterComputeDefined(interp, object); + return FilterInfo(interp, object->filterOrder, pattern, withGuards, 1); + } + return opt ? FilterInfo(interp, opt->filters, pattern, withGuards, 0) : TCL_OK; } static int -XOTclObjInfoChildrenMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; +XOTclObjInfoFilterguardMethod(Tcl_Interp *interp, XOTclObject *object, char *filter) { + return object->opt ? GuardList(interp, object->opt->filters, filter) : TCL_OK; +} - if (objc < 2 || objc > 3) return XOTclObjErrArgCnt(interp, objv[0], NULL, " ?pattern?"); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); +static int +XOTclObjInfoForwardMethod(Tcl_Interp *interp, XOTclObject *object, int withDefinition, char *methodName) { + return object->nsPtr ? + forwardList(interp, Tcl_Namespace_cmdTable(object->nsPtr), methodName, withDefinition) : + TCL_OK; +} - return ListChildren(interp, obj, objc == 3 ? ObjStr(objv[2]) : NULL, 0); +static int +XOTclObjInfoHasnamespaceMethod(Tcl_Interp *interp, XOTclObject *object) { + Tcl_SetBooleanObj(Tcl_GetObjResult(interp), object->nsPtr != NULL); + return TCL_OK; } +/*************************** + * End Object Info Methods + ***************************/ + + + static int XOTclObjInfoParametercmdMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { XOTclObject *obj; @@ -9016,130 +9036,8 @@ return ListSlotObjects(interp, obj, objc == 3 ? ObjStr(objv[2]) : NULL); } -static int -XOTclObjInfoCheckMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; - if (objc != 2) return XOTclObjErrArgCnt(interp, objv[0], NULL, ""); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); - - return AssertionListCheckOption(interp, obj); -} - static int -XOTclObjInfoDefaultMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; - Tcl_Namespace *nsp; - - if (objc != 5) return XOTclObjErrArgCnt(interp, objv[0], NULL, " "); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); - - if (obj->nonposArgsTable) { - XOTclNonposArgs *nonposArgs = NonposArgsGet(obj->nonposArgsTable, ObjStr(objv[2])); - if (nonposArgs && nonposArgs->ordinaryArgs) { - return ListDefaultFromOrdinaryArgs(interp, ObjStr(objv[2]), nonposArgs, ObjStr(objv[3]), objv[4]); - } - } - nsp = obj->nsPtr; - return nsp ? - ListProcDefault(interp, Tcl_Namespace_cmdTable(nsp), ObjStr(objv[2]), ObjStr(objv[3]), objv[4]) : - TCL_OK; -} - -static int -XOTclObjInfoFilterMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; - XOTclObjectOpt *opt;; - int idx, nobjc, withGuards = 0, withOrder = 0; - static CONST char *options[] = {"-guards", "-order", NULL}; - enum options {guardsIdx, orderIdx}; - - for (idx = 2; idx < objc; idx++) { - char *name; - int index; - - name = Tcl_GetString(objv[idx]); - if (name[0] != '-') { - break; - } - if (Tcl_GetIndexFromObj(interp, objv[idx], options, "switch", TCL_EXACT, &index) != TCL_OK) { - return TCL_ERROR; - } - switch ((enum options) index) { - case guardsIdx: withGuards = 1; break; - case orderIdx: withOrder = 1; break; - } - } - nobjc = objc - idx; - - if (objc < 2 || nobjc > 1 || objc > 4) - return XOTclObjErrArgCnt(interp, objv[0], NULL, " ?-guards|-order? ?pattern?"); - - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); - - if (withOrder) { - if (!(obj->flags & XOTCL_FILTER_ORDER_VALID)) - FilterComputeDefined(interp, obj); - return FilterInfo(interp, obj->filterOrder, idx < objc ? ObjStr(objv[idx]) : NULL, withGuards, 1); - } - opt = obj->opt; - return opt ? FilterInfo(interp, opt->filters, idx < objc ? ObjStr(objv[idx]) : NULL, withGuards, 0) : TCL_OK; -} - -static int -XOTclObjInfoFilterguardMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; - XOTclObjectOpt *opt; - - if (objc != 3) return XOTclObjErrArgCnt(interp, objv[0], NULL, " filter"); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); - - opt = obj->opt; - return opt ? GuardList(interp, opt->filters, ObjStr(objv[2])) : TCL_OK; -} - -static int -XOTclObjInfoForwardMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; - Tcl_Namespace *nsp; - int withDefinition = 0; - char *name = NULL; - - if (objc < 2 || objc > 4) return XOTclObjErrArgCnt(interp, objv[0], NULL, " ?-definition? ?name?"); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); - - if (objc > 2) { - name = ObjStr(objv[2]); - if (*name == '-' && !strcmp("-definition", name)) { - withDefinition = 1; - name = ObjStr(objv[3]); - } - } - - nsp = obj->nsPtr; - return nsp ? forwardList(interp, Tcl_Namespace_cmdTable(nsp), name, withDefinition) : TCL_OK; -} - -static int -XOTclObjInfoHasnamespaceMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { - XOTclObject *obj; - Tcl_Namespace *nsp;; - - if (objc != 2) return XOTclObjErrArgCnt(interp, objv[0], NULL, ""); - if (XOTclObjConvertObject(interp, objv[1], &obj) != TCL_OK) - return XOTclObjErrType(interp, objv[1], "Object"); - - nsp = obj->nsPtr; - Tcl_SetBooleanObj(Tcl_GetObjResult(interp), nsp != NULL); - return TCL_OK; -} - -static int XOTclObjInfoInvarMethod(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { XOTclObject *obj; XOTclObjectOpt *opt; @@ -11878,6 +11776,12 @@ } case 'o': { + if (strcmp(type,"object") == 0) { + if (XOTclObjConvertObject(interp, objPtr, (XOTclObject **)clientData) == TCL_OK) + break; + return XOTclObjErrType(interp, objPtr, type); + } + if (strcmp(type,"objpattern") == 0) { char *pattern = ObjStr(objPtr); *clientData = (ClientData)objPtr; @@ -14271,17 +14175,17 @@ {"type=boolean", XOTclCheckBooleanArgs} }; methodDefinition definitions4[] = { - {"args", XOTclObjInfoArgsMethod}, - {"body", XOTclObjInfoBodyMethod}, - {"class", XOTclObjInfoClassMethod}, - {"commands", XOTclObjInfoCommandsMethod}, - {"children", XOTclObjInfoChildrenMethod}, - {"check", XOTclObjInfoCheckMethod}, - {"default", XOTclObjInfoDefaultMethod}, - {"filter", XOTclObjInfoFilterMethod}, - {"filterguard", XOTclObjInfoFilterguardMethod}, - {"forward", XOTclObjInfoForwardMethod}, - {"hasNamespace", XOTclObjInfoHasnamespaceMethod}, + {"args", XOTclObjInfoArgsMethodStub}, + {"body", XOTclObjInfoBodyMethodStub}, + {"class", XOTclObjInfoClassMethodStub}, + {"commands", XOTclObjInfoCommandsMethodStub}, + {"children", XOTclObjInfoChildrenMethodStub}, + {"check", XOTclObjInfoCheckMethodStub}, + {"default", XOTclObjInfoDefaultMethodStub}, + {"filter", XOTclObjInfoFilterMethodStub}, + {"filterguard", XOTclObjInfoFilterguardMethodStub}, + {"forward", XOTclObjInfoForwardMethodStub}, + {"hasnamespace", XOTclObjInfoHasnamespaceMethodStub}, {"invar", XOTclObjInfoInvarMethod}, {"methods", XOTclObjInfoMethodsMethod}, {"mixin", XOTclObjInfoMixinMethod}, Index: tests/testx.xotcl =================================================================== diff -u -rdc0040a6ddddf73e61c2a7d733ad7e15127e6bc1 -r80dbbc5075b96ca2d25ebf426204398f68411e17 --- tests/testx.xotcl (.../testx.xotcl) (revision dc0040a6ddddf73e61c2a7d733ad7e15127e6bc1) +++ tests/testx.xotcl (.../testx.xotcl) (revision 80dbbc5075b96ca2d25ebf426204398f68411e17) @@ -1264,11 +1264,11 @@ set r [anObject aProc] if {$i > 0} { ::errorCheck $InfoTraceResult \ - "{::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasNamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-cleanup aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasNamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-setvalues aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasNamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-configure aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasNamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-init aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::xotcl::Class-::xotcl::classInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasNamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars-class} info-::aClass {::xotcl::Class-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::aClass-infoTraceFilter-::xotcl::Object ::xotcl::Class-recreate aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::xotcl::Class-::xotcl::classInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasNamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars-class} info-::aClass {::xotcl::Class-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::aClass-infoTraceFilter-::xotcl::Object ::xotcl::Class-create aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::ObjectsClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasNamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::anObject-infoTraceFilter-::xotcl::Object ::ObjectsClass-aProc run-::filterInfo {-::xotcl::Object instfilter infoTraceFilter}}" \ + "{::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasnamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-cleanup aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasnamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-setvalues aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasnamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-configure aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasnamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-init aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::xotcl::Class-::xotcl::classInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasnamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars-class} info-::aClass {::xotcl::Class-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::aClass-infoTraceFilter-::xotcl::Object ::xotcl::Class-recreate aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::xotcl::Class-::xotcl::classInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasnamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars-class} info-::aClass {::xotcl::Class-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::aClass-infoTraceFilter-::xotcl::Object ::xotcl::Class-create aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::ObjectsClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasnamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::anObject-infoTraceFilter-::xotcl::Object ::ObjectsClass-aProc run-::filterInfo {-::xotcl::Object instfilter infoTraceFilter}}" \ "FilterInfo InfoTrace: Filter information wrong (b)" } else { ::errorCheck $InfoTraceResult \ - "{::xotcl::Class-::xotcl::classInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasNamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars-class} info-::aClass {::xotcl::Class-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::aClass-infoTraceFilter-::xotcl::Object ::xotcl::Class-alloc aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasNamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-setvalues aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasNamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-configure aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasNamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-init aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::xotcl::Class-::xotcl::classInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasNamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars-class} info-::aClass {::xotcl::Class-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::aClass-infoTraceFilter-::xotcl::Object ::xotcl::Class-create aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::ObjectsClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasNamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::anObject-infoTraceFilter-::xotcl::Object ::ObjectsClass-aProc run-::filterInfo {-::xotcl::Object instfilter infoTraceFilter}}" \ + "{::xotcl::Class-::xotcl::classInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasnamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars-class} info-::aClass {::xotcl::Class-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::aClass-infoTraceFilter-::xotcl::Object ::xotcl::Class-alloc aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasnamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-setvalues aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasnamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-configure aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::aClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasnamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anotherObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {-::anotherObject-infoTraceFilter-::xotcl::Object ::aClass-init aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::xotcl::Class-::xotcl::classInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasnamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars-class} info-::aClass {::xotcl::Class-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::aClass-infoTraceFilter-::xotcl::Object ::xotcl::Class-create aProc-::anObject {::ObjectsClass-::xotcl::Object instfilter infoTraceFilter}} {::ObjectsClass-::xotcl::objectInfo-infoTraceFilter-::xotcl::Object {valid options are: args, body, check, children, class, commands, default, filter, filterguard, forward, hasnamespace, info, invar, is, methods, mixin, mixinguard, nonposargs, parametercmd, parent, post, pre, precedence, procs, slotobjects, vars-class} info-::anObject {::xotcl::Object-::xotcl::Object instfilter infoTraceFilter}} {::anotherObject-::anObject-infoTraceFilter-::xotcl::Object ::ObjectsClass-aProc run-::filterInfo {-::xotcl::Object instfilter infoTraceFilter}}" \ "FilterInfo InfoTrace: Filter information wrong" } } @@ -3230,7 +3230,7 @@ ::errorCheck [o mixin XY4] ::XY4 " __unknown XY4" } - ::errorCheck [UnknownClass info info] {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasNamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars} "info info" + ::errorCheck [UnknownClass info info] {valid options are: args, body, check, children, class, classchildren, classparent, commands, default, filter, filterguard, forward, hasnamespace, heritage, info, instances, instargs, instbody, instcommands, instdefault, instfilter, instfilterguard, instforward, instinvar, instmixin, instmixinguard, instmixinof, instnonposargs, instparametercmd, instpost, instpre, instprocs, invar, is, methods, mixin, mixinguard, mixinof, nonposargs, parameter, parametercmd, parent, post, pre, precedence, procs, slotobjects, slots, subclass, superclass, vars} "info info" # clear unknown handler to avoid strange results later Class proc __unknown "" ""