§1  changes for C  PART 1: INTRODUCTION 3

2* . The present implementation has a long ancestry, beginning in the spring of 1977, when its author wrote a prototype set of subroutines and macros that were used to develop the first Computer Modern fonts. This original proto- required the user to recompile a SAIL program whenever any character was changed, because it was not a “language” for font design; the language was SAIL. After several hundred characters had been designed in that way, the author developed an interpretable language called , in which it was possible to express the Computer Modern programs less cryptically. A complete processor was designed and coded by the author in 1979. This program, written in SAIL, was adapted for use with a variety of typesetting equipment and display terminals by Leo Guibas, Lyle Ramshaw, and David Fuchs. Major improvements to the design of Computer Modern fonts were made in the spring of 1982, after which it became clear that a new language would better express the needs of letterform designers. Therefore an entirely new language and system were developed in 1984; the present system retains the name and some of the spirit of 79, but all of the details have changed.

No doubt there still is plenty of room for improvement, but the author is firmly committed to keeping 84 “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 84 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 undergoes any modifications, so that it will be clear which version of might be the guilty party when a problem arises.

If this program is changed, the resulting system should not be called ‘ ’; the official name ‘ ’ 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 an implementation deserves to be known as ‘ ’ [cf. Stanford Computer Science report CS1095, January 1986].

define banner ≡ ´ ␣  ␣         ␣ ␣       ␣ ´  { printed when  starts }

7* . Some of the code below is intended to be used only when diagnosing the strange behavior that sometimes occurs when is being installed or when system wizards are fooling around with 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 ’s memory usage. The stat … tats code also implements special diagnostic information that is printed when tracingedges > 1.

define stat ≡ ifdef (´ ´ )

define tats ≡ endif (´ ´ )

define debug ≡ ifdef (´ ´ )

define gubed ≡ 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 ’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

4  PART 1: INTRODUCTION  changes for C §9

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 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* ⟩ ≡

Nocompiler directives

for C.

This code is used in section 4.

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

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

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

max halfword ; must be equal to mem top in , otherwise ≥ mem top } max internal = 300; { maximum number of internal quantities } buf size = 3000; { maximum number of characters simultaneously present in current lines of open files;

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 } screen width = 1664; { number of pixels in each row of screen display } screen depth = 1200; { number of pixels in each column of screen display } stack size = 300; { maximum number of simultaneous input sources } 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

identifier names and strings, after ’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 identifiers; must exceed string vacancies by the total length of ’s own strings, which is currently about 22000 }

move size = 20000; { space for storing moves in a single octant } max wiggle = 1000; { number of autorounded points per cycle } gf 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 } path size = 1000; { maximum number of knots between breakpoints of a path } bistack size = 1500; { size of stack for bisection algorithms; should probably be left at this value } header size = 100; { maximum number of header words, times 4 } lig table size = 15000;

{ maximum number of ligature/kern steps, must be at least 255 and at most 32510 } max kerns = 2500; { maximum number of distinct kern amounts } max font dimen = 50; { maximum number of fontdimen parameters } mem top = 262140; { largest index in the mem array dumped by ; must be substantially larger

than mem min 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 ’s capacity. But if they are changed, it is necessary to rerun the initialization program to generate new tables for the production 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 min = 0 { smallest index in the mem array, must not be less than min halfword } define hash size = 9500

{ maximum number of symbolic tokens, must be less than max halfword − 3 ∗ param size }

define hash prime = 7919 { a prime number equal to about 85% of hash size } define max in open = 15

{ maximum number of input files and error insertions that can be going on simultaneously }

define param size = 150 { maximum number of simultaneous macro parameters }

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

define negate(#) ≡ # ← −# { change the sign of a variable } define double(#) ≡ # ← # + # { multiply a variable by two } 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 { will henceforth say return instead of return }

6  PART 2: THE CHARACTER SET  changes for C §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 font design; so the present specification of 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 section 130. This code is used in section 4.

22* . 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. If 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 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 are allowed to have in their input files. Appropriate changes to ’s char class table should then be made. (Unlike TEX, each installation of has a fixed assignment of category codes, called the char class .) Such changes make portability of programs more difficult, so they should be introduced cautiously if at all.

define tab = ´ 11 { ASCII horizontal tab }

define form feed = ´ 14 { ASCII form feed } ⟨ 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);

§24  changes for C  PART 3: INPUT AND OUTPUT 7

24* . 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; (5) display of bits on the user’s screen. The bit-display operation will be discussed in a later section; we shall deal here only with more traditional kinds of I/O.

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 }

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

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

30* . The input ln function brings the next line of input from the specified field 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 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.

We define input ln in C, for efficiency.

31* . 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 }

8  PART 3: INPUT AND OUTPUT  changes for C §32

32* . 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 }

33* . 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 )

36* . 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;

§37  changes for C  PART 4: STRING HANDLING 9

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, MF 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 bad pool (´ ␣ ␣ ´ ´ ␣ ␣ ´ )

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 ; str ref [g] ← max str ref ; 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*.

10  PART 5: ON-LINE AND OFF-LINE PRINTING  changes for C §54

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

wterm(banner );

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

§67  changes for C  PART 6: REPORTING ERRORS 11

76* . The jump out procedure just cuts across all active procedure levels and goes to end of MF . 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 73 ⟩ +≡ procedure jump out ;

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

79* . It is desirable to provide an ‘ ’ option here that gives the user an easy way to return from - 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 has closed its files.

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

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

case c of

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

⟨ Delete c − tokens and goto continue 83 ⟩; debug : begin debug help; goto continue; end; gubed : if file 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 84 ⟩; : ⟨ Introduce new material from the terminal and return 82 ⟩; , , : ⟨ Change the interaction level and return 81 ⟩; : begin interaction ← scroll mode; jump out ;

end;

othercases do nothing

endcases; ⟨ Print the menu of available options 80 ⟩

This code is used in section 78.

12  PART 9: PACKED DATA  changes for C §95

153* . Packed data. In order to make efficient use of storage space, bases its major data structures on a memory word , which contains either a (signed) integer, possibly scaled, 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.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. 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.

N.B.: Valuable memory space will be dreadfully wasted unless is compiled by a Pascal that packs all of the memory word variants into the space of a single integer. 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 }

155* . The operation of subtracting min halfword occurs rather frequently in , so it is convenient to abbreviate this operation by using the macro ho defined here. will run faster with respect to compilers that don’t optimize the expression ‘x − 0’, if this macro is simplified in the obvious way when min halfword = 0. Similarly, qi and qo are used for input to and output from quarterwords. So they have been simplified here in the obvious way.

