| [7862] | 1 | #ifndef __DBBWRAP_H__
 | 
|---|
 | 2 | #define __DBBWRAP_H__
 | 
|---|
 | 3 | 
 | 
|---|
 | 4 | #include <odinwrap.h>
 | 
|---|
 | 5 | 
 | 
|---|
| [10395] | 6 | #define NO_CALLER
 | 
|---|
 | 7 | #ifndef NO_CALLER
 | 
|---|
 | 8 | #define DBGWRAP_CALLER_FMT  "%08x "
 | 
|---|
 | 9 | #define DBGWRAP_CALLER_ARG  ((unsigned *)&(arg1))[-1],
 | 
|---|
 | 10 | #else
 | 
|---|
 | 11 | #define DBGWRAP_CALLER_FMT
 | 
|---|
 | 12 | #define DBGWRAP_CALLER_ARG
 | 
|---|
 | 13 | #endif
 | 
|---|
 | 14 | 
 | 
|---|
| [7862] | 15 | typedef DWORD (* WIN32API DBG_WINPROC0)();
 | 
|---|
 | 16 | typedef DWORD (* WIN32API DBG_WINPROC4)(DWORD);
 | 
|---|
 | 17 | typedef DWORD (* WIN32API DBG_WINPROC4_NORET)(DWORD);
 | 
|---|
 | 18 | typedef DWORD (* WIN32API DBG_WINPROC8)(DWORD, DWORD);
 | 
|---|
 | 19 | typedef DWORD (* WIN32API DBG_WINPROC12)(DWORD, DWORD, DWORD);
 | 
|---|
 | 20 | typedef DWORD (* WIN32API DBG_WINPROC16)(DWORD, DWORD, DWORD, DWORD);
 | 
