---

Command evaluation in TCL

---

• Evaluating commands in TCL

  • In Tcl, the execution of a command is called evaluating a command

  • The evaluation of a command is done in 2 phases:

    The first phase is a single pass of substitutions Only one pass of substitutions is made. The second phase is the evaluation of the resulting command

  • Example:

    Example statment: set x "Hello World" x = (Hello World) // The brackets ( ) is not present // and I used it to denote that // Hello World is considered // as one argument Now consider how the following Tcl command is evaluated: puts $x

    Evaluation: puts $x Phase 1: substitute the content of each variable ==> puts (Hello World) Phase 2: evaluate (execute) the resulting command ==> Hello World This is the result of the evaluation and is returned by the Tcl command (.e.g., result can be assigned to a variable)

  ---

  ---

• Phase 1: Substitution - rules of substition in TCL
  • You must follow Tcl substitution rules to understand Tcl.

    Keep in mind that the substitution takes place before the command is passed to the Tcl evaluation engine

  • Tcl performs substitution on the following types of expressions:

    $variableName      (variable substitution) " .... "                      (evaluating quote) { .... }                       (non-evaluating quote) [ .... ]                       (command evaluation)

  ---

  ---

  ---

  ---

• $variableName substitution
  • An expression that start with $ is evaluated (executed) as follows:

    $varName is replaced by the content that is assigned (set) to the variable name varName

  • Example:

    set x Hello puts $x Phase 1: substitute the content of each variable ==> puts Hello This is the actual Tcl command this will be executed

  ---

  ---

• The "Escape" character in Tcl

  • Sometimes, you want $ to mean an ordinary dollar sign

  • Using the backslash (\) will disables (prevent) substitution for the (single) character immediately following the backslash.

    puts \$x // Prints $x

    ---

  • You can also formulate a number of special characters with the backslash:
    • \a       Audible bell
    • \b       backspace
    • \f       Form feed (clear screen)
    • \n       New line
    • \r       Carriage return
    • \t       Horizontal tab
    • \v       Vertical tab

  ---

  ---

• Command line continuation
  • A Tcl command/statement is always contained on one line

    Error:

    puts "Hello World"

    ---

  • If a Tcl command/statement has multiple lines, then every line (except the last) must contain a command continuation character:

    When the backslash (\) character is the last character on a line, the Tcl command/statement is continued on the next line

    Example:

    puts \ "Hello World"

  ---

  ---

  ---

  ---

• " ... " (evaluating quote) substitution
  • The expression " ... " is evaluated (executed) as follows:

    Apply Tcl substitution rules to every item inside " ... " All items (after the substitution) in " ... " are considered as one single item

    Note:

    This is kinda like a compound statement in C++ or Java where you "consider" multiple statements between braces { ... } as one single statement.

    ---

  • Examples:

    puts Hello World // Error, "puts" takes only 1 argument // There are two argements in the command // NOTE: puts with 2 argument will write // output to an output file !! // So you will get an "unexpected error": // can not find channel named "Hello" puts "Hello World" // Correct, prints "Hello World" // // Substitution goes as follows: // "Hello World" --> (Hello World) // (...) denotes the fact that Tcl considers // all words between (...) as one argument // // ++ puts receives as input: (Hello World) set x World puts Hello $x // Error, puts take 1 argument set x World puts "Hello $x" // Correct, prints "Hello World" // Substitution goes as follows: // // "Hello $x" --> "Hello World" // --> (Hello World) // (...) denotes the fact that Tcl considers // all words between (...) as one argument // // ++ puts receives as input: (Hello World)

  ---

  ---

  ---

  ---

• { ... } (braced) substitution
  • The expression { ... } is evaluated (executed) as follows:

    No substitutions are applied to any item inside { ... } All words (verbatim) in { ... } are considered as one single item

    Note:

    Every characters inside { ... } will be unsubstitued (i.e., verbatim). Items between { ... } are "what-you-see-is-what-you-get !!!

    Example:

    set x ABC puts {$x} // prints: $x // Reason: // {$x} --> (no substitution) --> $x // puts receives $x and will print $x Compare to: puts $x // prints: ABC puts "$x" // prints: ABC

    ---

    ---

  • Special character in {...}:

    There is one special character in { ... }... When the last character of the line is a backslash (\), it is (still) interpreted as the line continuation character.

    Example:

    set x ABC puts {Hello \ $x} // prints: Hello $x \ still means: continue line

  ---

  ---

