An introduction to the C shell

			William	Joy

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


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

	  UNIX users who have read a general  introduc-
     tion  to  the  system  will  find a valuable basic
     explanation of the	shell  here.   Simple  terminal
     interaction  with	csh  is	 possible after	reading
     just the first  section  of  this	document.   The
     second  section  describes	the shells capabilities
     which you can explore  after  you	have  begun  to
     become  acquainted	with the shell.	 Later sections
     introduce	features  which	 are  useful,  but  not
     necessary for all users of	the shell.

	  Back matter includes an appendix listing spe-
     cial  characters  of  the	shell and a glossary of
     terms and commands	introduced in this manual.

May 30,	1993

|  UNIX	 is  a	registered  trademark  of  Unix	 System
Laboratories, Inc.


	       An introduction to the C	shell

			William	Joy

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


     A shell is	a command language interpreter.	 Csh is	 the
name  of  one  particular  command interpreter on UNIX.	 The
primary	purpose	of csh is to translate command	lines  typed
at  a  terminal	 into  system actions, such as invocation of
other programs.	 Csh is	a user program	just  like  any	 you
might  write.	Hopefully, csh will be a very useful program
for you	in interacting with the	UNIX system.

     In	addition to this document, you will want to refer to
a  copy	of the UNIX programmer's manual.  The csh documenta-
tion in	the  manual  provides  a  full	description  of	 all
features of the	shell and is a final reference for questions
about the shell.

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


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


			   - 2 -

1.  Terminal usage of the shell

1.1.  The basic	notion of commands

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

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

	mail bill

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

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

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

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

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


			   - 3 -

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

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

     An	example	of a useful command you	can execute  now  is
the  tset  command,  which  sets  the default erase and	kill
characters on your terminal - the erase	character erases the
last  character	 you typed and the kill	character erases the
entire line you	have entered so	far.  By default, the  erase
character is `#' and the kill character	is `@'.	 Most people
who use	CRT displays prefer to use the backspace (|H)  char-
acter  as  their  erase	character since	it is then easier to
see what you have typed	so far.	 You can make this  be	true
by typing

	tset -e

which tells the	program	tset to	set the	erase character, and
its default setting for	this character is a backspace.

1.2.  Flag arguments

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


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

	ls -s

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


			   - 4 -

remember options of commands which are not  used  very	fre-
quently,  so  most  UNIX  utilities  perform only one or two
functions rather than having  a	 large	number	of  hard  to
remember options.

1.3.  Output to	files

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

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


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

     One other thing to	note here is  that  the	 file  `now'
need  not have existed before the date command was executed;
the shell would	have created the file if it did	 not  exist.
And  if	 the  file  did	exist?	If it had existed previously
these previous contents	would have been	discarded!  A  shell
option	noclobber  exists  to  prevent	this  from happening
accidentally; it is discussed in section 2.2.

     The system	normally keeps files which you	create	with
`>'  and  all other files.  Thus the default is	for files to
be permanent.  If you wish to create a file  which  will  be
removed	 automatically,	 you  can  begin its name with a `#'
character, this	`scratch' character denotes  the  fact	that
the file will be a scratch file.*  The	system	will  remove
*Note that if your erase character is a	`#',  you  will
have  to precede the `#' with a	`\'.  The fact that the
`#' character  is  the	old  (pre-CRT)	standard  erase
character  means that it seldom	appears	in a file name,
and allows this	 convention  to	 be  used  for	scratch


			   - 5 -

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

	date > #now

1.4.  Metacharacters in	the shell

     The shell has a  large  number  of	 special  characters
(like  `>')  which  indicate special functions.	 We say	that
these notations	have syntactic and semantic meaning  to	 the
shell.	 In  general,  most  characters	 which	are  neither
letters	nor digits have	special	meaning	to  the	 shell.	  We
shall  shortly learn a means of	quotation which	allows us to
use metacharacters without the shell treating  them  in	 any
special	way.

     Metacharacters normally have effect only when the shell
