unit vii wp ppt
DESCRIPTION
web Programming UNIT VII notesTRANSCRIPT
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