Introducing Tcl

Writing Your First Tcl Script

In Chapter 24, you learned how to write shell scripts and Perl scripts. You write Tcl scripts the same way. Unlike Perl, Tcl includes a shell-an interactive interpreter of Tcl commands. The Tcl shell program's name is tclsh; it should be in the /usr/bin directory.

When you log in, the PATH environment variable should include the /usr/bin directory. Thus, you can start the Tcl shell by typing tclsh at a text console or in a terminal window in GNOME or KDE. A percent sign (%) appears on the next line; this is the Tcl shell program's prompt. To see which version of Tcl you have, type info tclversion at the Tcl shell prompt. The Tcl shell program responds by printing the version of Tcl. Here is an example of how you interact with the Tcl shell:

tclsh
% info tclversion
8.3
%

Now you can interactively try the following Tcl program, which prints Hello, World! on the standard output (the display screen or the terminal window):

% puts "Hello, World!"
Hello, World!
% exit

Type exit to quit the Tcl shell.

The Tcl shell immediately processes the Tcl command you enter and displays the results, then it prompts you for the next input. At this point, you can type exit to quit the Tcl shell (tclsh).

To prepare and run a Tcl script, follow these steps:

1. Use a text editor to enter and save the following lines in a file named hellotcl (this file will be the Tcl script):

   #!/usr/bin/tclsh
   # A simple Tcl script
   puts "Hello, World!"

