Index: generic/gentclAPI.tcl =================================================================== diff -u -r8e5a1351ecc12dfca1e3988240a07fa745439d42 -r300e593347cf3f13d62ac4d21299a2278ff83d5e --- generic/gentclAPI.tcl (.../gentclAPI.tcl) (revision 8e5a1351ecc12dfca1e3988240a07fa745439d42) +++ generic/gentclAPI.tcl (.../gentclAPI.tcl) (revision 300e593347cf3f13d62ac4d21299a2278ff83d5e) @@ -33,10 +33,10 @@ } } -proc genifd {argDefinitions} { +proc genifd {parameterDefinitions} { set l [list] - foreach argDefinition $argDefinitions { - array set "" $argDefinition + foreach parameterDefinition $parameterDefinitions { + array set "" $parameterDefinition switch $(-type) { "" {set type NULL} default {set type $(-type)} @@ -61,7 +61,7 @@ join $l ",\n " } -proc gencall {fn argDefinitions clientData cDefsVar ifDefVar arglistVar preVar postVar introVar} { +proc gencall {fn parameterDefinitions clientData cDefsVar ifDefVar arglistVar preVar postVar introVar} { upvar $cDefsVar cDefs $ifDefVar ifDef $arglistVar arglist $preVar pre $postVar post \ $introVar intro set c [list] @@ -90,8 +90,8 @@ array set cd {arglist "" ifDefs ""} } } - foreach argDefinition $argDefinitions { - array set "" $argDefinition + foreach parameterDefinition $parameterDefinitions { + array set "" $parameterDefinition set ifSet 0 set cVar 1 set (-argName) [string map [list - _] $(-argName)] @@ -174,10 +174,10 @@ ${stub}(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; $intro - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[$idx].ifd, - method_definitions[$idx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[$idx].paramDefs, + method_definitions[$idx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { $cDefs @@ -216,11 +216,11 @@ foreach key [lsort [array names ::definitions]] { array set d $::definitions($key) lappend enums $d(idx) - set nrArgs [llength $d(argDefinitions)] + set nrArgs [llength $d(parameterDefinitions)] set stubDecl "static int $d(stub)$::objCmdProc\n" - set ifd "{\"$::ns($d(methodType))::$d(methodName)\", $d(stub), $nrArgs, {\n [genifd $d(argDefinitions)]}\n}" + set ifd "{\"$::ns($d(methodType))::$d(methodName)\", $d(stub), $nrArgs, {\n [genifd $d(parameterDefinitions)]}\n}" - gencall $d(stub) $d(argDefinitions) $d(clientData) cDefs ifDef arglist pre post intro + gencall $d(stub) $d(parameterDefinitions) $d(clientData) cDefs ifDef arglist pre post intro append decls "static int [implArgList $d(implementation) {Tcl_Interp *} $ifDef];\n" if {$post ne ""} { append cDefs "\n int returnCode;" @@ -234,7 +234,7 @@ #if {$nrArgs == 1} { puts stderr "$d(stub) => '$arglist'" } if {$nrArgs == 1 && $arglist eq "objc, objv"} { # TODO we would not need to generate a stub at all.... - #set ifd "{\"$::ns($d(methodType))::$d(methodName)\", $d(implementation), $nrArgs, {\n [genifd $d(argDefinitions)]}\n}" + #set ifd "{\"$::ns($d(methodType))::$d(methodName)\", $d(implementation), $nrArgs, {\n [genifd $d(parameterDefinitions)]}\n}" #set stubDecl "static int $d(implementation)$::objCmdProc\n" append fns [genSimpleStub $d(stub) $intro $d(idx) $cDefs $pre $call $post] } elseif {$nrArgs == 1 && $arglist eq "obj, objc, objv"} { @@ -253,13 +253,12 @@ typedef struct { char *methodName; Tcl_ObjCmdProc *proc; - /*CONST interfaceDefinition ifd;*/ - int ifdSize; - argDefinition ifd[10]; + int nrParameters; + parameterDefinition paramDefs[10]; } methodDefinition; -static int parseObjv(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], Tcl_Obj *procName, - argDefinition CONST *ifdPtr, int ifdSize, parseContext *pc); +static int ArgumentParse(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], Tcl_Obj *procName, + parameterDefinition CONST *paramPtr, int nrParameters, parseContext *pc); static int getMatchObject(Tcl_Interp *interp, Tcl_Obj *patternObj, Tcl_Obj *origObj, XOTclObject **matchObject, char **pattern); @@ -285,7 +284,7 @@ puts "static methodDefinition method_definitions\[\] = \{\n$definitionString\n\};\n" } -proc methodDefinition {methodName methodType implementation argDefinitions} { +proc methodDefinition {methodName methodType implementation parameterDefinitions} { set d(methodName) $methodName set d(implementation) $implementation set d(stub) ${implementation}Stub @@ -297,32 +296,32 @@ default {set d(clientData) ""} } set completed [list] - foreach argDefinition $argDefinitions { + foreach parameterDefinition $parameterDefinitions { array set "" {-required 0 -nrargs 0 -type ""} - array set "" $argDefinition + array set "" $parameterDefinition lappend completed [array get ""] } - set d(argDefinitions) $completed + set d(parameterDefinitions) $completed set ::definitions($d(methodType)-$d(implementation)-$d(methodName)) [array get d] } -proc infoClassMethod {methodName implementation argDefinitions} { - methodDefinition $methodName infoClassMethod $implementation $argDefinitions +proc infoClassMethod {methodName implementation parameterDefinitions} { + methodDefinition $methodName infoClassMethod $implementation $parameterDefinitions } -proc infoObjectMethod {methodName implementation argDefinitions} { - methodDefinition $methodName infoObjectMethod $implementation $argDefinitions +proc infoObjectMethod {methodName implementation parameterDefinitions} { + methodDefinition $methodName infoObjectMethod $implementation $parameterDefinitions } -proc checkMethod {methodName implementation argDefinitions} { - methodDefinition type=$methodName checkMethod $implementation $argDefinitions +proc checkMethod {methodName implementation parameterDefinitions} { + methodDefinition type=$methodName checkMethod $implementation $parameterDefinitions } -proc classMethod {methodName implementation argDefinitions} { - methodDefinition $methodName classMethod $implementation $argDefinitions +proc classMethod {methodName implementation parameterDefinitions} { + methodDefinition $methodName classMethod $implementation $parameterDefinitions } -proc objectMethod {methodName implementation argDefinitions} { - methodDefinition $methodName objectMethod $implementation $argDefinitions +proc objectMethod {methodName implementation parameterDefinitions} { + methodDefinition $methodName objectMethod $implementation $parameterDefinitions } -proc xotclCmd {methodName implementation argDefinitions} { - methodDefinition $methodName xotclCmd $implementation $argDefinitions +proc xotclCmd {methodName implementation parameterDefinitions} { + methodDefinition $methodName xotclCmd $implementation $parameterDefinitions } source [file dirname [info script]]/gentclAPI.decls Index: generic/tclAPI.h =================================================================== diff -u -rbedcf64642123d38ace4f5117e2b4b99fe9a0e06 -r300e593347cf3f13d62ac4d21299a2278ff83d5e --- generic/tclAPI.h (.../tclAPI.h) (revision bedcf64642123d38ace4f5117e2b4b99fe9a0e06) +++ generic/tclAPI.h (.../tclAPI.h) (revision 300e593347cf3f13d62ac4d21299a2278ff83d5e) @@ -21,13 +21,12 @@ typedef struct { char *methodName; Tcl_ObjCmdProc *proc; - /*CONST interfaceDefinition ifd;*/ - int ifdSize; - argDefinition ifd[10]; + int nrParameters; + parameterDefinition paramDefs[10]; } methodDefinition; -static int parseObjv(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], Tcl_Obj *procName, - argDefinition CONST *ifdPtr, int ifdSize, parseContext *pc); +static int ArgumentParse(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], Tcl_Obj *procName, + parameterDefinition CONST *paramPtr, int nrParameters, parseContext *pc); static int getMatchObject(Tcl_Interp *interp, Tcl_Obj *patternObj, Tcl_Obj *origObj, XOTclObject **matchObject, char **pattern); @@ -358,10 +357,10 @@ XOTclCheckBooleanArgsStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCheckBooleanArgsIdx].ifd, - method_definitions[XOTclCheckBooleanArgsIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCheckBooleanArgsIdx].paramDefs, + method_definitions[XOTclCheckBooleanArgsIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *name = (char *)pc.clientData[0]; @@ -377,10 +376,10 @@ XOTclCheckRequiredArgsStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCheckRequiredArgsIdx].ifd, - method_definitions[XOTclCheckRequiredArgsIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCheckRequiredArgsIdx].paramDefs, + method_definitions[XOTclCheckRequiredArgsIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *name = (char *)pc.clientData[0]; @@ -397,10 +396,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCAllocMethodIdx].ifd, - method_definitions[XOTclCAllocMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCAllocMethodIdx].paramDefs, + method_definitions[XOTclCAllocMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *name = (char *)pc.clientData[0]; @@ -416,10 +415,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCCreateMethodIdx].ifd, - method_definitions[XOTclCCreateMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCCreateMethodIdx].paramDefs, + method_definitions[XOTclCCreateMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *name = (char *)pc.clientData[0]; @@ -435,10 +434,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCDeallocMethodIdx].ifd, - method_definitions[XOTclCDeallocMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCDeallocMethodIdx].paramDefs, + method_definitions[XOTclCDeallocMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *object = (Tcl_Obj *)pc.clientData[0]; @@ -454,10 +453,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCInstFilterGuardMethodIdx].ifd, - method_definitions[XOTclCInstFilterGuardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCInstFilterGuardMethodIdx].paramDefs, + method_definitions[XOTclCInstFilterGuardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *filter = (char *)pc.clientData[0]; @@ -474,10 +473,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCInstForwardMethodIdx].ifd, - method_definitions[XOTclCInstForwardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCInstForwardMethodIdx].paramDefs, + method_definitions[XOTclCInstForwardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *method = (Tcl_Obj *)pc.clientData[0]; @@ -500,10 +499,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCInstMixinGuardMethodIdx].ifd, - method_definitions[XOTclCInstMixinGuardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCInstMixinGuardMethodIdx].paramDefs, + method_definitions[XOTclCInstMixinGuardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *mixin = (char *)pc.clientData[0]; @@ -520,10 +519,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCInstParametercmdMethodIdx].ifd, - method_definitions[XOTclCInstParametercmdMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCInstParametercmdMethodIdx].paramDefs, + method_definitions[XOTclCInstParametercmdMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *name = (char *)pc.clientData[0]; @@ -539,10 +538,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCInstProcMethodIdx].ifd, - method_definitions[XOTclCInstProcMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCInstProcMethodIdx].paramDefs, + method_definitions[XOTclCInstProcMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *name = (Tcl_Obj *)pc.clientData[0]; @@ -562,10 +561,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCInstProcMethodCIdx].ifd, - method_definitions[XOTclCInstProcMethodCIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCInstProcMethodCIdx].paramDefs, + method_definitions[XOTclCInstProcMethodCIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *name = (Tcl_Obj *)pc.clientData[0]; @@ -585,10 +584,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCInvalidateObjectParameterMethodIdx].ifd, - method_definitions[XOTclCInvalidateObjectParameterMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCInvalidateObjectParameterMethodIdx].paramDefs, + method_definitions[XOTclCInvalidateObjectParameterMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { @@ -604,10 +603,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCInvariantsMethodIdx].ifd, - method_definitions[XOTclCInvariantsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCInvariantsMethodIdx].paramDefs, + method_definitions[XOTclCInvariantsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *invariantlist = (Tcl_Obj *)pc.clientData[0]; @@ -623,10 +622,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCNewMethodIdx].ifd, - method_definitions[XOTclCNewMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCNewMethodIdx].paramDefs, + method_definitions[XOTclCNewMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *withChildof = (XOTclObject *)pc.clientData[0]; @@ -642,10 +641,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCRecreateMethodIdx].ifd, - method_definitions[XOTclCRecreateMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCRecreateMethodIdx].paramDefs, + method_definitions[XOTclCRecreateMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *name = (Tcl_Obj *)pc.clientData[0]; @@ -661,10 +660,10 @@ parseContext pc; XOTclClass *cl = XOTclObjectToClass(clientData); if (!cl) return XOTclObjErrType(interp, objv[0], "Class"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCUnknownMethodIdx].ifd, - method_definitions[XOTclCUnknownMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCUnknownMethodIdx].paramDefs, + method_definitions[XOTclCUnknownMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *name = (char *)pc.clientData[0]; @@ -679,10 +678,10 @@ XOTclClassInfoHeritageMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoHeritageMethodIdx].ifd, - method_definitions[XOTclClassInfoHeritageMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoHeritageMethodIdx].paramDefs, + method_definitions[XOTclClassInfoHeritageMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -698,10 +697,10 @@ XOTclClassInfoInstancesMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstancesMethodIdx].ifd, - method_definitions[XOTclClassInfoInstancesMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstancesMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstancesMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -732,10 +731,10 @@ XOTclClassInfoInstargsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstargsMethodIdx].ifd, - method_definitions[XOTclClassInfoInstargsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstargsMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstargsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -751,10 +750,10 @@ XOTclClassInfoInstbodyMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstbodyMethodIdx].ifd, - method_definitions[XOTclClassInfoInstbodyMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstbodyMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstbodyMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -770,10 +769,10 @@ XOTclClassInfoInstcommandsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstcommandsMethodIdx].ifd, - method_definitions[XOTclClassInfoInstcommandsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstcommandsMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstcommandsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -789,10 +788,10 @@ XOTclClassInfoInstdefaultMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstdefaultMethodIdx].ifd, - method_definitions[XOTclClassInfoInstdefaultMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstdefaultMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstdefaultMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -810,10 +809,10 @@ XOTclClassInfoInstfilterMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstfilterMethodIdx].ifd, - method_definitions[XOTclClassInfoInstfilterMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstfilterMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstfilterMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -830,10 +829,10 @@ XOTclClassInfoInstfilterguardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstfilterguardMethodIdx].ifd, - method_definitions[XOTclClassInfoInstfilterguardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstfilterguardMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstfilterguardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -849,10 +848,10 @@ XOTclClassInfoInstforwardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstforwardMethodIdx].ifd, - method_definitions[XOTclClassInfoInstforwardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstforwardMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstforwardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -869,10 +868,10 @@ XOTclClassInfoInstinvarMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstinvarMethodIdx].ifd, - method_definitions[XOTclClassInfoInstinvarMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstinvarMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstinvarMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -887,10 +886,10 @@ XOTclClassInfoInstmixinMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstmixinMethodIdx].ifd, - method_definitions[XOTclClassInfoInstmixinMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstmixinMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstmixinMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -922,10 +921,10 @@ XOTclClassInfoInstmixinguardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstmixinguardMethodIdx].ifd, - method_definitions[XOTclClassInfoInstmixinguardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstmixinguardMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstmixinguardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -941,10 +940,10 @@ XOTclClassInfoInstmixinofMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstmixinofMethodIdx].ifd, - method_definitions[XOTclClassInfoInstmixinofMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstmixinofMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstmixinofMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -975,10 +974,10 @@ XOTclClassInfoInstnonposargsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstnonposargsMethodIdx].ifd, - method_definitions[XOTclClassInfoInstnonposargsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstnonposargsMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstnonposargsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -994,10 +993,10 @@ XOTclClassInfoInstparametercmdMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstparametercmdMethodIdx].ifd, - method_definitions[XOTclClassInfoInstparametercmdMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstparametercmdMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstparametercmdMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -1013,10 +1012,10 @@ XOTclClassInfoInstpostMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstpostMethodIdx].ifd, - method_definitions[XOTclClassInfoInstpostMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstpostMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstpostMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -1032,10 +1031,10 @@ XOTclClassInfoInstpreMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstpreMethodIdx].ifd, - method_definitions[XOTclClassInfoInstpreMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstpreMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstpreMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -1051,10 +1050,10 @@ XOTclClassInfoInstprocsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoInstprocsMethodIdx].ifd, - method_definitions[XOTclClassInfoInstprocsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoInstprocsMethodIdx].paramDefs, + method_definitions[XOTclClassInfoInstprocsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -1070,10 +1069,10 @@ XOTclClassInfoMixinofMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoMixinofMethodIdx].ifd, - method_definitions[XOTclClassInfoMixinofMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoMixinofMethodIdx].paramDefs, + method_definitions[XOTclClassInfoMixinofMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -1104,10 +1103,10 @@ XOTclClassInfoParameterMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoParameterMethodIdx].ifd, - method_definitions[XOTclClassInfoParameterMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoParameterMethodIdx].paramDefs, + method_definitions[XOTclClassInfoParameterMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -1122,10 +1121,10 @@ XOTclClassInfoSlotsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoSlotsMethodIdx].ifd, - method_definitions[XOTclClassInfoSlotsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoSlotsMethodIdx].paramDefs, + method_definitions[XOTclClassInfoSlotsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -1140,10 +1139,10 @@ XOTclClassInfoSubclassMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoSubclassMethodIdx].ifd, - method_definitions[XOTclClassInfoSubclassMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoSubclassMethodIdx].paramDefs, + method_definitions[XOTclClassInfoSubclassMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -1174,10 +1173,10 @@ XOTclClassInfoSuperclassMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclClassInfoSuperclassMethodIdx].ifd, - method_definitions[XOTclClassInfoSuperclassMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclClassInfoSuperclassMethodIdx].paramDefs, + method_definitions[XOTclClassInfoSuperclassMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclClass *class = (XOTclClass *)pc.clientData[0]; @@ -1194,10 +1193,10 @@ XOTclObjInfoArgsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoArgsMethodIdx].ifd, - method_definitions[XOTclObjInfoArgsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoArgsMethodIdx].paramDefs, + method_definitions[XOTclObjInfoArgsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1213,10 +1212,10 @@ XOTclObjInfoBodyMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoBodyMethodIdx].ifd, - method_definitions[XOTclObjInfoBodyMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoBodyMethodIdx].paramDefs, + method_definitions[XOTclObjInfoBodyMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1232,10 +1231,10 @@ XOTclObjInfoCheckMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoCheckMethodIdx].ifd, - method_definitions[XOTclObjInfoCheckMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoCheckMethodIdx].paramDefs, + method_definitions[XOTclObjInfoCheckMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1250,10 +1249,10 @@ XOTclObjInfoChildrenMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoChildrenMethodIdx].ifd, - method_definitions[XOTclObjInfoChildrenMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoChildrenMethodIdx].paramDefs, + method_definitions[XOTclObjInfoChildrenMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1269,10 +1268,10 @@ XOTclObjInfoClassMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoClassMethodIdx].ifd, - method_definitions[XOTclObjInfoClassMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoClassMethodIdx].paramDefs, + method_definitions[XOTclObjInfoClassMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1287,10 +1286,10 @@ XOTclObjInfoCommandsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoCommandsMethodIdx].ifd, - method_definitions[XOTclObjInfoCommandsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoCommandsMethodIdx].paramDefs, + method_definitions[XOTclObjInfoCommandsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1306,10 +1305,10 @@ XOTclObjInfoDefaultMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoDefaultMethodIdx].ifd, - method_definitions[XOTclObjInfoDefaultMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoDefaultMethodIdx].paramDefs, + method_definitions[XOTclObjInfoDefaultMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1327,10 +1326,10 @@ XOTclObjInfoFilterMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoFilterMethodIdx].ifd, - method_definitions[XOTclObjInfoFilterMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoFilterMethodIdx].paramDefs, + method_definitions[XOTclObjInfoFilterMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1348,10 +1347,10 @@ XOTclObjInfoFilterguardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoFilterguardMethodIdx].ifd, - method_definitions[XOTclObjInfoFilterguardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoFilterguardMethodIdx].paramDefs, + method_definitions[XOTclObjInfoFilterguardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1367,10 +1366,10 @@ XOTclObjInfoForwardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoForwardMethodIdx].ifd, - method_definitions[XOTclObjInfoForwardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoForwardMethodIdx].paramDefs, + method_definitions[XOTclObjInfoForwardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1387,10 +1386,10 @@ XOTclObjInfoHasnamespaceMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoHasnamespaceMethodIdx].ifd, - method_definitions[XOTclObjInfoHasnamespaceMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoHasnamespaceMethodIdx].paramDefs, + method_definitions[XOTclObjInfoHasnamespaceMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1405,10 +1404,10 @@ XOTclObjInfoInvarMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoInvarMethodIdx].ifd, - method_definitions[XOTclObjInfoInvarMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoInvarMethodIdx].paramDefs, + method_definitions[XOTclObjInfoInvarMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1423,10 +1422,10 @@ XOTclObjInfoMethodsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoMethodsMethodIdx].ifd, - method_definitions[XOTclObjInfoMethodsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoMethodsMethodIdx].paramDefs, + method_definitions[XOTclObjInfoMethodsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1446,10 +1445,10 @@ XOTclObjInfoMixinMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoMixinMethodIdx].ifd, - method_definitions[XOTclObjInfoMixinMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoMixinMethodIdx].paramDefs, + method_definitions[XOTclObjInfoMixinMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1481,10 +1480,10 @@ XOTclObjInfoMixinguardMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoMixinguardMethodIdx].ifd, - method_definitions[XOTclObjInfoMixinguardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoMixinguardMethodIdx].paramDefs, + method_definitions[XOTclObjInfoMixinguardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1500,10 +1499,10 @@ XOTclObjInfoNonposargsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoNonposargsMethodIdx].ifd, - method_definitions[XOTclObjInfoNonposargsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoNonposargsMethodIdx].paramDefs, + method_definitions[XOTclObjInfoNonposargsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1519,10 +1518,10 @@ XOTclObjInfoParametercmdMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoParametercmdMethodIdx].ifd, - method_definitions[XOTclObjInfoParametercmdMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoParametercmdMethodIdx].paramDefs, + method_definitions[XOTclObjInfoParametercmdMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1538,10 +1537,10 @@ XOTclObjInfoParentMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoParentMethodIdx].ifd, - method_definitions[XOTclObjInfoParentMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoParentMethodIdx].paramDefs, + method_definitions[XOTclObjInfoParentMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1556,10 +1555,10 @@ XOTclObjInfoPostMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoPostMethodIdx].ifd, - method_definitions[XOTclObjInfoPostMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoPostMethodIdx].paramDefs, + method_definitions[XOTclObjInfoPostMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1575,10 +1574,10 @@ XOTclObjInfoPreMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoPreMethodIdx].ifd, - method_definitions[XOTclObjInfoPreMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoPreMethodIdx].paramDefs, + method_definitions[XOTclObjInfoPreMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1594,10 +1593,10 @@ XOTclObjInfoPrecedenceMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoPrecedenceMethodIdx].ifd, - method_definitions[XOTclObjInfoPrecedenceMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoPrecedenceMethodIdx].paramDefs, + method_definitions[XOTclObjInfoPrecedenceMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1614,10 +1613,10 @@ XOTclObjInfoProcsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoProcsMethodIdx].ifd, - method_definitions[XOTclObjInfoProcsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoProcsMethodIdx].paramDefs, + method_definitions[XOTclObjInfoProcsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1633,10 +1632,10 @@ XOTclObjInfoSlotObjectsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoSlotObjectsMethodIdx].ifd, - method_definitions[XOTclObjInfoSlotObjectsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoSlotObjectsMethodIdx].paramDefs, + method_definitions[XOTclObjInfoSlotObjectsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1652,10 +1651,10 @@ XOTclObjInfoVarsMethodStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclObjInfoVarsMethodIdx].ifd, - method_definitions[XOTclObjInfoVarsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclObjInfoVarsMethodIdx].paramDefs, + method_definitions[XOTclObjInfoVarsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -1672,10 +1671,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOAutonameMethodIdx].ifd, - method_definitions[XOTclOAutonameMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOAutonameMethodIdx].paramDefs, + method_definitions[XOTclOAutonameMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { int withInstance = (int )pc.clientData[0]; @@ -1693,10 +1692,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOCheckMethodIdx].ifd, - method_definitions[XOTclOCheckMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOCheckMethodIdx].paramDefs, + method_definitions[XOTclOCheckMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *flag = (Tcl_Obj *)pc.clientData[0]; @@ -1712,10 +1711,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOCleanupMethodIdx].ifd, - method_definitions[XOTclOCleanupMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOCleanupMethodIdx].paramDefs, + method_definitions[XOTclOCleanupMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { @@ -1741,10 +1740,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclODestroyMethodIdx].ifd, - method_definitions[XOTclODestroyMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclODestroyMethodIdx].paramDefs, + method_definitions[XOTclODestroyMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { @@ -1760,10 +1759,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOExistsMethodIdx].ifd, - method_definitions[XOTclOExistsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOExistsMethodIdx].paramDefs, + method_definitions[XOTclOExistsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *var = (char *)pc.clientData[0]; @@ -1779,10 +1778,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOFilterGuardMethodIdx].ifd, - method_definitions[XOTclOFilterGuardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOFilterGuardMethodIdx].paramDefs, + method_definitions[XOTclOFilterGuardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *filter = (char *)pc.clientData[0]; @@ -1799,10 +1798,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOFilterSearchMethodIdx].ifd, - method_definitions[XOTclOFilterSearchMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOFilterSearchMethodIdx].paramDefs, + method_definitions[XOTclOFilterSearchMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *filter = (char *)pc.clientData[0]; @@ -1818,10 +1817,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOForwardMethodIdx].ifd, - method_definitions[XOTclOForwardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOForwardMethodIdx].paramDefs, + method_definitions[XOTclOForwardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *method = (Tcl_Obj *)pc.clientData[0]; @@ -1854,10 +1853,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOInvariantsMethodIdx].ifd, - method_definitions[XOTclOInvariantsMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOInvariantsMethodIdx].paramDefs, + method_definitions[XOTclOInvariantsMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *invariantlist = (Tcl_Obj *)pc.clientData[0]; @@ -1873,10 +1872,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOIsClassMethodIdx].ifd, - method_definitions[XOTclOIsClassMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOIsClassMethodIdx].paramDefs, + method_definitions[XOTclOIsClassMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *class = (Tcl_Obj *)pc.clientData[0]; @@ -1892,10 +1891,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOIsMetaClassMethodIdx].ifd, - method_definitions[XOTclOIsMetaClassMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOIsMetaClassMethodIdx].paramDefs, + method_definitions[XOTclOIsMetaClassMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *metaclass = (Tcl_Obj *)pc.clientData[0]; @@ -1911,10 +1910,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOIsMixinMethodIdx].ifd, - method_definitions[XOTclOIsMixinMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOIsMixinMethodIdx].paramDefs, + method_definitions[XOTclOIsMixinMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *class = (Tcl_Obj *)pc.clientData[0]; @@ -1930,10 +1929,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOIsObjectMethodIdx].ifd, - method_definitions[XOTclOIsObjectMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOIsObjectMethodIdx].paramDefs, + method_definitions[XOTclOIsObjectMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *object = (Tcl_Obj *)pc.clientData[0]; @@ -1949,10 +1948,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOIsTypeMethodIdx].ifd, - method_definitions[XOTclOIsTypeMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOIsTypeMethodIdx].paramDefs, + method_definitions[XOTclOIsTypeMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *class = (Tcl_Obj *)pc.clientData[0]; @@ -1968,10 +1967,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOMixinGuardMethodIdx].ifd, - method_definitions[XOTclOMixinGuardMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOMixinGuardMethodIdx].paramDefs, + method_definitions[XOTclOMixinGuardMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *mixin = (char *)pc.clientData[0]; @@ -1998,10 +1997,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclONoinitMethodIdx].ifd, - method_definitions[XOTclONoinitMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclONoinitMethodIdx].paramDefs, + method_definitions[XOTclONoinitMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { @@ -2017,10 +2016,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOParametercmdMethodIdx].ifd, - method_definitions[XOTclOParametercmdMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOParametercmdMethodIdx].paramDefs, + method_definitions[XOTclOParametercmdMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *name = (char *)pc.clientData[0]; @@ -2036,10 +2035,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOProcMethodIdx].ifd, - method_definitions[XOTclOProcMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOProcMethodIdx].paramDefs, + method_definitions[XOTclOProcMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *name = (Tcl_Obj *)pc.clientData[0]; @@ -2059,10 +2058,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOProcSearchMethodIdx].ifd, - method_definitions[XOTclOProcSearchMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOProcSearchMethodIdx].paramDefs, + method_definitions[XOTclOProcSearchMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *name = (char *)pc.clientData[0]; @@ -2078,10 +2077,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclORequireNamespaceMethodIdx].ifd, - method_definitions[XOTclORequireNamespaceMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclORequireNamespaceMethodIdx].paramDefs, + method_definitions[XOTclORequireNamespaceMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { @@ -2097,10 +2096,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOSetMethodIdx].ifd, - method_definitions[XOTclOSetMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOSetMethodIdx].paramDefs, + method_definitions[XOTclOSetMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { Tcl_Obj *var = (Tcl_Obj *)pc.clientData[0]; @@ -2147,10 +2146,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOVolatileMethodIdx].ifd, - method_definitions[XOTclOVolatileMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOVolatileMethodIdx].paramDefs, + method_definitions[XOTclOVolatileMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { @@ -2166,10 +2165,10 @@ parseContext pc; XOTclObject *obj = (XOTclObject *)clientData; if (!obj) return XOTclObjErrType(interp, objv[0], "Object"); - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclOVwaitMethodIdx].ifd, - method_definitions[XOTclOVwaitMethodIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclOVwaitMethodIdx].paramDefs, + method_definitions[XOTclOVwaitMethodIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *varname = (char *)pc.clientData[0]; @@ -2184,10 +2183,10 @@ XOTclAliasCmdStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclAliasCmdIdx].ifd, - method_definitions[XOTclAliasCmdIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclAliasCmdIdx].paramDefs, + method_definitions[XOTclAliasCmdIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -2207,10 +2206,10 @@ XOTclConfigureCmdStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclConfigureCmdIdx].ifd, - method_definitions[XOTclConfigureCmdIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclConfigureCmdIdx].paramDefs, + method_definitions[XOTclConfigureCmdIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { int configureoption = (int )pc.clientData[0]; @@ -2226,10 +2225,10 @@ XOTclCreateObjectSystemCmdStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclCreateObjectSystemCmdIdx].ifd, - method_definitions[XOTclCreateObjectSystemCmdIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclCreateObjectSystemCmdIdx].paramDefs, + method_definitions[XOTclCreateObjectSystemCmdIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *rootClass = (char *)pc.clientData[0]; @@ -2245,10 +2244,10 @@ XOTclDeprecatedCmdStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclDeprecatedCmdIdx].ifd, - method_definitions[XOTclDeprecatedCmdIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclDeprecatedCmdIdx].paramDefs, + method_definitions[XOTclDeprecatedCmdIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { char *oldCmd = (char *)pc.clientData[0]; @@ -2264,10 +2263,10 @@ XOTclFinalizeObjCmdStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclFinalizeObjCmdIdx].ifd, - method_definitions[XOTclFinalizeObjCmdIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclFinalizeObjCmdIdx].paramDefs, + method_definitions[XOTclFinalizeObjCmdIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { @@ -2291,10 +2290,10 @@ XOTclMethodPropertyCmdStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclMethodPropertyCmdIdx].ifd, - method_definitions[XOTclMethodPropertyCmdIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclMethodPropertyCmdIdx].paramDefs, + method_definitions[XOTclMethodPropertyCmdIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -2313,10 +2312,10 @@ XOTclMyCmdStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclMyCmdIdx].ifd, - method_definitions[XOTclMyCmdIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclMyCmdIdx].paramDefs, + method_definitions[XOTclMyCmdIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { int withLocal = (int )pc.clientData[0]; @@ -2332,10 +2331,10 @@ XOTclRelationCmdStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclRelationCmdIdx].ifd, - method_definitions[XOTclRelationCmdIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclRelationCmdIdx].paramDefs, + method_definitions[XOTclRelationCmdIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; @@ -2352,10 +2351,10 @@ XOTclSetInstvarCmdStub(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { parseContext pc; - if (parseObjv(interp, objc, objv, objv[0], - method_definitions[XOTclSetInstvarCmdIdx].ifd, - method_definitions[XOTclSetInstvarCmdIdx].ifdSize, - &pc) != TCL_OK) { + if (ArgumentParse(interp, objc, objv, objv[0], + method_definitions[XOTclSetInstvarCmdIdx].paramDefs, + method_definitions[XOTclSetInstvarCmdIdx].nrParameters, + &pc) != TCL_OK) { return TCL_ERROR; } else { XOTclObject *object = (XOTclObject *)pc.clientData[0]; Index: generic/xotcl.c =================================================================== diff -u -r0f1d08f0090b3cb676b82f049bae6fe354d331ff -r300e593347cf3f13d62ac4d21299a2278ff83d5e --- generic/xotcl.c (.../xotcl.c) (revision 0f1d08f0090b3cb676b82f049bae6fe354d331ff) +++ generic/xotcl.c (.../xotcl.c) (revision 300e593347cf3f13d62ac4d21299a2278ff83d5e) @@ -72,9 +72,9 @@ Tcl_SubstObjCmd(clientData, interp, objc, objv) #endif -/* maybe move to stubs? */ -int XOTclObjErrArgCntObj(Tcl_Interp *interp, Tcl_Obj *cmdName, Tcl_Obj *methodName, Tcl_Obj *msg); +int XOTclObjWrongArgs(Tcl_Interp *interp, char *msg, Tcl_Obj *cmdName, Tcl_Obj *methodName, char *arglist); +/* maybe move to stubs? */ static int createMethod(Tcl_Interp *interp, XOTclClass *cl, char *name, int objc, Tcl_Obj *CONST objv[]); static Tcl_Obj *NameInNamespaceObj(Tcl_Interp *interp, char *name, Tcl_Namespace *ns); @@ -111,7 +111,7 @@ typedef struct XOTclProcContext { ClientData oldDeleteData; Tcl_CmdDeleteProc *oldDeleteProc; - XOTclNonposArgs *nonposArgs; + XOTclParamDefs *paramDefs; } XOTclProcContext; typedef struct tclCmdClientData { @@ -155,11 +155,12 @@ int lastobjc; int objc; int mustDecr; + int varArgs; } parseContext; #if defined(CANONICAL_ARGS) int ProcessMethodArguments(parseContext *pcPtr, Tcl_Interp *interp, - XOTclObject *obj, XOTclNonposArgs *nonposArgs, + XOTclObject *obj, XOTclParamDefs *paramDefs, char *methodName, int objc, Tcl_Obj *CONST objv[]); #endif @@ -225,7 +226,7 @@ /*fprintf(stderr,"release free %p %p\n",pc->full_objv,pc->clientData);*/ ckfree((char *)pc->full_objv); } - /* if the interface was extended, both clientData and flags are extended */ + /* if the parameter definition was extended, both clientData and flags are extended */ if (pc->clientData != &pc->clientData_static[0]) { ckfree((char *)pc->clientData); ckfree((char *)pc->flags); @@ -4844,8 +4845,8 @@ void XOTclProcDeleteProc(ClientData clientData) { XOTclProcContext *ctxPtr = (XOTclProcContext *)clientData; (*ctxPtr->oldDeleteProc)(ctxPtr->oldDeleteData); - if (ctxPtr->nonposArgs) { - fprintf(stderr, "would free %p\n",ctxPtr->nonposArgs); + if (ctxPtr->paramDefs) { + fprintf(stderr, "would free %p\n",ctxPtr->paramDefs); /*FREE(XOTclProcContext, ctxPtr->clientData);*/ } /*fprintf(stderr, "free %p\n",ctxPtr);*/ @@ -4867,16 +4868,16 @@ return FindProc(interp, Tcl_Namespace_cmdTable(class->nsPtr), methodName); } -static XOTclNonposArgs * -getNonposArgs(Tcl_Command cmdPtr) { +static XOTclParamDefs * +ParamDefsGet(Tcl_Command cmdPtr) { if (Tcl_Command_deleteProc(cmdPtr) == XOTclProcDeleteProc) { - return ((XOTclProcContext *)Tcl_Command_deleteData(cmdPtr))->nonposArgs; + return ((XOTclProcContext *)Tcl_Command_deleteData(cmdPtr))->paramDefs; } return NULL; } static int -addNonposArgs(Tcl_Interp *interp, Tcl_Command cmd, XOTclNonposArgs *nonposArgs) { +ParamDefsStore(Tcl_Interp *interp, Tcl_Command cmd, XOTclParamDefs *paramDefs) { Command *cmdPtr = (Command *)cmd; if (cmdPtr->deleteProc == TclProcDeleteProc) { @@ -4885,7 +4886,7 @@ ctxPtr->oldDeleteData = (Proc *)cmdPtr->deleteData; ctxPtr->oldDeleteProc = cmdPtr->deleteProc; cmdPtr->deleteProc = XOTclProcDeleteProc; - ctxPtr->nonposArgs = nonposArgs; + ctxPtr->paramDefs = paramDefs; cmdPtr->deleteData = (ClientData)ctxPtr; return TCL_OK; } @@ -4988,17 +4989,17 @@ # if defined(CANONICAL_ARGS) /* - If the method to be invoked hasnonposArgs, we have to call the + If the method to be invoked hasparamDefs, we have to call the argument parser with the argument definitions obtained from the proc context from the cmdPtr. */ { - XOTclNonposArgs *nonposArgs = Tcl_Command_deleteProc(cmdPtr) == XOTclProcDeleteProc ? - ((XOTclProcContext *)Tcl_Command_deleteData(cmdPtr))->nonposArgs : NULL; + XOTclParamDefs *paramDefs = Tcl_Command_deleteProc(cmdPtr) == XOTclProcDeleteProc ? + ((XOTclProcContext *)Tcl_Command_deleteData(cmdPtr))->paramDefs : NULL; - if (nonposArgs) { + if (paramDefs) { parseContext pc; - result = ProcessMethodArguments(&pc, interp, obj, nonposArgs, methodName, objc, objv); + result = ProcessMethodArguments(&pc, interp, obj, paramDefs, methodName, objc, objv); /* TODO: check potential leak for */ if (result == TCL_OK) { result = PushProcCallFrame(cp, interp, pc.objc, pc.full_objv, csc); @@ -5458,28 +5459,28 @@ * Non Positional Args */ -static void argDefinitionsFree(argDefinition *argDefinitions); -static void NonposArgsFree(XOTclNonposArgs *nonposArgs) { - if (nonposArgs->ifd) { - argDefinitionsFree(nonposArgs->ifd); +static void parameterDefinitionsFree(parameterDefinition *parameterDefinitions); +static void NonposArgsFree(XOTclParamDefs *paramDefs) { + if (paramDefs->paramPtr) { + parameterDefinitionsFree(paramDefs->paramPtr); } - FREE(XOTclNonposArgs, nonposArgs); + FREE(XOTclParamDefs, paramDefs); } -static void ParsedInterfaceDefinitionFree(XOTclParsedInterfaceDefinition *parsedIf) { - /*fprintf(stderr, "ParsedInterfaceDefinitionFree %p, npargs %p\n",parsedIf,parsedIf->nonposArgs);*/ - if (parsedIf->nonposArgs) { - NonposArgsFree(parsedIf->nonposArgs); +static void ParsedParameterDefinitionFree(XOTclParsedParameterDefinition *parsedParamPtr) { + /*fprintf(stderr, "ParsedParameterDefinitionFree %p, npargs %p\n",parsedParamPtr,parsedParamPtr->ParamDefs);*/ + if (parsedParamPtr->paramDefs) { + NonposArgsFree(parsedParamPtr->paramDefs); } - FREE(XOTclParsedInterfaceDefinition, parsedIf); + FREE(XOTclParsedParameterDefinition, parsedParamPtr); } static Tcl_Obj * -NonposArgsFormat(Tcl_Interp *interp, XOTclNonposArgs *nonposArgs) { +NonposArgsFormat(Tcl_Interp *interp, XOTclParamDefs *paramDefs) { int first; Tcl_Obj *list = Tcl_NewListObj(0, NULL), *innerlist, *nameStringObj; - argDefinition CONST *aPtr; + parameterDefinition CONST *aPtr; - for (aPtr = nonposArgs->ifd; aPtr->name; aPtr++) { + for (aPtr = paramDefs->paramPtr; aPtr->name; aPtr++) { if (*aPtr->name == '-') { first = 1; nameStringObj = Tcl_NewStringObj(aPtr->name, -1); @@ -5512,22 +5513,22 @@ * Proc-Creation */ -static Tcl_Obj *addPrefixToBody(Tcl_Obj *body, int nonposArgs, XOTclParsedInterfaceDefinition *ifPtr) { +static Tcl_Obj *addPrefixToBody(Tcl_Obj *body, int paramDefs, XOTclParsedParameterDefinition *paramPtr) { Tcl_Obj *resultBody = Tcl_NewStringObj("", 0); INCR_REF_COUNT(resultBody); #if defined(PRE85) Tcl_AppendStringsToObj(resultBody, "::xotcl::initProcNS\n", (char *) NULL); - if (nonposArgs) + if (paramDefs) Tcl_AppendStringsToObj(resultBody, "::eval ::xotcl::interpretNonpositionalArgs $args\n", (char *) NULL); #else # if !defined(CANONICAL_ARGS) - if (nonposArgs) + if (paramDefs) Tcl_AppendStringsToObj(resultBody, "::xotcl::interpretNonpositionalArgs {*}$args\n", (char *) NULL); # else - if (nonposArgs && ifPtr->possibleUnknowns > 0) + if (paramDefs && paramPtr->possibleUnknowns > 0) Tcl_AppendStringsToObj(resultBody, "::xotcl::unsetUnknownArgs\n", (char *) NULL); # endif #endif @@ -5551,23 +5552,23 @@ #define NEW_STRING(target,p,l) target = ckalloc(l+1); strncpy(target,p,l); *((target)+l) = '\0' -static argDefinition *argDefinitionsNew(int nr) { - argDefinition *interface = NEW_ARRAY(argDefinition,nr+1); - memset(interface, 0, sizeof(argDefinition)*(nr+1)); - return interface; +static parameterDefinition *ParameterDefinitionsNew(int nr) { + parameterDefinition *paramDefsPtr = NEW_ARRAY(parameterDefinition,nr+1); + memset(paramDefsPtr, 0, sizeof(parameterDefinition)*(nr+1)); + return paramDefsPtr; } -static void argDefinitionsFree(argDefinition *argDefinitions) { - argDefinition *ifPtr; +static void parameterDefinitionsFree(parameterDefinition *parameterDefinitions) { + parameterDefinition *paramPtr; - /*fprintf(stderr,"freeing %d argDefinitions\n",nr);*/ - for (ifPtr=argDefinitions; ifPtr->name; ifPtr++) { - /*fprintf(stderr,".... ifPtr = %p, name=%s, defaultValue %p\n",ifPtr,ifPtr->name,ifPtr->defaultValue);*/ - if (ifPtr->name) ckfree(ifPtr->name); - if (ifPtr->nameObj) {DECR_REF_COUNT(ifPtr->nameObj);} - if (ifPtr->defaultValue) {DECR_REF_COUNT(ifPtr->defaultValue);} + /*fprintf(stderr,"freeing %d parameterDefinitions\n",nr);*/ + for (paramPtr=parameterDefinitions; paramPtr->name; paramPtr++) { + /*fprintf(stderr,".... paramPtr = %p, name=%s, defaultValue %p\n",paramPtr,paramPtr->name,paramPtr->defaultValue);*/ + if (paramPtr->name) ckfree(paramPtr->name); + if (paramPtr->nameObj) {DECR_REF_COUNT(paramPtr->nameObj);} + if (paramPtr->defaultValue) {DECR_REF_COUNT(paramPtr->defaultValue);} } - FREE(argDefinition*,argDefinitions); + FREE(parameterDefinition*,parameterDefinitions); } XOTCLINLINE static int @@ -5663,50 +5664,50 @@ } static int -parseNonposargsOption(Tcl_Interp *interp, char *option, int length, argDefinition *ifPtr) { - /*fprintf(stderr, "def %s, option '%s' (%d)\n",ifPtr->name,option,length);*/ +parseNonposargsOption(Tcl_Interp *interp, char *option, int length, parameterDefinition *paramPtr) { + /*fprintf(stderr, "def %s, option '%s' (%d)\n",paramPtr->name,option,length);*/ if (strncmp(option,"required",length) == 0) { - ifPtr->flags |= XOTCL_ARG_REQUIRED; + paramPtr->flags |= XOTCL_ARG_REQUIRED; } else if (strncmp(option,"substdefault",length) == 0) { - ifPtr->flags |= XOTCL_ARG_SUBST_DEFAULT; + paramPtr->flags |= XOTCL_ARG_SUBST_DEFAULT; } else if (strncmp(option,"initcmd",length) == 0) { - ifPtr->flags |= XOTCL_ARG_INITCMD; + paramPtr->flags |= XOTCL_ARG_INITCMD; } else if (strncmp(option,"switch",length) == 0) { - ifPtr->nrargs = 0; - ifPtr->converter = convertToSwitch; - assert(ifPtr->defaultValue == NULL); - ifPtr->defaultValue = Tcl_NewBooleanObj(0); - INCR_REF_COUNT(ifPtr->defaultValue); - ifPtr->type = "switch"; + paramPtr->nrargs = 0; + paramPtr->converter = convertToSwitch; + assert(paramPtr->defaultValue == NULL); + paramPtr->defaultValue = Tcl_NewBooleanObj(0); + INCR_REF_COUNT(paramPtr->defaultValue); + paramPtr->type = "switch"; } else if (strncmp(option,"integer",length) == 0) { - ifPtr->nrargs = 1; - ifPtr->converter = convertToInteger; - ifPtr->type = "integer"; + paramPtr->nrargs = 1; + paramPtr->converter = convertToInteger; + paramPtr->type = "integer"; } else if (strncmp(option,"boolean",length) == 0) { - ifPtr->nrargs = 1; - ifPtr->converter = convertToBoolean; - ifPtr->type = "boolean"; + paramPtr->nrargs = 1; + paramPtr->converter = convertToBoolean; + paramPtr->type = "boolean"; } else if (strncmp(option,"object",length) == 0) { - ifPtr->nrargs = 1; - ifPtr->converter = convertToObject; - ifPtr->type = "object"; + paramPtr->nrargs = 1; + paramPtr->converter = convertToObject; + paramPtr->type = "object"; } else if (strncmp(option,"class",length) == 0) { - ifPtr->nrargs = 1; - ifPtr->converter = convertToClass; - ifPtr->type = "class"; + paramPtr->nrargs = 1; + paramPtr->converter = convertToClass; + paramPtr->type = "class"; } else if (strncmp(option,"relation",length) == 0) { - ifPtr->nrargs = 1; - ifPtr->converter = convertToRelation; - ifPtr->type = "tclobj"; + paramPtr->nrargs = 1; + paramPtr->converter = convertToRelation; + paramPtr->type = "tclobj"; } else { - fprintf(stderr, "**** unknown parameter option: def %s, option '%s' (%d)\n",ifPtr->name,option,length); + fprintf(stderr, "**** unknown parameter option: def %s, option '%s' (%d)\n",paramPtr->name,option,length); } return TCL_OK; } static int -parseArgDefinition(Tcl_Interp *interp, char *procName, Tcl_Obj *arg, int isNonposArgument, - argDefinition *ifPtr, int *possibleUnknowns) { +ParseParamDefinition(Tcl_Interp *interp, char *procName, Tcl_Obj *arg, int isNonposArgument, + parameterDefinition *paramPtr, int *possibleUnknowns) { Tcl_Obj **npav; char *argString, *argName; int rc, npac, length, j, nameLength; @@ -5729,11 +5730,11 @@ if (isNonposArgument) { argName = argString+1; nameLength = length-1; - ifPtr->nrargs = 1; /* per default 1 argument, switches set their arg numbers */ + paramPtr->nrargs = 1; /* per default 1 argument, switches set their arg numbers */ } else { argName = argString; nameLength = length; - ifPtr->flags |= XOTCL_ARG_REQUIRED; /* positional arguments are required unless we have a default */ + paramPtr->flags |= XOTCL_ARG_REQUIRED; /* positional arguments are required unless we have a default */ } /*fprintf(stderr, "... parsing '%s', name '%s' \n",ObjStr(arg),argName);*/ @@ -5747,9 +5748,9 @@ /* we found a ':' */ int l, start, end; - NEW_STRING(ifPtr->name,argString,j); - ifPtr->nameObj = Tcl_NewStringObj(argName,isNonposArgument ? j-1 : j); - INCR_REF_COUNT(ifPtr->nameObj); + NEW_STRING(paramPtr->name,argString,j); + paramPtr->nameObj = Tcl_NewStringObj(argName,isNonposArgument ? j-1 : j); + INCR_REF_COUNT(paramPtr->nameObj); /* skip space */ for (start = j+1; start0 && isspace((int)argString[end-1]); end--); - parseNonposargsOption(interp, argString+start, end-start, ifPtr); + parseNonposargsOption(interp, argString+start, end-start, paramPtr); l++; /* skip space */ for (start = l; start0 && isspace((int)argString[end-1]); end--); /* process last option */ - parseNonposargsOption(interp, argString+start, end-start, ifPtr); + parseNonposargsOption(interp, argString+start, end-start, paramPtr); } else { /* no ':', the whole arg is the name */ - NEW_STRING(ifPtr->name,argString,length); - ifPtr->nameObj = Tcl_NewStringObj(argName,isNonposArgument ? length-1 : length); - INCR_REF_COUNT(ifPtr->nameObj); + NEW_STRING(paramPtr->name,argString,length); + paramPtr->nameObj = Tcl_NewStringObj(argName,isNonposArgument ? length-1 : length); + INCR_REF_COUNT(paramPtr->nameObj); if (isArgsString(argString)) { - ifPtr->converter = convertToNothing; - ifPtr->flags &= ~XOTCL_ARG_REQUIRED; + paramPtr->converter = convertToNothing; + paramPtr->flags &= ~XOTCL_ARG_REQUIRED; } } /* if we have two arguments in the list, the second one is a default value */ if (npac == 2) { /* if we have for some reason already a default value, free it */ - if (ifPtr->defaultValue) { + if (paramPtr->defaultValue) { /* might be set by parseNonposargsOption */ - DECR_REF_COUNT(ifPtr->defaultValue); + DECR_REF_COUNT(paramPtr->defaultValue); } - ifPtr->defaultValue = Tcl_DuplicateObj(npav[1]); - INCR_REF_COUNT(ifPtr->defaultValue); + paramPtr->defaultValue = Tcl_DuplicateObj(npav[1]); + INCR_REF_COUNT(paramPtr->defaultValue); /* the argument will not required for an invocation, since we have a default */ - ifPtr->flags &= ~XOTCL_ARG_REQUIRED; + paramPtr->flags &= ~XOTCL_ARG_REQUIRED; } - /*fprintf(stderr,"%p %s ifPtr->name = '%s', nrargs %d, required %d, converter %p default %s\n",ifPtr,procName, - ifPtr->name,ifPtr->nrargs,ifPtr->flags & XOTCL_ARG_REQUIRED, ifPtr->converter, - ifPtr->defaultValue ? ObjStr(ifPtr->defaultValue) : "NONE");*/ - if (ifPtr->converter == NULL) { - ifPtr->converter = convertToTclobj; + /*fprintf(stderr,"%p %s paramPtr->name = '%s', nrargs %d, required %d, converter %p default %s\n",paramPtr,procName, + paramPtr->name,paramPtr->nrargs,paramPtr->flags & XOTCL_ARG_REQUIRED, paramPtr->converter, + paramPtr->defaultValue ? ObjStr(paramPtr->defaultValue) : "NONE");*/ + if (paramPtr->converter == NULL) { + paramPtr->converter = convertToTclobj; } /* @@ -5805,20 +5806,20 @@ * canonical arg handlers for instprocs) the unknown value * (e.g. don't set/unset a variable) */ - if (!(ifPtr->flags & XOTCL_ARG_REQUIRED) && ifPtr->defaultValue == NULL) { + if (!(paramPtr->flags & XOTCL_ARG_REQUIRED) && paramPtr->defaultValue == NULL) { (*possibleUnknowns)++; } return TCL_OK; } static int -parseNonposArgs(Tcl_Interp *interp, char *procName, Tcl_Obj *npArgs, Tcl_Obj *ordinaryArgs, - int *haveNonposArgs, XOTclParsedInterfaceDefinition *parsedIfPtr) { - int rc, i, nonposArgsDefc, ordinaryArgsDefc, possibleUnknowns = 0; - Tcl_Obj **nonposArgsDefv, **ordinaryArgsDefv; - argDefinition *interface, *ifPtr; +ParsedParameterDefinitionGet(Tcl_Interp *interp, char *procName, Tcl_Obj *npArgs, Tcl_Obj *ordinaryArgs, + int *haveNonposArgs, XOTclParsedParameterDefinition *parsedParamPtr) { + int rc, i, paramDefsDefc, ordinaryArgsDefc, possibleUnknowns = 0; + Tcl_Obj **paramDefsDefv, **ordinaryArgsDefv; + parameterDefinition *paramDefsPtr, *paramPtr; - rc = Tcl_ListObjGetElements(interp, npArgs, &nonposArgsDefc, &nonposArgsDefv); + rc = Tcl_ListObjGetElements(interp, npArgs, ¶mDefsDefc, ¶mDefsDefv); if (rc != TCL_OK) { return XOTclVarErrMsg(interp, "cannot break down non-positional args: ", ObjStr(npArgs), (char *) NULL); @@ -5829,13 +5830,13 @@ ObjStr(ordinaryArgs), (char *) NULL); } - ifPtr = interface = argDefinitionsNew(nonposArgsDefc+ordinaryArgsDefc); + paramPtr = paramDefsPtr = ParameterDefinitionsNew(paramDefsDefc+ordinaryArgsDefc); - if (nonposArgsDefc > 0) { - for (i=0; i < nonposArgsDefc; i++, ifPtr++) { - rc = parseArgDefinition(interp, procName, nonposArgsDefv[i], 1, ifPtr, &possibleUnknowns); + if (paramDefsDefc > 0) { + for (i=0; i < paramDefsDefc; i++, paramPtr++) { + rc = ParseParamDefinition(interp, procName, paramDefsDefv[i], 1, paramPtr, &possibleUnknowns); if (rc != TCL_OK) { - argDefinitionsFree(interface); + parameterDefinitionsFree(paramDefsPtr); return rc; } *haveNonposArgs = 1; @@ -5847,26 +5848,26 @@ via e.g. configure to activate/deactivate pos args handling. */ if (*haveNonposArgs) { - for (i=0; i< ordinaryArgsDefc; i++, ifPtr++) { - rc = parseArgDefinition(interp, procName, ordinaryArgsDefv[i], 0, ifPtr, &possibleUnknowns); + for (i=0; i< ordinaryArgsDefc; i++, paramPtr++) { + rc = ParseParamDefinition(interp, procName, ordinaryArgsDefv[i], 0, paramPtr, &possibleUnknowns); if (rc != TCL_OK) { - argDefinitionsFree(interface); + parameterDefinitionsFree(paramDefsPtr); return rc; } } } if (*haveNonposArgs) { - XOTclNonposArgs *nonposArg = NEW(XOTclNonposArgs); + XOTclParamDefs *nonposArg = NEW(XOTclParamDefs); MEM_COUNT_ALLOC("nonposArg", nonposArg); nonposArg->slotObj = NULL; - nonposArg->ifd = interface; - nonposArg->ifdSize = ifPtr-interface; + nonposArg->paramPtr = paramDefsPtr; + nonposArg->nrParameters = paramPtr-paramDefsPtr; /*fprintf(stderr, "method %s ifsize %d, possible unknowns = %d,\n", - procName,ifPtr-interface,possibleUnknowns);*/ - parsedIfPtr->nonposArgs = nonposArg; - parsedIfPtr->possibleUnknowns = possibleUnknowns; + procName,paramPtr-paramDefsPtr,possibleUnknowns);*/ + parsedParamPtr->paramDefs = nonposArg; + parsedParamPtr->possibleUnknowns = possibleUnknowns; } else { /* empty definitions */ } @@ -5875,16 +5876,16 @@ } static int -GenerateIfd(Tcl_Interp *interp, char *methodName, Tcl_Obj *input, - XOTclParsedInterfaceDefinition *output, int *hasNpArgs) { +ParseArgumentDefinitions(Tcl_Interp *interp, char *methodName, Tcl_Obj *input, + XOTclParsedParameterDefinition *output, int *hasNpArgs) { int result = TCL_OK, argsc, i; Tcl_Obj **argsv; *hasNpArgs = 0; - output->nonposArgs = NULL; + output->paramDefs = NULL; output->possibleUnknowns = 0; - /* see, if we have nonposArgs in the ordinary argument list */ + /* see, if we have paramDefs in the ordinary argument list */ result = Tcl_ListObjGetElements(interp, input, &argsc, &argsv); if (result != TCL_OK) { return XOTclVarErrMsg(interp, "cannot break args into list: ", @@ -5908,40 +5909,40 @@ if (*hasNpArgs) { int nrOrdinaryArgs = argsc - i; Tcl_Obj *ordinaryArgs = Tcl_NewListObj(nrOrdinaryArgs, &argsv[i]); - Tcl_Obj *nonposArgs = Tcl_NewListObj(i, &argsv[0]); + Tcl_Obj *paramDefs = Tcl_NewListObj(i, &argsv[0]); INCR_REF_COUNT(ordinaryArgs); - INCR_REF_COUNT(nonposArgs); - result = parseNonposArgs(interp, methodName, nonposArgs, ordinaryArgs, + INCR_REF_COUNT(paramDefs); + result = ParsedParameterDefinitionGet(interp, methodName, paramDefs, ordinaryArgs, hasNpArgs, output); DECR_REF_COUNT(ordinaryArgs); - DECR_REF_COUNT(nonposArgs); + DECR_REF_COUNT(paramDefs); } return result; } static int MakeProc(Tcl_Namespace *nsPtr, XOTclAssertionStore *aStore, Tcl_Interp *interp, - Tcl_Obj *name, Tcl_Obj *args, Tcl_Obj *body, Tcl_Obj *precondition, + Tcl_Obj *nameObj, Tcl_Obj *args, Tcl_Obj *body, Tcl_Obj *precondition, Tcl_Obj *postcondition, XOTclObject *obj, int clsns) { - int result, haveNonposArgs = 0, argsc, i; + int result, haveNonposArgs = 0; TclCallFrame frame, *framePtr = &frame; - Tcl_Obj *ov[4], **argsv; - char *procName = ObjStr(name); - XOTclParsedInterfaceDefinition parsedIf; + Tcl_Obj *ov[4]; + char *procName = ObjStr(nameObj); + XOTclParsedParameterDefinition parsedParam; ov[0] = NULL; /*objv[0];*/ - ov[1] = name; + ov[1] = nameObj; /* Obtain an signature description */ - result = GenerateIfd(interp, procName, args, &parsedIf, &haveNonposArgs); + result = ParseArgumentDefinitions(interp, procName, args, &parsedParam, &haveNonposArgs); if (result != TCL_OK) return result; if (haveNonposArgs) { # if defined(CANONICAL_ARGS) - argDefinition *aPtr; + parameterDefinition *aPtr; Tcl_Obj *argList = Tcl_NewListObj(0, NULL); - for (aPtr = parsedIf.nonposArgs->ifd; aPtr->name; aPtr++) { + for (aPtr = parsedParam.paramDefs->paramPtr; aPtr->name; aPtr++) { if (*aPtr->name == '-') { Tcl_ListObjAppendElement(interp, argList, Tcl_NewStringObj(aPtr->name+1,-1)); } else { @@ -5954,10 +5955,10 @@ #else ov[2] = XOTclGlobalObjects[XOTE_ARGS]; #endif - ov[3] = addPrefixToBody(body, 1, &parsedIf); + ov[3] = addPrefixToBody(body, 1, &parsedParam); } else { /* no nonpos arguments */ ov[2] = args; - ov[3] = addPrefixToBody(body, 0, &parsedIf); + ov[3] = addPrefixToBody(body, 0, &parsedParam); } Tcl_PushCallFrame(interp,(Tcl_CallFrame *)framePtr, nsPtr, 0); @@ -5983,14 +5984,14 @@ procPtr->cmdPtr->nsPtr = ((Command *)obj->id)->nsPtr; } } - addNonposArgs(interp, (Tcl_Command)procPtr->cmdPtr, parsedIf.nonposArgs); + ParamDefsStore(interp, (Tcl_Command)procPtr->cmdPtr, parsedParam.paramDefs); } #endif Tcl_PopCallFrame(interp); if (precondition || postcondition) { - AssertionAddProc(interp, ObjStr(name), aStore, precondition, postcondition); + AssertionAddProc(interp, ObjStr(nameObj), aStore, precondition, postcondition); } #if defined(CANONICAL_ARGS) @@ -6003,11 +6004,11 @@ return result; } -static int makeMethod(Tcl_Interp *interp, XOTclClass *cl, Tcl_Obj *name, Tcl_Obj *args, Tcl_Obj *body, +static int makeMethod(Tcl_Interp *interp, XOTclClass *cl, Tcl_Obj *nameObj, Tcl_Obj *args, Tcl_Obj *body, Tcl_Obj *precondition, Tcl_Obj *postcondition, int clsns) { XOTclClassOpt *opt = cl->opt; int result = TCL_OK; - char *argStr = ObjStr(args), *bdyStr = ObjStr(body), *nameStr = ObjStr(name); + char *argStr = ObjStr(args), *bdyStr = ObjStr(body), *nameStr = ObjStr(nameObj); if ((cl->object.flags & XOTCL_IS_ROOT_CLASS && isDestroyString(nameStr)) || (cl->object.flags & XOTCL_IS_ROOT_META_CLASS && isDeallocString(nameStr)) || @@ -6035,7 +6036,7 @@ aStore = opt->assertions; } result = MakeProc(cl->nsPtr, aStore, - interp, name, args, body, precondition, postcondition, + interp, nameObj, args, body, precondition, postcondition, &cl->object, clsns); } @@ -6223,11 +6224,11 @@ } static void -AppendOrdinaryArgsFromNonposArgs(Tcl_Interp *interp, XOTclNonposArgs *nonposArgs, +AppendOrdinaryArgsFromNonposArgs(Tcl_Interp *interp, XOTclParamDefs *paramDefs, int varsOnly, Tcl_Obj *argList) { - argDefinition CONST *aPtr; + parameterDefinition CONST *aPtr; - for (aPtr = nonposArgs->ifd; aPtr->name; aPtr++) { + for (aPtr = paramDefs->paramPtr; aPtr->name; aPtr++) { if (*aPtr->name == '-') continue; if (varsOnly || aPtr->defaultValue == NULL) { Tcl_ListObjAppendElement(interp, argList, Tcl_NewStringObj(aPtr->name,-1)); @@ -9034,28 +9035,114 @@ } /*********************************** - * objv parser + * argument parser ***********************************/ #include "tclAPI.h" +static int +ArgumentError(Tcl_Interp *interp, char *errorMsg, parameterDefinition CONST *paramPtr, Tcl_Obj *procNameObj) { + Tcl_Obj *argStringObj = Tcl_NewStringObj("", 0); + parameterDefinition CONST *aPtr; + + for (aPtr = paramPtr; aPtr->name; aPtr++) { + if (aPtr != paramPtr) { + Tcl_AppendToObj(argStringObj, " ", 1); + } + if (aPtr->flags & XOTCL_ARG_REQUIRED) { + Tcl_AppendToObj(argStringObj, aPtr->name, -1); + } else { + Tcl_AppendToObj(argStringObj, "?", 1); + Tcl_AppendToObj(argStringObj, aPtr->name, -1); + if (aPtr->nrargs >0) { + Tcl_AppendToObj(argStringObj, " arg", 4); + } + Tcl_AppendToObj(argStringObj, "?", 1); + } + } + XOTclObjWrongArgs(interp, errorMsg, procNameObj, NULL, ObjStr(argStringObj)); + DECR_REF_COUNT(argStringObj); + return TCL_ERROR; +} + +int +ArgumentDefaults(parseContext *pcPtr, Tcl_Interp *interp, + XOTclObject *obj, /* if provided, we might have to push the frame */ + parameterDefinition CONST *ifd, int nrParameters, char *methodName) { + parameterDefinition CONST *aPtr; + int i, rc; + + for (aPtr = ifd, i=0; i %p %p, default %s\n", + aPtr->name, aPtr->flags & XOTCL_ARG_REQUIRED, + pcPtr->clientData[i], pcPtr->objv[i], + aPtr->defaultValue ? ObjStr(aPtr->defaultValue) : "NONE");*/ + + if (pcPtr->objv[i]) { + /* we got an actual value, which was already checked by objv parser */ + /*fprintf(stderr, "setting passed value for %s to '%s'\n",aPtr->name,ObjStr(pcPtr->objv[i]));*/ + if (aPtr->converter == convertToSwitch) { + int bool; + Tcl_GetBooleanFromObj(interp, aPtr->defaultValue, &bool); + pcPtr->objv[i] = Tcl_NewBooleanObj(!bool); + } + } else { + /* no valued passed, check if default is available */ + + if (aPtr->defaultValue) { + Tcl_Obj *newValue = aPtr->defaultValue; + + /* we have a default, do we have to subst it? */ + if (aPtr->flags & XOTCL_ARG_SUBST_DEFAULT) { + + rc = SubstValue(interp, obj, &newValue); + if (rc != TCL_OK) { + return rc; + } + /*fprintf(stderr, "attribute %s default %p %s => %p '%s'\n", aPtr->name, + aPtr->defaultValue, ObjStr(aPtr->defaultValue), + newValue,ObjStr(newValue));*/ + + /* the according DECR is performed by parseContextRelease() */ + INCR_REF_COUNT(newValue); + pcPtr->flags[i] |= XOTCL_PC_MUST_DECR; + } + + pcPtr->objv[i] = newValue; + /* TODO: default value is not jet checked; could be done (without subt) in arg parsing */ + /*fprintf(stderr,"==> setting default value '%s' for var '%s'\n",ObjStr(newValue),aPtr->name);*/ + + } else if (aPtr->flags & XOTCL_ARG_REQUIRED) { + return XOTclVarErrMsg(interp, "method ", methodName, ": required argument '", + ObjStr(aPtr->nameObj), "' is missing", (char *) NULL); + } else { + /* Use as dummy default value an arbitrary symbol, which must not be + * returned to the Tcl level level; this value is + * unset later by unsetUnknownArgs + */ + pcPtr->objv[i] = XOTclGlobalObjects[XOTE___UNKNOWN__]; + } + } + } + return TCL_OK; +} + static int -parseObjv(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], Tcl_Obj *procName, - argDefinition CONST *ifdPtr, int ifdSize, parseContext *pc) { - int i, o, args = 0, flagCount = 0, nrReq = 0, nrOpt = 0, varArgs = 0, dashdash = 0; +ArgumentParse(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], Tcl_Obj *procNameObj, + parameterDefinition CONST *paramPtr, int nrParameters, parseContext *pc) { + int i, o, flagCount = 0, nrReq = 0, nrOpt = 0, dashdash = 0; /* todo benchmark with and without CONST */ - argDefinition CONST *aPtr, *bPtr; + parameterDefinition CONST *aPtr, *bPtr; - parseContextInit(pc, ifdSize, procName); + parseContextInit(pc, nrParameters, procNameObj); #if defined(PARSE_TRACE) - fprintf(stderr, "BEGIN (%d) [0]%s ",objc, ObjStr(procName)); + fprintf(stderr, "BEGIN (%d) [0]%s ",objc, ObjStr(procNameObj)); for (o=1; oname && oname && o < objc;) { #if defined(PARSE_TRACE_FULL) fprintf(stderr,"... (%d) processing [%d]: '%s' %s\n", i, o, aPtr->name,aPtr->flags & XOTCL_ARG_REQUIRED ? "req":"not req"); @@ -9077,22 +9164,22 @@ /*fprintf(stderr, "... flag '%s' o=%d p=%d, objc=%d nrargs %d\n",objStr,o,p,objc,bPtr->nrargs);*/ if (bPtr->flags & XOTCL_ARG_REQUIRED) nrReq++; else nrOpt++; if (bPtr->nrargs == 0) { - pc->clientData[bPtr-ifdPtr] = (ClientData)1; /* the flag was given */ - pc->objv[bPtr-ifdPtr] = XOTclGlobalObjects[XOTE_ONE]; + pc->clientData[bPtr-paramPtr] = (ClientData)1; /* the flag was given */ + pc->objv[bPtr-paramPtr] = XOTclGlobalObjects[XOTE_ONE]; } else { /* we assume for now, nrargs is at most 1 */ o++; p++; if (bPtr->flags & XOTCL_ARG_REQUIRED) nrReq++; else nrOpt++; - if (oname, ObjStr(objv[p]), bPtr->nrargs, + bPtr-paramPtr, bPtr->name, ObjStr(objv[p]), bPtr->nrargs, bPtr->flags & XOTCL_ARG_REQUIRED ? "req":"not req"); #endif - if ((*bPtr->converter)(interp, objv[p], &pc->clientData[bPtr-ifdPtr]) != TCL_OK) { + if ((*bPtr->converter)(interp, objv[p], &pc->clientData[bPtr-paramPtr]) != TCL_OK) { return TCL_ERROR; } - pc->objv[bPtr-ifdPtr] = objv[p]; + pc->objv[bPtr-paramPtr] = objv[p]; } else { Tcl_ResetResult(interp); Tcl_AppendResult(interp, "Argument for parameter '", objStr, "' expected", (char *) NULL); @@ -9112,7 +9199,7 @@ } } /*fprintf(stderr, "... we found %d flags\n",flagCount);*/ - /* skip in interface until the end of the switches */ + /* skip in parameter definition until the end of the switches */ while (aPtr->name && *aPtr->name == '-') {aPtr++,i++;}; /* under the assumption, flags have no arguments */ o += flagCount; @@ -9121,9 +9208,9 @@ */ if (oflags & XOTCL_ARG_REQUIRED) nrReq++; else nrOpt++; - args ++; /*fprintf(stderr,"... arg %s req %d converter %p try to set on %d: '%s'\n", aPtr->name,aPtr->flags & XOTCL_ARG_REQUIRED,aPtr->converter,i, ObjStr(objv[o]));*/ if ((*aPtr->converter)(interp, objv[o], &pc->clientData[i]) != TCL_OK) { @@ -9156,56 +9242,31 @@ pc->lastobjc = aPtr->name ? o : o-1; pc->objc = i + 1; - /* Process all args until end of interface to get correct counters */ + /* Process all args until end of parameter definitions to get correct counters */ while (aPtr->name) { - //fprintf(stderr, "end of if def %s\n",aPtr->name); if (aPtr->flags & XOTCL_ARG_REQUIRED) nrReq++; else nrOpt++; aPtr++; } /* is last argument a vararg? */ aPtr--; - if (!varArgs && aPtr->converter == convertToNothing) { - varArgs = 1; - /*fprintf(stderr, "last arg of proc '%s' is varargs\n", ObjStr(procName));*/ + if (aPtr->converter == convertToNothing) { + pc->varArgs = 1; + /*fprintf(stderr, "last arg of proc '%s' is varargs\n", ObjStr(procNameObj));*/ } - /* fprintf(stderr, "less nrreq %d last arg %s type %s\n", args < nrReq, aPtr->name, aPtr->converter); - fprintf(stderr, "objc = %d, args = %d, nrReq %d, nrReq + nrOpt = %d, varArgs %d i %d %s\n", - objc,args,nrReq,nrReq + nrOpt, varArgs, i,aPtr->name);*/ - -#if defined(PARSE_TRACE) - fprintf(stderr, "PROC '%s', END lastobjc %d, varargs %d, not enough args (%d<%d) = %d, to many (%d>%d) = %d, check = %d\n", ObjStr(procName), - pc->lastobjc, varArgs, args, nrReq, args < nrReq, - objc-dashdash-1, nrReq + nrOpt, objc-dashdash-1 > nrReq + nrOpt, - !varArgs && objc-dashdash-1 > nrReq + nrOpt - ); -#endif - /* handle missing or unexpected arguments */ - if (pc->lastobjc < nrReq || (!varArgs && objc-dashdash-1 > nrReq + nrOpt)) { - Tcl_Obj *msg = Tcl_NewStringObj("", 0); - for (aPtr = ifdPtr; aPtr->name; aPtr++) { - if (aPtr != ifdPtr) { - Tcl_AppendToObj(msg, " ", 1); - } - if (aPtr->flags & XOTCL_ARG_REQUIRED) { - Tcl_AppendToObj(msg, aPtr->name, -1); - } else { - Tcl_AppendToObj(msg, "?", 1); - Tcl_AppendToObj(msg, aPtr->name, -1); - if (aPtr->nrargs >0) { - Tcl_AppendToObj(msg, " arg", 4); - } - Tcl_AppendToObj(msg, "?", 1); - } - } - return XOTclObjErrArgCntObj(interp, procName, NULL, msg); + if (pc->lastobjc < nrReq || (!pc->varArgs && objc-dashdash-1 > nrReq + nrOpt)) { + ArgumentError(interp, "wrong # args:", paramPtr, procNameObj); } + return ArgumentDefaults(pc, interp, NULL /* TODO if obj is provided, we might have to push the frame */, + paramPtr, nrParameters, ObjStr(procNameObj)); + return TCL_OK; } + /*********************************** * Begin result setting commands * (essentially List*() and support @@ -9496,9 +9557,9 @@ } static int -ListArgsFromOrdinaryArgs(Tcl_Interp *interp, XOTclNonposArgs *nonposArgs) { +ListArgsFromOrdinaryArgs(Tcl_Interp *interp, XOTclParamDefs *paramDefs) { Tcl_Obj *argList = argList = Tcl_NewListObj(0, NULL); - AppendOrdinaryArgsFromNonposArgs(interp, nonposArgs, 1, argList); + AppendOrdinaryArgsFromNonposArgs(interp, paramDefs, 1, argList); Tcl_SetObjResult(interp, argList); return TCL_OK; } @@ -9519,10 +9580,10 @@ static int ListDefaultFromOrdinaryArgs(Tcl_Interp *interp, char *procName, - XOTclNonposArgs *nonposArgs, char *arg, Tcl_Obj *var) { - argDefinition CONST *aPtr; + XOTclParamDefs *paramDefs, char *arg, Tcl_Obj *var) { + parameterDefinition CONST *aPtr; - for (aPtr = nonposArgs->ifd; aPtr->name; aPtr++) { + for (aPtr = paramDefs->paramPtr; aPtr->name; aPtr++) { if (*aPtr->name == '-') continue; if (strcmp(aPtr->name,arg) == 0) { return SetProcDefault(interp, var, aPtr->defaultValue); @@ -9716,31 +9777,31 @@ /* TODO check: what about procs? */ } else { /* slotobj */ - XOTclNonposArgs *nonposArgs; + XOTclParamDefs *paramDefs; if (value == NULL) { return XOTclVarErrMsg(interp, "Option 'slotobj' of method ",methodName, " requires argument '", (char *) NULL); } - nonposArgs = getNonposArgs(cmd); - if (nonposArgs == NULL) { - nonposArgs = NEW(XOTclNonposArgs); - memset(nonposArgs, 0, sizeof(XOTclNonposArgs)); - addNonposArgs(interp, cmd, nonposArgs); + paramDefs = ParamDefsGet(cmd); + if (paramDefs == NULL) { + paramDefs = NEW(XOTclParamDefs); + memset(paramDefs, 0, sizeof(XOTclParamDefs)); + ParamDefsStore(interp, cmd, paramDefs); /* TODO check: handle cases: cmd is not a proc. what happens if first method property and then method. what happens if method then property then new method? */ } else { fprintf(stderr,"define slotobj for a method with nonpospargs\n slotobj = %s \n", ObjStr(value)); - if (nonposArgs->slotObj) { - DECR_REF_COUNT(nonposArgs->slotObj); + if (paramDefs->slotObj) { + DECR_REF_COUNT(paramDefs->slotObj); } } - nonposArgs->slotObj = value; - INCR_REF_COUNT(nonposArgs->slotObj); + paramDefs->slotObj = value; + INCR_REF_COUNT(paramDefs->slotObj); } return TCL_OK; @@ -10091,14 +10152,14 @@ static int GetObjectParameterDefinition(Tcl_Interp *interp, char *methodName, XOTclObject *obj, - XOTclParsedInterfaceDefinition *parsedIf, int *hasNonposArgs) { + XOTclParsedParameterDefinition *parsedParamPtr, int *hasNonposArgs) { int result; Tcl_Obj *rawConfArgs; /* WARNING: a) definitions are freed on a class cleanup, with - ParsedInterfaceDefinitionFree(cl->parsedIf) + ParsedParameterDefinitionFree(cl->parsedParamPtr) What should be done: @@ -10111,35 +10172,35 @@ */ - if (obj->cl->parsedIf) { - parsedIf->nonposArgs = obj->cl->parsedIf->nonposArgs; - parsedIf->possibleUnknowns = obj->cl->parsedIf->possibleUnknowns; - /*fprintf(stderr, "--- returned cached objif for obj %s from %s: parsedIf->nonposArgs %p ifdSize %d\n", - objectName(obj),className(obj->cl), parsedIf->nonposArgs, parsedIf->nonposArgs ? parsedIf->nonposArgs->ifdSize : -1);*/ + if (obj->cl->parsedParamPtr) { + parsedParamPtr->paramDefs = obj->cl->parsedParamPtr->paramDefs; + parsedParamPtr->possibleUnknowns = obj->cl->parsedParamPtr->possibleUnknowns; + /*fprintf(stderr, "--- returned cached objif for obj %s from %s: parsedParamPtr->paramDefs %p nrParameters %d\n", + objectName(obj),className(obj->cl), parsedParamPtr->paramDefs, parsedParamPtr->paramDefs ? parsedParamPtr->paramDefs->nrParameters : -1);*/ result = TCL_OK; } else { - /* get the string representation of the interface */ + /* get the string representation of the object parameters */ result = callMethod((ClientData) obj, interp, XOTclGlobalObjects[XOTE_OBJECTPARAMETER], 2, 0, 0); if (result == TCL_OK) { rawConfArgs = Tcl_GetObjResult(interp); INCR_REF_COUNT(rawConfArgs); /* TODO: this is a dangerous comparison */ if (rawConfArgs != XOTclGlobalObjects[XOTE_EMPTY]) { - /* Obtain interface structure */ + /* Obtain parameter structure */ /* TODO: rather ObjStr(rawConfArgs) or unnecessary */ - result = GenerateIfd(interp, methodName, rawConfArgs, parsedIf, hasNonposArgs); - /*fprintf(stderr, "GenerateIfd obj %s for '%s' returned parsedIf->nonposArgs %p\n", - objectName(obj), ObjStr(rawConfArgs), parsedIf->nonposArgs);*/ + result = ParseArgumentDefinitions(interp, methodName, rawConfArgs, parsedParamPtr, hasNonposArgs); + /*fprintf(stderr, "ParseArgumentDefinitions obj %s for '%s' returned parsedParamPtr->paramDefs %p\n", + objectName(obj), ObjStr(rawConfArgs), parsedParamPtr->paramDefs);*/ if (result == TCL_OK && RUNTIME_STATE(interp)->cacheInterface) { - XOTclParsedInterfaceDefinition *ifd = NEW(XOTclParsedInterfaceDefinition); - ifd->nonposArgs = parsedIf->nonposArgs; - ifd->possibleUnknowns = parsedIf->possibleUnknowns; - obj->cl->parsedIf = ifd; /* free with ParsedInterfaceDefinitionFree(cl->parsedIf); */ + XOTclParsedParameterDefinition *ppDefPtr = NEW(XOTclParsedParameterDefinition); + ppDefPtr->paramDefs = parsedParamPtr->paramDefs; + ppDefPtr->possibleUnknowns = parsedParamPtr->possibleUnknowns; + obj->cl->parsedParamPtr = ppDefPtr; /* free with ParsedParameterDefinitionFree(cl->parsedParamPtr); */ - /*fprintf(stderr, "--- GetObjectParameterDefinition cache objif for obj %s nonposArgs %p possibleUnknowns %d ifd %p ifdSize %d\n", + /*fprintf(stderr, "--- GetObjectParameterDefinition cache objif for obj %s paramDefs %p possibleUnknowns %d ifd %p nrParameters %d\n", objectName(obj),className(obj->cl), - ifd->nonposArgs,ifd->possibleUnknowns, ifd->nonposArgs ? ifd->nonposArgs->ifdSize : -1);*/ + ifdparamDefs,ifd->possibleUnknowns, ifdparamDefs ? ifdparamDefs->nrParameters : -1);*/ } } @@ -10154,18 +10215,18 @@ int result; #if defined(CONFIGURE_ARGS) - /* TODO: check for CONST, check for mem leaks and cleanups, especially XOTclParsedInterfaceDefinition */ + /* TODO: check for CONST, check for mem leaks and cleanups, especially XOTclParsedParameterDefinition */ Tcl_Obj *newValue; - XOTclParsedInterfaceDefinition parsedIf; + XOTclParsedParameterDefinition parsedParam; int haveNonposArgs = 0, i, remainingArgsc; - argDefinition *ifPtr; - XOTclNonposArgs *nonposArgs; + parameterDefinition *paramPtr; + XOTclParamDefs *paramDefs; parseContext pc; XOTcl_FrameDecls; /* Get the object parameter definition */ - result = GetObjectParameterDefinition(interp, ObjStr(objv[0]), obj, &parsedIf, &haveNonposArgs); - if (result != TCL_OK || !parsedIf.nonposArgs) { + result = GetObjectParameterDefinition(interp, ObjStr(objv[0]), obj, &parsedParam, &haveNonposArgs); + if (result != TCL_OK || !parsedParam.paramDefs) { /*fprintf(stderr, "... nothing to do for method %s\n", ObjStr(objv[0]));*/ goto configure_exit; } @@ -10174,8 +10235,8 @@ XOTcl_PushFrame(interp, obj); /* Call the objv parser and postprocess like with method parameters */ - nonposArgs = parsedIf.nonposArgs; - result = ProcessMethodArguments(&pc, interp, NULL, nonposArgs, "configure", objc, objv); + paramDefs = parsedParam.paramDefs; + result = ProcessMethodArguments(&pc, interp, NULL, paramDefs, "configure", objc, objv); if (result != TCL_OK) { XOTcl_PopFrame(interp, obj); parseContextRelease(&pc); @@ -10189,8 +10250,8 @@ #if defined(CONFIGURE_ARGS_TRACE) fprintf(stderr, "*** POPULATE OBJ ''''%s'''': nr of parsed args '%d'\n", objectName(obj), pc.objc); #endif - for (i = 1, ifPtr = nonposArgs->ifd; i < nonposArgs->ifdSize; i++, ifPtr++) { - char *argName = ifPtr->name; + for (i = 1, paramPtr = paramDefs->paramPtr; i < paramDefs->nrParameters; i++, paramPtr++) { + char *argName = paramPtr->name; if (*argName == '-') argName++; newValue = pc.full_objv[i]; @@ -10202,9 +10263,9 @@ } /* special setter due to relation handling */ - if (ifPtr->converter == convertToRelation) { + if (paramPtr->converter == convertToRelation) { int relIdx; - result = convertToRelationtype(interp, ifPtr->nameObj, (ClientData)&relIdx); + result = convertToRelationtype(interp, paramPtr->nameObj, (ClientData)&relIdx); /*fprintf(stderr, "### convert to reltype of %s => %d (%d, OK=%d)\n",argName,relIdx, result, TCL_OK);*/ if (result == TCL_OK) { @@ -10221,7 +10282,7 @@ } /* special setter for init commands */ - if (ifPtr->flags & XOTCL_ARG_INITCMD) { + if (paramPtr->flags & XOTCL_ARG_INITCMD) { result = Tcl_EvalObjEx(interp, newValue, TCL_EVAL_DIRECT); /*fprintf(stderr, "XOTclOConfigureMethod_ attribute %s evaluated %s => (%d)\n", argName, ObjStr(newValue), result);*/ @@ -10236,13 +10297,13 @@ /* standard setter */ #if defined(CONFIGURE_ARGS_TRACE) - fprintf(stderr, "*** %s SET %s '%s'\n",objectName(obj), ObjStr(ifPtr->nameObj), ObjStr(newValue)); + fprintf(stderr, "*** %s SET %s '%s'\n",objectName(obj), ObjStr(paramPtr->nameObj), ObjStr(newValue)); #endif - Tcl_ObjSetVar2(interp, ifPtr->nameObj, NULL, newValue, TCL_LEAVE_ERR_MSG|TCL_PARSE_PART1); + Tcl_ObjSetVar2(interp, paramPtr->nameObj, NULL, newValue, TCL_LEAVE_ERR_MSG|TCL_PARSE_PART1); } XOTcl_PopFrame(interp, obj); - remainingArgsc = pc.objc - nonposArgs->ifdSize; + remainingArgsc = pc.objc - paramDefs->nrParameters; #if 0 || defined(CONFIGURE_ARGS_TRACE) fprintf(stderr, "*** POPULATE OBJ SETVALUES with '%d' elements:\n", remainingArgsc); @@ -10312,9 +10373,9 @@ #endif configure_exit: #if defined(CONFIGURE_ARGS) - if(parsedIf.nonposArgs) { + if(parsedParam.paramDefs) { if (RUNTIME_STATE(interp)->cacheInterface == 0) { - NonposArgsFree(parsedIf.nonposArgs); + NonposArgsFree(parsedParam.paramDefs); } } #else @@ -11141,10 +11202,10 @@ } static int XOTclCInvalidateObjectParameterMethod(Tcl_Interp *interp, XOTclClass *cl) { - /*fprintf(stderr, " %s invalidate %p\n", className(cl), cl->parsedIf);*/ - if (cl->parsedIf) { - ParsedInterfaceDefinitionFree(cl->parsedIf); - cl->parsedIf = NULL; + /*fprintf(stderr, " %s invalidate %p\n", className(cl), cl->parsedParamPtr);*/ + if (cl->parsedParamPtr) { + ParsedParameterDefinitionFree(cl->parsedParamPtr); + cl->parsedParamPtr = NULL; } return TCL_OK; } @@ -11228,10 +11289,10 @@ static int XOTclObjInfoArgsMethod(Tcl_Interp *interp, XOTclObject *object, char *methodName) { Proc *proc = getObjectProc(interp, object, methodName); - XOTclNonposArgs *nonposArgs = proc ? getNonposArgs((Tcl_Command)proc->cmdPtr) : NULL; + XOTclParamDefs *paramDefs = proc ? ParamDefsGet((Tcl_Command)proc->cmdPtr) : NULL; - if (nonposArgs) { - return ListArgsFromOrdinaryArgs(interp, nonposArgs); + if (paramDefs) { + return ListArgsFromOrdinaryArgs(interp, paramDefs); } return ListProcArgs(interp, proc, methodName); } @@ -11261,10 +11322,10 @@ static int XOTclObjInfoDefaultMethod(Tcl_Interp *interp, XOTclObject *object, char *methodName, char *arg, Tcl_Obj *var) { Proc *procPtr = getObjectProc(interp, object, methodName); - XOTclNonposArgs *nonposArgs = procPtr ? getNonposArgs((Tcl_Command)procPtr->cmdPtr) : NULL; + XOTclParamDefs *paramDefs = procPtr ? ParamDefsGet((Tcl_Command)procPtr->cmdPtr) : NULL; - if (nonposArgs) { - return ListDefaultFromOrdinaryArgs(interp, methodName, nonposArgs, arg, var); + if (paramDefs) { + return ListDefaultFromOrdinaryArgs(interp, methodName, paramDefs, arg, var); } return ListProcDefault(interp, procPtr, methodName, arg, var); } @@ -11324,10 +11385,10 @@ static int XOTclObjInfoNonposargsMethod(Tcl_Interp *interp, XOTclObject *object, char *methodName) { Proc *procPtr = getObjectProc(interp, object, methodName); - XOTclNonposArgs *nonposArgs = procPtr ? getNonposArgs((Tcl_Command)procPtr->cmdPtr) : NULL; + XOTclParamDefs *paramDefs = procPtr ? ParamDefsGet((Tcl_Command)procPtr->cmdPtr) : NULL; - if (nonposArgs) { - Tcl_SetObjResult(interp, NonposArgsFormat(interp, nonposArgs)); + if (paramDefs) { + Tcl_SetObjResult(interp, NonposArgsFormat(interp, paramDefs)); } return TCL_OK; } @@ -11488,10 +11549,10 @@ static int XOTclClassInfoInstargsMethod(Tcl_Interp *interp, XOTclClass *class, char *methodName) { Proc *proc = getClassProc(interp, class, methodName); - XOTclNonposArgs *nonposArgs = proc ? getNonposArgs((Tcl_Command)proc->cmdPtr) : NULL; + XOTclParamDefs *paramDefs = proc ? ParamDefsGet((Tcl_Command)proc->cmdPtr) : NULL; - if (nonposArgs) { - return ListArgsFromOrdinaryArgs(interp, nonposArgs); + if (paramDefs) { + return ListArgsFromOrdinaryArgs(interp, paramDefs); } return ListProcArgs(interp, proc, methodName); } @@ -11508,10 +11569,10 @@ static int XOTclClassInfoInstdefaultMethod(Tcl_Interp *interp, XOTclClass *class, char *methodName, char *arg, Tcl_Obj *var) { Proc *procPtr = getClassProc(interp, class, methodName); - XOTclNonposArgs *nonposArgs = procPtr ? getNonposArgs((Tcl_Command)procPtr->cmdPtr) : NULL; + XOTclParamDefs *paramDefs = procPtr ? ParamDefsGet((Tcl_Command)procPtr->cmdPtr) : NULL; - if (nonposArgs) { - return ListDefaultFromOrdinaryArgs(interp, methodName, nonposArgs, arg, var); + if (paramDefs) { + return ListDefaultFromOrdinaryArgs(interp, methodName, paramDefs, arg, var); } return ListProcDefault(interp, procPtr, methodName, arg, var); } @@ -11592,10 +11653,10 @@ static int XOTclClassInfoInstnonposargsMethod(Tcl_Interp *interp, XOTclClass * class, char * methodName) { Proc *procPtr = getClassProc(interp, class, methodName); - XOTclNonposArgs *nonposArgs = procPtr ? getNonposArgs((Tcl_Command)procPtr->cmdPtr) : NULL; + XOTclParamDefs *paramDefs = procPtr ? ParamDefsGet((Tcl_Command)procPtr->cmdPtr) : NULL; - if (nonposArgs) { - Tcl_SetObjResult(interp, NonposArgsFormat(interp, nonposArgs)); + if (paramDefs) { + Tcl_SetObjResult(interp, NonposArgsFormat(interp, paramDefs)); } return TCL_OK; } @@ -11821,17 +11882,17 @@ Proc *procPtr = (Proc*) Tcl_Command_objClientData(cmd); Tcl_Obj *arglistObj = NULL; CompiledLocal *localPtr; - XOTclNonposArgs *nonposArgs = NULL; + XOTclParamDefs *paramDefs = NULL; /* * Build a list containing the arguments of the proc */ - nonposArgs = getNonposArgs(cmd); - if (nonposArgs) { - arglistObj = NonposArgsFormat(interp, nonposArgs); + paramDefs = ParamDefsGet(cmd); + if (paramDefs) { + arglistObj = NonposArgsFormat(interp, paramDefs); INCR_REF_COUNT(arglistObj); - AppendOrdinaryArgsFromNonposArgs(interp, nonposArgs, 0, arglistObj); + AppendOrdinaryArgsFromNonposArgs(interp, paramDefs, 0, arglistObj); } if (!arglistObj) { @@ -12094,15 +12155,15 @@ */ int isNonposArg(Tcl_Interp *interp, char * argStr, - int nonposArgsDefc, Tcl_Obj **nonposArgsDefv, + int paramDefsDefc, Tcl_Obj **paramDefsDefv, Tcl_Obj **var, char **type) { int i, npac; Tcl_Obj **npav; char *varName; if (argStr[0] == '-') { - for (i=0; i < nonposArgsDefc; i++) { - if (Tcl_ListObjGetElements(interp, nonposArgsDefv[i], + for (i=0; i < paramDefsDefc; i++) { + if (Tcl_ListObjGetElements(interp, paramDefsDefv[i], &npac, &npav) == TCL_OK && npac > 0) { varName = argStr+1; if (!strcmp(varName, ObjStr(npav[0]))) { @@ -12121,92 +12182,29 @@ int ProcessMethodArguments(parseContext *pcPtr, Tcl_Interp *interp, XOTclObject *obj, /* if provided, we might have to push the frame */ - XOTclNonposArgs *nonposArgs, + XOTclParamDefs *paramDefs, char *methodName, int objc, Tcl_Obj *CONST objv[]) { - argDefinition CONST *aPtr; - int i, rc; + int rc; - rc = parseObjv(interp, objc, objv, objv[0], nonposArgs->ifd, nonposArgs->ifdSize, pcPtr); + rc = ArgumentParse(interp, objc, objv, objv[0], paramDefs->paramPtr, paramDefs->nrParameters, pcPtr); if (rc != TCL_OK) { return rc; } - for (aPtr = nonposArgs->ifd, i=0; aPtr->name; aPtr++, i++) { - char *argName = aPtr->name; - if (*argName == '-') argName++; - /*fprintf(stderr, "ProcessMethodArguments got for arg %s (%d) => %p %p, default %s\n", - aPtr->name, aPtr->flags & XOTCL_ARG_REQUIRED, - pcPtr->clientData[i], pcPtr->objv[i], - aPtr->defaultValue ? ObjStr(aPtr->defaultValue) : "NONE");*/ - - if (pcPtr->objv[i]) { - /* we got an actual value, which was already checked by objv parser */ - /*fprintf(stderr, "setting passed value for %s to '%s'\n",argName,ObjStr(pcPtr->objv[i]));*/ - if (aPtr->converter == convertToSwitch) { - int bool; - Tcl_GetBooleanFromObj(interp, aPtr->defaultValue, &bool); - pcPtr->objv[i] = Tcl_NewBooleanObj(!bool); - } - } else { - /* no valued passed, check if default is available */ - - if (aPtr->defaultValue) { - Tcl_Obj *newValue = aPtr->defaultValue; - - /* we have a default, do we have to subst it? */ - if (aPtr->flags & XOTCL_ARG_SUBST_DEFAULT) { - - rc = SubstValue(interp, obj, &newValue); - if (rc != TCL_OK) { - return rc; - } - /*fprintf(stderr, "attribute %s default %p %s => %p '%s'\n", aPtr->name, - aPtr->defaultValue, ObjStr(aPtr->defaultValue), - newValue,ObjStr(newValue));*/ - - /* the according DECR is performed by parseContextRelease() */ - INCR_REF_COUNT(newValue); - pcPtr->flags[i] |= XOTCL_PC_MUST_DECR; - } - - pcPtr->objv[i] = newValue; - /* TODO: default value is not jet checked; could be done (without subt) in arg parsing */ - /*fprintf(stderr,"==> setting default value '%s' for var '%s'\n",ObjStr(newValue),argName);*/ - - } else if (aPtr->flags & XOTCL_ARG_REQUIRED) { - return XOTclVarErrMsg(interp, "method ", methodName, ": required argument '", - argName, "' is missing", (char *) NULL); - } else { - /* Use as dummy default value an arbitrary symbol, which must not be - * returned to the Tcl level level; this value is - * unset later by unsetUnknownArgs - */ - pcPtr->objv[i] = XOTclGlobalObjects[XOTE___UNKNOWN__]; - } - } - } - - /* Rewind to the last argument in the spec */ - aPtr--; - i--; - - /* fprintf(stderr, "***PRE: args last objc=%d, objc=%d, elts=%d, ifdSize=%d, pc->objc=%d\n", pcPtr->lastobjc, objc, objc - pcPtr->lastobjc,nonposArgs->ifdSize,pcPtr->objc); - */ - /* - * Set objc of the parse context to the size of the interface. - * pcPtr->objc and nonposArgs->ifdSize will be equivalent in cases + * Set objc of the parse context to the number of defined parameters. + * pcPtr->objc and paramDefs->nrParameters will be equivalent in cases * where argument values are passed to the call in absence of var - * args ('args'). Treating "args is more involved. + * args ('args'). Treating "args is more involved (see below). */ - pcPtr->objc = nonposArgs->ifdSize + 1; + pcPtr->objc = paramDefs->nrParameters + 1; - if (aPtr->converter == convertToNothing) { + if (pcPtr->varArgs) { /* * The last argument was "args". */ int elts = objc - pcPtr->lastobjc; - + if (elts == 0) { /* * No arguments were passed to "args". We simply decrement objc. @@ -12218,18 +12216,18 @@ * pointing to the first of the var args. We have to copy the * remaining actual argument vector objv to the parse context. */ - + /*XOTclPrintObjv("actual: ", objc, objv);*/ - parseContextExtendObjv(pcPtr, nonposArgs->ifdSize, elts-1, objv + 1 + pcPtr->lastobjc); + parseContextExtendObjv(pcPtr, paramDefs->nrParameters, elts-1, objv + 1 + pcPtr->lastobjc); } else { /* * A single argument was passed to "args". There is no need to * mutate the pcPtr->objv, because this has been achieved in - * parseObjvs (i.e., pcPtr->objv[i] contains this element). + * ArgumentParse (i.e., pcPtr->objv[i] contains this element). */ } } - + return TCL_OK; } @@ -12268,21 +12266,21 @@ XOTclInterpretNonpositionalArgsCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { XOTclCallStackContent *csc = CallStackGetFrame(interp, NULL); - XOTclNonposArgs *nonposArgs = getNonposArgs(csc->cmdPtr); + XOTclParamDefs *paramDefs = ParamDefsGet(csc->cmdPtr); char *procName = (char *)Tcl_GetCommandName(interp, csc->cmdPtr); Tcl_Obj *proc = Tcl_NewStringObj(procName, -1); - argDefinition CONST *aPtr; + parameterDefinition CONST *aPtr; parseContext pc; int i, rc; /* The arguments are passed via argument vector (not the single argument) at least for Tcl 8.5. TODO: Tcl 8.4 support? possible via introspection? (this is a possible TODO for optimization) */ - /*if (!nonposArgs) {return TCL_OK;}*/ + /*if (!paramDefs) {return TCL_OK;}*/ INCR_REF_COUNT(proc); - rc = parseObjv(interp, objc, objv, proc, nonposArgs->ifd, objc, &pc); + rc = ArgumentParse(interp, objc, objv, proc, paramDefs->paramPtr, objc, &pc); DECR_REF_COUNT(proc); if (rc != TCL_OK) { @@ -12292,7 +12290,7 @@ return rc; } - for (aPtr = nonposArgs->ifd, i=0; aPtr->name; aPtr++, i++) { + for (aPtr = paramDefs->paramPtr, i=0; aPtr->name; aPtr++, i++) { char *argName = aPtr->name; if (*argName == '-') argName++; /*fprintf(stderr, "got for arg %s (%d) => %p %p, default %s\n", Index: generic/xotclError.c =================================================================== diff -u -r7cb7c751d63fe0eece5756910e3f0b18e61a4d16 -r300e593347cf3f13d62ac4d21299a2278ff83d5e --- generic/xotclError.c (.../xotclError.c) (revision 7cb7c751d63fe0eece5756910e3f0b18e61a4d16) +++ generic/xotclError.c (.../xotclError.c) (revision 300e593347cf3f13d62ac4d21299a2278ff83d5e) @@ -64,10 +64,10 @@ } int -XOTclObjErrArgCnt(Tcl_Interp *interp, Tcl_Obj *cmdName, Tcl_Obj *methodName, char *arglist) { +XOTclObjWrongArgs(Tcl_Interp *interp, char *msg, Tcl_Obj *cmdName, Tcl_Obj *methodName, char *arglist) { int need_space = 0; Tcl_ResetResult(interp); - Tcl_AppendResult(interp, "wrong # args: should be \"", (char *) NULL); + Tcl_AppendResult(interp, msg, " should be \"", (char *) NULL); if (cmdName) { Tcl_AppendResult(interp, ObjStr(cmdName), (char *) NULL); need_space = 1; @@ -86,10 +86,8 @@ } int -XOTclObjErrArgCntObj(Tcl_Interp *interp, Tcl_Obj *cmdName, Tcl_Obj *methodName, Tcl_Obj *msg) { - int rc = XOTclObjErrArgCnt(interp, cmdName, methodName, ObjStr(msg)); - DECR_REF_COUNT(msg); - return rc; +XOTclObjErrArgCnt(Tcl_Interp *interp, Tcl_Obj *cmdName, Tcl_Obj *methodName, char *arglist) { + return XOTclObjWrongArgs(interp, "wrong # args:", cmdName, methodName, arglist); } int Index: generic/xotclInt.h =================================================================== diff -u -rfd885cf0c5e9db40afffb54a2a7e2e3d714a8a14 -r300e593347cf3f13d62ac4d21299a2278ff83d5e --- generic/xotclInt.h (.../xotclInt.h) (revision fd885cf0c5e9db40afffb54a2a7e2e3d714a8a14) +++ generic/xotclInt.h (.../xotclInt.h) (revision 300e593347cf3f13d62ac4d21299a2278ff83d5e) @@ -424,7 +424,7 @@ #define XOTCL_DELETED 0x4000 #define XOTCL_RECREATE 0x8000 -/* flags for argDefinitions */ +/* flags for parameterDefinitions */ #define XOTCL_ARG_REQUIRED 0x0001 #define XOTCL_ARG_SUBST_DEFAULT 0x0002 @@ -457,18 +457,18 @@ Tcl_Obj *defaultValue; char *type; Tcl_Obj *nameObj; -} argDefinition; +} parameterDefinition; -typedef struct XOTclNonposArgs { - argDefinition *ifd; - int ifdSize; +typedef struct XOTclParamDefs { + parameterDefinition *paramPtr; + int nrParameters; Tcl_Obj *slotObj; -} XOTclNonposArgs; +} XOTclParamDefs; -typedef struct XOTclParsedInterfaceDefinition { - XOTclNonposArgs *nonposArgs; +typedef struct XOTclParsedParameterDefinition { + XOTclParamDefs *paramDefs; int possibleUnknowns; -} XOTclParsedInterfaceDefinition; +} XOTclParsedParameterDefinition; typedef struct XOTclObjectOpt { XOTclAssertionStore *assertions; @@ -523,10 +523,9 @@ struct XOTclClasses *sub; short color; struct XOTclClasses *order; - /*struct XOTclClass *parent;*/ Tcl_HashTable instances; Tcl_Namespace *nsPtr; - XOTclParsedInterfaceDefinition *parsedIf; + XOTclParsedParameterDefinition *parsedParamPtr; XOTclClassOpt *opt; } XOTclClass;