'\" t

.\" Copyright (c) 1980, 1990, 1993

.\"	The Regents of the University of California.  All rights reserved.

.\"

.\" Redistribution and use in source and binary forms, with or without

.\" modification, are permitted provided that the following conditions

.\" are met:

.\" 1. Redistributions of source code must retain the above copyright

.\"    notice, this list of conditions and the following disclaimer.

.\" 2. Redistributions in binary form must reproduce the above copyright

.\"    notice, this list of conditions and the following disclaimer in the

.\"    documentation and/or other materials provided with the distribution.

.\" 3. Neither the name of the University nor the names of its contributors

.\"    may be used to endorse or promote products derived from this software

.\"    without specific prior written permission.

.\"

.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

.\" SUCH DAMAGE.

.\" 

.\" Style notes for the tcsh man page:

.\" 

.\" - Tags in lists are bold, except in the FILES section where they are

.\"   italic.

.\" 

.\" - References are bold for section headings and environment and shell

.\"   variables and italic for commands (externals, builtins, aliases, and

.\"   editor commands) and arguments to commands.

.\" 

.\" - Be careful with the .B and .I macros: they handle only a limited number

.\"   of words. Work around this with \fB and \fI, but only if absolutely

.\"   necessary, because tcsh.man2html uses .B/.I to find name anchors.

.\" 

.\" - Indent in multiples of 4, usually 8.

.\" 

.\" - Use `', not '' or "", except of course in shell syntax examples.

.\"   '' at the beginning of a line will vanish!

.\" 

.\" - Use \-, not -.

.\" 

.\" - Include the tilde when naming dot files. `~/.login', not `.login'.

.\" 

.\" - Refer to external commands in man page format, e.g., `csh(1)'. However,

.\"   tcsh is `tcsh', not `tcsh(1)', because this is the tcsh man page (and

.\"   see the next note anyway).

.\" 

.\" - Say `the shell', not `tcsh', unless distinguishing between tcsh and csh.

.\" 

.\" - Say `shell variable'/`environment variable' instead of `variable'

.\"   and `builtin command'/`editor command' instead of `builtin' or `command'

.\"   unless the distinction is absolutely clear from context.

.\" 

.\" - Use the simple present tense. `The shell uses', not `The shell will use'.

.\" 

.\" - IMPORTANT: Cross-reference as much as possible. Commands, variables,

.\"   etc. in the reference section should be mentioned in the appropriate

.\"   descriptive section, or at least in the reference-section description

.\"   of another command (or whatever) which is mentioned in a description

.\"   section. Remember to note OS-specific things in "OS variant support",

.\"   new features in NEW FEATURES and referenced external commands in SEE

.\"   ALSO.

.\" 

.\" - tcsh.man2html depends heavily on the specific nroff commands used in the

.\"   man page when the script was written. Please stick closely to the style

.\"   used here if you can. In particular, please don't use nroff commands

.\"   which aren't already used herein.

.\" 

.\" modified to reference existing Solaris man pages, to add the Solaris

.\" stability classification, and to add a note about source availability.

.\"

.TH TCSH 1 "10 July 2009" "Astron 6.17.00"

.SH NAME

tcsh \- C shell with file name completion and command line editing

.SH SYNOPSIS

.B tcsh \fR[\fB\-bcdefFimnqstvVxX\fR] [\fB\-Dname\fR[\fB=value\fR]] [arg ...]

.br

.B tcsh \-l

.SH DESCRIPTION

\fItcsh\fR is an enhanced but completely compatible version of the Berkeley

UNIX C shell, \fIcsh\fR(1).

It is a command language interpreter usable both as an interactive login

shell and a shell script command processor.

It includes a command-line editor (see \fBThe command-line editor\fR),

programmable word completion (see \fBCompletion and listing\fR),

spelling correction (see \fBSpelling correction\fR),

a history mechanism (see \fBHistory substitution\fR),

job control (see \fBJobs\fR)

and a C-like syntax.

The \fBNEW FEATURES\fR section describes major enhancements of \fItcsh\fR

over \fIcsh\fR(1).

Throughout this manual, features of

\fItcsh\fR not found in most \fIcsh\fR(1) implementations

(specifically, the 4.4BSD \fIcsh\fR)

are labeled with `(+)', and features which are present in \fIcsh\fR(1)

but not usually documented are labeled with `(u)'.

