csh(1)csh(1)NAMEcsh - C shell command interpreter
SYNOPSIScsh [-bcefinstvVxX] [argument...]
The csh command invokes the C shell and interprets C shell commands.
OPTIONS
Forces a break from option processing, causing any further shell argu‐
ments to be treated as nonoption arguments. This can be used to pass
options to a shell script without confusion or possible subterfuge.
The shell cannot run a set-user-ID script without this option. Reads
commands from the following single argument, which must be present.
Any remaining arguments are placed in argv. Causes the shell to exit
if any invoked command terminates abnormally or yields a nonzero exit
status. Causes the shell to start faster, because it neither searches
for nor executes the file in the invoker's home directory. Causes the
shell to be interactive, even if the input does not come from a termi‐
nal. Shells are always interactive when invoked from a terminal.
Parses commands, but does not execute them. This aids in syntactic
checking of shell scripts. Takes command input from the standard
input. Reads and executes a single line of input. You can use a \
(backslash) to escape the newline character at the end of the current
line to continue onto another line. Sets the verbose shell variable,
with the effect that command input is echoed to the standard output
after history substitution. Sets the verbose shell variable, even
before is executed. Sets the echo shell variable, so that commands are
echoed to the standard error after all substitutions and immediately
before execution. Sets the echo shell variable, even before is exe‐
cuted.
After processing of option arguments, if arguments remain but none of
the -c, -i, -s, or -t options was given, the first argument is taken as
the name of a file of commands to be executed (that is, a shell
script). The shell opens this file, and saves its name for possible
resubstitution by $0. If the first characters of the shell script are
#!shell_pathname or #csh, csh runs the specified shell to process the
script. Otherwise, csh runs. Remaining parameters initialize the argv
variable.
DESCRIPTION
The C shell is an interactive command interpreter and a command pro‐
gramming language that uses a syntax similar to the C programming lan‐
guage. The shell carries out commands either from a file (called a
shell script or procedure) or interactively from a terminal keyboard.
When you run csh, it begins by executing commands from the file in your
home directory, if it exists. If the shell is invoked with a name that
starts with -, as when started by login, the shell runs as a login
shell. If csh runs as a login shell, it executes commands from the
system-wide login file /etc/csh.login, if that file exists, and then
commands from your $home/.cshrc file and your $home/.login file, in
that order. (If argument zero ($0) to the shell is a - (dash), then
the shell is a login shell.) Your system administrator can create
/etc/csh.login to provide a standardized environment for all users, but
you can include commands in $home/.cshrc or $home/.login to override
settings and assignments made by /etc/csh.login.
At log in, the $home shell variable and the $HOME environment variable
both refer to your home directory. If you subsequently change $home to
some other value, you will encounter problems because the shell will
not be able to find files it uses, such as and
In the normal case, the shell begins reading commands from the termi‐
nal, prompting with % (percent sign) or # (number sign) for the supe‐
ruser. Processing of arguments and the use of the shell to process
files containing command scripts is described later.
The shell then repeatedly performs the following actions: A line of
command input is read and broken into words. This sequence of words is
placed on the command history list and then parsed. Each command in
the current line is executed.
When a login shell terminates, it executes commands from the file in
your home directory.
Shell Features
Job control and status reporting File name completion History substitu‐
tion Command aliasing Variable substitution Command substitution File
name substitution Input/output redirection and control flow Built-in
commands
Lexical Structure
A simple command is a sequence of words separated by spaces or tabs.
The shell splits input lines into words at spaces and tabs with the
following exceptions: The characters &, |, ;, <, >, (, ), and # form
separate words. If doubled in &&, ||, <<, or >>, these pairs form sin‐
gle words. Preceding parser metacharacters with a \ (backslash) pre‐
vents the shell from interpreting them as special characters. A new‐
line preceded by a \ (backslash) is equivalent to a space. Strings
enclosed in " " (double quotes), ` ` (grave accents), or ' ' (single
quotes) form parts of a word; metacharacters in these strings, includ‐
ing spaces and tabs, do not form separate words. For more information,
see the section Quoting with Single and Double Quotes. Within pairs of
' or " characters, you can include the newline character by preceding
it with a \ (backslash). When the shell is not reading input from a
terminal, it treats any word that begins with a # (number sign) charac‐
ter as a comment and ignores that word and all characters following up
to the next newline character. The # character loses its special mean‐
ing when it is quoted (preceded) by a \ (backslash) or when the string
is enclosed in quotes using `, ', or ".
When the shell is reading input from a terminal without the c
option, the # character is not treated specially. However, when
reading input from a terminal with the c option, the shell
treats a # character as the start of a comment and ignores sub‐
sequent text up to the next newline unless the # is quoted with
a \ (backslash) or the string is enclosed in quotes using `, ',
or ".
Shell Commands
A simple command is a sequence of words, the first of which (numbered
0) specifies the command to be executed. Any remaining words, with a
few exceptions, are passed to that command. If the command specifies
an executable file that is a compiled program, the shell immediately
runs that program. If the file is marked executable but is not a com‐
piled program, the shell assumes that it is a shell script. In this
case, it starts another shell to read the file and execute the commands
included in it. (See the section Nonbuilt-In Command Execution for
information about using the $shell variable to determine which shell is
executed.)
A pipeline is a sequence of one or more commands separated by either
the | (vertical bar) or |& (vertical bar and ampersand) characters.
With |, the standard output of the preceding command is redirected to
the standard input of the command that follows. With |&, both the stan‐
dard error and the standard output are redirected. Note that you cannot
pipe to a built-in command and an attempt to do so generates an error
message. A list is a sequence of pipelines separated by a ; (semi‐
colon), & (ampersand), && (two ampersands), or || (two vertical bars)
and optionally ended by a ; (semicolon) or an & (ampersand). These
separators and terminators have the following effects: Causes sequen‐
tial execution of the preceding pipeline (the shell waits for the pipe‐
line to finish). Causes asynchronous execution of the preceding pipe‐
line (the shell does not wait for the pipeline to finish). Causes the
list following it to be executed only if the preceding pipeline returns
a 0 (zero) exit value. Causes the list following it to be executed
only if the preceding pipeline returns a nonzero exit value.
The ; (semicolon) and & (ampersand) separators have equal precedence,
as do && and ||. The single-character separators have lower precedence
than the double-character separators. A newline character without
quotes following a pipeline functions the same as a ; (semicolon). A
pipeline or sequence can be enclosed in () (parentheses) to form a sim‐
ple command.
Job Control
The shell associates a job with each pipeline. It keeps a table of
current jobs and assigns them small integer numbers. When you start a
job asynchronously by terminating the command with &, the shell dis‐
plays a line that looks like this: [1] 1234
This line indicates that the job number is 1 and that the job is com‐
posed of one process with the process ID of 1234. Use the built-in
jobs command to see the table of current jobs.
If you are running a job and want to do something else, you can enter
the Suspend key sequence (normally <Ctrl-z>) which sends a stop signal
to the current job. The shell then normally indicates that the job has
been stopped and it prints another prompt. You can then manipulate the
state of this job, putting it in the background with the bg command, or
run some other commands and then eventually bring the job back into the
foreground with the foreground command fg. The job suspension takes
effect immediately, and is similar to the Interrupt key sequence in
that pending output and unread input are discarded. A special key
sequence, <Ctrl-y>, does not generate a stop signal until a program
attempts to read it. (See the read() system call for more information.)
This key sequence can usefully be typed ahead when you have prepared
some commands for a job that you want to stop after it has read them.
Multiple interactive loop based commands can be started and suspended.
These suspended commands can be restarted in any arbitrary order. When
a suspended job is restarted, it must be run in the foreground rather
than in the background. If an attempt is made to restart it in the
background, the shell restarts only the command that was suspended and
terminates once the job completes without continuing with the rest of
the loop.
A job being run in the background stops if it tries to read from the
terminal. Background jobs are normally allowed to produce output, but
this can be disabled by entering the stty tostop command. If you set
this terminal option, background jobs stop when they try to produce
output like they do when they try to read input.
There are several ways to refer to jobs in the shell. Use the % (per‐
cent sign) with the fg and bg built-in commands to control the job.
This name can be either the job number or a prefix of the string that
started the job, if this name is unique. (% can be used to refer to
both background and foreground jobs.)
For example, if a make process is running as job number 1, you can
refer to it as %1. You can also refer to it as %make, if there is only
one job with a name that begins with the string make. You can also use
the following characters to specify a job whose name contains string,
if there is only one such job: %?string
Just naming a job brings it to the foreground, so %1 is a synonym for
fg %1, bringing job 1 back into the foreground. Similarly, entering %1
& resumes job 1 in the background. Thus, %ex normally restarts a
stopped ex job if there was only one stopped job whose name began with
the string ex.
The shell maintains a notion of the current and previous jobs. In out‐
put produced by the built-in command jobs, the current job is marked
with a + (plus sign) and the previous job with a - (dash). The abbrevi‐
ation %+ refers to the current job and %- refers to the previous job.
For close analogy with the syntax of the history mechanism (described
later), %% is also a synonym for the current job.
Status Reporting
The shell tracks the state of each job and reports whenever a job fin‐
ishes or becomes blocked. The shell prints the status information just
before it prints the prompt to avoid disturbing the appearance of the
terminal screen. If, however, you set the notify shell variable, the
shell notifies you immediately of changes of status in background jobs.
There is also a notify shell command that marks a single process so
that its status changes are immediately reported. By default notify
marks the current process. Simply enter notify after starting a back‐
ground job to mark the job.
When you try to leave the shell while jobs are stopped, you are warned
that you have stopped jobs. You can use the built-in jobs command to
see what they are. If you then immediately exit the shell, or use jobs
and then exit, the shell does not warn you a second time, and the sus‐
pended jobs are terminated.
File Name Completion
The file name completion feature is enabled by setting the shell vari‐
able filec. The csh interactively completes file names and user names
from unique prefixes when they are input from the terminal followed by
the escape character (the <ESC> key or <Ctrl-[>)). For example, assume
the current directory looks like this:
DSC.OLD bench chaos cmd dev mail xmpl.c xmpl.out DSC.NEW bin
class cmtest lib mbox xmpl.o
The input is as follows: % vi ch<ESC>
The csh completes the prefix ch to the only matching file name chaos:
vi chaos
However, given the following command line: vi D<ESC>
csh only expands the input as follows: vi DSC.
The csh sounds the terminal bell to indicate that the expansion is
incomplete, because two file names match the prefix D.
If a partial file name is followed by the End-of-File character (shown
here as <Ctrl-d>), then instead of completing the name, csh lists all
file names matching the prefix. For example, the following input
causes all files beginning with D to be listed: vi D<Ctrl-d>
DSC.NEW DSC.OLD
The input line is then echoed again for you to complete.
The same system of <ESC> and <EOF> can also be used to expand partial
user names, if the word to be completed (or listed) begins with ~
(tilde). For example, entering the following command line: cd ~ro<ESC>
can produce the following expansion: cd ~root
The use of the terminal bell to signal errors or multiple matches can
be inhibited by setting the variable nobeep.
Normally, all files in the particular directory are candidates for name
completion. Files with certain suffixes can be excluded from consider‐
ation by setting the variable fignore to the list of suffixes to be
ignored. Thus, if fignore is set by the following command: % set fig‐
nore = (.o .out)
typing % vi x<ESC>
results in the completion to % vi xmpl.c
ignoring the files xmpl.o and xmpl.out. However, if the only completion
possible requires not ignoring these suffixes, then they are not
ignored. In addition, fignore does not affect the listing of file
names by <Ctrl-d>. All files are listed regardless of their suffixes.
History Substitution
History substitution places words from previous command input as por‐
tions of new commands, making it easy to repeat commands, repeat argu‐
ments of a previous command in the current command, or fix spelling
mistakes in the previous command with little typing. History substitu‐
tions begin with the ! (exclamation point) character and can begin
anywhere on the command line, provided they do not nest (in other
words, a history substitution cannot contain another history substitu‐
tion). You can precede the ! with a \ (backslash) to prevent the
exclamation point's special meaning. In addition, if you place an !
(exclamation point) before a space, tab, newline, = (equal sign), or (
(left parenthesis), the exclamation point is passed to the parser
unchanged. (History substitutions also occur when you begin an input
line with a ^ (circumflex). This special abbreviation is described
later.) The shell echoes any input line containing history substitu‐
tions before it executes that command line.
Commands input from the terminal that consist of one or more words are
saved on the history list. The history substitutions reintroduce
sequences of words from these saved commands into the input stream.
The history shell variable controls the size of the history list. You
must set the history shell variable either in the file or on the com‐
mand line with the built-in set command. The previous command is
always retained, however, regardless of the value of history. Commands
in the history list are numbered sequentially, starting from 1. The
built-in history command produces output of the type:
9 write michael 10 ex write.c 11 cat oldwrite.c 12 diff *write.c
The command strings are shown with their event numbers. It is not usu‐
ally necessary to use event numbers to refer to events, but you can
have the current event number displayed as part of your system prompt
by placing an ! (exclamation point) in the prompt string assigned to
the prompt variable.
A full history reference contains an event specification, a word desig‐
nator, and one or more modifiers in the following general format:
event[:]word:modifier[:modifier]...
Note that only one word can be modified. A string that contains spaces
is not allowed.
In the previous sample of history command output, the current event
number is 13. Using this example, the following refer to previous
events: Refers to event number 10. Refers to event number 11 (the cur‐
rent event minus 2). Refers to a command word beginning with d (in
this case, event number 12). Refers to a command word that contains
the string mic (in this case, event number 9).
These forms, without further modification, simply reintroduce the words
of the specified events, each separated by a single space. As a special
case, !! refers to the previous command. (The !! command alone on an
input line reruns the previous command.)
To select words from an event, follow the event specification by a :
(colon) and one of the following word designators. The words of an
input line are numbered sequentially, starting from 0 (zero), with the
first (usually command) word being 0 (zero), the second word (first
argument) being 1, and so on. The basic word designators are as fol‐
lows: First word (command). The nth argument, where n > 0, for exam‐
ple, !!:3 recalls the third word of the previous command and !:2
recalls to the second word of the current command. !#:n is the same as
!:n and recalls the nth word of the current command. First word (word
1). Last word. Word matched by (the immediately preceding) ?string?
history search. Range of words from x through y. Words 0-y. The sec‐
ond through the last words, or nothing if only one word in event.
Words x- $ Like x*, but omits the last word ($).
You can omit the : (colon) separating the event specification from the
word designator if the word designator begins with a ^, $, *, -, or %.
You can also place a sequence of modifiers, each preceded by a :
(colon), after the optional word designator. The following modifiers
are defined: Repeats the previous substitution. Removes all but the
trailing extension Applies the change globally, prefixing another modi‐
fier, for example g&. Removes a trailing path name extension, leaving
the head. Prints the new command, but does not execute it. Quotes the
substituted words, thus preventing further substitutions. Removes a
trailing component, leaving the root name. Substitutes r for l. It is
an error for no word to be applicable. Removes all leading path name
components, leaving the tail. Like q, but breaks into words at space,
tab or newline.
Unless the modifier is preceded by a g, the change is applied only to
the first modifiable word.
The l (left) side of a substitution is not a pattern in the sense of a
string recognized by an editor; rather, it is a word, a single unit
without spaces. Normally, a / (slash) delimits the word (l) and its
replacement (r). However, you can use any character as the delimiter.
Thus, in the following example the = character becomes the delimiter,
allowing you to include the / in your word: s=/usr/myfile=/usr/your‐
file=
If you include an & (ampersand) in the replacement (r), it is replaced
by the text from the left-hand side (l). A null l side is replaced by
either the last l string or by the last string used in the contextual
scan !?string?. You can omit the trailing delimiter (/) if a newline
character follows immediately.
A history reference can be given without an event specification. For
example, !$ refers to the last argument of the previous command. If a
history reference without an event specification is not the first his‐
tory reference on the line, it refers to the previous history reference
on the line and not to a previous event. For example, in !?foo?^ !$,
!?foo?^ gives the first argument of the command matching ?foo?, and the
!$ gives the last argument of that same command, not the last argument
of the previous command (as it would if it were on a line by itself).
A special abbreviation of a history reference occurs when the first
nonspace character of an input line is a ^ (circumflex). This is
equivalent to !:s^, providing a convenient shorthand for substitutions
on the text of the previous line. Thus, ^lb^lib corrects the spelling
of lib in the previous command. Finally, a history substitution can be
enclosed in { } (braces) to insulate it from the characters that fol‐
low. Thus, after ls -ld ~paul you might specify !{l}a to do ls -ld
~paula, or !la to rerun a command starting with la.
Command Line Editing (cmdedit)
If you are using a video display terminal or a workstation terminal
emulator, csh allows you to recall and edit commands as if you were
using an editor; this capability is in addition to the history mecha‐
nism. This version of the C shell provides intra-command line editing
that includes features such as a kill buffer, multiline named keyboard
macros which can be automatically saved and restored, convenient access
to the history list, and user settable key bindings. A summary of the
currently available functions is provided below. In most cases, the
functionality is apparent from the names of the routines in the list.
The shell's editing mode is determined by the value of the shell edit‐
mode variable which users should set to emacs or vi in their files. If
editmode is not set, then the shell will run in “dumb” mode. It is pos‐
sible to set the mode after the shell starts up; so if you find your‐
self in “dumb” mode, you can alter the situation without having to log
out and log in again. Setting the editmode variable has two important
side effects: (1) it causes the key bindings to be reevaluated, and
(2) it sets the EDITMODE environment variable. The latter has no
effect within the shell; so users should not set the environment vari‐
able directly in hopes of altering the editing mode.
Terminal control capabilities are extracted from the user's termcap
file (usually /etc/termcap), using the value of the shell variable
term, not the environment variable TERM, as the terminal type. If term
is undefined, unknown, or if the associated termcap definition is inad‐
equate, a warning will be displayed and most, or all, of the editing
features of the shell will be disabled. It is the user's responsibil‐
ity to make sure that term is set to an appropriate value before the
shell editor is initialized. Usually this should be done in the file.
If editing is disabled because term is not properly set when the shell
starts up, simply setting term to the proper value will normally cause
the shell editor to be reenabled. NB: Setting the shell variable term
causes the environment variable TERM to be set to the same value. For
information on controlling the bell, see the ERRORS section.
There is a bind-to-key command in this shell, which allows the func‐
tions listed in the table on bindings below, and also user defined key‐
board macros, to be bound to keys. The form of the command is bind-to-
key function key ...
where function is one of the function names from the list or else the
single character name of a keyboard macro and where key is a quoted
string designating a key sequence. Control characters in the key des‐
ignation should not be entered literally, but should be indicated by
the prefix "\^", e.g. "\^X". Similarly, escape is indicated by "\e".
A literal backslash is "\\". Escape and control-X are the only legiti‐
mate “prefix” characters. For vi mode, bindings prefixed with control-
X are for insert mode. Otherwise, the bindings are in effect only in
command mode. The following mnemonics should be used:
\^? delete (rubout)
\^c control 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
Since the shell converts returns to newlines, it is probably unwise to
alter the binding of newline. A common binding is to bind KillRegion to
Ctrl/U, which would be accomplished using the following command: bind-
to-key KillRegion "\^U"
During editor initialization the shell will read a file named in the
user's home directory. If you regularly want certain non-default key
bindings to be effective, put the appropriate bind-to-key commands in
your ~/.bindings file.
NB: Do not place the bind-to-key commands in your ~/.cshrc or ~/.login
file; they must be in the ~/.bindings file.
Invocation of the history mechanism with "!" either causes the matched
command to be inserted on the command line for editing before execution
or immediately executes the command. This is controlled by the shell
variable edithist, which is automatically set, when the shell variable
editmode is set, thereby allowing editing of previous commands invoked
by the history mechanism. This feature may be turned off with the com‐
mand "unset edithist", which may be placed in the user's file.
The following table shows the current functions and default key bind‐
ings:
Emacs Function Name Remark
^B Backspace
ESC-b BackwardWord
^A BeginningOfLine
^L ClearScreen
DefaultBinding
ESC-n DefineNamedMacro name macro
^D DeleteCurrentChar
^H DeletePreviousChar
ESC-d DeleteWord after cursor
EndOfFile exit shell
^E EndOfLine
EraseLine kills whole line
ESC-h EraseWord before cursor
ExecuteMacro
ESC-e ExecuteNamedMacro
ESC-x ExecuteNamedMacro
^X-e ExecuteUnNamedMacro
ESC-ESC FilenameExpansion
ESC-l FilenameList
^F ForwardChar
ESC-f ForwardWord
GnuTransposeChars like gnu-emacs
IncrementalSearchForward
IncrementalSearchReverse
InsertChar self insert
^V InsertLiteralChar
^W KillRegion to kill buffer
^K KillToEOL to kill buffer
^X^R LoadMacroFile
^N NextHistEntry wraps around
^P PreviousHistEntry wraps around
^R Redisplay redraws line
^U Repetition greater than 0
^M,^J Return
^X^S SaveMacroFile
^@ SetMark default mark at
BOL
SearchReverse look for next char
SearchForward look for next char
^Q StartFlow (see FLOW CONTROL)
^X-( StartRemembering begin a macro
^S StopFlow (see FLOW CONTROL)
^X-) StopRemembering end a macro
^I Tab inserts 8 spaces
^T TransposeChars before cursor
WipeLine kill line without
saving
^Y YankKillBuffer no kill ring
Vi Function Name Remark
A AppendToEOL can't use with
bind-to-key
^H BackSpace
h BackSpace
B BackwardWord
b BackwardWord
0 BeginningOfLine
^ BeginningOfLine
s ChangeChar can't use with
bind-to-key
c ChangeFollowingObject can't use with
bind-to-key
C ChangeToEOL can't use with
bind-to-key
S ChangeWholeLine can't use with
bind-to-key
x DeleteCurrentChar
d DeleteFollowingObject can't use with
bind-to-key
X DeletePreviousChar can't use with
bind-to-key
$ EndOfLine
ESC FilenameExpansion
^D FilenameListOrEof
l ForwardChar
SPACE ForwardChar
w ForwardWord
W ForwardWord
e ForwardWord
I InsertAtBOL can't use with
bind-to-key
D KillToEOL
@ ExecuteNamedMacro
+ NextHistEntry
j NextHistEntry
^N NextHistEntry
- PreviousHistEntry
k PreviousHistEntry
^P PreviousHistEntry
^L Redisplay
^R Redisplay
z Redisplay
1-9 Repetition
r ReplaceChar can't use with
bind-to-key
LINEFEED Return
RETURN Return
/ IncrementalSearchForward
? IncrementalSearchReverse
f SearchForward
F SearchReverse
m SetMark
a EnterViAppend can't use with
bind-to-key
i EnterViInsert can't use with
bind-to-key
p ViYankKillBuffer can't use with
bind-to-key
P ViYankKillBuffer can't use with
bind-to-key
Vi insert mode
^H DeletePreviousChar
EraseChar DeletePreviousChar
^W EraseWord
ESC ExitViInsert can't use with
bind-to-key
^D FilenameListOrEof
^Q InsertLiteralChar
^V InsertLiteralChar
^U KillRegion
^N NextHistEntry
^P PreviousHistEntry
^L Redisplay
^R Redisplay
LINEFEED Return
RETURN Return
TAB Tab
Users may change the bindings of functions to keys by means of the
shell bind-to-key command. These commands may be stored in a file
named in the user's home directory and will then be read by the shell
when the editor is initialized.
Flow control is handled by the terminal driver, not by the shell. The
terminal driver normally interprets ^S and ^Q as a signal to respec‐
tively stop and restart output to the terminal. By default, the shell
does not override these “bindings“, but the user may override them by
rebinding ^S or ^Q to functions other than StopFlow and StartFlow.
The functions StopFlow and StartFlow can only be usefully bound to the
keys that the terminal driver interprets as performing the correspond‐
ing flow control functions. In other words, you cannot simply bind
these functions to other keys in order to have them perform the flow
control operations normally provided by ^S and ^Q.
Keyboard macros can be used to simplify repetitive operations and
reduce typing lengthy commands. For example, the following lines
illustrate how to create a macro to startup Emacs and have it run the
shell inside a buffer:
% ^X(emacs -eshell % ^X)
Notice that this is a multiline macro, since it contains an embedded
newline. The user can give this macro a single character name, e.g.
“e”, as follows:
% \ene (escape-n-e).
The macro may then be executed by typing “\exe”. It can also be bound
to a key using the bind-to-key command. Macros can be saved in files
and can be reloaded automatically when the shell starts up. To create
a new unnamed macro, use the StartRemembering function which is bound
by default to ^X(. Subsequent keystrokes, until the StopRemembering, ^X
), function is executed, are remembered as an “unnamed” keyboard macro.
It can contain at most 1024 characters. You are not allowed to begin
creating another macro during macro creation, but it is okay to execute
other macros, provided loops are not created. The unnamed macro can be
executed using the ExecuteUnNamedMacro function, bound to ^Xe. There is
only one unnamed macro. Users can have up to 128 named macros. To
define such a macro, first create an unnamed macro as above and then
give it a name by executing the DefineNamedMacro function, bound to \en
(escape-n). The function takes a single character argument which will
be the name of the macro. Any previous macro with that same name will
be destroyed. To execute a named macro simply use the ExecuteNamed‐
Macro function, bound to \ex, and give it the name of the macro to be
executed. Named macros can also be bound to keys using the built-in
C shell command bind-to-key. Named keyboard macros can be saved in
files and loaded from files. To save the named macros in a file simply
type the file name on the command line (by itself) and then execute the
SaveMacroFile function bound to ^X^S. To read a file of previously
saved macros type the file name on the command line and execute the
LoadMacroFile function bound to ^X^R. Success in each case is indicated
by the erasure of the file name. It is okay to store macros in several
different macro files. NB: It is not advisable to try to edit saved
macros! If the shell variable macrofiles is assigned (in the user's
file) the names of one or more files of saved keyboard macros, then
those macro files will be automatically loaded when the shell starts
up. Similarly, the variable savemacros can be assigned the name of a
(single) file in which all named macros will be saved when the user
logs out.
NB: The names of the incremental search functions have changed since
earlier releases of this shell.
Four search functions are available to the user, but are not bound (by
default) to keys. If you want to use them, use the C shell bind-to-key
command to bind them to keys. When the user executes this function he
is placed in a read/search loop in which the string to be found is
built up character by character. As each new character is added to the
search string the cursor is placed at the end of the first match on the
command line following the position of the cursor when the function was
executed. You can reexecute the search function while in the loop to
cause the cursor to move to subsequent matches. Type ESC to exit the
loop. This function is similar to IncrementalSearchForward except that
the cursor is placed at the beginning of the first match on the command
line preceding the position of the cursor when the function was exe‐
cuted. This function grabs the next character you type and searches
for that character from the position of the cursor to the end of the
command line, leaving the cursor following the first instance of the
character if one is found. This function is like SearchForward except
that it searches from where the cursor is to the beginning of the com‐
mand line.
If the shell variable breakchars is assigned a string, then the charac‐
ters in that string are used to determine word boundaries. The default
break characters are " ", ",", ^I, /, \, (, ), [, ], {, }, ., ;, >, <,
!, ^, &, and |. The user defined break characters are used instead of,
not in addition to, the default list.
The display update functions take no advantage of the capabilities of
smart terminals. This will be fixed in the future.
The command line cannot exceed 1024 characters if characters are being
inserted in the middle of the line; it can be longer if characters are
being inserted at the end, but once the 1K boundary is passed the pre‐
vious characters can no longer be edited or redisplayed.
The interactive input routine performs some initialization the first
time it is called. As a result some things are not interactively
alterable. It is also not possible for the user to turn off echoing of
regular characters or to take the terminal out of CBREAK mode by means
of the stty command, for example, and have it affect the function of
the shell.
Error conditions within the editor functions are usually indicated by
an audible bell. If you prefer a visual signal and your terminal has a
visible bell capability, then you should set the variable visiblebell
in your file. If you want an audible bell also, then set both visible‐
bell and audiblebell. If you don't want to be told about your mis‐
takes, you can set the nobell variable.
Quoting with Single and Double Quotes
Enclose strings in single and double quotes to prevent all or some of
the substitutions that remain. Enclosing strings in ' ' (single
quotes) prevents any further interpretation except history substitu‐
tion. Enclosing strings in " " (double quotes) allows further variable
and command expansion. In both cases, the text that results becomes
(all or part of) a single word. Only in one special case does a string
quoted by " " yield parts of more than one word; strings quoted by ' '
never do (see Command Substitution).
Alias Substitution
The shell maintains a list of aliases that the alias and unalias built-
in commands can establish, display, and modify. After the shell scans a
command line, it divides the line into distinct commands and checks the
first word of each command, left to right, to see if it has an alias.
If an alias exists, the text defined as the alias for that command is
reread with the history mechanism, as if the alias were the previous
input line. The words that result replace the command and argument
list. If no reference is made to the history list, the argument list
is left unchanged.
Thus, if the alias for ls is ls -l, the shell replaces the command ls
/usr with ls -l /usr. The argument list is left unchanged because
there is no reference to the history list in the command with an alias.
Similarly, if the alias for lookup is grep !^ /etc/passwd, then lookup
bill maps to grep bill /etc/passwd.
Here !^ refers to the history list and the shell replaces it with the
first argument in the input line, in this case bill. Note that you can
use special pattern-matching characters in an alias. Thus, the line:
alias lprint 'pr \!* | lpr'
makes a command that formats its arguments to the line printer. The !
(exclamation point) is protected from the shell in the alias so that it
is not expanded until pr runs.
If an alias is found, the word transformation of the input text is per‐
formed and the aliasing process begins again on the reformed input
line. If the first word of the new text is the same as the old, looping
is prevented by flagging it to terminate the alias process. Other loops
are detected and cause an error.
Variable Substitution
The shell maintains a set of variables, each of which has as its value
a list of zero or more words. Some of these variables are set by the
shell or referred to by it. For instance, the argv variable is an image
of the shell variable list, and words that comprise the value of this
variable are referred to in special ways.
You can display and change the values of variables by using the set and
unset commands. Of the variables referred to by the shell, a number are
toggles (variables that turn on and off); the shell does not care what
their value is, only whether they are set or unset. For instance, the
verbose variable is a toggle that causes the words of each command to
be echoed. The setting of this variable results from the -v option on
the command line.
Other operations treat variables numerically. The @ command performs
numeric calculations and the result is assigned to a variable. Vari‐
able values are, however, always represented as (zero or more) strings.
For the purposes of numeric operations, the null string is considered
to be 0 (zero), and the second and subsequent words of multiword values
are ignored.
After the input line is parsed and alias substitution is performed, and
before each command is executed, variable substitution is performed,
keyed by $ (dollar sign) characters. You can prevent this expansion by
preceding the $ with a \ (backslash) except within " " (double quotes),
where it always occurs, or by using ' ' (single quotes), where it never
occurs. Strings quoted by ` ` (grave accents) are interpreted later
(see Command Substitution), so variable substitution does not occur
there until later, if at all. A $ is passed unchanged if followed by a
space, tab, or newline.
Input/output redirection is recognized and expanded before variable
expansion occurs. Otherwise, the command name and complete argument
list are expanded together. Therefore, it is possible for the first
(command) word to this point to generate more than one word, the first
of which becomes the command name, and the rest of which become argu‐
ments.
Unless enclosed in " " or given the :q modifier, the results of vari‐
able substitution can themselves eventually be command and file name
substituted. Within pairs of double quotes, a variable whose value
consists of multiple words expands to a (portion of a) single word,
with the words of the variable's value separated by spaces. When you
apply the :q modifier to a substitution, the variable expands to multi‐
ple words. The individual words are separated by spaces and quoted to
prevent later command or file name substitution.
The following notation allows you to introduce variable values into the
shell input. Except as noted, it is an error to reference a variable
that is not set. Are replaced by the words assigned to the variable
name, each separated by a space. Braces insulate name from following
characters that would otherwise be part of it. Shell variable names
begin with a letter and consist of up to 20 letters and digits, includ‐
ing the underscore character.
If name is not a shell variable but is set in the environment,
then that value is returned. Be aware that the : (colon) modi‐
fiers and the other forms given below are not available in this
case. Can be used to select only some of the words from the
value of name. The selector is subjected to variable substitu‐
tion and can consist of a single number or two numbers separated
by a - (dash). The first word of a variable's string value is
numbered 1. If the first number of a range is omitted, it
defaults to 1. If the last member of a range is omitted, it
defaults to $#name (the total number of words in the variable).
The * (asterisk) selects all words. It is not an error for a
range to be empty if the second argument is omitted or in range.
Gives the number of words in the variable. This can be used as a
[selector] (see previous notation). Substitutes the name of the
file from which command input is being read. An error occurs if
the name is not known. Equivalent to $argv[number]. Equivalent
to $argv[*].
You can apply the modifiers :gh, :gt, :gr, :h, :t, :r, :q and :x to the
preceding substitutions. If { } (braces) appear in the command form,
the modifiers must appear within the braces. Note that the current
implementation allows only one : (colon) modifier on each $ variable
expansion.
The following substitutions cannot be changed with : modifiers. Sub‐
stitutes the string 1 if name is set, 0 if it is not. Substitutes 1 if
the current input file name is known, 0 (zero) if it is not. Substi‐
tutes the (decimal) process number of the (parent) shell. Substitutes
a line from the standard input, with no further interpretation. Use it
to read from the keyboard in a shell script.
Command and File name Substitution
The shell performs command and file name substitution selectively on
the arguments of built-in commands. This means that it does not expand
those parts of expressions that are not evaluated. For commands that
are not internal (that is, built in) to the shell, the shell substi‐
tutes the command name separately from the argument list. This occurs
very late, after the shell performs input/output redirection, and in a
child of the main shell.
Command Substitution
The shell performs command substitution on a command string enclosed in
` ` (grave accents). The shell normally breaks the output from such a
command into separate words at spaces, tabs and newline characters,
with null words being discarded; this text then replaces the original
command string. Within strings surrounded by " " (double quotes), the
shell treats only the newline character as a word separator, thus pre‐
serving spaces and tabs.
In any case, the single final newline character does not force a new
word. Note that it is therefore possible for a command substitution to
yield only part of a word, even if the command outputs a complete line.
File Name Substitution
If a word contains any of the characters *, ?, [, or { or begins with a
~ (tilde), then that word is a candidate for file name substitution,
also known as globbing. This word is then regarded as a pattern, and
replaced with a sorted list of file names that match the pattern.
In a list of words specifying file name substitution, it is an error
for no pattern to match an existing file name, but it is not required
that each pattern match. Only the character-matching symbols (metachar‐
acters) *, ? and [ imply pattern matching; the characters ~ and { are
more like abbreviations.
In matching file names, the (dot) character at the beginning of a file
name or immediately following a / (slash), as well as the / character,
must be matched explicitly. The * (asterisk) character matches any
string of characters, including the null string. The ? (question mark)
character matches any single character. The sequence [abcd] matches any
one of the enclosed characters. Within [ ], a lexical range of charac‐
ters can be indicated by two characters separated by a - (dash), as in
[a-z]. The characters that match this pattern are defined by the cur‐
rent collating sequence. The collating sequence is determined by the
value of the LC_COLLATE or LANG environment variable.
The ~ (tilde) character at the beginning of a file name is used to
refer to home directories. Standing alone, the ~ expands to your home
directory as reflected in the value of the home shell variable. When
followed by a name that consists of letters, digits, and - (dash) char‐
acters, the shell searches for a user with that name and substitutes
that user's home directory. Thus, ~ken might expand to /users/ken and
~ken/chmach to /users/ken/chmach. If the ~ (tilde) character is fol‐
lowed by a character other than a letter or / (slash) or does not
appear at the beginning of a word, it is left undisturbed.
The pattern a{b,c,d}e is a shorthand for abe ace ade. Left-to-right
order is preserved, with the results of the matches being sorted sepa‐
rately at a low level to preserve this order. This construct can be
nested. Thus, the shell expands: ~source/s1/{oldls,ls}.c
to the file names: /usr/source/s1/oldls.c /usr/source/s1/ls.c
The preceding example assumes the home directory for source is
/usr/source. (Note that these files may or may not exist.)
Similarly, the shell expands: ../{memo,*box}
to the paths: ../memo ../box ../mbox
(Note that memo was not sorted with the results of matching *box.) As
a special case, {, }, and {} are passed undisturbed.
Redirecting Input and Output
You can redirect the standard input and standard output of a command
with the following syntax: Opens file (which is first variable, command
and file name expanded) as the standard input. Reads the shell input
up to a line that is identical to word. The word is not subjected to
variable, file name or command substitution; each input line is com‐
pared to word before any substitutions are done on this input line.
Unless a quoting character (\, ", `, or ') appears in word, the shell
performs variable and command substitution on the intervening lines,
allowing \ to quote $, \, and `. Commands that are substituted have all
spaces, tabs, and newline characters preserved, except for the final
newline character, which is dropped. The resulting text is placed in an
anonymous temporary file and given to the command as standard input.
Uses file as standard output. If the file does not exist, it is cre‐
ated; if the file exists, it is truncated, and its previous contents
are lost.
If the noclobber shell variable is set, then the file must not
exist or be a character special file (for example, a terminal or
/dev/null) or an error results. This helps prevent the acciden‐
tal destruction of files. In this case, use the ! (exclamation
point) forms to suppress this check.
The forms involving & (ampersand) route the diagnostic output
into the specified file as well as the standard output. file is
expanded in the same way as < input file names. Uses file as
standard output like > but places output at the end of the file.
If the noclobber shell variable is set, it is an error for the
file not to exist unless one of the ! forms is given. Other‐
wise, it is similar to >.
A command receives the environment in which the shell was invoked, as
changed by the input/output parameters and the presence of the command
in a pipeline. Thus, unlike some previous shells, commands run from a
shell script have no access to the text of the commands by default;
rather they receive the original standard input of the shell. Use the
<< mechanism to present inline data. This lets shell scripts function
as components of pipelines and lets the shell read its input in blocks.
To redirect diagnostic output through a pipe with the standard output,
use the form |& (vertical bar, ampersand) rather than | (vertical bar)
alone.
Control Flow
The shell contains a number of commands that can be used to regulate
the flow of control in command files (shell scripts) and (in limited
but useful ways) from terminal input. These commands all operate by
forcing the shell to reread or skip in its input and, because of the
implementation, restrict the placement of some of the commands.
The foreach, switch, and while statements, and the if-then-else form of
the if statement, require that the major keywords appear in a single
simple command on an input line.
If the shell input is not seekable, the shell buffers input whenever a
loop is being read and performs seeks in the internal buffer to do the
rereading implied by the loop. (To the extent that this allows, back‐
ward gotos succeed on non-seekable inputs.)
Built-In Commands
Built-in commands are executed within the shell. If a built-in command
occurs as any component of a pipeline except the last, it is executed
in a subshell. The csh searches for a csh built-in command first. If a
built-in does not exist, the csh searches through the directories spec‐
ified by the environment variable path for a system-level command to
execute. If no arguments are specified, displays all aliases. If name
is specified, displays the alias for name. If a word_list is also spec‐
ified, alias assigns the specified word_list as the alias of name.
Command and file name substitution are performed on word_list. Puts
the current (if %job is not specified) or specified jobs into the back‐
ground, continuing them if they were stopped. Causes execution to
resume after the end of the nearest enclosing foreach or while. The
remaining commands on the current line are executed. Multilevel breaks
are therefore possible by writing them all on one line. Causes a break
from a switch; resumes after the endsw. Defines a label in a switch
statement. (See switch.) Changes the shell's working directory to
directory. If no argument is given, it changes to your home directory.
If directory is not found as a subdirectory of the current
directory (and does not begin with /, or cdpath shell variable
is checked to see if it has a subdirectory directory. Finally,
if all else fails, but directory is a shell variable whose value
begins with /, this is tried to see if it is a directory. Con‐
tinues execution of the nearest enclosing while or foreach. The
rest of the commands on the current line are executed. Labels
the default case in a switch statement. The default should come
after all case labels. Displays the directory stack; the top of
the stack is at the left, the first directory in the stack being
the current directory. Writes the specified words to the
shell's standard output, separated by spaces, and terminated
with a newline character, unless the -n option is specified.
See the description of foreach, if, switch, and while below.
Reads arguments as input to the shell and executes the resulting
commands. This is usually used to execute commands generated as
the result of command or variable substitution, since parsing
occurs before these substitutions. Executes the specified com‐
mand in place of the current shell. Exits the shell with either
the value of the status shell variable, if no expression is
specified, or with the value of the specified expression.
Brings the current (if %job is not specified) or specified job
into the foreground, continuing them if they were stopped. Sets
the variable name to each member of word_list successively and
executes the sequence of commands between the foreach command
and the matching end. (foreach and end commands must appear
alone on separate lines.)
Use the built-in continue command to continue the loop and the
built-in break command to terminate it prematurely. When this
command is read from the terminal, the loop is read once,
prompting with ? before any statement in the loop is executed.
If you make a mistake in entering a loop at the terminal, it can
be corrected before you run the loop. Commands within loops
prompted for by ? are not placed in the history list. Func‐
tions like echo, but does not recognize \ (backslash) escapes
and delimits words by null characters in the output. Useful if
you want to use the shell to perform file name substitution to
expand a list of words. Performs file name and command expan‐
sion on the specified word to yield a string of the form label:.
The shell rewinds its input as much as possible and searches for
a line of the form label:, possibly preceded by spaces or tabs.
Execution continues after the line specified by word. Displays
the history event list; by default, the oldest events are dis‐
played first. If you specify a number, only the number most
recent events are displayed. The -r option reverses the display
order to the most recent first, rather than the oldest first.
The -h option displays the history list without leading numbers.
Use this to produce files suitable for sourcing using the source
command. Executes the single command (including its arguments)
if the specified expression evaluates TRUE. Variable substitu‐
tion on command happens early, at the same time it does for the
rest of the if command. The command argument must be a simple
command (rather than a pipeline, command list, alias, or paren‐
thesized command list). Note that input/output redirection
occurs even if expression is FALSE and command is not executed.
If expression is TRUE, executes the commands following the first
then up to the first else; otherwise, if expression2 is TRUE,
executes the commands following the second then up to the second
else. Any number of else-if pairs are possible; only one endif
is needed. The else part is optional. (The words else and
endif must appear at the beginning of input lines. The if com‐
mand must appear alone on its input line or after an else.)
This command is no longer supported. See the loader(5) refer‐
ence page for information on using shared libraries. Lists the
active jobs; with the -l option, lists process IDs in addition
to job numbers, status, and the command. Sends either the TERM
(terminate) signal or the specified signal to the jobs or pro‐
cesses that you specify. Signals are either given by number or
by name (as given in /usr/include/sys/signal.h, stripped of the
prefix SIG). The signal names are listed by kill -l. There is no
default job; specifying kill with no job or PID does not send a
signal to the current job. If the signal being sent is SIGTERM
(terminate) or SIGHUP (hangup), then the job or process is sent
a SIGCONT (continue) signal as well. Limits the usage by the
current process and each process it creates not to (individu‐
ally) exceed maximum_use on the specified resource. If no maxi‐
mum_use is given, then the current limit is displayed; if no
resource is given, then all limitations are given.
If the -h option is given, the hard limits are used instead of
the current limits. The hard limits impose a ceiling on the
values of the current limits. Only the superuser can raise the
hard limits, but a user can lower or raise the current limits
within the legal range.
Controllable resources currently include addresspace (the maxi‐
mum address space in bytes for a process), coredumpsize (the
size of the largest core dump that is created), cputime (the
maximum number of CPU seconds to be used by each process), data‐
size (the maximum growth of the data region allowed beyond the
end of the program text), descriptors (the maximum number of
open files for each process), filesize (the largest single file
that can be created), memoryuse (the maximum size to which a
process's resident set size can grow), and stacksize (the maxi‐
mum size of the automatically extended stack region).
The maximum_use can be specified as a floating-point or integer
number followed by a scale factor: k or kbytes (1024 bytes), m
or megabytes, or b or blocks. For both resource names and scale
factors, unambiguous prefixes of the names suffice. The scale
factor optionally can be separated from the numeric value by a
space; 1024k is exactly equivalent to 1024 k. The filesize can
be lowered by an instance of csh, but can only be raised by an
instance whose effective user ID is root. For more information,
refer to the documentation for the ulimit system call. Termi‐
nates a login shell and replaces it with an instance of
/usr/bin/login. This is one way to log out (included for com‐
patibility with sh). Terminates a login shell. Especially use‐
ful if ignoreeof is set. Changes the primary group identifica‐
tion of the current shell process to group. If you specify a -
(dash), newgrp changes the login environment to the login envi‐
ronment of the new group. If you do not specify a group, newgrp
changes the group identification to that specified for the cur‐
rent user in the /etc/passwd file. The newgrp command recog‐
nizes group names only; it does not recognize group ID numbers.
Only a user who is root can change the primary group of the
shell to one in which the user does not have membership. Any
active user-generated shell is terminated when the newgrp com‐
mand is used. Without arguments, nice sets the priority of com‐
mands run in this shell to 4. The +number arguments sets the
priority to the specified number. The command argument causes
command to run at priority 4 (without the +number argument) or
at priority number (if +number is specified). The greater the
number, the less CPU the process gets. The superuser can raise
the priority by using nice with a negative number. The command
is always executed in a subshell, and the restrictions placed on
commands in simple if statements apply. The first form causes
hangups to be ignored for the remainder of the shell script. The
second form causes the specified command to be run with hangups
ignored. To run a pipeline or list of commands with this form,
put the pipeline or list in a shell script, give the script exe‐
cute permission, and use the shell script as the command. All
processes run in the background with & are effectively protected
from being sent a hangup signal when you log out, but are still
subject to explicitly sent hangups unless nohup is used. Causes
the shell to notify you asynchronously when the status of the
current (if %job is not specified) or specified jobs changes.
Normally, notification is presented immediately before the shell
prompt. This is automatic if the notify shell variable is set.
Controls the action of the shell on interrupts. The first form
restores the default action of the shell on interrupts, which is
to terminate shell scripts or to return to the terminal command
input level. The second form causes all interrupts to be
ignored. The third form causes the shell to execute a goto
label when it receives an interrupt or when a child process ter‐
minates due to an interruption.
In any case, if the shell is running in the background and
interrupts are being ignored, all forms of onintr have no mean‐
ing and interrupts continue to be ignored by the shell and all
invoked commands. Pops the directory stack (removes the top
entry), changing directories to the new top directory. With a
+number argument, popd discards the number entry in the stack.
The elements of the directory stack are numbered from the top,
starting at 0 (zero). Changes to the directory that comes to
the top of the stack. With no arguments, pushd exchanges the
top two elements of the directory stack. With a name argument,
pushd changes to the new directory (that is, cd) and pushes the
old current working directory (given in the cwd shell variable)
onto the directory stack. With a numeric argument, pushd
rotates the number argument of the directory stack around to be
the top element and changes directory to it. The members of the
directory stack are numbered from the top, starting at 0 (zero).
Causes the internal hash table of the contents of the directo‐
ries in the path shell variable to be recomputed. This is needed
if new commands are added to directories in path while you are
logged in. This should be necessary only if commands are added
to one of your own directories, or if someone changes the con‐
tents of one of the system directories. Executes the specified
command, which is subject to the same restrictions as in the
simple if statement, count times. Note that input/output redi‐
rections occur exactly once, even if count is 0 (zero). This
command is no longer supported. See the loader(5) reference
page for information on using shared libraries. The first form
of the command displays the value of all shell variables. Vari‐
ables that have values other than a single word are displayed as
a parenthesized word list. The second form sets name to the null
string. The third form sets name to the single word. The fourth
form sets the indexth component of name to word; this component
must already exist. The final form sets name to the list of
words in word_list. In all cases, the value is command and file
name expanded. These arguments can be repeated to set multiple
values in a single set command. Note however, that variable
expansion happens for all arguments before any setting occurs.
Sets the value of the environment variable name to be value, a
single string. The most commonly used environment variables
USER, TERM, HOME, and PATH are automatically imported to and
exported from the csh variables user, term, home, and path, so
there is no need to use setenv for these common environment
variables.
If you modify the LC_COLLATE or LANG environment variables, the
current international character support environment and collat‐
ing sequence are changed as specified for subsequent commands
executed from the shell. Shifts to the left the members of argv
(discarding argv[1]) or the specified variable. An error occurs
if argv is not set or has fewer than two strings assigned to it.
Causes the shell to read commands from name. You can nest
source commands. However, if they are nested too deeply, the
shell can run out of file descriptors. An error in a source at
any level terminates all nested source commands. Normally, input
during source commands is not placed on the history list. The -h
option causes the commands to be placed in the history list
without being executed. Stops the current (if %job is not spec‐
ified) or specified job that is executing in the background.
Causes the shell to suspend execution by sending itself a stop
signal. This command gives an error message if attempted from a
login shell. Since csh normally ignores the stop signal, this is
the only way of suspending the shell. Successively matches each
case label (string1) against string, which is first command and
file name expanded. Use the pattern-matching characters *, ?,
and [...] in the case labels, which are variable expanded. If
none of the labels match before a default label is found, then
execution begins after the default label. Each case label and
the default label must appear at the beginning of a line.
The breaksw command causes execution to continue after the endsw
command. Otherwise, control can fall through case labels and
the default labels, as in C.
If no label matches and there is no default, execution continues
after the endsw command. With no argument, displays a summary
of time used by this shell and its children. If arguments are
given, the specified command is timed and a time summary (as
described under the time shell variable) is displayed. If neces‐
sary, an extra shell is created to display the time when the
command completes. Displays the file creation mask (first form)
or sets it to the specified value (second form). The mask is
given as an octal value. Common values for the mask are 002,
giving all access to the owner and group, and assigning read and
execute access to others, or 022, giving all access to the
owner, and assigning read and execute access to users in the
group and others. Discards all aliases with names that match
pattern. Thus, all aliases are removed by unalias *. The
absence of aliases that match pattern does not cause an error.
Disables the use of the internal hash table to speed location of
executed programs. Removes the limitation on resource. If no
resource is specified, then all resource limitations are
removed.
If -h is given, the corresponding hard limits are removed. Only
the superuser can do this. Removes all variables with names
that match pattern. Use unset * to remove all variables. The
absence of variables that match pattern is not an error.
Removes all variables with names that match pattern from the
environment. See also the setenv command (discussed earlier in
this list). Waits for all background jobs to terminate. If the
shell is interactive, an interrupt can disrupt the wait, at
which time the shell displays the names and job numbers of all
jobs known to be outstanding. Takes a list of names and looks
for the files which would be executed had these names been given
as commands. This built-in command works like /usr/bin/which if
the -U option is given; without the option, the built-in command
provides more useful information by identifying shell built-ins
and aliases. See which(1) for more information. While expres‐
sion evaluates as nonzero, executes the commands between the
while and the matching end. You can use the break command to
terminate the loop prematurely and the continue command to con‐
tinue the loop. (The while and end must appear alone on their
input lines.) If the input is a terminal, prompting occurs the
first time through the loop, as for the foreach statement.
Brings the specified job into the foreground. Continues the
specified job in the background. The first form displays the
values of all the shell variables. The second form sets the
specified name to the value of expression. If the expression
contains <, >, &, or |, at least this part of the expression
must be placed within ( ) (parentheses). The third form
assigns the value of expression to the indexth argument of name.
Both name and its indexth component must already exist.
C operators, such as *= and +=, are available. White space sepa‐
rating the name from the assignment operator is optional. Spaces
are, however, mandatory in separating components of expression,
which would otherwise be single words.
Special postfix ++ and - - operators increment and decrement
name, respectively, for example @ i++.
Expressions
The built-in commands @, exit, if, and while accept expressions that
include operators similar to those of C, but with a precedence from
right to left instead of from left to right. The following operators
are available:
( ) ~ ! * / % + - << >> <= >= < > == != =~ !~
& ^ | && ||
In the preceding list, operators of equal precedence appear on the same
line, below those lines containing operators (if any) that have greater
precedence, and above those lines containing operators having lesser
precedence. The ==, !=, =~, and !~ operators compare their arguments
as strings; all others operate on numbers. The =~ and !~ operators are
similar to != and ==, except that the rightmost side is a pattern
against which the left-hand operand is matched. This reduces the need
for use of the switch statement in shell scripts when all that is
really needed is pattern matching.
Null or missing arguments are considered 0 (zero). The result of all
expressions are strings, which represent decimal numbers. It is impor‐
tant to note that no two components of an expression can appear in the
same word. Except when next to components of expressions that are syn‐
tactically significant to the parser (&, |, <, >, -, (, and ) ) expres‐
sion components should be surrounded with spaces.
Also available in expressions as primitive operands are command execu‐
tions enclosed in { and } and file inquiries of the form -l name where
l is one of the following: Read access Write access Execute access
Existence Ownership Zero size Plain file Directory Symbolic link
The specified file is command and file name expanded and then tested to
see if it has the specified relationship to the real user. If the file
does not exist or is inaccessible, then all inquiries return FALSE,
that is, 0 (zero). Command executions succeed, returning TRUE (1), if
the command exits with status 0 (zero); otherwise, they fail, returning
FALSE (0). If more detailed status information is required, execute the
command outside of an expression and examine the status shell variable.
Predefined and Environment Variables
The following variables have special meaning to the shell. Of these,
argv, cwd, home, path, prompt, shell, and status are always set by the
shell. Except for cwd and status, this setting occurs only at initial‐
ization; the remaining variables maintain their settings unless you
explicitly reset them.
The csh command copies the USER environment variable into the variable
user, TERM into term, and HOME into home, and copies these back into
the environment whenever the normal shell variables are reset. The
PATH environment variable is handled similarly; it is not necessary to
worry about their settings other than in the file. Each csh subprocess
imports the definition of path from the environment, and exports it
again if you then change it. Is set to the arguments to the shell. It
is from this variable that positional parameters are substituted, for
example, $1 is replaced by $argv[1], and so on. If autologout is set
to a value greater than 0 (zero), the shell terminates if a command is
not entered within the prescribed number of minutes after issuing the
shell prompt.
Auto-logout is enabled by default if the shell runs as a login
shell and if the standard input stream is not a pseudo tty and
the DISPLAY environment variable is not set. Auto-logout can be
disabled by adding the following line to your or file:
set autologout = 0 Gives a list of alternate directories to be
searched to find subdirectories in chdir commands. Is set to
the full path name of the current directory. Causes each com‐
mand and its arguments to be echoed to standard output just
before it is executed. It is set when the -x command line
option is specified. For nonbuilt-in commands, all expansions
occur before echoing. Built-in commands are echoed before com‐
mand and file name substitution, since these substitutions are
then done selectively. Enables file name completion. Changes
the characters used in history substitution when given a string
value. The first character of its value is used as the history
substitution character, replacing the default character !
(exclamation point). The second character of its value replaces
the character ^ (circumflex) in quick substitutions. Controls
the existence and size of the history buffer. All commands (exe‐
cutable or not) are saved in the history buffer. Values of his‐
tory that are too large can run the shell out of memory. The
last executed command is always saved on the history list even
if history is left unset. Contains the absolute path name to
the home directory of the user, initialized from the environ‐
ment. The file name expansion of ~ (tilde) refers to this vari‐
able. Causes the shell to ignore End-of-File characters from
input devices that are terminals. This prevents shells from
accidentally being killed when they read an End-of-File charac‐
ter. Specifies the locale of your system, which is comprised of
three parts: language, territory, and codeset. The default
locale is the C locale, which specifies the value English for
language, U.S. for territory, and ASCII for codeset. The locale
specified for the LANG variable controls the language applied to
messages. Unless set explicitly, the LC_COLLATE, LC_CTYPE,
LC_MESSAGES, LC_MONETARY, LC_NUMERIC, and LC_TIME variables also
derive their settings from the locale set for LANG. Specifies
the collating sequence to use when sorting names and when char‐
acter ranges occur in patterns. The default value is the col‐
lating sequence for American English. Specifies the character
classification information to use on your system. The default
value is American English. Specifies the language that the sys‐
tem expects for user input of yes and no strings. The default
value is American English. Specifies the monetary format for
your system. The default value is the monetary format for Amer‐
ican English. Specifies the numeric format for your system.
The default value is the numeric format for American English.
Specifies the date and time format for your system. The default
value is the date and time format for American English. Speci‐
fies the files where the shell checks for mail. This is done
after each command completion that results in a prompt, if a
specified interval has elapsed. The shell displays the message
You have new mail if the file has been modified since the last
check.
If the first word of the value of mail is numeric, it specifies
a different mail checking interval (in seconds) than the default
(10 minutes).
If you specify multiple mail files, the shell displays the mes‐
sage New mail in file when there is mail in file. Specifies a
list of directories to search to find message catalogs. If set,
places restrictions on output redirection to ensure that files
are not accidentally destroyed, and that >> redirections refer
to existing files. (See also Redirecting Input and Output.) If
set, inhibits file name expansion. This is most useful in shell
scripts that do not deal with file names, or after a list of
file names is obtained and further expansions are not desirable.
If set, does not return an error for a file name expansion that
does not match any existing files; rather, the primitive pattern
is returned. It is still an error for the primitive pattern to
be malformed, for example, echo [ still gives an error. If set,
causes the shell to notify you asynchronously of background job
completion. The default is to present job status changes imme‐
diately before printing a prompt. Each word of the path vari‐
able specifies a directory in which commands are to be sought
for execution. A null word specifies the current directory. If
no path variable is set, then only full path names are executed.
The usual search path is the current directory and /usr/bin, but
this can vary from system to system. A shell that is given nei‐
ther the -c nor the -t option normally hashes the contents of
the directories in the path variable after reading and each time
the path variable is reset. If new commands are added to these
directories while the shell is active, it is necessary to exe‐
cute the rehash command in order to access the new commands.
The string that is printed before each command is read from an
interactive terminal input. If a ! (exclamation point) appears
in the string, it is replaced by the current event number,
unless it is preceded by a \ (backslash). The default prompt is
%, # for the superuser. When given a numeric value, controls
the number of entries of the history list that are saved in
~/.history when you log out. All commands (executable or not)
that are in the history list are saved. During startup, the
shell sources ~/.history into the history list, enabling history
to be saved across logins. Very large values of savehist slow
down the shell during startup. The file in which the shell
resides. This is used in forking shells to interpret files that
have execute bits set, but that are not executable by the sys‐
tem. (See Nonbuilt-In Command Execution.) This is initialized
to the (system-dependent) location of the shell. The status
returned by the last command. If it terminated abnormally, then
0200 is added to the status. Built-in commands that fail return
exit status 1; all other built-in commands set status 0 (zero).
Controls automatic timing of commands, and the line displayed by
a built-in time command. The value can consist of zero, one, or
two words.
The first word is the threshold for automatic timing, measured
in CPU seconds; for any command that takes at least that many
CPU seconds, the shell displays a line showing the timing infor‐
mation when that command finishes.
The second word is a string, enclosed in ' ' (single quotes) or
" " (double quotes), specifying the timing line to be displayed;
it controls both the automatic display and the output of the
time command. The string can contain any combination of text as
well as the following specifiers, which must be uppercase char‐
acters and preceded by a % (percent sign) as shown. Sequences
such as \n are not treated as special characters in the string.
Kilobytes of data space. Elapsed time, measured in seconds.
Number of page faults. Number of blocks read during I/O opera‐
tions. Kilobytes of stack space. Total kilobytes of memory.
Number of blocks written during I/O operations. CPU time (both
system and user) as a percentage of elapsed time. Number of
soft page faults. System time: CPU seconds used by system
calls. User time: CPU seconds used by the process outside of
system calls. Number of times the process was swapped. Kilo‐
bytes of text space.
If the first word is zero or if the time variable is set with no
value, every command is timed. The default string displayed,
when the second word is not supplied, is as follows:
%Uu %Ss %E %P% %X+%Dk %I+%Oio %Fpf+%Ww Causes the words of each
command to be displayed on the standard output after history
substitution. Set by the -v command line option.
Nonbuilt-In Command Execution
When a command to be executed is found not to be a built-in command,
the shell attempts to execute the command with the execv() system call.
Each word in the path shell variable names a directory from which the
shell attempts to execute the command (if the command does not begin
with a / (slash)). If it is given neither a -c nor a -t option, the
shell hashes the names in these directories into an internal table so
that it only tries an execv in a directory if there is a possibility
that the command resides there. This greatly speeds command location
when a large number of directories are present in the search path. If
this mechanism was turned off (with unhash), or if the shell was given
a -c or -t argument (and in any case, for each directory component of
path that does not begin with a /), the shell concatenates the direc‐
tory name with the given command name to form a path name of a file,
which it then attempts to execute.
Commands in parentheses are always executed in a subshell. Thus, (cd ;
pwd) ; pwd displays the home directory and then the current directory,
without changing the current directory location; whereas, cd ; pwd
changes the current directory location to the home directory, and
prints the home directory. Commands in parentheses are most often used
to prevent chdir from affecting the current shell.
If the file has execute permissions but is not an executable binary to
the system, then it is assumed to be a file containing shell commands
and a new shell is created to read it.
If there is an alias for shell, then the words of the alias are pre‐
fixed to the argument list to form the shell command. The first word
of the alias should be the full path name of the shell (for example,
$shell). Note that this is a special, late-occurring case of alias sub‐
stitution and only allows words to be prefixed to the argument list
without modification.
Signal Handling
The shell normally ignores SIGQUIT signals. Jobs running in the back‐
ground (either by & or the bg or %...& commands) are immune to signals
generated from the keyboard (SIGINT, SIGQUIT, and SIGHUP). Other sig‐
nals have the values the shell inherited from its parent. You can con‐
trol the shell's handling of interrupts and terminate signals in shell
scripts with onintr. Login shells catch the SIGTERM (terminate) signal;
otherwise, this signal is passed on to children from the state in the
shell's parent. In no case are interrupts allowed when a login shell
is reading the file.
Limitations
The following are csh limitations: Words can be no longer than 1024
bytes. Argument lists are limited to 38912 bytes. However, the argu‐
ment list space is shared with the space for environment variables;
having a large list of environment variables can severely limit the
allowable argument list length. The number of arguments to a command
that involves file name expansion is limited to 1/6th the number of
characters allowed in an argument list. Command substitutions can sub‐
stitute no more characters than are allowed in an argument list. To
detect looping, the shell restricts the number of alias substitutions
on a single line to 20. Words can also be separated by double spaces.
The job control is not supported in the non-interactive mode of opera‐
tion.
Character Classes
You can use the following notation to match file names within a range
indication: [:charclass:]
This format instructs the system to match any single character belong‐
ing to charclass; the defined classes correspond to ctype() subroutines
as follows:
alnum alpha cntrl digit graph lower print punct space upper xdigit
Your locale might define additional character properties, such as the
following:
[:vowel:]
The preceding character class could be TRUE for a, e, i, o, u, or y.
You could then use [:vowel] inside a set construction to match any
vowel. Refer to The LC_CTYPE Category section of the locale file for‐
mat reference page for more information.
RESTRICTIONS
Due to problems with the getrusage system call, csh incorrectly returns
a value of 0 for each of the following fields when the built-in time(3)
function or the time shell variable is used:
%D Kilobytes of data space
%F Number of page faults
%K Kilobytes of stack space
%W Number of times the process was swapped
%X Kilobytes of text space
RETURN VALUES
For information about return values, see the following sections:
sallyShell Commands, Expressions, Predefined and Environment Variables,
and OPTIONS.
FILES
C shell startup file; read at beginning of execution by each C shell.
Read by login shell (after Read by login shell at logout. The path to
the default shell. Temporary file for <<. Contains user information.
SEE ALSO
Commands: alias(1), bg(1), cd(1), echo(1), fg(1), hash(1), jobs(1),
kill(1), ksh(1), newgrp(1), nice(1), nohup(1), sh(1), Bourne shell
sh(1b), POSIX shell sh(1p), time(1), ulimit(1), umask(1), unalias(1),
wait(1)
Functions: access(2), chdir(2), exec(2), fork(2), getrlimit(2),
pipe(2), umask(2), wait(2)
Files: locale(4), null(7)
Miscellaneous: loader(5)
Command and Shell User's Guide
csh(1)
