Announcing XOTcl 1.2.0 ********************** WHAT IS XOTCL? XOTcl is an object-oriented extension of Tcl that was derived from OTcl. In short, XOTcl tries to provide a highly flexible, reflective, component-based, and object-oriented environment. It integrates language support for high-level concepts which are not found in other languages, with reasonable performance. It prevails the Tcl programming style and the dynamic/introspective nature of the language, rather than introducing other language's styles and rigidness (such as C++) into Tcl. CHANGES relative to 1.1.1 are: - Qualitative Improvements * improved performance (up to more than 30% faster) * reduced dependency on Tcl internals (stack rewritings removed) * less C-code (code reduction of about 500 lines c code) * defined macros to access Tcl's internal structures Due to the speedup, an emulation of an itcl like language in XOTcl can be faster than itcl itself (see below). - Functional Improvements * new subcommands of self: self callinglevel: returns the scope of the proc/instproc calling the current method (ignoring filters and next) self activelevel: returns the scope of the proc/instproc preceding the current method (might be a next call, ignoring filters) the returned level can be used in uplevel/upvar as first argument * new methods upvar/uplevel "my uplevel set x 1" is a short form of "uplevel [self callinglevel] set x 1" * sub-objects can be called like methods (potential incompatibility) If an object named o has a sub-object q (i.e. o::q) it is now possible to invoke the sub-object via "o q ?method args?". This change makes it possible to - to redefine tcl sub-commands via procs/instprocs by defining the command with subcommands as an object (instead of defining a command as a proc and its subcommands via a large and hard-to-refine switch statement) - to use the same approach for defining subcommands of subcommands (and so on) in the same way; it would be possible to define e.g. the xotcl info methods via an object), - to use interceptors (filters/mixins) for some or all subcommands (maybe you are only interested in "file delete") - to extend a tcl command on the fly by defining new subcommands (by defining new procs/instprocs) - to use the unknown mechanism to produce dynamic error messages about valid subcommands (via introspection commands). As a simple example, one define the a specialized version of Tcl's file-command (say ns::file) like the following: namespace eval ns { Object file file proc tail name { set tail [file tail $name] regexp {[^/\\]+$} $tail tail return $tail } file proc unknown {subcmd args} { return eval ::file $subcmd $args } } For more details, please consult the ChangeLog MORE INFO General and more detailed information about XOTcl and its components can be found at http://www.xotcl.org Best regards, Gustaf Neumann Uwe Zdun #======================================================================= # extract from the logfile of oobench (in oo-bench.tar.gz, # see http://media.wu-wien.ac.at/download.html) XOTcl methcall: 0.470u 0.000s 0:00.41 114.6% 0+0k 0+0io 347pf+0w ITcl emulation in XOTcl methcall: 0.590u 0.000s 0:00.62 95.1% 0+0k 0+0io 351pf+0w itcl methcall: 0.870u 0.020s 0:00.92 96.7% 0+0k 0+0io 347pf+0w #======================================================================= package require XOTcl; namespace import -force xotcl::* ########################################################### ## Small example to emulate a itcl-like language in XOTcl ## -gustaf neumann Jan. 2004 ########################################################### namespace eval itcl { Class create class -superclass Class class instproc instvars {} { set vars [list]; set c [self] for {} {[string compare ::xotcl::Object $c]} {set c [$c info superclass]} { eval lappend vars [$c set __autovars] } return "\n\tmy instvar [lsort -unique $vars]" } class proc constructor {args} { if {[llength $args]==2} { foreach {arglist body} $args break } else { foreach {arglist construct body} $args break set body $construct\n$body } my parameter [list {this [self]}] my proc constructor args {uplevel next $args} my instproc init $arglist [my instvars]\n$body } class proc method {name arglist body} { my proc $name args {uplevel next $args} my instproc $name $arglist [my instvars]\n$body } class proc inherit {class} { my superclass $class } class proc variable {arglist} { foreach v $arglist {my lappend __autovars $v} } class instproc init {classdef} { my set __autovars this namespace eval [self class] $classdef my class Class } } ########################################################### # Two Demo classes from oo-bench ########################################################### itcl::class Toggle { variable state constructor {start_state} { set state $start_state } method value {} { return $state } method activate {} { set state [expr {!$state}] return $this } } itcl::class NthToggle { inherit Toggle variable count_max variable counter constructor {start_state max_counter} { Toggle::constructor $start_state } { set count_max $max_counter set counter 0 } method activate {} { if {[incr counter] >= $count_max} { Toggle::activate set counter 0 } return $this } } proc main {} { set n [lindex $::argv 0] set val 1 set toggle [Toggle t1 $val] for {set i 0} {$i < $n} {incr i} { set val [[$toggle activate] value] } if {$val} {puts "true"} else {puts "false"} set val 1 set ntoggle [NthToggle t2 1 3] for {set i 0} {$i < $n} {incr i} { set val [[$ntoggle activate] value] } if {$val} {puts "true"} else {puts "false"} } main