.SS "Argument list processing"

If the first argument (argument 0) to the shell is `\-' then it is a

login shell.  A login shell can be also specified by invoking the shell with

the \fB\-l\fR flag as the only argument.

.PP

The rest of the flag arguments are interpreted as follows:

.TP 4

.B \-b

Forces a ``break'' from option processing, causing any

further shell arguments to be treated as non-option arguments.  The remaining

arguments will not be interpreted as shell options.  This may be used to pass

options to a shell script without confusion or possible subterfuge.  The shell

will not run a set-user ID script without this option.

.TP 4

.B \-c

Commands are read from the following argument (which must be present, and

must be a single argument),

stored in the \fBcommand\fR shell variable for reference, and executed.

Any remaining arguments are placed in the \fBargv\fR shell variable.

.TP 4

.B \-d

The shell loads the directory stack from \fI~/.cshdirs\fR as described under

\fBStartup and shutdown\fR, whether or not it is a login shell. (+)

.TP 4

.B \-D\fIname\fR[=\fIvalue\fR]

Sets the environment variable \fIname\fR to \fIvalue\fR. (Domain/OS only) (+)

.TP 4

.B \-e

The shell exits if any invoked command terminates abnormally or

yields a non-zero exit status.

.TP 4

.B \-f

The shell does not load any resource or startup files, or perform any 

command hashing, and thus starts faster.

.TP 4

.B \-F

The shell uses \fIfork\fR(2) instead of \fIvfork\fR(2) to spawn processes. (+)

.TP 4

.B \-i

The shell is interactive and prompts for its top-level input, even if

it appears to not be a terminal.  Shells are interactive without this option if

their inputs and outputs are terminals.

.TP 4

.B \-l

The shell is a login shell.  Applicable only if \fB\-l\fR is the only

flag specified.

.TP 4

.B \-m

The shell loads \fI~/.tcshrc\fR even if it does not belong to the effective

user.  Newer versions of \fIsu\fR(1M) can pass \fB\-m\fR to the shell. (+)

.TP 4

.B \-n

The shell parses commands but does not execute them.

This aids in debugging shell scripts.

.TP 4

.B \-q

The shell accepts SIGQUIT (see \fBSignal handling\fR) and behaves when

it is used under a debugger.  Job control is disabled. (u)

.TP 4

.B \-s

Command input is taken from the standard input.

.TP 4

.B \-t

The shell reads and executes a single line of input.  A `\\' may be used to

escape the newline at the end of this line and continue onto another line.

.TP 4

.B \-v

Sets the \fBverbose\fR shell variable, so that

command input is echoed after history substitution.

.TP 4

.B \-x

Sets the \fBecho\fR shell variable, so that commands are echoed

immediately before execution.

.TP 4

.B \-V

Sets the \fBverbose\fR shell variable even before executing \fI~/.tcshrc\fR.

.TP 4

.B \-X

Is to \fB\-x\fR as \fB\-V\fR is to \fB\-v\fR.

.TP 4

.B \-\-help

Print a help message on the standard output and exit. (+)

.TP 4

.B \-\-version

Print the version/platform/compilation options on the standard output and exit.

This information is also contained in the \fBversion\fR shell variable. (+)

.PP

After processing of flag arguments, if arguments remain but none of the

\fB\-c\fR, \fB\-i\fR, \fB\-s\fR, or \fB\-t\fR options were given, the first

argument is taken as the name of a file of commands, or ``script'', to

be executed.  The shell opens this file and saves its name for possible

resubstitution by `$0'.  Because many systems use either the standard

version 6 or version 7 shells whose shell scripts are not compatible

with this shell, the shell uses such a `standard' shell to execute a script