• Line continuation effect of {.....}
  • Normal Tcl behavior:

    The end-of-line ends a Tcl command (Hence: one Tcl command on one line You need to use \ as the last character to indicate continuation

    ---

  • Effect within {......}:

    The end-of-line character is interpreted as \n

    Example:

    set x { Hello World } puts $x Hello World

    ---

  • NOTE: the opening brace { must appear on the line of the command

    (Or else the Tcl interpreter cannot detect opening brace { and think the line has ended and give you a syntax error !)

  • Example:

    Correct: set x { Hello World } Incorrect: set x { Hello World }

    (BTW, I hate this requirement...)

  ---

  ---

• { or } appears inside a quote string:     "...{...",     "...}...",     "..{...}...", etc
  • A brace character { or } can appeared inside a quoted string:

    Examples:

    "foo{bar" "foo{b}ar"

    A brace character { or } inside a quoted string is treated as an a regular character with no special meaning.

    ---

  • Because braces { and } are treated as a regular character inside a inside a quoted string, substitution will occur within the quoted string, even between the braces !!

  • Example:

    set x ABC puts "foo{$x" // Output: foo{ABC puts "foo{$x}" // Output: foo{ABC}

  ---

  ---

• A quote character " appears inside a braced string:     {..."...},     {..."..."....}, etc
  • The quote character " can appeared inside a braced string:

    Examples:

    {foo"bar} {foo"b"ar}

    A quote character " inside a braced string is treated as an a regular character with no special meaning.

    ---

  • Effect:

    Substitutions will not occur within the string grouped with braces {...}

    ---

  • Examples:

    set x ABC puts {foo"$x"} // Output: foo"$x"

  ---

  ---

• Further examples (for your eyes only) - skipped in class
  • Try to predict what each of the following puts will print:

    set Z Albany set Z_LABEL "The Capitol of New York is: " puts "\n................. examples of differences between \" and \{" ................. examples of differences between " and { puts "$Z_LABEL $Z" The Capitol of New York is: Albany puts {$Z_LABEL $Z} $Z_LABEL $Z puts "\n....... examples of differences in nesting \{ and \" " ....... examples of differences in nesting { and " puts "$Z_LABEL {$Z}" The Capitol of New York is: {Albany} puts {Who said, "What this country needs is a good $0.05 cigar!"?} Who said, "What this country needs is a good $0.05 cigar!"? puts "\n................. examples of escape strings" ................. examples of escape strings puts {There are no substitutions done within braces \n \r \x0a \f \v} There are no substitutions done within braces \n \r \x0a \f \v puts {But, the escaped newline at the end of a\ string is still evaluated as a space} But, the escaped newline at the end of a string is still evaluated as a space

  ---

  ---

• [....] substitution (command execution)

  • A command within square brackets ( [...]) is replaced with the result of the execution of that command.

    ---

  • The expression:

    [cmd arguments]

    will:

    Evaluate (execute) the Tcl command cmd arguments (You must apply everything you learned from above to evaluate this command) The result returned by the evaluation (executiuon) will replace the expression [cmd arguments]

    ---

  • Example:

    The command: expr {3 + 4} // will returns: 3 + 4 = 7 Then: puts [expr {3 + 4}] // Outputs: 7 // NOTE: // Puts receives 7, NOT [expr {3 + 4}] !! Compare: puts {[expr {3 + 4}]} // Outputs: [expr {3 + 4}]

  ---

  ---

• Further reading
  • Evaluation & Substitutions 1: Grouping arguments with "" click here
  • Evaluation & Substitutions 2: Grouping arguments with {} click here
  • Evaluation & Substitutions 3: Grouping arguments with [] click here