Re: C bug of the day

["Robert I. Eachus" <rieachus@attbi.com>]

Hyman Rosen wrote:
 > Having to inherit from a special type to get finalization is
 > especially cumbersome in a language which does not have multiple
 > inheritance.

That's probably true, which is why the ability to combine access
discriminants with controlled type mix-ins in Ada is so useful. ;-)
Unfortunately, that only works for limited objects.  You can still add
an access component to the mix-in part of an object to provide
finalization behavoir for the parent, but it is a bit trickier:

with Ada.Finalization.Controlled;
with System.Address_to_Access_Conversion;
generic
   type Parent is tagged private;
    with procedure Initialize (Object : in out Parent);
    with procedure Adjust   (Object : in out Parent);
    with procedure Finalize (Object : in out Parent);
package Controlled_Mixins is

   type Controlled_Part is new Ada.Finalization.Controlled
       with record
     Parent_Access: Addresses.Object_Pointer;
   end record;

   package Addresses is new
              System.Address_to_Access_Conversion(Parent);

   type Child is new Parent with record
     CP: Controlled_Part;
   end record;

private
   procedure Initialize (Object : in out Controlled_Part);
   procedure Adjust   (Object : in out Controlled_Part);
   procedure Finalize (Object : in out Controlled_Part);
end Controlled_Mixins;

The body for this package should be considered as impementation
specific, and is not provided here.  Also it should be obvious that
instantiating this package when type Parent is derived from
Ada.Finialization.Controlled is asking for trouble.  I'd ask for a
generic formal: type Foo is not new Bar; if I didn't think this was a
very special case, and one that normally should be avoided.

Incidently this definitely comes in the "Part 2" class of things you can
do in Ada, but shouldn't.  Instead it is much better to have the parts 
of the object that need finalization wrapped in one or more controlled 
mixins.  That way the mixins are self consistant, and no component is 
reaching up to modify the containing object.  But you can do it.