Re: storage error: stack overflow

[Bob Duff <bobduff@theworld.com>]

"Jeffrey R. Carter" <spam.jrcarter.not@spam.not.acm.org> writes:

> On 08/18/2015 05:23 AM, hreba wrote:
>> 
>> I need an access type because in my real program TB is a tagged type and I need
>> class-wide variables.
>
> You do not /need/ access types for this. Avoiding them requires some thought,
> but that's what S/W engineers do.

I don't think it's fair to say that people who use access types
(i.e. pointers) aren't proper "S/W engineers".  It's true that Ada
doesn't require pointers in many cases where other languages do.
But Ada still requires pointers if the class-wide variable
needs to change its tag.  And pointers are required for recursive
data structures.  Etc.

I think what you and Randy have been saying (or should have been?)
is more like:

    1. Try to avoid using pointers.

    2. When you have to use them, try to encapsulate.

    3. When possible, use the encapsulations already provided by the
       language (i.e. the Ada.Containers).

But there are all sorts of reasons why Ada.Containers might not be
suitable, so in those cases, you WILL use pointers, preferably
encapsulated.  But that's different from saying "never use pointers"
(or "never use access types").

>> Didn't know about extended return (the Ada 95 book was cheaper -:). But there is
>> a problem: the TB in my original program is not only tagged, it is limited too
>> (and New_TB is for initialization). So "foo.all:=..." is forbidden.
>
> If your type is limited then you will have to use an extended return for Ada >
> 95. ...

I'm not sure what you mean by that.  There is no rule that return of a
limited type requires extended return.  This:

    return expression;

means exactly the same thing as:

    return Result : T := expression do
        null;
    end return;

whether T is limited or not.

You only need extended return when you want to have a name for the
function result (so you can assign into parts of it, for example).

And anyway, the example is returning an access value, which is not
limited.

> ...Does
>
> return Foo : access TB :=
>    new TB'( (A => TA'(Name => To_Unbounded_String (Name) ) );
>
> work?

Maybe you were just hoping that the extended return version wouldn't
tickle the same compiler bug?  That's possible, but unlikely;
I didn't try it.

Anyway, that could be written:

    return new TB'( (A => TA'(Name => To_Unbounded_String (Name) ) );

and mean the same thing.

- Bob