corrected code to really skip stack frames in the beginning and to number the remaini...

[wxWidgets.git] / include / wx / scopeguard.h

diff --git a/include/wx/scopeguard.h b/include/wx/scopeguard.h
index e93f88b760a675629d70e63dfad429271037d450..0bb390d130aabff512557625ed3f188789cde7ec 100644 (file)
--- a/include/wx/scopeguard.h
+++ b/include/wx/scopeguard.h
@@ -11,8 +11,9 @@
 
 /*
     Acknowledgements: this header is heavily based on (well, almost the exact
 
 /*
     Acknowledgements: this header is heavily based on (well, almost the exact

-    copy of) wxScopeGuard.h by Andrei Alexandrescu and Petru Marginean published
+    copy of) ScopeGuard.h by Andrei Alexandrescu and Petru Marginean published

     in December 2000 issue of C/C++ Users Journal.
     in December 2000 issue of C/C++ Users Journal.

+    http://www.cuj.com/documents/cujcexp1812alexandr/

  */
 
 #ifndef _WX_SCOPEGUARD_H_
  */
 
 #ifndef _WX_SCOPEGUARD_H_


@@ -26,12 +27,36 @@
 // helpers
 // ----------------------------------------------------------------------------
 
 // helpers
 // ----------------------------------------------------------------------------
 

+#ifdef __WATCOMC__
+
+// WATCOM-FIXME: C++ of Open Watcom 1.3 doesn't like OnScopeExit() created
+// through template so it must be workarounded with dedicated inlined macro.
+// For compatibility with Watcom compilers wxPrivate::OnScopeExit must be
+// replaced with wxPrivateOnScopeExit but in user code (for everyone who
+// doesn't care about OW compatibility) wxPrivate::OnScopeExit still works.
+
+#define wxPrivateOnScopeExit(guard)          \
+    {                                        \
+        if ( !(guard).WasDismissed() )       \
+        {                                    \
+            wxTRY                            \
+            {                                \
+                (guard).Execute();           \
+            }                                \
+            wxCATCH_ALL(;)                   \
+        }                                    \
+    }
+
+#define wxPrivateUse(n) wxUnusedVar(n)
+
+#else
+

 namespace wxPrivate
 {
     // in the original implementation this was a member template function of
     // ScopeGuardImplBase but gcc 2.8 which is still used for OS/2 doesn't
     // support member templates and so we must make it global
 namespace wxPrivate
 {
     // in the original implementation this was a member template function of
     // ScopeGuardImplBase but gcc 2.8 which is still used for OS/2 doesn't
     // support member templates and so we must make it global

-    template <typename ScopeGuardImpl>
+    template <class ScopeGuardImpl>

     void OnScopeExit(ScopeGuardImpl& guard)
     {
         if ( !guard.WasDismissed() )
     void OnScopeExit(ScopeGuardImpl& guard)
     {
         if ( !guard.WasDismissed() )


@@ -46,12 +71,17 @@ namespace wxPrivate
     }
 
     // just to avoid the warning about unused variables
     }
 
     // just to avoid the warning about unused variables

-    template <typename T>
+    template <class T>

     void Use(const T& WXUNUSED(t))
     {
     }
 } // namespace wxPrivate
 
     void Use(const T& WXUNUSED(t))
     {
     }
 } // namespace wxPrivate
 

+#define wxPrivateOnScopeExit(n) wxPrivate::OnScopeExit(n)
+#define wxPrivateUse(n) wxPrivate::Use(n)
+
+#endif
+

 // ============================================================================
 // wxScopeGuard for functions and functors
 // ============================================================================
 // ============================================================================
 // wxScopeGuard for functions and functors
 // ============================================================================


@@ -90,7 +120,7 @@ private:
 // wxScopeGuardImpl0: scope guard for actions without parameters
 // ----------------------------------------------------------------------------
 
 // wxScopeGuardImpl0: scope guard for actions without parameters
 // ----------------------------------------------------------------------------
 

-template <typename F>
+template <class F>

 class wxScopeGuardImpl0 : public wxScopeGuardImplBase
 {
 public:
 class wxScopeGuardImpl0 : public wxScopeGuardImplBase
 {
 public:


@@ -99,7 +129,7 @@ public:
         return wxScopeGuardImpl0<F>(fun);
     }
 
         return wxScopeGuardImpl0<F>(fun);
     }
 

