diff options
Diffstat (limited to 'community/visualboyadvance')
-rw-r--r-- | community/visualboyadvance/1.7.2-deprecatedsigc++.patch | 692 | ||||
-rw-r--r-- | community/visualboyadvance/1.7.2-gcc34.patch | 41 | ||||
-rw-r--r-- | community/visualboyadvance/1.7.2-gcc41.patch | 27 | ||||
-rw-r--r-- | community/visualboyadvance/1.7.2-glibc.patch | 76 | ||||
-rw-r--r-- | community/visualboyadvance/1.7.2-homedir.patch | 11 | ||||
-rw-r--r-- | community/visualboyadvance/1.7.2-uninit.patch | 13 | ||||
-rw-r--r-- | community/visualboyadvance/PKGBUILD | 48 |
7 files changed, 908 insertions, 0 deletions
diff --git a/community/visualboyadvance/1.7.2-deprecatedsigc++.patch b/community/visualboyadvance/1.7.2-deprecatedsigc++.patch new file mode 100644 index 000000000..4bb1787cb --- /dev/null +++ b/community/visualboyadvance/1.7.2-deprecatedsigc++.patch @@ -0,0 +1,692 @@ +--- src/gtk/sigccompat.h.old 2008-05-02 10:46:45.000000000 +0200 ++++ src/gtk/sigccompat.h 2008-05-02 10:47:08.000000000 +0200 +@@ -20,7 +20,7 @@ + #ifndef __VBA_SIGCCOMPAT_H__ + #define __VBA_SIGCCOMPAT_H__ + +-#undef LIBSIGC_DISABLE_DEPRECATED ++#define LIBSIGC_DISABLE_DEPRECATED + #include <sigc++/bind.h> + #include <sigc++/connection.h> + +@@ -28,9 +28,679 @@ + #include <sigc++/object.h> + #include <sigc++/functors/mem_fun.h> + +-namespace SigC ++ ++// From sigc++/bind.h ++namespace SigC { ++ ++template <class T_bound1, class T_functor> ++inline ::sigc::bind_functor<-1, T_functor, ++ typename ::sigc::unwrap_reference<T_bound1>::type> ++bind(const T_functor& _A_functor, T_bound1 _A_b1) ++{ return ::sigc::bind_functor<-1, T_functor, ++ typename ::sigc::unwrap_reference<T_bound1>::type> ++ (_A_functor, _A_b1); ++} ++ ++template <class T_bound1, class T_bound2, class T_functor> ++inline ::sigc::bind_functor<-1, T_functor, ++ typename ::sigc::unwrap_reference<T_bound1>::type, ++ typename ::sigc::unwrap_reference<T_bound2>::type> ++bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2) ++{ return ::sigc::bind_functor<-1, T_functor, ++ typename ::sigc::unwrap_reference<T_bound1>::type, ++ typename ::sigc::unwrap_reference<T_bound2>::type> ++ (_A_functor, _A_b1, _A_b2); ++} ++ ++template <class T_bound1, class T_bound2, class T_bound3, class T_functor> ++inline ::sigc::bind_functor<-1, T_functor, ++ typename ::sigc::unwrap_reference<T_bound1>::type, ++ typename ::sigc::unwrap_reference<T_bound2>::type, ++ typename ::sigc::unwrap_reference<T_bound3>::type> ++bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2,T_bound3 _A_b3) ++{ return ::sigc::bind_functor<-1, T_functor, ++ typename ::sigc::unwrap_reference<T_bound1>::type, ++ typename ::sigc::unwrap_reference<T_bound2>::type, ++ typename ::sigc::unwrap_reference<T_bound3>::type> ++ (_A_functor, _A_b1, _A_b2, _A_b3); ++} ++ ++} ++ ++// From sigc++/connection.h ++namespace SigC { ++ ++/** Convinience class for safe disconnection. ++ * Iterators must not be used beyond the lifetime of the list ++ * they work on. A connection object can be created from a ++ * slot list iterator and may safely be used to disconnect ++ * the referred slot at any time (disconnect()). If the slot ++ * has already been destroyed, disconnect() does nothing. empty() or ++ * operator bool() can be used to test whether the connection is ++ * still active. The connection can be blocked (block(), unblock()). ++ * ++ * This is possible because the connection object gets notified ++ * when the referred slot dies (notify()). ++ * ++ * @deprecated Use sigc::connection instead. ++ * @ingroup compat ++ */ ++typedef ::sigc::connection Connection; ++ ++} ++ ++// From sigc++/slot.h ++namespace SigC { ++ ++// SlotN ++/** Converts an arbitrary functor to a unified type which is opaque. ++ * Slot0 itself is a functor or to be more precise a closure. It contains ++ * a single, arbitrary functor (or closure) that is executed in operator()(). ++ * ++ * The template arguments determine the function signature of operator()(): ++ * - @e T_return The return type of operator()(). ++ * ++ * To use simply assign the slot to the desired functor. If the functor ++ * is not compatible with the parameter list defined with the template ++ * arguments compiler errors are triggered. When called the slot ++ * will invoke the functor with minimal copies. ++ * block() and unblock() can be used to block the functor's invocation ++ * from operator()() temporarily. ++ * ++ * @par Example: ++ * @code ++ * #include <sigc++/slot.h> ++ * void foo(int) {} ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); ++ * s(19); ++ * @endcode ++ * ++ * @deprecated Use the unnumbered template sigc::slot instead. ++ * @ingroup compat ++ */ ++template <class T_return> ++class Slot0 ++ : public ::sigc::slot<T_return> ++{ ++public: ++ typedef ::sigc::slot<T_return> parent_type; ++ ++ /// Constructs an empty slot. ++ Slot0() {} ++ ++ /** Constructs a slot from an arbitrary functor. ++ * @param _A_func The desired functor the new slot should be assigned to. ++ */ ++ template <class T_functor> ++ Slot0(const T_functor& _A_func) ++ : ::sigc::slot<T_return>(_A_func) {} ++ ++ /** Constructs a slot, copying an existing one. ++ * @param src The existing slot to copy. ++ */ ++ Slot0(const parent_type& src) ++ : parent_type(src) {} ++ ++ /** Overrides this slot making a copy from another slot. ++ * @param src The slot from which to make a copy. ++ * @return @p this. ++ */ ++ Slot0& operator=(const parent_type& src) ++ { parent_type::operator=(src); return *this; } ++}; ++ ++/** Converts an arbitrary functor to a unified type which is opaque. ++ * Slot1 itself is a functor or to be more precise a closure. It contains ++ * a single, arbitrary functor (or closure) that is executed in operator()(). ++ * ++ * The template arguments determine the function signature of operator()(): ++ * - @e T_return The return type of operator()(). ++ * - @e T_arg1 Argument type used in the definition of operator()(). ++ * ++ * To use simply assign the slot to the desired functor. If the functor ++ * is not compatible with the parameter list defined with the template ++ * arguments compiler errors are triggered. When called the slot ++ * will invoke the functor with minimal copies. ++ * block() and unblock() can be used to block the functor's invocation ++ * from operator()() temporarily. ++ * ++ * @par Example: ++ * @code ++ * #include <sigc++/slot.h> ++ * void foo(int) {} ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); ++ * s(19); ++ * @endcode ++ * ++ * @deprecated Use the unnumbered template sigc::slot instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1> ++class Slot1 ++ : public ::sigc::slot<T_return, T_arg1> ++{ ++public: ++ typedef ::sigc::slot<T_return, T_arg1> parent_type; ++ ++ /// Constructs an empty slot. ++ Slot1() {} ++ ++ /** Constructs a slot from an arbitrary functor. ++ * @param _A_func The desired functor the new slot should be assigned to. ++ */ ++ template <class T_functor> ++ Slot1(const T_functor& _A_func) ++ : ::sigc::slot<T_return, T_arg1>(_A_func) {} ++ ++ /** Constructs a slot, copying an existing one. ++ * @param src The existing slot to copy. ++ */ ++ Slot1(const parent_type& src) ++ : parent_type(src) {} ++ ++ /** Overrides this slot making a copy from another slot. ++ * @param src The slot from which to make a copy. ++ * @return @p this. ++ */ ++ Slot1& operator=(const parent_type& src) ++ { parent_type::operator=(src); return *this; } ++}; ++ ++/** Converts an arbitrary functor to a unified type which is opaque. ++ * Slot2 itself is a functor or to be more precise a closure. It contains ++ * a single, arbitrary functor (or closure) that is executed in operator()(). ++ * ++ * The template arguments determine the function signature of operator()(): ++ * - @e T_return The return type of operator()(). ++ * - @e T_arg1 Argument type used in the definition of operator()(). ++ * - @e T_arg2 Argument type used in the definition of operator()(). ++ * ++ * To use simply assign the slot to the desired functor. If the functor ++ * is not compatible with the parameter list defined with the template ++ * arguments compiler errors are triggered. When called the slot ++ * will invoke the functor with minimal copies. ++ * block() and unblock() can be used to block the functor's invocation ++ * from operator()() temporarily. ++ * ++ * @par Example: ++ * @code ++ * #include <sigc++/slot.h> ++ * void foo(int) {} ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); ++ * s(19); ++ * @endcode ++ * ++ * @deprecated Use the unnumbered template sigc::slot instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2> ++class Slot2 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2> ++{ ++public: ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2> parent_type; ++ ++ /// Constructs an empty slot. ++ Slot2() {} ++ ++ /** Constructs a slot from an arbitrary functor. ++ * @param _A_func The desired functor the new slot should be assigned to. ++ */ ++ template <class T_functor> ++ Slot2(const T_functor& _A_func) ++ : ::sigc::slot<T_return, T_arg1,T_arg2>(_A_func) {} ++ ++ /** Constructs a slot, copying an existing one. ++ * @param src The existing slot to copy. ++ */ ++ Slot2(const parent_type& src) ++ : parent_type(src) {} ++ ++ /** Overrides this slot making a copy from another slot. ++ * @param src The slot from which to make a copy. ++ * @return @p this. ++ */ ++ Slot2& operator=(const parent_type& src) ++ { parent_type::operator=(src); return *this; } ++}; ++ ++/** Converts an arbitrary functor to a unified type which is opaque. ++ * Slot3 itself is a functor or to be more precise a closure. It contains ++ * a single, arbitrary functor (or closure) that is executed in operator()(). ++ * ++ * The template arguments determine the function signature of operator()(): ++ * - @e T_return The return type of operator()(). ++ * - @e T_arg1 Argument type used in the definition of operator()(). ++ * - @e T_arg2 Argument type used in the definition of operator()(). ++ * - @e T_arg3 Argument type used in the definition of operator()(). ++ * ++ * To use simply assign the slot to the desired functor. If the functor ++ * is not compatible with the parameter list defined with the template ++ * arguments compiler errors are triggered. When called the slot ++ * will invoke the functor with minimal copies. ++ * block() and unblock() can be used to block the functor's invocation ++ * from operator()() temporarily. ++ * ++ * @par Example: ++ * @code ++ * #include <sigc++/slot.h> ++ * void foo(int) {} ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); ++ * s(19); ++ * @endcode ++ * ++ * @deprecated Use the unnumbered template sigc::slot instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3> ++class Slot3 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> ++{ ++public: ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> parent_type; ++ ++ /// Constructs an empty slot. ++ Slot3() {} ++ ++ /** Constructs a slot from an arbitrary functor. ++ * @param _A_func The desired functor the new slot should be assigned to. ++ */ ++ template <class T_functor> ++ Slot3(const T_functor& _A_func) ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>(_A_func) {} ++ ++ /** Constructs a slot, copying an existing one. ++ * @param src The existing slot to copy. ++ */ ++ Slot3(const parent_type& src) ++ : parent_type(src) {} ++ ++ /** Overrides this slot making a copy from another slot. ++ * @param src The slot from which to make a copy. ++ * @return @p this. ++ */ ++ Slot3& operator=(const parent_type& src) ++ { parent_type::operator=(src); return *this; } ++}; ++ ++/** Converts an arbitrary functor to a unified type which is opaque. ++ * Slot4 itself is a functor or to be more precise a closure. It contains ++ * a single, arbitrary functor (or closure) that is executed in operator()(). ++ * ++ * The template arguments determine the function signature of operator()(): ++ * - @e T_return The return type of operator()(). ++ * - @e T_arg1 Argument type used in the definition of operator()(). ++ * - @e T_arg2 Argument type used in the definition of operator()(). ++ * - @e T_arg3 Argument type used in the definition of operator()(). ++ * - @e T_arg4 Argument type used in the definition of operator()(). ++ * ++ * To use simply assign the slot to the desired functor. If the functor ++ * is not compatible with the parameter list defined with the template ++ * arguments compiler errors are triggered. When called the slot ++ * will invoke the functor with minimal copies. ++ * block() and unblock() can be used to block the functor's invocation ++ * from operator()() temporarily. ++ * ++ * @par Example: ++ * @code ++ * #include <sigc++/slot.h> ++ * void foo(int) {} ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); ++ * s(19); ++ * @endcode ++ * ++ * @deprecated Use the unnumbered template sigc::slot instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4> ++class Slot4 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> ++{ ++public: ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> parent_type; ++ ++ /// Constructs an empty slot. ++ Slot4() {} ++ ++ /** Constructs a slot from an arbitrary functor. ++ * @param _A_func The desired functor the new slot should be assigned to. ++ */ ++ template <class T_functor> ++ Slot4(const T_functor& _A_func) ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func) {} ++ ++ /** Constructs a slot, copying an existing one. ++ * @param src The existing slot to copy. ++ */ ++ Slot4(const parent_type& src) ++ : parent_type(src) {} ++ ++ /** Overrides this slot making a copy from another slot. ++ * @param src The slot from which to make a copy. ++ * @return @p this. ++ */ ++ Slot4& operator=(const parent_type& src) ++ { parent_type::operator=(src); return *this; } ++}; ++ ++/** Converts an arbitrary functor to a unified type which is opaque. ++ * Slot5 itself is a functor or to be more precise a closure. It contains ++ * a single, arbitrary functor (or closure) that is executed in operator()(). ++ * ++ * The template arguments determine the function signature of operator()(): ++ * - @e T_return The return type of operator()(). ++ * - @e T_arg1 Argument type used in the definition of operator()(). ++ * - @e T_arg2 Argument type used in the definition of operator()(). ++ * - @e T_arg3 Argument type used in the definition of operator()(). ++ * - @e T_arg4 Argument type used in the definition of operator()(). ++ * - @e T_arg5 Argument type used in the definition of operator()(). ++ * ++ * To use simply assign the slot to the desired functor. If the functor ++ * is not compatible with the parameter list defined with the template ++ * arguments compiler errors are triggered. When called the slot ++ * will invoke the functor with minimal copies. ++ * block() and unblock() can be used to block the functor's invocation ++ * from operator()() temporarily. ++ * ++ * @par Example: ++ * @code ++ * #include <sigc++/slot.h> ++ * void foo(int) {} ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); ++ * s(19); ++ * @endcode ++ * ++ * @deprecated Use the unnumbered template sigc::slot instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5> ++class Slot5 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> ++{ ++public: ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> parent_type; ++ ++ /// Constructs an empty slot. ++ Slot5() {} ++ ++ /** Constructs a slot from an arbitrary functor. ++ * @param _A_func The desired functor the new slot should be assigned to. ++ */ ++ template <class T_functor> ++ Slot5(const T_functor& _A_func) ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func) {} ++ ++ /** Constructs a slot, copying an existing one. ++ * @param src The existing slot to copy. ++ */ ++ Slot5(const parent_type& src) ++ : parent_type(src) {} ++ ++ /** Overrides this slot making a copy from another slot. ++ * @param src The slot from which to make a copy. ++ * @return @p this. ++ */ ++ Slot5& operator=(const parent_type& src) ++ { parent_type::operator=(src); return *this; } ++}; ++ ++/** Converts an arbitrary functor to a unified type which is opaque. ++ * Slot6 itself is a functor or to be more precise a closure. It contains ++ * a single, arbitrary functor (or closure) that is executed in operator()(). ++ * ++ * The template arguments determine the function signature of operator()(): ++ * - @e T_return The return type of operator()(). ++ * - @e T_arg1 Argument type used in the definition of operator()(). ++ * - @e T_arg2 Argument type used in the definition of operator()(). ++ * - @e T_arg3 Argument type used in the definition of operator()(). ++ * - @e T_arg4 Argument type used in the definition of operator()(). ++ * - @e T_arg5 Argument type used in the definition of operator()(). ++ * - @e T_arg6 Argument type used in the definition of operator()(). ++ * ++ * To use simply assign the slot to the desired functor. If the functor ++ * is not compatible with the parameter list defined with the template ++ * arguments compiler errors are triggered. When called the slot ++ * will invoke the functor with minimal copies. ++ * block() and unblock() can be used to block the functor's invocation ++ * from operator()() temporarily. ++ * ++ * @par Example: ++ * @code ++ * #include <sigc++/slot.h> ++ * void foo(int) {} ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); ++ * s(19); ++ * @endcode ++ * ++ * @deprecated Use the unnumbered template sigc::slot instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6> ++class Slot6 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> ++{ ++public: ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> parent_type; ++ ++ /// Constructs an empty slot. ++ Slot6() {} ++ ++ /** Constructs a slot from an arbitrary functor. ++ * @param _A_func The desired functor the new slot should be assigned to. ++ */ ++ template <class T_functor> ++ Slot6(const T_functor& _A_func) ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func) {} ++ ++ /** Constructs a slot, copying an existing one. ++ * @param src The existing slot to copy. ++ */ ++ Slot6(const parent_type& src) ++ : parent_type(src) {} ++ ++ /** Overrides this slot making a copy from another slot. ++ * @param src The slot from which to make a copy. ++ * @return @p this. ++ */ ++ Slot6& operator=(const parent_type& src) ++ { parent_type::operator=(src); return *this; } ++}; ++ ++/** Converts an arbitrary functor to a unified type which is opaque. ++ * Slot7 itself is a functor or to be more precise a closure. It contains ++ * a single, arbitrary functor (or closure) that is executed in operator()(). ++ * ++ * The template arguments determine the function signature of operator()(): ++ * - @e T_return The return type of operator()(). ++ * - @e T_arg1 Argument type used in the definition of operator()(). ++ * - @e T_arg2 Argument type used in the definition of operator()(). ++ * - @e T_arg3 Argument type used in the definition of operator()(). ++ * - @e T_arg4 Argument type used in the definition of operator()(). ++ * - @e T_arg5 Argument type used in the definition of operator()(). ++ * - @e T_arg6 Argument type used in the definition of operator()(). ++ * - @e T_arg7 Argument type used in the definition of operator()(). ++ * ++ * To use simply assign the slot to the desired functor. If the functor ++ * is not compatible with the parameter list defined with the template ++ * arguments compiler errors are triggered. When called the slot ++ * will invoke the functor with minimal copies. ++ * block() and unblock() can be used to block the functor's invocation ++ * from operator()() temporarily. ++ * ++ * @par Example: ++ * @code ++ * #include <sigc++/slot.h> ++ * void foo(int) {} ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); ++ * s(19); ++ * @endcode ++ * ++ * @deprecated Use the unnumbered template sigc::slot instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7> ++class Slot7 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> + { ++public: ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> parent_type; ++ ++ /// Constructs an empty slot. ++ Slot7() {} ++ ++ /** Constructs a slot from an arbitrary functor. ++ * @param _A_func The desired functor the new slot should be assigned to. ++ */ ++ template <class T_functor> ++ Slot7(const T_functor& _A_func) ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func) {} ++ ++ /** Constructs a slot, copying an existing one. ++ * @param src The existing slot to copy. ++ */ ++ Slot7(const parent_type& src) ++ : parent_type(src) {} ++ ++ /** Overrides this slot making a copy from another slot. ++ * @param src The slot from which to make a copy. ++ * @return @p this. ++ */ ++ Slot7& operator=(const parent_type& src) ++ { parent_type::operator=(src); return *this; } ++}; ++ ++ ++ ++#ifndef DOXYGEN_SHOULD_SKIP_THIS ++/* gcc 3.2 reports a strange conflict between SigC::slot() and sigc::slot<> ++ * when "using namespace SigC" and later using a slot(obj,func) overload ++ * without the prefix "SigC::". Probably a compiler bug. I will investigate. ++ * ++ * This ugly hack avoids the error: ++ */ ++// #define slot(...) make_slot(__VA_ARGS__) /* only works for gcc */ ++#endif + ++ ++// slot() ++/** Creates a functor of type SigC::Slot0 that wraps an existing non-member function. ++ * ++ * @param _A_func Pointer to function that should be wrapped. ++ * @return Functor that executes _A_func on invokation. ++ * ++ * @deprecated Use sigc::ptr_fun() instead. ++ * @ingroup compat ++ */ ++template <class T_return> ++inline Slot0<T_return> ++slot(T_return (*_A_func)()) ++{ return Slot0<T_return>(_A_func); } ++ ++/** Creates a functor of type SigC::Slot1 that wraps an existing non-member function. ++ * ++ * @param _A_func Pointer to function that should be wrapped. ++ * @return Functor that executes _A_func on invokation. ++ * ++ * @deprecated Use sigc::ptr_fun() instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1> ++inline Slot1<T_return, T_arg1> ++slot(T_return (*_A_func)(T_arg1)) ++{ return Slot1<T_return, T_arg1>(_A_func); } ++ ++/** Creates a functor of type SigC::Slot2 that wraps an existing non-member function. ++ * ++ * @param _A_func Pointer to function that should be wrapped. ++ * @return Functor that executes _A_func on invokation. ++ * ++ * @deprecated Use sigc::ptr_fun() instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2> ++inline Slot2<T_return, T_arg1,T_arg2> ++slot(T_return (*_A_func)(T_arg1,T_arg2)) ++{ return Slot2<T_return, T_arg1,T_arg2>(_A_func); } ++ ++/** Creates a functor of type SigC::Slot3 that wraps an existing non-member function. ++ * ++ * @param _A_func Pointer to function that should be wrapped. ++ * @return Functor that executes _A_func on invokation. ++ * ++ * @deprecated Use sigc::ptr_fun() instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3> ++inline Slot3<T_return, T_arg1,T_arg2,T_arg3> ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3)) ++{ return Slot3<T_return, T_arg1,T_arg2,T_arg3>(_A_func); } ++ ++/** Creates a functor of type SigC::Slot4 that wraps an existing non-member function. ++ * ++ * @param _A_func Pointer to function that should be wrapped. ++ * @return Functor that executes _A_func on invokation. ++ * ++ * @deprecated Use sigc::ptr_fun() instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4> ++inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4)) ++{ return Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); } ++ ++/** Creates a functor of type SigC::Slot5 that wraps an existing non-member function. ++ * ++ * @param _A_func Pointer to function that should be wrapped. ++ * @return Functor that executes _A_func on invokation. ++ * ++ * @deprecated Use sigc::ptr_fun() instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5> ++inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5)) ++{ return Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func); } ++ ++/** Creates a functor of type SigC::Slot6 that wraps an existing non-member function. ++ * ++ * @param _A_func Pointer to function that should be wrapped. ++ * @return Functor that executes _A_func on invokation. ++ * ++ * @deprecated Use sigc::ptr_fun() instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6> ++inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6)) ++{ return Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func); } ++ ++/** Creates a functor of type SigC::Slot7 that wraps an existing non-member function. ++ * ++ * @param _A_func Pointer to function that should be wrapped. ++ * @return Functor that executes _A_func on invokation. ++ * ++ * @deprecated Use sigc::ptr_fun() instead. ++ * @ingroup compat ++ */ ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7> ++inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7)) ++{ return Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func); } ++ ++ ++ ++} ++ ++// From sigc++/object.h ++namespace SigC { ++ ++// Object ++typedef ::sigc::trackable Object; ++ ++} ++ ++namespace SigC ++{ + template <class T_return, class T_obj1, class T_obj2> + inline Slot0<T_return> + slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)() ) diff --git a/community/visualboyadvance/1.7.2-gcc34.patch b/community/visualboyadvance/1.7.2-gcc34.patch new file mode 100644 index 000000000..8fa4fbf8d --- /dev/null +++ b/community/visualboyadvance/1.7.2-gcc34.patch @@ -0,0 +1,41 @@ +diff -ur src/gtk/joypadconfig.h src/gtk/joypadconfig.h +--- src/gtk/joypadconfig.h 2004-05-10 16:43:21.000000000 +0200 ++++ src/gtk/joypadconfig.h 2004-08-12 22:30:20.838039064 +0200 +@@ -22,8 +22,8 @@ + + #include <vector> + +-#include <libglademm.h> + #include <gtkmm.h> ++#include <libglademm.h> + + #ifndef GTKMM20 + # include "sigccompat.h" +diff -ur src/gtk/main.cpp src/gtk/main.cpp +--- src/gtk/main.cpp 2004-05-21 18:02:35.000000000 +0200 ++++ src/gtk/main.cpp 2004-08-12 22:39:08.633801912 +0200 +@@ -22,10 +22,10 @@ + + #include <list> + +-#include <libglademm.h> + #include <gtkmm/main.h> + #include <gtkmm/window.h> + #include <gtkmm/messagedialog.h> ++#include <libglademm.h> + + #include "images/vba-wm-pixbufs.h" + +diff -ur src/gtk/window.h src/gtk/window.h +--- src/gtk/window.h 2004-05-21 15:25:41.000000000 +0200 ++++ src/gtk/window.h 2004-08-12 22:30:58.650290728 +0200 +@@ -23,8 +23,8 @@ + #include <sys/types.h> + #include <stdarg.h> + +-#include <libglademm.h> + #include <gtkmm.h> ++#include <libglademm.h> + + #ifndef GTKMM20 + # include "sigccompat.h" diff --git a/community/visualboyadvance/1.7.2-gcc41.patch b/community/visualboyadvance/1.7.2-gcc41.patch new file mode 100644 index 000000000..cacf8e251 --- /dev/null +++ b/community/visualboyadvance/1.7.2-gcc41.patch @@ -0,0 +1,27 @@ +diff -ru src/prof/prof.cpp src/prof/prof.cpp +--- src/prof/prof.cpp 2004-05-14 00:31:58.000000000 +1000 ++++ src/prof/prof.cpp 2006-06-03 13:49:41.000000000 +1000 +@@ -266,7 +266,7 @@ + for (toindex=froms[fromindex]; toindex!=0; toindex=tos[toindex].link) { + if(profWrite8(fd, GMON_TAG_CG_ARC) || + profWrite32(fd, (u32)frompc) || +- profWrite32(fd, (u32)tos[toindex].selfpc) || ++ profWrite32(fd, (u32)(intptr_t)tos[toindex].selfpc) || + profWrite32(fd, tos[toindex].count)) { + systemMessage(0, "mcount: arc"); + fclose(fd); +diff -ru src/sdl/debugger.cpp src/sdl/debugger.cpp +--- src/sdl/debugger.cpp 2004-05-14 00:13:14.000000000 +1000 ++++ src/sdl/debugger.cpp 2006-06-03 13:49:57.000000000 +1000 +@@ -950,9 +950,9 @@ + { + u32 address = 0; + if(mem >= (u32*)&workRAM[0] && mem <= (u32*)&workRAM[0x3ffff]) +- address = 0x2000000 + ((u32)mem - (u32)&workRAM[0]); ++ address = 0x2000000 + ((u32)(intptr_t)mem - (u32)(intptr_t)&workRAM[0]); + else +- address = 0x3000000 + ((u32)mem - (u32)&internalRAM[0]); ++ address = 0x3000000 + ((u32)(intptr_t)mem - (u32)(intptr_t)&internalRAM[0]); + + if(size == 2) + printf("Breakpoint (on write) address %08x old:%08x new:%08x\n", diff --git a/community/visualboyadvance/1.7.2-glibc.patch b/community/visualboyadvance/1.7.2-glibc.patch new file mode 100644 index 000000000..5211b3623 --- /dev/null +++ b/community/visualboyadvance/1.7.2-glibc.patch @@ -0,0 +1,76 @@ +--- src/GBA.cpp ++++ src/GBA.cpp +@@ -1130,7 +1130,7 @@ + bool CPUIsZipFile(const char * file) + { + if(strlen(file) > 4) { +- char * p = strrchr(file,'.'); ++ const char * p = strrchr(file,'.'); + + if(p != NULL) { + if(_stricmp(p, ".zip") == 0) +@@ -1145,7 +1145,7 @@ + { + cpuIsMultiBoot = false; + if(strlen(file) > 4) { +- char * p = strrchr(file,'.'); ++ const char * p = strrchr(file,'.'); + + if(p != NULL) { + if(_stricmp(p, ".gba") == 0) +@@ -1169,7 +1169,7 @@ + bool CPUIsGBABios(const char * file) + { + if(strlen(file) > 4) { +- char * p = strrchr(file,'.'); ++ const char * p = strrchr(file,'.'); + + if(p != NULL) { + if(_stricmp(p, ".gba") == 0) +@@ -1189,7 +1189,7 @@ + bool CPUIsELF(const char *file) + { + if(strlen(file) > 4) { +- char * p = strrchr(file,'.'); ++ const char * p = strrchr(file,'.'); + + if(p != NULL) { + if(_stricmp(p, ".elf") == 0) +--- src/Util.cpp ++++ src/Util.cpp +@@ -478,7 +478,7 @@ + { + cpuIsMultiBoot = false; + if(strlen(file) > 4) { +- char * p = strrchr(file,'.'); ++ const char * p = strrchr(file,'.'); + + if(p != NULL) { + if(_stricmp(p, ".gba") == 0) +@@ -502,7 +502,7 @@ + bool utilIsGBImage(const char * file) + { + if(strlen(file) > 4) { +- char * p = strrchr(file,'.'); ++ const char * p = strrchr(file,'.'); + + if(p != NULL) { + if(_stricmp(p, ".gb") == 0) +@@ -522,7 +522,7 @@ + bool utilIsZipFile(const char *file) + { + if(strlen(file) > 4) { +- char * p = strrchr(file,'.'); ++ const char * p = strrchr(file,'.'); + + if(p != NULL) { + if(_stricmp(p, ".zip") == 0) +@@ -552,7 +552,7 @@ + bool utilIsGzipFile(const char *file) + { + if(strlen(file) > 3) { +- char * p = strrchr(file,'.'); ++ const char * p = strrchr(file,'.'); + + if(p != NULL) { + if(_stricmp(p, ".gz") == 0) diff --git a/community/visualboyadvance/1.7.2-homedir.patch b/community/visualboyadvance/1.7.2-homedir.patch new file mode 100644 index 000000000..e93d32cf5 --- /dev/null +++ b/community/visualboyadvance/1.7.2-homedir.patch @@ -0,0 +1,11 @@ +--- src/sdl/SDL.cpp.orig 2004-08-15 02:43:28.232750688 -0400 ++++ src/sdl/SDL.cpp 2004-08-15 02:44:01.557684528 -0400 +@@ -887,7 +887,7 @@ + + if(home != NULL) { + fprintf(stderr, "Searching home directory: %s\n", home); +- sprintf(path, "%s%c%s", home, FILE_SEP, name); ++ sprintf(path, "%s%c.%s%c%s", home, FILE_SEP, EXE_NAME, FILE_SEP, name); + f = fopen(path, "r"); + if(f != NULL) + return f; diff --git a/community/visualboyadvance/1.7.2-uninit.patch b/community/visualboyadvance/1.7.2-uninit.patch new file mode 100644 index 000000000..b54c2e8ab --- /dev/null +++ b/community/visualboyadvance/1.7.2-uninit.patch @@ -0,0 +1,13 @@ +diff -ru src/gtk/window.cpp src/gtk/window.cpp +--- src/gtk/window.cpp 2004-05-14 00:31:58.000000000 +1000 ++++ src/gtk/window.cpp 2007-03-17 14:57:22.000000000 -0500 +@@ -91,7 +91,8 @@ + m_iFilterIBMin (FirstFilterIB), + m_iFilterIBMax (LastFilterIB), + m_iJoypadMin (1), +- m_iJoypadMax (4) ++ m_iJoypadMax (4), ++ m_poKeymap (NULL) + { + m_poXml = _poXml; + m_poFileOpenDialog = NULL; diff --git a/community/visualboyadvance/PKGBUILD b/community/visualboyadvance/PKGBUILD new file mode 100644 index 000000000..4ae2014b7 --- /dev/null +++ b/community/visualboyadvance/PKGBUILD @@ -0,0 +1,48 @@ +# $Id: PKGBUILD 63767 2012-02-05 12:13:21Z ibiru $ +# Maintainer: Daenyth +# Contributor: Eric Belanger <belanger@astro.umontreal.ca> +# Contributor: Shahar Weiss <sweiss4@gmx.net> +# Contributor: Alexander Rødseth <rodseth@gmail.com> +pkgname=visualboyadvance +pkgver=1.7.2 +pkgrel=9 +pkgdesc="Emulator for Gameboy and Gameboy Advance systems" +arch=('x86_64' 'i686') +url="http://vba.ngemu.com/" +license=("GPL") +depends=('libglademm' 'sdl') +makedepends=('nasm') +backup=('etc/VisualBoyAdvance.cfg') +source=("http://downloads.sourceforge.net/sourceforge/vba/VisualBoyAdvance-src-$pkgver.tar.gz" + '1.7.2-deprecatedsigc++.patch' '1.7.2-gcc34.patch' '1.7.2-gcc41.patch' + '1.7.2-glibc.patch' '1.7.2-homedir.patch' '1.7.2-uninit.patch') +md5sums=('cc02339e3fd8efd9f23121b0a2f81fd8' + '95596fbe499c23b8154142b5789cd630' + 'e7c816ac1adf832c8bd3f6b899d6b935' + '22c90f2d75856c8407f70b19038105a4' + 'e7a5188b483e2c4d2fee2a5efb088908' + 'ef02d9be59ab74afa9a8f12e17e359d4' + '004c269a9cdbfa0f4b7fd51978f78705') + +build() { + cd "$srcdir/VisualBoyAdvance-$pkgver" + + sed -i 's:setjmp(png_ptr->jmpbuf):1+1==3:' src/Util.cpp + + patch -Np0 < "$srcdir/$pkgver-homedir.patch" + patch -Np0 < "$srcdir/$pkgver-gcc34.patch" + patch -Np0 < "$srcdir/$pkgver-gcc41.patch" + patch -Np0 < "$srcdir/$pkgver-deprecatedsigc++.patch" + patch -Np0 < "$srcdir/$pkgver-uninit.patch" + patch -Np0 < "$srcdir/$pkgver-glibc.patch" + ./configure --prefix=/usr --sysconfdir=/etc --enable-gtk=2.4 + make +} + +package() { + cd "$srcdir/VisualBoyAdvance-$pkgver" + + make DESTDIR="$pkgdir" install +} + +# vim:set ts=2 sw=2 et: |