Programming Using TclTk These slides are based upon

Programming Using Tcl/Tk These slides are based upon u u several Tcl/Tk text books material by. Dr. Ernest J. Friedman-Hill

What you’ll need u u u 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? u Tcl u – 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. my. Button -text "Hello World" -command exit ] u 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 u u u 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 my. Name Saul puts "My Name is $my. Name” set class CPSC-481; puts -nonewline $class

Arguments u Parser assigns no meaning to arguments (quoting by default, evaluation is special): set x 4 set y x+10 set z $x+10 u 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)

Variable Substitution u Syntax: $var. Name u Variable name is letters, digits, underscores. – This is a little white lie, actually. May occur anywhere in a word. Sample command Result u set set set b a a a 66 66 b b $b 66 $b+$b+$b 66+66+66 $b. 3 66. 3 $b 4 no such variable

Command Substitution u Syntax: [script] u Evaluate script, substitute result. u 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]" 5 b-3 is

Controlling Word Structure u 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 a. Long. Variable. Name. Is. Unusual “This is a string” -> This is a string – Substitutions don't change word structure: · set a "two words" set b $a -> two words

Comments u The # is the comment command u 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 u Command: words separated by whitespace u 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 u u u u { } prevents all interpolation escapes special characters TCL HAS NO GRAMMAR!

Tcl Expressions u u 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 expr {$a < "Anne"} 0 expr {$a < "Fred"} 1

Tcl Arrays u Tcl arrays are 'associative arrays': index is any string – set foo(fred) 44 – set foo(2) [expr $foo(fred) + 6] – array names foo u ; # 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 u Zero or more elements separated by white space: set colors {red green blue} u Braces and backslashes for grouping: set hierarchy {a b {c d e} f}) set two_item_list {one two two} u u List-related commands: concat lindex llength lsearch foreach linsert lrange lsort lappend list lreplace Note: all indices start with 0. end means last element u Examples: lindex {a b {c d e} f} 2 lsort {red green blue} red íc d e í blue green

String Manipulation u String manipulation commands: regexp format split regsub scan join string u string subcommands compare first last index length match range toupper tolower trimleft trimright u 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 u C-like in appearance. u Just commands that take Tcl scripts as arguments. Commands: if for switch break foreach while eval continue u

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 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 u proc command defines a procedure: proc decrement {x} { expr $x-1 name body } list of argument names u Procedures behave just like built-in commands: decrement 3 í 2 u Arguments can have default values: proc decrement {x {y 1}} { expr $x-$y } decrement 100 5 ; # 95 decrement 100 ; # 99

Procedures u 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 u Scoping: local and global variables. u – 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 where. Am. I {inside} { global outside puts $inside } where. Am. I "I wonder where I will be" -> I'm outside I wonder where I will be

Tcl File I/O u u Tcl file I/O commands: open gets seek flush close read tell cd fblocked fileevent puts source eof pwd glob fconfigure filename File commands use 'tokens' to refer to files set f [open "myfile. txt" "r"] => file 4 puts $f "Write this text into file" close $f

Tcl File I/O u u u 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 u 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 1 st 100 characters from Sun's home page u u Network looks just like a file! To create a server socket, just use socket -server accept portno