csh/USD.doc/csh.2

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

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

The command

stty tostop

causes all background jobs run on your terminal to stop
when they are about to
write output to the terminal. This prevents messages from background
jobs from interrupting foreground job output and allows you to run
a job in the background without losing terminal output. It also
can be used for interactive programs that sometimes have long
periods without interaction. Thus each time it outputs a prompt for more
input it will stop before the prompt. It can then be run in the
foreground using
 fg, more input can be given and, if necessary stopped and returned to
the background. This
 stty command might be a good thing to put in your
 .login file if you do not like output from background jobs interrupting
your work. It also can reduce the need for redirecting the output
of background jobs if the output is not very big:

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

Thus after some time the `wc' command, which counts the lines, words
and characters in a file, had one line of output. When it tried to
write this to the terminal it stopped. By restarting it in the
foreground we allowed it to write on the terminal exactly when we were
ready to look at its output.
Programs which attempt to change the mode of the terminal will also
block, whether or not
 tostop is set, when they are not in the foreground, as
it would be very unpleasant to have a background job change the state
of the terminal.

Since the
 jobs command only prints jobs started in the currently executing shell,
it knows nothing about background jobs started in other login sessions
or within shell files. The
 ps can be used in this case to find out about background jobs not started
in the current shell.

Working Directories

As mentioned in section 1.6, the shell is always in a particular
 "working directory." The `change directory' command
 chdir (its
short form
 cd may also be used)
changes the working directory of the shell,
that is, changes the directory you
are located in.

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

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

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

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

cd

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

cd ..

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

cd ../programs

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

The shell always remembers the pathname of its current working directory in
the variable
 cwd. The shell can also be requested to remember the previous directory when
you change to a new working directory. If the `push directory' command
 pushd is used in place of the
 cd command, the shell saves the name of the current working directory
on a
 "directory stack" before changing to the new one.
You can see this list at any time by typing the `directories'
command
 dirs.
% pushd newpaper/references
~/newpaper/references ~
% pushd /usr/lib/tmac
/usr/lib/tmac ~/newpaper/references ~
% dirs
/usr/lib/tmac ~/newpaper/references ~
% popd
~/newpaper/references ~
% popd
~
%

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

The
 pushd command with no argument
alternates the current directory with the first directory in the
list.
The `pop directory'
 popd command without an argument returns you to the directory you were in prior to
the current one, discarding the previous current directory from the
stack (forgetting it).
Typing
 popd several times in a series takes you backward through the directories
you had been in (changed to) by
 pushd command.
There are other options to
 pushd and
 popd to manipulate the contents of the directory stack and to change
to directories not at the top of the stack; see the
 csh manual page for details.

Since the shell remembers the working directory in which each job
was started, it warns you when you might be confused by restarting
a job in the foreground which has a different working directory than the
current working directory of the shell. Thus if you start a background
job, then change the shell's working directory and then cause the
background job to run in the foreground, the shell warns you that the
working directory of the currently running foreground job is different
from that of the shell.

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

This way the shell warns you when there
is an implied change of working directory, even though no cd command was
issued. In the above example the `ed' job was still in `/mnt/bill/project'
even though the shell had changed to `/mnt/bill'.
A similar warning is given when such a foreground job
terminates or is suspended (using the \s-2STOP\s0 signal) since
the return to the shell again implies a change of working directory.

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

These messages are sometimes confusing if you use programs that change
their own working directories, since the shell only remembers which
directory a job is started in, and assumes it stays there.
The `-l' option of
 jobs will type the working directory
of suspended or background jobs when it is different
from the current working directory of the shell.

Useful built-in commands

We now give a few of the useful built-in commands of the shell describing
how they are used.

The
 alias command described above is used to assign new aliases and to show the
existing aliases.
With no arguments it prints the current aliases.
It may also be given only one argument such as

alias ls

to show the current alias for, e.g., `ls'.

The
 echo command prints its arguments.
It is often used in
 "shell scripts" or as an interactive command
to see what filename expansions will produce.

The
 history command will show the contents of the history list.
The numbers given with the history events can be used to reference
previous events which are difficult to reference using the
contextual mechanisms introduced above.
There is also a shell variable called
 prompt. By placing a `!' character in its value the shell will there substitute
the number of the current command in the history list.
You can use this number to refer to this command in a history substitution.
Thus you could

set prompt=\'\e! % \'

Note that the `!' character had to be
 escaped here even within `\'' characters.

The
 limit command is used to restrict use of resources.
With no arguments it prints the current limitations:

cputime unlimited
filesize unlimited
datasize 5616 kbytes
stacksize 512 kbytes
coredumpsize unlimited
.so  tabs

Limits can be set, e.g.:

limit coredumpsize 128k

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

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

The
 rehash command causes the shell to recompute a table of where commands are
located. This is necessary if you add a command to a directory
in the current shell's search path and wish the shell to find it,
since otherwise the hashing algorithm may tell the shell that the
command wasn't in that directory when the hash table was computed.

The
 repeat command can be used to repeat a command several times.
Thus to make 5 copies of the file
 one in the file
 five you could do

repeat 5 cat one >> five


The
 setenv command can be used
to set variables in the environment.
Thus

setenv TERM adm3a

will set the value of the environment variable \s-2TERM\s0
to
`adm3a'.
A user program
 printenv exists which will print out the environment.
It might then show:

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


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

source .cshrc

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

The
 time command can be used to cause a command to be timed no matter how much
\s-2CPU\s0 time it takes.
Thus

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

indicates that the
 cp command used a negligible amount of user time (u)
and about 1/10th of a system time (s); the elapsed time was 1 second (0:01),
there was an average memory usage of 2k bytes of program space and 1k
bytes of data space over the cpu time involved (2+1k); the program
did three disk reads and two disk writes (3+2io), and took one page fault
and was not swapped (1pf+0w).
The word count command
 wc on the other hand used 0.1 seconds of user time and 0.1 seconds of system
time in less than a second of elapsed time.
The percentage `13%' indicates that over the period when it was active
the command `wc' used an average of 13 percent of the available \s-2CPU\s0
cycles of the machine.

The
 unalias and
 unset commands can be used
to remove aliases and variable definitions from the shell, and
 unsetenv removes variables from the environment.

What else?

This concludes the basic discussion of the shell for terminal users.
There are more features of the shell to be discussed here, and all
features of the shell are discussed in its manual pages.
One useful feature which is discussed later is the
 foreach built-in command which can be used to run the same command
sequence with a number of different arguments.

If you intend to use \s-2UNIX\s0 a lot you you should look through
the rest of this document and the csh manual pages (section1) to become familiar
with the other facilities which are available to you.
.bp