is reading our input.  We need not worry about placing shell
metacharacters in a letter we are sending via mail, or	when
we  are	 typing	in text	or data	to some	other program.	Note
that the shell is only reading input when  it  has  prompted
with `%	'.

1.5.  Input from files;	pipelines

     We	learned	above how to redirect the standard output of
a  command  to	a file.	 It is also possible to	redirect the
standard input of a command from a file.  This is not  often
necessary  since  most	commands will read from	a file whose
name is	given as an argument.  We can give the command

	sort < data

to run the sort	command	with standard input, where the	com-
mand  normally	reads  its  input, from	the file `data'.  We
would more likely say

	sort data

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

     We	should note that if we just typed


files.	 If  you  are using a CRT, your	erase character
should be a |H,	as we demonstrated in section  1.1  how
this could be set up.


			   - 6 -

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

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

	ls -s

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

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

	ls -s |	sort -n

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

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

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

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


			   - 7 -

routing	of information to the line printer.

1.6.  Filenames

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


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

     Most filenames consist  of	 a  number  of	alphanumeric
characters  and	`.'s (periods).	 In fact, all printing char-
acters except `/' (slash) may appear in	 filenames.   It  is
inconvenient  to  have	most  non-alphabetic  characters  in
filenames because many of these	have special meaning to	 the
shell.	  The	character  `.'	(period)  is  not  a  shell-
metacharacter and is often used	to separate the	extension of
a file name from the base of the name.	Thus

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

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

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


			   - 8 -


This word is expanded by the shell, before  the	 command  to
which  it  is  an argument is executed,	into a list of names
which begin with `prog.'.  The character  `*'  here  matches
any sequence (including	the empty sequence) of characters in
a file name.   The  names  which  match	 are  alphabetically
sorted and placed in the argument list of the command.	Thus
the command

	echo prog.*

will echo the names

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

Note that the names are	in sorted order	 here,	and  a	dif-
ferent	order  than  we	listed them above.  The	echo command
receives four words as arguments, even though we only  typed
one  word as as	argument directly.  The	four words were	gen-
erated by filename expansion of	the one	input word.

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

	echo ? ?? ???

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

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


will match

	prog.c prog.o

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


might match files

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

if they	existed.  This is shorthand for


			   - 9 -


and otherwise equivalent.

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

	No match.

and does not execute the command.

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

     Another filename expansion	mechanism  gives  access  to
the  pathname  of  the	home directory of other	users.	This
notation consists of the character `~' (tilde)	followed  by
another	 users'	 login	name.  For instance the	word `~bill'
would map to the pathname `/usr/bill' if the home  directory
for  `bill' was	`/usr/bill'.  Since, on	large systems, users
may have login directories  scattered  over  many  different
disk  volumes  with  different	prefix directory names,	this
notation provides a reliable way of accessing the  files  of
other users.

     A special case of	this  notation	consists  of  a	 `~'
alone,	e.g.  `~/mbox'.	  This	notation  is expanded by the
shell into the file `mbox' in your home	directory, i.e.	into
`/usr/bill/mbox'  for  me  on Ernie Co-vax, the	UCB Computer
Science	Department VAX	machine,  where	 this  document	 was
prepared.   This  can  be very useful if you have used cd to
change to another directory and	have found a file  you	wish
to copy	using cp.  If I	give the command

	cp thatfile ~

the shell will expand this command to

	cp thatfile /usr/bill

since my home directory	is /usr/bill.

     There also	exists a mechanism using the characters	 `{'
and  `}'  for  abbreviating a set of words which have common


			   - 10	-

parts but cannot be  abbreviated  by  the  above  mechanisms
because	 they are not files, are the names of files which do
not yet	exist, are not thus  conveniently  described.	This
mechanism  will	 be described much later, in section 4.2, as
it is used less	frequently.

1.7.  Quotation

     We	have already seen a number of metacharacters used by
the  shell.   These metacharacters pose	a problem in that we
cannot use them	directly as parts of words.  Thus  the	com-

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



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

	echo \''*'

which prints


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


			   - 11	-

1.8.  Terminating commands

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

	cat /etc/passwd

