Re: Accessing finalized values

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

<sbelmont700@gmail.com> wrote in message 
news:143a8db3-c14b-4983-a481-4b998aea42af@googlegroups.com...
>Does anyone have any insight into what happens if a program uses the value
>of an object after it has been finalized, but before it ceases to exist?

Nothing special (other than protected objects, as Adam notes). This is 
perfectly legitimate, although arguably pathological. One reason is that it 
is legal for Finalize to be called on the same object more than once in 
unusual circumstances (this does not necessarily represent a compiler bug). 
Moreover, Finalize routines often depend on other data in the program, and 
that data might already be finalized (imagine the final finalization of a 
program that's completed). It would be hard to get everything into an order 
where there was no dependence on things that are already finalized. (This 
sort of thing can happen in Claw programs, for instance.) The protected 
object case is a bounded error simply because too many implementations 
simply crashed in that case (early versions of GNAT did that, it was 
horrible trying to figure out why Claw programs wouldn't terminate 
properly - the problem was actually our design bug, but its not helpful to 
report a bug with a GP fault in the runtime). Making it a bounded error 
makes it clear that's not an acceptable implementation. The reference to 
"production code" in AARM 9.4(20.h/2) is talking about the locking used in 
Claw - which should be obvious from the naming used in the following 
example.

                                                              Randy.