Re: Elaboration of nested generic package.

[Robert A Duff <bobduff@shell01.TheWorld.com>]

mheaney@on2.com (Matthew Heaney) writes:

> "Robert I. Eachus" <rieachus@attbi.com> wrote in message news:<3F0CC2D1.10904@attbi.com>...
> > Don Westermeyer wrote:
> > 
> > > Usually I do use pragma Elaborate_All for every dependancy anyway
> > > since one does not have control over every software module developed. 
> > > Using it is always safer and causes no penalties that I know of
> > > (assuming the design stays clear of mutual dependancies).
> > 
> > This is silly.  The reason that Ada doesn't automagically assume 
> > Elaborate_Body or Elaborate_All, is that there is a better assumption. 
> > The implementation knows the potential elaboration issues and is 
> > encouraged to chose one that cannot result in Program_Error.
> 
> I was talking about library-level instantiations of generic packages.
> 
> Back in 1997, Bob Duff and Robert Dewar seemed to suggest that you
> always need Elaborate_All on the generic package:
> 
> with GP;
> pragma Elaborate_All (GP); --Do you need this pragma...
> package P is new GP;       --...in order to instantiate?
> 
> If we're not talking about with'ing a generic package, then I agree
> that it is silly to use the Elaborate_All on every dependency.  It
> only makes it harder for the compiler to find an acceptable
> elaboration order, because you have constrained the size of the set of
> possible orders.
> 
> You should only use it when the dependent unit calls subprograms
> provided by the with'd unit during its own elaboration.
> 
> 
> > Using pragma Elaborate, Elaborate_All, or Elaborate_Body 
> > indiscriminantly can only make the Ada compiler's job harder.  There are 
> > two exceptions though.  If you know that the subprograms declared in a 
> > package are used before the main program is elaborated, by all means use 
> > Elaborate_All.  
> 
> Yes.
> 
> I would still like a definitive answer, though.  In order to make a
> library-level package instantiation, do I need to use Elaborate_All on
> the generic unit? (As in the example above.)

If the generic unit says Elaborate_Body, then you do not.  However,
Elab_Body causes a problem: the body can't "with" its own children,
which is often useful.

If you don't have Elab_Body, and you say "with Some_Generic", then you
should normally Elab_All of the generic, because your instances will
normally be at library level.  If your instances are nested in
procedures, then you don't normally need to do that.  There are some
rare cases where Elab_All won't work, and you have to use pragma
Elaborate instead.

This part of the language is something of a mess.  Pragma Elaborate was
added late in the game of Ada 83, and it was later realized that it
doesn't work well, and we tried to fix it in Ada 95, and pretty much
failed.  We added some pragmas, but as evidenced by this thread, it's
not always clear when to use them.

But if you use GNAT in its default mode, it will tell you where you need
the pragmas, mostly.  It doesn't work in the case of
indirect/dispatching calls, though.

> Also: do the categorization pragmas in a generic unit make any
> difference?  In other words, you still need to say Elaborate_All,
> irrespective of what the generic unit says about categorization --
> correct?

I think there is an AI on this point.  Sorry, I don't remember the
details.

- Bob