MirBSD manpage: 04.csh(USD)


               An Introduction to the C shell

                        William Joy
            (revised for 4.3BSD by Mark Seiden)

                 Computer Science Division
 Department of Electrical Engineering and Computer Science
             University of California, Berkeley
                 Berkeley, California 94720

                          ABSTRACT

          Csh is a new command language interpreter for
     UNIX- systems. It incorporates  good  features  of
     other  shells  and  a history mechanism similar to
     the redo of INTERLISP.  While  incorporating  many
     features  of other shells which make writing shell
     programs  (shell  scripts)  easier,  most  of  the
     features  unique  to csh are designed more for the
     interactive UNIX user.

          UNIX users who have read a general  introduc-
     tion  to  the  system  will  find a valuable basic
     explanation of the  shell  here.  Simple  terminal
     interaction  with  csh  is  possible after reading
     just the  first  section  of  this  document.  The
     second  section describes the 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
     listing  special  characters  of  the  shell and a
     glossary of terms and commands introduced in  this
     manual.

Introduction

     A shell is a command language interpreter. Csh  is  the
name of one particular command interpreter on UNIX. The pri-
mary purpose of csh is to translate command lines typed at a
terminal  into  system  actions, such as invocation of other
_________________________
-  UNIX  is a registered trademark of AT&T Bell Labora-
tories in the USA and other countries.

USD:4-2                       An Introduction to the C shell

programs. Csh is a user program  just  like  any  you  might
write.  Hopefully, csh will be a very useful program for you
in interacting with the UNIX system.

     In addition to this document, you will want to refer to
a copy of the UNIX User Reference Manual. The csh documenta-
tion in section 1 of the manual provides a full  description
of all features 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 docu-
ment. If you don't know what is meant by a word, you  should
look for it in the glossary.

Acknowledgements

     Numerous people have provided good input about previous
versions of csh and aided in its debugging and in the debug-
ging of its documentation. I would especially like to  thank
Michael  Ubell who made the crucial observation that history
commands could be done well over the word structure of input
text,  and  implemented  a prototype history mechanism in an
older version of the shell. Eric Allman has also provided  a
large  number  of  useful  comments on the shell, helping to
unify those concepts which are present and to  identify  and
eliminate  useless  and  marginally  useful  features.  Mike
O'Brien  suggested  the  pathname  hashing  mechanism  which
speeds command execution. Jim Kulp added the job control and
directory stack primitives and added their documentation  to
this introduction.

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 built-in
functions which it performs directly,  most  commands  cause
execution  of  programs  that  are, in fact, external to the
shell. The shell is  thus  distinguished  from  the  command
interpreters  of  other  systems both by the fact that it is
just a user program, and by the fact that it is used  almost
exclusively as a mechanism for invoking other programs.

     Commands in the  UNIX  system  consist  of  a  list  of
strings  or  words interpreted as a command name followed by
arguments. Thus the command

        mail bill

consists of two words. The first word mail names the command
to  be  executed,  in this case the mail program which sends
messages to other users. The shell uses the name of the com-
mand  in attempting to execute it for you. It will look in a
number of directories for a file with the name mail which is
expected to contain the mail program.

     The rest of the words of the command are given as argu-
ments  to  the  command  itself when it is executed. In this
case we specified also the argument  bill  which  is  inter-
preted  by the mail program to be the name of a user to whom
mail is to be sent. In normal terminal usage  we  might  use
the mail command as follows.

        % mail bill
        I have a question about the csh documentation.
        My document seems to be missing page 5.
        Does a page five exist?
                Bill
        EOT
        %

     Here we typed a message to send to bill and ended  this
message with a ^D which sent an end-of-file to the mail pro-
gram. (Here  and  throughout  this  document,  the  notation
``^x'' is to be read ``control-x'' and represents the strik-
ing of the x key while the control key is  held  down.)  The
mail  program then echoed the characters `EOT' and transmit-
ted our message. The characters `% ' were printed before and
after  the  mail command by the shell to indicate that input
was needed.

     After typing the `% ' prompt,  the  shell  was  reading
command input from our terminal. We typed a complete command

USD:4-4                       An Introduction to the C shell

`mail bill'. The shell then executed the mail  program  with
argument  bill  and went dormant waiting for it to complete.
The mail program then read input from our terminal until  we
signaled  an  end-of-file  via  typing  a ^D after which the
shell noticed that mail had completed and signaled  us  that
it  was  ready  to  read from the terminal again by printing
another `% ' prompt.

     This is the essential pattern of all  interaction  with
UNIX  through  the shell. A complete command is typed at the
terminal, the shell executes the command and when this  exe-
cution  completes,  it prompts for a new command. If you run
the editor for an hour, the shell will  patiently  wait  for
you  to finish editing and obediently prompt you again when-
ever you finish editing.

     An example of a useful command you can execute  now  is
the  tset  command,  which  sets  the default erase and kill
characters on your terminal - the erase character erases the
last  character  you typed and the kill character erases the
entire line you have entered so far. By default,  the  erase
character  is  the  delete  key (equivalent to `^?') and the
kill character is `^U'.  Some  people  prefer  to  make  the
erase  character the backspace key (equivalent to `^H'). You
can make this be true by typing

        tset -e

which tells the program tset to set the erase  character  to
tset's default setting for this character (a backspace).

1.2. Flag arguments

     A useful notion in UNIX is that  of  a  flag  argument.
While  many arguments to commands specify file names or user
names, some arguments rather specify an optional  capability
of the command which you wish to invoke. By convention, such
arguments begin with the character `-'  (hyphen).  Thus  the
command

        ls

will produce a list of the  files  in  the  current  working
directory. The option -s is the size option, and

        ls -s

causes ls to also give, for each file the size of  the  file
in  blocks  of  512  characters. The manual section for each
command in the UNIX reference  manual  gives  the  available
options  for each command. The ls command has a large number
of useful and interesting options. Most other commands  have
either  no options or only one or two options. It is hard to
remember  options  of  commands  which  are  not  used  very

An Introduction to the C shell                       USD:4-5

frequently,  so  most UNIX utilities perform only one or two
functions rather than having  a  large  number  of  hard  to
remember options.

1.3. Output to files

     Commands that normally read input or  write  output  on
the  terminal  can  also  be executed with this input and/or
output done to a file.

     Thus suppose we wish to save the current date in a file
called `now'. The command

        date

will print the current date on our terminal. This is because
our  terminal  is  the  default standard output for the date
command and the date command prints the date on its standard
output.  The shell lets us redirect the standard output of a
command through a notation using the 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 section 2.2.

     The system normally keeps files which you  create  with
`>' and all other files. Thus the default is for files to be
permanent.  If you wish to  create  a  file  which  will  be
removed  automatically,  you  can  begin its name with a `#'
character, this `scratch' character denotes  the  fact  that
the file will be a scratch file.*  The  system  will  remove
_________________________
*Note that if your erase character is a `#',  you  will
have  to precede the `#' with a `\'.  The fact that the
`#' character is the old (pre-CRT) standard erase 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

USD:4-6                       An Introduction to the C shell

such files after a couple of days, or sooner if  file  space
becomes very tight. Thus, in running the date command above,
we don't really want to save the output forever, so we would
more likely do

        date > #now

1.4. Metacharacters in the shell

     The shell has a  large  number  of  special  characters
(like  `>')  which  indicate  special functions. We say that
these notations have syntactic and semantic meaning  to  the
shell. In general, most characters which are neither letters
nor digits have special  meaning  to  the  shell.  We  shall
shortly  learn  a  means of quotation which allows us to use
metacharacters without the shell treating them in  any  spe-
cial 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  com-
mand  normally  reads  its  input,  from the file `data'. We
would more likely say

        sort data

letting the sort command open  the  file  `data'  for  input
itself since this is less to type.

     We should note that if we just typed

        sort

_________________________
a ^H, as we demonstrated in section 1.1 how this  could
be set up.

An Introduction to the C shell                       USD:4-7

then the sort program would sort  lines  from  its  standard
input.  Since  we  did  not  redirect the standard input, it
would sort lines as we typed them on the terminal  until  we
typed a ^D to indicate an end-of-file.

     A most useful capability is the ability to combine  the
standard  output  of  one command with the standard input of
another, i.e. to run the commands in a sequence known  as  a
pipeline. For instance the command

        ls -s

normally produces a list of the files in our directory  with
the  size  of  each  in  blocks of 512 characters. If we are
interested in learning which of our files is largest we  may
wish  to have this sorted by size rather than by name, which
is the default way in which ls sorts. We  can  look  at  the
many options of ls to see if there was an option to do this,
or instead we can use a couple of simple options of the sort
command, combining it with ls to get what we want.

     The -n option of sort specifies a numeric  sort  rather
than an alphabetic sort. Thus

        ls -s | sort -n

specifies that the output of the ls  command  run  with  the
option  -s  is  to be piped to the command sort run with the
numeric sort option. This would give us a sorted list of our
files  by  size,  but with the smallest first. We could then
use the -r reverse sort option and the head command in  com-
bination with the previous command doing

        ls -s | sort -n -r | head -5

Here we have taken a list of  our  files  sorted  alphabeti-
cally, each with the size in blocks. We have run this to the
standard input of the sort command asking it to sort numeri-
cally in reverse order (largest first). This output has then
been run into the command head which gives us the first  few
lines.  In  this  case  we  have  asked head for the first 5
lines. Thus this command gives us the names and sizes of our
5 largest files.

     The  notation  introduced  above  is  called  the  pipe
mechanism.  Commands  separated  by  `|' characters are con-
nected together by the shell, and  the  standard  output  of
each  is  run into the standard input of the next. The left-
most command in a pipeline will normally take  its  standard
input  from  the  terminal  and the rightmost will place its
standard output on the terminal. Other examples of pipelines
will  be  given later when we discuss the history mechanism;
one important use of pipes which is illustrated there is  in
the routing of information to the line printer.

USD:4-8                       An Introduction to the C shell

1.6. Filenames

     Many commands to be executed will  need  the  names  of
files  as  arguments.  UNIX pathnames consist of a number of
components separated by `/'. Each component except the  last
names  a  directory  in which the next component resides, in
effect specifying the path of directories to follow to reach
the file. Thus the pathname

        /etc/motd

specifies a file in the directory `etc' which is a subdirec-
tory  of  the  root directory `/'. Within this directory the
file named is `motd' which stands for `message of the  day'.
A  pathname  that begins with a slash is said to be an abso-
lute pathname since it is specified from the absolute top of
the  entire  directory  hierarchy  of the system (the root).
Pathnames which do not begin with  `/'  are  interpreted  as
starting  in  the  current  working  directory, which is, by
default, your home directory and can be changed  dynamically
by  the cd change directory command. Such pathnames are said
to be relative to the working directory since they are found
by starting in the working directory and descending to lower
levels of directories for each component  of  the  pathname.
If  the pathname contains no slashes at all then the file is
contained in the working directory itself and  the  pathname
is  merely  the name of the file in this directory. Absolute
pathnames have no relation to the working directory.

     Most filenames consist  of  a  number  of  alphanumeric
characters and `.'s (periods). In fact, all printing charac-
ters 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 com-
pilation of the program and the file `prog.output' the  out-
put of a run of the program.

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

        prog.*

An Introduction to the C shell                       USD:4-9

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  dif-
ferent  order  than  we  listed them above. The echo command
receives four words as arguments, even though we only  typed
one  word  as an argument directly. The four words were gen-
erated by filename expansion of the one input word.

     Other notations for filename expansion are also  avail-
able.  The  character  `?' matches any single character in a
filename. Thus

        echo ? ?? ???

