framebased.h

来自「一个类似windows」· C头文件 代码 · 共 390 行 · 第 1/2 页

    static const int _SEHScopeKind = 0;                                        \
    (void)_SEHScopeKind;                                                       \
                                                                               \
    if(_SEHSetJmp(_SEHTryLevel.ST_JmpBuf) == 0)                                \
    {                                                                          \
     for(;;)                                                                   \
     {

#define _SEHX_HANDLE \
                                                                               \
      break;                                                                   \
     }                                                                         \
                                                                               \
     _SEHLeave();                                                              \
    }                                                                          \
    else                                                                       \
    {                                                                          \
     _SEHLeave();

#define _SEHX_END \
    }                                                                          \
                                                                               \
    if(_SEHHandlers.SH_Finally)                                                \
     _SEHHandlers.SH_Finally(_SEHPortableFrame);                               \
   }                                                                           \
  }                                                                            \
 }

#define _SEHX_LEAVE break

#define _SEHX_GetExceptionCode() (unsigned long)(_SEHPortableFrame->SPF_Code)

#define _SEHX_GetExceptionPointers() \
 ((struct _EXCEPTION_POINTERS *)_SEHExceptionPointers)

#define _SEHX_AbnormalTermination() (_SEHPortableFrame->SPF_Code != 0)

/* New syntax */

/*
 NOTE: do not move, remove or modify any instance of _SEH2_ASSUME and
 _SEH2_ASSUMING without doing extensive tests for correctness. Compilers can
 generate the wrong code in presence of __assume in unpredictable ways. BE SURE
 IT DOESN'T HAPPEN
*/
#if defined(_MSC_VER) && (_MSC_VER > 1200)
# define _SEH2_ASSUME(X_) __assume(X_)
# if !defined(_SEH_NO_NATIVE_NLG)
 /*
  If we use the native setjmp, the compiler stops keeping track of variables, so
  their actual values don't matter anymore. Optimize out some assignments
 */
#  define _SEH2_ASSUMING(X_)
# else
 /* No native setjmp, no magic, no assumptions. Actually set the values */
#  define _SEH2_ASSUMING(X_) X_
# endif
#else
# define _SEH2_ASSUME(X_)
# define _SEH2_ASSUMING(X_) X_
#endif

#ifdef __cplusplus
# define _SEH2_INIT_CONST static const
#else
# define _SEH2_INIT_CONST register const
#endif

#define _SEH_LEAVE break

#define _SEH_TRY \
 {                                                                             \
  _SEH2_INIT_CONST int _SEH2TopTryLevel = (_SEHScopeKind != 0);                \
  _SEHPortableFrame_t * const _SEH2CurPortableFrame = _SEHPortableFrame;       \
                                                                               \
  {                                                                            \
   static const int _SEHScopeKind = 0;                                         \
   register int _SEH2State = 0;                                                \
   register int _SEH2Handle = 0;                                               \
   _SEHFrame_t _SEH2Frame;                                                     \
   _SEHTryLevel_t _SEH2TryLevel;                                               \
   _SEHPortableFrame_t * const _SEHPortableFrame =                             \
    _SEH2TopTryLevel ? &_SEH2Frame.SEH_Header : _SEH2CurPortableFrame;         \
                                                                               \
   (void)_SEHScopeKind;                                                        \
   (void)_SEHPortableFrame;                                                    \
   (void)_SEH2Handle;                                                          \
                                                                               \
   for(;;)                                                                     \
   {                                                                           \
    if(_SEH2State)                                                             \
    {                                                                          \
     for(;;)                                                                   \
     {                                                                         \
      {

#define _SEH_EXCEPT(FILTER_) \
      }                                                                        \
                                                                               \
      break;                                                                   \
     }                                                                         \
                                                                               \
     _SEH2_ASSUME(_SEH2Handle == 0);                                           \
     break;                                                                    \
    }                                                                          \
    else                                                                       \
    {                                                                          \
     _SEH_DECLARE_HANDLERS((FILTER_), 0);                                      \
                                                                               \
     _SEH2TryLevel.ST_Header.SPT_Handlers = &_SEHHandlers;                     \
                                                                               \
     if(_SEH2TopTryLevel)                                                      \
     {                                                                         \
      if(&_SEHLocals != _SEHDummyLocals)                                       \
       _SEH2Frame.SEH_Locals = &_SEHLocals;                                    \
                                                                               \
      _SEH2Frame.SEH_Header.SPF_Handler = _SEHCompilerSpecificHandler;         \
      _SEHEnterFrame(&_SEH2Frame.SEH_Header, &_SEH2TryLevel.ST_Header);        \
     }                                                                         \
     else                                                                      \
      _SEHEnterTry(&_SEH2TryLevel.ST_Header);                                  \
                                                                               \
     if((_SEH2Handle = _SEHSetJmp(_SEH2TryLevel.ST_JmpBuf)) == 0)              \
     {                                                                         \
      _SEH2_ASSUMING(++ _SEH2State);                                           \
      _SEH2_ASSUME(_SEH2State != 0);                                           \
      continue;                                                                \
     }                                                                         \
     else                                                                      \
     {                                                                         \
      break;                                                                   \
     }                                                                         \
    }                                                                          \
                                                                               \
    break;                                                                     \
   }                                                                           \
                                                                               \
   _SEHLeave();                                                                \
                                                                               \
   if(_SEH2Handle) \
   {

#define _SEH_FINALLY(FINALLY_) \
      }                                                                        \
                                                                               \
      break;                                                                   \
     }                                                                         \
                                                                               \
     _SEHLeave();                                                              \
     break;                                                                    \
    }                                                                          \
    else                                                                       \
    {                                                                          \
     _SEH_DECLARE_HANDLERS(0, (FINALLY_));                                     \
                                                                               \
     _SEH2TryLevel.ST_Header.SPT_Handlers = &_SEHHandlers;                     \
                                                                               \
     if(_SEH2TopTryLevel)                                                      \
     {                                                                         \
      if(&_SEHLocals != _SEHDummyLocals)                                       \
       _SEH2Frame.SEH_Locals = &_SEHLocals;                                    \
                                                                               \
      _SEH2Frame.SEH_Header.SPF_Handler = 0;                                   \
      _SEHEnterFrame(&_SEH2Frame.SEH_Header, &_SEH2TryLevel.ST_Header);        \
     }                                                                         \
     else                                                                      \
      _SEHEnterTry(&_SEH2TryLevel.ST_Header);                                  \
                                                                               \
     ++ _SEH2State;                                                            \
     _SEH2_ASSUME(_SEH2State != 0);                                            \
     continue;                                                                 \
    }                                                                          \
                                                                               \
    break;                                                                     \
   }                                                                           \
                                                                               \
   (FINALLY_)(&_SEH2Frame.SEH_Header);                                         \
   if(0)                                                                       \
   {

#define _SEH_END \
   } \
  }                                                                            \
 }

#define _SEH_HANDLE _SEH_EXCEPT(_SEH_STATIC_FILTER(_SEH_EXECUTE_HANDLER))

#define _SEH_GetExceptionCode     _SEHX_GetExceptionCode
#define _SEH_GetExceptionPointers _SEHX_GetExceptionPointers
#define _SEH_AbnormalTermination  _SEHX_AbnormalTermination

#endif

/* EOF */