the system will	print a	copy of	a list of all users  of	 the
system	on  your  terminal.   This is likely to	continue for
several	minutes	unless you stop	it.  You can send an  INTER-
RUPT  signal  to the cat command by typing the DEL or RUBOUT
key on your terminal.*	Since cat does not take	any  precau-
tions to avoid or otherwise handle this	signal the INTERRUPT
will cause it to terminate.  The shell notices that cat	 has
terminated  and	 prompts  you  again  with `% '.  If you hit
INTERRUPT again, the shell will	just repeat its	prompt since
it handles INTERRUPT signals and chooses to continue to	exe-
cute commands rather than terminating like  cat	 did,  which
would have the effect of logging you out.

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

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

	mail bill < prepared.text

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

	cat prepared.text | mail bill

since the cat command  would  then  have  written  the	text
through	 the pipe to the standard input	of the mail command.
When the cat command completed	it  would  have	 terminated,
closing	 down  the  pipeline and the mail command would	have
received an end-of-file	from it	 and  terminated.   Using  a
*Many  users  use  stty(1)  to	change	the   interrupt
character to |C.


			   - 12	-

pipe here is more complicated than redirecting input  so  we
would  more likely use the first form.	These commands could
also have been stopped by sending an INTERRUPT.

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


2.  Details on the shell for terminal users

2.1.  Shell startup and	termination

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

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

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

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

	biff y

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

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

			May 30,	1993


			   - 2 -

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

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

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

2.2.  Shell variables

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

	set name=value

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

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

			May 30,	1993


3.  Shell control structures and command scripts

3.1.  Introduction

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

3.2.  Make

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

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

3.3.  Invocation and the argv variable

     A csh command script may be interpreted by	saying

	% csh script ...

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

     If	you make the file `script' executable by doing

	chmod 755 script

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


			May 30,	1993


			   - 2 -

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

3.4.  Variable substitution

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

	echo $argv

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

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


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

     The notation


expands	to the number of  elements  in	the  variable  name.

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

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

			May 30,	1993


			   - 3 -


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


would give `c',	and


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


where n	is an integer as a shorthand for


the nth	parameter and


which is a shorthand for


The form


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


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

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

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

			May 30,	1993


			   - 4 -

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

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

3.5.  Expressions

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

     The shell also allows file	enquiries of the form

	-? filename

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

	-e filename

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

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

			May 30,	1993


			   - 5 -

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

3.6.  Sample shell script

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

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

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

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

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

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

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

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

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

			May 30,	1993


			   - 6 -

	if ( expression	) then

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

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


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

     if	( expression )		     # Won't work!


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

			May 30,	1993


			   - 7 -

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

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

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

3.7.  Other control structures

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

	while (	expression )


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

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

does not do what one would expect.

			May 30,	1993


			   - 8 -

	switch ( word )

	case str1:


	case strn:



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

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

		goto loop

3.8.  Supplying	input to commands

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

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

			May 30,	1993


			   - 9 -

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

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

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

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

3.9.  Catching interrupts

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

	onintr label

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


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

3.10.  What else?

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

			May 30,	1993


			   - 10	-

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

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

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

			May 30,	1993


			   - 11	-

			May 30,	1993


4.  Other, less	commonly used, shell features

4.1.  Loops at the terminal; variables as vectors

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

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

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

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

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

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

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

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

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

			May 30,	1993


			   - 2 -

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

4.2.  Braces { ... } in	argument expansion

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


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
*Command expansion also	occurs in input	redirected with

			May 30,	1993


			   - 3 -

4.4.  Other details not	covered	here

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

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

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

			May 30,	1993


			   - 4 -

			May 30,	1993


Appendix - Special characters

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

Syntactic metacharacters

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

Filename metacharacters

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

Quotation metacharacters

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

Input/output metacharacters

	<	1.5	indicates redirected input
	>	1.3	indicates redirected output

Expansion/substitution metacharacters

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

Other metacharacters

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

			May 30,	1993


			   - 2 -

			May 30,	1993



     This glossary lists the most important terms introduced
in  the	 introduction  to  the shell and gives references to
sections of the	shell document for further information about
them.	References  of	the  form `pr (1)' indicate that the
command	pr is in the UNIX programmer's manual in section  1.
You can	get an online copy of its manual page by doing

	man 1 pr

