% This program by D. E. Knuth is not copyrighted and can be used freely.
% Version 0 was completed on April 23, 1984.
% Version 0.1 added char←code output (May 4).
% Version 0.2 included rules and dots in the boundary calculations (May 25).
% Version 0.3 added label type "/" (May 27).
% Version 0.4 (by Arthur Samuel) improved the dot labelling routine (July 23).
% Version 0.5 added the slant font for rules (September 2).
% Version 0.6 changed label types and allowed invisible dots (September 28).
% Version 1.0 switched to new GF format (December 8).
% Version 1.1 switched to newer GF format (February 2, 1985).
% Version 1.2 added the offset operations of MF version 0.8 (April 1, 1985).
% Version 1.3 allowed online entry of gray font, etc. (April 22, 1985).
% Version 1.4 allowed "almost" horizontal or vertical rules (May 20, 1985).
% Version 1.5 corrected a bug in the diagonal slant routine (June 18, 1985).

% Here is TeX material that gets inserted after \input webmac
\def\hang{\hangindent 3em\indent\ignorespaces}
\font\ninerm=amr9
\let\mc=\ninerm % medium caps for names like SAIL
\def\PASCAL{Pascal}
\font\logo=manfnt % font used for the METAFONT logo
\def\MF{{\logo META}\-{\logo FONT}}
\let\swap=\leftrightarrow

