Re: Ada Annoyances

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

Niklas Holsti <niklas.holsti@tidorum.invalid> writes:

> Isn't finalization of local objects usually implemented by creating a
> list of these objects, and then traversing that list on scope exit?

No.  That method was used originally by GNAT, but it was changed to
a simpler and much more efficient method.

Consider a record with defaulted discriminants.  The set of components
of that record that have finalization can change when the discriminant
changes.  That's complicated if you're keeping lists of those
components.

If you want to see how GNAT does it now, use the -gnatDGL switch
to compile some examples.  Look for procedures ending in "DI" ("deep
initialize") and "DF" ("deep finalize").

Lists are used only for heap objects that need finalization,
and not for their subcomponents.

>...It
> seems to me that changing the tag of an object on the list should not be
> a problem; the new tag would just lead to a different Finalize, through
> normal dispatching.

I agree, I don't see a problem here.  When Finalize is called, it
dispatches via the currrent Tag.  Tags can't change in Ada, but if they
could it would still dispatch via the Tag value present when Finalize is
called.

> But perhaps there are other implementations where the particular
> Finalize operation for a local object is determined when the
> local-object declaration is elaborated, and therefore corresponds to the
> initial tag value?

I don't know of any such.

- Bob