Programming Using Tcl/Tk

mewstennisSoftware and s/w Development

Nov 4, 2013 (4 years and 1 month ago)

77 views

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

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

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

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

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

OK

set 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

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 ;# 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

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

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

break


foreach

while

eval

continue

if else


set x 2

if {$x < 3} {


puts "x is less than 3"

} else {


puts "x is 3 or more"

}

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


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 ;# 95

decrement 100

;# 99

name

list of argument names

body

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


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