will echo a line of filenames; first those with one  charac-
ter  names, then those with two character names, and finally
those with three character names. The names of  each  length
will be independently sorted.

     Another mechanism consists of a sequence of  characters
between  `['  and  `]'. This metasequence matches any single
character from the enclosed set. Thus

        prog.[co]

will match

        prog.c prog.o

in the example above.  We  can  also  place  two  characters
around a `-' in this notation to denote a range. Thus

        chap.[1-5]

might match files

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

if they existed. This is shorthand for

        chap.[12345]

USD:4-10                      An Introduction to the C shell

and otherwise equivalent.

     An important point to note is that if a list  of  argu-
ment words to a command (an argument list) contains filename
expansion syntax, and  if  this  filename  expansion  syntax
fails  to match any existing file names, then the shell con-
siders this to be an error and prints a diagnostic

        No match.

and does not execute the command.

     Another very important point is  that  files  with  the
character  `.'  at the beginning are treated specially. Nei-
ther `*' nor `?' nor the `[' `]' mechanism  will  match  it.
This  prevents  accidental matching of the filenames `.' and
`..' in the working directory which have special meaning  to
the  system, as well as other files such as .cshrc which are
not normally visible. We will discuss the  special  role  of
the file .cshrc later.

     Another filename expansion mechanism  gives  access  to
the  pathname  of  the  home  directory of other users. This
notation consists of the character `~' (tilde)  followed  by
another  user's  login  name.  For instance the word `~bill'
would map to the pathname `/home/bill' if the home directory
for  `bill' was `/home/bill'. Since, on large systems, users
may have login directories  scattered  over  many  different
disk  volumes  with  different  prefix directory names, this
notation provides a convenient 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
`/home/bill/mbox'  for  me on Ernie Co-vax, the UCB Computer
Science Department VAX  machine,  where  this  document  was
prepared.  This  can  be  very useful if you have used cd to
change to another directory and have found a file  you  wish
to copy using cp. If I give the command

        cp thatfile ~

the shell will expand this command to

        cp thatfile /home/bill

since my home directory is /home/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

An Introduction to the C shell                      USD:4-11

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  a
sorted  list  of filenames in the current working directory,
or print the message `No match' if there are no files in the
working directory.

     The recommended mechanism for placing characters  which
are  neither  numbers, digits, `/', `.', nor `-' in an argu-
ment word to a command, is to enclose it with single  quota-
tion characters `'', i.e.

        echo '*'

There is one special character `!' which is used by the his-
tory  mechanism  of the shell and which cannot be escaped by
placing it within `'' characters. It and the  character  `''
itself can be preceded by a single `\' to prevent their spe-
cial meaning. Thus

        echo \'\!

prints

        '!

These two mechanisms suffice to place any printing character
into  a  word which is an argument to a shell command.  They
can be combined, as in

        echo \''*'

which prints

        '*

since the first `\' escaped the first `'' and  the  `*'  was
enclosed between `'' characters.

1.8. Terminating commands

     When you are executing a command and the shell is wait-
ing  for  it to complete, there are several ways to force it
to stop. For instance if you type the command

USD:4-12                      An Introduction to the C shell

        cat /etc/passwd

the system will print a copy of a list of all users  of  the
system  on  your  terminal.  This  is likely to continue for
several minutes unless you stop it. You can send  an  INTER-
RUPT  signal  to the cat command by typing ^C on your termi-
nal.* 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 commands rather
than terminating like cat did, which would have  the  effect
of logging you out.

     Another way in which many programs  terminate  is  when
they  get an end-of-file from their standard input. Thus the
mail program in the first example above was terminated  when
we  typed a ^D which generates an end-of-file from the stan-
dard input. The shell also terminates when it gets  an  end-
of-file,  printing `logout'; UNIX then logs you off the sys-
tem. Since this means that typing too many ^D's can acciden-
tally  log  us off, the shell has a mechanism for preventing
this. This ignoreeof option will  be  discussed  in  section
2.2.

     If a command has its standard input redirected  from  a
file,  then  it  will normally terminate when it reaches the
end of this file. Thus if we execute

        mail bill < prepared.text

the mail command will terminate without  our  typing  a  ^D.
This  is  because  it  read  to  the end-of-file of our file
`prepared.text' in which we placed a message for `bill' with
an editor program. We could also have done

        cat prepared.text | mail bill

since the cat command  would  then  have  written  the  text
through  the pipe to the standard input of the mail command.
When the cat command completed  it  would  have  terminated,
closing  down  the  pipeline and the mail command would have
received an end-of-file from it and terminated. Using a pipe
here  is more complicated than redirecting input so we would
more likely use the first form. These  commands  could  also
have been stopped by sending an INTERRUPT.

_________________________
*On some older Unix systems the DEL or RUBOUT  key  has
the  same  effect.  "stty all" will tell you the `intr'
key value.

An Introduction to the C shell                      USD:4-13

     Another  possibility  for  stopping  a  command  is  to
suspend  its  execution temporarily, with the possibility of
continuing execution later.  This is done by sending a  STOP
signal via typing a ^Z. This signal causes all commands run-
ning on the terminal (usually one, but more if a pipeline is
executing)  to  become suspended. The shell notices that the
command(s) have been suspended, types `Suspended', and  then
prompts  for a new command. The previously executing command
has been suspended, but otherwise  unaffected  by  the  STOP
signal.  Any other commands can be executed while the origi-
nal command remains suspended.  The suspended command can be
continued using the fg command with no arguments.  The shell
will then retype the command to remind you which command  is
being  continued, and cause the command to resume execution.
Unless any input files in use by the suspended command  have
been  changed  in the meantime, the suspension has no effect
whatsoever on the execution of the  command.   This  feature
can  be very useful during editing, when you need to look at
another  file  before  continuing.  An  example  of  command
suspension follows.

        % mail harold
        Someone just copied a big file into my directory and its name is
        ^Z
        Suspended
        % ls
        funnyfile
        prog.c
        prog.o
        % jobs
        [1]  + Suspended mail harold
        % fg
        mail harold
        (continue)
        funnyfile. Do you know who did it?
        EOT
        %

In this example someone was sending a message to Harold  and
forgot  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 `Suspended'
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 execution of the
mail program.  Input to the mail program was then  continued
and  ended  with a ^D which indicated the end of the message
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 keyboard.  This also happens on INTERRUPT, and QUIT sig-
nals.   More  information on suspending jobs and controlling

USD:4-14                      An Introduction to the C shell

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  sig-
nal,  sent  by  typing  a  ^\. This will usually provoke the
shell to produce a message like:

        Quit (core dumped)

indicating that a file `core' has  been  created  containing
information  about  the running program's state when it ter-
minated due to the QUIT signal. You can  examine  this  file
yourself,  or  forward  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 sig-
nals at the terminal.  To stop them you must  use  the  kill
command.  See section 2.6 for an example.

     If you want to examine the output of a command  without
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 screen-full  and
types  `[filename] %', at which point you can hit a space to
get another screen full, a return to get  another  line,  an
`h'  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 pro-
gram 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
current 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

An Introduction to the C shell                      USD:4-15

suffer  through  the output on a slow terminal; ^O is a tog-
gle, 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 -s /bin/csh myname

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 -s /bin/csh bill'. 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 change your shell  to  csh  before  you  begin
reading it.

USD:4-16                      An Introduction to the C shell

2. Details on the shell for terminal users

2.1. Shell startup and termination

     When you login, the shell is started by the  system  in
your  home  directory  and begins by reading commands from a
file .cshrc in this directory.  All  shells  which  you  may
start during your terminal session will read from this file.
We will later see what kinds of commands are usefully placed
there. For now we need not have this file and the shell does
not complain about its absence.

     A login shell, executed after you login to the  system,
will,  after  it  reads  commands from .cshrc, read commands
from a file .login also in your home  directory.  This  file
contains  commands which you wish to do each time you log in
to the UNIX system. My .login file looks something like:

        set ignoreeof
        set mail=(/usr/spool/mail/bill)
        echo "${prompt}users" ; users
        alias ts \
                'set noglob ; eval `tset -s -m dialup:c100rv4pna -m plugboard:?hp2621nl *`';
        ts; stty intr ^C kill ^U crt
        set time=15 history=10
        msgs -f
        if (-e $mail) then
                echo "${prompt}mail"
                mail
        endif

     This file contains several commands to be  executed  by
UNIX each time I log in. The first is a set command which is
interpreted directly by the shell.  It sets the shell  vari-
able ignoreeof which causes the shell to not log me off if I
hit ^D.  Rather, I use the logout command  to  log  off  the
system.  By  setting  the  mail variable, I ask the shell to
watch for incoming mail to me.  Every 5  minutes  the  shell
looks  for  this  file and tells me if more mail has arrived
there. An alternative to this is to put the command

        biff y

in place of this set; this will  cause  me  to  be  notified
immediately when mail arrives, and to be shown the first few
lines of the new message.

     I create an alias ``ts'' which executes a tset(1)  com-
mand setting up the modes of the terminal. The parameters to
tset indicate the kinds of terminal which I usually use when
not on a hardwired port.  I then execute ``ts'' and also use
the stty command to change the interrupt character to ^C and
the line kill character to ^U.

An Introduction to the C shell                      USD:4-17

     Next I set the shell variable `time'  to  `15'  causing
the  shell  to  automatically print out statistics lines for
commands which execute for at least 15 seconds of CPU  time.
The  variable  `history' is set to 10 indicating that I want
the shell to remember the last 10 commands  I  type  in  its
history list, (described later).

     I then run the `msgs' program, which provides  me  with
any  system  messages which I have not seen before; the `-f'
option here prevents it from telling me  anything  if  there
are  no  new  messages.  Finally, if my mailbox file exists,
then I run the `mail' program to process my mail.

     When the `mail' and `msgs' programs finish,  the  shell
