Version 8 of An Introduction to Tcl Scripting

Updated 2004-07-13 07:14:13 by RJM

An Introduction To Tcl Scripting John Ousterhout

Tcl/Tk Tutorial, Part II Language Overview


Two parts to learning Tcl:

  1. Syntax and substitution rules:
      - Substitutions simple, but may be confusing at first.
  1. Built-in commands:
      - Can learn individually as needed.
      - Control structures are commands, not language syntax.

Basics

  • 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 a 22; set b 33
      - set a 22
        set b 33

Division Of Responsibility

The Tcl Parser

  • Chops commands into words.
  • Makes substitutions.
  • Does not interpret values of words.

The Command Procedure

  • Interprets words.
  • Produces string result.

Arguments

  • Parser assigns no meaning to arguments (quoting by default, evaluation is special):
C
x = 4; y = x+10
   Result: y is 14

   Tcl: set x 4; set y x+10
   Result: y is "x+10"
  • Different commands assign different meanings to their arguments:
      set a 122
      expr 24/3.2
      eval "set a 122"
      button .b -text Hello -fg red
      string length Abracadabra

Variable Substitution

  • Syntax: $varName
  • Variable name is letters, digits, underscores.
  • 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  66+66+66
                set a $b.3      66.3
                set 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                         8
                set a [expr $b+2]               10
                set 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 "x is $x; y is $y"

      - Curly braces prevent breaks and substitutions:
        set a {[expr $b*$c]}

      - Backslashes quote special characters:
        set a word\ with\ \$\ and\ space
  • Substitutions don't change word structure:
        set a "two words"
        set b $a

Expressions

  • C-like (int and double), extra support for string operations.
  • Command, variable substitution occurs within expressions.
  • Used in expr, other commands.
                Sample command          Result

                set b 5                 5
                expr ($b*4) - 3         17
                expr $b <= 2            0
                expr $a * cos(2*$b)     -5.03443
                expr {$b * [fac 4]}     120
                set a Bill              Bill
                expr {$a < "Anne"}      0

Lists

  • Zero or more elements separated by white space:
        red green blue
  • Braces and backslashes for grouping:
        a b {c d e} f
        one\ word two three
  • List-related commands:
        concat         lindex  llength lsearch
        foreach        linsert lrange  lsort
        lappend        list    lreplace
  • Examples:
        lindex {a b {c d e} f} 2        -> c d e
        lsort {red green blue}          -> blue green red

Control Structures

  • C-like appearance.
  • Just commands that take Tcl scripts as arguments.
  • Example: list reversal.
        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

Procedures

  • proc command defines a procedure:
        proc sub1 x {expr $x-1}
             ^    ^      ^
             |    |      |
           name   |      |--------|
        list of argument names    |
                                body
  • Procedures behave just like built-in commands:
        sub1 3 -> 2
  • Arguments can have defaults:
        proc decr {x {y 1}} {
                expr $x-$y
        }
  • Scoping: local and global variables.
  • 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

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

Advanced Error Handling

  • Can intercept errors:
        catch {expr {2 +}} msg
        ->  1
        set msg
        ->  syntax error in expression "2 +"
  • Can generate errors:
        error "bad argument"
  • Global variable errorCode holds machine-readable information about errors
 (e.g. UNIX errno value).

Additional Tcl Features:

  • String manipulation commands:
        regexp format  split   string
        regsub scan    join
  • File I/O commands:
        open   gets    seek    flush   glob
        close  read    tell    cd
        puts   source  eof     pwd
  • Subprocesses with exec command:
        exec grep foo << $input | wc
  • Associative arrays:
        set x(fred) 44
        set x(2) [expr $x(fred) + 6]
        array names x
        ->  fred 2
  • Variable scoping:
        global uplevel upvar
  • Access to Tcl internals:
        info   rename  trace
  • Autoloading:
      - unknown procedure invoked when command doesn't exist.
      - Loads procedures on demand from libraries.
      - Uses search path of directories.
  • Additional features:
      - Dynamic loading of binaries: load command.
      - Security: Safe-Tcl.
      - Event-driven I/O.
      - Socket support.

More On Substitutions

  • Keep substitutions simple: use commands like format for complex arguments.
  • Use eval for another level of expansion:
        exec rm *.o
        ->  *.o: No such file or directory
        glob *.o
        ->  a.o b.o
        exec rm [glob *.o]
        ->  a.o b.o: No such file or directory
        eval exec rm [glob *.o]

----Commands And Lists: Tcl Quoting

  • Lists parse cleanly as commands: each element becomes one word.

Commands And Lists: Quoting Hell

  • Lists parse cleanly as commands: each element becomes one word.
  • To create commands safely, use list commands:
        button .b -text Reset -command {set x $initValue}
        (initValue read when button invoked)
        ... -command "set x $initValue"
        (fails if initValue is "New York": command is "set x New York")
        ... -command "set x {$initValue}"
        (fails if initValue is "{": command is "set x {{}")
        ... -command [list set x $initValue]
        (always works: if initValue is "{" command is "set x \{")

Tcl Syntax Summary

  • Script = commands separated by newlines or semicolons.
  • Script = commands separated by newlines or semicolons.
  • Command = words separated by white space.
  • $ causes variable substitution.
  • causes command substitution.
  • "" quotes white space and semi-colons.
  • {} quotes all special characters.
  • \ quotes next character, provides C-like substitutions.
  • # for comments (must be at beginning of command).


An Overview of Tcl and Tk - Building User Interfaces with Tcl and Tk - Writing Tcl-Based Applications in C


Category Tutorial