References of the form (2.5) indicate that more	 information
can be found in	section	2.5 of this manual.

.	       Your current directory has the  name  `.'  as
	       well  as	the name printed by the	command	pwd;
	       see also	dirs.  The current directory `.'  is
	       usually	the  first  component  of the search
	       path contained in  the  variable	 path,	thus
	       commands	 which	are  in	 `.' are found first
	       (2.2).  The character `.'  is  also  used  in
	       separating  components  of  filenames  (1.6).
	       The character `.' at the	beginning of a	com-
	       ponent of a pathname is treated specially and
	       not matched by the filename  expansion  meta-
	       characters `?', `*', and	`[' `]'	pairs (1.6).

..	       Each directory has a file `..' in it which is
	       a  reference  to	its parent directory.  After
	       changing	into the directory with	chdir, i.e.

		       chdir paper

	       you can return to  the  parent  directory  by

		       chdir ..

	       The  current  directory	is  printed  by	 pwd

a.out	       Compilers  which	 create	 executable   images
	       create  them,  by default, in the file a.out.
	       for historical reasons (2.3).

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

			May 30,	1993


			   - 2 -

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

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

		       echo a b	c

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

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

background     Commands	started	without	waiting	for them  to
	       complete	  are	called	background  commands

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

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

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

break	       Break is	a builtin command used to exit	from
	       loops  within  the  control  structure of the

			May 30,	1993


			   - 3 -

	       shell (3.7).

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

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

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

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

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

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

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

		       chsh your-login-name /bin/csh

	       Thus I would do

		       chsh bill /bin/csh

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

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

			May 30,	1993


			   - 4 -

	       `diff (1)' is used.

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

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

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

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

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

control-       Certain special	characters,  called  control
	       characters,  are	produced by holding down the
	       CONTROL key on your terminal  and  simultane-
	       ously  pressing	another	character, much	like
	       the SHIFT key is	used to	produce	 upper	case
	       characters.  Thus  control-c  is	 produced by
	       holding down the	CONTROL	key  while  pressing
	       the `c' key.  Usually UNIX prints an up-arrow
	       (|) followed by the corresponding letter	when
	       you  type  a control character (e.g. `|C' for
	       control-c (1.8).

core dump      When a  program	terminates  abnormally,	 the
	       system  places  an image	of its current state
	       in a file named `core'.	This core  dump	 can
	       be examined with	the system debugger `adb(1)'
	       or `sdb(1)' in order to determine  what	went
	       wrong  with  the	program	(1.8).	If the shell
	       produces	a message of the form

		       Illegal instruction (core dumped)

	       (where `Illegal instruction' is only  one  of

			May 30,	1993


			   - 5 -

	       several possible	messages), you should report
	       this to the author of the program or a system
	       administrator, saving the `core'	file.

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

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

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

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

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

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

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

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

diagnostic     An error	message	produced  by  a	 program  is
	       often  referred	to  as	a  diagnostic.	Most
	       error messages are not written to  the  stan-
	       dard  output,  since  that  is often directed
	       away from the  terminal	(1.3,  1.5).   Error
	       messsages are instead written to	the diagnos-
	       tic output which	may be	directed  away	from

			May 30,	1993


			   - 6 -

	       the terminal, but usually is not.  Thus diag-
	       nostics will usually appear on  the  terminal

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

directory stackThe shell saves the names of previous working
	       directories  in	the directory stack when you
	       change your current working directory via the
	       pushd  command.	 The  directory	stack can be
	       printed by  using  the  dirs  command,  which
	       includes	 your  current	working	directory as
	       the first directory name	on the left (2.7).

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

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

echo	       The echo	command	prints its  arguments  (1.6,

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

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

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

escape	       A character `\' used to prevent	the  special

			May 30,	1993


			   - 7 -

	       meaning	of a metacharacter is said to escape
	       the character from its special meaning.	Thus

		       echo \*

	       will echo the character `*' while just

		       echo *

	       will echo  the  names  of  the  file  in	 the
	       current	 directory.    In  this	 example,  \
	       escapes `*' (1.7).   There  is  also  a	non-
	       printing	 character  called  escape,  usually
	       labelled	ESC  or	 ALTMODE  on  terminal	key-
	       boards.	 Some  older  UNIX  systems use	this
	       character to indicate that output  is  to  be
	       suspended.   Most  systems  use	control-s to
	       stop the	output and control-q to	start it.

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

		       cat /etc/passwd

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

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

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

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

			May 30,	1993


			   - 8 -

	       substitutions (1.6, 3.4,	4.2).