|---|
 | 21 | typedef DWORD (* WIN32API DBG_WINPROC20)(DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
 | 22 | typedef DWORD (* WIN32API DBG_WINPROC24)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
 | 23 | typedef DWORD (* WIN32API DBG_WINPROC28)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
 | 24 | typedef DWORD (* WIN32API DBG_WINPROC32)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
 | 25 | typedef DWORD (* WIN32API DBG_WINPROC36)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
 | 26 | typedef DWORD (* WIN32API DBG_WINPROC40)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
 | 27 | typedef DWORD (* WIN32API DBG_WINPROC44)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
 | 28 | typedef DWORD (* WIN32API DBG_WINPROC48)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
| [7922] | 29 | typedef DWORD (* WIN32API DBG_WINPROC52)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
| [9430] | 30 | typedef DWORD (* WIN32API DBG_WINPROC56)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
 | 
|---|
| [7862] | 31 | 
 | 
|---|
| [9430] | 32 | 
 | 
|---|
| [7862] | 33 | #define DEBUGWRAP0(a) \
 | 
|---|
 | 34 | DWORD WIN32API Dbg##a()             \
 | 
|---|
 | 35 | {                                          \
 | 
|---|
 | 36 |     DWORD ret;                             \
 | 
|---|
 | 37 |     dprintf((DBGWRAP_MODULE": %s", #a));         \
 | 
|---|
 | 38 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 39 |     ret = (DWORD)a();         \
 | 
|---|
 | 40 |     dbg_ThreadPopCall(); \
 | 
|---|
 | 41 |     dprintf((DBGWRAP_MODULE": %s returned %x", #a, ret)); \
 | 
|---|
 | 42 |     return ret;                            \
 | 
|---|
 | 43 | }
 | 
|---|
 | 44 | 
 | 
|---|
 | 45 | #define DEBUGWRAP0_NORET(a) \
 | 
|---|
 | 46 | void WIN32API Dbg##a()             \
 | 
|---|
 | 47 | {                                          \
 | 
|---|
 | 48 |     DWORD ret;                             \
 | 
|---|
 | 49 |     dprintf((DBGWRAP_MODULE": %s", #a));         \
 | 
|---|
 | 50 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 51 |     a();         \
 | 
|---|
 | 52 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 53 |     dprintf((DBGWRAP_MODULE": %s returned (void)\n", #a));  \
 | 
|---|
| [7862] | 54 | }
 | 
|---|
 | 55 | 
 | 
|---|
 | 56 | #define DEBUGWRAP4(a) \
 | 
|---|
 | 57 | DWORD WIN32API Dbg##a(DWORD arg1)             \
 | 
|---|
 | 58 | {                                          \
 | 
|---|
 | 59 |     DWORD ret;                             \
 | 
|---|
| [10395] | 60 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x\n", DBGWRAP_CALLER_ARG #a, arg1));         \
 | 
|---|
| [7862] | 61 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 62 |     ret = ((DBG_WINPROC4)a)(arg1);         \
 | 
|---|
 | 63 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 64 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 65 |     return ret;                            \
 | 
|---|
 | 66 | }
 | 
|---|
 | 67 | 
 | 
|---|
 | 68 | #define DEBUGWRAP4_NORET(a) \
 | 
|---|
 | 69 | void WIN32API Dbg##a(DWORD arg1)             \
 | 
|---|
 | 70 | {                                          \
 | 
|---|
| [10395] | 71 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x\n", DBGWRAP_CALLER_ARG #a, arg1));         \
 | 
|---|
| [7862] | 72 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 73 |     ((DBG_WINPROC4_NORET)a)(arg1);         \
 | 
|---|
 | 74 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 75 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned void\n", DBGWRAP_CALLER_ARG #a));  \
 | 
|---|
| [7862] | 76 | }
 | 
|---|
 | 77 | 
 | 
|---|
 | 78 | #define DEBUGWRAP8(a) \
 | 
|---|
 | 79 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2) \
 | 
|---|
 | 80 | {                                          \
 | 
|---|
 | 81 |     DWORD ret;                             \
 | 
|---|
| [10395] | 82 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2));         \
 | 
|---|
| [7862] | 83 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 84 |     ret = ((DBG_WINPROC8)a)(arg1, arg2);         \
 | 
|---|
 | 85 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 86 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 87 |     return ret;                            \
 | 
|---|
 | 88 | }
 | 
|---|
 | 89 | 
 | 
|---|
| [8539] | 90 | #define DEBUGWRAP8_NORET(a) \
 | 
|---|
 | 91 | void WIN32API Dbg##a(DWORD arg1, DWORD arg2) \
 | 
|---|
 | 92 | {                                          \
 | 
|---|
| [10395] | 93 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2));         \
 | 
|---|
| [8539] | 94 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 95 |     ((DBG_WINPROC8)a)(arg1, arg2);         \
 | 
|---|
 | 96 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 97 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned void\n", DBGWRAP_CALLER_ARG #a)); \
 | 
|---|
| [8539] | 98 | }
 | 
|---|
 | 99 | 
 | 
|---|
| [7862] | 100 | #define DEBUGWRAP12(a) \
 | 
|---|
 | 101 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3) \
 | 
|---|
 | 102 | {                                          \
 | 
|---|
 | 103 |     DWORD ret;                             \
 | 
|---|
| [10395] | 104 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3));         \
 | 
|---|
| [7862] | 105 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 106 |     ret = ((DBG_WINPROC12)a)(arg1, arg2, arg3);         \
 | 
|---|
 | 107 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 108 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 109 |     return ret;                            \
 | 
|---|
 | 110 | }
 | 
|---|
 | 111 | 
 | 
|---|
 | 112 | #define DEBUGWRAP16(a) \
 | 
|---|
 | 113 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4) \
 | 
|---|
 | 114 | {                                          \
 | 
|---|
 | 115 |     DWORD ret;                             \
 | 
|---|
| [10395] | 116 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4));         \
 | 
|---|
| [7862] | 117 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 118 |     ret = ((DBG_WINPROC16)a)(arg1, arg2, arg3, arg4);         \
 | 
|---|
 | 119 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 120 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 121 |     return ret;                            \
 | 
|---|
 | 122 | }
 | 
|---|
 | 123 | 
 | 
|---|
 | 124 | #define DEBUGWRAP20(a) \
 | 
|---|
 | 125 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5) \
 | 
|---|
 | 126 | {                                          \
 | 
|---|
 | 127 |     DWORD ret;                             \
 | 
|---|
| [10395] | 128 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5));         \
 | 
|---|
| [7862] | 129 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 130 |     ret = ((DBG_WINPROC20)a)(arg1, arg2, arg3, arg4, arg5);         \
 | 
|---|
 | 131 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 132 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 133 |     return ret;                            \
 | 
|---|
 | 134 | }
 | 
|---|
 | 135 | 
 | 
