git.oblomov.eu Git - wine/blob - include/wine/exception.h

   1 /*
   2  * Wine exception handling
   3  *
   4  * Copyright (c) 1999 Alexandre Julliard
   5  */
   6
   7 #ifndef __WINE_WINE_EXCEPTION_H
   8 #define __WINE_WINE_EXCEPTION_H
   9
  10 #include <setjmp.h>
  11 #include "winnt.h"
  12 #include "thread.h"
  13
  14 /* The following definitions allow using exceptions in Wine and Winelib code
  15  *
  16  * They should be used like this:
  17  *
  18  * __TRY
  19  * {
  20  *     do some stuff that can raise an exception
  21  * }
  22  * __EXCEPT(filter_func,param)
  23  * {
  24  *     handle the exception here
  25  * }
  26  * __ENDTRY
  27  *
  28  * or
  29  *
  30  * __TRY
  31  * {
  32  *     do some stuff that can raise an exception
  33  * }
  34  * __FINALLY(finally_func,param)
  35  *
  36  * The filter_func must be defined with the WINE_EXCEPTION_FILTER
  37  * macro, and return one of the EXCEPTION_* code; it can use
  38  * GetExceptionInformation and GetExceptionCode to retrieve the
  39  * exception info.
  40  *
  41  * The finally_func must be defined with the WINE_FINALLY_FUNC macro.
  42  *
  43  * Warning: inside a __TRY or __EXCEPT block, 'break' or 'continue' statements
  44  *          break out of the current block. You cannot use 'return', 'goto'
  45  *          or 'longjmp' to leave a __TRY block, as this will surely crash.
  46  *          You can use them to leave a __EXCEPT block though.
  47  *
  48  * -- AJ
  49  */
  50
  51 /* Define this if you want to use your compiler built-in __try/__except support.
  52  * This is only useful when compiling to a native Windows binary, as the built-in
  53  * compiler exceptions will most certainly not work under Winelib.
  54  */
  55 #ifdef USE_COMPILER_EXCEPTIONS
  56
  57 #define __TRY __try
  58 #define __EXCEPT(func) __except((func)(GetExceptionInformation()))
  59 #define __FINALLY(func) __finally { (func)(!AbnormalTermination()); }
  60 #define __ENDTRY /*nothing*/
  61
  62 #else  /* USE_COMPILER_EXCEPTIONS */
  63
  64 #define __TRY \
  65     do { __WINE_FRAME __f; \
  66          int __first = 1; \
  67          for (;;) if (!__first) \
  68          { \
  69              do {
  70
  71 #define __EXCEPT(func) \
  72              } while(0); \
  73              EXC_pop_frame( &__f.frame ); \
  74              break; \
  75          } else { \
  76              __f.frame.Handler = (PEXCEPTION_HANDLER)WINE_exception_handler; \
  77              __f.u.filter = (func); \
  78              EXC_push_frame( &__f.frame ); \
  79              if (setjmp( __f.jmp)) { \
  80                  const __WINE_FRAME * const __eptr WINE_UNUSED = &__f; \
  81                  do {
  82
  83 #define __ENDTRY \
  84                  } while (0); \
  85                  break; \
  86              } \
  87              __first = 0; \
  88          } \
  89     } while (0);
  90
  91 #define __FINALLY(func) \
  92              } while(0); \
  93              EXC_pop_frame( &__f.frame ); \
  94              (func)(1); \
  95              break; \
  96          } else { \
  97              __f.frame.Handler = (PEXCEPTION_HANDLER)WINE_finally_handler; \
  98              __f.u.finally_func = (func); \
  99              EXC_push_frame( &__f.frame ); \
 100              __first = 0; \
 101          } \
 102     } while (0);
 103
 104
 105 typedef DWORD (*CALLBACK __WINE_FILTER)(PEXCEPTION_POINTERS);
 106 typedef void (*CALLBACK __WINE_FINALLY)(BOOL);
 107
 108 #define WINE_EXCEPTION_FILTER(func) DWORD WINAPI func( EXCEPTION_POINTERS *__eptr )
 109 #define WINE_FINALLY_FUNC(func) void WINAPI func( BOOL __normal )
 110
 111 #define GetExceptionInformation() (__eptr)
 112 #define GetExceptionCode()        (__eptr->ExceptionRecord->ExceptionCode)
 113 #define AbnormalTermination()     (!__normal)
 114
 115 typedef struct __tagWINE_FRAME
 116 {
 117     EXCEPTION_FRAME frame;
 118     union
 119     {
 120         /* exception data */
 121         __WINE_FILTER filter;
 122         /* finally data */
 123         __WINE_FINALLY finally_func;
 124     } u;
 125     jmp_buf jmp;
 126     /* hack to make GetExceptionCode() work in handler */
 127     DWORD ExceptionCode;
 128     const struct __tagWINE_FRAME *ExceptionRecord;
 129 } __WINE_FRAME;
 130
 131 extern DWORD WINAPI WINE_exception_handler( PEXCEPTION_RECORD record, EXCEPTION_FRAME *frame,
 132                                             CONTEXT *context, LPVOID pdispatcher );
 133 extern DWORD WINAPI WINE_finally_handler( PEXCEPTION_RECORD record, EXCEPTION_FRAME *frame,
 134                                           CONTEXT *context, LPVOID pdispatcher );
 135
 136 #endif /* USE_COMPILER_EXCEPTIONS */
 137
 138 static inline EXCEPTION_FRAME *EXC_push_frame( EXCEPTION_FRAME *frame )
 139 {
 140 #if defined(__GNUC__) && defined(__i386__)
 141     EXCEPTION_FRAME *prev;
 142     __asm__ __volatile__(".byte 0x64\n\tmovl (0),%0"
 143                          "\n\tmovl %0,(%1)"
 144                          "\n\t.byte 0x64\n\tmovl %1,(0)"
 145                          : "=&r" (prev) : "r" (frame) : "memory" );
 146     return prev;
 147 #else
 148     TEB * teb = CURRENT();
 149     frame->Prev = teb->except;
 150     teb->except = frame;
 151     return frame->Prev;
 152 #endif
 153 }
 154
 155 static inline EXCEPTION_FRAME *EXC_pop_frame( EXCEPTION_FRAME *frame )
 156 {
 157 #if defined(__GNUC__) && defined(__i386__)
 158     __asm__ __volatile__(".byte 0x64\n\tmovl %0,(0)"
 159                          : : "r" (frame->Prev) : "memory" );
 160     return frame->Prev;
 161
 162 #else
 163     CURRENT()->except = frame->Prev;
 164     return frame->Prev;
 165 #endif
 166 }
 167
 168 #ifdef __WINE__
 169 typedef DWORD (*DEBUGHOOK)( EXCEPTION_RECORD *, CONTEXT *, BOOL );
 170 extern void EXC_SetDebugEventHook( DEBUGHOOK hook );
 171 extern DEBUGHOOK EXC_GetDebugEventHook(void);
 172 extern void EXC_InitHandlers(void);
 173 #endif
 174
 175 #endif  /* __WINE_WINE_EXCEPTION_H */