Re: terminate applications

["Nick Roberts" <nickroberts@blueyonder.co.uk>]

"Marin David Condic" <nobody@noplace.com> wrote in message
news:3F227F16.2010908@noplace.com...

> The critical point being that if you *don't* give the
> programmer the choice, he'll just do an end-run
> around you anyway and resent the fact that he has
> to go outside the language to get what he wants.

I think it might be valuable to add to the standard library a procedure,
perhaps:

   procedure Ada.Unsafe_Terminate_Program;

The RM could define the execution of this procedure maybe as follows:

----------

Dynamic Semantics

Unsafe_Terminate_Program causes the execution of all the tasks in all the
partitions of the program to immediately cease execution. No finalization
occurs, and execution within abort-deferred regions will be terminated
without any deferral. A call to Unsafe_Terminate_Program never returns. The
time or place at which each task ceases is undefined.

Implementation Requirements

Implementations must document all the potential consequences of the
execution of Unsafe_Terminate_Program which are different to those of normal
program termination.

Implementation Permissions

An implementation may omit Unsafe_Terminate_Program if it would be
unreasonable (or too dangerous) to provide it. The mechanisms used by an
implementation to cause the cessation of execution in tasks other than the
calling task (especially those in separate partitions) is undefined, thus
the speed at which this cessation is propagated, and whether it may or may
not succeed in being propagated to all tasks in a program, is undefined. An
implementation may perform some or all finalization, if it would be
unreasonable not to. An implementation may allow some or all executions
within abort-deferred regions to complete before cessation, if it would be
unreasonable to do otherwise.

Notes

It is intended that Unsafe_Program_Termination not only avoids any
finalization or completion of abort-deferred regions in any part of the Ada
program itself, but also that it avoids as much of the normal termination
actions associated with the execution environment as reasonably possible
(e.g. finalizations within a run-time environment). It is recommended that
Unsafe_Program_Termination is used only as a last resort, when all other
attempts at bringing a program to completion have failed. It is recommended
that Unsafe_Program_Termination is not used in deliverable software unless
its use is considered unavoidable. It is strongly recommended that whenever
a program which could possibly execute Unsafe_Program_Termination is
deployed in a different execution environment, or a change is made to that
environment, a thorough check is made as to the worst possible consequences
of its execution.

----------

I think this suggestion makes it clear that: the semantics of such a
procedure would be difficult to define, and impossible to enforce or test;
it truly could be really dangerous in some environments. You might consider
all the above a bit too much to add to the RM to be worth it.

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]