perm filename UNDOC.DOC[PAS,DEK] blob sn#614620 filedate 1981-09-29 generic text, type C, neo UTF8
C00001 00001
C00003 00002	% Here is TEX material that gets inserted after \input dochdr
C00004 00003	@ \head The \.{UNDOC} processor.
C00015 00004	@ \head Input and output.
C00021 00005	@ \head Reporting errors to the user.
C00027 00006	@ \head Data structures.
C00039 00007	@ \head Searching for identifiers.
C00055 00008	@ \head Searching for module names.
C00061 00009	@ \head Tokens.
C00069 00010	@ \head Stacks for output.
C00087 00011	@ \head Producing the output.
C00107 00012	@ \head The big output switch.
C00118 00013	@ \head Introduction to the input phase.
C00128 00014	@ \head Inputting the next token.
C00136 00015	@ \head Scanning a numeric definition.
C00142 00016	@ \head Scanning a macro definition.
C00149 00017	@ \head Scanning a module.
C00155 00018	@ \head Debugging.
C00158 00019	@ \head The main program.
C00163 ENDMK
% Here is TEX material that gets inserted after \input dochdr
\def\sc{\:m} % small caps... this definition may go into DOCHDR later
\def\hang{\hangindent 3em}
\chcode'27=13 \def↔{\ifmmode{\mathrel{\char'444}}\else{\penalty999\ } }
	% make ↔ tie two words together except in math mode
\def\TEX{\hbox{T\hskip-.1667em\lower.424ex\hbox{E}\hskip-.125em X}}
\def\PASCAL{{\sc PAS}\-{\sc CAL}}
@ \head The \.{UNDOC} processor.

This program converts a \.{DOC} file to a \PASCAL\ file. It was written
by D. E. Knuth in September, 1981; a somewhat similar {\sc SAIL} program had
been developed in March, 1979. Since this program describes itself, a
bootstrapping process involving hand-translation had to be used to get started.

For large \.{DOC} files one should have a large memory, since \.{UNDOC} keeps
all the \PASCAL\ text in memory (in an abbreviated form). The program uses
a few features of the local \PASCAL\ compiler that may need to be changed in
other installations:

\yskip\item{1)} Case statements have a default.
\item{2)} Input-output is done with ascii characters in a way that allows
end-of-page marks to be distinguished from end-of-line marks.

These features are also present in the \PASCAL\ version of \TEX, where they
are used in a similar (but more complex) way. System-dependent portions
of \.{UNDOC} can be identified by looking at the entries for `system
dependencies' in the index below.
@!@↑system dependencies@>

@ The program begins with a fairly normal header, made up of pieces that
@↑system dependencies@>
will mostly be filled in later. \.{DOC} input comes from file |input|,
the \PASCAL\ output goes to file |output|, the string pool output
goes to file |pool|, and error messages go to the terminal (|tty|). 

If it is necessary to abort the job because of a fatal error, the program
calls the `|quit|' procedure, which goes to the label |end_of_UNDOC|.

@d end_of_UNDOC = 9999 {go here to wrap it up}

@p @<Compiler directives@>
program UNDOC(input,output,pool,tty);
label end_of_UNDOC; {go here to finish}
const @<Constants in the outer block@>
type @<Types in the outer block@>
var @<Globals in the outer block@>
@<Error handling procedures@>
procedure initialize;
	var @<Local variables for initialization@>
	begin @<Set initial values@>

