1. NS-2 LAB: TCL
Miriam Allalouf
Semester A

2. Why Scripting languages?
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!

3. Scripting languages TCL Introduction
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.

4. Script languages – TCL TCL Introduction
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

5. TCL - Tool Command Language - History
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.

6. TCL/Tk: Tk was ready by the end of 1990.
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.

7. TCL Plan: Review Tcl syntax Expressions Lists, arrays
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

8. Tcl script (String based) =
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 set the variable ‘a’ to 22
puts "Hello, World!" world’s shortest program
expr Calculates the sum of 100 and 20 and results the result, which is 120

9. Division Of Responsibility
TCL Introduction
Division Of Responsibility
Chops commands into words.
Makes substitutions.
Does not interpret values of words.
Single pass operation!
Command
Tcl Parser
Words
Interprets words.
Can invoke parser recursively.
Produces string result.
Command Procedure
Result

10. Tcl: Tool Command Language
TCL Introduction
Tcl: Tool Command Language
Simple syntax (similar to sh, C, Lisp):
set a 47 í 47
Substitutions:
set b $a í 47
set b [expr $a+10] í 57
Quoting:
set b "a is $a" í a is 47
set b {[expr $a+10]} í [expr $a+10]

11. Variable Substitution
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 66
set a b b
set a $b 66
set a $b+$b+$b
set a $b
set a $b4 no such variable

12. Command Substitution Syntax: [script]
TCL Introduction
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

13. TCL expression TCL Introduction What’s happening in these expressions?
expr $a * cos(2*$b) 
$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

14. Tcl String Expressions Some Tcl operators work on strings too
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

15. Controlling Word Structure
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

16. Notes on Substitution and Parsing
TCL Introduction
Notes on Substitution and Parsing
Tcl substitution rules are simple and absolute
Example: comments
set a 22; set b <- 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”]}”

17. Tcl Commands: TCL Introduction
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.

18. Zero or more elements separated by white space:
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 lindex llength lsearch
foreach linsert lrange lsort
lappend list lreplace
Note: all indices start with 0. end means last element
Concat ? List list …? 合併成一個
Lappend 新增
Lindex 得到第幾個
Linsert 插入list從第幾個
Llength 算個數
Lrange 取出一部分
List 形成list

19. Lists are Powerful TCL Introduction Examples:
lindex {a b {c d e} f} 2 > c d e
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 抽考
寫寫看

20. More about Lists TCL Introduction
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

21. String Manipulation TCL Introduction string subcommands
compare first last index length
match range toupper tolower trim
trimleft trimright
Note: all indexes start with 0. end means last char

22. Tcl Arrays TCL Introduction
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!)

23. Control Structures TCL Introduction 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

24. Control Structure Examples
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) }

25. More on Control Structures
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

26. proc command defines a procedure:
TCL Introduction
Procedures
proc command defines a procedure:
proc sub1 x {expr $x-1}
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.
name
body
list of argument names

27. Procedures and Scope TCL Introduction 抽考 Hanoi Tower
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
global x
> deltax 1 => 9 抽考
Hanoi Tower

28. Procedures and Scope TCL Introduction
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] }

29. Procedures and Scope TCL Introduction
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 => *****

30. More about Procedures TCL Introduction Variable-length argument lists:
proc sum args { set s 0
foreach i $args { incr s $i } return $s }
sum
>> 15
sum >> 0

31. ERRORS TCL Introduction
Errors normally abort commands in progress, application displays error message:
set n 0 foreach i { } { 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)

32. Advanced Error Handling
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"

33. Tcl file I/O Tcl file I/O commands:
TCL Introduction
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

34. TCP, Ports, and Sockets : Tcl Network I/O
TCL Introduction
TCP, Ports, and Sockets : Tcl Network I/O
Tcl provides a simplified Socket library
socket creates a network connection
set f [socket 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

35. I/O and Processes TCL Introduction
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] }

36. Runtime Information Facilities The info command
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

37. 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: 
Online Tcl/Tk manual pages:
A broad  list of Tcl/Tk resources.
The Scriptics company ( 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

38. NS-2 lab Introduction More Refernces