expressions    Expressions are used in the shell to  control
	       the  conditional	structures used	in the writ-
	       ing  of	shell  scripts	and  in	 calculating
	       values  for  these  scripts.   The  operators
	       available in shell expressions are  those  of
	       the language C (3.5).

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

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

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

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

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

			May 30,	1993


			   - 9 -

		       ls -s

foreach	       The foreach command is used in shell  scripts
	       and  at the terminal to specify repetition of
	       a sequence of commands while the	value  of  a
	       certain	 shell	variable  ranges  through  a
	       specified list (3.6, 4.1).

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

goto	       The shell has a command goto  used  in  shell
	       scripts	to transfer control to a given label

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

history	       The history mechanism  of  the  shell  allows
	       previous	 commands  to  be repeated, possibly
	       after modification to correct typing mistakes

			May 30,	1993


			   - 10	-

	       or to change the	meaning	of the command.	 The
	       shell has a history list	where these commands
	       are  kept,  and a history variable which	con-
	       trols how large this list is (2.3).

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

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

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

input	       Many commands on	UNIX take  information	from
	       the  terminal  or  from files which they	then
	       act on.	This information  is  called  input.
	       Commands	 normally  read	for input from their
	       standard	input which is,	by default, the	ter-
	       minal.  This standard input can be redirected
	       from a file using a shell  metanotation	with
	       the  character  `<'.  Many commands will	also
	       read from a file	specified as argument.	Com-
	       mands  placed in	pipelines will read from the
	       output of the previous command in  the  pipe-
	       line.   The  leftmost  command  in a pipeline
	       reads  from  the	 terminal  if  you   neither
	       redirect	 its input nor give it a filename to
	       use as standard	input.	 Special  mechanisms
	       exist  for  supplying  input  to	 commands in
	       shell scripts (1.5, 3.8).

interrupt      An interrupt is a signal	to a program that is
	       generated by hitting the	RUBOUT or DELETE key
	       (although users can and often do	 change	 the

			May 30,	1993


			   - 11	-

	       interrupt  character,  usually  to  |C).	  It
	       causes most programs to stop execution.	Cer-
	       tain programs, such as the shell	and the	edi-
	       tors, handle an interrupt  in  special  ways,
	       usually	by  stopping what they are doing and
	       prompting for  another  command.	  While	 the
	       shell  is executing another command and wait-
	       ing for it to  finish,  the  shell  does	 not
	       listen  to interrupts.  The shell often wakes
	       up when you hit interrupt because  many	com-
	       mands  die  when	 they  receive	an interrupt
	       (1.8, 3.9).

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

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

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

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

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

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

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

			May 30,	1993


			   - 12	-

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

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

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

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

mail	       The mail	program	is used	to send	and  receive
	       messages	from other UNIX	users (1.1, 2.1).

make	       The make	command	is used	to maintain  one  or
	       more  related files and to organize functions
	       to be performed on these	files. In many	ways
	       make  is	easier to use, and more	helpful	than
	       shell command scripts (3.2).

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

manual	       The manual often	referred  to  is  the  `UNIX
	       programmer's  manual'.	It contains a number
	       of sections and a description  of  each	UNIX
	       program.	  An online version of the manual is
	       accessible  through  the	 man  command.	 Its
	       documentation can be obtained online via

		       man man

	       Many characters which are neither letters nor
	       digits  have  special  meaning  either to the
	       shell  or  to  UNIX.   These  characters	 are
	       called metacharacters.  If it is	necessary to

			May 30,	1993


			   - 13	-

	       place these characters in arguments  to	com-
	       mands without them having their special mean-
	       ing then	they must be quoted.  An example  of
	       a metacharacter is the character	`>' which is
	       used to indicate	placement of output  into  a
	       file.	For  the  purposes  of	the  history
	       mechanism, most unquoted	metacharacters	form
	       separate	 words	(1.4).	The appendix to	this
	       user's manual  lists  the  metacharacters  in
	       groups by their function.

mkdir	       The mkdir command is used  to  create  a	 new

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

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,

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

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

onintr	       The onintr command is built  into  the  shell

			May 30,	1993


			   - 14	-

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

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

pushd	       The pushd command, which	means  `push  direc-
	       tory',  changes the shell's working directory
	       and also	remembers the current working direc-
	       tory  before the	change is made,	allowing you
	       to return to the	same directory via the	popd
	       command	 later	without	 retyping  its	name

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

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

	       the  shell  normally  looks  in	the  current

			May 30,	1993


			   - 15	-

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

		       chmod 755 script

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

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

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

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

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

