Scripting with TCL, Part 1

Transcription

1 Scripting with TCL, Part 1 Axel Kohlmeyer Center for Molecular Modeling University of Pennsylvania SBS JNCASR, Bangalore

2 The VMD Execution Model GUI (FLTK) Internal State Visualization Python Interpreter Tcl/Tk Interpreter

3 The Purpose of Scripting Extension to command line interface Automate/group sequences of commands Simplify repetitive tasks w/o programming Easily modifiable/adjustable programs Slower execution offset by faster programming Provide level of abstraction from low-level tasks Allow non-programmers to do complex tasks

4 Some Script Languages COMMAND.COM (DOS): ->.bat files ( batch execution of commands) Bourne shell / C shell (UNIX): -> #!/bin/sh or #!/bin/csh in first line of file (so-called shell scripts, in Unix reading from keyboard or a file is (mostly) equivalent) BASIC (PET, C64, GW-BASIC, Q-BASIC): Interpreter & line program editor => very platform dependent

5 Advanced Script Languages Languages with large integrated functionality Powerful syntax, similar to compiled languages Extensible & modular: new functionality can be added through script libraries and/or compiled dynamically loaded binaries Platform independent (mostly) Examples: perl, python, ruby, tcl/tk, lisp/scheme,... Embeddable interpreter (tcl, python, lisp): => script language for applications.

6 What is TCL? TCL = Tool Command Language Scripting language Embeddable interpreter Cross-platform (Unix, Windows, MacOS,...) Graphical toolkit companion: Tk Modeled after Unix shells (/bin/sh, /bin/csh) Designed to build extensible applications: Application embeds interpreter Compiled code interfaced to tcl commands High-level scripts can drive application

7 Basic TCL Syntax TCL syntax is very simple: command arg1 arg2 arg3... command can be an tcl internal command or a newly defined procedure Arguments can be grouped, expanded from variables or substituted from other commands Grouping is done via curly braces: { } Substitution is done via square brackets: [ ] Variables start with $ and are expanded when used directly or in strings defined via

8 Invoking TCL Using the standalone interpreter, tclsh: Works like a regular shell prompt Good for interactive testing No command line history and editing No VMD extensions (unless using VMD console) Writing a script file (hello.tcl) and giving it as argument to tclsh: tclsh hello.tcl Reading file interactively: source hello.tcl Using the Tk Console (-> Extensions menu) Flexible command line editing and history Syntax highlighting and completition

9 Simple Output in TCL Use the puts command to create output puts Hello, World! or: puts {Hello, World!} Newline is automatically appended unless: puts -nonewline {Hello, World!} Special control characters are only expanded in double-quotes: puts -nonewline Hello, World!\n or: puts -nonewline {Hello, World!\n} For more details: man n puts

10 Comments and Multi-line Commands in TCL puts "hello" ;# comment after the command. # comment at beginning of a line puts {bad syntax} # *Error* - no semicolon! puts "This is line 1"; puts "this is line 2" puts "Hello, World; - semicolon inside quotes" # No need to quote without white space: puts HelloWorld # no comments inside curly braces: puts {Hello ; # this will be printed World! } ; # but this will not be printed

11 Variables in TCL The set command assigns values to variables set hw {Hello, World!} Variables do not have to be declared Variables are local (unless declared as global) Expansion of variables with $: puts $hw puts hw is set to: $hw But no expansion with {}: puts {hw is set to: $hw} To remove a variable use: unset

12 More on Variables in TCL Accessing an unset variable is an error: % puts $a can't read "a": no such variable % set a 0 0 % puts $a 0 % unset a % puts $a can't read "a": no such variable

13 Command Substitution in TCL TCL commands in square brackets are executed and substituted by its output: % set x % set z [set y 876] 876 % puts "x: $x y: $y z: $z" x: 678 y: 876 z: 876 But: % puts "[set e 2.72]"; puts {[set p 3.41]} 2.72 [set p 3.41]

