Tcl Basics






Tcl Basics

Part I introduces the basics of Tcl. Everyone should read Chapter 1, which describes the fundamental properties of the language. Tcl is really quite simple, so beginners can pick it up quickly. The experienced programmer should review Chapter 1 to eliminate any misconceptions that come from using other languages. Chapter 2 is a short introduction to running Tcl and Tk on UNIX, Windows, and Macintosh systems. You may want to look at this chapter first so you can try out the examples as you read Chapter 1. Chapter 3 presents a sample application, a CGI script, that implements a guestbook for a Web site. The example uses several facilities that are described in detail in later chapters. The goal is to provide a working example that illustrates the power of Tcl. The rest of Part covers basic programming with Tcl. Simple string processing is covered in Chapter 4. Tcl lists, which share the syntax rules of Tcl commands, are explained in Chapter 5. Control structure like loops and if statements are described in Chapter 6. Chapter 7 describes Tcl procedures, which are new commands that you write in Tcl. Chapter 8 discusses Tcl arrays. Arrays are the most flexible and useful data structure in Tcl. Chapter 9 describes file I/O and running other programs. These facilities let you build Tcl scripts that glue together other programs and process data in files. After reading Part I you will know enough Tcl to read and understand other Tcl programs, and to write simple programs yourself.













I. Tcl Basics

Tcl Fundamentals


This chapter describes the basic syntax rules for the Tcl scripting language. It describes the basic mechanisms used by the Tcl interpreter: substitution and grouping. It touches lightly on the following Tcl commands: puts, format, set, expr, string, while, incr, and proc.

is a string-based command language. The language has only a few fundamental constructs and relatively little syntax, which makes it easy to learn. The Tcl syntax is meant to be simple. Tcl is designed to be a glue that assembles software building blocks into applications. A simpler glue makes the job easier. In addition, Tcl is interpreted when the application runs. The interpreter makes it easy to build and refine your application in an interactive manner. A great way to learn Tcl is to try out commands interactively. If you are not sure how to run Tcl on your system, see Chapter 2 for instructions for starting Tcl on UNIX, Windows, and Macintosh systems. This chapter takes you through the basics of the Tcl language syntax. Even if you are an expert programmer, it is worth taking the time to read these few pages to make sure you understand the fundamentals of Tcl. The basic mechanisms are all related to strings and string substitutions, so it is fairly easy to visualize what is going on in the interpreter. The model is a little different from some other programming languages with which you may already be familiar, so it is worth making sure you understand the basic concepts.


Tcl Commands
Tcl stands for Tool Command Language. A command does something for you, like output a string, compute a math expression, or display a widget on the screen. Tcl casts everything into the mold of a command, even programming constructs


Tcl Fundamentals

Chap. 1

like variable assignment and procedure definition. Tcl adds a tiny amount of syntax needed to properly invoke commands, and then it leaves all the hard work up to the command implementation. The basic syntax for a Tcl command is:
command arg1 arg2 arg3 ...

The command is either the name of a built-in command or a Tcl procedure. White space (i.e., spaces or tabs) is used to separate the command name and its arguments, and a newline (i.e., the end of line character) or semicolon is used to terminate a command. Tcl does not interpret the arguments to the commands except to perform grouping, which allows multiple words in one argument, and substitution, which is used with programming variables and nested command calls. The behavior of the Tcl command processor can be summarized in three basic steps: • Argument grouping. • Value substitution of nested commands, variables, and backslash escapes. • Command invocation. It is up to the command to interpret its arguments. This model is described in detail in this Chapter.

Hello, World!
Example 1–1 The “Hello, World!” example.

puts stdout {Hello, World!} => Hello, World!

In this example, the command is puts, which takes two arguments: an I/O stream identifier and a string. puts writes the string to the I/O stream along with a trailing newline character. There are two points to emphasize: • Arguments are interpreted by the command. In the example, stdout is used to identify the standard output stream. The use of stdout as a name is a convention employed by puts and the other I/O commands. Also, stderr is used to identify the standard error output, and stdin is used to identify the standard input. Chapter 9 describes how to open other files for I/O. • Curly braces are used to group words together into a single argument. The puts command receives Hello, World! as its second argument. The braces are not part of the value. The braces are syntax for the interpreter, and they get stripped off before the value is passed to the command. Braces group all characters, including newlines and nested braces, until a matching brace is found. Tcl also uses double quotes for grouping. Grouping arguments will be described in more detail later.



I. Tcl Basics

The set command is used to assign a value to a variable. It takes two arguments: The first is the name of the variable, and the second is the value. Variable names can be any length, and case is significant. In fact, you can use any character in a variable name. It is not necessary to declare Tcl variables before you use them. The interpreter will create the variable when it is first assigned a value. The value of a variable is obtained later with the dollar-sign syntax, illustrated in Example 1–2:
Example 1–2 Tcl variables.

set var 5 => 5 set b $var => 5

The second set command assigns to variable b the value of variable var. The use of the dollar sign is our first example of substitution. You can imagine that the second set command gets rewritten by substituting the value of var for $var to obtain a new command.
set b 5

The actual implementation of substitution is more efficient, which is important when the value is large.

Command Substitution
The second form of substitution is command substitution. A nested command is delimited by square brackets, [ ]. The Tcl interpreter takes everything between the brackets and evaluates it as a command. It rewrites the outer command by replacing the square brackets and everything between them with the result of the nested command. This is similar to the use of backquotes in other shells, except that it has the additional advantage of supporting arbitrary nesting of commands.
Example 1–3 Command substitution.

set len [string length foobar] => 6

In Example 1–3, the nested command is:
string length foobar

This command returns the length of the string foobar. The string command is described in detail starting on page 45. The nested command runs first.


Tcl Fundamentals

Chap. 1

Then, command substitution causes the outer command to be rewritten as if it were:
set len 6

If there are several cases of command substitution within a single command, the interpreter processes them from left to right. As each right bracket is encountered, the command it delimits is evaluated. This results in a sensible ordering in which nested commands are evaluated first so that their result can be used in arguments to the outer command.

Math Expressions
The Tcl interpreter itself does not evaluate math expressions. Tcl just does grouping, substitutions and command invocations. The expr command is used to parse and evaluate math expressions.
Example 1–4 Simple arithmetic.

expr 7.2 / 4 => 1.8

The math syntax supported by expr is the same as the C expression syntax. The expr command deals with integer, floating point, and boolean values. Logical operations return either 0 (false) or 1 (true). Integer values are promoted to floating point values as needed. Octal values are indicated by a leading zero (e.g., 033 is 27 decimal). Hexadecimal values are indicated by a leading 0x. Scientific notation for floating point numbers is supported. A summary of the operator precedence is given on page 20. You can include variable references and nested commands in math expressions. The following example uses expr to add the value of x to the length of the string foobar. As a result of the innermost command substitution, the expr command sees 6 + 7, and len gets the value 13:
Example 1–5 Nested commands.

set x 7 set len [expr [string length foobar] + $x] => 13

The expression evaluator supports a number of built-in math functions. (For a complete listing, see page 21.) Example 1–6 computes the value of pi:
Example 1–6 Built-in math functions.

set pi [expr 2*asin(1.0)] => 3.1415926535897931