|---|
 | 136 | #define DEBUGWRAP24(a) \
 | 
|---|
 | 137 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6) \
 | 
|---|
 | 138 | {                                          \
 | 
|---|
 | 139 |     DWORD ret;                             \
 | 
|---|
| [10395] | 140 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6));         \
 | 
|---|
| [7862] | 141 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 142 |     ret = ((DBG_WINPROC24)a)(arg1, arg2, arg3, arg4, arg5, arg6);         \
 | 
|---|
 | 143 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 144 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 145 |     return ret;                            \
 | 
|---|
 | 146 | }
 | 
|---|
 | 147 | 
 | 
|---|
 | 148 | #define DEBUGWRAP28(a) \
 | 
|---|
 | 149 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7) \
 | 
|---|
 | 150 | {                                          \
 | 
|---|
 | 151 |     DWORD ret;                             \
 | 
|---|
| [10395] | 152 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7));         \
 | 
|---|
| [7862] | 153 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 154 |     ret = ((DBG_WINPROC28)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);         \
 | 
|---|
 | 155 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 156 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 157 |     return ret;                            \
 | 
|---|
 | 158 | }
 | 
|---|
 | 159 | 
 | 
|---|
 | 160 | #define DEBUGWRAP32(a) \
 | 
|---|
 | 161 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8) \
 | 
|---|
 | 162 | {                                          \
 | 
|---|
 | 163 |     DWORD ret;                             \
 | 
|---|
| [10395] | 164 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));         \
 | 
|---|
| [7862] | 165 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 166 |     ret = ((DBG_WINPROC32)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);         \
 | 
|---|
 | 167 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 168 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 169 |     return ret;                            \
 | 
|---|
 | 170 | }
 | 
|---|
 | 171 | 
 | 
|---|
 | 172 | #define DEBUGWRAP36(a) \
 | 
|---|
 | 173 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9) \
 | 
|---|
 | 174 | {                                          \
 | 
|---|
 | 175 |     DWORD ret;                             \
 | 
|---|
| [10395] | 176 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));         \
 | 
|---|
| [7862] | 177 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 178 |     ret = ((DBG_WINPROC36)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);         \
 | 
|---|
 | 179 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 180 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 181 |     return ret;                            \
 | 
|---|
 | 182 | }
 | 
|---|
 | 183 | 
 | 
|---|
 | 184 | #define DEBUGWRAP40(a) \
 | 
|---|
 | 185 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10) \
 | 
|---|
 | 186 | {                                          \
 | 
|---|
 | 187 |     DWORD ret;                             \
 | 
|---|
| [10395] | 188 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));         \
 | 
|---|
| [7862] | 189 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 190 |     ret = ((DBG_WINPROC40)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);         \
 | 
|---|
 | 191 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 192 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 193 |     return ret;                            \
 | 
|---|
 | 194 | }
 | 
|---|
 | 195 | 
 | 
|---|
 | 196 | #define DEBUGWRAP44(a) \
 | 
|---|
 | 197 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11) \
 | 
|---|
 | 198 | {                                          \
 | 
|---|
 | 199 |     DWORD ret;                             \
 | 
|---|
| [10395] | 200 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));         \
 | 
|---|
| [7862] | 201 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 202 |     ret = ((DBG_WINPROC44)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);         \
 | 
|---|
 | 203 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 204 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 205 |     return ret;                            \
 | 
|---|
 | 206 | }
 | 
|---|
 | 207 | 
 | 
|---|
 | 208 | #define DEBUGWRAP48(a) \
 | 
|---|
 | 209 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12) \
 | 
|---|
 | 210 | {                                          \
 | 
|---|
 | 211 |     DWORD ret;                             \
 | 
|---|
| [10395] | 212 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));         \
 | 
|---|
| [7862] | 213 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 214 |     ret = ((DBG_WINPROC48)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);         \
 | 
|---|
 | 215 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 216 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 217 |     return ret;                            \
 | 
|---|
 | 218 | }
 | 
|---|
 | 219 | 
 | 
|---|
| [7922] | 220 | #define DEBUGWRAP52(a) \
 | 
|---|
 | 221 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12, DWORD arg13) \
 | 
|---|
 | 222 | {                                          \
 | 
|---|
 | 223 |     DWORD ret;                             \
 | 
|---|
| [10395] | 224 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));         \
 | 
