tcsh - C shell with file name completion  and  command  line

     tcsh [ -bcdefFilmnqstvVxX -Dname[=value] ] [ argument ... ]

     Tcsh is an enhanced version of the  Berkeley  UNIX  C  shell
     csh(1).  It behaves exactly like the C shell, except for the
     added utilities of:

       1)  Command line editing using Emacs-style commands.

       2)  Visual step up/down through the history list.

       3)  Terminal mode sanity checking and resetting.

       4)  Interactive command, file name and user  name  comple-

       5)  File/directory/user list in the middle of a typed com-

       6)  Spelling correction of command, file, and user names.

       7)  Lookup of command documentation in  the  middle  of  a
           typed command.

       8)  Enhanced history mechanism.

       9)  Automatic locking/logout after long  periods  of  idle

       10) Automatic execution  of  a  single  command  prior  to
           printing each prompt.

       11) Automatic periodic command execution.

       12) A new syntax for the prompt, and the  ability  to  set
           the prompt for "while" and "for" loops.

       13) Time stamps in the history list.

       14) An addition to  the  syntax  of  filenames  to  access
           entries  in the directory stack, and the ability treat
           symbolic links in a  sane  way  when  changing  direc-

       15) The ability to watch for logins and logouts by user or
           terminal on the machine.

       16) A scheduled event list, which specifies commands which
           are to be executed at given times.

       17) A new builtin that does a subset of ls(1).

       18) An addition to the file expression syntax for a  char-
           acter  not  in  a set of characters and the ability to
           negate a globbing pattern.

       19) New automatically  initialized  environment  variables
           HOST and HOSTTYPE.

       20) Commands for debugging terminal capabilities.

       21) Searching for the visual history mechanism.

       22) New builtins for the which(1) and where commands.

       23) Restarting a stopped editor with two keystrokes.

       24) Status line support

       25) Automatic execution of  a  command  when  the  current
           working directory is changed.

       26) Native Language System support.

       27) Automatic process time reporting.

       28) OS Dependent Builtin Support

       29) Automatic window size adjustment

       30) Input files

       31) Additional/Undocumented Options

       32) Enhanced history/variable modifier expansion

     For a description of standard C-shell features, see the  csh
     manual page.

     Commands that the user types in may be edited using the same
     control  characters  that  Gnu  Emacs or vi uses.  Arrow and
     function key sequences are also allowed.  Tcsh  allows  this
     by  setting  the  terminal  to `CBREAK' mode and reading the
     input one character at a time.

     There is a new shell command, bindkey, that allows the  user
     to  redefine  what any key does, or find out what any or all
     of the keys do.
     Syntax: bindkey [ -a ] [ -c ] [ -s ] [ -v ] [ -e ] [ -d ]  [
     -l ] [ -r ] [ -- ] [ in-string [ out-string | command ]]

     If no values are given all bindings are listed. If only  in-
     string is given, bindings for the in-string is listed.

     Otherwise it binds the in-string to the given out-string  or
     command.   If  out-string,  this is treated as input to tcsh
     when in-string is typed. This may  be  used  recursively  to
     currently a level of 10 deep.

     There are two basic key maps:  the  normal  and  alternative
     one.  The alternative is used by VI command mode. For multi-
     character input the basic  key  maps  contains  a  sequence-
     lead-in for the first character in the input.

         -a    bind in-string in alternative key map.
         -s    bind an out-string instead of a command
         -c    bind a unix command instead of a command
         -v    bind for default VI-mode
         -e    bind for default emacs-mode
         -d    bind to compiled in default
         -l    list functions available with short description
         -r    remove the binding of in-string

     In strings control  characters  may  be  written  as  caret-
     <letter>  and  backslash ("\") is used to escape a character
     as follows:
          \a   bell character
          \n   line feed (new line)
          \b   back space
          \t   horizontal tab
          \v   vertical tab
          \f   form feed
          \r   carriage return
          \e   escape
          \nnn character code in octal
     In all other cases \ escapes the following character. Needed
     for  escaping  the  special  meaning  of \ and ^.  Delete is
     written as "^?" (caret-question mark).

     Tcsh always binds the arrow keys as defined by  the  termcap
     entry to:

           up arrow       up-history
           down arrow     down-history
           right arrow    forward-char
           left arrow     backward-char

     except where these bindings would alter other single charac-
     ter  bindings.   If  this  is  not desired one can avoid the
     automatic arrow key binding using settc to change the  arrow
     key  escape  sequences  to the empty string.  The ansi/vt100
     sequences for arrow keys are always bound.

     The following is a list of the default emacs  and  vi  bind-
     ings.   Characters  with  the  8th bit set are written as M-
     <character>.  Note however, that unlike with  the  old  bind
     command (see below), the syntax M-<character> has no special
     meaning to the bindkey command, and  the  bindings  for  the
     sequence escape+<character> and M-<character> as given below
     are handled separately (although the  the  default  bindings
     are the same).  The printable ascii characters not mentioned
     in the list are bound to the  self-insert-command  function,
     which  just  inserts  the given character literally into the
     input line.  The  remaining  characters  are  bound  to  the
     undefined-key  function,  which  only  causes a beep (unless
     nobeep is set, of course).

           EMACS bindings

           "^@"                     ->  set-mark-command
           "^A"                     ->  beginning-of-line
           "^B"                     ->  backward-char
           "^C"                     ->  tty-sigintr
           "^D"                     ->  delete-char-or-list
           "^E"                     ->  end-of-line
           "^F"                     ->  forward-char
           "^G"                     ->  is undefined
           "^H"                     ->  backward-delete-char
           "^I"                     ->  complete-word
           "^J"                     ->  newline
           "^K"                     ->  kill-line
           "^L"                     ->  clear-screen
           "^M"                     ->  newline
           "^N"                     ->  down-history
           "^O"                     ->  tty-flush-output
           "^P"                     ->  up-history
           "^Q"                     ->  tty-start-output
           "^R"                     ->  redisplay
           "^S"                     ->  tty-stop-output
           "^T"                     ->  transpose-chars
           "^U"                     ->  kill-whole-line
           "^V"                     ->  quoted-insert
           "^W"                     ->  kill-region
           "^X"                     ->  sequence-lead-in
           "^Y"                     ->  yank
           "^Z"                     ->  tty-sigtsusp
           "^["                     ->  sequence-lead-in
           "^\"                     ->  tty-sigquit
           "^]"                     ->  tty-dsusp
           " " to "/"               ->  self-insert-command
           "0"  to "9"              ->  digit
           ":"  to "~"              ->  self-insert-command
           "^?"                     ->  backward-delete-char

           EMACS Multi-character and 8 bit bindings

           "^[^D" or "M-^D"         ->  list-choices
           "^[^H" or "M-^H"         ->  backward-delete-word
           "^[^I" or "M-^I"         ->  complete-word
           "^[^L" or "M-^L"         ->  clear-screen
           "^[^Z" or "M-^Z"         ->  run-fg-editor
           "^[^[" or "M-^["         ->  complete-word
           "^[^_" or "M-^_"         ->  copy-prev-word
           "^[ "  or "M- "          ->  expand-history
           "^[!"  or "M-!"          ->  expand-history
           "^[$"  or "M-$"          ->  spell-line
           "^[0"  or "M-0"          ->  digit-argument
           "^[1"  or "M-1"          ->  digit-argument
           "^[2"  or "M-2"          ->  digit-argument
           "^[3"  or "M-3"          ->  digit-argument
           "^[4"  or "M-4"          ->  digit-argument
           "^[5"  or "M-5"          ->  digit-argument
           "^[6"  or "M-6"          ->  digit-argument
           "^[7"  or "M-7"          ->  digit-argument
           "^[8"  or "M-8"          ->  digit-argument
           "^[9"  or "M-9"          ->  digit-argument
           "^[?"  or "M-?"          ->  which-command
           "^[B"  or "M-B"          ->  backward-word
           "^[C"  or "M-C"          ->  capitalize-word
           "^[D"  or "M-D"          ->  delete-word
           "^[F"  or "M-F"          ->  forward-word
           "^[H"  or "M-H"          ->  run-help
           "^[L"  or "M-L"          ->  downcase-word
           "^[N"  or "M-N"          ->  history-search-forward
           "^[P"  or "M-P"          ->  history-search-backward
           "^[R"  or "M-R"          ->  toggle-literal-history
           "^[S"  or "M-S"          ->  spell-word
           "^[U"  or "M-U"          ->  upcase-word
           "^[W"  or "M-W"          ->  copy-region-as-kill
           "^[_"  or "M-_"          ->  insert-last-word
           "^[b"  or "M-b"          ->  backward-word
           "^[c"  or "M-c"          ->  capitalize-word
           "^[d"  or "M-d"          ->  delete-word
           "^[f"  or "M-f"          ->  forward-word
           "^[h"  or "M-h"          ->  run-help
           "^[l"  or "M-l"          ->  downcase-word
           "^[n"  or "M-n"          ->  history-search-forward
           "^[p"  or "M-p"          ->  history-search-backward
           "^[r"  or "M-r"          ->  toggle-literal-history
           "^[s"  or "M-s"          ->  spell-word
           "^[u"  or "M-u"          ->  upcase-word
           "^[w"  or "M-w"          ->  copy-region-as-kill
           "^[^?" or "M-^?"         ->  backward-delete-word
           "^X^X"                   ->  exchange-point-and-mark
           "^X*"                    ->  expand-glob
           "^X$"                    ->  expand-variables
           "^XG"                    ->  list-glob
           "^Xg"                    ->  list-glob
           "^Xn                     ->  normalize-path
           "^XN                     ->  normalize-path

           VI Insert Mode functions

           "^@"                     ->  is undefined
           "^A"                     ->  beginning-of-line
           "^B"                     ->  backward-char
           "^C"                     ->  tty-sigintr
           "^D"                     ->  list-or-eof
           "^E"                     ->  end-of-line
           "^F"                     ->  forward-char
           "^G"                     ->  list-glob
           "^H"                     ->  backward-delete-char
           "^I"                     ->  complete-word
           "^J"                     ->  newline
           "^K"                     ->  kill-line
           "^L"                     ->  clear-screen
           "^M"                     ->  newline
           "^N"                     ->  down-history
           "^O"                     ->  tty-flush-output
           "^P"                     ->  up-history
           "^Q"                     ->  tty-start-output
           "^R"                     ->  redisplay
           "^S"                     ->  tty-stop-output
           "^T"                     ->  transpose-chars
           "^U"                     ->  backward-kill-line
           "^V"                     ->  quoted-insert
           "^W"                     ->  backward-delete-word
           "^X"                     ->  expand-line
           "^Y"                     ->  tty-dsusp
           "^Z"                     ->  tty-sigtsusp
           "^["                     ->  vi-cmd-mode
           "^\"                     ->  tty-sigquit
           " " to "~"               ->  self-insert-command
           "^?"                     ->  backward-delete-char

           VI Command Mode functions

           "^@"                     ->  is undefined
           "^A"                     ->  beginning-of-line
           "^B"                     ->  is undefined
           "^C"                     ->  tty-sigintr
           "^D"                     ->  list-choices
           "^E"                     ->  end-of-line
           "^F"                     ->  is undefined
           "^G"                     ->  list-glob
           "^H"                     ->  backward-char
           "^I"                     ->  vi-cmd-mode-complete
           "^J"                     ->  newline
           "^K"                     ->  kill-line
           "^L"                     ->  clear-screen
           "^M"                     ->  newline
           "^N"                     ->  down-history
           "^O"                     ->  tty-flush-output
           "^P"                     ->  up-history
           "^Q"                     ->  tty-start-output
           "^R"                     ->  redisplay
           "^S"                     ->  tty-stop-output
           "^T"                     ->  is undefined
           "^U"                     ->  backward-kill-line
           "^V"                     ->  is undefined
           "^W"                     ->  backward-delete-word
           "^X"                     ->  expand-line
           "^["                     ->  sequence-lead-in
           "^\"                     ->  tty-sigquit
           " "                      ->  forward-char
           "!"                      ->  expand-history
           "$"                      ->  end-of-line
           "*"                      ->  expand-glob
           "+"                      ->  down-history
           ";"                      ->  vi-repeat-char-fwd
           ","                      ->  vi-repeat-char-back
           "-"                      ->  up-history
           "."                      ->  is undefined
           "/"                      ->  vi-search-back
           "0"                      ->  vi-zero
           "1" to "9"               ->  digit-argument
           "?"                      ->  vi-search-fwd
           "@"                      ->  is undefined
           "A"                      ->  vi-add-at-eol
           "B"                      ->  vi-word-back
           "C"                      ->  change-till-end-of-line
           "D"                      ->  kill-line
           "E"                      ->  vi-endword
           "F"                      ->  vi-char-back
           "I"                      ->  vi-insert-at-bol
           "J"                      ->  history-search-forward
           "K"                      ->  history-search-backward
           "N"                      ->  vi-search-back
           "O"                      ->  sequence-lead-in
           "R"                      ->  vi-replace-mode
           "S"                      ->  vi-substitute-line
           "T"                      ->  vi-charto-back
           "U"                      ->  is undefined
           "V"                      ->  expand-variables
           "W"                      ->  vi-word-fwd
           "X"                      ->  backward-delete-char
           "["                      ->  sequence-lead-in
           "\^"                     ->  beginning-of-line
           "a"                      ->  vi-add
           "b"                      ->  backward-word
           "c"                      ->  is undefined
           "d"                      ->  vi-delmeta
           "e"                      ->  vi-eword
           "f"                      ->  vi-char-fwd
           "h"                      ->  backward-char
           "i"                      ->  vi-insert
           "j"                      ->  down-history
           "k"                      ->  up-history
           "l"                      ->  forward-char
           "m"                      ->  is undefined
           "n"                      ->  vi-search-fwd
           "r"                      ->  vi-replace-char
           "s"                      ->  vi-substitute-char
           "t"                      ->  vi-charto-fwd
           "u"                      ->  vi-undo
           "v"                      ->  expand-variables
           "w"                      ->  vi-beginning-of-next-word
           "x"                      ->  delete-char
           "~"                      ->  change-case
           "^?"                     ->  backward-delete-char
           "M-?"                    ->  run-help
           "M-["                    ->  sequence-lead-in
           "M-O"                    ->  sequence-lead-in

           VI Multi-character bindings

           "^[?"                    ->  run-help

     In tcsh there are two input modes: insert and overwrite. All
     characters  that are bound to the self-insert-command either
     get inserted or overwrite what was under the cursor  depend-
     ing on the input mode. In emacs one can toggle between modes
     using the overwrite-mode function, and in VI one can use any
     of  the  replace  mode  commands.   By  default  the mode is
     preserved between input lines. To  specify  a  default  mode
     that  can be enforced at the beginning of each command line,
     the variable inputmode  can  be  set  to  either  insert  or

     There is also an older version of bindkey called bind,  that
     allows  the  user to redefine what any key does, or find out
     what any or all of the keys do. This is retained for  compa-
     tibility reasons.

     If given two arguments bind binds the function (first  argu-
     ment)  to  the given key (second argument).  The key may be:
     the direct character or a caret-<letter> combination,  which
     is  converted to control-<letter>; M-<letter> for an escaped
     character; or F-<string> for a function key.  For  the  last
     of these, the function key prefix must be bound to the func-
     tion "sequence-lead-in" and the string specified to the bind
     command must not include this prefix.

     If given one argument bind takes the argument  as  the  name
     for  a key and tells what that key does.  As a special case,
     the user can say

           bind emacs
           bind vi

     to bind all the keys for Emacs or vi mode respectively.

     If given no arguments bind tells what all of  the  keys  do.
     If  you  give  bind  the  single  argument of 'defaults', it
     resets each key to its default value (see the above list).

     The keys ^P and ^N are used to step up and down the  history
     list.  If the user has typed in the following:

           > ls
           foo  bar
           > echo mumble

     then enters ^P, the shell will place "echo mumble" into  the
     editing  buffer,  and  will put the cursor at the end of the
     line.  If another ^P is entered, then the editing line  will
     change  to  "ls".   More  ^Ps will make the bell ring, since
     there are no more lines in the history.  ^N works  the  same
     way, except it steps down (forward in time).

     An easy way to re-do a command is to  type  ^P  followed  by
     Return.  Also,  pieces of previous commands can be assembled
     to make a new command.  The commands that  work  on  regions
     are especially useful for this.

     ^P and ^N actually only copy commands from out of  the  his-
     tory  into the edit buffer; thus the user may step back into
     the history and then edit things, but those changes  do  not
     affect what is actually in tcsh 's history.

     Another way to recall (parts of) history commands is via the
     'expand-history'  function.  A  variation  of  the  'expand-
     history' function is called  'magic-space'.   This  function
     expands csh history, and always appends a space. Magic-space
     thus can be bound to <space>, to  automatically  expand  csh
     history.   Expand-history is normally bound to M-<space> and
     magic-space is not bound.

     As part of the editor, tcsh does a check and  reset  of  the
     terminal  mode  bits.   If  the speed has been changed, then
     tcsh will change to using that speed.  Tcsh will  also  obey
     changes  in  the padding needed by the tty.  Also, the shell
     will automatically turn off RAW and CBREAK (on systems  that
     use  termio(7)  it will turn on ICANON) modes, and will turn
     on the tty driver's output processing (OPOST).

     The list of the tty modes that are always set or cleared  by
     tcsh  can  be examined and modified using the setty builtin.
     The setty display is similar to stty(1), and varies  depend-
     ing  on the system's tty driver. Modes that tcsh will always
     try to set are shown as +mode . Modes that tcsh will  always
     try  to  clear  are  shown as -mode and modes that tcsh will
     track and allow to be modified are not shown by default,  or
     if  the  -a flag is given, are shown without a leading sign.
     For tty characters, -char disables the tty character,  while
     +char protects the tty character from being changed.

     Setty can be used to control the three different modes  tcsh
     uses  for  the  tty. The default mode displayed is the "exe-
     cute" mode which is used when tcsh  executes  commands.  The
     two  other  modes  are the "edit" mode and the "quote" mode.
     The "edit" mode is used for command line  editing,  and  the
     "quote"  mode  is used when entering literal characters. The
     "execute" mode can be specified with -x ,  the  "edit"  mode
     with  -d  ,  and the "quote" mode with -q For example if one
     wants  to  set  the  echok  flag  and  let  the  echoe  pass

           > setty
           iflag:-inlcr -igncr +icrnl
           oflag:+opost +onlcr -onlret
           lflag:+isig +icanon +echo +echoe -echok -echonl -noflsh
                 +echoctl -flusho +iexten
           > setty +echok echoe
           > setty
           iflag:-inlcr -igncr +icrnl
           oflag:+opost +onlcr -onlret
           lflag:+isig +icanon +echo +echok -echonl -noflsh +echoctl
                 -flusho +iexten

     In typing commands, it is no longer necessary to type a com-
     plete  name,  only a unique abbreviation is necessary.  When
     you type a TAB to tcsh it will complete the  name  for  you,
     echoing  the full name on the terminal (and entering it into
     the edit buffer).  If the prefix you typed matches no  name,
     the  terminal  bell  is  rung, unless the variable nobeep is
     set.  The name may be  partially  completed  if  the  prefix
     matches several longer names.  If this is the case, the name
     is extended up to the point of ambiguity, and  the  bell  is
     rung.  This works for file names, command names, shell vari-
     ables and the ~ user name convention.  The variable  fignore
     may  be  set  to a list of suffixes to be disregarded during


     Assume the current directory contained the files:

           DSC.TXT   bin       cmd       lib       memos
           DSC.NEW   chaos     cmtest    mail      netnews
           bench     class     dev       mbox      new

     The command:

           > gnumacs ch[TAB]

     would cause tcsh to complete the command with the file  name
     chaos.  If instead, the user had typed:

           > gnumacs D[TAB]

     tcsh would have extended the name to DSC and rung the termi-
     nal bell, indicating partial completion. However, if fignore
     had previously been set to a list  containing  .NEW  as  one
     element, e.g. ( .o .NEW ), tcsh would have completed the `D'
     to DSC.TXT.

     File name completion works equally well  when  other  direc-
     tories  are addressed.  Additionally, tcsh understands the C
     shell tilde (~) convention for home directories.   In  addi-
     tion  it  caches tilde name references for fast access. This
     cache can be flushed by using the builtin rehash. Thus,

           > cd ~speech/data/fr[TAB]

     does what one might expect.  This may also be used to expand
     login names only.  Thus,

           > cd ~sy[TAB]

     expands to
           > cd ~synthesis

     Command names may also be completed, for example,

           > gnum[TAB]

     will expand to "gnumacs" (assuming that there are  no  other
     commands that begin with "gnum").

     Shell and environment variables are recognized also  and  in
     addition they can be expanded:

           > set local=/usr/local
           > echo $lo[TAB]

     will expand to "$local/". Note  that  a  slash  is  appended
     because the expanded variable points to a directory. Also:

           > set local=/usr/local
           > echo $local/[^D]
           bin/ etc/ lib/ man/ src/

     will correctly list the contents of  /usr/local.  Shell  and
     environment  variables  can also be expanded via the expand-
     variables function:

           > echo $local/[^X$]
           > echo /usr/local/

     Completion also works when the cursor is in  the  middle  of
     the  line,  rather than just the end.  All of the text after
     the cursor will be saved, the completion will work (possibly
     adding to the current name), and then the saved text will be
     restored in place, after the cursor.

     The behavior of the completion can be changed by the setting
     of several shell variables:

     Setting the recexact variable  makes  an  exact  command  be
     expanded  rather  than  just ringing the bell.  For example,
     assume the current directory has two  subdirectories  called
     foo  and food, then with recexact set the following could be

           > cd fo[TAB]
     to ...
           > cd foo[TAB]
     to ...
           > cd foo/

     rather than beeping on the second TAB.

     If the autolist variable is set,  invoking  completion  when
     several  choices  are  possible  will automatically list the
     choices, effectively merging the functionality described  in
     the  next section into the completion mechanism. If autolist
     is set to "ambiguous", then tcsh will only list the  choices
     if  there  were  no  new  characters added in the completion

     The "noise level" can be controlled by the value that match-
     beep is set to: With matchbeep=nomatch, completion will only
     beep   if   there    are    no    matching    names;    with
     matchbeep=ambiguous,  completion will also beep if there are
     many possible matches; with matchbeep=notunique,  completion
     will  also  beep  when there is an exact match but there are
     other, longer, matches (see recexact).  With matchbeep=never
     or  set  to  any  other value completion will never beep. If
     matchbeep is not set it defaults to ambiguous.

     If the autoexpand variable is set, the expand-history  func-
     tion  will  be  invoked  automatically before the completion
     attempt, expanding normal csh history substitutions.

     For covert operation, the variable nobeep  can  be  set;  it
     will  prevent  the  completion mechanism, as well as tcsh in
     general, from actually beeping.  Finally, if the autocorrect
     variable  is  set,  the spelling correction is attempted for
     any path components up to the completion point.

     At any point in typing a  command,  you  may  request  "what
     names are available".  Thus, when you have typed, perhaps:

           > cd ~speech/data/fritz/

     you may wish to know what files or subdirectories exist  (in
     ~speech/data/fritz),  without,  of course, aborting the com-
     mand you are typing.  Typing the character  Control-D  (^D),
     will  list  the  names (files, in this case) available.  The
     files are listed in multicolumn format, sorted  column-wise.
     Directories  are  indicated  with a trailing `/', executable
     files with a `*', symbolic links with a '@', sockets with  a
     '=',  FIFOs (named pipes) with a '|', character devices with
     a '%', and block devices with a '#'.  Once printed, the com-
     mand is re-echoed for you to complete.

     Additionally, one may want to know which files match a  pre-
     fix.  If the user had typed:

           > cd ~speech/data/fr[^D]

     all files and subdirectories whose prefix was  ``fr''  would
     be  printed.   Notice  that  the example before was simply a
     degenerate case of this with a null trailing file name. (The
     null string is a prefix of all strings.) Notice also, that a
     trailing slash is required to pass to a  new  directory  for
     both file name completion and listing.

     The degenerate

           > ~[^D]

     will print a full list of login names on the current system.
     Note, however, that the degenerate

           > <Spaces>[^D]

     does not list all of the commands, but only beeps.

     Listing/expanding of words  that  match  a  name  containing
     wildcard  characters  can  be done via the list-glob/expand-
     glob function:
           > ls
           foo.c  bar.c  a.out
           > vi *.c[^Xg]
           foo.c bar.c
           > vi *.c[^X*]
           > vi foo.c bar.c

