Re: Ammo-zilla

[lutz@iks-jena.de (Lutz Donnerhacke)]

* David Starner wrote:
>If garbage collection is not mandated, however, then it can't be relied on in 
>Ada code that might run under systems that don't garbage collect - i.e. 
>portable Ada code can't use it. Hence either you deallocate any memory 
>yourself, or suffer garbage leaks while running under a non-garbage 
>collecting system.

Almost all memory leaks I came across were caused in an internal handling
routine or in returning a pointer to an object leaving the 'free' procedure
to the user.

Internal routines should define there own access type (and so a seperate
allocation pool) and only use pointers of that type. If the access type
definition goes out of scope, all objects in this pool can be freed without
any need for complex garbage collection. IIUC Ada 95 enforces this.

Returning a pointer to an uplevel scope is bad design. If tagged type are
used (most cases, due to the well known abstract factory pattern), you can
replace your code in almost all cases in the following way:

  package Factories is
    type Factory is private;  
    type Object is tagged private;
    type Object_Ptr is access Object;
    function Make_A_Pointer_To_Object(f: in Factory) return Object_Ptr;
    ...    
  end Factories;

  procedure Do_Something(aFactory: in Factory)
    an_Object_Ptr: Object_Ptr := Make_A_Pointer_To_Object(aFactory);
  begin
    ...
    Free(po);   -- Don't forget it on all possible exits!
  exception
    when others =>
      Free(po); -- Don't forget it on all exceptions!
      raise;    -- Fire again.      
  end Do_Something;

by:
  package Factories is
    type Factory is private;  
    type Object is tagged private;
    function Make_A_Class_Wide_Object(f: in Factory) return Object'Class;
    ...    
  end Factories;

  procedure Do_Something(aFactory: in Factory)
    an_Object: Object'Class := Make_A_Class_Wide_Object(aFactory);
  begin
    ...
  end Do_Something;

In the rare cases where real pointers must be returned to build up a larger
dynamic structure the whole structure should be implemented as a seperate
package providing a Controlled object.

It took me several weeks to determine this. Thanks to the help of the group
regulars. I hope I wrote not so much bullshit.