%**start of header
\input eplain
\input macs
%**end of header
{\input cover }
\centerline{\fa Contents}
\vfill \readtocfile
\vfill\eject     \pageno=1
\ha A Fresh Start;

This text aims to be a serious introduction to academic computing. 
It is intended to prepare students for a comprehensive introduction to
computer science but is not, itself, such a course. Rather, it
provides an introduction to programming and accustoms students to
using complex programs. My approach is baroque rather than classical,
exploratory rather than axiomatic, organic rather than architectural. 
In teaching such a course, even to well prepared and
motivated students, the fundamental problem is to find meaningful
examples of programs and tasks. This  is my attempt to
solve this problem in a way that provides a foundation for further
studies.

In calling my approach baroque, I mean to suggest that we will be
working with large, complex programs with many convolutions and
interconnections. Not only are such programs and systems very common
but also, in my opinion, they are more interesting. Life, itself, is
very baroque and art {\it should} be imitative as it trys to create
patterns and structures in order to cultivate this vitality. Rigid
abstract structures developed for their own sakes, while modern, are
boring.

On the other hand, this very complexity can be intimidating. Thus, 
students need help in learning how to `explore the country' whether
this is in finding paths to the heartland, backtracking out of dead
ends, or planning for logistic support.  We're more concerned with the 
search for fundamentals than in relying upon presently accepted
building codes. 

In fact, we're not really concerned with building stuff at all.
Rather, this text just provides basic materials that can be used as
resources as the course grows. This growth should be controlled by the
interests and abilities of the students whom it is the responsibility
of the teacher to lead. The course should follow the students who are
following the teacher's lead.

The instruction is meant to follow an apprenticeship model more than a
scholastic model. Hence, we want to look at code produced by skilled 
professionals (but which is still understandable and significant to 
beginning young students).

So, what region should we explore? 
Although there are many appropriate text-processing tasks (and
suitable languages, e.g. AWK, for this programming), graphics-based
tasks are more interesting and vivid to the students.  However, none
of the standard languages are really appropriate for such work. While
one can make a special graphics package for, say, Pascal, the
resources provided are typically not extensive enough nor sufficiently
integrated into the basic syntax of the language.

\ha METAFONT;
 
Donald Knuth designed \mf\ as a fontmaking language to support his
\TeX\ typesetting language.  Thus, all the graphics support one needs
is built into the system. At the same time, \mf\ is a fullscale
programming language with assignments, loops, scoping and parameter
passing. Furthermore, \mf's equations provide an introduction to
declarative programming languages and its macro facilities enable one
to glimpse what is going on ``inside'' a programming language.  
Source code for \mf\ is freely available and free executables are
available for personal computers.
\smallskip
{\input fontchart \font\startfont=cmr10 at 10truept \table }
\smallskip\centerline{\bf Computer Modern Roman 10 point}
\smallskip
\mf\ is the primary programming language used in this text. I focus
primarily on simple drawing; however making a complete font provides a
good opportunity to present the complications of scale that accompany
a large programming project. In addition, such a project enables one
to appeal to a broader range of student talents and interests. 
The course works best, I think, if students' artistic skills are
cultivated as well as their ability to think analytically. Different
students will, of course, have different interests and abilities.
Learning how to work together and make the best advantage of this is
also very useful and provides a good introduction to software
engineering and related issues.  I hope this text will be of use for a
course at our school, Dayspring Christian Academy, and that we will be
able to include a sample of designing a font for the Wycliffe Bible
Translators.



\ha LINUX;

However, besides a programming language, one needs an operating
system. The system must support our programming well; in particular,
one must be able
to interactively write \mf\ code and look at the results
simultaneously. Hence, some sort of graphical windowing system is
essential.  We will be working with many files and directories and
will have need for a wide variety of support programs. In addition, we
want to use a system that will not be `outgrown' and which will also
provide a foundation for using and studying operating systems
themselves.  Furthermore, in our school environment, a multi-user
system is most efficient.  All of this leads one to want a Unix
workstation environment; however, the cost is prohibitive.

Rather, we use Linux, a largely POSIX-compliant multi-user operating
system whose kernel is written by Linus Torvalds, a graduate student
at the University of Helsinki. Linux is freely redistributable (under
the GNU copyleft) and runs on INTEL 386 cpu/IBM AT bus architectures.
It is sufficiently compatible with BSD and SYSV
UNIX that all of the software we need compiles ``out of the box.''  As
with Unix, the word Linux is often used to refer not just to the
operating system kernel itself, but also to the various systems and
applications software commonly available with the system. Much of
Linux's system software comes from the Free Software Foundation's GNU
project. GNU Emacs is our standard text editor (and lisp interpreter,
calculator, and symbolic math solver) and {\tt gcc} is the
standard C compiler.  \TeX\ and \mf, which provide a state of the art
typesetting environment, are also a standard part of Linux
and many other programs of interest to the academic community
(graphical FEM,
2 and 3D plotters, GUI builders, etc.) are
freely available. MIT's X Windows (X11R5 in its XFree86 version for 386
compatible machines) provides the graphical interface and various
graphic utilities. Linux also has full TCP/IP networking support and
there is a very active user/developer community available via the
Internet.  

All of the above software is free; not only does this save money, it
makes technical support, bug fixes and program updates more readily
available. Since the programs are free, and since they are widely
available, this text can refer to more programs and speak more
specifically and concretely than otherwise possible. Furthermore,
since source code is available for all the programs, the same system
that the students are first introduced to can also serve them well if
they continue to courses in operating systems, language theory,
systems engineering, etc. 

\mf\ itself is very well
documented by its author, Donald Knuth: {\it The METAFONTbook\/}, a
comprehensive user's guide and description of the programming language
and its standard macro package, {\it Computer Modern Typefaces},
attractively typeset source code for all the Computer Modern fonts
together with proof samples for font designers, and {\it METAFONT: The
Program}, which 
thoroughly documents the code of the program itself--a wide range
of programming paradigms are discussed here for professional programmers.

\ha MILIEU;

The close association of \mf\ and Linux is specific to this text; many
Linux users may use \TeX\ and/or \mf\ little, if at all. The Linux
Documentation Group is using \TeX\ for their work. I hope to write 
in a way that will be useful even if one is only interested in 
Linux  and also to provide useful information on Emacs, Emacs Lisp, 
and, perhaps, even Cweb. Nevertheless, my discussion of these
various topics will always be centered around \mf-related tasks. 
{\bf Warning:} I certainly don't claim any expertise regarding Linux,
\mf, or any of the other programs I discuss. I teach English as a
Second Language and Technical Writing; I'm very much an amateur
programmer.  I'm teaching myself as I write this; please join me in 
this endeavor. One reason that this text is publically available for 
ftp is to see if the same advantages that I claim for publically
available source code also apply to manuscripts. The free flow of
information is important to academic computing; most of the tension
between academic computing and business computing is that the two
areas have different aims and values. This text's focus is on academic
computing. For example, suppose one wants to make a black and white
logo. If it's just for some specific hardware, one could use a bitmap
editor such as MacPaint. If output device independence is needed, then
one could use Corel Draw, etc. 
In both cases, however, one needs a certain
program to determine what the logo looks like and still one has no
understanding as to the rationale behind the design. On the other
hand, with \mf\ one has a program that anyone can read which precisely
defines the logo in a device independent fashion and through which one
can explain various design considerations. Furthermore the source code
for the necessary programs to output the logo to various devices is 
freely available. This portability and archivibility is important to
academic enterprises.

It is true that our system places restrictions on the hardware; I
hope that this does not place too much of a financial burden on people
that would otherwise be happy with our approach. In calling this text,
{\it METAFONT and Linux: a Personal Computing Milieu,\/} the word
personal refers not to PC's but rather to the effort to personalize
one's computing system. There is an international `community' involved
in making such systems possible, hence the word {\it Milieu.\/}   


\ha Hardware;

First we will discuss building a particular type of computer suitable
for Linux. This will also provide the necessary information one needs
if one prefers to buy the computer. There are, however, advantages to
building it oneself: first and foremost, it is a good learning
experience --- it is interesting and also removes some of the mystery
which prevents students from being comfortable with computers;
furthermore, it allows one to have a system with precisely what one
needs and can afford; finally, one can, perhaps, save a slight bit of
money (especially if one can buy parts in bulk).
We will be building a 486/33, ISA bus computer with 16 megs
of ram (a 386/40 would also be fine). A 200 meg fixed disk is more
than adequate; half that would be fine but wouldn't be as good a buy. 
 Eight megs of ram is sufficient;
however, with the memory designs commonly used, adding more memory may
then mean scraping what one has.  

Of course, how you will be using the system determines where you
should spend your money. In deciding, one major concern should be 
the upgradability of the the system; don't put much money into
something that will have to be scrapped later. Browse in the various
trade magazines for product reviews; however, bear in mind that you
will be using the hardware for a different OS than what the reviewers
had in mind.
\hb Suggestions;
\item{1)} If your primary concern is that the system be fast, get a
486/66 with 16 megabits of ram (i.e. 4 4meg simms).  If you plan on 
making major use of {\tt gcc}, for example, frequent kernel
recompiles, etc., this is a good choice. Although Linux uses memory very
efficiently, programs such as {\tt gcc} and X
Windows use lots of memory and 8 megs isn't quite enough. If you will be doing
significant graphical work, you may want to 
get one of the video accelerators such
as ATI's Graphic Ultra or Orchid's Fahrenheit (make sure that your
card is supported by the X server that you will be using, see Appendix
1). A Tseng ET4000 based 
card on a VESA local bus is another, but slower, choice (XFree86 includes
special optimizations for the ET4000 chip).

\item{2)} If graphics are important, get a good monitor. Whatever
monitor you get, if you are going to use X Windows at all, make sure
the monitor can do 1024x768 extended VGA with an adequate refresh rate
(at least 70Hz, in my opinion). Thus, the monitor needs to be
multisyncing and to support a horizontal scan rate of at least 56khz 
(65khz would be better). Then, get the biggest monitor that you can
afford. Don't believe monitor specs; the diagonal sizes that are
advertised are usually optimistic. Frequently the image can't be
stretched to fill the entire screen. At any rate, take a ruler with
you and look at the monitor, if possible. While writing this text, I
used a 14" Viewsonic 5e (about \$420) and a 17" CTX 1760DF (about
\$820). If a good color monitor is too expensive, 
I suggest that you get the best monochrome monitor you can find.

\item{3)} Linux makes very efficient use of disk space so
unless you are doing something like compiling the entire X11
distribution yourself, a big fixed disk is not needed. An 80--130 meg
disk is fine; my personal opinion is that two small disks are better
than one large disk. Thus my recommendation is: if needed disk space is
${}<=130$, get one IDE fixed disk, if ${}<=450$, get two. Linux also
supports scsi disks--if you will also have scsi tape, cdrom, etc.,
this is a better option.
\smallskip
\noindent{\bf Exercise:} You're building a 486-based computer for your boss;
what  component will have the most influence in conveying an
impression of quality construction?

\ha Software;

Next, we need to get our operating system. There are various packaged
collections of Linux kernel, systems and applications software
available. The most widely available is the SoftLanding System (SLS)
archive which is mirrored at various sites and has a home at
tsx-11.mit.edu, dir pub/linux/SLS.  Other packages include Lu's
rootdisk/basedisk set (tsx-11.mit.edu, pub/linux/GCC), and LeBlanc's
excellent MCC-Interim package (hpb.mcc.ac.uk, pub/linux).

We will, however, be using the Milieu package especially designed to
go with 
this text. This package has a home at tsx-11.mit.edu, dir
pub/linux/packages/TeX/Milieu. If you have use of a machine with
Internet access, you might try {\tt archie Milieu} to get a list of
various other sites archiving this package. 

The files we need break down to four categories: 1) basic kernel (\kerver) and
utilities (\gccver),  2) \mf\ and \TeX (\mfver), 3) basic X
Windows (\xver), and 4) GNU Emacs (\emacsver).  
For each of these categories there are certain essential files and
then lots of enhancements and frills one can choose.  The Milieu
package was put together from various sources with the following
constraints: the entire system (including an emergency dos disk) must fit
on 5 $3.5''$ floppies and it must
include all the programs and files needed for this text. 

The Milieu package is certainly not comprehensive. For example, the
\TeX\ package doesn't include any La\TeX\ support, many basic file and
system utilities are missing, and there is no support for X Windows
programming. All these are widely available elsewhere. On the other
hand, the Milieu package permits you to carry one of those little 5
disk boxes and change any willing 386/AT bus computer with an IDE
fixed drive\footnote{${}^1$}{Linux also supports SCSI drives, I just
haven't compiled in support} into a multi-user workstation. 

\hb  Installing Linux via the Milieu package;

\i0; Get the Milieu files.

\i1; Make a dos bootable floppy (with format.exe and fdisk.exe on it)
and put \hfil\break 
{\tt bootlin.com, config.lnx, gzip.exe, rawrite.exe, 
and vmlinux} on it. 

\i2; On four other dos floppies, put 1) {\tt tex.tz}, 2) {\tt 
xfree86.tz}, 3) {\tt emacs.tz}, 
and 4) {\tt rootdisk.z}, which will be overwritten 
during the installation. There are also some additional
files you may want: {\tt usrlib.tz,usrbin.tz} contain the GNU C
compiler and miscellenious support files, {\tt gnuplot.tz} contains a
scientific plotting program (with \mf\ support), {\tt i-calc.tz} has the
Calc info files and {\tt elispman.tz} is the GNU Emacs Lisp manual.

You may want another disk for the kernel source. You can,
and may need to, arrange the disk contents differently, of course.

\i3; You will need at least a 40meg partition on the fixed disk. If
necessary, backup your files now.

\i4; Copy  {\tt bootlin.com, config.lnx, gzip.exe, rawrite.exe, 
vmlinux,} and\hfil\break {\tt rootdisk.z} to C:$\b$. Now, do
{\tt gzip -d 
rootdisk.z}, then run {\tt rawrite}; tell rawrite which floppy to write
to and write {\tt rootdisk} to the floppy that has {\tt rootdisk.z} on
it. Next, copy {\tt config.lnx} to {\tt config.sys} and reboot.

\i5; Bootlin will boot the vmlinux kernel and prompt you for a
location for the root filesystem. Insert the rootdisk floppy and
respond appropriately. Once the system loads, login as root. You are
now running Linux from the floppy. 

\i6; Run {\tt fdisk}, leave /dev/hda1 for dos, make /dev/hda2 for
linux, /dev/hda3 for swap (say 10megs), and the rest as you please.
On my maxtor 213, I have:
{\tt \obeylines
/book > fdisk
Using /dev/hda as default device!

Command (m for help): p

Disk /dev/hda: 16 heads, 38 sectors, 683 cylinders
Units = cylinders of 608 * 512 bytes

   Device Boot  Begin   Start     End  Blocks   Id  System
/dev/hda1   *       1       1     213   64733    6  DOS 16-bit >=32M
/dev/hda2         214     214     426   64752   81  Linux/MINIX
/dev/hda3         427     427     470   13376   82  Linux swap
/dev/hda4         471     471     683   64752   81  Linux/MINIX

}

\i7; Now you can install to your fixed disk. Reboot and mount the
rootdisk floppy. Use mkfs to put a minix 
filesystem on /dev/hda2 (or wherever).
Also use mkswap to make swap and move rootdisk stuff to your new 
partition. For example:
{\tt \obeylines
mkfs -c -n30 /dev/hda2 64752
mkswap -c /dev/hda3 13376
swapon /dev/hda3
mount /dev/hda2 /mnt
cd /
for i in bin dev etc lib root tmp
do
tar rvf /mnt/t.t \$i
done
cd /mnt; tar xvf t.t;rm t.t}