|---|
| [7922] | 225 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 226 |     ret = ((DBG_WINPROC52)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);         \
 | 
|---|
 | 227 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 228 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7922] | 229 |     return ret;                            \
 | 
|---|
 | 230 | }
 | 
|---|
 | 231 | 
 | 
|---|
| [9430] | 232 | #define DEBUGWRAP56(a) \
 | 
|---|
 | 233 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12, DWORD arg13, DWORD arg14) \
 | 
|---|
 | 234 | {                                          \
 | 
|---|
 | 235 |     DWORD ret;                             \
 | 
|---|
| [10395] | 236 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));         \
 | 
|---|
| [9430] | 237 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 238 |     ret = ((DBG_WINPROC56)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);         \
 | 
|---|
 | 239 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 240 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [9430] | 241 |     return ret;                            \
 | 
|---|
 | 242 | }
 | 
|---|
 | 243 | 
 | 
|---|
| [7862] | 244 | //level 2 logging
 | 
|---|
 | 245 | 
 | 
|---|
 | 246 | #define DEBUGWRAP_LVL2_0(a) \
 | 
|---|
 | 247 | DWORD WIN32API Dbg##a()             \
 | 
|---|
 | 248 | {                                          \
 | 
|---|
 | 249 |     DWORD ret;                             \
 | 
|---|
| [10395] | 250 |     dprintf2((DBGWRAP_MODULE": %s\n", #a));         \
 | 
|---|
| [7862] | 251 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 252 |     ret = ((DBG_WINPROC0)a)();         \
 | 
|---|
 | 253 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 254 |     dprintf2((DBGWRAP_MODULE": %s returned %x\n", #a, ret)); \
 | 
|---|
| [7862] | 255 |     return ret;                            \
 | 
|---|
 | 256 | }
 | 
|---|
 | 257 | 
 | 
|---|
 | 258 | #define DEBUGWRAP_LVL2_4(a) \
 | 
|---|
 | 259 | DWORD WIN32API Dbg##a(DWORD arg1)             \
 | 
|---|
 | 260 | {                                          \
 | 
|---|
 | 261 |     DWORD ret;                             \
 | 
|---|
| [10395] | 262 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x\n", DBGWRAP_CALLER_ARG #a, arg1));         \
 | 
|---|
| [7862] | 263 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 264 |     ret = ((DBG_WINPROC4)a)(arg1);         \
 | 
|---|
 | 265 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 266 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 267 |     return ret;                            \
 | 
|---|
 | 268 | }
 | 
|---|
 | 269 | 
 | 
|---|
 | 270 | #define DEBUGWRAP_LVL2_8(a) \
 | 
|---|
 | 271 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2) \
 | 
|---|
 | 272 | {                                          \
 | 
|---|
 | 273 |     DWORD ret;                             \
 | 
|---|
| [10395] | 274 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2));         \
 | 
|---|
| [7862] | 275 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 276 |     ret = ((DBG_WINPROC8)a)(arg1, arg2);         \
 | 
|---|
 | 277 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 278 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 279 |     return ret;                            \
 | 
|---|
 | 280 | }
 | 
|---|
 | 281 | 
 | 
|---|
 | 282 | #define DEBUGWRAP_LVL2_12(a) \
 | 
|---|
 | 283 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3) \
 | 
|---|
 | 284 | {                                          \
 | 
|---|
 | 285 |     DWORD ret;                             \
 | 
|---|
| [10395] | 286 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3));         \
 | 
|---|
| [7862] | 287 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 288 |     ret = ((DBG_WINPROC12)a)(arg1, arg2, arg3);         \
 | 
|---|
 | 289 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 290 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 291 |     return ret;                            \
 | 
|---|
 | 292 | }
 | 
|---|
 | 293 | 
 | 
|---|
 | 294 | #define DEBUGWRAP_LVL2_16(a) \
 | 
|---|
 | 295 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4) \
 | 
|---|
 | 296 | {                                          \
 | 
|---|
 | 297 |     DWORD ret;                             \
 | 
|---|
| [10395] | 298 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4));         \
 | 
|---|
| [7862] | 299 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 300 |     ret = ((DBG_WINPROC16)a)(arg1, arg2, arg3, arg4);         \
 | 
|---|
 | 301 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 302 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 303 |     return ret;                            \
 | 
|---|
 | 304 | }
 | 
|---|
 | 305 | 
 | 