whose first character is not a `#', i.e., that does not start with a

comment.

.PP

Remaining arguments are placed in the \fBargv\fR shell variable.

.SS "Startup and shutdown"

A login shell begins by executing commands from the system files

\fI/etc/.cshrc\fR and \fI/etc/.login\fR.

It then executes commands from files in the user's \fBhome\fR directory:

first \fI~/.tcshrc\fR (+)

or, if \fI~/.tcshrc\fR is not found, \fI~/.cshrc\fR,

then \fI~/.history\fR (or the value of the \fBhistfile\fR shell variable),

then \fI~/.login\fR,

and finally \fI~/.cshdirs\fR (or the value of the \fBdirsfile\fR shell variable) (+).

The shell may read \fI/etc/csh.login\fR before instead of after

\fI/etc/.cshrc\fR, and \fI~/.login\fR before instead of after

\fI~/.tcshrc\fR or \fI~/.cshrc\fR and \fI~/.history\fR, if so compiled;

see the \fBversion\fR shell variable. (+)

.PP

Non-login shells read only \fI/etc/.cshrc\fR and \fI~/.tcshrc\fR

or \fI~/.cshrc\fR on startup.

.PP

For examples of startup files, please consult

\fIhttp://tcshrc.sourceforge.net\fR.

.PP

Commands like \fIstty\fR(1) and \fItset\fR(1B),

which need be run only once per login, usually go in one's \fI~/.login\fR file.

Users who need to use the same set of files with both \fIcsh\fR(1) and

\fItcsh\fR can have only a \fI~/.cshrc\fR which checks for the existence of the

\fBtcsh\fR shell variable (q.v.) before using \fItcsh\fR-specific commands,

or can have both a \fI~/.cshrc\fR and a \fI~/.tcshrc\fR which \fIsource\fRs

(see the builtin command) \fI~/.cshrc\fR.

The rest of this manual uses `\fI~/.tcshrc\fR' to mean `\fI~/.tcshrc\fR or,

if \fI~/.tcshrc\fR is not found, \fI~/.cshrc\fR'.

.PP

In the normal case, the shell begins reading commands from the terminal,

prompting with `> '.  (Processing of arguments and the use of the shell to

process files containing command scripts are described later.)

The shell repeatedly reads a line of command input, breaks it into words,

places it on the command history list, parses it and executes each command

in the line.

.PP

One can log out by typing `^D' on an empty line, `logout' or `login' or

via the shell's autologout mechanism (see the \fBautologout\fR shell variable).

When a login shell terminates it sets the \fBlogout\fR shell variable to

`normal' or `automatic' as appropriate, then

executes commands from the files

\fI/etc/csh.logout\fR and \fI~/.logout\fR.  The shell may drop DTR on logout

if so compiled; see the \fBversion\fR shell variable.

.PP

The names of the system login and logout files vary from system to system for

compatibility with different \fIcsh\fR(1) variants; see \fBFILES\fR.

.SS Editing

We first describe \fBThe command-line editor\fR.

The \fBCompletion and listing\fR and \fBSpelling correction\fR sections

describe two sets of functionality that are implemented as editor commands

but which deserve their own treatment.

Finally, \fBEditor commands\fR lists and describes

the editor commands specific to the shell and their default bindings.

.SS "The command-line editor (+)"

Command-line input can be edited using key sequences much like those used in

GNU Emacs or \fIvi\fR(1).

The editor is active only when the \fBedit\fR shell variable is set, which

it is by default in interactive shells.

The \fIbindkey\fR builtin can display and change key bindings.

Emacs-style key bindings are used by default

(unless the shell was compiled otherwise; see the \fBversion\fR shell variable),

but \fIbindkey\fR can change the key bindings to \fIvi\fR-style bindings en masse.

.PP

The shell always binds the arrow keys (as defined in the \fBTERMCAP\fR

environment variable) to

.PP

.PD 0

.RS +4

.TP 8

down

\fIdown-history\fR

.TP 8

up

\fIup-history\fR

.TP 8

left

\fIbackward-char\fR

.TP 8

right

\fIforward-char\fR

.PD

.RE

.PP

unless doing so would alter another single-character binding.

One can set the arrow key escape sequences to the empty string with \fIsettc\fR

to prevent these bindings.

The ANSI/VT100 sequences for arrow keys are always bound.

.PP

Other key bindings are, for the most part, what Emacs and \fIvi\fR(1)

users would expect and can easily be displayed by \fIbindkey\fR, so there

is no need to list them here.  Likewise, \fIbindkey\fR can list the editor

commands with a short description of each.

.PP

Note that editor commands do not have the same notion of a ``word'' as does the

shell.  The editor delimits words with any non-alphanumeric characters not in

the shell variable \fBwordchars\fR, while the shell recognizes only whitespace

and some of the characters with special meanings to it, listed under

\fBLexical structure\fR.

.SS "Completion and listing (+)"

The shell is often able to complete words when given a unique abbreviation.

