Dear XOTcl Community,
here comes the announcement of XOTcl 1.2.0 all the best
-gustaf neumann =======================================================
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
-- Univ.Prof. Dr.Gustaf Neumann Abteilung für Wirtschaftsinformatik WU-Wien, Augasse 2-6, 1090 Wien
-------------------------------------------------------