|---|
 | 306 | #define DEBUGWRAP_LVL2_20(a) \
 | 
|---|
 | 307 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5) \
 | 
|---|
 | 308 | {                                          \
 | 
|---|
 | 309 |     DWORD ret;                             \
 | 
|---|
| [10395] | 310 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5));         \
 | 
|---|
| [7862] | 311 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 312 |     ret = ((DBG_WINPROC20)a)(arg1, arg2, arg3, arg4, arg5);         \
 | 
|---|
 | 313 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 314 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 315 |     return ret;                            \
 | 
|---|
 | 316 | }
 | 
|---|
 | 317 | 
 | 
|---|
 | 318 | #define DEBUGWRAP_LVL2_24(a) \
 | 
|---|
 | 319 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6) \
 | 
|---|
 | 320 | {                                          \
 | 
|---|
 | 321 |     DWORD ret;                             \
 | 
|---|
| [10395] | 322 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6));         \
 | 
|---|
| [7862] | 323 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 324 |     ret = ((DBG_WINPROC24)a)(arg1, arg2, arg3, arg4, arg5, arg6);         \
 | 
|---|
 | 325 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 326 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 327 |     return ret;                            \
 | 
|---|
 | 328 | }
 | 
|---|
 | 329 | 
 | 
|---|
 | 330 | #define DEBUGWRAP_LVL2_28(a) \
 | 
|---|
 | 331 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7) \
 | 
|---|
 | 332 | {                                          \
 | 
|---|
 | 333 |     DWORD ret;                             \
 | 
|---|
| [10395] | 334 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7));         \
 | 
|---|
| [7862] | 335 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 336 |     ret = ((DBG_WINPROC28)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);         \
 | 
|---|
 | 337 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 338 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 339 |     return ret;                            \
 | 
|---|
 | 340 | }
 | 
|---|
 | 341 | 
 | 
|---|
 | 342 | #define DEBUGWRAP_LVL2_32(a) \
 | 
|---|
 | 343 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8) \
 | 
|---|
 | 344 | {                                          \
 | 
|---|
 | 345 |     DWORD ret;                             \
 | 
|---|
| [10395] | 346 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));         \
 | 
|---|
| [7862] | 347 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 348 |     ret = ((DBG_WINPROC32)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);         \
 | 
|---|
 | 349 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 350 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 351 |     return ret;                            \
 | 
|---|
 | 352 | }
 | 
|---|
 | 353 | 
 | 
|---|
 | 354 | #define DEBUGWRAP_LVL2_36(a) \
 | 
|---|
 | 355 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9) \
 | 
|---|
 | 356 | {                                          \
 | 
|---|
 | 357 |     DWORD ret;                             \
 | 
|---|
| [10395] | 358 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));         \
 | 
|---|
| [7862] | 359 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 360 |     ret = ((DBG_WINPROC36)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);         \
 | 
|---|
 | 361 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 362 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 363 |     return ret;                            \
 | 
|---|
 | 364 | }
 | 
|---|
 | 365 | 
 | 
|---|
 | 366 | #define DEBUGWRAP_LVL2_40(a) \
 | 
|---|
 | 367 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10) \
 | 
|---|
 | 368 | {                                          \
 | 
|---|
 | 369 |     DWORD ret;                             \
 | 
|---|
| [10395] | 370 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));         \
 | 
|---|
| [7862] | 371 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 372 |     ret = ((DBG_WINPROC40)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);         \
 | 
|---|
 | 373 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 374 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 375 |     return ret;                            \
 | 
|---|
 | 376 | }
 | 
|---|
 | 377 | 
 | 
|---|
 | 378 | #define DEBUGWRAP_LVL2_44(a) \
 | 
|---|
 | 379 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11) \
 | 
|---|
 | 380 | {                                          \
 | 
|---|
 | 381 |     DWORD ret;                             \
 | 
|---|
| [10395] | 382 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));         \
 | 
|---|
| [7862] | 383 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 384 |     ret = ((DBG_WINPROC44)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);         \
 | 
|---|
 | 385 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 386 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 387 |     return ret;                            \
 | 
|---|
 | 388 | }
 | 
|---|
 | 389 | 
 | 
|---|
 | 390 | #define DEBUGWRAP_LVL2_48(a) \
 | 
|---|
 | 391 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12) \
 | 
