% This program by D. E. Knuth is not copyrighted and can be used freely.
% Version 0 was released in December, 1981.
% Version 1 was released in September, 1982, with version 0 of TeX.
% Slight changes were made in October, 1982, for version 0.6 of TeX.
% Version 1.2 added @@= and @@\ and introduced {:nnn} comments (December, 1982).
% Version 1.4 added "history" (February, 1983).
% Version 1.5 conformed to TeX version 0.96 and fixed @@\ (March, 1983).
% Version 1.7 introduced the new change file format (June, 1983).
% Version 2.0 was released in July, 1983, with version 0.999 of TeX.
% Version 2.5 was released in November, 1983, with version 1.0 of TeX.
% Version 2.6 fixed a bug: force-line-break after a constant (August, 1984).
% Version 2.7 fixed the definition of check←sum←prime (May, 1985).

% Here is TeX material that gets inserted after \input webmac
\def\hang{\hangindent 3em\indent\ignorespaces}
\font\ninerm=amr9
\let\mc=\ninerm % medium caps for names like SAIL
\def\PASCAL{Pascal}
\def\pb{$\.|\ldots\.|$} % Pascal brackets (|...|)
\def\v{\.{\char'174}} % vertical (|) in typewriter font
\mathchardef\BA="3224 % double arrow
\def\({} % kludge for alphabetizing certain module names

\def\title{TANGLE}
\def\contentspagenumber{123} % should be odd
\def\topofcontents{\null\vfill
  \titlefalse % include headline on the contents page
  \def\rheader{\mainfont Appendix E\hfil \contentspagenumber}
  \centerline{\titlefont The {\ttitlefont TANGLE} processor}
  \vskip 15pt
  \centerline{(Version 2.7)}
  \vfill}
\pageno=\contentspagenumber \advance\pageno by 1

@* Introduction.
This program converts a \.{WEB} file to a \PASCAL\ file. It was written
by D. E. Knuth in September, 1981; a somewhat similar {\mc 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 \.{WEB} files one should have a large memory, since \.{TANGLE} 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 routines may need to be adapted for use with a particular
character set and/or for printing messages on the user's terminal.

\yskip\noindent
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 \.{TANGLE} can be identified by looking at the entries for `system
dependencies' in the index below.
@!@↑system dependencies@>

The ``banner line'' defined here should be changed whenever \.{TANGLE}
is modified.

@d banner=='This is TANGLE, Version 2.7'

@ The program begins with a fairly normal header, made up of pieces that
@↑system dependencies@>
will mostly be filled in later. The \.{WEB} input comes from files |web←file|
and |change←file|, the \PASCAL\ output goes to file |Pascal←file|,
and the string pool output goes to file |pool|.

If it is necessary to abort the job because of a fatal error, the program
calls the `|jump←out|' procedure, which goes to the label |end←of←TANGLE|.

@d end←of←TANGLE = 9999 {go here to wrap it up}

@p @t\4@>@<Compiler directives@>@/
program TANGLE(@!web←file,@!change←file,@!Pascal←file,@!pool);
label end←of←TANGLE; {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@>@/
  end;

@ 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 \.{TANGLE}'s memory usage are desired.

@d debug==@{ {change this to `$\\{debug}\equiv\null$' when debugging}
@d gubed==@t@>@} {change this to `$\\{gubed}\equiv\null$' when debugging}
@f debug==begin
@f gubed==end
@#
@d stat==@{ {change this to `$\\{stat}\equiv\null$'
  when gathering usage statistics}
@d tats==@t@>@} {change this to `$\\{tats}\equiv\null$'
  when gathering usage statistics}
@f stat==begin
@f tats==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 \.{TANGLE} 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 `\ignorespaces|end|\unskip' 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.

@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}
@f return == nil
@f loop == xclause

@ We assume that |case| statements may include a default case that applies
if no matching label is found. Thus, we shall use constructions like
@↑system dependencies@>
$$\vbox{\halign{#\hfil\cr
|case x of|\cr
1: $\langle\,$code for $x=1\,\rangle$;\cr
3: $\langle\,$code for $x=3\,\rangle$;\cr
|othercases| $\langle\,$code for |x<>1| and |x<>3|$\,\rangle$\cr
|endcases|\cr}}$$
since most \PASCAL\ compilers have plugged this hole in the language by
incorporating some sort of default mechanism. For example, the compiler
used to develop \.{WEB} and \TeX\ allows `|others|:' as a default label,
and other \PASCAL s allow syntaxes like `\ignorespaces|else|\unskip' or
`\&{otherwise}' or `\\{otherwise}:', etc. The definitions of |othercases|
and |endcases| should be changed to agree with local conventions. (Of
course, if no default mechanism is available, the |case| statements of
this program must be extended by listing all remaining cases. The author
would have taken the trouble to modify \.{TANGLE} so that such extensions
were done automatically, if he had not wanted to encourage \PASCAL\
compiler writers to make this important change in \PASCAL, where it belongs.)

@d othercases == others: {default for cases not listed explicitly}
@d endcases == @+end {follows the default case in an extended |case| statement}
@f othercases == else
@f endcases == end

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

@<Constants...@>=
@!buf←size=100; {maximum length of input line}
@!max←bytes=45000; {|1/ww| times the number of bytes in identifiers,
  strings, and module names; must be less than 65536}
@!max←toks=50000; {|1/zz| times the 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=400; {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}

@ A global variable called |history| will contain one of four values
at the end of every run: |spotless| means that no unusual messages were
printed; |harmless←message| means that a message of possible interest
was printed but no serious errors were detected; |error←message| means that
at least one error was found; |fatal←message| means that the program
terminated abnormally. The value of |history| does not influence the
behavior of the program; it is simply computed for the convenience
of systems that might want to use such information.

@d spotless=0 {|history| value for normal jobs}
@d harmless←message=1 {|history| value when non-serious info was printed}
@d error←message=2 {|history| value when an error was noted}
@d fatal←message=3 {|history| value when we had to stop prematurely}
@#
@d mark←harmless==@t@>@+if history=spotless then history:=harmless←message
@d mark←error==history:=error←message
@d mark←fatal==history:=fatal←message

@<Glob...@>=@!history:spotless..fatal←message; {how bad was this run?}

@ @<Set init...@>=history:=spotless;

@* The character set.
One of the main goals in the design of \.{WEB} has been to make it readily
portable between a wide variety of computers. Yet \.{WEB} by its very
nature must use a greater variety of characters than most computer
programs deal with, and character encoding is one of the areas in which
existing machines differ most widely from each other.

To resolve this problem, all input to \.{WEAVE} and \.{TANGLE} is converted
to an internal seven-bit code that is essentially standard ASCII, the ``American
Standard Code for Information Interchange.''  The conversion is done
immediately when each character is read in. Conversely, characters are
converted from ASCII to the user's external representation just before
they are output.

Such an internal code is relevant to users of \.{WEB} only because it is
the code used for preprocessed constants like \.{"A"}. If you are writing
a program in \.{WEB} that makes use of such one-character constants, you
should convert your input to ASCII form, like \.{WEAVE} and \.{TANGLE} do.
Otherwise \.{WEB}'s internal coding scheme does not affect you.
@↑ASCII code@>

Here is a table of the standard visible ASCII codes:
$$\def\:{\char\count255\global\advance\count255 by 1}
\count255='40
\vbox{
\hbox{\hbox to 40pt{\it\hfill0\/\hfill}%
\hbox to 40pt{\it\hfill1\/\hfill}%
\hbox to 40pt{\it\hfill2\/\hfill}%
\hbox to 40pt{\it\hfill3\/\hfill}%
\hbox to 40pt{\it\hfill4\/\hfill}%
\hbox to 40pt{\it\hfill5\/\hfill}%
\hbox to 40pt{\it\hfill6\/\hfill}%
\hbox to 40pt{\it\hfill7\/\hfill}}
\vskip 4pt
\hrule
\def\↑{\vrule height 10.5pt depth 4.5pt}
\halign{\hbox to 0pt{\hskip -24pt\O{#0}\hfill}&\↑
\hbox to 40pt{\tt\hfill#\hfill\↑}&
&\hbox to 40pt{\tt\hfill#\hfill\↑}\cr
04&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
05&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
06&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
07&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
10&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
11&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
12&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
13&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
14&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
15&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
16&\:&\:&\:&\:&\:&\:&\:&\:\cr\noalign{\hrule}
17&\:&\:&\:&\:&\:&\:&\:\cr}
\hrule width 280pt}$$
(Actually, of course, code @'040 is an invisible blank space.)  Code @'136
was once an upward arrow (\.{\char'13}), and code @'137 was
once a left arrow (\.↑↑X), in olden times when the first draft
of ASCII code was prepared; but \.{WEB} works with today's standard
ASCII in which those codes represent circumflex and underline as shown.

@<Types...@>=
@!ASCII←code=0..127; {seven-bit numbers, a subrange of the integers}

@ The original \PASCAL\ compiler was designed in the late 60s, when six-bit
character sets were common, so it did not make provision for lowercase
letters. Nowadays, of course, we need to deal with both capital and small
letters in a convenient way, so \.{WEB} assumes that it is being used
with a \PASCAL\ whose character set contains at least the characters of
standard ASCII as listed above. Some \PASCAL\ compilers use the original
name |char| for the data type associated with the characters in text files,
while other \PASCAL s consider |char| to be a 64-element subrange of a larger
data type that has some other name.

In order to accommodate this difference, we shall use the name |text←char|
to stand for the data type of the characters in the input and output
files.  We shall also assume that |text←char| consists of the elements
|chr(first←text←char)| through |chr(last←text←char)|, inclusive. The
following definitions should be adjusted if necessary.
@↑system dependencies@>

@d text←char == char {the data type of characters in text files}
@d first←text←char=0 {ordinal number of the smallest element of |text←char|}
@d last←text←char=127 {ordinal number of the largest element of |text←char|}

@<Types...@>=
@!text←file=packed file of text←char;

@ The \.{WEAVE} and \.{TANGLE} processors convert between ASCII code and
the user's external character set by means of arrays |xord| and |xchr|
that are analogous to \PASCAL's |ord| and |chr| functions.

@<Globals...@>=
@!xord: array [text←char] of ASCII←code;
  {specifies conversion of input characters}
@!xchr: array [ASCII←code] of text←char;
  {specifies conversion of output characters}

@ If we assume that every system using \.{WEB} is able to read and write the
visible characters of standard ASCII (although not necessarily using the
ASCII codes to represent them), the following assignment statements initialize
most of the |xchr| array properly, without needing any system-dependent
changes. For example, the statement \.{xchr[@@\'101]:=\'A\'} that appears
in the present \.{WEB} file might be encoded in, say, {\mc EBCDIC} code
on the external medium on which it resides, but \.{TANGLE} will convert from
this external code to ASCII and back again. Therefore the assignment
statement \.{XCHR[65]:=\'A\'} will appear in the corresponding \PASCAL\ file,
and \PASCAL\ will compile this statement so that |xchr[65]| receives the
character \.A in the external (|char|) code. Note that it would be quite
incorrect to say \.{xchr[@@\'101]:="A"}, because |"A"| is a constant of
type |integer|, not |char|, and because we have $|"A"|=65$ regardless of
the external character set.

@<Set init...@>=
xchr[@'40]:=' ';
xchr[@'41]:='!';
xchr[@'42]:='"';
xchr[@'43]:='#';
xchr[@'44]:='$';
xchr[@'45]:='%';
xchr[@'46]:='&';
xchr[@'47]:='''';@/
xchr[@'50]:='(';
xchr[@'51]:=')';
xchr[@'52]:='*';
xchr[@'53]:='+';
xchr[@'54]:=',';
xchr[@'55]:='-';
xchr[@'56]:='.';
xchr[@'57]:='/';@/
xchr[@'60]:='0';
xchr[@'61]:='1';
xchr[@'62]:='2';
xchr[@'63]:='3';
xchr[@'64]:='4';
xchr[@'65]:='5';
xchr[@'66]:='6';
xchr[@'67]:='7';@/
xchr[@'70]:='8';
xchr[@'71]:='9';
xchr[@'72]:=':';
xchr[@'73]:=';';
xchr[@'74]:='<';
xchr[@'75]:='=';
xchr[@'76]:='>';
xchr[@'77]:='?';@/
xchr[@'100]:='@@';
xchr[@'101]:='A';
xchr[@'102]:='B';
xchr[@'103]:='C';
xchr[@'104]:='D';
xchr[@'105]:='E';
xchr[@'106]:='F';
xchr[@'107]:='G';@/
xchr[@'110]:='H';
xchr[@'111]:='I';
xchr[@'112]:='J';
xchr[@'113]:='K';
xchr[@'114]:='L';
xchr[@'115]:='M';
xchr[@'116]:='N';
xchr[@'117]:='O';@/
xchr[@'120]:='P';
xchr[@'121]:='Q';
xchr[@'122]:='R';
xchr[@'123]:='S';
xchr[@'124]:='T';
xchr[@'125]:='U';
xchr[@'126]:='V';
xchr[@'127]:='W';@/
xchr[@'130]:='X';
xchr[@'131]:='Y';
xchr[@'132]:='Z';
xchr[@'133]:='[';
xchr[@'134]:='\';
xchr[@'135]:=']';
xchr[@'136]:='↑';
xchr[@'137]:='←';@/
xchr[@'140]:='`';
xchr[@'141]:='a';
xchr[@'142]:='b';
xchr[@'143]:='c';
xchr[@'144]:='d';
xchr[@'145]:='e';
xchr[@'146]:='f';
xchr[@'147]:='g';@/
xchr[@'150]:='h';
xchr[@'151]:='i';
xchr[@'152]:='j';
xchr[@'153]:='k';
xchr[@'154]:='l';
xchr[@'155]:='m';
xchr[@'156]:='n';
xchr[@'157]:='o';@/
xchr[@'160]:='p';
xchr[@'161]:='q';
xchr[@'162]:='r';
xchr[@'163]:='s';
xchr[@'164]:='t';
xchr[@'165]:='u';
xchr[@'166]:='v';
xchr[@'167]:='w';@/
xchr[@'170]:='x';
xchr[@'171]:='y';
xchr[@'172]:='z';
xchr[@'173]:='{';
xchr[@'174]:='|';
xchr[@'175]:='}';
xchr[@'176]:='~';@/
xchr[0]:=' '; xchr[@'177]:=' '; {these ASCII codes are not used}

@ Some of the ASCII codes below @'40 have been given symbolic names in
\.{WEAVE} and \.{TANGLE} because they are used with a special meaning.

@d and←sign=@'4 {equivalent to `\.{and}'}
@d not←sign=@'5 {equivalent to `\.{not}'}
@d set←element←sign=@'6 {equivalent to `\.{in}'}
@d tab←mark=@'11 {ASCII code used as tab-skip}
@d line←feed=@'12 {ASCII code thrown away at end of line}
@d form←feed=@'14 {ASCII code used at end of page}
@d carriage←return=@'15 {ASCII code used at end of line}
@d left←arrow=@'30 {equivalent to `\.{:=}'}
@d not←equal=@'32 {equivalent to `\.{<>}'}
@d less←or←equal=@'34 {equivalent to `\.{<=}'}
@d greater←or←equal=@'35 {equivalent to `\.{>=}'}
@d equivalence←sign=@'36 {equivalent to `\.{==}'}
@d or←sign=@'37 {equivalent to `\.{or}'}

@ When we initialize the |xord| array and the remaining parts of |xchr|,
it will be convenient to make use of an index variable, |i|.

@<Local variables for init...@>=
@!i:0..last←text←char;

@ Here now is the system-dependent part of the character set.
If \.{WEB} is being implemented on a garden-variety \PASCAL\ for which
only standard ASCII codes will appear in the input and output files, you
don't need to make any changes here. But at MIT, for example, the code in
this module should be changed to
$$\hbox{|for i:=1 to @'37 do xchr[i]:=chr(i);|}$$
\.{WEB}'s character set is essentially identical to MIT's, even with respect to
characters less than @'40.
@↑system dependencies@>

Changes to the present module will make \.{WEB} more friendly on computers
that have an extended character set, so that one can type things like
\.↑↑Z\ instead of \.{<>}. If you have an extended set of characters that
are easily incorporated into text files, you can assign codes arbitrarily
here, giving an |xchr| equivalent to whatever characters the users of
\.{WEB} are allowed to have in their input files, provided that unsuitable
characters do not correspond to special codes like |carriage←return|
that are listed above.

(The present file \.{TANGLE.WEB} does not contain any of the non-ASCII
characters, because it is intended to be used with all implementations of
\.{WEB}.  It was originally created on a Stanford system that has a
convenient extended character set, then ``sanitized'' by applying another
program that transliterated all of the non-standard characters into
standard equivalents.)

@<Set init...@>=
for i:=1 to @'37 do xchr[i]:=' ';

@ The following system-independent code makes the |xord| array contain a
suitable inverse to the information in |xchr|.

@<Set init...@>=
for i:=first←text←char to last←text←char do xord[chr(i)]:=@'40;
for i:=1 to @'176 do xord[xchr[i]]:=i;

@* Input and output.
The input conventions of this program are intended to be very much like those
of \TeX\ (except, of course, that they are much simpler, because much less
needs to be done). Furthermore they are identical to those of \.{WEAVE}.
Therefore people who need to make modifications to all three systems
should be able to do so without too many headaches.

We use the standard \PASCAL\ input/output procedures in several places that
\TeX\ cannot, since \.{TANGLE} does not have to deal with files that are named
dynamically by the user, and since there is no input from the terminal.

@ Terminal output is done by writing on file |term←out|, which is assumed to
consist of characters of type |text←char|:
@↑system dependencies@>

@d print(#)==write(term←out,#) {`|print|' means write on the terminal}
@d print←ln(#)==write←ln(term←out,#) {`|print|' and then start new line}
@d new←line==write←ln(term←out) {start new line}
@d print←nl(#)==  {print information starting on a new line}
  begin new←line; print(#);
  end

@<Globals...@>=
@!term←out:text←file; {the terminal as an output file}

@ Different systems have different ways of specifying that the output on a
certain file will appear on the user's terminal. Here is one way to do this
on the \PASCAL\ system that was used in \.{TANGLE}'s initial development:
@↑system dependencies@>

@<Set init...@>=
rewrite(term←out,'TTY:'); {send |term←out| output to the terminal}

@ The |update←terminal| procedure is called when we want
to make sure that everything we have output to the terminal so far has
actually left the computer's internal buffers and been sent.
@↑system dependencies@>

@d update←terminal == break(term←out) {empty the terminal output buffer}

@ The main input comes from |web←file|; this input may be overridden
by changes in |change←file|. (If |change←file| is empty, there are no changes.)

@<Globals...@>=
@!web←file:text←file; {primary input}
@!change←file:text←file; {updates}

@ The following code opens the input files.  Since these files were listed
in the program header, we assume that the \PASCAL\ runtime system has
already checked that suitable file names have been given; therefore no
additional error checking needs to be done.
@↑system dependencies@>

@p procedure open←input; {prepare to read |web←file| and |change←file|}
begin reset(web←file); reset(change←file);
end;

@ The main output goes to |Pascal←file|, and string pool constants are
written to the |pool| file.

@<Globals...@>=
@!Pascal←file: text←file;
@!pool: text←file;

@ The following code opens |Pascal←file| and |pool|.
Since these files were listed in the program header, we assume that the
\PASCAL\ runtime system has checked that suitable external file names have
been given.
@↑system dependencies@>

@<Set init...@>=
rewrite(Pascal←file); rewrite(pool);

@ Input goes into an array called |buffer|.

@<Globals...@>=@!buffer: array[0..buf←size] of ASCII←code;

@ The |input←ln| procedure brings the next line of input from the specified
file into the |buffer| array and returns the value |true|, unless the file has
already been entirely read, in which case it returns |false|. The conventions
of \TeX\ are followed; i.e., |ASCII←code| numbers representing the next line
of the file are input into |buffer[0]|, |buffer[1]|, \dots,
|buffer[limit-1]|; trailing blanks are ignored;
and the global variable |limit| is set to the length of the
@↑system dependencies@>
line. The value of |limit| must be strictly less than |buf←size|.

We assume that none of the |ASCII←code| values
of |buffer[j]| for |0<=j<limit| is equal to 0, @'177, |line←feed|, |form←feed|,
or |carriage←return|.

@p function input←ln(var f:text←file):boolean;
  {inputs a line or returns |false|}
var final←limit:0..buf←size; {|limit| without trailing blanks}
begin limit:=0; final←limit:=0;
if eof(f) then input←ln:=false
else  begin while not eoln(f) do
    begin buffer[limit]:=xord[f↑]; get(f);
    incr(limit);
    if buffer[limit-1]<>" " then final←limit:=limit;
    if limit=buf←size then
      begin while not eoln(f) do get(f);
      decr(limit); {keep |buffer[buf←size]| empty}
      print←nl('! Input line too long'); loc:=0; error;
@.Input line too long@>
      end;
    end;
  read←ln(f); limit:=final←limit; input←ln:=true;
  end;
end;

@* Reporting errors to the user.
The \.{TANGLE} 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.

@<Globals...@>=
@!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;@+ gubed

@ During the first phase, syntax errors are reported to the user by saying
$$\hbox{`|err←print('! Error message')|'},$$
followed by `|jump←out|' 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 automatically supply a period.

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 new←line; print(#); error;
  end

@<Error handling...@>=
procedure error; {prints '\..' and location of error message}
var j: 0..out←buf←size; {index into |out←buf|}
@!k,@!l: 0..buf←size; {indices into |buffer|}
begin if phase←one then @<Print error location based on input buffer@>
else @<Print error location based on output buffer@>;
update←terminal; mark←error;
@!debug debug←help;@+gubed
end;

@ The error locations during Phase I can be indicated by using the global
variables |loc|, |line|, and |changing|, which tell respectively the first
unlooked-at position in |buffer|, the current line number, and whether or not
the current line is from |change←file| or |web←file|.
This routine should be modified on systems whose standard text editor
has special line-numbering conventions.
@↑system dependencies@>

@<Print error location based on input buffer@>=
begin if changing then print('. (change file ')@+else print('. (');
print←ln('l.', line:1, ')');
if loc>=limit then l:=limit else l:=loc;
for k:=1 to l do
  if buffer[k-1]=tab←mark then print(' ')
  else print(xchr[buffer[k-1]]); {print the characters already read}
new←line;
for k:=1 to l do print(' '); {space out the next line}
for k:=l+1 to limit do print(xchr[buffer[k-1]]); {print the part not yet read}
print(' '); {this space separates the message from future asterisks}
end

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

@<Print error location based on output...@>=
begin print←ln('. (l.',line:1,')');
for j:=1 to out←ptr do print(xchr[out←buf[j-1]]); {print current partial line}
print('... '); {indicate that this information is partial}
end

@ The |jump←out| procedure just cuts across all active procedure levels
and jumps out of the program. This is the only non-local |goto| statement
in \.{TANGLE}. It is used when no recovery from a particular error has
been provided.

Some \PASCAL\ compilers do not implement non-local |goto| statements.
@↑system dependencies@>
In such cases the code that appears at label |end←of←TANGLE| should be
copied into the |jump←out| procedure, followed by a call to a system procedure
that terminates the program.

@d fatal←error(#)==begin new←line; print(#); error; mark←fatal; jump←out;
  end

@<Error handling...@>=
procedure jump←out;
begin goto end←of←TANGLE;
end;

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

@d confusion(#)==fatal←error('! This can''t happen (',#,')')
@.This can't happen@>

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

@d overflow(#)==fatal←error('! Sorry, ',#,' capacity exceeded')
@.Sorry, x capacity exceeded@>


@* Data structures.
Most of the user's \PASCAL\ code is packed into seven- 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.

@<Types...@>=
@!eight←bits=0..255; {unsigned one-byte quantity}
@!sixteen←bits=0..65535; {unsigned two-byte quantity}

@ \.{TANGLE} has been designed to avoid the need for indices that are more
than sixteen bits wide, so that it can be used on most computers. But
there are programs that need more than 65536 tokens, and some programs
even need more than 65536 bytes; \TeX\ is one of these.  To get around
this problem, a slight complication has been added to the data structures:
|byte←mem| and |tok←mem| are two-dimensional arrays, whose first index is
either 0 or 1. (For generality, the first index is actually allowed to run
between 0 and |ww-1| in |byte←mem|, or between 0 and |zz-1| in |tok←mem|,
where |ww| and |zz| are set to 2 and~3; the program will work for any
positive values of |ww| and |zz|, and it can be simplified in obvious ways
if |ww=1| or |zz=1|.)

@d ww=2 {we multiply the byte capacity by approximately this amount}
@d zz=3 {we multiply the token capacity by approximately this amount}

@<Globals...@>=
@!byte←mem: packed array [0..ww-1,0..max←bytes] of ASCII←code;
  {characters of names}
@!tok←mem: packed array [0..zz-1,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]]]|, \dots, 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+ww]-1|, inclusive,
in the segment of |byte←mem| whose first index is |p mod ww|. Thus, when
|ww=2| the even-numbered name bytes appear in |byte←mem[0,@t$*$@>]|
and the odd-numbered ones appear in |byte←mem[1,@t$*$@>]|.
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 \.{TANGLE}'s purposes
strings behave like numeric macros. (A `string' here refers to the
strings delimited by double-quotes that \.{TANGLE} 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|, and the total number of names in |byte←mem|
is called |name←ptr|. The total number of bytes occupied in
|byte←mem[w,@t$*$@>]| is called |byte←ptr[w]|.

We usually have |byte←start[name←ptr+w]=byte←ptr[(name←ptr+w) mod ww]|
for |0<=w<ww|, since these are the starting positions for the next |ww|
names to be stored in |byte←mem|.

@d length(#)==byte←start[#+ww]-byte←start[#] {the length of a name}

@<Types...@>=
@!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:array [0..ww-1] of 0..max←bytes;
  {first unused position in |byte←mem|}
@!pool←check←sum:integer; {sort of a hash for the whole string pool}

@ @<Local variables for init...@>=
@!wi: 0..ww-1; {to initialize the |byte←mem| indices}

@ @<Set init...@>=
for wi:=0 to ww-1 do
  begin byte←start[wi]:=0; byte←ptr[wi]:=0;
  end;
byte←start[ww]:=0; {this makes name 0 of length zero}
name←ptr:=1; string←ptr:=128; pool←check←sum:=271828;

@ 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+zz]-1|, inclusive, in the segment of
|tok←mem| whose first index is |p mod zz|. Thus, when |zz=2| the
even-numbered replacement texts appear in |tok←mem[0,@t$*$@>]| and the
odd-numbered ones appear in |tok←mem[1,@t$*$@>]|.  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[z,@t$*$@>]| that is unoccupied by
replacement text is called |tok←ptr[z]|, and the first unused location of
|tok←start| is called |text←ptr|.  We usually have the identity
|tok←start[text←ptr+z]=tok←ptr[(text←ptr+z) mod zz]|, for |0<=z<zz|, since
these are the starting positions for the next |ww| replacement texts to
be stored in |tok←mem|.

@<Types...@>=
@!text←pointer=0..max←texts; {identifies a replacement text}

@ It is convenient to maintain a variable |z| that is equal to |text←ptr
mod zz|, so that we always insert tokens into segment |z| of |tok←mem|.

@<Glob...@>=
@t\hskip1em@>@!text←ptr:text←pointer; {first unused position in |tok←start|}
@t\hskip1em@>@!tok←ptr:array[0..zz-1] of 0..max←toks;
  {first unused position in a given segment of |tok←mem|}
@t\hskip1em@>@!z:0..zz-1; {current segment of |tok←mem|}
stat @!max←tok←ptr:array[0..zz-1] of 0..max←toks;
  {largest values assumed by |tok←ptr|}
tats

@ @<Local variables for init...@>=
@!zi:0..zz-1; {to initialize the |tok←mem| indices}

@ @<Set init...@>=
for zi:=0 to zz-1 do
  begin tok←start[zi]:=0; tok←ptr[zi]:=0;
  end;
tok←start[zz]:=0; {this makes replacement text 0 of length zero}
text←ptr:=1; z:=1 mod zz;

@ 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
corresponding value in the |equiv| array
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 lowercase letters are
changed to uppercase.

\yskip\hang |numeric| identifiers have been defined to be numeric macros;
their |equiv| value 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 |equiv| value points to the corresponding replacement text.

\yskip\hang |parametric| identifiers have been defined to be parametric macros;
like simple identifiers, their |equiv| value 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
\.{TANGLE} 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
|equiv[p]=0|).

@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|}
@!w:0..ww-1; {segment of |byte←mem|}
begin if p>=name←ptr then print('IMPOSSIBLE')
else  begin w:=p mod ww;
  for k:=byte←start[p] to byte←start[p+ww]-1 do print(xchr[byte←mem[w,k]]);
  end;
end;

@* 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 \.{TANGLE}'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 \.{WEB} 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.)

@<Glob...@>=
@!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;
  end;

@ 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|}
@!w:0..ww-1; {segment of |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)or(t<>normal) then
  @<Update the tables and check for possible errors@>;
id←lookup:=p;
end;

@ A simple hash code is used: If the sequence of
ASCII codes is $c←1c←2\ldots c←m$, its hash value will be
$$(2↑{n-1}c←1+2↑{n-2}c←2+\cdots+c←n)\,\bmod\,|hash←size|.$$

@<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);
  end

@ 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...@>=
p:=hash[h];
while p<>0 do
  begin if length(p)=l then
      @<Compare name |p| with current identifier, |goto found| if equal@>;
  p:=link[p];
  end;
p:=name←ptr; {the current identifier is new}
link[p]:=hash[h]; hash[h]:=p; {insert |p| at beginning of hash list}
found:

@ @<Compare name |p|...@>=
begin i:=id←first; k:=byte←start[p]; w:=p mod ww;
while (i<id←loc)and(buffer[i]=byte←mem[w,k]) do
  begin incr(i); incr(k);
  end;
if i=id←loc then goto found; {all characters agree}
end

@ @<Update the tables...@>=
begin if ((p<>name←ptr)and(t<>normal)and(ilk[p]=normal)) or
    ((p=name←ptr)and(t=normal)and(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|@>;
end

@ 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.
@↑uppercase@>

@<Compute the secondary...@>=
begin i:=id←first; s:=0; h:=0;
while (i<id←loc)and(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);
    end;
  incr(i);
  end;
chopped←id[s]:=0;
end

@ If a macro has appeared before it was defined, \.{TANGLE} 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 \.{TANGLE} 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');
@.This identifier has already...@>
  @<Remove |p| from secondary hash table@>;
  end
else err←print('! This identifier was defined before');
@.This identifier was defined...@>
ilk[p]:=t;
end

@ 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...@>=
q:=chop←hash[h];
if q=p then chop←hash[h]:=equiv[p]
else  begin while equiv[q]<>p do q:=equiv[q];
  equiv[q]:=equiv[p];
  end

@ 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)and(buffer[id←first]<>"""") then
  @<Check for ambiguity and update secondary hash@>;
w:=name←ptr mod ww; k:=byte←ptr[w];
if k+l>max←bytes then overflow('byte memory');
if name←ptr>max←names-ww then overflow('name');
i:=id←first; {get ready to move the identifier into |byte←mem|}
while i<id←loc do
  begin byte←mem[w,k]:=buffer[i]; incr(k); incr(i);
  end;
byte←ptr[w]:=k; byte←start[name←ptr+ww]:=k; incr(name←ptr);
if buffer[id←first]<>"""" then ilk[p]:=t
else @<Define and output a new string of the pool@>;
end

@ @<Check for ambig...@>=
begin q:=chop←hash[h];
while q<>0 do
  begin @<Check if |q| conflicts with |p|@>;
  q:=equiv[q];
  end;
equiv[p]:=chop←hash[h]; chop←hash[h]:=p; {put |p| at front of secondary list}
end

@ @<Check if |q| conflicts...@>=
begin k:=byte←start[q]; s:=0; w:=q mod ww;
while (k<byte←start[q+ww]) and (s<unambig←length) do
  begin c:=byte←mem[w,k];
  if c<>"←" then
    begin if c>="a" then c:=c-@'40; {convert to uppercase}
@↑uppercase@>
    if chopped←id[s]<>c then goto not←found;
    incr(s);
    end;
  incr(k);
  end;
if (k=byte←start[q+ww])and(chopped←id[s]<>0) then goto not←found;
print←nl('! Identifier conflict with ');
@.Identifier conflict...@>
for k:=byte←start[q] to byte←start[q+ww]-1 do print(xchr[byte←mem[w,k]]);
error; q:=0; {only one conflict will be printed, since |equiv[0]=0|}
not←found:
end

@ We compute the string pool check sum by working modulo a prime number
that is large but not so large that overflow might occur.

@d check←sum←prime==@'3777777667 {$2↑{29}-73$}
@↑preprocessed strings@>

@<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}
  equiv[p]:=buffer[id←first+1]+@'100000
else  begin equiv[p]:=string←ptr+@'100000;
  l:=l-double←chars-1;
  if l>99 then err←print('! Preprocessed string is too long');
@.Preprocessed string is too long@>
  incr(string←ptr);
  write(pool,xchr["0"+l div 10],xchr["0"+l mod 10]); {output the length}
  pool←check←sum:=pool←check←sum+pool←check←sum+l;
  while pool←check←sum>check←sum←prime do
    pool←check←sum:=pool←check←sum-check←sum←prime;
  i:=id←first+1;
  while i<id←loc do
    begin write(pool,xchr[buffer[i]]); {output characters of string}
    pool←check←sum:=pool←check←sum+pool←check←sum+buffer[i];
    while pool←check←sum>check←sum←prime do
      pool←check←sum:=pool←check←sum-check←sum←prime;
    if (buffer[i]="""") or (buffer[i]="@@") then
      i:=i+2 {omit second appearance of doubled character}
    else incr(i);
    end;
  write←ln(pool);
  end;
end

@* Searching for module names.
The |mod←lookup| procedure finds the module name |mod←text[1..l]| in the
search tree, after inserting it if necessary, and returns a pointer to
where it was found.

@<Glob...@>=
@!mod←text:array [0..longest←name] of ASCII←code; {name being sought for}

@ According to the rules of \.{WEB}, 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. An error message is printed when such violations
are detected during phase two of \.{WEAVE}.

@d less=0 {the first name is lexicographically less than the second}
@d equal=1 {the first name is equal to the second}
@d greater=2 {the first name is lexicographically greater than the second}
@d prefix=3 {the first name is a proper prefix of the second}
@d extension=4 {the first name is a proper extension of the second}

@p function mod←lookup(@!l:sixteen←bits):name←pointer; {finds module name}
label found;
var c:less..extension; {comparison between two names}
@!j:0..longest←name; {index into |mod←text|}
@!k:0..max←bytes; {index into |byte←mem|}
@!w:0..ww-1; {segment of |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 the given name to
    name |p|@>;
  q:=p;
  if c=less then p:=llink[q]
  else if c=greater then p:=rlink[q]
  else goto found;
  end;
@<Enter a new module name into the tree@>;
found: if c<>equal then
  begin err←print('! Incompatible section names'); p:=0;
@.Incompatible module names@>
  end;
mod←lookup:=p;
end;

@ @<Enter a new module name...@>=
w:=name←ptr mod ww; k:=byte←ptr[w];
if k+l>max←bytes then overflow('byte memory');
if name←ptr>max←names-ww then overflow('name');
p:=name←ptr;
if c=less then llink[q]:=p else rlink[q]:=p;
llink[p]:=0; rlink[p]:=0; c:=equal; equiv[p]:=0;
for j:=1 to l do byte←mem[w,k+j-1]:=mod←text[j];
byte←ptr[w]:=k+l; byte←start[name←ptr+ww]:=k+l; incr(name←ptr);

@ @<Set \(|c|...@>=
begin k:=byte←start[p]; w:=p mod ww; c:=equal; j:=1;
while (k<byte←start[p+ww]) and (j<=l) and (mod←text[j]=byte←mem[w,k]) do
  begin incr(k); incr(j);
  end;
if k=byte←start[p+ww] then
  if j>l then c:=equal
  else c:=extension
else if j>l then c:=prefix
else if mod←text[j]<byte←mem[w,k] then c:=less
else c:=greater;
end

@ The |prefix←lookup| procedure is supposed to find exactly one module
name that has |mod←text[1..l]| as a prefix. Actually the algorithm silently
accepts also the situation that some module name is a prefix of
|mod←text[1..l]|, because the user who painstakingly typed in more than
necessary probably doesn't want to be told about the wasted effort.

@p function prefix←lookup(@!l:sixteen←bits):name←pointer; {finds name extension}
var c:less..extension; {comparison between two names}
@!count:0..max←names; {the number of hits}
@!j:0..longest←name; {index into |mod←text|}
@!k:0..max←bytes; {index into |byte←mem|}
@!w:0..ww-1; {segment of |byte←mem|}
@!p:name←pointer; {current node of the search tree}
@!q:name←pointer; {another place to resume the search after one branch is done}
@!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|...@>;
  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];
    end;
  if p=0 then
    begin p:=q; q:=0;
    end;
  end;
if count<>1 then
  if count=0 then err←print('! Name does not match')
@.Name does not match@>
  else err←print('! Ambiguous prefix');
@.Ambiguous prefix@>
prefix←lookup:=r; {the result will be 0 if there was no match}
end;

@* 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}

@<Glob...@>=
@!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 |param| denotes insertion of a parameter. This occurs only in
the replacement texts of parametric macros, outside of single-quoted strings
in those texts.

\hang |begin←comment| denotes \.{@@\{}, which will become either
\.{\{} or \.{[}.

\hang |end←comment| denotes \.{@@\}}, which will become either
\.{\}} or \.{]}.

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

\hang |hex| denotes the \.{@@"} that precedes a hexadecimal constant.

\hang |check←sum| denotes the \.{@@\char'44} that denotes the string pool
check sum.

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

\hang |double←dot| denotes `\.{..}' in \PASCAL.

\hang |verbatim| denotes the \.{@@=} that begins a verbatim \PASCAL\ string.
It is also used for the end of the string.

\hang |force←line| denotes the \.{@@\\} that forces a new line in the
\PASCAL\ output.
@↑ASCII code@>

@d param=0 {ASCII null code will not appear}
@d verbatim=@'2 {extended ASCII alpha should not appear}
@d force←line=@'3 {extended ASCII beta should not appear}
@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 hex=@'15 {ASCII carriage return will not appear}
@d double←dot=@'40 {ASCII space will not appear except in strings}
@d check←sum=@'175 {will not be confused with right brace}
@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[z]+2>max←toks then overflow('token');
tok←mem[z,tok←ptr[z]]:=x div@'400; {this could be done by a shift command}
tok←mem[z,tok←ptr[z]+1]:=x mod@'400; {this could be done by a logical and}
tok←ptr[z]:=tok←ptr[z]+2;
end;

@ When \.{TANGLE} 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)}
@!zp: 0..zz-1; {segment of |tok←mem| being accessed}
begin if p>=text←ptr then print('BAD')
else  begin k:=tok←start[p]; zp:=p mod zz;
  while k<tok←start[p+zz] do
    begin a:=tok←mem[zp,k];
    if a>=@'200 then @<Display two-byte token starting with |a|@>
    else @<Display one-byte token |a|@>;
    incr(k);
    end;
  end;
end;
gubed

@ @<Display two-byte...@>=
begin incr(k);
if a<@'250 then {identifier or string}
  begin a:=(a-@'200)*@'400+tok←mem[zp,k]; print←id(a);
  if byte←mem[a mod ww,byte←start[a]]="""" then print('"')
  else print(' ');
  end
else if a<@'320 then {module name}
  begin print('@@<'); print←id((a-@'250)*@'400+tok←mem[zp,k]);
  print('@@>');
  end
else  begin a:=(a-@'320)*@'400+tok←mem[zp,k]; {module number}
  print('@@',xchr["{"],a:1,'@@',xchr["}"]); {can't use right brace
    between \&{debug} and \&{gubed}}
  end;
end

@ @<Display one-byte...@>=
case a of
begin←comment: print('@@',xchr["{"]);
end←comment: print('@@',xchr["}"]); {can't use right brace
    between \&{debug} and \&{gubed}}
octal: print('@@''');
hex: print('@@"');
check←sum: print('@@$');
param: print('#');
"@@": print('@@@@');
verbatim: print('@@=');
force←line: print('@@\');
othercases print(xchr[a])
endcases

@* 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 five 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.

\hang |mod←field| is the module number, or zero if this is a macro.

\yskip\noindent The current values of these five 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|, |cur←repl|, and |cur←mod|.

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

@<Types...@>=
@t\4@>@!output←state=record
  @!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}
  @!mod←field: 0..@'27777; {module number or zero if not a module}
  end;

@ @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}
@d cur←mod==cur←state.mod←field {current module number being expanded}

@<Globals...@>=
@!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}

@ It is convenient to keep a global variable |zo| equal to |cur←repl mod zz|.

@<Glob...@>=
@!zo:0..zz-1; {the segment of |tok←mem| from which output is coming}

@ 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[z]| 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.

@<Globals...@>=
@!brace←level: eight←bits; {current depth of $\.{@@\{}\ldots\.{@@\}}$ 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];
zo:=cur←repl mod zz; cur←byte:=tok←start[cur←repl];
cur←end:=tok←start[cur←repl+zz]; cur←mod:=0;

@ 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.}
  incr(stack←ptr);
  cur←name:=p; cur←repl:=equiv[p]; zo:=cur←repl mod zz;
  cur←byte:=tok←start[cur←repl]; cur←end:=tok←start[cur←repl+zz];
  cur←mod:=0;
  end;
end;

@ 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 we
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@>;
  end
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}
  zo:=cur←repl mod zz;
  cur←byte:=tok←start[cur←repl]; cur←end:=tok←start[cur←repl+zz];
  return;
  end;
decr(stack←ptr); {we will go down to the previous level}
if stack←ptr>0 then
  begin cur←state:=stack[stack←ptr]; zo:=cur←repl mod zz;
  end;
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 |module←number|
if the next output begins or ends the replacement text of some module,
in which case |cur←val| is that module's number (if beginning) or the
negative of that value (if ending). 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}

@<Globals...@>=
@!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 token after macro expansion}
label restart, done, found;
var a:sixteen←bits; {value of current byte}
@!b:eight←bits; {byte being copied}
@!bal:sixteen←bits; {excess of \.( versus \.) while copying a parameter}
@!k:0..max←bytes; {index into |byte←mem|}
@!w:0..ww-1; {segment of |byte←mem|}
begin restart: if stack←ptr=0 then
  begin a:=0; goto found;
  end;
if cur←byte=cur←end then
  begin cur←val:=-cur←mod; pop←level;
  if cur←val=0 then goto restart;
  a:=module←number; goto found;
  end;
a:=tok←mem[zo,cur←byte]; incr(cur←byte);
if a<@'200 then {one-byte token}
  if a=param then
      @<Start scanning current macro parameter, |goto restart|@>
  else goto found;
a:=(a-@'200)*@'400+tok←mem[zo,cur←byte]; incr(cur←byte);
if a<@'24000 then {|@'24000=(@'250-@'200)*@'400|}
  @<Expand macro |a| and |goto found|, or |goto restart| if no output found@>;
if a<@'50000 then {|@'50000=(@'320-@'200)*@'400|}
  @<Expand module |a-@'24000|, |goto restart|@>;
cur←val:=a-@'50000; a:=module←number; cur←mod:=cur←val;
found:
@!debug if trouble←shooting then debug←help;@;@+gubed@/
get←output:=a;
end;

@ 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;
@.Not present: <section name>@>
  end;
goto restart;
end

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

@ 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)and(stack←ptr>0) do pop←level;
if (stack←ptr=0)or(tok←mem[zo,cur←byte]<>"(") then
  begin print←nl('! No parameter given for '); print←id(a); error;
@.No parameter given for macro@>
  goto restart;
  end;
@<Copy the parameter into |tok←mem|@>;
equiv[name←ptr]:=text←ptr; ilk[name←ptr]:=simple; w:=name←ptr mod ww;
k:=byte←ptr[w];
@!debug if k=max←bytes then overflow('byte memory');
byte←mem[w,k]:="#"; incr(k); byte←ptr[w]:=k;
gubed {this code has set the parameter identifier for debugging printouts}
if name←ptr>max←names-ww then overflow('name');
byte←start[name←ptr+ww]:=k; incr(name←ptr);
if text←ptr>max←texts-zz then overflow('text');
text←link[text←ptr]:=0; tok←start[text←ptr+zz]:=tok←ptr[z];
incr(text←ptr);
z:=text←ptr mod zz

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

@<Remove a parameter...@>=
begin decr(name←ptr); decr(text←ptr);
z:=text←ptr mod zz;
stat if tok←ptr[z]>max←tok←ptr[z] then max←tok←ptr[z]:=tok←ptr[z];
tats {the maximum value of |tok←ptr| occurs just before parameter popping}
tok←ptr[z]:=tok←start[text←ptr];
@!debug decr(byte←ptr[name←ptr mod ww]);@+gubed
end

@ 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;
end

@ 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[z]=max←toks then overflow('token');
  tok←mem[z,tok←ptr[z]]:=#; incr(tok←ptr[z]); end

@<Copy the parameter...@>=
bal:=1; incr(cur←byte); {skip the opening `\.('}
loop@+  begin b:=tok←mem[zo,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[zo,cur←byte]; incr(cur←byte);
      end
    else   case b of
      "(": incr(bal);
      ")":  begin decr(bal);
        if bal=0 then goto done;
        end;
      "'": repeat app←repl(b);
        b:=tok←mem[zo,cur←byte]; incr(cur←byte);
        until b="'"; {copy string, don't change |bal|}
      othercases do←nothing
      endcases;
    app←repl(b);
    end;
  end;
done:

@* 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 \.{TANGLE}'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 very little attempt to make ``logical'' line breaks that
would enhance the readability of the output; people are supposed to read
the input of \.{TANGLE} or the \TeX ed output of \.{WEAVE}, but not the
tangled-up output. The only concession to readability is that a break after
a semicolon will be made if possible, since commonly used ``pretty
printing'' routines give better results in such cases.

Second, we want to decimalize non-decimal 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+17)}
as equivalent to `\.{(E+2)}', while also leaving `\.{(1E-15+17)}' 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
@↑mod@>
`\.{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 three 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 second 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|. Finally, |semi←ptr| is either
zero or the largest known value of a legal break after a semicolon or comment
on the current line; we will always have |semi←ptr<=break←ptr|.

@<Globals...@>=
@!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|}
@!semi←ptr: 0..out←buf←size; {last semicolon breaking place in |out←buf|}

@ Besides having those three 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
$\vert|out←val|\vert$ should be appended to the buffer. If |out←val<0|,
or if |out←val=0| and |last←sign<0|, the number should be preceded by a minus
sign. Otherwise it should be preceded by the character |out←sign| unless
|out←sign=0|; the |out←sign| variable is either 0 or \.{"\ "} or \.{"+"}.

\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, using |last←sign| in case
|out←app=0|.

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

\yskip\noindent
For example, the output buffer and output state run through the following
sequence as we generate characters from `\.{(x-15+19-2)}':
$$\vbox{\halign{$\hfil#\hfil$\quad&#\hfil&\quad\hfil#\hfil&\quad
\hfil#\hfil&\quad\hfil#\hfil&\quad\hfil#\hfil\quad&\hfil#\hfil\cr
output&|out←buf|&|out←state|&|out←sign|&|out←val|&|out←app|&|last←sign|\cr
\noalign{\vskip 3pt}
(&\.(&|misc|\cr
x&\.{(x}&|num←or←id|\cr
-&\.{(x}&|sign|&&&$-1$&$-1$\cr
15&\.{(x}&|sign←val|&\.{"+"}&$-15$&&$-15$\cr
+&\.{(x}&|sign←val←sign|&\.{"+"}&$-15$&$+1$&$+1$\cr
19&\.{(x}&|sign←val←val|&\.{"+"}&$-15$&$+19$&$+1$\cr
-&\.{(x}&|sign←val←sign|&\.{"+"}&$+4$&$-1$&$-1$\cr
2&\.{(x}&|sign←val←val|&\.{"+"}&$+4$&$-2$&$-2$\cr
)&\.{(x+2)}&|misc|\cr}}$$
At each stage we have put as much into the buffer as possible without
knowing what is coming next. Examples like `\.{x-0.1}' indicate why
|last←sign| is needed to associate the proper sign with an output of zero.

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 \.{@@\&}}

@<Globals...@>=
@!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|}
@!last←sign:-1..+1; {sign to use if appending a zero}

@ 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; semi←ptr:=0; out←buf[0]:=0; line:=1;

@ Here is a routine that is invoked when |out←ptr>line←length|
or when it is time to flush out the final line. The |flush←buffer| procedure
often writes out the line up to the current |break←ptr| position, then moves the
remaining information to the front of |out←buf|. However, it prefers to
write only up to |semi←ptr|, if the residual line won't be too long.

@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|}
@!b:0..out←buf←size; {value of |break←ptr| upon entry}
begin b:=break←ptr;
if (semi←ptr<>0)and(out←ptr-semi←ptr<=line←length) then break←ptr:=semi←ptr;
for k:=1 to break←ptr do write(Pascal←file,xchr[out←buf[k-1]]);
write←ln(Pascal←file); incr(line);
if line mod 100 = 0 then
  begin print('.');
  if line mod 500 = 0 then print(line:1);
  update←terminal; {progress report}
  end;
if break←ptr<out←ptr then
  begin if out←buf[break←ptr]=" " then
    begin incr(break←ptr); {drop space at break}
    if break←ptr>b then b:=break←ptr;
    end;
  for k:=break←ptr to out←ptr-1 do out←buf[k-break←ptr]:=out←buf[k];
  end;
out←ptr:=out←ptr-break←ptr; break←ptr:=b-break←ptr; semi←ptr:=0;
if out←ptr>line←length then
  begin err←print('! Long line must be truncated'); out←ptr:=line←length;
@.Long line must be truncated@>
  end;
end;

@ @<Empty the last line from the buffer@>=
break←ptr:=out←ptr; semi←ptr:=0; flush←buffer;
if brace←level<>0 then
  err←print('! Program ended at brace level ',brace←level:1);
@.Program ended at brace level n@>

@ 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); {append a single character}
  end

@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}
end;

@ 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
|out←contrib|.

@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}

@<Glob...@>=
@!out←contrib:array[1..line←length] of ASCII←code; {a contribution to |out←buf|}

@ A slightly subtle point in the following code is that the user may ask
for a |join| operation (i.e., \.{@@\&}) following whatever is being sent
out.  We will see later that |join| is implemented in part by calling
|send←out(frac,0)|.

@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);
check←break;
if (t=misc)and((v=";")or(v="}")) then
  begin semi←ptr:=out←ptr; break←ptr:=out←ptr;
  end;
if t>=ident then out←state:=num←or←id {|t=ident| or |frac|}
else out←state:=misc {|t=str| or |misc|}
end;

@ 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 $\vert c\vert=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(" ");
  end;
sign: begin app(","-out←app); check←break; break←ptr:=out←ptr;
  end;
sign←val,sign←val←sign: begin @<Append \(|out←val| to buffer@>;
  out←state:=out←state-2; goto restart;
  end;
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}
endcases

@ @<Append \(|out←val|...@>=
if (out←val<0)or((out←val=0)and(last←sign<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)or(@<Contribution is \.* or \./ or \.{DIV} or \.{MOD}@>) then
  begin @<Append \(|out←val| to buffer@>;
  out←sign:="+"; out←val:=out←app;
  end
else out←val:=out←val+out←app;
out←state:=sign←val; goto restart;
end

@ @<Contribution is \.*...@>=
((t=ident)and(v=3)and@|
 (((out←contrib[1]="D")and(out←contrib[2]="I")and(out←contrib[3]="V")) or@|
 ((out←contrib[1]="M")and(out←contrib[2]="O")and(out←contrib[3]="D")) ))or@|
@↑uppercase@>
 ((t=misc)and((v="*")or(v="/")))

@ 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;
  end;
sign←val←val: begin out←val:=out←val+out←app; out←app:=v;
  out←state:=sign←val←sign;
  end;
othercases begin break←ptr:=out←ptr; out←app:=v; out←state:=sign;
  end
endcases;@/
last←sign:=out←app;
end;

@ When a (signed) integer value is to be output, we call |send←val|.

@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}
  exit;
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;
  last←sign:=+1;
  end;
misc: begin @<If previous output was \.* or \./, |goto bad←case|@>;
  out←sign:=0; out←state:=sign←val; out←val:=v; break←ptr:=out←ptr;
  last←sign:=+1;
  end;
@t\4@>@<Handle cases of |send←val| when |out←state| contains a sign@>@;
othercases goto bad←case
endcases;@/
return;
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;
  end;
sign←val: begin out←state:=sign←val←val; out←app:=v;
  err←print('! Two numbers occurred without a sign between them');
  end;
sign←val←sign: begin out←state:=sign←val←val; out←app:=out←app*v;
  end;
sign←val←val: begin out←val:=out←val+out←app; out←app:=v;
  err←print('! Two numbers occurred without a sign between them');
@.Two numbers occurred...@>
  end;

@ @<If previous output was \.*...@>=
if (out←ptr=break←ptr+1)and((out←buf[break←ptr]="*")or(out←buf[break←ptr]="/"))
  then goto bad←case

@ @<If previous output was \.{DIV}...@>=
if (out←ptr=break←ptr+3)or
 ((out←ptr=break←ptr+4)and(out←buf[break←ptr]=" ")) then
@↑uppercase@>
  if ((out←buf[out←ptr-3]="D")and(out←buf[out←ptr-2]="I")and
    (out←buf[out←ptr-1]="V"))or @/
     ((out←buf[out←ptr-3]="M")and(out←buf[out←ptr-2]="O")and
    (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(" ");
    end;
  app←val(v); check←break; out←state:=num←or←id;
  end
else  begin app("("); app("-"); app←val(-v); app(")"); check←break;
  out←state:=misc;
  end

@* 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
  begin print←nl('! No output was specified.'); mark←harmless;
@.No output was specified@>
  end
else  begin print←nl('Writing the output file'); update←terminal;@/
  @<Initialize the output stacks@>;
  @<Initialize the output buffer@>;
  send←the←output;@/
  @<Empty the last line...@>;
  print←nl('Done.');
  end

@ 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|}
  @!w:0..ww-1; {segment of |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}
  @t\4@>@<Cases related to identifiers@>@;
  @t\4@>@<Cases related to constants, possibly leading to
    |get←fraction| or |reswitch|@>@;
  "+","-": send←sign(","-cur←char);
  @t\4@>@<Cases like \.{<>} and \.{:=}@>@;
  "'": @<Send a string, |goto reswitch|@>;
  @<Other printable characters@>: send←out(misc,cur←char);
  @t\4@>@<Cases involving \.{@@\{} and \.{@@\}}@>@;
  join: begin send←out(frac,0); out←state:=unbreakable;
    end;
  verbatim: @<Send verbatim string@>;
  force←line: @<Force a line break@>;
  othercases err←print('! Can''t output ASCII code ',cur←char:1)
@.Can't output ASCII code n@>
  endcases;@/
  goto continue;
  get←fraction: @<Special code to finish real constants@>;
  continue: end;
end;

@ @<Cases like \.{<>}...@>=
and←sign: begin out←contrib[1]:="A"; out←contrib[2]:="N"; out←contrib[3]:="D";
@↑uppercase@>
  send←out(ident,3);
  end;
not←sign: begin out←contrib[1]:="N"; out←contrib[2]:="O"; out←contrib[3]:="T";
  send←out(ident,3);
  end;
set←element←sign: begin out←contrib[1]:="I"; out←contrib[2]:="N";
  send←out(ident,2);
  end;
or←sign: begin out←contrib[1]:="O"; out←contrib[2]:="R"; send←out(ident,2);
  end;
left←arrow: begin out←contrib[1]:=":"; out←contrib[2]:="="; send←out(str,2);
  end;
not←equal: begin out←contrib[1]:="<"; out←contrib[2]:=">"; send←out(str,2);
  end;
less←or←equal: begin out←contrib[1]:="<"; out←contrib[2]:="="; send←out(str,2);
  end;
greater←or←equal: begin out←contrib[1]:=">"; out←contrib[2]:="=";
  send←out(str,2);
  end;
equivalence←sign: begin out←contrib[1]:="="; out←contrib[2]:="=";
  send←out(str,2);
  end;
double←dot: begin out←contrib[1]:="."; out←contrib[2]:="."; send←out(str,2);
  end;

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

If \.{TANGLE} is producing code for a \PASCAL\ compiler that uses `\.{(.}'
and `\.{.)}' instead of square brackets (e.g., on machines with {\mc EBCDIC}
code), one should remove |"["| and |"]"| from this list and put them into
the preceding module in the appropriate way. Similarly, some compilers
want `\.\↑' to be converted to `\.{@@}'.
@↑system dependencies@>@↑EBCDIC@>

@<Other printable characters@>=
"!","""","#","$","%","&","(",")","*",",","/",":",";","<","=",">","?",
"@@","[","\","]","↑","←","`","{","|"

@ Single-character identifiers represent themselves, while longer ones
appear in |byte←mem|. All must be converted to uppercase,
with underlines removed. Extremely long identifiers must be chopped.

(Some \PASCAL\ compilers work with lowercase letters instead of
uppercase. If this module of \.{TANGLE} is changed, it's also necessary
to change from uppercase to lowercase in the modules that are
listed in the index under ``uppercase''.)
@↑system dependencies@>
@↑uppercase@>

@d up←to(#)==#-24,#-23,#-22,#-21,#-20,#-19,#-18,#-17,#-16,#-15,#-14,
  #-13,#-12,#-11,#-10,#-9,#-8,#-7,#-6,#-5,#-4,#-3,#-2,#-1,#

@<Cases related to identifiers@>=
"A",up←to("Z"): begin out←contrib[1]:=cur←char; send←out(ident,1);
  end;
"a",up←to("z"): begin out←contrib[1]:=cur←char-@'40; send←out(ident,1);
  end;
identifier: begin k:=0; j:=byte←start[cur←val]; w:=cur←val mod ww;
  while (k<max←id←length)and(j<byte←start[cur←val+ww]) do
    begin incr(k); out←contrib[k]:=byte←mem[w,j]; incr(j);
    if out←contrib[k]>="a" then out←contrib[k]:=out←contrib[k]-@'40
    else if out←contrib[k]="←" then decr(k);
    end;
  send←out(ident,k);
  end;

@ 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);
out←contrib[k]:=get←output;
until (out←contrib[k]="'")or(stack←ptr=0);
if k=line←length then err←print('! String too long');
@.String too long@>
send←out(str,k); cur←char:=get←output;
if cur←char="'" then out←state:=unbreakable;
goto reswitch;
end

@ Sending a verbatim string is similar, but we don't have to look ahead.

@<Send verbatim string@>=
begin k:=0;
repeat if k<line←length then incr(k);
out←contrib[k]:=get←output;
until (out←contrib[k]=verbatim)or(stack←ptr=0);
if k=line←length then err←print('! Verbatim string too long');
@.Verbatim string too long@>
send←out(str,k-1);
end

@ In order to encourage portable software, \.{TANGLE} complains
if the constants get dangerously close to the largest value representable
on a 32-bit computer ($2↑{31}-1$).

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

@<Cases related to constants...@>=
digits: begin n:=0;
  repeat cur←char:=cur←char-"0";
  if n>=@'1463146314 then err←print('! Constant too big')
@.Constant too big@>
  else n:=10*n+cur←char;
  cur←char:=get←output;
  until (cur←char>"9")or(cur←char<"0");
  send←val(n); k:=0;
  if cur←char="e" then cur←char:="E";
@↑uppercase@>
  if cur←char="E" then goto get←fraction
  else goto reswitch;
  end;
check←sum: send←val(pool←check←sum);
octal: begin n:=0; cur←char:="0";
  repeat cur←char:=cur←char-"0";
  if n>=@'2000000000 then err←print('! Constant too big')
  else n:=8*n+cur←char;
  cur←char:=get←output;
  until (cur←char>"7")or(cur←char<"0");
  send←val(n); goto reswitch;
  end;
hex: begin n:=0; cur←char:="0";
  repeat if cur←char>="A" then cur←char:=cur←char+10-"A"
  else cur←char:=cur←char-"0";
  if n>=@"8000000 then err←print('! Constant too big')
  else n:=16*n+cur←char;
  cur←char:=get←output;
  until (cur←char>"F")or(cur←char<"0")or@|
    ((cur←char>"9")and(cur←char<"A"));
  send←val(n); goto reswitch;
  end;
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);
    end
  else if (cur←char>="0")and(cur←char<="9") then goto get←fraction
  else  begin send←out(misc,"."); goto reswitch;
    end;
  end;

@ 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")and((cur←char="+")or(cur←char="-")) then
@↑uppercase@>
  begin if k<line←length then incr(k);
  out←contrib[k]:=cur←char; cur←char:=get←output;
  end
else if cur←char="e" then cur←char:="E";
until (cur←char<>"E")and((cur←char<"0")or(cur←char>"9"));
if k=line←length then err←print('! Fraction too long');
@.Fraction too long@>
send←out(frac,k); goto reswitch

@ Some \PASCAL\ compilers do not recognize comments in braces, so the
comments must be delimited by `\.{(*}' and `\.{*)}'.
@↑system dependencies@>
In such cases the statement `|send←out(misc,"{")|' that appears here should
be replaced by `\ignorespaces|begin out←contrib[1]:="("; out←contrib[2]:="*";
send←out(str,2); end|', and a similar change should be made to
`|send←out(misc,"}")|'.

@<Cases involving \.{@@\{} and \.{@@\}}@>=
begin←comment: begin if brace←level=0 then send←out(misc,"{")
  else send←out(misc,"[");
  incr(brace←level);
  end;
end←comment: if brace←level>0 then
    begin decr(brace←level);
    if brace←level=0 then send←out(misc,"}")
    else send←out(misc,"]");
    end
  else err←print('! Extra @@}');
@.Extra \AT!\}@>
module←number: begin if brace←level=0 then send←out(misc,"{")
  else send←out(misc,"[");
  if cur←val<0 then
    begin send←out(misc,":"); send←val(-cur←val);
    end
  else  begin send←val(cur←val); send←out(misc,":");
    end;
  if brace←level=0 then send←out(misc,"}")
  else send←out(misc,"]");
  end;

@ @<Force a line break@>=
begin send←out(str,0); {normalize the buffer}
while out←ptr>0 do
  begin if out←ptr<=line←length then break←ptr:=out←ptr;
  flush←buffer;
  end;
out←state:=misc;
end

@* Introduction to the input phase.
We have now seen that \.{TANGLE} 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 \.{WEB} 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 |get←line|
that takes care of merging |change←file| into |web←file|. The |get←line|
procedure also updates the line numbers for error messages.

@<Globals...@>=
@!line:integer; {the number of the current line in the current file}
@!other←line:integer; {the number of the current line in the input file that
  is not currently being read}
@!temp←line:integer; {used when interchanging |line| with |other←line|}
@!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}
@!changing: boolean; {if |true|, the current line is from |change←file|}

@ As we change |changing| from |true| to |false| and back again, we must
remember to swap the values of |line| and |other←line| so that the |err←print|
routine will be sure to report the correct line number.

@d change←changing==
  changing := not changing;
  temp←line:=other←line; other←line:=line; line:=temp←line
    {|line @t$\null\BA\null$@> other←line|}

@ When |changing| is |false|, the next line of |change←file| is kept in
|change←buffer[0..change←limit]|, for purposes of comparison with the next
line of |web←file|. After the change file has been completely input, we
set |change←limit:=0|, so that no further matches will be made.

@<Globals...@>=
@!change←buffer:array[0..buf←size] of ASCII←code;
@!change←limit:0..buf←size; {the last position occupied in |change←buffer|}

@ Here's a simple function that checks if the two buffers are different.

@p function lines←dont←match:boolean;
label exit;
var k:0..buf←size; {index into the buffers}
begin lines←dont←match:=true;
if change←limit<>limit then return;
if limit>0 then
  for k:=0 to limit-1 do if change←buffer[k]<>buffer[k] then return;
lines←dont←match:=false;
exit: end;

@ Procedure |prime←the←change←buffer| sets |change←buffer| in preparation
for the next matching operation. Since blank lines in the change file are
not used for matching, we have |(change←limit=0)and not changing| if and
only if the change file is exhausted. This procedure is called only
when |changing| is true; hence error messages will be reported correctly.

@p procedure prime←the←change←buffer;
label continue, done, exit;
var k:0..buf←size; {index into the buffers}
begin change←limit:=0; {this value will be used if the change file ends}
@<Skip over comment lines in the change file; |return| if end of file@>;
@<Skip to the next nonblank line; |return| if end of file@>;
@<Move |buffer| and |limit| to |change←buffer| and |change←limit|@>;
exit: end;

@ While looking for a line that begins with \.{@@x} in the change file,
we allow lines that begin with \.{@@}, as long as they don't begin with
\.{@@y} or \.{@@z} (which would probably indicate that the change file is
fouled up).

@<Skip over comment lines in the change file...@>=
loop@+  begin incr(line);
  if not input←ln(change←file) then return;
  if limit<2 then goto continue;
  if buffer[0]<>"@@" then goto continue;
  if (buffer[1]>="X")and(buffer[1]<="Z") then
    buffer[1]:=buffer[1]+"z"-"Z"; {lowercasify}
  if buffer[1]="x" then goto done;
  if (buffer[1]="y")or(buffer[1]="z") then
    begin loc:=2; err←print('! Where is the matching @@x?');
@.Where is the match...@>
    end;
continue: end;
done:

@ Here we are looking at lines following the \.{@@x}.

@<Skip to the next nonblank line...@>=
repeat incr(line);
  if not input←ln(change←file) then
    begin err←print('! Change file ended after @@x');
@.Change file ended...@>
    return;
    end;
until limit>0;

@ @<Move |buffer| and |limit| to |change←buffer| and |change←limit|@>=
begin change←limit:=limit;
for k:=0 to limit do change←buffer[k]:=buffer[k];
end

@ The following procedure is used to see if the next change entry should
go into effect; it is called only when |changing| is false.
The idea is to test whether or not the current
contents of |buffer| matches the current contents of |change←buffer|.
If not, there's nothing more to do; but if so, a change is called for:
All of the text down to the \.{@@y} is supposed to match. An error
message is issued if any discrepancy is found. Then the procedure
prepares to read the next line from |change←file|.

@p procedure check←change; {switches to |change←file| if the buffers match}
label exit;
var n:integer; {the number of discrepancies found}
@!k:0..buf←size; {index into the buffers}
begin if lines←dont←match then return;
n:=0;
loop@+  begin change←changing; {now it's |true|}
  incr(line);
  if not input←ln(change←file) then
    begin err←print('! Change file ended before @@y');
@.Change file ended...@>
    change←limit:=0;  change←changing; {|false| again}
    return;
    end;
  @<If the current line starts with \.{@@y},
    report any discrepancies and |return|@>;
  @<Move |buffer| and |limit|...@>;
  change←changing; {now it's |false|}
  incr(line);
  if not input←ln(web←file) then
    begin err←print('! WEB file ended during a change');
@.WEB file ended...@>
    input←has←ended:=true; return;
    end;
  if lines←dont←match then incr(n);
  end;
exit: end;

@ @<If the current line starts with \.{@@y}...@>=
if limit>1 then if buffer[0]="@@" then
  begin if (buffer[1]>="X")and(buffer[1]<="Z") then
    buffer[1]:=buffer[1]+"z"-"Z"; {lowercasify}
  if (buffer[1]="x")or(buffer[1]="z") then
    begin loc:=2; err←print('! Where is the matching @@y?');
@.Where is the match...@>
    end
  else if buffer[1]="y" then
    begin if n>0 then
      begin loc:=2; err←print('! Hmm... ',n:1,
        ' of the preceding lines failed to match');
@.Hmm... n of the preceding...@>
      end;
    return;
    end;
  end

@ @<Initialize the input system@>=
open←input; line:=0; other←line:=0;@/
changing:=true; prime←the←change←buffer; change←changing;@/
limit:=0; loc:=1; buffer[0]:=" "; input←has←ended:=false;

@ The |get←line| procedure is called when |loc>limit|; it puts the next
line of merged input into the buffer and updates the other variables
appropriately. A space is placed at the right end of the line.

@p procedure get←line; {inputs the next line}
label restart;
begin restart: if changing then
  @<Read from |change←file| and maybe turn off |changing|@>;
if not changing then
  begin @<Read from |web←file| and maybe turn on |changing|@>;
  if changing then goto restart;
  end;
loc:=0; buffer[limit]:=" ";
end;

@ @<Read from |web←file|...@>=
begin incr(line);
if not input←ln(web←file) then input←has←ended:=true
else if limit=change←limit then
  if buffer[0]=change←buffer[0] then
    if change←limit>0 then check←change;
end

@ @<Read from |change←file|...@>=
begin incr(line);
if not input←ln(change←file) then
  begin err←print('! Change file ended without @@z');
@.Change file ended...@>
  buffer[0]:="@@"; buffer[1]:="z"; limit:=2;
  end;
if limit>1 then {check if the change has ended}
  if buffer[0]="@@" then
    begin if (buffer[1]>="X")and(buffer[1]<="Z") then
      buffer[1]:=buffer[1]+"z"-"Z"; {lowercasify}
    if (buffer[1]="x")or(buffer[1]="y") then
      begin loc:=2; err←print('! Where is the matching @@z?');
@.Where is the match...@>
      end
    else if buffer[1]="z" then
      begin prime←the←change←buffer; change←changing;
      end;
    end;
end

@ At the end of the program, we will tell the user if the change file
had a line that didn't match any relevant line in |web←file|.

@<Check that all changes have been read@>=
if change←limit<>0 then {|changing| is false}
  begin for loc:=0 to change←limit do buffer[loc]:=change←buffer[loc];
  limit:=change←limit; changing:=true; line:=other←line; loc:=change←limit;
  err←print('! Change file entry did not match');
@.Change file entry did not match@>
  end

@ Important milestones are reached during the input phase when certain
control codes are sensed.

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

@d ignore=0 {control code of no interest to \.{TANGLE}}
@d control←text=@'203 {control code for `\.{@@t}', `\.{@@\↑}', etc.}
@d format=@'204 {control code for `\.{@@f}'}
@d definition=@'205 {control code for `\.{@@d}'}
@d begin←Pascal=@'206 {control code for `\.{@@p}'}
@d module←name=@'207 {control code for `\.{@@<}'}
@d new←module=@'210 {control code for `\.{@@\ }' and `\.{@@*}'}

@p function control←code(@!c:ASCII←code):eight←bits; {convert |c| after \.{@@}}
begin case c of
"@@": control←code:="@@"; {`quoted' at sign}
"'": control←code:=octal; {precedes octal constant}
"""": control←code:=hex; {precedes hexadecimal constant}
"$": control←code:=check←sum; {string pool check sum}
" ",tab←mark: control←code:=new←module; {beginning of a new module}
"*": begin print('*',module←count+1:1);
  update←terminal; {print a progress report}
  control←code:=new←module; {beginning of a new module}
  end;
"D","d": control←code:=definition; {macro definition}
"F","f": control←code:=format; {format definition}
"{": control←code:=begin←comment; {begin-comment delimiter}
"}": control←code:=end←comment; {end-comment delimiter}
"P","p": control←code:=begin←Pascal; {\PASCAL\ text in unnamed module}
"T","t","↑",".",":": control←code:=control←text; {control text to be ignored}
"&": control←code:=join; {concatenate two tokens}
"<": control←code:=module←name; {beginning of a module name}
"=": control←code:=verbatim; {beginning of \PASCAL\ verbatim mode}
"\": control←code:=force←line; {force a new line in \PASCAL\ output}
othercases control←code:=ignore {ignore all other cases}
endcases;
end;

@ 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 input←has←ended then
      begin c:=new←module; goto done;
      end;
    end;
  buffer[limit+1]:="@@";
  while buffer[loc]<>"@@" do incr(loc);
  if loc<=limit then
    begin loc:=loc+2; c:=control←code(buffer[loc-1]);
    if (c<>ignore)or(buffer[loc-1]=">") then goto done;
    end;
  end;
done: skip←ahead:=c;
end;

@ The |skip←comment| procedure reads through the input at somewhat high speed
until finding the first unmatched right brace or until coming to the end
of the file. 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 \.{WEB} file.

@p procedure skip←comment; {skips to next unmatched `\.\}'}
label exit;
var bal:eight←bits; {excess of left braces}
@!c:ASCII←code; {current character}
begin bal:=0;
loop@+  begin if loc>limit then
    begin get←line;
    if input←has←ended then
      begin err←print('! Input ended in mid-comment');
@.Input ended in mid-comment@>
      return;
      end;
    end;
  c:=buffer[loc]; incr(loc);
  @<Do special things when |c="@@", "\", "{", "}"|; |return| at end@>;
  end;
exit:end;

@ @<Do special things when |c="@@"...@>=
if c="@@" then
  begin c:=buffer[loc];
  if (c<>" ")and(c<>tab←mark)and(c<>"*")and(c<>"z")and(c<>"Z") then incr(loc)
  else  begin err←print('! Section ended in mid-comment');
@.Section ended in mid-comment@>
    decr(loc); return;
    end
  end
else if (c="\")and(buffer[loc]<>"@@") then incr(loc)
else if c="{" then incr(bal)
else if c="}" then
  begin if bal=0 then return;
  decr(bal);
  end

@* Inputting the next token.
As stated above, \.{TANGLE}'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.

Another global variable, |scanning←hex|, is |true| during the time that
the letters \.A through \.F should be treated as if they were digits.

@<Globals...@>=
@!cur←module: name←pointer; {name of module just scanned}
@!scanning←hex: boolean; {are we scanning a hexadecimal constant?}

@ @<Set init...@>=
scanning←hex:=false;

@ At the top level, |get←next| is a multi-way switch based on the next
character in the input buffer. A |new←module| code is inserted at the
very end of the input file.

@p function get←next:eight←bits; {produces the next input token}
label restart,done,found;
var c:eight←bits; {the current character}
@!d:eight←bits; {the next character}
@!j,@!k:0..longest←name; {indices into |mod←text|}
begin restart: if loc>limit then
  begin get←line;
  if input←has←ended then
    begin c:=new←module; goto found;
    end;
  end;
c:=buffer[loc]; incr(loc);
if scanning←hex then @<Go to |found| if |c| is a hexadecimal digit,
  otherwise set |scanning←hex:=false|@>;
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@>;
@t\4@>@<Compress two-symbol combinations like `\.{:=}'@>@;
" ",tab←mark: goto restart; {ignore spaces and tabs}
"{": begin skip←comment; goto restart;
  end;
othercases do←nothing
endcases;
found:@!debug if trouble←shooting then debug←help;@;@+gubed@/
get←next:=c;
end;

@ @<Go to |found| if |c| is a hexadecimal digit...@>=
if ((c>="0")and(c<="9"))or((c>="A")and(c<="F")) then goto found
else scanning←hex:=false

@ 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 if loc<=limit then begin c:=#; incr(loc); end; end

@<Compress two-symbol...@>=
".": if buffer[loc]="." then compress(double←dot)
  else if buffer[loc]=")" then compress("]");
":": if buffer[loc]="=" then compress(left←arrow);
"=": 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(not←equal);
"(": if buffer[loc]="*" then compress(begin←comment)
  else if buffer[loc]="." then compress("[");
"*": if buffer[loc]=")" then compress(end←comment);

@ We have to look at the preceding character to make sure this isn't part
of a real constant, before trying to find an identifier starting with
`\.e' or `\.E'.

@<Get an identifier@>=
begin if ((c="e")or(c="E"))and(loc>1) then
  if (buffer[loc-2]<="9")and(buffer[loc-2]>="0") then c:=0;
if c<>0 then
  begin decr(loc); id←first:=loc;
  repeat incr(loc); d:=buffer[loc];
  until ((d<"0")or((d>"9")and(d<"A"))or((d>"Z")and(d<"a"))or(d>"z")) and
    (d<>"←");
  if loc>id←first+1 then
    begin c:=identifier; id←loc:=loc;
    end;
  end
else c:="E"; {exponent of a real constant}
end

@ 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.
@↑preprocessed strings@>

@<Get a preprocessed string@>=
begin double←chars:=0; id←first:=loc-1;
repeat d:=buffer[loc]; incr(loc);
  if (d="""")or(d="@@") then
    if buffer[loc]=d then
      begin incr(loc); d:=0; incr(double←chars);
      end
    else  begin if d="@@" then err←print('! Double @@ sign missing')
@.Double \AT! sign missing@>
      end
  else if loc>limit then
    begin err←print('! String constant didn''t end'); d:="""";
@.String constant didn't end@>
    end;
until d="""";
id←loc:=loc-1; c:=identifier;
end

@ After an \.{@@} sign has been scanned, the next character tells us
whether there is more work to do.

@<Get control code and possible module name@>=
begin c:=control←code(buffer[loc]); incr(loc);
if c=ignore then goto restart
else if c=hex then scanning←hex:=true
else if c=module←name then
  @<Scan the \(module name and make |cur←module| point to it@>
else if c=control←text then
  begin repeat c:=skip←ahead;
  until c<>"@@";
  if buffer[loc-1]<>">" then
    err←print('! Improper @@ within control text');
@.Improper \AT! within control text@>
  goto restart;
  end;
end

@ @<Scan the \(module name...@>=
begin @<Put module name into |mod←text[1..k]|@>;
if k>3 then
  begin if (mod←text[k]=".")and(mod←text[k-1]=".")and(mod←text[k-2]=".") then
    cur←module:=prefix←lookup(k-3)
  else cur←module:=mod←lookup(k);
  end
else cur←module:=mod←lookup(k);
end

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

@<Set init...@>=mod←text[0]:=" ";

@ @<Put module name...@>=
k:=0;
loop@+  begin if loc>limit then
    begin get←line;
    if input←has←ended then
      begin err←print('! Input ended in section name');
@.Input ended in section name@>
      goto done;
      end;
    end;
  d:=buffer[loc];
  @<If end of name, |goto done|@>;
  incr(loc); if k<longest←name-1 then incr(k);
  if (d=" ")or(d=tab←mark) then
    begin d:=" "; if mod←text[k-1]=" " then decr(k);
    end;
  mod←text[k]:=d;
  end;
done: @<Check for overlong name@>;
if (mod←text[k]=" ")and(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;
    end;
  if (d=" ")or(d=tab←mark)or(d="*") then
    begin err←print('! Section name didn''t end'); goto done;
@.Section name didn't end@>
    end;
  incr(k); mod←text[k]:="@@"; incr(loc); {now |d=buffer[loc]| again}
  end

@ @<Check for overlong name@>=
if k>=longest←name-2 then
  begin print←nl('! Section name too long: ');
@.Section name too long@>
  for j:=1 to 25 do print(xchr[mod←text[j]]);
  print('...'); mark←harmless;
  end

@* Scanning a numeric definition.
When \.{TANGLE} 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|, and |new←module|, 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?}

@<Global...@>=
@!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 by
|next←sign| and added to the |accumulator|, then |next←sign| is reset to $+1$.

@d add←in(#)==begin accumulator:=accumulator+next←sign*(#); next←sign:=+1;
  end

@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}
begin @<Set \(|accumulator| to the value of the right-hand side@>;
if abs(accumulator)>=@'100000 then
  begin err←print('! Value too big: ',accumulator:1); accumulator:=0;
@.Value too big@>
  end;
equiv[p]:=accumulator+@'100000; {name |p| now is defined to equal |accumulator|}
end;

@ @<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;
    end;
  octal: begin @<Set |val| to value of octal constant, and
      set |next←control| to the following token@>;
    add←in(val); goto reswitch;
    end;
  hex: begin @<Set |val| to value of hexadecimal constant, and
      set |next←control| to the following token@>;
    add←in(val); goto reswitch;
    end;
  identifier: begin q:=id←lookup(normal);
    if ilk[q]<>numeric then
      begin next←control:="*"; goto reswitch; {leads to error}
      end;
    add←in(equiv[q]-@'100000);
    end;
  "+": do←nothing;
  "-": next←sign:=-next←sign;
  format, definition, module←name, begin←Pascal, new←module: goto done;
  ";": err←print('! Omit semicolon in numeric definition');
@.Omit semicolon in numeric def...@>
  othercases @<Signal error, flush rest of the definition@>
  endcases;
  end;
done:

@ @<Signal error, flush rest...@>=
begin err←print('! Improper numeric definition will be flushed');
@.Improper numeric definition...@>
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;
  end;
accumulator:=0; goto done;
end

@ @<Set |val| to value of decimal...@>=
val:=0;
repeat val:=10*val+next←control-"0"; next←control:=get←next;
until (next←control>"9")or(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")or(next←control<"0")

@ @<Set |val| to value of hex...@>=
val:=0; next←control:="0";
repeat if next←control>="A" then next←control:=next←control+"0"+10-"A";
val:=16*val+next←control-"0"; next←control:=get←next;
until (next←control>"F")or(next←control<"0")or@|
  ((next←control>"9")and(next←control<"A"))

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

@<Globals...@>=
@!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 )')
@.Extra )@>
    else decr(bal);
  "'": @<Copy a string from the buffer to |tok←mem|@>;
  "#": if t=parametric then a:=param;
  @t\4@>@<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
  endcases;@/
  app←repl(a); {store |a| in |tok←mem|}
  end;
done: next←control:=a;
@<Make sure the parentheses balance@>;
if text←ptr>max←texts-zz then overflow('text');
cur←repl←text:=text←ptr; tok←start[text←ptr+zz]:=tok←ptr[z];
incr(text←ptr);
if z=zz-1 then z:=0@+else incr(z);
end;

@ @<Make sure the parentheses balance@>=
if bal>0 then
  begin if bal=1 then err←print('! Missing )')
  else err←print('! Missing ',bal:1,' )''s');
@.Missing n )@>
  while bal>0 do
    begin app←repl(")"); decr(bal);
    end;
  end

@ @<In cases that |a| is...@>=
identifier: begin a:=id←lookup(normal); app←repl((a div @'400)+@'200);
  a:=a mod @'400;
  end;
module←name: if t<>module←name then goto done
  else  begin app←repl((cur←module div @'400)+@'250);
    a:=cur←module mod @'400;
    end;
verbatim: @<Copy verbatim string from the buffer to |tok←mem|@>;
definition, format, begin←Pascal: if t<>module←name then goto done
  else  begin err←print('! @@',xchr[buffer[loc-1]],
@.\AT!p is ignored in Pascal text@>
@.\AT!d is ignored in Pascal text@>
@.\AT!f is ignored in Pascal text@>
      ' is ignored in Pascal text'); goto continue;
    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');
@.You should double \AT! signs@>
  if loc=limit then
    begin err←print('! String didn''t end');
@.String didn't end@>
    buffer[loc]:="'"; buffer[loc+1]:=0;
    end;
  b:=buffer[loc]; incr(loc);
  if b="'" then
    begin if buffer[loc]<>"'" then goto found
    else  begin incr(loc); app←repl("'");
      end;
    end;
  end;
found: end {now |a| holds the final |"'"| that will be stored}

@ @<Copy verbatim string...@>=
begin app←repl(verbatim);
buffer[limit+1]:="@@";
while buffer[loc]<>"@@" do
  begin app←repl(buffer[loc]);
  incr(loc);
  if loc<limit then
    if (buffer[loc]="@@") and (buffer[loc+1]="@@") then
      begin app←repl("@@");
      loc:=loc+2;
      end;
  end;
if loc>=limit then err←print('! Verbatim string didn''t end')
@.Verbatim string didn't end@>
else if buffer[loc+1]<>">" then
  err←print('! You should double @@ signs in verbatim strings');
@.You should double \AT! signs@>
loc:=loc+2;
end {another |verbatim| byte will be stored, since |a=verbatim|}

@ 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;
end;

@* Scanning a module.
The |scan←module| procedure starts when `\.{@@\ }' or `\.{@@*}' has been
sensed in the input, and it proceeds until the end of that module.  It
uses |module←count| to keep track of the current module number; with luck,
\.{WEAVE} and \.{TANGLE} will both assign the same numbers to modules.

@<Globals...@>=
@!module←count:0..@'27777; {the current module number}

@ The top level of |scan←module| is trivial.
@p procedure scan←module;
label continue, 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...@>=
next←control:=0;
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;
      end;
    end;
  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 ',
@.Definition flushed...@>
      'identifier of length > 1'); goto continue;
    end;
  next←control:=get←next; {get token after the identifier}
  if next←control="=" then
    begin scan←numeric(id←lookup(numeric)); goto continue;
    end
  else if next←control=equivalence←sign then
    begin define←macro(simple); goto continue;
    end
  else @<If the next text is `|(#)==|', call |define←macro|
    and |goto continue|@>;
  err←print('! Definition flushed since it starts badly');
@.Definition flushed...@>
  end;
done:

@ @<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');
@.Use == for macros@>
        next←control:=equivalence←sign;
        end;
      if next←control=equivalence←sign then
        begin define←macro(parametric); goto continue;
        end;
      end;
    end;
  end;

@ @<Scan the \PASCAL...@>=
case next←control of
begin←Pascal:p:=0;
module←name: begin p:=cur←module;
  @<Check that |=| or |==| follows this module name, otherwise |return|@>;
  end;
othercases return
endcases;@/
@<Insert the module number into |tok←mem|@>;
scan←repl(module←name); {now |cur←repl←text| 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<>"=")and(next←control<>equivalence←sign) then
  begin err←print('! Pascal text flushed, = sign is missing');
@.Pascal text flushed...@>
  repeat next←control:=skip←ahead;
  until next←control=new←module;
  return;
  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;
  end
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[p]:=cur←repl←text;
  end;
text←link[cur←repl←text]:=module←flag;
  {mark this replacement text as a nonmacro}

@* Debugging.
The \PASCAL\ debugger with which \.{TANGLE} 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 each phase 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, at the
place of `\ignorespaces|breakpoint:|\unskip' below.  Then when
|debug←help| is to be activated, set |trouble←shooting| equal to |true|.
The |debug←help| routine will prompt you for values of |ddt| and |dd|,
discontinuing this when |ddt<=0|; thus you type $2n+1$ integers, ending
with zero or a negative number. Then control either passes to the
breakpoint, allowing you to look at and/or change variables (if you typed
zero), or to exit the routine (if you typed a negative value).

Another global variable, |debug←cycle|, can be used to skip silently
past calls on |debug←help|. If you set |debug←cycle>1|, the program stops
only every |debug←cycle| times |debug←help| is called; however,
any error stop will set |debug←cycle| to zero.

@<Globals...@>=
@!debug@!trouble←shooting:boolean; {is |debug←help| wanted?}
@!ddt:integer; {operation code for the |debug←help| routine}
@!dd:integer; {operand in procedures performed by |debug←help|}
@!debug←cycle:integer; {threshold for |debug←help| stopping}
@!debug←skipped:integer; {we have skipped this many |debug←help| calls}
@!term←in:text←file; {the user's terminal as an input file}
gubed

@ The debugging routine needs to read from the user's terminal.
@↑system dependencies@>
@<Set init...@>=
@!debug trouble←shooting:=true; debug←cycle:=1; debug←skipped:=0;@/
trouble←shooting:=false; debug←cycle:=99999; {use these when it almost works}
reset(term←in,'TTY:','/I'); {open |term←in| as the terminal, don't do a |get|}
gubed

@ @d breakpoint=888 {place where a breakpoint is desirable}
@↑system dependencies@>

@p @!debug procedure debug←help; {routine to display various things}
label breakpoint,exit;
var k:integer; {index into various arrays}
begin incr(debug←skipped);
if debug←skipped<debug←cycle then return;
debug←skipped:=0;
loop@+  begin write(term←out,'#'); update←terminal; {prompt}
  read(term←in,ddt); {read a list of integers}
  if ddt<0 then return
  else if ddt=0 then
    begin goto breakpoint;@\ {go to every label at least once}
    breakpoint: ddt:=0;@\
    end
  else  begin read(term←in,dd);
    case ddt of
    1: print←id(dd);
    2: print←repl(dd);
    3: for k:=1 to dd do print(xchr[buffer[k]]);
    4: for k:=1 to dd do print(xchr[mod←text[k]]);
    5: for k:=1 to out←ptr do print(xchr[out←buf[k]]);
    6: for k:=1 to dd do print(xchr[out←contrib[k]]);
    othercases print('?')
    endcases;
    end;
  end;
exit:end;
gubed

@* 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 \.{TANGLE} starts, and where
it ends.
@↑system dependencies@>

@p begin initialize;
@<Initialize the input system@>;
print←ln(banner); {print a ``banner line''}
@<Phase I: Read all the user's text and compress it into |tok←mem|@>;
stat for zo:=0 to zz-1 do max←tok←ptr[zo]:=tok←ptr[zo];@+tats@;@/
@<Phase II:...@>;
end←of←TANGLE:
if string←ptr>128 then @<Finish off the string pool file@>;
stat @<Print statistics about memory usage@>;@+tats@;@/
@t\4\4@>{here files should be closed if the operating system requires it}
@<Print the job |history|@>;
end.

@ @<Phase I:...@>=
phase←one:=true;
module←count:=0;
repeat next←control:=skip←ahead;
until next←control=new←module;
while not input←has←ended do scan←module;
@<Check that all changes have been read@>;
phase←one:=false;

@ @<Finish off the string pool file@>=
begin print←nl(string←ptr-128:1, ' strings written to string pool file.');
write(pool,'*');
for string←ptr:=1 to 9 do
  begin out←buf[string←ptr]:=pool←check←sum mod 10;
  pool←check←sum:=pool←check←sum div 10;
  end;
for string←ptr:=9 downto 1 do write(pool,xchr["0"+out←buf[string←ptr]]);
write←ln(pool);
end

@ @<Glob...@>=
stat @!wo:0..ww-1; {segment of memory for which statistics are being printed}
tats

@ @<Print statistics about memory usage@>=
print←nl('Memory usage statistics:');
print←nl(name←ptr:1, ' names, ', text←ptr:1, ' replacement texts;');
print←nl(byte←ptr[0]:1);
for wo:=1 to ww-1 do print('+',byte←ptr[wo]:1);
print(' bytes, ', max←tok←ptr[0]:1);
for zo:=1 to zz-1 do print('+',max←tok←ptr[zo]:1);
print(' tokens.');

@ Some implementations may wish to pass the |history| value to the
operating system so that it can be used to govern whether or not other
programs are started. Here we simply report the history to the user.
@↑system dependencies@>

@<Print the job |history|@>=
case history of
spotless: print←nl('(No errors were found.)');
harmless←message: print←nl('(Did you see the warning message above?)');
error←message: print←nl('(Pardon me, but I think I spotted something wrong.)');
fatal←message: print←nl('(That was a fatal error, my friend.)');
end {there are no other cases}

@* System-dependent changes.
This module should be replaced, if necessary, by changes to the program
that are necessary to make \.{TANGLE} work at a particular installation.
It is usually best to design your change file so that all changes to
previous modules preserve the module numbering; then everybody's version
will be consistent with the printed program. More extensive changes,
which introduce new modules, can be inserted here; then only the index
itself will get a new module number.
@↑system dependencies@>

@* Index.
Here is a cross-reference table for the \.{TANGLE} processor.
All modules in which an identifier is
used are listed with that identifier, except that reserved words are
indexed only when they appear in format definitions, and the appearances
of identifiers in module names are not indexed. Underlined entries
correspond to where the identifier was declared. Error messages and
a few other things like ``ASCII code'' are indexed here too.