Compiler bootstrapping

Compiler for a language L is implemented in L. Let us call it C0.


Now some bugs are reported for C0. How do we incorporate these
fixes into the new version?


One way is to include one fix at a time, so that we have a better
compiler at each stage. But the problem with this approach is,
there is a preferred order of fixing the bugs which has to be
worked out depending on the correlated nature of the bugs.


Another approach is, include all the fixes and compile the sources
using C0, creating C1. Now compile the sources with C1 creating C2.
If C1 and C2 are not identical, repeat the process, i.e., recompile
with C2 creating C3 and so on.


Now,
  a) Which of the above approaches is 'better'?
  b) Is the process in second approach guaranteed to terminate?
        Under some conditions?


Thanks in advance,


--- ramana@svl.cdc.com ---
[I usually make a tentative C1 with all of the bugs fixed, then make c2 by
running the new source through C1 and C3 by compiling with C2. If C2 and
C3 aren't the same (modulo date stamps), I go back and make a new C1. I
can't ever recall having bugs that had to be fixed in order; compiler
writers are very good at writing code that doesn't exercise any of the
bugs in their compiler. The answer to your second question is no, even
for working compilers, although most of the time we don't consider a
compiler to be working acceptably unless it compiles itself consistently.
--

Return to the comp.compilers page.
Search the comp.compilers archives again.