\i8; Reboot with the dos floppy disk and format the dos partition (if you
didn't make the partition active with linux's {\tt fdisk}, use the dos
fdisk) with {\tt format c:/s}. Then restore files to your dos partition
(including vmlinux and bootlin.com). Again use bootlin to boot the
linux kernel but now use /dev/hda2 for your root filesystem. Untar the 
various other tz's ({\it note:} they are compressed with gzip, to which
uncompress, etc. are linked), for example: 
{\tt \obeylines
cd /
mkdir /fd
mount -t msdos /dev/fd0 fd
tar zxvf /fd/tex.tz
sync
umount /dev/fd0 \par}
and you're all set (mread could also be used; in that case, don't
mount the dos
floppy. That's faster; I just wanted to show that Linux can read/write
dos filesystems). To automate the bootup, either:
 1) install {\tt lilo}, or 2) recompile the kernel or use rdev, Norton
Utilities, etc to change the root device in vmlinux (for example:
{\tt rdev vmlinux /dev/hda2}) and then continue to use {\tt
bootlin}. You may want to put the floppy installation files on your 
dos partition. To remake the rootdisk.z, do{\tt \obeylines
dd if=/dev/fd0 of=rootdisk bs=1024    \% or /dev/fd1, as appropriate
compress -9 rootdisk; cp rootdisk.z /dos/linux/backup   \%for example
\par}

\ha Operation System Basics;

We just discuss here the bare minimum needed to use Linux. We want to
start programming as soon as possible. 

To get a brief overview of the files in the Milieu package that you
have installed, enter {\tt pushd /; du -b|more;popd},
this will show you the size (in bytes) of each directory. Press the
spacebar to page through the file (b to backup one page, q to quit).
Pushd is an internal command for the bash (Bourne-Again SHell)
shell which saves the current directory on a stack and moves to the
directory specified. Multiple commands can be given on a line by
separating the commands with a `;'. Du gives you a listing of the Disk
Usage and the `{\tt |}' pipes its output into the {\tt more} file viewer.
Finally, we pop the directory off the stack and are back where we
were. You might also want to sort the result by size by using {\tt
sort -nr} (numeric, reverse).

See Appendix 2 for a brief summary of usage for various
executables in the package. In particular, I assume that you
can use one of the text editors on your system. 
Speaking of editors, the Milieu package includes three: {\tt ed} the
line/script oriented editor\footnote{${}^2$}{See Appendix 1 of
Kernighan and Pike's {\it The UNIX Programming Environment.\/}}, {{\it
jove\/}} an emacs clone which is nice for quick little editing jobs,
and GNU Emacs.\footnote{${}^3$}{See Abrahams and Larson's standard UNIX
reference, {\it UNIX for the Impatient.\/}} To view a 
reference card on Emacs, start X Windows by entering {\tt startx} and
then hold down the right mouse button and move down to the Xterm menu
selection.
Inside the xterm window, do {\tt \obeylines
cd /usr/emacs/etc
sed s/columnsperpage=1/columnsperpage=3/ refcard.tex >emacs.tex
tex emacs
xdvi -s 2 -paper usr -offset 1in -l emacs\par} You can use the arrow
keys to move around on the page (press d to move down, 4s to zoom out;
if there were 
more pages, {\tt n,p,3g} could be used to move to next, previous, and
page 3).

See Appendix 4 if you have trouble starting X.

We will discuss
customizing your {\tt .emacs} file and also {\tt elisp} programming in
a later chapter. You should look at {\tt /root/.emacs} (see Appendix
3) now, however,
to see what default keybindings I've given the function keys, etc. 

I usually log in as {\tt root}; it teachs one to be careful! It is
safer to log in as, say, {\tt user} and just log in as root when
necessary in another virtual console.
 
\ha GNU Specifics;

Basic information on {\tt bash}, is available in Gnu Emacs info
format. Start emacs and press the F1 key and then press i to start the
info reader. The {\tt features} and {\tt history} menu entries discuss
the bash shell. The {\tt usrman.tz} package contains some important
manual pages.

Many of the standard utilities included with Linux are GNU
enhancements of standard Unix programs. The number of options can be 
useful, overwhelming, or amusing, depending on your point of view.  
If, for example, you enter {\tt ls -h}, the program will 
respond: {\tt \obeylines
/book > ls -h
ls: unrecognized option `-h'
Usage: ls [-abcdgiklmnpqrstuxABCFLNQRSUX1] 
\qquad [-w cols] [-T cols] [-I pattern] [{-}{-}all] [{-}{-}escape] 
\qquad [{-}{-}directory] [{-}{-}inode] [{-}{-}kilobytes] [{-}{-}literal] 
\qquad [{-}{-}numeric-uid-gid] [{-}{-}hide-control-chars] [{-}{-}reverse] [{-}{-}size] 
\qquad [{-}{-}width=cols] [{-}{-}tabsize=cols] [{-}{-}almost-all] [{-}{-}ignore-backups]
\qquad [{-}{-}classify] [{-}{-}file-type] [{-}{-}ignore=pattern] [{-}{-}dereference]
\qquad [{-}{-}quote-name] [{-}{-}recursive] [{-}{-}sort={none,time,size,extension}]
\qquad [{-}{-}format={long,verbose,commas,across,vertical,single-column}]
\qquad [{-}{-}time={atime,access,use,ctime,status}] [{-}{-}no-color] [path...]}\par
See any Unix reference for the standard options and Appendix 2 for GNU
specifics. Better, experiment with it yourself: {\tt pushd
/root; ls -saFx;cd /usr/TeX/lib\hfill\break ls -FCR {-}{-}format=across 
{-}{-}sort=size|more; popd} (press enter after each line).  One can, of
course, make little shell scripts for frequently used options. For
example, {\tt \obeylines
cat >/bin/lss
ls -lar {-}{-}sort=size \$*
\^d
chmod 755 /bin/lss}  (\^d, the unix end-of-file,
 is my notation for holding down
the control key and pressing d). Emacs has an excellent file
management macro package--inside emacs, 
press \^xd to access {\tt dired} (\^hm for
help). There are also X utilities, such as
xdtm, for file management. Metrolink sells a
Motif package for Linux and has generously made xmfm and other sample 
Motif applications freely available (it is statically linked so one
doesn't have to have Motif to run xmfm).

\vfill\eject

\ha \mf\ Basics;

Let's plunge right in with some sample \mf\ code. The boldface section
headings are what you type.  The subsequent 
paragraphs provide more details; sometimes they explain the previous
code or introduce the following code and other times they introduce 
topics that may be skipped on first reading. 

Run \mf\ by entering (in a {\tt xterm} window! Since we will want to
view our work onscreen, a graphic display is needed) the command, 
{\tt mf}: 

\input ./intromf


\ha Dots, etc.;

First, let's set up our programming environment. Start X {\tt
(startx)} and then launch Emacs (with the
default Milieu setup, press the right mouse button). Press {\tt \^x2}
to split the Emacs screen and then drag one of the corners (put the
cursor over the corner and hold down the left mouse button as you move
the mouse cursor) to make the Emacs window higher. To change Emacs
font, hold down the control key and press the right mouse button 
to raise a menu of fonts from which to choose.

Enter  {\tt \"x shell} (hit the escape key and then x)
 to run an
interactive shell and start \mf\ by entering {\tt mf}. 

I find running \mf\ inside Emacs is more convenient than using an
xterm. Emacs' editing facilities are useful and compensate for \mf's 
lack of a builtin editor ({\it Note:\/} in writing this, I have a 
\TeX\ buffer and a {\tt shell} buffer and cut and paste between them.
To copy, left-click on the first character and then 
right-click just after the last character you want to copy.
The region currently selected will be highlighted. To delete the 
region, right-click again. To paste the region, left-click where you want
it and then middle-click to paste.

You can, of course, also use Emacs keyboard commands. The main point
is that the full power of the Emacs editor is available not only in 
the \TeX\ text buffer, but also in the \mf\ shell buffer).
Various macro packages
provide helpful tools; in particular, the Calc macro package is a
powerful calculator/symbolic mathematics system for Emacs.

Respond to {\tt mf's **} prompt with $\b${\tt relax}. 

\input ./dotsetc

Suppose we want a non-convex dot? Let's make a macro to print a `star'
dot.

\input ./stardot

The log file shows:
{\tt \obeylines;
p1 scaled 5
>> Edge structure at line 32:
row 129: | 100- 100+
row 128: | 100- 100+
row 127: | 99+ 101-
row 126: | 99+ 101-
.
.

p2 scaled 3
>> Edge structure at line 34:
row 29: | 0- 0+
row 28: | 0- 0+
row 27: | -1- 1+
row 26: | -1- 1+
.
.
\par}

\mf\ decides whether a pixel is to be filled by keeping track of `edge
structures'--only changes in the fill number are saved. Pixels with a
fill number greater than zero are blackened.

The {\tt p2} curve has tiny `loops' that confuse \mf.
{\bf Note to
author: }  figure out exactly what's going on here!

\ha A First Program: Tic Tac Toe;

It's high time to write our first \mf\ program. When I was a child, I
saw an exhibit at the Smithsonian (or maybe it was the 1960 Worlds
Fair in New York) in which one played tic-tac-toe against a computer. 
For our first program, let's write a program so two people can play
this on-screen without needing paper.

As mentioned earlier, the default {\tt plain.mf} file includes no way 
for a \mf\ program to find a point's position on the screen. We will
assume that any user of this program is using a base format in which
the pair {\tt screen\_topleft} has been assigned the coordinates of the
top left point of the {\tt mf} screen. 

\input ./ttt3

\ha Program Refinement;

There are several things we could do to improve the TicTacToe program.
Several redundant calculations can be eliminated; while the current
program is fast enough, there's no good reason to waste computer
resources any more than paper. In addition, the current program can
not handle incorrect user input--not only `a3' but even `45' isn't
handled smoothly. However, as far as potential users are concerned,
probably the most important improvement would be to adapt the 
program to work with, say 5x5, or other size boards. 

Instead of taking the board size to be 3, this time let's prompt the 
user for a size and use that (we'll continue using a square board).
As the size gets bigger, screen size becomes more critical so we
change the {\tt topleft} default.

\input ./tttn

\medskip
In the above, we've used the {\tt mft} utility to convert the \mf\
source into attractively typeset code. 

\ha Complex Documents;

As programs and documents become complex, it becomes useful to split them into
pieces. The {\tt make} utility is used to manage the resulting files. 
Here is the {\tt Makefile} for this book:
\medskip {\tt \obeylines
MACROS=/usr/TeX/lib/mf/macros
BASE=/usr/TeX/lib/mf/bases/mf.base
FORMAT=/usr/TeX/lib/tex/formats/tex.fmt
TEXINPUTS=/usr/TeX/lib/tex/inputs
BOOK=/book/milieu.texi

INPUTS = tttn.tex eflask.tex Makefile cmd10.tex llogo.tex $\b$
\qquad   gnuchars.tex linus.tex queen.tex ttt3.tex dotsetc.tex $\b$
\qquad   intromf.tex stardot.tex linusa.tex geo.mf

\#
\#the first target is what is made by default. After the target,
\#we list its dependencies. The following line(s), which are begun
\#with a TAB, tell how to make (or update) the target.
\#

milieu.dvi: macs.tex \$(BOOK) \$(FORMAT) \$(INPUTS) \$(TEXINPUTS)/mftmac.tex 
\qquad tex \$(BOOK) \# note: line begins with TAB (not spaces)

\#
\#We can define general rules. The following, for example, says
\#that the tex files are made by MFT from the corresponding mf files.
\#
\%.tex:\%.mf mplain.mft 
\qquad mft \$$<$ -s ./mplain.mft
\#
\# Finally, some utility targets.
\#
\$(BASE): \$(MACROS)/plain.mf \$(MACROS)/modes.mf
\qquad inimf mf.ini
\qquad mv mf.base /usr/TeX/lib/mf/bases

\$(FORMAT): \$(TEXINPUTS)/plain.tex \$(TEXINPUTS)/hyphen.tex 
\qquad initex tex.ini
\qquad mv tex.fmt /usr/TeX/lib/tex/formats

clean:
\qquad rm -vf *.log *gf *.dvi
}

\ha A First Font;

My son, Daniel, wanted a font with chemistry symbols. First he drew 
a sketch on graph paper and then entered the points into \mf\ and drew
the first `curve'. Initially, there were no units; thus, when we made
the font for a 300dpi printer, the characters were too big. At that
point, I added the {\tt u=pt/36;} definition. Since the point unit
isn't sharped (ie, {\tt pt\#}), it gets converted for the current
device. As a result, what was designed for a 2602dpi device looks ok
on our printer also. 
\medskip
\input ./eflask

\ha Modifying Computer Modern Parameters;

Start Emacs in its own X-window and enter {\tt M-x shell} and {\tt cd
macros} (see Appendix 2 for setting {\tt CDPATH}) to move to the \mf\
font sources. Suppose you want to make a variation on {\tt cmr10} with
thicker hairlines, etc. To look at several parameter files
side-by-side in Emacs, press {\tt C-x 3}. Use {\tt C-x C-f} to
load several parameter files ({\tt C-x o} to change emacs
window, or left-click). You may want to use a smaller font: {\tt M-x
x-set-font 6x13}. As I
write this, I have four parameter files (cmd10,cmr10,ccr10,cmb10) 
across the top of the Emacs
screen, then a horizontal border with two more windows below: one with
the \TeX\ source for this book and the other a shell window.

Use {\tt M-x rename-buffer} to make {\tt cmd10.mf} from {\tt cmr10.mf}
which is our model. We will only change a few of the parameters from
their cmr10 defaults:

\input ./cmd10

\medskip

Save {\tt cmd10.mf}; for a listing of differences, you can do: {\tt
diff cmr10.mf cmd10.mf >diffs}. 
\medskip
We now want to test the font; however, there's not yet a font metric for
it ({\tt cmd10.tfm}) so we can't use \TeX. There are two ways to cope
with this: 1) {\tt cp cmr10.tfm cmd10.tfm} and go ahead and use it;
when we preview, the real {\tt tfm} file will be made along with the
actual packed font bitmap (cmd10.300pk). 2) run {\tt mf
$\b\b$mode=localfont$\b$; input cmd10;gftopk
cmd10.300gf} (the first semicolon is for \mf, the second for the shell) and 
then {\tt cp cmd*pk cmd*.tfm /usr/TeX/lib/tex/fonts}. 
{\bf Warning:} check what path {\tt mf} uses
in searching for font files to make sure that it is using the files
you intend. Also, if you are using {\tt MakeTeXPK}, you may want to
delete its change to a temp dir.

We can now run {\tt tex testfont} to test the font. I tested at {\tt
magstep1} since I was using that. Two problems showed up: first, the
cap stems were a bit too prominent so I changed {\tt cap\_stem}.
The major problem, however, was that the `w' was too dark. Although
{\it Computer Modern Typefaces\/} suggests that {\tt fudge} can be
used to fix this, I found that, in addition, {\tt hefty:=true} was
needed.

This last change has an unintended side-effect on the exclamation and
question marks (see the {\tt bot\_width} definition for the characters
in {\tt punct.mf} and {\tt romanp.mf}, respectively).  However, since
I'm happy with the font otherwise, I'll just pretend the change was
intended! While fixing this is not difficult, it would take us away
from simple changes to the parameter file.

The resulting font, {\tt cmd10 scaled 1200}, reproduces on my 300dpi
LaserJet better than the standard {\tt cmr12}. While not as legible as
Knuth's Concrete, {\tt ccr10}, it has more variety 
than that font. In fact, this text is set with this Computer Modern
Demi-Roman at 12 points.

 

\ha A Logo for Linux;

Logos are meant to give simple and concise symbolic expression of the
nature of 
some group, person, etc. The cross, for example, is the simplest
anthropomorphic symbol I can think of, thus symbolizing Christ's
humanity. Furthermore, it also represents Jesus' divinity in that the
fact of His death is only of ultimate importance to us as
we recognize God reaching out to us through His Son. As Paul says,
``If Christ has not been raised, our preaching is useless and so is
your faith.'' Our conviction of this historical reality by the Holy
Spirit is what gives the cross its significance in our own lives.

Regretfully, few of Linux's users or developers give much regard to
the eternal logos. Nevertheless, I want to make a logo for Linux, one
that will embody its nature.
 It seems appropriate for the logo to
be a program; I'll just use \mf\ to write the letters in a stylized
fashion.  L is for Linux and its creator, Linus Torvalds; in addition,
the U indicates the close association with various other `unix'
systems. I make the bottom stroke of the L so that it cradles the U.
The X could refer to Linux's POSIX compliance; instead, I use it to
say that X Window support is standard. Linux is an `in' unix with X.
Having the `in' separate also conveys that the `i' is short as in 
`lint' rather than as in the famous cartoon character (whose picture
we will also show an encoding for if copyright restrictions permit).

\input ./llogo 

beginchar("l",.7in\#,.5in\#,.05in\#); "The letter l (linux logo)";

$\vdots$

\ha Electronic Documents;

Let's diverge  from \mf\ programming to consider the
electronic production of documents. Certainly, different document
types need different tools for their production. In particular, I want
to discuss Knuth's tools for producing scientific texts such as this
book. 

\hb Ease of Use: The Primary Criteria;

As in any other endeavor, we want our tools to be as easy to use as
possible given our requirements. Namely, although our page layout
requirements are minimal (unlike 6 column newspapers or advertizing
graphics), we do require full support for the two dimensional nature
of typesetting. In addition, we want to be able to compose and edit as
efficiently as possible. Furthermore, the finished document files should
precisely specify the document independently of any specific
equipment. Knuth's \TeX\ typesetting system, which he designed
specifically for the production of beautiful books, especially ones
containing much mathematics, meets these requirements well.  

\hc Two Dimensional Type;

When using a typewriter (proto-typical wysiwyg system!), 
type barely has one dimension: we type a
letter and then the next has the same size and its placement doesn't
usually depend on the previous letter. Simple word processing software extends
this slightly to allow the use of letters which vary in height and,
more significantly, width. Still, however, the placement of a
character is largely independent of the previous character.
Finally, sophisticated word-processors may provide horizontal kerning
support so that, for example, an AV is set tighter than a TV.  

So far we've considered text as merely a linear string of characters.
But even if we are just setting plain text, this viewpoint is
inadequate. For example, how do we decide where to insert hyphens and
line breaks? All the commercial wordprocessors I'm familiar with just
go to the end of the line and then hypenate, if necessary, and insert
space between the words of that line in order to fill the line. The
resulting variation in word spacing between lines can look very
sloppy. Consequently, one often has to be satisfied with left
justified text. However, then (and even assuming good hyphenation
routines) the lines frequently still look bad since usually no word
spacing is then added; as a result, line lengths often vary wildly.

\TeX\ copes with this problem by taking a broader viewpoint. \TeX, in
addition to having very good hyphenation algorithms, looks at a
paragraph as a whole and inserts word spacing and hyphens so as to
make the paragraph look as good as possible. \TeX\ makes good choices
by default; moreover, it's algorithms can be customized by the user by
setting various parameters. 

The two dimensional nature of type really comes to the fore when we
come to typesetting mathematics. Now, in addition to horizontal
kerning, we often want to adjust the vertical position of a character
depending on the previous character. Or rather, we want the program to
do the vertical kerning automatically instead of having to place the
character by hand and 
merely getting what we see.  The optimal position may, in fact,
depend on more than the previous character's height--it's `center' or
some other parameter may be significant. By the way, \TeX\ can use
standard PostScript fonts; however, such fonts are too naively
parameterized to typeset equations, etc.\ attractively. There are a few
PostScript fonts (Lucida Bright, Math Times) that have had \TeX\ font
metrics added.

\hc Efficient Editing;

\TeX\ is a `markup' language: we do the data entry with our favorite
text editor and embed formatting commands that \TeX\ will use to
format the text. The widely used wordprocesser, {\it Word Perfect},
does the same thing; however, it hides its commands and uses a
proprietary format. \TeX, on the other hand, uses plain ascii file
format and `backslash' commands such as {\tt $\b$nopagenumbers}. One
can, of course, define a \TeX\ macro (or Emacs Lisp macro and Emacs
key binding)  to save keystrokes, if desired. 

As mentioned above, we want our system to be as easy to use as
possible. This is not the same thing as {\it easy to learn!} \TeX\ is
widely regarded to be hard to learn to use; however, there are several
good books, at several levels, to help in the learning process.
Furthermore, \TeX\ provides a good return on one's investment--once
learned, one can write scientific articles, etc. faster with \TeX\
than with {\it wysiwyg} programs such as {\it Microsoft Word}. One can
also more easily maintain and modify such documents: one may use Emacs
to do a sophisticated regular expression replacement throughout the text
or change various \TeX\ macros that determine the overall style of the
document. 

Standard \TeX\ archive sites such as {\tt pip.shsu.edu} have a large
collection of \TeX\ packages and macros to  cope with a wide range of
formatting problems or ease producing various
styles of documents.

\hc Permanent Portability;

The plain text format of \TeX\ document source files ensures that spacetime
separations need not interfere with our sharing of documents. The
public availability of the code for the \TeX\ programs themselves
makes \TeX\ available on more hardware platforms than any other
typesetting software. 

All the \TeX\footnote{${}^1$}{The word \TeX\ (ie $\tau\epsilon\chi$) is
sometimes used to refer specifically to the {\tt virtex} text
formatter. It is also used, as here, to refer to the entire set of
typesetting programs and utilities which Knuth designed to work
together: {\tt initex, virtex, inimf, virmf, gftopk, tangle, weave,
plain.tex,  cmbase.mf, etc.}} programs are well documented. In fact,
Knuth developed 
his {\tt web} composite programming language specifically for this
purpose. For example, {\tt mf.web} is the {\tt WEB} source for the
\mf\ program. By running {\tt weave} on this source, one gets the
document {\it \mf, The Program} (minus introduction, etc.); running
{\tt tangle} on it instead gives {\tt PASCAL} source code (with Linux,
and other unixlike systems, we instead use {\tt web2c} to generate C
code). A crucial feature of {\tt web} is that it enables skilled
programmers to write and document code in whatever combination of
`topdown' and/or `bottomup' style they prefer.  

To conclude with a rather impractical, but significant, thought
problem: suppose one has a only a document's source in microfiche
format.
What is essential to answer the question: if printed on 8.5x11
paper (assume the printer can precisely align the paper), what are the
coordinates of the top right corner of the 77th 
character on page 2? In theory at least, with \TeX\ one does not even
need the \TeX\ program if one has Knuth's {\it Computers and
Typesetting} texts and sufficient patience to calculate the answer. 

In contrast, with a typical word processor one:
\smallskip
\i 1); Could not conveniently put the source on microfiche but would
have to use hexidecimal, etc.\ to represent the special control
characters..

