From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.5-pre1 (2020-06-20) on
	ip-172-31-74-118.ec2.internal
X-Spam-Level: 
X-Spam-Status: No, score=-1.9 required=3.0 tests=BAYES_00 autolearn=ham
	autolearn_force=no version=3.4.5-pre1
Date: 21 Oct 92 23:42:11 GMT
From: dog.ee.lbl.gov!hellgate.utah.edu!caen!zaphod.mps.ohio-state.edu!rpi!bu.ed
u!inmet!spock!stt@ucbvax.Berkeley.EDU  (Tucker Taft)
Subject: Re: User-defined assignment
Message-ID: <1992Oct21.234211.5684@inmet.camb.inmet.com>
List-Id: <comp.lang.ada>

In article <HUDSON.92Oct20101211@yough.cs.umass.edu> 
  hudson@cs.umass.edu writes:

>>>>>> On Sat, 17 Oct 1992 23:32:09 GMT, 
  stt@spock.camb.inmet.com (Tucker Taft) said:

>Tucker> Therefore, this sort of user-defined assignment is 
>Tucker> supported, and Initialize and Finalize work correctly,
>Tucker> in the presence of exceptions and abort.  (What this means
>Tucker> is that Finalize is performed on an object if and only if Initialize
>Tucker> is performed on the object, and both Initialize and Finalize defer abo
rt
>Tucker> until they complete, once they get started.)
>
>It is probable wrong to formally specify that Finalize will *defer* abort
>until it completes. Such a specification pretty much limits Ada to gc
>strategies that utilize reference counts which are not as efficient
>generational copying collectors. While such forms of memory management may be
>the only strategies that are currently envisioned for Ada, similar languages
>such as Modula-3 have shown that other solution are possible. If the Ada 9X
>folks simply say that Finalization will eventually happen (possible
>concurrently) then it doesn't cut off roads that might lead to interesting
>places.

If you reread what it says above, it says that "Finalize" defers
abort until it completes, *once it gets started.*
For stack-allocated variables, Finalize is required to happen prior
to exiting the frame.  For heap-allocated variables, Finalize
may be performed automatically as soon as the object is no longer
accessible, or anytime thereafter, up until the access type itself
goes away.  Alternatively, if the user explicitly deallocates a 
heap-allocated object (via UNCHECKED_DEALLOCATION), Finalize is performed
immediately prior to reclaiming the storage.

In other words, garbage collection is permitted in Ada 9X, and
even acknowledged in the proposed language rules (as it was in Ada 83).
Now all we are waiting for is enough bucks to get some Ada compiler
vendor to implement it.  The ones who tried in the past (AT&T and Symbolics)
never became major players in the Ada market.  Maybe this will
change, but we did not feel it was appropriate to mandate garbage
collection without some proof of commercial viability.  Perhaps
by 200X we will be ready to require GC for Ada.  Until then, you
will have to use your wallet rather than the "club" of the ANSI standard
to get GC into your favorite Ada compiler...

>       Richard L. Hudson  -  Hudson@cs.umass.edu; (413) 545-1220; 
>       Advanced Languages Project - University Computing Services
>       Lederle Graduate Research Center
>       University of Massachusetts             Amherst, MA  01003

S. Tucker Taft    stt@inmet.com
Ada 9X Mapping/Revision Team
Intermetrics, Inc.
Cambridge, MA  02138