*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->IRIX man pages -> tcsh (1)              


TCSH(1)								       TCSH(1)

NAME    [Toc]    [Back]

     tcsh - shell with file name completion and	command	line editing

SYNOPSIS    [Toc]    [Back]

     tcsh [ -bcdefimnqstvVxX ] [ argument ... ]

     tcsh -l

     OS/Dependent Options
     tcsh [ -F ] [ -Dname[=value] ]

DESCRIPTION    [Toc]    [Back]

     Tcsh is an	enhanced version of the	Berkeley UNIX C	shell csh(1).  It
     behaves similarly to 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	completion.

       5)  File/directory/user list in the middle of a typed command.

       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 time.

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

       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 directories.

       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

									Page 1

TCSH(1)								       TCSH(1)

	   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 character not in a
	   set of characters and the ability to	negate a globbing pattern.

       19) New automatically initialized environment variables HOST and

       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

       33) Programmable	completion.

       34) Enhanced file inquiry operator.

       35) Readonly variables.

       36) Implicit cd for directory names entered as commands.

     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.

									Page 2

TCSH(1)								       TCSH(1)

     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 ] [ -k ] [	-l ] [
     -r	] [ -- ] [ [ in-string | key-name ] [ 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

	 -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
	 -k    interpret in-string as a	symbolic arrow key name
	 -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 "^?"	(caretquestion

     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 character bindings.

									Page 3

TCSH(1)								       TCSH(1)

     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 bindings.  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 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

									Page 4

TCSH(1)								       TCSH(1)

	   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

									Page 5

TCSH(1)								       TCSH(1)

	   "^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

									Page 6

TCSH(1)								       TCSH(1)

	   "^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

									Page 7

TCSH(1)								       TCSH(1)

	   "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 depending 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 overwrite.

     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 compatibility reasons.

     If	given two arguments bind binds the function (first argument) 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 function
     "sequence-lead-in"	and the	string specified to the	bind command must not
     include this prefix.

									Page 8

TCSH(1)								       TCSH(1)

     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 history 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

     Another way to recall (parts of) history commands is via the 'expandhistory'
 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 magicspace
 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).

									Page 9

TCSH(1)								       TCSH(1)

     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 depending 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 "execute" 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 unchanged:

	   > 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 complete 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 variables and	the ~ user name	convention.  The variable
     fignore may be set	to a list of suffixes to be disregarded	during


								       Page 10

TCSH(1)								       TCSH(1)

     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 terminal 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	directories are
     addressed.	 Additionally, tcsh understands	the C shell tilde (~)
     convention	for home directories.  In addition 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

								       Page 11

TCSH(1)								       TCSH(1)

     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 sub-directories called foo	and food, then with recexact set the
     following could be	done:

	   > 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 matchbeep 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

								       Page 12

TCSH(1)								       TCSH(1)

     If	the autoexpand variable	is set,	the expand-history function 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	sub-directories	exist (in
     ~speech/data/fritz), without, of course, aborting the command 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 command is re-echoed for you
     to	complete.

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

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

     all files and sub-directories 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 the files in the current
     working directory.

     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

								       Page 13

TCSH(1)								       TCSH(1)

	   > 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

	   > 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 cursor is in the
     middle of a line (or on an	empty line), a Meta-Control-D should be	typed
     (Escape followed by Control-D).

     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 cursor.  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.

								       Page 14

TCSH(1)								       TCSH(1)

     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 experimental feature. Suggestions and improvements are

     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.help, 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 "~/.history" 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 history. 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

								       Page 15

TCSH(1)								       TCSH(1)

	   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 useful 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

     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 window 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-logout.

     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

								       Page 16

TCSH(1)								       TCSH(1)

     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 convenient	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 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.)
	   %p	       Current time in 12-hour format, am/pm format with seconds.
	   %P	       Current time in 24-hour format, with seconds.
	   \c	       `c' is parsed the same way as in	bindkey.

								       Page 17

TCSH(1)								       TCSH(1)

	   ^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.

     On	%C, %c and %., if the optional digit is	0, then	the next digit is
     interpreted as the	number of directory components to be skipped, and the
     number of components skipped are reported as: /<num-skipped>path/path.

     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 normal 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 spelling 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

								       Page 18

TCSH(1)								       TCSH(1)

     stamp.  The time stamp printouts can be omitted from the history list by
     adding the	-t switch to the history command.  Tcsh	provides a way to
     save, restore and clear the history list in a file.

     history -S	[<filename>]
     history -L	[<filename>]
     history -c

     The 'S' flag saves	the current history, the 'L' flags loads the history,
     and the 'c' flag clears the history.  If a	filename is not	specified,
     then $HOME/.history is used.

     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

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

     Tcsh always saves the last	directory visited. Changing to the previous
     directory can be done by using 'cd	-' or 'pushd -'.

     Tcsh will now allow the user to access all	elements in the	directory
     stack directly.  The syntax "=<digit>" is recognized 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.

								       Page 19

TCSH(1)								       TCSH(1)

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

     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 ~

     Tcsh provides a way to save, restore and clear the	directory stack	in a

     dirs -S [<filename>]
     dirs -L [<filename>]
     dirs -c

     The 'S' flag saves	the current directory stack, the 'L' flags loads the
     directory stack, and the 'c' flag clears the directory stack.  If a
     filename is not specified,	then $HOME/.cshdirs is used.

     In	addition, if the shell variable	dunique	is set,	only directories that
     are not already in	the directory stack will be added when push is

     The way symbolic links that point to directories are crossed is
     determined	by the symlinks	variable. By default, it is not	set to
     anything and symbolic links are not treated specially. However, it	can be
     set to either:  chase, ignore, or expand. If symlinks is set to chase,
     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 symlinks is set to
     either ignore or expand, then tcsh	tries to determine the current
     directory name relative to	the name of the	current	directory before the
     link was crossed. In simple terms,	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.
     While ignore affects only builtin commands	and completion,	expand affects
     command execution too, by `fixing'	arguments that it considers to be path
     names. Unfortunately this does not	work in	every case, specially when
     file arguments are	embedded in command line options. Expand also allows
     to	specify	the `real' (as opposed to the one determined relatively	to
     $cwd), by quoting the file	argument.

								       Page 20

TCSH(1)								       TCSH(1)

     For example:

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

	   > unset symlinks
	   > cd	/tmp/to/dst; echo $cwd
	   > cd	..; echo $cwd

	   > set symlinks=chase
	   > cd	/tmp/to/dst; echo $cwd
	   > cd	..; echo $cwd

	   > set symlinks=ignore
	   > cd	/tmp/to/dst; echo $cwd
	   > cd	..; echo $cwd

	   > set symlinks=expand
	   > cd	/tmp/to/dst; echo $cwd
	   > cd	..; echo $cwd	    # builtin
	   > cd	/tmp/to/dst; echo $cwd
	   > cd	".."; echo $cwd		 # quoted
	   > /bin/echo ..	    # rewrites non builtin commands.
	   > /bin/echo ".."

     While the expand setting is the most convenient, and makes	symbolic links
     invisible,	it can sometimes be misleading and confusing in	cases where it
     fails to recognize	arguments. A compromise	is to use the ignore setting
     and use the editor	functions "normalize-path", bound by default to	^Xn.

     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

								       Page 21

TCSH(1)								       TCSH(1)

     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*' logging 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

     By	default, the interval between checks of	users on the system 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 minutes.

     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 announcement 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. In addition to the standard prompt % escapes,	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.
	   %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.

     The %M and	%m sequences are only available	on systems that	store the
     remote hostname in	/var/adm/utmp. If who is not set, the format defaults

								       Page 22

TCSH(1)								       TCSH(1)

     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

	   > 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 giving 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

	   > 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

								       Page 23

TCSH(1)								       TCSH(1)

     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 -F".  If the shell	variable showdots has been set,	it
     acts like "ls -aF". If showdots is	equal to "-A", then ls-F acts like "ls
     -AF". Ls-F	works like ls, only it is generally faster, since it does not
     need to fork and exec, and	safer against Trojan horses if the user	has
     `.' in the	execution path.	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 listing 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 type:

	   =	       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 listlinks 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

								       Page 24

TCSH(1)								       TCSH(1)

		      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 added:

	   > 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 {}.

     Currently,	\< and \> are not supported.

     On	startup, tcsh now automatically	initializes the	environment 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.

								       Page 25

TCSH(1)								       TCSH(1)

     The current possible values are:

     386BSD	    an Intel 386, running 386BSD
     aix370	    an IBM 370,	running	aix
     aixESA	    an IBM ESA,	running	aix
     alliant	    an Alliant FX series
     alliant-fx80   an Alliant FX80 (mc68000 based)
     alliant-fx2800 an Alliant FX2800 (i860 based)
     alpha	    an DEC Alpha running OSF/1
     amdahl	    an Amdahl running uts 2.1
     amiga	    an amiga running amix 2.02
     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)
     bsd386	    an Intel 386, running BSDI's bsd386
     butterfly	    a BBN Computer Butterfly 1000
     coh386	    a 386 running Coherent 4.0
     coherent	    an unknown machine running Coherent
     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 runn

 Similar pages
Name OS Title
tcsh Linux C shell with file name completion and command line editing
tcsh FreeBSD C shell with file name completion and command line editing
csh FreeBSD C shell with file name completion and command line editing
VkForkIO IRIX Command-line interface to shell command component
edit Tru64 Edits a file line by line with a simplified command set
readline OpenBSD get a line from a user with editing
readline FreeBSD get a line from a user with editing
glfinishasyncsgix IRIX wait for completion of an asynchronous command
glpollasyncsgix IRIX poll for completion of an asynchronous command
sh Tru64 Shell, the standard command language interpreter (POSIX Shell)
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service