include/wine/exception.h

   1 /*
   2  * Wine exception handling
   3  *
   4  * Copyright (c) 1999 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #ifndef __WINE_WINE_EXCEPTION_H
  22 #define __WINE_WINE_EXCEPTION_H
  23
  24 #include <setjmp.h>
  25 #include <windef.h>
  26
  27 /* The following definitions allow using exceptions in Wine and Winelib code
  28  *
  29  * They should be used like this:
  30  *
  31  * __TRY
  32  * {
  33  *     do some stuff that can raise an exception
  34  * }
  35  * __EXCEPT(filter_func,param)
  36  * {
  37  *     handle the exception here
  38  * }
  39  * __ENDTRY
  40  *
  41  * or
  42  *
  43  * __TRY
  44  * {
  45  *     do some stuff that can raise an exception
  46  * }
  47  * __FINALLY(finally_func,param)
  48  *
  49  * The filter_func must be defined with the WINE_EXCEPTION_FILTER
  50  * macro, and return one of the EXCEPTION_* code; it can use
  51  * GetExceptionInformation and GetExceptionCode to retrieve the
  52  * exception info.
  53  *
  54  * The finally_func must be defined with the WINE_FINALLY_FUNC macro.
  55  *
  56  * Warning: inside a __TRY or __EXCEPT block, 'break' or 'continue' statements
  57  *          break out of the current block. You cannot use 'return', 'goto'
  58  *          or 'longjmp' to leave a __TRY block, as this will surely crash.
  59  *          You can use them to leave a __EXCEPT block though.
  60  *
  61  * -- AJ
  62  */
  63
  64 /* Define this if you want to use your compiler built-in __try/__except support.
  65  * This is only useful when compiling to a native Windows binary, as the built-in
  66  * compiler exceptions will most certainly not work under Winelib.
  67  */
  68 #ifdef USE_COMPILER_EXCEPTIONS
  69
  70 #define __TRY __try
  71 #define __EXCEPT(func) __except((func)(GetExceptionInformation()))
  72 #define __FINALLY(func) __finally { (func)(!AbnormalTermination()); }
  73 #define __ENDTRY /*nothing*/
  74
  75 #else  /* USE_COMPILER_EXCEPTIONS */
  76
  77 #ifndef __GNUC__
  78 #define __attribute__(x) /* nothing */
  79 #endif
  80
  81 #define __TRY \
  82     do { __WINE_FRAME __f; \
  83          int __first = 1; \
  84          for (;;) if (!__first) \
  85          { \
  86              do {
  87
  88 #define __EXCEPT(func) \
  89              } while(0); \
  90              __wine_pop_frame( &__f.frame ); \
  91              break; \
  92          } else { \
  93              __f.frame.Handler = __wine_exception_handler; \
  94              __f.u.filter = (func); \
  95              __wine_push_frame( &__f.frame ); \
  96              if (sigsetjmp( __f.jmp, 1 )) { \
  97                  const __WINE_FRAME * const __eptr __attribute__((unused)) = &__f; \
  98                  do {
  99
 100 #define __ENDTRY \
 101                  } while (0); \
 102                  break; \
 103              } \
 104              __first = 0; \
 105          } \
 106     } while (0);
 107
 108 #define __FINALLY(func) \
 109              } while(0); \
 110              __wine_pop_frame( &__f.frame ); \
 111              (func)(1); \
 112              break; \
 113          } else { \
 114              __f.frame.Handler = __wine_finally_handler; \
 115              __f.u.finally_func = (func); \
 116              __wine_push_frame( &__f.frame ); \
 117              __first = 0; \
 118          } \
 119     } while (0);
 120
 121
 122 typedef DWORD (CALLBACK *__WINE_FILTER)(PEXCEPTION_POINTERS);
 123 typedef void (CALLBACK *__WINE_FINALLY)(BOOL);
 124
 125 #define WINE_EXCEPTION_FILTER(func) DWORD WINAPI func( EXCEPTION_POINTERS *__eptr )
 126 #define WINE_FINALLY_FUNC(func) void WINAPI func( BOOL __normal )
 127
 128 #define GetExceptionInformation() (__eptr)
 129 #define GetExceptionCode()        (__eptr->ExceptionRecord->ExceptionCode)
 130 #define AbnormalTermination()     (!__normal)
 131
 132 typedef struct __tagWINE_FRAME
 133 {
 134     EXCEPTION_REGISTRATION_RECORD frame;
 135     union
 136     {
 137         /* exception data */
 138         __WINE_FILTER filter;
 139         /* finally data */
 140         __WINE_FINALLY finally_func;
 141     } u;
 142     sigjmp_buf jmp;
 143     /* hack to make GetExceptionCode() work in handler */
 144     DWORD ExceptionCode;
 145     const struct __tagWINE_FRAME *ExceptionRecord;
 146 } __WINE_FRAME;
 147
 148 extern DWORD __wine_exception_handler( PEXCEPTION_RECORD record, EXCEPTION_REGISTRATION_RECORD *frame,
 149                                        CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher );
 150 extern DWORD __wine_finally_handler( PEXCEPTION_RECORD record, EXCEPTION_REGISTRATION_RECORD *frame,
 151                                      CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher );
 152
 153 #endif /* USE_COMPILER_EXCEPTIONS */
 154
 155 static inline EXCEPTION_REGISTRATION_RECORD *__wine_push_frame( EXCEPTION_REGISTRATION_RECORD *frame )
 156 {
 157 #if defined(__GNUC__) && defined(__i386__)
 158     EXCEPTION_REGISTRATION_RECORD *prev;
 159     __asm__ __volatile__(".byte 0x64\n\tmovl (0),%0"
 160                          "\n\tmovl %0,(%1)"
 161                          "\n\t.byte 0x64\n\tmovl %1,(0)"
 162                          : "=&r" (prev) : "r" (frame) : "memory" );
 163     return prev;
 164 #else
 165     NT_TIB *teb = (NT_TIB *)NtCurrentTeb();
 166     frame->Prev = (void *)teb->ExceptionList;
 167     teb->ExceptionList = (void *)frame;
 168     return frame->Prev;
 169 #endif
 170 }
 171
 172 static inline EXCEPTION_REGISTRATION_RECORD *__wine_pop_frame( EXCEPTION_REGISTRATION_RECORD *frame )
 173 {
 174 #if defined(__GNUC__) && defined(__i386__)
 175     __asm__ __volatile__(".byte 0x64\n\tmovl %0,(0)"
 176                          : : "r" (frame->Prev) : "memory" );
 177     return frame->Prev;
 178
 179 #else
 180     NT_TIB *teb = (NT_TIB *)NtCurrentTeb();
 181     teb->ExceptionList = (void *)frame->Prev;
 182     return frame->Prev;
 183 #endif
 184 }
 185
 186
 187 /* Wine-specific exceptions codes */
 188
 189 #define EXCEPTION_WINE_STUB       0x80000100  /* stub entry point called */
 190 #define EXCEPTION_WINE_ASSERTION  0x80000101  /* assertion failed */
 191
 192 /* unhandled return status from vm86 mode */
 193 #define EXCEPTION_VM86_INTx       0x80000110
 194 #define EXCEPTION_VM86_STI        0x80000111
 195 #define EXCEPTION_VM86_PICRETURN  0x80000112
 196
 197 extern void __wine_enter_vm86( CONTEXT *context );
 198
 199 #endif  /* __WINE_WINE_EXCEPTION_H */