An introduction to the C shell
William Joy
Computer Science Division
Department of Electrical Engineering and Computer Science
University of California, Berkeley
Berkeley, California 94720
ABSTRACT
Csh is a new command language interpreter for
UNIX| systems. It incorporates good features of
other shells and a history mechanism similar to
the redo of INTERLISP. While incorporating many
features of other shells which make writing shell
programs (shell scripts) easier, most of the
features unique to csh are designed more for the
interactive UNIX user.
UNIX users who have read a general introduc-
tion to the system will find a valuable basic
explanation of the shell here. Simple terminal
interaction with csh is possible after reading
just the first section of this document. The
second section describes the shells capabilities
which you can explore after you have begun to
become acquainted with the shell. Later sections
introduce features which are useful, but not
necessary for all users of the shell.
Back matter includes an appendix listing spe-
cial characters of the shell and a glossary of
terms and commands introduced in this manual.
May 30, 1993
_________________________
| UNIX is a registered trademark of Unix System
Laboratories, Inc.
An introduction to the C shell
William Joy
Computer Science Division
Department of Electrical Engineering and Computer Science
University of California, Berkeley
Berkeley, California 94720
Introduction
A shell is a command language interpreter. Csh is the
name of one particular command interpreter on UNIX. The
primary purpose of csh is to translate command lines typed
at a terminal into system actions, such as invocation of
other programs. Csh is a user program just like any you
might write. Hopefully, csh will be a very useful program
for you in interacting with the UNIX system.
In addition to this document, you will want to refer to
a copy of the UNIX programmer's manual. The csh documenta-
tion in the manual provides a full description of all
features of the shell and is a final reference for questions
about the shell.
Many words in this document are shown in italics.
These are important words; names of commands, and words
which have special meaning in discussing the shell and UNIX.
Many of the words are defined in a glossary at the end of
this document. If you don't know what is meant by a word,
you should look for it in the glossary.
Acknowledgements
Numerous people have provided good input about previous
versions of csh and aided in its debugging and in the debug-
ging of its documentation. I would especially like to thank
Michael Ubell who made the crucial observation that history
commands could be done well over the word structure of input
text, and implemented a prototype history mechanism in an
older version of the shell. Eric Allman has also provided a
large number of useful comments on the shell, helping to
unify those concepts which are present and to identify and
eliminate useless and marginally useful features. Mike
O'Brien suggested the pathname hashing mechanism which
speeds command execution. Jim Kulp added the job control
and directory stack primitives and added their documentation
to this introduction.
- 2 -
1. Terminal usage of the shell
1.1. The basic notion of commands
A shell in UNIX acts mostly as a medium through which
other programs are invoked. While it has a set of builtin
functions which it performs directly, most commands cause
execution of programs that are, in fact, external to the
shell. The shell is thus distinguished from the command
interpreters of other systems both by the fact that it is
just a user program, and by the fact that it is used almost
exclusively as a mechanism for invoking other programs.
Commands in the UNIX system consist of a list of
strings or words interpreted as a command name followed by
arguments. Thus the command
mail bill
consists of two words. The first word mail names the com-
mand to be executed, in this case the mail program which
sends messages to other users. The shell uses the name of
the command in attempting to execute it for you. It will
look in a number of directories for a file with the name
mail which is expected to contain the mail program.
The rest of the words of the command are given as argu-
ments to the command itself when it is executed. In this
case we specified also the argument bill which is inter-
preted by the mail program to be the name of a user to whom
mail is to be sent. In normal terminal usage we might use
the mail command as follows.
% mail bill
I have a question about the csh documentation.
My document seems to be missing page 5.
Does a page five exist?
Bill
EOT
%
Here we typed a message to send to bill and ended this
message with a |D which sent an end-of-file to the mail pro-
gram. (Here and throughout this document, the notation
``|x'' is to be read ``control-x'' and represents the strik-
ing of the x key while the control key is held down.) The
mail program then echoed the characters `EOT' and transmit-
ted our message. The characters `% ' were printed before
and after the mail command by the shell to indicate that
input was needed.
After typing the `% ' prompt the shell was reading com-
mand input from our terminal. We typed a complete command
- 3 -
`mail bill'. The shell then executed the mail program with
argument bill and went dormant waiting for it to complete.
The mail program then read input from our terminal until we
signalled an end-of-file via typing a |D after which the
shell noticed that mail had completed and signaled us that
it was ready to read from the terminal again by printing
another `% ' prompt.
This is the essential pattern of all interaction with
UNIX through the shell. A complete command is typed at the
terminal, the shell executes the command and when this exe-
cution completes, it prompts for a new command. If you run
the editor for an hour, the shell will patiently wait for
you to finish editing and obediently prompt you again when-
ever you finish editing.
An example of a useful command you can execute now is
the tset command, which sets the default erase and kill
characters on your terminal - the erase character erases the
last character you typed and the kill character erases the
entire line you have entered so far. By default, the erase
character is `#' and the kill character is `@'. Most people
who use CRT displays prefer to use the backspace (|H) char-
acter as their erase character since it is then easier to
see what you have typed so far. You can make this be true
by typing
tset -e
which tells the program tset to set the erase character, and
its default setting for this character is a backspace.
1.2. Flag arguments
A useful notion in UNIX is that of a flag argument.
While many arguments to commands specify file names or user
names some arguments rather specify an optional capability
of the command which you wish to invoke. By convention,
such arguments begin with the character `-' (hyphen). Thus
the command
ls
will produce a list of the files in the current working
directory. The option -s is the size option, and
ls -s
causes ls to also give, for each file the size of the file
in blocks of 512 characters. The manual section for each
command in the UNIX reference manual gives the available
options for each command. The ls command has a large number
of useful and interesting options. Most other commands have
either no options or only one or two options. It is hard to
- 4 -
remember options of commands which are not used very fre-
quently, so most UNIX utilities perform only one or two
functions rather than having a large number of hard to
remember options.
1.3. Output to files
Commands that normally read input or write output on
the terminal can also be executed with this input and/or
output done to a file.
Thus suppose we wish to save the current date in a file
called `now'. The command
date
will print the current date on our terminal. This is
because our terminal is the default standard output for the
date command and the date command prints the date on its
standard output. The shell lets us redirect the standard
output of a command through a notation using the metacharac-
ter `>' and the name of the file where output is to be
placed. Thus the command
date > now
runs the date command such that its standard output is the
file `now' rather than the terminal. Thus this command
places the current date and time into the file `now'. It is
important to know that the date command was unaware that its
output was going to a file rather than to the terminal. The
shell performed this redirection before the command began
executing.
One other thing to note here is that the file `now'
need not have existed before the date command was executed;
the shell would have created the file if it did not exist.
And if the file did exist? If it had existed previously
these previous contents would have been discarded! A shell
option noclobber exists to prevent this from happening
accidentally; it is discussed in section 2.2.
The system normally keeps files which you create with
`>' and all other files. Thus the default is for files to
be permanent. If you wish to create a file which will be
removed automatically, you can begin its name with a `#'
character, this `scratch' character denotes the fact that
the file will be a scratch file.* The system will remove
_________________________
*Note that if your erase character is a `#', you will
have to precede the `#' with a `\'. The fact that the
`#' character is the old (pre-CRT) standard erase
character means that it seldom appears in a file name,
and allows this convention to be used for scratch
- 5 -
such files after a couple of days, or sooner if file space
becomes very tight. Thus, in running the date command
above, we don't really want to save the output forever, so
we would more likely do
date > #now
1.4. Metacharacters in the shell
The shell has a large number of special characters
(like `>') which indicate special functions. We say that
these notations have syntactic and semantic meaning to the
shell. In general, most characters which are neither
letters nor digits have special meaning to the shell. We
shall shortly learn a means of quotation which allows us to
use metacharacters without the shell treating them in any
special way.
Metacharacters normally have effect only when the shell
is reading our input. We need not worry about placing shell
metacharacters in a letter we are sending via mail, or when
we are typing in text or data to some other program. Note
that the shell is only reading input when it has prompted
with `% '.
1.5. Input from files; pipelines
We learned above how to redirect the standard output of
a command to a file. It is also possible to redirect the
standard input of a command from a file. This is not often
necessary since most commands will read from a file whose
name is given as an argument. We can give the command
sort < data
to run the sort command with standard input, where the com-
mand normally reads its input, from the file `data'. We
would more likely say
sort data
letting the sort command open the file `data' for input
itself since this is less to type.
We should note that if we just typed
sort
_________________________
files. If you are using a CRT, your erase character
should be a |H, as we demonstrated in section 1.1 how
this could be set up.
- 6 -
then the sort program would sort lines from its standard
input. Since we did not redirect the standard input, it
would sort lines as we typed them on the terminal until we
typed a |D to indicate an end-of-file.
A most useful capability is the ability to combine the
standard output of one command with the standard input of
another, i.e. to run the commands in a sequence known as a
pipeline. For instance the command
ls -s
normally produces a list of the files in our directory with
the size of each in blocks of 512 characters. If we are
interested in learning which of our files is largest we may
wish to have this sorted by size rather than by name, which
is the default way in which ls sorts. We could look at the
many options of ls to see if there was an option to do this
but would eventually discover that there is not. Instead we
can use a couple of simple options of the sort command, com-
bining it with ls to get what we want.
The -n option of sort specifies a numeric sort rather
than an alphabetic sort. Thus
ls -s | sort -n
specifies that the output of the ls command run with the
option -s is to be piped to the command sort run with the
numeric sort option. This would give us a sorted list of
our files by size, but with the smallest first. We could
then use the -r reverse sort option and the head command in
combination with the previous command doing
ls -s | sort -n -r | head -5
Here we have taken a list of our files sorted alphabeti-
cally, each with the size in blocks. We have run this to
the standard input of the sort command asking it to sort
numerically in reverse order (largest first). This output
has then been run into the command head which gives us the
first few lines. In this case we have asked head for the
first 5 lines. Thus this command gives us the names and
sizes of our 5 largest files.
The notation introduced above is called the pipe
mechanism. Commands separated by `|' characters are con-
nected together by the shell and the standard output of each
is run into the standard input of the next. The leftmost
command in a pipeline will normally take its standard input
from the terminal and the rightmost will place its standard
output on the terminal. Other examples of pipelines will be
given later when we discuss the history mechanism; one
important use of pipes which is illustrated there is in the
- 7 -
routing of information to the line printer.
1.6. Filenames
Many commands to be executed will need the names of
files as arguments. UNIX pathnames consist of a number of
components separated by `/'. Each component except the last
names a directory in which the next component resides, in
effect specifying the path of directories to follow to reach
the file. Thus the pathname
/etc/motd
specifies a file in the directory `etc' which is a subdirec-
tory of the root directory `/'. Within this directory the
file named is `motd' which stands for `message of the day'.
A pathname that begins with a slash is said to be an abso-
lute pathname since it is specified from the absolute top of
the entire directory hierarchy of the system (the root).
Pathnames which do not begin with `/' are interpreted as
starting in the current working directory, which is, by
default, your home directory and can be changed dynamically
by the cd change directory command. Such pathnames are said
to be relative to the working directory since they are found
by starting in the working directory and descending to lower
levels of directories for each component of the pathname.
If the pathname contains no slashes at all then the file is
contained in the working directory itself and the pathname
is merely the name of the file in this directory. Absolute
pathnames have no relation to the working directory.
Most filenames consist of a number of alphanumeric
characters and `.'s (periods). In fact, all printing char-
acters except `/' (slash) may appear in filenames. It is
inconvenient to have most non-alphabetic characters in
filenames because many of these have special meaning to the
shell. The character `.' (period) is not a shell-
metacharacter and is often used to separate the extension of
a file name from the base of the name. Thus
prog.c prog.o prog.errs prog.output
are four related files. They share a base portion of a name
(a base portion being that part of the name that is left
when a trailing `.' and following characters which are not
`.' are stripped off). The file `prog.c' might be the
source for a C program, the file `prog.o' the corresponding
object file, the file `prog.errs' the errors resulting from
a compilation of the program and the file `prog.output' the
output of a run of the program.
If we wished to refer to all four of these files in a
command, we could use the notation
- 8 -
prog.*
This word is expanded by the shell, before the command to
which it is an argument is executed, into a list of names
which begin with `prog.'. The character `*' here matches
any sequence (including the empty sequence) of characters in
a file name. The names which match are alphabetically
sorted and placed in the argument list of the command. Thus
the command
echo prog.*
will echo the names
prog.c prog.errs prog.o prog.output
Note that the names are in sorted order here, and a dif-
ferent order than we listed them above. The echo command
receives four words as arguments, even though we only typed
one word as as argument directly. The four words were gen-
erated by filename expansion of the one input word.
Other notations for filename expansion are also avail-
able. The character `?' matches any single character in a
filename. Thus
echo ? ?? ???
will echo a line of filenames; first those with one charac-
ter names, then those with two character names, and finally
those with three character names. The names of each length
will be independently sorted.
Another mechanism consists of a sequence of characters
between `[' and `]'. This metasequence matches any single
character from the enclosed set. Thus
prog.[co]
will match
prog.c prog.o
in the example above. We can also place two characters
around a `-' in this notation to denote a range. Thus
chap.[1-5]
might match files
chap.1 chap.2 chap.3 chap.4 chap.5
if they existed. This is shorthand for
- 9 -
chap.[12345]
and otherwise equivalent.
An important point to note is that if a list of argu-
ment words to a command (an argument list) contains filename
expansion syntax, and if this filename expansion syntax
fails to match any existing file names, then the shell con-
siders this to be an error and prints a diagnostic
No match.
and does not execute the command.
Another very important point is that files with the
character `.' at the beginning are treated specially. Nei-
ther `*' or `?' or the `[' `]' mechanism will match it.
This prevents accidental matching of the filenames `.' and
`..' in the working directory which have special meaning to
the system, as well as other files such as .cshrc which are
not normally visible. We will discuss the special role of
the file .cshrc later.
Another filename expansion mechanism gives access to
the pathname of the home directory of other users. This
notation consists of the character `~' (tilde) followed by
another users' login name. For instance the word `~bill'
would map to the pathname `/usr/bill' if the home directory
for `bill' was `/usr/bill'. Since, on large systems, users
may have login directories scattered over many different
disk volumes with different prefix directory names, this
notation provides a reliable way of accessing the files of
other users.
A special case of this notation consists of a `~'
alone, e.g. `~/mbox'. This notation is expanded by the
shell into the file `mbox' in your home directory, i.e. into
`/usr/bill/mbox' for me on Ernie Co-vax, the UCB Computer
Science Department VAX machine, where this document was
prepared. This can be very useful if you have used cd to
change to another directory and have found a file you wish
to copy using cp. If I give the command
cp thatfile ~
the shell will expand this command to
cp thatfile /usr/bill
since my home directory is /usr/bill.
There also exists a mechanism using the characters `{'
and `}' for abbreviating a set of words which have common
- 10 -
parts but cannot be abbreviated by the above mechanisms
because they are not files, are the names of files which do
not yet exist, are not thus conveniently described. This
mechanism will be described much later, in section 4.2, as
it is used less frequently.
1.7. Quotation
We have already seen a number of metacharacters used by
the shell. These metacharacters pose a problem in that we
cannot use them directly as parts of words. Thus the com-
mand
echo *
will not echo the character `*'. It will either echo an
sorted list of filenames in the current working directory,
or print the message `No match' if there are no files in the
working directory.
The recommended mechanism for placing characters which
are neither numbers, digits, `/', `.' or `-' in an argument
word to a command is to enclose it with single quotation
characters `'', i.e.
echo '*'
There is one special character `!' which is used by the his-
tory mechanism of the shell and which cannot be escaped by
placing it within `'' characters. It and the character `''
itself can be preceded by a single `\' to prevent their spe-
cial meaning. Thus
echo \'\!
prints
'!
These two mechanisms suffice to place any printing character
into a word which is an argument to a shell command. They
can be combined, as in
echo \''*'
which prints
'*
since the first `\' escaped the first `'' and the `*' was
enclosed between `'' characters.
- 11 -
1.8. Terminating commands
When you are executing a command and the shell is wait-
ing for it to complete there are several ways to force it to
stop. For instance if you type the command
cat /etc/passwd
the system will print a copy of a list of all users of the
system on your terminal. This is likely to continue for
several minutes unless you stop it. You can send an INTER-
RUPT signal to the cat command by typing the DEL or RUBOUT
key on your terminal.* Since cat does not take any precau-
tions to avoid or otherwise handle this signal the INTERRUPT
will cause it to terminate. The shell notices that cat has
terminated and prompts you again with `% '. If you hit
INTERRUPT again, the shell will just repeat its prompt since
it handles INTERRUPT signals and chooses to continue to exe-
cute commands rather than terminating like cat did, which
would have the effect of logging you out.
Another way in which many programs terminate is when
they get an end-of-file from their standard input. Thus the
mail program in the first example above was terminated when
we typed a |D which generates an end-of-file from the stan-
dard input. The shell also terminates when it gets an end-
of-file printing `logout'; UNIX then logs you off the sys-
tem. Since this means that typing too many |D's can
accidentally log us off, the shell has a mechanism for
preventing this. This ignoreeof option will be discussed in
section 2.2.
If a command has its standard input redirected from a
file, then it will normally terminate when it reaches the
end of this file. Thus if we execute
mail bill < prepared.text
the mail command will terminate without our typing a |D.
This is because it read to the end-of-file of our file
`prepared.text' in which we placed a message for `bill' with
an editor program. We could also have done
cat prepared.text | mail bill
since the cat command would then have written the text
through the pipe to the standard input of the mail command.
When the cat command completed it would have terminated,
closing down the pipeline and the mail command would have
received an end-of-file from it and terminated. Using a
_________________________
*Many users use stty(1) to change the interrupt
character to |C.
- 12 -
pipe here is more complicated than redirecting input so we
would more likely use the first form. These commands could
also have been stopped by sending an INTERRUPT.
Another possibility for stopping a command is to
suspend its execution temporarily, with the possibility of
continuing execution later. This is done by sending a STOP
signal via typing a |Z. This signal causes all commands
running on the terminal (usually one but more if a pipeline
is executing) to become suspended. The shell notices that
the command(s) have been suspended, types `Stopped' and then
prompts for a new command. The previously executing command
has been suspended, but otherwise unaffected by the STOP
signal. Any other commands can be executed while the origi-
nal command remains suspended. The suspended command can be
continued using the fg command with no arguments. The shell
will then retype the command to remind you which command is
being continued, and cause the command to resume execution.
Unless any input files in use by the suspended command have
been changed in the meantime, the suspension has no effect
whatsoever on the execution of the command. This feature
can be very useful during editing, when you need to look at
another file before continuing. An example of command
suspension follows.
2. Details on the shell for terminal users
2.1. Shell startup and termination
When you login, the shell is started by the system in
your home directory and begins by reading commands from a
file .cshrc in this directory. All shells which you may
start during your terminal session will read from this file.
We will later see what kinds of commands are usefully placed
there. For now we need not have this file and the shell
does not complain about its absence.
A login shell, executed after you login to the system,
will, after it reads commands from .cshrc, read commands
from a file .login also in your home directory. This file
contains commands which you wish to do each time you login
to the UNIX system. My .login file looks something like:
set ignoreeof
set mail=(/usr/spool/mail/bill)
echo "${prompt}users" ; users
alias ts \
'set noglob ; eval `tset -s -m dialup:c100rv4pna -m plugboard:?hp2621nl *`';
ts; stty intr |C kill |U crt
set time=15 history=10
msgs -f
if (-e $mail) then
echo "${prompt}mail"
mail
endif
This file contains several commands to be executed by
UNIX each time I login. The first is a set command which is
interpreted directly by the shell. It sets the shell vari-
able ignoreeof which causes the shell to not log me off if I
hit |D. Rather, I use the logout command to log off of the
system. By setting the mail variable, I ask the shell to
watch for incoming mail to me. Every 5 minutes the shell
looks for this file and tells me if more mail has arrived
there. An alternative to this is to put the command
biff y
in place of this set; this will cause me to be notified
immediately when mail arrives, and to be shown the first few
lines of the new message.
Next I set the shell variable `time' to `15' causing
the shell to automatically print out statistics lines for
commands which execute for at least 15 seconds of CPU time.
The variable `history' is set to 10 indicating that I want
the shell to remember the last 10 commands I type in its
history list, (described later).
May 30, 1993
- 2 -
I create an alias ``ts'' which executes a tset(1) com-
mand setting up the modes of the terminal. The parameters
to tset indicate the kinds of terminal which I usually use
when not on a hardwired port. I then execute ``ts'' and
also use the stty command to change the interrupt character
to |C and the line kill character to |U.
I then run the `msgs' program, which provides me with
any system messages which I have not seen before; the `-f'
option here prevents it from telling me anything if there
are no new messages. Finally, if my mailbox file exists,
then I run the `mail' program to process my mail.
When the `mail' and `msgs' programs finish, the shell
will finish processing my .login file and begin reading com-
mands from the terminal, prompting for each with `% '. When
I log off (by giving the logout command) the shell will
print `logout' and execute commands from the file `.logout'
if it exists in my home directory. After that the shell
will terminate and UNIX will log me off the system. If the
system is not going down, I will receive a new login mes-
sage. In any case, after the `logout' message the shell is
committed to terminating and will take no further input from
my terminal.
2.2. Shell variables
The shell maintains a set of variables. We saw above
the variables history and time which had values `10' and
`15'. In fact, each shell variable has as value an array of
zero or more strings. Shell variables may be assigned
values by the set command. It has several forms, the most
useful of which was given above and is
set name=value
Shell variables may be used to store values which are
to be used in commands later through a substitution mechan-
ism. The shell variables most commonly referenced are, how-
ever, those which the shell itself refers to. By changing
the values of these variables one can directly affect the
behavior of the shell.
One of the most important variables is the variable
path. This variable contains a sequence of directory names
where the shell searches for commands. The set command with
no arguments shows the value of all variables currently
defined (we usually say set) in the shell. The default
value for path will be shown by set to be
May 30, 1993
3. Shell control structures and command scripts
3.1. Introduction
It is possible to place commands in files and to cause
shells to be invoked to read and execute commands from these
files, which are called shell scripts. We here detail those
features of the shell useful to the writers of such scripts.
3.2. Make
It is important to first note what shell scripts are
not useful for. There is a program called make which is
very useful for maintaining a group of related files or per-
forming sets of operations on related files. For instance a
large program consisting of one or more files can have its
dependencies described in a makefile which contains defini-
tions of the commands used to create these different files
when changes occur. Definitions of the means for printing
listings, cleaning up the directory in which the files
reside, and installing the resultant programs are easily,
and most appropriately placed in this makefile. This format
is superior and preferable to maintaining a group of shell
procedures to maintain these files.
Similarly when working on a document a makefile may be
created which defines how different versions of the document
are to be created and which options of nroff or troff are
appropriate.
3.3. Invocation and the argv variable
A csh command script may be interpreted by saying
% csh script ...
where script is the name of the file containing a group of
csh commands and `...' is replaced by a sequence of argu-
ments. The shell places these arguments in the variable
argv and then begins to read commands from the script.
These parameters are then available through the same mechan-
isms which are used to reference any other shell variables.
If you make the file `script' executable by doing
chmod 755 script
and place a shell comment at the beginning of the shell
script (i.e. begin the file with a `#' character) then a
`/bin/csh' will automatically be invoked to execute `script'
when you type
script
May 30, 1993
- 2 -
If the file does not begin with a `#' then the standard
shell `/bin/sh' will be used to execute it. This allows you
to convert your older shell scripts to use csh at your con-
venience.
3.4. Variable substitution
After each input line is broken into words and history
substitutions are done on it, the input line is parsed into
distinct commands. Before each command is executed a
mechanism know as variable substitution is done on these
words. Keyed by the character `$' this substitution
replaces the names of variables by their values. Thus
echo $argv
when placed in a command script would cause the current
value of the variable argv to be echoed to the output of the
shell script. It is an error for argv to be unset at this
point.
A number of notations are provided for accessing com-
ponents and attributes of variables. The notation
$?name
expands to `1' if name is set or to `0' if name is not set.
It is the fundamental mechanism used for checking whether
particular variables have been assigned values. All other
forms of reference to undefined variables cause errors.
The notation
$#name
expands to the number of elements in the variable name.
Thus
% set argv=(a b c)
% echo $?argv
1
% echo $#argv
3
% unset argv
% echo $?argv
0
% echo $argv
Undefined variable: argv.
%
It is also possible to access the components of a vari-
able which has several values. Thus
May 30, 1993
- 3 -
$argv[1]
gives the first component of argv or in the example above
`a'. Similarly
$argv[$#argv]
would give `c', and
$argv[1-2]
would give `a b'. Other notations useful in shell scripts
are
$n
where n is an integer as a shorthand for
$argv[n]
the nth parameter and
$*
which is a shorthand for
$argv
The form
$$
expands to the process number of the current shell. Since
this process number is unique in the system it can be used
in generation of unique temporary file names. The form
$<
is quite special and is replaced by the next line of input
read from the shell's standard input (not the script it is
reading). This is useful for writing shell scripts that are
interactive, reading commands from the terminal, or even
writing a shell script that acts as a filter, reading lines
from its input file. Thus the sequence
echo 'yes or no?\c'
set a=($<)
would write out the prompt `yes or no?' without a newline
and then read the answer into the variable `a'. In this
case `$#a' would be `0' if either a blank line or end-of-
file (|D) was typed.
May 30, 1993
- 4 -
One minor difference between `$n' and `$argv[n]' should
be noted here. The form `$argv[n]' will yield an error if n
is not in the range `1-$#argv' while `$n' will never yield
an out of range subscript error. This is for compatibility
with the way older shells handled parameters.
Another important point is that it is never an error to
give a subrange of the form `n-'; if there are less than n
components of the given variable then no words are substi-
tuted. A range of the form `m-n' likewise returns an empty
vector without giving an error when m exceeds the number of
elements of the given variable, provided the subscript n is
in range.
3.5. Expressions
In order for interesting shell scripts to be con-
structed it must be possible to evaluate expressions in the
shell based on the values of variables. In fact, all the
arithmetic operations of the language C are available in the
shell with the same precedence that they have in C. In par-
ticular, the operations `==' and `!=' compare strings and
the operators `&&' and `||' implement the boolean and/or
operations. The special operators `=~' and `!~' are similar
to `==' and `!=' except that the string on the right side
can have pattern matching characters (like *, ? or []) and
the test is whether the string on the left matches the pat-
tern on the right.
The shell also allows file enquiries of the form
-? filename
where `?' is replace by a number of single characters. For
instance the expression primitive
-e filename
tell whether the file `filename' exists. Other primitives
test for read, write and execute access to the file, whether
it is a directory, or has non-zero length.
It is possible to test whether a command terminates
normally, by a primitive of the form `{ command }' which
returns true, i.e. `1' if the command succeeds exiting nor-
mally with exit status 0, or `0' if the command terminates
abnormally or with exit status non-zero. If more detailed
information about the execution status of a command is
required, it can be executed and the variable `$status'
examined in the next command. Since `$status' is set by
every command, it is very transient. It can be saved if it
is inconvenient to use it only in the single immediately
following command.
May 30, 1993
- 5 -
For a full list of expression components available see
the manual section for the shell.
3.6. Sample shell script
A sample shell script which makes use of the expression
mechanism of the shell and some of its control structure
follows:
% cat copyc
#
# Copyc copies those C programs in the specified list
# to the directory ~/backup if they differ from the files
# already in ~/backup
#
set noglob
foreach i ($argv)
if ($i !~ *.c) continue # not a .c file so do nothing
if (! -r ~/backup/$i:t) then
echo $i:t not in backup... not cp\'ed
continue
endif
cmp -s $i ~/backup/$i:t # to set $status
if ($status != 0) then
echo new backup of $i
cp $i ~/backup/$i:t
endif
end
This script makes use of the foreach command, which
causes the shell to execute the commands between the foreach
and the matching end for each of the values given between
`(' and `)' with the named variable, in this case `i' set to
successive values in the list. Within this loop we may use
the command break to stop executing the loop and continue to
prematurely terminate one iteration and begin the next.
After the foreach loop the iteration variable (i in this
case) has the value at the last iteration.
We set the variable noglob here to prevent filename
expansion of the members of argv. This is a good idea, in
general, if the arguments to a shell script are filenames
which have already been expanded or if the arguments may
contain filename expansion metacharacters. It is also pos-
sible to quote each use of a `$' variable expansion, but
this is harder and less reliable.
The other control construct used here is a statement of
the form
May 30, 1993
- 6 -
if ( expression ) then
command
...
endif
The placement of the keywords here is not flexible due to
the current implementation of the shell.|
The shell does have another form of the if statement of
the form
if ( expression ) command
which can be written
if ( expression ) \
command
Here we have escaped the newline for the sake of appearance.
The command must not involve `|', `&' or `;' and must not be
another control command. The second form requires the final
`\' to immediately precede the end-of-line.
The more general if statements above also admit a
sequence of else-if pairs followed by a single else and an
endif, e.g.:
if ( expression ) then
commands
else if (expression ) then
commands
...
else
commands
endif
Another important mechanism used in shell scripts is
_________________________
|The following two formats are not currently acceptable
to the shell:
if ( expression ) # Won't work!
then
command
...
endif
and
if ( expression ) then command endif # Won't work
May 30, 1993
- 7 -
the `:' modifier. We can use the modifier `:r' here to
extract a root of a filename or `:e' to extract the exten-
sion. Thus if the variable i has the value `/mnt/foo.bar'
then
% echo $i $i:r $i:e
/mnt/foo.bar /mnt/foo bar
%
shows how the `:r' modifier strips off the trailing `.bar'
and the the `:e' modifier leaves only the `bar'. Other
modifiers will take off the last component of a pathname
leaving the head `:h' or all but the last component of a
pathname leaving the tail `:t'. These modifiers are fully
described in the csh manual pages in the programmers manual.
It is also possible to use the command substitution mechan-
ism described in the next major section to perform modifica-
tions on strings to then reenter the shells environment.
Since each usage of this mechanism involves the creation of
a new process, it is much more expensive to use than the `:'
modification mechanism.# Finally, we note that the character
`#' lexically introduces a shell comment in shell scripts
(but not from the terminal). All subsequent characters on
the input line after a `#' are discarded by the shell. This
character can be quoted using `'' or `\' to place it in an
argument word.
3.7. Other control structures
The shell also has control structures while and switch
similar to those of C. These take the forms
while ( expression )
commands
end
and
_________________________
#It is also important to note that the current
implementation of the shell limits the number of `:'
modifiers on a `$' substitution to 1. Thus
% echo $i $i:h:t
/a/b/c /a/b:t
%
does not do what one would expect.
May 30, 1993
- 8 -
switch ( word )
case str1:
commands
breaksw
...
case strn:
commands
breaksw
default:
commands
breaksw
endsw
For details see the manual section for csh. C programmers
should note that we use breaksw to exit from a switch while
break exits a while or foreach loop. A common mistake to
make in csh scripts is to use break rather than breaksw in
switches.
Finally, csh allows a goto statement, with labels look-
ing like they do in C, i.e.:
loop:
commands
goto loop
3.8. Supplying input to commands
Commands run from shell scripts receive by default the
standard input of the shell which is running the script.
This is different from previous shells running under UNIX.
It allows shell scripts to fully participate in pipelines,
but mandates extra notation for commands which are to take
inline data.
Thus we need a metanotation for supplying inline data
to commands in shell scripts. As an example, consider this
script which runs the editor to delete leading blanks from
the lines in each argument file
May 30, 1993
- 9 -
% cat deblank
# deblank -- remove leading blanks
foreach i ($argv)
ed - $i << 'EOF'
1,$s/|[ ]*//
w
q
'EOF'
end
%
The notation `<< 'EOF'' means that the standard input for
the ed command is to come from the text in the shell script
file up to the next line consisting of exactly `'EOF''. The
fact that the `EOF' is enclosed in `'' characters, i.e.
quoted, causes the shell to not perform variable substitu-
tion on the intervening lines. In general, if any part of
the word following the `<<' which the shell uses to ter-
minate the text to be given to the command is quoted then
these substitutions will not be performed. In this case
since we used the form `1,$' in our editor script we needed
to insure that this `$' was not variable substituted. We
could also have insured this by preceding the `$' here with
a `\', i.e.:
1,\$s/|[ ]*//
but quoting the `EOF' terminator is a more reliable way of
achieving the same thing.
3.9. Catching interrupts
If our shell script creates temporary files, we may
wish to catch interruptions of the shell script so that we
can clean up these files. We can then do
onintr label
where label is a label in our program. If an interrupt is
received the shell will do a `goto label' and we can remove
the temporary files and then do an exit command (which is
built in to the shell) to exit from the shell script. If we
wish to exit with a non-zero status we can do
exit(1)
e.g. to exit with status `1'.
3.10. What else?
There are other features of the shell useful to writers
of shell procedures. The verbose and echo options and the
related -v and -x command line options can be used to help
May 30, 1993
- 10 -
trace the actions of the shell. The -n option causes the
shell only to read commands and not to execute them and may
sometimes be of use.
One other thing to note is that csh will not execute
shell scripts which do not begin with the character `#',
that is shell scripts that do not begin with a comment.
Similarly, the `/bin/sh' on your system may well defer to
`csh' to interpret shell scripts which begin with `#'. This
allows shell scripts for both shells to live in harmony.
There is also another quotation mechanism using `"'
which allows only some of the expansion mechanisms we have
so far discussed to occur on the quoted string and serves to
make this string into a single word as `'' does.
May 30, 1993
- 11 -
May 30, 1993
4. Other, less commonly used, shell features
4.1. Loops at the terminal; variables as vectors
It is occasionally useful to use the foreach control
structure at the terminal to aid in performing a number of
similar commands. For instance, there were at one point
three shells in use on the Cory UNIX system at Cory Hall,
`/bin/sh', `/bin/nsh', and `/bin/csh'. To count the number
of persons using each shell one could have issued the com-
mands
% grep -c csh$ /etc/passwd
27
% grep -c nsh$ /etc/passwd
128
% grep -c -v sh$ /etc/passwd
430
%
Since these commands are very similar we can use foreach to
do this more easily.
% foreach i ('sh$' 'csh$' '-v sh$')
? grep -c $i /etc/passwd
? end
27
128
430
%
Note here that the shell prompts for input with `? ' when
reading the body of the loop.
Very useful with loops are variables which contain
lists of filenames or other words. You can, for example, do
% set a=(`ls`)
% echo $a
csh.n csh.rm
% ls
csh.n
csh.rm
% echo $#a
2
%
The set command here gave the variable a a list of all the
filenames in the current directory as value. We can then
iterate over these names to perform any chosen function.
The output of a command within ``' characters is con-
verted by the shell to a list of words. You can also place
the ``' quoted string within `"' characters to take each
May 30, 1993
- 2 -
(non-empty) line as a component of the variable; preventing
the lines from being split into words at blanks and tabs. A
modifier `:x' exists which can be used later to expand each
component of the variable into another variable splitting it
into separate words at embedded blanks and tabs.
4.2. Braces { ... } in argument expansion
Another form of filename expansion, alluded to before
involves the characters `{' and `}'. These characters
specify that the contained strings, separated by `,' are to
be consecutively substituted into the containing characters
and the results expanded left to right. Thus
A{str1,str2,...strn}B
expands to
Astr1B Astr2B ... AstrnB
This expansion occurs before the other filename expansions,
and may be applied recursively (i.e. nested). The results
of each expanded string are sorted separately, left to right
order being preserved. The resulting filenames are not
required to exist if no other expansion mechanisms are used.
This means that this mechanism can be used to generate argu-
ments which are not filenames, but which have common parts.
A typical use of this would be
mkdir ~/{hdrs,retrofit,csh}
to make subdirectories `hdrs', `retrofit' and `csh' in your
home directory. This mechanism is most useful when the com-
mon prefix is longer than in this example, i.e.
chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}
4.3. Command substitution
A command enclosed in ``' characters is replaced, just
before filenames are expanded, by the output from that com-
mand. Thus it is possible to do
set pwd=`pwd`
to save the current directory in the variable pwd or to do
ex `grep -l TRACE *.c`
to run the editor ex supplying as arguments those files
whose names end in `.c' which have the string `TRACE' in
them.*
_________________________
*Command expansion also occurs in input redirected with
May 30, 1993
- 3 -
4.4. Other details not covered here
In particular circumstances it may be necessary to know
the exact nature and order of different substitutions per-
formed by the shell. The exact meaning of certain combina-
tions of quotations is also occasionally important. These
are detailed fully in its manual section.
The shell has a number of command line option flags
mostly of use in writing UNIX programs, and debugging shell
scripts. See the shells manual section for a list of these
options.
_________________________
`<<' and within `"' quotations. Refer to the shell
manual section for full details.
May 30, 1993
- 4 -
May 30, 1993
Appendix - Special characters
The following table lists the special characters of csh and
the UNIX system, giving for each the section(s) in which it
is discussed. A number of these characters also have spe-
cial meaning in expressions. See the csh manual section for
a complete list.
Syntactic metacharacters
; 2.4 separates commands to be executed sequentially
| 1.5 separates commands in a pipeline
( ) 2.2,3.6 brackets expressions and variable values
& 2.5 follows commands to be executed without waiting for completion
Filename metacharacters
/ 1.6 separates components of a file's pathname
? 1.6 expansion character matching any single character
* 1.6 expansion character matching any sequence of characters
[ ] 1.6 expansion sequence matching any single character from a set
~ 1.6 used at the beginning of a filename to indicate home directories
{ } 4.2 used to specify groups of arguments with common parts
Quotation metacharacters
\ 1.7 prevents meta-meaning of following single character
' 1.7 prevents meta-meaning of a group of characters
" 4.3 like ', but allows variable and command expansion
Input/output metacharacters
< 1.5 indicates redirected input
> 1.3 indicates redirected output
Expansion/substitution metacharacters
$ 3.4 indicates variable substitution
! 2.3 indicates history substitution
: 3.6 precedes substitution modifiers
| 2.3 used in special forms of history substitution
` 4.3 indicates command substitution
Other metacharacters
# 1.3,3.6 begins scratch file names; indicates shell comments
- 1.2 prefixes option (flag) arguments to commands
% 2.6 prefixes job name specifications
May 30, 1993
- 2 -
May 30, 1993
Glossary
This glossary lists the most important terms introduced
in the introduction to the shell and gives references to
sections of the shell document for further information about
them. References of the form `pr (1)' indicate that the
command pr is in the UNIX programmer's manual in section 1.
You can get an online copy of its manual page by doing
man 1 pr
References of the form (2.5) indicate that more information
can be found in section 2.5 of this manual.
. Your current directory has the name `.' as
well as the name printed by the command pwd;
see also dirs. The current directory `.' is
usually the first component of the search
path contained in the variable path, thus
commands which are in `.' are found first
(2.2). The character `.' is also used in
separating components of filenames (1.6).
The character `.' at the beginning of a com-
ponent of a pathname is treated specially and
not matched by the filename expansion meta-
characters `?', `*', and `[' `]' pairs (1.6).
.. Each directory has a file `..' in it which is
a reference to its parent directory. After
changing into the directory with chdir, i.e.
chdir paper
you can return to the parent directory by
doing
chdir ..
The current directory is printed by pwd
(2.7).
a.out Compilers which create executable images
create them, by default, in the file a.out.
for historical reasons (2.3).
absolute pathname
A pathname which begins with a `/' is abso-
lute since it specifies the path of direc-
tories from the beginning of the entire
directory system - called the root directory.
Pathnames which are not absolute are called
relative (see definition of relative path-
name) (1.6).
May 30, 1993
- 2 -
alias An alias specifies a shorter or different
name for a UNIX command, or a transformation
on a command to be performed in the shell.
The shell has a command alias which estab-
lishes aliases and can print their current
values. The command unalias is used to
remove aliases (2.4).
argument Commands in UNIX receive a list of argument
words. Thus the command
echo a b c
consists of the command name `echo' and three
argument words `a', `b' and `c'. The set of
arguments after the command name is said to
be the argument list of the command (1.1).
argv The list of arguments to a command written in
the shell language (a shell script or shell
procedure) is stored in a variable called
argv within the shell. This name is taken
from the conventional name in the C program-
ming language (3.4).
background Commands started without waiting for them to
complete are called background commands
(2.6).
base A filename is sometimes thought of as con-
sisting of a base part, before any `.' char-
acter, and an extension - the part after the
`.'. See filename and extension (1.6)
bg The bg command causes a suspended job to con-
tinue execution in the background (2.6).
bin A directory containing binaries of programs
and shell scripts to be executed is typically
called a bin directory. The standard system
bin directories are `/bin' containing the
most heavily used commands and `/usr/bin'
which contains most other user programs.
Programs developed at UC Berkeley live in
`/usr/ucb', while locally written programs
live in `/usr/local'. Games are kept in the
directory `/usr/games'. You can place
binaries in any directory. If you wish to
execute them often, the name of the direc-
tories should be a component of the variable
path.
break Break is a builtin command used to exit from
loops within the control structure of the
May 30, 1993
- 3 -
shell (3.7).
breaksw The breaksw builtin command is used to exit
from a switch control structure, like a break
exits from loops (3.7).
builtin A command executed directly by the shell is
called a builtin command. Most commands in
UNIX are not built into the shell, but rather
exist as files in bin directories. These
commands are accessible because the direc-
tories in which they reside are named in the
path variable.
case A case command is used as a label in a switch
statement in the shell's control structure,
similar to that of the language C. Details
are given in the shell documentation `csh(1)'
(3.7).
cat The cat program catenates a list of specified
files on the standard output. It is usually
used to look at the contents of a single file
on the terminal, to `cat a file' (1.8, 2.3).
cd The cd command is used to change the working
directory. With no arguments, cd changes
your working directory to be your home direc-
tory (2.4, 2.7).
chdir The chdir command is a synonym for cd. Cd is
usually used because it is easier to type.
chsh The chsh command is used to change the shell
which you use on UNIX. By default, you use
an different version of the shell which
resides in `/bin/sh'. You can change your
shell to `/bin/csh' by doing
chsh your-login-name /bin/csh
Thus I would do
chsh bill /bin/csh
It is only necessary to do this once. The
next time you log in to UNIX after doing this
command, you will be using csh rather than
the shell in `/bin/sh' (1.9).
cmp Cmp is a program which compares files. It is
usually used on binary files, or to see if
two files are identical (3.6). For comparing
text files the program diff, described in
May 30, 1993
- 4 -
`diff (1)' is used.
command A function performed by the system, either by
the shell (a builtin command) or by a program
residing in a file in a directory within the
UNIX system, is called a command (1.1).
command name
When a command is issued, it consists of a
command name, which is the first word of the
command, followed by arguments. The conven-
tion on UNIX is that the first word of a com-
mand names the function to be performed
(1.1).
command substitution
The replacement of a command enclosed in ``'
characters by the text output by that command
is called command substitution (4.3).
component A part of a pathname between `/' characters
is called a component of that pathname. A
variable which has multiple strings as value
is said to have several components; each
string is a component of the variable.
continue A builtin command which causes execution of
the enclosing foreach or while loop to cycle
prematurely. Similar to the continue command
in the programming language C (3.6).
control- Certain special characters, called control
characters, are produced by holding down the
CONTROL key on your terminal and simultane-
ously pressing another character, much like
the SHIFT key is used to produce upper case
characters. Thus control-c is produced by
holding down the CONTROL key while pressing
the `c' key. Usually UNIX prints an up-arrow
(|) followed by the corresponding letter when
you type a control character (e.g. `|C' for
control-c (1.8).
core dump When a program terminates abnormally, the
system places an image of its current state
in a file named `core'. This core dump can
be examined with the system debugger `adb(1)'
or `sdb(1)' in order to determine what went
wrong with the program (1.8). If the shell
produces a message of the form
Illegal instruction (core dumped)
(where `Illegal instruction' is only one of
May 30, 1993
- 5 -
several possible messages), you should report
this to the author of the program or a system
administrator, saving the `core' file.
cp The cp (copy) program is used to copy the
contents of one file into another file. It
is one of the most commonly used UNIX com-
mands (1.6).
csh The name of the shell program that this docu-
ment describes.
.cshrc The file .cshrc in your home directory is
read by each shell as it begins execution.
It is usually used to change the setting of
the variable path and to set alias parameters
which are to take effect globally (2.1).
cwd The cwd variable in the shell holds the abso-
lute pathname of the current working direc-
tory. It is changed by the shell whenever
your current working directory changes and
should not be changed otherwise (2.2).
date The date command prints the current date and
time (1.3).
debugging Debugging is the process of correcting mis-
takes in programs and shell scripts. The
shell has several options and variables which
may be used to aid in shell debugging (4.4).
default: The label default: is used within shell
switch statements, as it is in the C language
to label the code to be executed if none of
the case labels matches the value switched on
(3.7).
DELETE The DELETE or RUBOUT key on the terminal nor-
mally causes an interrupt to be sent to the
current job. Many users change the interrupt
character to be |C.
detached A command that continues running in the back-
ground after you logout is said to be
detached.
diagnostic An error message produced by a program is
often referred to as a diagnostic. Most
error messages are not written to the stan-
dard output, since that is often directed
away from the terminal (1.3, 1.5). Error
messsages are instead written to the diagnos-
tic output which may be directed away from
May 30, 1993
- 6 -
the terminal, but usually is not. Thus diag-
nostics will usually appear on the terminal
(2.5).
directory A structure which contains files. At any
time you are in one particular directory
whose names can be printed by the command
pwd. The chdir command will change you to
another directory, and make the files in that
directory visible. The directory in which you
are when you first login is your home direc-
tory (1.1, 2.7).
directory stackThe shell saves the names of previous working
directories in the directory stack when you
change your current working directory via the
pushd command. The directory stack can be
printed by using the dirs command, which
includes your current working directory as
the first directory name on the left (2.7).
dirs The dirs command prints the shell's directory
stack (2.7).
du The du command is a program (described in
`du(1)') which prints the number of disk
blocks is all directories below and including
your current working directory (2.6).
echo The echo command prints its arguments (1.6,
3.6).
else The else command is part of the `if-then-
else-endif' control command construct (3.6).
endif If an if statement is ended with the word
then, all lines following the if up to a line
starting with the word endif or else are exe-
cuted if the condition between parentheses
after the if is true (3.6).
EOF An end-of-file is generated by the terminal
by a control-d, and whenever a command reads
to the end of a file which it has been given
as input. Commands receiving input from a
pipe receive an end-of-file when the command
sending them input completes. Most commands
terminate when they receive an end-of-file.
The shell has an option to ignore end-of-file
from a terminal input which may help you keep
from logging out accidentally by typing too
many control-d's (1.1, 1.8, 3.8).
escape A character `\' used to prevent the special
May 30, 1993
- 7 -
meaning of a metacharacter is said to escape
the character from its special meaning. Thus
echo \*
will echo the character `*' while just
echo *
will echo the names of the file in the
current directory. In this example, \
escapes `*' (1.7). There is also a non-
printing character called escape, usually
labelled ESC or ALTMODE on terminal key-
boards. Some older UNIX systems use this
character to indicate that output is to be
suspended. Most systems use control-s to
stop the output and control-q to start it.
/etc/passwd This file contains information about the
accounts currently on the system. It con-
sists of a line for each account with fields
separated by `:' characters (1.8). You can
look at this file by saying
cat /etc/passwd
The commands finger and grep are often used
to search for information in this file. See
`finger(1)', `passwd(5)', and `grep(1)' for
more details.
exit The exit command is used to force termination
of a shell script, and is built into the
shell (3.9).
exit status A command which discovers a problem may
reflect this back to the command (such as a
shell) which invoked (executed) it. It does
this by returning a non-zero number as its
exit status, a status of zero being con-
sidered `normal termination'. The exit com-
mand can be used to force a shell command
script to give a non-zero exit status (3.6).
expansion The replacement of strings in the shell input
which contain metacharacters by other strings
is referred to as the process of expansion.
Thus the replacement of the word `*' by a
sorted list of files in the current directory
is a `filename expansion'. Similarly the
replacement of the characters `!!' by the
text of the last command is a `history expan-
sion'. Expansions are also referred to as
May 30, 1993
- 8 -
substitutions (1.6, 3.4, 4.2).
expressions Expressions are used in the shell to control
the conditional structures used in the writ-
ing of shell scripts and in calculating
values for these scripts. The operators
available in shell expressions are those of
the language C (3.5).
extension Filenames often consist of a base name and an
extension separated by the character `.'. By
convention, groups of related files often
share the same root name. Thus if `prog.c'
were a C program, then the object file for
this program would be stored in `prog.o'.
Similarly a paper written with the `-me'
nroff macro package might be stored in
`paper.me' while a formatted version of this
paper might be kept in `paper.out' and a list
of spelling errors in `paper.errs' (1.6).
fg The job control command fg is used to run a
background or suspended job in the foreground
(1.8, 2.6).
filename Each file in UNIX has a name consisting of up
to 14 characters and not including the char-
acter `/' which is used in pathname building.
Most filenames do not begin with the charac-
ter `.', and contain only letters and digits
with perhaps a `.' separating the base por-
tion of the filename from an extension (1.6).
filename expansion
Filename expansion uses the metacharacters
`*', `?' and `[' and `]' to provide a con-
venient mechanism for naming files. Using
filename expansion it is easy to name all the
files in the current directory, or all files
which have a common root name. Other filename
expansion mechanisms use the metacharacter
`~' and allow files in other users' direc-
tories to be named easily (1.6, 4.2).
flag Many UNIX commands accept arguments which are
not the names of files or other users but are
used to modify the action of the commands.
These are referred to as flag options, and by
convention consist of one or more letters
preceded by the character `-' (1.2). Thus
the ls (list files) command has an option
`-s' to list the sizes of files. This is
specified
May 30, 1993
- 9 -
ls -s
foreach The foreach command is used in shell scripts
and at the terminal to specify repetition of
a sequence of commands while the value of a
certain shell variable ranges through a
specified list (3.6, 4.1).
foreground When commands are executing in the normal way
such that the shell is waiting for them to
finish before prompting for another command
they are said to be foreground jobs or run-
ning in the foreground. This is as opposed
to background. Foreground jobs can be
stopped by signals from the terminal caused
by typing different control characters at the
keyboard (1.8, 2.6).
goto The shell has a command goto used in shell
scripts to transfer control to a given label
(3.7).
grep The grep command searches through a list of
argument files for a specified string. Thus
grep bill /etc/passwd
will print each line in the file /etc/passwd
which contains the string `bill'. Actually,
grep scans for regular expressions in the
sense of the editors `ed(1)' and `ex(1)'.
Grep stands for `globally find regular
expression and print' (2.4).
head The head command prints the first few lines
of one or more files. If you have a bunch of
files containing text which you are wondering
about it is sometimes useful to run head with
these files as arguments. This will usually
show enough of what is in these files to let
you decide which you are interested in (1.5).
Head is also used to describe the part of a
pathname before and including the last `/'
character. The tail of a pathname is the
part after the last `/'. The `:h' and `:t'
modifiers allow the head or tail of a path-
name stored in a shell variable to be used
(3.6).
history The history mechanism of the shell allows
previous commands to be repeated, possibly
after modification to correct typing mistakes
May 30, 1993
- 10 -
or to change the meaning of the command. The
shell has a history list where these commands
are kept, and a history variable which con-
trols how large this list is (2.3).
home directory
Each user has a home directory, which is
given in your entry in the password file,
/etc/passwd. This is the directory which you
are placed in when you first login. The cd
or chdir command with no arguments takes you
back to this directory, whose name is
recorded in the shell variable home. You can
also access the home directories of other
users in forming filenames using a filename
expansion notation and the character `~'
(1.6).
if A conditional command within the shell, the
if command is used in shell command scripts
to make decisions about what course of action
to take next (3.6).
ignoreeof Normally, your shell will exit, printing
`logout' if you type a control-d at a prompt
of `% '. This is the way you usually log off
the system. You can set the ignoreeof vari-
able if you wish in your .login file and then
use the command logout to logout. This is
useful if you sometimes accidentally type too
many control-d characters, logging yourself
off (2.2).
input Many commands on UNIX take information from
the terminal or from files which they then
act on. This information is called input.
Commands normally read for input from their
standard input which is, by default, the ter-
minal. This standard input can be redirected
from a file using a shell metanotation with
the character `<'. Many commands will also
read from a file specified as argument. Com-
mands placed in pipelines will read from the
output of the previous command in the pipe-
line. The leftmost command in a pipeline
reads from the terminal if you neither
redirect its input nor give it a filename to
use as standard input. Special mechanisms
exist for supplying input to commands in
shell scripts (1.5, 3.8).
interrupt An interrupt is a signal to a program that is
generated by hitting the RUBOUT or DELETE key
(although users can and often do change the
May 30, 1993
- 11 -
interrupt character, usually to |C). It
causes most programs to stop execution. Cer-
tain programs, such as the shell and the edi-
tors, handle an interrupt in special ways,
usually by stopping what they are doing and
prompting for another command. While the
shell is executing another command and wait-
ing for it to finish, the shell does not
listen to interrupts. The shell often wakes
up when you hit interrupt because many com-
mands die when they receive an interrupt
(1.8, 3.9).
job One or more commands typed on the same input
line separated by `|' or `;' characters are
run together and are called a job. Simple
commands run by themselves without any `|' or
`;' characters are the simplest jobs. Jobs
are classified as foreground, background, or
suspended (2.6).
job control The builtin functions that control the execu-
tion of jobs are called job control commands.
These are bg, fg, stop, kill (2.6).
job number When each job is started it is assigned a
small number called a job number which is
printed next to the job in the output of the
jobs command. This number, preceded by a `%'
character, can be used as an argument to job
control commands to indicate a specific job
(2.6).
jobs The jobs command prints a table showing jobs
that are either running in the background or
are suspended (2.6).
kill A command which sends a signal to a job caus-
ing it to terminate (2.6).
.login The file .login in your home directory is
read by the shell each time you login to UNIX
and the commands there are executed. There
are a number of commands which are usefully
placed here, especially set commands to the
shell itself (2.1).
login shell The shell that is started on your terminal
when you login is called your login shell.
It is different from other shells which you
may run (e.g. on shell scripts) in that it
reads the .login file before reading commands
from the terminal and it reads the .logout
file after you logout (2.1).
May 30, 1993
- 12 -
logout The logout command causes a login shell to
exit. Normally, a login shell will exit when
you hit control-d generating an end-of-file,
but if you have set ignoreeof in you .login
file then this will not work and you must use
logout to log off the UNIX system (2.8).
.logout When you log off of UNIX the shell will exe-
cute commands from the file .logout in your
home directory after it prints `logout'.
lpr The command lpr is the line printer daemon.
The standard input of lpr spooled and printed
on the UNIX line printer. You can also give
lpr a list of filenames as arguments to be
printed. It is most common to use lpr as the
last component of a pipeline (2.3).
ls The ls (list files) command is one of the
most commonly used UNIX commands. With no
argument filenames it prints the names of the
files in the current directory. It has a
number of useful flag arguments, and can also
be given the names of directories as argu-
ments, in which case it lists the names of
the files in these directories (1.2).
mail The mail program is used to send and receive
messages from other UNIX users (1.1, 2.1).
make The make command is used to maintain one or
more related files and to organize functions
to be performed on these files. In many ways
make is easier to use, and more helpful than
shell command scripts (3.2).
makefile The file containing commands for make is
called makefile (3.2).
manual The manual often referred to is the `UNIX
programmer's manual'. It contains a number
of sections and a description of each UNIX
program. An online version of the manual is
accessible through the man command. Its
documentation can be obtained online via
man man
metacharacter
Many characters which are neither letters nor
digits have special meaning either to the
shell or to UNIX. These characters are
called metacharacters. If it is necessary to
May 30, 1993
- 13 -
place these characters in arguments to com-
mands without them having their special mean-
ing then they must be quoted. An example of
a metacharacter is the character `>' which is
used to indicate placement of output into a
file. For the purposes of the history
mechanism, most unquoted metacharacters form
separate words (1.4). The appendix to this
user's manual lists the metacharacters in
groups by their function.
mkdir The mkdir command is used to create a new
directory.
modifier Substitutions with the history mechanism,
keyed by the character `!' or of variables
using the metacharacter `$', are often sub-
jected to modifications, indicated by placing
the character `:' after the substitution and
following this with the modifier itself. The
command substitution mechanism can also be
used to perform modification in a similar
way, but this notation is less clear (3.6).
more The program more writes a file on your termi-
nal allowing you to control how much text is
displayed at a time. More can move through
the file screenful by screenful, line by
line, search forward for a string, or start
again at the beginning of the file. It is
generally the easiest way of viewing a file
(1.8).
noclobber The shell has a variable noclobber which may
be set in the file .login to prevent acciden-
tal destruction of files by the `>' output
redirection metasyntax of the shell (2.2,
2.5).
noglob The shell variable noglob is set to suppress
the filename expansion of arguments contain-
ing the metacharacters `~', `*', `?', `[' and
`]' (3.6).
notify The notify command tells the shell to report
on the termination of a specific background
job at the exact time it occurs as opposed to
waiting until just before the next prompt to
report the termination. The notify variable,
if set, causes the shell to always report the
termination of background jobs exactly when
they occur (2.6).
onintr The onintr command is built into the shell
May 30, 1993
- 14 -
and is used to control the action of a shell
command script when an interrupt signal is
received (3.9).
output Many commands in UNIX result in some lines of
text which are called their output. This
output is usually placed on what is known as
the standard output which is normally con-
nected to the user's terminal. The shell has
a syntax using the metacharacter `>' for
redirecting the standard output of a command
to a file (1.3). Using the pipe mechanism
and the metacharacter `|' it is also possible
for the standard output of one command to
become the standard input of another command
(1.5). Certain commands such as the line
printer daemon p do not place their results
on the standard output but rather in more
useful places such as on the line printer
(2.3). Similarly the write command places
its output on another user's terminal rather
than its standard output (2.3). Commands
also have a diagnostic output where they
write their error messages. Normally these
go to the terminal even if the standard out-
put has been sent to a file or another com-
mand, but it is possible to direct error
diagnostics along with standard output using
a special metanotation (2.5).
pushd The pushd command, which means `push direc-
tory', changes the shell's working directory
and also remembers the current working direc-
tory before the change is made, allowing you
to return to the same directory via the popd
command later without retyping its name
(2.7).
path The shell has a variable path which gives the
names of the directories in which it searches
for the commands which it is given. It
always checks first to see if the command it
is given is built into the shell. If it is,
then it need not search for the command as it
can do it internally. If the command is not
builtin, then the shell searches for a file
with the name given in each of the direc-
tories in the path variable, left to right.
Since the normal definition of the path vari-
able is
path (. /usr/ucb /bin /usr/bin)
the shell normally looks in the current
May 30, 1993
- 15 -
directory, and then in the standard system
directories `/usr/ucb', `/bin' and `/usr/bin'
for the named command (2.2). If the command
cannot be found the shell will print an error
diagnostic. Scripts of shell commands will
be executed using another shell to interpret
them if they have `execute' permission set.
This is normally true because a command of
the form
chmod 755 script
was executed to turn this execute permission
on (3.3). If you add new commands to a
directory in the path, you should issue the
command rehash (2.2).
pathname A list of names, separated by `/' characters,
forms a pathname. Each component, between
successive `/' characters, names a directory
in which the next component file resides.
Pathnames which begin with the character `/'
are interpreted relative to the root direc-
tory in the filesystem. Other pathnames are
interpreted relative to the current directory
as reported by pwd. The last component of a
pathname may name a directory, but usually
names a file.
pipeline A group of commands which are connected
together, the standard output of each con-
nected to the standard input of the next, is
called a pipeline. The pipe mechanism used
to connect these commands is indicated by the
shell metacharacter `|' (1.5, 2.3).
popd The popd command changes the shell's working
directory to the directory you most recently
left using the pushd command. It returns to
the directory without having to type its
name, forgetting the name of the current
working directory before doing so (2.7).
port The part of a computer system to which each
terminal is connected is called a port. Usu-
ally the system has a fixed number of ports,
some of which are connected to telephone
lines for dial-up access, and some of which
are permanently wired directly to specific
terminals.
pr The pr command is used to prepare listings of
the contents of files with headers giving the
name of the file and the date and time at
May 30, 1993
- 16 -
which the file was last modified (2.3).
printenv The printenv command is used to print the
current setting of variables in the environ-
ment (2.8).
process An instance of a running program is called a
process (2.6). UNIX assigns each process a
unique number when it is started - called the
process number. Process numbers can be used
to stop individual processes using the kill
or stop commands when the processes are part
of a detached background job.
program Usually synonymous with command; a binary
file or shell command script which performs a
useful function is often called a program.
programmer's manuals manual'u>(360u+1n) .br
Also referred to as the manual. See the
glossary entry for `manual'.
prompt Many programs will print a prompt on the ter-
minal when they expect input. Thus the edi-
tor `ex(1)' will print a `:' when it expects
input. The shell prompts for input with `% '
and occasionally with `? ' when reading com-
mands from the terminal (1.1). The shell has
a variable prompt which may be set to a dif-
ferent value to change the shell's main
prompt. This is mostly used when debugging
the shell (2.8).
ps The ps command is used to show the processes
you are currently running. Each process is
shown with its unique process number, an
indication of the terminal name it is
attached to, an indication of the state of
the process (whether it is running, stopped,
awaiting some event (sleeping), and whether
it is swapped out), and the amount of CPU
time it has used so far. The command is
identified by printing some of the words used
when it was invoked (2.6). Shells, such as
the csh you use to run the ps command, are
not normally shown in the output.
pwd The pwd command prints the full pathname of
the current working directory. The dirs
builtin command is usually a better and fas-
ter choice.
quit The quit signal, generated by a control-\, is
used to terminate programs which are behaving
May 30, 1993
- 17 -
unreasonably. It normally produces a core
image file (1.8).
quotation The process by which metacharacters are
prevented their special meaning, usually by
using the character `' in pairs, or by using
the character `\', is referred to as quota-
tion (1.7).
redirection The routing of input or output from or to a
file is known as redirection of input or out-
put (1.3).
rehash The rehash command tells the shell to rebuild
its internal table of which commands are
found in which directories in your path.
This is necessary when a new program is
installed in one of these directories (2.8).
relative pathname
A pathname which does not begin with a `/' is
called a relative pathname since it is inter-
preted relative to the current working direc-
tory. The first component of such a pathname
refers to some file or directory in the work-
ing directory, and subsequent components
between `/' characters refer to directories
below the working directory. Pathnames that
are not relative are called absolute path-
names (1.6).
repeat The repeat command iterates another command a
specified number of times.
root The directory that is at the top of the
entire directory structure is called the root
directory since it is the `root' of the
entire tree structure of directories. The
name used in pathnames to indicate the root
is `/'. Pathnames starting with `/' are said
to be absolute since they start at the root
directory. Root is also used as the part of
a pathname that is left after removing the
extension. See filename for a further expla-
nation (1.6).
RUBOUT The RUBOUT or DELETE key sends an interrupt
to the current job. Most interactive com-
mands return to their command level upon
receipt of an interrupt, while non-
interactive commands usually terminate,
returning control to the shell. Users often
change interrupt to be generated by |C rather
than DELETE by using the stty command.
May 30, 1993
- 18 -
scratch file Files whose names begin with a `#' are
referred to as scratch files, since they are
automatically removed by the system after a
couple of days of non-use, or more frequently
if disk space becomes tight (1.3).
script Sequences of shell commands placed in a file
are called shell command scripts. It is
often possible to perform simple tasks using
these scripts without writing a program in a
language such as C, by using the shell to
selectively run other programs (3.3, 3.10).
set The builtin set command is used to assign new
values to shell variables and to show the
values of the current variables. Many shell
variables have special meaning to the shell
itself. Thus by using the set command the
behavior of the shell can be affected (2.1).
setenv Variables in the environment `environ(5)' can
be changed by using the setenv builtin com-
mand (2.8). The printenv command can be used
to print the value of the variables in the
environment.
shell A shell is a command language interpreter.
It is possible to write and run your own
shell, as shells are no different than any
other programs as far as the system is con-
cerned. This manual deals with the details
of one particular shell, called csh.
shell script See script (3.3, 3.10).
signal A signal in UNIX is a short message that is
sent to a running program which causes some-
thing to happen to that process. Signals are
sent either by typing special control charac-
ters on the keyboard or by using the kill or
stop commands (1.8, 2.6).
sort The sort program sorts a sequence of lines in
ways that can be controlled by argument flags
(1.5).
source The source command causes the shell to read
commands from a specified file. It is most
useful for reading files such as .cshrc after
changing them (2.8).
special character
See metacharacters and the appendix to this
manual.
May 30, 1993
- 19 -
standard We refer often to the standard input and
standard output of commands. See input and
output (1.3, 3.8).
status A command normally returns a status when it
finishes. By convention a status of zero
indicates that the command succeeded. Com-
mands may return non-zero status to indicate
that some abnormal event has occurred. The
shell variable status is set to the status
returned by the last command. It is most
useful in shell commmand scripts (3.6).
stop The stop command causes a background job to
become suspended (2.6).
string A sequential group of characters taken
together is called a string. Strings can
contain any printable characters (2.2).
stty The stty program changes certain parameters
inside UNIX which determine how your terminal
is handled. See `stty(1)' for a complete
description (2.6).
substitution The shell implements a number of substitu-
tions where sequences indicated by metachar-
acters are replaced by other sequences. Not-
able examples of this are history substitu-
tion keyed by the metacharacter `!' and vari-
able substitution indicated by `$'. We also
refer to substitutions as expansions (3.4).
suspended A job becomes suspended after a STOP signal
is sent to it, either by typing a control-z
at the terminal (for foreground jobs) or by
using the stop command (for background jobs).
When suspended, a job temporarily stops run-
ning until it is restarted by either the fg
or bg command (2.6).
switch The switch command of the shell allows the
shell to select one of a number of sequences
of commands based on an argument string. It
is similar to the switch statement in the
language C (3.7).
termination When a command which is being executed fin-
ishes we say it undergoes termination or ter-
minates. Commands normally terminate when
they read an end-of-file from their standard
input. It is also possible to terminate com-
mands by sending them an interrupt or quit
signal (1.8). The kill program terminates
May 30, 1993
- 20 -
specified jobs (2.6).
then The then command is part of the shell's `if-
then-else-endif' control construct used in
command scripts (3.6).
time The time command can be used to measure the
amount of CPU and real time consumed by a
specified command as well as the amount of
disk i/o, memory utilized, and number of page
faults and swaps taken by the command (2.1,
2.8).
tset The tset program is used to set standard
erase and kill characters and to tell the
system what kind of terminal you are using.
It is often invoked in a .login file (2.1).
tty The word tty is a historical abbreviation for
`teletype' which is frequently used in UNIX
to indicate the port to which a given termi-
nal is connected. The tty command will print
the name of the tty or port to which your
terminal is presently connected.
unalias The unalias command removes aliases (2.8).
UNIX UNIX is an operating system on which csh
runs. UNIX provides facilities which allow
csh to invoke other programs such as editors
and text formatters which you may wish to
use.
unset The unset command removes the definitions of
shell variables (2.2, 2.8).
variable expansion
See variables and expansion (2.2, 3.4).
variables Variables in csh hold one or more strings as
value. The most common use of variables is
in controlling the behavior of the shell.
See path, noclobber, and ignoreeof for exam-
ples. Variables such as argv are also used
in writing shell programs (shell command
scripts) (2.2).
verbose The verbose shell variable can be set to
cause commands to be echoed after they are
history expanded. This is often useful in
debugging shell scripts. The verbose vari-
able is set by the shell's -v command line
option (3.10).
May 30, 1993
- 21 -
wc The wc program calculates the number of char-
acters, words, and lines in the files whose
names are given as arguments (2.6).
while The while builtin control construct is used
in shell command scripts (3.7).
word A sequence of characters which forms an argu-
ment to a command is called a word. Many
characters which are neither letters, digits,
`-', `.' nor `/' form words all by themselves
even if they are not surrounded by blanks.
Any sequence of characters may be made into a
word by surrounding it with `'' characters
except for the characters `'' and `!' which
require special treatment (1.1). This pro-
cess of placing special characters in words
without their special meaning is called quot-
ing.
working directory
At any given time you are in one particular
directory, called your working directory.
This directory's name is printed by the pwd
command and the files listed by ls are the
ones in this directory. You can change work-
ing directories using chdir.
write The write command is used to communicate with
other users who are logged in to UNIX.
May 30, 1993