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

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

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

5. 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 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 Strings and pattern matching Control structures Procedures Error handling File and network I/O and process management Getting info at runtime TCL Introduction

8. 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 + 20Calculates the sum of 100 and 20 and results the result, which is 120 TCL Introduction

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

10. 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] TCL Introduction

11. 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 commandResult set b 6666 set a bb set a $b66 set a $b+$b+$b66+66+66 set a $b.366.3 set a $b4no such variable TCL Introduction

12. Command Substitution Syntax: [script] Evaluate script, substitute result. May occur anywhere within a word. Sample commandResult set b 88 set a [expr $b+2]10 set a "b-3 is [expr $b-3]"b-3 is 5 TCL Introduction

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

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

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

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

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

18. 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: concatlindexllengthlsearch foreachlinsertlrangelsort lappendlistlreplace Note: all indices start with 0. end means last element TCL Introduction

19. Lists are Powerful 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 commandResult set stack 11 push stack redred 1 push stack {a fish}{a fish} red 1 pop stacka fish (stack contains: red 1) push and pop are very short and use list commands to do their work TCL Introduction 抽考 寫寫看

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

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

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

23. 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: ifforswitchbreak foreachwhileevalcontinue source TCL Introduction

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

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

26. 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 list of argument names body TCL Introduction

27. 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] } > deltax 1 => 9 TCL Introduction 抽考 Hanoi Tower

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

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

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

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

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

33. Tcl file I/O Tcl file I/O commands: opengetsseekflushglob closereadtellcd fconfigure fblocked fileevent putssourceeofpwdfilename 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

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

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

36. 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 TCL Introduction

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).Bibliography: The Tcl/Tk track is based on Ousterhout and Welch's Online resources, some of the most useful Tcl/Tk links: http://dev.scriptics.com/man/tcl8.3/contents.htmOnline 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 http://stage.caldera.com/Technology/tcl/Tcl.html A broad list of Tcl/Tk resources.A broad list of Tcl/Tk resources. The Scriptics company (http://www.scriptics.com/)that commercializes Tcl and its developper web site.The Scriptics company (that commercializes Tcl and its developper web site. Tutorials: –A Tcl/Tk introductionA Tcl/Tk introduction –The TclTutorThe TclTutor –An online overview with examples.An online overview with examples. Tcl/Tk course material in hebrew (see the lecture notes sectionTcl/Tk course material in hebrew (see the lecture notes section

38. 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:wTF3fij- gGQC:www.usenix.org/publications/library/proceedings/tcl97/full_paper s/poster_bergeman/bergeman- abstract.pdf+tcl/tk+application+area&hl=en&ie=UTF-8http://216.239.51.100/search?q=cache:wTF3fij- gGQC:www.usenix.org/publications/library/proceedings/tcl97/full_paper s/poster_bergeman/bergeman- abstract.pdf+tcl/tk+application+area&hl=en&ie=UTF-8