Command Name Recognition
     Command name recognition and completion works  in  the  same
     manner  as  file name recognition and completion above.  The
     current value of the environment variable PATH  is  used  in
     searching for the command.  For example

           > newa[TAB]

     might expand to

           > newaliases


           > new[^D]

     would list all commands (along PATH) that begin with "new".

     Note that Control-D has three different effects on tcsh.  On
     an  empty line (one that contains nothing, not even spaces),
     ^D sends an EOF to tcsh just as it does for normal programs.
     When  the  cursor  is  in  the  middle of a line of text, ^D
     deletes the character that the cursor is under.  Finally,  a
     ^D at the end of a line of text lists the available names at
     that point.  To get a list of available names when the  cur-
     sor  is  in  the  middle  of a line (or on an empty line), a
     Meta-Control-D should be typed (Escape followed by  Control-

     If while typing a command, the user mistypes or misspells  a
     file  name, user name, or command name, tcsh can correct the
     spelling.  When correcting a file name,  each  part  of  the
     path   is  individually  checked  and  corrected.   Spelling
     correction can be invoked in several different ways:

     The spell-word function, normally bound to  M-s  (and  M-S),
     will attempt to correct the word immediately before the cur-
     sor.  For example, suppose that the user has typed:

           > cd /uxr/spol/news[ESC s]

     Tcsh will check the path for spelling, correct the mistakes,
     and redraw the line as

           > cd /usr/spool/news

     leaving the cursor at the end of the line.

     Spelling correction of the entire command line  (independent
     of  where  the  cursor  is)  can be done with the spell-line
     function, normally bound to M-$  (Escape  Dollar-sign).   It
     will  check  each  word independently, but in order to avoid
     e.g. command options, no correction is  attempted  on  words
     whose first character is found in the string "!.\^-*%".

     Finally, automatic spelling correction  will  be  done  each
     time  the  Return key is hit, if the correct variable is set
     to an appropriate value: correct=cmd will cause the spelling
     of  the  command  name only to be checked, while correct=all
     causes checking of all words on the line,  like  the  spell-
     line   function.   If  any  part  of  the  command  line  is
     corrected, the user  will  be  given  a  special  prompt  as
     defined  by  the prompt3 variable, followed by the corrected
     line, e.g.

           > lz /usr/bin
           CORRECT>ls /usr/bin (y|n|e)?

     Answering 'y' or  <space>  at  the  prompt  will  cause  the
     corrected   line   to   be  executed,  'e'  will  leave  the
     uncorrected command in the input buffer  and  anything  else
     will execute the original line unchanged.

     Automatic correction is not guaranteed to work the  way  the
     user   intended.    Command   line  parsing  is  done  in  a
     rudimentary fashion. It is mostly provided as an  experimen-
     tal feature. Suggestions and improvements are welcome.

     The editor function run-help (M-h) prints a help file on the
     current command (using the same definition of current as the
     completion routines  use).   This  help  file  is  found  by
     searching  the  path  list  HPATH  for  files  of  the  form, foo.1, foo.8, or foo.6  in  that  order  (assuming
     that the current command is foo).  The file is just printed,
     not paged in any way.  This is because run-help is meant  to
     be  used  to  look  up  short  help  files, not manual pages
     (although it can do manual pages also).

     Tcsh will save the history list between login sessions.   It
     does  this  by writing the current list to the file "~/.his-
     tory" on logout, and reading it in on login.   For  example,
     placing the line

           > set history=25 savehist=20

     tells tcsh to save the last 25 commands on the history list,
     and  to  save  the  last  20  of  them  between logins.  The
     "savehist" variable may be set up to the  size  of  history,
     although  it  is  an error to have savehist larger than his-
     tory.  In  addition  to  the  above  tcsh,  keeps   unparsed
     (literal) versions of the history if the variable histlit is
     set. Also the toggle-history function  toggles  between  the
     parsed  and  literal  version of the recalled history in the
     editor buffer. For example:

           > set histlit
           > echo !:s/foo/bar; ls
           Modifier failed.
           > ^P
           > echo !:s/foo/bar; ls
           > unset histlit
           > echo !:s/foo/bar; ls
           Modifier failed.
           > ^P
           > echo unset histlit[M-r]
           > echo !:s/foo/bar; ls

     Tcsh also supports the history escape !#. This  undocumented
     csh escape holds the words of the current line. This is use-
     ful in renaming commands:

           > mv foo bar!#:1
           mv foo barfoo

     Care should be taken when using this  history  expansion  in
     csh  since there is no check for recursion. In tcsh up to 10
     levels of recursion are allowed.

     Another difference between tcsh and csh  history  expansion,
     is the treatment of history arguments. In csh !3d expands to
     event 3 with the letter "d" appended to it. There is no  way
     to repeat a command that begins with a number using the name
     of the command in the history escape. In tcsh  only  numeric
     arguments  are  treated  as  event numbers; therefore !3d is
     interpreted as: repeat the last command  that  started  with
     the string "3d". To mimic the csh behavior !3\d can be used.

     The automatic locking and logout time are controlled by  the
     variable  autologout.  The  value  of  the first word is the
     number of minutes  of  inactivity  will  be  allowed  before
     automatically  logging the user out.  When that many minutes
     have been reached, the shell prints "auto-logout"  and  dies
     (without  executing  ~/.logout).  The default for tcsh is to
     set autologout for 60 minutes on login shells, and when  the
     user is root.  To disable autologout (for instance in a win-
     dow system), unset the shell variable autologout.

     The value of the optional second word indicates  the  number
     of  minutes  of  inactivity  after  which  the  user will be
     prompted for his login password to continue working. Failure
     to  enter  the  correct  password  5 times, results in auto-

     Tcsh supports a special alias, precmd, which if set holds  a
     command  that  will be executed before printing each prompt.
     For example, if the user has done

           > alias precmd date

     then the program date will be  run  just  before  the  shell
     prompts  for each command.  There are no limitations on what
     precmd can be set to do, although discretion should be used.

     Tcsh is now capable of providing periodic command  execution
     through  the use of the shell variable tperiod and the alias
     periodic. When these items are set, the alias periodic  will
     be  executed  every  tperiod  minutes.  This provides a con-
     venient means for checking on common but infrequent changes,
     such as new messages.  Example:

           > set tperiod = 30
           > alias periodic checknews

     This will cause the checknews(1) program to be run every  30
     minutes.   Having  the  alias periodic set but with an unset
     tperiod (or a value of 0 for tperiod) will cause periodic to
     degenerate to another form of precmd.

     The format for the prompt shell variable has been changed to
     include  many  new  things, such as the current time of day,
     current  working  directory,  etc..   The  new  format  uses
     "%<char>"  to signal an expansion, much like printf(3S). The
     available sequences are:

           %/          Current working directory.
           %~          cwd.  If it starts with $HOME, that part is
                       replaced by a ~. In addition if a directory
                       name prefix matches a user's home directory,
                       that part of the directory will be substituted
                       with ~user. NOTE: The ~user substitution will
                       only happen if the shell has performed a ~
                       expansion for that user name in this session.
           %c or %.    Trailing component of cwd, may be
                       followed by by a digit to get more than one
                       component, if it starts with $HOME, that
                       part is replaced with a ~.
           %C          Trailing component of cwd, may be followed
                       by a digit to get more than one component, no
                       ~ substitution.
           %h, %!, !   Current history event number.
           %M          The full machine hostname.
           %m          The hostname up to the first ".".
           %S (%s)     Start (stop) standout mode.
           %B (%b)     Start (stop) boldfacing mode. (Only if
                       tcsh was compiled to be eight bit clean.)
           %U (%u)     Start (stop) underline mode. (Only if
                       tcsh was compiled to be eight bit clean.)
           %t or %@    Current time of day, in 12-hour, am/pm format.
           %T          Current time of day, in 24-hour format.
                       (But see the ampm shell variable below.)
           \c          `c' is parsed the same way as in bindkey.
           ^c          `c' is parsed the same way as in bindkey.
           %%          A single %.
           %n          The user name, contents of $user.
           %d          The weekday in <Day> format.
           %D          The day in dd format.
           %w          The month in <Mon> format.
           %W          The month in mm format.
           %y          The year in yy format.
           %Y          The year in yyyy format.
           %l          The line (tty) the user is logged on.
           %L          clear from prompt to end of display or end of line.
           %#          A `#' if tcsh is run as a root shell,
                       a `>' if not.

           %{..%}      Include string as a literal escape sequence.
                       Note that the enclosed escape sequence, should
                       only be used to change terminal attributes and
                       should not move the cursor location. Also, this
                       cannot be the last character in the prompt
                       string. (Available only if tcsh was compiled to
                       be eight bit clean.)
           %?          return code of the last command executed just
                       before the prompt.
           %R          In prompt3 this is the corrected string; in
                       prompt2 it is the status of the parser.

     The sequences for standout are often used to  indicate  that
     this is an enabled (running as root) shell.  An example:

           > set prompt="%m [%h] %U[%@]%u [%/] you rang? "
           tut [37] [2:54pm] [/usr/accts/sys] you rang? _

     In addition, there is a new variable, prompt2, which is used
     to prompt for the body of while and for loops (wherever nor-
     mal csh prompts with a  question  mark).   The  default  for
     prompt2  is  "%R?  ": the status of the parser followed by a
     question mark.  This alternate prompt is also used when  the
     parser  is  waiting  for  more input; i.e. when the previous
     line ended in a  \.   The  prompt3  variable  is  used  when
     displaying  the  corrected command line when automatic spel-
     ling correction is in effect;  it  defaults  to  "CORRECT>%R
     (y|n|e)? ".

     The history  list  in  tcsh  now  has  a  time-of-day  stamp
     attached  to  each  history  list event.  This time stamp is
     printed whenever the  history  command  is  executed.   This
     allows  the  user  to  keep track of when the various events
     occurred.  The time stamps are not maintained on  the  saved
     history  list (also available in csh); thus, on logging back
     in, all the saved history events will be recorded  with  the
     login  time  as  their time stamp.  The time stamp printouts
     can be omitted from the history list by adding the -t switch
     to the history command.

     Tcsh supports three new flags  to  control  directory  style
     printing for cd, pushd, popd, and dirs:

     -n  Print entries in new lines so that the screen  width  is
         not exceeded

     -l  Don't print ~ but print the whole path

     -v  Print the stack entries one in each  line,  preceded  by
         the stack number.

     Note that popd +n can be used to pop out  stack  entries  of
     directories that do not exist any more.

     Tcsh will now allow the user to access all elements  in  the
     directory  stack  directly.  The syntax "=<digit>" is recog-
     nized by tcsh as indicating a particular  directory  in  the
     stack.  (This works for the file/command name recognition as
     well.) This syntax is analogous to the ~ syntax  for  access
     to  users'  home  directories.  The stack is viewed as zero-
     based, i.e., =0 is the same as $cwd, which is  the  same  as
     ".".   As  a  special case, the string "=-" is recognized as
     indicating the last directory in the stack.  Thus,

           > dirs -v
           0 /usr/net/bin
           1 /usr/spool/uucp
           2 /usr/accts/sys
           > echo =2
           > ls -l =1/LOGFILE
           -rw-r--r-- 1 uucp   2594 Jan 19 09:09 /usr/spool/uucp/LOGFILE
           > echo =-/.cs*
           > echo =4
           Not that many dir stack entries.

     Tcsh will complain if you ask for  a  directory  stack  item
     which does not exist.

     In the normal csh, saying "pushd +2" would rotate the entire
     stack  around  through  2  stack elements, placing the entry
     found there at the top of the stack.  If, however,  the  new
     shell variable dextract is set, then issuing "pushd +n" will
     cause the nth directory stack element to be  extracted  from
     its current position, which will then be pushed onto the top
     of the stack.  Example:

           > dirs
           ~ /usr/spool/uucp /usr/net/bin /sys/src
           > set dextract
           > pushd +2
           /usr/net/bin ~ /usr/spool/uucp /sys/src
           > unset dextract
           > pushd +2
           /usr/spool/uucp /sys/src /usr/net/bin ~

     The way symbolic links that point to directories are crossed
     is   determined   by   two   variables:  chase_symlinks  and
     ignore_symlinks. If chase_symlinks is set, then  every  time
     the  directory  changes,  $cwd  reflects  the real directory
     name, and not the name through the link. A notable exception
     is  the  user's home directory, but that should be fixed. If
     ignore_symlinks is set, then directory change tries to  find
     where  you  came  from before you crossed the link to change
     the directory relatively. If you chdir  through  a  symbolic
     link and then cd .., you will end .. relatively to where you
     were before you crossed the link and not  ..  relatively  to
     where the symbolic link points.

     For example:

           > cd /tmp
           > mkdir from from/src to
           > ln -s ../from/src to/dst
           > echo $cwd

           > unset ignore_symlinks; unset chase_symlinks
           > cd to/dst; echo $cwd
           > cd ..

           > unset ignore_symlinks; set chase_symlinks
           > cd /tmp/to/dst; echo $cwd
           > cd ..; echo $cwd

           > set ignore_symlinks; unset chase_symlinks
           > cd /tmp/to/dst; echo $cwd
           > cd ..; echo $pwd

     In case you are wondering what happens when  you  set  both,
     ignore_symlinks will override chase_symlinks.

     Tcsh has a mechanism so that the user can  watch  for  login
     and  logout  activity of any user or terminal in the system.
     This is accomplished using the new  special  shell  variable
     watch,  which  contains  login/terminal  pattern pairs to be
     checked for activity.  For example:

           > set watch=(sys ttyjd root console)

     This setting will allow the user to check on when  the  user
     "sys"  logs in on /dev/ttyjd.  Similarly, it will inform the
     user of root's activity on the console.  In order to be more
     general,  the  word  "any"  may  be substituted for either a
     user's or a terminal's name, thus allowing

           > set watch=('b*' any any ttyh0)

     which will check for users that match the pattern 'b*'  log-
     ging  in  or  out  of the system on any terminal, as well as
     anyone logging in to /dev/ttyh0. Naturally,  the  completely
     general case

           > set watch=(any any)

     allows the  user  to  check  on  any  and  all  login/logout
     activity in the the system.

     By default, the interval between checks of users on the sys-
     tem  is  10 minutes; this can be changed by making the first
     element of watch a number of minutes which  should  be  used
     instead, as in

           > set watch=(40 any any)

     which will check for any users logging in or  out  every  40

     There is also a new command, log, which  is  used  to  cause
     tcsh  to  inform the user of all users/terminals affected by
     watch whether they have been announced before or not.   This
     is  useful  if  a  user has been on for some time and cannot
     remember if a particular person/terminal is online right now
     or not.  Log will reset all indication of previous announce-
     ment and give the user the login list  all  over  again,  as
     well as printing the current value of watch.

     The first time that  watch  is  set  at  tcsh  startup,  all
     affected users and terminals will be printed as though those
     users/terminals had just logged on.  This may appear to be a
     bug,  but is generally considered a feature, since it allows
     the user to see who is on when he first logs in.

     The format of the printouts can be tailored via  setting  of
     the  variable who. The following sequences are available for
     the format specification:

           %n          The name of the user that logged in/out.
           %a          The observed action, i.e. "logged on",
                       "logged off", or "replaced <olduser> on".
           %l          The line (tty) the user is logged on.
           %S (%s)     Start (stop) standout mode.
           %B (%b)     Start (stop) boldfacing mode. (Only if
                       tcsh was compiled to be eight bit clean)
           %U (%u)     Start (stop) underline mode. (Only if
                       tcsh was compiled to be eight bit clean)

           %M          The full hostname of the remote host ("local"
                       if non-remote).
           %m          The hostname up to the first ".". If only
                       the ip address is available or the utmp
                       field contains the name of an x-windows
                       display, the whole name is printed.
           %t or %@    The time, in 12-hour, am/pm format (logout
                       time is approximated if unavailable).
           %T          The time, in 24-hour format. (but see
                       the "ampm" shell variable below).
           %D          The day in dd format.
           %w          The month in <Mon> format.
           %W          The month in mm format.
           %Y          The year in yy format.

     The %M and %m sequences are only available on  systems  that
     store  the  remote hostname in /etc/utmp. If who is not set,
     the format defaults to "%n has %a %l from %m.", or  "%n  has
     %a %l." on systems that don't store the hostname.

     Tcsh now supports a scheduled-event list through the use  of
     the  command  sched. This command gives the user a mechanism
     by which to arrange for other commands  to  be  executed  at
     given  times.  An event is added to the scheduled-event list
     by saying

           > sched [+]hh:mm <command>

     as in

           > sched 11:00 echo It\'s eleven o\'clock.

     This will make an entry in the list at  11am  for  the  echo
     command to be run with the given arguments.  The time may be
     specified in either absolute or relative time, and  absolute
     times  may  have  a morning/afternoon specification as well,
     using "am" or "pm." For example,

           > sched +2:15 /usr/lib/uucp/uucico -r1 -sother
           > sched 5pm set prompt='[%h] It\'s after 5; go home: >'
           > sched +3am echo This syntax doesn\'t work.
           Relative time inconsistent with am/pm.

     Note that tcsh will complain if you try to make faulty  time

     Printing the current time-event list is accomplished by giv-
     ing the sched command with no arguments:

           > sched
                1  Wed Apr  4 15:42  /usr/lib/uucp/uucico -r1 -sother
                2  Wed Apr  4 17:00  set prompt=[%h] It's after 5; go home: >

     There is also a mechanism by which the user  can  remove  an
     item from the list:

           > sched --3
           Usage for delete: sched -<item#>.
           > sched -3
           Not that many scheduled events.
           > sched -2
           > sched
                1  Wed Apr  4 15:42  /usr/lib/uucp/uucico -r1 -sother

     All commands specified on the scheduled-event list  will  be
     executed just prior to printing the first prompt immediately
     following the time when the command is to be run.  Hence, it
     is possible to miss the exact time when the command is to be
     run, but tcsh will definitely get  around  to  all  commands
     which  are overdue at its next prompt.  Scheduled-event list
     items which come due while tcsh is waiting  for  user  input
     will  be  executed  immediately.   In no case, however, will
     normal operation of already-running commands be  interrupted
     so that a scheduled-event list element may be run.

     This mechanism is similar to, but not the same as, the at(1)
     command  on  some  Unix  systems.  Its major disadvantage is
     that it does not necessarily run a command  at  exactly  the
     specified time (but only if another command is already being
     run).  Its  major  advantage  is  that  commands  which  run
     directly  from  tcsh,  as sched commands are, have access to
     shell variables  and  other  structures.   This  provides  a
     mechanism  for  changing  one's working environment based on
     the time of day.

     There is a new builtin command called ls-F  which  does  the
     same  thing  as  the  command "ls -aF" if the shell variable
     showdots has been set, and acts like "ls -F" otherwise. Ls-F
     works  like  ls,  only  it  is  generally  faster.  If other
     switches are passed to ls-F, then the normal ls is executed.
     Aliasing ls to ls-F provides a fast alternative way of list-
     ing files.  Note that on non BSD machines, where  ls  -C  is
     not the default, ls-F, behaves like ls -CF.

     ls-F appends the following characters depending on the  file

           =           File is an AF_UNIX domain socket.
                       [if system supports sockets]

           |           File is a named pipe (fifo)
                       [if system supports named pipes]
           %           File is a character device
           #           File is a block device
           /           File is a directory
           *           File is executable
           +           File is a hidden directory [aix]
                       or context dependent [hpux]
           :           File is network special [hpux]

     On systems that support symbolic links  the  variable  list-
     links  controls  the  way  symbolic links are identified. If
     listlinks is not set then the character '@' is  appended  to
     the  file. If listlinks is set then the following characters
     are appended to the filename depending on the type  of  file
     the symbolic links points to:

           @           File is a symbolic link pointing
                       to a non-directory
           >           File is a symbolic link pointing
                       to a directory
           &           File is a symbolic link pointing
                       to nowhere

     While setting listlinks  can  be  helpful  while  navigating
     around  the  file  system,  it slows down ls-F and it causes
     mounting of file systems if the symbolic links point  to  an
     NFS auto-mounted partition.

     The syntax for any character in a range (for  example  ".[a-
     z]*")  has been extended so as to conform with standard Unix
     regular expression syntax (see ed(1)).  Specifically,  after
     an  open  bracket  ("["),  if the first character is a caret
     ("^") then the character matched will  be  any  not  in  the
     range specified.  For example:

           > cd ~
           > echo .[a-z]*
           .cshrc .emacs .login .logout .menuwmrc
           > echo .[^.]*
           .Xdefaults .Xinit .cshrc .emacs .login .logout .menuwmrc

     Note that the second form  includes  .Xdefaults  and  .Xinit
     because  'X' (and all the lower case letters) are outside of
     the range of a single '.'.

     Also the ability to  negate  a  globbing  pattern  has  been

           > echo *
           foo foobar bar barfoo
           > echo ^foo*
           bar barfoo

     Note that this does not work  correctly  if  the  expression
     does  not  have  any  wildcard  characters  (?*[]) or if the
     expression has braces {}.

     On startup, tcsh now automatically initializes the  environ-
     ment  variable  HOST  to  the name of the machine that it is
     running on.  It does this by doing a  gethostname(2)  system
     call, and setting HOST to the result.

     Tcsh also initializes the environment variable HOSTTYPE to a
     symbolic  name  for  the type of computer that it is running
     on.  This is useful when sharing a single physical directory
     between   several   types  of  machines  (running  NFS,  for
     instance).  For example, if the following is in .login:

        set  path  =  (~/bin.$HOSTTYPE  /usr/ucb  /bin   /usr/bin
        /usr/games .)

     and the user  has  directories  named  "bin.machine"  (where
     machine  is  a  name from the list below), then the user can
     have the same programs compiled for  different  machines  in
     the  appropriate "bin.machine" directories and tcsh will run
     the binary for the correct machine.

     The current possible values are:

     aix370         an IBM 370, running aix
     aixESA         an IBM ESA, running aix
     alliant        an Alliant FX series
     amdahl         an Amdahl running uts 2.1
     apollo         an Apollo running DomainOS
     att3b15        an AT&T 3b15
     att3b2         an AT&T 3b2
     att3b20        an AT&T 3b20
     att3b5         an AT&T 3b5
     balance        a Sequent Balance (32000 based)
     butterfly      a BBN Computer Butterfly 1000
     convex         a Convex
     cray           a Cray running Unicos
     decstation     a DecStation XXXX
     eta10          an ETA 10 running SVR3
     gould-np1      a Gould NP1
     hk68           a Heurikon HK68 running Uniplus+ 5.0
     hp300          an HP 9000, series 300, running mtXinu
     hp800          an HP 9000, series 800, running mtXinu
     hp9000s300     an HP 9000, series 300, running hpux
     hp9000s500     an HP 9000, series 500, running hpux
     hp9000s700     an HP 9000, series 700, running hpux
     hp9000s800     an HP 9000, series 800, running hpux
     hp             an HP, running hpux
     i386           an Intel 386, generic
     i386-mach      an Intel 386, running mach
     intel386       an Intel 386, running INTEL's SVR3
     iris3d         a Silicon Graphics Iris 3000
     iris4d         a Silicon Graphics Iris 4D
     isc386         an Intel 386, running ISC
     m88k           an mc88000 CPU machine
     mac2           an Apple Computer Macintosh II, running AUX
     masscomp       a Concurrent (Masscomp), running RTU
     minix386       an i386 running minix
     minix          a mac or an amiga running minix
     mips           another mips CPU
     multimax       an Encore Computer Corp. Multimax (32000 based)
     news           a Sony NEWS 800 or 1700 workstation
     news_mips      a NeWS machine with mips CPU
     nd500          a Norsk Data ND 500/5000 running Ndix
     ns32000        an NS32000 CPU machine
     next           a NeXT computer
     pfa50          a PFU/Fujitsu A-xx computer
     ps2            an IBM PS/2, running aix
     ptx            a Sequent Symmetry running DYNIX/ptx (386/486 based)
     pyramid        a Pyramid Technology computer (of any flavor)
     rs6000         an IBM RS6000, running aix
     rt             an IBM PC/RT, running BSD (AOS 4.3) or mach
     rtpc           an IBM PC/RT, running aix
     sco386         an Intel 386, running SCO
     stellar        a stellar running stellix
     sun            a Sun workstation of none of the above types
     sun2           a Sun Microsystems series 2 workstation (68010 based)
     sun3           a Sun Microsystems series 3 workstation (68020 based)
     sun386i        a Sun Microsystems 386i workstation (386 based)
     sun4           a Sun Microsystems series 4 workstation (SPARC based)
     symmetry       a Sequent Symmetry running DYNIX 3 (386/486 based)
     titan          an Stardent Titan
     unixpc         an UNIX/PC running SVR1 att7300 aka att3b1
     vax            a Digital Equipment Corp. Vax (of any flavor)

     (The names of the machines are usually trade  marks  of  the
     corresponding companies.)

     Tcsh also initializes the shell variables uid and gid to the
     value  of  the current real user ID/GID.  This is useful for
     telling what user/group  the  shell  is  running  as.  Under
     Domain/OS tcsh will also set oid indicating the current real
     organization id.

     Only two such commands are available  at  this  point,  both
     concerned with testing termcap entries.
     telltc tells you, politely, what tcsh thinks of your  termi-
     nal,  and settc `cap' `value' tells tcsh to believe that the
     termcap capability `cap' ( as defined in  termcap(5)  )  has
     the  value  `value'. No checking for sanity is performed, so
     beware of improper use.

     Four new editor functions have been added in emacs mode: Two
     of  them,  history-search-backward,  bound to M-p (and M-P),
     and history-search-forward, bound to M-n (and  M-N),  imple-
     ment  a  conventional search mechanism, while the other two,
     i-search-back and i-search-fwd,  both  unbound  by  default,
     implement the emacs-style incremental search.

     History-search-backward  (history-search-forward)   searches
     backward  (forward)  through  the  history list for previous
     (next) occurrence of the beginning of the input buffer as  a
     command.  That is, if the user types:

           > echo foo
           > ls
           filea     fileb
           > echo bar

     and then types "echo<ESC>p", the shell will place "echo bar"
     in  the  editing  buffer.   If  another M-p was entered, the
     editing buffer would change to "echo foo".  This  capability
     is  compatible  with  the  plain visual history; if the user
     were to then enter ^P the editing buffer would be changed to
     "ls".  The  pattern  used  to  search through the history is
     defined by the characters from the beginning of the line  up
     to the current cursor position and may contain a shell glob-
     bing pattern. Successive history searches use the same  pat-

     When the incremental search functions are used, a  prompt  -
     "bck:"  or  "fwd:",  depending  on  the  chosen  direction -
     appears, and characters typed are  appended  to  the  search
     pattern.  The matching command line is placed in the editing
     buffer, with the cursor positioned at the  point  where  the
     pattern  was  found  (the  incremental  search  will also do
     searching within a command line).  If the search fails,  the
     terminal  bell is rung, and the ':' in the prompt is changed
     to '?'.

     If these functions are bound to single characters,  and  one
     of  those  is typed again during the incremental search, the
     search continues in the corresponding  direction,  with  the
     pattern  unchanged; if the previous search failed, this will
     also cause it to "wrap around" the history  list.   Finally,
     the  following characters also have a special meaning during
     the search:

           Delete      (or any character bound to backward-delete-char)
                       Undo the effect of the last character typed,
                       deleting a character from the pattern if appropriate.
           ^G          Abort the search, back to the last successful one
                       if previous search failed, otherwise entire search.
           ^W          Append the rest of the current word to the pattern.
           ESC         Terminate the search, leaving current line in buffer.

     Any  other  character,  that  isn't  bound  to  self-insert-
     command,  terminates the search, leaving the current command
     line in the editing buffer, after which tcsh interprets  the
     character  as  if  it was normal input - notably Return will
     cause the current command line to be executed.

     In vi mode "vi-search-fwd" (bound to  '/')  and  "vi-search-
     back"  (bound  to '?') can be used to search the visual his-
     tory. In command mode '/' or '?' followed by  a  shell  pat-
     tern,  searches the visual history for the pattern. The pat-
     tern can be terminated either with a Return, in  which  case
     the matched history event is placed in the command buffer or
     an Escape, in which case the matched history event  is  exe-
     cuted.  If  no  history event matches the shell pattern then
     the bell is rung.

     There is now a builtin version of the which(1) command.  The
     builtin  version  is  just like the original, except that it
     correctly reports aliases peculiar to this tcsh, and builtin
     commands.   The  only  other  difference is that the builtin
     runs somewhere between 10 and 100 times  faster.   There  is
     also  a  key-function  interface to this command: the which-
     command function (normally bound to M-?), can be  used  any-
     where  on  the command line, and will in effect do a 'which'
     on the command name.

     Similarly where will report all known instances of the  com-
     mand:  aliases,  builtins,  as well as all references in the

     There is another new editor function:  run-fg-editor,  which
     is  bound  to  M-^Z.   When typed, it saves away the current
     input buffer, and looks for a stopped job with a name  equal
     to the file name part (last element) of either the EDITOR or
     VISUAL environment variables (if not  defined,  the  default
     names  are  "ed"  and  "vi" respectively).  If such a job is
     found, then it is restarted as if "fg %name" had been typed.
     This  is used to toggle back and forth between an editor and
     the shell easily.  Some people bind this function to  ^Z  so
     they can do this even more easily.

     Tcsh has a new builtin called echotc that allows the user to
     access  the  terminal  capabilities  from  the command line,
     similar to the system V tput(1).

           > echotc home

     Places the cursor at the home position and

           > echotc cm 3 10

     places the cursor at column 3 row 10.  This command replaces
     the  el  and  sl  variables  that  used  contain  the escape
     sequences to begin and end status line changes. The command:

           > echo $sl this is a test $el

     is replaced by:

           > echotc ts 0; echo "this is a test"; echotc fs

     In addition echotc understands the  arguments  baud,  lines,
     cols, meta, and tabs And prints the baud rate, the number of
     lines and columns, and "yes" or "no" depending if the termi-
     nal has tabs or a meta key.  This can be useful in determin-
     ing how terse the output of commands will  be  depending  on
     the baud rate, or setting limits to commands like history to
     the highest number so that the terminal does not scroll:

           > set history=`echotc lines`
           > @ history--

     Note: Termcap strings may contain wildcard  characters,  and
     echoing  them  will not work correctly. The suggested method
     of setting shell variables to terminal capability strings is
     using double quotes, as in the following example that places
     the date in the status line:

           > set tosl="`echotc ts 0`"
           > set frsl="`echotc fs`"
           > echo -n "$tosl";date; echo -n "$frsl"

     Echotc accepts two flags. The flag -v enables  verbose  mes-
     sages  and  the  flag  -s ignores any errors and returns the
     empty string if the capability is not found.

     Tcsh now supports a special  alias,  cwdcmd,  which  if  set
     holds  a  command  that  will be executed after changing the
     value of $cwd.  For example, if the user is running on an  X
     window  system  xterm(1),  and a re-parenting window manager
     that supports title bars such as twm(1) and has done:

           > alias cwdcmd  'echo -n "^[]2;${HOST}:$cwd ^G"'

     then the shell will change the title of the running xterm(1)
     to  be  the  name of the host, a colon, and the full current
     working directory. A more fancy way to do that is:

           >        alias         cwdcmd         'echo         -n

     This will put the hostname  and  working  directory  on  the
     title  bar  but  only the hostname in the icon manager menu.
     Note that if a user defines cwdcmd to contain a  cd,  pushd,
     or  popd,  command,  an  infinite  loop may result.  In this
     case, it is the author's opinion that  said  user  will  get
     what he deserves.

     Tcsh is eight bit clean (if so compiled, see the description
     of  the version shell variable below), and will thus support
     character sets needing this capability.   The  tcsh  support
     for  NLS differs depending on whether it was compiled to use
     the system's NLS (again, see the version variable)  or  not.
     In  either  case,  the  default for character classification
     (i.e. which characters are printable etc) and sorting is  7-
     bit  ascii,  and  any  setting  or  unsetting of the LANG or
     LC_CTYPE environment variables will cause a check for possi-
     ble changes in these respects.

     When using the system's NLS, the setlocale C  library  func-
     tion will be called to determine appropriate character clas-
     sification and sorting - this function will typically  exam-
     ine  the LANG and LC_CTYPE variables for this purpose (refer
     to the system documentation for  further  details).   Other-
     wise, NLS will be simulated, by assuming that the ISO 8859-1
     character set is  used  whenever  either  of  the  LANG  and
     LC_CTYPE  variables  are  set,  regardless  of their values.
     Sorting is not affected for the simulated NLS.

     In addition, with both real and simulated NLS, all printable
     characters  in  the range \200-\377, i.e. those that have M-
     <char> bindings, are automatically rebound  to  self-insert-
     command  (the  corresponding  binding  for the escape+<char>
     sequence, if any, is left alone).  This automatic  rebinding
     is  inhibited  if the NOREBIND environment variable is set -
     this may be useful for the simulated  NLS,  or  a  primitive
     real  NLS  which  assumes  full ISO 8859-1 (otherwise all M-
     <char> bindings in the range \240-\377 will  effectively  be
     undone  in  these cases).  Explicitly rebinding the relevant
     keys, using bindkey, is of course still possible.

     Unknown characters (i.e. those that  are  neither  printable
     nor  control characters) will be printed using the \nnn for-
     mat.  If the tty is not in 8 bit mode, other 8  bit  charac-
     ters  will  be printed by converting them to ascii and using
     standout mode.  Tcsh will never change the 7/8 bit  mode  of
     the  tty,  and will track user-initiated settings for this -
     i.e. it may be necessary for NLS users (or, for that matter,
     those that want to use a Meta key) to explicitly set the tty
     in 8 bit mode through the  appropriate  stty(1)  command  in
     e.g. the .login file.

     Automatic process time reporting is a feature that exists in
     csh, but it is usually not documented. In addition tcsh pro-
     vides a slightly enriched syntax. Process time  reports  are
     controlled  via  the time shell variable.  The first word of
     the time  variable  indicates  the  minimum  number  of  CPU
     seconds  the  process has to consume before a time report is
     produced. The optional second word controls  the  format  of
     the  report.   The following sequences are available for the
     format specification:

           %U          The time the process spent in user mode
                       in cpu seconds.
           %S          The time the process spent in kernel mode
                       in cpu seconds.
           %E          The elapsed time in seconds.
           %P          The CPU percentage computed as (%U + %S) / %E.

     The following sequences are supported only in  systems  that
     have the BSD resource limit functions.

           %W          Number of times the process was swapped.
           %X          The average amount in (shared) text space used
                       in Kbytes.
           %D          The average amount in (unshared) data/stack
                       space used in Kbytes.
           %K          The total space used (%X + %D) in Kbytes.
           %M          The maximum memory the process had in use at
                       any time in Kbytes.
           %F          The number of major page faults (page needed to
                       be brought from disk).
           %R          The number of minor page faults.
           %I          The number of input operations.
           %O          The number of output operations.
           %r          The number of socket messages received.
           %s          The number of socket messages sent.
           %k          The number of signals received.
           %w          Number of voluntary context switches (waits).
           %c          Number of involuntary context switches.

     The default time format is "%Uu %Ss  %E  %P  %X+%Dk  %I+%Oio
     %Fpf+%Ww"  for systems that support resource usage reporting
     and "%Uu %Ss %E %P" for systems that do not.

     For Sequent's DYNIX/ptx %X, %D, %K, %r and %s are  not  sup-
     ported.   However,  the  following  additional sequences are

           %Y          The number of system calls performed.
           %Z          The number of pages which are zero-filled
                       on demand.
           %i          The number of times a process' resident
                       set size was increased by the kernel.
           %d          The number of times a process' resident
                       set size was decreased by the kernel.
           %l          The number of read system calls performed.
           %m          The number of write system calls performed.
           %p          the number of reads from raw disk devices.
           %q          the number of writes to raw disk devices.

     The default time format for Sequent's DYNIX/ptx is "%Uu  %Ss
     $E  %P  %I+%Oio %Fpf+%Ww". Also note that the CPU percentage
     can be higher than 100% on multi-processors.


     On systems that support TCF (aix-ibm370, aix-ps2)  the  fol-
     lowing builtins have been added:

     getspath  Print the current system execution path.

     setspath LOCAL|<site>|<cpu> ...
               Set the current execution path.

     getxvers  Print the current experimental version prefix.

     setxvers [<string>]
               If the optional string is ommited, any  experimen-
               tal  version  prefix  is  removed.   Otherwise the
               experimental version prefix is set to string.

     migrate [-<site>] <pid>|%<jobid> ...
     migrate -<site>
               The first form migrates the process or job to  the
               site  specified  or the default site determined by
               the system path.  The second form,  is  equivalent
               to 'migrate -<site> $$', i.e. migrates the current
               process to the  site  specified.  Note:  migrating
               tcsh  itself  can cause unexpected behavior, since
               the shell does not like to lose its tty.

     In addition, jobs will print the site the job is executing.

     Domain/OS Support

     inlib <shared-library> ...
          Inlib adds shared libraries to the current environment.
          There is no way to remove them...

     rootnode //<nodename>
          Change the name of the current rootnode. From now on, /
          will resolve to //<rootnode>

     ver [<systype>] [<command>]
          Without arguments, print $SYSTYPE; with  the  <systype>
          provided,  set  SYSTYPE to the one provided. Valid sys-
          types are bsd4.3 and sys5.3. If a <command> is argument
          is  given,  then  <command> is executed under the <sys-
          type> specified.


     setpath <path-spec> ...
          XXX: What does it do?


     universe <universe-spec> ...
          Sets the current universe to the specified parameter.


     warp [<universe-spec>] ...
          Without arguments  prints  the  current  value  of  the
          universe.  With a universe argument it sets the current
          universe to the value of the argument.

     On systems that support SIGWINCH or SIGWINDOW,  tcsh  adapts
     to window resizing automatically and adjusts the environment
     variables LINES and COLUMNS if set. Also if the  environment
     variable TERMCAP contains li#, and co# fields, these will be
     adjusted also to reflect the new window size.

     On startup tcsh will try to source /etc/csh.cshrc  and  then
     /etc/csh.login  if  the shell is a login shell. Then it will
     try  to  source  $HOME/.tcshrc  and  then  $HOME/.cshrc   if
     $HOME/.tcshrc is not found. Then it will source $HOME/.login
     if the shell is a login shell.  On  exit  tcsh  will  source
     first  /etc/csh.logout  and  then $HOME/.logout if the shell
     was a login shell.

     Note: On convexos  and  stellix  the  names  of  the  system
     default  files  are  /etc/cshrc , /etc/login and /etc/logout
     respectively. On the NeXT  the  names  are  also  different:
     /etc/cshrc.std  , /etc/login.std and /etc/logout.std Finally
     on irix, A/UX and the cray only the file /etc/cshrc is  exe-
     cuted if the shell is a login shell.

     This section describes options that are either  undocumented
     in csh (*) or present only in tcsh. (+)

     -d  Load ~/.cshdirs  (If  tcsh  was  compiled  with  CSHDIRS

         Set environment variable name to value. (Domain/OS only)

     -F  Use  fork()  instead  of  vfork()  to  spawn  processes.
         (Convex/OS only) (+)

     -l  Make tcsh behave like a login shell.  (+)

     -m  Allow reading of a .cshrc that does not  belong  to  the
         effective user. Newer versions of su(1) can pass that to
         the shell. (some versions of csh have it) (+*)

     -q  Make the shell accept SIGQUIT, and  behave  when  it  is
         used under a debugger.  Job control is disabled. (*)

     Tcsh accepts more than one variable modifier per variable or
     history expansion. For example, in csh(1) the following com-
     mand expands to:

           % set a=/usr/local/
           % echo $a:t:r:e

     but in tcsh:
           > set a=/usr/local/
           > echo $a:t:r:e

     This bug fix changes slightly the input syntax of csh, caus-
     ing expressions of the form to have invalid syntax:

           > set a=/usr/local/
           > echo $a:t:$cwd
           Unknown variable modifier.

     Which is the correct behavior, since after the second  colon
     a  variable  modifier is expected and `$' is found.  Expres-
     sions like this should be re-written as:

           > echo ${a:t}:$cwd

     Also tcsh has an additional : character a which applies  the
     current  modifier  multiple  times  in the same word, in the
     same way g applies the modifier once in each word:

           > set foo=(a:b:c d:e:f)
           > echo $foo:s/:/ /
           a b:c d:e:f
           > echo $foo:gs/:/ /
           a b:c d e:f
           > echo $foo:as/:/ /
           a b c d:e:f
           > echo $foo:ags/:/ /
           a b c d e f

     The csh expert will notice in the above example another tcsh
     enhancement.  In  csh the s modifier does not work for vari-

     The a character works correctly with  other  modifiers,  for

           > echo $host
           > echo $host:r
           > echo $host:ar

     Note: The a character causes a modifier to be applied  to  a
     word  repeatedly  until the modifier fails. This can lead to
     an infinite loop in the  current  implementation  when  used
     with  the  s modifier. For example :as/f/ff/ will never ter-
     minate. This behavior might change in the future.

     This shell uses cbreak mode but takes typed-ahead characters
     anyway.   You can still use stty(1) to set some of the modes
     of your terminal (but not bindings).

     This shell will restore your  tty  to  a  sane  mode  if  it
     appears  to return from some command in raw, cbreak, or noe-
     cho mode. This behavior can be changed using setty.

     HPATH -- path to look for command documentation
     LANG -- used to give preferred  character  environment  (see
     LC_CTYPE -- used to change  only  ctype  character  handling
     (see NLS)
     NOREBIND -- inhibits rebinding of  printable  characters  to
     PATH -- path to look for command execution
     SHLVL -- current shell level nesting
     TERM -- used to tell how to handle the terminal
     LINES -- Number of lines in terminal (see WINDOW SIZE)
     COLUMNS -- Number of columns in terminal (see WINDOW SIZE)
     TERMCAP -- Terminal capability string (see WINDOW SIZE)
     SYSTYPE -- The current system type (Domain OS only)

     addsuffix add a / for directories, and a  space  for  normal
               files  when  complete  matches a name exactly.  If
               unset don't add anything extra.

     ampm      show all times in 12 hour, AM/PM format.

               Correct mis-spelled path components  automatically
               before attempting completion.

               invoke the expand-history  function  automatically
               on completion.

     autolist  list possibilities on an ambiguous completion.

               The first word  indicates  number  of  minutes  of
               inactivity  before automatic logout.  The optional
               second word indicates the  number  of  minutes  of
               inactivity  after  which the user will be prompted
               for his login password to enter a command.

               makes the backslash quote \, ', and ". This option
               changes the parsing mechanism for tcsh, and it can
               cause syntax errors in csh scripts.

               always resolve symbolic links to real names on cd,

     correct   automatically try to correct the spelling of  com-
               mands.   Must  be  set to either correct=cmd, only
               command name will be  corrected,  or  correct=all,
               the whole line will be corrected.

     dextract  extract a directory on pushd rather than rotating.

     edit      use the input editor, set by default.

     fignore   list of file name suffixes (e.g. .o, ~) to  ignore
               during complete.

     gid       the current real group id.

     histlit   If set, history lines in the editor will be  shown
               with its literal value (that is the line as it was
               input) instead of the shells lexical version.  The
               current   history  line  can  be  toggled  between
               literal  and  lexical  with  the   toggle-literal-
               history  function.   History  lines saved at shell
               exit are also saved as this variable indicates.

     histfile  If set, it contains the  full  path-name  where  a
               history  file  is  read/written.   It  defaults to
               $home/.history. This is useful  when  sharing  the
               same  home  directory in different machines, or if
               one wants to save all the  histories  in  the  tty
               sessions. It is usually set in .cshrc for interac-
               tive shells, because history  is  sourced  between
               .cshrc  and  .login  so  that it is available from

               don't resolve symbolic links to real names on  cd,

     listjobs  list all jobs when suspending. set  listjobs=long,
               produces long format.

     listlinks Resolve symbolic links when listing files so  that
               the correct filetype is shown.

     listmax   maximum number of items  to  list  without  asking

     matchbeep control    beeping    on     completion.      With
               matchbeep=nomatch,   completion  only  beeps  when
               there is no match, with matchbeep=ambiguous, beeps
               also   when   there  are  multiple  matches,  with
               matchbeep=notunique, beeps when there is one exact
               and other longer matches, with matchbeep=never, it
               never beeps.

     nobeep    Disables beeping completely.

     oid       The organization id number (Domain OS only).

               if an interactive program  exits  non-zero,  print
               the exit value.

     prompt    the string to prompt with.

     prompt2   the string to prompt for while and for loops with.

     prompt3   the string to prompt with when automatic  spelling
               correction has corrected a command line.

               make pushd with no args do a "pushd  ~"  (like  cd

               do not print the dir  stack  on  every  pushd  and

     recexact  recognize exact matches even if they  are  ambigu-

               list choices of commands only  displays  files  in
               the path that are executable (slow).

     rmstar    Prompt the user before execution of `rm *'.

     savehist  number of history items to save between login ses-

     shlvl     Integer value  indicating  the  number  of  nested

     showdots  show hidden files in list and complete operations.

     tcsh      Contains the  current  version  of  the  shell  as
               R.VV.PP. The R indicates the major release number,
               the  VV  the  current  version  and  the  PP   the

     term      the terminal type; see above.

     tperiod   periodic command wait period (in minutes).

     tty       The name of the tty, or empty if not  attached  to

     uid       the current real user ID.

     version   the version ID stamp for this tcsh.  It  contains,
               the  origin of this version of tcsh, the date this
               version was released and  a  string  containing  a
               comma  separated  list of the compile time options
               8b 7b  If tcsh was compiled to be eight bit clean
                      or not.  The default is 8b.
               nls    Set if tcsh uses the system's NLS, should be
                      the default for systems that have NLS.
               lf     Set if tcsh should execute .login before
                      .cshrc on login shells. Default is not set.
               dl     Set if tcsh should put . last on the path
                      for security. Default is set.
               vi     Set if tcsh's default editor is vi. Default
                      is unset (emacs)
               dtr    Set if tcsh should drop dtr on login shells
                      when exiting.  Default is unset.
               bye    Set if tcsh should accept bye in addition
                      to logout, and rename log to watchlog.
                      Default is unset.
               al     Set if tcsh should determine if autologout
                      should be enabled. The default is set.
               dir    Set if tcsh should save and restore the directory
               kan    Set if tcsh is compiled for Kanji.
                      (ignore the iso character set.) Default is unset.
               sm     Set if tcsh was compiled to use the system's malloc.

     In addition to the above strings, administrators  can  enter
     local strings to indicate differences in the local version.

               use the visible bell (screen  flash)  rather  than
               audible bell.

     watch     list of events to watch.

     who       format string for  the  printouts  generated  when
               watch is set.

     wordchars list  of  non-alphanumeric  characters  considered
               part  of  a  word  for the purpose of the forward-
               word, backward-word etc functions --  defaults  to

     cwdcmd    the command is run after every change  of  working

     periodic  the command to be run every tperiod minutes.

     precmd    the command to  be  run  prior  to  printing  each

     beepcmd   the command to be run every  time  tcsh  wants  to
               echo the terminal bell.

     xterm(1), twm(1), csh(1), chsh(1), termcap(5), termio(7)

     The screen update for lines longer than the screen width  is
     very  poor  if  the terminal cannot move the cursor up (i.e.
     terminal type "dumb").

     I am certain that there are  bugs.   Bugs  (preferably  with
     fixes)     should     be    sent    to    Christos    Zoulas

     This man page documents tcsh 6.01.00 (Cornell) 12/19/91.

     Ken Greer, HP Labs, 1981
     Wrote the command completion.

     Mike Ellis, Fairchild, 1983
     Added command name recognition/completion.

     Paul Placeway, Ohio State CIS dept., 1983
     Added the command line editor.

     Rayan Zachariassen, University of Toronto, 1984
     Added the builtin which feature to the editor, and the  code
     for  ls-F . Also numerous bug fixes, modifications, and per-
     formance enhancements.

     Chris Kingsley, Caltech
     Wrote the fast storage allocator routines (nmalloc.c).

     Karl Kleinpaste, CCI 1983-4
     Added special aliases,  directory  stack  extraction  stuff,
     login/logout watch, and scheduled events.  Also came up with
     the idea of the new prompt format.
     Paul Placeway, Ohio State CIS dept., 1987
     Re-wrote the editor, cleaned up other code,  and  added  the
     prompt  routines,  added to the syntax for file name expres-
     sions, and sped up the shell some.

     Chris Grevstad, TRW, 1987
     Ported the 4.3 csh sources to tcsh.

     Christos S. Zoulas, Cornell U. EE dept., 1987-91
     ported tcsh to HPUX, and System V rel. 2 and 3 and  wrote  a
     SysV  version  of  getwd.c. Added SHORT_STRINGS support. New
     version of sh.glob.c.

     James J Dempsey, BBN, 1988, and Paul Placeway, OSU, 1988
     Re-ported tcsh to A/UX.

     Scott Krotz, Motorola, 1991
     Minix port.

     David Dawes, Sydney U. Australia, Physics dept., 1991
     SVR4 job control fixes. (reverse pipeline startup code,  and
     signal fixes).

     Jose Sousa, Interactive Systems Corp., 1991
     Extended vi fixes. Added delete command in vi.

     Marc Horowitz, MIT, 1991
     Ansification fixes, new  exec  hashing  code,  imake  fixes,
     where builtin.

     Eric Schnoebelen, Convex, 1990
     Convex support, lots of csh bug fixes, save and  restore  of
     directory stack.

     Jaap Vermeulen, Sequent, 1990-91
     Vi mode fixes, expand-line, window change fixes,  ported  to
     symmetry machines.

     Ron Flax, Apple, 1990
     Ported again to A/UX 2.0

     Dan Oscarsson, LTH Sweden, 1990
     NLS support and simulated for non NLS sites.  Correction  of
     file  names  also handles the case when the / is replaced by
     another character.  The editor does not switch  into  cbreak
     mode unless needed.  The shell will not use character attri-
     butes when output is not to a tty.

     Johan Widen, SICS Sweden, 1990
     Shell level  variable,  mach  support,  correct-line,  8-bit

     Matt Day, Sanyo Icon, 1990
     Added POSIX termio support; Fixed limit stuff for SysV.

     Hans J. Albertsson (Sun Sweden)
     Added the ampm variable handling, DING!, and the  settc  and
     telltc builtins.

     Michael Bloom
     Fixed some of the interrupt handling.

     Michael Fine, Digital Equipment Corp
     added the extended key support.

     Daniel Long, NNSC, 1988
     Added the wordchars variable.

     George  Hartzell,  MCD  Biology,  University  of   Colorado-
     Boulder, 1988
     Fixed the always resetting to DEL bug.

     Patrick Wolfe, Kuck and Associates, Inc., 1988
     Cleaned up VI mode and wrote the new editor description  (in
     section 1).

     Jak Kirman, 1988
     Fixed the SunOS 4 giant stack allocation bug.

     Bruce Robertson, Tektronix, 1989
     Fixed setting erase and kill (again).

     David C Lawrence, Rensselaer Polytechnic Institute, 1989
     Added "autolist" variable and code to list possibilities  on
     ambiguous completion.

     Martin Boyer, Institut de recherche d'Hydro-Quebec, 1991.
     Modified "autolist" variable and code  to  give  options  on
     beeping behavior.  Modified the history search to search for
     the whole string from the beginning of the line to the  cur-

     Alec Wolman, DEC, 1989
     Added code to allow newlines in the prompt.

     Matt Landau, BBN, 1989
     Fixed YP bugs on Suns, added .tcshrc stuff.

     Ray Moody, Purdue Physics, 1989
     Added the code to do magic spacebar history expansion.

     Mordechai ????, Intel, 1989
     Re-arranged the printprompt() routine to use  a  switch(*cp)
     (rather than a bunch of ifs), and added a few things to it.

     Josh Siegel,, 1989
     Fixed "fg-editor" and added the status line shell  variables
     "sl" and "el".

     Karl Berry, UMB, 1989
     Fixed a bug involving environ (in sh.func.c) on NeXT comput-

     Michael Greim, Universitaet  des  Saarlandes,  Saarbruecken,
     Fixed the nested backquote bug (yes, you can  do  it;  think
     about   aliases)  in  4.2  csh.   This  fix  was  posted  to

     Kazuhiro Honda, Department of Computer Science, Keio Univer-
     sity, 1989
     Added  the  code  for  automatic  spelling  correction,  the
     prompt3 stuff (the autocorrect prompt), and HOSTTYPE symbols
     for the Sony NEWS.

     Paul Placeway, BBN, 1990
     Fixed character redrawing code insert bugs, and made redraw-
     ing  code  handle  multiple  character movement, insert, and
     delete (if it exists).  Fixed setting of SHELL.

     Per Hedeland, Ellemtel, Sweden, 1990
     Various bugfixes and improvements, e.g.  in  history  expan-
     sion, autolist, added autoexpand, updated the manual.

     A special thanks to:  Bryan  Dunlap,  Clayton  Elwell,  Karl
     Kleinpaste,  Bob  Manson,  Steve  Romig, Diana Smetters, Bob
     Sutterfield, Mark Verber,  Elizabeth  Zwicky,  and  all  the
     other  people  at  Ohio State for suggestions and encourage-

     Also, thanks to all the people on the  net  for  putting  up
     with, reporting bugs in, and suggesting new additions to the
     old tcsh editor.