pr	       The pr command is used to prepare listings of
	       the contents of files with headers giving the
	       name of the file	and the	 date  and  time  at

			May 30,	1993


			   - 16	-

	       which the file was last modified	(2.3).

printenv       The printenv command is	used  to  print	 the
	       current	setting	of variables in	the environ-
	       ment (2.8).

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

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

programmer's manuals manual'u>(360u+1n)	.br
	       Also referred to	 as  the  manual.   See	 the
	       glossary	entry for `manual'.

prompt	       Many programs will print	a prompt on the	ter-
	       minal  when they	expect input.  Thus the	edi-
	       tor `ex(1)' will	print a	`:' when it  expects
	       input.  The shell prompts for input with	`% '
	       and occasionally	with `?	' when reading	com-
	       mands from the terminal (1.1).  The shell has
	       a variable prompt which may be set to a	dif-
	       ferent  value  to  change  the  shell's	main
	       prompt.	This is	mostly used  when  debugging
	       the shell (2.8).

ps	       The ps command is used to show the  processes
	       you  are	 currently running.  Each process is
	       shown with  its	unique	process	 number,  an
	       indication   of	 the  terminal	name  it  is
	       attached	to, an indication of  the  state  of
	       the  process (whether it	is running, stopped,
	       awaiting	some event (sleeping),	and  whether
	       it  is  swapped	out),  and the amount of CPU
	       time it has used	 so  far.   The	 command  is
	       identified by printing some of the words	used
	       when it was invoked (2.6).  Shells,  such  as
	       the  csh	 you  use to run the ps	command, are
	       not normally shown in the output.

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

quit	       The quit	signal,	generated by a control-\, is
	       used to terminate programs which	are behaving

			May 30,	1993


			   - 17	-

	       unreasonably.  It normally  produces  a	core
	       image file (1.8).

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

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

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

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

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

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

RUBOUT	       The RUBOUT or DELETE key	sends  an  interrupt
	       to  the	current	 job.  Most interactive	com-
	       mands return  to	 their	command	 level	upon
	       receipt	 of   an   interrupt,	while	non-
	       interactive   commands	usually	  terminate,
	       returning  control to the shell.	 Users often
	       change interrupt	to be generated	by |C rather
	       than DELETE by using the	stty command.

			May 30,	1993


			   - 18	-

scratch	file   Files  whose  names  begin  with	 a  `#'	 are
	       referred	 to as scratch files, since they are
	       automatically removed by	the system  after  a
	       couple of days of non-use, or more frequently
	       if disk space becomes tight (1.3).

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

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

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

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

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

			May 30,	1993


			   - 19	-

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

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

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

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

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

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

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

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

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

			May 30,	1993


			   - 20	-

	       specified jobs (2.6).

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

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

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

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

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

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

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

			May 30,	1993


			   - 21	-

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

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

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

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

write	       The write command is used to communicate	with
	       other users who are logged in to	UNIX.

			May 30,	1993