§1  TEX82  PART 1: INTRODUCTION 3

2* . The present implementation has a long ancestry, beginning in the summer of 1977, when Michael F. Plass and Frank M. Liang designed and coded a prototype based on some specifications that the author had made in May of that year. This original protoTEX included macro definitions and elementary manipulations on boxes and glue, but it did not have line-breaking, page-breaking, mathematical formulas, alignment routines, error recovery, or the present semantic nest; furthermore, it used character lists instead of token lists, so that a control sequence like was represented by a list of seven characters. A complete version of TEX was designed and coded by the author in late 1977 and early 1978; that program, like its prototype, was written in the SAIL language, for which an excellent debugging system was available. Preliminary plans to convert the SAIL code into a form somewhat like the present “web” were developed by Luis Trabb Pardo and the author at the beginning of 1979, and a complete implementation was created by Ignacio A. Zabala in 1979 and 1980. The TEX82 program, which was written by the author during the latter part of 1981 and the early part of 1982, also incorporates ideas from the 1979 implementation of TEX in MESA that was written by Leonidas Guibas, Robert Sedgewick, and Douglas Wyatt at the Xerox Palo Alto Research Center. Several hundred refinements were introduced into TEX82 based on the experiences gained with the original implementations, so that essentially every part of the system has been substantially improved. After the appearance of “Version 0” in September 1982, this program benefited greatly from the comments of many other people, notably David R. Fuchs and Howard W. Trickey. A final revision in September 1989 extended the input character set to eight-bit codes and introduced the ability to hyphenate words from different languages, based on some ideas of Michael J. Ferguson.

No doubt there still is plenty of room for improvement, but the author is firmly committed to keeping TEX82 “frozen” from now on; stability and reliability are to be its main virtues.

On the other hand, the description can be extended without changing the core of TEX82 itself, and the program has been designed so that such extensions are not extremely difficult to make. The banner string defined here should be changed whenever TEX undergoes any modifications, so that it will be clear which version of TEX might be the guilty party when a problem arises.

If this program is changed, the resulting system should not be called ‘TEX’; the official name ‘TEX’ by itself is reserved for software systems that are fully compatible with each other. A special test suite called the “ test” is available for helping to determine whether a particular implementation deserves to be known as ‘TEX’ [cf. Stanford Computer Science report CS1027, November 1984].

4  PART 1: INTRODUCTION  TEX82 §4

define banner ≡ ´ ␣ ␣ ␣ ␣ ␣ ´ { printed when TEX starts } 4* . The program begins with a normal Pascal program heading, whose components will be filled in later, using the conventions of . For example, the portion of the program called ‘⟨ Global variables 13 ⟩’ below will be replaced by a sequence of variable declarations that starts in §13 of this documentation. In this way, we are able to define each individual global variable when we are prepared to understand what it means; we do not have to define all of the globals at once. Cross references in §13, where it says “See also sections 20, 26, …,” also make it possible to look at the set of all global variables, if desired. Similar remarks apply to the other portions of the program heading.

define mtype ≡ t y p e { this is a coding trick: } format mtype ≡ type { ‘mtype’ will be equivalent to ‘type’ } format type ≡ true { but ‘type’ will not be treated as a reserved word }

⟨ Compiler directives 9* ⟩ program TEX ; { all file names are defined dynamically }

const ⟨ Constants in the outer block 11* ⟩ mtype ⟨ Types in the outer block 18 ⟩ var ⟨ Global variables 13 ⟩ procedure initialize; { this procedure gets things started properly }

var ⟨ Local variables for initialization 19* ⟩ begin ⟨ Initialize whatever TEX might access 8* ⟩ end;

⟨ Basic printing procedures 57 ⟩ ⟨ Error handling procedures 78 ⟩

6* . Three labels must be declared in the main program, so we give them symbolic names.

define start of TEX = 1 { go here when TEX’s variables are initialized } define end of TEX = 9998 { go here to close files and terminate gracefully } define final end = 9999 { this label marks the ending of the program }

⟨ Labels in the outer block 6* ⟩ ≡ start of TEX, end of TEX, final end ; { key control points }

7* . Some of the code below is intended to be used only when diagnosing the strange behavior that sometimes occurs when TEX is being installed or when system wizards are fooling around with TEX without quite knowing what they are doing. Such code will not normally be compiled; it is delimited by the codewords ‘debug … gubed’, with apologies to people who wish to preserve the purity of English.

Similarly, there is some conditional code delimited by ‘stat … tats’ that is intended for use when statistics are to be kept about TEX’s memory usage. The stat … tats code also implements diagnostic information for and .

define debug ≡ ifdef (´ ´ ) define gubed ≡ endif (´ ´ ) format debug ≡ begin format gubed ≡ end define stat ≡ ifdef (´ ´ ) define tats ≡ endif (´ ´ ) format stat ≡ begin format tats ≡ end 8* . This program has two important variations: (1) There is a long and slow version called , which does the extra calculations needed to initialize TEX’s internal tables; and (2) there is a shorter and faster production version, which cuts the initialization to a bare minimum. Parts of the program that are needed in (1) but not in (2) are delimited by the codewords ‘init … tini’.

define init ≡ ifdef (´ ´ )

define tini ≡ endif (´ ´ )

format init ≡ begin

format tini ≡ end ⟨ Initialize whatever TEX might access 8* ⟩ ≡

⟨ Set initial values of key variables 21 ⟩

init ⟨ Initialize table entries (done by only) 164 ⟩ tini

This code is used in section 4*.

9* . If the first character of a Pascal comment is a dollar sign, Pascal-H treats the comment as a list of “compiler directives” that will affect the translation of this program into machine language. The directives shown below specify full checking and inclusion of the Pascal debugger when TEX is being debugged, but they cause range checking and other redundant code to be eliminated when the production system is being generated. Arithmetic overflow will be detected in all cases. ⟨ Compiler directives 9* ⟩ ≡

This code is used in section 4*.

11* . The following parameters can be changed at compile time to extend or reduce TEX’s capacity. They may have different values in and in production versions of TEX.

define file name size ≡ FILENAMESIZE { Get value from . } ⟨ Constants in the outer block 11* ⟩ ≡

mem max = 262140; { greatest index in TEX’s internal mem array; must be strictly less than

max halfword ; must be equal to mem top in , otherwise ≥ mem top } mem min = 0; { smallest index in TEX’s internal mem array; must be min halfword or more; must be

equal to mem bot in , otherwise ≤ mem bot } buf size = 3000; { maximum number of characters simultaneously present in current lines of open files

and in control sequences between and ; must not exceed max halfword } error line = 79; { width of context lines on terminal error messages } half error line = 50; { width of first lines of contexts in terminal error messages; should be between 30

and error line − 15 } max print line = 79; { width of longest text lines output; should be at least 60 } stack size = 300; { maximum number of simultaneous input sources } max in open = 15;

{ maximum number of input files and error insertions that can be going on simultaneously } font max = 255; { maximum internal font number; must not exceed max quarterword and must be at

most font base + 256 } font mem size = 72000; { number of words of font info for all fonts } param size = 60; { maximum number of simultaneous macro parameters } nest size = 40; { maximum number of semantic levels simultaneously active } max strings = 7500; { maximum number of strings; must not exceed max halfword } string vacancies = 74000; { the minimum number of characters that should be available for the user’s

control sequences and font names, after TEX’s own error messages are stored } pool size = 100000; { maximum number of characters in strings, including all error messages and help

texts, and the names of all fonts and control sequences; must exceed string vacancies by the total length of TEX’s own strings, which is currently about 23000 }

save size = 4000; { space for saving values outside of current group; must be at most max halfword } trie size = 24000; { space for hyphenation patterns; should be larger for than it is in production

versions of TEX } trie op size = 1000; { space for “opcodes” in the hyphenation patterns } neg trie op size = −1000; { for lower trie op hash array bound } dvi buf size = 16384; { size of the output buffer; must be a multiple of 8 } pool name = ´ ´ ; { string of length file name size; tells where the string pool appears } mem top = 262140; { largest index in the mem array dumped by ; must be substantially larger

than mem bot and not greater than mem max }

This code is used in section 4*.

12* . Like the preceding parameters, the following quantities can be changed at compile time to extend or reduce TEX’s capacity. But if they are changed, it is necessary to rerun the initialization program to generate new tables for the production TEX program. One can’t simply make helter-skelter changes to the following constants, since certain rather complex initialization numbers are computed from them. They are defined here using macros, instead of being put into Pascal’s const list, in order to emphasize this distinction.

define mem bot = 0

{ smallest index in the mem array dumped by ; must not be less than mem min }

define font base = 0 { smallest internal font number; must not be less than min quarterword } define hash size = 9500 { maximum number of control sequences; it should be at most about

(mem max − mem min)/10 }

define hash prime = 7919 { a prime number equal to about 85% of hash size } define hyph size = 607 { another prime; the number of exceptions }

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

define negate(#) ≡ # ← −# { change the sign of a variable } define loop ≡ while true do { repeat over and over until a goto happens } format loop ≡ xclause { ’s xclause acts like ‘while true do’ } define do nothing ≡ { empty statement } define return ≡ goto exit { terminate a procedure call } format return ≡ nil define empty = 0 { symbolic name for a null constant }

8  PART 2: THE CHARACTER SET  TEX82 §17

19* . The original Pascal compiler was designed in the late 60s, when six-bit character sets were common, so it did not make provision for lowercase letters. Nowadays, of course, we need to deal with both capital and small letters in a convenient way, especially in a program for typesetting; so the present specification of TEX has been written under the assumption that the Pascal compiler and run-time system permit the use of text files with more than 64 distinguishable characters. More precisely, we assume that the character set contains at least the letters and symbols associated with ASCII codes ´ 40 through ´ 176 ; all of these characters are now available on most computer terminals.

Since we are dealing with more characters than were present in the first Pascal compilers, we have to decide what to call the associated data type. Some Pascals use the original name char for the characters in text files, even though there now are more than 64 such characters, 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 that are converted to and from ASCII code when they are input and output. 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 } ⟨ Local variables for initialization 19* ⟩ ≡ i: integer ;

See also sections 163 and 927. This code is used in section 4*.

23* . The ASCII code is “standard” only to a certain extent, since many computer installations have found it advantageous to have ready access to more than 94 printing characters. Appendix C of The TEXbook gives a complete specification of the intended correspondence between characters and TEX’s internal representation.

If TEX is being used on a garden-variety Pascal for which only standard ASCII codes will appear in the input and output files, it doesn’t really matter what codes are specified in xchr [0 . . ´ 37 ], but the safest policy is to blank everything out by using the code shown below.

However, other settings of xchr will make TEX more friendly on computers that have an extended character set, so that users can type things like ‘ ’ instead of ‘ ’. People with extended character sets can assign codes arbitrarily, giving an xchr equivalent to whatever characters the users of TEX are allowed to have in their input files. It is best to make the codes correspond to the intended interpretations as shown in Appendix C whenever possible; but this is not necessary. For example, in countries with an alphabet of more than 26 letters, it is usually best to map the additional letters into codes less than ´ 40 . To get the most “permissive” character set, change ´ ␣´ on the right of these assignment statements to chr (i). ⟨ Set initial values of key variables 21 ⟩ +≡

for i ← 0 to ´ 37 do xchr [i] ← chr (i);

for i ← ´ 177 to ´ 377 do xchr [i] ← chr (i);

§25  TEX82  PART 3: INPUT AND OUTPUT 9

25* . Input and output. The bane of portability is the fact that different operating systems treat input and output quite differently, perhaps because computer scientists have not given sufficient attention to this problem. People have felt somehow that input and output are not part of “real” programming. Well, it is true that some kinds of programming are more fun than others. With existing input/output conventions being so diverse and so messy, the only sources of joy in such parts of the code are the rare occasions when one can find a way to make the program a little less bad than it might have been. We have two choices, either to attack I/O now and get it over with, or to postpone I/O until near the end. Neither prospect is very attractive, so let’s get it over with.

The basic operations we need to do are (1) inputting and outputting of text, to or from a file or the user’s terminal; (2) inputting and outputting of eight-bit bytes, to or from a file; (3) instructing the operating system to initiate (“open”) or to terminate (“close”) input or output from a specified file; (4) testing whether the end of an input file has been reached.

TEX needs to deal with two kinds of files. We shall use the term alpha file for a file that contains textual data, and the term byte file for a file that contains eight-bit binary information. These two types turn out to be the same on many computers, but sometimes there is a significant distinction, so we shall be careful to distinguish between them. Standard protocols for transferring such files from computer to computer, via high-speed networks, are now becoming available to more and more communities of users.

I/O in C is done using standard I/O. We will define the path numbers in an include file for C which are used in searching for files to be read. We’ll define all the file types in C also. ⟨ Types in the outer block 18 ⟩ +≡

eight bits = 0 . . 255; { unsigned one-byte quantity }

27* . All of the file opening functions are defined in C.

28* . And all the file closing routines as well.

31* . The input ln function brings the next line of input from the specified file into available positions of the buffer array and returns the value true, unless the file has already been entirely read, in which case it returns false and sets last ← first . In general, the ASCII code numbers that represent the next line of the file are input into buffer [first ], buffer [first + 1], …, buffer [last − 1]; and the global variable last is set equal to first plus the length of the line. Trailing blanks are removed from the line; thus, either last = first (in which case the line was entirely blank) or buffer [last − 1] ≠ ␣ .

An overflow error is given, however, if the normal actions of input ln would make last ≥ buf size; this is done so that other parts of TEX can safely look at the contents of buffer [last + 1] without overstepping the bounds of the buffer array. Upon entry to input ln, the condition first < buf size will always hold, so that there is always room for an “empty” line.

The variable max buf stack , which is used to keep track of how large the buf size parameter must be to accommodate the present job, is also kept up to date by input ln.

If the bypass eoln parameter is true, input ln will do a get before looking at the first character of the line; this skips over an eoln that was in f↑. The procedure does not do a get when it reaches the end of the line; therefore it can be used to acquire input from the user’s terminal as well as from ordinary text files.

Standard Pascal says that a file should have eoln immediately before eof , but TEX needs only a weaker restriction: If eof occurs in the middle of a line, the system function eoln should return a true result (even though f↑ will be undefined).

Since the inner loop of input ln is part of TEX’s “inner loop”—each character of input comes in at this place—it is wise to reduce system overhead by making use of special routines that read in an entire array of characters at once, if such routines are available. The following code uses standard Pascal to illustrate what needs to be done, but finer tuning is often possible at well-developed Pascal sites.

We define input ln in C, for efficiency.

10  PART 3: INPUT AND OUTPUT  TEX82 §32

32* . The user’s terminal acts essentially like other files of text, except that it is used both for input and for output. When the terminal is considered an input file, the file variable is called term in, and when it is considered an output file the file variable is term out .

define term in ≡ stdin { the terminal as an input file }

define term out ≡ stdout { the terminal as an output file }

33* . Here is how to open the terminal files. t open out does nothing. t open in, on the other hand, does the work of “rescanning,” or getting any command line arguments the user has provided. It’s defined in C.

define t open out ≡ { output already open for text output }

34* . Sometimes it is necessary to synchronize the input/output mixture that happens on the user’s terminal, and three system-dependent procedures are used for this purpose. The first of these, update terminal , is called when we want to make sure that everything we have output to the terminal so far has actually left the computer’s internal buffers and been sent. The second, clear terminal , is called when we wish to cancel any input that the user may have typed ahead (since we are about to issue an unexpected error message). The third, wake up terminal , is supposed to revive the terminal if the user has disabled it by some instruction to the operating system. The following macros show how these operations can be specified with UNIX. update terminal does an fflush (via the macro flush), since that’s easy. wake up terminal and clear terminal are defined in C routines, if desired.

define update terminal ≡ flush(term out )

37* . The following program does the required initialization. Iff anything has been specified on the command line, then t open in will return with last > first . function init terminal : boolean; { gets the terminal input started }

label exit ;

begin t open in;

if last > first then begin loc ← first ; while (loc < last ) ∧ (buffer [loc] = ´ ␣´ ) do incr (loc); if loc < last then

begin init terminal ← true; goto exit ;

end; end;

loop begin wake up terminal ; write(term out , ´ ´ ); update terminal ;

if ¬input ln(term in, true) then begin { this shouldn’t happen } write ln(term out ); write(term out , ´ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ´ ); init terminal ← false; return; end; loc ← first ; while (loc < last ) ∧ (buffer [loc] = ␣ ) do incr (loc); if loc < last then

begin init terminal ← true; return; { return unless the line was all blank } end;

write ln(term out , ´ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ´ ); end;

exit : end;

§38  TEX82  PART 4: STRING HANDLING 11

51* . define bad pool (#) ≡ begin wake up terminal ; write ln(term out , #); a close(pool file); get strings started ← false; return; end

⟨ Read the other strings from the file and return true, or give an error message and return

false 51* ⟩ ≡

vstrcpy (name of file + 1, pool name); { copy the string } name of file[0] ← ´ ␣´ ; name of file[strlen(pool name) + 1] ← ´ ␣´ ; if a open in(pool file, TEX POOL PATH ) then

begin c ← false; repeat ⟨ Read one string, but return false if the string memory space is getting too tight for

comfort 52* ⟩; until c; a close(pool file); get strings started ← true; end

else begin { Like bad pool , but must not close file if we never opened it } wake up terminal ; write ln(term out , ´ ␣ ␣ ´ ´ ␣ ␣ ´ ); get strings started ← false; return; end

This code is used in section 47.

52* . ⟨ Read one string, but return false if the string memory space is getting too tight for comfort 52* ⟩ ≡ begin if eof (pool file) then bad pool (´ ␣ ␣ ␣ ␣ ␣ ´ ); read (pool file, m); read (pool file, n); { read two digits of string length } if m = ´ ´ then ⟨ Check the pool check sum 53* ⟩ else begin if (xord [m] < ) ∨ (xord [m] > ) ∨ (xord [n] < ) ∨ (xord [n] > ) then

bad pool (´ ␣ ␣ ␣ ´ ´ ␣ ␣ ␣ ␣ ´ ); l ← xord [m] ∗ 10 + xord [n] − ∗ 11; { compute the length } if pool ptr + l + string vacancies > pool size then bad pool (´ ␣ ␣ ␣ ␣ ␣ ´ ); for k ← 1 to l do

begin if eoln(pool file) then m ← ´ ␣´ else read (pool file, m); append char (xord [m]); end;

read ln(pool file); g ← make string ; end;

end

This code is used in section 51*.

53* . The  operation $ denotes the value that should be at the end of this  file; any other

value means that the wrong pool file has been loaded. ⟨ Check the pool check sum 53* ⟩ ≡

begin a ← 0; k ← 1; loop begin if (xord [n] < ) ∨ (xord [n] > ) then

bad pool (´ ␣ ␣ ␣ ␣ ´ ´ ␣ ␣ ␣ ´ ); a ← 10 ∗ a + xord [n] − ; if k = 9 then goto done; incr (k); read (pool file, n); end;

done: if a ≠ $ then bad pool (´ ␣ ␣ ´ ´ ␣ ␣ ␣ ␣ ´ ); c ← true; end

This code is used in section 52*.

12  PART 5: ON-LINE AND OFF-LINE PRINTING  TEX82 §54

61* . Here is the very first thing that TEX prints: a headline that identifies the version number and format package. The term offset variable is temporarily incorrect, but the discrepancy is not serious since we assume that the banner and format identifier together will occupy at most max print line character positions. ⟨ Initialize the output routines 55 ⟩ +≡

wterm(banner );

if format ident > 0 then print (format ident ); print ln; update terminal ;

§72  TEX82  PART 6: REPORTING ERRORS 13

81* . The jump out procedure just cuts across all active procedure levels and goes to end of TEX . This is the only nontrivial goto statement in the whole program. It is used when there is no recovery from a particular error.

Some Pascal compilers do not implement non-local goto statements. In such cases the body of jump out should simply be ‘close files and terminate; ’ followed by a call on some system procedure that quietly terminates the program.

define do final end ≡ begin update terminal ; ready already ← 0; if (history ≠ spotless ) ∧ (history ≠ warning issued ) then uexit (1) else uexit (0); end

⟨ Error handling procedures 78 ⟩ +≡ procedure jump out ;

begin close files and terminate; do final end ; end;

84* . It is desirable to provide an ‘ ’ option here that gives the user an easy way to return from TEX to the system editor, with the offending line ready to be edited. We do this by calling the external procedure call edit with a pointer to the filename, its length, and the line number. However, here we just set up the variables that will be used as arguments, since we don’t want to do the switch-to-editor until after TeX has closed its files.

There is a secret ‘ ’ option available when the debugging routines haven’t been commented out. define edit file ≡ input stack [base ptr ]

⟨ Interpret code c and return if done 84* ⟩ ≡

case c of

, , , , , , , , , : if deletions allowed then

⟨ Delete c − tokens and goto continue 88 ⟩; debug : begin debug help; goto continue; end; gubed : if base ptr > 0 then

begin edit name start ← str start [edit file.name field ];

edit name length ← str start [edit file.name field + 1] − str start [edit file.name field ]; edit line ← line; jump out ; end;

: ⟨ Print the help information and goto continue 89 ⟩; : ⟨ Introduce new material from the terminal and return 87 ⟩; , , : ⟨ Change the interaction level and return 86 ⟩; : begin interaction ← scroll mode; jump out ;

end;

othercases do nothing

endcases; ⟨ Print the menu of available options 85 ⟩

This code is used in section 83.

14  PART 7: ARITHMETIC WITH SCALED DIMENSIONS  TEX82 §99

109* . When TEX “packages” a list into a box, it needs to calculate the proportionality ratio by which the glue inside the box should stretch or shrink. This calculation does not affect TEX’s decision making, so the precise details of rounding, etc., in the glue calculation are not of critical importance for the consistency of results on different computers.

We shall use the type glue ratio for such proportionality ratios. A glue ratio should take the same amount of memory as an integer (usually 32 bits) if it is to blend smoothly with TEX’s other data structures. Thus glue ratio should be equivalent to short real in some implementations of Pascal. Alternatively, it is possible to deal with glue ratios using nothing but fixed-point arithmetic; see TUGboat 3,1 (February 1982), 10–27. (But the routines cited there must be modified to allow negative glue ratios.)

define set glue ratio zero(#) ≡ # ← 0.0 { store the representation of zero ratio }

define set glue ratio one(#) ≡ # ← 1.0 { store the representation of unit ratio }

define float (#) ≡ # { convert from glue ratio to type real }

define unfloat (#) ≡ # { convert from real to type glue ratio }

define float constant (#) ≡ #.0 { convert integer constant to real } ⟨ Types in the outer block 18 ⟩ +≡

§110  TEX82  PART 8: PACKED DATA 15

110* . Packed data. In order to make efficient use of storage space, TEX bases its major data structures on a memory word , which contains either a (signed) integer, possibly scaled, or an (unsigned) glue ratio, or a small number of fields that are one half or one quarter of the size used for storing integers.

If x is a variable of type memory word , it contains up to four fields that can be referred to as follows:

x.int (an integer )
x.sc  (a scaled integer)
x.gr  (a glue ratio)
x.hh.lh, x.hh.rh  (two halfword fields)
x.hh.b0 , x.hh.b1 , x.hh.rh  (two quarterword fields, one halfword field)
x.qqqq .b0 , x.qqqq .b1 , x.qqqq .b2 , x.qqqq .b3  (four quarterword fields)

This is somewhat cumbersome to write, and not very readable either, but macros will be used to make the notation shorter and more transparent. The Pascal code below gives a formal definition of memory word and its subsidiary types, using packed variant records. TEX makes no assumptions about the relative positions of the fields within a word.

Since we are assuming 32-bit integers, a halfword must contain at least 16 bits, and a quarterword must contain at least 8 bits. But it doesn’t hurt to have more bits; for example, with enough 36-bit words you might be able to have mem max as large as 262142, which is eight times as much memory as anybody had during the first four years of TEX’s existence.

N.B.: Valuable memory space will be dreadfully wasted unless TEX is compiled by a Pascal that packs all of the memory word variants into the space of a single integer. This means, for example, that glue ratio words should be short real instead of real on some computers. Some Pascal compilers will pack an integer whose subrange is ‘0 . . 255’ into an eight-bit field, but others insist on allocating space for an additional sign bit; on such systems you can get 256 values into a quarterword only if the subrange is ‘−128 . . 127’.

The present implementation tries to accommodate as many variations as possible, so it makes few assumptions. If integers having the subrange ‘min quarterword . . max quarterword ’ can be packed into a quarterword, and if integers having the subrange ‘min halfword . . max halfword ’ can be packed into a halfword, everything should work satisfactorily.

It is usually most efficient to have min quarterword = min halfword = 0, so one should try to achieve this unless it causes a severe problem. The values defined here are recommended for most 32-bit computers.

define min quarterword = 0 { smallest allowable value in a quarterword }

define max quarterword = 255 { largest allowable value in a quarterword }

define min halfword ≡ 0 { smallest allowable value in a halfword }

define max halfword ≡ 262143 { largest allowable value in a halfword }

112* . The operation of adding or subtracting min quarterword occurs quite frequently in TEX, so it is convenient to abbreviate this operation by using the macros qi and qo for input and output to and from quarterword format.

The inner loop of TEX will run faster with respect to compilers that don’t optimize expressions like ‘x + 0’ and ‘x − 0’, if these macros are simplified in the obvious way when min quarterword = 0. So they have been simplified here in the obvious way.

define qi (#) ≡ # { to put an eight bits item into a quarterword }

define qo(#) ≡ # { to take an eight bits item from a quarterword }

define hi (#) ≡ # { to put a sixteen-bit item into a halfword }

define ho(#) ≡ # { to take a sixteen-bit item from a halfword }

16  PART 8: PACKED DATA  TEX82 §113

113* . The reader should study the following definitions closely:

define sc ≡ int { scaled data is equivalent to integer } ⟨ Types in the outer block 18 ⟩ +≡

quarterword = min quarterword . . max quarterword ; halfword = min halfword . . max halfword ; two choices = 1 . . 2; { used when there are two variants in a record } four choices = 1 . . 4; { used when there are four variants in a record }

 \underline{\overline{#       ␣}}

§115  TEX82  PART 9: DYNAMIC MEMORY ALLOCATION 17

116* . The mem array is divided into two regions that are allocated separately, but the dividing line between these two regions is not fixed; they grow together until finding their “natural” size in a particular job. Locations less than or equal to lo mem max are used for storing variable-length records consisting of two or more words each. This region is maintained using an algorithm similar to the one described in exercise 2.5–19 of The Art of Computer Programming. However, no size field appears in the allocated nodes; the program is responsible for knowing the relevant size when a node is freed. Locations greater than or equal to hi mem min are used for storing one-word records; a conventional stack is used for allocation in this region.

Locations of mem between mem bot and mem top may be dumped as part of preloaded format files, by the preprocessor. Production versions of TEX may extend the memory at both ends in order to provide more space; locations between mem min and mem bot are always used for variable-size nodes, and locations between mem top and mem max are always used for single-word nodes.

The key pointers that govern mem allocation have a prescribed order:

null ≤ mem min ≤ mem bot < lo mem max < hi mem min < mem top ≤ mem end ≤ mem max .

Empirical tests show that the present implementation of TEX tends to spend about 9% of its running time allocating nodes, and about 6% deallocating them after their use. ⟨ Global variables 13 ⟩ +≡ zmem: array [mem min . . mem max ] of memory word ; { the big dynamic storage area } lo mem max : pointer ; { the largest location of variable-size memory in use } hi mem min: pointer ; { the smallest location of one-word memory in use }

127* . Empirical tests show that the routine in this section performs a node-merging operation about 0.75 times per allocation, on the average, after which it finds that r > p + 1 about 95% of the time. ⟨ Try to allocate within node p and its physical successors, and goto found if allocation was possible 127* ⟩ ≡

q ← p + node size(p); { find the physical successor }

while is empty (q) do { merge node p with node q } begin t ← rlink (q); if q = rover then rover ← t; llink (t) ← llink (q); rlink (llink (q)) ← t; q ← q + node size(q); end;

r ← q − s;

if r > toint (p + 1) then ⟨ Allocate from the top of node p and goto found 128 ⟩;

if r = p then

if rlink (p) ≠ p then ⟨ Allocate entire node p and goto found 129 ⟩; node size(p) ← q − p { reset the size in case it grew }

This code is used in section 125.

18  PART 11: MEMORY LAYOUT  TEX82 §133

165* . If TEX is extended improperly, the mem array might get screwed up. For example, some pointers might be wrong, or some “dead” nodes might not have been freed when the last reference to them disappeared. Procedures check mem and search mem are available to help diagnose such problems. These procedures make use of two arrays called free and was free that are present only if TEX’s debugging routines have been included. (You may want to decrease the size of mem while you are debugging.)

define free ≡ free arr ⟨ Global variables 13 ⟩ +≡

debug free: packed array [mem min . . mem max ] of boolean; { free cells }

was free: packed array [mem min . . mem max ] of boolean; { previously free cells }

was mem end , was lo max , was hi min: pointer ; { previous mem end , lo mem max , and hi mem min } panicking : boolean; { do we want to check memory constantly? } gubed

§173  TEX82  PART 12: DISPLAYING BOXES 19

174* . Boxes, rules, inserts, whatsits, marks, and things in general that are sort of “complicated” are indicated only by printing ‘ ’. procedure short display (p : integer ); { prints highlights of list p }

var n: integer ; { for replacement counts } begin while p > mem min do

begin if is char node(p) then

begin if p ≤ mem end then

begin if font (p) ≠ font in short display then begin if (font (p) > font max ) then print char ( ) else ⟨ Print the font identifier for font (p) 267 ⟩; print char ( ␣ ); font in short display ← font (p); end;

print ASCII (qo(character (p)));

end; end

else ⟨ Print a short indication of the contents of node p 175 ⟩; p ← link (p); end;

end;

176* . The show node list routine requires some auxiliary subroutines: one to print a font-and-character combination, one to print a token list without its reference count, and one to print a rule dimension. procedure print font and char (p : integer ); { prints char node data }

begin if p > mem end then print esc( ) else begin if (font (p) > font max ) then print char ( )

else ⟨ Print the font identifier for font (p) 267 ⟩;

print char ( ␣ ); print ASCII (qo(character (p)));

end; end;

procedure print mark (p : integer ); { prints token list data in braces } begin print char ( ); if (p < hi mem min) ∨ (p > mem end ) then print esc( ) else show token list (link (p), null , max print line − 10); print char ( ); end;

procedure print rule dimen(d : scaled ); { prints dimension in rule node } begin if is running (d) then print char ( ) else print scaled (d); end;

20  PART 12: DISPLAYING BOXES  TEX82 §186

186* . The code will have to change in this place if glue ratio is a structured type instead of an ordinary real . Note that this routine should avoid arithmetic errors even if the glue set field holds an arbitrary random value. The following code assumes that a properly formed nonzero real number has absolute value 2^{20} or more when it is regarded as an integer; this precaution was adequate to prevent floating point underflow on the author’s computer. ⟨ Display the value of glue set (p) 186* ⟩ ≡

g ← float (glue set (p));

if (g ≠ float constant (0)) ∧ (glue sign(p) ≠ normal ) then begin print ( ␣ ␣ ␣ ); if glue sign(p) = shrinking then print ( ␣ ); { The Unix pc folks removed this restriction with a

remark that invalid bit patterns were vanishingly improbable, so we follow their example without really understanding it. if abs (mem[p + glue offset ].int ) < ´ 4000000 then print (´ ´ ) else }

if fabs (g) > float constant (20000) then begin if g > float constant (0) then print char ( ) else print ( ␣ ); print glue(20000 ∗ unity , glue order (p), 0); end

else print glue(round (unity ∗ g), glue order (p), 0);

end

This code is used in section 184.

§199  TEX82  PART 17: THE TABLE OF EQUIVALENTS 21

241* . The following procedure, which is called just before TEX initializes its input and output, establishes the initial values of the date and time. It calls a macro-defined date and time routine. date and time in turn is a C macro, which calls get date and time, passing it the addresses of the day, month, etc., so they can be set by the routine. get date and time also sets up interrupt catching if that is conditionally compiled in the C code.

define fix date and time ≡ date and time(time, day , month, year )

253* . The last two regions of eqtb have fullword values instead of the three fields eq level , eq type, and equiv . An eq type is unnecessary, but TEX needs to store the eq level information in another array called xeq level . ⟨ Global variables 13 ⟩ +≡ zeqtb: array [active base . . eqtb size] of memory word ; xeq level : array [int base . . eqtb size] of quarterword ;

22  PART 18: THE HASH TABLE  TEX82 §256

262* . Single-character control sequences do not need to be looked up in a hash table, since we can use the character code itself as a direct address. The procedure print cs prints the name of a control sequence, given a pointer to its address in eqtb. A space is printed after the name unless it is a single nonletter or an active character. This procedure might be invoked with invalid data, so it is “extra robust.” The individual characters must be printed one at a time using print , since they may be unprintable. ⟨ Basic printing procedures 57 ⟩ +≡ procedure print cs (p : integer ); { prints a purported control sequence }

begin if p < hash base then { single character }

if p ≥ single base then if p = null cs then

begin print esc( ); print esc( ); end

else begin print esc(p − single base); if cat code(p − single base) = letter then print char ( ␣ ); end

else if p < active base then print esc( )

else print (p − active base) else if p ≥ undefined control sequence then print esc( )

else if (text (p) ≥ str ptr ) then print esc( )

else begin print esc( ); slow print (text (p)); print char ( ␣ );

§268  TEX82  PART 29: FILE NAMES 23

end; end; 513* . The file names we shall deal with for illustrative purposes have the following structure: If the name contains ‘ ’, 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 last ‘ ’ to the end, otherwise the file extension is null.

We can scan such file names easily by using two global variables that keep track of the occurrences of area and extension delimiters: ⟨ Global variables 13 ⟩ +≡ area delimiter : pool pointer ; { the most recent ‘ ’, if any } ext delimiter : pool pointer ; { the most recent ‘ ’, if any }

514* . Input files that can’t be found in the user’s area may appear in a standard system area called TEX area. Font metric files whose areas are not given explicitly are assumed to appear in a standard system area called TEX font area. These system area names will, of course, vary from place to place.

In C, the default paths are specified in a separate file, . The file opening procedures do path searching based either on those default paths, or on paths given by the user in environment variables.

516* . And here’s the second. The string pool might change as the file name is being scanned, since a new might be entered; therefore we keep area delimiter and ext delimiter relative to the beginning of the current string, instead of assigning an absolute address like pool ptr to them. function more name(c : ASCII code): boolean;

begin if c = ␣ then more name ← false

else begin str room(1); append char (c); { contribute c to the current string }

if (c = ) then begin area delimiter ← cur length; ext delimiter ← 0; end

else if c = then ext delimiter ← cur length; more name ← true; end;

end;

520* . A messier routine is also needed, since format file names must be scanned before TEX’s string mechanism has been initialized. We shall use the global variable TEX format default to supply the text for default system areas and extensions related to format files.

Under UNIX we don’t give the area part, instead depending on the path searching that will happen during file opening. Also, the length will be set in the main program.

define format area length = 0 { length of its area part }

define format ext length = 4 { length of its ‘ ’ part }

define format extension = { the extension, as a constant } ⟨ Global variables 13 ⟩ +≡ format default length: integer ; TEX format default : c char pointer ;

521* . We set the name of the default format file and the length of that name in C, instead of Pascal, since we want them to depend on the name of the program.

24  PART 29: FILE NAMES  TEX82 §524

524* . Here is the only place we use pack buffered name. This part of the program becomes active when a “virgin” TEX is trying to get going, just after the preliminary initialization, or when the user is substituting another format file by typing ‘ ’ after the initial ‘ ’ prompt. The buffer contains the first line of input in buffer [loc . . (last − 1)], where loc < last and buffer [loc] ≠ ␣ . ⟨ Declare the function called open fmt file 524* ⟩ ≡ function open fmt file: boolean;

label found , exit ; var j: 0 . . buf size; { the first space after the format file name } begin j ← loc; if buffer [loc] = then

begin incr (loc); j ← loc; buffer [last ] ← ␣ ;

while buffer [j] ≠ ␣ do incr (j);

pack buffered name(0, loc, j − 1);

if w open in(fmt file) then goto found ;

wake up terminal ; wterm ln(´ ␣ ␣ ´ ´ ␣ ␣ ␣ ´ , ´ ␣ ␣ ␣ ␣ ´ ); update terminal ; end; { now pull out all the stops: try for the system file }

pack buffered name(format default length − format ext length, 1, 0); if ¬w open in(fmt file) then

begin wake up terminal ; wterm ln(´ ␣ ´ ´ ␣ ␣ ␣ ␣ ␣ ´ );

open fmt file ← false; return;

end; found : loc ← j; open fmt file ← true; exit : end;

This code is used in section 1303*.

534* . The open log file routine is used to open the transcript file and to help it catch up to what has previously been printed on the terminal. procedure open log file;

var old setting : 0 . . max selector ; { previous selector setting } k: 0 . . buf size; { index into months and buffer } l: 0 . . buf size; { end of first input line } months : c char pointer ;

begin old setting ← selector ; if job name = 0 then job name ← ; pack job name( ); while ¬a open out (log file) do ⟨ Try to get a different log file name 535 ⟩; log name ← a make name string (log file); selector ← log only ; log opened ← true; ⟨ Print the banner line, including the date and time 536* ⟩; input stack [input ptr ] ← cur input ; { make sure bottom level is in memory } print nl ( ); l ← input stack [0].limit field ; { last position of first line } if buffer [l] = end line char then decr (l); for k ← 1 to l do print (buffer [k]); print ln; { now the transcript file contains the first line of input } selector ← old setting + 2; { log only or term and log } end; 536* . ⟨ Print the banner line, including the date and time 536* ⟩ ≡

begin wlog (banner ); print (format ident ); print ( ␣␣ ); print int (day ); print char ( ␣ ); months ← ´ ␣ ´ ; for k ← 3 ∗ month − 2 to 3 ∗ month do wlog (months [k]); print char ( ␣ ); print int (year ); print char ( ␣ ); print two(time div 60); print char ( ); print two(time mod 60); end

This code is used in section 534*.

537* . Let’s turn now to the procedure that is used to initiate file reading when an ‘ ’ command is being processed. procedure start input ; { TEX will something }

label done; begin scan file name; { set cur name to desired file name } if cur ext = then pack file name(cur name, cur area, ) else pack cur name; loop begin begin file reading ; { set up cur file and new level of input }

if a open in(cur file, TEX INPUT PATH ) then goto done;

if cur ext = then { try to open the file without ‘ ’ } begin pack cur name; if a open in(cur file, TEX INPUT PATH ) then goto done; end;

end file reading ; { remove the level that didn’t work }

prompt file name( ␣ ␣ , );

end; done: name ← a make name string (cur file);

if job name = 0 then begin job name ← cur name; open log file; end; { open log file doesn’t show context , so limit and loc needn’t be set to meaningful values yet }

if term offset + length(name) > max print line − 3 then print ln else if (term offset > 0) ∨ (file offset > 0) then print char ( ␣ ); print char ( ); incr (open parens ); print (name); update terminal ; state ← new line; ⟨ Read the first line of the new file 538 ⟩; end;

26  PART 30: FONT METRIC DATA  TEX82 §539

563* . ⟨ Open tfm file for input 563* ⟩ ≡ file opened ← false; pack file name(nom, aire, ); if ¬b open in(tfm file) then abort ; file opened ← true

This code is used in section 562.

564* . Note: A malformed file might be shorter than it claims to be; thus eof (tfm file) might be true when read font info refers to tfm file↑ or when it says get (tfm file). If such circumstances cause system error messages, you will have to defeat them somehow, for example by defining fget to be ‘begin get (tfm file); if eof (tfm file) then abort ; end’.

define fget ≡ tfm temp ← getc(tfm file) define fbyte ≡ tfm temp define read sixteen(#) ≡

begin # ← fbyte;

if # > 127 then abort ; fget ; # ← # ∗ ´ 400 + fbyte; end

define store four quarters (#) ≡ begin fget ; a ← fbyte; qw .b0 ← qi (a); fget ; b ← fbyte; qw .b1 ← qi (b); fget ; c ← fbyte; qw .b2 ← qi (c); fget ; d ← fbyte; qw .b3 ← qi (d); # ← qw ; end

575* . We check to see that the file doesn’t end prematurely; but no error message is given for files having more than lf words. ⟨ Read font parameters 575* ⟩ ≡

begin for k ← 1 to np do

if k = 1 then { the slant parameter is a pure number } begin fget ; sw ← fbyte; if sw > 127 then sw ← sw − 256; fget ; sw ← sw ∗ ´ 400 + fbyte; fget ; sw ← sw ∗ ´ 400 + fbyte; fget ; font info[param base[f]].sc ← (sw ∗ ´ 20 ) + (fbyte div ´ 20 ); end

else store scaled (font info[param base[f] + k − 1].sc); if feof (tfm file) then abort ; for k ← np + 1 to 7 do font info[param base[f] + k − 1].sc ← 0; end

This code is used in section 562.

§583  TEX82  PART 32: SHIPPING PAGES OUT 27

597* . The actual output of dvi buf [a . . b] to dvi file is performed by calling write dvi (a, b). For best results, this procedure should be optimized to run as fast as possible on each particular system, since it is part of TEX’s inner loop. 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.

In C, we use a macro to call fwrite or write directly, writing all the bytes to be written in one shot. Much better even than writing four bytes at a time.

28  PART 38: BREAKING PARAGRAPHS INTO LINES  TEX82 §644

859* . ⟨ Compute the demerits, d, from r to cur p 859* ⟩ ≡ begin d ← line penalty + b; if abs (d) ≥ 10000 then d ← 100000000 else d ← d ∗ d; if pi ≠ 0 then

if pi > 0 then d ← d + pi ∗ pi

else if pi > eject penalty then d ← d − pi ∗ pi ; if (break type = hyphenated ) ∧ (type(r) = hyphenated ) then

if cur p ≠ null then d ← d + double hyphen demerits else d ← d + final hyphen demerits ;

if abs (toint (fit class ) − toint (fitness (r))) > 1 then d ← d + adj demerits ; end

This code is used in section 855.

§862  TEX82  PART 39: BREAKING PARAGRAPHS INTO LINES, CONTINUED 29

875* . The adjustment for a desired looseness is a slightly more complicated version of the loop just considered. Note that if a paragraph is broken into segments by displayed equations, each segment will be subject to the looseness calculation, independently of the other segments. ⟨ Find the best active node for the desired looseness 875* ⟩ ≡

begin r ← link (active); actual looseness ← 0; repeat if type(r) ≠ delta node then

begin line diff ← toint (line number (r)) − toint (best line); if ((line diff < actual looseness ) ∧ (looseness ≤ line diff )) ∨

((line diff > actual looseness ) ∧ (looseness ≥ line diff )) then begin best bet ← r; actual looseness ← line diff ; fewest demerits ← total demerits (r); end

else if (line diff = actual looseness ) ∧ (total demerits (r) < fewest demerits ) then begin best bet ← r; fewest demerits ← total demerits (r); end;

end; r ← link (r);

until r = last active; best line ← line number (best bet ); end

This code is used in section 873.

30  PART 43: INITIALIZING THE HYPHENATION TABLES  TEX82 §891

943* . Before we discuss trie building in detail, let’s consider the simpler problem of creating the hyf distance, hyf num, and hyf next arrays.

Suppose, for example, that TEX reads the pattern ‘ ’. This is a pattern of length 5, with n_{0} … n_{5} = 0 0 2 0 0 1 in the notation above. We want the corresponding trie op code v to have hyf distance[v] = 3, hyf num[v] = 2, and hyf next [v] = v′, where the auxiliary trie op code v′ has hyf distance[v′] = 0, hyf num[v′] = 1, and hyf next [v′] = min quarterword .

TEX computes an appropriate value v with the new trie op subroutine below, by setting

v′ ← new trie op(0, 1, min quarterword ), v ← new trie op(3, 2, v′).

This subroutine looks up its three parameters in a special hash table, assigning a new value only if these three have not appeared before for the current language.

The hash table is called trie op hash, and the number of entries it contains is trie op ptr . ⟨ Global variables 13 ⟩ +≡

init trie op hash: array [neg trie op size . . trie op size] of 0 . . trie op size;

{ trie op codes for quadruples }

trie used : array [ASCII code] of quarterword ; { largest opcode used so far for this language } trie op lang : array [1 . . trie op size] of ASCII code; { language part of a hashed quadruple } trie op val : array [1 . . trie op size] of quarterword ; { opcode corresponding to a hashed quadruple } trie op ptr : 0 . . trie op size; { number of stored ops so far }

tini

944* . It’s tempting to remove the overflow stops in the following procedure; new trie op could return min quarterword (thereby simply ignoring part of a hyphenation pattern) instead of aborting the job. However, that would lead to different hyphenation results on different installations of TEX using the same patterns. The overflow stops are necessary for portability of patterns. ⟨ Declare procedures for preprocessing hyphenation patterns 944* ⟩ ≡ function new trie op(d, n : small number ; v : quarterword ): quarterword ;

label exit ;

var h: neg trie op size . . trie op size; { trial hash location } u: quarterword ; { trial op code } l: 0 . . trie op size; { pointer to stored data }

begin h ← abs (toint (n) + 313 ∗ toint (d) + 361 ∗ toint (v) + 1009 ∗ toint (cur lang )) mod (trie op size +

trie op size) − trie op size; loop begin l ← trie op hash[h];

if l = 0 then { empty position found for a new op } begin if trie op ptr = trie op size then overflow ( ␣ ␣ , trie op size); u ← trie used [cur lang ]; if u = max quarterword then

overflow ( ␣ ␣ ␣ ␣ , max quarterword − min quarterword ); incr (trie op ptr ); incr (u); trie used [cur lang ] ← u; hyf distance[trie op ptr ] ← d; hyf num[trie op ptr ] ← n; hyf next [trie op ptr ] ← v; trie op lang [trie op ptr ] ← cur lang ; trie op hash[h] ← trie op ptr ; trie op val [trie op ptr ] ← u; new trie op ← u; return; end;

if (hyf distance[l] = d) ∧ (hyf num[l] = n) ∧ (hyf next [l] = v) ∧ (trie op lang [l] = cur lang ) then begin new trie op ← trie op val [l]; return; end;

if h > −trie op size then decr (h) else h ← trie op size;

end; exit : end;

See also sections 948*, 949, 953, 957, 959, 960, and 966. This code is used in section 942.

§948  TEX82  PART 43: INITIALIZING THE HYPHENATION TABLES 31

948* . Let us suppose that a linked trie has already been constructed. Experience shows that we can often reduce its size by recognizing common subtries; therefore another hash table is introduced for this purpose, somewhat similar to trie op hash. The new hash table will be initialized to zero.

The function trie node(p) returns p if p is distinct from other nodes that it has seen, otherwise it returns the number of the first equivalent node that it has seen.

Notice that we might make subtries equivalent even if they correspond to patterns for different languages, in which the trie ops might mean quite different things. That’s perfectly all right. ⟨ Declare procedures for preprocessing hyphenation patterns 944* ⟩ +≡ function trie node(p : trie pointer ): trie pointer ; { converts to a canonical form }

label exit ;

var h: trie pointer ; { trial hash location }

q: trie pointer ; { trial trie node } begin h ← abs (toint (trie c[p]) + 1009 ∗ toint (trie o[p]) +

2718 ∗ toint (trie l [p]) + 3142 ∗ toint (trie r [p])) mod trie size; loop begin q ← trie hash[h];

if q = 0 then begin trie hash[h] ← p; trie node ← p; return; end;

if (trie c[q] = trie c[p]) ∧ (trie o[q] = trie o[p]) ∧ (trie l [q] = trie l [p]) ∧ (trie r [q] = trie r [p]) then begin trie node ← q; return; end;

if h > 0 then decr (h) else h ← trie size;

end; exit : end;

32  PART 49: MODE-INDEPENDENT PROCESSING  TEX82 §967

1275* . ⟨ Declare action procedures for use by main control 1043 ⟩ +≡ procedure open or close in;

var c: 0 . . 1; { 1 for , 0 for }

n: 0 . . 15; { stream number } begin c ← cur chr ; scan four bit int ; n ← cur val ; if read open[n] ≠ closed then

begin a close(read file[n]); read open[n] ← closed ; end;

if c ≠ 0 then begin scan optional equals ; scan file name; if cur ext = then cur ext ← ; pack cur name; if a open in(read file[n], TEX INPUT PATH ) then read open[n] ← just open; end;

§1299  TEX82  PART 50: DUMPING AND UNDUMPING THE TABLES 33

end; 1302* . ⟨ Declare action procedures for use by main control 1043 ⟩ +≡

init procedure store fmt file; label found1 , found2 , done1 , done2 ; var j, k, l: integer ; { all-purpose indices }

p, q: pointer ; { all-purpose pointers } x: integer ; { something to dump }

begin ⟨ If dumping is not allowed, abort 1304 ⟩; ⟨ Create the format ident , open the format file, and inform the user that dumping has begun 1328* ⟩; ⟨ Dump constants for consistency check 1307 ⟩; ⟨ Dump the string pool 1309* ⟩; ⟨ Dump the dynamic memory 1311* ⟩; ⟨ Dump the table of equivalents 1313 ⟩; ⟨ Dump the font information 1320* ⟩; ⟨ Dump the hyphenation tables 1324* ⟩; ⟨ Dump a couple more things and the closing check word 1326 ⟩; ⟨ Close the format file 1329 ⟩; end; tini

1303* . Corresponding to the procedure that dumps a format file, we have a function that reads one in. The function returns false if the dumped format is incompatible with the present TEX table sizes, etc.

define bad fmt = 6666 { go here if the format file is unacceptable } define too small (#) ≡

begin wake up terminal ; wterm ln(´ ␣ ␣ ␣ ␣´ , #); goto bad fmt ; end

⟨ Declare the function called open fmt file 524* ⟩ function load fmt file: boolean;

label bad fmt , exit ; var j, k: integer ; { all-purpose indices }

p, q: pointer ; { all-purpose pointers } x: integer ; { something undumped }

begin ⟨ Undump constants for consistency check 1308* ⟩; ⟨ Undump the string pool 1310* ⟩; ⟨ Undump the dynamic memory 1312* ⟩; ⟨ Undump the table of equivalents 1314 ⟩; ⟨ Undump the font information 1321* ⟩; ⟨ Undump the hyphenation tables 1325* ⟩; ⟨ Undump a couple more things and the closing check word 1327* ⟩; load fmt file ← true; return; { it worked! }

bad fmt : wake up terminal ; wterm ln(´ ␣ ␣ ␣ ␣ ´ ´ ␣ ´ );

load fmt file ← false; exit : end;

34  PART 50: DUMPING AND UNDUMPING THE TABLES  TEX82 §1306

1305* . Format files consist of memory word items, and we use the following macros to dump words of different types: ⟨ Global variables 13 ⟩ +≡ fmt file: word file; { for input or output of format information } 1306* . The inverse macros are slightly more complicated, since we need to check the range of the values we are reading in. We say ‘undump(a)(b)(x)’ to read an integer value x that is supposed to be in the range a ≤ x ≤ b.

define undump end end (#) ≡ # ← x; end define undump end (#) ≡ (x > #) then goto bad fmt else undump end end define undump(#) ≡

begin undump int (x); if (x < #) ∨ undump end

define undump size end end (#) ≡ too small (#) else undump end end define undump size end (#) ≡

if x > # then undump size end end

define undump size(#) ≡ begin undump int (x); if x < # then goto bad fmt ; undump size end

1308* . Sections of a program that are “commented out” still contribute strings to the string pool; therefore and TEX will have the same strings. (And it is, of course, a good thing that they do.) ⟨ Undump constants for consistency check 1308* ⟩ ≡

undump int (x); { This is reading the first word of the fmt file } if x ≠ $ then goto bad fmt ; { check that strings are the same } undump int (x); if x ≠ mem bot then goto bad fmt ; undump int (x); if x ≠ mem top then goto bad fmt ; undump int (x); if x ≠ eqtb size then goto bad fmt ; undump int (x); if x ≠ hash prime then goto bad fmt ; undump int (x); if x ≠ hyph size then goto bad fmt

This code is used in section 1303*.

1309* . define dump four ASCII ≡ w.b0 ← qi (so(str pool [k])); w.b1 ← qi (so(str pool [k + 1]));

w.b2 ← qi (so(str pool [k + 2])); w.b3 ← qi (so(str pool [k + 3])); dump qqqq (w)

⟨ Dump the string pool 1309* ⟩ ≡ dump int (pool ptr ); dump int (str ptr ); dump things (str start [0], str ptr + 1); dump things (str pool [0], pool ptr ); print ln; print int (str ptr ); print ( ␣ ␣ ␣ ␣ ␣ ); print int (pool ptr )

This code is used in section 1302*.

1310* . define undump four ASCII ≡ undump qqqq (w); str pool [k] ← si (qo(w.b0 ));

str pool [k + 1] ← si (qo(w.b1 )); str pool [k + 2] ← si (qo(w.b2 )); str pool [k + 3] ← si (qo(w.b3 ))

⟨ Undump the string pool 1310* ⟩ ≡ undump size(0)(pool size)(´ ␣ ␣ ´ )(pool ptr ); undump size(0)(max strings )(´ ␣ ´ )(str ptr ); undump things (str start [0], str ptr + 1); undump things (str pool [0], pool ptr ); init str ptr ← str ptr ; init pool ptr ← pool ptr

This code is used in section 1303*.

1311* . By sorting the list of available spaces in the variable-size portion of mem, we are usually able to get by without having to dump very much of the dynamic memory.

We recompute var used and dyn used , so that dumps valid information even when it has not been gathering statistics. ⟨ Dump the dynamic memory 1311* ⟩ ≡

sort avail ; var used ← 0; dump int (lo mem max ); dump int (rover ); p ← mem bot ; q ← rover ; x ← 0; repeat dump things (mem[p], q + 2 − p); x ← x + q + 2 − p; var used ← var used + q − p;

p ← q + node size(q); q ← rlink (q); until q = rover ; var used ← var used + lo mem max − p; dyn used ← mem end + 1 − hi mem min; dump things (mem[p], lo mem max + 1 − p); x ← x + lo mem max + 1 − p; dump int (hi mem min); dump int (avail ); dump things (mem[hi mem min], mem end + 1 − hi mem min); x ← x + mem end + 1 − hi mem min; p ← avail ; while p ≠ null do

begin decr (dyn used ); p ← link (p);

end; dump int (var used ); dump int (dyn used ); print ln; print int (x); print ( ␣ ␣ ␣ ␣ ␣ ␣ ␣ ); print int (var used ); print char ( ); print int (dyn used )

This code is used in section 1302*.

1312* . ⟨ Undump the dynamic memory 1312* ⟩ ≡ undump(lo mem stat max + 1000)(hi mem stat min − 1)(lo mem max ); undump(lo mem stat max + 1)(lo mem max )(rover ); p ← mem bot ; q ← rover ; repeat undump things (mem[p], q + 2 − p); p ← q + node size(q);

if (p > lo mem max ) ∨ ((q ≥ rlink (q)) ∧ (rlink (q) ≠ rover )) then goto bad fmt ; q ← rlink (q);

until q = rover ; undump things (mem[p], lo mem max + 1 − p); if mem min < mem bot − 2 then { make more low memory available }

begin p ← llink (rover ); q ← mem min + 1; link (mem min) ← null ; info(mem min) ← null ;

{ we don’t use the bottom word } rlink (p) ← q; llink (rover ) ← q; rlink (q) ← rover ; llink (q) ← p; link (q) ← empty flag ; node size(q) ← mem bot − q; end;

undump(lo mem max + 1)(hi mem stat min)(hi mem min); undump(null )(mem top)(avail ); mem end ← mem top; undump things (mem[hi mem min], mem end + 1 − hi mem min); undump int (var used ); undump int (dyn used )

This code is used in section 1303*.

1315* . The table of equivalents usually contains repeated information, so we dump it in compressed form: The sequence of n + 2 values (n, x_{1}, …, x_{n}, m) in the format file represents n + m consecutive entries of eqtb, with m extra copies of x_{n}, namely (x_{1}, …, x_{n}, x_{n}, …, x_{n}). ⟨ Dump regions 1 to 4 of eqtb 1315* ⟩ ≡

k ← active base; repeat j ← k;

while j < int base − 1 do

begin if (equiv (j) = equiv (j + 1)) ∧ (eq type(j) = eq type(j + 1)) ∧ (eq level (j) = eq level (j + 1))

then goto found1 ; incr (j); end;

l ← int base; goto done1 ; { j = int base − 1 } found1 : incr (j); l ← j;

while j < int base − 1 do

begin if (equiv (j) ≠ equiv (j + 1)) ∨ (eq type(j) ≠ eq type(j + 1)) ∨ (eq level (j) ≠ eq level (j + 1))

then goto done1 ; incr (j); end;

done1 : dump int (l − k); dump things (eqtb[k], l − k); k ← j + 1; dump int (k − l); until k = int base

This code is used in section 1313.

1316* . ⟨ Dump regions 5 and 6 of eqtb 1316* ⟩ ≡

repeat j ← k;

while j < eqtb size do begin if eqtb[j].int = eqtb[j + 1].int then goto found2 ; incr (j); end;

l ← eqtb size + 1; goto done2 ; { j = eqtb size } found2 : incr (j); l ← j;

while j < eqtb size do begin if eqtb[j].int ≠ eqtb[j + 1].int then goto done2 ; incr (j); end;

done2 : dump int (l − k); dump things (eqtb[k], l − k); k ← j + 1; dump int (k − l); until k > eqtb size

This code is used in section 1313.

1317* . ⟨ Undump regions 1 to 6 of eqtb 1317* ⟩ ≡ k ← active base; repeat undump int (x);

if (x < 1) ∨ (k + x > eqtb size + 1) then goto bad fmt ; undump things (eqtb[k], x); k ← k + x; undump int (x); if (x < 0) ∨ (k + x > eqtb size + 1) then goto bad fmt ; for j ← k to k + x − 1 do eqtb[j] ← eqtb[k − 1]; k ← k + x;

until k > eqtb size

This code is used in section 1314.

1318* . A different scheme is used to compress the hash table, since its lower region is usually sparse. When text (p) ≠ 0 for p ≤ hash used , we output two words, p and hash[p]. The hash table is, of course, densely packed for p ≥ hash used , so the remaining entries are output in a block. ⟨ Dump the hash table 1318* ⟩ ≡

dump int (hash used ); cs count ← frozen control sequence − 1 − hash used ; for p ← hash base to hash used do

if text (p) ≠ 0 then begin dump int (p); dump hh(hash[p]); incr (cs count ); end;

dump things (hash[hash used + 1], undefined control sequence − 1 − hash used ); dump int (cs count ); print ln; print int (cs count ); print ( ␣ ␣ ␣ )

This code is used in section 1313.

1319* . ⟨ Undump the hash table 1319* ⟩ ≡ undump(hash base)(frozen control sequence)(hash used ); p ← hash base − 1; repeat undump(p + 1)(hash used )(p); undump hh(hash[p]); until p = hash used ; undump things (hash[hash used + 1], undefined control sequence − 1 − hash used ); undump int (cs count )

This code is used in section 1314.

1320* . ⟨ Dump the font information 1320* ⟩ ≡ dump int (fmem ptr ); ⟨ Dump the array info for internal font number k 1322* ⟩; print ln; print int (fmem ptr − 7); print ( ␣ ␣ ␣ ␣ ␣ ␣ ); print int (font ptr − font base); print ( ␣ ␣ ); if font ptr ≠ font base + 1 then print char ( )

This code is used in section 1302*.

1321* . ⟨ Undump the font information 1321* ⟩ ≡ undump size(7)(font mem size)(´ ␣ ␣ ´ )(fmem ptr ); ⟨ Undump the array info for internal font number k 1323* ⟩;

This code is used in section 1303*.

1322* . ⟨ Dump the array info for internal font number k 1322* ⟩ ≡ begin dump things (font info[0], fmem ptr ); dump int (font ptr ); dump things (font check [null font ], font ptr + 1 − null font ); dump things (font size[null font ], font ptr + 1 − null font ); dump things (font dsize[null font ], font ptr + 1 − null font ); dump things (font params [null font ], font ptr + 1 − null font ); dump things (hyphen char [null font ], font ptr + 1 − null font ); dump things (skew char [null font ], font ptr + 1 − null font ); dump things (font name[null font ], font ptr + 1 − null font ); dump things (font area[null font ], font ptr + 1 − null font ); dump things (font bc[null font ], font ptr + 1 − null font ); dump things (font ec[null font ], font ptr + 1 − null font ); dump things (char base[null font ], font ptr + 1 − null font ); dump things (width base[null font ], font ptr + 1 − null font ); dump things (height base[null font ], font ptr + 1 − null font ); dump things (depth base[null font ], font ptr + 1 − null font ); dump things (italic base[null font ], font ptr + 1 − null font ); dump things (lig kern base[null font ], font ptr + 1 − null font ); dump things (kern base[null font ], font ptr + 1 − null font ); dump things (exten base[null font ], font ptr + 1 − null font ); dump things (param base[null font ], font ptr + 1 − null font ); dump things (font glue[null font ], font ptr + 1 − null font ); dump things (bchar label [null font ], font ptr + 1 − null font ); dump things (font bchar [null font ], font ptr + 1 − null font ); dump things (font false bchar [null font ], font ptr + 1 − null font ); for k ← null font to font ptr do

begin print nl ( ); print esc(font id text (k)); print char ( ); print file name(font name[k], font area[k], ); if font size[k] ≠ font dsize[k] then

begin print ( ␣ ␣ ); print scaled (font size[k]); print ( ); end;

end; end

This code is used in section 1320*.

1323* . The way this is done in C makes the reference to the internal font number meaningless, but putting the code here preserves the association with the WEB modules. ⟨ Undump the array info for internal font number k 1323* ⟩ ≡

begin undump things (font info[0], fmem ptr ); undump size(font base)(font max )(´ ␣ ´ )(font ptr ); undump things (font check [null font ], font ptr + 1 − null font ); undump things (font size[null font ], font ptr + 1 − null font ); undump things (font dsize[null font ], font ptr + 1 − null font ); undump things (font params [null font ], font ptr + 1 − null font ); undump things (hyphen char [null font ], font ptr + 1 − null font ); undump things (skew char [null font ], font ptr + 1 − null font ); undump things (font name[null font ], font ptr + 1 − null font ); undump things (font area[null font ], font ptr + 1 − null font ); undump things (font bc[null font ], font ptr + 1 − null font ); undump things (font ec[null font ], font ptr + 1 − null font ); undump things (char base[null font ], font ptr + 1 − null font ); undump things (width base[null font ], font ptr + 1 − null font ); undump things (height base[null font ], font ptr + 1 − null font ); undump things (depth base[null font ], font ptr + 1 − null font ); undump things (italic base[null font ], font ptr + 1 − null font ); undump things (lig kern base[null font ], font ptr + 1 − null font ); undump things (kern base[null font ], font ptr + 1 − null font ); undump things (exten base[null font ], font ptr + 1 − null font ); undump things (param base[null font ], font ptr + 1 − null font ); undump things (font glue[null font ], font ptr + 1 − null font ); undump things (bchar label [null font ], font ptr + 1 − null font ); undump things (font bchar [null font ], font ptr + 1 − null font ); undump things (font false bchar [null font ], font ptr + 1 − null font ); end

This code is used in section 1321*.

1324* . ⟨ Dump the hyphenation tables 1324* ⟩ ≡ dump int (hyph count ); for k ← 0 to hyph size do

if hyph word [k] ≠ 0 then begin dump int (k); dump int (hyph word [k]); dump int (hyph list [k]); end;

print ln; print int (hyph count ); print ( ␣ ␣ ); if hyph count ≠ 1 then print char ( ); if trie not ready then init trie; dump int (trie max ); dump things (trie[0], trie max + 1); dump int (trie op ptr ); dump things (hyf distance[1], trie op ptr ); dump things (hyf num[1], trie op ptr ); dump things (hyf next [1], trie op ptr ); print nl ( ␣ ␣ ␣ ␣ ); print int (trie max ); print ( ␣ ␣ ); print int (trie op ptr ); print ( ␣ ); if trie op ptr ≠ 1 then print char ( ); print ( ␣ ␣ ␣ ); print int (trie op size); for k ← 255 downto 0 do

if trie used [k] > min quarterword then begin print nl ( ␣␣ ); print int (qo(trie used [k])); print ( ␣ ␣ ␣ ); print int (k); dump int (k); dump int (qo(trie used [k])); end

This code is used in section 1302*.

1325* . Only “nonempty” parts of op start need to be restored. ⟨ Undump the hyphenation tables 1325* ⟩ ≡

undump(0)(hyph size)(hyph count ); for k ← 1 to hyph count do

begin undump(0)(hyph size)(j); undump(0)(str ptr )(hyph word [j]);

undump(min halfword )(max halfword )(hyph list [j]);

end; undump size(0)(trie size)(´ ␣ ´ )(j); init trie max ← j; tiniundump things (trie[0], j + 1); undump size(0)(trie op size)(´ ␣ ␣ ´ )(j); init

trie op ptr ← j; tiniundump things (hyf distance[1], j); undump things (hyf num[1], j); undump things (hyf next [1], j); init for k ← 0 to 255 do trie used [k] ← min quarterword ; tinik ← 256; while j > 0 do

begin undump(0)(k − 1)(k); undump(1)(j)(x); init trie used [k] ← qi (x); tinij ← j − x; op start [k] ← qo(j); end;

init trie not ready ← false tini

This code is used in section 1303*.

1327* . ⟨ Undump a couple more things and the closing check word 1327* ⟩ ≡ undump(batch mode)(error stop mode)(interaction); undump(0)(str ptr )(format ident ); undump int (x); if (x ≠ 69069) ∨ feof (fmt file) then goto bad fmt

This code is used in section 1303*.

1328* . ⟨ Create the format ident , open the format file, and inform the user that dumping has

begun 1328* ⟩ ≡ selector ← new string ; print ( ␣ ); print (job name); print char ( ␣ ); print int (year mod 100); print char ( ); print int (month); print char ( ); print int (day ); print char ( ); if interaction = batch mode then selector ← log only else selector ← term and log ; str room(1); format ident ← make string ; pack job name(format extension); while ¬w open out (fmt file) do prompt file name( ␣ ␣ , format extension); print nl ( ␣ ␣ ␣ ␣ ␣ ); print (w make name string (fmt file)); flush string ; print nl (format ident )

This code is used in section 1302*.

§1330  TEX82  PART 51: THE MAIN PROGRAM 41

1332* . Now this is really it: TEX starts and ends here.

The initial test involving ready already should be deleted if the Pascal runtime system is smart enough to detect such a “mistake.” procedure tex body ;

begin { start here } history ← fatal error stop; { in case we quit during initialization } t open out ; { open the terminal for output }

{ get default file paths from the environment } set paths (TEX FORMAT PATH BIT + TEX INPUT PATH BIT + TEX POOL PATH BIT +

TFM FILE PATH BIT ); if ready already = 314159 then goto start of TEX ; ⟨ Check the “constant” values for consistency 14 ⟩ if bad > 0 then

begin wterm ln(´ ␣ ␣ ␣ ␣ ␣ ´ , ´ ␣´ , bad : 1); goto final end ; end;

initialize; { set global variables to their starting values } init if ¬get strings started then goto final end ; init prim; { call primitive for each primitive } init str ptr ← str ptr ; init pool ptr ← pool ptr ; fix date and time; tini ready already ← 314159;

start of TEX : ⟨ Initialize the output routines 55 ⟩; ⟨ Get the first line of input and prepare to start 1337 ⟩; history ← spotless ; { ready to go! } main control ; { come to life } final cleanup; { prepare for death } close files and terminate;

final end : do final end ; end { tex body } ; end .

42  PART 51: THE MAIN PROGRAM  TEX82 §1333

1333* . Here we do whatever is needed to complete TEX’s job gracefully on the local operating system. The code here might come into play after a fatal error; it must therefore consist entirely of “safe” operations that cannot produce error messages. For example, it would be a mistake to call str room or make string at this time, because a call on overflow might lead to an infinite loop.

Actually there’s one way to get error messages, via prepare mag ; but that can’t cause infinite recursion. This program doesn’t bother to close the input files that may still be open.

⟨ Last-minute procedures 1333* ⟩ ≡ procedure close files and terminate;

var k: integer ; { all-purpose index } begin ⟨ Finish the extensions 1378 ⟩; stat if tracing stats > 0 then ⟨ Output statistics about this job 1334 ⟩; tats wake up terminal ; ⟨ Finish the file 642 ⟩;

if log opened then

begin wlog cr ; a close(log file); selector ← selector − 2; if selector = term only then

begin print nl ( ␣ ␣ ␣ ); print (log name); print char ( ); end;

end; print ln; if (edit name start ≠ 0) ∧ (interaction > batch mode) then

call edit (str pool , edit name start , edit name length, edit line); end;

See also sections 1335, 1336, and 1338*. This code is used in section 1330.

§1338  TEX82  PART 52: DEBUGGING 43

1338* . Debugging. Once TEX is working, you should be able to diagnose most errors with the commands and other diagnostic features. But for the initial stages of debugging, and for the revelation of really deep mysteries, you can compile TEX with a few more aids, including the Pascal runtime checks and its debugger. An additional routine called debug help will also come into play when you type ‘ ’ after an error message; debug help also occurs just before a fatal error causes TEX to succumb.

The interface to debug help is primitive, but it is good enough when used with a Pascal debugger that allows you to set breakpoints and to read variables and change their values. After getting the prompt ‘ #’, you type either a negative number (this exits debug help), or zero (this goes to a location where you can set a breakpoint, thereby entering into dialog with the Pascal debugger), or a positive number m followed by an argument n. The meaning of m and n will be clear from the program below. (If m = 13, there is an additional argument, l.)

define breakpoint = 888 { place where a breakpoint is desirable } ⟨ Last-minute procedures 1333* ⟩ +≡

debug procedure debug help; { routine to display various things }

label breakpoint , exit ;

var k, l, m, n: integer ;

begin loop

begin wake up terminal ; print nl ( ␣#␣ ␣ ␣ ); update terminal ; read (term in, m); if m < 0 then return else if m = 0 then dump core { Do something to cause a core dump }

else begin read (term in, n);

case m of

⟨ Numbered cases for debug help 1339 ⟩ othercases print ( ) endcases; end;

end; exit : end;

gubed

44  PART 54: SYSTEM-DEPENDENT CHANGES  TEX82 §1340

1379* . System-dependent changes. Here is a temporary integer, used as a holder during reading and writing of TFM files, and a temporary memory word , used in reading/writing format files. Also, the variables used to hold “switch-to-editor” information. ⟨ Global variables 13 ⟩ +≡ edit name start : pool pointer ; edit name length, edit line, tfm temp: integer ;

1380* . The edit name start will be set to point into str pool somewhere after its beginning if TEX is supposed to switch to an editor on exit. ⟨ Set initial values of key variables 21 ⟩ +≡

§1381  TEX82  PART 55: INDEX 45

edit name start ← 0; 1381* . Index. Here is where you can find all uses of each identifier in the program, with underlined entries pointing to where the identifier was defined. If the identifier is only one letter long, however, you get to see only the underlined entries. All references are to section numbers instead of page numbers.

This index also lists error messages and other aspects of the program that you might want to look up some day. For example, the entry for “system dependencies” lists all sections that should receive special attention from people who are installing TEX in a new operating environment. A list of various things that can’t happen appears under “this can’t happen”. Approximately 40 sections are listed under “inner loop”; these account for about 60% of TEX’s running time, exclusive of input and output.

The following sections were changed by the change file: 2, 4, 6, 7, 8, 9, 11, 12, 16, 19, 23, 25, 27, 28, 31, 32, 33, 34, 37, 51, 52, 53, 61, 81, 84, 109, 110, 112, 113, 116, 127, 165, 174, 176, 186, 241, 253, 262, 513, 514, 516, 520, 521, 524, 534, 536, 537, 563, 564, 575, 597, 859, 875, 943, 944, 948, 1275, 1302, 1303, 1305, 1306, 1308, 1309, 1310, 1311, 1312, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1327, 1328, 1332, 1333, 1338, 1379, 1380, 1381.

: 37* , 534* . : 174* , 176* , 178, 313, 360, 856, 1006, 1355. : 294. ¡system dependencies: 1379* . : 363. : 59, 60. : 83. : 856. : 846. a: \underline{47}, \underline{102}, \underline{218}, \underline{518}, \underline{519}, \underline{523}, \underline{560}, \underline{691}, \underline{722}, \underline{738},

\underline{752}, \underline{1123}, \underline{1194}, \underline{1211}, \underline{1236}, \underline{1257}. : 1084. a close: 51* , 329, 485, 486, 1275* , 1333* , 1374, 1378. a leaders : \underline{149}, 189, 625, 627, 634, 636, 656, 671,

1071, 1072, 1073, 1078, 1148. a make name string : \underline{525}, 534* , 537* . a open in: 51* , 537* , 1275* . a open out : 534* , 1374. A token: \underline{445}. abort : \underline{560}, 563* , 564* , 565, 568, 569, 570, 571,

573, 575* . above: \underline{208}, 1046, 1178, 1179, 1180. primitive: \underline{1178}. above code: \underline{1178}, 1179, 1182, 1183. above display short skip: \underline{224}, 814. primitive: \underline{226}. above display short skip code: \underline{224}, 225, 226, 1203. above display skip: \underline{224}, 814. primitive: \underline{226}. above display skip code: \underline{224}, 225, 226, 1203, 1206. primitive: \underline{1178}. abs : 66, 186* , 211, 218, 219, 418, 422, 448, 501,

610, 663, 675, 718, 737, 757, 758, 759, 831, 836, 849, 859* , 944* , 948* , 1029, 1030, 1056, 1076, 1078, 1080, 1083, 1093, 1110, 1120, 1127, 1149, 1243, 1244, 1377.

absorbing : \underline{305}, 306, 339, 473. acc kern: \underline{155}, 191, 837, 842, 879, 1125. accent : \underline{208}, 265, 266, 1090, 1122, 1164, 1165. primitive: \underline{265}.

accent chr : \underline{687}, 696, 738, 1165.
accent noad : \underline{687}, 690, 696, 698, 733, 761,

1165, 1186. accent noad size: \underline{687}, 698, 761, 1165.

act width: \underline{866}, 867, 868, 869, 871.
action procedure: \underline{1029}.

active: \underline{162}, 819, 829, 843, 854, 860, 861, 863,

864, 865, 873, 874, 875* . active base: 220, \underline{222}, 252, 253* , 255, 262* , 263, 353, 442, 506, 1152, 1257, 1289, 1315* , 1317* .

active char : \underline{207}, 344, 506.

active height : \underline{970}, 975, 976.
active node size: \underline{819}, 845, 860, 864, 865.
active width: \underline{823}, 824, 829, 843, 861, 864,

866, 868, 970. actual looseness : \underline{872}, 873, 875* .

add delims to: \underline{347}.
add glue ref : \underline{203}, 206, 430, 802, 881, 996,

1100, 1229. add token ref : \underline{203}, 206, 323, 979, 1012, 1016,

1221, 1227, 1357. additional : \underline{644}, 645, 657, 672.

adj demerits : \underline{236}, 836, 859* .
primitive: \underline{238}.
adj demerits code: \underline{236}, 237, 238.
adjust : \underline{576}.

adjust head : \underline{162}, 888, 889, 1076, 1085, 1199, 1205. adjust node: \underline{142}, 148, 175, 183, 202, 206, 647, 651, 655, 730, 761, 866, 899, 1100. adjust ptr : \underline{142}, 197, 202, 206, 655, 1100.

adjust space factor : \underline{1034}, 1038.

adjust tail : \underline{647}, 648, 649, 651, 655, 796, 888,

889, 1076, 1085, 1199. adjusted hbox group: \underline{269}, 1062, 1083, 1085.

adv past : \underline{1362}, 1363.

advance: \underline{209}, 265, 266, 1210, 1235, 1236, 1238.

primitive: \underline{265}.
advance major tail : \underline{914}, 917.
after : \underline{147}, 866, 1196.
after assignment : \underline{208}, 265, 266, 1268.

46  PART 55: INDEX  TEX82 §1381

primitive: \underline{265}. after group: \underline{208}, 265, 266, 1271. primitive: \underline{265}. after math: 1193, \underline{1194}. after token: \underline{1266}, 1267, 1268, 1269. aire: \underline{560}, 561, 563* , 576. align error : 1126, \underline{1127}. align group: \underline{269}, 768, 774, 791, 800, 1131, 1132. align head : \underline{162}, 770, 777. align peek : 773, 774, \underline{785}, 799, 1048, 1133. align ptr : \underline{770}, 771, 772. align stack node size: \underline{770}, 772. align state: 88, \underline{309}, 324, 325, 331, 339, 342, 347,

357, 394, 395, 396, 403, 442, 475, 482, 486, 770, 771, 772, 774, 777, 783, 784, 785, 788, 789, 791, 1069, 1094, 1126, 1127.

aligning : \underline{305}, 306, 339, 777, 789. alignment of rules with characters: 589. alpha: \underline{560}, 571, 572. alpha file: 25* , 50, 54, 304, 480, 525, 1342. alpha token: \underline{438}, 440. alter aux : 1242, \underline{1243}. alter box dimen: 1242, \underline{1247}. alter integer : 1242, \underline{1246}. alter page so far : 1242, \underline{1245}. alter prev graf : 1242, \underline{1244}. : 1183. Amble, Ole: 925. : 1331. any mode: \underline{1045}, 1048, 1057, 1063, 1067, 1073,

1097, 1102, 1104, 1126, 1134, 1210, 1268, 1271, 1274, 1276, 1285, 1290, 1347.

any state plus : \underline{344}, 345, 347. app lc hex : \underline{48}. app space: 1030, \underline{1043}. append char : \underline{42}, 48, 52* , 58, 180, 195, 260, 516* ,

525, 692, 695, 939. append charnode to t : \underline{908}, 911. append choices : 1171, \underline{1172}. append discretionary : 1116, \underline{1117}. append glue: 1057, \underline{1060}, 1078. append italic correction: 1112, \underline{1113}. append kern: 1057, \underline{1061}. append normal space: \underline{1030}. append penalty : 1102, \underline{1103}. append to name: \underline{519}, 523. append to vlist : \underline{679}, 799, 888, 1076, 1203, 1204,

1205. area delimiter : \underline{513*} , 515, 516* , 517. : 395. arith error : \underline{104}, 105, 106, 107, 448, 453, 460,

1236.

: 1236.

artificial demerits : \underline{830}, 851, 854, 855, 856.

ASCII code: 17, 503.

ASCII code: \underline{18}, 19* , 20, 29, 30, 31* , 38, 42, 54, 58, 60, 82, 292, 341, 389, 516* , 519, 523, 692, 892, 912, 921, 943* , 950, 953, 959, 960, 1376. assign dimen: \underline{209}, 248, 249, 413, 1210, 1224,

1228. assign font dimen: \underline{209}, 265, 266, 413, 1210, 1253. assign font int : \underline{209}, 413, 1210, 1253, 1254, 1255.

assign glue: \underline{209}, 226, 227, 413, 782, 1210,

1224, 1228. assign int : \underline{209}, 238, 239, 413, 1210, 1222, 1224,

1228, 1237. assign mu glue: \underline{209}, 226, 227, 413, 1210, 1222,

1224, 1228, 1237. assign toks : \underline{209}, 230, 231, 233, 323, 413, 415,

1210, 1224, 1226, 1227. : 1258. primitive: \underline{1178}. atop code: \underline{1178}, 1179, 1182. primitive: \underline{1178}. attach fraction: \underline{448}, 453, 454, 456. attach sign: \underline{448}, 449, 455. auto breaking : \underline{862}, 863, 866, 868. aux : 212, \underline{213}, 216, 786, 800, 812. aux field : \underline{212}, 213, 218, 775. aux save: \underline{800}, 812, 1206. avail : \underline{118}, 120, 121, 122, 123, 164, 168, 1311* , 1312* . : 168. awful bad : \underline{833}, 834, 835, 836, 854, 874, 970, 974,

975, 987, 1005, 1006, 1007. axis height : \underline{700}, 706, 736, 746, 747, 749, 762. b: \underline{464}, \underline{465}, \underline{470}, \underline{498}, \underline{523}, \underline{560}, \underline{679}, \underline{705}, \underline{706}, \underline{709}, \underline{711}, \underline{715}, \underline{830}, \underline{970}, \underline{994}, \underline{1198}, \underline{1247}, \underline{1288}.

b close: 560, 642.

b make name string : \underline{525}, 532.

b open in: 563* . b open out : 532. back error : \underline{327}, 373, 396, 403, 415, 442, 446, 476, 479, 503, 577, 783, 1078, 1084, 1161, 1197, 1207, 1212.

back input : 281, \underline{325}, 326, 327, 368, 369, 372, 375, 379, 395, 405, 407, 415, 443, 444, 448, 452, 455, 461, 526, 788, 1031, 1047, 1054, 1064, 1090, 1095, 1124, 1127, 1132, 1138, 1150, 1152, 1153, 1215, 1221, 1226, 1269, 1375. back list : \underline{323}, 325, 337, 407, 1288. backed up: \underline{307}, 311, 312, 314, 323, 324, 325, 1026.

background : \underline{823}, 824, 827, 837, 863, 864.
backup backup: \underline{366}.
backup head : \underline{162}, 366, 407.

: 293, 294. bad : \underline{13}, 14, 111, 290, 522, 1249, 1332* . : 961. : 1244. : 434. : 437. : 170. : 182. : 436. : 435. : 433. : 1243. bad fmt : \underline{1303*} , 1306* , 1308* , 1312* , 1317* , 1327* . bad pool : \underline{51*} , 52* , 53* . bad tfm: \underline{560}. badness : \underline{108}, 660, 667, 674, 678, 828, 852, 853,

975, 1007. primitive: \underline{416}. badness code: \underline{416}, 424. banner : \underline{2*} , 61* , 536* , 1299. base line: \underline{619}, 623, 624, 628. base ptr : 84* , 85, \underline{310}, 311, 312, 313. baseline skip: \underline{224}, 247, 679. primitive: \underline{226}. baseline skip code: 149, \underline{224}, 225, 226, 679. batch mode: \underline{73}, 75, 86, 90, 92, 93, 535, 1262,

1263, 1327* , 1328* , 1333* . primitive: \underline{1262}. bc: 540, 541, 543, 545, \underline{560}, 565, 566, 570, 576. bch label : \underline{560}, 573, 576. bchar : \underline{560}, 573, 576, \underline{901}, 903, 905, \underline{906}, 908, 911,

913, 916, 917, \underline{1032}, 1034, 1037, 1038, 1040. bchar label : \underline{549}, 552, 576, 909, 916, 1034, 1040,

1322* , 1323* . before: \underline{147}, 192, 1196. begin: 7* , 8* . begin box : 1073, \underline{1079}, 1084. begin diagnostic: 76, \underline{245}, 284, 299, 323, 400, 401,

502, 509, 581, 638, 641, 663, 675, 863, 987, 992, 1006, 1011, 1121, 1293, 1296.

begin file reading : 78, 87, \underline{328}, 483, 537* . begin group: \underline{208}, 265, 266, 1063. primitive: \underline{265}. begin insert or adjust : 1097, \underline{1099}. begin name: 512, \underline{515}, 526, 527, 531. begin pseudoprint : \underline{316}, 318, 319. begin token list : \underline{323}, 359, 386, 390, 774, 788,

789, 799, 1025, 1030, 1083, 1091, 1139, 1145, 1167, 1371.

: 1328* . below display short skip: \underline{224}. primitive: \underline{226}.

below display short skip code: \underline{224}, 225, 226, 1203.
below display skip: \underline{224}.
primitive: \underline{226}.
below display skip code: \underline{224}, 225, 226, 1203, 1206.
best bet : \underline{872}, 874, 875* , 877, 878.
best height plus depth: \underline{971}, 974, 1010, 1011.
best ins ptr : \underline{981}, 1005, 1009, 1018, 1020, 1021.
best line: \underline{872}, 874, 875* , 877, 890.
best page break : \underline{980}, 1005, 1013, 1014.
best pl line: \underline{833}, 845, 855.
best place: \underline{833}, 845, 855, \underline{970}, 974, 980.
best size: \underline{980}, 1005, 1017.
beta: \underline{560}, 571, 572.
big op spacing1 : \underline{701}, 751.
big op spacing2 : \underline{701}, 751.
big op spacing3 : \underline{701}, 751.
big op spacing4 : \underline{701}, 751.
big op spacing5 : \underline{701}, 751.
big switch: 209, 236, 994, 1029, \underline{1030}, 1031,

1036, 1041. BigEndian order: \underline{540}.

bin noad : \underline{682}, 690, 696, 698, 728, 729, 761,

1156, 1157. bin op penalty : \underline{236}, 761. primitive: \underline{238}. bin op penalty code: \underline{236}, 237, 238. blank line: \underline{245}. boolean: 37* , 45, 46, 47, 76, 79, 96, 104, 106, 107, 165* , 167, 245, 256, 311, 361, 407, 413, 440, 448, 461, 473, 498, 516* , 524* , 527, 549, 560, 578, 592, 619, 629, 645, 706, 719, 726, 791, 825, 828, 829, 830, 862, 877, 900, 907, 950, 960, 989, 1012, 1032, 1051, 1054, 1091, 1160, 1194, 1211, 1281, 1303* , 1342.

bop: 583, 585, \underline{586}, 588, 590, 592, 638, 640.

Bosshard, Hans Rudolf: 458.

bot : \underline{546}.

bot mark : \underline{382}, 383, 1012, 1016.

primitive: \underline{384}. bot mark code: \underline{382}, 384, 385. bottom level : \underline{269}, 272, 281, 1064, 1068. bottom line: \underline{311}. bowels: 592. box : \underline{230}, 232, 420, 505, 977, 992, 993, 1009, 1015, 1017, 1018, 1021, 1023, 1028, 1079, 1110, 1247, 1296. primitive: \underline{1071}.

box base: \underline{230}, 232, 233, 255, 1077.
box code: \underline{1071}, 1072, 1079, 1107, 1110.

box context : \underline{1075}, 1076, 1077, 1078, \underline{1079}, 1083,

\underline{1084}.

box end : \underline{1075}, 1079, 1084, 1086.

box error : \underline{992}, 993, 1015, 1028. box flag : \underline{1071}, 1075, 1077, 1083, 1241. box max depth: \underline{247}, 1086. primitive: \underline{248}. box max depth code: \underline{247}, 248. box node size: \underline{135}, 136, 202, 206, 649, 668, 715,

727, 751, 756, 977, 1021, 1100, 1110, 1201. box ref : \underline{210}, 232, 275, 1077. box there: \underline{980}, 987, 1000, 1001. : 1015. : 458. brain: 1029. breadth max : \underline{181}, 182, 198, 233, 236, 1339. break node: \underline{819}, 845, 855, 856, 864, 877, 878. break penalty : \underline{208}, 265, 266, 1102. break type: \underline{829}, 837, 845, 846, 859* . break width: \underline{823}, 824, 837, 838, 840, 841, 842,

843, 844, 879. breakpoint : \underline{1338*} . broken ins : \underline{981}, 986, 1010, 1021. broken penalty : \underline{236}, 890. primitive: \underline{238}. broken penalty code: \underline{236}, 237, 238. broken ptr : \underline{981}, 1010, 1021. buf size: \underline{11*} , 30, 31* , 35, 71, 111, 315, 328, 331,

341, 363, 366, 374, 524* , 530, 534* , 1334. buffer : \underline{30}, 31* , 36, 37* , 45, 71, 83, 87, 88, 259, 260,

261, 264, 302, 303, 315, 318, 331, 341, 343, 352, 354, 355, 356, 360, 362, 363, 366, 374, 483, 484, 523, 524* , 530, 531, 534* , 538, 1337, 1339.

: 35. build choices : 1173, \underline{1174}. build discretionary : 1118, \underline{1119}. build page: 800, 812, 988, \underline{994}, 1026, 1054, 1060,

1076, 1091, 1094, 1100, 1103, 1145, 1200. bypass eoln: 31* . byte file: 25* , 525, 532, 539. b0 : 110* , 114, 133, 221, 268, 545, 546, 550, 554,

556, 564* , 602, 683, 685, 921, 958, 1309* , 1310* . b1 : 110* , 114, 133, 221, 268, 545, 546, 554, 556,

564* , 602, 683, 685, 921, 958, 1309* , 1310* . b2 : 110* , 114, 545, 546, 554, 556, 564* , 602, 683,

685, 1309* , 1310* . b3 : 110* , 114, 545, 546, 556, 564* , 602, 683, 685,

1309* , 1310* . c: \underline{47}, \underline{63}, \underline{82}, \underline{144}, \underline{264}, \underline{274}, \underline{292}, \underline{341}, \underline{470}, \underline{516*} , \underline{519},

\underline{523}, \underline{560}, \underline{581}, \underline{582}, \underline{592}, \underline{645}, \underline{692}, \underline{694}, \underline{706}, \underline{709}, \underline{711}, \underline{712}, \underline{738}, \underline{749}, \underline{893}, \underline{912}, \underline{953}, \underline{959}, \underline{960}, \underline{994}, \underline{1012}, \underline{1086}, \underline{1110}, \underline{1117}, \underline{1136}, \underline{1151}, \underline{1155}, \underline{1181}, \underline{1243}, \underline{1245}, \underline{1246}, \underline{1247}, \underline{1275*} , \underline{1279}, \underline{1288}, \underline{1335}.

c char pointer : 520* , 534* . c leaders : \underline{149}, 190, 627, 636, 1071, 1072. primitive: \underline{1071}. c loc: \underline{912}, 916. call : \underline{210}, 223, 275, 296, 366, 380, 387, 395, 396,

507, 1218, 1221, 1225, 1226, 1227, 1295. call edit : 84* , 1333* . cancel boundary : 1030, \underline{1032}, 1033, 1034. : 484. car ret : \underline{207}, 232, 342, 347, 777, 780, 781, 783,

784, 785, 788, 1126. carriage return: \underline{22}, 49, 207, 232, 240, 363. case shift : \underline{208}, 1285, 1286, 1287. cat : \underline{341}, 354, 355, 356. cat code: \underline{230}, 232, 236, 262* , 341, 343, 354,

355, 356, 1337. primitive: \underline{1230}. cat code base: \underline{230}, 232, 233, 235, 1230, 1231, 1233. cc: \underline{341}, 352, 355. : 458. change if limit : \underline{497}, 498, 509. char : 19* , 26. primitive: \underline{265}. char base: \underline{550}, 552, 554, 566, 570, 576, 1322* , 1323* . char box : \underline{709}, 710, 711, 738. primitive: \underline{1222}. char def code: \underline{1222}, 1223, 1224. char depth: \underline{554}, 654, 708, 709, 712. char depth end : \underline{554}. char exists : \underline{554}, 573, 576, 582, 708, 722, 738,

740, 749, 755, 1036. char given: \underline{208}, 413, 935, 1030, 1038, 1090, 1124,

1151, 1154, 1222, 1223, 1224. char height : \underline{554}, 654, 708, 709, 712, 1125. char height end : \underline{554}. char info: 543, 550, \underline{554}, 555, 557, 570, 573, 576,

582, 620, 654, 708, 709, 712, 714, 715, 722, 724, 738, 740, 749, 841, 842, 866, 867, 870, 871, 909, 1036, 1037, 1039, 1040, 1113, 1123, 1125, 1147.

char info end : \underline{554}. char info word : 541, \underline{543}, 544. char italic: \underline{554}, 709, 714, 749, 755, 1113. char italic end : \underline{554}. char kern: \underline{557}, 741, 753, 909, 1040. char kern end : \underline{557}. char node: \underline{134}, 143, 145, 162, 176* , 548, 592, 620,

649, 752, 881, 907, 1029, 1113, 1138. char num: \underline{208}, 265, 266, 935, 1030, 1038, 1090,

1124, 1151, 1154. char tag : \underline{554}, 570, 708, 710, 740, 741, 749,

752, 909, 1039. char warning : \underline{581}, 582, 722, 1036. char width: \underline{554}, 620, 654, 709, 714, 715, 740, 841,

842, 866, 867, 870, 871, 1123, 1125, 1147. char width end : \underline{554}. character : \underline{134}, 143, 144, 174* , 176* , 206, 582, 620,

654, 681, 682, 683, 687, 691, 709, 715, 722, 724, 749, 752, 753, 841, 842, 866, 867, 870, 871, 896, 897, 898, 903, 907, 908, 910, 911, 1032, 1034, 1035, 1036, 1037, 1038, 1040, 1113, 1123, 1125, 1147, 1151, 1155, 1165.

character set dependencies: 23* , 49. check sum: 53* , 542, 588. check byte range: \underline{570}, 573. check dimensions : \underline{726}, 727, 733, 754. check existence: \underline{573}, 574. check full save stack : \underline{273}, 274, 276, 280. check interrupt : \underline{96}, 324, 343, 753, 911, 1031, 1040. check mem: 165* , \underline{167}, 1031, 1339. check outer validity : \underline{336}, 351, 353, 354, 357,

362, 375. check shrinkage: \underline{825}, 827, 868. Chinese characters: 134, 585. choice node: 688, \underline{689}, 690, 698, 730. choose mlist : \underline{731}. chr : 19* , 20, 23* , 24, 1222. chr cmd : \underline{298}, 781. chr code: 227, 231, 239, 249, \underline{298}, 377, 385, 411,

412, 413, 417, 469, 488, 492, 781, 984, 1053, 1059, 1071, 1072, 1089, 1108, 1115, 1143, 1157, 1170, 1179, 1189, 1209, 1220, 1223, 1231, 1251, 1255, 1261, 1263, 1273, 1278, 1287, 1289, 1292, 1346.

clang : 212, \underline{213}, 812, 1034, 1091, 1200, 1376, 1377. clean box : \underline{720}, 734, 735, 737, 738, 742, 744, 749,

750, 757, 758, 759. clear for error prompt : 78, 83, \underline{330}, 346. clear terminal : 34* , 330, 530. : 293. clobbered : \underline{167}, 168, 169. close files and terminate: 78, 81* , 1332* , \underline{1333*} . primitive: \underline{1272}. close noad : \underline{682}, 690, 696, 698, 728, 761, 762,

1156, 1157. close node: \underline{1341}, 1344, 1346, 1348, 1356, 1357,

1358, 1373, 1374, 1375. primitive: \underline{1344}. closed : \underline{480}, 481, 483, 485, 486, 501, 1275* . clr : \underline{737}, \underline{743}, 745, 746, \underline{756}, 757, 758, 759. club penalty : \underline{236}, 890. primitive: \underline{238}. club penalty code: \underline{236}, 237, 238. : 458. cmd : \underline{298}, 1222, 1289. co backup: \underline{366}. combine two deltas : \underline{860}.

comment : \underline{207}, 232, 347.
common ending : \underline{15}, 498, 500, 509, 649, 660,

666, 667, 668, 674, 677, 678, 895, 903, 1257, 1260, 1293, 1294, 1297.

: 638. compress trie: \underline{949}, 952. cond math glue: \underline{149}, 189, 732, 1171. cond ptr : \underline{489}, 490, 495, 496, 497, 498, 500,

509, 1335. conditional : 366, 367, \underline{498}. confusion: \underline{95}, 202, 206, 281, 497, 630, 669, 728, 736, 754, 761, 766, 791, 798, 800, 841, 842, 866, 870, 871, 877, 968, 973, 1000, 1068, 1185, 1200, 1211, 1348, 1357, 1358, 1373.

continental point token: \underline{438}, 448.

continue: \underline{15}, 82, 83, 84* , 88, 89, 389, 392, 393, 394, 397, 706, 708, 774, 784, 815, 829, 832, 851, 896, 906, 909, 910, 911, 994, 1001. contrib head : \underline{162}, 215, 218, 988, 994, 995, 998,

999, 1001, 1017, 1023, 1026. contrib tail : \underline{995}, 1017, 1023, 1026. contribute: \underline{994}, 997, 1000, 1002, 1008, 1364. conv toks : 366, 367, \underline{470}. conventions for representing stacks: 300. convert : \underline{210}, 366, 367, 468, 469, 470. convert to break width: \underline{843}. primitive: \underline{1071}. copy code: \underline{1071}, 1072, 1079, 1107, 1108, 1110. copy node list : 161, 203, \underline{204}, 206, 1079, 1110. copy to cur active: \underline{829}, 861. count : \underline{236}, 427, 638, 640, 986, 1008, 1009, 1010. primitive: \underline{411}. count base: \underline{236}, 239, 242, 1224, 1237. primitive: \underline{1222}. count def code: \underline{1222}, 1223, 1224. primitive: \underline{780}. cr code: \underline{780}, 781, 789, 791, 792. primitive: \underline{780}. cr cr code: \underline{780}, 785, 789. cramped : \underline{688}, 702. cramped style: \underline{702}, 734, 737, 738. cs count : \underline{256}, 258, 260, 1318* , 1319* , 1334. cs error : 1134, \underline{1135}. cs name: \underline{210}, 265, 266, 366, 367. primitive: \underline{265}. cs token flag : \underline{289}, 290, 293, 334, 336, 337, 339, 357, 358, 365, 369, 372, 375, 379, 380, 381, 442, 466, 506, 780, 1065, 1132, 1215, 1289, 1314, 1371.

cur active width: \underline{823}, 824, 829, 832, 837, 843, 844, 851, 852, 853, 860. cur align: \underline{770}, 771, 772, 777, 778, 779, 783, 786,

788, 789, 791, 792, 795, 796, 798. cur area: \underline{512}, 517, 529, 530, 537* , 1257, 1260,

1351, 1374. cur boundary : 270, \underline{271}, 272, 274, 282. cur box : \underline{1074}, 1075, 1076, 1077, 1078, 1079, 1080,

1081, 1082, 1084, 1086, 1087. cur break : \underline{821}, 845, 879, 880, 881, 883. cur c: 722, 723, \underline{724}, 738, 749, 752, 753, 755. cur chr : 88, 296, \underline{297}, 299, 332, 337, 341, 343, 348,

349, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 364, 365, 378, 380, 381, 386, 387, 389, 403, 407, 413, 424, 428, 442, 470, 472, 474, 476, 479, 483, 494, 495, 498, 500, 506, 507, 508, 509, 510, 526, 577, 782, 785, 789, 935, 937, 962, 1030, 1034, 1036, 1038, 1049, 1058, 1060, 1061, 1066, 1073, 1079, 1083, 1090, 1093, 1105, 1106, 1110, 1117, 1124, 1128, 1140, 1142, 1151, 1152, 1154, 1155, 1158, 1159, 1160, 1171, 1181, 1191, 1211, 1212, 1213, 1217, 1218, 1221, 1224, 1226, 1227, 1228, 1232, 1233, 1234, 1237, 1243, 1245, 1246, 1247, 1252, 1253, 1265, 1275* , 1279, 1288, 1293, 1335, 1348, 1350, 1375.

cur cmd : 88, 211, 296, \underline{297}, 299, 332, 337, 341, 342, 343, 344, 348, 349, 351, 353, 354, 357, 358, 360, 364, 365, 366, 367, 368, 372, 380, 381, 386, 387, 403, 404, 406, 407, 413, 415, 428, 440, 442, 443, 444, 448, 452, 455, 461, 463, 474, 476, 477, 478, 479, 483, 494, 506, 507, 526, 577, 777, 782, 783, 784, 785, 788, 789, 935, 961, 1029, 1030, 1038, 1049, 1066, 1078, 1079, 1084, 1095, 1099, 1124, 1128, 1138, 1151, 1152, 1160, 1165, 1176, 1177, 1197, 1206, 1211, 1212, 1213, 1221, 1226, 1227, 1228, 1236, 1237, 1252, 1270, 1375.

cur cs : \underline{297}, 332, 333, 336, 337, 338, 341, 351, 353, 354, 356, 357, 358, 365, 372, 374, 379, 380, 381, 389, 391, 407, 472, 473, 507, 774, 1152, 1215, 1218, 1221, 1224, 1225, 1226, 1257, 1294, 1352, 1371.

cur ext : \underline{512}, 517, 529, 530, 537* , 1275* , 1351, 1374. cur f : 722, \underline{724}, 738, 741, 749, 752, 753, 755. cur fam: \underline{236}, 1151, 1155, 1165. cur fam code: \underline{236}, 237, 238, 1139, 1145. cur file: \underline{304}, 329, 362, 537* , 538. cur font : \underline{230}, 232, 558, 559, 577, 1032, 1034,

1042, 1044, 1117, 1123, 1124, 1146. cur font loc: \underline{230}, 232, 233, 234, 1217. cur group: 270, \underline{271}, 272, 274, 281, 282, 800, 1062,

1063, 1064, 1065, 1067, 1068, 1069, 1130, 1131, 1140, 1142, 1191, 1192, 1193, 1194, 1200.

cur h: \underline{616}, 617, 618, 619, 620, 622, 623, 626, 627, 628, 629, 632, 637.

cur head : \underline{770}, 771, 772, 786, 799.
cur height : \underline{970}, 972, 973, 974, 975, 976.
cur i : 722, 723, \underline{724}, 738, 741, 749, 752, 753, 755.
cur if : 336, \underline{489}, 490, 495, 496, 1335.
cur indent : \underline{877}, 889.
cur input : 35, 36, 87, \underline{301}, 302, 311, 321, 322, 534* .
cur l : \underline{907}, 908, 909, 910, 911, 1032, 1034, 1035,

1036, 1037, 1039, 1040. cur lang : 891, \underline{892}, 923, 924, 930, 934, 939,

944* , 963, 1362. cur length: \underline{41}, 180, 182, 260, 516* , 525, 617,

692, 1368. cur level : 270, \underline{271}, 272, 274, 277, 278, 280,

281, 1304, 1335. cur line: \underline{877}, 889, 890.

cur list : \underline{213}, 216, 217, 218, 422, 1244.

cur loop: \underline{770}, 771, 772, 777, 783, 792, 793, 794.

cur mark : 296, \underline{382}, 386.

cur mlist : \underline{719}, 720, 726, 754, 1194, 1196, 1199.

cur mu: 703, \underline{719}, 730, 732, 766.

cur name: \underline{512}, 517, 529, 530, 537* , 1257, 1258,

1260, 1351, 1374. cur order : 366, 439, \underline{447}, 448, 454, 462. cur p: 823, \underline{828}, 829, 830, 833, 837, 839, 840, 845, 851, 853, 855, 856, 857, 858, 859* , 860, 862, 863, 865, 866, 867, 868, 869, 872, 877, 878, 879, 880, 881, 883, 894, 903, 1362. cur q : \underline{907}, 908, 910, 911, 1034, 1035, 1036,

1037, 1040. cur r : \underline{907}, 908, 909, 910, 911, 1032, 1034, 1036,

1037, 1038, 1039, 1040. cur rh: \underline{906}, 908, 909, 910.

cur s : 593, \underline{616}, 619, 629, 640, 642.

cur size: 700, 701, 703, \underline{719}, 722, 723, 732, 736,

737, 744, 746, 747, 748, 749, 757, 758, 759, 762. cur span: \underline{770}, 771, 772, 787, 796, 798.

cur style: 703, \underline{719}, 720, 726, 730, 731, 734,

735, 737, 738, 742, 744, 745, 746, 748, 749, 750, 754, 756, 757, 758, 759, 760, 763, 766, 1194, 1196, 1199.

cur tail : \underline{770}, 771, 772, 786, 796, 799.

cur tok : 88, 281, \underline{297}, 325, 326, 327, 336, 364, 365, 366, 368, 369, 372, 375, 379, 380, 381, 392, 393, 394, 395, 397, 399, 403, 405, 407, 440, 441, 442, 444, 445, 448, 452, 474, 476, 477, 479, 483, 494, 503, 506, 783, 784, 1038, 1047, 1095, 1127, 1128, 1132, 1215, 1221, 1268, 1269, 1271, 1371, 1372.

cur v : \underline{616}, 618, 619, 623, 624, 628, 629, 631, 632,

633, 635, 636, 637, 640. cur val : 264, 265, 334, 366, \underline{410}, 413, 414, 415,

418, 419, 420, 421, 423, 424, 425, 426, 427, 429, 430, 431, 433, 434, 435, 436, 437, 438, 439, 440, 442, 444, 445, 447, 448, 450, 451, 453, 455, 457, 458, 460, 461, 462, 463, 465, 466, 472, 482, 491, 501, 503, 504, 505, 509, 553, 577, 578, 579, 580, 645, 780, 782, 935, 1030, 1038, 1060, 1061, 1073, 1079, 1082, 1099, 1103, 1110, 1123, 1124, 1151, 1154, 1160, 1161, 1165, 1182, 1188, 1224, 1225, 1226, 1227, 1228, 1229, 1232, 1234, 1236, 1237, 1238, 1239, 1240, 1241, 1243, 1244, 1245, 1246, 1247, 1248, 1253, 1258, 1259, 1275* , 1296, 1344, 1350, 1377.

cur val level : 366, \underline{410}, 413, 418, 419, 420, 421, 423, 424, 427, 429, 430, 439, 449, 451, 455, 461, 465, 466.

cur width: \underline{877}, 889. current page: 980. current character being worked on: \underline{570}. cv backup: \underline{366}. cvl backup: \underline{366}. d: \underline{107}, \underline{176*} , \underline{177}, \underline{259}, \underline{341}, \underline{440}, \underline{560}, \underline{649}, \underline{668}, \underline{679},

\underline{706}, \underline{830}, \underline{944*} , \underline{970}, \underline{1068}, \underline{1086}, \underline{1138}, \underline{1198}. d fixed : \underline{608}, 609. danger : \underline{1194}, 1195, 1199. data: \underline{210}, 232, 1217, 1232, 1234. data structure assumptions: \underline{161}, 164, 204, 816,

968, 981. date and time: 241* . day : \underline{236}, 241* , 536* , 617, 1328* . primitive: \underline{238}. day code: \underline{236}, 237, 238. : 458. deactivate: \underline{829}, 851, 854. dead cycles : 419, \underline{592}, 593, 638, 1012, 1024, 1025,

1054, 1242, 1246. primitive: \underline{416}. debug: \underline{7*} , \underline{78}, \underline{84*} , \underline{93}, \underline{114}, \underline{165*} , \underline{166}, \underline{167}, \underline{172},

\underline{1031}, \underline{1338*} . # : 1338* . debug help: 78, 84* , 93, \underline{1338*} . debugging: 7* , 84* , 96, 114, 165* , 182, 1031, 1338* . decent fit : \underline{817}, 834, 852, 853, 864. decr : 42, 44, 64, 71, 86, 88, 89, 90, 92, 102, 120,

121, 123, 175, 177, 200, 201, 205, 217, 245, 260, 281, 282, 311, 322, 324, 325, 329, 331, 347, 356, 357, 360, 362, 394, 399, 422, 429, 442, 477, 483, 494, 509, 534* , 538, 568, 576, 601, 619, 629, 638, 642, 643, 803, 808, 840, 858, 869, 883, 915, 916, 930, 931, 940, 944* , 948* , 965, 1060, 1100, 1120, 1127, 1174, 1186, 1194, 1244, 1293, 1311* , 1335, 1337.

def : \underline{209}, 1208, 1209, 1210, 1213, 1218. primitive: \underline{1208}. def code: \underline{209}, 413, 1210, 1230, 1231, 1232. def family : \underline{209}, 413, 577, 1210, 1230, 1231, 1234. def font : \underline{209}, 265, 266, 413, 577, 1210, 1256. def ref : \underline{305}, 306, 473, 482, 960, 1101, 1218, 1226,

1279, 1288, 1352, 1354, 1370. default code: \underline{683}, 697, 743, 1182. default hyphen char : \underline{236}, 576. primitive: \underline{238}. default hyphen char code: \underline{236}, 237, 238. default rule: \underline{463}. default rule thickness : 683, \underline{701}, 734, 735, 737,

743, 745, 759. default skew char : \underline{236}, 576. primitive: \underline{238}. default skew char code: \underline{236}, 237, 238. defecation: 597* . define: \underline{1214}, 1217, 1218, 1221, 1224, 1225, 1226,

1227, 1228, 1232, 1234, 1236, 1248, 1257. defining : \underline{305}, 306, 339, 473, 482. del code: \underline{236}, 240, 1160. primitive: \underline{1230}. del code base: \underline{236}, 240, 242, 1230, 1232, 1233. delete glue ref : \underline{201}, 202, 275, 451, 465, 578,

732, 802, 816, 826, 881, 976, 996, 1004, 1017, 1022, 1100, 1229, 1239.

delete last : 1104, \underline{1105}. delete q : \underline{726}, 760, 763. delete token ref : \underline{200}, 202, 275, 324, 977, 979,

1012, 1016, 1358. deletions allowed : \underline{76}, 77, 84* , 85, 98, 336, 346. delim num: \underline{207}, 265, 266, 1046, 1151, 1154, 1160. delimited code: \underline{1178}, 1179, 1182, 1183. delimiter : \underline{687}, 762, 1191. primitive: \underline{265}. delimiter factor : \underline{236}, 762. primitive: \underline{238}. delimiter factor code: \underline{236}, 237, 238. delimiter shortfall : \underline{247}, 762. primitive: \underline{248}. delimiter shortfall code: \underline{247}, 248. delim1 : \underline{700}, 748. delim2 : \underline{700}, 748. delta: \underline{103}, \underline{726}, 728, 733, \underline{735}, \underline{736}, \underline{737}, \underline{738}, 742,

\underline{743}, 745, 746, 747, 748, \underline{749}, 750, 754, 755, \underline{756},

759, \underline{762}, \underline{994}, 1008, 1010, \underline{1123}, 1125.

delta node: \underline{822}, 830, 832, 843, 844, 860, 861,

865, 874, 875* . delta node size: \underline{822}, 843, 844, 860, 861, 865. delta1 : \underline{743}, 746, \underline{762}. delta2 : \underline{743}, 746, \underline{762}. den: 585, \underline{587}, 590. denom: \underline{450}, 458. denom style: \underline{702}, 744. denominator : \underline{683}, 690, 697, 698, 744, 1181, 1185. denom1 : \underline{700}, 744. denom2 : \underline{700}, 744. deplorable: \underline{974}, 1005. : 463. depth: \underline{135}, 136, 138, 139, 140, 184, 187, 188, 463,

554, 622, 624, 626, 631, 632, 635, 641, 649, 653, 656, 668, 670, 679, 688, 704, 706, 709, 713, 727, 730, 731, 735, 736, 737, 745, 746, 747, 749, 750, 751, 756, 758, 759, 768, 769, 801, 806, 810, 973, 1002, 1009, 1010, 1021, 1087, 1100.

depth base: \underline{550}, 552, 554, 566, 571, 1322* , 1323* . depth index : \underline{543}, 554. depth offset : \underline{135}, 416, 769, 1247. depth threshold : \underline{181}, 182, 198, 233, 236, 692, 1339. dig : \underline{54}, 64, 65, 67, 102, 452. digit sensed : \underline{960}, 961, 962. dimen: \underline{247}, 427, 1008, 1010. primitive: \underline{411}. dimen base: 220, \underline{236}, 247, 248, 249, 250, 251,

252, 1070, 1145. primitive: \underline{1222}. dimen def code: \underline{1222}, 1223, 1224. dimen par : \underline{247}. dimen pars : \underline{247}. dimen val : \underline{410}, 411, 412, 413, 415, 416, 417,

418, 420, 421, 424, 425, 427, 428, 429, 449, 455, 465, 1237.

: 460. dirty Pascal: \underline{3}, 114, 172, 182, 186* , 285, 1331. dirty Pascal: 812, 1035. disc break : \underline{877}, 880, 881, 882, 890. disc group: \underline{269}, 1117, 1118, 1119. disc node: \underline{145}, 148, 175, 183, 202, 206, 730,

761, 817, 819, 829, 856, 858, 866, 881, 914, 1081, 1105.

disc width: \underline{839}, 840, 869, 870. discretionary : \underline{208}, 1090, 1114, 1115, 1116. : 1120. primitive: \underline{1114}. $$ : 1197. display indent : \underline{247}, 800, 1138, 1145, 1199. primitive: \underline{248}. display indent code: \underline{247}, 248, 1145. primitive: \underline{1156}. display mlist : \underline{689}, 695, 698, 731, 1174. display style: \underline{688}, 694, 731, 1169, 1199. primitive: \underline{1169}. display widow penalty : \underline{236}, 1145. primitive: \underline{238}. display widow penalty code: \underline{236}, 237, 238.

display width: \underline{247}, 1138, 1145, 1199.
primitive: \underline{248}.
display width code: \underline{247}, 248, 1145.
div: \underline{100}, \underline{627}, \underline{636}.
divide: \underline{209}, 265, 266, 1210, 1235, 1236.
primitive: \underline{265}.
do all six : \underline{823}, 829, 832, 837, 843, 844, 860,

861, 864, 970, 987. do assignments : 800, 1123, 1206, \underline{1270}.

do endv : 1130, \underline{1131}.
do extension: 1347, \underline{1348}, 1375.
do final end : \underline{81*} , 1332* .

do nothing : \underline{16*} , 57, 58, 84* , 175, 202, 275, 344, 357, 538, 569, 609, 611, 612, 622, 631, 651, 669, 692, 728, 733, 761, 837, 866, 899, 1045, 1236, 1359, 1360, 1373. do register command : 1235, \underline{1236}.

doing leaders : \underline{592}, 593, 628, 637, 1374.

done: \underline{15}, 47, 53* , 202, 281, 282, 311, 380, 389, 397, 440, 445, 448, 453, 458, 473, 474, 476, 482, 483, 494, 526, 530, 531, 537* , 560, 567, 576, 615, 638, 640, 641, 698, 726, 738, 740, 760, 761, 774, 777, 815, 829, 837, 863, 873, 877, 881, 895, 906, 909, 911, 931, 960, 961, 970, 974, 977, 979, 994, 997, 998, 1005, 1079, 1081, 1119, 1121, 1138, 1146, 1211, 1227, 1252, 1358. done with noad : \underline{726}, 727, 728, 733, 754.

done with node: \underline{726}, 727, 730, 731, 754.

done1 : \underline{15}, 167, 168, 389, 399, 448, 452, 473, 474, 738, 741, 774, 783, 815, 829, 852, 877, 879, 894, 896, 899, 960, 965, 994, 997, 1000, 1302* , 1315* . done2 : \underline{15}, 167, 169, 448, 458, 459, 473, 478, 774,

784, 815, 896, 1302* , 1316* . done3 : \underline{15}, 815, 897, 898. done4 : \underline{15}, 815, 899. done5 : \underline{15}, 815, 866, 869. done6 : \underline{15}. dont expand : \underline{210}, 258, 357, 369. : 1177. : 1177. double hyphen demerits : \underline{236}, 859* . primitive: \underline{238}. double hyphen demerits code: \underline{236}, 237, 238. : 169. down ptr : \underline{605}, 606, 607, 615. downdate width: \underline{860}. down1 : 585, \underline{586}, 607, 609, 610, 613, 614, 616. down2 : \underline{585}, 594, 610. down3 : \underline{585}, 610. down4 : \underline{585}, 610. primitive: \underline{416}. dry rot: 95.

: 1335. primitive: \underline{1052}. dump core: 1338* . dump four ASCII : \underline{1309*} . dump hh: 1318* . dump int : 1307, 1309* , 1311* , 1313, 1315* , 1316* ,

1318* , 1320* , 1322* , 1324* , 1326. dump qqqq : 1309* . dump things : 1309* , 1311* , 1315* , 1316* , 1318* ,

1322* , 1324* . : 963. dvi buf : 594, \underline{595}, 597* , 598, 607, 613, 614. dvi buf size: \underline{11*} , 14, 594, 595, 596, 598, 599,

607, 613, 614, 642. dvi f : \underline{616}, 617, 620, 621. dvi file: \underline{532}, 592, 595, 597* , 642. files: 583. dvi font def : \underline{602}, 621, 643. dvi four : \underline{600}, 602, 610, 617, 624, 633, 640,

642, 1368. dvi gone: 594, \underline{595}, 596, 598, 612. dvi h: \underline{616}, 617, 619, 620, 623, 624, 628, 629,

632, 637. dvi index : \underline{594}, 595. dvi limit : 594, \underline{595}, 596, 598, 599. dvi offset : 594, \underline{595}, 596, 598, 601, 605, 607, 613,

614, 619, 629, 640, 642. dvi out : \underline{598}, 600, 601, 602, 603, 609, 610, 617,

619, 620, 621, 624, 629, 633, 640, 642, 1368. dvi pop: \underline{601}, 619, 629. dvi ptr : 594, \underline{595}, 596, 598, 599, 601, 607, 619,

629, 640, 642. dvi swap: \underline{598}. dvi v : \underline{616}, 617, 619, 623, 628, 629, 632, 637. dyn used : \underline{117}, 120, 121, 122, 123, 164, 639,

1311* , 1312* . e: \underline{277}, \underline{279}, \underline{518}, \underline{519}, \underline{530}, \underline{1198}, \underline{1211}. easy line: 819, 835, \underline{847}, 848, 850. ec: 540, 541, 543, 545, \underline{560}, 565, 566, 570, 576. primitive: \underline{1208}. edge: \underline{619}, 623, 626, \underline{629}, 635. edit file: \underline{84*} . edit line: 84* , 1333* , \underline{1379*} . edit name length: 84* , 1333* , \underline{1379*} . edit name start : 84* , 1333* , \underline{1379*} , 1380* . eight bits : \underline{25*} , 64, 112* , 297, 549, 560, 581, 582,

595, 607, 649, 706, 709, 712, 977, 992, 993, 1079, 1247, 1288.

eject penalty : \underline{157}, 829, 831, 851, 859* , 873, 970,

972, 974, 1005, 1010, 1011. else: 10. primitive: \underline{491}. else code: \underline{489}, 491, 498. : 455. : 93. emergency stretch: \underline{247}, 828, 863. primitive: \underline{248}. emergency stretch code: \underline{247}, 248. empty : \underline{16*} , 421, 681, 685, 687, 692, 722, 723, 738,

749, 751, 752, 754, 755, 756, 980, 986, 987, 991, 1001, 1008, 1176, 1177, 1186.

empty line at end of file: 486, 538. empty field : \underline{684}, 685, 686, 742, 1163, 1165, 1181. empty flag : \underline{124}, 126, 130, 150, 164, 1312* . end: 7* , 8* , 10. : 37* , 71. : 1335. primitive: \underline{1052}. end cs name: \underline{208}, 265, 266, 372, 1134. primitive: \underline{265}. end diagnostic: \underline{245}, 284, 299, 323, 400, 401, 502,

509, 581, 638, 641, 663, 675, 863, 987, 992, 1006, 1011, 1121, 1298.

end file reading : \underline{329}, 330, 360, 362, 483, 537* . end graf : 1026, 1085, 1094, \underline{1096}, 1100, 1131,

1133, 1168. end group: \underline{208}, 265, 266, 1063. primitive: \underline{265}. primitive: \underline{376}. end line char : 87, \underline{236}, 240, 303, 318, 332, 360,

362, 483, 534* , 538, 1337. primitive: \underline{238}. end line char code: \underline{236}, 237, 238. end line char inactive: \underline{360}, 362, 483, 538, 1337. end match: \underline{207}, 289, 291, 294, 391, 392, 394. end match token: \underline{289}, 389, 391, 392, 393, 394,

474, 476, 482. end name: 512, \underline{517}, 526, 531. end of TEX : \underline{6*} , 81* . end span: \underline{162}, 768, 779, 793, 797, 801, 803. end template: \underline{210}, 366, 375, 380, 780, 1295. end template token: \underline{780}, 784, 790. end token list : \underline{324}, 325, 357, 390, 1026, 1371. end write: \underline{222}, 1369, 1371. : 1369. end write token: \underline{1371}, 1372. endcases: \underline{10}. endif : 7* , 8* . endv : \underline{207}, 298, 375, 380, 768, 780, 782, 791,

1046, 1130. ensure dvi open: \underline{532}, 617. ensure vbox : \underline{993}, 1009, 1018. eof : 26, 31* , 52* , 564* . eoln: 31* , 52* . eop: 583, 585, \underline{586}, 588, 640, 642. eq define: \underline{277}, 278, 279, 372, 782, 1070, 1077,

1214. eq destroy : \underline{275}, 277, 279, 283. eq level : \underline{221}, 222, 228, 232, 236, 253* , 264, 277,

279, 283, 780, 977, 1315* , 1369. eq level field : \underline{221}. eq no: \underline{208}, 1140, 1141, 1143, 1144. primitive: \underline{1141}. eq save: \underline{276}, 277, 278. eq type: 210, \underline{221}, 222, 223, 228, 232, 253* , 258,

264, 265, 267, 277, 279, 351, 353, 354, 357, 358, 372, 389, 391, 780, 1152, 1315* , 1369.

eq type field : \underline{221}, 275. eq word define: \underline{278}, 279, 1070, 1139, 1145, 1214. eqtb: 115, 163, 220, 221, 222, 223, 224, 228, 230,

232, 236, 240, 242, 247, 250, 251, 252, 253* , 255, 262* , 264, 265, 266, 267, 268, 270, 272, 274, 275, 276, 277, 278, 279, 281, 282, 283, 284, 285, 286, 289, 291, 297, 298, 305, 307, 332, 333, 354, 389, 413, 414, 473, 491, 548, 553, 780, 814, 1188, 1208, 1222, 1238, 1240, 1253, 1257, 1315* , 1316* , 1317* , 1339, 1345.

eqtb size: 220, \underline{247}, 250, 252, 253* , 254, 1307,

1308* , 1316* , 1317* . equiv : \underline{221}, 222, 223, 224, 228, 229, 230, 232,

233, 234, 235, 253* , 255, 264, 265, 267, 275, 277, 279, 351, 353, 354, 357, 358, 413, 414, 415, 508, 577, 780, 1152, 1227, 1239, 1240, 1257, 1289, 1315* , 1369.

equiv field : \underline{221}, 275, 285. err help: 79, \underline{230}, 1283, 1284. primitive: \underline{230}. err help loc: \underline{230}. primitive: \underline{1277}. error : 72, 75, 76, 78, 79, \underline{82}, 88, 91, 93, 98, 327,

338, 346, 370, 398, 408, 418, 428, 445, 454, 456, 459, 460, 475, 476, 486, 500, 510, 523, 535, 561, 567, 579, 641, 723, 776, 784, 792, 826, 936, 937, 960, 961, 962, 963, 976, 978, 992, 1004, 1009, 1024, 1027, 1050, 1064, 1066, 1068, 1069, 1080, 1082, 1095, 1099, 1106, 1110, 1120, 1121, 1128, 1129, 1135, 1159, 1166, 1177, 1183, 1192, 1195, 1213, 1225, 1232, 1236, 1237, 1252, 1259, 1283, 1284, 1293, 1372.

error context lines : \underline{236}, 311. primitive: \underline{238}. error context lines code: \underline{236}, 237, 238. error count : \underline{76}, 77, 82, 86, 1096, 1293. error line: \underline{11*} , 14, 54, 58, 306, 311, 315, 316, 317. error message issued : \underline{76}, 82, 95. error stop mode: 72, \underline{73}, 74, 82, 93, 98, 1262,

1283, 1293, 1294, 1297, 1327* , 1335. primitive: \underline{1262}. escape: \underline{207}, 232, 344, 1337. escape char : \underline{236}, 240, 243. primitive: \underline{238}. escape char code: \underline{236}, 237, 238. : 182. : 292. every cr : \underline{230}, 774, 799. primitive: \underline{230}. every cr loc: \underline{230}, 231. every cr text : \underline{307}, 314, 774, 799. every display : \underline{230}, 1145. primitive: \underline{230}. every display loc: \underline{230}, 231. every display text : \underline{307}, 314, 1145. every hbox : \underline{230}, 1083. primitive: \underline{230}. every hbox loc: \underline{230}, 231. every hbox text : \underline{307}, 314, 1083. every job: \underline{230}, 1030. primitive: \underline{230}. every job loc: \underline{230}, 231. every job text : \underline{307}, 314, 1030. every math: \underline{230}, 1139. primitive: \underline{230}. every math loc: \underline{230}, 231. every math text : \underline{307}, 314, 1139. every par : \underline{230}, 1091. primitive: \underline{230}. every par loc: \underline{230}, 231, 307, 1226. every par text : \underline{307}, 314, 1091. every vbox : \underline{230}, 1083, 1167. primitive: \underline{230}. every vbox loc: \underline{230}, 231. every vbox text : \underline{307}, 314, 1083, 1167. : 455. ex hyphen penalty : 145, \underline{236}, 869. primitive: \underline{238}. ex hyphen penalty code: \underline{236}, 237, 238. ex space: \underline{208}, 265, 266, 1030, 1090. exactly : \underline{644}, 645, 715, 889, 977, 1017, 1062, 1201. exit : \underline{15}, 16* , 37* , 47, 58, 59, 60, 69, 82, 125, 182,

292, 341, 389, 407, 461, 497, 498, 524* , 582, 607, 615, 649, 668, 752, 791, 829, 895, 934, 944* , 948* , 977, 994, 1012, 1030, 1054, 1079, 1105, 1110, 1113, 1119, 1151, 1159, 1174, 1211, 1236, 1270, 1303* , 1335, 1338* .

expand : 358, \underline{366}, 368, 371, 380, 381, 439, 467,

478, 498, 510, 782. expand after : \underline{210}, 265, 266, 366, 367. primitive: \underline{265}. explicit : \underline{155}, 1058, 1113. ext bot : \underline{546}, 713, 714. ext delimiter : \underline{513*} , 515, 516* , 517. ext mid : \underline{546}, 713, 714. ext rep: \underline{546}, 713, 714. ext tag : \underline{544}, 569, 708, 710. ext top: \underline{546}, 713, 714. exten: \underline{544}. exten base: \underline{550}, 552, 566, 573, 574, 576, 713,

1322* , 1323* . extensible recipe: 541, \underline{546}. extension: \underline{208}, 1344, 1346, 1347, 1375. extensions to TEX: 2* , 146, 1340. : 510. : 1135. : 510. : 500, 510. : 1192. : 1069. : 792. : 1066. extra info: \underline{769}, 788, 789, 791, 792. extra right brace: 1068, \underline{1069}. extra space: 547, \underline{558}, 1044. extra space code: \underline{547}, 558. eyes and mouth: 332. f: \underline{144}, \underline{448}, \underline{525}, \underline{560}, \underline{577}, \underline{578}, \underline{581}, \underline{582}, \underline{592}, \underline{602},

\underline{649}, \underline{706}, \underline{709}, \underline{711}, \underline{712}, \underline{715}, \underline{716}, \underline{717}, \underline{738}, \underline{830}, \underline{862}, \underline{1068}, \underline{1113}, \underline{1123}, \underline{1138}, \underline{1211}, \underline{1257}.

fabs : 186* . false: 31* , 37* , 45, 46, 47, 51* , 76, 80, 88, 89, 98, 106,

107, 166, 167, 168, 169, 264, 284, 299, 311, 323, 327, 331, 336, 346, 361, 362, 365, 374, 400, 401, 407, 425, 440, 441, 445, 447, 448, 449, 455, 460, 461, 462, 465, 485, 501, 502, 505, 507, 509, 512, 516* , 524* , 526, 528, 538, 551, 563* , 581, 593, 706, 720, 722, 754, 774, 791, 826, 828, 837, 851, 854, 863, 881, 903, 906, 910, 911, 951, 954, 960, 961, 962, 963, 966, 987, 990, 1006, 1011, 1020, 1026, 1031, 1033, 1034, 1035, 1040, 1051, 1054, 1061, 1101, 1167, 1182, 1183, 1191, 1192, 1194, 1199, 1226, 1236, 1258, 1279, 1282, 1283, 1288, 1303* , 1325* , 1336, 1342, 1343, 1352, 1354, 1371, 1374.

false bchar : \underline{1032}, 1034, 1038. fam: \underline{681}, 682, 683, 687, 691, 722, 723, 752, 753,

1151, 1155, 1165. primitive: \underline{238}. fam fnt : \underline{230}, 700, 701, 707, 722, 1195. fam in range: \underline{1151}, 1155, 1165. fast delete glue ref : \underline{201}, 202. fast get avail : \underline{122}, 371, 1034, 1038. fast store new token: \underline{371}, 399, 464, 466.

: 1303* . fatal error : 71, \underline{93}, 324, 360, 484, 530, 535,

782, 789, 791. fatal error stop: \underline{76}, 77, 82, 93, 1332* . fbyte: \underline{564*} , 568, 571, 575* . feof : 575* , 1327* . Ferguson, Michael John: 2* . fetch: \underline{722}, 724, 738, 741, 749, 752, 755. fewest demerits : \underline{872}, 874, 875* . fflush: 34* . fget : \underline{564*} , 565, 568, 571, 575* . primitive: \underline{491}. fi code: \underline{489}, 491, 492, 494, 498, 500, 509, 510. fi or else: \underline{210}, 366, 367, 489, 491, 492, 494, 510. : 454. fil : 135, \underline{150}, 164, 177, 454, 650, 659, 665, 1201. fil code: \underline{1058}, 1059, 1060. fil glue: \underline{162}, 164, 1060. fil neg code: \underline{1058}, 1060. fil neg glue: \underline{162}, 164, 1060. : 338. : 486. file name size: \underline{11*} , 26, 519, 522, 523, 525. file offset : \underline{54}, 55, 57, 58, 62, 537* , 638, 1280. file opened : \underline{560}, 561, 563* . FILENAMESIZE : 11* . fill : 135, \underline{150}, 164, 650, 659, 665, 1201. fill code: \underline{1058}, 1059, 1060. fill glue: \underline{162}, 164, 1054, 1060. filll : 135, \underline{150}, 177, 454, 650, 659, 665, 1201. fin align: 773, 785, \underline{800}, 1131. fin col : 773, \underline{791}, 1131. fin mlist : 1174, \underline{1184}, 1186, 1191, 1194. fin row : 773, \underline{799}, 1131. fin rule: \underline{619}, 622, 626, 629, 631, 635. final cleanup: 1332* , \underline{1335}. final end : \underline{6*} , 35, 331, 1332* , 1337. final hyphen demerits : \underline{236}, 859* . primitive: \underline{238}. final hyphen demerits code: \underline{236}, 237, 238. final pass : \underline{828}, 854, 863, 873. final widow penalty : 814, \underline{815}, 876, \underline{877}, 890. find font dimen: 425, \underline{578}, 1042, 1253. fingers: 511. finite shrink : 825, \underline{826}. fire up: 1005, \underline{1012}. firm up the line: 340, 362, \underline{363}, 538. first : \underline{30}, 31* , 35, 36, 37* , 71, 83, 87, 88, 328, 329,

331, 355, 360, 362, 363, 374, 483, 531, 538. first child : \underline{960}, 963, 964. first count : \underline{54}, 315, 316, 317. first fit : \underline{953}, 957, 966. first indent : \underline{847}, 849, 889. first mark : \underline{382}, 383, 1012, 1016. primitive: \underline{384}. first mark code: \underline{382}, 384, 385. first text char : \underline{19*} , 24. first width: \underline{847}, 849, 850, 889. fit class : \underline{830}, 836, 845, 846, 852, 853, 855, 859* . fitness : \underline{819}, 845, 859* , 864. fix date and time: \underline{241*} , 1332* , 1337. fix language: 1034, \underline{1376}. fix word : \underline{541}, 542, 547, 548, 571. float : \underline{109*} , 114, 186* , 625, 634, 809. float constant : \underline{109*} , 186* , 1123, 1125. float cost : \underline{140}, 188, 1008, 1100. floating penalty : 140, \underline{236}, 1068, 1100. primitive: \underline{238}. floating penalty code: \underline{236}, 237, 238. flush: 34* . flush char : \underline{42}, 180, 195, 692, 695. flush list : \underline{123}, 200, 324, 372, 396, 407, 801, 903,

960, 1279, 1297, 1370. flush math: \underline{718}, 776, 1195. flush node list : 199, \underline{202}, 275, 639, 698, 718, 731,

732, 742, 800, 816, 879, 883, 903, 918, 968, 992, 999, 1078, 1105, 1120, 1121, 1375.

flush string : \underline{44}, 264, 1279, 1328* . fmem ptr : 425, \underline{549}, 552, 566, 569, 570, 576, 578,

579, 580, 1320* , 1321* , 1322* , 1323* , 1334. fmt file: 524* , \underline{1305*} , 1327* , 1328* , 1329, 1337. fnt def1 : 585, \underline{586}, 602. fnt def2 : \underline{585}. fnt def3 : \underline{585}. fnt def4 : \underline{585}. fnt num 0 : 585, \underline{586}, 621. fnt1 : 585, \underline{586}, 621. fnt2 : \underline{585}. fnt3 : \underline{585}. fnt4 : \underline{585}. font : \underline{134}, 143, 144, 174* , 176* , 193, 206, 267, 548,

582, 620, 654, 681, 709, 715, 724, 841, 842, 866, 867, 870, 871, 896, 897, 898, 903, 908, 911, 1034, 1038, 1113, 1147.

font metric files: 539. font parameters: 700, 701. : 579. : 561. : 567. primitive: \underline{265}. font area: \underline{549}, 552, 576, 602, 603, 1260, 1322* ,

1323* . font base: 11* , \underline{12*} , 111, 134, 222, 232, 548, 551,

602, 621, 643, 1260, 1320* , 1323* , 1334.

font bc: \underline{549}, 552, 576, 582, 708, 722, 1036,

1322* , 1323* . font bchar : \underline{549}, 552, 576, 903, 915, 1032, 1034,

1322* , 1323* . font check : \underline{549}, 568, 602, 1322* , 1323* .

primitive: \underline{265}.

font dsize: 472, \underline{549}, 552, 568, 602, 1260, 1261,

1322* , 1323* . font ec: \underline{549}, 552, 576, 582, 708, 722, 1036,

1322* , 1323* . font false bchar : \underline{549}, 552, 576, 1034, 1322* , 1323* . font glue: \underline{549}, 552, 576, 578, 1042, 1322* , 1323* .

font id base: \underline{222}, 234, 256, 415, 548, 1257.
font id text : \underline{256}, 267, 579, 1257, 1322* .

font in short display : \underline{173}, 174* , 193, 663, 864,

1339. font index : \underline{548}, 549, 560, 906, 1032, 1211. font info: 11* , 425, 548, \underline{549}, 550, 552, 554, 557, 558, 560, 566, 569, 571, 573, 574, 575* , 578, 580, 700, 701, 713, 741, 752, 909, 1032, 1039, 1042, 1211, 1253, 1322* , 1323* , 1339. font max : \underline{11*} , 111, 174* , 176* , 548, 551, 566,

1323* , 1334. font mem size: \underline{11*} , 548, 549, 566, 580, 1321* , 1334. font name: 472, \underline{549}, 552, 576, 581, 602, 603,

1260, 1261, 1322* , 1323* . primitive: \underline{468}.

font name code: \underline{468}, 469, 471, 472.

font params : \underline{549}, 552, 576, 578, 579, 580, 1195,

1322* , 1323* . font ptr : \underline{549}, 552, 566, 576, 578, 643, 1260,

1320* , 1322* , 1323* , 1334. font size: 472, \underline{549}, 552, 568, 602, 1260, 1261,

1322* , 1323* . font used : \underline{549}, 551, 621, 643. : 1257. : 191. : 338. force eof : 331, \underline{361}, 362, 378. format area length: \underline{520*} . format default length: \underline{520*} , 522, 523, 524* . format ext length: \underline{520*} , 523, 524* . format extension: \underline{520*} , 529, 1328* . format ident : 35, 61* , 536* , \underline{1299}, 1300, 1301, 1326,

1327* , 1328* , 1337. forward : 78, 218, 281, 340, 366, 409, 618, 692,

693, 720, 774, 800. found : \underline{15}, 125, 128, 129, 259, 341, 354, 356,

389, 392, 394, 448, 455, 473, 475, 477, 524* , 607, 609, 612, 613, 614, 645, 706, 708, 720, 895, 923, 931, 934, 941, 953, 955, 1138, 1146, 1147, 1148, 1236, 1237. found1 : \underline{15}, 895, 902, 1302* , 1315* . found2 : \underline{15}, 895, 903, 1302* , 1316* . four choices : \underline{113*} . four quarters : 548, 549, 554, 555, 560, 649,

683, 684, 706, 709, 712, 724, 738, 749, 906, 1032, 1123.

fraction noad : \underline{683}, 687, 690, 698, 733, 761,

1178, 1181. fraction noad size: \underline{683}, 698, 761, 1181. fraction rule: \underline{704}, 705, 735, 747. free: \underline{165*} , 167, 168, 169, 170, 171. free arr : 165* . free avail : \underline{121}, 202, 204, 217, 400, 452, 772,

915, 1036, 1226, 1288. free node: \underline{130}, 201, 202, 275, 496, 615, 655, 698,

715, 721, 727, 751, 753, 756, 760, 772, 803, 860, 861, 865, 903, 910, 977, 1019, 1021, 1022, 1037, 1100, 1110, 1186, 1187, 1201, 1358.

freeze page specs : \underline{987}, 1001, 1008. frozen control sequence: \underline{222}, 258, 1215, 1314,

1318* , 1319* . frozen cr : \underline{222}, 339, 780, 1132. frozen dont expand : \underline{222}, 258, 369. frozen end group: \underline{222}, 265, 1065. frozen end template: \underline{222}, 375, 780. frozen endv : \underline{222}, 375, 380, 780. frozen fi : \underline{222}, 336, 491. frozen null font : \underline{222}, 553. frozen protection: \underline{222}, 1215, 1216. frozen relax : \underline{222}, 265, 379. frozen right : \underline{222}, 1065, 1188. Fuchs, David Raymond: 2* , 583, 591. primitive: \underline{1219}. fwrite: 597* . g: \underline{47}, \underline{182}, \underline{560}, \underline{592}, \underline{649}, \underline{668}, \underline{706}, \underline{716}. g order : \underline{619}, 625, \underline{629}, 634. g sign: \underline{619}, 625, \underline{629}, 634. garbage: \underline{162}, 467, 470, 960, 1183, 1192, 1279. primitive: \underline{1208}. geq define: \underline{279}, 782, 1077, 1214. geq word define: \underline{279}, 288, 1013, 1214. get : 26, 29, 31* , 485, 538, 564* . get avail : \underline{120}, 122, 204, 205, 216, 325, 337, 339,

369, 371, 372, 452, 473, 482, 582, 709, 772, 783, 784, 794, 908, 911, 938, 1035, 1064, 1065, 1226, 1371.

get date and time: 241* . get next : 76, 297, 332, 336, 340, \underline{341}, 357, 360,

364, 365, 366, 369, 380, 381, 387, 389, 478, 494, 507, 644, 1038, 1126.

get node: \underline{125}, 131, 136, 139, 144, 145, 147, 151, 152, 153, 156, 158, 206, 495, 607, 649, 668, 686, 688, 689, 716, 772, 798, 843, 844, 845, 864, 914, 1009, 1100, 1101, 1163, 1165, 1181, 1248, 1249, 1349, 1357. get preamble token: \underline{782}, 783, 784. get r token: \underline{1215}, 1218, 1221, 1224, 1225, 1257.

get strings started : \underline{47}, 51* , 1332* .

get token: 76, 78, 88, 364, \underline{365}, 368, 369, 392, 399, 442, 452, 471, 473, 474, 476, 477, 479, 483, 782, 1027, 1138, 1215, 1221, 1252, 1268, 1271, 1294, 1371, 1372.

get x token: 364, 366, 372, \underline{380}, 381, 402, 404, 406, 407, 443, 444, 445, 452, 465, 479, 506, 526, 780, 935, 961, 1029, 1030, 1138, 1197, 1237, 1375.

get x token or active char : \underline{506}.

getc: 564* .

give err help: 78, 89, 90, \underline{1284}.

global : \underline{1214}, 1218, 1241.

global definitions: 221, 279, 283.

primitive: \underline{1208}.

global defs : \underline{236}, 782, 1214, 1218. primitive: \underline{238}. global defs code: \underline{236}, 237, 238. glue base: 220, \underline{222}, 224, 226, 227, 228, 229,

252, 782. glue node: \underline{149}, 152, 153, 175, 183, 202, 206, 424, 622, 631, 651, 669, 730, 732, 761, 816, 817, 837, 856, 862, 866, 879, 881, 899, 903, 968, 972, 973, 988, 996, 997, 1000, 1106, 1107, 1108, 1147, 1202. glue offset : \underline{135}, 159, 186* . glue ord : \underline{150}, 447, 619, 629, 646, 649, 668, 791. glue order : \underline{135}, 136, 159, 185, 186* , 619, 629,

657, 658, 664, 672, 673, 676, 769, 796, 801, 807, 809, 810, 811, 1148.

glue par : \underline{224}, 766.

glue pars : \underline{224}.

glue ptr : \underline{149}, 152, 153, 175, 189, 190, 202, 206, 424, 625, 634, 656, 671, 679, 732, 786, 793, 795, 802, 803, 809, 816, 838, 868, 881, 969, 976, 996, 1001, 1004, 1148. glue ratio: 109* , 110* , 135, 186* . glue ref : \underline{210}, 228, 275, 782, 1228, 1236. glue ref count : \underline{150}, 151, 152, 153, 154, 164, 201,

203, 228, 766, 1043, 1060. glue set : \underline{135}, 136, 159, 186* , 625, 634, 657, 658, 664, 672, 673, 676, 807, 809, 810, 811, 1148.

glue shrink : \underline{159}, 185, 796, 799, 801, 810, 811. glue sign: \underline{135}, 136, 159, 185, 186* , 619, 629, 657, 658, 664, 672, 673, 676, 769, 796, 801, 807, 809, 810, 811, 1148.

glue spec size: \underline{150}, 151, 162, 164, 201, 716. glue stretch: \underline{159}, 185, 796, 799, 801, 810, 811. glue val : \underline{410}, 411, 412, 413, 416, 417, 424, 427,

429, 430, 451, 461, 465, 782, 1060, 1228, 1236, 1237, 1238, 1240.

: 986, 987. goto: \underline{35}, \underline{81*} . gr : 110* , 114, 135. group code: \underline{269}, 271, 274, 645, 1136. gubed: \underline{7*} . Guibas, Leonidas Ioannis: 2* . g1 : \underline{1198}, 1203. g2 : \underline{1198}, 1203, 1205. h: \underline{204}, \underline{259}, \underline{649}, \underline{668}, \underline{738}, \underline{929}, \underline{934}, \underline{944*} , \underline{948*} , \underline{953},

\underline{966}, \underline{970}, \underline{977}, \underline{994}, \underline{1086}, \underline{1091}, \underline{1123}. h offset : \underline{247}, 617, 641. primitive: \underline{248}. h offset code: \underline{247}, 248. ha: \underline{892}, 896, 900, 903, 912. half : \underline{100}, 706, 736, 737, 738, 745, 746, 749,

750, 1202. half buf : 594, \underline{595}, 596, 598, 599. half error line: \underline{11*} , 14, 311, 315, 316, 317. halfword : 108, 110* , \underline{113*} , 115, 130, 264, 277, 279,

280, 281, 297, 298, 300, 333, 341, 366, 389, 413, 464, 473, 549, 560, 577, 681, 791, 800, 821, 829, 830, 833, 847, 872, 877, 901, 906, 907, 1032, 1079, 1211, 1243, 1266, 1288.

halign: \underline{208}, 265, 266, 1094, 1130. primitive: \underline{265}. handle right brace: 1067, \underline{1068}. hang after : \underline{236}, 240, 847, 849, 1070, 1149. primitive: \underline{238}. hang after code: \underline{236}, 237, 238, 1070. hang indent : \underline{247}, 847, 848, 849, 1070, 1149. primitive: \underline{248}. hang indent code: \underline{247}, 248, 1070. hanging indentation: 847. hash: 234, \underline{256}, 257, 259, 260, 1318* , 1319* . hash base: 220, \underline{222}, 256, 257, 259, 262* , 263,

1257, 1314, 1318* , 1319* . hash brace: \underline{473}, 476. hash is full : \underline{256}, 260. hash prime: \underline{12*} , 14, 259, 261, 1307, 1308* . hash size: \underline{12*} , 14, 222, 260, 261, 1334. hash used : \underline{256}, 258, 260, 1318* , 1319* . hb: \underline{892}, 897, 898, 900, 903. hbadness : \underline{236}, 660, 666, 667. primitive: \underline{238}. hbadness code: \underline{236}, 237, 238. primitive: \underline{1071}. hbox group: \underline{269}, 274, 1083, 1085. hc: \underline{892}, 893, 897, 898, 900, 901, 919, 920, 923,

930, 931, 934, 937, 939, 960, 962, 963, 965.

hchar : 905, \underline{906}, 908, 909.
hd : \underline{649}, 654, \underline{706}, 708, \underline{709}, \underline{712}.
head : 212, \underline{213}, 215, 216, 217, 424, 718, 776, 796,

799, 805, 812, 814, 816, 1026, 1054, 1080, 1081, 1086, 1091, 1096, 1100, 1105, 1113, 1119, 1121, 1145, 1159, 1168, 1176, 1181, 1184, 1185, 1187, 1191.

head field : \underline{212}, 213, 218. head for vmode: 1094, \underline{1095}. header : 542. Hedrick, Charles Locke: 3. height : \underline{135}, 136, 138, 139, 140, 184, 187, 188, 463, 554, 622, 624, 626, 629, 631, 632, 635, 637, 640, 641, 649, 653, 656, 670, 672, 679, 704, 706, 709, 711, 713, 727, 730, 735, 736, 737, 738, 739, 742, 745, 746, 747, 749, 750, 751, 756, 757, 759, 768, 769, 796, 801, 804, 806, 807, 809, 810, 811, 969, 973, \underline{981}, 986, 1001, 1002, 1008, 1009, 1010, 1021, 1087, 1100.

: 463.

height base: \underline{550}, 552, 554, 566, 571, 1322* , 1323* . height depth: \underline{554}, 654, 708, 709, 712, 1125. height index : \underline{543}, 554. height offset : \underline{135}, 416, 417, 769, 1247. height plus depth: \underline{712}, 714. : 986. help line: \underline{79}, 89, 90, 336, 1106. help ptr : \underline{79}, 80, 89, 90. help0 : \underline{79}, 1252, 1293. help1 : \underline{79}, 93, 95, 288, 408, 428, 454, 476, 486,

500, 503, 510, 960, 961, 962, 963, 1066, 1080, 1099, 1121, 1132, 1135, 1159, 1177, 1192, 1212, 1213, 1232, 1237, 1243, 1244, 1258, 1283, 1304.

help2 : 72, \underline{79}, 88, 89, 94, 95, 288, 346, 373, 433, 434, 435, 436, 437, 442, 445, 460, 475, 476, 577, 579, 641, 936, 937, 978, 1015, 1027, 1047, 1068, 1080, 1082, 1095, 1106, 1120, 1129, 1166, 1197, 1207, 1225, 1236, 1259, 1372. help3 : 72, \underline{79}, 98, 336, 396, 415, 446, 479, 776, 783, 784, 792, 993, 1009, 1024, 1028, 1078, 1084, 1110, 1127, 1183, 1195, 1293. help4 : \underline{79}, 89, 338, 398, 403, 418, 456, 567, 723,

976, 1004, 1050, 1283. help5 : \underline{79}, 370, 561, 826, 1064, 1069, 1128,

1215, 1293. help6 : \underline{79}, 395, 459, 1128, 1161. : 1334. hex to cur chr : \underline{352}, 355. hex token: \underline{438}, 444. hf : \underline{892}, 896, 897, 898, 903, 908, 909, 910,

911, 915, 916. primitive: \underline{1058}. primitive: \underline{1058}. primitive: \underline{1058}. hfuzz : \underline{247}, 666. primitive: \underline{248}. hfuzz code: \underline{247}, 248. hh: 110* , 114, 118, 133, 182, 213, 219, 221, 268,

686, 742, 1163, 1165, 1181, 1186. hi : \underline{112*} , 232, 1232. hi mem min: \underline{116*} , 118, 120, 125, 126, 134, 164,

165* , 167, 168, 171, 172, 176* , 293, 639, 1311* , 1312* , 1334.

hi mem stat min: \underline{162}, 164, 1312* . hi mem stat usage: \underline{162}, 164. history : \underline{76}, 77, 81* , 82, 93, 95, 245, 1332* , 1335. hlist node: \underline{135}, 136, 137, 138, 148, 159, 175, 183,

184, 202, 206, 505, 618, 619, 622, 631, 644, 649, 651, 669, 681, 807, 810, 814, 841, 842, 866, 870, 871, 968, 973, 993, 1000, 1074, 1080, 1087, 1110, 1147, 1203.

hlist out : 592, 615, 616, 618, \underline{619}, 620, 623, 628,

629, 632, 637, 638, 640, 693, 1373. hlp1 : \underline{79}. hlp2 : \underline{79}. hlp3 : \underline{79}. hlp4 : \underline{79}. hlp5 : \underline{79}. hlp6 : \underline{79}. hmode: \underline{211}, 218, 416, 501, 786, 787, 796, 799,

1030, 1045, 1046, 1048, 1056, 1057, 1071, 1073, 1076, 1079, 1083, 1086, 1091, 1092, 1093, 1094, 1096, 1097, 1109, 1110, 1112, 1116, 1117, 1119, 1122, 1130, 1137, 1200, 1243, 1377.

hmove: \underline{208}, 1048, 1071, 1072, 1073. hn: \underline{892}, 897, 898, 899, 902, 912, 913, 915, 916,

917, 919, 923, 930, 931. ho: \underline{112*} , 235, 414, 1151, 1154. hold head : \underline{162}, 306, 779, 783, 784, 794, 808, 905,

906, 913, 914, 915, 916, 917, 1014, 1017. holding inserts : \underline{236}, 1014. primitive: \underline{238}. holding inserts code: \underline{236}, 237, 238. hpack : 162, 236, 644, 645, 646, 647, \underline{649}, 661,

709, 715, 720, 727, 737, 748, 754, 756, 796, 799, 804, 806, 889, 1062, 1086, 1125, 1194, 1199, 1201, 1204.

hrule: \underline{208}, 265, 266, 463, 1046, 1056, 1084,

1094, 1095. primitive: \underline{265}. hsize: \underline{247}, 847, 848, 849, 1054, 1149. primitive: \underline{248}. hsize code: \underline{247}, 248. hskip: \underline{208}, 1057, 1058, 1059, 1078, 1090. primitive: \underline{1058}. primitive: \underline{1058}. primitive: \underline{416}. hu: \underline{892}, 893, 897, 898, 901, 903, 905, 907, 908,

910, 911, 912, 915, 916. : 641. hyf : \underline{900}, 902, 905, 908, 909, 913, 914, 919, 920,

923, 924, 932, 960, 961, 962, 963, 965. hyf char : \underline{892}, 896, 913, 915. hyf distance: 920, \underline{921}, 922, 924, 943* , 944* , 945,

1324* , 1325* . hyf next : 920, \underline{921}, 924, 943* , 944* , 945, 1324* , 1325* . hyf node: \underline{912}, 915. hyf num: 920, \underline{921}, 924, 943* , 944* , 945, 1324* , 1325* . hyph count : \underline{926}, 928, 940, 1324* , 1325* , 1334. hyph data: \underline{209}, 1210, 1250, 1251, 1252. hyph list : \underline{926}, 928, 929, 932, 933, 934, 940,

941, 1324* , 1325* . hyph pointer : \underline{925}, 926, 927, 929, 934. hyph size: \underline{12*} , 925, 928, 930, 933, 939, 940, 1307,

1308* , 1324* , 1325* , 1334. hyph word : \underline{926}, 928, 929, 931, 934, 940, 941,

1324* , 1325* . hyphen char : 426, \underline{549}, 552, 576, 891, 896, 1035,

1117, 1253, 1322* , 1323* . primitive: \underline{1254}. hyphen passed : \underline{905}, 906, 909, 913, 914. hyphen penalty : 145, \underline{236}, 869. primitive: \underline{238}. hyphen penalty code: \underline{236}, 237, 238. hyphenate: 894, \underline{895}. hyphenated : \underline{819}, 820, 829, 846, 859* , 869, 873. : 1324* . primitive: \underline{1250}. i: \underline{19*} , \underline{315}, \underline{587}, \underline{649}, \underline{738}, \underline{749}, \underline{901}, \underline{1123}, \underline{1348}. : 524* . : 530. : 95. : 51* . : 530. id byte: \underline{587}, 617, 642. id lookup: \underline{259}, 264, 356, 374. ident val : \underline{410}, 415, 465, 466. primitive: \underline{487}. if case code: \underline{487}, 488, 501. if cat code: \underline{487}, 488, 501. primitive: \underline{487}. primitive: \underline{487}. if char code: \underline{487}, 501, 506. if code: \underline{489}, 495, 510. primitive: \underline{487}. if dim code: \underline{487}, 488, 501. primitive: \underline{487}. if eof code: \underline{487}, 488, 501. primitive: \underline{487}. if false code: \underline{487}, 488, 501. primitive: \underline{487}. if hbox code: \underline{487}, 488, 501, 505. primitive: \underline{487}. if hmode code: \underline{487}, 488, 501. primitive: \underline{487}. if inner code: \underline{487}, 488, 501. primitive: \underline{487}. if int code: \underline{487}, 488, 501, 503. if limit : \underline{489}, 490, 495, 496, 497, 498, 510. if line: \underline{489}, 490, 495, 496, 1335. if line field : \underline{489}, 495, 496, 1335. primitive: \underline{487}. if mmode code: \underline{487}, 488, 501. if node size: \underline{489}, 495, 496. primitive: \underline{487}. if odd code: \underline{487}, 488, 501. if test : \underline{210}, 336, 366, 367, 487, 488, 494, 498,

503, 1335. primitive: \underline{487}. if true code: \underline{487}, 488, 501. primitive: \underline{487}. if vbox code: \underline{487}, 488, 501. primitive: \underline{487}. if vmode code: \underline{487}, 488, 501. primitive: \underline{487}. if void code: \underline{487}, 488, 501, 505. ifdef : 7* , 8* . primitive: \underline{487}. ifx code: \underline{487}, 488, 501. ignore: \underline{207}, 232, 332, 345. ignore depth: \underline{212}, 215, 219, 679, 787, 1025, 1056,

1083, 1099, 1167. ignore spaces : \underline{208}, 265, 266, 1045. primitive: \underline{265}. : 288, 1258. : 1120. : 479. : 454, 456, 459. primitive: \underline{1344}. immediate code: \underline{1344}, 1346, 1348. : 262* . : 776. : 936. : 418. : 418. : 1259. : 442.

: 458.

in open: \underline{304}, 328, 329, 331. in state record : \underline{300}, 301. in stream: \underline{208}, 1272, 1273, 1274. : 408. : 1110. : 288. incompleat noad : 212, \underline{213}, 718, 776, 1136, 1178,

1181, 1182, 1184, 1185. : 336. incr : 37* , 42, 43, 45, 46, 53* , 58, 59, 60, 65, 67, 70, 71, 82, 90, 98, 120, 122, 152, 153, 170, 182, 203, 216, 260, 274, 276, 280, 294, 311, 312, 321, 325, 328, 343, 347, 352, 354, 355, 356, 357, 360, 362, 374, 392, 395, 397, 399, 400, 403, 407, 442, 452, 454, 464, 475, 476, 477, 494, 517, 519, 524* , 531, 537* , 580, 598, 619, 629, 640, 642, 645, 714, 798, 842, 845, 877, 897, 898, 910, 911, 914, 915, 923, 930, 931, 937, 939, 940, 941, 944* , 954, 956, 962, 963, 964, 986, 1022, 1025, 1035, 1039, 1069, 1099, 1117, 1119, 1121, 1127, 1142, 1153, 1172, 1174, 1315* , 1316* , 1318* , 1337.

primitive: \underline{1088}.

indent in hmode: 1092, \underline{1093}.
indented : \underline{1091}.
index : 300, \underline{302}, 303, 304, 307, 328, 329, 331.
index field : \underline{300}, 302.
inf : 447, \underline{448}, 453.

inf bad : \underline{108}, 157, 851, 852, 853, 856, 863, 974,

1005, 1017. inf penalty : \underline{157}, 761, 767, 816, 829, 831, 974,

1005, 1013, 1203, 1205. : 826, 976, 1004,

1009. infinity : \underline{445}. info: \underline{118}, 124, 126, 140, 164, 172, 200, 233, 275,

291, 293, 325, 337, 339, 357, 358, 369, 371, 374, 389, 391, 392, 393, 394, 397, 400, 423, 452, 466, 508, 605, 608, 609, 610, 611, 612, 613, 614, 615, 681, 689, 692, 693, 698, 720, 734, 735, 736, 737, 738, 742, 749, 754, 768, 769, 772, 779, 783, 784, 790, 793, 794, 797, 798, 801, 803, 821, 847, 848, 925, 932, 938, 981, 1065, 1076, 1093, 1149, 1151, 1168, 1181, 1185, 1186, 1191, 1226, 1248, 1249, 1289, 1312* , 1339, 1341, 1371. init: \underline{8*} , \underline{47}, \underline{50}, \underline{131}, \underline{264}, \underline{891}, \underline{942}, \underline{943*} , \underline{947}, \underline{950},

\underline{1252}, \underline{1302*} , \underline{1325*} , \underline{1332*} , \underline{1335}, \underline{1336}.

init align: 773, \underline{774}, 1130.
init col : 773, 785, \underline{788}, 791.
init lft : \underline{900}, 903, 905, 908.
init lig : \underline{900}, 903, 905, 908.
init list : \underline{900}, 903, 905, 908.

init math: 1137, \underline{1138}. init pool ptr : \underline{39}, 42, 1310* , 1332* , 1334. init prim: 1332* , \underline{1336}. init row : 773, 785, \underline{786}. init span: 773, 786, \underline{787}, 791. init str ptr : \underline{39}, 43, 517, 1310* , 1332* , 1334. init terminal : \underline{37*} , 331. init trie: 891, \underline{966}, 1324* . : 8* , 11* , 12* , 47, 50, 116* , 1299, 1331. initialize: \underline{4*} , 1332* , 1337. inner loop: 31* , 112* , 120, 121, 122, 123, 125, 127* ,

128, 130, 202, 324, 325, 341, 342, 343, 357, 365, 380, 399, 407, 554, 597* , 611, 620, 651, 654, 832, 835, 851, 852, 867.

inner noad : \underline{682}, 683, 690, 696, 698, 733, 761,

764, 1156, 1157, 1191. input : \underline{210}, 366, 367, 376, 377. primitive: \underline{376}. input file: \underline{304}. primitive: \underline{416}. input line no code: \underline{416}, 417, 424. input ln: 30, 31* , 37* , 58, 71, 362, 485, 486, 538. input ptr : \underline{301}, 311, 312, 321, 322, 330, 331,

360, 534* . input stack : 84* , \underline{301}, 311, 321, 322, 534* . ins disc: \underline{1032}, 1033, 1035. ins error : \underline{327}, 336, 395, 1047, 1127, 1132, 1215. ins list : \underline{323}, 339, 467, 470, 1064, 1371. ins node: \underline{140}, 148, 175, 183, 202, 206, 647,

651, 730, 761, 866, 899, 968, 973, 981, 986, 1000, 1014, 1100.

ins node size: \underline{140}, 202, 206, 1022, 1100. ins ptr : \underline{140}, 188, 202, 206, 1010, 1020, 1021, 1100. ins the toks : 366, 367, \underline{467}. insert : \underline{208}, 265, 266, 1097. : 87. primitive: \underline{265}. insert dollar sign: 1045, \underline{1047}. insert group: \underline{269}, 1068, 1099, 1100. insert penalties : 419, \underline{982}, 990, 1005, 1008, 1010,

1014, 1022, 1026, 1242, 1246. primitive: \underline{416}. insert relax : 378, \underline{379}, 510. insert token: \underline{268}, 280, 282. inserted : \underline{307}, 314, 323, 324, 327, 379, 1095. inserting : \underline{981}, 1009. : 993. inserts only : \underline{980}, 987, 1008. int : 110* , 113* , 114, 140, 141, 157, 186* , 213, 219,

236, 240, 242, 274, 278, 279, 413, 414, 489, 605, 725, 769, 772, 819, 1238, 1240, 1316* .

int base: 220, \underline{230}, 232, 236, 238, 239, 240, 242,

252, 253* , 254, 268, 283, 288, 1013, 1070, 1139, 1145, 1315* .

int error : \underline{91}, 288, 433, 434, 435, 436, 437, 1243,

1244, 1258. int par : \underline{236}.

int pars : \underline{236}.

int val : \underline{410}, 411, 412, 413, 414, 416, 417, 418, 419, 422, 423, 424, 426, 427, 428, 429, 439, 440, 449, 461, 465, 1236, 1237, 1238, 1240. integer : 3, 13, 19* , 45, 47, 54, 59, 60, 63, 65, 66, 67, 69, 82, 91, 94, 96, 100, 101, 102, 105, 106, 107, 108, 109* , 110* , 113* , 117, 125, 158, 163, 172, 173, 174* , 176* , 177, 178, 181, 182, 211, 212, 218, 225, 237, 247, 256, 259, 262* , 278, 279, 286, 292, 304, 308, 309, 311, 315, 366, 410, 440, 448, 450, 482, 489, 493, 494, 498, 518, 519, 520* , 523, 549, 550, 560, 578, 592, 595, 600, 601, 607, 615, 616, 619, 629, 638, 645, 646, 661, 691, 694, 699, 706, 716, 717, 726, 738, 752, 764, 815, 828, 829, 830, 833, 872, 877, 892, 912, 922, 966, 970, 980, 982, 994, 1012, 1030, 1032, 1068, 1075, 1079, 1084, 1091, 1117, 1119, 1138, 1151, 1155, 1194, 1211, 1302* , 1303* , 1331, 1333* , 1338* , 1348, 1370, 1379* .

inter line penalty : \underline{236}, 890.

primitive: \underline{238}.
inter line penalty code: \underline{236}, 237, 238.

interaction: 71, 72, \underline{73}, 74, 75, 82, 84* , 86, 90, 92, 93, 98, 360, 363, 484, 530, 1265, 1283, 1293, 1294, 1297, 1326, 1327* , 1328* , 1333* , 1335. internal font number : \underline{548}, 549, 550, 560, 577, 578, 581, 582, 602, 616, 649, 706, 709, 711, 712, 715, 724, 738, 830, 862, 892, 1032, 1113, 1123, 1138, 1211, 1257. interrupt : \underline{96}, 97, 98, 1031. : 98. : 324,

782, 789, 791. : 1232. invalid char : \underline{207}, 232, 344. invalid code: \underline{22}, 24, 232. is char node: \underline{134}, 174* , 183, 202, 205, 424, 620, 630, 651, 669, 715, 720, 721, 756, 805, 816, 837, 841, 842, 866, 867, 868, 870, 871, 879, 883, 896, 897, 899, 903, 1036, 1040, 1080, 1081, 1105, 1113, 1121, 1147, 1202.

is empty : \underline{124}, 127* , 169, 170.

is hex : \underline{352}, 355.
is running : \underline{138}, 176* , 624, 633, 806.
issue message: 1276, \underline{1279}.
ital corr : \underline{208}, 265, 266, 1111, 1112.
italic correction: \underline{543}.

italic base: \underline{550}, 552, 554, 566, 571, 1322* , 1323* . italic index : \underline{543}. its all over : 1045, \underline{1054}, 1335. j: \underline{45}, \underline{46}, \underline{59}, \underline{60}, \underline{69}, \underline{70}, \underline{259}, \underline{264}, \underline{315}, \underline{366}, \underline{519},

\underline{523}, \underline{524*} , \underline{638}, \underline{893}, \underline{901}, \underline{906}, \underline{934}, \underline{966}, \underline{1211}, \underline{1302*} , \underline{1303*} , \underline{1348}, \underline{1370}, \underline{1373}.

Japanese characters: 134, 585. Jensen, Kathleen: 10. : 360. : 530. job name: 92, 471, 472, \underline{527}, 528, 529, 532, 534* ,

537* , 1257, 1328* , 1335. primitive: \underline{468}. job name code: \underline{468}, 470, 471, 472. jump out : \underline{81*} , 82, 84* , 93. just box : \underline{814}, 888, 889, 1146, 1148. just open: \underline{480}, 483, 1275* . k: \underline{45}, \underline{46}, \underline{47}, \underline{64}, \underline{65}, \underline{67}, \underline{69}, \underline{71}, \underline{102}, \underline{163}, \underline{259},

\underline{264}, \underline{341}, \underline{363}, \underline{407}, \underline{450}, \underline{464}, \underline{519}, \underline{523}, \underline{525}, \underline{530}, \underline{534*} , \underline{560}, \underline{587}, \underline{602}, \underline{607}, \underline{638}, \underline{705}, \underline{906}, \underline{929}, \underline{934}, \underline{960}, \underline{966}, \underline{1079}, \underline{1211}, \underline{1302*} , \underline{1303*} , \underline{1333*} , \underline{1338*} , \underline{1348}, \underline{1368}.

kern: \underline{208}, 545, 1057, 1058, 1059. primitive: \underline{1058}. kern base: \underline{550}, 552, 557, 566, 573, 576, 1322* , 1323* . kern base offset : \underline{557}, 566, 573. kern break : \underline{866}. kern flag : \underline{545}, 741, 753, 909, 1040. kern node: \underline{155}, 156, 183, 202, 206, 424, 622, 631,

651, 669, 721, 730, 732, 761, 837, 841, 842, 856, 866, 870, 871, 879, 881, 896, 897, 899, 968, 972, 973, 976, 996, 997, 1000, 1004, 1106, 1107, 1108, 1121, 1147.

kk : \underline{450}, 452. Knuth, Donald Ervin: 2* , 86, 693, 813, 891, 925,

997, 1154, 1371. l: \underline{47}, \underline{259}, \underline{264}, \underline{276}, \underline{281}, \underline{292}, \underline{315}, \underline{494}, \underline{497}, \underline{534*} ,

\underline{601}, \underline{615}, \underline{668}, \underline{830}, \underline{901}, \underline{944*} , \underline{953}, \underline{960}, \underline{1138}, \underline{1194}, \underline{1236}, \underline{1302*} , \underline{1338*} , \underline{1376}.

l hyf : 891, \underline{892}, 894, 899, 902, 923, 1362. language: \underline{236}, 934, 1034, 1376. primitive: \underline{238}. language code: \underline{236}, 237, 238. language node: \underline{1341}, 1356, 1357, 1358, 1362,

1373, 1376, 1377. large attempt : \underline{706}. large char : \underline{683}, 691, 697, 706, 1160. large fam: \underline{683}, 691, 697, 706, 1160. last : \underline{30}, 31* , 35, 36, 37* , 71, 83, 87, 88, 331, 360,

363, 483, 524* , 531. last active: \underline{819}, 820, 832, 835, 844, 854, 860, 861,

863, 864, 865, 873, 874, 875* . last badness : 424, \underline{646}, 648, 649, 660, 664, 667,

668, 674, 676, 678. last bop: \underline{592}, 593, 640, 642. primitive: \underline{1071}. last box code: \underline{1071}, 1072, 1079. last glue: 424, \underline{982}, 991, 996, 1017, 1106. last ins ptr : \underline{981}, 1005, 1008, 1018, 1020. last item: \underline{208}, 413, 416, 417, 1048. last kern: 424, \underline{982}, 991, 996. primitive: \underline{416}. last penalty : 424, \underline{982}, 991, 996. primitive: \underline{416}. primitive: \underline{416}. last special line: \underline{847}, 848, 849, 850, 889. last text char : \underline{19*} , 24. lc code: \underline{230}, 232, 891, 896, 897, 898, 937, 962. primitive: \underline{1230}. lc code base: \underline{230}, 235, 1230, 1231, 1286, 1287,

1288. leader box : \underline{619}, 626, 628, \underline{629}, 635, 637. leader flag : \underline{1071}, 1073, 1078, 1084. leader ht : \underline{629}, 635, 636, 637. leader ptr : \underline{149}, 152, 153, 190, 202, 206, 626,

635, 656, 671, 816, 1078. leader ship: \underline{208}, 1071, 1072, 1073. leader wd : \underline{619}, 626, 627, 628. leaders: 1374. : 1078. primitive: \underline{1071}. least cost : \underline{970}, 974, 980. least page cost : \underline{980}, 987, 1005, 1006. primitive: \underline{1188}. left brace: \underline{207}, 289, 294, 298, 347, 357, 403, 473,

476, 777, 1063, 1150, 1226. left brace limit : \underline{289}, 325, 392, 394, 399. left brace token: \underline{289}, 403, 1127, 1226, 1371. left delimiter : \underline{683}, 696, 697, 737, 748, 1163,

1181, 1182. left edge: \underline{619}, 627, \underline{629}, 632, 637. left hyphen min: \underline{236}, 1091, 1376, 1377. primitive: \underline{238}. left hyphen min code: \underline{236}, 237, 238. left noad : \underline{687}, 690, 696, 698, 725, 728, 733, 760,

761, 762, 1185, 1188, 1189, 1191. left right : \underline{208}, 1046, 1188, 1189, 1190. left skip: \underline{224}, 827, 880, 887. primitive: \underline{226}. left skip code: \underline{224}, 225, 226, 887. length: \underline{40}, 46, 259, 537* , 602, 931, 941, 1280. length of lines: 847. primitive: \underline{1141}. let : \underline{209}, 1210, 1219, 1220, 1221. primitive: \underline{1219}. letter : \underline{207}, 232, 262* , 289, 291, 294, 298, 347,

354, 356, 935, 961, 1029, 1030, 1038, 1090, 1124, 1151, 1154, 1160.

letter token: \underline{289}, 445. level : 410, \underline{413}, 415, 418, 428, \underline{461}. level boundary : \underline{268}, 270, 274, 282. level one: \underline{221}, 228, 232, 254, 264, 272, 277, 278,

279, 280, 281, 283, 780, 1304, 1335, 1369. level zero: \underline{221}, 222, 272, 276, 280. lf : 540, \underline{560}, 565, 566, 575* , 576. lft hit : 906, \underline{907}, 908, 910, 911, 1033, 1035, 1040. lh: 110* , 114, 118, 213, 219, 256, 540, 541, \underline{560},

565, 566, 568, 685, 950. lhm field : \underline{212}, 213, 218. lhmin: 212, \underline{213}, 215, 891, 1091. Liang, Franklin Mark: 2* , 919. lig char : \underline{143}, 144, 193, 206, 652, 841, 842, 866,

870, 871, 898, 903, 1113. lig kern: 544, 545, 549. lig kern base: \underline{550}, 552, 557, 566, 571, 573, 576,

1322* , 1323* . lig kern command : 541, \underline{545}. lig kern restart : \underline{557}, 741, 752, 909, 1039. lig kern restart end : \underline{557}. lig kern start : \underline{557}, 741, 752, 909, 1039. lig ptr : \underline{143}, 144, 175, 193, 202, 206, 896, 898,

903, 907, 910, 911, 1037, 1040. lig stack : \underline{907}, 908, 910, 911, 1032, 1034, 1035,

1036, 1037, 1038, 1040. lig tag : \underline{544}, 569, 741, 752, 909, 1039. lig trick : \underline{162}, 652. ligature node: \underline{143}, 144, 148, 175, 183, 202, 206,

622, 651, 752, 841, 842, 866, 870, 871, 896, 897, 899, 903, 1113, 1121, 1147.

ligature present : 906, \underline{907}, 908, 910, 911, 1033,

1035, 1037, 1040. limit : 300, \underline{302}, 303, 307, 318, 328, 330, 331, 343,

348, 350, 351, 352, 354, 355, 356, 360, 362, 363, 483, 537* , 538, 1337.

: 1159. limit field : 35, 87, \underline{300}, 302, 534* . limit switch: \underline{208}, 1046, 1156, 1157, 1158. limits : \underline{682}, 696, 733, 749, 1156, 1157. primitive: \underline{1156}. line: 84* , 216, \underline{304}, 313, 328, 329, 331, 362, 424,

494, 495, 538, 663, 675, 1025. line break : 162, 814, \underline{815}, 828, 839, 848, 862, 863,

866, 876, 894, 934, 967, 970, 982, 1096, 1145. line diff : \underline{872}, 875* . line number : \underline{819}, 820, 833, 835, 845, 846, 850,

864, 872, 874, 875* .

line penalty : \underline{236}, 859* .
primitive: \underline{238}.
line penalty code: \underline{236}, 237, 238.
line skip: \underline{224}, 247.
primitive: \underline{226}.
line skip code: 149, 152, \underline{224}, 225, 226, 679.
line skip limit : \underline{247}, 679.
primitive: \underline{248}.
line skip limit code: \underline{247}, 248.
line stack : \underline{304}, 328, 329.
line width: \underline{830}, 850, 851.
link : \underline{118}, 120, 121, 122, 123, 124, 125, 126, 130,

133, 134, 135, 140, 143, 150, 164, 168, 172, 174* , 175, 176* , 182, 202, 204, 212, 214, 218, 223, 233, 292, 295, 306, 319, 323, 339, 357, 358, 366, 369, 371, 374, 389, 390, 391, 394, 396, 397, 400, 407, 452, 464, 466, 467, 470, 478, 489, 495, 496, 497, 508, 605, 607, 609, 611, 615, 620, 622, 630, 649, 651, 652, 654, 655, 666, 669, 679, 681, 689, 705, 711, 715, 718, 719, 720, 721, 727, 731, 732, 735, 737, 738, 739, 747, 748, 751, 752, 753, 754, 755, 756, 759, 760, 761, 766, 767, 770, 772, 778, 779, 783, 784, 786, 790, 791, 793, 794, 795, 796, 797, 798, 799, 801, 802, 803, 804, 805, 806, 807, 808, 809, 812, 814, 816, 819, 821, 822, 829, 830, 837, 840, 843, 844, 845, 854, 857, 858, 860, 861, 862, 863, 864, 865, 866, 867, 869, 873, 874, 875* , 877, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 890, 894, 896, 897, 898, 899, 903, 905, 906, 907, 908, 910, 911, 913, 914, 915, 916, 917, 918, 932, 938, 960, 968, 969, 970, 973, 979, 980, 981, 986, 988, 991, 994, 998, 999, 1000, 1001, 1005, 1008, 1009, 1014, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1026, 1035, 1037, 1040, 1041, 1043, 1064, 1065, 1076, 1081, 1086, 1091, 1100, 1101, 1105, 1110, 1119, 1120, 1121, 1123, 1125, 1146, 1155, 1168, 1181, 1184, 1185, 1186, 1187, 1191, 1194, 1196, 1199, 1204, 1205, 1206, 1226, 1279, 1288, 1297, 1311* , 1312* , 1335, 1339, 1341, 1349, 1368, 1371, 1375.

list offset : \underline{135}, 649, 769, 1018.

list ptr : \underline{135}, 136, 184, 202, 206, 619, 623, 629, 632, 658, 663, 664, 668, 673, 676, 709, 711, 715, 721, 739, 747, 751, 807, 977, 979, 1021, 1087, 1100, 1110, 1146, 1199.

list state record : \underline{212}, 213.

list tag : \underline{544}, 569, 570, 708, 740, 749.
ll : \underline{953}, 956.

llink : \underline{124}, 126, 127* , 129, 130, 131, 145, 149, 164,

169, 772, 819, 821, 1312* . lo mem max : \underline{116*} , 120, 125, 126, 164, 165* , 167,

169, 170, 171, 172, 178, 639, 1311* , 1312* , 1334. lo mem stat max : \underline{162}, 164, 1312* . load fmt file: \underline{1303*} , 1337. loc: \underline{36}, 37* , 87, 300, 302, 303, 307, 312, 314, 318,

319, 323, 325, 328, 330, 331, 343, 348, 350, 351, 352, 354, 356, 357, 358, 360, 362, 369, 390, 483, 524* , 537* , 538, 1026, 1027, 1337.

loc field : 35, 36, \underline{300}, 302. local base: 220, \underline{224}, 228, 230, 252. location: \underline{605}, 607, 612, 613, 614, 615. log file: \underline{54}, 56, 75, 534* , 1333* . log name: \underline{532}, 534* , 1333* . log only : \underline{54}, 57, 58, 62, 75, 98, 360, 534* , 1328* ,

1370. log opened : 92, 93, \underline{527}, 528, 534* , 535, 1265,

1333* , 1334. primitive: \underline{1208}. long call : \underline{210}, 275, 366, 387, 389, 392, 399, 1295. long help seen: \underline{1281}, 1282, 1283. long outer call : \underline{210}, 275, 366, 387, 389, 1295. long state: 339, \underline{387}, 391, 392, 395, 396, 399. loop: 15, \underline{16*} . : 660. : 674. loose fit : \underline{817}, 834, 852. looseness : \underline{236}, 848, 873, 875* , 1070. primitive: \underline{238}. looseness code: \underline{236}, 237, 238, 1070. primitive: \underline{1071}. primitive: \underline{1286}. lq : \underline{592}, 627, 636. lr : \underline{592}, 627, 636. lx : \underline{619}, 626, 627, 628, \underline{629}, 635, 636, 637. m: \underline{47}, \underline{65}, \underline{158}, \underline{211}, \underline{218}, \underline{292}, \underline{315}, \underline{389}, \underline{413},

\underline{440}, \underline{482}, \underline{498}, \underline{577}, \underline{649}, \underline{668}, \underline{706}, \underline{716}, \underline{717}, \underline{1079}, \underline{1105}, \underline{1194}, \underline{1338*} .

mac param: \underline{207}, 291, 294, 298, 347, 474, 477,

479, 783, 784, 1045. macro: \underline{307}, 314, 319, 323, 324, 390. macro call : 291, 366, 380, 382, 387, 388, \underline{389}, 391. macro def : \underline{473}, 477. mag : \underline{236}, 240, 288, 457, 585, \underline{587}, 588, 590,

617, 642. primitive: \underline{238}. mag code: \underline{236}, 237, 238, 288. mag set : \underline{286}, 287, 288. magic offset : \underline{764}, 765, 766. main control : 1029, \underline{1030}, 1032, 1040, 1041, 1052,

1054, 1055, 1056, 1057, 1126, 1134, 1208, 1290, 1332* , 1337, 1344, 1347.

main f : \underline{1032}, 1034, 1035, 1036, 1037, 1038,

1039, 1040. main i : \underline{1032}, 1036, 1037, 1039, 1040. main j : \underline{1032}, 1039, 1040. main k : \underline{1032}, 1034, 1039, 1040, 1042. main lig loop: \underline{1030}, 1034, 1037, 1038, 1039, 1040. main loop: \underline{1030}. main loop lookahead : \underline{1030}, 1034, 1036, 1037,

1038. main loop move: \underline{1030}, 1034, 1036, 1040. main loop move lig : \underline{1030}, 1034, 1036, 1037. main loop wrapup: \underline{1030}, 1034, 1039, 1040. main p: \underline{1032}, 1035, 1037, 1040, 1041, 1042,

1043, 1044. main s : \underline{1032}, 1034. major tail : \underline{912}, 914, 917, 918. make accent : 1122, \underline{1123}. make box : \underline{208}, 1071, 1072, 1073, 1079, 1084. make fraction: 733, 734, \underline{743}. make left right : 761, \underline{762}. make mark : 1097, \underline{1101}. make math accent : 733, \underline{738}. make name string : \underline{525}. make op: 733, \underline{749}. make ord : 733, \underline{752}. make over : 733, \underline{734}. make radical : 733, 734, \underline{737}. make scripts : 754, \underline{756}. make string : \underline{43}, 48, 52* , 260, 517, 525, 939, 1257,

1279, 1328* , 1333* . make under : 733, \underline{735}. make vcenter : 733, \underline{736}. mark : \underline{208}, 265, 266, 1097. primitive: \underline{265}. mark node: \underline{141}, 148, 175, 183, 202, 206, 647,

651, 730, 761, 866, 899, 968, 973, 979, 1000, 1014, 1101.

mark ptr : \underline{141}, 142, 196, 202, 206, 979, 1016, 1101. mark text : \underline{307}, 314, 323, 386. mastication: 341. match: \underline{207}, 289, 291, 292, 294, 391, 392. match chr : \underline{292}, 294, \underline{389}, 391, 400. match token: \underline{289}, 391, 392, 393, 394, 476. matching : \underline{305}, 306, 339, 391. : 1195. math ac: 1164, \underline{1165}. math accent : \underline{208}, 265, 266, 1046, 1164. primitive: \underline{265}. primitive: \underline{1156}. math char : \underline{681}, 692, 720, 722, 724, 738, 741, 749,

752, 753, 754, 1151, 1155, 1165. primitive: \underline{265}. primitive: \underline{1222}. math char def code: \underline{1222}, 1223, 1224. math char num: \underline{208}, 265, 266, 1046, 1151, 1154. math choice: \underline{208}, 265, 266, 1046, 1171. primitive: \underline{265}. math choice group: \underline{269}, 1172, 1173, 1174. primitive: \underline{1156}. math code: \underline{230}, 232, 236, 414, 1151, 1154. primitive: \underline{1230}. math code base: \underline{230}, 235, 414, 1230, 1231,

1232, 1233. math comp: \underline{208}, 1046, 1156, 1157, 1158. math font base: \underline{230}, 232, 234, 1230, 1231. math fraction: 1180, \underline{1181}. math given: \underline{208}, 413, 1046, 1151, 1154, 1222,

1223, 1224. math glue: \underline{716}, 732, 766. math group: \underline{269}, 1136, 1150, 1153, 1186. primitive: \underline{1156}. math kern: \underline{717}, 730. math left group: \underline{269}, 1065, 1068, 1069, 1150, 1191. math left right : 1190, \underline{1191}. math limit switch: 1158, \underline{1159}. math node: \underline{147}, 148, 175, 183, 202, 206, 622, 651,

817, 837, 866, 879, 881, 1147. primitive: \underline{1156}. primitive: \underline{1156}. primitive: \underline{1156}. primitive: \underline{1156}. math quad : \underline{700}, 703, 1199. math radical : 1162, \underline{1163}. primitive: \underline{1156}. math shift : \underline{207}, 289, 294, 298, 347, 1090, 1137,

1138, 1193, 1197, 1206. math shift group: \underline{269}, 1065, 1068, 1069, 1130,

1139, 1140, 1142, 1145, 1192, 1193, 1194, 1200. math shift token: \underline{289}, 1047, 1065. math spacing : \underline{764}, 765. math style: \underline{208}, 1046, 1169, 1170, 1171. math surround : \underline{247}, 1196. primitive: \underline{248}. math surround code: \underline{247}, 248. math text char : \underline{681}, 752, 753, 754, 755. math type: \underline{681}, 683, 687, 692, 698, 720, 722, 723,

734, 735, 737, 738, 741, 742, 749, 751, 752, 753, 754, 755, 756, 1076, 1093, 1151, 1155, 1165, 1168, 1176, 1181, 1185, 1186, 1191.

math x height : \underline{700}, 737, 757, 758, 759. mathex : \underline{701}. mathsy : \underline{700}. mathsy end : \underline{700}. max answer : \underline{105}. max buf stack : \underline{30}, 31* , 331, 374, 1334. max char code: \underline{207}, 303, 344, 1233.

max command : \underline{209}, 210, 211, 219, 358, 366, 368,

380, 381, 478, 782. max d : \underline{726}, 727, 730, 760, 761, \underline{762}.

max dead cycles : \underline{236}, 240, 1012.
primitive: \underline{238}.
max dead cycles code: \underline{236}, 237, 238.
max depth: \underline{247}, 980, 987.
primitive: \underline{248}.
max depth code: \underline{247}, 248.
max dimen: \underline{421}, 460, 641, 668, 1010, 1017,

1145, 1146, 1148. max group code: \underline{269}. max h: \underline{592}, 593, 641, 642, \underline{726}, 727, 730, 760,

761, \underline{762}. max halfword : 11* , 14, \underline{110*} , 111, 113* , 124, 125, 126, 131, 132, 289, 290, 424, 820, 848, 850, 982, 991, 996, 1017, 1106, 1249, 1325* .

max in open: \underline{11*} , 14, 304, 328.

max in stack : \underline{301}, 321, 331, 1334.
max internal : \underline{209}, 413, 440, 448, 455, 461.
max nest stack : \underline{213}, 215, 216, 1334.
max non prefixed command : \underline{208}, 1211, 1270.
max param stack : \underline{308}, 331, 390, 1334.

max print line: \underline{11*} , 14, 54, 58, 61* , 72, 176* , 537* ,

638, 1280. max push: \underline{592}, 593, 619, 629, 642. max quarterword : 11* , \underline{110*} , 111, 113* , 274, 797,

798, 944* , 1120. max save stack : \underline{271}, 272, 273, 1334. max selector : \underline{54}, 246, 311, 465, 470, 534* , 638,

1257, 1279, 1368, 1370. max strings : \underline{11*} , 38, 43, 111, 517, 525, 1310* , 1334. max v : \underline{592}, 593, 641, 642. primitive: \underline{468}. meaning code: \underline{468}, 469, 471, 472. med mu skip: \underline{224}. primitive: \underline{226}. med mu skip code: \underline{224}, 225, 226, 766. mem: 11* , 12* , 115, 116* , 118, 124, 126, 131, 133, 134, 135, 140, 141, 150, 151, 157, 159, 162, 163, 164, 165* , 167, 172, 182, 186* , 203, 205, 206, 221, 224, 275, 291, 387, 420, 489, 605, 652, 680, 681, 683, 686, 687, 720, 725, 742, 753, 769, 770, 772, 797, 816, 818, 819, 822, 823, 832, 843, 844, 847, 848, 850, 860, 861, 889, 925, 1149, 1151, 1160, 1163, 1165, 1181, 1186, 1247, 1248, 1311* , 1312* , 1339.

mem bot : 11* , \underline{12*} , 14, 111, 116* , 125, 126, 162, 164,

1307, 1308* , 1311* , 1312* . mem end : 116* , \underline{118}, 120, 164, 165* , 167, 168, 171, 172, 174* , 176* , 182, 293, 1311* , 1312* , 1334. mem max : \underline{11*} , 12* , 14, 110* , 111, 116* , 120, 124,

125, 165* , 166. mem min: \underline{11*} , 12* , 111, 116* , 120, 125, 165* , 166,

167, 169, 170, 171, 172, 174* , 178, 182, 1249, 1312* , 1334.

mem top: \underline{11*} , 14, 111, 116* , 162, 164, 1249, 1307,

1308* , 1312* . : 639. memory word : 110* , 114, 116* , 182, 212, 218, 221,

253* , 268, 271, 275, 548, 549, 800, 1305* , 1379* . message: \underline{208}, 1276, 1277, 1278. primitive: \underline{1277}. : 589. mid : \underline{546}. mid line: 87, \underline{303}, 328, 344, 347, 352, 353, 354. min halfword : 11* , \underline{110*} , 111, 113* , 115, 230,

1027, 1325* . min internal : \underline{208}, 413, 440, 448, 455, 461. min quarterword : 12* , \underline{110*} , 111, 112* , 113* , 134, 136,

140, 185, 221, 274, 549, 550, 554, 556, 557, 566, 576, 649, 668, 685, 697, 707, 713, 714, 796, 801, 803, 808, 920, 923, 924, 943* , 944* , 945, 946, 958, 963, 964, 965, 994, 1012, 1324* , 1325* .

minimal demerits : \underline{833}, 834, 836, 845, 855. minimum demerits : \underline{833}, 834, 835, 836, 854, 855. minor tail : \underline{912}, 915, 916. : 462. : 1128. : 1128. : 1129. : 1129. : 1128. : 503. # : 783. $ : 1047, 1065. : 1132. : 373. : 1065. : 1065. : 403, 475, 1127. : 1065, 1127. : 1082. : 1225. $$ : 1207. : 581. : 1215. : 1161. : 577. : 415, 446. mkern: \underline{208}, 1046, 1057, 1058, 1059. primitive: \underline{1058}. ml field : \underline{212}, 213, 218.

mlist : \underline{726}, 760.
mlist penalties : \underline{719}, 720, 726, 754, 1194, 1196,

1199. mlist to hlist : 693, 719, 720, 725, \underline{726}, 734, 754,

760, 1194, 1196, 1199. : 458. mmode: \underline{211}, 212, 213, 218, 501, 718, 775, 776, 800, 812, 1030, 1045, 1046, 1048, 1056, 1057, 1073, 1078, 1080, 1092, 1097, 1109, 1110, 1112, 1116, 1120, 1130, 1136, 1140, 1145, 1150, 1154, 1158, 1162, 1164, 1167, 1171, 1175, 1180, 1190, 1193, 1194.

mode: 211, 212, \underline{213}, 215, 216, 299, 418, 422, 424, 501, 718, 775, 776, 785, 786, 787, 796, 799, 804, 807, 808, 809, 812, 1025, 1029, 1030, 1034, 1035, 1049, 1051, 1056, 1076, 1078, 1080, 1083, 1086, 1091, 1093, 1094, 1095, 1096, 1099, 1103, 1105, 1110, 1117, 1119, 1120, 1136, 1138, 1145, 1167, 1194, 1196, 1200, 1243, 1370, 1371, 1377.

mode field : \underline{212}, 213, 218, 422, 800, 1244.

mode line: 212, \underline{213}, 215, 216, 304, 804, 815, 1025. month: \underline{236}, 241* , 536* , 617, 1328* . primitive: \underline{238}. month code: \underline{236}, 237, 238. months : \underline{534*} , 536* . more name: 512, \underline{516*} , 526, 531. primitive: \underline{1071}. move past : \underline{619}, 622, 625, 629, 631, 634. primitive: \underline{1071}. movement : \underline{607}, 609, 616. movement node size: \underline{605}, 607, 615. mskip: \underline{208}, 1046, 1057, 1058, 1059, 1078. primitive: \underline{1058}. mskip code: \underline{1058}, 1060. mstate: \underline{607}, 611, 612. mtype: \underline{4*} . mu: 447, \underline{448}, 449, 453, 455, \underline{461}, 462. : 456. mu error : \underline{408}, 429, 449, 455, 461. mu glue: \underline{149}, 155, 191, 424, 717, 732, 1058,

1060, 1061. mu mult : \underline{716}, 717.

mu skip: \underline{224}, 427.
primitive: \underline{411}.
mu skip base: \underline{224}, 227, 229, 1224, 1237.
primitive: \underline{1222}.
mu skip def code: \underline{1222}, 1223, 1224.

mu val : \underline{410}, 411, 413, 424, 427, 429, 430, 449, 451, 455, 461, 465, 1060, 1228, 1236, 1237.

mult and add : \underline{105}.

mult integers : \underline{105}, 1240.

multiply : \underline{209}, 265, 266, 1210, 1235, 1236, 1240. primitive: \underline{265}. : 1303* . n: \underline{47}, \underline{65}, \underline{66}, \underline{67}, \underline{69}, \underline{91}, \underline{94}, \underline{105}, \underline{106}, \underline{107}, \underline{152},

\underline{154}, \underline{174*} , \underline{182}, \underline{225}, \underline{237}, \underline{247}, \underline{252}, \underline{292}, \underline{315}, \underline{389}, \underline{482}, \underline{498}, \underline{518}, \underline{519}, \underline{523}, \underline{578}, \underline{706}, \underline{716}, \underline{717}, \underline{791}, \underline{800}, \underline{906}, \underline{934}, \underline{944*} , \underline{977}, \underline{992}, \underline{993}, \underline{994}, \underline{1012}, \underline{1079}, \underline{1119}, \underline{1138}, \underline{1211}, \underline{1275*} , \underline{1338*} .

name: 300, \underline{302}, 303, 304, 307, 311, 313, 314, 323,

328, 329, 331, 337, 360, 390, 483, 537* . name field : 84* , \underline{300}, 302. name in progress : 378, 526, \underline{527}, 528, 1258. name length: \underline{26}, 519, 523, 525. name of file: \underline{26}, 51* , 519, 523, 525, 530. natural : \underline{644}, 705, 715, 720, 727, 735, 737, 738,

748, 754, 756, 759, 796, 799, 806, 977, 1021, 1100, 1125, 1194, 1199, 1204.

nd : 540, 541, \underline{560}, 565, 566, 569. ne: 540, 541, \underline{560}, 565, 566, 569. neg trie op size: \underline{11*} , 943* , 944* . negate: \underline{16*} , 65, 103, 105, 106, 107, 430, 431,

440, 448, 461, 775. negative: \underline{106}, \underline{413}, 430, \underline{440}, 441, \underline{448}, \underline{461}. nest : 212, \underline{213}, 216, 217, 218, 219, 413, 422,

775, 800, 995, 1244. nest ptr : \underline{213}, 215, 216, 217, 218, 422, 775, 800,

995, 1017, 1023, 1091, 1100, 1145, 1200, 1244. nest size: \underline{11*} , 213, 216, 218, 413, 1244, 1334. new character : \underline{582}, 755, 915, 1117, 1123, 1124. new choice: \underline{689}, 1172. new delta from break width: \underline{844}. new delta to break width: \underline{843}. new disc: \underline{145}, 1035, 1117. new font : 1256, \underline{1257}. new glue: \underline{153}, 154, 715, 766, 786, 793, 795, 809,

1041, 1043, 1054, 1060, 1171. new graf : 1090, \underline{1091}. new hlist : \underline{725}, 727, 743, 748, 749, 750, 754,

756, 762, 767. new hyph exceptions : \underline{934}, 1252. new interaction: 1264, \underline{1265}. new kern: \underline{156}, 705, 715, 735, 738, 739, 747,

751, 753, 755, 759, 910, 1040, 1061, 1112, 1113, 1125, 1204.

new lig item: \underline{144}, 911, 1040. new ligature: \underline{144}, 910, 1035. new line: \underline{303}, 331, 343, 344, 345, 347, 483, 537* . new line char : \underline{236}, 244. primitive: \underline{238}. new line char code: \underline{236}, 237, 238. new math: \underline{147}, 1196. new noad : \underline{686}, 720, 742, 753, 1076, 1093, 1150,

1155, 1158, 1168, 1177, 1191. new null box : \underline{136}, 706, 709, 713, 720, 747, 750,

779, 793, 809, 1018, 1054, 1091, 1093. new param glue: \underline{152}, 154, 679, 778, 816, 886, 887,

1041, 1043, 1091, 1203, 1205, 1206. new patterns : \underline{960}, 1252. new penalty : \underline{158}, 767, 816, 890, 1054, 1103,

1203, 1205, 1206. new rule: \underline{139}, 463, 666, 704. new save level : \underline{274}, 645, 774, 785, 791, 1025,

1063, 1099, 1117, 1119, 1136. new skip param: \underline{154}, 679, 969, 1001. new spec: \underline{151}, 154, 430, 462, 826, 976, 1004,

1042, 1043, 1239, 1240. new string : \underline{54}, 57, 58, 465, 470, 617, 1257,

1279, 1328* , 1368. new style: \underline{688}, 1171. new trie op: 943* , \underline{944*} , 945, 965. new whatsit : \underline{1349}, 1350, 1354, 1376, 1377. new write whatsit : \underline{1350}, 1351, 1352, 1353. next : \underline{256}, 257, 259, 260. next break : \underline{877}, 878, 883. next char : \underline{545}, 741, 753, 909, 1039. next p: \underline{619}, 622, 626, 629, 630, 631, 633, 635. nh: 540, 541, \underline{560}, 565, 566, 569. ni : 540, 541, \underline{560}, 565, 566, 569. nil: 16* . nk : 540, 541, \underline{560}, 565, 566, 573. nl : 540, 541, 545, \underline{560}, 565, 566, 569, 573, 576. nn: \underline{311}, 312. : 642. no align: \underline{208}, 265, 266, 785, 1126. primitive: \underline{265}. no align error : 1126, \underline{1129}. no align group: \underline{269}, 768, 785, 1133. no boundary : \underline{208}, 265, 266, 1030, 1038, 1045,

1090. primitive: \underline{265}. no break yet : \underline{829}, 836, 837. no expand : \underline{210}, 265, 266, 366, 367. primitive: \underline{265}. no expand flag : \underline{358}, 506. primitive: \underline{1088}. no limits : \underline{682}, 1156, 1157. primitive: \underline{1156}. no new control sequence: \underline{256}, 257, 259, 264,

365, 374, 1336. no print : \underline{54}, 57, 58, 75, 98. no shrink error yet : \underline{825}, 826, 827. no tag : \underline{544}, 569. noad size: \underline{681}, 686, 698, 753, 761, 1186, 1187. node list display : \underline{180}, 184, 188, 190, 195, 197. node r stays active: \underline{830}, 851, 854. node size: \underline{124}, 126, 127* , 128, 130, 164, 169,

1311* , 1312* . nom: \underline{560}, 561, 563* , 576. non address : \underline{549}, 552, 576, 909, 916, 1034. non char : \underline{549}, 552, 576, 901, 903, 908, 909, 910,

911, 915, 916, 917, 1032, 1034, 1035, 1038, 1040. non discardable: \underline{148}, 879. non math: \underline{1046}, 1063, 1144. non script : \underline{208}, 265, 266, 1046, 1171. primitive: \underline{265}, \underline{732}. none seen: \underline{611}, 612. : 262* . : 962. nonnegative integer : 69, \underline{101}, 107. nonstop mode: \underline{73}, 86, 360, 363, 484, 1262, 1263. primitive: \underline{1262}. nop: 583, 585, \underline{586}, 588, 590. norm min: \underline{1091}, 1376, 1377. normal : \underline{135}, 136, 149, 150, 153, 155, 156, 164,

177, 186* , 189, 191, 305, 331, 336, 369, 448, 471, 473, 480, 482, 485, 489, 490, 507, 619, 625, 629, 634, 650, 657, 658, 659, 660, 664, 665, 666, 667, 672, 673, 674, 676, 677, 678, 682, 686, 696, 716, 717, 732, 749, 777, 801, 810, 811, 825, 826, 896, 897, 899, 976, 988, 1004, 1009, 1156, 1163, 1165, 1181, 1201, 1219, 1220, 1221, 1239.

normal paragraph: 774, 785, 787, 1025, \underline{1070},

1083, 1094, 1096, 1099, 1167. normalize selector : 78, \underline{92}, 93, 94, 95, 863. : 937. not found : \underline{15}, 45, 46, 448, 455, 560, 570, 607,

611, 612, 895, 930, 931, 934, 941, 953, 955, 970, 972, 973, 1138, 1146, 1365.

: 258. np: 540, 541, \underline{560}, 565, 566, 575* , 576. nucleus : \underline{681}, 682, 683, 686, 687, 690, 696, 698,

720, 725, 734, 735, 736, 737, 738, 741, 742, 749, 750, 752, 753, 754, 755, 1076, 1093, 1150, 1151, 1155, 1158, 1163, 1165, 1168, 1186, 1191.

null : \underline{115}, 116* , 118, 120, 122, 123, 125, 126, 135, 136, 144, 145, 149, 150, 151, 152, 153, 154, 164, 168, 169, 175, 176* , 182, 200, 201, 202, 204, 210, 212, 218, 219, 222, 223, 232, 233, 275, 292, 295, 306, 307, 312, 314, 325, 331, 357, 358, 371, 374, 382, 383, 386, 390, 391, 392, 397, 400, 407, 410, 420, 423, 452, 464, 466, 473, 478, 482, 489, 490, 497, 505, 508, 549, 552, 576, 578, 582, 606, 611, 615, 619, 623, 629, 632, 648, 649, 651, 655, 658, 664, 666, 668, 673, 676, 681, 685, 689, 692, 715, 718, 719, 720, 721, 726, 731, 732, 752, 754, 755, 756, 760, 761, 766, 767, 771, 774, 776, 777, 783, 784, 790, 791, 792, 794, 796, 797, 799, 801, 804, 805, 806, 807, 812, 821, 829, 837, 840, 846, 847, 848, 850, 856, 857, 858, 859* , 863, 864, 865, 867, 869, 872, 877, 878, 879, 881, 882, 883, 884, 885, 887, 888, 889, 894, 896, 898, 903, 906, 907, 908, 910, 911, 913, 914, 915, 916, 917, 918, 928, 932, 935, 968, 969, 970, 972, 973, 977, 978, 979, 981, 991, 992, 993, 994, 998, 999, 1000, 1009, 1010, 1011, 1012, 1014, 1015, 1016, 1017, 1018, 1020, 1021, 1022, 1023, 1026, 1027, 1028, 1030, 1032, 1035, 1036, 1037, 1038, 1040, 1042, 1043, 1070, 1074, 1075, 1076, 1079, 1080, 1081, 1083, 1087, 1091, 1105, 1110, 1121, 1123, 1124, 1136, 1139, 1145, 1146, 1149, 1167, 1174, 1176, 1181, 1184, 1185, 1186, 1194, 1196, 1199, 1202, 1205, 1206, 1226, 1227, 1247, 1248, 1283, 1288, 1296, 1311* , 1312* , 1335, 1339, 1353, 1354, 1368, 1369, 1375.

null delimiter: 240, 1065. null character : \underline{555}, 556, 722, 723. null code: \underline{22}, 232. null cs : \underline{222}, 262* , 263, 354, 374, 1257. null delimiter : \underline{684}, 685, 1181. null delimiter space: \underline{247}, 706. primitive: \underline{248}. null delimiter space code: \underline{247}, 248. null flag : \underline{138}, 139, 463, 653, 779, 793, 801. null font : \underline{232}, 552, 553, 560, 577, 617, 663, 706,

707, 722, 864, 1257, 1322* , 1323* , 1339. primitive: \underline{553}. null list : 14, \underline{162}, 380, 780. num: \underline{450}, 458, 585, \underline{587}, 590. num style: \underline{702}, 744. : 445. primitive: \underline{468}. number code: \underline{468}, 469, 470, 471, 472. numerator : \underline{683}, 690, 697, 698, 744, 1181, 1185. num1 : \underline{700}, 744. num2 : \underline{700}, 744. num3 : \underline{700}, 744. nw : 540, 541, \underline{560}, 565, 566, 569. nx plus y : \underline{105}, 455, 716, 1240. o: \underline{264}, \underline{607}, \underline{649}, \underline{668}, \underline{791}, \underline{800}. octal token: \underline{438}, 444. odd : 62, 100, 193, 504, 758, 902, 903, 908, 909,

913, 914, 1211, 1218. off save: 1063, \underline{1064}, 1094, 1095, 1130, 1131,

1140, 1192, 1193. : 1298. OK so far : \underline{440}, 445. OK to interrupt : 88, \underline{96}, 97, 98, 327, 1031. old l : \underline{829}, 835, 850. old mode: \underline{1370}, 1371. old rover : \underline{131}. old setting : 245, \underline{246}, \underline{311}, 312, \underline{465}, \underline{470}, \underline{534*} , 617,

\underline{638}, \underline{1257}, \underline{1279}, \underline{1368}, \underline{1370}. omit : \underline{208}, 265, 266, 788, 789, 1126. primitive: \underline{265}. omit error : 1126, \underline{1129}. omit template: \underline{162}, 789, 790. # : 784. op byte: \underline{545}, 557, 741, 753, 909, 911, 1040. op noad : \underline{682}, 690, 696, 698, 726, 728, 733, 749,

761, 1156, 1157, 1159. op start : 920, \underline{921}, 924, 945, 1325* . open area: \underline{1341}, 1351, 1356, 1374. open ext : \underline{1341}, 1351, 1356, 1374. open fmt file: \underline{524*} , 1337. primitive: \underline{1272}. open log file: 78, 92, 360, 471, 532, \underline{534*} , 535,

537* , 1257, 1335. open name: \underline{1341}, 1351, 1356, 1374. open noad : \underline{682}, 690, 696, 698, 728, 733, 761,

762, 1156, 1157. open node: \underline{1341}, 1344, 1346, 1348, 1356, 1357,

1358, 1373. open node size: \underline{1341}, 1351, 1357, 1358. open or close in: 1274, \underline{1275*} . primitive: \underline{1344}. open parens : \underline{304}, 331, 362, 537* , 1335. primitive: \underline{491}. or code: \underline{489}, 491, 492, 500, 509. ord : 20. ord noad : 681, \underline{682}, 686, 687, 690, 696, 698, 728,

729, 733, 752, 753, 761, 764, 765, 1075, 1155, 1156, 1157, 1186.

order : \underline{177}. oriental characters: 134, 585. other A token: \underline{445}. other char : \underline{207}, 232, 289, 291, 294, 298, 347,

445, 464, 526, 935, 961, 1030, 1038, 1090, 1124, 1151, 1154, 1160.

other token: \underline{289}, 405, 438, 441, 445, 464, 503,

1065, 1221. othercases: \underline{10}. others : 10. : 1332* . out param: \underline{207}, 289, 291, 294, 357. out param token: \underline{289}, 479. out what : 1366, 1367, \underline{1373}, 1375. primitive: \underline{1208}. outer call : \underline{210}, 275, 339, 351, 353, 354, 357, 366,

387, 391, 396, 780, 1152, 1295, 1369. outer doing leaders : \underline{619}, 628, \underline{629}, 637. : 1024.

: 642. primitive: \underline{230}. output active: 421, 663, 675, 986, \underline{989}, 990, 994,

1005, 1025, 1026. output file name: \underline{532}, 533, 642.

output group: \underline{269}, 1025, 1100.
output penalty : \underline{236}.
primitive: \underline{238}.
output penalty code: \underline{236}, 237, 238, 1013.
output routine: \underline{230}, 1012, 1025.

output routine loc: \underline{230}, 231, 232, 307, 323, 1226.

output text : \underline{307}, 314, 323, 1025, 1026.
primitive: \underline{1178}.
over code: \underline{1178}, 1179, 1182.
over noad : \underline{687}, 690, 696, 698, 733, 761, 1156.
primitive: \underline{1178}.
overbar : \underline{705}, 734, 737.
overflow : 35, 42, 43, \underline{94}, 120, 125, 216, 260,

273, 274, 321, 328, 374, 390, 517, 580, 940, 944* , 954, 964, 1333* . Overflow in arithmetic: 9* , 104. : 666. : 677. overfull boxes: 854. overfull rule: \underline{247}, 666, 800, 804. primitive: \underline{248}. overfull rule code: \underline{247}, 248. primitive: \underline{1156}. p: \underline{120}, \underline{123}, \underline{125}, \underline{130}, \underline{131}, \underline{136}, \underline{139}, \underline{144}, \underline{145}, \underline{147}, \underline{151}, \underline{152}, \underline{153}, \underline{154}, \underline{156}, \underline{158}, \underline{167}, \underline{172}, \underline{174*} , \underline{176*} , \underline{178}, \underline{182}, \underline{198}, \underline{200}, \underline{201}, \underline{202}, \underline{204}, \underline{218}, \underline{259}, \underline{262*} , \underline{263}, \underline{276}, \underline{277}, \underline{278}, \underline{279}, \underline{281}, \underline{284}, \underline{292}, \underline{295}, \underline{306}, \underline{315}, \underline{323}, \underline{325}, \underline{336}, \underline{366}, \underline{389}, \underline{407}, \underline{413}, \underline{450}, \underline{464}, \underline{465}, \underline{473}, \underline{482}, \underline{497}, \underline{498}, \underline{582}, \underline{607}, \underline{615}, \underline{619}, \underline{629}, \underline{638}, \underline{649}, \underline{668}, \underline{679}, \underline{686}, \underline{688}, \underline{689}, \underline{691}, \underline{692}, \underline{704}, \underline{705}, \underline{709}, \underline{711}, \underline{715}, \underline{716}, \underline{717}, \underline{720}, \underline{726}, \underline{735}, \underline{738}, \underline{743}, \underline{749}, \underline{752}, \underline{756}, \underline{772}, \underline{774}, \underline{787}, \underline{791}, \underline{799}, \underline{800}, \underline{826}, \underline{906}, \underline{934}, \underline{948*} , \underline{949}, \underline{953}, \underline{957}, \underline{959}, \underline{960}, \underline{966}, \underline{968}, \underline{970}, \underline{993}, \underline{994}, \underline{1012}, \underline{1064}, \underline{1068}, \underline{1075}, \underline{1079}, \underline{1086}, \underline{1093}, \underline{1101}, \underline{1105}, \underline{1110}, \underline{1113}, \underline{1119}, \underline{1123}, \underline{1138}, \underline{1151}, \underline{1155}, \underline{1160}, \underline{1174}, \underline{1176}, \underline{1184}, \underline{1191}, \underline{1194}, \underline{1211}, \underline{1236}, \underline{1244}, \underline{1288}, \underline{1293}, \underline{1302*} ,

\underline{1303*} , \underline{1348}, \underline{1349}, \underline{1355}, \underline{1368}, \underline{1370}, \underline{1373}.

pack begin line: \underline{661}, 662, 663, 675, 804, 815.

pack buffered name: \underline{523}, 524* .

pack cur name: \underline{529}, 530, 537* , 1275* , 1374.

pack file name: \underline{519}, 529, 537* , 563* . pack job name: \underline{529}, 532, 534* , 1328* . pack lig : \underline{1035}. package: 1085, \underline{1086}. packed ASCII code: \underline{38}, 39, 947. page: \underline{304}. page contents : 421, \underline{980}, 986, 987, 991, 1000,

1001, 1008. page depth: \underline{982}, 987, 991, 1002, 1003, 1004,

1008, 1010. primitive: \underline{983}. primitive: \underline{983}. primitive: \underline{983}. primitive: \underline{983}. page goal : 980, \underline{982}, 986, 987, 1005, 1006, 1007,

1008, 1009, 1010. primitive: \underline{983}. page head : \underline{162}, 215, 980, 986, 988, 991, 1014,

1017, 1023, 1026, 1054. page ins head : \underline{162}, 981, 986, 1005, 1008, 1018,

1019, 1020. page ins node size: \underline{981}, 1009, 1019. page loc: \underline{638}, 640. page max depth: \underline{980}, 982, 987, 991, 1003, 1017. page shrink : \underline{982}, 985, 1004, 1007, 1008, 1009. primitive: \underline{983}. page so far : 421, \underline{982}, 985, 987, 1004, 1007,

1009, 1245. page stack : \underline{304}. primitive: \underline{983}. page tail : 215, \underline{980}, 986, 991, 998, 1000, 1017,

1023, 1026, 1054. page total : \underline{982}, 985, 1002, 1003, 1004, 1007,

1008, 1010. primitive: \underline{983}. panicking : \underline{165*} , 166, 1031, 1339. primitive: \underline{334}. par end : \underline{207}, 334, 335, 1046, 1094. par fill skip: \underline{224}, 816. primitive: \underline{226}. par fill skip code: \underline{224}, 225, 226, 816. par indent : \underline{247}, 1091, 1093. primitive: \underline{248}. par indent code: \underline{247}, 248. par loc: \underline{333}, 334, 351, 1313, 1314. primitive: \underline{265}. par shape loc: \underline{230}, 232, 233, 1070, 1248. par shape ptr : \underline{230}, 232, 233, 423, 814, 847, 848,

850, 889, 1070, 1149, 1249. par skip: \underline{224}, 1091. primitive: \underline{226}. par skip code: \underline{224}, 225, 226, 1091. par token: \underline{333}, 334, 339, 392, 395, 399, 1095, 1314. : 396. param: 542, 547, \underline{558}. param base: \underline{550}, 552, 558, 566, 574, 575* , 576,

578, 580, 700, 701, 1042, 1322* , 1323* . param end : \underline{558}. param ptr : \underline{308}, 323, 324, 331, 390. param size: \underline{11*} , 308, 390, 1334. param stack : 307, \underline{308}, 324, 359, 388, 389, 390. param start : \underline{307}, 323, 324, 359. parameter : \underline{307}, 314, 359. parameters for symbols: 700, 701. : 476. Pascal-H: \underline{3}. Pascal: 1, 10, 693, 764. pass number : \underline{821}, 845, 864. pass text : 366, \underline{494}, 500, 509, 510. passive: \underline{821}, 845, 846, 864, 865. passive node size: \underline{821}, 845, 865. : 1252. primitive: \underline{1250}. pause for instructions : 96, \underline{98}. pausing : \underline{236}, 363. primitive: \underline{238}. pausing code: \underline{236}, 237, 238. pc: 186* . : 458. pen: \underline{726}, 761, 767, \underline{877}, 890. penalties: 1102. penalties : \underline{726}, 767. penalty : \underline{157}, 158, 194, 424, 816, 866, 973, 996,

1000, 1010, 1011, 1013. primitive: \underline{265}. penalty node: \underline{157}, 158, 183, 202, 206, 424, 730,

761, 767, 816, 817, 837, 856, 866, 879, 899, 968, 973, 996, 1000, 1010, 1011, 1013, 1107.

pg field : \underline{212}, 213, 219, 422, 1244.

pi : \underline{829}, 831, 851, 856, 859* , \underline{970}, 972, 973, 974,

\underline{994}, 1000, 1005, 1006. : 521* , 524* , 1331. Plass, Michael Frederick: 2* , 813. : 360, 530. : 1166. : 561. : 462. point token: \underline{438}, 440, 448, 452. pointer : \underline{115}, 116* , 118, 120, 123, 124, 125, 130,

131, 136, 139, 144, 145, 147, 151, 152, 153, 154, 156, 158, 165* , 167, 172, 198, 200, 201, 202, 204, 212, 218, 252, 256, 259, 263, 275, 276, 277, 278, 279, 281, 284, 295, 297, 305, 306, 308, 323, 325, 333, 336, 366, 382, 388, 389, 407, 450, 461, 463, 464, 465, 473, 482, 489, 497, 498, 549, 560, 582, 592, 605, 607, 615, 619, 629, 638, 647, 649, 668, 679, 686, 688, 689, 691, 692, 704, 705, 706, 709, 711, 715, 716, 717, 719, 720, 722, 726, 734, 735, 736, 737, 738, 743, 749, 752, 756, 762, 770, 772, 774, 787, 791, 799, 800, 814, 821, 826, 828, 829, 830, 833, 862, 872, 877, 892, 900, 901, 906, 907, 912, 926, 934, 968, 970, 977, 980, 982, 993, 994, 1012, 1032, 1043, 1064, 1068, 1074, 1075, 1079, 1086, 1093, 1101, 1105, 1110, 1113, 1119, 1123, 1138, 1151, 1155, 1160, 1174, 1176, 1184, 1191, 1194, 1198, 1211, 1236, 1257, 1288, 1293, 1302* , 1303* , 1345, 1348, 1349, 1355, 1368, 1370, 1373.

Poirot, Hercule: 1283. pool file: 47, \underline{50}, 51* , 52* , 53* . pool name: \underline{11*} , 51* . pool pointer : \underline{38}, 39, 45, 46, 59, 60, 69, 70, 264,

407, 464, 465, 470, 513* , 519, 602, 638, 929, 934, 1368, 1379* .

pool ptr : 38, \underline{39}, 41, 42, 43, 44, 47, 52* , 58, 70, 198, 260, 464, 465, 470, 516* , 525, 617, 1309* , 1310* , 1332* , 1334, 1339, 1368.

pool size: \underline{11*} , 38, 42, 52* , 58, 198, 525, 1310* ,

1334, 1339, 1368. pop: 584, 585, \underline{586}, 590, 601, 608, 642. pop alignment : \underline{772}, 800. pop input : \underline{322}, 324, 329. pop lig stack : \underline{910}, 911. pop nest : \underline{217}, 796, 799, 812, 816, 1026, 1086,

1096, 1100, 1119, 1145, 1168, 1184, 1206. positive: \underline{107}. post : 583, 585, \underline{586}, 590, 591, 642. post break : \underline{145}, 175, 195, 202, 206, 840, 858,

882, 884, 916, 1119. post disc break : \underline{877}, 881, 884. post display penalty : \underline{236}, 1205, 1206. primitive: \underline{238}. post display penalty code: \underline{236}, 237, 238. post line break : 876, \underline{877}. post post : 585, \underline{586}, 590, 591, 642. pre: 583, 585, \underline{586}, 617. pre break : \underline{145}, 175, 195, 202, 206, 858, 869, 882,

885, 915, 1117, 1119. pre display penalty : \underline{236}, 1203, 1206. primitive: \underline{238}. pre display penalty code: \underline{236}, 237, 238. pre display size: \underline{247}, 1138, 1145, 1148, 1203. primitive: \underline{248}. pre display size code: \underline{247}, 248, 1145. preamble: 768, 774. preamble: \underline{770}, 771, 772, 777, 786, 801, 804. preamble of file: 617. precedes break : \underline{148}, 868, 973, 1000. prefix : \underline{209}, 1208, 1209, 1210, 1211. prefixed command : 1210, \underline{1211}, 1270. prepare mag : \underline{288}, 457, 617, 642, 1333* . pretolerance: \underline{236}, 828, 863. primitive: \underline{238}.

pretolerance code: \underline{236}, 237, 238.
prev break : \underline{821}, 845, 846, 877, 878.
prev depth: 212, \underline{213}, 215, 418, 679, 775, 786, 787,

1025, 1056, 1083, 1099, 1167, 1206, 1242, 1243. primitive: \underline{416}.

prev dp: \underline{970}, 972, 973, 974, 976.

prev graf : 212, \underline{213}, 215, 216, 422, 814, 864, 877,

890, 1091, 1149, 1200, 1242. primitive: \underline{265}. prev p: \underline{862}, 863, 866, 867, 868, 869, \underline{968}, 969,

\underline{970}, 973, \underline{1012}, 1014, 1017, 1022.

prev prev r : \underline{830}, 832, 843, 844, 860.

prev r : \underline{829}, 830, 832, 843, 844, 845, 851, 854, 860.

prev s : \underline{862}, 894, 896.

primitive: 226, 230, 238, 248, \underline{264}, 265, 266, 298, 334, 376, 384, 411, 416, 468, 487, 491, 553, 780, 983, 1052, 1058, 1071, 1088, 1107, 1114, 1141, 1156, 1169, 1178, 1188, 1208, 1219, 1222, 1230, 1250, 1254, 1262, 1272, 1277, 1286, 1291, 1331, 1332* , 1344.

print : 54, \underline{59}, 60, 61* , 62, 63, 68, 70, 71, 73, 85, 86, 89, 91, 94, 95, 175, 177, 178, 182, 183, 184, 185, 186* , 187, 188, 190, 191, 192, 193, 195, 211, 218, 219, 225, 233, 234, 237, 247, 251, 262* , 263, 284, 288, 294, 298, 299, 306, 317, 318, 323, 336, 338, 339, 363, 373, 395, 396, 398, 400, 428, 454, 456, 459, 465, 472, 502, 509, 518, 530, 534* , 536* , 537* , 561, 567, 579, 581, 617, 638, 639, 642, 660, 663, 666, 674, 675, 677, 692, 694, 697, 723, 776, 846, 856, 936, 978, 985, 986, 987, 1006, 1011, 1015, 1024, 1049, 1064, 1095, 1132, 1166, 1213, 1232, 1237, 1257, 1259, 1261, 1280, 1295, 1296, 1298, 1309* , 1311* , 1318* , 1320* , 1322* , 1324* , 1328* , 1333* , 1334, 1335, 1338* , 1339, 1346, 1356. print ASCII : \underline{68}, 174* , 176* , 298, 581, 691, 723. print char : \underline{58}, 59, 60, 64, 65, 66, 67, 69, 70, 82, 91, 94, 95, 103, 114, 171, 172, 174* , 175, 176* , 177, 178, 184, 186* , 187, 188, 189, 190, 191, 193, 218, 219, 223, 229, 233, 234, 235, 242, 251, 252, 255, 262* , 284, 285, 294, 296, 299, 306, 313, 317, 362, 472, 509, 536* , 537* , 561, 581, 617, 638, 639, 642, 691, 723, 846, 856, 933, 1006, 1011, 1065, 1069, 1212, 1213, 1280, 1294, 1296, 1311* , 1320* , 1322* , 1324* , 1328* , 1333* , 1335, 1340, 1355, 1356. print cmd chr : 223, 233, 266, 296, \underline{298}, 299, 323, 336, 418, 428, 503, 510, 1049, 1066, 1128, 1212, 1213, 1237, 1335, 1339. print cs : \underline{262*} , 293, 314, 401.

print current string : \underline{70}, 182, 692.
print delimiter : \underline{691}, 696, 697.

print err : 72, \underline{73}, 93, 94, 95, 98, 288, 336, 338, 346, 370, 373, 395, 396, 398, 403, 408, 415, 418, 428, 433, 434, 435, 436, 437, 442, 445, 446, 454, 456, 459, 460, 475, 476, 479, 486, 500, 503, 510, 530, 561, 577, 579, 641, 723, 776, 783, 784, 792, 826, 936, 937, 960, 961, 962, 963, 976, 978, 993, 1004, 1009, 1015, 1024, 1027, 1028, 1047, 1049, 1064, 1066, 1068, 1069, 1078, 1082, 1084, 1095, 1099, 1110, 1120, 1121, 1127, 1128, 1129, 1132, 1135, 1159, 1161, 1166, 1177, 1183, 1192, 1195, 1197, 1207, 1212, 1213, 1215, 1225, 1232, 1236, 1237, 1243, 1244, 1252, 1258, 1259, 1283, 1298, 1304, 1372.

print esc: \underline{63}, 86, 176* , 184, 187, 188, 189, 190, 191, 192, 194, 195, 196, 197, 225, 227, 229, 231, 233, 234, 235, 237, 239, 242, 247, 249, 251, 262* , 263, 266, 267, 292, 293, 294, 323, 335, 373, 377, 385, 412, 417, 428, 469, 486, 488, 492, 500, 579, 691, 694, 695, 696, 697, 699, 776, 781, 792, 856, 936, 960, 961, 978, 984, 986, 1009, 1015, 1028, 1053, 1059, 1065, 1069, 1072, 1089, 1095, 1099, 1108, 1115, 1120, 1129, 1132, 1135, 1143, 1157, 1166, 1179, 1189, 1192, 1209, 1213, 1220, 1223, 1231, 1244, 1251, 1255, 1263, 1273, 1278, 1287, 1292, 1295, 1322* , 1335, 1346, 1355, 1356.

print fam and char : \underline{691}, 692, 696. print file name: \underline{518}, 530, 561, 1322* , 1356. print font and char : \underline{176*} , 183, 193. print glue: \underline{177}, 178, 185, 186* . print hex : \underline{67}, 691, 1223. print int : \underline{65}, 91, 94, 103, 114, 168, 169, 170, 171,

172, 185, 188, 194, 195, 218, 219, 227, 229, 231, 233, 234, 235, 239, 242, 249, 251, 255, 285, 288, 313, 336, 400, 465, 472, 509, 536* , 561, 579, 617, 638, 639, 642, 660, 663, 667, 674, 675, 678, 691, 723, 846, 856, 933, 986, 1006, 1009, 1011, 1024, 1028, 1099, 1232, 1296, 1309* , 1311* , 1318* , 1320* , 1324* , 1328* , 1335, 1339, 1355, 1356.

print length param: \underline{247}, 249, 251. print ln: \underline{57}, 58, 59, 60, 61* , 62, 71, 86, 89, 90,

114, 182, 198, 218, 236, 245, 296, 306, 314, 317, 330, 360, 363, 401, 484, 534* , 537* , 638, 639, 660, 663, 666, 667, 674, 675, 677, 678, 692, 986, 1265, 1280, 1309* , 1311* , 1318* , 1320* , 1324* , 1333* , 1340, 1370.

print locs : \underline{167}. print mark : \underline{176*} , 196, 1356. print meaning : \underline{296}, 472, 1294. print mode: \underline{211}, 218, 299, 1049. print nl : \underline{62}, 73, 82, 85, 90, 168, 169, 170, 171,

172, 218, 219, 245, 255, 285, 288, 299, 306, 311, 313, 314, 323, 360, 400, 530, 534* , 581, 638, 639, 641, 642, 660, 666, 667, 674, 677, 678, 846, 856, 857, 863, 933, 986, 987, 992, 1006, 1011, 1121, 1294, 1296, 1297, 1322* , 1324* , 1328* , 1333* , 1335, 1338* , 1370.

print param: \underline{237}, 239, 242.

print plus : \underline{985}.
print plus end : \underline{985}.
print roman int : \underline{69}, 472.
print rule dimen: \underline{176*} , 187.

print scaled : \underline{103}, 114, 176* , 177, 178, 184, 188, 191, 192, 219, 251, 465, 472, 561, 666, 677, 697, 985, 986, 987, 1006, 1011, 1259, 1261, 1322* .

print size: \underline{699}, 723, 1231.

print skip param: 189, \underline{225}, 227, 229. print spec: \underline{178}, 188, 189, 190, 229, 465. print style: 690, \underline{694}, 1170. print subsidiary data: \underline{692}, 696, 697. print the digs : \underline{64}, 65, 67. print totals : 218, \underline{985}, 986, 1006. print two: \underline{66}, 536* , 617. print word : \underline{114}, 1339. print write whatsit : \underline{1355}, 1356. printed node: \underline{821}, 856, 857, 858, 864. privileged : \underline{1051}, 1054, 1130, 1140. prompt file name: \underline{530}, 532, 535, 537* , 1328* , 1374. prompt input : \underline{71}, 83, 87, 360, 363, 484, 530. prune movements : \underline{615}, 619, 629. prune page top: \underline{968}, 977, 1021. pseudo: \underline{54}, 57, 58, 59, 60, 316. pstack : \underline{388}, 390, 396, 400. : 453. punct noad : \underline{682}, 690, 696, 698, 728, 752, 761,

1156, 1157. push: 584, 585, \underline{586}, 590, 592, 601, 608, 616,

619, 629. push alignment : \underline{772}, 774.

push input : \underline{321}, 323, 325, 328.

push math: \underline{1136}, 1139, 1145, 1153, 1172, 1174,

1191. push nest : \underline{216}, 774, 786, 787, 1025, 1083, 1091, 1099, 1117, 1119, 1136, 1167, 1200.

put : 26, 29.

put rule: 585, \underline{586}, 633.

put1 : \underline{585}. put2 : \underline{585}. put3 : \underline{585}. put4 : \underline{585}. q: \underline{123}, \underline{125}, \underline{130}, \underline{131}, \underline{144}, \underline{151}, \underline{152}, \underline{153}, \underline{167}, \underline{172}, \underline{202}, \underline{204}, \underline{218}, \underline{275}, \underline{292}, \underline{315}, \underline{336}, \underline{366}, \underline{389}, \underline{407}, \underline{450}, \underline{461}, \underline{463}, \underline{464}, \underline{465}, \underline{473}, \underline{482}, \underline{497}, \underline{498}, \underline{607}, \underline{649}, \underline{705}, \underline{706}, \underline{709}, \underline{712}, \underline{720}, \underline{726}, \underline{734}, \underline{735}, \underline{736}, \underline{737}, \underline{738}, \underline{743}, \underline{749}, \underline{752}, \underline{756}, \underline{762}, \underline{791}, \underline{800}, \underline{826}, \underline{830}, \underline{862}, \underline{877}, \underline{901}, \underline{906}, \underline{934}, \underline{948*} , \underline{953}, \underline{957}, \underline{959}, \underline{960}, \underline{968}, \underline{970}, \underline{994}, \underline{1012}, \underline{1043}, \underline{1068}, \underline{1079}, \underline{1093}, \underline{1105}, \underline{1119}, \underline{1123}, \underline{1138}, \underline{1184}, \underline{1198}, \underline{1211}, \underline{1236}, \underline{1302*} , \underline{1303*} , \underline{1348}, \underline{1370}.

qi : \underline{112*} , 545, 549, 564* , 570, 573, 576, 582, 620, 753, 907, 908, 911, 913, 923, 958, 959, 981, 1008, 1009, 1034, 1035, 1038, 1039, 1040, 1100, 1151, 1155, 1160, 1165, 1309* , 1325* .

qo: \underline{112*} , 159, 174* , 176* , 185, 188, 554, 570, 576, 602, 620, 691, 708, 722, 723, 741, 752, 755, 896, 897, 898, 903, 909, 923, 945, 981, 986, 1008, 1018, 1021, 1039, 1310* , 1324* , 1325* .

qqqq : 110* , 114, 550, 554, 569, 573, 574, 683, 713,

741, 752, 909, 1039, 1181. quad : 547, \underline{558}, 1146. quad code: \underline{547}, 558. quarterword : 110* , \underline{113*} , 144, 212, 253* , 264, 271,

276, 277, 279, 281, 298, 300, 323, 592, 681, 706, 709, 711, 712, 724, 738, 749, 877, 921, 943* , 944* , 947, 960, 1061, 1079, 1105.

qw : \underline{560}, 564* , 570, 573, 576. r: \underline{108}, \underline{123}, \underline{125}, \underline{131}, \underline{204}, \underline{218}, \underline{366}, \underline{389}, \underline{465}, \underline{482},

\underline{498}, \underline{649}, \underline{668}, \underline{706}, \underline{720}, \underline{726}, \underline{752}, \underline{791}, \underline{800}, \underline{829}, \underline{862}, \underline{877}, \underline{901}, \underline{953}, \underline{966}, \underline{970}, \underline{994}, \underline{1012}, \underline{1123}, \underline{1160}, \underline{1198}, \underline{1236}, \underline{1348}, \underline{1370}.

r count : \underline{912}, 914, 918. r hyf : 891, \underline{892}, 894, 899, 902, 923, 1362. r type: \underline{726}, 727, 728, 729, 760, 766, 767. radical : \underline{208}, 265, 266, 1046, 1162. primitive: \underline{265}. radical noad : \underline{683}, 690, 696, 698, 733, 761, 1163. radical noad size: \underline{683}, 698, 761, 1163. radix : 366, \underline{438}, 439, 440, 444, 445, 448. radix backup: \underline{366}. primitive: \underline{1071}. Ramshaw, Lyle Harold: 539. rbrace ptr : \underline{389}, 399, 400. read : 52* , 53* , 1338* , 1339. primitive: \underline{265}. read file: \underline{480}, 485, 486, 1275* . read font info: \underline{560}, 564* , 1040, 1257. read ln: 52* . read open: \underline{480}, 481, 483, 485, 486, 501, 1275* . read sixteen: \underline{564*} , 565, 568. read to cs : \underline{209}, 265, 266, 1210, 1225. read toks : 303, \underline{482}, 1225. ready already : 81* , \underline{1331}, 1332* . real : 3, 109* , 110* , 182, 186* , 1123, 1125. real addition: 1125. real division: 658, 664, 673, 676, 810, 811,

1123, 1125. real multiplication: 114, 186* , 625, 634, 809, 1125. rebox : \underline{715}, 744, 750. reconstitute: 905, \underline{906}, 913, 915, 916, 917, 1032. recursion: 76, 78, 173, 180, 198, 202, 203, 366, 402,

527, 592, 618, 692, 719, 949, 957, 959, 1375. ref count : \underline{389}, 390, 401. reference counts: 150, 200, 201, 203, 275, 291, 307. register : \underline{209}, 411, 412, 413, 1210, 1235, 1236,

1237. rel noad : \underline{682}, 690, 696, 698, 728, 761, 767,

1156, 1157. rel penalty : \underline{236}, 682, 761. primitive: \underline{238}. rel penalty code: \underline{236}, 237, 238. relax : \underline{207}, 265, 266, 358, 372, 404, 506, 1045, 1224. primitive: \underline{265}. rem byte: \underline{545}, 554, 557, 570, 708, 713, 740,

749, 753, 911, 1040. remainder : \underline{104}, 106, 107, 457, 458, \underline{543}, 544,

545, 716, 717. remove item: \underline{208}, 1104, 1107, 1108. rep: \underline{546}. replace count : \underline{145}, 175, 195, 840, 858, 869, 882,

883, 918, 1081, 1105, 1120. report illegal case: 1045, \underline{1050}, 1051, 1243, 1377. reset : 26. restart : \underline{15}, 125, 126, 341, 346, 357, 359, 360, 362,

380, 752, 753, 782, 785, 789, 1151, 1215. restore old value: \underline{268}, 276, 282. restore trace: 283, \underline{284}. restore zero: \underline{268}, 276, 278. result : \underline{45}, \underline{46}. resume after display : 800, 1199, \underline{1200}, 1206. reswitch: \underline{15}, 341, 343, 352, 463, 619, 620, 649,

651, 652, 726, 728, 934, 935, 1029, 1030, 1036, 1045, 1138, 1147, 1151.

return: 15, \underline{16*} . rewrite: 26. rh: 110* , 114, 118, 213, 219, 221, 234, 256, 268,

685, 921, 958. rhm field : \underline{212}, 213, 218. rhmin: 212, \underline{213}, 215, 891, 1091. primitive: \underline{1188}. right brace: \underline{207}, 289, 294, 298, 347, 357, 389, 442,

474, 477, 785, 935, 961, 1067, 1252. right brace limit : \underline{289}, 325, 392, 399, 400, 474, 477. right brace token: \underline{289}, 339, 1065, 1127, 1226,

1371. right delimiter : \underline{683}, 697, 748, 1181, 1182. right hyphen min: \underline{236}, 1091, 1376, 1377. primitive: \underline{238}. right hyphen min code: \underline{236}, 237, 238. right noad : \underline{687}, 690, 696, 698, 725, 728, 760,

761, 762, 1184, 1188, 1191. right ptr : \underline{605}, 606, 607, 615. right skip: \underline{224}, 827, 880, 881. primitive: \underline{226}. right skip code: \underline{224}, 225, 226, 881, 886. right1 : 585, \underline{586}, 607, 610, 616. right2 : 585, 610. right3 : 585, 610. right4 : 585, 610. rlink : \underline{124}, 125, 126, 127* , 129, 130, 131, 132, 145,

149, 164, 169, 772, 819, 821, 1311* , 1312* . primitive: \underline{468}. roman numeral code: \underline{468}, 469, 471, 472. round : 114, 186* , 625, 634, 809, 1125. round decimals : \underline{102}, 103, 452. rover : \underline{124}, 125, 126, 127* , 128, 129, 130, 131,

132, 164, 169, 1311* , 1312* . rt hit : 906, \underline{907}, 910, 911, 1033, 1035, 1040. rule dp: \underline{592}, 622, 624, 626, 631, 633, 635. rule ht : \underline{592}, 622, 624, 626, 631, 633, 634, 635, 636. rule node: \underline{138}, 139, 148, 175, 183, 202, 206, 622,

626, 631, 635, 651, 653, 669, 670, 730, 761, 805, 841, 842, 866, 870, 871, 968, 973, 1000, 1074, 1087, 1121, 1147.

rule node size: \underline{138}, 139, 202, 206. rule save: \underline{800}, 804. rule wd : \underline{592}, 622, 624, 625, 626, 627, 631,

633, 635. rules aligning with characters: 589. runaway : 120, \underline{306}, 338, 396, 486. : 306. s: \underline{45}, \underline{46}, \underline{58}, \underline{59}, \underline{60}, \underline{62}, \underline{63}, \underline{93}, \underline{94}, \underline{95}, \underline{103}, \underline{108},

\underline{125}, \underline{130}, \underline{147}, \underline{177}, \underline{178}, \underline{264}, \underline{284}, \underline{389}, \underline{407}, \underline{473}, \underline{482}, \underline{529}, \underline{530}, \underline{560}, \underline{638}, \underline{645}, \underline{649}, \underline{668}, \underline{688}, \underline{699}, \underline{706}, \underline{720}, \underline{726}, \underline{738}, \underline{791}, \underline{800}, \underline{830}, \underline{862}, \underline{877}, \underline{901}, \underline{934}, \underline{966}, \underline{987}, \underline{1012}, \underline{1060}, \underline{1061}, \underline{1123}, \underline{1138}, \underline{1198}, \underline{1236}, \underline{1257}, \underline{1279}, \underline{1349}, \underline{1355}.

save cond ptr : \underline{498}, 500, 509. save cs ptr : \underline{774}, 777. save cur val : \underline{450}, 455. save for after : \underline{280}, 1271. save h: \underline{619}, 623, 627, 628, \underline{629}, 632, 637. save index : \underline{268}, 274, 276, 280, 282. save level : \underline{268}, 269, 274, 276, 280, 282. save link : \underline{830}, 857. save loc: \underline{619}, \underline{629}. save ptr : 268, \underline{271}, 272, 273, 274, 276, 280, 282,

283, 285, 645, 804, 1086, 1099, 1100, 1117, 1120, 1142, 1153, 1168, 1172, 1174, 1186, 1194, 1304.

save scanner status : \underline{366}, 369, \underline{389}, \underline{470}, 471,

\underline{494}, \underline{498}, 507. save size: \underline{11*} , 111, 271, 273, 1334. save split top skip: \underline{1012}, 1014.

save stack : 203, 268, 270, \underline{271}, 273, 274, 275, 276,

277, 281, 282, 283, 285, 300, 372, 489, 645, 768, 1062, 1071, 1131, 1140, 1150, 1153, 1339.

save style: \underline{720}, \underline{726}, 754.

save type: \underline{268}, 274, 276, 280, 282.
save v : \underline{619}, 623, 628, \underline{629}, 632, 636, 637.
save vbadness : \underline{1012}, 1017.
save vfuzz : \underline{1012}, 1017.
save warning index : \underline{389}.

saved : \underline{274}, 645, 804, 1083, 1086, 1099, 1100, 1117, 1119, 1142, 1153, 1168, 1172, 1174, 1186, 1194.

sc: 110* , \underline{113*} , 114, 135, 150, 159, 164, 213, 219, 247, 250, 251, 413, 420, 425, 550, 552, 554, 557, 558, 571, 573, 575* , 580, 700, 701, 775, 822, 823, 832, 843, 844, 848, 850, 860, 861, 889, 1042, 1149, 1206, 1247, 1248, 1253.

scaled : \underline{101}, 102, 103, 104, 105, 106, 107, 108, 110* , 113* , 147, 150, 156, 176* , 177, 447, 448, 450, 453, 548, 549, 560, 584, 592, 607, 616, 619, 629, 646, 649, 668, 679, 704, 705, 706, 712, 715, 716, 717, 719, 726, 735, 736, 737, 738, 743, 749, 756, 762, 791, 800, 823, 830, 839, 847, 877, 906, 970, 971, 977, 980, 982, 994, 1012, 1068, 1086, 1123, 1138, 1198, 1257.

: 1258.

scaled base: \underline{247}, 249, 251, 1224, 1237.

scan box : 1073, \underline{1084}, 1241.

scan char num: 414, \underline{434}, 935, 1030, 1038, 1123,

1124, 1151, 1154, 1224, 1232. scan delimiter : \underline{1160}, 1163, 1182, 1183, 1191, 1192. scan dimen: 410, 440, 447, \underline{448}, 461, 462, 1061. scan eight bit int : 415, 420, 427, \underline{433}, 505, 1079, 1082, 1099, 1110, 1224, 1226, 1227, 1237, 1241, 1247, 1296.

scan fifteen bit int : \underline{436}, 1151, 1154, 1165, 1224. scan file name: 265, 334, \underline{526}, 527, 537* , 1257,

1275* , 1351. scan font ident : 415, 426, 471, \underline{577}, 578, 1234,

1253. scan four bit int : \underline{435}, 501, 577, 1234, 1275* , 1350. scan glue: 410, \underline{461}, 782, 1060, 1228, 1238. scan int : 409, 410, 432, 433, 434, 435, 436, 437,

438, \underline{440}, 447, 448, 461, 471, 503, 504, 509, 578, 1103, 1225, 1228, 1232, 1238, 1240, 1243, 1244, 1246, 1248, 1253, 1258, 1350, 1377. scan keyword : 162, \underline{407}, 453, 454, 455, 456, 458, 462, 463, 645, 1082, 1225, 1236, 1258. scan left brace: \underline{403}, 473, 645, 785, 934, 960, 1025,

1099, 1117, 1119, 1153, 1172, 1174. scan math: 1150, \underline{1151}, 1158, 1163, 1165, 1176. scan normal dimen: \underline{448}, 463, 503, 645, 1073, 1082, 1182, 1183, 1228, 1238, 1243, 1245,

1247, 1248, 1253, 1259. scan optional equals : \underline{405}, 782, 1224, 1226, 1228,

1232, 1234, 1236, 1241, 1243, 1244, 1245, 1246, 1247, 1248, 1253, 1257, 1275* , 1351.

scan rule spec: \underline{463}, 1056, 1084. scan something internal : 409, 410, \underline{413}, 432, 440,

449, 451, 455, 461, 465. scan spec: \underline{645}, 768, 774, 1071, 1083, 1167. scan toks : 291, 464, \underline{473}, 960, 1101, 1218, 1226,

1279, 1288, 1352, 1354, 1371. scan twenty seven bit int : \underline{437}, 1151, 1154, 1160. scanned result : \underline{413}, 414, 415, 418, 422, 425,

426, 428. scanned result end : \underline{413}. scanner status : \underline{305}, 306, 331, 336, 339, 366,

369, 389, 391, 470, 471, 473, 482, 494, 498, 507, 777, 789.

primitive: \underline{1230}. script mlist : \underline{689}, 695, 698, 731, 1174. primitive: \underline{1230}. script script mlist : \underline{689}, 695, 698, 731, 1174. script script size: \underline{699}, 756, 1195, 1230. script script style: \underline{688}, 694, 731, 1169. primitive: \underline{1169}. script size: \underline{699}, 756, 1195, 1230. script space: \underline{247}, 757, 758, 759. primitive: \underline{248}. script space code: \underline{247}, 248. script style: \underline{688}, 694, 702, 703, 731, 756, 762,

766, 1169. primitive: \underline{1169}. scripts allowed : \underline{687}, 1176. scroll mode: 71, \underline{73}, 84* , 86, 93, 530, 1262,

1263, 1281. primitive: \underline{1262}. search mem: 165* , \underline{172}, 255, 1339. second indent : \underline{847}, 848, 849, 889. second pass : \underline{828}, 863, 866. second width: \underline{847}, 848, 849, 850, 889. Sedgewick, Robert: 2* . : 1335. selector : \underline{54}, 55, 57, 58, 59, 60, 62, 71, 75, 86,

90, 92, 98, 245, 311, 312, 316, 360, 465, 470, 534* , 535, 617, 638, 1257, 1265, 1279, 1298, 1328* , 1333* , 1335, 1368, 1370.

semi simple group: \underline{269}, 1063, 1065, 1068, 1069. serial : \underline{821}, 845, 846, 856. set aux : \underline{209}, 413, 416, 417, 418, 1210, 1242. set box : \underline{209}, 265, 266, 1210, 1241. primitive: \underline{265}. set box dimen: \underline{209}, 413, 416, 417, 1210, 1242. set break width to background : \underline{837}. set char 0 : 585, \underline{586}, 620. set conversion: \underline{458}. set conversion end : \underline{458}. set cur lang : \underline{934}, 960. set cur r : \underline{908}, 910, 911. set font : \underline{209}, 413, 553, 577, 1210, 1217, 1257,

1261. set glue ratio one: \underline{109*} , 664, 676, 810, 811. set glue ratio zero: \underline{109*} , 136, 657, 658, 664, 672,

673, 676, 810, 811. set height zero: \underline{970}. set interaction: \underline{209}, 1210, 1262, 1263, 1264. primitive: \underline{1344}. set language code: \underline{1344}, 1346, 1348. set math char : 1154, \underline{1155}. set page dimen: \underline{209}, 413, 982, 983, 984, 1210,

1242. set page int : \underline{209}, 413, 416, 417, 1210, 1242. set page so far zero: \underline{987}. set paths : 1332* . set prev graf : \underline{209}, 265, 266, 413, 1210, 1242. set rule: 583, 585, \underline{586}, 624. set shape: \underline{209}, 265, 266, 413, 1210, 1248. set trick count : \underline{316}, 317, 318, 320. set1 : 585, \underline{586}, 620. set2 : \underline{585}. set3 : \underline{585}. set4 : \underline{585}. sf code: \underline{230}, 232, 1034. primitive: \underline{1230}. sf code base: \underline{230}, 235, 1230, 1231, 1233. shape ref : \underline{210}, 232, 275, 1070, 1248. shift amount : \underline{135}, 136, 159, 184, 623, 628, 632,

637, 649, 653, 668, 670, 681, 706, 720, 737, 738, 749, 750, 756, 757, 759, 799, 806, 807, 808, 889, 1076, 1081, 1125, 1146, 1203, 1204, 1205.

shift case: 1285, \underline{1288}. shift down: \underline{743}, 744, 745, 746, 747, \underline{749}, 751,

\underline{756}, 757, 759. shift up: \underline{743}, 744, 745, 746, 747, \underline{749}, 751,

\underline{756}, 758, 759. ship out : 211, 592, \underline{638}, 644, 1023, 1075. primitive: \underline{1071}. ship out flag : \underline{1071}, 1075. short display : 173, \underline{174*} , 175, 193, 663, 857, 1339. short real : 109* , 110* . shortcut : 447, \underline{448}. shortfall : \underline{830}, 851, 852, 853. shorthand def : \underline{209}, 1210, 1222, 1223, 1224. primitive: \underline{1291}. show activities : \underline{218}, 1293. show box : 180, 182, \underline{198}, 218, 219, 236, 638, 641,

663, 675, 986, 992, 1121, 1296, 1339. primitive: \underline{1291}. show box breadth: \underline{236}, 1339. primitive: \underline{238}. show box breadth code: \underline{236}, 237, 238. show box code: \underline{1291}, 1292, 1293. show box depth: \underline{236}, 1339. primitive: \underline{238}. show box depth code: \underline{236}, 237, 238. show code: \underline{1291}, 1293. show context : 54, 78, 82, 88, 310, \underline{311}, 318,

530, 535, 537* . show cur cmd chr : \underline{299}, 367, 1031. show eqtb: \underline{252}, 284. show info: 692, \underline{693}. show lists : \underline{1291}, 1292, 1293. primitive: \underline{1291}. show node list : 173, 176* , 180, 181, \underline{182}, 195, 198,

233, 690, 692, 693, 695, 1339. primitive: \underline{1291}. show the code: \underline{1291}, 1292. show token list : 176* , 223, 233, \underline{292}, 295, 306, 319,

320, 400, 1339, 1368. show whatever : 1290, \underline{1293}. shown mode: \underline{213}, 215, 299. shrink : \underline{150}, 151, 164, 178, 431, 462, 625, 634, 656,

671, 716, 809, 825, 827, 838, 868, 976, 1004, 1009, 1042, 1044, 1148, 1229, 1239, 1240.

shrink order : \underline{150}, 164, 178, 462, 625, 634, 656, 671, 716, 809, 825, 826, 976, 1004, 1009, 1148, 1239.

shrinking : \underline{135}, 186* , 619, 629, 664, 676, 809,

810, 811, 1148. si : \underline{38}, 42, 69, 951, 964, 1310* . simple group: \underline{269}, 1063, 1068. Single-character primitives: \underline{267}.

: \underline{1114}.

: \underline{265}.

␣ : \underline{265}. single base: \underline{222}, 262* , 263, 264, 354, 374, 442,

1257, 1289. skew char : 426, \underline{549}, 552, 576, 741, 1253, 1322* ,

1323* . primitive: \underline{1254}. skip: \underline{224}, 427, 1009. primitive: \underline{411}. skip base: \underline{224}, 227, 229, 1224, 1237. skip blanks : \underline{303}, 344, 345, 347, 349, 354. skip byte: \underline{545}, 557, 741, 752, 753, 909, 1039. skip code: \underline{1058}, 1059, 1060. primitive: \underline{1222}.

skip def code: \underline{1222}, 1223, 1224.
skip line: 336, \underline{493}, 494.
skipping : \underline{305}, 306, 336, 494.
slant : 547, \underline{558}, 575* , 1123, 1125.
slant code: \underline{547}, 558.
slow print : \underline{60}, 262* , 263.
small char : \underline{683}, 691, 697, 706, 1160.
small fam: \underline{683}, 691, 697, 706, 1160.
small node size: \underline{141}, 144, 145, 147, 152, 153, 156,

158, 202, 206, 655, 721, 903, 910, 914, 1037, 1100, 1101, 1357, 1358, 1376, 1377. small number : \underline{101}, 102, 147, 152, 154, 264, 366, 389, 413, 438, 440, 450, 461, 470, 482, 489, 494, 497, 498, 523, 607, 649, 668, 688, 706, 719, 720, 726, 756, 762, 829, 892, 893, 905, 906, 921, 934, 944* , 960, 970, 987, 1060, 1086, 1091, 1176, 1181, 1191, 1198, 1211, 1236, 1247, 1257, 1335, 1349, 1350, 1370, 1373. so: \underline{38}, 45, 59, 60, 69, 70, 264, 407, 464, 519, 603, 617, 766, 931, 953, 955, 956, 959, 963, 1309* , 1368.

: 524* .

sort avail : \underline{131}, 1311* .

sp: 104, 587. : 458. space: 547, \underline{558}, 752, 755, 1042. space code: \underline{547}, 558, 578, 1042. space factor : 212, \underline{213}, 418, 786, 787, 799, 1030,

1034, 1043, 1044, 1056, 1076, 1083, 1091, 1093, 1117, 1119, 1123, 1196, 1200, 1242, 1243.

primitive: \underline{416}.

space shrink : 547, \underline{558}, 1042.
space shrink code: \underline{547}, 558, 578.
space skip: \underline{224}, 1041, 1043.
primitive: \underline{226}.
space skip code: \underline{224}, 225, 226, 1041.
space stretch: 547, \underline{558}, 1042.
space stretch code: \underline{547}, 558.
space token: \underline{289}, 393, 464, 1215.

spacer : \underline{207}, 208, 232, 289, 291, 294, 298, 303, 337, 345, 347, 348, 349, 354, 404, 406, 407, 443, 444, 452, 464, 783, 935, 961, 1030, 1045, 1221.

primitive: \underline{780}.

span code: \underline{780}, 781, 782, 789, 791.
span count : 136, \underline{159}, 185, 796, 801, 808.
span node size: \underline{797}, 798, 803.
spec code: \underline{645}.
primitive: \underline{1344}.

special node: \underline{1341}, 1344, 1346, 1348, 1354, 1356,

1357, 1358, 1373. special out : \underline{1368}, 1373. : 1011. split bot mark : \underline{382}, 383, 977, 979. primitive: \underline{384}. split bot mark code: \underline{382}, 384, 385. split first mark : \underline{382}, 383, 977, 979. primitive: \underline{384}. split first mark code: \underline{382}, 384, 385. split max depth: 140, \underline{247}, 977, 1068, 1100. primitive: \underline{248}. split max depth code: \underline{247}, 248. split top ptr : \underline{140}, 188, 202, 206, 1021, 1022, 1100. split top skip: 140, \underline{224}, 968, 977, 1012, 1014,

1021, 1100. primitive: \underline{226}. split top skip code: \underline{224}, 225, 226, 969. split up: \underline{981}, 986, 1008, 1010, 1020, 1021. spotless : \underline{76}, 77, 81* , 245, 1332* , 1335. : 645. sprint cs : 223, \underline{263}, 338, 395, 396, 398, 472,

479, 484, 561, 1294. square roots: 737. ss code: \underline{1058}, 1059, 1060. ss glue: \underline{162}, 164, 715, 1060. stack conventions: 300. stack into box : \underline{711}, 713. stack size: \underline{11*} , 301, 310, 321, 1334. start : 300, \underline{302}, 303, 307, 318, 319, 323, 324, 325,

328, 329, 331, 360, 362, 363, 369, 483, 538. start cs : \underline{341}, 354, 355. start eq no: 1140, \underline{1142}. start field : \underline{300}, 302. start font error message: \underline{561}, 567. start here: 5, \underline{1332*} . start input : 366, 376, 378, \underline{537*} , 1337. start of TEX : \underline{6*} , 1332* . start par : \underline{208}, 1088, 1089, 1090, 1092. stat: \underline{7*} , \underline{117}, \underline{120}, \underline{121}, \underline{122}, \underline{123}, \underline{125}, \underline{130}, \underline{252},

\underline{260}, \underline{283}, \underline{284}, \underline{639}, \underline{829}, \underline{845}, \underline{855}, \underline{863}, \underline{987},

\underline{1005}, \underline{1010}, \underline{1333*} .

state: 87, 300, \underline{302}, 303, 307, 311, 312, 323, 325, 328, 330, 331, 337, 341, 343, 344, 346, 347, 349, 352, 353, 354, 390, 483, 537* .

state field : \underline{300}, 302. stdin: 32* . stdout : 32* . stomach: 402. stop: \underline{207}, 1045, 1046, 1052, 1053, 1054, 1094. stop flag : \underline{545}, 557, 741, 752, 753, 909, 1039. store background : \underline{864}. store break width: \underline{843}. store fmt file: \underline{1302*} , 1335. store four quarters : \underline{564*} , 568, 569, 573, 574.

store new token: \underline{371}, 372, 393, 397, 399, 407, 464,

466, 473, 474, 476, 477, 482, 483. store scaled : \underline{571}, 573, 575* .

str eq buf : \underline{45}, 259.
str eq str : \underline{46}, 1260.

str number : \underline{38}, 39, 43, 45, 46, 47, 62, 63, 79, 93, 94, 95, 177, 178, 264, 284, 407, 512, 519, 525, 527, 529, 530, 532, 549, 560, 926, 929, 934, 1257, 1279, 1299, 1355.

str pool : 38, \underline{39}, 42, 43, 45, 46, 47, 59, 60, 69, 70, 256, 260, 264, 303, 407, 464, 519, 602, 603, 617, 638, 764, 766, 929, 931, 934, 941, 1309* , 1310* , 1333* , 1334, 1368, 1380* .

str ptr : 38, \underline{39}, 41, 43, 44, 47, 59, 60, 70, 260, 262* , 517, 525, 617, 1309* , 1310* , 1325* , 1327* , 1332* , 1334, 1368.

str room: \underline{42}, 180, 260, 464, 516* , 525, 939, 1257,

1279, 1328* , 1333* , 1368. str start : 38, \underline{39}, 40, 41, 43, 44, 45, 46, 47, 59, 60, 69, 70, 84* , 256, 260, 264, 407, 517, 519, 603, 617, 765, 929, 931, 934, 941, 1309* , 1310* , 1368.

str toks : \underline{464}, 465, 470.

stretch: \underline{150}, 151, 164, 178, 431, 462, 625, 634, 656, 671, 716, 809, 827, 838, 868, 976, 1004, 1009, 1042, 1044, 1148, 1229, 1239, 1240. stretch order : \underline{150}, 164, 178, 462, 625, 634, 656, 671, 716, 809, 827, 838, 868, 976, 1004, 1009, 1148, 1239.

stretching : \underline{135}, 625, 634, 658, 673, 809, 810,

811, 1148. string pool: 47, 1308* . primitive: \underline{468}. string code: \underline{468}, 469, 471, 472. string vacancies : \underline{11*} , 52* . strlen: 51* . style: \underline{726}, 760, 761, \underline{762}. style node: 160, \underline{688}, 690, 698, 730, 731, 761, 1169. style node size: \underline{688}, 689, 698, 763. sub box : \underline{681}, 687, 692, 698, 720, 734, 735, 737,

738, 749, 754, 1076, 1093, 1168. sub drop: \underline{700}, 756.

sub mark : \underline{207}, 294, 298, 347, 1046, 1175.

sub mlist : \underline{681}, 683, 692, 720, 742, 754, 1181,

1185, 1186, 1191. sub style: \underline{702}, 750, 757, 759.

sub sup: 1175, \underline{1176}.

subscr : \underline{681}, 683, 686, 687, 690, 696, 698, 738, 742, 749, 750, 751, 752, 753, 754, 755, 756, 757, 759, 1151, 1163, 1165, 1175, 1176, 1177, 1186.

subscripts: 754, 1175.

subtype: \underline{133}, 134, 135, 136, 139, 140, 143, 144, 145, 146, 147, 149, 150, 152, 153, 154, 155, 156, 158, 159, 188, 189, 190, 191, 192, 193, 424, 489, 495, 496, 625, 627, 634, 636, 649, 656, 668, 671, 681, 682, 686, 688, 689, 690, 696, 717, 730, 731, 732, 733, 749, 763, 766, 768, 786, 795, 809, 819, 820, 822, 837, 842, 843, 844, 866, 879, 881, 896, 897, 899, 903, 910, 981, 986, 988, 1008, 1009, 1018, 1020, 1021, 1035, 1060, 1061, 1078, 1100, 1101, 1113, 1125, 1148, 1159, 1163, 1165, 1171, 1181, 1335, 1341, 1349, 1356, 1357, 1358, 1362, 1373, 1374.

sub1 : \underline{700}, 757. sub2 : \underline{700}, 759. succumb: \underline{93}, 94, 95, 1304. sup drop: \underline{700}, 756. sup mark : \underline{207}, 294, 298, 344, 355, 1046, 1175,

1176, 1177. sup style: \underline{702}, 750, 758. superscripts: 754, 1175. supscr : \underline{681}, 683, 686, 687, 690, 696, 698, 738,

742, 750, 751, 752, 753, 754, 756, 758, 1151, 1163, 1165, 1175, 1176, 1177, 1186.

sup1 : \underline{700}, 758. sup2 : \underline{700}, 758. sup3 : \underline{700}, 758. sw : \underline{560}, 571, 575* . switch: \underline{341}, 343, 344, 346, 350. synch h: \underline{616}, 620, 624, 628, 633, 637, 1368. synch v : \underline{616}, 620, 624, 628, 632, 633, 637, 1368. system dependencies: 2* , \underline{3}, 9* , 10, 11* , 12* , 19* , 21,

23* , 26, 32* , 34* , 35, 37* , 49, 56, 59, 72, 81* , 84* , 96, 109* , 110* , 112* , 113* , 161, 186* , 241* , 304, 313, 328, 485, 511, 512, 513* , 514* , 515, 516* , 517, 518, 519, 520* , 521* , 523, 525, 538, 557, 564* , 591, 595, 597* , 1331, 1332* , 1333* , 1338* , 1340.

s1 : \underline{82}, 88. s2 : \underline{82}, 88. s3 : \underline{82}, 88. s4 : \underline{82}, 88. t: \underline{46}, \underline{107}, \underline{108}, \underline{125}, \underline{218}, \underline{277}, \underline{279}, \underline{280}, \underline{281}, \underline{323},

\underline{341}, \underline{366}, \underline{389}, \underline{464}, \underline{473}, \underline{704}, \underline{705}, \underline{726}, \underline{756}, \underline{800}, \underline{830}, \underline{877}, \underline{906}, \underline{934}, \underline{966}, \underline{970}, \underline{1030}, \underline{1123}, \underline{1176}, \underline{1191}, \underline{1198}, \underline{1257}, \underline{1288}.

t open in: 33* , 37* . t open out : \underline{33*} , 1332* . tab mark : \underline{207}, 289, 294, 342, 347, 780, 781, 782,

783, 784, 788, 1126. tab skip: \underline{224}. primitive: \underline{226}. tab skip code: \underline{224}, 225, 226, 778, 782, 786,

795, 809. tab token: \underline{289}, 1128. tag : \underline{543}, 544, 554.

tail : 212, \underline{213}, 214, 215, 216, 424, 679, 718, 776,

786, 795, 796, 799, 812, 816, 888, 890, 995, 1017, 1023, 1026, 1034, 1035, 1036, 1037, 1040, 1041, 1043, 1054, 1060, 1061, 1076, 1078, 1080, 1081, 1091, 1096, 1100, 1101, 1105, 1110, 1113, 1117, 1119, 1120, 1123, 1125, 1145, 1150, 1155, 1158, 1159, 1163, 1165, 1168, 1171, 1174, 1176, 1177, 1181, 1184, 1186, 1187, 1191, 1196, 1205, 1206, 1349, 1350, 1351, 1352, 1353, 1354, 1375, 1376, 1377.

tail append : \underline{214}, 786, 795, 816, 1035, 1036, 1037, 1040, 1054, 1056, 1060, 1061, 1091, 1093, 1100, 1103, 1112, 1113, 1117, 1150, 1158, 1163, 1165, 1168, 1171, 1172, 1177, 1191, 1196, 1203, 1205, 1206.

tail field : \underline{212}, 213, 995.

tally : \underline{54}, 55, 57, 58, 292, 312, 315, 316, 317.
tats: \underline{7*} .

temp head : \underline{162}, 306, 391, 396, 400, 464, 466, 467, 470, 478, 719, 720, 754, 760, 816, 862, 863, 864, 877, 879, 880, 881, 887, 968, 1064, 1065, 1194, 1196, 1199, 1297.

temp ptr : \underline{115}, 154, 618, 619, 623, 628, 629, 632, 637, 640, 679, 692, 693, 969, 1001, 1021, 1037, 1041.

term and log : \underline{54}, 57, 58, 71, 75, 92, 245, 534* ,

1298, 1328* , 1335, 1370. term in: \underline{32*} , 36, 37* , 71, 1338* , 1339.

term input : \underline{71}, 78.
term offset : \underline{54}, 55, 57, 58, 61* , 62, 71, 537* ,

638, 1280. term only : \underline{54}, 55, 57, 58, 71, 75, 92, 535, 1298,

1333* , 1335. term out : \underline{32*} , 34* , 35, 36, 37* , 51* , 56. terminal input : \underline{304}, 313, 328, 330, 360. test char : \underline{906}, 909. TEX : \underline{4*} . : 94. buffer size: 35, 328, 374. exception dictionary: 940. font memory: 580. grouping levels: 274. hash size: 260. input stack size: 321. main memory size: 120, 125. number of strings: 43, 517. parameter stack size: 390. pattern memory: 954, 964. pool size: 42. save size: 273. semantic nest size: 216. text input levels: 328.

: 53* . : 53* . : 52* . : 52* . TEX area: 514* . tex body : \underline{1332*} . TEX font area: 514* . TEX format default : \underline{520*} , 523. TEX FORMAT PATH BIT : 1332* . TEX INPUT PATH : 537* , 1275* . TEX INPUT PATH BIT : 1332* . TEX POOL PATH : 51* . TEX POOL PATH BIT : 1332* . The TEXbook: 1, 23* , 49, 108, 207, 415, 446, 456,

459, 683, 688, 764, 1215, 1331. : 11* , 521* . : 35, 534* , 1257. text : 234, \underline{256}, 257, 258, 259, 260, 262* , 263, 264,

265, 491, 553, 780, 1188, 1216, 1257, 1318* , 1369. : 346. text char : \underline{19*} , 20, 47. primitive: \underline{1230}. text mlist : \underline{689}, 695, 698, 731, 1174. text size: \underline{699}, 703, 732, 762, 1195, 1199. text style: \underline{688}, 694, 703, 731, 737, 744, 745, 746,

748, 749, 758, 762, 1169, 1194, 1196. primitive: \underline{1169}. TEX82: \underline{1}, 99. files: 539. tfm file: \underline{539}, 560, 563* , 564* , 575* . TFM FILE PATH BIT : 1332* . tfm temp: 564* , \underline{1379*} . : 561. : 82. the: \underline{210}, 265, 266, 366, 367, 478. : 641, 992, 1121. primitive: \underline{265}. the toks : \underline{465}, 466, 467, 478, 1297. thick mu skip: \underline{224}. primitive: \underline{226}. thick mu skip code: \underline{224}, 225, 226, 766. thickness : \underline{683}, 697, 725, 743, 744, 746, 747, 1182. thin mu skip: \underline{224}. primitive: \underline{226}. thin mu skip code: \underline{224}, 225, 226, 229, 766. : 95.

align: 800.

copying: 206.

curlevel: 281.

disc1: 841.

disc2: 842.

disc3: 870. disc4: 871. display: 1200. endv: 791. ext1: 1348. ext2: 1357. ext3: 1358. ext4: 1373. flushing: 202. if: 497. line breaking: 877. mlist1: 728. mlist2: 754. mlist3: 761. mlist4: 766. page: 1000. paragraph: 866. prefix: 1211. pruning: 968. right: 1185. rightbrace: 1068. vcenter: 736. vertbreak: 973. vlistout: 630. vpack: 669. 256 spans: 798.

this box : \underline{619}, 624, 625, \underline{629}, 633, 634.

this if : \underline{498}, 501, 503, 505, 506.

three codes : \underline{645}.

threshold : \underline{828}, 851, 854, 863.

: 667. : 678. tight fit : \underline{817}, 819, 830, 833, 834, 836, 853. time: \underline{236}, 241* , 536* , 617. primitive: \underline{238}. time code: \underline{236}, 237, 238. tini: \underline{8*} . : 645, 1082. toint : 127* , 859* , 875* , 944* , 948* . tok val : \underline{410}, 415, 418, 428, 465. token: 289. token list : \underline{307}, 311, 312, 323, 325, 330, 337,

341, 346, 390. token ref count : \underline{200}, 203, 291, 473, 482, 979. token show : \underline{295}, 296, 323, 401, 1279, 1284,

1297, 1370. token type: \underline{307}, 311, 312, 314, 319, 323, 324,

325, 327, 379, 1026, 1095. toks : \underline{230}.

primitive: \underline{265}.

toks base: \underline{230}, 231, 232, 233, 415, 1224, 1226,

1227. primitive: \underline{1222}. toks def code: \underline{1222}, 1224. toks register : \underline{209}, 265, 266, 413, 415, 1210,

1226, 1227. tolerance: \underline{236}, 240, 828, 863. primitive: \underline{238}. tolerance code: \underline{236}, 237, 238. : 1068. too small : \underline{1303*} , 1306* . top: \underline{546}. top bot mark : \underline{210}, 296, 366, 367, 384, 385, 386. top edge: \underline{629}, 636. top mark : \underline{382}, 383, 1012. primitive: \underline{384}. top mark code: \underline{382}, 384, 386. top skip: \underline{224}. primitive: \underline{226}. top skip code: \underline{224}, 225, 226, 1001. total demerits : \underline{819}, 845, 846, 855, 864, 874, 875* . : 986. total mathex params : \underline{701}, 1195. total mathsy params : \underline{700}, 1195. total pages : \underline{592}, 593, 617, 640, 642. total shrink : \underline{646}, 650, 656, 664, 665, 666, 667,

671, 676, 677, 678, 796, 1201. total stretch: \underline{646}, 650, 656, 658, 659, 660, 671,

673, 674, 796. tracing commands : \underline{236}, 367, 498, 509, 1031. primitive: \underline{238}. tracing commands code: \underline{236}, 237, 238. tracing lost chars : \underline{236}, 581. primitive: \underline{238}. tracing lost chars code: \underline{236}, 237, 238. tracing macros : \underline{236}, 323, 389, 400. primitive: \underline{238}. tracing macros code: \underline{236}, 237, 238. tracing online: \underline{236}, 245, 1293, 1298. primitive: \underline{238}. tracing online code: \underline{236}, 237, 238. tracing output : \underline{236}, 638, 641. primitive: \underline{238}. tracing output code: \underline{236}, 237, 238. tracing pages : \underline{236}, 987, 1005, 1010. primitive: \underline{238}. tracing pages code: \underline{236}, 237, 238. tracing paragraphs : \underline{236}, 845, 855, 863. primitive: \underline{238}. tracing paragraphs code: \underline{236}, 237, 238. tracing restores : \underline{236}, 283. primitive: \underline{238}. tracing restores code: \underline{236}, 237, 238. tracing stats : 117, \underline{236}, 639, 1326, 1333* . primitive: \underline{238}. tracing stats code: \underline{236}, 237, 238. : 1333* . trap zero glue: 1228, \underline{1229}, 1236. trick buf : \underline{54}, 58, 315, 317. trick count : \underline{54}, 58, 315, 316, 317. Trickey, Howard Wellington: 2* . trie: 920, \underline{921}, 922, 950, 952, 953, 954, 958, 959,

966, 1324* , 1325* . trie back : \underline{950}, 954, 956. trie c: \underline{947}, 948* , 951, 953, 955, 956, 959, 963, 964.

trie char : 920, \underline{921}, 923, 958, 959.
trie fix : 958, \underline{959}.
trie hash: \underline{947}, 948* , 949, 950, 952.
trie l : \underline{947}, 948* , 949, 957, 959, 960, 963, 964.

trie link : 920, \underline{921}, 923, 950, 952, 953, 954, 955,

956, 958, 959. trie max : \underline{950}, 952, 954, 958, 1324* , 1325* .

trie min: \underline{950}, 952, 953, 956.
trie node: \underline{948*} , 949.

trie not ready : 891, \underline{950}, 951, 960, 966, 1324* , 1325* .

trie o: \underline{947}, 948* , 959, 963, 964.
trie op: 920, \underline{921}, 923, 924, 943* , 958, 959.
trie op hash: 11* , \underline{943*} , 944* , 945, 946, 948* , 952.
trie op lang : \underline{943*} , 944* , 945, 952.
trie op ptr : \underline{943*} , 944* , 945, 946, 1324* , 1325* .

trie op size: \underline{11*} , 921, 943* , 944* , 946, 1324* , 1325* .

trie op val : \underline{943*} , 944* , 945, 952.
trie pack : \underline{957}, 966.

trie pointer : \underline{920}, 921, 922, 947, 948* , 949, 950,

953, 957, 959, 960, 966. trie ptr : \underline{947}, 951, 952, 964. trie r : \underline{947}, 948* , 949, 955, 956, 957, 959, 963, 964. trie ref : \underline{950}, 952, 953, 956, 957, 959. trie root : \underline{947}, 949, 951, 952, 958, 966. trie size: \underline{11*} , 920, 948* , 950, 952, 954, 964, 1325* . trie taken: \underline{950}, 952, 953, 954, 956. trie used : \underline{943*} , 944* , 945, 946, 1324* , 1325* . true: 4* , 16* , 31* , 37* , 45, 46, 49, 51* , 53* , 71, 77, 88, 97, 98, 104, 105, 106, 107, 168, 169, 256, 257, 259, 311, 327, 328, 336, 346, 361, 362, 365, 374, 378, 407, 413, 430, 440, 444, 447, 453, 461, 462, 486, 501, 508, 512, 516* , 524* , 526, 534* , 563* , 578, 592, 621, 628, 637, 638, 641, 663, 675, 706, 719, 791, 827, 828, 829, 851, 854, 863, 880, 882, 884, 903, 905, 910, 911, 951, 956, 962, 963, 992, 1020, 1021, 1025, 1030, 1035, 1037, 1040, 1051, 1054, 1083, 1090, 1101, 1121, 1163, 1194, 1195, 1218, 1253, 1258, 1279, 1283, 1298, 1303* , 1336, 1342, 1354, 1371, 1374.

: 453.

try break : 828, \underline{829}, 839, 851, 858, 862, 866, 868, 869, 873, 879. two: \underline{101}, 102. two choices : \underline{113*} . two halves : 118, 124, 172, 221, 256, 684, 921, 966. type: \underline{4*} , \underline{133}, 134, 135, 136, 137, 138, 139, 140,

141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 152, 153, 155, 156, 157, 158, 159, 160, 175, 183, 184, 202, 206, 424, 489, 495, 496, 497, 505, 622, 623, 626, 628, 631, 632, 635, 637, 640, 649, 651, 653, 655, 668, 669, 670, 680, 681, 682, 683, 686, 687, 688, 689, 696, 698, 713, 715, 720, 721, 726, 727, 728, 729, 731, 732, 736, 747, 750, 752, 761, 762, 767, 768, 796, 799, 801, 805, 807, 809, 810, 811, 816, 819, 820, 822, 830, 832, 837, 841, 842, 843, 844, 845, 856, 858, 859* , 860, 861, 862, 864, 865, 866, 870, 871, 874, 875* , 879, 881, 896, 897, 899, 903, 914, 968, 970, 972, 973, 976, 978, 979, 981, 986, 988, 993, 996, 997, 1000, 1004, 1008, 1009, 1010, 1011, 1013, 1014, 1021, 1074, 1080, 1081, 1087, 1100, 1101, 1105, 1110, 1113, 1121, 1147, 1155, 1158, 1159, 1163, 1165, 1168, 1181, 1185, 1186, 1191, 1202, 1203, 1341, 1349.

: 85. u: \underline{69}, \underline{107}, \underline{389}, \underline{560}, \underline{706}, \underline{791}, \underline{800}, \underline{929}, \underline{934},

\underline{944*} , \underline{1257}. u part : 768, \underline{769}, 779, 788, 794, 801. u template: \underline{307}, 314, 324, 788. uc code: \underline{230}, 232, 407. primitive: \underline{1230}. uc code base: \underline{230}, 235, 1230, 1231, 1286, 1288. uc hyph: \underline{236}, 891, 896. primitive: \underline{238}. uc hyph code: \underline{236}, 237, 238. uexit : 81* . un hbox : \underline{208}, 1090, 1107, 1108, 1109. primitive: \underline{1107}. primitive: \underline{1107}. primitive: \underline{1107}. primitive: \underline{1107}. primitive: \underline{1107}. un vbox : \underline{208}, 1046, 1094, 1107, 1108, 1109. primitive: \underline{1107}. primitive: \underline{1107}. unbalance: \underline{389}, 391, 396, 399, \underline{473}, 477. : 1027. : 1372. : 370. undefined control sequence: \underline{222}, 232, 256, 257,

259, 262* , 268, 282, 290, 1318* , 1319* . undefined cs : \underline{210}, 222, 366, 372, 1226, 1227, 1295. under noad : \underline{687}, 690, 696, 698, 733, 761, 1156,

1157.

: 674. primitive: \underline{1156}. undump: \underline{1306*} , 1312* , 1314, 1319* , 1325* , 1327* . undump end : \underline{1306*} . undump end end : \underline{1306*} . undump four ASCII : \underline{1310*} . undump hh: 1319* . undump int : 1306* , 1308* , 1312* , 1317* , 1319* , 1327* . undump qqqq : 1310* . undump size: \underline{1306*} , 1310* , 1321* , 1323* , 1325* . undump size end : \underline{1306*} . undump size end end : \underline{1306*} . undump things : 1310* , 1312* , 1317* , 1319* , 1323* ,

1325* . unfloat : \underline{109*} , 658, 664, 673, 676, 810, 811. unhyphenated : \underline{819}, 829, 837, 864, 866, 868. unity : \underline{101}, 103, 114, 164, 186* , 453, 568, 1259. unpackage: 1109, \underline{1110}. unsave: \underline{281}, 283, 791, 800, 1026, 1063, 1068,

1086, 1100, 1119, 1133, 1168, 1174, 1186, 1191, 1194, 1196, 1200.

unset node: 136, \underline{159}, 175, 183, 184, 202, 206, 651,

669, 682, 688, 689, 768, 796, 799, 801, 805. update active: \underline{861}. update heights : \underline{970}, 972, 973, 994, 997, 1000. update terminal : \underline{34*} , 37* , 61* , 71, 81* , 86, 362, 524* ,

537* , 638, 1280, 1338* . update width: \underline{832}, 860. primitive: \underline{1286}. : 398. use err help: \underline{79}, 80, 89, 90, 1283. v: \underline{69}, \underline{107}, \underline{389}, \underline{450}, \underline{706}, \underline{715}, \underline{736}, \underline{743}, \underline{749}, \underline{800},

\underline{830}, \underline{922}, \underline{934}, \underline{944*} , \underline{960}, \underline{977}, \underline{1138}. v offset : \underline{247}, 640, 641. primitive: \underline{248}. v offset code: \underline{247}, 248. v part : 768, \underline{769}, 779, 789, 794, 801. v template: \underline{307}, 314, 789. vacuous : \underline{440}, 444, 445. vadjust : \underline{208}, 265, 266, 1097, 1098, 1099, 1100. primitive: \underline{265}. valign: \underline{208}, 265, 266, 1046, 1090, 1130. primitive: \underline{265}. var code: \underline{232}, 1151, 1155, 1165. var delimiter : \underline{706}, 737, 748, 762. var used : \underline{117}, 125, 130, 164, 639, 1311* , 1312* . vbadness : \underline{236}, 674, 677, 678, 1012, 1017. primitive: \underline{238}. vbadness code: \underline{236}, 237, 238. primitive: \underline{1071}. vbox group: \underline{269}, 1083, 1085. vcenter : \underline{208}, 265, 266, 1046, 1167. primitive: \underline{265}. vcenter group: \underline{269}, 1167, 1168. vcenter noad : \underline{687}, 690, 696, 698, 733, 761, 1168. vert break : \underline{970}, 971, 976, 977, 980, 982, 1010. very loose fit : \underline{817}, 819, 830, 833, 834, 836, 852. primitive: \underline{1058}. primitive: \underline{1058}. primitive: \underline{1058}. vfuzz : \underline{247}, 677, 1012, 1017. primitive: \underline{248}. vfuzz code: \underline{247}, 248. : 1331. virtual memory: 126. Vitter, Jeffrey Scott: 261. vlist node: \underline{137}, 148, 159, 175, 183, 184, 202, 206,

505, 618, 622, 623, 628, 629, 631, 632, 637, 640, 644, 651, 668, 669, 681, 713, 715, 720, 736, 747, 750, 807, 809, 811, 841, 842, 866, 870, 871, 968, 973, 978, 1000, 1074, 1080, 1087, 1110, 1147.

vlist out : 592, 615, 616, 618, 619, 623, 628, \underline{629},

632, 637, 638, 640, 693, 1373. vmode: \underline{211}, 215, 416, 417, 418, 422, 424, 501,

775, 785, 786, 804, 807, 808, 809, 812, 1025, 1029, 1045, 1046, 1048, 1056, 1057, 1071, 1072, 1073, 1076, 1078, 1079, 1080, 1083, 1090, 1091, 1094, 1098, 1099, 1103, 1105, 1109, 1110, 1111, 1130, 1167, 1243, 1244.

vmove: \underline{208}, 1048, 1071, 1072, 1073. vpack : 236, 644, 645, 646, \underline{668}, 705, 735, 738, 759,

799, 804, 977, 1021, 1100, 1168. vpackage: \underline{668}, 796, 977, 1017, 1086. vrule: \underline{208}, 265, 266, 463, 1056, 1084, 1090. primitive: \underline{265}. vsize: \underline{247}, 980, 987. primitive: \underline{248}. vsize code: \underline{247}, 248. vskip: \underline{208}, 1046, 1057, 1058, 1059, 1078, 1094. primitive: \underline{1058}. vsplit : 967, \underline{977}, 978, 980, 1082. : 978. primitive: \underline{1071}. vsplit code: \underline{1071}, 1072, 1079. primitive: \underline{1058}. vstrcpy : 51* . primitive: \underline{1071}. vtop code: \underline{1071}, 1072, 1083, 1085, 1086. vtop group: \underline{269}, 1083, 1085. w: \underline{114}, \underline{147}, \underline{156}, \underline{275}, \underline{278}, \underline{279}, \underline{607}, \underline{649}, \underline{668},

\underline{706}, \underline{715}, \underline{738}, \underline{791}, \underline{800}, \underline{906}, \underline{994}, \underline{1123}, \underline{1138}, \underline{1198}, \underline{1349}, \underline{1350}.

w close: 1329, 1337. w make name string : \underline{525}, 1328* . w open in: 524* . w open out : 1328* . wait : \underline{1012}, 1020, 1021, 1022. wake up terminal : 34* , 37* , 51* , 71, 73, 363, 484, 524* , 530, 1294, 1297, 1303* , 1333* , 1338* . warning index : \underline{305}, 331, 338, 389, 390, 395, 396,

398, 401, 473, 479, 482, 774, 777. warning issued : \underline{76}, 81* , 245, 1335. was free: \underline{165*} , 167, 171. was hi min: \underline{165*} , 166, 167, 171. was lo max : \underline{165*} , 166, 167, 171. was mem end : \underline{165*} , 166, 167, 171. primitive: \underline{416}. : 1, 4* , 38, 40, 50, 1308* . what lang : \underline{1341}, 1356, 1362, 1376, 1377. what lhm: \underline{1341}, 1356, 1362, 1376, 1377. what rhm: \underline{1341}, 1356, 1362, 1376, 1377. whatsit node: \underline{146}, 148, 175, 183, 202, 206, 622, 631, 651, 669, 730, 761, 866, 896, 899, 968, 973, 1000, 1147, 1341, 1349.

widow penalty : \underline{236}, 1096.

primitive: \underline{238}. widow penalty code: \underline{236}, 237, 238. : 463. width: \underline{135}, 136, 138, 139, 147, 150, 151, 155, 156, 178, 184, 187, 191, 192, 424, 429, 431, 451, 462, 463, 554, 605, 607, 611, 622, 623, 625, 626, 631, 633, 634, 635, 641, 651, 653, 656, 657, 666, 668, 669, 670, 671, 679, 683, 688, 706, 709, 714, 715, 716, 717, 731, 738, 744, 747, 749, 750, 757, 758, 759, 768, 779, 793, 796, 797, 798, 801, 802, 803, 804, 806, 807, 808, 809, 810, 811, 827, 837, 838, 841, 842, 866, 868, 870, 871, 881, 969, 976, 996, 1001, 1004, 1009, 1042, 1044, 1054, 1091, 1093, 1147, 1148, 1199, 1201, 1205, 1229, 1239, 1240.

width base: \underline{550}, 552, 554, 566, 569, 571, 576,

1322* , 1323* . width index : \underline{543}, 550. width offset : \underline{135}, 416, 417, 1247. Wirth, Niklaus: 10. wlog : \underline{56}, 58, 536* , 1334. wlog cr : \underline{56}, 57, 58, 1333* . wlog ln: \underline{56}, 1334. word define: \underline{1214}, 1228, 1232, 1236. word file: 525, 1305* . words : \underline{204}, 205, 206, 1357. wrap lig : \underline{910}, 911. wrapup: \underline{1035}, 1040. write: 37* , 56, 58, 597* . primitive: \underline{1344}. write dvi : 597* , 598, 599. write file: 57, 58, \underline{1342}, 1374, 1378. write ln: 35, 37* , 51* , 56, 57. write loc: 1313, 1314, 1344, \underline{1345}, 1371. write node: \underline{1341}, 1344, 1346, 1348, 1356, 1357,

1358, 1373, 1374. write node size: \underline{1341}, 1350, 1352, 1353, 1354,

1357, 1358. write open: \underline{1342}, 1343, 1370, 1374, 1378. write out : \underline{1370}, 1374. write stream: \underline{1341}, 1350, 1354, 1355, 1370, 1374. write text : \underline{307}, 314, 323, 1340, 1371. write tokens : \underline{1341}, 1352, 1353, 1354, 1356, 1357,

1358, 1368, 1371. writing : \underline{578}. wterm: \underline{56}, 58, 61* . wterm cr : \underline{56}, 57, 58. wterm ln: \underline{56}, 524* , 1303* , 1332* . Wyatt, Douglas Kirk: 2* . w0 : 585, \underline{586}, 604, 609. w1 : 585, \underline{586}, 607. w2 : \underline{585}. w3 : \underline{585}. w4 : \underline{585}. x: \underline{100}, \underline{105}, \underline{106}, \underline{107}, \underline{587}, \underline{600}, \underline{649}, \underline{668}, \underline{706},

\underline{720}, \underline{726}, \underline{735}, \underline{737}, \underline{738}, \underline{743}, \underline{749}, \underline{756}, \underline{1123}, \underline{1302*} , \underline{1303*} .

x height : 547, \underline{558}, 559, 738, 1123. x height code: \underline{547}, 558. x leaders : \underline{149}, 190, 627, 1071, 1072. primitive: \underline{1071}. x over n: \underline{106}, 703, 716, 717, 986, 1008, 1009,

1010, 1240. x token: 364, \underline{381}, 478, 1038, 1152. xchr : \underline{20}, 21, 23* , 24, 38, 49, 58, 519. xclause: 16* . primitive: \underline{1208}. xeq level : \underline{253*} , 254, 268, 278, 279, 283, 1304. xn over d : \underline{107}, 455, 457, 458, 568, 716, 1044,

1260. xord : \underline{20}, 24, 52* , 53* , 523, 525. xpand : \underline{473}, 477, 479. xray : \underline{208}, 1290, 1291, 1292. xspace skip: \underline{224}, 1043. primitive: \underline{226}. xspace skip code: \underline{224}, 225, 226, 1043. xxx1 : 585, \underline{586}, 1368. xxx2 : \underline{585}. xxx3 : \underline{585}. xxx4 : 585, \underline{586}, 1368. x0 : 585, \underline{586}, 604, 609. x1 : 585, \underline{586}, 607. x2 : \underline{585}. x3 : \underline{585}. x4 : \underline{585}. y: \underline{105}, \underline{706}, \underline{726}, \underline{735}, \underline{737}, \underline{738}, \underline{743}, \underline{749}, \underline{756}. y here: \underline{608}, 609, 611, 612, 613. y OK : \underline{608}, 609, 612. y seen: \underline{611}, 612. year : \underline{236}, 241* , 536* , 617, 1328* . primitive: \underline{238}. year code: \underline{236}, 237, 238. : 476. : 1099. : 1304. : 1095. : 1213. : 1212. : 428, 1237. : 1049. : 52* . you cant : \underline{1049}, 1050, 1080, 1106. yz OK : \underline{608}, 609, 610, 612. y0 : 585, \underline{586}, 594, 604, 609. y1 : 585, \underline{586}, 607, 613. y2 : \underline{585}, 594. y3 : \underline{585}. y4 : \underline{585}. z: \underline{560}, \underline{706}, \underline{726}, \underline{743}, \underline{749}, \underline{756}, \underline{922}, \underline{927}, \underline{953},

\underline{959}, \underline{1198}.

z here: \underline{608}, 609, 611, 612, 614.

z OK : \underline{608}, 609, 612. z seen: \underline{611}, 612. Zabala Salelles, Ignacio Andres: 2* . zeqtb: \underline{253*} . zero glue: \underline{162}, 175, 224, 228, 424, 462, 732, 802,

887, 1041, 1042, 1043, 1171, 1229. zero token: \underline{445}, 452, 473, 476, 479.

zmem: \underline{116*} .
z0 : 585, \underline{586}, 604, 609.
z1 : 585, \underline{586}, 607, 614.
z2 : \underline{585}.
z3 : \underline{585}.
z4 : \underline{585}.

84  NAMES OF THE SECTIONS  TEX82 §1381

⟨ Accumulate the constant until cur tok is not a suitable digit 445 ⟩ Used in section 444. ⟨ Add the width of node s to act width 871 ⟩ Used in section 869. ⟨ Add the width of node s to break width and increase t, unless it’s discardable 842 ⟩ Used in section 840. ⟨ Add the width of node s to disc width 870 ⟩ Used in section 869. ⟨ Adjust for the magnification ratio 457 ⟩ Used in section 453. ⟨ Adjust for the setting of 1214 ⟩ Used in section 1211. ⟨ Adjust shift up and shift down for the case of a fraction line 746 ⟩ Used in section 743. ⟨ Adjust shift up and shift down for the case of no fraction line 745 ⟩ Used in section 743. ⟨ Advance cur p to the node following the present string of characters 867 ⟩ Used in section 866. ⟨ Advance past a whatsit node in the line break loop 1362 ⟩ Used in section 866. ⟨ Advance past a whatsit node in the pre-hyphenation loop 1363 ⟩ Used in section 896. ⟨ Advance r; goto found if the parameter delimiter has been fully matched, otherwise goto continue 394 ⟩

Used in section 392.

⟨ Allocate entire node p and goto found 129 ⟩ Used in section 127*. ⟨ Allocate from the top of node p and goto found 128 ⟩ Used in section 127*. ⟨ Apologize for inability to do the operation now, unless follows non-glue 1106 ⟩ Used in section 1105. ⟨ Apologize for not loading the font, goto done 567 ⟩ Used in section 566. ⟨ Append a ligature and/or kern to the translation; goto continue if the stack of inserted ligatures is

nonempty 910 ⟩ Used in section 906.

⟨ Append a new leader node that uses cur box 1078 ⟩ Used in section 1075. ⟨ Append a new letter or a hyphen level 962 ⟩ Used in section 961. ⟨ Append a new letter or hyphen 937 ⟩ Used in section 935. ⟨ Append a normal inter-word space to the current list, then goto big switch 1041 ⟩ Used in section 1030. ⟨ Append a penalty node, if a nonzero penalty is appropriate 890 ⟩ Used in section 880. ⟨ Append an insertion to the current page and goto contribute 1008 ⟩ Used in section 1000. ⟨ Append any new hlist entries for q, and any appropriate penalties 767 ⟩ Used in section 760. ⟨ Append box cur box to the current list, shifted by box context 1076 ⟩ Used in section 1075. ⟨ Append character cur chr and the following characters (if any) to the current hlist in the current font;

goto reswitch when a non-character has been fetched 1034 ⟩ Used in section 1030. ⟨ Append characters of hu[j . .] to major tail , advancing j 917 ⟩ Used in section 916. ⟨ Append inter-element spacing based on r type and t 766 ⟩ Used in section 760. ⟨ Append tabskip glue and an empty box to list u, and update s and t as the prototype nodes are passed 809 ⟩

Used in section 808.

⟨ Append the accent with appropriate kerns, then set p ← q 1125 ⟩ Used in section 1123. ⟨ Append the current tabskip glue to the preamble list 778 ⟩ Used in section 777. ⟨ Append the display and perhaps also the equation number 1204 ⟩ Used in section 1199. ⟨ Append the glue or equation number following the display 1205 ⟩ Used in section 1199. ⟨ Append the glue or equation number preceding the display 1203 ⟩ Used in section 1199. ⟨ Append the new box to the current vertical list, followed by the list of special nodes taken out of the box

by the packager 888 ⟩ Used in section 880.

⟨ Append the value n to list p 938 ⟩ Used in section 937. ⟨ Assign the values depth threshold ← show box depth and breadth max ← show box breadth 236 ⟩

Used in section 198. ⟨ Assignments 1217, 1218, 1221, 1224, 1225, 1226, 1228, 1232, 1234, 1235, 1241, 1242, 1248, 1252, 1253, 1256, 1264 ⟩

Used in section 1211.

⟨ Attach list p to the current list, and record its length; then finish up and return 1120 ⟩ Used in section 1119. ⟨ Attach the limits to y and adjust height (v), depth(v) to account for their presence 751 ⟩ Used in section 750. ⟨ Back up an outer control sequence so that it can be reread 337 ⟩ Used in section 336.

⟨ Basic printing procedures 57, 58, 59, 60, 62, 63, 64, 65, 262*, 263, 518, 699, 1355 ⟩ Used in section 4*.

⟨ Break the current page at node p, put it in box 255, and put the remaining nodes on the contribution

list 1017 ⟩ Used in section 1014.

§1381  TEX82  NAMES OF THE SECTIONS 85

⟨ Break the paragraph at the chosen breakpoints, justify the resulting lines to the correct widths, and

append them to the current vertical list 876 ⟩ Used in section 815. ⟨ Calculate the length, l, and the shift amount, s, of the display lines 1149 ⟩ Used in section 1145. ⟨ Calculate the natural width, w, by which the characters of the final line extend to the right of the reference

point, plus two ems; or set w ← max dimen if the non-blank information on that line is affected by stretching or shrinking 1146 ⟩ Used in section 1145.

⟨ Call the packaging subroutine, setting just box to the justified box 889 ⟩ Used in section 880. ⟨ Call try break if cur p is a legal breakpoint; on the second pass, also try to hyphenate the next word, if

cur p is a glue node; then advance cur p to the next node of the paragraph that could possibly be a

legal breakpoint 866 ⟩ Used in section 863.

⟨ Carry out a ligature replacement, updating the cursor structure and possibly advancing j; goto continue

if the cursor doesn’t advance, otherwise goto done 911 ⟩ Used in section 909. ⟨ Case statement to copy different types and set words to the number of initial words not yet copied 206 ⟩

Used in section 205.

⟨ Cases for noads that can follow a bin noad 733 ⟩ Used in section 728. ⟨ Cases for nodes that can appear in an mlist, after which we goto done with node 730 ⟩ Used in section 728. ⟨ Cases of flush node list that arise in mlists only 698 ⟩ Used in section 202. ⟨ Cases of handle right brace where a right brace triggers a delayed action 1085, 1100, 1118, 1132, 1133, 1168,

1173, 1186 ⟩ Used in section 1068.

⟨ Cases of main control that are for extensions to TEX 1347 ⟩ Used in section 1045. ⟨ Cases of main control that are not part of the inner loop 1045 ⟩ Used in section 1030.

⟨ Cases of main control that build boxes and lists 1056, 1057, 1063, 1067, 1073, 1090, 1092, 1094, 1097, 1102, 1104, 1109, 1112, 1116, 1122, 1126, 1130, 1134, 1137, 1140, 1150, 1154, 1158, 1162, 1164, 1167, 1171, 1175, 1180, 1190, 1193 ⟩ Used in section 1045.

⟨ Cases of main control that don’t depend on mode 1210, 1268, 1271, 1274, 1276, 1285, 1290 ⟩ Used in section 1045. ⟨ Cases of print cmd chr for symbolic printing of primitives 227, 231, 239, 249, 266, 335, 377, 385, 412, 417, 469,

488, 492, 781, 984, 1053, 1059, 1072, 1089, 1108, 1115, 1143, 1157, 1170, 1179, 1189, 1209, 1220, 1223, 1231, 1251, 1255, 1261, 1263, 1273, 1278, 1287, 1292, 1295, 1346 ⟩ Used in section 298.

⟨ Cases of show node list that arise in mlists only 690 ⟩ Used in section 183. ⟨ Cases where character is ignored 345 ⟩ Used in section 344. ⟨ Change buffered instruction to y or w and goto found 613 ⟩ Used in section 612. ⟨ Change buffered instruction to z or x and goto found 614 ⟩ Used in section 612. ⟨ Change current mode to −vmode for , −hmode for 775 ⟩ Used in section 774. ⟨ Change discretionary to compulsory and set disc break ← true 882 ⟩ Used in section 881.

⟨ Change font dvi f to f 621 ⟩ Used in section 620.

⟨ Change state if necessary, and goto switch if the current character should be ignored, or goto reswitch if

the current character changes to another 344 ⟩ Used in section 343. ⟨ Change the case of the token in p, if a change is appropriate 1289 ⟩ Used in section 1288. ⟨ Change the current style and goto delete q 763 ⟩ Used in section 761. ⟨ Change the interaction level and return 86 ⟩ Used in section 84*. ⟨ Change this node to a style node followed by the correct choice, then goto done with node 731 ⟩

Used in section 730.

⟨ Character k cannot be printed 49 ⟩ Used in section 48. ⟨ Character s is the current new-line character 244 ⟩ Used in sections 58, 59, and 60. ⟨ Check flags of unavailable nodes 170 ⟩ Used in section 167. ⟨ Check for charlist cycle 570 ⟩ Used in section 569. ⟨ Check for improper alignment in displayed math 776 ⟩ Used in section 774. ⟨ Check if node p is a new champion breakpoint; then goto done if p is a forced break or if the page-so-far

is already too full 974 ⟩ Used in section 972.

⟨ Check if node p is a new champion breakpoint; then if it is time for a page break, prepare for output, and either fire up the user’s output routine and return or ship out the page and goto done 1005 ⟩

Used in section 997.

⟨ Check single-word avail list 168 ⟩ Used in section 167.

⟨ Check that another $ follows 1197 ⟩ Used in sections 1194, 1194, and 1206.

⟨ Check that the necessary fonts for math symbols are present; if not, flush the current math lists and set

danger ← true 1195 ⟩ Used in sections 1194 and 1194.

⟨ Check that the nodes following hb permit hyphenation and that at least l hyf + r hyf letters have been

found, otherwise goto done1 899 ⟩ Used in section 894.

⟨ Check the “constant” values for consistency 14, 111, 290, 522, 1249 ⟩ Used in section 1332*. ⟨ Check the pool check sum 53* ⟩ Used in section 52*. ⟨ Check variable-size avail list 169 ⟩ Used in section 167. ⟨ Clean up the memory by removing the break nodes 865 ⟩ Used in sections 815 and 863.

⟨ Clear dimensions to zero 650 ⟩ Used in sections 649 and 668.

⟨ Clear off top level from save stack 282 ⟩ Used in section 281.

⟨ Close the format file 1329 ⟩ Used in section 1302*. ⟨ Coerce glue to a dimension 451 ⟩ Used in sections 449 and 455.

⟨ Compiler directives 9* ⟩ Used in section 4*. ⟨ Complain about an undefined family and set cur i null 723 ⟩ Used in section 722. ⟨ Complain about an undefined macro 370 ⟩ Used in section 367. ⟨ Complain about missing 373 ⟩ Used in section 372. ⟨ Complain about unknown unit and goto done2 459 ⟩ Used in section 458. ⟨ Complain that can’t do this; give zero result 428 ⟩ Used in section 413. ⟨ Complain that the user should have said 1166 ⟩ Used in section 1165. ⟨ Compleat the incompleat noad 1185 ⟩ Used in section 1184. ⟨ Complete a potentially long command 1298 ⟩ Used in section 1293. ⟨ Compute result of multiply or divide, put it in cur val 1240 ⟩ Used in section 1236. ⟨ Compute result of register or advance, put it in cur val 1238 ⟩ Used in section 1236. ⟨ Compute the amount of skew 741 ⟩ Used in section 738. ⟨ Compute the badness, b, of the current page, using awful bad if the box is too full 1007 ⟩

Used in section 1005.

⟨ Compute the badness, b, using awful bad if the box is too full 975 ⟩ Used in section 974. ⟨ Compute the demerits, d, from r to cur p 859* ⟩ Used in section 855. ⟨ Compute the discretionary break width values 840 ⟩ Used in section 837. ⟨ Compute the hash code h 261 ⟩ Used in section 259. ⟨ Compute the magic offset 765 ⟩ Used in section 1337. ⟨ Compute the minimum suitable height, w, and the corresponding number of extension steps, n; also set

width(b) 714 ⟩ Used in section 713.

⟨ Compute the new line width 850 ⟩ Used in section 835. ⟨ Compute the register location l and its type p; but return if invalid 1237 ⟩ Used in section 1236. ⟨ Compute the sum of two glue specs 1239 ⟩ Used in section 1238. ⟨ Compute the trie op code, v, and set l ← 0 965 ⟩ Used in section 963. ⟨ Compute the values of break width 837 ⟩ Used in section 836. ⟨ Consider a node with matching width; goto found if it’s a hit 612 ⟩ Used in section 611. ⟨ Consider the demerits for a line from r to cur p; deactivate node r if it should no longer be active; then

goto continue if a line from r to cur p is infeasible, otherwise record a new feasible break 851 ⟩

Used in section 829.

⟨ Constants in the outer block 11* ⟩ Used in section 4*. ⟨ Construct a box with limits above and below it, skewed by delta 750 ⟩ Used in section 749. ⟨ Construct a sub/superscript combination box x, with the superscript offset by delta 759 ⟩

Used in section 756.

⟨ Construct a subscript box x when there is no superscript 757 ⟩ Used in section 756. ⟨ Construct a superscript box x 758 ⟩ Used in section 756. ⟨ Construct a vlist box for the fraction, according to shift up and shift down 747 ⟩ Used in section 743.

⟨ Construct an extensible character in a new box b, using recipe rem byte(q) and font f 713 ⟩

Used in section 710.

⟨ Contribute an entire group to the current parameter 399 ⟩ Used in section 392. ⟨ Contribute the recently matched tokens to the current parameter, and goto continue if a partial match is

still in effect; but abort if s = null 397 ⟩ Used in section 392.

⟨ Convert a final bin noad to an ord noad 729 ⟩ Used in sections 726 and 728.

⟨ Convert cur val to a lower level 429 ⟩ Used in section 413. ⟨ Convert math glue to ordinary glue 732 ⟩ Used in section 730. ⟨ Convert nucleus (q) to an hlist and attach the sub/superscripts 754 ⟩ Used in section 728. ⟨ Copy the tabskip glue between columns 795 ⟩ Used in section 791. ⟨ Copy the templates from node cur loop into node p 794 ⟩ Used in section 793.

⟨ Copy the token list 466 ⟩ Used in section 465.

⟨ Create a character node p for nucleus (q), possibly followed by a kern node for the italic correction, and set

delta to the italic correction if a subscript is present 755 ⟩ Used in section 754. ⟨ Create a character node q for the next character, but set q ← null if problems arise 1124 ⟩

Used in section 1123.

⟨ Create a new glue specification whose width is cur val ; scan for its stretch and shrink components 462 ⟩

Used in section 461.

⟨ Create a page insertion node with subtype(r) = qi (n), and include the glue correction for box n in the

current page state 1009 ⟩ Used in section 1008.

⟨ Create an active breakpoint representing the beginning of the paragraph 864 ⟩ Used in section 863. ⟨ Create and append a discretionary node as an alternative to the unhyphenated word, and continue to

develop both branches until they become equivalent 914 ⟩ Used in section 913. ⟨ Create equal-width boxes x and z for the numerator and denominator, and compute the default amounts

shift up and shift down by which they are displaced from the baseline 744 ⟩ Used in section 743. ⟨ Create new active nodes for the best feasible breaks just found 836 ⟩ Used in section 835. ⟨ Create the format ident , open the format file, and inform the user that dumping has begun 1328* ⟩

Used in section 1302*.

⟨ Current mem equivalent of glue parameter number n 224 ⟩ Used in sections 152 and 154.

⟨ Deactivate node r 860 ⟩ Used in section 851. ⟨ Declare action procedures for use by main control 1043, 1047, 1049, 1050, 1051, 1054, 1060, 1061, 1064, 1069, 1070,

1075, 1079, 1084, 1086, 1091, 1093, 1095, 1096, 1099, 1101, 1103, 1105, 1110, 1113, 1117, 1119, 1123, 1127, 1129, 1131, 1135, 1136, 1138, 1142, 1151, 1155, 1159, 1160, 1163, 1165, 1172, 1174, 1176, 1181, 1191, 1194, 1200, 1211, 1270, 1275*, 1279, 1288, 1293, 1302*, 1348, 1376 ⟩ Used in section 1030.

⟨ Declare math construction procedures 734, 735, 736, 737, 738, 743, 749, 752, 756, 762 ⟩ Used in section 726.

⟨ Declare procedures for preprocessing hyphenation patterns 944*, 948*, 949, 953, 957, 959, 960, 966 ⟩

Used in section 942.

⟨ Declare procedures needed for displaying the elements of mlists 691, 692, 694 ⟩ Used in section 179. ⟨ Declare procedures needed in do extension 1349, 1350 ⟩ Used in section 1348.

⟨ Declare procedures needed in hlist out , vlist out 1368, 1370, 1373 ⟩ Used in section 619.

⟨ Declare procedures that scan font-related stuff 577, 578 ⟩ Used in section 409. ⟨ Declare procedures that scan restricted classes of integers 433, 434, 435, 436, 437 ⟩ Used in section 409.

⟨ Declare subprocedures for line break 826, 829, 877, 895, 942 ⟩ Used in section 815. ⟨ Declare subprocedures for prefixed command 1215, 1229, 1236, 1243, 1244, 1245, 1246, 1247, 1257, 1265 ⟩

Used in section 1211. ⟨ Declare subprocedures for var delimiter 709, 711, 712 ⟩ Used in section 706.

⟨ Declare the function called fin mlist 1184 ⟩ Used in section 1174. ⟨ Declare the function called open fmt file 524* ⟩ Used in section 1303*. ⟨ Declare the function called reconstitute 906 ⟩ Used in section 895. ⟨ Declare the procedure called align peek 785 ⟩ Used in section 800. ⟨ Declare the procedure called fire up 1012 ⟩ Used in section 994. ⟨ Declare the procedure called get preamble token 782 ⟩ Used in section 774.

⟨ Declare the procedure called handle right brace 1068 ⟩ Used in section 1030. ⟨ Declare the procedure called init span 787 ⟩ Used in section 786. ⟨ Declare the procedure called insert relax 379 ⟩ Used in section 366. ⟨ Declare the procedure called macro call 389 ⟩ Used in section 366. ⟨ Declare the procedure called print cmd chr 298 ⟩ Used in section 252. ⟨ Declare the procedure called print skip param 225 ⟩ Used in section 179. ⟨ Declare the procedure called restore trace 284 ⟩ Used in section 281. ⟨ Declare the procedure called runaway 306 ⟩ Used in section 119. ⟨ Declare the procedure called show token list 292 ⟩ Used in section 119. ⟨ Decry the invalid character and goto restart 346 ⟩ Used in section 344.

⟨ Delete c − tokens and goto continue 88 ⟩ Used in section 84*.

⟨ Delete the page-insertion nodes 1019 ⟩ Used in section 1014. ⟨ Destroy the t nodes following q, but save the last one if it is a necessary kern; make r point to the following

node 883 ⟩ Used in section 882.

⟨ Determine horizontal glue shrink setting, then return or goto common ending 664 ⟩ Used in section 657. ⟨ Determine horizontal glue stretch setting, then return or goto common ending 658 ⟩ Used in section 657. ⟨ Determine the displacement, d, of the left edge of the equation, with respect to the line size z, assuming

that l = false 1202 ⟩ Used in section 1199. ⟨ Determine the shrink order 665 ⟩ Used in sections 664, 676, and 796. ⟨ Determine the stretch order 659 ⟩ Used in sections 658, 673, and 796.

⟨ Determine the value of height (r) and the appropriate glue setting; then return or goto

common ending 672 ⟩ Used in section 668.

⟨ Determine the value of width(r) and the appropriate glue setting; then return or goto common ending 657 ⟩

Used in section 649.

⟨ Determine vertical glue shrink setting, then return or goto common ending 676 ⟩ Used in section 672. ⟨ Determine vertical glue stretch setting, then return or goto common ending 673 ⟩ Used in section 672. ⟨ Discard erroneous prefixes and return 1212 ⟩ Used in section 1211. ⟨ Discard the prefixes and if they are irrelevant 1213 ⟩ Used in section 1211. ⟨ Dispense with trivial cases of void or bad boxes 978 ⟩ Used in section 977.

⟨ Display adjustment p 197 ⟩ Used in section 183. ⟨ Display box p 184 ⟩ Used in section 183. ⟨ Display choice node p 695 ⟩ Used in section 690.

⟨ Display discretionary p 195 ⟩ Used in section 183. ⟨ Display fraction noad p 697 ⟩ Used in section 690.

⟨ Display glue p 189 ⟩ Used in section 183. ⟨ Display insertion p 188 ⟩ Used in section 183. ⟨ Display kern p 191 ⟩ Used in section 183. ⟨ Display leaders p 190 ⟩ Used in section 189. ⟨ Display ligature p 193 ⟩ Used in section 183. ⟨ Display mark p 196 ⟩ Used in section 183. ⟨ Display math node p 192 ⟩ Used in section 183. ⟨ Display node p 183 ⟩ Used in section 182. ⟨ Display normal noad p 696 ⟩ Used in section 690. ⟨ Display penalty p 194 ⟩ Used in section 183. ⟨ Display rule p 187 ⟩ Used in section 183.

⟨ Display special fields of the unset node p 185 ⟩ Used in section 184. ⟨ Display the current context 312 ⟩ Used in section 311. ⟨ Display the insertion split cost 1011 ⟩ Used in section 1010. ⟨ Display the page break cost 1006 ⟩ Used in section 1005. ⟨ Display the token (m, c) 294 ⟩ Used in section 293.

⟨ Display the value of b 502 ⟩ Used in section 498.

⟨ Display the value of glue set (p) 186* ⟩ Used in section 184.

⟨ Display the whatsit node p 1356 ⟩ Used in section 183. ⟨ Display token p, and return if there are problems 293 ⟩ Used in section 292. ⟨ Do first-pass processing based on type(q); goto done with noad if a noad has been fully processed, goto

check dimensions if it has been translated into new hlist (q), or goto done with node if a node has been

fully processed 728 ⟩ Used in section 727.

⟨ Do ligature or kern command, returning to main lig loop or main loop wrapup or main loop move 1040 ⟩

Used in section 1039.

⟨ Do magic computation 320 ⟩ Used in section 292. ⟨ Do some work that has been queued up for 1374 ⟩ Used in section 1373. ⟨ Drop current token and complain that it was unmatched 1066 ⟩ Used in section 1064. ⟨ Dump a couple more things and the closing check word 1326 ⟩ Used in section 1302*. ⟨ Dump constants for consistency check 1307 ⟩ Used in section 1302*.

⟨ Dump regions 1 to 4 of eqtb 1315* ⟩ Used in section 1313. ⟨ Dump regions 5 and 6 of eqtb 1316* ⟩ Used in section 1313.

⟨ Dump the array info for internal font number k 1322* ⟩ Used in section 1320*.

⟨ Dump the dynamic memory 1311* ⟩ Used in section 1302*.

⟨ Dump the font information 1320* ⟩ Used in section 1302*.

⟨ Dump the hash table 1318* ⟩ Used in section 1313.

⟨ Dump the hyphenation tables 1324* ⟩ Used in section 1302*.

⟨ Dump the string pool 1309* ⟩ Used in section 1302*.

⟨ Dump the table of equivalents 1313 ⟩ Used in section 1302*. ⟨ Either append the insertion node p after node q, and remove it from the current page, or delete

node(p) 1022 ⟩ Used in section 1020.

⟨ Either insert the material specified by node p into the appropriate box, or hold it for the next page; also

delete node p from the current page 1020 ⟩ Used in section 1014. ⟨ Either process or set b to the value of a boolean condition 501 ⟩ Used in section 498. ⟨ Empty the last bytes out of dvi buf 599 ⟩ Used in section 642. ⟨ Ensure that box 255 is empty after output 1028 ⟩ Used in section 1026. ⟨ Ensure that box 255 is empty before output 1015 ⟩ Used in section 1014.

⟨ Ensure that trie max ≥ h + 256 954 ⟩ Used in section 953.

⟨ Enter a hyphenation exception 939 ⟩ Used in section 935. ⟨ Enter all of the patterns into a linked trie, until coming to a right brace 961 ⟩ Used in section 960. ⟨ Enter as many hyphenation exceptions as are listed, until coming to a right brace; then return 935 ⟩

Used in section 934.

⟨ Enter skip blanks state, emit a space 349 ⟩ Used in section 347.

⟨ Error handling procedures 78, 81*, 82, 93, 94, 95 ⟩ Used in section 4*.

⟨ Examine node p in the hlist, taking account of its effect on the dimensions of the new box, or moving it to

the adjustment list; then advance p to the next node 651 ⟩ Used in section 649. ⟨ Examine node p in the vlist, taking account of its effect on the dimensions of the new box; then advance p

to the next node 669 ⟩ Used in section 668. ⟨ Expand a nonmacro 367 ⟩ Used in section 366.

⟨ Expand macros in the token list and make link (def ref ) point to the result 1371 ⟩ Used in section 1370. ⟨ Expand the next part of the input 478 ⟩ Used in section 477. ⟨ Expand the token after the next token 368 ⟩ Used in section 367. ⟨ Explain that too many dead cycles have occurred in a row 1024 ⟩ Used in section 1012. ⟨ Express astonishment that no number was here 446 ⟩ Used in section 444. ⟨ Express consternation over the fact that no alignment is in progress 1128 ⟩ Used in section 1127. ⟨ Express shock at the missing left brace; goto found 475 ⟩ Used in section 474. ⟨ Feed the macro body and its parameters to the scanner 390 ⟩ Used in section 389. ⟨ Fetch a box dimension 420 ⟩ Used in section 413. ⟨ Fetch a character code from some table 414 ⟩ Used in section 413. ⟨ Fetch a font dimension 425 ⟩ Used in section 413.

⟨ Fetch a font integer 426 ⟩ Used in section 413. ⟨ Fetch a register 427 ⟩ Used in section 413.

⟨ Fetch a token list or font identifier, provided that level = tok val 415 ⟩ Used in section 413. ⟨ Fetch an internal dimension and goto attach sign, or fetch an internal integer 449 ⟩ Used in section 448. ⟨ Fetch an item in the current node, if appropriate 424 ⟩ Used in section 413. ⟨ Fetch something on the page so far 421 ⟩ Used in section 413.

⟨ Fetch the dead cycles or the insert penalties 419 ⟩ Used in section 413. ⟨ Fetch the par shape size 423 ⟩ Used in section 413. ⟨ Fetch the prev graf 422 ⟩ Used in section 413. ⟨ Fetch the space factor or the prev depth 418 ⟩ Used in section 413.

⟨ Find an active node with fewest demerits 874 ⟩ Used in section 873. ⟨ Find hyphen locations for the word in hc, or return 923 ⟩ Used in section 895. ⟨ Find optimal breakpoints 863 ⟩ Used in section 815. ⟨ Find the best active node for the desired looseness 875* ⟩ Used in section 873. ⟨ Find the best way to split the insertion, and change type(r) to split up 1010 ⟩ Used in section 1008. ⟨ Find the glue specification, main p, for text spaces in the current font 1042 ⟩ Used in sections 1041 and 1043. ⟨ Finish an alignment in a display 1206 ⟩ Used in section 812.

⟨ Finish displayed math 1199 ⟩ Used in section 1194.

⟨ Finish issuing a diagnostic message for an overfull or underfull hbox 663 ⟩ Used in section 649. ⟨ Finish issuing a diagnostic message for an overfull or underfull vbox 675 ⟩ Used in section 668.

⟨ Finish line, emit a 351 ⟩ Used in section 347.

⟨ Finish line, emit a space 348 ⟩ Used in section 347.

⟨ Finish line, goto switch 350 ⟩ Used in section 347. ⟨ Finish math in text 1196 ⟩ Used in section 1194. ⟨ Finish the file 642 ⟩ Used in section 1333*. ⟨ Finish the extensions 1378 ⟩ Used in section 1333*.

⟨ Fire up the user’s output routine and return 1025 ⟩ Used in section 1012. ⟨ Fix the reference count, if any, and negate cur val if negative 430 ⟩ Used in section 413. ⟨ Flush the box from memory, showing statistics if requested 639 ⟩ Used in section 638.

⟨ Forbidden cases detected in main control 1048, 1098, 1111, 1144 ⟩ Used in section 1045.

⟨ Generate a down or right command for w and return 610 ⟩ Used in section 607. ⟨ Generate a y0 or z0 command in order to reuse a previous appearance of w 609 ⟩ Used in section 607. ⟨ Get ready to compress the trie 952 ⟩ Used in section 966.

⟨ Get ready to start line breaking 816, 827, 834, 848 ⟩ Used in section 815.

⟨ Get the first line of input and prepare to start 1337 ⟩ Used in section 1332*.

⟨ Get the next non-blank non-call token 406 ⟩ Used in sections 405, 441, 455, 503, 526, 577, 785, 791, and 1045.

⟨ Get the next non-blank non-relax non-call token 404 ⟩

Used in sections 403, 1078, 1084, 1151, 1160, 1211, 1226, and 1270.

⟨ Get the next non-blank non-sign token; set negative appropriately 441 ⟩ Used in sections 440, 448, and 461. ⟨ Get the next token, suppressing expansion 358 ⟩ Used in section 357. ⟨ Get user’s advice and return 83 ⟩ Used in section 82. ⟨ Give diagnostic information, if requested 1031 ⟩ Used in section 1030.

⟨ Give improper error 936 ⟩ Used in section 935. ⟨ Global variables 13, 20, 26, 30, 39, 50, 54, 73, 76, 79, 96, 104, 115, 116*, 117, 118, 124, 165*, 173, 181, 213, 246, 253*,

256, 271, 286, 297, 301, 304, 305, 308, 309, 310, 333, 361, 382, 387, 388, 410, 438, 447, 480, 489, 493, 512, 513*, 520*, 527, 532, 539, 549, 550, 555, 592, 595, 605, 616, 646, 647, 661, 684, 719, 724, 764, 770, 814, 821, 823, 825, 828, 833, 839, 847, 872, 892, 900, 905, 907, 921, 926, 943*, 947, 950, 971, 980, 982, 989, 1032, 1074, 1266, 1281, 1299, 1305*, 1331, 1342, 1345, 1379* ⟩ Used in section 4*.

⟨ Go into display math mode 1145 ⟩ Used in section 1138.

⟨ Go into ordinary math mode 1139 ⟩ Used in sections 1138 and 1142.

⟨ Go through the preamble list, determining the column widths and changing the alignrecords to dummy

unset boxes 801 ⟩ Used in section 800.

⟨ Grow more variable-size memory and goto restart 126 ⟩ Used in section 125. ⟨ Handle situations involving spaces, braces, changes of state 347 ⟩ Used in section 344. ⟨ If a line number class has ended, create new active nodes for the best feasible breaks in that class; then

return if r = last active, otherwise compute the new line width 835 ⟩ Used in section 829. ⟨ If all characters of the family fit relative to h, then goto found , otherwise goto not found 955 ⟩

Used in section 953.

⟨ If an alignment entry has just ended, take appropriate action 342 ⟩ Used in section 341. ⟨ If an expanded code is present, reduce it and goto start cs 355 ⟩ Used in sections 354 and 356. ⟨ If dumping is not allowed, abort 1304 ⟩ Used in section 1302*. ⟨ If instruction cur i is a kern with cur c, attach the kern after q; or if it is a ligature with cur c, combine

noads q and p appropriately; then return if the cursor has moved past a noad, or goto restart 753 ⟩

Used in section 752.

⟨ If no hyphens were found, return 902 ⟩ Used in section 895. ⟨ If node cur p is a legal breakpoint, call try break ; then update the active widths by including the glue in

glue ptr (cur p) 868 ⟩ Used in section 866.

⟨ If node p is a legal breakpoint, check if this break is the best known, and goto done if p is null or if the

page-so-far is already too full to accept more stuff 972 ⟩ Used in section 970. ⟨ If node q is a style node, change the style and goto delete q ; otherwise if it is not a noad, put it into the

hlist, advance q, and goto done; otherwise set s to the size of noad q, set t to the associated type (ord noad . . inner noad ), and set pen to the associated penalty 761 ⟩ Used in section 760.

⟨ If node r is of type delta node, update cur active width, set prev r and prev prev r , then goto continue 832 ⟩

Used in section 829.

⟨ If the current list ends with a box node, delete it from the list and make cur box point to it; otherwise set

cur box ← null 1080 ⟩ Used in section 1079.

⟨ If the current page is empty and node p is to be deleted, goto done1 ; otherwise use node p to update the state of the current page; if this node is an insertion, goto contribute; otherwise if this node is not a legal breakpoint, goto contribute or update heights ; otherwise set pi to the penalty associated with

this breakpoint 1000 ⟩ Used in section 997.

⟨ If the cursor is immediately followed by the right boundary, goto reswitch; if it’s followed by an invalid character, goto big switch; otherwise move the cursor one step to the right and goto main lig loop 1036 ⟩

Used in section 1034.

⟨ If the next character is a parameter number, make cur tok a match token; but if it is a left brace, store

‘left brace, end match’, set hash brace, and goto done 476 ⟩ Used in section 474.

⟨ If the preamble list has been traversed, check that the row has ended 792 ⟩ Used in section 791. ⟨ If the right-hand side is a token parameter or token register, finish the assignment and goto done 1227 ⟩

Used in section 1226.

⟨ If the string hyph word [h] is less than hc[1 . . hn], goto not found ; but if the two strings are equal, set hyf

to the hyphen positions and goto found 931 ⟩ Used in section 930. ⟨ If the string hyph word [h] is less than or equal to s, interchange (hyph word [h], hyph list [h]) with (s, p) 941 ⟩

Used in section 940.

⟨ If there’s a ligature or kern at the cursor position, update the data structures, possibly advancing j;

continue until the cursor moves 909 ⟩ Used in section 906. ⟨ If there’s a ligature/kern command relevant to cur l and cur r , adjust the text appropriately; exit to

main loop wrapup 1039 ⟩ Used in section 1034.

⟨ If this font has already been loaded, set f to the internal font number and goto common ending 1260 ⟩

Used in section 1257.

⟨ If this sup mark starts an expanded character like  or  , then goto reswitch, otherwise set

state ← mid line 352 ⟩ Used in section 344.

⟨ Ignore the fraction operation and complain about this ambiguous case 1183 ⟩ Used in section 1181.

⟨ Implement 1353 ⟩ Used in section 1348. ⟨ Implement 1375 ⟩ Used in section 1348. ⟨ Implement 1351 ⟩ Used in section 1348.

⟨ Implement 1377 ⟩ Used in section 1348. ⟨ Implement 1354 ⟩ Used in section 1348. ⟨ Implement 1352 ⟩ Used in section 1348.

⟨ Incorporate a whatsit node into a vbox 1359 ⟩ Used in section 669. ⟨ Incorporate a whatsit node into an hbox 1360 ⟩ Used in section 651. ⟨ Incorporate box dimensions into the dimensions of the hbox that will contain it 653 ⟩ Used in section 651. ⟨ Incorporate box dimensions into the dimensions of the vbox that will contain it 670 ⟩ Used in section 669. ⟨ Incorporate character dimensions into the dimensions of the hbox that will contain it, then move to the

next node 654 ⟩ Used in section 651.

⟨ Incorporate glue into the horizontal totals 656 ⟩ Used in section 651. ⟨ Incorporate glue into the vertical totals 671 ⟩ Used in section 669. ⟨ Increase the number of parameters in the last font 580 ⟩ Used in section 578. ⟨ Initialize for hyphenating a paragraph 891 ⟩ Used in section 863.

⟨ Initialize table entries (done by only) 164, 222, 228, 232, 240, 250, 258, 552, 946, 951, 1216, 1301, 1369 ⟩

Used in section 8*.

⟨ Initialize the current page, insert the glue ahead of p, and goto continue 1001 ⟩

Used in section 1000.

⟨ Initialize the input routines 331 ⟩ Used in section 1337.

⟨ Initialize the output routines 55, 61*, 528, 533 ⟩ Used in section 1332*. ⟨ Initialize the print selector based on interaction 75 ⟩ Used in sections 1265 and 1337.

⟨ Initialize the special list heads and constant nodes 790, 797, 820, 981, 988 ⟩ Used in section 164. ⟨ Initialize variables as ship out begins 617 ⟩ Used in section 640. ⟨ Initialize whatever TEX might access 8* ⟩ Used in section 4*. ⟨ Initiate or terminate input from a file 378 ⟩ Used in section 367. ⟨ Initiate the construction of an hbox or vbox, then return 1083 ⟩ Used in section 1079. ⟨ Input and store tokens from the next line of the file 483 ⟩ Used in section 482. ⟨ Input for from the terminal 484 ⟩ Used in section 483. ⟨ Input from external file, goto restart if no input found 343 ⟩ Used in section 341. ⟨ Input from token list, goto restart if end of list or if a parameter needs to be expanded 357 ⟩

Used in section 341.

⟨ Input the first line of read file[m] 485 ⟩ Used in section 483. ⟨ Input the next line of read file[m] 486 ⟩ Used in section 483. ⟨ Insert a delta node to prepare for breaks at cur p 843 ⟩ Used in section 836. ⟨ Insert a delta node to prepare for the next active node 844 ⟩ Used in section 836. ⟨ Insert a dummy noad to be sub/superscripted 1177 ⟩ Used in section 1176. ⟨ Insert a new active node from best place[fit class ] to cur p 845 ⟩ Used in section 836. ⟨ Insert a new control sequence after p, then make p point to it 260 ⟩ Used in section 259. ⟨ Insert a new pattern into the linked trie 963 ⟩ Used in section 961. ⟨ Insert a new trie node between q and p, and make p point to it 964 ⟩ Used in section 963. ⟨ Insert a token containing frozen endv 375 ⟩ Used in section 366. ⟨ Insert a token saved by , if any 1269 ⟩ Used in section 1211. ⟨ Insert glue for split top skip and set p ← null 969 ⟩ Used in section 968. ⟨ Insert hyphens as specified in hyph list [h] 932 ⟩ Used in section 931. ⟨ Insert macro parameter and goto restart 359 ⟩ Used in section 357. ⟨ Insert the appropriate mark text into the scanner 386 ⟩ Used in section 367. ⟨ Insert the current list into its environment 812 ⟩ Used in section 800. ⟨ Insert the pair (s, p) into the exception table 940 ⟩ Used in section 939. ⟨ Insert the ⟨v_{j}⟩ template and goto restart 789 ⟩ Used in section 342. ⟨ Insert token p into TEX’s input 326 ⟩ Used in section 282. ⟨ Interpret code c and return if done 84* ⟩ Used in section 83. ⟨ Introduce new material from the terminal and return 87 ⟩ Used in section 84*. ⟨ Issue an error message if cur val = fmem ptr 579 ⟩ Used in section 578.

⟨ Justify the line ending at breakpoint cur p, and append it to the current vertical list, together with

associated penalties and other insertions 880 ⟩ Used in section 877. ⟨ Labels in the outer block 6* ⟩

⟨ Last-minute procedures 1333*, 1335, 1336, 1338* ⟩ Used in section 1330.

⟨ Lengthen the preamble periodically 793 ⟩ Used in section 792. ⟨ Let cur h be the position of the first box, and set leader wd + lx to the spacing between corresponding

parts of boxes 627 ⟩ Used in section 626.

⟨ Let cur v be the position of the first box, and set leader ht + lx to the spacing between corresponding

parts of boxes 636 ⟩ Used in section 635.

⟨ Let d be the natural width of node p; if the node is “visible,” goto found ; if the node is glue that stretches

or shrinks, set v ← max dimen 1147 ⟩ Used in section 1146.

⟨ Let d be the natural width of this glue; if stretching or shrinking, set v ← max dimen; goto found in the

case of leaders 1148 ⟩ Used in section 1147.

⟨ Let d be the width of the whatsit p 1361 ⟩ Used in section 1147. ⟨ Let n be the largest legal code value, based on cur chr 1233 ⟩ Used in section 1232. ⟨ Link node p into the current page and goto done 998 ⟩ Used in section 997. ⟨ Local variables for dimension calculations 450 ⟩ Used in section 448. ⟨ Local variables for finishing a displayed formula 1198 ⟩ Used in section 1194. ⟨ Local variables for formatting calculations 315 ⟩ Used in section 311.

⟨ Local variables for hyphenation 901, 912, 922, 929 ⟩ Used in section 895.

⟨ Local variables for initialization 19*, 163, 927 ⟩ Used in section 4*. ⟨ Local variables for line breaking 862, 893 ⟩ Used in section 815. ⟨ Look ahead for another character, or leave lig stack empty if there’s none there 1038 ⟩ Used in section 1034. ⟨ Look at all the marks in nodes before the break, and set the final link to null at the break 979 ⟩

Used in section 977.

⟨ Look at the list of characters starting with x in font g; set f and c whenever a better character is found;

goto found as soon as a large enough variant is encountered 708 ⟩ Used in section 707. ⟨ Look at the other stack entries until deciding what sort of command to generate; goto found if node

p is a “hit” 611 ⟩ Used in section 607.

⟨ Look at the variants of (z, x); set f and c whenever a better character is found; goto found as soon as a

large enough variant is encountered 707 ⟩ Used in section 706. ⟨ Look for parameter number or ## 479 ⟩ Used in section 477. ⟨ Look for the word hc[1 . . hn] in the exception table, and goto found (with hyf containing the hyphens) if

an entry is found 930 ⟩ Used in section 923.

⟨ Look up the characters of list r in the hash table, and set cur cs 374 ⟩ Used in section 372. ⟨ Make a copy of node p in node r 205 ⟩ Used in section 204. ⟨ Make a ligature node, if ligature present ; insert a null discretionary, if appropriate 1035 ⟩

Used in section 1034.

⟨ Make a partial copy of the whatsit node p and make r point to it; set words to the number of initial words

not yet copied 1357 ⟩ Used in section 206.

⟨ Make a second pass over the mlist, removing all noads and inserting the proper spacing and penalties 760 ⟩

Used in section 726.

⟨ Make final adjustments and goto done 576 ⟩ Used in section 562.

⟨ Make node p look like a char node and goto reswitch 652 ⟩ Used in sections 622, 651, and 1147.

⟨ Make sure that page max depth is not exceeded 1003 ⟩ Used in section 997. ⟨ Make sure that pi is in the proper range 831 ⟩ Used in section 829. ⟨ Make the contribution list empty by setting its tail to contrib head 995 ⟩ Used in section 994. ⟨ Make the first 256 strings 48 ⟩ Used in section 47. ⟨ Make the height of box y equal to h 739 ⟩ Used in section 738. ⟨ Make the running dimensions in rule q extend to the boundaries of the alignment 806 ⟩ Used in section 805. ⟨ Make the unset node r into a vlist node of height w, setting the glue as if the height were t 811 ⟩

Used in section 808.

⟨ Make the unset node r into an hlist node of width w, setting the glue as if the width were t 810 ⟩

Used in section 808.

⟨ Make variable b point to a box for (f, c) 710 ⟩ Used in section 706. ⟨ Manufacture a control sequence name 372 ⟩ Used in section 367. ⟨ Math-only cases in non-math modes, or vice versa 1046 ⟩ Used in section 1045. ⟨ Merge the widths in the span nodes of q with those of p, destroying the span nodes of q 803 ⟩

Used in section 801.

⟨ Modify the end of the line to reflect the nature of the break and to include ; also set the proper

value of disc break 881 ⟩ Used in section 880.

⟨ Modify the glue specification in main p according to the space factor 1044 ⟩ Used in section 1043. ⟨ Move down or output leaders 634 ⟩ Used in section 631. ⟨ Move node p to the current page; if it is time for a page break, put the nodes following the break back onto

the contribution list, and return to the user’s output routine if there is one 997 ⟩ Used in section 994. ⟨ Move pointer s to the end of the current list, and set replace count (r) appropriately 918 ⟩

Used in section 914.

⟨ Move right or output leaders 625 ⟩ Used in section 622. ⟨ Move the characters of a ligature node to hu and hc; but goto done3 if they are not all letters 898 ⟩

Used in section 897.

⟨ Move the cursor past a pseudo-ligature, then goto main loop lookahead or main lig loop 1037 ⟩

Used in section 1034. ⟨ Move the data into trie 958 ⟩ Used in section 966.

⟨ Move to next line of file, or goto restart if there is no next line, or return if a line has finished 360 ⟩

Used in section 343.

⟨ Negate all three glue components of cur val 431 ⟩ Used in section 430. ⟨ Nullify width(q) and the tabskip glue following this column 802 ⟩ Used in section 801.

⟨ Numbered cases for debug help 1339 ⟩ Used in section 1338*. ⟨ Open tfm file for input 563* ⟩ Used in section 562.

⟨ Other local variables for try break 830 ⟩ Used in section 829. ⟨ Output a box in a vlist 632 ⟩ Used in section 631. ⟨ Output a box in an hlist 623 ⟩ Used in section 622. ⟨ Output a leader box at cur h, then advance cur h by leader wd + lx 628 ⟩ Used in section 626. ⟨ Output a leader box at cur v , then advance cur v by leader ht + lx 637 ⟩ Used in section 635. ⟨ Output a rule in a vlist, goto next p 633 ⟩ Used in section 631. ⟨ Output a rule in an hlist 624 ⟩ Used in section 622. ⟨ Output leaders in a vlist, goto fin rule if a rule or to next p if done 635 ⟩ Used in section 634. ⟨ Output leaders in an hlist, goto fin rule if a rule or to next p if done 626 ⟩ Used in section 625. ⟨ Output node p for hlist out and move to the next node, maintaining the condition cur v = base line 620 ⟩

Used in section 619.

⟨ Output node p for vlist out and move to the next node, maintaining the condition cur h = left edge 630 ⟩

Used in section 629.

⟨ Output statistics about this job 1334 ⟩ Used in section 1333*. ⟨ Output the font definitions for all fonts that were used 643 ⟩ Used in section 642. ⟨ Output the font name whose internal number is f 603 ⟩ Used in section 602. ⟨ Output the non-char node p for hlist out and move to the next node 622 ⟩ Used in section 620.

⟨ Output the non-char node p for vlist out 631 ⟩ Used in section 630.

⟨ Output the whatsit node p in a vlist 1366 ⟩ Used in section 631. ⟨ Output the whatsit node p in an hlist 1367 ⟩ Used in section 622. ⟨ Pack the family into trie relative to h 956 ⟩ Used in section 953. ⟨ Package an unset box for the current column and record its width 796 ⟩ Used in section 791. ⟨ Package the preamble list, to determine the actual tabskip glue amounts, and let p point to this prototype

box 804 ⟩ Used in section 800.

⟨ Perform the default output routine 1023 ⟩ Used in section 1012.

⟨ Pontificate about improper alignment in display 1207 ⟩ Used in section 1206.

⟨ Pop the condition stack 496 ⟩ Used in sections 498, 500, 509, and 510.

⟨ Prepare all the boxes involved in insertions to act as queues 1018 ⟩ Used in section 1014. ⟨ Prepare to deactivate node r, and goto deactivate unless there is a reason to consider lines of text from r

to cur p 854 ⟩ Used in section 851.

⟨ Prepare to insert a token that matches cur group, and print what it is 1065 ⟩ Used in section 1064. ⟨ Prepare to move a box or rule node to the current page, then goto contribute 1002 ⟩ Used in section 1000. ⟨ Prepare to move whatsit p to the current page, then goto contribute 1364 ⟩ Used in section 1000. ⟨ Print a short indication of the contents of node p 175 ⟩ Used in section 174*. ⟨ Print a symbolic description of the new break node 846 ⟩ Used in section 845. ⟨ Print a symbolic description of this feasible break 856 ⟩ Used in section 855.

⟨ Print either ‘  ’ or ‘ ’ or ‘  ’ or ‘  ’, and insert tokens that should lead to

recovery 339 ⟩ Used in section 338.

⟨ Print location of current line 313 ⟩ Used in section 312. ⟨ Print newly busy locations 171 ⟩ Used in section 167. ⟨ Print string s as an error message 1283 ⟩ Used in section 1279. ⟨ Print string s on the terminal 1280 ⟩ Used in section 1279. ⟨ Print the banner line, including the date and time 536* ⟩ Used in section 534*.

⟨ Print the font identifier for font (p) 267 ⟩ Used in sections 174* and 176*.

⟨ Print the help information and goto continue 89 ⟩ Used in section 84*. ⟨ Print the list between printed node and cur p, then set printed node ← cur p 857 ⟩ Used in section 856. ⟨ Print the menu of available options 85 ⟩ Used in section 84*. ⟨ Print the result of command c 472 ⟩ Used in section 470. ⟨ Print two lines using the tricky pseudoprinted information 317 ⟩ Used in section 312. ⟨ Print type of token list 314 ⟩ Used in section 312. ⟨ Process an active-character control sequence and set state ← mid line 353 ⟩ Used in section 344. ⟨ Process node-or-noad q as much as possible in preparation for the second pass of mlist to hlist , then move

to the next item in the mlist 727 ⟩ Used in section 726. ⟨ Process whatsit p in vert break loop, goto not found 1365 ⟩ Used in section 973. ⟨ Prune the current list, if necessary, until it contains only char node, kern node, hlist node, vlist node,

rule node, and ligature node items; set n to the length of the list, and set q to the list’s tail 1121 ⟩

Used in section 1119.

⟨ Prune unwanted nodes at the beginning of the next line 879 ⟩ Used in section 877. ⟨ Pseudoprint the line 318 ⟩ Used in section 312. ⟨ Pseudoprint the token list 319 ⟩ Used in section 312. ⟨ Push the condition stack 495 ⟩ Used in section 498.

⟨ Put each of TEX’s primitives into the hash table 226, 230, 238, 248, 265, 334, 376, 384, 411, 416, 468, 487, 491, 553, 780, 983, 1052, 1058, 1071, 1088, 1107, 1114, 1141, 1156, 1169, 1178, 1188, 1208, 1219, 1222, 1230, 1250, 1254, 1262, 1272, 1277, 1286, 1291, 1344 ⟩ Used in section 1336.

⟨ Put help message on the transcript file 90 ⟩ Used in section 82. ⟨ Put the (positive) ‘at’ size into s 1259 ⟩ Used in section 1258. ⟨ Put the characters hu[i + 1 . .] into post break (r), appending to this list and to major tail until

synchronization has been achieved 916 ⟩ Used in section 914. ⟨ Put the characters hu[l . . i] and a hyphen into pre break (r) 915 ⟩ Used in section 914. ⟨ Put the fraction into a box with its delimiters, and make new hlist (q) point to it 748 ⟩ Used in section 743. ⟨ Put the glue at the left and detach this line 887 ⟩ Used in section 880. ⟨ Put the optimal current page into box 255, update first mark and bot mark , append insertions to their

boxes, and put the remaining nodes back on the contribution list 1014 ⟩ Used in section 1012. ⟨ Put the glue after node q 886 ⟩ Used in section 881. ⟨ Read and check the font data; abort if the file is malformed; if there’s no room for this font, say so

and goto done; otherwise incr (font ptr ) and goto done 562 ⟩ Used in section 560. ⟨ Read box dimensions 571 ⟩ Used in section 562.

⟨ Read character data 569 ⟩ Used in section 562.

⟨ Read extensible character recipes 574 ⟩ Used in section 562.

⟨ Read font parameters 575* ⟩ Used in section 562.

⟨ Read ligature/kern program 573 ⟩ Used in section 562. ⟨ Read next line of file into buffer , or goto restart if the file has ended 362 ⟩ Used in section 360. ⟨ Read one string, but return false if the string memory space is getting too tight for comfort 52* ⟩

Used in section 51*.

⟨ Read the first line of the new file 538 ⟩ Used in section 537*. ⟨ Read the other strings from the file and return true, or give an error message and return

false 51* ⟩ Used in section 47. ⟨ Read the header 568 ⟩ Used in section 562. ⟨ Read the size fields 565 ⟩ Used in section 562.

⟨ Readjust the height and depth of cur box , for 1087 ⟩ Used in section 1086. ⟨ Reconstitute nodes for the hyphenated word, inserting discretionary hyphens 913 ⟩ Used in section 903. ⟨ Record a new feasible break 855 ⟩ Used in section 851. ⟨ Recover from an unbalanced output routine 1027 ⟩ Used in section 1026. ⟨ Recover from an unbalanced write command 1372 ⟩ Used in section 1371.

⟨ Recycle node p 999 ⟩ Used in section 997.

⟨ Remove the last box, unless it’s part of a discretionary 1081 ⟩ Used in section 1080. ⟨ Replace nodes ha . . hb by a sequence of nodes that includes the discretionary hyphens 903 ⟩

Used in section 895.

⟨ Replace the tail of the list by p 1187 ⟩ Used in section 1186. ⟨ Replace z by z′ and compute α, β 572 ⟩ Used in section 571. ⟨ Report a runaway argument and abort 396 ⟩ Used in sections 392 and 399. ⟨ Report a tight hbox and goto common ending , if this box is sufficiently bad 667 ⟩ Used in section 664. ⟨ Report a tight vbox and goto common ending , if this box is sufficiently bad 678 ⟩ Used in section 676. ⟨ Report an extra right brace and goto continue 395 ⟩ Used in section 392. ⟨ Report an improper use of the macro and abort 398 ⟩ Used in section 397. ⟨ Report an overfull hbox and goto common ending , if this box is sufficiently bad 666 ⟩ Used in section 664. ⟨ Report an overfull vbox and goto common ending , if this box is sufficiently bad 677 ⟩ Used in section 676. ⟨ Report an underfull hbox and goto common ending , if this box is sufficiently bad 660 ⟩ Used in section 658. ⟨ Report an underfull vbox and goto common ending , if this box is sufficiently bad 674 ⟩ Used in section 673. ⟨ Report overflow of the input buffer, and abort 35 ⟩ ⟨ Report that an invalid delimiter code is being changed to null; set cur val ← 0 1161 ⟩ Used in section 1160. ⟨ Report that the font won’t be loaded 561 ⟩ Used in section 560. ⟨ Report that this dimension is out of range 460 ⟩ Used in section 448. ⟨ Resume the page builder after an output routine has come to an end 1026 ⟩ Used in section 1100. ⟨ Reverse the links of the relevant passive nodes, setting cur p to the first breakpoint 878 ⟩

Used in section 877.

⟨ Scan a control sequence and set state ← skip blanks or mid line 354 ⟩ Used in section 344. ⟨ Scan a numeric constant 444 ⟩ Used in section 440. ⟨ Scan a parameter until its delimiter string has been found; or, if s = null , simply scan the delimiter

string 392 ⟩ Used in section 391.

⟨ Scan a subformula enclosed in braces and return 1153 ⟩ Used in section 1151. ⟨ Scan ahead in the buffer until finding a nonletter; if an expanded code is encountered, reduce it and

goto start cs ; otherwise if a multiletter control sequence is found, adjust cur cs and loc, and goto

found 356 ⟩ Used in section 354.

⟨ Scan an alphabetic character code into cur val 442 ⟩ Used in section 440.

⟨ Scan an optional space 443 ⟩ Used in sections 442, 448, 455, and 1200.

⟨ Scan and build the body of the token list; goto found when finished 477 ⟩ Used in section 473. ⟨ Scan and build the parameter part of the macro definition 474 ⟩ Used in section 473. ⟨ Scan decimal fraction 452 ⟩ Used in section 448.

⟨ Scan file name in the buffer 531 ⟩ Used in section 530. ⟨ Scan for all other units and adjust cur val and f accordingly; goto done in the case of scaled points 458 ⟩

Used in section 453.

⟨ Scan for units; goto attach fraction if found 454 ⟩ Used in section 453.

⟨ Scan for units and goto attach fraction 456 ⟩ Used in section 453.

⟨ Scan for units that are internal dimensions; goto attach sign with cur val set if found 455 ⟩

Used in section 453.

⟨ Scan preamble text until cur cmd is tab mark or car ret , looking for changes in the tabskip glue; append

an alignrecord to the preamble list 779 ⟩ Used in section 777. ⟨ Scan the argument for command c 471 ⟩ Used in section 470. ⟨ Scan the font size specification 1258 ⟩ Used in section 1257. ⟨ Scan the parameters and make link (r) point to the macro body; but return if an illegal is

detected 391 ⟩ Used in section 389.

⟨ Scan the preamble and record it in the preamble list 777 ⟩ Used in section 774. ⟨ Scan the template ⟨u_{j}⟩, putting the resulting token list in hold head 783 ⟩ Used in section 779. ⟨ Scan the template ⟨v_{j}⟩, putting the resulting token list in hold head 784 ⟩ Used in section 779. ⟨ Scan units and set cur val to x · (cur val + f/2^{16}), where there are x sp per unit; goto attach sign if the

units are internal 453 ⟩ Used in section 448.

⟨ Search eqtb for equivalents equal to p 255 ⟩ Used in section 172. ⟨ Search hyph list for pointers to p 933 ⟩ Used in section 172. ⟨ Search save stack for equivalents that point to p 285 ⟩ Used in section 172. ⟨ Select the appropriate case and return or goto common ending 509 ⟩ Used in section 501.

⟨ Set initial values of key variables 21, 23*, 24, 74, 77, 80, 97, 166, 215, 254, 257, 272, 287, 383, 439, 481, 490, 551, 556,

593, 596, 606, 648, 662, 685, 771, 928, 990, 1033, 1267, 1282, 1300, 1343, 1380* ⟩ Used in section 8*.

⟨ Set line length parameters in preparation for hanging indentation 849 ⟩ Used in section 848. ⟨ Set the glue in all the unset boxes of the current list 805 ⟩ Used in section 800. ⟨ Set the glue in node r and change it from an unset node 808 ⟩ Used in section 807. ⟨ Set the unset box q and the unset boxes in it 807 ⟩ Used in section 805. ⟨ Set the value of b to the badness for shrinking the line, and compute the corresponding fit class 853 ⟩

Used in section 851.

⟨ Set the value of b to the badness for stretching the line, and compute the corresponding fit class 852 ⟩

Used in section 851. ⟨ Set the value of output penalty 1013 ⟩ Used in section 1012.

⟨ Set up data structures with the cursor following position j 908 ⟩ Used in section 906. ⟨ Set up the values of cur size and cur mu, based on cur style 703 ⟩

Used in sections 720, 726, 730, 754, 760, and 763.

⟨ Set variable c to the current escape character 243 ⟩ Used in section 63.

⟨ Ship box p out 640 ⟩ Used in section 638.

⟨ Show equivalent n, in region 1 or 2 223 ⟩ Used in section 252. ⟨ Show equivalent n, in region 3 229 ⟩ Used in section 252. ⟨ Show equivalent n, in region 4 233 ⟩ Used in section 252. ⟨ Show equivalent n, in region 5 242 ⟩ Used in section 252. ⟨ Show equivalent n, in region 6 251 ⟩ Used in section 252. ⟨ Show the auxiliary field, a 219 ⟩ Used in section 218. ⟨ Show the current contents of a box 1296 ⟩ Used in section 1293. ⟨ Show the current meaning of a token, then goto common ending 1294 ⟩ Used in section 1293. ⟨ Show the current value of some parameter or register, then goto common ending 1297 ⟩

Used in section 1293.

⟨ Show the font identifier in eqtb[n] 234 ⟩ Used in section 233. ⟨ Show the halfword code in eqtb[n] 235 ⟩ Used in section 233. ⟨ Show the status of the current page 986 ⟩ Used in section 218. ⟨ Show the text of the macro being expanded 401 ⟩ Used in section 389.

⟨ Simplify a trivial box 721 ⟩ Used in section 720.

⟨ Skip to or , then goto common ending 500 ⟩ Used in section 498.

⟨ Skip to node ha, or goto done1 if no hyphenation should be attempted 896 ⟩ Used in section 894. ⟨ Skip to node hb, putting letters into hu and hc 897 ⟩ Used in section 894. ⟨ Sort p into the list starting at rover and advance p to rlink (p) 132 ⟩ Used in section 131. ⟨ Sort the hyphenation op tables into proper order 945 ⟩ Used in section 952. ⟨ Split off part of a vertical box, make cur box point to it 1082 ⟩ Used in section 1079. ⟨ Squeeze the equation as much as possible; if there is an equation number that should go on a separate line

by itself, set e ← 0 1201 ⟩ Used in section 1199. ⟨ Start a new current page 991 ⟩ Used in sections 215 and 1017. ⟨ Store cur box in a box register 1077 ⟩ Used in section 1075.

⟨ Store maximum values in the hyf table 924 ⟩ Used in section 923. ⟨ Store save stack [save ptr ] in eqtb[p], unless eqtb[p] holds a global value 283 ⟩ Used in section 282. ⟨ Store the current token, but goto continue if it is a blank space that would become an undelimited

parameter 393 ⟩ Used in section 392. ⟨ Subtract glue from break width 838 ⟩ Used in section 837.

⟨ Subtract the width of node v from break width 841 ⟩ Used in section 840. ⟨ Suppress expansion of the next token 369 ⟩ Used in section 367. ⟨ Swap the subscript and superscript into box x 742 ⟩ Used in section 738. ⟨ Switch to a larger accent if available and appropriate 740 ⟩ Used in section 738. ⟨ Tell the user what has run away and try to recover 338 ⟩ Used in section 336. ⟨ Terminate the current conditional and skip to 510 ⟩ Used in section 367. ⟨ Test box register status 505 ⟩ Used in section 501. ⟨ Test if an integer is odd 504 ⟩ Used in section 501. ⟨ Test if two characters match 506 ⟩ Used in section 501. ⟨ Test if two macro texts match 508 ⟩ Used in section 507. ⟨ Test if two tokens match 507 ⟩ Used in section 501. ⟨ Test relation between integers or dimensions 503 ⟩ Used in section 501.

⟨ The em width for cur font 558 ⟩ Used in section 455. ⟨ The x-height for cur font 559 ⟩ Used in section 455.

⟨ Tidy up the parameter just scanned, and tuck it away 400 ⟩ Used in section 392. ⟨ Transfer node p to the adjustment list 655 ⟩ Used in section 651. ⟨ Transplant the post-break list 884 ⟩ Used in section 882. ⟨ Transplant the pre-break list 885 ⟩ Used in section 882.

⟨ Treat cur chr as an active character 1152 ⟩ Used in sections 1151 and 1155.

⟨ Try the final line break at the end of the paragraph, and goto done if the desired breakpoints have been

found 873 ⟩ Used in section 863.

⟨ Try to allocate within node p and its physical successors, and goto found if allocation was possible 127* ⟩

Used in section 125.

⟨ Try to break after a discretionary fragment, then goto done5 869 ⟩ Used in section 866. ⟨ Try to get a different log file name 535 ⟩ Used in section 534*. ⟨ Try to hyphenate the following word 894 ⟩ Used in section 866. ⟨ Try to recover from mismatched 1192 ⟩ Used in section 1191.

⟨ Types in the outer block 18, 25*, 38, 101, 109*, 113*, 150, 212, 269, 300, 548, 594, 920, 925 ⟩ Used in section 4*.

⟨ Undump a couple more things and the closing check word 1327* ⟩ Used in section 1303*. ⟨ Undump constants for consistency check 1308* ⟩ Used in section 1303*.

⟨ Undump regions 1 to 6 of eqtb 1317* ⟩ Used in section 1314.

⟨ Undump the array info for internal font number k 1323* ⟩ Used in section 1321*. ⟨ Undump the dynamic memory 1312* ⟩ Used in section 1303*. ⟨ Undump the font information 1321* ⟩ Used in section 1303*.

⟨ Undump the hash table 1319* ⟩ Used in section 1314.

⟨ Undump the hyphenation tables 1325* ⟩ Used in section 1303*.

⟨ Undump the string pool 1310* ⟩ Used in section 1303*.

⟨ Undump the table of equivalents 1314 ⟩ Used in section 1303*. ⟨ Update the active widths, since the first active node has been deleted 861 ⟩ Used in section 860. ⟨ Update the current height and depth measurements with respect to a glue or kern node p 976 ⟩

Used in section 972.

⟨ Update the current page measurements with respect to the glue or kern specified by node p 1004 ⟩

Used in section 997.

⟨ Update the value of printed node for symbolic displays 858 ⟩ Used in section 829. ⟨ Update the values of first mark and bot mark 1016 ⟩ Used in section 1014. ⟨ Update the values of last glue, last penalty , and last kern 996 ⟩ Used in section 994. ⟨ Update the values of max h and max v ; but if the page is too large, goto done 641 ⟩ Used in section 640. ⟨ Update width entry for spanned columns 798 ⟩ Used in section 796. ⟨ Use code c to distinguish between generalized fractions 1182 ⟩ Used in section 1181. ⟨ Use node p to update the current height and depth measurements; if this node is not a legal breakpoint,

goto not found or update heights , otherwise set pi to the associated penalty at the break 973 ⟩

Used in section 972.

⟨ Use size fields to allocate font information 566 ⟩ Used in section 562. ⟨ Wipe out the whatsit node p and goto done 1358 ⟩ Used in section 202. ⟨ Wrap up the box specified by node r, splitting node p if called for; set wait ← true if node p holds a

remainder after splitting 1021 ⟩ Used in section 1020.

Section Page

Changes to 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 3 Changes to 2. The character set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 8 Changes to 3. Input and output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 9 Changes to 4. String handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 11 Changes to 5. On-line and off-line printing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 12 Changes to 6. Reporting errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 13 Changes to 7. Arithmetic with scaled dimensions . . . . . . . . . . . . . . . . . . . . . . . . 99 14 Changes to 8. Packed data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 15 Changes to 9. Dynamic memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 17 Changes to 10. Data structures for boxes and their friends . . . . . . . . . . . . . . . . 133 18 Changes to 11. Memory layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 18 Changes to 12. Displaying boxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 19 Changes to 13. Destroying boxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199 21 Changes to 14. Copying boxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 21 Changes to 15. The command codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 21 Changes to 16. The semantic nest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 21 Changes to 17. The table of equivalents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 21 Changes to 18. The hash table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256 22 Changes to 19. Saving and restoring equivalents . . . . . . . . . . . . . . . . . . . . . . . . . 268 23 Changes to 20. Token lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 23 Changes to 21. Introduction to the syntactic routines . . . . . . . . . . . . . . . . . . . . . 297 23 Changes to 22. Input stacks and states . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 23 Changes to 23. Maintaining the input stacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 23 Changes to 24. Getting the next token . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 23 Changes to 25. Expanding the next token . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366 23 Changes to 26. Basic scanning subroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402 23 Changes to 27. Building token lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464 23 Changes to 28. Conditional processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487 23 Changes to 29. File names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511 23 Changes to 30. Font metric data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539 26 Changes to 31. Device-independent file format . . . . . . . . . . . . . . . . . . . . . . . . . . . 583 27 Changes to 32. Shipping pages out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592 27 Changes to 33. Packaging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644 28 Changes to 34. Data structures for math mode . . . . . . . . . . . . . . . . . . . . . . . . . . 680 28 Changes to 35. Subroutines for math mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699 28 Changes to 36. Typesetting math formulas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719 28 Changes to 37. Alignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 768 28 Changes to 38. Breaking paragraphs into lines . . . . . . . . . . . . . . . . . . . . . . . . . . . 813 28 Changes to 39. Breaking paragraphs into lines, continued . . . . . . . . . . . . . . . . . 862 29 Changes to 40. Pre-hyphenation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 891 30 Changes to 41. Post-hyphenation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 900 30 Changes to 42. Hyphenation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 919 30 Changes to 43. Initializing the hyphenation tables . . . . . . . . . . . . . . . . . . . . . . . 942 30 Changes to 44. Breaking vertical lists into pages . . . . . . . . . . . . . . . . . . . . . . . . . 967 32 Changes to 45. The page builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 980 32 Changes to 46. The chief executive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1029 32 Changes to 47. Building boxes and lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055 32 Changes to 48. Building math lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1136 32 Changes to 49. Mode-independent processing . . . . . . . . . . . . . . . . . . . . . . . . . . . 1208 32 Changes to 50. Dumping and undumping the tables . . . . . . . . . . . . . . . . . . . . . 1299 33 Changes to 51. The main program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1330 41 Changes to 52. Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1338 43 Changes to 53. Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1340 44 Changes to 54. System-dependent changes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1379 44 Changes to 55. Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1381 45