Tautological comparisons removed; buffer initialized by zeros; LXX files merged to HXX; descriptions added
Standard_DomainError.hxx
Standard_ErrorHandler.cxx
Standard_ErrorHandler.hxx
-Standard_ErrorHandler.lxx
Standard_ErrorHandlerCallback.cxx
Standard_ErrorHandlerCallback.hxx
-Standard_ErrorHandlerCallback.lxx
Standard_ExtCharacter.hxx
Standard_ExtString.cxx
Standard_ExtString.hxx
myStatus(Standard_HandlerVoid), myCallbackPtr(0)
{
myThread = GetThreadID();
+ memset (&myLabel, 0, sizeof(myLabel));
theMutex.Lock();
myPrevious = Top;
Standard_Boolean Standard_ErrorHandler::IsInTryBlock()
{
Standard_ErrorHandler* anActive = FindHandler(Standard_HandlerVoid, Standard_False);
- return anActive != NULL && anActive->myLabel != NULL;
+ return anActive != NULL;
}
Standard_ErrorHandler* anActive = FindHandler(Standard_HandlerVoid, Standard_True);
//==== Check if can do the "longjmp" =======================================
- if(anActive == NULL || anActive->myLabel == NULL) {
+ if(anActive == NULL) {
cerr << "*** Abort *** an exception was raised, but no catch was found." << endl;
if (!theError.IsNull())
cerr << "\t... The exception is:" << theError->GetMessageString() << endl;
#define _Standard_ErrorHandler_HeaderFile
#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_PErrorHandler.hxx>
#include <Standard_JmpBuf.hxx>
#include <Standard_HandlerStatus.hxx>
#include <Standard_ThreadId.hxx>
-#include <Standard_Address.hxx>
-#include <Standard_Boolean.hxx>
#include <Standard_Type.hxx>
+
+//! @file
+//! Support of handling of C signals as C++-style exceptions, and implementation
+//! of C++ exception handling on platforms that do not implement these natively.
+//!
+//! The implementation is based on C long jumps.
+//!
+//! If macro NO_CXX_EXCEPTION is defined, "try" and "catch" are defined as
+//! macros that use jumps to implement exception handling.
+//! See Standard_Failure::Reraise() for exception throwing code.
+//! Note that this option is obsolete and useless for modern platforms.
+//!
+//! If macro OCC_CONVERT_SIGNALS is defined, this enables macro OCC_CATCH_SIGNALS
+//! that can be used in the code (often inside try {} blocks) to convert C-style
+//! signals to standard C++ exceptions. This works only when OSD::SetSignal()
+//! is called to set appropriate signal handler. In the case of signal (like
+//! access violation, division by zero, etc.) it will jump to the nearest
+//! OCC_CATCH_SIGNALS in the call stack, which will then throw a C++ exception.
+//! This method is useful for Unix and Linux systems where C++ exceptions
+//! cannot be thrown from C signal handler.
+//!
+//! On Windows with MSVC compiler, exceptions can be thrown directly from
+//! signal handler, this OCC_CONVERT_SIGNALS is not needed. Note however that
+//! this requires that compiler option /EHa is used.
+
+#ifdef NO_CXX_EXCEPTION
+
+ // No CXX Exceeptions, only jumps in all the cases.
+ //
+ // Note: In the current version setjmp is used. The alternative solution is to
+ // use sigsetjmp that stores the signal mask (to be checked)
+ // In the original implementation sigsetjmp is tried to use for SUN and IRIX
+ // in the following way:
+ // #ifdef SOLARIS
+ // #define DoesNotAbort(aHandler) !sigsetjmp(aHandler.Label(),1)
+ // #endif
+
+ #define try Standard_ErrorHandler _Function; \
+ if(!setjmp(_Function.Label()))
+ #define catch(Error) else if(_Function.Catches(STANDARD_TYPE(Error)))
+ #define OCC_CATCH_SIGNALS
+
+#elif defined(OCC_CONVERT_SIGNALS)
+
+ // Exceptions are raied as usual, signal cause jumps in the nearest
+ // OCC_CATCH_SIGNALS and then thrown as exceptions.
+ #define OCC_CATCH_SIGNALS Standard_ErrorHandler _aHandler; \
+ if(setjmp(_aHandler.Label())) { \
+ _aHandler.Catches(STANDARD_TYPE(Standard_Failure)); \
+ _aHandler.Error()->Reraise(); \
+ }
+
+#else
+
+ // Normal Exceptions (for example WNT with MSVC and option /GHa)
+ #define OCC_CATCH_SIGNALS
+
+#endif
+
class Standard_Failure;
class Standard_ErrorHandlerCallback;
-
+//! Class implementing mechanics of conversion of signals to exceptions.
+//!
+//! Each instance of it stores data for jump placement, thread id,
+//! and callbacks to be called during jump (for proper resource release).
+//!
+//! The active handlers are stored in the global stack, which is used
+//! to find appropriate handler when signal is raised.
class Standard_ErrorHandler
{
//! Unlinks and checks if there is a raised exception.
Standard_EXPORT void Destroy();
-~Standard_ErrorHandler()
-{
- Destroy();
-}
+
+ //! Destructor
+ ~Standard_ErrorHandler()
+ {
+ Destroy();
+ }
//! Removes handler from the handlers list
Standard_EXPORT void Unlink();
Standard_EXPORT Standard_Boolean Catches (const Handle(Standard_Type)& aType);
//! Returns label for jump
- Standard_JmpBuf& Label();
+ Standard_JmpBuf& Label() { return myLabel; }
//! Returns the current Error.
Standard_EXPORT Handle(Standard_Failure) Error() const;
//! Test if the code is currently running in a try block
Standard_EXPORT static Standard_Boolean IsInTryBlock();
-
-friend class Standard_Failure;
-friend class Standard_ErrorHandlerCallback;
-
-
-protected:
-
-
-
-
-
private:
-
//! A exception is raised but it is not yet caught.
//! So Abort the current function and transmit the exception
//! Set the Error which will be transmitted to "calling routines".
Standard_EXPORT static void Error (const Handle(Standard_Failure)& aError);
- //! Returns the current handler (Top in former implemntations)
+ //! Returns the current handler (closest in the stack in the current execution thread)
Standard_EXPORT static Standard_PErrorHandler FindHandler (const Standard_HandlerStatus theStatus, const Standard_Boolean theUnlink);
+private:
Standard_PErrorHandler myPrevious;
Handle(Standard_Failure) myCaughtError;
Standard_ThreadId myThread;
Standard_Address myCallbackPtr;
-
+ friend class Standard_Failure;
+ friend class Standard_ErrorHandlerCallback;
};
-
-#include <Standard_ErrorHandler.lxx>
-
-
-
-
-
#endif // _Standard_ErrorHandler_HeaderFile
+++ /dev/null
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_JmpBuf.hxx>
-
-inline Standard_JmpBuf& Standard_ErrorHandler::Label()
-{
- return myLabel;
-}
-
-/*Common part for jumps*/
-// In the current version setjmp is used. The alternative solution is to
-// use sigsetjmp that stores the signal mask (to be checked)
-// In the original implementation sigsetjmp is tried to use for SUN and IRIX
-// in the following way:
-// #ifdef SOLARIS
-// #define DoesNotAbort(aHandler) !sigsetjmp(aHandler.Label(),1)
-// #endif
-//
-
-#if defined(NO_CXX_EXCEPTION) || defined(OCC_CONVERT_SIGNALS)
- #ifdef SOLARIS
- #define DoesNotAbort(aHandler) !setjmp(aHandler.Label())
- #elif IRIX
- #define DoesNotAbort(aHandler) !setjmp(aHandler.Label())
- #else
- #define DoesNotAbort(aHandler) !setjmp(aHandler.Label())
- #endif
-#endif
-
-
-#ifdef NO_CXX_EXCEPTION
-/* No CXX Exceeptions, only jumps in all the cases.*/
- #define try Standard_ErrorHandler _Function; \
- if(DoesNotAbort(_Function))
- #define catch(Error) else if(_Function.Catches(STANDARD_TYPE(Error)))
- #define OCC_CATCH_SIGNALS
-#elif defined(OCC_CONVERT_SIGNALS)
-/* Exceptions are raied as usual, signal are converted into jumps and
- raused in the proper point.*/
- #define OCC_CATCH_SIGNALS Standard_ErrorHandler _aHandler; \
- if(!DoesNotAbort(_aHandler)) { \
- _aHandler.Catches(STANDARD_TYPE(Standard_Failure)); \
- _aHandler.Error()->Reraise(); \
- }
-#else
-/*Normal Exceptions (for example WNT)*/
- #define OCC_CATCH_SIGNALS
-#endif
#define _Standard_ErrorHandlerCallback_HeaderFile
#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <Standard_Address.hxx>
class Standard_ErrorHandler;
-
//! Defines a base class for callback objects that can be registered
//! in the OCC error handler (the class simulating C++ exceptions)
//! so as to be correctly destroyed when error handler is activated.
public:
DEFINE_STANDARD_ALLOC
-
- //! Registers this callback object in the current error handler
- //! (if found).
- void RegisterCallback();
+ //! Registers this callback object in the current error handler (if found).
+ void RegisterCallback();
//! Unregisters this callback object from the error handler.
- void UnregisterCallback();
-virtual Standard_EXPORT ~Standard_ErrorHandlerCallback ();
+ void UnregisterCallback();
+
+ //! Destructor
+ virtual Standard_EXPORT ~Standard_ErrorHandlerCallback ();
//! The callback function to perform necessary callback action.
//! Called by the exception handler when it is being destroyed but
//! still has this callback registered.
Standard_EXPORT virtual void DestroyCallback() = 0;
-
friend class Standard_ErrorHandler;
-
protected:
-
//! Empty constructor
- Standard_ErrorHandlerCallback();
-
-
-
+ Standard_ErrorHandlerCallback();
private:
-
-
-
Standard_Address myHandler;
Standard_Address myPrev;
Standard_Address myNext;
-
-
};
-
-#include <Standard_ErrorHandlerCallback.lxx>
-
-
-
-
+// If neither NO_CXX_EXCEPTION nor OCC_CONVERT_SIGNALS is defined,
+// provide empty inline implementation
+#if ! defined(NO_CXX_EXCEPTION) && ! defined(OCC_CONVERT_SIGNALS)
+inline Standard_ErrorHandlerCallback::Standard_ErrorHandlerCallback ()
+ : myHandler(0), myPrev(0), myNext(0)
+{
+}
+inline Standard_ErrorHandlerCallback::~Standard_ErrorHandlerCallback ()
+{
+}
+inline void Standard_ErrorHandlerCallback::RegisterCallback ()
+{
+}
+inline void Standard_ErrorHandlerCallback::UnregisterCallback ()
+{
+}
+#endif
#endif // _Standard_ErrorHandlerCallback_HeaderFile
+++ /dev/null
-// Created on: 2006-04-13
-// Created by: Andrey BETENEV
-// Copyright (c) 2006-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// If neither NO_CXX_EXCEPTION nor OCC_CONVERT_SIGNALS is defined,
-// provide empty inline implementation
-
-#if ! defined(NO_CXX_EXCEPTION) && ! defined(OCC_CONVERT_SIGNALS)
-
-inline Standard_ErrorHandlerCallback::Standard_ErrorHandlerCallback ()
- : myHandler(0), myPrev(0), myNext(0)
-{
-}
-
-inline Standard_ErrorHandlerCallback::~Standard_ErrorHandlerCallback ()
-{
-}
-
-inline void Standard_ErrorHandlerCallback::RegisterCallback ()
-{
-}
-
-inline void Standard_ErrorHandlerCallback::UnregisterCallback ()
-{
-}
-
-#endif
projects / occt.git / commitdiff