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 -> 8eval "set a 122" evaluate argument as a commandbutton .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 66set a b bset a $b 66set a $b+$b+$b 66+66+66set a $b.3 66.3set 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 8set a [expr $b+2] 10set 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 5set 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 <- OKset 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 Resultset b 5 5expr ($b*4) - 3 17expr $b <= 2 0expr {$b * cos(4)} -3.268…

Some Tcl operators work on strings too(but safer to use the string compare command)

set a Bill Billexpr {$a < "Anne"} 0expr {$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 lsearchforeach linsert lrange lsortlappend list lreplace

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

lindex {a b {c d e} f} 2 c d elsort {red green blue} blue green red

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

Control Structures C-like in appearance. Just commands that take Tcl scripts as arguments. Commands:

if for switch breakforeach while evalcontinue

if else

set x 2

if {$x < 3} {

puts "x is less than 3"

} else {

puts "x is 3 or more"

}

while

#list reversalset 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}

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 ;# 95decrement 100 ;# 99

name

list of argument names

body

Procedures

Procedures can have a variable number of argumentsproc sum args { set s 0

foreach i $args { incr s $i } return $s}

sum 1 2 3 4 5 15sum 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 outsideI wonder where I will be

Tcl File I/O

Tcl file I/O commands:

open gets seek flush globclose read tell cdfconfigure fblocked fileeventputs 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