Tcl |
Tcl (originally from Tool Command Language , but nonetheless conventionally rendered as Tcl rather than TCL ; and pronounced like tickle ) is a scripting language created by John Ousterhout that is generally thought to be easy to learn, but powerful in competent hands. It is most commonly used for rapid prototyping, scripted applications, GUIs and testing.
= Features =
Tcl s features include:
Tcl proper does not provide an Object-oriented programming framework, but it can be extended to provide new features as needed. Many C extensions have been written to give OO functionality, including the XOTcl and incr Tcl packages. Other OO extensions, including Snit and STOOOP (simple tcl-only object-oriented programming), are written fully in Tcl.
Functional programming can easily be done in Tcl, as higher-order functions or functional abstractions are built into the language, though it is not widely used for this purpose. As an example, consider the ease with which two functions can be composed: proc o {f g x} {$f [$g $x]}
= Syntax =
== Very simple and consistent syntax ==
Tcl has a very simple syntax which is applied in a consistent way. A Tcl script consists of several commands. A command is a list of words separated by whitespace.
word0 word1 word2 ... wordN
The first word is the name of a command, which is not built into the language, but which is in the library. The following words are arguments. So we have:
commandName argument1 argument2 ... argumentN
Any argument may be replaced by another command in square brackets. The subcommand is evaluated first and the result is substituted as the argument. Alternatively, any argument placed in curly braces will not be evaluated, but rather will be handed directly back to the orginal command as an argument.
To summarize: there is one basic construct (the command) and a set of simple substitution rules, and only the block, the curly braces and the backslash have a special meaning besides the quotes. The single equality sign (=) for example is not used at all, and the double equality sign (==) is the test for equality, and even then only in the expr command.
All commands have the same structure, a keyword which is followed by several parameters. A command is terminated by a newline or a semicolon. Even comments are just commands which happen to do nothing.
Tcl is not statically typed: each variable may contain integers, floats, strings, lists or any other value.
=== Symbols with a special meaning ===
== Some examples of commands ==
Assignments are made with the command set , no equality sign.
set variable value
While loops are implemented by the command while which takes two arguments. The arguments are Tcl scripts. They are in curly braces to avoid execution on the first level of interpretation. Within the execution of the while command the scripts are executed.
while { [aTCLcommandWhichEvalutesToAnInteger] } { aTCLcommand anotherTclCommand .... }
If command
if {$x < 0} { set x 0 }
Commands may have no arguments
pwd
gives back the current working directory. With
set wdir [pwd]
you store the string describing the working directory in the variable wdir .
A command may give back as a result a list
glob aPattern
gives back a list of file names in the working directory whose names match aPattern .
== Procedures ==
Procedures are defined as follows
proc nameOfProc { argumentList } { .... .... }
== Associative arrays ==
The following code snippet creates and initializes an associative array which in other languages is called a map, dictionary, or hash table.
set capital(France) Paris set capital(Italy) Rome set capital(Germany) Berlin set capital(Poland) Warsaw set capital(Russia) Moscow set capital(Spain) Madrid
To query it and put the result on standard output use
puts $capital(Italy)
To get a list of all countries for which a capital is defined use array names capital
The result is unsorted because Tcl arrays are based hash tables. Poland Spain Russia Germany Italy France
If you like to have it sorted use lsort [array names capital]
Note however that arrays are collections of variables, not first-class objects, and cannot be freely passed around the way strings are. The commands
set CapitalCopy $capital
and
DoSomethingWith $capital
both produce the error message
can t read capital : variable is array
In general, note that Tcl has a different concept of references than some people might expect. To refer to an array (to pass it by reference), give its variable name: proc demo _arr { upvar 1 $_arr arr ;# tie the reference to a local name #do something with arr }
To pass the contents of an array by value, use array get resp. array set . For example, to copy one array to another:
array set Newarr [array get Oldarr]
For pure-value associative arrays, Tcl introduced the dict type in version 8.5.
= Extension Packages =
The Tcl language has always supported extension packages, which provide additional functionality (such as a GUI, terminal-based application automation, database access, etc.)
The most popular Tcl extension is the Tk toolkit, which provides a graphical user interface library for a variety of operating system. Each GUI consists of one or more frames . Each frame has a layout manager.
Another popular extension is Expect, which allows automated driving of terminal-based programs (such as passwd, ftp, telnet and command driven shells).
A number of database extensions are available:
= Examples =
== Hello, world!==
puts Hello, world!
or
puts {Hello, world!}
== Echo server ==
A simple working example, demonstrating event-based handling of a socket, follows.
#!/bin/sh # next line restarts using tclsh in path exec tclsh $0 ${1+ $@ }
# echo server that can handle multiple # simultaneous connections.
proc newConnection { sock addr port } { # client connections will be handled in # line-buffered, non-blocking mode fconfigure $sock -blocking no -buffering line
# call handleData when socket is readable fileevent $sock readable [ list handleData $sock ] }
proc handleData { sock } { puts $sock [ gets $sock ] if { [ eof $sock ] } { close $sock } }
# handle all connections to port given # as argument when server was invoked # by calling newConnection set port [ lindex $argv 0 ] socket -server newConnection $port
# enter the event loop by waiting # on a dummy variable that is otherwise # unused. vwait forever
== Digital clock ==
Another example using Tk (from [http://mini.net/tcl/2563.html A simple A/D clock]) and timer events, a digital clock in three lines of code:
proc every {ms body} { eval $body after $ms [list every $ms $body] } pack [label .clock -textvar time] every 1000 {set ::time [clock format [clock sec] -format %H:%M:%S]} ;# RS
Explanation: the first line defines a command, every , which re-schedules an action ( body ) every ms milliseconds; the second creates a label whose content is bound to the variable time ; the third line arranges so that the variable time is updated to formatted local time every second.
Note that the every command treats its first parameter as a number and its second parameter as a script, resulting in correct calls being those programs that pass in arguments that look like those pieces of syntax. However, the Tcl interpreter assigns no special syntactic interpretation to either argument, meaning that the code is free to interpret those arguments as desired. (By contrast, a language using a conventional BNF description could only achieve the equivalent functionality by defining every as a keyword, adding extra syntax to mark the executable argument, or by making the curly braces deeply magical indeed, possibly requiring a more complex declaration.)
== List of content of associative array ==
In an array tcl_platform , platform-specific properties are kept. A list of the names of the properties is obtained by
array names tcl_platform
The following snippet lists them together with their values
foreach i [array names tcl_platform] { puts [ concat $i= $tcl_platform($i) ] }
If the properties should be sorted
foreach i [lsort [array names tcl_platform]] { puts [ concat $i= $tcl_platform($i) ] }
This demonstrates how commands may be nested. In fact they may be nested to any depth. If you want it fancier (keys padded with blanks so that the equal signs align) just use the proc parray that comes delivered with Tcl.
== Intersection of two sets ==
The filter procedure returns those elements of the list where the script returns TRUE: proc filter {list script} { set res {} foreach e $list {if {[uplevel 1 $script $e]} {lappend res $e}} set res } The in procedure is shorthand for list inclusion:
proc in {list e} {expr {[lsearch -exact $list $e]>=0}} Testing: % filter {a b c} {in {b c d}} b c
== Factorial ==
proc ! x {expr {$x|
|