0025078: Coding rules - eliminate GCC warning -Wclobbered
[occt.git] / src / Standard / Standard_ErrorHandler.hxx
1 // Created on: 1992-09-28
2 // Created by: Ramin BARRETO
3 // Copyright (c) 1992-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #ifndef _Standard_ErrorHandler_HeaderFile
18 #define _Standard_ErrorHandler_HeaderFile
19
20 #include <Standard.hxx>
21 #include <Standard_Handle.hxx>
22
23 #include <Standard_PErrorHandler.hxx>
24 #include <Standard_JmpBuf.hxx>
25 #include <Standard_HandlerStatus.hxx>
26 #include <Standard_ThreadId.hxx>
27 #include <Standard_Type.hxx>
28
29 //! @file
30 //! Support of handling of C signals as C++-style exceptions, and implementation
31 //! of C++ exception handling on platforms that do not implement these natively.
32 //!
33 //! The implementation is based on C long jumps.
34 //!
35 //! If macro NO_CXX_EXCEPTION is defined, "try" and "catch" are defined as
36 //! macros that use jumps to implement exception handling. 
37 //! See Standard_Failure::Reraise() for exception throwing code.
38 //! Note that this option is obsolete and useless for modern platforms.
39 //! 
40 //! If macro OCC_CONVERT_SIGNALS is defined, this enables macro OCC_CATCH_SIGNALS
41 //! that can be used in the code (often inside try {} blocks) to convert C-style 
42 //! signals to standard C++ exceptions. This works only when OSD::SetSignal()
43 //! is called to set appropriate signal handler. In the case of signal (like 
44 //! access violation, division by zero, etc.) it will jump to the nearest 
45 //! OCC_CATCH_SIGNALS in the call stack, which will then throw a C++ exception.
46 //! This method is useful for Unix and Linux systems where C++ exceptions
47 //! cannot be thrown from C signal handler.
48 //! 
49 //! On Windows with MSVC compiler, exceptions can be thrown directly from 
50 //! signal handler, this OCC_CONVERT_SIGNALS is not needed. Note however that
51 //! this requires that compiler option /EHa is used.
52
53 #ifdef NO_CXX_EXCEPTION
54
55   // No CXX Exceeptions, only jumps in all the cases.
56   //
57   // Note: In the current version setjmp is used. The alternative solution is to
58   // use sigsetjmp that stores the signal mask (to be checked)
59   // In the original implementation sigsetjmp is tried to use for SUN and IRIX
60   // in the following way:
61   //    #ifdef SOLARIS
62   //      #define DoesNotAbort(aHandler) !sigsetjmp(aHandler.Label(),1)
63   //    #endif
64
65   #define try               Standard_ErrorHandler _Function; \
66                             if(!setjmp(_Function.Label()))
67   #define catch(Error)        else if(_Function.Catches(STANDARD_TYPE(Error)))
68   #define OCC_CATCH_SIGNALS 
69
70   // Suppress GCC warning "variable ...  might be clobbered by 'longjmp' or 'vfork'"
71   #ifdef __GNUC__
72   #pragma GCC diagnostic ignored "-Wclobbered"
73   #endif
74
75 #elif defined(OCC_CONVERT_SIGNALS)
76
77   // Exceptions are raied as usual, signal cause jumps in the nearest 
78   // OCC_CATCH_SIGNALS and then thrown as exceptions.
79   #define OCC_CATCH_SIGNALS   Standard_ErrorHandler _aHandler; \
80                               if(setjmp(_aHandler.Label())) { \
81                                 _aHandler.Catches(STANDARD_TYPE(Standard_Failure)); \
82                                 _aHandler.Error()->Reraise(); \
83                               }
84
85   // Suppress GCC warning "variable ...  might be clobbered by 'longjmp' or 'vfork'"
86   #ifdef __GNUC__
87   #pragma GCC diagnostic ignored "-Wclobbered"
88   #endif
89
90 #else
91
92   // Normal Exceptions (for example WNT with MSVC and option /GHa)
93   #define OCC_CATCH_SIGNALS
94
95 #endif
96
97 class Standard_Failure;
98 class Standard_ErrorHandlerCallback;
99
100 //! Class implementing mechanics of conversion of signals to exceptions.
101 //!
102 //! Each instance of it stores data for jump placement, thread id,
103 //! and callbacks to be called during jump (for proper resource release).
104 //!
105 //! The active handlers are stored in the global stack, which is used
106 //! to find appropriate handler when signal is raised.
107
108 class Standard_ErrorHandler 
109 {
110 public:
111
112   DEFINE_STANDARD_ALLOC
113
114   
115   //! Create a ErrorHandler (to be used with try{}catch(){}).
116   //! It uses the "setjmp" and "longjmp" routines.
117   Standard_EXPORT Standard_ErrorHandler();
118   
119   //! Unlinks and checks if there is a raised exception.
120   Standard_EXPORT void Destroy();
121
122   //! Destructor
123   ~Standard_ErrorHandler()
124   {
125     Destroy();
126   }
127   
128   //! Removes handler from the handlers list
129   Standard_EXPORT void Unlink();
130   
131   //! Returns "True" if the caught exception has the same type
132   //! or inherits from "aType"
133   Standard_EXPORT Standard_Boolean Catches (const Handle(Standard_Type)& aType);
134   
135   //! Returns label for jump
136   Standard_JmpBuf& Label() { return myLabel; }
137   
138   //! Returns the current Error.
139   Standard_EXPORT Handle(Standard_Failure) Error() const;
140   
141   //! Returns the caught exception.
142   Standard_EXPORT static Handle(Standard_Failure) LastCaughtError();
143   
144   //! Test if the code is currently running in a try block
145   Standard_EXPORT static Standard_Boolean IsInTryBlock();
146
147 private:
148   
149   //! A exception is raised but it is not yet caught.
150   //! So Abort the current function and transmit the exception
151   //! to "calling routines".
152   //! Warning: If no catch is prepared for this exception, it displays the
153   //! exception name and calls "exit(1)".
154   Standard_EXPORT static void Abort (const Handle(Standard_Failure)& theError);
155   
156   //! Set the Error which will be transmitted to "calling routines".
157   Standard_EXPORT static void Error (const Handle(Standard_Failure)& aError);
158   
159   //! Returns the current handler (closest in the stack in the current execution thread)
160   Standard_EXPORT static Standard_PErrorHandler FindHandler (const Standard_HandlerStatus theStatus, const Standard_Boolean theUnlink);
161
162 private:
163
164   Standard_PErrorHandler myPrevious;
165   Handle(Standard_Failure) myCaughtError;
166   Standard_JmpBuf myLabel;
167   Standard_HandlerStatus myStatus;
168   Standard_ThreadId myThread;
169   Standard_Address myCallbackPtr;
170
171   friend class Standard_Failure;
172   friend class Standard_ErrorHandlerCallback;
173 };
174
175 #endif // _Standard_ErrorHandler_HeaderFile