Re: This is a simple question

[Jacob Sparre Andersen <sparre@nbi.dk>]

Stephen:

> The problem is the gnat compiler will only accept one compilation unit per
> file. Because what I am playing at seems to make a single function/procedure
> into a single compilation unit, I seem to be incuring the inefficient
> situation of requiring a file for each function declaration and then
> definition.

I am not sure it is an inefficient solution. But it is
definitely a very Unix-like solution.

> My real question is whether this is indeed the case, and that if you don't
> use packages you will always have this situation. Is this the case with all
> Ada compilers?

No.

> I come from a background of 'C' and am used to the #include<>
> nature of things. The idea of packages seems to adstract the native file
> system to another level (packages) and allows the compiler implementation to
> determine where files are on the host computer. Is this so?

The package/procedure/function-file relation is a GNAT
specific thing.

If I remember correctly GNAT has a pragma, you can use to
specify that a compilation unit is in a file with another
name than the one GNAT derives from the name of the
compilation unit.

> As for question 2. from reading this newsgroup I get the impression that
> there are quite a few "bugs" in gnat?!

I am only aware of two apparent defects in the current
public version of GNAT. And only one of these is related to
actual compilation of Ada programs. The other one is a
_potential_ security hole in the compiler, when compiling on
multi-user systems.

This is actually quite close to a perfect system.

You should appreciate that there is openness about the few
remaining defects in GNAT.

> Is Ada in real life as good as Ada theoretical could be?

No - but that goes for any language whose formal definition
isn't a specific implementation of the language (and
probably also for some of those whose formal definition _is_
a specific implementation).

GNAT is for example not always as agressive in its
optimisation as it is theoretically and practically
possible.

> Is there a grading system to Ada compiler technologies?

There is an official "validation suite", which is supposed
to test if an Ada compiler is actually an Ada compiler, but
it is not exhaustive.

Jacob
-- 
"It is very easy to get ridiculously confused about the
 tenses of time travel, but most things can be resolved
 by a sufficiently large ego."