EIC code displayed by LXR master/​include/​opencascade/​OSD.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-10-04 09:15:44

 // Copyright (c) 1992-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.
 
 #ifndef _OSD_HeaderFile
 #define _OSD_HeaderFile
 
 #include <Standard.hxx>
 #include <Standard_PCharacter.hxx>
 #include <OSD_SignalMode.hxx>
 
 //! Set of Operating System Dependent (OSD) tools.
 class OSD
 {
 public:
   DEFINE_STANDARD_ALLOC
 
   //! Sets or removes signal and FPE (floating-point exception) handlers.
   //! OCCT signal handlers translate signals raised by C subsystem to C++
   //! exceptions inheriting Standard_Failure.
   //!
   //! ### Windows-specific notes
   //!
   //! Compiled with MS VC++ sets 3 main handlers:
   //! @li Signal handlers (via ::signal() functions) that translate system signals
   //! (SIGSEGV, SIGFPE, SIGILL) into C++ exceptions (classes inheriting
   //! Standard_Failure). They only be called if function ::raise() is called
   //! with one of supported signal type set.
   //! @li Exception handler OSD::WntHandler() (via ::SetUnhandledExceptionFilter())
   //! that will be used when user's code is compiled with /EHs option.
   //! @li Structured exception (SE) translator (via _set_se_translator()) that
   //! translates SE exceptions (aka asynchronous exceptions) into the
   //! C++ exceptions inheriting Standard_Failure. This translator will be
   //! used when user's code is compiled with /EHa option.
   //!
   //! This approach ensures that regardless of the option the user chooses to
   //! compile his code with (/EHs or /EHa), signals (or SE exceptions) will be
   //! translated into Open CASCADE C++ exceptions.
   //!
   //! MinGW should use SEH exception mode for signal handling to work.
   //!
   //! ### Linux-specific notes
   //!
   //! OSD::SetSignal() sets handlers (via ::sigaction()) for multiple signals
   //! (SIGFPE, SIGSEGV, etc).
   //!
   //! ### Common notes
   //!
   //! If @a theFloatingSignal is TRUE then floating point exceptions will
   //! generate SIGFPE in accordance with the mask
   //! - Windows: _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW,
   //!            see _controlfp() system function.
   //! - Linux:   FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW,
   //!            see feenableexcept() system function.
   //!
   //! If @a theFloatingSignal is FALSE then floating point calculations will gracefully
   //! complete regardless of occurred exceptions (e.g. division by zero).
   //! Otherwise the (thread-specific) FPE flags are set to raise signal if one of
   //! floating-point exceptions (division by zero, overflow, or invalid operation) occurs.
   //!
   //! The recommended approach is to call OSD::SetSignal() in the beginning of the
   //! execution of the program, in function main() or its equivalent.
   //! In multithreaded programs it is advisable to call OSD::SetSignal() or
   //! OSD::SetThreadLocalSignal() with the same parameters in other threads where
   //! OCCT is used, to ensure consistency of behavior.
   //!
   //! Note that in order to handle signals as C++ exceptions on Linux and under
   //! MinGW on Windows it is necessary to compile both OCCT and application with
   //! OCC_CONVERT_SIGNALS macro, and use macro OCC_CATCH_SIGNALS within each try{}
   //! block that has to catch this kind of exceptions.
   //!
   //! Refer to documentation of Standard_ErrorHandler.hxx for details.
   Standard_EXPORT static void SetSignal(OSD_SignalMode theSignalMode, bool theFloatingSignal);
 
   //! Sets signal and FPE handlers.
   //! Short-cut for OSD::SetSignal (OSD_SignalMode_Set, theFloatingSignal).
   static void SetSignal(const bool theFloatingSignal = true)
   {
     SetSignal(OSD_SignalMode_Set, theFloatingSignal);
   }
 
   //! Initializes thread-local signal handlers.
   //! This includes _set_se_translator() on Windows platform, and SetFloatingSignal().
   //! The main purpose of this method is initializing handlers for newly created threads
   //! without overriding global handlers (set by application or by OSD::SetSignal()).
   Standard_EXPORT static void SetThreadLocalSignal(OSD_SignalMode theSignalMode,
                                                    bool           theFloatingSignal);
 
   //! Enables / disables generation of C signal on floating point exceptions (FPE).
   //! This call does NOT register a handler for signal raised in case of FPE -
   //! SetSignal() should be called beforehand for complete setup.
   //! Note that FPE setting is thread-local, new threads inherit it from parent.
   Standard_EXPORT static void SetFloatingSignal(bool theFloatingSignal);
 
   //! Returns signal mode set by the last call to SetSignal().
   //! By default, returns OSD_SignalMode_AsIs.
   Standard_EXPORT static OSD_SignalMode SignalMode();
 
   //! Returns true if floating point exceptions will raise C signal
   //! according to current (platform-dependent) settings in this thread.
   Standard_EXPORT static bool ToCatchFloatingSignals();
 
   //! Commands the process to sleep for a number of seconds.
   Standard_EXPORT static void SecSleep(const int theSeconds);
 
   //! Commands the process to sleep for a number of milliseconds
   Standard_EXPORT static void MilliSecSleep(const int theMilliseconds);
 
   //! Converts aReal into aCstring in exponential format with a period as decimal point,
   //! no thousand separator and no grouping of digits.
   //! The conversion is independent from the current locale
   Standard_EXPORT static bool RealToCString(const double aReal, Standard_PCharacter& aString);
 
   //! Converts aCstring representing a real with a period as decimal point,
   //! no thousand separator and no grouping of digits into aReal.
   //!
   //! The conversion is independent from the current locale.
   Standard_EXPORT static bool CStringToReal(const char* const aString, double& aReal);
 
   //! since Windows NT does not support 'SIGINT' signal like UNIX,
   //! then this method checks whether Ctrl-Break keystroke was or
   //! not. If yes then raises Exception_CTRL_BREAK.
   Standard_EXPORT static void ControlBreak();
 
   //! Returns a length of stack trace to be put into exception redirected from signal;
   //! 0 by default meaning no stack trace.
   //! @sa Standard_Failure::GetStackString()
   Standard_EXPORT static int SignalStackTraceLength();
 
   //! Sets a length of stack trace to be put into exception redirected from signal.
   Standard_EXPORT static void SetSignalStackTraceLength(int theLength);
 };
 
 #endif // _OSD_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team