% This program by E. W. Sewell, based on one by D. E. Knuth, is
%             not copyrighted and can be used freely.

% Version 1.0 was released in March 1987

% Here is TeX material that gets inserted after \input webmac
\def\hang{\hangindent 3em\indent\ignorespaces}
\font\ninerm=cmr9
\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{WEBMERGE}
\def\contentspagenumber{1} % should be odd
\def\topofcontents{\null\vfill
  \centerline{\titlefont The {\ttitlefont WEBMERGE} processor}
  \vskip 15pt
  \centerline{(Version 1.0)}
  \vfill}
\pageno=\contentspagenumber \advance\pageno by 1

@* Introduction.
This program takes a \.{WEB} file and merges multiple change files into it,
creating a new \.{WEB} file and a composite change file.
If it bears an uncanny resemblance to Donald Knuth's \.{TANGLE},
this is no accident, since
it was cloned from \.{TANGLE}. While \.{WEBMERGE} was developed on a VAX
system using VAX Pascal, rather than the Stanford system on which \.{TANGLE}
was developed, the system dependencies of the latter were used in \.{WEBMERGE}
so the modifications to implement it on a particular system are almost exactly
the same as for \.{TANGLE} and \.{WEAVE}.

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 \.{WEBMERGE} 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 \.{WEBMERGE}
is modified.

@d banner=='This is WEBMERGE, Version 1.0'

@ 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| (which is implemented as an array of files),
the web output goes to file |out_web_file|,
and the composite change file output goes to file |out_change_file|.

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

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

@p @t\4@>@<Compiler directives@>@/
program WEBMERGE(@!web_file,@!out_web_file,@!out_change_file);
label end_of_WEBMERGE; {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 \.{WEBMERGE}'s line counts 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 \.{WEBMERGE} 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 original
author of \.{TANGLE} (Knuth)
would have taken the trouble to modify it 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 constants need to be defined.
@<Constants...@>=
@!buf_size=1000; {maximum length of input line}
@!max_change_files=6; {number of simultaneous change files }
@!out_buf_size=144; {length of output buffer, should be twice |line_length|}
@ We use the constant |max_change_files| to define a valid range of change
file numbers.
@<Types...@>=
@!range_of_change_files = 1..max_change_files;

@ 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}
(and \.{WEBMERGE}!) 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}, \.{TANGLE} and \.{WEBMERGE} 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}, \.{TANGLE} and \.{WEBMERGE} 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 \.{WEBMERGE} 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}, \.{TANGLE} and \.{WEBMERGE} because they are used with a special meaning.

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

@ 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 \.{WEBMERGE.WEB} does not contain any of the non-ASCII
characters, because it is intended to be used with all implementations of
\.{WEB}.  It is based on \.{TANGLE}, which 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 \.{TANGLE} and \.{WEAVE}.
Therefore people who need to make modifications to all four systems
should be able to do so without too many headaches.


@ 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}
@!term_in:text_file; {the user's terminal as an input 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}
reset(term_in,'TTY:','/I'); {open |term_in| as the terminal, don't do a |get|}

@ 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| and is overridden
by changes in |change_file|, which is implemented as an array of files.

@d change_file==change_files[active_change_file]
@d changing== (active_change_file > 0)
@<Globals...@>=
@!web_file:text_file; {primary input}
@!change_files:array [range_of_change_files] of text_file; {updates}
@!out_web_file, out_change_file : text_file; { output files }
@!active_change_file : 0..max_change_files;
       { |range_of_change_files| plus 0 to indicate no change file }
@!last_active_change_file , @!number_of_actual_change_files : range_of_change_files;

@ The following code opens the fixed input and output 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 write to
|out_web_file| and |out_change_file|}
begin reset(web_file); rewrite(out_web_file); rewrite(out_change_file);
end;


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

@ The |output_ln| procedure writes the next line of output from the |buffer|
array to the specified file.

@p procedure output_ln(var f:text_file);
  {outputs a line }
var @!ch : char; { current output character }
   @!temp : 0..buf_size;
begin
  if limit > 0 then begin
    for temp := 0 to limit - 1 do begin
      ch := xchr[buffer[temp]];
      f^ := ch;
      put(f);
    end;
  end;
  write_ln(f);
end ;

@* Reporting errors to the user.

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.


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 @<Print error location@>;
update_terminal; mark_error;
end;

@ The error locations 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 one of the instances of |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@>=
begin if changing then print('. (change file ',active_change_file:1,' ')@+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}
new_line; {this separates the message from future asterisks}
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 \.{WEBMERGE}. 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_WEBMERGE| 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_WEBMERGE;
end;