Type part of a word (for example `ls /usr/lost') and hit the tab key to

run the \fIcomplete-word\fR editor command.

The shell completes the filename `/usr/lost' to `/usr/lost+found/',

replacing the incomplete word with the complete word in the input buffer.

(Note the terminal `/'; completion adds a `/' to the

end of completed directories and a space to the end of other completed words,

to speed typing and provide a visual indicator of successful completion.

The \fBaddsuffix\fR shell variable can be unset to prevent this.)

If no match is found (perhaps `/usr/lost+found' doesn't exist),

the terminal bell rings.

If the word is already complete (perhaps there is a `/usr/lost' on your

system, or perhaps you were thinking too far ahead and typed the whole thing)

a `/' or space is added to the end if it isn't already there.

.PP

Completion works anywhere in the line, not at just the end; completed

text pushes the rest of the line to the right.  Completion in the middle of a word

often results in leftover characters to the right of the cursor that need

to be deleted.

.PP

Commands and variables can be completed in much the same way.

For example, typing `em[tab]' would complete `em' to

`emacs' if \fIemacs\fR were the only command on your system beginning with `em'.

Completion can find a command in any directory in \fBpath\fR or if

given a full pathname.

Typing `echo $ar[tab]' would complete `$ar' to `$argv'

if no other variable began with `ar'.

.PP

The shell parses the input buffer to determine whether the word you want to

complete should be completed as a filename, command or variable.

The first word in the buffer and the first word following

`;', `|', `|&', `&&' or `||' is considered to be a command.

A word beginning with `$' is considered to be a variable.

Anything else is a filename.  An empty line is `completed' as a filename.

.PP

You can list the possible completions of a word at any time by typing `^D'

to run the \fIdelete-char-or-list-or-eof\fR editor command.

The shell lists the possible completions using the \fIls\-F\fR builtin (q.v.)

and reprints the prompt and unfinished command line, for example:

.IP "" 4

> ls /usr/l[^D]

.br

lbin/       lib/        local/      lost+found/

.br

> ls /usr/l

.PP

If the \fBautolist\fR shell variable is set, the shell lists the remaining

choices (if any) whenever completion fails:

.IP "" 4

> set autolist

.br

> nm /usr/lib/libt[tab]

.br

libtermcap.a@ libtermlib.a@

.br

> nm /usr/lib/libterm

.PP

If \fBautolist\fR is set to `ambiguous', choices are listed only when

completion fails and adds no new characters to the word being completed.

.PP

A filename to be completed can contain variables, your own or others' home

directories abbreviated with `~' (see \fBFilename substitution\fR) and

directory stack entries abbreviated with `='

(see \fBDirectory stack substitution\fR).  For example,

.IP "" 4

> ls ~k[^D]

.br

kahn    kas     kellogg

.br

> ls ~ke[tab]

.br

> ls ~kellogg/

.PP

or

.IP "" 4

> set local = /usr/local

.br

> ls $lo[tab]

.br

> ls $local/[^D]

.br

bin/ etc/ lib/ man/ src/

.br

> ls $local/

.PP

Note that variables can also be expanded explicitly with the

\fIexpand-variables\fR editor command.

.PP

\fIdelete-char-or-list-or-eof\fR lists at only the end of the line;

in the middle of a line it deletes the character under the cursor and

on an empty line it logs one out or, if \fBignoreeof\fR is set, does nothing.

`M-^D', bound to the editor command \fIlist-choices\fR, lists completion

possibilities anywhere on a line, and \fIlist-choices\fR (or any one of the

related editor commands that do or don't delete, list and/or log out,

listed under \fIdelete-char-or-list-or-eof\fR) can be bound to `^D' with

the \fIbindkey\fR builtin command if so desired.

.PP

The \fIcomplete-word-fwd\fR and \fIcomplete-word-back\fR editor commands

(not bound to any keys by default) can be used to cycle up and down through

the list of possible completions, replacing the current word with the next or

previous word in the list.

.PP

The shell variable \fBfignore\fR can be set to a list of suffixes to be

ignored by completion.  Consider the following:

.IP "" 4

> ls

.br

Makefile        condiments.h~   main.o          side.c

.br

README          main.c          meal            side.o

.br

condiments.h    main.c~

.br

> set fignore = (.o \\~)

.br

> emacs ma[^D]

.br

main.c   main.c~  main.o

.br

> emacs ma[tab]

.br

> emacs main.c

.PP

`main.c~' and `main.o' are ignored by completion (but not listing),

because they end in suffixes in \fBfignore\fR.

Note that a `\\' was needed in front of `~' to prevent it from being

expanded to \fBhome\fR as described under \fBFilename substitution\fR.

\fBfignore\fR is ignored if only one completion is possible.

.PP

If the \fBcomplete\fR shell variable is set to `enhance', completion

1) ignores case and 2) considers periods, hyphens and underscores

(`.', `\-' and `_') to be word separators and hyphens and underscores to

be equivalent.  If you had the following files

.IP "" 4

comp.lang.c      comp.lang.perl   comp.std.c++

.br

comp.lang.c++    comp.std.c

.PP

and typed `mail \-f c.l.c[tab]', it would be completed to

`mail \-f comp.lang.c', and ^D would list `comp.lang.c' and `comp.lang.c++'.

`mail \-f c..c++[^D]' would list `comp.lang.c++' and `comp.std.c++'.  Typing

`rm a\-\-file[^D]' in the following directory

.IP "" 4

A_silly_file    a-hyphenated-file    another_silly_file

.PP

would list all three files, because case is ignored and hyphens and

underscores are equivalent.  Periods, however, are not equivalent to

hyphens or underscores.

.PP

Completion and listing are affected by several other shell variables:

\fBrecexact\fR can be set to complete on the shortest possible unique

match, even if more typing might result in a longer match:

.IP "" 4

> ls

.br

fodder   foo      food     foonly

.br

> set recexact

.br

> rm fo[tab]

.PP

just beeps, because `fo' could expand to `fod' or `foo', but if we type

another `o',

.IP "" 4

> rm foo[tab]

.br

> rm foo

.PP

the completion completes on `foo', even though `food' and `foonly'

also match.

\fBautoexpand\fR can be set to run the \fIexpand-history\fR editor command

before each completion attempt, \fBautocorrect\fR can be set to

spelling-correct the word to be completed (see \fBSpelling correction\fR)

before each completion attempt and \fBcorrect\fR can be set to complete

commands automatically after one hits `return'.

\fBmatchbeep\fR can be set to make completion beep or not beep in a variety

of situations, and \fBnobeep\fR can be set to never beep at all.

\fBnostat\fR can be set to a list of directories and/or patterns that

match directories to prevent the completion mechanism from \fIstat\fR(2)ing

those directories.

\fBlistmax\fR and \fBlistmaxrows\fR can be set to limit the number of items

and rows (respectively) that are listed without asking first.

\fBrecognize_only_executables\fR can be set to make the shell list only

executables when listing commands, but it is quite slow.

.PP

Finally, the \fIcomplete\fR builtin command can be used to tell the shell how

to complete words other than filenames, commands and variables.

Completion and listing do not work on glob-patterns (see \fBFilename substitution\fR),

but the \fIlist-glob\fR and \fIexpand-glob\fR editor commands perform

equivalent functions for glob-patterns.

.SS "Spelling correction (+)"

The shell can sometimes correct the spelling of filenames, commands and variable names

as well as completing and listing them.

.PP

Individual words can be spelling-corrected with the \fIspell-word\fR

editor command (usually bound to M-s and M-S)

and the entire input buffer with \fIspell-line\fR (usually bound to M-$).

The \fBcorrect\fR shell variable can be set to `cmd' to correct the

command name or `all' to correct the entire line each time return is typed,

and \fBautocorrect\fR can be set to correct the word to be completed

before each completion attempt.

.PP

When spelling correction is invoked in any of these ways and

the shell thinks that any part of the command line is misspelled,

it prompts with the corrected line:

.IP "" 4

> set correct = cmd

.br

> lz /usr/bin

.br

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

.PP

One can answer `y' or space to execute the corrected line,

`e' to leave the uncorrected command in the input buffer,

`a' to abort the command as if `^C' had been hit, and

anything else to execute the original line unchanged.

.PP

Spelling correction recognizes user-defined completions (see the

\fIcomplete\fR builtin command).  If an input word in a position for

which a completion is defined resembles a word in the completion list,

spelling correction registers a misspelling and suggests the latter

word as a correction.  However, if the input word does not match any of

the possible completions for that position, spelling correction does

not register a misspelling.

.PP

Like completion, spelling correction works anywhere in the line,

pushing the rest of the line to the right and possibly leaving

extra characters to the right of the cursor.