








               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(R) 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  fea-
     tures  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 sec-
     ond  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  nec-
     essary 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
primary purpose of csh is to translate command  lines  typed
at  a  terminal  into  system actions, such as invocation of
other programs.  Csh is a user program  just  like  any  you
might  write.   Hopefully, csh will be a very useful program
for you in interacting with the UNIX system.

     In addition to this document, you will want to refer to
a   copy  of  the  UNIX  User  Reference  Manual.   The  csh









USD:4-2                       An Introduction to the C shell


documentation in section 1 of the  manual  provides  a  full
description  of all features of the shell and is the defini-
tive reference for questions about the shell.

     Many words in  this  document  are  shown  in  italics.
These  are  important  words;  names  of commands, and words
which have special meaning in discussing the shell and UNIX.
Many  of  the  words are defined in a glossary at the end of
this document.  If you don't know what is meant by  a  word,
you should look for it in the glossary.

Acknowledgements

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




































An Introduction to the C shell                       USD:4-3


1.  Terminal usage of the shell

1.1.  The basic notion of commands

     A shell in UNIX acts mostly as a medium  through  which
other  programs  are invoked.  While it has a set of builtin
functions which it performs directly,  most  commands  cause
execution  of  programs  that  are, in fact, external to the
shell.  The shell is thus  distinguished  from  the  command
interpreters  of  other  systems both by the fact that it is
just a user program, and by the fact that it is used  almost
exclusively as a mechanism for invoking other programs.

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

     mail bill

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

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

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


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

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









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
signalled an end-of-file via typing a  ^D  after  which  the
shell  noticed  that mail had completed and signaled us that
it was ready to read from the  terminal  again  by  printing
another `% ' prompt.

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

     An  example  of a useful command you can execute now is
the tset command, which sets  the  default  erase  and  kill
characters on your terminal - the erase character erases the
last character you typed and the kill character  erases  the
entire  line you have entered so far.  By default, the erase
character is 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 metacharac-
ter  `>'  and  the  name  of  the file where output is to be
placed.  Thus the command

     date > now

runs the date command such that its standard output  is  the
file  `now'  rather  than  the  terminal.  Thus this command
places the current date and time into the file `now'.  It is
important to know that the date command was unaware that its
output was going to a file rather than to the terminal.  The
shell  performed  this  redirection before the command began
executing.

     One other thing to note here is  that  the  file  `now'
need  not have existed before the date command was executed;
the shell would have created the file if it did  not  exist.
And  if  the  file  did exist?  If it had existed previously
these previous contents would have been discarded!  A  shell
option noclobber exists to prevent this from happening acci-
dentally; 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) stan-
dard erase character 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,









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 let-
ters 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

then the sort program would sort  lines  from  its  standard
-----------
your  erase character should be a ^H, as we demon-
strated in section 1.1 how this could be set up.









An Introduction to the C shell                       USD:4-7


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

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

     ls -s

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

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

     ls -s | sort -n

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

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

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

     The notation introduced above is called the pipe mecha-
nism.  Commands separated by `|'  characters  are  connected
together by the shell and the standard output of each is run
into the standard input of the next.  The  leftmost  command
in a pipeline will normally take its standard input from the
terminal and the rightmost will place its standard output on
the  terminal.   Other  examples  of pipelines will be given
later when we discuss the history mechanism;  one  important
use of pipes which is illustrated there is in the 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  char-
acters  except  `/'  (slash) may appear in filenames.  It is
inconvenient to have most non-alphabetic characters in file-
names  because  many  of  these  have special meaning to the
shell.  The character `.' (period) is not a  shell-metachar-
acter  and is often used to separate the extension of a file
name from the base of the name.  Thus

     prog.c prog.o prog.errs prog.output

are four related files.  They share a base portion of a name
(a  base  portion  being  that part of the name that is left
when a trailing `.' and following characters which  are  not
`.'  are  stripped  off).   The  file  `prog.c' might be the
source for a C program, the file `prog.o' the  corresponding
object  file, the file `prog.errs' the errors resulting from
a compilation of the program and the file `prog.output'  the
output of a run of the program.

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

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

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

     echo ? ?? ???

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

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

     prog.[co]

will match

     prog.c prog.o

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

     chap.[1-5]

might match files

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

if they existed.  This is shorthand for

     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 `*' or `?' or the `['  `]'  mechanism  will  match  it.
This  prevents  accidental matching of the filenames `.' and
`..'  in the working directory which have special meaning to
the  system, as well as other files such as .cshrc which are
not normally visible.  We will discuss the special  role  of
the file .cshrc later.

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

     cp thatfile ~

the shell will expand this command to

     cp thatfile /usr/bill