-    ~wxScopeGuardImpl0() { wxPrivate::OnScopeExit(*this); }
+    ~wxScopeGuardImpl0() { wxPrivateOnScopeExit(*this); }

 
     void Execute() { m_fun(); }
 
 
     void Execute() { m_fun(); }
 


@@ -111,7 +141,7 @@ protected:
     wxScopeGuardImpl0& operator=(const wxScopeGuardImpl0&);
 };
 
     wxScopeGuardImpl0& operator=(const wxScopeGuardImpl0&);
 };
 

-template <typename F>
+template <class F>

 inline wxScopeGuardImpl0<F> wxMakeGuard(F fun)
 {
     return wxScopeGuardImpl0<F>::MakeGuard(fun);
 inline wxScopeGuardImpl0<F> wxMakeGuard(F fun)
 {
     return wxScopeGuardImpl0<F>::MakeGuard(fun);


@@ -121,7 +151,7 @@ inline wxScopeGuardImpl0<F> wxMakeGuard(F fun)
 // wxScopeGuardImpl1: scope guard for actions with 1 parameter
 // ----------------------------------------------------------------------------
 
 // wxScopeGuardImpl1: scope guard for actions with 1 parameter
 // ----------------------------------------------------------------------------
 

-template <typename F, typename P1>
+template <class F, class P1>

 class wxScopeGuardImpl1 : public wxScopeGuardImplBase
 {
 public:
 class wxScopeGuardImpl1 : public wxScopeGuardImplBase
 {
 public:


@@ -130,7 +160,7 @@ public:
         return wxScopeGuardImpl1<F, P1>(fun, p1);
     }
 
         return wxScopeGuardImpl1<F, P1>(fun, p1);
     }
 

-    ~wxScopeGuardImpl1() { wxPrivate::OnScopeExit(*this); }
+    ~wxScopeGuardImpl1() { wxPrivateOnScopeExit(* this); }

 
     void Execute() { m_fun(m_p1); }
 
 
     void Execute() { m_fun(m_p1); }
 


@@ -143,7 +173,7 @@ protected:
     wxScopeGuardImpl1& operator=(const wxScopeGuardImpl1&);
 };
 
     wxScopeGuardImpl1& operator=(const wxScopeGuardImpl1&);
 };
 

-template <typename F, typename P1>
+template <class F, class P1>

 inline wxScopeGuardImpl1<F, P1> wxMakeGuard(F fun, P1 p1)
 {
     return wxScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
 inline wxScopeGuardImpl1<F, P1> wxMakeGuard(F fun, P1 p1)
 {
     return wxScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);


@@ -153,7 +183,7 @@ inline wxScopeGuardImpl1<F, P1> wxMakeGuard(F fun, P1 p1)
 // wxScopeGuardImpl2: scope guard for actions with 2 parameters
 // ----------------------------------------------------------------------------
 
 // wxScopeGuardImpl2: scope guard for actions with 2 parameters
 // ----------------------------------------------------------------------------
 

-template <typename F, typename P1, typename P2>
+template <class F, class P1, class P2>

 class wxScopeGuardImpl2 : public wxScopeGuardImplBase
 {
 public:
 class wxScopeGuardImpl2 : public wxScopeGuardImplBase
 {
 public:


@@ -162,7 +192,7 @@ public:
         return wxScopeGuardImpl2<F, P1, P2>(fun, p1, p2);
     }
 
         return wxScopeGuardImpl2<F, P1, P2>(fun, p1, p2);
     }
 

-    ~wxScopeGuardImpl2() { wxPrivate::OnScopeExit(*this); }
+    ~wxScopeGuardImpl2() { wxPrivateOnScopeExit(*this); }

 
     void Execute() { m_fun(m_p1, m_p2); }
 
 
     void Execute() { m_fun(m_p1, m_p2); }
 


@@ -176,7 +206,7 @@ protected:
     wxScopeGuardImpl2& operator=(const wxScopeGuardImpl2&);
 };
 
     wxScopeGuardImpl2& operator=(const wxScopeGuardImpl2&);
 };
 

-template <typename F, typename P1, typename P2>
+template <class F, class P1, class P2>

 inline wxScopeGuardImpl2<F, P1, P2> wxMakeGuard(F fun, P1 p1, P2 p2)
 {
     return wxScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);
 inline wxScopeGuardImpl2<F, P1, P2> wxMakeGuard(F fun, P1 p1, P2 p2)
 {
     return wxScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);


