Transcript ONU - SW HLD

NS-2 LAB: TCL
Miriam Allalouf
2005-2006 - Semester A
TCL Introduction
Why Scripting languages?
•C,C++,Java  Perl, Python, TCL
•UNIX scripting languages: XTERM + shell, PERL:
–based around C type language constructs.
• Scripting languages chars.:
–Configure
–Glue different application
– Flexible data structure  easy porting
– Slow but processor’s power grew!
– Undefined variable types
– Code and Data are the same : easy to add code!
TCL Introduction
Scripting languages
•A script file is a list of commands which a shell
interpreter reads and executes.
•First line is a line which indicates what interpreter to
run.
•Rest of the file is just a sequence of commands, most
often just like those you can run on your command line.
•Script languages include some method for manipulating
variables and data.
TCL Introduction
Script languages – TCL
•The tcl interpreter gives a bridging solutions:
–TK - display extension for using X widgets (TCL/TK)
–XML
–CORBA
–ORACLE, Sybase
–DCOM,SAP,WEB, HTTP
–SNMP
–Test Equipment
•The tcl interpreter is called "tclsh". You can run: which tclsh
•in order to find out where your tcl interpreter is located.
•The first line of your tclsh script should be:
–#!/your.location/tclsh
TCL Introduction
TCL - Tool Command Language - History
1980’s Tcl invented by John Ousterhout while working
on design tools for integrated circuits at the University of
California at Berkeley. Wanted a language that could be
used over many tools.
•To create a good interpreted language
•To build it as a library package that could be reused in
many different applications.
•To provide a language interpreter with a set of generic
facilities, such as variables, control structures, and
procedures.
•To enable the application that used the language to
extend it and add its own features into the language, so
that the language could be used to control the
application.
TCL Introduction
TCL Goals
The goals set for the language were:
•The language must be extensible: The language must be very
easy to work on, and it should be easy and convenient to add
features to the language in order to adapt this language to the
programmer’s specific goal.
•The application should be very simple and generic: The
application should be able to work easily with many different
applications in such a way that it does not restrict the features that
those applications have to provide.
•Integration: The language should be able to glue together the
extensions. Thus the language must have good facilities for
integration.
The first version of Tcl in a graphical text editor was ready by the
spring of 1988.
TCL/Tk: Tk was ready by the end of 1990.
TCL Introduction
TCL Plan:
•
•
•
•
•
•
•
•
•
Review Tcl syntax
Expressions
Lists, arrays
Strings and pattern matching
Control structures
Procedures
Error handling
File and network I/O and process management
Getting info at runtime
TCL Introduction
TCL Basics
• Tcl script (String based) =
– 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 (always returns – usually numbers)
• Examples:
set a 22
set the variable ‘a’ to 22
puts "Hello, World!" world’s shortest program
expr 100 + 20 Calculates the sum of 100 and 20 and results
the result, which is 120
TCL Introduction
Division Of Responsibility
Command
Tcl Parser
Words
Command Procedure
Result
• Chops commands into words.
• Makes substitutions.
• Does not interpret values of
words.
• Single pass operation!
• Interprets words.
• Can invoke parser
recursively.
• Produces string result.
TCL Introduction
Tcl: Tool Command Language
• Simple syntax (similar to sh, C, Lisp):
set a 47
í
47
í
í
47
57
• Substitutions:
set b $a
set b [expr $a+10]
• Quoting:
set b "a is $a"
í a is 47
set b {[expr $a+10]} í [expr $a+10]
TCL Introduction
Variable Substitution
• Syntax: $varName
• Variable name is letters, digits, underscores.
•
•
•
•
– This is a little white lie, actually.
Tcl will promote integers to reals when needed
All values translated to the same type
Note that expr knows about types, not Tcl!
May occur anywhere in a word.
Sample command
Result
set b 66
set a b
set a $b
set a $b+$b+$b
set a $b.3
set a $b4
66
b
66
66+66+66
66.3
no such variable
TCL Introduction
Command Substitution
• Syntax: [script]
• Evaluate script, substitute result.
• May occur anywhere within a word.
Sample command
Result
set b 8
set a [expr $b+2]
set a "b-3 is [expr $b-3]"
8
10
b-3 is 5
TCL Introduction
TCL expression
• What’s happening in these expressions?
expr $a * cos(2*$b)  -5.03443
$a, $b substituted by scanner before expr is called
expr {$b * [fac 4]} 
120
here, $b is substituted by expr itself
• Therefore, expressions get substituted more than
once! (In fact, TCL once, and expr once)
set b \$a
set a 4
expr $b * 2  8
TCL Introduction
Tcl String Expressions
• Some Tcl operators work on strings too
set a Bill Bill
expr {$a < "Anne"} 0
• <, >, <=, >=, ==, and != work on strings
• Beware when strings can look like numbers
• You can also use the string compare function
TCL Introduction
Controlling Word Structure
• Words break at white space and semi-colons, except:
– Double quotation marks group words as a single argument
to a command and prevent breaks.Dollar signs and square
brackets are interpreted inside double quotation marks.
set a "x is $x; y is $y"
– Curly braces also group words into a single argument. In this
case, however, elements within the braces are not
interpreted or substituted.
set a {[expr $b*$c]}
– Backslashes quote special characters: For example, \n
generates a newline.
set a word\ with\ \$\ and\ space
– Backslashes can escape newline (continuation)
• Substitutions don't change word structure:
set a "two words"
set b $a
TCL Introduction
Notes on Substitution and Parsing
• Tcl substitution rules are simple and absolute
– Example: comments
set a 22; set b 33
<- OK
# this is a comment
<- OK
set a 22 # same thing? <- Wrong!
set a 22 ;# same thing <- OK
• Parser looks at a command just once!
• It’s OK to experiment
– Expressions exist that can’t be written in one
command
– Sometimes things get hairy “{[“cmd”]}”
TCL Introduction
Tcl Commands:
• Built-in commands: this group of commands is
provided by the Tcl interpreter itself.
• All of the commands discussed so far.
• Present in all Tcl applications.
• Tcl extension commands: created using the Tcl
extension mechanism.
– Tcl APIs to create a new command where the
command procedure is implemented in C or C++,
command name be registered with the Tcl
interpreter. TCL recognizes this particular name for
a Tcl command and, will execute the new
command.
• proc commands: consists of procedures created with
the proc command.
TCL Introduction
Lists
• Zero or more elements separated by white
space:
red green blue
• Braces and backslashes for grouping:
a b {c d e} f
(4 words)
one\ word two three
(3 words)
• List-related commands:
concat
foreach
lappend
lindex
linsert
list
llength
lrange
lreplace
lsearch
lsort
• Note: all indices start with 0. end means last
element
TCL Introduction
Lists are Powerful
• Examples:
lindex {a b {c d e} f} 2
>cde
lsort {red green blue}
> blue green red
• A list makes a handy stack
Sample command
Result
set stack 1
1
push stack red
red 1
push stack {a fish}
{a fish} red 1
抽考
pop stack
a fish
寫寫看
(stack contains: red 1)
• push and pop are very short and use list commands
to do their work
TCL Introduction
More about Lists
• A true list’s meaning won’t change when (re)scanned
red $animal blue $animal <= not a list
red fish blue fish
<= list
red \$fish blue \$fish <= not a list, but
list red \$fish blue \$fish gives you…
red {$fish} blue {$fish} <= which is a list
• Commands and lists are closely related
– A command is a list
– Use eval to evaluate a list as a command
TCL Introduction
String Manipulation
string subcommands
compare
first last index length
match range toupper tolower trim
trimleft trimright
• Note: all indexes start with 0. end means last char
TCL Introduction
Tcl Arrays
• Tcl arrays are 'associative arrays': index is any string
set x(fred) 44
set x(2) [expr $x(fred) + 6]
array names x
=> 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!)
TCL Introduction
Control Structures
• C-like in appearance.
• Just commands that take Tcl scripts as arguments.
• Example: list reversal. Set list b to reverse of list a:
set b ""
set i [expr [llength $a] - 1]
while {$i >= 0} {
lappend b [lindex $a $i]
incr i -1
}
• Commands:
if
for
switch
break
foreach
while
eval
continue
source
TCL Introduction
Control Structure Examples
• if expr script
• for script expr script script
for {set i 0} {$i<10} {incr i} {...}
• switch (opt) string {p1 s1 p2 s2...}
• foreach index [array names a] {
puts $a($index)
}
TCL Introduction
More on Control Structures
• Brackets are not required
set x 3
if $x>2 {...
<= this is OK, eval’ed once
while $x>2 {... <= eval’ed many times!
set a {red blue green}
foreach i $a
<= this is OK
foreach i red blue green {...
NOT OK!
• foreach index [array names A] is a common idiom
TCL Introduction
Procedures
• proc command defines a procedure:
proc sub1
x
{expr $x-1}
name
body
list of argument names
• Procedures behave just like built-in commands:
sub1 3
í2
• Arguments can have default values:
proc decr {x {y 1}} {
expr $x-$y
}
– Return value of a procedure is implicitly the return value of
the last statement in the script. Unless the ‘return’ command
exists.
TCL Introduction
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 x 10
> proc deltax {d} {
set x [expr $x-$d]
}
> deltax 1 => can't read x: no such variable
> proc deltax {d} {
global x
抽考
set x [expr $x-$d]
Hanoi
}
> deltax 1 => 9
Tower
TCL Introduction
Procedures and Scope
• Note that global is an ordinary command
proc tricky {varname} {
global $varname
set $varname "passing by reference"
• upvar and uplevel let you do more complex things
• level naming:
– #num: #0 is global, #1 is one call deep, #2 is 2…
– num: 0 is current, 1 is caller, 2 is caller's caller…
proc incr {varname} {
upvar 1 $varname var
set var [expr $var+1]
}
TCL Introduction
Procedures and Scope
• uplevel does for code what upvar does for variables
proc loop {from to script} {
set i $from
while {$i <= $to} {
uplevel $script
incr i
}
}
set s ""
loop 1 5 {set s $s*}
puts $s
=> *****
TCL Introduction
More about Procedures
• Variable-length argument lists:
proc sum args {
set s 0
foreach i $args {
incr s $i
}
return $s
}
sum 1 2 3 4 5
>> 15
sum
>> 0
TCL Introduction
ERRORS
• Errors normally abort commands in progress,
application displays error message:
set n 0
foreach i {1 2 3 4 5} {
set n [expr {$n + i*i}]
}
í syntax error in expression "$n + i*i"
• Global variable errorInfo provides stack trace:
set errorInfo
í syntax error in expression "$n + i*i"
while executing
"expr {$n + i*i}"
invoked from within
"set n [expr {$n + i*i}]..."
("foreach" body line 2)
...
TCL Introduction
Advanced Error Handling
• Global variable errorCode holds machine-readable
information about errors (e.g. UNIX errno value).
NONE (in this case)
• Can intercept errors (like exception handling):
catch {expr {2 +}} msg
í 1 (catch returns 0=OK, 1=err, other values...)
set msg
í syntax error in expression "2 +"
• You can generate errors yourself (style question:)
error "bad argument"
return -code error "bad argument"
TCL Introduction
Tcl file I/O
• Tcl file I/O commands:
open
close
fconfigure
puts
gets seek
read tell
fblocked
sourceeof
flush glob
cd
fileevent
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 Introduction
TCP, Ports, and Sockets : Tcl Network I/O
• Tcl provides a simplified Socket library
• socket creates a network connection
set f [socket www.sun.com 80]
fconfigure $f -buffering line
puts $f "GET /"
puts [read $f]
=> loads of HTML from Sun's home page
• Network looks just like a file!
• To create a server socket, just use
socket -server accept portno
TCL Introduction
I/O and Processes
• exec starts processes, and can use '&'
set FAVORITE_EDITOR emacs
exec $FAVORITE_EDITOR &
• no filename expansion; use glob instead
eval exec "ls [glob *.c]"
• you can open pipes using open
set f [open "|grep foo bar.tcl" "r"]
while {[eof $f] != 0} {
puts [gets $f]
}
TCL Introduction
Runtime Information Facilities
• The info command
what variables are there?
–info vars, info globals, info locals, info exists
what procedures have I defined, and how?
–info procs, info args, info default, info body, info
commands
• the rename command
–can rename any command, even built-in
–can therefore replace any built-in command
NS-2 lab TCL Introduction
Resources
•Bibliography: The Tcl/Tk track is based on Ousterhout and Welch's
book (Practical Programming in Tcl/Tk).
•Online resources, some of the most useful Tcl/Tk
links: http://dev.scriptics.com/man/tcl8.3/contents.htm
•Online Tcl/Tk manual pages:
http://stage.caldera.com/Technology/tcl/Tcl.html
•A broad list of Tcl/Tk resources.
•The Scriptics company (http://www.scriptics.com/)that commercializes
Tcl and its developper web site.
•Tutorials:
–A Tcl/Tk introduction
–The TclTutor
–An online overview with examples.
•Tcl/Tk course material in hebrew (see the lecture notes section
NS-2 lab Introduction
More Refernces
•http://www.ixiacom.com/products/paa/customappdev/
•http://www.cetus-links.org/oo_tcl_tk.html#oo_tcl_tk_start_here
•http://www.pconline.com/~erc/tcl.htm
•http://www.scriptics.com/doc/scriptHistory.html
•http://www.itworld.com/AppDev/1243/UIR000804tk/
•http://www.softpanorama.org/Scripting/tcl_tk.shtml
•http://www.tcl.tk/advocacy/choose.html
•http://www.cs.utah.edu/dept/old/texinfo/dejagnu/dejagnu_8.html
•http://www.usenix.org/publications/library/proceedings/tcl95/
•http://216.239.51.100/search?q=cache:wTF3fijgGQC:www.usenix.org/publications/library/proceedings/tcl97/full_paper
s/poster_bergeman/bergemanabstract.pdf+tcl/tk+application+area&hl=en&ie=UTF-8