Re: User-defined assignment

[dog.ee.lbl.gov!hellgate.utah.edu!cs.utexas.edu!qt.cs.utexas.edu!news.Brow n.EDU!noc.near.net!inmet!spock!stt@ucbvax.Berkeley.EDU (Tucker Taft)]

In article <1992Oct16.115805.15575@cfmu.eurocontrol.be> 
stef@cfmu.eurocontrol.be (Stef Van Vlierberghe) writes:
> . . .
>Ideally you would submit a comment to ada9x-mrt@inmet.com, then it will
>get filed in their database, and forwarded to DRs and ISO delegates. As
>these comments are processed automatically, they have to start with the
>following header :
>
>!topic User defined assignment
>!reference MS-5.2,7.4.1,7.4.5;4.0

Please don't use this format.  It will be rejected by our automatic
mail processing tool.  Each reference should be on its own line:

  !reference MS-5.2;4.0
  !reference MS-7.4.1;4.0
  !reference MS-7.4.5;4.0

In case you are interested, these references refer to sections
of the Ada 9X Mapping Specification, version 4.0, which is on-line
on the ajpo machine, available via anonymous ftp.

>!discussion

We do encourage people to comment on this issue.

The fundamental difficulty we face is the fact that
Ada already supports exceptions and abort (something only
beginning to appear in C++), and having full support
for user-defined assignment and finalization without imposing
significant per-object space overhead requires an approach
based on some kind of program counter (PC) map of the program.
Currently Ada exception handlers are typically implemented using
PC maps, but they don't have to handle the granularity of
individual component initializations of a composite object, which
would be necessary to fully support finalization via a PC map.

Array initializations are problem the worst, since these generally
occur in a loop, and so the finalization would to be done
for only those elements for which initialiation succeeded, requiring
that the exception handler have a loop that depended on the state
of the initialization loop at the time of the exception.

It will be interesting to see how C++ implementations adapt to
accommodate the addition of exception handling, given that they
already support destructors and user-defined assignment without
per-object overhead (in general).  I have seen some descriptions
of PC-map based approaches, but they seemed both complex and incomplete.
Does anyone know the strategy/complexity/efficiency of HP's C++ 
(which supposedly supports exception handling, and of course destructors)?

>-- 
>Stef VAN VLIERBERGHE            Eurocontrol - Central Flow Management Unit
>stef@cfmu.eurocontrol.be        Avenue des Arts 19H
>Tel: +32 2 729 33 42            B-1040 BRUSSELS
>Fax: +32 2 729 32 16            Belgium

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