archlinuxarm/PKGBUILDs
1
0
Fork 0
mirror of https://github.com/archlinuxarm/PKGBUILDs.git synced 2024-11-08 22:45:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

added community/visualboyadvance, fixes #154

Browse source
This commit is contained in:
Kevin Mihelich 2012-09-17 17:23:13 +00:00
parent 74e90fc40f
commit 0c7ef0583d
9 changed files with 956 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
community/visualboyadvance/1.7.2-debugger.patch Normal file
View file

@ -0,0 +1,30 @@
diff -Naur VisualBoyAdvance-1.7.2-old/src/sdl/debugger.cpp VisualBoyAdvance-1.7.2-new/src/sdl/debugger.cpp
--- VisualBoyAdvance-1.7.2-old/src/sdl/debugger.cpp 2004-05-13 07:13:14.000000000 -0700
+++ VisualBoyAdvance-1.7.2-new/src/sdl/debugger.cpp 2012-03-22 22:45:31.000000000 -0700
@@ -1280,7 +1280,7 @@
if(n == 2) {
u32 addr = 0;
sscanf(args[1], "%x", &addr);
- for(int i = 0; i < 16; i++) {
+ for(int loop_i = 0; loop_i < 16; loop_i++) {
int a = debuggerReadByte(addr);
int b = debuggerReadByte(addr+1);
int c = debuggerReadByte(addr+2);
@@ -1316,7 +1316,7 @@
u32 addr = 0;
sscanf(args[1], "%x", &addr);
addr = addr & 0xfffffffe;
- for(int i = 0; i < 16; i++) {
+ for(int loop_i = 0; loop_i < 16; loop_i++) {
int a = debuggerReadByte(addr);
int b = debuggerReadByte(addr+1);
int c = debuggerReadByte(addr+2);
@@ -1352,7 +1352,7 @@
u32 addr = 0;
sscanf(args[1], "%x", &addr);
addr = addr & 0xfffffffc;
- for(int i = 0; i < 16; i++) {
+ for(int loop_i = 0; loop_i < 16; loop_i++) {
int a = debuggerReadByte(addr);
int b = debuggerReadByte(addr+1);
int c = debuggerReadByte(addr+2);

692
community/visualboyadvance/1.7.2-deprecatedsigc++.patch Normal file
View file

@ -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)() )

41
community/visualboyadvance/1.7.2-gcc34.patch Normal file
View file

@ -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"

27
community/visualboyadvance/1.7.2-gcc41.patch Normal file
View file

@ -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",

76
community/visualboyadvance/1.7.2-glibc.patch Normal file
View file

@ -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)

11
community/visualboyadvance/1.7.2-homedir.patch Normal file
View file

@ -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;

13
community/visualboyadvance/1.7.2-uninit.patch Normal file
View file

@ -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;

10
community/visualboyadvance/1.7.2-util.patch Normal file
View file

@ -0,0 +1,10 @@
--- src/Util.cpp.orig 2012-07-19 22:08:18.559690539 +0200
+++ src/Util.cpp 2012-07-19 22:08:42.548436166 +0200
@@ -984,7 +984,7 @@
gzFile utilGzOpen(const char *file, const char *mode)
{
- utilGzWriteFunc = (int (*)(void *,void * const, unsigned int))gzwrite;
+ utilGzWriteFunc = (int (ZEXPORT *)(gzFile,const voidp, unsigned int))gzwrite;
utilGzReadFunc = gzread;
utilGzCloseFunc = gzclose;

56
community/visualboyadvance/PKGBUILD Normal file
View file

@ -0,0 +1,56 @@
# $Id: PKGBUILD 63766 2012-02-05 12:13:13Z ibiru $
# Maintainer: Daenyth
# Contributor: Eric Belanger <belanger@astro.umontreal.ca>
# Contributor: Shahar Weiss <sweiss4@gmx.net>
# Contributor: Alexander Rødseth <rodseth@gmail.com>
# ALARM: Kevin Mihelich <kevin@archlinuxarm.org>
# - patches to fix FTBFS: 1.7.2-debugger.patch 1.7.2-util.patch
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' '1.7.2-debugger.patch' '1.7.2-util.patch')
md5sums=('cc02339e3fd8efd9f23121b0a2f81fd8'
'95596fbe499c23b8154142b5789cd630'
'e7c816ac1adf832c8bd3f6b899d6b935'
'22c90f2d75856c8407f70b19038105a4'
'e7a5188b483e2c4d2fee2a5efb088908'
'ef02d9be59ab74afa9a8f12e17e359d4'
'004c269a9cdbfa0f4b7fd51978f78705'
'db64f9d34f0b642b254c44ddaafa553b'
'2ae89e9a858bc396891340d0308a794b')
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"
patch -Np1 -i ../1.7.2-debugger.patch
patch -Np0 -i ../1.7.2-util.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: