NAME
       tclsh - Simple shell containing Tcl interpreter

SYNOPSIS
       tclsh ?fileName arg arg ...?


DESCRIPTION
       Tclsh  is a shell-like application that reads Tcl commands
       from its standard input or from a file and evaluates them.
       If  invoked  with no arguments then it runs interactively,
       reading Tcl commands  from  standard  input  and  printing
       command results and error messages to standard output.  It
       runs until the exit command is invoked or until it reaches
       end-of-file on its standard input.  If there exists a file
       .tclshrc (or tclshrc.tcl on the Windows platforms) in  the
       home  directory of the user, tclsh evaluates the file as a
       Tcl script just before  reading  the  first  command  from
       standard input.


SCRIPT FILES
       If tclsh is invoked with arguments then the first argument
       is the name of a script file and any additional  arguments
       are made available to the script as variables (see below).
       Instead of reading commands from standard input tclsh will
       read  Tcl  commands  from the named file;  tclsh will exit
       when it  reaches  the  end  of  the  file.   There  is  no
       automatic  evaluation  of  .tclshrc  in this case, but the
       script file can always source it if desired.

       If you create a Tcl script in a file whose first line is
              #!/usr/local/bin/tclsh
       then you can invoke the script  file  directly  from  your
       shell  if  you  mark the file as executable.  This assumes
       that tclsh has been installed in the default  location  in
       /usr/local/bin;   if  it's  installed  somewhere else then
       you'll have to modify the above line to match.  Many  UNIX
       systems  do  not  allow  the  #!  line  to exceed about 30
       characters in length, so be sure that the tclsh executable
       can be accessed with a short file name.

       An even better approach is to start your script files with
       the following three lines:
              #!/bin/sh
              # the next line restarts using tclsh \
              exec tclsh "$0" "$@"
       This approach has three advantages over  the  approach  in
       the  previous paragraph.  First, the location of the tclsh
       binary doesn't have to be hard-wired into the script:   it
       can  be  anywhere  in  your shell search path.  Second, it
       gets around  the  30-character  file  name  limit  in  the
       previous approach.  Third, this approach will work even if
       tclsh is itself a shell  script  (this  is  done  on  some
       systems  in  order  to  handle  multiple  architectures or
       operating  systems:   the  tclsh  script  selects  one  of
       several  binaries  to run).  The three lines cause both sh
       and tclsh to process the script,  but  the  exec  is  only
       executed by sh.  sh processes the script first;  it treats
       the second line as a comment and executes the third  line.
       The  exec statement cause the shell to stop processing and
       instead to start up tclsh to reprocess the entire  script.
       When  tclsh  starts  up,  it  treats  all  three  lines as
       comments, since the backslash at the  end  of  the  second
       line  causes  the  third line to be treated as part of the
       comment on the second line.


VARIABLES
       Tclsh sets the following Tcl variables:

       argc           Contains a  count  of  the  number  of  arg
                      arguments  (0  if  none), not including the
                      name of the script file.

       argv           Contains a Tcl list whose elements are  the
                      arg arguments, in order, or an empty string
                      if there are no arg arguments.

       argv0          Contains  fileName  if  it  was  specified.
                      Otherwise, contains the name by which tclsh
                      was invoked.

       tcl_interactive
                      Contains   1   if    tclsh    is    running
                      interactively  (no  fileName  was specified
                      and  standard  input  is  a   terminal-like
                      device), 0 otherwise.


PROMPTS
       When  tclsh  is  invoked interactively it normally prompts
       for each command with ``% ''.  You can change  the  prompt
       by  setting the variables tcl_prompt1 and tcl_prompt2.  If
       variable tcl_prompt1 exists then it must consist of a  Tcl
       script to output a prompt;  instead of outputting a prompt
       tclsh  will  evaluate  the  script  in  tcl_prompt1.   The
       variable  tcl_prompt2  is  used  in  a  similar way when a
       newline  is  typed  but  the  current  command  isn't  yet
       complete;  if  tcl_prompt2  isn't  set  then  no prompt is
       output for incomplete commands.


KEYWORDS
