wok-next rev 7031
Add: visualboyadvance & visualboyadvance-gtk (1.7.2)
| author | Antoine Bodin <gokhlayeh@slitaz.org> |
|---|---|
| date | Sun Oct 31 23:23:34 2010 +0100 (2010-10-31) |
| parents | 28c40f5c21f5 |
| children | 79077110c5c7 |
| files | visualboyadvance-gtk/receipt visualboyadvance-gtk/stuff/visualboyadvance-gtk.desktop visualboyadvance/receipt visualboyadvance/stuff/1.7.2-deprecatedsigc++.patch visualboyadvance/stuff/1.7.2-gcc34.patch visualboyadvance/stuff/1.7.2-gcc41.patch visualboyadvance/stuff/1.7.2-glibc.patch visualboyadvance/stuff/1.7.2-homedir.patch visualboyadvance/stuff/1.7.2-uninit.patch |
line diff
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 1.2 +++ b/visualboyadvance-gtk/receipt Sun Oct 31 23:23:34 2010 +0100 1.3 @@ -0,0 +1,21 @@ 1.4 +# SliTaz package receipt. 1.5 + 1.6 +PACKAGE="visualboyadvance-gtk" 1.7 +VERSION="1.7.2" 1.8 +CATEGORY="games" 1.9 +SHORT_DESC="An emulator for Gameboy and Gameboy Advance systems (GTK frontend)." 1.10 +MAINTAINER="gokhlayeh@slitaz.org" 1.11 +WANTED="visualboyadvance" 1.12 +DEPENDS="libglademm visualboyadvance" 1.13 +WEB_SITE="http://vba.ngemu.com/" 1.14 + 1.15 +# Rules to gen a SliTaz package suitable for Tazpkg. 1.16 +genpkg_rules() 1.17 +{ 1.18 + mkdir -p $fs/usr/bin $fs/usr/games $fs/usr/share/applications 1.19 + cp -a stuff/*.desktop $fs/usr/share/applications 1.20 + _pkg=${_pkg/$WANTED-$VERSION/VisualBoyAdvance-$VERSION} 1.21 + cp -a $_pkg/usr/bin/gvba $fs/usr/bin 1.22 + cp -a $_pkg/usr/games/* $fs/usr/games 1.23 +} 1.24 +
2.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 2.2 +++ b/visualboyadvance-gtk/stuff/visualboyadvance-gtk.desktop Sun Oct 31 23:23:34 2010 +0100 2.3 @@ -0,0 +1,9 @@ 2.4 +[Desktop Entry] 2.5 +Name=Visual Boy Advance GTK+ 2.6 +Comment=An emulator for Gameboy and Gameboy Advance systems 2.7 +Exec=/usr/bin/gvba 2.8 +Icon=/usr/games/VisualBoyAdvance/vba-64.png 2.9 +Terminal=false 2.10 +Type=Application 2.11 +Categories=Game; 2.12 +StartupNotify=false
3.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 3.2 +++ b/visualboyadvance/receipt Sun Oct 31 23:23:34 2010 +0100 3.3 @@ -0,0 +1,41 @@ 3.4 +# SliTaz package receipt. 3.5 + 3.6 +PACKAGE="visualboyadvance" 3.7 +VERSION="1.7.2" 3.8 +CATEGORY="games" 3.9 +SHORT_DESC="An emulator for Gameboy and Gameboy Advance systems." 3.10 +MAINTAINER="gokhlayeh@slitaz.org" 3.11 +DEPENDS="libsdl" 3.12 +BUILD_DEPENDS="libglademm-dev libglademm libsdl-dev patch nasm gtk+-dev gtkmm-dev cairomm-dev libglade-dev libxml2-dev zlib-dev" 3.13 +SOURCE="VisualBoyAdvance" 3.14 +TARBALL="$SOURCE-src-$VERSION.tar.gz" 3.15 +CONFIG_FILES="'/etc/VisualBoyAdvance.cfg" 3.16 +WEB_SITE="http://vba.ngemu.com/" 3.17 +WGET_URL="http://downloads.sourceforge.net/sourceforge/vba/$TARBALL" 3.18 + 3.19 +# Rules to configure and make the package. 3.20 +compile_rules() 3.21 +{ 3.22 + cd $src 3.23 + for i in ../stuff/$VERSION-*.patch; do 3.24 + patch -Np0 < $i 3.25 + done 3.26 + ./configure \ 3.27 + --prefix=/usr \ 3.28 + --infodir=/usr/share/info \ 3.29 + --mandir=/usr/share/man \ 3.30 + --sysconfdir=/etc \ 3.31 + --datadir=/usr/games \ 3.32 + --enable-gtk=2.4 \ 3.33 + $CONFIGURE_ARGS && 3.34 + make -j 4 && make DESTDIR=$PWD/_pkg install 3.35 +} 3.36 + 3.37 +# Rules to gen a SliTaz package suitable for Tazpkg. 3.38 +genpkg_rules() 3.39 +{ 3.40 + mkdir -p $fs/usr/bin 3.41 + cp -a $_pkg/etc $fs 3.42 + cp -a $_pkg/usr/bin/VisualBoyAdvance $fs/usr/bin 3.43 +} 3.44 +
4.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 4.2 +++ b/visualboyadvance/stuff/1.7.2-deprecatedsigc++.patch Sun Oct 31 23:23:34 2010 +0100 4.3 @@ -0,0 +1,692 @@ 4.4 +--- src/gtk/sigccompat.h.old 2008-05-02 10:46:45.000000000 +0200 4.5 ++++ src/gtk/sigccompat.h 2008-05-02 10:47:08.000000000 +0200 4.6 +@@ -20,7 +20,7 @@ 4.7 + #ifndef __VBA_SIGCCOMPAT_H__ 4.8 + #define __VBA_SIGCCOMPAT_H__ 4.9 + 4.10 +-#undef LIBSIGC_DISABLE_DEPRECATED 4.11 ++#define LIBSIGC_DISABLE_DEPRECATED 4.12 + #include <sigc++/bind.h> 4.13 + #include <sigc++/connection.h> 4.14 + 4.15 +@@ -28,9 +28,679 @@ 4.16 + #include <sigc++/object.h> 4.17 + #include <sigc++/functors/mem_fun.h> 4.18 + 4.19 +-namespace SigC 4.20 ++ 4.21 ++// From sigc++/bind.h 4.22 ++namespace SigC { 4.23 ++ 4.24 ++template <class T_bound1, class T_functor> 4.25 ++inline ::sigc::bind_functor<-1, T_functor, 4.26 ++ typename ::sigc::unwrap_reference<T_bound1>::type> 4.27 ++bind(const T_functor& _A_functor, T_bound1 _A_b1) 4.28 ++{ return ::sigc::bind_functor<-1, T_functor, 4.29 ++ typename ::sigc::unwrap_reference<T_bound1>::type> 4.30 ++ (_A_functor, _A_b1); 4.31 ++} 4.32 ++ 4.33 ++template <class T_bound1, class T_bound2, class T_functor> 4.34 ++inline ::sigc::bind_functor<-1, T_functor, 4.35 ++ typename ::sigc::unwrap_reference<T_bound1>::type, 4.36 ++ typename ::sigc::unwrap_reference<T_bound2>::type> 4.37 ++bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2) 4.38 ++{ return ::sigc::bind_functor<-1, T_functor, 4.39 ++ typename ::sigc::unwrap_reference<T_bound1>::type, 4.40 ++ typename ::sigc::unwrap_reference<T_bound2>::type> 4.41 ++ (_A_functor, _A_b1, _A_b2); 4.42 ++} 4.43 ++ 4.44 ++template <class T_bound1, class T_bound2, class T_bound3, class T_functor> 4.45 ++inline ::sigc::bind_functor<-1, T_functor, 4.46 ++ typename ::sigc::unwrap_reference<T_bound1>::type, 4.47 ++ typename ::sigc::unwrap_reference<T_bound2>::type, 4.48 ++ typename ::sigc::unwrap_reference<T_bound3>::type> 4.49 ++bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2,T_bound3 _A_b3) 4.50 ++{ return ::sigc::bind_functor<-1, T_functor, 4.51 ++ typename ::sigc::unwrap_reference<T_bound1>::type, 4.52 ++ typename ::sigc::unwrap_reference<T_bound2>::type, 4.53 ++ typename ::sigc::unwrap_reference<T_bound3>::type> 4.54 ++ (_A_functor, _A_b1, _A_b2, _A_b3); 4.55 ++} 4.56 ++ 4.57 ++} 4.58 ++ 4.59 ++// From sigc++/connection.h 4.60 ++namespace SigC { 4.61 ++ 4.62 ++/** Convinience class for safe disconnection. 4.63 ++ * Iterators must not be used beyond the lifetime of the list 4.64 ++ * they work on. A connection object can be created from a 4.65 ++ * slot list iterator and may safely be used to disconnect 4.66 ++ * the referred slot at any time (disconnect()). If the slot 4.67 ++ * has already been destroyed, disconnect() does nothing. empty() or 4.68 ++ * operator bool() can be used to test whether the connection is 4.69 ++ * still active. The connection can be blocked (block(), unblock()). 4.70 ++ * 4.71 ++ * This is possible because the connection object gets notified 4.72 ++ * when the referred slot dies (notify()). 4.73 ++ * 4.74 ++ * @deprecated Use sigc::connection instead. 4.75 ++ * @ingroup compat 4.76 ++ */ 4.77 ++typedef ::sigc::connection Connection; 4.78 ++ 4.79 ++} 4.80 ++ 4.81 ++// From sigc++/slot.h 4.82 ++namespace SigC { 4.83 ++ 4.84 ++// SlotN 4.85 ++/** Converts an arbitrary functor to a unified type which is opaque. 4.86 ++ * Slot0 itself is a functor or to be more precise a closure. It contains 4.87 ++ * a single, arbitrary functor (or closure) that is executed in operator()(). 4.88 ++ * 4.89 ++ * The template arguments determine the function signature of operator()(): 4.90 ++ * - @e T_return The return type of operator()(). 4.91 ++ * 4.92 ++ * To use simply assign the slot to the desired functor. If the functor 4.93 ++ * is not compatible with the parameter list defined with the template 4.94 ++ * arguments compiler errors are triggered. When called the slot 4.95 ++ * will invoke the functor with minimal copies. 4.96 ++ * block() and unblock() can be used to block the functor's invocation 4.97 ++ * from operator()() temporarily. 4.98 ++ * 4.99 ++ * @par Example: 4.100 ++ * @code 4.101 ++ * #include <sigc++/slot.h> 4.102 ++ * void foo(int) {} 4.103 ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); 4.104 ++ * s(19); 4.105 ++ * @endcode 4.106 ++ * 4.107 ++ * @deprecated Use the unnumbered template sigc::slot instead. 4.108 ++ * @ingroup compat 4.109 ++ */ 4.110 ++template <class T_return> 4.111 ++class Slot0 4.112 ++ : public ::sigc::slot<T_return> 4.113 ++{ 4.114 ++public: 4.115 ++ typedef ::sigc::slot<T_return> parent_type; 4.116 ++ 4.117 ++ /// Constructs an empty slot. 4.118 ++ Slot0() {} 4.119 ++ 4.120 ++ /** Constructs a slot from an arbitrary functor. 4.121 ++ * @param _A_func The desired functor the new slot should be assigned to. 4.122 ++ */ 4.123 ++ template <class T_functor> 4.124 ++ Slot0(const T_functor& _A_func) 4.125 ++ : ::sigc::slot<T_return>(_A_func) {} 4.126 ++ 4.127 ++ /** Constructs a slot, copying an existing one. 4.128 ++ * @param src The existing slot to copy. 4.129 ++ */ 4.130 ++ Slot0(const parent_type& src) 4.131 ++ : parent_type(src) {} 4.132 ++ 4.133 ++ /** Overrides this slot making a copy from another slot. 4.134 ++ * @param src The slot from which to make a copy. 4.135 ++ * @return @p this. 4.136 ++ */ 4.137 ++ Slot0& operator=(const parent_type& src) 4.138 ++ { parent_type::operator=(src); return *this; } 4.139 ++}; 4.140 ++ 4.141 ++/** Converts an arbitrary functor to a unified type which is opaque. 4.142 ++ * Slot1 itself is a functor or to be more precise a closure. It contains 4.143 ++ * a single, arbitrary functor (or closure) that is executed in operator()(). 4.144 ++ * 4.145 ++ * The template arguments determine the function signature of operator()(): 4.146 ++ * - @e T_return The return type of operator()(). 4.147 ++ * - @e T_arg1 Argument type used in the definition of operator()(). 4.148 ++ * 4.149 ++ * To use simply assign the slot to the desired functor. If the functor 4.150 ++ * is not compatible with the parameter list defined with the template 4.151 ++ * arguments compiler errors are triggered. When called the slot 4.152 ++ * will invoke the functor with minimal copies. 4.153 ++ * block() and unblock() can be used to block the functor's invocation 4.154 ++ * from operator()() temporarily. 4.155 ++ * 4.156 ++ * @par Example: 4.157 ++ * @code 4.158 ++ * #include <sigc++/slot.h> 4.159 ++ * void foo(int) {} 4.160 ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); 4.161 ++ * s(19); 4.162 ++ * @endcode 4.163 ++ * 4.164 ++ * @deprecated Use the unnumbered template sigc::slot instead. 4.165 ++ * @ingroup compat 4.166 ++ */ 4.167 ++template <class T_return, class T_arg1> 4.168 ++class Slot1 4.169 ++ : public ::sigc::slot<T_return, T_arg1> 4.170 ++{ 4.171 ++public: 4.172 ++ typedef ::sigc::slot<T_return, T_arg1> parent_type; 4.173 ++ 4.174 ++ /// Constructs an empty slot. 4.175 ++ Slot1() {} 4.176 ++ 4.177 ++ /** Constructs a slot from an arbitrary functor. 4.178 ++ * @param _A_func The desired functor the new slot should be assigned to. 4.179 ++ */ 4.180 ++ template <class T_functor> 4.181 ++ Slot1(const T_functor& _A_func) 4.182 ++ : ::sigc::slot<T_return, T_arg1>(_A_func) {} 4.183 ++ 4.184 ++ /** Constructs a slot, copying an existing one. 4.185 ++ * @param src The existing slot to copy. 4.186 ++ */ 4.187 ++ Slot1(const parent_type& src) 4.188 ++ : parent_type(src) {} 4.189 ++ 4.190 ++ /** Overrides this slot making a copy from another slot. 4.191 ++ * @param src The slot from which to make a copy. 4.192 ++ * @return @p this. 4.193 ++ */ 4.194 ++ Slot1& operator=(const parent_type& src) 4.195 ++ { parent_type::operator=(src); return *this; } 4.196 ++}; 4.197 ++ 4.198 ++/** Converts an arbitrary functor to a unified type which is opaque. 4.199 ++ * Slot2 itself is a functor or to be more precise a closure. It contains 4.200 ++ * a single, arbitrary functor (or closure) that is executed in operator()(). 4.201 ++ * 4.202 ++ * The template arguments determine the function signature of operator()(): 4.203 ++ * - @e T_return The return type of operator()(). 4.204 ++ * - @e T_arg1 Argument type used in the definition of operator()(). 4.205 ++ * - @e T_arg2 Argument type used in the definition of operator()(). 4.206 ++ * 4.207 ++ * To use simply assign the slot to the desired functor. If the functor 4.208 ++ * is not compatible with the parameter list defined with the template 4.209 ++ * arguments compiler errors are triggered. When called the slot 4.210 ++ * will invoke the functor with minimal copies. 4.211 ++ * block() and unblock() can be used to block the functor's invocation 4.212 ++ * from operator()() temporarily. 4.213 ++ * 4.214 ++ * @par Example: 4.215 ++ * @code 4.216 ++ * #include <sigc++/slot.h> 4.217 ++ * void foo(int) {} 4.218 ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); 4.219 ++ * s(19); 4.220 ++ * @endcode 4.221 ++ * 4.222 ++ * @deprecated Use the unnumbered template sigc::slot instead. 4.223 ++ * @ingroup compat 4.224 ++ */ 4.225 ++template <class T_return, class T_arg1,class T_arg2> 4.226 ++class Slot2 4.227 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2> 4.228 ++{ 4.229 ++public: 4.230 ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2> parent_type; 4.231 ++ 4.232 ++ /// Constructs an empty slot. 4.233 ++ Slot2() {} 4.234 ++ 4.235 ++ /** Constructs a slot from an arbitrary functor. 4.236 ++ * @param _A_func The desired functor the new slot should be assigned to. 4.237 ++ */ 4.238 ++ template <class T_functor> 4.239 ++ Slot2(const T_functor& _A_func) 4.240 ++ : ::sigc::slot<T_return, T_arg1,T_arg2>(_A_func) {} 4.241 ++ 4.242 ++ /** Constructs a slot, copying an existing one. 4.243 ++ * @param src The existing slot to copy. 4.244 ++ */ 4.245 ++ Slot2(const parent_type& src) 4.246 ++ : parent_type(src) {} 4.247 ++ 4.248 ++ /** Overrides this slot making a copy from another slot. 4.249 ++ * @param src The slot from which to make a copy. 4.250 ++ * @return @p this. 4.251 ++ */ 4.252 ++ Slot2& operator=(const parent_type& src) 4.253 ++ { parent_type::operator=(src); return *this; } 4.254 ++}; 4.255 ++ 4.256 ++/** Converts an arbitrary functor to a unified type which is opaque. 4.257 ++ * Slot3 itself is a functor or to be more precise a closure. It contains 4.258 ++ * a single, arbitrary functor (or closure) that is executed in operator()(). 4.259 ++ * 4.260 ++ * The template arguments determine the function signature of operator()(): 4.261 ++ * - @e T_return The return type of operator()(). 4.262 ++ * - @e T_arg1 Argument type used in the definition of operator()(). 4.263 ++ * - @e T_arg2 Argument type used in the definition of operator()(). 4.264 ++ * - @e T_arg3 Argument type used in the definition of operator()(). 4.265 ++ * 4.266 ++ * To use simply assign the slot to the desired functor. If the functor 4.267 ++ * is not compatible with the parameter list defined with the template 4.268 ++ * arguments compiler errors are triggered. When called the slot 4.269 ++ * will invoke the functor with minimal copies. 4.270 ++ * block() and unblock() can be used to block the functor's invocation 4.271 ++ * from operator()() temporarily. 4.272 ++ * 4.273 ++ * @par Example: 4.274 ++ * @code 4.275 ++ * #include <sigc++/slot.h> 4.276 ++ * void foo(int) {} 4.277 ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); 4.278 ++ * s(19); 4.279 ++ * @endcode 4.280 ++ * 4.281 ++ * @deprecated Use the unnumbered template sigc::slot instead. 4.282 ++ * @ingroup compat 4.283 ++ */ 4.284 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3> 4.285 ++class Slot3 4.286 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> 4.287 ++{ 4.288 ++public: 4.289 ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> parent_type; 4.290 ++ 4.291 ++ /// Constructs an empty slot. 4.292 ++ Slot3() {} 4.293 ++ 4.294 ++ /** Constructs a slot from an arbitrary functor. 4.295 ++ * @param _A_func The desired functor the new slot should be assigned to. 4.296 ++ */ 4.297 ++ template <class T_functor> 4.298 ++ Slot3(const T_functor& _A_func) 4.299 ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>(_A_func) {} 4.300 ++ 4.301 ++ /** Constructs a slot, copying an existing one. 4.302 ++ * @param src The existing slot to copy. 4.303 ++ */ 4.304 ++ Slot3(const parent_type& src) 4.305 ++ : parent_type(src) {} 4.306 ++ 4.307 ++ /** Overrides this slot making a copy from another slot. 4.308 ++ * @param src The slot from which to make a copy. 4.309 ++ * @return @p this. 4.310 ++ */ 4.311 ++ Slot3& operator=(const parent_type& src) 4.312 ++ { parent_type::operator=(src); return *this; } 4.313 ++}; 4.314 ++ 4.315 ++/** Converts an arbitrary functor to a unified type which is opaque. 4.316 ++ * Slot4 itself is a functor or to be more precise a closure. It contains 4.317 ++ * a single, arbitrary functor (or closure) that is executed in operator()(). 4.318 ++ * 4.319 ++ * The template arguments determine the function signature of operator()(): 4.320 ++ * - @e T_return The return type of operator()(). 4.321 ++ * - @e T_arg1 Argument type used in the definition of operator()(). 4.322 ++ * - @e T_arg2 Argument type used in the definition of operator()(). 4.323 ++ * - @e T_arg3 Argument type used in the definition of operator()(). 4.324 ++ * - @e T_arg4 Argument type used in the definition of operator()(). 4.325 ++ * 4.326 ++ * To use simply assign the slot to the desired functor. If the functor 4.327 ++ * is not compatible with the parameter list defined with the template 4.328 ++ * arguments compiler errors are triggered. When called the slot 4.329 ++ * will invoke the functor with minimal copies. 4.330 ++ * block() and unblock() can be used to block the functor's invocation 4.331 ++ * from operator()() temporarily. 4.332 ++ * 4.333 ++ * @par Example: 4.334 ++ * @code 4.335 ++ * #include <sigc++/slot.h> 4.336 ++ * void foo(int) {} 4.337 ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); 4.338 ++ * s(19); 4.339 ++ * @endcode 4.340 ++ * 4.341 ++ * @deprecated Use the unnumbered template sigc::slot instead. 4.342 ++ * @ingroup compat 4.343 ++ */ 4.344 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4> 4.345 ++class Slot4 4.346 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> 4.347 ++{ 4.348 ++public: 4.349 ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> parent_type; 4.350 ++ 4.351 ++ /// Constructs an empty slot. 4.352 ++ Slot4() {} 4.353 ++ 4.354 ++ /** Constructs a slot from an arbitrary functor. 4.355 ++ * @param _A_func The desired functor the new slot should be assigned to. 4.356 ++ */ 4.357 ++ template <class T_functor> 4.358 ++ Slot4(const T_functor& _A_func) 4.359 ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func) {} 4.360 ++ 4.361 ++ /** Constructs a slot, copying an existing one. 4.362 ++ * @param src The existing slot to copy. 4.363 ++ */ 4.364 ++ Slot4(const parent_type& src) 4.365 ++ : parent_type(src) {} 4.366 ++ 4.367 ++ /** Overrides this slot making a copy from another slot. 4.368 ++ * @param src The slot from which to make a copy. 4.369 ++ * @return @p this. 4.370 ++ */ 4.371 ++ Slot4& operator=(const parent_type& src) 4.372 ++ { parent_type::operator=(src); return *this; } 4.373 ++}; 4.374 ++ 4.375 ++/** Converts an arbitrary functor to a unified type which is opaque. 4.376 ++ * Slot5 itself is a functor or to be more precise a closure. It contains 4.377 ++ * a single, arbitrary functor (or closure) that is executed in operator()(). 4.378 ++ * 4.379 ++ * The template arguments determine the function signature of operator()(): 4.380 ++ * - @e T_return The return type of operator()(). 4.381 ++ * - @e T_arg1 Argument type used in the definition of operator()(). 4.382 ++ * - @e T_arg2 Argument type used in the definition of operator()(). 4.383 ++ * - @e T_arg3 Argument type used in the definition of operator()(). 4.384 ++ * - @e T_arg4 Argument type used in the definition of operator()(). 4.385 ++ * - @e T_arg5 Argument type used in the definition of operator()(). 4.386 ++ * 4.387 ++ * To use simply assign the slot to the desired functor. If the functor 4.388 ++ * is not compatible with the parameter list defined with the template 4.389 ++ * arguments compiler errors are triggered. When called the slot 4.390 ++ * will invoke the functor with minimal copies. 4.391 ++ * block() and unblock() can be used to block the functor's invocation 4.392 ++ * from operator()() temporarily. 4.393 ++ * 4.394 ++ * @par Example: 4.395 ++ * @code 4.396 ++ * #include <sigc++/slot.h> 4.397 ++ * void foo(int) {} 4.398 ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); 4.399 ++ * s(19); 4.400 ++ * @endcode 4.401 ++ * 4.402 ++ * @deprecated Use the unnumbered template sigc::slot instead. 4.403 ++ * @ingroup compat 4.404 ++ */ 4.405 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5> 4.406 ++class Slot5 4.407 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> 4.408 ++{ 4.409 ++public: 4.410 ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> parent_type; 4.411 ++ 4.412 ++ /// Constructs an empty slot. 4.413 ++ Slot5() {} 4.414 ++ 4.415 ++ /** Constructs a slot from an arbitrary functor. 4.416 ++ * @param _A_func The desired functor the new slot should be assigned to. 4.417 ++ */ 4.418 ++ template <class T_functor> 4.419 ++ Slot5(const T_functor& _A_func) 4.420 ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func) {} 4.421 ++ 4.422 ++ /** Constructs a slot, copying an existing one. 4.423 ++ * @param src The existing slot to copy. 4.424 ++ */ 4.425 ++ Slot5(const parent_type& src) 4.426 ++ : parent_type(src) {} 4.427 ++ 4.428 ++ /** Overrides this slot making a copy from another slot. 4.429 ++ * @param src The slot from which to make a copy. 4.430 ++ * @return @p this. 4.431 ++ */ 4.432 ++ Slot5& operator=(const parent_type& src) 4.433 ++ { parent_type::operator=(src); return *this; } 4.434 ++}; 4.435 ++ 4.436 ++/** Converts an arbitrary functor to a unified type which is opaque. 4.437 ++ * Slot6 itself is a functor or to be more precise a closure. It contains 4.438 ++ * a single, arbitrary functor (or closure) that is executed in operator()(). 4.439 ++ * 4.440 ++ * The template arguments determine the function signature of operator()(): 4.441 ++ * - @e T_return The return type of operator()(). 4.442 ++ * - @e T_arg1 Argument type used in the definition of operator()(). 4.443 ++ * - @e T_arg2 Argument type used in the definition of operator()(). 4.444 ++ * - @e T_arg3 Argument type used in the definition of operator()(). 4.445 ++ * - @e T_arg4 Argument type used in the definition of operator()(). 4.446 ++ * - @e T_arg5 Argument type used in the definition of operator()(). 4.447 ++ * - @e T_arg6 Argument type used in the definition of operator()(). 4.448 ++ * 4.449 ++ * To use simply assign the slot to the desired functor. If the functor 4.450 ++ * is not compatible with the parameter list defined with the template 4.451 ++ * arguments compiler errors are triggered. When called the slot 4.452 ++ * will invoke the functor with minimal copies. 4.453 ++ * block() and unblock() can be used to block the functor's invocation 4.454 ++ * from operator()() temporarily. 4.455 ++ * 4.456 ++ * @par Example: 4.457 ++ * @code 4.458 ++ * #include <sigc++/slot.h> 4.459 ++ * void foo(int) {} 4.460 ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); 4.461 ++ * s(19); 4.462 ++ * @endcode 4.463 ++ * 4.464 ++ * @deprecated Use the unnumbered template sigc::slot instead. 4.465 ++ * @ingroup compat 4.466 ++ */ 4.467 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6> 4.468 ++class Slot6 4.469 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> 4.470 ++{ 4.471 ++public: 4.472 ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> parent_type; 4.473 ++ 4.474 ++ /// Constructs an empty slot. 4.475 ++ Slot6() {} 4.476 ++ 4.477 ++ /** Constructs a slot from an arbitrary functor. 4.478 ++ * @param _A_func The desired functor the new slot should be assigned to. 4.479 ++ */ 4.480 ++ template <class T_functor> 4.481 ++ Slot6(const T_functor& _A_func) 4.482 ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func) {} 4.483 ++ 4.484 ++ /** Constructs a slot, copying an existing one. 4.485 ++ * @param src The existing slot to copy. 4.486 ++ */ 4.487 ++ Slot6(const parent_type& src) 4.488 ++ : parent_type(src) {} 4.489 ++ 4.490 ++ /** Overrides this slot making a copy from another slot. 4.491 ++ * @param src The slot from which to make a copy. 4.492 ++ * @return @p this. 4.493 ++ */ 4.494 ++ Slot6& operator=(const parent_type& src) 4.495 ++ { parent_type::operator=(src); return *this; } 4.496 ++}; 4.497 ++ 4.498 ++/** Converts an arbitrary functor to a unified type which is opaque. 4.499 ++ * Slot7 itself is a functor or to be more precise a closure. It contains 4.500 ++ * a single, arbitrary functor (or closure) that is executed in operator()(). 4.501 ++ * 4.502 ++ * The template arguments determine the function signature of operator()(): 4.503 ++ * - @e T_return The return type of operator()(). 4.504 ++ * - @e T_arg1 Argument type used in the definition of operator()(). 4.505 ++ * - @e T_arg2 Argument type used in the definition of operator()(). 4.506 ++ * - @e T_arg3 Argument type used in the definition of operator()(). 4.507 ++ * - @e T_arg4 Argument type used in the definition of operator()(). 4.508 ++ * - @e T_arg5 Argument type used in the definition of operator()(). 4.509 ++ * - @e T_arg6 Argument type used in the definition of operator()(). 4.510 ++ * - @e T_arg7 Argument type used in the definition of operator()(). 4.511 ++ * 4.512 ++ * To use simply assign the slot to the desired functor. If the functor 4.513 ++ * is not compatible with the parameter list defined with the template 4.514 ++ * arguments compiler errors are triggered. When called the slot 4.515 ++ * will invoke the functor with minimal copies. 4.516 ++ * block() and unblock() can be used to block the functor's invocation 4.517 ++ * from operator()() temporarily. 4.518 ++ * 4.519 ++ * @par Example: 4.520 ++ * @code 4.521 ++ * #include <sigc++/slot.h> 4.522 ++ * void foo(int) {} 4.523 ++ * SigC::Slot1<void, long> s = SigC::slot(&foo); 4.524 ++ * s(19); 4.525 ++ * @endcode 4.526 ++ * 4.527 ++ * @deprecated Use the unnumbered template sigc::slot instead. 4.528 ++ * @ingroup compat 4.529 ++ */ 4.530 ++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> 4.531 ++class Slot7 4.532 ++ : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> 4.533 + { 4.534 ++public: 4.535 ++ typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> parent_type; 4.536 ++ 4.537 ++ /// Constructs an empty slot. 4.538 ++ Slot7() {} 4.539 ++ 4.540 ++ /** Constructs a slot from an arbitrary functor. 4.541 ++ * @param _A_func The desired functor the new slot should be assigned to. 4.542 ++ */ 4.543 ++ template <class T_functor> 4.544 ++ Slot7(const T_functor& _A_func) 4.545 ++ : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func) {} 4.546 ++ 4.547 ++ /** Constructs a slot, copying an existing one. 4.548 ++ * @param src The existing slot to copy. 4.549 ++ */ 4.550 ++ Slot7(const parent_type& src) 4.551 ++ : parent_type(src) {} 4.552 ++ 4.553 ++ /** Overrides this slot making a copy from another slot. 4.554 ++ * @param src The slot from which to make a copy. 4.555 ++ * @return @p this. 4.556 ++ */ 4.557 ++ Slot7& operator=(const parent_type& src) 4.558 ++ { parent_type::operator=(src); return *this; } 4.559 ++}; 4.560 ++ 4.561 ++ 4.562 ++ 4.563 ++#ifndef DOXYGEN_SHOULD_SKIP_THIS 4.564 ++/* gcc 3.2 reports a strange conflict between SigC::slot() and sigc::slot<> 4.565 ++ * when "using namespace SigC" and later using a slot(obj,func) overload 4.566 ++ * without the prefix "SigC::". Probably a compiler bug. I will investigate. 4.567 ++ * 4.568 ++ * This ugly hack avoids the error: 4.569 ++ */ 4.570 ++// #define slot(...) make_slot(__VA_ARGS__) /* only works for gcc */ 4.571 ++#endif 4.572 + 4.573 ++ 4.574 ++// slot() 4.575 ++/** Creates a functor of type SigC::Slot0 that wraps an existing non-member function. 4.576 ++ * 4.577 ++ * @param _A_func Pointer to function that should be wrapped. 4.578 ++ * @return Functor that executes _A_func on invokation. 4.579 ++ * 4.580 ++ * @deprecated Use sigc::ptr_fun() instead. 4.581 ++ * @ingroup compat 4.582 ++ */ 4.583 ++template <class T_return> 4.584 ++inline Slot0<T_return> 4.585 ++slot(T_return (*_A_func)()) 4.586 ++{ return Slot0<T_return>(_A_func); } 4.587 ++ 4.588 ++/** Creates a functor of type SigC::Slot1 that wraps an existing non-member function. 4.589 ++ * 4.590 ++ * @param _A_func Pointer to function that should be wrapped. 4.591 ++ * @return Functor that executes _A_func on invokation. 4.592 ++ * 4.593 ++ * @deprecated Use sigc::ptr_fun() instead. 4.594 ++ * @ingroup compat 4.595 ++ */ 4.596 ++template <class T_return, class T_arg1> 4.597 ++inline Slot1<T_return, T_arg1> 4.598 ++slot(T_return (*_A_func)(T_arg1)) 4.599 ++{ return Slot1<T_return, T_arg1>(_A_func); } 4.600 ++ 4.601 ++/** Creates a functor of type SigC::Slot2 that wraps an existing non-member function. 4.602 ++ * 4.603 ++ * @param _A_func Pointer to function that should be wrapped. 4.604 ++ * @return Functor that executes _A_func on invokation. 4.605 ++ * 4.606 ++ * @deprecated Use sigc::ptr_fun() instead. 4.607 ++ * @ingroup compat 4.608 ++ */ 4.609 ++template <class T_return, class T_arg1,class T_arg2> 4.610 ++inline Slot2<T_return, T_arg1,T_arg2> 4.611 ++slot(T_return (*_A_func)(T_arg1,T_arg2)) 4.612 ++{ return Slot2<T_return, T_arg1,T_arg2>(_A_func); } 4.613 ++ 4.614 ++/** Creates a functor of type SigC::Slot3 that wraps an existing non-member function. 4.615 ++ * 4.616 ++ * @param _A_func Pointer to function that should be wrapped. 4.617 ++ * @return Functor that executes _A_func on invokation. 4.618 ++ * 4.619 ++ * @deprecated Use sigc::ptr_fun() instead. 4.620 ++ * @ingroup compat 4.621 ++ */ 4.622 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3> 4.623 ++inline Slot3<T_return, T_arg1,T_arg2,T_arg3> 4.624 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3)) 4.625 ++{ return Slot3<T_return, T_arg1,T_arg2,T_arg3>(_A_func); } 4.626 ++ 4.627 ++/** Creates a functor of type SigC::Slot4 that wraps an existing non-member function. 4.628 ++ * 4.629 ++ * @param _A_func Pointer to function that should be wrapped. 4.630 ++ * @return Functor that executes _A_func on invokation. 4.631 ++ * 4.632 ++ * @deprecated Use sigc::ptr_fun() instead. 4.633 ++ * @ingroup compat 4.634 ++ */ 4.635 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4> 4.636 ++inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> 4.637 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4)) 4.638 ++{ return Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); } 4.639 ++ 4.640 ++/** Creates a functor of type SigC::Slot5 that wraps an existing non-member function. 4.641 ++ * 4.642 ++ * @param _A_func Pointer to function that should be wrapped. 4.643 ++ * @return Functor that executes _A_func on invokation. 4.644 ++ * 4.645 ++ * @deprecated Use sigc::ptr_fun() instead. 4.646 ++ * @ingroup compat 4.647 ++ */ 4.648 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5> 4.649 ++inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> 4.650 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5)) 4.651 ++{ return Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func); } 4.652 ++ 4.653 ++/** Creates a functor of type SigC::Slot6 that wraps an existing non-member function. 4.654 ++ * 4.655 ++ * @param _A_func Pointer to function that should be wrapped. 4.656 ++ * @return Functor that executes _A_func on invokation. 4.657 ++ * 4.658 ++ * @deprecated Use sigc::ptr_fun() instead. 4.659 ++ * @ingroup compat 4.660 ++ */ 4.661 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6> 4.662 ++inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> 4.663 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6)) 4.664 ++{ return Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func); } 4.665 ++ 4.666 ++/** Creates a functor of type SigC::Slot7 that wraps an existing non-member function. 4.667 ++ * 4.668 ++ * @param _A_func Pointer to function that should be wrapped. 4.669 ++ * @return Functor that executes _A_func on invokation. 4.670 ++ * 4.671 ++ * @deprecated Use sigc::ptr_fun() instead. 4.672 ++ * @ingroup compat 4.673 ++ */ 4.674 ++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> 4.675 ++inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> 4.676 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7)) 4.677 ++{ return Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func); } 4.678 ++ 4.679 ++ 4.680 ++ 4.681 ++} 4.682 ++ 4.683 ++// From sigc++/object.h 4.684 ++namespace SigC { 4.685 ++ 4.686 ++// Object 4.687 ++typedef ::sigc::trackable Object; 4.688 ++ 4.689 ++} 4.690 ++ 4.691 ++namespace SigC 4.692 ++{ 4.693 + template <class T_return, class T_obj1, class T_obj2> 4.694 + inline Slot0<T_return> 4.695 + slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)() )
5.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 5.2 +++ b/visualboyadvance/stuff/1.7.2-gcc34.patch Sun Oct 31 23:23:34 2010 +0100 5.3 @@ -0,0 +1,41 @@ 5.4 +diff -ur src/gtk/joypadconfig.h src/gtk/joypadconfig.h 5.5 +--- src/gtk/joypadconfig.h 2004-05-10 16:43:21.000000000 +0200 5.6 ++++ src/gtk/joypadconfig.h 2004-08-12 22:30:20.838039064 +0200 5.7 +@@ -22,8 +22,8 @@ 5.8 + 5.9 + #include <vector> 5.10 + 5.11 +-#include <libglademm.h> 5.12 + #include <gtkmm.h> 5.13 ++#include <libglademm.h> 5.14 + 5.15 + #ifndef GTKMM20 5.16 + # include "sigccompat.h" 5.17 +diff -ur src/gtk/main.cpp src/gtk/main.cpp 5.18 +--- src/gtk/main.cpp 2004-05-21 18:02:35.000000000 +0200 5.19 ++++ src/gtk/main.cpp 2004-08-12 22:39:08.633801912 +0200 5.20 +@@ -22,10 +22,10 @@ 5.21 + 5.22 + #include <list> 5.23 + 5.24 +-#include <libglademm.h> 5.25 + #include <gtkmm/main.h> 5.26 + #include <gtkmm/window.h> 5.27 + #include <gtkmm/messagedialog.h> 5.28 ++#include <libglademm.h> 5.29 + 5.30 + #include "images/vba-wm-pixbufs.h" 5.31 + 5.32 +diff -ur src/gtk/window.h src/gtk/window.h 5.33 +--- src/gtk/window.h 2004-05-21 15:25:41.000000000 +0200 5.34 ++++ src/gtk/window.h 2004-08-12 22:30:58.650290728 +0200 5.35 +@@ -23,8 +23,8 @@ 5.36 + #include <sys/types.h> 5.37 + #include <stdarg.h> 5.38 + 5.39 +-#include <libglademm.h> 5.40 + #include <gtkmm.h> 5.41 ++#include <libglademm.h> 5.42 + 5.43 + #ifndef GTKMM20 5.44 + # include "sigccompat.h"
6.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 6.2 +++ b/visualboyadvance/stuff/1.7.2-gcc41.patch Sun Oct 31 23:23:34 2010 +0100 6.3 @@ -0,0 +1,27 @@ 6.4 +diff -ru src/prof/prof.cpp src/prof/prof.cpp 6.5 +--- src/prof/prof.cpp 2004-05-14 00:31:58.000000000 +1000 6.6 ++++ src/prof/prof.cpp 2006-06-03 13:49:41.000000000 +1000 6.7 +@@ -266,7 +266,7 @@ 6.8 + for (toindex=froms[fromindex]; toindex!=0; toindex=tos[toindex].link) { 6.9 + if(profWrite8(fd, GMON_TAG_CG_ARC) || 6.10 + profWrite32(fd, (u32)frompc) || 6.11 +- profWrite32(fd, (u32)tos[toindex].selfpc) || 6.12 ++ profWrite32(fd, (u32)(intptr_t)tos[toindex].selfpc) || 6.13 + profWrite32(fd, tos[toindex].count)) { 6.14 + systemMessage(0, "mcount: arc"); 6.15 + fclose(fd); 6.16 +diff -ru src/sdl/debugger.cpp src/sdl/debugger.cpp 6.17 +--- src/sdl/debugger.cpp 2004-05-14 00:13:14.000000000 +1000 6.18 ++++ src/sdl/debugger.cpp 2006-06-03 13:49:57.000000000 +1000 6.19 +@@ -950,9 +950,9 @@ 6.20 + { 6.21 + u32 address = 0; 6.22 + if(mem >= (u32*)&workRAM[0] && mem <= (u32*)&workRAM[0x3ffff]) 6.23 +- address = 0x2000000 + ((u32)mem - (u32)&workRAM[0]); 6.24 ++ address = 0x2000000 + ((u32)(intptr_t)mem - (u32)(intptr_t)&workRAM[0]); 6.25 + else 6.26 +- address = 0x3000000 + ((u32)mem - (u32)&internalRAM[0]); 6.27 ++ address = 0x3000000 + ((u32)(intptr_t)mem - (u32)(intptr_t)&internalRAM[0]); 6.28 + 6.29 + if(size == 2) 6.30 + printf("Breakpoint (on write) address %08x old:%08x new:%08x\n",
7.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 7.2 +++ b/visualboyadvance/stuff/1.7.2-glibc.patch Sun Oct 31 23:23:34 2010 +0100 7.3 @@ -0,0 +1,76 @@ 7.4 +--- src/GBA.cpp 7.5 ++++ src/GBA.cpp 7.6 +@@ -1130,7 +1130,7 @@ 7.7 + bool CPUIsZipFile(const char * file) 7.8 + { 7.9 + if(strlen(file) > 4) { 7.10 +- char * p = strrchr(file,'.'); 7.11 ++ const char * p = strrchr(file,'.'); 7.12 + 7.13 + if(p != NULL) { 7.14 + if(_stricmp(p, ".zip") == 0) 7.15 +@@ -1145,7 +1145,7 @@ 7.16 + { 7.17 + cpuIsMultiBoot = false; 7.18 + if(strlen(file) > 4) { 7.19 +- char * p = strrchr(file,'.'); 7.20 ++ const char * p = strrchr(file,'.'); 7.21 + 7.22 + if(p != NULL) { 7.23 + if(_stricmp(p, ".gba") == 0) 7.24 +@@ -1169,7 +1169,7 @@ 7.25 + bool CPUIsGBABios(const char * file) 7.26 + { 7.27 + if(strlen(file) > 4) { 7.28 +- char * p = strrchr(file,'.'); 7.29 ++ const char * p = strrchr(file,'.'); 7.30 + 7.31 + if(p != NULL) { 7.32 + if(_stricmp(p, ".gba") == 0) 7.33 +@@ -1189,7 +1189,7 @@ 7.34 + bool CPUIsELF(const char *file) 7.35 + { 7.36 + if(strlen(file) > 4) { 7.37 +- char * p = strrchr(file,'.'); 7.38 ++ const char * p = strrchr(file,'.'); 7.39 + 7.40 + if(p != NULL) { 7.41 + if(_stricmp(p, ".elf") == 0) 7.42 +--- src/Util.cpp 7.43 ++++ src/Util.cpp 7.44 +@@ -478,7 +478,7 @@ 7.45 + { 7.46 + cpuIsMultiBoot = false; 7.47 + if(strlen(file) > 4) { 7.48 +- char * p = strrchr(file,'.'); 7.49 ++ const char * p = strrchr(file,'.'); 7.50 + 7.51 + if(p != NULL) { 7.52 + if(_stricmp(p, ".gba") == 0) 7.53 +@@ -502,7 +502,7 @@ 7.54 + bool utilIsGBImage(const char * file) 7.55 + { 7.56 + if(strlen(file) > 4) { 7.57 +- char * p = strrchr(file,'.'); 7.58 ++ const char * p = strrchr(file,'.'); 7.59 + 7.60 + if(p != NULL) { 7.61 + if(_stricmp(p, ".gb") == 0) 7.62 +@@ -522,7 +522,7 @@ 7.63 + bool utilIsZipFile(const char *file) 7.64 + { 7.65 + if(strlen(file) > 4) { 7.66 +- char * p = strrchr(file,'.'); 7.67 ++ const char * p = strrchr(file,'.'); 7.68 + 7.69 + if(p != NULL) { 7.70 + if(_stricmp(p, ".zip") == 0) 7.71 +@@ -552,7 +552,7 @@ 7.72 + bool utilIsGzipFile(const char *file) 7.73 + { 7.74 + if(strlen(file) > 3) { 7.75 +- char * p = strrchr(file,'.'); 7.76 ++ const char * p = strrchr(file,'.'); 7.77 + 7.78 + if(p != NULL) { 7.79 + if(_stricmp(p, ".gz") == 0)
8.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 8.2 +++ b/visualboyadvance/stuff/1.7.2-homedir.patch Sun Oct 31 23:23:34 2010 +0100 8.3 @@ -0,0 +1,11 @@ 8.4 +--- src/sdl/SDL.cpp.orig 2004-08-15 02:43:28.232750688 -0400 8.5 ++++ src/sdl/SDL.cpp 2004-08-15 02:44:01.557684528 -0400 8.6 +@@ -887,7 +887,7 @@ 8.7 + 8.8 + if(home != NULL) { 8.9 + fprintf(stderr, "Searching home directory: %s\n", home); 8.10 +- sprintf(path, "%s%c%s", home, FILE_SEP, name); 8.11 ++ sprintf(path, "%s%c.%s%c%s", home, FILE_SEP, EXE_NAME, FILE_SEP, name); 8.12 + f = fopen(path, "r"); 8.13 + if(f != NULL) 8.14 + return f;
9.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 9.2 +++ b/visualboyadvance/stuff/1.7.2-uninit.patch Sun Oct 31 23:23:34 2010 +0100 9.3 @@ -0,0 +1,13 @@ 9.4 +diff -ru src/gtk/window.cpp src/gtk/window.cpp 9.5 +--- src/gtk/window.cpp 2004-05-14 00:31:58.000000000 +1000 9.6 ++++ src/gtk/window.cpp 2007-03-17 14:57:22.000000000 -0500 9.7 +@@ -91,7 +91,8 @@ 9.8 + m_iFilterIBMin (FirstFilterIB), 9.9 + m_iFilterIBMax (LastFilterIB), 9.10 + m_iJoypadMin (1), 9.11 +- m_iJoypadMax (4) 9.12 ++ m_iJoypadMax (4), 9.13 ++ m_poKeymap (NULL) 9.14 + { 9.15 + m_poXml = _poXml; 9.16 + m_poFileOpenDialog = NULL;