@@ -190,7 +220,7 @@ inline wxScopeGuardImpl2<F, P1, P2> wxMakeGuard(F fun, P1 p1, P2 p2)
 // wxObjScopeGuardImpl0
 // ----------------------------------------------------------------------------
 
 // wxObjScopeGuardImpl0
 // ----------------------------------------------------------------------------
 

-template <class Obj, typename MemFun>
+template <class Obj, class MemFun>

 class wxObjScopeGuardImpl0 : public wxScopeGuardImplBase
 {
 public:
 class wxObjScopeGuardImpl0 : public wxScopeGuardImplBase
 {
 public:


@@ -200,7 +230,7 @@ public:
         return wxObjScopeGuardImpl0<Obj, MemFun>(obj, memFun);
     }
 
         return wxObjScopeGuardImpl0<Obj, MemFun>(obj, memFun);
     }
 

-    ~wxObjScopeGuardImpl0() { wxPrivate::OnScopeExit(*this); }
+    ~wxObjScopeGuardImpl0() { wxPrivateOnScopeExit(*this); }

 
     void Execute() { (m_obj.*m_memfun)(); }
 
 
     void Execute() { (m_obj.*m_memfun)(); }
 


@@ -212,13 +242,13 @@ protected:
     MemFun m_memfun;
 };
 
     MemFun m_memfun;
 };
 

-template <class Obj, typename MemFun>
+template <class Obj, class MemFun>

 inline wxObjScopeGuardImpl0<Obj, MemFun> wxMakeObjGuard(Obj& obj, MemFun memFun)
 {
     return wxObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun);
 }
 
 inline wxObjScopeGuardImpl0<Obj, MemFun> wxMakeObjGuard(Obj& obj, MemFun memFun)
 {
     return wxObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun);
 }
 

-template <class Obj, typename MemFun, typename P1>
+template <class Obj, class MemFun, class P1>

 class wxObjScopeGuardImpl1 : public wxScopeGuardImplBase
 {
 public:
 class wxObjScopeGuardImpl1 : public wxScopeGuardImplBase
 {
 public:


@@ -228,7 +258,7 @@ public:
         return wxObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1);
     }
 
         return wxObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1);
     }
 

-    ~wxObjScopeGuardImpl1() { wxPrivate::OnScopeExit(*this); }
+    ~wxObjScopeGuardImpl1() { wxPrivateOnScopeExit(*this); }

 
     void Execute() { (m_obj.*m_memfun)(m_p1); }
 
 
     void Execute() { (m_obj.*m_memfun)(m_p1); }
 


@@ -241,14 +271,14 @@ protected:
     const P1 m_p1;
 };
 
     const P1 m_p1;
 };
 

-template <class Obj, typename MemFun, typename P1>
+template <class Obj, class MemFun, class P1>

 inline wxObjScopeGuardImpl1<Obj, MemFun, P1>
 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
 {
     return wxObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1);
 }
 
 inline wxObjScopeGuardImpl1<Obj, MemFun, P1>
 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
 {
     return wxObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1);
 }
 

-template <class Obj, typename MemFun, typename P1, typename P2>
+template <class Obj, class MemFun, class P1, class P2>

 class wxObjScopeGuardImpl2 : public wxScopeGuardImplBase
 {
 public:
 class wxObjScopeGuardImpl2 : public wxScopeGuardImplBase
 {
 public:


@@ -258,7 +288,7 @@ public:
         return wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2);
     }
 
         return wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2);
     }
 

-    ~wxObjScopeGuardImpl2() { wxPrivate::OnScopeExit(*this); }
+    ~wxObjScopeGuardImpl2() { wxPrivateOnScopeExit(*this); }

 
     void Execute() { (m_obj.*m_memfun)(m_p1, m_p2); }
 
 
     void Execute() { (m_obj.*m_memfun)(m_p1, m_p2); }
 


@@ -272,7 +302,7 @@ protected:
     const P2 m_p2;
 };
 
     const P2 m_p2;
 };
 