In the example. you should be aware that these expressions are all valid and run a bit faster than the examples shown above: Example 1–7 Grouping expressions with braces. there is probably a simpler way to achieve the effect you are striving for. you do not have to worry about the value of variables until you use eval. expr {7. In particular. The second set command in the example illustrates an important property of Tcl.0)}] Backslash Substitution The final type of substitution done by the Tcl interpreter is backslash substitution. In general. you can make expr operate more efficiently by grouping the entire expression in curly braces. Tcl Basics The implementation of expr is careful to preserve accurate numeric values and avoid conversions between numbers and strings. However. For now. or octal value: set escape \u001b set escape \0x1b set escape \033 The value of variable escape is the ASCII ESC character. . For example. you can specify a literal dollar sign. the value of x and dollar is the string $foo. which has character code 27. As a rule. which is described in Chapter 10. The explanation has to do with the byte code compiler that Tcl uses internally. however. and its effects are explained in more detail on page 15. set dollar \$foo => $foo set x $dollar => $foo Only a single round of interpretation is done.2 / 4} set len [expr {[string length foobar] + $x}] set pi [expr {2*asin(1. The table on page 20 summarizes backslash substitutions. This is used to quote characters that have special meaning to the interpreter. In Example 1–8 backslash is used to get a literal $: Example 1–8 Quoting special characters with backslash. the Tcl parser does not care about the value of a variable when it does the substitution. or bracket by quoting it with a backslash. the list command described on page 61 will do quoting for you automatically. The value of dollar does not affect the substitution performed in the assignment to x.Backslash Substitution 7 I. hexadecimal. brace. In other words. if you find yourself using lots of backslashes. You can also use backslash sequences to specify characters with their Unicode.

\n for newline and \t for tab). otherwise the expr command gets terminated by the newline after the plus sign. and spaces. This rule applies to command. This is necessary because a newline terminates a command. Grouping with Braces and Double Quotes Double quotes and curly braces are used to group words together into one argument. so the string is printed as is. grouping with curly braces is used when substitutions on the argument must be delayed until a later time (or never done at all). the newlines are automatically part of the group and do not terminate the command. length of $s is [string length $s]. if you are grouping an argument as described in the next section.8 Tcl Fundamentals Chap. The first argument to format is a format specifier that often includes special characters like newlines. the Tcl interpreter does variable and command substitution on the second argument to puts. The backslashes must be substituted before the format command is . The backslash in the next example is required.. Example 1–10 Grouping with double quotes vs. variable. and backslash substitutions. 1 A common use of backslashes is to continue long commands on multiple lines. set totalLength [expr [string length $one] + \ [string length $two]] There are two fine points to escaping newlines. the backslash-newline sequence also consumes all the leading white space on the next line. set s Hello => Hello puts stdout "The => The length of puts stdout {The => The length of length of $s is [string length $s]. First. This is similar to the C printf function. conditional statements. Second. and all the white space at the beginning of the next line is replaced by this substitution. The easiest way to specify these characters is with backslash sequences (e. Another common use of quotes is with the format command. while curly braces prevent substitutions. then you do not need to escape newlines. braces. and procedure declarations. substitutions are prevented. In practice. Double quotes are useful in simple cases like the puts command previously shown.g. Example 1–9 Continuing long lines with backslashes. a backslash as the last character in a line is converted into a space. In the second command of Example 1–10. Examples include loops." Hello is 5. In the third command. tabs. The difference between double quotes and curly braces is that quotes allow substitutions to occur in the group.} $s is [string length $s]. In other words.

the second argument to puts is: $x+$y=[expr $x + $y] The white space inside the nested command is ignored for the purposes of grouping the argument. and the nested command is just part of that group. puts stdout [string length $s] The following is a redundant use of double quotes: puts stdout "[expr $x + $y]" Grouping before Substitution The Tcl parser makes a single pass through a command as it makes grouping decisions and performs string substitutions. For more information about the format command. set y 9 puts stdout $x+$y=[expr $x + $y] => 7+9=16 In Example 1–11.Grouping with Braces and Double Quotes 9 I. Square Brackets Do Not Group The square bracket syntax used for command substitution does not provide grouping. This means that the values being substituted do not affect grouping because the grouping decisions have already been made.3f" $name $value] Here format is used to align a name and a value with a tab. In the command below." If an argument is made up of only a nested command. It is included with the surrounding group of characters when collecting arguments for the main command. Tcl Basics called. set x 7. the double quotes group the last argument. Note that the trailing \n usually found in a C printf call is not needed because puts provides one for us. puts stdout "The length of $s is [string length $s]. which is an important property of Tcl. see page 52. By the time Tcl encounters the left bracket. so you need to use quotes to group the format specifier. Grouping decisions are made before substitutions are performed. puts [format "Item: %s\t%5. regardless of its internal structure. Instead. it has already done some variable substitutions to obtain: .3f indicate how the remaining arguments to format are to be formatted. A nested command is treated as an unbroken sequence of characters. a nested command is considered part of the current group. The %s and %5. The following example demonstrates how nested command substitution affects grouping. Example 1–11 Embedded command and variable substitution. you do not need to group it with double-quotes because the Tcl parser treats the whole nested command as part of the group.

The following command sets concat to the value of variables a. the result of expr is substituted for everything from the left bracket to the right bracket. if you want to add spaces. The point of this example is that the grouping decision about puts’s second argument is made before the command substitution is done. World!" . The following computes a command name: [findCommand $x] arg arg When you use Tk. then you must use double quotes to explicitly group the argument to puts: puts stdout "$x + $y = [expr $x + $y]" The double quotes are used for grouping in this case to allow the variable and command substitution on the argument to puts. b. you can place a bracketed command or variable reference anywhere. Again. with spaces around the + and =. Spaces or special characters in variable values do not affect grouping decisions because these decisions are made before the variable values are substituted. If you want the output to look nicer in the example. you can avoid grouping with quotes. Grouping and variable substitution interact the same as grouping and command substitution. you often use widget names as command names: $text insert end "Hello.10 Tcl Fundamentals Chap. they would be ignored for the purposes of grouping the arguments to the outer command. the $x and $y are substituted before calling expr. Even if the result of the nested command contained spaces or other special characters. and c all concatenated together: set concat $a$b$c Again. Finally. The puts command gets the following as its second argument: 7+9=16 Grouping before substitution. This means you can write commands like the one below and the substitutions on the variables in the expression still occur: puts stdout "$x + $y = [expr {$x + $y}]" More Substitution Examples If you have several substitutions with no white space between them. the interpreter calls itself recursively to evaluate the nested command. you’ll need to use quotes: set concat "$a $b $c" In general. 1 7+9= When the left bracket is encountered. This is explained in more detail on page 15. Grouping Math Expressions with Braces It turns out that expr does its own substitutions inside curly braces.

Good programming style is important as your Tcl scripts get larger. Double quotes have the same property. a Tcl procedure is used just like any of the other built-in Tcl commands. As a convention. Procedure names and variable names do not conflict with each other. Tcl coding style is discussed in Chapter 12. The result of the grouping is that . and in fact it can contain any characters. 4 right triangle is [Diag 3 4]" => The diagonal of a 3. Example 1–12 Defining a procedure. So. 4 right triangle is 5. causing it to ignore newline characters and scan the text until a matching right brace is found. Once defined. Variable scope is discussed further in Chapter 7. this book begins procedure names with uppercase letters and it begins variable names with lowercase letters. The sqrt function is one of many math functions supported by the expr command. In this case. The return command is optional in this example because the Tcl interpreter returns the value of the last command in the body as the value of the procedure. it is defined only during execution of Diag. They group characters. The basic syntax to define a procedure is: proc name arglist body The first argument is the name of the procedure being defined. the procedure could be reduced to: proc Diag {a b} { expr sqrt($a * $a + $b * $b) } Note the stylized use of curly braces in the example. proc Diag {a b} { set c [expr sqrt($a * $a + $b * $b)] return $c } puts "The diagonal of a 3. including newlines. until another double quote is found.Procedures 11 I. The procedure name is case sensitive. Tcl Basics Procedures Tcl uses the proc command to define procedures. the Tcl interpreter sees the opening left brace. It is not really necessary to use the variable c in this example. The procedure can also be written as: proc Diag {a b} { return [expr sqrt($a * $a + $b * $b)] } The return command is used to return the result of the procedure. The curly brace at the end of the first line starts the third argument to proc. The third argument is a command body that is one or more Tcl commands. The variable c is local to the procedure.0 The Diag procedure defined in the example computes the length of the diagonal side of a right triangle given the lengths of the other two sides. The second argument is a list of parameters to the procedure. which is the command body.

set product 1 while {$i <= $x} { set product [expr $product * $i] incr i } return $product } Factorial 10 => 3628800 The semicolon is used on the first line to remind you that it is a command terminator just like the newline character. These are described in detail in Chapter 7. . There is no need to explicitly use the expr command in the first argument to while. proc Factorial {x} { set i 1. below is a longer example that uses a while loop to compute the factorial function: Example 1–13 A while loop to compute factorial. and c are not defined until the procedure is called. you must escape the newline with a backslash: while {$i < $x} \ { set product . The while command and other control structures are described in Chapter 6. so we do not want to do variable substitution at the time Diag is defined.12 Tcl Fundamentals Chap. the embedded newlines will terminate each command. When they are evaluated later. If you like to put opening curly braces on the line after a while or if statement. The first argument to while is a boolean expression.. and its second argument is a command body to execute. The opening curly brace must be on the same line as proc and while. the variables a. The loop body and the procedure body are grouped with curly braces in the same way. The while loop is used to multiply all the numbers from one up to the value of x. } Always group expressions and command bodies with curly braces. The proc command supports additional features such as having variable numbers of arguments and default values for arguments. The same math expression evaluator used by the expr command is used by while to evaluate the boolean expression. The other crucial effect of the curly braces around the procedure body is to delay any substitutions in the body until the time the procedure is called. 1 the third argument to proc is a sequence of commands.. b. A Factorial Example To reinforce what we have learned so far. For example. even if you have a much more complex expression.

Tcl Basics Curly braces around the boolean expression are crucial because they delay variable substitution until the while command implementation tests the expression. Tcl 8.0 introduced a byte-code compiler. it is possible to eliminate the loop variable i and just modify the parameter x. This is a handy command that saves us from the longer command: set i [expr $i + 1] The incr command can take an additional argument. proc Factorial {x} { if {$x <= 1} { return 1 } else { return [expr $x * [Factorial [expr $x . then the recursion stops. The following example is an infinite loop: set i 1. and the first releases of Tcl 8.5 patch release.0. You can avoid these kinds of errors by adopting a consistent coding style that groups expressions with curly braces: set i 1.* The reason is that the Tcl interpreter will substitute for $i before while is called. Example 1–15 shows a trick you can play by putting the name of one variable into another variable: * Ironically.More about Variables 13 I. Example 1–14 A recursive definition of factorial. It treats that argument as a variable name and returns the current value of the variable. The dollar-sign syntax used to get the value of a variable is really just an easy way to use the set command. while $i<=10 {incr i} The loop will run indefinitely. while {$i<=10} {incr i} The incr command is used to increment the value of the loop variable i. Each recursive call decrements x by one. this time using a recursive definition. Using this form.0 had a bug in the compiler that caused this loop to terminate! This bug is fixed in the 8. A recursive function is one that calls itself to complete its work. a positive or negative integer by which to change the value of the variable. . so while gets a constant expression 1<=10 that will always be true. and when x is one. The loop body can be written like this: while {$x > 1} { set product [expr $product * $x] incr x -1 } Example 1–14 shows factorial again.1]]] } } More about Variables The set command will return the value of a variable if it is only passed a single argument.

1 set var {the value of var} => the value of var set name var => var set name => var set $name => the value of var This is a somewhat tricky example. By default. If the variable reference is not delimited by punctuation or white space. or computing the names of variables.o”. In the last command. There is even a special command. The upvar command is described in detail in Chapter 7.o => filename. ${x}).g. that makes this sort of trick easier.o set a AAA set b abc${a}def => abcAAAdef set . Then. If you find yourself using funny variable names. $name gets substituted with var.o yuk! set x ${. then you can use curly braces to explicitly delimit the variable name (e..o}y => yuk!y . it assumes that variable names contain only letters.14 Example 1–15 Using set to return a variable value. You can also use this to reference variables with funny characters in their name. then you may want to use the upvar command.o represents a concatenation of the value of foo and the literal “. digits. However. and the underscore. the set command returns the value of var. Example 1–16 Embedded variable references. The construct $foo. Tcl Fundamentals Chap. there are some times when it is very useful. which is the value of var. Nested set commands provide another way to achieve a level of indirection. upvar. although you probably do not want variables named like that. The last set command above can be written as follows: set [set name] => the value of var Using a variable to store the name of another variable may seem overly complex. set foo filename set object $foo. Funny Variable Names The Tcl interpreter makes some assumptions about variable names that make it easy to embed variable references into other strings.

. In Tcl 7. 12 significant digits. Using info to Find Out about Variables The existence of a variable can be tested with the info exists command. because incr requires that a variable exist. if {![info exists foobar]} { set foobar 0 } else { incr foobar } Example 7–6 on page 86 implements a new version of incr which handles this case. you might have to test for the existence of the variable first.33333333333333331 . The result is formatted into a string that has. Any number of variable names can be passed to the unset command.. Example 1–17 Using info to determine if a variable exists. For example.More about Math Expressions 15 I. This number can be changed by setting the tcl_precision variable to the number of significant digits desired. More about Math Expressions This section describes a few fine points about math in Tcl scripts. The expr command must convert its arguments from strings to numbers. Tcl Basics The unset Command You can delete a variable with the unset command: unset varName varName2 . by default.6 and earlier versions math is not that efficient because of conversions between strings and numbers.333333333333 set tcl_precision 17 => 17 expr 1 / 3. Seventeen digits of precision are enough to ensure that no information is lost when converting back and forth between a string and an IEEE double precision number: Example 1–18 Controlling precision with tcl_precision.0 => 0. unset will raise an error if a variable is not already defined. It then does all its computations with double precision floating point values. expr 1 / 3 => 0 expr 1 / 3.0 # The trailing 1 is the IEEE rounding digit => 0. However.

This is because an argument to expr is subject to two rounds of substitution: one by the Tcl interpreter. Expressions can include variable and command substitutions and still be grouped with curly braces.0 and later versions. suppose x is computed from a math function: set x [expr {sqrt(2. but the conversions can loose precision in certain circumstances. if you do this: set two [expr {$x * $x}] then expr will do the substitutions. the overhead of conversions is eliminated in most cases by the built-in compiler. and then parse the expression again. In contrast. An easy trick to append a comment to the end of a command is . The expression will be more accurate and run more efficiently because no string conversions will be done. The story behind Tcl values is described in more detail in Chapter 44 on C programming and Tcl. The issues with string operations and expr are discussed on page 48. #. Otherwise. Ordinarily this is not a problem because math values do not contain the characters that are special to the Tcl interpreter.16 Tcl Fundamentals Chap. } However. for comments. Grouping expressions can make them run more efficiently.. A # that occurs elsewhere is not treated specially. You should always group expressions in curly braces and let expr do command and variable substitutions. The second round of substitutions is needed to support commands like while and if that use the expression evaluator internally. Not only is this process slow. Tcl was not designed to support math-intensive applications. Even so. For example. the string compare and string equal commands described in Chapter 4 are more reliable because expr may do conversions on strings that look like numbers. You must use quotes so that expr knows to do string comparisons: if {$answer == "yes"} { .. 1 In Tcl 8. so you can test string values in if statements. just as you would expect. If you do this: set two [expr $x * $x] then you may or may not get 2. You may want to implement math-intensive code in a compiled language and register the function as a Tcl command as described in Chapter 44. and it will be careful to preserve the floating point value of x. There is support for string comparisons by expr. your values may suffer extra conversions from numbers to strings and back to numbers. the # must occur at the beginning of a command. and a second by expr itself.0 as the result! This is because Tcl will substitute $x and expr will concatenate all its arguments into one string.0)}] At this point the value of x is a double-precision floating point value. Comments Tcl uses the pound character. Unlike in many other languages.

# The loan term One subtle effect to watch for is that a backslash effectively continues a comment line onto the next line of the script. I think the motivation for this mis-feature was to keep the original Tcl parser simpler.e. A surprising property of Tcl comments is that curly braces inside comments are still counted for the purposes of finding matching brackets. it means that the following will not work as expected to comment out an alternate version of an if expression: # if {boolean expression1} { if {boolean expression2} { some commands } The previous sequence results in an extra left curly brace. still in the comment The behavior of a backslash in comments is pretty obscure. outermost) braces are not included in the group’s value. Tcl Basics to precede the # with a semicolon to terminate the previous command: # Here are some parameters set rate 7. The enclosing (i.# The interest rate set months 60 . The enclosing quotes are not included in the group of char- . In addition. including newlines and semicolons.Substitution and Grouping Summary 17 I. • Grouping with curly braces. but it can be exploited as shown in Example 2–3 on page 27. • Grouping with double quotes. a semicolon inside a comment is not significant. The interpreter groups everything until another double quote is found. However. Only a newline terminates comments: # Here is the start of a Tcl comment \ and some more of it. including newlines. " ". and probably a complaint about a missing close brace at the end of your script! A technique I use to comment out large chunks of code is to put the code inside an if block that will never execute: if {0} { unused code here } Substitution and Grouping Summary The following rules summarize the fundamental mechanisms of grouping and substitution that are performed by the Tcl interpreter before it invokes a command: • Command arguments are separated by white space. and nested braces. The interpreter includes all characters between the matching left and right brace in the group.0 . { }. unless arguments are grouped with curly braces or double quotes as described below.. allows substitutions. prevents substitutions. Braces nest. semicolons.

This is because white space is used as the separator. digits. You can think of this as another form of substitution in which the backslash and the next character or group of characters are replaced with a new character. you do not have to worry about special characters in values causing extra substitutions. causes variable substitution. A single round of substitutions is performed before command invocation. This requires that curly braces or white space delimit the group. they can be distinguished with the ${varname} syntax. (e. This rule is important if you have a variable value or a command result that contains special characters such as spaces. Everything between the brackets is treated as a command. Substitutions can occur anywhere unless prevented by curly brace grouping. 1 • • • • • • acters. or braces. Fine Points • A common error is to forget a space between arguments when grouping with braces or quotes.g. Even the command name can be affected by substitutions. $. A dollar sign. I do not recommend using this obscure feature. and other parts of it can be the result of substitutions. square brackets.18 Tcl Fundamentals Chap. If variable references are embedded into other strings. but this is what it looks like: set silly a"b • When double quotes are used for grouping. The following is an error because of the missing space between } and {: if {$x > 1}{puts "x = $x"} • A double quote is only used for grouping when it comes after white space. Variable names can be any length. This means you can include a double quote in the middle of a group without quoting it with a backslash. and case is significant. and everything including the brackets is replaced with the result of the command. cause command substitution. Because only a single round of substitution is done. Substitutions occur everywhere inside a group formed with . which means that the values of variables or command results do not affect grouping. A double-quote character can be included in the group by quoting it with a backslash.. while the braces or quotes only provide grouping. you will get syntax errors about unexpected characters after the closing brace or quote. Nesting is allowed. or if they include characters other than letters. and the underscore. The result of a substitution is not interpreted a second time. Part of a group can be a constant string. \"). is used to quote special characters. If you forget the space. Square brackets. The backslash character. dollar signs. \. [ ]. Grouping decisions are made before substitutions are performed. the special effect of curly braces is turned off.

Fine Points 19 I. put a backslash before the newline if you want to continue the command on another line. too. In the next command. or left parenthesis is treated as a literal dollar sign. If you have a long command that is nested in square brackets. the interpreter considers everything between the square brackets as part of the current group. puts "results [format "%f %f" $x $y]" • Spaces are not required around the square brackets used for command substitution. For the purposes of grouping. Tcl Basics double quotes. the variables are still substituted: set x xvalue set y "foo {$x} bar" => foo {xvalue} bar • When double quotes are used for grouping and a nested command is encountered. This was illustrated in Example 1–9 on page 8. The following sets x to the concatenation of two command results because there is no space between ] and [. They get included in the group of characters just like all the others." • During command substitution. • A dollar sign followed by something other than a letter. The following sets x to the single character $. The following sets x to a string that contains newlines: set x "This is line one. the nested command can use double quotes for grouping. set x [cmd1][cmd2] • Newlines and semicolons are ignored when grouping with braces or double quotes. This is line two. This is line three. underscore. set x $ . digit. newlines and semicolons are significant as command terminators.

Left shift. Equal. (‘\’) Octal specification of character code. 1. greater or equal. Logical OR. logical NOT. Add. \". Multiply. subtract. \$. Backslash. (0xc) Newline. In particular. \]. divide. right shift. Bitwise XOR. If x then y else z. Bitwise AND. Hexadecimal specification of character code. Arithmetic Operators Table 1–2 Arithmetic operators from highest to lowest precedence. not equal. (0xd) Tab. bitwise NOT. greater. or 3 digits. (0xa) Carriage return. \}. 1 or 2 digits.~ ! * / % + << >> < > <= >= == != & ^ | && || x?y:z Unary minus. (0x8) Form feed. 2. (0x7) Backspace. (0x9) Vertical tab. 1 Reference Backslash Sequences Table 1–1 Backslash sequences. Bitwise OR. \a \b \f \n \r \t \v \<newline> \\ \ooo \xhh \uhhhh \c Bell. \{. less or equal. remainder. Replaced with literal c if c is not one of the cases listed above. . Logical AND. 4 hex digits. Hexadecimal specification of a 16-bit Unicode character value. . and \[ are used to obtain these characters.20 Tcl Fundamentals Chap. (0xb) Replace the newline and the leading white space on the next line with a space. Comparison: less.

Round x to an integer. Arcsine of x. Sine of x. xy. Core Tcl Commands The pages listed in Table 1–4 give the primary references for the command.y) sin(x) sinh(x) sqrt(x) tan(x) tanh(x) abs(x) double(x) int(x) round(x) rand() srand(x) Arccosine of x.x) ceil(x) cos(x) cosh(x) exp(x) floor(x) fmod(x. Hyperbolic tangent of x. Exponential. . r part of polar coordinates. Returns sqrt(x*x + y*y). Greatest integral value less than or equal to x. x to the y power.Reference 21 I. Set the seed for the random number generator to the integer x. Return a random floating point value between 0.y) hypot(x. Absolute value of x. Natural log of x. Truncate x to an integer. Rectangular (x. Promote x to floating point.0 and 1. acos(x) asin(x) atan(x) atan2(y. ex. Square root of x.y) to polar (r.th).0. Least integral value greater than or equal to x. atan2 gives th. Arctangent of x. Floating point remainder of x/y. Tangent of x. Cosine of x. Log base 10 of x. Hyperbolic cosine of x. Hyperbolic sine of x. Tcl Basics Built-in Math Functions Table 1–3 Built-in math functions.y) log(x) log10(x) pow(x.

Query the file system. Change working directory. No spaces added. or lists. Set and query I/O channel properties. Read a line of input from an I/O stream. Raise an error. Loop construct similar to C for statement. Poll an I/O channel to see if data is ready. Check for end of file. Register callback for event-driven I/O. 218 51 91 54 77 77 115 173 115 61 28 77 79 109 122 99 116 6 223 221 237 102 219 109 76 73 52 112 115 84 Description Schedule a Tcl command for later execution. Loop construct over a list. 1 Command after append array binary break catch cd clock close concat console continue error eof eval exec exit expr fblocked fconfigure fcopy file fileevent flush for foreach format gets glob global Pg. Query array state and search through elements. Control the console used to enter commands interactively. Concatenate arguments and evaluate them as a command. Splices lists. Copy from one I/O channel to another. Close an open I/O stream. Fork and execute a UNIX program. Expand a pattern to matching file names. Concatenate arguments with spaces between. Evaluate a math expression. Declare global variables. of values. Append arguments to a variable’s value. Continue with next loop iteration. Terminate the process. Flush output from an I/O stream’s internal buffers. Get the time and format date strings. Convert between strings and binary data.22 Table 1–4 Built-in Tcl commands. Trap errors. Tcl Fundamentals Chap. Format a string similar to C sprintf. Exit loop prematurely. .

Sort a list. Parse a string according to a format specification. Read blocks of characters from an I/O stream. Return a value from a procedure. Provide or require code packages. . Add elements to the end of a list. Substitute based on regular expressions.Reference Table 1–4 Built-in Tcl commands. Output a string to an I/O stream. Increment a variable by an integer amount. Open a file or process pipeline for I/O. Test a condition. Return the number of elements in a list. Tcl Basics history if incr info interp join lappend lindex linsert list llength load lrange lreplace lsearch lsort namespace open package pid proc puts pwd read regexp regsub rename return scan seek set 185 70 12 176 274 65 61 63 64 61 63 607 63 64 64 65 203 110 165 116 81 112 115 113 148 152 82 80 54 114 5 Use command-line history. Create and manipulate namespaces. Load shared libraries that define Tcl commands. Insert elements into a list. Replace elements of a list. Return a range of list elements. (Continued) 23 I. Allows else and elseif clauses. Create a list out of the arguments. Return the current working directory. Create additional Tcl interpreters. Match regular expressions. Set the seek offset of an I/O stream. Return the process ID. Search for an element of a list that matches a pattern. Fetch an element of a list. Assign a value to a variable. Query the state of the Tcl interpreter. Concatenate list elements with a given separator string. Change the name of a Tcl command. Define a Tcl procedure.

Reference a variable in a different scope. Operate on strings. Substitute embedded commands and variable references.24 Table 1–4 Built-in Tcl commands. Evaluate the Tcl commands in a file. Execute a command in a different scope. (Continued) Tcl Fundamentals Chap. Measure the execution time of a command. . 1 socket source split string subst switch tell time trace unknown unset uplevel upvar variable vwait while 226 26 65 45 132 71 114 191 183 167 13 130 85 197 220 73 Open a TCP/IP network connection. Loop until a boolean expression is false. Handle unknown commands. Delete variables. Return the current seek offset of an I/O stream. Monitor variable assignments. Chop a string up into list elements. Test several conditions. Declare namespace variables. Wait for a variable to be modified.

console and info. Wish stands for windowing shell.exe. such as wish4. a console window is used to prompt for Tcl commands. such as with the CGI script discussed in Chapter 3. On UNIX it is just wish.C H A P T E R 2 I. On UNIX. On Windows and Macintosh. A version number may also be part of the name. and Tk is described in Part III. Tcl commands discussed are: source. and with it you can create graphical applications that run on all these platforms. When you run wish.exe or Tclsh. you can also set up standalone Tcl/Tk scripts that are self-contained applications. and described in more detail in Part VII of the book. In this case the program is tclsh. You can enter Tcl commands interactively and experiment with the examples in this book. your terminal window is used. or Wish 8.2. Tk adds Tcl commands that are used to create graphical user interfaces. Windows. On Windows you will find wish. and Macintosh. Tcl Basics Getting Started 2 This chapter explains how to run Tcl and Tk on different operating system platforms: UNIX. it displays an empty window and prompts for a Tcl command with a % prompt. The name of the program is a little different on each of the UNIX.2. and Macintosh systems. If you are looking for a current version of Tcl/Tk. While you can write Tcl scripts that are portable among UNIX. The main Tcl/Tk program is wish.exe. and on the Macintosh the application name is Wish. 25 T . and Macintosh. wish80. Windows. his chapter explains how to run Tcl scripts on different computer systems. Windows. As described later. The differences among versions are introduced on page xlviii. You can run Tcl without Tk if you do not need a graphical interface. check the Internet sites listed in the Preface on page lii. tclsh. the details about getting started are different for each system. This book will use wish to refer to all of these possibilities.

tcl. Development goes quickly because you do not wait for things to compile! UNIX Tcl Scripts On UNIX you can create a standalone Tcl or Tcl/Tk script much like an sh or csh script.2 Watch out for long pathnames. The "Hello. It is a good idea to try out the examples in this book as you read along. World!"} pack .hello -padx 10 -pady 10 The actual pathnames for tclsh and wish may be different on your system. . the Tk hello world program from Chapter 21 is shown in Example 2–2: Example 2–2 A standalone Tk script on UNIX. The highlighted examples from the book are on the CD-ROM in the exsource folder. #!/usr/local/bin/wish button . 2 The source Command You can enter Tcl commands interactively at the % prompt. You can edit these scripts in your favorite editor. To get started. You can find out the complete pathname of the Tcl interpreter with the info nameofexecutable command.26 Getting Started Chap. If you type the pathname for the interpreter wrong. and test it again. If the first line of a file begins with #!pathname. This is what appears on my system: info nameofexecutable => /home/welch/install/solaris/bin/tclsh8. just open an editor on a file named cgi1. World!} Similarly. Each time you update this file you can save it. you receive a confusing “command not found” error. then UNIX uses pathname as the interpreter for the rest of the script. World!" program from Chapter 1 is repeated in Example 2–1 with the special starting line: Example 2–1 A standalone Tcl script on UNIX. Save your examples to a file and then execute them with the Tcl source command: source filename The source command reads Tcl commands from a file and evaluates them just as if you had typed them interactively. Chapter 3 develops a sample application. reload it into Tcl with the source command. The trick is in the first line of the file that contains your script. #!/usr/local/bin/tclsh puts stdout {Hello.hello -text Hello -command {puts "Hello.

watch out for systems like Solaris in which the script interpreter cannot be a symbolic link. You might try using a symbolic link from a short name to the true. giving you syntax errors. the Bourne shell command that runs the Tcl interpreter is hidden in a comment as far as Tcl is concerned. The next example shows a trick that works around the pathname length limitation in all cases. Solaris doesn’t impose a 32-character limit on the pathname. If the pathname is too long.. long name of the interpreter. Tcl script goes here . so you must use quotes.. is also counted in the 32-character limit on #! lines. The command is the complete name of the wish.exe program and the name of the script. . #!/bin/sh # The backslash makes the next line a comment in Tcl \ exec /some/very/long/path/to/wish "$0" ${1+"$@"} # .tcl by Kevin Kenny. some users may not have these programs in their PATH.6 or earlier.exe has a space in it in the default configuration. However.Windows 95 Start Menu 27 I.exe" "c:\My Files\script. #!/usr/local/bin/wish -f Windows 95 Start Menu You can add your Tcl/Tk programs to the Windows start menu. including the #!.0 and higher versions. you may end up with /bin/sh trying to interpret your script. Tcl Basics On most UNIX systems. its version of wish requires a -f argument to make it read the contents of a file. so you can just use a long pathname. but it is visible to /bin/sh: Example 2–3 Using /bin/sh to run a Tcl script. if required.tcl as a standalone Tcl/Tk program. In addition.. this special first line is limited to 32 characters.lang. Fortunately. Tcl comments are described on page 16.. If you have Tk version 3. You do not even have to know the complete pathname of tclsh or wish to use this trick. Your start command will look something like this: "c:\Program Files\TCL82\wish.tcl" This starts c:\My Files\script. It takes advantage of a difference between comments in Tcl and the Bourne shell. The trick is that the name of wish. The -f switch is ignored in Tk 4. You can just do the following: #!/bin/sh # Run wish from the users PATH \ exec wish -f "$0" ${1+"$@"} The drawback of an incomplete pathname is that many sites have different versions of wish and tclsh that correspond to different versions of Tcl and Tk. In the example. The -f. The trick comes from a posting to comp.

TkCon was created by Jeff Hobbs and has lots of nice features. you can just use the Wish Source menu to select a script to run.r file. You can use TkCon on Unix systems. you must copy the Wish program and add a Macintosh resource named tclshrc that has the start-up Tcl code. it will create a copy of Wish and create the tclshrc text resource that has a source command that will load that script. which comes with the Macintosh Tcl distribution. you can build a version of Wish that has additional resources built right in. You can control this console with the console command. Type in a source command that names your script: source "Hard Disk:Tcl/Tk 8. The console Command The Windows and Macintosh platforms have a built-in console that is used to enter Tcl commands interactively. too. and you can find current versions on the Internet.1:Applications:MyScript. The console is visible by default. This sequence of commands is captured in an application called Drag n Drop Tclets. you use it like this: source -rcrc resource If you don’t want to edit resources. The Tcl code can be a single source command that reads your script file. make a copy of Wish and open the copy in ResEdit. • Pull down the Resource menu and select Create New Resource operation to make a new TEXT resource. You add the resources to the applicationInit. 2 The Macintosh and ResEdit If you want to create a self-contained Tcl/Tk application on Macintosh. . Here are step-by-step instructions to create the resource using ResEdit: • First. It is included on the CD-ROM. You do this through the Get Resource Info dialog under the Resources menu in ResEdit. If you drag a Tcl script onto this icon.tcl" • Set the name of the resource to be tclshrc. Hide the console like this: console hide Display the console like this: console show The console is implemented by a second Tcl interpreter. • ResEdit opens a window and you can type in text.28 Getting Started Chap. You can evaluate Tcl commands in that interpreter with: console eval command There is an alternate version of this console called TkCon. If a resource contains Tcl code. If you have a Macintosh development environment.

tcl arg1 The Tcl shells pass the command-line arguments to the script as the value of the argv variable. The name of the program. which is described on page 59. Tcl Basics Command-Line Arguments If you run a script from the command line. The general form of the wish command line is: wish ?options? ?script? ?arg1 arg2? If no script is specified. For example. -colormap new -display display -geometry geometry -name name Use a new private colormap. Table 2–1 lists the options that wish supports: Table 2–1 Wish command line options. so you can use the lindex command. Instead. is not part of argv nor is it counted by argc. argv is a list. under UNIX you can type this at a shell: % myscript.Command-Line Arguments 29 I. You can also specify these arguments in the shortcut command in Windows. Table 2–2 lists all the predefined variables in the Tcl shells. Specify the Tk application name. for example from a UNIX shell.exe" c:\your\script.tcl arg1 arg2 arg3 In Windows. # Tcl script to echo command line arguments puts "Program: $argv0" puts "Number of arguments: $argc" set i 0 foreach arg $argv { puts "Arg $i: $arg" incr i } Command-Line Options to Wish Some command-line options are interpreted by wish. or script. Use the specified X display. See page 538. UNIX only. and they do not appear in the argv variable. you can pass the script command-line arguments. The size and position of the window. then wish just enters an interactive command loop. it is put into the argv0 variable. See page 570. The number of command-line arguments is given by the argc variable. See page 560. you can have a shortcut that runs wish on your script and also passes additional arguments: "c:\Program Files\TCL82\wish. . to extract items from it: set arg1 [lindex $argv 0] The following script prints its arguments (foreach is described on page 73): Example 2–4 The EchoArgs script.

g. If set. argv0 is the name of the shell program. (Continued) Getting Started Chap. Predefined Variables Table 2–2 Variables defined by tclsh and wish.30 Table 2–1 Wish command line options. this is a command that outputs the prompt if the current command is not yet complete. See page 538. Specify the visual for the main window. Tcl applets only. If defined. True (one) if the tclsh is prompting for commands. The script library directory. e. See page 296. A list of the command-line arguments. An array of the environment variables. the auto execute facility is disabled. argc argv argv0 embed_args env tcl_interactive tcl_library tcl_patchLevel tcl_platform tcl_prompt1 tcl_prompt2 tcl_version auto_path auto_index auto_noload auto_noexec geometry The number of command-line arguments. See page 578. See page 117. 2 -sync -use id -visual visual -- Run X synchronously. If set. If defined. (wish only). A map from command name to a Tcl command that defines it. See page 162. this is a command that outputs the prompt. Terminate options to wish. The search path for script library directories.. . Modified version number. 8. Version number. Use the window specified by id for the main window. If being used interactively. The value of the -geometry argument. The list of arguments in the <EMBED> tag. UNIX only. the library facility is disabled. See page 182.0b1. The name of the script being executed. Array containing operating system information.

Our guests can leave their address as a Universal Resource Location (URL). The details of how the page gets from your program to the user with the Web browser vary from system to system. A guestbook is a place for visitors to sign their name and perhaps provide other information. including hypertext links to other pages on the World Wide Web. We will build a guestbook that takes advantage of the World Wide Web. Tcl Basics The Guestbook CGI Application 3 This chapter presents a simple Tcl program that computes a Web page.C H A P T E R 3 I. The chapter provides a very brief introduction to HTML and CGI programming. The guestbook will be presented as a page that has hypertext links to all these URLs so that other guests can visit them. 1997) is a good reference for details that are left unexplained here. based on the contents of a simple database. his chapter presents a complete. The Tcl Web Server described in Chapter 18 comes with this guestbook example already set up. T 31 . HTML is a way to specify text formatting. The basic idea is that a user with a Web browser visits a page that is computed by the program. CGI Developers Resource. CGI is a standard for communication between a Web server that delivers documents and a program that computes documents for the server. but you will need help from your Webmaster to set things up. or Web page. The chapter provides a brief background to HTML and the CGI interface to Web servers. and it generates the guestbook page from the database. The program works by keeping a simple database of the guests. but simple guestbook program that computes an HTML document. Web Programming with Tcl and Perl by John Ivler (Prentice Hall. You can also use these scripts on your own Web server. There are many books on these subjects alone.

and the close tag name begins with a slash. or even </TiTlE>. The idea of HTML is that you annotate. your browser switches to the page at the address "http://www. your browser typically displays "Brent Welch" in blue underlined text. . Delimits head section of the HTML document. The <A> tag defines hypertext links that reference other pages on the Web. If the examples in this chapter raise questions. There is a lot more to HTML. </Title>. </TITLE>. The <A> tag takes an HREF parameter that defines the destination of the link. <Title>. Lets you specify page colors. 3 The Tcl scripts described in this chapter use commands and techniques that are described in more detail in later chapters. If you wanted to link to my home page. the title of a Web page is defined like this: <TITLE>My Home Page</TITLE> The tags provide general formatting guidelines. It is the flexibility of the links that make the Web so interesting.32 The Guestbook CGI Application Chap. or mark up. This keeps the markup simple. and <TITLE> are all valid and mean the same thing. The following list summarizes the HTML tags that will be used in the examples: Table 3–1 HTML tags used in the examples. The goal of the examples is to demonstrate the power of Tcl without explaining every detail. For example. regular text with special tags that indicate structure and formatting.com/">Brent Welch</A> When this construct appears in a Web page. The corresponding close tag could be </title>. but the browsers that display HTML pages have freedom in how they display things.com/". A Quick Introduction to HTML Web pages are written in a text markup language called HTML (HyperText Markup Language). The open tag may have some parameters. Defines the title of the page. The case of a tag is not considered. The general syntax for HTML tags is: <tag parameters>normal text</tag> As shown here. but this should give you a basic idea of what is going on in the examples. you would put this in your page: <A HREF="http://www. When you click on that text.beedub. The hypertext links connect pages into a Web so that you can move from page to page to page and find related information. so <title>. the tags usually come in pairs. HTML HEAD TITLE BODY Main tag that surrounds the whole document. of course.beedub. Delimits the body section. you can follow the references to examples in other chapters that do go into more depth.

As we shall see. Definition clause in a definition list. Create a table. it is also easier to maintain information in a database of some sort and generate the HTML formatting for the data with a program. A dynamic page does not mean it includes animations. An unordered list. Start a new paragraph.CGI for Dynamic Pages Table 3–1 HTML tags used in the examples. H6. H2. Specify an image. One blank line.H6 P BR B I A IMG DL DT DD UL LI TABLE TR TD FORM INPUT TEXTAREA HTML defines 6 heading levels: H1. A bulleted item within a list. a dynamic page is computed each time it is viewed. Italic text. This is the easy way to think about Web pages. CGI for Dynamic Pages There are two classes of pages on the Web. In contrast. The advantage of this approach is that a user might see something different each time he or she visits the page. and the same thing is returned each time a user views the page. Term clause in a definition list. A CGI (Common Gateway Interface) program is used to compute Web pages. or submit button. checkbox. it is probably in this class. Tcl Basics H1 . H3. A multiline text field. A one-line entry field. The CGI standard defines how inputs are passed to the program as well . H4. for example. Bold text. Defines a data entry form. A cell within a table row. static and dynamic. This is how pages that give up-to-the-minute stock prices work. H5. Used for hypertext links. You have some information to share. A static page is written and stored on a Web server. A table row. it just means that a program computes the page contents when a user visits the page. Definition list. (Continued) 33 I. If you have a home page. so you compose a page and tinker with the HTML tags to get the information to look good. radio button.

plain text. such as images. The guestbook. Each time a user visits the page they will see the current time on the server. and a second time to format the time into a nice looking string.cgi Script The guestbook. and then each part of it is discussed in more detail later. Content-Type: text/html <TITLE>The Current Time</TITLE> The time is <B>Wed Oct 16 11:23:43 1996</B> This example is a bit sloppy in its use of HTML. The clock command is described in detail on page 173. The clock command is used twice: once to get the current time in seconds. puts puts puts puts "Content-Type: text/html" "" "<TITLE>The Current Time</TITLE>" "The time is <B>[clock format [clock seconds]]</B>" The program computes a simple HTML page that has the current time. the output of the program will look like this: Example 3–2 Output of Example 3–1. The first lines of the script use the UNIX trick to have tclsh interpret the script. there is no conflict between the markup syntax used by HTML and the Tcl syntax for embedded commands. When run. Fortunately.34 The Guestbook CGI Application Chap. and the Web server takes care of delivering the document to the user’s Web browser. The following is a very simple CGI script: Example 3–1 A simple CGI script.cgi script computes a page that lists all the registered guests. so we can mix the two in the argument to the puts command. The server that has the CGI program and the user viewing the page might be on different sides of the planet. or HTML markup. A CGI program simply writes the contents of the document to its standard output. Double quotes are used to group the argument to puts so that the clock commands will be executed. Example 3–3 includes all the required tags for a proper HTML document. This trick is described on page 26: . This is followed by a blank line and then the contents of the page. 3 as a way to identify different types of results. but it should display properly in most Web browsers. The output of the program starts with a Content-Type line that tells your Web browser what kind of data comes next. The example is shown first. One thing to note right away is that the HTML tags are generated by procedures that hide the details of the HTML syntax.

which would have to be changed if .cgi # Implement a simple guestbook page.cgi script will update the database. The file dirname and file join commands manipulate file names in a platform-independent way. yet. # \ exec tclsh "$0" ${1+"$@"} # The cgilib.tcl] set datafile [file join $dir guestbook.tcl file.The guestbook.tcl file has helper procedures # The guestbook." P puts "Be the first [Link {registered guest!} newguest. I use this trick to avoid putting absolute file names into my scripts. which is kept in the same directory as the main script. They are described on page 102.cgi script. The following command determines the location of the cgilib.cgi Script Example 3–3 The guestbook. The info script command returns the file name of the script.data file has the database # Both file are in the same directory as the script set dir [file dirname [info script]] source [file join $dir cgilib. # The set of visitors is kept in a simple database. These procedures are kept in the cgilib.tcl file based on the location of the main script. The script starts by sourcing the cgilib.data] Cgi_Header "Brent's Guestbook" {BGCOLOR=white TEXT=black} P if {![file exists $datafile]} { puts "No registered guests.tcl file so that these procedures are available." P puts [Link Register newguest. 35 I. Tcl Basics #!/bin/sh # guestbook.html]" } else { puts "The following folks have registered in my GuestBook.html] H2 Guests catch {source $datafile} foreach name [lsort [array names Guestbook]] { set item $Guestbook($name) set homepage [lindex $item 0] set markup [lindex $item 1] H3 [Link $name $homepage] puts $markup } } Cgi_End Using a Script Library File The script uses a number of Tcl procedures that make working with HTML and the CGI interface easier. # The newguest.

The Cgi_Header procedure just contains a single puts command that generates the standard boilerplate that appears at the beginning of the output. Note that several lines are grouped together with double quotes. a blank line. The file command. 3 the program moves later: set dir [file dirname [info script]] source [file join $dir cgilib. The procedure definition uses the syntax for an optional parameter. Finally. Double quotes are used so that the variable references mixed into the HTML are substituted properly.tcl] Beginning the HTML Page The following command generates the standard information that comes at the beginning of an HTML page: Cgi_Header {Brent’s GuestBook} {bgcolor=white text=black} The Cgi_Header is shown in Example 3–4: Example 3–4 The Cgi_Header procedure. H1) in the body of the page. Simple Tags and Hypertext Links The next thing the program does is to see whether there are any registered guests or not.. The HTML is divided into a head and a body part. and then the HTML. The <TITLE> tag goes in the head section of an HTML document. Default values for procedure parameters are described on page 81. so I always want to repeat the title as a level-one heading (i. proc Cgi_Header {title {bodyparams {}}} { puts stdout \ "Content-Type: text/html <HTML> <HEAD> <TITLE>$title</TITLE> </HEAD> <BODY $bodyparams> <H1>$title</H1>" } The Cgi_Header procedure takes as arguments the title for the page and some optional parameters for the HTML <Body> tag. The guestbook. The output begins with the CGI content-type information.cgi script specifies black text on a white background to avoid the standard gray background of most browsers.e. browsers display the title in a different place than the rest of the page. is used to see whether there is any data: .36 The Guestbook CGI Application Chap. so you do not have to pass bodyparams to Cgi_Header. which is described in detail on page 102.

Instead of printing the HTML directly. so you can include it in-line with other text you are printing: Example 3–5 The Link command formats a hypertext link. The newguest.html]" The P command generates the HTML for a paragraph break.cgi. proc Link {text url} { return "<A HREF=\"$url\">$text</A>" } The output of the program would be as below if there were no data: Example 3–6 Initial output of guestbook. <P> Be the first <A HREF="newguest. a different page is displayed to encourage a registration.cgi Script 37 I.html">registered guest!</A> </BODY> </HTML> If the database file exists. Content-Type: text/html <HTML> <HEAD> <TITLE>Brent’s Guestbook</TITLE> </HEAD> <BODY BGCOLOR=white TEXT=black> <H1>Brent’s Guestbook</H1> <P> No registered guests. then the real work begins." P puts "Be the first [Link {registered guest!} newguest. We first generate a link to the registration page.html] H2 Guests . and a level-two header to separate that from the guest list: puts [Link Register newguest. it is returned. Tcl Basics if {![file exists $datafile]} { If the database file does not exist.html page will be described in more detail later: puts "No registered guests.The guestbook. This trivial procedure saves us a few keystrokes: proc P {} { puts <P> } The Link command formats and returns the HTML for a hypertext link. yet. The page includes a hypertext link to a registration page.

The value of the array element is a Tcl list with two elements: their URL and some additional HTML markup that they can include in the guestbook.38 The Guestbook CGI Application Chap. The foreach command loops over the sorted list.gif>} } The spaces in the name result in additional braces to group the whole variable name and each list element. then you can compute its name: set dir [file dirname [info script]] set datafile [file join $dir guestbook. in the array.beedub.cgi script.data] By using Tcl commands to represent the data.data. Catching errors is described in detail on page 79: catch {source $datafile} The Guestbook variable is the array defined in guestbook. If this file is kept in the same directory as the guestbook.com/welch. Tcl lists are the topic of Chapter 5. setting the loop variable x to each key in turn: foreach name [lsort [array names Guestbook]] { Given the key. or keys. we can load the data with the source command. 3 The H2 procedure handles the detail of including the matching close tag: proc H2 {string} { puts "<H2>$string</H2>" } Using a Tcl Array for the Database The datafile contains Tcl commands that define an array that holds the guestbook data. The main point is that the person’s name is the key. Do not worry about it now.com/ {<img src=http://www. This syntax is explained on page 90. Array variables are the topic of Chapter 8. or key. we get the value like this: set item $Guestbook($name) The two list elements are extracted with lindex. which is described on page 63. The following example shows what the command looks like with real data: set {Guestbook(Brent Welch)} { http://www. The array names command returns all the indices. The catch command is used to protect the script from a bad data file. Each element of the array is defined with a Tcl command that looks like this: set Guestbook(key) {url markup} The person’s name is the array index. and the lsort command sorts these alphabetically. and the value is a list with two elements. We will see on page 42 that all the braces in the previous statement are generated automatically. which will show up as an error from the source command. set homepage [lindex $item 0] .beedub.

Second. and some additional HTML markup. except it generates <H3> tags: H3 [Link $name $homepage] puts $markup Sample Output The last thing the script does is call Cgi_End to output the proper closing tags. home page URL. The other half of CGI deals with input from the user.cgi script. The form has a submit button. We follow the link with any HTML markup text that the guest has supplied to embellish his or her entry.cgi script: Example 3–7 Output of guestbook.beedub. . we have to define another HTML page that has a form for the user to fill out. First. This page contains a form that lets a user register his or her name. When a user clicks that button in their browser. and the procedure that decodes the form data is shown in Example 11–6 on page 155. Example 3–8 on page 40 defines a very simple form. Input is more complex for two reasons. The guestbook page contains a link to newguest.com/">Brent Welch</A></H3> <IMG SRC="http://www.com/welch. This script updates the database and computes another page for the user that acknowledges the user’s contribution.Defining Forms and Processing Form Data 39 I.gif"> </BODY> </HTML> Defining Forms and Processing Form Data The guestbook.cgi script only generates output. <P> <A HREF="newguest. The H3 procedure is similar to the H2 procedure already shown. Example 3–7 shows the output of the guestbook.cgi. Content-Type: text/html <HTML> <HEAD> <TITLE>Brent’s Guestbook</TITLE> </HEAD> <BODY BGCOLOR=white TEXT=black> <H1>Brent’s Guestbook</H1> <P> The following folks have registered in my guestbook.beedub.html. the data from the form is organized and encoded in a standard form that must be decoded by the script. the information from the form is passed to the newguest. Tcl Basics set markup [lindex $item 1] We generate the HTML for the guestbook entry as a level-three header that contains a hypertext link to the guest’s home page.html">Register</A> <H2>Guests</H2> <H3><A HREF="http://www.

buttons. you can use an email URL like "mailto:welch@acm.40 The Guestbook CGI Application Chap. scrolling text field that is useful for specifying lots of information.0//EN"> <HTML> <HEAD> <TITLE>Register in my Guestbook</TITLE> <!-. In this case. such as the label on the submit button and the size of the text area. This name identifies the data that will come back from the form. For example. The complete form is shown in Example 3–8: Example 3–8 The newguest. a oneline entry field that is used to enter the home page URL is defined like this: <INPUT TYPE=text NAME=url> The INPUT tag is used to define several kinds of input elements. The tags also have parameters that affect their display. <TEXTAREA NAME=markup ROWS=10 COLS=50>Hello.org" <LI>Additional HTML to include after your link: <BR> <TEXTAREA NAME="html" COLS="60" ROWS="15"> </TEXTAREA> <LI><INPUT TYPE="submit" NAME="new" VALUE="Add me to your . TYPE=text creates a one-line text entry field.Author: bwelch --> <META HTTP-Equiv=Editor Content="SunLabs WebTk 1. In our case we will let guests type in HTML that will appear with their guestbook entry. such as a free-form comment. and the VALUE parameter becomes the text that appears on the button: <INPUT TYPE=submit NAME=submit VALUE=Register> A general type-in window is defined with the TEXTAREA tag.html Form An HTML form contains tags that define data entry fields. The text between the open and close TEXTAREA tags is inserted into the type-in window when the page is first displayed. 3 The newguest.html form.0beta 10/ 11/96"> </HEAD> <BODY> <FORM ACTION="newguest. This creates a multiline. checkboxes.</TEXTAREA> A common parameter to the form tags is NAME=something. <!Doctype HTML PUBLIC "-//IETF//DTD HTML 2. Those details are not important for our example. and other elements that let the user specify values. and its type parameter indicates what kind. The submit button is defined with an INPUT tag that has TYPE=submit.cgi" METHOD="POST"> <H1>Register in my Guestbook</H1> <UL> <LI>Name <INPUT TYPE="text" NAME="name" SIZE="40"> <LI>URL <INPUT TYPE="text" NAME="url" SIZE="40"> <P> If you don't have a home page.

and Cgi_Value gets a form value in the script. the data from the form is passed to the program identified by the Action parameter of the form tag. and then returns a new page for the browser to display.cgi set dir [file dirname [info script]] source [file join $dir cgilib.tcl] set datafile [file join $dir guestbook. #!/bin/sh # \ exec tclsh "$0" ${1+"$@"} # source cgilib.cgi as the program to handle the data: <FORM ACTION=newguest.cgi script.cgi Script When the user clicks the Submit button in their browser. In our case the FORM tag names newguest. Example 3–9 starts out by calling Cgi_Parse: Example 3–9 The newguest. The data is encoded and organized so that the program can figure out the values the user specified for each form element. These procedures are described in Example 11–6 on page 155.tcl from the same directory as newguest. Tcl Basics guestbook"> <LI><INPUT TYPE="submit" NAME="update" VALUE="Update my guestbook entry"> </UL> </FORM> </BODY> </HTML> The newguest.cgi METHOD=POST> The CGI specification defines how the data from the form is passed to the program. That program takes the data. The encoding is handled rather nicely with some regular expression tricks that are done in Cgi_Parse. Cgi_Parse saves the form data.data] Cgi_Parse # Open the datafile in append mode if [catch {open $datafile a} out] { Cgi_Header "Guestbook Registration Error" \ {BGCOLOR=black TEXT=red} P puts "Cannot open the data file" P puts $out. does something useful with it.# the error message exit 0 } .Defining Forms and Processing Form Data 41 I.

3 # Append a Tcl set command that defines the guest's entry puts $out "" puts $out [list set Guestbook([Cgi_Value name]) \ [list [Cgi_Value url] [Cgi_Value html]]] close $out # Return a page to the browser Cgi_Header "Guestbook Registration Confirmed" \ {BGCOLOR=white TEXT=black} puts " <DL> <DT>Name <DD>[Cgi_Value name] <DT>URL <DD>[Link [Cgi_Value url] [Cgi_Value url]] </DL> [Cgi_Value html] " Cgi_End The main idea of the newguest. If an error occurs. the variable out gets the result of the open command. The script opens the datafile in append mode so that it can add a new record to the end.42 The Guestbook CGI Application Chap. This trick of storing data as a Tcl script saves us from the chore of defining a new file format and writing code to parse it. The script uses a catch command to guard against errors. disk full.cgi script is that it saves the data to a file as a Tcl command that defines an element of the Guestbook array. The script writes the data as a Tcl set command. we can rely on the well-tuned Tcl implementation to do the hard work for us efficiently. The list command is used to format the data properly: puts $out [list set Guestbook([Cgi_Value name]) \ [list [Cgi_Value url] [Cgi_Value html]]] . This style of using catch is described in detail in Example 6–14 on page 77. Opening files is described in detail on page 110. This lets the guestbook. file-not-found. Working with files is one of the most common sources of errors (permission denied. Instead. and so on). a page explaining the error is returned to the user. which is either a file descriptor or an error message. so I always open the file inside a catch statement: if [catch {open $datafile a} out] { # an error occurred } else { # open was ok } In this command.cgi script simply load the data by using the Tcl source command.

Then. The list command is described in more detail on page 61. for example. The details of how a CGI script is hooked up with a Web server vary from server to server. A user may want to update their entry. and also has the fields that let them update the data. but they would have to retype everything. The cgi.tcl Package 43 I.The cgi. First the url and html values are formatted into one list. the command is generated from this: list set variable value Using the list command ensures that the result will always be a valid Tcl command that sets the variable to the given value. he has defined a whole suite of Tcl commands similar to the P and H2 procedures shown in this chapter that automatically emit the matching close tags. Don Libes has created a comprehensive package for CGI scripts known as cgi.gov/cgi. This is the topic of Chapter 18. The next few chapters describe basic Tcl commands and data structures. They could do that now. Tcl Basics There are two lists.tcl. Next Steps There are a number of details that can be added to this example. He also has support procedures to deal with browser cookies. the whole Tcl command is formed as a list.tcl Package The cgilib. You should ask your local Webmaster for help if you want to try this out on your local Web site. We return to the CGI example in Chapter 11 on regular expressions.tcl/ One of Don’s goals in cgi. and other CGI features. They might also like a chance to check the results of their registration and make changes before committing them.nist. In simplified form. This requires another page that displays their guest entry as it would appear on a page. The Tcl Web Server comes with this guestbook example already set up. You can find it on the Web at http://expect. page redirects. .tcl was to eliminate the need to directly write any HTML markup at all. This list will be the value of the array element. plus it has a number of other very interesting ways to generate pages.tcl file included with this book just barely scratches the surface of things you might like to do in a CGI script. My own taste in Web page generation has shifted from CGI to a template-based approach supported by the Tcl Web Server. Instead.

Blank page 44 .

last. S The string Command The string command is really a collection of operations you can perform on strings. Chapter 11 describes a more complex and powerful regular expression pattern matching mechanism. wordend. A closely related topic is pattern matching. scan. or wordstart 45 . trings are the basic data item in Tcl. match.C H A P T E R 4 I. The string command is a collection of several useful string manipulation operations. in which string comparisons are made more powerful by matching a string against a pattern. compare. replace. You can ask string for valid operations by giving it a bad one: string junk => bad option "junk": should be bytelength. append. first. Tcl commands described are: string. range. set name "Brent Welch" string length $name => 11 The first argument to string determines the operation. trimleft. trim. index. equal. format. totitle. repeat. so it should not be surprising that there are a large number of commands to manipulate strings. Tcl Basics String Processing in Tcl 4 This chapter describes string manipulation and simple pattern matching. tolower. length. The following example calculates the length of the value of a variable. and binary. is. toupper. map. trimright. This chapter describes a simple pattern matching mechanism that is similar to that used in many other shell languages.

Returns the range of characters in str from i to j. Use -nocase for case insensitve comparison. Returns a new string created by mapping characters in string according to the input. Returns the index in str2 of the last occurrence of str1. then varname is assigned the index of the character in string that prevented it from being a member of class. An index counts from zero. or upper case. and the rest with lower case. Returns string in lower case. output list in charMap. Returns 1 if str matches the pattern. else 1. Returns the index in str2 of the first occurrence of str1. If -strict. Returns a new string created by replacing characters first through last with newstr. See Table 4–3 on page 50 for character class names. which may be different from the character length returned by string length because of UTF-8 encoding. then empty strings never match. Table 4–1 summarizes the string command. Globstyle matching is used. else 0. Table 4–1 The string command. string compare ?-nocase? Compares strings lexicographically. string equal ?-nocase? str1 str2 string first str1 str2 string index string index string is class ?-strict? ?-failindex varname? string Compares strings and returns 1 if they are the same. Returns 1 if string belongs to class. or -1 if str1 is not found. first and last determine the range of string on which to operate.46 String Processing in Tcl Chap. 4 This trick of feeding a Tcl command bad arguments to find out its usage is common across many commands. or nothing. Use end for the last character. See page 210 of Chapter 15 about Unicode and UTF-8. string last str1 str2 string length string string map ?-nocase? charMap string string match pattern str string range str i j string repeat str count string replace str first last ?newstr? string tolower string ?first? ?last? string totitle string ?first? ?last? . otherwise they always match. Returns the number of characters in string. first and last determine the range of string on which to operate. Returns str repeated count times. Use -nocase for ?-length len? str1 str2 case insensitve comparison. -1 if str1 sorts before str2. or -1 if str1 is not found. See page 51. If -failindex is specified. Use -length to limit the comparison to the first len characters. Returns the character at the specified index. Capitalizes string by replacing its first character with the Unicode title case. See page 48. string bytelength str Returns the number of bytes used to store a string. Returns 0 if equal.

String classes are listed in Table 4–3 on page 50. Trims the characters in chars from the end of string. which is shown in Example 4–2 on page 48. totitle. String match.. These new operations were added in Tcl 8.1 added syntax for specifying an index relative to the end. Specify end-N to get the Nth caracter before the end.1 (actually.The string Command Table 4–1 The string command.) • The repeat and replace operations. • The totitle operation. For example. Returns the index in str of the character after the word containing the character at index ix. chars defaults to whitespace. and trimleft operations are handy for cleaning up strings. like the Unix tr command. String Indices Several of the string operations involve string indices that are positions within a string. chars defaults to whitespace. Trims the characters in chars from the beginning of string. Returns the index in str of the first character in the word containing the character at index ix.g. These are the string operations I use most: • • • • The equal operation. • The is operation that test for kinds of strings.1. the following command returns a new string that drops the first and last characters from the original: string range $string 1 end-1 . they first appeared in the 8. chars defaults to whitespace. The trim. The special index end is used to specify the last character in a string: string range abcd 2 end => cd Tcl 8. The tolower. (Continued) 47 I. Tcl Basics string toupper string ?first? ?last? string trim string ?chars? string trimleft string ?chars? string trimright string ?chars? string wordend str ix string wordstart str ix Returns string in upper case. This pattern matching operation is described on page 48. • The map operation that translates characters (e. which is handy for capitalizing words. first and last determine the range of string on which to operate. which is simpler than using string compare. Trims the characters in chars from both ends of string.1 patch release): • The equal operation. Tcl counts characters in strings starting with zero. and toupper operations convert case. trimright.

Strings and Expressions Strings can be compared with expr. and then converts them back if it detects a case of string comparison. < and >. The conversion back is always done as a decimal number. wordend. . Like the C library strcmp function.48 String Processing in Tcl Chap. you must group the expression with curly braces to prevent the double quotes from being stripped off by the main interpreter: if {$x == "foo"} command expr is unreliable for string comparison. If you find yourself using combinations of these operations to pick apart data. you must quote the string value so that the expression parser can identify it as a string type. 4 There are several operations that pick apart strings: first. Then. if {[string equal $s1 $s2]} { # strings are equal } String Matching The string match command implements glob-style pattern matching that is modeled after the file name pattern matching done by various UNIX shells. it will be faster if you can do it with the regular expression pattern matcher described in Chapter 11. string compare returns 0 if the strings are equal. last. and while using the comparison operators ==. if. The following boolean expression is true! if {"0xa" == "10"} { puts stdout ack! } => ack! A safe way to compare strings is to use the string compare and equal operations. !=. and range. However. index. wordstart. Ironically. there are a number of subtle issues that can cause problems. or 1 if the first string is greater than the second: Example 4–1 Comparing strings with string compare. the expression evaluator first converts items to numbers if possible.1 makes this simpler: Example 4–2 Comparing strings with string equal. if {[string compare $s1 $s2] == 0} { # strings are equal } The string equal command added in Tcl 8. minus 1 if the first string is lexicographically less than the second. First. despite the quotes. These operations work faster because the unnecessary conversions are eliminated. This can lead to unexpected conversions between strings that look like hexadecimal or octal numbers.

like one or more characters from a set. Any letter. then you need to use regular expression matching. [a-z] represents the set of all lower-case letters. Any other characters in a pattern are taken as literals that must match the input exactly. If you need to include a literal *. digit. For example. Another approach is to put the pattern into a variable: set pat {[ab]*x} string match $pat box => 1 You can specify a range of characters with the syntax [x-y]. and Tcl preserves this historical oddity in the glob command that does pattern matching on file names. The following example matches all strings that begin with a: string match a* alpha => 1 To match all two-letter strings: string match ?? XY => 1 To match all strings that begin with either a or b: string match {[ab]*} cello => 0 Be careful! Square brackets are also special to the Tcl interpreter. ?. The glob command is described on page 115. preface it with a backslash: string match {*\?} what? => 1 In this case the pattern is quoted with curly braces because the Tcl interpreter is also doing backslash substitutions. * ? [chars] Match any number of any characters. you would have . or the underscore is matched with: string match {[a-zA-Z0-9_]} $char The set matches only a single character. Match any character in chars. You can include more than one range in a set. Tcl Basics The heritage of the word "glob" is rooted in UNIX.The string Command 49 I. Without the braces. so you will need to wrap the pattern up in curly braces to prevent it from being interpreted as a nested command. To match more complicated patterns. which is described on page 148. or bracket in your pattern. Table 4–2 shows the three constructs used in string match patterns: Table 4–2 Matching characters used with string match. Match exactly one character. and [0-9] represents all the digits.

string match *\\? what? Character Classes The string is command tests a string to see whether it belongs to a particular class. Alphabet. Any alphabet character. true. alpha includes many characters outside the range of [AZa-z] because of different characters in other alphabets. The classes are listed in Table 4–3. Character code less than 32. Table 4–3 Character class names. alnum alpha ascii boolean control digit double false graph integer lower print punct space true upper wordchar xdigit Any alphabet or digit character. A synonym for alnum. They are replaced with a single backslash by Tcl before string match is called. . A string in all lower case. 1. This is useful for input validation. For example. you do: if {![string is integer $input]} { error "Invalid input. 1 or true (in any case). 4 to use two backslashes. and the underscore.) 0.50 String Processing in Tcl Chap." } Classes are defined in terms of the Unicode character set. 0 or false (in any case). A valid floating point number. Valid hexadecimal digits. Any punctuation character. which means they are more general than specifying character sets with ranges over the ASCII encoding. to make sure something is a number. backspace. Any character with a 7-bit character code (i. carriage return. newline. Please enter a number. A string all in upper case. For example. A valid integer. digit.. not including space characters. false (in any case). less than 128. Any printing characters. Any digit character.e. Space. tab. and not NULL. vertical tab.

The append Command


I. Tcl Basics

Mapping Strings The string map command translates a string based on a character map. The map is in the form of a input, output list. Whereever a string contains an input sequence, that is replaced with the corresponding output. For example:
string map "food" {f p d l} => pool

The inputs and outputs can be more than one character and do not have to be the same length:
string map "food" {f p d ll oo u} => pull

Example 4–3 is more practical. It uses string map to replace fancy quotes and hyphens produced by Microsoft Word into ASCII equivalents. It uses the open, read, and close file operations that are described in Chapter 9, and the fconfigure command described on page 223 to ensure that the file format is UNIX friendly.
Example 4–3 Mapping Microsoft World special characters to ASCII.

proc Dos2Unix {filename} { set input [open $filename] set output [open $filename.new] fconfigure $output -translation lf puts $output [string map { \223 " \224 " \222 ’ \226 } [read $input]] close $input close $output }

The append Command
The append command takes a variable name as its first argument and concatenates its remaining arguments onto the current value of the named variable. The variable is created if it does not already exist:
set foo z append foo a b c set foo => zabc

The append command is efficient with large strings. The append command provides an efficient way to add items to the end of a string. It modifies a variable directly, so it can exploit the memory allocation scheme used internally by Tcl. Using the append command like this:


String Processing in Tcl

Chap. 4

append x " some new stuff"

is always faster than this:
set x "$x some new stuff"

The lappend command described on page 61 has similar performance benefits when working with Tcl lists.

The format Command
The format command is similar to the C printf function. It formats a string according to a format specification:
format spec value1 value2 ...

The spec argument includes literals and keywords. The literals are placed in the result as is, while each keyword indicates how to format the corresponding argument. The keywords are introduced with a percent sign, %, followed by zero or more modifiers, and terminate with a conversion specifier. Example keywords include %f for floating point, %d for integer, and %s for string format. Use %% to obtain a single percent character. The most general keyword specification for each argument contains up to six parts: position specifier flags field width precision word length conversion character These components are explained by a series of examples. The examples use double quotes around the format specification. This is because often the format contains white space, so grouping is required, as well as backslash substitutions like \t or \n, and the quotes allow substitution of these special characters. Table 4–4 lists the conversion characters:
Table 4–4 Format conversions.

• • • • • •

d u i o x or X c s f

Signed integer. Unsigned integer. Signed integer. The argument may be in hex (0x) or octal (0) format. Unsigned octal. Unsigned hexadecimal. ‘x’ gives lowercase results. Map from an integer to the ASCII character it represents. A string. Floating point number in the format a.b.

The format Command Table 4–4 Format conversions. (Continued)


I. Tcl Basics

e or E g or G

Floating point number in scientific notation, a.bE+-c. Floating point number in either %f or %e format, whichever is shorter.

A position specifier is i$, which means take the value from argument i as opposed to the normally corresponding argument. The position counts from 1. If a position is specified for one format keyword, the position must be used for all of them. If you group the format specification with double quotes, you need to quote the $ with a backslash:
set lang 2 format "%${lang}\$s" one un uno => un

The position specifier is useful for picking a string from a set, such as this simple language-specific example. The message catalog facility described in Chapter 15 is a much more sophisticated way to solve this problem. The position is also useful if the same value is repeated in the formatted string. The flags in a format are used to specify padding and justification. In the following examples, the # causes a leading 0x to be printed in the hexadecimal value. The zero in 08 causes the field to be padded with zeros. Table 4–5 summarizes the format flag characters.
format "%#x" 20 => 0x14 format "%#08x" 10 => 0x0000000a
Table 4–5 Format flags.

+ space 0 #

Left justify the field. Always include a sign, either + or -. Precede a number with a space, unless the number has a leading sign. Useful for packing numbers close together. Pad with zeros. Leading 0 for octal. Leading 0x for hex. Always include a decimal point in floating point. Do not remove trailing zeros (%g).

After the flags you can specify a minimum field width value. The value is padded to this width with spaces, or with zeros if the 0 flag is used:
format "%-20s %3d" Label 2 => Label 2

You can compute a field width and pass it to format as one of the arguments by using * as the field width specifier. In this case the next argument is used as the field width instead of the value, and the argument after that is the value that

0 added support for binary strings. For %g it indicates the total number of significant digits used. It returns the number of successful conversions it made. The scan Command The scan command parses a string according to a format specification and assigns values to variables. The scan format includes a set notation.2d" 1 1 => 1. For %d and %x it indicates how many digits will be printed. The %c scan format converts one character to its decimal value. Tcl now uses counted strings. then characters not in the set match. which foils the manipulation of some types of data.. you will want to protect the format with braces. For %f and %e it indicates how many digits come after the decimal point. The binary Command Tcl 8. or use backslashes. If the first character in the set is ^. and it is specified with a period and a number.. Use square brackets to delimit a set of characters. format "%6.54 String Processing in Tcl Chap. so it can tolerate a null byte in a string value without truncating it. then it is considered part of the set. because square brackets are special to the Tcl parser. 4 gets formatted. The set matches one or more characters that are copied into the variable. As in the previous example. . Previous versions of Tcl used null-terminated strings internally. The following scans a field of all lowercase letters. A dash is used to specify a range.00 01 The storage length part comes last but it is rarely useful because Tcl maintains all floating point values in double-precision. Nothing special is required to include a left square bracket in the set. There is no %u scan format. The format for scan is nearly the same as in the format command. put a right square bracket immediately after the ^ to include it in the set. set maxl 8 format "%-*s = %s" $maxl Key Value => Key = Value The precision comes next. padding with zeros if necessary.2f %6. Again. and all integers as long words. The general form of the command is: scan string format var ?var? ?var? . scan abcABC {%[a-z]} result => 1 set result => abc If the first character in the set is a right square bracket.

For example. A 16-bit integer in big-endian byte order. Padded with spaces in binary format. A 32-bit integer in big-endian byte order.? The binary scan command extracts values from a binary string according to a similar template. Low-to-high order. The count is for repetition. a A b B h H c s S i I f d x X @ A character string of length count. Backup count bytes. A character string of length count. For types like integer (i) and double (d).) An 8-bit character code. Tcl Basics This section describes the binary command that provides conversions between strings and packed binary data representations. count is for repetition. A binary string of length count. A 16-bit integer in little-endian byte order. Double-precision floating point value in native format. Single-precision floating point value in native format.. count is for repetition.. Table 4–6 Binary conversion types. count is the optional count following the type letter. The count is for repetition. In the table. High-to-low order. The count is for repetition. A hexadecimal string of length count. The resulting binary value is returned: binary format template value ?value .The binary Command 55 I. i3 means three . skip to the end. Low-to-high order. this is useful for extracting data stored in binary format. The count is interpreted differently depending on the type. The count is for repetition. Padded with nulls in binary format. A hexadecimal string of length count.g. (More commonly used than h.. If count is *. The binary format command takes values and packs them according to a template. For example. Pack count null bytes with binary format.? Format Templates The template consists of type keys and counts. A 32-bit integer in little-endian byte order.. It assigns values to a set of Tcl variables: binary scan value template variable ?variable . The count is for repetition. The types are summarized in Table 4–6. this can be used to format a floating point vector in memory suitable for passing to Fortran. Skip to absolute position specified by count. A binary string of length count. High-to-low order. Trailing nulls and blanks are discarded in binary scan.. the count is a repetition count (e. Skip count bytes with binary scan.

As a special case. If count is *. The X key backs up count bytes. @* skips to the end of the data.. and the H type specifies nybbles from high-to-low order. If you want each character code in a separate variable. The B and H formats match the way you normally write out numbers. Note that the official byte order for data transmitted over a network is big-endian. The c type returns these character codes: set input 6 binary scan $input "c" 6val set 6val => 54 You can scan several character codes at a time: binary scan abc "c3" list => 1 set list => 97 98 99 The previous example uses a single type key. the count is a length (e. A hexadecimal string specifies 4 bits (i. is the character 6 with character code 54 or 0x36. 4 integers). Different integer sizes are 16-bit (s or S). SPARC and Motorola). If no count is specified. and possibly 64-bit (l or L) on those machines that support 64-bit integers. the A type strips trailing blanks and nulls. A binary string consists of zeros and ones. Several type keys can be specified in a template. and it skips over bytes in binary scan. then binary scan uses all the remaining bytes in the value. A "6". The type keys are lowercase for little-endian byte order (e. In binary scan. remember that Tcl treats things as strings by default. For strings. and the B type specifies bits from high-to-low order. for example. There are three string types: character (a or A). Intel) and uppercase for big-endian byte order (e.g. The @ key uses its count as an absolute byte offset to which to set the cursor. binary (b or B). use separate type keys: . so it only makes sense to format and scan these values on the same machine. 32-bit (i or I). so binary scan sets one corresponding Tcl variable. a3 means a three-character string).e.g. Each key-count combination moves an imaginary cursor through the binary data. and hexadecimal (h or H). The h type specifies nybbles from low-to-high order.56 String Processing in Tcl Chap. The b type specifies bits from low-to-high order. With these types the count is the length of the string. nybbles) with each character. Examples When you experiment with binary format and binary scan. There are special type keys to move the cursor.. it defaults to 1. Numeric types have a particular byte order that determines how their value is laid out in memory.g. The x key generates null bytes in binary format. it is truncated.. The a type pads its value to the specified length with null bytes in binary format and the A type pads its value with spaces. Floating point values are always machine-specific.. If the value is too long.

45 7. Binary Data and File I/O When working with binary data in files. if necessary.2 3.03e4 Remember that floating point values are always in native format. The tcl_platform variable described on page 182 can tell you the byte order of the current platform. Assume the vector is read from a binary data file: binary scan $vector "@8d" double With binary format. Note that A trims trailing spaces: binary scan "hello world " a3x2A* first second puts "\"$first\" \"$second\"" => "hel" " world" Use the @ key to seek to a particular offset in a value. These are described in more detail on pages 114 and 209.43 -45. The value is truncated if the string is too long: binary format "A9A3" hello world => hello wor An array of floating point values can be created with this command: binary format "f*" 1. Here the * count is used to get all the rest of the string. you need to turn off the newline translations and character set encoding that Tcl performs automatically.The binary Command 57 I. so you have to read them on the same type of machine that they were created.67 1. the a and A types create fixed width fields. For example. if you are generating binary data. With integer data you specify either big-endian or little-endian formats. A pads its field with spaces. the following command puts your standard output in binary mode: fconfigure stdout -translation binary -encoding binary puts [binary format "B8" 11001010] . The following command gets the second double-precision number from a vector. Tcl Basics binary scan abc "ccc" x y z => 3 set z => 99 Use the H format to get hexadecimal values: binary scan 6 "H2" 6val set 6val => 36 Use the a and A formats to extract fixed width fields.

58 String Processing in Tcl Chap. . • For more about pattern matching. read about regular expressions in Chapter 11. see Chapter 9. • For information on Unicode and other Internationalization issues. • For more about file I/O. see Chapter 15. read about lists in Chapter 5 and arrays in Chapter 8. 4 Related Chapters • To learn more about manipulating data in Tcl.

C H A P T E R 5 I. lreplace. L Tcl Lists A Tcl list is a sequence of values. Tcl commands provide operations to put values into a list. lindex. which are described in Chapter 11. However. Tcl commands described are: list. Braces or quotes can be used to group words with white space into a single list element. Delayed command evaluation with eval is described in Chapter 10. Lists are used with commands such as foreach that take lists as arguments. linsert. 59 . it is best to think of lists in terms of operations instead of syntax. replace elements of lists. Tcl lists are not often the right way to build complicated data structures in scripts. and they are the topic of Chapter 8. and split. However. when you work with Tcl lists. concat. You may find Tcl arrays more useful. count the elements of lists. lists are important when you are building up a command to be evaluated later. especially when you have to group arguments to the list commands themselves. In addition. A list has its elements separated by white space. join. lrange. llength. ists in Tcl have the same structure as Tcl commands. Use regular expressions instead. get elements from lists. List operations are also not right for handling unstructured data such as user input. it has the same syntax as a Tcl command. All the rules you learned about grouping arguments in Chapter 1 apply to creating valid Tcl lists. and similar issues with Tk callback commands are described in Chapter 27. When you write out a list. lsearch. and so on. lappend. The syntax can sometimes be confusing. lsort. Tcl Basics Tcl Lists 5 This chapter describes Tcl lists.

Tcl lists are just strings with a special interpretation. -command command. -dictionary.. consider changing your code to use arrays instead. -glob is the default. 5 Because of the relationship between lists and commands. the cost of accessing an element was proportional to the number of elements before it in the list. lindex list i llength list lrange list i j lappend listVar arg arg . Returns -1 if not found.. Before Tcl 8. Accessing the first element costs the same as accessing any other element in the list.0. -increasing. A list with a few elements will not slow down your code much. Returns a new list.60 Tcl Lists Chap. using the characters in splitChars as boundaries between list elements.. Returns the number of elements in list.. -index ix... computing the length required reading the whole list. Returns the index of the element in list that matches the value according to the mode. integer. concat list list . Joins multiple lists together into one list. The string representation must be parsed on each list access. Before Tcl 8. Returns a new list.0. Appends elements to the value of listVar. The performance of lists was improved by the Tcl compiler added in Tcl 8. The internal format also records the number of list elements. Table 5–1 briefly describes the Tcl commands related to lists. lreplace list i j arg arg . Table 5–1 List-related commands. so be careful when you use large lists.0. which is -exact. Returns the ith through jth elements from list. Replaces elements i through j of list with the args. Inserts elements into list before the element at position index. or regexp.. Unlike list data structures in other languages. Returns a new list. list arg1 arg2 . Splits a string up into list elements.. Merges the elements of a list together by separating them with joinString.0. A list with hundreds or thousands of elements can be very slow. so getting the length of a list is cheap.. Big lists were often slow before Tcl 8. the list-related commands described in this chapter are used often when constructing Tcl commands. linsert list index arg arg . -decreasing. lsearch ?mode? list value lsort ?switches? list Creates a list out of all its arguments. The compiler stores lists in an internal format that requires constant time to access. join list joinString split string splitChars . If you find yourself maintaining large lists that must be frequently accessed. -real. Sorts elements of the list according to the switches: -ascii. Returns the ith element from list.. -glob.

The automatic quoting is very useful. and the examples in this book use the list command frequently. you can do this by hand.Constructing Lists 61 I. In the first step. When I first experimented with Tcl lists. the list command takes care of all these details automatically. the Tcl parser groups arguments. so quoting is required. We are taking a risk by not quoting $y because we know it doesn’t contain spaces. If its value changes in the future. In simple cases. I became confused by the treatment of curly braces. Also. the structure of the list can change and even become invalid. Example 5–1 Constructing a list with the list command. two of which contain special characters. set x {1 2} => 1 2 set y foo => foo set l1 [list $x "a b" $y] => {1 2} {a b} foo set l2 "\{$x\} {a b} $y" => {1 2} {a b} foo The list command does automatic quoting. they come back again when $x is put into a bigger list. However. you should use Tcl commands that take care of quoting so that the syntax comes out right. the double quotes around a b get changed into curly braces. In the assignment to x. however. The list command The list command constructs a list out of its arguments so that there is one list element for each argument. Compare the use of list with doing the quoting by hand in Example 5–1. the list command adds quoting to ensure that they are parsed as a single element of the resulting list. We also have to know in advance that $x contains a space. If any of the arguments contain special characters. but we need to group the result so that it remains a single list element. In contrast. . This may require quoting to get the list elements into the right groups. In the second step. The assignment of l2 requires carefully constructing the first list element by using quoted braces. The list command uses curly braces to group values back into list elements. for example. the curly braces disappear. Tcl Basics Constructing Lists Constructing a list can be tricky because you must maintain proper list syntax. These syntax characters get stripped off. In the grouping process. the braces and quotes are syntax that define groups. The braces must be turned off so that $x can be substituted. What’s going on? Remember that there are two steps. In more complex cases. The next example uses list to create a list with three values. the list command creates a valid Tcl list. The braces and quotes are not part of the value.

However. separating them with spaces. and the rest of the arguments are added to the variable’s value as new list elements. the concat command trims extra white space from the end of its arguments before joining them together with a single separating space character. 5 The lappend Command The lappend command is used to append elements to the end of a list. double quotes behave exactly like concat. This joins multiple lists into one list where the top-level list elements in each input list become top-level list elements in the resulting list: Example 5–3 Using concat to splice lists together.62 Tcl Lists Chap. Like list. lappend new => 1 2 lappend new => 1 2 3 {4 set new => 1 2 3 {4 1 2 3 "4 5" 5} 5} The lappend command is unique among the list-related commands because its first argument is the name of a list-valued variable. You can call lappend with the name of an undefined variable and the variable will be created. The lappend command is implemented efficiently to take advantage of the way that Tcl stores lists internally. The first argument to lappend is the name of a Tcl variable. set x {4 5 6} set y {2 3} set z 1 concat $z $y $x => 1 2 3 4 5 6 Double quotes behave much like the concat command. concat. Example 5–2 Using lappend to add elements to a list. while all the other commands take list values as arguments. In simple cases. It is always more efficient to use lappend than to try and append elements by hand. lappend preserves the structure of its arguments. It may add braces to group the values of its arguments so that they retain their identity as list elements when they are appended onto the string representation of the list. The concat Command The concat command is useful for splicing lists together. and double quotes: . Example 5–4 compares the use of list. It works by concatenating its arguments.

The distinction can be subtle because there are examples where list and concat return the same results.2}] lindex $list end-1 The lrange command returns a range of list elements. or the syntax end-N to count back from the end of the list. and lrange Example 5–4 Double quotes compared to the concat and list commands. llength {a b {c d} "e f g" h} => 5 llength {} => 0 The lindex command returns a particular element of a list. The basic rule is that list and lappend preserve list structure. set x {1 2 3} lindex $x 1 => 2 You can use the keyword end to specify the last element of a list. It takes an index. lindex. This issue is discussed more in Chapter 10. lindex. Getting List Elements: llength. you will see the list command used to safely construct lists. list indices count from zero. Tcl Basics set x {1 2} => 1 2 set y "$x 3" => 1 2 3 set y [concat $x 3] => 1 2 3 set s { 2 } => 2 set y "1 $s 3" => 1 2 3 set y [concat 1 $s 3] => 1 2 3 set z [list $x $s 3] => {1 2} { 2 } 3 The distinction between list and concat becomes important when Tcl commands are built dynamically. end or end-N can be used as an index: lrange {1 2 3 {4 5}} 2 end => 3 {4 5} . lindex $list [expr {[llength $list] . The following commands are equivalent ways to get the element just before the last element in a list. Unfortunately. and lrange The llength command returns the number of elements in a list. Again.Getting List Elements: llength. while concat (or double quotes) eliminates one level of list structure. this can lead to data-dependent bugs. Throughout the examples of this book. It takes a list and two indices as arguments. 63 I.

Instead. the glob pattern l* matches the value list. Otherwise. 5 Modifying Lists: linsert and lreplace The linsert command inserts elements into a list value at a specified index. and this can be disabled with the -exact flag. If you don’t specify any new elements. you effectively delete elements from a list. If the index is zero or less. If the index is equal to or greater than the length of the list. Note: linsert and lreplace do not modify an existing list. The value is found with lsearch. or -1 if it is not present. the lreplace command does not change the value of x: Example 5–5 Modifying lists with linsert and lreplace. Regular expressions are described in Chapter 11. lsearch supports pattern matching in its search. proc ldelete { list value } { set ix [lsearch -exact $list $value] if {$ix >= 0} { return [lreplace $list $ix $ix] } else { return $list } } . The value is removed with an lreplace that does not specify any replacement list elements: Example 5–6 Deleting a list element by value. Glob-style pattern matching is the default. In the following example. linsert {1 2} 0 new stuff => new stuff 1 2 set x [list a {b c} e d] => a {b c} e d lreplace $x 1 2 B C => a B C d lreplace $x 0 0 => {b c} e d Searching Lists: lsearch lsearch returns the index of a value in the list. The -regexp option lets you specify the list value with a regular expression. lsearch {here is a list} l* => 3 Example 5–6 uses lreplace and lsearch to delete a list element by value. In the following example.64 Tcl Lists Chap. the elements are inserted before the element that is currently at the specified index. they return a new list value. lreplace replaces a range of list elements with new elements. then the elements are added to the front. The semantics of glob pattern matching is described in Chapter 4. then the elements are appended to the end.

or -real options. An ASCII sort uses character codes. suppose you have a list of names. For example: lsort -ascii {a Z n2 n100} => Z a n100 n2 lsort -dictionary {a Z n2 n100} => a n2 n100 Z You can provide your own sorting function for special-purpose sorting.Sorting Lists: lsort 65 I. The list is not sorted in place.0 added a -index option to lsort that can be used to sort lists on an index. middle name (if any). Tcl Basics Sorting Lists: lsort You can sort a list in a variety of ways with lsort. -dictionary. The default option set is -ascii -increasing. Welch} {John Ousterhout} {Miles Davis} lsort -command NameCompare $list => {Miles Davis} {John Ousterhout} {Brent B. proc NameCompare {a b} { set alast [lindex $a end] set blast [lindex $b end] set res [string compare $alast $blast] if {$res != 0} { return $res } else { return [string compare $a $b] } } set list {{Brent B. then it just compares the whole of each argument. and a dictionary sort folds together case and treats digits like numbers. -integer. and last name. Welch} {John Ousterhout} {Miles Davis}} => {Brent B. Example 5–7 Sorting a list using a comparison function. you need to supply a sorting command. The basic types of sorts are specified with the -ascii. The -increasing or -decreasing option indicate the sorting order. Instead of using NameCompare. you could do this: lsort -index end $list The split Command The split command takes a string and turns it into a list by breaking it at specified characters and ensuring that the result has the proper list syntax. Welch} The NameCompare procedure extracts the last element from each of its arguments and compares those. The default sorts by everyone’s first name. The split command provides a robust way to turn input lines into proper Tcl lists: . For example. a new list value is returned. Instead. If they are equal. Tcl 8. where each element is itself a list containing the person’s first name. If you want to sort by their last name.

66 Tcl Lists Chap. tabs. your script will raise an error. world. if you write scripts that process data one character at a time." split $line \ . these result in empty list elements. You could also group the argument to split with double quotes: set line "\tHello. the separators are not collapsed. occurs in the middle of the list. If there are multiple separator characters in a row. 5 set line {welch:*:28405:100:Brent Welch:/usr/welch:/bin/csh} split $line : => welch * 28405 100 {Brent Welch} /usr/welch /bin/csh lindex [split $line :] 4 => Brent Welch Do not use list operations on arbitrary data. and newlines. set line {this is "not a tcl list} lindex $line 1 => unmatched open quote in list lindex [split $line] 2 => "not The default separator character for split is white space.\t => {} Hello {} world {} A trick that splits each character into a list element is to specify an empty string as the split character. periods. they may run slowly. but when invalid list syntax appears in the input. The syntax error. The next example shows what happens when input is not a valid list. Your code will work with simple test cases. you should be careful when using list operators on arbitrary input data. Read Chapter 11 about regular expressions for hints on really efficient string processing. The backslash–space sequence is used to include a space in the set of characters. you cannot access any of the list because the lindex command tries to convert the value to a list before returning any part of it. However. This lets you get at individual characters with list operations: split abc {} => a b c However. . Otherwise. stray double quotes or curly braces in the input can result in invalid list structure and errors in your script. Even if your data has space-separated words. an unmatched quote. Example 5–8 Use split to turn input data into Tcl lists. The following command splits on commas. which contains spaces. spaces. and tabs..

• List operations are used when generating Tcl code dynamically. which may help to understand the process: Example 5–9 Implementing join in Tcl. They are described in Chapter 8. Chapter 10 describes these techniques when using the eval command.The join Command 67 I. remember that the first value is parsed into a list. Tcl Basics The join Command The join command is the inverse of split. In doing so. For example: join {1 {2 3} {4 5 6}} : => 1:2 3:4 5 6 If the treatment of braces is puzzling. It takes a list value and reformats it with specified characters separating the list elements. . it removes any curly braces from the string representation of the list that are used to group the top-level elements. The braces around element values disappear in the process. Example 5–9 shows a way to implement join in a Tcl procedure. proc join {list sep} { set s {} . • The foreach command loops over the values in a list. It is described on page 73 in Chapter 6.# s is the current separator set result {} foreach x $list { append result $s $x set s $sep } return $result } Related Chapters • Arrays are the other main data structure in Tcl.

Blank page 68 .

it is important to group the command body with curly braces to avoid substitutions at the time the control structure command is invoked. continue. C 69 . Tcl Basics Control Structure Commands 6 This chapter describes the Tcl commands that implement control structures: if. ontrol structure in Tcl is achieved with commands. there are some commands to fine-tune control structures: break. for. and return. and error. and for. Another pleasant property of curly braces is that they group things together while including newlines. while. In this case. There are conditional commands: if and switch. Commands like if. catch. so there is no need for you to invoke expr explicitly to evaluate their boolean test expressions. A control structure command returns the value of the last command it chose to execute. and while involve boolean expressions. The examples use braces in a way that is both readable and convenient for extending the control structure commands across multiple lines. foreach. for. and let the control structure command trigger evaluation at the proper time. Group with braces. break. foreach. continue. There is an error handling command: catch. Finally. They use the expr command internally. There are looping commands: while. either conditionally or in a loop. switch. return. A control structure command often has a command body that is executed later. error. just like everything else.C H A P T E R 6 I.

The style of this example takes advantage of the way the Tcl interpreter parses commands. The stylized placement of the opening curly brace at the end of the first and third lines exploits this property to extend the if command over multiple lines. then execute one command body. you can get away without using curly braces around the command. The first argument to if is a boolean expression. like this: if [command] body1 However. The expression evaluator performs variable and command substitution on the expression. with constructs such as: if $x break continue This is a sloppy. like this: if {[command]} body1 . always use braces around the command bodies to avoid trouble later when you modify the command. if {$x == 0} { puts stderr "Divide by zero!" } else { set slope [expr $y/$x] } Curly brace positioning is important. except when the interpreter is in the middle of a group defined by braces or double quotes. 6 If Then Else The if command is the basic conditional command. I omit then but use else as illustrated in the next example. It is possible to be lax in this regard. if command that will either break out of a loop or continue with the next iteration depending on the value of variable x. it turns out that you can execute the if statement more efficiently if you always group the expression with braces.70 Control Structure Commands Chap. even in the simplest cases: Example 6–1 A conditional if then else command. If an expression is true. The second command body (the else clause) is optional. The syntax of the command is: if expression ?then? body1 ?else? ?body2? The then and else keywords are optional. otherwise. Using curly braces ensures that these substitutions are performed at the proper time. execute another command body. I always use braces around the command bodies. Instead. Recall that newlines are command terminators. albeit legitimate. In practice. As a matter of style this expression is grouped with curly braces. The following is much better (use then if it suits your taste): if {$x} { break } else { continue } When you are testing the result of a command. This style is fragile and error prone.

This is shown in Example 6–3. Uses glob-style pattern matching. } The first form allows substitutions on the patterns but will require backslashes to continue the command onto multiple lines. if {$key < 0} { incr range 1 } elseif {$key == 0} { return $range } else { incr range -1 } Any number of conditionals can be chained in this manner. No flag (or end of flags). In practice I always use the -. The second form groups all the patterns and bodies into one argument.. However. This makes it easy to group the whole command without worrying about newlines. In either case.. There are four possible flags that determine how value is matched. then this command .. See page 48. Necessary when value can begin with -. You can also group all the pattern-body pairs into one argument: switch flags value { pat1 body1 pat2 body2 . The choice can be made on the basis of pattern matching as well as simple comparisons. Again. The general form of the command is: switch flags value pat1 body1 pat2 body2 . This is the default. If multiple patterns match. but it suppresses any substitutions on the patterns. Tcl Basics You can create chained conditionals by using the elseif keyword. Uses regular expression pattern matching. Pattern matching is discussed in more detail in Chapter 4 and Chapter 11.Switch 71 I. If the pattern associated with the last body is default. the switch command provides a more powerful way to test multiple conditions. This is shown in Example 6–4 on page 72.flag before value so that I don’t have to worry about that problem. note the careful placement of curly braces that create a single if command: Example 6–2 Chained conditional with elseif. Switch The switch command is used to branch to one of many command bodies depending on the value of an expression. -exact -glob -regexp -- Matches the value exactly to one of the patterns.. Any number of pattern-body pairs can be specified. you should always group the command bodies with curly braces so that substitution occurs only on the body with the pattern that matches the value. See page 134. The switch command raises an error if any other flag is specified or if the value begins with -. only the body of the first matching pattern is evaluated.

switch -glob -. too. Example 6–5 A switch with "fall through" cases. the first and second patterns have substitutions performed to replace $key with its value and \t with a tab character. .72 Control Structure Commands Chap. return $count(foo)} default { incr count(other) } } If you have variable references or backslash sequences in the patterns. as shown in Example 6–6. The default keyword works only on the last pattern-body pair. then the switch command “falls through” to the body associated with the next pattern. (See page Chapter 11.$value { foo { doFoo. The third pattern is quoted with curly braces to prevent command substitution. You must put them inside the command body associated with a pattern. incr count(foo) } bar { doBar. switch -exact -.) If the body associated with a pattern is just a dash. -. This restricts the location of comments in a switch command. it will be treated as a pattern to match the literal string default: Example 6–3 Using switch for an exact match. switch -regexp -. square brackets are part of the regular expression syntax. If you put a comment at the same level as the patterns. then you cannot use braces around all the pattern-body pairs. the switch command will try to interpret the comment as one or more pattern-body pairs.$value \ ^$key { body1 }\ \t### { body2 }\ {[0-9]*} { body3 } In this example. 6 body is executed if no other patterns match.$value { X* Y* { takeXorYaction $value } } Comments in switch Commands A comment can occur only where the Tcl parser expects a command to begin. If you use the default pattern on an earlier body. You can tie together any number of patterns in this manner. You must use backslashes to escape the newlines in the command: Example 6–4 Using switch with substitutions in the patterns.

73 I. The following example uses gets to read standard input. Each time through the loop. Because the test expression is evaluated again before each iteration of the loop.While Example 6–6 Comments in switch commands. returning -1 upon end of file. it is crucial to protect the expression from any substitutions before the while command is invoked.5. The following is an infinite loop (see also Example 1–13 on page 12): set i 0 . set numLines 0 . The syntax for the simple case of a single variable and a single list is: foreach loopVar valueList commandBody The first argument is the name of a variable.$value { # this comment confuses switch pattern { # this comment is ok } } While The while command takes two arguments. the variable line contains the next line in the file: Example 6–7 A while loop to read standard input. The gets command returns the number of characters read. set numChars 0 while {[gets stdin line] >= 0} { incr numLines incr numChars [string length $line] } Foreach The foreach command loops over a command body assigning one or more loop variables to each of the values in one or more lists. Tcl Basics switch -. as in the next example: . while $i<10 {incr i} The following behaves as expected: set i 0 . The list can be entered explicitly. Multiple loop variables were introduced in Tcl 7. while {$i<10} {incr i} It is also possible to put nested commands in the boolean expression. a test and a command body: while booleanExpr body The while command repeatedly tests the boolean expression and then executes the body if the expression is true (nonzero). and the command body is executed once for each element in the list with the loop variable taking on successive values in the list.

the list structure will be reparsed.$state { flag { switch -glob -. Control Structure Commands Chap. The -. then the list command should be used to form the list.74 Example 6–8 Looping with foreach. The -glob option lets the user abbreviate the -force and -verbose options. The variable argv is set by the Tcl interpreter to be a list of the command-line arguments given when the interpreter was started: Example 6–9 Parsing command-line arguments. 6 set i 1 foreach value {1 3 5 7 11 13 17 19 23} { set i [expr $i*$value] } set i => 111546435 It is also common to use a list-valued variable or command result instead of a static list value.$arg { -f* {set force 1} -v* {set verbose 1} -max {set state max} default {error "unknown flag $arg"} } } max { set max $arg set state flag } } } The loop uses the state variable to keep track of what is expected next. Avoid double quotes because if any values or command results contain spaces or braces. The next example loops through command-line arguments. which can lead to errors or unexpected results. which in this example is either a flag or the integer value for -max. If the list of values is to contain variable values or command results.flag to switch is required in this example because the switch command complains about a bad flag if the pattern begins with a .character. . # argv is set by the Tcl shells # possible flags are: # -max integer # -force # -verbose set state flag set force 0 set verbose 0 set max 10 foreach arg $argv { switch -.

foreach {key value} {orange 55 blue 72 red 24 green} { puts "$key: $value" } orange: 55 blue: 72 red: 24 green: If you have a command that returns a short list of values. Tcl Basics foreach x [list $a $b [foo]] { puts stdout "x = $x" } The loop variable x will take on the value of a. Here is one way to get the values: set result [MinMax $list] set min [lindex $result 0] set max [lindex $result 1] The foreach command lets us do this much more compactly: foreach {min max} [MinMax $list] {break} The break in the body of the foreach loop guards against the case where the command returns more values than we expected. For example. If there are not enough values to assign to all the loop variables. regardless of any special characters or whitespace in those values. In the second iteration. In the first iteration of the loop. 75 I. . This trick is encapsulated into the lassign procedure in Example 10–4 on page 131. and the result of the foo command. Multiple Loop Variables You can have more than one loop variable with foreach.Foreach Example 6–10 Using list with foreach. suppose the command MinMax returns two values as a list: the minimum and maximum values. Example 6–11 Multiple loop variables with foreach. Suppose you have two loop variables x and y. x gets the first value from the value list and y gets the second value. This continues until there are no more values. x gets the third value and y gets the fourth value. then you can abuse the foreach command to assign the results of the commands to several variables all at once. the value of b. the extra variables get the empty string as their value.

for {set i 0} {$i < 10} {incr i 3} { lappend aList $i } set aList => 0 3 6 9 You could use for to iterate over a list. In this case. The foreach command keeps iterating until all values are used from all value lists. each value list can also have one or more variables. 6 Multiple Value Lists The foreach command has the ability to loop over multiple value lists in parallel. The third argument is a command to execute after the loop body: Example 6–13 A for loop. If a value list runs out of values before the last iteration of the loop. but you should really use foreach instead. foreach {k1 k2} {orange blue red green black} value {55 72 24} { puts "$k1 $k2: $value" } orange blue: 55 red green: 72 black : 24 For The for command is similar to the C for statement. its corresponding loop variables just get the empty string for their value. It takes four arguments: for initial test final body The first argument is a command to initialize the loop. Example 6–12 Multiple value lists with foreach.76 Control Structure Commands Chap. Code like the following is slow and cluttered: for {set i 0} {$i < [llength $list]} {incr i} { set value [lindex $list $i] } This is the same as: foreach value $list { } . The second argument is a boolean expression that determines whether the loop body will execute.

In practice. In interactive use.* The catch command is used to trap such errors. while the continue command causes the loop to continue with the next iteration. however. You should use curly braces to group the command instead of double quotes because catch invokes the full Tcl interpreter on the command. In Tk. or an error message if the command raises an error. There is no goto command in Tcl. An uncaught error aborts execution of a script. It takes two arguments: catch command ?resultVar? The first argument to catch is a command body. If double quotes are used. Tcl Basics Break and Continue You can control loop execution with the break and continue commands. result contains the return value } A more general catch phrase is shown in the next example. you should check the result of Tcl_Eval and take appropriate action in the case of an error. a Tcl procedure you can implement in your application. The errorInfo variable is set by the Tcl interpreter after an error to reflect the stack trace from the point of the error: * More precisely.Break and Continue 77 I. The second argument is the name of a variable that will contain the result of the command. Catch Until now we have ignored the possibility of errors. errors that arise during event handling trigger a call to bgerror. } result]} { puts stderr $result } else { # command was ok. Multiple commands are grouped into a command body. a command will raise an error if it is called with the wrong number of arguments. or a nonzero error code if it did catch an error. an extra round of substitutions occurs before catch is even called. The break command causes immediate exit from a loop. catch returns zero if there was no error caught. In your own C code. There are three cases. . if {[catch { command arg1 arg2 . the Tcl script unwinds and the current Tcl_Eval procedure in the C runtime library returns TCL_ERROR.. the Tcl shell prints the error message.. The simplest use of catch looks like the following: catch { command } A more careful catch phrase saves the result and prints an error message: Example 6–14 A standard catch phrase. or if it detects some error condition particular to its implementation.

Nonerror cases are passed up to the surrounding code by invoking return. } result] { 0 { 1 { 2 { return $result 3 { break 4 { continue default { } # # .# . or continue commands. so the if command will parse correctly. You need to be aware of this if you try to isolate troublesome code with a catch phrase. The next example uses switch to find out exactly what catch returns. 6 if {[catch { command1 command2 command3 } result]} { global errorInfo puts stderr $result puts stderr "*** Tcl TRACE ***" puts stderr $errorInfo } else { # command body ok. then curly braces would be necessary to ensure that the catch phrase was evaluated repeatedly. Catching More Than Errors The catch command catches more than just errors..# . switch [catch { command1 command2 . result of last command is in result } These examples have not grouped the call to catch with curly braces. break. This is acceptable because catch always returns an integer. or continue: Example 6–16 There are several possible return values from catch.78 Example 6–15 A longer catch phrase. these terminate the command body and are reflected by catch as nonzero return codes. An innocent looking return command will cause the catch to signal an apparent error. If the command body contains return. break. However.. Control Structure Commands Chap. if we had used while instead of if.# # Normal completion } Error case } return from procedure} break out of the loop} continue loop} User-defined error codes } .

then the Tcl interpreter uses this to initialize the errorInfo global variable. and the associated error message: POSIX ENOENT {No such file or directory} In addition.. if {[catch {foo} result]} { global errorInfo set savedInfo $errorInfo # Attempt to handle the error here. machine-readable description of the error.. That variable is used to collect a stack trace from the point of the error. the error name (e. Tcl Basics Error The error command raises an error condition that terminates a script unless it is trapped with the catch command. then the error command itself is used to initialize the errorInfo trace. error $result $savedInfo } The code argument specifies a concise. It is stored into the global errorCode variable. The command takes up to three arguments: error message ?info? ?code? The message becomes the error message stored in the result variable of the catch command. the error command itself appears in the trace. In the next example. Many of the file system commands return an errorCode that has three elements: POSIX. proc foo {} { error bogus } foo => bogus set errorInfo => bogus while executing "error bogus" (procedure "foo" line 2) invoked from within "foo" In the previous example. but cannot. . the information from the original error is preserved: Example 6–18 Preserving errorInfo when calling error.Error 79 I. ENOENT). Example 6–17 Raising an error. your application can define error codes of its own.. If the info argument is not provided. Catch phrases can examine the code in the global errorCode variable and decide how to respond to the error. It defaults to NONE.g. One common use of the info argument is to preserve the errorInfo that is available after a catch. If the info argument is provided.

The -code error option makes return behave much like the error command. The complete syntax is: return ?-code c? ?-errorinfo i? ?-errorcode ec? string The -code option value is one of ok. These -code options to return enable the construction of new control structures entirely in Tcl. then the calling procedure breaks out of a loop. I also use return at the end of a procedure. then the calling procedure returns. 6 Return The return command is used to return from a procedure. break. If -code break is specified. or if a constant value needs to be returned. It is needed if return is to occur before the end of the procedure body. Compare Example 6–17 with Example 6–19: Example 6–19 Raising an error with return. The -errorcode option sets the global errorCode variable. even though a procedure returns the value of the last command executed in the body. The following example implements the break command with a Tcl procedure: proc break {} { return -code break } . break. and if -code continue is specified. When you use return -code error. Exceptional return conditions can be specified with some optional arguments to return. return. As a matter of style. or an integer. and continue code options take effect in the caller of the procedure doing the exceptional return.80 Control Structure Commands Chap. ok is the default if -code is not specified. error. there is no error command in the stack trace. and the -errorinfo option initializes the errorInfo global variable. proc bar {} { return -code error bogus } catch {bar} result => 1 set result => bogus set errorInfo => bogus while executing "bar" The return. continue. If -code return is specified. then the calling procedure continues to the next iteration of the loop.

and upvar. The scope of a variable is the range of commands over which it is defined. The return command can be used to return a specific value. In addition. Originally.C H A P T E R 7 I. Tcl had one global scope for shared variables. Namespaces are described in Chapter 14. Tcl Basics Procedures and Scope 7 Procedures encapsulate a set of commands. and one global scope for procedures. global. Tcl 8. Commands described are: proc. which is added to the set of commands understood by the Tcl interpreter. a Tcl procedure is used just like any other Tcl command. and they introduce a local scope for variables. local scopes within procedures. It takes three arguments: proc name params body The first argument is the procedure name. each procedure has a new local scope for variables. The last argument is the body of the procedure. The second argument is a list of parameter names. The result of the procedure is the result returned by the last command in the body. Procedure names do not conflict with variable names. each argument is assigned to the corresponding parameter and the body is evaluated. rocedures parameterize a commonly used sequence of commands. P The proc Command A Tcl procedure is defined with the proc command. 81 .0 added namespaces that provide new scopes for procedures and global variables. Once defined. For simple applications you can ignore namespaces and just use the global scope. The name is case sensitive and can contain any characters. When it is called.

as shown in the next example: Example 7–1 Default parameter values. 7 Procedures can have default parameters so that the caller can leave out some of the command arguments. When $z is . two. If it is called with only one argument. At least one argument and no more than three arguments can be passed to P2. then only c gets the default value. A default parameter is specified with its name and default value. or three arguments.82 Procedures and Scope Chap. and the arguments are assigned to a and b. then the parameters b and c take on the values specified in the proc command. The value of z has special characters in it. A procedure can take a variable number of arguments by specifying the args keyword as the last parameter. the args parameter is a list that contains all the remaining values: Example 7–2 Variable number of arguments. If two arguments are provided. When the procedure is called. proc P2 {a {b 7} {c -2} } { expr $a / $b + $c } P2 6 3 => 0 Here the procedure P2 can be called with one. proc ArgTest {a {b foo} args} { foreach param {a b args} { puts stdout "\t$param = [set $param]" } } set x one set y {two things} set z \[special\$ ArgTest $x => a = one b = foo args = ArgTest $y $z => a = two things b = [special$ args = ArgTest $x $y $z => a = one b = two things args = {[special$} ArgTest $z $y $z $x => a = [special$ b = two things args = {[special$} one The effect of the list structure in args is illustrated by the treatment of variable z in Example 7–2.

There is a different namespace for variables and procedures. This means that you can use a procedure anywhere in your script.Changing Command Names with rename 83 I. Before you redefine it with proc. rename the existing command: rename foo foo.orig From within the new implementation of foo you can invoke the original command as foo. global variables are not automatically visible inside procedures. so you could disable exec with the following command: rename exec {} Scope By default there is a single. variables introduced in the procedure live only for the duration of the procedure call. Existing users of foo will transparently use the new version. the variable a in the global scope is different from the parameter a to P1. If the same variable name exists in an outer scope. Similarly. You can also use qualified names to name variables in a namespace scope. quoting is automatically added to create a valid Tcl list as the value of args. The first is to augment an existing procedure. Each procedure has a local scope for variables. its value comes through to the procedure unchanged. However. it is unaffected by the use of that variable name inside a procedure. For example. Changing Command Names with rename The rename command changes the name of a command. Tcl Basics passed as the value of parameter b. The global and upvar commands are described later in this chapter. those variables are undefined. The other thing you can do with rename is completely hide a command by renaming it to the empty string. Qualified names are described on page 198. Variables defined outside the procedure are not visible to a procedure unless the upvar or global scope commands are used. After the procedure returns.orig. When $z is part of the optional parameters. There are two main uses for rename. In Example 7–3. the global variable b is different from the variable b inside P1: . global scope for procedure names. You can use the namespace facility described in Chapter 7 to manage procedures and global variables. That is. so you could have a procedure and a global variable with the same name without conflict. as described below. you might not want users to execute UNIX programs. Variables defined outside any procedure are global variables. Example 10–3 on page 127 illustrates a technique that uses eval to undo the effect of the added list structure.

The global command adds a global variable to the current scope. Instead. When the variable is defined. This scope is outside of any procedure. The syntax for global is: global varName1 varName2 .137287362934 The point of the example is to show a state variable.. Variables defined at the global scope must be made accessible to the commands inside a procedure by using the global command. let me point out that the best way to get random numbers in Tcl is to use the rand() math function: expr rand() => . you must put a global command in all procedures that access the global variable. The choice of randomSeed as the name of the global variable associates it with the random number generator. The global command goes inside a procedure.84 Example 7–3 Variable scope and Tcl procedures. 7 set a 5 set b -8 proc P1 {a} { set b 42 if {$a < 0} { return $b } else { return $a } } P1 $b => 42 P1 [expr $a*2] => 10 The global Command Global scope is the toplevel scope. A common mistake is to have a single global command and expect that to apply to all procedures. For comparison. Procedures and Scope Chap. Example 7–4 shows a random number generator. it becomes visible in the global scope. that has to persist between calls to random. It is important to pick names of global variables carefully to avoid conflict with other parts of your program.. The variable can be undefined at the time the global command is used. Before we look at the example. the seed. Example 14–1 on page 196 uses namespaces to hide the state variable: . a global command in the global scope has no effect. However. so it is kept in a global variable.

an array element. You can specify some other number of frames to go up. 1988. Tcl Basics proc RandomInit { seed } { global randomSeed set randomSeed $seed } proc Random {} { global randomSeed set randomSeed [expr ($randomSeed*9301 + 49297) % 233280] return [expr $randomSeed/double(233280)] } proc RandomRange { range } { expr int([Random]*$range) } RandomInit [pid] => 5049 Random => 0.. Cambridge University Press. or an array name. and from Numerical Recipes in C by Press et al.517686899863 Random => 0. The use of upvar and arrays is discussed further in Chapter 8 on page 92. Inc. . and it defaults to 1. the local variable is treated like a scalar variable. so the global foo command is equivalent to: upvar #0 foo foo The variable in the uplevel stack frame can be either a scalar variable. then the local variable is treated like an array. as opposed to its value. In the first two cases. In the case of an array name. * Adapted from Exploring Expect by Don Libes. The upvar command associates a local variable with a variable in a scope up the Tcl call stack. which means one level up the Tcl call stack. or you can specify an absolute frame number with a #number syntax.217176783265 RandomRange 100 => 17 Call by Name Using upvar Use the upvar command when you need to pass the name of a variable. 1995. Level #0 is the global scope.* 85 I.Call by Name Using upvar Example 7–4 A random number generator.. The syntax of the upvar command is: upvar ?level? varName localvar The level argument is optional. into a procedure. The following procedure uses upvar to print the value of a variable given its name. O’Reilly & Associates.

If the variable is in the same scope. In Example 7–2 on page 82. You can use the name of these objects as the name of a variable that keeps state about the object. The upvar command makes this more convenient: upvar #0 $name state Using the name directly like this is somewhat risky. Their value is obtained with this construct: puts stdout "\t$param = [set $param]" Another way to do this is to use upvar. URLs. then this trick might conflict with an unrelated variable named x elsewhere in your program.86 Example 7–5 Print variable by name. the loop variable param holds the names of other variables. or people. If there were an object named x. We can define a new version of incr that initializes the variable if it does not already exist: Example 7–6 Improved incr procedure. proc incr { varName {amount 1}} { upvar 1 $varName var if {[info exists var]} { set var [expr $var + $amount] } else { set var $amount } return $var } Variable Aliases with upvar The upvar command is useful in any situation where you have the name of a variable stored in another variable. use zero as the scope number with upvar. The following is equivalent: upvar 0 $param x puts stdout "\t$param = $x" Associating State with Data Suppose you have a program that maintains state about a set of objects like files. You can modify the name to make this trick more robust: . It eliminates the need to use awkward constructs like [set $param]. Procedures and Scope Chap. One drawback of the built-in incr is that it raises an error if the variable does not exist. 7 proc PrintByName { varName } { upvar 1 $varName var puts stdout "$varName = $var" } You can use upvar to fix the incr command.

For example. You do not need to worry about special characters in $name. Commands That Take Variable Names Several Tcl commands involve variable names. as an alternative to reserving all global variables beginning with state. which is described on page 183. This upvar trick works from inside any namespace. the Tk widgets can be associated with a global Tcl variable.b -textvariable state(foo) Instead. Tcl Basics upvar #0 state$name state Your code can pass name around as a handle on an object.Variable Aliases with upvar 87 I. This technique is illustrated in Example 17–7 on page 232. you cannot: vwait state(foo) button . Once the name has been passed into the Tk widget it will be used directly as a variable name. you can use a namespace to hide these variables: upvar #0 state::$name state Now state is an alias to the namespace variable. Your code is just written to use the state variable. To continue the above example where state is an alias. . then use upvar to get access to the data associated with the object. Namespaces and upvar You can use upvar to create aliases for namespace variables. The aliases created with upvar do not work with these commands. Namespaces are described in Chapter 14. you must use the actual name of the global variable. too. which is an alias to the state variable for the current object. The vwait and tkwait commands also take variable names as arguments. nor do they work if you use trace. For example.b -textvariable state$name\(foo) The backslash turns off the array reference so Tcl does not try to access name as an array. except parentheses. Upvar aliases do not work with text variables. Instead. you must vwait state$name\(foo) button .

Blank page 88 .

and it can be the result of variable or command substitution. The index can have any string value.. A Array Syntax The index of an array is delimited by parentheses. The index. Array elements are defined with set: set arr(index) value The value of an array element is obtained with $ substitution: set foo $arr(index) Example 8–1 uses the loop variable value $i as an array index. or key. A common use of arrays is to manage a collection of variables. n array is a Tcl variable with a stringvalued index. Tcl Basics Tcl Arrays 8 This chapter describes Tcl arrays. can be any string value. Tcl command described is: array. so the cost of accessing each array element is about the same.0. arrays had a performance advantage over lists that took time to access proportional to the size of the list. * x: 89 . The flexibility of arrays makes them an important tool for the Tcl programmer. which provide a flexible mechanism to build many other data structures in Tcl.C H A P T E R 8 I. Internally. an array is implemented with a hash table. much as you use a C struct or Pascal record. You can think of the index as a key. It sets arr(x) to the product of 1 * 2 * . This chapter shows how to create several simple data structures using Tcl arrays. Before Tcl 8.. and the array as a collection of related data items identified by different keys.

For example. Tcl Arrays Chap. 8 set arr(0) 1 for {set i 1} {$i <= 10} {incr i} { set arr($i) [expr {$i * $arr([expr $i-1])}] } Complex Indices An array index can be any string.} If the array index is stored in a variable. The following works well: set index {I’m asking for trouble} set arr($index) {I told you so. often use indices that are pretty complex strings to create flexible data structures. and in this book.} set arr(I’m\ asking\ for\ trouble) {I told you so. 5. This is a tricky situation. then there is no problem with spaces in the variable’s value. The space in the index needs to be quoted with a backslash. which is why a space causes problems. Parentheses do not group like curly braces or quotes. The main Tcl parser does not know about array syntax. and append elements to it with lappend: if {[info exists stats($event)]} {incr stats($event)} You can delete an entire array. As a rule of thumb. increment its value with incr.} Array Variables You can use an array element as you would a simple variable. as shown in Example 8–2: . use a comma to separate different parts of the index. If you use a space in an index instead. If you have complex indices. Using unset on an array is a convenient way to clear out a big data structure.bar. but avoid using a string that contains spaces. The examples in this chapter. It is an error to use a variable as both an array and a normal variable. or just a single array element with unset. you can use any string for an index. or foo. like orange.1415. 3. or the whole variable reference needs to be grouped: set {arr(I’m asking for trouble)} {I told you so. All the rules about grouping and substitution described in Chapter 1 are still the same in spite of the array syntax described here. Parentheses are not a grouping mechanism.90 Example 8–1 Using arrays. then you have a quoting problem. The following is an error: set arr(0) 1 set arr 3 => can’t set "arr": variable is array The name of the array can be the result of a substitution. you can test for its existence with info exists.

It is essentially determined by the hash table implementation of the array. The ordering is also random. If your array has an extremely large number of elements. I never use them. The pattern is the kind supported by the string match command. and I find the foreach over the results of array names much more convenient. then array names just returns an empty list. which is introduced on page 79. then the array search operations might be more appropriate. or if you need to manage an iteration over a long period of time. Tcl Basics set name TheArray => TheArray set ${name}(xyz) {some value} => some value set x $TheArray(xyz) => some value set x ${name}(xyz) => TheArray(xyz) set x [set ${name}(xyz)] => some value A better way to deal with this situation is to use the upvar command. If the array variable is not defined. The previous example is much cleaner when upvar is used: Example 8–3 Referencing an array indirectly using upvar. It is also possible to iterate through the elements of an array one at a time using the search-related commands listed in Table 8–1. It allows easy iteration through an array with a foreach loop: foreach index [array names arr pattern] { # use arr($index) } The order of the names returned by array names is arbitrary. which is described on page 48. The array names command returns the index names that are defined in the array. set name TheArray => TheArray upvar 0 $name a set a(xyz) {some value} => some value set x $TheArray(xyz) => some value The array Command The array command returns information about array variables. Frankly. 91 I.The array Command Example 8–2 Referencing an array indirectly. Table 8–1 summarizes the array command: . You can limit what names are returned by specifying a pattern that matches indices.

or those that match the string match pattern.92 Table 8–1 The array command. Returns 1 if more elements remain in the search. and the next is the corresponding array value. Returns the value of the next element in array in the search identified by the token id. pattern selects matching indices. Returns an empty string if no more elements remain in the search. or worst # value is some fruit } Passing Arrays by Name The upvar command works on arrays. Returns a list that alternates between an index and the corresponding array value. Returns the list of all indices defined for arr. Initializes the array arr from list. which inverts an . 8 array exists arr array get arr ?pattern? Returns 1 if arr is an array variable. If not specified. Tcl Arrays Chap. foreach {key value} [array get fruit] { # key is ok. Returns a search token for a search through arr. array names arr ?pattern? array set arr list array size arr array startsearch arr array nextelement arr id array anymore arr id array donesearch arr id Converting Between Arrays and Lists The array get and array set operations are used to convert between an array and a list. The list elements continue to alternate between index and value. all indices and values are returned. The first element is an index. Returns the number of indices defined for arr. You can pass an array name to a procedure and use the upvar command to get an indirect reference to the array variable in the caller’s scope. which has the same form as the list returned by array get. best. Ends the search identified by id. This is illustrated in Example 8–4. The list returned by array get has an even number of elements. array set fruit { best kiwi worst peach ok banana } array get fruit => ok banana best kiwi worst peach Another way to loop through the contents of an array is to use array get and the two-variable form of the foreach command. The list argument to array set must have the same structure.

Also. These examples are presented as procedures that implement access functions to the data structure. This example uses upvar because the array names are passed into the ArrayInvert procedure. Example 8–4 ArrayInvert inverts an array. As with array names.Building Data Structures with Arrays 93 I. proc Emp_AddRecord {id name manager phone} { global employeeID employeeManager \ employeePhone employeeName set employeeID($name) $id set employeeManager($name) $manager set employeePhone($name) $phone set employeeName($id) $name } proc Emp_Manager {name} { . One approach uses a different array for each class of information. It shields the user of your data structure from the details of its implementation. in each of the module’s procedures. proc ArrayInvert {arrName inverseName {pattern *}} { upvar $arrName array $inverseName inverse foreach {index value} [array get array $pattern] { set inverse($value) $index } } Building Data Structures with Arrays This section describes several data structures you can build with Tcl arrays. much as one would use a record in other languages. name conflicts between different modules are avoided. Wrapping up your data structures in procedures is good practice. You can also use upvar to manage a collection of arrays. Tcl Basics array. A good use for arrays is to collect together a set of related variables for a module. version 1. By collecting these together in an array that has the same name as the module. Simple Records Suppose we have a database of information about people. Use arrays to collect related variables. you can specify a pattern to array get to limit what part of the array is returned. The name of the person is the index into each array: Example 8–5 Using arrays for records. as shown in Example 8–8 on page 95. a single global statement will suffice to make all the state variables visible. The inverse array does not need to exist before you call ArrayInvert.

It maps from the employee ID to the name so that the other information can be obtained if you have an ID instead of a name. A Stack A stack can be implemented with either a list or an array. you should hide the implementation in a small set of procedures.94 Tcl Arrays Chap. If the stack has a few elements this is fine. Example 8–7 Using a list to implement a stack.$name) $manager set employee(phone. In any case. Using a single array can be more convenient because there are fewer variables to manage. 8 global employeeManager return $employeeManager($name) } Simple procedures are defined to return fields of the record. then the push and pop operations have a runtime cost that is proportional to the size of the stack. proc Push { stack value } { upvar $stack list lappend list $value } proc Pop { stack } { upvar $stack list set value [lindex $list end] set list [lrange $list 0 [expr [llength $list]-2]] return $value } . If there are a lot of items in a stack.$name) $id set employee(manager. version 2. you may wish to use arrays instead. The employeeName array provides a secondary key.$id) $name } proc Emp_Manager {name} { global employee return $employee(manager. Another way to implement the same little database is to use a single array with more complex indices: Example 8–6 Using arrays for records.$name) $phone set employee(name. If you use a list. proc Emp_AddRecord {id name manager phone} { global employee set employee(id.$name) } The difference between these two approaches is partly a matter of taste. which hides the implementation so that you can change it more easily.

The top index records the depth of the stack. Tcl Basics In these examples. that applies a script to each array in order. The Tcl commands in script can reference the arrays with the name data: . Example 8–9 defines RecordInsert to add an array to the list. Example 8–8 Using an array to implement a stack. the array variable is created in the caller’s scope. The script is executed with eval. The iterator uses upvar to make data an alias for the current array. When the first assignment to S(top) is done by Push. the name of the stack is a parameter. The other elements of the array have the stack values. and an iterator function. The variable is a list in Example 8–7 and an array in Example 8–8. The example uses array indices in two ways. RecordIterate. and you want to maintain an overall ordering among the data sets.Building Data Structures with Arrays 95 I. The array implementation of a stack uses one array element to record the number of items in the stack. One approach is to keep a Tcl list with the name of each array in order. proc Push { stack value } { upvar $stack S if {![info exists S(top)]} { set S(top) 0 } set S($S(top)) $value incr S(top) } proc Pop { stack } { upvar $stack S if {![info exists S(top)]} { return {} } if {$S(top) == 0} { return {} } else { incr S(top) -1 set x $S($S(top)) unset S($S(top)) return $x } } A List of Arrays Suppose you have many arrays. each of which stores some data. so the construct $S($S(top)) is used to reference the top of the stack. which is described in detail in Chapter 10. and upvar is used to convert that into the data used for the stack. The user of the stack module does not have to know. The other indices are numbers. The Push and Pop procedures both guard against a nonexistent array with the info exists command.

or simply a large chunk of text or binary data. One implementation of Db_Insert might just be: . Once again. value list suitable for passing to array set. It is perfectly all right to make an alias with upvar to a nonexistent variable. It is also all right to change the target of the upvar alias. Example 8–10 shows the insert function and the iterator function when using this approach. proc RecordInsert {recName afterThis} { upvar $recName record $afterThis after set record(next) $after(next) set after(next) $recName } proc RecordIterate {firstRecord body} { upvar #0 $firstRecord data while {[info exists data]} { eval $body upvar #0 $data(next) data } } A Simple In-Memory Database Suppose you have to manage a lot of records. 8 proc RecordAppend {listName arrayName} { upvar $listName list lappend list $arrayName } proc RecordIterate {listName script} { upvar $listName list foreach arrayName $list { upvar #0 $arrayName data eval $script } } Another way to implement this list-of-records structure is to keep references to the arrays that come before and after each record. The procedure to add a record is called like this: Db_Insert keylist datablob The datablob might be a name.96 Example 8–9 A list of arrays. the loop is terminated by testing for the existence of the next array. One detail that is missing from the example is the initialization of the very first record so that its next element is the empty string: Example 8–10 A list of arrays. In this case. upvar is used to set up data as an alias for the current array in the iterator. each of which contain a large chunk of data and one or more key values you use to look up those values. Tcl Arrays Chap.

Tcl Basics foreach key $keylist { lappend Db($key) $datablob } The problem with this approach is that it duplicates the data chunks under each key. illustrates this approach. namespace eval db { variable data . The other array stores the association between the keys and the data chunks.# Index into data variable index .# Array of data blobs variable uid 0 . The example also shows how you can easily dump data structures by writing array set commands to a file. One stores all the data chunks under a simple ID that is generated automatically.Building Data Structures with Arrays 97 I.# Cross references into data } proc db::insert {keylist datablob} { variable data variable uid variable index set data([incr uid]) $datablob foreach key $keylist { lappend index($key) $uid } } proc db::get {key} { variable data variable index set result {} if {![info exist index($key)]} { return {} } foreach uid $index($key) { lappend result $data($uid) } return $result } proc db::save {filename} { variable uid set out [open $filename w] puts $out [list namespace eval db \ [list variable uid $uid]] puts $out [list array set db::data [array get db::data]] puts $out [list array set db::index [array get db::index]] close $out } proc db::load {filename} { source $filename } . which uses the namespace syntax described in Chapter 14. A better approach is to use two arrays. Example 8–11. and then load them later with a source command: Example 8–11 A simple in-memory database.

Blank page 98 .

tell. T Running Programs with exec The exec command runs programs from your Tcl script. Instead. and registry. There are facilities for naming files and manipulating file names in a platform-independent way. close. read. cd. the Tcl exec does not replace the current process with the new one. However. Tcl commands described are: exec. his chapter describes how to run programs and access the file system from Tcl. file. pid. If you do not care about the exit status. open. These capabilities enable your Tcl script to be a general-purpose glue that assembles other programs into a tool that is customized for your needs. In Tcl 7. flush. so you can write scripts that are portable across systems.C H A P T E R 9 I. puts. then exec raises an error.5 they were implemented in the Tcl ports to Windows and Macintosh. write. seek. gets. or you use a program that insists on writing to standard error. 99 . and access environment variables through the env array. glob. then you can use catch to mask the errors: catch {exec program arg arg} result * Unlike other UNIX shell exec commands. exit. pwd.* For example: set d [exec date] The standard output of the program is returned as the value of the exec command. Tcl Basics Working with Files and Programs9 This chapter describes how to run programs. the Tcl library forks first and executes the program as a child process. examine the file system. if the program writes to its standard error channel or exits with a nonzero status code. These commands were designed for UNIX.

and standard error. The output of sort is piped into uniq. The output of uniq is piped into wc. Appends standard output to the named file. Takes input from the I/O channel identified by fileId. Pipes standard output from one process into another. Overwrites fileName with standard output. which suppresses duplicate lines. Appends both standard error and standard output to the named file. Table 9–1 provides a summary of the syntax understood by the exec command. The error output of the command is diverted to the null device to suppress any error messages. Table 9–1 Summary of the exec syntax for I/O redirection. Directs standard error to the I/O channel identified by fileId. -keepnewline | |& < fileName <@ fileId << value > fileName 2> fileName >& fileName >> fileName 2>> fileName >>& fileName >@ fileId 2>@ fileId >&@ fileId & (First argument. Takes input from the named file. which counts the lines. Each process normally has three I/O channels associated with it: standard input. Example 9–1 Using exec on a process pipeline. Any number of programs can be linked together into a pipeline.100 Working with Files and Programs Chap. Appends standard error to the named file. Directs both standard error and standard output to the I/O channel. standard output.) Do not discard trailing newline from the result. A pipeline is a chain of processes that have the standard output of one command hooked up to the standard input of the next command in the pipeline. which takes its input from the file /etc/passwd. Overwrites fileName with standard error output. Pipes both standard output and standard error output. With I/O redirection. Directs standard output to the I/O channel identified by fileId. Takes input from the given value. 9 The exec command supports a full set of I/O redirection and pipeline syntax. . indicates pipeline should run in background. As the last argument. Overwrites fileName with both standard error and standard out. set n [exec sort < /etc/passwd | uniq | wc -l 2> /dev/null] Example 9–1 uses exec to run three programs in a pipeline. The first program is sort. you can divert these I/O channels to files or to I/O channels you have opened with the Tcl open command.

pipes are really just simulated by writing output from one process to a temporary file and then having the next process read from that file. unless you specify -keepnewline as the first argument to exec. If exec or a process pipeline fails.Running Programs with exec 101 I.1. define the auto_noexec variable: set auto_noexec anything Limitations of exec on Windows Windows 3. Windows NT 4. The auto_noexec Variable The Tcl shell programs are set up during interactive use to attempt to execute unknown Tcl commands as programs.0 is the most robust. 16-bit programs. and 32-bit programs. In addition. there is no guarantee this trick will continue to work. To turn this off. That release includes Tcl1680. The good news is that Windows 95 and Windows NT cleaned up most of the problems with exec. The standard error is joined to the standard output by &. Standard error is diverted separately by using 2>. If you look closely at the I/O redirection syntax. Otherwise. However. You can find documentation in the AppleScript.dll. Tcl ships with an AppleScript extension that lets you control other Macintosh applications. which is necessary to work with the win32s subsystem. In this case. the process identifier is returned by the exec command. For example. you may be able to use later releases of Tcl on Windows 3. You can use your own I/O channels by using @. and < for input. It can also cause unexpected behavior when you are just playing around.0p2 was the last release to officially support Windows 3.html that goes with the distribution. and the standard output of the program is the return value of exec. > for output. If you copy that file into the same directory as the other Tcl DLLs. Tcl 8. you can get a directory listing by typing: ls instead of: exec ls This is handy if you are using the Tcl interpreter as a general shell. The trailing newline in the output is trimmed off. AppleScript on Macintosh The exec command is not provided on the Macintosh. it is because of a fundamental limitation of Windows. The basic idea is that | stands for pipeline.1. You must use package require to load the AppleScript command: .1 has an unfortunate combination of special cases that stem from console-mode programs. the exec command blocks during execution of the program. you’ll see that it is built up from a few basic building blocks. Tcl Basics A trailing & causes the program to run in the background.

(Tcl 7. Table 9–2 provides a summary of the various forms of the file command..0) Copies file source to file destination.6) Returns parent directory of file name.0. The file Command The file command provides several ways to check the status of files in the file system. For example. join.6. or store. . The copy.5) Places attributes of the link name into var. The attributes operation was added in Tcl 8.) to the end. Returns 1 if name is not a directory. 9 package require Tclapplescript AppleScript junk => bad option "junk": must be compile. (Tcl 8. Queries or sets file attributes. (Tcl 7. Joins pathname components into a new pathname. (Tcl 7. and other file attributes. else 0.. delete. else 0. load. The source and destination can be directories. mkdir. and rename operations were added in Tcl 7. They are described in more detail later.e.6) Deletes the named file.102 Working with Files and Programs Chap. else 0.. and pathtype operations were added in Tcl 7. else 0. decompile. Table 9–2 The file command options. Creates directory name. Returns 1 if name exists. There are facilities for manipulating files in a platformindependent manner. Returns the part of name from the last dot (i. Returns 1 if name has execute permission. execute. what type of file it is. file atime name file attributes name ?option? ?value? . file copy ?-force? source destination file delete ?-force? name file dirname name file executable name file exists name file extension name file isdirectory name file isfile name file join path path. you can find out if a file exists. Note that the split.. . file lstat name var file mkdir name file mtime name Returns access time as a decimal string.6) Returns modify time of name as a decimal string. symbolic link. Returns 1 if name is a directory.5.. The dot is included in the return value. or device. delete. run. info. (Tcl 7.

$tcl_library) on Macintosh. and Macintosh. Changes the name of old to new. In addition. you can use forward slashes instead: c:/Program Files/Tcl/lib/Tcl7. else 0. Windows. in name). Tcl Basics file nativename name file owned name file pathtype name file readable name file readlink name file rename ?-force? old new file rootname name file size name file split name file stat name var file tail name file type name Returns the platform-native version of name. Returns the contents of the symbolic link name. Happily. characterSpecial. or driverelative.6 There are some ambiguous cases that can be specified only with native pathnames. respectively: Disk:System Folder:Extensions:Tool Command Language:tcl7. UNIX separates file name components with a forward slash (/). Tcl and Tk are installed in a directory that has a . relative.6 The good news is that Tcl provides operations that let you deal with file pathnames in a platform-independent manner. The backslash used in Windows pathnames is especially awkward because the backslash is special to Tcl.Cross-Platform File Naming Table 9–2 The file command options. (Tcl 7. and Windows separates components with a backslash (\). else 0. The file operations described in this chapter allow either native format or the UNIX naming convention. these are absolute pathnames for the Tcl script library (i. blockSpecial. fifo. up to but not including the last . (Tcl 7. Returns the number of bytes in name. and UNIX. Returns type identifier. which is one of: file.5) Places attributes of name into array var. On my Macintosh.6 /usr/local/tcl/lib/tcl7. directory.. (Continued) 103 I. else 0.6 c:\Program Files\Tcl\lib\Tcl7.e. For example. absolute. Windows. (Tcl 7. link.0). file writable name Cross-Platform File Naming Files are named differently on UNIX.6) Returns all but the extension of name (i. Splits name into its pathname components. or socket.. (Tk 8. The elements defined for var are listed in Table 9–3.5) Returns 1 if name has read permission. Returns 1 if current user owns the file name.e. Returns the last pathname component of name. Returns 1 if name has write permission. the way that absolute and relative names are distinguished is different. Macintosh separates components with a colon (:).

you put a trailing colon on the first component so that it is interpreted as a volume specifier. this construct will not create a valid pathname on the Macintosh because $tcl_library is in native format: set file $tcl_library/init. joining things with slashes will result in incorrect pathnames on Macintosh and Windows. Of course. The same problem arises when you accept user input. You can avoid accidentally constructing a network name by using the file join command described next. You can also convert a UNIXlike name to a native name with file nativename.tcl Use file join to construct file names. so it overrides any paths that come before it in the arguments to file join: file join a b/c d => a/b/c/d file join a /b/c d => /b/c/d On Macintosh. a relative pathname starts with a colon. The user is likely to provide file names in native format. The following command returns the name of the init. Building up Pathnames: file join You can get into trouble if you try to construct file names by simply joining components with a slash. If you must communicate with external programs. rootname. join. For example (on UNIX). For example. split. Several of the file operations operate on pathnames as opposed to returning information about the file itself. and tail operations on any string. you can use network names to access remote files.tcl] The file join operation can join any number of pathname components. 9 slash in it. You can construct these names with file join described later. b:c is an absolute pathname with b: as the volume speci- . pathtype.104 Working with Files and Programs Chap.tcl file in native format: set file [file join $tcl_library init. and an absolute pathname does not. You can use the dirname. there is no requirement that the pathnames refer to an existing file. To specify an absolute path. extension. The platform-independent way to construct file names is with file join. This is the Windows syntax for network names that reference files on other computers. you may need to construct a file name in the native syntax for the current platform. If part of the name is in native format.2 Another construct to watch out for is a leading // in a file name. /b/c is an absolute pathname. it has the feature that an absolute pathname overrides any previous components. In addition. You can name it only with the native Macintosh name: Disk:Applications:Tcl/Tk 4. These relative components are joined into a relative pathname: file join a :b:c d => :a:b:c:d In the next case.

on Macintosh you get this: file join /usr/local/lib => usr:local:lib Chopping Pathnames: split.c => . while tail returns the trailing component of the pathname: file dirname /a/b/c => /a/b file tail /a/b/c => c For a pathname with a single component. or ":" on Macintosh. rename files. In earlier versions it was necessary to exec other programs to do . tail The file split command divides a pathname into components. the last period in the pathname: file root /a/b. The absolute name overrides the previous relative name: file join a b:c d => b:c:d The file join operation converts UNIX-style pathnames to native format. but not including. This is the name of the current directory.c Manipulating Files and Directories Tcl 7. dirname. This task is handled directly by the dirname and tail operations. For example. It is the inverse of file join.. The Macintosh syntax for a volume specifier (Disk:) is returned on the leading component: file split "/Disk/System Folder/Extensions" => Disk: {System Folder} Extensions A common reason to split up pathnames is to divide a pathname into the directory part and the file part.". the file suffix including the period. and create directories. Tcl Basics fier.) The root option returns everything up to. The dirname operation returns the parent directory of a pathname.6 added file operations to copy files. For example. The extension and root options are also complementary. The results of file split may contain some syntax to help resolve ambiguous cases when the results are passed back to file join. the dirname option returns ". The split operation detects automatically if the input is in native or UNIX format.e. on UNIX and Windows. The extension option returns everything from the last period in the name to the end (i. on Macintosh a UNIX-style pathname is split on slash separators. delete files.c => /a/b file extension /a/b.Manipulating Files and Directories 105 I.

where cp. mkdir. A non-empty directory is not deleted unless the -force option is specified. Instead. It is not an error if the directory already exists. 9 these things.. in which case it is recursively deleted: file delete ?-force? name name . file mkdir -force oops Deleting Files The file delete operation deletes files and directories. File name patterns are not directly supported by the file operations. It is not an error if the files do not exist. Furthermore... as well as one named oops. If file2 already exists... The following example copies file1 to file2. you can use the glob command described on page 115 to get a list of file names that match a pattern. The -force option indicates that files under dir2 can be replaced: file copy ?-force? dir1 dir2 Creating Directories The file mkdir operation creates one or more directories: file mkdir dir dir .106 Working with Files and Programs Chap. These commands are no longer supported on the Macintosh. Suppose /tmp has no subdirectories at all. intermediate directories are created if needed. Your scripts should use the file command operations described below to manipulate files in a platform-independent way. This means that you can always make sure a directory exists with a single mkdir operation. The -force option indicates that files under directory can be replaced: file copy ?-force? file1 file2 . directory Directories can be recursively copied. The names of the source files are preserved. rm. and rmdir were built in. except on Macintosh. Copying Files The file copy operation copies files and directories.. mv. The following command creates /tmp/sub1 and /tmp/sub1/sub2: file mkdir /tmp/sub1/sub2 The -force option is not understood by file mkdir. so the following command accidentally creates a folder named -force. To delete a file or directory named -force. you must specify a nonexistent file before the -force to prevent it from being interpreted as a flag (-force -force won’t work): . the operation raises an error unless the -force option is specified: file copy ?-force? file1 file2 Several files can be copied into a destination directory.

size and type. All the element values are decimal strings. which can have the values returned by the type option. isfile. This ensures that any other programs that access the file will not see the new version until it is complete. The -force option causes new to be replaced if it already exists. exists. They take a third argument that is the name of an array variable. If you have ever resorted to piping the results of ls -l into awk in order to derive this information in other shell scripts. generate the new version of the file in a temporary file. file rename ?-force? old new Using file rename is the best way to update an existing file.File Attributes 107 I. Use the file attributes command described later to get other platform-specific attributes: . readable. File Attributes There are several file operations that return specific file attributes: atime. The array elements are listed in Table 9–3. First. you will appreciate this example: Example 9–2 Comparing file modify times. use file rename to replace the old version with the new version. If the file is a symbolic link. owned. except for type. and they initialize that array with elements that contain the file attributes. readlink. The following command uses file mtime to compare the modify times of two files. Refer to Table 9–2 on page 102 for their function. proc newer { file1 file2 } { if ![file exists $file2] { return 1 } else { # Assume file1 exists expr [file mtime $file1] > [file mtime $file2] } } The stat and lstat operations return a collection of file attributes. isdirectory. Then. Tcl Basics file delete xyzzy -force Renaming Files and Directories The file rename operation changes a file’s name from old to new. executable. mtime. The element names are based on the UNIX stat system call. then the lstat operation returns information about the link itself and the stat operation returns information about the target of the link.

With no options.doc -readonly => 0 The attributes are modified by specifying one or more option–value pairs. inode number). blockSpecial. all the current values are returned. in seconds. The number of links. The file number (i. The attributes are UNIX specific. Setting attributes can raise an error if you do not have the right permissions: file attributes book. The last change time (not the create time). The permission bits. in seconds. The device identifier. they are not well defined on Windows and Macintosh. an integer. The four-character type codes used on Macintosh are illustrated on page 514. The number of bytes in the file. 9 atime ctime dev gid ino mode mtime nlink size type uid The last access time. in seconds. The attributes operation lets you set and query attributes. The owner’s user ID. file attributes book. or socket. link. Working with Files and Programs Chap. to the file. only that value is returned: file attributes book. an integer.0 to provide access to platform-specific attributes.doc => -creator FRAM -hidden 0 -readonly 0 -type MAKR These Macintosh attributes are explained in Table 9–4. directory. file. The interface uses option-value pairs. The last modify time. an integer. proc fileeq { path1 path2 } { file stat $path1 stat1 file stat $path2 stat2 expr $stat1(ino) == $stat2(ino) && \ $stat1(dev) == $stat2(dev) } The file attributes operation was added in Tcl 8. Example 9–3 Determining whether pathnames reference the same file. The group owner. characterSpecial..108 Table 9–3 Array elements defined by file stat. With a single option.doc -readonly 1 -hidden 0 . or directory references. Example 9–3 uses the device (dev) and inode (ino) attributes of a file to determine whether two pathnames reference the same file. an integer.e. fifo.

open what ?access? ?permissions? puts ?-nonewline? ?channel? string gets channel ?varname? read channel ?numBytes? read -nonewline channel tell channel seek channel offset ?origin? eof channel flush channel close channel Returns channel ID for a file or pipeline. (Macintosh) type is 4-character type code. Returns the seek offset. then you cannot remove the file. (UNIX) The archive bit. then close the file. 109 I. Tcl Basics -permissions mode -group ID -owner ID -archive bool -hidden bool -readonly bool -system bool -creator type -type type File permission bits. Writes buffers of a channel. . (Windows. Reads all bytes and discard the last \n. Network sockets also use the commands described here. or all data. or end. (UNIX) The group owner of the file. and more advanced event-driven I/O is described in Chapter 16.Input/Output Command Summary Table 9–4 Platform-specific file attributes. (Windows) If set. and write files. Reads a line. which is set by backup programs. mode is a number with bits defined by the chmod system call. then the file does not appear in listings. current. Socket programming is discussed in Chapter 17. The basic model is that you open a file. Macintosh) If set. Writes a string. Queries end-of-file status. Sets the seek offset. read. read or write it. (Macintosh) Input/Output Command Summary The following sections describe how to open. Table 9–5 lists the basic commands associated with file I/O: Table 9–5 Tcl commands used for file access. Macintosh) If set. (Windows) type is 4-character code of creating application. Closes an I/O channel. then you cannot write the file. origin is one of start. (UNIX) The owner of the file. (Windows. Reads numBytes bytes.

Does not block during the open. Create if it does not exist. stdin. Opens for reading and writing. and stderr identifiers in the examples so far. Data is appended. or a list of POSIX access flags. 9 Opening Files for I/O The open command sets up an I/O channel to either a file or a pipeline of processes.110 Working with Files and Programs Chap. Prevents terminal devices from becoming the controlling terminal. Data is appended to the file. The file must exist. r r+ w w+ a a+ Opens for reading. The return value of open is an identifier for the I/O channel. Opens for reading and writing. either a short character sequence that is compatible with the fopen library routine. Store the result of open in a variable and use the variable as you used the stdout. RDONLY WRONLY RDWR APPEND CREAT EXCL NOCTTY NONBLOCK TRUNC Opens for reading. The file must exist. Table 9–6 summarizes the first form. Opens for reading and writing. set fileId [open /tmp/foo w 0600] puts $fileId "Hello. Table 9–7 Summary of POSIX flags for the access argument. Example 9–4 Opening a file for writing. Creates the file if it does not exist. Opens for writing. foo!" close $fileId Table 9–6 Summary of the open access arguments. Truncate if it exists. The access argument can take two forms. . it defaults to read. while Table 9–7 summarizes the POSIX flags. If CREAT is also specified. then the file cannot already exist. Opens for writing. Truncates the file if it exists. Opens for writing. If access is not specified. The basic syntax is: open what ?access? ?permissions? The what argument is either a file name or a pipeline specification similar to that used by the exec command. Truncate or create. Opens for append. Opens for reading and writing.

. it puts the error message into the variable. After a puts. write. set input [open "|sort /etc/passwd" r] set contents [split [read $input] \n] close $input You can open a pipeline for both read and write by specifying the r+ access mode. then. It treats its second argument as the name of a variable. it puts the result of the command into the variable: Example 9–5 A more careful use of open. creating it if needed. Recall that catch returns 1 if it catches an error. This is something you cannot do with the simpler form of the access argument: set fileId [open /tmp/bar {RDWR CREAT}] Catch errors from open. Example 9–4 specifies 0600 so that the file is readable and writable only by the owner. and everyone else. otherwise. write. The default permission bits are 0666. Consult the UNIX manual page on chmod command for more details. These bits are usually specified with an octal number. group. and execute permissions to the owner and group. as the first character of the first argument. the data may . and it uses the split command to separate the output lines into list elements: Example 9–6 Opening a process pipeline. and execute permission.Opening Files for I/O 111 I. and not truncating it. you need to worry about buffering. you should check for errors when opening files. In general. You can set other special properties with additional high-order bits. 0775 would grant read. including input and output redirection. The bits specify read. The second argument determines which end of the pipeline open returns. |. Tcl Basics The permissions argument is a value used for the permission bits on a newly created file. The remainder of the pipeline specification is interpreted just as with the exec command. The following example illustrates how to use a list of POSIX access flags to open a file for reading and writing.. In the normal case. UNIX uses three bits each for the owner. it returns zero. which has a leading zero. and read and execute permissions to everyone else. close $fileId } Opening a Process Pipeline You can open a process pipeline by specifying the pipe character. so that there is one octal digit for each set of bits. which grant read/write access to everybody. if [catch {open /tmp/data r} fileId] { puts stderr "Cannot open /tmp/data: $fileId" } else { # Read and process the file. In the error case. The following example runs the UNIX sort program on the password file. In this case. The following example illustrates a catch phrase used to open files.

. respectively.. It was created by Don Libes at the National Institute of Standards and Technology (NIST). Expect is described in Exploring Expect (Libes. These channels are identified by stdin. Expect adds Tcl commands that are used to control interactive applications. You can also close the standard I/O channels with close.gov/ Reading and Writing The standard I/O channels are already open for you. Expect If you are trying to do sophisticated things with an external application. It means you can do other processing while the pipeline executes. and stderr. O’Reilly & Associates. stdout. You can find the software on the CD and on the web at: http://expect. Inc. Windows has no standard error channel. and it is also an extension that you can dynamically load into other Tcl shells. and simply respond when the pipe generates data. Use the flush command to force the data out to the spawned processes before you try to read any output from the pipeline. Note that you must use flush to force output of a partial line. Remember that read-write pipes will not work at all with Windows 3. Telnet. Other I/O channels are returned by the open command. and by the socket command described on page 226. There is a standard input channel. Event-driven I/O is also very useful with pipes. It is extremely useful for automating FTP.1 because pipes are simulated with files. and a standard error output channel. You can also use the fconfigure command described on page 223 to force line buffering. The puts and gets Commands The puts command writes a string and a newline to the output channel.112 Working with Files and Programs Chap. a standard output channel. There are a couple of details about the puts command that we have not yet used. There may be cases when the standard I/O channels are not available. Some UNIX window managers close the standard I/O channels when you start programs from window manager menus. This is illustrated in Example 9–7.nist. and programs under test. 9 still be in a buffer in the Tcl library. It comes as a Tcl shell named expect. defaulting to stdout if not specified. This is used in the prompt example below. It takes a -nonewline argument that prevents the newline character that is normally appended to the output channel. This is described in Chapter 16. you will find that the Expect extension provides a much more powerful interface than a process pipeline. The second feature is that the channel identifier is optional. 1995).

You must use the eof command to tell the difference between a blank line and end-of-file. 113 I. There are two forms for read: You can specify the -nonewline argument or the numBytes argument. Given a second varName argument. The trailing newline is not discarded in this case. Example 9–8 A read loop using gets. an empty string is returned. with just a single argument. and split chops the file into list elements. read returns that amount. which is not counted. one for each line. but not both. and it has two forms. If end of file is reached. In the previous example. A -1 is returned if the channel has reached the end of file. while {[gets $channel line] >= 0} { # Process line } close $channel The read Command The read command reads blocks of data. The -nonewline argument causes the trailing newline to be discarded. read returns the whole file. the whole file (or what is left in the I/O channel) is read and returned. Without numBytes. gets stores the line into a named variable and returns the number of bytes read. and this capability is often more efficient. In this case.# Necessary to get partial line output set answer [gets stdin] The gets command reads a line of input. For small files (less than 1K) it doesn’t really matter. Tcl Basics puts -nonewline "Enter value: " flush stdout . It discards the trailing newline. eof returns 1 if there is end of file.Reading and Writing Example 9–7 Prompting for input. For large files (megabytes) you might induce paging with this approach. Example 9–9 A read loop using read and split. it is about 10 percent faster to loop over the lines in a file using the read loop in the second example. foreach line [split [read $channel] \n] { # Process line } close $channel For moderate-sized files. It discards the trailing newline from the return value. Given a byte count argument. or less if there is not enough data in the channel. . gets returns the line read from the specified I/O channel.

Tcl accepts any of these. newline sequence (\r\n). On Windows. On UNIX.114 Working with Files and Programs Chap. Each channel has a current position called the seek offset. Both the read and gets commands do this conversion. text lines are always terminated with a newline character (\n). 9 Platform-Specific End of Line Characters Tcl automatically detects different end of line conventions. they are terminated with a carriage return. You just need to read it in and write it out: puts -nonewline $out [read $in] To suppress conversions. close $in } Random Access I/O The seek and tell commands provide random access to I/O channels. The automatic handling of line formats means that it is easy to convert a file to native format. use the fconfigure command. or end. text lines are ended with a newline character (\n). which can be positive or negative. On Macintosh. The current value of the offset is returned by the tell command. All these different conventions are converted to the UNIX style so that once read. . from an origin which is either start. Example 9–10 demonstrates a File_Copy procedure that translates files to native format. proc File_Copy {src dest} { if [file isdirectory $src] { file mkdir $dest foreach f [glob -nocomplain [file join $src *]] { File_Copy $f [file join $dest [file tail $f]] } return } if [file isdirectory $dest] { set dest [file join $dest [file tail $src]] } set in [open $src] set out [open $dest w] puts -nonewline $out [read $in] close $out . text lines are generated in the platform-native format. current. Each read or write operation updates the seek offset by the number of bytes transferred. The seek command sets the seek offset by an amount. and the line terminator can even change within a file. During output. which is described in more detail on page 223. they are terminated with a carriage return (\r). It is complicated because it handles directories: Example 9–10 Copy a file and translate to native format.

c} matches any of a.b} construct can match nonexistent names. Unlike the glob matching in csh. it will be closed when your process exits. The close command can raise an error. the results of glob are not sorted. the Tcl glob command matches only the names of existing files. The error is raised when the channel to the pipeline is finally closed. Tcl Basics Closing I/O Channels The close command is just as important as the others because it frees operating system resources associated with the I/O channel. ? matches a single character. glob raises an error if no files match. close raises an error. The pwd command returns the current directory. b.flag must be used if the pattern begins with a -.. Similarly. If the channel was a process pipeline and any of the processes wrote to their standard error channel. which traverses the file system hierarchy using recursion. like a Tk script. The general form of the glob command is: glob ?flags? pattern ?pattern? . if you have a longrunning program. A catch guards against bogus names. Matching File Names with glob The glob command expands a pattern into the set of matching file names.The Current Directory — cd and pwd 115 I. The -nocomplain flag causes glob to return an empty list if no files match the pattern. if any of the processes in the pipeline exit with a nonzero status. If you forget to close a channel. or c. However. the {a. Use the lsort command to sort its result if you find it important. Otherwise. In addition. In csh. Example 9–11 shows the FindFile procedure. All other characters must match themselves. At each iteration it saves its current directory and then attempts to change to the next subdirectory. and the cd command changes the current directory. Example 9–11 uses these commands. you might exhaust some operating system resources if you forget to close your I/O channels. then Tcl believes this is an error.b. The pattern syntax is similar to the string match patterns: • • • • • * matches zero or more characters. The glob command matches file names: . [abc] matches a set of characters. {a. The Current Directory — cd and pwd Every process has a current directory that is used as the starting point when resolving a relative pathname.. The -.

g. Working with Files and Programs Chap. On UNIX systems you can exec the kill program to terminate a process: exec kill $pid . This can be useful as the seed for a random number generator because it changes each time you run your script. then that becomes the exit status of the process. If you have a file that starts with a literal tilde. There are two cases: • ~/ expands to the current user’s home directory../ (e.116 Example 9–11 Finding a file by name. you can avoid the tilde expansion by adding a leading ./~foobar). It is also common to embed the process ID in the name of temporary files. The pid command returns the process ID of the current process. • ~user expands to the home directory of user. Note that exit causes termination of the whole process that was running the script. .$namePat] { puts stdout [file join $startDir $match] } foreach file [glob -nocomplain *] { if [file isdirectory $file] { FindFile [file join $startDir $file] $namePat } } cd $pwd } Expanding Tilde in File Names The glob command also expands a leading tilde (~) in filenames. The exit and pid Commands The exit command terminates your script. You can also find out the process IDs associated with a process pipeline with pid: set pipe [open "|command"] set pids [pid $pipe] There is no built-in mechanism to control processes in Tcl. If you supply an integer-valued argument to exit. 9 proc FindFile { startDir namePat } { set pwd [pwd] if [catch {cd $startDir} err] { puts stderr $err return } foreach match [glob -nocomplain -.

so programs run with the exec command inherit the environment of the Tcl script. and typed data. and each value name has data associated with it. If assignments are made to env. proc printenv { args } { global env set maxl 0 if {[llength $args] == 0} { set args [lsort [array names env]] } foreach x $args { if {[string length $x] > $maxl} { set maxl [string length $x] } } incr maxl 2 foreach x $args { puts stdout [format "%*s = %s" $maxl $x $env($x)] } } printenv USER SHELL TERM => USER = welch SHELL = /bin/csh TERM = tx Note: Environment variables can be initialized for Macintosh applications by editing a resource of type STR# whose name is Tcl Environment Variables. The Windows tool to browse and edit the registry is called regedit. and the array element contains the current value of the environment variable. The format of the resource values is NAME=VALUE.Environment Variables 117 I. Tcl Basics Environment Variables Environment variables are a collection of string-valued variables associated with each process. Follow the directions on page 28 for using ResEdit. The registry Command Windows uses the registry to store various system configuration information. Environment variables are inherited by child processes. It is a loadable package that you must load by using: package require registry The registry structure has keys. The name of the environment variable is the index. (e. they result in changes to the corresponding environment variable. This resource is part of the tclsh and wish applications. The following example prints the values of environment variables. . Tcl provides a registry command. value names.. env(PATH)). The value names are stored under a key. Example 9–12 Printing environment variable values. The process’s environment variables are available through the global array env.g.

A 32-bit integer in the other byte order. so another way to think of the value names is as an extra level in the hierarchy. Tables 9–8 and 9–9 summarize the registry command and data types: Table 9–8 The registry command. The key names have one of the following formats: \\hostname\rootname\keypath rootname\keypath rootname The rootname is one of HKEY_LOCAL_MACHINE. HKEY_USERS. or HKEY_DYN_DATA. registry delete key ?valueName? registry get key valueName registry keys key ?pat? registry set key registry set key valueName data ?type? registry type key valueName registry values key ?pat? Deletes the key and the named value. Creates valueName under key with value data of the given type. Returns the type of valueName under key. . Table 9–9 The registry data types. The main point is that you need to specify both a key name and a value name in order to get something out of the registry. An array of strings. 9 The keys are organized into a hierarchical naming system. Creates key. A device driver resource list. HKEY_CURRENT_CONFIG. which is a string match pattern. A 32-bit integer. Arbitrary binary data. A symbolic link. HKEY_CLASSES_ROOT.118 Working with Files and Programs Chap. It is represented in Tcl as a decimal string. Returns the value associated with valueName under key. or it deletes all values under the key if valueName is not specified. Returns the names of the values stored under key that match pat. Returns the list of keys or value names under key that match pat. which is a string match pattern. HKEY_CURRENT_USER. HKEY_PERFORMANCE_DATA. binary none expand_sz dword dword_big_endian link multi_sz resource_list Arbitrary binary data. which are represented as a Tcl list. Types are listed in Table 9–9. A string that contains references to environment variables with the %VARNAME% syntax.

Sign up to vote on this title
UsefulNot useful