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"
mail
endif
This file contains several commands to be executed by UNIX each time I login. The first is a set command which is interpreted directly by the shell. It sets the shell variable ignoreeof which causes the shell to not log me off if I hit ^D. Rather, I use the logout command to log off of the system. By setting the mail variable, I ask the shell to watch for incoming mail to me. Every 5 minutes the shell looks for this file and tells me if more mail has arrived there. An alternative to this is to put the command
biff y
Next I set the shell variable `time' to `15' causing the shell to automatically print out statistics lines for commands which execute for at least 15 seconds of CPU time. The variable `history' is set to 10 indicating that I want the shell to remember the last 10 commands I type in its history list, (described later).
I create an alias ``ts'' which executes a tset(1) command setting up the modes of the terminal. The parameters to tset indicate the kinds of terminal which I usually use when not on a hardwired port. I then execute ``ts'' and also use the stty 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 commands from the terminal, prompting for each with `% '. When I log off (by giving the logout command) the shell will print `logout' and execute commands from the file `.logout' if it exists in my home directory. After that the shell will terminate and UNIX will log me off the system. If the system is not going down, I will receive a new login message. In any case, after the `logout' message the shell is committed to terminating and will take no further input from my terminal.
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 mechanism. The shell variables most commonly referenced are, however, those which the shell itself refers to. By changing the values of these variables one can directly affect the behavior of the 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
% set argv () cwd /usr/bill home /usr/bill path (. /usr/ucb /bin /usr/bin) prompt % shell /bin/csh status 0 term c100rv4pna user bill %
A number of locally developed programs on the system live in the directory `/usr/local'. If we wish that all shells which we invoke to have access to these new programs we can place the command
set path=(. /usr/ucb /bin /usr/bin /usr/local)
set
One thing you should be aware of is that the shell examines each directory which you insert into your path and determines which commands are contained there. Except for the current directory `.', which the shell treats specially, this means that if commands are added to a directory in your search path after you have started the shell, they will not necessarily be found by the shell. If you wish to use a command which has been added in this way, you should give the command
rehash
Other useful built in variables are the variable home which shows your home directory, cwd which contains your current working directory, the variable ignoreeof which can be set in your .login file to tell the shell not to exit when it receives an end-of-file from a terminal (as described above). The variable `ignoreeof' is one of several variables which the shell does not care about the value of, only whether they are set or unset. Thus to set this variable you simply do
set ignoreeof
unset ignoreeof
Finally, some other built-in shell variables of use are the variables noclobber and mail. The metasyntax
> filename
set noclobber
date > now
date >! now
The shell can maintain a history list into which it places the words of previous commands. It is possible to use a notation to reuse commands or words from commands in forming new commands. This mechanism can be used to repeat previous commands or to correct minor typing mistakes in commands.
The following figure gives a sample session involving typical usage of the history mechanism of the shell.
% cat bug.c
main()
{
printf("hello);
}
% cc !$
cc bug.c
"bug.c", line 4: newline in string or char constant
"bug.c", line 5: syntax error
% ed !$
ed bug.c
29
4s/);/"&/p
printf("hello");
w
30
q
% !c
cc bug.c
% a.out
hello% !e
ed bug.c
30
4s/lo/lo\\n/p
printf("hello\n");
w
32
q
% !c -o bug
cc bug.c -o bug
% size a.out bug
a.out: 2784+364+1028 = 4176b = 0x1050b
bug: 2784+364+1028 = 4176b = 0x1050b
% ls -l !*
ls -l a.out bug
-rwxr-xr-x 1 bill 3932 Dec 19 09:41 a.out
-rwxr-xr-x 1 bill 3932 Dec 19 09:42 bug
% bug
hello
% num bug.c | spp
spp: Command not found.
% ^spp^ssp
num bug.c | ssp
1 main()
3 {
4 printf("hello\n");
5 }
% !! | lpr
num bug.c | ssp | lpr
%
After this recompilation, we ran the resulting `a.out' file, and then noting that there still was a bug, ran the editor again. After fixing the program we ran the C compiler again, but tacked onto the command an extra `-o bug' telling the compiler to place the resultant binary in the file `bug' rather than `a.out'. In general, the history mechanisms may be used anywhere in the formation of new commands and other characters may be placed before and after the substituted commands.
We then ran the `size' command to see how large the binary program images we have created were, and then an `ls -l' command with the same argument list, denoting the argument list `!*'. Finally we ran the program `bug' to see that its output is indeed correct.
To make a numbered listing of the program we ran the `num' command on the file `bug.c'. In order to compress out blank lines in the output of `num' we ran the output through the filter `ssp', but misspelled it as spp. To correct this we used a shell substitute, placing the old text and new text between `^' characters. This is similar to the substitute command in the editor. Finally, we repeated the same command with `!!', but sent its output to the line printer.
There are other mechanisms available for repeating commands. The history command prints out a number of previous commands with numbers by which they can be referenced. There is a way to refer to a previous command by searching for a string which appeared in it, and there are other, less useful, ways to select arguments to include in a new command. A complete description of all these mechanisms is given in the C shell manual pages in the UNIX Programmer's Manual.
The shell has an alias mechanism which can be used to make transformations on input commands. This mechanism can be used to simplify the commands you type, to supply default arguments to commands, or to perform transformations on commands and their arguments. The alias facility is similar to a macro facility. Some of the features obtained by aliasing can be obtained also using shell command files, but these take place in another instance of the shell and cannot directly affect the current shells environment or involve commands such as cd which must be done in the current shell.
As an example, suppose that there is a new version of the mail program on the system called `newmail' you wish to use, rather than the standard mail program which is called `mail'. If you place the shell command
alias mail newmail
mail bill
alias ls ls -s
alias dir ls -s
dir ~bill
ls -s /mnt/bill
Thus the alias mechanism can be used to provide short names for commands, to provide default arguments, and to define new short commands in terms of other commands. It is also possible to define aliases which contain multiple commands or pipelines, showing where the arguments to the original command are to be substituted using the facilities of the history mechanism. Thus the definition
alias cd 'cd \!* ; ls '
alias whois 'grep \!^ /etc/passwd'
Warning: The shell currently reads the .cshrc file each time it starts up. If you place a large number of commands there, shells will tend to start slowly. A mechanism for saving the shell environment after reading the .cshrc file and quickly restoring it is under development, but for now you should try to limit the number of aliases you have to a reasonable number... 10 or 15 is reasonable, 50 or 60 will cause a noticeable delay in starting up shells, and make the system seem sluggish when you execute commands from within the editor and other programs.
There are a few more notations useful to the terminal user which have not been introduced yet.
In addition to the standard output, commands also have a diagnostic output which is normally directed to the terminal even when the standard output is redirected to a file or a pipe. It is occasionally desirable to direct the diagnostic output along with the standard output. For instance if you want to redirect the output of a long running command into a file and wish to have a record of any error diagnostic it produces you can do
command >& file
command |& lpr
Finally, it is possible to use the form
command >> file
When one or more commands are typed together as a pipeline or as a sequence of commands separated by semicolons, a single job is created by the shell consisting of these commands together as a unit. Single commands without pipes or semicolons create the simplest jobs. Usually, every line typed to the shell creates a job. Some lines that create jobs (one per line) are
sort < data ls -s | sort -n | head -5 mail harold
If the metacharacter `&' is typed at the end of the commands, then the job is started as a background job. This means that the shell does not wait for it to complete but immediately prompts and is ready for another command. The job runs in the background at the same time that normal jobs, called foreground jobs, continue to be read and executed by the shell one at a time. Thus
du > usage &
% du > usage & [1] 503 % mail bill How do you know when a background job is finished? EOT [1] - Done du > usage %
Jobs are recorded in a table inside the shell until they terminate. In this table, the shell remembers the command names, arguments and the process numbers of all commands in the job as well as the working directory where the job was started. Each job in the table is either running in the foreground with the shell waiting for it to terminate, running in the background, or suspended. Only one job can be running in the foreground at one time, but several jobs can be suspended or running in the background at once. As each job is started, it is assigned a small identifying number called the job number which can be used later to refer to the job in the commands described below. Job numbers remain the same until the job terminates and then are re-used.
When a job is started in the backgound using `&', its number, as well as the process numbers of all its (top level) commands, is typed by the shell before prompting you for another command. For example,
% ls -s | sort -n > usage & [2] 2034 2035 %
As mentioned in section 1.8, foreground jobs become suspended by typing ^Z which sends a STOP signal to the currently running foreground job. A background job can become suspended by using the stop command described below. When jobs are suspended they merely stop any further progress until started again, either in the foreground or the backgound. The shell notices when a job becomes stopped and reports this fact, much like it reports the termination of background jobs. For foreground jobs this looks like
% du > usage ^Z Stopped %
% sort usage & [1] 2345 % stop %1 [1] + Stopped (signal) sort usage %
% du > usage ^Z Stopped % bg [1] du > usage & %
All job control commands can take an argument that identifies a particular job. All job name arguments begin with the character `%', since some of the job control commands also accept process numbers (printed by the ps command.) The default job (when no argument is given) is called the current job and is identified by a `+' in the output of the jobs command, which shows you which jobs you have. When only one job is stopped or running in the background (the usual case) it is always the current job thus no argument is needed. If a job is stopped while running in the foreground it becomes the current job and the existing current job becomes the previous job - identified by a `-' in the output of jobs. When the current job terminates, the previous job becomes the current job. When given, the argument is either `%-' (indicating the previous job); `%#', where # is the job number; `%pref' where pref is some unique prefix of the command name and arguments of one of the jobs; or `%?' followed by some string found in only one of the jobs.
The jobs command types the table of jobs, giving the job number, commands and status (`Stopped' or `Running') of each backgound or suspended job. With the `-l' option the process numbers are also typed.
% du > usage & [1] 3398 % ls -s | sort -n > myfile & [2] 3405 % mail bill ^Z Stopped % jobs [1] - Running du > usage [2] Running ls -s | sort -n > myfile [3] + Stopped mail bill % fg %ls ls -s | sort -n > myfile % more myfile
The fg command runs a suspended or background job in the foreground. It is used to restart a previously suspended job or change a background job to run in the foreground (allowing signals or input from the terminal). In the above example we used fg to change the `ls' job from the background to the foreground since we wanted to wait for it to finish before looking at its output file. The bg command runs a suspended job in the background. It is usually used after stopping the currently running foreground job with the STOP signal. The combination of the STOP signal and the bg command changes a foreground job into a background job. The stop command suspends a background job.
The kill command terminates a background or suspended job immediately. In addition to jobs, it may be given process numbers as arguments, as printed by ps. Thus, in the example above, the running du command could have been terminated by the command
% kill %1 [1] Terminated du > usage %
The notify command (not the variable mentioned earlier) indicates that the termination of a specific job should be reported at the time it finishes instead of waiting for the next prompt.
If a job running in the background tries to read input from the terminal it is automatically stopped. When such a job is then run in the foreground, input can be given to the job. If desired, the job can be run in the background again until it requests input again. This is illustrated in the following sequence where the `s' command in the text editor might take a long time.
% ed bigfile 120000 1,$s/thisword/thatword/ ^Z Stopped % bg [1] ed bigfile & % . . . some foreground commands [1] Stopped (tty input) ed bigfile % fg ed bigfile w 120000 q %
The command
stty tostop
% 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
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.
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 %
No matter where you have moved to in a directory hierarchy, you can return to your `home' login directory by doing just
cd
cd ..
cd ../programs
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 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)
% fg ed prog.c (wd: ~/myproject) . . . after some editing q (wd now: ~) %
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
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='\! % '
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
limit coredumpsize 128k
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
% 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
The time command can be used to cause a command to be timed no matter how much CPU time it takes. Thus
% time cp /etc/rc /usr/bill/rc
0.0u 0.1s 0:01 8% 2+1k 3+2io 1pf+0w
% time wc /etc/rc /usr/bill/rc
52 178 1347 /etc/rc
52 178 1347 /usr/bill/rc
104 356 2694 total
0.1u 0.1s 0:00 13% 3+3k 5+3io 7pf+0w
%
The unalias and unset commands can be used to remove aliases and variable definitions from the shell, and unsetenv removes variables from the environment.
This concludes the basic discussion of the shell for terminal users. There are more features of the shell to be discussed here, and all features of the shell are discussed in its manual pages. One useful feature which is discussed later is the foreach built-in command which can be used to run the same command sequence with a number of different arguments.
If you intend to use UNIX a lot you should look through the rest of this document and the csh manual pages (section1) to become familiar with the other facilities which are available to you.