diff options
Diffstat (limited to 'TAO/tao/try_macros.h')
-rw-r--r-- | TAO/tao/try_macros.h | 272 |
1 files changed, 0 insertions, 272 deletions
diff --git a/TAO/tao/try_macros.h b/TAO/tao/try_macros.h deleted file mode 100644 index 79485c0c26f..00000000000 --- a/TAO/tao/try_macros.h +++ /dev/null @@ -1,272 +0,0 @@ -// This may look like C, but it's really -*- C++ -*- -// $Id$ - -// ============================================================================ -// -// = LIBRARY -// TAO -// -// = FILENAME -// try_macros.h -// -// = DESCRIPTION -// Writing code that is portable between platforms with a without -// native C++ exceptions is hard. The following macros offer some -// help on this task, mostly oriented to making the ORB code and the -// IDL generated code portable. -// -// = AUTHOR -// Copyright by Douglas C. Schmidt. -// -// ============================================================================ - -#if !defined (TAO_TRY_MACROS_H) -#define TAO_TRY_MACROS_H - -#include "tao/orbconf.h" - -// These macros can be used to write "portable" code between platforms -// supporting CORBA exceptions natively (using the C++ exceptions) or -// through the Enviroment parameter. Their use requires some -// discipline, but they certainly help... - -#if defined (TAO_USE_EXCEPTIONS) - -#define TAO_TRY_ENV __env -// The first "do" scope is for the env. -// The second "do" scope is for the TAO_CHECK_ENV continues. -#define TAO_TRY \ -do { \ -CORBA_Environment TAO_TRY_ENV; \ -try { - -#define TAO_TRY_EX(LABEL) \ -do { \ -CORBA_Environment TAO_TRY_ENV; \ -try { - -#define TAO_CATCH(TYPE,VAR) \ -} catch (TYPE & VAR) { \ -ACE_UNUSED_ARG (VAR); - -#define TAO_CATCHANY \ -} catch (...) { -#define TAO_ENDTRY }} while (0) - -// No need to do checking, exception handling does it for us. -#define TAO_CHECK_ENV -#define TAO_CHECK_ENV_EX(LABEL) -#define TAO_CHECK_ENV_RETURN(X, Y) - -#define TAO_THROW(EXCEPTION) throw EXCEPTION -#define TAO_THROW_ENV(EXCEPTION, ENV) throw EXCEPTION -#define TAO_RETHROW throw - -#if defined (ACE_WIN32) - -// MSVC++ gives a warning if there is no return after the throw -// expression, it is possible that other compilers have the same -// problem. -#define TAO_THROW_RETURN(EXCEPTION, RETURN) do {\ - throw EXCEPTION; \ - return RETURN; } while (0) -#define TAO_THROW_ENV_RETURN(EXCEPTION, ENV, RETURN) do { \ - throw EXCEPTION; \ - return RETURN; } while (0) -#define TAO_RETHROW_RETURN(RETURN) throw; \ - return RETURN - -#else - -#define TAO_THROW_RETURN(EXCEPTION, RETURN) throw EXCEPTION -#define TAO_THROW_ENV_RETURN(EXCEPTION, ENV, RETURN) throw EXCEPTION -#define TAO_RETHROW_RETURN(RETURN) throw - -#endif /* ACE_WIN32 */ - -// #define TAO_THROW_SPEC(X) ACE_THROW_SPEC(X) -#define TAO_THROW_SPEC(X) -// The IDL compiler is not generating throw specs, so putting them in -// the servant implementation only results in compilation -// errors. Further the spec does not say that we should generate them -// and I'm concerned that putting a throw spec can result in an -// "unexpected" exception, which *could* be translated into a -// CORBA::UNKNOWN, but I'm not sure. - -#define TAO_RAISE(EXCEPTION) throw EXCEPTION -// This is used in the implementation of the _raise methods - -#else /* ACE_HAS_EXCEPTIONS && TAO_IDL_COMPILES_HAS_EXCEPTIONS */ - -// Define a local enviroment variable... -#define TAO_TRY_ENV __env - -// I would like to experiment with this idea in the future.... -#if 0 -#define TAO_TRY_VAR(X) \ -do { CORBA_Environment &_env = CORBA_Environment::default_environment ()= X; \ -int TAO_TRY_FLAG = 1; \ -TAO_TRY_LABEL: \ -if (TAO_TRY_FLAG) \ -do { -#endif /* 0 */ - -// The first "do" scope is for the env. -// The second "do" scope is for the TAO_CHECK_ENV continues. -#define TAO_TRY \ -do { CORBA_Environment TAO_TRY_ENV; \ -int TAO_TRY_FLAG = 1; \ -TAO_TRY_LABEL: \ -if (TAO_TRY_FLAG) \ -do { - -// This serves a similar purpose as the macro above, -// The second "do" scope is for the TAO_CHECK_ENV continues. -#define TAO_TRY_EX(LABEL) \ -do { \ -CORBA_Environment TAO_TRY_ENV; \ -int TAO_TRY_FLAG = 1; \ -TAO_TRY_LABEL ## LABEL: \ -if (TAO_TRY_FLAG) \ -do { - -// Each CATCH statement ends the previous scope and starts a new one. -// Since all CATCH statements can end the TAO_TRY macro, they must all -// start a new scope for the next potential TAO_CATCH. The TAO_ENDTRY -// will finish them all. Cool, eh? -#define TAO_CATCH(TYPE,VAR) \ -} while (0); \ -do \ -if (TAO_TRY_ENV.exception () != 0 && \ - TYPE::_narrow(TAO_TRY_ENV.exception ()) != 0) { \ - TYPE &VAR = *TYPE::_narrow (TAO_TRY_ENV.exception ()); \ - ACE_UNUSED_ARG (VAR); - -#define TAO_CATCHANY \ -} while (0); \ -do { \ -if (TAO_TRY_ENV.exception () != 0) - -// The first "while" closes the local scope. The second "while" -// closes the TAO_TRY_ENV scope. -#define TAO_ENDTRY \ -} while (0); \ -} while (0) - -// If continue is called, control will skip to the next TAO_CATCHANY -// statement. -#define TAO_CHECK_ENV \ -{\ -if (TAO_TRY_ENV.exception () != 0) \ - { \ - TAO_TRY_FLAG = 0; \ - goto TAO_TRY_LABEL; \ - } \ -} - -// Same as above but for TAO_TRY_EX -#define TAO_CHECK_ENV_EX(LABEL) \ -do {\ -if (TAO_TRY_ENV.exception () != 0) \ - { \ - TAO_TRY_FLAG = 0; \ - goto TAO_TRY_LABEL ## LABEL; \ - } \ -} while (0) - -#define TAO_CHECK_ENV_RETURN(X, Y) \ - if ( X . exception () != 0) return Y - -#define TAO_THROW(EXCEPTION) \ -do {\ - _env.exception (new EXCEPTION); \ - return; } while (0) - -#define TAO_THROW_ENV(EXCEPTION, ENV) \ -do {\ - ENV.exception (new EXCEPTION); \ - return; } while (0) - -#define TAO_THROW_RETURN(EXCEPTION, RETURN) \ -do {\ - _env.exception (new EXCEPTION); \ - return RETURN; } while (0) - -#define TAO_THROW_ENV_RETURN(EXCEPTION, ENV, RETURN) \ -do {\ - ENV.exception (new EXCEPTION); \ - return RETURN; } while (0) - -#define TAO_RETHROW \ -_env.exception (TAO_TRY_ENV.exception ()); \ -return - -#define TAO_RETHROW_RETURN(RETURN) \ -_env.exception (TAO_TRY_ENV.exception ()); \ -return RETURN - -#define TAO_THROW_SPEC(X) - -#define TAO_RAISE(EXCEPTION) - -#endif /* TAO_USE_EXCEPTIONS */ - -// This macros can be used even outside the TAO_TRY blocks, in fact -// some are designed for that purpose. - -#define TAO_CHECK_ENV_RETURN_VOID(X) \ - if ( X . exception () != 0) return - -#define TAO_CHECK_ENV_PRINT_RETURN(ENV, PRINT_STRING, RETURN) \ - if (ENV . exception () != 0) \ - { \ - ENV.print_exception (PRINT_STRING); \ - return RETURN; \ - } - -#define TAO_CHECK_ENV_PRINT_RETURN_VOID(ENV, PRINT_STRING) \ - if (ENV . exception () != 0) \ - { \ - ENV.print_exception (PRINT_STRING); \ - return; \ - } - -// Throwing an exception from within a TAO_TRY block has slightly -// different semantics, we need to check that in the near future. -# define TAO_TRY_THROW(EXCEPTION) TAO_THROW(EXCEPTION) - -// This macros are used to grab a lock using a Guard, test that the -// lock was correctly grabbed and throw an exception on failure. -// If you do not wish to throw an exception, but just to return a -// value please use the ACE macros. -#define TAO_GUARD_THROW(MUTEX,OBJ,LOCK,ENV,EXCEPTION) \ - ACE_Guard<MUTEX> OBJ (LOCK); \ - if (OBJ.locked () == 0) \ - TAO_THROW_ENV (EXCEPTION,ENV) - -#define TAO_GUARD_THROW_RETURN(MUTEX,OBJ,LOCK,RETURN,ENV,EXCEPTION) \ - ACE_Guard<MUTEX> OBJ (LOCK); \ - if (OBJ.locked () == 0) \ - TAO_THROW_ENV_RETURN (EXCEPTION,ENV,RETURN) - -#define TAO_READ_GUARD_THROW(MUTEX,OBJ,LOCK,ENV,EXCEPTION) \ - ACE_Read_Guard<MUTEX> OBJ (LOCK); \ - if (OBJ.locked () == 0) \ - TAO_THROW_ENV (EXCEPTION,ENV) - -#define TAO_READ_GUARD_THROW_RETURN(MUTEX,OBJ,LOCK,RETURN,ENV,EXCEPTION) \ - ACE_Read_Guard<MUTEX> OBJ (LOCK); \ - if (OBJ.locked () == 0) \ - TAO_THROW_ENV_RETURN (EXCEPTION,ENV,RETURN) - -#define TAO_WRITE_GUARD_THROW(MUTEX,OBJ,LOCK,ENV,EXCEPTION) \ - ACE_Write_Guard<MUTEX> OBJ (LOCK); \ - if (OBJ.locked () == 0) \ - TAO_THROW_ENV (EXCEPTION,ENV) - -#define TAO_WRITE_GUARD_THROW_RETURN(MUTEX,OBJ,LOCK,RETURN,ENV,EXCEPTION) \ - ACE_Write_Guard<MUTEX> OBJ (LOCK); \ - if (OBJ.locked () == 0) \ - TAO_THROW_ENV_RETURN (EXCEPTION,ENV,RETURN) - -#endif /* TAO_TRY_MACROS_H */ |