Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!watmath!clyde!rutgers!dayton!umn-cs!amit
From: amit@umn-cs.UUCP
Newsgroups: comp.text
Subject: Re: A question about WEB and bibtex
Message-ID: <60400006@umn-cs.UUCP>
Date: Tue, 17-Feb-87 14:04:00 EST
Article-I.D.: umn-cs.60400006
Posted: Tue Feb 17 14:04:00 1987
Date-Received: Thu, 19-Feb-87 06:35:31 EST
References: <1605@utastro.UUCP>
Lines: 48
Nf-ID: #R:utastro:-160500:umn-cs:60400006:000:2336
Nf-From: umn-cs!amit    Feb 17 13:04:00 1987


ken@rochester reasons why WEB programs need their own .change files:
1. TANGLE isn't smart enough to handle tokens; it can only refer to line
   numbers for patching. This dictates a .change file per program.

2. Differences between systems (read: compilers) cannot be listed in advance.
   In general, only when one ports an application from System-X to System-Y,
   will one find out that her Pascal-Y cannot do foo. She'll *then* tailor
   a .change file for the application.

3. The opposite: she may find out that her Pascal-Y can do much better than
   the original Pascal-X, and decide to rewrite parts of the original WEB code.
----------------

Terminology: CPF-XY: Compiler-Patch-File, for the Pascal compiler on System-Y.
	     PP: Patch-Program: accepts Prog-X and CPF_Y, produces Prog-Y.

(1) is a fact -- TANGLE cannot handle tokens. But PP might. Imagine the
sequence Tangle-then-PP. PP will take CPF-Y and a tangled WEB (= Pascal-X)
application program, and produce an equivalent Pascal-Y application program.
Nothing prohibits CPF-Y from generating external C routines, and calling them
from the Pascal-Y application.  ***TANGLE can still accept .change files!***

(2) is generally true -- it would be virtually impossible to list differences
between two similar complex systems.  My conclusion, though, is that when a
discrepancy has been discovered, modify CPF-Y, not just for the application at
hand, but once and for all.

(3) to me is less important than the issue of portability. Nonetheless, it *is*
possible to improve WEB programs through .change files, as indicated in (1).
----------------

So far, this doesn't look too complex, perhaps even suitable for a serious
Compiler Construction class. However, for the documentation to conform to the
program, the CPF-Y mods need to be incorporated. And WEAVE-then-PT (Patch
Text) is much-much harder than TANGLE-then-PP. On the other hand, this is not
crucial for the execution.

Summary:
1. TANGLE Prog.web [ Prog.change ]  ==> Prog.pas-x
2. PP Prog.pas-x CPF-Y		    ==> Prog.pas-y
3. Write a Prog.change file, which should closely match the CPF-Y mods,
   but on a line-by-line basis. Note, though, that this is not crucial
   for the execution of the ported program.
4. WEAVE Prog.web Prog.change       ==> Prog.tex

Neta Amit (amit@umn-cs)
U of Minnesota CSci