define ho(#) ≡ #

define qo(#) ≡ #

define qi (#) ≡ #

156* . 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 ; { 1/4 of a word }

halfword = min halfword . . max halfword ; { 1/2 of a word }

two choices = 1 . . 2; { used when there are two variants in a record }

three choices = 1 . . 3; { used when there are three variants in a record }

   \underline{\overline{#       ␣}}

§158  changes for C  PART 10: DYNAMIC MEMORY ALLOCATION 13

169* . ⟨ Try to allocate within node p and its physical successors, and goto found if allocation was

possible 169* ⟩ ≡ q ← p + node size(p); { find the physical successor } while is empty (q) do { merge node p with node q }

begin t ← rlink (q); tt ← llink (q);

if q = rover then rover ← t;

llink (t) ← tt ; rlink (tt ) ← 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 170 ⟩; if r = p then

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

This code is used in section 167.

14  PART 11: MEMORY LAYOUT  changes for C §175

178* . If 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 ’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

182* . ⟨ Check variable-size avail list 182* ⟩ ≡ p ← rover ; q ← null ; clobbered ← false; repeat if (p ≥ lo mem max ) then clobbered ← true

else if (rlink (p) ≥ lo mem max ) then clobbered ← true

else if ¬(is empty (p)) ∨ (node size(p) < 2) ∨ (p + node size(p) > lo mem max ) ∨

(llink (rlink (p)) ≠ p) then clobbered ← true;

if clobbered then

begin print nl ( ␣ ␣ ␣ ␣ ); print int (q); goto done2 ; end;

for q ← p to p + node size(p) − 1 do { mark all locations free }

begin if free[q] then begin print nl ( ␣ ␣ ␣ ␣ ); print int (q); goto done2 ; end; free[q] ← true; end;

q ← p; p ← rlink (p); until p = rover ;

done2 :

This code is used in section 180.

§186  changes for C  PART 12: THE COMMAND CODES 15

194* . The following procedure, which is called just before initializes its input and output, establishes the initial values of the date and time. It is calls an externally defined date and time, even though it could be done from Pascal. The external procedure also sets up interrupt catching.

Note that the values are scaled integers. Hence can no longer be used after the year 32767. procedure fix date and time;

begin date and time(internal [time], internal [day ], internal [month], internal [year ]); internal [time] ← internal [time] ∗ unity ; internal [day ] ← internal [day ] ∗ unity ; internal [month] ← internal [month] ∗ unity ; internal [year ] ← internal [year ] ∗ unity ; end;

199* . If changes are made to accommodate non-ASCII character sets, they should follow the guidelines in Appendix C of The book. ⟨ Set initial values of key variables 21 ⟩ +≡

for k ← to do char class [k] ← digit class ; char class [ ] ← period class ; char class [ ␣ ] ← space class ; char class [ % ] ← percent class ; char class [ ] ← string class ; char class [ ] ← 5; char class [ ] ← 6; char class [ ] ← 7; char class [ ] ← right paren class ;

for k ←  to  do char class [k] ← letter class ;
for k ←  to  do char class [k] ← letter class ;

char class [ ] ← letter class ; char class [ ] ← 10; char class [ ] ← 10; char class [ ] ← 10; char class [ ] ← 10; char class [ ] ← 10; char class [ ` ] ← 11; char class [ ´ ] ← 11; char class [ ] ← 12; char class [ ] ← 12; char class [ ] ← 13; char class [ ] ← 13; char class [ ] ← 13; char class [ ] ← 14; char class [ ] ← 14; char class [ # ] ← 15; char class [ ] ← 15; char class [ ] ← 15; char class [ $ ] ← 15; char class [ ] ← 16; char class [ ] ← 16; char class [ ] ← left bracket class ; char class [ ] ← right bracket class ; char class [ ] ← 19; char class [ ] ← 19; for k ← 0 to ␣ − 1 do char class [k] ← invalid class ; for k ← 127 to 255 do char class [k] ← invalid class ; char class [tab] ← space class ; char class [form feed ] ← space class ;

16  PART 27: ONLINE GRAPHIC OUTPUT  changes for C §200

564* . Online graphic output. displays images on the user’s screen by means of a few primitive operations that are defined below. These operations have deliberately been kept simple so that they can be implemented without great difficulty on a wide variety of machines. Since Pascal has no traditional standards for graphic output, some system-dependent code needs to be written in order to support this aspect of ; but the necessary routines are usually quite easy to write.

In fact, there are exactly four such routines: init screen does whatever initialization is necessary to support the other operations; it is a boolean function

that returns false if graphic output cannot be supported (e.g., if the other three routines have not been written, or if the user doesn’t have the right kind of terminal).

blank rectangle updates a buffer area in memory so that all pixels in a specified rectangle will be set to the

background color. paint row assigns values to specified pixels in a row of the buffer just mentioned, based on “transition”

indices explained below. update screen displays the current screen buffer; the effects of blank rectangle and paint row commands may

or may not become visible until the next update screen operation is performed. (Thus, update screen is analogous to update terminal .)

The Pascal code here is a minimum version of init screen and update screen, usable on installations that don’t support screen output. If init screen is changed to return true instead of false, the other routines will simply log the fact that they have been called; they won’t really display anything. The standard test routines for use this log information to check that is working properly, but the wlog instructions should be removed from production versions of .

These functions/procedures are defined externally in C.

567* . The blank rectangle routine simply whitens all pixels that lie in columns left col through right col −1, inclusive, of rows top row through bot row − 1, inclusive, given four parameters that satisfy the relations

0 ≤ left col ≤ right col ≤ screen width, 0 ≤ top row ≤ bot row ≤ screen depth.

If left col = right col or top row = bot row , nothing happens.

The commented-out code in the following procedure is for illustrative purposes only.

Same thing

568* . The real work of screen display is done by paint row . But it’s not hard work, because the operation affects only one of the screen rows, and it affects only a contiguous set of columns in that row. There are four parameters: r (the row), b (the initial color), a (the array of transition specifications), and n (the number of transitions). The elements of a will satisfy

0 ≤ a[0] < a[1] < ⋯ < a[n] ≤ screen width;

the value of r will satisfy 0 ≤ r < screen depth; and n will be positive.

The general idea is to paint blocks of pixels in alternate colors; the precise details are best conveyed by means of a Pascal program (see the commented-out code below).

§585  changes for C  PART 38: FILE NAMES 17

Same thing 768* . 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 first remaining ‘ ’ 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 }

769* . Input files that can’t be found in the user’s area may appear in a standard system area called MF area. This system area name 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.

771* . And here’s the second. function more name(c : ASCII code): boolean;

begin if (c = ␣ ) ∨ (c = tab) then more name ← false

else begin if (c = ) then begin area delimiter ← pool ptr ; ext delimiter ← 0; end

else if (c = ) ∧ (ext delimiter = 0) then ext delimiter ← pool ptr ; str room(1); append char (c); { contribute c to the current string } more name ← true; end;

end;

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

In C, 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 base area length = 0 { length of its area part }

define base ext length = 5 { length of its ‘ ’ part }

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

776* . 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.

18  PART 38: FILE NAMES  changes for C §779

779* . Here is the only place we use pack buffered name. This part of the program becomes active when a “virgin” is trying to get going, just after the preliminary initialization, or when the user is substituting another base 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 base file 779* ⟩ ≡ function open base file: boolean;

label found , exit ;

var j: 0 . . buf size; { the first space after the 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(base 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(base default length − base ext length, 1, 0);

if ¬w open in(base file) then begin wake up terminal ; wterm ln(´ ␣ ´ ´ ␣ ␣ ␣ ␣ ␣ ´ ); open base file ← false; return; end;

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

This code is used in section 1187.

781* . Now let’s consider the “driver” routines by which deals with file names in a systemindependent manner. First comes a procedure that looks for a file name in the input by taking the information from the input buffer. (We can’t use get next , because the conversion to tokens would destroy necessary information.)

This procedure doesn’t allow semicolons or percent signs to be part of file names, because of other conventions of . The manual doesn’t use semicolons or percents immediately after file names, but some users no doubt will find it natural to do so; therefore system-dependent changes to allow such characters in file names should probably be made with reluctance, and only when an entire file name that includes special characters is “quoted” somehow. procedure scan file name;

label done;

begin begin name;

while (buffer [loc] = ␣ ) ∨ (buffer [loc] = tab) do incr (loc);

loop begin if (buffer [loc] = ) ∨ (buffer [loc] = % ) then goto done; if ¬more name(buffer [loc]) then goto done; incr (loc); end;

done: end name; end; 787* . ⟨ Scan file name in the buffer 787* ⟩ ≡

begin begin name; k ← first ; while ((buffer [k] = ␣ ) ∨ (buffer [k] = tab)) ∧ (k < last ) do incr (k); loop begin if k = last then goto done;

if ¬more name(buffer [k]) then goto done; incr (k); end;

done: end name;

end

This code is used in section 786.

788* . 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 } m: integer ; { the current month } 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 789 ⟩; log name ← a make name string (log file); selector ← log only ; log opened ← true; ⟨ Print the banner line, including the date and time 790* ⟩; input stack [input ptr ] ← cur input ; { make sure bottom level is in memory } print nl ( ); l ← input stack [0].limit field − 1; { last position of first line } 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;

790* . ⟨ Print the banner line, including the date and time 790* ⟩ ≡ begin wlog (banner ); print (base ident ); print ( ␣␣ ); print int (round unscaled (internal [day ])); print char ( ␣ ); months ← ´ ␣ ´ ; m ← round unscaled (internal [month]); for k ← 3 ∗ m − 2 to 3 ∗ m do wlog (months [k]); print char ( ␣ ); print int (round unscaled (internal [year ])); print char ( ␣ ); m ← round unscaled (internal [time]); print dd (m div 60); print char ( ); print dd (m mod 60); end

This code is used in section 788*.

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

label done; begin ⟨ Put the desired file name in (cur name, cur ext , cur area) 795 ⟩; 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, MF 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, MF 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); str ref [cur name] ← max str ref ;

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 − 2 then print ln else if (term offset > 0) ∨ (file offset > 0) then print char ( ␣ ); print char ( ); incr (open parens ); print (name); update terminal ; ⟨ Read the first line of the new file 794 ⟩; end;

§796  changes for C  PART 42: DOING THE OPERATIONS 21

965* . ⟨ Shift the edges by (tx , ty ), rounded 965* ⟩ ≡ tx ← round unscaled (tx ); ty ← round unscaled (ty ); if (toint (m min(cur edges )) + tx ≤ 0) ∨ (m max (cur edges ) + tx ≥ 8192) ∨

(toint (n min(cur edges )) + ty ≤ 0) ∨ (n max (cur edges ) + ty ≥ 8191) ∨ (abs (tx ) ≥ 4096) ∨ (abs (ty ) ≥ 4096) then

begin print err (  ␣   ␣  ␣  );

help3 ( ␣   ´ ␣     ␣   ␣       ␣  ␣             ␣  )
(  ␣    ␣          ␣   ␣     ␣  ␣   ␣  )

(  ␣   ␣ ´ ␣    ␣   ␣  ); put get error ;

end else begin if tx ≠ 0 then

begin if ¬valid range(m offset (cur edges ) − tx ) then fix offset ;

m min(cur edges ) ← m min(cur edges ) + tx ; m max (cur edges ) ← m max (cur edges ) + tx ; m offset (cur edges ) ← m offset (cur edges ) − tx ; last window time(cur edges ) ← 0; end;

if ty ≠ 0 then begin n min(cur edges ) ← n min(cur edges ) + ty ; n max (cur edges ) ← n max (cur edges ) + ty ; n pos (cur edges ) ← n pos (cur edges ) + ty ; last window time(cur edges ) ← 0; end;

end

This code is used in section 964.

22  PART 45: FONT METRIC DATA  changes for C §989

1120* . The smallest d such that a given list can be covered with m intervals is determined by the threshold routine, which is sort of an inverse to min cover . The idea is to increase the interval size rapidly until finding the range, then to go sequentially until the exact borderline has been discovered. function threshold fn(m : integer ): scaled ;

var d: scaled ; { lower bound on the smallest interval size } begin excess ← min cover (0) − m; if excess ≤ 0 then threshold fn ← 0 else begin repeat d ← perturbation;

until min cover (d + d) ≤ m;

while min cover (d) > m do d ← perturbation;

threshold fn ← d;

end; end;

1121* . The skimp procedure reduces the current list to at most m entries, by changing values if necessary. It also sets info(p) ← k if value(p) is the kth distinct value on the resulting list, and it sets perturbation to the maximum amount by which a value field has been changed. The size of the resulting list is returned as the value of skimp. function skimp(m : integer ): integer ;

var d: scaled ; { the size of intervals being coalesced } p, q, r: pointer ; { list manipulation registers } l: scaled ; { the least value in the current interval } v: scaled ; { a compromise value }

begin d ← threshold fn(m); perturbation ← 0; q ← temp head ; m ← 0; p ← link (temp head ); while p ≠ inf val do

begin incr (m); l ← value(p); info(p) ← m;

if value(link (p)) ≤ l + d then ⟨ Replace an interval of values by its midpoint 1122 ⟩; q ← p; p ← link (p); end;

skimp ← m; end;

1133* . Finally we’re ready to actually write the information. Here are some utility routines for this purpose.

Under UNIX, we are using the binary input and output routines. Hence, we redefine all the TFM input and output in terms of those routines.

define tfm out (#) ≡ b write byte(tfm file, #) define tfm two(#) ≡ b write 2 bytes (tfm file, #) define tfm four (#) ≡ b write 4 bytes (tfm file, #)

procedure tfm qqqq (x : four quarters ); { output four quarterwords to tfm file } begin tfm out (qo(x.b0 )); tfm out (qo(x.b1 )); tfm out (qo(x.b2 )); tfm out (qo(x.b3 )); end;

§1142  changes for C  PART 47: SHIPPING CHARACTERS OUT 23

1154* . The actual output of gf buf [a . . b] to gf file is performed by calling write gf (a, b). It is safe to assume that a and b + 1 will both be multiples of 4 when write gf (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.

1163* . Here is a routine that gets a file off to a good start.

define check gf ≡ if output file name = 0 then init gf ⟨ Declare generic font output procedures 1155 ⟩ +≡ procedure init gf ;

var k: 0 . . 256; { runs through all possible character codes }

t: integer ; { the time of this run } begin gf min m ← 4096; gf max m ← −4096; gf min n ← 4096; gf max n ← −4096; for k ← 0 to 255 do char ptr [k] ← −1; ⟨ Determine the file extension, gf ext 1164 ⟩; set output file name; gf out (pre); gf out (gf id byte); { begin to output the preamble } old setting ← selector ; selector ← new string ; print ( ␣ ␣ ␣ ); print int (round unscaled (internal [year ])); print char ( ); print dd (round unscaled (internal [month])); print char ( ); print dd (round unscaled (internal [day ])); print char ( ); t ← round unscaled (internal [time]); print dd (t div 60); print dd (t mod 60); selector ← old setting ; gf out (cur length); str start [str ptr + 1] ← pool ptr ; gf string (0, str ptr ); pool ptr ← str start [str ptr ]; { flush that string from memory } gf prev ptr ← gf offset + gf ptr ; end;

1169* . In this loop, prev w represents the weight at column prev m, which is the most recent column reflected in the output so far; w represents the weight at column m, which is the most recent column in the edge data. Several edges might cancel at the same column position, so we need to look ahead to column mm before actually outputting anything. ⟨ Output the pixels of edge row p to font row n 1169* ⟩ ≡

if unsorted (p) > void then sort edges (p); q ← sorted (p); w ← 0; prev m ← −fraction one; { fraction one ≈ ∞ } ww ← 0; prev w ← 0; m ← prev m; repeat if q = sentinel then mm ← fraction one

else begin d ← ho(info(q)); mm ← d div 8; ww ← ww + (d mod 8) − zero w ;

end; if mm ≠ m then

begin if prev w ≤ 0 then begin if w > 0 then ⟨ Start black at (m, n) 1170 ⟩; end

else if w ≤ 0 then ⟨ Stop black at (m, n) 1171 ⟩; m ← mm; end;

w ← ww ; q ← link (q); until mm = fraction one; if w ≠ 0 then { this should be impossible }

print nl ( ´ ␣ ␣ ␣ ␣ ␣ ␣ ); if prev m − toint (m offset (cur edges )) + x off > gf max m then

gf max m ← prev m − m offset (cur edges ) + x off

This code is used in section 1167.

24  PART 48: DUMPING AND UNDUMPING THE TABLES  changes for C §1183

1188* . Base files consist of memory word items, and we use the following macros to dump words of different types: ⟨ Global variables 13 ⟩ +≡ base file: word file; { for input or output of base information }

1189* . 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 off base 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 off base; undump size end

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

undump int (x); if x ≠ $ then goto off base; { check that strings are the same } undump int (x); if x ≠ mem min then goto off base; undump int (x); if x ≠ mem top then goto off base; undump int (x); if x ≠ hash size then goto off base; undump int (x); if x ≠ hash prime then goto off base; undump int (x); if x ≠ max in open then goto off base

This code is used in section 1187.

1199* . ⟨ Undump a few more things and the closing check word 1199* ⟩ ≡ undump(max given internal )(max internal )(int ptr ); for k ← 1 to int ptr do

begin undump int (internal [k]); undump(0)(str ptr )(int name[k]); end;

undump(0)(frozen inaccessible)(start sym); undump(batch mode)(error stop mode)(interaction); undump(0)(str ptr )(base ident ); undump(1)(hash end )(bg loc); undump(1)(hash end )(eg loc); undump int (serial no); undump int (x); if (x ≠ 69069) ∨ feof (base file) then goto off base

This code is used in section 1187.

§1200  changes for C  PART 48: DUMPING AND UNDUMPING THE TABLES 25

1200* . ⟨ Create the base ident , open the base file, and inform the user that dumping has begun 1200* ⟩ ≡ selector ← new string ; print ( ␣ ); print (job name); print char ( ␣ ); print int (round unscaled (internal [year ]) mod 100); print char ( ); print int (round unscaled (internal [month])); print char ( ); print int (round unscaled (internal [day ])); print char ( ); if interaction = batch mode then selector ← log only else selector ← term and log ; str room(1); base ident ← make string ; str ref [base ident ] ← max str ref ; pack job name(base extension); while ¬w open out (base file) do prompt file name( ␣ ␣ , base extension); print nl ( ␣ ␣ ␣ ␣ ␣ ); print (w make name string (base file)); flush string (str ptr − 1); print nl (base ident )

This code is used in section 1186.

26  PART 49: THE MAIN PROGRAM  changes for C §1202

1204* . Now this is really it: 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.”

begin { start here } history ← fatal error stop; { in case we quit during initialization } t open out ; { open the terminal for output } set paths (MF BASE PATH BIT + MF INPUT PATH BIT + MF POOL PATH BIT ); if ready already = 314159 then goto start of MF ; ⟨ 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 tab; { initialize the tables } init prim; { call primitive for each primitive } init str ptr ← str ptr ; init pool ptr ← pool ptr ; max str ptr ← str ptr ; max pool ptr ← pool ptr ; fix date and time; tini ready already ← 314159;

start of MF : ⟨ Initialize the output routines 55 ⟩; ⟨ Get the first line of input and prepare to start 1211 ⟩; history ← spotless ; { ready to go! } if start sym > 0 then { insert the ‘everyjob’ symbol }

begin cur sym ← start sym; back input ;

end; main control ; { come to life } final cleanup; { prepare for death } close files and terminate;

final end : do final end ; end.

§1205  changes for C  PART 49: THE MAIN PROGRAM 27

1205* . Here we do whatever is needed to complete ’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.

This program doesn’t bother to close the input files that may still be open. ⟨ Last-minute procedures 1205* ⟩ ≡ procedure close files and terminate;

var k: integer ; { all-purpose index } lh: integer ; { the length of the header, in words } lk offset : 0 . . 256; { extra words inserted at beginning of lig kern array } p: pointer ; { runs through a list of dimensions } x: scaled ; { a tfm width value being output to the file }

begin stat if internal [tracing stats ] > 0 then ⟨ Output statistics about this job 1208 ⟩; tats wake up terminal ; ⟨ Finish the and files 1206 ⟩;

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 1209, 1210, and 1212. This code is used in section 1202.

28  PART 51: SYSTEM-DEPENDENT CHANGES  changes for C §1212

1214* . System-dependent changes. Here are the variables used to hold “switch-to-editor” information. ⟨ Global variables 13 ⟩ +≡ edit name start : pool pointer ; edit name length, edit line: integer ;

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

§1216  changes for C  PART 52: INDEX 29

edit name start ← 0; 1216* . 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 in a new operating environment. A list of various things that can’t happen appears under “this can’t happen”. Approximately 25 sections are listed under “inner loop”; these account for more than 60% of ’s running time, exclusive of input and output.

The following sections were changed by the change file: 2, 7, 8, 9, 11, 12, 16, 19, 22, 24, 26, 27, 30, 31, 32, 33, 36, 51, 52, 53, 61, 76, 79, 153, 155, 156, 169, 178, 182, 194, 199, 564, 567, 568, 768, 769, 771, 775, 776, 779, 781, 787, 788, 790, 793, 965, 1120, 1121, 1133, 1154, 1163, 1169, 1188, 1189, 1191, 1199, 1200, 1204, 1205, 1214, 1215, 1216.

primitive: \underline{893}. : 68, 807. primitive: \underline{893}. : 36* , 788* . : 679. primitive: \underline{893}. primitive: \underline{893}. primitive: \underline{893}. primitive: \underline{211}. primitive: \underline{893}. : 227. token: 669. primitive: \underline{211}. primitive: \underline{893}. primitive: \underline{211}. primitive: \underline{211}. primitive: \underline{211}. primitive: \underline{211}. primitive: \underline{211}. primitive: \underline{893}. primitive: \underline{893}. primitive: \underline{893}. primitive: \underline{893}. primitive: \underline{1108}. primitive: \underline{1108}. primitive: \underline{1108}. primitive: \underline{1108}. primitive: \underline{1108}. primitive: \underline{1108}. primitive: \underline{1108}. primitive: \underline{1108}. : 682. primitive: \underline{893}. primitive: \underline{893}. : 807, 1040. : 398, 1041. : 261, 263. : 59, 60, 257, 258. : 78, 638. primitive: \underline{211}. primitive: \underline{211}. primitive: \underline{211}. primitive: \underline{211}. #### : 603. ### : 817. ## : 613. # primitive: \underline{688}. # primitive: \underline{688}. primitive: \underline{688}. : 509. : 510. : 515, 521. primitive: \underline{211}. a: \underline{47}, \underline{102}, \underline{117}, \underline{124}, \underline{126}, \underline{321}, \underline{391}, \underline{429}, \underline{431}, \underline{433},

\underline{440}, \underline{722}, \underline{773}, \underline{774}, \underline{778}, \underline{976}, \underline{977}, \underline{978}.

: 1140.

: 832. : 823. : 862. : 990. : 864. a close: 51* , 655, 1205* . a make name string : \underline{780}, 788* , 793* . a minus b: \underline{865}, 866. a open in: 51* , 793* . a open out : 788* . a plus b: \underline{865}, 866. a tension: \underline{296}. aa: \underline{286}, 288, 290, 291, 301, \underline{321}, 322, \underline{440},

444, 445, 446. aaa: \underline{321}, 322. ab vs cd : \underline{117}, 152, 300, 306, 317, 375, 376, 479, 488, 502, 516, 522, 546, 548, 549, 943, 949.

abnegate: \underline{390}, 413, 421. abort find : \underline{242}, 243. abs : 65, 124, 126, 150, 151, 152, 260, 288, 289,

30  PART 52: INDEX  changes for C §1216

292, 294, 295, 299, 300, 302, 321, 326, 362, 378, 404, 408, 426, 433, 434, 437, 441, 445, 457, 459, 479, 496, 498, 502, 529, 533, 540, 543, 589, 591, 595, 596, 598, 599, 600, 603, 611, 612, 615, 616, 812, 814, 837, 866, 915, 943, 949, 965* , 1008, 1056, 1098, 1129, 1140, 1182. absorbing : \underline{659}, 664, 665, 730. acc: \underline{116}, \underline{286}, 290. add mac ref : \underline{226}, 720, 845, 862, 864, 868, 1035. add mult dep: \underline{971}, 972. add or subtract : 929, \underline{930}, 936, 939. add pen ref : \underline{487}, 621, 855, 1063. add str ref : \underline{42}, 621, 678, 855, 1083. addto primitive: \underline{211}. add to command : \underline{186}, 211, 212, 1058. add to type: \underline{1059}, 1064. after : 426, \underline{427}, 429, 436, 439, 440, 444, 446. all safe: \underline{426}, \underline{440}, 446. alpha: \underline{296}, \underline{433}, 436, 439, \underline{440}, 444, \underline{527}, 528,

529, 530, 533. alpha file: 24* , 50, 54, 631, 780. already there: \underline{577}, 578, 583, 584. also primitive: \underline{1052}. also code: \underline{403}, 1052, 1059. ampersand : \underline{186}, 868, 869, 874, 886, 887, 891,

893, 894. : 868. and primitive: \underline{893}. and command : \underline{186}, 882, 884, 893, 894. and op: \underline{189}, 893, 940. angle: \underline{106}, 137, 139, 144, 145, 256, 279, 283,

527, 542, 865, 875. : 140. angle primitive: \underline{893}. angle op: \underline{189}, 893, 907. app lc hex : \underline{48}. append char : \underline{41}, 48, 52* , 58, 207, 671, 771* , 780,

897, 912, 976, 977. append to name: \underline{774}, 778. appr t : 556, \underline{557}. appr tt : 556, \underline{557}. area delimiter : \underline{768*} , 770, 771* , 772. arg list : 719, \underline{720}, 721, 724, 725, 726, 728, 734, 736. arith error : \underline{97}, 98, 99, 100, 107, 109, 112, 114,

124, 135, 269, 270. : 99. ASCII code: 17. ASCII primitive: \underline{893}. ASCII code: \underline{18}, 19* , 20, 28, 29, 30* , 37, 41, 54, 58,

77, 198, 667, 771* , 774, 778, 913. ASCII op: \underline{189}, 893, 912, 913. assignment : \underline{186}, 211, 212, 693, 733, 755, 821,

841, 868, 993, 995, 996, 1021, 1035. at primitive: \underline{211}. at least : \underline{186}, 211, 212, 882. atleast primitive: \underline{211}, \underline{256}, \underline{300}. at token: \underline{186}, 211, 212, 1073. attr : \underline{188}, 229, 236, 239, 240, 245.

attr head : \underline{228}, 229, 239, 241, 242, 244, 245,

246, 247, 850, 1047. attr loc: \underline{229}, 236, 239, 241, 244, 245, 246, 850. attr loc loc: \underline{229}, 241. attr node size: \underline{229}, 239, 241, 245, 247. autorounding : \underline{190}, 192, 193, 402. autorounding primitive: \underline{192}. avail : \underline{161}, 163, 164, 165, 176, 177, 181, 1194, 1195. : 181. axis : \underline{393}, 459, 507, 517, 519. b: \underline{124}, \underline{126}, \underline{321}, \underline{391}, \underline{429}, \underline{431}, \underline{433}, \underline{440}, \underline{580}, \underline{723},

\underline{778}, \underline{913}, \underline{919}, \underline{976}, \underline{977}, \underline{978}, \underline{1072}.

b close: 1134, 1182.

b make name string : \underline{780}, 791, 1134.

b open out : 791, 1134.

b tension: \underline{296}. b write byte: 1133* . b write 2 bytes : 1133* . b write 4 bytes : 1133* . back error : \underline{653}, 693, 703, 713, 726, 727, 734, 735, 747, 755, 756, 765, 820, 832, 839, 859, 861, 875, 878, 881, 990, 991, 1021, 1032, 1034, 1035, 1106, 1107, 1113.

back expr : 847, \underline{848}.

back input : \underline{652}, 653, 715, 716, 733, 751, 824, 825, 837, 841, 847, 854, 862, 864, 868, 881, 1012, 1034, 1107, 1204* . back list : \underline{649}, 652, 662, 715, 848. backed up: \underline{632}, 635, 636, 638, 649, 650. backpointers: 1147. : 1068. : 219. bad : \underline{13}, 14, 154, 204, 214, 310, 553, 777, 1204* . : 1074. : 183. : 617. : 1071. bad binary : \underline{923}, 929, 936, 940, 941, 948, 951,

952, 975, 983, 988. bad char : \underline{913}, 914.

bad exp: 823, \underline{824}, 862, 864, 868.
bad for : \underline{754}, 765.
bad pool : \underline{51*} , 52* , 53* .
bad subscript : 846, \underline{849}, 861.

bad unary : 898, \underline{901}, 903, 905, 906, 907, 909,

912, 915, 917, 921. bad vardef : \underline{175}, 698, 701, 702.

balance: \underline{685}, 687, \underline{730}, 731, 732.
banner : \underline{2*} , 61* , 790* , 1183.
base: \underline{374}, 375, 376, \underline{697}, 703, 704.
base area length: \underline{775*} .
base default length: \underline{775*} , 777, 778, 779* .

base ext length: \underline{775*} , 778, 779* . base extension: \underline{775*} , 784, 1200* . base file: 779* , \underline{1188*} , 1199* , 1200* , 1201, 1211. base ident : 34, 61* , 790* , \underline{1183}, 1184, 1185, 1198,

1199* , 1200* , 1211. batch mode: \underline{68}, 70, 81, 86, 87, 88, 789, 1024,

1025, 1199* , 1200* , 1205* . batchmode primitive: \underline{1024}. bb: \underline{286}, 287, 288, 291, \underline{440}, 444, 445, 446. bc: 1088, 1089, 1091, 1093, \underline{1096}, 1097, 1099,

1124, 1126, 1132, 1135, 1136. bch label : \underline{1096}, 1097, 1111, 1137, 1141. bchar : \underline{1096}, 1137, 1139. bchar label : \underline{186}, 211, 212, 1107. be careful : \underline{107}, 108, \underline{109}, \underline{112}, \underline{114}, 115, \underline{119}. before: 426, \underline{427}, 429, 436, 439, 444, 446. before and after : \underline{429}, 434, 437, 441. begin: 7* , 8* . begin diagnostic: 71, \underline{195}, 197, 254, 603, 613,

626, 721, 728, 734, 750, 762, 817, 902, 924, 945, 997, 998.

begin edge tracing : \underline{372}, 465, 506. begin file reading : 73, 82, \underline{654}, 717, 793* , 897. begin group: \underline{186}, 211, 212, 732, 823. begingroup primitive: \underline{211}. begin iteration: 706, 707, \underline{755}, 764. begin name: 767, \underline{770}, 781* , 787* . begin pseudoprint : \underline{642}, 644, 645. begin token list : \underline{649}, 677, 736, 760. : 1200* . Bernshteĭn, Sergeĭ Natanovich: 303. beta: \underline{296}, \underline{440}, 444, \underline{527}, 528, 529, 530, 533, 536. Bézier, Pierre Etienne: 255. bg loc: 211, 698, \underline{699}, 1198, 1199* . big : \underline{124}, \underline{126}. big node size: \underline{230}, 231, 232, 803, 810, 857, 919,

928, 939, 966, 1005. big trans : 952, \underline{966}. BigEndian order: \underline{1088}. bilin1 : 967, \underline{968}, 972. bilin2 : 970, \underline{972}. bilin3 : 973, \underline{974}. binary mac: 862, \underline{863}, 864, 868. bisect ptr : \underline{309}, 311, 312, 314, 553, 558, 559, 561. bisect stack : \underline{309}, 553. bistack size: \underline{11*} , 309, 310, 553, 557. black : \underline{565}, 577, 579, 580, 583, 584, 1143, 1144. blank line: \underline{195}. blank rectangle: 564* , 566, 567* , 569, 571, 572,

574, 577. boc: 1142, 1144, \underline{1145}, 1146, 1147, 1149, 1161, boc c: 1161, \underline{1162}, 1165. boc p: 1161, \underline{1162}, 1165. boc1 : 1144, \underline{1145}, 1161. boolean: 36* , 45, 47, 71, 74, 91, 97, 107, 109, 112, 114, 124, 126, 178* , 180, 195, 197, 238, 246, 249, 257, 332, 402, 406, 426, 440, 453, 455, 473, 497, 527, 569, 572, 577, 592, 599, 600, 621, 661, 680, 771* , 779* , 782, 801, 868, 899, 913, 943, 977, 978, 1006, 1054, 1072, 1084, 1096, 1187.

boolean primitive: \underline{1013}.

boolean reset : \underline{906}, 937, 1181.

boolean type: \underline{187}, 216, 248, 621, 798, 799, 802, 809, 855, 892, 895, 905, 906, 918, 919, 920, 936, 937, 940, 1003, 1013, 1181.

bot : \underline{1094}.

bot row : 567* , \underline{572}, 574, 577.
boundary char : \underline{190}, 192, 193, 1097, 1137.
boundarychar primitive: \underline{192}.
breakpoint : \underline{1212}.

buf size: \underline{11*} , 29, 30* , 34, 66, 154, 641, 654, 667, 682, 707, 717, 779* , 786, 788* , 1208.

buffer : \underline{29}, 30* , 35, 36* , 45, 66, 78, 82, 83, 205, 206, 207, 208, 210, 629, 630, 641, 644, 667, 669, 671, 673, 674, 679, 681, 682, 717, 778, 779* , 781* , 786, 787* , 788* , 794, 897, 1211, 1213.

: 34.

bypass eoln: 30* .

byte file: 24* , 780, 791, 1087.

b0 : 153* , 157, 214, 255, 1093, 1094, 1133* , 1192,

1193. b1 : 153* , 157, 214, 255, 1093, 1094, \underline{1131}, 1132,

1133* , 1192, 1193. b2 : 153* , 157, 1093, 1094, \underline{1131}, 1132, 1133* ,

1192, 1193. b3 : 153* , 157, 1093, 1094, \underline{1131}, 1132, 1133* ,

1192, 1193. b4 : \underline{1131}, 1132. c: \underline{47}, \underline{77}, \underline{189}, \underline{210}, \underline{217}, \underline{391}, \underline{440}, \underline{491}, \underline{527}, \underline{625}, \underline{626}, \underline{667}, \underline{697}, \underline{771*} , \underline{774}, \underline{778}, \underline{823}, \underline{862}, \underline{863}, \underline{864}, \underline{868}, \underline{895}, \underline{898}, \underline{901}, \underline{910}, \underline{913}, \underline{919}, \underline{922}, \underline{923}, \underline{930}, \underline{953}, \underline{960}, \underline{962}, \underline{963}, \underline{966}, \underline{985}, \underline{1070}, \underline{1072}, \underline{1103}, \underline{1104}, \underline{1106}, \underline{1165}, \underline{1209}.

c char pointer : 775* , 788* .

call edit : 79* , 1205* .

cancel skips : \underline{1110}, 1139.

: 237.

capsule: \underline{188}, 214, 219, 233, 237, 238, 619, 799,

806, 830, 856, 857, 911, 931, 982. capsule token: \underline{186}, 651, 676, 678, 823, 1042.

cat : 975, \underline{976}.

cc: \underline{286}, 288, 289, 290, 294, 295, \underline{440}, 444, 445, 446, \underline{1106}. cf : \underline{116}, 297, \underline{298}, 299, 300, 301. change if limit : \underline{746}, 748. char : 19* , 25. char primitive: \underline{893}. char class : 22* , \underline{198}, 199* , 217, 223, 669, 673, 674. char code: \underline{190}, 192, 193, 1070. charcode primitive: \underline{192}. char dp: \underline{190}, 192, 193, 1099, 1126. chardp primitive: \underline{192}. char dx : \underline{190}, 192, 193, 1099. chardx primitive: \underline{192}. char dy : \underline{190}, 192, 193, 1099. chardy primitive: \underline{192}. char exists : \underline{1096}, 1097, 1099, 1124, 1126, 1132,

1136, 1181, 1182. charexists primitive: \underline{893}. char exists op: \underline{189}, 893, 906. char ext : \underline{190}, 192, 193, 1165. charext primitive: \underline{192}. char ht : \underline{190}, 192, 193, 1099, 1126. charht primitive: \underline{192}. char ic: \underline{190}, 192, 193, 1099, 1126. charic primitive: \underline{192}. char info: 1091. char info word : 1089, \underline{1091}, 1092. charlist primitive: \underline{1101}. char list code: \underline{1101}, 1102, 1106. char loc: 1144, \underline{1145}, 1147, 1182. char loc0 : \underline{1144}. char op: \underline{189}, 893, 912. char ptr : \underline{1149}, 1163* , 1165, 1182. char remainder : \underline{1096}, 1097, 1104, 1136, 1138. char tag : \underline{1096}, 1097, 1104, 1105, 1136. char wd : \underline{190}, 192, 193, 1099, 1124. charwd primitive: \underline{192}. : 1105. character set dependencies: 22* , 49. check sum: 53* , 1090, 1131, 1146. check arith: \underline{99}, 269, 815, 823, 837, 895, 898,

922, 1001. check colon: \underline{747}, 748. check delimiter : 703, 826, 830, \underline{1032}. check equals : \underline{693}, 694, 697. check gf : \underline{1163*} , 1165, 1177, 1179. check interrupt : \underline{91}, 650, 669, 825. check mem: 178* , \underline{180}, 617, 825, 1213. check outer validity : \underline{661}, 668, 681. Chinese characters: 1147. chop path: 975, \underline{978}. chop string : 975, \underline{977}. chopped : \underline{402}, 404. chr : 19* , 20, 22* , 23. class : \underline{217}, 220, 221, 223, \underline{667}, 669. clear arith: \underline{99}. clear for error prompt : 73, 78, \underline{656}, 670, 672. clear symbol : \underline{249}, 252, 254, 692, 1011, 1035. clear terminal : 33* , 656, 786. clear the list : \underline{1117}, 1124, 1126. : 218. clobbered : \underline{180}, 181, 182* . clockwise: 452, \underline{453}, 454, 458. close files and terminate: 73, 76* , 1204* , \underline{1205*} . : 1203. coef bound : \underline{592}, 595, 596, 598, 599, 600, 932,

943, 949. collective subscript : \underline{229}, 239, 241, 244, 246,

850, 1012. colon: \underline{186}, 211, 212, 747, 756, 764, 1106, 1107,

1111, 1113. comma: \underline{186}, 211, 212, 704, 725, 726, 727, 764, 826, 859, 878, 1015, 1016, 1029, 1033, 1036, 1040, 1044, 1049, 1107, 1113, 1114, 1115.

command code: \underline{186}, 685, 694, 1072. common ending : \underline{15}, 865, 1071. compiler : 9* . compromise: \underline{432}, 435, 438, 443. concatenate: \underline{189}, 893, 975. cond ptr : \underline{738}, 739, 744, 745, 746, 748, 749, 1209. conditional : 706, 707, \underline{748}. confusion: \underline{90}, 107, 114, 216, 236, 239, 311, 362, 378, 517, 523, 589, 655, 746, 802, 809, 855.

const dependency : \underline{607}, 608, 969, 972, 1007.

constant x : \underline{406}, 407, 413, 417.

continue: \underline{15}, 77, 78, 79* , 83, 84, 311, 314, 402, 406, 417, 447, 556, 755, 764, 862, 864, 868, 1106, 1107, 1111. continue path: \underline{868}, 869. contour primitive: \underline{1052}. contour code: \underline{403}, 917, 1052, 1053. : 258. controls : \underline{186}, 211, 212, 881. controls primitive: \underline{211}. coord node size: 175, \underline{472}, 476, 481, 487. coordinates, explained: 576. copied : \underline{1006}, 1009. copy dep list : \underline{609}, 855, 858, 947. copy edges : \underline{334}, 621, 855. copy knot : \underline{264}, 870, 885, 980, 981. copy path: \underline{265}, 621, 855. cosd primitive: \underline{893}. cos d op: \underline{189}, 893, 906. cosine: \underline{280}, 281. crossing point : \underline{391}, 392, 407, 411, 413, 415, 420,

424, 497, 499, 503, 545, 547, 549. cs : \underline{1146}. ct : \underline{116}, 297, \underline{298}, 299, 300, 301. cubic intersection: 555, \underline{556}, 557, 562. cull primitive: \underline{211}. cull command : \underline{186}, 211, 212, 1069. cull edges : \underline{348}, 1074. cull op: \underline{186}, 1052, 1053, 1074. cur area: \underline{767}, 772, 784, 786, 793* , 795. cur cmd : 83, 186, \underline{624}, 626, 651, 652, 658, 667,

668, 671, 675, 676, 678, 685, 686, 691, 693, 697, 700, 703, 704, 705, 706, 707, 713, 715, 718, 725, 726, 727, 731, 732, 733, 734, 735, 742, 743, 747, 755, 756, 764, 765, 796, 823, 824, 826, 832, 837, 839, 841, 844, 846, 847, 851, 852, 859, 860, 861, 862, 864, 868, 869, 874, 875, 878, 881, 882, 884, 989, 990, 991, 992, 993, 995, 996, 1011, 1012, 1015, 1016, 1017, 1021, 1029, 1032, 1033, 1034, 1035, 1036, 1040, 1041, 1042, 1044, 1049, 1051, 1062, 1072, 1074, 1106, 1107, 1111, 1113, 1114, 1115.

cur edges : \underline{327}, 328, 329, 330, 331, 332, 333, 336, 337, 340, 341, 342, 343, 348, 352, 353, 354, 355, 356, 364, 365, 366, 367, 373, 374, 375, 376, 377, 378, 381, 382, 383, 384, 465, 577, 581, 804, 929, 963, 964, 965* , 1057, 1061, 1064, 1070, 1071, 1074, 1167, 1169* , 1172.

cur exp: 603, 615, 651, 713, 716, 717, 718, 726, 728, 730, 748, 750, 760, 761, 764, 765, \underline{796}, 797, 798, 799, 800, 801, 808, 816, 819, 823, 827, 829, 830, 833, 837, 840, 841, 846, 852, 855, 856, 857, 860, 861, 863, 865, 870, 872, 875, 876, 877, 878, 879, 880, 882, 883, 885, 891, 895, 896, 897, 898, 901, 903, 905, 906, 907, 908, 910, 912, 913, 915, 916, 917, 919, 920, 921, 923, 927, 929, 930, 931, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 946, 948, 949, 951, 953, 955, 956, 962, 963, 964, 967, 968, 970, 972, 973, 976, 977, 978, 979, 984, 985, 988, 992, 994, 995, 996, 999, 1003, 1004, 1005, 1006, 1009, 1022, 1056, 1059, 1061, 1062, 1063, 1070, 1071, 1072, 1073, 1074, 1082, 1083, 1086, 1103, 1106, 1112, 1115, 1177, 1179, 1181.

cur ext : \underline{767}, 772, 784, 786, 793* , 795. cur file: \underline{631}, 655, 681, 793* , 794. cur gran: \underline{430}, 431, 432, 433, 442. cur if : \underline{738}, 739, 744, 745, 748, 1209. cur input : 34, 35, 82, \underline{628}, 629, 635, 647, 648, 788* . cur length: \underline{40}, 1163* . cur min m: \underline{1165}, 1172, 1173. cur mod : 83, \underline{624}, 626, 651, 652, 658, 667, 668,

671, 675, 676, 678, 687, 690, 691, 694, 697, 700, 703, 705, 707, 711, 718, 726, 727, 731, 735, 742, 743, 748, 749, 751, 755, 796, 823, 824, 826, 833, 834, 835, 837, 839, 841, 846, 847, 851, 860, 861, 862, 864, 868, 990, 992, 1011, 1015, 1023, 1029, 1032, 1034, 1035, 1040, 1041, 1042, 1049, 1051, 1054, 1059, 1074, 1082, 1106, 1112, 1177, 1209.

cur name: \underline{767}, 772, 784, 786, 793* , 795.

cur path type: \underline{403}, 435, 438, 442, 917, 1064, 1068. cur pen: 402, \underline{403}, 435, 438, 442, 506, 917, 1062,

1063, 1064, 1068. cur rounding ptr : 426, \underline{427}, 429, 433, 436, 439,

440, 444, 446. cur spec: 394, 399, 400, 402, \underline{403}, 404, 406, 407, 417, 419, 421, 433, 440, 447, 450, 452. cur sym: 83, 210, 211, \underline{624}, 651, 652, 658, 661,

662, 663, 664, 667, 668, 669, 676, 677, 683, 685, 686, 690, 691, 692, 694, 700, 703, 704, 705, 707, 718, 726, 735, 740, 751, 755, 796, 823, 824, 826, 837, 846, 847, 851, 860, 862, 864, 868, 893, 1011, 1012, 1029, 1031, 1032, 1033, 1034, 1035, 1036, 1041, 1049, 1076, 1204* . cur t : \underline{555}, 556, 558, 559, 560, 561, 562, 988. cur tok : \underline{651}, 652, 685, 715, 730, 844. cur tt : \underline{555}, 556, 558, 559, 560, 561, 562, 988. cur type: 603, 615, 651, 716, 718, 726, 728, 730,

760, 764, 765, \underline{796}, 798, 799, 800, 801, 808, 816, 819, 823, 826, 827, 830, 832, 833, 837, 840, 841, 846, 852, 855, 856, 857, 860, 861, 864, 865, 870, 872, 876, 877, 878, 883, 885, 891, 892, 895, 896, 897, 898, 901, 903, 905, 906, 907, 908, 909, 910, 912, 915, 917, 918, 919, 920, 921, 923, 927, 929, 930, 931, 934, 935, 936, 937, 939, 940, 941, 942, 944, 946, 948, 951, 953, 955, 960, 962, 967, 970, 973, 975, 982, 983, 988, 989, 992, 993, 995, 996, 999, 1000, 1002, 1003, 1004, 1006, 1009, 1021, 1054, 1059, 1061, 1062, 1070, 1071, 1072, 1073, 1074, 1082, 1103, 1106, 1112, 1115, 1177, 1181.

cur wt : \underline{327}, 372, 373, 374, 375, 376, 378, 381,

382, 383, 384, 465, 1064, 1068. cur x : 387, 388, \underline{389}, 390, 394, 413, 421, 445, 447, 451, 454, 457, 481, 485, 488, 489, 510, 871, 872, 873, 877, 878, 884, 984, 1072, 1073, 1074, 1075. cur y : 387, 388, \underline{389}, 390, 394, 413, 421, 445, 447, 451, 454, 457, 481, 485, 488, 489, 510, 871, 872, 873, 877, 878, 884, 984, 1072, 1073, 1074, 1075.

curl : \underline{256}, 258, 259, 263, 271, 282, 284, 285, 290,

875, 876, 888, 889, 890, 891. curl primitive: \underline{211}. curl command : \underline{186}, 211, 212, 875. curl ratio: 294, 295, \underline{296}. curvature: 275. : 404. cycle: \underline{186}, 823, 869, 893, 894. cycle spec: \underline{393}.

: 394. cycle primitive: \underline{893}. cycle hit : \underline{868}, 869, 886, 891. cycle op: \underline{189}, 893, 920. c0 : \underline{574}, 575, 576, \underline{1073}. c1 : \underline{574}, 575, \underline{1073}. d: \underline{333}, \underline{348}, \underline{373}, \underline{391}, \underline{440}, \underline{527}, \underline{580}, \underline{862}, \underline{864}, \underline{868},

\underline{944}, \underline{1118}, \underline{1120*} , \underline{1121*} , \underline{1128}, \underline{1159}, \underline{1165}. data structure assumptions: 176. date and time: 194* . day : \underline{190}, 192, 193, 194* , 790* , 1163* , 1200* , 1211. day primitive: \underline{192}. dd : \underline{286}, 288, 289, \underline{440}, 444, 445, 446. dead cubics: \underline{402}. debug : \underline{7*} , \underline{73}, \underline{79*} , \underline{88}, 107, 114, \underline{157}, \underline{178*} , \underline{179}, \underline{180},

\underline{185}, 378, 517, 523, 825, \underline{1212}. # : 1212. debug help: 73, 79* , 88, \underline{1212}. debugging: 7* , 79* , 91, 157, 178* , 1212. decimal : \underline{189}, 893, 912. decimal primitive: \underline{893}. : 1015. decr : 43, 46, 63, 66, 81, 83, 84, 86, 87, 102, 121,

123, 149, 163, 164, 177, 195, 207, 226, 291, 315, 322, 330, 331, 332, 333, 352, 364, 375, 376, 377, 382, 383, 384, 436, 439, 458, 459, 483, 487, 488, 497, 515, 516, 521, 522, 556, 560, 577, 635, 648, 650, 655, 681, 687, 731, 732, 742, 854, 862, 864, 868, 1051, 1122, 1135, 1138, 1139, 1141, 1167, 1182, 1194, 1209.

def primitive: \underline{683}. def delims : 1030, \underline{1031}. def ref : \underline{720}, 721, 736. defined macro: \underline{186}, 249, 700, 706, 707, 718,

1035, 1041, 1043. del : \underline{406}, 407, 408, 413, \underline{419}, 420, \underline{453}, 454. del m: \underline{1144}. del n: \underline{1144}. delete mac ref : \underline{226}, 249, 650, 809. delete pen ref : \underline{487}, 808, 809, 1062, 1063. delete str ref : \underline{43}, 216, 691, 743, 808, 809, 976,

977, 1042, 1083. deletions allowed : \underline{71}, 72, 79* , 80, 93, 661, 670,

672, 675. delimiters : \underline{186}, 211, 212, 1030. delimiters primitive: \underline{211}. delta: \underline{103}, \underline{279}, 281, 288, \underline{328}, \underline{329}, 330, 331, \underline{342},

343, \underline{366}, 367, \underline{378}, 381, 382, 383, 384, \underline{527}, 530, 531, 533, 534, 535, \underline{968}, \underline{974}, \underline{1165}, 1173, 1174.

delta a: \underline{426}. delta b: \underline{426}. delta x : \underline{279}, 281, 292, 293, 299, 301, 302.

delta y : \underline{279}, 281, 292, 293, 299, 301, 302.
delx : \underline{280}, 282, \underline{374}, 375, 376, \underline{511}, 516, 522, 552,

553, 556, \underline{557}, 558, 559, 560, 561.

dely : \underline{280}, 282, \underline{374}, 375, 376, \underline{511}, 516, 522, 552,

553, 556, \underline{557}, 558, 559, 560, 561.

del1 : \underline{406}, 407, 408, 409, 413, 414, \underline{419}, 420,

421, 423. del2 : \underline{406}, 407, 408, 409, 411, 413, 414, 415, \underline{419},

420, 421, 423, 424. del3 : \underline{406}, 407, 408, 409, 411, 413, 414, 415, \underline{419},

420, 421, 423, 424. denom: \underline{116}, \underline{296}, \underline{836}, 837.

dep div : 948, \underline{949}.

dep final : \underline{592}, 594, 597, 601, 606, 607, 608, 609,

615, 818, 819, 829, 855, 856, 858, 971, 972, 1007. dep finish: 934, \underline{935}, 943, 949.

dep head : \underline{175}, 587, 588, 604, 606, 614, 617,

812, 1050. dep list : 585, \underline{587}, 604, 605, 606, 614, 617, 798,

799, 801, 803, 811, 812, 816, 818, 819, 827, 855, 858, 903, 930, 931, 932, 935, 943, 947, 949, 959, 968, 969, 971, 972, 1007, 1009, 1050.

dep mult : 942, \underline{943}, 944, 946, 968.

dep node size: \underline{587}, 595, 596, 597, 598, 599, 600, 601, 603, 605, 607, 608, 609, 612, 615, 616, 818, 819, 829, 1008.

dependent : \underline{187}, 216, 248, 585, 587, 588, 589, 590, 594, 595, 596, 597, 599, 600, 601, 603, 610, 612, 613, 615, 798, 799, 800, 801, 802, 808, 809, 812, 813, 815, 816, 817, 818, 819, 829, 855, 857, 858, 900, 903, 930, 932, 943, 949, 969, 1003, 1006, 1007, 1009, 1010, 1050.

depth index : \underline{1091}. design size: 1146. design size: \underline{190}, 192, 193, 1128, 1129, 1182. designsize primitive: \underline{192}. dest x : \underline{406}, 407, 409, 411, 412, 413, 415, 416,

\underline{419}, 421, 423, 424, 425.

dest y : \underline{406}, 407, 411, 412, 413, 414, 415, 416,

\underline{419}, 421, 423, 424, 425.

diag offset : \underline{442}, 443. diag round : 402, \underline{440}. diagonal : \underline{393}, 459, 507, 508, 509, 519, 523. dig : \underline{54}, 63, 64, 102, 674. digit class : \underline{198}, 199* , 220, 669, 673, 674. dimen head : 1124, \underline{1125}, 1126, 1136. dimen out : \underline{1129}, 1132, 1136, 1139, 1140. directiontime primitive: \underline{893}. direction time of : \underline{189}, 893, 983. directives : 9* . dirty Pascal: \underline{3}, 157, 185, 1203. discard suffixes : \underline{246}. disp edges : \underline{577}, 1071. disp err : 716, 754, \underline{807}, 873, 923, 937, 955, 1002. disp token: \underline{1041}, 1043, 1044, 1049. disp var : \underline{1046}, 1047, 1049. display primitive: \underline{211}. display command : \underline{186}, 211, 212, 1069. div: \underline{95}. : 838, 950. dm: \underline{1144}. dmax : \underline{406}, 408, \underline{419}, \underline{453}, 457. do add to: 1058, \underline{1059}. do assignment : 993, 995, \underline{996}. do binary : 834, 837, 839, 859, 862, 864, 868,

893, \underline{922}, 966. do cull : 1069, \underline{1074}. do display : 1069, \underline{1071}. do equation: 993, \underline{995}, 996. do expression: 996. do final end : \underline{76*} , 1204* . do interim: 1033, \underline{1034}. do let : 1033, \underline{1035}. do message: 1081, \underline{1082}. do new internal : 1033, \underline{1036}. do nothing : \underline{16*} , 57, 58, 79* , 146, 216, 223, 249, 669,

707, 794, 808, 809, 919, 957, 1003, 1035. do nullary : 834, 893, \underline{895}. do open window : 1069, \underline{1073}. do protection: 1026, \underline{1029}. do random seed : 1020, \underline{1021}. do ship out : 1069, \underline{1070}. do show : \underline{1040}, 1051. do show dependencies : \underline{1050}, 1051, 1213. do show stats : \underline{1045}, 1051. do show token: \underline{1044}, 1051. do show var : 1046, \underline{1049}, 1051. do show whatever : 1039, \underline{1051}. do special : 1175, \underline{1177}. do statement : 832, \underline{989}, 992, 1017, 1020, 1034. do tfm command : 1100, \underline{1106}. do type declaration: 992, \underline{1015}. do unary : 834, 835, 893, \underline{898}. done: \underline{15}, 47, 53* , 124, 125, 126, 127, 177, 257, 269,

272, 311, 317, 344, 345, 346, 347, 348, 349, 354, 358, 366, 368, 374, 375, 378, 381, 382, 383, 384, 394, 402, 452, 458, 477, 479, 488, 491, 502, 506, 512, 518, 527, 531, 532, 539, 546, 547, 548, 577, 578, 584, 594, 597, 604, 605, 609, 635, 650, 667, 673, 685, 687, 730, 731, 732, 742, 748, 749, 755, 764, 765, 781* , 786, 787* , 793* , 809, 812, 823, 835, 837, 839, 840, 841, 852, 860, 868, 881, 919, 922, 930, 932, 936, 953, 955, 957, 958, 959, 1001, 1003, 1004, 1005, 1006, 1007, 1011, 1012, 1049, 1059, 1068, 1106, 1107, 1110, 1165, 1172, 1173.

done1 : \underline{15}, 180, 181, 257, 258, 261, 374, 376, 477, 481, 506, 516, 518, 522, 527, 536, 823, 844, 922, 939, 1006, 1009.

done2 : \underline{15}, 180, 182* , 823, 850. done3 : \underline{15}. done4 : \underline{15}. done5 : \underline{15}. done6 : \underline{15}. double: \underline{16*} , 108, 115, 123, 132, 142, 143, 392, 408,

457, 496, 543, 556, 559. : 182* . double colon: \underline{186}, 211, 212, 1107. double dot : \underline{189}. doublepath primitive: \underline{1052}. double path code: \underline{403}, 435, 438, 442, 1052, 1053,

1059, 1064, 1068. : 182* . drop code: \underline{1052}, 1053, 1074, 1075. dropping primitive: \underline{1052}. dry rot: 90. ds : \underline{1146}. du: \underline{495}, \underline{497}, 498. dual moves : 512, \underline{518}. : 1209. dump primitive: \underline{1018}. dump four ASCII : \underline{1192}. dump hh: 1196. dump int : 1190, 1192, 1194, 1196, 1198. dump qqqq : 1192. dump wd : 1194. dup offset : \underline{476}, 483. dv : \underline{495}, \underline{497}, 498. dw : \underline{357}, 358. dx : \underline{378}, 380, 381, 382, 383, 384, \underline{477}, 479, 480,

494, \underline{495}, 501, 502, 1144, 1147. dx1 : \underline{453}, 454, 457. dx2 : \underline{453}, 454, 457. dy : \underline{477}, 479, 480, \underline{495}, 501, 502, 1144, 1147. dyn used : \underline{160}, 163, 164, 165, 176, 177, 1045,

1194, 1195. dy1 : \underline{453}, 454, 457. dy2 : \underline{453}, 454, 457. d0 : \underline{464}, 467, 468, 508, 517, 523. d1 : 463, \underline{464}, 467, 468, 508, 517, 523. e: \underline{773}, \underline{774}, \underline{786}, \underline{1071}, \underline{1074}. east edge: \underline{435}. east west edge: \underline{435}. ec: 1088, 1089, 1091, 1093, \underline{1096}, 1097, 1099,

1124, 1126, 1132, 1135, 1136. edge and weight : \underline{378}, 381, 382, 383, 384. edge header size: \underline{326}, 334, 385, 895, 964. edge prep: \underline{329}, 366, 375, 376, 380. edges trans : 952, \underline{963}. edit file: \underline{79*} . edit line: 79* , 1205* , \underline{1214*} . edit name length: 79* , 1205* , \underline{1214*} . edit name start : 79* , 1205* , \underline{1214*} , 1215* . ee: \underline{286}, 288, 289. eg loc: 211, 698, \underline{699}, 1198, 1199* . eight bits : \underline{24*} , 63, 624, 1096, 1103, 1131, 1149,

1152, 1165. eighth octant : \underline{139}, 141, 380, 387, 388, 390, 396,

426, 443, 449, 461, 462. el gordo: \underline{95}, 100, 107, 109, 112, 114, 124, 135,

235, 244, 917, 1118, 1140. else: 10. else primitive: \underline{740}. else code: \underline{738}, 740, 741. elseif primitive: \underline{740}. else if code: \underline{738}, 740, 748. : 88. empty edges : \underline{326}, 329, 963. empty flag : \underline{166}, 168, 172, 176, 1207. encapsulate: 855, \underline{856}. end: 7* , 8* , 10. : 1209. : 36* , 66. end primitive: \underline{1018}. end attr : \underline{175}, 229, 239, 247, 1047. end cycle: \underline{272}, 281, 282, 284, 287. end def : \underline{683}, 992. enddef primitive: \underline{683}. end diagnostic: \underline{195}, 254, 257, 332, 372, 394, 473,

603, 613, 626, 721, 728, 734, 750, 762, 817, 902, 924, 945, 997, 998.

end edge tracing : \underline{372}, 465, 506. end file reading : \underline{655}, 656, 679, 681, 714, 793* , 897. end for : \underline{683}, 707. endfor primitive: \underline{683}. end group: \underline{186}, 211, 212, 732, 832, 991, 992,

993, 1017. endinput primitive: \underline{709}. end name: 767, \underline{772}, 781* , 787* . end of MF : \underline{6}, 76* . end of statement : \underline{186}, 732, 991, 1015, 1016. end round : \underline{463}, 464, 467, 508. end token list : \underline{650}, 652, 676, 712, 714, 736, 795. endcases: \underline{10}. endgroup primitive: \underline{211}. endif : 7* , 8* . endpoint : \underline{255}, 256, 257, 258, 266, 273, 393, 394,

398, 399, 400, 401, 402, 451, 452, 457, 465, 466, 491, 506, 512, 518, 539, 562, 563, 865, 868, 870, 871, 885, 891, 916, 917, 920, 921, 962, 978, 979, 985, 987, 1064.

: 1098. : 1098. : 1098. : 1098. : 1098. : 675. : 394. env move: \underline{507}, 513, 514, 515, 516, 517, 519,

520, 521, 522, 523. eoc: 1142, 1144, \underline{1145}, 1146, 1149, 1165. eof : 25, 52* . eoln: 30* , 52* . eq type: \underline{200}, 202, 203, 210, 211, 213, 229, 242, 249, 254, 668, 694, 700, 702, 759, 850, 1011, 1029, 1031, 1035, 1036, 1041, 1213. eqtb: 158, 200, \underline{201}, 202, 210, 211, 212, 213,

249, 250, 252, 254, 625, 632, 683, 740, 893, 1196, 1197.

equal to: \underline{189}, 893, 936, 937.

equals : \underline{186}, 693, 733, 755, 868, 893, 894, 993,

995, 996, 1035. : 1002. equiv : \underline{200}, 202, 209, 210, 211, 213, 229, 234, 239, 242, 249, 254, 664, 668, 694, 700, 702, 850, 1011, 1015, 1030, 1031, 1035, 1036, 1213.

err help: \underline{74}, 75, 85, 1083, 1086.

errhelp primitive: \underline{1079}.
err help code: \underline{1079}, 1082.
errmessage primitive: \underline{1079}.
err message code: \underline{1079}, 1080, 1082.

error : 67, 70, 71, 73, 74, \underline{77}, 83, 88, 93, 99, 122, 128, 134, 140, 602, 653, 670, 672, 675, 701, 708, 712, 713, 725, 751, 778, 789, 795, 820, 838, 996, 1032, 1051, 1110. error count : \underline{71}, 72, 77, 81, 989, 1051. error line: \underline{11*} , 14, 54, 58, 635, 641, 642, 643, 665.

error message issued : \underline{71}, 77, 90.

error stop mode: 67, \underline{68}, 69, 77, 88, 93, 398, 807,

1024, 1051, 1086, 1199* , 1209. errorstopmode primitive: \underline{1024}. eta corr : 306, \underline{311}, 313, 314, 317. : 217, 227. everyjob primitive: \underline{211}. every job command : \underline{186}, 211, 212, 1076. excess : \underline{1119}, 1120* , 1122. exit : \underline{15}, 16* , 36* , 46, 47, 77, 117, 167, 217, 227, 235, 242, 246, 265, 266, 284, 311, 391, 406, 488, 497, 539, 556, 562, 589, 622, 667, 746, 748, 760, 779* , 868, 899, 904, 922, 928, 930, 943, 949, 953, 962, 963, 966, 1032, 1070, 1071, 1073, 1074, 1131, 1161, 1187, 1209, 1212.

exitif primitive: \underline{211}. exit test : \underline{186}, 211, 212, 706, 707. exp err : \underline{807}, 830, 849, 872, 876, 878, 883, 892,

901, 914, 923, 937, 950, 960, 993, 996, 999, 1002, 1021, 1055, 1060, 1061, 1062, 1071, 1082, 1103, 1106, 1112, 1115, 1178.

expand : \underline{707}, 715, 718. expand after : \underline{186}, 211, 212, 706, 707. expandafter primitive: \underline{211}. explicit : \underline{256}, 258, 261, 262, 266, 271, 273, 280,

282, 299, 302, 393, 407, 486, 563, 874, 880, 884, 1066.

: 222. expr primitive: \underline{695}. expr base: \underline{214}, 218, 222, 676, 683, 684, 694, 695,

696, 697, 703, 705, 725, 727, 755, 764. expr macro: \underline{226}, 227, 705, 733. expression binary : \underline{186}, 893, 894. expression tertiary macro: \underline{186}, 249, 683, 868,

1035, 1043. ext bot : \underline{1094}, 1113. ext delimiter : \underline{768*} , 770, 771* , 772. ext mid : \underline{1094}, 1113. ext rep: \underline{1094}, 1113. ext tag : \underline{1092}, 1096, 1105, 1113. ext top: \underline{1094}, 1113. exten: \underline{1092}, 1094, \underline{1096}, 1140. extensible primitive: \underline{1101}. extensible code: \underline{1101}, 1102, 1106. extensible recipe: 1089, \underline{1094}. extensions to : 2* . : 708. : 1017. : 751. : 751. : 751. : 991. extra space: 1095. extra space code: \underline{1095}. extras : 362, \underline{363}. f: \underline{107}, \underline{109}, \underline{112}, \underline{114}, \underline{398}, \underline{594}, \underline{667}, \underline{780}, \underline{1165}. false: 30* , 36* , 45, 47, 51* , 71, 75, 83, 84, 93, 98,

99, 107, 110, 114, 124, 126, 179, 180, 181, 182* , 254, 269, 270, 404, 407, 426, 446, 452, 454, 455, 456, 474, 497, 503, 505, 530, 564* , 570, 573, 577, 592, 593, 600, 603, 604, 613, 626, 653, 657, 661, 670, 672, 675, 680, 681, 692, 721, 728, 734, 750, 762, 767, 771* , 779* , 783, 794, 801, 804, 817, 825, 869, 899, 902, 913, 924, 944, 945, 977, 978, 997, 998, 1003, 1009, 1010, 1011, 1015, 1035, 1045, 1054, 1064, 1072, 1085, 1086, 1097, 1107, 1137, 1138, 1187.

false primitive: \underline{893}. false code: \underline{189}, 798, 892, 893, 895, 905, 906,

918, 919, 920, 937, 940. fast case down: \underline{378}, 380. fast case up: \underline{378}, 380. fast get avail : \underline{165}, 381, 382, 383, 384, 651, 844. : 1187. fatal error : 66, \underline{88}, 679, 714, 786, 789, 897. fatal error stop: \underline{71}, 72, 77, 88, 1204* . feof : 1199* . ff : \underline{286}, 287, 289, 290, 295, \underline{296}, 302. fflush: 33* . fi primitive: \underline{740}. fi code: \underline{738}, 740, 741, 742, 748, 749, 751. fi or else: \underline{186}, 706, 707, 738, 740, 741, 742,

751, 1209. fifth octant : \underline{139}, 141, 380, 387, 388, 390, 396,

426, 443, 449, 461, 462. : 663. : 795. file name size: \underline{11*} , 25, 774, 777, 778, 780. file offset : \underline{54}, 55, 57, 58, 62, 333, 372, 793* ,

1048, 1165. file ptr : 79* , 80, \underline{634}, 635, 636, 637. file state: \underline{632}, 635, 636, 656, 667, 714, 795. FILENAMESIZE : 11* . fill envelope: 481, \underline{506}, 518, 1064. fill spec: \underline{465}, 506, 511, 1064. fillin: \underline{190}, 192, 193, 525, 533. fillin primitive: \underline{192}. fin numeric token: \underline{667}, 669, 673. fin offset prep: \underline{497}, 503, 504, 505. final cleanup: 1204* , \underline{1209}. final end : \underline{6}, 34, 657, 1204* , 1211. final node: \underline{610}, 612, 615. final value: \underline{752}, 761, 765. find direction time: \underline{539}, 540, 984. find edges var : \underline{1057}, 1061, 1064, 1070, 1071, 1074. find offset : \underline{488}, 984. find point : 983, \underline{985}. find variable: \underline{242}, 700, 852, 1000, 1015, 1057. finish path: \underline{868}, 869, 874. firm up the line: 666, 681, \underline{682}, 794. first : \underline{29}, 30* , 34, 35, 36* , 66, 78, 82, 83, 654, 655,

657, 679, 681, 682, 717, 787* , 794. first count : \underline{54}, 641, 642, 643. first octant : \underline{139}, 141, 378, 379, 380, 387, 388, 390,

395, 396, 406, 407, 409, 411, 426, 435, 443, 448, 449, 461, 462, 473, 480, 484, 488, 489.

first text char : \underline{19*} , 23. first x : \underline{406}, 407, \underline{440}, 444, 445. first y : \underline{406}, 407, \underline{440}, 444, 445. fix check sum: \underline{1131}, 1206. fix date and time: \underline{194*} , 1204* , 1211. fix dependencies : \underline{604}, 610, 815, 935, 968, 971. fix design size: \underline{1128}, 1206. fix needed : \underline{592}, 593, 595, 596, 598, 599, 600, 604,

610, 815, 932, 935, 968, 971. fix offset : \underline{328}, 329, 965* . fix word : \underline{1089}, 1090, 1095, 1129, 1147. floor primitive: \underline{893}. floor op: \underline{189}, 893, 906. floor scaled : \underline{119}, 516, 522, 906. floor unscaled : \underline{119}, 306, 463, 513, 515, 516, 519,

521, 522, 1074. flush: 33* . flush below variable: 246, \underline{247}, 249. flush cur exp: 717, \underline{808}, 820, 872, 907, 913, 915,

917, 918, 919, 920, 921, 935, 936, 938, 956, 962, 982, 984, 993, 1040, 1061, 1063, 1070, 1072, 1082, 1177.

flush error : \underline{820}, 849, 1017. flush list : \underline{177}, 385, 700, 736, 1015. flush node list : \underline{177}, 685, 811, 815, 852, 996,

1009, 1057. flush p: \underline{621}. flush string : \underline{43}, 210, 1200* . flush token list : \underline{216}, 224, 226, 235, 650, 698, 763,

840, 1062, 1071, 1074. flush variable: \underline{246}, 700, 1015. flushing : \underline{659}, 664, 665, 991, 1016. : 1140. font metric files: 1087. : 1134. fontdimen primitive: \underline{1101}. font dimen code: \underline{1101}, 1106. fontmaking : \underline{190}, 192, 193, 1206. fontmaking primitive: \underline{192}. for primitive: \underline{683}. forsuffixes primitive: \underline{683}. : 663. force eof : 657, \underline{680}, 681, 711. forever primitive: \underline{683}. forever text : \underline{632}, 638, 714, 760. form feed : \underline{22*} , 199* . forty five deg : \underline{106}, 145. forward : 73, 216, 217, 224, 225, 666, 706, 820,

995, 1034. found : \underline{15}, 167, 170, 171, 205, 206, 207, 235, 236,

284, 291, 292, 295, 477, 527, 532, 539, 541, 543, 544, 547, 548, 577, 582, 667, 669, 685, 686, 720, 726, 748, 755, 779* , 1103, 1117. found1 : \underline{15}. found2 : \underline{15}. four quarters : 1096, 1133* , 1186, 1187. fourth octant : \underline{139}, 141, 380, 387, 388, 390, 393, 396, 426, 435, 443, 449, 461, 462, 472.

frac mult : 837, \underline{944}.

fraction: \underline{105}, 107, 109, 114, 116, 119, 124, 126, 144, 145, 148, 149, 150, 187, 259, 280, 283, 286, 296, 298, 299, 391, 406, 410, 419, 433, 440, 493, 495, 497, 542, 585, 587, 591, 592, 594, 599, 612, 932, 944.

fraction four : \underline{105}, 111, 113, 116, 121, 123, 125,

126, 127, 132, 133, 296, 1116. fraction half : \underline{105}, 111, 152, 288, 408, 496, 543,

1098, 1128, 1140. fraction one: \underline{105}, 107, 108, 109, 142, 145, 148, 149, 150, 285, 288, 290, 291, 295, 300, 311, 391, 392, 402, 407, 411, 413, 415, 420, 424, 436, 439, 444, 457, 477, 478, 497, 499, 503, 530, 540, 547, 549, 599, 603, 612, 615, 815, 816, 917, 1169* , 1170. fraction three: \underline{105}, 116, 288, 296. fraction threshold : \underline{594}, 597. fraction two: \underline{105}, 116, 121, 124, 142. free: \underline{178*} , 180, 181, 182* , 183, 184. free arr : 178* . free avail : \underline{164}, 177, 216, 254, 349, 360, 604,

760, 763, 852, 860. free node: \underline{172}, 177, 216, 246, 247, 249, 254, 268, 352, 353, 354, 358, 385, 405, 452, 487, 532, 537, 595, 598, 599, 600, 601, 603, 605, 612, 615, 616, 650, 745, 763, 800, 808, 810, 818, 819, 827, 829, 837, 855, 858, 866, 890, 903, 910, 922, 925, 942, 944, 947, 955, 970, 980, 1001, 1006, 1008, 1065.

from primitive: \underline{211}.

from token: \underline{186}, 211, 212, 1073.
frozen bad vardef : \underline{201}, 203, 702.
frozen colon: \underline{201}, 203, 211, 751.
frozen end def : \underline{201}, 203, 664, 683.
frozen end for : \underline{201}, 203, 664, 683.
frozen end group: \underline{201}, 203, 211, 664, 698.
frozen fi : \underline{201}, 203, 661, 740.

frozen inaccessible: \underline{201}, 203, 691, 1196, 1197,

1199* . frozen left bracket : \underline{201}, 203, 211, 847. frozen repeat loop: \underline{201}, 757, 758, 759. frozen right delimiter : \underline{201}, 203, 664. frozen semicolon: \underline{201}, 203, 211, 664. frozen slash: \underline{201}, 203, 837, 893. frozen undefined : \underline{201}, 249. Fuchs, David Raymond: 2* , 1148. future pen: \underline{187}, 216, 248, 798, 802, 804, 808, 809,

855, 864, 865, 896, 918, 919, 921, 952, 962, 983. fwrite: 1154* . g: \underline{47}. g pointer : 216, 219, 224, \underline{225}, 1042. gamma: \underline{296}, \underline{527}, 528, 529, 530. general macro: \underline{226}, 227, 694, 697, 725. get : 25, 28, 30* , 794. get avail : \underline{163}, 165, 235, 236, 250, 335, 350, 362,

375, 376, 605, 662, 694, 697, 698, 704, 728, 734, 758, 764, 841, 845, 853, 854, 860, 863, 1011.

get boolean: 706, 713, 748, \underline{892}. get clear symbol : \underline{692}, 694, 700, 1031, 1036. get code: \underline{1103}, 1106, 1107, 1110, 1112, 1113, 1114. get next : 71, 73, 83, 624, 658, 659, 666, \underline{667},

676, 679, 685, 690, 691, 694, 700, 703, 704, 705, 706, 715, 718, 720, 730, 742, 781* , 991, 1016, 1044, 1049.

get node: \underline{167}, 173, 215, 232, 233, 234, 239, 240, 241, 244, 245, 252, 253, 264, 265, 266, 330, 331, 334, 341, 355, 364, 410, 451, 476, 477, 481, 486, 528, 535, 536, 537, 596, 597, 607, 608, 609, 619, 651, 694, 704, 705, 744, 755, 765, 799, 830, 856, 857, 871, 895, 896, 931, 964, 982, 1117.

get pair : \underline{1072}, 1073, 1074. get strings started : \underline{47}, 51* , 1204* . get symbol : \underline{691}, 692, 694, 704, 705, 755, 757,

1011, 1029, 1033, 1035, 1076. get x next : 694, 697, 706, 707, 716, \underline{718}, 726, 729,

733, 734, 735, 748, 751, 752, 755, 764, 765, 799, 800, 820, 823, 824, 825, 826, 830, 835, 837, 839, 840, 841, 844, 846, 850, 851, 853, 854, 859, 860, 861, 862, 864, 868, 874, 875, 876, 878, 881, 882, 884, 886, 892, 989, 990, 995, 996, 1011, 1012, 1021, 1023, 1029, 1031, 1033, 1034, 1035, 1036, 1040, 1044, 1045, 1049, 1050, 1054, 1059, 1070, 1071, 1072, 1073, 1074, 1076, 1082, 1103, 1106, 1107, 1112, 1115, 1177.

gf boc: \underline{1161}, 1162, 1168, 1172. gf buf : 1151, \underline{1152}, 1154* , 1155. gf buf size: \underline{11*} , 14, 1151, 1152, 1153, 1155,

1156, 1182. gf dx : 1099, \underline{1149}, 1182. gf dy : 1099, \underline{1149}, 1182. gf ext : \underline{785}, 791, 1164. gf file: \underline{791}, 1149, 1151, 1154* , 1182. gf four : \underline{1157}, 1161, 1166, 1177, 1182. gf id byte: \underline{1144}, 1163* , 1182. gf index : \underline{1151}, 1152. gf limit : 1151, \underline{1152}, 1153, 1155, 1156. gf max m: \underline{1149}, 1163* , 1168, 1169* , 1182. gf max n: \underline{1149}, 1161, 1163* , 1182. gf min m: \underline{1149}, 1161, 1163* , 1182. gf min n: \underline{1149}, 1163* , 1167, 1168, 1182. gf offset : 1151, \underline{1152}, 1153, 1155, 1163* , 1165, 1182. gf out : \underline{1155}, 1157, 1158, 1159, 1160, 1161, 1163* ,

1165, 1166, 1173, 1174, 1177, 1182. gf paint : \underline{1159}, 1170, 1171, 1172. gf prev ptr : \underline{1149}, 1150, 1163* , 1165, 1182, 1206. gf ptr : 1151, \underline{1152}, 1153, 1155, 1156, 1163* ,

1165, 1182. gf string : \underline{1160}, 1163* , 1166, 1177, 1179. gf swap: \underline{1155}. gf three: \underline{1158}, 1160. gf two: \underline{1158}, 1159, 1174. given: \underline{256}, 258, 259, 273, 282, 284, 285, 875,

877, 888, 889. good val : \underline{431}, 432, 435, 438, 442. goto: \underline{34}, \underline{76*} . granularity : \underline{190}, 192, 193, 430, 433. granularity primitive: \underline{192}. greater or equal : \underline{189}, 893, 936, 937. greater than: \underline{189}, 893, 936, 937. group line: \underline{831}, 832. gubed : \underline{7*} , 73, 79* , 88, 107, 114, 157, 178* , 179, 180,

185, 378, 517, 523, 825, 1212. Guibas, Leonidas Ioannis: 2* , 469. h: \underline{205}, \underline{257}, \underline{269}, \underline{326}, \underline{334}, \underline{344}, \underline{346}, \underline{366}, \underline{369},

\underline{385}, \underline{402}, \underline{465}, \underline{473}, \underline{477}, \underline{484}, \underline{488}, \underline{491}, \underline{506}, \underline{518}, \underline{527}, \underline{539}, \underline{562}, \underline{860}, \underline{1011}.

half : \underline{96}, 102, 111, 113, 121, 126, 133, 142, 150, 232, 313, 314, 317, 392, 432, 442, 445, 556, 559, 561, 596, 866, 939, 1122.

half buf : 1151, \underline{1152}, 1153, 1155, 1156. half error line: \underline{11*} , 14, 635, 641, 642, 643. half fraction threshold : \underline{594}, 599, 600, 612, 616. half scaled threshold : \underline{594}, 599, 600. half unit : \underline{101}, 113, 119, 374, 402, 462, 463,

468, 477, 478, 512, 515, 518, 521, 528, 530, 533, 917, 1106.

halfword : 153* , \underline{156*} , 158, 172, 210, 246, 253, 284, 329, 346, 366, 491, 497, 624, 627, 697, 755, 862, 864, 868, 1029, 1077, 1104.

hard times : 941, \underline{946}. hash: 200, \underline{201}, 202, 205, 207, 625, 658, 1196, 1197. hash base: \underline{200}, 201, 205. hash end : \underline{201}, 202, 204, 209, 214, 229, 250,

253, 254, 699, 841, 996, 998, 999, 1049, 1196, 1197, 1199* .

hash is full : \underline{200}, 207. hash prime: \underline{12*} , 14, 205, 208, 1190, 1191* . hash size: \underline{12*} , 14, 201, 207, 208, 1190, 1191* , 1208. hash top: \underline{201}. hash used : \underline{200}, 203, 207, 1196, 1197. header : 1090. header byte: \underline{1096}, 1097, 1106, 1114, 1128, 1131,

1135, 1182. headerbyte primitive: \underline{1101}. header byte code: \underline{1101}, 1102, 1106. header size: \underline{11*} , 14, 1096, 1097, 1114, 1135. Hedrick, Charles Locke: 3. height index : \underline{1091}. help line: \underline{74}, 84, 86, 661, 664, 691, 852, 1016,

1055. help ptr : \underline{74}, 75, 84, 86. help0 : \underline{74}, 1051. help1 : \underline{74}, 88, 90, 703, 713, 734, 751, 838, 839,

876, 881, 883, 914, 937, 1021, 1034, 1051, 1056, 1071, 1074, 1082, 1086, 1098, 1106, 1107, 1110, 1113, 1115, 1178.

help2 : 67, \underline{74}, 83, 84, 89, 90, 122, 128, 134, 140, 270, 478, 623, 670, 675, 701, 708, 712, 713, 716, 727, 735, 747, 765, 832, 865, 878, 892, 937, 950, 996, 999, 1002, 1004, 1008, 1015, 1017, 1021, 1032, 1055, 1057, 1061, 1062, 1067, 1073, 1103, 1105, 1106, 1112.

help3 : 67, \underline{74}, 93, 340, 342, 478, 661, 672, 691, 725, 726, 727, 755, 756, 795, 849, 859, 861, 875, 887, 901, 923, 955, 960, 963, 965* , 993, 1032, 1035, 1068.

help4 : \underline{74}, 84, 99, 404, 602, 663, 754, 824, 830,

1060, 1086. help5 : \underline{74}, 693, 851, 872, 873, 878, 990, 1016. help6 : \underline{74}, 991. : 1208. hex primitive: \underline{893}. hex op: \underline{189}, 893, 912. hh: 153* , 157, 161, 214, 250, 255, \underline{334}, \underline{477},

479, \underline{562}, 563. hi mem min: \underline{159}, 161, 163, 167, 168, 176, 177,

178* , 180, 181, 184, 185, 216, 218, 242, 617, 676, 850, 1045, 1194, 1195, 1207, 1208.

hi mem stat min: \underline{175}, 176, 1195. history : \underline{71}, 72, 76* , 77, 88, 90, 195, 1204* , 1209. hlp1 : \underline{74}. hlp2 : \underline{74}. hlp3 : \underline{74}. hlp4 : \underline{74}. hlp5 : \underline{74}. hlp6 : \underline{74}. ho: \underline{155*} , 324, 333, 343, 344, 349, 352, 358, 359,

360, 370, 373, 582, 1169* . Hobby, John Douglas: 274, 354, 432, 524. hold head : \underline{175}, 665, 685, 697, 730. hppp: \underline{190}, 192, 193, 785, \underline{1146}, 1164, 1182. hppp primitive: \underline{192}. htap ypoc: \underline{266}, 921, 978, 1064, 1065. i: \underline{19*} , \underline{150}, \underline{641}. : 779* . : 786. : 90. : 51* . : 786. id lookup: \underline{205}, 210, 669. id transform: \underline{233}, 955. if primitive: \underline{740}. if code: \underline{738}, 740, 741, 744, 751. if limit : \underline{738}, 739, 744, 745, 746, 748, 751. if line: \underline{738}, 739, 744, 745, 748, 1209. if line field : \underline{738}, 744, 745, 1209. if node size: \underline{738}, 744, 745. if test : \underline{186}, 706, 707, 740, 741, 742, 748. ifdef : 7* , 8* . : 1128. : 1107. : 1016. : 218. : 996. : 1061, 1062. : 1073. : 876. : 1115. : 1112. : 1106. : 849. : 883. : 955. : 1055. : 754. in open: \underline{631}, 654, 655, 657. in state record : \underline{627}, 628. in window : \underline{186}, 211, 212, 1071. inwindow primitive: \underline{211}. : 661. : 672. : 1004, 1008. incr : 36* , 41, 42, 44, 45, 46, 53* , 58, 59, 60, 64, 66,

77, 85, 86, 93, 108, 115, 123, 136, 143, 147, 163, 165, 183, 207, 226, 281, 284, 297, 314, 315, 317, 319, 320, 321, 322, 333, 348, 352, 362, 364, 366, 375, 376, 377, 381, 382, 383, 384, 404, 429, 458, 459, 481, 483, 487, 497, 502, 514, 515, 516, 520, 521, 522, 560, 574, 577, 583, 584, 647, 654, 669, 671, 673, 674, 681, 687, 704, 705, 717, 721, 724, 728, 731, 732, 734, 736, 737, 742, 772, 774, 779* , 781* , 787* , 793* , 1036, 1104, 1107, 1112, 1113, 1114, 1115, 1118, 1121* , 1129, 1137, 1138, 1140, 1155, 1165, 1196, 1211. independent : \underline{187}, 216, 219, 232, 248, 585, 589,

592, 604, 615, 798, 799, 800, 801, 802, 803, 808, 809, 816, 827, 828, 855, 857, 858, 903, 918, 925, 926, 927, 928, 944, 1003, 1006, 1007, 1009.

independent being fixed : \underline{605}. independent needing fix : \underline{592}, 595, 596, 598,

599, 600. index : 627, \underline{629}, 630, 631, 632, 654, 655, 657. index field : \underline{627}, 629. inf val : \underline{175}, 1116, 1117, 1118, 1121* , 1136. info: \underline{161}, 166, 168, 176, 185, 214, 218, 221, 226,

227, 228, 229, 235, 236, 242, 245, 246, 250, 252, 253, 254, 324, 325, 326, 328, 333, 335, 337, 338, 339, 342, 343, 344, 345, 346, 347, 349, 350, 351, 358, 359, 360, 362, 366, 367, 368, 370, 373, 375, 376, 378, 381, 382, 383, 384, 472, 473, 475, 481, 484, 488, 491, 509, 512, 519, 580, 582, 587, 589, 591, 594, 595, 596, 597, 598, 599, 600, 601, 604, 605, 607, 608, 609, 610, 611, 612, 614, 615, 616, 617, 651, 662, 676, 685, 686, 694, 697, 698, 700, 704, 705, 714, 719, 721, 722, 725, 726, 727, 728, 729, 733, 734, 736, 752, 755, 758, 760, 763, 764, 805, 811, 812, 816, 818, 819, 841, 850, 853, 854, 860, 863, 904, 931, 933, 935, 968, 996, 998, 999, 1006, 1007, 1010, 1011, 1015, 1050, 1121* , 1122, 1127, 1136, 1169* , 1207, 1213.

: 8* , 11* , 12* , 47, 50, 159, 1183, 1203. init: \underline{8*} , \underline{47}, \underline{50}, \underline{173}, \underline{210}, \underline{1186}, \underline{1204*} , \underline{1209}, \underline{1210}. init big node: \underline{232}, 233, 830, 857, 982. init edges : \underline{326}, 353, 364, 895, 964. init gf : \underline{1163*} . init pool ptr : \underline{38}, 41, 1045, 1193, 1204* , 1208. init prim: 1204* , \underline{1210}. init randoms : \underline{150}, 1022, 1211. init screen: 564* , 569, 570, 571. init str ptr : \underline{38}, 44, 772, 1045, 1193, 1204* , 1208. init tab: 1204* , \underline{1210}. init terminal : \underline{36*} , 657. initialize: \underline{4}, 1204* , 1211. inner loop: 30* , 107, 108, 109, 111, 112, 113, 163,

165, 167, 169* , 172, 177, 242, 244, 408, 650, 651, 667, 668, 669, 676, 718, 850.

inner primitive: \underline{1027}. input : \underline{186}, 706, 707, 709, 710. input primitive: \underline{709}. input file: \underline{631}. input ln: 29, 30* , 36* , 58, 66, 681, 794. input ptr : \underline{628}, 635, 636, 647, 648, 656, 657,

679, 788* . input stack : 79* , \underline{628}, 635, 647, 648, 788* . ins error : \underline{653}, 661, 663, 691, 751, 824. : 82. inserted : \underline{632}, 638, 650, 653. install : 857, \underline{858}, 957, 959. int : 153* , 156* , 157, 214, 326, 435, 738. int increment : \underline{553}, 559, 561. int name: \underline{190}, 193, 254, 998, 999, 1036, 1043,

1098, 1123, 1198, 1199* . int packets : \underline{553}, 558, 560. int ptr : \underline{190}, 191, 1036, 1198, 1199* , 1208. integer : 13, 19* , 45, 46, 47, 54, 59, 60, 64, 65, 77, 89, 91, 100, 101, 102, 105, 106, 107, 109, 112, 114, 116, 117, 119, 121, 124, 126, 129, 130, 132, 135, 139, 145, 152, 153* , 156* , 160, 167, 185, 200, 205, 217, 227, 242, 299, 308, 309, 311, 321, 327, 328, 329, 332, 333, 337, 340, 342, 348, 354, 357, 363, 366, 369, 371, 373, 374, 378, 391, 398, 402, 403, 453, 464, 473, 477, 484, 488, 495, 497, 507, 511, 527, 555, 557, 562, 572, 574, 577, 580, 585, 589, 594, 597, 599, 600, 601, 608, 610, 621, 624, 625, 626, 631, 633, 641, 651, 659, 667, 685, 707, 720, 723, 730, 738, 742, 773, 774, 775* , 778, 788* , 796, 801, 809, 813, 831, 895, 898, 899, 900, 913, 922, 930, 943, 977, 1001, 1059, 1070, 1073, 1074, 1096, 1103, 1106, 1118, 1119, 1120* , 1121* , 1129, 1130, 1131, 1149, 1152, 1157, 1158, 1159, 1160, 1161, 1162, 1163* , 1165, 1186, 1187, 1203, 1205* , 1210, 1212, 1214* .

interaction: 66, 67, \underline{68}, 69, 70, 77, 79* , 81, 86, 87, 88, 93, 398, 679, 682, 786, 807, 897, 1023, 1051, 1086, 1198, 1199* , 1200* , 1205* , 1209.

interesting : \underline{238}, 603, 613, 817, 1050.

interim primitive: \underline{211}.
interim command : \underline{186}, 211, 212, 1033.

internal : \underline{190}, 191, 194* , 195, 238, 253, 254, 269, 375, 376, 381, 382, 383, 384, 402, 430, 433, 465, 468, 477, 506, 508, 510, 515, 517, 521, 523, 533, 602, 603, 610, 682, 707, 713, 720, 728, 734, 748, 760, 790* , 804, 816, 832, 841, 895, 898, 922, 944, 992, 994, 995, 996, 999, 1036, 1051, 1064, 1068, 1070, 1097, 1098, 1099, 1128, 1129, 1134, 1137, 1163* , 1164, 1165, 1177, 1182, 1198, 1199* , 1200* , 1205* , 1206, 1211, 1213.

: 999.

internal quantity : \underline{186}, 192, 823, 844, 860, 1011,

1034, 1036, 1043. interrupt : \underline{91}, 92, 93, 825. : 93. intersect : \underline{189}, 893, 988. intersectiontimes primitive: \underline{893}. : 1103. invalid class : \underline{198}, 199* , 669. is empty : \underline{166}, 169* , 182* , 183. : 993. isolated classes : \underline{198}, 223, 669. italic index : \underline{1091}. iteration: \underline{186}, 683, 684, 685, 706, 707, 758. j: \underline{45}, \underline{46}, \underline{59}, \underline{60}, \underline{77}, \underline{150}, \underline{205}, \underline{210}, \underline{357}, \underline{378},

\underline{707}, \underline{774}, \underline{778}, \underline{779*} , \underline{1106}. j random: \underline{148}, 149, 151, 152. Japanese characters: 1147. Jensen, Kathleen: 10. jj : \underline{150}, \underline{357}, 364. : 679. : 786. job name: 87, \underline{782}, 783, 784, 788* , 791, 793* , 895,

1134, 1200* , 1209. jobname primitive: \underline{893}. job name op: \underline{189}, 893, 895. jump out : \underline{76*} , 77, 79* , 88. k: \underline{45}, \underline{46}, \underline{47}, \underline{63}, \underline{64}, \underline{66}, \underline{102}, \underline{121}, \underline{130}, \underline{132}, \underline{135},

\underline{139}, \underline{145}, \underline{149}, \underline{150}, \underline{205}, \underline{210}, \underline{264}, \underline{280}, \underline{284}, \underline{299}, \underline{321}, \underline{346}, \underline{363}, \underline{366}, \underline{378}, \underline{402}, \underline{426}, \underline{440}, \underline{473}, \underline{477}, \underline{484}, \underline{487}, \underline{491}, \underline{497}, \underline{511}, \underline{574}, \underline{577}, \underline{667}, \underline{682}, \underline{697}, \underline{707}, \underline{774}, \underline{778}, \underline{780}, \underline{786}, \underline{788*} , \underline{895}, \underline{913}, \underline{976}, \underline{977}, \underline{978}, \underline{1073}, \underline{1106}, \underline{1131}, \underline{1160}, \underline{1163*} , \underline{1186}, \underline{1187}, \underline{1205*} , \underline{1210}, \underline{1212}.

keep code: \underline{1052}, 1074. keeping : \underline{1074}, 1075. keeping primitive: \underline{1052}. kern: 1093, \underline{1096}, 1106, 1112, 1139. kern primitive: \underline{1108}. kern flag : \underline{1093}, 1112. knil : \underline{325}, 326, 330, 331, 332, 334, 336, 341, 352,

354, 355, 364, 376, 377, 382, 384, 442, 472, 473, 475, 476, 482, 483, 484, 497, 503, 505, 508, 509, 513, 515, 517, 519, 521, 523, 1167.

knot node size: \underline{255}, 264, 265, 266, 268, 405, 410, 451, 452, 486, 528, 532, 535, 536, 537, 866, 871, 890, 896, 980, 1065.

knots : \underline{269}, 271, 272. known: \underline{187}, 214, 215, 216, 219, 233, 248, 585,

594, 603, 615, 651, 678, 726, 760, 765, 798, 799, 802, 803, 808, 809, 823, 826, 827, 829, 830, 837, 841, 846, 855, 857, 858, 861, 873, 876, 878, 883, 895, 899, 903, 906, 912, 915, 918, 919, 930, 931, 932, 935, 937, 939, 941, 942, 943, 944, 948, 949, 951, 953, 956, 957, 959, 960, 966, 968, 969, 970, 971, 972, 974, 982, 983, 999, 1003, 1006, 1007, 1009, 1021, 1052, 1054, 1062, 1071, 1073, 1074, 1103, 1106, 1112, 1115, 1176, 1177, 1180.

known primitive: \underline{893}. known op: \underline{189}, 893, 918, 919. known pair : 871, \underline{872}, 877, 884. Knuth, Donald Ervin: 2* , 81. l: \underline{46}, \underline{47}, \underline{152}, \underline{205}, \underline{210}, \underline{217}, \underline{227}, \underline{311}, \underline{641}, \underline{742},

\underline{746}, \underline{788*} , \underline{977}, \underline{978}, \underline{1006}, \underline{1011}, \underline{1035}, \underline{1118},
\underline{1121*} , \underline{1160}, \underline{1212}.

l delim: \underline{697}, 703, \underline{720}, 726, 727, 729, \underline{730}, 731,

735, \underline{823}, 826, 830, \underline{1031}, \underline{1032}.

l packet : 560.

l packets : \underline{553}, 559.

label char : \underline{1096}, 1104, 1137, 1138.

label loc: \underline{1096}, 1097, 1104, 1137, 1138, 1139. label ptr : \underline{1096}, 1097, 1104, 1137, 1138, 1139. Lane, Jeffrey Michael: 303. last : \underline{29}, 30* , 34, 35, 36* , 66, 78, 82, 83, 657, 679,

682, 779* , 787* , 897. last text char : \underline{19*} , 23.

last window : \underline{326}, 334, 577.

last window time: \underline{326}, 334, 336, 337, 340, 342,

344, 348, 364, 577, 965* . left brace: \underline{186}, 211, 212, 874. left bracket : \underline{186}, 211, 212, 823, 844, 847, 860,

1011, 1012. left bracket class : \underline{198}, 199* , 220, 221.

left col : 567* , \underline{572}, 574, 577, 581.
left curl : \underline{256}, 259, 263, 271, 282, 295, 879,

890, 891. left delimiter : \underline{186}, 697, 703, 726, 731, 735, 823,

1030, 1031, 1043. left given: \underline{256}, 259, 263, 282, 292, 301, 879,

880, 888. left length: \underline{528}, 531, 532, 534, 535. left octant : \underline{393}, 394, 398, 401, 451, 452, 458,

459, 465, 506. left tension: \underline{256}, 258, 260, 288, 289, 294, 295,

299, 300, 302, 880. left transition: \underline{393}, 459, 508. left type: \underline{255}, 256, 257, 258, 259, 261, 262, 263,

265, 266, 269, 271, 272, 273, 281, 282, 284, 285, 287, 299, 302, 393, 394, 397, 398, 399, 400, 401, 402, 404, 410, 451, 452, 465, 486, 506, 528, 865, 870, 871, 879, 885, 887, 888, 890, 891, 896, 916, 917, 920, 962, 978, 979, 985, 987, 1064, 1066.

left v : \underline{528}, 531, 534, 535.

left x : \underline{255}, 256, 261, 265, 266, 271, 282, 299, 302, 393, 397, 404, 407, 409, 410, 411, 412, 418, 419, 421, 423, 424, 425, 434, 436, 441, 444, 447, 451, 457, 468, 486, 492, 496, 512, 518, 528, 543, 558, 563, 866, 880, 887, 896, 962, 987, 1066. left y : \underline{255}, 256, 261, 265, 266, 271, 282, 299, 302, 393, 397, 404, 409, 410, 413, 414, 415, 416, 419, 423, 424, 425, 437, 439, 444, 447, 451, 457, 468, 486, 492, 496, 512, 518, 528, 543, 558, 563, 866, 880, 887, 896, 962, 987, 1066.

length: \underline{39}, 46, 205, 716, 717, 793* , 912, 913, 915, 976, 977, 1083, 1103, 1160. length primitive: \underline{893}. length op: \underline{189}, 893, 915. less or equal : \underline{189}, 893, 936, 937. less than: \underline{189}, 893, 936, 937. let primitive: \underline{211}. let command : \underline{186}, 211, 212, 1033. letter class : \underline{198}, 199* , 218, 223. lf : 1088. lh: 153* , 157, 161, 200, \underline{491}, 502, 505, 1088,

1089, 1135, \underline{1205*} . lhs : \underline{995}, \underline{996}, 997, 998, 999, 1000, \underline{1001}, 1002,

1003, \underline{1059}, 1061, 1062, 1064. lig kern: 1092, 1093, \underline{1096}, 1137, 1139, 1205* . lig kern command : 1089, \underline{1093}. lig kern token: \underline{186}, 1107, 1108, 1109. ligtable primitive: \underline{1101}. lig table code: \underline{1101}, 1102, 1106. lig table size: \underline{11*} , 14, 1096, 1107, 1137, 1141. lig tag : \underline{1092}, 1104, 1105, 1111. limit : 627, \underline{629}, 630, 632, 644, 654, 656, 657, 669,

671, 672, 679, 681, 682, 717, 793* , 794, 1211. limit field : 34, 82, \underline{627}, 629, 788* . line: 79* , 197, \underline{631}, 637, 654, 655, 657, 681, 742,

744, 748, 794, 832. line edges : \underline{374}, 378, 507, 510. line stack : \underline{631}, 654, 655. linear eq : \underline{610}, 1006. link : \underline{161}, 163, 164, 165, 166, 167, 168, 172, 176,

177, 181, 185, 216, 217, 227, 228, 229, 230, 232, 234, 235, 236, 237, 238, 239, 240, 241, 242, 244, 245, 246, 247, 250, 252, 253, 254, 255, 257, 265, 266, 268, 271, 272, 273, 281, 284, 297, 324, 325, 326, 328, 330, 331, 332, 334, 335, 336, 337, 338, 339, 341, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 359, 360, 362, 364, 366, 367, 368, 369, 370, 375, 376, 377, 381, 382, 383, 384, 385, 394, 398, 399, 400, 401, 402, 404, 405, 406, 410, 411, 412, 413, 415, 416, 418, 419, 424, 425, 433, 435, 436, 439, 440, 442, 444, 447, 450, 451, 452, 458, 459, 465, 466, 468, 472, 473, 475, 476, 477, 479, 481, 482, 483, 484, 485, 487, 488, 491, 492, 493, 497, 499, 502, 503, 504, 506, 508, 509, 512, 513, 515, 517, 518, 519, 521, 523, 528, 532, 535, 536, 537, 539, 556, 558, 562, 577, 582, 587, 589, 591, 594, 595, 596, 597, 598, 599, 600, 601, 603, 604, 605, 606, 608, 609, 611, 612, 614, 616, 617, 639, 640, 650, 651, 665, 676, 678, 685, 686, 694, 697, 698, 700, 702, 704, 705, 719, 720, 721, 722, 723, 724, 725, 727, 728, 730, 734, 736, 738, 744, 745, 746, 752, 758, 760, 762, 763, 764, 799, 805, 811, 812, 814, 815, 816, 818, 819, 827, 844, 845, 848, 850, 851, 852, 853, 854, 860, 863, 867, 870, 871, 885, 887, 890, 891, 896, 904, 910, 916, 921, 931, 933, 947, 962, 968, 978, 980, 981, 985, 986, 1007, 1010, 1011, 1015, 1043, 1047, 1050, 1065, 1068, 1117, 1118, 1121* , 1122, 1124, 1126, 1136, 1169* , 1194, 1207, 1209, 1213.

list tag : \underline{1092}, 1105, 1106. lk offset : 1135, 1137, 1138, 1139, \underline{1205*} . lk started : \underline{1096}, 1107, 1112, 1137, 1138, 1139. ll : \underline{1096}, 1110, 1111, 1139. llink : \underline{166}, 168, 169* , 171, 172, 173, 176, 182* , 1207. lll : \underline{1096}, 1110, 1111. lo mem max : \underline{159}, 163, 167, 168, 176, 178* , 180,

182* , 183, 184, 185, 1045, 1194, 1195, 1207, 1208. lo mem stat max : \underline{175}, 176, 1195, 1207. load base file: \underline{1187}, 1211. loc: \underline{35}, 36* , 82, 627, \underline{629}, 630, 632, 636, 638, 644,

645, 649, 652, 654, 656, 657, 669, 671, 672, 673, 674, 676, 678, 679, 681, 712, 717, 736, 779* , 781* , 793* , 794, 795, 1211.

loc field : 34, 35, \underline{627}, 629. : 1139. log file: \underline{54}, 56, 70, 788* , 1205* . log name: \underline{782}, 788* , 1205* . log only : \underline{54}, 57, 58, 62, 70, 93, 679, 788* , 1022,

1200* . log opened : 87, 88, \underline{782}, 783, 788* , 789, 1023,

1205* , 1208. : 134. long help seen: \underline{1084}, 1085, 1086. loop: 15, \underline{16*} . : 714. : 762. loop defining : \underline{659}, 664, 665, 758. loop list : \underline{752}, 760, 763, 764. loop list loc: \underline{752}, 764. loop node size: \underline{752}, 755, 763. loop ptr : 712, 713, 714, \underline{752}, 753, 758, 760, 763. loop repeat : 685. loop text : \underline{632}, 638, 714, 760. loop type: \underline{752}, 755, 760, 763, 764, 765. : 712. ls : \underline{46}. lt : \underline{46}, \underline{286}, 289, 294, 295, \underline{299}, 302. m: \underline{47}, \underline{64}, \underline{311}, \underline{333}, \underline{337}, \underline{348}, \underline{357}, \underline{369}, \underline{373}, \underline{473},

\underline{484}, \underline{511}, \underline{574}, \underline{580}, \underline{608}, \underline{625}, \underline{626}, \underline{641}, \underline{694}, \underline{697}, \underline{755}, \underline{788*} , \underline{913}, \underline{1029}, \underline{1082}, \underline{1098}, \underline{1118}, \underline{1120*} , \underline{1121*} , \underline{1123}, \underline{1165}, \underline{1177}, \underline{1212}.

m adjustment : \underline{580}, 581, 582. m exp: \underline{135}, 906. mexp primitive: \underline{893}. m exp op: \underline{189}, 893, 906. m log : \underline{132}, 134, 152, 906. mlog primitive: \underline{893}. m log op: \underline{189}, 893, 906. m magic: \underline{354}, 361, 362, 365. m max : \underline{326}, 329, 334, 337, 342, 348, 352, 354,

356, 357, 364, 366, 965* , 1172. m min: \underline{326}, 329, 334, 337, 342, 348, 352, 354,

356, 357, 364, 365, 366, 965* , 1172. m offset : \underline{326}, 328, 329, 333, 334, 337, 342, 348,

352, 364, 365, 366, 367, 373, 375, 376, 381, 382, 383, 384, 581, 965* , 1169* , 1172.

m spread : 356, \underline{357}, 364. m window : \underline{572}, 576, 581. mac name: \underline{862}, \underline{864}, \underline{868}. macro: \underline{632}, 638, 645, 649, 736. macro at : \underline{688}, 689. macro call : 707, 718, 719, \underline{720}, 853, 854, 863. macro def : \underline{186}, 683, 684, 685, 694, 698, 992, 1043. macro name: \underline{720}, 721, 725, 726, 734, 736. macro prefix : \underline{688}, 689. macro ref : \underline{843}, 845, 854. macro special : \underline{186}, 685, 688, 689, 700. macro suffix : \underline{688}, 689, 700. main control : \underline{1017}, 1204* , 1211. major axis : \underline{527}, 530, 533, \underline{865}, 866. make choices : \underline{269}, 274, 277, 278, 891. make ellipse: \underline{527}, 528, 866. make eq : 995, 1000, \underline{1001}. make exp copy : 651, 823, 852, \underline{855}, 859, 903, 910,

926, 927, 944, 967, 970, 973, 1000. make fraction: \underline{107}, 109, 116, 125, 127, 145, 152,

281, 288, 289, 290, 291, 294, 295, 296, 300, 302, 375, 376, 436, 439, 444, 454, 498, 516, 522, 530, 533, 540, 548, 549, 612, 818, 944.

make known: \underline{603}, 604, 614, 818, 819. make moves : 309, \underline{311}, 321, 468, 512, 514,

518, 550. make name string : \underline{780}. make op def : \underline{694}, 992. make path: \underline{484}, 921, 962. makepath primitive: \underline{893}. make path op: \underline{189}, 893, 921. make pen: \underline{477}, 865. makepen primitive: \underline{893}. make pen op: \underline{189}, 893, 921. make safe: \underline{426}, 427, 436, 439, 440, 446. make scaled : \underline{114}, 116, 600, 612, 819, 837, 948,

949, 980, 1128, 1129, 1164, 1182. make spec: \underline{402}, 403, 409, 448, 460, 493, 917, 1064. make string : \underline{44}, 48, 52* , 207, 671, 772, 780, 840,

897, 912, 976, 977, 1164, 1200* , 1205* . Marple, Jane: 1086. materialize pen: 864, \underline{865}, 921, 983. max : \underline{539}, 543. max allowed : 402, \underline{403}, 404, 434, 437. max buf stack : \underline{29}, 30* , 657, 717, 1208. max c: 812, \underline{813}, 814, 815, 816, 817. max class : \underline{198}. max coef : \underline{495}, 496, \underline{591}, 932, 943, 949. max command code: \underline{186}, 821, 823, 824, 868. max d : \underline{348}, 351, 352. max expression command : \underline{186}, 868. max font dimen: \underline{11*} , 1096, 1115, 1141. max given internal : \underline{190}, 191, 1199* . max halfword : 11* , 12* , 14, \underline{153*} , 154, 156* , 166, 167,

168, 173, 174, 204, 214, 324, 348, 351, 358, 1207. max in open: \underline{12*} , 631, 632, 654, 1190, 1191* . max in stack : \underline{628}, 647, 657, 1208. max internal : \underline{11*} , 190, 204, 1036, 1199* , 1208. max kerns : \underline{11*} , 1096, 1106, 1112, 1141. max link : 812, \underline{813}, 814, 815, 818, 819. max m: 1144, \underline{1146}, \underline{1161}. max n: \underline{348}, 351, 352, 1144, \underline{1146}, \underline{1161}. max new row : \underline{1145}, 1173. max offset : \underline{472}, 475, 477, 962, 1064. max param stack : \underline{633}, 657, 736, 737, 1208. max patience: \underline{555}, 556. max pool ptr : \underline{38}, 41, 47, 1045, 1193, 1204* , 1208. max primary command : \underline{186}, 823, 836, 862, 864,

868, 989, 990. max print line: \underline{11*} , 14, 54, 58, 61* , 67, 333, 372,

793* , 1046, 1048, 1165. max ptr : \underline{813}, 814, 815, 816. max quarterword : \underline{153*} , 154, 156* , 399, 404, 481. max rounding ptr : \underline{427}, 428, 429, 1208. max secondary command : \underline{186}, 862. max selector : \underline{54}, 196, 635, 788* . max statement command : \underline{186}, 989. max str ptr : \underline{38}, 44, 47, 772, 1045, 1193, 1204* ,

1208. max str ref : \underline{42}, 43, 48, 52* , 207, 793* , 1193, 1200* . max strings : \underline{11*} , 37, 44, 154, 772, 780, 1045,

1193, 1208. max suffix token: \underline{186}, 844. max t : \underline{555}, 556. max tertiary command : \underline{186}, 864. max tfm dimen: 1128, 1129, \underline{1130}, 1182. max wiggle: \underline{11*} , 426, 427, 429, 440, 1208. mc: \underline{477}, 478, 479. Meggitt, John E.: 143. mem: 11* , 12* , 158, \underline{159}, 161, 166, 168, 173, 175,

176, 178* , 180, 185, 214, 216, 229, 241, 242, 244, 250, 255, 264, 326, 334, 435, 472, 475, 587, 594, 738, 752, 827, 947, 961, 1194, 1195, 1213. mem end : 159, \underline{161}, 163, 176, 178* , 180, 181, 184,

185, 218, 1194, 1195, 1208. mem max : \underline{11*} , 14, 153* , 154, 159, 163, 166,

167, 178* , 179. mem min: 11* , \underline{12*} , 14, 154, 158, 159, 163, 167, 168,

175, 176, 178* , 179, 180, 183, 184, 185, 218, 1190, 1191* , 1194, 1195, 1208.

mem top: \underline{11*} , 14, 154, 159, 175, 176, 1190,

1191* , 1195. : 1045. memory word : 153* , 157, 159, 242, 1188* . merge edges : \underline{366}, 929, 1061. message primitive: \underline{1079}. message code: \underline{1079}, 1082. message command : \underline{186}, 1079, 1080, 1081. : 89.

buffer size: 34, 654, 717. extensible: 1113. fontdimen: 1115. hash size: 207. headerbyte: 1114. input stack size: 647. kern: 1112. ligtable size: 1107. main memory size: 163, 167. move table size: 356, 468, 508. number of internals: 1036. number of strings: 44, 772. parameter stack size: 704, 736, 737. path size: 281. pen polygon size: 481. pool size: 41. rounding table size: 429. text input levels: 654.

The book: 1, 199* , 574, 824, 872, 873,

878, 990, 991, 1068, 1203. 84: \underline{1}. metric file name: \underline{1087}, 1134. MF : \underline{4}. : 53* . : 53* . : 52* . : 52* . MF area: 769* . MF base default : \underline{775*} , 778. MF BASE PATH BIT : 1204* . MF INPUT PATH : 793* . MF INPUT PATH BIT : 1204* . MF POOL PATH : 51* . MF POOL PATH BIT : 1204* . : 776* . mid : \underline{1094}. min col : \underline{580}, 581, 582, 583. min command : \underline{186}, 706, 715, 718. min cover : \underline{1118}, 1120* . min d : \underline{348}, 351, 352. min expression command : \underline{186}, 868, 869. min halfword : 12* , \underline{153*} , 154, 155* , 156* , 324, 326,

337, 342, 348, 350, 365, 375, 376, 381, 382, 383, 384, 580.

min m: 1144, \underline{1146}, \underline{1161}. min n: \underline{348}, 351, 352, 1144, \underline{1146}, \underline{1161}. min of : \underline{189}, 923. min primary command : \underline{186}, 823, 837, 862,

864, 868, 989. min quarterword : \underline{153*} , 154, 156* , 1093. min secondary command : \underline{186}, 862. min suffix token: \underline{186}, 844. min tension: \underline{883}. min tertiary command : \underline{186}, 864. minor axis : \underline{527}, 530, 533, \underline{865}, 866. minus : \underline{189}, 859, 893, 898, 903, 922, 929, 930,

936, 939. : 727, 735, 1032. : 725. : 727, 878. : 881. : 747, 751, 756, 1106. : 1021. : 713. : 693, 755, 1035. : 1113. : 875. : 859, 861. : 734, 839. : 765. : 726. : 703. : 691. : 94. missing err : \underline{94}, 693, 713, 727, 734, 735, 747, 751,

755, 756, 765, 839, 859, 861, 875, 878, 881, 1021, 1032, 1035, 1106, 1113.

missing extensible punctuation: \underline{1113}. ml : \underline{329}. mm: \underline{348}, 349, \underline{357}, 358, 362, 364, \underline{580}, 582,

\underline{1165}, 1169* . mm0 : \underline{511}, 513, 517, 519, 523. mm1 : \underline{511}, 513, 517, 519, 523. mock curvature: 275. mode command : \underline{186}, 1023, 1024, 1025. Moler, Cleve Barry: 124. month: \underline{190}, 192, 193, 194* , 790* , 1163* , 1200* . month primitive: \underline{192}. months : \underline{788*} , 790* . more name: 767, \underline{771*} , 781* , 787* . Morrison, Donald Ross: 124. move: \underline{308}, 311, 315, 316, 319, 320, 321, 322, 354,

356, 357, 362, 364, 378, 379, 381, 382, 383, 384, 468, 507, 512, 514, 517, 518, 520, 523.

move increment : \underline{309}, 310, 312, 314. move ptr : \underline{308}, 311, 315, 316, 319, 320, 468,

511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523.

move size: \underline{11*} , 308, 311, 321, 356, 357, 362, 378,

468, 507, 508, 511. move to edges : \underline{378}, 465, 517, 523. mr : \underline{329}. mtype: \underline{4}. : 1187. my var flag : \underline{823}, 841, 852, \underline{868}. m0 : \underline{374}, 375, 376, \underline{378}, 380, 381, 382, 383, 384,

\underline{464}, 465, 467, 508, 511, 517, 523. m1 : \underline{374}, 375, 376, \underline{378}, 380, 463, \underline{464}, 465, 467,

508, 511, 517, 523. n: \underline{47}, \underline{64}, \underline{65}, \underline{89}, \underline{107}, \underline{109}, \underline{112}, \underline{114}, \underline{242}, \underline{246}, \underline{280},

\underline{284}, \underline{311}, \underline{332}, \underline{348}, \underline{366}, \underline{369}, \underline{373}, \underline{374}, \underline{378}, \underline{473}, \underline{477}, \underline{484}, \underline{488}, \underline{491}, \underline{497}, \underline{511}, \underline{539}, \underline{562}, \underline{574}, \underline{580}, \underline{610}, \underline{641}, \underline{667}, \underline{697}, \underline{720}, \underline{722}, \underline{723}, \underline{755}, \underline{773}, \underline{774}, \underline{778}, \underline{863}, \underline{913}, \underline{916}, \underline{944}, \underline{985}, \underline{1046}, \underline{1165}, \underline{1212}.

n arg : \underline{139}, 140, 141, 147, 256, 281, 282, 292, 293,

301, 387, 541, 544, 866, 877, 907. n cos : \underline{144}, 145, 259, 263, 297, 301, 530, 533,

906, 958. n magic: \underline{354}, 361, 362, 365. n max : \underline{326}, 329, 331, 332, 334, 336, 340, 348,

352, 364, 365, 366, 965* , 1167. n min: \underline{326}, 329, 330, 334, 336, 340, 348, 352,

364, 366, 577, 965* , 1172. n pos : \underline{326}, 330, 331, 334, 336, 352, 364, 374,

377, 378, 965* . n rover : \underline{326}, 330, 331, 334, 352, 364, 374,

377, 378. n sin: \underline{144}, 145, 259, 263, 297, 301, 530, 533,

906, 958. n sin cos : 144, \underline{145}, 147, 259, 263, 297, 301,

530, 906, 958. n window : \underline{572}, 576, 577. name: 229, 627, \underline{629}, 630, 631, 632, 635, 637, 638,

649, 654, 655, 657, 679, 717, 736, 793* , 897. name field : 79* , \underline{627}, 629. name length: \underline{25}, 774, 778, 780. name of file: \underline{25}, 51* , 774, 778, 780, 786. name type: 188, \underline{214}, 215, 219, 228, 229, 230,

232, 233, 234, 235, 236, 237, 238, 239, 240, 244, 245, 246, 247, 249, 254, 619, 651, 678, 702, 738, 744, 745, 799, 806, 830, 856, 857, 911, 931, 982, 1047, 1209.

nd : 1088, 1089, \underline{1096}, 1126, 1135, 1141. ne: 1088, 1089, \underline{1096}, 1097, 1113, 1135, 1140, 1141. NE SW edge: \underline{435}. negate: \underline{16*} , 64, 103, 107, 110, 114, 118, 139, 146,

380, 409, 411, 412, 414, 415, 416, 418, 423, 424, 425, 480, 882, 903, 904, 930, 959, 1007, 1068.

negate dep list : 903, \underline{904}, 930, 959. negate edges : \underline{344}, 345, 903, 929. negate x : \underline{139}, 390, 406, 409, 411, 418, 480, 489. negate y : \underline{139}, 390, 406, 414, 415, 418, 437, 438,

439, 480, 489. negative: \underline{107}, \underline{109}, 110, \underline{112}, \underline{114}. : 184. new boundary : \underline{451}, 452, 458. new dep: \underline{606}, 615, 829, 856, 858, 947, 969, 972. new if limit : \underline{748}. new indep: \underline{585}, 586, 816, 855. new internal : \underline{186}, 211, 212, 1033. newinternal primitive: \underline{211}. new knot : 870, \underline{871}, 885, 908. new num tok : \underline{215}, 236, 860. new randoms : 148, \underline{149}, 150. new ring entry : \underline{619}, 855. new root : \underline{234}, 242, 1011. new row 0 : 1144, \underline{1145}, 1173. new row 1 : \underline{1144}. new row 164 : \underline{1144}, 1145. new string : \underline{54}, 57, 58, 840, 912, 1163* , 1164, 1200* . new structure: \underline{239}, 243. next : \underline{200}, 202, 205, 207. next a: \underline{426}, \underline{440}, 446. next char : \underline{1093}, 1107, 1112, 1137. next random: \underline{149}, 151, 152. nh: 1088, 1089, \underline{1096}, 1126, 1135, 1141. ni : 1088, 1089, \underline{1096}, 1126, 1135, 1141. nice pair : \underline{899}, 900, 907, 915, 941, 975, 983, 1072. nil: 16* . ninety deg : \underline{106}, 141, 530. nk : 1088, 1089, \underline{1096}, 1097, 1112, 1135, 1139, 1141. nl : \underline{329}, 330, 1088, 1089, 1093, \underline{1096}, 1097, 1107,

1110, 1111, 1112, 1135, 1137, 1139, 1141. nn: \underline{562}. No: 9* . : 713. : 372. no crossing : \underline{391}, 392. no op: \underline{1144}, 1147. no print : \underline{54}, 57, 58, 70, 93. no tag : \underline{1092}, 1096, 1097, 1104. node size: \underline{166}, 168, 169* , 170, 172, 176, 182* ,

1194, 1195, 1207. node to round : 426, \underline{427}, 429, 436, 439, 444,

445, 446. : 218. nonlinear eq : \underline{621}, 1003. : 830. nonstop mode: \underline{68}, 81, 679, 682, 897, 1024, 1025. nonstopmode primitive: \underline{1024}. norm rand : \underline{152}, 895. normal : \underline{659}, 660, 661, 694, 697, 730, 738, 739,

742, 758, 991, 1016. normal deviate: \underline{189}, 893, 895. normaldeviate primitive: \underline{893}. normalize selector : 73, \underline{87}, 88, 89, 90. north edge: \underline{435}, 438. north south edge: \underline{435}. : 1067. : 716, 1082. : 1060. : 901, 923. not primitive: \underline{893}. not found : \underline{15}, 45, 394, 477, 479, 491, 494, 496,

539, 541, 556, 560, 561, 760, 1001, 1004, 1059, 1064, 1067, 1071, 1073, 1074, 1075.

not op: \underline{189}, 893, 905. nothing printed : \underline{473}, 474. np: 1088, 1089, \underline{1096}, 1097, 1115, 1135, 1140, 1141. nr : \underline{329}, 331. nuline: \underline{197}, \underline{257}, \underline{332}, \underline{473}. null : \underline{158}, 159, 161, 163, 165, 167, 168, 176, 177,

181, 182* , 202, 214, 216, 217, 226, 227, 229, 232, 233, 234, 235, 237, 242, 246, 249, 251, 252, 253, 254, 257, 258, 324, 346, 355, 364, 368, 398, 472, 475, 477, 479, 487, 528, 532, 536, 537, 587, 589, 591, 594, 597, 599, 600, 604, 605, 607, 609, 611, 612, 614, 615, 616, 617, 618, 619, 620, 632, 636, 638, 639, 640, 650, 651, 652, 665, 676, 685, 686, 694, 697, 698, 700, 707, 712, 713, 714, 716, 718, 719, 720, 721, 722, 723, 724, 726, 728, 730, 734, 735, 736, 738, 739, 746, 752, 753, 754, 755, 760, 762, 763, 764, 795, 801, 802, 805, 806, 807, 810, 811, 812, 816, 818, 819, 840, 844, 845, 848, 850, 851, 852, 853, 854, 857, 902, 904, 924, 925, 926, 927, 928, 929, 930, 931, 933, 934, 935, 936, 942, 943, 944, 945, 948, 949, 968, 970, 972, 997, 998, 1000, 1003, 1006, 1007, 1008, 1009, 1010, 1011, 1015, 1035, 1040, 1041, 1043, 1048, 1049, 1050, 1057, 1061, 1064, 1068, 1070, 1071, 1074, 1194, 1195, 1207, 1209, 1213.

null coords : \underline{175}, 214, 475. null pen: \underline{175}, 435, 438, 442, 475, 477, 487, 865,

895, 917, 962, 1062. nullpen primitive: \underline{893}. null pen code: \underline{189}, 893, 895. nullpicture primitive: \underline{893}. null picture code: \underline{189}, 893, 895. null tally : \underline{217}. nullary : \underline{186}, 713, 823, 893, 894, 895. num: \underline{116}, \underline{296}, \underline{836}, 837. numspecial primitive: \underline{1176}. : 914. numeric primitive: \underline{1013}. numeric token: \underline{186}, 651, 675, 678, 823, 824, 836,

837, 844, 846, 860, 861, 1016, 1042. numeric type: \underline{187}, 189, 229, 242, 248, 585, 798,

802, 809, 855, 918, 1013. nw : 1088, 1089, \underline{1096}, 1124, 1135, 1141. NW SE edge: \underline{435}. n0 : \underline{373}, \underline{374}, 375, 376, 377, \underline{378}, 380, 382, 383,

384, \underline{464}, 465, 467, 468, 508, 513, 515, 517, 519, 521, 523.

n1 : \underline{373}, \underline{374}, 375, 376, \underline{378}, 380, 463, \underline{464}, 465,

467, 468, 508, 513, 517, 519, 523. o: \underline{210}, \underline{431}, \underline{477}. obliterated : \underline{851}, 852, 1000, 1057. oct primitive: \underline{893}. oct op: \underline{189}, 893, 912, 913, 914. octant : \underline{139}, 141, \underline{379}, 380, \underline{387}, \underline{388}, \underline{394}, 434,

437, \underline{451}, 463, 465, 468, 473, 479, 480, 481, 484, 485, \underline{488}, 489, 506, 508, 509, 510, 512, 513, 515, 516, 518, 519, 521, 522.

octant after : \underline{390}. octant before: \underline{390}. octant code: \underline{448}, 449, 458, 473, 481, 484. octant dir : 394, \underline{395}, 396, 398, 401, 509. octant number : \underline{448}, 449, 452, 459, 479, 488,

508, 512. octant subdivide: 402, \underline{419}. odd : 62, 111, 113, 145, 390, 417, 434, 435, 436,

442, 445, 459, 473, 482, 483, 484, 488, 508, 512, 530, 560, 906.

odd primitive: \underline{893}. odd op: \underline{189}, 893, 906. of primitive: \underline{211}. of macro: \underline{226}, 227, 705, 733. of token: \underline{186}, 211, 212, 705, 734, 839. off base: \underline{1187}, 1189* , 1191* , 1195, 1199* . offset prep: \underline{491}, 494, 500, 506. : 1051. OK to interrupt : 83, \underline{91}, 92, 93, 653, 825. old exp: \underline{922}, 925, 927, \underline{944}. old p: \underline{922}, 925, 926. old rover : \underline{173}. old setting : 195, \underline{196}, \underline{635}, 636, \underline{788*} , 840, 912,

1022, 1163* , 1164. one byte: \underline{1161}. one crossing : \underline{391}. one eighty deg : \underline{106}, 139, 141, 292, 544. oo: \underline{477}, 479. op byte: \underline{1093}, 1107, 1112, 1137. op defining : \underline{659}, 664, 665, 694, 700. open: \underline{256}, 258, 262, 263, 271, 272, 273, 280, 282,

284, 285, 865, 868, 870, 874, 875, 877, 879, 885, 887, 888, 889, 890, 891, 896.

: 258, 262. open a window : \underline{574}, 1073. open base file: \underline{779*} , 1211. open log file: 73, 87, 679, \underline{788*} , 789, 791, 793* ,

895, 1134, 1209. open parens : \underline{631}, 657, 681, 793* , 1209. open window : \underline{186}, 211, 212, 1069. openwindow primitive: \underline{211}. or primitive: \underline{893}. or op: \underline{189}, 893, 940. ord : 20. oriental characters: 1147. othercases: \underline{10}. others : 10. : 1204* . : 617. outer primitive: \underline{1027}. outer tag : \underline{186}, 242, 249, 254, 668, 759, 850,

1029, 1041. output : \underline{4}. : 1182. output file name: \underline{791}, 792, 1163* , 1182. over : \underline{189}, 837, 893, 948. overflow : 34, 41, 44, \underline{89}, 163, 167, 207, 281,

356, 429, 468, 481, 508, 647, 654, 704, 705, 717, 736, 737, 772, 1036, 1107, 1112, 1113, 1114, 1115, 1205* .

Overflow in arithmetic: 9* . o1 : 452, \underline{453}, 458, 459. o2 : 452, \underline{453}, 458, 459. p: \underline{107}, \underline{109}, \underline{112}, \underline{114}, \underline{163}, \underline{167}, \underline{172}, \underline{173}, \underline{177}, \underline{180},

\underline{185}, \underline{205}, \underline{215}, \underline{216}, \underline{217}, \underline{226}, \underline{227}, \underline{232}, \underline{233}, \underline{234}, \underline{235}, \underline{238}, \underline{239}, \underline{242}, \underline{246}, \underline{247}, \underline{248}, \underline{249}, \underline{252}, \underline{253}, \underline{254}, \underline{257}, \underline{264}, \underline{265}, \underline{266}, \underline{268}, \underline{269}, \underline{284}, \underline{299}, \underline{328}, \underline{329}, \underline{332}, \underline{334}, \underline{336}, \underline{337}, \underline{340}, \underline{342}, \underline{344}, \underline{346}, \underline{348}, \underline{354}, \underline{366}, \underline{369}, \underline{374}, \underline{378}, \underline{385}, \underline{394}, \underline{398}, \underline{402}, \underline{405}, \underline{406}, \underline{410}, \underline{419}, \underline{429}, \underline{433}, \underline{440}, \underline{451}, \underline{465}, \underline{473}, \underline{477}, \underline{484}, \underline{486}, \underline{487}, \underline{488}, \underline{491}, \underline{493}, \underline{497}, \underline{506}, \underline{510}, \underline{518}, \underline{527}, \underline{539}, \underline{556}, \underline{562}, \underline{577}, \underline{589}, \underline{591}, \underline{594}, \underline{597}, \underline{599}, \underline{600}, \underline{601}, \underline{603}, \underline{604}, \underline{606}, \underline{608}, \underline{609}, \underline{610}, \underline{619}, \underline{620}, \underline{621}, \underline{622}, \underline{641}, \underline{649}, \underline{650}, \underline{651}, \underline{652}, \underline{661}, \underline{685}, \underline{694}, \underline{697}, \underline{707}, \underline{720}, \underline{722}, \underline{730}, \underline{737}, \underline{746}, \underline{748}, \underline{755}, \underline{760}, \underline{763}, \underline{799}, \underline{800}, \underline{801}, \underline{805}, \underline{807}, \underline{809}, \underline{823}, \underline{827}, \underline{848}, \underline{855}, \underline{856}, \underline{858}, \underline{860}, \underline{862}, \underline{863}, \underline{864}, \underline{865}, \underline{868}, \underline{872}, \underline{898}, \underline{899}, \underline{904}, \underline{910}, \underline{916}, \underline{919}, \underline{922}, \underline{923}, \underline{928}, \underline{930}, \underline{935}, \underline{943}, \underline{944}, \underline{946}, \underline{949}, \underline{953}, \underline{961}, \underline{962}, \underline{963}, \underline{966}, \underline{968}, \underline{971}, \underline{972}, \underline{974}, \underline{976}, \underline{977}, \underline{978}, \underline{982}, \underline{984}, \underline{985}, \underline{995}, \underline{996}, \underline{1001}, \underline{1006}, \underline{1015}, \underline{1046}, \underline{1050}, \underline{1057}, \underline{1059}, \underline{1072}, \underline{1117}, \underline{1118}, \underline{1121*} , \underline{1165}, \underline{1186}, \underline{1187}, \underline{1205*} .

p over v : \underline{600}, 819, 932, 949.
p plus fq : 592, \underline{594}, 597, 601, 818, 819, 932,

968, 971, 1010. p plus q : \underline{597}, 932, 1010. p times v : \underline{599}, 943, 969. p with x becoming q : \underline{601}, 614. pack buffered name: \underline{778}, 779* . pack cur name: \underline{784}, 786, 793* . pack file name: \underline{774}, 784, 793* . pack job name: \underline{784}, 788* , 791, 1134, 1200* . packed ASCII code: \underline{37}, 38. page: \underline{631}. page stack : \underline{631}. paint row : 564* , 566, 568* , 569, 571, 578, 579. paint switch: \underline{1143}, 1144. paint 0 : 1144, \underline{1145}, 1159. paint1 : 1144, \underline{1145}, 1159. paint2 : \underline{1144}. paint3 : \underline{1144}. pair primitive: \underline{1013}. pair node size: \underline{230}, 231. pair to path: \underline{908}, 921, 975, 983, 988, 1003, 1062. pair type: \underline{187}, 216, 230, 231, 232, 248, 798, 799, 800, 802, 808, 809, 830, 837, 855, 868, 870, 872, 877, 898, 899, 900, 903, 909, 917, 918, 919, 921, 926, 927, 929, 936, 941, 942, 944, 946, 948, 952, 957, 975, 982, 983, 988, 995, 1001, 1002, 1003, 1013, 1062.

pair value: \underline{982}, 984, 987, 988.

panicking : \underline{178*} , 179, 825, 1213.
param: 1090, 1095, \underline{1096}, 1106, 1115, 1140.
param ptr : \underline{633}, 649, 650, 657, 736, 737.
param size: \underline{12*} , 214, 633, 677, 697, 704, 705,

736, 737, 1208. param stack : 632, \underline{633}, 639, 640, 650, 676, 677,

720, 736, 737. param start : \underline{632}, 639, 640, 649, 650, 676, 677. param type: \underline{186}, 227, 695, 696, 697, 703. parameter : \underline{632}, 638, 677. parent : \underline{229}, 236, 239, 240, 241, 245. Pascal-H: \underline{3}. Pascal: 1, 10. pass text : 706, \underline{742}, 749, 751. : 257. path primitive: \underline{1013}. path intersection: \underline{562}, 988. path join: \underline{186}, 211, 212, 874, 881, 886, 887. path length: 915, \underline{916}, 978. path size: \underline{11*} , 279, 280, 281, 283, 284. path tail : 266, \underline{267}, 1065. path trans : 952, \underline{962}. path type: \underline{187}, 216, 248, 621, 798, 802, 804,

808, 809, 855, 868, 870, 885, 891, 908, 915, 917, 918, 919, 920, 921, 952, 975, 983, 988, 1003, 1013, 1062.

: 887. pause for instructions : 91, \underline{93}. pausing : \underline{190}, 192, 193, 682. pausing primitive: \underline{192}. pd : \underline{357}, 358, 360. Peirce, Charles Santiago Sanders: 526. : 478. : 865. : 478. pen primitive: \underline{1013}. pen circle: \underline{189}, 893, 895. pencircle primitive: \underline{893}. pen edge: \underline{433}, 435, 438, \underline{440}, 442, 443. pen head : \underline{484}. pen node size: 175, \underline{472}, 477, 487. penoffset primitive: \underline{893}. pen offset of : \underline{189}, 893, 983. pen type: \underline{187}, 216, 248, 621, 798, 802, 804, 808,

809, 855, 865, 895, 918, 919, 921, 952, 962, 983, 1003, 1013, 1052, 1053, 1054, 1055.

percent class : \underline{198}, 199* , 217, 669. period class : \underline{198}, 199* , 669. perturbation: 1118, \underline{1119}, 1120* , 1121* , 1122, 1123,

1124, 1126. phi : 541, \underline{542}, 544. picture primitive: \underline{1013}. picture type: \underline{187}, 216, 248, 621, 798, 802, 804,

808, 809, 855, 895, 898, 903, 918, 919, 921, 929, 952, 1003, 1013, 1057, 1061, 1070.

pixel color : \underline{565}, 566, 580. : 776* , 779* , 1203. : 679, 786. plus : \underline{189}, 859, 893, 898, 922, 930. plus or minus : \underline{186}, 823, 836, 837, 893, 894. pm: \underline{357}, 358, 360. point primitive: \underline{893}. point of : \underline{189}, 893, 983, 987. pointer : \underline{158}, 159, 161, 163, 166, 167, 172, 173,

177, 178* , 180, 185, 200, 205, 215, 216, 225, 226, 227, 232, 233, 234, 235, 238, 239, 242, 246, 247, 248, 249, 250, 252, 253, 254, 257, 264, 265, 266, 267, 268, 269, 280, 284, 299, 326, 327, 328, 329, 332, 333, 334, 336, 337, 340, 342, 344, 346, 348, 354, 366, 369, 373, 374, 378, 385, 394, 398, 402, 403, 405, 406, 410, 419, 427, 429, 433, 440, 451, 465, 473, 476, 477, 484, 486, 487, 488, 491, 493, 497, 506, 510, 511, 518, 527, 539, 556, 562, 577, 589, 591, 592, 594, 597, 599, 600, 601, 603, 604, 606, 607, 608, 609, 610, 619, 620, 621, 622, 633, 649, 650, 651, 652, 661, 685, 694, 697, 707, 718, 720, 722, 723, 730, 737, 738, 746, 748, 752, 755, 760, 763, 799, 800, 801, 805, 807, 809, 813, 823, 827, 843, 848, 851, 855, 856, 858, 860, 862, 863, 864, 865, 868, 871, 872, 898, 904, 910, 916, 919, 922, 923, 928, 930, 935, 943, 944, 946, 949, 953, 961, 962, 963, 966, 968, 971, 972, 974, 976, 977, 978, 982, 984, 985, 995, 996, 1001, 1006, 1011, 1015, 1031, 1032, 1035, 1046, 1050, 1057, 1059, 1071, 1072, 1074, 1117, 1118, 1121* , 1125, 1165, 1186, 1187, 1205* .

pool file: 47, \underline{50}, 51* , 52* , 53* .

pool name: \underline{11*} , 51* .

pool pointer : \underline{37}, 38, 45, 46, 59, 60, 77, 210, 707,

768* , 774, 913, 976, 1160, 1214* . pool ptr : 37, \underline{38}, 40, 41, 43, 44, 47, 52* , 58, 771* ,

780, 1045, 1163* , 1192, 1193, 1204* . pool size: \underline{11*} , 37, 41, 52* , 58, 780, 1045, 1193, 1208.

pop input : \underline{648}, 650, 655.
post : 1142, 1144, \underline{1145}, 1146, 1148, 1182.
post head : 842, \underline{843}, 844, 845, 851, 852, 854.
post post : 1144, \underline{1145}, 1146, 1148, 1182.
postcontrol primitive: \underline{893}.
postcontrol of : \underline{189}, 893, 983, 987.

pp: \underline{242}, 243, 244, 245, \underline{265}, \underline{266}, \underline{334}, 335, \underline{340}, 341, \underline{366}, 367, 368, \underline{406}, 413, 414, 415, 416, 417, 418, \underline{440}, 444, 445, 446, \underline{556}, 558, \underline{562}, \underline{589}, 590, \underline{594}, 595, \underline{597}, 598, \underline{755}, 765, \underline{809}, 816, \underline{868}, 885, 886, 887, 889, 890, \underline{966}, 970, \underline{978}, 980, 981, \underline{1006}, 1009, 1010.

pre: 1142, 1144, \underline{1145}, 1163* .

pre head : 842, \underline{843}, 844, 850, 851, 852, 853, 854.

precontrol primitive: \underline{893}.
precontrol of : \underline{189}, 893, 983, 987.

prev dep: \underline{587}, 603, 606, 617, 799, 811, 816, 827,

931, 947, 1007. prev m: \underline{1165}, 1169* , 1170, 1171.

prev n: \underline{1165}, 1167, 1172, 1174.
prev r : \underline{610}, 614.
prev w : \underline{348}, 349, 350, \underline{1165}, 1169* , 1170, 1171.
primary primitive: \underline{695}.
primary binary : \underline{186}, 189, 823, 839, 893, 894.

primarydef primitive: \underline{683}. primary macro: \underline{226}, 227, 695, 733. primitive: 192, \underline{210}, 211, 212, 625, 683, 688, 695,

709, 740, 893, 1013, 1018, 1024, 1027, 1037, 1052, 1079, 1101, 1108, 1176, 1203, 1204* .

print : 54, \underline{59}, 60, 61* , 62, 66, 68, 80, 81, 84, 85, 89, 90, 94, 122, 128, 134, 187, 189, 197, 212, 217, 218, 219, 221, 222, 223, 227, 235, 237, 254, 257, 258, 259, 260, 261, 262, 263, 332, 372, 394, 397, 398, 401, 509, 510, 515, 521, 589, 613, 625, 638, 639, 643, 644, 663, 664, 665, 682, 684, 689, 696, 710, 721, 722, 723, 725, 734, 741, 750, 754, 773, 786, 788* , 790* , 793* , 802, 804, 805, 807, 817, 824, 832, 839, 851, 900, 902, 923, 924, 945, 997, 998, 999, 1002, 1008, 1019, 1025, 1028, 1032, 1034, 1038, 1041, 1042, 1043, 1045, 1048, 1050, 1053, 1057, 1080, 1098, 1102, 1105, 1109, 1123, 1134, 1139, 1140, 1163* , 1164, 1180, 1182, 1192, 1194, 1196, 1200* , 1205* , 1208, 1209, 1212, 1213.

print arg : 721, \underline{723}, 728, 734. print capsule: 217, 219, \underline{224}, 1042. print char : \underline{58}, 59, 63, 64, 65, 77, 85, 89, 90, 103,

104, 157, 184, 185, 189, 197, 209, 212, 219, 220, 221, 222, 223, 224, 227, 237, 254, 259, 263, 332, 333, 372, 373, 394, 398, 401, 509, 589, 590, 602, 603, 613, 626, 637, 643, 681, 689, 725, 762, 790* , 793* , 802, 803, 806, 817, 824, 900, 902, 914, 924, 945, 990, 998, 1002, 1008, 1022, 1041, 1042, 1045, 1046, 1050, 1057, 1134, 1163* , 1164, 1165, 1182, 1194, 1200* , 1205* , 1213.

print cmd mod : 212, 227, \underline{625}, 626, 751, 824, 839,

990, 1041, 1043, 1209, 1213. print dd : \underline{65}, 790* , 1163* . print dependency : \underline{589}, 613, 805, 817, 1050. print diagnostic: \underline{197}, 257, 332, 372, 394, 473. print dp: 802, 803, \underline{805}. print edges : \underline{332}, 804, 1165. print err : 67, \underline{68}, 88, 89, 90, 93, 94, 99, 122, 128,

134, 140, 270, 340, 342, 398, 404, 478, 602, 623, 661, 663, 670, 672, 675, 691, 701, 703, 708, 712, 713, 725, 726, 751, 786, 795, 807, 824, 832, 838, 851, 865, 887, 914, 963, 965* , 990, 991, 1004, 1008, 1015, 1016, 1017, 1032, 1034, 1051, 1056, 1057, 1067, 1073, 1074, 1086, 1098, 1105, 1107, 1110.

print exp: 224, 639, 723, 762, \underline{801}, 807, 902, 924,

945, 997, 998, 1040, 1046. print file name: \underline{773}, 786. print int : \underline{64}, 89, 103, 157, 181, 182* , 183, 184,

185, 197, 209, 222, 237, 332, 333, 372, 397, 398, 509, 515, 521, 617, 637, 661, 723, 790* , 832, 914, 1045, 1105, 1139, 1140, 1163* , 1164, 1165, 1182,

1192, 1194, 1196, 1200* , 1209, 1213. print known or unknown type: \underline{900}, 901, 923. print ln: \underline{57}, 58, 61* , 62, 66, 81, 84, 85, 86, 157, 195, 257, 394, 473, 638, 643, 656, 665, 679, 682, 721, 788* , 793* , 1023, 1041, 1043, 1045, 1165, 1192, 1194, 1196, 1205* .

print locs : \underline{180}.

print macro name: 721, \underline{722}, 725, 726, 734.

print nl : \underline{62}, 68, 77, 80, 86, 181, 182* , 183, 184, 185, 195, 197, 209, 254, 257, 259, 332, 333, 372, 373, 394, 397, 398, 473, 474, 509, 510, 515, 521, 603, 613, 617, 626, 637, 638, 639, 665, 679, 723, 725, 762, 786, 788* , 807, 817, 902, 924, 945, 994, 997, 998, 1022, 1040, 1041, 1045, 1046, 1048, 1050, 1082, 1123, 1128, 1134, 1139, 1140, 1169* , 1182, 1200* , 1205* , 1209, 1212. print op: \underline{189}, 894, 901, 902, 923, 924.

print path: \underline{257}, 269, 402, 804.
print pen: \underline{473}, 477, 484, 804.

print scaled : \underline{103}, 104, 122, 128, 134, 157, 220, 254, 259, 260, 263, 589, 590, 602, 603, 802, 803, 817, 912, 945, 1008, 1022, 1042, 1123.

print spec: \underline{394}, 402.

print strange: \underline{398}, 399, 1068.
print the digs : \underline{63}, 64.
print two: \underline{104}, 258, 261, 394, 473, 510.
print two true: \underline{394}, 397, 474, 509, 515, 521.

print type: \underline{187}, 189, 802, 804, 806, 900, 1002,

1014, 1057. print variable name: 221, \underline{235}, 589, 603, 613, 664, 802, 803, 806, 817, 1046, 1048, 1050, 1213.

print weight : 332, \underline{333}.

print word : \underline{157}, 1213.
procrustes : \underline{404}.
progression node size: \underline{752}, 763, 765.

prompt file name: \underline{786}, 789, 791, 793* , 1134, 1200* .

prompt input : \underline{66}, 78, 82, 679, 682, 786, 897.

proofing : \underline{190}, 192, 193, 994, 1070, 1147, 1165,

1177. proofing primitive: \underline{192}.

protection command : \underline{186}, 1026, 1027, 1028.

proto dependent : \underline{187}, 216, 248, 588, 589, 594, 597, 599, 601, 603, 610, 612, 798, 799, 800, 802, 808, 809, 812, 813, 815, 817, 818, 819, 855, 857, 903, 932, 943, 949, 968, 969, 971, 972, 1003, 1010.

pseudo: \underline{54}, 57, 58, 642. psi : \underline{279}, 281, 290, 294, 297. push input : \underline{647}, 649, 654. put : 25, 28. put get error : 270, 340, 342, 404, 478, 623, \underline{820}, 865, 873, 887, 901, 914, 923, 950, 955, 963, 965* , 993, 999, 1000, 1002, 1004, 1008, 1015, 1016, 1051, 1057, 1067, 1068, 1073, 1074, 1082, 1086, 1098, 1105, 1106, 1178.

put get flush error : 716, 754, \underline{820}, 830, 852, 872, 876, 878, 883, 892, 937, 960, 1021, 1055, 1056, 1060, 1061, 1062, 1071, 1103, 1112, 1115.

pyth add : \underline{124}, 145, 281, 454, 530, 533, 866,

915, 951. pyth sub: \underline{126}, 951. pythag add : \underline{189}, 893, 951. pythag sub: \underline{189}, 893, 951. : 128. q: \underline{107}, \underline{109}, \underline{112}, \underline{114}, \underline{117}, \underline{121}, \underline{145}, \underline{167}, \underline{172}, \underline{173},

\underline{177}, \underline{180}, \underline{185}, \underline{216}, \underline{217}, \underline{227}, \underline{232}, \underline{233}, \underline{235}, \underline{239}, \underline{242}, \underline{246}, \underline{247}, \underline{249}, \underline{252}, \underline{253}, \underline{254}, \underline{257}, \underline{264}, \underline{265}, \underline{266}, \underline{268}, \underline{269}, \underline{284}, \underline{299}, \underline{311}, \underline{328}, \underline{329}, \underline{332}, \underline{333}, \underline{336}, \underline{337}, \underline{340}, \underline{342}, \underline{344}, \underline{346}, \underline{348}, \underline{354}, \underline{366}, \underline{369}, \underline{385}, \underline{394}, \underline{398}, \underline{402}, \underline{405}, \underline{406}, \underline{410}, \underline{419}, \underline{433}, \underline{440}, \underline{451}, \underline{465}, \underline{477}, \underline{491}, \underline{493}, \underline{506}, \underline{518}, \underline{527}, \underline{539}, \underline{556}, \underline{577}, \underline{589}, \underline{594}, \underline{597}, \underline{601}, \underline{603}, \underline{604}, \underline{606}, \underline{608}, \underline{609}, \underline{610}, \underline{619}, \underline{620}, \underline{621}, \underline{622}, \underline{641}, \underline{685}, \underline{694}, \underline{697}, \underline{720}, \underline{722}, \underline{723}, \underline{746}, \underline{755}, \underline{760}, \underline{763}, \underline{801}, \underline{805}, \underline{809}, \underline{823}, \underline{827}, \underline{851}, \underline{855}, \underline{858}, \underline{863}, \underline{865}, \underline{868}, \underline{871}, \underline{898}, \underline{919}, \underline{922}, \underline{928}, \underline{930}, \underline{935}, \underline{943}, \underline{946}, \underline{949}, \underline{953}, \underline{961}, \underline{962}, \underline{966}, \underline{968}, \underline{972}, \underline{978}, \underline{985}, \underline{996}, \underline{1001}, \underline{1006}, \underline{1015}, \underline{1046}, \underline{1059}, \underline{1117}, \underline{1121*} , \underline{1165}, \underline{1186}, \underline{1187}.

qi : \underline{155*} , 1107, 1110, 1111, 1112, 1113, 1137, 1192. qo: \underline{155*} , 1110, 1111, 1133* , 1193. qq : 229, \underline{242}, 245, \underline{265}, \underline{266}, \underline{334}, \underline{366}, 367, 368,

\underline{406}, 413, 414, 415, 416, 417, 418, \underline{556}, 558, \underline{594}, 595, 596, \underline{597}, 598, \underline{868}, 885, 886, 887, 890, \underline{966}, 970, \underline{978}, 980, 981.

qqq : 229. qqqq : 153* , 157. qqq1 : 229. qqq2 : 229. qq1 : 229. qq2 : 229. quad : 1095. quad code: \underline{1095}. quadrant subdivide: 402, \underline{406}, 426. quarter unit : \underline{101}. quarterword : 153* , \underline{156*} , 189, 627, 649, 823, 895,

898, 899, 901, 910, 913, 919, 922, 923, 930, 953, 960, 962, 963, 966, 985.

quote: \underline{688}, 690. quote primitive: \underline{688}. q1 : 229. r: \underline{117}, \underline{124}, \underline{126}, \underline{145}, \underline{167}, \underline{173}, \underline{177}, \underline{180}, \underline{217}, \underline{227},

\underline{233}, \underline{235}, \underline{239}, \underline{242}, \underline{246}, \underline{247}, \underline{268}, \underline{284}, \underline{311}, \underline{332}, \underline{334}, \underline{336}, \underline{337}, \underline{340}, \underline{344}, \underline{346}, \underline{348}, \underline{354}, \underline{366}, \underline{373}, \underline{374}, \underline{378}, \underline{402}, \underline{406}, \underline{410}, \underline{419}, \underline{451}, \underline{465}, \underline{476}, \underline{477}, \underline{491}, \underline{493}, \underline{506}, \underline{518}, \underline{527}, \underline{577}, \underline{594}, \underline{597}, \underline{599}, \underline{600},

\underline{601}, \underline{604}, \underline{606}, \underline{610}, \underline{621}, \underline{622}, \underline{694}, \underline{697}, \underline{720}, \underline{809},
\underline{823}, \underline{855}, \underline{858}, \underline{863}, \underline{868}, \underline{922}, \underline{928}, \underline{930}, \underline{946}, \underline{953},
\underline{966}, \underline{968}, \underline{971}, \underline{1006}, \underline{1104}, \underline{1117}, \underline{1121*} .

r delim: \underline{697}, 703, \underline{720}, 725, 726, 727, 729, \underline{730},

731, 735, \underline{823}, 826, 830, 1031, \underline{1032}. r packet : 560. r packets : \underline{553}, 558. Ramshaw, Lyle Harold: 2* , 469, 1087. random seed : \underline{186}, 211, 212, 1020. randomseed primitive: \underline{211}. randoms : \underline{148}, 149, 150, 151, 152. rd : \underline{357}, 358, 359. read : 52* , 53* , 1212, 1213. read ln: 52* . readstring primitive: \underline{893}. read string op: \underline{189}, 893, 895. ready already : 76* , \underline{1203}, 1204* . real : 3, 120. recursion: 71, 73, 217, 224, 246, 706, 719, 748,

796, 995, 1041. recycle value: 224, 246, 247, 650, 763, 808, \underline{809},

810, 829, 873, 903, 910, 922, 925, 935, 944, 955, 968, 970, 972, 1000, 1001.

reduce angle: \underline{292}, 293. : 623. : 1004. ref count : \underline{226}, 475, 477, 487, 694, 697, 854,

862, 864, 868. reference counts: 42, 226, 632. relax : \underline{186}, 211, 212, 686, 706, 707. rem byte: \underline{1093}, 1107, 1112, 1137. remainder : \underline{1091}, 1092, 1093, 1096. remove cubic: \underline{405}, 417, 447, 492. rep: \underline{1094}. repeat loop: \underline{186}, 706, 707, 759, 1043. reset : 25. restart : \underline{15}, 167, 168, 667, 668, 670, 672, 676,

677, 679, 681, 691, 823, 853, 854, 855, 862, 864, 868, 1001, 1003.

restore cur exp: \underline{801}. result : \underline{45}, \underline{1054}, 1056. resume iteration: 706, 712, 755, \underline{760}, 763. reswitch: \underline{15}, 748. : 510. return: 15, \underline{16*} . return sign: \underline{117}, 118. rev turns : 452, 454, \underline{455}, 456, 1064. reverse: \underline{189}, 893, 921. reverse primitive: \underline{893}. reversed : \underline{977}, \underline{978}. rewrite: 25. rh: 153* , 157, 161, 200. rhs : \underline{1059}, 1062, 1064, 1065, 1066, 1067. Riesenfeld, Richard Franklin: 303. right brace: \underline{186}, 211, 212, 875. right bracket : \underline{186}, 211, 212, 846, 859, 861, 1012. right bracket class : \underline{198}, 199* , 220, 221. right class : \underline{528}, 531, 532, 534, 535. right col : 567* , \underline{572}, 574, 577, 581, 583, 584. right curl : \underline{256}, 263, 271, 282, 294, 890, 891. right delimiter : \underline{186}, 203, 726, 727, 731, 735,

1030, 1031, 1032, 1043. right edge: \underline{580}, 581, 582. right given: \underline{256}, 263, 282, 293, 301, 879, 888, 889. right octant : \underline{393}, 451, 452, 458, 459. right paren class : \underline{198}, 199* , 219, 222. right tension: \underline{256}, 258, 260, 288, 289, 294, 295,

299, 300, 302, 881, 882, 886, 887. right transition: \underline{393}, 459, 509, 517, 523. right type: \underline{255}, 256, 258, 263, 265, 266, 269, 271,

272, 273, 282, 285, 290, 299, 302, 393, 394, 404, 405, 407, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 421, 423, 424, 425, 426, 434, 435, 436, 437, 438, 439, 441, 442, 443, 445, 447, 450, 451, 452, 454, 457, 466, 479, 481, 486, 491, 494, 497, 499, 512, 515, 518, 521, 528, 539, 562, 563, 870, 871, 874, 879, 880, 884, 885, 888, 889, 890, 891, 896, 921, 962, 978, 987, 1065, 1066.

right u: \underline{528}, 531, 532, 534, 535, 537. right x : \underline{255}, 256, 261, 265, 266, 271, 282, 299, 302,

393, 397, 404, 405, 407, 409, 410, 411, 412, 418, 419, 421, 423, 424, 425, 434, 436, 441, 444, 447, 457, 468, 486, 492, 496, 512, 518, 528, 543, 558, 563, 866, 884, 890, 896, 962, 987, 1065, 1066.

right y : \underline{255}, 256, 261, 265, 266, 271, 282, 299, 302, 393, 397, 404, 405, 410, 413, 414, 415, 416, 419, 423, 424, 425, 437, 439, 444, 447, 457, 468, 486, 492, 496, 512, 518, 528, 543, 558, 563, 866, 884, 890, 896, 962, 987, 1065, 1066.

ring delete: \underline{620}, 809. ring merge: \underline{622}, 1003. rising : \underline{497}. rlink : \underline{166}, 167, 168, 169* , 171, 172, 173, 174, 176,

182* , 1194, 1195, 1207. rm: \underline{357}, 358, 359. root : \underline{188}, 229, 230, 234, 239, 254, 702. rotate: 389. rotated primitive: \underline{893}. rotated by : \underline{189}, 893, 952, 957. round decimals : \underline{102}, 103, 674. round fraction: \underline{119}, 590, 600, 817, 819, 906,

958, 1010. round unscaled : \underline{119}, 374, 375, 376, 575, 576, 790* ,

906, 912, 965* , 977, 1056, 1070, 1071, 1073,

1103, 1106, 1137, 1163* , 1165, 1181, 1200* . rover : \underline{166}, 167, 168, 169* , 170, 171, 172, 173, 174,

176, 182* , 1194, 1195, 1207. row node size: \underline{325}, 330, 331, 334, 341, 352, 353,

354, 355, 358, 364, 385. row transition: 578, \underline{579}, 580, 582, 583, 584. rr : \underline{242}, 245, \underline{266}, \underline{299}, 300, \underline{334}, 335, \underline{340}, \underline{366},

368, \underline{922}, 939, \underline{978}, 980. rt : \underline{286}, 289, 294, 295, \underline{299}, 302. runaway : 163, 663, \underline{665}. r0 : \underline{574}, 575, 576, \underline{1073}. r1 : 229, \underline{574}, 575, \underline{1073}. s: \underline{43}, \underline{45}, \underline{46}, \underline{58}, \underline{59}, \underline{60}, \underline{62}, \underline{88}, \underline{89}, \underline{90}, \underline{94}, \underline{103}, \underline{167}, \underline{172}, \underline{197}, \underline{210}, \underline{232}, \underline{242}, \underline{257}, \underline{280}, \underline{284}, \underline{311}, \underline{332}, \underline{337}, \underline{340}, \underline{342}, \underline{344}, \underline{346}, \underline{348}, \underline{354}, \underline{394}, \underline{398}, \underline{402}, \underline{406}, \underline{419}, \underline{465}, \underline{473}, \underline{477}, \underline{488}, \underline{495}, \underline{497}, \underline{506}, \underline{518}, \underline{527}, \underline{594}, \underline{597}, \underline{599}, \underline{600}, \underline{601}, \underline{604}, \underline{610}, \underline{754}, \underline{755}, \underline{784}, \underline{786}, \underline{807}, \underline{809}, \underline{824}, \underline{930}, \underline{943}, \underline{949}, \underline{966}, \underline{977}, \underline{1160}.

s scale: \underline{585}, 589, 608, 610, 817.

safety margin: \underline{402}. save primitive: \underline{211}. save boundary item: \underline{250}, 832. save command : \underline{186}, 211, 212, 1033. save cond ptr : \underline{748}, 749. save exp: \underline{651}, \underline{718}. save flag : \underline{824}. save internal : \underline{253}, 1034. save node size: \underline{250}, 252, 253, 254. save ptr : \underline{250}, 251, 252, 253, 254. save type: \underline{651}. save variable: \underline{252}, 1033. save word : \underline{242}, 244. : 235. saved equiv : \underline{250}, 252, 254. saved root : \underline{188}, 230, 235, 247, 249. saving : \underline{249}. sc: 153* , \underline{156*} , 157, 229, 255, 472, 752, 961. scaled : \underline{101}, 102, 103, 104, 105, 112, 114, 116, 119, 121, 132, 135, 150, 151, 152, 153* , 156* , 187, 190, 194* , 214, 215, 228, 229, 250, 259, 279, 280, 286, 296, 299, 304, 306, 311, 369, 374, 387, 388, 389, 390, 402, 403, 406, 410, 419, 426, 427, 429, 430, 431, 432, 433, 434, 440, 463, 477, 486, 488, 497, 510, 511, 527, 539, 542, 555, 574, 585, 587, 588, 594, 599, 600, 602, 607, 612, 798, 808, 820, 836, 865, 868, 875, 916, 917, 935, 944, 946, 949, 954, 961, 968, 971, 972, 974, 978, 982, 985, 1073, 1096, 1098, 1117, 1118, 1119, 1120* , 1121* , 1128, 1129, 1130, 1144, 1146, 1147, 1182, 1205* .

: 340, 342.

scaled primitive: \underline{893}. scaled by : \underline{189}, 893, 952, 957. scaled threshold : \underline{594}, 597. scaling down: \underline{599}, \underline{600}. scan declared variable: 700, \underline{1011}, 1015. scan def : \underline{697}, 992. scan direction: \underline{875}, 879, 880. scan expression: 706, 729, 733, 734, 764, 765,

796, 798, 821, 826, 830, 839, 846, 859, 861, \underline{868}, 876, 877, 878, 892, 993, 995, 996, 1021, 1040, 1054, 1059, 1070, 1071, 1072, 1073, 1082, 1103, 1106, 1112, 1115, 1177.

scan file name: \underline{781*} , 795. scan primary : 706, 716, 733, 734, 796, 798, 821,

\underline{823}, 835, 837, 839, 842, 862, 882, 884, 893, 1059, 1071, 1074.

scan secondary : 706, 733, 796, 798, 821, \underline{862}, 864. scan suffix : 706, 729, 735, 764, 840, \underline{860}. scan tertiary : 706, 733, 796, 798, 821, \underline{864},

868, 869. scan text arg : 729, \underline{730}, 733. scan tokens : \underline{186}, 211, 212, 706, 707. scantokens primitive: \underline{211}. scan toks : \underline{685}, 694, 698, 758. scan with: \underline{1054}, 1062, 1074. scanner status : \underline{659}, 660, 661, 663, 664, 665, 694,

697, 700, 730, 742, 758, 991, 1016. screen col : \underline{565}, 566, 572, 580. screen depth: \underline{11*} , 565, 567* , 568* , 575. screen OK : \underline{569}, 570, 574, 577. screen pixel : \underline{566}. screen row : \underline{565}, 566, 572. screen started : \underline{569}, 570. screen width: \underline{11*} , 565, 567* , 568* , 575. scroll mode: 66, \underline{68}, 79* , 81, 88, 786, 1024,

1025, 1084. scrollmode primitive: \underline{1024}. search mem: 178* , \underline{185}, 1213. second octant : \underline{139}, 141, 380, 387, 388, 396, 435,

443, 449, 461, 462. secondary primitive: \underline{695}. secondary binary : \underline{186}, 893, 894. secondarydef primitive: \underline{683}. secondary macro: \underline{226}, 227, 695, 696, 733. secondary primary macro: \underline{186}, 249, 683, 684,

862, 1035, 1043. : 1209. seed : \underline{150}. selector : \underline{54}, 55, 57, 58, 62, 66, 70, 81, 86, 87, 93,

195, 635, 636, 642, 679, 788* , 789, 804, 840, 912, 1022, 1023, 1163* , 1164, 1200* , 1205* , 1209.

semicolon: \underline{186}, 211, 212, 713, 732, 832, 989, 990, 991, 1017, 1051, 1070. sentinel : \underline{175}, 177, 324, 328, 330, 331, 332, 335,

339, 343, 344, 345, 346, 347, 348, 349, 355, 356, 358, 364, 367, 368, 369, 582, 1169* .

serial no: \underline{585}, 587, 1198, 1199* . set controls : 297, 298, \underline{299}, 301. set min max : \underline{554}, 558, 559. set output file name: \underline{791}, 1163* . set paths : 1204* . set tag : \underline{1104}, 1106, 1111, 1113. set trick count : \underline{642}, 643, 644, 646. set two: \underline{387}, 388. set two end : \underline{387}. set up direction time: 983, \underline{984}. set up known trans : \underline{960}, 962, 963, 967. set up offset : 983, \underline{984}. set up trans : \underline{953}, 960, 970. seventh octant : \underline{139}, 141, 380, 387, 388, 396, 435,

443, 449, 461, 462. sf : \underline{116}, 297, \underline{298}, 299, 300, 301. shifted primitive: \underline{893}. shifted by : \underline{189}, 893, 952, 957. ship out : 1070, 1149, \underline{1165}, 1175. shipout primitive: \underline{211}. ship out command : \underline{186}, 211, 212, 1069. show primitive: \underline{1037}. show cmd mod : \underline{626}, 713, 895. show code: \underline{1037}, 1038, 1040, 1051. show command : \underline{186}, 1037, 1038, 1039. show context : 54, 73, 77, 83, 634, \underline{635}, 644,

786, 789, 793* . show cur cmd mod : \underline{626}, 707, 832, 992. showdependencies primitive: \underline{1037}. show dependencies code: \underline{1037}, 1051. show macro: \underline{227}, 645, 721, 1041, 1048. showstats primitive: \underline{1037}. show stats code: \underline{1037}, 1038, 1051. showtoken primitive: \underline{1037}. show token code: \underline{1037}, 1038, 1051. show token list : \underline{217}, 224, 227, 235, 639, 640,

645, 646, 665, 722, 723, 762, 840, 851, 998, 1043, 1057, 1213.

showvariable primitive: \underline{1037}. show var code: \underline{1037}, 1038, 1051. showstopping : \underline{190}, 192, 193, 1051. showstopping primitive: \underline{192}. si : \underline{37}, 41, 85, 1193. sind primitive: \underline{893}. sin d op: \underline{189}, 893, 906. sine: \underline{280}, 281, \underline{299}, 300. single dependency : \underline{608}, 829, 855, 858, 1007, 1009. sixth octant : \underline{139}, 141, 379, 380, 387, 388, 395,

396, 443, 448, 449, 461, 462, 488. skew : \underline{387}, 421, 445, 447, 451, 457, 481. skew line edges : 508, \underline{510}, 517, 523. skimp: \underline{1121*} , 1124, 1126. skip byte: \underline{1093}, 1107, 1110, 1111, 1112, 1137. skip error : \underline{1110}, 1111. skip table: \underline{1096}, 1097, 1110, 1111, 1139. skip to: \underline{186}, 211, 212, 1107. skipto primitive: \underline{211}. skipping : \underline{659}, 661, 742. skip0 : 1144, \underline{1145}, 1173. skip1 : 1144, \underline{1145}, 1174. skip2 : \underline{1144}. skip3 : \underline{1144}. slant : 1095. slant code: \underline{1095}. slanted primitive: \underline{893}. slanted by : \underline{189}, 893, 952, 957. slash: \underline{186}, 837, 893, 894. slow add : \underline{100}, 594, 597, 930, 931, 933. slow case down: \underline{378}, 380. slow case up: \underline{378}, 380. slow print : \underline{60}, 219, 802, 994, 1082, 1086. small computers: 95. small number : \underline{101}, 102, 121, 135, 139, 145, 187,

210, 217, 230, 232, 238, 248, 311, 387, 388, 390, 394, 451, 453, 477, 589, 594, 597, 599, 600, 601, 610, 621, 651, 685, 738, 746, 778, 796, 801, 805, 809, 843, 875, 900, 930, 935, 943, 949, 966, 1001, 1015, 1054, 1098, 1104, 1123, 1177, 1209.

smooth bot : \underline{511}, 512, 517, 518, 523. smooth moves : \underline{321}, 468, 517, 523. smooth top: \underline{511}, 512, 517, 518, 523. smoothing : \underline{190}, 192, 193, 468, 517, 523. smoothing primitive: \underline{192}. so: \underline{37}, 45, 59, 60, 85, 210, 223, 717, 774, 913,

976, 977, 1103, 1160, 1192. solve choices : 278, \underline{284}. : 1123. : 1123. : 1123. : 1123. : 270. : 779* . sort avail : \underline{173}, 1194. sort edges : \underline{346}, 348, 354, 578, 1169* . sort in: \underline{1117}, 1124, 1126. sorted : 324, \underline{325}, 328, 330, 331, 332, 335, 339, 343,

344, 345, 346, 347, 348, 349, 355, 356, 358, 364, 367, 368, 369, 385, 580, 582, 1169* .

sorted loc: \underline{325}, 335, 345, 347, 368. south edge: \underline{435}, 438. space: 1095. space class : \underline{198}, 199* , 669. space code: \underline{1095}. space shrink : 1095. space shrink code: \underline{1095}. space stretch: 1095. space stretch code: \underline{1095}. spec atan: \underline{137}, 138, 143, 147. spec head : \underline{506}. spec log : \underline{129}, 131, 133, 136. special primitive: \underline{1176}. special command : \underline{186}, 1175, 1176, 1180. split cubic: \underline{410}, 411, 412, 415, 416, 424, 425,

493, 980, 981, 986. split for offset : \underline{493}, 499, 503, 504. spotless : \underline{71}, 72, 76* , 195, 1204* , 1209. sqrt primitive: \underline{893}. sqrt op: \underline{189}, 893, 906. : 122. square rt : \underline{121}, 122, 906. ss : \underline{242}, 243, 245, \underline{299}, 300, \underline{334}, 335, \underline{340}, \underline{978}, 980. st : \underline{116}, 297, \underline{298}, 299, 300, 301. st count : \underline{200}, 203, 207, 1196, 1197, 1208. stack argument : \underline{737}, 760. stack dx : \underline{553}, 559, 561. stack dy : \underline{553}, 559, 561. stack l : \underline{309}, 312, 314. stack m: \underline{309}, 312, 314. stack max : \underline{553}, 554, 556. stack min: \underline{553}, 554, 556. stack n: \underline{309}, 312, 314. stack r : \underline{309}, 312, 314. stack s : \underline{309}, 312, 314. stack size: \underline{11*} , 628, 634, 647, 1208. stack tol : \underline{553}, 559, 561. stack uv : \underline{553}, 559, 561. stack xy : \underline{553}, 559, 561. stack x1 : \underline{309}, 312, 314. stack x2 : \underline{309}, 312, 314. stack x3 : \underline{309}, 312, 314. stack y1 : \underline{309}, 312, 314. stack y2 : \underline{309}, 312, 314. stack y3 : \underline{309}, 312, 314. stack 1 : \underline{553}, 554, 559, 560. stack 2 : \underline{553}, 554, 559, 560. stack 3 : \underline{553}, 554, 559, 560. start : 627, \underline{629}, 630, 632, 644, 645, 649, 650, 654,

655, 657, 679, 681, 682, 714, 717, 794, 897. start decimal token: \underline{667}, 669. start def : \underline{683}, 684, 697, 698, 700. start field : \underline{627}, 629. start forever : \underline{683}, 684, 755. start here: 5, \underline{1204*} . start input : 706, 709, 711, \underline{793*} , 1211. start numeric token: \underline{667}, 669. start of MF : \underline{6}, 1204* . start screen: \underline{570}, 574. start sym: 1076, \underline{1077}, 1078, 1198, 1199* , 1204* . stash cur exp: 651, 718, 728, 734, 760, 764, \underline{799},

800, 801, 837, 839, 848, 859, 862, 863, 864, 868, 926, 946, 955, 970, 988, 995, 1000.

stash in: \underline{827}, 830, 903. stat: \underline{7*} , \underline{160}, \underline{163}, \underline{164}, \underline{165}, \underline{167}, \underline{172}, \underline{177}, \underline{207},

\underline{508}, \underline{510}, \underline{515}, \underline{521}, \underline{1045}, \underline{1134}, \underline{1205*} . state: 670. stdin: 31* . stdout : 31* . step primitive: \underline{211}. step size: \underline{752}, 760, 761, 765. step token: \underline{186}, 211, 212, 764. Stern, Moriz Abraham: 526. Stolfi, Jorge: 469. stop: \underline{186}, 732, 991, 1017, 1018, 1019. stop flag : \underline{1093}, 1107, 1110. stop iteration: 706, 714, 760, \underline{763}. store base file: \underline{1186}, 1209. str primitive: \underline{211}. str eq buf : \underline{45}, 205. str number : \underline{37}, 38, 42, 43, 44, 45, 46, 47, 62, 74,

88, 89, 90, 94, 190, 197, 210, 214, 257, 332, 394, 395, 398, 473, 754, 767, 774, 780, 782, 784, 785, 786, 791, 807, 824, 976, 977, 1087, 1160, 1183.

str op: \underline{186}, 211, 212, 823. str pool : 37, \underline{38}, 41, 44, 45, 46, 47, 59, 60, 85, 200,

210, 223, 630, 707, 717, 774, 913, 976, 977, 1103, 1160, 1192, 1193, 1205* , 1208, 1215* .

str ptr : 37, \underline{38}, 40, 43, 44, 47, 59, 60, 210, 218, 772, 780, 798, 1045, 1163* , 1192, 1193, 1199* , 1200* , 1204* .

str ref : \underline{42}, 43, 44, 48, 52* , 207, 793* , 1193, 1200* . str room: \underline{41}, 207, 671, 771* , 780, 897, 912, 976,

977, 1200* , 1205* . str start : 37, \underline{38}, 39, 40, 43, 44, 45, 46, 47, 59, 60,

79* , 85, 200, 210, 223, 717, 772, 774, 913, 976, 977, 1103, 1160, 1163* , 1192, 1193.

str to num: 912, \underline{913}. str vs str : \underline{46}, 936, 1004. : 1068. : 914. string pool: 47, 1191* . string primitive: \underline{1013}. string class : \underline{198}, 199* , 219, 669. string token: \underline{186}, 671, 678, 691, 743, 823. string type: \underline{187}, 189, 214, 216, 219, 248, 621, 651,

716, 798, 802, 808, 809, 833, 840, 855, 895, 897, 912, 915, 918, 919, 936, 975, 993, 1003, 1004, 1013, 1082, 1103, 1176, 1177.

string vacancies : \underline{11*} , 52* .

strlen: 51* .

structured : \underline{187}, 188, 228, 229, 239, 242, 243,

246, 247, 809, 850, 1046. structured root : \underline{188}, 229, 236, 239.

subpath primitive: \underline{893}.
subpath of : \underline{189}, 893, 975.

subscr : \underline{188}, 229, 236, 239, 244, 246, 247, 1047. subscr head : \underline{228}, 229, 239, 240, 244, 246, 247,

1047. subscr head loc: \underline{228}, 240, 241, 244, 246. subscr node size: \underline{229}, 240, 244, 246, 247. subscript : \underline{229}, 236, 240, 244. subscript loc: \underline{229}, 244. subst list : \underline{685}, 686. substring primitive: \underline{893}. substring of : \underline{189}, 893, 975. succumb: \underline{88}, 89, 90. : 222. suffix primitive: \underline{695}. suffix base: \underline{214}, 222, 676, 677, 683, 690, 695, 696,

697, 705, 726, 729, 755, 764. suffix count : \underline{685}, 690.

suffix macro: \underline{226}, 227, 705, 733.
suffixed macro: \underline{187}, 700, 798, 809, 845, 1048.
sum: \underline{378}.
switch: \underline{667}, 669, 670, 672.
switch x and y : \underline{139}, 406, 423, 424, 441, 442,

445, 480, 489. sx : \underline{601}.

symmetric: \underline{527}, 528, 530.

system dependencies: 2* , \underline{3}, 4, 9* , 10, 11* , 12* , 19* , 21, 22* , 25, 31* , 33* , 34, 36* , 49, 56, 59, 67, 76* , 79* , 91, 107, 109, 153* , 155* , 156* , 194* , 199* , 564* , 567* , 568* , 631, 637, 654, 766, 767, 768* , 769* , 770, 771* , 772, 773, 774, 775* , 776* , 778, 780, 781* , 794, 1148, 1152, 1154* , 1203, 1204* , 1205* , 1212, 1214* .

s1 : \underline{77}, 83.

s2 : \underline{77}, 83.
s3 : \underline{77}, 83.

t: \underline{46}, \underline{116}, \underline{139}, \underline{145}, \underline{167}, \underline{187}, \underline{197}, \underline{238}, \underline{242}, \underline{246}, \underline{280}, \underline{284}, \underline{311}, \underline{321}, \underline{340}, \underline{342}, \underline{344}, \underline{398}, \underline{406}, \underline{410}, \underline{419}, \underline{493}, \underline{495}, \underline{497}, \underline{542}, \underline{589}, \underline{594}, \underline{597}, \underline{601}, \underline{603}, \underline{604}, \underline{610}, \underline{621}, \underline{649}, \underline{801}, \underline{805}, \underline{809}, \underline{843}, \underline{855}, \underline{860}, \underline{868}, \underline{875}, \underline{899}, \underline{900}, \underline{930}, \underline{935}, \underline{943}, \underline{949}, \underline{968}, \underline{972}, \underline{974}, \underline{1001}, \underline{1006}, \underline{1011}, \underline{1015}, \underline{1029}, \underline{1054}, \underline{1057}, \underline{1104}, \underline{1160}, \underline{1163*} .

t of the way : \underline{410}, 411, 415, 424, 499, 503,

504, 547, 548. t of the way end : \underline{410}. t open in: 32* , 36* . t open out : \underline{32*} , 1204* . tab: \underline{22*} , 199* , 771* , 781* , 787* . tag : \underline{1091}, 1092. tag token: \underline{186}, 202, 234, 242, 249, 254, 702, 823,

844, 850, 860, 1011, 1035, 1043, 1049. tail : \underline{720}, 724, 728, 734, 842, \underline{843}, 844, 845. tail end : \underline{685}. take fraction: \underline{109}, 112, 116, 125, 127, 151, 152,

281, 287, 288, 289, 290, 291, 294, 295, 296, 297, 299, 300, 302, 375, 376, 410, 436, 439, 444, 454, 498, 516, 522, 530, 533, 543, 594, 595, 596, 599, 943, 944.

take part : 909, \underline{910}, 939. take scaled : \underline{112}, 594, 595, 596, 599, 942, 943,

961, 968, 971, 974. tally : \underline{54}, 55, 57, 58, 217, 227, 235, 636, 639,

640, 641, 642, 643. tarnished : 926, 927, \underline{928}, 944. tats: \underline{7*} . temp head : \underline{175}, 335, 346, 347, 349, 351, 484,

594, 597, 599, 600, 601, 612, 616, 1117, 1118, 1121* , 1124, 1126.

temp val : \underline{175}, 910, 911. tension: \underline{186}, 211, 212, 881. tension primitive: \underline{211}. term and log : \underline{54}, 57, 58, 66, 70, 87, 195, 788* ,

804, 1200* , 1209. term in: \underline{31*} , 35, 36* , 66, 1212, 1213. term input : \underline{66}, 73. term offset : \underline{54}, 55, 57, 58, 61* , 62, 66, 793* , 1165. term only : \underline{54}, 55, 57, 58, 66, 70, 87, 789, 804,

1205* , 1209. term out : \underline{31*} , 33* , 34, 35, 36* , 51* , 56. terminal input : \underline{631}, 637, 654, 656. terminator : \underline{685}. tertiary primitive: \underline{695}. tertiary binary : \underline{186}, 893, 894. tertiarydef primitive: \underline{683}. tertiary macro: \underline{226}, 227, 695, 733. tertiary secondary macro: \underline{186}, 249, 683, 684,

864, 1035, 1043. test known: 918, \underline{919}. text : \underline{200}, 202, 203, 205, 206, 207, 210, 218, 254,

638, 664, 722, 725, 727, 735, 759, 1032, 1034, 1036, 1041, 1043, 1196.

: 222. : 670. text primitive: \underline{695}. text base: \underline{214}, 222, 677, 695, 697, 723, 729. text char : \underline{19*} , 20, 47. text macro: \underline{226}, 227, 697, 705, 723, 733. files: 1087. tfm changed : 1129, \underline{1130}, 1132, 1136, 1140. tfm check : \underline{1098}, 1099. tfm command : \underline{186}, 1100, 1101, 1102. tfm depth: \underline{1096}, 1097, 1099, 1126, 1136. tfm file: \underline{1087}, 1133* , 1134. tfm four : \underline{1133*} , 1136, 1139, 1140. tfm height : \underline{1096}, 1097, 1099, 1126, 1136. tfm ital corr : \underline{1096}, 1097, 1099, 1126, 1136. tfm out : \underline{1133*} , 1135, 1136, 1139. tfm qqqq : \underline{1133*} , 1139, 1140. tfm two: \underline{1133*} , 1135, 1139. tfm warning : \underline{1123}, 1124, 1126. tfm width: \underline{1096}, 1097, 1099, 1124, 1131, 1132,

1136, 1182, 1205* . : 77. : 963. : 1032. : 1034. : 1169* . theta: \underline{283}, 291, 292, 295, 297, \underline{527}, 530, 533,

\underline{542}, 544, \underline{865}, 866. thing to add : \underline{186}, 1052, 1053, 1059. third octant : \underline{139}, 141, 379, 380, 387, 388, 393,

396, 406, 443, 449, 461, 462. : 90.

: 107, 114. copy: 855. dep: 589. endinput: 655. exp: 802. if: 746. m: 311. recycle: 809. struct: 239. token: 216. var: 236. xy: 362. 0: 378.

: 701.

three: \underline{101}, 296.

three bytes : \underline{1128}, 1129, 1157, 1182.

three choices : \underline{156*} .

three l : \underline{557}, 558, 559, 560, 561. three quarter unit : \underline{101}, 883. three sixty deg : \underline{106}, 145, 292. three sixty units : \underline{906}, 958. threshold : \underline{594}, 595, 596, \underline{597}, 598, \underline{599}, \underline{600}, 1120* . threshold fn: \underline{1120*} , 1121* . time: \underline{190}, 192, 193, 194* , 790* , 1163* , 1211. time primitive: \underline{192}. time to go: \underline{555}, 556. times : \underline{189}, 837, 859, 893, 941, 944. tini: \underline{8*} . to primitive: \underline{211}. to token: \underline{186}, 211, 212, 1073. toint : 169* , 965* , 1169* . token: 214. token: \underline{188}, 214, 215, 219, 651, 678. token list : \underline{187}, 670, 726, 728, 730, 798, 799, 809,

841, 852, 860, 996, 1059, 1070, 1071, 1074. token node size: \underline{214}, 215, 216, 651, 694, 704,

705, 755. token recycle: 216, \underline{224}. token state: \underline{632}, 652, 672, 712, 736, 795. token type: \underline{632}, 635, 636, 638, 645, 649, 650,

653, 714. tol : 552, 553, 556, \underline{557}, 558, 559, 560, 561. tol step: \underline{552}, 557, 559, 561, 562. : 965* . : 1110. : 725. too small : \underline{1187}, 1189* . top: \underline{1094}. top row : 567* , \underline{572}, 574, 577. toss edges : \underline{385}, 808, 809, 964. toss knot list : \underline{268}, 465, 506, 808, 809, 865, 921,

978, 1064, 1067. toss pen: 475, \underline{487}. total chars : \underline{1149}, 1150, 1165, 1182. total weight : \underline{369}, 921. totalweight primitive: \underline{893}. total weight op: \underline{189}, 893, 921. trace a corner : \underline{372}, 373. trace new edge: \underline{373}, 375, 376, 381, 382, 383, 384. trace x : \underline{371}, 372, 373. trace y : \underline{371}, 372, 373. trace yy : \underline{371}, 372, 373. tracing : \underline{402}. tracing capsules : \underline{190}, 192, 193, 238. tracingcapsules primitive: \underline{192}. tracing choices : \underline{190}, 192, 193, 269. tracingchoices primitive: \underline{192}. tracing commands : \underline{190}, 192, 193, 707, 713, 748,

760, 832, 895, 898, 922, 944, 992, 995, 996. tracingcommands primitive: \underline{192}. tracing edges : \underline{190}, 192, 193, 371, 375, 376, 381,

382, 383, 384, 465, 506, 508, 510, 515, 521. tracingedges primitive: \underline{192}. tracing equations : \underline{190}, 192, 193, 603, 610, 816. tracingequations primitive: \underline{192}. tracing macros : \underline{190}, 192, 193, 720, 728, 734. tracingmacros primitive: \underline{192}. tracing online: \underline{190}, 192, 193, 195, 804. tracingonline primitive: \underline{192}. tracing output : \underline{190}, 192, 193, 1165. tracingoutput primitive: \underline{192}. tracing pens : \underline{190}, 192, 193, 253, 477. tracingpens primitive: \underline{192}. tracing restores : \underline{190}, 192, 193, 254. tracingrestores primitive: \underline{192}. tracing specs : \underline{190}, 192, 193, 1064. tracingspecs primitive: \underline{192}. tracing stats : 160, \underline{190}, 192, 193, 1134, 1198, 1205* . tracingstats primitive: \underline{192}. tracing titles : \underline{190}, 192, 193, 994. tracingtitles primitive: \underline{192}. trans : \underline{961}, 962. trans spec: \underline{565}, 579. : 1205* . : 960. transform primitive: \underline{1013}. transform node size: \underline{230}, 231, 233, 956. transform type: \underline{187}, 216, 230, 231, 232, 233, 248, 798, 799, 800, 802, 808, 809, 855, 909, 918, 919, 926, 927, 936, 944, 952, 953, 955, 967, 970, 973, 1003, 1013, 1015.

transformed primitive: \underline{893}.

transformed by : \underline{189}, 893, 952, 953, 957.

: 515, 521. trick buf : \underline{54}, 58, 641, 643. trick count : \underline{54}, 58, 641, 642, 643. trivial knot : 484, 485, \underline{486}. true: 4, 16* , 30* , 36* , 45, 49, 51* , 53* , 66, 72, 83, 92, 93, 97, 100, 107, 109, 110, 112, 114, 124, 126, 135, 181, 182* , 238, 257, 269, 332, 372, 394, 402, 404, 407, 426, 446, 452, 454, 455, 473, 477, 497, 503, 504, 530, 564* , 569, 570, 574, 577, 592, 593, 595, 596, 598, 599, 600, 621, 653, 654, 661, 670, 672, 675, 680, 681, 700, 711, 767, 771* , 779* , 788* , 801, 886, 899, 913, 942, 946, 968, 969, 977, 978, 1003, 1009, 1010, 1054, 1056, 1064, 1072, 1086, 1099, 1112, 1137, 1165, 1187.

true primitive: \underline{893}.

true code: \underline{189}, 713, 748, 750, 798, 802, 892, 893,

895, 905, 906, 918, 919, 920, 940. try eq : 1003, 1005, \underline{1006}. tt : \underline{167}, 169* , \underline{539}, 541, 547, 548, \underline{594}, 595, 596, 842, \underline{843}, 844, 845, 850, \underline{1006}, 1009, 1010.

turning check : \underline{190}, 192, 193, 1068.
turningcheck primitive: \underline{192}.
turning number : \underline{403}, 450, 459, 917, 1068.
turningnumber primitive: \underline{893}.
turning op: \underline{189}, 893, 917.
two: \underline{101}, 102, 256, 294, 295, 556, 895, 898,

922, 944, 995, 996. two choices : \underline{156*} . two halves : 161, 166, 185, 201. two to the: \underline{129}, 131, 133, 136, 143, 147, 314,

317, 608, 616. tx : \underline{374}, 375, 376, \underline{511}, 516, 522, 866, 867, 953,

\underline{954}, 956, 960, 961, 962, 965* , 967, 973. txx : 866, 953, \underline{954}, 956, 960, 961, 963, 964,

967, 973. txy : 866, 953, \underline{954}, 956, 960, 961, 963, 967, 973. ty : \underline{511}, 516, 522, 866, 867, 953, \underline{954}, 956, 960,

961, 962, 965* , 967, 973. type: \underline{4}, 188, \underline{214}, 215, 216, 219, 228, 229, 232, 233,

234, 239, 242, 243, 244, 245, 246, 247, 248, 585, 587, 589, 595, 596, 598, 599, 600, 603, 604, 605, 614, 615, 619, 621, 651, 678, 700, 738, 744, 745, 746, 799, 800, 801, 803, 809, 812, 819, 827, 829, 830, 842, 850, 855, 856, 857, 858, 868, 873, 899, 903, 910, 919, 923, 926, 928, 929, 930, 931, 932, 935, 936, 939, 940, 941, 942, 943, 946, 947, 948, 949, 951, 952, 956, 957, 959, 966, 968, 969, 971, 972, 975, 982, 983, 988, 995, 1000, 1001, 1002, 1006, 1007, 1009, 1015, 1046, 1048, 1050, 1057.

: 80. type name: \underline{186}, 823, 989, 992, 1013, 1014, 1015. type range: \underline{918}. type range end : \underline{918}. type test : \underline{918}. type test end : \underline{918}. tyx : 866, 953, \underline{954}, 956, 960, 961, 963, 967, 973. tyy : 866, 953, \underline{954}, 956, 960, 961, 963, 964,

967, 973. t0 : \underline{495}, \underline{497}, 498, 503, \underline{599}, \underline{600}. t1 : \underline{495}, \underline{497}, 498, 499, 503, \underline{599}, \underline{600}. t2 : \underline{495}, \underline{497}, 498, 499, 503. u: \underline{152}, \underline{311}, \underline{344}, \underline{432}, \underline{527}, \underline{946}, \underline{968}, \underline{972}, \underline{974}. u packet : \underline{553}, 556, 559, 560. uexit : 76* . ul packet : \underline{553}, 559. unary : \underline{186}, 823, 893, 894. und type: \underline{248}, 1000. undefined : \underline{187}, 229, 234, 239, 242, 244, 245, 247,

248, 585, 809, 842, 844, 845, 850, 1046. : 892. : 872, 873, 878. undefined label : \underline{1096}, 1097, 1110, 1111, 1137,

1139, 1141. undump: \underline{1189*} , 1193, 1195, 1197, 1199* . undump end : \underline{1189*} . undump end end : \underline{1189*} . undump four ASCII : \underline{1193}. undump hh: 1197. undump int : 1189* , 1191* , 1195, 1197, 1199* . undump qqqq : 1193. undump size: \underline{1189*} , 1193. undump size end : \underline{1189*} . undump size end end : \underline{1189*} . undump wd : 1195. unequal to: \underline{189}, 893, 936, 937. unif rand : \underline{151}, 906. uniform deviate: \underline{189}, 893, 906. uniformdeviate primitive: \underline{893}. unity : \underline{101}, 103, 112, 114, 115, 116, 119, 132, 194* , 233, 256, 258, 271, 282, 288, 294, 295, 296, 300, 302, 311, 374, 375, 376, 402, 430, 431, 433, 462, 463, 508, 510, 515, 516, 521, 522, 530, 539, 548, 555, 556, 562, 590, 674, 675, 707, 713, 748, 760, 816, 817, 819, 876, 881, 883, 886, 887, 890, 891, 896, 906, 913, 915, 916, 917, 932, 943, 949, 960, 963, 964, 968, 969, 972, 974, 978, 980, 985, 1010, 1068, 1071, 1074, 1097, 1128, 1157, 1158, 1166, 1182, 1211.

: 937.

: 1021.

unknown primitive: \underline{893}.

unknown boolean: \underline{187}, 229, 248, 618, 798, 799,

918, 936. unknown op: \underline{189}, 893, 918. unknown path: \underline{187}, 248, 618, 798, 918, 995, 1003.

unknown pen: \underline{187}, 248, 618, 798.
unknown picture: \underline{187}, 248, 618, 798, 918.
unknown string : \underline{187}, 248, 618, 798, 918, 936.
unknown tag : \underline{187}, 621, 1003, 1015.
unknown types : \underline{187}, 216, 799, 800, 802, 808,

809, 855, 1003. unrotate: 389. unsave: \underline{254}, 832. unskew : \underline{388}, 394, 421, 445, 447, 451, 454, 457,

485, 488, 510. unsorted : 324, \underline{325}, 326, 328, 330, 331, 332,

335, 338, 343, 344, 346, 348, 354, 355, 364, 367, 368, 369, 375, 376, 381, 382, 383, 384, 385, 578, 1169* .

unstash cur exp: 718, \underline{800}, 801, 859, 870, 926, 942,

946, 948, 962, 963, 988, 995, 1000. unsuffixed macro: \underline{187}, 700, 798, 809, 842, 844,

845, 1046, 1048. : 1178. until primitive: \underline{211}. until token: \underline{186}, 211, 212, 765. update screen: 564* , 569, 571, 574, 577. update terminal : \underline{33*} , 36* , 61* , 66, 76* , 81, 564* , 681,

779* , 793* , 994, 1165, 1212. ur packet : \underline{553}, 558, 559.

use err help: \underline{74}, 75, 84, 86, 1086.

uu: \underline{283}, 285, 287, 288, 290, 291, 293, 294, 295, 297. uv : 553, 556, \underline{557}, 558, 559, 560, 561. u1l : \underline{553}, 559. u1r : \underline{553}, 558, 559. u2l : \underline{553}, 559. u2r : \underline{553}, 558, 559. u3l : \underline{553}, 559. u3r : \underline{553}, 558, 559. v: \underline{215}, \underline{217}, \underline{410}, \underline{432}, \underline{497}, \underline{527}, \underline{589}, \underline{594}, \underline{597}, \underline{599},

\underline{600}, \underline{601}, \underline{607}, \underline{610}, \underline{621}, \underline{801}, \underline{808}, \underline{809}, \underline{820}, \underline{900}, \underline{922}, \underline{930}, \underline{935}, \underline{943}, \underline{944}, \underline{946}, \underline{949}, \underline{961}, \underline{971}, \underline{972}, \underline{974}, \underline{985}, \underline{1001}, \underline{1117}, \underline{1121*} .

v is scaled : \underline{599}, \underline{943}. v packet : \underline{553}, 556, 559, 560. vacuous : \underline{187}, 216, 219, 248, 621, 764, 798, 799,

800, 802, 809, 827, 844, 855, 919, 989, 992, 993, 996, 1003, 1054, 1059, 1070, 1071, 1074.

val too big : \underline{602}, 603, 615. valid range: \underline{326}, 329, 965* . value: \underline{214}, 215, 216, 219, 220, 228, 229, 230, 232,

233, 239, 242, 244, 246, 250, 253, 254, 585, 587, 589, 590, 591, 594, 595, 596, 597, 598, 599, 600, 601, 603, 604, 605, 607, 608, 609, 610, 611, 612, 615, 616, 619, 620, 621, 622, 651, 678, 685, 686, 694, 698, 700, 704, 705, 752, 755, 760, 765, 798, 799, 800, 801, 803, 806, 809, 812, 814, 816, 817, 818, 819, 827, 829, 830, 845, 853, 855, 857, 858, 872, 873, 899, 903, 904, 907, 910, 915, 919, 928, 929, 930, 931, 933, 935, 936, 938, 939, 940, 942, 943, 944, 946, 948, 949, 951, 955, 956, 957, 958, 959, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 982, 983, 984, 988, 1000, 1001, 1005, 1006, 1007, 1008, 1009, 1010, 1015, 1048, 1057, 1072, 1116, 1117, 1118, 1121* , 1122, 1127, 1132, 1136, 1182.

: 602. value loc: \underline{214}, 587, 605, 812, 827, 947. value node size: \underline{228}, 233, 234, 239, 247, 249, 603,

615, 619, 650, 763, 799, 800, 808, 827, 830, 837, 855, 856, 857, 858, 903, 910, 922, 925, 931, 942, 944, 947, 955, 970, 982, 1001, 1006, 1117.

var def : \underline{683}, 684, 697, 992. vardef primitive: \underline{683}. var defining : \underline{659}, 664, 665, 700. var flag : \underline{821}, 822, 823, 824, 868, 993, 995, 996,

1059, 1070, 1071, 1074. var used : \underline{160}, 167, 172, 176, 1045, 1194, 1195. : 1057. : 851. velocity : \underline{116}, 275, 299. verbosity : \underline{801}, 802, 803, 804, \underline{805}, 1040. : 1203. virtual memory: 168. Vitter, Jeffrey Scott: 208. vl packet : \underline{553}, 559. void : \underline{324}, 326, 328, 330, 331, 332, 335, 338, 343,

344, 346, 348, 354, 367, 368, 369, 385, 578, 639, 650, 719, 723, 752, 755, 760, 762, 763, 799, 926, 927, 928, 944, 1169* .

vppp: \underline{190}, 192, 193, \underline{1146}, 1182. vppp primitive: \underline{192}. vr packet : \underline{553}, 558, 559. vstrcpy : 51* . vv : \underline{283}, 285, 290, 291, 293, 294, 295, 297, \underline{809},

817, \underline{935}, \underline{972}. v1l : \underline{553}, 559. v1r : \underline{553}, 558, 559. v2l : \underline{553}, 559. v2r : \underline{553}, 558, 559. v3l : \underline{553}, 559. v3r : \underline{553}, 558, 559. w: \underline{157}, \underline{333}, \underline{342}, \underline{348}, \underline{357}, \underline{373}, \underline{473}, \underline{476}, \underline{477},

\underline{484}, \underline{487}, \underline{488}, \underline{491}, \underline{497}, \underline{510}, \underline{511}, \underline{580}, \underline{599}, \underline{600}, \underline{610}, \underline{1059}, \underline{1074}, \underline{1165}, \underline{1186}, \underline{1187}.

w close: 1201, 1211. w hi : \underline{348}, 349. w in: \underline{348}, 349, \underline{1074}, 1075. w lo: \underline{348}, 349. w make name string : \underline{780}, 1200* . w open in: 779* . w open out : 1200* . w out : \underline{348}, 349, \underline{1074}, 1075. wake up terminal : 33* , 36* , 51* , 66, 68, 398, 682,

779* , 786, 807, 1051, 1187, 1205* , 1212. warning check : \underline{190}, 192, 193, 602. warningcheck primitive: \underline{192}. warning info: \underline{659}, 661, 664, 694, 698, 700, 701,

730, 742, 758. warning issued : \underline{71}, 76* , 195, 1209. was free: \underline{178*} , 180, 184. was hi min: \underline{178*} , 179, 180, 184. was lo max : \underline{178*} , 179, 180, 184. was mem end : \underline{178*} , 179, 180, 184. watch coefs : \underline{592}, 593, 595, 596, 598, 1010. we found it : \underline{547}, 548, 549. : 1, 4, 37, 39, 50, 1191* . : 1056. west edge: \underline{435}. white: \underline{565}, 577, 579, 583, 584, 1143, 1144. width index : \underline{1091}. window number : \underline{571}, 572, 574, 577. window open: \underline{572}, 573, 574, 1071. window time: \underline{572}, 573, 574, 577. Wirth, Niklaus: 10. with option: \underline{186}, 1052, 1053, 1062, 1074. withpen primitive: \underline{1052}. withweight primitive: \underline{1052}. wlog : \underline{56}, 58, 564* , 790* , 1208. wlog cr : \underline{56}, 57, 58, 1205* . wlog ln: \underline{56}, 1141, 1208. word file: 780, 1188* . write: 36* , 56, 1154* . write gf : 1154* , 1155, 1156. write ln: 34, 36* , 51* , 56. wterm: \underline{56}, 58, 61* . wterm cr : \underline{56}, 57, 58. wterm ln: \underline{56}, 779* , 1187, 1204* . ww : \underline{283}, 285, 290, 291, 293, 294, \underline{348}, 349, \underline{357},

362, \underline{473}, 474, \underline{484}, 485, \underline{487}, \underline{488}, \underline{491}, \underline{497}, 498, 502, 503, 508, 509, \underline{510}, \underline{511}, 513, 519, \underline{580}, 582, 583, 584, \underline{1165}, 1169* .

www : \underline{506}, 508. x: \underline{100}, \underline{104}, \underline{119}, \underline{121}, \underline{132}, \underline{135}, \underline{139}, \underline{145}, \underline{149},

\underline{151}, \underline{152}, \underline{234}, \underline{387}, \underline{388}, \underline{390}, \underline{391}, \underline{463}, \underline{486}, \underline{488}, \underline{539}, \underline{574}, \underline{591}, \underline{601}, \underline{602}, \underline{604}, \underline{610}, \underline{868}, \underline{875}, \underline{898}, \underline{982}, \underline{1011}, \underline{1129}, \underline{1131}, \underline{1133*} , \underline{1157}, \underline{1158}, \underline{1186}, \underline{1187}, \underline{1205*} .

x coord : \underline{255}, 256, 258, 265, 266, 271, 281, 282, 299, 302, 393, 394, 397, 404, 405, 406, 407, 409, 410, 411, 412, 413, 418, 419, 421, 423, 424, 425, 434, 436, 441, 442, 444, 445, 447, 451, 457, 467, 468, 472, 473, 474, 475, 476, 477, 479, 481, 483, 484, 485, 486, 488, 492, 493, 496, 498, 502, 508, 509, 510, 512, 513, 515, 518, 519, 521, 528, 534, 535, 536, 537, 543, 558, 563, 866, 867, 871, 887, 896, 962, 980, 981, 986, 987, 1066.

x corr : \underline{461}, 462, 463. x height : 1095. x height code: \underline{1095}. x off : \underline{332}, \underline{333}, \underline{1165}, 1166, 1169* , 1172. x offset : \underline{190}, 192, 193, 1165. xoffset primitive: \underline{192}. x packet : \underline{553}, 556, 559, 560. x part : \underline{189}, 893, 909, 910, 939. xpart primitive: \underline{893}. x part loc: \underline{230}, 830, 873, 899, 903, 907, 915, 929,

942, 944, 946, 947, 948, 956, 957, 959, 967, 970, 973, 977, 978, 982, 984, 1072.

x part sector : \underline{188}, 230, 232, 235, 237, 238. x reflect edges : \underline{337}, 964. x scale edges : \underline{342}, 964. x scaled : \underline{189}, 893, 952, 957. xscaled primitive: \underline{893}. xchr : \underline{20}, 21, 22* , 23, 37, 49, 58, 774. xclause: 16* . xi corr : 306, \underline{311}, 313, 314, 317. xl packet : \underline{553}, 559. xord : \underline{20}, 23, 52* , 53* , 778, 780. xp: \underline{511}, 515, 516, 521, 522. xq : \underline{410}. xr packet : \underline{553}, 558, 559. xw : 362, \underline{363}. xx : \underline{391}, 392, \underline{511}, 515, 516, 521, 522. xx part : \underline{189}, 893, 909. xxpart primitive: \underline{893}. xx part loc: \underline{230}, 233, 956, 957, 958, 959, 967,

970, 973. xx part sector : \underline{188}, 230, 237. xxx1 : 1144, \underline{1145}, 1160. xxx2 : \underline{1144}. xxx3 : 1144, \underline{1145}, 1160. xxx4 : \underline{1144}. xx0 : \underline{311}. xx1 : \underline{311}. xx2 : \underline{311}. xx3 : \underline{311}. xy : 553, 556, \underline{557}, 558, 559, 560, 561. xy corr : \underline{461}, 462, 468, 512, 513, 515, 516, 518,

519, 521, 522. xy part : \underline{189}, 893, 909. xypart primitive: \underline{893}. xy part loc: \underline{230}, 956, 957, 958, 959, 967, 970, 973. xy part sector : \underline{188}, 230, 237. xy round : 402, \underline{433}. xy swap edges : \underline{354}, 963. x0 : \underline{374}, 375, 376, \underline{391}, 392, \underline{495}, 496, \underline{497}, 498,

499, 501, 503, 504, 505, \underline{510}. x0a: \underline{495}, 504. x1 : \underline{311}, 312, 313, 314, 317, 318, \underline{374}, \underline{391}, 392,

\underline{495}, 496, \underline{497}, 498, 499, 501, 503, 504, 505, \underline{510},

541, \underline{542}, 543, 544, 546, 547, 548, 549.

x1a: \underline{495}, 503, 504. x1l : \underline{553}, 559. x1r : \underline{553}, 558, 559. x2 : \underline{311}, 312, 313, 314, 317, 318, \underline{391}, 392, \underline{495},

496, \underline{497}, 498, 499, 501, 503, 504, 505, \underline{542}, 543, 546, 547, 548, 549.

x2a: \underline{311}, 317, 318, \underline{495}, 503. x2l : \underline{553}, 559. x2r : \underline{553}, 558, 559. x3 : \underline{311}, 312, 313, 314, 317, 318, 541, \underline{542}, 543,

546, 547, 548, 549. x3a: \underline{311}, 317, 318. x3l : \underline{553}, 559. x3r : \underline{553}, 558, 559. y: \underline{100}, \underline{104}, \underline{121}, \underline{132}, \underline{135}, \underline{139}, \underline{145}, \underline{151}, \underline{387}, \underline{388},

\underline{390}, \underline{463}, \underline{486}, \underline{488}, \underline{539}, \underline{574}, \underline{868}, \underline{982}. y coord : \underline{255}, 256, 258, 265, 266, 271, 281, 282,

299, 302, 393, 394, 397, 404, 405, 406, 407, 409, 410, 413, 414, 415, 416, 419, 421, 423, 424, 425, 435, 437, 439, 444, 445, 447, 451, 457, 467, 468, 472, 473, 474, 475, 476, 477, 479, 481, 483, 484, 485, 486, 488, 492, 493, 496, 498, 502, 508, 509, 510, 512, 515, 518, 521, 528, 534, 535, 536, 537, 543, 558, 563, 866, 867, 871, 887, 896, 962, 980, 981, 986, 987, 1066.

y corr : \underline{461}, 462, 463, 468, 512, 515, 516, 518,

521, 522. y off : \underline{332}, \underline{1165}, 1166, 1167, 1172. y offset : \underline{190}, 192, 193, 1165. yoffset primitive: \underline{192}. y packet : \underline{553}, 556, 559, 560. y part : \underline{189}, 893, 909. ypart primitive: \underline{893}. y part loc: \underline{230}, 830, 873, 899, 903, 907, 915, 929,

942, 944, 946, 947, 948, 956, 957, 959, 967, 970, 973, 977, 978, 982, 984, 1072.

y part sector : \underline{188}, 230, 237. y reflect edges : \underline{336}, 964. y scale edges : \underline{340}, 964. y scaled : \underline{189}, 893, 952, 957. yscaled primitive: \underline{893}. year : \underline{190}, 192, 193, 194* , 790* , 1163* , 1200* . year primitive: \underline{192}. yl packet : \underline{553}, 559. : 52* . yp: \underline{511}, 515, 516, 521, 522. yq : \underline{410}. yr packet : \underline{553}, 558, 559. yt : \underline{374}. yx part : \underline{189}, 893, 909. yxpart primitive: \underline{893}. yx part loc: \underline{230}, 956, 958, 959, 967, 970, 973. yx part sector : \underline{188}, 230, 237. yy : \underline{511}, 515, 516, 521, 522. yy part : \underline{189}, 893, 909. yypart primitive: \underline{893}. yy part loc: \underline{230}, 233, 956, 957, 958, 959, 967,

970, 973. yy part sector : \underline{188}, 230, 237. yyy : 1144, \underline{1145}, 1147, 1166, 1177. yy0 : \underline{311}. yy1 : \underline{311}. yy2 : \underline{311}. yy3 : \underline{311}. y0 : \underline{374}, 375, 376, \underline{495}, 496, \underline{497}, 498, 499, 501,

503, 504, 505, \underline{510}. y0a: \underline{495}, 504.

y1 : \underline{311}, 312, 313, 314, 317, 318, \underline{374}, 375, 376,

\underline{495}, 496, \underline{497}, 498, 499, 501, 503, 504, 505, \underline{510}, 541, \underline{542}, 543, 544, 546, 547, 548.

y1a: \underline{495}, 503, 504.
y1l : \underline{553}, 559.
y1r : \underline{553}, 558, 559.
y2 : \underline{311}, 312, 313, 314, 317, 318, \underline{495}, 496, \underline{497}, 498,

499, 501, 503, 504, 505, \underline{542}, 543, 546, 547, 548.

y2a: \underline{311}, 317, 318, \underline{495}, 503.
y2l : \underline{553}, 559.
y2r : \underline{553}, 558, 559.
y3 : \underline{311}, 312, 313, 314, 317, 318, 541, \underline{542}, 543,

546, 547, 548. y3a: \underline{311}, 317, 318. y3l : \underline{553}, 559. y3r : \underline{553}, 558, 559. z: \underline{132}, \underline{135}, \underline{139}, \underline{145}. z corr : \underline{461}, 462, 463. z scaled : \underline{189}, 893, 952, 957. zscaled primitive: \underline{893}. Zabala Salelles, Ignacio Andres: 812. zero crossing : \underline{391}. zero field : \underline{326}, 328, 329, 332, 336, 337, 340,

342, 352, 364, 365, 366, 370, 374, 377, 378, 577, 1167, 1172. zero val : \underline{175}, 1126, 1127. zero w : \underline{324}, 326, 333, 337, 349, 350, 358, 365, 370, 373, 375, 376, 381, 382, 383, 384, 582, 1169* .

62  NAMES OF THE SECTIONS  changes for C §1216

⟨ Abandon edges command because there’s no variable 1060 ⟩ Used in sections 1059, 1070, 1071, and 1074. ⟨ Absorb delimited parameters, putting them into lists q and r 703 ⟩ Used in section 697. ⟨ Absorb parameter tokens for type base 704 ⟩ Used in section 703. ⟨ Absorb undelimited parameters, putting them into list r 705 ⟩ Used in section 697. ⟨ Add a known value to the constant term of dep list (p) 931 ⟩ Used in section 930. ⟨ Add dependency list pp of type tt to dependency list p of type t 1010 ⟩ Used in section 1009. ⟨ Add edges for fifth or eighth octants, then goto done 382 ⟩ Used in section 378. ⟨ Add edges for first or fourth octants, then goto done 381 ⟩ Used in section 378. ⟨ Add edges for second or third octants, then goto done 383 ⟩ Used in section 378. ⟨ Add edges for sixth or seventh octants, then goto done 384 ⟩ Used in section 378. ⟨ Add operand p to the dependency list v 932 ⟩ Used in section 930. ⟨ Add or subtract the current expression from p 929 ⟩ Used in section 922. ⟨ Add the contribution of node q to the total weight, and set q ← link (q) 370 ⟩ Used in sections 369 and 369. ⟨ Add the known value(p) to the constant term of v 933 ⟩ Used in section 932. ⟨ Add the right operand to list p 1009 ⟩ Used in section 1006.

⟨ Additional cases of binary operators 936, 940, 941, 948, 951, 952, 975, 983, 988 ⟩ Used in section 922. ⟨ Additional cases of unary operators 905, 906, 907, 909, 912, 915, 917, 918, 920, 921 ⟩ Used in section 898.

⟨ Adjust θ_{n} to equal θ_{0} and goto found 291 ⟩ Used in section 287. ⟨ Adjust the balance for a delimited argument; goto done if done 731 ⟩ Used in section 730. ⟨ Adjust the balance for an undelimited argument; goto done if done 732 ⟩ Used in section 730. ⟨ Adjust the balance; goto done if it’s zero 687 ⟩ Used in section 685. ⟨ Adjust the coordinates (r0 , c0 ) and (r1 , c1 ) so that they lie in the proper range 575 ⟩ Used in section 574. ⟨ Adjust the data of h to account for a difference of offsets 367 ⟩ Used in section 366. ⟨ Adjust the header to reflect the new edges 364 ⟩ Used in section 354. ⟨ Advance pointer p to the next vertical edge, after destroying the previous one 360 ⟩ Used in section 358. ⟨ Advance pointer r to the next vertical edge 359 ⟩ Used in section 358. ⟨ Advance to the next pair (cur t , cur tt ) 560 ⟩ Used in section 556. ⟨ Advance p to node q, removing any “dead” cubics that might have been introduced by the splitting

process 492 ⟩ Used in section 491.

⟨ Allocate entire node p and goto found 171 ⟩ Used in section 169*. ⟨ Allocate from the top of node p and goto found 170 ⟩ Used in section 169*. ⟨ Announce that the equation cannot be performed 1002 ⟩ Used in section 1001. ⟨ Append the current expression to arg list 728 ⟩ Used in sections 726 and 733. ⟨ Ascend one level, pushing a token onto list q and replacing p by its parent 236 ⟩ Used in section 235. ⟨ Assign the current expression to an internal variable 999 ⟩ Used in section 996. ⟨ Assign the current expression to the variable lhs 1000 ⟩ Used in section 996. ⟨ Attach the replacement text to the tail of node p 698 ⟩ Used in section 697. ⟨ Augment some edges by others 1061 ⟩ Used in section 1059. ⟨ Back up an outer symbolic token so that it can be reread 662 ⟩ Used in section 661.

⟨ Basic printing procedures 57, 58, 59, 60, 62, 63, 64, 103, 104, 187, 195, 197, 773 ⟩ Used in section 4.

⟨ Calculate integers α, β, γ for the vertex coordinates 530 ⟩ Used in section 528. ⟨ Calculate the given value of θ_{n} and goto found 292 ⟩ Used in section 284. ⟨ Calculate the ratio ff = C_{k}/(C_{k} + B_{k} − u_{k−1}A_{k}) 289 ⟩ Used in section 287. ⟨ Calculate the turning angles ψ_{k} and the distances d_{k,k+1}; set n to the length of the path 281 ⟩

Used in section 278.

⟨ Calculate the values aa = A_{k}/B_{k}, bb = D_{k}/C_{k}, dd = (3 − α_{k−1})d_{k,k+1}, ee = (3 − β_{k+1})d_{k−1,k}, and

cc = (B_{k} − u_{k−1}A_{k})/B_{k} 288 ⟩ Used in section 287.

⟨ Calculate the values of v_{k} and w_{k} 290 ⟩ Used in section 287.

⟨ Cases of do statement that invoke particular commands 1020, 1023, 1026, 1030, 1033, 1039, 1058, 1069, 1076, 1081,

1100, 1175 ⟩ Used in section 992. ⟨ Cases of print cmd mod for symbolic printing of primitives 212, 684, 689, 696, 710, 741, 894, 1014, 1019, 1025,

1028, 1038, 1043, 1053, 1080, 1102, 1109, 1180 ⟩ Used in section 625.

§1216  changes for C  NAMES OF THE SECTIONS 63

⟨ Change node q to a path for an elliptical pen 866 ⟩ Used in section 865. ⟨ Change one-point paths into dead cycles 563 ⟩ Used in section 562. ⟨ Change the interaction level and return 81 ⟩ Used in section 79*. ⟨ Change the tentative pen 1063 ⟩ Used in section 1062.

⟨ Change to ‘ ’ 701 ⟩ Used in section 700.

⟨ Change variable x from independent to dependent or known 615 ⟩ Used in section 610. ⟨ Character k cannot be printed 49 ⟩ Used in section 48. ⟨ Check flags of unavailable nodes 183 ⟩ Used in section 180. ⟨ Check for the presence of a colon 756 ⟩ Used in section 755. ⟨ Check if unknowns have been equated 938 ⟩ Used in section 936. ⟨ Check single-word avail list 181 ⟩ Used in section 180. ⟨ Check that the proper right delimiter was present 727 ⟩ Used in section 726.

⟨ Check the “constant” values for consistency 14, 154, 204, 214, 310, 553, 777 ⟩ Used in section 1204*.

⟨ Check the list of linear dependencies 617 ⟩ Used in section 180. ⟨ Check the places where B(y_{1}, y_{2}, y_{3}; t) = 0 to see if B(x_{1}, x_{2}, x_{3}; t) ≥ 0 547 ⟩ Used in section 546. ⟨ Check the pool check sum 53* ⟩ Used in section 52*. ⟨ Check the tentative weight 1056 ⟩ Used in section 1054. ⟨ Check the turning number 1068 ⟩ Used in section 1064. ⟨ Check variable-size avail list 182* ⟩ Used in section 180. ⟨ Choose a dependent variable to take the place of the disappearing independent variable, and change all

remaining dependencies accordingly 815 ⟩ Used in section 812. ⟨ Choose control points for the path and put the result into cur exp 891 ⟩ Used in section 869.

⟨ Close the base file 1201 ⟩ Used in section 1186.

⟨ Compare the current expression with zero 937 ⟩ Used in section 936. ⟨ Compile a ligature/kern command 1112 ⟩ Used in section 1107. ⟨ Compiler directives 9* ⟩ Used in section 4. ⟨ Complain about a bad pen path 478 ⟩ Used in section 477. ⟨ Complain about a character tag conflict 1105 ⟩ Used in section 1104. ⟨ Complain about improper special operation 1178 ⟩ Used in section 1177. ⟨ Complain about improper type 1055 ⟩ Used in section 1054. ⟨ Complain about non-cycle and goto not found 1067 ⟩ Used in section 1064. ⟨ Complement the x coordinates of the cubic between p and q 409 ⟩ Used in section 407. ⟨ Complement the y coordinates of the cubic between pp and qq 414 ⟩ Used in sections 413 and 417. ⟨ Complete the contour filling operation 1064 ⟩ Used in section 1062. ⟨ Complete the ellipse by copying the negative of the half already computed 537 ⟩ Used in section 527. ⟨ Complete the error message, and set cur sym to a token that might help recover from the error 664 ⟩

Used in section 663.

⟨ Complete the half ellipse by reflecting the quarter already computed 536 ⟩ Used in section 527. ⟨ Complete the offset splitting process 503 ⟩ Used in section 494. ⟨ Compute f = ⌊2^{16}(1 + p/q) + \frac{1}{2}⌋ 115 ⟩ Used in section 114. ⟨ Compute f = ⌊2^{28}(1 + p/q) + \frac{1}{2}⌋ 108 ⟩ Used in section 107. ⟨ Compute p = ⌊qf/2^{16} + \frac{1}{2}⌋ − q 113 ⟩ Used in section 112. ⟨ Compute p = ⌊qf/2^{28} + \frac{1}{2}⌋ − q 111 ⟩ Used in section 109. ⟨ Compute a check sum in (b1 , b2 , b3 , b4 ) 1132 ⟩ Used in section 1131. ⟨ Compute a compromise pen edge 443 ⟩ Used in section 442. ⟨ Compute a good coordinate at a diagonal transition 442 ⟩ Used in section 441. ⟨ Compute before-and-after x values based on the current pen 435 ⟩ Used in section 434. ⟨ Compute before-and-after y values based on the current pen 438 ⟩ Used in section 437. ⟨ Compute test coefficients (t0 , t1 , t2 ) for s(t) versus s_{k} or s_{k−1} 498 ⟩ Used in sections 497 and 503. ⟨ Compute the distance d from class 0 to the edge of the ellipse in direction (u, v), times \sqrt{u^{2} + v^{2}}, rounded

to the nearest integer 533 ⟩ Used in section 531. ⟨ Compute the hash code h 208 ⟩ Used in section 205.

⟨ Compute the incoming and outgoing directions 457 ⟩ Used in section 454. ⟨ Compute the ligature/kern program offset and implant the left boundary label 1137 ⟩ Used in section 1135. ⟨ Compute the magic offset values 365 ⟩ Used in section 354. ⟨ Compute the octant code; skew and rotate the coordinates (x, y) 489 ⟩ Used in section 488. ⟨ Compute the offsets between screen coordinates and actual coordinates 576 ⟩ Used in section 574. ⟨ Constants in the outer block 11* ⟩ Used in section 4. ⟨ Construct a path from pp to qq of length ⌈b⌉ 980 ⟩ Used in section 978. ⟨ Construct a path from pp to qq of length zero 981 ⟩ Used in section 978. ⟨ Construct the offset list for the kth octant 481 ⟩ Used in section 477. ⟨ Contribute a term from p, plus the corresponding term from q 598 ⟩ Used in section 597. ⟨ Contribute a term from p, plus f times the corresponding term from q 595 ⟩ Used in section 594. ⟨ Contribute a term from q, multiplied by f 596 ⟩ Used in section 594. ⟨ Convert a suffix to a string 840 ⟩ Used in section 823. ⟨ Convert the left operand, p, into a partial path ending at q; but return if p doesn’t have a suitable

type 870 ⟩ Used in section 869.

⟨ Convert the right operand, cur exp, into a partial path from pp to qq 885 ⟩ Used in section 869. ⟨ Convert (x, y) to the octant determined by q 146 ⟩ Used in section 145.

⟨ Copy both sorted and unsorted lists of p to pp 335 ⟩ Used in sections 334 and 341. ⟨ Copy the big node p 857 ⟩ Used in section 855.

⟨ Copy the unskewed and unrotated coordinates of node ww 485 ⟩ Used in section 484. ⟨ Correct the octant code in segments with decreasing y 418 ⟩ Used in section 413. ⟨ Create the base ident , open the base file, and inform the user that dumping has begun 1200* ⟩

Used in section 1186.

⟨ Cull superfluous edge-weight entries from sorted (p) 349 ⟩ Used in section 348. ⟨ Deal with redundant or inconsistent equation 1008 ⟩ Used in section 1006. ⟨ Decide whether or not to go clockwise 454 ⟩ Used in section 452.

⟨ Declare action procedures for use by do statement 995, 996, 1015, 1021, 1029, 1031, 1034, 1035, 1036, 1040, 1041, 1044, 1045, 1046, 1049, 1050, 1051, 1054, 1057, 1059, 1070, 1071, 1072, 1073, 1074, 1082, 1103, 1104, 1106, 1177, 1186 ⟩ Used in section 989.

⟨ Declare basic dependency-list subroutines 594, 600, 602, 603, 604 ⟩ Used in section 246.

⟨ Declare binary action procedures 923, 928, 930, 943, 946, 949, 953, 960, 961, 962, 963, 966, 976, 977, 978, 982, 984,

985 ⟩ Used in section 922. ⟨ Declare generic font output procedures 1155, 1157, 1158, 1159, 1160, 1161, 1163*, 1165 ⟩ Used in section 989.

⟨ Declare miscellaneous procedures that were declared forward 224 ⟩ Used in section 1202.

⟨ Declare subroutines for printing expressions 257, 332, 388, 473, 589, 801, 807 ⟩ Used in section 246. ⟨ Declare subroutines needed by big trans 968, 971, 972, 974 ⟩ Used in section 966.

⟨ Declare subroutines needed by make exp copy 856, 858 ⟩ Used in section 855.

⟨ Declare subroutines needed by make spec 405, 406, 419, 426, 429, 431, 432, 433, 440, 451 ⟩ Used in section 402.

⟨ Declare subroutines needed by offset prep 493, 497 ⟩ Used in section 491. ⟨ Declare subroutines needed by solve choices 296, 299 ⟩ Used in section 284.

⟨ Declare the basic parsing subroutines 823, 860, 862, 864, 868, 892 ⟩ Used in section 1202.

⟨ Declare the function called open base file 779* ⟩ Used in section 1187. ⟨ Declare the function called scan declared variable 1011 ⟩ Used in section 697. ⟨ Declare the function called tfm check 1098 ⟩ Used in section 1070. ⟨ Declare the function called trivial knot 486 ⟩ Used in section 484. ⟨ Declare the procedure called check delimiter 1032 ⟩ Used in section 697. ⟨ Declare the procedure called dep finish 935 ⟩ Used in section 930. ⟨ Declare the procedure called dual moves 518 ⟩ Used in section 506. ⟨ Declare the procedure called flush below variable 247 ⟩ Used in section 246. ⟨ Declare the procedure called flush cur exp 808, 820 ⟩ Used in section 246. ⟨ Declare the procedure called flush string 43 ⟩ Used in section 73. ⟨ Declare the procedure called known pair 872 ⟩ Used in section 871.

⟨ Declare the procedure called macro call 720 ⟩ Used in section 706. ⟨ Declare the procedure called make eq 1001 ⟩ Used in section 995. ⟨ Declare the procedure called make exp copy 855 ⟩ Used in section 651. ⟨ Declare the procedure called print arg 723 ⟩ Used in section 720. ⟨ Declare the procedure called print cmd mod 625 ⟩ Used in section 227. ⟨ Declare the procedure called print dp 805 ⟩ Used in section 801. ⟨ Declare the procedure called print macro name 722 ⟩ Used in section 720. ⟨ Declare the procedure called print weight 333 ⟩ Used in section 332. ⟨ Declare the procedure called runaway 665 ⟩ Used in section 162. ⟨ Declare the procedure called scan text arg 730 ⟩ Used in section 720. ⟨ Declare the procedure called show token list 217 ⟩ Used in section 162. ⟨ Declare the procedure called skew line edges 510 ⟩ Used in section 506. ⟨ Declare the procedure called solve choices 284 ⟩ Used in section 269. ⟨ Declare the procedure called split cubic 410 ⟩ Used in section 406. ⟨ Declare the procedure called try eq 1006 ⟩ Used in section 995.

⟨ Declare the recycling subroutines 268, 385, 487, 620, 809 ⟩ Used in section 246.

⟨ Declare the stashing/unstashing routines 799, 800 ⟩ Used in section 801.

⟨ Declare unary action procedures 899, 900, 901, 904, 908, 910, 913, 916, 919 ⟩ Used in section 898.

⟨ Decrease the string reference count, if the current token is a string 743 ⟩

Used in sections 83, 742, 991, and 1016.

⟨ Decrease the velocities, if necessary, to stay inside the bounding triangle 300 ⟩ Used in section 299. ⟨ Decrease k by 1, maintaining the invariant relations between x, y, and q 123 ⟩ Used in section 121. ⟨ Decry the invalid character and goto restart 670 ⟩ Used in section 669. ⟨ Decry the missing string delimiter and goto restart 672 ⟩ Used in section 671. ⟨ Define an extensible recipe 1113 ⟩ Used in section 1106. ⟨ Delete all the row headers 353 ⟩ Used in section 352. ⟨ Delete empty rows at the top and/or bottom; update the boundary values in the header 352 ⟩

Used in section 348. ⟨ Delete c − tokens and goto continue 83 ⟩ Used in section 79*.

⟨ Descend one level for the attribute info(t) 245 ⟩ Used in section 242. ⟨ Descend one level for the subscript value(t) 244 ⟩ Used in section 242. ⟨ Descend past a collective subscript 1012 ⟩ Used in section 1011.

⟨ Descend the structure 1047 ⟩ Used in section 1046.

⟨ Descend to the previous level and goto not found 561 ⟩ Used in section 560. ⟨ Determine if a character has been shipped out 1181 ⟩ Used in section 906. ⟨ Determine the before-and-after values of both coordinates 445 ⟩ Used in sections 444 and 446. ⟨ Determine the dependency list s to substitute for the independent variable p 816 ⟩ Used in section 815. ⟨ Determine the envelope’s starting and ending lattice points (m0 , n0 ) and (m1 , n1 ) 508 ⟩

Used in section 506.

⟨ Determine the file extension, gf ext 1164 ⟩ Used in section 1163*. ⟨ Determine the number n of arguments already supplied, and set tail to the tail of arg list 724 ⟩

Used in section 720.

⟨ Determine the octant boundary q that precedes f 400 ⟩ Used in section 398. ⟨ Determine the octant code for direction (dx , dy ) 480 ⟩ Used in section 479. ⟨ Determine the path join parameters; but goto finish path if there’s only a direction specifier 874 ⟩

Used in section 869.

⟨ Determine the starting and ending lattice points (m0 , n0 ) and (m1 , n1 ) 467 ⟩ Used in section 465. ⟨ Determine the tension and/or control points 881 ⟩ Used in section 874. ⟨ Dispense with the cases a < 0 and/or b > l 979 ⟩ Used in section 978.

⟨ Display a big node 803 ⟩ Used in section 802.

⟨ Display a collective subscript 221 ⟩ Used in section 218. ⟨ Display a complex type 804 ⟩ Used in section 802.

⟨ Display a numeric token 220 ⟩ Used in section 219. ⟨ Display a parameter token 222 ⟩ Used in section 218. ⟨ Display a variable macro 1048 ⟩ Used in section 1046. ⟨ Display a variable that’s been declared but not defined 806 ⟩ Used in section 802. ⟨ Display the boolean value of cur exp 750 ⟩ Used in section 748. ⟨ Display the current context 636 ⟩ Used in section 635. ⟨ Display the new dependency 613 ⟩ Used in section 610. ⟨ Display the pixels of edge row p in screen row r 578 ⟩ Used in section 577. ⟨ Display token p and set c to its class; but return if there are problems 218 ⟩ Used in section 217. ⟨ Display two-word token 219 ⟩ Used in section 218.

⟨ Divide list p by 2^{n} 616 ⟩ Used in section 615.

⟨ Divide list p by −v, removing node q 612 ⟩ Used in section 610. ⟨ Divide the variables by two, to avoid overflow problems 313 ⟩ Used in section 311. ⟨ Do a statement that doesn’t begin with an expression 992 ⟩ Used in section 989.

⟨ Do a title 994 ⟩ Used in section 993.

⟨ Do an equation, assignment, title, or ‘⟨ expression ⟩ endgroup’ 993 ⟩ Used in section 989. ⟨ Do any special actions needed when y is constant; return or goto continue if a dead cubic from p to q is

removed 417 ⟩ Used in section 413.

⟨ Do magic computation 646 ⟩ Used in section 217. ⟨ Do multiple equations and goto done 1005 ⟩ Used in section 1003.

⟨ Double the path 1065 ⟩ Used in section 1064.

⟨ Dump a few more things and the closing check word 1198 ⟩ Used in section 1186. ⟨ Dump constants for consistency check 1190 ⟩ Used in section 1186. ⟨ Dump the dynamic memory 1194 ⟩ Used in section 1186.

⟨ Dump the string pool 1192 ⟩ Used in section 1186.

⟨ Dump the table of equivalents and the hash table 1196 ⟩ Used in section 1186. ⟨ Either begin an unsuffixed macro call or prepare for a suffixed one 845 ⟩ Used in section 844. ⟨ Empty the last bytes out of gf buf 1156 ⟩ Used in section 1182.

⟨ Ensure that type(p) = proto dependent 969 ⟩ Used in section 968. ⟨ Error handling procedures 73, 76*, 77, 88, 89, 90 ⟩ Used in section 4. ⟨ Exclaim about a redundant equation 623 ⟩ Used in sections 622, 1004, and 1008.

⟨ Exit a loop if the proper time has come 713 ⟩ Used in section 707. ⟨ Exit prematurely from an iteration 714 ⟩ Used in section 713. ⟨ Exit to found if an eastward direction occurs at knot p 544 ⟩ Used in section 541. ⟨ Exit to found if the curve whose derivatives are specified by x1 , x2 , x3 , y1 , y2 , y3 travels eastward at some

time tt 546 ⟩ Used in section 541.

⟨ Exit to found if the derivative B(x_{1}, x_{2}, x_{3}; t) becomes ≥ 0 549 ⟩ Used in section 548. ⟨ Expand the token after the next token 715 ⟩ Used in section 707. ⟨ Feed the arguments and replacement text to the scanner 736 ⟩ Used in section 720. ⟨ Fill in the control information between consecutive breakpoints p and q 278 ⟩ Used in section 273. ⟨ Fill in the control points between p and the next breakpoint, then advance p to that breakpoint 273 ⟩

Used in section 269.

⟨ Find a node q in list p whose coefficient v is largest 611 ⟩ Used in section 610. ⟨ Find the approximate type tt and corresponding q 850 ⟩ Used in section 844. ⟨ Find the first breakpoint, h, on the path; insert an artificial breakpoint if the path is an unbroken

cycle 272 ⟩ Used in section 269.

⟨ Find the index k such that s_{k−1} ≤ dy /dx < s_{k} 502 ⟩ Used in section 494. ⟨ Find the initial slope, dy /dx 501 ⟩ Used in section 494. ⟨ Find the minimum lk offset and adjust all remainders 1138 ⟩ Used in section 1137. ⟨ Find the starting point, f 399 ⟩ Used in section 398. ⟨ Finish choosing angles and assigning control points 297 ⟩ Used in section 284. ⟨ Finish getting the symbolic token in cur sym; goto restart if it is illegal 668 ⟩ Used in section 667.

⟨ Finish linking the offset nodes, and duplicate the borderline offset nodes if necessary 483 ⟩

Used in section 481.

⟨ Finish off an entirely blank character 1168 ⟩ Used in section 1167.

⟨ Finish the file 1182 ⟩ Used in section 1206. ⟨ Finish the and files 1206 ⟩ Used in section 1205*. ⟨ Finish the file 1134 ⟩ Used in section 1206.

⟨ Fix up the transition fields and adjust the turning number 459 ⟩ Used in section 452. ⟨ Flush spurious symbols after the declared variable 1016 ⟩ Used in section 1015. ⟨ Flush unparsable junk that was found after the statement 991 ⟩ Used in section 989. ⟨ For each of the eight cases, change the relevant fields of cur exp and goto done; but do nothing if capsule

p doesn’t have the appropriate type 957 ⟩ Used in section 955. ⟨ For each type t, make an equation and goto done unless cur type is incompatible with t 1003 ⟩

Used in section 1001.

⟨ Get a stored numeric or string or capsule token and return 678 ⟩ Used in section 676. ⟨ Get a string token and return 671 ⟩ Used in section 669. ⟨ Get given directions separated by commas 878 ⟩ Used in section 877. ⟨ Get ready to close a cycle 886 ⟩ Used in section 869. ⟨ Get ready to fill a contour, and fill it 1062 ⟩ Used in section 1059. ⟨ Get the first line of input and prepare to start 1211 ⟩ Used in section 1204*. ⟨ Get the fraction part f of a numeric token 674 ⟩ Used in section 669. ⟨ Get the integer part n of a numeric token; set f ← 0 and goto fin numeric token if there is no decimal

point 673 ⟩ Used in section 669.

⟨ Get the linear equations started; or return with the control points in place, if linear equations needn’t be

solved 285 ⟩ Used in section 284.

⟨ Get user’s advice and return 78 ⟩ Used in section 77. ⟨ Give error messages if bad char or n ≥ 4096 914 ⟩ Used in section 913.

⟨ Global variables 13, 20, 25, 29, 38, 42, 50, 54, 68, 71, 74, 91, 97, 129, 137, 144, 148, 159, 160, 161, 166, 178*, 190, 196, 198, 200, 201, 225, 230, 250, 267, 279, 283, 298, 308, 309, 327, 371, 379, 389, 395, 403, 427, 430, 448, 455, 461, 464, 507, 552, 555, 557, 566, 569, 572, 579, 585, 592, 624, 628, 631, 633, 634, 659, 680, 699, 738, 752, 767, 768*, 775*, 782, 785, 791, 796, 813, 821, 954, 1077, 1084, 1087, 1096, 1119, 1125, 1130, 1149, 1152, 1162, 1183, 1188*, 1203, 1214* ⟩ Used in section 4.

⟨ Grow more variable-size memory and goto restart 168 ⟩ Used in section 167. ⟨ Handle erroneous pyth sub and set a ← 0 128 ⟩ Used in section 126. ⟨ Handle non-positive logarithm 134 ⟩ Used in section 132. ⟨ Handle quoted symbols, # , , or # 690 ⟩ Used in section 685. ⟨ Handle square root of zero or negative argument 122 ⟩ Used in section 121. ⟨ Handle the special case of infinite slope 505 ⟩ Used in section 494. ⟨ Handle the test for eastward directions when y_{1}y_{3} = y_{2}^{2}; either goto found or goto done 548 ⟩

Used in section 546. ⟨ Handle undefined arg 140 ⟩ Used in section 139.

⟨ Handle unusual cases that masquerade as variables, and goto restart or goto done if appropriate;

otherwise make a copy of the variable and goto done 852 ⟩ Used in section 844. ⟨ If consecutive knots are equal, join them explicitly 271 ⟩ Used in section 269. ⟨ If node q is a transition point between octants, compute and save its before-and-after coordinates 441 ⟩

Used in section 440.

⟨ If node q is a transition point for x coordinates, compute and save its before-and-after coordinates 434 ⟩

Used in section 433.

⟨ If node q is a transition point for y coordinates, compute and save its before-and-after coordinates 437 ⟩

Used in section 433.

⟨ If the current transform is entirely known, stash it in global variables; otherwise return 956 ⟩

Used in section 953.

⟨ Increase and decrease move[k − 1] and move[k] by δ_{k} 322 ⟩ Used in section 321. ⟨ Increase k until x can be multiplied by a factor of 2^{−k}, and adjust y accordingly 133 ⟩ Used in section 132.

⟨ Increase z to the arg of (x, y) 143 ⟩ Used in section 142. ⟨ Initialize for dual envelope moves 519 ⟩ Used in section 518. ⟨ Initialize for intersections at level zero 558 ⟩ Used in section 556. ⟨ Initialize for ordinary envelope moves 513 ⟩ Used in section 512. ⟨ Initialize for the display computations 581 ⟩ Used in section 577.

⟨ Initialize table entries (done by only) 176, 193, 203, 229, 324, 475, 587, 702, 759, 911, 1116, 1127, 1185 ⟩

Used in section 1210.

⟨ Initialize the array of new edge list heads 356 ⟩ Used in section 354. ⟨ Initialize the ellipse data structure by beginning with directions (0, −1), (1, 0), (0, 1) 528 ⟩

Used in section 527.

⟨ Initialize the input routines 657, 660 ⟩ Used in section 1211.

⟨ Initialize the output routines 55, 61*, 783, 792 ⟩ Used in section 1204*. ⟨ Initialize the print selector based on interaction 70 ⟩ Used in sections 1023 and 1211.

⟨ Initialize the random seed to cur exp 1022 ⟩ Used in section 1021. ⟨ Initiate or terminate input from a file 711 ⟩ Used in section 707. ⟨ Input from external file; goto restart if no input found, or return if a non-symbolic token is found 669 ⟩

Used in section 667.

⟨ Input from token list; goto restart if end of list or if a parameter needs to be expanded, or return if a

non-symbolic token is found 676 ⟩ Used in section 667. ⟨ Insert a fractional node by splitting the cubic 986 ⟩ Used in section 985. ⟨ Insert a line segment dually to approach the correct offset 521 ⟩ Used in section 518. ⟨ Insert a line segment to approach the correct offset 515 ⟩ Used in section 512. ⟨ Insert a new line for direction (u, v) between p and q 535 ⟩ Used in section 531. ⟨ Insert a new symbolic token after p, then make p point to it and goto found 207 ⟩ Used in section 205. ⟨ Insert a suffix or text parameter and goto restart 677 ⟩ Used in section 676. ⟨ Insert additional boundary nodes, then goto done 458 ⟩ Used in section 452. ⟨ Insert an edge-weight for edge m, if the new pixel weight has changed 350 ⟩ Used in section 349. ⟨ Insert blank rows at the top and bottom, and set p to the new top row 355 ⟩ Used in section 354. ⟨ Insert downward edges for a line 376 ⟩ Used in section 374. ⟨ Insert exactly n min(cur edges ) − nl empty rows at the bottom 330 ⟩ Used in section 329. ⟨ Insert exactly nr − n max (cur edges ) empty rows at the top 331 ⟩ Used in section 329. ⟨ Insert horizontal edges of weight w between m and mm 362 ⟩ Used in section 358. ⟨ Insert octant boundaries and compute the turning number 450 ⟩ Used in section 402. ⟨ Insert one or more octant boundary nodes just before q 452 ⟩ Used in section 450. ⟨ Insert the horizontal edges defined by adjacent rows p, q, and destroy row p 358 ⟩ Used in section 354. ⟨ Insert the new envelope moves dually in the pixel data 523 ⟩ Used in section 518. ⟨ Insert the new envelope moves in the pixel data 517 ⟩ Used in section 512. ⟨ Insert upward edges for a line 375 ⟩ Used in section 374. ⟨ Install a complex multiplier, then goto done 959 ⟩ Used in section 957. ⟨ Install sines and cosines, then goto done 958 ⟩ Used in section 957. ⟨ Interpolate new vertices in the ellipse data structure until improvement is impossible 531 ⟩

Used in section 527.

⟨ Interpret code c and return if done 79* ⟩ Used in section 78. ⟨ Introduce new material from the terminal and return 82 ⟩ Used in section 79*. ⟨ Join the partial paths and reset p and q to the head and tail of the result 887 ⟩ Used in section 869. ⟨ Labels in the outer block 6 ⟩ Used in section 4.

⟨ Last-minute procedures 1205*, 1209, 1210, 1212 ⟩ Used in section 1202.

⟨ Link a new attribute node r in place of node p 241 ⟩ Used in section 239. ⟨ Link a new subscript node r in place of node p 240 ⟩ Used in section 239. ⟨ Link node r to the previous node 482 ⟩ Used in section 481. ⟨ Local variables for formatting calculations 641 ⟩ Used in section 635. ⟨ Local variables for initialization 19*, 130 ⟩ Used in section 4.

⟨ Log the subfile sizes of the file 1141 ⟩ Used in section 1134. ⟨ Make a special knot node for pencircle 896 ⟩ Used in section 895. ⟨ Make a trivial one-point path cycle 1066 ⟩ Used in section 1065. ⟨ Make moves for current subinterval; if bisection is necessary, push the second subinterval onto the stack,

and goto continue in order to handle the first subinterval 314 ⟩ Used in section 311. ⟨ Make one move of each kind 317 ⟩ Used in section 314. ⟨ Make sure that all the diagonal roundings are safe 446 ⟩ Used in section 444. ⟨ Make sure that both nodes p and pp are of structured type 243 ⟩ Used in section 242. ⟨ Make sure that both x and y parts of p are known; copy them into cur x and cur y 873 ⟩

Used in section 872.

⟨ Make sure that the current expression is a valid tension setting 883 ⟩ Used in sections 882 and 882. ⟨ Make the dynamic memory into one big available node 1207 ⟩ Used in section 1206. ⟨ Make the envelope moves for the current octant and insert them in the pixel data 512 ⟩ Used in section 506. ⟨ Make the first 256 strings 48 ⟩ Used in section 47. ⟨ Make the moves for the current octant 468 ⟩ Used in section 465. ⟨ Make variable q + s newly independent 586 ⟩ Used in section 232. ⟨ Massage the heights, depths, and italic corrections 1126 ⟩ Used in section 1206.

⟨ Massage the widths 1124 ⟩ Used in section 1206. ⟨ Merge row pp into row p 368 ⟩ Used in section 366.

⟨ Merge the temp head list into sorted (h) 347 ⟩ Used in section 346.

⟨ Move right then up 319 ⟩ Used in sections 317 and 317.

⟨ Move the dependent variable p into both parts of the pair node r 947 ⟩ Used in section 946. ⟨ Move to next line of file, or goto restart if there is no next line 679 ⟩ Used in section 669.

⟨ Move to row n0 , pointed to by p 377 ⟩ Used in sections 375, 376, 381, 382, 383, and 384.

⟨ Move to the next remaining triple (p, q, r), removing and skipping past zero-length lines that might be

present; goto done if all triples have been processed 532 ⟩ Used in section 531. ⟨ Move to the right m steps 316 ⟩ Used in section 314.

⟨ Move up then right 320 ⟩ Used in sections 317 and 317. ⟨ Move upward n steps 315 ⟩ Used in section 314.

⟨ Multiply when at least one operand is known 942 ⟩ Used in section 941.

⟨ Multiply y by exp(−z/2^{27}) 136 ⟩ Used in section 135.

⟨ Negate the current expression 903 ⟩ Used in section 898. ⟨ Normalize the given direction for better accuracy; but return with zero result if it’s zero 540 ⟩

Used in section 539. ⟨ Numbered cases for debug help 1213 ⟩ Used in section 1212.

⟨ Other local variables for disp edges 580 ⟩ Used in section 577.

⟨ Other local variables for fill envelope 511 ⟩ Used in sections 506 and 518.

⟨ Other local variables for find direction time 542 ⟩ Used in section 539. ⟨ Other local variables for make choices 280 ⟩ Used in section 269. ⟨ Other local variables for make spec 453 ⟩ Used in section 402. ⟨ Other local variables for offset prep 495 ⟩ Used in section 491.

⟨ Other local variables for scan primary 831, 836, 843 ⟩ Used in section 823.

⟨ Other local variables for solve choices 286 ⟩ Used in section 284. ⟨ Other local variables for xy swap edges 357, 363 ⟩ Used in section 354. ⟨ Output statistics about this job 1208 ⟩ Used in section 1205*. ⟨ Output the answer, v (which might have become known) 934 ⟩ Used in section 932. ⟨ Output the character information bytes, then output the dimensions themselves 1136 ⟩ Used in section 1134. ⟨ Output the character represented in cur edges 1167 ⟩ Used in section 1165. ⟨ Output the extensible character recipes and the font metric parameters 1140 ⟩ Used in section 1134. ⟨ Output the ligature/kern program 1139 ⟩ Used in section 1134. ⟨ Output the pixels of edge row p to font row n 1169* ⟩ Used in section 1167. ⟨ Output the subfile sizes and header bytes 1135 ⟩ Used in section 1134.

⟨ Pack the numeric and fraction parts of a numeric token and return 675 ⟩ Used in section 669. ⟨ Plug an opening in right type(pp), if possible 889 ⟩ Used in section 887. ⟨ Plug an opening in right type(q), if possible 888 ⟩ Used in section 887.

⟨ Pop the condition stack 745 ⟩ Used in sections 748, 749, and 751.

⟨ Preface the output with a part specifier; return in the case of a capsule 237 ⟩ Used in section 235. ⟨ Prepare for and switch to the appropriate case, based on octant 380 ⟩ Used in section 378. ⟨ Prepare for derivative computations; goto not found if the current cubic is dead 496 ⟩ Used in section 494. ⟨ Prepare for step-until construction and goto done 765 ⟩ Used in section 764. ⟨ Pretend we’re reading a new one-line file 717 ⟩ Used in section 716. ⟨ Print a line of diagnostic info to introduce this octant 509 ⟩ Used in section 508. ⟨ Print an abbreviated value of v with format depending on t 802 ⟩ Used in section 801. ⟨ Print control points between p and q, then goto done1 261 ⟩ Used in section 258. ⟨ Print information for a curve that begins curl or given 263 ⟩ Used in section 258. ⟨ Print information for a curve that begins open 262 ⟩ Used in section 258. ⟨ Print information for adjacent knots p and q 258 ⟩ Used in section 257. ⟨ Print location of current line 637 ⟩ Used in section 636. ⟨ Print newly busy locations 184 ⟩ Used in section 180. ⟨ Print string cur exp as an error message 1086 ⟩ Used in section 1082. ⟨ Print string r as a symbolic token and set c to its class 223 ⟩ Used in section 218. ⟨ Print tension between p and q 260 ⟩ Used in section 258. ⟨ Print the banner line, including the date and time 790* ⟩ Used in section 788*. ⟨ Print the coefficient, unless it’s ±1.0 590 ⟩ Used in section 589. ⟨ Print the cubic between p and q 397 ⟩ Used in section 394. ⟨ Print the current loop value 639 ⟩ Used in section 638. ⟨ Print the help information and goto continue 84 ⟩ Used in section 79*. ⟨ Print the menu of available options 80 ⟩ Used in section 79*. ⟨ Print the name of a vardef’d macro 640 ⟩ Used in section 638. ⟨ Print the string err help, possibly on several lines 85 ⟩ Used in sections 84 and 86. ⟨ Print the turns, if any, that start at q, and advance q 401 ⟩ Used in sections 398 and 398. ⟨ Print the unskewed and unrotated coordinates of node ww 474 ⟩ Used in section 473. ⟨ Print two dots, followed by given or curl if present 259 ⟩ Used in section 257. ⟨ Print two lines using the tricky pseudoprinted information 643 ⟩ Used in section 636. ⟨ Print type of token list 638 ⟩ Used in section 636.

⟨ Process a skip to command and goto done 1110 ⟩ Used in section 1107.

⟨ Protest division by zero 838 ⟩ Used in section 837. ⟨ Pseudoprint the line 644 ⟩ Used in section 636. ⟨ Pseudoprint the token list 645 ⟩ Used in section 636. ⟨ Push the condition stack 744 ⟩ Used in section 748. ⟨ Put a string into the input buffer 716 ⟩ Used in section 707.

⟨ Put each of ’s primitives into the hash table 192, 211, 683, 688, 695, 709, 740, 893, 1013, 1018, 1024,

1027, 1037, 1052, 1079, 1101, 1108, 1176 ⟩ Used in section 1210.

⟨ Put help message on the transcript file 86 ⟩ Used in section 77. ⟨ Put the current transform into cur exp 955 ⟩ Used in section 953. ⟨ Put the desired file name in (cur name, cur ext , cur area) 795 ⟩ Used in section 793*. ⟨ Put the left bracket and the expression back to be rescanned 847 ⟩ Used in sections 846 and 859. ⟨ Put the list sorted (p) back into sort 345 ⟩ Used in section 344. ⟨ Put the post-join direction information into x and t 880 ⟩ Used in section 874. ⟨ Put the pre-join direction information into node q 879 ⟩ Used in section 874. ⟨ Read a string from the terminal 897 ⟩ Used in section 895. ⟨ Read next line of file into buffer , or goto restart if the file has ended 681 ⟩ Used in section 679. ⟨ 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 794 ⟩ Used in section 793*. ⟨ Read the other strings from the file and return true, or give an error message and return false 51* ⟩

Used in section 47.

⟨ Record a label in a lig/kern subprogram and goto continue 1111 ⟩ Used in section 1107. ⟨ Record a line segment from (xx , yy ) to (xp, yp) dually in env move 522 ⟩ Used in section 521. ⟨ Record a line segment from (xx , yy ) to (xp, yp) in env move 516 ⟩ Used in section 515. ⟨ Record a new maximum coefficient of type t 814 ⟩ Used in section 812. ⟨ Record a possible transition in column m 583 ⟩ Used in section 582.

⟨ Recycle a big node 810 ⟩ Used in section 809.

⟨ Recycle a dependency list 811 ⟩ Used in section 809. ⟨ Recycle an independent variable 812 ⟩ Used in section 809. ⟨ Recycle any sidestepped independent capsules 925 ⟩ Used in section 922. ⟨ Reduce comparison of big nodes to comparison of scalars 939 ⟩ Used in section 936. ⟨ Reduce to simple case of straight line and return 302 ⟩ Used in section 285. ⟨ Reduce to simple case of two givens and return 301 ⟩ Used in section 285. ⟨ Reduce to the case that a, c ≥ 0, b, d > 0 118 ⟩ Used in section 117. ⟨ Reduce to the case that f ≥ 0 and q > 0 110 ⟩ Used in sections 109 and 112. ⟨ Reflect the edge-and-weight data in sorted (p) 339 ⟩ Used in section 337. ⟨ Reflect the edge-and-weight data in unsorted (p) 338 ⟩ Used in section 337. ⟨ Remove a subproblem for make moves from the stack 312 ⟩ Used in section 311.

⟨ Remove dead cubics 447 ⟩ Used in section 402.

⟨ Remove the left operand from its container, negate it, and put it into dependency list p with constant

term q 1007 ⟩ Used in section 1006.

⟨ Remove the line from p to q, and adjust vertex q to introduce a new line 534 ⟩ Used in section 531. ⟨ Remove open types at the breakpoints 282 ⟩ Used in section 278.

⟨ Repeat a loop 712 ⟩ Used in section 707.

⟨ Replace an interval of values by its midpoint 1122 ⟩ Used in section 1121*. ⟨ Replace a by an approximation to \sqrt{a^{2} + b^{2}} 125 ⟩ Used in section 124. ⟨ Replace a by an approximation to \sqrt{a^{2} − b^{2}} 127 ⟩ Used in section 126. ⟨ Replicate every row exactly s times 341 ⟩ Used in section 340. ⟨ Report an unexpected problem during the choice-making 270 ⟩ Used in section 269. ⟨ Report overflow of the input buffer, and abort 34 ⟩ ⟨ Report redundant or inconsistent equation and goto done 1004 ⟩ Used in section 1003. ⟨ Return an appropriate answer based on z and octant 141 ⟩ Used in section 139. ⟨ Revise the values of α, β, γ, if necessary, so that degenerate lines of length zero will not be obtained 529 ⟩

Used in section 528.

⟨ Rotate the cubic between p and q; then goto found if the rotated cubic travels due east at some time tt ;

but goto not found if an entire cyclic path has been traversed 541 ⟩ Used in section 539. ⟨ Run through the dependency list for variable t, fixing all nodes, and ending with final link q 605 ⟩

Used in section 604. ⟨ Save string cur exp as the err help 1083 ⟩ Used in section 1082.

⟨ Scale the x coordinates of each row by s 343 ⟩ Used in section 342. ⟨ Scale the edges, shift them, and return 964 ⟩ Used in section 963. ⟨ Scale up del1 , del2 , and del3 for greater accuracy; also set del to the first nonzero element of

(del1 , del2 , del3 ) 408 ⟩ Used in sections 407, 413, and 420.

⟨ Scan a binary operation with ‘of’ between its operands 839 ⟩ Used in section 823. ⟨ Scan a bracketed subscript and set cur cmd ← numeric token 861 ⟩ Used in section 860. ⟨ Scan a curl specification 876 ⟩ Used in section 875. ⟨ Scan a delimited primary 826 ⟩ Used in section 823. ⟨ Scan a given direction 877 ⟩ Used in section 875. ⟨ Scan a grouped primary 832 ⟩ Used in section 823. ⟨ Scan a mediation construction 859 ⟩ Used in section 823.

⟨ Scan a nullary operation 834 ⟩ Used in section 823. ⟨ Scan a path construction operation; but return if p has the wrong type 869 ⟩ Used in section 868. ⟨ Scan a primary that starts with a numeric token 837 ⟩ Used in section 823. ⟨ Scan a string constant 833 ⟩ Used in section 823. ⟨ Scan a suffix with optional delimiters 735 ⟩ Used in section 733. ⟨ Scan a unary operation 835 ⟩ Used in section 823. ⟨ Scan a variable primary; goto restart if it turns out to be a macro 844 ⟩ Used in section 823. ⟨ Scan an expression followed by ‘of ⟨primary⟩’ 734 ⟩ Used in section 733. ⟨ Scan an internal numeric quantity 841 ⟩ Used in section 823. ⟨ Scan file name in the buffer 787* ⟩ Used in section 786. ⟨ Scan for a subscript; replace cur cmd by numeric token if found 846 ⟩ Used in section 844. ⟨ Scan the argument represented by info(r) 729 ⟩ Used in section 726. ⟨ Scan the delimited argument represented by info(r) 726 ⟩ Used in section 725. ⟨ Scan the loop text and put it on the loop control stack 758 ⟩ Used in section 755. ⟨ Scan the remaining arguments, if any; set r to the first token of the replacement text 725 ⟩

Used in section 720.

⟨ Scan the second of a pair of numerics 830 ⟩ Used in section 826. ⟨ Scan the token or variable to be defined; set n, scanner status , and warning info 700 ⟩ Used in section 697. ⟨ Scan the values to be used in the loop 764 ⟩ Used in section 755. ⟨ Scan undelimited argument(s) 733 ⟩ Used in section 725. ⟨ Scold the user for having an extra endfor 708 ⟩ Used in section 707. ⟨ Search eqtb for equivalents equal to p 209 ⟩ Used in section 185. ⟨ Send nonzero offsets to the output file 1166 ⟩ Used in section 1165. ⟨ Send the current expression as a title to the output file 1179 ⟩ Used in section 994. ⟨ Set explicit control points 884 ⟩ Used in section 881. ⟨ Set explicit tensions 882 ⟩ Used in section 881.

⟨ Set initial values of key variables 21, 22*, 23, 69, 72, 75, 92, 98, 131, 138, 179, 191, 199*, 202, 231, 251, 396, 428, 449,

456, 462, 570, 573, 593, 739, 753, 797, 822, 1078, 1085, 1097, 1150, 1153, 1184, 1215* ⟩ Used in section 4.

⟨ Set local variables x1 , x2 , x3 and y1 , y2 , y3 to multiples of the control points of the rotated derivatives 543 ⟩

Used in section 541.

⟨ Set the current expression to the desired path coordinates 987 ⟩ Used in section 985. ⟨ Set up equation for a curl at θ_{n} and goto found 295 ⟩ Used in section 284. ⟨ Set up equation to match mock curvatures at z_{k}; then goto found with θ_{n} adjusted to equal θ_{0}, if a cycle

has ended 287 ⟩ Used in section 284.

⟨ Set up suffixed macro call and goto restart 854 ⟩ Used in section 852. ⟨ Set up the culling weights, or goto not found if the thresholds are bad 1075 ⟩ Used in section 1074. ⟨ Set up the equation for a curl at θ_{0} 294 ⟩ Used in section 285. ⟨ Set up the equation for a given value of θ_{0} 293 ⟩ Used in section 285. ⟨ Set up the parameters needed for paint row ; but goto done if no painting is needed after all 582 ⟩

Used in section 578.

⟨ Set up the variables (del1 , del2 , del3 ) to represent x′ − y′ 421 ⟩ Used in section 420. ⟨ Set up unsuffixed macro call and goto restart 853 ⟩ Used in section 845. ⟨ Set variable q to the node at the end of the current octant 466 ⟩ Used in sections 465, 506, and 506. ⟨ Set variable z to the arg of (x, y) 142 ⟩ Used in section 139. ⟨ Shift the coordinates of path q 867 ⟩ Used in section 866. ⟨ Shift the edges by (tx , ty ), rounded 965* ⟩ Used in section 964. ⟨ Show a numeric or string or capsule token 1042 ⟩ Used in section 1041. ⟨ Show the text of the macro being expanded, and the existing arguments 721 ⟩ Used in section 720. ⟨ Show the transformed dependency 817 ⟩ Used in section 816. ⟨ Sidestep independent cases in capsule p 926 ⟩ Used in section 922. ⟨ Sidestep independent cases in the current expression 927 ⟩ Used in section 922. ⟨ Simplify all existing dependencies by substituting for x 614 ⟩ Used in section 610.

⟨ Skip down prev n − n rows 1174 ⟩ Used in section 1172. ⟨ Skip to elseif or else or fi, then goto done 749 ⟩ Used in section 748.

⟨ Skip to column m in the next row and goto done, or skip zero rows 1173 ⟩ Used in section 1172. ⟨ Sort p into the list starting at rover and advance p to rlink (p) 174 ⟩ Used in section 173. ⟨ Splice independent paths together 890 ⟩ Used in section 887. ⟨ Split off another rising cubic for fin offset prep 504 ⟩ Used in section 503. ⟨ Split the cubic at t, and split off another cubic if the derivative crosses back 499 ⟩ Used in section 497. ⟨ Split the cubic between p and q, if necessary, into cubics associated with single offsets, after which q should

point to the end of the final such cubic 494 ⟩ Used in section 491. ⟨ Squeal about division by zero 950 ⟩ Used in section 948. ⟨ Stamp all nodes with an octant code, compute the maximum offset, and set hh to the node that begins

the first octant; goto not found if there’s a problem 479 ⟩ Used in section 477.

⟨ Start a new row at (m, n) 1172 ⟩ Used in section 1170. ⟨ Start black at (m, n) 1170 ⟩ Used in section 1169*.

⟨ Stash an independent cur exp into a big node 829 ⟩ Used in section 827.

⟨ Stop black at (m, n) 1171 ⟩ Used in section 1169*.

⟨ Store a list of font dimensions 1115 ⟩ Used in section 1106. ⟨ Store a list of header bytes 1114 ⟩ Used in section 1106. ⟨ Store a list of ligature/kern steps 1107 ⟩ Used in section 1106. ⟨ Store the width information for character code c 1099 ⟩ Used in section 1070. ⟨ Subdivide all cubics between p and q so that the results travel toward the first quadrant; but return or

goto continue if the cubic from p to q was dead 413 ⟩ Used in section 406. ⟨ Subdivide for a new level of intersection 559 ⟩ Used in section 556. ⟨ Subdivide the cubic a second time with respect to x′ 412 ⟩ Used in section 411. ⟨ Subdivide the cubic a second time with respect to x′ − y′ 425 ⟩ Used in section 424. ⟨ Subdivide the cubic a second time with respect to y′ 416 ⟩ Used in section 415. ⟨ Subdivide the cubic between p and q so that the results travel toward the first octant 420 ⟩

Used in section 419.

⟨ Subdivide the cubic between p and q so that the results travel toward the right halfplane 407 ⟩

Used in section 406.

⟨ Subdivide the cubic with respect to x′, possibly twice 411 ⟩ Used in section 407. ⟨ Subdivide the cubic with respect to x′ − y′, possibly twice 424 ⟩ Used in section 420. ⟨ Subdivide the cubic with respect to y′, possibly twice 415 ⟩ Used in section 413. ⟨ Substitute for cur sym, if it’s on the subst list 686 ⟩ Used in section 685. ⟨ Substitute new dependencies in place of p 818 ⟩ Used in section 815. ⟨ Substitute new proto-dependencies in place of p 819 ⟩ Used in section 815. ⟨ Subtract angle z from (x, y) 147 ⟩ Used in section 145. ⟨ Supply diagnostic information, if requested 825 ⟩ Used in section 823. ⟨ Swap the x and y coordinates of the cubic between p and q 423 ⟩ Used in section 420. ⟨ Switch to the right subinterval 318 ⟩ Used in section 317. ⟨ Tell the user what has run away and try to recover 663 ⟩ Used in section 661. ⟨ Terminate the current conditional and skip to fi 751 ⟩ Used in section 707. ⟨ The arithmetic progression has ended 761 ⟩ Used in section 760. ⟨ Trace the current assignment 998 ⟩ Used in section 996. ⟨ Trace the current binary operation 924 ⟩ Used in section 922. ⟨ Trace the current equation 997 ⟩ Used in section 995. ⟨ Trace the current unary operation 902 ⟩ Used in section 898. ⟨ Trace the fraction multiplication 945 ⟩ Used in section 944. ⟨ Trace the start of a loop 762 ⟩ Used in section 760. ⟨ Transfer moves dually from the move array to env move 520 ⟩ Used in section 518. ⟨ Transfer moves from the move array to env move 514 ⟩ Used in section 512. ⟨ Transform a known big node 970 ⟩ Used in section 966.

⟨ Transform an unknown big node and return 967 ⟩ Used in section 966. ⟨ Transform known by known 973 ⟩ Used in section 970. ⟨ Transform the skewed coordinates 444 ⟩ Used in section 440. ⟨ Transform the x coordinates 436 ⟩ Used in section 433. ⟨ Transform the y coordinates 439 ⟩ Used in section 433. ⟨ Treat special case of length 1 and goto found 206 ⟩ Used in section 205. ⟨ Truncate the values of all coordinates that exceed max allowed , and stamp segment numbers in each

left type field 404 ⟩ Used in section 402.

⟨ Try to allocate within node p and its physical successors, and goto found if allocation was possible 169* ⟩

Used in section 167.

⟨ Try to get a different log file name 789 ⟩ Used in section 788*.

⟨ Types in the outer block 18, 24*, 37, 101, 105, 106, 156*, 186, 565, 571, 627, 1151 ⟩ Used in section 4.

⟨ Undump a few more things and the closing check word 1199* ⟩ Used in section 1187. ⟨ Undump constants for consistency check 1191* ⟩ Used in section 1187. ⟨ Undump the dynamic memory 1195 ⟩ Used in section 1187.

⟨ Undump the string pool 1193 ⟩ Used in section 1187.

⟨ Undump the table of equivalents and the hash table 1197 ⟩ Used in section 1187. ⟨ Update the max/min amounts 351 ⟩ Used in section 349. ⟨ Use bisection to find the crossing point, if one exists 392 ⟩ Used in section 391. ⟨ Wind up the paint row parameter calculation by inserting the final transition; goto done if no painting is

needed 584 ⟩ Used in section 582.

⟨ Worry about bad statement 990 ⟩ Used in section 989.

Section Page

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 3 2. The character set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 6 3. Input and output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 7 4. String handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 9 5. On-line and off-line printing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 10 6. Reporting errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 11 7. Arithmetic with scaled numbers . . . . . . . . . . . . . . . . . . . . . . . . . . 95 12 8. Algebraic and transcendental functions . . . . . . . . . . . . . . . . . . . 120 12 9. Packed data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 12 10. Dynamic memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 13 11. Memory layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 14 12. The command codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 15 13. The hash table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 16 14. Token lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 16 15. Data structures for variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 16 16. Saving and restoring equivalents . . . . . . . . . . . . . . . . . . . . . . . . 250 16 17. Data structures for paths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 16 18. Choosing control points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 16 19. Generating discrete moves . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 16 20. Edge structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323 16 21. Subdivision into octants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 16 22. Filling a contour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460 16 23. Polygonal pens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469 16 24. Filling an envelope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490 16 25. Elliptical pens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524 16 26. Direction and intersection times . . . . . . . . . . . . . . . . . . . . . . . . . 538 16 27. Online graphic output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564 16 28. Dynamic linear equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585 17 29. Dynamic nonlinear equations . . . . . . . . . . . . . . . . . . . . . . . . . . . 618 17 30. Introduction to the syntactic routines . . . . . . . . . . . . . . . . . . . . 624 17 31. Input stacks and states . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627 17 32. Maintaining the input stacks . . . . . . . . . . . . . . . . . . . . . . . . . . . 647 17 33. Getting the next token . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658 17 34. Scanning macro definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683 17 35. Expanding the next token . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706 17 36. Conditional processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 738 17 37. Iterations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 752 17 38. File names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766 17 39. Introduction to the parsing routines . . . . . . . . . . . . . . . . . . . . . 796 21 40. Parsing primary expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823 21 41. Parsing secondary and higher expressions . . . . . . . . . . . . . . . . 862 21 42. Doing the operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 893 21 43. Statements and commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 989 22 44. Commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1020 22 45. Font metric data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1087 22 46. Generic font file format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1142 23 47. Shipping characters out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1149 23 48. Dumping and undumping the tables . . . . . . . . . . . . . . . . . . . . 1183 24 49. The main program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1202 26 50. Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1212 28 51. System-dependent changes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1214 28 52. Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1216 29