Programming Using Tcl/Tk

These slides are based upon

several Tcl/Tk text books
material byDr. Ernest J. Friedman-Hill
 What youll need
PCs in the Computer Science Lab have it installed
Start / Tcl / Wish
Start / Widget tour
Or install it on your own computer
Windows & Macintosh: free binaries available
Most Unix: source available
Documentation
books can be bought (bookstore, etc)
books in the PC lab
up-to-date man pages on-line
Start / Help
 What is Tcl/Tk?
Tcl
a scripting language
can be extended in C (but this is harder)
ugly but simple
Tk
a simple but powerful widget set
Hello World: a complete program that exits when a
person presses the button

grid [ button .myButton -text "Hello World" -command exit ]

Simple things are simple, hard things are possible
 Tcl Language Programming
There are two parts to learning Tcl:

1. Syntax and substitution rules:

Substitutions simple (?), but may be confusing at first.

2. Built-in commands:
Can learn individually as needed.
Control structures are commands, not language syntax.
 Scripts and Commands
Tcl script =
Sequence of commands.
Commands separated by newlines, semi-colons.
Tcl command =
One or more words separated by white space.
First word is command name, others are arguments.
Returns string result.
Examples:
set myName Saul
puts "My Name is $myName
set class CPSC-481; puts -nonewline $class
 Arguments
Parser assigns no meaning to arguments (quoting by
default, evaluation is special):
set x 4 x is "4 "
set y x+10 y is "x+10
set z $x+10 z is "4+10

Different commands assign different meanings to their

arguments. Type-checking must be done by commands
themselves.
expr 24/3 arg is math expresson -> 8
eval "set a 122" evaluate argument as a command
button .b -text Hello -fg red some args are options (the -)
string length Abracadabra some args are qualifiers (length)
 Variable Substitution
Syntax: $varName
Variable name is letters, digits, underscores.
This is a little white lie, actually.
May occur anywhere in a word.
Sample command Result
set b 66 66
set a b b
set a $b 66
set a $b+$b+$b 66+66+66
set a $b.3 66.3
set a $b4 no such variable
 Command Substitution
Syntax: [script]
Evaluate script, substitute result.
May occur anywhere within a word.

Sample command Result

set b 8 8
set a [expr $b+2] 10
set a "b-3 is [expr $b-3]" b-3 is 5
 Controlling Word Structure
Words break at white space and semi-colons, except:
Double-quotes prevent breaks:
set a 4; set y 5
set a "x is $x; y is $y"
-> x is 4; y is 5
Curly braces prevent breaks and substitutions:
set a {[expr $b*$c]}
->[expr $b*$c]
Backslashes quote special characters:
set a word\ with\ \$\ and\ space
->word with $ and space
 Controlling Word Structure
(continued)
Backslashes can escape newline (continuation)
set aLongVariableNameIsUnusual \
This is a string
-> This is a string

Substitutions don't change word structure:

set a "two words"
set b $a
-> two words
 Comments
The # is the comment command
Tcl parsing rules apply to comments as well
set a 22; set b 33 <- OK
# this is a comment <- OK
set a 22 # same thing? <- Wrong!
set a 22 ;# same thing <- OK
 Summary of Tcl Command Syntax
Command: words separated by whitespace
First word is a function, others are arguments
Only functions apply meanings to arguments
Single-pass tokenizing and substitution
$ causes variable interpolation
[ ] causes command interpolation
prevents word breaks
{ } prevents all interpolation
\ escapes special characters
TCL HAS NO GRAMMAR!
 Tcl Expressions
Arguments are interpretted as expressions in some
commands: expr, if, ...
Sample command Result
set b 5 5
expr ($b*4) - 3 17
expr $b <= 2 0
expr {$b * cos(4)} -3.268
Some Tcl operators work on strings too
(but safer to use the string compare command)
set a Bill Bill
expr {$a < "Anne"} 0
expr {$a < "Fred"} 1
 Tcl Arrays
