Re: GNAT - return by anonymous access

["Randy Brukardt" <randy@rrsoftware.com>]

"Georg Bauhaus" <rm.dash-bauhaus@futureapps.de> wrote in message 
news:4ef1cb93$0$7626$9b4e6d93@newsspool1.arcor-online.net...
...
> OP wanted to return an allocated object of limited type (which
> is when GNAT issues its message). If there is a reason for doing
> so (maybe allocating a global library level task at some nested
> level), then what can be done without a redesign?

A redesign is necessary, because what he is trying to do is not likely to 
work on any Ada compiler, and is certainly not going to be portable to other 
Ada compilers (because the language rules aren't consistent).

> (Is everyone happy with dropping return-by-reference for limited
> types? There was a use case for these. I guess it has not
> disappeared, whatever difficulties implementers might have
> encountered...)

We (the ARG) think that is you really need return-by-reference, you should 
write it explicitly using an access type. (And my preference is that access 
type is a pool-specific named access type, otherwise, you'll run into the 
sort of problems the OP did - the rules for anonymous types are a mess.) 
That is, your function should return an access value, not some other type 
where the by-reference nature is hidden (and causes all sort of problems in 
actual use).

Ada 95's rules caused huge problems when you had limited types. In Claw, the 
registry key type is limited, and the effort to create the predefined keys 
was insane: you couldn't declare constants, you could declare a function, 
but you couldn't return an aggregate, you couldn't return a local object, 
you could return a global object -- but that is where we started! -- these 
objects couldn't be constants, they couldn't be initialized with an 
aggregate (either in the declaration or in the package body). We had to 
resort to initializing them component-by-component in the package body - a 
hugely error-prone way of working. Luckily, these things hardly ever change, 
so it was a one-time pain in Claw -- in other circumstances it could be a 
real maintenance problem.

Ada 2005 added build-in-place to solve all of that. But for that to make 
sense, the old scheme had to go, thus we got rid of return-by-reference 
(which never made any sense in the first place).

                                             Randy.