CPP12 — Server-side exception specifications and ISO C++ std::exception

In CORBA C++ 2.4 and before, the exception specification of generated
POA skeleton member functions is CORBA::SystemException plus the mapped C++
class for exceptions specified in the raise expression of the corresponding
IDL operation [see CORBA C++ 2.4 paragraph 23.27].
As a result, a servant programmer needs to convert any exception other than
those in the exception specification to one in the exception specification
– else the C++ runtime will call std::unexpected() if an unexpected
exception is thrown.

This makes exception handling on the server-side quite painful:
for example if a servant programmer calls operator new(), s/he's supposed
to catch std::bad_alloc and convert it to CORBA::NO_MEMORY. Similarly,
if s/he uses any of the ISO C++ libraries, s/he's supposed to convert the
std::exception objects raised by the library into CORBA::SystemExceptions,
or user-defined IDL exceptions.

Given that C++ compilers provide more and more features of ISO C++,
in particular the standard libraries, this is a real world issue!

Proposal
========

Add std::exception in the exception specification of generated
POA-skeleton member functions. The POA (or POA skeleton) implementation
is responsible to perform the following conversions:
std::bad_alloc to CORBA::NO_MEMORY
other std::exception to CORBA::UNKNOWN (see 3.17.1.1 in CORBA 2.3 core)

Source-code backward-compatibility
----------------------------------
I propose to make exception specifications in generated skeletons a bit
less restrictive than they were in CORBA C++ 2.4 (and before).
C++ servants written with the CORBA C++ 2.4 (and before) mapping do not
require any change – their exception specifications will be more
restrictive than required by the new mapping, which is perfectly correct.

Interoperability
----------------
It does not affect interoperability: only CORBA exceptions go on the
wire. An ORB-mediated operation can only raise a CORBA::SystemException
or a user-defined IDL exception.

Alternative Mapping for C++ Dialects
------------------------------------
Unfortunately, not all C++ compilers comply (or almost comply) with
ISO C+. With such a "C+ compiler", the ORB/POA implementation will
behave as in CORBA C++ 2.4 (i.e. no std::exception is the exception
specification). Or maybe we can allow the ORB/POA to add an
implementation-dependent class in the generated exception
specifications?

Portable user-written servants will simply include
CORBA::SystemException (or something more restrictive) in their
exception specifications.

see below