\def\(#1){} % this is used to make section names sort themselves better
\def\9#1{} % this is used for sort keys in the index

\def\title{GF$\,$\lowercase{to}$\,$DVI}
\def\contentspagenumber{201}
\def\topofcontents{\null
  \def\titlepage{F} % include headline on the contents page
  \def\rheader{\mainfont\hfil \contentspagenumber}
  \vfill
  \centerline{\titlefont The {\ttitlefont GFtoDVI} processor}
  \vskip 15pt
  \centerline{(Version 1.5, June 1985)}
  \vfill}
\def\botofcontents{\vfill
  \centerline{\hsize 5in\baselineskip9pt
    \vbox{\ninerm\noindent
    The preparation of this report
    was supported in part by the National Science
    Foundation under grants IST-8201926 and MCS-8300984,
    and by the System Development Foundation. `\TeX' is a
    trademark of the American Mathematical Society.}}}
\pageno=\contentspagenumber \advance\pageno by 1

@* Introduction.
The \.{GFtoDVI} utility program reads binary generic font (``\.{GF}'')
files that are produced by font compilers such as \MF, and converts them
into device-independent (``\.{DVI}'') files that can be printed to give
annotated hardcopy proofs of the character shapes. The annotations are
specified by the comparatively simple conventions of plain \MF; i.e.,
there are mechanisms for labeling chosen points and for superimposing
horizontal or vertical rules on the enlarged character shapes.

The purpose of \.{GFtoDVI} is simply to make proof copies; it does not
exhaustively test the validity of a \.{GF} file, nor do its algorithms
much resemble the algorithms that are typically used to prepare font
descriptions for commercial typesetting equipment. Another program,
\.{GFtype}, is available for validity checking; \.{GFtype} also serves
as a model of programs that convert fonts from \.{GF} format to some
other coding scheme.

The |banner| string defined here should be changed whenever \.{GFtoDVI}
gets modified.

@d banner=='This is GFtoDVI, Version 1.5' {printed when the program starts}

@ This program is written in standard \PASCAL, except where it is necessary
to use extensions; for example, \.{GFtoDVI} must read files whose names
are dynamically specified, and such a task would be impossible in pure \PASCAL.
All places where nonstandard constructions are used have been listed in
the index under ``system dependencies.''
@!@↑system dependencies@>

Another exception to standard \PASCAL\ occurs in the
use of default branches in |case| statements; the conventions
of \.{TANGLE}, \.{WEAVE}, etc., have been followed.

@d othercases == others: {default for cases not listed explicitly}
@d endcases == @+end {follows the default case in an extended |case| statement}
@f othercases == else
@f endcases == end

@ The input and output files are not mentioned in the program header,
because their external names
will be determined at run time (e.g., by interpreting the
command line that invokes this program). Error messages and other remarks
are written on the |output| file, which the user may
choose to assign to the terminal if the system permits it.
@↑system dependencies@>

The term |print| is used instead of |write| when this program writes on
the |output| file, so that all such output can be easily deflected.

@d print(#)==write(#)
@d print←ln(#)==write←ln(#)
@d print←nl(#)==begin write←ln; write(#);
  end

@p program GF←to←DVI(@!output);
label @<Labels in the outer block@>@/
const @<Constants in the outer block@>@/
type @<Types in the outer block@>@/
var @<Globals in the outer block@>@/
procedure initialize; {this procedure gets things started properly}
  var @!i,@!j,@!m,@!n:integer; {loop indices for initializations}
  begin print←ln(banner);@/
  @<Set initial values@>@/
  end;

@ If the program has to stop prematurely, it goes to the
`|final←end|'.

@d final←end=9999 {label for the end of it all}

@<Labels...@>=final←end;

@ The following parameters can be changed at compile time to extend or
reduce \.{GFtoDVI}'s capacity.

@<Constants...@>=
@!max←labels=2000; {maximum number of labels and dots per character}
@!pool←size=10000; {maximum total length of labels and other strings}
@!max←strings=1100; {maximum number of labels and other strings}
@!terminal←line←length=150; {maximum number of characters input in a single
  line of input from the terminal}
@!file←name←size=50; {a file name shouldn't be longer than this}
@!font←mem←size=1000; {space for font metric data}
@!dvi←buf←size=800; {size of the output buffer; must be a multiple of 8}
@!widest←row=8192; {maximum number of pixels per row}

@ Labels are given symbolic names by the following definitions, so that
occasional |goto| statements will be meaningful. We insert the label
`|exit|:' just before the `\ignorespaces|end|\unskip' of a procedure in
which we have used the `|return|' statement defined below; the label
`|reswitch|' is occasionally used just prior to a |case|
statement in which some cases change the conditions and we wish to branch
to the newly applicable case.  Loops that are set up with the |loop|
construction defined below are commonly exited by going to `|done|' or to
`|found|' or to `|not←found|', and they are sometimes repeated by going to
`|continue|'.

Incidentally, this program never declares a label that isn't actually used,
because some fussy \PASCAL\ compilers will complain about redundant labels.

@d exit=10 {go here to leave a procedure}
@d reswitch=21 {go here to start a case statement again}
@d continue=22 {go here to resume a loop}
@d done=30 {go here to exit a loop}
@d done1=31 {like |done|, when there is more than one loop}
@d found=40 {go here when you've found it}
@d not←found=45 {go here when you've found nothing}

@ Here are some macros for common programming idioms.

@d incr(#) == #:=#+1 {increase a variable by unity}
@d decr(#) == #:=#-1 {decrease a variable by unity}
@d loop == @+ while true do@+ {repeat over and over until a |goto| happens}
@f loop == xclause
  {\.{WEB}'s |xclause| acts like `\ignorespaces|while true do|\unskip'}
@d do←nothing == {empty statement}
@d return == goto exit {terminate a procedure call}
@f return == nil {\.{WEB} will henceforth say |return| instead of \\{return}}

@ If the \.{GF} file is badly malformed, the whole process must be aborted;
\.{GFtoDVI} will give up, after issuing an error message about the symptoms
that were noticed.

Such errors might be discovered inside of subroutines inside of subroutines,
so a procedure called |jump←out| has been introduced. This procedure, which
simply transfers control to the label |final←end| at the end of the program,
contains the only non-local |goto| statement in \.{GFtoDVI}.
@↑system dependencies@>

@d abort(#)==begin print(' ',#); jump←out;
    end
@d bad←gf(#)==abort('Bad GF file: ',#,'! (at byte ',cur←loc-1:1,')')
@.Bad GF file@>

@p procedure jump←out;
begin goto final←end;
end;

@ As in \TeX\ and \MF, this program deals with numeric quantities that
are integer multiples of~$2↑{16}$, and calls them |scaled|.

@d unity==@'200000 {|scaled| representation of 1.0}

@<Types ...@>=
@!scaled=integer; {fixed-point numbers}

@* The character set.
Like all programs written with the  \.{WEB} system, \.{GFtoDVI} can be
used with any character set. But it uses ASCII code internally, because
the programming for portable input-output is easier when a fixed internal
code is used. Furthermore, both \.{GF} and \.{DVI} files use ASCII code
for file names and certain other strings.

The next few sections of \.{GFtoDVI} have therefore been copied from the
analogous ones in the \.{WEB} system routines. They have been considerably
simplified, since \.{GFtoDVI} need not deal with the controversial
ASCII codes less than @'40.

@<Types ...@>=
@!ASCII←code=" ".."~"; {a subrange of the integers}

@ The original \PASCAL\ compiler was designed in the late 60s, when
six-bit character sets were common, so it did not make provision for lower
case letters. Nowadays, of course, we need to deal with both upper and
lower case alphabets in a convenient way.  So we shall assume that the
\PASCAL\ system being used for \.{GFtoDVI} has a character set containing
at least the standard visible ASCII characters (|"!"| through |"~"|).

Some \PASCAL\ compilers use the original name |char| for the data type
associated with the characters in text files, while other \PASCAL s
consider |char| to be a 64-element subrange of a larger data type that has
some other name.  In order to accommodate this difference, we shall use
the name |text←char| to stand for the data type of the characters in the
output file.  We shall also assume that |text←char| consists of
the elements |chr(first←text←char)| through |chr(last←text←char)|,
inclusive. The following definitions should be adjusted if necessary.
@↑system dependencies@>

@d text←char == char {the data type of characters in text files}
@d first←text←char=0 {ordinal number of the smallest element of |text←char|}
@d last←text←char=127 {ordinal number of the largest element of |text←char|}

@<Types ...@>=
@!text←file=packed file of text←char;

@ The \.{GFtoDVI} processor converts between ASCII code and
the user's external character set by means of arrays |xord| and |xchr|
that are analogous to \PASCAL's |ord| and |chr| functions.

@<Globals...@>=
@!xord: array [text←char] of ASCII←code;
  {specifies conversion of input characters}
@!xchr: array [0..255] of text←char;
  {specifies conversion of output characters}

@ Under our assumption that the visible characters of standard ASCII are
all present, the following assignment statements initialize the
|xchr| array properly, without needing any system-dependent changes.

@<Set init...@>=
for i:=0 to @'37 do xchr[i]:='?';
xchr[@'40]:=' ';
xchr[@'41]:='!';
xchr[@'42]:='"';
xchr[@'43]:='#';
xchr[@'44]:='$';
xchr[@'45]:='%';
xchr[@'46]:='&';
xchr[@'47]:='''';@/
xchr[@'50]:='(';
xchr[@'51]:=')';
xchr[@'52]:='*';
xchr[@'53]:='+';
xchr[@'54]:=',';
xchr[@'55]:='-';
xchr[@'56]:='.';
xchr[@'57]:='/';@/
xchr[@'60]:='0';
xchr[@'61]:='1';
xchr[@'62]:='2';
xchr[@'63]:='3';
xchr[@'64]:='4';
xchr[@'65]:='5';
xchr[@'66]:='6';
xchr[@'67]:='7';@/
xchr[@'70]:='8';
xchr[@'71]:='9';
xchr[@'72]:=':';
xchr[@'73]:=';';
xchr[@'74]:='<';
xchr[@'75]:='=';
xchr[@'76]:='>';
xchr[@'77]:='?';@/
xchr[@'100]:='@@';
xchr[@'101]:='A';
xchr[@'102]:='B';
xchr[@'103]:='C';
xchr[@'104]:='D';
xchr[@'105]:='E';
xchr[@'106]:='F';
xchr[@'107]:='G';@/
xchr[@'110]:='H';
xchr[@'111]:='I';
xchr[@'112]:='J';
xchr[@'113]:='K';
xchr[@'114]:='L';
xchr[@'115]:='M';
xchr[@'116]:='N';
xchr[@'117]:='O';@/
xchr[@'120]:='P';
xchr[@'121]:='Q';
xchr[@'122]:='R';
xchr[@'123]:='S';
xchr[@'124]:='T';
xchr[@'125]:='U';
xchr[@'126]:='V';
xchr[@'127]:='W';@/
xchr[@'130]:='X';
xchr[@'131]:='Y';
xchr[@'132]:='Z';
xchr[@'133]:='[';
xchr[@'134]:='\';
xchr[@'135]:=']';
xchr[@'136]:='↑';
xchr[@'137]:='←';@/
xchr[@'140]:='`';
xchr[@'141]:='a';
xchr[@'142]:='b';
xchr[@'143]:='c';
xchr[@'144]:='d';
xchr[@'145]:='e';
xchr[@'146]:='f';
xchr[@'147]:='g';@/
xchr[@'150]:='h';
xchr[@'151]:='i';
xchr[@'152]:='j';
xchr[@'153]:='k';
xchr[@'154]:='l';
xchr[@'155]:='m';
xchr[@'156]:='n';
xchr[@'157]:='o';@/
xchr[@'160]:='p';
xchr[@'161]:='q';
xchr[@'162]:='r';
xchr[@'163]:='s';
xchr[@'164]:='t';
xchr[@'165]:='u';
xchr[@'166]:='v';
xchr[@'167]:='w';@/
xchr[@'170]:='x';
xchr[@'171]:='y';
xchr[@'172]:='z';
xchr[@'173]:='{';
xchr[@'174]:='|';
xchr[@'175]:='}';
xchr[@'176]:='~';
for i:=@'177 to 255 do xchr[i]:='?';

@ The following system-independent code makes the |xord| array contain a
suitable inverse to the information in |xchr|.

@<Set init...@>=
for i:=first←text←char to last←text←char do xord[chr(i)]:=" ";
for i:="!" to "~" do xord[xchr[i]]:=i;

@ The |input←ln| routine waits for the user to type a line at his or her
terminal; then it puts ASCII-code equivalents for the characters on that line
into the |buffer| array. The |term←in| file is used for terminal input.
@↑system dependencies@>

Since the terminal is being used for both input and output, some systems
need a special routine to make sure that the user can see a prompt message
before waiting for input based on that message. (Otherwise the message
may just be sitting in a hidden buffer somewhere, and the user will have
no idea what the program is waiting for.) We shall call a system-dependent
subroutine |update←terminal| in order to avoid this problem.

@d update←terminal == break(output) {empty the terminal output buffer}

@<Glob...@>=
@!buffer:array[0..terminal←line←length] of 0..255;
@!term←in:text←file; {the terminal, considered as an input file}

@ A global variable |line←length| records the first buffer position after
the line just read.
@↑system dependencies@>

@p procedure input←ln; {inputs a line from the terminal}
begin update←terminal; reset(term←in);
if eoln(term←in) then read←ln(term←in);
line←length:=0;
while (line←length<terminal←line←length)and not eoln(term←in) do
  begin buffer[line←length]:=xord[term←in↑]; incr(line←length); get(term←in);
  end;
end;

@ @<Glob...@>=
@!line←length:0..terminal←line←length; {end of line read by |input←ln|}

@ The global variable |buf←ptr| is used while scanning each line of input;
it points to the first unread character in |buffer|.

@<Glob...@>=
@!buf←ptr:0..terminal←line←length; {the number of characters read}

@* Device-independent file format.
Before we get into the details of \.{GFtoDVI}, we need to know exactly
what \.{DVI} files are. The form of such files was designed by David R.
@↑Fuchs, David Raymond@>
Fuchs in 1979. Almost any reasonable typesetting device can be driven by
a program that takes \.{DVI} files as input, and dozens of such
\.{DVI}-to-whatever programs have been written. Thus, it is possible to
print the output of document compilers like \TeX\ on many different kinds
of equipment. (The following material has been copied almost verbatim from the
program for \TeX.)

A \.{DVI} file is a stream of 8-bit bytes, which may be regarded as a
series of commands in a machine-like language. The first byte of each command
is the operation code, and this code is followed by zero or more bytes
that provide parameters to the command. The parameters themselves may consist
of several consecutive bytes; for example, the `|set←rule|' command has two
parameters, each of which is four bytes long. Parameters are usually
regarded as nonnegative integers; but four-byte-long parameters,
and shorter parameters that denote distances, can be
either positive or negative. Such parameters are given in two's complement
notation. For example, a two-byte-long distance parameter has a value between
$-2↑{15}$ and $2↑{15}-1$.
@.DVI {\rm files}@>

Incidentally, when two or more 8-bit bytes are combined to form an integer of
16 or more bits, the most significant bytes appear first in the file.
This is called BigEndian order.
@↑BigEndian order@>

A \.{DVI} file consists of a ``preamble,'' followed by a sequence of one
or more ``pages,'' followed by a ``postamble.'' The preamble is simply a
|pre| command, with its parameters that define the dimensions used in the
file; this must come first.  Each ``page'' consists of a |bop| command,
followed by any number of other commands that tell where characters are to
be placed on a physical page, followed by an |eop| command. The pages
appear in the order that they were generated, not in any particular
numerical order. If we ignore |nop| commands and \\{fnt\←def} commands
(which are allowed between any two commands in the file), each |eop|
command is immediately followed by a |bop| command, or by a |post|
command; in the latter case, there are no more pages in the file, and the
remaining bytes form the postamble.  Further details about the postamble
will be explained later.

Some parameters in \.{DVI} commands are ``pointers.'' These are four-byte
quantities that give the location number of some other byte in the file;
the first byte is number~0, then comes number~1, and so on. For example,
one of the parameters of a |bop| command points to the previous |bop|;
this makes it feasible to read the pages in backwards order, in case the
results are being directed to a device that stacks its output face up.
Suppose the preamble of a \.{DVI} file occupies bytes 0 to 99. Now if the
first page occupies bytes 100 to 999, say, and if the second
page occupies bytes 1000 to 1999, then the |bop| that starts in byte 1000
points to 100 and the |bop| that starts in byte 2000 points to 1000. (The
very first |bop|, i.e., the one that starts in byte 100, has a pointer of $-1$.)

@ The \.{DVI} format is intended to be both compact and easily interpreted
by a machine. Compactness is achieved by making most of the information
implicit instead of explicit. When a \.{DVI}-reading program reads the
commands for a page, it keeps track of several quantities: (a)~The current
font |f| is an integer; this value is changed only
by \\{fnt} and \\{fnt\←num} commands. (b)~The current position on the page
is given by two numbers called the horizontal and vertical coordinates,
|h| and |v|. Both coordinates are zero at the upper left corner of the page;
moving to the right corresponds to increasing the horizontal coordinate, and
moving down corresponds to increasing the vertical coordinate. Thus, the
coordinates are essentially Cartesian, except that vertical directions are
flipped; the Cartesian version of |(h,v)| would be |(h,-v)|.  (c)~The
current spacing amounts are given by four numbers |w|, |x|, |y|, and |z|,
where |w| and~|x| are used for horizontal spacing and where |y| and~|z|
are used for vertical spacing. (d)~There is a stack containing
|(h,v,w,x,y,z)| values; the \.{DVI} commands |push| and |pop| are used to
change the current level of operation. Note that the current font~|f| is
not pushed and popped; the stack contains only information about
positioning.

The values of |h|, |v|, |w|, |x|, |y|, and |z| are signed integers having up
to 32 bits, including the sign. Since they represent physical distances,
there is a small unit of measurement such that increasing |h| by~1 means
moving a certain tiny distance to the right. The actual unit of
measurement is variable, as explained below.

@ Here is a list of all the commands that may appear in a \.{DVI} file. Each
command is specified by its symbolic name (e.g., |bop|), its opcode byte
(e.g., 139), and its parameters (if any). The parameters are followed
by a bracketed number telling how many bytes they occupy; for example,
`|p[4]|' means that parameter |p| is four bytes long.

\yskip\hang|set←char←0| 0. Typeset character number~0 from font~|f|
such that the reference point of the character is at |(h,v)|. Then
increase |h| by the width of that character. Note that a character may
have zero or negative width, so one cannot be sure that |h| will advance
after this command; but |h| usually does increase.

\yskip\hang|set←char←1| through |set←char←127| (opcodes 1 to 127).
Do the operations of |set←char←0|; but use the character whose number
matches the opcode, instead of character~0.

\yskip\hang|set1| 128 |c[1]|. Same as |set←char←0|, except that character
number~|c| is typeset. \TeX82 uses this command for characters in the
range |128<=c<256|.

\yskip\hang|set2| 129 |c[2]|. Same as |set1|, except that |c|~is two
bytes long, so it is in the range |0<=c<65536|.

\yskip\hang|set3| 130 |c[3]|. Same as |set1|, except that |c|~is three
bytes long, so it can be as large as $2↑{24}-1$. Not even the Chinese
language has this many characters, but this command might prove useful
in some yet unforeseen way.

\yskip\hang|set4| 131 |c[4]|. Same as |set1|, except that |c|~is four
bytes long, possibly even negative. Imagine that.

\yskip\hang|set←rule| 132 |a[4]| |b[4]|. Typeset a solid black rectangle
of height |a| and width |b|, with its bottom left corner at |(h,v)|. Then
set |h:=h+b|. If either |a<=0| or |b<=0|, nothing should be typeset. Note
that if |b<0|, the value of |h| will decrease even though nothing else happens.

\yskip\hang|put1| 133 |c[1]|. Typeset character number~|c| from font~|f|
such that the reference point of the character is at |(h,v)|. (The `put'
commands are exactly like the `set' commands, except that they simply put out a
character or a rule without moving the reference point afterwards.)

\yskip\hang|put2| 134 |c[2]|. Same as |set2|, except that |h| is not changed.

\yskip\hang|put3| 135 |c[3]|. Same as |set3|, except that |h| is not changed.

\yskip\hang|put4| 136 |c[4]|. Same as |set4|, except that |h| is not changed.

\yskip\hang|put←rule| 137 |a[4]| |b[4]|. Same as |set←rule|, except that
|h| is not changed.

\yskip\hang|nop| 138. No operation, do nothing. Any number of |nop|'s
may occur between \.{DVI} commands, but a |nop| cannot be inserted between
a command and its parameters or between two parameters.

\yskip\hang|bop| 139 $c←0[4]$ $c←1[4]$ $\ldots$ $c←9[4]$ $p[4]$. Beginning
of a page: Set |(h,v,w,x,y,z):=(0,0,0,0,0,0)| and set the stack empty. Set
the current font |f| to an undefined value.  The ten $c←i$ parameters can
be used to identify pages, if a user wants to print only part of a \.{DVI}
file; \TeX82 gives them the values of \.{\\count0} $\ldots$ \.{\\count9}
at the time \.{\\shipout} was invoked for this page.  The parameter |p|
points to the previous |bop| command in the file, where the first |bop|
has $p=-1$.

\yskip\hang|eop| 140.  End of page: Print what you have read since the
previous |bop|. At this point the stack should be empty. (The \.{DVI}-reading
programs that drive most output devices will have kept a buffer of the
material that appears on the page that has just ended. This material is
largely, but not entirely, in order by |v| coordinate and (for fixed |v|) by
|h|~coordinate; so it usually needs to be sorted into some order that is
appropriate for the device in question. \.{GFtoDVI} does not do such sorting.)

\yskip\hang|push| 141. Push the current values of |(h,v,w,x,y,z)| onto the
top of the stack; do not change any of these values. Note that |f| is
not pushed.

\yskip\hang|pop| 142. Pop the top six values off of the stack and assign
them to |(h,v,w,x,y,z)|. The number of pops should never exceed the number
of pushes, since it would be highly embarrassing if the stack were empty
at the time of a |pop| command.

\yskip\hang|right1| 143 |b[1]|. Set |h:=h+b|, i.e., move right |b| units.
The parameter is a signed number in two's complement notation, |-128<=b<128|;
if |b<0|, the reference point actually moves left.

\yskip\hang|right2| 144 |b[2]|. Same as |right1|, except that |b| is a
two-byte quantity in the range |-32768<=b<32768|.

\yskip\hang|right3| 145 |b[3]|. Same as |right1|, except that |b| is a
three-byte quantity in the range |@t$-2↑{23}$@><=b<@t$2↑{23}$@>|.

\yskip\hang|right4| 146 |b[4]|. Same as |right1|, except that |b| is a
four-byte quantity in the range |@t$-2↑{31}$@><=b<@t$2↑{31}$@>|.

\yskip\hang|w0| 147. Set |h:=h+w|; i.e., move right |w| units. With luck,
this parameterless command will usually suffice, because the same kind of motion
will occur several times in succession; the following commands explain how
|w| gets particular values.

\yskip\hang|w1| 148 |b[1]|. Set |w:=b| and |h:=h+b|. The value of |b| is a
signed quantity in two's complement notation, |-128<=b<128|. This command
changes the current |w|~spacing and moves right by |b|.

\yskip\hang|w2| 149 |b[2]|. Same as |w1|, but |b| is a two-byte-long
parameter, |-32768<=b<32768|.

\yskip\hang|w3| 150 |b[3]|. Same as |w1|, but |b| is a three-byte-long
parameter, |@t$-2↑{23}$@><=b<@t$2↑{23}$@>|.

\yskip\hang|w4| 151 |b[4]|. Same as |w1|, but |b| is a four-byte-long
parameter, |@t$-2↑{31}$@><=b<@t$2↑{31}$@>|.

\yskip\hang|x0| 152. Set |h:=h+x|; i.e., move right |x| units. The `|x|'
commands are like the `|w|' commands except that they involve |x| instead
of |w|.

\yskip\hang|x1| 153 |b[1]|. Set |x:=b| and |h:=h+b|. The value of |b| is a
signed quantity in two's complement notation, |-128<=b<128|. This command
changes the current |x|~spacing and moves right by |b|.

\yskip\hang|x2| 154 |b[2]|. Same as |x1|, but |b| is a two-byte-long
parameter, |-32768<=b<32768|.

\yskip\hang|x3| 155 |b[3]|. Same as |x1|, but |b| is a three-byte-long
parameter, |@t$-2↑{23}$@><=b<@t$2↑{23}$@>|.

\yskip\hang|x4| 156 |b[4]|. Same as |x1|, but |b| is a four-byte-long
parameter, |@t$-2↑{31}$@><=b<@t$2↑{31}$@>|.

\yskip\hang|down1| 157 |a[1]|. Set |v:=v+a|, i.e., move down |a| units.
The parameter is a signed number in two's complement notation, |-128<=a<128|;
if |a<0|, the reference point actually moves up.

\yskip\hang|down2| 158 |a[2]|. Same as |down1|, except that |a| is a
two-byte quantity in the range |-32768<=a<32768|.

\yskip\hang|down3| 159 |a[3]|. Same as |down1|, except that |a| is a
three-byte quantity in the range |@t$-2↑{23}$@><=a<@t$2↑{23}$@>|.

\yskip\hang|down4| 160 |a[4]|. Same as |down1|, except that |a| is a
four-byte quantity in the range |@t$-2↑{31}$@><=a<@t$2↑{31}$@>|.

\yskip\hang|y0| 161. Set |v:=v+y|; i.e., move down |y| units. With luck,
this parameterless command will usually suffice, because the same kind of motion
will occur several times in succession; the following commands explain how
|y| gets particular values.

\yskip\hang|y1| 162 |a[1]|. Set |y:=a| and |v:=v+a|. The value of |a| is a
signed quantity in two's complement notation, |-128<=a<128|. This command
changes the current |y|~spacing and moves down by |a|.

\yskip\hang|y2| 163 |a[2]|. Same as |y1|, but |a| is a two-byte-long
parameter, |-32768<=a<32768|.

\yskip\hang|y3| 164 |a[3]|. Same as |y1|, but |a| is a three-byte-long
parameter, |@t$-2↑{23}$@><=a<@t$2↑{23}$@>|.

\yskip\hang|y4| 165 |a[4]|. Same as |y1|, but |a| is a four-byte-long
parameter, |@t$-2↑{31}$@><=a<@t$2↑{31}$@>|.

\yskip\hang|z0| 166. Set |v:=v+z|; i.e., move down |z| units. The `|z|' commands
are like the `|y|' commands except that they involve |z| instead of |y|.

\yskip\hang|z1| 167 |a[1]|. Set |z:=a| and |v:=v+a|. The value of |a| is a
signed quantity in two's complement notation, |-128<=a<128|. This command
changes the current |z|~spacing and moves down by |a|.

\yskip\hang|z2| 168 |a[2]|. Same as |z1|, but |a| is a two-byte-long
parameter, |-32768<=a<32768|.

\yskip\hang|z3| 169 |a[3]|. Same as |z1|, but |a| is a three-byte-long
parameter, |@t$-2↑{23}$@><=a<@t$2↑{23}$@>|.

\yskip\hang|z4| 170 |a[4]|. Same as |z1|, but |a| is a four-byte-long
parameter, |@t$-2↑{31}$@><=a<@t$2↑{31}$@>|.

\yskip\hang|fnt←num←0| 171. Set |f:=0|. Font 0 must previously have been
defined by a \\{fnt\←def} instruction, as explained below.

\yskip\hang|fnt←num←1| through |fnt←num←63| (opcodes 172 to 234). Set
|f:=1|, \dots, |f:=63|, respectively.

\yskip\hang|fnt1| 235 |k[1]|. Set |f:=k|. \TeX82 uses this command for font
numbers in the range |64<=k<256|.

\yskip\hang|fnt2| 236 |k[2]|. Same as |fnt1|, except that |k|~is two
bytes long, so it is in the range |0<=k<65536|. \TeX82 never generates this
command, but large font numbers may prove useful for specifications of
color or texture, or they may be used for special fonts that have fixed
numbers in some external coding scheme.

\yskip\hang|fnt3| 237 |k[3]|. Same as |fnt1|, except that |k|~is three
bytes long, so it can be as large as $2↑{24}-1$.

\yskip\hang|fnt4| 238 |k[4]|. Same as |fnt1|, except that |k|~is four
bytes long; this is for the really big font numbers (and for the negative ones).

\yskip\hang|xxx1| 239 |k[1]| |x[k]|. This command is undefined in
general; it functions as a $(k+2)$-byte |nop| unless special \.{DVI}-reading
programs are being used. \TeX82 generates |xxx1| when a short enough
\.{\\special} appears, setting |k| to the number of bytes being sent. It
is recommended that |x| be a string having the form of a keyword followed
by possible parameters relevant to that keyword.

\yskip\hang|xxx2| 240 |k[2]| |x[k]|. Like |xxx1|, but |0<=k<65536|.

\yskip\hang|xxx3| 241 |k[3]| |x[k]|. Like |xxx1|, but |0<=k<@t$2↑{24}$@>|.

\yskip\hang|xxx4| 242 |k[4]| |x[k]|. Like |xxx1|, but |k| can be ridiculously
large. \TeX82 uses |xxx4| when |xxx1| would be incorrect.

\yskip\hang|fnt←def1| 243 |k[1]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
Define font |k|, where |0<=k<256|; font definitions will be explained shortly.

\yskip\hang|fnt←def2| 244 |k[2]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
Define font |k|, where |0<=k<65536|.

\yskip\hang|fnt←def3| 245 |k[3]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
Define font |k|, where |0<=k<@t$2↑{24}$@>|.

\yskip\hang|fnt←def4| 246 |k[4]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
Define font |k|, where |@t$-2↑{31}$@><=k<@t$2↑{31}$@>|.

\yskip\hang|pre| 247 |i[1]| |num[4]| |den[4]| |mag[4]| |k[1]| |x[k]|.
Beginning of the preamble; this must come at the very beginning of the
file. Parameters |i|, |num|, |den|, |mag|, |k|, and |x| are explained below.

\yskip\hang|post| 248. Beginning of the postamble, see below.

\yskip\hang|post←post| 249. Ending of the postamble, see below.

\yskip\noindent Commands 250--255 are undefined at the present time.

@ Only a few of the operation codes above are actually needed by \.{GFtoDVI}.

@d set1=128 {typeset a character and move right}
@d put←rule=137 {typeset a rule}
@d bop=139 {beginning of page}
@d eop=140 {ending of page}
@d push=141 {save the current positions}
@d pop=142 {restore previous positions}
@d right4=146 {move right}
@d down4=160 {move down}
@d z0=166 {move down |z|}
@d z4=170 {move down and set |z|}
@d fnt←num←0=171 {set current font to 0}
@d fnt←def1=243 {define the meaning of a font number}
@d pre=247 {preamble}
@d post=248 {postamble beginning}
@d post←post=249 {postamble ending}

@ The preamble contains basic information about the file as a whole. As
stated above, there are six parameters:
$$\hbox{|@!i[1]| |@!num[4]| |@!den[4]| |@!mag[4]| |@!k[1]| |@!x[k]|.}$$
The |i| byte identifies \.{DVI} format; currently this byte is always set
to~2. (Some day we will set |i=3|, when \.{DVI} format makes another
incompatible change---perhaps in 1992.)

The next two parameters, |num| and |den|, are positive integers that define
the units of measurement; they are the numerator and denominator of a
fraction by which all dimensions in the \.{DVI} file could be multiplied
in order to get lengths in units of $10↑{-7}$ meters. (For example, there are
exactly 7227 \TeX\ points in 254 centimeters, and \TeX82 works with scaled
points where there are $2↑{16}$ sp in a point, so \TeX82 sets |num=25400000|
and $|den|=7227\cdot2↑{16}=473628672$.)
@↑sp@>

The |mag| parameter is what \TeX82 calls \.{\\mag}, i.e., 1000 times the
desired magnification. The actual fraction by which dimensions are
multiplied is therefore $mn/1000d$. Note that if a \TeX\ source document
does not call for any `\.{true}' dimensions, and if you change it only by
specifying a different \.{\\mag} setting, the \.{DVI} file that \TeX\
creates will be completely unchanged except for the value of |mag| in the
preamble and postamble. (Fancy \.{DVI}-reading programs allow users to
override the |mag|~setting when a \.{DVI} file is being printed.)

Finally, |k| and |x| allow the \.{DVI} writer to include a comment, which is not
interpreted further. The length of comment |x| is |k|, where |0<=k<256|.

@d dvi←id←byte=2 {identifies the kind of \.{DVI} files described here}

@ Font definitions for a given font number |k| contain further parameters
$$\hbox{|c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.}$$
The four-byte value |c| is the check sum that \TeX\ (or whatever program
generated the \.{DVI} file) found in the \.{TFM} file for this font;
|c| should match the check sum of the font found by programs that read
this \.{DVI} file.
@↑check sum@>

Parameter |s| contains a fixed-point scale factor that is applied to the
character widths in font |k|; font dimensions in \.{TFM} files and other
font files are relative to this quantity, which is always positive and
less than $2↑{27}$. It is given in the same units as the other dimensions
of the \.{DVI} file.  Parameter |d| is similar to |s|; it is the ``design
size,'' and it is given in \.{DVI} units that have not been corrected for
the magnification~|mag| found in the preamble.  Thus, font |k| is to be
used at $|mag|\cdot s/1000d$ times its normal size.

The remaining part of a font definition gives the external name of the font,
which is an ASCII string of length |a+l|. The number |a| is the length
of the ``area'' or directory, and |l| is the length of the font name itself;
the standard local system font area is supposed to be used when |a=0|.
The |n| field contains the area in its first |a| bytes.

Font definitions must appear before the first use of a particular font number.
Once font |k| is defined, it must not be defined again; however, we
shall see below that font definitions appear in the postamble as well as
in the pages, so in this sense each font number is defined exactly twice,
if at all. Like |nop| commands and \\{xxx} commands, font definitions can
appear before the first |bop|, or between an |eop| and a |bop|.

@ The last page in a \.{DVI} file is followed by `|post|'; this command
introduces the postamble, which summarizes important facts that \TeX\ has
accumulated about the file, making it possible to print subsets of the data
with reasonable efficiency. The postamble has the form
$$\vbox{\halign{\hbox{#\hfil}\cr
  |post| |p[4]| |num[4]| |den[4]| |mag[4]| |l[4]| |u[4]| |s[2]| |t[2]|\cr
  $\langle\,$font definitions$\,\rangle$\cr
  |post←post| |q[4]| |i[1]| 223's$[{\G}4]$\cr}}$$
Here |p| is a pointer to the final |bop| in the file. The next three
parameters, |num|, |den|, and |mag|, are duplicates of the quantities that
appeared in the preamble.

Parameters |l| and |u| give respectively the height-plus-depth of the tallest
page and the width of the widest page, in the same units as other dimensions
of the file. These numbers might be used by a \.{DVI}-reading program to
position individual ``pages'' on large sheets of film or paper; however,
the standard convention for output on normal size paper is to position each
page so that the upper left-hand corner is exactly one inch from the left
and the top. Experience has shown that it is unwise to design \.{DVI}-to-printer
software that attempts cleverly to center the output; a fixed position of
the upper left corner is easiest for users to understand and to work with.
Therefore |l| and~|u| are often ignored.

Parameter |s| is the maximum stack depth (i.e., the largest excess of
|push| commands over |pop| commands) needed to process this file. Then
comes |t|, the total number of pages (|bop| commands) present.

The postamble continues with font definitions, which are any number of
\\{fnt\←def} commands as described above, possibly interspersed with |nop|
commands. Each font number that is used in the \.{DVI} file must be defined
exactly twice: Once before it is first selected by a \\{fnt} command, and once
in the postamble.

@ The last part of the postamble, following the |post←post| byte that
signifies the end of the font definitions, contains |q|, a pointer to the
|post| command that started the postamble.  An identification byte, |i|,
comes next; this currently equals~2, as in the preamble.

The |i| byte is followed by four or more bytes that are all equal to
the decimal number 223 (i.e., @'337 in octal). \TeX\ puts out four to seven of
these trailing bytes, until the total length of the file is a multiple of
four bytes, since this works out best on machines that pack four bytes per
word; but any number of 223's is allowed, as long as there are at least four
of them. In effect, 223 is a sort of signature that is added at the very end.
@↑Fuchs, David Raymond@>

This curious way to finish off a \.{DVI} file makes it feasible for
\.{DVI}-reading programs to find the postamble first, on most computers,
even though \TeX\ wants to write the postamble last. Most operating
systems permit random access to individual words or bytes of a file, so
the \.{DVI} reader can start at the end and skip backwards over the 223's
until finding the identification byte. Then it can back up four bytes, read
|q|, and move to byte |q| of the file. This byte should, of course,
contain the value 248 (|post|); now the postamble can be read, so the
\.{DVI} reader discovers all the information needed for typesetting the
pages. Note that it is also possible to skip through the \.{DVI} file at
reasonably high speed to locate a particular page, if that proves
desirable. This saves a lot of time, since \.{DVI} files used in production
jobs tend to be large.

Unfortunately, however, standard \PASCAL\ does not include the ability to
@↑system dependencies@>
access a random position in a file, or even to determine the length of a file.
Almost all systems nowadays provide the necessary capabilities, so \.{DVI}
format has been designed to work most efficiently with modern operating systems.

@* Generic font file format.
The ``generic font'' (\.{GF}) input files that \.{GFtoDVI} must deal with
have a structure that was inspired by \.{DVI} format, although its
operation codes are quite different in most cases.  The term {\sl
generic\/} indicates that this file format doesn't match the conventions
of any name-brand manufacturer; but it is easy to convert \.{GF} files to
the special format required by almost all digital phototypesetting
equipment. There's a strong analogy between the \.{DVI} files written by
\TeX\ and the \.{GF} files written by \MF; and, in fact, the reader will
notice that many of the paragraphs below are identical to their
counterparts in the description of \.{DVI} already given. The following
description has been lifted almost verbatim from the program for \MF.

A \.{GF} file is a stream of 8-bit bytes that may be
regarded as a series of commands in a machine-like language. The first
byte of each command is the operation code, and this code is followed by
zero or more bytes that provide parameters to the command. The parameters
themselves may consist of several consecutive bytes; for example, the
`|boc|' (beginning of character) command has six parameters, each of
which is four bytes long. Parameters are usually regarded as nonnegative
integers; but four-byte-long parameters can be either positive or
negative, hence they range in value from $-2↑{31}$ to $2↑{31}-1$.
As in \.{DVI} files, numbers that occupy
more than one byte position appear in BigEndian order,
and negative numbers appear in two's complement notation.

A \.{GF} file consists of a ``preamble,'' followed by a sequence of one or
more ``characters,'' followed by a ``postamble.'' The preamble is simply a
|pre| command, with its parameters that introduce the file; this must come
first.  Each ``character'' consists of a |boc| command, followed by any
number of other commands that specify ``black'' pixels,
followed by an |eoc| command. The characters appear in the order that \MF\
generated them. If we ignore no-op commands (which are allowed between any
two commands in the file), each |eoc| command is immediately followed by a
|boc| command, or by a |post| command; in the latter case, there are no
more characters in the file, and the remaining bytes form the postamble.
Further details about the postamble will be explained later.

Some parameters in \.{GF} commands are ``pointers.'' These are four-byte
quantities that give the location number of some other byte in the file;
the first file byte is number~0, then comes number~1, and so on.

@ The \.{GF} format is intended to be both compact and easily interpreted
by a machine. Compactness is achieved by making most of the information
relative instead of absolute. When a \.{GF}-reading program reads the
commands for a character, it keeps track of two quantities: (a)~the current
column number,~|m|; and (b)~the current row number,~|n|.  These are 32-bit
signed integers, although most actual font formats produced from \.{GF}
files will need to curtail this vast range because of practical
limitations. (\MF\ output will never allow $\vert m\vert$ or $\vert
n\vert$ to get extremely large, but the \.{GF} format tries to be more general.)

How do \.{GF}'s row and column numbers correspond to the conventions
of \TeX\ and \MF? Well, the ``reference point'' of a character, in \TeX's
view, is considered to be at the lower left corner of the pixel in row~0
and column~0. This point is the intersection of the baseline with the left
edge of the type; it corresponds to location $(0,0)$ in \MF\ programs.
Thus the pixel in \.{GF} row~0 and column~0 is \MF's unit square, comprising the
region of the plane whose coordinates both lie between 0 and~1. The
pixel in \.{GF} row~|n| and column~|m| consists of the points whose \MF\
coordinates |(x,y)| satisfy |m<=x<=m+1| and |n<=y<=n+1|.  Negative values of
|m| and~|x| correspond to columns of pixels {\sl left\/} of the reference
point; negative values of |n| and~|y| correspond to rows of pixels {\sl
below\/} the baseline.

Besides |m| and |n|, there's also a third aspect of the current
state, namely the @!|paint←switch|, which is always either \\{black} or
\\{white}. Each \\{paint} command advances |m| by a specified amount~|d|,
and blackens the intervening pixels if |paint←switch=black|; then
the |paint←switch| changes to the opposite state. \.{GF}'s commands are
designed so that |m| will never decrease within a row, and |n| will never
increase within a character; hence there is no way to whiten a pixel that
has been blackened.

@ Here is a list of all the commands that may appear in a \.{GF} file. Each
command is specified by its symbolic name (e.g., |boc|), its opcode byte
(e.g., 67), and its parameters (if any). The parameters are followed
by a bracketed number telling how many bytes they occupy; for example,
`|d[2]|' means that parameter |d| is two bytes long.

\yskip\hang|paint←0| 0. This is a \\{paint} command with |d=0|; it does
nothing but change the |paint←switch| from \\{black} to \\{white} or vice~versa.

\yskip\hang\\{paint\←1} through \\{paint\←63} (opcodes 1 to 63).
These are \\{paint} commands with |d=1| to~63, defined as follows: If
|paint←switch=black|, blacken |d|~pixels of the current row~|n|,
in columns |m| through |m+d-1| inclusive. Then, in any case,
complement the |paint←switch| and advance |m| by~|d|.

\yskip\hang|paint1| 64 |d[1]|. This is a \\{paint} command with a specified
value of~|d|; \MF\ uses it to paint when |64<=d<256|.

\yskip\hang|paint2| 65 |d[2]|. Same as |paint1|, but |d|~can be as high
as~65535.

\yskip\hang|paint3| 66 |d[3]|. Same as |paint1|, but |d|~can be as high
as $2↑{24}-1$. \MF\ never needs this command, and it is hard to imagine
anybody making practical use of it; surely a more compact encoding will be
desirable when characters can be this large. But the command is there,
anyway, just in case.

\yskip\hang|boc| 67 |c[4]| |p[4]| |min←m[4]| |max←m[4]| |min←n[4]|
|max←n[4]|. Beginning of a character:  Here |c| is the character code, and
|p| points to the previous character beginning (if any) for characters having
this code number modulo 256.  (The pointer |p| is |-1| if there was no
prior character with an equivalent code.) The values of registers |m| and |n|
defined by the instructions that follow for this character must
satisfy |min←m<=m<=max←m| and |min←n<=n<=max←n|.  (The values of |max←m| and
|min←n| need not be the tightest bounds possible.)  When a \.{GF}-reading
program sees a |boc|, it can use |min←m|, |max←m|, |min←n|, and |max←n| to
initialize the bounds of an array. Then it sets |m:=min←m|, |n:=max←n|, and
|paint←switch:=white|.

\yskip\hang|boc1| 68 |c[1]| |@!del←m[1]| |max←m[1]| |@!del←n[1]| |max←n[1]|.
Same as |boc|, but |p| is assumed to be~$-1$; also |del←m=max←m-min←m|
and |del←n=max←n-min←n| are given instead of |min←m| and |min←n|.
The one-byte parameters must be between 0 and 255, inclusive.
\ (This abbreviated |boc| saves 19~bytes per character, in common cases.)

\yskip\hang|eoc| 69. End of character: All pixels blackened so far
constitute the pattern for this character. In particular, a completely
blank character might have |eoc| immediately following |boc|.

\yskip\hang|skip0| 70. Decrease |n| by 1 and set |m:=min←m|,
|paint←switch:=white|. \ (This finishes one row and begins another,
ready to whiten the leftmost pixel in the new row.)

\yskip\hang|skip1| 71 |d[1]|. Decrease |n| by |d+1|, set |m:=min←m|, and set
|paint←switch:=white|. This is a way to produce |d| all-white rows.

\yskip\hang|skip2| 72 |d[2]|. Same as |skip1|, but |d| can be as large
as 65535.

\yskip\hang|skip3| 73 |d[3]|. Same as |skip1|, but |d| can be as large
as $2↑{24}-1$. \MF\ obviously never needs this command.

\yskip\hang|new←row←0| 74. Decrease |n| by 1 and set |m:=min←m|,
|paint←switch:=black|. \ (This finishes one row and begins another,
ready to {\sl blacken\/} the leftmost pixel in the new row.)

\yskip\hang|@!new←row←1| through |@!new←row←164| (opcodes 75 to 238). Same as
|new←row←0|, but with |m:=min←m+1| through |min←m+164|, respectively.

\yskip\hang|xxx1| 239 |k[1]| |x[k]|. This command is undefined in
general; it functions as a $(k+2)$-byte |no←op| unless special \.{GF}-reading
programs are being used. \MF\ generates \\{xxx} commands when encountering
a \&{special} string; this occurs in the \.{GF} file only between
characters, after the preamble, and before the postamble. However,
\\{xxx} commands might appear anywhere in \.{GF} files generated by other
processors. It is recommended that |x| be a string having the form of a
keyword followed by possible parameters relevant to that keyword.

\yskip\hang|xxx2| 240 |k[2]| |x[k]|. Like |xxx1|, but |0<=k<65536|.

\yskip\hang|xxx3| 241 |k[3]| |x[k]|. Like |xxx1|, but |0<=k<@t$2↑{24}$@>|.
\MF\ uses this when sending a \&{special} string whose length exceeds~255.

\yskip\hang|xxx4| 242 |k[4]| |x[k]|. Like |xxx1|, but |k| can be
ridiculously large; |k| mustn't be negative.

\yskip\hang|yyy| 243 |y[4]|. This command is undefined in general;
it functions as a 5-byte |no←op| unless special \.{GF}-reading programs
are being used. \MF\ puts |scaled| numbers into |yyy|'s, as a
result of \&{numspecial} commands; the intent is to provide numeric
parameters to \\{xxx} commands that immediately precede.

\yskip\hang|no←op| 244. No operation, do nothing. Any number of |no←op|'s
may occur between \.{GF} commands, but a |no←op| cannot be inserted between
a command and its parameters or between two parameters.

\yskip\hang|char←loc| 245 |c[1]| |dx[4]| |dy[4]| |w[4]| |p[4]|.
This command will appear only in the postamble, which will be explained shortly.

\yskip\hang|@!char←loc0| 246 |c[1]| |@!dm[1]| |w[4]| |p[4]|.
Same as |char←loc|, except that |dy| is assumed to be zero, and the value
of~|dx| is taken to be |65536*dm|, where |0<=dm<256|.

\yskip\hang|pre| 247 |i[1]| |k[1]| |x[k]|.
Beginning of the preamble; this must come at the very beginning of the
file. Parameter |i| is an identifying number for \.{GF} format, currently
131. The other information is merely commentary; it is not given
special interpretation like \\{xxx} commands are. (Note that \\{xxx}
commands may immediately follow the preamble, before the first |boc|.)

\yskip\hang|post| 248. Beginning of the postamble, see below.

\yskip\hang|post←post| 249. Ending of the postamble, see below.

\yskip\noindent Commands 250--255 are undefined at the present time.

@d gf←id←byte=131 {identifies the kind of \.{GF} files described here}

@ Here are the opcodes that \.{GFtoDVI} actually refers to.

@d paint←0=0 {beginning of the \\{paint} commands}
@d paint1=64 {move right a given number of columns, then
  black${}\swap{}$white}
@d paint2=65 {ditto, with potentially larger number of columns}
@d paint3=66 {ditto, with potentially excessive number of columns}
@d boc=67 {beginning of a character}
@d boc1=68 {abbreviated |boc|}
@d eoc=69 {end of a character}
@d skip0=70 {skip no blank rows}
@d skip1=71 {skip over blank rows}
@d skip2=72 {skip over lots of blank rows}
@d skip3=73 {skip over a huge number of blank rows}
@d new←row←0=74 {move down one row and then right}
@d xxx1=239 {for \&{special} strings}
@d xxx2=240 {for somewhat long \&{special} strings}
@d xxx3=241 {for extremely long \&{special} strings}
@d xxx4=242 {for incredibly long \&{special} strings}
@d yyy=243 {for \&{numspecial} numbers}
@d no←op=244 {no operation}

@ The last character in a \.{GF} file is followed by `|post|'; this command
introduces the postamble, which summarizes important facts that \MF\ has
accumulated. The postamble has the form
$$\vbox{\halign{\hbox{#\hfil}\cr
  |post| |p[4]| |@!ds[4]| |@!cs[4]| |@!hppp[4]| |@!vppp[4]|
   |@!min←m[4]| |@!max←m[4]| |@!min←n[4]| |@!max←n[4]|\cr
  $\langle\,$character locators$\,\rangle$\cr
  |post←post| |q[4]| |i[1]| 223's$[{\G}4]$\cr}}$$
Here |p| is a pointer to the byte following the final |eoc| in the file
(or to the byte following the preamble, if there are no characters);
it can be used to locate the beginning of \\{xxx} commands
that might have preceded the postamble. The |ds| and |cs| parameters
@↑design size@> @↑check sum@>
give the design size and check sum, respectively, of the font (see the
description of \.{TFM} format below).
Parameters |hppp| and |vppp| are the ratios of
pixels per point, horizontally and vertically, expressed as |scaled| integers
(i.e., multiplied by $2↑{16}$); they can be used to correlate the font
with specific device resolutions, magnifications, and ``at sizes.''  Then
come |min←m|, |max←m|, |min←n|, and |max←n|, which bound the values that
registers |m| and~|n| assume in all characters in this \.{GF} file.
(These bounds need not be the best possible; |max←m| and |min←n| may, on the
other hand, be tighter than the similar bounds in |boc| commands. For
example, some character may have |min←n=-100| in its |boc|, but it might
turn out that |n| never gets lower than |-50| in any character; then
|min←n| can have any value |<=-50|. If there are no characters in the file,
it's possible to have |min←m>max←m| and/or |min←n>max←n|.)

@ Character locators are introduced by |char←loc| commands,
which specify a character residue~|c|, character escapements (|dx,dy|),
a character width~|w|, and a pointer~|p|
to the beginning of that character. (If two or more characters have the
same code~|c| modulo 256, only the last will be indicated; the others can be
located by following backpointers. Characters whose codes differ by a
multiple of 256 are assumed to share the same font metric information,
hence the \.{TFM} file contains only residues of character codes modulo~256.
This convention is intended for oriental languages, when there are many
character shapes but few distinct widths.)
@↑oriental characters@>@↑Chinese characters@>@↑Japanese characters@>

The character escapements (|dx,dy|) are the values of \MF's \&{chardx}
and \&{chardy} parameters; they are in units of |scaled| pixels;
i.e., |dx| is in horizontal pixel units times $2↑{16}$, and |dy| is in
vertical pixel units times $2↑{16}$.  This is the intended amount of
displacement after typesetting the character; for \.{DVI} files, |dy|
should be zero, but other document file formats allow nonzero vertical
escapement.

The character width~|w| duplicates the information in the \.{TFM} file; it
is $2↑{24}$ times the ratio of the true width to the font's design size.

The backpointer |p| points to the character's |boc|, or to the first of
a sequence of consecutive \\{xxx} or |yyy| or |no←op| commands that
immediately precede the |boc|, if such commands exist; such ``special''
commands essentially belong to the characters, while the special commands
after the final character belong to the postamble (i.e., to the font
as a whole). This convention about |p| applies also to the backpointers
in |boc| commands, even though it wasn't explained in the description
of~|boc|. @↑backpointers@>

Pointer |p| might be |-1| if the character exists in the \.{TFM} file
but not in the \.{GF} file. This unusual situation can arise in \MF\ output
if the user had |proofing<0| when the character was being shipped out,
but then made |proofing>=0| in order to get a \.{GF} file.

@ The last part of the postamble, following the |post←post| byte that
signifies the end of the character locators, contains |q|, a pointer to the
|post| command that started the postamble.  An identification byte, |i|,
comes next; this currently equals~131, as in the preamble.

The |i| byte is followed by four or more bytes that are all equal to
the decimal number 223 (i.e., @'337 in octal). \MF\ puts out four to seven of
these trailing bytes, until the total length of the file is a multiple of
four bytes, since this works out best on machines that pack four bytes per
word; but any number of 223's is allowed, as long as there are at least four
of them. In effect, 223 is a sort of signature that is added at the very end.
@↑Fuchs, David Raymond@>

This curious way to finish off a \.{GF} file makes it feasible for
\.{GF}-reading programs to find the postamble first, on most computers,
even though \MF\ wants to write the postamble last. Most operating
systems permit random access to individual words or bytes of a file, so
the \.{GF} reader can start at the end and skip backwards over the 223's
until finding the identification byte. Then it can back up four bytes, read
|q|, and move to byte |q| of the file. This byte should, of course,
contain the value 248 (|post|); now the postamble can be read, so the
\.{GF} reader can discover all the information needed for individual characters.

Unfortunately, however, standard \PASCAL\ does not include the ability to
@↑system dependencies@>
access a random position in a file, or even to determine the length of a file.
Almost all systems nowadays provide the necessary capabilities, so \.{GF}
format has been designed to work most efficiently with modern operating systems.
But if \.{GF} files have to be processed under the restrictions of standard
\PASCAL, one can simply read them from front to back. This will
be adequate for most applications. However, the postamble-first approach
would facilitate a program that merges two \.{GF} files, replacing data
from one that is overridden by corresponding data in the other.

@* Extensions to the generic format.
The \\{xxx} and \\{yyy} instructions understood by \.{GFtoDVI} will be
listed now, so that we have a convenient reference to all of the special
assumptions made later.

Each special instruction begins with an \\{xxx} command, which consists of
either a keyword by itself, or a keyword followed by a space followed
by arguments. This \\{xxx} command may then be followed by \\{yyy}
commands that are understood to be arguments.

The keywords of special instructions that are intended to be used at
many different sites should be published as widely as possible in order
to minimize conflicts. The first person to establish a keyword presumably
has a right to define it; \.{GFtoDVI}, as the first program
to use extended \.{GF} commands, has the opportunity of choosing any
keywords it likes, and the responsibility of choosing reasonable ones.
Since labels are expected to account for the bulk of extended commands
in typical uses of \MF, the ``null'' keyword has been set aside to
denote a labeling command.

@ Here then are the special commands of \.{GFtoDVI}.

\def\string{$\langle\,$string$\,\rangle$}
\def\okpagebreak{\vfil\penalty-100\vfilneg}
\smallskip\hang\noindent
\.{\SP n}\string\ $x$ $y$. Here \.n denotes the type of label; the
characters \.1, \.2, \.3,~\.4 respectively denote labels forced to be
at the top, left, right, or bottom of their dot, and the characters
\.5, \.6, \.7,~\.8 stand for the same possibilities but with no dot printed.
The character \.0 causes \.{GFtoDVI} to choose one the first four possibilities,
if there's no overlap with other labels or dots, otherwise an ``overflow''
entry is placed at the right of the figure. The character \./ is the same
as \.0 except that overflow entries are not produced. The
label itself is the \string\ that follows. \MF\ coordinates of the
point that is to receive this label are given by arguments $x$ and~$y$,
in units of scaled pixels. (These arguments appear in \\{yyy} commands.)
(Precise definitions of the size and positioning of labels, and of the
notion of ``conflicting'' labels, will be given later.)

\smallskip\hang\noindent
\.{rule} $x←1$ $y←1$ $x←2$ $y←2$. This command draws a line from
$(x←1,y←1)$ to $(x←2,y←2)$ in \MF\ coordinates. The present implementation
does this only if the line is either horizontal or vertical, or if its
slope matches the slope of the slant font.

\smallskip\hang\noindent
\.{title\SP}\string. This command (which is output by \MF\
when it sees a ``title statement'') specifies a string that will appear
at the top of the next proofsheet to be output by \.{GFtoDVI}.
If more than one title is given, they will appear in sequence; they
should be short enough to fit on a single line.

\smallskip\hang\noindent
\.{titlefont\SP}\string. This command, and the other font-naming
commands below, must precede the first |boc| in the \.{GF} file.
It overrides the current font used to
typeset the titles at the top of proofsheets. \.{GFtoDVI} has default
fonts that will be used if none other are specified; the ``current'' title
font is initially the default title font.

\smallskip\hang\noindent
\.{titlefontarea\SP}\string. This command overrides the current
file area (or directory name) from which \.{GFtoDVI} will try to
find metric information for the title font.

\smallskip\hang\noindent
\.{titlefontat} $s$. This command overrides the current ``at size'' that
will be used for the title font. (See the discussion of font metric files
below, for the meaning of ``at size'' versus ``design size.'') The
value of~$s$ is given in units of scaled points.

\okpagebreak
\smallskip\hang\noindent
\.{labelfont\SP}\string. This command overrides the current font
used to typeset the labels that are superimposed on proof figures.
(The label font is fairly arbitrary, but it should be dark enough to
stand out when superimposed on gray pixels, and it should contain at
least the decimal digits and the characters `\.(', `\.)', `\.=', `\.+',
`\.-', `\.,', and `\..'.)

\smallskip\hang\noindent
\.{labelfontarea\SP}\string. This command overrides the current
file area (or directory name) from which \.{GFtoDVI} will try to
find metric information for the label font.

\smallskip\hang\noindent
\.{labelfontat} $s$. This command overrides the current ``at size'' that
will be used for the label font.

\okpagebreak
\smallskip\hang\noindent
\.{grayfont\SP}\string. This command overrides the current font
used to typeset the black pixels and the dots for labels. (Gray fonts
will be explained in detail later.)
@↑gray fonts@>

\smallskip\hang\noindent
\.{grayfontarea\SP}\string. This command overrides the current
file area (or directory name) from which \.{GFtoDVI} will try to
find metric information for the gray font.

\smallskip\hang\noindent
\.{grayfontat} $s$. This command overrides the current ``at size'' that
will be used for the gray font.

\okpagebreak
\smallskip\hang\noindent
\.{slantfont\SP}\string. This command overrides the current font
used to typeset rules that are neither horizontal nor vertical. (Slant
fonts will be explained in detail later.)
@↑slant fonts@>

\smallskip\hang\noindent
\.{slantfontarea\SP}\string. This command overrides the current
file area (or directory name) from which \.{GFtoDVI} will try to
find metric information for the slant font.

\smallskip\hang\noindent
\.{slantfontat} $s$. This command overrides the current ``at size'' that
will be used for the slant font.

\okpagebreak
\smallskip\hang\noindent
\.{rulethickness} $t$. This command overrides the current value used
for the thickness of rules. If the current value is negative, no rule
will be drawn; if the current value is zero, the rule thickness will
be specified by a parameter of the gray font. Each \.{rule} command
uses the rule thickness that is current at the time the command appears;
hence it is possible to get different thicknesses of rules on the same
figure. The value of $t$ is given in units of scaled points (\TeX's `\.{sp}').
At the beginning of each character the current rule thickness is zero.

\smallskip\hang\noindent
\.{offset} $x$ $y$. This command overrides the current offset values
that are added to all coordinates of a character being output; $x$ and
$y$ are given as scaled \MF\ coordinates. This simply has the effect
of repositioning the figures on the pages; the title line always appears
in the same place, but the figure can be moved up, down, left, or right.
At the beginning of each character the current offsets are zero.

\smallskip\hang\noindent
\.{xoffset} $x$. This command is output by \MF\ just before shipping out
a character whose $x$~offset is nonzero. \.{GFtoDVI} adds the specified
amount to the $x$ coordinates of all labels in the following character.

\smallskip\hang\noindent
\.{yoffset} $y$. This command is output by \MF\ just before shipping out
a character whose $y$~offset is nonzero. \.{GFtoDVI} adds the specified
amount to the $y$ coordinates of all labels in the following character.

@* Font metric data.
Before we can get into the meaty details of \.{GFtoDVI}, we need to
deal with yet another esoteric binary file format, since \.{GFtoDVI}
also does elementary typesetting operations. Therefore it has to
read important information about the fonts it will be using.
The following material (again copied almost verbatim from \TeX)
describes the contents of so-called \TeX\ font metric (\.{TFM}) files.

The idea behind \.{TFM} files is that typesetting routines
need a compact way to store the relevant information about
fonts, and computer centers need a compact way to store the
relevant information about several hundred fonts. \.{TFM} files are
compact, and most of the information they contain is highly relevant,
so they provide a solution to the problem. \.{GFtoDVI} uses only
three fonts, but interesting changes in its output will occur when
those fonts are varied.

The information in a \.{TFM} file appears in a sequence of 8-bit bytes.
Since the number of bytes is always a multiple of 4, we could
also regard the file as a sequence of 32-bit words; but \TeX\ uses the
byte interpretation, and so does \.{GFtoDVI}. The individual bytes
are considered to be unsigned numbers.

@ The first 24 bytes (6 words) of a \.{TFM} file contain twelve 16-bit
integers that give the lengths of the various subsequent portions
of the file. These twelve integers are, in order:
$$\vbox{\halign{\hfil#&$\null=\null$#\hfil\cr
|@!lf|&length of the entire file, in words;\cr
|@!lh|&length of the header data, in words;\cr
|@!bc|&smallest character code in the font;\cr
|@!ec|&largest character code in the font;\cr
|@!nw|&number of words in the width table;\cr
|@!nh|&number of words in the height table;\cr
|@!nd|&number of words in the depth table;\cr
|@!ni|&number of words in the italic correction table;\cr
|@!nl|&number of words in the lig/kern table;\cr
|@!nk|&number of words in the kern table;\cr
|@!ne|&number of words in the extensible character table;\cr
|@!np|&number of font parameter words.\cr}}$$
They are all nonnegative and less than $2↑{15}$. We must have |bc-1<=ec<=255|,
|ne<=256|, and
$$\hbox{|lf=6+lh+(ec-bc+1)+nw+nh+nd+ni+nl+nk+ne+np|.}$$
Note that a font may contain as many as 256 characters (if |bc=0| and |ec=255|),
and as few as 0 characters (if |bc=ec+1|). When two or more 8-bit bytes are
combined to form an integer of 16 or more bits, the bytes appear in
BigEndian order.
@↑BigEndian order@>

@<Glob...@>=
@!lf,@!lh,@!bc,@!ec,@!nw,@!nh,@!nd,@!ni,@!nl,@!nk,@!ne,@!np:0..@'77777;
  {subfile sizes}

@ The rest of the \.{TFM} file may be regarded as a sequence of ten data
arrays having the informal specification
$$\def\arr$[#1]#2${\&{array} $[#1]$ \&{of} #2}
\vbox{\halign{\hfil\\{#}&$\,:\,$\arr#\hfil\cr
header&|[0..lh-1]stuff|\cr
char\←info&|[bc..ec]char←info←word|\cr
width&|[0..nw-1]fix←word|\cr
height&|[0..nh-1]fix←word|\cr
depth&|[0..nd-1]fix←word|\cr
italic&|[0..ni-1]fix←word|\cr
lig\←kern&|[0..nl-1]lig←kern←command|\cr
kern&|[0..nk-1]fix←word|\cr
exten&|[0..ne-1]extensible←recipe|\cr
param&|[1..np]fix←word|\cr}}$$
The most important data type used here is a |@!fix←word|, which is
a 32-bit representation of a binary fraction. A |fix←word| is a signed
quantity, with the two's complement of the entire word used to represent
negation. Of the 32 bits in a |fix←word|, exactly 12 are to the left of the
binary point; thus, the largest |fix←word| value is $2048-2↑{-20}$, and
the smallest is $-2048$. We will see below, however, that all but one of
the |fix←word| values will lie between $-16$ and $+16$.

@ The first data array is a block of header information, which contains
general facts about the font. The header must contain at least two words,
and for \.{TFM} files to be used with Xerox printing software it must
contain at least 18 words, allocated as described below. When different
kinds of devices need to be interfaced, it may be necessary to add further
words to the header block.

\yskip\hang|header[0]| is a 32-bit check sum that \.{GFtoDVI} will copy into the
\.{DVI} output file whenever it uses the font.  Later on when the \.{DVI}
file is printed, possibly on another computer, the actual font that gets
used is supposed to have a check sum that agrees with the one in the
\.{TFM} file used by \.{GFtoDVI}. In this way, users will be warned about
potential incompatibilities. (However, if the check sum is zero in either
the font file or the \.{TFM} file, no check is made.)  The actual relation
between this check sum and the rest of the \.{TFM} file is not important;
the check sum is simply an identification number with the property that
incompatible fonts almost always have distinct check sums.
@↑check sum@>

\yskip\hang|header[1]| is a |fix←word| containing the design size of the
font, in units of \TeX\ points (7227 \TeX\ points = 254 cm).  This number
must be at least 1.0; it is fairly arbitrary, but usually the design size
is 10.0 for a ``10 point'' font, i.e., a font that was designed to look
best at a 10-point size, whatever that really means. When a \TeX\ user
asks for a font `\.{at} $\delta$ \.{pt}', the effect is to override the
design size and replace it by $\delta$, and to multiply the $x$ and~$y$
coordinates of the points in the font image by a factor of $\delta$
divided by the design size.  Similarly, specific sizes can be substituted
for the design size by \.{GFtoDVI} commands like `\.{titlefontat}'.  {\sl
All other dimensions in the\/\ \.{TFM} file are |fix←word| numbers in
design-size units.} Thus, for example, the value of |param[6]|, one \.{em}
or \.{\\quad}, is often the |fix←word| value $2↑{20}=1.0$, since many
fonts have a design size equal to one em.  The other dimensions must be
less than 16 design-size units in absolute value; thus, |header[1]| and
|param[1]| are the only |fix←word| entries in the whole \.{TFM} file whose
first byte might be something besides 0 or 255.  @↑design size@>@↑at size@>

\yskip\hang|header[2..11]|, if present, contains 40 bytes that identify
the character coding scheme. The first byte, which must be between 0 and
39, is the number of subsequent ASCII bytes actually relevant in this
string, which is intended to specify what character-code-to-symbol
convention is present in the font.  Examples are \.{ASCII} for standard
ASCII, \.{TEX TEXT} for fonts like \.{cmr} and \.{cmti}, \.{TEX MATHEX}
for \.{cmex}, \.{XEROX TEXT} for Xerox fonts, \.{GFGRAY} for \.{GFtoDVI}'s
gray fonts, \.{GFSLANT} for \.{GFtoDVI}'s slant fonts, \.{UNSPECIFIED} for
the default case when there is no information.  Parentheses should not
appear in this name.  (Such a string is said to be in {\mc BCPL} format.)
Oriental fonts, for which many different individual symbols might share
the same metric information, should be identifiable via this part of the
\.{TFM} header.  @↑coding scheme@>@↑gray fonts@>@↑slant fonts@>

\yskip\hang|header[12..@twhatever@>]| might also be present.

@ Next comes the |char←info| array, which contains one |char←info←word|
per character. Each |char←info←word| contains six fields packed into
four bytes as follows.

\yskip\hang first byte: |width←index| (8 bits)\par
\hang second byte: |height←index| (4 bits) times 16, plus |depth←index|
  (4~bits)\par
\hang third byte: |italic←index| (6 bits) times 4, plus |tag|
  (2~bits)\par
\hang fourth byte: |remainder| (8 bits)\par
\yskip\noindent
The actual width of a character is |width[width←index]|, in design-size
units; this is a device for compressing information, since many characters
have the same width. Since it is quite common for many characters
to have the same height, depth, or italic correction, the \.{TFM} format
imposes a limit of 16 different heights, 16 different depths, and
64 different italic corrections.

Incidentally, the relation |width[0]=height[0]=depth[0]=italic[0]=0|
should always hold, so that an index of zero implies a value of zero.
The |width←index| should never be zero unless the character does
not exist in the font, since a character is valid if and only if it lies
between |bc| and |ec| and has a nonzero |width←index|.

@ The |tag| field in a |char←info←word| has four values that explain how to
interpret the |remainder| field.

\yskip\hang|tag=0| (|no←tag|) means that |remainder| is unused.\par
\hang|tag=1| (|lig←tag|) means that this character has a ligature/kerning
program starting at |lig←kern[remainder]|.\par
\hang|tag=2| (|list←tag|) means that this character is part of a chain of
characters of ascending sizes, and not the largest in the chain.  The
|remainder| field gives the character code of the next larger character.\par
\hang|tag=3| (|ext←tag|) means that this character code represents an
extensible character, i.e., a character that is built up of smaller pieces
so that it can be made arbitrarily large. The pieces are specified in
|exten[remainder]|.\par

@d no←tag=0 {vanilla character}
@d lig←tag=1 {character has a ligature/kerning program}
@d list←tag=2 {character has a successor in a charlist}
@d ext←tag=3 {character is extensible}

@ The |lig←kern| array contains instructions in a simple programming language
that explains what to do for special letter pairs. Each word is a
|lig←kern←command| of four bytes.

\yskip\hang first byte: |stop←bit|, indicates that this is the final program
  step if the byte is 128 or more.\par
\hang second byte: |next←char|, ``if |next←char| follows the current character,
  then perform the operation and stop, otherwise continue.''\par
\hang third byte: |op←bit|, indicates a ligature step if less than~128,
  a kern step otherwise.\par
\hang fourth byte: |remainder|.\par
\yskip\noindent
In a ligature step the current character and |next←char| are replaced by
the single character whose code is |remainder|. In a kern step, an
additional space equal to |kern[remainder]| is inserted between the
current character and |next←char|. (The value of |kern[remainder]| is
often negative, so that the characters are brought closer together
by kerning; but it might be positive.)

@d stop←flag=128 {value indicating `\.{STOP}' in a lig/kern program}
@d kern←flag=128 {op code for a kern step}

@ Extensible characters are specified by an |extensible←recipe|,
which consists of four bytes called |top|, |mid|,
|bot|, and |rep| (in this order). These bytes are the character codes
of individual pieces used to build up a large symbol.
If |top|, |mid|, or |bot| are zero,
they are not present in the built-up result. For example, an extensible
vertical line is like an extensible bracket, except that the top and
bottom pieces are missing.


@ The final portion of a \.{TFM} file is the |param| array, which is another
sequence of |fix←word| values.

\yskip\hang|param[1]=@!slant| is the amount of italic slant.
For example, |slant=.25| means that when you go
up one unit, you also go .25 units to the right. The |slant| is a pure
number; it's the only |fix←word| other than the design size itself that is
not scaled by the design size.

\hang|param[2]=space| is the normal spacing between words in text.
Note that character |" "| in the font need not have anything to do with
blank spaces.

\hang|param[3]=space←stretch| is the amount of glue stretching between words.

\hang|param[4]=space←shrink| is the amount of glue shrinking between words.

\hang|param[5]=x←height| is the height of letters for which accents don't
have to be raised or lowered.

\hang|param[6]=quad| is the size of one em in the font.

\hang|param[7]=extra←space| is the amount added to |param[2]| at the
ends of sentences.

When the character coding scheme is \.{GFGRAY} or \.{GFSLANT}, the font is
supposed to contain an additional parameter called
|default←rule←thickness|. Other special parameters go with other coding
schemes.

@* Input from binary files.
We have seen that \.{GF} and \.{DVI} and \.{TFM} files are sequences of
8-bit bytes.  The bytes appear physically in what is called a `|packed
file of 0..255|' in \PASCAL\ lingo.

Packing is system dependent, and many \PASCAL\ systems fail to implement
such files in a sensible way (at least, from the viewpoint of producing
good production software).  For example, some systems treat all
byte-oriented files as text, looking for end-of-line marks and such
things. Therefore some system-dependent code is often needed to deal with
binary files, even though most of the program in this section of
\.{GFtoDVI} is written in standard \PASCAL.
@↑system dependencies@>

One common way to solve the problem is to consider files of |integer|
numbers, and to convert an integer in the range $-2↑{31}\L x<2↑{31}$ to
a sequence of four bytes $(a,b,c,d)$ using the following code, which
avoids the controversial integer division of negative numbers:
$$\vbox{\halign{#\hfil\cr
|if x>=0 then a:=x div @'100000000|\cr
|else begin x:=(x+@'10000000000)+@'10000000000; a:=x div @'100000000+128;|\cr
\quad|end|\cr
|x:=x mod @'100000000;|\cr
|b:=x div @'200000; x:=x mod @'200000;|\cr
|c:=x div @'400; d:=x mod @'400;|\cr}}$$
The four bytes are then kept in a buffer and output one by one. (On 36-bit
computers, an additional division by 16 is necessary at the beginning.
Another way to separate an integer into four bytes is to use/abuse
\PASCAL's variant records, storing an integer and retrieving bytes that are
packed in the same place; {\sl caveat implementor!\/}) It is also desirable
in some cases to read a hundred or so integers at a time, maintaining a
larger buffer.

We shall stick to simple \PASCAL\ in this program, for reasons of clarity,
even if such simplicity is sometimes unrealistic.

@<Types ...@>=
@!eight←bits=0..255; {unsigned one-byte quantity}
@!byte←file=packed file of eight←bits; {files that contain binary data}

@ The program deals with three binary file variables: |gf←file| is the main
input file that we are converting into a document; |dvi←file| is the main
output file that will specify that document; and |tfm←file| is
the current font metric file from which character-width information is
being read.

@<Glob...@>=
@!gf←file:byte←file; {the character data we are reading}
@!dvi←file:byte←file; {the typesetting instructions we are writing}
@!tfm←file:byte←file; {a font metric file}

@ To prepare these files for input or output, we |reset| or |rewrite|
them. An extension of \PASCAL\ is needed, since we want to associate
it with external files whose names are specified dynamically (i.e., not
known at compile time). The following code assumes that `|reset(f,s)|' and
`|rewrite(f,s)|' do this, when |f| is a file variable and |s| is a string
variable that specifies the file name.
@↑system dependencies@>

@p procedure open←gf←file; {prepares to read packed bytes in |gf←file|}
begin reset(gf←file,name←of←file);
cur←loc:=0;
end;
@#
procedure open←tfm←file; {prepares to read packed bytes in |tfm←file|}
begin reset(tfm←file,name←of←file);
end;
@#
procedure open←dvi←file; {prepares to write packed bytes in |dvi←file|}
begin rewrite(dvi←file,name←of←file);
end;

@ If you looked carefully at the preceding code, you probably asked,
``What are |cur←loc| and |name←of←file|?'' Good question. They are global
variables: The integer |cur←loc| tells which byte of the input file will
be read next, and the string |name←of←file| will be set to the current
file name before the file-opening procedures are called.

@<Glob...@>=
@!cur←loc:integer; {current byte number in |gf←file|}
@!name←of←file:packed array[1..file←name←size] of char; {external file name}

@ It turns out to be convenient to read four bytes at a time, when we are
inputting from \.{TFM} files. The input goes into global variables
|b0|, |b1|, |b2|, and |b3|, with |b0| getting the first byte and |b3|
the fourth.

@<Glob...@>=
@!b0,@!b1,@!b2,@!b3: eight←bits; {four bytes input at once}

@ The |read←tfm←word| procedure sets |b0| through |b3| to the next
four bytes in the current \.{TFM} file.
@↑system dependencies@>

@p procedure read←tfm←word;
begin read(tfm←file,b0); read(tfm←file,b1);
read(tfm←file,b2); read(tfm←file,b3);
end;

@ We shall use another set of simple functions to read the next byte or
bytes from |gf←file|. There are four possibilities, each of which is
treated as a separate function in order to minimize the overhead for
subroutine calls.
@↑system dependencies@>

@p function get←byte:integer; {returns the next byte, unsigned}
var b:eight←bits;
begin if eof(gf←file) then get←byte:=0
else  begin read(gf←file,b); incr(cur←loc); get←byte:=b;
  end;
end;
@#
function get←two←bytes:integer; {returns the next two bytes, unsigned}
var a,@!b:eight←bits;
begin read(gf←file,a); read(gf←file,b);
cur←loc:=cur←loc+2;
get←two←bytes:=a*256+b;
end;
@#
function get←three←bytes:integer; {returns the next three bytes, unsigned}
var a,@!b,@!c:eight←bits;
begin read(gf←file,a); read(gf←file,b); read(gf←file,c);
cur←loc:=cur←loc+3;
get←three←bytes:=(a*256+b)*256+c;
end;
@#
function signed←quad:integer; {returns the next four bytes, signed}
var a,@!b,@!c,@!d:eight←bits;
begin read(gf←file,a); read(gf←file,b); read(gf←file,c); read(gf←file,d);
cur←loc:=cur←loc+4;
if a<128 then signed←quad:=((a*256+b)*256+c)*256+d
else signed←quad:=(((a-256)*256+b)*256+c)*256+d;
end;

@* Reading the font information.
Now let's get down to brass tacks and consider the more substantial
routines that actually convert \.{TFM} data into a form suitable for
computation.  The routines in this part of the program have been borrowed
from \TeX, with slight changes, since \.{GFtoDVI} has to do some of the
things that \TeX\ does.

The \.{TFM} data is stored in a large array called
|font←info|. Each item of |font←info| is a |memory←word|; the |fix←word|
data gets converted into |scaled| entries, while everything else goes into
words of type |four←quarters|. (These data structures are special cases of
the more general memory words of \TeX. On some machines it is necessary to
define |min←quarterword=-128| and |max←quarterword=127| in order to pack
four quarterwords into a single word.)
@↑system dependencies@>

@d min←quarterword=0 {change this to allow efficient packing, if necessary}
@d max←quarterword=255 {ditto}
@d qi(#)==#+min←quarterword
  {to put an |eight←bits| item into a quarterword}
@d qo(#)==#-min←quarterword
  {to take an |eight←bits| item out of a quarterword}
@d title←font=1
@d label←font=2
@d gray←font=3
@d slant←font=4
@d logo←font=5

@<Types ...@>=
@!quarterword = min←quarterword..max←quarterword; {1/4 of a word}
@!four←quarters = packed record@;@/
  @!b0:quarterword;
  @!b1:quarterword;
  @!b2:quarterword;
  @!b3:quarterword;
  end;
@!memory←word = record@;@/
  case boolean of
  true: (@!sc:scaled);
  false: (@!qqqq:four←quarters);
  end;
@!internal←font←number=title←font..logo←font;

@ Besides |font←info|, there are also a number of index arrays that point
into it, so that we can locate width and height information, etc.  For
example, the |char←info| data for character |c| in font |f| will be in
|font←info[char←base[f]+c].qqqq|; and if |w| is the |width←index| part of
this word (the |b0| field), the width of the character is
|font←info[width←base[f]+w].sc|. (These formulas assume that
|min←quarterword| has already been added to |w|, but not to |c|.)

@<Glob...@>=
@!font←info:array[0..font←mem←size] of memory←word; {the font metric data}
@!fmem←ptr:0..font←mem←size; {first unused word of |font←info|}
@!font←check:array[internal←font←number] of four←quarters; {check sum}
@!font←size:array[internal←font←number] of scaled; {``at'' size}
@!font←dsize:array[internal←font←number] of scaled; {``design'' size}
@!font←bc:array[internal←font←number] of eight←bits;
  {beginning (smallest) character code}
@!font←ec:array[internal←font←number] of eight←bits;
  {ending (largest) character code}
@!char←base:array[internal←font←number] of integer;
  {base addresses for |char←info|}
@!width←base:array[internal←font←number] of integer;
  {base addresses for widths}
@!height←base:array[internal←font←number] of integer;
  {base addresses for heights}
@!depth←base:array[internal←font←number] of integer;
  {base addresses for depths}
@!italic←base:array[internal←font←number] of integer;
  {base addresses for italic corrections}
@!lig←kern←base:array[internal←font←number] of integer;
  {base addresses for ligature/kerning programs}
@!kern←base:array[internal←font←number] of integer;
  {base addresses for kerns}
@!exten←base:array[internal←font←number] of integer;
  {base addresses for extensible recipes}
@!param←base:array[internal←font←number] of integer;
  {base addresses for font parameters}

@ @<Set init...@>=
fmem←ptr:=0;

@ Of course we want to define macros that suppress the detail of how font
information is actually packed, so that we don't have to write things like
$$\hbox{|font←info[width←base[f]+font←info[char←base[f]+c].qqqq.b0].sc|}$$
too often. The \.{WEB} definitions here make |char←info(f)(c)| the
|four←quarters| word of font information corresponding to character
|c| of font |f|. If |q| is such a word, |char←width(f)(q)| will be
the character's width; hence the long formula above is at least
abbreviated to
$$\hbox{|char←width(f)(char←info(f)(c))|.}$$
In practice we will try to fetch |q| first and look at several of its
fields at the same time.

The italic correction of a character will be denoted by
|char←italic(f)(q)|, so it is analogous to |char←width|.  But we will get
at the height and depth in a slightly different way, since we usually want
to compute both height and depth if we want either one.  The value of
|height←depth(q)| will be the 8-bit quantity
$$b=|height←index|\times16+|depth←index|,$$ and if |b| is such a byte we
will write |char←height(f)(b)| and |char←depth(f)(b)| for the height and
depth of the character |c| for which |q=char←info(f)(c)|. Got that?

The tag field will be called |char←tag(q)|; and the remainder byte will be
called |rem←byte(q)|.

@d char←info←end(#)==#].qqqq
@d char←info(#)==font←info[char←base[#]+char←info←end
@d char←width←end(#)==#.b0].sc
@d char←width(#)==font←info[width←base[#]+char←width←end
@d char←exists(#)==(#.b0>min←quarterword)
@d char←italic←end(#)==(qo(#.b2)) div 4].sc
@d char←italic(#)==font←info[italic←base[#]+char←italic←end
@d height←depth(#)==qo(#.b1)
@d char←height←end(#)==(#) div 16].sc
@d char←height(#)==font←info[height←base[#]+char←height←end
@d char←depth←end(#)==# mod 16].sc
@d char←depth(#)==font←info[depth←base[#]+char←depth←end
@d char←tag(#)==((qo(#.b2)) mod 4)
@d stop←bit(#)==#.b0
@d next←char(#)==#.b1
@d op←bit(#)==#.b2
@d rem←byte(#)==#.b3

@ Here are some macros that help process ligatures and kerns.
We write |char←kern(f)(j)| to find the amount of kerning specified by
kerning command~|j| in font~|f|.

@d lig←kern←start(#)==lig←kern←base[#]+rem←byte {beginning of lig/kern program}
@d char←kern←end(#)==rem←byte(#)].sc
@d char←kern(#)==font←info[kern←base[#]+char←kern←end

@ Font parameters are referred to as |slant(f)|, |space(f)|, etc.

@d param←end(#)==param←base[#]].sc
@d param(#)==font←info[#+param←end
@d slant==param(1) {slant to the right, per unit distance upward}
@d space==param(2) {normal space between words}
@d x←height==param(5) {one ex}
@d default←rule←thickness==param(8) {thickness of rules}

@ Here is the subroutine that inputs the information on |tfm←file|, assuming
that the file has just been reset. Parameter~|f| tells which metric file is
being read (either |title←font| or |label←font| or |gray←font| or |slant←font|
or |logo←font|); parameter~|s| is the ``at'' size, which will be
substituted for the design size if it is positive.

This routine does only limited checking of the validity of the file,
because another program (\.{TFtoPL}) is available to diagnose errors in
the rare case that something is amiss.

@d bad←tfm=11 {label for |read←font←info|}
@d abend==goto bad←tfm {do this when the \.{TFM} data is wrong}

@p procedure read←font←info(@!f:integer;@!s:scaled); {input a \.{TFM} file}
label done,bad←tfm;
var k:0..font←mem←size; {index into |font←info|}
@!lf,@!lh,@!bc,@!ec,@!nw,@!nh,@!nd,@!ni,@!nl,@!nk,@!ne,@!np:0..65535;
  {sizes of subfiles}
@!qw:four←quarters;@!sw:scaled; {accumulators}
@!z:scaled; {the design size or the ``at'' size}
@!alpha:integer;@!beta:1..16;
  {auxiliary quantities used in fixed-point multiplication}
begin @<Read and check the font data; |abend| if the \.{TFM} file is
  malformed; otherwise |goto done|@>;
bad←tfm: print←nl('Bad TFM file for');
@.Bad TFM file...@>
case f of
title←font:abort('titles!');
label←font:abort('labels!');
gray←font:abort('pixels!');
slant←font:abort('slants!');
logo←font:abort('METAFONT logo!');
end; {there are no other cases}
done: {it might be good to close |tfm←file| now}
end;

@ @<Read and check...@>=
@<Read the {\.{TFM}} size fields@>;
@<Use size fields to allocate font information@>;
@<Read the {\.{TFM}} header@>;
@<Read character data@>;
@<Read box dimensions@>;
@<Read ligature/kern program@>;
@<Read extensible character recipes@>;
@<Read font parameters@>;
@<Make final adjustments and |goto done|@>

@ @d read←two←halves←end(#)==#:=b2*256+b3
@d read←two←halves(#)==read←tfm←word; #:=b0*256+b1; read←two←halves←end

@<Read the {\.{TFM}} size fields@>=
begin read←two←halves(lf)(lh);
read←two←halves(bc)(ec);
if (bc>ec+1)or(ec>255) then abend;
read←two←halves(nw)(nh);
read←two←halves(nd)(ni);
read←two←halves(nl)(nk);
read←two←halves(ne)(np);
if lf<>6+lh+(ec-bc+1)+nw+nh+nd+ni+nl+nk+ne+np then abend;
end

@ The preliminary settings of the index variables |width←base|,
|lig←kern←base|, |kern←base|, and |exten←base| will be corrected later by
subtracting |min←quarterword| from them; and we will subtract 1 from
|param←base| too. It's best to forget about such anomalies until later.

@<Use size fields to allocate font information@>=
lf:=lf-6-lh; {|lf| words should be loaded into |font←info|}
if np<8 then lf:=lf+8-np; {at least eight parameters will appear}
if fmem←ptr+lf>font←mem←size then abort('No room for TFM file!');
@.No room for TFM file@>
char←base[f]:=fmem←ptr-bc;
width←base[f]:=char←base[f]+ec+1;
height←base[f]:=width←base[f]+nw;
depth←base[f]:=height←base[f]+nh;
italic←base[f]:=depth←base[f]+nd;
lig←kern←base[f]:=italic←base[f]+ni;
kern←base[f]:=lig←kern←base[f]+nl;
exten←base[f]:=kern←base[f]+nk;
param←base[f]:=exten←base[f]+ne

@ Only the first two words of the header are needed by \.{GFtoDVI}.

@d store←four←quarters(#)==
  begin read←tfm←word;
  qw.b0:=qi(b0); qw.b1:=qi(b1); qw.b2:=qi(b2); qw.b3:=qi(b3);
  #:=qw;
  end

@<Read the {\.{TFM}} header@>=
begin if lh<2 then abend;
store←four←quarters(font←check[f]);
read←tfm←word;
if b0>127 then abend; {design size must be positive}
z:=((b0*256+b1)*256+b2)*16+(b3 div 16);
if z<unity then abend;
while lh>2 do
  begin read←tfm←word; decr(lh); {ignore the rest of the header}
  end;
font←dsize[f]:=z;
if s>0 then z:=s;
font←size[f]:=z;
end

@ @<Read character data@>=
for k:=fmem←ptr to width←base[f]-1 do
  begin store←four←quarters(font←info[k].qqqq);
  if (b0>=nw)or(b1 div @'20>=nh)or(b1 mod @'20>=nd)or
    (b2 div 4>=ni) then abend;
  case b2 mod 4 of
  lig←tag: if b3>=nl then abend;
  ext←tag: if b3>=ne then abend;
  no←tag,list←tag: do←nothing;
  end; {there are no other cases}
  end

@ A |fix←word| whose four bytes are $(b0,b1,b2,b3)$ from left to right
represents the number
$$x=\left\{\vcenter{\halign{$#$,\hfil\qquad&if $#$\hfil\cr
b←1\cdot2↑{-4}+b←2\cdot2↑{-12}+b←3\cdot2↑{-20}&b←0=0;\cr
-16+b←1\cdot2↑{-4}+b←2\cdot2↑{-12}+b←3\cdot2↑{-20}&b←0=255.\cr}}\right.$$
(No other choices of |b0| are allowed, since the magnitude of a number in
design-size units must be less than 16.)  We want to multiply this
quantity by the integer~|z|, which is known to be less than $2↑{27}$. Let
$\alpha=16z$.  If $|z|<2↑{23}$, the individual multiplications $b\cdot z$,
$c\cdot z$, $d\cdot z$ cannot overflow; otherwise we will divide |z| by 2,
4, 8, or 16, to obtain a multiplier less than $2↑{23}$, and we can
compensate for this later. If |z| has thereby been replaced by
$|z|↑\prime=|z|/2↑e$, let $\beta=2↑{4-e}$; we shall compute
$$\lfloor(b←1+b←2\cdot2↑{-8}+b←3\cdot2↑{-16})\,z↑\prime/\beta\rfloor$$
if $a=0$, or the same quantity minus $\alpha$ if $a=255$.

@d store←scaled(#)==begin read←tfm←word;
  sw:=(((((b3*z)div@'400)+(b2*z))div@'400)+(b1*z))div beta;
  if b0=0 then #:=sw@+else if b0=255 then #:=sw-alpha@+else abend;
  end

@<Read box dimensions@>=
begin @<Replace |z| by $|z|↑\prime$ and compute $\alpha,\beta$@>;
for k:=width←base[f] to lig←kern←base[f]-1 do
  store←scaled(font←info[k].sc);
if font←info[width←base[f]].sc<>0 then abend; {\\{width}[0] must be zero}
if font←info[height←base[f]].sc<>0 then abend; {\\{height}[0] must be zero}
if font←info[depth←base[f]].sc<>0 then abend; {\\{depth}[0] must be zero}
if font←info[italic←base[f]].sc<>0 then abend; {\\{italic}[0] must be zero}
end

@ @<Replace |z|...@>=
begin alpha:=16*z; beta:=16;
while z>=@'40000000 do
  begin z:=z div 2; beta:=beta div 2;
  end;
end

@ @d check←byte←range(#)==begin if (#<bc)or(#>ec) then abend@+end

@<Read ligature/kern program@>=
begin for k:=lig←kern←base[f] to kern←base[f]-1 do
  begin store←four←quarters(font←info[k].qqqq);
  check←byte←range(b1);
  if b2<128 then check←byte←range(b3) {check ligature}
  else if b3>=nk then abend; {check kern}
  end;
if (nl>0)and(b0<128) then abend; {check for stop bit on last command}
for k:=kern←base[f] to exten←base[f]-1 do
  store←scaled(font←info[k].sc);
end

@ @<Read extensible character recipes@>=
for k:=exten←base[f] to param←base[f]-1 do
  begin store←four←quarters(font←info[k].qqqq);
  if b0<>0 then check←byte←range(b0);
  if b1<>0 then check←byte←range(b1);
  if b2<>0 then check←byte←range(b2);
  check←byte←range(b3);
  end

@ @<Read font parameters@>=
begin for k:=1 to np do
  if k=1 then {the |slant| parameter is a pure number}
    begin read←tfm←word;
    if b0>127 then sw:=b0-256@+else sw:=b0;
    sw:=sw*@'400+b1; sw:=sw*@'400+b2;
    font←info[param←base[f]].sc:=(sw*@'20)+(b3 div@'20);
    end
  else store←scaled(font←info[param←base[f]+k-1].sc);
for k:=np+1 to 8 do font←info[param←base[f]+k-1].sc:=0;
end

@ Now to wrap it up, we have checked all the necessary things about the \.{TFM}
file, and all we need to do is put the finishing touches on the data for
the new font.

@d adjust(#)==#[f]:=qo(#[f])
  {correct for the excess |min←quarterword| that was added}

@<Make final adjustments...@>=
font←bc[f]:=bc; font←ec[f]:=ec;
adjust(width←base); adjust(lig←kern←base);
adjust(kern←base); adjust(exten←base);
decr(param←base[f]);
fmem←ptr:=fmem←ptr+lf; goto done

@* The string pool.
\.{GFtoDVI} remembers strings by putting them into an array called
|str←pool|. The |str←start| array tells where each string starts in the pool.

@<Types ...@>=
@!pool←pointer = 0..pool←size; {for variables that point into |str←pool|}
@!str←number = 0..max←strings; {for variables that point into |str←start|}

@ As new strings enter, we keep track of the storage currently used, by
means of two global variables called |pool←ptr| and |str←ptr|. These are
periodically reset to their initial valus when we move from one character
to another, because most strings are of only temporary interest.

@<Glob...@>=
@!str←pool:packed array[pool←pointer] of ASCII←code; {the characters}
@!str←start : array[str←number] of pool←pointer; {the starting pointers}
@!pool←ptr : pool←pointer; {first unused position in |str←pool|}
@!str←ptr : str←number; {start of the current string being created}
@!init←str←ptr:str←number; {|str←ptr| setting when a new character starts}

@ Several of the elementary string operations are performed using \.{WEB}
macros instead of using \PASCAL\ procedures, because many of the
operations are done quite frequently and we want to avoid the
overhead of procedure calls. For example, here is
a simple macro that computes the length of a string.
@.WEB@>

@d length(#)==(str←start[#+1]-str←start[#]) {the number of characters
  in string number \#}

@ Strings are created by appending character codes to |str←pool|.
The macro called |append←char|, defined here, does not check to see if the
value of |pool←ptr| has gotten too high; this test is supposed to be
made before |append←char| is used.

To test if there is room to append |l| more characters to |str←pool|,
we shall write |str←room(l)|, which aborts \.{GFtoDVI} and gives an
apologetic error message if there isn't enough room.

@d append←char(#) == {put |ASCII←code| \# at the end of |str←pool|}
begin str←pool[pool←ptr]:=#; incr(pool←ptr);
end
@d str←room(#) == {make sure that the pool hasn't overflowed}
  begin if pool←ptr+# > pool←size then
    abort('Too many strings!');
@.Too many strings@>
  end

@ Once a sequence of characters has been appended to |str←pool|, it
officially becomes a string when the function |make←string| is called.
This function returns the identification number of the new string as its
value.

@p function make←string : str←number; {current string enters the pool}
begin if str←ptr=max←strings then
  abort('Too many labels!');
@.Too many labels@>
incr(str←ptr); str←start[str←ptr]:=pool←ptr;
make←string:=str←ptr-1;
end;

@ The first strings in the string pool are the keywords that \.{GFtoDVI}
recognizes in the \\{xxx} commands of a \.{GF} file. They are entered
into |str←pool| by means of a tedious bunch of assignment statements,
together with calls on the |first←string| subroutine.

@p procedure first←string(@!c:integer);
begin if str←ptr<>c then abort('?'); {internal consistency check}
@.?@>
while l>0 do
  begin append←char(buffer[l]); decr(l);
  end;
incr(str←ptr); str←start[str←ptr]:=pool←ptr;
end;

@ @<Glob...@>=
@!l:integer; {length of string being made by |first←string|}

@ String number 0 is the empty string.

@d init←str0(#)==first←string(#)
@d init←str1(#)==buffer[1]:=#; init←str0
@d init←str2(#)==buffer[2]:=#; init←str1
@d init←str3(#)==buffer[3]:=#; init←str2
@d init←str4(#)==buffer[4]:=#; init←str3
@d init←str5(#)==buffer[5]:=#; init←str4
@d init←str6(#)==buffer[6]:=#; init←str5
@d init←str7(#)==buffer[7]:=#; init←str6
@d init←str8(#)==buffer[8]:=#; init←str7
@d init←str9(#)==buffer[9]:=#; init←str8
@d init←str10(#)==buffer[10]:=#; init←str9
@d init←str11(#)==buffer[11]:=#; init←str10
@d init←str12(#)==buffer[12]:=#; init←str11
@d init←str13(#)==buffer[13]:=#; init←str12
@d longest←keyword=13
@#
@d null←string=0 {the empty keyword}
@d area←code=4 {add to font code for the `\.{area}' keywords}
@d at←code=8 {add to font code for the `\.{at}' keywords}
@d rule←code=13 {code for the keyword `\.{rule}'}
@d title←code=14 {code for the keyword `\.{title}'}
@d rule←thickness←code=15 {code for the keyword `\.{rulethickness}'}
@d offset←code=16 {code for the keyword `\.{offset}'}
@d x←offset←code=17 {code for the keyword `\.{xoffset}'}
@d y←offset←code=18 {code for the keyword `\.{yoffset}'}
@d max←keyword=18 {largest keyword code number}

@<Initialize the strings@>=
str←ptr:=0; pool←ptr:=0; str←start[0]:=0;@/
l:=0; init←str0(null←string);@/
l:=9; init←str9("t")("i")("t")("l")("e")("f")("o")("n")("t")(title←font);@/
l:=9; init←str9("l")("a")("b")("e")("l")("f")("o")("n")("t")(label←font);@/
l:=8; init←str8("g")("r")("a")("y")("f")("o")("n")("t")(gray←font);@/
l:=9; init←str9("s")("l")("a")("n")("t")("f")("o")("n")("t")(slant←font);@/
l:=13; init←str13("t")("i")("t")("l")("e")
  ("f")("o")("n")("t")("a")("r")("e")("a")(title←font+area←code);@/
l:=13; init←str13("l")("a")("b")("e")("l")
  ("f")("o")("n")("t")("a")("r")("e")("a")(label←font+area←code);@/
l:=12; init←str12("g")("r")("a")("y")
  ("f")("o")("n")("t")("a")("r")("e")("a")(gray←font+area←code);@/
l:=13; init←str13("s")("l")("a")("n")("t")
  ("f")("o")("n")("t")("a")("r")("e")("a")(slant←font+area←code);@/
l:=11; init←str11("t")("i")("t")("l")("e")
  ("f")("o")("n")("t")("a")("t")(title←font+at←code);@/
l:=11; init←str11("l")("a")("b")("e")("l")
  ("f")("o")("n")("t")("a")("t")(label←font+at←code);@/
l:=10; init←str10("g")("r")("a")("y")
  ("f")("o")("n")("t")("a")("t")(gray←font+at←code);@/
l:=11; init←str11("s")("l")("a")("n")("t")
  ("f")("o")("n")("t")("a")("t")(slant←font+at←code);@/
l:=4; init←str4("r")("u")("l")("e")(rule←code);@/
l:=5; init←str5("t")("i")("t")("l")("e")(title←code);@/
l:=13; init←str13("r")("u")("l")("e")
  ("t")("h")("i")("c")("k")("n")("e")("s")("s")(rule←thickness←code);@/
l:=6; init←str6("o")("f")("f")("s")("e")("t")(offset←code);@/
l:=7; init←str7("x")("o")("f")("f")("s")("e")("t")(x←offset←code);@/
l:=7; init←str7("y")("o")("f")("f")("s")("e")("t")(y←offset←code);@/

@ We will also find it useful to have the following strings. (The names of
default fonts will presumably be different at different sites.)
@↑system dependencies@>
@↑default fonts@>

@d gf←ext=max←keyword+1 {string number for `\.{.gf}'}
@d dvi←ext=max←keyword+2 {string number for `\.{.dvi}'}
@d tfm←ext=max←keyword+3 {string number for `\.{.tfm}'}
@d page←header=max←keyword+4 {string number for `\.{\ \ Page\ }'}
@d char←header=max←keyword+5 {string number for `\.{\ \ Character\ }'}
@d fam←header=max←keyword+6 {string number for `\.{\ \ Family\ }'}
@d left←quotes=max←keyword+7 {string number for `\.{\ \ ``}'}
@d right←quotes=max←keyword+8 {string number for `\.{''}'}
@d equals←sign=max←keyword+9 {string number for `\.{ = }'}
@d plus←sign=max←keyword+10 {string number for `\.{ + (}'}
@d default←title←font=max←keyword+11
  {string number for the default |title←font|}
@d default←label←font=max←keyword+12
  {string number for the default |label←font|}
@d default←gray←font=max←keyword+13 {string number for the default |gray←font|}
@d logo←font←name=max←keyword+14 {string number for the font with \MF\ logo}
@d small←logo=max←keyword+15 {character string for `{\logo opqrstuq}'}
@d home←font←area=max←keyword+16 {string number for system-dependent font area}

@<Initialize the strings@>=
l:=3; init←str3(".")("g")("f")(gf←ext);@/
l:=4; init←str4(".")("d")("v")("i")(dvi←ext);@/
l:=4; init←str4(".")("t")("f")("m")(tfm←ext);@/
l:=7; init←str7(" ")(" ")("P")("a")("g")("e")(" ")(page←header);@/
l:=12; init←str12(" ")(" ")("C")("h")("a")("r")("a")("c")("t")("e")("r")(" ")
  (char←header);@/
l:=9; init←str9(" ")(" ")("F")("a")("m")("i")("l")("y")(" ")(fam←header);@/
l:=4; init←str4(" ")(" ")("`")("`")(left←quotes);@/
l:=2; init←str2("'")("'")(right←quotes);@/
l:=3; init←str3(" ")("=")(" ")(equals←sign);@/
l:=4; init←str4(" ")("+")(" ")("(")(plus←sign);@/
l:=4; init←str4("a")("m")("r")("8")(default←title←font);@/
  {some day this will change to \.{cmr8}}
l:=6; init←str6("a")("m")("t")("t")("1")("0")(default←label←font);@/
  {some day this will change to \.{cmtt10}}
l:=4; init←str4("g")("r")("a")("y")(default←gray←font);
l:=6; init←str6("m")("a")("n")("f")("n")("t")(logo←font←name);
l:=8; init←str8("o")("p")("q")("r")("s")("t")("u")("q")(small←logo);

@ If an \\{xxx} command has just been encountered in the \.{GF} file,
the following procedure interprets its keyword. More precisely, we assume
that |cur←gf| contains an op-code byte just read from the \.{GF} file,
where |xxx1<=cur←gf<=no←op|. The |interpret←xxx| procedure will read the
rest of the command, in the following way:
\smallskip
\item{1)} If |cur←gf| is |no←op| or |yyy|, or it's an \\{xxx} command with
an unknown keyword, the bytes are simply read and ignored, and the
value |no←operation| is returned.

\item{2)} If |cur←gf| is an \\{xxx} command (either |xxx1| or $\cdots$
or |xxx4|), and if the associated string matches a keyword exactly,
the string number of that keyword is returned (e.g., |rule←thickness←code|).

\item{3)} If |cur←gf| is an \\{xxx} command whose string begins with
keyword and space, the string number of that keyword is returned, and
the remainder of the string is put into the string pool (where it will be
string number |cur←string|. Exception: If the keyword is |null←string|,
the character immediately following the blank space is put into the
global variable |label←type|, and the remaining characters go into the
string pool.

\smallskip\noindent
In all cases, |cur←gf| will then be reset to the op-code byte that
immediately follows the original command.

@d no←operation=max←keyword+1

@<Types ...@>=
@!keyword←code=null←string..no←operation;

@ @<Glob...@>=
@!cur←gf:eight←bits; {the byte most recently read from |gf←file|}
@!cur←string:str←number; {the string following a keyword and space}
@!label←type:eight←bits; {the character following a null keyword and space}

@ We will be using this procedure when reading the \.{GF} file just
after the preamble and just after |eoc| commands.

@p function interpret←xxx:keyword←code;
label done,done1,not←found;
var @!k:integer; {number of bytes in an \\{xxx} command}
@!j:integer; {number of bytes read so far}
@!l:0..longest←keyword; {length of keyword to check}
@!m:keyword←code; {runs through the list of known keywords}
@!n1:0..longest←keyword; {buffered character being checked}
@!n2:pool←pointer; {pool character being checked}
@!c:keyword←code; {the result to return}
begin c:=no←operation; cur←string:=null←string;
case cur←gf of
no←op:goto done;
yyy:begin k:=signed←quad; goto done;
  end;
xxx1:k:=get←byte;
xxx2:k:=get←two←bytes;
xxx3:k:=get←three←bytes;
xxx4:k:=signed←quad;
end; {there are no other cases}
@<Read the next |k| characters of the \.{GF} file;
  change |c| and |goto done| if a keyword is recognized@>;
done: cur←gf:=get←byte; interpret←xxx:=c;
end;

@ @<Read the next |k|...@>=
j:=0;@+if k<2 then goto not←found;
loop@+  begin l:=j;
  if j=k then goto done1;
  if j=longest←keyword then goto not←found;
  incr(j); buffer[j]:=get←byte;
  if buffer[j]=" " then goto done1;
  end;
done1:@<If the keyword in |buffer[1..l]| is known, change |c| and |goto done|@>;
not←found: while j<k do
  begin incr(j); cur←gf:=get←byte;
  end

@ @<If the keyword...@>=
for m:=null←string to max←keyword do if length(m)=l then
  begin n1:=0; n2:=str←start[m];
  while (n1<l)and(buffer[n1+1]=str←pool[n2]) do
    begin incr(n1); incr(n2);
    end;
  if n1=l then
    begin c:=m;
    if m=null←string then
      begin incr(j); label←type:=get←byte;
      end;
    str←room(k-j);
    while j<k do
      begin incr(j); append←char(get←byte);
      end;
    cur←string:=make←string; goto done;
    end;
  end

@ When an \\{xxx} command takes a numeric argument, |get←yyy| reads
that argument and puts the following byte into |cur←gf|.

@p function get←yyy:scaled;
var @!v:scaled; {value just read}
begin if cur←gf<>yyy then get←yyy:=0
else  begin v:=signed←quad; cur←gf:=get←byte; get←yyy:=v;
  end;
end;

@ A simpler method is used for special commands between |boc| and |eoc|,
since \.{GFtoDVI} doesn't even look at them.

@p procedure skip←nop;
label done;
var @!k:integer; {number of bytes in an \\{xxx} command}
@!j:integer; {number of bytes read so far}
begin case cur←gf of
no←op:goto done;
yyy:begin k:=signed←quad; goto done;
  end;
xxx1:k:=get←byte;
xxx2:k:=get←two←bytes;
xxx3:k:=get←three←bytes;
xxx4:k:=signed←quad;
end; {there are no other cases}
for j:=1 to k do cur←gf:=get←byte;
done: cur←gf:=get←byte;
end;

@* File names.
It's time now to fret about file names. \.{GFtoDVI} uses the conventions of
\TeX\ and \MF\ to convert file names into strings that can be used to open
files. Three routines called |begin←name|, |more←name|, and |end←name| are
involved, so that the system-dependent parts of file naming conventions are
isolated from the system-independent ways in which file names are used.
(See the \TeX\ or \MF\ program listing for further explanation.)
@↑system dependencies@>

@<Glob...@>=
@!cur←name:str←number; {name of file just scanned}
@!cur←area:str←number; {file area just scanned, or |null←string|}
@!cur←ext:str←number; {file extension just scanned, or |null←string|}

@ The file names we shall deal with for illustrative purposes have the
following structure:  If the name contains `\.>' or `\.:', the file area
consists of all characters up to and including the final such character;
otherwise the file area is null.  If the remaining file name contains
`\..', the file extension consists of all such characters from the first
remaining `\..' to the end, otherwise the file extension is null.
@↑system dependencies@>

We can scan such file names easily by using two global variables that keep track
of the occurrences of area and extension delimiters:

@<Glob...@>=
@!area←delimiter:pool←pointer; {the most recent `\.>' or `\.:', if any}
@!ext←delimiter:pool←pointer; {the relevant `\..', if any}

@ Font metric files whose areas are not given
explicitly are assumed to appear in a standard system area called
|home←font←area|.  This system area name will, of course, vary from place
to place. The program here sets it to `\.{TeXfonts:}'.
@↑system dependencies@>
@.TeXfonts@>

@<Initialize the strings@>=
l:=9; init←str9("T")("e")("X")("f")("o")("n")("t")("s")(":")(home←font←area);@/

@ Here now is the first of the system-dependent routines for file name scanning.
@↑system dependencies@>

@p procedure begin←name;
begin area←delimiter:=0; ext←delimiter:=0;
end;

@ And here's the second.
@↑system dependencies@>

@p function more←name(@!c:ASCII←code):boolean;
begin if c=" " then more←name:=false
else  begin if (c=">")or(c=":") then
    begin area←delimiter:=pool←ptr; ext←delimiter:=0;
    end
  else if (c=".")and(ext←delimiter=0) then ext←delimiter:=pool←ptr;
  str←room(1); append←char(c); {contribute |c| to the current string}
  more←name:=true;
  end;
end;

@ The third.
@↑system dependencies@>

@p procedure end←name;
begin if str←ptr+3>max←strings then
  abort('Too many strings!');
@.Too many strings@>
if area←delimiter=0 then cur←area:=null←string
else  begin cur←area:=str←ptr; incr(str←ptr);
  str←start[str←ptr]:=area←delimiter+1;
  end;
if ext←delimiter=0 then
  begin cur←ext:=null←string; cur←name:=make←string;
  end
else  begin cur←name:=str←ptr; incr(str←ptr);
  str←start[str←ptr]:=ext←delimiter; cur←ext:=make←string;
  end;
end;

@ Another system-dependent routine is needed to convert three strings
into the |name←of←file| value that is used to open files. The present code
allows both lowercase and uppercase letters in the file name.
@↑system dependencies@>

@d append←to←name(#)==begin c:=#; incr(k);
  if k<=file←name←size then name←of←file[k]:=xchr[c];
  end

@p procedure pack←file←name(@!n,@!a,@!e:str←number);
var k:integer; {number of positions filled in |name←of←file|}
@!c: ASCII←code; {character being packed}
@!j:integer; {index into |str←pool|}
@!name←length:0..file←name←size; {number of characters packed}
begin k:=0;
for j:=str←start[a] to str←start[a+1]-1 do append←to←name(str←pool[j]);
for j:=str←start[n] to str←start[n+1]-1 do append←to←name(str←pool[j]);
for j:=str←start[e] to str←start[e+1]-1 do append←to←name(str←pool[j]);
if k<=file←name←size then name←length:=k@+else name←length:=file←name←size;
for k:=name←length+1 to file←name←size do name←of←file[k]:=' ';
end;

@ Now let's consider the routines by which \.{GFtoDVI} deals with file names
in a system-independent manner.
The global variable |job←name| contains the \.{GF} file name that is
being input. This name is extended by `\.{dvi}'
in order to make the name of the output file.

@<Glob...@>=
@!job←name:str←number; {principal file name}

@ The |start←gf| procedure prompts the user for the name of the generic
font file to be input. It opens the file, making sure that some input is
present; then it opens the output file.

Although this routine is system-independent, it should probably be
modified to take the file name from the command line (without an initial
prompt), on systems that permit such things.

@p procedure start←gf;
label found,done;
begin loop@+begin print←nl('GF file name: '); input←ln;
@.GF file name@>
  buf←ptr:=0; buffer[line←length]:="?";
  while buffer[buf←ptr]=" " do incr(buf←ptr);
  if buf←ptr<line←length then
    begin @<Scan the file name in the buffer@>;
    if cur←ext=null←string then cur←ext:=gf←ext;
    pack←file←name(cur←name,cur←area,cur←ext); open←gf←file;
    if not eof(gf←file) then goto found;
    print←nl('Oops... I can''t find file '); print(name←of←file);
@.Oops...@>
@.I can't find...@>
    end;
  end;
found:job←name:=cur←name; pack←file←name(job←name,null←string,dvi←ext);
open←dvi←file;
end;

@ @<Scan the file name in the buffer@>=
if buffer[line←length-1]="/" then
  begin interaction:=true; decr(line←length);
  end;
begin←name;
loop@+  begin if buf←ptr=line←length then goto done;
  if not more←name(buffer[buf←ptr]) then goto done;
  incr(buf←ptr);
  end;
done:end←name

@ Special instructions found near the beginning of the \.{GF} file might
change the names, areas, and ``at'' sizes of the fonts that \.{GFtoDVI}
will be using. But when we reach the first |boc| instruction, we input
all of the \.{TFM} files. The global variable |interaction| is set |true|
if a |"/"| was removed at the end of the file name; this user that the
user will have a chance to issue special instructions online just before
the fonts are loaded.

@d check←fonts==if fonts←not←loaded then load←fonts

@<Glob...@>=
@!interaction:boolean; {is the user allowed to type specials online?}
@!fonts←not←loaded:boolean; {have the \.{TFM} files still not been input?}
@!font←name:array[internal←font←number] of str←number; {current font names}
@!font←area:array[internal←font←number] of str←number; {current font areas}
@!font←at:array[internal←font←number] of scaled; {current font ``at'' sizes}

@ @<Set init...@>=
interaction:=false; fonts←not←loaded:=true;
font←name[title←font]:=default←title←font;
font←name[label←font]:=default←label←font;
font←name[gray←font]:=default←gray←font;
font←name[slant←font]:=null←string;
font←name[logo←font]:=logo←font←name;
for k:=title←font to logo←font do
  begin font←area[k]:=null←string; font←at[k]:=0;
  end;

@ After the following procedure has been performed, there will be no
turning back; the fonts will have been firmly established in
\.{GFtoDVI}'s memory.

@<Declare the procedure called |load←fonts|@>=
procedure load←fonts;
label done,continue,found,not←found;
var @!f:internal←font←number;
@!i:four←quarters; {font information word}
@!j,@!k,@!v:integer; {registers for initializing font tables}
@!m:title←font..slant←font+area←code; {keyword found}
@!n1:0..longest←keyword; {buffered character being checked}
@!n2:pool←pointer; {pool character being checked}
begin if interaction then @<Get online special input@>;
fonts←not←loaded:=false;
for f:=title←font to logo←font do
 if (f<>slant←font)or(length(font←name[f])>0) then
  begin if length(font←area[f])=0 then font←area[f]:=home←font←area;
  pack←file←name(font←name[f],font←area[f],tfm←ext);
  open←tfm←file; read←font←info(f,font←at[f]);
  if font←area[f]=home←font←area then font←area[f]:=null←string;
  dvi←font←def(f); {put the font name in the \.{DVI} file}
  end;
@<Initialize global variables that depend on the font data@>;
end;

@ @<Get online special input@>=
loop@+  begin not←found: print←nl('Special font substitution: ');
@.Special font subst...@>
  continue: input←ln;
  if line←length=0 then goto done;
  @<Search buffer for valid keyword; if successful, |goto found|@>;
  print('Please say, e.g., "grayfont foo" or "slantfontarea baz".');
  goto not←found;
  found: @<Update the font name or area@>;
  print('OK; any more? '); goto continue;
  end;
done:

@ @<Search buffer for valid keyword; if successful, |goto found|@>=
buf←ptr:=0; buffer[line←length]:=" ";
while buffer[buf←ptr]<>" " do incr(buf←ptr);
for m:=title←font to slant←font+area←code do if length(m)=buf←ptr then
  begin n1:=0; n2:=str←start[m];
  while (n1<buf←ptr)and(buffer[n1]=str←pool[n2]) do
    begin incr(n1); incr(n2);
    end;
  if n1=buf←ptr then goto found;
  end

@ @<Update the font name or area@>=
incr(buf←ptr); str←room(line←length-buf←ptr);
while buf←ptr<line←length do
  begin append←char(buffer[buf←ptr]); incr(buf←ptr);
  end;
if m>area←code then font←area[m-area←code]:=make←string
else  begin font←name[m]:=make←string; font←area[m]:=null←string;
  font←at[m]:=0;
  end;
init←str←ptr:=str←ptr

@* Shipping pages out.
The following routines are used to write the \.{DVI} file. They have
been copied from \TeX, but simplified; we don't have to handle
nearly as much generality as \TeX\ does.

Statistics about the entire set of pages that will be shipped out must be
reported in the \.{DVI} postamble. The global variables |total←pages|,
|max←v|, |max←h|, and |last←bop| are used to record this information.

@<Glob...@>=
@!total←pages:integer; {the number of pages that have been shipped out}
@!max←v:scaled; {maximum height-plus-depth of pages shipped so far}
@!max←h:scaled; {maximum width of pages shipped so far}
@!last←bop:integer; {location of previous |bop| in the \.{DVI} output}

@ @<Set init...@>=
total←pages:=0; max←v:=0; max←h:=0; last←bop:=-1;

@ The \.{DVI} bytes are output to a buffer instead of being written directly
to the output file. This makes it possible to reduce the overhead of
subroutine calls.

The output buffer is divided into two parts of equal size; the bytes found
in |dvi←buf[0..half←buf-1]| constitute the first half, and those in
|dvi←buf[half←buf..dvi←buf←size-1]| constitute the second. The global
variable |dvi←ptr| points to the position that will receive the next
output byte. When |dvi←ptr| reaches |dvi←limit|, which is always equal
to one of the two values |half←buf| or |dvi←buf←size|, the half buffer that
is about to be invaded next is sent to the output and |dvi←limit| is
changed to its other value. Thus, there is always at least a half buffer's
worth of information present, except at the very beginning of the job.

Bytes of the \.{DVI} file are numbered sequentially starting with 0;
the next byte to be generated will be number |dvi←offset+dvi←ptr|.

@<Types ...@>=
@!dvi←index=0..dvi←buf←size; {an index into the output buffer}

@ Some systems may find it more efficient to make |dvi←buf| a |packed|
array, since output of four bytes at once may be facilitated.
@↑system dependencies@>

@<Glob...@>=
@!dvi←buf:array[dvi←index] of eight←bits; {buffer for \.{DVI} output}
@!half←buf:dvi←index; {half of |dvi←buf←size|}
@!dvi←limit:dvi←index; {end of the current half buffer}
@!dvi←ptr:dvi←index; {the next available buffer address}
@!dvi←offset:integer; {|dvi←buf←size| times the number of times the
  output buffer has been fully emptied}

@ Initially the buffer is all in one piece; we will output half of it only
after it first fills up.

@<Set init...@>=
half←buf:=dvi←buf←size div 2; dvi←limit:=dvi←buf←size; dvi←ptr:=0;
dvi←offset:=0;

@ The actual output of |dvi←buf[a..b]| to |dvi←file| is performed by calling
|write←dvi(a,b)|. It is safe to assume that |a| and |b+1| will both be
multiples of 4 when |write←dvi(a,b)| is called; therefore it is possible on
many machines to use efficient methods to pack four bytes per word and to
output an array of words with one system call.
@↑system dependencies@>

@p procedure write←dvi(@!a,@!b:dvi←index);
var k:dvi←index;
begin for k:=a to b do write(dvi←file,dvi←buf[k]);
end;

@ To put a byte in the buffer without paying the cost of invoking a procedure
each time, we use the macro |dvi←out|.

@d dvi←out(#)==@+begin dvi←buf[dvi←ptr]:=#; incr(dvi←ptr);
  if dvi←ptr=dvi←limit then dvi←swap;
  end

@p procedure dvi←swap; {outputs half of the buffer}
begin if dvi←limit=dvi←buf←size then
  begin write←dvi(0,half←buf-1); dvi←limit:=half←buf;
  dvi←offset:=dvi←offset+dvi←buf←size; dvi←ptr:=0;
  end
else  begin write←dvi(half←buf,dvi←buf←size-1); dvi←limit:=dvi←buf←size;
  end;
end;

@ Here is how we clean out the buffer when \TeX\ is all through; |dvi←ptr|
will be a multiple of~4.

@<Empty the last bytes out of |dvi←buf|@>=
if dvi←limit=half←buf then write←dvi(half←buf,dvi←buf←size-1);
if dvi←ptr>0 then write←dvi(0,dvi←ptr-1)

@ The |dvi←four| procedure outputs four bytes in two's complement notation,
without risking arithmetic overflow.

@p procedure dvi←four(@!x:integer);
begin if x>=0 then dvi←out(x div @'100000000)
else  begin x:=x+@'10000000000;
  x:=x+@'10000000000;
  dvi←out((x div @'100000000) + 128);
  end;
x:=x mod @'100000000; dvi←out(x div @'200000);
x:=x mod @'200000; dvi←out(x div @'400);
dvi←out(x mod @'400);
end;

@ Here's a procedure that outputs a font definition.

@d select←font(#)==dvi←out(fnt←num←0+#) {set current font to \#}

@p procedure dvi←font←def(@!f:internal←font←number);
var k:integer; {index into |str←pool|}
begin dvi←out(fnt←def1);
dvi←out(f);@/
dvi←out(qo(font←check[f].b0));
dvi←out(qo(font←check[f].b1));
dvi←out(qo(font←check[f].b2));
dvi←out(qo(font←check[f].b3));@/
dvi←four(font←size[f]);
dvi←four(font←dsize[f]);@/
dvi←out(length(font←area[f]));
dvi←out(length(font←name[f]));
@<Output the font name whose internal number is |f|@>;
end;@/
@t\4@>@<Declare the procedure called |load←fonts|@>@;

@ @<Output the font name whose internal number is |f|@>=
for k:=str←start[font←area[f]] to str←start[font←area[f]+1]-1 do
  dvi←out(str←pool[k]);
for k:=str←start[font←name[f]] to str←start[font←name[f]+1]-1 do
  dvi←out(str←pool[k])

@ The |typeset| subroutine typesets any eight-bit character.

@p procedure typeset(@!c:eight←bits);
begin if c>=128 then dvi←out(set1);
dvi←out(c);
end;

@ The |dvi←scaled| subroutine takes a |real| value |x| and outputs
a decimal approximation to |x/unity|, correct to one decimal place.

@p procedure dvi←scaled(@!x:real);
var @!n:integer; {an integer approximation to |10*x/unity|}
@!m:integer; {the integer part of the answer}
@!k:integer; {the number of digits in |m|}
begin n:=round(x/6553.6);
if n<0 then
  begin dvi←out("-"); n:=-n;
  end;
m:=n div 10; k:=0;
repeat incr(k); buffer[k]:=(m mod 10)+"0"; m:=m div 10;
until m=0;
repeat dvi←out(buffer[k]); decr(k);
until k=0;
if n mod 10 <> 0 then
  begin dvi←out("."); dvi←out((n mod 10)+"0");
  end;
end;

@ At the end of the program, we must finish things off by writing the
post\-amble. An integer variable~|k| will be declared for use by this routine.

@<Finish the \.{DVI} file and |goto final←end|@>=
begin dvi←out(post); {beginning of the postamble}
dvi←four(last←bop); last←bop:=dvi←offset+dvi←ptr-5; {|post| location}
dvi←four(25400000); dvi←four(473628672); {conversion ratio for sp}
dvi←four(1000); {magnification factor}
dvi←four(max←v); dvi←four(max←h);@/
dvi←out(0); dvi←out(3); {`\\{max\←push}' is said to be 3}@/
dvi←out(total←pages div 256); dvi←out(total←pages mod 256);@/
if not fonts←not←loaded then
  for k:=title←font to logo←font do
    if length(font←name[k])>0 then dvi←font←def(k);
dvi←out(post←post); dvi←four(last←bop); dvi←out(dvi←id←byte);@/
k:=4+((dvi←buf←size-dvi←ptr) mod 4); {the number of 223's}
while k>0 do
  begin dvi←out(223); decr(k);
  end;
@<Empty the last bytes out of |dvi←buf|@>;
goto final←end;
end

@* Rudimentary typesetting.
One of \.{GFtoDVI}'s little duties is to be a mini-\TeX: It must be able
to typeset the equivalent of `\.{\\hbox\{}$\langle$string$\rangle$\.\}' for
a given string of ASCII characters, using either the title font or the
label font.

The |hbox| procedure does this. The width, height, and depth of the
box defined by string~|s| in font~|f| are computed in global variables
|box←width|, |box←height|, and |box←depth|.

If parameter |send←it| is |false|, we merely want to know the box dimensions.
Otherwise typesetting commands are also sent to
the \.{DVI} file; we assume in this case that font |f| has already been
selected in the \.{DVI} file as the current font.


@p procedure hbox(@!s:str←number;@!f:internal←font←number;@!send←it:boolean);
label continue, done;
var @!k,@!max←k:pool←pointer; {indices into |str←pool|}
@!i,@!j:four←quarters; {font information words}
@!c:eight←bits; {a character code}
@!r:quarterword; {ligature or kern must match this}
@!l:0..font←mem←size; {pointer to lig/kern instruction}
@!kern←amount:scaled; {extra space to be typeset}
@!hd:eight←bits; {height and depth indices for a character}
@!x:scaled; {temporary register}
begin box←width:=0; box←height:=0; box←depth:=0;@/
k:=str←start[s]; max←k:=str←start[s+1];
while k<max←k do @<Typeset character |str←pool[k]|, possibly making a
  ligature with the following character or characters, and advance |k|@>;
end;

@ @<Glob...@>=
@!box←width:scaled; {width of box constructed by |hbox|}
@!box←height:scaled; {height of box constructed by |hbox|}
@!box←depth:scaled; {depth of box constructed by |hbox|}

@ @<Typeset character |str←pool[k]|...@>=
begin c:=str←pool[k]; incr(k); kern←amount:=0;
if c=" " then kern←amount:=space(f)
else if c>=font←bc[f] then if c<=font←ec[f] then
  begin continue: i:=char←info(f)(c);
  if char←exists(i) then
    begin if char←tag(i)=lig←tag then if k<max←k then
      @<Look for possible ligature or kern;
       |goto continue| if |c| has been replaced by a ligature@>;
    @<Typeset character |c|@>;
    end;
  end;
if kern←amount<>0 then
  begin box←width:=box←width+kern←amount;
  if send←it then
    begin dvi←out(right4); dvi←four(kern←amount);
    end;
  end;
end

@ @<Look for possible lig...@>=
begin r:=qi(str←pool[k]);
l:=lig←kern←start(f)(i);
repeat j:=font←info[l].qqqq;
if next←char(j)=r then
  if op←bit(j)<qi(kern←flag) then
    begin c:=qo(rem←byte(j)); incr(k); goto continue;
    end
  else  begin kern←amount:=char←kern(f)(j); goto done;
    end;
incr(l);
until stop←bit(j)>=qi(stop←flag);
done:end


@ @<Typeset character |c|@>=
box←width:=box←width+char←width(f)(i);
hd:=height←depth(i);
x:=char←height(f)(hd);
if x>box←height then box←height:=x;
x:=char←depth(f)(hd);
if x>box←depth then box←depth:=x;
if send←it then typeset(c);

@* Gray fonts.
The proof diagrams constructed by \.{GFtoDVI}
can be regarded as an array of rectangles, where each rectangle is either
blank or filled with a special symbol that we shall call $x$. A blank
rectangle represents a white pixel, while $x$ represents a black pixel.
Additional labels and reference lines are often superimposed on this
array of rectangles; hence it is usually best to choose a symbol $x$ that
has a somewhat gray appearance, although any symbol can actually be used.

In order to construct such proofs, \.{GFtoDVI} needs to work with
a special type of font known as a ``gray font''; it's possible to
obtain a wide variety of different sorts of proofs by using different
sorts of gray fonts. The next few paragraphs
explain exactly what gray fonts are supposed to contain.
@↑gray fonts@>

@ The simplest gray font contains only two characters, namely $x$
and a another symbol that is used for dots that identify key points.
If proofs with relatively large pixels are desired, a two-character
gray font is all that's needed. However, if the pixel size is to be
relatively small, practical considerations make a two-character
font too inefficient, since it requires the typesetting of tens
of thousands of tiny little characters; printing device drivers
rarely work very well when they are presented with data that is
so different from ordinary text. Therefore a gray font with small
pixels usually has a number of characters that replicate $x$ in
such a way that comparatively few characters actually need to be
typeset.

Since many printing devices are not able to cope with
arbitrarily large or complex characters, it is not possible for a
single gray font to work well on all machines. In fact,
$x$ must have a width that is an even multiple of the printing
device's unit of horizontal position, since rounding the positions of grey
characters would otherwise produce unsightly streaks on proof output.
Thus, there is no way to make the gray font as device independent as
the rest of the system, in the sense that we would expect approximately
identical output on machines with different resolution. Fortunately,
proof sheets are rarely considered to be final documents; hence
\.{GFtoDVI} is set up to provide results that adapt suitably to
local conditions.

@ This understood, we can now take a look at what \.{GFtoDVI} expects to
see in a gray font. The character~$x$ always appears in position~1. It
must have positive height~$h$ and positive width~$w$; its depth
and italic correction are ignored.

Positions 2--120 of a gray font are reserved for special combinations
of $x$'s and blanks, stacked on top of each other. None of these character
codes need be present in the font; but if they are, the slots should be
occupied by characters of width~$w$ that have certain configurations of
$x$'s and blanks, prescribed for each character position. For example,
position~3 of the font should either contain no character at all,
or it should contain a character consisting of two $x$'s one above
the other; one of these $x$'s should appear immediately above the
baseline, and the other should appear immediately below.

It will be convenient to use a horizontal notation like `\.{XOXXO}'
to stand for a vertical stack of $x$'s and blanks. The convention
will be that the stack is built from bottom to top, and the topmost
rectangle should sit on the baseline. Thus, `\.{XOXXO}' stands
actually for a character of depth~$4h$ that looks like this:
$$\vcenter{\halign{\hfil#\hfil\cr
blank\cr
$x$\rlap{\qquad\raise8pt\hbox{\smash{\hbox{$\longleftarrow$ baseline}}}}\cr
$x$\cr
blank\cr
$x$\cr
}}$$
We use a horizontal notation instead of a vertical one because column
vectors take too much space, and because the horizontal notation corresponds
to binary numbers in a convenient way.

Positions 1--63 of a gray font are reserved for the patterns \.X, \.{XO},
\.{XX}, \.{XOO}, \.{XOX}, \dots, \.{XXXXXX}, just as in the normal
binary notation of the numbers 1--63. Positions 64--70 are reserved for
the special patterns \.{XOOOOOO}, \.{XXOOOOO}, \dots, \.{XXXXXXO},
\.{XXXXXXX} of length seven; positions 71--78 are, similarly, reserved for
the length-eight patterns \.{XOOOOOOO} through \.{XXXXXXXX}. The
length-nine patterns \.{XOOOOOOOO} through \.{XXXXXXXXX} are assigned
to positions 79--87, the length-ten patterns to positions 88--97,
the length-eleven patterns to positions 98--108, and the length-twelve
patterns to positions 109--120.

The following program sets a global array |c[1..120]| to the bit patterns
just described. Another array |d[1..120]| is set to contain only the next
higher bit; this determines the depth of the corresponding character.

@<Set init...@>=
c[1]:=1; d[1]:=2; two←to←the[0]:=1; m:=1;
for k:=1 to 13 do two←to←the[k]:=2*two←to←the[k-1];
for k:=2 to 6 do @<Add a full set of |k|-bit characters@>;
for k:=7 to 12 do @<Add special |k|-bit characters of the form \.{X..XO..O}@>;

@ @<Glob...@>=
@!c:array[1..120] of 1..4095; {bit patterns for a gray font}
@!d:array[1..120] of 2..4096; {the superleading bits}
@!two←to←the:array[0..13] of 1..8192; {powers of 2}

@ @<Add a full set of |k|-bit...@>=
begin n:=two←to←the[k-1];
for j:=0 to n-1 do
  begin incr(m); c[m]:=m; d[m]:=n+n;
  end;
end

@ @<Add special |k|-bit...@>=
begin n:=two←to←the[k-1];
for j:=k downto 1 do
  begin incr(m); d[m]:=n+n;
  if j=k then c[m]:=n
  else c[m]:=c[m-1]+two←to←the[j-1];
  end;
end

@ Position 0 of a gray font is reserved for the ``dot'' character, which
should have positive height~$h'$ and positive width~$w'$. When \.{GFtoDVI}
wants to put a dot at some place $(x,y)$ on the figure, it positions
the dot character so that its reference point is at $(x,y)$. The
dot will be considered to occupy a rectangle $(x+\delta,y+\epsilon)$
for $-w'\leq\delta\leq w'$ and $-h'\leq\epsilon\leq h'$; the rectangular
box for a label will butt up against the rectangle enclosing the dot.

@ All other character positions of a gray font (namely, positions 121--255)
are unreserved, in the sense that they have no predefined meaning.
But \.{GFtoDVI} may access them via the ``character list'' feature of
\.{TFM} files, starting with any of the characters in positions
1--120. In such a case each succeeding character in a list should be
equivalent to two of its predecessors, horizontally adjacent to each other.
For example, in a character list like
$$53,\;121,\;122,\;123$$
character 121 will stand for two 53's, character 122 for two 121's (i.e.,
four 53's), and character 123 for two 122's (i.e., eight 53's). Since
position~53 contains the pattern \.{XXOXOX}, character~123 in this example
would have height~$h$, depth~$5h$, and width~$8w$, and it would stand for
the pattern
$$\vcenter{\halign{&$\hfil#\hfil$\cr
x&x&x&x&x&x&x&x\cr
&&&&&&&\cr
x&x&x&x&x&x&x&x\cr
&&&&&&&\cr
x&x&x&x&x&x&x&x\cr
x&x&x&x&x&x&x&x\cr}}$$
Such a pattern is, of course, rather unlikely to occur in a \.{GF} file,
but \.{GFtoDVI} would be able to use if it were present. Designers
of gray fonts should provide characters only for patterns that they think
will occur often enough to make the doubling worthwhile. For example,
the character in position 120 (\.{XXXXXXXXXXXX}), or whatever is the
tallest stack of $x$'s present in the font, is a natural candidate for
repeated doubling.

Here's how \.{GFtoDVI} decides what characters of the gray font will be used,
given a configuration of black and white pixels: If there are no black
pixels, stop. Otherwise look at the top row that contains at least one
black pixel, and the eleven rows that follow. For each such column,
find the largest~$k$ such that $1\leq k\leq120$ and the gray font contains
character~$k$ and the pattern assigned to position~$k$ appears in the
given column. Typeset character $k$ (unless no such character exists)
and erase the corresponding black pixels; use doubled characters,
if they are present in the gray font, if two or more consecutive equal
characters need to be typeset. Repeat the same process on the remaining
configuration, until all the black pixels have been erased.

If all characters in positions 1--120 are present, this process is guaranteed to
take care of at least six rows each time; and it usually takes care of
twelve, since all patterns that contain at most one ``run'' of $x$'s
are present.

@ Fonts have optional parameters, as described in Appendix~F of {\sl The
\TeX book}, and some of these are important in gray fonts. The
slant parameter~$s$, if nonzero, will cause \.{GFtoDVI} to skew its
output; in this case the character $x$ will presumably be a parallelogram
with a corresponding slant, rather than the usual rectangle. \MF's
coordinate $(x,y)$ will appear in physical position $(xw+yhs,yh)$
on the proofsheets.

Parameter number~8 of a gray font specifies the thickness of rules
that go on the proofs. If this parameter is zero, \TeX's default
rule thickness (0.4\thinspace pt) will be used.

The other parameters of a gray font are ignored by \.{GFtoDVI}, but
it is conventional to set the space parameter to~$w$ and the
xheight parameter to~$h$.

@ For best results the designer of a gray font should choose $h$ and~$w$
so that the user's \.{DVI}-to-hardcopy software will not make any
rounding errors. Furthermore, the dot should be an even number~$2m$ of
pixels in diameter, and the rule thickness should work out to an
even number~$2n$ of pixels; then the dots and rules will be centered on
the correct positions, in case of integer coordinates. Gray fonts
are almost always intended for particular output devices, even though
`\.{DVI}' stands for `device independent'; we use \.{DVI} files for \MF\
proofs chiefly because software to print \.{DVI} files is already in place.

@* Slant fonts.
\.{GFtoDVI} also makes use of another special type of font, if it is
necessary to typeset slanted rules. The format of such  so-called
``slant fonts'' is quite a bit simpler than the format of gray fonts.

A slant font should contain exactly $n$ characters, in positions 1 to~$n$,
where the character in position~$k$ represents a slanted line $k$ units
tall, starting at the baseline. These lines all have a fixed slant ratio~$s$.

The following simple algorithm is used to typeset a rule that is $m$ units
high: Compute $q=\lceil m/n\rceil$; then typeset $q$~characters of
approximately equal size, namely $(m\bmod q)$ copies of character number
$\lceil m/q\rceil$ and $q-(m\bmod q)$ copies of character number
$\lfloor m/q\rfloor$. For example, if $n=15$ and $m=100$, we have $q=7$;
a 100-unit-high rule will be composed of 7~pieces, using characters
14,~14, 14, 14, 14, 15,~15.

@<Glob...@>=
@!rule←slant:real; {the slant ratio $s$ in the slant font,
  or zero if there is no slant font}
@!slant←n:integer; {the number of characters in the slant font}
@!slant←unit:real; {the number of scaled points in the slant font unit}
@!slant←reported:real; {invalid slant ratio reported to the user}

@ \.{GFtoDVI} looks only at the height of character $n$, so the \.{TFM} file
need not be accurate about the heights of the other characters. (This is
fortunate, since \.{TFM} format allows at most 16 different heights per font.)

The width of character~$k$ should be $k/n$ times $s$ times the height of
character~$n$.

The slant parameter of a slant file should be $s$. It is customary to
set the |default←rule←thickness| parameter (number~8) to the thickness of
the slanted rules, but \.{GFtoDVI} doesn't look at it.

@ For best results on a particular output device, it is usually wise to
choose the `unit' in the above discussion to be an integer number of pixels,
and to make it no larger than the default rule thickness in the gray font
being used.

@ @<Initialize glob...@>=
if length(font←name[slant←font])=0 then rule←slant:=0.0
else  begin rule←slant:=slant(slant←font)/unity;
  slant←n:=font←ec[slant←font];
  i:=char←info(slant←font)(slant←n);
  slant←unit:=char←height(slant←font)(height←depth(i))/slant←n;
  end;
slant←reported:=0.0;

@ The following error message is given when an absent slant has been
requested.

@p procedure slant←complaint(@!r:real);
begin if abs(r-slant←reported)>0.001 then
  begin print←nl('Sorry, I can''t make diagonal rules of slant ',r:10:5,'!');
@.Sorry, I can't...@>
  slant←reported:=r;
  end;
end;

@* Allocation of labels.
OK---the preliminary spadework has now been done. We're ready at last
to concentrate on \.{GFtoDVI}'s {\sl raison d'\↑↑Detre}.

One of the most interesting tasks remaining is to make
a ``map'' of the labels that have been allocated.
A 2D search tree is maintained for this purpose. Each node of the tree
represents a rectangular region and contains the following eleven fields:
\smallskip\hang\noindent
|xl|, |xr|, |yt|, and |yb| are the left, right, top, and bottom of the
rectangle, expressed in \.{DVI} coordinates. (This program uses scaled
points as \.{DVI} coordinates. Since \.{DVI} coordinates increase as one
moves down the page, |yb| will be greater than |yt|.)
\smallskip\hang\noindent
|xx| and |yy| are the coordinates of the reference point of a box to be
typeset from this node, again in \.{DVI} coordinates.
\smallskip\hang\noindent
|left|, |right|, and |mid| are pointers to descendents of this node.
On even-numbered levels of the tree, |left[p]| is for rectangles~|q|
with |xr[q]<=xl[p]|, |right[p]| is for |xl[q]>=xr[p]|, and |mid[p]| is
for all other rectangles inserted after~|p|. On odd-numbered levels
the conventions are similar, but |yt| and |yb| play the respective
r\↑↑Doles of |xl| and~|xr|.
\smallskip\hang\noindent
|info| is the number of a string associated with this node; or it equals
the negative of such a number, if this node represents a dot instead of a label.
\smallskip\hang\noindent
|dl←tie| is used initially for cross referencing dot nodes and label nodes
with |dl←tie[p]:=q| and |dlnottie[q]:=p| at the time when a dot node |q| is
gotten to correspond to the label node |p|. This array is also defined as
|oct| for dots and is used to contain the octant occupied by each dot's
nearest neighbor and finally it is set to zero for dots when their
associated labels have been printed so that later we can distinguish dots
whose labels have been printed (for reporting distances to the nearest
labeled dot in the overflow area).

We will also find it convenient to have two quite different nearest-dot
routines, one called |nearest←dot| for use in helping to locate the labels
that go on the figure, and the second, |n←l←dot|, for the overflow
reporting where we will want to report distances to the nearest labeled
dot.  At the moment, |nearest←dot| is an n-squared iterative procedure
that actually takes considerably less computing time for a 47 dot example
than did the first tried 2-D recursive routine using a modified form of
the |n←l←dot| routine.  The reason for this is thought to be because of
the time used in procedure calls for the recursive routine, and because of
the complications introduced by a desire to modify the sequence of
considering possible label locations for overlapping dots.
\smallskip\noindent

The eleven fields of a node appear in eleven global arrays. The root of the
tree is pointed to by a global variable called |root|. Null pointers
are denoted by |null|, which is zero. All nodes whose address is greater
than |max←node| are unused (i.e., available).

@d null=0

@<Types ...@>=
@!tree←pointer=null..max←labels;

@ Before the 2D tree is built, the |right| fields are used to make linked lists.
Also note that the |left| fields for the label nodes are called |lab←typ|
and are used to differentiate between different |label←type| requests.

@d oct==dl←tie {the octant occupied by a dot's nearest dot neighbor}

@ @<Glob...@>=
@!xl,@!xr,@!yt,@!yb:array[1..max←labels] of scaled; {boundary coordinates}
@!xx,@!yy:array[1..max←labels] of scaled; {reference coordinates}
@!left,@!mid:array[1..max←labels] of tree←pointer; {descendants}
@!right:array[0..max←labels] of tree←pointer; {descendants or links}
@!dl←tie:array[0..max←labels] of tree←pointer; {dot-label cross pointers}
@!ov←flag:boolean; {to signal need for an overflow listing}
@!info:array[1..max←labels] of integer; {associated strings}
@!root:tree←pointer; {root of the 2D tree}
@!q←save:tree←pointer; {temporary}
@!max←node:tree←pointer; {the largest node in use}


@ It's easy to allocate a new node (unless no more room is left):

@p function get←avail:tree←pointer;
begin if max←node=max←labels then abort('Too many labels and/or rules!');
@.Too many labels@>
incr(max←node); get←avail:=max←node;
end;

@ The |tree←ins| procedure inserts a new node |p| into the tree, assuming
that |xl[p]|, |xr[p]|, |yt[p]|, and |yb[p]| have been set to the boundaries
of a rectangle.

@d ins←move(#)==if #[q]<>null then q:=#[q]
  else  begin #[q]:=p; return;
    end

@p procedure tree←ins(@!p:tree←pointer);
label exit;
var @!q:tree←pointer; {for tree traversal}
begin q:=root; left[p]:=null; mid[p]:=null; right[p]:=null;
if q=null then root:=p
else loop@+begin if xl[q]>=xr[p] then ins←move(left)
  else if xl[p]>=xr[q] then ins←move(right)
  else ins←move(mid);
  if yt[q]>=yb[p] then ins←move(left)
  else if yt[p]>=yb[q] then ins←move(right)
  else ins←move(mid);
  end;
exit:end;

@ The |overlap| subroutine determines (recursively) whether or not
a rectangle whose boundaries are specified by |xl[p]|, |xr[p]|,
|yt[p]|, and |yb[p]| has a nonempty intersection with some rectangle
in the tree.

It is implemented in terms of two other subroutines called
|even←overlap| and |odd←overlap|, which check for overlaps
in subtrees whose root appears at even or odd levels, respectively.
@↑recursion@>

@p function@?even←overlap(@!p:tree←pointer):boolean; forward;@t\2@>@/
function@?odd←overlap(@!p:tree←pointer):boolean; forward;@t\2@>@/
function overlap(@!p:tree←pointer):boolean;
begin x←left:=xl[p]; x←right:=xr[p]; y←top:=yt[p]; y←bot:=yb[p];
overlap:=even←overlap(root);
end;

@ @<Glob...@>=
@!x←left,@!x←right,@!y←top,@!y←bot:scaled; {boundaries to test for overlap}

@ The |mid| branch is tried before |left| or |right|, because overlaps
are more likely to be found there.

@d even←overlap←found==begin even←overlap:=true; return;@+end

@p function even←overlap; {this was declared |forward| above}
label exit;
begin if p<>null then {look for an overlap in the subtree rooted at |p|}
  begin if x←left<xr[p] then if x←right>xl[p] then
   if y←top<yb[p] then if y←bot>yt[p] then even←overlap←found;
  if odd←overlap(mid[p]) then even←overlap←found;
  if x←left<xl[p] then if odd←overlap(left[p]) then even←overlap←found;
  if x←right>xr[p] then if odd←overlap(right[p]) then even←overlap←found;
  end;
even←overlap:=false;
exit:end;

@ @d odd←overlap←found==begin odd←overlap:=true; return;@+end

@p function odd←overlap; {this was declared |forward| above}
label exit;
begin if p<>null then {look for an overlap in the subtree rooted at |p|}
  begin if x←left<xr[p] then if x←right>xl[p] then
   if y←top<yb[p] then if y←bot>yt[p] then odd←overlap←found;
  if even←overlap(mid[p]) then odd←overlap←found;
  if y←top<yt[p] then if even←overlap(left[p]) then odd←overlap←found;
  if y←bot>yb[p] then if even←overlap(right[p]) then odd←overlap←found;
  end;
odd←overlap:=false;
exit:end;

@ Tree nodes that represent dots instead of labels satisfy the following
constraints:
$$\vcenter{\halign{#\hfil&\quad#\hfil\cr
|info[p]<0;|\cr
|xl[p]=xx[p]-dot←width|,&|xr[p]=xx[p]+dot←width|;\cr
|yt[p]=yy[p]-dot←height|,&|yb[p]=yy[p]+dot←height|.\cr}}$$

The |n←l←dot| subroutine finds a dot node whose reference point is as
close as possible to a given position. More precisely, the ``nearest'' node
minimizes $d(q)=\max\bigl(\vert |xx|[q]-|xx|[p]\vert,
  \vert |yy|[q]-|yy|[p]\bigr)$ over all dot nodes nodes~|q|
whose labels have already been printed.

After |n←l←dot| has been called, the global variable |q←dot| will point
to a node that minimizes |d(q)|, and |d←dot| will be this minimum distance,
assuming that there is at least one dot node in the tree. A pair of
mutually recursive routines are used in this computation, by analogy with
the ideas of |overlap|.

Actually, we will have to have two separate routines,
the first that considers all dots, for use in finding the optimum direction
for locating a label that we hope to be able to print on the figure, and a
second routine for finding the nearest labelled dot as an overflow label
referencing point. This second
selection is made easy by the fact that the value of |oct| for these dots
will have been set to zero at the time the labels were printed.

@ @<Glob...@>=
@!q←dot:tree←pointer; {a nearest dot}
@!first←dot:tree←pointer; {the first assigned dot}
@!last←dot:tree←pointer; {the last assigned dot}

@ We first list the version that considers all dots.  Special handling is
effected for those cases where there are two overlapping dots, since to locate
one label as far as possible away from the nearest non-overlapping dot would
frequently result in permitting only one of the labels for the overlapping
dots to be shown.  The larger of the two rectangular coordinates of the
inter-dot distance is used in the determination of the nearest dot as this
is found to be the controlling factor for locating labels unambiguously.

@p procedure nearest←dot;
var i,j,d,d←min,x←min,y←min : integer;
ov←flag: boolean;
begin
for i:=first←dot to last←dot do
begin
d←min:=max←int; ov←flag:=false;
for j:=first←dot to last←dot do
begin if j <> i then
    begin if abs(xx[j]-xx[i]) > abs(yy[j]-yy[i]) then
          d:=abs(xx[j]-xx[i]) else d:=abs(yy[j]-yy[i]);
    if d=0 then ov←flag:=true else
    if d<d←min then
        begin d←min:=d; x←min:=xx[j]-xx[i]; y←min:=yy[j]-yy[i];
  end;
    end;
end;
if y←min<=0 then @<The |nearest←dot| is above@>
  else @<The |nearest←dot| is below@>;
if ov←flag=true then oct[i]:=oct[i]+8; {Special handling for overlapping dots}
end;
end;


@ @<The |nearest←dot| is above@>=
    begin
    if x←min>0 then {in the first quadrant}
  begin
  if x←min > -y←min then oct[i]:=1 else oct[i]:=2;
  end else {in the second quadrant}
  begin
  if -y←min >= -x←min then oct[i]:=3 else oct[i]:=4;
  end;
    end

@ @<The |nearest←dot| is below@>=
    begin
    if x←min < 0 then {in the third quadrant}
  begin
  if -x←min > y←min then oct[i]:=5 else oct[i]:=6;
  end else {in the fourth quadrant}
  begin
  if y←min > x←min then oct[i]:=7 else oct[i]:=8;
  end;
    end

@ Now we come to the second procedure, |n←l←dot|, to compute the distance
to the nearest labeled dot, making use of the fact that the value of
|oct[p]| for these dots have been set to zero by this time.

@↑recursion@>
@p procedure@?even←n←l←dot(@!p:tree←pointer); forward;@t\2@>@/
procedure@?odd←n←l←dot(@!p:tree←pointer); forward;@t\2@>@/
procedure n←l←dot(@!p:tree←pointer);
begin x←dot:=xx[p]; y←dot:=yy[p]; d←dot:=@'4000000000;
even←n←l←dot(root);
end;

@ @<Glob...@>=
@!x←dot,@!y←dot:scaled; {coordinates in a |nearest←dot| search}
@!d←dot:scaled; {distance to the nearest dot}

@ The search goes faster if we try the most plausible branches first;
so we descend to |mid| before going to the |left| or |right|.

@p procedure even←n←l←dot; {declared |forward| above}
begin if p<>null then {look for improvements in the subtree rooted at |p|}
  begin if info[p]<0 then  {it is a dot}
  if oct[p]=0 then  {and it has been labeled}
  if abs(xx[p]-x←dot)<d←dot then
   if abs(yy[p]-y←dot)<d←dot then
    begin q←dot:=p; d←dot:=abs(xx[p]-x←dot);
    if d←dot<abs(yy[p]-y←dot) then d←dot:=abs(yy[p]-y←dot);
    end;
  odd←n←l←dot(mid[p]);
  if xl[p]-dot←width>x←dot-d←dot then odd←n←l←dot(left[p]);
  if xr[p]+dot←width<x←dot+d←dot then odd←n←l←dot(right[p]);
  end;
end;
@#
procedure odd←n←l←dot; {declared |forward| above}
begin if p<>null then {look for improvements in the subtree rooted at |p|}
  begin if info[p]<0 then  {it is a dot}
  if oct[p]=0 then {and it has been labeled}
  if abs(xx[p]-x←dot)<d←dot then
   if abs(yy[p]-y←dot)<d←dot then
    begin q←dot:=p; d←dot:=abs(xx[p]-x←dot);
    if d←dot<abs(yy[p]-y←dot) then d←dot:=abs(yy[p]-y←dot);
    end;
  even←n←l←dot(mid[p]);
  if yt[p]-dot←height>y←dot-d←dot then even←n←l←dot(left[p]);
  if yb[p]+dot←height<y←dot+d←dot then even←n←l←dot(right[p]);
  end;
end;

@* Doing the labels.
Each ``character'' in the \.{GF} file is preceded by a number of special
commands that define labels, titles, rules, etc. We store these away,
to be considered later when the |boc| command appears. The |boc|
command establishes the size information by which labels and rules
can be positioned, so we spew out the label information as soon as
we see the |boc|. The gray pixels will be typeset after all the labels
for a particular character have been finished.

@ Here is the part of \.{GFtoDVI} that stores information preceding a~|boc|.
It comes into play when |cur←gf| is between |xxx1| and~|no←op|, inclusive.

@d font←change(#)==if fonts←not←loaded then
    begin #; end
  else print←nl('(Tardy font change will be ignored (byte ',
@.Tardy font change...@>
    cur←loc:1,')!)')

@<Process a no-op command@>=
begin k:=interpret←xxx;
case k of
no←operation: do←nothing;
title←font,label←font,gray←font,slant←font:font←change(font←name[k]:=cur←string;
  font←area[k]:=null←string;font←at[k]:=0;init←str←ptr:=str←ptr);
title←font+area←code,label←font+area←code,gray←font+area←code,
  slant←font+area←code:@|
  font←change(font←area[k-area←code]:=cur←string;init←str←ptr:=str←ptr);
title←font+at←code,label←font+at←code,gray←font+at←code,
  slant←font+at←code:@|
  font←change(font←at[k-at←code]:=get←yyy;init←str←ptr:=str←ptr);
rule←thickness←code:rule←thickness:=get←yyy;
rule←code:@<Store a rule@>;
offset←code:@<Override the offsets@>;
x←offset←code:x←offset:=get←yyy;
y←offset←code:y←offset:=get←yyy;
title←code:@<Store a title@>;
null←string:@<Store a label@>;
end; {there are no other cases}
end

@ The following quantities are cleared just before reading the
\.{GF} commands pertaining to a character.

@<Glob...@>=
@!rule←thickness:scaled; {the current rule thickness
  (zero means use the default)}
@!offset←x,@!offset←y:scaled; {the current offsets for images}
@!x←offset,@!y←offset:scaled; {the current offsets for labels}
@!pre←min←x,@!pre←max←x,@!pre←min←y,@!pre←max←y:scaled;
  {extreme values of coordinates preceding a character}

@ @<Initialize variables for the next character@>=
rule←thickness:=0;
offset←x:=0; offset←y:=0; x←offset:=0; y←offset:=0;
pre←min←x:=@'2000000000; pre←max←x:=-@'2000000000;
pre←min←y:=@'2000000000; pre←max←y:=-@'2000000000;

@ @<Override the offsets@>=
begin offset←x:=get←yyy; offset←y:=get←yyy;
end

@ Rules that will need to be drawn are kept in a linked list accessible
via |rule←ptr|, in last-in-first-out order.  The tree-node area of memory
serves double duty; i.e., we use it for rules as well as for labels, even
those these nodes will never be part of the 2D tree.

@d x0==xl {starting |x| coordinate of a stored rule}
@d y0==yt {starting |y| coordinate (in scaled \MF\ pixels)}
@d x1==xr {ending |x| coordinate of a stored rule}
@d y1==yb {ending |y| coordinate of a stored rule}
@d rule←size==xx {thickness of a stored rule, in scaled points}

@<Glob...@>=
@!rule←ptr:tree←pointer; {top of the stack of remembered rules}

@ @<Initialize variables for the next character@>=
rule←ptr:=null; max←node:=0;

@ @<Store a rule@>=
begin p:=get←avail; right[p]:=rule←ptr; rule←ptr:=p;@/
x0[p]:=get←yyy; y0[p]:=get←yyy; x1[p]:=get←yyy; y1[p]:=get←yyy;
if x0[p]<pre←min←x then pre←min←x:=x0[p];
if x0[p]>pre←max←x then pre←max←x:=x0[p];
if y0[p]<pre←min←y then pre←min←y:=y0[p];
if y0[p]>pre←max←y then pre←max←y:=y0[p];
if x1[p]<pre←min←x then pre←min←x:=x1[p];
if x1[p]>pre←max←x then pre←max←x:=x1[p];
if y1[p]<pre←min←y then pre←min←y:=y1[p];
if y1[p]>pre←max←y then pre←max←y:=y1[p];
rule←size[p]:=rule←thickness;
end

@ Titles and labels are, likewise, stored temporarily in the tree area.
In this case the list is first-in-first-out.
Variables |title←tail| and |label←tail| point to the most recently inserted
title or label; variables |title←head| and |label←head| will
point to the beginning of the list.

@d lab←typ==left {the type of a stored label (|"/"..."8"|)}
@d label←head==right[0] {this is a coding trick; do you get it?}

@<Glob...@>=
@!label←tail:tree←pointer; {tail of the queue of remembered labels}
@!title←head,@!title←tail:tree←pointer; {head and tail of the queue for titles}

@ @<Initialize variables for the next char...@>=
title←head:=null; title←tail:=null; label←tail:=0; root:=null;

@ @<Store a title@>=
begin p:=get←avail; info[p]:=cur←string;
if title←head=null then title←head:=p
else right[title←tail]:=p;
title←tail:=p;
end

@ @<Store a label@>=
if (label←type<"/")or(label←type>"8") then
  print←nl('Bad label type precedes byte ',cur←loc:1,'!')
@.Bad label type...@>
else  begin p:=get←avail; right[label←tail]:=p; label←tail:=p;@/
  lab←typ[p]:=label←type; info[p]:=cur←string;@/
  xx[p]:=get←yyy; yy[p]:=get←yyy;
  if xx[p]<pre←min←x then pre←min←x:=xx[p];
  if xx[p]>pre←max←x then pre←max←x:=xx[p];
  if yy[p]<pre←min←y then pre←min←y:=yy[p];
  if yy[p]>pre←max←y then pre←max←y:=yy[p];
  end

@ The process of ferreting everything away comes to an abrupt halt
when a |boc| command is sensed. The following steps are performed
at such times:

@<Process a character@>=
begin check←fonts;
@<Finish reading the parameters of the |boc|@>;
@<Get ready to convert \MF\ coordinates to \.{DVI} coordinates@>;
@<Output the |bop| and the title line@>;
print('[',total←pages:1); update←terminal; {print a progress report}
@<Output all rules for the current character@>;
@<Output all labels for the current character@>;
do←pixels;
dvi←out(eop); {finish the page}
@<Adjust the maximum page width@>;
print(']'); update←terminal;
end

@ @<Finish reading the parameters of the |boc|@>=
if cur←gf=boc then
  begin fam:=signed←quad; {read the character code}
  char←code:=fam mod 256;
  if char←code<0 then char←code:=char←code+256;
  fam:=(fam-char←code) div 256;
  k:=signed←quad; {read and ignore the prev pointer}
  min←x:=signed←quad; {read the minimum $x$ coordinate}
  max←x:=signed←quad; {read the maximum $x$ coordinate}
  min←y:=signed←quad; {read the minimum $y$ coordinate}
  max←y:=signed←quad; {read the maximum $y$ coordinate}
  end
else  begin fam:=0; char←code:=get←byte;@/
  min←x:=get←byte; max←x:=get←byte; min←x:=max←x-min←x;
  min←y:=get←byte; max←y:=get←byte; min←y:=max←y-min←y;
  end;
if max←x-min←x>widest←row then abort('Character too wide!')
@.Character too wide@>

@ @<Glob...@>=
@!char←code,@!fam:integer; {the current character code and family}
@!min←x,@!max←x,@!min←y,@!max←y:integer; {character boundaries, in pixels}
@!x,@!y:integer; {current painting position, in pixels}
@!z:integer; {initial painting position in row, relative to |min←x|}

@ \MF\ coordinates $(x,y)$ are converted to \.{DVI} coordinates by the
following routine. Real values |x←ratio|, |y←ratio|, and |slant←ratio|
will have been calculated based on the gray font; |scaled| values
|delta←x| and |delta←y| will have been computed so that, in the absence
of slanting and offsets, \MF\ point |(min←x,max←y+1)| will correspond
to \.{DVI} coordinate $(0,50\,\rm pt)$.

@p procedure convert(@!x,@!y:scaled);
begin x:=x+x←offset; y:=y+y←offset;
dvi←y:=-round(y←ratio*y)+delta←y;
dvi←x:=round(x←ratio*x+slant←ratio*y)+delta←x;
end;

@ @<Glob...@>=
@!x←ratio,@!y←ratio,@!slant←ratio:real; {conversion factors}
@!unsc←x←ratio,@!unsc←y←ratio,@!unsc←slant←ratio:real;
  {ditto, times |unity|}
@!fudge←factor:real; {unconversion factor}
@!delta←x,@!delta←y:scaled; {magic constants used by |convert|}
@!dvi←x,@!dvi←y:scaled; {outputs of |convert|, in scaled points}
@!over←col:scaled; {overflow labels start here}
@!page←height,page←width:scaled; {size of the current page}

@ @<Initialize global variables that depend on the font data@>=
i:=char←info(gray←font)(1);
if not char←exists(i) then abort('Missing pixel char!');
@.Missing pixel char@>
unsc←x←ratio:=char←width(gray←font)(i);
x←ratio:=unsc←x←ratio/unity;
unsc←y←ratio:=char←height(gray←font)(height←depth(i));
y←ratio:=unsc←y←ratio/unity;
unsc←slant←ratio:=slant(gray←font)*y←ratio;
slant←ratio:=unsc←slant←ratio/unity;
if x←ratio*y←ratio=0 then abort('Vanishing pixel size!');
@.Vanishing pixel size@>
fudge←factor:=(slant←ratio/x←ratio)/y←ratio;

@ @<Get ready to convert...@>=
if pre←min←x<min←x*unity then offset←x:=offset←x+min←x*unity-pre←min←x;
if pre←max←y>max←y*unity then offset←y:=offset←y+max←y*unity-pre←max←y;
if pre←max←x>max←x*unity then pre←max←x:=pre←max←x div unity
else pre←max←x:=max←x;
if pre←min←y<min←y*unity then pre←min←y:=pre←min←y div unity
else pre←min←y:=min←y;
delta←y:=round(unsc←y←ratio*(max←y+1)-y←ratio*offset←y)+3276800;
delta←x:=round(x←ratio*offset←x-unsc←x←ratio*min←x);
if slant←ratio>=0 then
  over←col:=round(unsc←x←ratio*pre←max←x+unsc←slant←ratio*max←y)
else over←col:=round(unsc←x←ratio*pre←max←x+unsc←slant←ratio*min←y);
over←col:=over←col+delta←x+10000000;
page←height:=round(unsc←y←ratio*(max←y+1-pre←min←y))+3276800-offset←y;
if page←height>max←v then max←v:=page←height;
page←width:=over←col-10000000

@ The |dvi←goto| subroutine outputs bytes to the \.{DVI} file that
will initiate typesetting at given \.{DVI} coordinates, assuming that
the current position of the \.{DVI} reader is $(0,0)$. This subroutine
begins by outputting a |push| command; therefore, a |pop| command should
be given later. That |pop| will restore the \.{DVI} position to $(0,0)$.

@p procedure dvi←goto(@!x,@!y:scaled);
begin dvi←out(push);
if x<>0 then
  begin dvi←out(right4); dvi←four(x);
  end;
if y<>0 then
  begin dvi←out(down4); dvi←four(y);
  end;
end;

@ @<Output the |bop| and the title line@>=
dvi←out(bop); incr(total←pages); dvi←four(total←pages);
dvi←four(char←code); dvi←four(fam);
for k:=3 to 9 do dvi←four(0);
dvi←four(last←bop); last←bop:=dvi←offset+dvi←ptr-45;@/
dvi←goto(0,655360); {the top baseline is 10\thinspace pt down}
if use←logo then
  begin select←font(logo←font); hbox(small←logo,logo←font,true);
  end;
select←font(title←font); hbox(time←stamp,title←font,true);@/
hbox(page←header,title←font,true); dvi←scaled(total←pages*65536.0);@/
if (char←code<>0)or(fam<>0) then
  begin hbox(char←header,title←font,true); dvi←scaled(char←code*65536.0);
  if fam<>0 then
    begin hbox(fam←header,title←font,true); dvi←scaled(fam*65536.0);
    end;
  end;
if title←head<>null then
  begin right[title←tail]:=null;
  repeat hbox(left←quotes,title←font,true);
  hbox(info[title←head],title←font,true);
  hbox(right←quotes,title←font,true);
  title←head:=right[title←head];
  until title←head=null;
  end;
dvi←out(pop)

@ @d tol==6554 {one tenth of a point, in \.{DVI} coordinates}

@<Output all rules for the current character@>=
if rule←slant<>0 then select←font(slant←font);
while rule←ptr<>null do
  begin p:=rule←ptr; rule←ptr:=right[p];@/
  if rule←size[p]=0 then rule←size[p]:=gray←rule←thickness;
  if rule←size[p]>0 then
    begin convert(x0[p],y0[p]); temp←x:=dvi←x; temp←y:=dvi←y;
    convert(x1[p],y1[p]);
    if abs(temp←x-dvi←x)<tol then @<Output a vertical rule@>
    else if abs(temp←y-dvi←y)<tol then @<Output a horizontal rule@>
    else @<Try to output a diagonal rule@>;
    end;
  end

@ @<Glob...@>=
@!gray←rule←thickness:scaled; {thickness of rules, according to the gray font}
@!temp←x,@!temp←y:scaled; {temporary registers for intermediate calculations}

@ @<Initialize glob...@>=
gray←rule←thickness:=default←rule←thickness(gray←font);
if gray←rule←thickness=0 then gray←rule←thickness:=26214; {0.4\thinspace pt}

@ @<Output a vertical rule@>=
begin if temp←y>dvi←y then
  begin k:=temp←y; temp←y:=dvi←y; dvi←y:=k;
  end;
dvi←goto(dvi←x-(rule←size[p] div 2), dvi←y);
dvi←out(put←rule); dvi←four(dvi←y-temp←y); dvi←four(rule←size[p]);
dvi←out(pop);
end

@ @<Output a horizontal rule@>=
begin if temp←x<dvi←x then
  begin k:=temp←x; temp←x:=dvi←x; dvi←x:=k;
  end;
dvi←goto(dvi←x,dvi←y+(rule←size[p] div 2));
dvi←out(put←rule); dvi←four(rule←size[p]); dvi←four(temp←x-dvi←x);
dvi←out(pop);
end

@ @<Try to output a diagonal rule@>=
if (rule←slant=0)or@|
 (abs(temp←x+rule←slant*(temp←y-dvi←y)-dvi←x)>rule←size[p]) then
  slant←complaint((dvi←x-temp←x)/(temp←y-dvi←y))
else  begin if temp←y>dvi←y then
    begin k:=temp←y; temp←y:=dvi←y; dvi←y:=k;@/
    k:=temp←x; temp←x:=dvi←x; dvi←x:=k;
    end;
  m:=round((dvi←y-temp←y)/slant←unit);
  if m>0 then
    begin dvi←goto(dvi←x,dvi←y);
    q:=((m-1) div slant←n)+1; k:=m div q;
    p:=m mod q; q:=q-p;
    @<Typeset |q| copies of character |k|@>;
    @<Typeset |p| copies of character |k+1|@>;
    dvi←out(pop);
    end;
  end

@ @<Typeset |q| copies of character |k|@>=
typeset(k); dy:=round(k*slant←unit); dvi←out(z4); dvi←four(-dy);
while q>1 do
  begin typeset(k); dvi←out(z0); decr(q);
  end

@ @<Typeset |p| copies of character |k+1|@>=
if p>0 then
  begin incr(k); typeset(k);
  dy:=round(k*slant←unit); dvi←out(z4); dvi←four(-dy);
  while p>1 do
    begin typeset(k); dvi←out(z0); decr(p);
    end;
  end

@ Now we come to a more interesting part of the computation, where we
go through the stored labels and try to fit them in the illustration for
the current character, together with their associated dots.

While it would simplify font-switching if we were to typeset the labels
first, we find it desirable to typeset the dots first and then typeset the
labels.  This procedure makes it possible for us to allow the dots to
overlap each other without allowing the labels to overlap. We will also arrange
to typeset all prescribed labels, that is, labels with a
|lab←typ| of |"1".."8"|.

@<Output all labels for the current character@>=
overflow←line:=1;
if label←tail<>0 then
    begin right[label←tail]:=null; select←font(gray←font);
    @<Output all dots@>;
    nearest←dot; {assigns octant |oct| directions for nearest neighbors}
    select←font(label←font);
    @<Output all prescribed labels@>;
    @<Output all attachable labels@>;
    @<Output all overflow labels@>;
    end

@ @<Glob...@>=
@!overflow←line:integer; {the number of labels that didn't fit, plus~1}

@ A label that appears above its dot is considered to occupy a
rectangle of height~$h+\Delta$, depth~$d$, and width~$w+2\Delta$, where
$(h,w,d)$ are the height, width, and depth of the label computed by |hbox|,
and $\Delta$ is an additional amount of blank space that keeps labels from
coming too close to each other. (\.{GFtoDVI} arbitrarily defines $\Delta$
to be one half the width of a space in the label font.) This label is
centered over its dot, with its baseline $d+h'$ above the center of the dot;
here $h'=|dot←height|$ is the height of character~0 in the gray font.

Similarly, a label that appears below its dot is considered to occupy
a rectangle of height~$h$, depth~$d+\Delta$, and width~$w+2\Delta$; the
baseline is $h+h'$ below the center of the dot.

A label at the right of its dot is considered to occupy a rectangle of
height~$h+\Delta$, depth~$d+\Delta$, and width~$w+\Delta$. Its
reference point can be found by starting at the center of the dot and
moving right $w'=|dot←width|$ (i.e., the width of character~0 in the
gray font), then moving down by half the x-height of the label font.
A label at the left of its dot is similar.

A dot is considered to occupy a rectangle of height $2h'$ and width~$2w'$,
centered on the dot.

When the label type is |"1"| or more, the labels
are put into the tree unconditionally. Otherwise they are put into the tree
only if they don't overlap any previously inserted rectangles.

@<Glob...@>=
@!delta:scaled; {extra padding to keep labels from being too close}
@!half←x←height:scaled; {amount to drop baseline of label below the dot center}
@!thrice←x←height:scaled; {baseline separation for overflow labels}
@!dot←width,@!dot←height:scaled; {$w'$ and $h'$ in the discussion above}

@ @<Initialize global variables that depend on the font data@>=
i:=char←info(gray←font)(0);
if not char←exists(i) then abort('Missing dot char!');
@.Missing dot char@>
dot←width:=char←width(gray←font)(i);
dot←height:=char←height(gray←font)(height←depth(i));
delta:=space(label←font) div 2;
thrice←x←height:=3*x←height(label←font);
half←x←height:=thrice←x←height div 6;

@ Here is a subroutine that computes the rectangle boundaries
|xl[p]|, |xr[p]|, |yt[p]|, |yb[p]|, and the reference point coordinates
|xx[p]|,~|yy[p]|, for a label that is to be placed above a dot.
The coordinates of the dot's center are assumed given in |dvi←x|
and |dvi←y|; the |hbox| subroutine is assumed to have
already computed the height, width, and depth of the label box.

@p procedure top←coords(@!p:tree←pointer);
begin xx[p]:=dvi←x-(box←width div 2); xl[p]:=xx[p]-delta;
xr[p]:=xx[p]+box←width+delta;@/
yb[p]:=dvi←y-dot←height; yy[p]:=yb[p]-box←depth;
yt[p]:=yy[p]-box←height-delta;
end;

@ The other three label positions are handled by similar routines.

@p procedure bot←coords(@!p:tree←pointer);
begin xx[p]:=dvi←x-(box←width div 2); xl[p]:=xx[p]-delta;
xr[p]:=xx[p]+box←width+delta;@/
yt[p]:=dvi←y+dot←height; yy[p]:=yt[p]+box←height;
yb[p]:=yy[p]+box←depth+delta;
end;
@#
procedure right←coords(@!p:tree←pointer);
begin xl[p]:=dvi←x+dot←width; xx[p]:=xl[p]; xr[p]:=xx[p]+box←width+delta;@/
yy[p]:=dvi←y+half←x←height; yb[p]:=yy[p]+box←depth+delta;
yt[p]:=yy[p]-box←height-delta;
end;
@#
procedure left←coords(@!p:tree←pointer);
begin xr[p]:=dvi←x-dot←width; xx[p]:=xr[p]-box←width; xl[p]:=xx[p]-delta;@/
yy[p]:=dvi←y+half←x←height; yb[p]:=yy[p]+box←depth+delta;
yt[p]:=yy[p]-box←height-delta;
end;

@ @<Output all dots@>=
    p:=right[0];
    first←dot:=0;
    while p<>null do
  begin if lab←typ[p]<"5" then do←dot(p)
  else  begin convert(xx[p],yy[p]); xx[p]:=dvi←x; yy[p]:=dvi←y; dl←tie[p]:=0;
    end;
  p:=right[p];
  end

@ @<Output all prescribed labels@>=
    q:=0;
    while right[q]<>null do
  begin p:=right[q];
  if lab←typ[p] > "0" then
    begin
    right[q]:=right[p];
    do←a←label(p);
    end
    else q:=right[q];
  end

@ @<Output all attachable labels@>=
    q:=0;
    while right[q]<>null do
  begin p:=right[q];
  q←save:=right[p];
  do←b←label(p);
  if ov←flag=true then  q:=right[q] else right[q]:=q←save;
  end

@ @<Output all overflow labels@>=
    p:=0;
    while right[p]<>null do
  begin p:=right[p];
        @<Typeset an overflow label for |p|@>;
  end

@ Here are the procedures for locating the labels, for
adding them to the tree and for putting them out.

@p procedure do←a←label(@!p:tree←pointer);
var @!q:tree←pointer;
begin hbox(info[p],label←font,false); {Compute the size of this label}
dvi←x:=xx[p];  dvi←y:=yy[p];
case lab←typ[p] of
"1","5":top←coords(p);
"2","6":left←coords(p);
"3","7":right←coords(p);
"4","8":bot←coords(p);
end; {Only these four cases will be treated by |do←a←label|}
q:=dl←tie[p]; oct[q]:=0; {to identify labelled dot for |nearest←dot| routine}
tree←ins(p);@/
dvi←goto(xx[p],yy[p]); hbox(info[p],label←font,true); dvi←out(pop);
end;

@ And here is the second of the two label routines.

@p procedure do←b←label(@!p:tree←pointer);
label found,exit;
var @!q:tree←pointer;
k: integer;
begin hbox(info[p],label←font,false); {Compute the size of this label}
dvi←x:=xx[p];  dvi←y:=yy[p];
@<Find non-overlapping coordinates, if possible;
  otherwise set an overflow flag and |return|@>;
found:tree←ins(p);@/
q:=dl←tie[p]; oct[q]:=0; {to identify labelled dot for |nearest←dot| routine}
dvi←goto(xx[p],yy[p]); hbox(info[p],label←font,true); dvi←out(pop);
exit:end;

@ As noted earlier, the dots are all to be printed even when
overlapping. We can, therefore, enter them into the tree now and output them.

@p procedure do←dot(@!p:tree←pointer);
var @!q:tree←pointer;
begin
q:=get←avail; if first←dot=0 then first←dot:=q;
last←dot:=q;
dl←tie[p]:=q; dl←tie[q]:=p; info[q]:=-info[p]; convert(xx[p],yy[p]);@/
xx[q]:=dvi←x; yy[q]:=dvi←y;@/
xx[p]:=xx[q]; yy[p]:=yy[q];@/
xl[q]:=dvi←x-dot←width; xr[q]:=dvi←x+dot←width;@/
yt[q]:=dvi←y-dot←height; yb[q]:=dvi←y+dot←height;@/
tree←ins(q);@/
dvi←goto(xx[q],yy[q]); dvi←out(0); dvi←out(pop);
end;

@ @<Find non-overlapping coordinates, if possible...@>=
ov←flag:=false;
q:=dl←tie[p];
@<First choice for label direction@>;
@<Second choice for label direction@>;
@<Third choice for label direction@>;
@<Fourth choice for label direction@>;
xx[p]:=dvi←x;  yy[p]:=dvi←y;
if lab←typ[p]="0" then
  ov←flag:=true; {identify this label for overflow treatment}
return

@ @<First choice for label direction@>=
case oct[q] of
1,8,10,15: left←coords(p);
2,3,9,12: bot←coords(p);
4,5,11,14: right←coords(p);
6,7,13,16: top←coords(p);
end;
if not overlap(p) then goto found

@ @<Second choice for label direction@>=
case oct[q] of
1,4,13,16: bot←coords(p);
2,7,11,14: left←coords(p);
3,6,10,15: right←coords(p);
5,8,9,12: top←coords(p);
end;
if not overlap(p) then goto found

@ @<Third choice for label direction@>=
case oct[q] of
1,4,14,15: top←coords(p);
2,7,12,13: right←coords(p);
3,6,9,16: left←coords(p);
5,8,10,11: bot←coords(p);
end;
if not overlap(p) then goto found

@ @<Fourth choice for label direction@>=
case oct[q] of
1,8,9,16: right←coords(p);
2,3,10,11: top←coords(p);
4,5,12,13: left←coords(p);
6,7,14,15: bot←coords(p);
end;
if not overlap(p) then goto found

@ @<Typeset an overflow label for |p|@>=
begin
q:=dl←tie[p];
n←l←dot(q); incr(overflow←line);
dvi←goto(over←col,overflow←line*thrice←x←height+655360);
hbox(info[p],label←font,true);
hbox(equals←sign,label←font,true);
hbox(-info[q←dot],label←font,true);
hbox(plus←sign,label←font,true);
dvi←scaled((xx[p]-xx[q←dot])/x←ratio+(yy[p]-yy[q←dot])*fudge←factor);
dvi←out(",");
dvi←scaled((yy[q←dot]-yy[p])/y←ratio);
dvi←out(")"); dvi←out(pop);
end

@ @<Adjust the maximum page width@>=
if overflow←line>1 then page←width:=over←col+10000000;
  {overflow labels are estimated to occupy $10↑7\,$sp}
if page←width>max←h then max←h:=page←width

@* Doing the pixels.
The most interesting part of \.{GFtoDVI} is the way it makes use of a gray
font to typeset the pixels of a character. In fact, the author must admit having
great fun devising the algorithms below. Perhaps the reader will also
enjoy reading them.

The basic idea will be to use an array of 12-bit integers to represent the next
twelve rows that need to be typeset. The binary expansions of these integers,
reading from least significant bit to most significant bit, will represent
pixels from top to bottom.

@ We have already used such a binary representation in the tables
|c[1..120]| and |d[1..120]| of bit patterns and lengths that are potentially
present in a gray font; we shall now use those tables to compute
an auxiliary array |b[0..4095]|. Given a 12-bit number~$v$, the gray-font
character appropriate to $v$'s binary pattern will be~|b[v]|. If no
character should be typeset for this pattern in the current row,
|b[v]| will be~0.

The array |b| can have many different configurations, depending on how
many characters are actually present in the gray font. But
it's not difficult to compute |b| by going through the existing characters
in increasing order and marking all patterns~$x$ to which they apply.

@<Initialize glob...@>=
for k:=0 to 4095 do b[k]:=0;
for k:=font←bc[gray←font] to font←ec[gray←font] do
 if k>=1 then if k<=120 then
  if char←exists(char←info(gray←font)(k)) then
  begin v:=c[k];
  repeat b[v]:=k; v:=v+d[k];
  until v>4095;
  end;

@ We also compute an auxiliary array |r[0..4095]| such that $r[v]=2↑j$
when |v| is an odd multiple of~$2↑j$; we also set $r[0]=2↑{12}$.

@<Initialize g...@>=
for j:=0 to 11 do
  begin k:=two←to←the[j]; v:=k;
  repeat r[v]:=k; v:=v+k+k;
  until v>4095;
  end;
r[0]:=4096;

@ @<Glob...@>=
@!b:array[0..4095] of 0..120; {largest existing character for a given pattern}
@!r:array[0..4095] of 1..4096; {the ``ruler function''}

@ But how will we use these tables? Let's imagine that the \.{DVI} file
already contains instructions that have selected the gray font and moved
to the proper horizontal coordinate for the row that we wish to process next.
Let's suppose that 12-bit patterns have been set up in array~|a|, and that
the global variables |starting←col| and |finishing←col| are known such
that |a[j]| is zero unless |starting←col<=j<=finishing←col|. Here's what
we can do, assuming that appropriate local variables and labels have
been declared:

@<Typeset the pixels of the current row@>=
j:=starting←col;
loop@+  begin while (j<=finishing←col)and(b[a[j]]=0) do incr(j);
  if j>finishing←col then goto done;
  dvi←out(push); @<Move to column |j| in the \.{DVI} output@>;
  repeat v:=b[a[j]]; a[j]:=a[j]-c[v];
  k:=j; incr(j);
  while b[a[j]]=v do
    begin a[j]:=a[j]-c[v]; incr(j);
    end;
  k:=j-k; @<Output the equivalent of |k| copies of character |v|@>;
  until b[a[j]]=0;
  dvi←out(pop);
  end;
done:

@ @<Move to column |j| in the \.{DVI} output@>=
dvi←out(right4);
dvi←four(round(unsc←x←ratio*j+unsc←slant←ratio*y)+delta←x)

@ The doubling-up property of gray font character lists is utilized here.

@<Output the equivalent of |k| copies of character |v|@>=
reswitch: if k=1 then typeset(v)
else  begin i:=char←info(gray←font)(v);
  if char←tag(i)=list←tag then {|v| has a successor}
    begin if odd(k) then typeset(v);
    k:=k div 2; v:=qo(rem←byte(i)); goto reswitch;
    end
  else repeat typeset(v); decr(k);
    until k=0;
  end

@ @<Glob...@>=
@!a:array[0..widest←row] of 0..4095; {bit patterns for twelve rows}

@ In order to use the approach above, we need to be able to initialize
array~|a|, and we need to be able to keep it up to date as new rows
scroll by. A moment's thought about the problem reveals that we will either
have to read an entire character from the \.{GF} file into memory,
or we'll need to adopt a coroutine-like approach: A single \\{skip}
command in the \.{GF} file might need to be processed in pieces, since
it might generate more rows of zeroes than we are ready to absorb
all at once into~|a|.

The coroutine method actually turns out to be quite simple, so we shall
introduce a global variable |blank←rows|, which tells how many rows of
blanks should be generated before we read the \.{GF} instructions
for another row.

@<Glob...@>=
@!blank←rows:integer;
  {rows of blanks carried over from a previous \.{GF} command}

@ Initialization and updating of~|a| can now be handled as follows,
if we introduce another variable~|l| that is set initially to~1:

@<Add more rows to |a|, until 12-bit entries are obtained@>=
repeat @<Put the bits for the next row, times |l|, into |a|@>;
l:=l+l; decr(y);
until l=4096;

@ As before, |cur←gf| will contain the first \.{GF} command that has
not yet been interpreted.

@<Put the bits...@>=
if blank←rows>0 then decr(blank←rows)
else if cur←gf<>eoc then
  begin x:=z;
  if starting←col>x then starting←col:=x;
  @<Read and process \.{GF} commands until coming to the end of this row@>;
  end;

@ @d do←skip==z:=0; paint←black:=false
@d end←with(#)==begin #; cur←gf:=get←byte; goto done1;@+end
@d five←cases(#)==#,#+1,#+2,#+3,#+4
@d eight←cases(#)==#,#+1,#+2,#+3,#+4,#+5,#+6,#+7
@d thirty←two←cases(#)==eight←cases(#),eight←cases(#+8),
  eight←cases(#+16), eight←cases(#+24)
@d sixty←four←cases(#)==thirty←two←cases(#), thirty←two←cases(#+32)

@<Read and process...@>=
loop  @+begin continue: case cur←gf of
  sixty←four←cases(0): k:=cur←gf;
  paint1:k:=get←byte;
  paint2:k:=get←two←bytes;
  paint3:k:=get←three←bytes;
  eoc:goto done1;
  skip0:end←with(blank←rows:=0; do←skip);
  skip1:end←with(blank←rows:=get←byte; do←skip);
  skip2:end←with(blank←rows:=get←two←bytes; do←skip);
  skip3:end←with(blank←rows:=get←three←bytes; do←skip);
  sixty←four←cases(new←row←0),sixty←four←cases(new←row←0+64),
   thirty←two←cases(new←row←0+128),five←cases(new←row←0+160):
    end←with(z:=cur←gf-new←row←0;paint←black:=true);
  xxx1,xxx2,xxx3,xxx4,yyy,no←op:begin skip←nop; goto continue;
    end;
  othercases bad←gf('Improper opcode')
  endcases;@/
  @<Paint |k| bits and read another command@>;
  end;
done1:

@ @<Paint |k| bits and read another command@>=
if x+k>finishing←col then finishing←col:=x+k;
if paint←black then for j:=x to x+k-1 do a[j]:=a[j]+l;
paint←black:=not paint←black;
x:=x+k;
cur←gf:=get←byte

@ When the current row has been typeset, all entries of |a| will be even;
we want to divide them by~2 and incorporate a new row with $l=2↑{11}$.
However, if they are all multiples of~4, we actually want to divide by~4
and incorporate two new rows, with $l=2↑{10}$ and $l=2↑{11}$. In general,
we want to divide by the maximum possible power of~2 and add the corresponding
number of new rows; that's where the |r|~array comes in handy:

@<Advance to the next row that needs to be typeset;
  or |return|, if we're all done@>=
l:=r[a[starting←col]];
for j:=starting←col+1 to finishing←col do if l>r[a[j]] then l:=r[a[j]];
if l=4096 then
  if cur←gf=eoc then return
  else  begin y:=y-blank←rows; blank←rows:=0; l:=1;
    starting←col:=z; finishing←col:=z;
    end
else  begin while a[starting←col]=0 do incr(starting←col);
  while a[finishing←col]=0 do decr(finishing←col);
  for j:=starting←col to finishing←col do a[j]:=a[j] div l;
  l:=4096 div l;
  end

@ We now have constructed the major components of the necessary routine;
it simply remains to glue them all together in the proper framework.

@p procedure do←pixels;
label done,done1,reswitch,continue,exit;
var @!paint←black:boolean; {the paint switch}
@!starting←col,@!finishing←col:0..widest←row; {currently nonzero area}
@!j:0..widest←row; {for traversing that area}
@!l:integer; {power of two used to manipulate bit patterns}
@!i:four←quarters; {character information word}
@!v:eight←bits; {character corresponding to a pixel pattern}
begin select←font(gray←font);
delta←x:=delta←x+round(unsc←x←ratio*min←x);
for j:=0 to max←x-min←x do a[j]:=0;
l:=1; z:=0; starting←col:=0; finishing←col:=0; y:=max←y+12; paint←black:=false;
blank←rows:=0; cur←gf:=get←byte;
loop@+  begin @<Add more rows...@>;
  dvi←goto(0,delta←y-round(unsc←y←ratio*y)); @<Typeset the pixels...@>;
  dvi←out(pop); @<Advance to the next...@>;
  end;
exit:end;

@* The main program.
Now we are ready to put it all together. This is where \.{GFtoDVI} starts,
and where it ends.

@p begin initialize; {get all variables initialized}
@<Initialize the strings@>;
start←gf; {open the input and output files}
@<Process the preamble@>;
cur←gf:=get←byte; init←str←ptr:=str←ptr;
loop@+  begin @<Initialize variables for the next character@>;
  while (cur←gf>=xxx1)and(cur←gf<=no←op) do @<Process a no-op command@>;
  if cur←gf=post then @<Finish the \.{DVI} file and |goto final←end|@>;
  if cur←gf<>boc then if cur←gf<>boc1 then abort('Missing boc!');
@.Missing boc@>
  @<Process a character@>;
  cur←gf:=get←byte; str←ptr:=init←str←ptr; pool←ptr:=str←start[str←ptr];
  end;
final←end:end.

@ The main program needs a few global variables in order to do its work.

@<Glob...@>=
@!k,@!s,@!m,@!p,@!q,@!dx,@!dy:integer; {general purpose registers}
@!time←stamp:str←number; {the date and time when the input file was made}
@!use←logo:boolean; {should \MF's logo be put on the title line?}

@ \MF\ sets the opening string to 32 bytes that give date and time as follows:
$$\hbox{|' METAFONT output yyyy.mm.dd:tttt'|}$$
We copy this to the \.{DVI} file, but remove the `\.{METAFONT}' part so that
it can be replaced by its proper logo.

@<Process the preamble@>=
if get←byte<>pre then bad←gf('No preamble');
@.No preamble@>
if get←byte<>gf←id←byte then bad←gf('Wrong ID');
@.Wrong ID@>
k:=get←byte; {|k| is the length of the initial string to be copied}
for m:=1 to k do append←char(get←byte);
dvi←out(pre); dvi←out(dvi←id←byte); {output the preamble}
dvi←four(25400000); dvi←four(473628672); {conversion ratio for sp}
dvi←four(1000); {magnification factor}
dvi←out(k); use←logo:=false; s:=str←start[str←ptr];
for m:=1 to k do dvi←out(str←pool[s+m-1]);
if str←pool[s]=" " then
 if str←pool[s+1]="M" then
  if str←pool[s+2]="E" then
   if str←pool[s+3]="T" then
    if str←pool[s+4]="A" then
     if str←pool[s+5]="F" then
      if str←pool[s+6]="O" then
       if str←pool[s+7]="N" then
        if str←pool[s+8]="T" then
    begin incr(str←ptr); str←start[str←ptr]:=s+9; use←logo:=true;
    end; {we will substitute `\MF' for \.{METAFONT}}
time←stamp:=make←string

@* System-dependent changes.
This section should be replaced, if necessary, by changes to the program
that are necessary to make \.{GFtoDVI} work at a particular installation.
It is usually best to design your change file so that all changes to
previous sections preserve the section numbering; then everybody's version
will be consistent with the printed program. More extensive changes,
which introduce new sections, can be inserted here; then only the index
itself will get a new section number.
@↑system dependencies@>

@* Index.
Pointers to error messages appear here together with the section numbers
where each ident\-i\-fier is used.