\i 2); To read the source, one needs the wordprocessor program (or
some conversion utility--all of which, to my knowledge, lose data).

\i 3); To try to answer the question, one must use the program. One
could use a {\tt print preview} feature to approximate the answer.

\i 4); To actually answer the question, print one the first two pages
and use calipers, etc. to measure the position.
\smallskip
While perhaps seeming a bit absurd, this example illustrates
features which have significant
bearing on one's day to day work, especially as documents become more
electronically based.  For a more farfetched example, can your
word-processor and font tools be used to specify the circuits to
`burn' onto microchips so they will be able to execute that same program?


\hb The \TeX\ files;

This section gives a brief listing of the types of files used by the
\TeX\ system.

\hh inimf; We use this to make the
\mf\ base files; to make the plain 
base, one can run (user input in bold):{\tt \obeywhitespace\smallskip
/book > {\bf inimf}
This is METAFONT, Version 2.71 (C version d) (INIMF)
**{\bf plain}
(/usr/TeX/lib/mf/macros/plain.mf
Preloading the plain base, version 2.7: preliminaries,
 basic constants and mathematical macros,
 macros for converting from device-independent units to pixels,
 macros and tables for various modes of operation,
 macros for drawing and filling,
 macros for proof labels and rules,
 macros for character and font administration,
and a few last-minute items.)  {\bf input modes;}
(/usr/TeX/lib/mf/macros/modes.mf) {\bf dump;}
Beginning to dump on file plain.base
 (base=plain 93.6.28)
1760 strings of total length 27399
8361 memory locations dumped; current usage is 2436\&5709
744 symbolic tokens
Transcript written on plain.log.
/book >{\bf mv plain.base /usr/TeX/lib/mf/bases/mf.base}}
\smallskip
The file {\tt /usr/TeX/lib/mf/mf.pool}, a file of strings used by \mf,
is also needed by {\tt inimf}. {\tt Inimf} is a special version of \mf\
which is used to make an initialization file consisting of
`predigested' \mf\ macros that can be quickly loaded. This base file
is then loaded by {\tt virmf}, virgin \mf, which, as you recall, is
linked to a name with the same base as the initialization file. For
example, if we'd done a {\tt inimf cmbase$\b$; input modes$\b$; dump;
mv cmbase.base /usr/TeX/lib/mf/bases/cmmf.base; \hfil\break ln -s
/usr/TeX/bin/virmf /usr/TeX/bin/cmmf} we could then produce a cmr10
font slightly faster by running {\tt cmmf}. 

\hh cmbx10.mf; The only other files needed for fontmakes are the
various source files. These are often broken up into various
components; for example, {\tt cmbx10.mf} just sets various parameters
that determine the appearance of the font and then calls {\tt
roman.mf} which in turn inputs the various character files (e.g., {\tt
romlig.mf}). 

\hh cmbx10.300gf; This is an actual font file in Generic Format.
Usually, these aren't used but rather are converted to packed format
by running {\tt gftopk cmbx10.300gf}.

\hh cmbx10.300pk; This is the actual font file which is used by {\tt
xdvi, dvips, dvilj2p,} etc. {\bf Note:} {\tt tex}, itself, does not
use the font file.

\hh cmbx10.tfm; When fontmaking, \mf\ also outputs a {\tt tfm}, \TeX\
Font Metric, file that contains the font parameters needed by \TeX. In
particular, it contains 1) overall font parameters like {\tt xheight}
and {\tt quad}, 2) ligature (ie, what converts f{l} into fl) and
kerning information, 3) charater width and height. Math fonts contain
extra information needed by \TeX; run {\tt tftopl cmsy10.tfm
cmsy10.pl; more cmsy10.pl} to see a sample.

\hh initex; Like \mf, \TeX\ also uses an initialization file. Unlike
\mf, however, \TeX\ does not separate statements with a semi-colon. It
does use a string file called {\tt tex.pool}. If we use the command
line, instead of a file, to make the base format we have to use a
$\b$, as with \mf, to protect special characters from being
interpreted by the shell. This we might enter: {\tt initex plain
$\b\b$input eplain $\b\b$input local $\b\b$dump} if we want our
default format to 
include Berry's {\tt eplain} macros (described in {\it \TeX\ for the
Impatient}). If run interactively, a sample run might look like:
{\tt \obeywhitespace
/book > initex
initex
This is TeX, Version 3.141 (C version d) (INITEX)
**{\bf mplain $\b$input eplain $\b$dump}
(/usr/TeX/lib/tex/macros/mplain.tex Preloading the plain format: codes,
registers, parameters, fonts, macros, math definitions, output routines,
hyphenation (/usr/TeX/lib/tex/macros/hyphen.tex))
(/usr/TeX/lib/tex/macros/eplain.tex)
Beginning to dump on file mplain.fmt
 (format=mplain 93.6.28)
2512 strings of total length 34832
15059 memory locations dumped; current usage is 118\&14924
1500 multiletter control sequences
$\b$font$\b$nullfont=nullfont
$\b$font$\b$tenrm=cmd10
$\b$font$\b$sevenrm=cmr7
$\b$font$\b$fiverm=cmr5
$\b$font$\b$teni=cmmi10
$\b$font$\b$seveni=cmmi7
$\b$font$\b$fivei=cmmi5
$\b$font$\b$tensy=cmsy10
$\b$font$\b$sevensy=cmsy7
$\b$font$\b$fivesy=cmsy5
$\b$font$\b$tenex=cmex10
$\b$font$\b$tenbf=cmbx10
$\b$font$\b$sevenbf=cmbx7
$\b$font$\b$fivebf=cmbx5
$\b$font$\b$tentt=cmttss10
$\b$font$\b$tensl=cmsl10
$\b$font$\b$tenit=cmti10
$\b$font$\b$manfnt=cmss10
$\b$font$\b$manfntsl=cmssi10
$\b$font$\b$tenln=line10
5761 words of font info for 19 preloaded fonts
14 hyphenation exceptions
Hyphenation trie of length 6075 has 181 ops out of 751
  181 for language 0
No pages of output.
Transcript written on mplain.log.
/book >{\bf mv mplain.fmt /usr/TeX/lib/tex/formats/tex.fmt}
}
\smallskip
In addition to the three \TeX\ files mentioned, {\tt initex} also
reads 19 {\tt tfm} files (note: my tenrm and tentt are non-standard).
The actual font files themselves are not used by {\tt tex}, ie {\tt
virtex}, itself.

\hh mplain.log; Both {\tt tex} and {\tt mf} generate log
files; the amount of detail (for debugging, etc.) contained in them
can vary depending on various parameter settings. 

\hh MakeTeXPK; Finally, I should mention the {\tt MakeTeXPK} script.
If, when using {\tt xdvi} or a printer driver, a font file is missing,
the driver will call this script to make the font. The script in the
Milieu package also updates the {\tt tfm} file. 

If the {\tt tfm} file doesn't exist in the first place, either 1) make
it with {\tt mf} or 2) {\tt cp cmsy10.tfm foo.tfm} to fake \TeX\ into
thinking you have a {\tt foo} font, preview (which will make the font
and correct the tfm file) and then run {\tt tex} on the source again.
Actually, you shouldn't have to do this, but some versions of web2c
have a bug that prevents \TeX\ from calling MakeTeXTFM as it should.
See the chapter on Hacking on patching {\tt openinout.c}.

\hb Basic Use;

Now that we've covered the main types of files used by \TeX, how do we
use it? I recommend Ramond Seroul and Silvio Levy's {\it A Beginner's
Book of \TeX} for an introduction. Here, I just give a small example,
one which is not very representative of \TeX: 
 
\hc Memos with \TeX;

Suppose you want to use \TeX\ to print memos satisfying the following
conditions: 
\ib One page
\ib Output to postscript printer
\ib Two line `from' and `to' addresses

First let's write a sample:

{\tt\verbatim
\def\footline{\hfil\ifnum\pageno=1 \else\folio\fi\hfil} %1st page
%a \nopagenumbers would have been easier..this is for 2+ page letters
\def\getfromaddress{}
\def\gettoaddress{}
|endverbatim
}

\hc Testing fonts with \TeX;

The standard \TeX\ distribution includes a file {\tt testfont.tex}
which one uses to test character spacing, etc. Since that file is
closely related to this text's topics, we will use it as an example of
writing \TeX\ macros for specialized tasks. It also can serve,
perhaps, to scare off the fainthearted.
\smallskip\listing{fontchart.tex}\smallskip
{\bf Note:} this file's table macro was used for the table on page 2. 

\hb The Andrew Toolkit, a WYSIWYG alternative;

