0 $SET $ ASCII                                                            00000100           
1                                                                         00000800           
2 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -    00000900           
3                                                                         00001000           
4           PROSE - A TEXT FORMATTING TOOL.                               00001100           
5           J. P. STRAIT.      77/06/05.                                  00001200           
6           COPYRIGHT (C) 1977, 1979.                                     00001300           
7           ALL RIGHTS RESERVED.                                          00001400           
8                                                                         00001500           
9                                                                         00001600           
10                                                                         00001700           
11                                                                         00001800           
12           PROSE IS A FORMATTING PROGRAM, DESIGNED FOR DOCUMENT          00001900           
13 PREPARATION.  IT IS WRITTEN IN PASCAL AND IS IMPLEMENTED IN SUCH        00002000           
14 A WAY AS TO ENCOURAGE TRANSPORTATION BETWEEN DIFFERENT HARDWARE AND     00002100           
15 DIFFERENT OPERATING SYSTEMS.                                            00002200           
16                                                                         00002300           
17           PROSE WAS DEVELOPED IN THE SPRING OF 1977, AND DRAWS          00002400           
18 VERY HEAVILY FROM TYPESET, A FORMATTING PROGRAM WRITTEN BY MICHAEL      00002500           
19 HUCK.  TYPESET, WRITTEN IN COMPASS (THE CDC 6000/CYBER SERIES           00002600           
20 ASSEMBLY LANGUAGE), WAS IN TURN BASED ON EDIT-RUNOFF.  THUS             00002700           
21 IS ONE OF THE MANY DESCENDANTS OF RUNOFF.                               00002800           
22                                                                         00002900           
23           COMPLETE EXTERNAL DOCUMENTATION IS AVAILABLE, AND IT IS       00003000           
24 MAINTAINED IN PROSE FORM.  REFER TO THAT FOR AN OVERVIEW OF      .      00003100           
25                                                                         00003200           
26           IN STRIVING FOR PORTABILITY, THE DECISION WAS MADE TO         00003300           
27 REPRESENT TEXT INTERNALLY IN ASCII.  THIS MEANS THAT TO TRANSPORT       00003400           
28 THIS PROGRAM, ONE INPUT ROUTINE AND ONE OUTPUT ROUTINE MUST BE          00003500           
29 REWRITTEN TO TRANSLATE BETWEEN THE HOST CHARACTER SET AND ASCII.        00003600           
30 OTHER SYSTEM DEPENDANT DETAILS SUCH AS THE DATE AND CLOCK FUNCTIONS     00003700           
31 MUST BE CONSIDERED FOR TRANSPORTATION OF THIS PROGRAM.  ALL AREAS       00003800           
32 WHICH NEED ATTENTION WHEN CONVERTING THIS PROGRAM FROM THE CDC 6000     00003900           
33 VERSION ARE MARKED WITH NULL COMMENTS ( * * ) IN COLUMNS 69-72.         00004000           
34                                                                         00004100           
35           THIS VERSION OF PROSE READS AND WRITES THE CDC ASCII 63       00004200           
36 CHARACTER SET.  IF YOU RUN SOME OTHER CHARACTER SET, YOU MAY WISH       00004300           
37 TO CONVERT THE INPUT/OUTPUT ROUTINES TO PROCESS THAT CHARACTER SET.     00004400           
38                                                                         00004500           
39  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00004600           
40                                                                         00004700           
41                                                                         00004800           
42 PROGRAM PROSE(INFILE,OUTPUT+,INPUT/);                               (**)00004900           
43                                                                         00005000           
44                                                                         00005100           
45                                                                         00005200           
46 CONST                                                                   00005300           
47                                                                         00005400           
48  INFINITY        = 1000;     (* LARGEST NUMBER + 1 *)                   00005500           
49  MAINTITLE       = TRUE;     (* TITLE INDICATOR *)                      00005600           
50  MAXINXLENGTH    = 60;       (* MAX LENGTH OF INDEX ENTRIES *)          00005700           
51  MAXIWIDTH       = 200;      (* MAXIMUN INPUT WIDTH *)                  00005800           
52  MAXKEEP         = 9;        (* MAXIMUM KEEP VALUE *)                   00005900           
53  MAXMARGIN       = 200;      (* LARGEST RIGHT MARGIN *)                 00006000           
54  MAXNUMBERWIDTH  = 12;       (* MAX NUMBER OF DIGITS IN A NUMBER *)     00006100           
55  MAXOWIDTH       = 200;      (* MAXIMUM OUTPUT WIDTH *)                 00006200           
56  MAXPAGE         = 999;      (* MAXIMUM PAGE NUMBER *)                  00006300           
57  MAXPITCH        = 20;       (* MAX PITCH FOR AJ TERMINAL *)            00006400           
58  MAXSHIFT        = 50;       (* MAX OUTPUT SHIFT *)                     00006500           
59  MAXSKIP         = 100;      (* MAXIMUM SKIP COUNT *)                   00006600           
60  MAXSPLIT        = 20;       (* MAXIMUM NUMBER OF SPLIT POINTS *)       00006700           
61  MAXSTRINGLENGTH = 222;      (* MAX LENGTH OF TEXT LINES *)             00006800           
62  MIN             = 10;       (* GENERAL REASONABLE MIMIMUM *)           00006900           
63  MINPITCH        = 5;        (* MINIMUM PITCH FOR AJ TERMINAL *)        00007000           
64  SUBTITLE        = FALSE;    (* SUBTITLE INDICATOR *)                   00007100           
65                                                                         00007200           
66 (* CERTAIN CONSTRAINTS ARE APPLIED TO THE MIN/MAX VALUES,     *)        00007300           
67 (* TO ELIMINATE ARRAY OVERFLOW CHECKS AND OTHER ERROR CHECKS: *)        00007400           
68 (*                                                            *)        00007500           
69 (*      MAXSTRINGLENGTH >= MAXIWIDTH + MAXNUMBERWIDTH + 2     *)        00007600           
70 (*      MAXMARGIN       <= MAXSTRINGLENGTH - 2                *)        00007700           
71 (*      (EVERYTHING)    <  INFINITY                           *)        00007800           
72 (*      (EVERYTHING)    >  (REASONABLE)                       *)        00007900           
73                                                                         00008000           
74 (* THE ASCII CHARACTER SET: *)                                          00008100           
75                                                                         00008200           
76  NUL = 0;       BLANK = 32;          AT = 64;        GRAV = 96;         00008300           
77  SOH = 1;     EXCLAIM = 33;           A = 65;      SMALLA = 97;         00008400           
78  STX = 2;      DQUOTE = 34;           B = 66;      SMALLB = 98;         00008500           
79  ETX = 3;        HASH = 35;           C = 67;      SMALLC = 99;         00008600           
80  EOT = 4;      DOLLAR = 36;           D = 68;      SMALLD = 100;        00008700           
81  ENQ = 5;     PERCENT = 37;           E = 69;      SMALLE = 101;        00008800           
82  ACK = 6;   AMPERSAND = 38;           F = 70;      SMALLF = 102;        00008900           
83  BEL = 7;      SQUOTE = 39;           G = 71;      SMALLG = 103;        00009000           
84   BS = 8;      LPAREN = 40;           H = 72;      SMALLH = 104;        00009100           
85   HT = 9;      RPAREN = 41;           I = 73;      SMALLI = 105;        00009200           
86   LF = 10;        STAR = 42;           J = 74;      SMALLJ = 106;       00009300           
87   VT = 11;        PLUS = 43;           K = 75;      SMALLK = 107;       00009400           
88   FF = 12;       COMMA = 44;           L = 76;      SMALLL = 108;       00009500           
89   CR = 13;       MINUS = 45;           M = 77;      SMALLM = 109;       00009600           
90   SO = 14;      PERIOD = 46;           N = 78;      SMALLN = 110;       00009700           
91   SI = 15;       SLASH = 47;           O = 79;      SMALLO = 111;       00009800           
92  DLE = 16;        ZERO = 48;           P = 80;      SMALLP = 112;       00009900           
93  DC1 = 17;         ONE = 49;           Q = 81;      SMALLQ = 113;       00010000           
94  DC2 = 18;         TWO = 50;           R = 82;      SMALLR = 114;       00010100           
95  DC3 = 19;       THREE = 51;           S = 83;      SMALLS = 115;       00010200           
96  DC4 = 20;        FOUR = 52;           T = 84;      SMALLT = 116;       00010300           
97  NAK = 21;        FIVE = 53;           U = 85;      SMALLU = 117;       00010400           
98  SYN = 22;         SIX = 54;           V = 86;      SMALLV = 118;       00010500           
99  ETB = 23;       SEVEN = 55;           W = 87;      SMALLW = 119;       00010600           
100  CAN = 24;       EIGHT = 56;           X = 88;      SMALLX = 120;       00010700           
101   EM = 25;        NINE = 57;           Y = 89;      SMALLY = 121;       00010800           
102  SUB = 26;       COLON = 58;           Z = 90;      SMALLZ = 122;       00010900           
103  ESC = 27;   SEMICOLON = 59;    LBRACKET = 91;      LBRACE = 123;       00011000           
104   FS = 28;        LESS = 60;   BACKSLASH = 92; VERTICALBAR = 124;       00011100           
105   GS = 29;       EQUAL = 61;    RBRACKET = 93;      RBRACE = 125;       00011200           
106   RS = 30;     GREATER = 62;       CARET = 94;       TILDE = 126;       00011300           
107   US = 31;    QUESTION = 63;  UNDERSCORE = 95;         DEL = 127;       00011400           
108                                                                         00011500           
109                                                                         00011600           
110                                                                         00011700           
111 TYPE                                                                    00011800           
112                                                                         00011900           
113  ALFA = PACKED ARRAY [1..10] OF CHAR;                                   00011920           
114                                                                         00011930           
115  ASCII = 0..127;                                                        00012000           
116                                                                         00012100           
117  ASCIIX = 0..255;  (* THE TYPE ASCII IS EXTENDED FOR INTERNAL USE   *)  00012200           
118                     (* IN THE FOLLOWING MANNER:                      *) 00012300           
119                     (*                                               *) 00012400           
120                     (* C + 128      INDICATES THAT C IS UNDERLINED. *)  00012500           
121                                                                         00012600           
122  ASCII2HOST = PACKED RECORD                                         (**)00012700           
123   C              : CHAR;     (* EXTERNAL CHARACTER *)               (**)00012800           
124   CHR74          : BOOLEAN;  (* IF A 74 ESCAPE IS REQUIRED *)       (**)00012900           
125   CHR76          : BOOLEAN   (* IF A 76 ESCAPE IS REQUIRED *)       (**)00013000           
126   END;                                                              (**)00013100           
127                                                                         00013200           
128  CHARCLASS = PACKED RECORD                                              00013300           
129   DIGIT          : BOOLEAN;  (* ZERO..NINE *)                           00013400           
130   FORMCHAR       : BOOLEAN;  (* C,D,E,L,P,S,T,W,HASH,LBRACKET,RBRACKET, 00013500           
131                                 SLASH,DQUOTE,SQUOTE,RPAREN,BLANK *)     00013600           
132   INPUTCHAR      : BOOLEAN;  (* B,C,D,H,K,U,W,BLANK *)                  00013700           
133   LETTER         : BOOLEAN;  (* A..Z,SMALLA..SMALLZ *)                  00013800           
134   MARGINCHAR     : BOOLEAN;  (* K,L,R,BLANK *)                          00013900           
135   NUMFORM        : BOOLEAN;  (* N,SMALLN,L,SMALLL,R,SMALLR,BLANK *)     00014000           
136   OPTIONCHAR     : BOOLEAN;  (* E,F,J,K,L,M,P,R,S,U,BLANK *)            00014100           
137   OUTPUTCHAR     : BOOLEAN;  (* E,P,S,U,W,BLANK *)                      00014200           
138   PARAGRAPHCHAR    : BOOLEAN;  (* C,I,K,N,P,U,BLANK *)                  00014300           
139   PLUSORMINUS    : BOOLEAN;  (* PLUS,MINUS *)                           00014400           
140   QUOTE          : BOOLEAN;  (* DQUOTE,SQUOTE *)                        00014500           
141   SORTINXCHAR    : BOOLEAN;  (* L,M,P,R,S,BLANK *)                      00014600           
142   END;                                                                  00014700           
143                                                                         00014800           
144  CH3 = PACKED ARRAY[1..3] OF ASCIIX;                                    00014900           
145                                                                         00015000           
146  CH10 = PACKED ARRAY[1..10] OF ASCIIX;                                  00015100           
147                                                                         00015200           
148  DIRECT = (BRE,              (* BREAK *)                                00015300           
149            COM,              (* COMMENT *)                              00015400           
150            COU,              (* COUNT *)                                00015500           
151            FRM,              (* FORM *)                                 00015600           
152            IND,              (* INDENT *)                               00015700           
153            INP,              (* INPUT *)                                00015800           
154            INX,              (* INX *)                                  00015900           
155            LIT,              (* LITERAL *)                              00016000           
156            MAR,              (* MARGIN *)                               00016100           
157            OPT,              (* OPTION *)                               00016200           
158            OUT,              (* OUTPUT *)                               00016300           
159            PAG,              (* PAGE *)                                 00016400           
160            PAR,              (* PARAGRAPH *)                            00016500           
161            RES,              (* RESET *)                                00016600           
162            SEL,              (* SELECT *)                               00016700           
163            SKI,              (* SKIP *)                                 00016800           
164            SOR,              (* SORTINDEX *)                            00016900           
165            SBT,              (* SUBTITLE *)                             00017000           
166            TTL,              (* TITLE *)                                00017100           
167            UND,              (* UNDENT *)                               00017200           
168            WEO,              (* WEOS *)                                 00017300           
169            EXC,              (* EXCEPT (USED BY RESET) *)               00017400           
170            ILL,              (* ILLEGAL *)                              00017500           
171                                                                         00017600           
172 (* THE FOLLOWING ARE NOT DIRECTIVES, BUT IT IS CONVENIENT *)            00017700           
173 (* TO INCLUDE THEM IN THIS TABLE.                         *)            00017800           
174                                                                         00017900           
175            AST,              (* ASCII TERMINAL *)                       00018000           
176            LPT,              (* LINE PRINTER *)                         00018100           
177            AJT,              (* ANDERSON/JACOBSON TERMINAL *)           00018200           
178            ILT);             (* ILLEGAL *)                              00018300           
179                                                                         00018400           
180  DIRSET = SET OF DIRECT;                                                00018500           
181                                                                         00018600           
182  INPUTSETTINGS = PACKED RECORD                                          00018700           
183   DEFINED   : BOOLEAN;                                                  00018800           
184   B,C,D,H,U : ASCII;                                                    00018900           
185   W         : 0..INFINITY                                               00019000           
186   END;                                                                  00019100           
187                                                                         00019200           
188  PINXENTRY = ^INXENTRY;                                                 00019300           
189  INXENTRY = RECORD                                                      00019400           
190   X    : PACKED ARRAY[1..MAXINXLENGTH] OF ASCIIX;                       00019500           
191   XL   : INTEGER;            (* LENGTH OF ENTRY *)                      00019600           
192   XP   : INTEGER;            (* PAGE NUMBER *)                          00019700           
193   NEXT : PINXENTRY                                                      00019800           
194   END;                                                                  00019900           
195                                                                         00020000           
196  MARGINSETTINGS = PACKED RECORD                                         00020100           
197   DEFINED : BOOLEAN;                                                    00020200           
198   L,R     : 0..INFINITY                                                 00020300           
199   END;                                                                  00020400           
200                                                                         00020500           
201  NUMBERFORM = (NUMERIC,UPPERALPHA,LOWERALPHA,UPPERROMAN,LOWERROMAN,     00020600           
202                NONUMBERING);                                            00020700           
203                                                                         00020800           
204  OPTIONSETTINGS = PACKED RECORD                                         00020900           
205   DEFINED       : BOOLEAN;                                              00021000           
206   E,F,L,M,P,R,U : BOOLEAN;                                              00021100           
207   J,S           : 0..INFINITY                                           00021200           
208   END;                                                                  00021300           
209                                                                         00021400           
210  PARAGRAPHSETTINGS = PACKED RECORD                                      00021500           
211   DEFINED : BOOLEAN;                                                    00021600           
212   C       : 0..INFINITY;                                                00021700           
213   F       : ASCII;                                                      00021800           
214   I       : -INFINITY..INFINITY;                                        00021900           
215   N       : NUMBERFORM;                                                 00022000           
216   P       : 0..INFINITY;                                                00022100           
217   S       : 0..INFINITY;                                                00022200           
218   W       : 0..INFINITY                                                 00022300           
219   END;                                                                  00022400           
220                                                                         00022500           
221  REMEMBER = 0..MAXKEEP;                                                 00022600           
222                                                                         00022700           
223  SPLITPOINT = PACKED RECORD                                             00022800           
224   POINT : 0..INFINITY;  (* POSITION OF SPLIT POINT WITHIN WORD *)       00022900           
225   INPNT : 0..INFINITY;  (* POSITION OF SPLIT POINT WITHIN INLINE *)     00023000           
226   HYPNT : BOOLEAN   (* SPLIT POINT REPRESENTS POSSIBLE HYPHEN *)        00023100           
227   END;                                                                  00023200           
228                                                                         00023300           
229  PSTRING = PACKED ARRAY[1..MAXSTRINGLENGTH] OF ASCIIX;                  00023400           
230                                                                         00023500           
231  STRING = ARRAY[1..MAXSTRINGLENGTH] OF  (* STR[1].C ALWAYS = ' ' *)     00023600           
232   PACKED RECORD                                                         00023700           
233    C   : ASCIIX;      (* CHARACTER *)                                   00023800           
234    NBL : 0..INFINITY  (* IF C=' ', NUMBER OF BLANKS, ELSE CHARWIDTH *)  00023900           
235    END;                                                                 00024000           
236                                                                         00024100           
237                                                                         00024200           
238                                                                         00024300           
239 VAR                                                                     00024400           
240                                                                         00024500           
241                                                                         00024600           
242  ACTUALCOLUMN    : INTEGER;  (* ACTUAL COLUMN OF PRINT HEAD (FOR AJ) *) 00024700           
243  ASC             : ARRAY[CHAR] OF ASCII;                            (**)00024800           
244                              (* CONVERT DISPLAY CODE TO ASCII *)    (**)00024900           
245  ASC74           : ARRAY[CHAR] OF ASCII;                            (**)00025000           
246                              (* CONVERT 74 ESCAPE CODE TO ASCII *)  (**)00025100           
247  ASC76           : ARRAY[CHAR] OF ASCII;                            (**)00025200           
248                              (* CONVERT 76 ESCAPE CODE TO ASCII *)  (**)00025300           
249  BADJUSTIFY      : INTEGER;  (* J OPTION *)                             00025400           
250  BLANKCOUNT      : INTEGER;  (* ACCUMULATED BLANK OUTPUT LINE COUNTER *)00025500           
251  BLANKLINE       : BOOLEAN;  (* BLANK OUTPUT LINE INDICATOR *)          00025600           
252  CARRIAGECONTROL : ASCII;    (* FOR LINE PRINTER OUTPUT *)              00025700           
253  CASECH          : ASCII;    (* C INPUT *)                              00025800           
254  CLASS           : ARRAY[ASCII] OF CHARCLASS;                           00025900           
255                              (* CHARACTER CLASSIFICATIONS *)            00026000           
256  CHARWIDTH       : INTEGER;  (* CHAR WIDTH IN PRINTER UNITS *)          00026100           
257  DIRCH           : ASCII;    (* D INPUT *)                              00026200           
258  DIRECTLINE      : BOOLEAN;  (* INPUT LINE IS A DIRECTIVE *)            00026300           
259  DIRECTS         : ARRAY[DIRECT] OF CH3;                                00026400           
260                              (* DIRECTIVE NAMES *)                      00026500           
261  EJECT           : BOOLEAN;  (* E OUTPUT *)                             00026600           
262  ENDOFINPUT      : BOOLEAN;  (* INTERNAL EOF INDICATOR *)               00026700           
263  ENSURE2         : BOOLEAN;  (* P OPTION *)                             00026800           
264  ERRORN1         : INTEGER;  (* ERROR IN NUMBER *)                      00026900           
265  ERRORN2         : INTEGER;  (* ERROR IN NUMBER *)                      00027000           
266  ERRORS          : BOOLEAN;  (* ERRORS IN THIS PROSE RUN *)             00027100           
267  ERRORSMALL      : BOOLEAN;  (* NUMBER IS TOO SMALL *)                  00027200           
268  ERROR1          : ASCIIX;   (* ERROR TEXT *)                           00027300           
269  ERROR10         : CH10;     (* ERROR TEXT *)                           00027400           
270  EOL             : BOOLEAN;  (* INTERNAL EOLN INDICATOR *)              00027500           
271  EXPLICITBLANK   : ASCII;    (* B INPUT *)                              00027600           
272  FILL            : BOOLEAN;  (* F OPTION *)                             00027700           
273  FIRSTERROR      : BOOLEAN;  (* FIRST ERROR ON THIS LINE *)             00027800           
274  FORM            : PSTRING;  (* FORM BUFFER *)                          00027900           
275  FORMINDEX       : INTEGER;  (* CURRENT FORM POSITION *)                00028000           
276  FORMLENGTH      : INTEGER;  (* FORM LENGTH *)                          00028100           
277  FORMNEXT        : PSTRING;  (* FORM FOR NEXT PAGE *)                   00028200           
278  FORMNLENGTH     : INTEGER;  (* LENGTH OF FORMNEXT *)                   00028300           
279  GAPS            : ARRAY[0..MAXSTRINGLENGTH] OF 1..MAXSTRINGLENGTH;     00028400           
280                              (* POINTERS TO WORD GAPS *)                00028500           
281  HOST            : ARRAY[ASCII] OF ASCII2HOST;                      (**)00028600           
282                              (* CONVERT ASCII TO DISPLAY CODE *)    (**)00028700           
283  HYPHEN          : ASCII;    (* H OPTION *)                             00028800           
284  INCHAR          : ASCIIX;   (* CURRENT INPUT CHARACTER *)              00028900           
285  INCOLUMN        : INTEGER;  (* CURRENT INPUT COLUMN *)                 00029000           
286  INFILE          : TEXT;     (* PROSE SOURCE INPUT FILE *)              00029100           
287  INLENGTH        : INTEGER;  (* LENGTH OF CURRENT INPUT LINE *)         00029200           
288  INLINE          : STRING;   (* CURRENT INPUT LINE *)                   00029300           
289  INWIDTH         : INTEGER;  (* W INPUT *)                              00029400           
290  INXBASE         : PINXENTRY;(* BASE OF INDEX ENTRY LIST *)             00029500           
291  INXLAST         : PINXENTRY;(* LAST INDEX ENTRY *)                     00029600           
292  KEEPINP         : INTEGER;  (* CURRENT INPUT KEEP BUFFER *)            00029700           
293  KEEPMAR         : INTEGER;  (* CURRENT MARGIN KEEP BUFFER *)           00029800           
294  KEEPOPT         : INTEGER;  (* CURRENT OPTION KEEP BUFFER *)           00029900           
295  KEEPPAR         : INTEGER;  (* CURRENT PARAGRAPH KEEP BUFFER *)        00030000           
296  LEFTJUSTIFY     : BOOLEAN;  (* L OPTION *)                             00030100           
297  LEFTMARGIN      : INTEGER;  (* L MARGIN *)                             00030200           
298  LINECOUNT       : INTEGER;  (* OUTPUT LINE COUNT (WITHIN PAGE) *)      00030300           
299  LINENUMBER      : INTEGER;  (* INPUT LINE COUNT (FOR ERROR MESSES) *)  00030400           
300  LINENUMS        : BOOLEAN;  (* LINE NUMBERS EXIST ON INPUT FILE *)     00030500           
301  LOCKEDDENT      : INTEGER;  (* I/U PARAGRAPH *)                        00030600           
302  LOWERCASE       : BOOLEAN;  (* FOR UPPER TO LOWER CASE CONVERSION *)   00030700           
303  LOWERDIR        : BOOLEAN;  (* LOWERCASE FLAG IN DIRECTIVES *)         00030800           
304  MONTHS          : ARRAY[1..12] OF CH3;                                 00030900           
305                              (* MONTH NAMES *)                          00031000           
306  MOREONLEFT      : BOOLEAN;  (* INDICATOR FOR JUSTIFYING *)             00031100           
307  MULTIPLEBLANKS  : BOOLEAN;  (* M OPTION *)                             00031200           
308  NBLANKS         : INTEGER;  (* BLANK COUNT ON INPUT *)                 00031300           
309  NCHARS          : INTEGER;  (* WIDTH OF OUTPUT LINE *)                 00031400           
310  NEWINLINE       : BOOLEAN;  (* BEGIN INPUT LINE INDICATOR *)           00031500           
311  NEWOUTLINE      : BOOLEAN;  (* BEGIN OUTPUT LINE INDICATOR *)          00031600           
312  NEWPARAGRAPH    : BOOLEAN;  (* BEGIN PARAGRAPH INDICATOR *)            00031700           
313  NEXTCOLUMN      : INTEGER;  (* DESIRED COLUMN TO PRINT (FOR AJ) *)     00031800           
314  NGAPS           : INTEGER;  (* NUMBER OF WORD GAPS *)                  00031900           
315  NICEDATE        : CH10;     (* DATE AS YY MMM DD *)                    00032000           
316  NSPLITS         : INTEGER;  (* NUMBER OF SPLIT POINTS IN WORD *)       00032100           
317  NWORDS          : INTEGER;  (* NUMBER OF WORDS IN OUTPUT LINE *)       00032200           
318  NUMBERING       : NUMBERFORM;                                          00032300           
319                              (* N PARAGRAPH *)                          00032400           
320  NUMBERWIDTH     : INTEGER;  (* N PARAGRAPH *)                          00032500           
321  OUTLENGTH       : INTEGER;  (* LENGTH OF OUTPUT LINE *)                00032600           
322  OUTLINE         : STRING;   (* OUTPUT LINE *)                          00032700           
323  OUTWIDTH        : INTEGER;  (* W OUTPUT *)                             00032800           
324  PAGENUMBER      : INTEGER;  (* CURRENT PAGE NUMBER *)                  00032900           
325  PARACHAR        : ASCII;    (* F PARAGRAPH *)                          00033000           
326  PARACOUNT       : INTEGER;  (* PARAGRAPH COUNTER *)                    00033100           
327  PARAPAGE        : INTEGER;  (* P PARAGRAPH *)                          00033200           
328  PARASKIP        : INTEGER;  (* S PARAGRAPH *)                          00033300           
329  PAUSE           : BOOLEAN;  (* P OUTPUT *)                             00033400           
330  PRINTERRORS     : BOOLEAN;  (* E OPTION *)                             00033500           
331  RAWCLOCK        : CH10;     (* CLOCK TIME AS HH:MM:SS *)               00033600           
332  RAWDATE         : CH10;     (* DATE AS YY/MM/DD *)                     00033700           
333  RIGHTJUSTIFY    : BOOLEAN;  (* R OPTION *)                             00033800           
334  RIGHTMARGIN     : INTEGER;  (* R MARGIN *)                             00033900           
335  SAVEINP         : ARRAY[REMEMBER] OF INPUTSETTINGS;                    00034000           
336                              (* INPUT STACK *)                          00034100           
337  SAVEMAR         : ARRAY[REMEMBER] OF MARGINSETTINGS;                   00034200           
338                              (* MARGIN STACK *)                         00034300           
339  SAVEOPT         : ARRAY[REMEMBER] OF OPTIONSETTINGS;                   00034400           
340                              (* OPTION STACK *)                         00034500           
341  SAVEPAR         : ARRAY[REMEMBER] OF PARAGRAPHSETTINGS;                00034600           
342                              (* PARAGRAPH STACK *)                      00034700           
343  SELECTION       : PACKED ARRAY[0..MAXPAGE] OF BOOLEAN;                 00034800           
344                              (* SELECT DIRECTIVE SETTING *)             00034900           
345  SHIFT           : INTEGER;  (* S OUTPUT *)                             00035000           
346  SHIFTUP         : BOOLEAN;  (* U OPTION *)                             00035100           
347  SPACE           : INTEGER;  (* S OPTION *)                             00035200           
348  SPLITS          : ARRAY[1..MAXSPLIT] OF SPLITPOINT;                    00035300           
349                              (* SPLIT POINTS WITHIN WORD *)             00035400           
350  TERMINALTYPE    : DIRECT;   (* OUTPUT TERMINAL TYPE *)                 00035500           
351  TEXT            : STRING;   (* FOR BUILDING FORM SPECIFICATIONS *)     00035600           
352  TEXTINDEX       : INTEGER;  (* CURRENT TEXT POSITION *)                00035700           
353  TEXTLENGTH      : INTEGER;  (* LENGTH OF TEXT *)                       00035800           
354  TITLE           : ARRAY[BOOLEAN] OF PSTRING;                           00035900           
355                              (* TITLE AND SUBTITLE BUFFERS *)           00036000           
356  TITLELENGTH     : ARRAY[BOOLEAN] OF INTEGER;                           00036100           
357                              (* TITLE AND SUBTITLE LENGTHS *)           00036200           
358  UNDERAVAIL      : BOOLEAN;  (* U OUTPUT *)                             00036300           
359  UNDERCHAR       : ASCII;    (* U INPUT *)                              00036400           
360  UNDERLINING     : BOOLEAN;  (* UNDERLINING FLAG *)                     00036500           
361  UNDERDIR        : BOOLEAN;  (* UNDERLINING FLAG IN DIRECTIVES *)       00036600           
362  WALLCLOCK       : CH10;     (* CLOCK TIME AS HH:MM AM *)               00036700           
363  WORD            : STRING;   (* CURRENT WORD *)                         00036800           
364  WORDLENGTH      : INTEGER;  (* LENGTH OF WORD *)                       00036900           
365                                                                         00037000           
366                                                                         00037100           
367                                                                         00037200           
368                                                                         00037300           
369                                                                         00037400           
370                                                                         00037500           
371                                                                         00037600           
372                                                                         00037700           
373                                                                         00037800           
374                                                                         00037900           
375                                                                         00038000           
376  PROCEDURE ERROR( N : INTEGER ); FORWARD;                               00038100           
377  PROCEDURE VALIDATE( VAR NUM : INTEGER;                                 00038200           
378                      MIN,MAX,ERR : INTEGER ); FORWARD;                  00038300           
379  PROCEDURE REINITIALIZE( WHICH : DIRSET ); FORWARD;                     00038400           
380                                                                         00038500           
381                                                                         00038600           
382                                                                         00038700           
383                                                                         00038800           
384                                                                         00038900           
385                                                                         00039000           
386                                                                         00039100           
387                                                                         00039200           
388 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00039300           
389 (*                                                                   *) 00039400           
390 (*                          GENERAL UTILITY                          *) 00039500           
391 (*                          ------- -------                          *) 00039600           
392 (*                                                                   *) 00039700           
393 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00039800           
394                                                                         00039900           
395                                                                         00040000           
396                                                                         00040100           
397                                                                         00040200           
398 (*        ASCIICHAR - CONVERT LITERAL HOST CHARACTER TO ASCII.          00040300           
399  *)                                                                     00040400           
400                                                                         00040500           
401  FUNCTION ASCIICHAR( CH : CHAR ) : ASCII;                               00040600           
402  BEGIN (* ASCIICHAR *)                                                  00040700           
403  ASCIICHAR := ASC[CH]                                               (**)00040800           
404  END (* ASCIICHAR *);                                                   00040900           
405                                                                         00041000           
406                                                                         00041100           
407                                                                         00041200           
408                                                                         00041300           
409 (*        UPPER - CONVERT ALPHABETIC CHARACTERS TO UPPER CASE.          00041400           
410  *)                                                                     00041500           
411                                                                         00041600           
412  FUNCTION UPPER( CH : ASCIIX ) : ASCIIX;                                00041700           
413  BEGIN (* UPPER *)                                                      00041800           
414  IF CLASS[CH].LETTER                                                    00041900           
415   THEN IF CH >= SMALLA                                                  00042000           
416    THEN UPPER := CH - 32                                                00042100           
417    ELSE UPPER := CH                                                     00042200           
418   ELSE UPPER := CH                                                      00042300           
419  END (* UPPER *);                                                       00042400           
420                                                                         00042500           
421                                                                         00042600           
422                                                                         00042700           
423                                                                         00042800           
424 (*        LOWER - CONVERT TO LOWER CASE IF ALPHABETIC.                  00042900           
425  *)                                                                     00043000           
426                                                                         00043100           
427  FUNCTION LOWER( CH : ASCIIX ) : ASCIIX;                                00043200           
428  BEGIN (* LOWER *)                                                      00043300           
429  IF CLASS[CH].LETTER                                                    00043400           
430   THEN IF CH <= Z                                                       00043500           
431    THEN LOWER := CH + 32                                                00043600           
432    ELSE LOWER := CH                                                     00043700           
433   ELSE LOWER := CH                                                      00043800           
434  END (* LOWER *);                                                       00043900           
435                                                                         00044000           
436                                                                         00044100           
437                                                                         00044200           
438                                                                         00044300           
439 (*        NUMFORM - DETERMINE THE NUMERIC FORM.                         00044400           
440  *                                                                      00044500           
441  *        PARAM  CH = N, SMALLN, L, SMALLL, R, SMALLR.                  00044600           
442  *               ERR = ERROR IF BAD NUMERIC FORM.                       00044700           
443  *)                                                                     00044800           
444                                                                         00044900           
445  FUNCTION NUMFORM( CH : ASCII; ERR : INTEGER ) : NUMBERFORM;            00045000           
446  BEGIN (* NUMFORM *)                                                    00045100           
447  IF CLASS[CH].NUMFORM                                                   00045200           
448   THEN CASE CH OF                                                       00045300           
449    N,                                                                   00045400           
450    SMALLN : NUMFORM := NUMERIC;                                         00045500           
451    L      : NUMFORM := UPPERALPHA;                                      00045600           
452    SMALLL : NUMFORM := LOWERALPHA;                                      00045700           
453    R      : NUMFORM := UPPERROMAN;                                      00045800           
454    SMALLR : NUMFORM := LOWERROMAN;                                      00045900           
455    BLANK  : NUMFORM := NONUMBERING                                      00046000           
456    END                                                                  00046100           
457   ELSE BEGIN ERROR1 := CH; ERROR(ERR); NUMFORM := NUMERIC END           00046200           
458  END (* NUMFORM *);                                                     00046300           
459                                                                         00046400           
460                                                                         00046500           
461                                                                         00046600           
462                                                                         00046700           
463 (*        CONVERTNUMBER - CONVERT NUMBER FROM BINARY TO TEXT.           00046800           
464  *                                                                      00046900           
465  *        PARAM  STR - OUTPUT STRING.                                   00047000           
466  *               LEN - LENGTH OF OUTPUT STRING.                         00047100           
467  *               NUM - NUMBER TO CONVERT.                               00047200           
468  *               FW  - FIELD WIDTH OF NUMBER.                           00047300           
469  *               FORM- FORM OF CONVERSION.                              00047400           
470  *)                                                                     00047500           
471                                                                         00047600           
472  PROCEDURE CONVERTNUMBER( VAR STR : STRING; VAR LEN : INTEGER;          00047700           
473                           NUM,FW : INTEGER; FORM : NUMBERFORM );        00047800           
474  VAR                                                                    00047900           
475   DIGIT          : ARRAY[1..MAXNUMBERWIDTH] OF ASCII;                   00048000           
476                              (* DIGIT ARRAY *)                          00048100           
477   NEXTNUM        : INTEGER;  (* FOR DECOMPOSITION *)                    00048200           
478   X1,X2          : INTEGER;  (* LOOP INDECES *)                         00048300           
479                                                                         00048400           
480                                                                         00048500           
481                                                                         00048600           
482                                                                         00048700           
483  (*       SEND1 - SEND ONE DIGIT.                                       00048800           
484   *                                                                     00048900           
485   *       PARAM  DIG - DIGIT TO SEND.                                   00049000           
486   *)                                                                    00049100           
487                                                                         00049200           
488   PROCEDURE SEND1( DIG : ASCII );                                       00049300           
489   BEGIN (* SEND1 *)                                                     00049400           
490   IF X1 < MAXNUMBERWIDTH                                                00049500           
491    THEN BEGIN X1 := X1 + 1;                                             00049600           
492     DIGIT[X1] := DIG                                                    00049700           
493     END                                                                 00049800           
494   END (* SEND1 *);                                                      00049900           
495                                                                         00050000           
496                                                                         00050100           
497                                                                         00050200           
498                                                                         00050300           
499  BEGIN (* CONVERTNUMBER *)                                              00050400           
500  X1 := 0;                                                               00050500           
501  CASE FORM OF                                                           00050600           
502    NUMERIC    : REPEAT NEXTNUM := NUM DIV 10;                           00050700           
503                  SEND1(NUM - 10 * NEXTNUM + ZERO);                      00050800           
504                  NUM := NEXTNUM                                         00050900           
505                 UNTIL NUM = 0;                                          00051000           
506    LOWERALPHA,                                                          00051100           
507    UPPERALPHA : REPEAT NUM := NUM - 1;                                  00051200           
508                  NEXTNUM := NUM DIV 26;                                 00051300           
509                  SEND1(NUM - 26 * NEXTNUM + A);                         00051400           
510                  NUM := NEXTNUM                                         00051500           
511                 UNTIL NUM = 0;                                          00051600           
512    LOWERROMAN,                                                          00051700           
513    UPPERROMAN : BEGIN WHILE NUM >= 1000 DO                              00051800           
514                  BEGIN SEND1(M); NUM := NUM - 1000 END;                 00051900           
515                 IF NUM >= 900                                           00052000           
516                  THEN BEGIN SEND1(D); SEND1(M); NUM := NUM - 900 END    00052100           
517                  ELSE IF NUM >= 500                                     00052200           
518                   THEN BEGIN SEND1(D); NUM := NUM - 500 END             00052300           
519                   ELSE IF NUM >= 400                                    00052400           
520                    THEN BEGIN SEND1(C); SEND1(D); NUM := NUM - 400 END; 00052500           
521                 WHILE NUM >= 100 DO                                     00052600           
522                  BEGIN SEND1(C); NUM := NUM - 100 END;                  00052700           
523                 IF NUM >= 90                                            00052800           
524                  THEN BEGIN SEND1(X); SEND1(C); NUM := NUM - 90 END     00052900           
525                  ELSE IF NUM >= 50                                      00053000           
526                   THEN BEGIN SEND1(L); NUM := NUM - 50 END              00053100           
527                   ELSE IF NUM >= 40                                     00053200           
528                    THEN BEGIN SEND1(X); SEND1(L); NUM := NUM - 40 END;  00053300           
529                 WHILE NUM >= 10 DO                                      00053400           
530                  BEGIN SEND1(X); NUM := NUM - 10 END;                   00053500           
531                 IF NUM >= 9                                             00053600           
532                  THEN BEGIN SEND1(I); SEND1(X); NUM := NUM - 9 END      00053700           
533                  ELSE IF NUM >= 5                                       00053800           
534                   THEN BEGIN SEND1(V); NUM := NUM - 5 END               00053900           
535                   ELSE IF NUM >= 4                                      00054000           
536                    THEN BEGIN SEND1(I); SEND1(V); NUM := NUM - 4 END;   00054100           
537                 WHILE NUM >= 1 DO                                       00054200           
538                  BEGIN SEND1(I); NUM := NUM - 1 END                     00054300           
539                 END;                                                    00054400           
540    NONUMBERING:                                                         00054500           
541   END;                                                                  00054600           
542  IF LEN + FW > MAXSTRINGLENGTH THEN FW := MAXSTRINGLENGTH - LEN;        00054700           
543  FOR X2 := X1+1 TO FW DO                                                00054800           
544   BEGIN LEN := LEN + 1;                                                 00054900           
545   WITH STR[LEN] DO                                                      00055000           
546    BEGIN C := BLANK;                                                    00055100           
547    NBL := CHARWIDTH                                                     00055200           
548    END                                                                  00055300           
549   END;                                                                  00055400           
550  IF LEN + X1 > MAXSTRINGLENGTH THEN X1 := MAXSTRINGLENGTH - LEN;        00055500           
551  IF FORM IN [NUMERIC,LOWERALPHA,UPPERALPHA]                             00055600           
552   THEN FOR X2 := X1 DOWNTO 1 DO                                         00055700           
553    BEGIN LEN := LEN + 1;                                                00055800           
554    WITH STR[LEN] DO                                                     00055900           
555     BEGIN IF FORM = LOWERALPHA                                          00056000           
556      THEN C := DIGIT[X2] + 32                                           00056100           
557      ELSE C := DIGIT[X2];                                               00056200           
558     NBL := CHARWIDTH                                                    00056300           
559     END                                                                 00056400           
560    END                                                                  00056500           
561   ELSE FOR X2 := 1 TO X1 DO                                             00056600           
562    BEGIN LEN := LEN + 1;                                                00056700           
563    WITH STR[LEN] DO                                                     00056800           
564     BEGIN IF FORM = LOWERROMAN                                          00056900           
565      THEN C := DIGIT[X2] + 32                                           00057000           
566      ELSE C := DIGIT[X2];                                               00057100           
567     NBL := CHARWIDTH                                                    00057200           
568     END                                                                 00057300           
569    END                                                                  00057400           
570  END (* CONVERTNUMBER *);                                               00057500           
571                                                                         00057600           
572                                                                         00057700           
573                                                                         00057800           
574                                                                         00057900           
575 (*        SHIFTSTRING - CONVERT STRING TO UPPER/LOWER CASE,             00058000           
576  *                      CONSIDERING STUTTERING AND CASE SHIFT.          00058100           
577  *)                                                                     00058200           
578                                                                         00058300           
579  PROCEDURE SHIFTSTRING( VAR STR : STRING; VAR LEN : INTEGER;            00058400           
580                         VAR LCS : BOOLEAN );                            00058500           
581  VAR                                                                    00058600           
582   INTCH          : ASCII;    (* INTERNAL CHARACTER *)                   00058700           
583   OLDCH          : ASCII;    (* PREVIOUS INTERNAL CHARACTER *)          00058800           
584   OLDOLDCH       : ASCII;    (* PREVIOUS PREVIOUS CHARACTER *)          00058900           
585   X1,X2          : INTEGER;  (* LOOP INDICES *)                         00059000           
586  BEGIN (* SHIFTSTRING *)                                                00059100           
587  OLDCH := BLANK;                                                        00059200           
588  OLDOLDCH := BLANK;                                                     00059300           
589  X1 := 0;                                                               00059400           
590  X2 := 1;                                                               00059500           
591  IF LEN >= 1                                                            00059600           
592   THEN IF STR[1].C = PARACHAR                                           00059700           
593    THEN BEGIN X1 := 1; X2 := 2 END;                                     00059800           
594  FOR X2 := X2 TO LEN DO                                                 00059900           
595   BEGIN INTCH := LOWER(STR[X2].C);                                      00060000           
596   IF INTCH = CASECH                                                     00060100           
597    THEN LCS := NOT LCS                                                  00060200           
598    ELSE IF INTCH = OLDCH                                                00060300           
599     THEN IF (OLDOLDCH = BLANK) AND CLASS[INTCH].LETTER                  00060400           
600      THEN BEGIN STR[X1].C := UPPER(INTCH);                              00060500           
601       LCS := TRUE                                                       00060600           
602       END                                                               00060700           
603      ELSE BEGIN X1 := X1 + 1;                                           00060800           
604       IF LCS                                                            00060900           
605        THEN STR[X1].C := INTCH                                          00061000           
606        ELSE STR[X1].C := UPPER(INTCH)                                   00061100           
607       END                                                               00061200           
608     ELSE BEGIN X1 := X1 + 1;                                            00061300           
609      IF LCS                                                             00061400           
610       THEN STR[X1].C := INTCH                                           00061500           
611       ELSE STR[X1].C := UPPER(INTCH)                                    00061600           
612      END;                                                               00061700           
613   OLDOLDCH := OLDCH;                                                    00061800           
614   OLDCH := INTCH                                                        00061900           
615   END;                                                                  00062000           
616  LEN := X1                                                              00062100           
617  END (* SHIFTSTRING *);                                                 00062200           
618                                                                         00062300           
619                                                                         00062400           
620                                                                         00062500           
621                                                                         00062600           
622 (*        UNDERSTRING - SET UNDERLINED CHARACTERS IN STRING,            00062700           
623  *                      CONSIDERING UNDERLINE CHARACTER.                00062800           
624  *                      THIS IS ALSO DONE IN READPSTRING.               00062900           
625  *)                                                                     00063000           
626                                                                         00063100           
627  PROCEDURE UNDERSTRING( VAR STR : STRING; VAR LEN : INTEGER;            00063200           
628                         VAR ULN : BOOLEAN );                            00063300           
629  VAR                                                                    00063400           
630   INTCH          : ASCII;    (* INTERNAL CHARACTER *)                   00063500           
631   X1,X2          : INTEGER;  (* LOOP INDICES *)                         00063600           
632  BEGIN (* UNDERSTRING *)                                                00063700           
633  X1 := 0;                                                               00063800           
634  FOR X2 := 1 TO LEN DO                                                  00063900           
635   BEGIN INTCH := STR[X2].C;                                             00064000           
636   IF INTCH = UNDERCHAR                                                  00064100           
637    THEN ULN := NOT ULN                                                  00064200           
638    ELSE BEGIN X1 := X1 + 1;                                             00064300           
639     IF (INTCH <> BLANK) AND ULN                                         00064400           
640      THEN STR[X1].C := INTCH + 128                                      00064500           
641      ELSE STR[X1].C := INTCH                                            00064600           
642     END                                                                 00064700           
643   END;                                                                  00064800           
644  LEN := X1                                                              00064900           
645  END (* UNDERSTRING *);                                                 00065000           
646                                                                         00065100           
647                                                                         00065200           
648                                                                         00065300           
649                                                                         00065400           
650 (*        JUSTIFY - LEFT JUSTIFY, RIGHT JUSTIFY, AND/OR CENTER          00065500           
651  *                  AN OUTPUT LINE.                                     00065600           
652  *)                                                                     00065700           
653                                                                         00065800           
654  PROCEDURE JUSTIFY;                                                     00065900           
655  CONST                                                                  00066000           
656   FLOOR          = 0.0;      (* MAKES TRUNC DO FLOOR *)                 00066100           
657   CIELING        = 0.9999;   (* MAKES TRUNC DO CIELING *)               00066200           
658  VAR                                                                    00066300           
659   FC             : REAL;     (* TO SELECT FLOOR OR CIELING *)           00066400           
660   IB             : INTEGER;  (* INSERT BLANKS *)                        00066500           
661   NB             : INTEGER;  (* NUMBER BLANKS (TOTAL) *)                00066600           
662   NG             : INTEGER;  (* NUMBER GAPS (ACTUAL) *)                 00066700           
663  BEGIN (* JUSTIFY *)                                                    00066800           
664  NG := NGAPS - 1;                                                       00066900           
665  NB := (RIGHTMARGIN - NCHARS) * CHARWIDTH;                              00067000           
666  IF LEFTJUSTIFY                                                         00067100           
667   THEN BEGIN IF RIGHTJUSTIFY                                            00067200           
668     THEN BEGIN IF MOREONLEFT                                            00067300           
669       THEN FC := FLOOR                                                  00067400           
670       ELSE FC := CIELING;                                               00067500           
671      FOR NG := NG DOWNTO 1 DO                                           00067600           
672       BEGIN IB := TRUNC(FC + NB / NG);                                  00067700           
673       WITH OUTLINE[GAPS[NG]] DO NBL := NBL + IB;                        00067800           
674       NB := NB - IB                                                     00067900           
675       END                                                               00068000           
676      END                                                                00068100           
677    END                                                                  00068200           
678   ELSE WITH OUTLINE[GAPS[0]] DO                                         00068300           
679    IF RIGHTJUSTIFY                                                      00068400           
680     THEN NBL := NBL + NB                                                00068500           
681     ELSE NBL := NBL + TRUNC(NB / 2);                                    00068600           
682  MOREONLEFT := NOT MOREONLEFT                                           00068700           
683  END (* JUSTIFY *);                                                     00068800           
684                                                                         00068900           
685                                                                         00069000           
686                                                                         00069100           
687                                                                         00069200           
688                                                                         00069300           
689                                                                         00069400           
690                                                                         00069500           
691                                                                         00069600           
692 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00069700           
693 (*                                                                   *) 00069800           
694 (*                              OUTPUT                               *) 00069900           
695 (*                              ------                               *) 00070000           
696 (*                                                                   *) 00070100           
697 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00070200           
698                                                                         00070300           
699                                                                         00070400           
700                                                                         00070500           
701                                                                         00070600           
702 (*        WRITE1 - WRITE ONE CHARACTER, DO CONVERSION FROM ASCII        00070700           
703  *                 TO THE HOST CHARACTER SET.                           00070800           
704  *                                                                      00070900           
705  *        PARAM  CH = CHARACTER TO WRITE.                               00071000           
706  *)                                                                     00071100           
707                                                                         00071200           
708  PROCEDURE WRITE1( CH : ASCIIX );                                       00071300           
709  BEGIN (* WRITE1 *)                                                     00071400           
710  WITH HOST[CH MOD 128] DO                                          (**) 00071500           
711   BEGIN IF CHR74                                                    (**)00071600           
712    THEN WRITE(CHR(60))                                             (**) 00071700           
713    ELSE IF CHR76                                                    (**)00071800           
714     THEN WRITE(CHR(62));                                           (**) 00071900           
715   WRITE(C)                                                          (**)00072000           
716   END                                                               (**)00072100           
717  END (* WRITE1 *);                                                      00072200           
718                                                                         00072300           
719                                                                         00072400           
720                                                                         00072500           
721                                                                         00072600           
722 (*        ENDLINE - TERMINATE AND COUNT AN OUTPUT LINE.                 00072700           
723  *)                                                                     00072800           
724                                                                         00072900           
725  PROCEDURE ENDLINE;                                                     00073000           
726  BEGIN (* ENDLINE *)                                                    00073100           
727  IF SELECTION[PAGENUMBER]                                               00073200           
728   THEN IF BLANKLINE                                                     00073300           
729    THEN BLANKCOUNT := BLANKCOUNT + 1                                    00073400           
730    ELSE IF TERMINALTYPE = AJT                                           00073500           
731     THEN BEGIN WRITE1(ESC); WRITE1(Z);                                  00073600           
732      WRITE1(ZERO); WRITE1(ZERO); WRITE1(EIGHT);                         00073700           
733      NEXTCOLUMN := 0;                                                   00073800           
734      END                                                                00073900           
735     ELSE WRITELN;                                                       00074000           
736  IF LINECOUNT <> INFINITY THEN LINECOUNT := LINECOUNT - 1               00074100           
737  END (* ENDLINE *);                                                     00074200           
738                                                                         00074300           
739                                                                         00074400           
740                                                                         00074500           
741                                                                         00074600           
742 (*        WRITEBLANKLINES - WRITE ACCUMULATED BLANK LINES.              00074700           
743  *)                                                                     00074800           
744                                                                         00074900           
745  PROCEDURE WRITEBLANKLINES;                                             00075000           
746  BEGIN (* WRITEBLANKLINES *)                                            00075100           
747  BLANKLINE := FALSE;                                                    00075200           
748  IF TERMINALTYPE = LPT                                                  00075300           
749   THEN WHILE BLANKCOUNT >= 2 DO                                         00075400           
750    BEGIN IF SELECTION[PAGENUMBER] THEN WRITE('0');                      00075500           
751    BLANKCOUNT := BLANKCOUNT - 2;                                        00075600           
752    IF LINECOUNT <> INFINITY THEN LINECOUNT := LINECOUNT + 1;            00075700           
753    ENDLINE                                                              00075800           
754    END;                                                                 00075900           
755  WHILE BLANKCOUNT > 0 DO                                                00076000           
756   BEGIN BLANKCOUNT := BLANKCOUNT - 1;                                   00076100           
757   IF LINECOUNT <> INFINITY THEN LINECOUNT := LINECOUNT + 1;             00076200           
758   ENDLINE                                                               00076300           
759   END                                                                   00076400           
760  END (* WRITEBLANKLINES *);                                             00076500           
761                                                                         00076600           
762                                                                         00076700           
763                                                                         00076800           
764                                                                         00076900           
765 (*        WRITESTRING - WRITE A STRING TO THE OUTPUT FILE.              00077000           
766  *                                                                      00077100           
767  *        PARAM  STR = STRING TO WRITE.                                 00077200           
768  *               LEN = LENGTH OF STR.                                   00077300           
769  *)                                                                     00077400           
770                                                                         00077500           
771  PROCEDURE WRITESTRING( VAR STR : STRING; LEN : INTEGER );              00077600           
772  VAR                                                                    00077700           
773   X1,X2          : INTEGER;  (* GENERAL INDEX VARIABLES *)              00077800           
774   UNDERSTR       : STRING;   (* UNDERLINING FOR THIS STRING *)          00077900           
775  BEGIN (* WRITESTRING *)                                                00078000           
776  IF SELECTION[PAGENUMBER]                                               00078100           
777   THEN BEGIN WHILE (STR[LEN].C = BLANK) AND (LEN > 1) DO                00078200           
778     LEN := LEN - 1;                                                     00078300           
779    IF STR[LEN].C = BLANK THEN LEN := 0;                                 00078400           
780    BLANKLINE := (LEN = 0) AND (CARRIAGECONTROL = BLANK);                00078500           
781    IF NOT BLANKLINE                                                     00078600           
782     THEN BEGIN WRITEBLANKLINES;                                         00078700           
783      IF UNDERCHAR <> NUL                                                00078800           
784       THEN BEGIN X2 := 0;                                               00078900           
785        FOR X1 := 1 TO LEN DO WITH STR[X1] DO                            00079000           
786         IF ODD(C DIV 128)                                               00079100           
787          THEN BEGIN UNDERSTR[X1].C := UNDERSCORE;                       00079200           
788           C := C - 128;                                                 00079300           
789           X2 := X1                                                      00079400           
790           END                                                           00079500           
791          ELSE BEGIN UNDERSTR[X1].C := BLANK;                            00079600           
792           UNDERSTR[X1].NBL := NBL                                       00079700           
793           END;                                                          00079800           
794        IF (X2 <> 0) AND UNDERAVAIL                                      00079900           
795         THEN BEGIN WRITESTRING(UNDERSTR,X2);                            00080000           
796          CASE TERMINALTYPE OF                                           00080100           
797           AST : WRITE1(CR);                                             00080200           
798           LPT : BEGIN WRITELN; CARRIAGECONTROL := PLUS END;             00080300           
799           AJT : NEXTCOLUMN := 0                                         00080400           
800           END                                                           00080500           
801          END                                                            00080600           
802        END;                                                             00080700           
803      STR[1].NBL := STR[1].NBL + SHIFT;                                  00080800           
804      IF TERMINALTYPE = LPT THEN WRITE1(CARRIAGECONTROL);                00080900           
805      IF EXPLICITBLANK <> NUL                                            00081000           
806       THEN FOR X1 := 1 TO LEN DO WITH STR[X1] DO                        00081100           
807        IF C = EXPLICITBLANK                                             00081200           
808         THEN BEGIN C := BLANK; NBL := CHARWIDTH END;                    00081300           
809      IF SHIFTUP                                                         00081400           
810       THEN FOR X1 := 1 TO LEN DO                                        00081500           
811        STR[X1].C := UPPER(STR[X1].C);                                   00081600           
812      IF TERMINALTYPE = AJT                                              00081700           
813       THEN FOR X1 := 1 TO LEN DO                                        00081800           
814        WITH STR[X1] DO                                                  00081900           
815         IF C <> BLANK                                                   00082000           
816          THEN BEGIN IF NEXTCOLUMN <> ACTUALCOLUMN                       00082100           
817            THEN BEGIN WRITE1(ESC); WRITE1(A);                           00082200           
818             WRITE1(NEXTCOLUMN DIV 100 + ZERO);                          00082300           
819             WRITE1(NEXTCOLUMN DIV 10 MOD 10 + ZERO);                    00082400           
820             WRITE1(NEXTCOLUMN MOD 10 + ZERO)                            00082500           
821             END;                                                        00082600           
822           WRITE1(C);                                                    00082700           
823           ACTUALCOLUMN := NEXTCOLUMN + CHARWIDTH;                       00082800           
824           NEXTCOLUMN := ACTUALCOLUMN                                    00082900           
825           END                                                           00083000           
826          ELSE NEXTCOLUMN := NEXTCOLUMN + NBL                            00083100           
827       ELSE FOR X1 := 1 TO LEN DO                                        00083200           
828        WITH STR[X1] DO                                                  00083300           
829         IF C = BLANK                                                    00083400           
830          THEN FOR X2 := 1 TO NBL DO                                     00083500           
831           WRITE1(BLANK)                                                 00083600           
832          ELSE WRITE1(C);                                                00083700           
833      CARRIAGECONTROL := BLANK;                                          00083800           
834      STR[1].NBL := STR[1].NBL - SHIFT                                   00083900           
835      END                                                                00084000           
836    END                                                                  00084100           
837   ELSE BLANKLINE := FALSE                                               00084200           
838  END (* WRITESTRING *);                                                 00084300           
839                                                                         00084400           
840                                                                         00084500           
841                                                                         00084600           
842                                                                         00084700           
843 (*        ADVANCEFORM - ADVANCE FORM TO NEXT L SPECIFICATION.           00084800           
844  *)                                                                     00084900           
845                                                                         00085000           
846  PROCEDURE ADVANCEFORM;                                                 00085100           
847  VAR                                                                    00085200           
848   CH             : ASCII;    (* KEY CHARACTER *)                        00085300           
849   FORMCH         : ASCIIX;   (* CURRENT FORM CHARACTER *)               00085400           
850   FW             : INTEGER;  (* FIELD WIDTH OF CURRENT ITEM *)          00085500           
851   TL             : INTEGER;  (* LOCAL TITLE LENGTH *)                   00085600           
852   WHICH          : BOOLEAN;  (* WHICH TITLE (MAIN,SUB) *)               00085700           
853   X1             : INTEGER;  (* GENERAL INDEX *)                        00085800           
854                                                                         00085900           
855                                                                         00086000           
856                                                                         00086100           
857                                                                         00086200           
858  (*       NEXTCH - ADVANCE TO NEXT FORM CHARACTER.                      00086300           
859   *)                                                                    00086400           
860                                                                         00086500           
861   PROCEDURE NEXTCH;                                                     00086600           
862   BEGIN (* NEXTCH *)                                                    00086700           
863   FORMINDEX := (FORMINDEX MOD FORMLENGTH) + 1;                          00086800           
864   FORMCH := FORM[FORMINDEX]                                             00086900           
865   END (* NEXTCH *);                                                     00087000           
866                                                                         00087100           
867                                                                         00087200           
868                                                                         00087300           
869                                                                         00087400           
870  (*       NUMBER - READ A NUMBER FROM THE FORM.                         00087500           
871   *                                                                     00087600           
872   *       PARAM  DEF = DEFAULT NUMBER.                                  00087700           
873   *)                                                                    00087800           
874                                                                         00087900           
875   FUNCTION NUMBER( DEF : INTEGER ) : INTEGER;                           00088000           
876   VAR                                                                   00088100           
877    NUM           : INTEGER;  (* NUMBER BEGIN BUILT *)                   00088200           
878   BEGIN (* NUMBER *)                                                    00088300           
879   IF CLASS[FORMCH].DIGIT                                                00088400           
880    THEN BEGIN NUM := 0;                                                 00088500           
881     REPEAT NUM := NUM * 10 + FORMCH - ZERO;                             00088600           
882      IF NUM >= INFINITY THEN NUM := INFINITY-1;                         00088700           
883      NEXTCH                                                             00088800           
884     UNTIL NOT CLASS[FORMCH].DIGIT;                                      00088900           
885     NUMBER := NUM                                                       00089000           
886     END                                                                 00089100           
887    ELSE NUMBER := DEF                                                   00089200           
888   END (* NUMBER *);                                                     00089300           
889                                                                         00089400           
890                                                                         00089500           
891                                                                         00089600           
892                                                                         00089700           
893  (*       FIELDWIDTH - READ OPTIONAL FIELD WIDTH SPECIFICATION.         00089800           
894   *                                                                     00089900           
895   *       PARAM  DEF = DEFAULT FIELD WIDTH.                             00090000           
896   *              MIN = MINIMUM FIELD WIDTH.                             00090100           
897   *)                                                                    00090200           
898                                                                         00090300           
899   PROCEDURE FIELDWIDTH( DEF,MIN : INTEGER );                            00090400           
900   BEGIN (* FIELDWIDTH *)                                                00090500           
901   FW := DEF;                                                            00090600           
902   IF FORMCH = COLON                                                     00090700           
903    THEN BEGIN NEXTCH;                                                   00090800           
904     FW := NUMBER(DEF)                                                   00090900           
905     END;                                                                00091000           
906   IF FW < MIN THEN FW := MIN                                            00091100           
907   END (* FIELDWIDTH *);                                                 00091200           
908                                                                         00091300           
909                                                                         00091400           
910                                                                         00091500           
911                                                                         00091600           
912  (*       SEND1 - SEND ONE CHARACTER TO THE TEXT LINE.                  00091700           
913   *                                                                     00091800           
914   *       PARAM  CH = CHARACTER TO BE SENT.                             00091900           
915   *)                                                                    00092000           
916                                                                         00092100           
917   PROCEDURE SEND1( CH : ASCIIX );                                       00092200           
918   BEGIN (* SEND1 *)                                                     00092300           
919   TEXTINDEX := TEXTINDEX + 1;                                           00092400           
920   IF TEXTINDEX + SHIFT > MAXOWIDTH                                      00092500           
921    THEN BEGIN TEXTINDEX := 1; ERROR(-1) END;                            00092600           
922   TEXT[TEXTINDEX].C := CH;                                              00092700           
923   TEXT[TEXTINDEX].NBL := CHARWIDTH;                                     00092800           
924   IF TEXTINDEX > TEXTLENGTH THEN TEXTLENGTH := TEXTINDEX                00092900           
925   END (* SEND1 *);                                                      00093000           
926                                                                         00093100           
927                                                                         00093200           
928                                                                         00093300           
929                                                                         00093400           
930  (*       SEND10 - SEND UP TO 10 CHARACTERS TO THE TEXT LINE,           00093500           
931   *                DETERMINING FIELD WIDTH.                             00093600           
932   *                                                                     00093700           
933   *       PARAM  CH = 10 CHARACTERS.                                    00093800           
934   *              DEF = DEFAULT FIELD WIDTH.                             00093900           
935   *              MIN = MINIMUM FIELD WIDTH.                             00094000           
936   *)                                                                    00094100           
937                                                                         00094200           
938   PROCEDURE SEND10( CH : CH10; DEF,MIN : INTEGER );                     00094300           
939   VAR                                                                   00094400           
940    X1            : INTEGER;  (* INDEX INTO CH *)                        00094500           
941   BEGIN (* SEND10 *)                                                    00094600           
942   FIELDWIDTH(DEF,MIN);                                                  00094700           
943   IF FW < DEF                                                           00094800           
944    THEN (* SEND RIGHTMOST FW CHARACTERS *)                              00094900           
945     FOR X1 := DEF-FW+1 TO DEF DO SEND1(CH[X1])                          00095000           
946    ELSE (* SEND LEADING BLANKS AND ALL DEF CHARACTERS *)                00095100           
947     BEGIN FOR X1 := 1 TO FW-DEF DO SEND1(BLANK);                        00095200           
948     FOR X1 := 1 TO DEF DO SEND1(CH[X1])                                 00095300           
949     END                                                                 00095400           
950   END (* SEND10 *);                                                     00095500           
951                                                                         00095600           
952                                                                         00095700           
953                                                                         00095800           
954                                                                         00095900           
955  (*       WRITETEXT - WRITE TEXT BUFFER.                                00096000           
956   *)                                                                    00096100           
957                                                                         00096200           
958   PROCEDURE WRITETEXT;                                                  00096300           
959   BEGIN (* WRITETEXT *)                                                 00096400           
960   WRITESTRING(TEXT,TEXTLENGTH);                                         00096500           
961   ENDLINE;                                                              00096600           
962   TEXTLENGTH := 1;                                                      00096700           
963   TEXTINDEX := 1                                                        00096800           
964   END (* WRITETEXT *);                                                  00096900           
965                                                                         00097000           
966                                                                         00097100           
967                                                                         00097200           
968                                                                         00097300           
969  (*       WAIT - WAIT FOR OPERATOR ACKNOWLEDGEMENT.                     00097400           
970   *              HEAVILY SYSTEM DEPENDANT.                              00097500           
971   *)                                                                    00097600           
972                                                                         00097700           
973   PROCEDURE WAIT;                                                   (**)00097800           
974                                                                     (**)00098100           
975                                                                     (**)00098300           
976   BEGIN (* WAIT *)                                                  (**)00098400           
977   END (* WAIT *);                                                       00099300           
978                                                                         00099400           
979                                                                         00099500           
980                                                                         00099600           
981                                                                         00099700           
982  BEGIN (* ADVANCEFORM *)                                                00099800           
983  CH := UPPER(FORM[FORMINDEX]);                                          00099900           
984  IF NOT CLASS[CH].QUOTE THEN NEXTCH;                                    00100000           
985  IF CLASS[CH].FORMCHAR                                                  00100100           
986   THEN CASE CH OF                                                       00100200           
987    C : SEND10(RAWCLOCK,8,0);                                            00100300           
988    D : SEND10(RAWDATE,8,0);                                             00100400           
989    E : SEND10(NICEDATE,9,0);                                            00100500           
990    L : BEGIN IF TEXTLENGTH > 1 THEN WRITETEXT;                          00100600           
991        LINECOUNT := NUMBER(1)                                           00100700           
992        END;                                                             00100800           
993    P : BEGIN IF (FORMCH = COLON) OR (FORMCH = BLANK)                    00100900           
994         THEN CH := N                                                    00101000           
995         ELSE BEGIN CH := FORMCH; NEXTCH END;                            00101100           
996        FIELDWIDTH(3,0);                                                 00101200           
997        CONVERTNUMBER(TEXT,TEXTINDEX,PAGENUMBER,FW,NUMFORM(CH,-4));      00101300           
998        IF TEXTINDEX > TEXTLENGTH THEN TEXTLENGTH := TEXTINDEX           00101400           
999        END;                                                             00101500           
1000    S,                                                                   00101600           
1001    T : BEGIN WHICH := (CH = T) OR (CH = SMALLT);                        00101700           
1002        TL := TITLELENGTH[WHICH];                                        00101800           
1003        FIELDWIDTH(TL,0);                                                00101900           
1004        IF FW < TL                                                       00102000           
1005         THEN (* SEND LAST FW CHARACTERS *)                              00102100           
1006          FOR X1 := TL-FW+1 TO TL DO SEND1(TITLE[WHICH][X1])             00102200           
1007         ELSE (* SEND LEADING BLANKS AND ALL TL CHARACTERS *)            00102300           
1008          BEGIN FOR X1 := 1 TO FW-TL DO SEND1(BLANK);                    00102400           
1009          FOR X1 := 1 TO TL DO SEND1(TITLE[WHICH][X1])                   00102500           
1010          END                                                            00102600           
1011        END;                                                             00102700           
1012    W : SEND10(WALLCLOCK,8,0);                                           00102800           
1013    HASH : BEGIN X1 := NUMBER(1);                                        00102900           
1014        WHILE TEXTINDEX < X1 DO SEND1(BLANK);                            00103000           
1015        TEXTINDEX := X1                                                  00103100           
1016        END;                                                             00103200           
1017    LBRACKET : BEGIN IF TEXTLENGTH > 1 THEN WRITETEXT;                   00103300           
1018        IF SELECTION[PAGENUMBER]                                         00103400           
1019         THEN BEGIN IF PAUSE THEN WAIT;                                  00103500           
1020          IF EJECT                                                       00103600           
1021           THEN BEGIN BLANKCOUNT := 0;                                   00103700           
1022            IF TERMINALTYPE = LPT                                        00103800           
1023             THEN CARRIAGECONTROL := ONE                                 00103900           
1024             ELSE WRITE1(FF)                                             00104000           
1025            END                                                          00104100           
1026           ELSE IF TERMINALTYPE <> LPT                                   00104200           
1027            THEN WRITEBLANKLINES                                         00104300           
1028          END;                                                           00104400           
1029        IF FORMNLENGTH > 0                                               00104500           
1030         THEN BEGIN FORM := FORMNEXT;                                    00104600           
1031          FORMLENGTH := FORMNLENGTH;                                     00104700           
1032          FORMINDEX := 0;                                                00104800           
1033          REPEAT NEXTCH UNTIL FORMCH = LBRACKET;                         00104900           
1034          NEXTCH;                                                        00105000           
1035          FORMNLENGTH := 0                                               00105100           
1036          END                                                            00105200           
1037        END;                                                             00105300           
1038    RBRACKET : BEGIN IF TEXTLENGTH > 1 THEN WRITETEXT;                   00105400           
1039        PAGENUMBER := PAGENUMBER + 1;                                    00105500           
1040        VALIDATE(PAGENUMBER,0,INFINITY-1,-3)                             00105600           
1041        END;                                                             00105700           
1042    SLASH : FOR X1 := 1 TO NUMBER(1) DO WRITETEXT;                       00105800           
1043    DQUOTE,                                                              00105900           
1044    SQUOTE : REPEAT NEXTCH;                                              00106000           
1045         WHILE FORMCH <> CH DO                                           00106100           
1046          BEGIN SEND1(FORMCH);                                           00106200           
1047          NEXTCH                                                         00106300           
1048          END;                                                           00106400           
1049         NEXTCH;                                                         00106500           
1050         IF FORMCH = CH THEN SEND1(CH)                                   00106600           
1051        UNTIL FORMCH <> CH;                                              00106700           
1052    BLANK :                                                              00106800           
1053    END                                                                  00106900           
1054   ELSE BEGIN ERROR1 := CH; ERROR(-2) END                                00107000           
1055  END (* ADVANCEFORM *);                                                 00107100           
1056                                                                         00107200           
1057                                                                         00107300           
1058                                                                         00107400           
1059                                                                         00107500           
1060 (*        BEGINLINE - BEGIN OUTPUT LINE, ADVANCE FORM AS NECESSARY.     00107600           
1061  *)                                                                     00107700           
1062                                                                         00107800           
1063  PROCEDURE BEGINLINE;                                                   00107900           
1064  VAR                                                                    00108000           
1065   FIX            : INTEGER;  (* LOCAL COPY OF FORMINDEX *)              00108100           
1066   FNL            : INTEGER;  (* LOCAL COPY OF FORMNLENGTH *)            00108200           
1067  BEGIN (* BEGINLINE *)                                                  00108300           
1068  IF LINECOUNT <= 0                                                      00108400           
1069   THEN (* MAKE LINECOUNT > 0 *)                                         00108500           
1070    BEGIN FIX := FORMINDEX;                                              00108600           
1071     FNL := FORMNLENGTH;                                                 00108700           
1072     REPEAT                                                              00108800           
1073      IF FNL <> FORMNLENGTH                                              00108900           
1074       THEN BEGIN FIX := FORMINDEX;                                      00109000           
1075        FNL := FORMNLENGTH                                               00109100           
1076        END;                                                             00109200           
1077      ADVANCEFORM                                                        00109300           
1078     UNTIL (LINECOUNT > 0) OR ((FIX = FORMINDEX) AND (FNL = 0));         00109400           
1079     IF LINECOUNT <= 0                                                   00109500           
1080      THEN (* BAD FORM *)                                                00109600           
1081       BEGIN ERROR(-5);                                                  00109700           
1082        LINECOUNT := INFINITY                                            00109800           
1083        END                                                              00109900           
1084     END;                                                                00110000           
1085  BLANKLINE := TRUE                                                      00110100           
1086  END (* BEGINLINE *);                                                   00110200           
1087                                                                         00110300           
1088                                                                         00110400           
1089                                                                         00110500           
1090                                                                         00110600           
1091 (*        WRITENULL - WRITE A NULL LINE.                                00110700           
1092  *)                                                                     00110800           
1093                                                                         00110900           
1094  PROCEDURE WRITENULL;                                                   00111000           
1095  BEGIN (* WRITENULL *)                                                  00111100           
1096  BEGINLINE;                                                             00111200           
1097  WRITESTRING(OUTLINE,1);                                                00111300           
1098  ENDLINE                                                                00111400           
1099  END (* WRITENULL *);                                                   00111500           
1100                                                                         00111600           
1101                                                                         00111700           
1102                                                                         00111800           
1103                                                                         00111900           
1104 (*        SKIP - SKIP OUTPUT LINES.                                     00112000           
1105  *)                                                                     00112100           
1106                                                                         00112200           
1107  PROCEDURE SKIP( N : INTEGER );                                         00112300           
1108  BEGIN (* SKIP *)                                                       00112400           
1109  IF N > LINECOUNT THEN N := LINECOUNT;                                  00112500           
1110  FOR N := 1 TO N DO WRITENULL                                           00112600           
1111  END (* SKIP *);                                                        00112700           
1112                                                                         00112800           
1113                                                                         00112900           
1114                                                                         00113000           
1115                                                                         00113100           
1116 (*        WRITELINE - WRITE THE OUTPUT LINE.                            00113200           
1117  *)                                                                     00113300           
1118                                                                         00113400           
1119  PROCEDURE WRITELINE;                                                   00113500           
1120  BEGIN (* WRITELINE *)                                                  00113600           
1121  BEGINLINE;                                                             00113700           
1122  WRITESTRING(OUTLINE,OUTLENGTH);                                        00113800           
1123  ENDLINE;                                                               00113900           
1124  IF SPACE <> 0 THEN SKIP(SPACE);                                        00114000           
1125  OUTLENGTH := 1;                                                        00114100           
1126  OUTLINE[1].NBL := LEFTMARGIN * CHARWIDTH;                              00114200           
1127  NCHARS := LEFTMARGIN;                                                  00114300           
1128  NWORDS := 0;                                                           00114400           
1129  NGAPS := 0;                                                            00114500           
1130  GAPS[0] := 1;                                                          00114600           
1131  NEWOUTLINE := TRUE                                                     00114700           
1132  END (* WRITELINE *);                                                   00114800           
1133                                                                         00114900           
1134                                                                         00115000           
1135                                                                         00115100           
1136                                                                         00115200           
1137 (*        PAGE - CONDITIONALLY PRODUCE A PAGE EJECT.                    00115300           
1138  *)                                                                     00115400           
1139                                                                         00115500           
1140  PROCEDURE PAGE( N : INTEGER );                                         00115600           
1141  BEGIN (* PAGE *)                                                       00115700           
1142  IF LINECOUNT < N                                                       00115800           
1143   THEN REPEAT WHILE LINECOUNT > 0 DO WRITENULL;                         00115900           
1144     WHILE (FORM[FORMINDEX] <> LBRACKET) AND (LINECOUNT <= 0) DO         00116000           
1145      ADVANCEFORM                                                        00116100           
1146    UNTIL FORM[FORMINDEX] = LBRACKET                                     00116200           
1147   ELSE IF LINECOUNT = INFINITY THEN                                     00116300           
1148    IF 5 < N THEN SKIP(5)                                                00116400           
1149  END (* PAGE *);                                                        00116500           
1150                                                                         00116600           
1151                                                                         00116700           
1152                                                                         00116800           
1153                                                                         00116900           
1154                                                                         00117000           
1155                                                                         00117100           
1156                                                                         00117200           
1157                                                                         00117300           
1158 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00117400           
1159 (*                                                                   *) 00117500           
1160 (*                               INPUT                               *) 00117600           
1161 (*                               -----                               *) 00117700           
1162 (*                                                                   *) 00117800           
1163 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00117900           
1164                                                                         00118000           
1165                                                                         00118100           
1166                                                                         00118200           
1167                                                                         00118300           
1168 (*        NEXTCHAR - ADVANCE TO THE NEXT INPUT CHARACTER, AND           00118400           
1169  *                   CONVERT FROM HOST CHARACTER SET TO ASCII.          00118500           
1170  *)                                                                     00118600           
1171                                                                         00118700           
1172  PROCEDURE NEXTCHAR;                                                    00118800           
1173                                                                         00118900           
1174                                                                         00119000           
1175                                                                         00119100           
1176                                                                         00119200           
1177  (*       READLINE - READ AN INPUT LINE, CONVERT INTO ASCII,            00119300           
1178   *                  CONSIDERING CASE SHIFT AND UNDERLINING.            00119400           
1179   *)                                                                    00119500           
1180                                                                         00119600           
1181   PROCEDURE READLINE;                                                   00119700           
1182   VAR                                                                   00119800           
1183    EXTCH         : CHAR;     (* EXTERNAL CHARACTER *)                   00119900           
1184    INTCH         : ASCII;    (* INTERNAL CHARACTER *)                   00120000           
1185    X1,X2         : INTEGER;  (* GENERAL INDEX VARIABLES *)              00120100           
1186   BEGIN (* READLINE *)                                                  00120200           
1187   NEWINLINE := TRUE;                                                    00120300           
1188   X1 := 0;                                                              00120400           
1189   WHILE NOT EOLN(INFILE) AND (X1 < INWIDTH) DO                          00120500           
1190    BEGIN READ(INFILE,EXTCH);                                        (**)00120600           
1191    X1 := X1 + 1;                                                    (**)00120700           
1192    INTCH := ORD(EXTCH);                                                 00120800           
1193    INLINE[X1].C := INTCH                                                00121900           
1194    END;                                                                 00122000           
1195   INLINE[X1+1].C := BLANK;                                              00122100           
1196   FOR X2 := 1 TO X1+1 DO INLINE[X2].NBL := CHARWIDTH;                   00122200           
1197   IF INLINE[1].C = DIRCH                                                00122300           
1198    THEN BEGIN DIRECTLINE := TRUE; LOWERDIR := TRUE END                  00122400           
1199    ELSE DIRECTLINE := DIRECTLINE AND (INLINE[1].C = PLUS);              00122500           
1200   IF CASECH <> NUL                                                      00122600           
1201    THEN IF DIRECTLINE                                                   00122700           
1202     THEN SHIFTSTRING(INLINE,X1,LOWERDIR)                                00122800           
1203     ELSE SHIFTSTRING(INLINE,X1,LOWERCASE);                              00122900           
1204   IF X1 > 1                                                             00123000           
1205    THEN WHILE (INLINE[X1].C = BLANK) AND (X1 > 1) DO                    00123100           
1206     X1 := X1 - 1;                                                       00123200           
1207   IF X1 = 1                                                             00123300           
1208    THEN IF INLINE[X1].C = BLANK                                         00123400           
1209     THEN X1 := 0;                                                       00123500           
1210   INLENGTH := X1;                                                       00123600           
1211   READLN(INFILE);                                                       00123700           
1212   FIRSTERROR := TRUE;                                                   00123800           
1213   END (* READLINE *);                                                   00123900           
1214                                                                         00124000           
1215                                                                         00124100           
1216                                                                         00124200           
1217                                                                         00124300           
1218  BEGIN (* NEXTCHAR *)                                                   00124400           
1219  INCOLUMN := INCOLUMN + 1;                                              00124500           
1220  IF INCOLUMN > INLENGTH                                                 00124600           
1221   THEN IF EOL                                                           00124700           
1222    THEN IF EOF(INFILE)                                                  00124800           
1223     THEN ENDOFINPUT := TRUE                                             00124900           
1224     ELSE BEGIN READLINE;                                                00125000           
1225      INCOLUMN := 1;                                                     00125100           
1226      IF LINENUMS                                                        00125200           
1227       THEN BEGIN IF CLASS[INLINE[1].C].DIGIT                            00125300           
1228         THEN BEGIN LINENUMBER := 0;                                     00125400           
1229          REPEAT LINENUMBER := LINENUMBER * 10 +                         00125500           
1230                               INLINE[INCOLUMN].C - ZERO;                00125600           
1231           INCOLUMN := INCOLUMN + 1                                      00125700           
1232          UNTIL NOT CLASS[INLINE[INCOLUMN].C].DIGIT                      00125800           
1233          END;                                                           00125900           
1234        INCOLUMN := INCOLUMN + 1                                         00126000           
1235        END                                                              00126100           
1236       ELSE LINENUMBER := LINENUMBER + 1;                                00126200           
1237      EOL := INCOLUMN > INLENGTH;                                        00126300           
1238      IF EOL                                                             00126400           
1239       THEN INCHAR := BLANK                                              00126500           
1240       ELSE INCHAR := INLINE[INCOLUMN].C                                 00126600           
1241      END                                                                00126700           
1242    ELSE BEGIN EOL := TRUE;                                              00126800           
1243     INCHAR := BLANK                                                     00126900           
1244     END                                                                 00127000           
1245   ELSE INCHAR := INLINE[INCOLUMN].C                                     00127100           
1246  END (* NEXTCHAR *);                                                    00127200           
1247                                                                         00127300           
1248                                                                         00127400           
1249                                                                         00127500           
1250                                                                         00127600           
1251                                                                         00127700           
1252 (*        NEXTLINE - ADVANCE TO BEGINNING OF NEXT INPUT LINE.           00127800           
1253  *)                                                                     00127900           
1254                                                                         00128000           
1255  PROCEDURE NEXTLINE;                                                    00128100           
1256  BEGIN (* NEXTLINE *)                                                   00128200           
1257  INCOLUMN := INLENGTH + 1;                                              00128300           
1258  EOL := TRUE;                                                           00128400           
1259  NEXTCHAR                                                               00128500           
1260  END (* NEXTLINE *);                                                    00128600           
1261                                                                         00128700           
1262                                                                         00128800           
1263                                                                         00128900           
1264                                                                         00129000           
1265                                                                         00129100           
1266                                                                         00129200           
1267                                                                         00129300           
1268                                                                         00129400           
1269 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00129500           
1270 (*                                                                   *) 00129600           
1271 (*                       DIRECTIVE PROCESSING                        *) 00129700           
1272 (*                       --------- ----------                        *) 00129800           
1273 (*                                                                   *) 00129900           
1274 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00130000           
1275                                                                         00130100           
1276                                                                         00130200           
1277                                                                         00130300           
1278                                                                         00130400           
1279 (*        BREAK - CAUSE A BREAK IN JUSTIFICATION.                       00130500           
1280  *)                                                                     00130600           
1281                                                                         00130700           
1282  PROCEDURE BREAK;                                                       00130800           
1283  BEGIN (* BREAK *)                                                      00130900           
1284  IF NOT NEWOUTLINE                                                      00131000           
1285   THEN BEGIN IF NOT (LEFTJUSTIFY AND RIGHTJUSTIFY)                      00131100           
1286     THEN JUSTIFY;                                                       00131200           
1287    WRITELINE                                                            00131300           
1288    END;                                                                 00131400           
1289  UNDERLINING := FALSE;                                                  00131500           
1290  NEWPARAGRAPH := TRUE                                                   00131600           
1291  END (* BREAK *);                                                       00131700           
1292                                                                         00131800           
1293                                                                         00131900           
1294                                                                         00132000           
1295                                                                         00132100           
1296 (*        INUNDENT - SCHEDULE AN INDENT OR UNDENT.                      00132200           
1297  *                                                                      00132300           
1298  *        PARAM  INUN > 0 FOR INDENT,                                   00132400           
1299  *                    < 0 FOR UNDENT.                                   00132500           
1300  *)                                                                     00132600           
1301                                                                         00132700           
1302  PROCEDURE INUNDENT( INUN : INTEGER );                                  00132800           
1303  BEGIN (* INUNDENT *)                                                   00132900           
1304  BREAK;                                                                 00133000           
1305  NCHARS := LEFTMARGIN + INUN;                                           00133100           
1306  IF NCHARS < 0 THEN NCHARS := 0;                                        00133200           
1307  OUTLINE[1].NBL := NCHARS * CHARWIDTH                                   00133300           
1308  END (* INUNDENT *);                                                    00133400           
1309                                                                         00133500           
1310                                                                         00133600           
1311                                                                         00133700           
1312                                                                         00133800           
1313 (*      INPSAVE - SAVE INPUT SETTINGS                                   00133900           
1314  *)                                                                     00134000           
1315                                                                         00134100           
1316  PROCEDURE INPSAVE;                                                     00134200           
1317  BEGIN (* INPSAVE *)                                                    00134300           
1318  VALIDATE(KEEPINP,0,MAXKEEP,1151);                                      00134400           
1319  WITH SAVEINP[KEEPINP] DO                                               00134500           
1320   BEGIN DEFINED := TRUE;                                                00134600           
1321   B := EXPLICITBLANK;                                                   00134700           
1322   C := CASECH;                                                          00134800           
1323   D := DIRCH;                                                           00134900           
1324   H := HYPHEN;                                                          00135000           
1325   U := UNDERCHAR;                                                       00135100           
1326   W := INWIDTH                                                          00135200           
1327   END                                                                   00135300           
1328  END (* INPSAVE *);                                                     00135400           
1329                                                                         00135500           
1330                                                                         00135600           
1331                                                                         00135700           
1332 (*      INPRESTORE - RESTORE PREVIOUS INPUT SETTINGS.                   00135800           
1333  *)                                                                     00135900           
1334                                                                         00136000           
1335  PROCEDURE INPRESTORE;                                                  00136100           
1336  BEGIN (* INPRESTORE *)                                                 00136200           
1337  VALIDATE(KEEPINP,0,MAXKEEP,1151);                                      00136300           
1338  WITH SAVEINP[KEEPINP] DO                                               00136400           
1339   IF DEFINED                                                            00136500           
1340    THEN BEGIN EXPLICITBLANK := B;                                       00136600           
1341     IF CASECH <> C                                                      00136700           
1342      THEN BEGIN CASECH := C;                                            00136800           
1343       LOWERCASE := CASECH <> NUL                                        00136900           
1344       END;                                                              00137000           
1345     DIRCH := D;                                                         00137100           
1346     HYPHEN := H;                                                        00137200           
1347     UNDERCHAR := U;                                                     00137300           
1348     INWIDTH := W                                                        00137400           
1349     END                                                                 00137500           
1350    ELSE ERROR(1105)                                                     00137600           
1351  END (* INPRESTORE *);                                                  00137700           
1352                                                                         00137800           
1353                                                                         00137900           
1354                                                                         00138000           
1355                                                                         00138100           
1356 (*      MARSAVE - SAVE MARGIN SETTINGS.                                 00138200           
1357  *)                                                                     00138300           
1358                                                                         00138400           
1359  PROCEDURE MARSAVE;                                                     00138500           
1360  BEGIN (* MARSAVE *)                                                    00138600           
1361  VALIDATE(KEEPMAR,0,MAXKEEP,151);                                       00138700           
1362  WITH SAVEMAR[KEEPMAR] DO                                               00138800           
1363   BEGIN DEFINED := TRUE;                                                00138900           
1364   L := LEFTMARGIN;                                                      00139000           
1365   R := RIGHTMARGIN                                                      00139100           
1366   END                                                                   00139200           
1367  END (* MARSAVE *);                                                     00139300           
1368                                                                         00139400           
1369                                                                         00139500           
1370                                                                         00139600           
1371                                                                         00139700           
1372 (*      MARRESTORE - RESTORE PREVIOUS MARGIN SETTINGS.                  00139800           
1373  *)                                                                     00139900           
1374                                                                         00140000           
1375  PROCEDURE MARRESTORE;                                                  00140100           
1376  BEGIN (* MARRESTORE *)                                                 00140200           
1377  VALIDATE(KEEPMAR,0,MAXKEEP,151);                                       00140300           
1378  WITH SAVEMAR[KEEPMAR] DO                                               00140400           
1379   IF DEFINED                                                            00140500           
1380    THEN BEGIN LEFTMARGIN := L;                                          00140600           
1381     RIGHTMARGIN := R                                                    00140700           
1382     END                                                                 00140800           
1383    ELSE ERROR(105)                                                      00140900           
1384  END (* MARRESTORE *);                                                  00141000           
1385                                                                         00141100           
1386                                                                         00141200           
1387                                                                         00141300           
1388                                                                         00141400           
1389 (*      OPTSAVE - SAVE OPTION SETTINGS.                                 00141500           
1390  *)                                                                     00141600           
1391                                                                         00141700           
1392  PROCEDURE OPTSAVE;                                                     00141800           
1393  BEGIN (* OPTSAVE *)                                                    00141900           
1394  VALIDATE(KEEPOPT,0,MAXKEEP,251);                                       00142000           
1395  WITH SAVEOPT[KEEPOPT] DO                                               00142100           
1396   BEGIN DEFINED := TRUE;                                                00142200           
1397   E := PRINTERRORS;                                                     00142300           
1398   F := FILL;                                                            00142400           
1399   J := BADJUSTIFY;                                                      00142500           
1400   L := LEFTJUSTIFY;                                                     00142600           
1401   M := MULTIPLEBLANKS;                                                  00142700           
1402   P := ENSURE2;                                                         00142800           
1403   R := RIGHTJUSTIFY;                                                    00142900           
1404   S := SPACE;                                                           00143000           
1405   U := SHIFTUP                                                          00143100           
1406   END                                                                   00143200           
1407  END (* OPTSAVE *);                                                     00143300           
1408                                                                         00143400           
1409                                                                         00143500           
1410                                                                         00143600           
1411 (*      OPTRESTORE - RESTORE PREVIOUS OPTION SETTINGS.                  00143700           
1412  *)                                                                     00143800           
1413                                                                         00143900           
1414  PROCEDURE OPTRESTORE;                                                  00144000           
1415  BEGIN (* OPTRESTORE *)                                                 00144100           
1416  VALIDATE(KEEPOPT,0,MAXKEEP,251);                                       00144200           
1417  WITH SAVEOPT[KEEPOPT] DO                                               00144300           
1418   IF DEFINED                                                            00144400           
1419    THEN BEGIN PRINTERRORS := E;                                         00144500           
1420     FILL := F;                                                          00144600           
1421     BADJUSTIFY := J;                                                    00144700           
1422     LEFTJUSTIFY := L;                                                   00144800           
1423     MULTIPLEBLANKS := M;                                                00144900           
1424     ENSURE2 := P;                                                       00145000           
1425     RIGHTJUSTIFY := R;                                                  00145100           
1426     SPACE := S;                                                         00145200           
1427     SHIFTUP := U                                                        00145300           
1428     END                                                                 00145400           
1429    ELSE ERROR(205)                                                      00145500           
1430  END (* OPTRESTORE *);                                                  00145600           
1431                                                                         00145700           
1432                                                                         00145800           
1433                                                                         00145900           
1434                                                                         00146000           
1435 (*      PARSAVE - SAVE PARAGRAPH SETTINGS.                              00146100           
1436  *)                                                                     00146200           
1437                                                                         00146300           
1438  PROCEDURE PARSAVE;                                                     00146400           
1439  BEGIN (* PARSAVE *)                                                    00146500           
1440  VALIDATE(KEEPPAR,0,MAXKEEP,351);                                       00146600           
1441  WITH SAVEPAR[KEEPPAR] DO                                               00146700           
1442   BEGIN DEFINED := TRUE;                                                00146800           
1443   C := 0;  (* IT WOULD SEEM THAT THIS IS SUPERFLUOUS *)                 00146900           
1444   F := PARACHAR;                                                        00147000           
1445   I := LOCKEDDENT;                                                      00147100           
1446   N := NUMBERING;                                                       00147200           
1447   P := PARAPAGE;                                                        00147300           
1448   S := PARASKIP;                                                        00147400           
1449   W := NUMBERWIDTH                                                      00147500           
1450   END                                                                   00147600           
1451  END (* PARSAVE *);                                                     00147700           
1452                                                                         00147800           
1453                                                                         00147900           
1454                                                                         00148000           
1455                                                                         00148100           
1456 (*      PARRESTORE - RESTORE PREVIOUS PARAGRAPH SETTINGS.               00148200           
1457  *)                                                                     00148300           
1458                                                                         00148400           
1459  PROCEDURE PARRESTORE;                                                  00148500           
1460  BEGIN (* PARRESTORE *)                                                 00148600           
1461  VALIDATE(KEEPPAR,0,MAXKEEP,351);                                       00148700           
1462  WITH SAVEPAR[KEEPPAR] DO                                               00148800           
1463   IF DEFINED                                                            00148900           
1464    THEN BEGIN PARACOUNT := C;                                           00149000           
1465     PARACHAR := F;                                                      00149100           
1466     LOCKEDDENT := I;                                                    00149200           
1467     NUMBERING := N;                                                     00149300           
1468     PARAPAGE := P;                                                      00149400           
1469     PARASKIP := S;                                                      00149500           
1470     NUMBERWIDTH := W                                                    00149600           
1471     END                                                                 00149700           
1472    ELSE ERROR(305)                                                      00149800           
1473  END (* PARRESTORE *);                                                  00149900           
1474                                                                         00150000           
1475                                                                         00150100           
1476                                                                         00150200           
1477                                                                         00150300           
1478 (*        DIRECTIVE - PROCESS ONE DIRECTIVE                             00150400           
1479  *)                                                                     00150500           
1480                                                                         00150600           
1481  PROCEDURE DIRECTIVE;                                                   00150700           
1482  VAR                                                                    00150800           
1483   DIR            : DIRECT;   (* CURRENT DIRECTIVE *)                    00150900           
1484   FULLWORD       : CH10;     (* CURRENT DIRECTIVE WORD *)               00151000           
1485   WORD           : CH3;      (* 3 LETTERS OF CURRENT DIRECTIVE WORD *)  00151100           
1486   WORDLENGTH     : INTEGER;  (* LENGTH OF CURRENT DIRECTIVE WORD *)     00151200           
1487   X1,X2          : INTEGER;  (* GENERAL INDEX VARIABLES *)              00151300           
1488                                                                         00151400           
1489                                                                         00151500           
1490                                                                         00151600           
1491                                                                         00151700           
1492                                                                         00151800           
1493                                                                         00151900           
1494                                                                         00152000           
1495  (*      NEXTCH - ADVANCE TO NEXTCHAR, CONSIDERING CONTINUATIONS.       00152100           
1496   *)                                                                    00152200           
1497                                                                         00152300           
1498   PROCEDURE NEXTCH;                                                     00152400           
1499   BEGIN (* NEXTCH *)                                                    00152500           
1500   NEXTCHAR;                                                             00152600           
1501   IF EOL AND (INFILE^ = '+')                                            00152700           
1502    THEN BEGIN NEXTCHAR;                                                 00152800           
1503     INCHAR := BLANK                                                     00152900           
1504     END                                                                 00153000           
1505   END (* NEXTCH *);                                                     00153100           
1506                                                                         00153200           
1507                                                                         00153300           
1508                                                                         00153400           
1509                                                                         00153500           
1510  (*       SWITCH - DETERMINE A SWITCH OPTION, CONSIDERING               00153600           
1511   *                THE DEFAULT.                                         00153700           
1512   *                                                                     00153800           
1513   *       PARAM  DEF = DEFAULT.                                         00153900           
1514   *)                                                                    00154000           
1515                                                                         00154100           
1516   FUNCTION SWITCH( DEF : BOOLEAN ) : BOOLEAN;                           00154200           
1517   BEGIN (* SWITCH *)                                                    00154300           
1518   IF CLASS[INCHAR].PLUSORMINUS                                          00154400           
1519    THEN BEGIN SWITCH := INCHAR = PLUS;                                  00154500           
1520     NEXTCH                                                              00154600           
1521     END                                                                 00154700           
1522    ELSE SWITCH := DEF                                                   00154800           
1523   END (* SWITCH *);                                                     00154900           
1524                                                                         00155000           
1525                                                                         00155100           
1526                                                                         00155200           
1527                                                                         00155300           
1528  (*       CHARACTER - DETERMINE A CHARACTER OPTION, CONSIDERING         00155400           
1529   *                   THE DEFAULT.                                      00155500           
1530   *                                                                     00155600           
1531   *       PARAM  DEF = DEFAULT.                                         00155700           
1532   *)                                                                    00155800           
1533                                                                         00155900           
1534   FUNCTION CHARACTER( DEF : ASCII ) : ASCII;                            00156000           
1535   BEGIN (* CHARACTER *)                                                 00156100           
1536   IF INCHAR <> BLANK                                                    00156200           
1537    THEN BEGIN CHARACTER := INCHAR;                                      00156300           
1538     NEXTCH                                                              00156400           
1539     END                                                                 00156500           
1540    ELSE CHARACTER := DEF                                                00156600           
1541   END (* CHARACTER *);                                                  00156700           
1542                                                                         00156800           
1543                                                                         00156900           
1544                                                                         00157000           
1545                                                                         00157100           
1546  (*       NUMBER - DETERMINE A NUMERIC OPTION, CONSIDERING              00157200           
1547   *                THE DEFAULT AND THE PREVIOUS VALUE.                  00157300           
1548   *                                                                     00157400           
1549   *       PARAM  DEF  = DEFAULT.                                        00157500           
1550   *              LAST = PREVIOUS VALUE, IF < 0 THEN                     00157600           
1551   *                     RELATIVE FORM IS NOT RECOGNIZED.                00157700           
1552   *              MIN  = MINIMUM ALLOWED VALUE.                          00157800           
1553   *              MAX  = MAXIMUM ALLOWED VALUE.                          00157900           
1554   *              ERR  = ERROR NUMBER (IF OUT OF RANGE).                 00158000           
1555   *)                                                                    00158100           
1556                                                                         00158200           
1557   FUNCTION NUMBER( DEF,LAST,MIN,MAX,ERR : INTEGER ) : INTEGER;          00158300           
1558   VAR                                                                   00158400           
1559    NUM           : INTEGER;  (* NUMBER BEING BUILT *)                   00158500           
1560    SIGN          : ASCII;    (* PLUS OR MINUS SIGN *)                   00158600           
1561   BEGIN (* NUMBER *)                                                    00158700           
1562   IF CLASS[INCHAR].PLUSORMINUS AND (LAST >= 0)                          00158800           
1563    THEN BEGIN SIGN := INCHAR; NEXTCH END                                00158900           
1564    ELSE BEGIN SIGN := PLUS; LAST := 0 END;                              00159000           
1565   IF CLASS[INCHAR].DIGIT                                                00159100           
1566    THEN BEGIN NUM := 0;                                                 00159200           
1567     REPEAT NUM := NUM * 10 + INCHAR - ZERO;                             00159300           
1568      IF NUM >= INFINITY THEN NUM := INFINITY - 1;                       00159400           
1569      NEXTCH                                                             00159500           
1570     UNTIL NOT CLASS[INCHAR].DIGIT                                       00159600           
1571     END                                                                 00159700           
1572    ELSE NUM := DEF;                                                     00159800           
1573   IF SIGN = PLUS                                                        00159900           
1574    THEN NUM := LAST + NUM                                               00160000           
1575    ELSE NUM := LAST - NUM;                                              00160100           
1576   IF NUM < 0 THEN NUM := 0;                                             00160200           
1577   VALIDATE(NUM,MIN,MAX,ERR);                                            00160300           
1578   NUMBER := NUM                                                         00160400           
1579   END (* NUMBER *);                                                     00160500           
1580                                                                         00160600           
1581                                                                         00160700           
1582                                                                         00160800           
1583                                                                         00160900           
1584  (*       READWORD - READ THE NEXT DIRECTIVE WORD.                      00161000           
1585   *)                                                                    00161100           
1586                                                                         00161200           
1587   PROCEDURE READWORD;                                                   00161300           
1588   VAR                                                                   00161400           
1589    X1            : INTEGER;  (* LOOP INDEX *)                           00161500           
1590   BEGIN (* READWORD *)                                                  00161600           
1591   WORDLENGTH := 0;                                                      00161700           
1592   WHILE CLASS[INCHAR].LETTER DO                                         00161800           
1593    BEGIN WORDLENGTH := WORDLENGTH + 1;                                  00161900           
1594    IF WORDLENGTH <= 10                                                  00162000           
1595     THEN BEGIN FULLWORD[WORDLENGTH] := INCHAR;                          00162100           
1596      IF WORDLENGTH <= 3 THEN WORD[WORDLENGTH] := UPPER(INCHAR)          00162200           
1597      END;                                                               00162300           
1598    NEXTCH                                                               00162400           
1599    END;                                                                 00162500           
1600   FOR X1 := WORDLENGTH + 1 TO 10 DO FULLWORD[X1] := BLANK;              00162600           
1601   FOR X1 := WORDLENGTH + 1 TO 3 DO WORD[X1] := BLANK                    00162700           
1602   END (* READWORD *);                                                   00162800           
1603                                                                         00162900           
1604                                                                         00163000           
1605                                                                         00163100           
1606                                                                         00163200           
1607  (*        READPSTRING - READ A PSTRING UNTIL A TERMINATOR CHARACTER.   00163300           
1608   *                                                                     00163400           
1609   *        PARAM  STR = PSTRING TO BE READ.                             00163500           
1610   *               LEN = LENGTH OF PREDEFINED PORTION OF STR, UPDATED    00163600           
1611   *                     TO NEW LENGTH.                                  00163700           
1612   *               ENDC = TERMINATOR CHARACTER.                          00163800           
1613   *)                                                                    00163900           
1614                                                                         00164000           
1615   PROCEDURE READPSTRING( VAR STR : PSTRING; VAR LEN : INTEGER;          00164100           
1616                         ENDC : ASCII );                                 00164200           
1617   BEGIN (* READPSTRING *)                                               00164300           
1618   UNDERDIR := FALSE;                                                    00164400           
1619   WHILE (INCHAR <> ENDC) AND NOT EOL DO                                 00164500           
1620    BEGIN IF INCHAR = UNDERCHAR                                          00164600           
1621     THEN UNDERDIR := NOT UNDERDIR                                       00164700           
1622     ELSE IF LEN < MAXSTRINGLENGTH                                       00164800           
1623      THEN BEGIN LEN := LEN + 1;                                         00164900           
1624      IF UNDERDIR                                                        00165000           
1625       THEN STR[LEN] := INCHAR + 128                                     00165100           
1626       ELSE STR[LEN] := INCHAR                                           00165200           
1627      END;                                                               00165300           
1628    NEXTCH                                                               00165400           
1629    END                                                                  00165500           
1630   END (* READPSTRING *);                                                00165600           
1631                                                                         00165700           
1632                                                                         00165800           
1633                                                                         00165900           
1634                                                                         00166000           
1635  (*       LOOKUP - LOOK UP THE DIRECTIVE WORD.                          00166100           
1636   *                                                                     00166200           
1637   *       PARAM  FIRST = FIRST ACCEPTABLE DIRECTIVE WORD.               00166300           
1638   *              ILLEGAL = LAST+1 ACCEPTABLE DIRECTIVE WORD.            00166400           
1639   *)                                                                    00166500           
1640                                                                         00166600           
1641   FUNCTION LOOKUP( FIRST,ILLEGAL : DIRECT ) : DIRECT;                   00166700           
1642   VAR                                                                   00166800           
1643    D             : DIRECT;   (* LOOKUP LOOP INDEX *)                    00166900           
1644   BEGIN (* LOOKUP *)                                                    00167000           
1645   DIRECTS[ILLEGAL] := WORD;                                             00167100           
1646   D := FIRST;                                                           00167200           
1647   WHILE (DIRECTS[D][1] <> WORD[1]) OR                                   00167300           
1648         (DIRECTS[D][2] <> WORD[2]) OR                                   00167400           
1649         (DIRECTS[D][3] <> WORD[3]) DO                                   00167500           
1650    D := SUCC(D);                                                        00167600           
1651   LOOKUP := D                                                           00167700           
1652   END (* LOOKUP *);                                                     00167800           
1653                                                                         00167900           
1654                                                                         00168000           
1655                                                                         00168100           
1656                                                                         00168200           
1657  (*       INPUT - PROCESS INPUT DIRECTIVE.                              00168300           
1658   *)                                                                    00168400           
1659                                                                         00168500           
1660   PROCEDURE INPUTD;                                                     00168600           
1661   VAR                                                                   00168700           
1662    CH            : ASCII;    (* KEY CHARACTER *)                        00168800           
1663   BEGIN (* INPUTD *)                                                    00168900           
1664   IF INCHAR = LPAREN                                                    00169000           
1665    THEN BEGIN NEXTCH;                                                   00169100           
1666     KEEPINP := KEEPINP + 1;                                             00169200           
1667     WHILE (INCHAR <> RPAREN) AND NOT EOL DO                             00169300           
1668      BEGIN CH := UPPER(INCHAR);                                         00169400           
1669      NEXTCH;                                                            00169500           
1670      IF CLASS[CH].INPUTCHAR                                             00169600           
1671       THEN CASE CH OF                                                   00169700           
1672        B : EXPLICITBLANK := CHARACTER(NUL);                             00169800           
1673        C : BEGIN CH := CHARACTER(NUL);                                  00169900           
1674            IF CH <> CASECH                                              00170000           
1675             THEN BEGIN CASECH := CH;                                    00170100           
1676              LOWERCASE := CASECH <> NUL                                 00170200           
1677              END                                                        00170300           
1678            END;                                                         00170400           
1679        D : DIRCH := CHARACTER(PERIOD);                                  00170500           
1680        H : HYPHEN := CHARACTER(NUL);                                    00170600           
1681        K : KEEPINP := NUMBER(0,-1,0,MAXKEEP,1151);                      00170700           
1682        U : UNDERCHAR := CHARACTER(NUL);                                 00170800           
1683        W : INWIDTH := NUMBER(150,-1,MIN,MAXIWIDTH,1154);                00170900           
1684        BLANK :                                                          00171000           
1685        END                                                              00171100           
1686       ELSE BEGIN ERROR1 := CH; ERROR(1101) END                          00171200           
1687      END;                                                               00171300           
1688     IF INCHAR = RPAREN                                                  00171400           
1689      THEN NEXTCH                                                        00171500           
1690      ELSE ERROR(1102);                                                  00171600           
1691     INPSAVE                                                             00171700           
1692     END                                                                 00171800           
1693    ELSE BEGIN IF CLASS[INCHAR].DIGIT                                    00171900           
1694      THEN KEEPINP := NUMBER(0,-1,0,MAXKEEP,1151)                        00172000           
1695      ELSE KEEPINP := KEEPINP - 1;                                       00172100           
1696     INPRESTORE                                                          00172200           
1697     END                                                                 00172300           
1698   END (* INPUTD *);                                                     00172400           
1699                                                                         00172500           
1700                                                                         00172600           
1701                                                                         00172700           
1702                                                                         00172800           
1703  (*       LITERAL - PROCESS LITERAL DIRECTIVE.                          00172900           
1704   *)                                                                    00173000           
1705                                                                         00173100           
1706   PROCEDURE LITERAL;                                                    00173200           
1707   VAR                                                                   00173300           
1708    CH            : ASCIIX;   (* LITERAL CHARACTER *)                    00173400           
1709    I             : INTEGER;  (* LOOP INDEX *)                           00173500           
1710    LITLENGTH     : INTEGER;  (* LENGTH OF LITSTRING *)                  00173600           
1711    LITSTRING     : PSTRING;  (* ARGUMENT OF LITERAL DIRECTIVE *)        00173700           
1712   BEGIN (* LITERAL *)                                                   00173800           
1713   LITLENGTH := 0;                                                       00173900           
1714   READPSTRING(LITSTRING,LITLENGTH,NUL);                                 00174000           
1715   FOR I := 1 TO LITLENGTH DO                                            00174100           
1716    BEGIN CH := LITSTRING[I];                                            00174200           
1717    IF CH = EXPLICITBLANK                                                00174300           
1718     THEN WRITE1(BLANK)                                                  00174400           
1719     ELSE WRITE1(CH)                                                     00174500           
1720    END;                                                                 00174600           
1721   WRITELN                                                               00174700           
1722   END (* LITERAL *);                                                    00174800           
1723                                                                         00174900           
1724                                                                         00175000           
1725                                                                         00175100           
1726                                                                         00175200           
1727  (*       MARGIN - PROCESS MARGIN DIRECTIVE.                            00175300           
1728   *)                                                                    00175400           
1729                                                                         00175500           
1730   PROCEDURE MARGIN;                                                     00175600           
1731   VAR                                                                   00175700           
1732    CH            : ASCII;    (* KEY CHARACTER *)                        00175800           
1733   BEGIN (* MARGIN *)                                                    00175900           
1734   IF INCHAR = LPAREN                                                    00176000           
1735    THEN BEGIN NEXTCH;                                                   00176100           
1736     KEEPMAR := KEEPMAR + 1;                                             00176200           
1737     WHILE (INCHAR <> RPAREN) AND NOT EOL DO                             00176300           
1738      BEGIN CH := UPPER(INCHAR);                                         00176400           
1739      NEXTCH;                                                            00176500           
1740      IF CLASS[CH].MARGINCHAR                                            00176600           
1741       THEN CASE CH OF                                                   00176700           
1742        K : KEEPMAR := NUMBER(0,-1,0,MAXKEEP,151);                       00176800           
1743        L : LEFTMARGIN := NUMBER(0,LEFTMARGIN,0,INFINITY,0);             00176900           
1744        R : RIGHTMARGIN := NUMBER(70,RIGHTMARGIN,0,INFINITY,0);          00177000           
1745        BLANK :                                                          00177100           
1746        END                                                              00177200           
1747       ELSE BEGIN ERROR1 := CH; ERROR(101) END                           00177300           
1748      END;                                                               00177400           
1749     IF INCHAR = RPAREN                                                  00177500           
1750      THEN NEXTCH                                                        00177600           
1751      ELSE ERROR(102);                                                   00177700           
1752     VALIDATE(RIGHTMARGIN,MIN,MAXMARGIN,152);                            00177800           
1753     VALIDATE(LEFTMARGIN,0,RIGHTMARGIN,153);                             00177900           
1754     MARSAVE                                                             00178000           
1755     END                                                                 00178100           
1756    ELSE BEGIN IF CLASS[INCHAR].DIGIT                                    00178200           
1757      THEN KEEPMAR := NUMBER(0,-1,0,MAXKEEP,151)                         00178300           
1758      ELSE KEEPMAR := KEEPMAR - 1;                                       00178400           
1759     MARRESTORE                                                          00178500           
1760     END;                                                                00178600           
1761   NCHARS := LEFTMARGIN;                                                 00178700           
1762   OUTLINE[1].NBL := NCHARS * CHARWIDTH                                  00178800           
1763   END (* MARGIN *);                                                     00178900           
1764                                                                         00179000           
1765                                                                         00179100           
1766                                                                         00179200           
1767                                                                         00179300           
1768  (*       OPTION - PROCESS OPTION DIRECTIVE.                            00179400           
1769   *)                                                                    00179500           
1770                                                                         00179600           
1771   PROCEDURE OPTION;                                                     00179700           
1772   VAR                                                                   00179800           
1773    CH            : ASCII;    (* KEY CHARACTER *)                        00179900           
1774   BEGIN (* OPTION *)                                                    00180000           
1775   IF INCHAR = LPAREN                                                    00180100           
1776    THEN BEGIN NEXTCH;                                                   00180200           
1777     KEEPOPT := KEEPOPT + 1;                                             00180300           
1778     WHILE (INCHAR <> RPAREN) AND NOT EOL DO                             00180400           
1779      BEGIN CH := UPPER(INCHAR);                                         00180500           
1780      NEXTCH;                                                            00180600           
1781      IF CLASS[CH].OPTIONCHAR                                            00180700           
1782       THEN CASE CH OF                                                   00180800           
1783        E : PRINTERRORS := SWITCH(TRUE);                                 00180900           
1784        F : FILL := SWITCH(TRUE);                                        00181000           
1785        J : BADJUSTIFY := NUMBER(3,-1,3,INFINITY,265) - 2;               00181100           
1786        K : KEEPOPT := NUMBER(0,-1,0,MAXKEEP,251);                       00181200           
1787        L : LEFTJUSTIFY := SWITCH(TRUE);                                 00181300           
1788        M : MULTIPLEBLANKS := SWITCH(TRUE);                              00181400           
1789        P : ENSURE2 := SWITCH(TRUE);                                     00181500           
1790        R : RIGHTJUSTIFY := SWITCH(TRUE);                                00181600           
1791        S : SPACE := NUMBER(1,-1,1,3,266) - 1;                           00181700           
1792        U : SHIFTUP := SWITCH(FALSE);                                    00181800           
1793        BLANK :                                                          00181900           
1794        END                                                              00182000           
1795       ELSE BEGIN ERROR1 := CH; ERROR(201) END                           00182100           
1796      END;                                                               00182200           
1797     IF INCHAR = RPAREN                                                  00182300           
1798      THEN NEXTCH                                                        00182400           
1799      ELSE ERROR(202);                                                   00182500           
1800     OPTSAVE                                                             00182600           
1801     END                                                                 00182700           
1802    ELSE BEGIN IF CLASS[INCHAR].DIGIT                                    00182800           
1803      THEN KEEPOPT := NUMBER(0,-1,0,MAXKEEP,251)                         00182900           
1804      ELSE KEEPOPT := KEEPOPT - 1;                                       00183000           
1805     OPTRESTORE                                                          00183100           
1806     END                                                                 00183200           
1807   END (* OPTION *);                                                     00183300           
1808                                                                         00183400           
1809                                                                         00183500           
1810                                                                         00183600           
1811                                                                         00183700           
1812  (*       OUTPUT - PROCESS OUTPUT DIRECTIVE.                            00183800           
1813   *)                                                                    00183900           
1814                                                                         00184000           
1815   PROCEDURE OUTPUTD;                                                    00184100           
1816   VAR                                                                   00184200           
1817    CH            : ASCII;    (* KEY CHARACTER *)                        00184300           
1818   BEGIN (* OUTPUTD *)                                                   00184400           
1819   IF LINECOUNT < 0                                                      00184500           
1820    THEN BEGIN IF INCHAR = LPAREN                                        00184600           
1821      THEN BEGIN REPEAT NEXTCH UNTIL (INCHAR <> BLANK) OR EOL;           00184700           
1822       READWORD;                                                         00184800           
1823       IF WORDLENGTH <= 3                                                00184900           
1824        THEN TERMINALTYPE := LOOKUP(AST,ILT)                             00185000           
1825        ELSE TERMINALTYPE := ILT;                                        00185100           
1826       IF TERMINALTYPE = ILT                                             00185200           
1827        THEN BEGIN ERROR(1009); TERMINALTYPE := AST END;                 00185300           
1828       CASE TERMINALTYPE OF                                              00185400           
1829        AST : ;                                                          00185500           
1830        LPT : CARRIAGECONTROL := ONE;                                    00185600           
1831        AJT : BEGIN WHILE INCHAR = BLANK DO NEXTCH;                      00185700           
1832              CHARWIDTH :=                                               00185800           
1833               ROUND(60.0 / NUMBER(10,-1,MINPITCH,MAXPITCH,1063));       00185900           
1834              WRITE1(ESC); WRITE1(ZERO);                                 00186000           
1835              WRITE1(ESC); WRITE1(P);                                    00186100           
1836              WRITE1(ESC); WRITE1(H); WRITE1(PLUS);                      00186200           
1837              WRITE1(CHARWIDTH + ZERO)                                   00186300           
1838              END                                                        00186400           
1839        END;                                                             00186500           
1840       WHILE (INCHAR <> RPAREN) AND NOT EOL DO                           00186600           
1841        BEGIN CH := UPPER(INCHAR);                                       00186700           
1842        NEXTCH;                                                          00186800           
1843        IF CLASS[CH].OUTPUTCHAR                                          00186900           
1844         THEN CASE CH OF                                                 00187000           
1845          E : EJECT := SWITCH(FALSE);                                    00187100           
1846          P : PAUSE := SWITCH(FALSE);                                    00187200           
1847          S : SHIFT := NUMBER(0,-1,0,MAXSHIFT,1064);                     00187300           
1848          U : UNDERAVAIL := SWITCH(TRUE);                                00187400           
1849          W : OUTWIDTH := NUMBER(MAXOWIDTH,-1,0,MAXOWIDTH,1054);         00187500           
1850          BLANK :                                                        00187600           
1851          END                                                            00187700           
1852         ELSE BEGIN ERROR1 := CH; ERROR(1001) END                        00187800           
1853        END;                                                             00187900           
1854       IF INCHAR = RPAREN                                                00188000           
1855        THEN NEXTCH                                                      00188100           
1856        ELSE ERROR(1002);                                                00188200           
1857       SHIFT := SHIFT * CHARWIDTH;                                       00188300           
1858       LINECOUNT := 0                                                    00188400           
1859       END                                                               00188500           
1860     END                                                                 00188600           
1861    ELSE ERROR(1010)                                                     00188700           
1862   END (* OUTPUTD *);                                                    00188800           
1863                                                                         00188900           
1864                                                                         00189000           
1865                                                                         00189100           
1866                                                                         00189200           
1867  (*       PARAGRAPH - PROCESS PARAGRAPH DIRECTIVE.                      00189300           
1868   *)                                                                    00189400           
1869                                                                         00189500           
1870   PROCEDURE PARAGRAPH;                                                  00189600           
1871   VAR                                                                   00189700           
1872    CH            : ASCII;    (* KEY CHARACTER *)                        00189800           
1873   BEGIN (* PARAGRAPH *)                                                 00189900           
1874   SAVEPAR[KEEPPAR].C := PARACOUNT;                                      00190000           
1875   IF INCHAR = LPAREN                                                    00190100           
1876    THEN BEGIN NEXTCH;                                                   00190200           
1877     KEEPPAR := KEEPPAR + 1;                                             00190300           
1878     PARACOUNT := 0;                                                     00190400           
1879     WHILE (INCHAR <> RPAREN) AND NOT EOL DO                             00190500           
1880      BEGIN CH := UPPER(INCHAR);                                         00190600           
1881      NEXTCH;                                                            00190700           
1882      IF CLASS[CH].PARAGRAPHCHAR                                         00190800           
1883       THEN CASE CH OF                                                   00190900           
1884        C : PARACOUNT := NUMBER(0,-1,0,INFINITY,0);                      00191000           
1885        F : PARACHAR := CHARACTER(NUL);                                  00191100           
1886        I : LOCKEDDENT := NUMBER(5,-1,0,RIGHTMARGIN-MIN,355);            00191200           
1887        K : KEEPPAR := NUMBER(0,-1,0,MAXKEEP,351);                       00191300           
1888        N : BEGIN IF NOT CLASS[INCHAR].DIGIT                             00191400           
1889             THEN NUMBERING := NUMFORM(CHARACTER(BLANK),307)             00191500           
1890             ELSE NUMBERING := NUMERIC;                                  00191600           
1891            NUMBERWIDTH := NUMBER(3,-1,0,MAXNUMBERWIDTH,356)             00191700           
1892            END;                                                         00191800           
1893        P : PARAPAGE := NUMBER(0,-1,0,INFINITY,0);                       00191900           
1894        S : PARASKIP := NUMBER(0,PARASKIP,0,MAXSKIP,357);                00192000           
1895        U : LOCKEDDENT := -NUMBER(0,-1,0,INFINITY,0);                    00192100           
1896        BLANK :                                                          00192200           
1897        END                                                              00192300           
1898       ELSE BEGIN ERROR1 := CH; ERROR(301) END                           00192400           
1899      END;                                                               00192500           
1900     IF INCHAR = RPAREN                                                  00192600           
1901      THEN NEXTCH                                                        00192700           
1902      ELSE ERROR(302);                                                   00192800           
1903     PARSAVE                                                             00192900           
1904     END                                                                 00193000           
1905    ELSE IF CLASS[INCHAR].DIGIT                                          00193100           
1906     THEN BEGIN KEEPPAR := NUMBER(0,-1,0,MAXKEEP,351);                   00193200           
1907      PARRESTORE;                                                        00193300           
1908      PARACOUNT := 0                                                     00193400           
1909      END                                                                00193500           
1910     ELSE BEGIN KEEPPAR := KEEPPAR - 1;                                  00193600           
1911      PARRESTORE                                                         00193700           
1912      END                                                                00193800           
1913   END (* PARAGRAPH *);                                                  00193900           
1914                                                                         00194000           
1915                                                                         00194100           
1916                                                                         00194200           
1917                                                                         00194300           
1918  (*       READFORM - READ THE FORM SPECIFICATION TO THE FORM BUFFER.    00194400           
1919   *)                                                                    00194500           
1920                                                                         00194600           
1921   PROCEDURE READFORM;                                                   00194700           
1922   VAR                                                                   00194800           
1923    NOBRACKET     : BOOLEAN;  (* IF NO LBRACKET IN THE FORM *)           00194900           
1924    QUOTE         : ASCII;    (* OUTER QUOTE CHARACTER FOR A STRING *)   00195000           
1925                                                                         00195100           
1926                                                                         00195200           
1927                                                                         00195300           
1928                                                                         00195400           
1929   (*      ADDCH - ADD A CHARACTER TO THE FORM.                          00195500           
1930    *                                                                    00195600           
1931    *      PARAM  CH = CHARACTER TO ADD.                                 00195700           
1932    *)                                                                   00195800           
1933                                                                         00195900           
1934    PROCEDURE ADDCH( CH : ASCII );                                       00196000           
1935    BEGIN (* ADDCH *)                                                    00196100           
1936    FORMNLENGTH := FORMNLENGTH + 1;                                      00196200           
1937    FORMNEXT[FORMNLENGTH] := CH                                          00196300           
1938    END (* ADDCH *);                                                     00196400           
1939                                                                         00196500           
1940                                                                         00196600           
1941                                                                         00196700           
1942                                                                         00196800           
1943   BEGIN (* READFORM *)                                                  00196900           
1944   FORMNLENGTH := 0;                                                     00197000           
1945   NOBRACKET := TRUE;                                                    00197100           
1946   IF INCHAR = LPAREN                                                    00197200           
1947    THEN BEGIN NEXTCH;                                                   00197300           
1948     WHILE (INCHAR <> RPAREN) AND NOT EOL DO                             00197400           
1949      BEGIN ADDCH(INCHAR);                                               00197500           
1950      NOBRACKET := NOBRACKET AND (INCHAR <> LBRACKET);                   00197600           
1951      IF CLASS[INCHAR].QUOTE                                             00197700           
1952       THEN BEGIN QUOTE := INCHAR;                                       00197800           
1953        NEXTCH;                                                          00197900           
1954        READPSTRING(FORMNEXT,FORMNLENGTH,QUOTE);                         00198000           
1955        IF INCHAR = QUOTE                                                00198100           
1956         THEN NEXTCH                                                     00198200           
1957         ELSE ERROR(403);                                                00198300           
1958        ADDCH(QUOTE)                                                     00198400           
1959        END                                                              00198500           
1960       ELSE NEXTCH                                                       00198600           
1961      END;                                                               00198700           
1962     IF INCHAR = RPAREN                                                  00198800           
1963      THEN NEXTCH                                                        00198900           
1964      ELSE ERROR(402);                                                   00199000           
1965     IF NOBRACKET THEN ADDCH(LBRACKET)                                   00199100           
1966     END                                                                 00199200           
1967    ELSE LINECOUNT := INFINITY                                           00199300           
1968   END (* READFORM *);                                                   00199400           
1969                                                                         00199500           
1970                                                                         00199600           
1971                                                                         00199700           
1972                                                                         00199800           
1973  (*       READINX - READ AN INDEX ENTRY.                                00199900           
1974   *)                                                                    00200000           
1975                                                                         00200100           
1976   PROCEDURE READINX;                                                    00200200           
1977   VAR                                                                   00200300           
1978    INDEX         : PSTRING;  (* INDEX BUFFER *)                         00200400           
1979    INDEXLENGTH   : INTEGER;  (* LENGTH OF INDEX *)                      00200500           
1980    P             : PINXENTRY;(* POINTER TO NEW INDEX ENTRY *)           00200600           
1981    X1            : INTEGER;  (* GENERAL INDEX VARIABLE *)               00200700           
1982   BEGIN (* READINDEX *)                                                 00200800           
1983   INDEXLENGTH := 0;                                                     00200900           
1984   READPSTRING(INDEX,INDEXLENGTH,NUL);                                   00201000           
1985   NEW(P);                                                               00201100           
1986   IF INDEXLENGTH > MAXINXLENGTH THEN INDEXLENGTH := MAXINXLENGTH;       00201200           
1987   WITH P^ DO                                                            00201300           
1988    BEGIN XL := INDEXLENGTH;                                             00201400           
1989    XP := PAGENUMBER;                                                    00201500           
1990    FOR X1 := 1 TO INDEXLENGTH DO X[X1] := INDEX[X1];                    00201600           
1991    FOR X1 := INDEXLENGTH+1 TO MAXINXLENGTH DO X[X1] := NUL              00201700           
1992    END;                                                                 00201800           
1993   IF INXBASE = NIL                                                      00201900           
1994    THEN INXBASE := P                                                    00202000           
1995    ELSE INXLAST^.NEXT := P;                                             00202100           
1996   INXLAST := P                                                          00202200           
1997   END (* READINX *);                                                    00202300           
1998                                                                         00202400           
1999                                                                         00202500           
2000                                                                         00202600           
2001                                                                         00202700           
2002  (*       RESET - PROCESS RESET DIRECTIVE.                              00202800           
2003   *)                                                                    00202900           
2004                                                                         00203000           
2005   PROCEDURE RESET;                                                      00203100           
2006   VAR                                                                   00203200           
2007    D             : DIRECT;   (* RESET DIRECTIVE NAME *)                 00203300           
2008    EXCEPT        : BOOLEAN;  (* EXCEPT KEYWORD IS PRESENT *)            00203400           
2009    FIRST         : BOOLEAN;  (* FIRST DIRECTIVE NAME *)                 00203500           
2010    WHICH         : DIRSET;   (* WHICH DIRECTIVES TO RESET *)            00203600           
2011   BEGIN (* RESET *)                                                     00203700           
2012   IF INCHAR = LPAREN                                                    00203800           
2013    THEN BEGIN FIRST := TRUE;                                            00203900           
2014     EXCEPT := FALSE;                                                    00204000           
2015     WHICH := [];                                                        00204100           
2016     NEXTCH;                                                             00204200           
2017     WHILE INCHAR <> RPAREN DO                                           00204300           
2018      IF INCHAR = BLANK                                                  00204400           
2019       THEN NEXTCH                                                       00204500           
2020       ELSE IF CLASS[INCHAR].LETTER                                      00204600           
2021        THEN BEGIN READWORD;                                             00204700           
2022         D := LOOKUP(BRE,ILL);                                           00204800           
2023         IF D IN [COU,FRM,INP,INX,MAR,OPT,OUT,PAG,PAR,SEL,SBT,TTL]       00204900           
2024          THEN WHICH := WHICH + [D]                                      00205000           
2025          ELSE IF D = EXC                                                00205100           
2026           THEN IF FIRST                                                 00205200           
2027            THEN EXCEPT := TRUE                                          00205300           
2028            ELSE ERROR(1211)                                             00205400           
2029           ELSE BEGIN ERROR10 := FULLWORD;                               00205500           
2030            IF D = ILL                                                   00205600           
2031             THEN ERROR(1206)                                            00205700           
2032             ELSE ERROR(1212)                                            00205800           
2033            END;                                                         00205900           
2034         FIRST := FALSE                                                  00206000           
2035         END                                                             00206100           
2036        ELSE BEGIN ERROR1 := INCHAR; ERROR(1201); NEXTCH END;            00206200           
2037     IF EXCEPT THEN WHICH := [BRE..ILL] - WHICH                          00206300           
2038     END                                                                 00206400           
2039    ELSE WHICH := [BRE..ILL];                                            00206500           
2040   WHILE NOT EOL DO NEXTCH;                                              00206600           
2041   IF [OUT,PAG,FRM] * WHICH <> []                                        00206700           
2042    THEN BEGIN PAGE(INFINITY);                                           00206800           
2043     IF LINECOUNT < INFINITY THEN ADVANCEFORM                            00206900           
2044     END;                                                                00207000           
2045   REINITIALIZE(WHICH)                                                   00207100           
2046   END (* RESET *);                                                      00207200           
2047                                                                         00207300           
2048                                                                         00207400           
2049                                                                         00207500           
2050                                                                         00207600           
2051  (*       SELECT - PROCESS SELECT DIRECTIVE.                            00207700           
2052   *)                                                                    00207800           
2053                                                                         00207900           
2054   PROCEDURE SELECT;                                                     00208000           
2055   VAR                                                                   00208100           
2056    X1,X2         : INTEGER;  (* GENERAL INDEX VARIABLES *)              00208200           
2057   BEGIN (* SELECT *)                                                    00208300           
2058   IF INCHAR = LPAREN                                                    00208400           
2059    THEN BEGIN NEXTCH;                                                   00208500           
2060     FOR X1 := 0 TO MAXPAGE DO SELECTION[X1] := FALSE;                   00208600           
2061     WHILE (INCHAR <> RPAREN) AND NOT EOL DO                             00208700           
2062      IF CLASS[INCHAR].DIGIT                                             00208800           
2063       THEN BEGIN X1 := NUMBER(0,-1,0,MAXPAGE,504);                      00208900           
2064        IF INCHAR = COLON                                                00209000           
2065         THEN BEGIN NEXTCH;                                              00209100           
2066          FOR X1 := X1 TO NUMBER(X1,X1,X1,MAXPAGE,504) DO                00209200           
2067           SELECTION[X1] := TRUE                                         00209300           
2068          END                                                            00209400           
2069         ELSE SELECTION[X1] := TRUE                                      00209500           
2070        END                                                              00209600           
2071       ELSE BEGIN IF INCHAR <> BLANK                                     00209700           
2072         THEN BEGIN ERROR1 := INCHAR; ERROR(501) END;                    00209800           
2073        NEXTCHAR                                                         00209900           
2074        END;                                                             00210000           
2075     IF INCHAR = RPAREN                                                  00210100           
2076      THEN NEXTCH                                                        00210200           
2077      ELSE ERROR(502)                                                    00210300           
2078     END                                                                 00210400           
2079    ELSE FOR X1 := 0 TO MAXPAGE DO SELECTION[X1] := TRUE                 00210500           
2080   END (* SELECT *);                                                     00210600           
2081                                                                         00210700           
2082                                                                         00210800           
2083                                                                         00210900           
2084                                                                         00211000           
2085  (*       SORTINX - SORT AND PRINT INDEX ENTRIES.                       00211100           
2086   *)                                                                    00211200           
2087                                                                         00211300           
2088   PROCEDURE SORTINX;                                                    00211400           
2089   VAR                                                                   00211500           
2090    FIRSTINX      : PINXENTRY;(* FIRST ENTRY FOR SORTING *)              00211600           
2091    LASTINX       : PINXENTRY;(* LAST ENTRY FOR SORTING *)               00211700           
2092    LEFTWIDTH     : INTEGER;  (* L SPECIFICATION *)                      00211800           
2093    MARGIN        : INTEGER;  (* M SPECIFICATION *)                      00211900           
2094    PAGECOL       : INTEGER;  (* P SPECIFICATION *)                      00212000           
2095    RIGHTWIDTH    : INTEGER;  (* R SPECIFICATION *)                      00212100           
2096    SORTCOL       : INTEGER;  (* S SPECIFICATION *)                      00212200           
2097                                                                         00212300           
2098                                                                         00212400           
2099                                                                         00212500           
2100                                                                         00212600           
2101   (*      PARSE - PARSE THE SORTINDEX DIRECTIVE.                        00212700           
2102    *)                                                                   00212800           
2103                                                                         00212900           
2104    PROCEDURE PARSE;                                                     00213000           
2105    VAR                                                                  00213100           
2106     CH           : ASCII;    (* KEY CHARACTER *)                        00213200           
2107    BEGIN (* PARSE *)                                                    00213300           
2108    LEFTWIDTH := 2;                                                      00213400           
2109    MARGIN := 0;                                                         00213500           
2110    PAGECOL := 0;                                                        00213600           
2111    RIGHTWIDTH := 2;                                                     00213700           
2112    SORTCOL := 1;                                                        00213800           
2113    IF INCHAR = LPAREN                                                   00213900           
2114     THEN BEGIN NEXTCH;                                                  00214000           
2115      WHILE (INCHAR <> RPAREN) AND NOT EOL DO                            00214100           
2116       BEGIN CH := UPPER(INCHAR);                                        00214200           
2117       NEXTCH;                                                           00214300           
2118       IF CLASS[CH].SORTINXCHAR                                          00214400           
2119        THEN CASE CH OF                                                  00214500           
2120         L : LEFTWIDTH := NUMBER(2,-1,0,30,658);                         00214600           
2121         M : MARGIN := NUMBER(0,-1,0,30,659);                            00214700           
2122         P : PAGECOL := NUMBER(0,-1,0,MAXINXLENGTH+MIN,660);             00214800           
2123         R : RIGHTWIDTH := NUMBER(2,-1,0,30,661);                        00214900           
2124         S : IF (INCHAR = P) OR (INCHAR = SMALLP)                        00215000           
2125              THEN BEGIN SORTCOL := -1; NEXTCH END                       00215100           
2126              ELSE SORTCOL := NUMBER(1,-1,1,MAXINXLENGTH-MIN,662);       00215200           
2127         BLANK :                                                         00215300           
2128         END                                                             00215400           
2129        ELSE BEGIN ERROR1 := CH; ERROR(601) END                          00215500           
2130       END;                                                              00215600           
2131      IF INCHAR = RPAREN                                                 00215700           
2132       THEN NEXTCH                                                       00215800           
2133       ELSE ERROR(602)                                                   00215900           
2134      END                                                                00216000           
2135    END (* PARSE *);                                                     00216100           
2136                                                                         00216200           
2137                                                                         00216300           
2138                                                                         00216400           
2139                                                                         00216500           
2140   (*      SORT - SORT THE INDEX ENTRIES.                                00216600           
2141    *)                                                                   00216700           
2142                                                                         00216800           
2143    PROCEDURE SORT;                                                      00216900           
2144    VAR                                                                  00217000           
2145     P            : PINXENTRY;(* FOR TRAVERSING THE INDEX LIST *)        00217100           
2146     S1,S2        : PINXENTRY;(* TEMPS FOR SORTING *)                    00217200           
2147     X1           : INTEGER;  (* GENERAL INDEX VARIABLE *)               00217300           
2148    BEGIN (* SORT *)                                                     00217400           
2149    NEW(FIRSTINX);                                                       00217500           
2150    NEW(LASTINX);                                                        00217600           
2151    WITH FIRSTINX^ DO                                                    00217700           
2152     BEGIN XL := 0;                                                      00217800           
2153     NEXT := LASTINX;                                                    00217900           
2154     FOR X1 := 1 TO MAXINXLENGTH DO X[X1] := NUL                         00218000           
2155     END;                                                                00218100           
2156    WITH LASTINX^ DO                                                     00218200           
2157     BEGIN XL := 0;                                                      00218300           
2158     NEXT := NIL;                                                        00218400           
2159     FOR X1 := 1 TO MAXINXLENGTH DO X[X1] := DEL                         00218500           
2160     END;                                                                00218600           
2161    IF SORTCOL < 0                                                       00218700           
2162     THEN BEGIN INXLAST^.NEXT := LASTINX;                                00218800           
2163      FIRSTINX^.NEXT := INXBASE;                                         00218900           
2164      INXBASE := NIL                                                     00219000           
2165      END                                                                00219100           
2166     ELSE BEGIN P := INXBASE;                                            00219200           
2167      INXLAST^.NEXT := NIL;                                              00219300           
2168      WHILE P <> NIL DO                                                  00219400           
2169       BEGIN INXBASE := P^.NEXT;                                         00219500           
2170       S2 := FIRSTINX;                                                   00219600           
2171       REPEAT S1 := S2;                                                  00219700           
2172        S2 := S1^.NEXT;                                                  00219800           
2173        X1 := SORTCOL;                                                   00219900           
2174        WHILE (X1 < MAXINXLENGTH) AND                                    00220000           
2175              (UPPER(P^.X[X1]) = UPPER(S2^.X[X1])) DO                    00220100           
2176         X1 := X1 + 1                                                    00220200           
2177       UNTIL UPPER(P^.X[X1]) < UPPER(S2^.X[X1]);                         00220300           
2178       S1^.NEXT := P;                                                    00220400           
2179       P^.NEXT := S2;                                                    00220500           
2180       P := INXBASE                                                      00220600           
2181       END                                                               00220700           
2182      END                                                                00220800           
2183    END (* SORT *);                                                      00220900           
2184                                                                         00221000           
2185                                                                         00221100           
2186                                                                         00221200           
2187                                                                         00221300           
2188   (*      PRINT - PRINT THE INDEX ENTRIES.                              00221400           
2189    *)                                                                   00221500           
2190                                                                         00221600           
2191    PROCEDURE PRINT;                                                     00221700           
2192    VAR                                                                  00221800           
2193     P            : PINXENTRY;(* FOR TRAVERSING THE INDEX LIST *)        00221900           
2194     X1           : INTEGER;  (* GENERAL INDEX VARIABLE *)               00222000           
2195                                                                         00222100           
2196                                                                         00222200           
2197                                                                         00222300           
2198                                                                         00222400           
2199    (*     SEND1 - SEND ONE CHARACTER TO THE OUTPUT LINE.                00222500           
2200     *                                                                   00222600           
2201     *     PARAM  CH - CHARACTER TO SEND.                                00222700           
2202     *)                                                                  00222800           
2203                                                                         00222900           
2204     PROCEDURE SEND1( CH : ASCIIX );                                     00223000           
2205     BEGIN (* SEND1 *)                                                   00223100           
2206     OUTLENGTH := OUTLENGTH + 1;                                         00223200           
2207     WITH OUTLINE[OUTLENGTH] DO                                          00223300           
2208      BEGIN C := CH;                                                     00223400           
2209      NBL := CHARWIDTH                                                   00223500           
2210      END                                                                00223600           
2211     END (* SEND1 *);                                                    00223700           
2212                                                                         00223800           
2213                                                                         00223900           
2214                                                                         00224000           
2215                                                                         00224100           
2216    BEGIN (* PRINT *)                                                    00224200           
2217    P := FIRSTINX^.NEXT;                                                 00224300           
2218    WHILE P <> LASTINX DO                                                00224400           
2219     WITH P^ DO                                                          00224500           
2220      BEGIN FOR X1 := 1 TO MARGIN DO SEND1(BLANK);                       00224600           
2221      FOR X1 := 1 TO PAGECOL DO                                          00224700           
2222       IF X1 > XL                                                        00224800           
2223        THEN SEND1(BLANK)                                                00224900           
2224        ELSE SEND1(X[X1]);                                               00225000           
2225      CONVERTNUMBER(OUTLINE,OUTLENGTH,XP,LEFTWIDTH,NUMERIC);             00225100           
2226      FOR X1 := 1 TO RIGHTWIDTH DO SEND1(BLANK);                         00225200           
2227      FOR X1 := PAGECOL+1 TO XL DO SEND1(X[X1]);                         00225300           
2228      WRITELINE;                                                         00225400           
2229      DISPOSE(FIRSTINX);                                                 00225500           
2230      FIRSTINX := P;                                                     00225600           
2231      P := FIRSTINX^.NEXT                                                00225700           
2232      END;                                                               00225800           
2233    DISPOSE(LASTINX)                                                     00225900           
2234    END (* PRINT *);                                                     00226000           
2235                                                                         00226100           
2236                                                                         00226200           
2237                                                                         00226300           
2238                                                                         00226400           
2239   BEGIN (* SORTINX *)                                                   00226500           
2240   PARSE;                                                                00226600           
2241   SORT;                                                                 00226700           
2242   PRINT                                                                 00226800           
2243   END (* SORTINX *);                                                    00226900           
2244                                                                         00227000           
2245                                                                         00227100           
2246                                                                         00227200           
2247                                                                         00227300           
2248  BEGIN (* DIRECTIVE *)                                                  00227400           
2249  REPEAT NEXTCH;                                                         00227500           
2250   READWORD;                                                             00227600           
2251   DIR := LOOKUP(BRE,ILL);                                               00227700           
2252   WHILE (INCHAR = BLANK) AND NOT EOL DO NEXTCH;                         00227800           
2253   IF DIR IN [BRE,FRM,IND,MAR,OPT,PAG,RES,SKI,SOR,UND,WEO] THEN BREAK;   00227900           
2254   CASE DIR OF                                                           00228000           
2255    BRE : ;                                                              00228100           
2256    COM : WHILE NOT EOL DO NEXTCH;                                       00228200           
2257    COU : PAGENUMBER := NUMBER(1,PAGENUMBER,0,MAXPAGE,759);              00228300           
2258    FRM : READFORM;                                                      00228400           
2259    IND : INUNDENT(NUMBER(5,-1,0,RIGHTMARGIN,856));                      00228500           
2260    INP : INPUTD;                                                        00228600           
2261    INX : READINX;                                                       00228700           
2262    LIT : LITERAL;                                                       00228800           
2263    MAR : MARGIN;                                                        00228900           
2264    OPT : OPTION;                                                        00229000           
2265    OUT : OUTPUTD;                                                       00229100           
2266    PAG : PAGE(NUMBER(INFINITY,-1,0,INFINITY,0));                        00229200           
2267    PAR : PARAGRAPH;                                                     00229300           
2268    RES : RESET;                                                         00229400           
2269    SEL : SELECT;                                                        00229500           
2270    SKI : SKIP(NUMBER(5,-1,0,MAXSKIP,957));                              00229600           
2271    SOR : SORTINX;                                                       00229700           
2272    SBT : BEGIN TITLELENGTH[SUBTITLE] := 0;                              00229800           
2273          READPSTRING(TITLE[SUBTITLE],TITLELENGTH[SUBTITLE],NUL)         00229900           
2274          END;                                                           00230000           
2275    TTL : BEGIN TITLELENGTH[MAINTITLE] := 0;                             00230100           
2276          READPSTRING(TITLE[MAINTITLE],TITLELENGTH[MAINTITLE],NUL)       00230200           
2277          END;                                                           00230300           
2278    UND : INUNDENT(-NUMBER(INFINITY,-1,0,INFINITY,0));                   00230400           
2279    WEO : WRITELN(OUTPUT);                                           (**)00230500           
2280    EXC,                                                                 00230600           
2281    ILL : BEGIN ERROR10 := FULLWORD; ERROR(006) END                      00230700           
2282    END;                                                                 00230800           
2283   WHILE (INCHAR <> DIRCH) AND NOT EOL DO                                00230900           
2284    BEGIN IF INCHAR <> BLANK                                             00231000           
2285     THEN BEGIN ERROR1 := INCHAR; ERROR(1) END;                          00231100           
2286    NEXTCH                                                               00231200           
2287    END                                                                  00231300           
2288  UNTIL EOL                                                              00231400           
2289  END (* DIRECTIVE *);                                                   00231500           
2290                                                                         00231600           
2291                                                                         00231700           
2292                                                                         00231800           
2293                                                                         00231900           
2294                                                                         00232000           
2295                                                                         00232100           
2296                                                                         00232200           
2297                                                                         00232300           
2298 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00232400           
2299 (*                                                                   *) 00232500           
2300 (*                          TEXT FORMATTING                          *) 00232600           
2301 (*                          ---- ----------                          *) 00232700           
2302 (*                                                                   *) 00232800           
2303 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00232900           
2304                                                                         00233000           
2305                                                                         00233100           
2306                                                                         00233200           
2307                                                                         00233300           
2308                                                                         00233400           
2309 (*        NEXTWORD - READ THE NEXT INPUT WORD, PROCESS DIRECTIVES       00233500           
2310  *                   WHEN APPROPRIATE.                                  00233600           
2311  *)                                                                     00233700           
2312                                                                         00233800           
2313  PROCEDURE NEXTWORD;                                                    00233900           
2314  VAR                                                                    00234000           
2315   X1             : INTEGER;  (* LOOP INDEX *)                           00234100           
2316  BEGIN (* NEXTWORD *)                                                   00234200           
2317  WORDLENGTH := 0;                                                       00234300           
2318  NEWINLINE := FALSE;                                                    00234400           
2319  WHILE EOL AND NOT ENDOFINPUT DO                                        00234500           
2320   BEGIN NEXTCHAR;                                                       00234600           
2321   IF EOL AND NOT ENDOFINPUT                                             00234700           
2322    THEN BEGIN BREAK; WRITENULL END                                      00234800           
2323    ELSE IF INCHAR = DIRCH                                               00234900           
2324     THEN DIRECTIVE                                                      00235000           
2325     ELSE IF INCHAR = PARACHAR                                           00235100           
2326      THEN BEGIN BREAK;                                                  00235200           
2327       IF PARASKIP > 0 THEN SKIP(PARASKIP);                              00235300           
2328       IF PARAPAGE > 0 THEN PAGE(PARAPAGE);                              00235400           
2329       INUNDENT(LOCKEDDENT);                                             00235500           
2330       IF NUMBERING <> NONUMBERING                                       00235600           
2331        THEN BEGIN PARACOUNT := PARACOUNT + 1;                           00235700           
2332         CONVERTNUMBER(WORD,WORDLENGTH,PARACOUNT,NUMBERWIDTH,NUMBERING)  00235800           
2333         END;                                                            00235900           
2334       NEXTCHAR                                                          00236000           
2335       END                                                               00236100           
2336   END;                                                                  00236200           
2337  IF NOT ENDOFINPUT                                                      00236300           
2338   THEN BEGIN NBLANKS := 0;                                              00236400           
2339    IF WORDLENGTH = 0                                                    00236500           
2340     THEN WHILE INCHAR = BLANK DO                                        00236600           
2341      BEGIN NBLANKS := NBLANKS + 1;                                      00236700           
2342      NEXTCHAR                                                           00236800           
2343      END;                                                               00236900           
2344    IF NEWINLINE                                                         00237000           
2345     THEN BEGIN IF (NBLANKS > 0) OR NOT FILL THEN BREAK;                 00237100           
2346      IF UNDERCHAR <> NUL                                                00237200           
2347       THEN BEGIN UNDERSTRING(INLINE,INLENGTH,UNDERLINING);              00237300           
2348        INCOLUMN := INCOLUMN - 1;                                        00237400           
2349        NEXTCHAR                                                         00237500           
2350        END                                                              00237600           
2351      END                                                                00237700           
2352     ELSE IF NOT MULTIPLEBLANKS AND (NBLANKS > 1) THEN NBLANKS := 1;     00237800           
2353    NSPLITS := 0;                                                        00237900           
2354    WHILE INCHAR <> BLANK DO                                             00238000           
2355     BEGIN IF INCHAR MOD 128 = HYPHEN                                    00238100           
2356      THEN BEGIN IF NSPLITS < MAXSPLIT                                   00238200           
2357        THEN BEGIN NSPLITS := NSPLITS + 1;                               00238300           
2358         WITH SPLITS[NSPLITS] DO                                         00238400           
2359          BEGIN POINT := WORDLENGTH;                                     00238500           
2360          IF INCOLUMN > 1                                                00238600           
2361           THEN HYPNT := CLASS[INLINE[INCOLUMN-1].C MOD 128].LETTER AND  00238700           
2362                         CLASS[INLINE[INCOLUMN+1].C MOD 128].LETTER      00238800           
2363           ELSE HYPNT := FALSE;                                          00238900           
2364          INPNT := INCOLUMN                                              00239000           
2365          END                                                            00239100           
2366         END                                                             00239200           
2367       END                                                               00239300           
2368      ELSE BEGIN WORDLENGTH := WORDLENGTH + 1;                           00239400           
2369       WITH WORD[WORDLENGTH] DO                                          00239500           
2370        BEGIN C := INCHAR; NBL := CHARWIDTH END                          00239600           
2371       END;                                                              00239700           
2372     NEXTCHAR                                                            00239800           
2373     END                                                                 00239900           
2374    END                                                                  00240000           
2375  END (* NEXTWORD *);                                                    00240100           
2376                                                                         00240200           
2377                                                                         00240300           
2378                                                                         00240400           
2379                                                                         00240500           
2380 (*        PACKWORD - PACK A WORD INTO THE OUTPUT LINE.                  00240600           
2381  *)                                                                     00240700           
2382                                                                         00240800           
2383  PROCEDURE PACKWORD;                                                    00240900           
2384  VAR                                                                    00241000           
2385   NB             : INTEGER;  (* NUMBER BLANKS (PRECEDING WORD) *)       00241100           
2386   NC             : INTEGER;  (* NCHARS PREDICTED AFTER ADDING WORD *)   00241200           
2387                                                                         00241300           
2388                                                                         00241400           
2389                                                                         00241500           
2390                                                                         00241600           
2391  (*       ADDWORD - ADD THE WORD TO THE OUTPUT LINE.                    00241700           
2392   *)                                                                    00241800           
2393                                                                         00241900           
2394   PROCEDURE ADDWORD;                                                    00242000           
2395   VAR                                                                   00242100           
2396    X1            : INTEGER;  (* GENERAL INDEX VARIABLE *)               00242200           
2397   BEGIN (* ADDWORD *)                                                   00242300           
2398   WITH OUTLINE[OUTLENGTH] DO NBL := NBL + NB * CHARWIDTH;               00242400           
2399   FOR X1 := 1 TO WORDLENGTH DO                                          00242500           
2400    BEGIN OUTLENGTH := OUTLENGTH + 1;                                    00242600           
2401    OUTLINE[OUTLENGTH] := WORD[X1]                                       00242700           
2402    END;                                                                 00242800           
2403   OUTLENGTH := OUTLENGTH + 1;                                           00242900           
2404   WITH OUTLINE[OUTLENGTH] DO                                            00243000           
2405    BEGIN C := BLANK; NBL := 0 END;                                      00243100           
2406   NCHARS := NC;                                                         00243200           
2407   IF NCHARS >= LEFTMARGIN                                               00243300           
2408    THEN BEGIN NGAPS := NGAPS + 1;                                       00243400           
2409     GAPS[NGAPS] := OUTLENGTH                                            00243500           
2410     END                                                                 00243600           
2411    ELSE GAPS[0] := OUTLENGTH                                            00243700           
2412   END (* ADDWORD *);                                                    00243800           
2413                                                                         00243900           
2414                                                                         00244000           
2415                                                                         00244100           
2416                                                                         00244200           
2417  (*       SETUP - SET UP FOR PACKWORD.                                  00244300           
2418   *)                                                                    00244400           
2419                                                                         00244500           
2420   PROCEDURE SETUP;                                                      00244600           
2421   VAR                                                                   00244700           
2422    X1            : INTEGER;  (* LOOP INDEX *)                           00244800           
2423   BEGIN (* SETUP *)                                                     00244900           
2424   IF NEWPARAGRAPH                                                       00245000           
2425    THEN NB := NBLANKS                                                   00245100           
2426    ELSE IF NEWOUTLINE                                                   00245200           
2427     THEN NB := 0                                                        00245300           
2428     ELSE BEGIN IF NEWINLINE                                             00245400           
2429       THEN NB := NBLANKS + 1                                            00245500           
2430       ELSE NB := NBLANKS;                                               00245600           
2431      IF ENSURE2 AND                                                     00245700           
2432         (OUTLINE[OUTLENGTH-1].C MOD 128 = PERIOD) AND                   00245800           
2433         (NBLANKS < 2) AND (NCHARS >= LEFTMARGIN)                        00245900           
2434       THEN NB := 2                                                      00246000           
2435      END;                                                               00246100           
2436   NC := NCHARS + NB + WORDLENGTH;                                       00246200           
2437   IF NC > RIGHTMARGIN                                                   00246300           
2438    THEN IF RIGHTMARGIN - NCHARS > BADJUSTIFY * (NGAPS - 1)              00246400           
2439     THEN (* GOING TO INSERT TOO MANY BLANKS *)                          00246500           
2440      BEGIN IF NSPLITS > 0                                               00246600           
2441       THEN BEGIN X1 := NSPLITS;                                         00246700           
2442        WHILE X1 > 0 DO WITH SPLITS[X1] DO                               00246800           
2443         BEGIN NC := NCHARS + NB + POINT + ORD(HYPNT);                   00246900           
2444         IF NC <= RIGHTMARGIN                                            00247000           
2445          THEN BEGIN X1 := 0; (* EXIT LOOP *)                            00247100           
2446           INCOLUMN := INPNT;      (* RESET INPUT STREAM *)              00247200           
2447           EOL := FALSE;                                                 00247300           
2448           NEXTCHAR;                                                     00247400           
2449           WORDLENGTH := POINT + ORD(HYPNT);                             00247500           
2450           IF HYPNT THEN WORD[WORDLENGTH].C := MINUS                     00247600           
2451           END                                                           00247700           
2452          ELSE X1 := X1 - 1                                              00247800           
2453         END                                                             00247900           
2454        END;                                                             00248000           
2455      IF NC > RIGHTMARGIN THEN ERROR(008)                                00248100           
2456      END;                                                               00248200           
2457   NEWOUTLINE := FALSE;                                                  00248300           
2458   NEWPARAGRAPH := FALSE                                                 00248400           
2459   END (* SETUP *);                                                      00248500           
2460                                                                         00248600           
2461                                                                         00248700           
2462                                                                         00248800           
2463                                                                         00248900           
2464  BEGIN (* PACKWORD *)                                                   00249000           
2465  SETUP;                                                                 00249100           
2466  IF NC <= RIGHTMARGIN THEN ADDWORD;                                     00249200           
2467  IF NC >= RIGHTMARGIN                                                   00249300           
2468   THEN (* DON-T CALL PACKWORD, TO PREVENT UNENDING RECURSION IN   *)    00249400           
2469        (* THE CASE OF A WORD THAT DOESN-T FIT BETWEEN THE MARGINS *)    00249500           
2470    BEGIN JUSTIFY;                                                       00249600           
2471    WRITELINE;                                                           00249700           
2472    IF NC > RIGHTMARGIN                                                  00249800           
2473     THEN BEGIN SETUP;                                                   00249900           
2474      ADDWORD;                                                           00250000           
2475      IF NC >= RIGHTMARGIN THEN BEGIN JUSTIFY; WRITELINE END             00250100           
2476      END                                                                00250200           
2477    END                                                                  00250300           
2478  END (* PACKWORD *);                                                    00250400           
2479                                                                         00250500           
2480                                                                         00250600           
2481                                                                         00250700           
2482                                                                         00250800           
2483                                                                         00250900           
2484                                                                         00251000           
2485                                                                         00251100           
2486                                                                         00251200           
2487 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00251300           
2488 (*                                                                   *) 00251400           
2489 (*                         ERROR PROCESSING                          *) 00251500           
2490 (*                         ----- ----------                          *) 00251600           
2491 (*                                                                   *) 00251700           
2492 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00251800           
2493                                                                         00251900           
2494                                                                         00252000           
2495                                                                         00252100           
2496                                                                         00252200           
2497 (*        ERROR - ISSUE AN ERROR MESSAGE.                               00252300           
2498  *                                                                      00252400           
2499  *        PARAM  N = ERROR NUMBER.                                      00252500           
2500  *               N IS NEGATIVE FOR ERRORS DETECTED DURING FORM          00252600           
2501  *               PROCESSING TO PREVENT UNENDING RECURSION.              00252700           
2502  *               FOR POSITIVE N, THE FOLLOWING CONVENTION IS USED:      00252800           
2503  *               N DIV 100 INDICATES WHICH DIRECTIVE THE                00252900           
2504  *               REFERS TO.                                             00253000           
2505  *               N MOD 100 SELECTS A PARTICULAR ERROR MESSAGE.          00253100           
2506  *               N MOD 100 IS >= 50 FOR NUMERIC ERRORS.                 00253200           
2507  *               GLOBAL VARIABLES ERROR10, ERROR1, ERRORN1, ERRORN2,    00253300           
2508  *               AND ERRORSMALL ARE USED FOR PRINTING SPECIFIC          00253400           
2509  *               VALUES WHICH ARE IN ERROR.                             00253500           
2510  *)                                                                     00253600           
2511                                                                         00253700           
2512  PROCEDURE ERROR(* N : INTEGER *);                                      00253800           
2513  TYPE                                                                   00253900           
2514   HOST5          = PACKED ARRAY[1..5] OF CHAR;                          00254000           
2515   HOST10         = PACKED ARRAY[1..10] OF CHAR;                         00254100           
2516   HOST20         = PACKED ARRAY[1..20] OF CHAR;                         00254200           
2517  VAR                                                                    00254300           
2518  LEN             : INTEGER;  (* LENGTH OF STR *)                        00254400           
2519   STR            : STRING;   (* FOR PRINTING INLINE *)                  00254500           
2520   X1,X2          : INTEGER;  (* GENERAL LOOP INDEX *)                   00254600           
2521                                                                         00254700           
2522                                                                         00254800           
2523                                                                         00254900           
2524                                                                         00255000           
2525  (*       WR5,WR10,WR20 - WRITE HOST CHARACTERS TO STR.                 00255100           
2526   *)                                                                    00255200           
2527                                                                         00255300           
2528   PROCEDURE WR5( CS : HOST5; NC : INTEGER);                             00255400           
2529   BEGIN (* WR5 *)                                                       00255500           
2530   FOR NC := 1 TO NC DO                                                  00255600           
2531    BEGIN LEN := LEN + 1;                                                00255700           
2532    WITH STR[LEN] DO BEGIN C := ASCIICHAR(CS[NC]); NBL := CHARWIDTH END  00255800           
2533    END                                                                  00255900           
2534   END (* WR5 *);                                                        00256000           
2535                                                                         00256100           
2536                                                                         00256200           
2537   PROCEDURE WR10( CS : HOST10; NC : INTEGER);                           00256300           
2538   BEGIN (* WR10 *)                                                      00256400           
2539   FOR NC := 1 TO NC DO                                                  00256500           
2540    BEGIN LEN := LEN + 1;                                                00256600           
2541    WITH STR[LEN] DO BEGIN C := ASCIICHAR(CS[NC]); NBL := CHARWIDTH END  00256700           
2542    END                                                                  00256800           
2543   END (* WR10 *);                                                       00256900           
2544                                                                         00257000           
2545                                                                         00257100           
2546   PROCEDURE WR20( CS : HOST20; NC : INTEGER);                           00257200           
2547   BEGIN (* WR20 *)                                                      00257300           
2548   FOR NC := 1 TO NC DO                                                  00257400           
2549    BEGIN LEN := LEN + 1;                                                00257500           
2550    WITH STR[LEN] DO BEGIN C := ASCIICHAR(CS[NC]); NBL := CHARWIDTH END  00257600           
2551    END                                                                  00257700           
2552   END (* WR20 *);                                                       00257800           
2553                                                                         00257900           
2554                                                                         00258000           
2555                                                                         00258100           
2556                                                                         00258200           
2557  BEGIN (* ERROR *)                                                      00258300           
2558  IF PRINTERRORS                                                         00258400           
2559   THEN BEGIN ERRORS := TRUE;                                            00258500           
2560    STR[1].C := BLANK; STR[1].NBL := 0;                                  00258600           
2561    LEN := 1;                                                            00258700           
2562    WR5('---- ',5);                                                      00258800           
2563    IF N < 0                                                             00258900           
2564     THEN BEGIN WR20('FORM ERROR:         ',12);                         00259000           
2565      CASE N OF                                                          00259100           
2566       -1 : WR20('LINE TOO LONG       ',13);                             00259200           
2567       -2 : BEGIN LEN := LEN + 1;                                        00259300           
2568            WITH STR[LEN] DO BEGIN C := ERROR1; NBL := CHARWIDTH END     00259400           
2569            END;                                                         00259500           
2570       -3 : WR20('PAGENUMBER TOO LARGE',20);                             00259600           
2571       -4 : WR20('BAD NUMERIC FORM    ',16);                             00259700           
2572       -5 : WR20('NO "L" FOUND        ',12);                             00259800           
2573       END;                                                              00259900           
2574      WRITESTRING(STR,LEN);                                              00260000           
2575      ENDLINE                                                            00260100           
2576      END                                                                00260200           
2577     ELSE BEGIN IF FIRSTERROR (* FIRST ERROR ON THIS LINE *)             00260300           
2578       THEN BEGIN CONVERTNUMBER(STR,LEN,LINENUMBER,4,NUMERIC);           00260400           
2579        WR5('.    ',2);                                                  00260500           
2580        FOR X1 := 1 TO INLENGTH DO STR[LEN+X1] := INLINE[X1];            00260600           
2581        LEN := LEN + INLENGTH;                                           00260700           
2582        WRITESTRING(STR,LEN);                                            00260800           
2583        ENDLINE;                                                         00260900           
2584        FIRSTERROR := FALSE;                                             00261000           
2585        STR[1].NBL := 0;                                                 00261100           
2586        LEN := 6                                                         00261200           
2587        END;                                                             00261300           
2588      CASE N DIV 100 OF                                                  00261400           
2589        0 : ;                                                            00261500           
2590        1 : WR10('MARGIN    ',6);                                        00261600           
2591        2 : WR10('OPTION    ',6);                                        00261700           
2592        3 : WR10('PARAGRAPH ',9);                                        00261800           
2593        4 : WR5('FORM ',4);                                              00261900           
2594        5 : WR10('SELECT    ',6);                                        00262000           
2595        6 : WR10('SORTINDEX ',9);                                        00262100           
2596        7 : WR5('COUNT',5);                                              00262200           
2597        8 : WR10('INDENT    ',6);                                        00262300           
2598        9 : WR5('SKIP ',4);                                              00262400           
2599       10 : WR10('OUTPUT    ',6);                                        00262500           
2600       11 : WR5('INPUT',5);                                              00262600           
2601       12 : WR5('RESET',5);                                              00262700           
2602       END;                                                              00262800           
2603      WR10(' ERROR:   ',8);                                              00262900           
2604      N := N MOD 100;                                                    00263000           
2605      IF N < 50                                                          00263100           
2606       THEN CASE N OF                                                    00263200           
2607         1 : BEGIN LEN := LEN + 1;                                       00263300           
2608             WITH STR[LEN] DO BEGIN C := ERROR1; NBL := CHARWIDTH END    00263400           
2609             END;                                                        00263500           
2610         2 : WR10('MISSING ) ',9);                                       00263600           
2611         3 : WR20('UNMATCHED QUOTE     ',15);                            00263700           
2612         4 : WR20('PAGENUMBER TOO LARGE',20);                            00263800           
2613         5 : BEGIN WR20('UNDEFINED KEEP BUFFE',20);                      00263900           
2614             WR5('R    ',1)                                              00264000           
2615             END;                                                        00264100           
2616         6 : BEGIN WR20('UNKNOWN DIRECTIVE:  ',19);                      00264200           
2617             FOR X1 := 1 TO 10 DO                                        00264300           
2618              BEGIN LEN := LEN + 1;                                      00264400           
2619              WITH STR[LEN] DO                                           00264500           
2620               BEGIN C := ERROR10[X1]; NBL := CHARWIDTH END              00264600           
2621              END                                                        00264700           
2622             END;                                                        00264800           
2623         7 : WR20('BAD NUMERIC FORM    ',16);                            00264900           
2624         8 : BEGIN WR20('HYPHENATION NEEDED: ',20);                      00265000           
2625             FOR X1 := 1 TO WORDLENGTH DO                                00265100           
2626              IF LEN < MAXSTRINGLENGTH THEN                              00265200           
2627               BEGIN LEN := LEN + 1; STR[LEN] := WORD[X1] END            00265300           
2628             END;                                                        00265400           
2629         9 : WR20('BAD TERMINAL TYPE   ',17);                            00265500           
2630        10 : BEGIN WR20('MUST BE IN INITIAL D',20);                      00265600           
2631             WR20('IRECTIVE GROUP      ',14)                             00265700           
2632             END;                                                        00265800           
2633        11 : BEGIN WR20('"EXCEPT" MUST BE FIR',20);                      00265900           
2634             WR5('ST   ',2)                                              00266000           
2635             END;                                                        00266100           
2636        12 : BEGIN WR20('DIRECTIVE NOT ALLOWE',20);                      00266200           
2637             WR5('D:   ',3);                                             00266300           
2638             FOR X1 := 1 TO 10 DO                                        00266400           
2639              BEGIN LEN := LEN + 1;                                      00266500           
2640              WITH STR[LEN] DO                                           00266600           
2641               BEGIN C := ERROR10[X1]; NBL := CHARWIDTH END              00266700           
2642              END                                                        00266800           
2643             END;                                                        00266900           
2644        END                                                              00267000           
2645       ELSE BEGIN CASE N OF                                              00267100           
2646         51 : WR5('KEEP ',4);                                            00267200           
2647         52 : WR20('RIGHT MARGIN        ',12);                           00267300           
2648         53 : WR20('LEFT MARGIN         ',11);                           00267400           
2649         54 : WR5('WIDTH',5);                                            00267500           
2650         55 : WR10('INDENT    ',6);                                      00267600           
2651         56 : WR20('NUMBER WIDTH        ',12);                           00267700           
2652         57 : WR5('SKIP ',4);                                            00267800           
2653         58 : WR10('LEFT WIDTH',10);                                     00267900           
2654         59 : WR10('MARGIN    ',6);                                      00268000           
2655         60 : WR20('PAGE COLUMN         ',11);                           00268100           
2656         61 : WR20('RIGHT WIDTH         ',11);                           00268200           
2657         62 : WR20('SORT COLUMN         ',11);                           00268300           
2658         63 : WR10('AJ PITCH  ',8);                                      00268400           
2659         64 : WR5('SHIFT',5);                                            00268500           
2660         65 : WR20('JUSTIFICATION LIMIT ',19);                           00268600           
2661         66 : WR10('SPACING   ',7);                                      00268700           
2662         END;                                                            00268800           
2663        WR5(' OF  ',4);                                                  00268900           
2664        IF ERRORN1 < 0                                                   00269000           
2665         THEN BEGIN WR5('-    ',1); ERRORN1 := -ERRORN1 END;             00269100           
2666        CONVERTNUMBER(STR,LEN,ERRORN1,0,NUMERIC);                        00269200           
2667        WR10(' IS TOO   ',8);                                            00269300           
2668        IF ERRORSMALL THEN WR5('SMALL',5) ELSE WR5('LARGE',5);           00269400           
2669        WR5(',    ',2);                                                  00269500           
2670        CONVERTNUMBER(STR,LEN,ERRORN2,0,NUMERIC);                        00269600           
2671        WR5(' USED',5)                                                   00269700           
2672        END;                                                             00269800           
2673      WRITESTRING(STR,LEN);                                              00269900           
2674      ENDLINE                                                            00270000           
2675      END                                                                00270100           
2676    END                                                                  00270200           
2677  END (* ERROR *);                                                       00270300           
2678                                                                         00270400           
2679                                                                         00270500           
2680                                                                         00270600           
2681                                                                         00270700           
2682 (*       VALIDATE NUMERIC OPTION.                                       00270800           
2683  *                                                                      00270900           
2684  *       PARAM  NUM = NUMBER TO TEST.                                   00271000           
2685  *              MIN = MINIMUM ALLOWED VALUE.                            00271100           
2686  *              MAX = MAXIMUM ALLOWED VALUE.                            00271200           
2687  *              ERR = ERROR NUMBER IF NOT IN RANGE.                     00271300           
2688  *)                                                                     00271400           
2689                                                                         00271500           
2690  PROCEDURE VALIDATE(* VAR NUM : INTEGER; MIN,MAX,ERR : INTEGER *);      00271600           
2691  BEGIN (* VALIDATE *)                                                   00271700           
2692  ERRORN1 := NUM;                                                        00271800           
2693  ERRORSMALL := NUM < MIN;                                               00271900           
2694  IF ERRORSMALL                                                          00272000           
2695   THEN BEGIN NUM := MIN; ERRORN2 := NUM; ERROR(ERR) END                 00272100           
2696   ELSE IF NUM > MAX                                                     00272200           
2697    THEN BEGIN NUM := MAX; ERRORN2 := NUM; ERROR(ERR) END                00272300           
2698  END (* VALIDATE *);                                                    00272400           
2699                                                                         00272500           
2700                                                                         00272600           
2701                                                                         00272700           
2702                                                                         00272800           
2703                                                                         00272900           
2704                                                                         00273000           
2705                                                                         00273100           
2706                                                                         00273200           
2707 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00273300           
2708 (*                                                                   *) 00273400           
2709 (*                     SECONDARY INITIALIZATION                      *) 00273500           
2710 (*                     ------------------------                      *) 00273600           
2711 (*                                                                   *) 00273700           
2712 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00273800           
2713                                                                         00273900           
2714                                                                         00274000           
2715                                                                         00274100           
2716                                                                         00274200           
2717 (*        REINITIALIZE - RE-INITIALIZE GLOBAL VARIABLES.                00274300           
2718  *)                                                                     00274400           
2719                                                                         00274500           
2720  PROCEDURE REINITIALIZE;                                                00274600           
2721  VAR                                                                    00274700           
2722   D              : DIRECT;   (* DIRECTIVE LOOP INDEX *)                 00274800           
2723   X1             : INTEGER;  (* LOOP INDEX *)                           00274900           
2724                                                                         00275000           
2725                                                                         00275100           
2726                                                                         00275200           
2727                                                                         00275300           
2728  (*       INITFORM - INITIALIZE DEFAULT FORM.                           00275400           
2729   *)                                                                    00275500           
2730                                                                         00275600           
2731   PROCEDURE INITFORM;                                                   00275700           
2732   VAR                                                                   00275800           
2733    DEFAULT       : PACKED ARRAY[1..40] OF CHAR;                         00275900           
2734                              (* DEFAULT FORM *)                         00276000           
2735    X1            : INTEGER;  (* LOOP INDEX *)                           00276100           
2736   BEGIN (* INITFORM *)                                                  00276200           
2737   DEFAULT := '[//T#62E///L56//#33"- "PN:1" -"///]     ';                00276300           
2738   FOR X1 := 1 TO 40 DO                                                  00276400           
2739    FORM[X1] := ASCIICHAR(DEFAULT[X1]);                                  00276500           
2740   FORMLENGTH := 40;                                                     00276600           
2741   FORMNLENGTH := 0;                                                     00276700           
2742   FORMINDEX := 1;                                                       00276800           
2743   TEXTLENGTH := 1;                                                      00276900           
2744   TEXTINDEX := 1;                                                       00277000           
2745   TEXT[1].C := BLANK;                                                   00277100           
2746   TEXT[1].NBL := 0;                                                     00277200           
2747   END (* INITFORM *);                                                   00277300           
2748                                                                         00277400           
2749                                                                         00277500           
2750                                                                         00277600           
2751                                                                         00277700           
2752  (*       INITINP - INITIALIZE INPUT SETTINGS.                          00277800           
2753   *)                                                                    00277900           
2754                                                                         00278000           
2755   PROCEDURE INITINP;                                                    00278100           
2756   VAR                                                                   00278200           
2757    X1            : INTEGER;  (* LOOP INDEX *)                           00278300           
2758   BEGIN (* INITINP *)                                                   00278400           
2759   LOWERCASE := TRUE;                                                    00278500           
2760   LOWERDIR := TRUE;                                                     00278600           
2761   UNDERDIR := FALSE;                                                    00278700           
2762   UNDERLINING := FALSE;                                                 00278800           
2763   KEEPINP := 0;                                                         00278900           
2764   EXPLICITBLANK := NUL;                                                 00279000           
2765   CASECH := NUL;                                                        00279100           
2766   DIRCH := PERIOD;                                                      00279200           
2767   HYPHEN := NUL;                                                        00279300           
2768   UNDERCHAR := NUL;                                                     00279400           
2769   INWIDTH := 150;                                                       00279500           
2770   FOR X1 := 0 TO MAXKEEP DO SAVEINP[X1].DEFINED := FALSE;               00279600           
2771   INPSAVE                                                               00279700           
2772   END (* INITINP *);                                                    00279800           
2773                                                                         00279900           
2774                                                                         00280000           
2775                                                                         00280100           
2776                                                                         00280200           
2777  (*       INITINX - INITIALIZE INX VARIABLES.                           00280300           
2778   *)                                                                    00280400           
2779                                                                         00280500           
2780   PROCEDURE INITINX;                                                    00280600           
2781   VAR                                                                   00280700           
2782    IP            : PINXENTRY;(* TO DISPOSE INDEX ENTRIES *)             00280800           
2783   BEGIN (* INITINX *)                                                   00280900           
2784   WHILE INXBASE <> NIL DO                                               00281000           
2785    BEGIN IP := INXBASE;                                                 00281100           
2786    INXBASE := INXBASE^.NEXT;                                            00281200           
2787    DISPOSE(IP)                                                          00281300           
2788    END;                                                                 00281400           
2789   INXLAST := NIL                                                        00281500           
2790   END (* INITINX *);                                                    00281600           
2791                                                                         00281700           
2792                                                                         00281800           
2793                                                                         00281900           
2794                                                                         00282000           
2795  (*       INITMAR - INITIALIZE MARGIN SETTINGS.                         00282100           
2796   *)                                                                    00282200           
2797                                                                         00282300           
2798   PROCEDURE INITMAR;                                                    00282400           
2799   VAR                                                                   00282500           
2800    X1            : INTEGER;  (* LOOP INDEX *)                           00282600           
2801   BEGIN (* INITMAR *)                                                   00282700           
2802   KEEPMAR := 0;                                                         00282800           
2803   LEFTMARGIN := 0;                                                      00282900           
2804   RIGHTMARGIN := 70;                                                    00283000           
2805   FOR X1 := 0 TO MAXKEEP DO SAVEMAR[X1].DEFINED := FALSE;               00283100           
2806   NCHARS := 0;                                                          00283200           
2807   OUTLINE[1].NBL := 0;                                                  00283300           
2808   MARSAVE                                                               00283400           
2809   END (* INITMAR *);                                                    00283500           
2810                                                                         00283600           
2811                                                                         00283700           
2812                                                                         00283800           
2813                                                                         00283900           
2814  (*       INITOPT - INITIALIZE OPTION SETTINGS.                         00284000           
2815   *)                                                                    00284100           
2816                                                                         00284200           
2817   PROCEDURE INITOPT;                                                    00284300           
2818   VAR                                                                   00284400           
2819    X1            : INTEGER;  (* LOOP INDEX *)                           00284500           
2820   BEGIN (* INITOPT *)                                                   00284600           
2821   KEEPOPT := 0;                                                         00284700           
2822   PRINTERRORS := TRUE;                                                  00284800           
2823   FILL := TRUE;                                                         00284900           
2824   BADJUSTIFY := 1;                                                      00285000           
2825   LEFTJUSTIFY := TRUE;                                                  00285100           
2826   MULTIPLEBLANKS := TRUE;                                               00285200           
2827   ENSURE2 := TRUE;                                                      00285300           
2828   RIGHTJUSTIFY := TRUE;                                                 00285400           
2829   SPACE := 0;                                                           00285500           
2830   SHIFTUP := FALSE;                                                     00285600           
2831   FOR X1 := 0 TO MAXKEEP DO SAVEOPT[X1].DEFINED := FALSE;               00285700           
2832   OPTSAVE                                                               00285800           
2833   END (* INITOPT *);                                                    00285900           
2834                                                                         00286000           
2835                                                                         00286100           
2836                                                                         00286200           
2837                                                                         00286300           
2838  (*       INITOUT - INITIALIZE OUTPUT SETTINGS.                         00286400           
2839   *)                                                                    00286500           
2840                                                                         00286600           
2841   PROCEDURE INITOUT;                                                    00286700           
2842   BEGIN (* INITOUT *)                                                   00286800           
2843   BLANKCOUNT := 0;                                                      00286900           
2844   BLANKLINE := FALSE;                                                   00287000           
2845   CARRIAGECONTROL := BLANK;                                             00287100           
2846   ACTUALCOLUMN := 0;                                                    00287200           
2847   NEXTCOLUMN := 0;                                                      00287300           
2848   LINECOUNT := -1;                                                      00287400           
2849   TERMINALTYPE := AST;                                                  00287500           
2850   CHARWIDTH := 1;                                                       00287600           
2851   EJECT := FALSE;                                                       00287700           
2852   PAUSE := FALSE;                                                       00287800           
2853   SHIFT := 0;                                                           00287900           
2854   UNDERAVAIL := TRUE;                                                   00288000           
2855   OUTWIDTH := MAXOWIDTH                                                 00288100           
2856   END (* INITOUT *);                                                    00288200           
2857                                                                         00288300           
2858                                                                         00288400           
2859                                                                         00288500           
2860                                                                         00288600           
2861  (*       INITPAR - INITIALIZE PARAGRAPH SETTINGS.                      00288700           
2862   *)                                                                    00288800           
2863                                                                         00288900           
2864   PROCEDURE INITPAR;                                                    00289000           
2865   VAR                                                                   00289100           
2866    X1            : INTEGER;  (* LOOP INDEX *)                           00289200           
2867   BEGIN (* INITPAR *)                                                   00289300           
2868   KEEPPAR := 0;                                                         00289400           
2869   PARACOUNT := 0;                                                       00289500           
2870   PARACHAR := NUL;                                                      00289600           
2871   LOCKEDDENT := 0;                                                      00289700           
2872   NUMBERING := NONUMBERING;                                             00289800           
2873   PARAPAGE := 0;                                                        00289900           
2874   PARASKIP := 0;                                                        00290000           
2875   NUMBERWIDTH := 3;                                                     00290100           
2876   FOR X1 := 0 TO MAXKEEP DO SAVEPAR[X1].DEFINED := FALSE;               00290200           
2877   PARSAVE                                                               00290300           
2878   END (* INITPAR *);                                                    00290400           
2879                                                                         00290500           
2880                                                                         00290600           
2881                                                                         00290700           
2882                                                                         00290800           
2883                                                                         00290900           
2884  BEGIN (* REINITIALIZE *)                                               00291000           
2885  FOR D := BRE TO ILL DO                                                 00291100           
2886   IF D IN WHICH                                                         00291200           
2887    THEN CASE D OF                                                       00291300           
2888     BRE : ;                                                             00291400           
2889     COM : ;                                                             00291500           
2890     COU : PAGENUMBER := 1;                                              00291600           
2891     FRM : INITFORM;                                                     00291700           
2892     IND : ;                                                             00291800           
2893     INP : INITINP;                                                      00291900           
2894     INX : INITINX;                                                      00292000           
2895     LIT : ;                                                             00292100           
2896     MAR : INITMAR;                                                      00292200           
2897     OPT : INITOPT;                                                      00292300           
2898     OUT : INITOUT;                                                      00292400           
2899     PAG : ;                                                             00292500           
2900     PAR : INITPAR;                                                      00292600           
2901     RES : ;                                                             00292700           
2902     SEL : FOR X1 := 0 TO MAXPAGE DO SELECTION[X1] := TRUE;              00292800           
2903     SKI : ;                                                             00292900           
2904     SOR : ;                                                             00293000           
2905     SBT : TITLELENGTH[SUBTITLE] := 0;                                   00293100           
2906     TTL : TITLELENGTH[MAINTITLE] := 0;                                  00293200           
2907     UND : ;                                                             00293300           
2908     WEO : ;                                                             00293400           
2909     EXC : ;                                                             00293500           
2910     ILL :                                                               00293600           
2911     END                                                                 00293700           
2912  END (* REINITIALIZE *);                                                00293800           
2913                                                                         00293900           
2914                                                                         00294000           
2915                                                                         00294100           
2916                                                                         00294200           
2917                                                                         00294300           
2918                                                                         00294400           
2919                                                                         00294500           
2920                                                                         00294600           
2921 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00294700           
2922 (*                                                                   *) 00294800           
2923 (*                      PRIMARY INITIALIZATION                       *) 00294900           
2924 (*                      ----------------------                       *) 00295000           
2925 (*                                                                   *) 00295100           
2926 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00295200           
2927                                                                         00295300           
2928                                                                         00295400           
2929                                                                         00295500           
2930                                                                         00295600           
2931 (*        INITIALIZE - INITIALIZE GLOBAL VARIABLES.                     00295700           
2932  *)                                                                     00295800           
2933                                                                         00295900           
2934  PROCEDURE INITIALIZE;                                                  00296000           
2935                                                                         00296100           
2936                                                                         00296200           
2937                                                                         00296300           
2938                                                                         00296400           
2939  (*       INITASC - INITIALIZE HOST TO ASCII CONVERSION TABLES.         00296500           
2940   *)                                                                    00296600           
2941                                                                         00296700           
2942   PROCEDURE INITASC;                                                (**)00296800           
2943   VAR                                                               (**)00296900           
2944    EXTCH         : CHAR;     (* EXTERNAL CHARACTER *)               (**)00297000           
2945    INTCH         : ASCII;    (* INTERNAL CHARACTER *)               (**)00297100           
2946   BEGIN (* INITASC *)                                               (**)00297200           
2947   FOR EXTCH := CHR(NUL) TO CHR(DEL) DO                                  00297300           
2948     ASC[EXTCH] :=ORD(EXTCH);                                            00297310           
2949   END (* INITASC *);                                                (**)00302400           
2950                                                                         00302500           
2951                                                                         00302600           
2952                                                                         00302700           
2953                                                                         00302800           
2954  (*       INITCLASS - INITIALIZE THE CLASSIFICATION TABLE.              00302900           
2955   *)                                                                    00303000           
2956                                                                         00303100           
2957   PROCEDURE INITCLASS;                                                  00303200           
2958   VAR                                                                   00303300           
2959    CH            : ASCII;    (* INDEX VARIABLE *)                       00303400           
2960    EMPTY         : CHARCLASS;(* ALL FIELDS ARE FALSE *)                 00303500           
2961   BEGIN (* INITCLASS *)                                                 00303600           
2962   WITH EMPTY DO                                                         00303700           
2963    BEGIN LETTER := FALSE;                                               00303800           
2964    DIGIT := FALSE;                                                      00303900           
2965    FORMCHAR := FALSE;                                                   00304000           
2966    OPTIONCHAR := FALSE;                                                 00304100           
2967    MARGINCHAR := FALSE;                                                 00304200           
2968    PARAGRAPHCHAR := FALSE;                                              00304300           
2969    SORTINXCHAR := FALSE;                                                00304400           
2970    PLUSORMINUS := FALSE;                                                00304500           
2971    QUOTE := FALSE;                                                      00304600           
2972    NUMFORM := FALSE;                                                    00304700           
2973    END;                                                                 00304800           
2974   FOR CH := NUL TO DEL DO CLASS[CH] := EMPTY;                           00304900           
2975   FOR CH := A TO Z DO CLASS[CH].LETTER := TRUE;                         00305000           
2976   FOR CH := SMALLA TO SMALLZ DO CLASS[CH].LETTER := TRUE;               00305100           
2977   FOR CH := ZERO TO NINE DO CLASS[CH].DIGIT := TRUE;                    00305200           
2978   CLASS[C].FORMCHAR := TRUE;                                            00305300           
2979   CLASS[D].FORMCHAR := TRUE;                                            00305400           
2980   CLASS[E].FORMCHAR := TRUE;                                            00305500           
2981   CLASS[L].FORMCHAR := TRUE;                                            00305600           
2982   CLASS[P].FORMCHAR := TRUE;                                            00305700           
2983   CLASS[S].FORMCHAR := TRUE;                                            00305800           
2984   CLASS[T].FORMCHAR := TRUE;                                            00305900           
2985   CLASS[W].FORMCHAR := TRUE;                                            00306000           
2986   CLASS[HASH].FORMCHAR := TRUE;                                         00306100           
2987   CLASS[LBRACKET].FORMCHAR := TRUE;                                     00306200           
2988   CLASS[RBRACKET].FORMCHAR := TRUE;                                     00306300           
2989   CLASS[SLASH].FORMCHAR := TRUE;                                        00306400           
2990   CLASS[DQUOTE].FORMCHAR := TRUE;                                       00306500           
2991   CLASS[SQUOTE].FORMCHAR := TRUE;                                       00306600           
2992   CLASS[BLANK].FORMCHAR := TRUE;                                        00306700           
2993   CLASS[B].INPUTCHAR := TRUE;                                           00306800           
2994   CLASS[C].INPUTCHAR := TRUE;                                           00306900           
2995   CLASS[D].INPUTCHAR := TRUE;                                           00307000           
2996   CLASS[H].INPUTCHAR := TRUE;                                           00307100           
2997   CLASS[K].INPUTCHAR := TRUE;                                           00307200           
2998   CLASS[U].INPUTCHAR := TRUE;                                           00307300           
2999   CLASS[W].INPUTCHAR := TRUE;                                           00307400           
3000   CLASS[BLANK].INPUTCHAR := TRUE;                                       00307500           
3001   CLASS[K].MARGINCHAR := TRUE;                                          00307600           
3002   CLASS[L].MARGINCHAR := TRUE;                                          00307700           
3003   CLASS[R].MARGINCHAR := TRUE;                                          00307800           
3004   CLASS[BLANK].MARGINCHAR := TRUE;                                      00307900           
3005   CLASS[E].OPTIONCHAR := TRUE;                                          00308000           
3006   CLASS[F].OPTIONCHAR := TRUE;                                          00308100           
3007   CLASS[J].OPTIONCHAR := TRUE;                                          00308200           
3008   CLASS[K].OPTIONCHAR := TRUE;                                          00308300           
3009   CLASS[L].OPTIONCHAR := TRUE;                                          00308400           
3010   CLASS[M].OPTIONCHAR := TRUE;                                          00308500           
3011   CLASS[P].OPTIONCHAR := TRUE;                                          00308600           
3012   CLASS[R].OPTIONCHAR := TRUE;                                          00308700           
3013   CLASS[S].OPTIONCHAR := TRUE;                                          00308800           
3014   CLASS[U].OPTIONCHAR := TRUE;                                          00308900           
3015   CLASS[BLANK].OPTIONCHAR := TRUE;                                      00309000           
3016   CLASS[E].OUTPUTCHAR := TRUE;                                          00309100           
3017   CLASS[P].OUTPUTCHAR := TRUE;                                          00309200           
3018   CLASS[S].OUTPUTCHAR := TRUE;                                          00309300           
3019   CLASS[U].OUTPUTCHAR := TRUE;                                          00309400           
3020   CLASS[W].OUTPUTCHAR := TRUE;                                          00309500           
3021   CLASS[BLANK].OUTPUTCHAR := TRUE;                                      00309600           
3022   CLASS[C].PARAGRAPHCHAR := TRUE;                                       00309700           
3023   CLASS[F].PARAGRAPHCHAR := TRUE;                                       00309800           
3024   CLASS[I].PARAGRAPHCHAR := TRUE;                                       00309900           
3025   CLASS[K].PARAGRAPHCHAR := TRUE;                                       00310000           
3026   CLASS[N].PARAGRAPHCHAR := TRUE;                                       00310100           
3027   CLASS[P].PARAGRAPHCHAR := TRUE;                                       00310200           
3028   CLASS[S].PARAGRAPHCHAR := TRUE;                                       00310300           
3029   CLASS[U].PARAGRAPHCHAR := TRUE;                                       00310400           
3030   CLASS[BLANK].PARAGRAPHCHAR := TRUE;                                   00310500           
3031   CLASS[L].SORTINXCHAR := TRUE;                                         00310600           
3032   CLASS[M].SORTINXCHAR := TRUE;                                         00310700           
3033   CLASS[P].SORTINXCHAR := TRUE;                                         00310800           
3034   CLASS[R].SORTINXCHAR := TRUE;                                         00310900           
3035   CLASS[S].SORTINXCHAR := TRUE;                                         00311000           
3036   CLASS[BLANK].SORTINXCHAR := TRUE;                                     00311100           
3037   CLASS[PLUS].PLUSORMINUS := TRUE;                                      00311200           
3038   CLASS[MINUS].PLUSORMINUS := TRUE;                                     00311300           
3039   CLASS[DQUOTE].QUOTE := TRUE;                                          00311400           
3040   CLASS[SQUOTE].QUOTE := TRUE;                                          00311500           
3041   CLASS[N].NUMFORM := TRUE;                                             00311600           
3042   CLASS[SMALLN].NUMFORM := TRUE;                                        00311700           
3043   CLASS[L].NUMFORM := TRUE;                                             00311800           
3044   CLASS[SMALLL].NUMFORM := TRUE;                                        00311900           
3045   CLASS[R].NUMFORM := TRUE;                                             00312000           
3046   CLASS[SMALLR].NUMFORM := TRUE;                                        00312100           
3047   CLASS[BLANK].NUMFORM := TRUE;                                         00312200           
3048   END (* INITCLASS *);                                                  00312300           
3049                                                                         00312400           
3050                                                                         00312500           
3051                                                                         00312600           
3052                                                                         00312700           
3053  (*       INITCLOCKS - INITIALIZE RAWCLOCK AND WALLCLOCK.               00312800           
3054   *)                                                                    00312900           
3055                                                                         00313000           
3056   PROCEDURE INITCLOCKS;                                             (**)00313100           
3057   VAR                                                               (**)00313200           
3058    C1            : ASCII;    (* TENS DIGIT OF WALLCLOCK *)          (**)00313300           
3059    C2            : ASCII;    (* ONES DIGIT OF WALLCLOCK *)          (**)00313400           
3060    C3            : ASCII;    (* A OR P FOR AM OR PM *)              (**)00313500           
3061    SYSTEMCLOCK   : ALFA;     (* SYSTEM CLOCK AS ' HH.MM.SS.' *)     (**)00313600           
3062    TIMEARR : ARRAY[0..5] OF INTEGER;                                    00313610           
3063    X1            : INTEGER;  (* GENERAL LOOP INDEX *)               (**)00313700           
3064   BEGIN (* INITCLOCKS *)                                            (**)00313800           
3065     TIMESTAMP(TIMEARR);                                                 00313900           
3066     SYSTEMCLOCK[1] := CHR(BLANK);                                       00313905           
3067     SYSTEMCLOCK[2] := CHR(TIMEARR[3] DIV 10 + 48);                      00313910           
3068     SYSTEMCLOCK[3] := CHR(TIMEARR[3] MOD 10 + 48);                      00313920           
3069     SYSTEMCLOCK[4]:= '.';                                               00313930           
3070     SYSTEMCLOCK[5] := CHR(TIMEARR[4] DIV 10 + 48);                      00313940           
3071     SYSTEMCLOCK[6] := CHR(TIMEARR[4] MOD 10 + 48);                      00313950           
3072     SYSTEMCLOCK[7] := '.';                                              00313960           
3073     SYSTEMCLOCK[8] := CHR(TIMEARR[5] DIV 10 + 48);                      00313970           
3074     SYSTEMCLOCK[9] := CHR(TIMEARR[5]MOD 10 + 48);                       00313980           
3075     SYSTEMCLOCK[10] := '.';                                             00313990           
3076   FOR X1 := 1 TO 8 DO RAWCLOCK[X1] := ASC[SYSTEMCLOCK[X1+1]];       (**)00315200           
3077   RAWCLOCK[9] := BLANK;                                             (**)00315300           
3078   RAWCLOCK[10] := BLANK;                                            (**)00315400           
3079   C1 := RAWCLOCK[1];                                                (**)00315500           
3080   C2 := RAWCLOCK[2];                                                (**)00315600           
3081   C3 := A;                                                          (**)00315700           
3082   CASE C1 OF                                                        (**)00315800           
3083    ZERO : IF C2 = ZERO                                              (**)00315900           
3084            THEN BEGIN C1 := ONE; C2 := TWO END                      (**)00316000           
3085            ELSE C1 := BLANK;                                        (**)00316100           
3086    ONE  : IF C2 = TWO                                               (**)00316200           
3087            THEN C3 := P                                             (**)00316300           
3088            ELSE IF C2 > TWO                                         (**)00316400           
3089             THEN BEGIN C1 := BLANK; C2 := C2 - 2; C3 := P END;      (**)00316500           
3090    TWO  : BEGIN IF C2 <= ONE                                        (**)00316600           
3091            THEN BEGIN C1 := BLANK; C2 := C2 - 2 END                 (**)00316700           
3092            ELSE BEGIN C1 := ONE; C2 := C2 + 2 END;                  (**)00316800           
3093           C3 := P                                                   (**)00316900           
3094           END                                                       (**)00317000           
3095    END;                                                             (**)00317100           
3096   WALLCLOCK[ 1] := C1;                                              (**)00317200           
3097   WALLCLOCK[ 2] := C2;                                              (**)00317300           
3098   WALLCLOCK[ 3] := COLON;                                           (**)00317400           
3099   WALLCLOCK[ 4] := RAWCLOCK[4];                                     (**)00317500           
3100   WALLCLOCK[ 5] := RAWCLOCK[5];                                     (**)00317600           
3101   WALLCLOCK[ 6] := BLANK;                                           (**)00317700           
3102   WALLCLOCK[ 7] := C3;                                              (**)00317800           
3103   WALLCLOCK[ 8] := M;                                               (**)00317900           
3104   WALLCLOCK[ 9] := BLANK;                                           (**)00318000           
3105   WALLCLOCK[10] := BLANK                                            (**)00318100           
3106   END (* INITCLOCKS *);                                             (**)00318200           
3107                                                                         00318300           
3108                                                                         00318400           
3109                                                                         00318500           
3110                                                                         00318600           
3111  (*       INITDATES - INITIALIZE RAWDATE AND NICEDATE.                  00318700           
3112   *)                                                                    00318800           
3113                                                                         00318900           
3114   PROCEDURE INITDATES;                                              (**)00319000           
3115   VAR                                                               (**)00319100           
3116    MONTH         : CH3;      (* CURRENT MONTH NAME *)               (**)00319200           
3117        TIMEARR : ARRAY[0..5] OF INTEGER;                                00319210           
3118    SYSTEMDATE    : ALFA;     (* SYSTEM DATE AS ' YY/MM/DD.' *)      (**)00319300           
3119    X1            : INTEGER;  (* GENERAL LOOP INDEX *)               (**)00319400           
3120   BEGIN (* INITDATES *)                                             (**)00319500           
3121     TIMESTAMP(TIMEARR);                                                 00319600           
3122     SYSTEMDATE[1] := CHR(BLANK);                                        00319605           
3123     SYSTEMDATE[2] := CHR(TIMEARR[0] DIV 10 MOD 10 + 48);                00319610           
3124     SYSTEMDATE[3] := CHR(TIMEARR[0] MOD 10 + 48);                       00319620           
3125     SYSTEMDATE[4] := '/';                                               00319630           
3126     SYSTEMDATE[5] := CHR(TIMEARR[1] DIV 10 + 48);                       00319640           
3127     SYSTEMDATE[6] := CHR(TIMEARR[1] MOD 10 + 48);                       00319650           
3128     SYSTEMDATE[7] := '/';                                               00319660           
3129     SYSTEMDATE[8] := CHR(TIMEARR[2] DIV 10 + 48);                       00319670           
3130     SYSTEMDATE[9] := CHR(TIMEARR[2] MOD 10 + 48);                       00319680           
3131     SYSTEMDATE[10] := '.';                                              00319690           
3132   FOR X1 := 1 TO 8 DO RAWDATE[X1] := ASC[SYSTEMDATE[X1+1]];         (**)00320900           
3133   RAWDATE[9] := BLANK;                                              (**)00321000           
3134   RAWDATE[10] := BLANK;                                             (**)00321100           
3135   MONTH := MONTHS[(RAWDATE[4] - ZERO) * 10 + RAWDATE[5] - ZERO];    (**)00321200           
3136   NICEDATE[ 1] := RAWDATE[7];                                       (**)00321300           
3137   NICEDATE[ 2] := RAWDATE[8];                                       (**)00321400           
3138   NICEDATE[ 3] := BLANK;                                            (**)00321500           
3139   NICEDATE[ 4] := MONTH[1];                                         (**)00321600           
3140   NICEDATE[ 5] := MONTH[2];                                         (**)00321700           
3141   NICEDATE[ 6] := MONTH[3];                                         (**)00321800           
3142   NICEDATE[ 7] := BLANK;                                            (**)00321900           
3143   NICEDATE[ 8] := RAWDATE[1];                                       (**)00322000           
3144   NICEDATE[ 9] := RAWDATE[2];                                       (**)00322100           
3145   NICEDATE[10] := BLANK                                             (**)00322200           
3146   END (* INITDATES *);                                              (**)00322300           
3147                                                                         00322400           
3148                                                                         00322500           
3149                                                                         00322600           
3150                                                                         00322700           
3151  (*       INITDIRECTS - INITIALIZE THE DIRECTS TABLE.                   00322800           
3152   *)                                                                    00322900           
3153                                                                         00323000           
3154   PROCEDURE INITDIRECTS;                                                00323100           
3155                                                                         00323200           
3156                                                                         00323300           
3157                                                                         00323400           
3158                                                                         00323500           
3159   (*      ONEDIRECT - INITIALIZE ONE DIRECT ENTRY.                      00323600           
3160    *                                                                    00323700           
3161    *      PARAM  DIR = DIRECTIVE.                                       00323800           
3162    *             A,B,C = 3 CHARACTERS OF DIRECTIVE NAME.                00323900           
3163    *)                                                                   00324000           
3164                                                                         00324100           
3165    PROCEDURE ONEDIRECT( DIR : DIRECT; A,B,C : ASCII );                  00324200           
3166    BEGIN (* ONEDIRECT *)                                                00324300           
3167    DIRECTS[DIR][1] := A;                                                00324400           
3168    DIRECTS[DIR][2] := B;                                                00324500           
3169    DIRECTS[DIR][3] := C                                                 00324600           
3170    END (* ONEDIRECT *);                                                 00324700           
3171                                                                         00324800           
3172                                                                         00324900           
3173                                                                         00325000           
3174                                                                         00325100           
3175   BEGIN (* INITDIRECTS *)                                               00325200           
3176   ONEDIRECT(BRE,B,R,E);                                                 00325300           
3177   ONEDIRECT(COM,C,O,M);                                                 00325400           
3178   ONEDIRECT(COU,C,O,U);                                                 00325500           
3179   ONEDIRECT(FRM,F,O,R);                                                 00325600           
3180   ONEDIRECT(IND,I,N,D);                                                 00325700           
3181   ONEDIRECT(INP,I,N,P);                                                 00325800           
3182   ONEDIRECT(INX,I,N,X);                                                 00325900           
3183   ONEDIRECT(LIT,L,I,T);                                                 00326000           
3184   ONEDIRECT(MAR,M,A,R);                                                 00326100           
3185   ONEDIRECT(OPT,O,P,T);                                                 00326200           
3186   ONEDIRECT(OUT,O,U,T);                                                 00326300           
3187   ONEDIRECT(PAG,P,A,G);                                                 00326400           
3188   ONEDIRECT(PAR,P,A,R);                                                 00326500           
3189   ONEDIRECT(RES,R,E,S);                                                 00326600           
3190   ONEDIRECT(SEL,S,E,L);                                                 00326700           
3191   ONEDIRECT(SKI,S,K,I);                                                 00326800           
3192   ONEDIRECT(SOR,S,O,R);                                                 00326900           
3193   ONEDIRECT(SBT,S,U,B);                                                 00327000           
3194   ONEDIRECT(TTL,T,I,T);                                                 00327100           
3195   ONEDIRECT(UND,U,N,D);                                                 00327200           
3196   ONEDIRECT(WEO,W,E,O);                                                 00327300           
3197   ONEDIRECT(EXC,E,X,C);                                                 00327400           
3198   ONEDIRECT(AST,A,S,C);                                                 00327500           
3199   ONEDIRECT(LPT,L,P,T);                                                 00327600           
3200   ONEDIRECT(AJT,A,J,BLANK)                                              00327700           
3201   END (* INITDIRECTS *);                                                00327800           
3202                                                                         00327900           
3203                                                                         00328000           
3204                                                                         00328100           
3205                                                                         00328200           
3206  (*       INITHOST - INITIALIZE ASCII TO HOST CONVERSION TABLE.         00328300           
3207   *)                                                                    00328400           
3208                                                                         00328500           
3209   PROCEDURE INITHOST;                                               (**)00328600           
3210   VAR                                                               (**)00328700           
3211    EXTCH         : CHAR;     (* EXTERNAL CHARACTER *)               (**)00328800           
3212    INTCH         : ASCII;    (* INTERNAL CHARACTER *)               (**)00328900           
3213   BEGIN (* INITHOST *)                                              (**)00329000           
3214   FOR INTCH:=NUL TO DEL DO BEGIN                                        00329100           
3215     WITH HOST[INTCH] DO BEGIN                                           00329200           
3216       C:=CHR(INTCH);                                                    00329300           
3217       CHR74:=FALSE;                                                     00329400           
3218       CHR76:=FALSE;                                                     00329500           
3219     END;                                                                00329600           
3220   END;                                                                  00329700           
3221   END (* INITHOST *);                                               (**)00332700           
3222                                                                         00332800           
3223                                                                         00332900           
3224                                                                         00333000           
3225                                                                         00333100           
3226  (*       INITMONTHS - INITIALIZE THE MONTHS TABLE.                     00333200           
3227   *)                                                                    00333300           
3228                                                                         00333400           
3229   PROCEDURE INITMONTHS;                                                 00333500           
3230                                                                         00333600           
3231                                                                         00333700           
3232                                                                         00333800           
3233                                                                         00333900           
3234   (*      ONEMONTH - INITIALIZE ONE MONTH NAME.                         00334000           
3235    *                                                                    00334100           
3236    *      PARAM  MON : MONTH NUMBER.                                    00334200           
3237    *             A,B,C : THREE LETTERS OF MONTH NAME.                   00334300           
3238    *)                                                                   00334400           
3239                                                                         00334500           
3240    PROCEDURE ONEMONTH( MON : INTEGER; A,B,C : ASCII );                  00334600           
3241    BEGIN (* ONEMONTH *)                                                 00334700           
3242    MONTHS[MON][1] := A;                                                 00334800           
3243    MONTHS[MON][2] := B;                                                 00334900           
3244    MONTHS[MON][3] := C                                                  00335000           
3245    END (* ONEMONTH *);                                                  00335100           
3246                                                                         00335200           
3247                                                                         00335300           
3248                                                                         00335400           
3249                                                                         00335500           
3250   BEGIN (* INITMONTHS *)                                                00335600           
3251   ONEMONTH( 1,J,SMALLA,SMALLN);                                         00335700           
3252   ONEMONTH( 2,F,SMALLE,SMALLB);                                         00335800           
3253   ONEMONTH( 3,M,SMALLA,SMALLR);                                         00335900           
3254   ONEMONTH( 4,A,SMALLP,SMALLR);                                         00336000           
3255   ONEMONTH( 5,M,SMALLA,SMALLY);                                         00336100           
3256   ONEMONTH( 6,J,SMALLU,SMALLN);                                         00336200           
3257   ONEMONTH( 7,J,SMALLU,SMALLL);                                         00336300           
3258   ONEMONTH( 8,A,SMALLU,SMALLG);                                         00336400           
3259   ONEMONTH( 9,S,SMALLE,SMALLP);                                         00336500           
3260   ONEMONTH(10,O,SMALLC,SMALLT);                                         00336600           
3261   ONEMONTH(11,N,SMALLO,SMALLV);                                         00336700           
3262   ONEMONTH(12,D,SMALLE,SMALLC)                                          00336800           
3263   END (* INITMONTHS *);                                                 00336900           
3264                                                                         00337000           
3265                                                                         00337100           
3266                                                                         00337200           
3267                                                                         00337300           
3268                                                                         00337400           
3269  BEGIN (* INITIALIZE *)                                                 00337500           
3270  RESET(INFILE);                                                         00337600           
3271  REWRITE(OUTPUT);                                                   (**)00337700           
3272  INITMONTHS;   (* BEFORE INITDATES *)                                   00337900           
3273  INITASC;                                                           (**)00338000           
3274  INITCLASS;                                                             00338100           
3275  INITCLOCKS;                                                            00338200           
3276  INITDATES;                                                             00338300           
3277  INITDIRECTS;                                                           00338400           
3278  INITHOST;                                                          (**)00338500           
3279  DIRECTLINE := FALSE;                                                   00338600           
3280  ENDOFINPUT := FALSE;                                                   00338700           
3281  EOL := TRUE;                                                           00338800           
3282  ERRORS := FALSE;                                                       00338900           
3283  GAPS[0] := 1;                                                          00339000           
3284  INCHAR := BLANK;                                                       00339100           
3285  INCOLUMN := 150;                                                       00339200           
3286  INLENGTH := 0;                                                         00339300           
3287  INXBASE := NIL;                                                        00339400           
3288  INXLAST := NIL;                                                        00339500           
3289  LINENUMBER := 0;                                                       00339600           
3290  LINENUMS := INFILE^ IN ['0'..'9'];                                     00339700           
3291  MOREONLEFT := FALSE;                                                   00339800           
3292  NBLANKS := 0;                                                          00339900           
3293  NCHARS := 0;                                                           00340000           
3294  NEWINLINE := TRUE;                                                     00340100           
3295  NEWOUTLINE := TRUE;                                                    00340200           
3296  NEWPARAGRAPH := TRUE;                                                  00340300           
3297  NGAPS := 0;                                                            00340400           
3298  NWORDS := 0;                                                           00340500           
3299  OUTLENGTH := 1;                                                        00340600           
3300  OUTLINE[1].C := BLANK;                                                 00340700           
3301  OUTLINE[1].NBL := 0;                                                   00340800           
3302  REINITIALIZE([BRE..ILL])                                               00340900           
3303  END (* INITIALIZE *);                                                  00341000           
3304                                                                         00341100           
3305                                                                         00341200           
3306                                                                         00341300           
3307                                                                         00341400           
3308                                                                         00341500           
3309                                                                         00341600           
3310                                                                         00341700           
3311                                                                         00341800           
3312 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00341900           
3313 (*                                                                   *) 00342000           
3314 (*                               PROSE                               *) 00342100           
3315 (*                               -----                               *) 00342200           
3316 (*                                                                   *) 00342300           
3317 (* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *) 00342400           
3318                                                                         00342500           
3319                                                                         00342600           
3320                                                                         00342700           
3321                                                                         00342800           
3322 BEGIN (* PROSE *)                                                       00342900           
3323 INITIALIZE;                                                             00343000           
3324 NEXTWORD;                                                               00343100           
3325 WHILE NOT ENDOFINPUT DO                                                 00343200           
3326  BEGIN PACKWORD; NEXTWORD END;                                          00343300           
3327 BREAK;                                                                  00343400           
3328 IF LINECOUNT < INFINITY                                                 00343500           
3329  THEN BEGIN PAGE(INFINITY);                                             00343600           
3330   ADVANCEFORM                                                           00343700           
3331   END;                                                                  00343800           
3332 IF ERRORS THEN BEGIN                                                    00343900           
3333   WRITELN(' PROSE ERRORS DETECTED.');                                   00343910           
3334   HALT;                                                                 00343920           
3335 END;                                                                    00343930           
3336 END (* PROSE *).                                                        00344000           