|---|
 | 392 | {                                          \
 | 
|---|
 | 393 |     DWORD ret;                             \
 | 
|---|
| [10395] | 394 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));         \
 | 
|---|
| [7862] | 395 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 396 |     ret = ((DBG_WINPROC48)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);         \
 | 
|---|
 | 397 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 398 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7862] | 399 |     return ret;                            \
 | 
|---|
 | 400 | }
 | 
|---|
 | 401 | 
 | 
|---|
| [7922] | 402 | #define DEBUGWRAP_LVL2_52(a) \
 | 
|---|
 | 403 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12, DWORD arg13) \
 | 
|---|
 | 404 | {         \
 | 
|---|
 | 405 |     DWORD ret;                                 \
 | 
|---|
| [10395] | 406 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));         \
 | 
|---|
| [7922] | 407 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 408 |     ret = ((DBG_WINPROC52)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);         \
 | 
|---|
 | 409 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 410 |     dprintf2((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7922] | 411 |     return ret; \
 | 
|---|
 | 412 | }
 | 
|---|
| [7862] | 413 | 
 | 
|---|
| [7922] | 414 | 
 | 
|---|
| [7902] | 415 | //level 1 logging without function definitions
 | 
|---|
 | 416 | 
 | 
|---|
 | 417 | #define NODEF_DEBUGWRAP0(a) \
 | 
|---|
 | 418 | DWORD WIN32API a();  \
 | 
|---|
 | 419 | DWORD WIN32API Dbg##a()             \
 | 
|---|
 | 420 | {                                          \
 | 
|---|
 | 421 |     DWORD ret;                             \
 | 
|---|
| [10395] | 422 |     dprintf((DBGWRAP_MODULE": %s\n", #a));         \
 | 
|---|
| [7902] | 423 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 424 |     ret = (DWORD)a();         \
 | 
|---|
 | 425 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 426 |     dprintf((DBGWRAP_MODULE": %s returned %x\n", #a, ret)); \
 | 
|---|
| [7902] | 427 |     return ret;                            \
 | 
|---|
 | 428 | }
 | 
|---|
 | 429 | 
 | 
|---|
 | 430 | #define NODEF_DEBUGWRAP0_NORET(a) \
 | 
|---|
 | 431 | void WIN32API a();  \
 | 
|---|
 | 432 | void WIN32API Dbg##a()             \
 | 
|---|
 | 433 | {                                          \
 | 
|---|
 | 434 |     DWORD ret;                             \
 | 
|---|
| [10395] | 435 |     dprintf((DBGWRAP_MODULE": %s\n", #a));         \
 | 
|---|
| [7902] | 436 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 437 |     a();         \
 | 
|---|
 | 438 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 439 |     dprintf((DBGWRAP_MODULE": %s returned (void)\n", #a));  \
 | 
|---|
| [7902] | 440 | }
 | 
|---|
 | 441 | 
 | 
|---|
 | 442 | #define NODEF_DEBUGWRAP4(a) \
 | 
|---|
 | 443 | DWORD WIN32API a(DWORD arg1);             \
 | 
|---|
 | 444 | DWORD WIN32API Dbg##a(DWORD arg1)             \
 | 
|---|
 | 445 | {                                          \
 | 
|---|
 | 446 |     DWORD ret;                             \
 | 
|---|
| [10395] | 447 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x\n", DBGWRAP_CALLER_ARG #a, arg1));         \
 | 
|---|
| [7902] | 448 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 449 |     ret = ((DBG_WINPROC4)a)(arg1);         \
 | 
|---|
 | 450 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 451 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 452 |     return ret;                            \
 | 
|---|
 | 453 | }
 | 
|---|
 | 454 | 
 | 
|---|
 | 455 | #define NODEF_DEBUGWRAP4_NORET(a) \
 | 
|---|
 | 456 | void WIN32API a(DWORD arg1);             \
 | 
|---|
 | 457 | void WIN32API Dbg##a(DWORD arg1)             \
 | 
|---|
 | 458 | {                                          \
 | 
|---|
| [10395] | 459 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x\n", DBGWRAP_CALLER_ARG #a, arg1));         \
 | 
|---|
| [7902] | 460 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 461 |     ((DBG_WINPROC4_NORET)a)(arg1);         \
 | 
|---|
 | 462 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 463 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned (void)\n", DBGWRAP_CALLER_ARG #a));  \
 | 
|---|
| [7902] | 464 | }
 | 
|---|
 | 465 | 
 | 
|---|
 | 466 | #define NODEF_DEBUGWRAP8(a) \
 | 
|---|
 | 467 | DWORD WIN32API a(DWORD arg1, DWORD arg2); \
 | 
|---|
 | 468 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2) \
 | 
|---|
 | 469 | {                                          \
 | 
|---|
 | 470 |     DWORD ret;                             \
 | 
|---|
| [10395] | 471 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2));         \
 | 
|---|
| [7902] | 472 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 473 |     ret = ((DBG_WINPROC8)a)(arg1, arg2);         \
 | 
|---|
 | 474 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 475 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 476 |     return ret;                            \
 | 
|---|
 | 477 | }
 | 
|---|
 | 478 | 
 | 
|---|
 | 479 | #define NODEF_DEBUGWRAP12(a) \
 | 
|---|
 | 480 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3); \
 | 
|---|
 | 481 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3) \
 | 
|---|
 | 482 | {                                          \
 | 
|---|
 | 483 |     DWORD ret;                             \
 | 
|---|
| [10395] | 484 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3));         \
 | 
|---|
| [7902] | 485 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 486 |     ret = ((DBG_WINPROC12)a)(arg1, arg2, arg3);         \
 | 
|---|
 | 487 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 488 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 489 |     return ret;                            \
 | 
|---|
 | 490 | }
 | 
|---|
 | 491 | 
 | 
|---|
 | 492 | #define NODEF_DEBUGWRAP16(a) \
 | 
|---|
 | 493 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4); \
 | 
