TCL Language Fundamentals: Syntax and Core Commands

Variable Declaration and Output

In TCL, variables are declared using the set command. This declaration occurs automatically when needed, preventing errors from undeclared variables. However, commands like puts require variables to be declared first. In TCL, variables are essentially strings, and their values are accessed using the $ symbol. Variables must be declared before they can be accessed.

set counter 0
puts $counter
puts counter

Both puts commands will display output, but the first one outputs the value of the variable, while the second outputs the literal string "counter".

Expression Evaluation and Command Nesting

TCL commands have a fixed structure determined by keywords, with parameters separated by spaces. To nest commands within a parameter, you must use [ ] to define the scope of the nested command. The expr command evaluates arithmetic expressions and returns the result.

set value 0
set value [expr $value + 1]
puts $value

The final result is 1, as the second statement increments the value of value by 1.

Lists and Braces

Similar to command nesting, strings containing spaces or special characters need to be embedded in TCL. Using { } converts the enclosed content into a special string variable known as a list in TCL. When used as a parameter, the symbols within a list are controlled by the corresponding command rather than being interpreted by TCL itself. TCL provides numerous commands for list manipulation.

set data {1 2 3 {1 2} 2 {4 5}}
puts $data

The value of data is the list shown in the example.

Conditional Statements: if and elseif

TCL provides conditional statements similar to those in other programming languages:

if { $counter == 0 } {
    set counter 1
    puts $counter
} elseif { $counter == 1 } {
    set counter 2
    puts $counter
} elseif { $counter == 2 } {
    set counter 3
    puts $counter
} elseif { $counter < 11 } {
    set counter [expr $counter + 1]
    puts $counter
}

The syntax resembles C, with each parameter enclosed in { } and separated by spaces.

Loop Statements: while and for

TCL supports while and for loops with syntax similar to C:

while { $counter < 10 } {
    if { $counter == 0 } {
        set counter 1
        puts $counter
    } elseif { $counter == 1 } {
        set counter 2
        puts $counter
    } elseif { $counter == 2 } {
        set counter 3
        puts $counter
    } elseif { $counter < 11 } {
        set counter [expr $counter + 1]
        puts $counter
    }
}

for {
    set index 0
} { 
    $index < 10
} { 
    incr index 1
} { 
    puts "index=$index"
}

The while loop takes two parameters: the condition and the body. The for loop has four parameters: initialization, condition, increment, and body. These parameters correspond directly to their C language counterparts.

Foreach Loop

The foreach loop is a special construct for iterating over lists. It determines the iteration based on the list's length and elements. The body works similarly to other loops. The first parameter specifies the iteration variables, the second is the list to iterate over, and the third is the loop body.

set result " "
set elements {10 100 2300 {1} }
foreach element $elements {
    set result [linsert $result 0 $element]    
    puts $element
    puts $result
}

set output {}
foreach {key value} {a b c d e f} {
    lappend output $value $key
    puts "output=$output"
}

In the first foreach example, the iteration length is 1 (only element), the cache variable is element, and the list to iterate over is specified directly. The linsert command inserts elements into a list.

The second example uses a length of 2 with cache variables key and value, while maintaining the same structure.

Command Evaluation and File Inclusion

The eval command interprets strings as TCL commands. The source command executes external TCL files:

#!/bin/sh
# eval_example.tcl \
exec tclsh "$0" ${1+"$@"}
eval set result 2 ; set result 4
puts $result

set command "puts \"Hello, World! \""
eval $command

source "/path/to/script.tcl"

Here, command is declared as a string (similar to C, with attention to escape characters). The eval command can interpret strings as TCL commands, allowing execution of system commands. The source command directly executes external TCL files.