Lines Matching +defs:snit +defs:type
21 namespace eval ::snit:: {
23 compile type widget widgetadaptor typemethod method macro
29 namespace eval ::snit:: {
30 variable reservedArgs {type selfns win self}
43 namespace eval ::snit:: {
44 # Template type definition: All internal and user-visible Snit
51 # %COMPILEDDEFS% The compiled type definition.
54 # %TYPE% The fully qualified type name.
59 # %TYPEVARS% The compiled type variable initialization code.
61 # This is the overall type template.
64 # This is the normal type proc
67 # This is the "-hastypemethods no" type proc
71 set ::snit::typeTemplate {
74 # The type's namespace definition and the user's type variables
84 interp alias {} %TYPE%::installhull {} ::snit::RT.installhull %TYPE%
85 interp alias {} %TYPE%::install {} ::snit::RT.install %TYPE%
87 interp alias {} %TYPE%::variable {} ::snit::RT.variable
88 interp alias {} %TYPE%::mytypevar {} ::snit::RT.mytypevar %TYPE%
89 interp alias {} %TYPE%::typevarname {} ::snit::RT.mytypevar %TYPE%
90 interp alias {} %TYPE%::myvar {} ::snit::RT.myvar
91 interp alias {} %TYPE%::varname {} ::snit::RT.myvar
92 interp alias {} %TYPE%::codename {} ::snit::RT.codename %TYPE%
93 interp alias {} %TYPE%::myproc {} ::snit::RT.myproc %TYPE%
94 interp alias {} %TYPE%::mymethod {} ::snit::RT.mymethod
95 interp alias {} %TYPE%::mytypemethod {} ::snit::RT.mytypemethod %TYPE%
96 interp alias {} %TYPE%::from {} ::snit::RT.from %TYPE%
104 # ns: The type's namespace
110 # hulltype: Hull type (frame or toplevel) for widgets only.
128 # Array: Public methods of this type.
135 # Array: Public methods of instances of this type.
167 proc %TYPE%::Snit_typeconstructor {type} {
169 namespace path [namespace parent $type]
178 # Snit_destructor type selfns win self
180 # Default destructor for the type. By default, it does
185 proc %TYPE%::Snit_destructor {type selfns win self} { }
201 # These procs expect the fully-qualified type name to be
204 # This is the nominal type proc. It supports typemethods and
206 set ::snit::nominalTypeProc {
207 # WHD: Code for creating the type ensemble
210 -unknown [list ::snit::RT.UnknownTypemethod %TYPE% ""] \
215 # This is the simplified type proc for when there are no typemethods
218 set ::snit::simpleTypeProc {
237 set command [list ::snit::RT.widget.typemethod.create %TYPE%]
239 set command [list ::snit::RT.type.typemethod.create %TYPE%]
269 # The following variables are used while Snit is compiling a type,
272 namespace eval ::snit:: {
274 # used to compile type definitions.
277 # The compile array accumulates information about the type or
281 # type: The name of the type being compiled, for use
284 # which: type, widget, widgetadaptor
289 # widgetclass: The widgetclass, for snit::widgets, only
301 # typevarnames Names of type variables
329 # The following variable lists the reserved type definition statement
336 # type compilation commands
338 # The type and widgettype commands use a slave interpreter to compile
339 # the type definition. These are the procs
343 proc ::snit::Comp.Init {} {
359 # @mdgen NODEP: ::snit::__does_not_exist__
360 catch {package require ::snit::__does_not_exist__}
362 # Protect some Tcl commands our type definitions
369 $compiler alias pragma ::snit::Comp.statement.pragma
370 $compiler alias widgetclass ::snit::Comp.statement.widgetclass
371 $compiler alias hulltype ::snit::Comp.statement.hulltype
372 $compiler alias constructor ::snit::Comp.statement.constructor
373 $compiler alias destructor ::snit::Comp.statement.destructor
374 $compiler alias option ::snit::Comp.statement.option
375 $compiler alias oncget ::snit::Comp.statement.oncget
376 $compiler alias onconfigure ::snit::Comp.statement.onconfigure
377 $compiler alias method ::snit::Comp.statement.method
378 $compiler alias typemethod ::snit::Comp.statement.typemethod
379 $compiler alias typeconstructor ::snit::Comp.statement.typeconstructor
380 $compiler alias proc ::snit::Comp.statement.proc
381 $compiler alias typevariable ::snit::Comp.statement.typevariable
382 $compiler alias variable ::snit::Comp.statement.variable
383 $compiler alias typecomponent ::snit::Comp.statement.typecomponent
384 $compiler alias component ::snit::Comp.statement.component
385 $compiler alias delegate ::snit::Comp.statement.delegate
386 $compiler alias expose ::snit::Comp.statement.expose
393 # Compile a type definition, and return the results as a list of two
394 # items: the fully-qualified type name, and a script that will define
395 # the type when executed.
397 # which type, widget, or widgetadaptor
398 # type the type name
399 # body the type definition
400 proc ::snit::Comp.Compile {which type body} {
410 if {![string match "::*" $type]} {
418 set type "$ns$type"
429 set compile(type) $type
460 # NEXT, Evaluate the type's definition in the class interpreter.
470 # Indicate whether the type can create instances that replace
478 error "$which $type has neither typemethods nor instances"
482 # the nominal type proc. Otherwise define the simple type proc.
487 using {::snit::RT.typemethod.info %t}
493 using {::snit::RT.typemethod.destroy %t}
496 # Add the nominal type proc.
499 # Add the simple type proc.
504 # type has instances.
509 using {::snit::RT.method.info %t %n %w %s}
517 using {::snit::RT.method.cget %t %n %w %s}
519 using {::snit::RT.method.configurelist %t %n %w %s}
521 using {::snit::RT.method.configure %t %n %w %s}
539 using {::snit::RT.method.destroy %t %n %w %s}
542 using {::snit::RT.type.typemethod.create %t}
545 using {::snit::RT.widget.typemethod.create %t}
555 # NEXT, compiling the type definition built up a set of information
556 # about the type's locally defined options; add this information to
560 # NEXT, compiling the type definition built up a set of information
571 # NEXT, substitute the compiled definition into the type template
572 # to get the type definition script.
576 # NEXT, substitute the defined macros into the type definition script.
581 %TYPE% $type \
591 return [list $type $defscript]
604 proc ::snit::Comp.SaveOptionInfo {} {
618 # the typedefinition using snit::method.
641 %TYPESPEC% [list $compile(-type-$option)]
646 # Evaluates a compiled type definition, thus making the type available.
647 proc ::snit::Comp.Define {compResult} {
649 # type name and a script to evaluate to define the type.
650 set type [lindex $compResult 0]
653 # Execute the type definition script.
656 namespace delete $type
657 catch {rename $type ""}
661 return $type
664 # Sets pragma options which control how the type is defined.
665 proc ::snit::Comp.statement.pragma {args} {
692 # This statement is only available for snit::widgets,
693 # not for snit::types or snit::widgetadaptors.
694 proc ::snit::Comp.statement.widgetclass {name} {
699 error "widgetclass cannot be set for snit::$compile(which)s"
721 # Defines a widget's hull type.
722 # This statement is only available for snit::widgets,
723 # not for snit::types or snit::widgetadaptors.
724 proc ::snit::Comp.statement.hulltype {name} {
730 error "hulltype cannot be set for snit::$compile(which)s"
752 proc ::snit::Comp.statement.constructor {arglist body} {
758 set arglist [concat type selfns win self $arglist]
768 proc ::snit::Comp.statement.destructor {body} {
774 append compile(defs) "proc %TYPE%::Snit_destructor {type selfns win self} [list $body]\n\n"
777 # Defines a type option. The option value can be a triple, specifying
779 proc ::snit::Comp.statement.option {optionDef args} {
811 set compile(-type-$option) ""
850 -type {
854 # The type spec *is* the validation object
879 proc ::snit::Comp.OptionNameIsValid {option} {
888 proc ::snit::Comp.statement.oncget {option body} {
906 proc ::snit::Comp.statement.onconfigure {option arglist body} {
932 proc ::snit::Comp.statement.method {method arglist body} {
938 Comp.CheckMethodName $method 0 ::snit::methodInfo \
950 # Next, add magic references to type and self.
951 set arglist [concat type selfns win self $arglist]
954 set body "%TVARDECS%\n%IVARDECS%\n# END snit method prolog\n$body"
980 proc ::snit::Comp.CheckMethodName {method delFlag infoVar errRoot} {
1026 proc ::snit::Comp.statement.typemethod {method arglist body} {
1032 Comp.CheckMethodName $method 0 ::snit::typemethodInfo \
1037 # First, add magic reference to type.
1038 set arglist [concat type $arglist]
1041 set body "%TVARDECS%\n# END snit method prolog\n$body"
1061 # Defines a type constructor.
1062 proc ::snit::Comp.statement.typeconstructor {body} {
1072 # Defines a static proc in the type's namespace.
1073 proc ::snit::Comp.statement.proc {proc arglist body} {
1092 # Defines a static variable in the type's namespace.
1093 proc ::snit::Comp.statement.typevariable {name args} {
1126 append compile(tvprocdec) "namespace upvar [list $compile(type)]"
1132 # type's create typemethod.
1133 proc ::snit::Comp.statement.variable {name args} {
1177 proc ::snit::Comp.statement.typecomponent {component args} {
1228 proc ::snit::Comp.DefineTypecomponent {component {errRoot "Error"}} {
1239 # Make it a type variable with no initial value
1245 [list ::snit::RT.TypecomponentTrace [list %TYPE%] %COMP%]
1246 } %TYPE% $compile(type) %COMP% $component
1258 # read the entire type definition.
1260 proc ::snit::Comp.statement.component {component args} {
1311 proc ::snit::Comp.DefineComponent {component {errRoot "Error"}} {
1328 [list ::snit::RT.ComponentTrace [list %TYPE%] $selfns %COMP%]
1329 } %TYPE% $compile(type) %COMP% $component
1334 proc ::snit::Comp.statement.delegate {what name args} {
1356 proc ::snit::Comp.DelegatedTypemethod {method arglist} {
1426 Comp.CheckMethodName $method 1 ::snit::typemethodInfo $errRoot
1444 proc ::snit::Comp.DelegatedMethod {method arglist} {
1519 Comp.CheckMethodName $method 1 ::snit::methodInfo $errRoot
1538 proc ::snit::Comp.DelegatedOption {optionDef arglist} {
1645 proc ::snit::Comp.statement.expose {component {"as" ""} {methodname ""}} {
1652 # NEXT, define the method just as though it were in the type
1678 # Compile a type definition, and return the results as a list of two
1679 # items: the fully-qualified type name, and a script that will define
1680 # the type when executed.
1682 # which type, widget, or widgetadaptor
1683 # type the type name
1684 # body the type definition
1685 proc ::snit::compile {which type body} {
1686 return [Comp.Compile $which $type $body]
1689 proc ::snit::type {type body} {
1690 return [Comp.Define [Comp.Compile type $type $body]]
1693 proc ::snit::widget {type body} {
1694 return [Comp.Define [Comp.Compile widget $type $body]]
1697 proc ::snit::widgetadaptor {type body} {
1698 return [Comp.Define [Comp.Compile widgetadaptor $type $body]]
1701 proc ::snit::typemethod {type method arglist body} {
1702 # Make sure the type exists.
1703 if {![info exists ${type}::Snit_info]} {
1704 error "no such type: \"$type\""
1707 upvar ${type}::Snit_info Snit_info
1708 upvar ${type}::Snit_typemethodInfo Snit_typemethodInfo
1712 Comp.CheckMethodName $method 0 ${type}::Snit_typemethodInfo \
1716 CheckArgs "snit::typemethod $type $method" $arglist
1718 # Next, add magic reference to type.
1719 set arglist [concat type $arglist]
1727 uplevel 1 [list proc ${type}::Snit_typemethod$method $arglist $body]
1731 uplevel 1 [list proc ${type}::Snit_htypemethod$suffix $arglist $body]
1735 proc ::snit::method {type method arglist body} {
1736 # Make sure the type exists.
1737 if {![info exists ${type}::Snit_info]} {
1738 error "no such type: \"$type\""
1741 upvar ${type}::Snit_methodInfo Snit_methodInfo
1742 upvar ${type}::Snit_info Snit_info
1746 Comp.CheckMethodName $method 0 ${type}::Snit_methodInfo \
1750 CheckArgs "snit::method $type $method" $arglist
1752 # Next, add magic references to type and self.
1753 set arglist [concat type selfns win self $arglist]
1761 uplevel 1 [list proc ${type}::Snit_method$method $arglist $body]
1766 uplevel 1 [list proc ${type}::Snit_hmethod$suffix $arglist $body]
1771 # type definition statements, and thus can be used for meta-programming.
1772 proc ::snit::macro {name arglist body} {
1803 proc ::snit::Expand {template args} {
1808 proc ::snit::Mappend {varname template args} {
1815 proc ::snit::CheckArgs {which arglist} {
1826 proc ::snit::Capitalize {text} {
1839 # Creates a new instance of the snit::type given its name and the args.
1841 # type The snit::type
1845 proc ::snit::RT.type.typemethod.create {type name args} {
1846 variable ${type}::Snit_info
1847 variable ${type}::Snit_optionInfo
1864 set name [::snit::RT.UniqueName Snit_info(counter) $type $name]
1871 [::snit::RT.UniqueInstanceNamespace Snit_info(counter) $type]
1875 RT.MakeInstanceCommand $type $selfns $name
1886 ${type}::Snit_instanceVars $selfns
1888 # Execute the type's constructor.
1890 RT.ConstructInstance $type $selfns $name $args
1900 ::snit::RT.DestroyObject $type $selfns $name
1908 # Creates a new instance of the snit::widget or snit::widgetadaptor
1911 # type The snit::widget or snit::widgetadaptor
1915 proc ::snit::RT.widget.typemethod.create {type name args} {
1916 variable ${type}::Snit_info
1917 variable ${type}::Snit_optionInfo
1922 set name [::snit::RT.UniqueName Snit_info(counter) $type $name]
1927 [::snit::RT.UniqueInstanceNamespace Snit_info(counter) $type]
1938 ${type}::Snit_instanceVars $selfns
1943 # the basename of the $type with an initial upper case letter.
1954 set wclass [::snit::Capitalize [namespace tail $type]]
1961 ${type}::installhull using $Snit_info(hulltype) -class $wclass
1966 set dbval [RT.OptionDbGet $type $name $opt]
1974 # Execute the type's constructor, and verify that it
1977 RT.ConstructInstance $type $selfns $name $args
1979 ::snit::RT.Component $type $selfns hull
1985 bind Snit$type$name <Destroy> [::snit::Expand {
1986 ::snit::RT.DestroyObject %TYPE% %NS% %W
1987 } %TYPE% $type %NS% $selfns]
1994 bindtags $name [linsert $taglist $ndx Snit$type$name]
2003 ::snit::RT.DestroyObject $type $selfns $name
2012 # RT.MakeInstanceCommand type selfns instance
2014 # type The object type
2020 proc ::snit::RT.MakeInstanceCommand {type selfns instance} {
2021 variable ${type}::Snit_info
2041 set unknownCmd [list ::snit::RT.UnknownMethod $type $selfns $instance ""]
2051 [list ::snit::RT.InstanceTrace $type $selfns $instance]
2057 # type The fully-qualified type name
2071 proc ::snit::RT.InstanceTrace {type selfns win old new op} {
2072 variable ${type}::Snit_info
2085 ::snit::RT.DestroyObject $type $selfns $win
2102 puts "Error in ::snit::RT.InstanceTrace $type $selfns $win $old $new $op:"
2108 proc ::snit::RT.ConstructInstance {type selfns instance arglist} {
2109 variable ${type}::Snit_optionInfo
2117 ${type}::Snit_constructor $type $selfns $instance $instance]
2148 # REQUIRE: type is a fully qualified name.
2151 proc ::snit::RT.UniqueName {countervar type name} {
2161 set auto "[namespace tail $type]$counter"
2172 # type The instance's type
2174 # REQUIRE: type is fully qualified
2177 proc ::snit::RT.UniqueInstanceNamespace {countervar type} {
2187 set ins "${type}::Snit_inst${counter}"
2196 proc ::snit::RT.OptionDbGet {type self opt} {
2197 variable ${type}::Snit_optionInfo
2209 # type The snit type
2214 proc ::snit::RT.method.destroy {type selfns win self} {
2224 ::snit::RT.DestroyObject $type $selfns $win
2231 # type The fully-qualified type name.
2235 proc ::snit::RT.DestroyObject {type selfns win} {
2236 variable ${type}::Snit_info
2247 RT.RemoveInstanceTrace $type $selfns $win $instance
2250 ${type}::Snit_destructor $type $selfns $win $instance
2259 set hullcmd [::snit::RT.Component $type $selfns hull]
2264 bind Snit$type$win <Destroy> ""
2290 # type The fully qualified type name
2295 proc ::snit::RT.RemoveInstanceTrace {type selfns win instance} {
2296 variable ${type}::Snit_info
2307 [list ::snit::RT.InstanceTrace $type $selfns $win]
2319 proc ::snit::RT.TypecomponentTrace {type component n1 n2 op} {
2320 namespace upvar $type \
2334 namespace ensemble configure $type -map {}
2339 # RT.UnknownTypemethod type eId eCmd method args
2341 # type The type
2355 proc snit::RT.UnknownTypemethod {type eId eCmd method args} {
2356 namespace upvar $type \
2387 if {[set ${type}::Snit_info(isWidget)] &&
2392 # Without this check, the call "$type info" will redefine the
2413 set newCmd ${type}::Snit_ten[llength $eId]_[join $eId _]
2415 set unknownCmd [list ::snit::RT.UnknownTypemethod \
2416 $type $eId]
2423 namespace eval $type $createCmd
2438 %t $type \
2445 error "$type delegates typemethod \"$method\" to undefined typecomponent \"$compName\""
2488 proc ::snit::RT.Component {type selfns name} {
2494 error "component \"$name\" is undefined in $type $Snit_instance"
2505 proc ::snit::RT.ComponentTrace {type selfns component n1 n2 op} {
2506 namespace upvar $type Snit_info Snit_info
2532 # RT.UnknownMethod type selfns win eId eCmd method args
2534 # type The type or widget command.
2550 proc ::snit::RT.UnknownMethod {type selfns win eId eCmd method args} {
2551 variable ${type}::Snit_info
2552 variable ${type}::Snit_methodInfo
2553 variable ${type}::Snit_typecomponents
2581 # used ${type} rather than ${selfns}.
2584 set unknownCmd [list ::snit::RT.UnknownMethod \
2585 $type $selfns $win $eId]
2607 %t $type \
2621 error "$type $self delegates method \"$fullMethod\" to undefined component \"$compName\""
2655 proc ::snit::RT.ClearInstanceCaches {selfns} {
2659 # via the "variable" type definition statement.
2681 proc ::snit::RT.installhull {type {using "using"} {widgetType ""} args} {
2682 variable ${type}::Snit_info
2683 variable ${type}::Snit_optionInfo
2692 error "installhull is valid only for snit::widgetadaptors"
2696 error "hull already installed for $type $self"
2738 set dbval [RT.OptionDbGet $type $self $opt]
2753 set dbval [RT.OptionDbGet $type $self $opt]
2772 RT.MakeInstanceCommand $type $selfns $self
2785 proc ::snit::RT.install {type compName "using" widgetType winPath args} {
2786 variable ${type}::Snit_optionInfo
2787 variable ${type}::Snit_info
2813 set dbval [RT.OptionDbGet $type $self $opt]
2887 proc ::snit::RT.variable {varname} {
2903 proc ::snit::RT.mytypevar {type name} {
2904 return ${type}::$name
2910 proc ::snit::RT.myvar {name} {
2921 proc ::snit::RT.myproc {type procname args} {
2922 set procname "${type}::$procname"
2927 proc ::snit::RT.codename {type name} {
2928 return "${type}::$name"
2933 # Inserts the type command at the beginning.
2937 proc ::snit::RT.mytypemethod {type args} {
2938 return [linsert $args 0 $type]
2950 proc ::snit::RT.mymethod {args} {
2952 return [linsert $args 0 ::snit::RT.CallInstance ${selfns}]
2967 proc ::snit::RT.CallInstance {selfns args} {
2994 proc ::snit::RT.from {type argvName option {defvalue ""}} {
2995 namespace upvar $type Snit_optionInfo Snit_optionInfo
3021 # Destroys a type completely.
3023 # type The snit type
3025 proc ::snit::RT.typemethod.destroy {type} {
3026 variable ${type}::Snit_info
3029 foreach selfns [namespace children $type "${type}::Snit_inst*"] {
3045 # NEXT, get rid of the type command.
3046 rename $type ""
3048 # NEXT, destroy the type's data.
3049 namespace delete $type
3059 # type The snit type
3065 proc ::snit::RT.method.cget {type selfns win self option} {
3067 set command [snit::RT.CacheCgetCommand $type $selfns $win $self $option]
3080 # type The snit type
3086 proc ::snit::RT.CacheCgetCommand {type selfns win self option} {
3087 variable ${type}::Snit_optionInfo
3123 set obj [RT.Component $type $selfns $comp]
3133 # type The snit type
3139 proc ::snit::RT.method.configurelist {type selfns win self optionlist} {
3140 variable ${type}::Snit_optionInfo
3145 set command [snit::RT.CacheConfigureCommand \
3146 $type $selfns $win $self $option]
3153 # NEXT, if we have a type-validation object, use it.
3187 # type The snit type
3193 proc ::snit::RT.CacheConfigureCommand {type selfns win self option} {
3194 variable ${type}::Snit_optionInfo
3257 set obj [RT.Component $type $selfns $comp]
3267 # type The snit type
3273 proc ::snit::RT.method.configure {type selfns win self args} {
3276 ::snit::RT.method.configurelist $type $selfns $win $self $args
3284 foreach opt [RT.method.info.options $type $selfns $win $self] {
3287 $type $selfns $win $self $opt]
3296 return [RT.GetOptionDbSpec $type $selfns $win $self $opt]
3302 # type The snit type
3311 proc ::snit::RT.GetOptionDbSpec {type selfns win self opt} {
3312 variable ${type}::Snit_optionInfo
3326 [RT.method.cget $type $selfns $win $self $opt]]
3357 return [::snit::Expand $result $target $opt]
3372 # type The snit type
3376 proc ::snit::RT.typemethod.info {type command args} {
3391 ::snit::RT.typemethod.info.$command $type]
3402 error "\"$type info $command\" is not defined"
3408 # Returns a list of the type's typevariables whose names match a
3411 # type A Snit type
3415 proc ::snit::RT.typemethod.info.typevars {type {pattern *}} {
3417 foreach name [info vars "${type}::$pattern"] {
3427 # Returns a list of the type's methods whose names match a
3431 # type A Snit type
3435 proc ::snit::RT.typemethod.info.typemethods {type {pattern *}} {
3436 variable ${type}::Snit_typemethodInfo
3456 # Next, get the type's -map
3457 array set typemethodCache [namespace ensemble configure $type -map]
3471 # $type info args
3477 proc ::snit::RT.typemethod.info.args {type method} {
3478 upvar ${type}::Snit_typemethodInfo Snit_typemethodInfo
3503 set map [list %m $method %j [join $method _] %t $type]
3508 # $type info body
3514 proc ::snit::RT.typemethod.info.body {type method} {
3515 upvar ${type}::Snit_typemethodInfo Snit_typemethodInfo
3540 set map [list %m $method %j [join $method _] %t $type]
3545 # $type info default
3551 proc ::snit::RT.typemethod.info.default {type method aname dvar} {
3553 upvar ${type}::Snit_typemethodInfo Snit_typemethodInfo
3578 set map [list %m $method %j [join $method _] %t $type]
3583 # Returns a list of the type's instances whose names match
3586 # type A Snit type
3590 # REQUIRE: type is fully qualified.
3592 proc ::snit::RT.typemethod.info.instances {type {pattern *}} {
3595 foreach selfns [namespace children $type "${type}::Snit_inst*"] {
3611 # type The snit type
3618 proc ::snit::RT.method.info {type selfns win self command args} {
3623 type -
3630 uplevel 1 [linsert $args 0 ::snit::RT.method.info.$command \
3631 $type $selfns $win $self]
3648 # $self info type
3650 # Returns the instance's type
3651 proc ::snit::RT.method.info.type {type selfns win self} {
3652 return $type
3657 # Returns the instance's type's typevariables
3658 proc ::snit::RT.method.info.typevars {type selfns win self {pattern *}} {
3659 return [RT.typemethod.info.typevars $type $pattern]
3664 # Returns the instance's type's typemethods
3665 proc ::snit::RT.method.info.typemethods {type selfns win self {pattern *}} {
3666 return [RT.typemethod.info.typemethods $type $pattern]
3673 # type A Snit type
3680 proc ::snit::RT.method.info.methods {type selfns win self {pattern *}} {
3681 variable ${type}::Snit_methodInfo
3724 proc ::snit::RT.method.info.args {type selfns win self method} {
3726 upvar ${type}::Snit_methodInfo Snit_methodInfo
3751 set map [list %m $method %j [join $method _] %t $type %n $selfns %w $win %s $self]
3762 proc ::snit::RT.method.info.body {type selfns win self method} {
3764 upvar ${type}::Snit_methodInfo Snit_methodInfo
3789 set map [list %m $method %j [join $method _] %t $type %n $selfns %w $win %s $self]
3800 proc ::snit::RT.method.info.default {type selfns win self method aname dvar} {
3802 upvar ${type}::Snit_methodInfo Snit_methodInfo
3825 set map [list %m $method %j [join $method _] %t $type %n $selfns %w $win %s $self]
3833 proc ::snit::RT.method.info.vars {type selfns win self {pattern *}} {
3848 proc ::snit::RT.method.info.options {type selfns win self {pattern *}} {
3849 variable ${type}::Snit_optionInfo
3885 proc ::snit::RT.body {body} {
3886 regsub -all ".*# END snit method prolog\n" $body {} body