Programming Using Tcl/Tk
What you’ll need
What is Tcl/Tk?
Tcl Language Programming
Scripts and Commands
Arguments
Variable Substitution
Command Substitution
Controlling Word Structure
Controlling Word Structure (continued)
Comments
Summary of Tcl Command Syntax
Tcl Expressions
Tcl Arrays
Lists
String Manipulation
Control Structures
if else
while
for and foreach
switch
Procedures
Procedures
Procedures and Scope
Tcl File I/O
Tcl File I/O
Tcl Network I/O
75.00K
Category: programmingprogramming

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
English     Русский Rules