From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,INVALID_MSGID
	autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 103376,a02ecdd4cb0f0996
X-Google-Attributes: gid103376,public
From: Robert A Duff <bobduff@world.std.com>
Subject: Re: Pragma Inline and its Effects of Compilation Dependencies.
Date: 2000/03/24
Message-ID: <wccpuskjo3e.fsf@world.std.com>#1/1
X-Deja-AN: 601826501
Sender: bobduff@world.std.com (Robert A Duff)
References: <8b64ul$jov$1@inputplus.demon.co.uk> <8b8gen$mko$1@nnrp1.deja.com>
 <8bd7oh$6sv$1@inputplus.demon.co.uk> <8bdo4e$bi5$1@nnrp1.deja.com>
Organization: The World Public Access UNIX, Brookline, MA
Newsgroups: comp.lang.ada
Date: 2000-03-24T00:00:00+00:00
List-Id: <comp.lang.ada>

Robert Dewar <robert_dewar@my-deja.com> writes:

> The genesis of this idea was that Richard Stallman could not
> believe that a language where the meaning of the program
> depended on the order in which sources were compiled could
> even vaguely be acceptable :-).

And yet he seems perfectly happy with a language where the meaning of
the program depends on the order in which the object code is loaded into
the system -- Lisp.

I certainly agree that the source-based model is a good one, and I've
thought so since around 1984 or so.

There are really two aspects to the source-based model, as supported by
GNAT and the various compilers derived from the Intermetrics/AverStar
front end:

    1. The source is what matters.  If you change the source code,
       rebuilding tools notice.  Order of compilation doesn't matter.
       Compiling something twice produces the same result.  Etc.

    2. Symbol tables and whatnot are NOT stored in some sort of persistent
       data structure (disk files, or whatever), but are recomputed as
       needed.

These are somewhat independent design decisions.  That is, you could
have number 1, but as an optimization store symbol tables on disk, so
long as you make it a pure optimization (doesn't affect the semantics of
the source-based model).

Number 1 seems obviously Good to me.  I'm not so sure about number 2.
Clearly, not storing persistent data simplifies the compiler, which is a
good thing.  Especially since it won't *be* an optimization unless you go
to some trouble to make sure the data structures are reasonably small --
you can do a lot of compiling in the time it takes to read stuff from
the disk.

- Bob