Programming Using Tcl/Tk

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
set y x+10
set z $x+10
x is "4 "
y is "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
set a b
set a $b
set a $b+$b+$b
set a $b.3
set a $b4
66
b
66
66+66+66
66.3
no such variable

8. Command Substitution

Syntax: [script]
Evaluate script, substitute result.
May occur anywhere within a word.
Sample command
Result
set b 8
set a [expr $b+2]
set a "b-3 is [expr $b-3]"
8
10
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
# this is a comment
set a 22 # same thing?
set a 22 ;# same thing
<- OK
<- OK
<- Wrong!
<- 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
– set foo(2) [expr $foo(fred) + 6]
– array names foo
;# 44
;# 50
;# 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
lsort {red green blue}
c d e
blue green red

16. 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"
string trimleft “XXXXHello”
string index “abcde” 2
;# this
;# Hello
;# c

17. Control Structures

C-like in appearance.
Just commands that take Tcl scripts as arguments.
Commands:
if
foreach
for
while
switch
eval
break
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} {
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

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
close
puts
gets
seek
read
tell
fconfigure
fileevent
source eof
flushglob
cd
fblocked
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