[Richard Suchenwirth] 2002-05-05 - Static variables are seen here as variables that are local to a procedure, but retain their value ("state") between calls to the procedure. One way to maintain a variable's state is to make it global (which includes putting it into a namespace), but this is frowned upon as it clutters the environment. Another way, as shown in ''intgen'' in [Braintwisters], is to store the value as default for a proc argument, and rewrite the proc definition. To generalize the specific approach taken there, we first write a proc that rewrites one argument's default with a given value: proc redefaultProc {procn argn value} { set argl {} foreach arg [info args $procn] { if [info default $procn $arg default] { if {$arg==$argn} {set default $value} lappend argl [list $arg $default] } else { lappend argl $arg } } proc $procn $argl [info body $procn] } With this tool in hand, we can proceed to write ''static'', a command that somehow resembles a C "declaration", but actively registers arguments as "static", i.e. installs a write trace so every time the variable is changed, the proc definition is rewritten (for performance, don't assign to it too often!): proc static args { set caller [lindex [info level -1] 0] foreach arg $args { uplevel 1 [list trace var $arg w [list staticTrace $caller]] } } # ... and the trace proc, which only serves to ignore 'el' and 'op': proc staticTrace {caller name el op} { upvar 1 $name var redefaultProc $caller $name $var } ..and now testing the whole thing. Note that a ''static'' variable needs also to be written into the proc argument list with a default value to start with: proc x {y {z 0}} { static z puts [incr z]:$y } % x hello 1:hello % x world 2:world Looks like we made it - proc x has a "counter" z that remembers how often it was called before, but you can reset it explicitly (as the call to x pre-increments, use -1 to start next time with a 0 counter): % x reset -1 0:reset % x test 1:test Static variables need not be numbers, for instance this example shows that it always remembers the previous call's argument (any string): proc lookback {now {before {}}} { static before puts $before->$now set before $now } And ''intgen'' can now be rewritten like this: proc intgen {{seed 0}} {static seed; incr seed} ---- [Ulrich Schoebel] 2002-10-09 - Another way to implement static variables without a need for traces is to use a reserved namespace (in this example ::StaticVariables) for their storage. This handles scalar and array variables. The variable names must not contain namespace qualifiers (why should they?). proc static {args} { set ns ::StaticVariables append ns [string trimright [uplevel 1 namespace current] :] append ns :: [namespace tail [lindex [info level -1] 0]] foreach var $args { if {![string equal [namespace tail $var] $var]} { return -code error -errorinfo "Static variable $var has namespace qualifiers" } # if {![info exists ${ns}::$var]} { namespace eval $ns [list variable $var] ;# (1) # } uplevel 1 upvar #0 ${ns}::$var $var } } This proc is completely sufficient as long as you don't rename the proc using static variables. If you need renaming, add the following: rename rename _rename proc rename {old new} { set ns ::StaticVariables append ns [string trimright [uplevel 1 namespace current] :] append nso $ns :: [string trimleft $old :] if {[string length $new] == 0} { foreach var [info vars ${nso}::*] { catch {unset $var} } _rename $old "" return "" } append nsn $ns :: [string trimleft $new :] foreach var [info vars ${nso}::*] { if {![catch {set $var} value]} { namespace eval $nsn [list set [namespace tail $var] $value] } elseif {[array exists $var]} { namespace eval $nsn [list array set [namespace tail $var] [array get $var]] } catch {unset $var} } _rename $old $new } [US] ---- [RS]: A good alternative! But I think the existence check marked at (1) above is not needed; redeclaring an existing [variable] can't hurt. [US]: I agree. Haven't read the man page thoroughly enough. Commented check. [RHS] The following works also: namespace eval ::localvars {} proc static {varName args} { if {![string equal [namespace tail $varName] $varName]} { return -code error \ "static variables may not contain namespace qualifiers" } set procName [lindex [info level -1] 0] namespace eval ::localvars [list variable [list $procName $varName]] uplevel 1 [list upvar ::localvars::[list $procName $varName] $varName] switch -exact -- [llength $args] { 0 { } 1 { set ::localvars::[list $procName $varName] [lindex $args 0] } default { return -code error \ "wrong # args: should be \"local varName ?value\"" } } trace add command $procName delete \ [list ::localvars::renameCallback $varName] trace add command $procName rename \ [list ::localvars::renameCallback $varName] } proc ::localvars::renameCallback {var oldname newname op} { switch -exact -- $op { delete { unset ::localvars::[list $oldname $var] } rename { set old ::localvars::[list $oldname $var] set new ::localvars::[list $newname $var] set $new [set $old] unset $old } default { error "Unexpected op $op to localnames::renameCallback" } } } The code and tests for the above can be found at http://robert.rkseeger.net/tcl ---- [Zarutian]: 10. may 2005: an other way would be putting a execute trace on the procedure which updates the defaults to the procedure. [Zarutian]: 6. june 2005: sorry I have been a little bit busy. package require Tcl 8.4 proc proc_with_staticVars {name args staticVars body} { set staticVarsWithValues [list] foreach item $staticVars { if {[llength $item] == 2} { lappend staticVarsWithValues $item } elseif {[llength $item] == 1} { upvar $item tmp lappend staticVarsWithValues [list $item $tmp] } } set old_args $args foreach item $staticVarsWithValues { lappend args $item } lappend args [list old_args $args] proc $name $args $body trace add execution $name leave saveStaticVars } proc saveStaticVars args { set op [lindex $args end] set command_string [lindex $args 0] set proc_name [lindex $command_string 0] if {$op == "leave"} { set vars [uplevel 1 [list info locals]] set varsAndValues [list] set old_args {} foreach item $vars { upvar $item tmp if {$item == "old_args"} { set old_args $tmp } else { lappend varsAndValues [list $item $tmp] } } set args [list] foreach item $old_args { lappend args $item } foreach item $varsAndValues { lappend args $item } proc $proc_name $args [info body $proc_name] } } ''Should work now'' [Zarutian] 2. june 2008: but it doesnt as saveStaticVars gets invoked after the command it is trace has returned and destoryed its callframe. ---- [RS] 2005-05-11: Here's how I would reimplement the namespace-based solution these days - rename at your own risk (statics will be reset to initial values then): namespace eval ::static {} proc static {name {value ""}} { set caller [lindex [info level -1] 0] namespace eval ::static::$caller {} set qname ::static::${caller}::$name if {![info exists $qname]} {set $qname $value} uplevel 1 [list upvar #0 $qname $name] } #-- Testing: proc intgen {} { static i 0 incr i } % intgen 1 % intgen 2 % intgen 3 ---- See [Streams] for many usage examples of static variables (and another ''intgen'' variation) - [Closures] - [static data in command procedures] ---- Inspired by the use of namespaces in [jimulation] by [RS] here is another version of the namespace-based solution (and another intgen variation) posted by kruzalex proc static {name {value 0}} { set caller [lindex [info level -1] 0] set qname ::static::${caller} if {![info exists ${qname}::$name]} { foreach var [list [lrange [info level 0] 1 end]] { if {[llength $var]==1} {lappend var $value} namespace eval $qname [linsert $var 0 variable] } } uplevel 1 [list upvar 0 ${qname}::$name $name] } #-- Testing: proc intgen {} { static i 0 incr i } % intgen 1 % intgen 2 % intgen 3 ---- !!!!!! %| [Category Concept] | [Arts and crafts of Tcl-Tk programming] |% !!!!!!