It is a good idea to try out the examples in this book as you read along. The highlighted examples from the book are on the CD-ROM in the exsource folder. You can edit these scripts in your favorite editor. 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. To get started, just open an editor on a file named cgi1.tcl. Each time you update this file you can save it, reload it into Tcl with the source command, and test it again. Development goes quickly because you do not wait for things to compile!

On UNIX you can create a standalone Tcl or Tcl/Tk script much like an sh or csh script. The trick is in the first line of the file that contains your script. If the first line of a file begins with #!pathname, then UNIX uses pathname as the interpreter for the rest of the script. The "Hello, World!" program from Chapter 1 is repeated in Example 2-1 with the special starting line:

#!/usr/local/bin/tclsh
puts stdout {Hello, World!}

The Tk hello world program from Chapter 23 is shown in Example 2-2:

#!/usr/local/bin/wish
button .hello -text Hello -command {puts "Hello, World!"}
pack .hello -padx 10 -pady 10

The actual pathnames for tclsh and wish may be different on your system. If you type the pathname for the interpreter wrong, you receive a confusing “command not found” error. You can find out the complete pathname of the Tcl interpreter with the info nameofexecutable command. This is what appears on my system:

info nameofexecutable
=> /home/welch/install/linux-ix86/bin/tclsh8.4

Note

Watch out for long pathnames.

On most UNIX systems, this special first line is limited to 32 characters, including the #!. If the pathname is too long, you may end up with /bin/sh trying to interpret your script, giving you syntax errors. You might try using a symbolic link from a short name to the true, long name of the interpreter. However, watch out for systems like older versions of Solaris in which the script interpreter cannot be a symbolic link. Fortunately, Solaris doesn't impose a 32-character limit on the pathname, so you can just use a long pathname.

The next example shows a trick that works around the pathname length limitation in all cases. The trick comes from a posting to comp.lang.tcl by Kevin Kenny. It takes advantage of a difference between comments in Tcl and the Bourne shell. Tcl comments are described on page 16. In the example, the exec Bourne shell command that runs the Tcl interpreter is hidden in a comment as far as Tcl is concerned, but it is visible to /bin/sh. The exec command (in /bin/sh) replaces the current program, so that is all that the Bourne shell processes; Tcl interprets the rest 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 script goes here ...

You do not even have to know the complete pathname of tclsh or wish to use this trick. 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 addition, some users may not have these programs in their PATH.

You can hide more than one Bourne shell command in a script with this trick. For example, you might need to set environment variables:

#!/bin/sh
# 
export LD_LIBRARY_PATH=/usr/local/lib
# 
exec /usr/local/bin/tclsh "$0" ${1+"$@"}

You can add your Tcl/Tk programs to the Windows start menu. The command is the complete name of the wish.exe program and the name of the script. The trick is that the name of wish.exe has a space in it in the default configuration, so you must use quotes. Your start command will look something like this:

"c:Program FilesTcl84wish84.exe" "c:My Filesscript.tcl"

This starts c:My Filesscript.tcl as a standalone Tcl/Tk program.

If you want to create a self-contained Tcl/Tk application on Macintosh OS 8 or 9, you must copy the Wish program and add a Macintosh resource named tclshrc that has the start-up Tcl code. The Tcl code can be a single source command that reads your script file. Here are step-by-step instructions to create the resource using ResEdit:

This sequence of commands is captured in an application called Drag n Drop Tclets, which comes with the Macintosh Tcl distribution. If you drag a Tcl script onto this icon, it will create a copy of Wish and create the tclshrc text resource that has a source command that will load that script.

If you have a Macintosh development environment, you can build a version of Wish that has additional resources built right in. You add the resources to the applicationInit.r file. If a resource contains Tcl code, you use it like this:

source -rcrc resource

If you don't want to edit resources, you can just use the Wish Source menu to select a script to run.

The Windows and Macintosh platforms have a built-in console that is used to enter Tcl commands interactively. You can control this console with the console command. The console is visible by default. Hide the console like this:

console hide

Display the console like this:

console show

The console is implemented by a second Tcl interpreter. You can evaluate Tcl commands in that interpreter with:

console eval command

There is an alternate version of this console called TkCon. It is included on the CD-ROM, and you can find current versions on the Internet. TkCon was created by Jeff Hobbs and has lots of nice features. You can use TkCon on Unix systems, too. Some of its features were added to console in 8.4.

If you run a script from the command line, for example from a UNIX shell, you can pass the script command-line arguments. You can also specify these arguments in the shortcut command in Windows. For example, under UNIX you can type this at a shell:

% myscript.tcl arg1 arg2 arg3

In Windows, you can have a shortcut that runs wish on your script and also passes additional arguments:

"c:Program FilesTcl84wish.exe" c:yourscript.tcl arg1

The Tcl shells pass the command-line arguments to the script as the value of the argv variable. The number of command-line arguments is given by the argc variable. The name of the program, or script, is not part of argv nor is it counted by argc. Instead, it is put into the argv0 variable. Table 2-2 lists all the predefined variables in the Tcl shells. argv is a list, so you can use the lindex command, which is described on page 63, to extract items from it:

set arg1 [lindex $argv 0]

The following script prints its arguments (foreach is described on page 79):

# 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
}

wish ?options? ?script? ?arg1 arg2?