since my home directory is /usr/bill.

     There  also exists a mechanism using the characters `{'
and `}' for abbreviating a set of words  which  have  common
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 com-
mand

     echo *

will not echo the character `*'.  It  will  either  echo  an
sorted  list  of filenames in the current working directory,
or print the message `No match' if there are no files in the
working directory.

     The  recommended mechanism for placing characters which
are neither numbers, digits, `/', `.' or `-' in an  argument
word  to  a  command  is to enclose it with single quotation
characters `'', i.e.

     echo '*'

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

     echo \'\!

prints

     '!

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

     echo \''*'

which prints

     '*

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

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  com-
mands rather than terminating like cat did, which would have
the effect of logging you out.

     Another way in which many programs  terminate  is  when
they get an end-of-file from their standard input.  Thus the
mail 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  acci-
dentally  log us off, the shell has a mechanism for prevent-
ing this.  This ignoreeof option will be discussed  in  sec-
tion 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 `pre-
pared.text'  in which we placed a message for `bill' with an
editor program.  We could also have done

     cat prepared.text | mail bill

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

     Another  possibility  for stopping a command is to sus-
pend its execution  temporarily,  with  the  possibility  of
-----------
*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


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

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

In this example someone was sending a message to Harold  and
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 `Stopped' and
prompted for a new command.  Then the ls command  was  typed
to  find out the name of the file.  The jobs command was run
to find out which command was suspended. At this time the fg
command was typed to continue 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 signals.
More  information on suspending jobs and controlling them is
given in section 2.6.











USD:4-14                      An Introduction to the C shell


     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 termi-
nated 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  screenful  and
types  `--More--'  at which point you can hit a space to get
another screenful, a return to get another line,  a  `?'  to
get  some  help  on other commands, or a `q' to end the more
program.  You can also use more as a filter, i.e.

     cat /etc/passwd | more

works just like the more simple more command above.

     For stopping output of commands not involving more  you
can  use  the  ^S key to stop the typeout.  The typeout will
resume when you hit ^Q or any other key, but ^Q is  normally
used because it only restarts the output and does not become
input to the program which is running.  This works  well  on
low-speed  terminals, but at 9600 baud it is hard to type ^S
and ^Q fast enough to paginate the output nicely, and a 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
suffer through the output on a slow terminal; ^O is  a  tog-
gle,  so flushing can be turned off by typing ^O again while









An Introduction to the C shell                      USD:4-15


output is being flushed.

1.9.  What now?

     We have so far seen a number of mechanisms of the shell
and  learned  a lot about the way in which it operates.  The
remaining sections will go yet further into the internals of
the  shell,  but you will surely want to try using the shell
before you go any further.  To try it you can log in to UNIX
and type the following command to the system:

     chsh myname /bin/csh

Here  `myname'  should  be replaced by the name you typed to
the system prompt of `login:' to get onto the system.   Thus
I  would use `chsh bill /bin/csh'.  You only have to do this
once; it takes effect at next login.  You are now  ready  to
try using csh.

     Before  you  do  the  `chsh' command, the shell you are
using when you log into the system is `/bin/sh'.   In  fact,
much  of  the  above  discussion is applicable to `/bin/sh'.
The next section will introduce many features particular  to
csh  so you should change your shell to csh before you begin
reading it.






































USD:4-16                      An Introduction to the C shell


2.  Details on the shell for terminal users

2.1.  Shell startup and termination

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

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

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


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

     biff y

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

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









An Introduction to the C shell                      USD:4-17


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

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

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

2.2.  Shell variables

     The shell maintains a set of variables.  We  saw  above
the  variables  history  and  time which had values `10' and
`15'.  In fact, each shell variable has as value an array of
zero  or more strings.  Shell variables may be assigned val-
ues by the set command.  It has several forms, the most use-
ful 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  mecha-
nism.   The  shell  variables  most commonly referenced are,
however, those which the shell itself refers to.  By  chang-
ing  the  values  of these variables one can directly affect
the behavior of the shell.

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













USD:4-18                      An Introduction to the C shell


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

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

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

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

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

     set

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

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

     rehash

to the shell, which will cause it to recompute its  internal
table  of  command locations, so that it will find the newly
added 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
-----------
   Another directory that might  interest  you  is
/usr/new, which contains many useful user-contrib-
uted programs provided with Berkeley Unix.









An Introduction to the C shell                      USD:4-19


overhead.

     Other  useful  built in variables are the variable home
