2  INTRODUCTION  DVIcopy §1

1* . Introduction. The utility program copies (selected pages of) binary device-independent (“ ”) files that are produced by document compilers such as TEX, and replaces all references to characters from virtual fonts by the typesetting instructions specified for them in binary virtual-font (“ ”) files. This program has two chief purposes: (1) It can be used as preprocessor for existing -related software in cases where this software is unable to handle virtual fonts or (given suitable files) where this software cannot handle fonts with more than 128 characters; and (2) it serves as an example of a program that reads and files correctly, for system programmers who are developing -related software.

Goal number (1) is important since quite a few existing programs have to be adapted to the extened capabilities of Version 3 of TEX which will require some time. Moreover some existing programs are ‘as is’ and the source code is, unfortunately, not available. Goal number (2) needs perhaps a bit more explanation. Programs for typesetting need to be especially careful about how they do arithmetic; if rounding errors accumulate, margins won’t be straight, vertical rules won’t line up, and so on (see the documentaion of for more details). This program is written as if it were a -driver for a hypothetical typesetting device out file, the output file receiving the copy of the input dvi file. In addition all code related to out file is concentrated in a few chapters of this program and quite independent of the rest of the code concerned with the decoding of and files and with font substitutions. Thus it should be relatively easy to replace the device dependent code of this program by the corresponding code required for a real typesetting device. Having this in mind ’s pixel rounding algorithms are included as conditional code not used by .

The banner and preamble comment strings defined here should be changed whenever gets modified.

define banner ≡ ´ ␣ ␣ ␣ ␣ ␣ ´ { printed when the program starts } define preamble comment ≡ ´ ␣ ␣ ␣ ␣ ␣´ define comm length = 24 { length of preamble comment } define from length = 6 { length of its ´ ␣ ␣´ part }

3* . The program begins with a fairly normal header, made up of pieces that will mostly be filled in later. The input comes from file dvi file, the output goes to file out file, and messages go to Pascal’s standard output file. The and files are defined later since their external names are determined dynamically.

If it is necessary to abort the job because of a fatal error, the program calls the ‘jump out ’ procedure, which goes to the label final end .

define final end = 9999 { go here to wrap it up } ⟨ Compiler directives 7 ⟩ program DVI copy ;

label final end ;

const ⟨ Constants in the outer block 13* ⟩

type ⟨ Types in the outer block 4 ⟩

var ⟨ Globals in the outer block 14 ⟩

⟨ Error handling procedures 23* ⟩ procedure initialize; { this procedure gets things started properly }

var ⟨ Local variables for initialization 18 ⟩ begin print ln(banner ); ⟨ Set initial values 15 ⟩ end;

§9  DVIcopy  INTRODUCTION 3

9* . The term print is used instead of write when this program writes on output , so that all such output could easily be redirected if desired; the term d print is used for conditional output if we are debugging.