2. Type the following command at the shell prompt to make the hellotcl file executable (that's what the +x in the chmod command means):

   chmod +x hellotcl

3. To run the hellotcl script, type the following at the shell prompt:

   ./hellotcl
   Hello, World!

Use these basic steps to create and run any Tcl script. You still have to learn the nuances of Tcl syntax, of course-as well as many rules. This section gets you started with an overview of Tcl.

Getting More Information on Tcl/Tk

This chapter provides an overview of Tcl and Tk, highlights many key points, and shows simple examples. However, there isn't enough room in this chapter to list all the information you need to fully exploit the power of Tcl and Tk. Because of Tcl/Tk's popularity, you can find quite a few resources about it, ranging from books to Internet sites. Following is a short list of Tcl/Tk resources:

• Books -Two prominent books on Tcl/Tk are available. The first book is Tcl and the Tk Toolkit (Addison Wesley 1994) by John K. Ousterhout, the originator of Tcl and Tk. John's book provides a broad overview of Tcl and Tk, including an explanation of the way that Tcl command strings are parsed. The other book is Practical Programming in Tcl and Tk, Third Edition (Prentice Hall 2000) by Brent B. Welch. This book provides more Tcl and Tk examples.

• Internet resources-Several FTP and websites contain the latest Tcl/Tk distributions and information about Tcl/Tk development. Following are the URLs for a few key sites:

  • ftp://ftp.scriptics.com/pub/tcl/-(Tcl/Tk master distribution site)

  • http://www.scriptics.com/-(Tcl developer site)

  • http://www.neosoft.com/tcl/-(Tcl/Tk contributed sources archive)

Getting an Overview of Tcl

True to its name (Tool Command Language), Tcl consists of a set of commands you can combine according to a set of rules. To write Tcl scripts, you have to understand two broad subjects:

• Tcl syntax-Tcl syntax is the set of rules the Tcl command interpreter follows when it interprets a command string (a line that contains a command and its arguments).

• Tcl commands-Although the syntax is the same for all commands, each Tcl command is meant to perform a specific task. To exploit Tcl fully, you have to know what commands are available and what each command does. The Tcl command set can be extended by applications. In fact, Tk itself is an extension of Tcl; Tk adds commands that manipulate components of GUIs.

Start by learning the Tcl syntax, a handful of rules that determine the way each Tcl command is parsed. Because Tcl has many commands, learning all of them can take a while. Even after you become proficient in the Tcl syntax and a small set of commands, you may need to keep a reference manual nearby so that you can check the exact format of the arguments that each command requires.

Tcl commands include the following basic programming facilities that you expect from any programming language:

• Variables, which store data. Each variable has a name and a value. Tcl also allows you to define arrays of variables.

• Expressions, which combine values of variables with operators. An expression might add two variables, for example. Tcl uses the expr command to evaluate expressions.

• Control-flow commands, which enable commands to be executed in various orders, depending on the value of some expression. Tcl provides commands such as for, foreach, break, continue, if, while, and return to implement flow control in Tcl scripts.

• Procedures, which enable you to group several commands and give them a name. Procedures also accept arguments. Tcl provides the proc command to enable you to define procedures. You can use a procedure to execute the same set of commands (usually with different arguments) by invoking the procedure that represents those commands.

The next few sections provide an overview of the Tcl syntax and the core Tcl commands.

Learning the Basic Tcl Syntax

To understand the basic Tcl syntax, you have to know a bit about how the Tcl interpreter processes each command string. The steps are as follows:

1. The Tcl interpreter parses (breaks down) the command string into words-the constituent parts, including variables and operators.

2. The Tcl interpreter applies rules to substitute the values of variables and replace certain commands with their results.

3. The Tcl interpreter executes the commands, taking the first word as the command name and calling a command procedure to execute the command. The command procedure receives the rest of the words as strings.

When writing Tcl command strings, you have to use white space (a space or a tab) to separate a command's name from its arguments. A newline or a semicolon (;) marks the end of a command string. You can put two commands on the same line if you insert a semicolon after the first command. Thus, you can use the following:

% puts Hello, ; puts World!
Hello,
World!

The resulting output appears on separate lines because the puts command adds a newline by default.

Use a backslash (\) at the end of a line to continue that command string on the next line (this is a standard convention in UNIX). Thus, you can write a command string to print Hello, World! as follows:

puts "Hello, \
World!"

set count 100

puts $count

puts 100

% puts "Hello, World!" # This is a comment
wrong # args: should be "puts ?-nonewline? ?channelId? string"
%

% puts "Hello, World!" ;# This is a comment
Hello, World!

% puts "Hello, World!"
Hello, World!
% puts "Enter 1; otherwise file won't be saved!"
Enter 1; otherwise file won't be saved!

% puts "There are [string length hello] characters in 'hello'"
There are 5 characters in 'hello'

% puts {There are [string length hello] characters in 'hello'}
There are [string length hello] characters in 'hello'

Understanding Tcl Variables

Everything is a string in Tcl. Variable names, as well as values, are stored as strings. To define a variable, use the built-in Tcl command set. The following commands, for example, define the variable book as "Red Hat Linux Professional Secrets"; the variable year as 2003; and the variable price as $49.99:

set book "Red Hat Linux Professional Secrets"
set year 2003
set price \$49.99

To refer to the value of a variable, add a dollar sign ($) prefix to the variable's name. Therefore, to print the variable book, use the following format:

% puts $book
Red Hat Linux Professional Secrets

If you use set with a single argument, set returns the value of that argument. Thus, set book is equivalent to $book, as the following example shows:

% puts [set book]
Red Hat Linux Professional Secrets

Writing Expressions

You can write expressions by combining variables with mathematical operators, such as + (add), - (subtract), * (multiply), and / (divide). Here are some examples of expressions:

set count 1
$count+1
$count + 5 - 2
2 + 3.5

You can use numbers, as well as variable names, in expressions. Use white space to enhance readability. Use parentheses to specify how you want an expression to be evaluated.

In addition to the basic mathematical operators, Tcl includes several built-in mathematical functions, such as sin, cos, tan, log, and sqrt. Call these functions just as you do in C, with arguments in parentheses, as follows:

set angle 1.5
2*sin($angle)

In addition, you can use Boolean operators, such as ! (not), && (and), and || (or). Comparison operators-such as < (less than), > (greater than), <= (less than or equal to), == (equal to), and != (not equal to)-also are available. Expressions that use Boolean or comparison operators evaluate to 1 if true and 0 if false. You can write expressions, such as the following:

count == 10
angle < 3.1415

Expressions are not commands by themselves. You can use expressions as arguments only for commands that accept expressions as arguments. The if and while commands, for example, expect expressions as arguments.

Tcl also provides the expr command to evaluate an expression. The following example shows how you might evaluate an expression in a Tcl command:

% set angle 1.5
1.5
% puts "Result = [expr 2*sin($angle)]"
Result = 1.99498997321

Although Tcl stores everything as a string, you have to use numbers where numbers are expected. If book is defined as "Red Hat Linux Professional Secrets", for example, you cannot write an expression $book+1, because it does not make sense.

Using Control-Flow Commands in Tcl

Tcl's control-flow commands enable you to specify the order in which the Tcl interpreter executes commands. You can use the if command to test the value of an expression; and if the value is true (nonzero), you can make the interpreter execute a set of commands. Tcl includes control-flow commands similar to those in C, such as if, for, while, and switch. This section provides an overview of the control-flow commands.

Secret

A Tcl control-flow command typically has a command block (a group of commands) that the control-flow command executes after evaluating an expression. To avoid substitutions (such as replacing variables with their values), you must enclose the entire command block in braces. The following if-else control-flow commands illustrate the style of braces that works properly:

 if { expression } {
 # Commands to execute when expression is true
   command_1
   command_2
} else {
 # Commands to execute when expression is false
 # ...
}

You should follow this style of braces religiously in Tcl scripts. In particular, remember to include a space between the control-flow command (such as if) and the left brace ({) that follows the command.

if { $errorCount > 25 } {
    puts "Too many errors!"
}

if { $user == "root" } {
    puts "Starting system setup ..."
} else {
    puts "Sorry, you must be \"root\" to run this program!"
}

puts -nonewline "Enter version number: "  ;# Prompt user
set version [gets stdin]                  ;# Read version number

if { $version >= 10 } {
   puts "No upgrade necessary"
} elseif { $version >= 6 && $version < 9} {
   puts "Standard upgrade"
} elseif { $version >= 3 && $version < 6} {
    puts "Reinstall"
} else {
    puts "Sorry, cannot upgrade"
}

while { [gets stdin line]  != -1 } {
    puts $line
# Do whatever you need to do with $line.
}

#!/usr/bin/tclsh

set i 0
set sum 0

while { 1 } {
    incr i                     ;# Increment i
    if {$i == 5} { continue }  ;# Skip if i is 5
    if {$i > 10} {break }      ;# End loop if i exceeds 10
    set sum [expr $sum+$i]     ;# Otherwise, add i to sum
}
puts "Sum = $sum";

Sum = 50

for {expr1} { expr2} { expr3} {
    commands
}

#!/usr/bin/tclsh
for {set i 0; set sum 0} {$i <= 10} {set sum [expr $sum+$i]; incr i} {
}
puts "Sum = $sum";

Sum = 55

set sum 0
foreach i { 1 2 3 4 5 6 7 8 9 10} {
    set sum [expr $sum+$i]
}
puts "Sum = $sum"

set users "root naba"
foreach user $users {
    puts "$user"
}

Using the switch Command

Tcl's switch command is different from C's switch statement. Instead of evaluating a mathematical expression, Tcl's switch command compares a string with a set of patterns and executes a set of commands, depending on which pattern matches. Often, the pattern is expressed in terms of a regular expression.

Cross Ref

See Chapter 24 for an introduction to regular expressions.

The following script illustrates the syntax and a typical use of the switch command:

#!/usr/bin/tclsh
# This script reads commands from the user and processes
# the commands using a switch statement.

set prompt "Enter command (\"quit\" to exit): "

puts -nonewline "$prompt"; flush stdout

while { [gets stdin cmd]  != -1 } {
    switch -exact -- $cmd {
        quit    { puts "Bye!"; exit}
        start   { puts "Started"}
        stop    { puts "Stopped"}
        draw    { puts "Draw.."}
        default { puts "Unknown command: $cmd" }
    }
# Prompt user again
    puts -nonewline $prompt; flush stdout
}

Following is a sample session with this script (user input is in boldface):

Enter command ("quit" to exit): help
Unknown command: help
Enter command ("quit" to exit): start
Started
Enter command ("quit" to exit): stop
Stopped
Enter command ("quit" to exit): quit
Bye!

As this example shows, the switch statement enables you to compare a string with a set of other strings and to activate a set of commands, depending on which pattern matches. In this example, the string is $cmd (which is initialized by reading the user's input with a gets command), and the patterns are literal strings: quit, start, stop, and draw.

Secret

When you want the switch statement to compare a string with a set of other strings and look for an exact match, use the -exact flag on the first line of the switch command, as follows:

switch -exact -- $cmd {
 ...
}

The two hyphens (-) immediately after the -exact flag mark the end of the flags. When you use the switch command, you should always use the double hyphens at the end of the flag to prevent the test string (in this example, the test string is $cmd) from matching a flag inadvertently.

You can use the switch command with the -regexp flag to compare a string with a regular expression, as in the following example:

# Assume that $cmd is the string to be matched.

switch -regexp -- $cmd {
    ^q.*     { puts "Bye!"; exit}
    ^x.*   { puts "Something x..."}
    ^y.*   { puts "Something y..."}
    ^z.*   { puts "Something z..."}
    default { puts "Unknown command: $cmd" }
}

In this example, each regular expression has a similar form. The pattern ^z.* means any string that starts with a single z, followed by any number of other characters.

Writing Tcl Procedures

You can use the proc command to add your own commands. Such commands are called procedures; the Tcl interpreter treats them just as though they were built-in Tcl commands. The following example shows how easy it is to write a procedure in Tcl:

#!/usr/bin/tclsh

proc total items {
    set sum 0
    foreach i $items {
        set sum [expr $sum+$i]
    }
    return $sum
}

set counts "5 4 3 5"
puts "Total = [total $counts]"

When you run the preceding script, it prints the following:

Total = 17

In this example, the procedure's name is total, and it takes a list of numbers as the argument. The procedure receives the arguments in the variable named items. The body of the procedure extracts each item and returns a sum of the items. Thus, to add numbers from 1 to 10, you have to call the total procedure as follows:

set sum1_10 [total {1 2 3 4 5 6 7 8 9 10}]

Secret

In a Tcl procedure, the argument name args has special significance; if you use args as the argument name, you can pass a variable number of arguments to the procedure. For example, write the total procedure with the argument name as args, as follows:

proc total args {
    set sum 0
    foreach i $args {
        set sum [expr $sum+$i]
    }
    return $sum
}

Now, you can call total in the following manner:

set sum1_10 [total 1 2 3 4 5 6 7 8 9 10]   ;# Variable arguments

This should set sum1_10 to the sum of the numbers from 1 through 10.

If you want to access a global variable (a variable defined outside a procedure) in the Tcl procedure, you have to use the global command inside the procedure. The global command makes a global variable visible within the scope of a procedure. If a variable named theCanvas holds the current drawing area in a Tk (Tcl's X toolkit) program, a procedure that uses theCanvas must include the following command:

global theCanvas

Taking Stock of Built-in Tcl Commands

You have seen many Tcl commands in the preceding examples. Knowing the types of commands that are available in Tcl helps you decide which commands are most appropriate for the task at hand. Although this chapter does not have enough room to cover all Tcl commands, Table 25-2 summarizes Tcl's built-in commands.

Manipulating Strings in Tcl

If you browse through the Tcl commands listed in Table 25-2, you find quite a few-such as append, join, split, string, regexp, and regsub-that operate on strings. This section summarizes a few string-manipulation commands.

Secret

When you set a variable to a string, the Tcl interpreter considers that string to be a single entity, even if that string contains embedded spaces or special characters. Sometimes you need to access the string as a list of items. The split command is a handy way to separate a string into its components. The lines in the /etc/passwd file, for example, look like the following:

root:x:0:0:root:/root:/bin/bash

The line is composed of fields separated by colons (:). Suppose that you want to extract the first field from each line (because that field contains the login name). You can read the file one line at a time, split each line into a list, and extract the first element (the item at index 0) of each list. Following is a Tcl script that does this:

#!/usr/bin/tclsh

set fid [open "/etc/passwd" r]    ;# Open file for read-only access

while { [gets $fid line] != -1 } {
    set fields [split $line ":"]  ;# Split the string into a list
# Just print out the first field
    puts [lindex $fields 0]       ;# Extract item at a index 0
}

When you run this script, it prints all the login names from your system's /etc/ passwd file.

The join command is the opposite of split; you can use it to create a single string from the items in a list. Suppose that you have a list of six items, defined as follows:

set x {1 2 3 4 5 6}

When you join the elements, you can select what character you want to use between fields. To join the elements without anything in between them, use the following format:

set y [join $x ""]

Now the y string is "123456".

The string command is a group of commands for working with strings; the first argument of string specifies the operation to be performed. The string compare command, for example, compares two strings, returning zero when the two strings are identical. A return value of -1 indicates that the first string argument is lexicographically less than the second one, which means it appears before the second one in a dictionary. Similarly, a 1 return value indicates that the first string is lexicographically greater than the second one. Thus, you might use string compare in an if command as follows:

if { [string compare $command "quit"] == 0} {
    puts "Exiting..."
    exit 0
}

Table 25-3 lists the