|---|
 | 494 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4) \
 | 
|---|
 | 495 | {                                          \
 | 
|---|
 | 496 |     DWORD ret;                             \
 | 
|---|
| [10395] | 497 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4));         \
 | 
|---|
| [7902] | 498 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 499 |     ret = ((DBG_WINPROC16)a)(arg1, arg2, arg3, arg4);         \
 | 
|---|
 | 500 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 501 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 502 |     return ret;                            \
 | 
|---|
 | 503 | }
 | 
|---|
 | 504 | 
 | 
|---|
 | 505 | #define NODEF_DEBUGWRAP20(a) \
 | 
|---|
 | 506 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5); \
 | 
|---|
 | 507 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5) \
 | 
|---|
 | 508 | {                                          \
 | 
|---|
 | 509 |     DWORD ret;                             \
 | 
|---|
| [10395] | 510 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5));         \
 | 
|---|
| [7902] | 511 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 512 |     ret = ((DBG_WINPROC20)a)(arg1, arg2, arg3, arg4, arg5);         \
 | 
|---|
 | 513 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 514 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 515 |     return ret;                            \
 | 
|---|
 | 516 | }
 | 
|---|
 | 517 | 
 | 
|---|
 | 518 | #define NODEF_DEBUGWRAP24(a) \
 | 
|---|
 | 519 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6); \
 | 
|---|
 | 520 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6) \
 | 
|---|
 | 521 | {                                          \
 | 
|---|
 | 522 |     DWORD ret;                             \
 | 
|---|
| [10395] | 523 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6));         \
 | 
|---|
| [7902] | 524 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 525 |     ret = ((DBG_WINPROC24)a)(arg1, arg2, arg3, arg4, arg5, arg6);         \
 | 
|---|
 | 526 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 527 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 528 |     return ret;                            \
 | 
|---|
 | 529 | }
 | 
|---|
 | 530 | 
 | 
|---|
 | 531 | #define NODEF_DEBUGWRAP28(a) \
 | 
|---|
 | 532 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7); \
 | 
|---|
 | 533 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7) \
 | 
|---|
 | 534 | {                                          \
 | 
|---|
 | 535 |     DWORD ret;                             \
 | 
|---|
| [10395] | 536 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7));         \
 | 
|---|
| [7902] | 537 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 538 |     ret = ((DBG_WINPROC28)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);         \
 | 
|---|
 | 539 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 540 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 541 |     return ret;                            \
 | 
|---|
 | 542 | }
 | 
|---|
 | 543 | 
 | 
|---|
 | 544 | #define NODEF_DEBUGWRAP32(a) \
 | 
|---|
 | 545 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8); \
 | 
|---|
 | 546 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8) \
 | 