will finish processing my .login file and begin reading com-
mands from the terminal, prompting for each with `% '.  When
I  log  off  (by  giving  the logout command) the shell will
print `logout' and execute commands from the file  `.logout'
if it exists in my home directory. After that the shell will
terminate and UNIX will log me off the system. If the system
is  not  going  down, I will receive a new login message. In
any case, after the `logout' message the shell is  committed
to terminating and will take no further input from my termi-
nal.

2.2. Shell variables

     The shell maintains a set of variables.  We  saw  above
the  variables  history  and  time which had values `10' and
`15'. In fact, each shell variable has as value an array  of
zero or more strings. Shell variables may be assigned values
by the set command.  It has several forms, the  most  useful
of which was given above and is

        set name=value

     Shell variables may be used to store values  which  are
to  be used in commands later through a substitution mechan-
ism. The shell variables most commonly referenced are,  how-
ever,  those  which  the shell itself refers to. By changing
the values of these variables one can  directly  affect  the
behavior of the shell.

     One of the most important  variables  is  the  variable
path.  This  variable contains a sequence of directory names
where the shell searches for commands. The set command  with
no  arguments  shows  the  value  of all variables currently
defined (we usually say set) in the shell. The default value
for path will be shown by set to be

USD:4-18                      An Introduction to the C shell

        % set
        argv   ()
        cwd    /home/bill
        home   /home/bill
        path   (/bin /usr/bin .)
        prompt %
        shell  /bin/csh
        status 0
        term   c100rv4pna
        user   bill
        %

This output indicates  that  the  variable  path  points  to
`/bin',  `/usr/bin', and the current directory `.'. Commands
which you may write might be in `.'  (usually  one  of  your
directories). Other commands may live in /bin and /usr/bin.

     A number of locally developed programs  on  the  system
live  in the directory `/usr/local/bin'. If we wish that all
shells which we invoke to have access to these new  programs
we can place the command

        set path=(/bin /usr/bin /usr/local/bin .)

in our file .cshrc in our home directory. Try doing this and
then logging out and back in and do

        set

again to see that the value assigned to path has changed.

     One thing you should be aware  of  is  that  the  shell
examines  each directory which you insert into your path and
determines which commands are contained there.   Except  for
the current directory `.', which the shell treats specially,
this means that if commands are added to a directory in your
search  path after you have started the shell, they will not
necessarily be found by the shell. If you wish to use a com-
mand  which  has been added in this way, you should give the
command

        rehash

to the shell, which will cause it to recompute its  internal
table  of  command locations, so that it will find the newly
added command. Since the shell has to look  in  the  current
directory  `.' on each command, placing it at the end of the
path specification 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 working directory; and the variable ignoreeof, which

An Introduction to the C shell                      USD:4-19

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 vari-
able you simply do

        set ignoreeof

and to unset it do

        unset ignoreeof

These give the variable `ignoreeof' no value,  but  none  is
desired or required.

     Finally, some other built-in shell variables of use are
the variables noclobber and mail. The metasyntax

        > filename

which redirects the  standard  output  of  a  command,  will
overwrite  and  destroy  the  previous contents of the named
file. In this way you  may  accidentally  overwrite  a  file
which  is  valuable.  If you would prefer that the shell not
overwrite files in this way you can

        set noclobber

in your .login file. Then trying to do

        date > now

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

        date >!  now

if you really wanted to overwrite the contents of `now'. The
`>!'  is a special metasyntax indicating that clobbering the
file is ok.-

2.3. The shell's history list

     The shell can maintain a history  list  into  which  it
places the words of previous commands. It is possible to use
a notation to reuse commands or words from commands in form-
ing  new commands. This mechanism can be used to repeat pre-
vious commands  or  to  correct  minor  typing  mistakes  in
_________________________
-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

commands.

     The following figure gives a sample  session  involving
typical 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, refer-
ring 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 history mechanism,
and then executed it. The compilation yielded error diagnos-
tics  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 command starting with `cc' without execut-
ing 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  com-
piler  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 formation of new com-
mands  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  argu-
ment  list `*'. Finally we ran the program `bug' to see that
its output is indeed correct.

     To make a numbered listing of the program  we  ran  the
`cat'  command  on  the  file  `bug.c',  with the `-n' flag.
Unfortunately, we mispelled `cat' as `cay'. To correct  this
we  used  a  shell  substitute, placing the old text and new
text between `^' characters.  This is similar to the substi-
tute  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 com-
mands.   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 com-
mand. A complete description  of  all  these  mechanisms  is

An Introduction to the C shell                      USD:4-21

        % cat bug.c
        main()

        {
                printf("hello);
        }
        % cc !$
        cc bug.c
        bug.c:4: unterminated string or character constant
        bug.c:4: possible real start of unterminated constant
        % ed !$
        ed bug.c
        29
        4s/);/"&/p
                printf("hello");
        w
        30
        q
        % !c
        cc bug.c
        % a.out
        hello% !e
        ed bug.c
        30
        4s/lo/lo\\n/p
                printf("hello\n");
        w
        32
        q
        % !c -o bug
        cc bug.c -o bug
        % size a.out bug
        text    data    bss     dec     hex
        1022    208     288     1518    5ee     a.out
        1022    208     288     1518    5ee     bug
        % ls -l !*
        ls -l a.out bug
        -rwxr-xr-x 1 bill       3932 Dec 19 09:41 a.out
        -rwxr-xr-x 1 bill       3932 Dec 19 09:42 bug
        % bug
        hello
        % cay -n bug.c
        cay: Command not found.
        % ^cay^cat
        cat -n bug.c
            1   main()
            3   {
            4           printf("hello\n");
            5   }
        % !! | lpr
        cat -n bug.c | lpr
        %

given in the C shell manual pages in the  UNIX  Programmer's
Manual.

USD:4-22                      An Introduction to the C shell

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 com-
mands and their arguments. The alias facility is similar  to
a  macro facility. Some of the features obtained by aliasing
can be obtained also using shell command  files,  but  these
take  place  in  another  instance  of  the shell and cannot
directly affect the current shells  environment  or  involve
commands such as cd which must be done in the current shell.

     As an example, suppose that there is a new  version  of
the  mail program on the system called `newmail' you wish to
use, rather than the standard mail program which  is  called
`mail'. If you place the shell command

        alias mail newmail

in your .cshrc file, the shell will transform an input  line
of the form

        mail bill

into a call on `newmail'. More generally,  suppose  we  wish
the  command `ls' to always show sizes of files, that is, to
always do `-s'. We can do

        alias ls ls -s

or even

        alias dir ls -s

creating a new command syntax `dir' which does an  `ls  -s'.
If we say

        dir ~bill

then the shell will translate this to

        ls -s /home/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 com-
mands or pipelines, showing where the arguments to the  ori-
ginal  command are to be substituted using the facilities of
the history mechanism. Thus the definition

        alias cd 'cd \!* ; ls '

An Introduction to the C shell                      USD:4-23

would do an ls command after each change directory  cd  com-
mand. We enclosed the entire alias definition in `'' charac-
ters to prevent 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  argument  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
password 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 termi-
nal even when the standard output is redirected to a file or
a  pipe. It is occasionally desirable to direct the diagnos-
tic 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  diagnos-
tic it produces you can do

        command >& file

The `>&' here tells the shell to route both  the  diagnostic
output  and  the  standard output into `file'. Similarly you
can give the command

        command |& lpr

to route both standard and  diagnostic  output  through  the
pipe to the line printer daemon lpr.=
_________________________
= A command of the form

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 pipe-
line or as a sequence of commands separated by semicolons, a
single job is created by the shell consisting of these  com-
mands  together  as a unit. Single commands without pipes or
semicolons create the simplest  jobs.  Usually,  every  line
typed  to  the  shell  creates 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
commands, 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 exe-
cuted 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 immedi-
ately with a prompt for the next command without 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 meantime. 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 finishes sometime during
the execution of the mail  command  and  its  completion  is
reported  just  before  the  prompt  after  the  mail job is
_________________________
     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

finished.

        % du > usage &
        [1] 503
        % mail bill
        How do you know when a background job is finished?
        EOT
        [1] - Done       du > usage
        %

If the job did not terminate normally,  the  `Done'  message
might say something else like `Killed'. If you want the ter-
minations of background jobs to be reported at the time they
occur  (possibly 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 signals 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 com-
mand names, arguments, and the process numbers of  all  com-
mands 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 background 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 background using `&',  its
number,  as  well  as  the  process  numbers of all its (top
level) commands, 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' option, pipes this  out-
put into the `sort' program with the `-n' option, which puts
its output 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 immediately prompts for a new command, leaving the job
running simultaneously.

     As mentioned in section  1.8,  foreground  jobs  become

USD:4-26                      An Introduction to the C shell

suspended  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 they merely stop  any  further  pro-
gress  until  started again, either in the foreground or the
background.  The shell notices when a  job  becomes  stopped
and  reports this fact, much like it reports the termination
of background jobs. For foreground jobs this looks like

        % du > usage
        ^Z
        Suspended
        %

The `Suspended' 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] + Suspended (signal)sort usage
        %

Suspending foreground jobs can be very useful when you  need
to temporarily change what you are doing (execute other com-
mands) and then return to the suspended  job.   Also,  fore-
ground  jobs  can  be  suspended and then continued as back-
ground jobs using the bg command, allowing you  to  continue
other  work  and stop waiting for the foreground job to fin-
ish.  Thus

        % du > usage
        ^Z
        Stopped
        % bg
        [1] du > usage &
        %

starts `du' in the foreground, stops it before it  finishes,
then continues it in the background allowing more foreground
commands to be executed. This is especially helpful  when  a
foreground  job  ends up taking longer than you expected and
you wish you had started it in the background in the  begin-
ning.

     All job control commands  can  take  an  argument  that
identifies  a  particular  job. All job name arguments begin
with the character `%', since some of the job  control  com-
mands  also  accept  process numbers (printed by the ps com-
mand). 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

An Introduction to the C shell                      USD:4-27

usual case) it is always the current job; thus  no  argument
is  needed.  If  a job is stopped while running in the fore-
ground 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  previ-
ous job becomes the current job. When given, the argument 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 (`Suspended' or `Running')
of each background or suspended job.  With the  `-l'  option
the process numbers are also typed.

        % du > usage &
        [1] 3398
        % ls -s | sort -n > myfile &
        [2] 3405
        % mail bill
        ^Z
        Stopped
        % jobs
        [1] - Running    du > usage
        [2]    Running   ls -s | sort -n > myfile
        [3] + Suspended  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 fore-
ground (allowing signals 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 background.  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 background 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 pro-
cess numbers as arguments, as printed by ps.  Thus,  in  the
example  above,  the running du command could have been ter-
minated by the command

        % kill %1
        [1]  Terminated  du > usage
        %

USD:4-28                      An Introduction to the C shell

     The notify command (not the variable mentioned earlier)
indicates  that  the termination of a specific job should be
reported at the time it finishes instead of waiting for  the
next prompt.

     If a job running in the background tries to read  input
from  the terminal it is automatically stopped.  When such a
job is then run in the foreground, input can be given to the
job.  If desired, the job can be run in the background again
until it requests input again. This is  illustrated  in  the
following  sequence where the `s' command in the text editor
might take a long time.

        % ed bigfile
        120000
        1,$s/thisword/thatword/
        ^Z
        Suspended
        % bg
        [1] ed bigfile &
        %
         . . .  some foreground commands
        [1] Suspended (tty input)ed bigfile
        % fg
        ed bigfile
        w
        120000
        q
        %