@ Some of this code is optional for use when debugging only; such material
is enclosed between the delimiters |DEBUG| and |GUBED|. 
Other parts, delimited by |STAT| and |TATS|,
are optionally included if statistics about \.{UNDOC}'s memory
usage are desired. Another small section
@↑system dependencies@>
is used to skip the `directory pages' in files produced with the {\sc E} editor
at Stanford; that code is delimited by |STANFORD| and |DROFNATS|.

@d DEBUG==@{ {change this to `|DEBUG==@t@>|' when debugging}
@d GUBED==@} {change this to `|GUBED==@t@>|' when debugging}
@f DEBUG==begin
@f GUBED==end
@d STAT==@{ {change this to `|STAT==@t@>|' when gathering usage statistics}
@d TATS==@} {change this to `|TATS==@t@>|' when gathering usage statistics}
@f STAT==begin
@f TATS==end
@d STANFORD== {change this to `|STANFORD==@t\.{@@\{}@>|' when not using E files}
@d DROFNATS== {change this to `|DROFNATS==@t\.{@@\}}@>|' when not using E files}
@f STANFORD==begin
@f DROFNATS==end

@ The \PASCAL\ compiler used to develop this system has `compiler
directives' that can appear in comments whose first character is a dollar sign.
In production versions of \.{UNDOC} these directives tell the compiler that
@↑system dependencies@>
it is safe to avoid range checks and to leave out the extra code it inserts
for the \PASCAL\ debugger's benefit, although interrupts will occur if
there is arithmetic overflow.

@<Compiler directives@>=
@{@&$C-,A+,D-@} {no range check, catch arithmetic overflow, no debug overhead}
DEBUG @{@&$C+,D+@} GUBED {but turn everything on when debugging}

@ Labels are given symbolic names by the following definitions. We insert
the label `|exit|:' just before the \&{end} of a procedure in which we have
used the `\&{return}' statement defined below;
the label `|restart|' is occasionally used at the very beginning of a
procedure; and the label `|reswitch|' is occasionally used just prior to
a \&{case} statement in which some cases change the conditions and we wish to
branch to the newly applicable case.
Loops that are set up with the \&{loop} construction defined below are
commonly exited by going to `|done|' or to `|found|' or to `|not_found|',
and they are sometimes repeated by going to `|continue|'.

@d exit=10 {go here to leave a procedure}
@d restart=20 {go here to start a procedure again}
@d reswitch=21 {go here to start a case statement again}
@d continue=22 {go here to resume a loop}
@d done=30 {go here to exit a loop}
@d found=31 {go here when you've found it}
@d not_found=32 {go here when you've found something else}

@ Here are some macros for common programming idioms and for the default
case statement.
@↑system dependencies@>

@d incr(#) == #←#+1 {increase a variable by unity}
@d decr(#) == #←#-1 {decrease a variable by unity}
@d loop == while true do {repeat over and over until a |goto| happens}
@d do_nothing == {empty statement}
@d return == goto exit {terminate a procedure call}
@d othercases == others: {default for cases not listed explicitly}
@d endcases == end {follows the default case}
@f othercases == else
@f endcases == end
@f return == nil

@ The following parameters are set big enough to handle \TEX, so they
should be sufficient for most applications of \.{UNDOC}.

buf_size=100; {maximum length of input line}
max_bytes=30000; {number of bytes in identifiers, strings, module names;
	must be less than 65536}
max_toks=65535; {number of bytes in compressed \PASCAL\ code;
	must be less than 65536}
max_names=4000; {number of identifiers, strings, module names;
	must be less than 10240}
max_texts=2000; {number of replacement texts, must be less than 10240}
hash_size=353; {should be prime}
longest_name=300; {module names shouldn't be longer than this}
line_length=72; {lines of \PASCAL\ output have at most this many characters}
out_buf_size=144; {length of output buffer, should be twice |line_length|}
stack_size=50; {number of simultaneous levels of macro expansion}
max_id_length=12; {long identifiers are chopped to this length, which must
	not exceed |line_length|}
unambig_length=7; {identifiers must be unique if chopped to this length}
{note that 7 is more strict than \PASCAL's 8, but this can be varied}
@ \head Input and output.

The input conventions of this program are intended to be very much like those
of \TEX\ (except, of course, they are much simpler because much less needs
to be done). Furthermore they are identical to those of \.{TEXDOC}.
Therefore people who need to make modifications to all three systems
@↑system dependencies@>
should be able to save some time and some headaches.

However, we use the standard \PASCAL\ input/output procedures here wherever
possible, since \.{UNDOC} does not have to deal with files that are names
dynamically by the user, and since there is no input from the terminal.

@ Terminal output is done by writing on file |tty|:
@↑system dependencies@>

@d print(#)==write(tty,#) {`|print|' means write on the terminal}
@d print_ln(#)==write_ln(tty,#) {`|print|' and then start new line}
@d print_nl(#)==  {print information starting on a new line}
	begin write_ln(tty); print(#);

@ The following code re-opens the |input| file in a mode that (a)↔allows us
to see end-of-line characters, and (b)↔does not get the first characters;
@↑system dependencies@>
the first |read_ln| does the first |get|.

@<Set initial...@>=
reset(input,'','/E/I/O'); {prepare for ascii input}
if eof(input) then
	begin print_nl('! Couldn''t open the input file.'); quit;

@ The external text files we work with are of type |char|, which is the full
7-bit ascii code on our local \PASCAL.
@↑system dependencies@>
Internal calculations of \.{UNDOC} are, however, done entirely with the
type |ascii_code|, which is a subrange of the integers. The |ord| and |chr|
functions of \PASCAL\ are used to convert to and from |ascii_code| numbers.

ascii_file = file of char; {text files}
ascii_code = 0..127; {seven-bit numbers}

@ String pool constants are written to the |pool| file.

pool: ascii_file;

@ The following code opens |pool| and checks to make sure that the external
file is available for writing.
@↑system dependencies@>

@<Set init...@>=
if not eof(pool) then
	begin print_nl('! Couldn''t open the pool file.'); quit;

@ Input goes into an array called |buffer|.

@<Globals...@>=buffer: array[0..buf_size] of ascii_code;

@ The following procedure gets one line of input, according to the conventions
of \TEX, namely: If the |input| file has been entirely read, |input_ln| returns
|false| and does nothing else. Otherwise if the next item in the file is an
end-of-page mark, the procedure sets |buffer[0]←form_feed|, |limit←0|, and
returns |true|. Otherwise |ascii_code| numbers representing the next line
of the file are input into |buffer[0]|, |buffer[1]|, $\ldotss$, 
|buffer[limit-1]|; the global variable |limit| is set to the length of the
@↑system dependencies@>
line; |buffer[limit]| is set to an ascii |carriage_return|; and the
procedure returns |true|.

@d carriage_return=@'15 {ascii code (control-M) used at end of line}
@d form_feed=@'14	{ascii code (control-L) used at end of page}
@d tab_mark=@'11	{ascii code (control-I) used as tab-skip}

@p function input_ln:boolean; {inputs the next line or returns |false|}
begin read_ln; {|get| the first character of the line}
if eof(input) then input_ln←false
else	begin limit←0; buffer[0]←ord(input↑);
	if buffer[0]≠form_feed then {not end of page}
		while buffer[limit]≠carriage_return do
			if limit=buf_size-1 then {keep |buffer[buf_size]| empty}
				begin buffer[limit]←carriage_return;
				print_nl('! Input line too long'); error;
			else	begin incr(limit); get(input);
				if eof(input) then buffer[limit]←carriage_return
				else buffer[limit]←ord(input↑);
@ \head Reporting errors to the user.

The \.{UNDOC} processor operates in two phases: first it inputs the source
file and stores a compressed representation of the program, then it produces
the \PASCAL\ output from the compressed representation. 

The global variable |phase_one| tells whether we are in Phase I or not.

phase_one: boolean; {|true| in Phase I, |false| in Phase II}

@ If an error is detected while we are debugging,
we usually want to look at the contents of memory.
A special procedure will be declared later for this purpose.

@<Error handling...@>=
DEBUG procedure debug_help; forward;

@ During the first phase, syntax errors are reported to the user by saying
$$\hbox{`|err_print('! Error message')|'},$$
followed by `|quit|' if no recovery from the error is provided.
This will print the error message followed by an indication of where the error
was spotted in the source file. Note that no period follows the error message,
since the error routine will fill this in automatically.

Errors that are noticed during the second phase are reported to the user
in the same fashion, but the error message will be
followed by an indication of where the error was spotted in the output file.

The actual error indications are provided by a procedure called |error|.

@d err_print(#)==begin print_nl(#); error;

@<Error handling...@>=
procedure error; {prints '\..' and location of error message}
var @<Local variables for |error|@>
begin if phase_one then @<Print error location based on input buffer@>
else @<Print error location based on output buffer@>;
DEBUG debug_help;

@ The error locations during Phase I can be indicated by using the global
variables |loc|, |page|, and |line|, which tell respectively the first
unlooked-at position in |buffer|, the current page number, and the current
line number.

@<Local variables for |error|@>=
k,l: 0..buf_size; {indices into |buffer|}

@ @<Print error location based on input buffer@>=
begin print_ln('. (p.', page:0, ',l.', line:0, ')');
if loc≥limit then l←limit else l←loc;
for k←1 to l do print(chr(buffer[k-1])); {print the characters already read}
for k←1 to l do print(' '); {space out the next line}
for k←l+1 to limit do print(chr(buffer[k-1])); {print the part not yet read}
print(' '); {this space separates the message from future page numbers}

@ The position of errors detected during the second phase can be indicated
by outputting the partially-filled output buffer, which contains |out_ptr|

@<Local variables for |error|@>=
j: 0..out_buf_size; {index into |out_buf|}

@ @<Print error location based on output...@>=
begin print_ln('. (l.',line:0,')');
for j←1 to out_ptr do print(chr(out_buf[j-1])); {print current partial line}
print('...'); {indicate that this information is partial}

@ The |quit| procedure just cuts across all active procedure levels
and jumps out of the program. This is the only non-local \&{goto} statement
in \.{UNDOC}.

@<Error handling...@>=
procedure quit;
begin goto end_of_UNDOC;

@ Sometimes the program's behavior is far different from what it should be,
and \.{UNDOC} prints an error message that is really for the \.{UNDOC}
maintenance person, not the user. In such cases the program says
|confusion('indication of where we are')|.

@d confusion(#)==begin err_print('! This can''t happen (',#,')'); quit;

@ An overflow stop occurs if \.{UNDOC}'s tables aren't large enough.

@d overflow(#)==begin err_print('! Sorry, ',#,' capacity exceeded'); quit;
@ \head Data structures.

Most of the user's \PASCAL\ code is packed into seven-bit or
eight-bit integers in two
large arrays called |byte_mem| and |tok_mem|.
The |byte_mem| array holds the names of identifiers, strings, and modules;
the |tok_mem| array holds the replacement texts
for macros and modules. Allocation is sequential, since things are deleted only
during Phase II, and only in a last-in-first-out manner.

Auxiliary arrays |byte_start| and |tok_start| are used as directories to
|byte_mem| and |tok_mem|, and the |link|, |ilk|, |equiv|, and |text_link|
arrays give further information about names. These auxiliary arrays
consist of sixteen-bit items.

eight_bits=0..255; {unsigned one-byte quantity}
sixteen_bits=0..65535; {unsigned two-byte quantity}

@ @<Globals...@>=
byte_mem: packed array [0..max_bytes] of ascii_code; {characters of names}
tok_mem: packed array [0..max_toks] of eight_bits; {tokens}
byte_start: array [0..max_names] of sixteen_bits; {directory into |byte_mem|}
tok_start: array [0..max_texts] of sixteen_bits; {directory into |tok_mem|}
link: array [0..max_names] of sixteen_bits; {hash table or tree links}
ilk: array [0..max_names] of sixteen_bits; {type codes or tree links}
equiv: array [0..max_names] of sixteen_bits; {info corresponding to names}
text_link: array [0..max_texts] of sixteen_bits; {relates replacement texts}

@ The names of identifiers are found by computing a hash address |h| and
then looking at strings of bytes signified by |hash[h]|, |link[hash[h]]|,
|link[link[hash[h]]]|, $\ldotss$, until either finding the desired name
or encountering a zero.

A `|name_pointer|' variable, which signifies a name, is an index into
|byte_start|. The actual sequence of characters in the name pointed to by
$p$ appears in positions |byte_start[p]| to |byte_start[p+1]-1|, inclusive,
in |byte_mem|. The pointer 0 is used for undefined module names; we don't
want to use it for the names of identifiers, since 0 stands for a null
pointer in a linked list.

Strings are treated like identifiers; the first character (a double-quote)
distinguishes a string from an alphabetic name, but for \.{UNDOC}'s purposes
strings behave like numeric macros. (A `string' here refers to the
strings delimited by double-quotes that \.{UNDOC} processes. \PASCAL\
string constants delimited by single-quote marks are not given such special
treatment, they simply appear as sequences of characters in the \PASCAL\
texts.)  The total number of strings in the string
pool is called |string_ptr|; the total number of names in |byte_mem|
is called |name_ptr|; and the total number of bytes occupied in
|byte_mem| is called |byte_ptr|.

We usually have |byte_start[name_ptr]=byte_ptr|, since this identifies the
end of the most recently created name, which is pointed to by |(name_ptr-1)|.

@d length(#)==byte_start[#+1]-byte_start[#] {the length of a name}

name_pointer=0..max_names; {identifies a name}

@ @<Global...@>=
name_ptr:name_pointer; {first unused position in |byte_start|}
string_ptr:name_pointer; {next number to be given to a string of length $≠1$}
byte_ptr:0..max_bytes; {first unused position in |byte_mem|}

@ @<Set init...@>=
name_ptr←1; string_ptr←128; byte_ptr←1; byte_start[0]←1; byte_start[1]←1; 

@ Replacement texts are stored in |tok_mem|, using similar conventions.
A `|text_pointer|' variable is an index into |tok_start|, and the replacement
text that corresponds to $p$
runs from positions |tok_start[p]| to |tok_start[p+1]-1|, inclusive.
Furthermore, |text_link[p]| is used to connect pieces of text that
have the same name, as we shall see later. The pointer 0 is used
for undefined replacement texts.

The first position of |tok_mem|
that is unoccupied by replacement text is called |tok_ptr|, and the first
unused location of |tok_start| is called |text_ptr|.
We usually have |tok_start[text_ptr]=tok_ptr|, for the same reason that
|byte_start[name_ptr]| is usually equal to |byte_ptr|.

text_pointer=0..max_texts; {identifies a replacement text}

@ @<Glob...@>=
text_ptr:text_pointer; {first unused position in |tok_start|}
tok_ptr:0..max_toks; {first unused position in |tok_mem|}
STAT max_tok_ptr:0..max_toks; {largest value assumed by |tok_ptr|}

@ @<Set init...@>=
tok_ptr←1; text_ptr←1; tok_start[0]←1; tok_start[1]←1;

@ Four types of identifiers are distinguished by their |ilk|:

\yskip\hang |normal| identifiers will appear in the \PASCAL\ program as
ordinary identifiers since they have not been defined to be macros; the
|repl| field for such identifiers is a link in a secondary hash table that
is used to check whether any two of them agree in their first |unambig_length|
characters after underline symbols are removed and lower case letters are
changed to upper case.

\yskip\hang |numeric| identifiers have been defined to be numeric macros;
their |repl| field contains the corresponding numeric value plus $2↑{15}$.
Strings are treated as numeric macros.

\yskip\hang |simple| identifiers have been defined to be simple macros;
their |repl| field points to the corresponding replacement text.

\yskip\hang |parametric| identifiers have been defined to be parametric macros;
like simple identifiers, their |repl| field points to the replacement text.

@d normal=0 {ordinary identifiers have |normal| ilk}
@d numeric=1 {numeric macros and strings have |numeric| ilk}
@d simple=2 {simple macros have |simple| ilk}
@d parametric=3 {parametric macros have |parametric| ilk}

@ The names of modules are stored in |byte_mem| together
with the identifier names, but a hash table is not used for them because
\.{UNDOC} needs to be able to recognize a module name when given a prefix of
that name. A conventional binary seach tree is used to retrieve module names,
with fields called |llink| and |rlink| in place of |link| and |ilk|. The
root of this tree is |rlink[0]|. If $p$ is a pointer to a module name,
|equiv[p]| points to its replacement text, just as in simple and parametric
macros, unless this replacement text has not yet been defined (in which case

@d llink==link {left link in binary search tree for module names}
@d rlink==ilk {right link in binary search tree for module names}

@<Set init...@>=
rlink[0]←0; {the binary search tree starts out with nothing in it}
equiv[0]←0; {the undefined module has no replacement text}

@ Here is a little procedure that prints the text of a given name.

@p procedure print_id(p:name_pointer); {print identifier or module name}
var k:0..max_bytes; {index into |byte_mem|}
begin if p≥name_ptr then print('IMPOSSIBLE')
else for k←byte_start[p] to byte_start[p+1]-1 do print(chr(byte_mem[k]));
@ \head Searching for identifiers.

The hash table described above is updated by the |id_lookup| procedure,
which finds a given identifier and returns a pointer to its index in
|byte_start|. If the identifier was not already present, it is inserted with
a given |ilk| code; and an error message is printed if the identifier is being
doubly defined.

Because of the way \.{UNDOC}'s scanning mechanism works, it is most convenient
to let |id_lookup| search for an identifier that is present in the |buffer|
array. Two other global variables specify its position in the buffer: the
first character is |buffer[id_first]|, and the last is |buffer[id_loc-1]|.
Furthermore, if the identifier is really a string, the global variable
|double_chars| tells how many of the characters in the buffer appear
twice (namely \.{@@@@} and \.{""}), since this additional information makes
it easy to calculate the true length of the string. The final double-quote
of the string is not included in its ``identifier,'' but the first one is,
so the string length is |id_loc-id_first-double_chars-1|.

We have mentioned that |normal| identifiers belong to two hash tables,
one for their true names as they appear in the \.{DOC} file and the other
when they have been reduced to their first |unambig_length| characters.
The hash tables are kept by the method of simple chaining, where the
heads of the individual lists appear in the |hash| and |chop_hash| arrays.
If |h| is a hash code, the primary hash table list starts at |hash[h]| and
proceeds through |link| pointers; the secondary hash table list starts at
|chop_hash[h]| and proceeds through |equiv| pointers. Of course, the same
identifier will probably have two different values of |h|.

The |id_lookup| procedure uses an auxiliary array called |chopped_id| to
contain up to |unambig_length| characters of the current identifier, if
it is necessary to compute the secondary hash code. (This array could be
declared local to |id_lookup|, but in general we are making all array
declarations global in this program, because some compilers and some machine
architectures make dynamic array allocation inefficient.)

id_first:0..buf_size; {where the current identifier begins in the buffer}
id_loc:0..buf_size; {just after the current identifier in the buffer}
double_chars:0..buf_size; {correction to length in case of strings}
hash,chop_hash:array [0..hash_size] of sixteen_bits; {heads of hash lists}
chopped_id:array [0..unambig_length] of ascii_code; {chopped identifier}

@ Initially all the hash lists are empty.

@<Local variables for init...@>=
h:0..hash_size; {index into hash-head arrays}

@ @<Set init...@>=
for h←0 to hash_size-1 do 
	begin hash[h]←0; chop_hash[h]←0;

@ Here now is the main procedure for finding identifiers (and strings).
The parameter $t$ is set to |normal| except when the identifier is
a macro name that is just being defined; in the latter case, $t$ will be
|numeric|, |simple|, or |parametric|.

@p function id_lookup(t:eight_bits):name_pointer; {finds current identifier}
label found, not_found;
var c:eight_bits; {byte being chopped}
i:0..buf_size; {index into |buffer|}
h:0..hash_size; {hash code}
k:0..max_bytes; {index into |byte_mem|}
l:0..buf_size; {length of the given identifier}
p,q:name_pointer; {where the identifier is being sought}
s:0..unambig_length; {index into |chopped_id|}
begin l←id_loc-id_first; {compute the length}
@<Compute the hash code $h$@>;
@<Compute the name location $p$@>;
if (p=name_ptr)∨(t≠normal) then
	@<Update the tables and check for possible errors@>;

@ A simple hash code is used: If the sequence of
ascii_codes is $c↓1c↓2\ldotsm c↓m$, its hash value will be

@<Compute the hash...@>=
h←buffer[id_first]; i←id_first+1;
while i<id_loc do
	begin h←(h+h+buffer[i]) mod hash_size; incr(i);

@ If the identifier is new, it will be placed in position |p=name_ptr|, 
otherwise $p$ will point to its existing location.

@<Compute the name location...@>=
while p≠0 do
	begin if length(p)=l then
	    @<Compare name $p$ with current identifier, |goto found| if equal@>;
p←name_ptr; {the current identifier is new}
link[p]←hash[h]; hash[h]←p; {insert $p$ at beginning of hash list}

@ @<Compare name $p$...@>=
begin i←id_first; k←byte_start[p];
while (i<id_loc)∧(buffer[i]=byte_mem[k]) do
	begin incr(i); incr(k);
if i=id_loc then goto found; {all characters agree}

@ @<Update the tables...@>=
begin if ((p≠name_ptr)∧(t≠normal)∧(ilk[p]=normal)) ∨
		((p=name_ptr)∧(t=normal)∧(buffer[id_first]≠"""")) then
	@<Compute the secondary hash code $h$ and put the first characters
	into the auxiliary array |chopped_id|@>;
if p≠name_ptr then @<Give double-definition error and change $p$ to type $t$@>
else @<Enter a new identifier into the table at position $p$@>;

@ The following routine, which is called into play when it is necessary to
look at the secondary hash table, computes the same hash function as before
(but on the chopped data), and places a zero after the chopped identifier
in |chopped_id| to serve as a convenient sentinel.

@<Compute the secondary...@>=
begin i←id_first; s←0; h←0;
while (i<id_loc)∧(s<unambig_length) do
	begin if buffer[i]≠"_" then
		begin if buffer[i]≥"a" then chopped_id[s]←buffer[i]-@'40
		else chopped_id[s]←buffer[i];
		h←(h+h+chopped_id[s]) mod hash_size; incr(s);

@ If a macro has appeared before it was defined, \.{UNDOC} will
still work all right; after all, such behavior is typical of the replacement
texts for modules, which act very much like macros. However, an undefined
numeric macro
may not be used on the right-hand side of another numeric macro definition,
so \.{UNDOC} finds it simplest to make a blanket rule that macros should
be defined before they are used. The following routine gives an error message
and also fixes up any damage that may have been caused.

@<Give double...@>= {now |p≠name_ptr| and |t≠normal|}
begin if ilk[p]=normal then
	begin err_print('! This identifier has already appeared');
	@<Remove $p$ from secondary hash table@>;
else err_print('! This identifier was defined before');

@ When we have to remove a secondary hash entry, because a |normal| identifier
is changing to another |ilk|, the hash code $h$ and chopped identifier have
already been computed.

@<Remove $p$ from secondary...@>=
if q=p then chop_hash[h]←equiv[p]
else	begin while equiv[q]≠p do q←equiv[q];

@ The following routine could make good use of a generalized |pack| procedure
that puts items into just part of a packed array instead of the whole thing.

@<Enter a new identifier...@>=
begin if (t=normal)∧(buffer[id_first]≠"""") then
	@<Check for ambiguity and update secondary hash@>;
if byte_ptr+l>max_bytes then overflow('byte memory');
if name_ptr=max_names then overflow('name');
i←id_first; k←byte_ptr; {get ready to move the identifier into |byte_mem|}
while i<id_loc do
	begin byte_mem[k]←buffer[i]; incr(k); incr(i);
byte_ptr←k; incr(name_ptr); byte_start[name_ptr]←k;
if buffer[id_first]≠"""" then ilk[p]←t
else @<Define and output a new string of the pool@>;

@ @<Check for ambig...@>=
begin q←chop_hash[h];
while q≠0 do
	begin @<Check if $q$ conflicts with $p$@>;
equiv[p]←chop_hash[h]; chop_hash[h]←p; {put $p$ at front of secondary list}

@ @<Check if $q$ conflicts...@>=
begin k←byte_start[q]; s←0;
while (k<byte_start[q+1]) ∧ (s<unambig_length) do
	begin c←byte_mem[k];
	if c≠"_" then
		begin if c≥"a" then c←c-@'40; {convert to upper case}
		if chopped_id[s]≠c then goto not_found;
if (k=byte_start[q+1])∧(chopped_id[s]≠0) then goto not_found;
print_nl('! Identifier conflict with ');
for k←byte_start[q] to byte_start[q+1]-1 do print(chr(byte_mem[k]));
error; q←0; {only one conflict will be printed, since |equiv[0]=0|}

@ @<Define and output a new string...@>=
begin ilk[p]←numeric; {strings are like numeric macros}
if l-double_chars=2 then {this string is for a single character}
else	begin equiv[p]←string_ptr+@'100000;
	write(pool,chr(@'37+l-double_chars)); {output string length plus @'40}
	while i<id_loc do
		begin write(pool,chr(buffer[i])); {output characters of string}
		if (buffer[i]="""") ∨ (buffer[i]="@@") then
			i←i+2 {omit second appearance of doubled character}
		else incr(i);
@ \head Searching for module names.

The |mod_lookup| procedure finds the module name |module[1..l]| in the
search tree, after inserting it if necessary, and returns a pointer to
where it was found. According to the rules of \.{DOC}, no module name
should be a proper prefix of another, so a ``clean'' comparison should
occur between any two names. The result of |mod_lookup| is↔0 if this
prefix condition is violated.

module:array [0..longest_name] of ascii_code; {name being sought for}

@ @p function mod_lookup(l:sixteen_bits):name_pointer; {finds module name}
label found;
var c:(less,equal,greater,prefix,extension); {comparison between two names}
j:0..longest_name; {index into |module|}
k:0..max_bytes; {index into |byte_mem|}
p:name_pointer; {current node of the search tree}
q:name_pointer; {father of node $p$}
begin c←greater; q←0; p←rlink[0]; {|rlink[0]| is the root of the tree}
while p≠0 do
	begin @<Set $c$ to the result of comparing given name to name $p$@>;
	if c=less then p←llink[q]
	else if c=greater then p←rlink[q]
	else goto found;
@<Enter new module name into the tree@>;
found: if c≠equal then
	begin err_print('! Incompatible module names'); p←0;

@ @<Enter new module name...@>=
if byte_ptr+l>max_bytes then overflow('byte memory');
if name_ptr=max_names then overflow('name');
if c=less then llink[q]←p else rlink[q]←p;
llink[p]←0; rlink[p]←0; c←equal;
for j←1 to l do byte_mem[byte_ptr+j-1]←module[j];
byte_ptr←byte_ptr+l; incr(name_ptr); byte_start[name_ptr]←byte_ptr;

@ @<Set $c$...@>=
begin k←byte_start[p]; c←equal; j←1;
while (k<byte_start[p+1]) ∧ (j≤l) ∧ (module[j]=byte_mem[k]) do
	begin incr(k); incr(j);
if k=byte_start[p+1] then
	if j>l then c←equal
	else c←extension
else if j>l then c←prefix
else if module[j]<byte_mem[k] then c←less
else c←greater;

@ The |prefix_lookup| procedure is supposed to find exactly one module
name that has |module[1..l]| as a prefix. Actually the algorithm silently
accepts also the situation that some module name is a prefix of |module[1..l]|,
because the user is unlikely to object.

@p function prefix_lookup(l:sixteen_bits):name_pointer; {finds name extension}
label found;
var c:(less,equal,greater,prefix,extension); {comparison between two names}
count:0..max_names; {the number of hits}
j:0..longest_name; {index into |module|}
k:0..max_bytes; {index into |byte_mem|}
p:name_pointer; {current node of the search tree}
q:name_pointer; {another place to resume the search after done with one branch}
r:name_pointer; {extension found}
begin q←0; p←rlink[0]; count←0; r←0; {begin search at root of tree}
while p≠0 do
	begin @<Set $c$ to the result of comparing given name to name $p$@>;
	if c=less then p←llink[p]
	else if c=greater then p←rlink[p]
	else	begin r←p; incr(count); q←rlink[p]; p←llink[p];
	if p=0 then
		begin p←q; q←0;
if count≠1 then
	if count=0 then err_print('! Name does not match')
	else err_print('! Ambiguous prefix');
prefix_lookup←r; {the result will be 0 if there was no match}
@ \head Tokens.

Replacement texts, which represent \PASCAL\ code in a compressed format,
appear in |tok_mem| as mentioned above. The codes in
these texts are called `tokens'; some tokens occupy two consecutive
eight-bit byte positions, and the others take just one byte.

If $p>0$ points to a replacement text, |tok_start[p]| is the |tok_mem| position
of the first eight-bit code of that text. If |text_link[p]=0|,
this is the replacement text for a macro, otherwise it is the replacement
text for a module. In the latter case |text_link[p]| is either equal to
|module_flag|, which means that there is no further text for this module, or
|text_link[p]| points to a
continuation of this replacement text; such links are created when
several modules have \PASCAL\ texts with the same name, and they also
tie together all the \PASCAL\ texts of unnamed modules.
The replacement text pointer for the first unnamed module
appears in |text_link[0]|, and the most recent such pointer is |last_unnamed|.

@d module_flag==max_texts {final |link| in module replacement texts}

last_unnamed:text_pointer; {most recent replacement text of unnamed module}

@ @<Set init...@>= last_unnamed←0; text_link[0]←0;

@ If the first byte of a token is less than @'200, the token occupies a
single byte. Otherwise we make a sixteen-bit token by combining two consecutive
bytes $a$ and $b$. If $@'200≤a<@'250$, then $(a-@'200)\times2↑8+b$ points
to an identifier; if $@'250≤a<@'320$, then
$(a-@'250)\times2↑8+b$ points to a module name; otherwise, i.e., if
$@'320≤a<@'400$, then $(a-@'320)\times2↑8+b$ is the number of the module
in which the current replacement text appears.

Codes less than @'200 are 7-bit ascii codes that represent themselves.
In particular, a single-character identifier like `|x|' will be a one-byte
token, while all longer identifiers will occupy two bytes.

Some of the 7-bit ascii codes will not be present, however, so we can
use them for special purposes. The following symbolic names are used:

\yskip\hang |begin_comment| denotes \.{@@\{}, which will become either
\.{\{} or \.{[}.

\yskip\hang |end_comment| denotes \.{@@\}}, which will become either
\.{\}} or \.{]}.

\yskip\hang |octal| denotes the |@@'| that precedes an octal constant.

\yskip\hang |param| denotes insertion of a parameter. This occurs only in
the replacement texts of parametric macros, outside of single-quoted strings
in those texts.

\yskip\hang |join| denotes the concatenation of adjacent items with no
space or line breaks allowed between them (the |@@&| operation of \.{DOC}).

@d begin_comment=@'11 {ascii tab mark will not appear}
@d end_comment=@'12 {ascii line feed will not appear}
@d octal=@'14 {ascii form feed will not appear}
@d param=@'15 {ascii carriage return will not appear}
@d join=@'177 {ascii delete will not appear}

@ The following procedure is used to enter a two-byte value into
|tok_mem| when a replacement text is being generated.

@p procedure store_two_bytes(x:sixteen_bits); {stores high byte, then low byte}
begin if tok_ptr+2>max_toks then overflow('token');
tok_mem[tok_ptr]←x div@'400; {this could be done by a shift command}
tok_mem[tok_ptr+1]←x mod@'400; {this could be done by a logical and}

@ When \.{UNDOC} is being operated in debug mode, it has a procedure to display
a replacement text in symbolic form. This procedure has not been spruced up to
generate a real great format, but at least the results are not as bad as
a memory dump.

@p DEBUG procedure print_repl(p:text_pointer);
var k:0..max_toks; {index into |tok_mem|}
a: sixteen_bits; {current byte(s)}
begin if p≥text_ptr then print('BAD')
else	begin k←tok_start[p];
	while k<tok_start[p+1] do
		begin a←tok_mem[k];
		if a≥@'200 then @<Display two-byte token starting with $a$@>
		else @<Display one-byte token $a$@>;

@ @<Display two-byte...@>=
begin incr(k);
if a<@'250 then {identifier or string}
	begin a←(a-@'200)*@'400+tok_mem[k]; print_id(a);
	if byte_mem[byte_start[a]]="""" then print('"')
	else print(' ');
else if a<@'320 then {module name}
	begin print('@@<'); print_id((a-@'250)*@'400+tok_mem[k]);
else	begin a←(a-@'320)*@'400+tok_mem[k]; {module number}
	print('@@{',a:0,'@@',chr("}")); {can't use right brace in comments}

@ @<Display one-byte...@>=
case a of
begin_comment: print('@@{');
end_comment: print('@@',chr("}")); {can't use right brace in comments}
octal: print('@@''');
param: print('#');
"@@": print('@@@@');
othercases print(chr(a))
@ \head Stacks for output.

Let's make sure that our data structures contain enough information to
produce the entire \PASCAL\ program as desired, by working next on the
algorithms that actually do produce that program.

@ The output process uses a stack to keep track of what is going on at
different ``levels'' as the macros are being expanded.
Entries on this stack have four parts:

\yskip\hang |end_field| is the |tok_mem| location where the replacement
text of a particular level will end;

\hang |byte_field| is the |tok_mem| location from which the next token
on a particular level will be read;

\hang |name_field| points to the name corresponding to a particular level;

\hang |repl_field| points to the replacement text currently being read
at a particular level. (The |name_field| is not sufficient by itself, because
replacement texts can be chained together in their |text_link| fields.)

yskip\noindent The current values of these four quantities are referred to
quite frequently, so they are stored in a separate place instead of in
the |stack| array. We call the current values |cur_end|, |cur_byte|,
|cur_name|, and |cur_repl|.

The global variable |stack_ptr| tells how many levels of output are
currently in progress. The end of all output occurs when the stack is
empty, i.e., when |stack_ptr=0|.

	end_field: sixteen_bits; {ending location of replacement text}
	byte_field: sixteen_bits; {present location within replacement text}
	name_field: name_pointer; {|byte_start| index for text being output}
	repl_field: text_pointer; {|tok_start| index for text being output}

@ @d cur_end==cur_state.end_field {current ending location in |tok_mem|}
@d cur_byte==cur_state.byte_field {location of next output byte in |tok_mem|}
@d cur_name==cur_state.name_field {pointer to current name being expanded}
@d cur_repl==cur_state.repl_field {pointer to current replacement text}

cur_state : output_state; {|cur_end|, |cur_byte|, |cur_name|, |cur_repl|}
stack : array [1..stack_size] of output_state; {info for non-current levels}
stack_ptr: 0..stack_size; {first unused location in the output state |stack|}

@ Parameters must also be stacked. They are placed in
|tok_mem| just above the other replacement texts, and dummy parameter
`names' are placed in |byte_start| just after the other names.
The variables |text_ptr| and |tok_ptr| essentially serve as parameter
stack pointers during the output phase, so there is no need for a separate
data structure to handle this problem.

@ There is an implicit stack corresponding to meta-comments that are output
via \.{@@\{} and \.{@@\}}. But this stack need not be represented in detail,
because we only need to know whether it is empty or not. A global variable
|brace_level| tells how many items would be on this stack if it were present.

brace_level: eight_bits; {current depth of $\.{@@\{}\ldotsm\.{@@\}}$ nesting}

@ To get the output process started, we will perform the following
initialization steps. We may assume that |text_link[0]| is nonzero, since it
points to the \PASCAL\ text in the first unnamed module that generates
code; if there are no such modules, there is nothing to output, and an
error message will have been generated before we do any of the initialization.

@<Initialize the output stacks@>=
stack_ptr←1; brace_level←0; cur_name←0; cur_repl←text_link[0];
cur_byte←tok_start[cur_repl]; cur_end←tok_start[cur_repl+1];

@ When the replacement text for name $p$ is to be inserted into the output,
the following subroutine is called to save the old level of output and get
the new one going.

@p procedure push_level(p:name_pointer); {suspends the current level}
begin if stack_ptr=stack_size then overflow('stack')
else	begin stack[stack_ptr]←cur_state; {save |cur_end|, |cur_byte|, etc.}
	cur_name←p; cur_repl←equiv[p]; cur_byte←tok_start[cur_repl];

@ When we come to the end of a replacement text, the |pop_level| subroutine
does the right thing: It either moves to the continuation of this replacement
text or returns the state to the most recently stacked level. Part of this
subroutine, which updates the parameter stack, will be given later when
study the parameter stack in more detail.

@p procedure pop_level; {do this when |cur_byte| reaches |cur_end|}
label exit;
begin if text_link[cur_repl]=0 then {end of macro expansion}
	begin if ilk[cur_name]=parametric then
		@<Remove a parameter from the parameter stack@>;
else if text_link[cur_repl]<module_flag then {link to a continuation}
	begin cur_repl←text_link[cur_repl]; {we will stay on the same level}
	cur_byte←tok_start[cur_repl]; cur_end←tok_start[cur_repl+1];
decr(stack_ptr); {we will go down to the previous level}
if stack_ptr>0 then cur_state←stack[stack_ptr];
exit: end;

@ The heart of the output procedure is the |get_output| routine, which produces
the next token of output that is not a reference to a macro. This procedure
handles all the stacking and unstacking that is necessary. It returns the
value |number| if the next output has a numeric value (the value of a
numeric macro or string), in which case |cur_val| has been set to the
number in question. The procedure also returns the value |new_module| if the
next output begins the replacement text of some module, in which case
|cur_val| is that module's number. And it returns the value |identifier| if
the next output is an identifier of length two or more, in which case
|cur_val| points to that identifier name.

@d number=@'200 {code returned by |get_output| when next output is numeric}
@d module_number=@'201 {code returned by |get_output| for module numbers}
@d identifier=@'202 {code returned by |get_output| for identifiers}

cur_val:integer; {additional information corresponding to output token}

@ If |get_output| finds that no more output remains, it returns the value zero.

@p function get_output:sixteen_bits; {returns next byte after macro expansion}
label restart, done;
var a:sixteen_bits; {value of current byte}
b:eight_bits; {byte being copied}
bal:sixteen_bits; {excess of \.( versus \.) while copying a parameter}
begin restart: if stack_ptr=0 then a←0
else	begin if cur_byte=cur_end then
		begin pop_level; goto restart;
	a←tok_mem[cur_byte]; incr(cur_byte);
	if a<@'200 then {one-byte token}
		begin if a=param then
		    @<Start scanning current macro parameter, |goto restart|@>;
	else	begin a←(a-@'200)*@'400+tok_mem[cur_byte]; incr(cur_byte);
		if a<@'24000 then {|@'24000=(@'250-@'200)*@'400|}
		    @<Expand macro $a$, |goto restart| if no output found@>
		else if a<@'50000 then {|@'50000=(@'320-@'200)*@'400|}
		    @<Expand module $a-@'24000$, |goto restart|@>
		else	begin cur_val←a-@'50000; a←module_number;
DEBUG if trouble_shooting then debug_help;

@ The user may have forgotten to give any \PASCAL\ text for a module name,
or the \PASCAL\ text may have been associated with a different name by mistake.

@<Expand module $a-...@>=
begin a←a-@'24000;
if equiv[a]≠0 then push_level(a)
else if a≠0 then
	begin print_nl('! Not present: <'); print_id(a); print('>'); error;
goto restart;

@ @<Expand macro ...@>=
begin case ilk[a] of
normal: begin cur_val←a; a←identifier;
numeric: begin cur_val←equiv[a]-@'100000; a←number;
simple: begin push_level(a); goto restart;
parametric: begin @<Put a parameter on the parameter stack,
	or |goto restart| if error occurs@>;
	push_level(a); goto restart;
othercases confusion('output')

@ We come now to the interesting part, the job of putting a parameter on
the parameter stack. First we pop the stack if necessary until getting to
a level that hasn't ended. Then the next character must be a `\.(';
and since parentheses are balanced on each level, the entire parameter must
be present, so we can copy it without difficulty.

@<Put a parameter...@>=
while (cur_byte=cur_end)∧(stack_ptr>0) do pop_level;
if (stack_ptr=0)∨(tok_mem[cur_byte]≠"(") then
	begin print_nl('! No parameter given for '); print_id(a); error;
	goto restart;
@<Copy the parameter into |tok_mem|@>;
equiv[name_ptr]←text_ptr; ilk[name_ptr]←simple;
DEBUG if byte_ptr=max_bytes then overflow('byte memory');
byte_mem[byte_ptr]←"#"; incr(byte_ptr);
GUBED {this is the parameter identifier for debugging printouts}
if name_ptr=max_names then overflow('name');
incr(name_ptr); byte_start[name_ptr]←byte_ptr;
if text_ptr=max_texts then overflow('text');
text_link[text_ptr]←0; incr(text_ptr); tok_start[text_ptr]←tok_ptr;

@ The |pop_level| routine undoes the effect of parameter-pushing when
a parameter macro is finished:

@<Remove a parameter...@>=
STAT tok_ptr>max_tok_ptr then max_tok_ptr←tok_ptr;
TATS {the maximum value of |tok_ptr| occurs just before parameter popping}
decr(name_ptr); decr(text_ptr); tok_ptr←tok_start[text_ptr];
DEBUG decr(byte_ptr);

@ When a parameter occurs in a replacement text, we treat it as a simple
macro in position (|name_ptr-1|):

@<Start scanning...@>=
begin push_level(name_ptr-1); goto restart;

@ Similarly, a |param| token encountered as we copy a parameter is converted
into a simple macro call for |name_ptr-1|.
Some care is needed to handle cases like |macro(#; print('#)'))|; the \.{\#}
token will have been changed to |param| outside of strings, but we still
must distinguish `real' parentheses from those in strings.

@d app_repl(#)==begin if tok_ptr=max_toks then overflow('token');
	tok_mem[tok_ptr]←#; incr(tok_ptr); end

@<Copy the parameter...@>=
bal←1; incr(cur_byte); {skip the opening `\.('}
loop	begin b←tok_mem[cur_byte]; incr(cur_byte);
	if b=param then store_two_bytes(name_ptr+@'77777)
	else	begin if b≥@'200 then
			begin app_repl(b);
			b←tok_mem[cur_byte]; incr(cur_byte);
		else 	case b of
			"(": incr(bal);
			")":	begin decr(bal);
				if bal=0 then goto done;
			"'": repeat app_repl(b);
				b←tok_mem[cur_byte]; incr(cur_byte);
				until b="'"; {copy string, don't change |bal|}
			othercases do_nothing
@ \head Producing the output.

The |get_output| routine above handles most of the complexity of output
generation, but there are two further considerations that have a nontrivial
effect on \.{UNDOC}'s algorithms.

First, we want to make sure that the output is broken into lines not
exceeding |line_length| characters per line, where these breaks occur at
valid places (e.g., not in the middle of a string or a constant or an
identifier, not between `\.<' and `\.>', not at a `\.{@@&}' position
where quantities are being joined together. Therefore we assemble the
output into a buffer before deciding where the line breaks will appear.
However, we make no attempt to make ``logical'' line breaks that would enhance
the readability of the output; people are supposed to read the input of
\.{UNDOC} or the \TEX ed output of \.{TEXDOC} but not the undocumented

Second, we want to decimalize octal constants, and to combine integer
quantities that are added or subtracted, because \PASCAL\ doesn't allow
constant expressions in subrange types or in case labels. This means we
want to have a procedure that treats a construction like \.{(E-15+y)}
as equivalent to `\.{(E+2)}', while also leaving `\.{(1E-15+y)}' and
`\.{(E-15+17*y)}' untouched. Consider also `\.{-15+17.5}' versus
`\.{-15+17..5}'. We shall not combine integers preceding or following
\.*, \./, \.{div}, \.{mod}, or \.{@@&}. Note that if $y$ has been defined
to equal $-2$, we must expand `\.{x*y}' into `\.{x*(-2)}'; but `\.{x-y}'
can expand into `\.{x+2}' and we can even change `\.{x-y mod z}' to
`\.{x+2 mod z}' because \PASCAL\ has a nonstandard \&{mod} operation!

The following solution to these problems has been adopted: An array
|out_buf| contains characters that have been generated but not yet output,
and there are two pointers into this array. One of these, |out_ptr|, is
the number of characters currently in the buffer, and we will have
|1≤out_ptr≤line_length| most of the time. The other is |break_ptr|,
which is the largest value |≤out_ptr| such that we are definitely entitled
to end a line by outputting the characters |out_buf[1..(break_ptr-1)]|;
we will always have |break_ptr≤line_length|.

out_buf: array [0..out_buf_size] of ascii_code; {assembled characters}
out_ptr: 0..out_buf_size; {first available place in |out_buf|}
break_ptr: 0..out_buf_size; {last breaking place in |out_buf|}

@ Besides these two pointers, the output process is in one of several states:

\yskip\hang |num_or_id| means that the last item in the buffer is a number or
identifier, hence a blank space or line break must be inserted if the next
item is also a number or identifier.

\yskip\hang |unbreakable| means that the last item in the buffer was followed
by the \.{@@&} operation that inhibits spaces between it and the next item.

\yskip\hang |sign| means that the last item in the buffer is to be followed
by \.+ or \.-, depending on whether |out_app| is positive or negative.

\yskip\hang |sign_val| means that the decimal equivalent of
$\leftv|out_val|\rightv$ should be appended to the buffer; if $out_val<0$,
it should be preceded by a minus sign, otherwise it should be preceded by
the character |out_sign| unless |out_sign=0|.

\yskip\hang |sign_val_sign| is like |sign_val|, but also append \.+ or \.-
afterwards, depending on whether |out_app| is positive or negative.

\yskip\hang |sign_val_val| is like |sign_val|, but also append the decimal
equivalent of |out_app| including its sign.

\yskip\hang |misc| means none of the above.

For example, the output buffer and output state run through the following
sequence as we generate characters from `\.{(x-15+19-2)':
\noalign{\vskip 3pt}
At each stage we have put as much into the buffer as possible without
knowing what is coming next.

In states |num_or_id|, |unbreakable|, and |misc| the last item in the buffer
lies between |break_ptr| and |out_ptr-1|, inclusive; in the other states we
have |break_ptr=out_ptr|.

The numeric values assigned to |num_or_id|, etc., have been chosen to
shorten some of the program logic; for example, the program makes use of
the fact that |sign+2=sign_val_sign|.

@d misc=0 {state associated with special characters}
@d num_or_id=1 {state associated with numbers and identifiers}
@d sign=2 {state associated with pending \.+ or \.-}
@d sign_val=num_or_id+2 {state associated with pending sign and value}
@d sign_val_sign=sign+2 {|sign_val| followed by another pending sign}
@d sign_val_val=sign_val+2 {|sign_val| followed by another pending value}
@d unbreakable=sign_val_val+1 {state associated with \.{@@&}}

out_state:eight_bits; {current status of partial output}
out_val,out_app:integer; {pending values}
out_sign:ascii_code; {sign to use if appending |out_val≥0|}

@ During the output process, |line| will equal the number of the next line
to be output.

@<Initialize the output buffer@>=
out_state←misc; out_ptr←0; break_ptr←0; out_buf[0]←0; line←1;

@ Here is a simple routine that is invoked when |out_ptr>line_length|
or when it is time to flush out the final line. The |flush_buffer| procedure
writes out the line up to the current |break_ptr| position, then moves the
remaining information to the front of |out_buf|.

@d check_break==if out_ptr>line_length then flush_buffer

@p procedure flush_buffer; {writes one line to output file}
var k:0..out_buf_size; {index into |out_buf|}
begin for k←1 to break_ptr do write(chr(out_buf[k-1]));
write_ln; incr(line);
if line mod 100 = 0 then print('.');
if break_ptr<out_ptr then
	begin if out_buf[break_ptr]=" " then
		incr(break_ptr); {drop space at break}
	for k←break_ptr to out_ptr-1 do out_buf[k-break_ptr]←out_buf[k];
out_ptr←out_ptr-break_ptr; break_ptr←0;
if out_ptr>line_length then
	begin err_print('! Long line must be truncated'); out_ptr←line_length;

@ @<Empty the last line from the buffer@>=
if (out_state≠misc)∨(out_buf[break_ptr]≠".") then
	err_print('! Program didn''t end with period');
break_ptr←out_ptr; flush_buffer;

@ Another simple and useful routine appends the decimal equivalent of
a nonnegative integer to the output buffer.

@d app(#)==begin out_buf[out_ptr]←#; incr(out_ptr); {appends a single character}

@p procedure app_val(v:integer); {puts $v$ into buffer, assumes $v≥0$}
var k:0..out_buf_size; {index into |out_buf|}
begin k←out_buf_size; {first we put the digits at the very end of |out_buf|}
repeat out_buf[k]←v mod 10; v←v div 10; decr(k);
until v=0;
repeat incr(k); app(out_buf[k]+"0");
until k=out_buf_size; {then we append them, most significant first}

@ The output states are kept up to date by the output routines, which are
called |send_out|, |send_val|, and |send_sign|. The |send_out| procedure
has two parameters: $t$ tells the type of information being sent and
$v$ contains the information proper. Some information may also be passed
in the array |out_contrib|.

\yskip\hang If |t=misc| then $v$ is a character to be output.

\hang If |t=str| then $v$ is the length of a string or something like `\.{<>}'
in |out_contrib|.

\hang If |t=ident| then $v$ is the length of an identifier in |out_contrib|.

\hang If |t=frac| then $v$ is the length of a fraction and/or exponent in

@d str=1 {|send_out| code for a string}
@d ident=2 {|send_out| code for an identifier}
@d frac=3 {|send_out| code for a fraction}

out_contrib:array[1..line_length] of ascii_code; {a contribution to |out_buf|}

@ @p procedure send_out(t:eight_bits; v:sixteen_bits); {outputs $v$ of type $t$}
label restart;
var k: 0..line_length; {index into out_contrib}
begin @<Get the buffer ready for appending the new information@>;
if t≠misc then for k←1 to v do app(out_contrib[k])
else app(v);
if t≥ident then out_state←num_or_id {|t=ident| or |frac|}
else out_state←misc {|t=str| or |misc|}

@ Here is where the buffer states for signs and values collapse into simpler
states, because we are about to append something that doesn't combine with
the previous integer constants.

We use an ascii-code trick: Since |","-1="+"| and |","+1="-"|, we have
|","-c=@t sign of $c$@>|, when $\leftv c\rightv=1$.

@<Get the buffer ready...@>=
restart: case out_state of
num_or_id: if t≠frac then
	begin break_ptr←out_ptr;
	if t=ident then app(" ");
sign: begin app(","-out_app); check_break; break_ptr←out_ptr;
sign_val,sign_val_sign: begin @<Append |out_val| to buffer@>;
	out_state←out_state-2; goto restart;
sign_val_val: @<Reduce |sign_val_val| to |sign_val| and |goto restart|@>;
misc: if t≠frac then break_ptr←out_ptr;
othercases do_nothing {this is for |unbreakable| state}

@ @<Append |out_val|...@>=
if out_val<0 then app("-")
else if out_sign>0 then app(out_sign);
app_val(abs(out_val)); check_break;

@ @<Reduce |sign_val_val|...@>=
begin if (t=frac)∨(@<contribution is \.* or \./ or \.{DIV} or \.{MOD}@>) then
	begin @<Append |out_val| to buffer@>;
	out_sign←"+"; out_val←out_app;
else out_val←out_val+out_app;
out_state←sign_val; goto restart;

@ @<contribution is \.*...@>=
     (	((out_contrib[1]="D")∧(out_contrib[2]="I")∧(out_contrib[3]="V")) ∨
	((out_contrib[1]="M")∧(out_contrib[2]="O")∧(out_contrib[3]="D")) ))∨@/

@ The following routine is called with $v=\pm1$ when a plus or minus sign is
appended to the output. It extends \PASCAL\ to allow repeated signs
(e.g., `\.{--}' is equivalent to `\.+'), rather than to give an error message.
The signs following `\.E' in real constants are treated as part of a fraction,
so they are not seen by this routine.

@p procedure send_sign(v:integer);
begin case out_state of
sign, sign_val_sign: out_app←out_app*v;
sign_val:begin out_app←v; out_state←sign_val_sign;
sign_val_val: begin out_val←out_val+out_app; out_app←v; out_state←sign_val_sign;
othercases begin break_ptr←out_ptr; out_app←v; out_state←sign;

@ When a (signed) integer value is to be output, we call |send_val|.
Two consecutive values, although syntactically illegal, are silently
added together. In a situation like `\.{if x=y}' where $x$ has been defined
to equal $+3$, the output will be `\.{IF+3=Y}' rather than `\.{IF 3=Y}'.

@d bad_case=666 {this is a label used below}

@p procedure send_val(v:integer); {output the (signed) value $v$}
label bad_case, {go here if we can't keep $v$ in the output state}
begin case out_state of
num_or_id: begin @<if previous output was \.{DIV} or \.{MOD}, |goto bad_case|@>;
	out_sign←" "; out_state←sign_val; out_val←v; break_ptr←out_ptr;
misc: begin @<if previous output was \.* or \./, |goto bad_case|@>;
	out_sign←0; out_state←sign_val; out_val←v; break_ptr←out_ptr;
@<Handle cases of |send_val| when |out_state| contains a sign@>
othercases goto bad_case
bad_case: @<Append the decimal value of $v$, with parentheses if negative@>;
exit: end;

@ @<Handle cases of |send_val|...@>=
sign: begin out_sign←"+"; out_state←sign_val; out_val←out_app*v;
sign_val: begin out_state←sign_val_val; out_app←v;
sign_val_sign: begin out_state←sign_val_val; out_app←out_app*v;
sign_val_val: begin out_val←out_val+out_app; out_app←v;

@ @<if previous output was \.*...@>=
if (out_ptr=break_ptr+1)∧((out_buf[break_ptr]="*")∨(out_buf[break_ptr]="/"))
	then goto bad_case

@ @<if previous output was \.{DIV}...@>=
if (out_ptr=break_ptr+3)∨((out_ptr=break_ptr+4)∧(out_buf[break_ptr]=" ")) then
	if ((out_buf[out_ptr-3]="D")∧(out_buf[out_ptr-2]="I")∧
		(out_buf[out_ptr-1]="V"))∨ @/
		(out_buf[out_ptr-1]="D")) then goto bad_case

@ @<Append the decimal value...@>=
if v≥0 then
	begin if out_state=num_or_id then
		begin break_ptr←out_ptr; app(" ");
	app_val(v); check_break; out_state←num_or_id;
else	begin app("("); app("-"); app_val(-v); app(")"); check_break;
@ \head The big output switch.

To complete the output process, we need a routine that takes the results
of |get_output| and feeds them to |send_out|, |send_val|, or |send_sign|.
This procedure `|send_the_output|' will be invoked just once, as follows:

@<Phase II: Output the contents of the compressed tables@>=
if text_link[0]=0 then print_nl('! No output was specified.')
else	begin print_nl('Writing the output file...');
	@<Initialize the output stacks@>;
	@<Initialize the output buffer@>;
	@<Empty the last line...@>;

@ A many-way switch is used to send the output:

@d get_fraction=2 {this label is used below}

@p procedure send_the_output;
label get_fraction, {go here to finish scanning a real constant}
	reswitch, continue;
var cur_char:eight_bits; {the latest character received}
	k:0..line_length; {index into |out_contrib|}
	j:0..max_bytes; {index into |byte_mem|}
	n:integer; {number being scanned}
begin while stack_ptr>0 do
	begin cur_char←get_output;
	reswitch: case cur_char of
	0: do_nothing; {this case might arise if output ends unexpectedly}
	@<Cases related to identifiers@>
	@<Cases related to constants, possibly leading to |get_fraction| or
	"+","-": send_sign(","-cur_char);
	@<Cases like |"≠"| and |"←"|@>
	"'": @<Send a string, |goto reswitch|@>;
	@<Other printable characters@>: send_out(misc,cur_char);
	@<Cases involving \.{@@\{} and \.{@@\}}@>
	join: begin send_out(frac,0); out_state←unbreakable;
	othercases err_print('! Can''t output ascii code ',cur_char:0)
	goto continue;
	get_fraction: @<Special code to finish real constants@>;
	continue: end;

@ The numbers in the following definitions are ``ascii codes'' for special
characters that aren't standard in ascii, but they have the stated meaning at
Stanford, MIT, Carnegie, USC, etc.; but the codes for |"←"| and |"≠"| are not
shown explicitly, because they tend to vary at different sites.

@d and_sign=@'4
@d not_sign=@'5
@d set_element_sign=@'6
@d or_sign=@'37
@d equivalence_sign=@'36
@d greater_or_equal=@'35
@d less_or_equal=@'34

@<Cases like |"≠"|...@>=
and_sign: begin out_contrib[1]←"A"; out_contrib[2]←"N"; out_contrib[3]←"D";
not_sign: begin out_contrib[1]←"N"; out_contrib[2]←"O"; out_contrib[3]←"T";
set_element_sign: begin out_contrib[1]←"I"; out_contrib[2]←"N";
or_sign: begin out_contrib[1]←"O"; out_contrib[2]←"R"; send_out(ident,2);
"←": begin out_contrib[1]←":"; out_contrib[2]←"="; send_out(str,2);
"≠": begin out_contrib[1]←"<"; out_contrib[2]←">"; send_out(str,2);
less_or_equal: begin out_contrib[1]←"<"; out_contrib[2]←"="; send_out(str,2);
greater_or_equal: begin out_contrib[1]←">"; out_contrib[2]←"="; send_out(str,2);
equivalence_sign: begin out_contrib[1]←"="; out_contrib[2]←"="; send_out(str,2);

@ Please don't ask how all of the following characters can actually get
through \.{UNDOC} outside of strings. It seems that |" "|, |""""|, |"{"|,
and |"}"| cannot actually occur at this point of the program, but they have
been included just in case \.{UNDOC} changes.

@<Other printable characters@>=
" ","!","""","#","$","%","&","(",")","*",",","/",":",";","<","=",">","?",

@ Single-character identifiers represent themselves, while longer ones
appear in |byte_mem|. All must be converted to upper case,
with underlines removed. Extremely long identifiers must be chopped.

@d up_to(#)==#-24,#-23,#-22,#-21,#-20,#-19,#-18,#-17,#-16,#-15,#-14,

@<Cases related to identifiers@>=
"A",up_to("Z"): begin out_contrib[1]←cur_char; send_out(ident,1);
"a",up_to("z"): begin out_contrib[1]←cur_char-@'40; send_out(ident,1);
identifier: begin k←0; j←byte_start[cur_val];
	while (k<max_id_length)∧(j<byte_start[cur_val+1]) do
		begin incr(k); out_contrib[k]←byte_mem[j]; incr(j);
		if out_contrib[k]≥"a" then out_contrib[k]←out_contrib[k]-@'40
		else if out_contrib[k]="_" then decr(k);

@ After sending a string, we need to look ahead at the next character, in order
to see if there were two consecutive single-quote marks. Afterwards we go to
|reswitch| to process the next character.

@<Send a string...@>=
begin k←1; out_contrib[1]←"'";
repeat if k<line_length then incr(k);
until (out_contrib[k]="'")∨(stack_ptr=0);
if k=line_length then err_print('! String too long');
send_out(str,k); cur_char←get_output;
if cur_char="'" then out_state←unbreakable;
goto reswitch;

@ @d digits=="0","1","2","3","4","5","6","7","8","9"

@<Cases related to constants...@>=
digits: begin n←0;
	repeat n←10*n+cur_char-"0"; cur_char←get_output;
	until (cur_char>"9")∨(cur_char<"0");
	send_val(n); k←0;
	if cur_char="e" then cur_char←"E";
	if cur_char="E" then goto get_fraction
	else goto reswitch;
octal: begin n←0; cur_char←"0";
	repeat n←8*n+cur_char-"0"; cur_char←get_output;
	until (cur_char>"7")∨(cur_char<"0");
	send_val(n); goto reswitch;
number: send_val(cur_val);
".":	begin k←1; out_contrib[1]←"."; cur_char←get_output;
	if cur_char="." then
		begin out_contrib[2]←"."; send_out(str,2);
	else if (cur_char≥"0")∧(cur_char≤"9") then goto get_fraction
	else	begin send_out(misc,"."); goto reswitch;

@ The following code appears at label `|get_fraction|', when we want to
scan to the end of a real constant. The first $k$ characters of a fraction
have already been placed in |out_contrib|, and |cur_char| is the next character.

@<Special code...@>=
repeat if k<line_length then incr(k);
out_contrib[k]←cur_char; cur_char←get_output;
if (out_contrib[k]="E")∧((cur_char="+")∨(cur_char="-")) then
	begin if k<line_length then incr(k);
	out_contrib[k]←cur_char; cur_char←get_output;
else if cur_char="e" then cur_char←"E";
until (cur_char≠"E")∧((cur_char<"0")∨(cur_char>"9"));
if k=line_length then err_print('! Fraction too long');
send_out(frac,k); goto reswitch

@ @<Cases involving \.{@@\{} and \.{@@\}}@>=
begin_comment: begin if brace_level=0 then send_out(misc,"{")
	else send_out(misc,"[");
end_comment: if brace_level>0 then
		begin decr(brace_level);
		if brace_level=0 then send_out(misc,"}")
		else send_out(misc,"]");
	else err_print('! Extra @@}');
module_number: if brace_level=0 then
	begin send_out(misc,"{"); send_val(cur_val); send_out(misc,"}");
else	begin send_out(misc,"["); send_val(cur_val); send_out(misc,"]");
@ \head Introduction to the input phase.

We have now seen that \.{UNDOC} will be able to output the full \PASCAL\ 
program, if we can only get that program into the byte memory in the proper
format. The input process is something like the output process in reverse,
since we compress the text as we read it in and we expand it as we write it out.

There are three main input routines. The most interesting is the one that gets
the next token of a \PASCAL\ text; the other two are used to scan rapidly past
\TEX\ text in the \.{DOC} source code. One of the latter routines will jump to
the next token that starts with `\.{@@}', and the other skips to the end
of a \PASCAL\ comment.

@ But first we need to consider the low-level routine that takes care of
updating page and line numbers for error messages and progress reports.
This routine also makes sure that the input ends with an end-of-page signal.
The conventions of \TEX's input routine are used in simplified form: When
|line=0|, it is time to read a new page. After a line has been input, either
|buffer[limit]| is a |carriage_return|, on a normal line, or we have
|limit=0| and |buffer[0]=form_feed|, in which case this is the line that
ends a page. The value of |limit| is always strictly less than |buf_size|,
so it is possible to refer to |buffer[limit+1]| without overstepping the
bounds of the array.

page:sixteen_bits; {the number of the page currently being read}
line:sixteen_bits; {the number of the current line on the current page}
limit:0..buf_size; {the last character position occupied in the buffer}
loc:0..buf_size; {the next character position to be read from the buffer}
input_has_ended: boolean; {if |true|, there is no more input}

@ @<Set initial...@>=
page←0; line←0; limit←0; loc←1; buffer[0]←carriage_return;

@ The |get_line| procedure is called when |loc>limit|; it puts the next
line of input into the buffer and updates the other variables appropriately.

@p procedure get_line; {inputs the next line}
begin if buffer[0]=form_feed then line←0;
if input_ln then {not end of file}
	begin if line=0 then {first line of page}
		begin incr(page); print(page:0,' '); {print progress report}
		@<Special check for file directory page@>;
else if buffer[0]≠form_feed then {insert page mark at end of file}
	begin limit←0; buffer[0]←form_feed;
else input_has_ended←true; {note that page mark is still present}
incr(line); loc←0;

@ The `E' editor on Stanford's {\sc SAIL} computer, where the present version
of \.{UNDOC} was developed, makes up a special first page called the `file
directory' for the files it works with.
This first page is recognizable with sufficiently high
probability by the fact that its first line has length 29 and its first
and ninth characters are respectively `\.C' and `\.⊗'. So the Stanford
version of \.{UNDOC} has special code to skip past all but the page mark
of such a first page:

@<Special check for file directory page@>=
STANFORD if (page=1)∧(limit=29) then
	if (buffer[0]="C")∧(buffer[8]="⊗") then
		repeat if input_ln then do_nothing
		else	begin limit←0; buffer[0]←form_feed;
		until buffer[0]=form_feed

@ Important milestones are reached during the input phase when certain
control codes are sensed, or when a page ends.

Control codes in \.{DOC} begin with `\.{@@}', and the next character
identifies the code. Some of these are of interest only to \.{TEXDOC},
so \.{UNDOC} ignores them; the others are converted by \.{UNDOC} into
internal code numbers by the |control_code| function below. The ordering
of these internal code numbers has been chosen to simplify the progrqm logic;
larger numbers are given to the control codes that denote more significant

@d ignore=0 {control code of no interest to \.{UNDOC}}
@d format=@'203 {control code for `\.{@@f}'}
@d definition=@'204 {control code for `\.{@@d}'}
@d module_name=@'205 {control code for `\.{@@<}'}
@d begin_pascal=@'206 {control code for `\.{@@p}'}
@d page_end=@'207 {control code for end-of-page}
@d new_module=@'210 {control code for `\.{@@ }'}

@p function control_code(c:eight_bits):eight_bits; {convert $c$ after \.{@@}}
begin case c of
"@@": control_code←"@@";
"'": control_code←octal;
" ",tab_mark,carriage_return: control_code←new_module;
"d": control_code←definition;
"f": control_code←format;
"{": control_code←begin_comment;
"}": control_code←end_comment;
"p": control_code←begin_pascal;
"&": control_code←join;
"<": control_code←module_name;
othercases control_code←ignore {ignore all other cases}

@ The |skip_ahead| procedure reads through the input at fairly high speed
until finding the next non-ignorable control code, which it returns.

@p function skip_ahead:eight_bits; {skip to next control code}
label done;
var c:eight_bits; {control code found}
begin loop begin if loc>limit then
		begin get_line;
		if buffer[0]=form_feed then
			begin incr(loc); c←page_end; goto done;
	while buffer[loc]≠"@@" do incr(loc);
	if loc≤limit then
		begin loc←loc+2; c←control_code(buffer[loc-1]);
		if c≠ignore then goto done;
done: skip_ahead←c;

@ The |comment_skip| procedure reads through the input at somewhat high speed
until finding the first unmatched right brace or until coming to the end
of a page. It ignores characters following `\.\\' characters, since all
braces that aren't nested are supposed to be hidden in that way. For
example, consider the process of skipping the first comment below,
where the string containing the right brace has been typed as \.{\`\\.\\\}\'}
in the \.{DOC} file.

@p procedure comment_skip; {skips to next unmatched `\.\}'}
label exit;
var bal:eight_bits; {excess of left braces}
c:eight_bits; {current character}
begin bal←0;
loop	begin if loc>limit then
		begin get_line;
		if buffer[0]=form_feed then
			begin err_print('! Page ended in mid-comment'); return;
	c←buffer[loc]; incr(loc);
	if c="\" then incr(loc)
	else if c="{" then incr(bal)
	else if c="}" then
		begin if bal=0 then return;
@ \head Inputting the next token.

As stated above, \.{UNDOC}'s most interesting input procedure is the
|get_next| routine that inputs the next token. However, the procedure
isn't especially difficult.

In most cases the tokens output by |get_next| have the form used in
replacement texts, except that two-byte tokens are not produced.
An identifier that isn't one letter long is represented by the
output `|identifier|', and in such a case the global variables
|id_first| and |id_loc| will have been set to the appropriate values
needed by the |id_lookup| procedure. A string that begins with a
double-quote is also considered an |identifier|, and in such a case
the global variable |double_chars| will also have been set appropriately.
Control codes produce the corresponding output of the |control_code|
function above; and if that code is |module_name|, the value of |cur_module|
will point to the |byte_start| entry for that module name.

cur_module: name_pointer; {name of module just scanned}

@ @p function get_next:eight_bits; {produces the next input token}
label restart,done;
var c:eight_bits; {the current character}
d:eight_bits; {the next character}
k:0..longest_name; {index into |module|}
begin restart: if loc>limit then get_line;
c←buffer[loc]; incr(loc);
case c of
"A",up_to("Z"),"a",up_to("z"): @<Get an identifier@>;
"""": @<Get a preprocessed string@>;
"@@": @<Get control code and possible module name@>;
@<Compress two-symbol combinations like `\.{:=}'@>
" ",tab_mark,carriage_return: goto restart; {ignore spaces, tabs, end-of-line}
"{": begin comment_skip; goto restart;
form_feed: c←page_end;
othercases do_nothing
DEBUG if trouble_shooting then debug_help;

@ Note that the following code substitutes \.{@@\{} and \.{@@\}} for the
respective combinations `\.{(*}' and `\.{*)}'. Explicit braces should be used
for \TEX\ comments in \PASCAL\ text.

@d compress(#)==begin c←#; incr(loc); end 
@<Compress two-symbol...@>=
":": if buffer[loc]="=" then compress("←");
"=": if buffer[loc]="=" then compress(equivalence_sign);
">": if buffer[loc]="=" then compress(greater_or_equal);
"<": if buffer[loc]="=" then compress(less_or_equal)
	else if buffer[loc]=">" then compress("≠");
"(": if buffer[loc]="*" then compress(begin_comment);
"*": if buffer[loc]=")" then compress(end_comment);

@ @<Get an identifier@>=
begin decr(loc); id_first←loc;
repeat incr(loc); d←buffer[loc];
until ((d<"0")∨((d>"9")∧(d<"A"))∨((d>"Z")∧(d<"a"))∨(d>"z")) ∧ (d≠"_");
if loc>id_first+1 then
	begin c←identifier; id_loc←loc;

@ A string that starts and ends with double-quote marks is converted into
an identifier that behaves like a numeric macro by means of the following
piece of the program.

@<Get a preprocessed string@>=
begin double_chars←0; id_first←loc-1;
repeat d←buffer[loc]; incr(loc);
	if (d="""")∨(d="@@") then
		if buffer[loc]=d then
			begin incr(loc); d←0; incr(double_chars);
		else if d="@@" then err_print('! Double @@ sign missing')
	else if loc>limit then
		begin err_print('! String constant didn''t end'); d←"""";
until d="""";
id_loc←loc-1; c←identifier;

@ @<Get control code and possible module name@>=
begin c←control_code(buffer[loc]); incr(loc);
if c=ignore then goto restart
else if c=module_name then
	@<Scan the module name and make |cur_module| point to it@>;

@ @<Scan the module name...@>=
begin @<Put module name into |module[1..k]|@>;
if k>3 then
	begin if (module[k]=".")∧(module[k-1]=".")∧(module[k-2]=".") then
	else cur_module←mod_lookup(k);

@ Module names are placed into the |module| aray with consecutive spaces,
tabs, and carriage-returns replaced by single spaces. There will be no
spaces at the beginning or the end. (We set |module[0]←" "| to facilitate
this, since the |mod_lookup| routine uses |module[1]| as the first
character of the name.)

@<Put module name...@>=
k←0; module[0]←" ";
loop	begin if loc>limit then
		begin get_line;
		if buffer[0]=form_feed then
			begin err_print('! Page ended in module name');
			goto done;
	@<if end of name, |goto done|@>;
	incr(loc); incr(k);
	if (d=" ")∨(d=tab_mark)∨(d=carriage_return) then
		begin d←" "; if module[k-1]=" " then decr(k);
done: if (module[k]=" ")∧(k>0) then decr(k);

@ @<if end of name,...@>=
if d="@@" then
	begin d←buffer[loc+1];
	if d=">" then
		begin loc←loc+2; goto done;
	if (d=" ")∨(d=tab_mark)∨(d=carriage_return) then
		begin err_print('! Module name didn''t end'); goto done;
	incr(k); module[k]←"@@"; incr(loc); {now |d=buffer[loc]| again}
@ \head Scanning a numeric definition.

When \.{UNDOC} looks at the \PASCAL\ text following the `\.=' of a numeric
macro definition, it calls on the precedure |scan_numeric(p)|, where $p$
points to the name that is to be defined. This procedure evaluates the
right-hand side, which must consist entirely of integer constants and
defined numeric macros connected with \.+ and \.- signs (no parentheses).
It also sets the global variable |next_control| to the control code that
terminated this definition.

A definition ends with the control codes |definition|, |format|, |module_name|,
|begin_pascal|, |new_module|, and |page_end|, all of which can be recognized
by the fact that they are the largest values |get_next| can return.

@d end_of_definition(#)==(#≥format) {is |#| a control code ending a definition?}

next_control:eight_bits; {control code waiting to be acted upon}

@ The evaluation of a numeric expression makes use of two variables called the
|accumulator| and the |next_sign|. At the beginning, |accumulator| is zero and
|next_sign| is $+1$. When a \.+ or \.- is scanned, |next_sign| is multiplied
by the value of that sign. When a numeric value is scanned, it is multiplied
|next_sign| and added to the |accumulator|, then |next_sign| is reset to $+1$.

@p procedure scan_numeric(p:name_pointer); {defines numeric macros}
label reswitch, done;
var accumulator:integer; {accumulates sums}
next_sign:-1..+1; {sign to attach to next value}
q:name_pointer; {points to identifiers being evaluated}
val:integer; {constants being evaluated}
procedure add_in(v:integer); {do this when a new value comes in}
	begin accumulator←accumulator+next_sign*v; next_sign←+1;
begin @<Set |accumulator| to the value of the right-hand side@>;
if abs(accumulator)≥@'100000 then
	begin err_print('! Value too big: ',accumulator:0); accumulator←0;
equiv[p]←accumulator+@'100000; {name $p$ now is defined to equal |accumulator|}

@ @<Set |accumulator| to the value of the right-hand side@>=
accumulator←0; next_sign←+1;
loop	begin next_control←get_next;
	reswitch: case next_control of
	digits: begin @<Set |val| to value of decimal constant, and
			set |next_control| to the following token@>;
		add_in(val); goto reswitch;
	octal: begin @<Set |val| to value of octal constant, and
			set |next_control| to the following token@>;
		add_in(val); goto reswitch;
	identifier: begin q←id_lookup(normal);
		if ilk[q]≠numeric then
			begin next_control←"*"; goto reswitch; {leads to error}
	"+": do_nothing;
	"-": next_sign←-next_sign;
	format, definition, module_name, begin_pascal, page_end,
		new_module: goto done;
	";": err_print('! Omit semicolon in numeric definition');
	othercases @<Signal error, flush rest of the definition@>

@ @<Signal error, flush rest...@>=
begin err_print('! Improper numeric definition will be flushed');
repeat next_control←skip_ahead
until end_of_definition(next_control);
if next_control=module_name then
	begin {we want to scan the module name too}
	loc←loc-2; next_control←get_next;
accumulator←0; goto done;

@ @<Set |val| to value of decimal...@>=
repeat val←10*val+next_control-"0"; next_control←get_next;
until (next_control>"9")∨(next_control<"0");

@ @<Set |val| to value of octal...@>=
val←0; next_control←"0";
repeat val←8*val+next_control-"0"; next_control←get_next;
until (next_control>"7")∨(next_control<"0");
@ \head Scanning a macro definition.

The rules for generating the replacement texts corresponding to simple
macros, parametric macros, and \PASCAL\ texts of a module are almost
identical, so a single procedure is used for all three cases. The
differences are that

\yskip\item{a)} The sign |#| denotes a parameter only when it appears
outside of strings in a parametric macro; otherwise it stands for the
ascii character |#|. (This is not used in standard \PASCAL, but some
\PASCAL s allow, for example, `\.{/\#}' after a certain kind of file name.)

\item{b)}Module names are not allowed in simple macros or parametric macros;
in fact, the appearance of a module name terminates such macros and denotes
the name of the current module.

\item{c)}The symbols \.{@@d} and \.{@@f} and \.{@@p} are not allowed after
module names, while they terminate macro definitions.

@ Therefore there is a procedure |scan_repl| whose parameter $t$ specifies
either |simple| or |parametric| or |module_name|. After |scan_repl| has
acted, |cur_repl_text| will point to the replacement text just generated, and
|next_control| will contain the control code that terminated the activity.

cur_repl_text:text_pointer; {replacement text formed by |scan_repl|}

@ @p procedure scan_repl(t:eight_bits); {creates a replacement text}
label continue, done, found;
var a:sixteen_bits; {the current token}
b:ascii_code; {a character from the buffer}
bal:eight_bits; {left parentheses minus right parentheses}
begin bal←0;
loop	begin continue: a←get_next;
	case a of
	"(": incr(bal);
	")": if bal=0 then err_print('! Extra )')
		else decr(bal);
	"'": @<Copy a string from the buffer to |tok_mem|@>;
	"#": if t=parametric then a←param;
	@<In cases that $a$ is a non-ascii token (|identifier|, |module_name|,
	etc.), 	either process it and change $a$ to a byte that should be
	stored, or |goto continue| if $a$ should be ignored, or
	|goto done| if $a$ signals the end of this replacement text@>
	othercases do_nothing
	app_repl(a); {store $a$ in |tok_mem|}
done: next_control←a;
@<Make sure the parentheses balance@>;
if text_ptr=max_texts then overflow('text');
cur_repl_text←text_ptr; incr(text_ptr); tok_start[text_ptr]←tok_ptr;

@ @<Make sure the parentheses balance@>=
if bal>0 then
	begin err_print('! Missing ',bal:0,' )');
	while bal>0 do
		begin app_repl(")"); decr(bal);

@ @<In cases that $a$ is...@>=
identifier: begin a←id_lookup(normal); app_repl((a div @'400)+@'200);
	a←a mod @'400;
module_name: if t≠module_name then goto done
	else	begin app_repl((cur_module div @'400)+@'250);
		a←cur_module mod @'400;
definition, format, begin_pascal: if t≠module_name then goto done
	else	begin err_print('! @@',chr(buffer[loc-1]),
			' is ignored in PASCAL text'); goto continue;
page_end, new_module: goto done;

@ @<Copy a string...@>=
begin b←"'";
loop	begin app_repl(b);
	if b="@@" then
		if buffer[loc]="@@" then incr(loc) {store only one \.{@@}}
		else err_print('! You should double @@ signs in strings');
	if loc=limit then
		begin err_print('! String didn''t end');
		buffer[loc]←"'"; buffer[loc+1]←0;
	b←buffer[loc]; incr(loc);
	if b="'" then
		begin if buffer[loc]≠"'" then goto found
		else	begin incr(loc); app_repl("'");
found: end {now |a| holds the final |"'"| that will be stored}

@ The following procedure is used to define a simple or parametric macro,
just after the `\.{==}' of its definition has been scanned.

@p procedure define_macro(t:eight_bits);
var p:name_pointer; {the identifier being defined}
begin p←id_lookup(t); scan_repl(t);@/
equiv[p]←cur_repl_text; text_link[cur_repl_text]←0;
@ \head Scanning a module.

The |scan_module| procedure starts when `\.{@@ }' has been sensed in the
input, and it proceeds until the end of that module, i.e., until the
end of the page or the next `\.{@@ }'. It uses |module_count| to keep
track of the current module number; with luck, \.{TEXDOC} and \.{UNDOC}
will both assign the same numbers to modules.

module_count:0..@'27777; {the current module number}

@ @p procedure scan_module;
label done, exit;
var p:name_pointer; {module name for the current module}
begin incr(module_count);
@<Scan the definition part of the current module@>;
@<Scan the \PASCAL\ part of the current module@>;
exit: end;

@ @<Scan the definition part...@>=
loop	begin continue: while next_control≤format do
		begin next_control←skip_ahead;
		if next_control=module_name then
			begin {we want to scan the module name too}
			loc←loc-2; next_control←get_next;
	if next_control≠definition then goto done;
	next_control←get_next; {get identifier name}
	if next_control≠identifier then
		begin err_print('! Definition flushed, must start with ',
			'identifier of length > 1'); goto continue;
	next_control←get_next; {get token after the identifier}
	if next_control="=" then
		begin scan_numeric(id_lookup(numeric)); goto continue;
	else if next_control=equivalence_sign then
		begin define_macro(simple); goto continue;
	else @<if the next text is `|(#)==|', call |define_macro|
		and |goto continue|@>;
	err_print('! Definition flushed since it starts badly');

@ @<if the next text is `|(#)==|'...@>=
if next_control="(" then
	begin next_control←get_next;
	if next_control="#" then
		begin next_control←get_next;
		if next_control=")" then
			begin next_control←get_next;
			if next_control="=" then
				begin err_print('! Use == for macros');
			if next_control=equivalence_sign then
				begin define_macro(parametric); goto continue;

@ @<Scan the \PASCAL...@>=
case next_control of
module_name: begin p←cur_module;
	@<Check that |=| or |==| follows this module name, otherwise |return|@>;
othercases return
@<Insert the module number into |tok_mem|@>;
scan_repl(module_name); {now |cur_repl_txt| points to the replacement text}
@<Update the data structure so that the replacement text is accessible@>;

@ @<Check that |=|...@>=
repeat next_control←get_next;
until next_control≠"+"; {allow optional `\.{+=}'}
if (next_control≠"=")∧(next_control≠equivalence_sign) then
	begin err_print('! PASCAL text flushed, = sign is missing');
	repeat next_control←skip_ahead;
	until next_control≥page_end;

@ @<Insert the module number...@>=
store_two_bytes(@'150000+module_count); {|@'150000=@'320*@'400|}

@ @<Update the data...@>=
if p=0 then {unnamed module}
	begin text_link[last_unnamed]←cur_repl_text; last_unnamed←cur_repl_text;
else if equiv[p]=0 then equiv[p]←cur_repl_text {first module of this name}
else	begin p←equiv[p];
	while text_link[p]<module_flag do p←text_link[p]; {find end of list}
text_link[cur_repl_text]←module_flag; {mark this replacement text as a nonmacro}
@ \head Debugging.

The \PASCAL\ debugger with which \.{UNDOC} was developed allows breakpoints
to be set, and variables can be read and changed, but procedures cannot be
executed. Therefore a `|debug_help|' procedure has been inserted in the main
loops of both phases of the program; when |ddt| and |dd| are set to appropriate
values, symbolic printouts of various tables will appear.

The idea is to set a breakpoint inside the |debug_help| routine.
Then when |debug_help| is to be activated, set |trouble_shooting|
equal to |true|, and set |ddt| and |dd| for the desired actions.

DEBUG trouble_shooting:boolean; {is |debug_help| wanted?}
ddt:eight_bits; {operation code for the |debug_help| routine}
dd:sixteen_bits; {operand in procedures performed by |debug_help|}

@ @<Set init...@>=
DEBUG trouble_shooting←true; ddt←0;

@ @d breakpoint=888 {label where breakpoint is desirable}

@p DEBUG procedure debug_help; {routine to display various things}
label breakpoint;
var k:eight_bits;
begin while ddt≠0 do
	begin breakpoint: {debugger stops here allowing changes to |ddt,dd|}
	case ddt of
	0: do_nothing;
	1: print_id(dd);
	2: print_repl(dd);
	3: err_print('*'); {shows input or output buffer}
	4: for k←1 to dd do print(chr(module[k]));
	5: for k←1 to dd do print(chr(out_contrib[k]));
	othercases print('?')
@ \head The main program.

We have defined plenty of procedures, and it is time to put the last
pieces of the puzzle in place. Here is where \.{UNDOC} starts, and where
it ends.
@↑system dependencies@>

@p begin initialize;
@<Phase I: Read all the user's text and compress it into |tok_mem|@>;
STAT max_tok_ptr←tok_ptr;
@<Phase II:...@>;
if string_ptr>128 then
	print_nl(string_ptr-128:0, ' strings written to string pool file.');
STAT @<Print statistics about memory usage@>;
{here files should be closed if the operating system requires it}

@ @<Phase I:...@>=
repeat next_control←skip_ahead;
while next_control=new_module do scan_module;
until input_has_ended;

@ @<Print statistics about memory usage@>=
print_nl('Memory usage statistics:');
print_nl(name_ptr:0, ' names, ', text_ptr:0, ' replacement texts;');
print_nl(byte_ptr:0, ' bytes, ', max_tok_ptr:0, ' tokens.');