CSH(C) XENIX System V CSH(C)
Name
csh - Invokes a shell command interpreter with C-like
syntax.
Syntax
csh [ -cefinstvVxX ] [ arg ... ]
Description
csh is a command language interpreter. It begins by
executing commands from the file .cshrc in the home
directory of the invoker. If this is a login shell, it also
executes commands from the file .login there. 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 will
be 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. Finally, each command in the current line is
executed.
When a login shell terminates, it executes commands from the
file .logout in the user's home directory.
Lexical structure
The shell splits input lines into words at blanks and tabs
with the following exceptions. The characters &, |, ;, <,
>, (, ), form separate words. If doubled in &&, ||, <<, or
>>, these pairs form single words. These parser
metacharacters may be made part of other words, or prevented
their special meaning, by preceding them with \. A newline
preceded by a \ is equivalent to a blank.
In addition, strings enclosed in matched pairs of
quotations, ', ` or ", form parts of a word; metacharacters
in these strings, including blanks and tabs, do not form
separate words. These quotations have semantics to be
described subsequently. Within pairs of \ or " characters,
a newline preceded by a \ gives a true newline character.
When the shell's input is not a terminal, the character #
introduces a comment which continues to the end of the input
line. It does not have this special meaning when preceded
by \ and placed inside the quotation marks `, ', and ".
Page 1 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
Commands
A simple command is a sequence of words, the first of which
specifies the command to be executed. A simple command or a
sequence of simple commands separated by | characters forms
a pipeline. The output of each command in a pipeline is
connected to the input of the next. Sequences of pipelines
may be separated by ;, and are then executed sequentially.
A sequence of pipelines may be executed without waiting for
it to terminate by following it with a &. Such a sequence
is automatically prevented from being terminated by a hangup
signal; the nohup command need not be used.
Any of the above may be placed in parentheses to form a
simple command (which may be a component of a pipeline,
etc.) It is also possible to separate pipelines with || or
&& indicating, as in the C language, that the second is to
be executed only if the first fails or succeeds
respectively. (See Expressions.)
Substitutions
The following sections describe the various transformations
the shell performs on the input in the order in which they
occur.
History Substitutions
History substitutions can be used to reintroduce sequences
of words from previous commands, possibly performing
modifications on these words. Thus, history substitutions
provide a generalization of a redo function.
History substitutions begin with the character ! and may
begin anywhere in the input stream if a history substitution
is not already in progress. The ! may be preceded by a \ to
prevent its special meaning; a ! is passed unchanged when it
is followed by a blank, tab, newline, =, or (. History
substitutions may also occur when an input line begins with
^. This special abbreviation will be described later.
Any input line which contains history substitution is echoed
on the terminal before it is executed as it could have been
entered without history substitution.
Commands input from the terminal which consist of one or
more words are saved on the history list, the size of which
is controlled by the history variable. The previous command
is always retained. Commands are numbered sequentially from
1.
Page 2 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
For example, enter the command:
history
Now, consider the following output from the history command:
9 write michael
10 ex write.c
11 cat oldwrite.c
12 diff *write.c
The commands are shown with their event numbers. It is not
usually necessary to use event numbers, but the current
event number can be made part of the prompt by placing a !
in the prompt string.
With the current event 13 we can refer to previous events by
event number !11, relatively as in !-2 (referring to the
same event), by a prefix of a command word as in !d for
event 12 or !w for event 9, or by a string contained in a
word in the command as in !?mic? also referring to event 9.
These forms, without further modification, simply
reintroduce the words of the specified events, each
separated by a single blank. As a special case !! refers to
the previous command; thus !! alone is essentially a redo.
The form !# references the current command (the one being
entered). It allows a word to be selected from further left
in the line, to avoid retyping a long name, as in !#:1.
To select words from an event, we can follow the event
specification by a : and a designator for the desired words.
The words of an input line are numbered from 0, the first
(usually command) word being 0, the second word (first
argument) being 1, and so on. The basic word designators
are:
0 First (command) word
n nth argument
^ First argument, i.e. 1
$ Last argument
% Word matched by (immediately preceding) ?s? search
x-y Range of words
-y Abbreviates 0-y
* Abbreviates ^-$, or nothing if only 1 word in event
Page 3 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
x* Abbreviates x-$
x- Like x* but omitting word $
The : separating the event specification from the word
designator can be omitted if the argument selector begins
with a ^, $, *, - or %. After the optional word designator,
a sequence of modifiers can be placed, each preceded by a :.
The following modifiers are defined:
h Removes a trailing pathname component
r Removes a trailing .xxx component
s/l/r/
Substitutes l for r
t Removes all leading pathname components
& Repeats the previous substitution
g Applies the change globally, prefixing the above
p Prints the new command but does not execute it
q Quotes the substituted words, preventing substitutions
x Like q, but breaks into words at blanks, tabs, and
newlines
Unless preceded by a g, the modification is applied only to
the first modifiable word. In any case it is an error for
no word to be applicable.
The left sides of substitutions are not regular expressions
in the sense of the editors, but rather strings. Any
character may be used as the delimiter in place of /; a \
quotes the delimiter within the l and r strings. The
character & in the right side is replaced by the text from
the left. A \ quotes & also. A null l uses the previous
string either from a l or from a contextual scan string s in
!?s?. The trailing delimiter in the substitution may be
omitted if a newline follows immediately as may the trailing
? in a contextual scan.
A history reference may be given without an event
specification, e.g., !$. In this case the reference is to
the previous command unless a previous history reference
occurred on the same line in which case this form repeats
the previous reference. Thus !?foo?^!$ gives the first and
last arguments from the command matching ?foo?.
Page 4 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
A special abbreviation of a history reference occurs when
the first nonblank character of an input line is a ^. This
is equivalent to !:s^, providing a convenient shorthand for
substitutions on the text of the previous line. Thus
^lb^lib fixes the spelling of lib in the previous command.
Finally, a history substitution may be surrounded with { and
} if necessary to insulate it from the characters that
follow. Thus, after ls -ld ~paul we might do !{l}a to do ls
-ld ~paula, while !la would look for a command starting la.
Quotations With ' and "
The quotation of strings by ' and " can be used to prevent
all or some of the remaining substitutions. Strings
enclosed in ' are prevented any further interpretation.
Strings enclosed in " are variable and command expansion may
occur.
In both cases, the resulting text becomes (all or part of) a
single word; only in one special case (see Command
Substitution below) does a " quoted string yield parts of
more than one word; ' quoted strings never do.
Alias Substitution
The shell maintains a list of aliases which can be
established, displayed and modified by the alias and unalias
commands. After a command line is scanned, it is parsed
into distinct commands and the first word of each command,
left-to-right, is checked to see if it has an alias. If it
does, then the text which is the alias for that command is
reread with the history mechanism available as though that
command were the previous input line. The resulting words
replace the command and argument list. If no reference is
made to the history list, then the argument list is left
unchanged.
Thus if the alias for ls is ls -l the command ``ls /usr''
would map to ``ls -l /usr''. Similarly if the alias for
lookup was ``grep \!^ /etc/passwd'' then ``lookup bill''
would map to ``grep bill /etc/passwd''.
If an alias is found, the word transformation of the input
text is performed and the aliasing process begins again on
the reformed input line. Looping is prevented if the first
word of the new text is the same as the old by flagging it
to prevent further aliasing. Other loops are detected and
cause an error.
Note that the mechanism allows aliases to introduce parser
metasyntax. Thus we can alias print ``'pr \!* | lpr''' to
Page 5 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
make a command that paginates its arguments to the
lineprinter.
There are four csh aliases distributed with the System V
csh. These are pushd , popd , swapd , and flipd . These
aliases maintain a directory stack.
pushd dir
Pushes the current directory onto the top of the
directory stack, changes to the directory dir .
popd
Changes to the directory at the top of the stack, then
removes (pops) the top directory from the stack, and
announces the current directory.
swapd
Swaps the top two directories on the stack. The
directory on the top becomes the second to the top, and
the second to the top directory becomes the top
directory.
flipd
Flips between two directories, the current directory
and the top directory on the stack. If you are
currently in dir1 , and dir2 is on the top of the
stack, when flipd is invoked, you change to dir2 and
dir1 is replaced as the top directory on the stack.
When flipd is again invoked, you change to dir1 and
dir2 is again the top directory on the stack.
Variable Substitution
The shell maintains a set of variables, each of which has a
list of zero or more words as its value. 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's
argument list, and words of this variable's value are
referred to in special ways.
The values of variables may be displayed and changed by
using the set and unset commands. Of the variables referred
to by the shell a number are toggles; the shell does not
care what their value is, only whether they are set or not.
For instance, the verbose variable is a toggle which causes
command input to be echoed. The setting of this variable
results from the -v command line option.
Page 6 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
Other operations treat variables numerically. The at-sign
(@) command permits numeric calculations to be performed and
the result assigned to a variable. However, variable values
are always represented as (zero or more) strings. For the
purposes of numeric operations, the null string is
considered to be zero, and the second and subsequent words
of multiword values are ignored.
After the input line is aliased and parsed, and before each
command is executed, variable substitution is performed,
keyed by dollar sign ($) characters. This expansion can be
prevented by preceding the dollar sign with a backslash (\)
except within double quotation marks (") where it always
occurs, and within single quotation marks (') where it never
occurs. Strings quoted by back quotation marks (`) are
interpreted later (see Command substitution below) so dollar
sign substitution does not occur there until later, if at
all. A dollar sign is passed unchanged if followed by a
blank, tab, or end-of-line.
Input and output redirections are recognized before variable
expansion, and are variable expanded separately. Otherwise,
the command name and entire argument list are expanded
together. It is thus possible for the first (command) word
to generate more than one word, the first of which becomes
the command name, and the rest of which become arguments.
Unless enclosed in double quotation marks or given the :q
modifier, the results of variable substitution may
eventually be command and filename substituted. Within
double quotation marks (") 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 blanks.
When the :q modifier is applied to a substitution, the
variable expands to multiple words with each word separated
by a blank and quoted to prevent later command or filename
substitution.
The following sequences are provided for introducing
variable values into the shell input. Except as noted, it
is an error to reference a variable which is not set.
$name
${name}
Are replaced by the words of the value of variable
name, each separated by a blank. Braces insulate name
from following characters which would otherwise be part
of it. Shell variables have names consisting of up to
20 letters, digits, and underscores.
Page 7 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
If name is not a shell variable, but is set in the
environment, then that value is returned (but : modifiers
and the other forms given below are not available in this
case).
$name[selector]
${name[selector]}
May be used to select only some of the words from the
value of name. The selector is subjected to $
substitution and may consist of a single number or two
numbers separated by a -. The first word of a
variables 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 selector * selects all words. It is not an error
for a range to be empty if the second argument is
omitted or in range.
$#name
${#name}
Gives the number of words in the variable. This is
useful for later use in a [selector].
$0 Substitutes the name of the file from which command input
is being read. An error occurs if the name is not
known.
$number
${number}
Equivalent to $argv[number].
$* Equivalent to $argv[*].
The modifiers :h, :t, :r, :q and :x may be applied to the
substitutions above as may :gh, :gt and :gr. If braces { }
appear in the command form then the modifiers must appear
within the braces. Only one : modifier is allowed on each $
expansion.
The following substitutions may not be modified with :
modifiers.
$?name
${?name}
Substitutes the string 1 if name is set, 0 if it is
not.
$?0 Substitutes 1 if the current input filename is known, 0
if it is not.
$$ Substitutes the (decimal) process number of the (parent)
shell.
Page 8 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
Command and Filename Substitution
Command and filename substitution are applied selectively to
the arguments of built-in commands. This means that
portions of expressions which are not evaluated are not
subjected to these expansions. For commands which are not
internal to the shell, the command name is substituted
separately from the argument list. This occurs very late,
after input-output redirection is performed, and in a child
of the main shell.
Command Substitution
Command substitution is indicated by a command enclosed in
back quotation marks. The output from such a command is
normally broken into separate words at blanks, tabs and
newlines, with null words being discarded, this text then
replacing the original string. Within double quotation
marks, only newlines force new words; blanks and tabs are
preserved.
In any case, the single final newline does not force a new
word. Note that it is possible for a command substitution
to yield only part of a word, even if the command outputs a
complete line.
Filename Substitution
If a word contains any of the characters *, ?, [ or { or
begins with the character ~, then that word is a candidate
for filename substitution, also known as globbing. This
word is then regarded as a pattern, and replaced with an
alphabetically sorted list of filenames which match the
pattern. In a list of words specifying filename
substitution it is an error for no pattern to match an
existing filename, but it is not required for each pattern
to match. Only the metacharacters *, ?, and [ imply pattern
matching, the characters ~ and { being more akin to
abbreviations.
In matching filenames, the character . at the beginning of a
filename or immediately following a /, as well as the
character / must be matched explicitly. The character *
matches any string of characters, including the null string.
The character ? matches any single character. The sequence
within square brackets [] matches any one of the characters
enclosed. Within square brackets [], a pair of characters
separated by - matches any character lexically between the
two.
The character ~ at the beginning of a filename is used to
Page 9 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
refer to home directories. Standing alone, it expands to
the invoker's home directory as reflected in the value of
the variable home. When followed by a name consisting of
letters, digits and - characters the shell searches for a
user with that name and substitutes their home directory;
thus ~ken might expand to /usr/ken and ~ken/chmach to
/usr/ken/chmach. If the character ~ is followed by a
character other than a letter or / or appears not at the
beginning of a word, it is left unchanged.
The metanotation a{b,c,d}e is a shorthand for abe ace ade.
Left to right order is preserved, with results of matches
being sorted separately at a low level to preserve this
order. This construct may be nested. Thus
~source/s1/{oldls,ls}.c expands to /usr/source/s1/oldls.c
/usr/source/s1/ls.c, whether or not these files exist,
assuming that the home directory for source is /usr/source.
Similarly ../{memo,*box} might expand to ../memo ../box
../mbox. (Note that memo was not sorted with the results of
matching *box.) As a special case {, } and {} are passed
unchanged.
Input/Output
The standard input and standard output of a command may be
redirected with the following syntax:
< name
Opens file name (which is first variable, command and
filename expanded) as the standard input.
<< word
Reads the shell input up to a line which is identical
to word. Word is not subjected to variable, filename or
command substitution, and each input line is compared
to word before any substitutions are done on this input
line. Unless a quoting backslash, double, or single
quotation mark, or a back quotation mark appears in
word, variable and command substitution is performed on
the intervening lines, allowing \ to quote $, \ and `.
Commands which are substituted have all blanks, tabs,
and newlines preserved, except for the final newline
which is dropped. The resulting text is placed in an
anonymous temporary file which is given to the command
as standard input.
> name
>! name
>& name
>&! name
The file name is used as standard output. If the file
Page 10 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
does not exist, then it is created; if the file exists,
it is truncated, and its previous contents are lost.
If the variable noclobber is set, then the file must
not already exist or it must be a character special
file (e.g., a terminal or /dev/null) or an error
results. This helps prevent accidental destruction of
files. In this case, the ! forms can be used and
suppress this check.
The forms involving & route the diagnostic output into
the specified file as well as the standard output.
Name is expanded in the same way as < input filenames
are.
>> name
>>& name
>>! name
>>&! name
Uses file name as standard output like > but places
output at the end of the file. If the variable
noclobber is set, then it is an error for the file not
to exist unless one of the ! forms is given. Otherwise
similar to >.
If a command is run detached (followed by &) then the
default standard input for the command is the empty file
/dev/null. Otherwise, the command receives the environment
in which the shell was invoked as modified by the input-
output parameters and the presence of the command in a
pipeline. Thus, unlike some previous shells, commands run
from a file of shell commands have no access to the text of
the commands by default; rather they receive the original
standard input of the shell. The << mechanism should be
used to present inline data. This permits shell command
scripts to function as components of pipelines and allows
the shell to block read its input.
Diagnostic output may be directed through a pipe with the
standard output. Simply use the form |& rather than just |.
Expressions
A number of the built-in commands (to be described later)
take expressions, in which the operators are similar to
those of C, with the same precedence. These expressions
appear in the @, exit, if, and while commands. The
following operators are available:
|| && | ^ & == != <= >= < > << >>
+ - * / % ! ~ ( )
Page 11 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
Here the precedence increases to the right, == and !=, <=,
>=, <, and >, << and >>, + and -, * / and % being, in
groups, at the same level. The == and != operators compare
their arguments as strings, all others operate on numbers.
Strings which begin with 0 are considered octal numbers.
Null or missing arguments are considered 0. The result of
all expressions are strings, which represent decimal
numbers. It is important to note that no two components of
an expression can appear in the same word; except when
adjacent to components of expressions which are
syntactically significant to the parser (& | < > ( )) they
should be surrounded by spaces.
Also available in expressions as primitive operands are
command executions enclosed in { and } and file enquiries of
the form -l name where l is one of:
r Read access
w Write access
x Execute access
e Existence
o Ownership
z Zero size
f Plain file
d Directory
The specified name is command and filename expanded, 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 enquiries return false, i.e. 0. Command executions
succeed, returning true, i.e. 1, if the command exits with
status 0, otherwise they fail, returning false, i.e. 0. If
more detailed status information is required then the
command should be executed outside of an expression and the
variable status examined.
Control Flow
The shell contains a number of commands which 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, due to the implementation,
restrict the placement of some of the commands.
The foreach, switch, and while statements, as well as the
if-then-else form of the if statement require that the major
keywords appear in a single simple command on an input line
as shown below.
If the shell's input is not seekable, the shell buffers up
input whenever a loop is being read and performs seeks in
Page 12 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
this internal buffer to accomplish the rereading implied by
the loop. (To the extent that this allows, backward goto
commands will succeed on nonseekable 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, then it is executed in a subshell.
alias
alias name
alias name wordlist
The first form prints all aliases. The second form
prints the alias for name . The final form assigns the
specified wordlist as the alias of name; wordlist is
command and filename substituted. Name is not allowed
to be alias or unalias
break
Causes execution to resume after the end of the nearest
enclosing foreach or while statement. The remaining
commands on the current line are executed. Multilevel
breaks are thus possible by writing them all on one
line.
breaksw
Causes a break from a switch, resuming after the endsw.
case label:
A label in a switch statement as discussed below.
cd
cd name
chdir
chdir name
Changes the shell's working directory to directory
name. If no argument is given, it then changes to the
home directory of the user. If name is not found as a
subdirectory of the current directory (and does not
begin with /, ./, or ../), then each component of the
variable cdpath is checked to see if it has a
subdirectory name. Finally, if all else fails but name
is a shell variable whose value begins with /, then
this is tried to see if it is a directory.
continue
Continues execution of the nearest enclosing while or
foreach. The rest of the commands on the current line
are executed.
default:
Page 13 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
Labels the default case in a switch statement. The
default should come after all case labels.
echo wordlist
The specified words are written to the shell's standard
output. A \c causes the echo to complete without
printing a newline. A \n in wordlist causes a newline
to be printed. Otherwise the words are echoed,
separated by spaces.
else
end
endif
endsw
See the description of the foreach, if, switch, and
while statements below.
exec command
The specified command is executed in place of the
current shell.
exit
exit(expr)
The shell exits either with the value of the status
variable (first form) or with the value of the
specified expr (second form).
foreach name (wordlist)
...
end
The variable name is successively set to each member of
wordlist and the sequence of commands between this
Page 14 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
command and the matching end are executed. (Both
foreach and end must appear alone on separate lines.)
The built-in command continue may be used to continue
the loop prematurely and the built-in command break to
terminate it prematurely. When this command is read
from the terminal, the loop is read up once prompting
with ? before any statements in the loop are executed.
glob wordlist
Like echo but no \ escapes are recognized and words are
delimited by null characters in the output. Useful for
programs which wish to use the shell to filename expand
a list of words.
goto word
The specified word is filename and command expanded 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 blanks or tabs.
Execution continues after the specified line.
history
Displays the history event list.
if (expr) command
If the specified expression evaluates true, then the
single command with arguments is executed. Variable
substitution on command happens early, at the same time
it does for the rest of the if command. Command must
be a simple command, not a pipeline, a command list, or
a parenthesized command list. Input/output redirection
occurs even if expr is false, when command is not
executed.
if (expr) then
...
else if (expr2) then
...
else
...
endif
If the specified expr is true then the commands to the
first else are executed; else if expr2 is true then the
commands to the second else are executed, etc. Any
number of else-if pairs are possible; only one endif is
needed. The else part is likewise optional. (The
words else and endif must appear at the beginning of
input lines; the if must appear alone on its input line
or after an else.)
logout
Page 15 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
Terminates a login shell. The only way to log out if
ignoreeof is set.
nice
nice +number
nice command
nice +number command
The first form sets the nice for this shell to 4. The
second form sets the nice to the given number. The
final two forms run command at priority 4 and number
respectively. The super-user may specify negative
niceness by using ``nice -number ....'' The command is
always executed in a subshell, and the restrictions
placed on commands in simple if statements apply.
nohup
nohup command
The first form can be used in shell scripts to cause
hangups to be ignored for the remainder of the script.
The second form causes the specified command to be run
with hangups ignored. Unless the shell is running
detached, nohup has no effect. All processes detached
with & are automatically nohuped. (Thus, nohup is not
really needed.)
onintr
onintr -
onintr label
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 onintr - causes all interrupts to be ignored. The
final form causes the shell to execute a goto label
when an interrupt is received or a child process
terminates because it was interrupted.
In any case, if the shell is running detached and
interrupts are being ignored, all forms of onintr have
no meaning and interrupts continue to be ignored by the
shell and all invoked commands.
rehash
Causes the internal hash table of the contents of the
directories in the path variable to be recomputed.
This is needed if new commands are added to directories
in the path while you are logged in. This should only
be necessary if you add commands to one of your own
directories, or if a systems programmer changes the
contents of one of the system directories.
repeat count command
Page 16 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
The specified command which is subject to the same
restrictions as the command in the one line if
statement above, is executed count times. I/O
redirection occurs exactly once, even if count is 0.
set
set name
set name=word
set name[index]=word
set name=(wordlist)
The first form of the command shows the value of all
shell variables. Variables which have other than a
single word as value print 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 wordlist. In all cases the
value is command and filename expanded.
These arguments may be repeated to set multiple values
in a single set command. Note however, that variable
expansion happens for all arguments before any setting
occurs.
setenv name value
Sets the value of the environment variable name to be
value, a single string. Useful environment variables
are TERM, the type of your terminal and SHELL, the
shell you are using.
shift
shift variable
The members of argv are shifted to the left, discarding
argv[1]. It is an error for argv not to be set or to
have less than one word as value. The second form
performs the same function on the specified variable.
source name
The shell reads commands from name. Source commands may
be nested; if they are nested too deeply, the shell may
run out of file descriptors. An error in a source at
any level terminates all nested source commands. Input
during source commands is never placed on the history
list.
Page 17 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
switch (string)
case str1:
...
breaksw
...
default:
...
breaksw
endsw
Each case label is successively matched, against the
specified string which is first command and filename
expanded. The file metacharacters *, ?, and [...] may
be used in the case labels, which are variable
expanded. If none of the labels match before a default
label is found, then the execution begins after the
default label. Each case label and the default label
must appear at the beginning of a line. The command
breaksw causes execution to continue after the endsw.
Otherwise control may fall through case labels and
default labels, as in C. If no label matches and there
is no default, execution continues after the endsw.
time
time command
With no argument, a summary of time used by this shell
and its children is printed. If arguments are given,
the specified simple command is timed and a time
summary as described under the time variable is
printed. If necessary, an extra shell is created to
print the time statistic when the command completes.
umask
umask value
The file creation mask is displayed (first form) or set
to the specified value (second form). The mask is
given in octal. Common values for the mask are 002
giving all access to the group and read and execute
access to others, or 022 giving all access except no
write access for users in the group or others.
unalias pattern
All aliases whose names match the specified pattern are
discarded. Thus, all aliases are removed by unalias *.
It is not an error for nothing to be unaliased.
unhash
Use of the internal hash table to speed location of
executed programs is disabled.
unset pattern
All variables whose names match the specified pattern
are removed. Thus, all variables are removed by unset
Page 18 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
*; this has noticeably distasteful side-effects. It is
not an error for nothing to be unset.
wait
All child processes are waited for. If the shell is
interactive, then an interrupt can disrupt the wait, at
which time the shell prints names and process numbers
of all children known to be outstanding.
while (expr)
...
end
While the specified expression evaluates nonzero, the
commands between the while and the matching end are
evaluated. Break and continue may be used to terminate
or continue the
loop prematurely. (The while and end must appear alone
on their input lines.) Prompting occurs here the first
time through the loop as for the foreach statement if
the input is a terminal.
@
@ name = expr
@ name[index] = expr
The first form prints the values of all the shell
variables. The second form sets the specified name to
the value of expr. If the expression contains <, >, &
or | then at least this part of the expression must be
placed within ( ). The third form assigns the value of
expr to the indexth argument of name. Both name and its
indexth component must already exist.
The operators *=, +=, etc. are available as in C. The
space separating the name from the assignment operator
is optional. Spaces are mandatory in separating
components of expr which would otherwise be single
words.
Special postfix ++ and -- operators increment and
decrement name respectively, i.e. @ i++.
Predefined Variables
The following variables have special meaning to the shell.
Of these, argv, child, home, path, prompt, shell and status
are always set by the shell. Except for child and status
this setting occurs only at initialization; these variables
will not be modified unless done explicitly by the user.
The shell copies the environment variable PATH into the
variable path, and copies the value back into the
environment whenever path is set. Thus is is not necessary
Page 19 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
to worry about its setting other than in the file .cshrc as
inferior csh processes will import the definition of path
from the environment.
argv Set to the arguments to the shell, it is from
this variable that positional parameters are
substituted, i.e., $1 is replaced by
$argv[1], etc.
cdpath Gives a list of alternate directories
searched to find subdirectories in cd
commands.
child The process number printed when the last
command was forked with &. This variable is
unset when this process terminates.
echo Set when the -x command line option is given.
Causes each command and its arguments to be
echoed just before it is executed. For
nonbuilt-in commands all expansions occur
before echoing. Builtin commands are echoed
before command and filename substitution,
since these substitutions are then done
selectively.
histchars Can be assigned a two-character string. The
first character is used as a history
character in place of !, the second character
is used in place of the ^ substitution
mechanism. For example, set histchars=",;"
will cause the history characters to be comma
and semicolon.
history Can be given a numeric value to control the
size of the history list. Any command which
has been referenced in this many events will
not be discarded. A history that is too
large may run the shell out of memory. The
last executed command is always saved on the
history list.
home The home directory of the invoker,
initialized from the environment. The
filename expansion of ~ refers to this
variable.
ignoreeof If set, the shell ignores end-of-file from
input devices that are terminals. This
prevents a shell from accidentally being
terminated by pressing Ctrl-D.
Page 20 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
mail The files where the shell checks for mail.
This is done after each command completion
which will result in a prompt, if a specified
interval has elapsed. The shell responds
with, ``You have new mail'' if the file
exists with an access time not greater than
its modify time.
If the first word of the value of mail is
numeric, it specifies a different mail
checking interval: in seconds, rather than
the default, which is 10 minutes.
If multiple mail files are specified, then
the shell responds with ``New mail in name'',
when there is mail in the file name.
noclobber As described in the section Input/Output,
restrictions are placed on output redirection
to insure that files are not accidentally
destroyed, and that >> redirections refer to
existing files.
noglob If set, filename expansion is inhibited.
This is most useful in shell scripts which
are not dealing with filenames, or after a
list of filenames has been obtained and
further expansions are not desirable.
nonomatch If set, it is not an error for a filename
expansion to not match any existing files;
rather, the primitive pattern is returned.
It is still an error for the primitive
pattern to be malformed, i.e., echo [ still
gives an error.
path Each word of the path variable specifies a
directory in which commands are to be sought
for execution. A null word specifies the
current directory. If there is no path
variable, then only full pathnames will
execute. The usual search path is /bin,
/usr/bin, and ., but this may vary from
system to system. For the super-user, the
default search path is /etc, /bin and
/usr/bin. A shell which is given neither the
-c nor the -t option will normally hash the
contents of the directories in the path
variable after reading .cshrc, and each time
the path variable is reset. If new commands
are added to these directories while the
shell is active, it may be necessary to give
Page 21 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
the rehash command, or the commands may not
be found.
prompt The string which is printed before each
command is read from an interactive terminal
input. If a ! appears in the string, it will
be replaced by the current event number
unless a preceding \ is given. Default is %
, or # for the super-user.
shell The file in which the shell resides. This is
used in forking shells to interpret files
which have execute bits set, but which are
not executable by the system. (See the
description of Nonbuilt-In Command Execution
below.) Initialized to the (system-dependent)
home of the shell.
status The status returned by the last command. If
it terminated abnormally, then 0200 is added
to the status. Built-in commands which fail
return exit status 1, all other built-in
commands set status 0.
time Controls automatic timing of commands. If
set, then any command which takes more than
this many cpu seconds will cause a line
giving user, system, real time, and a
utilization percentage which is the ratio of
user plus system times to real time to be
printed when it terminates.
verbose Set by the -v command line option, causes the
words of each command to be printed after
history substitution.
Nonbuilt-In Command Execution
When a command to be executed is found to not be a built-in
command, the shell attempts to execute the command via
exec(S). Each word in the variable path names a directory
from which the shell will attempt to execute the command.
If it is given neither a -c nor a -t option, the shell will
hash the names in these directories into an internal table
so that it will only try an exec 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 has been
turned off (via unhash), or if the shell was given a -c or
-t argument, and in any case for each directory component of
path which does not begin with a /, the shell concatenates
Page 22 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
with the given command name to form a pathname of a file
which it then attempts to execute.
Parenthesized commands are always executed in a subshell.
Thus (cd ; pwd) ; pwd prints the home directory; leaving you
where you were (printing this after the home directory),
while cd ; pwd leaves you in the home directory.
Parenthesized commands are most often used to prevent cd
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 spawned to read
it.
If there is an alias for shell then the words of the alias
are prepended to the argument list to form the shell
command. The first word of the alias should be the full
pathname of the shell (e.g. $shell). Note that this is a
special, late occurring, case of alias substitution, and
only allows words to be prepended to the argument list
without modification.
Argument List Processing
If argument 0 to the shell is - then this is a login shell.
The flag arguments are interpreted as follows:
-c Commands are read from the (single) following argument
which must be present. Any remaining arguments are
placed in argv.
-e The shell exits if any invoked command terminates
abnormally or yields a nonzero exit status.
-f The shell will start faster, because it will neither
search for nor execute commands from the file .cshrc in
the invoker's home directory.
-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 input and
output are terminals.
-n Commands are parsed, but not executed. This may aid in
syntactic checking of shell scripts.
-s Command input is taken from the standard input.
-t A single line of input is read and executed. A \ may
be used to escape the newline at the end of this line
and continue onto another line.
Page 23 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
-v Causes the verbose variable to be set, with the effect
that command input is echoed after history
substitution.
-x Causes the echo variable to be set, so that commands
are echoed immediately before execution.
-V Causes the verbose variable to be set even before
.cshrc is executed.
-X Causes the echo variable to be set even before .cshrc
is executed.
After processing of flag arguments, if arguments remain but
none of the -c, -i, -s, or -t options were given, the first
argument is taken as the name of a file of commands to be
executed. The shell opens this file, and saves its name for
possible resubstitution by $0. On a typical system, most
shell scripts are written for the standard shell (see
sh(C)), the C shell will execute such a standard shell if
the first character of a script is not a # (i.e. if the
script does not start with a comment). Remaining arguments
initialize the variable argv.
Signal Handling
The shell normally ignores quit signals. The interrupt and
quit signals are ignored for an invoked command if the
command is followed by &; otherwise the signals have the
values which the shell inherited from its parent. The
shells handling of interrupts can be controlled by onintr.
Login shells catch the 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 .logout.
Files
~/.cshrc Read at by each shell at the beginning
of execution
/etc/cshrc Systemwide default cshrc file if none is present
~/.login Read by login shell, after .cshrc at login
~/.logout Read by login shell, at logout
/bin/sh Shell for scripts not starting with a #
/tmp/sh* Temporary file for <<
/dev/null Source of empty file
Page 24 (printed 8/7/87)
CSH(C) XENIX System V CSH(C)
/etc/passwd Source of home directories for ~name
Limitations
Words can be no longer than 512 characters. The number of
arguments to a command which involves filename expansion is
limited to 1/6 number of characters allowed in an argument
list, which is 5120, less the characters in the environment.
Also, command substitutions may substitute 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.
See Also
access(S), exec(S), fork(S), pipe(S), signal(S), umask(S),
wait(S), a.out(F), environ(M)
Credit
This utility was developed at the University of California
at Berkeley and is used with permission.
Notes
Built-in control structure commands like foreach and while
cannot be used with |, & or ;.
Commands within loops, prompted for by ?, are not placed in
the history list.
It is not possible to use the colon (:) modifiers on the
output of command substitutions.
csh attempts to import and export the PATH variable for use
with regular shell scripts. This only works for simple
cases, where the PATH contains no command characters.
This version of csh does not support or use the process
control features of the 4th Berkeley Distribution.
Page 25 (printed 8/7/87)