Tcl arrays are 'associative arrays': index is any string
set foo(fred) 44 ;# 44
set foo(2) [expr $foo(fred) + 6] ;# 50
array names foo ;# fred 2

You can 'fake' 2-D arrays:

set A(1,1) 10
set A(1,2) 11
array names A
=> 1,1 1,2 (commas included in names!)
 Lists
Zero or more elements separated by white space:
set colors {red green blue}
Braces and backslashes for grouping:
set hierarchy {a b {c d e} f})
set two_item_list {one two\ two}
List-related commands:
concat lindex llength lsearch
foreach linsert lrange lsort
lappend list lreplace
Note: all indices start with 0. end means last element
Examples:
lindex {a b {c d e} f} 2 c d e
lsort {red green blue} blue green red
 String Manipulation
String manipulation commands:
regexp format splitstring
regsub scan join
string subcommands
compare first lastindex length
match range toupper tolower trim
trimleft trimright
Note: all indexes start with 0. end means last char
string tolower "THIS" ;# this
string trimleft XXXXHello ;# Hello
string index abcde 2 ;# c
 Control Structures
C-like in appearance.
Just commands that take Tcl scripts as arguments.
Commands:
if for switch break
foreach while eval continue
 if else

set x 2
if {$x < 3} {
puts "x is less than 3"
} else {
puts "x is 3 or more"
}
 while
#list reversal
set a {a b c d e}
set b "
set i [expr [llength $a] - 1]
while {$i >= 0} {
lappend b [lindex $a $i]
incr i -1
}
puts $b
 for and foreach
for {set i 0} {$i<10} {incr i} {
puts $I
}

foreach color {red green blue} {

puts I like $color
}

set A(1) a; set A(2) b; set A(26) z

foreach index [array names A] {
puts $A($index)
}
 switch
set pete_count 0
set bob_count 0
set other_count 0
foreach name {Peter Peteee Bobus Me Bobor Bob} {
switch -regexp $name {
^Pete* {incr pete_count}
^Bob|^Robert {incr bob_count}
default {incr other_count}
}
}
puts "$pete_count $bob_count $other_count"
 Procedures
proc command defines a procedure:
proc decrement {x} {
expr $x-1
name body
}
list of argument names

Procedures behave just like built-in commands:

decrement 3 2
Arguments can have default values:
proc decrement {x {y 1}} {
expr $x-$y
}
decrement 100 5 ;# 95
decrement 100 ;# 99
 Procedures
Procedures can have a variable number of arguments
proc sum args {
set s 0
foreach i $args {
incr s $i
}
return $s
}

sum 1 2 3 4 5
15
sum
0
 Procedures and Scope
Scoping: local and global variables.
Interpreter knows variables by their name and scope
Each procedure introduces a new scope
global procedure makes a global variable local
set outside "I'm outside"
set inside "I'm really outside"
proc whereAmI {inside} {
global outside
puts $outside
puts $inside
}
whereAmI "I wonder where I will be"
-> I'm outside
I wonder where I will be
 Tcl File I/O
Tcl file I/O commands:
open gets seek flushglob
close read tell cd
fconfigure fblocked
fileevent
puts source eof pwd filename
File commands use 'tokens' to refer to files
set f [open "myfile.txt" "r"]
=> file4
puts $f "Write this text into file"
close $f
 Tcl File I/O
gets and puts are line oriented
set x [gets $f] reads one line of $f into x
read can read specific numbers of bytes
read $f 100
=> (up to 100 bytes of file $f)
seek, tell, and read can do random-access I/O
set f [open "database" "r"]
seek $f 1024
read $f 100
=> (bytes 1024-1123 of file $f)
 Tcl Network I/O
socket creates a network connection
set f [socket www.sun.com 80]
fconfigure $f -buffering line
puts $f "GET /"
puts [read $f 100]
close $f
=> The 1st 100 characters from Sun's home page
Network looks just like a file!
To create a server socket, just use
socket -server accept portno