-template <class Obj, typename MemFun, typename P1, typename P2>
+template <class Obj, class MemFun, class P1, class P2>

 inline wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>
 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
 {
 inline wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>
 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
 {


@@ -298,39 +328,38 @@ typedef const wxScopeGuardImplBase& wxScopeGuard;
 
 #define wxON_BLOCK_EXIT0_IMPL(n, f) \
     wxScopeGuard n = wxMakeGuard(f); \
 
 #define wxON_BLOCK_EXIT0_IMPL(n, f) \
     wxScopeGuard n = wxMakeGuard(f); \

-    wxPrivate::Use(n)
+    wxPrivateUse(n)

 #define wxON_BLOCK_EXIT0(f) \
     wxON_BLOCK_EXIT0_IMPL(wxGuardName, f)
 
 #define wxON_BLOCK_EXIT_OBJ0_IMPL(n, o, m) \
     wxScopeGuard n = wxMakeObjGuard(o, m); \
 #define wxON_BLOCK_EXIT0(f) \
     wxON_BLOCK_EXIT0_IMPL(wxGuardName, f)
 
 #define wxON_BLOCK_EXIT_OBJ0_IMPL(n, o, m) \
     wxScopeGuard n = wxMakeObjGuard(o, m); \

-    wxPrivate::Use(n)
+    wxPrivateUse(n)

 #define wxON_BLOCK_EXIT_OBJ0(o, m) \
 #define wxON_BLOCK_EXIT_OBJ0(o, m) \

-    wxON_BLOCK_EXIT_OBJ0_IMPL(wxGuardName, o, m)
+    wxON_BLOCK_EXIT_OBJ0_IMPL(wxGuardName, o, &m)

 
 #define wxON_BLOCK_EXIT1_IMPL(n, f, p1) \
     wxScopeGuard n = wxMakeGuard(f, p1); \
 
 #define wxON_BLOCK_EXIT1_IMPL(n, f, p1) \
     wxScopeGuard n = wxMakeGuard(f, p1); \

-    wxPrivate::Use(n)
+    wxPrivateUse(n)

 #define wxON_BLOCK_EXIT1(f, p1) \
     wxON_BLOCK_EXIT1_IMPL(wxGuardName, f, p1)
 
 #define wxON_BLOCK_EXIT_OBJ1_IMPL(n, o, m, p1) \
     wxScopeGuard n = wxMakeObjGuard(o, m, p1); \
 #define wxON_BLOCK_EXIT1(f, p1) \
     wxON_BLOCK_EXIT1_IMPL(wxGuardName, f, p1)
 
 #define wxON_BLOCK_EXIT_OBJ1_IMPL(n, o, m, p1) \
     wxScopeGuard n = wxMakeObjGuard(o, m, p1); \

-    wxPrivate::Use(n)
+    wxPrivateUse(n)

 #define wxON_BLOCK_EXIT_OBJ1(o, m, p1) \
 #define wxON_BLOCK_EXIT_OBJ1(o, m, p1) \

-    wxON_BLOCK_EXIT_OBJ1_IMPL(wxGuardName, o, m, p1)
+    wxON_BLOCK_EXIT_OBJ1_IMPL(wxGuardName, o, &m, p1)

 
 #define wxON_BLOCK_EXIT2_IMPL(n, f, p1, p2) \
     wxScopeGuard n = wxMakeGuard(f, p1, p2); \
 
 #define wxON_BLOCK_EXIT2_IMPL(n, f, p1, p2) \
     wxScopeGuard n = wxMakeGuard(f, p1, p2); \

-    wxPrivate::Use(n)
+    wxPrivateUse(n)

 #define wxON_BLOCK_EXIT2(f, p1, p2) \
     wxON_BLOCK_EXIT2_IMPL(wxGuardName, f, p1, p2)
 
 #define wxON_BLOCK_EXIT_OBJ2_IMPL(n, o, m, p1, p2) \
     wxScopeGuard n = wxMakeObjGuard(o, m, p1, p2); \
 #define wxON_BLOCK_EXIT2(f, p1, p2) \
     wxON_BLOCK_EXIT2_IMPL(wxGuardName, f, p1, p2)
 
 #define wxON_BLOCK_EXIT_OBJ2_IMPL(n, o, m, p1, p2) \
     wxScopeGuard n = wxMakeObjGuard(o, m, p1, p2); \

-    wxPrivate::Use(n)
+    wxPrivateUse(n)

 #define wxON_BLOCK_EXIT_OBJ2(o, m, p1, p2) \
 #define wxON_BLOCK_EXIT_OBJ2(o, m, p1, p2) \

-    wxON_BLOCK_EXIT_OBJ2_IMPL(wxGuardName, o, m, p1, p2)
+    wxON_BLOCK_EXIT_OBJ2_IMPL(wxGuardName, o, &m, p1, p2)

 
 #endif // _WX_SCOPEGUARD_H_
 
 #endif // _WX_SCOPEGUARD_H_

-