Now, while \TeX\ is faster, produces better output, and is much more
configurable, there is certainly still a need for wysiwyg style word
processors. This is especially true if one needs to produce
`multimedia' documents.
 
The Andrew Toolkit (ATK) is a portable user-interface toolkit that runs under 
X11. It provides a dynamically-loadable object-oriented environment wherein 
objects can be embedded in one-another. It includes an editor (ez)
that one expects in an editor but it also can contain embedded 
raster images, spreadsheets, drawing editors, equations, simple
animations, clocks, calendars, etc. The system also includes an
extensive help system. All files are stored in ascii format and one 
can include {\tt troff} commands for special needs. Postscript
printing of the multimedia documents is supported via troff (or, in 
the case of Linux, GNU's groff).

The Andrew binaries (at sunsite.unc.edu: /pub/Linux/X11/andrew or in
the Milieu package) can
be unpacked at the root directory and used immediately. A few points
should be noted:

\item{1)}  Since bash interprets {\tt help} as a shell command, write
a little shell script called ahelp: {\tt /usr/andrew/bin/help \$* }

\item{2)} For a tour of features, run: {\tt ez
/usr/andrew/doc/AtkTour/Tour}.



\ha Simple Hacking;

By hacking I mean the modification of someone's source code to fix bugs or
to add some needed feature. Often one needs to do this inspite of not 
fully understanding the source code; or even the language it's programmed in!
This section gives two examples: 1) modifying the web source for \mf\ to
change the prompt character and 2) fixing web2c's routine that \TeX\ uses to
try to make a missing {\tt tfm} file.

\hb Modifying mf.web;

I've mentioned the needed changes earlier; suppose one didn't know how to
change the input prompt but just knew that the default ``*'' interfered with
interactive cut-and-paste use.

\item{1)} First, we need to try to find the relevant section of source code.
Several options are possible; one could, as I did, be reading 
{\it METAFONT: The Program\/} and notice the relevant code. Another method is
to use grep (or fgrep, if regular expression matches aren't needed) 
to search for key phrases. One could search for {\tt prompt} or {\tt input},
with, say, {\tt fgrep prompt mf.web|more}. A better `phrase' to search for,
however, is a quote followed by an asterick-- {\tt 
fgrep "$\backslash$"*" mf.web} -- which gives one:\smallskip
\listing{fgrep-mf.lst}\smallskip
Looking through this, the relevent source line is obvious so one loads 
a copy of mf.web into Emacs and searches for {\tt prompt\_input("*")}. 
After changing the prompt to a space, and also deleting the newline, one
can run diff which will list the change:
\smallskip\listing{mf.web.diff}\smallskip
(Of course, having the diff, one can use {\tt patch}, rather than an editor,
to change the source.)

\hb Fixing openinout.c;

If one runs \TeX\ and a tfm file is missing, \TeX\ normally stops with an 
error; in an analogous situation, when xdvi is missing a pk bitmap, it just
calls {\tt mf} to make it and then proceeds. Wouldn't it be nice if \TeX\
could do the same? It can! Searching the top of the web2c-5.851d source
directory, the NEWS file says:
\smallskip{\obeywhitespace\tt
   - If a .tex, .tfm, or .mf file can't be found, MakeTeX{TeX,TFM,MF} is
    invoked before giving up, as in dvips' MakeTeXPK.}\smallskip
Thus we are lead to use {\tt fgrep} to search source files for, 
say, {\tt MakeTeX}. The relevant file turns out to be {\tt lib/openinout.c}
where grep reports:
\smallskip{\obeywhitespace\tt
  /* Wrap another sh around the invocation of the MakeTeX program, so we
     can avoid `sh: MakeTeXTFM: not found' errors confusing the user.
  return make\_tex\_file ("MakeTeXTeX");
  return make\_tex\_file ("MakeTeXTFM");
  return make\_tex\_file ("MakeTeXMF");}\smallskip
Further snooping in the configuration file lib/c-auto.h.in (which is the 
first thing that the INSTALL info file mentions to edit) shows that this
feature is enabled by default 
(despite the misleading comment in c-auto.h.in!). 

So. We need to see 1) is \TeX, in fact, trying to call mf to 
make the tfm file and 2) if so, what's going wrong. An easy way to do this
is to run {\tt top} which shows the current process activity (you may 
need to slow down your computer to see the call). With {\tt top} running in
one xterm window, run \TeX\ on a file that needs a non-existant tfm file.
Then as tex forks the call to MakeTeXTFM, top will (among other things) report:
\smallskip{\tt \obeywhitespace
 PID  SIZE  RES SHRD STAT \%CPU \%MEM  TIME COMMAND
  161   89  300  316 R     5.8  1.9  0:30 top
   21 1582 1328  496 S     2.9  8.7  4:29 X :0
  204  285  340  404 S     1.5  2.2  0:00 sh -c sh -c MakeTeXTFM fakef.tfm>/dev/nu
}\smallskip
Now, {\tt sh -c \it string} means that the shell is to to execute {\it string}, unfortunately, 
since the above isn't quoted, {\tt MakeTeXTFM} doesn't get passed it's needed argument of 
{\tt fakef.tfm}. 

To fix openinout.c, we just need to add quotes to the call. Diff -{}-context=5 reports:
\smallskip\listing{openinout.c.diff}
\smallskip Now a {\tt make clean; make TeX} will make corrected tex binaries.

\hb Educational hacking;

\item{1)} Read documentation files that a program's author includes
with the source code. Read the source code and it's comments.

\item{2)} This sort of hacking is an alternative way of learning
programming. Rather than listening to orderly lectures, one is
apprenticed to experienced programmers. Hopefully, their programs can
speak for themselves.

\item{3)} For that matter, much of this text is concerned with this 
sort of training. I think it much more fun and useful but it does need
a rather different set of skills, e.g., browsing around systems
involving hundreds of files and looking for ways to `get into' the 
code. 

\ha Embedding characters in METAFONT;

Suppose you want to make some labeled drawings in \mf; how can you get
the characters easily? The GNUPLOT 2--3D scientific graphing program
points out an easy way to do this: just use some  already defined
font! The {\tt gnuplot} \mf\ output loads {\tt cmr10} characters for
each plot and uses them for various labels. 

It is more efficient to make a special format with these `pictures'
included. 
\medskip
\input ./gnuchars

\ha Geometric Graphics;
\medskip
\input ./geo

\ha Linus;

This is very tedious and ugly code; it does, however, point out that 
one can use brute force methods for line drawings. About the only
point of it, besides its original use for announcing Linux's release,
is to provide the reader opportunities for improvements.
\medskip

\input ./linusa

\ha Watching an N Queens solution;

\input ./queen 

\hb Other general programming stuff with \mf;

\ha A Real Font;

\hb New Pens;  

\hc Pens are primary;

\hc Triangular Pens;

\hb  A Meta Font;

\hc Using declarations to exploit our new pens;

\hc Organization and Cooperation;

\ha Further Reading;

\hb THE BOOKS;

\item{1)} New International Version. There are certainly other
excellent translations of the Bible also.\footnote{${}^1$}{ A few
verses are translated 
and commented upon in Knuth's {\it 3:16.} }

\hb Knuth's books;

\item{1)} The \mf{}book. Volume C of {\it Computers and Typesetting.}

\item{2)} Seminumerical Algorithms. Volume 2 of {\it The Art of
Computer Programming.}

\hb Other Texts;

\item{1)} The Unix Programming Environment {\it by Brian Kernighan and
Robert Pike}

\item{2)} Structure and Interpretation of Computer Programs {\it by Harold
Abelson and Gerald Jay Sussman with Julie Sussman}

\item{3)} Code Complete {\it by Steven McConnell}



\hb Online References;


\item{1)} /usr/TeX/lib/mf/macros

\item{2)} /usr/lib/emacs/19.19/lisp

\item{3)} /usr/src/linux

\item{4)} /usr/man/cat1, /usr/TeX/man, /usr/info

\ha Appendix 1;

\hb Motherboards;

\hb Video Cards;

Supported accelerator chips include: S3 (928, 805, 801) and ATI
(Mach32 and Mach8).

\hb Cases and Fans;

\hb Other Parts;

\ha Appendix 2;

\hb The Filesystem and ls;

The standard unix utility to list directories is {\tt ls}. As we list
its options, we will also discuss Linux filesystems in general. The
Milieu package uses the `minix' filesystem with 30 character filenames
(use mkfs -n30 to make such a filesystem). Linux supports several 
filesystems (minix,efs,efs2,xia,dos,proc,cdrom); via its Virtual File
System, the user is shielded from having to be concerned with the
details.

\mi       -a, --all
               List  all files in directories, including all files
               that start with `.' (such files are used for
initialization and customization and are mainly to be found in ones
home directory--for example:  ls -al /root).

\mi       -d, --directory
               List directories  like  other  files,  rather  than
               listing their contents. The need for this is
demonstrated by trying: {\tt ls /usr} and then trying {\tt 
ls /usr/i*} (you may also want to add a {\tt -l} option).


\mi       -i, --inode
               Print  the index number of each file to the left of
               the file name. {\bf Important: }the inodes are actually
               the files. File names are merely pointers to the
               inodes. When an inode has only one filename, one can
               think of the filename as the file. However, one can
               also link a file (ie, a inode) to several filenames:
               {\tt ln ls dir}. In addition to hard links,
                Linux also supports symbolic links:
               {\tt ln -s /bin/ls /usr/bin/dir} (sometimes these links
need to be forced: {\tt ln -sf /lib/libc.so.4 /lib/libc.so.4.4.4}
({\bf Do NOT} relink lib files unless you have floppies to reboot with in
case something vital breaks. Furthermore, it's safer not to remove the
old lib files for a while--something important may need the old libs) 

\mi       -l, --format=verbose
               In addition to the name of  each  file,  print  the
               file type, permissions (see {\tt chmod} below for
information on permissions, etc.), number of hard links, owner
               name, group name, size in bytes, and timestamp (the
               modification time unless other times are selected).
               For files with a time that is more  than  6  months
               old or more than 1 hour into the future, the timestamp
               contains the year instead of the time of  day. 

\mi       -r, --reverse
               Sort directory contents in reverse order. As with all
               the other one character options, you can conbine
               options, for example: {\tt ls -ltr}

\mi       -F, --classify
               Append a character to each file name indicating the
               file  type.  For regular files that are executable,
               append a `*'.  The file type indicators are `/' for
               directories, `@' for symbolic links, `|' for FIFOs,
               `=' for sockets, and nothing for regular files.

\mi       -R, --recursive
               List the contents of all directories recursively.

\mi       -S, --sort=size
               Sort directory contents by  file  size  instead  of
               alaphabetically,  with  the  largest  files  listed
               first.

\mi       -b, --escape
               Quote nongraphic characters  in  file  names  using
               alphabetic and octal backslash sequences like those
               used in C.

\mi       -c, --time=ctime
               Sort directory contents  according  to  the  files'
               status  change  time  instead  of  the modification
               time.  If the long listing format  is  being  used,
               print the status change time instead of the
               modification time. 

\mi       -k, --kilobytes
               If file sizes are being listed, print them in
kilobytes.   This  overrides  the  environment variable  POSIXLY\_CORRECT.


\mi       -m, --format=commas
               List  files  horizontally, with as many as will fit
               on each line, separated by commas.

\mi       -n, --numeric-uid-gid
               List the numeric UID and GID instead of the  names.

\mi       -p, {}     Append a character to each file name indicating the
               file type.

\mi       -q, --hide-control-chars
               Print question marks instead of nongraphic  characters in file names.


\mi       -s, --size
               Print  the  size  of  each file in 1K blocks to the
               left of the file name.  If the environment variable
               POSIXLY\_CORRECT  is  set,  512-byte blocks are used
               instead.

\mi       -t, --sort=time
               Sort directory contents  by  timestamp  instead  of
               alphabetically, with the newest files listed first.

\mi  -u, --time=atime 
               Sort directory contents  according  to  the  files'
               last  access time instead of the modification time.
               If the long listing format is being used, print the
               last  access time instead of the modification time.

\mi       -x, --format=across 
               List the files in columns, sorted horizontally.

\mi       -A, --almost-all
               List all files in directories except  for  `.'  and
               `..'.

\mi    -B, --ignore-backups
               Do  not  list  files that end with `~', unless they
               are given on the command line.

\mi       -C, --format=vertical
               List files in columns, sorted vertically.


\mi       -L, --dereference
               List the files linked to by symbolic links  instead
               of listing the contents of the links.

\mi       -N, --literal
               Do not quote file names.

\mi       -Q, --quote-name
               Enclose  file names in double quotes and quote nongraphic characters as in C.


\mi       -U, --sort=none
               Do not sort directory contents.

\mi       -X, --sort=extension
               Sort  directory  contents  alphabetically  by  file
               extension  (characters  after  the last `.'); files
               with no extension are sorted first.

\mi      -1, --format=single-column
               List one file per line.

\mi       -w, --width cols
               Assume  the  screen  is  cols  columns  wide.   The
               default is taken from the terminal driver if possible; otherwise the environment variable COLUMNS  is
               used if it is set; otherwise the default is 80.

\mi       -T, --tabsize cols
               Assume that each tabstop is cols columns wide.  The
               default is 8.

\mi       -I, --ignore pattern
               Do not list files whose names match the shell  pattern
pattern  unless they are given on the command  line.  As in the shell,
an initial `.' in  a  filename does not match a wildcard at the start
of pattern.  

\hb Listing and creating files with {\tt cat};

The command {\tt cat} copies its arguments to standard output. One
useful option is:

\mi       -b, --number-nonblank 
              Number all nonblank output lines, starting with  1.

If the file is more than a few lines, you will want to pipe the 
output to a pager: {\tt cat /root/.emacs $\|$ more}. You can also create
files with {\tt cat}: {\tt cat >/bin/ll}\hfil\break
{\tt ls -la \$*}\hfil\break
\^d \hfil\break
This file, containing instructions to be passed to the shell, can be 
executed with {\tt sh /bin/ll /bin/l* /bin/c*}. The {\tt \$*} passes
the arguments given to {\tt ll} on to {\tt ls}. We don't have to use
the file as a script given to the shell; we can make it executable
itself with, say, {\tt chmod 755 /bin/ll} (see {\tt chmod} below).

\hb File Permissions and chmod;

    Chmod will accept symbolic mode specifications. I prefer
    numeric mode specifications myself.
    A numeric mode is from one to  four  octal  digits  (0-7),
       derived  by  adding  up  the bits with values 4, 2, and 1.
       Any omitted digits are assumed to be leading  zeros.   The
       first  digit  selects the set user ID (4) (for an example of
       this, do {\tt ls -l /usr/X386/bin}; the suid bit is used by 
       programs which start other programs--it passes its permissions
on to its `children') and set group ID
       (2) and save text image (1) attributes.  The second  digit
       selects  permissions  for the user who owns the file: read
       (4), write (2), and execute (1); the third selects permis-
       sions  for  other users in the file's group, with the same
       values; and the fourth for other users not in  the  file's
       group, with the same values.

\item{\bf -v}     Verbosely describe changed permissions.

\item{\bf -R}     Recursively  change  permissions of directories and
              their contents.


\hb Kermit;

Kermit is a widely available communications package. The file
/root/.kermrc is the initialization file I use (both on my local
linux and the remote unix site that I log into).
{\tt \obeylines
set escape 29  ;ie press \^] to escape to local kermit
set file type binary ; 
set send packet-length 1000
set receive packet-length 1000
set flow none
set line /dev/modem
set baud 9600
set window 5
set block 3
\par}

Kermit has extensive online help. However, let's walk thru a simple
session. First, run {\tt kermit}, press `c' at the kermit prompt.
Then, if using a modem, enter {\tt atdt 123-4567}, for example.
Once connected, login and do what you need (for example:
{\tt \obeylines
ftp nic.funet.fi
anonymous
tdunbar@vtaix.cc.vt.edu
cd pub/OS/Linux/testing/Linus
get ALPHA-patch.diff.z
get linux-1.01.tar.z
quit \par}
To transfer these files, one might do: {\tt kermit -i -s *.z}, when
prompted by the server, enter {\tt \^]c receive} to get the files.

\hb Gzip compression;

The {\tt gzip} utility is linked (in the Milieu package) to {\tt
compress, uncompress, {\rm and} zcat} so one can just do: {\tt
uncompress ALPHA-diff;mv ALPHA-diff /usr/src/linux}. 

\hb Tar archives;

To remove the old kernel source, one can do: {\tt rm -r
/usr/src/linux} {\bf Warning:} this can be a very dangerous
command--know what you are doing. Depending on how permissions are set
and your user and group id, you may also need the {\tt -f} option to
force the removal. 

We can unpack the above kernel source with: {\tt mv linux-1.01.tar.z
/usr/src; tar zxvf linux-1.01.tar.z} (the z tells tar to uncompress,
x=extract, v=verbose, f=file to extract from; there is also a
p=permissions option to preserve the original permissions--this may
be needed if you set default permissions with {\tt umask}, I don't).

\hb Patching source code;

The above patches can be applied with {\tt patch -p1 $<$ ALPHA-diff}
(the -p1 tells patch to strip off one subdirectory layer since 
we're already in {\tt /usr/src/linux} [which we could have renamed via
{\tt mv linux linux-1.01}]. If we were in {\tt /usr/src} instead, we'd
have used {\tt -p0}).

\hb Finding files;

The {\tt find} utility enables one to search through a directory
hierarchy for files matching certain conditions and then to 
perform actions on the matching files. For example,

{\tt find . -name "*\#" -exec ls -l $\{\}\,\,\b$; }

will list any files unsuccessfully patched by the above patch and
the old files which were modified can be deleted with:

{\tt find . -name ``*$\tilde{}$'' -exec rm -v $\{\}\,\,\b$; }



\hb Making a new kernel;

To make a new boot image,
{\tt \obeylines
make clean;
emacs Makefile;  \# change video default, etc., as needed
make config;
make dep; make clean; make Image;
cd /etc/lilo; ./install 
\par}

\hb Booting via lilo;

Lilo comes with excellent and extensive documentation which should be 
consulted. The above kernel make assumed 1) {\tt /usr/src/linux/Image}
was {\bf not} the default boot kernel--if it were, and something went
wrong, we'd have to reboot via floppy. 2) lilo is installed and
there's an entry for {\tt /usr/src/linux/Image}.  My {\tt
/etc/lilo/install} is: {\tt ./lilo -v -v -C config {\rm where config
is:} \obeylines
install = /etc/lilo/boot.b
compact
delay = 9   \# optional, for systems that boot very quickly
boot = /dev/hda
image = /etc/vmlinux
  label = linux
image = /usr/src/linux/Image
  label = tlinux
other = /dev/hda1
  table = /dev/hda
  label = dos
\par}

Then, when one reboots, as soon as the word LILO appears, press ALT or
CTRL and then enter tlinux to boot from your new kernel.

\hb stty;

{\tt stty 9600 cs8 ixon </dev/ttys2} will setup com2 for a serial 
connection to a LaserWriter.

\hb Bourne Again SHell;

  The default key-bindings for bash may be changed with an $\tilde{}$/.inputrc
       file.   Other programs that use this library may add their
       own commands and bindings.

       For example, placing

          \centerline{\tt M-Control-u: universal-argument}
       or

\centerline{\tt   C-Meta-u: universal-argument}
       into the .inputrc would make M-C-u execute  the  command
       universal-argument.

       The  following  symbolic  character  names are recognized:
       RUBOUT, DEL, ESC, NEWLINE, SPACE, RETURN, LFD, TAB.
\smallskip

The bindings are meant to be compatible with the Emacs default
keybindings where appropriate.

\hc   Commands for Moving;

\def\bh#1){\medskip \hangafter1\hang\noindent{\bf #1)\hfil\break}}

\bh        beginning-of-line (C-a)
              Move to the start of the current line.
  
\bh       end-of-line (C-e)
              Move to the end of the line.

\bh        forward-char (C-f)
              Move forward a character.

\bh        backward-char (C-b)
              Move back a character.

\bh        forward-word (M-f)
              Move forward to the end of the next word.


\bh       backward-word (M-b)
              Move  back  to  the start of this, or the previous,
              word.

\bh        clear-screen (C-l)
              Clear the screen leaving the current  line  at  the
              top of the screen.

\hc   Commands for Manipulating the History;
       
\bh       accept-line (Newline, Return)
              Accept  the line regardless of where the cursor is.
              If this line is non-empty, add it  to  the  history
              list  according to the state of the history\_control
              variable.  If this line was a  history  line,  then
              restore the history line to its original state.

\bh        previous-history (C-p)
              Fetch  the  previous command from the history list,
              moving back in the list.

\bh        next-history (C-n)
              Fetch the next command from the history list,  moving 
              forward in the list. 

\bh        beginning-of-history (M-$<$)
              Move  to  the  first line in the history, the first
              line entered.

\bh        end-of-history (M-$>$)
              Move to the end of the  input  history,  i.e.,  the
              line you are entering.

\bh        reverse-search-history (C-r)
              Search  backward  starting  at the current line and
              moving `up' through the history as necessary.  This
              is an incremental search.

\bh        forward-search-history (C-s)
              Search  forward  starting  at  the current line and
              moving `down' through the history as necessary.

\bh        shell-expand-line (M-C-e)
              Expand the line the way  the  shell  does  when  it
              reads  it.   This performs alias and history expansion.

\bh        insert-last-argument (M-., M-\_)
              Insert the last argument to  the  previous  command
              (the last word on the previous line).

\bh        operate-and-get-next (C-O)
              Accept the current line for execution and fetch the
              next line relative to the  current  line  from  the
              history file for editing.

\hc   Commands for Changing Text;

\bh        delete-char (C-d)
              Delete the character under the cursor.  If the cursor 
              is at the beginning of the line, and there  are
              no  characters  in the line, and the last character
              typed was not C-d, then return EOF.

\bh        backward-delete-char (Rubout)
              Delete the character behind the cursor.  A  numeric
              arg says to kill the characters instead of deleting
              them.

\bh        quoted-insert (C-q, C-v)
              Add the next character that you type  to  the  line
              verbatim.   This  is  how to insert characters like
              C-q, for example.

\bh        tab-insert (M-TAB)
              Insert a tab character.

\bh        self-insert (a, b, A, 1, !, ...)
              Insert the character typed.

\bh        transpose-chars (C-t)
              Drag the character before point  forward  over  the
              character  at  point.  Point moves forward as well.
              If point is at the end of the line, then  transpose
              the  two  characters  before point.  Negative arguments 
              don't work.

\bh        transpose-words (M-t)
            Drag the word behind the cursor past  the  word  in
              front  of  the  cursor  moving the cursor over that
              word as well.

\bh        upcase-word (M-u)
              Uppercase the current (or following) word.  With  a
              negative argument, do the previous word, but do not
              move point.

\bh        downcase-word (M-l)
              Lowercase the current (or following) word.  With  a
              negative argument, do the previous word, but do not
              move point.

\bh        capitalize-word (M-c)
              Capitalize the current (or following) word.  With a
              negative argument, do the previous word, but do not
              move point.

\hc   Killing and Yanking;

\bh        kill-line (C-k)
              Kill the text from the current cursor  position  to
              the end of the line.  This saves the killed text on
              the kill-ring.  (see below)

\bh        backward-kill-linen ()
              Kill backward to the beginning of the  line.   This
              is normally unbound, in favor of unix-line-discard,
              which emulates the behavior of  the  standard  Unix
              terminal driver.

\bh        kill-word (M-d)
              Kill  from  the  cursor  to  the end of the current
              word, or if between words, to the end of  the  next
              word.

\bh        backward-kill-word (M-Rubout)
              Kill the word behind the cursor.

\bh        unix-line-discard (C-u)
              Do what C-u used to do in Unix line input.  We save
              the killed text on the kill-ring, though.

\bh        unix-word-rubout (C-w)
              Do what C-w used to do in  Unix  line  input.   The
              killed  text  is  saved  on the kill-ring.  This is
              different than backward-kill-word because the  word
              boundaries differ.

\bh        yank (C-y)
              Yank  the  top  of the kill ring into the buffer at
              point.

\bh        yank-pop (M-y)
              Rotate the kill-ring, and yank the new  top.   Only
              works following `yank' or `yank-pop'.

\hc   Arguments;

\bh        digit-argument (M-0, M-1, ..., M-{}-)
              Add  this  digit to the argument already accumulating, 
            or start a new argument.  M-{}- starts  a  negative argument.

\bh        universal-argument ()
              Do what C-u does in emacs.  By default, this is not
              bound to a key.

\hc   Completing;

\bh        complete (TAB)
              Attempt to perform completion on  the  text  before
              point.   Bash attempts completion treating the text
              as a variable (if the text begins with \$), username
              (if  the text begins with $\tilde{}$), hostname (if the text
              begins with @), or command (including  aliases  and
              functions)  in  turn.   If none of these produces a
              match, filename completion is attempted.

\bh        possible-completions (M-?)
              List the possible completions of  the  text  before
              point.

\bh        complete-filename (M-/)
              Attempt  filename  completion  on  the  text before
              point.

\bh        possible-filename-completions (C-x /)
            List the possible completions of  the  text  before
              point, treating it as a filename.

\bh        complete-username (M-$\tilde{}$)
              Attempt completion on the text before point, treating 
              it as a username.

\bh        possible-username-completions (C-x $\tilde{}$)
              List the possible completions of  the  text  before
              point, treating it as a username.

\bh        complete-variable (M-\$)
              Attempt completion on the text before point, treating 
             it as a shell variable.

\bh        possible-variable-completions (C-x \$)
              List the possible completions of  the  text  before
              point, treating it as a shell variable.

\bh        complete-hostname (M-@)
              Attempt completion on the text before point, treating 
             it as a hostname.

\bh        possible-hostname-completions (C-x @)
              List the possible completions of  the  text  before
              point, treating it as a hostname.

\hc   Miscellaneous;

\bh        abort (C-g)
              Abort the current editing command and ring the terminal's bell.

\bh        do-uppercase-version (M-a, M-b, ...)
              Run the command that is  bound  to  the  uppercased
              key.

\bh        prefix-meta (ESC)
              Metafy  the next character typed.  This is for people 
               without a meta key.  ESC  f  is  equivalent  to
               Meta-f.

\bh        undo (C-\_)
              Incremental  undo,  separately  remembered for each
              line.

\bh        revert-line (M-r)
              Undo all changes made to this line.  This  is  like
              typing  the `undo' command enough times to get back
              to the beginning.

\bh        display-shell-version (C-x C-v)
              Display  version  information  about  the   current
              instance of bash.

\bh        emacs-editing-mode (C-e)
              When  in  vi  editing mode, this causes a switch to
              emacs editing mode.

\bh        vi-editing-mode (M-C-j or M-C-m)
              When in emacs editing mode, this causes a switch to
              vi editing mode.

 

\ha Getting the \mf\ and \TeX\ files;


Suppose you want to recompile \mf? 
\I FTP to ftp.cs.umb.edu`
Get the latest {\tt web.tar.Z} (Knuth's
web source for \TeX, \mf, and friends) and {\tt web2c.tar.Z} (utility to
generate C code from the web (Pascal) source). These are available at
various sites; the above is Karl Berry's (the current web2c
maintainer) home site. As I write this, the current version for web2c
is 5.851d.
Unpack these files in some convenient
directory ({\tt tar zxvf web.tar.Z; tar zxvf web2c.tar.Z}) and {\tt
cd} into the top directory (e.g., web2c-5.851d).

\I Edit Makefile.in`
Changes you may wish to make: 1) change the prefix from {\tt
/usr/local} to {\tt /usr/TeX}, 2) change {\tt CFLAGS} from {\tt -g} to
{\tt -O2} (no need to debug, optimize) and add {\tt -s} to {\tt LDFLAGS}
(use shared libraries), and 3) add // to the end of path components if
you want subdirectories to be searched (the
implementation will work fastest if the top directory, say {\tt
/usr/TeX/lib/mf/macros//}, just contains subdirectories). 

You may 
want to change the {\tt EDITOR} default in {\tt lib/c-auto.h} (I
set it to {\tt TeXeditor} which is a symlink to my editor. 

{\bf Note:} As mentioned in the text, I've modified section 679 of the
source and also the openinout.c file; you may also want to.

\I Now run make`
When (if?) the compiler exits due to the error from the {\tt malloc}
def in lex.yy.c, just run {{\tt jove +37 lex.yy.c}}, for example, and
delete the unneeded {\tt malloc} def. Then you can:
\I make; make install-programs;`
Other than the programs themselves, various \TeX\ and \mf\ files are
needed.

\hb \TeX\ archives;
\I ftp pip.shsu.edu`
Or other convenient site to get the needed files. For example, at
shsu,\hfil\break {\tt cd 
tex-archive/fonts/mf; get cm.tar.Z} will pack up the {\tt cm}
subdirectory which has the needed \mf\ font source code. You may also
want to get the {\tt tfm} (TeX font Metric) files while you are there.

Only a few \TeX\ files are essential: {\tt plain.tex, hyphen.tex}.
There are various macro packages you may also want (for plain \TeX, I
recommend {\tt stables.tex, newsletr.tex}) such as La\TeX.

Certainly, it is simplest to get a prepackaged collection of all the
needed \TeX\ and \mf\ files. The SLS archive (disks t1-t3) contains an
extensive package for Linux.

\ha Initialization files;
\hb /etc/rc;
\listing{/book/rc}

\hb /etc/rc.inet;
To set networking, uncomment the call to {\tt rc.inet} after you've:
\smallskip
\item{1} Created a file /etc/resolv.conf containing a line with:
\centerline{\tt nameserver <your.nameserver.ip.here>}
\smallskip
\item{2} Edited rc.inet for your local site editing all the
$<your.ip.goes.here>$ entries for your site (search for $<$ in
rc.inet).
\smallskip
A minimal, unedited rc.inet might look like:
\smallskip\listing{rc.inet}

\hb  /etc/profile;
\listing{/etc/profile}

\ha Appendix 3;

\hb Misc. Emacs Notes:;

\item{$\bullet$} When loading files, etc., Emacs will prompt with a
default directory. If you want a different directory, just start with
/ (i.e., give the absolute pathname). For example, if the prompt is
{\tt /book/} you can type {\tt /etc/rc} which will be loaded (even
though the minibuffer has {\tt /book//etc/rc}).

For reference, here are default Emacs key-bindings (this is the
refcard.tex by Stephen Gildea, copyright 1993, Free Software
Foundation) that comes with GNU Emacs 19:

\vfill\eject{
% Reference Card for GNU Emacs version 19 on Unix systems
% Time-stamp: <93/05/21 12:52:26 gildea>
%**start of header
\newcount\columnsperpage

% This file can be printed with 1, 2, or 3 columns per page (see below).
% Specify how many you want here.  Nothing else needs to be changed.

\columnsperpage=2

% Copyright (c) 1987, 1993 Free Software Foundation, Inc.

% This file is part of GNU Emacs.

% GNU Emacs is free software; you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation; either version 1, or (at your option)
% any later version.

% GNU Emacs is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
% GNU General Public License for more details.

% You should have received a copy of the GNU General Public License
% along with GNU Emacs; see the file COPYING.  If not, write to
% the Free Software Foundation, 675 Mass Ave, Cambridge MA 02139, USA.

% This file is intended to be processed by plain TeX (TeX82).
%
% The final reference card has six columns, three on each side.
% This file can be used to produce it in any of three ways:
% 1 column per page
%    produces six separate pages, each of which needs to be reduced to 80%.
%    This gives the best resolution.
% 2 columns per page
%    produces three already-reduced pages.
%    You will still need to cut and paste.
% 3 columns per page
%    produces two pages which must be printed sideways to make a
%    ready-to-use 8.5 x 11 inch reference card.
%    For this you need a dvi device driver that can print sideways.
% Which mode to use is controlled by setting \columnsperpage above.
%
% Author:
%  Stephen Gildea
%  Internet: gildea@mit.edu
%
% Thanks to Paul Rubin, Bob Chassell, Len Tower, and Richard Mlynarik
% for their many good ideas.

% If there were room, it would be nice to see a section on Dired.

\def\versionnumber{2.0}
\def\year{1993}
\def\version{May \year\ v\versionnumber}

\def\shortcopyrightnotice{\vskip 1ex plus 2 fill
  \centerline{\small \copyright\ \year\ Free Software Foundation, Inc.
  Permissions on back.  v\versionnumber}}

\def\copyrightnotice{
\vskip 1ex plus 2 fill\begingroup\small
\centerline{Copyright \copyright\ \year\ Free Software Foundation, Inc.}
\centerline{designed by Stephen Gildea, \version}
\centerline{for GNU Emacs version 19 on Unix systems}

Permission is granted to make and distribute copies of
this card provided the copyright notice and this permission notice
are preserved on all copies.

For copies of the GNU Emacs manual, write to the Free Software
Foundation, Inc., 675 Massachusetts Ave, Cambridge MA 02139.

\endgroup}

% make \bye not \outer so that the \def\bye in the \else clause below
% can be scanned without complaint.
\def\bye{\par\vfill\supereject\end}

\newdimen\intercolumnskip       %horizontal space between columns
\newbox\columna                 %boxes to hold columns already built
\newbox\columnb

\def\ncolumns{\the\columnsperpage}

\message{[\ncolumns\space 
  column\if 1\ncolumns\else s\fi\space per page]}

\def\scaledmag#1{ scaled \magstep #1}

% This multi-way format was designed by Stephen Gildea October 1986.
% Note that the 1-column format is fontfamily-independent.
\if 1\ncolumns                  %one-column format uses normal size
  \hsize 4in
  \vsize 10in
  \voffset -.4in
  \font\titlefont=\fontname\tenbf \scaledmag3
  \font\headingfont=\fontname\tenbf \scaledmag2
  \font\smallfont=\fontname\sevenrm
  \font\smallsy=\fontname\sevensy

  \footline{\hss\folio}
  \def\makefootline{\baselineskip10pt\hsize6.5in\line{\the\footline}}
\else                           %2 or 3 columns uses prereduced size
  \hsize 3.2in
  \vsize 7.95in
  \hoffset -.5in
  \voffset -.5in
  \font\titlefont=cmbx10 \scaledmag2
  \font\headingfont=cmbx10 \scaledmag1
  \font\smallfont=cmr5 at 6pt
  \font\smallsy=cmsy5 at 6pt
  \font\eightrm=cmr7 at 8pt
  \font\eightbf=cmbx7 at 8pt
  \font\eightit=cmti10 at 8pt
  \font\eighttt=cmtt10 at 8pt
  \font\eightmi=cmmi7 at 8pt
  \font\eightsy=cmsy7 at 8pt
  \textfont0=\eightrm
  \textfont1=\eightmi
  \textfont2=\eightsy
  \def\rm{\eightrm}
  \def\bf{\eightbf}
  \def\it{\eightit}
  \def\tt{\eighttt}
  \normalbaselineskip=.8\normalbaselineskip
  \normallineskip=.8\normallineskip
  \normallineskiplimit=.8\normallineskiplimit
  \normalbaselines\rm           %make definitions take effect

  \if 2\ncolumns
    \let\maxcolumn=b
    \footline{\hss\rm\folio\hss}
    \def\makefootline{\vskip 2in \hsize=6.86in\line{\the\footline}}
  \else \if 3\ncolumns
    \let\maxcolumn=c
    \nopagenumbers
  \else
    \errhelp{You must set \columnsperpage equal to 1, 2, or 3.}
    \errmessage{Illegal number of columns per page}
  \fi\fi

  \intercolumnskip=.46in
  \def\abc{a}
  \output={%                    %see The TeXbook page 257
      % This next line is useful when designing the layout.
      %\immediate\write16{Column \folio\abc\space starts with \firstmark}
      \if \maxcolumn\abc \multicolumnformat \global\def\abc{a}
      \else\if a\abc
        \global\setbox\columna\columnbox \global\def\abc{b}
        %% in case we never use \columnb (two-column mode)
        \global\setbox\columnb\hbox to -\intercolumnskip{}
      \else
        \global\setbox\columnb\columnbox \global\def\abc{c}\fi\fi}
  \def\multicolumnformat{\shipout\vbox{\makeheadline
      \hbox{\box\columna\hskip\intercolumnskip
        \box\columnb\hskip\intercolumnskip\columnbox}
      \makefootline}\advancepageno}
  \def\columnbox{\leftline{\pagebody}}

  \def\bye{\par\vfill\supereject
    \if a\abc \else\null\vfill\eject\fi
    \if a\abc \else\null\vfill\eject\fi
    \end}  
\fi

% we won't be using math mode much, so redefine some of the characters
% we might want to talk about
\catcode`\^=12
\catcode`\_=12

\chardef\\=`\\
\chardef\{=`\{
\chardef\}=`\}

\hyphenation{mini-buf-fer}

\parindent 0pt
\parskip 1ex plus .5ex minus .5ex

\def\small{\smallfont\textfont2=\smallsy\baselineskip=.8\baselineskip}

% newcolumn - force a new column.  Use sparingly, probably only for
% the first column of a page, which should have a title anyway.
\outer\def\newcolumn{\vfill\eject}

% title - page title.  Argument is title text.
\outer\def\title#1{{\titlefont\centerline{#1}}\vskip 1ex plus .5ex}

% section - new major section.  Argument is section name.
\outer\def\section#1{\par\filbreak
  \vskip 3ex plus 2ex minus 2ex {\headingfont #1}\mark{#1}%
  \vskip 2ex plus 1ex minus 1.5ex}

\newdimen\keyindent

% beginindentedkeys...endindentedkeys - key definitions will be
% indented, but running text, typically used as headings to group
% definitions, will not.
\def\beginindentedkeys{\keyindent=1em}
\def\endindentedkeys{\keyindent=0em}
\endindentedkeys

% paralign - begin paragraph containing an alignment.
% If an \halign is entered while in vertical mode, a parskip is never
% inserted.  Using \paralign instead of \halign solves this problem.
\def\paralign{\vskip\parskip\halign}

% \<...> - surrounds a variable name in a code example
\def\<#1>{{\it #1\/}}

% kbd - argument is characters typed literally.  Like the Texinfo command.
\def\kbd#1{{\tt#1}\null}        %\null so not an abbrev even if period follows

% beginexample...endexample - surrounds literal text, such a code example.
% typeset in a typewriter font with line breaks preserved
\def\beginexample{\par\leavevmode\begingroup
  \obeylines\obeyspaces\parskip0pt\tt}
{\obeyspaces\global\let =\ }
\def\endexample{\endgroup}

% key - definition of a key.
% \key{description of key}{key-name}
% prints the description left-justified, and the key-name in a \kbd
% form near the right margin.
\def\key#1#2{\leavevmode\hbox to \hsize{\vtop
  {\hsize=.75\hsize\rightskip=1em
  \hskip\keyindent\relax#1}\kbd{#2}\hfil}}

\newbox\metaxbox
\setbox\metaxbox\hbox{\kbd{M-x }}
\newdimen\metaxwidth
\metaxwidth=\wd\metaxbox

% metax - definition of a M-x command.
% \metax{description of command}{M-x command-name}
% Tries to justify the beginning of the command name at the same place
% as \key starts the key name.  (The "M-x " sticks out to the left.)
\def\metax#1#2{\leavevmode\hbox to \hsize{\hbox to .75\hsize
  {\hskip\keyindent\relax#1\hfil}%
  \hskip -\metaxwidth minus 1fil
  \kbd{#2}\hfil}}

% threecol - like "key" but with two key names.
% for example, one for doing the action backward, and one for forward.
\def\threecol#1#2#3{\hskip\keyindent\relax#1\hfil&\kbd{#2}\hfil\quad
  &\kbd{#3}\hfil\quad\cr}

%**end of header


\title{GNU Emacs Reference Card}

\centerline{(for version 19)}

\section{Starting Emacs}

To enter GNU Emacs 19, just type its name: \kbd{emacs}

To read in a file to edit, see Files, below.

\section{Leaving Emacs}

\key{suspend Emacs (or iconify it under X)}{C-z}
\key{exit Emacs permanently}{C-x C-c}

\section{Files}

\key{{\bf read} a file into Emacs}{C-x C-f}
\key{{\bf save} a file back to disk}{C-x C-s}
\key{save {\bf all} files}{C-x s}
\key{{\bf insert} contents of another file into this buffer}{C-x i}
\key{replace this file with the file you really want}{C-x C-v}
\key{write buffer to a specified file}{C-x C-w}

\section{Getting Help}

The Help system is simple.  Type \kbd{C-h} and follow the directions.
If you are a first-time user, type \kbd{C-h t} for a {\bf tutorial}.

\key{remove Help window}{C-x 1}
\key{scroll Help window}{ESC C-v}

\key{apropos: show cmds matching string}{C-h a}
\key{show the function a key runs}{C-h c}
\key{describe a function}{C-h f}
\key{get mode-specific information}{C-h m}

\section{Error Recovery}

\key{{\bf abort} partially typed or executing command}{C-g}
\metax{{\bf recover} a file lost by a system crash}{M-x recover-file}
\key{{\bf undo} an unwanted change}{C-x u {\rm or} C-_}
\metax{restore a buffer to its original contents}{M-x revert-buffer}
\key{redraw garbaged screen}{C-l}

\section{Incremental Search}

\key{search forward}{C-s}
\key{search backward}{C-r}
\key{regular expression search}{C-M-s}
\key{reverse regular expression search}{C-M-r}

\key{select previous search string}{M-p}
\key{select next later search string}{M-n}
\key{exit incremental search}{RET}
\key{undo effect of last character}{DEL}
\key{abort current search}{C-g}

Use \kbd{C-s} or \kbd{C-r} again to repeat the search in either direction.
If Emacs is still searching, \kbd{C-g} cancels only the part not done.

\shortcopyrightnotice

\section{Motion}

\paralign to \hsize{#\tabskip=10pt plus 1 fil&#\tabskip=0pt&#\cr
\threecol{{\bf entity to move over}}{{\bf backward}}{{\bf forward}}
\threecol{character}{C-b}{C-f}
\threecol{word}{M-b}{M-f}
\threecol{line}{C-p}{C-n}
\threecol{go to line beginning (or end)}{C-a}{C-e}
\threecol{sentence}{M-a}{M-e}
\threecol{paragraph}{M-\{}{M-\}}
\threecol{page}{C-x [}{C-x ]}
\threecol{sexp}{C-M-b}{C-M-f}
\threecol{function}{C-M-a}{C-M-e}
\threecol{go to buffer beginning (or end)}{M-<}{M->}
}

\key{scroll to next screen}{C-v}
\key{scroll to previous screen}{M-v}
\key{scroll left}{C-x <}
\key{scroll right}{C-x >}
\key{scroll current line to center of screen}{C-u C-l}

\section{Killing and Deleting}

\paralign to \hsize{#\tabskip=10pt plus 1 fil&#\tabskip=0pt&#\cr
\threecol{{\bf entity to kill}}{{\bf backward}}{{\bf forward}}
\threecol{character (delete, not kill)}{DEL}{C-d}
\threecol{word}{M-DEL}{M-d}
\threecol{line (to end of)}{M-0 C-k}{C-k}
\threecol{sentence}{C-x DEL}{M-k}
\threecol{sexp}{M-- C-M-k}{C-M-k}
}

\key{kill {\bf region}}{C-w}
\key{copy region to kill ring}{M-w}
\key{kill through next occurrence of {\it char}}{M-z {\it char}}

\key{yank back last thing killed}{C-y}
\key{replace last yank with previous kill}{M-y}

\section{Marking}

\key{set mark here}{C-@ {\rm or} C-SPC}
\key{exchange point and mark}{C-x C-x}

\key{set mark {\it arg\/} {\bf words} away}{M-@}
\key{mark {\bf paragraph}}{M-h}
\key{mark {\bf page}}{C-x C-p}
\key{mark {\bf sexp}}{C-M-@}
\key{mark {\bf function}}{C-M-h}
\key{mark entire {\bf buffer}}{C-x h}

\section{Query Replace}

\key{interactively replace a text string}{M-\%}
\metax{using regular expressions}{M-x query-replace-regexp}

Valid responses in query-replace mode are

\key{{\bf replace} this one, go on to next}{SPC}
\key{replace this one, don't move}{,}
\key{{\bf skip} to next without replacing}{DEL}
\key{replace all remaining matches}{!}
\key{{\bf back up} to the previous match}{^}
\key{{\bf exit} query-replace}{ESC}
\key{enter recursive edit (\kbd{C-M-c} to exit)}{C-r}

\section{Multiple Windows}

\key{delete all other windows}{C-x 1}
\key{delete this window}{C-x 0}
\key{split window in two vertically}{C-x 2}
\key{split window in two horizontally}{C-x 3}

\key{scroll other window}{C-M-v}
\key{switch cursor to another window}{C-x o}

\metax{shrink window shorter}{M-x shrink-window}
\key{grow window taller}{C-x ^}
\key{shrink window narrower}{C-x \{}
\key{grow window wider}{C-x \}}

\key{select buffer in other window}{C-x 4 b}
\key{display buffer in other window}{C-x 4 C-o}
\key{find file in other window}{C-x 4 f}
\key{find file read-only in other window}{C-x 4 r}
\key{run Dired in other window}{C-x 4 d}
\key{find tag in other window}{C-x 4 .}

\section{Formatting}

\key{indent current {\bf line} (mode-dependent)}{TAB}
\key{indent {\bf region} (mode-dependent)}{C-M-\\}
\key{indent {\bf sexp} (mode-dependent)}{C-M-q}
\key{indent region rigidly {\it arg\/} columns}{C-x TAB}

\key{insert newline after point}{C-o}
\key{move rest of line vertically down}{C-M-o}
\key{delete blank lines around point}{C-x C-o}
\key{join line with previous (with arg, next)}{M-^}
\key{delete all white space around point}{M-\\}
\key{put exactly one space at point}{M-SPC}

\key{fill paragraph}{M-q}
\key{set fill column}{C-x f}
\key{set prefix each line starts with}{C-x .}

\section{Case Change}

\key{uppercase word}{M-u}
\key{lowercase word}{M-l}
\key{capitalize word}{M-c}

\key{uppercase region}{C-x C-u}
\key{lowercase region}{C-x C-l}
\metax{capitalize region}{M-x capitalize-region}

\section{The Minibuffer}

The following keys are defined in the minibuffer.

\key{complete as much as possible}{TAB}
\key{complete up to one word}{SPC}
\key{complete and execute}{RET}
\key{show possible completions}{?}
\key{fetch previous minibuffer input}{M-p}
\key{fetch next later minibuffer input}{M-n}
\key{regexp search backward through history}{M-r}
\key{regexp search forward through history}{M-s}
\key{abort command}{C-g}

Type \kbd{C-x ESC ESC} to edit and repeat the last command that used the
minibuffer.  The following keys are then defined.

\key{previous minibuffer command}{M-p}
\key{next minibuffer command}{M-n}

\newcolumn
\title{GNU Emacs Reference Card}

\section{Buffers}

\key{select another buffer}{C-x b}
\key{list all buffers}{C-x C-b}
\key{kill a buffer}{C-x k}

\section{Transposing}

\key{transpose {\bf characters}}{C-t}
\key{transpose {\bf words}}{M-t}
\key{transpose {\bf lines}}{C-x C-t}
\key{transpose {\bf sexps}}{C-M-t}

\section{Spelling Check}

\key{check spelling of current word}{M-\$}
\metax{check spelling of all words in region}{M-x ispell-region}
\metax{check spelling of entire buffer}{M-x ispell-buffer}

\section{Tags}

\key{find a tag (a definition)}{M-.}
\key{find next occurrence of tag}{C-u M-.}
\metax{specify a new tags file}{M-x visit-tags-table}

\metax{regexp search on all files in tags table}{M-x tags-search}
\metax{run query-replace on all the files}{M-x tags-query-replace}
\key{continue last tags search or query-replace}{M-,}

\section{Shells}

\key{execute a shell command}{M-!}
\key{run a shell command on the region}{M-|}
\key{filter region through a shell command}{C-u M-|}
\metax{start a shell in window \kbd{*shell*}}{M-x shell}

\section{Rectangles}

\key{copy rectangle to register}{C-x r r}
\key{kill rectangle}{C-x r k}
\key{yank rectangle}{C-x r y}
\key{open rectangle, shifting text right}{C-x r o}
\metax{blank out rectangle}{M-x clear-rectangle}
\metax{prefix each line with a string}{M-x string-rectangle}

\section{Abbrevs}

\key{add global abbrev}{C-x a g}
\key{add mode-local abbrev}{C-x a l}
\key{add global expansion for this abbrev}{C-x a i g}
\key{add mode-local expansion for this abbrev}{C-x a i l}
\key{explicitly expand abbrev}{C-x a e}

\key{expand previous word dynamically}{M-/}

\section{Regular Expressions}

\key{any single character except a newline}{. {\rm(dot)}}
\key{zero or more repeats}{*}
\key{one or more repeats}{+}
\key{zero or one repeat}{?}
\key{any character in the set}{[ {\rm$\ldots$} ]}
\key{any character not in the set}{[^ {\rm$\ldots$} ]}
\key{beginning of line}{^}
\key{end of line}{\$}
\key{quote a special character {\it c\/}}{\\{\it c}}
\key{alternative (``or'')}{\\|}
\key{grouping}{\\( {\rm$\ldots$} \\)}
\key{{\it n\/}th group}{\\{\it n}}
\key{beginning of buffer}{\\`}
\key{end of buffer}{\\'}
\key{word break}{\\b}
\key{not beginning or end of word}{\\B}
\key{beginning of word}{\\<}
\key{end of word}{\\>}
\key{any word-syntax character}{\\w}
\key{any non-word-syntax character}{\\W}
\key{character with syntax {\it c}}{\\s{\it c}}
\key{character with syntax not {\it c}}{\\S{\it c}}

\section{Registers}

\key{save region in register}{C-x r s}
\key{insert register contents into buffer}{C-x r i}

\key{save value of point in register}{C-x r SPC}
\key{jump to point saved in register}{C-x r j}

\section{Info}

\key{enter the Info documentation reader}{C-h i}
\beginindentedkeys

Moving within a node:

\key{scroll forward}{SPC}
\key{scroll reverse}{DEL}
\key{beginning of node}{. {\rm (dot)}}

Moving between nodes:

\key{{\bf next} node}{n}
\key{{\bf previous} node}{p}
\key{move {\bf up}}{u}
\key{select menu item by name}{m}
\key{select {\it n\/}th menu item by number (1--5)}{{\it n}}
\key{follow cross reference  (return with \kbd{l})}{f}
\key{return to last node you saw}{l}
\key{return to directory node}{d}
\key{go to any node by name}{g}

Other:

\key{run Info {\bf tutorial}}{h}
\key{list Info commands}{?}
\key{{\bf quit} Info}{q}
\key{search nodes for regexp}{s}

\endindentedkeys

\section{Keyboard Macros}

\key{{\bf start} defining a keyboard macro}{C-x (}
\key{{\bf end} keyboard macro definition}{C-x )}
\key{{\bf execute} last-defined keyboard macro}{C-x e}
\key{append to last keyboard macro}{C-u C-x (}
\metax{name last keyboard macro}{M-x name-last-kbd-macro}
\metax{insert Lisp definition in buffer}{M-x insert-kbd-macro}

\section{Commands Dealing with Emacs Lisp}

\key{eval {\bf sexp} before point}{C-x C-e}
\key{eval current {\bf defun}}{C-M-x}
\metax{eval {\bf region}}{M-x eval-region}
\metax{eval entire {\bf buffer}}{M-x eval-current-buffer}
\key{read and eval minibuffer}{M-ESC}
\key{re-execute last minibuffer command}{C-x ESC ESC}
\metax{read and eval Emacs Lisp file}{M-x load-file}
\metax{load from standard system directory}{M-x load-library}

\section{Simple Customization}

% The intended audience here is the person who wants to make simple
% customizations and knows Lisp syntax.

Here are some examples of binding global keys in Emacs Lisp.  Note
that you cannot say \kbd{"\\M-\#"}; you must say \kbd{"\\e\#"}.

\beginexample%
(global-set-key "\\C-cg" 'goto-line)
(global-set-key "\\C-x\\C-k" 'kill-region)
(global-set-key "\\e\#" 'query-replace-regexp)
\endexample

An example of setting a variable in Emacs Lisp:

\beginexample%
(setq backup-by-copying-when-linked t)
\endexample

\section{Writing Commands}

\beginexample%
(defun \<command-name> (\<args>)
  "\<documentation>"
  (interactive "\<template>")
  \<body>)
\endexample

An example:

\beginexample%
(defun this-line-to-top-of-window (line)
  "Reposition line point is on to top of window.
With ARG, put point on line ARG.
Negative counts from bottom."
  (interactive "P")
  (recenter (if (null line)
                0
              (prefix-numeric-value line))))
\endexample

The argument to \kbd{interactive} is a string specifying how to get
the arguments when the function is called interactively.
Type \kbd{C-h f interactive} for more information.

\copyrightnotice

}\vfill\eject

\hb .emacs;

\noindent  Here is a sample .emacs file:

\listing{emacs-init.el}

\ha Appendix 4;

The main difficulty in configuring X is in adjusting for one's monitor
and video card. The file {\tt /usr/X386/lib/X11/VideoModes.Doc} gives
detailed instructions on setting the video timings. X allows far more
flexibility than DOS configurations. The downside of this is that one
has to do the configuration oneself. A crucial point is to ensure that
one doesn't try to drive one's monitor past its ability--{\bf this can
damage the monitor!}  To check the horizontal refresh rates needed by
the below, start emacs, press {\tt ESC x calc} and then enter:
'[25/800 28/800 36/1024 40/1056 44/1264] 1000 *. This will give a
vector giving the horizontal refresh in kilohertz. I've commented out
the fast refreshs; still, you should definitely read (and understand) 
the VideoModes.Doc file and modify the Xconfig appropriately before
starting X.

\listing{Xconfig}

\hb .Xdefaults;

\noindent Here is a sample .Xdefaults (the olvwm and Openwindows
resources are just for olvwm):

\listing{Xdefaults}

\hb .fvwmrc;

\noindent Here's the rc file for the feeble window manager I'm using:

\listing{fvwmrc}


\ha Appendix 5;

\hb Sample file structure;
\doublecolumns
{\obeylines
\font\tta=cmttss10 scaled 800 \tta\baselineskip=9pt
/
total   19
drwxr-xr-x bin
drwxr-xr-x book
drwxr-xr-x dev
drwxr-xr-x dos
drwxr-xr-x etc
drwxr-xr-x fd
-rw-r--r-- files
drwxr-xr-x home
drwxr-xr-x lib
drwxr-xr-x mnt
dr-xr-xr-x proc
drwxr-xr-x root
drwxr-xr-x tmp
drwxr-xr-x usr
\medskip
bin:
total 1084
-r-xr-xr-x basename
-r-xr-xr-x bash
-r-x--x--x cat
-r-xr-xr-x chmod
-r-xr-xr-x chown
lrwxrwxrwx compress-$>$gzip
-r-xr-xr-x cp
-r-xr-xr-x dd
-r-xr-xr-x df
-r-xr-xr-x du
-r-xr-xr-x ed
-rwxr-xr-x env
-rwxr-xr-x fdformat
-r-xr-xr-x fdisk
-r-xr-xr-x fgrep
-r-xr-xr-x find
-rwxr-xr-x fsck
-r-xr-xr-x grep
-r-xr-xr-x gzexe
-r-xr-xr-x gzip
-rwxr-xr-x jove
-rwxr-xr-x ksh
-r-xr-xr-x ln
-r-sr-xr-x login
-r-xr-xr-x ls
-r-xr-xr-x mdel
-r-xr-xr-x mdir
-r-xr-xr-x mkdir
-r-xr-xr-x mkfs
-r-xr-xr-x mknod
-r-xr-xr-x mkswap
-r-xr-xr-x more
lrwxrwxrwx mrd-$>$/bin/mread
-r-xr-xr-x mread
-r-xr-xr-x mv
-r-xr-xr-x mwrite
-r-sr-xr-x passwd
-r-xr-xr-x ps
-r-xr-xr-x rdev
-r-xr-xr-x rm
lrwxrwxrwx sh-$>$ksh
-rwxr-xr-x sleep
-r-xr-xr-x sort
-rwxr-xr-x split
-r-xr-xr-x stty
-r-xr-xr-x sync
-r-xr-xr-x tail
-rwxr-xr-x tar
-r-xr-xr-x touch
lrwxrwxrwx uncompress-$>$gzip
-r-xr-xr-x uudecode
-r-xr-xr-x wc
-r-xr-xr-x xargs
lrwxrwxrwx zcat-$>$gzip
\medskip
book:
total 576
-rwxr-xr-x Makefile
-rw-r--r-- cmd10.mf
-rw-r--r-- cmd10.tex
-rw-r--r-- cmttss.readme
-rw-r--r-- cmttss10.mf
-rw-r--r-- cmttss10.tex
-rw-r--r-- dotsetc.mf
-rw-r--r-- dotsetc.tex
-rw-r--r-- eflask.mf
-rw-r--r-- eflask.tex
-rw-r--r-- expr.mf
-rw-r--r-- expr.tex
-rw-r--r-- files
-rw-r--r-- files.txt
-rw-r--r-- geo.mf
-rw-r--r-- geo.tex
-rw-r--r-- gnuchars.mf
-rw-r--r-- gnuchars.tex
-rw-r--r-- intromf.mf
-rw-r--r-- intromf.tex
-rw-r--r-- linus.mf
-rw-r--r-- linus.tex
-rw-r--r-- linusa.mf
-rw-r--r-- linusa.tex
-rw-r--r-- llogo.mf
-rw-r--r-- llogo.tex
-rw-r--r-- mflan.tex
-rw-r--r-- milieu.dvi
-rw-r--r-- milieu.texi
-rw-r--r-- mmacs.tex
-rw-r--r-- mplain.mft
-rw-r--r-- queen.mf
-rw-r--r-- queen.tex
-rw-r--r-- stardot.mf
-rw-r--r-- stardot.tex
-rw-r--r-- ttt3.mf
-rw-r--r-- ttt3.tex
-rw-r--r-- tttn.mf
-rw-r--r-- tttn.tex
\medskip
dev:
total 16
-rwxr-xr-x 7540 Aug MAKEDEV
crw-r--r-- 10, 0 bm
crw-r--r-- 10, 3 bmouseatixl
crw-r--r-- 10, 0 bmouselogitec
crw-r--r-- 10, 2 bmousems
crw-r--r-- 10, 1 bmouseps2
crw------- 0, 0 boot0
crw------- 4, 1 console
brw-r----- 2, 0 fd0
brw-r----- 2, 28 fd0H1440
brw-r----- 2, 8 fd0h1200
brw-r----- 2, 1 fd1
brw-r----- 2, 29 fd1H1440
brw-r----- 2, 9 fd1h1200
brw-r----- 3, 0 hda
brw-r----- 3, 1 hda1
brw-r----- 3, 2 hda2
crw-r----- 1, 2 kmem
brw------- 12, 0 loop0
brw------- 12, 1 loop1
crw-r----- 6, 0 lp0
crw-r----- 6, 1 lp1
crw-r----- 6, 2 lp2
crw-r----- 1, 1 mem
lrwxrwxrwx 10 Jun modem-$>$/dev/ttys2
lrwxrwxrwx 6 Jun mouse-$>$ps2aux
crw-r--r-- 1, 3 null
crw-r----- 6, 0 par0
crw-r----- 6, 1 par1
crw-r----- 6, 2 par2
crw-r----- 1, 4 port
crw-r----- 6, 1 prn
brw-r--r-- 0, 10 proc
crw-r--r-- 10, 1 ps2aux
crw-rw-rw- 4, 128 ptyp0
crw-rw-rw- 4, 129 ptyp1
crw-rw-rw- 4, 130 ptyp2
brw-r----- 1, 0 ram
brw-r----- 8, 0 sda
brw-r----- 8, 1 sda1
lrwxrwxrwx 9 Jun swap-$>$/dev/hda1
crw-r--r-- 5, 0 tty
crw--w--w- 4, 0 tty0
crw--w--w- 4, 1 tty1
crw--w--w- 4, 2 tty2
crw--w--w- 4, 3 tty3
crw--w--w- 4, 192 ttyp0
crw--w--w- 4, 193 ttyp1
crw-r--r-- 4, 64 ttys0
crw-r--r-- 4, 64 ttys1
crw-r--r-- 4, 65 ttys2
crw-r--r-- 4, 66 ttys3
crw-r--r-- 4, 67 ttys4
crw-r--r-- 1, 5 zero
\medskip
dos:
total 2
\medskip
etc:
total 291
-r-xr-xr-x ctrlaltdel
-r--r--r-- fstab
-r-xr--r-- getty
-r--r--r-- group
-r-xr-xr-x hostname
-r-xr--r-- init
-rw-r--r-- inittab
-rw-r--r-- issue
drwxr-xr-x lilo
-r-xr-xr-x mount
-rw-r--r-- mtab
-rw-r--r-- mtools
-rw-r--r-- passwd
-r--r--r-- profile
-r-xr--r-- rc
-r-xr-xr-x setterm
-rw-r--r-- smtab
-r-xr-xr-x swapon
-r--r--r-- termcap
-r-xr-xr-x umount
-r-xr--r-- update
-r--r--r-- utmp
-rwxr-xr-x vmlinux
-r--r--r-- wtmp
\medskip
etc/lilo:
total 45
-rw-r--r-- boot.0300
-r--r--r-- boot.b
-r--r--r-- chain.b
-rw-r--r-- config
-rwxr-xr-x install
-r-xr--r-- lilo
-rw------- map
\medskip
fd:
total 2
\medskip
home:
drwxr-xr-x user
\medskip
home/user:
total 2
\medskip
lib:
total 1534
lrwxrwxrwx cpp-$>$/usr/bin/cpp
lrwxrwxrwx libX11.so.3-$>$libX11.so.3.0.1
-r-xr-xr-x libX11.so.3.0.1
lrwxrwxrwx libXaw.so.3-$>$libXaw.so.3.0.1
-r-xr-xr-x libXaw.so.3.0.1
lrwxrwxrwx libXt.so.3-$>$libXt.so.3.0.1
-r-xr-xr-x libXt.so.3.0.1
lrwxrwxrwx libc.so.4-$>$/lib/libc.so.4.3.3
-r-xr-xr-x libc.so.4.3.3
lrwxrwxrwx libm.so.4-$>$/lib/libm.so.4.3.3
-r-xr-xr-x libm.so.4.3.3
\medskip
mnt:
total 2
\medskip
root:
total 22
-rw-r--r-- .Xdefaults
-rw-r--r-- .bash\_history
-rw-r--r-- .bashrc
-rw-r--r-- .emacs
-rw-r--r-- .fvwmrc
-rw-r--r-- .joverc
-rw-r--r-- .kermrc
-rw-r--r-- .kshrc
-rw-r--r-- .pdksh\_hist
-rw-r--r-- .profile
drwxr-xr-x work
\medskip
root/work:
total 2
\medskip
tmp:
-r--r--r-- .X0-lock
drwxrwxrwx .X11-unix
\medskip
tmp/.X11-unix:
total 2
srwxrwxrwx X0
\medskip
usr:
total 8
drwxr-xr-x Emacs
drwxr-xr-x TeX
drwxr-xr-x X386
drwxr-xr-x bin
drwxr-xr-x lib
\medskip
usr/Emacs:
total 8
drwxr-xr-x etc
drwxr-xr-x info
drwxr-xr-x lib-src
drwxr-xr-x lisp
drwxr-xr-x site-lisp
\medskip
usr/Emacs/etc:
total 634
-rw-r--r-- DOC-19.13.1
-rw-r--r-- NEWS
-rw-r--r-- TUTORIAL
-rw-r--r-- refcard.tex
\medskip
usr/Emacs/info:
total 2696
-rw-r--r-- calc.info
-rw-r--r-- dir
-rw-r--r-- elisp
-rw-r--r-- emacs
-rw-r--r-- info
\medskip
usr/Emacs/lib-src:
total 2
\medskip
usr/Emacs/lisp:
total 425
-rw-r--r-- apropos.elc
-rw-r--r-- backquote.elc
-rw-r--r-- byte-opt.elc
-rw-r--r-- bytecomp.elc
drwxr-xr-x calc-2.02a
-rw-r--r-- comint.elc
-rw-r--r-- compile.elc
-rw-r--r-- dired-aux.elc
-rw-r--r-- dired.elc
-rw-r--r-- faces.elc
-rw-r--r-- find-dired.elc
-rw-r--r-- info.elc
-r--r--r-- menu-bar.el
-rw-r--r-- menu-bar.elc
-rw-r--r-- picture.elc
-rw-r--r-- rect.elc
-rw-r--r-- ring.elc
-rw-r--r-- shell.elc
-rw-r--r-- sort.elc
-rw-r--r-- tabify.elc
drwxr-xr-x term
-r--r--r-- tex-mode.el
-rw-r--r-- tex-mode.elc
-rw-r--r-- tex-site.elc
\medskip
usr/Emacs/lisp/calc-2.02a:
total 956
-rw-r--r-- calc.elc
\medskip
usr/Emacs/lisp/term:
total 28
-r--r--r-- x-win.el
-rw-r--r-- x-win.elc
\medskip
usr/Emacs/site-lisp:
total 2
\medskip
usr/TeX:
total 5
drwxr-xr-x bin
drwxr-xr-x gnuplot
drwxr-xr-x lib
\medskip
usr/TeX/bin:
total 1410
-rwxr-xr-x MakeTeXPK
lrwxrwxrwx TeXeditor-$>$jove
-rwxr-xr-x dvilj2p
-rwxr-xr-x dvips
-rwxr-xr-x dvp
-rwxr-xr-x gftodvi
-rwxr-xr-x gftopk
lrwxrwxrwx gmf-$>$/usr/TeX/bin/virmf
-rwxr-xr-x gnuplot
-rwxr-xr-x gnuplot\_x11
-rwxr-xr-x inimf
-rwxr-xr-x initex
-rwxr-xr-x makeinfo
lrwxrwxrwx mf-$>$/usr/TeX/bin/virmf
-rwxr-xr-x mft
lrwxrwxrwx tex-$>$/usr/TeX/bin/virtex
-rwxr-xr-x texindex
-rwxr-xr-x virmf
-rwxr-xr-x virtex
-rwxr-xr-x xdvi
\medskip
usr/TeX/gnuplot:
total 114
-rwxr-xr-x gnuplot.gih
\medskip
usr/TeX/lib:
drwxr-xr-x mf
drwxr-xr-x tex
\medskip
usr/TeX/lib/mf:
total 31
drwxr-xr-x bases
drwxr-xr-x macros
-rw-r--r-- mf.pool
\medskip
usr/TeX/lib/mf/bases:
total 119
-rw------- gmf.ini
-rw-r--r-- mf.base
-rw------- mf.ini
\medskip
usr/TeX/lib/mf/macros:
total 894
-rw-r--r-- accent.mf
-rw-r--r-- bigacc.mf
-rw-r--r-- bigdel.mf
-rw-r--r-- bigop.mf
-rw-r--r-- black.mf
-rw-r--r-- blacklj.mf
-rw-r--r-- book.mf
-rw-r--r-- calu.mf
-rw-r--r-- cccsc10.mf
-rw-r--r-- ccmi10.mf
-rw-r--r-- ccr10.mf
-rw-r--r-- ccr5.mf
-rw-r--r-- ccr7.mf
-rw-r--r-- ccsl10.mf
-rw-r--r-- ccti10.mf
-rw------- cm.ini
-rw-r--r-- cmb10.mf
-rw-r--r-- cmbase.mf
-rw------- cmbase.mft
-rw-r--r-- cmbsy10.mf
-rw-r--r-- cmbx10.mf
-rw-r--r-- cmbx12.mf
-rw-r--r-- cmbx5.mf
-rw-r--r-- cmbx7.mf
-rw-r--r-- cmbxcd10.mf
-rw-r--r-- cmbxsl10.mf
-rw-r--r-- cmbxti10.mf
-rw-r--r-- cmbxti12.mf
-rw-r--r-- cmbxti7.mf
-rw-r--r-- cmcsc10.mf
-rw-r--r-- cmcscsl10.mf
-rw-r--r-- cmd10.mf
-rw-r--r-- cmdunh10.mf
-rw-r--r-- cmex10.mf
-rw-r--r-- cminch.mf
-rw-r--r-- cmmi10.mf
-rw-r--r-- cmmi12.mf
-rw-r--r-- cmmi5.mf
-rw-r--r-- cmmi7.mf
-rw-r--r-- cmmib10.mf
-rw-r--r-- cmr10.mf
-rw-r--r-- cmr12.mf
-rw-r--r-- cmr17.mf
-rw-r--r-- cmr5.mf
-rw-r--r-- cmr7.mf
-rw-r--r-- cmsl10.mf
-rw-r--r-- cmsl12.mf
-rw-r--r-- cmss10.mf
-rw-r--r-- cmss12.mf
-rw-r--r-- cmss17.mf
-rw-r--r-- cmssb10.mf
-rw-r--r-- cmssbx10.mf
-rw-r--r-- cmssbxo10.mf
-rw-r--r-- cmssdc10.mf
-rw-r--r-- cmssi10.mf
-rw-r--r-- cmssi12.mf
-rw-r--r-- cmssi17.mf
-rw-r--r-- cmsslu30.mf
-rw-r--r-- cmssu30.mf
-rw-r--r-- cmsy10.mf
-rw-r--r-- cmsy5.mf
-rw-r--r-- cmsy7.mf
-rw-r--r-- cmtex10.mf
-rw-r--r-- cmti10.mf
-rw-r--r-- cmti12.mf
-rw-r--r-- cmti7.mf
-rw-r--r-- cmtt10.mf
-rw-r--r-- cmtt12.mf
-rw-r--r-- cmu10.mf
-rw-r--r-- comlig.mf
-rw-r--r-- csc.mf
-rw-r--r-- cscspu.mf
-rw------- e.mft
-rw-r--r-- eflask.mf
-rw-r--r-- ega.mf
-rw-r--r-- expr.mf
-rw-r--r-- geo.mf
-rw-r--r-- gnuchars.mf
-rw-r--r-- graphbase.mf
-rw-r--r-- gray.mf
-rw-r--r-- grayf.mf
-rw-r--r-- graylj.mf
-rw-r--r-- greekl.mf
-rw-r--r-- greeku.mf
-rw-r--r-- halftone.mf
-rw-r--r-- io.mf
-rw-r--r-- itald.mf
-rw-r--r-- italig.mf
-rw-r--r-- itall.mf
-rw-r--r-- italms.mf
-rw-r--r-- italp.mf
-rw-r--r-- italsp.mf
-rw-r--r-- l.mf
-rw-r--r-- life.mf
-rw-r--r-- linus.mf
-rw-r--r-- llogo.mf
-rw-r--r-- logo.mf
-rw-r--r-- logo10.mf
-rw-r--r-- logobf10.mf
-rw-r--r-- logosl10.mf
-rw-r--r-- macs.mf
-rw-r--r-- manfnt.mf
-rw-r--r-- mathex.mf
-rw-r--r-- mathit.mf
-rw-r--r-- mathsy.mf
-rw-r--r-- modes.mf
-rw-r--r-- null.mf
-rw-r--r-- olddig.mf
-rw-r--r-- plain.mf
-rw-r--r-- plain.mft
-rw-r--r-- punct.mf
-rw-r--r-- queen.mf
-rw-r--r-- roman.mf
-rw-r--r-- romand.mf
-rw-r--r-- romanl.mf
-rw-r--r-- romanp.mf
-rw-r--r-- romanu.mf
-rw-r--r-- romlig.mf
-rw-r--r-- romms.mf
-rw-r--r-- romspl.mf
-rw-r--r-- romspu.mf
-rw-r--r-- romsub.mf
-rw-r--r-- slant.mf
-rw-r--r-- slantlj.mf
-rw-r--r-- sym.mf
-rw-r--r-- symbol.mf
-rw-r--r-- texset.mf
-rw-r--r-- textit.mf
-rw-r--r-- title.mf
-rw-r--r-- tset.mf
-rw-r--r-- tsetsl.mf
-rw-r--r-- ttt3.mf
-rw-r--r-- tttn-1.mf
-rw-r--r-- tttn-2.mf
-rw-r--r-- tttn-3.mf
-rw-r--r-- tttn.mf
\medskip
usr/TeX/lib/tex:
total 36
drwxr-xr-x fonts
drwxr-xr-x formats
drwxr-xr-x inputs
drwxr-xr-x ps
-rw-r--r-- tex.pool
\medskip
usr/TeX/lib/tex/fonts:
total 263
-rw-r--r-- cmb10.tfm
-rw-r--r-- cmbx10.tfm
-rw------- cmbx5.tfm
-rw------- cmbx7.tfm
-rw-r--r-- cmd10.300pk
-rw-r--r-- cmd10.tfm
-rw-r--r-- cmex10.tfm
-rw-r--r-- cmmi10.tfm
-rw------- cmmi5.tfm
-rw------- cmmi7.tfm
-rw-r--r-- cmr10.tfm
-rw------- cmr5.tfm
-rw-r--r-- cmr7.tfm
-rw------- cmsl10.tfm
-rw------- cmss10.tfm
-rw-r--r-- cmsy10.tfm
-rw------- cmsy5.tfm
-rw------- cmsy7.tfm
-rw-r--r-- cmtex10.tfm
-rw-r--r-- cmti10.tfm
-rw-r--r-- cmtt10.tfm
-rw------- dummy.tfm
\medskip

usr/TeX/lib/tex/formats:
total 204
-rw-r--r-- tex.fmt
\medskip
usr/TeX/lib/tex/inputs:
total 420
-rw-r--r-- cropmarks.tex
-rw-r--r-- eplain.tex
-rw-r--r-- frac.tex
-rw-r--r-- hyphen.tex
-rw-r--r-- italic.tex
-rw-r--r-- l.tex
-rw-r--r-- list.tex
-rw-r--r-- manpage.tex
-rw-r--r-- mftmac.tex
-rw-r--r-- newsletr.tex
-rw-r--r-- newsletr.txt
-rw-r--r-- newssamp.tex
-rw-r--r-- null.tex
-rw-r--r-- plain.tex
-rw-r--r-- quote.tex
-rw-r--r-- stables.tex
-rw-r--r-- story.tex
-rw-r--r-- tabledoc.tex
-rw-r--r-- testfont.tex
-r--r--r-- texinfo.tex
-rw-r--r-- verbatim.tex
-rw-r--r-- webmac.tex
\medskip
usr/TeX/lib/tex/ps:
total 29
-rw-r--r-- color.pro
-rw-r--r-- config.ps
-rw-r--r-- crop.pro
-rw-r--r-- figtex.pro
-rw-r--r-- finclude.pro
-rw-r--r-- psfonts.map
-rw-r--r-- special.pro
-rw-r--r-- tex.pro
-rw-r--r-- texc.pro
-rw-r--r-- texps.pro
\medskip
usr/X386:
total 5
drwxr-xr-x bin
drwxr-xr-x include
drwxr-xr-x lib
\medskip
usr/X386/bin:
total 2642
lrwxrwxrwx X-$>$XF86\_SVGA
-rwsr-xr-x XF86\_SVGA
-rwsr-xr-x cxterm
-rwxr-xr-x fvwm
-rwsr-sr-x rxvt
-rwxr-xr-x startx
-rwxr-xr-x xdu
-rwxr-xr-x xinit
-rwxr-xr-x xmfm
-rwxr-xr-x xmodmap
-rwxr-xr-x xrdb
-rwxr-xr-x xset
-rwxr-xr-x xsetroot
lrwxrwxrwx xterm-$>$cxterm
\medskip
usr/X386/include:
drwxr-xr-x X11
\medskip
usr/X386/include/X11:
total 9
drwxr-xr-x bitmaps
\medskip
usr/X386/include/X11/bitmaps:
total 8
\medskip
usr/X386/lib:
drwxr-xr-x X11
\medskip
usr/X386/lib/X11:
total 244
-r--r--r-- VideoModes.doc
-r--r--r-- XErrorDB
-r--r--r-- XKeysymDB
-r--r--r-- Xconfig
-r--r--r-- Xconfig.sample
drwxr-xr-x app-defaults
drwxr-xr-x bitmaps
drwxr-xr-x fonts
drwxr-xr-x fvwm
-rw-r--r-- rgb.dir
-rw-r--r-- rgb.pag
-rw-r--r-- rgb.txt
drwxr-xr-x xinit
\medskip
usr/X386/lib/X11/app-defaults:
total 15
-rw-r--r-- XDu
-r--r--r-- XTerm
-rw-r--r-- XmFm
-rw-r--r-- xmfmrc
\medskip
usr/X386/lib/X11/bitmaps:
total 9
drwxr-xr-x XmFm
\medskip
usr/X386/lib/X11/bitmaps/XmFm:
total 275
-rw-r----- cweb-s.xbm
-rw-r--r-- dotdot.xbm
-rw-r--r-- dvi.xbm
-rw-r--r-- emacs.xbm
-rw-r--r-- herefolder.xbm
-rw-r----- sm-mf.xbm
-rw-r----- sm-tex.xbm
-rw-r--r-- xdtm.xbm
-r--r--r-- xlogo32
\medskip
usr/X386/lib/X11/fonts:
drwxr-xr-x misc
\medskip
usr/X386/lib/X11/fonts/misc:
total 419
-r--r--r-- 10x20.pcf
-r--r--r-- 12x24.pcf
-r--r--r-- 5x8.pcf
-r--r--r-- 6x10.pcf
-r--r--r-- 6x12.pcf
-r--r--r-- 6x13.pcf
-r--r--r-- 6x13B.pcf
-r--r--r-- 6x9.pcf
-r--r--r-- 7x13.pcf
-r--r--r-- 7x13B.pcf
-r--r--r-- 7x14.pcf
-r--r--r-- 7x14B.pcf
-r--r--r-- 8x13.pcf
-r--r--r-- 8x13B.pcf
-r--r--r-- 8x16.pcf
-r--r--r-- 9x15.pcf
-r--r--r-- 9x15B.pcf
-r--r--r-- courB14.pcf
-r--r--r-- courR12.pcf
-r--r--r-- cursor.pcf
-rw-r--r-- fonts.alias
-rw-r--r-- fonts.dir
-r--r--r-- helvB14.pcf
-r--r--r-- nil2.pcf
-r--r--r-- olcursor.pcf
-r--r--r-- olgl12.pcf
\medskip
usr/X386/lib/X11/fvwm:
-rw-r--r-- system.fvwmrc
\medskip
usr/X386/lib/X11/xinit:
total 5
-rw-r--r-- .Xmodmap
-rw-r--r-- .Xresources
-rwxr-xr-x xinitrc
\medskip
usr/bin:
total 2111
-r-xr-xr-x ar
-r-xr-xr-x as
-r-xr-xr-x as86
-rwxr-xr-x awk
lrwxrwxrwx cc-$>$/usr/bin/gcc
-rwxr-xr-x clear
-r-xr-xr-x cpp
-rwxr-xr-x date
-rwxr-xr-x diff
-rwxr-xr-x echo
-rwxr-xr-x emacs
-rwxr-xr-x expr
-r-xr-xr-x free
-r-xr-xr-x gcc
-rwxr-xr-x kermit
-r-xr-xr-x ld
-r-xr-xr-x ld86
-rwxr-xr-x ll
-rwxr-xr-x lss
-r-xr-xr-x make
-r-xr-xr-x nm
-r-xr-xr-x objdump
-r-xr-xr-x patch
-r-xr-xr-x ranlib
-r-xr-xr-x sed
-r-xr-xr-x size
-r-xr-xr-x strip
-rwxr-xr-x tee
-r-xr-xr-x true
-r-xr-xr-x uname
-rwxr-xr-x where
-rwxr-xr-x whoami
\medskip
usr/lib:
lrwxrwxrwx X11-$>$/usr/X386/lib/X11
drwxr-xr-x emacs
\medskip
usr/lib/emacs:
lrwxrwxrwx site-lisp-$>$/usr/Emacs/site-lisp
\medskip
}
\bye
