Re: Elaboration of nested generic package.

[mheaney@on2.com (Matthew Heaney)]

Robert A Duff <bobduff@shell01.TheWorld.com> wrote in message news:<wcc65m8pwq1.fsf@shell01.TheWorld.com>...
> mheaney@on2.com (Matthew Heaney) writes:
> 
> > 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.

Things are even more weird, at least wrt GNAT.

I have this:

generic 
   ...
package GP is
   pragma Preelaborate;
   ...
end GP;

And then I instantiate it, like this:

with GP;
pragma Elaborate_All (GP);
package P is new GP (...);

I then with it from a normal packet that has a categorization pragma:

with P;
package Q is
   pragma Preelaborate;
   ...
end Q;

What's weird is that the compiler is telling me I'm not allowed to
with P from a preelaborate package Q.  I was surprised by this
behavior, because GP says explicitly that it is Preelaborate
categorization.

To make the compiler happy I have to use a confirming pragma on the
instantion of GP:

with GP;
pragma Elaborate_All (GP);
package P is new GP (...);
pragma Preelaborate (P);

and then Q compiles without error.

Is this normal behavior?  This is the reason I was asking whether the
categorization pragmas do anything if they're declared in a generic
package.

Is it necessary to use a categorization pragma on library-level
package instantiations?

-Matt