define output ≡ stdout define print (#) ≡ write(output , #) define print ln(#) ≡ write ln(output , #) define d print (#) ≡

debug print (#) gubed

define d print ln(#) ≡ debug print ln(#) gubed

10* . Here are some macros for common programming idioms.

define Incr Decr (#) ≡ # define Incr (#) ≡ # ← # + Incr Decr { increase a variable } define Decr (#) ≡ # ← # − Incr Decr { decrease a variable } define loop ≡ while true do { repeat over and over until a goto happens } define do nothing ≡ { empty statement } define return ≡ goto exit { terminate a procedure call } format return ≡ nil format loop ≡ xclause

13* . The following parameters can be changed at compile time to extend or reduce ’s capacity.

define name length ≡ FILENAMESIZE ⟨ Constants in the outer block 13* ⟩ ≡

max fonts = 100; { maximum number of distinct fonts } max chars = 10000; { maximum number of different characters among all fonts } max widths = 3000; { maximum number of different characters widths } max packets = 5000; { maximum number of different characters packets; must be less than 65536 } max bytes = 30000; { maximum number of bytes for characters packets } max recursion = 10; { files shouldn’t recurse beyond this level } stack size = 100; { files shouldn’t push beyond this depth }

This code is used in section 3*.

4  THE CHARACTER SET  DVIcopy §16
16* . The character set. Like all programs written with the  system,  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, and because and files use ASCII code for file names and certain other strings.

The next few sections of have therefore been copied from the analogous ones in the system routines. They have been considerably simplified, since need not deal with the controversial ASCII codes less than ´ 40 or greater than ´ 176 . If such codes appear in the file, they will be printed as question marks. ⟨ Types in the outer block 4 ⟩ +≡

ASCII code = 0 . . 255; { a subrange of the integers }

17* . 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, especially in a program like . So we shall assume that the Pascal system being used for has a character set containing at least the standard visible characters of ASCII code ( through ).

Some Pascal compilers use the original name char for the data type associated with the characters in text files, while other Pascals 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.

define text char ≡ ASCII code { the data type of characters in text files }

define first text char = 0 { ordinal number of the smallest element of text char }

define last text char = 255 { ordinal number of the largest element of text char } ⟨ Types in the outer block 4 ⟩ +≡

text file = packed file of text char ;

§22  DVIcopy  REPORTING ERRORS TO THE USER 5

23* . If an input ( , , , or other) file is badly malformed, the whole process must be aborted; will give up, after issuing an error message about what caused the error. These messages will, however, in most cases just indicate which input file caused the error. One of the programs , or should then be used to diagnose the error in full detail.

Such errors might be discovered inside of subroutines inside of subroutines, so a procedure called jump out has been introduced. This procedure is actually a macro which calls exit() with a non-zero exit status.

define abort (#) ≡ begin print ln(´ ␣´ , #, ´ ´ ); jump out ; end

⟨ Error handling procedures 23* ⟩ ≡

⟨ Basic printing procedures 72 ⟩ procedure close files and terminate; forward ;

procedure jump out ; begin mark fatal ; close files and terminate; uexit (1); end;

See also sections 24, 25, 109, 130, and 156. This code is used in section 3*.

6  BINARY DATA AND BINARY FILES  DVIcopy §31

75* . define begin pair (#) ≡ var a, b: eight bits ; begin #(a); #(b)

define comp spair (#) ≡

if a < 128 then # ← a ∗ toint (256) + b else # ← (a − toint (256)) ∗ toint (256) + b

define comp upair (#) ≡ # ← a ∗ toint (256) + b format begin pair ≡ begin

function pckt spair : int 16 ; { returns the next two bytes, signed } begin pair (pckt extract ); comp spair (pckt spair ); end;

function pckt upair : int 16u; { returns the next two bytes, unsigned } begin pair (pckt extract ); comp upair (pckt upair ); end;

76* . define begin trio(#) ≡ var a, b, c: eight bits ; begin #(a); #(b); #(c)

define comp strio(#) ≡

if a < 128 then

# ← (a∗toint (256)+b)∗toint (256)+c else # ← ((a−toint (256))∗toint (256)+b)∗toint (256)+c

define comp utrio(#) ≡ # ← (a ∗ toint (256) + b) ∗ toint (256) + c format begin trio ≡ begin

function pckt strio: int 24 ; { returns the next three bytes, signed } begin trio (pckt extract ); comp strio(pckt strio); end;

function pckt utrio: int 24u; { returns the next three bytes, unsigned } begin trio (pckt extract ); comp utrio(pckt utrio); end;

77* . define begin quad (#) ≡ var a, b, c, d: eight bits ;

begin #(a); #(b); #(c); #(d)

define comp squad (#) ≡ if a < 128 then # ← ((a ∗ toint (256) + b) ∗ toint (256) + c) ∗ toint (256) + d else # ← (((a − toint (256)) ∗ toint (256) + b) ∗ toint (256) + c) ∗ toint (256) + d

format begin quad ≡ begin function pckt squad : int 32 ; { returns the next four bytes, signed }

begin quad (pckt extract ); comp squad (pckt squad ); end;

§87  DVIcopy  FILE NAMES 7

89* . For and files we just append the apropriate extension to the file name packet; in addition a system dependent area part (usually different for anf files) is prepended if the file name packet contains no area part. For other font files (e.g., or ) the extension or area part will in most cases depend on the resolution of the output device (corrected for font magnification).

The make name procedure used to build the external file name has three parameters: the packets with the font name and the extension, and the length of the default area which must be copied to cur name before make name is called. procedure make name(n, e : pckt pointer ; r : int 15 );

var b: eight bits ; { a byte extracted from byte mem }

cur loc, cur limit : byte pointer ; { indices into byte mem } begin cur loc ← pckt start [n]; cur limit ← pckt start [n + 1]; pckt extract (b); { length of area part } if b > 0 then r ← 0; if r + (cur limit − cur loc) + pckt length(e) > name length then overflow (str name length, name length); while cur loc < cur limit do

begin pckt extract (b); incr (r); cur name[r] ← xchr [b]; end;

cur loc ← pckt start [e]; cur limit ← pckt start [e + 1]; while cur loc < cur limit do

begin pckt extract (b); incr (r); cur name[r] ← xchr [b]; end;

while r < name length do

8  DEFINING FONTS  DVIcopy §90

begin incr (r); cur name[r] ← ´ ␣´ ; end; end; 103* . We use macros to access the various fields. We will say, e.g., font name(f) for the name field of font f, and font width(f)(c) for the width pointer of character c in font f (this character exists provided font bc(f) ≤ c ≤ font ec(f) and font width(f)(c) > 0). The actual width of character c in font f is stored in widths [font width(f)(c)]; the horizontal escapement is given by font pixel (f)(c).

define font check (#) ≡ font data[#].check field { checksum } define font scaled (#) ≡ font data[#].scaled field { scaled or ‘at’ size } define font design(#) ≡ font data[#].design field { design size } define font space(#) ≡ font data[#].space field { boundary between “small” and “large” spaces } define font name(#) ≡ font data[#].name field { area plus name packet } define font bc(#) ≡ font data[#].bc field { first character } define font ec(#) ≡ font data[#].ec field { last character } define font chars (#) ≡ font data[#].chars field { character width offset } define font type(#) ≡ font data[#].type field { type of this font } define font width end (#) ≡ # ] define font width(#) ≡ char widths [ font chars (#) + font width end define font pixel (#) ≡ char pixels [ font chars (#) + font width end

⟨ Types in the outer block 4 ⟩ +≡

font record = packed record { all data for one font } check field : int 32 ; { checksum } scaled field : int 31 ; { scaled size } design field : int 31 ; { design size }

device space field : int 32 ; { boundary between “small” and “large” spaces } ecived

name field : pckt pointer ; { pointer to area plus name packet } bc field : eight bits ; { first character } ec field : eight bits ; { last character } chars field : char offset ; { character width offset } type field : f type; { type of font }

⟨ Cases for font record 104* ⟩ end;

104* . Here we define the additional font data fields required for a new font which has been defined but not yet been used. In order to simplify the translation the fields in the variant for f type = new font type are accessed through the macro new font data.

Actually we need no fields for this record variant (at least for the moment). define new font data(#) ≡ font data[#] { access new font type variant fields }

⟨ Cases for font record 104* ⟩ ≡

See also sections 165* and 211*. This code is used in section 103*.

108* . ⟨ Initialize predefined strings 69 ⟩ +≡ id4 ( )( )( )( )(tfm ext ); { file name extension for files }

§110  DVIcopy  DEFINING FONTS 9

110* . To prepare tfm file for input we reset it.

In C, we use the external test access procedure, which also does path searching based on the user’s environment or the default path. ⟨ TFM: Open tfm file 110* ⟩ ≡

if test read access (cur name, TFM FILE PATH ) then begin reset (tfm file, cur name); end

else begin print pascal string (cur name); abort (´ ␣ ␣ ␣ ␣ ´ ´ ␣ ␣ ´ );

end; cur tfm ← f { in case bad tfm is called }

This code is used in section 118*.

116* . If no font directory has been specified,  is supposed to use the default  directory, which is a

system-dependent place where the files for standard fonts are kept. The string variable TFM default area contains the name of this area.

Actually, under UNIX the standard area is defined in an external file . And the users have a path searched for fonts, by setting the environment variable.

117* . (No initialization to be done. Keep this module to preserve numbering.)

118* . ⟨ Define a new font 118* ⟩ ≡ begin if nf = max fonts then overflow (str fonts , max fonts ); font type(f) ← new font type; make name(font name(f), tfm ext , 0); ⟨ TFM: Open tfm file 110* ⟩; ⟨ TFM: Read past the header data 120* ⟩; ⟨ TFM: Store character-width indices 121 ⟩; ⟨ TFM: Read and convert the width values 126 ⟩; ⟨ TFM: Convert character-width indices to character-width pointers 127 ⟩; ⟨ TFM: Close tfm file 111 ⟩; d print (´ ␣ ␣ ␣´ , font scaled (f) : 1, ´ ␣ ␣ ´ ); incr (nf ); end

This code is used in section 115.

120* . We will use the following macros to construct integers from two or four of the four bytes read by read tfm word .

define tfm b01 (#) ≡ { tfm b0 . . tfm b1 as non-negative integer } if tfm b0 > 127 then bad tfm else # ← tfm b0 ∗ toint (256) + tfm b1

define tfm b23 (#) ≡ { tfm b2 . . tfm b3 as non-negative integer } if tfm b2 > 127 then bad tfm else # ← tfm b2 ∗ toint (256) + tfm b3

define tfm squad (#) ≡ { tfm b0 . . tfm b3 as signed integer }

if tfm b0 < 128 then

# ← ((tfm b0 ∗ toint (256) + tfm b1 ) ∗ toint (256) + tfm b2 ) ∗ toint (256) + tfm b3 else # ← (((tfm b0 − toint (256)) ∗ toint (256) + tfm b1 ) ∗ toint (256) + tfm b2 ) ∗ toint (256) + tfm b3

define tfm uquad ≡ { tfm b0 . . tfm b3 as unsigned integer }

(((tfm b0 ∗ toint (256) + tfm b1 ) ∗ toint (256) + tfm b2 ) ∗ toint (256) + tfm b3 )

⟨ TFM: Read past the header data 120* ⟩ ≡ read tfm word ; tfm b23 (lh); read tfm word ; tfm b01 (bc); tfm b23 (ec); if ec < bc then

begin bc ← 1; ec ← 0; end

else if ec > 255 then bad tfm; read tfm word ; tfm b01 (nw ); if (nw = 0) ∨ (nw > 256) then bad tfm; for k ← −2 to lh do

begin read tfm word ; if k = 1 then

begin tfm squad (w); check check sum(f, w); end

else if k = 2 then begin if tfm b0 > 127 then bad tfm; check design size(f, round (tfm conv ∗ tfm uquad )); end;

end

This code is used in section 118*.

§129  DVIcopy  LOW-LEVEL DVI INPUT ROUTINES 11

129* . Low-level DVI input routines. The program uses the binary file variable dvi file for its main input file; dvi loc is the number of the byte about to be read next from dvi file. In C, we also have a real name of file string, that gets set by the external test access procedure after path searching. ⟨ Globals in the outer block 14 ⟩ +≡ dvi file: byte file; { the stuff we are ing } dvi loc: int 32 ; { where we are about to look, in dvi file } real name of file: packed array [0 . . name length] of text char ; i: integer ; { loop control }

131* . To prepare dvi file for input, we reset it. ⟨ Open input file(s) 131* ⟩ ≡

argv (toint (1), cur name); reset (dvi file, cur name); dvi loc ← 0;

This code is used in section 292*.

134* . Next we come to the routines that are used only if random reading is true. The driver program below needs two such routines: dvi length should compute the total number of bytes in dvi file, possibly also causing eof (dvi file) to be true; and dvi move(n) should position dvi file so that the next dvi byte will read byte n, starting with n = 0 for the first byte in the file.

Such routines are, of course, highly system dependent. They are implemented here in terms of two assumed system routines called set pos and cur pos . The call set pos (f, n) moves to item n in file f, unless n is negative or larger than the total number of items in f; in the latter case, set pos (f, n) moves to the end of file f. The call cur pos (f) gives the total number of items in f, if eof (f) is true; we use cur pos only in such a situation. function dvi length: int 32 ;

begin checked fseek (dvi file, 0, 2); dvi loc ← ftell (dvi file); dvi length ← dvi loc;

end; procedure dvi move(n : int 32 );

begin checked fseek (dvi file, n, 0); dvi loc ← n;

end;

12  LOW-LEVEL VF INPUT ROUTINES  DVIcopy §154

155* . ⟨ Initialize predefined strings 69 ⟩ +≡ id3 ( )( )( )(vf ext ); { file name extension for files }

157* . To prepare vf file for input we reset it. ⟨ VF: Open vf file or goto not found 157* ⟩ ≡

if test read access (cur name, VF FILE PATH ) then begin reset (vf file, cur name); end

else goto not found ;

vf loc ← 0

This code is used in section 196*.

165* . Here we define the additional font data fields required for virtual fonts; font vf fnt (f) is the default font for character packets from virtual font f, font vf packet (f)(c) is the character packet for character c from virtual font f. In order to simplify the translation the fields in the variant for f type = vf font type are accessed through the macro vf font data. This time we allocate the fields used by variants.

define vf font data(#) ≡ font data[#] { access vf font type variant fields } define font vf chars (#) ≡ vf font data(#).vf chars field { character packet offset } define font vf fnt (#) ≡ vf font data(#).vf fnt field { font number of default font } define font vf packet end (#) ≡ # ] define font vf packet (#) ≡ char packets [ font vf chars (#) + font vf packet end

⟨ Cases for font record 104* ⟩ +≡ vf chars field : char offset ; { character packet offset } vf fnt field : font number ; { font number of default font }

§171  DVIcopy  READING VF FILES 13

182* . ⟨ VF: Start a new level 182* ⟩ ≡ append one(push); vf move[vf ptr ][0][0] ← vf move[vf ptr − 1][0][0]; vf move[vf ptr ][0][1] ← vf move[vf ptr − 1][0][1]; vf move[vf ptr ][1][0] ← vf move[vf ptr − 1][1][0]; vf move[vf ptr ][1][1] ← vf move[vf ptr − 1][1][1]; vf push loc[vf ptr ] ← byte ptr ; vf last end [vf ptr ] ← byte ptr ; vf last [vf ptr ] ← vf other

This code is used in sections 181 and 191.

189* . ⟨ VF: Apply rule 3 or 4 189* ⟩ ≡

begin if vf push num[vf ptr ] > 0 then begin decr (vf push num[vf ptr ]); vf move[vf ptr ][0][0] ← vf move[vf ptr − 1][0][0]; vf move[vf ptr ][0][1] ← vf move[vf ptr − 1][0][1]; vf move[vf ptr ][1][0] ← vf move[vf ptr − 1][1][0]; vf move[vf ptr ][1][1] ← vf move[vf ptr − 1][1][1]; end

else begin decr (byte ptr ); decr (vf ptr );

end; if cur class ≠ pop cl then goto reswitch; { this is rule 4 } end

This code is used in section 187.

195* . If no font directory has been specified, is supposed to use the default directory, which is a system-dependent place where the files for standard fonts are kept. The string variable VF default area contains the name of this area.

Actually, under UNIX the standard area is defined in an external file . And the users have a path searched for fonts, by setting the environment variable.

196* . The function do vf attempts to read the file for a font and returns false if the file could not be found; when the file has been read, the font type is changed to vf font type. function do vf : boolean; { read a file }

label not found , exit ; var temp byte: int 8u; { byte for temporary variables }

k: int 15 ; { general purpose variable }

save ext : int 24 ; { used to save cur ext }

save res : int 8u; { used to save cur res }

save wp: width pointer ; { used to save cur wp }

save upd : boolean; { used to save cur upd } begin save ext ← cur ext ; save res ← cur res ; save wp ← cur wp; save upd ← cur upd ; cur vf ← cur fnt ; { save } make name(font name(cur vf ), vf ext , 0); ⟨ VF: Open vf file or goto not found 157* ⟩; font type(cur vf ) ← vf font type; ⟨ VF: Process the preamble 197 ⟩; ⟨ VF: Process the font definitions 198 ⟩; ⟨ VF: Process the character packets 199 ⟩; debug print (´ ␣ ␣ ␣ ␣´ , cur vf : 1); print font (cur vf ); print ln(´ ␣ ´ ); gubed ⟨ VF: Close vf file 158 ⟩; cur ext ← save ext ; cur res ← save res ; cur wp ← save wp; cur upd ← save upd ; cur fnt ← cur vf ;

{ restore } do vf ← true; return;

not found : do vf ← false; exit : end;

14  LOW-LEVEL OUTPUT ROUTINES  DVIcopy §200

200* . Low-level output routines. The program uses the binary file variable out file for its main output file; out loc is the number of the byte about to be written next on out file. ⟨ Globals in the outer block 14 ⟩ +≡ out file: byte file; { the file we are writing } outf name: packed array [1 . . FILENAMESIZE ] of char ; out loc: int 32 ; { where we are about to write, in out file } out back : int 32 ; { a back pointer } out max v : int 31 ; { maximum v value so far } out max h: int 31 ; { maximum h value so far } out stack : int 16u; { maximum stack depth } out pages : int 16u; { total number of pages }

202* . To prepare out file for output, we rewrite it. ⟨ Open output file(s) 202* ⟩ ≡

argv (toint (2), outf name); rewrite(out file, outf name); { prepares to write packed bytes to out file }

This code is used in section 292*.

204* . Writing the out file should be done as efficient as possible for a particular system; on many systems this means that a large number of bytes will be accumulated in a buffer and is then written from that buffer to out file. In order to simplify such system dependent changes we use the macro out byte to write the next byte.

define out byte(#) ≡ put byte(#, out file) { write next byte }

211* . Here we define the additional font data fields required for the real fonts used in out file. In order to simplify the translation the fields in the variant for f type = out font type are accessed through the macro out font data. Now we can reuse the field vf fnt field , which is also a font number .

define out font data(#) ≡ font data[#] { access out font type variant fields }

define font out (#) ≡ out font data(#).vf fnt field { font number in out file } ⟨ Cases for font record 104* ⟩ +≡

{ same field as in default font }

§216  DVIcopy  WRITING THE OUTPUT FILE 15

217* . These are the local variables (if any) needed for do pre. ⟨ OUT: Local variables for do pre 217* ⟩ ≡ var k: int 15 ; { general purpose variable }

p, q, r: byte pointer ; { indices into byte mem }

comment : c char pointer ; { preamble comment prefix }

This code is used in section 255.

16  THE MAIN PROGRAM  DVIcopy §249

292* . Now we are ready to put it all together. Here is where starts, and where it ends.

begin set paths (TFM FILE PATH BIT + VF FILE PATH BIT ); initialize;

{ get all variables initialized } if argc ≠ 3 then

begin write ln(´ ␣ ␣ ␣ ␣ ´ ); uexit (1); end;

⟨ Initialize predefined strings 69 ⟩ ⟨ Open input file(s) 131* ⟩ ⟨ Open output file(s) 202* ⟩ do dvi ; { process the entire file } close files and terminate; print ln(´ ␣´ ); end.

§296  DVIcopy  INDEX 17

296* . Index. Pointers to error messages appear here together with the section numbers where each identifier is used.

The following sections were changed by the change file: 1, 3, 9, 10, 13, 16, 17, 23, 75, 76, 77, 89, 103, 104, 108, 110, 116, 117, 118, 120, 129, 131, 134, 155, 157, 165, 182, 189, 195, 196, 200, 202, 204, 211, 217, 292, 296.

a: \underline{74}, \underline{75*} , \underline{76*} , \underline{77*} , \underline{215}. abort : \underline{23*} , 109, 110* , 130, 156. abs : 114, 231, 234, 261, 262. alpha: \underline{123}, 124, 126, 161, 162. any : 173. append byte: \underline{58}, 78, 79, 80, 81, 83, 153, 170, 186,

197, 218, 277, 282, 286. append one: \underline{58}, 180, 182* , 183, 185, 187. argc: 292* . argv : 131* , 202* . ASCII code: \underline{16*} , 17* , 19, 55, 68, 72. axis height : 51. b: \underline{75*} , \underline{76*} , \underline{77*} , \underline{89*} . : 130. : 109. : 156. bad dvi : \underline{130}, 133, 136, 151, 153, 258, 259, 281,

284, 285, 286, 288, 289. bad tfm: \underline{109}, 110* , 113, 120* , 126. bad vf : \underline{156}, 159, 162, 163, 164, 168, 170, 179,

180, 187, 197, 199. banner : \underline{1*} , 3* . bc: \underline{44}, 45, 47, 49, \underline{115}, 120* , 121, 127. bc field : \underline{103*} . begin: 5, 6, 74, 75* , 76* , 77* , 78, 79, 80, 81. begin byte: \underline{74}, \underline{135}, \underline{160}. begin char: \underline{79}, \underline{208}. begin four: \underline{78}, \underline{207}. begin pair: \underline{75*} , \underline{135}, \underline{160}. begin quad: \underline{77*} , \underline{135}, \underline{160}. begin signed: \underline{81}, \underline{210}. begin trio: \underline{76*} , \underline{135}, \underline{160}. begin unsigned: \underline{80}, \underline{209}. beta: \underline{123}, 124, 125, 161. : 114. : 114. : 114. bi : \underline{55}, 58, 68, 218, 279. big op spacing1 : 51. big op spacing5 : 51. bo: \underline{55}, 65, 72, 73, 86, 87, 192, 206, 215, 218. boolean: 79, 144, 147, 153, 172, 176, 178, 196* ,

208, 249, 265, 273. bop: 31, 33, \underline{34}, 36, 37, 41, 141, 143, 220, 249,

256, 281, 285. bot : 50. byte file: \underline{54}, 107, 129* , 154, 200* .

byte mem: 55, \underline{56}, 58, 60, 62, 64, 65, 67, 68, 72,

73, 74, 78, 82, 83, 86, 87, 89* , 173, 174, 178, 179, 190, 192, 206, 215, 217* , 218, 260, 279. byte pointer : \underline{55}, 56, 64, 72, 73, 83, 86, 87, 89* ,

175, 178, 206, 215, 217* , 271, 273. byte ptr : \underline{56}, 58, 59, 62, 64, 65, 67, 68, 71, 83, 179, 181, 182* , 183, 184, 185, 187, 188, 189* , 190, 192, 218, 293.

18  INDEX  DVIcopy §296

c: \underline{76*} , \underline{77*} , \underline{114}. c char pointer : 217* . cc: 41. chain flag : \underline{82}, 83, 85. char : 17* , 88, 200* . : 114. char cl : \underline{141}, 143, 174, 180, 183, 277, 282. char code: 82, 137. char ext : 82, 137. char info: 47. char info word : 45, 47, 48. char offset : \underline{98}, 101, 103* , 106, 165* . char packets : 98, \underline{99}, 106, 165* . char par : \underline{138}, 140, 148, 164, 269. char pixels : 98, \underline{99}, 103* , 127. char pointer : \underline{98}, 99, 106, 115. char res : 82, 137. char widths : 98, \underline{99}, 101, 103* , 115, 121, 126, 127. chars field : \underline{103*} . check sum: 36, 46. : 114. check check sum: \underline{114}, 115, 120* , 197. check design size: \underline{114}, 115, 120* , 197. check field : \underline{103*} . check width: \underline{114}, 179. checked fseek : 134* . Chinese characters: 33. chr : 17* , 19, 21. close files and terminate: \underline{23*} , \underline{291}, 292* . cmd cl : \underline{141}, 142, 146. cmd par : \underline{138}, 139. coding scheme: 46. comm length: \underline{1*} , 218. comment : \underline{217*} , 218. comp char : \underline{79}, 208. comp four : \underline{78}, 207. comp sbyte: \underline{74}, 135. comp signed : \underline{81}, 210. comp spair : \underline{75*} , 135. comp squad : \underline{77*} , 135, 160. comp strio: \underline{76*} , 135, 160. comp ubyte: \underline{74}, 135, 160. comp unsigned : \underline{80}, 209. comp upair : \underline{75*} , 135, 160. comp utrio: \underline{76*} , 135, 160. confusion: \underline{24}, 69, 73, 83, 84, 244, 268, 277. continue: \underline{8}, 83, 84, 85, 273, 277. count : 220, \underline{249}, 256, 281. cs : 40. cur class : \underline{146}, 148, 164, 180, 183, 188, 189* , 230,

233, 261, 262, 269, 277, 282, 283, 285, 288. cur cmd : \underline{146}, 148, 164, 179, 180, 198, 199, 230,

233, 269, 281, 285, 288. cur ext : \underline{147}, 148, 164, 184, 192, 196* , 244, 266,

269, 274, 276. cur fnt : 27, \underline{128}, 151, 164, 168, 171, 179, 183,

184, 196* , 242, 244, 256, 261, 262, 266, 268, 274, 275, 276, 277, 278, 284.

cur h: 231, \underline{252}, 261, 263, 265, 266. cur h dimen: \underline{147}, 148, 164, 185, 236, 238, 263,

265, 269, 273, 282. cur hh: \underline{252}, 261. cur limit : \underline{73}, 74, \underline{83}, 84, 85, \underline{89*} , 273, 276,

277, 278, 279. cur loc: \underline{73}, 74, \underline{83}, 84, 85, \underline{89*} , 277, 278, 279. cur name: \underline{88}, 89* , 110* , 131* , 157* . cur parm: \underline{146}, 148, 151, 152, 153, 164, 168, 169,

170, 179, 180, 186, 198, 230, 233, 261, 262, 269, 277, 282, 283.

cur pckt : \underline{73}, 84, 276, 277. cur pckt length: \underline{59}. cur pos : 134* . cur res : 27, \underline{147}, 148, 164, 184, 192, 196* , 244,

266, 269, 274, 276, 278. cur stack : \underline{252}, 256, 259. cur tfm: \underline{107}, 109, 110* . cur upd : \underline{147}, 148, 164, 183, 184, 185, 188,

196* , 238, 244, 264, 265, 266, 269, 273, 274, 278, 279, 282.

cur v : 234, \underline{252}, 262. cur v dimen: \underline{147}, 148, 164, 185, 238, 265,

269, 282. cur vf : \underline{154}, 156, 179, 192, 196* , 197, 198, 199. cur vf ext : \underline{171}, 179. cur vf res : \underline{171}, 179, 192. cur vf wp: \underline{171}, 179, 192. cur vv : \underline{252}, 262. cur w x : \underline{252}, 261. cur wp: \underline{147}, 164, 192, 196* , 266, 273, 274, 278, 284. cur y z : \underline{252}, 262. d: \underline{77*} , \underline{86}, \underline{114}. d print : \underline{9*} , 114, 115, 118* , 242, 256, 280. d print ln: \underline{9*} , 288. d warn count : 26, \underline{29}, 30. debug: \underline{5}, \underline{7}, \underline{9*} , \underline{68}, \underline{73}, \underline{83}, \underline{84}, \underline{86}, \underline{196*} , \underline{244},

\underline{268}, \underline{280}. Decr : \underline{10*} , 126, 162, 190, 194, 218, 289. decr : 58, 71, 121, 153, 170, 183, 186, 187, 189* , 191,

245, 246, 247, 256, 259, 277, 279, 282, 283, 289. default rule thickness : 51. delim1 : 51. delim2 : 51. den: 33, \underline{35}, 37. denom1 : 51. denom2 : 51. depth: 47. depth index : 47. design size: 46. : 114. design field : \underline{103*} . device: \underline{6}, \underline{92}, \underline{93}, \underline{94}, \underline{95}, \underline{99}, \underline{103*} , \underline{105}, \underline{126},

\underline{127}, \underline{249}, \underline{251}, \underline{253}, \underline{255}, \underline{261}, \underline{262}, \underline{263}, \underline{264},

\underline{265}, \underline{266}, \underline{273}, \underline{282}.

dim1 par : \underline{138}, 140, 148, 164, 269. dim2 par : \underline{138}, 140, 148, 164, 269. dim3 par : \underline{138}, 140, 148, 164, 269. dim4 : 269. dim4 par : \underline{138}, 140, 148, 164, 269. do bop: 219, 220, \underline{256}, 281. do char : 243, \underline{244}, \underline{266}, 278, 284. do down: 232, \underline{233}, \underline{262}, 277, 282. do dvi : \underline{285}, 292* . do eop: 221, \underline{222}, \underline{258}, 281. do font : 240, \underline{241}, \underline{268}, 278, 284. do h pixels : \underline{261}, 263, 265, 266. do nothing : \underline{10*} , 148, 164, 269, 283. do page: \underline{281}, 285. do pop: 225, \underline{226}, \underline{259}, 277, 282. do pre: 217* , 218, \underline{255}, 286. do push: 223, \underline{224}, \underline{259}, 277, 282. do right : 229, \underline{230}, \underline{261}, 277, 282. do rule: 237, 238, \underline{265}, 277, 282. do v pixels : \underline{262}. do vf : \underline{196*} , 268. do vf packet : 270, 271, \underline{273}, 274, 275, 279, 284. do width: 235, \underline{236}, \underline{263}, 273, 282. do xxx : 227, 228, \underline{260}, 277, 282. done: \underline{8}, 178, 180, 242, 268, 273, 276, 277,

281, 282, 283. down: 81, 210, 233, 262, 277, 282. down cl : \underline{141}, 143, 144, 145, 180, 233, 262. down1 : 33, \underline{34}, 140, 143, 144, 145. down2 : 33. down3 : 33. down4 : 33. ds : 40. dup warning : \underline{26}, 29, 83. : 26. dvi : 41. files : 31. dvi back : \underline{287}, 288. dvi byte: \underline{133}, 134* , 135. dvi char cmd : 79, \underline{144}, 145, 148, 164, 269. dvi cl : 137, 141, \underline{142}, 143, 148, 164, 269. DVI copy : \underline{3*} . dvi den: 218, 247, 255, 286, \underline{287}, 288. dvi do font : \underline{153}, 282, 283, 285, 288. dvi down cmd : \underline{144}, 145, 180, 233. dvi e fnts : \underline{149}, 152. dvi eof : \underline{133}. dvi file: 1* , 3* , \underline{129*} , 131* , 132, 133, 134* , 135. dvi first par : \underline{148}, 281, 282, 283, 285, 288. dvi font : \underline{151}, 282. dvi i fnts : \underline{149}, 151, 153. dvi id : \underline{35}, 218, 247, 286, 289. dvi length: \underline{134*} , 289. dvi loc: \underline{129*} , 130, 131* , 134* , 135, 256, 288. dvi mag : 87, 218, 247, 255, 286, \underline{287}, 288. dvi move: \underline{134*} , 288, 289. dvi nf : \underline{149}, 150, 151, 152, 153, 293. dvi num: 218, 247, 255, 286, \underline{287}, 288. dvi pages : \underline{287}, 288. dvi par : 137, 138, \underline{139}, 140, 148, 164, 269. dvi pointer : \underline{136}, 288. dvi pquad : \underline{136}, 153, 286, 288, 289. dvi right cmd : \underline{144}, 145, 180, 230. dvi rule cmd : \underline{144}, 145, 185, 238. dvi sbyte: \underline{135}, 148. dvi spair : \underline{135}, 148. dvi squad : \underline{135}, 136, 148, 153, 281, 288. dvi strio: \underline{135}, 148. dvi ubyte: \underline{135}, 148, 153, 282, 283, 286, 289. dvi upair : \underline{135}, 148, 288. dvi uquad : \underline{136}, 148. dvi utrio: \underline{135}, 148. e: \underline{28}, \underline{83}, \underline{84}, \underline{89*} . ec: \underline{44}, 45, 47, 49, \underline{115}, 120* , 121. ec field : \underline{103*} . ecived: \underline{6}. eight bits : \underline{52}, 54, 55, 74, 75* , 76* , 77* , 79, 80, 81,

83, 84, 89* , 103* , 112, 139, 142, 144, 146, 175, 208, 209, 210, 215, 271.

else: 11. empty packet : \underline{62}, 64, 85, 277. end: 5, 6, 11. endcases: \underline{11}. eof : 113, 133, 134* , 159. eop: 31, 33, \underline{34}, 36, 41, 141, 143, 222, 245, 258,

281, 282, 285. error message: \underline{14}, 294. exit : \underline{8}, 10* , 196* . ext : \underline{26}, \underline{28}, \underline{79}, \underline{83}, \underline{84}, 85, \underline{208}. ext flag : \underline{82}, 83, 85. ext tag : \underline{48}. exten: 48. extensible recipe: 45, 50. extra space: 51. f: \underline{83}, \underline{84}, \underline{87}, \underline{106}, \underline{114}, \underline{115}, \underline{151}, \underline{153}, \underline{168},

\underline{170}, \underline{215}, \underline{273}.

f type: \underline{101}, 103* , 104* , 165* , 211* .

face: 46.

false: 2, 38, 79, 145, 147, 153, 177, 180, 183, 188, 196* , 208, 250, 258, 265, 278, 279, 288.

family name: 46.

fatal message: \underline{14}, 294. FILENAMESIZE : 13* , 200* . final end : \underline{3*} . find packet : \underline{84}, 276. first par : 137. first text char : \underline{17*} , 21. five cases : \underline{137}, 277, 282. fix word : 40, 41, \underline{45}, 46, 51, 122, 161, 162. flag : 82. flush byte: \underline{58}. flush packet : \underline{71}, 197, 218, 260, 286. fnt : 80, 173, 184, 209. fnt cl : \underline{141}, 143, 180, 277, 282. fnt def : 209. fnt def cl : \underline{141}, 143, 180, 282, 283, 285, 288. fnt def1 : 33, \underline{34}, 40, 140, 143, 153, 170, 198, 215. fnt def2 : 33, \underline{40}. fnt def3 : 33, \underline{40}. fnt def4 : 33, \underline{40}, 153, 170. fnt num: 80, 138, 173, 184, 209. fnt num 0 : 33, \underline{34}, 80, 140, 143, 148, 164, 269. fnt num 1 : 33. fnt num 63 : 33. fnt num0 : 41. fnt par : \underline{138}, 140, 148, 164, 269. fnt1 : 33, \underline{34}, 80, 140, 143, 184, 244. fnt2 : 33. fnt3 : 33. fnt4 : 33, 41. font identifier: 46. font types: \underline{12}, 101, 104* , 165* , 211* . font bc: 101, \underline{103*} , 106, 121, 164, 179. font chars : 101, \underline{103*} , 121, 127. font check : 101, \underline{103*} , 114, 115, 153, 170, 197, 215. font data: \underline{102}, 103* , 104* , 115, 165* , 211* . font design: 87, 101, \underline{103*} , 114, 115, 153, 170,

197, 215. font ec: 101, \underline{103*} , 106, 121, 164, 179. font name: 87, 101, \underline{103*} , 115, 118* , 153, 170,

196* , 215. font number : 87, \underline{101}, 102, 106, 107, 114, 115,

128, 149, 151, 153, 154, 165* , 166, 168, 170, 171, 211* , 212, 215, 271.

font out : \underline{211*} , 215, 242, 244. font pixel : \underline{103*} , 266. font record : 102, \underline{103*} . font scaled : 87, 101, \underline{103*} , 115, 118* , 126, 153,

170, 198, 215, 242. font space: 101, \underline{103*} , 105, 126, 261, 262. font type: 101, \underline{103*} , 118* , 196* , 242, 244, 268,

278, 284. font vf chars : \underline{165*} , 199. font vf fnt : \underline{165*} , 179, 198, 276. font vf packet : \underline{165*} , 179, 192, 276. font vf packet end : \underline{165*} . font width: \underline{103*} , 164, 179, 278. font width end : \underline{103*} . forward : 23* . found : \underline{8}, 64, 67, 95, 97, 273, 277. from length: \underline{1*} , 218. ftell : 134* . Fuchs, David Raymond: 31, 38, 39. gubed: \underline{5}. h: \underline{63}, \underline{64}, \underline{95}, \underline{252}. h conv : 95, \underline{249}, 255, 264. h field : \underline{251}, 252, 253. h pixel round : \underline{95}, 254, 261, 282. h pixels : \underline{249}, 263, 265, 273, 282. h resolution: \underline{216}, 255. h rule pixels : \underline{264}, 265. harmless message: \underline{14}, 294. hash code: \underline{60}, 61, 63, 64, 93, 95. hash size: \underline{60}, 62, 65, 94, 96. header : 46. height : 47. height index : 47. hex packet : \underline{86}, 280. hh: 251, \underline{252}, 254. hh field : \underline{251}, 252, 253. history : \underline{14}, 15, 294. i: \underline{18}, \underline{35}, \underline{64}, \underline{219}, \underline{256}. id1 : \underline{68}. id10 : \underline{68}, 69. id2 : \underline{68}. id3 : \underline{68}, 155* . id4 : \underline{68}, 108* .

id5 : \underline{68}, 69.
id6 : \underline{68}, 69.
id7 : \underline{68}, 69.
id8 : \underline{68}.
id9 : \underline{68}, 69.
improper DVI for VF : \underline{41}.
Incr : \underline{10*} , 68, 78, 79, 80, 81, 83, 135, 153, 160,

162, 163, 170, 192, 206, 207, 215, 218, 261, 262, 263, 265, 266.

incr : 26, 27, 28, 58, 64, 65, 67, 71, 73, 89* , 95, 115, 118* , 121, 135, 152, 153, 160, 162, 169, 170, 181, 183, 191, 205, 215, 218, 220, 242, 279.

Incr Decr : \underline{10*} .

incr stack : \underline{181}, 259.

: 280.

initialize: \underline{3*} , 292* .

int 15 : \underline{4}, 89* , 115, 123, 153, 170, 196* , 217* ,

281, 285, \underline{291}. int 16 : \underline{4}, 18, 75* , 95, 115, 135. int 16u: \underline{4}, 25, 75* , 135, 160, 200* , 287. int 23 : \underline{4}. int 24 : \underline{4}, 26, 28, 76* , 83, 84, 135, 147, 160,

171, 196* , 271. int 24u: \underline{4}, 76* , 135, 160.

int 31 : \underline{4}, 81, 87, 103* , 136, 163, 200* , 287.

int 32 : \underline{4}, 52, 77* , 78, 79, 80, 81, 83, 93, 95, 103* , 114, 115, 123, 129* , 134* , 135, 136, 146, 147, 149, 154, 160, 162, 163, 166, 178, 193, 200* , 207, 208, 209, 210, 249, 251, 264, 281, 285, 287.

int 7 : \underline{4}, 29.

int 8 : \underline{4}, 74, 135.

int 8u: \underline{4}, 74, 86, 135, 147, 160, 171, 178, 196* ,

273, 281, 285. integer : 4, 53, 129* . invalid cl : \underline{141}, 143, 180, 282, 283. invalid font : \underline{105}, 128, 164, 198, 220, 256. invalid packet : \underline{83}, 84, 106, 276. invalid width: \underline{94}, 164, 179, 284. italic: 47. italic index : 47. j: \underline{86}, \underline{219}, \underline{256}. Japanese characters: 33. jump out : 3* , \underline{23*} , 24, 25. k: \underline{35}, \underline{64}, \underline{72}, \underline{86}, \underline{87}, \underline{106}, \underline{115}, \underline{153}, \underline{170}, \underline{178}, \underline{196*} ,

\underline{206}, \underline{215}, \underline{217*} , \underline{273}, \underline{281}, \underline{285}, \underline{291}.

kern: 49. kern flag : \underline{49}. Knuth, Donald Ervin: 11, 39. l: \underline{64}, \underline{86}, \underline{215}. last pop: \underline{178}, 180. last text char : \underline{17*} , 21. lcl nf : \underline{166}, 167, 170, 293. lf : \underline{44}. lh: \underline{44}, 45, \underline{115}, 120* . lig kern: 48, 49. lig kern command : 45, 49. lig tag : \underline{48}. list tag : \underline{48}. long char : \underline{41}, 179, 199. loop: \underline{10*} . m: \underline{87}. mag : 33, \underline{35}, 36, 37. make char packets : \underline{106}, 199. make font : \underline{115}, 122, 153, 170. make name: \underline{89*} , 118* , 196* . make packet : 60, \underline{64}, 68, 71, 153, 170, 192. make width: \underline{95}, 126. mark error : \underline{14}, 27, 28, 114. mark fatal : \underline{14}, 23* . mark harmless : \underline{14}, 26, 246. max bytes : \underline{13*} , 55, 58, 293. max chars : \underline{13*} , 98, 106, 121, 126, 293. max cl : \underline{141}. max drift : 254. max font type: \underline{12}, 101. max fonts : \underline{13*} , 101, 105, 118* , 153, 170, 242, 293. max h drift : \underline{254}, 261. max packets : \underline{13*} , 55, 64, 71, 83, 293. max par : \underline{138}. max recursion: \underline{13*} , 270, 279, 280, 293. max v drift : \underline{254}, 262. max widths : \underline{13*} , 92, 95, 293. mid : 50. : 27. move: 173. move zero: \underline{178}, 183, 184. n: \underline{25}, \underline{89*} , \underline{264}. n chars : \underline{99}, 100, 121, 126, 127, 293. n packets : \underline{99}, 100, 106, 293. n recur : 270, \underline{271}, 272, 274, 275, 276, 279. n widths : \underline{93}, 94, 95, 97, 293. name field : \underline{103*} . name length: \underline{13*} , 88, 89* , 129* . nd : \underline{44}, 45. ne: \underline{44}, 45. new font data: \underline{104*} . new font type: \underline{12}, 101, 104* , 118* , 268, 278, 284. new packet : \underline{71}, 197, 218, 255, 260, 286. next char : 49. nf : 101, \underline{102}, 105, 115, 118* , 153, 170, 197, 293. nh: \underline{44}, 45. ni : \underline{44}, 45. nil: 10* . nk : \underline{44}, 45. nl : \underline{44}, 45, 49. no par : \underline{138}, 140, 148, 164, 269. no tag : \underline{48}. nop: 31, 33, \underline{34}, 36, 37, 140, 141, 143, 148, 180. not found : \underline{8}, 157* , 196* . np: \underline{44}, 45. num: 33, \underline{35}, 37. numu: 269. numu par : \underline{138}, 140, 148, 164. num1 : 51. num1 par : \underline{138}, 140, 148, 164, 269. num2 : 51. num2 par : \underline{138}, 140, 148, 164, 269. num3 : 51. num3 par : \underline{138}, 140, 148, 164, 269. num4 : 269. num4 par : \underline{138}, 140, 148, 164. nw : \underline{44}, 45, \underline{115}, 120* , 126. o: \underline{79}, \underline{80}, \underline{81}, \underline{209}, \underline{210}. op byte: 49. optimization: \underline{4}, 74, 78, 113, 123, 133, 159, 204* . ord : 19. oriental characters: 33. othercases: \underline{11}. others : 11. out back : \underline{200*} , 201, 220, 247. out byte: \underline{204*} , 205, 206, 207, 215. out char : \underline{208}, 244. out file: 1* , 3* , 12, \underline{200*} , 202* , 203, 204* , 206, 207,

211* , 212, 218, 246. out fnt : \underline{212}, 220, 244.

out fnt def : \underline{215}, 242, 247.
out fnts : \underline{212}, 242, 247.
out font data: \underline{211*} .
out font type: \underline{12}, 211* , 242, 244.
out four : \underline{207}, 215, 218, 220, 236, 238, 247.

out loc: \underline{200*} , 201, 205, 206, 207, 215, 220, 246, 247.

out max h: \underline{200*} , 201, 231, 247.
out max v : \underline{200*} , 201, 234, 247.
out nf : \underline{212}, 213, 214, 242, 247.

out one: \underline{205}, 208, 209, 210, 218, 220, 222, 224, 226, 230, 233, 236, 238, 245, 246, 247.

out packet : \underline{206}, 218, 228.

out pages : \underline{200*} , 201, 220, 246, 247.
out signed : \underline{210}, 230, 233.
out stack : \underline{200*} , 201, 224, 247.
out unsigned : \underline{209}, 215, 228, 244.
outf name: \underline{200*} , 202* .
output : 3* , \underline{9*} .

overflow : \underline{25}, 58, 64, 69, 71, 89* , 95, 106, 118* , 121, 126, 153, 170, 181, 242, 280, 288. p: \underline{24}, \underline{25}, \underline{64}, \underline{83}, \underline{84}, \underline{86}, \underline{87}, \underline{95}, \underline{106}, \underline{114}, \underline{115},

\underline{206}, \underline{215}, \underline{217*} , \underline{227}, \underline{260}, \underline{273}. p hash: 60, \underline{61}, 62, 66. p link : 60, \underline{61}, 66. p warn count : 27, \underline{29}, 30. packed byte: \underline{55}, 56. pair 32 : \underline{251}. param: 46, 51. pckt char : \underline{79}, 184. pckt extract : \underline{73}, 74, 75* , 76* , 77* , 85, 89* . pckt first par : \underline{269}, 277. pckt four : \underline{78}, 185. pckt length: \underline{57}, 66, 89* , 206, 228. pckt pointer : 24, 25, \underline{55}, 56, 61, 64, 70, 71, 72,

73, 83, 84, 86, 87, 89* , 98, 99, 103* , 107, 154, 206, 215, 260, 271, 273.

pckt ptr : \underline{56}, 59, 62, 64, 66, 67, 71, 83, 192,

218, 293. pckt room: \underline{58}, 68, 78, 79, 80, 81, 83, 153, 170,

186, 197, 218, 277, 282, 286. pckt sbyte: \underline{74}, 269. pckt signed : \underline{81}, 180. pckt spair : \underline{75*} , 269. pckt squad : \underline{77*} , 269. pckt start : 55, \underline{56}, 57, 59, 62, 64, 67, 71, 72, 83,

85, 86, 87, 89* , 192, 206, 215, 218. pckt strio: \underline{76*} , 85, 269. pckt ubyte: \underline{74}, 85, 269, 277. pckt unsigned : \underline{80}, 184, 186. pckt upair : \underline{75*} , 85, 269. pckt utrio: \underline{76*} , 269. pckt warning : \underline{27}, 29, 276. pid init : \underline{68}. pid0 : \underline{68}. pid1 : \underline{68}. pid10 : \underline{68}. pid2 : \underline{68}. pid3 : \underline{68}. pid4 : \underline{68}. pid5 : \underline{68}. pid6 : \underline{68}. pid7 : \underline{68}. pid8 : \underline{68}. pid9 : \underline{68}. pix value: \underline{92}, 93, 99, 249, 251, 264. pix widths : 92, \underline{93}, 94, 95, 98, 127, 273. pl : 41. pop: 32, 33, \underline{34}, 37, 41, 90, 143, 173, 174, 178,

180, 187, 188, 226, 245, 259, 279. pop cl : \underline{141}, 143, 180, 189* , 277, 282. post : 31, 33, \underline{34}, 37, 38, 42, 141, 199, 247, 285, 289. post post : 33, \underline{34}, 37, 38, 247, 288, 289. pre: 31, 33, \underline{34}, 40, 141, 143, 197, 218, 286. preamble comment : \underline{1*} , 218. print : \underline{9*} , 24, 25, 72, 86, 87, 109, 130, 153, 156,

170, 196* , 197, 214, 242, 246, 256, 280, 286, 293. print font : \underline{87}, 109, 115, 156, 196* , 197, 242, 280. print ln: 3* , \underline{9*} , 23* , 24, 25, 26, 27, 28, 86, 109,

114, 115, 130, 156, 196* , 197, 242, 246, 256, 280, 286, 292* , 293, 294.

print packet : 24, 25, \underline{72}, 197, 286. print pascal string : 110* . push: 13* , 32, 33, \underline{34}, 37, 41, 90, 143, 173, 174,

175, 180, 181, 182* , 183, 224, 259. push cl : \underline{141}, 143, 180, 277, 282. put : 79, 138, 147, 173, 174, 188, 193, 208,

277, 278, 279. put byte: 204* . put rule: 33, \underline{34}, 138, 140, 143, 144, 145, 173, 188. put1 : 33, \underline{34}, 79, 137, 140, 143, 144, 145, 148,

164, 269. put2 : 33. put3 : 33. put4 : 33, 137. q: \underline{83}, \underline{84}, \underline{115}, \underline{217*} . quad : 51. r: \underline{83}, \underline{89*} , \underline{217*} . random reading : \underline{2}, 38, 130, 134* , 282, 283, 285. read : 113, 133, 159. read tfm word : \underline{113}, 120* , 121, 126. real : 119, 249. real name of file: \underline{129*} . recur ext : \underline{271}, 274, 280. recur fnt : \underline{271}, 274, 275, 280. recur loc: \underline{271}, 279, 280. recur pckt : \underline{271}, 276, 280. recur pointer : \underline{270}, 271, 273. recur res : \underline{271}, 274, 280. recur used : \underline{271}, 272, 279, 293. recursion: 270. remainder : 47, 48, 49. rep: 50. res : \underline{79}, \underline{208}. reset : 110* , 131* , 157* . restart : \underline{8}. reswitch: \underline{8}, 178, 180, 183, 189* . return: 8, \underline{10*} . rewrite: 202* . right : 81, 210, 230, 261, 277, 282. right cl : \underline{141}, 143, 144, 145, 180, 230, 261. right1 : 33, \underline{34}, 140, 143, 144, 145, 173, 193. right2 : 33. right3 : 33. right4 : 33. round : 87, 95, 120* , 170, 197. rule cl : \underline{141}, 143, 174, 183, 277, 282. rule par : \underline{138}, 140, 148, 164, 269. rule pixels : 33. s: \underline{64}. s warn count : 28, \underline{29}, 30. save ext : \underline{196*} . save limit : \underline{273}, 276, 279. save res : \underline{196*} . save upd : \underline{196*} , \underline{273}, 274, 278. save wp: \underline{196*} , \underline{273}, 274. scaled field : \underline{103*} . second : \underline{153}. set char : 79, 173, 174, 184, 188, 193, 208, 278, 279. set char 0 : 33, \underline{34}, 137, 143. set char 1 : 33. set char 127 : 33. set cur wp: \underline{164}, 284. set paths : 292* . set pos : 134* . set rule: 31, 33, \underline{34}, 138, 140, 143, 144, 145, 147,

148, 164, 173, 174, 188, 193, 236, 269. set1 : 33, \underline{34}, 79, 144, 145, 148, 164, 269. set2 : 33. set3 : 33. set4 : 33, 137. seven bit safe flag : 46. short char0 : 41. short char241 : 41. signed byte: \underline{52}. signed pair : \underline{52}. signed quad : \underline{52}. signed trio: \underline{52}. sixteen bits : \underline{52}. skip byte: 49. slant : \underline{51}. : 25. sp: 35. space: 51. space field : \underline{103*} . space shrink : 51. space stretch: 51. spotless : \underline{14}, 15, 294. stack : \underline{252}, 259. stack pointer : 175, \underline{251}, 252. stack ptr : 175, 224, 245, \underline{252}, 253, 258, 259. stack record : \underline{251}, 252. stack size: \underline{13*} , 181, 251, 252, 288, 293. stack used : \underline{175}, 177, 181, 293. start packet : \underline{83}, 179. stat: \underline{5}. stdout : 9* . stop flag : \underline{49}. str bytes : 58, 69, \underline{70}. str chars : 69, \underline{70}, 106, 121, 126. str fonts : 69, \underline{70}, 118* , 153, 170, 242, 244, 268. str name length: 69, \underline{70}, 89* . str packets : 64, 69, \underline{70}, 71, 73, 83, 84, 277. str recursion: 69, \underline{70}, 280. str stack : 69, \underline{70}, 181, 288. str widths : 69, \underline{70}, 95. stuff : 45. subdrop: 51. subst warning : \underline{28}, 29, 84. : 28. sub1 : 51. sub2 : 51. supdrop: 51. sup1 : 51. sup2 : 51. sup3 : 51. system dependencies: \underline{2}, 3* , 4, 7, 11, 17* , 38, \underline{52}, 53, 55, 74, 78, 87, 89* , 95, 113, 116* , 120* , 123, 133, 134* , 159, 195* , 204* , 291, 292* , 294, 295.

t: \underline{83}.

tag : 47, 48. tats: \underline{5}. temp byte: \underline{178}, 192, \underline{196*} , 197, \underline{281}, 283, \underline{285},

286, 289. temp int : \underline{178}, 179, \underline{281}, \underline{285}, 288, 289. temp pix : \underline{249}, 261, 262. test access : 110* , 129* . test read access : 110* , 157* . text char : \underline{17*} , 19, 129* . text file: \underline{17*} . tfm: 41. files : 90. ´ : 110* . tfm byte: \underline{113}. tfm b0 : \underline{112}, 113, 120* , 121, 126, 162, 163. tfm b01 : \underline{120*} . tfm b1 : \underline{112}, 113, 120* , 125, 126, 162, 163. tfm b2 : \underline{112}, 113, 120* , 125, 126, 162, 163. tfm b23 : \underline{120*} . tfm b3 : \underline{112}, 113, 120* , 125, 126, 162, 163. tfm conv : \underline{119}, 120* , 170, 197, 286. TFM default area: 116* . tfm ext : \underline{107}, 108* , 118* . tfm file: \underline{107}, 110* , 111, 113. TFM FILE PATH : 110* . TFM FILE PATH BIT : 292* . tfm squad : \underline{120*} . tfm uquad : \underline{120*} . : 24. three cases : \underline{137}, 180, 269. toint : 75* , 76* , 77* , 120* , 131* , 202* . top: 50. true: 2, 10* , 133, 134* , 145, 147, 148, 153, 159,

164, 177, 178, 180, 183, 184, 196* , 249, 257, 264, 265, 269, 278.

trunc: 264. twentyfour bits : \underline{52}. two cases : \underline{137}, 148, 180. type field : \underline{103*} . type flag : \underline{82}, 84. type setting : \underline{249}, 250, 256, 257, 258, 267, 281. uexit : 23* , 292* . undefined commands : \underline{34}. upd : \underline{79}, \underline{208}. : 130. : 109. : 156. v: \underline{252}. v conv : 95, \underline{249}, 255, 264. v field : \underline{251}, 252, 253. v pixel round : \underline{95}, 254, 262. v pixels : \underline{249}, 265. v resolution: \underline{216}, 255. v rule pixels : \underline{264}, 265. vf byte: \underline{159}, 160, 162, 163. vf char type: \underline{176}, 177, 184. vf chars field : \underline{165*} . vf complex : \underline{192}, 193. VF default area: 195* . vf do char : \underline{178}, 199. vf do font : \underline{170}, 198. vf e fnts : \underline{166}, 169. vf eof : \underline{159}. vf ext : \underline{154}, 155* , 196* . vf file: \underline{154}, 157* , 158, 159, 160. VF FILE PATH : 157* . VF FILE PATH BIT : 292* . vf first par : \underline{164}, 180. vf fixp: \underline{163}, 170. vf fix1 : \underline{162}, 164. vf fix2 : \underline{162}, 164. vf fix3 : \underline{162}, 164. vf fix3u: \underline{162}, 179. vf fix4 : \underline{162}, 164, 179. vf fnt : \underline{171}, 179, 183, 184. vf fnt field : \underline{165*} , 211* . vf font : \underline{168}, 180. vf font data: \underline{165*} . vf font type: \underline{12}, 165* , 196* , 278, 284. vf group: \underline{174}, 187. vf i fnts : \underline{166}, 168, 170, 198.

vf id : \underline{40}, 197.
vf last : 174, \underline{175}, 179, 182* , 184, 185, 186, 187,

188, 190, 192. vf last end : 174, \underline{175}, 179, 182* , 183, 187, 190.

vf last loc: 174, \underline{175}, 184, 185, 187, 190, 192.
vf limit : \underline{154}, 179, 180.
vf loc: \underline{154}, 156, 157* , 160, 162, 163, 179, 180.
vf move: \underline{175}, 177, 180, 182* , 189* .
vf nf : \underline{166}, 168, 169, 170, 198.
vf other : \underline{174}, 177, 179, 182* , 184, 186, 190.
vf pquad : \underline{163}, 170, 197.

vf ptr : 174, \underline{175}, 179, 180, 181, 182* , 183, 184, 185,

186, 187, 188, 189* , 190, 191. vf push loc: 174, \underline{175}, 179, 181, 182* , 183, 187,

188, 192. vf push num: 174, \underline{175}, 181, 187, 189* , 191. vf put : \underline{174}, 177, 192. vf rule: \underline{174}, 177, 187. vf rule type: \underline{176}, 177, 185. vf set : \underline{174}, 177. vf simple: \underline{192}, 193, 278. vf squad : \underline{160}, 163, 164, 170, 197, 198. vf state: \underline{172}, 175. vf strio: \underline{160}, 164, 179. vf type: \underline{174}, 175, 176. vf ubyte: \underline{160}, 164, 170, 179, 186, 197, 198, 199. vf upair : \underline{160}, 164, 198. vf uquad : \underline{163}, 164, 179. vf utrio: \underline{160}, 164, 198. visible: \underline{237}, \underline{265}. vv : 251, \underline{252}, 254. vv field : \underline{251}, 252, 253. w: \underline{95}, \underline{115}, \underline{252}. w cl : \underline{141}, 143, 145, 180, 261. w hash: 92, \underline{93}, 94, 97. w link : 92, \underline{93}, 94, 97. w x field : \underline{251}, 252, 253. : 57. : 104* , 165* , 211* . width: 47. width dimen: \underline{193}, 194, 236, 282. width index : 47. width pointer : \underline{92}, 93, 95, 98, 99, 114, 115, 147,

171, 196* , 273. widths : 92, \underline{93}, 94, 95, 97, 103* , 114, 115, 266, 273. write: 9* . write ln: 9* , 292* . w0 : 33, \underline{34}, 143, 172, 230. w0 cl : \underline{141}, 143, 180, 261, 277, 282. w1 : 33, \underline{34}, 140, 143, 144, 145. w2 : 33. w3 : 33. w4 : 33. x: \underline{35}, \underline{78}, \underline{80}, \underline{81}, \underline{95}, \underline{136}, \underline{162}, \underline{163}, \underline{207}, \underline{209},

\underline{210}, \underline{252}. x cl : \underline{141}, 143, 144, 145. x height : 51. xchr : \underline{19}, 20, 21, 72, 86, 87, 89* . xclause: 10* . xord : \underline{19}, 21, 218. xx : \underline{81}. xxx : 80, 173, 183, 209. xxx cl : \underline{141}, 143, 183, 277, 282, 283. xxx1 : 33, \underline{34}, 140, 143, 186, 228. xxx2 : 33. xxx3 : 33. xxx4 : 33, \underline{34}. x0 : 33, \underline{34}, 143, 172, 230. x0 cl : \underline{141}, 143. x1 : 33, \underline{34}, 140, 143, 144, 145. x2 : 33. x3 : 33. x4 : 33, 193. y: \underline{252}. y cl : \underline{141}, 143, 145, 180, 262. y z field : \underline{251}, 252, 253. y0 : 33, \underline{34}, 143, 172, 233. y0 cl : \underline{141}, 143, 180, 262, 277, 282. y1 : 33, \underline{34}, 140, 143, 144, 145. y2 : 33. y3 : 33. y4 : 33. z: \underline{123}, \underline{252}. z cl : \underline{141}, 143, 144, 145. zero: 173. zero stack : \underline{252}, 253, 256. zero width: \underline{94}. z0 : 33, \underline{34}, 143, 172, 233. z0 cl : \underline{141}, 143. z1 : 33, \underline{34}, 140, 143, 144, 145. z2 : 33. z3 : 33. z4 : 33, 173.

26  NAMES OF THE SECTIONS  DVIcopy §296

⟨ Basic printing procedures 72, 86, 87 ⟩ Used in section 23*.

⟨ Cases for font record 104*, 165*, 211* ⟩ Used in section 103*. ⟨ Close input file(s) 132 ⟩ Used in section 291. ⟨ Close output file(s) 203 ⟩ Used in section 291.

⟨ Compare packet p with current packet, goto found if equal 67 ⟩ Used in section 66. ⟨ Compiler directives 7 ⟩ Used in section 3*. ⟨ Compute the packet hash code h 65 ⟩ Used in section 64. ⟨ Compute the packet location p 66 ⟩ Used in section 64. ⟨ Compute the width hash code h 96 ⟩ Used in section 95. ⟨ Compute the width location p, goto found unless the value is new 97 ⟩ Used in section 95. ⟨ Constants in the outer block 13* ⟩ Used in section 3*. ⟨ DVI: Find the postamble 289 ⟩ Used in section 288.

⟨ DVI: Locate font cur parm 152 ⟩ Used in sections 151 and 153.

⟨ DVI: Process a page; then goto done 282 ⟩ Used in section 281. ⟨ DVI: Process the postamble 288 ⟩ Used in section 285. ⟨ DVI: Process the preamble 286 ⟩ Used in section 285. ⟨ DVI: Skip a page; then goto done 283 ⟩ Used in section 281.

⟨ DVI: Typeset a char 284 ⟩ Used in section 282. ⟨ Define a new font 118* ⟩ Used in section 115.

⟨ Determine whether this page should be processed or skipped 257 ⟩ Used in section 256.

⟨ Error handling procedures 23*, 24, 25, 109, 130, 156 ⟩ Used in section 3*.

⟨ Finish output file(s) 267 ⟩ Used in section 291.

⟨ Globals in the outer block 14, 19, 29, 56, 61, 70, 73, 88, 93, 99, 102, 107, 112, 119, 128, 129*, 139, 142, 144, 146, 147,

149, 154, 161, 166, 171, 175, 176, 193, 200*, 212, 249, 252, 271, 287 ⟩ Used in section 3*. ⟨ Initialize predefined strings 69, 108*, 155* ⟩ Used in section 292*.

⟨ Local variables for initialization 18, 63 ⟩ Used in section 3*. ⟨ Locate character packet for extension ext 85 ⟩ Used in sections 83 and 84. ⟨ OUT: Finish incomplete page 245 ⟩ Used in section 267. ⟨ OUT: Finish output file(s) 246 ⟩ Used in section 267. ⟨ OUT: Local variables for do char 243 ⟩ Used in section 266. ⟨ OUT: Local variables for do down 232 ⟩ Used in section 262. ⟨ OUT: Local variables for do eop 221 ⟩ Used in section 258. ⟨ OUT: Local variables for do font 240 ⟩ Used in section 268. ⟨ OUT: Local variables for do pop 225 ⟩ Used in section 259. ⟨ OUT: Local variables for do pre 217* ⟩ Used in section 255. ⟨ OUT: Local variables for do push 223 ⟩ Used in section 259. ⟨ OUT: Local variables for do right 229 ⟩ Used in section 261. ⟨ OUT: Local variables for do width 235 ⟩ Used in section 263. ⟨ OUT: Look for a font file after trying to read the file; if found goto done 242 ⟩ Used in section 268. ⟨ OUT: Look for a font file before trying to read the file; if found goto done 241 ⟩ Used in section 268. ⟨ OUT: More local variables for do bop 219 ⟩ Used in section 256. ⟨ OUT: More local variables for do rule 237 ⟩ Used in section 265. ⟨ OUT: More local variables for do xxx 227 ⟩ Used in section 260.

⟨ OUT: Move down 234 ⟩ Used in section 262. ⟨ OUT: Move right 231 ⟩ Used in sections 261, 263, 265, and 266. ⟨ OUT: Process a bop 220 ⟩ Used in section 256. ⟨ OUT: Process a down or y or z 233 ⟩ Used in section 262. ⟨ OUT: Process a pop 226 ⟩ Used in section 259. ⟨ OUT: Process a push 224 ⟩ Used in section 259. ⟨ OUT: Process a right or w or x 230 ⟩ Used in section 261. ⟨ OUT: Process an eop 222 ⟩ Used in section 258. ⟨ OUT: Process an xxx 228 ⟩ Used in section 260.

§296  DVIcopy  NAMES OF THE SECTIONS 27

⟨ OUT: Process the pre 218 ⟩ Used in section 255. ⟨ OUT: Typeset a visible rule 238 ⟩ Used in sections 239 and 265. ⟨ OUT: Typeset a char 244 ⟩ Used in section 266. ⟨ OUT: Typeset a width 236 ⟩ Used in section 263.

⟨ OUT: Typeset an invisible rule 239 ⟩ Used in section 265. ⟨ OUT: Write the postamble 247 ⟩ Used in section 246.

⟨ Open input file(s) 131* ⟩ Used in section 292*. ⟨ Open output file(s) 202* ⟩ Used in section 292*.

⟨ Print memory usage statistics 293 ⟩ Used in section 291. ⟨ Print more font usage statistics 214 ⟩ Used in section 293. ⟨ Print more memory usage statistics 248 ⟩ Used in section 293.

⟨ Print the job history 294 ⟩ Used in section 291. ⟨ Replace z by z′ and compute α, β 124 ⟩ Used in sections 126 and 198. ⟨ Scaled value of tfm b1 . . tfm b3 125 ⟩ Used in sections 126, 162, 162, 162, 162, 162, and 163. ⟨ Set initial values 15, 20, 21, 30, 62, 94, 100, 105, 140, 143, 145, 150, 167, 177, 194, 201, 213, 250, 253, 272 ⟩

Used in section 3*. ⟨ TFM: Close tfm file 111 ⟩ Used in section 118*.

⟨ TFM: Convert character-width indices to character-width pointers 127 ⟩ Used in section 118*.

⟨ TFM: Open tfm file 110* ⟩ Used in section 118*.

⟨ TFM: Read and convert the width values 126 ⟩ Used in section 118*. ⟨ TFM: Read past the header data 120* ⟩ Used in section 118*. ⟨ TFM: Store character-width indices 121 ⟩ Used in section 118*.

⟨ Types in the outer block 4, 16*, 17*, 52, 54, 55, 60, 82, 92, 98, 101, 103*, 138, 141, 172, 174, 251, 270 ⟩

Used in section 3*.

⟨ VF: Append commands to the character packet 180 ⟩ Used in section 178.

⟨ VF: Apply rule 3 or 4 189* ⟩ Used in section 187. ⟨ VF: Apply rule 5 191 ⟩ Used in section 187. ⟨ VF: Apply rule 6 190 ⟩ Used in section 187.

⟨ VF: Build the final form of the character packet 192 ⟩ Used in section 178.

⟨ VF: Close vf file 158 ⟩ Used in section 196*.

⟨ VF: Display the recursion traceback and terminate 280 ⟩ Used in section 279.

⟨ VF: Do a char , rule, or xxx 183 ⟩ Used in section 180. ⟨ VF: Do a fnt , a char , or both 184 ⟩ Used in section 183. ⟨ VF: Do a pop 187 ⟩ Used in section 180. ⟨ VF: Do a push 181 ⟩ Used in section 180. ⟨ VF: Do a rule 185 ⟩ Used in section 183. ⟨ VF: Do an xxx 186 ⟩ Used in section 183.

⟨ VF: Enter a new recursion level 279 ⟩ Used in section 278. ⟨ VF: Initialize the character packet 179 ⟩ Used in section 178. ⟨ VF: Initialize variables for do vf packet ; or goto done 276 ⟩ Used in section 273. ⟨ VF: Interpret the commands in the packet 277 ⟩ Used in section 273.

⟨ VF: Locate font cur parm 169 ⟩ Used in sections 168 and 170. ⟨ VF: Open vf file or goto not found 157* ⟩ Used in section 196*.

⟨ VF: Prepare for rule 4 188 ⟩ Used in section 187. ⟨ VF: Process the character packets 199 ⟩ Used in section 196*. ⟨ VF: Process the font definitions 198 ⟩ Used in section 196*. ⟨ VF: Process the preamble 197 ⟩ Used in section 196*. ⟨ VF: Restore values on exit from do vf packet 275 ⟩ Used in section 273. ⟨ VF: Save values on entry to do vf packet 274 ⟩ Used in section 273.

⟨ VF: Start a new level 182* ⟩ Used in sections 181 and 191. ⟨ VF: Typeset a char 278 ⟩ Used in section 277.

⟨ Variables for scaling computation 123 ⟩ Used in sections 115 and 161.

The DVIcopy processor

(Version 1.0, August 1990)

Section Page

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 2 The character set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 4 Reporting errors to the user . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 5 Device-independent file format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 6 Virtual fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 6 Font metric data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 6 Binary data and binary files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 6 File names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 7 Defining fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 8 Low-level DVI input routines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 11 Low-level VF input routines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 12 Reading VF files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 13 Low-level output routines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 14 Writing the output file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 15 Subroutines for typesetting commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 16 Interpreting VF packets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 16 Interpreting the DVI file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 16 The main program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 16 System-dependent changes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 17 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 17

This program was developed at the Max-Planck-Instiut für Physik (Werner-Heisenberg-Institut), Munich, Germany. ‘TEX’ is a trademark of the American Mathematical Society.