So after the `s'  command  was  issued,  the  `ed'  job  was
stopped  with  ^Z  and  then put in the background using bg.
Some time later when the `s' command was finished, ed  tried
to  read another command and was stopped because jobs in the
background cannot read from the terminal.   The  fg  command
returned  the `ed' job to the foreground where it could once
again accept commands from the terminal.

     The command

        stty tostop

causes all background jobs run on your terminal to stop when
they  are  about  to  write  output  to  the terminal.  This
prevents messages from  background  jobs  from  interrupting
foreground  job  output  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 back-
ground.  This stty command might be a good thing to  put  in
your  .login  file if you do not like output from background

An Introduction to the C shell                      USD:4-29

jobs interrupting your work.  It also can  reduce  the  need
for  redirecting the output of background jobs if the output
is not very big:

        % stty tostop
        % wc hugefile &
        [1] 10387
        % ed text
        . . . some time later
        q
        [1] Stopped (tty output)wc hugefile
        % fg wc
        wc hugefile
           13371   30123   302577
        % stty -tostop

Thus after some time the  `wc'  command,  which  counts  the
lines,  words and characters in a file, had one line of out-
put.  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
currently executing shell, it knows nothing about background
jobs started in other login sessions or within shell  files.
The  ps  command  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
particular working directory. The `change directory' command
chdir (its short form cd may also be used) changes the work-
ing  directory  of the shell, that is, changes the directory
you are located in.

     It is useful to make a directory for each  project  you
wish  to work on and to place all files related to that pro-
ject 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  direc-
tory  of  the  shell, that is, the directory you are located
in. Thus in the example below:

USD:4-30                      An Introduction to the C shell

        % pwd
        /home/bill
        % mkdir newpaper
        % chdir newpaper
        % pwd
        /home/bill/newpaper
        %

the user has created and moved to  the  directory  newpaper,
where, for example, he might place a group of related files.

     No matter where  you  have  moved  to  in  a  directory
hierarchy,  you can return to your `home' login directory by
doing just

        cd

with no arguments. The name `..' always means the  directory
above the current one in the hierarchy; thus

        cd ..

changes the shell's working directory to  the  one  directly
above  the  current  one.  The  name `..' can be used in any
pathname; thus,

        cd ../programs

means change to the directory `programs'  contained  in  the
directory  above the current one. If you have several direc-
tories for different projects under, say, your  home  direc-
tory,  this  shorthand notation permits you to switch easily
between them.

     The shell always remembers the pathname of its  current
working 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
        ~

An Introduction to the C shell                      USD:4-31

        %

The list is printed in a horizontal line,  reading  left  to
right,   with  a  tilde  (~)  as  shorthand  for  your  home
directory-in this case `/home/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  usu-
ally 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 directory' popd command without an argument returns you
to  the directory you were in prior to the current one, dis-
carding the previous current directory from the stack  (for-
getting it). Typing popd several times in a series takes you
backward through the directories you had  been  in  (changed
to)  by  the 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 direc-
tory 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 foreground, the shell warns you
that  the  working  directory of the currently running fore-
ground job is different from that of the shell.

        % dirs -l
        /home/bill
        % cd myproject
        % dirs
        ~/myproject
        % ed prog.c
        1143
        ^Z
        Suspended
        % cd ..
        % ls
        myproject
        textfile
        % fg
        ed prog.c (wd: ~/myproject)

This way the shell warns you when there is an implied change
of  working directory, even though no cd command was issued.
In  the  above  example  the   `ed'   job   was   still   in
`/home/bill/project'  even  though  the shell had changed to
`/home/bill'.  A  similar  warning  is  given  when  such  a

USD:4-32                      An Introduction to the C shell

foreground  job  terminates  or is suspended (using the STOP
signal) since the return to the shell again implies a change
of working directory.

        % fg
        ed prog.c (wd: ~/myproject)
         . . . after some editing
        q
        (wd now: ~)
        %

These messages are sometimes confusing if you  use  programs
that  change  their own working directories, since the shell
only remembers 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.

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
argument 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  his-
tory  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:

An Introduction to the C shell                      USD:4-33

        cputime   unlimited
        filesize  unlimited
        datasize  5616 kbytes
        stacksize 512 kbytes
        coredumpsizeunlimited

Limits can be set, e.g.:

        limit coredumpsize 128k

Most reasonable units abbreviations will work; see  the  csh
manual page for more details.

     The logout command can be used  to  terminate  a  login
shell which has ignoreeof set.

     The rehash command causes  the  shell  to  recompute  a
table  of  where commands are located.  This is necessary if
you add a command to a  directory  in  the  current  shell's
search  path  and wish 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
environment. 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 environment. It might then show:

        % printenv
        HOME=/home/bill
        SHELL=/bin/csh
        PATH=:/bin:/usr/bin:/usr/local/bin
        TERM=adm3a
        USER=bill
        %

     The source command can be used  to  force  the  current
shell to read commands from a file. Thus

        source .cshrc

USD:4-34                      An Introduction to the C shell

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 /home/bill/rc
        0.0u 0.1s 0:01 8% 2+1k 3+2io 1pf+0w
        % time wc /etc/rc /home/bill/rc
             52    178   1347 /etc/rc
             52    178   1347 /home/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 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  average
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
terminal  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 foreach 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 should look through
the  rest  of  this  document and the csh manual pages (sec-
tion1) to become familiar with the  other  facilities  which
are available to you.

An Introduction to the C shell                      USD:4-35

3. Shell control structures and command scripts

3.1. Introduction

     It is possible to place commands in files and to  cause
shells to be invoked to read and execute commands from these
files, which are called shell scripts. We here detail  those
features of the shell useful to the writers of such scripts.

3.2. Make

     It is important to first note what  shell  scripts  are
not useful for. There is a program called make which is very
useful for maintaining a group of related files or  perform-
ing  sets  of  operations  on  related files. For instance a
large program consisting of one or more files can  have  its
dependencies  described in a makefile which contains defini-
tions of the commands used to create these  different  files
when  changes  occur.  Definitions of the means for printing
listings, cleaning up  the  directory  in  which  the  files
reside,  and  installing  the resultant programs are easily,
and most appropriately, placed in this makefile. This format
is  superior  and preferable to maintaining a group of shell
procedures to maintain these files.

     Similarly when working on a document a makefile may  be
created which defines how different versions of the document
are to be created and which options of nroff  or  troff  are
appropriate.

3.3. Invocation and the argv variable

     A csh command script may be interpreted by saying

        % csh script ...

where script is the name of the file containing a  group  of
csh  commands  and  `...' is replaced by a sequence of argu-
ments. The shell places these arguments in the variable argv
and  then  begins  to  read  commands from the script. These
parameters are then available through  the  same  mechanisms
which are used to reference any other shell variables.

     If you make the file `script' executable by doing

        chmod 755 script