@* Change file handling.



@d change_line==ch_line_array[active_change_file]
@<Globals...@>=
@!line:integer; {the number of the current line in the current file}
@!web_line:integer; {the number of the current line in the main web file }
@!out_web_line:integer; { the number of the line in the output web file }
@!out_ch_line:integer; {the number of the line in the output change file }
@!ch_line_array: array [range_of_change_files] of integer;
{the number of the current line the the various change files}
@!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}

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

@d change_changing==
  if changing then begin
 last_active_change_file := active_change_file;
 change_line := line;
 active_change_file := 0; line := web_line;
 end
    else begin
   active_change_file := last_active_change_file ;
   web_line := line; line := change_line;
  end;

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

@d change_buffer==ch_buffer_array[active_change_file]
@d change_limit==ch_limit_array[active_change_file]
@d change_file_is_open==ch_flag_array[active_change_file]
@d terminate_change_file==
              change_file_is_open := false;
{here change file should be closed if the operating system requires it}
@d output_change_line==begin output_ln(out_change_file);incr(out_ch_line); end
@<Globals...@>=
@!ch_buffer_array:array [range_of_change_files] of array[0..buf_size]
of ASCII_code;
@!ch_limit_array:array [range_of_change_files] of 0..buf_size; {the
last position occupied in |change_buffer|}
@!ch_flag_array:array [range_of_change_files] of boolean;
{flags indicating change file is still open}

@ 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) or (not change_file_is_open) 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. Blank lines in the change file are
not used for matching. 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(change_line);
  if not input_ln(change_file) then begin terminate_change_file;return; end;
  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(change_line);
  if not input_ln(change_file) then
    begin err_print('! Change file ended after @@x');
@.Change file ended...@>
  terminate_change_file;return;
    end;
until limit>0;