which shows your home directory,  cwd  which  contains  your
current  working directory, the variable ignoreeof which can
be set in your .login file to tell the  shell  not  to  exit
when   it  receives  an  end-of-file  from  a  terminal  (as
described above).  The variable `ignoreeof' is one  of  sev-
eral variables which the shell does not care about the value
of, only whether they are set or unset.  Thus  to  set  this
variable you simply do

     set ignoreeof

and to unset it do

     unset ignoreeof

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

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

     > filename

which  redirects the standard output of a command will over-
write 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.



-----------
The space between the `!' and the  word  `now'  is
critical here, as `!now' would be an invocation of
the history mechanism, and have a totally  differ-
ent effect.









USD:4-20                      An Introduction to the C shell


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
forming new commands.  This mechanism can be used to  repeat
previous  commands  or  to  correct minor typing mistakes in
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,
referring  to the file again as `!$', meaning the last argu-
ment 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 com-
mand, as it would have been typed without use of the history
mechanism,  and  then  executed it.  The compilation yielded
error diagnostics so we now run the editor on  the  file  we
were  trying to compile, fix the bug, and run the C compiler
again, this time referring to this command simply  as  `!c',
which repeats the last command which started with the letter
`c'.  If there were other commands starting  with  `c'  done
recently  we  could  have  said  `!cc' or even `!cc:p' which
would have printed the last command starting with `cc' with-
out executing it.

     After  this recompilation, we ran the resulting `a.out'
file, and then noting that there still was a  bug,  ran  the
editor  again.   After  fixing the program we ran the C 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
`num' command on the file `bug.c'.  In order to compress out
blank lines in the output of `num' we ran the output through
the filter `ssp', but misspelled it as spp.  To correct this
we  used  a  shell  substitute, placing the old text and new
text between `^' 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.









An Introduction to the C shell                      USD:4-21



     % cat bug.c
     main()

     {
          printf("hello);
     }
     % cc !$
     cc bug.c
     "bug.c", line 4: newline in string or char constant
     "bug.c", line 5: syntax error
     % ed !$
     ed bug.c
     29
     4s/);/"&/p
             printf("hello");
     w
     30
     q
     % !c
     cc bug.c
     % a.out
     hello% !e
     ed bug.c
     30
     4s/lo/lo\\n/p
             printf("hello\n");
     w
     32
     q
     % !c -o bug
     cc bug.c -o bug
     % size a.out bug
     a.out: 2784+364+1028 = 4176b = 0x1050b
     bug: 2784+364+1028 = 4176b = 0x1050b
     % ls -l !*
     ls -l a.out bug
     -rwxr-xr-x 1 bill       3932 Dec 19 09:41 a.out
     -rwxr-xr-x 1 bill       3932 Dec 19 09:42 bug
     % bug
     hello
     % num bug.c | spp
     spp: Command not found.
     % ^spp^ssp
     num bug.c | ssp
         1     main()
         3     {
         4          printf("hello\n");
         5     }
     % !! | lpr
     num bug.c | ssp | lpr
     %











USD:4-22                      An Introduction to the C shell


     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
given in the C shell manual pages in the  UNIX  Programmer's
Manual.

2.4.  Aliases

     The  shell  has an alias mechanism which can be used to
make transformations on input commands.  This mechanism  can
be used to simplify the commands you type, to supply default
arguments to commands, or to perform transformations on 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 /mnt/bill










An Introduction to the C shell                      USD:4-23


     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 orig-
inal  command  are to be substituted using the facilities of
the history mechanism.  Thus the definition

     alias cd 'cd \!* ; ls '

would do an ls command after each change directory  cd  com-
mand.   We enclosed the entire alias definition in `'' char-
acters 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-alias-
ing  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










USD:4-24                      An Introduction to the C shell


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.

     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
-----------
 A command of the form
     command >&! file
exists, and is used when noclobber is set and file
already exists.
 If noclobber is set, then an error will result if
file does not exist, otherwise the shell will cre-
ate file if it doesn't exist.  A form
     command >>! file
makes it not be an error for  file  to  not  exist
when noclobber is set.









An Introduction to the C shell                      USD:4-25


immediately with a prompt for the next command  without  out
waiting  for  du  to  finish.  The du program would continue
executing in the background until it finished,  even  though
you  can  type  and  execute more commands in the mean time.
When a background job terminates, a message is typed by  the
shell  just  before the next prompt telling you that the job
has completed.  In the following example the du job finishes
sometime  during  the  execution of the mail command and its
completion is reported just before the prompt after the mail
job is 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
terminations  of  background jobs to be reported at the time
they occur (possibly interrupting the output of other  fore-
ground  jobs), you can set the notify variable.  In the pre-
vious example this would mean that the `Done' message  might
have come right in the middle of the message to Bill.  Back-
ground 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 num-
ber called the job number which can be used later  to  refer
to  the  job  in  the commands described below.  Job numbers
remain the same until the job terminates and  then  are  re-
used.

     When  a  job is started in the backgound using `&', its
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'  options,  pipes  this









