Update to bsnes v062r06 release.

You'll need snesreader's DLL from my last WIP post to use the above.

This initializes mode, region and ram_size again in Cartridge::load()
to stop the phantom SRAM files from being generated.
This fixes DSP-2 mapping to match Overload's findings (which requires
an unposted snesreader, so Dungeon Master won't run for you guys yet.)
This removes nall/traits.hpp and uses std::tr1::type_traits instead.
It also drops move, forward and identity in favor of those from
std::tr1::utility*.
This fixes linear_vector and pointer_vector to not crash when using
vectors of vectors and copying them.
This fixed linear_vector, pointer_vector and array to initialize all
internal variables for all constructors.
This fixes the file browser to look for patches in your patch
directory, so the "Apply Patch" box should work correctly now.

* I have no objection to using functions from the C++ standard library
when they don't suck.

src/base.hpp

@@ -1,4 +1,4 @@
-static const char bsnesVersion[] = "062.05";
+static const char bsnesVersion[] = "062.06";
 static const char bsnesTitle[] = "bsnes";
 static const unsigned bsnesSerializerVersion = 8;
 

src/cartridge/cartridge.cpp

@@ -19,6 +19,9 @@ namespace memory {
 Cartridge cartridge;
 
 void Cartridge::load(Mode cartridge_mode, const lstring &xml_list) {
+  mode = Mode::Normal;
+  region = Region::NTSC;
+  ram_size = 0;
   spc7110_data_rom_offset = 0x100000;
   supergameboy_version = SuperGameBoyVersion::Version1;
   supergameboy_ram_size = 0;

src/cartridge/xml.cpp

@@ -476,8 +476,8 @@ void Cartridge::xml_parse_necdsp(xml_element *root) {
     }
   }
 
-  Memory *dr[5] = { 0, &dsp1dr, &dsp2, &dsp3, &dsp4 };
-  Memory *sr[5] = { 0, &dsp1sr, &dsp2, &dsp3, &dsp4 };
+  Memory *dr[5] = { 0, &dsp1dr, &dsp2dr, &dsp3, &dsp4 };
+  Memory *sr[5] = { 0, &dsp1sr, &dsp2sr, &dsp3, &dsp4 };
 
   foreach(node, root->element) {
     if(node->name == "dr" && dr[program]) {

src/chip/dsp1/dsp1.cpp

@@ -30,4 +30,4 @@ void DSP1DR::write(unsigned addr, uint8 data) { dsp1.dsp1.setDr(data); }
 uint8 DSP1SR::read(unsigned addr) { return dsp1.dsp1.getSr(); }
 void DSP1SR::write(unsigned addr, uint8 data) {}
 
-};
+}

src/chip/dsp2/dsp2.cpp

@@ -4,6 +4,8 @@
 namespace SNES {
 
 DSP2 dsp2;
+DSP2DR dsp2dr;
+DSP2SR dsp2sr;
 
 #include "serialization.cpp"
 #include "opcodes.cpp"
@@ -141,5 +143,11 @@ void DSP2::write(unsigned addr, uint8 data) {
 
 DSP2::DSP2() {}
 DSP2::~DSP2() {}
-};
 
+uint8 DSP2DR::read(unsigned addr) { return dsp2.read(addr); }
+void DSP2DR::write(unsigned addr, uint8 data) { dsp2.write(addr, data); }
+
+uint8 DSP2SR::read(unsigned addr) { return 0x00; }
+void DSP2SR::write(unsigned addr, uint8 data) {}
+
+}

src/chip/dsp2/dsp2.hpp

@@ -1,4 +1,4 @@
-class DSP2 : public Memory {
+class DSP2 {
 public:
   struct {
     bool waiting_for_command;
@@ -42,4 +42,16 @@ protected:
   void op0d();
 };
 
+class DSP2DR : public Memory {
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
+};
+
+class DSP2SR : public Memory {
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
+};
+
 extern DSP2 dsp2;
+extern DSP2DR dsp2dr;
+extern DSP2SR dsp2sr;

src/lib/nall/any.hpp

@@ -2,8 +2,8 @@
 #define NALL_ANY_HPP
 
 #include <typeinfo>
+#include <type_traits>
 #include <nall/static.hpp>
-#include <nall/traits.hpp>
 
 namespace nall {
   class any {
@@ -13,8 +13,8 @@ namespace nall {
 
     template<typename T> any& operator=(const T& value_) {
       typedef typename static_if<
-        is_array<T>::value,
-        typename remove_extent<typename add_const<T>::type>::type*,
+        std::is_array<T>::value,
+        typename std::remove_extent<typename std::add_const<T>::type>::type*,
         T
       >::type auto_t;
 
@@ -49,13 +49,13 @@ namespace nall {
   };
 
   template<typename T> T any_cast(any &value) {
-    typedef typename remove_reference<T>::type nonref;
+    typedef typename std::remove_reference<T>::type nonref;
     if(value.type() != typeid(nonref)) throw;
     return static_cast<any::holder<nonref>*>(value.container)->value;
   }
 
   template<typename T> T any_cast(const any &value) {
-    typedef const typename remove_reference<T>::type nonref;
+    typedef const typename std::remove_reference<T>::type nonref;
     if(value.type() != typeid(nonref)) throw;
     return static_cast<any::holder<nonref>*>(value.container)->value;
   }

src/lib/nall/array.hpp

@@ -3,10 +3,11 @@
 
 #include <stdlib.h>
 #include <initializer_list>
+#include <type_traits>
+#include <utility>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
 #include <nall/concept.hpp>
-#include <nall/traits.hpp>
 
 namespace nall {
   //dynamic vector array
@@ -81,7 +82,7 @@ namespace nall {
       return *this;
     }
 
-    array(const array &source) : pool(0) {
+    array(const array &source) : pool(0), poolsize(0), buffersize(0) {
       operator=(source);
     }
 
@@ -91,12 +92,12 @@ namespace nall {
       pool = source.pool;
       poolsize = source.poolsize;
       buffersize = source.buffersize;
-      source.pool = 0;
+      source.reset();
       return *this;
     }
 
-    array(array &&source) {
-      operator=(move(source));
+    array(array &&source) : pool(0), poolsize(0), buffersize(0) {
+      operator=(std::move(source));
     }
 
     //index

src/lib/nall/foreach.hpp

@@ -6,9 +6,9 @@
   for(unsigned foreach_counter = 0, foreach_limit = foreach_size(object), foreach_once = 0, foreach_broken = 0; foreach_counter < foreach_limit && foreach_broken == 0; foreach_counter++, foreach_once = 0) \
     for(auto &iter = object[foreach_counter]; foreach_once == 0 && (foreach_broken = 1); foreach_once++, foreach_broken = 0)
 
+#include <type_traits>
 #include <nall/concept.hpp>
 #include <nall/static.hpp>
-#include <nall/traits.hpp>
 
 namespace nall {
   template<typename T> unsigned foreach_size(const T& object, typename mp_enable_if<has_count<T>>::type = 0) {
@@ -23,8 +23,8 @@ namespace nall {
     return object.size();
   }
 
-  template<typename T> unsigned foreach_size(const T& object, typename mp_enable_if<is_array<T>>::type = 0) {
-    return sizeof(T) / sizeof(typename remove_extent<T>::type);
+  template<typename T> unsigned foreach_size(const T& object, typename mp_enable_if<std::is_array<T>>::type = 0) {
+    return sizeof(T) / sizeof(typename std::remove_extent<T>::type);
   }
 }
 

src/lib/nall/serializer.hpp

@@ -1,8 +1,9 @@
 #ifndef NALL_SERIALIZER_HPP
 #define NALL_SERIALIZER_HPP
 
+#include <type_traits>
+#include <utility>
 #include <nall/stdint.hpp>
-#include <nall/traits.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
@@ -16,6 +17,10 @@ namespace nall {
   //caveats:
   //- only plain-old-data can be stored. complex classes must provide serialize(serializer&);
   //- floating-point usage is not portable across platforms
+
+  template<typename T> struct is_bool { enum { value = false }; };
+  template<> struct is_bool<bool> { enum { value = true }; };
+
   class serializer {
   public:
     enum mode_t { Load, Save, Size };
@@ -63,7 +68,7 @@ namespace nall {
     }
 
     template<typename T> void array(T &array) {
-      enum { size = sizeof(T) / sizeof(typename remove_extent<T>::type) };
+      enum { size = sizeof(T) / sizeof(typename std::remove_extent<T>::type) };
       for(unsigned n = 0; n < size; n++) integer(array[n]);
     }
 
@@ -102,7 +107,7 @@ namespace nall {
     }
 
     serializer(serializer &&s) {
-      operator=(move(s));
+      operator=(std::move(s));
     }
 
     //construction

src/lib/nall/string/variadic.hpp

@@ -2,18 +2,18 @@
 #define NALL_STRING_VARIADIC_HPP
 
 namespace nall {
-  static void sprint(string &output) {
+  static void isprint(string &output) {
   }
 
   template<typename T, typename... Args>
-  static void sprint(string &output, T value, Args... args) {
+  static void isprint(string &output, T value, Args... args) {
     output << to_string<T>(value);
-    sprint(output, args...);
+    isprint(output, args...);
   }
 
   template<typename... Args> inline string sprint(Args... args) {
     string output;
-    sprint(output, args...);
+    isprint(output, args...);
     return output;
   }
 

src/lib/nall/traits.hpp

@@ -1,97 +0,0 @@
-#ifndef NALL_TRAITS_HPP
-#define NALL_TRAITS_HPP
-
-namespace nall {
-  //==
-  //is
-  //==
-
-  template<typename T> struct is_integral { enum { value = false }; };
-  template<> struct is_integral<bool> { enum { value = true }; };
-  template<> struct is_integral<char> { enum { value = true }; };
-  template<> struct is_integral<signed char> { enum { value = true }; };
-  template<> struct is_integral<unsigned char> { enum { value = true }; };
-  template<> struct is_integral<wchar_t> { enum { value = true }; };
-  template<> struct is_integral<short> { enum { value = true }; };
-  template<> struct is_integral<unsigned short> { enum { value = true }; };
-  template<> struct is_integral<long> { enum { value = true }; };
-  template<> struct is_integral<unsigned long> { enum { value = true }; };
-  template<> struct is_integral<long long> { enum { value = true }; };
-  template<> struct is_integral<unsigned long long> { enum { value = true }; };
-  template<> struct is_integral<int> { enum { value = true }; };
-  template<> struct is_integral<unsigned int> { enum { value = true }; };
-
-  template<typename T> struct is_floating_point { enum { value = false }; };
-  template<> struct is_floating_point<float> { enum { value = true }; };
-  template<> struct is_floating_point<double> { enum { value = true }; };
-  template<> struct is_floating_point<long double> { enum { value = true }; };
-
-  template<typename T> struct is_bool { enum { value = false }; };
-  template<> struct is_bool<bool> { enum { value = true }; };
-
-  template<typename T> struct is_void { enum { value = false }; };
-  template<> struct is_void<void> { enum { value = true }; };
-
-  template<typename T> struct is_arithmetic {
-    enum { value = is_integral<T>::value || is_floating_point<T>::value };
-  };
-
-  template<typename T> struct is_fundamental {
-    enum { value = is_integral<T>::value || is_floating_point<T>::value || is_void<T>::value };
-  };
-
-  template<typename T> struct is_compound {
-    enum { value = !is_fundamental<T>::value };
-  };
-
-  template<typename T> struct is_array { enum { value = false }; };
-  template<typename T> struct is_array<T[]> { enum { value = true }; };
-  template<typename T, int N> struct is_array<T[N]> { enum { value = true }; };
-
-  template<typename T> struct is_const { enum { value = false }; };
-  template<typename T> struct is_const<const T> { enum { value = true }; };
-  template<typename T> struct is_const<const T&> { enum { value = true }; };
-
-  template<typename T> struct is_pointer { enum { value = false }; };
-  template<typename T> struct is_pointer<T*> { enum { value = true }; };
-
-  template<typename T> struct is_reference { enum { value = false }; };
-  template<typename T> struct is_reference<T&> { enum { value = true }; };
-
-  template<typename T, typename U> struct is_same { enum { value = false }; };
-  template<typename T> struct is_same<T, T> { enum { value = true }; };
-
-  //===
-  //add
-  //===
-
-  template<typename T> struct add_const { typedef const T type; };
-  template<typename T> struct add_const<const T> { typedef const T type; };
-  template<typename T> struct add_const<const T&> { typedef const T& type; };
-
-  template<typename T> struct add_pointer { typedef T* type; };
-  template<typename T> struct add_pointer<T*> { typedef T** type; };
-
-  template<typename T> struct add_reference { typedef T& type; };
-  template<typename T> struct add_reference<T&> { typedef T& type; };
-
-  //======
-  //remove
-  //======
-
-  template<typename T> struct remove_const { typedef T type; };
-  template<typename T> struct remove_const<const T> { typedef T type; };
-  template<typename T> struct remove_const<const T&> { typedef T type; };
-
-  template<typename T> struct remove_extent { typedef T type; };
-  template<typename T> struct remove_extent<T[]> { typedef T type; };
-  template<typename T, int N> struct remove_extent<T[N]> { typedef T type; };
-
-  template<typename T> struct remove_pointer { typedef T type; };
-  template<typename T> struct remove_pointer<T*> { typedef T type; };
-
-  template<typename T> struct remove_reference { typedef T type; };
-  template<typename T> struct remove_reference<T&> { typedef T type; };
-}
-
-#endif

src/lib/nall/utility.hpp

@@ -1,29 +1,17 @@
 #ifndef NALL_UTILITY_HPP
 #define NALL_UTILITY_HPP
 
-#include <nall/traits.hpp>
+#include <type_traits>
 
 namespace nall {
-  template<typename T> struct identity {
-    typedef T type;
-  };
-
-  template<typename T> typename remove_reference<T>::type&& move(T &&value) {
-    return value;
-  }
-
-  template<typename T> T&& forward(typename identity<T>::type &&value) {
-    return value;
-  }
-
   template<bool C, typename T = bool> struct enable_if { typedef T type; };
   template<typename T> struct enable_if<false, T> {};
   template<typename C, typename T = bool> struct mp_enable_if : enable_if<C::value, T> {};
 
   template<typename T> inline void swap(T &x, T &y) {
-    T temp(move(x));
-    x = move(y);
-    y = move(temp);
+    T temp(std::move(x));
+    x = std::move(y);
+    y = std::move(temp);
   }
 
   template<typename T> struct base_from_member {

src/lib/nall/vector.hpp

@@ -3,10 +3,11 @@
 
 #include <initializer_list>
 #include <new>
+#include <type_traits>
+#include <utility>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
 #include <nall/concept.hpp>
-#include <nall/traits.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
@@ -86,11 +87,12 @@ namespace nall {
     inline linear_vector<T>& operator=(const linear_vector<T> &source) {
       reset();
       reserve(source.capacity());
-      for(unsigned i = 0; i < source.size(); i++) add(source[i]);
+      resize(source.size());
+      for(unsigned i = 0; i < source.size(); i++) operator[](i) = source.operator[](i);
       return *this;
     }
 
-    linear_vector(const linear_vector<T> &source) {
+    linear_vector(const linear_vector<T> &source) : pool(0), poolsize(0), objectsize(0) {
       operator=(source);
     }
 
@@ -100,12 +102,12 @@ namespace nall {
       pool = source.pool;
       poolsize = source.poolsize;
       objectsize = source.objectsize;
-      source.pool = 0;
+      source.reset();
       return *this;
     }
 
-    linear_vector(linear_vector<T> &&source) {
-      operator=(move(source));
+    linear_vector(linear_vector<T> &&source) : pool(0), poolsize(0), objectsize(0) {
+      operator=(std::move(source));
     }
 
     //construction
@@ -193,11 +195,12 @@ namespace nall {
     inline pointer_vector<T>& operator=(const pointer_vector<T> &source) {
       reset();
       reserve(source.capacity());
-      for(unsigned i = 0; i < source.size(); i++) add(source[i]);
+      resize(source.size());
+      for(unsigned i = 0; i < source.size(); i++) operator[](i) = source.operator[](i);
       return *this;
     }
 
-    pointer_vector(const pointer_vector<T> &source) {
+    pointer_vector(const pointer_vector<T> &source) : pool(0), poolsize(0), objectsize(0) {
       operator=(source);
     }
 
@@ -207,12 +210,12 @@ namespace nall {
       pool = source.pool;
       poolsize = source.poolsize;
       objectsize = source.objectsize;
-      source.pool = 0;
+      source.reset();
       return *this;
     }
 
-    pointer_vector(pointer_vector<T> &&source) {
-      operator=(move(source));
+    pointer_vector(pointer_vector<T> &&source) : pool(0), poolsize(0), objectsize(0) {
+      operator=(std::move(source));
     }
 
     //construction

src/memory/memory-inline.hpp

@@ -46,7 +46,7 @@ unsigned MappedRAM::size() const { return size_; }
 
 uint8 MappedRAM::read(unsigned addr) { return data_[addr]; }
 void MappedRAM::write(unsigned addr, uint8 n) { if(!write_protect_) data_[addr] = n; }
-const uint8 MappedRAM::operator[](unsigned addr) const { return data_[addr]; }
+const uint8& MappedRAM::operator[](unsigned addr) const { return data_[addr]; }
 MappedRAM::MappedRAM() : data_(0), size_(-1U), write_protect_(false) {}
 
 //Bus

src/memory/memory.hpp

@@ -48,7 +48,7 @@ struct MappedRAM : Memory {
 
   inline uint8 read(unsigned addr);
   inline void write(unsigned addr, uint8 n);
-  inline const uint8 operator[](unsigned addr) const;
+  inline const uint8& operator[](unsigned addr) const;
   inline MappedRAM();
 
 private:

src/ui_qt/base/filebrowser.cpp

@@ -102,8 +102,8 @@ void FileBrowser::onChangeCartridge(const string &path) {
   else filename = path;
 
   string info;
-  string image = string() << nall::basename(filename) << ".png";
-  string patch = string() << nall::basename(filename) << ".ups";
+  string image = sprint(nall::basename(filename), ".png");
+  string patch = sprint(filepath(nall::basename(filename), config().path.patch), ".ups");
 
   if(file::exists(filename)) {
     if(striend(filename, ".sfc")) {