From a3806ce7a117445e9018bfc0b9444bab56a11788 Mon Sep 17 00:00:00 2001 From: couriersud Date: Sun, 31 May 2015 18:00:42 +0200 Subject: [PATCH] delegate.h now supports mingw 32 bit builds with INTERNAL configuration. Member functions are called in this case using __thiscall ABI. [Couriersud] --- src/emu/devdelegate.h | 4 +++ src/emu/schedule.h | 2 ++ src/lib/util/delegate.h | 76 ++++++++++++++++++++++++++++++++--------- 3 files changed, 66 insertions(+), 16 deletions(-) diff --git a/src/emu/devdelegate.h b/src/emu/devdelegate.h index 2ce6cc9a0fa..ba1b82ab8ee 100644 --- a/src/emu/devdelegate.h +++ b/src/emu/devdelegate.h @@ -54,17 +54,21 @@ public: device_delegate(const basetype &src) : basetype(src), device_delegate_helper(src.m_device_name) { } device_delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object), device_delegate_helper(src.m_device_name) { } template device_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object), device_delegate_helper(safe_tag(dynamic_cast(object))) { } +#ifdef USE_STATIC_DELEGATE template device_delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object), device_delegate_helper(safe_tag(dynamic_cast(object))) { } template device_delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object), device_delegate_helper(safe_tag(dynamic_cast(object))) { } +#endif device_delegate &operator=(const thistype &src) { *static_cast(this) = src; m_device_name = src.m_device_name; return *this; } // provide additional constructors that take a device name string template device_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, const char *devname) : basetype(funcptr, name, (_FunctionClass *)0), device_delegate_helper(devname) { } template device_delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, const char *devname, _FunctionClass *object) : basetype(funcptr, name, (_FunctionClass *)0), device_delegate_helper(devname) { } +#ifdef USE_STATIC_DELEGATE template device_delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, const char *devname, _FunctionClass *object) : basetype(funcptr, name, (_FunctionClass *)0), device_delegate_helper(devname) { } template device_delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, const char *devname, _FunctionClass *object) : basetype(funcptr, name, (_FunctionClass *)0), device_delegate_helper(devname) { } device_delegate(typename basetype::template traits::static_func_type funcptr, const char *name) : basetype(funcptr, name, (device_t *)0), device_delegate_helper(NULL) { } device_delegate(typename basetype::template traits::static_ref_func_type funcptr, const char *name) : basetype(funcptr, name, (device_t *)0), device_delegate_helper(NULL) { } +#endif // and constructors that provide a search root device_delegate(const thistype &src, device_t &search_root) : basetype(src), device_delegate_helper(src.m_device_name) { bind_relative_to(search_root); } diff --git a/src/emu/schedule.h b/src/emu/schedule.h index 36ae83d2929..a2d8660ef4f 100644 --- a/src/emu/schedule.h +++ b/src/emu/schedule.h @@ -144,10 +144,12 @@ public: void synchronize(timer_expired_delegate callback = timer_expired_delegate(), int param = 0, void *ptr = NULL) { timer_set(attotime::zero, callback, param, ptr); } // timers with old-skool callbacks +#ifdef USE_STATIC_DELEGATE emu_timer *timer_alloc(timer_expired_func callback, const char *name, void *ptr = NULL) { return timer_alloc(timer_expired_delegate(callback, name, &machine()), ptr); } void timer_set(const attotime &duration, timer_expired_func callback, const char *name, int param = 0, void *ptr = NULL) { timer_set(duration, timer_expired_delegate(callback, name, &machine()), param, ptr); } void timer_pulse(const attotime &period, timer_expired_func callback, const char *name, int param = 0, void *ptr = NULL) { timer_pulse(period, timer_expired_delegate(callback, name, &machine()), param, ptr); } void synchronize(timer_expired_func callback, const char *name = NULL, int param = 0, void *ptr = NULL) { timer_set(attotime::zero, callback, name, param, ptr); } +#endif // timers, specified by device/id; generally devices should use the device_t methods instead emu_timer *timer_alloc(device_t &device, device_timer_id id = 0, void *ptr = NULL); diff --git a/src/lib/util/delegate.h b/src/lib/util/delegate.h index 363163e2ccf..3b02f91b976 100644 --- a/src/lib/util/delegate.h +++ b/src/lib/util/delegate.h @@ -95,20 +95,29 @@ #if defined(__GNUC__) /* does not work in versions over 4.7.x of 32bit MINGW */ #if defined(__MINGW32__) && !defined(__x86_64) && defined(__i386__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))) - #define USE_DELEGATE_TYPE DELEGATE_TYPE_COMPATIBLE + //#define USE_DELEGATE_TYPE DELEGATE_TYPE_COMPATIBLE + #define USE_DELEGATE_TYPE DELEGATE_TYPE_INTERNAL + #define MEMBER_ABI __thiscall + #define HAS_DIFFERENT_ABI 1 #elif defined(EMSCRIPTEN) #define USE_DELEGATE_TYPE DELEGATE_TYPE_COMPATIBLE #elif defined(__arm__) || defined(__ARMEL__) #define USE_DELEGATE_TYPE DELEGATE_TYPE_COMPATIBLE #else #define USE_DELEGATE_TYPE DELEGATE_TYPE_INTERNAL + #define MEMBER_ABI + #define HAS_DIFFERENT_ABI 0 #endif #else #define USE_DELEGATE_TYPE DELEGATE_TYPE_COMPATIBLE #endif +#define USE_STATIC_DELEGATE 1 - +#if (USE_DELEGATE_TYPE == DELEGATE_TYPE_COMPATIBLE) + #define MEMBER_ABI + #define HAS_DIFFERENT_ABI 0 +#endif //************************************************************************** // HELPER CLASSES //************************************************************************** @@ -554,7 +563,7 @@ public: typedef typename delegate_traits<_FunctionClass, _ReturnType, _P1Type, _P2Type, _P3Type, _P4Type, _P5Type, _P6Type, _P7Type, _P8Type, _P9Type, _P10Type, _P11Type, _P12Type>::static_ref_func_type static_ref_func_type; }; typedef typename traits::static_func_type generic_static_func; - + typedef MEMBER_ABI generic_static_func generic_member_func; // generic constructor delegate_base() : m_function(NULL), @@ -646,20 +655,29 @@ public: return (m_raw_function == rhs.m_raw_function && object() == rhs.object() && m_raw_mfp == rhs.m_raw_mfp); } +#define DELEGATE_CALL(x) \ + if (is_mfp() && (HAS_DIFFERENT_ABI)) \ + return (*reinterpret_cast(m_function)) x; \ + else \ + return (*m_function) x; \ + + //return MEMBER_ABI (*reinpertret_cast(m_function)) x; + // call the function - _ReturnType operator()() const { return (*m_function)(m_object); } - _ReturnType operator()(_P1Type p1) const { return (*m_function)(m_object, p1); } - _ReturnType operator()(_P1Type p1, _P2Type p2) const { return (*m_function)(m_object, p1, p2); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3) const { return (*m_function)(m_object, p1, p2, p3); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4) const { return (*m_function)(m_object, p1, p2, p3, p4); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5) const { return (*m_function)(m_object, p1, p2, p3, p4, p5); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6) const { return (*m_function)(m_object, p1, p2, p3, p4, p5, p6); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7) const { return (*m_function)(m_object, p1, p2, p3, p4, p5, p6, p7); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8) const { return (*m_function)(m_object, p1, p2, p3, p4, p5, p6, p7, p8); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8, _P9Type p9) const { return (*m_function)(m_object, p1, p2, p3, p4, p5, p6, p7, p8, p9); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8, _P9Type p9, _P10Type p10) const { return (*m_function)(m_object, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8, _P9Type p9, _P10Type p10, _P11Type p11) const { return (*m_function)(m_object, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } - _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8, _P9Type p9, _P10Type p10, _P11Type p11, _P12Type p12) const { return (*m_function)(m_object, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } + _ReturnType operator()() const { DELEGATE_CALL((m_object)); } + //_ReturnType operator()() const { return (*m_function)(m_object); } + _ReturnType operator()(_P1Type p1) const { DELEGATE_CALL((m_object, p1)); } + _ReturnType operator()(_P1Type p1, _P2Type p2) const { DELEGATE_CALL((m_object, p1, p2)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3) const { DELEGATE_CALL((m_object, p1, p2, p3)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4) const { DELEGATE_CALL((m_object, p1, p2, p3, p4)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5) const { DELEGATE_CALL((m_object, p1, p2, p3, p4, p5)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6) const { DELEGATE_CALL((m_object, p1, p2, p3, p4, p5, p6)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7) const { DELEGATE_CALL((m_object, p1, p2, p3, p4, p5, p6, p7)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8) const { DELEGATE_CALL((m_object, p1, p2, p3, p4, p5, p6, p7, p8)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8, _P9Type p9) const { DELEGATE_CALL((m_object, p1, p2, p3, p4, p5, p6, p7, p8, p9)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8, _P9Type p9, _P10Type p10) const { DELEGATE_CALL((m_object, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8, _P9Type p9, _P10Type p10, _P11Type p11) const { DELEGATE_CALL((m_object, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)); } + _ReturnType operator()(_P1Type p1, _P2Type p2, _P3Type p3, _P4Type p4, _P5Type p5, _P6Type p6, _P7Type p7, _P8Type p8, _P9Type p9, _P10Type p10, _P11Type p11, _P12Type p12) const { DELEGATE_CALL((m_object, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)); } // getters bool has_object() const { return (object() != NULL); } @@ -732,8 +750,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -749,8 +769,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -766,8 +788,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -783,8 +807,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -800,8 +826,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -817,8 +845,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -834,8 +864,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -851,8 +883,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -868,8 +902,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -885,8 +921,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -902,8 +940,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -919,8 +959,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } }; @@ -936,8 +978,10 @@ public: delegate(const basetype &src) : basetype(src) { } delegate(const basetype &src, delegate_late_bind &object) : basetype(src, object) { } template delegate(typename basetype::template traits<_FunctionClass>::member_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#ifdef USE_STATIC_DELEGATE template delegate(typename basetype::template traits<_FunctionClass>::static_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } template delegate(typename basetype::template traits<_FunctionClass>::static_ref_func_type funcptr, const char *name, _FunctionClass *object) : basetype(funcptr, name, object) { } +#endif delegate &operator=(const basetype &src) { *static_cast(this) = src; return *this; } };