USD:4-26                      An Introduction to the C shell


output  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 immediates prompts for a new com-
mand, leaving the job running simultaneously.

     As mentioned in section  1.8,  foreground  jobs  become
suspended by typing ^Z which sends a STOP signal to the cur-
rently 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  progress
until  started  again, either in the foreground or the back-
gound.  The shell notices when a  job  becomes  stopped  and
reports  this  fact, much like it reports the termination of
background jobs.  For foreground jobs this looks like

     % du > usage
     ^Z
     Stopped
     %

`Stopped' message is typed by the shell when it notices that
the du program stopped.  For background jobs, using the stop
command, it is

     % sort usage &
     [1] 2345
     % stop %1
     [1] + Stopped (signal)sort usage
     %

Suspending foreground jobs can be very useful when you  need
to temporarily change what you are doing (execute other 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  backgound  in  the









An Introduction to the C shell                      USD:4-27


beginning.

     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  back-
ground (the usual case) it is always the current job thus no
argument is needed.  If a job is stopped  while  running  in
the  foreground  it becomes the current job and the existing
current job becomes the previous job - identified by  a  `-'
in the output of jobs.  When the current job terminates, the
previous job becomes the current job.  When given, the argu-
ment  is  either  `%-'  (indicating the previous job); `%#',
where # is the job number; `%pref' where pref is some unique
prefix of the command name and arguments of one of the jobs;
or `%?' followed by some string found in  only  one  of  the
jobs.

     The  jobs  command  types the table of jobs, giving the
job number, commands and status (`Stopped' or `Running')  of
each  backgound  or suspended job.  With the `-l' option the
process numbers are also typed.

     % du > usage &
     [1] 3398
     % ls -s | sort -n > myfile &
     [2] 3405
     % mail bill
     ^Z
     Stopped
     % jobs
     [1] - Running    du > usage
     [2]    Running   ls -s | sort -n > myfile
     [3] + Stopped    mail bill
     % fg %ls
     ls -s | sort -n > myfile
     % more myfile


     The fg command runs a suspended or  background  job  in
the  foreground.   It  is  used to restart a previously sus-
pended 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









USD:4-28                      An Introduction to the C shell


stop command suspends a background job.

     The  kill  command terminates a background or suspended
job immediately.  In addition  to  jobs,  it  may  be  given
process  numbers  as  arguments, as printed by ps.  Thus, in
the example above, the running du command  could  have  been
terminated by the command

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


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

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

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

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

     The command











An Introduction to the C shell                      USD:4-29


     stty tostop

causes all background jobs run on your terminal to stop when
they  are  about to write output to the terminal.  This pre-
vents messages from background jobs from interrupting  fore-
ground  job  output and allows you to run a job in the back-
ground without losing terminal output.  It also can be  used
for  interactive  programs  that sometimes have long periods
without interaction.  Thus each time it outputs a prompt for
more  input  it will stop before the prompt.  It can then be
run in the foreground using fg, more input can be given and,
if  necessary  stopped and returned to the background.  This
stty command might be a good thing to  put  in  your  .login
file  if  you do not like output from background jobs inter-
rupting your work.  It also can reduce the  need  for  redi-
recting  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 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'  com-
mand  chdir (its short form cd may also be used) changes the
working directory of the shell, that is, changes the  direc-
tory you are located in.









USD:4-30                      An Introduction to the C shell


     It  is  useful to make a directory for each project you
wish to work on and to  place  all  files  related  to  that
project  in  that  directory.  The `make directory' command,
mkdir, creates a new directory.   The  pwd  (`print  working
directory')  command  reports  the  absolute pathname of the
working directory of the shell, that is, the  directory  you
are located in.  Thus in the example below:

     % pwd
     /usr/bill
     % mkdir newpaper
     % chdir newpaper
     % pwd
     /usr/bill/newpaper
     %

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

     No  matter where you have moved to in a directory hier-
archy, 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 direc-
tory 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









An Introduction to the C shell                      USD:4-31


     /usr/lib/tmac  ~/newpaper/references  ~
     % dirs
     /usr/lib/tmac  ~/newpaper/references  ~
     % popd
     ~/newpaper/references  ~
     % popd
     ~
     %

The  list  is  printed in a horizontal line, reading left to
right, with a tilde (~) as shorthand for  your  home  direc-
tory--in  this  case  `/usr/bill'.   The  directory stack is
printed whenever there is more than one entry on it  and  it
changes.   It  is  also  printed by a dirs command.  Dirs is
usually faster and more informative than pwd since it  shows
the  current working directory as well as any other directo-
ries remembered in the stack.

     The pushd command with no argument alternates the  cur-
rent  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 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.
























USD:4-32                      An Introduction to the C shell


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

This way the shell warns you when there is an implied change
of  working directory, even though no cd command was issued.
In  the  above  example  the   `ed'   job   was   still   in
`/mnt/bill/project'  even  though  the  shell had changed to
`/mnt/bill'.  A similar warning is given when such  a  fore-
ground  job  terminates or is suspended (using the STOP sig-
nal) 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'.










An Introduction to the C shell                      USD:4-33


     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:

     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 ta-
ble 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 sev-
eral  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









USD:4-34                      An Introduction to the C shell


     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=/usr/bill
     SHELL=/bin/csh
     PATH=:/usr/ucb:/bin:/usr/bin:/usr/local
     TERM=adm3a
     USER=bill
     %


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

     source .cshrc

can be used after editing in a change  to  the  .cshrc  file
which you wish to take effect right away.

     The  time  command can be used to cause a command to be
timed no matter how much CPU time it takes.  Thus

     % time cp /etc/rc /usr/bill/rc
     0.0u 0.1s 0:01 8% 2+1k 3+2io 1pf+0w
     % time wc /etc/rc /usr/bill/rc
          52    178   1347 /etc/rc
          52    178   1347 /usr/bill/rc
         104    356   2694 total
     0.1u 0.1s 0:00 13% 3+3k 5+3io 7pf+0w
     %

indicates that the cp command used a  negligible  amount  of
user  time  (u)  and  about 1/10th of a system time (s); the
elapsed time was 1 second (0:01), there was an average  mem-
ory  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.












An Introduction to the C shell                      USD:4-35


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 you should look
through the rest of this document and the csh  manual  pages
(section1)  to  become  familiar  with  the other facilities
which are available to you.

















































USD:4-36                      An Introduction to the C shell


3.  Shell control structures and command scripts

3.1.  Introduction

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

3.2.  Make

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

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

3.3.  Invocation and the argv variable

     A csh command script may be interpreted by saying

     % csh script ...

where  script  is the name of the file containing a group of
csh commands and `...' is replaced by a  sequence  of  argu-
ments.   The  shell  places  these arguments in the variable
argv and then begins  to  read  commands  from  the  script.
These  parameters are then available through the same mecha-
nisms 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










An Introduction to the C shell                      USD:4-37


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 mecha-
nism 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 compo-
nents and attributes of variables.  The notation

     $?name

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

     The notation

     $#name

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

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


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










USD:4-38                      An Introduction to the C shell


     $argv[1]

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

     $argv[$#argv]

would give `c', and

     $argv[1-2]

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

     $n

where n is an integer as a shorthand for

     $argv[n]

the nth parameter and

     $*

which is a shorthand for

     $argv

The form

     $$

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

     $<

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

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

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











An Introduction to the C shell                      USD:4-39


     One minor difference between `$n' and `$argv[n]' should
be noted here.  The form `$argv[n]' will yield an error if n
is  not  in the range `1-$#argv' while `$n' will never yield
an out of range subscript error.  This is for  compatibility
with the way older shells handled parameters.

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

3.5.  Expressions

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

     The shell also allows file enquiries of the form

     -? filename

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

     -e filename

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

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










USD:4-40                      An Introduction to the C shell


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

3.6.  Sample shell script

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

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

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

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

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

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


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

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

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









An Introduction to the C shell                      USD:4-41


     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 `:' modifier.  We can use  the  modifier  `:r'  here  to
extract  a  root  of  a  filename  or  `:e'  to  extract the
-----------
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









USD:4-42                      An Introduction to the C shell


extension.   Thus  if  the  variable   i   has   the   value
`/mnt/foo.bar' then

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

shows  how  the `:r' modifier strips off the trailing `.bar'
and the the `:e' modifier leaves only the `bar'.  Other mod-
ifiers  will take off the last component of a pathname leav-
ing the head `:h' or all but the last component of  a  path-
name  leaving  the  tail  `:t'.   These  modifiers are fully
described in the csh manual pages in  the  User's  Reference
Manual.  It is also possible to use the command substitution
mechanism described in the next  major  section  to  perform
modifications  on  strings to then reenter the shell's envi-
ronment.  Since each usage of this  mechanism  involves  the
creation  of a new process, it is much more expensive to use
than the `:' modification mechanism.  Finally, we note  that
the  character  `#'  lexically introduces a shell comment in
shell scripts (but not from the terminal).   All  subsequent
characters  on  the  input line after a `#' are discarded by
the shell.  This character can be quoted using `'' or `\' to
place it in an argument word.

3.7.  Other control structures

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

     while ( expression )
          commands
     end

and









-----------
 It is also important to  note  that  the  current
implementation  of  the shell limits the number of
`:' modifiers on a `$' substitution to 1.  Thus

     % echo $i $i:h:t
     /a/b/c /a/b:t
     %

does not do what one would expect.









An Introduction to the C shell                      USD:4-43


     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:


















USD:4-44                      An Introduction to the C shell


     % 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 termi-
nate the text to be given to  the  command  is  quoted  then
these  substitutions  will  not  be performed.  In this case
since we used the form `1,$' in our editor script we  needed
to  insure  that  this `$' was not variable substituted.  We
could also have insured this by preceding the `$' here  with
a `\', i.e.:

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

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

3.9.  Catching interrupts

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

     onintr label

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

     exit(1)

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

3.10.  What else?

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









An Introduction to the C shell                      USD:4-45


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.

















































USD:4-46                      An Introduction to the C shell


4.  Other, less commonly used, shell features

4.1.  Loops at the terminal; variables as vectors

     It  is  occasionally  useful to use the foreach control
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









An Introduction to the C shell                      USD:4-47


(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 spec-
ify 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










USD:4-48                      An Introduction to the C shell


them.*

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.




































-----------
*Command expansion also occurs in input redirected
with `<<' and within `"' quotations.  Refer to the
shell manual section for full details.









An Introduction to the C shell                      USD:4-49


Appendix - Special characters

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

Syntactic metacharacters

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


Filename metacharacters

     /    1.6  separates components of a file's pathname
     .    1.6  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













USD:4-50                      An Introduction to the C shell


     #    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-51


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 the first  component  of  the  search
               path  contained  in  the  variable path, thus
               commands which are in  `.'  are  found  first
               (2.2).   The  character  `.'  is also used in
               separating  components  of  filenames  (1.6).
               The  character `.' at the beginning of a com-
               ponent of a pathname is treated specially and
               not   matched   by   the  filename  expansion
               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 cre-
               ate 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 directo-
               ries from the beginning of the entire  direc-
               tory  system  -  called  the  root directory.
               Pathnames which are not absolute  are  called
               relative    (see   definition   of   relative









USD:4-52                      An Introduction to the C shell


               pathname) (1.6).

alias          An alias specifies  a  shorter  or  different
               name  for a UNIX command, or a transformation
               on a command to be performed  in  the  shell.
               The  shell  has  a command alias which 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.
               Programs developed at  UC  Berkeley  live  in
               `/usr/ucb',  while  locally  written programs
               live in `/usr/local'.  Games are kept in  the
               directory  `/usr/games'.  You can place bina-
               ries in any directory.  If you wish  to  exe-
               cute  them often, the name of the directories
               should be a component of the variable path.










An Introduction to the C shell                      USD:4-53


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

breaksw        The breaksw builtin command is used  to  exit
               from a switch control structure, like a break
               exits from loops (3.7).

builtin        A command executed directly by the  shell  is
               called  a  builtin command.  Most commands in
               UNIX are not built into the shell, but rather
               exist  as  files  in  bin directories.  These
               commands are accessible because the  directo-
               ries  in  which  they reside are named in the
               path variable.

case           A case command is used as a label in a switch
               statement  in  the shell's control structure,
               similar to that of the language  C.   Details
               are  given  in  the  shell documentation `csh
               (1)' (3.7).

cat            The cat program catenates a list of specified
               files  on the standard output.  It is usually
               used to look at the contents of a single file
               on  the terminal, to `cat a file' (1.8, 2.3).

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

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

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

                    chsh your-login-name /bin/csh

               Thus I would do

                    chsh bill /bin/csh

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

cmp            Cmp is a program which compares files.  It is
               usually used on binary files, or  to  see  if









USD:4-54                      An Introduction to the C shell


               two files are identical (3.6).  For comparing
               text files the  program  diff,  described  in
               `diff (1)' is used.

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

command name
               When a command is issued, it  consists  of  a
               command  name, which is the first word of the
               command, 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 `adb
               (1)' or `sdb (1)' in order to determine  what
               went  wrong  with  the program (1.8).  If the
               shell produces a message of the form











An Introduction to the C shell                      USD:4-55


                    Illegal instruction (core dumped)

               (where `Illegal instruction' is only  one  of
               several possible messages), you should report
               this to the author of the program or a system
               administrator, saving the `core' file.

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

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

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

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

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

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

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

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

detached       A command that continues running in the back-
               ground  after  you  logout  is  said  to   be
               detached.

diagnostic     An  error  message  produced  by a program is
               often referred  to  as  a  diagnostic.   Most
               error  messages  are not written to the stan-
               dard output, since  that  is  often  directed









USD:4-56                      An Introduction to the C shell


               away  from  the  terminal  (1.3, 1.5).  Error
               messsages are instead written to the diagnos-
               tic  output  which  may be directed away from
               the terminal, but usually is not.  Thus diag-
               nostics  will  usually appear on the terminal
               (2.5).

directory      A structure which  contains  files.   At  any
               time  you  are  in  one  particular directory
               whose names can be  printed  by  the  command
               pwd.   The  chdir  command will change you to
               another directory, and make the files in that
               directory visible. The directory in which you
               are when you first login is your home  direc-
               tory (1.1, 2.7).

directory stack
               The 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









An Introduction to the C shell                      USD:4-57


               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 \*

               will echo the character `*' while just

                    echo *

               will  echo  the names of the file in the cur-
               rent directory.  In this example,  \  escapes
               `*'  (1.7).   There  is  also  a non-printing
               character 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  con-
               sists  of a line for each account with fields
               separated by `:' characters (1.8).   You  can
               look at this file by saying

                    cat /etc/passwd

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

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

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

expansion      The replacement of strings in the shell input
               which contain metacharacters by other strings
               is  referred  to as the process of expansion.
               Thus the replacement of the  word  `*'  by  a
               sorted list of files in the current directory









USD:4-58                      An Introduction to the C shell


               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  val-
               ues  for these scripts.  The operators avail-
               able 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 conve-
               nient  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' directo-
               ries 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









An Introduction to the C shell                      USD:4-59


               the ls (list files)  command  has  an  option
               `-s'  to  list  the  sizes of files.  This is
               specified

                    ls -s


foreach        The foreach command is used in shell  scripts
               and  at the terminal to specify repetition of
               a sequence of commands while the value  of  a
               certain shell variable ranges through a spec-
               ified 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).










USD:4-60                      An Introduction to the C shell


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

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

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

input          Many commands on UNIX take  information  from
               the  terminal  or  from files which they then
               act on.  This information  is  called  input.
               Commands  normally  read for input from their
               standard input which is, by default, the ter-
               minal.  This standard input can be redirected
               from a file using a shell  metanotation  with
               the  character  `<'.  Many commands will also
               read from a file specified as argument.  Com-
               mands  placed in pipelines will read from the
               output of the previous command in  the  pipe-
               line.   The  leftmost  command  in a pipeline
               reads from the terminal if you neither  redi-
               rect  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).










An Introduction to the C shell                      USD:4-61


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 inter-
               rupt in special  ways,  usually  by  stopping
               what they are doing and prompting for another
               command.   While  the  shell   is   executing
               another command and waiting for it to finish,
               the shell does not listen to interrupts.  The
               shell  often  wakes up when you hit interrupt
               because many commands die when  they  receive
               an interrupt (1.8, 3.9).

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

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

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

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

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

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

login shell    The  shell  that  is started on your terminal
               when you login is called  your  login  shell.
               It  is  different from other shells which you
               may run (e.g. on shell scripts)  in  that  it
               reads the .login file before reading commands









USD:4-62                      An Introduction to the C shell


               from the terminal and it  reads  the  .logout
               file after you logout (2.1).

logout         The  logout  command  causes a login shell to
               exit.  Normally, a login shell will exit when
               you  hit control-d generating an end-of-file,
               but if you have set ignoreeof in  you  .login
               file then this will not work and you must use
               logout to log off the UNIX system (2.8).

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

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

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

mail           The mail program is used to send and  receive
               messages  from  other  UNIX users (1.1, 2.1),
               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  8  numbered  sections
               with a description of each UNIX program (sec-
               tion 1), system call (section 2),  subroutine
               (section 3), device (section 4), special data
               structure (section 5), game (section 6), mis-
               cellaneous item (section 7) and system admin-
               istration program  (section  8).   There  are
               also  supplementary  documents (tutorials and
               reference  guides)  for  individual  programs
               which require explanation in more detail.  An









An Introduction to the C shell                      USD:4-63


               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
               /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 com-
               mands without them having their special mean-
               ing  then they must be quoted.  An example of
               a metacharacter is the character `>' which is
               used  to  indicate placement of output into a
               file.  For the purposes of the history mecha-
               nism, most unquoted metacharacters form sepa-
               rate  words  (1.4).   The  appendix  to  this
               user's  manual  lists  the  metacharacters in
               groups by their function.

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

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

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

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









USD:4-64                      An Introduction to the C shell


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

notify         The  notify command tells the shell to report
               on the termination of a  specific  background
               job at the exact time it occurs as opposed to
               waiting until just before the next prompt  to
               report the termination.  The notify variable,
               if set, causes the shell to always report the
               termination  of  background jobs exactly when
               they occur (2.6).

onintr         The onintr command is built  into  the  shell
               and  is used to control the action of a shell
               command script when an  interrupt  signal  is
               received (3.9).

output         Many commands in UNIX result in some lines of
               text which are  called  their  output.   This
               output  is usually placed on what is known as
               the standard output which  is  normally  con-
               nected to the user's terminal.  The shell has
               a syntax  using  the  metacharacter  `>'  for
               redirecting  the standard output of a command
               to a file (1.3).  Using  the  pipe  mechanism
               and the metacharacter `|' it is also possible
               for the standard output  of  one  command  to
               become  the standard input of another command
               (1.5).  Certain commands  such  as  the  line
               printer  daemon  p do not place their results
               on the standard output  but  rather  in  more
               useful  places  such  as  on the line printer
               (2.3).  Similarly the  write  command  places
               its  output on another user's terminal rather
               than its  standard  output  (2.3).   Commands
               also  have  a  diagnostic  output  where they
               write their error messages.   Normally  these
               go  to the terminal even if the standard out-
               put has been sent to a file or  another  com-
               mand,  but  it  is  possible  to direct error
               diagnostics along with standard output  using
               a special metanotation (2.5).

path           The shell has a variable path which gives the
               names of the directories in which it searches
               for  the  commands  which  it  is  given.  It
               always checks first to see if the command  it
               is  given is built into the shell.  If it is,
               then it need not search for the command as it
               can  do it internally.  If the command is not
               builtin, then the shell searches for  a  file
               with   the   name   given   in  each  of  the









An Introduction to the C shell                      USD:4-65


               directories in the  path  variable,  left  to
               right.   Since  the  normal definition of the
               path variable is

                    path (. /usr/ucb /bin /usr/bin)

               the  shell  normally  looks  in  the  current
               directory,  and  then  in the standard system
               directories `/usr/ucb', `/bin' and `/usr/bin'
               for  the named command (2.2).  If the command
               cannot be found the shell will print an error
               diagnostic.   Scripts  of shell commands will
               be executed using another shell to  interpret
               them  if  they have `execute' permission set.
               This is normally true because  a  command  of
               the form

                    chmod 755 script

               was  executed to turn this execute permission
               on (3.3).  If  you  add  new  commands  to  a
               directory  in  the path, you should issue the
               command rehash (2.2).

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

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

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

port           The part of a computer system to  which  each
               terminal is connected is called a port.  Usu-
               ally the system has a fixed number of  ports,
               some  of  which  are  connected  to telephone









USD:4-66                      An Introduction to the C shell


               lines for dial-up access, and some  of  which
               are  permanently  wired  directly to specific
               terminals.

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

printenv       The  printenv  command  is  used to print the
               current setting of variables in the  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  edi-
               tor `ex (1)' will print a `:' when it expects
               input.  The shell prompts for input with `% '
               and  occasionally with `? ' when reading com-
               mands from the terminal (1.1).  The shell has
               a  variable prompt which may be set to a dif-
               ferent  value  to  change  the  shell's  main
               prompt.   This  is mostly used when debugging
               the shell (2.8).

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
               identified by printing some of the words used









An Introduction to the C shell                      USD:4-67


               when it was invoked (2.6).  Shells,  such  as
               the  csh  you  use to run the ps command, are
               not normally shown in the output.

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

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

quotation      The process by which metacharacters are  pre-
               vented  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









USD:4-68                      An Introduction to the C shell


               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
               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
               command (2.8).  The printenv command  can  be
               used  to  print the value of the variables in
               the environment.

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

shell script   See script (3.3, 3.10).

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

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









An Introduction to the C shell                      USD:4-69


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
               output (1.3, 3.8).

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

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

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

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

substitution   The  shell  implements  a number of substitu-
               tions where sequences indicated by  metachar-
               acters   are  replaced  by  other  sequences.
               Notable examples of this are history  substi-
               tution  keyed  by  the  metacharacter `!' and
               variable 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









USD:4-70                      An Introduction to the C shell


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

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 used,  and  number  of  page
               faults  and  swaps taken by the command (2.1,
               2.8).

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

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

unalias        The unalias command removes aliases (2.8).

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

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

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

variables      Variables  in csh hold one or more strings as
               value.  The most common use of  variables  is
               in  controlling  the  behavior  of the shell.
               See path, noclobber, and ignoreeof for  exam-
               ples.   Variables  such as argv are also used









An Introduction to the C shell                      USD:4-71


               in  writing  shell  programs  (shell  command
               scripts) (2.2).

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

wc             The wc program calculates the number of char-
               acters,  words,  and lines in the files whose
               names are given as arguments (2.6).

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

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

working directory
               At any given time you are in  one  particular
               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.

