@ @<Move |buffer| and |limit| to |change_buffer| and |change_limit|@>=
begin change_limit:=limit;
if limit>0 then for k:=0 to limit-1 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,done;
var n:integer; {the number of discrepancies found}
@!k:0..buf_size; {index into the buffers}
@!none_match:boolean; {none of the change files match}
@!temp_index : integer;
@!prev_history: spotless..fatal_message; {previous value of |history|}
@!flush_needed:array [range_of_change_files] of boolean;
begin
@<Determine if the web file line matches any of the change files@>;
if none_match then return;
n:=0;
@<Write \.{@@x} to the output change file@>;
loop@+
  begin
  @<Flush any other change files which also match the current line@>;
  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;
  change_changing; {now it's |true|}
  if lines_dont_match then incr(n)
  else output_change_line;
  change_changing; {now it's |false|}
  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 output_change_line; 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; @/
@<Open the input change files@>;
limit:=0; loc:=1; buffer[0]:=" "; input_has_ended:=false;

@ If any other change files match the same line as the currently active change
file, they must be flushed, since \.{WEBMERGE} does not allow
overlapping change files. We make two passes through the list of change files
because the call to |prime_the_change_buffer| if a flush occurs will modify
|buffer| and interfere with further comparisons.
@d this_line_matches==(not lines_dont_match)
@<Flush any other change files which also match the current line@>=
   for active_change_file := 1 to number_of_actual_change_files do begin
      flush_needed[active_change_file] :=
       (active_change_file <> last_active_change_file)
   and this_line_matches ;
      if flush_needed[active_change_file] then begin
            prev_history := history;
            err_print('overlapping change files --- ',last_active_change_file:1,
              ' and ',active_change_file:1,' --- ',
    active_change_file:1,
    ' flushed');
            history := prev_history;
            mark_harmless;
            end;
      end;
   for active_change_file := 1 to number_of_actual_change_files do
      if flush_needed[active_change_file] then begin
         @<Flush current change file entry@>;
         prime_the_change_buffer;
         end;
   active_change_file := 0;
@ We flush the aborted change by skipping to the next \.{@@x}.
This procedure is almost the same as the one to skip over comment lines,
except that we {\it expect} to hit the \.{@@y} and the \.{@@z}, do not
want the error messages, and we want to |exit| rather |return| if end-of-file
is encountered.
@<Flush current change file entry@>=
loop begin
 incr(change_line);
  if not input_ln(change_file) then begin terminate_change_file;goto done; end
  else if (limit>=2) and (buffer[0]="@@") then begin
    if (buffer[1]>="X")and(buffer[1]<="Z") then
         buffer[1]:=buffer[1]+"z"-"Z"; {lowercasify}
    if buffer[1]="z" then goto done;
  end;
end;
done:
@ We are going to compare the target line with each of the active change
files. The files are searched in ascending order. The first one to match
becomes the active change file.
@d one_matches==(not none_match)
@<Determine if the web file line matches any of the change files@>=
none_match := true; temp_index := 1;
repeat
   if (temp_index <= number_of_actual_change_files )
 then active_change_file := temp_index ;
   none_match := none_match and lines_dont_match;
   incr(temp_index);
until one_matches or (temp_index > number_of_actual_change_files );
last_active_change_file := active_change_file ;
active_change_file := 0;

@ @<Write \.{@@x} to the output change file@>=
  change_changing; {now it's |true|}
  buffer[0]:="@@"; buffer[1]:="x"; limit:=2; output_change_line;
limit:=change_limit;
buffer[0]:=change_buffer[0];
buffer[1]:=change_buffer[1];
  change_changing; {now it's |false|}
  output_change_line;

@ @<Globals...@>=
@!more_names:boolean; { flag indicating there are more change files}
@!filename : packed array [1..200] of char;
@ In this section we open all of the files. Since we do not know how many
change files are to be input (although the maximum is |max_change_files|),
we must open them one at a time.
@<Open the...@>=
more_names:= true;
active_change_file := 0;
while more_names do begin
  @<Get next change file and open it@>;
end;
if active_change_file = 0 then
  fatal_error('No Change Files specified');
line:=0; web_line:=0;out_web_line:=0;out_ch_line:=0;@/
for active_change_file:=1 to number_of_actual_change_files do begin
   change_line:=0;
   change_file_is_open := true;
   prime_the_change_buffer;
end;
change_changing;
limit:=0; loc:=1; buffer[0]:=" "; input_has_ended:=false;
@ This section is {\it highly} system-dependent. We have to determine if there
are more change files, possibly from the command line, and open the next one.
If there are no more, we set the variable |more_names| accordingly. Since this
section of code must open a variable number of files, the first plan was to
copy from \TeX\ the code which opens input text files dynamically, but it was
finally decided that this was overkill. The simplistic routine which follows
prompts the user for another change file name. If an end-of-file is
received from the terminal, the first character of the file name is set to
a blank, or the maximum number of change files is exceeded, |more_names| is
set to false.

The logical change to make here is to get the file names from the command
line, if that is possible on the target system.
@^system dependencies@>
@<Get next change file and open it@>=
more_names := (not eof(term_in)) and (active_change_file < max_change_files) ;
if more_names then
   begin
   write_ln(term_out,'next_change_file:');
   read_ln(term_in,filename);
   if filename[1] <> ' ' then begin
        incr(active_change_file);
        reset(change_file,filename);
        number_of_actual_change_files := active_change_file;
        end
   else more_names := false;
   end;

@ The |get_line| procedure is called to put the next
line of merged input into the buffer and update 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 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
         output_change_line;
         limit := 0; output_change_line;
         change_changing; active_change_file := last_active_change_file;
         prime_the_change_buffer; active_change_file := 0;
      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@>=
for active_change_file:=1 to number_of_actual_change_files  do
  if change_file_is_open then begin
    terminate_change_file;
    if change_limit<>0 then begin {|changing| is false}
      for loc:=0 to change_limit do buffer[loc]:=change_buffer[loc];
      limit:=change_limit;
      line:=web_line; loc:=change_limit;
      err_print('! Change file entry did not match');
@.Change file entry did not match@>
    end;
  end;



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

@p begin initialize;
@<Initialize the input system@>;
print_ln(banner); {print a ``banner line''}
@<Read the input@>;
end_of_WEBMERGE:
stat @<Print statistics about line counts@>;@+tats@;@/
@t\4\4@>{here files should be closed if the operating system requires it}
@<Print the job |history|@>;
end.

@ In this procedure we read the input a line at time. We output an ``I'm
alive!'' dot to the terminal every 100 output lines and a new line every
2000.
@<Read the...@>=
while not input_has_ended do
begin
  get_line;
  output_ln(out_web_file);
  incr(out_web_line);
  if (out_web_line mod 100) = 0 then begin
     print('.');
     if (out_web_line mod 2000) = 0 then new_line;
     end;
  if changing then output_change_line;
end;
@<Check that all changes have been read@>;


@ @<Print statistics about line counts@>=
stat
print_nl('Line count statistics:');
print_nl(web_line:1,' lines in web file');
for active_change_file :=1 to number_of_actual_change_files do
     print_nl(change_line:1,' lines in change file ',active_change_file:1);
print_nl(out_web_line:1,' lines in output web file');
print_nl(out_ch_line:1,' lines in output change file');
print_nl(' ');
tats

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