An Introduction to the C shell USD:4-1
An Introduction to the C shell
William Joy
(revised for 4.3BSD by Mark Seiden)
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 introduction 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
shell's 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.
Additional information includes an appendix list-
ing special characters of the shell and a glossary of
terms and commands introduced in this manual.
Introduction
A shell is a command language interpreter. Csh is the name
of one particular command interpreter on UNIX. The primary pur-
pose 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.
_________________________
UNIX is a trademark of AT&T Bell Laboratories.
USD:4-2 An Introduction to the C shell
In addition to this document, you will want to refer to a
copy of the UNIX User Reference Manual. The csh documentation in
section 1 of the manual provides a full description of all fea-
tures of the shell and is the definitive 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 glos-
sary.
Acknowledgements
Numerous people have provided good input about previous ver-
sions of csh and aided in its debugging and in the debugging 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 use-
ful 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 documenta-
tion to this introduction.
An Introduction to the C shell USD:4-3
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 pro-
grams 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 command 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 arguments
to the command itself when it is executed. In this case we spec-
ified also the argument bill which is interpreted 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 mes-
sage with a ^D which sent an end-of-file to the mail program.
(Here and throughout this document, the notation ``^x'' is to be
read ``control-x'' and represents the striking of the x key while
the control key is held down.) The mail program then echoed the
characters `EOT' and transmitted 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 command
input from our terminal. We typed a complete command `mail
bill'. The shell then executed the mail program with argument
bill and went dormant waiting for it to complete. The mail
USD:4-4 An Introduction to the C shell
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 execution 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 obe-
diently prompt you again whenever 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 the delete
key (equivalent to `^?') and the kill character is `^U'. Some
people prefer to make the erase character the backspace key
(equivalent to `^H'). You can make this be true by typing
tset -e
which tells the program tset to set the erase character to tset's
default setting for this character (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 direc-
tory. 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 inter-
esting options. Most other commands have either no options or
only one or two options. It is hard to remember options of com-
mands which are not used very frequently, so most UNIX utilities
perform only one or two functions rather than having a large num-
ber of hard to remember options.
1.3. Output to files
Commands that normally read input or write output on the
An Introduction to the C shell USD:4-5
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 metacharacter `>' 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 sec-
tion 2.2.
The system normally keeps files which you create with `>'
and all other files. Thus the default is for files to be perma-
nent. If you wish to create a file which will be removed auto-
matically, 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 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
_________________________
*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 char-
acter means that it seldom appears in a file name, and
allows this convention to be used for scratch 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.
USD:4-6 An Introduction to the C shell
1.4. Metacharacters in the shell
The shell has a large number of special characters (like
`>') which indicate special functions. We say that these nota-
tions have syntactic and semantic meaning to the shell. In gen-
eral, 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 `% '
(although we can type our input even before it prompts).
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 command
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
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 stan-
dard 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
An Introduction to the C shell USD:4-7
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 dis-
cover that there is not. Instead we can use a couple of simple
options of the sort command, combining 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 alphabetically,
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 connected together by
the shell and the standard output of each is run into the stan-
dard input of the next. The leftmost command in a pipeline will
normally take its standard input from the terminal and the right-
most will place its standard output on the terminal. Other exam-
ples of pipelines will be given later when we discuss the history
mechanism; one important use of pipes which is illustrated there
is in the 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 sep-
arated 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 path-
name
/etc/motd
specifies a file in the directory `etc' which is a subdirectory
of the root directory `/'. Within this directory the file named
is `motd' which stands for `message of the day'. A pathname that
USD:4-8 An Introduction to the C shell
begins with a slash is said to be an absolute pathname since it
is specified from the absolute top of the entire directory hier-
archy 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 descend-
ing 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 path-
name 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 charac-
ters and `.'s (periods). In fact, all printing characters 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 com-
mand, we could use the notation
prog.*
This expression 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 different
order than we listed them above. The echo command receives four
words as arguments, even though we only typed one word as as
An Introduction to the C shell USD:4-9
argument directly. The four words were generated by filename
expansion of the one input word.
Other notations for filename expansion are also available.
The character `?' matches any single character in a filename.
Thus
echo ? ?? ???
will echo a line of filenames; first those with one character
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 char-
acter 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
chap.[12345]
and otherwise equivalent.
An important point to note is that if a list of argument
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 considers 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 charac-
ter `.' at the beginning are treated specially. Neither `*' or
`?' or the `[' `]' mechanism will match it. This prevents acci-
dental matching of the filenames `.' and `..' in the working
directory which have special meaning to the system, as well as
USD:4-10 An Introduction to the C shell
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 user's
login name. For instance the word `~bill' would map to the path-
name `/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 dif-
ferent prefix directory names, this notation provides a conve-
nient 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 use-
ful 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 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 command
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 direc-
tory.
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.
An Introduction to the C shell USD:4-11
echo '*'
There is one special character `!' which is used by the history
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 special 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 com-
bined, as in
echo \''*'
which prints
'*
since the first `\' escaped the first `'' and the `*' was
enclosed between `'' characters.
1.8. Terminating commands
When you are executing a command and the shell is waiting
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 INTERRUPT signal to the cat
command by typing ^C on your terminal.* Since cat does not take
any precautions 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 execute com-
mands 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
_________________________
*On some older Unix systems the DEL or RUBOUT key has
the same effect. "stty all" will tell you the INTR key
value.
USD:4-12 An Introduction to the C shell
program in the first example above was terminated when we typed a
^D which generates an end-of-file from the standard input. The
shell also terminates when it gets an end-of-file printing
`logout'; UNIX then logs you off the system. 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 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 execu-
tion 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 sus-
pended. The shell notices that the command(s) have been sus-
pended, 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 exe-
cuted while the original command remains suspended. The sus-
pended 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 com-
mand 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.
An Introduction to the C shell USD:4-13
% mail harold
Someone just copied a big file into my directory and its name is
^Z
Stopped
% ls
funnyfile
prog.c
prog.o
% jobs
[1] + Stopped mail harold
% fg
mail harold
funnyfile. Do you know who did it?
EOT
%
In this example someone was sending a message to Harold and for-
got the name of the file he wanted to mention. The mail command
was suspended by typing ^Z. When the shell noticed that the mail
program was suspended, it typed `Stopped' and prompted for a new
command. Then the ls command was typed to find out the name of
the file. The jobs command was run to find out which command was
suspended. At this time the fg command was typed to continue exe-
cution of the mail program. Input to the mail program was then
continued and ended with a ^D which indicated the end of the mes-
sage at which time the mail program typed EOT. The jobs command
will show which commands are suspended. The ^Z should only be
typed at the beginning of a line since everything typed on the
current line is discarded when a signal is sent from the key-
board. This also happens on INTERRUPT, and QUIT signals. More
information on suspending jobs and controlling them is given in
section 2.6.
If you write or run programs which are not fully debugged
then it may be necessary to stop them somewhat ungracefully.
This can be done by sending them a QUIT signal, sent by typing a
^\. This will usually provoke the shell to produce a message
like:
Quit (Core dumped)
indicating that a file `core' has been created containing infor-
mation about the running program's state when it terminated due
to the QUIT signal. You can examine this file yourself, or for-
ward information to the maintainer of the program telling him/her
where the core file is.
If you run background commands (as explained in section 2.6)
then these commands will ignore INTERRUPT and QUIT signals at the
terminal. To stop them you must use the kill command. See sec-
tion 2.6 for an example.
If you want to examine the output of a command without
USD:4-14 An Introduction to the C shell
having it move off the screen as the output of the
cat /etc/passwd
command will, you can use the command
more /etc/passwd
The more program pauses after each complete screenful and types
`--More--' at which point you can hit a space to get another
screenful, a return to get another line, a `?' to get some help
on other commands, or a `q' to end the more program. You can
also use more as a filter, i.e.
cat /etc/passwd | more
works just like the more simple more command above.
For stopping output of commands not involving more you can
use the ^S key to stop the typeout. The typeout will resume when
you hit ^Q or any other key, but ^Q is normally used because it
only restarts the output and does not become input to the program
which is running. This works well on low-speed terminals, but at
9600 baud it is hard to type ^S and ^Q fast enough to paginate
the output nicely, and a program like more is usually used.
An additional possibility is to use the ^O flush output
character; when this character is typed, all output from the cur-
rent command is thrown away (quickly) until the next input read
occurs or until the next shell prompt. This can be used to allow
a command to complete without having to suffer through the output
on a slow terminal; ^O is a toggle, so flushing can be turned off
by typing ^O again while output is being flushed.
1.9. What now?
We have so far seen a number of mechanisms of the shell and
learned a lot about the way in which it operates. The remaining
sections will go yet further into the internals of the shell, but
you will surely want to try using the shell before you go any
further. To try it you can log in to UNIX and type the following
command to the system:
chsh myname /bin/csh
Here `myname' should be replaced by the name you typed to the
system prompt of `login:' to get onto the system. Thus I would
use `chsh bill /bin/csh'. You only have to do this once; it
takes effect at next login. You are now ready to try using csh.
Before you do the `chsh' command, the shell you are using
when you log into the system is `/bin/sh'. In fact, much of the
above discussion is applicable to `/bin/sh'. The next section
will introduce many features particular to csh so you should
An Introduction to the C shell USD:4-15
change your shell to csh before you begin reading it.
USD:4-16 An Introduction to the C shell
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 inter-
preted directly by the shell. It sets the shell variable
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 immedi-
ately 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 remem-
ber the last 10 commands I type in its history list, (described
later).
An Introduction to the C shell USD:4-17
I create an alias ``ts'' which executes a tset(1) command
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 com-
mand 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 commands from
the terminal, prompting for each with `% '. When I log off (by
giving the logout command) the shell will print `logout' and exe-
cute 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 message. 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 com-
mand. 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 mechanism. The
shell variables most commonly referenced are, however, 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
USD:4-18 An Introduction to the C shell
% set
argv ()
cwd /usr/bill
home /usr/bill
path (. /usr/ucb /bin /usr/bin)
prompt %
shell /bin/csh
status 0
term c100rv4pna
user bill
%
This output indicates that the variable path points to the cur-
rent directory `.' and then `/usr/ucb', `/bin' and `/usr/bin'.
Commands which you may write might be in `.' (usually one of your
directories). Commands developed at Berkeley, live in `/usr/ucb'
while commands developed at Bell Laboratories live in `/bin' and
`/usr/bin'.
A number of locally developed programs on the system live in
the directory `/usr/local'. If we wish that all shells which we
invoke to have access to these new programs we can place the com-
mand
set path=(. /usr/ucb /bin /usr/bin /usr/local)
in our file .cshrc in our home directory. Try doing this and
then logging out and back in and do
set
again to see that the value assigned to path has changed.
One thing you should be aware of is that the shell examines
each directory which you insert into your path and determines
which commands are contained there. Except for the current
directory `.', which the shell treats specially, this means that
if commands are added to a directory in your search path after
you have started the shell, they will not necessarily be found by
the shell. If you wish to use a command which has been added in
this way, you should give the command
rehash
to the shell, which will cause it to recompute its internal table
of command locations, so that it will find the newly added com-
mand. Since the shell has to look in the current directory `.'
on each command, placing it at the end of the path specification
_________________________
Another directory that might interest you is
/usr/new, which contains many useful user-contributed
programs provided with Berkeley Unix.
An Introduction to the C shell USD:4-19
usually works equivalently and reduces overhead.
Other useful built in variables are the variable home which
shows your home directory, cwd which contains your current work-
ing directory, the variable ignoreeof which can be set in your
.login file to tell the shell not to exit when it receives an
end-of-file from a terminal (as described above). The variable
`ignoreeof' is one of several variables which the shell does not
care about the value of, only whether they are set or unset.
Thus to set this variable you simply do
set ignoreeof
and to unset it do
unset ignoreeof
These give the variable `ignoreeof' no value, but none is desired
or required.
Finally, some other built-in shell variables of use are the
variables noclobber and mail. The metasyntax
> filename
which redirects the standard output of a command will overwrite
and destroy the previous contents of the named file. In this way
you may accidentally overwrite a file which is valuable. If you
would prefer that the shell not overwrite files in this way you
can
set noclobber
in your .login file. Then trying to do
date > now
would cause a diagnostic if `now' existed already. You could
type
date >! now
if you really wanted to overwrite the contents of `now'. The
`>!' is a special metasyntax indicating that clobbering the file
is ok.
2.3. The shell's history list
The shell can maintain a history list into which it places
_________________________
The space between the `!' and the word `now' is criti-
cal here, as `!now' would be an invocation of the his-
tory mechanism, and have a totally different effect.
USD:4-20 An Introduction to the C shell
the words of previous commands. It is possible to use a notation
to reuse commands or words from commands in forming new commands.
This mechanism can be used to repeat previous commands or to cor-
rect minor typing mistakes in commands.
The following figure gives a sample session involving typi-
cal usage of the history mechanism of the shell. In this example
we have a very simple C program which has a bug (or two) in it in
the file `bug.c', which we `cat' out on our terminal. We then
try to run the C compiler on it, referring to the file again as
`!$', meaning the last argument to the previous command. Here
the `!' is the history mechanism invocation metacharacter, and
the `$' stands for the last argument, by analogy to `$' in the
editor which stands for the end of the line. The shell echoed
the command, as it would have been typed without use of the his-
tory mechanism, and then executed it. The compilation yielded
error diagnostics so we now run the editor on the file we were
trying to compile, fix the bug, and run the C compiler again,
this time referring to this command simply as `!c', which repeats
the last command which started with the letter `c'. If there
were other commands starting with `c' done recently we could have
said `!cc' or even `!cc:p' which would have printed the last com-
mand starting with `cc' without executing it.
After this recompilation, we ran the resulting `a.out' file,
and then noting that there still was a bug, ran the editor again.
After fixing the program we ran the C compiler again, but tacked
onto the command an extra `-o bug' telling the compiler to place
the resultant binary in the file `bug' rather than `a.out'. In
general, the history mechanisms may be used anywhere in the for-
mation of new commands and other characters may be placed before
and after the substituted commands.
We then ran the `size' command to see how large the binary
program images we have created were, and then an `ls -l' command
with the same argument list, denoting the argument list `*'.
Finally we ran the program `bug' to see that its output is indeed
correct.
To make a numbered listing of the program we ran the `num'
command on the file `bug.c'. In order to compress out blank
lines in the output of `num' we ran the output through the filter
`ssp', but misspelled it as spp. To correct this we used a shell
substitute, placing the old text and new text between `^' charac-
ters. This is similar to the substitute command in the editor.
Finally, we repeated the same command with `!!', but sent its
output to the line printer.
There are other mechanisms available for repeating commands.
The history command prints out a number of previous commands with
numbers by which they can be referenced. There is a way to refer
to a previous command by searching for a string which appeared in
it, and there are other, less useful, ways to select arguments to
include in a new command. A complete description of all these
An Introduction to the C shell USD:4-21
% cat bug.c
main()
{
printf("hello);
}
% cc !$
cc bug.c
"bug.c", line 4: newline in string or char constant
"bug.c", line 5: syntax error
% ed !$
ed bug.c
29
4s/);/"&/p
printf("hello");
w
30
q
% !c
cc bug.c
% a.out
hello% !e
ed bug.c
30
4s/lo/lo\\n/p
printf("hello\n");
w
32
q
% !c -o bug
cc bug.c -o bug
% size a.out bug
a.out: 2784+364+1028 = 4176b = 0x1050b
bug: 2784+364+1028 = 4176b = 0x1050b
% ls -l !*
ls -l a.out bug
-rwxr-xr-x 1 bill 3932 Dec 19 09:41 a.out
-rwxr-xr-x 1 bill 3932 Dec 19 09:42 bug
% bug
hello
% num bug.c | spp
spp: Command not found.
% ^spp^ssp
num bug.c | ssp
1 main()
3 {
4 printf("hello\n");
5 }
% !! | lpr
num bug.c | ssp | lpr
%
USD:4-22 An Introduction to the C shell
mechanisms is given in the C shell manual pages in the UNIX Pro-
grammer's Manual.
2.4. Aliases
The shell has an alias mechanism which can be used to make
transformations on input commands. This mechanism can be used to
simplify the commands you type, to supply default arguments to
commands, or to perform transformations on commands and their
arguments. The alias facility is similar to a macro facility.
Some of the features obtained by aliasing can be obtained also
using shell command files, but these take place in another
instance of the shell and cannot directly affect the current
shells environment or involve commands such as cd which must be
done in the current shell.
As an example, suppose that there is a new version of the
mail program on the system called `newmail' you wish to use,
rather than the standard mail program which is called `mail'. If
you place the shell command
alias mail newmail
in your .cshrc file, the shell will transform an input line of
the form
mail bill
into a call on `newmail'. More generally, suppose we wish the
command `ls' to always show sizes of files, that is to always do
`-s'. We can do
alias ls ls -s
or even
alias dir ls -s
creating a new command syntax `dir' which does an `ls -s'. If we
say
dir ~bill
then the shell will translate this to
ls -s /mnt/bill
Thus the alias mechanism can be used to provide short names
for commands, to provide default arguments, and to define new
short commands in terms of other commands. It is also possible
to define aliases which contain multiple commands or pipelines,
showing where the arguments to the original command are to be
substituted using the facilities of the history mechanism. Thus
An Introduction to the C shell USD:4-23
the definition
alias cd 'cd \!* ; ls '
would do an ls command after each change directory cd command.
We enclosed the entire alias definition in `'' characters to pre-
vent most substitutions from occurring and the character `;' from
being recognized as a metacharacter. The `!' here is escaped
with a `\' to prevent it from being interpreted when the alias
command is typed in. The `\!*' here substitutes the entire argu-
ment list to the pre-aliasing cd command, without giving an error
if there were no arguments. The `;' separating commands is used
here to indicate that one command is to be done and then the
next. Similarly the definition
alias whois 'grep \!^ /etc/passwd'
defines a command which looks up its first argument in the pass-
word file.
Warning: The shell currently reads the .cshrc file each time
it starts up. If you place a large number of commands there,
shells will tend to start slowly. A mechanism for saving the
shell environment after reading the .cshrc file and quickly
restoring it is under development, but for now you should try to
limit the number of aliases you have to a reasonable number... 10
or 15 is reasonable, 50 or 60 will cause a noticeable delay in
starting up shells, and make the system seem sluggish when you
execute commands from within the editor and other programs.
2.5. More redirection; >> and >&
There are a few more notations useful to the terminal user
which have not been introduced yet.
In addition to the standard output, commands also have a
diagnostic output which is normally directed to the terminal even
when the standard output is redirected to a file or a pipe. It
is occasionally desirable to direct the diagnostic output along
with the standard output. For instance if you want to redirect
the output of a long running command into a file and wish to have
a record of any error diagnostic it produces you can do
command >& file
The `>&' here tells the shell to route both the diagnostic output
and the standard output into `file'. Similarly you can give the
command
command |& lpr
to route both standard and diagnostic output through the pipe to
the line printer daemon lpr.
_________________________
USD:4-24 An Introduction to the C shell
Finally, it is possible to use the form
command >> file
to place output at the end of an existing file.
2.6. Jobs; Background, Foreground, or Suspended
When one or more commands are typed together as a pipeline
or as a sequence of commands separated by semicolons, a single
job is created by the shell consisting of these commands together
as a unit. Single commands without pipes or semicolons create
the simplest jobs. Usually, every line typed to the shell cre-
ates a job. Some lines that create jobs (one per line) are
sort < data
ls -s | sort -n | head -5
mail harold
If the metacharacter `&' is typed at the end of the com-
mands, then the job is started as a background job. This means
that the shell does not wait for it to complete but immediately
prompts and is ready for another command. The job runs in the
background at the same time that normal jobs, called foreground
jobs, continue to be read and executed by the shell one at a
time. Thus
du > usage &
would run the du program, which reports on the disk usage of your
working directory (as well as any directories below it), put the
output into the file `usage' and return immediately with a prompt
for the next command without out waiting for du to finish. The
du program would continue executing in the background until it
finished, even though you can type and execute more commands in
the mean time. When a background job terminates, a message is
typed by the shell just before the next prompt telling you that
the job has completed. In the following example the du job fin-
ishes sometime during the execution of the mail command and its
completion is reported just before the prompt after the mail job
is finished.
_________________________
A command of the form
command >&! file
exists, and is used when noclobber is set and file al-
ready exists.
If noclobber is set, then an error will result if file
does not exist, otherwise the shell will create file if
it doesn't exist. A form
command >>! file
makes it not be an error for file to not exist when no-
clobber is set.
An Introduction to the C shell USD:4-25
% du > usage &
[1] 503
% mail bill
How do you know when a background job is finished?
EOT
[1] - Done du > usage
%
If the job did not terminate normally the `Done' message might
say something else like `Killed'. If you want the terminations
of background jobs to be reported at the time they occur (possi-
bly interrupting the output of other foreground jobs), you can
set the notify variable. In the previous example this would mean
that the `Done' message might have come right in the middle of
the message to Bill. Background jobs are unaffected by any sig-
nals from the keyboard like the STOP, INTERRUPT, or QUIT signals
mentioned earlier.
Jobs are recorded in a table inside the shell until they
terminate. In this table, the shell remembers the command names,
arguments and the process numbers of all commands in the job as
well as the working directory where the job was started. Each
job in the table is either running in the foreground with the
shell waiting for it to terminate, running in the background, or
suspended. Only one job can be running in the foreground at one
time, but several jobs can be suspended or running in the back-
ground at once. As each job is started, it is assigned a small
identifying number called the job number which can be used later
to refer to the job in the commands described below. Job numbers
remain the same until the job terminates and then are re-used.
When a job is started in the backgound using `&', its num-
ber, as well as the process numbers of all its (top level) com-
mands, is typed by the shell before prompting you for another
command. For example,
% ls -s | sort -n > usage &
[2] 2034 2035
%
runs the `ls' program with the `-s' options, pipes this output
into the `sort' program with the `-n' option which puts its out-
put into the file `usage'. Since the `&' was at the end of the
line, these two programs were started together as a background
job. After starting the job, the shell prints the job number in
brackets (2 in this case) followed by the process number of each
program started in the job. Then the shell immediates prompts
for a new command, leaving the job running simultaneously.
As mentioned in section 1.8, foreground jobs become sus-
pended by typing ^Z which sends a STOP signal to the currently
running foreground job. A background job can become suspended by
using the stop command described below. When jobs are suspended
USD:4-26 An Introduction to the C shell
they merely stop any further progress until started again, either
in the foreground or the backgound. The shell notices when a job
becomes stopped and reports this fact, much like it reports the
termination of background jobs. For foreground jobs this looks
like
% du > usage
^Z
Stopped
%
`Stopped' message is typed by the shell when it notices that the
du program stopped. For background jobs, using the stop command,
it is
% sort usage &
[1] 2345
% stop %1
[1] + Stopped (signal)sort usage
%
Suspending foreground jobs can be very useful when you need to
temporarily change what you are doing (execute other commands)
and then return to the suspended job. Also, foreground jobs can
be suspended and then continued as background jobs using the bg
command, allowing you to continue other work and stop waiting for
the foreground job to finish. Thus
% du > usage
^Z
Stopped
% bg
[1] du > usage &
%
starts `du' in the foreground, stops it before it finishes, then
continues it in the background allowing more foreground commands
to be executed. This is especially helpful when a foreground job
ends up taking longer than you expected and you wish you had
started it in the backgound in the beginning.
All job control commands can take an argument that identi-
fies a particular job. All job name arguments begin with the
character `%', since some of the job control commands also accept
process numbers (printed by the ps command.) The default job
(when no argument is given) is called the current job and is
identified by a `+' in the output of the jobs command, which
shows you which jobs you have. When only one job is stopped or
running in the background (the usual case) it is always the cur-
rent job thus no argument is needed. If a job is stopped while
running in the foreground it becomes the current job and the
existing current job becomes the previous job - identified by a
`-' in the output of jobs. When the current job terminates, the
previous job becomes the current job. When given, the argument
An Introduction to the C shell USD:4-27
is either `%-' (indicating the previous job); `%#', where # is
the job number; `%pref' where pref is some unique prefix of the
command name and arguments of one of the jobs; or `%?' followed
by some string found in only one of the jobs.
The jobs command types the table of jobs, giving the job
number, commands and status (`Stopped' or `Running') of each
backgound or suspended job. With the `-l' option the process
numbers are also typed.
% du > usage &
[1] 3398
% ls -s | sort -n > myfile &
[2] 3405
% mail bill
^Z
Stopped
% jobs
[1] - Running du > usage
[2] Running ls -s | sort -n > myfile
[3] + Stopped mail bill
% fg %ls
ls -s | sort -n > myfile
% more myfile
The fg command runs a suspended or background job in the
foreground. It is used to restart a previously suspended job or
change a background job to run in the foreground (allowing sig-
nals or input from the terminal). In the above example we used
fg to change the `ls' job from the background to the foreground
since we wanted to wait for it to finish before looking at its
output file. The bg command runs a suspended job in the back-
ground. It is usually used after stopping the currently running
foreground job with the STOP signal. The combination of the STOP
signal and the bg command changes a foreground job into a back-
ground job. The stop command suspends a background job.
The kill command terminates a background or suspended job
immediately. In addition to jobs, it may be given process num-
bers as arguments, as printed by ps. Thus, in the example above,
the running du command could have been terminated by the command
% kill %1
[1] Terminated du > usage
%
The notify command (not the variable mentioned earlier)
indicates that the termination of a specific job should be
reported at the time it finishes instead of waiting for the next
prompt.
If a job running in the background tries to read input from
USD:4-28 An Introduction to the C shell
the terminal it is automatically stopped. When such a job is
then run in the foreground, input can be given to the job. If
desired, the job can be run in the background again until it
requests input again. This is illustrated in the following
sequence where the `s' command in the text editor might take a
long time.
% ed bigfile
120000
1,$s/thisword/thatword/
^Z
Stopped
% bg
[1] ed bigfile &
%
. . . some foreground commands
[1] Stopped (tty input)ed bigfile
% fg
ed bigfile
w
120000
q
%
So after the `s' command was issued, the `ed' job was stopped
with ^Z and then put in the background using bg. Some time later
when the `s' command was finished, ed tried to read another com-
mand and was stopped because jobs in the backgound cannot read
from the terminal. The fg command returned the `ed' job to the
foreground where it could once again accept commands from the
terminal.
The command
stty tostop
causes all background jobs run on your terminal to stop when they
are about to write output to the terminal. This prevents mes-
sages from background jobs from interrupting foreground job out-
put and allows you to run a job in the background without losing
terminal output. It also can be used for interactive programs
that sometimes have long periods without interaction. Thus each
time it outputs a prompt for more input it will stop before the
prompt. It can then be run in the foreground using fg, more
input can be given and, if necessary stopped and returned to the
background. This stty command might be a good thing to put in
your .login file if you do not like output from background jobs
interrupting your work. It also can reduce the need for redi-
recting the output of background jobs if the output is not very
big:
An Introduction to the C shell USD:4-29
% stty tostop
% wc hugefile &
[1] 10387
% ed text
. . . some time later
q
[1] Stopped (tty output)wc hugefile
% fg wc
wc hugefile
13371 30123 302577
% stty -tostop
Thus after some time the `wc' command, which counts the lines,
words and characters in a file, had one line of output. When it
tried to write this to the terminal it stopped. By restarting it
in the foreground we allowed it to write on the terminal exactly
when we were ready to look at its output. Programs which attempt
to change the mode of the terminal will also block, whether or
not tostop is set, when they are not in the foreground, as it
would be very unpleasant to have a background job change the
state of the terminal.
Since the jobs command only prints jobs started in the cur-
rently executing shell, it knows nothing about background jobs
started in other login sessions or within shell files. The ps
can be used in this case to find out about background jobs not
started in the current shell.
2.7. Working Directories
As mentioned in section 1.6, the shell is always in a par-
ticular working directory. The `change directory' command chdir
(its short form cd may also be used) changes the working direc-
tory of the shell, that is, changes the directory you are located
in.
It is useful to make a directory for each project you wish
to work on and to place all files related to that project in that
directory. The `make directory' command, mkdir, creates a new
directory. The pwd (`print working directory') command reports
the absolute pathname of the working directory of the shell, that
is, the directory you are located in. Thus in the example below:
% pwd
/usr/bill
% mkdir newpaper
% chdir newpaper
% pwd
/usr/bill/newpaper
%
the user has created and moved to the directory newpaper. where,
for example, he might place a group of related files.
USD:4-30 An Introduction to the C shell
No matter where you have moved to in a directory hierarchy,
you can return to your `home' login directory by doing just
cd
with no arguments. The name `..' always means the directory
above the current one in the hierarchy, thus
cd ..
changes the shell's working directory to the one directly above
the current one. The name `..' can be used in any pathname,
thus,
cd ../programs
means change to the directory `programs' contained in the direc-
tory above the current one. If you have several directories for
different projects under, say, your home directory, this short-
hand notation permits you to switch easily between them.
The shell always remembers the pathname of its current work-
ing directory in the variable cwd. The shell can also be
requested to remember the previous directory when you change to a
new working directory. If the `push directory' command pushd is
used in place of the cd command, the shell saves the name of the
current working directory on a directory stack before changing to
the new one. You can see this list at any time by typing the
`directories' command dirs.
% pushd newpaper/references
~/newpaper/references ~
% pushd /usr/lib/tmac
/usr/lib/tmac ~/newpaper/references ~
% dirs
/usr/lib/tmac ~/newpaper/references ~
% popd
~/newpaper/references ~
% popd
~
%
The list is printed in a horizontal line, reading left to right,
with a tilde (~) as shorthand for your home directory--in this
case `/usr/bill'. The directory stack is printed whenever there
is more than one entry on it and it changes. It is also printed
by a dirs command. Dirs is usually faster and more informative
than pwd since it shows the current working directory as well as
any other directories remembered in the stack.
The pushd command with no argument alternates the current
directory with the first directory in the list. The `pop direc-
tory' popd command without an argument returns you to the direc-
tory you were in prior to the current one, discarding the
An Introduction to the C shell USD:4-31
previous current directory from the stack (forgetting it). Typ-
ing popd several times in a series takes you backward through the
directories you had been in (changed to) by pushd command. There
are other options to pushd and popd to manipulate the contents of
the directory stack and to change to directories not at the top
of the stack; see the csh manual page for details.
Since the shell remembers the working directory in which
each job was started, it warns you when you might be confused by
restarting a job in the foreground which has a different working
directory than the current working directory of the shell. Thus
if you start a background job, then change the shell's working
directory and then cause the background job to run in the fore-
ground, the shell warns you that the working directory of the
currently running foreground job is different from that of the
shell.
% dirs -l
/mnt/bill
% cd myproject
% dirs
~/myproject
% ed prog.c
1143
^Z
Stopped
% cd ..
% ls
myproject
textfile
% fg
ed prog.c (wd: ~/myproject)
This way the shell warns you when there is an implied change of
working directory, even though no cd command was issued. In the
above example the `ed' job was still in `/mnt/bill/project' even
though the shell had changed to `/mnt/bill'. A similar warning
is given when such a foreground job terminates or is suspended
(using the STOP signal) since the return to the shell again
implies a change of working directory.
% fg
ed prog.c (wd: ~/myproject)
. . . after some editing
q
(wd now: ~)
%
These messages are sometimes confusing if you use programs that
change their own working directories, since the shell only remem-
bers which directory a job is started in, and assumes it stays
there. The `-l' option of jobs will type the working directory
of suspended or background jobs when it is different from the
current working directory of the shell.
USD:4-32 An Introduction to the C shell
2.8. Useful built-in commands
We now give a few of the useful built-in commands of the
shell describing how they are used.
The alias command described above is used to assign new
aliases and to show the existing aliases. With no arguments it
prints the current aliases. It may also be given only one argu-
ment such as
alias ls
to show the current alias for, e.g., `ls'.
The echo command prints its arguments. It is often used in
shell scripts or as an interactive command to see what filename
expansions will produce.
The history command will show the contents of the history
list. The numbers given with the history events can be used to
reference previous events which are difficult to reference using
the contextual mechanisms introduced above. There is also a
shell variable called prompt. By placing a `!' character in its
value the shell will there substitute the number of the current
command in the history list. You can use this number to refer to
this command in a history substitution. Thus you could
set prompt='\! % '
Note that the `!' character had to be escaped here even within
`'' characters.
The limit command is used to restrict use of resources.
With no arguments it prints the current limitations:
cputime unlimited
filesize unlimited
datasize 5616 kbytes
stacksize 512 kbytes
coredumpsizeunlimited
Limits can be set, e.g.:
limit coredumpsize 128k
Most reasonable units abbreviations will work; see the csh manual
page for more details.
The logout command can be used to terminate a login shell
which has ignoreeof set.
The rehash command causes the shell to recompute a table of
where commands are located. This is necessary if you add a com-
mand to a directory in the current shell's search path and wish
An Introduction to the C shell USD:4-33
the shell to find it, since otherwise the hashing algorithm may
tell the shell that the command wasn't in that directory when the
hash table was computed.
The repeat command can be used to repeat a command several
times. Thus to make 5 copies of the file one in the file five
you could do
repeat 5 cat one >> five
The setenv command can be used to set variables in the envi-
ronment. Thus
setenv TERM adm3a
will set the value of the environment variable TERM to `adm3a'.
A user program printenv exists which will print out the environ-
ment. It might then show:
% printenv
HOME=/usr/bill
SHELL=/bin/csh
PATH=:/usr/ucb:/bin:/usr/bin:/usr/local
TERM=adm3a
USER=bill
%
The source command can be used to force the current shell to
read commands from a file. Thus
source .cshrc
can be used after editing in a change to the .cshrc file which
you wish to take effect right away.
The time command can be used to cause a command to be timed
no matter how much CPU time it takes. Thus
% time cp /etc/rc /usr/bill/rc
0.0u 0.1s 0:01 8% 2+1k 3+2io 1pf+0w
% time wc /etc/rc /usr/bill/rc
52 178 1347 /etc/rc
52 178 1347 /usr/bill/rc
104 356 2694 total
0.1u 0.1s 0:00 13% 3+3k 5+3io 7pf+0w
%
indicates that the cp command used a negligible amount of user
time (u) and about 1/10th of a system time (s); the elapsed time
was 1 second (0:01), there was an average memory usage of 2k
bytes of program space and 1k bytes of data space over the cpu
time involved (2+1k); the program did three disk reads and two
USD:4-34 An Introduction to the C shell
disk writes (3+2io), and took one page fault and was not swapped
(1pf+0w). The word count command wc on the other hand used 0.1
seconds of user time and 0.1 seconds of system time in less than
a second of elapsed time. The percentage `13%' indicates that
over the period when it was active the command `wc' used an aver-
age of 13 percent of the available CPU cycles of the machine.
The unalias and unset commands can be used to remove aliases
and variable definitions from the shell, and unsetenv removes
variables from the environment.
2.9. What else?
This concludes the basic discussion of the shell for termi-
nal users. There are more features of the shell to be discussed
here, and all features of the shell are discussed in its manual
pages. One useful feature which is discussed later is the fore-
ach built-in command which can be used to run the same command
sequence with a number of different arguments.
If you intend to use UNIX a lot you you should look through
the rest of this document and the csh manual pages (section1) to
become familiar with the other facilities which are available to
you.
An Introduction to the C shell USD:4-35
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 fea-
tures 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 performing sets of
operations on related files. For instance a large program con-
sisting of one or more files can have its dependencies described
in a makefile which contains definitions 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 cre-
ated 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 arguments. 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 mechanisms 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
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 convenience.
USD:4-36 An Introduction to the C shell
3.4. Variable substitution
After each input line is broken into words and history sub-
stitutions 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 char-
acter `$' 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 components
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 refer-
ence 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 variable
which has several values. Thus
$argv[1]
gives the first component of argv or in the example above `a'.
Similarly
$argv[$#argv]
An Introduction to the C shell USD:4-37
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 genera-
tion 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.
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 substituted. A range of
USD:4-38 An Introduction to the C shell
the form `m-n' likewise returns an empty vector without giving an
error when m exceeds the number of elements of the given vari-
able, provided the subscript n is in range.
3.5. Expressions
In order for interesting shell scripts to be constructed 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 prece-
dence that they have in C. In particular, the operations `=='
and `!=' compare strings and the operators `&&' and `||' imple-
ment 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
pattern 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 nor-
mally, by a primitive of the form `{ command }' which returns
true, i.e. `1' if the command succeeds exiting normally 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 imme-
diately following command.
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:
An Introduction to the C shell USD:4-39
% 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 val-
ues 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 expan-
sion 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 possible 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
if ( expression ) then
command
...
endif
The placement of the keywords here is not flexible due to the
current implementation of the shell.
_________________________
USD:4-40 An Introduction to the C 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 imme-
diately 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 `:'
modifier. We can use the modifier `:r' here to extract a root of
a filename or `:e' to extract the extension. Thus if the vari-
able 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
_________________________
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
An Introduction to the C shell USD:4-41
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 User's Reference Manual. It is also possible to use
the command substitution mechanism described in the next major
section to perform modifications on strings to then reenter the
shell's 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 argu-
ment word.
3.7. Other control structures
The shell also has control structures while and switch simi-
lar to those of C. These take the forms
while ( expression )
commands
end
and
switch ( word )
case str1:
commands
breaksw
...
case strn:
commands
breaksw
default:
commands
breaksw
endsw
_________________________
It is also important to note that the current imple-
mentation of the shell limits the number of `:' modi-
fiers on a `$' substitution to 1. Thus
% echo $i $i:h:t
/a/b/c /a/b:t
%
does not do what one would expect.
USD:4-42 An Introduction to the C shell
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 looking
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 stan-
dard 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:
% 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 substitution on the intervening
lines. In general, if any part of the word following the `<<'
which the shell uses to terminate 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.
An Introduction to the C shell USD:4-43
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 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 dis-
cussed to occur on the quoted string and serves to make this
string into a single word as `'' does.
USD:4-44 An Introduction to the C shell
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 struc-
ture 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 commands
% 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 file-
names 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 converted
by the shell to a list of words. You can also place the ``'
quoted string within `"' characters to take each (non-empty) line
as a component of the variable; preventing the lines from being
An Introduction to the C shell USD:4-45
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 embed-
ded 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 consecu-
tively 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 arguments which are not file-
names, 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 common 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 command.
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
USD:4-46 An Introduction to the C shell
4.4. Other details not covered here
In particular circumstances it may be necessary to know the
exact nature and order of different substitutions performed by
the shell. The exact meaning of certain combinations of quota-
tions 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 csh(1) manual section for a list of these options.
_________________________
`<<' and within `"' quotations. Refer to the shell
manual section for full details.
An Introduction to the C shell USD:4-47
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. Refer-
ences of the form `pr (1)' indicate that the command pr is in the
UNIX User Reference manual in section 1. You can look at 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 component
of a pathname is treated specially and not matched
by the filename expansion metacharacters `?', `*',
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 histori-
cal reasons (2.3).
absolute pathname
A pathname which begins with a `/' is absolute
since it specifies the path of directories from
the beginning of the entire directory system -
called the root directory. Pathnames which are
not absolute are called relative (see definition
of relative pathname) (1.6).
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 establishes aliases and can
USD:4-48 An Introduction to the C shell
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 argu-
ments 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 programming language (3.4).
background Commands started without waiting for them to com-
plete are called background commands (2.6).
base A filename is sometimes thought of as consisting
of a base part, before any `.' character, and an
extension - the part after the `.'. See filename
and extension (1.6) and basename (1).
bg The bg command causes a suspended job to continue
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 directo-
ries 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 directories 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 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
An Introduction to the C shell USD:4-49
because the directories 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, simi-
lar 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 directory (2.4,
2.7).
chdir The chdir command is a synonym for cd. Cd is usu-
ally 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 usu-
ally used on binary files, or to see if two files
are identical (3.6). For comparing text files the
program diff, described in `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, fol-
lowed by arguments. The convention on UNIX is
that the first word of a command names the func-
tion to be performed (1.1).
USD:4-50 An Introduction to the C shell
command substitution
The replacement of a command enclosed in ``' char-
acters 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 compo-
nent of the variable.
continue A builtin command which causes execution of the
enclosing foreach or while loop to cycle prema-
turely. Similar to the continue command in the
programming language C (3.6).
control- Certain special characters, called control charac-
ters, are produced by holding down the CONTROL key
on your terminal and simultaneously 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
caret (^) 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 pro-
gram (1.8). If the shell produces a message of
the form
Illegal instruction (core dumped)
(where `Illegal instruction' is only one of sev-
eral possible messages), you should report this to
the author of the program or a system administra-
tor, 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 commands (1.6).
csh The name of the shell program that this document
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).
An Introduction to the C shell USD:4-51
cwd The cwd variable in the shell holds the absolute
pathname of the current working directory. It is
changed by the shell whenever your current working
directory changes and should not be changed other-
wise (2.2).
date The date command prints the current date and time
(1.3).
debugging Debugging is the process of correcting mistakes 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 normally
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 background
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 standard output, since that
is often directed away from the terminal (1.3,
1.5). Error messsages are instead written to the
diagnostic output which may be directed away from
the terminal, but usually is not. Thus diagnos-
tics 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
directory (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 com-
mand. 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).
USD:4-52 An Introduction to the C shell
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 executed 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. Com-
mands receiving input from a pipe receive an end-
of-file when the command sending them input com-
pletes. 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 mean-
ing of a metacharacter is said to escape the char-
acter 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 termi-
nal keyboards. Some older UNIX systems use this
character to indicate that output is to be sus-
pended. 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 consists of a line
for each account with fields separated by `:'
characters (1.8). You can look at this file by
saying
cat /etc/passwd
An Introduction to the C shell USD:4-53
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 considered `normal termination'. The
exit command 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 expansion'. Expansions are also
referred to as substitutions (1.6, 3.4, 4.2).
expressions Expressions are used in the shell to control the
conditional structures used in the writing of
shell scripts and in calculating values for these
scripts. The operators available in shell expres-
sions are those of the language C (3.5).
extension Filenames often consist of a base name and an
extension separated by the character `.'. By con-
vention, groups of related files often share the
same root name. Thus if `prog.c' were a C pro-
gram, 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 back-
ground 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 character `/'
which is used in pathname building. Most file-
names do not begin with the character `.', and
contain only letters and digits with perhaps a `.'
separating the base portion of the filename from
an extension (1.6).
USD:4-54 An Introduction to the C shell
filename expansion
Filename expansion uses the metacharacters `*',
`?' and `[' and `]' to provide a convenient mecha-
nism 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'
directories 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
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 running in the fore-
ground. This is as opposed to background. Fore-
ground jobs can be stopped by signals from the
terminal caused by typing different control char-
acters 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 argu-
ment 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 edi-
tors `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
An Introduction to the C shell USD:4-55
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 path-
name 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 pathname 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 modifica-
tion to correct typing mistakes or to change the
meaning of the command. The shell has a history
list where these commands are kept, and a history
variable which controls 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 expan-
sion 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 variable if you wish in your
.login file and then use the command logout to
logout. This is useful if you sometimes acciden-
tally 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 nor-
mally read for input from their standard input
which is, by default, the terminal. This standard
input can be redirected from a file using a shell
metanotation with the character `<'. Many com-
mands will also read from a file specified as
argument. Commands placed in pipelines will read
USD:4-56 An Introduction to the C shell
from the output of the previous command in the
pipeline. The leftmost command in a pipeline
reads from the terminal if you neither redirect
its input nor give it a filename to use as stan-
dard input. Special mechanisms exist for supply-
ing input to commands in shell scripts (1.5, 3.8).
interrupt An interrupt is a signal to a program that is gen-
erated by typing ^C. (On older versions of UNIX
the RUBOUT or DELETE key were used for this pur-
pose.) It causes most programs to stop execution.
Certain 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 waiting for it to finish, the
shell does not listen to interrupts. The shell
often wakes up when you hit interrupt because many
commands 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 `;' charac-
ters are the simplest jobs. Jobs are classified
as foreground, background, or suspended (2.6).
job control The builtin functions that control the execution
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 sus-
pended (2.6).
kill A command which sends a signal to a job causing 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 com-
mands there are executed. There are a number of
commands which are usefully placed here, espe-
cially 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
An Introduction to the C shell USD:4-57
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 ter-
minal and it reads the .logout file after you
logout (2.1).
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 execute
commands from the file .logout in your home direc-
tory 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 arguments, 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 mes-
sages from other UNIX users (1.1, 2.1), whether
they are logged on or not.
make The make command is used to maintain one or more
related files and to organize functions to be per-
formed on these files. In many ways make is eas-
ier to use, and more helpful than shell command
scripts (3.2).
makefile The file containing commands for make is called
makefile or Makefile (3.2).
manual The manual often referred to is the `UNIX manual'.
It contains 8 numbered sections with a description
of each UNIX program (section 1), system call
(section 2), subroutine (section 3), device (sec-
tion 4), special data structure (section 5), game
(section 6), miscellaneous item (section 7) and
system administration program (section 8). There
are also supplementary documents (tutorials and
reference guides) for individual programs which
USD:4-58 An Introduction to the C shell
require explanation in more detail. An online
version of the manual is accessible through the
man command. Its documentation can be obtained
online via
man man
If you can't decide what manual page to look in,
try the apropos(1) command. The supplementary
documents are in subdirectories of /usr/doc.
metacharacter
Many characters which are neither letters nor dig-
its have special meaning either to the shell or to
UNIX. These characters are called metacharacters.
If it is necessary to place these characters in
arguments to commands without them having their
special meaning 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 mecha-
nism, most unquoted metacharacters form separate
words (1.4). The appendix to this user's manual
lists the metacharacters in groups by their func-
tion.
mkdir The mkdir command is used to create a new direc-
tory.
modifier Substitutions with the history mechanism, keyed by
the character `!' or of variables using the
metacharacter `$', are often subjected to modifi-
cations, indicated by placing the character `:'
after the substitution and following this with the
modifier itself. The command substitution mecha-
nism 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 terminal
allowing you to control how much text is displayed
at a time. More can move through the file screen-
ful 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 accidental
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 containing the
An Introduction to the C shell USD:4-59
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 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 connected 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 com-
mand to become the standard input of another com-
mand (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 output has been
sent to a file or another command, but it is pos-
sible to direct error diagnostics along with stan-
dard output using a special metanotation (2.5).
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 directories in the path variable, left to
right. Since the normal definition of the path
variable is
path (. /usr/ucb /bin /usr/bin)
the shell normally looks in the current directory,
and then in the standard system directories
`/usr/ucb', `/bin' and `/usr/bin' for the named
USD:4-60 An Introduction to the C shell
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 succes-
sive `/' characters, names a directory in which
the next component file resides. Pathnames which
begin with the character `/' are interpreted rela-
tive to the root directory 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 connected to the stan-
dard 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 direc-
tory 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 termi-
nal is connected is called a port. Usually 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 which the file
was last modified (2.3).
printenv The printenv command is used to print the current
setting of variables in the environment (2.8).
An Introduction to the C shell USD:4-61
process An instance of a running program is called a pro-
cess (2.6). UNIX assigns each process a unique
number when it is started - called the process
number. Process numbers can be used to stop indi-
vidual processes using the kill or stop commands
when the processes are part of a detached back-
ground job.
program Usually synonymous with command; a binary file or
shell command script which performs a useful func-
tion is often called a program.
prompt Many programs will print a prompt on the terminal
when they expect input. Thus the editor `ex (1)'
will print a `:' when it expects input. The shell
prompts for input with `% ' and occasionally with
`? ' when reading commands from the terminal
(1.1). The shell has a variable prompt which may
be set to a different value to change the shell's
main prompt. This is mostly used when debugging
the shell (2.8).
pushd The pushd command, which means `push directory',
changes the shell's working directory and also
remembers the current working directory before the
change is made, allowing you to return to the same
directory via the popd command later without
retyping its name (2.7).
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 identi-
fied 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 com-
mand is usually a better and faster choice.
quit The quit signal, generated by a control-\, is used
to terminate programs which are behaving unreason-
ably. It normally produces a core image file
(1.8).
quotation The process by which metacharacters are prevented
their special meaning, usually by using the char-
acter `' in pairs, or by using the character `\',
USD:4-62 An Introduction to the C shell
is referred to as quotation (1.7).
redirection The routing of input or output from or to a file
is known as redirection of input or output (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 interpreted
relative to the current working directory. The
first component of such a pathname refers to some
file or directory in the working directory, and
subsequent components between `/' characters refer
to directories below the working directory. Path-
names that are not relative are called absolute
pathnames (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 struc-
ture 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 explanation
(1.6).
RUBOUT The RUBOUT or DELETE key is often used to erase
the previously typed character; some users prefer
the BACKSPACE for this purpose. On older versions
of UNIX this key served as the INTR character.
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 possi-
ble 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 pro-
grams (3.3, 3.10).
An Introduction to the C shell USD:4-63
set The builtin set command is used to assign new val-
ues 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 command (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 concerned. 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 something to
happen to that process. Signals are sent either
by typing special control characters on the key-
board 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 com-
mands 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 man-
ual.
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 fin-
ishes. By convention a status of zero indicates
that the command succeeded. Commands 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).
USD:4-64 An Introduction to the C shell
string A sequential group of characters taken together is
called a string. Strings can contain any print-
able 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 substitutions
where sequences indicated by metacharacters are
replaced by other sequences. Notable examples of
this are history substitution keyed by the
metacharacter `!' and variable substitution indi-
cated 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 sus-
pended, a job temporarily stops running 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 finishes we
say it undergoes termination or terminates. Com-
mands normally terminate when they read an end-of-
file from their standard input. It is also possi-
ble to terminate commands by sending them an
interrupt or quit signal (1.8). The kill program
terminates 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 com-
mand 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 terminal is
An Introduction to the C shell USD:4-65
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 examples. Variables
such as argv are also used in writing shell pro-
grams (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 variable is set by the
shell's -v command line option (3.10).
wc The wc program calculates the number of charac-
ters, 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 argument
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 charac-
ters may be made into a word by surrounding it
with `'' characters except for the characters `''
and `!' which require special treatment (1.1).
This process of placing special characters in
words without their special meaning is called
quoting.
working directory
At any given time you are in one particular direc-
tory, called your working directory. This direc-
tory's name is printed by the pwd command and the
files listed by ls are the ones in this directory.
USD:4-66 An Introduction to the C shell
You can change working directories using chdir.
write The write command is an obsolete way of communi-
cating with other users who are logged in to UNIX
(you have to take turns typing). If you are both
using display terminals, use talk(1), which is
much more pleasant.