Programming Using Tcl/Tk Tcl/Tk is a scripting language and widget toolkit. Tcl is used to write scripts and can be extended with C. Tk provides widgets to build graphical user interfaces. Simple programs in Tcl/Tk are easy to write, but more complex tasks are also possible. The language has no formal grammar but uses commands, variables, and substitutions to provide programming capabilities.

1. Programming Using Tcl/Tk
These slides are based upon
several Tcl/Tk text books
material byDr. Ernest J. Friedman-Hill

2. 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

3. 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

4. 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.

5. 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

6. 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)

7. 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

8. 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

9. 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

10. 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

11. 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

12. 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!

13. 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

14. 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!)

15. 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

16. String Manipulation
String manipulation commands:
regexp format split string
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

17. Control Structures
C-like in appearance.
Just commands that take Tcl scripts as arguments.
Commands:
if for switch break
foreach while eval continue

18. if else
set x 2
if {$x < 3} {
puts "x is less than 3"
} else {
puts "x is 3 or more"
}

19. 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

20. 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)
}

21. 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"

22. Procedures
proc command defines a procedure:
proc decrement {x} {
name
expr $x-1 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

23. 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

24. 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

25. 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

26. 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)

27. 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