Re: Proposal: Auto-allocation of Indefinite Objects

["Jeffrey R. Carter" <spam.jrcarter.not@spam.not.acm.org>]

On 4/4/20 1:45 AM, Stephen Leake wrote:
> 
> with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
> 
> declare
>     Foo : Unbounded_String; -- empty
> begin
>     Foo := To_Unbounded ("hi"); -- allocated on the heap
>     Foo := Foo & To_Unbounded ("bye"); -- allocation grows

Foo := Foo & "bye";

Those should be To_Unbounded_String;

For an issue related to the OP's idea, consider

with System;

procedure Boom is
    type Very_Large_Item is ...;
    type Very_Large_Index is mod System.Max_Binary_Modulus;
    type Very_Large_List is array (Very_Large_Index range <>) of Very_Large_Item;

    Last : constant := ...;

    List : Very_Large_List (0 .. Last);
begin -- Boom
    ... -- Do some thing useful with List
end Boom;

There exists a value N > 0 such that Last = N works and Last = N + 1 results in 
Storage_Error. The actual value of N may vary depending on the compiler, target, 
and the actual machine on which the program is executed.

If you want to handle a List with Last > N, you have to make it an access to 
Very_Large_List unless you care where it is allocated. There is still a value M 
which will result in Storage_Error, but on most machines where you'd try to 
process such a large object, M >> N because on such machines the heap is much 
larger than the stack. Implicit dereferencing makes this change less painful 
than it would be without implicit dereferencing, but there are still usually 
places where explicit dereferencing will be needed, so there is still some pain 
involved even though you don't care where the object is allocated.

It would be nice if there were a compiler option where objects that don't fit on 
the stack would be automatically allocated on the heap, and automatically 
deallocated when they go out of scope.

Similar arguments can be made for a compiler option where all numeric types 
would be accepted, with some implemented in terms of the compiler's ability to 
calculate static expressions exactly, rather than the user having to switch from 
a numeric type to an unbounded-number pkg. This has the added value that such 
pkgs usually lose the automated checks that numeric types have.

All of these issues have been around for some time, and the ARG is aware of them 
and has chosen to take no action. That seems unlikely to change.

-- 
Jeff Carter
"I'm a vicious jungle beast!"
Play It Again, Sam
131