|---|
 | 547 | {                                          \
 | 
|---|
 | 548 |     DWORD ret;                             \
 | 
|---|
| [10395] | 549 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));         \
 | 
|---|
| [7902] | 550 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 551 |     ret = ((DBG_WINPROC32)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);         \
 | 
|---|
 | 552 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 553 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 554 |     return ret;                            \
 | 
|---|
 | 555 | }
 | 
|---|
 | 556 | 
 | 
|---|
 | 557 | #define NODEF_DEBUGWRAP36(a) \
 | 
|---|
 | 558 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9); \
 | 
|---|
 | 559 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9) \
 | 
|---|
 | 560 | {                                          \
 | 
|---|
 | 561 |     DWORD ret;                             \
 | 
|---|
| [10395] | 562 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));         \
 | 
|---|
| [7902] | 563 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 564 |     ret = ((DBG_WINPROC36)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);         \
 | 
|---|
 | 565 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 566 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 567 |     return ret;                            \
 | 
|---|
 | 568 | }
 | 
|---|
 | 569 | 
 | 
|---|
 | 570 | #define NODEF_DEBUGWRAP40(a) \
 | 
|---|
 | 571 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10); \
 | 
|---|
 | 572 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10) \
 | 
|---|
 | 573 | {                                          \
 | 
|---|
 | 574 |     DWORD ret;                             \
 | 
|---|
| [10395] | 575 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));         \
 | 
|---|
| [7902] | 576 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 577 |     ret = ((DBG_WINPROC40)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);         \
 | 
|---|
 | 578 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 579 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 580 |     return ret;                            \
 | 
|---|
 | 581 | }
 | 
|---|
 | 582 | 
 | 
|---|
 | 583 | #define NODEF_DEBUGWRAP44(a) \
 | 
|---|
 | 584 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11); \
 | 
|---|
 | 585 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11) \
 | 
|---|
 | 586 | {                                          \
 | 
|---|
 | 587 |     DWORD ret;                             \
 | 
|---|
| [10395] | 588 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));         \
 | 
|---|
| [7902] | 589 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 590 |     ret = ((DBG_WINPROC44)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);         \
 | 
|---|
 | 591 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 592 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 593 |     return ret;                            \
 | 
|---|
 | 594 | }
 | 
|---|
 | 595 | 
 | 
|---|
 | 596 | #define NODEF_DEBUGWRAP48(a) \
 | 
|---|
 | 597 | DWORD WIN32API a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12); \
 | 
|---|
 | 598 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12) \
 | 
|---|
 | 599 | {                                          \
 | 
|---|
 | 600 |     DWORD ret;                             \
 | 
|---|
| [10395] | 601 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));         \
 | 
|---|
| [7902] | 602 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 603 |     ret = ((DBG_WINPROC48)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);         \
 | 
|---|
 | 604 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 605 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7902] | 606 |     return ret;                            \
 | 
|---|
 | 607 | }
 | 
|---|
 | 608 | 
 | 
|---|
| [7922] | 609 | #define NODEF_DEBUGWRAP52(a) \
 | 
|---|
 | 610 | DWORD WIN32API #a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12, DWORD arg13); \
 | 
|---|
 | 611 | DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5, DWORD arg6, DWORD arg7, DWORD arg8, DWORD arg9, DWORD arg10, DWORD arg11, DWORD arg12, DWORD arg13) \
 | 
|---|
 | 612 | {         \
 | 
|---|
 | 613 |     DWORD ret;                                 \
 | 
|---|
| [10395] | 614 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s %x %x %x %x %x %x %x %x %x %x %x %x %x\n", DBGWRAP_CALLER_ARG #a, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));         \
 | 
|---|
| [7922] | 615 |     dbg_ThreadPushCall(#a); \
 | 
|---|
 | 616 |     ret = ((DBG_WINPROC52)a)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);         \
 | 
|---|
 | 617 |     dbg_ThreadPopCall(); \
 | 
|---|
| [10395] | 618 |     dprintf((DBGWRAP_CALLER_FMT DBGWRAP_MODULE": %s returned %x\n", DBGWRAP_CALLER_ARG #a, ret)); \
 | 
|---|
| [7922] | 619 |     return ret; \
 | 
|---|
 | 620 | }
 | 
|---|
 | 621 | 
 | 
|---|
| [7862] | 622 | #endif
 | 
|---|
 | 623 | 
 | 
|---|