TCL

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):
setx4
setyx+10
setz$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.
expr24/3
arg is math expresson -> 8

eval"seta122"
evaluate argument as a command
button.btextHellofgredsome args are options (the -)
stringlengthAbracadabra
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
setb66
setab
seta$b
seta$b+$b+$b
seta$b.3
seta$b4
66
b
66
66+66+66
66.3
no such variable
Command Substitution
Syntax: [script]
Evaluate script, substitute result.
May occur anywhere within a word.

Sample command
Result
setb8
seta[expr$b+2]
seta"b3is[expr$b3]"
8
10
b3is5
Controlling Word Structure
Words break at white space and semi-colons, except:

Double-quotes prevent breaks:
seta4;sety5
seta"xis$x;yis$y"
-> xis4;yis5
Curly braces prevent breaks and substitutions:
seta{[expr$b*$c]}
>[expr $b*$c]
Backslashes quote special characters:
setaword\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

seta22;setb33<OK
#thisisacomment<OK
seta22#samething?<Wrong!
seta22;#samething<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
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!)
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
foreach
linsert
lappend
list
llength
lrange
lreplace
lsearch
lsort
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
split
string
regsub scan join
string subcommands
compare first
match
range
trimleft
last
toupper
index
length
tolower
trim
trimright
Note: all indexes start with 0. end means last char

string tolower "THIS"
string trimleft XXXXHello
string index abcde 2
;# this
;# Hello
;# c
Control Structures
C-like in appearance.
Just commands that take Tcl scripts as arguments.
Commands:
if
foreach
for
while
switch
eval
break
continue
if else
set x 2
if {$x < 3} {
puts "x is less than 3"
} else {
puts "x is 3 or more"
}
while
#list
set a
set b
set i
while
reversal
{a b c d e}
"
[expr [llength $a] - 1]
{$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
set bob_count
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

Uploaded by

Copyright:

Available Formats

TCL

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

TCL

Uploaded by

Copyright:

Available Formats

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

Or install it on your own computer

up-to-date man pages on-line

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

Simple things are simple, hard things are possible

Tcl Language Programming

Scripts and Commands

puts "My Name is $myName

Parser assigns no meaning to arguments (quoting by

Different commands assign different meanings to their

arg is math expresson -> 8

Variable name is letters, digits, underscores.

May occur anywhere in a word.

Evaluate script, substitute result.

May occur anywhere within a word.

Controlling Word Structure

Words break at white space and semi-colons, except:

Controlling Word Structure

Substitutions don't change word structure:

The # is the comment command

Tcl parsing rules apply to comments as well

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!

Arguments are interpretted as expressions in some

Tcl arrays are 'associative arrays': index is any string

You can 'fake' 2-D arrays:

(commas included in names!)

Zero or more elements separated by white space:

Braces and backslashes for grouping:

Note: all indices start with 0. end means last element

String manipulation commands:

regsub scan join

Note: all indexes start with 0. end means last char

Just commands that take Tcl scripts as arguments.

for and foreach

proc command defines a procedure:

Procedures behave just like built-in commands:

Arguments can have default values:

Procedures can have a variable number of arguments

Procedures and Scope

Scoping: local and global variables.

global procedure makes a global variable local

"I'm really outside"

proc whereAmI {inside} {