Re: Legit Warnings or not

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

"Randy Brukardt" <randy@rrsoftware.com> writes:

> "Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message 
> news:wcc8vrrbrb6.fsf@shell01.TheWorld.com...
> ...
>> Implicit heap allocation could be a good feature in a different
>> language, but then I'd want that language to allow:
>>
>>    type Tree is tagged
>>        record
>>            Left, Right : Tree'Class; -- doubly illegal!
>>        end record;
>
> Yes, of course Ada should support this, too. ;-) As noted, it's not 
> particularly hard.

Maybe in Ada 2020?  ;-)

":=" and "=" need to walk the whole tree of subcomponents.
Many folks (not me) would find that disconcerting.
Unchecked_Deallocation would too, unless you use garbage collection.

> Note that these sorts of allocations aren't really the same as heap 
> allocations -- their lifetime is similar to that of the secondary stack. 

Their lifetime is, but you want to use heap allocation because the
sizes can change.  Note that I'm assuming the Tag can change
(which is highly not-Ada).  E.g.:

    type This_Tree is new Tree with ...;
    type That_Tree is new Tree with ...;

    X : Tree'Class;
    X := This_Tree'(...);
    X.Left := This_Tree'(...);
    X.Left := That_Tree'(...);

Or are you suggesting that you just keep growing the secondary stack?
I don't like memory leaks.

> Janus/Ada does allocate them on the heap (with them being deallocated when 
> scope goes away), but I've been thinking about ways to reduce/eliminate 
> that. One obvious idea is to allocate the initial sizes off of the secondary 
> stack, and only allocate from the heap if they get bigger via assignment in 
> a different master (which is fairly rare). Not sure if that would save 
> enough to be worth the extra complication.

- Bob