Programming Using Tcl/Tk

These slides are based upon

 several Tcl/Tk text books
 material byDr. Ernest J. Friedman-Hill
 What you’ll 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 last index 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 flush glob
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