[QUERY] Incremental dependencies

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]


--

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