RE: RE: RE: Ada 0y wish list:

RE: RE: RE: Ada 0y wish list:

[Beard, Frank]

-----Original Message-----
From: Ted Dennison [mailto:dennison@telepath.com]

> Whether its implemented as a stack object or a heap object does not
> change the fact that the referencing code is going to have to be generated
to go
> out and get X bytes for the object from somewhere, and that code will have
to be
> recompiled whenver you change the source file that contains the
calculation of
> X.

How does it work for access types?  If I change the type that is being
"access"ed, anything making use of the size of what it's pointing to has to
be recompiled?

Why can't it work like an access type does during runtime?  Everywhere you
can use an access type you could use the deferred type.  An array of access
types would be just like an array of deferred types.  They would both be an
array of "addresses".  As far as 'size, using X'size would be the same as
using X.all'size.

Maybe I'm not thinking it through all the way (wouldn't be the first time),
but that's why I threw it out on the wish list.  To me, it would be a nice
to have if it were feasible.  It just seems like it could work like an
access type without the hassles of new, deallocate, garbage collection, etc.
Java does something similar, but that may be part of what contributes to
it's poor runtime performance.

Frank

Re: RE: RE: RE: Ada 0y wish list:

[Ted Dennison]

In article <mailman.982280592.27013.comp.lang.ada@ada.eu.org>, Beard, Frank
says...
>
>How does it work for access types?  If I change the type that is being
>"access"ed, anything making use of the size of what it's pointing to has to
>be recompiled?

Yes.


---
T.E.D.    homepage   - http://www.telepath.com/dennison/Ted/TED.html
          home email - mailto:dennison@telepath.com