and place a shell comment at  the  beginning  of  the  shell
script  (i.e.  begin  the  file with a `#' character) then a
`/bin/csh' will automatically be invoked to execute `script'
when you type

        script

USD:4-36                      An Introduction to the C shell

If the file does not begin with  a  `#'  then  the  standard
shell  `/bin/sh' will be used to execute it. This allows you
to convert your older shell scripts to use csh at your  con-
venience.

3.4. Variable substitution

     After each input line is broken into words and  history
substitutions  are done on it, the input line is parsed into
distinct commands. Before each command is executed a mechan-
ism  know  as  variable substitution is done on these words.
Keyed by the character `$' this  substitution  replaces  the
names of variables by their values. Thus

        echo $argv

when placed in a command  script  would  cause  the  current
value of the variable argv to be echoed to the output of the
shell script. It is an error for argv to be  unset  at  this
point.

     A number of notations are provided for  accessing  com-
ponents and attributes of variables. The notation

        $?name

expands to `1' if name is set or to `0' if name is not  set.
It  is  the  fundamental mechanism used for checking whether
particular variables have been assigned  values.  All  other
forms of reference to undefined variables cause errors.

     The notation

        $#name

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

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

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

        $argv[1]

An Introduction to the C shell                      USD:4-37

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

        $argv[$#argv]

would give `c', and

        $argv[1-2]

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

        $n

where n is an integer as a shorthand for

        $argv[n]

the nth parameter and

        $*

which is a shorthand for

        $argv

The form

        $$

expands to the process number of the  current  shell.  Since
this  process  number is unique in the system it can be used
in generation of unique temporary file names. The form

        $<

is quite special and is replaced by the next line  of  input
read  from  the shell's standard input (not the script it is
reading).  This is useful for writing shell scripts that are
interactive,  reading  commands  from  the terminal, or even
writing a shell script that acts as a filter, reading  lines
from its input file. Thus the sequence

        echo 'yes or no?\c'
        set a=($<)

would write out the prompt `yes or no?'  without  a  newline
and  then  read  the  answer into the variable `a'.  In this
case `$#a' would be `0' if either a blank  line  or  end-of-
file (^D) was typed.

     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

USD:4-38                      An Introduction to the C shell

an  out  of range subscript error. This is for compatibility
with the way older shells handled parameters.

     Another important point is that it is never an error to
give  a  subrange of the form `n-'; if there are less than n
components of the given variable then no words  are  substi-
tuted.  A  range of the form `m-n' likewise returns an empty
vector without giving an error when m exceeds the number  of
elements  of the given variable, provided the subscript n is
in range.

3.5. Expressions

     In order for  interesting  shell  scripts  to  be  con-
structed  it must be possible to evaluate expressions in the
shell based on the values of variables.  In  fact,  all  the
arithmetic operations of the language C are available in the
shell with the same precedence that they have in C. In  par-
ticular,  the  operations  `==' and `!=' compare strings and
the operators `&&' and `||'  implement  the  boolean  and/or
operations.  The special operators `=~' and `!~' are similar
to `==' and `!=' except that the string on  the  right  side
can  have  pattern matching characters (like *, ? or []) and
the test is whether the string on the left matches the  pat-
tern on the right.

     The shell also allows file enquiries of the form

        -? filename

where `?' is replace by a number of single  characters.  For
instance the expression primitive

        -e filename

tell whether the file `filename'  exists.  Other  primitives
test for read, write and execute access to the file, whether
it is a directory, or has non-zero length.

     It is possible to test  whether  a  command  terminates
normally,  by  a  primitive  of the form `{ command }' which
returns true, i.e. `1' if the command succeeds exiting  nor-
mally  with  exit status 0, or `0' if the command terminates
abnormally or with exit status non-zero.  If  more  detailed
information  about  the  execution  status  of  a command is
required, it can be  executed  and  the  variable  `$status'
examined  in  the  next  command.  Since `$status' is set by
every command, it is very transient. It can be saved  if  it
is  inconvenient  to  use  it only in the single immediately
following command.

     For a full list of expression components available  see
the manual section for the shell.

An Introduction to the C shell                      USD:4-39

3.6. Sample shell script

     A sample shell script which makes use of the expression
mechanism  of  the  shell  and some of its control structure
follows:

        % cat copyc
        #
        # Copyc copies those C programs in the specified list
        # to the directory ~/backup if they differ from the files
        # already in ~/backup
        #
        set backdir = ~/backup
        set noglob
        foreach i ($argv)

                if ($i !~ *.c) continue  # not a .c file so do nothing

                if (! -r $backdir/$i:t) then
                        echo $i:t not in backup... not cp'ed
                        continue
                endif

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

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

     This script makes use of  the  foreach  command,  which
causes the shell to execute the commands between the foreach
and the matching end for each of the  values  given  between
`(' and `)' with the named variable, in this case `i' set to
successive values in the list. Within this loop we  may  use
the command break to stop executing the loop and continue to
prematurely terminate one  iteration  and  begin  the  next.
After  the  foreach  loop  the iteration variable (i in this
case) has the value at the last iteration.

     We set the variable noglob  here  to  prevent  filename
expansion  of  the  members of argv. This is a good idea, in
general, if the arguments to a shell  script  are  filenames
which  have  already  been  expanded or if the arguments may
contain filename expansion metacharacters. It is also possi-
ble  to quote each use of a `$' variable expansion, but this
is harder and less reliable.

     The other control construct used here is a statement of
the form

USD:4-40                      An Introduction to the C shell

        if ( expression ) then
                command
                ...
        endif

The placement of the keywords here is not  flexible  due  to
the current implementation of the shell.-

     The shell does have another form of the if statement of
the form

        if ( expression ) command

which can be written

        if ( expression ) \
                command

Here we have escaped the newline for the sake of appearance.
The command must not involve `|', `&' or `;' and must not be
another control command. The second form requires the  final
`\' to immediately precede the end-of-line.

     The more general  if  statements  above  also  admit  a
sequence  of  else-if pairs followed by a single else and an
endif, e.g.:

        if ( expression ) then
                commands
        else if (expression ) then
                commands
        ...

        else
                commands
        endif

     Another important mechanism used in  shell  scripts  is
_________________________
-The following two formats are not currently acceptable
to the shell:

     if ( expression )               # Won't work!
     then
             command
             ...
     endif

and

     if ( expression ) then command endif            # Won't work

An Introduction to the C shell                      USD:4-41

the `:' modifier. We can  use  the  modifier  `:r'  here  to
extract  a  root of a filename or `:e' to extract the exten-
sion. Thus if the variable i has  the  value  `/mnt/foo.bar'
then

     % echo $i $i:r $i:e
     /mnt/foo.bar /mnt/foo bar
     %

shows how the `:r' modifier strips off the  trailing  `.bar'
and the `:e' modifier leaves only the `bar'. Other modifiers
will take off the last component of a pathname  leaving  the
head  `:h' or all but the last component of a pathname leav-
ing 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
argument word.

3.7. Other control structures

     The shell also has control structures while and  switch
similar to those of C. These take the forms

        while ( expression )
                commands
        end

and

_________________________
= It is also important to note that the current  imple-
mentation  of the shell limits the number of `:' modif-
iers 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

        switch ( word )

        case str1:
                commands
                breaksw

         ...

        case strn:
                commands
                breaksw

        default:
                commands
                breaksw

        endsw

For details see the manual section for  csh.  C  programmers
should  note that we use breaksw to exit from a switch while
break exits a while or foreach loop.  A  common  mistake  to
make  in  csh scripts is to use break rather than breaksw in
switches.

     Finally, csh allows a goto statement, with labels look-
ing like they do in C, i.e.:

        loop:
                commands
                goto loop

3.8. Supplying input to commands

     Commands run from shell scripts receive by default  the
standard  input  of  the  shell which is running the script.
This is different from previous shells running  under  UNIX.
It  allows  shell scripts to fully participate in pipelines,
but mandates extra notation for commands which are  to  take
inline data.

     Thus we need a metanotation for supplying  inline  data
to  commands  in shell scripts. As an example, consider this
script which runs the editor to delete leading  blanks  from
the lines in each argument file:

An Introduction to the C shell                      USD:4-43

        % cat deblank
        # deblank -- remove leading blanks
        foreach i ($argv)
        ed - $i << 'EOF'
        1,$s/^[ ]*//
        w
        q
        'EOF'
        end
        %

The notation `<< 'EOF'' means that the  standard  input  for
the  ed command is to come from the text in the shell script
file up to the next line consisting of exactly `'EOF''.  The
fact  that  the  `EOF'  is  enclosed in `'' characters, i.e.
quoted, causes the shell to not perform  variable  substitu-
tion  on  the  intervening lines. In general, if any part of
the word following the `<<' which the  shell  uses  to  ter-
minate  the  text  to be given to the command is quoted then
these substitutions will not  be  performed.  In  this  case
since  we used the form `1,$' in our editor script we needed
to ensure that this `$' was  not  variable  substituted.  We
could  also have ensured this by preceding the `$' here with
a `\', i.e.:

        1,\$s/^[ ]*//

but quoting the `EOF' terminator is a more reliable  way  of
achieving the same thing.

3.9. Catching interrupts

     If our shell script creates  temporary  files,  we  may
wish  to  catch interruptions of the shell script so that we
can clean up these files. We can then do

        onintr label

where label is a label in our program. If  an  interrupt  is
received  the shell will do a `goto label' and we can remove
the temporary files and then do an exit  command  (which  is
built  in to the shell) to exit from the shell script. If we
wish to exit with a non-zero status we can do

        exit(1)

e.g. to exit with status `1'.

3.10. What else?

     There are other features of the shell useful to writers
of  shell  procedures.  The verbose and echo options and the
related -v and -x command line options can be used  to  help

USD:4-44                      An Introduction to the C shell

trace  the  actions  of  the shell. The -n option causes the
shell only to read commands and not to execute them and  may
sometimes be of use.

     One other thing to note is that csh  will  not  execute
shell  scripts  which  do  not begin with the character `#',
that is shell scripts that do  not  begin  with  a  comment.
Similarly,  the  `/bin/sh'  on your system may well defer to
`csh' to interpret shell scripts which begin with `#'.  This
allows shell scripts for both shells to live in harmony.

     There is also another  quotation  mechanism  using  `"'
which  allows  only some of the expansion mechanisms we have
so far discussed to occur on the quoted string and serves to
make this string into a single word as `'' does.

An Introduction to the C shell                      USD:4-45

4. Other, less commonly used, shell features

4.1. Loops at the terminal; variables as vectors

     It is occasionally useful to use  the  foreach  control
structure  at  the terminal to aid in performing a number of
similar commands. For instance,  there  were  at  one  point
three  shells  in  use on the Cory UNIX system at Cory Hall,
`/bin/sh', `/bin/nsh', and `/bin/csh'. To count  the  number
of  persons  using each shell one could have issued the com-
mands

        % grep -c csh$ /etc/passwd
        27
        % grep -c nsh$ /etc/passwd
        128
        % grep -c -v sh$ /etc/passwd
        430
        %

Since these commands are very similar we can use foreach  to
do this more easily.

        % foreach i ('sh$' 'csh$' '-v sh$')
        ? grep -c $i /etc/passwd
        ? end
        27
        128
        430
        %

Note here that the shell prompts for input with  `?  '  when
reading the body of the loop.

     Very useful with  loops  are  variables  which  contain
lists of filenames or other words. You can, for example, do

        % set a=(`ls`)
        % echo $a
        csh.n csh.rm
        % ls
        csh.n
        csh.rm
        % echo $#a
        2
        %

The set command here gave the variable a a list of  all  the
filenames  in  the  current  directory as value. We can then
iterate over these names to perform any chosen function.

     The output of a command within ``' characters  is  con-
verted  by  the shell to a list of words. You can also place
the ``' quoted string within `"'  characters  to  take  each

USD:4-46                      An Introduction to the C shell

(non-empty)  line as a component of the variable; preventing
the lines from being split into words at blanks and tabs.  A
modifier  `:x' exists which can be used later to expand each
component of the variable into another variable splitting it
into separate words at embedded blanks and tabs.

4.2. Braces { ... } in argument expansion

     Another form of filename expansion, alluded to  before,
involves  the  characters  `{'  and  `}'.  These  characters
specify that the contained strings, separated by `,', are to
be  consecutively substituted into the containing characters
and the results expanded left to right. Thus

        A{str1,str2,...strn}B

expands to

        Astr1B Astr2B ... AstrnB

This expansion occurs before the other filename  expansions,
and may be applied recursively (i.e. nested). The results of
each expanded string are sorted separately,  left  to  right
order  being  preserved.  The  resulting  filenames  are not
required to exist if no other expansion mechanisms are used.
This means that this mechanism can be used to generate argu-
ments which are not filenames, but which have common parts.

     A typical use of this would be

        mkdir ~/{hdrs,retrofit,csh}

to make subdirectories `hdrs', `retrofit' and `csh' in  your
home  directory. This mechanism is most useful when the com-
mon prefix is longer than in this example, i.e.

        chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}

4.3. Command substitution

     A command enclosed in ``' characters is replaced,  just
before  filenames are expanded, by the output from that com-
mand. Thus it is possible to do

        set pwd=`pwd`

to save the current directory in the variable pwd or to do

        ex `grep -l TRACE *.c`

to run the editor ex  supplying  as  arguments  those  files
whose  names  end  in  `.c' which have the string `TRACE' in
them.*
_________________________
*Command expansion also occurs in input redirected with

An Introduction to the C shell                      USD:4-47

4.4. Other details not covered here

     In particular circumstances it may be necessary to know
the  exact  nature and order of different substitutions per-
formed by the shell. The exact meaning of  certain  combina-
tions  of  quotations  is also occasionally important. These
are detailed fully in its manual section.

     The shell has a number of  command  line  option  flags
mostly  of use in writing UNIX programs, and debugging shell
scripts. See the csh(1) manual section for a list  of  these
options.

_________________________
`<<'  and  within  `"'  quotations.  Refer to the shell
manual section for full details.

USD:4-48                      An Introduction to the C shell

Appendix - Special characters

The following table lists the special characters of csh  and
the  UNIX system, giving for each the section(s) in which it
is discussed. A number of these characters also have special
meaning  in  expressions.  See  the csh manual section for a
complete list.

Syntactic metacharacters

        ;       2.4     separates commands to be executed sequentially
        |       1.5     separates commands in a pipeline
        ( )     2.2,3.6 brackets expressions and variable values
        &       2.5     follows commands to be executed without waiting for completion

Filename metacharacters

        /       1.6     separates components of a file's pathname
        .       1.6     separates root parts of a file name from extensions
        ?       1.6     expansion character matching any single character
        *       1.6     expansion character matching any sequence of characters
        [ ]     1.6     expansion sequence matching any single character from a set
        ~       1.6     used at the beginning of a filename to indicate home directories
        { }     4.2     used to specify groups of arguments with common parts

Quotation metacharacters

        \       1.7     prevents meta-meaning of following single character
        '       1.7     prevents meta-meaning of a group of characters
        "       4.3     like ', but allows variable and command expansion

Input/output metacharacters

        <       1.5     indicates redirected input
        >       1.3     indicates redirected output

Expansion/substitution metacharacters

        $       3.4     indicates variable substitution
        !       2.3     indicates history substitution
        :       3.6     precedes substitution modifiers
        ^       2.3     used in special forms of history substitution
        `       4.3     indicates command substitution

Other metacharacters

        #       1.3,3.6 begins scratch file names; indicates shell comments
        -       1.2     prefixes option (flag) arguments to commands
        %       2.6     prefixes job name specifications

An Introduction to the C shell                      USD:4-49

Glossary

     This glossary lists the most important terms introduced
in  the  introduction  to  the shell and gives references to
sections of the shell document for further information about
them. References of the form pr(1) indicate that the command
pr is in the UNIX 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 included as a component of the search
               path contained  in  the  variable  path.  The
               character `.' is also used in separating com-
               ponents 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 historical reasons (2.3).

absolute pathname
               A pathname which begins with a `/'  is  abso-
               lute  since  it  specifies the path of direc-
               tories  from  the  beginning  of  the  entire
               directory system - called the root directory.
               Pathnames which are not absolute  are  called
               relative  (see  definition  of relative path-
               name) (1.6).

alias          An alias specifies  a  shorter  or  different

USD:4-50                      An Introduction to the C shell

               name  for a UNIX command, or a transformation
               on a command to be performed  in  the  shell.
               The  shell  has  a command alias which estab-
               lishes aliases and can  print  their  current
               values. The command unalias is used to remove
               aliases (2.4).

argument       Commands in UNIX receive a list  of  argument
               words. Thus the command

                       echo a b c

               consists of the command name `echo' and three
               argument  words  `a', `b' and `c'. The set of
               arguments after the command name is  said  to
               be the argument list of the command (1.1).

argv           The list of arguments to a command written in
               the  shell  language (a shell script or shell
               procedure) is stored  in  a  variable  called
               argv  within  the  shell.  This name is taken
               from the conventional name in the C  program-
               ming language (3.4).

background     Commands started without waiting for them  to
               complete   are   called  background  commands
               (2.6).

base           A filename is sometimes thought  of  as  con-
               sisting  of a base part, before any `.' char-
               acter, and an extension - the part after  the
               `.'.   See  filename  and extension (1.6) and
               basename(1).

bg             The bg command causes a suspended job to con-
               tinue execution in the background (2.6).

bin            A directory containing binaries  of  programs
               and shell scripts to be executed is typically
               called a bin directory. The  standard  system
               bin  directories  are  `/bin'  containing the
               most heavily  used  commands  and  `/usr/bin'
               which  contains  most  other  user  programs.
               Locally    written    programs    live     in
               `/usr/local/bin'.   Games  are  kept  in  the
               directory   `/usr/games'.   You   can   place
               binaries  in  any  directory.  If you wish to
               execute them often, the name  of  the  direc-
               tories  should be a component of the variable
               path.

break          Break is a builtin command used to exit  from
               loops  within  the  control  structure of the
               shell (3.7).

An Introduction to the C shell                      USD:4-51

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 com-
               mands are accessible 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,
               similar to that of the  language  C.  Details
               are  given  in the shell documentation csh(1)
               (3.7).

cat            The cat program concatenates a list of speci-
               fied files on the standard output. It is usu-
               ally used to look at the contents of a single
               file  on  the terminal, to `cat a file' (1.8,
               2.3).

cd             The cd command is used to change the  working
               directory. With no arguments, cd changes your
               working directory to be your  home  directory
               (2.4, 2.7).

chdir          The chdir command is a synonym for cd. Cd  is
               usually used because it is easier to type.

chsh           The chsh command is used to change the  shell
               which  you use on UNIX. By default, you use a
               different version of the shell which  resides
               in  `/bin/sh'.  You  can change your shell to
               `/bin/csh' by doing

                       chsh -s /bin/csh your-login-name

               Thus I would do

                       chsh -s /bin/csh bill

               It is only necessary to  do  this  once.  The
               next time you log in to UNIX after doing this
               command, you will be using  csh  rather  than
               the shell in `/bin/sh' (1.9).

cmp            Cmp is a program which compares files. It  is
               usually  used  on  binary files, or to see if
               two files are identical (3.6). For  comparing
               text  files  the  program  diff, described in
               diff(1) is used.

USD:4-52                      An Introduction to the C shell

command        A function performed by the system, either by
               the shell (a builtin command) or by a program
               residing in a file in a directory within  the
               UNIX system, is called a command (1.1).

command name
               When a command is issued, it  consists  of  a
               command  name, which is the first word of the
               command, followed by arguments.  The  conven-
               tion on UNIX is that the first word of a com-
               mand  names  the  function  to  be  performed
               (1.1).

command substitution
               The replacement of a command enclosed in  ``'
               characters by the text output by that command
               is called command substitution (4.3).

component      A part of a pathname between  `/'  characters
               is  called  a  component  of that pathname. A
               variable which has multiple strings as  value
               is  said  to  have  several  components; each
               string is a component of the variable.

continue       A builtin command which causes  execution  of
               the  enclosing foreach or while loop to cycle
               prematurely. Similar to the continue  command
               in the programming language C (3.6).

control-       Certain special  characters,  called  control
               characters,  are produced by holding down the
               CONTROL key on your terminal  and  simultane-
               ously  pressing  another character, much like
               the SHIFT key is used to produce  upper  case
               characters.  Thus  control-c  is  produced by
               holding down the CONTROL key  while  pressing
               the  `c'  key.   Usually UNIX prints an 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 gdb(1) in
               order to determine what went wrong  with  the
               program  (1.8).  If the shell produces a mes-
               sage of the form

                       Segmentation fault (core dumped)

               (where `Segmentation fault' is  only  one  of
               several possible messages), you should report
               this to the author of the program or a system

An Introduction to the C shell                      USD:4-53

               administrator, saving the `core' file.

cp             The cp (copy) program is  used  to  copy  the
               contents of one file into another file. It is
               one of the most commonly used  UNIX  commands
               (1.6).

csh            The name of the shell program that this docu-
               ment describes.

.cshrc         The file .cshrc in  your  home  directory  is
               read by each shell as it begins execution. It
               is usually used to change the setting of  the
               variable  path  and  to  set alias parameters
               which are to take effect globally (2.1).

cwd            The cwd variable in the shell holds the abso-
               lute  pathname  of the current working direc-
               tory. It is changed  by  the  shell  whenever
               your  current  working  directory changes and
               should not be changed otherwise (2.2).

date           The date command prints the current date  and
               time (1.3).

debugging      Debugging is the process of  correcting  mis-
               takes  in  programs  and  shell  scripts. The
               shell has several options and variables which
               may be used to aid in shell debugging (4.4).

default:       The  label  default:  is  used  within  shell
               switch   statements,   as  it  is  in  the  C
               language, to label the code to be executed if
               none  of  the  case  labels matches the value
               switched on (3.7).

DELETE         The DELETE or RUBOUT key on the terminal nor-
               mally  causes  an interrupt to be sent to the
               current job. Most  users  map  the  interrupt
               character to ^C.

detached       A command that continues running in the back-
               ground  after  you  log  out  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 out-
               put,  since  that is often directed away from
               the terminal (1.3, 1.5). Error  messages  are
               instead  written  to  the  diagnostic  output
               which may be directed away from the terminal,
               but  usually  is  not.  Thus diagnostics will
               usually appear on the terminal (2.5).

USD:4-54                      An Introduction to the C shell

directory      A structure which contains files. At any time
               you  are  in  one  particular directory whose
               name can be printed by the command  pwd.  The
               chdir  command  will  change  you  to another
               directory, and make the files in that  direc-
               tory  visible. The directory in which you are
               when you first log in 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  command.   The  directory stack can be
               printed by  using  the  dirs  command,  which
               includes  your  current  working directory as
               the first directory name on the left (2.7).

dirs           The dirs command prints the shell's directory
               stack (2.7).

du             The du command is  a  program  (described  in
               du(1)) which prints the number of disk blocks
               is all directories below and  including  your
               current working directory (2.6).

echo           The echo command prints its  arguments  (1.6,
               3.6).

else           The else command is  part  of  the  `if-then-
               else-endif' control command construct (3.6).

endif          If an if statement is  ended  with  the  word
               then, all lines following the if up to a line
               starting with the word endif or else are exe-
               cuted  if  the  condition between parentheses
               after the if is true (3.6).

EOF            An end-of-file is generated by  the  terminal
               by  a control-d, and whenever a command reads
               to the end of a file which it has been  given
               as  input.  Commands  receiving  input from a
               pipe receive an end-of-file when the  command
               sending  them  input completes. Most commands
               terminate when they receive  an  end-of-file.
               The shell has an option to ignore end-of-file
               from a terminal input which may help you keep
               from  logging  out accidentally by typing too
               many control-d's (1.1, 1.8, 3.8).

escape         A character `\' used to prevent  the  special
               meaning  of a metacharacter is said to escape
               the character from its special meaning. Thus

                       echo \*

An Introduction to the C shell                      USD:4-55

               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 char-
               acter  called escape, usually labelled ESC or
               ALTMODE on  terminal  keyboards.  Some  older
               UNIX  systems  use this character to indicate
               that output is to be suspended. Most  systems
               use   control-s   to   stop  the  output  and
               control-q to start it.

/etc/passwd    This  file  contains  information  about  the
               accounts currently on the system. It consists
               of  a  line  for  each  account  with  fields
               separated  by  `:'  characters (1.8). You can
               look at this file by saying

                       cat /etc/passwd

               The commands finger and grep are  often  used
               to  search  for information in this file. See
               finger(1), passwd(5), and  grep(1)  for  more
               details.

exit           The exit command is used to force termination
               of  a  shell  script,  and  is built into the
               shell (3.9).

exit status    A  command  which  discovers  a  problem  may
               reflect  this  back to the command (such as a
               shell) which invoked (executed) it.  It  does
               this  by  returning  a non-zero number as its
               exit status, a  status  of  zero  being  con-
               sidered  `normal  termination'. The exit com-
               mand can be used to  force  a  shell  command
               script to give a non-zero exit status (3.6).

expansion      The replacement of strings in the shell input
               which contain metacharacters by other strings
               is referred to as the process  of  expansion.
               Thus  the  replacement  of  the word `*' by a
               sorted list of files in the current directory
               is  a  `filename  expansion'.  Similarly  the
               replacement of the  characters  `!!'  by  the
               text of the last command is a `history expan-
               sion'. Expansions are  also  referred  to  as
               substitutions (1.6, 3.4, 4.2).

expressions    Expressions are used in the shell to  control
               the  conditional structures used in the writ-
               ing  of  shell  scripts  and  in  calculating

USD:4-56                      An Introduction to the C shell

               values   for  these  scripts.  The  operators
               available in shell expressions are  those  of
               the language C (3.5).

extension      Filenames often consist of a base name and an
               extension  separated by the character `.'. By
               convention, groups  of  related  files  often
               share  the  same  root name. Thus if `prog.c'
               were a C program, then the  object  file  for
               this  program  would  be  stored in `prog.o'.
               Similarly a  paper  written  with  the  `-me'
               nroff   macro  package  might  be  stored  in
               `paper.me' while a formatted version of  this
               paper might be kept in `paper.out' and a list
               of spelling errors in `paper.errs' (1.6).

fg             The job control command fg is used to  run  a
               background or suspended job in the foreground
               (1.8, 2.6).

filename       Each file in UNIX has a name consisting of up
               to  14 characters and not including the char-
               acter `/' which is used in pathname building.
               Most  filenames do not begin with the charac-
               ter `.', and contain only letters and  digits
               with  perhaps  a `.' separating the base por-
               tion of the filename from an extension (1.6).

filename expansion
               Filename expansion  uses  the  metacharacters
               `*',  `?'  and  `[' and `]' to provide a con-
               venient mechanism  for  naming  files.  Using
               filename expansion it is easy to name all the
               files in the current directory, or all  files
               which have a common root name. Other filename
               expansion mechanisms  use  the  metacharacter
               `~'  and  allow  files in other users' direc-
               tories to be named easily (1.6, 4.2).

flag           Many UNIX commands accept arguments which are
               not the names of files or other users but are
               used to modify the action  of  the  commands.
               These are referred to as flag options, and by
               convention consist of  one  or  more  letters
               preceded by the character `-' (1.2). Thus the
               ls (list files) command has an option `-s' to
               list the sizes of files. This is specified

                       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

An Introduction to the C shell                      USD:4-57

               certain   shell  variable  ranges  through  a
               specified list (3.6, 4.1).

foreground     When commands are executing in the normal way
               such  that  the  shell is waiting for them to
               finish before prompting for  another  command
               they  are  said to be foreground jobs or run-
               ning in the foreground. This is as opposed to
               background. Foreground jobs can be stopped by
               signals from the terminal  caused  by  typing
               different  control characters at the keyboard
               (1.8, 2.6).

goto           The shell has a command goto  used  in  shell
               scripts  to transfer control to a given label
               (3.7).

grep           The grep command searches through a  list  of
               argument files for a specified string. Thus

                       grep bill /etc/passwd

               will print each line in the file  /etc/passwd
               which  contains  the string `bill'. Actually,
               grep scans for  regular  expressions  in  the
               sense  of  the  editors ed(1) and ex(1). Grep
               stands for `globally find regular  expression
               and print' (2.4).

head           The head command prints the first  few  lines
               of  one or more files. If you have a bunch of
               files containing text which you are wondering
               about it is sometimes useful to run head with
               these files as arguments. This  will  usually
               show  enough of what is in these files to let
               you decide which you are interested in (1.5).
               Head is also used to describe the part  of  a
               pathname  before  and  including the last `/'
               character.  The tail of  a  pathname  is  the
               part  after  the last `/'.  The `:h' and `:t'
               modifiers allow the head or tail of  a  path-
               name  stored  in  a shell variable to be used
               (3.6).

history        The history mechanism  of  the  shell  allows
               previous  commands  to  be repeated, possibly
               after modification to correct typing mistakes
               or  to change the meaning of the command. The
               shell has a history list where these commands
               are  kept,  and a history variable which con-
               trols how large this list is (2.3).

home directory
               Each user has  a  home  directory,  which  is

USD:4-58                      An Introduction to the C shell

               given  in  your  entry  in the password file,
               /etc/passwd. This is the directory which  you
               are  placed  in when you first log in. The cd
               or chdir command with no arguments takes  you
               back   to   this  directory,  whose  name  is
               recorded in the shell variable home. You  can
               also  access  the  home  directories of other
               users in forming filenames using  a  filename
               expansion  notation  and  the  character  `~'
               (1.6).

if             A conditional command within the  shell,  the
               if  command  is used in shell command scripts
               to make decisions about what course of action
               to take next (3.6).

ignoreeof      Normally,  your  shell  will  exit,  printing
               `logout'  if you type a control-d at a prompt
               of `% '. This is the way you usually log  off
               the  system.  You can set the ignoreeof vari-
               able if you wish in your .login file and then
               use  the  command  logout to log out. This is
               useful if you sometimes accidentally type too
               many  control-d  characters, logging yourself
               off (2.2).

input          Many commands on UNIX take  information  from
               the  terminal  or  from files which they then
               act on. This  information  is  called  input.
               Commands normally read input from their stan-
               dard input which is, by default,  the  termi-
               nal.  This  standard  input can be redirected
               from a file using a shell  metanotation  with
               the  character  `<'.  Many commands will also
               read from a file specified  as  an  argument.
               Commands  placed  in pipelines will read 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  standard  input.  Special  mechanisms
               exist  for  supplying  input  to  commands in
               shell scripts (1.5, 3.8).

interrupt      An interrupt is a signal to a program that is
               generated by typing ^C. (On older versions of
               UNIX the RUBOUT or DELETE key were  used  for
               this  purpose.)  It  causes  most programs to
               stop execution. Certain programs, such as the
               shell and the editors, 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

An Introduction to the C shell                      USD:4-59

               not listen to  interrupts.  The  shell  often
               wakes  up when you hit interrupt because many
               commands die when they receive  an  interrupt
               (1.8, 3.9).

job            One or more commands typed on the same  input
               line  separated  by `|' or `;' characters are
               run together and are  called  a  job.  Simple
               commands run by themselves without any `|' or
               `;' characters are the  simplest  jobs.  Jobs
               are  classified as foreground, background, or
               suspended (2.6).

job control    The builtin functions that control the execu-
               tion of jobs are called job control commands.
               These are bg, fg, stop, and kill (2.6).

job number     When each job is started  it  is  assigned  a
               small  number  called  a  job number which is
               printed next to the job in the output of  the
               jobs command.  This number, preceded by a `%'
               character, can be used as an argument to  job
               control  commands  to indicate a specific job
               (2.6).

jobs           The jobs command prints a table showing  jobs
               that  are either running in the background or
               are suspended (2.6).

kill           A command which sends a signal to a job caus-
               ing it to terminate (2.6).

.login         The file .login in  your  home  directory  is
               read  by  the  shell  each time you log in to
               UNIX and the  commands  there  are  executed.
               There are a number of commands which are use-
               fully placed here, especially set commands to
               the shell itself (2.1).

login shell    The shell that is started  on  your  terminal
               when  you  log in is called your login shell.
               It is different from other shells  which  you
               may  run  (e.g.  on shell scripts) in that it
               reads the .login file before reading commands
               from  the  terminal  and it reads the .logout
               file after you log out (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 your .login
               file then this will not work and you must use
               logout to log off the UNIX system (2.8).

USD:4-60                      An Introduction to the C shell

.logout        When you log off UNIX the shell will  execute
               commands  from  the file .logout in your home
               directory after it prints `logout'.

lpr            The command lpr is the line  printer  daemon.
               The standard input of lpr spooled and printed
               on the UNIX line printer. You can  also  give
               lpr  a  list  of filenames as arguments to be
               printed. It is most common to use lpr as  the
               last component of a pipeline (2.3).

ls             The ls (list files) command  is  one  of  the
               most  commonly  used  UNIX  commands. With no
               argument filenames it prints the names of the
               files  in  the  current  directory.  It has a
               number of useful flag arguments, and can also
               be  given  the  names of directories as argu-
               ments, in which case it lists  the  names  of
               the files in these directories (1.2).

mail           The mail program is used to send and  receive
               messages  from  other  UNIX users (1.1, 2.1),
               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 performed on these files. In many  ways
               make  is easier to use, and more helpful than
               shell command scripts (3.2).

makefile       The file  containing  commands  for  make  is
               called makefile or Makefile (3.2).

manual         The manual often referred  to  is  the  `UNIX
               manual'. It contains 9 numbered sections with
               a description of each UNIX  program  (section
               1), system call (section 2), subroutine (sec-
               tion 3), device  (section  4),  special  data
               structure (section 5), game (section 6), mis-
               cellaneous item (section 7), system  adminis-
               tration   program  (section  8),  and  kernel
               internals (section 9). There are also supple-
               mentary  documents  (tutorials  and reference
               guides) for individual programs which 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 supple-
               mentary documents are  in  subdirectories  of

An Introduction to the C shell                      USD:4-61

               /usr/doc.

metacharacter
               Many characters which are neither letters nor
               digits  have  special  meaning  either to the
               shell or to UNIX. These characters are called
               metacharacters.  If  it is necessary to 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 mechan-
               ism,  most   unquoted   metacharacters   form
               separate  words  (1.4).  The appendix to this
               user's manual  lists  the  metacharacters  in
               groups by their function.

mkdir          The mkdir command is used  to  create  a  new
               directory.

modifier       Substitutions  with  the  history  mechanism,
               keyed  by  the  character `!' or of variables
               using the metacharacter `$', are  often  sub-
               jected to modifications, indicated by placing
               the character `:' after the substitution  and
               following  this with the modifier itself. The
               command substitution mechanism  can  also  be
               used  to  perform  modification  in a similar
               way, but this notation is less clear (3.6).

more           The program more writes a file on your termi-
               nal  allowing you to control how much text is
               displayed at a time. More  can  move  through
               the  file screen-full by screen-full, line by
               line, search forward for a string,  or  start
               again  at  the  beginning  of the file. It is
               generally the easiest way of viewing  a  file
               (1.8).

noclobber      The shell has a variable noclobber which  may
               be set in the file .login to prevent acciden-
               tal destruction of files by  the  `>'  output
               redirection  metasyntax  of  the  shell (2.2,
               2.5).

noglob         The shell variable noglob is set to  suppress
               the  filename expansion of arguments contain-
               ing the metacharacters `~', `*', `?', `[' and
               `]' (3.6).

notify         The notify command tells the shell to  report
               on  the  termination of a specific background
               job at the exact time it occurs as opposed to

USD:4-62                      An Introduction to the C shell

               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 out-
               put is usually placed on what is known as the
               standard  output, which is normally connected
               to the user's terminal. The shell has a  syn-
               tax using the metacharacter `>' for redirect-
               ing the standard output of  a  command  to  a
               file  (1.3). Using the pipe mechanism and the
               metacharacter `|' it is also possible for the
               standard  output of one command to become the
               standard input of another command (1.5). Cer-
               tain commands such as the line printer daemon
               lpd do not place their results on  the  stan-
               dard  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 stan-
               dard output (2.3). Commands also have a diag-
               nostic 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 possible
               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 buil-
               tin,  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    (/bin /usr/bin .)

               the shell normally looks in the standard sys-
               tem  directories  `/bin'  and `/usr/bin', and
               then the current  directory,  for  the  named

An Introduction to the C shell                      USD:4-63

               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 nor-
               mally 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 direc-
               tory in the path, you should issue  the  com-
               mand rehash (2.2).

pathname       A list of names, separated by `/' characters,
               forms  a  pathname.  Each  component, between
               successive `/' characters, names a  directory
               in  which  the  next  component file resides.
               Pathnames which begin with the character  `/'
               are  interpreted  relative to the root direc-
               tory in the filesystem. Other  pathnames  are
               interpreted relative to the current directory
               as reported by pwd. The last component  of  a
               pathname  may  name  a directory, but usually
               names a file.

pipeline       A  group  of  commands  which  are  connected
               together,  the  standard  output of each con-
               nected to the standard input of the next,  is
               called a pipeline. The pipe mechanism used to
               connect these commands is  indicated  by  the
               shell metacharacter `|' (1.5, 2.3).

popd           The popd command changes the shell's  working
               directory  to the directory you most recently
               left using the pushd command.  It returns  to
               the  directory  without  having  to  type its
               name, forgetting  the  name  of  the  current
               working directory before doing so (2.7).

port           The part of a computer system to  which  each
               terminal  is connected is called a port. Usu-
               ally the system has a fixed number of  ports,
               some  of  which  are  connected  to telephone
               lines for dial-up access, and some  of  which
               are  permanently  wired  directly to specific
               terminals.

pr             The pr command is used to prepare listings of
               the contents of files with headers giving the
               name of the file and the  date  and  time  at
               which the file was last modified (2.3).

printenv       The printenv command is  used  to  print  the

USD:4-64                      An Introduction to the C shell

               current  setting of variables in the environ-
               ment (2.8).

process        An instance of a running program is called  a
               process  (2.6).  UNIX  assigns each process a
               unique number when it is started - called the
               process  number.  Process numbers can be used
               to stop individual processes using  the  kill
               or  stop commands when the processes are part
               of a detached background job.

program        Usually synonymous  with  command;  a  binary
               file or shell command script which performs a
               useful function is often called a program.

prompt         Many programs will print a prompt on the ter-
               minal 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  dif-
               ferent  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  direc-
               tory',  changes the shell's working directory
               and also remembers the current working direc-
               tory  before the change is made, allowing you
               to return to the same directory via the  popd
               command   later  without  retyping  its  name
               (2.7).

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 iden-
               tified  by  printing  some  of the words used
               when it was invoked (2.6).

pwd            The pwd command prints the full  pathname  of
               the current working directory. The dirs buil-
               tin command is usually a  better  and  faster
               choice.

quit           The quit signal, generated by a control-\, is
               used to terminate programs which are behaving
               unreasonably. It  normally  produces  a  core

An Introduction to the C shell                      USD:4-65

               image file (1.8).

quotation      The  process  by  which  metacharacters   are
               prevented  their  special meaning, usually by
               using the character `'' in pairs, or by using
               the  character  `\', is referred to as quota-
               tion (1.7).

redirection    The routing of input or output from or  to  a
               file is known as redirection of input or out-
               put (1.3).

rehash         The rehash command tells the shell to rebuild
               its  internal  table  of  which  commands are
               found in which directories in your path. This
               is  necessary when a new program is installed
               in one of these directories (2.8).

relative pathname
               A pathname which does not begin with a `/' is
               called a relative pathname since it is inter-
               preted relative to the current working direc-
               tory.  The first component of such a pathname
               refers to some file or directory in the work-
               ing   directory,  and  subsequent  components
               between `/' characters refer  to  directories
               below  the  working directory. Pathnames that
               are not relative are  called  absolute  path-
               names (1.6).

repeat         The repeat command iterates another command a
               specified number of times.

root           The directory that  is  at  the  top  of  the
               entire directory structure is called the root
               directory since  it  is  the  `root'  of  the
               entire  tree  structure  of directories.  The
               name used in pathnames to indicate  the  root
               is  `/'. Pathnames starting with `/' are said
               to be absolute since they start at  the  root
               directory. Root is also used as the part of a
               pathname that  is  left  after  removing  the
               extension.  See filename for a further expla-
               nation (1.6).

RUBOUT         The RUBOUT or DELETE key  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

USD:4-66                      An Introduction to the C shell

               couple of days of non-use, or more frequently
               if disk space becomes tight (1.3).

script         Sequences of shell commands placed in a  file
               are called shell command scripts. It is often
               possible to perform simple tasks using  these
               scripts   without  writing  a  program  in  a
               language such as C, by  using  the  shell  to
               selectively run other programs (3.3, 3.10).

set            The builtin set command is used to assign new
               values  to  shell  variables  and to show the
               values of the current variables.  Many  shell
               variables  have  special meaning to the shell
               itself. Thus by using  the  set  command  the
               behavior of the shell can be affected (2.1).

setenv         Variables in the environment  environ(5)  can
               be  changed  by using the setenv builtin com-
               mand (2.8). The printenv command can be  used
               to  print  the  value of the variables in the
               environment.

shell          A shell is a command language interpreter. It
               is  possible to write and run your own shell,
               as shells are no  different  than  any  other
               programs  as  far as the system is concerned.
               This manual deals with  the  details  of  one
               particular shell, called csh.

shell script   See script (3.3, 3.10).

signal         A signal in UNIX is a short message  that  is
               sent  to a running program which causes some-
               thing to happen to that process. Signals  are
               sent either by typing special control charac-
               ters on the keyboard or by using the kill  or
               stop commands (1.8, 2.6).

sort           The sort program sorts a sequence of lines in
               ways that can be controlled by argument flags
               (1.5).

source         The source command causes the shell  to  read
               commands  from  a  specified file. It is most
               useful for reading files such as .cshrc after
               changing them (2.8).

special character
               See metacharacters and the appendix  to  this
               manual.

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

An Introduction to the C shell                      USD:4-67

               output (1.3, 3.8).

status         A command normally returns a status  when  it
               finishes.  By  convention  a  status  of zero
               indicates that the  command  succeeded.  Com-
               mands  may return non-zero status to indicate
               that some abnormal event  has  occurred.  The
               shell  variable  status  is set to the status
               returned by the last command. It is most use-
               ful in shell command scripts (3.6).

stop           The stop command causes a background  job  to
               become suspended (2.6).

string         A  sequential  group  of   characters   taken
               together is called a string. Strings can con-
               tain any printable characters (2.2).

stty           The stty program changes  certain  parameters
               inside UNIX which determine how your terminal
               is  handled.   See  stty(1)  for  a  complete
               description (2.6).

substitution   The shell implements a  number  of  substitu-
               tions  where sequences indicated by metachar-
               acters are replaced by other sequences.  Not-
               able  examples  of this are history substitu-
               tion keyed by the metacharacter `!' and vari-
               able  substitution  indicated by `$'. We also
               refer to substitutions as expansions (3.4).

suspended      A job becomes suspended after a  STOP  signal
               is  sent  to it, either by typing a control-z
               at the terminal (for foreground jobs)  or  by
               using the stop command (for background jobs).
               When suspended, a job temporarily stops  run-
               ning  until  it is restarted by either the fg
               or bg command (2.6).

switch         The switch command of the  shell  allows  the
               shell  to select one of a number of sequences
               of commands based on an argument  string.  It
               is  similar  to  the  switch statement in the
               language C (3.7).

termination    When a command which is being  executed  fin-
               ishes we say it undergoes termination or ter-
               minates.  Commands  normally  terminate  when
               they  read an end-of-file from their standard
               input. It is also possible to terminate  com-
               mands  by  sending  them an interrupt or quit
               signal (1.8).  The  kill  program  terminates
               specified jobs (2.6).

USD:4-68                      An Introduction to the C shell

then           The then command is part of the shell's  `if-
               then-else-endif'  control  construct  used in
               command scripts (3.6).

time           The time command can be used to  measure  the
               amount  of  CPU  and  real time consumed by a
               specified command as well as  the  amount  of
               disk I/O, memory utilized, and number of page
               faults and swaps taken by the  command  (2.1,
               2.8).

tset           The tset program  is  used  to  set  standard
               erase  and  kill  characters  and to tell the
               system what kind of terminal you  are  using.
               It is often invoked in a .login file (2.1).

tty            The word tty is a historical abbreviation for
               `teletype'  which  is frequently used in UNIX
               to indicate the port to which a given  termi-
               nal is connected.  The tty command will print
               the name of the tty or  port  to  which  your
               terminal is presently connected.

unalias        The unalias command removes aliases (2.8).

UNIX           UNIX is an  operating  system  on  which  csh
               runs.  UNIX  provides  facilities which allow
               csh to invoke other programs such as  editors
               and  text  formatters  which  you may wish to
               use.

unset          The unset command removes the definitions  of
               shell variables (2.2, 2.8).

variable expansion
               See variables and expansion (2.2, 3.4).

variables      Variables in csh hold one or more strings  as
               value. The most common use of variables is in
               controlling the behavior of  the  shell.  See
               path,  noclobber, and ignoreeof for examples.
               Variables such as argv are also used in writ-
               ing  shell  programs  (shell command scripts)
               (2.2).

verbose        The verbose shell  variable  can  be  set  to
               cause  commands  to  be echoed after they are
               history expanded. This  is  often  useful  in
               debugging shell scripts. The verbose variable
               is set by the shell's -v command line  option
               (3.10).

wc             The wc program calculates the number of char-
               acters,  words,  and lines in the files whose

An Introduction to the C shell                      USD:4-69

               names are given as arguments (2.6).

while          The while builtin control construct  is  used
               in shell command scripts (3.7).

word           A sequence of characters which forms an argu-
               ment  to  a  command  is  called a word. Many
               characters which are neither letters, digits,
               `-', `.' nor `/' form words all by themselves
               even if they are not  surrounded  by  blanks.
               Any sequence of characters may be made into a
               word by surrounding it  with  `''  characters
               except  for  the characters `'' and `!' which
               require special treatment (1.1). This process
               of   placing   special  characters  in  words
               without their special meaning is called quot-
               ing.

working directory
               At any given time you are in  one  particular
               directory,  called  your  working  directory.
               This directory's name is printed by  the  pwd
               command  and  the  files listed by ls are the
               ones in this directory. You can change  work-
               ing directories using chdir.

write          The write command is an obsolete way of  com-
               municating 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.

Generated on 2021-12-07 11:28:18 by $MirOS: src/scripts/roff2htm,v 1.103 2021/01/23 20:24:35 tg Exp $ — This product includes material provided by mirabilos.

These manual pages and other documentation are copyrighted by their respective writers; their sources are available at the project’s CVSweb, AnonCVS and other mirrors. The rest is Copyright © 2002–2021 MirBSD.

This manual page’s HTML representation is supposed to be valid XHTML/1.1; if not, please send a bug report — diffs preferred.