14 Computations with expr Use expr for mathematical expressions: % expr % set x 4 4 % expr 2 + $x 6 % expr {2 + $x} 6 Also substitution works: set y [expr 50*$x]

15 TCL Expressions A TCL expression consists of a combination of operands, operators, and parentheses. White space may be used between operands, operators and parentheses. Where possible, operands are interpreted as integer values. Integer values may be specified in decimal (the normal case), in octal (if the first character of the operand is 0), or in hexadecimal (if the first two characters of the operand are 0x)

16 More on TCL Expressions If an operand does not have one of the integer formats given above, then it is treated as a floating-point number, if that is possible. Floating-point numbers may be specified in ANSI-C syntax: E4 7.91e If no numeric interpretation is possible, then an operand is left as a string (and only a limited set of operators may be applied to it). Beware of leading zeros: 0700 is not 700

17 TCL Expression Operators TCL supports most typical operators: - + : (Unary minus, unary plus, not for strings) * / %: Multiply, divide, remainder. + - : Add and subtract. < > <= >=: Relational operators: Returns 1 if true, 0 otherwise. Compares numerical or lexical (for strings that cannot be converted) value. eq ne: compare strings for equality or inequality. Numbers are converted to strings first. expr { 9 == 9.0 }vs. expr { 9 eq 9.0 }

18 More TCL Expression Operators Tcl supports the following mathematical functions in expressions: abs cosh log sqrt acos log10 srand asin exp pow tan atan floor rand tanh atan2 fmod round ceil hypot sin cos sinh int The trigonometric functions work with radians: set pi6 [expr { /6.0}] puts "The sine and cosine of pi/6:\ [expr {sin($pi6)}] [expr {cos($pi6)}]"

19 Conditionals in TCL Like most languages, Tcl supports an if command. The syntax is: if {expr1} then {... } elseif {expr2} then {... } elseif {expr3} then {... } else {...} The words then and else are optional, elseif clauses are not required and also the else branch can be left away.

20 More on Conditionals The test expression following if or elseif should return a value that can be interpreted as representing "true" or "false": False True a numeric value: 0 all others yes/no: no yes true/false: false true If the test expression returns a string "yes"/"no" or "true"/"false", the case of the string is irrelevant (e.g. Yes, TRUE, FaLSe).

21 For Loops in TCL Tcl supports an iterated loop construct similar to the for loop in C or do loop in Fortran. The for command in Tcl takes four arguments; an initialization, a test, an increment, and the body of code to evaluate on each loop. Example: for {set i 0} {$i < 100} {incr i} { puts $i } incr increments the variable i by 1. Use an optional argument for other increments: incr i 5

22 New Commands in TCL In Tcl there is no distinction between commands (or functions) and "syntax". There are no reserved words (like if and while) as in C, Java, Python, Perl, etc... When Tcl starts up there is a list of known commands: if, for, set, puts, expr,... They are just regular Tcl commands, that obey the same syntax rules as all Tcl commands, both built-in, and those that you create yourself with the proc command.

23 Using proc in TCL The proc command creates a new command. Syntax: proc name {args} {body} When proc is evaluated, it creates a new command called name. If name already exists it will be overwritten! When the procedure name is called, it then runs the code contained in body. args is a list of arguments passed to name. When name is invoked, local variables with these names will be created.

24 More on Using proc The value that the body of a proc returns can be defined with the return command. Example: proc sum {arg1 arg2} { set x [expr {$arg1 + $arg2}]; return $x } puts " The sum is: [sum 2 3]\n\n" Arguments with defaults are optional: proc addsome {value {increment 1}} { return [expr $value + $increment]}

25 Variable Scope in TCL Variables in TCL are usually only valid within the level where they are created. Variables in commands are automatically destroyed when the command returns Variables created on a higher level are not visible within procedures defined within (the same goes for procedures created within procedures). Variables can be imported from the top level with the global command