[QUERY] Incremental dependencies

jlilley@empathy.com (John Lilley)
9 Jan 1997 21:47:59 -0500

          From comp.compilers

Related articles
[QUERY] Incremental dependencies jlilley@empathy.com (1997-01-09)
Re: [QUERY] Incremental dependencies dlmoore@ix.netcom.com (David L Moore) (1997-01-12)
Re: [QUERY] Incremental dependencies jsgray@acm.org (Jan Gray) (1997-01-14)
Re: [QUERY] Incremental dependencies lat@hpmoose6.cern.ch (Lassi Tuura) (1997-01-15)
| List of all articles for this month |

From: jlilley@empathy.com (John Lilley)
Newsgroups: comp.compilers
Date: 9 Jan 1997 21:47:59 -0500
Organization: Compilers Central
Keywords: C++, parse

I've been pondering an issue that should be of practical importance to
compiler writers, but seems to be implemented miniminally in
commercial compilers (C++ compilers are my only data set).

So I wonder: do any compilers/parsers, commercial or otherwise, make
use of incremental or minimal dependency calculations. For example,
in C++:

1: void foo(int x);
2: void glarp(int x);
3: void glarp(float f);
4: void f() {
5: foo(4);
6: glarp(4);
7: }

If I parse this, and then change the line 1, then I should only have
to recompile lines 1 and 5. But if I change line 2 then I must
recompile (or at least reparse) lines 2,3, and 6.

Given, this is incredibly difficult, escpecially when scoping, overloading,
and the preprocessor are thrown in. I have seen commercial products that
will try one or both of:
    1) Precompiled headers.
    2) Skipping recompiles for a file under certain cases (MSVC++).

Have there been other efforts to create a dependency graph that is
more fine-grained than the file dependency typically used by "make"
and project-oriented compilers? I understand that the task must vary
considerably with the language, but any work that has been published
would be of help.

thanks in advance,
john lilley
|| John Lilley GUIs phone: 303-543-9115 ||
|| Nerds for Hire, Inc. Parsers fax: 303-543-6069 ||
|| http://www.empathy.com jlilley@empathy.com ||
[There was a series of articles by W.M. McKeeman and Shota Aki in the
Journal of C Language Translation in 1991-92 on an incremental C
system. They really did incremental lexing and parsing, keeping track of
what had changed at the lowest level and propagating it all up as far as
necessary. -John]


Post a followup to this message

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