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


          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.


     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-


     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?

     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


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


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


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

     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-


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

     If  we  wished to refer to all four of these files in a com-
mand, we could use the notation


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.

        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


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


might match files

        chap.1 chap.2 chap.3 chap.4 chap.5

if they existed.  This is shorthand for


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-

     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 `'',

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 \'\!



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

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

     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

An Introduction to the C shell                           USD:4-13

        % mail harold
        Someone just copied a big file into my directory and its name is
        % ls
        % jobs
        [1]  + Stopped   mail harold
        % fg
        mail harold
        funnyfile. Do you know who did it?

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

        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

     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"

     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

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

     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

     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-

        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


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


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

        set noclobber

in your .login file.  Then trying to do

        date > now

would  cause  a  diagnostic  if `now' existed already.  You could

        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

     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

        % cc !$
        cc bug.c
        "bug.c", line 4: newline in string or char constant
        "bug.c", line 5: syntax error
        % ed !$
        ed bug.c
        % !c
        cc bug.c
        % a.out
        hello% !e
        ed bug.c
        % !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
        % 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

        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 |& 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?
        [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

        % du > usage

`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
        % 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
        % 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

     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
        % bg
        [1] ed bigfile &
         . . .  some foreground commands
        [1] Stopped (tty input)ed bigfile
        % fg
        ed bigfile

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

     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

An Introduction to the C shell                           USD:4-29

        % stty tostop
        % wc hugefile &
        [1] 10387
        % ed text
        . . . some time later
        [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

     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
        % mkdir newpaper
        % chdir newpaper
        % pwd

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


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,

        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

        % dirs -l
        % cd myproject
        % dirs
        % ed prog.c
        % cd ..
        % ls
        % 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
        (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

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

     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

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


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


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


expands to the number of elements in the variable name.  Thus

        % set argv=(a b c)
        % echo $?argv
        % echo $#argv
        % unset argv
        % echo $?argv
        % echo $argv
        Undefined variable: argv.

     It  is  also possible to access the components of a variable
which has several values.  Thus


gives the first component of argv or in the  example  above  `a'.


An Introduction to the C shell                           USD:4-37

would give `c', and


would give `a b'. Other notations useful in shell scripts are


where n is an integer as a shorthand for


the nth parameter and


which is a shorthand for


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

     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

                cmp -s $i ~/backup/$i:t # to set $status

                if ($status != 0) then
                        echo new backup of $i
                        cp $i ~/backup/$i:t

     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

     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

        if ( expression ) then

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

        if ( expression ) command

which can be written

        if ( expression ) \

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
        else if (expression ) then


     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/' then

     % echo $i $i:r $i:e
     /mnt/ /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!


     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 )


        switch ( word )

        case str1:


        case strn:


  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.:

                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/^[ ]*//

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


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

     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
        % grep -c nsh$ /etc/passwd
        % grep -c -v sh$ /etc/passwd

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

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
        % echo $#a

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


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


     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,

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

.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

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

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

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

                       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

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 `' 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,

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'

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

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

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,

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.

               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-

mkdir          The  mkdir  command is used to create a new direc-

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

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

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,

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

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

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

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,

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-

standard       We  refer often to the standard input and standard
               output of commands.  See input  and  output  (1.3,

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

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.