Update to bsnes v062 release.

Major accuracy improvements have happened over the past few days. They easily warrant a new beta release.
First, it turns out that every emulator to date; not only for the SNES, but for the Apple II GS as well, incorrectly computed ADC (add) and SBC (subtract) flags in BCD (binary-coded decimal) mode. At least fifteen years of emulating the 65816 processor, at least five known investigations into their behavior, and we all still had it wrong.
So I wrote some tests that dumped every possible combination of adc and sbc with every possible input and every possible flag, and recorded both the accumulator result and status flag register. From here, blargg figured out the underlying trick: the CPU was computing overflow before the top-nibble's BCD correction pass. With the routines rewritten, bsnes perfectly matches real hardware now.
Next, some background. The whole reason I got into SNES emulation was because I was tired of writing code that ran perfectly fine on emulators, but failed miserably on real hardware. The number one problem was emulators allowing video RAM to be written while the screen was being rendered. This single bug has broken dozens of fan translations and ROM hacks. Some have been updated to work around this bug, and many others are left in a permanently broken state (such as the translations of Dragon Quest I & II and Sailor Moon: Another Story, to name just two.) After asking emulator authors to fix this since 1997, I finally had enough in 2004 and started on bsnes. For this particular bug, I'm very happy to report that all but one SNES emulator now properly blocks these invalid accesses. Although sadly one still offers a configuration setting for backwards compatibility with these translations. What an ironic shame ... emulating an emulator. And in the process, sapping the motivation to ever go back and fix these 
titles to ever run on real hardware. But I digress ...
The second biggest problem that causes software created under emulation to break on real hardware has, without a doubt, been the hardware delays as the S-CPU computes MUL (multiplication) and DIV (division) results. To date, whenever you used this hardware functionality, emulators have immmediately furnished the correct results. But on real hardware, multiplication requires eight CPU cycles, and division requires sixteen. Each step computes one bit of the source operand and updates the results. Reading the output registers early thus provides the partially computed results.
This is obscure. It isn't well known, and many people writing software for the SNES probably aren't even aware of this limitation. Because of the partial computation results, outright delaying the computation would break many commercial software titles. But by not emulating the delay at all, we were causing a great disservice to anyone wishing to use an emulator for development purposes.
Now, once again, thanks to blargg's algorithm help, he has determined the underlying multiplication and division algorithms. Combined with my expertise of SNES analysis and hardware testing, I was able to determine when and how the ALU (arithmetic logic unit) stepped through each work cycle. Our work combined, bsnes now also perfectly emulates the hardware MUL and DIV delays.
Again, this isn't going to fix commercial software titles. They would have realized that they were reading back invalid MUL and DIV values, and fixed their code. This is for all of the software developed using emulators. This is an extension of my commitment to create a hardware emulator, and not a video game emulator.
We also verified that the S-PPU multiplication interface does indeed return instant results with no delay. So emulation of that interface was already correct.
I'm only labelling this release a beta because it hasn't been tested. But I'm fairly confident that it is stable, and I seriously recommend upgrading from v060 or prior releases. This is easily one of the last major pieces missing from emulation.
The last notable elements are: S-CPU auto joypad poll timing, S-CPUr1 HDMA crash detection, S-CPU<>S-SMP port ORing, S-SMP timer glitching, S-DSP mute pulse, and full cycle-level emulation of the S-PPU. With all of the aforementioned items, I will consider a v1.0 release of bsnes ;)
Lastly, I'll post this screenshot just for fun. When d4s translated Breath of Fire II to German, he added some code that relies on the incorrect emulation of the DIV register to detect emulators. With this emulated properly, you now see the following screen:
./sshots/bs_349.png
Sorry to spoil that, but the secret's already out, as the MESS team reported on it publicly already.
I intend to add pseudo-randomness support shortly, which should eliminate one of the last vectors possible to distinguish bsnes from real hardware :)
A million thanks to blargg for making this release possible.

snesfilter/Makefile

@@ -3,8 +3,8 @@ include nall/Makefile
 qtlibs := QtCore QtGui
 include nall/qt/Makefile
 
-c     := $(compiler)
-cpp   := $(subst cc,++,$(compiler))
+c     := $(compiler) -std=gnu99
+cpp   := $(subst cc,++,$(compiler)) -std=gnu++0x
 flags := -O3 -I. -Iobj -fomit-frame-pointer $(qtinc)
 link  :=
 

snesfilter/nall/algorithm.hpp

@@ -5,11 +5,11 @@
 #undef max
 
 namespace nall {
-  template<typename T, typename U> T min(const T& t, const U& u) {
+  template<typename T, typename U> T min(const T &t, const U &u) {
     return t < u ? t : u;
   }
 
-  template<typename T, typename U> T max(const T& t, const U& u) {
+  template<typename T, typename U> T max(const T &t, const U &u) {
     return t > u ? t : u;
   }
 

snesfilter/nall/array.hpp

@@ -2,8 +2,11 @@
 #define NALL_ARRAY_HPP
 
 #include <stdlib.h>
+#include <initializer_list>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
+#include <nall/concept.hpp>
+#include <nall/traits.hpp>
 
 namespace nall {
   //dynamic vector array
@@ -57,18 +60,18 @@ namespace nall {
       memset(pool, 0, buffersize * sizeof(T));
     }
 
-    array() {
-      pool = 0;
-      poolsize = 0;
-      buffersize = 0;
+    array() : pool(0), poolsize(0), buffersize(0) {
     }
 
-    ~array() { reset(); }
-
-    array(const array &source) : pool(0) {
-      operator=(source);
+    array(std::initializer_list<T> list) : pool(0), poolsize(0), buffersize(0) {
+      for(const T *p = list.begin(); p != list.end(); ++p) add(*p);
     }
 
+    ~array() {
+      reset();
+    }
+
+    //copy
     array& operator=(const array &source) {
       if(pool) free(pool);
       buffersize = source.buffersize;
@@ -78,6 +81,25 @@ namespace nall {
       return *this;
     }
 
+    array(const array &source) : pool(0) {
+      operator=(source);
+    }
+
+    //move
+    array& operator=(array &&source) {
+      if(pool) free(pool);
+      pool = source.pool;
+      poolsize = source.poolsize;
+      buffersize = source.buffersize;
+      source.pool = 0;
+      return *this;
+    }
+
+    array(array &&source) {
+      operator=(move(source));
+    }
+
+    //index
     inline T& operator[](unsigned index) {
       if(index >= buffersize) resize(index + 1);
       if(index >= buffersize) throw "array[] out of bounds";
@@ -89,6 +111,8 @@ namespace nall {
       return pool[index];
     }
   };
+
+  template<typename T> struct has_size<array<T>> { enum { value = true }; };
 }
 
 #endif

snesfilter/nall/concept.hpp

@@ -0,0 +1,15 @@
+#ifndef NALL_CONCEPT_HPP
+#define NALL_CONCEPT_HPP
+
+namespace nall {
+  //unsigned count() const;
+  template<typename T> struct has_count { enum { value = false }; };
+
+  //unsigned length() const;
+  template<typename T> struct has_length { enum { value = false }; };
+
+  //unsigned size() const;
+  template<typename T> struct has_size { enum { value = false }; };
+}
+
+#endif

snesfilter/nall/config.hpp

@@ -53,7 +53,7 @@ namespace nall {
         }
       }
     };
-    vector<item_t> list;
+    linear_vector<item_t> list;
 
     template<typename T>
     void attach(T &data, const char *name, const char *desc = "") {

snesfilter/nall/dictionary.hpp

@@ -6,7 +6,7 @@
 #include <nall/utility.hpp>
 
 namespace nall {
-  class dictionary : noncopyable {
+  class dictionary {
   public:
     string operator[](const char *input) {
       for(unsigned i = 0; i < index_input.size(); i++) {
@@ -64,6 +64,9 @@ namespace nall {
       reset();
     }
 
+    dictionary& operator=(const dictionary&) = delete;
+    dictionary(const dictionary&) = delete;
+
   protected:
     lstring index_input;
     lstring index_output;

snesfilter/nall/dl.hpp

@@ -16,7 +16,7 @@
 #endif
 
 namespace nall {
-  struct library : noncopyable {
+  struct library {
     bool opened() const { return handle; }
     bool open(const char*);
     void* sym(const char*);
@@ -25,6 +25,9 @@ namespace nall {
     library() : handle(0) {}
     ~library() { close(); }
 
+    library& operator=(const library&) = delete;
+    library(const library&) = delete;
+
   private:
     uintptr_t handle;
   };

snesfilter/nall/file.hpp

@@ -23,7 +23,7 @@ namespace nall {
     #endif
   }
 
-  class file : noncopyable {
+  class file {
   public:
     enum FileMode { mode_read, mode_write, mode_readwrite, mode_writeread };
     enum SeekMode { seek_absolute, seek_relative };
@@ -218,6 +218,9 @@ namespace nall {
       close();
     }
 
+    file& operator=(const file&) = delete;
+    file(const file&) = delete;
+
   private:
     enum { buffer_size = 1 << 12, buffer_mask = buffer_size - 1 };
     char buffer[buffer_size];

snesfilter/nall/foreach.hpp

@@ -0,0 +1,31 @@
+#ifndef NALL_FOREACH_HPP
+#define NALL_FOREACH_HPP
+
+#undef foreach
+#define foreach(iter, object) \
+  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 <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) {
+    return object.count();
+  }
+
+  template<typename T> unsigned foreach_size(const T& object, typename mp_enable_if<has_length<T>>::type = 0) {
+    return object.length();
+  }
+
+  template<typename T> unsigned foreach_size(const T& object, typename mp_enable_if<has_size<T>>::type = 0) {
+    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);
+  }
+}
+
+#endif

snesfilter/nall/priorityqueue.hpp

@@ -14,7 +14,7 @@ namespace nall {
   //O(1)     find   (tick)
   //O(log n) insert (enqueue)
   //O(log n) remove (dequeue)
-  template<typename type_t> class priority_queue : noncopyable {
+  template<typename type_t> class priority_queue {
   public:
     inline void tick(unsigned ticks) {
       basecounter += ticks;
@@ -86,6 +86,9 @@ namespace nall {
       delete[] heap;
     }
 
+    priority_queue& operator=(const priority_queue&) = delete;
+    priority_queue(const priority_queue&) = delete;
+
   private:
     function<void (type_t)> callback;
     unsigned basecounter;

snesfilter/nall/qt/concept.hpp

@@ -0,0 +1,10 @@
+#ifndef NALL_QT_CONCEPT_HPP
+#define NALL_QT_CONCEPT_HPP
+
+#include <nall/concept.hpp>
+
+namespace nall {
+  template<typename T> struct has_count<QList<T>> { enum { value = true }; };
+}
+
+#endif

snesfilter/nall/qt/hex-editor.moc.hpp

@@ -11,15 +11,14 @@ class HexEditor : public QTextEdit {
   Q_OBJECT
 
 public:
-  enum {
-    LineWidth = 59,
-  };
-
   function<uint8_t (unsigned)> reader;
   function<void (unsigned, uint8_t)> writer;
 
+  void setColumns(unsigned columns);
+  void setRows(unsigned rows);
   void setOffset(unsigned offset);
   void setSize(unsigned size);
+  unsigned lineWidth() const;
   void refresh();
 
   HexEditor();
@@ -30,6 +29,8 @@ protected slots:
 protected:
   QHBoxLayout *layout;
   QScrollBar *scrollBar;
+  unsigned editorColumns;
+  unsigned editorRows;
   unsigned editorOffset;
   unsigned editorSize;
   bool lock;
@@ -39,8 +40,8 @@ protected:
 
 inline void HexEditor::keyPressEvent(QKeyEvent *event) {
   QTextCursor cursor = textCursor();
-  unsigned x = cursor.position() % LineWidth;
-  unsigned y = cursor.position() / LineWidth;
+  unsigned x = cursor.position() % lineWidth();
+  unsigned y = cursor.position() / lineWidth();
 
   int hexCode = -1;
   switch(event->key()) {
@@ -66,7 +67,7 @@ inline void HexEditor::keyPressEvent(QKeyEvent *event) {
     bool cursorOffsetValid = (x >= 11 && ((x - 11) % 3) != 2);
     if(cursorOffsetValid) {
       bool nibble = (x - 11) % 3;  //0 = top nibble, 1 = bottom nibble
-      unsigned cursorOffset = y * 16 + ((x - 11) / 3);
+      unsigned cursorOffset = y * editorColumns + ((x - 11) / 3);
       unsigned effectiveOffset = editorOffset + cursorOffset;
       if(effectiveOffset >= editorSize) effectiveOffset %= editorSize;
 
@@ -76,7 +77,7 @@ inline void HexEditor::keyPressEvent(QKeyEvent *event) {
       if(writer) writer(effectiveOffset, data);
       refresh();
 
-      cursor.setPosition(y * LineWidth + x + 1);  //advance cursor
+      cursor.setPosition(y * lineWidth() + x + 1);  //advance cursor
       setTextCursor(cursor);
     }
   } else {
@@ -87,16 +88,30 @@ inline void HexEditor::keyPressEvent(QKeyEvent *event) {
   }
 }
 
+inline void HexEditor::setColumns(unsigned columns) {
+  editorColumns = columns;
+}
+
+inline void HexEditor::setRows(unsigned rows) {
+  editorRows = rows;
+  scrollBar->setPageStep(editorRows);
+}
+
 inline void HexEditor::setOffset(unsigned offset) {
   lock = true;
   editorOffset = offset;
-  scrollBar->setSliderPosition(editorOffset / 16);
+  scrollBar->setSliderPosition(editorOffset / editorColumns);
   lock = false;
 }
 
 inline void HexEditor::setSize(unsigned size) {
   editorSize = size;
-  scrollBar->setRange(0, editorSize / 16 - 16);
+  bool indivisible = (editorSize % editorColumns) != 0;  //add one for incomplete row
+  scrollBar->setRange(0, editorSize / editorColumns + indivisible - editorRows);
+}
+
+inline unsigned HexEditor::lineWidth() const {
+  return 11 + 3 * editorColumns;
 }
 
 inline void HexEditor::refresh() {
@@ -104,20 +119,20 @@ inline void HexEditor::refresh() {
   char temp[256];
   unsigned offset = editorOffset;
 
-  for(unsigned y = 0; y < 16; y++) {
+  for(unsigned y = 0; y < editorRows; y++) {
     if(offset >= editorSize) break;
     sprintf(temp, "%.4x:%.4x", (offset >> 16) & 0xffff, (offset >> 0) & 0xffff);
     output << "<font color='#808080'>" << temp << "</font>&nbsp;&nbsp;";
 
-    for(unsigned x = 0; x < 16; x++) {
+    for(unsigned x = 0; x < editorColumns; x++) {
       if(offset >= editorSize) break;
       sprintf(temp, "%.2x", reader ? reader(offset) : 0x00);
       offset++;
       output << "<font color='" << ((x & 1) ? "#000080" : "#0000ff") << "'>" << temp << "</font>";
-      if(x != 15) output << "&nbsp;";
+      if(x != (editorColumns - 1)) output << "&nbsp;";
     }
 
-    if(y != 15) output << "<br>";
+    if(y != (editorRows - 1)) output << "<br>";
   }
 
   setHtml(output);
@@ -126,7 +141,7 @@ inline void HexEditor::refresh() {
 inline void HexEditor::scrolled() {
   if(lock) return;
   unsigned offset = scrollBar->sliderPosition();
-  editorOffset = offset * 16;
+  editorOffset = offset * editorColumns;
   refresh();
 }
 
@@ -142,12 +157,13 @@ inline HexEditor::HexEditor() {
 
   scrollBar = new QScrollBar(Qt::Vertical);
   scrollBar->setSingleStep(1);
-  scrollBar->setPageStep(16);
   layout->addWidget(scrollBar);
 
   lock = false;
   connect(scrollBar, SIGNAL(actionTriggered(int)), this, SLOT(scrolled()));
 
+  setColumns(16);
+  setRows(16);
   setSize(0);
   setOffset(0);
 }

snesfilter/nall/serializer.hpp

@@ -6,7 +6,6 @@
 #include <nall/utility.hpp>
 
 namespace nall {
-
   //serializer: a class designed to save and restore the state of classes.
   //
   //benefits:
@@ -17,7 +16,6 @@ namespace nall {
   //caveats:
   //- only plain-old-data can be stored. complex classes must provide serialize(serializer&);
   //- floating-point usage is not portable across platforms
-
   class serializer {
   public:
     enum mode_t { Load, Save, Size };
@@ -73,6 +71,7 @@ namespace nall {
       for(unsigned n = 0; n < size; n++) integer(array[n]);
     }
 
+    //copy
     serializer& operator=(const serializer &s) {
       if(idata) delete[] idata;
 
@@ -89,6 +88,24 @@ namespace nall {
       operator=(s);
     }
 
+    //move
+    serializer& operator=(serializer &&s) {
+      if(idata) delete[] idata;
+
+      imode = s.imode;
+      idata = s.idata;
+      isize = s.isize;
+      icapacity = s.icapacity;
+
+      s.idata = 0;
+      return *this;
+    }
+
+    serializer(serializer &&s) {
+      operator=(move(s));
+    }
+
+    //construction
     serializer() {
       imode = Size;
       idata = 0;

snesfilter/nall/static.hpp

@@ -2,16 +2,19 @@
 #define NALL_STATIC_HPP
 
 namespace nall {
-  template<bool condition> struct static_assert;
-  template<> struct static_assert<true> {};
+  template<bool C, typename T, typename F> struct static_if { typedef T type; };
+  template<typename T, typename F> struct static_if<false, T, F> { typedef F type; };
+  template<typename C, typename T, typename F> struct mp_static_if { typedef typename static_if<C::type, T, F>::type type; };
 
-  template<bool condition, typename true_type, typename false_type> struct static_if {
-    typedef true_type type;
-  };
+  template<bool A, bool B> struct static_and { enum { value = false }; };
+  template<> struct static_and<true, true> { enum { value = true }; };
+  template<typename A, typename B> struct mp_static_and { enum { value = static_and<A::value, B::value>::value }; };
 
-  template<typename true_type, typename false_type> struct static_if<false, true_type, false_type> {
-    typedef false_type type;
-  };
+  template<bool A, bool B> struct static_or { enum { value = false }; };
+  template<> struct static_or<false, true> { enum { value = true }; };
+  template<> struct static_or<true, false> { enum { value = true }; };
+  template<> struct static_or<true, true> { enum { value = true }; };
+  template<typename A, typename B> struct mp_static_or { enum { value = static_or<A::value, B::value>::value }; };
 }
 
 #endif

snesfilter/nall/stdint.hpp

@@ -30,15 +30,15 @@
 #endif
 
 namespace nall {
-  static static_assert<sizeof(int8_t)   == 1> int8_t_assert;
-  static static_assert<sizeof(int16_t)  == 2> int16_t_assert;
-  static static_assert<sizeof(int32_t)  == 4> int32_t_assert;
-  static static_assert<sizeof(int64_t)  == 8> int64_t_assert;
+  static_assert(sizeof(int8_t)   == 1, "int8_t is not of the correct size" );
+  static_assert(sizeof(int16_t)  == 2, "int16_t is not of the correct size");
+  static_assert(sizeof(int32_t)  == 4, "int32_t is not of the correct size");
+  static_assert(sizeof(int64_t)  == 8, "int64_t is not of the correct size");
 
-  static static_assert<sizeof(uint8_t)  == 1> uint8_t_assert;
-  static static_assert<sizeof(uint16_t) == 2> uint16_t_assert;
-  static static_assert<sizeof(uint32_t) == 4> uint32_t_assert;
-  static static_assert<sizeof(uint64_t) == 8> uint64_t_assert;
+  static_assert(sizeof(uint8_t)  == 1, "int8_t is not of the correct size" );
+  static_assert(sizeof(uint16_t) == 2, "int16_t is not of the correct size");
+  static_assert(sizeof(uint32_t) == 4, "int32_t is not of the correct size");
+  static_assert(sizeof(uint64_t) == 8, "int64_t is not of the correct size");
 }
 
 #endif

snesfilter/nall/string.hpp

@@ -1,6 +1,7 @@
 #ifndef NALL_STRING_HPP
 #define NALL_STRING_HPP
 
+#include <initializer_list>
 #include <nall/string/base.hpp>
 #include <nall/string/core.hpp>
 #include <nall/string/cast.hpp>
@@ -14,5 +15,12 @@
 #include <nall/string/replace.hpp>
 #include <nall/string/split.hpp>
 #include <nall/string/utility.hpp>
+#include <nall/string/variadic.hpp>
+#include <nall/string/xml.hpp>
+
+namespace nall {
+  template<> struct has_length<string> { enum { value = true }; };
+  template<> struct has_size<lstring> { enum { value = true }; };
+}
 
 #endif

snesfilter/nall/string/base.hpp

@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <nall/concept.hpp>
 #include <nall/stdint.hpp>
 #include <nall/utf8.hpp>
 #include <nall/vector.hpp>
@@ -26,11 +27,6 @@ inline intmax_t  strsigned  (const char *str);
 inline uintmax_t strunsigned(const char *str);
 inline uintmax_t strbin     (const char *str);
 inline double    strdouble  (const char *str);
-inline size_t strhex     (char *str, uintmax_t value, size_t length = 0);
-inline size_t strsigned  (char *str, intmax_t  value, size_t length = 0);
-inline size_t strunsigned(char *str, uintmax_t value, size_t length = 0);
-inline size_t strbin     (char *str, uintmax_t value, size_t length = 0);
-inline size_t strdouble  (char *str, double    value, size_t length = 0);
 inline bool match(const char *pattern, const char *str);
 inline bool strint (const char *str, int &result);
 inline bool strmath(const char *str, int &result);
@@ -49,8 +45,6 @@ namespace nall {
 
   class string {
   public:
-    static string printf(const char*, ...);
-
     inline void reserve(size_t);
     inline unsigned length() const;
 
@@ -73,7 +67,9 @@ namespace nall {
     inline string();
     inline string(const char*);
     inline string(const string&);
+    inline string(string&&);
     inline string& operator=(const string&);
+    inline string& operator=(string&&);
     inline ~string();
 
     inline bool readfile(const char*);
@@ -90,18 +86,25 @@ namespace nall {
   #endif
   };
 
-  class lstring : public vector<string> {
+  class lstring : public linear_vector<string> {
   public:
     template<typename T> inline lstring& operator<<(T value);
 
     inline int find(const char*);
     inline void split (const char*, const char*, unsigned = 0);
     inline void qsplit(const char*, const char*, unsigned = 0);
+
+    lstring();
+    lstring(std::initializer_list<string>);
   };
+
+  template<typename... Args> inline string sprint(const char *s, Args... args);
+  template<typename... Args> inline void print(const char *s, Args... args);
 };
 
 inline size_t strlcpy(nall::string &dest, const char *src, size_t length);
 inline size_t strlcat(nall::string &dest, const char *src, size_t length);
+
 inline nall::string& strlower(nall::string &str);
 inline nall::string& strupper(nall::string &str);
 inline nall::string& strtr(nall::string &dest, const char *before, const char *after);
@@ -113,10 +116,11 @@ inline nall::string& rtrim_once(nall::string &str, const char *key = " ");
 inline nall::string& trim_once (nall::string &str, const char *key = " ");
 
 inline nall::string substr(const char *src, size_t start = 0, size_t length = 0);
-inline nall::string strhex     (uintmax_t value);
-inline nall::string strsigned  (intmax_t  value);
-inline nall::string strunsigned(uintmax_t value);
-inline nall::string strbin     (uintmax_t value);
-inline nall::string strdouble  (double    value);
+template<unsigned length = 0, char padding = '0'> inline nall::string strhex(uintmax_t value);
+template<unsigned length = 0, char padding = '0'> inline nall::string strsigned(intmax_t value);
+template<unsigned length = 0, char padding = '0'> inline nall::string strunsigned(uintmax_t value);
+template<unsigned length = 0, char padding = '0'> inline nall::string strbin(uintmax_t value);
+inline size_t strdouble(char *str, double value);
+inline nall::string strdouble(double value);
 
 #endif

snesfilter/nall/string/cast.hpp

@@ -2,8 +2,7 @@
 #define NALL_STRING_CAST_HPP
 
 namespace nall {
-  //this is needed, as C++98 does not support explicit template specialization inside classes;
-  //redundant memory allocation should hopefully be avoided via compiler optimizations.
+  //this is needed, as C++0x does not support explicit template specialization inside classes
   template<> inline string to_string<bool>         (bool v)          { return v ? "true" : "false"; }
   template<> inline string to_string<signed int>   (signed int v)    { return strsigned(v); }
   template<> inline string to_string<unsigned int> (unsigned int v)  { return strunsigned(v); }
@@ -25,6 +24,6 @@ namespace nall {
   template<> inline string to_string<const QString&>(const QString &v) { return v.toUtf8().constData(); }
   string::operator QString() const { return QString::fromUtf8(*this); }
   #endif
-};
+}
 
 #endif

snesfilter/nall/string/convert.hpp

@@ -146,140 +146,4 @@ double strdouble(const char *str) {
   return !negate ? result : -result;
 }
 
-//
-
-size_t strhex(char *str, uintmax_t value, size_t length /* = 0 */) {
-  if(length == 0) length -= 1U;  //"infinite" length
-  size_t initial_length = length;
-
-  //count number of digits in value
-  int digits_integral = 1;
-  uintmax_t digits_integral_ = value;
-  while(digits_integral_ /= 16) digits_integral++;
-
-  int digits = digits_integral;
-  if(!str) return digits + 1;  //only computing required length?
-
-  length = nall::min(digits, length - 1);
-  str += length;  //seek to end of target string
-  *str = 0;  //set null terminator
-
-  while(length--) {
-    uint8_t x = value % 16;
-    value /= 16;
-    *--str = x < 10 ? (x + '0') : (x + 'a' - 10);  //iterate backwards to write string
-  }
-
-  return nall::min(initial_length, digits + 1);
-}
-
-size_t strsigned(char *str, intmax_t value_, size_t length /* = 0 */) {
-  if(length == 0) length = -1U;  //"infinite" length
-  size_t initial_length = length;
-
-  bool negate = value_ < 0;
-  uintmax_t value = value_ >= 0 ? value_ : -value_;
-
-  //count number of digits in value
-  int digits_integral = 1;
-  uintmax_t digits_integral_ = value;
-  while(digits_integral_ /= 10) digits_integral++;
-
-  int digits = (negate ? 1 : 0) + digits_integral;
-  if(!str) return digits + 1;  //only computing required length?
-
-  length = nall::min(digits, length - 1);
-  str += length;  //seek to end of target string
-  *str = 0;  //set null terminator
-  while(length && digits_integral--) {
-    uint8_t x = '0' + (value % 10);
-    value /= 10;
-    *--str = x;  //iterate backwards to write string
-    length--;
-  }
-
-  if(length && negate) {
-    *--str = '-';
-  }
-
-  return nall::min(initial_length, digits + 1);
-}
-
-size_t strunsigned(char *str, uintmax_t value, size_t length /* = 0 */) {
-  if(length == 0) length = -1U;  //"infinite" length
-  size_t initial_length = length;
-
-  //count number of digits in value
-  int digits_integral = 1;
-  uintmax_t digits_integral_ = value;
-  while(digits_integral_ /= 10) digits_integral++;
-
-  int digits = digits_integral;
-  if(!str) return digits_integral + 1;  //only computing required length?
-
-  length = nall::min(digits, length - 1);
-  str += length;  //seek to end of target string
-  *str = 0;  //set null terminator
-
-  while(length--) {
-    uint8_t x = '0' + (value % 10);
-    value /= 10;
-    *--str = x;  //iterate backwards to write string
-  }
-
-  return nall::min(initial_length, digits + 1);
-}
-
-size_t strbin(char *str, uintmax_t value, size_t length /* = 0 */) {
-  if(length == 0) length = -1U;  //"infinite" length
-  size_t initial_length = length;
-
-  //count number of digits in value
-  int digits_integral = 1;
-  uintmax_t digits_integral_ = value;
-  while(digits_integral_ /= 2) digits_integral++;
-
-  int digits = digits_integral;
-  if(!str) return digits + 1;  //only computing required length?
-
-  length = nall::min(digits, length - 1);
-  str += length;  //seek to end of target string
-  *str = 0;  //set null terminator
-
-  while(length--) {
-    uint8_t x = '0' + (value % 2);
-    value /= 2;
-    *--str = x;  //iterate backwards to write string
-  }
-
-  return nall::min(initial_length, digits + 1);
-}
-
-//using sprintf is certainly not the most ideal method to convert
-//a double to a string ... but attempting to parse a double by
-//hand, digit-by-digit, results in subtle rounding errors.
-//
-//note: length parameter is currently ignored.
-//it remains for consistency and possible future support.
-size_t strdouble(char *str, double value, size_t length /* = 0 */) {
-  char buffer[256];
-  sprintf(buffer, "%f", value);
-
-  //remove excess 0's in fraction (2.500000 -> 2.5)
-  for(char *p = buffer; *p; p++) {
-    if(*p == '.') {
-      char *p = buffer + strlen(buffer) - 1;
-      while(*p == '0') {
-        if(*(p - 1) != '.') *p = 0;  //... but not for eg 1.0 -> 1.
-        p--;
-      }
-      break;
-    }
-  }
-
-  length = strlen(buffer);
-  if(str) strcpy(str, buffer);
-  return length + 1;
-}
-
 #endif

snesfilter/nall/string/core.hpp

@@ -3,15 +3,6 @@
 
 namespace nall {
 
-inline string string::printf(const char *fmt, ...) {
-  static char text[4096];
-  va_list args;
-  va_start(args, fmt);
-  vsprintf(text, fmt, args);
-  va_end(args);
-  return text;
-}
-
 void string::reserve(size_t size_) {
   if(size_ > size) {
     size = size_;
@@ -74,11 +65,25 @@ string::string(const string &value) {
   data = strdup(value);
 }
 
+string::string(string &&source) {
+  size = source.size;
+  data = source.data;
+  source.data = 0;
+}
+
 string& string::operator=(const string &value) {
   assign(value);
   return *this;
 }
 
+string& string::operator=(string &&source) {
+  if(data) free(data);
+  size = source.size;
+  data = source.data;
+  source.data = 0;
+  return *this;
+}
+
 string::~string() {
   free(data);
 }
@@ -113,6 +118,15 @@ int lstring::find(const char *key) {
   return -1;
 }
 
-};
+inline lstring::lstring() {
+}
+
+inline lstring::lstring(std::initializer_list<string> list) {
+  for(const string *s = list.begin(); s != list.end(); ++s) {
+    operator<<(*s);
+  }
+}
+
+}
 
 #endif

snesfilter/nall/string/utility.hpp

@@ -37,32 +37,122 @@ nall::string& trim_once (nall::string &str, const char *key) { trim_once (str(),
 
 /* arithmetic <> string */
 
-nall::string strhex(uintmax_t value) {
-  nall::string temp;
-  temp.reserve(strhex(0, value));
-  strhex(temp(), value);
-  return temp;
+template<unsigned length, char padding> nall::string strhex(uintmax_t value) {
+  nall::string output;
+  unsigned offset = 0;
+
+  //render string backwards, as we do not know its length yet
+  do {
+    unsigned n = value & 15;
+    output[offset++] = n < 10 ? '0' + n : 'a' + n - 10;
+    value >>= 4;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  output[offset--] = 0;
+
+  //reverse the string in-place
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
 }
 
-nall::string strsigned(intmax_t value) {
-  nall::string temp;
-  temp.reserve(strsigned(0, value));
-  strsigned(temp(), value);
-  return temp;
+template<unsigned length, char padding> nall::string strsigned(intmax_t value) {
+  nall::string output;
+  unsigned offset = 0;
+
+  bool negative = value < 0;
+  if(negative) value = abs(value);
+
+  do {
+    unsigned n = value % 10;
+    output[offset++] = '0' + n;
+    value /= 10;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  if(negative) output[offset++] = '-';
+  output[offset--] = 0;
+
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
 }
 
-nall::string strunsigned(uintmax_t value) {
-  nall::string temp;
-  temp.reserve(strunsigned(0, value));
-  strunsigned(temp(), value);
-  return temp;
+template<unsigned length, char padding> nall::string strunsigned(uintmax_t value) {
+  nall::string output;
+  unsigned offset = 0;
+
+  do {
+    unsigned n = value % 10;
+    output[offset++] = '0' + n;
+    value /= 10;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  output[offset--] = 0;
+
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
 }
 
-nall::string strbin(uintmax_t value) {
-  nall::string temp;
-  temp.reserve(strbin(0, value));
-  strbin(temp(), value);
-  return temp;
+template<unsigned length, char padding> nall::string strbin(uintmax_t value) {
+  nall::string output;
+  unsigned offset = 0;
+
+  do {
+    unsigned n = value & 1;
+    output[offset++] = '0' + n;
+    value >>= 1;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  output[offset--] = 0;
+
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
+}
+
+//using sprintf is certainly not the most ideal method to convert
+//a double to a string ... but attempting to parse a double by
+//hand, digit-by-digit, results in subtle rounding errors.
+size_t strdouble(char *str, double value) {
+  char buffer[256];
+  sprintf(buffer, "%f", value);
+
+  //remove excess 0's in fraction (2.500000 -> 2.5)
+  for(char *p = buffer; *p; p++) {
+    if(*p == '.') {
+      char *p = buffer + strlen(buffer) - 1;
+      while(*p == '0') {
+        if(*(p - 1) != '.') *p = 0;  //... but not for eg 1.0 -> 1.
+        p--;
+      }
+      break;
+    }
+  }
+
+  unsigned length = strlen(buffer);
+  if(str) strcpy(str, buffer);
+  return length + 1;
 }
 
 nall::string strdouble(double value) {

snesfilter/nall/string/variadic.hpp

@@ -0,0 +1,37 @@
+#ifndef NALL_STRING_VARIADIC_HPP
+#define NALL_STRING_VARIADIC_HPP
+
+namespace nall {
+  static void sprint(string &output, unsigned &offset, const char *&s) {
+    while(*s) output[offset++] = *s++;
+  }
+
+  template<typename T, typename... Args>
+  static void sprint(string &output, unsigned &offset, const char *&s, T value, Args... args) {
+    while(*s) {
+      if(*s == '$') {
+        string data = to_string<T>(value);
+        unsigned i = 0;
+        while(data[i]) output[offset++] = data[i++];
+        sprint(output, offset, ++s, args...);
+        return;
+      } else {
+        output[offset++] = *s++;
+      }
+    }
+  }
+
+  template<typename... Args> inline string sprint(const char *s, Args... args) {
+    string output;
+    unsigned offset = 0;
+    sprint(output, offset, s, args...);
+    output[offset] = 0;
+    return output;
+  }
+
+  template<typename... Args> inline void print(const char *s, Args... args) {
+    printf("%s", (const char*)sprint(s, args...));
+  }
+}
+
+#endif

snesfilter/nall/string/xml.hpp

@@ -0,0 +1,268 @@
+#ifndef NALL_STRING_XML_HPP
+#define NALL_STRING_XML_HPP
+
+//XML subset parser
+//version 0.04
+
+#include <nall/array.hpp>
+
+namespace nall {
+
+struct xml_attribute {
+  string name;
+  string content;
+  virtual string parse() const;
+};
+
+struct xml_element : xml_attribute {
+  string parse() const;
+  array<xml_attribute*> attribute;
+  array<xml_element*> element;
+  ~xml_element();
+
+protected:
+  void parse_doctype(const char *&data);
+  bool parse_head(string data);
+  bool parse_body(const char *&data);
+  friend xml_element *xml_parse(const char *data);
+};
+
+inline string xml_attribute::parse() const {
+  string data;
+  unsigned offset = 0;
+
+  const char *source = content;
+  while(*source) {
+    if(*source == '&') {
+      if(strbegin(source, "&lt;"))   { data[offset++] = '<';  source += 4; continue; }
+      if(strbegin(source, "&gt;"))   { data[offset++] = '>';  source += 4; continue; }
+      if(strbegin(source, "&amp;"))  { data[offset++] = '&';  source += 5; continue; }
+      if(strbegin(source, "&apos;")) { data[offset++] = '\''; source += 6; continue; }
+      if(strbegin(source, "&quot;")) { data[offset++] = '"';  source += 6; continue; }
+    }
+
+    //reject illegal characters
+    if(*source == '&') return "";
+    if(*source == '<') return "";
+    if(*source == '>') return "";
+
+    data[offset++] = *source++;
+  }
+
+  data[offset] = 0;
+  return data;
+}
+
+inline string xml_element::parse() const {
+  string data;
+  unsigned offset = 0;
+
+  const char *source = content;
+  while(*source) {
+    if(*source == '&') {
+      if(strbegin(source, "&lt;"))   { data[offset++] = '<';  source += 4; continue; }
+      if(strbegin(source, "&gt;"))   { data[offset++] = '>';  source += 4; continue; }
+      if(strbegin(source, "&amp;"))  { data[offset++] = '&';  source += 5; continue; }
+      if(strbegin(source, "&apos;")) { data[offset++] = '\''; source += 6; continue; }
+      if(strbegin(source, "&quot;")) { data[offset++] = '"';  source += 6; continue; }
+    }
+
+    if(strbegin(source, "<!--")) {
+      signed pos = strpos(source, "-->");
+      if(pos == -1) return "";
+      source += pos + 3;
+      continue;
+    }
+
+    if(strbegin(source, "<![CDATA[")) {
+      signed pos = strpos(source, "]]>");
+      if(pos == -1) return "";
+      string cdata = substr(source, 9, pos - 9);
+      data << cdata;
+      offset += strlen(cdata);
+
+      source += offset + 3;
+      continue;
+    }
+
+    //reject illegal characters
+    if(*source == '&') return "";
+    if(*source == '<') return "";
+    if(*source == '>') return "";
+
+    data[offset++] = *source++;
+  }
+
+  data[offset] = 0;
+  return data;
+}
+
+inline void xml_element::parse_doctype(const char *&data) {
+  name = "!DOCTYPE";
+  const char *content_begin = data;
+
+  signed counter = 0;
+  while(*data) {
+    char value = *data++;
+    if(value == '<') counter++;
+    if(value == '>') counter--;
+    if(counter < 0) {
+      content = substr(content_begin, 0, data - content_begin - 1);
+      return;
+    }
+  }
+  throw "...";
+}
+
+inline bool xml_element::parse_head(string data) {
+  data.qreplace("\t", " ");
+  data.qreplace("\r", " ");
+  data.qreplace("\n", " ");
+  while(qstrpos(data, "  ") >= 0) data.qreplace("  ", " ");
+  data.qreplace(" =", "=");
+  data.qreplace("= ", "=");
+  rtrim(data);
+
+  lstring part;
+  part.qsplit(" ", data);
+
+  name = part[0];
+  if(name == "") throw "...";
+
+  for(unsigned i = 1; i < part.size(); i++) {
+    lstring side;
+    side.qsplit("=", part[i]);
+    if(side.size() != 2) throw "...";
+
+    xml_attribute *attr = new xml_attribute;
+    attr->name = side[0];
+    attr->content = side[1];
+    if(strbegin(attr->content, "\"") && strend(attr->content, "\"")) trim_once(attr->content, "\"");
+    else if(strbegin(attr->content, "'") && strend(attr->content, "'")) trim_once(attr->content, "'");
+    else throw "...";
+    attribute.add(attr);
+  }
+}
+
+inline bool xml_element::parse_body(const char *&data) {
+  while(true) {
+    if(!*data) return false;
+    if(*data++ != '<') continue;
+    if(*data == '/') return false;
+
+    if(strbegin(data, "!DOCTYPE") == true) {
+      parse_doctype(data);
+      return true;
+    }
+
+    if(strbegin(data, "!--")) {
+      signed offset = strpos(data, "-->");
+      if(offset == -1) throw "...";
+      data += offset + 3;
+      continue;
+    }
+
+    if(strbegin(data, "![CDATA[")) {
+      signed offset = strpos(data, "]]>");
+      if(offset == -1) throw "...";
+      data += offset + 3;
+      continue;
+    }
+
+    signed offset = strpos(data, ">");
+    if(offset == -1) throw "...";
+
+    string tag = substr(data, 0, offset);
+    data += offset + 1;
+    const char *content_begin = data;
+
+    bool self_terminating = false;
+
+    if(strend(tag, "?") == true) {
+      self_terminating = true;
+      rtrim_once(tag, "?");
+    } else if(strend(tag, "/") == true) {
+      self_terminating = true;
+      rtrim_once(tag, "/");
+    }
+
+    parse_head(tag);
+    if(self_terminating) return true;
+
+    while(*data) {
+      unsigned index = element.size();
+      xml_element *elem = new xml_element;
+      if(elem->parse_body(data) == false) {
+        delete elem;
+
+        if(*data == '/') {
+          signed length = data - content_begin - 1;
+          if(length > 0) content = substr(content_begin, 0, length);
+
+          data++;
+          offset = strpos(data, ">");
+          if(offset == -1) throw "...";
+
+          tag = substr(data, 0, offset);
+          data += offset + 1;
+
+          tag.replace("\t", " ");
+          tag.replace("\r", " ");
+          tag.replace("\n", " ");
+          while(strpos(tag, "  ") >= 0) tag.replace("  ", " ");
+          rtrim(tag);
+
+          if(name != tag) throw "...";
+          return true;
+        }
+      } else {
+        element.add(elem);
+      }
+    }
+  }
+}
+
+inline xml_element::~xml_element() {
+  for(unsigned i = 0; i < attribute.size(); i++) delete attribute[i];
+  for(unsigned i = 0; i < element.size(); i++) delete element[i];
+}
+
+//ensure there is only one root element
+inline bool xml_validate(xml_element *document) {
+  unsigned root_counter = 0;
+
+  for(unsigned i = 0; i < document->element.size(); i++) {
+    string &name = document->element[i]->name;
+    if(strbegin(name, "?")) continue;
+    if(strbegin(name, "!")) continue;
+    if(++root_counter > 1) return false;
+  }
+
+  return true;
+}
+
+inline xml_element* xml_parse(const char *data) {
+  xml_element *self = new xml_element;
+
+  try {
+    while(*data) {
+      xml_element *elem = new xml_element;
+      if(elem->parse_body(data) == false) {
+        delete elem;
+        break;
+      } else {
+        self->element.add(elem);
+      }
+    }
+
+    if(xml_validate(self) == false) throw "...";
+    return self;
+  } catch(const char*) {
+    delete self;
+    return 0;
+  }
+}
+
+}
+
+#endif

snesfilter/nall/utility.hpp

@@ -1,32 +1,37 @@
 #ifndef NALL_UTILITY_HPP
 #define NALL_UTILITY_HPP
 
+#include <nall/traits.hpp>
+
 namespace nall {
-  template<typename T>
-  inline void swap(T &x, T &y) {
-    T temp(x);
-    x = y;
-    y = temp;
+  template<typename T> struct identity {
+    typedef T type;
+  };
+
+  template<typename T> typename remove_reference<T>::type&& move(T &&value) {
+    return value;
   }
 
-  template<typename T>
-  struct base_from_member {
+  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);
+  }
+
+  template<typename T> struct base_from_member {
     T value;
     base_from_member(T value_) : value(value_) {}
   };
 
-  class noncopyable {
-  protected:
-    noncopyable() {}
-    ~noncopyable() {}
-
-  private:
-    noncopyable(const noncopyable&);
-    const noncopyable& operator=(const noncopyable&);
-  };
-
-  template<typename T>
-  inline T* allocate(size_t size, const T &value) {
+  template<typename T> inline T* allocate(size_t size, const T &value) {
     T *array = new T[size];
     for(size_t i = 0; i < size; i++) array[i] = value;
     return array;

snesfilter/nall/vector.hpp

@@ -1,9 +1,12 @@
 #ifndef NALL_VECTOR_HPP
 #define NALL_VECTOR_HPP
 
+#include <initializer_list>
 #include <new>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
+#include <nall/concept.hpp>
+#include <nall/traits.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
@@ -19,7 +22,7 @@ namespace nall {
   //if objects hold memory address references to themselves (introspection), a
   //valid copy constructor will be needed to keep pointers valid.
 
-  template<typename T> class linear_vector : noncopyable {
+  template<typename T> class linear_vector {
   protected:
     T *pool;
     unsigned poolsize, objectsize;
@@ -79,8 +82,43 @@ namespace nall {
       return pool[index];
     }
 
-    linear_vector() : pool(0), poolsize(0), objectsize(0) {}
-    ~linear_vector() { reset(); }
+    //copy
+    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]);
+      return *this;
+    }
+
+    linear_vector(const linear_vector<T> &source) {
+      operator=(source);
+    }
+
+    //move
+    inline linear_vector<T>& operator=(linear_vector<T> &&source) {
+      reset();
+      pool = source.pool;
+      poolsize = source.poolsize;
+      objectsize = source.objectsize;
+      source.pool = 0;
+      return *this;
+    }
+
+    linear_vector(linear_vector<T> &&source) {
+      operator=(move(source));
+    }
+
+    //construction
+    linear_vector() : pool(0), poolsize(0), objectsize(0) {
+    }
+
+    linear_vector(std::initializer_list<T> list) : pool(0), poolsize(0), objectsize(0) {
+      for(const T *p = list.begin(); p != list.end(); ++p) add(*p);
+    }
+
+    ~linear_vector() {
+      reset();
+    }
   };
 
   //pointer_vector
@@ -93,7 +131,7 @@ namespace nall {
   //by guaranteeing that the base memory address of each objects never changes,
   //this avoids the need for an object to have a valid copy constructor.
 
-  template<typename T> class pointer_vector : noncopyable {
+  template<typename T> class pointer_vector {
   protected:
     T **pool;
     unsigned poolsize, objectsize;
@@ -151,12 +189,47 @@ namespace nall {
       return *pool[index];
     }
 
-    pointer_vector() : pool(0), poolsize(0), objectsize(0) {}
-    ~pointer_vector() { reset(); }
+    //copy
+    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]);
+      return *this;
+    }
+
+    pointer_vector(const pointer_vector<T> &source) {
+      operator=(source);
+    }
+
+    //move
+    inline pointer_vector<T>& operator=(pointer_vector<T> &&source) {
+      reset();
+      pool = source.pool;
+      poolsize = source.poolsize;
+      objectsize = source.objectsize;
+      source.pool = 0;
+      return *this;
+    }
+
+    pointer_vector(pointer_vector<T> &&source) {
+      operator=(move(source));
+    }
+
+    //construction
+    pointer_vector() : pool(0), poolsize(0), objectsize(0) {
+    }
+
+    pointer_vector(std::initializer_list<T> list) : pool(0), poolsize(0), objectsize(0) {
+      for(const T *p = list.begin(); p != list.end(); ++p) add(*p);
+    }
+
+    ~pointer_vector() {
+      reset();
+    }
   };
 
-  //default vector type
-  template<typename T> class vector : public linear_vector<T> {};
+  template<typename T> struct has_size<linear_vector<T>> { enum { value = true }; };
+  template<typename T> struct has_size<pointer_vector<T>> { enum { value = true }; };
 }
 
 #endif

snesreader/Makefile

@@ -3,8 +3,8 @@ include nall/Makefile
 qtlibs := QtCore QtGui
 include nall/qt/Makefile
 
-c     := $(compiler)
-cpp   := $(subst cc,++,$(compiler))
+c     := $(compiler) -std=gnu99
+cpp   := $(subst cc,++,$(compiler)) -std=gnu++0x
 flags := -O3 -I. -Iobj -fomit-frame-pointer
 link  :=
 

snesreader/libjma/winout.h

@@ -64,8 +64,9 @@ public:
       MoveBlockBackward();
     BYTE *p = m_Buffer + m_Pos;
     aDistance++;
+    BYTE *p2 = p - aDistance;
     for(UINT32 i = 0; i < aLen; i++)
-      p[i] = p[i - aDistance];
+      p[i] = p2[i];
     m_Pos += aLen;
   }
 

snesreader/nall/algorithm.hpp

@@ -5,11 +5,11 @@
 #undef max
 
 namespace nall {
-  template<typename T, typename U> T min(const T& t, const U& u) {
+  template<typename T, typename U> T min(const T &t, const U &u) {
     return t < u ? t : u;
   }
 
-  template<typename T, typename U> T max(const T& t, const U& u) {
+  template<typename T, typename U> T max(const T &t, const U &u) {
     return t > u ? t : u;
   }
 

snesreader/nall/array.hpp

@@ -2,8 +2,11 @@
 #define NALL_ARRAY_HPP
 
 #include <stdlib.h>
+#include <initializer_list>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
+#include <nall/concept.hpp>
+#include <nall/traits.hpp>
 
 namespace nall {
   //dynamic vector array
@@ -57,18 +60,18 @@ namespace nall {
       memset(pool, 0, buffersize * sizeof(T));
     }
 
-    array() {
-      pool = 0;
-      poolsize = 0;
-      buffersize = 0;
+    array() : pool(0), poolsize(0), buffersize(0) {
     }
 
-    ~array() { reset(); }
-
-    array(const array &source) : pool(0) {
-      operator=(source);
+    array(std::initializer_list<T> list) : pool(0), poolsize(0), buffersize(0) {
+      for(const T *p = list.begin(); p != list.end(); ++p) add(*p);
     }
 
+    ~array() {
+      reset();
+    }
+
+    //copy
     array& operator=(const array &source) {
       if(pool) free(pool);
       buffersize = source.buffersize;
@@ -78,6 +81,25 @@ namespace nall {
       return *this;
     }
 
+    array(const array &source) : pool(0) {
+      operator=(source);
+    }
+
+    //move
+    array& operator=(array &&source) {
+      if(pool) free(pool);
+      pool = source.pool;
+      poolsize = source.poolsize;
+      buffersize = source.buffersize;
+      source.pool = 0;
+      return *this;
+    }
+
+    array(array &&source) {
+      operator=(move(source));
+    }
+
+    //index
     inline T& operator[](unsigned index) {
       if(index >= buffersize) resize(index + 1);
       if(index >= buffersize) throw "array[] out of bounds";
@@ -89,6 +111,8 @@ namespace nall {
       return pool[index];
     }
   };
+
+  template<typename T> struct has_size<array<T>> { enum { value = true }; };
 }
 
 #endif

snesreader/nall/concept.hpp

@@ -0,0 +1,15 @@
+#ifndef NALL_CONCEPT_HPP
+#define NALL_CONCEPT_HPP
+
+namespace nall {
+  //unsigned count() const;
+  template<typename T> struct has_count { enum { value = false }; };
+
+  //unsigned length() const;
+  template<typename T> struct has_length { enum { value = false }; };
+
+  //unsigned size() const;
+  template<typename T> struct has_size { enum { value = false }; };
+}
+
+#endif

snesreader/nall/config.hpp

@@ -53,7 +53,7 @@ namespace nall {
         }
       }
     };
-    vector<item_t> list;
+    linear_vector<item_t> list;
 
     template<typename T>
     void attach(T &data, const char *name, const char *desc = "") {

snesreader/nall/dictionary.hpp

@@ -6,7 +6,7 @@
 #include <nall/utility.hpp>
 
 namespace nall {
-  class dictionary : noncopyable {
+  class dictionary {
   public:
     string operator[](const char *input) {
       for(unsigned i = 0; i < index_input.size(); i++) {
@@ -64,6 +64,9 @@ namespace nall {
       reset();
     }
 
+    dictionary& operator=(const dictionary&) = delete;
+    dictionary(const dictionary&) = delete;
+
   protected:
     lstring index_input;
     lstring index_output;

snesreader/nall/dl.hpp

@@ -16,7 +16,7 @@
 #endif
 
 namespace nall {
-  struct library : noncopyable {
+  struct library {
     bool opened() const { return handle; }
     bool open(const char*);
     void* sym(const char*);
@@ -25,6 +25,9 @@ namespace nall {
     library() : handle(0) {}
     ~library() { close(); }
 
+    library& operator=(const library&) = delete;
+    library(const library&) = delete;
+
   private:
     uintptr_t handle;
   };

snesreader/nall/file.hpp

@@ -23,7 +23,7 @@ namespace nall {
     #endif
   }
 
-  class file : noncopyable {
+  class file {
   public:
     enum FileMode { mode_read, mode_write, mode_readwrite, mode_writeread };
     enum SeekMode { seek_absolute, seek_relative };
@@ -218,6 +218,9 @@ namespace nall {
       close();
     }
 
+    file& operator=(const file&) = delete;
+    file(const file&) = delete;
+
   private:
     enum { buffer_size = 1 << 12, buffer_mask = buffer_size - 1 };
     char buffer[buffer_size];

snesreader/nall/foreach.hpp

@@ -0,0 +1,31 @@
+#ifndef NALL_FOREACH_HPP
+#define NALL_FOREACH_HPP
+
+#undef foreach
+#define foreach(iter, object) \
+  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 <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) {
+    return object.count();
+  }
+
+  template<typename T> unsigned foreach_size(const T& object, typename mp_enable_if<has_length<T>>::type = 0) {
+    return object.length();
+  }
+
+  template<typename T> unsigned foreach_size(const T& object, typename mp_enable_if<has_size<T>>::type = 0) {
+    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);
+  }
+}
+
+#endif

snesreader/nall/priorityqueue.hpp

@@ -14,7 +14,7 @@ namespace nall {
   //O(1)     find   (tick)
   //O(log n) insert (enqueue)
   //O(log n) remove (dequeue)
-  template<typename type_t> class priority_queue : noncopyable {
+  template<typename type_t> class priority_queue {
   public:
     inline void tick(unsigned ticks) {
       basecounter += ticks;
@@ -86,6 +86,9 @@ namespace nall {
       delete[] heap;
     }
 
+    priority_queue& operator=(const priority_queue&) = delete;
+    priority_queue(const priority_queue&) = delete;
+
   private:
     function<void (type_t)> callback;
     unsigned basecounter;

snesreader/nall/qt/concept.hpp

@@ -0,0 +1,10 @@
+#ifndef NALL_QT_CONCEPT_HPP
+#define NALL_QT_CONCEPT_HPP
+
+#include <nall/concept.hpp>
+
+namespace nall {
+  template<typename T> struct has_count<QList<T>> { enum { value = true }; };
+}
+
+#endif

snesreader/nall/qt/hex-editor.moc.hpp

@@ -11,15 +11,14 @@ class HexEditor : public QTextEdit {
   Q_OBJECT
 
 public:
-  enum {
-    LineWidth = 59,
-  };
-
   function<uint8_t (unsigned)> reader;
   function<void (unsigned, uint8_t)> writer;
 
+  void setColumns(unsigned columns);
+  void setRows(unsigned rows);
   void setOffset(unsigned offset);
   void setSize(unsigned size);
+  unsigned lineWidth() const;
   void refresh();
 
   HexEditor();
@@ -30,6 +29,8 @@ protected slots:
 protected:
   QHBoxLayout *layout;
   QScrollBar *scrollBar;
+  unsigned editorColumns;
+  unsigned editorRows;
   unsigned editorOffset;
   unsigned editorSize;
   bool lock;
@@ -39,8 +40,8 @@ protected:
 
 inline void HexEditor::keyPressEvent(QKeyEvent *event) {
   QTextCursor cursor = textCursor();
-  unsigned x = cursor.position() % LineWidth;
-  unsigned y = cursor.position() / LineWidth;
+  unsigned x = cursor.position() % lineWidth();
+  unsigned y = cursor.position() / lineWidth();
 
   int hexCode = -1;
   switch(event->key()) {
@@ -66,7 +67,7 @@ inline void HexEditor::keyPressEvent(QKeyEvent *event) {
     bool cursorOffsetValid = (x >= 11 && ((x - 11) % 3) != 2);
     if(cursorOffsetValid) {
       bool nibble = (x - 11) % 3;  //0 = top nibble, 1 = bottom nibble
-      unsigned cursorOffset = y * 16 + ((x - 11) / 3);
+      unsigned cursorOffset = y * editorColumns + ((x - 11) / 3);
       unsigned effectiveOffset = editorOffset + cursorOffset;
       if(effectiveOffset >= editorSize) effectiveOffset %= editorSize;
 
@@ -76,7 +77,7 @@ inline void HexEditor::keyPressEvent(QKeyEvent *event) {
       if(writer) writer(effectiveOffset, data);
       refresh();
 
-      cursor.setPosition(y * LineWidth + x + 1);  //advance cursor
+      cursor.setPosition(y * lineWidth() + x + 1);  //advance cursor
       setTextCursor(cursor);
     }
   } else {
@@ -87,16 +88,30 @@ inline void HexEditor::keyPressEvent(QKeyEvent *event) {
   }
 }
 
+inline void HexEditor::setColumns(unsigned columns) {
+  editorColumns = columns;
+}
+
+inline void HexEditor::setRows(unsigned rows) {
+  editorRows = rows;
+  scrollBar->setPageStep(editorRows);
+}
+
 inline void HexEditor::setOffset(unsigned offset) {
   lock = true;
   editorOffset = offset;
-  scrollBar->setSliderPosition(editorOffset / 16);
+  scrollBar->setSliderPosition(editorOffset / editorColumns);
   lock = false;
 }
 
 inline void HexEditor::setSize(unsigned size) {
   editorSize = size;
-  scrollBar->setRange(0, editorSize / 16 - 16);
+  bool indivisible = (editorSize % editorColumns) != 0;  //add one for incomplete row
+  scrollBar->setRange(0, editorSize / editorColumns + indivisible - editorRows);
+}
+
+inline unsigned HexEditor::lineWidth() const {
+  return 11 + 3 * editorColumns;
 }
 
 inline void HexEditor::refresh() {
@@ -104,20 +119,20 @@ inline void HexEditor::refresh() {
   char temp[256];
   unsigned offset = editorOffset;
 
-  for(unsigned y = 0; y < 16; y++) {
+  for(unsigned y = 0; y < editorRows; y++) {
     if(offset >= editorSize) break;
     sprintf(temp, "%.4x:%.4x", (offset >> 16) & 0xffff, (offset >> 0) & 0xffff);
     output << "<font color='#808080'>" << temp << "</font>&nbsp;&nbsp;";
 
-    for(unsigned x = 0; x < 16; x++) {
+    for(unsigned x = 0; x < editorColumns; x++) {
       if(offset >= editorSize) break;
       sprintf(temp, "%.2x", reader ? reader(offset) : 0x00);
       offset++;
       output << "<font color='" << ((x & 1) ? "#000080" : "#0000ff") << "'>" << temp << "</font>";
-      if(x != 15) output << "&nbsp;";
+      if(x != (editorColumns - 1)) output << "&nbsp;";
     }
 
-    if(y != 15) output << "<br>";
+    if(y != (editorRows - 1)) output << "<br>";
   }
 
   setHtml(output);
@@ -126,7 +141,7 @@ inline void HexEditor::refresh() {
 inline void HexEditor::scrolled() {
   if(lock) return;
   unsigned offset = scrollBar->sliderPosition();
-  editorOffset = offset * 16;
+  editorOffset = offset * editorColumns;
   refresh();
 }
 
@@ -142,12 +157,13 @@ inline HexEditor::HexEditor() {
 
   scrollBar = new QScrollBar(Qt::Vertical);
   scrollBar->setSingleStep(1);
-  scrollBar->setPageStep(16);
   layout->addWidget(scrollBar);
 
   lock = false;
   connect(scrollBar, SIGNAL(actionTriggered(int)), this, SLOT(scrolled()));
 
+  setColumns(16);
+  setRows(16);
   setSize(0);
   setOffset(0);
 }

snesreader/nall/serializer.hpp

@@ -6,7 +6,6 @@
 #include <nall/utility.hpp>
 
 namespace nall {
-
   //serializer: a class designed to save and restore the state of classes.
   //
   //benefits:
@@ -17,7 +16,6 @@ namespace nall {
   //caveats:
   //- only plain-old-data can be stored. complex classes must provide serialize(serializer&);
   //- floating-point usage is not portable across platforms
-
   class serializer {
   public:
     enum mode_t { Load, Save, Size };
@@ -73,6 +71,7 @@ namespace nall {
       for(unsigned n = 0; n < size; n++) integer(array[n]);
     }
 
+    //copy
     serializer& operator=(const serializer &s) {
       if(idata) delete[] idata;
 
@@ -89,6 +88,24 @@ namespace nall {
       operator=(s);
     }
 
+    //move
+    serializer& operator=(serializer &&s) {
+      if(idata) delete[] idata;
+
+      imode = s.imode;
+      idata = s.idata;
+      isize = s.isize;
+      icapacity = s.icapacity;
+
+      s.idata = 0;
+      return *this;
+    }
+
+    serializer(serializer &&s) {
+      operator=(move(s));
+    }
+
+    //construction
     serializer() {
       imode = Size;
       idata = 0;

snesreader/nall/static.hpp

@@ -2,16 +2,19 @@
 #define NALL_STATIC_HPP
 
 namespace nall {
-  template<bool condition> struct static_assert;
-  template<> struct static_assert<true> {};
+  template<bool C, typename T, typename F> struct static_if { typedef T type; };
+  template<typename T, typename F> struct static_if<false, T, F> { typedef F type; };
+  template<typename C, typename T, typename F> struct mp_static_if { typedef typename static_if<C::type, T, F>::type type; };
 
-  template<bool condition, typename true_type, typename false_type> struct static_if {
-    typedef true_type type;
-  };
+  template<bool A, bool B> struct static_and { enum { value = false }; };
+  template<> struct static_and<true, true> { enum { value = true }; };
+  template<typename A, typename B> struct mp_static_and { enum { value = static_and<A::value, B::value>::value }; };
 
-  template<typename true_type, typename false_type> struct static_if<false, true_type, false_type> {
-    typedef false_type type;
-  };
+  template<bool A, bool B> struct static_or { enum { value = false }; };
+  template<> struct static_or<false, true> { enum { value = true }; };
+  template<> struct static_or<true, false> { enum { value = true }; };
+  template<> struct static_or<true, true> { enum { value = true }; };
+  template<typename A, typename B> struct mp_static_or { enum { value = static_or<A::value, B::value>::value }; };
 }
 
 #endif

snesreader/nall/stdint.hpp

@@ -30,15 +30,15 @@
 #endif
 
 namespace nall {
-  static static_assert<sizeof(int8_t)   == 1> int8_t_assert;
-  static static_assert<sizeof(int16_t)  == 2> int16_t_assert;
-  static static_assert<sizeof(int32_t)  == 4> int32_t_assert;
-  static static_assert<sizeof(int64_t)  == 8> int64_t_assert;
+  static_assert(sizeof(int8_t)   == 1, "int8_t is not of the correct size" );
+  static_assert(sizeof(int16_t)  == 2, "int16_t is not of the correct size");
+  static_assert(sizeof(int32_t)  == 4, "int32_t is not of the correct size");
+  static_assert(sizeof(int64_t)  == 8, "int64_t is not of the correct size");
 
-  static static_assert<sizeof(uint8_t)  == 1> uint8_t_assert;
-  static static_assert<sizeof(uint16_t) == 2> uint16_t_assert;
-  static static_assert<sizeof(uint32_t) == 4> uint32_t_assert;
-  static static_assert<sizeof(uint64_t) == 8> uint64_t_assert;
+  static_assert(sizeof(uint8_t)  == 1, "int8_t is not of the correct size" );
+  static_assert(sizeof(uint16_t) == 2, "int16_t is not of the correct size");
+  static_assert(sizeof(uint32_t) == 4, "int32_t is not of the correct size");
+  static_assert(sizeof(uint64_t) == 8, "int64_t is not of the correct size");
 }
 
 #endif

snesreader/nall/string.hpp

@@ -1,6 +1,7 @@
 #ifndef NALL_STRING_HPP
 #define NALL_STRING_HPP
 
+#include <initializer_list>
 #include <nall/string/base.hpp>
 #include <nall/string/core.hpp>
 #include <nall/string/cast.hpp>
@@ -14,5 +15,12 @@
 #include <nall/string/replace.hpp>
 #include <nall/string/split.hpp>
 #include <nall/string/utility.hpp>
+#include <nall/string/variadic.hpp>
+#include <nall/string/xml.hpp>
+
+namespace nall {
+  template<> struct has_length<string> { enum { value = true }; };
+  template<> struct has_size<lstring> { enum { value = true }; };
+}
 
 #endif

snesreader/nall/string/base.hpp

@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <nall/concept.hpp>
 #include <nall/stdint.hpp>
 #include <nall/utf8.hpp>
 #include <nall/vector.hpp>
@@ -26,11 +27,6 @@ inline intmax_t  strsigned  (const char *str);
 inline uintmax_t strunsigned(const char *str);
 inline uintmax_t strbin     (const char *str);
 inline double    strdouble  (const char *str);
-inline size_t strhex     (char *str, uintmax_t value, size_t length = 0);
-inline size_t strsigned  (char *str, intmax_t  value, size_t length = 0);
-inline size_t strunsigned(char *str, uintmax_t value, size_t length = 0);
-inline size_t strbin     (char *str, uintmax_t value, size_t length = 0);
-inline size_t strdouble  (char *str, double    value, size_t length = 0);
 inline bool match(const char *pattern, const char *str);
 inline bool strint (const char *str, int &result);
 inline bool strmath(const char *str, int &result);
@@ -49,8 +45,6 @@ namespace nall {
 
   class string {
   public:
-    static string printf(const char*, ...);
-
     inline void reserve(size_t);
     inline unsigned length() const;
 
@@ -73,7 +67,9 @@ namespace nall {
     inline string();
     inline string(const char*);
     inline string(const string&);
+    inline string(string&&);
     inline string& operator=(const string&);
+    inline string& operator=(string&&);
     inline ~string();
 
     inline bool readfile(const char*);
@@ -90,18 +86,25 @@ namespace nall {
   #endif
   };
 
-  class lstring : public vector<string> {
+  class lstring : public linear_vector<string> {
   public:
     template<typename T> inline lstring& operator<<(T value);
 
     inline int find(const char*);
     inline void split (const char*, const char*, unsigned = 0);
     inline void qsplit(const char*, const char*, unsigned = 0);
+
+    lstring();
+    lstring(std::initializer_list<string>);
   };
+
+  template<typename... Args> inline string sprint(const char *s, Args... args);
+  template<typename... Args> inline void print(const char *s, Args... args);
 };
 
 inline size_t strlcpy(nall::string &dest, const char *src, size_t length);
 inline size_t strlcat(nall::string &dest, const char *src, size_t length);
+
 inline nall::string& strlower(nall::string &str);
 inline nall::string& strupper(nall::string &str);
 inline nall::string& strtr(nall::string &dest, const char *before, const char *after);
@@ -113,10 +116,11 @@ inline nall::string& rtrim_once(nall::string &str, const char *key = " ");
 inline nall::string& trim_once (nall::string &str, const char *key = " ");
 
 inline nall::string substr(const char *src, size_t start = 0, size_t length = 0);
-inline nall::string strhex     (uintmax_t value);
-inline nall::string strsigned  (intmax_t  value);
-inline nall::string strunsigned(uintmax_t value);
-inline nall::string strbin     (uintmax_t value);
-inline nall::string strdouble  (double    value);
+template<unsigned length = 0, char padding = '0'> inline nall::string strhex(uintmax_t value);
+template<unsigned length = 0, char padding = '0'> inline nall::string strsigned(intmax_t value);
+template<unsigned length = 0, char padding = '0'> inline nall::string strunsigned(uintmax_t value);
+template<unsigned length = 0, char padding = '0'> inline nall::string strbin(uintmax_t value);
+inline size_t strdouble(char *str, double value);
+inline nall::string strdouble(double value);
 
 #endif

snesreader/nall/string/cast.hpp

@@ -2,8 +2,7 @@
 #define NALL_STRING_CAST_HPP
 
 namespace nall {
-  //this is needed, as C++98 does not support explicit template specialization inside classes;
-  //redundant memory allocation should hopefully be avoided via compiler optimizations.
+  //this is needed, as C++0x does not support explicit template specialization inside classes
   template<> inline string to_string<bool>         (bool v)          { return v ? "true" : "false"; }
   template<> inline string to_string<signed int>   (signed int v)    { return strsigned(v); }
   template<> inline string to_string<unsigned int> (unsigned int v)  { return strunsigned(v); }
@@ -25,6 +24,6 @@ namespace nall {
   template<> inline string to_string<const QString&>(const QString &v) { return v.toUtf8().constData(); }
   string::operator QString() const { return QString::fromUtf8(*this); }
   #endif
-};
+}
 
 #endif

snesreader/nall/string/convert.hpp

@@ -146,140 +146,4 @@ double strdouble(const char *str) {
   return !negate ? result : -result;
 }
 
-//
-
-size_t strhex(char *str, uintmax_t value, size_t length /* = 0 */) {
-  if(length == 0) length -= 1U;  //"infinite" length
-  size_t initial_length = length;
-
-  //count number of digits in value
-  int digits_integral = 1;
-  uintmax_t digits_integral_ = value;
-  while(digits_integral_ /= 16) digits_integral++;
-
-  int digits = digits_integral;
-  if(!str) return digits + 1;  //only computing required length?
-
-  length = nall::min(digits, length - 1);
-  str += length;  //seek to end of target string
-  *str = 0;  //set null terminator
-
-  while(length--) {
-    uint8_t x = value % 16;
-    value /= 16;
-    *--str = x < 10 ? (x + '0') : (x + 'a' - 10);  //iterate backwards to write string
-  }
-
-  return nall::min(initial_length, digits + 1);
-}
-
-size_t strsigned(char *str, intmax_t value_, size_t length /* = 0 */) {
-  if(length == 0) length = -1U;  //"infinite" length
-  size_t initial_length = length;
-
-  bool negate = value_ < 0;
-  uintmax_t value = value_ >= 0 ? value_ : -value_;
-
-  //count number of digits in value
-  int digits_integral = 1;
-  uintmax_t digits_integral_ = value;
-  while(digits_integral_ /= 10) digits_integral++;
-
-  int digits = (negate ? 1 : 0) + digits_integral;
-  if(!str) return digits + 1;  //only computing required length?
-
-  length = nall::min(digits, length - 1);
-  str += length;  //seek to end of target string
-  *str = 0;  //set null terminator
-  while(length && digits_integral--) {
-    uint8_t x = '0' + (value % 10);
-    value /= 10;
-    *--str = x;  //iterate backwards to write string
-    length--;
-  }
-
-  if(length && negate) {
-    *--str = '-';
-  }
-
-  return nall::min(initial_length, digits + 1);
-}
-
-size_t strunsigned(char *str, uintmax_t value, size_t length /* = 0 */) {
-  if(length == 0) length = -1U;  //"infinite" length
-  size_t initial_length = length;
-
-  //count number of digits in value
-  int digits_integral = 1;
-  uintmax_t digits_integral_ = value;
-  while(digits_integral_ /= 10) digits_integral++;
-
-  int digits = digits_integral;
-  if(!str) return digits_integral + 1;  //only computing required length?
-
-  length = nall::min(digits, length - 1);
-  str += length;  //seek to end of target string
-  *str = 0;  //set null terminator
-
-  while(length--) {
-    uint8_t x = '0' + (value % 10);
-    value /= 10;
-    *--str = x;  //iterate backwards to write string
-  }
-
-  return nall::min(initial_length, digits + 1);
-}
-
-size_t strbin(char *str, uintmax_t value, size_t length /* = 0 */) {
-  if(length == 0) length = -1U;  //"infinite" length
-  size_t initial_length = length;
-
-  //count number of digits in value
-  int digits_integral = 1;
-  uintmax_t digits_integral_ = value;
-  while(digits_integral_ /= 2) digits_integral++;
-
-  int digits = digits_integral;
-  if(!str) return digits + 1;  //only computing required length?
-
-  length = nall::min(digits, length - 1);
-  str += length;  //seek to end of target string
-  *str = 0;  //set null terminator
-
-  while(length--) {
-    uint8_t x = '0' + (value % 2);
-    value /= 2;
-    *--str = x;  //iterate backwards to write string
-  }
-
-  return nall::min(initial_length, digits + 1);
-}
-
-//using sprintf is certainly not the most ideal method to convert
-//a double to a string ... but attempting to parse a double by
-//hand, digit-by-digit, results in subtle rounding errors.
-//
-//note: length parameter is currently ignored.
-//it remains for consistency and possible future support.
-size_t strdouble(char *str, double value, size_t length /* = 0 */) {
-  char buffer[256];
-  sprintf(buffer, "%f", value);
-
-  //remove excess 0's in fraction (2.500000 -> 2.5)
-  for(char *p = buffer; *p; p++) {
-    if(*p == '.') {
-      char *p = buffer + strlen(buffer) - 1;
-      while(*p == '0') {
-        if(*(p - 1) != '.') *p = 0;  //... but not for eg 1.0 -> 1.
-        p--;
-      }
-      break;
-    }
-  }
-
-  length = strlen(buffer);
-  if(str) strcpy(str, buffer);
-  return length + 1;
-}
-
 #endif

snesreader/nall/string/core.hpp

@@ -3,15 +3,6 @@
 
 namespace nall {
 
-inline string string::printf(const char *fmt, ...) {
-  static char text[4096];
-  va_list args;
-  va_start(args, fmt);
-  vsprintf(text, fmt, args);
-  va_end(args);
-  return text;
-}
-
 void string::reserve(size_t size_) {
   if(size_ > size) {
     size = size_;
@@ -74,11 +65,25 @@ string::string(const string &value) {
   data = strdup(value);
 }
 
+string::string(string &&source) {
+  size = source.size;
+  data = source.data;
+  source.data = 0;
+}
+
 string& string::operator=(const string &value) {
   assign(value);
   return *this;
 }
 
+string& string::operator=(string &&source) {
+  if(data) free(data);
+  size = source.size;
+  data = source.data;
+  source.data = 0;
+  return *this;
+}
+
 string::~string() {
   free(data);
 }
@@ -113,6 +118,15 @@ int lstring::find(const char *key) {
   return -1;
 }
 
-};
+inline lstring::lstring() {
+}
+
+inline lstring::lstring(std::initializer_list<string> list) {
+  for(const string *s = list.begin(); s != list.end(); ++s) {
+    operator<<(*s);
+  }
+}
+
+}
 
 #endif

snesreader/nall/string/utility.hpp

@@ -37,32 +37,122 @@ nall::string& trim_once (nall::string &str, const char *key) { trim_once (str(),
 
 /* arithmetic <> string */
 
-nall::string strhex(uintmax_t value) {
-  nall::string temp;
-  temp.reserve(strhex(0, value));
-  strhex(temp(), value);
-  return temp;
+template<unsigned length, char padding> nall::string strhex(uintmax_t value) {
+  nall::string output;
+  unsigned offset = 0;
+
+  //render string backwards, as we do not know its length yet
+  do {
+    unsigned n = value & 15;
+    output[offset++] = n < 10 ? '0' + n : 'a' + n - 10;
+    value >>= 4;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  output[offset--] = 0;
+
+  //reverse the string in-place
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
 }
 
-nall::string strsigned(intmax_t value) {
-  nall::string temp;
-  temp.reserve(strsigned(0, value));
-  strsigned(temp(), value);
-  return temp;
+template<unsigned length, char padding> nall::string strsigned(intmax_t value) {
+  nall::string output;
+  unsigned offset = 0;
+
+  bool negative = value < 0;
+  if(negative) value = abs(value);
+
+  do {
+    unsigned n = value % 10;
+    output[offset++] = '0' + n;
+    value /= 10;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  if(negative) output[offset++] = '-';
+  output[offset--] = 0;
+
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
 }
 
-nall::string strunsigned(uintmax_t value) {
-  nall::string temp;
-  temp.reserve(strunsigned(0, value));
-  strunsigned(temp(), value);
-  return temp;
+template<unsigned length, char padding> nall::string strunsigned(uintmax_t value) {
+  nall::string output;
+  unsigned offset = 0;
+
+  do {
+    unsigned n = value % 10;
+    output[offset++] = '0' + n;
+    value /= 10;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  output[offset--] = 0;
+
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
 }
 
-nall::string strbin(uintmax_t value) {
-  nall::string temp;
-  temp.reserve(strbin(0, value));
-  strbin(temp(), value);
-  return temp;
+template<unsigned length, char padding> nall::string strbin(uintmax_t value) {
+  nall::string output;
+  unsigned offset = 0;
+
+  do {
+    unsigned n = value & 1;
+    output[offset++] = '0' + n;
+    value >>= 1;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  output[offset--] = 0;
+
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
+}
+
+//using sprintf is certainly not the most ideal method to convert
+//a double to a string ... but attempting to parse a double by
+//hand, digit-by-digit, results in subtle rounding errors.
+size_t strdouble(char *str, double value) {
+  char buffer[256];
+  sprintf(buffer, "%f", value);
+
+  //remove excess 0's in fraction (2.500000 -> 2.5)
+  for(char *p = buffer; *p; p++) {
+    if(*p == '.') {
+      char *p = buffer + strlen(buffer) - 1;
+      while(*p == '0') {
+        if(*(p - 1) != '.') *p = 0;  //... but not for eg 1.0 -> 1.
+        p--;
+      }
+      break;
+    }
+  }
+
+  unsigned length = strlen(buffer);
+  if(str) strcpy(str, buffer);
+  return length + 1;
 }
 
 nall::string strdouble(double value) {

snesreader/nall/string/variadic.hpp

@@ -0,0 +1,37 @@
+#ifndef NALL_STRING_VARIADIC_HPP
+#define NALL_STRING_VARIADIC_HPP
+
+namespace nall {
+  static void sprint(string &output, unsigned &offset, const char *&s) {
+    while(*s) output[offset++] = *s++;
+  }
+
+  template<typename T, typename... Args>
+  static void sprint(string &output, unsigned &offset, const char *&s, T value, Args... args) {
+    while(*s) {
+      if(*s == '$') {
+        string data = to_string<T>(value);
+        unsigned i = 0;
+        while(data[i]) output[offset++] = data[i++];
+        sprint(output, offset, ++s, args...);
+        return;
+      } else {
+        output[offset++] = *s++;
+      }
+    }
+  }
+
+  template<typename... Args> inline string sprint(const char *s, Args... args) {
+    string output;
+    unsigned offset = 0;
+    sprint(output, offset, s, args...);
+    output[offset] = 0;
+    return output;
+  }
+
+  template<typename... Args> inline void print(const char *s, Args... args) {
+    printf("%s", (const char*)sprint(s, args...));
+  }
+}
+
+#endif

snesreader/nall/string/xml.hpp

@@ -0,0 +1,268 @@
+#ifndef NALL_STRING_XML_HPP
+#define NALL_STRING_XML_HPP
+
+//XML subset parser
+//version 0.04
+
+#include <nall/array.hpp>
+
+namespace nall {
+
+struct xml_attribute {
+  string name;
+  string content;
+  virtual string parse() const;
+};
+
+struct xml_element : xml_attribute {
+  string parse() const;
+  array<xml_attribute*> attribute;
+  array<xml_element*> element;
+  ~xml_element();
+
+protected:
+  void parse_doctype(const char *&data);
+  bool parse_head(string data);
+  bool parse_body(const char *&data);
+  friend xml_element *xml_parse(const char *data);
+};
+
+inline string xml_attribute::parse() const {
+  string data;
+  unsigned offset = 0;
+
+  const char *source = content;
+  while(*source) {
+    if(*source == '&') {
+      if(strbegin(source, "&lt;"))   { data[offset++] = '<';  source += 4; continue; }
+      if(strbegin(source, "&gt;"))   { data[offset++] = '>';  source += 4; continue; }
+      if(strbegin(source, "&amp;"))  { data[offset++] = '&';  source += 5; continue; }
+      if(strbegin(source, "&apos;")) { data[offset++] = '\''; source += 6; continue; }
+      if(strbegin(source, "&quot;")) { data[offset++] = '"';  source += 6; continue; }
+    }
+
+    //reject illegal characters
+    if(*source == '&') return "";
+    if(*source == '<') return "";
+    if(*source == '>') return "";
+
+    data[offset++] = *source++;
+  }
+
+  data[offset] = 0;
+  return data;
+}
+
+inline string xml_element::parse() const {
+  string data;
+  unsigned offset = 0;
+
+  const char *source = content;
+  while(*source) {
+    if(*source == '&') {
+      if(strbegin(source, "&lt;"))   { data[offset++] = '<';  source += 4; continue; }
+      if(strbegin(source, "&gt;"))   { data[offset++] = '>';  source += 4; continue; }
+      if(strbegin(source, "&amp;"))  { data[offset++] = '&';  source += 5; continue; }
+      if(strbegin(source, "&apos;")) { data[offset++] = '\''; source += 6; continue; }
+      if(strbegin(source, "&quot;")) { data[offset++] = '"';  source += 6; continue; }
+    }
+
+    if(strbegin(source, "<!--")) {
+      signed pos = strpos(source, "-->");
+      if(pos == -1) return "";
+      source += pos + 3;
+      continue;
+    }
+
+    if(strbegin(source, "<![CDATA[")) {
+      signed pos = strpos(source, "]]>");
+      if(pos == -1) return "";
+      string cdata = substr(source, 9, pos - 9);
+      data << cdata;
+      offset += strlen(cdata);
+
+      source += offset + 3;
+      continue;
+    }
+
+    //reject illegal characters
+    if(*source == '&') return "";
+    if(*source == '<') return "";
+    if(*source == '>') return "";
+
+    data[offset++] = *source++;
+  }
+
+  data[offset] = 0;
+  return data;
+}
+
+inline void xml_element::parse_doctype(const char *&data) {
+  name = "!DOCTYPE";
+  const char *content_begin = data;
+
+  signed counter = 0;
+  while(*data) {
+    char value = *data++;
+    if(value == '<') counter++;
+    if(value == '>') counter--;
+    if(counter < 0) {
+      content = substr(content_begin, 0, data - content_begin - 1);
+      return;
+    }
+  }
+  throw "...";
+}
+
+inline bool xml_element::parse_head(string data) {
+  data.qreplace("\t", " ");
+  data.qreplace("\r", " ");
+  data.qreplace("\n", " ");
+  while(qstrpos(data, "  ") >= 0) data.qreplace("  ", " ");
+  data.qreplace(" =", "=");
+  data.qreplace("= ", "=");
+  rtrim(data);
+
+  lstring part;
+  part.qsplit(" ", data);
+
+  name = part[0];
+  if(name == "") throw "...";
+
+  for(unsigned i = 1; i < part.size(); i++) {
+    lstring side;
+    side.qsplit("=", part[i]);
+    if(side.size() != 2) throw "...";
+
+    xml_attribute *attr = new xml_attribute;
+    attr->name = side[0];
+    attr->content = side[1];
+    if(strbegin(attr->content, "\"") && strend(attr->content, "\"")) trim_once(attr->content, "\"");
+    else if(strbegin(attr->content, "'") && strend(attr->content, "'")) trim_once(attr->content, "'");
+    else throw "...";
+    attribute.add(attr);
+  }
+}
+
+inline bool xml_element::parse_body(const char *&data) {
+  while(true) {
+    if(!*data) return false;
+    if(*data++ != '<') continue;
+    if(*data == '/') return false;
+
+    if(strbegin(data, "!DOCTYPE") == true) {
+      parse_doctype(data);
+      return true;
+    }
+
+    if(strbegin(data, "!--")) {
+      signed offset = strpos(data, "-->");
+      if(offset == -1) throw "...";
+      data += offset + 3;
+      continue;
+    }
+
+    if(strbegin(data, "![CDATA[")) {
+      signed offset = strpos(data, "]]>");
+      if(offset == -1) throw "...";
+      data += offset + 3;
+      continue;
+    }
+
+    signed offset = strpos(data, ">");
+    if(offset == -1) throw "...";
+
+    string tag = substr(data, 0, offset);
+    data += offset + 1;
+    const char *content_begin = data;
+
+    bool self_terminating = false;
+
+    if(strend(tag, "?") == true) {
+      self_terminating = true;
+      rtrim_once(tag, "?");
+    } else if(strend(tag, "/") == true) {
+      self_terminating = true;
+      rtrim_once(tag, "/");
+    }
+
+    parse_head(tag);
+    if(self_terminating) return true;
+
+    while(*data) {
+      unsigned index = element.size();
+      xml_element *elem = new xml_element;
+      if(elem->parse_body(data) == false) {
+        delete elem;
+
+        if(*data == '/') {
+          signed length = data - content_begin - 1;
+          if(length > 0) content = substr(content_begin, 0, length);
+
+          data++;
+          offset = strpos(data, ">");
+          if(offset == -1) throw "...";
+
+          tag = substr(data, 0, offset);
+          data += offset + 1;
+
+          tag.replace("\t", " ");
+          tag.replace("\r", " ");
+          tag.replace("\n", " ");
+          while(strpos(tag, "  ") >= 0) tag.replace("  ", " ");
+          rtrim(tag);
+
+          if(name != tag) throw "...";
+          return true;
+        }
+      } else {
+        element.add(elem);
+      }
+    }
+  }
+}
+
+inline xml_element::~xml_element() {
+  for(unsigned i = 0; i < attribute.size(); i++) delete attribute[i];
+  for(unsigned i = 0; i < element.size(); i++) delete element[i];
+}
+
+//ensure there is only one root element
+inline bool xml_validate(xml_element *document) {
+  unsigned root_counter = 0;
+
+  for(unsigned i = 0; i < document->element.size(); i++) {
+    string &name = document->element[i]->name;
+    if(strbegin(name, "?")) continue;
+    if(strbegin(name, "!")) continue;
+    if(++root_counter > 1) return false;
+  }
+
+  return true;
+}
+
+inline xml_element* xml_parse(const char *data) {
+  xml_element *self = new xml_element;
+
+  try {
+    while(*data) {
+      xml_element *elem = new xml_element;
+      if(elem->parse_body(data) == false) {
+        delete elem;
+        break;
+      } else {
+        self->element.add(elem);
+      }
+    }
+
+    if(xml_validate(self) == false) throw "...";
+    return self;
+  } catch(const char*) {
+    delete self;
+    return 0;
+  }
+}
+
+}
+
+#endif

snesreader/nall/utility.hpp

@@ -1,32 +1,37 @@
 #ifndef NALL_UTILITY_HPP
 #define NALL_UTILITY_HPP
 
+#include <nall/traits.hpp>
+
 namespace nall {
-  template<typename T>
-  inline void swap(T &x, T &y) {
-    T temp(x);
-    x = y;
-    y = temp;
+  template<typename T> struct identity {
+    typedef T type;
+  };
+
+  template<typename T> typename remove_reference<T>::type&& move(T &&value) {
+    return value;
   }
 
-  template<typename T>
-  struct base_from_member {
+  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);
+  }
+
+  template<typename T> struct base_from_member {
     T value;
     base_from_member(T value_) : value(value_) {}
   };
 
-  class noncopyable {
-  protected:
-    noncopyable() {}
-    ~noncopyable() {}
-
-  private:
-    noncopyable(const noncopyable&);
-    const noncopyable& operator=(const noncopyable&);
-  };
-
-  template<typename T>
-  inline T* allocate(size_t size, const T &value) {
+  template<typename T> inline T* allocate(size_t size, const T &value) {
     T *array = new T[size];
     for(size_t i = 0; i < size; i++) array[i] = value;
     return array;

snesreader/nall/vector.hpp

@@ -1,9 +1,12 @@
 #ifndef NALL_VECTOR_HPP
 #define NALL_VECTOR_HPP
 
+#include <initializer_list>
 #include <new>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
+#include <nall/concept.hpp>
+#include <nall/traits.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
@@ -19,7 +22,7 @@ namespace nall {
   //if objects hold memory address references to themselves (introspection), a
   //valid copy constructor will be needed to keep pointers valid.
 
-  template<typename T> class linear_vector : noncopyable {
+  template<typename T> class linear_vector {
   protected:
     T *pool;
     unsigned poolsize, objectsize;
@@ -79,8 +82,43 @@ namespace nall {
       return pool[index];
     }
 
-    linear_vector() : pool(0), poolsize(0), objectsize(0) {}
-    ~linear_vector() { reset(); }
+    //copy
+    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]);
+      return *this;
+    }
+
+    linear_vector(const linear_vector<T> &source) {
+      operator=(source);
+    }
+
+    //move
+    inline linear_vector<T>& operator=(linear_vector<T> &&source) {
+      reset();
+      pool = source.pool;
+      poolsize = source.poolsize;
+      objectsize = source.objectsize;
+      source.pool = 0;
+      return *this;
+    }
+
+    linear_vector(linear_vector<T> &&source) {
+      operator=(move(source));
+    }
+
+    //construction
+    linear_vector() : pool(0), poolsize(0), objectsize(0) {
+    }
+
+    linear_vector(std::initializer_list<T> list) : pool(0), poolsize(0), objectsize(0) {
+      for(const T *p = list.begin(); p != list.end(); ++p) add(*p);
+    }
+
+    ~linear_vector() {
+      reset();
+    }
   };
 
   //pointer_vector
@@ -93,7 +131,7 @@ namespace nall {
   //by guaranteeing that the base memory address of each objects never changes,
   //this avoids the need for an object to have a valid copy constructor.
 
-  template<typename T> class pointer_vector : noncopyable {
+  template<typename T> class pointer_vector {
   protected:
     T **pool;
     unsigned poolsize, objectsize;
@@ -151,12 +189,47 @@ namespace nall {
       return *pool[index];
     }
 
-    pointer_vector() : pool(0), poolsize(0), objectsize(0) {}
-    ~pointer_vector() { reset(); }
+    //copy
+    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]);
+      return *this;
+    }
+
+    pointer_vector(const pointer_vector<T> &source) {
+      operator=(source);
+    }
+
+    //move
+    inline pointer_vector<T>& operator=(pointer_vector<T> &&source) {
+      reset();
+      pool = source.pool;
+      poolsize = source.poolsize;
+      objectsize = source.objectsize;
+      source.pool = 0;
+      return *this;
+    }
+
+    pointer_vector(pointer_vector<T> &&source) {
+      operator=(move(source));
+    }
+
+    //construction
+    pointer_vector() : pool(0), poolsize(0), objectsize(0) {
+    }
+
+    pointer_vector(std::initializer_list<T> list) : pool(0), poolsize(0), objectsize(0) {
+      for(const T *p = list.begin(); p != list.end(); ++p) add(*p);
+    }
+
+    ~pointer_vector() {
+      reset();
+    }
   };
 
-  //default vector type
-  template<typename T> class vector : public linear_vector<T> {};
+  template<typename T> struct has_size<linear_vector<T>> { enum { value = true }; };
+  template<typename T> struct has_size<pointer_vector<T>> { enum { value = true }; };
 }
 
 #endif

snesreader/snesreader.cpp

@@ -17,13 +17,10 @@ extern "C" char* uncompressStream(int, int);  //micro-bunzip
 #include <nall/string.hpp>
 using namespace nall;
 
+#include "xml.cpp"
+
 dllexport const char* snesreader_supported() {
-  //libjma does not work on 64-bit architectures
-  #if !defined(__amd64) && !defined(_M_X64)
   return "*.zip *.z *.7z *.rar *.gz *.bz2 *.jma";
-  #else
-  return "*.zip *.z *.7z *.rar *.gz *.bz2";
-  #endif
 }
 
 void snesreader_apply_ips(const char *filename, uint8_t *&data, unsigned &size) {
@@ -197,8 +194,9 @@ bool snesreader_load_jma(const char *filename, uint8_t *&data, unsigned &size) {
   }
 }
 
-dllexport bool snesreader_load(string &filename, uint8_t *&data, unsigned &size) {
+dllexport bool snesreader_load(string &filename, string &xmldata, uint8_t *&data, unsigned &size) {
   if(file::exists(filename) == false) return false;
+  xmldata = "";
 
   bool success = false;
   if(striend(filename, ".zip")
@@ -228,5 +226,6 @@ dllexport bool snesreader_load(string &filename, uint8_t *&data, unsigned &size)
   //remove copier header, if it exists
   if((size & 0x7fff) == 512) memmove(data, data + 512, size -= 512);
 
+  xml.generate(xmldata, data, size);
   return true;
 }

snesreader/snesreader.hpp

@@ -3,5 +3,5 @@ namespace nall { class string; }
 
 extern "C" {
   const char* snesreader_supported();
-  bool snesreader_load(nall::string &filename, uint8_t *&data, unsigned &size);
+  bool snesreader_load(nall::string &filename, nall::string &xml, uint8_t *&data, unsigned &size);
 }

snesreader/xml.cpp

@@ -0,0 +1,750 @@
+#include "xml.hpp"
+XML xml;
+
+typedef uint8_t  uint8;
+typedef uint16_t uint16;
+typedef uint32_t uint32;
+typedef uint64_t uint64;
+
+void XML::generate(string &xml, const uint8_t *data, unsigned size) {
+  read_header(data, size);
+
+  xml = "<?xml version='1.0' encoding='UTF-8'?>\n";
+
+  if(type == TypeBsx) {
+    xml << "<cartridge/>";
+    return;
+  } else if(type == TypeSufamiTurbo) {
+    xml << "<cartridge/>";
+    return;
+  } else if(type == TypeGameBoy) {
+    xml << "<cartridge rtc='" << gameboy_has_rtc(data, size) << "'>\n";
+    if(gameboy_ram_size(data, size) > 0) {
+      xml << "  <ram size='" << strhex(gameboy_ram_size(data, size)) << "'/>\n";
+    }
+    xml << "</cartridge>\n";
+    return;
+  }
+
+  xml << "<cartridge";
+  if(region == NTSC) {
+    xml << " region='NTSC'";
+  } else {
+    xml << " region='PAL'";
+  }
+  xml << ">\n";
+
+  if(type == TypeSuperGameBoy1Bios) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <supergameboy revision='1'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:6000-7fff'/>\n";
+    xml << "      <map address='80-bf:6000-7fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </supergameboy>\n";
+  } else if(type == TypeSuperGameBoy2Bios) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <supergameboy revision='2'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:6000-7fff'/>\n";
+    xml << "      <map address='80-bf:6000-7fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </supergameboy>\n";
+  } else if(has_sdd1) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-3f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='40-7f:0000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-bf:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+
+    if(ram_size > 0) {
+      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+      xml << "  </ram>\n";
+    }
+
+    xml << "  <sdd1>\n";
+    xml << "    <mcu>\n";
+    xml << "      <map address='c0-ff:0000-ffff'/>\n";
+    xml << "    </mcu>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:4800-4807'/>\n";
+    xml << "      <map address='80-bf:4800-4807'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </sdd1>\n";
+  } else if(has_spc7110) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='shadow' address='00-0f:8000-ffff'/>\n";
+    xml << "    <map mode='shadow' address='80-bf:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='c0-cf:0000-ffff'/>\n";
+    xml << "  </rom>\n";
+
+    xml << "  <spc7110>\n";
+    xml << "    <mcu>\n";
+    xml << "      <map address='d0-ff:0000-ffff' offset='100000' size='" << strhex(size - 0x100000) << "'/>\n";
+    xml << "    </mcu>\n";
+    xml << "    <ram size='" << strhex(ram_size) << "'>\n";
+    xml << "      <map mode='linear' address='00:6000-7fff'/>\n";
+    xml << "      <map mode='linear' address='30:6000-7fff'/>\n";
+    xml << "    </ram>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:4800-483f'/>\n";
+    xml << "      <map address='80-bf:4800-483f'/>\n";
+    xml << "    </mmio>\n";
+    if(has_spc7110rtc) {
+      xml << "    <rtc>\n";
+      xml << "      <map address='00-3f:4840-4842'/>\n";
+      xml << "      <map address='80-bf:4840-4842'/>\n";
+      xml << "    </rtc>\n";
+    }
+    xml << "    <dcu>\n";
+    xml << "      <map address='50:0000-ffff'/>\n";
+    xml << "    </dcu>\n";
+    xml << "  </spc7110>\n";
+  } else if(mapper == LoROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+
+    if(ram_size > 0) {
+      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
+        xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+        xml << "    <map mode='linear' address='f0-ff:0000-7fff'/>\n";
+      } else {
+        xml << "    <map mode='linear' address='70-7f:0000-ffff'/>\n";
+        xml << "    <map mode='linear' address='f0-ff:0000-ffff'/>\n";
+      }
+      xml << "  </ram>\n";
+    }
+  } else if(mapper == HiROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='shadow' address='00-3f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='40-7f:0000-ffff'/>\n";
+    xml << "    <map mode='shadow' address='80-bf:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='c0-ff:0000-ffff'/>\n";
+    xml << "  </rom>\n";
+
+    if(ram_size > 0) {
+      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
+        xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+      } else {
+        xml << "    <map mode='linear' address='70-7f:0000-ffff'/>\n";
+      }
+      xml << "  </ram>\n";
+    }
+  } else if(mapper == ExHiROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='shadow' address='00-3f:8000-ffff' offset='400000'/>\n";
+    xml << "    <map mode='linear' address='40-7f:0000-ffff' offset='400000'/>\n";
+    xml << "    <map mode='shadow' address='80-bf:8000-ffff' offset='000000'/>\n";
+    xml << "    <map mode='linear' address='c0-ff:0000-ffff' offset='000000'/>\n";
+    xml << "  </rom>\n";
+
+    if(ram_size > 0) {
+      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
+        xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+      } else {
+        xml << "    <map mode='linear' address='70-7f:0000-ffff'/>\n";
+      }
+      xml << "  </ram>\n";
+    }
+  } else if(mapper == SuperFXROM) {
+    xml << "  <superfx revision='2'>\n";
+    xml << "    <rom>\n";
+    xml << "      <map mode='linear' address='00-3f:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='40-5f:0000-ffff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='c0-df:0000-ffff'/>\n";
+    xml << "    </rom>\n";
+    xml << "    <ram size='" << strhex(ram_size) << "'>\n";
+    xml << "      <map mode='linear' address='00-3f:6000-7fff' size='2000'/>\n";
+    xml << "      <map mode='linear' address='60-7f:0000-ffff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:6000-7fff' size='2000'/>\n";
+    xml << "      <map mode='linear' address='e0-ff:0000-ffff'/>\n";
+    xml << "    </ram>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:3000-32ff'/>\n";
+    xml << "      <map address='80-bf:3000-32ff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </superfx>\n";
+  } else if(mapper == SA1ROM) {
+    xml << "  <sa1>\n";
+    xml << "    <rom>\n";
+    xml << "      <map mode='linear' address='00-3f:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='c0-ff:0000-ffff'/>\n";
+    xml << "    </rom>\n";
+    xml << "    <iram size='800'>\n";
+    xml << "      <map mode='linear' address='00-3f:3000-37ff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:3000-37ff'/>\n";
+    xml << "    </iram>\n";
+    xml << "    <bwram size='" << strhex(ram_size) << "'>\n";
+    xml << "      <map mode='linear' address='00-3f:6000-7fff'/>\n";
+    xml << "      <map mode='linear' address='40-4f:0000-ffff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:6000-7fff'/>\n";
+    xml << "    </bwram>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:2200-23ff'/>\n";
+    xml << "      <map address='80-bf:2200-23ff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </sa1>\n";
+  } else if(mapper == BSCLoROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-1f:8000-ffff' offset='000000'/>\n";
+    xml << "    <map mode='linear' address='20-3f:8000-ffff' offset='100000'/>\n";
+    xml << "    <map mode='linear' address='80-9f:8000-ffff' offset='200000'/>\n";
+    xml << "    <map mode='linear' address='a0-bf:8000-ffff' offset='100000'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+    xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+    xml << "    <map mode='linear' address='f0-ff:0000-7fff'/>\n";
+    xml << "  </ram>\n";
+    xml << "  <bsx>\n";
+    xml << "    <slot>\n";
+    xml << "      <map mode='linear' address='c0-ef:0000-ffff'/>\n";
+    xml << "    </slot>\n";
+    xml << "  </bsx>\n";
+  } else if(mapper == BSCHiROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='shadow' address='00-1f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='40-5f:0000-ffff'/>\n";
+    xml << "    <map mode='shadow' address='80-9f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='c0-df:0000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+    xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+    xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+    xml << "  </ram>\n";
+    xml << "  <bsx>\n";
+    xml << "    <slot>\n";
+    xml << "      <map mode='shadow' address='20-3f:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='60-7f:0000-ffff'/>\n";
+    xml << "      <map mode='shadow' address='a0-bf:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='e0-ff:0000-ffff'/>\n";
+    xml << "    </slot>\n";
+    xml << "  </bsx>\n";
+  } else if(mapper == BSXROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-3f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-bf:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <bsx>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:5000-5fff'/>\n";
+    xml << "      <map address='80-bf:5000-5fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </bsx>\n";
+  } else if(mapper == STROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-1f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-9f:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <sufamiturbo>\n";
+    xml << "    <slot id='A'>\n";
+    xml << "      <rom>\n";
+    xml << "        <map mode='linear' address='20-3f:8000-ffff'/>\n";
+    xml << "        <map mode='linear' address='a0-bf:8000-ffff'/>\n";
+    xml << "      </rom>\n";
+    xml << "      <ram>\n";
+    xml << "        <map mode='linear' address='60-63:8000-ffff'/>\n";
+    xml << "        <map mode='linear' address='e0-e3:8000-ffff'/>\n";
+    xml << "      </ram>\n";
+    xml << "    </slot>\n";
+    xml << "    <slot id='B'>\n";
+    xml << "      <rom>\n";
+    xml << "        <map mode='linear' address='40-5f:8000-ffff'/>\n";
+    xml << "        <map mode='linear' address='c0-df:8000-ffff'/>\n";
+    xml << "      </rom>\n";
+    xml << "      <ram>\n";
+    xml << "        <map mode='linear' address='70-73:8000-ffff'/>\n";
+    xml << "        <map mode='linear' address='f0-f3:8000-ffff'/>\n";
+    xml << "      </ram>\n";
+    xml << "    </slot>\n";
+    xml << "  </sufamiturbo>\n";
+  }
+
+  if(has_srtc) {
+    xml << "  <srtc>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:2800-2801'/>\n";
+    xml << "      <map address='80-bf:2800-2801'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </srtc>\n";
+  }
+
+  if(has_cx4) {
+    xml << "  <cx4>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:6000-7fff'/>\n";
+    xml << "      <map address='80-bf:6000-7fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </cx4>\n";
+  }
+
+  if(has_dsp1) {
+    xml << "  <necdsp program='DSP-1B'>\n";
+    if(dsp1_mapper == DSP1LoROM1MB) {
+      xml << "    <dr>\n";
+      xml << "      <map address='20-3f:8000-bfff'/>\n";
+      xml << "      <map address='a0-bf:8000-bfff'/>\n";
+      xml << "    </dr>\n";
+      xml << "    <sr>\n";
+      xml << "      <map address='20-3f:c000-ffff'/>\n";
+      xml << "      <map address='a0-bf:c000-ffff'/>\n";
+      xml << "    </sr>\n";
+    } else if(dsp1_mapper == DSP1LoROM2MB) {
+      xml << "    <dr>\n";
+      xml << "      <map address='60-6f:0000-3fff'/>\n";
+      xml << "      <map address='e0-ef:0000-3fff'/>\n";
+      xml << "    </dr>\n";
+      xml << "    <sr>\n";
+      xml << "      <map address='60-6f:4000-7fff'/>\n";
+      xml << "      <map address='e0-ef:4000-7fff'/>\n";
+      xml << "    </sr>\n";
+    } else if(dsp1_mapper == DSP1HiROM) {
+      xml << "    <dr>\n";
+      xml << "      <map address='00-1f:6000-6fff'/>\n";
+      xml << "      <map address='80-9f:6000-6fff'/>\n";
+      xml << "    </dr>\n";
+      xml << "    <sr>\n";
+      xml << "      <map address='00-1f:7000-7fff'/>\n";
+      xml << "      <map address='80-9f:7000-7fff'/>\n";
+      xml << "    </sr>\n";
+    }
+    xml << "  </necdsp>\n";
+  }
+
+  if(has_dsp2) {
+    xml << "  <necdsp program='DSP-2'>\n";
+    xml << "    <dr>\n";
+    xml << "      <map address='20-3f:6000-6fff'/>\n";
+    xml << "      <map address='a0-bf:6000-6fff'/>\n";
+    xml << "    </dr>\n";
+    xml << "    <sr>\n";
+    xml << "      <map address='20-3f:8000-bfff'/>\n";
+    xml << "      <map address='a0-bf:8000-bfff'/>\n";
+    xml << "    </sr>\n";
+    xml << "  </necdsp>\n";
+  }
+
+  if(has_dsp3) {
+    xml << "  <necdsp program='DSP-3'>\n";
+    xml << "    <dr>\n";
+    xml << "      <map address='20-3f:8000-bfff'/>\n";
+    xml << "      <map address='a0-bf:8000-bfff'/>\n";
+    xml << "    </dr>\n";
+    xml << "    <sr>\n";
+    xml << "      <map address='20-3f:c000-ffff'/>\n";
+    xml << "      <map address='a0-bf:c000-ffff'/>\n";
+    xml << "    </sr>\n";
+    xml << "  </necdsp>\n";
+  }
+
+  if(has_dsp4) {
+    xml << "  <necdsp program='DSP-4'>\n";
+    xml << "    <dr>\n";
+    xml << "      <map address='30-3f:8000-bfff'/>\n";
+    xml << "      <map address='b0-bf:8000-bfff'/>\n";
+    xml << "    </dr>\n";
+    xml << "    <sr>\n";
+    xml << "      <map address='30-3f:c000-ffff'/>\n";
+    xml << "      <map address='b0-bf:c000-ffff'/>\n";
+    xml << "    </sr>\n";
+    xml << "  </necdsp>\n";
+  }
+
+  if(has_obc1) {
+    xml << "  <obc1>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:6000-7fff'/>\n";
+    xml << "      <map address='80-bf:6000-7fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </obc1>\n";
+  }
+
+  if(has_st010) {
+    xml << "  <setadsp program='ST-0010'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='68-6f:0000-0fff'/>\n";
+    xml << "      <map address='e8-ef:0000-0fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </setadsp>\n";
+  }
+
+  if(has_st011) {
+    //ST-0011 addresses not verified; chip is unsupported
+    xml << "  <setadsp program='ST-0011'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='68-6f:0000-0fff'/>\n";
+    xml << "      <map address='e8-ef:0000-0fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </setadsp>\n";
+  }
+
+  if(has_st018) {
+    xml << "  <setarisc program='ST-0018'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:3800-38ff'/>\n";
+    xml << "      <map address='80-bf:3800-38ff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </setarisc>\n";
+  }
+
+  xml << "</cartridge>\n";
+}
+
+void XML::read_header(const uint8_t *data, unsigned size) {
+  type        = TypeUnknown;
+  mapper      = LoROM;
+  dsp1_mapper = DSP1Unmapped;
+  region      = NTSC;
+  rom_size    = size;
+  ram_size    = 0;
+
+  has_bsx_slot   = false;
+  has_superfx    = false;
+  has_sa1        = false;
+  has_srtc       = false;
+  has_sdd1       = false;
+  has_spc7110    = false;
+  has_spc7110rtc = false;
+  has_cx4        = false;
+  has_dsp1       = false;
+  has_dsp2       = false;
+  has_dsp3       = false;
+  has_dsp4       = false;
+  has_obc1       = false;
+  has_st010      = false;
+  has_st011      = false;
+  has_st018      = false;
+
+  //=====================
+  //detect Game Boy carts
+  //=====================
+
+  if(size >= 0x0140) {
+    if(data[0x0104] == 0xce && data[0x0105] == 0xed && data[0x0106] == 0x66 && data[0x0107] == 0x66
+    && data[0x0108] == 0xcc && data[0x0109] == 0x0d && data[0x010a] == 0x00 && data[0x010b] == 0x0b) {
+      type = TypeGameBoy;
+      return;
+    }
+  }
+
+  const unsigned index = find_header(data, size);
+  const uint8 mapperid = data[index + Mapper];
+  const uint8 rom_type = data[index + RomType];
+  const uint8 rom_size = data[index + RomSize];
+  const uint8 company  = data[index + Company];
+  const uint8 regionid = data[index + CartRegion] & 0x7f;
+
+  ram_size = 1024 << (data[index + RamSize] & 7);
+  if(ram_size == 1024) ram_size = 0;  //no RAM present
+
+  //0, 1, 13 = NTSC; 2 - 12 = PAL
+  region = (regionid <= 1 || regionid >= 13) ? NTSC : PAL;
+
+  //=======================
+  //detect BS-X flash carts
+  //=======================
+
+  if(data[index + 0x13] == 0x00 || data[index + 0x13] == 0xff) {
+    if(data[index + 0x14] == 0x00) {
+      const uint8_t n15 = data[index + 0x15];
+      if(n15 == 0x00 || n15 == 0x80 || n15 == 0x84 || n15 == 0x9c || n15 == 0xbc || n15 == 0xfc) {
+        if(data[index + 0x1a] == 0x33 || data[index + 0x1a] == 0xff) {
+          type = TypeBsx;
+          mapper = BSXROM;
+          region = NTSC;  //BS-X only released in Japan
+          return;
+        }
+      }
+    }
+  }
+
+  //=========================
+  //detect Sufami Turbo carts
+  //=========================
+
+  if(!memcmp(data, "BANDAI SFC-ADX", 14)) {
+    if(!memcmp(data + 16, "SFC-ADX BACKUP", 14)) {
+      type = TypeSufamiTurboBios;
+    } else {
+      type = TypeSufamiTurbo;
+    }
+    mapper = STROM;
+    region = NTSC;  //Sufami Turbo only released in Japan
+    return;         //RAM size handled outside this routine
+  }
+
+  //==========================
+  //detect Super Game Boy BIOS
+  //==========================
+
+  if(!memcmp(data + index, "Super GAMEBOY2", 14)) {
+    type = TypeSuperGameBoy2Bios;
+    return;
+  }
+
+  if(!memcmp(data + index, "Super GAMEBOY", 13)) {
+    type = TypeSuperGameBoy1Bios;
+    return;
+  }
+
+  //=====================
+  //detect standard carts
+  //=====================
+
+  //detect presence of BS-X flash cartridge connector (reads extended header information)
+  if(data[index - 14] == 'Z') {
+    if(data[index - 11] == 'J') {
+      uint8 n13 = data[index - 13];
+      if((n13 >= 'A' && n13 <= 'Z') || (n13 >= '0' && n13 <= '9')) {
+        if(company == 0x33 || (data[index - 10] == 0x00 && data[index - 4] == 0x00)) {
+          has_bsx_slot = true;
+        }
+      }
+    }
+  }
+
+  if(has_bsx_slot) {
+    if(!memcmp(data + index, "Satellaview BS-X     ", 21)) {
+      //BS-X base cart
+      type = TypeBsxBios;
+      mapper = BSXROM;
+      region = NTSC;  //BS-X only released in Japan
+      return;         //RAM size handled internally by load_cart_bsx() -> BSXCart class
+    } else {
+      type = TypeBsxSlotted;
+      mapper = (index == 0x7fc0 ? BSCLoROM : BSCHiROM);
+      region = NTSC;  //BS-X slotted cartridges only released in Japan
+    }
+  } else {
+    //standard cart
+    type = TypeNormal;
+
+    if(index == 0x7fc0 && size >= 0x401000) {
+      mapper = ExLoROM;
+    } else if(index == 0x7fc0 && mapperid == 0x32) {
+      mapper = ExLoROM;
+    } else if(index == 0x7fc0) {
+      mapper = LoROM;
+    } else if(index == 0xffc0) {
+      mapper = HiROM;
+    } else {  //index == 0x40ffc0
+      mapper = ExHiROM;
+    }
+  }
+
+  if(mapperid == 0x20 && (rom_type == 0x13 || rom_type == 0x14 || rom_type == 0x15 || rom_type == 0x1a)) {
+    has_superfx = true;
+    mapper = SuperFXROM;
+    ram_size = 1024 << (data[index - 3] & 7);
+    if(ram_size == 1024) ram_size = 0;
+  }
+
+  if(mapperid == 0x23 && (rom_type == 0x32 || rom_type == 0x34 || rom_type == 0x35)) {
+    has_sa1 = true;
+    mapper = SA1ROM;
+  }
+
+  if(mapperid == 0x35 && rom_type == 0x55) {
+    has_srtc = true;
+  }
+
+  if(mapperid == 0x32 && (rom_type == 0x43 || rom_type == 0x45)) {
+    has_sdd1 = true;
+  }
+
+  if(mapperid == 0x3a && (rom_type == 0xf5 || rom_type == 0xf9)) {
+    has_spc7110 = true;
+    has_spc7110rtc = (rom_type == 0xf9);
+    mapper = SPC7110ROM;
+  }
+
+  if(mapperid == 0x20 && rom_type == 0xf3) {
+    has_cx4 = true;
+  }
+
+  if((mapperid == 0x20 || mapperid == 0x21) && rom_type == 0x03) {
+    has_dsp1 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x05 && company != 0xb2) {
+    has_dsp1 = true;
+  }
+
+  if(mapperid == 0x31 && (rom_type == 0x03 || rom_type == 0x05)) {
+    has_dsp1 = true;
+  }
+
+  if(has_dsp1 == true) {
+    if((mapperid & 0x2f) == 0x20 && size <= 0x100000) {
+      dsp1_mapper = DSP1LoROM1MB;
+    } else if((mapperid & 0x2f) == 0x20) {
+      dsp1_mapper = DSP1LoROM2MB;
+    } else if((mapperid & 0x2f) == 0x21) {
+      dsp1_mapper = DSP1HiROM;
+    }
+  }
+
+  if(mapperid == 0x20 && rom_type == 0x05) {
+    has_dsp2 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x05 && company == 0xb2) {
+    has_dsp3 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x03) {
+    has_dsp4 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x25) {
+    has_obc1 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0xf6 && rom_size >= 10) {
+    has_st010 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0xf6 && rom_size < 10) {
+    has_st011 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0xf5) {
+    has_st018 = true;
+  }
+}
+
+unsigned XML::find_header(const uint8_t *data, unsigned size) const {
+  unsigned score_lo = score_header(data, size, 0x007fc0);
+  unsigned score_hi = score_header(data, size, 0x00ffc0);
+  unsigned score_ex = score_header(data, size, 0x40ffc0);
+  if(score_ex) score_ex += 4;  //favor ExHiROM on images > 32mbits
+
+  if(score_lo >= score_hi && score_lo >= score_ex) {
+    return 0x007fc0;
+  } else if(score_hi >= score_ex) {
+    return 0x00ffc0;
+  } else {
+    return 0x40ffc0;
+  }
+}
+
+unsigned XML::score_header(const uint8_t *data, unsigned size, unsigned addr) const {
+  if(size < addr + 64) return 0;  //image too small to contain header at this location?
+  int score = 0;
+
+  uint16 resetvector = data[addr + ResetVector] | (data[addr + ResetVector + 1] << 8);
+  uint16 checksum    = data[addr + Checksum   ] | (data[addr + Checksum    + 1] << 8);
+  uint16 complement  = data[addr + Complement ] | (data[addr + Complement  + 1] << 8);
+
+  uint8 resetop = data[(addr & ~0x7fff) | (resetvector & 0x7fff)];  //first opcode executed upon reset
+  uint8 mapper  = data[addr + Mapper] & ~0x10;                      //mask off irrelevent FastROM-capable bit
+
+  //$00:[000-7fff] contains uninitialized RAM and MMIO.
+  //reset vector must point to ROM at $00:[8000-ffff] to be considered valid.
+  if(resetvector < 0x8000) return 0;
+
+  //some images duplicate the header in multiple locations, and others have completely
+  //invalid header information that cannot be relied upon.
+  //below code will analyze the first opcode executed at the specified reset vector to
+  //determine the probability that this is the correct header.
+
+  //most likely opcodes
+  if(resetop == 0x78  //sei
+  || resetop == 0x18  //clc (clc; xce)
+  || resetop == 0x38  //sec (sec; xce)
+  || resetop == 0x9c  //stz $nnnn (stz $4200)
+  || resetop == 0x4c  //jmp $nnnn
+  || resetop == 0x5c  //jml $nnnnnn
+  ) score += 8;
+
+  //plausible opcodes
+  if(resetop == 0xc2  //rep #$nn
+  || resetop == 0xe2  //sep #$nn
+  || resetop == 0xad  //lda $nnnn
+  || resetop == 0xae  //ldx $nnnn
+  || resetop == 0xac  //ldy $nnnn
+  || resetop == 0xaf  //lda $nnnnnn
+  || resetop == 0xa9  //lda #$nn
+  || resetop == 0xa2  //ldx #$nn
+  || resetop == 0xa0  //ldy #$nn
+  || resetop == 0x20  //jsr $nnnn
+  || resetop == 0x22  //jsl $nnnnnn
+  ) score += 4;
+
+  //implausible opcodes
+  if(resetop == 0x40  //rti
+  || resetop == 0x60  //rts
+  || resetop == 0x6b  //rtl
+  || resetop == 0xcd  //cmp $nnnn
+  || resetop == 0xec  //cpx $nnnn
+  || resetop == 0xcc  //cpy $nnnn
+  ) score -= 4;
+
+  //least likely opcodes
+  if(resetop == 0x00  //brk #$nn
+  || resetop == 0x02  //cop #$nn
+  || resetop == 0xdb  //stp
+  || resetop == 0x42  //wdm
+  || resetop == 0xff  //sbc $nnnnnn,x
+  ) score -= 8;
+
+  //at times, both the header and reset vector's first opcode will match ...
+  //fallback and rely on info validity in these cases to determine more likely header.
+
+  //a valid checksum is the biggest indicator of a valid header.
+  if((checksum + complement) == 0xffff && (checksum != 0) && (complement != 0)) score += 4;
+
+  if(addr == 0x007fc0 && mapper == 0x20) score += 2;  //0x20 is usually LoROM
+  if(addr == 0x00ffc0 && mapper == 0x21) score += 2;  //0x21 is usually HiROM
+  if(addr == 0x007fc0 && mapper == 0x22) score += 2;  //0x22 is usually ExLoROM
+  if(addr == 0x40ffc0 && mapper == 0x25) score += 2;  //0x25 is usually ExHiROM
+
+  if(data[addr + Company] == 0x33) score += 2;        //0x33 indicates extended header
+  if(data[addr + RomType] < 0x08) score++;
+  if(data[addr + RomSize] < 0x10) score++;
+  if(data[addr + RamSize] < 0x08) score++;
+  if(data[addr + CartRegion] < 14) score++;
+
+  if(score < 0) score = 0;
+  return score;
+}
+
+unsigned XML::gameboy_ram_size(const uint8_t *data, unsigned size) const {
+  if(size < 512) return 0;
+  switch(data[0x0149]) {
+    case 0x00: return   0 * 1024;
+    case 0x01: return   8 * 1024;
+    case 0x02: return   8 * 1024;
+    case 0x03: return  32 * 1024;
+    case 0x04: return 128 * 1024;
+    case 0x05: return 128 * 1024;
+    default:   return 128 * 1024;
+  }
+}
+
+bool XML::gameboy_has_rtc(const uint8_t *data, unsigned size) const {
+  if(size < 512) return false;
+  if(data[0x0147] == 0x0f ||data[0x0147] == 0x10) return true;
+  return false;
+}

snesreader/xml.hpp

@@ -0,0 +1,103 @@
+class XML {
+public:
+  void generate(nall::string &xml, const uint8_t *data, unsigned size);
+
+private:
+  void read_header(const uint8_t *data, unsigned size);
+  unsigned find_header(const uint8_t *data, unsigned size) const;
+  unsigned score_header(const uint8_t *data, unsigned size, unsigned addr) const;
+
+  unsigned gameboy_ram_size(const uint8_t *data, unsigned size) const;
+  bool gameboy_has_rtc(const uint8_t *data, unsigned size) const;
+
+  enum HeaderField {
+    CartName    = 0x00,
+    Mapper      = 0x15,
+    RomType     = 0x16,
+    RomSize     = 0x17,
+    RamSize     = 0x18,
+    CartRegion  = 0x19,
+    Company     = 0x1a,
+    Version     = 0x1b,
+    Complement  = 0x1c,  //inverse checksum
+    Checksum    = 0x1e,
+    ResetVector = 0x3c,
+  };
+
+  enum Mode {
+    ModeNormal,
+    ModeBsxSlotted,
+    ModeBsx,
+    ModeSufamiTurbo,
+    ModeSuperGameBoy,
+  };
+
+  enum Type {
+    TypeNormal,
+    TypeBsxSlotted,
+    TypeBsxBios,
+    TypeBsx,
+    TypeSufamiTurboBios,
+    TypeSufamiTurbo,
+    TypeSuperGameBoy1Bios,
+    TypeSuperGameBoy2Bios,
+    TypeGameBoy,
+    TypeUnknown,
+  };
+
+  enum Region {
+    NTSC,
+    PAL,
+  };
+
+  enum MemoryMapper {
+    LoROM,
+    HiROM,
+    ExLoROM,
+    ExHiROM,
+    SuperFXROM,
+    SA1ROM,
+    SPC7110ROM,
+    BSCLoROM,
+    BSCHiROM,
+    BSXROM,
+    STROM,
+  };
+
+  enum DSP1MemoryMapper {
+    DSP1Unmapped,
+    DSP1LoROM1MB,
+    DSP1LoROM2MB,
+    DSP1HiROM,
+  };
+
+  bool loaded;        //is a base cartridge inserted?
+  unsigned crc32;     //crc32 of all cartridges (base+slot(s))
+  unsigned rom_size;
+  unsigned ram_size;
+
+  Mode mode;
+  Type type;
+  Region region;
+  MemoryMapper mapper;
+  DSP1MemoryMapper dsp1_mapper;
+
+  bool has_bsx_slot;
+  bool has_superfx;
+  bool has_sa1;
+  bool has_srtc;
+  bool has_sdd1;
+  bool has_spc7110;
+  bool has_spc7110rtc;
+  bool has_cx4;
+  bool has_dsp1;
+  bool has_dsp2;
+  bool has_dsp3;
+  bool has_dsp4;
+  bool has_obc1;
+  bool has_st010;
+  bool has_st011;
+  bool has_st018;
+};
+
+extern XML xml;

src/Makefile

@@ -8,8 +8,8 @@ include lib/nall/qt/Makefile
 ### compiler ###
 ################
 
-c     := $(compiler)
-cpp   := $(subst cc,++,$(compiler))
+c     := $(compiler) --std=gnu99
+cpp   := $(subst cc,++,$(compiler)) -std=gnu++0x
 flags := -O3 -fomit-frame-pointer -Ilib
 link  :=
 
@@ -25,7 +25,7 @@ link  :=
 ################
 
 ifeq ($(platform),x)
-  link += -s
+  link += -s -ldl -lX11 -lXext
 
   ruby := video.glx video.xv video.qtraster video.sdl
   ruby += audio.alsa audio.openal audio.oss audio.pulseaudio audio.pulseaudiosimple audio.ao
@@ -70,7 +70,8 @@ link += $(if $(findstring video.xv,$(ruby)),-lXv)
 link += $(if $(findstring audio.alsa,$(ruby)),-lasound)
 link += $(if $(findstring audio.ao,$(ruby)),-lao)
 link += $(if $(findstring audio.directsound,$(ruby)),-ldsound)
-link += $(if $(findstring audio.pulseaudio,$(ruby)),-lpulse-simple)
+link += $(if $(findstring audio.pulseaudio,$(ruby)),-lpulse)
+link += $(if $(findstring audio.pulseaudiosimple,$(ruby)),-lpulse-simple)
 link += $(if $(findstring input.directinput,$(ruby)),-ldinput8 -ldxguid)
 link += $(if $(findstring input.rawinput,$(ruby)),-ldinput8 -ldxguid)
 
@@ -82,8 +83,8 @@ objects := libco ruby
 objects += system cartridge cheat
 objects += memory smemory cpu cpucore scpu smp smpcore ssmp dsp sdsp ppu bppu
 objects += supergameboy superfx sa1
-objects += bsx srtc sdd1 spc7110 cx4 dsp1 dsp2 dsp3 dsp4 obc1 st010 st011 st018
-objects += msu
+objects += bsx srtc sdd1 spc7110 cx4 dsp1 dsp2 dsp3 dsp4 obc1 st0010 st0011 st0018
+objects += msu1
 
 ######################
 ### implicit rules ###
@@ -183,10 +184,10 @@ obj/dsp2.o        : chip/dsp2/dsp2.cpp chip/dsp2/*
 obj/dsp3.o        : chip/dsp3/dsp3.cpp chip/dsp3/*
 obj/dsp4.o        : chip/dsp4/dsp4.cpp chip/dsp4/*
 obj/obc1.o        : chip/obc1/obc1.cpp chip/obc1/*
-obj/st010.o       : chip/st010/st010.cpp chip/st010/*
-obj/st011.o       : chip/st011/st011.cpp chip/st011/*
-obj/st018.o       : chip/st018/st018.cpp chip/st018/*
-obj/msu.o         : chip/msu/msu.cpp chip/msu/*
+obj/st0010.o      : chip/st0010/st0010.cpp chip/st0010/*
+obj/st0011.o      : chip/st0011/st0011.cpp chip/st0011/*
+obj/st0018.o      : chip/st0018/st0018.cpp chip/st0018/*
+obj/msu1.o        : chip/msu1/msu1.cpp chip/msu1/*
 
 ###############
 ### targets ###

src/base.hpp

@@ -1,6 +1,6 @@
-static const char bsnesVersion[] = "060";
+static const char bsnesVersion[] = "062";
 static const char bsnesTitle[] = "bsnes";
-static const unsigned bsnesSerializerVersion = 4;
+static const unsigned bsnesSerializerVersion = 6;
 
 //S-DSP can be encapsulated into a state machine using #define magic
 //this avoids ~2.048m co_switch() calls per second (~5% speedup)
@@ -22,6 +22,7 @@ static const unsigned bsnesSerializerVersion = 4;
 #include <nall/dl.hpp>
 #include <nall/endian.hpp>
 #include <nall/file.hpp>
+#include <nall/foreach.hpp>
 #include <nall/function.hpp>
 #include <nall/moduloarray.hpp>
 #include <nall/platform.hpp>

src/cartridge/cartridge.cpp

@@ -5,8 +5,7 @@
 #define CARTRIDGE_CPP
 namespace SNES {
 
-#include "header.cpp"
-#include "gameboyheader.cpp"
+#include "xml.cpp"
 #include "serialization.cpp"
 
 namespace memory {
@@ -19,9 +18,32 @@ namespace memory {
 
 Cartridge cartridge;
 
-void Cartridge::load(Mode cartridge_mode) {
+void Cartridge::load(Mode cartridge_mode, const lstring &xml_list) {
+  spc7110_data_rom_offset = 0x100000;
+  supergameboy_version = SuperGameBoyVersion::Version1;
+  supergameboy_ram_size = 0;
+  supergameboy_rtc_size = 0;
+
+  has_bsx_slot   = false;
+  has_superfx    = false;
+  has_sa1        = false;
+  has_srtc       = false;
+  has_sdd1       = false;
+  has_spc7110    = false;
+  has_spc7110rtc = false;
+  has_cx4        = false;
+  has_dsp1       = false;
+  has_dsp2       = false;
+  has_dsp3       = false;
+  has_dsp4       = false;
+  has_obc1       = false;
+  has_st0010     = false;
+  has_st0011     = false;
+  has_st0018     = false;
+  has_msu1       = false;
+
   mode = cartridge_mode;
-  read_header(memory::cartrom.data(), memory::cartrom.size());
+  parse_xml(xml_list);
 
   if(ram_size > 0) {
     memory::cartram.map(allocate<uint8_t>(ram_size, 0xff), ram_size);
@@ -31,23 +53,20 @@ void Cartridge::load(Mode cartridge_mode) {
     memory::cartrtc.map(allocate<uint8_t>(20, 0xff), 20);
   }
 
-  if(mode == ModeBsx) {
+  if(mode == Mode::Bsx) {
     memory::bsxram.map (allocate<uint8_t>( 32 * 1024, 0xff),  32 * 1024);
     memory::bsxpram.map(allocate<uint8_t>(512 * 1024, 0xff), 512 * 1024);
   }
 
-  if(mode == ModeSufamiTurbo) {
+  if(mode == Mode::SufamiTurbo) {
     if(memory::stArom.data()) memory::stAram.map(allocate<uint8_t>(128 * 1024, 0xff), 128 * 1024);
     if(memory::stBrom.data()) memory::stBram.map(allocate<uint8_t>(128 * 1024, 0xff), 128 * 1024);
   }
 
-  if(mode == ModeSuperGameBoy) {
+  if(mode == Mode::SuperGameBoy) {
     if(memory::gbrom.data()) {
-      unsigned ram_size = gameboy_ram_size();
-      unsigned rtc_size = gameboy_rtc_size();
-
-      if(ram_size) memory::gbram.map(allocate<uint8_t>(ram_size, 0xff), ram_size);
-      if(rtc_size) memory::gbrtc.map(allocate<uint8_t>(rtc_size, 0x00), rtc_size);
+      if(supergameboy_ram_size) memory::gbram.map(allocate<uint8_t>(supergameboy_ram_size, 0xff), supergameboy_ram_size);
+      if(supergameboy_rtc_size) memory::gbrtc.map(allocate<uint8_t>(supergameboy_rtc_size, 0x00), supergameboy_rtc_size);
     }
   }
 
@@ -65,21 +84,13 @@ void Cartridge::load(Mode cartridge_mode) {
   memory::gbram.write_protect(false);
   memory::gbrtc.write_protect(false);
 
-  unsigned checksum = ~0;
-  for(unsigned n = 0; n < memory::cartrom.size(); n++) checksum = crc32_adjust(checksum, memory::cartrom[n]);
-  if(memory::bsxflash.size() != 0 && memory::bsxflash.size() != ~0)
-  for(unsigned n = 0; n < memory::bsxflash.size(); n++) checksum = crc32_adjust(checksum, memory::bsxflash[n]);
-  if(memory::stArom.size() != 0 && memory::stArom.size() != ~0)
-  for(unsigned n = 0; n < memory::stArom.size(); n++) checksum = crc32_adjust(checksum, memory::stArom[n]);
-  if(memory::stBrom.size() != 0 && memory::stBrom.size() != ~0)
-  for(unsigned n = 0; n < memory::stBrom.size(); n++) checksum = crc32_adjust(checksum, memory::stBrom[n]);
-  if(memory::gbrom.size() != 0 && memory::gbrom.size() != ~0)
-  for(unsigned n = 0; n < memory::gbrom.size(); n++) checksum = crc32_adjust(checksum, memory::gbrom[n]);
+  unsigned checksum = ~0;                                           foreach(n, memory::cartrom ) checksum = crc32_adjust(checksum, n);
+  if(memory::bsxflash.size() != 0 && memory::bsxflash.size() != ~0) foreach(n, memory::bsxflash) checksum = crc32_adjust(checksum, n);
+  if(memory::stArom.size()   != 0 && memory::stArom.size()   != ~0) foreach(n, memory::stArom  ) checksum = crc32_adjust(checksum, n);
+  if(memory::stBrom.size()   != 0 && memory::stBrom.size()   != ~0) foreach(n, memory::stBrom  ) checksum = crc32_adjust(checksum, n);
+  if(memory::gbrom.size()    != 0 && memory::gbrom.size()    != ~0) foreach(n, memory::gbrom   ) checksum = crc32_adjust(checksum, n);
   crc32 = ~checksum;
 
-#if 0
-  fprintf(stdout, "crc32  = %.8x\n", (unsigned)crc32);
-
   sha256_ctx sha;
   uint8_t shahash[32];
   sha256_init(&sha);
@@ -87,10 +98,9 @@ void Cartridge::load(Mode cartridge_mode) {
   sha256_final(&sha);
   sha256_hash(&sha, shahash);
 
-  fprintf(stdout, "sha256 = ");
-  for(unsigned i = 0; i < 32; i++) fprintf(stdout, "%.2x", shahash[i]);
-  fprintf(stdout, "\n");
-#endif
+  string hash;
+  foreach(n, shahash) hash << strhex<2>(n);
+  sha256 = hash;
 
   bus.load_cart();
   system.serialize_init();
@@ -117,10 +127,6 @@ void Cartridge::unload() {
   loaded = false;
 }
 
-bool Cartridge::has_msu() const {
-  return msu.exists();
-}
-
 Cartridge::Cartridge() {
   loaded = false;
   unload();

src/cartridge/cartridge.hpp

@@ -1,60 +1,34 @@
 class Cartridge : property<Cartridge> {
 public:
-  enum Mode {
-    ModeNormal,
-    ModeBsxSlotted,
-    ModeBsx,
-    ModeSufamiTurbo,
-    ModeSuperGameBoy,
+  enum class Mode : unsigned {
+    Normal,
+    BsxSlotted,
+    Bsx,
+    SufamiTurbo,
+    SuperGameBoy,
   };
 
-  enum Type {
-    TypeNormal,
-    TypeBsxSlotted,
-    TypeBsxBios,
-    TypeBsx,
-    TypeSufamiTurboBios,
-    TypeSufamiTurbo,
-    TypeSuperGameBoy1Bios,
-    TypeSuperGameBoy2Bios,
-    TypeGameBoy,
-    TypeUnknown,
-  };
-
-  enum Region {
+  enum class Region : unsigned {
     NTSC,
     PAL,
   };
 
-  enum MemoryMapper {
-    LoROM,
-    HiROM,
-    ExLoROM,
-    ExHiROM,
-    SuperFXROM,
-    SA1ROM,
-    SPC7110ROM,
-    BSCLoROM,
-    BSCHiROM,
-    BSXROM,
-    STROM,
+  enum class SuperGameBoyVersion : unsigned {
+    Version1,
+    Version2,
   };
 
-  enum DSP1MemoryMapper {
-    DSP1Unmapped,
-    DSP1LoROM1MB,
-    DSP1LoROM2MB,
-    DSP1HiROM,
-  };
-
-  readonly<bool> loaded;     //is a base cartridge inserted?
-  readonly<unsigned> crc32;  //crc32 of all cartridges (base+slot(s))
+  readonly<bool> loaded;
+  readonly<unsigned> crc32;
+  readonly<string> sha256;
 
   readonly<Mode> mode;
-  readonly<Type> type;
   readonly<Region> region;
-  readonly<MemoryMapper> mapper;
-  readonly<DSP1MemoryMapper> dsp1_mapper;
+  readonly<unsigned> ram_size;
+  readonly<unsigned> spc7110_data_rom_offset;
+  readonly<SuperGameBoyVersion> supergameboy_version;
+  readonly<unsigned> supergameboy_ram_size;
+  readonly<unsigned> supergameboy_rtc_size;
 
   readonly<bool> has_bsx_slot;
   readonly<bool> has_superfx;
@@ -69,12 +43,29 @@ public:
   readonly<bool> has_dsp3;
   readonly<bool> has_dsp4;
   readonly<bool> has_obc1;
-  readonly<bool> has_st010;
-  readonly<bool> has_st011;
-  readonly<bool> has_st018;
-  bool has_msu() const;
+  readonly<bool> has_st0010;
+  readonly<bool> has_st0011;
+  readonly<bool> has_st0018;
+  readonly<bool> has_msu1;
 
-  void load(Mode);
+  struct Mapping {
+    Memory *memory;
+    MMIO *mmio;
+    Bus::MapMode mode;
+    unsigned banklo;
+    unsigned bankhi;
+    unsigned addrlo;
+    unsigned addrhi;
+    unsigned offset;
+    unsigned size;
+
+    Mapping();
+    Mapping(Memory&);
+    Mapping(MMIO&);
+  };
+  array<Mapping> mapping;
+
+  void load(Mode, const lstring&);
   void unload();
 
   void serialize(serializer&);
@@ -82,27 +73,31 @@ public:
   ~Cartridge();
 
 private:
-  enum HeaderField {
-    CartName    = 0x00,
-    Mapper      = 0x15,
-    RomType     = 0x16,
-    RomSize     = 0x17,
-    RamSize     = 0x18,
-    CartRegion  = 0x19,
-    Company     = 0x1a,
-    Version     = 0x1b,
-    Complement  = 0x1c,  //inverse checksum
-    Checksum    = 0x1e,
-    ResetVector = 0x3c,
-  };
+  void parse_xml(const lstring&);
+  void parse_xml_cartridge(const char*);
+  void parse_xml_bsx(const char*);
+  void parse_xml_sufami_turbo(const char*, bool);
+  void parse_xml_gameboy(const char*);
 
-  unsigned ram_size;
-  void read_header(const uint8_t *data, unsigned size);
-  unsigned find_header(const uint8_t *data, unsigned size) const;
-  unsigned score_header(const uint8_t *data, unsigned size, unsigned addr) const;
+  void xml_parse_rom(xml_element*);
+  void xml_parse_ram(xml_element*);
+  void xml_parse_superfx(xml_element*);
+  void xml_parse_sa1(xml_element*);
+  void xml_parse_bsx(xml_element*);
+  void xml_parse_sufamiturbo(xml_element*);
+  void xml_parse_supergameboy(xml_element*);
+  void xml_parse_srtc(xml_element*);
+  void xml_parse_sdd1(xml_element*);
+  void xml_parse_spc7110(xml_element*);
+  void xml_parse_cx4(xml_element*);
+  void xml_parse_necdsp(xml_element*);
+  void xml_parse_obc1(xml_element*);
+  void xml_parse_setadsp(xml_element*);
+  void xml_parse_setarisc(xml_element*);
+  void xml_parse_msu1(xml_element*);
 
-  unsigned gameboy_ram_size() const;
-  unsigned gameboy_rtc_size() const;
+  void xml_parse_address(Mapping&, const string&);
+  void xml_parse_mode(Mapping&, const string&);
 };
 
 namespace memory {

src/cartridge/gameboyheader.cpp

@@ -1,22 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-unsigned Cartridge::gameboy_ram_size() const {
-  if(memory::gbrom.size() < 512) return 0;
-  switch(memory::gbrom[0x0149]) {
-    case 0x00: return   0 * 1024;
-    case 0x01: return   8 * 1024;
-    case 0x02: return   8 * 1024;
-    case 0x03: return  32 * 1024;
-    case 0x04: return 128 * 1024;
-    case 0x05: return 128 * 1024;
-    default:   return 128 * 1024;
-  }
-}
-
-unsigned Cartridge::gameboy_rtc_size() const {
-  if(memory::gbrom.size() < 512) return 0;
-  if(memory::gbrom[0x0147] == 0x0f || memory::gbrom[0x0147] == 0x10) return 4;
-  return 0;
-}
-
-#endif

src/cartridge/header.cpp

@@ -1,321 +0,0 @@
-#ifdef CARTRIDGE_CPP
-
-void Cartridge::read_header(const uint8_t *data, unsigned size) {
-  type        = TypeUnknown;
-  mapper      = LoROM;
-  dsp1_mapper = DSP1Unmapped;
-  region      = NTSC;
-  ram_size    = 0;
-
-  has_bsx_slot   = false;
-  has_superfx    = false;
-  has_sa1        = false;
-  has_srtc       = false;
-  has_sdd1       = false;
-  has_spc7110    = false;
-  has_spc7110rtc = false;
-  has_cx4        = false;
-  has_dsp1       = false;
-  has_dsp2       = false;
-  has_dsp3       = false;
-  has_dsp4       = false;
-  has_obc1       = false;
-  has_st010      = false;
-  has_st011      = false;
-  has_st018      = false;
-
-  //=====================
-  //detect Game Boy carts
-  //=====================
-
-  if(size >= 0x0140) {
-    if(data[0x0104] == 0xce && data[0x0105] == 0xed && data[0x0106] == 0x66 && data[0x0107] == 0x66
-    && data[0x0108] == 0xcc && data[0x0109] == 0x0d && data[0x010a] == 0x00 && data[0x010b] == 0x0b) {
-      type = TypeGameBoy;
-      return;
-    }
-  }
-
-  const unsigned index = find_header(data, size);
-  const uint8 mapperid = data[index + Mapper];
-  const uint8 rom_type = data[index + RomType];
-  const uint8 rom_size = data[index + RomSize];
-  const uint8 company  = data[index + Company];
-  const uint8 regionid = data[index + CartRegion] & 0x7f;
-
-  ram_size = 1024 << (data[index + RamSize] & 7);
-  if(ram_size == 1024) ram_size = 0;  //no RAM present
-
-  //0, 1, 13 = NTSC; 2 - 12 = PAL
-  region = (regionid <= 1 || regionid >= 13) ? NTSC : PAL;
-
-  //=======================
-  //detect BS-X flash carts
-  //=======================
-
-  if(data[index + 0x13] == 0x00 || data[index + 0x13] == 0xff) {
-    if(data[index + 0x14] == 0x00) {
-      const uint8_t n15 = data[index + 0x15];
-      if(n15 == 0x00 || n15 == 0x80 || n15 == 0x84 || n15 == 0x9c || n15 == 0xbc || n15 == 0xfc) {
-        if(data[index + 0x1a] == 0x33 || data[index + 0x1a] == 0xff) {
-          type = TypeBsx;
-          mapper = BSXROM;
-          region = NTSC;  //BS-X only released in Japan
-          return;
-        }
-      }
-    }
-  }
-
-  //=========================
-  //detect Sufami Turbo carts
-  //=========================
-
-  if(!memcmp(data, "BANDAI SFC-ADX", 14)) {
-    if(!memcmp(data + 16, "SFC-ADX BACKUP", 14)) {
-      type = TypeSufamiTurboBios;
-    } else {
-      type = TypeSufamiTurbo;
-    }
-    mapper = STROM;
-    region = NTSC;  //Sufami Turbo only released in Japan
-    return;         //RAM size handled outside this routine
-  }
-
-  //==========================
-  //detect Super Game Boy BIOS
-  //==========================
-
-  if(!memcmp(data + index, "Super GAMEBOY2", 14)) {
-    type = TypeSuperGameBoy2Bios;
-    return;
-  }
-
-  if(!memcmp(data + index, "Super GAMEBOY", 13)) {
-    type = TypeSuperGameBoy1Bios;
-    return;
-  }
-
-  //=====================
-  //detect standard carts
-  //=====================
-
-  //detect presence of BS-X flash cartridge connector (reads extended header information)
-  if(data[index - 14] == 'Z') {
-    if(data[index - 11] == 'J') {
-      uint8 n13 = data[index - 13];
-      if((n13 >= 'A' && n13 <= 'Z') || (n13 >= '0' && n13 <= '9')) {
-        if(company == 0x33 || (data[index - 10] == 0x00 && data[index - 4] == 0x00)) {
-          has_bsx_slot = true;
-        }
-      }
-    }
-  }
-
-  if(has_bsx_slot) {
-    if(!memcmp(data + index, "Satellaview BS-X     ", 21)) {
-      //BS-X base cart
-      type = TypeBsxBios;
-      mapper = BSXROM;
-      region = NTSC;  //BS-X only released in Japan
-      return;         //RAM size handled internally by load_cart_bsx() -> BSXCart class
-    } else {
-      type = TypeBsxSlotted;
-      mapper = (index == 0x7fc0 ? BSCLoROM : BSCHiROM);
-      region = NTSC;  //BS-X slotted cartridges only released in Japan
-    }
-  } else {
-    //standard cart
-    type = TypeNormal;
-
-    if(index == 0x7fc0 && size >= 0x401000) {
-      mapper = ExLoROM;
-    } else if(index == 0x7fc0 && mapperid == 0x32) {
-      mapper = ExLoROM;
-    } else if(index == 0x7fc0) {
-      mapper = LoROM;
-    } else if(index == 0xffc0) {
-      mapper = HiROM;
-    } else {  //index == 0x40ffc0
-      mapper = ExHiROM;
-    }
-  }
-
-  if(mapperid == 0x20 && (rom_type == 0x13 || rom_type == 0x14 || rom_type == 0x15 || rom_type == 0x1a)) {
-    has_superfx = true;
-    mapper = SuperFXROM;
-    ram_size = 1024 << (data[index - 3] & 7);
-    if(ram_size == 1024) ram_size = 0;
-  }
-
-  if(mapperid == 0x23 && (rom_type == 0x32 || rom_type == 0x34 || rom_type == 0x35)) {
-    has_sa1 = true;
-    mapper = SA1ROM;
-  }
-
-  if(mapperid == 0x35 && rom_type == 0x55) {
-    has_srtc = true;
-  }
-
-  if(mapperid == 0x32 && (rom_type == 0x43 || rom_type == 0x45)) {
-    has_sdd1 = true;
-  }
-
-  if(mapperid == 0x3a && (rom_type == 0xf5 || rom_type == 0xf9)) {
-    has_spc7110 = true;
-    has_spc7110rtc = (rom_type == 0xf9);
-    mapper = SPC7110ROM;
-  }
-
-  if(mapperid == 0x20 && rom_type == 0xf3) {
-    has_cx4 = true;
-  }
-
-  if((mapperid == 0x20 || mapperid == 0x21) && rom_type == 0x03) {
-    has_dsp1 = true;
-  }
-
-  if(mapperid == 0x30 && rom_type == 0x05 && company != 0xb2) {
-    has_dsp1 = true;
-  }
-
-  if(mapperid == 0x31 && (rom_type == 0x03 || rom_type == 0x05)) {
-    has_dsp1 = true;
-  }
-
-  if(has_dsp1 == true) {
-    if((mapperid & 0x2f) == 0x20 && size <= 0x100000) {
-      dsp1_mapper = DSP1LoROM1MB;
-    } else if((mapperid & 0x2f) == 0x20) {
-      dsp1_mapper = DSP1LoROM2MB;
-    } else if((mapperid & 0x2f) == 0x21) {
-      dsp1_mapper = DSP1HiROM;
-    }
-  }
-
-  if(mapperid == 0x20 && rom_type == 0x05) {
-    has_dsp2 = true;
-  }
-
-  if(mapperid == 0x30 && rom_type == 0x05 && company == 0xb2) {
-    has_dsp3 = true;
-  }
-
-  if(mapperid == 0x30 && rom_type == 0x03) {
-    has_dsp4 = true;
-  }
-
-  if(mapperid == 0x30 && rom_type == 0x25) {
-    has_obc1 = true;
-  }
-
-  if(mapperid == 0x30 && rom_type == 0xf6 && rom_size >= 10) {
-    has_st010 = true;
-  }
-
-  if(mapperid == 0x30 && rom_type == 0xf6 && rom_size < 10) {
-    has_st011 = true;
-  }
-
-  if(mapperid == 0x30 && rom_type == 0xf5) {
-    has_st018 = true;
-  }
-}
-
-unsigned Cartridge::find_header(const uint8_t *data, unsigned size) const {
-  unsigned score_lo = score_header(data, size, 0x007fc0);
-  unsigned score_hi = score_header(data, size, 0x00ffc0);
-  unsigned score_ex = score_header(data, size, 0x40ffc0);
-  if(score_ex) score_ex += 4;  //favor ExHiROM on images > 32mbits
-
-  if(score_lo >= score_hi && score_lo >= score_ex) {
-    return 0x007fc0;
-  } else if(score_hi >= score_ex) {
-    return 0x00ffc0;
-  } else {
-    return 0x40ffc0;
-  }
-}
-
-unsigned Cartridge::score_header(const uint8_t *data, unsigned size, unsigned addr) const {
-  if(size < addr + 64) return 0;  //image too small to contain header at this location?
-  int score = 0;
-
-  uint16 resetvector = data[addr + ResetVector] | (data[addr + ResetVector + 1] << 8);
-  uint16 checksum    = data[addr + Checksum   ] | (data[addr + Checksum    + 1] << 8);
-  uint16 complement  = data[addr + Complement ] | (data[addr + Complement  + 1] << 8);
-
-  uint8 resetop = data[(addr & ~0x7fff) | (resetvector & 0x7fff)];  //first opcode executed upon reset
-  uint8 mapper  = data[addr + Mapper] & ~0x10;                      //mask off irrelevent FastROM-capable bit
-
-  //$00:[000-7fff] contains uninitialized RAM and MMIO.
-  //reset vector must point to ROM at $00:[8000-ffff] to be considered valid.
-  if(resetvector < 0x8000) return 0;
-
-  //some images duplicate the header in multiple locations, and others have completely
-  //invalid header information that cannot be relied upon.
-  //below code will analyze the first opcode executed at the specified reset vector to
-  //determine the probability that this is the correct header.
-
-  //most likely opcodes
-  if(resetop == 0x78  //sei
-  || resetop == 0x18  //clc (clc; xce)
-  || resetop == 0x38  //sec (sec; xce)
-  || resetop == 0x9c  //stz $nnnn (stz $4200)
-  || resetop == 0x4c  //jmp $nnnn
-  || resetop == 0x5c  //jml $nnnnnn
-  ) score += 8;
-
-  //plausible opcodes
-  if(resetop == 0xc2  //rep #$nn
-  || resetop == 0xe2  //sep #$nn
-  || resetop == 0xad  //lda $nnnn
-  || resetop == 0xae  //ldx $nnnn
-  || resetop == 0xac  //ldy $nnnn
-  || resetop == 0xaf  //lda $nnnnnn
-  || resetop == 0xa9  //lda #$nn
-  || resetop == 0xa2  //ldx #$nn
-  || resetop == 0xa0  //ldy #$nn
-  || resetop == 0x20  //jsr $nnnn
-  || resetop == 0x22  //jsl $nnnnnn
-  ) score += 4;
-
-  //implausible opcodes
-  if(resetop == 0x40  //rti
-  || resetop == 0x60  //rts
-  || resetop == 0x6b  //rtl
-  || resetop == 0xcd  //cmp $nnnn
-  || resetop == 0xec  //cpx $nnnn
-  || resetop == 0xcc  //cpy $nnnn
-  ) score -= 4;
-
-  //least likely opcodes
-  if(resetop == 0x00  //brk #$nn
-  || resetop == 0x02  //cop #$nn
-  || resetop == 0xdb  //stp
-  || resetop == 0x42  //wdm
-  || resetop == 0xff  //sbc $nnnnnn,x
-  ) score -= 8;
-
-  //at times, both the header and reset vector's first opcode will match ...
-  //fallback and rely on info validity in these cases to determine more likely header.
-
-  //a valid checksum is the biggest indicator of a valid header.
-  if((checksum + complement) == 0xffff && (checksum != 0) && (complement != 0)) score += 4;
-
-  if(addr == 0x007fc0 && mapper == 0x20) score += 2;  //0x20 is usually LoROM
-  if(addr == 0x00ffc0 && mapper == 0x21) score += 2;  //0x21 is usually HiROM
-  if(addr == 0x007fc0 && mapper == 0x22) score += 2;  //0x22 is usually ExLoROM
-  if(addr == 0x40ffc0 && mapper == 0x25) score += 2;  //0x25 is usually ExHiROM
-
-  if(data[addr + Company] == 0x33) score += 2;        //0x33 indicates extended header
-  if(data[addr + RomType] < 0x08) score++;
-  if(data[addr + RomSize] < 0x10) score++;
-  if(data[addr + RamSize] < 0x08) score++;
-  if(data[addr + CartRegion] < 14) score++;
-
-  if(score < 0) score = 0;
-  return score;
-}
-
-#endif

src/cartridge/xml.cpp

@@ -0,0 +1,656 @@
+#ifdef CARTRIDGE_CPP
+
+void Cartridge::parse_xml(const lstring &list) {
+  mapping.reset();
+  parse_xml_cartridge(list[0]);
+
+  if(mode == Mode::BsxSlotted) {
+    parse_xml_bsx(list[1]);
+  } else if(mode == Mode::Bsx) {
+    parse_xml_bsx(list[1]);
+  } else if(mode == Mode::SufamiTurbo) {
+    parse_xml_sufami_turbo(list[1], 0);
+    parse_xml_sufami_turbo(list[2], 1);
+  } else if(mode == Mode::SuperGameBoy) {
+    parse_xml_gameboy(list[1]);
+  }
+}
+
+void Cartridge::parse_xml_cartridge(const char *data) {
+  xml_element *document = xml_parse(data);
+  if(document == 0) return;
+
+  foreach(head, document->element) {
+    if(head->name == "cartridge") {
+      foreach(attr, head->attribute) {
+        if(attr->name == "region") {
+          if(attr->content == "NTSC") region = Region::NTSC;
+          if(attr->content == "PAL") region = Region::PAL;
+        }
+      }
+
+      foreach(node, head->element) {
+        if(node->name == "rom") xml_parse_rom(node);
+        if(node->name == "ram") xml_parse_ram(node);
+        if(node->name == "superfx") xml_parse_superfx(node);
+        if(node->name == "sa1") xml_parse_sa1(node);
+        if(node->name == "bsx") xml_parse_bsx(node);
+        if(node->name == "sufamiturbo") xml_parse_sufamiturbo(node);
+        if(node->name == "supergameboy") xml_parse_supergameboy(node);
+        if(node->name == "srtc") xml_parse_srtc(node);
+        if(node->name == "sdd1") xml_parse_sdd1(node);
+        if(node->name == "spc7110") xml_parse_spc7110(node);
+        if(node->name == "cx4") xml_parse_cx4(node);
+        if(node->name == "necdsp") xml_parse_necdsp(node);
+        if(node->name == "obc1") xml_parse_obc1(node);
+        if(node->name == "setadsp") xml_parse_setadsp(node);
+        if(node->name == "setarisc") xml_parse_setarisc(node);
+        if(node->name == "msu1") xml_parse_msu1(node);
+      }
+    }
+  }
+}
+
+void Cartridge::parse_xml_bsx(const char *data) {
+}
+
+void Cartridge::parse_xml_sufami_turbo(const char *data, bool slot) {
+}
+
+void Cartridge::parse_xml_gameboy(const char *data) {
+  xml_element *document = xml_parse(data);
+  if(document == 0) return;
+
+  foreach(head, document->element) {
+    if(head->name == "cartridge") {
+      foreach(attr, head->attribute) {
+        if(attr->name == "rtc") {
+          supergameboy_rtc_size = (attr->content == "true") ? 4 : 0;
+        }
+      }
+
+      foreach(leaf, head->element) {
+        if(leaf->name == "ram") {
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "size") {
+              supergameboy_ram_size = strhex(attr->content);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  delete document;
+}
+
+void Cartridge::xml_parse_rom(xml_element *root) {
+  foreach(leaf, root->element) {
+    if(leaf->name == "map") {
+      Mapping m(memory::cartrom);
+      foreach(attr, leaf->attribute) {
+        if(attr->name == "address") xml_parse_address(m, attr->content);
+        if(attr->name == "mode") xml_parse_mode(m, attr->content);
+        if(attr->name == "offset") m.offset = strhex(attr->content);
+        if(attr->name == "size") m.size = strhex(attr->content);
+      }
+      mapping.add(m);
+    }
+  }
+}
+
+void Cartridge::xml_parse_ram(xml_element *root) {
+  foreach(attr, root->attribute) {
+    if(attr->name == "size") ram_size = strhex(attr->content);
+  }
+
+  foreach(leaf, root->element) {
+    if(leaf->name == "map") {
+      Mapping m(memory::cartram);
+      foreach(attr, leaf->attribute) {
+        if(attr->name == "address") xml_parse_address(m, attr->content);
+        if(attr->name == "mode") xml_parse_mode(m, attr->content);
+        if(attr->name == "offset") m.offset = strhex(attr->content);
+        if(attr->name == "size") m.size = strhex(attr->content);
+      }
+      mapping.add(m);
+    }
+  }
+}
+
+void Cartridge::xml_parse_superfx(xml_element *root) {
+  has_superfx = true;
+
+  foreach(node, root->element) {
+    if(node->name == "rom") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(memory::fxrom);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+            if(attr->name == "mode") xml_parse_mode(m, attr->content);
+            if(attr->name == "offset") m.offset = strhex(attr->content);
+            if(attr->name == "size") m.size = strhex(attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "ram") {
+      foreach(attr, node->attribute) {
+        if(attr->name == "size") ram_size = strhex(attr->content);
+      }
+
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(memory::fxram);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+            if(attr->name == "mode") xml_parse_mode(m, attr->content);
+            if(attr->name == "offset") m.offset = strhex(attr->content);
+            if(attr->name == "size") m.size = strhex(attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(superfx);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_sa1(xml_element *root) {
+  has_sa1 = true;
+
+  foreach(node, root->element) {
+    if(node->name == "rom") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(memory::vsprom);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+            if(attr->name == "mode") xml_parse_mode(m, attr->content);
+            if(attr->name == "offset") m.offset = strhex(attr->content);
+            if(attr->name == "size") m.size = strhex(attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "iram") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(memory::cpuiram);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+            if(attr->name == "mode") xml_parse_mode(m, attr->content);
+            if(attr->name == "offset") m.offset = strhex(attr->content);
+            if(attr->name == "size") m.size = strhex(attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "bwram") {
+      foreach(attr, node->attribute) {
+        if(attr->name == "size") ram_size = strhex(attr->content);
+      }
+
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(memory::cc1bwram);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+            if(attr->name == "mode") xml_parse_mode(m, attr->content);
+            if(attr->name == "offset") m.offset = strhex(attr->content);
+            if(attr->name == "size") m.size = strhex(attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(sa1);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_bsx(xml_element *root) {
+  foreach(node, root->element) {
+    if(node->name == "slot") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(memory::bsxflash);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+            if(attr->name == "mode") xml_parse_mode(m, attr->content);
+            if(attr->name == "offset") m.offset = strhex(attr->content);
+            if(attr->name == "size") m.size = strhex(attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(bsxcart);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_sufamiturbo(xml_element *root) {
+  foreach(node, root->element) {
+    if(node->name == "slot") {
+      bool slotid = 0;
+      foreach(attr, node->attribute) {
+        if(attr->name == "id") {
+          if(attr->content == "A") slotid = 0;
+          if(attr->content == "B") slotid = 1;
+        }
+      }
+
+      foreach(slot, node->element) {
+        if(slot->name == "rom") {
+          foreach(leaf, slot->element) {
+            if(leaf->name == "map") {
+              Mapping m(slotid == 0 ? memory::stArom : memory::stBrom);
+              foreach(attr, leaf->attribute) {
+                if(attr->name == "address") xml_parse_address(m, attr->content);
+                if(attr->name == "mode") xml_parse_mode(m, attr->content);
+                if(attr->name == "offset") m.offset = strhex(attr->content);
+                if(attr->name == "size") m.size = strhex(attr->content);
+              }
+              if(m.memory->size() > 0) mapping.add(m);
+            }
+          }
+        } else if(slot->name == "ram") {
+          foreach(leaf, slot->element) {
+            if(leaf->name == "map") {
+              Mapping m(slotid == 0 ? memory::stAram : memory::stBram);
+              foreach(attr, leaf->attribute) {
+                if(attr->name == "address") xml_parse_address(m, attr->content);
+                if(attr->name == "mode") xml_parse_mode(m, attr->content);
+                if(attr->name == "offset") m.offset = strhex(attr->content);
+                if(attr->name == "size") m.size = strhex(attr->content);
+              }
+              if(m.memory->size() > 0) mapping.add(m);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_supergameboy(xml_element *root) {
+  foreach(attr, root->attribute) {
+    if(attr->name == "revision") {
+      if(attr->content == "1") supergameboy_version = SuperGameBoyVersion::Version1;
+      if(attr->content == "2") supergameboy_version = SuperGameBoyVersion::Version2;
+    }
+  }
+
+  foreach(node, root->element) {
+    if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m((Memory&)supergameboy);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_srtc(xml_element *root) {
+  has_srtc = true;
+
+  foreach(node, root->element) {
+    if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(srtc);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_sdd1(xml_element *root) {
+  has_sdd1 = true;
+
+  foreach(node, root->element) {
+    if(node->name == "mcu") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m((Memory&)sdd1);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m((MMIO&)sdd1);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_spc7110(xml_element *root) {
+  has_spc7110 = true;
+
+  foreach(node, root->element) {
+    if(node->name == "dcu") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(spc7110dcu);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "mcu") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(spc7110mcu);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+            if(attr->name == "offset") spc7110_data_rom_offset = strhex(attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(spc7110);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "ram") {
+      foreach(attr, node->attribute) {
+        if(attr->name == "size") ram_size = strhex(attr->content);
+      }
+
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(spc7110ram);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+            if(attr->name == "mode") xml_parse_mode(m, attr->content);
+            if(attr->name == "offset") m.offset = strhex(attr->content);
+            if(attr->name == "size") m.size = strhex(attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "rtc") {
+      has_spc7110rtc = true;
+
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(spc7110);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_cx4(xml_element *root) {
+  has_cx4 = true;
+
+  foreach(node, root->element) {
+    if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(cx4);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_necdsp(xml_element *root) {
+  unsigned program = 0;
+
+  foreach(attr, root->attribute) {
+    if(attr->name == "program") {
+      if(attr->content == "DSP-1" || attr->content == "DSP-1A" || attr->content == "DSP-1B") {
+        program = 1;
+        has_dsp1 = true;
+      } else if(attr->content == "DSP-2") {
+        program = 2;
+        has_dsp2 = true;
+      } else if(attr->content == "DSP-3") {
+        program = 3;
+        has_dsp3 = true;
+      } else if(attr->content == "DSP-4") {
+        program = 4;
+        has_dsp4 = true;
+      }
+    }
+  }
+
+  Memory *dr[5] = { 0, &dsp1dr, &dsp2, &dsp3, &dsp4 };
+  Memory *sr[5] = { 0, &dsp1sr, &dsp2, &dsp3, &dsp4 };
+
+  foreach(node, root->element) {
+    if(node->name == "dr" && dr[program]) {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(*dr[program]);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    } else if(node->name == "sr" && sr[program]) {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(*sr[program]);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_obc1(xml_element *root) {
+  has_obc1 = true;
+
+  foreach(node, root->element) {
+    if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(obc1);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_setadsp(xml_element *root) {
+  unsigned program = 0;
+
+  foreach(attr, root->attribute) {
+    if(attr->name == "program") {
+      if(attr->content == "ST-0010") {
+        program = 1;
+        has_st0010 = true;
+      } else if(attr->content == "ST-0011") {
+        program = 2;
+        has_st0011 = true;
+      }
+    }
+  }
+
+  Memory *map[3] = { 0, &st0010, 0 };
+
+  foreach(node, root->element) {
+    if(node->name == "mmio" && map[program]) {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(*map[program]);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_setarisc(xml_element *root) {
+  unsigned program = 0;
+
+  foreach(attr, root->attribute) {
+    if(attr->name == "program") {
+      if(attr->content == "ST-0018") {
+        program = 1;
+        has_st0018 = true;
+      }
+    }
+  }
+
+  MMIO *map[2] = { 0, &st0018 };
+
+  foreach(node, root->element) {
+    if(node->name == "mmio" && map[program]) {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(*map[program]);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_msu1(xml_element *root) {
+  has_msu1 = true;
+
+  foreach(node, root->element) {
+    if(node->name == "mmio") {
+      foreach(leaf, node->element) {
+        if(leaf->name == "map") {
+          Mapping m(msu1);
+          foreach(attr, leaf->attribute) {
+            if(attr->name == "address") xml_parse_address(m, attr->content);
+          }
+          mapping.add(m);
+        }
+      }
+    }
+  }
+}
+
+void Cartridge::xml_parse_address(Mapping &m, const string &data) {
+  lstring part;
+  part.split(":", data);
+  if(part.size() != 2) return;
+
+  lstring subpart;
+  subpart.split("-", part[0]);
+  if(subpart.size() == 1) {
+    m.banklo = strhex(subpart[0]);
+    m.bankhi = m.banklo;
+  } else if(subpart.size() == 2) {
+    m.banklo = strhex(subpart[0]);
+    m.bankhi = strhex(subpart[1]);
+  }
+
+  subpart.split("-", part[1]);
+  if(subpart.size() == 1) {
+    m.addrlo = strhex(subpart[0]);
+    m.addrhi = m.addrlo;
+  } else if(subpart.size() == 2) {
+    m.addrlo = strhex(subpart[0]);
+    m.addrhi = strhex(subpart[1]);
+  }
+}
+
+void Cartridge::xml_parse_mode(Mapping &m, const string& data) {
+       if(data == "direct") m.mode = Bus::MapMode::Direct;
+  else if(data == "linear") m.mode = Bus::MapMode::Linear;
+  else if(data == "shadow") m.mode = Bus::MapMode::Shadow;
+}
+
+Cartridge::Mapping::Mapping() {
+  memory = 0;
+  mmio = 0;
+  mode = Bus::MapMode::Direct;
+  banklo = bankhi = addrlo = addrhi = offset = size = 0;
+}
+
+Cartridge::Mapping::Mapping(Memory &memory_) {
+  memory = &memory_;
+  mmio = 0;
+  mode = Bus::MapMode::Direct;
+  banklo = bankhi = addrlo = addrhi = offset = size = 0;
+}
+
+Cartridge::Mapping::Mapping(MMIO &mmio_) {
+  memory = 0;
+  mmio = &mmio_;
+  mode = Bus::MapMode::Direct;
+  banklo = bankhi = addrlo = addrhi = offset = size = 0;
+}
+
+#endif

src/cheat/cheat.cpp

@@ -83,7 +83,7 @@ bool Cheat::decode(const char *s, unsigned &addr, uint8 &data, Type &type) {
     //validate input
     for(unsigned i = 0; i < 8; i++) if(!ischr(t[i])) return false;
 
-    type = ProActionReplay;
+    type = Type::ProActionReplay;
     unsigned r = strhex((const char*)t);
     addr = r >> 8;
     data = r & 0xff;
@@ -94,7 +94,7 @@ bool Cheat::decode(const char *s, unsigned &addr, uint8 &data, Type &type) {
     //validate input
     for(unsigned i = 0; i < 8; i++) if(!ischr(t[i])) return false;
 
-    type = GameGenie;
+    type = Type::GameGenie;
     strtr(t, "df4709156bc8a23e", "0123456789abcdef");
     unsigned r = strhex((const char*)t);
     //8421 8421 8421 8421 8421 8421
@@ -124,11 +124,10 @@ bool Cheat::decode(const char *s, unsigned &addr, uint8 &data, Type &type) {
 bool Cheat::encode(string &s, unsigned addr, uint8 data, Type type) {
   char t[16];
 
-  if(type == ProActionReplay) {
-    sprintf(t, "%.6x%.2x", addr, data);
-    s = t;
+  if(type == Type::ProActionReplay) {
+    s = sprint("$$", strhex<6>(addr), strhex<2>(data));
     return true;
-  } else if(type == GameGenie) {
+  } else if(type == Type::GameGenie) {
     unsigned r = addr;
     addr = (!!(r & 0x008000) << 23) | (!!(r & 0x004000) << 22)
          | (!!(r & 0x002000) << 21) | (!!(r & 0x001000) << 20)
@@ -142,9 +141,8 @@ bool Cheat::encode(string &s, unsigned addr, uint8 data, Type type) {
          | (!!(r & 0x080000) <<  5) | (!!(r & 0x040000) <<  4)
          | (!!(r & 0x020000) <<  3) | (!!(r & 0x010000) <<  2)
          | (!!(r & 0x000800) <<  1) | (!!(r & 0x000400) <<  0);
-    sprintf(t, "%.2x%.2x-%.4x", data, addr >> 16, addr & 0xffff);
-    strtr(t, "0123456789abcdef", "df4709156bc8a23e");
-    s = t;
+    s = sprint("$$-$", strhex<2>(data), strhex<2>(addr >> 16), strhex<4>(addr & 0xffff));
+    strtr(s, "0123456789abcdef", "df4709156bc8a23e");
     return true;
   } else {
     return false;

src/cheat/cheat.hpp

@@ -7,9 +7,9 @@ struct CheatCode {
   CheatCode();
 };
 
-class Cheat : public vector<CheatCode> {
+class Cheat : public linear_vector<CheatCode> {
 public:
-  enum Type { ProActionReplay, GameGenie };
+  enum class Type : unsigned { ProActionReplay, GameGenie };
 
   bool enabled() const;
   void enable(bool);

src/chip/bsx/bsx_cart.cpp

@@ -6,7 +6,6 @@ void BSXCart::init() {
 }
 
 void BSXCart::enable() {
-  for(uint16 i = 0x5000; i <= 0x5fff; i++) memory::mmio.map(i, *this);
 }
 
 void BSXCart::power() {
@@ -26,39 +25,39 @@ void BSXCart::update_memory_map() {
 
   if((regs.r[0x02] & 0x80) == 0x00) {
     //LoROM mapping
-    bus.map(Bus::MapLinear, 0x00, 0x7d, 0x8000, 0xffff, cart);
-    bus.map(Bus::MapLinear, 0x80, 0xff, 0x8000, 0xffff, cart);
+    bus.map(Bus::MapMode::Linear, 0x00, 0x7d, 0x8000, 0xffff, cart);
+    bus.map(Bus::MapMode::Linear, 0x80, 0xff, 0x8000, 0xffff, cart);
   } else {
     //HiROM mapping
-    bus.map(Bus::MapShadow, 0x00, 0x3f, 0x8000, 0xffff, cart);
-    bus.map(Bus::MapLinear, 0x40, 0x7d, 0x0000, 0xffff, cart);
-    bus.map(Bus::MapShadow, 0x80, 0xbf, 0x8000, 0xffff, cart);
-    bus.map(Bus::MapLinear, 0xc0, 0xff, 0x0000, 0xffff, cart);
+    bus.map(Bus::MapMode::Shadow, 0x00, 0x3f, 0x8000, 0xffff, cart);
+    bus.map(Bus::MapMode::Linear, 0x40, 0x7d, 0x0000, 0xffff, cart);
+    bus.map(Bus::MapMode::Shadow, 0x80, 0xbf, 0x8000, 0xffff, cart);
+    bus.map(Bus::MapMode::Linear, 0xc0, 0xff, 0x0000, 0xffff, cart);
   }
 
   if(regs.r[0x03] & 0x80) {
-    bus.map(Bus::MapLinear, 0x60, 0x6f, 0x0000, 0xffff, memory::bsxpram);
-  //bus.map(Bus::MapLinear, 0x70, 0x77, 0x0000, 0xffff, memory::bsxpram);
+    bus.map(Bus::MapMode::Linear, 0x60, 0x6f, 0x0000, 0xffff, memory::bsxpram);
+  //bus.map(Bus::MapMode::Linear, 0x70, 0x77, 0x0000, 0xffff, memory::bsxpram);
   }
 
   if((regs.r[0x05] & 0x80) == 0x00) {
-    bus.map(Bus::MapLinear, 0x40, 0x4f, 0x0000, 0xffff, memory::bsxpram);
+    bus.map(Bus::MapMode::Linear, 0x40, 0x4f, 0x0000, 0xffff, memory::bsxpram);
   }
 
   if((regs.r[0x06] & 0x80) == 0x00) {
-    bus.map(Bus::MapLinear, 0x50, 0x5f, 0x0000, 0xffff, memory::bsxpram);
+    bus.map(Bus::MapMode::Linear, 0x50, 0x5f, 0x0000, 0xffff, memory::bsxpram);
   }
 
   if(regs.r[0x07] & 0x80) {
-    bus.map(Bus::MapLinear, 0x00, 0x1f, 0x8000, 0xffff, memory::cartrom);
+    bus.map(Bus::MapMode::Linear, 0x00, 0x1f, 0x8000, 0xffff, memory::cartrom);
   }
 
   if(regs.r[0x08] & 0x80) {
-    bus.map(Bus::MapLinear, 0x80, 0x9f, 0x8000, 0xffff, memory::cartrom);
+    bus.map(Bus::MapMode::Linear, 0x80, 0x9f, 0x8000, 0xffff, memory::cartrom);
   }
 
-  bus.map(Bus::MapShadow, 0x20, 0x3f, 0x6000, 0x7fff, memory::bsxpram);
-  bus.map(Bus::MapLinear, 0x70, 0x77, 0x0000, 0xffff, memory::bsxpram);
+  bus.map(Bus::MapMode::Shadow, 0x20, 0x3f, 0x6000, 0x7fff, memory::bsxpram);
+  bus.map(Bus::MapMode::Linear, 0x70, 0x77, 0x0000, 0xffff, memory::bsxpram);
 }
 
 uint8 BSXCart::mmio_read(unsigned addr) {

src/chip/bsx/bsx_flash.cpp

@@ -60,7 +60,7 @@ void BSXFlash::write(unsigned addr, uint8 data) {
   //use read-write flashcarts, and HiROM-mapped BS-X carts always use
   //read-only flashcarts.
   //below is an unfortunately necessary workaround to this problem.
-  if(cartridge.mapper() == Cartridge::BSCHiROM) return;
+  //if(cartridge.mapper() == Cartridge::BSCHiROM) return;
 
   if((addr & 0xff0000) == 0) {
     regs.write_old = regs.write_new;

src/chip/chip.hpp

@@ -11,7 +11,7 @@
 #include "dsp3/dsp3.hpp"
 #include "dsp4/dsp4.hpp"
 #include "obc1/obc1.hpp"
-#include "st010/st010.hpp"
-#include "st011/st011.hpp"
-#include "st018/st018.hpp"
-#include "msu/msu.hpp"
+#include "st0010/st0010.hpp"
+#include "st0011/st0011.hpp"
+#include "st0018/st0018.hpp"
+#include "msu1/msu1.hpp"

src/chip/cx4/cx4.cpp

@@ -21,8 +21,6 @@ void Cx4::init() {
 }
 
 void Cx4::enable() {
-  bus.map(Bus::MapDirect, 0x00, 0x3f, 0x6000, 0x7fff, *this);
-  bus.map(Bus::MapDirect, 0x80, 0xbf, 0x6000, 0x7fff, *this);
 }
 
 uint32 Cx4::ldr(uint8 r) {

src/chip/dsp1/dsp1.cpp

@@ -4,6 +4,8 @@
 namespace SNES {
 
 DSP1 dsp1;
+DSP1DR dsp1dr;
+DSP1SR dsp1sr;
 
 #include "serialization.cpp"
 #include "dsp1emu.cpp"
@@ -12,22 +14,6 @@ void DSP1::init() {
 }
 
 void DSP1::enable() {
-  switch(cartridge.dsp1_mapper()) {
-    case Cartridge::DSP1LoROM1MB: {
-      bus.map(Bus::MapDirect, 0x20, 0x3f, 0x8000, 0xffff, *this);
-      bus.map(Bus::MapDirect, 0xa0, 0xbf, 0x8000, 0xffff, *this);
-    } break;
-
-    case Cartridge::DSP1LoROM2MB: {
-      bus.map(Bus::MapDirect, 0x60, 0x6f, 0x0000, 0x7fff, *this);
-      bus.map(Bus::MapDirect, 0xe0, 0xef, 0x0000, 0x7fff, *this);
-    } break;
-
-    case Cartridge::DSP1HiROM: {
-      bus.map(Bus::MapDirect, 0x00, 0x1f, 0x6000, 0x7fff, *this);
-      bus.map(Bus::MapDirect, 0x80, 0x9f, 0x6000, 0x7fff, *this);
-    } break;
-  }
 }
 
 void DSP1::power() {
@@ -38,46 +24,10 @@ void DSP1::reset() {
   dsp1.reset();
 }
 
-/*****
- * addr_decode()
- * determine whether address is accessing
- * data register (DR) or status register (SR)
- * -- 0 (false) = DR
- * -- 1 (true ) = SR
- *
- * note: there is no need to bounds check addresses,
- * as memory mapper will not allow DSP1 accesses outside
- * of expected ranges
- *****/
-bool DSP1::addr_decode(uint16 addr) {
-  switch(cartridge.dsp1_mapper()) {
-    case Cartridge::DSP1LoROM1MB: {
-    //$[20-3f]:[8000-bfff] = DR, $[20-3f]:[c000-ffff] = SR
-      return (addr >= 0xc000);
-    }
+uint8 DSP1DR::read(unsigned addr) { return dsp1.dsp1.getDr(); }
+void DSP1DR::write(unsigned addr, uint8 data) { dsp1.dsp1.setDr(data); }
 
-    case Cartridge::DSP1LoROM2MB: {
-    //$[60-6f]:[0000-3fff] = DR, $[60-6f]:[4000-7fff] = SR
-      return (addr >= 0x4000);
-    }
-
-    case Cartridge::DSP1HiROM: {
-    //$[00-1f]:[6000-6fff] = DR, $[00-1f]:[7000-7fff] = SR
-      return (addr >= 0x7000);
-    }
-  }
-
-  return 0;
-}
-
-uint8 DSP1::read(unsigned addr) {
-  return (addr_decode(addr) == 0) ? dsp1.getDr() : dsp1.getSr();
-}
-
-void DSP1::write(unsigned addr, uint8 data) {
-  if(addr_decode(addr) == 0) {
-    dsp1.setDr(data);
-  }
-}
+uint8 DSP1SR::read(unsigned addr) { return dsp1.dsp1.getSr(); }
+void DSP1SR::write(unsigned addr, uint8 data) {}
 
 };

src/chip/dsp1/dsp1.hpp

@@ -1,20 +1,30 @@
 #include "dsp1emu.hpp"
 
-class DSP1 : public Memory {
+class DSP1 {
 public:
   void init();
   void enable();
   void power();
   void reset();
 
-  uint8 read(unsigned addr);
-  void write(unsigned addr, uint8 data);
-
   void serialize(serializer&);
 
 private:
   Dsp1 dsp1;
-  bool addr_decode(uint16 addr);
+  friend class DSP1DR;
+  friend class DSP1SR;
+};
+
+class DSP1DR : public Memory {
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
+};
+
+class DSP1SR : public Memory {
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
 };
 
 extern DSP1 dsp1;
+extern DSP1DR dsp1dr;
+extern DSP1SR dsp1sr;

src/chip/dsp2/dsp2.cpp

@@ -12,10 +12,6 @@ void DSP2::init() {
 }
 
 void DSP2::enable() {
-  bus.map(Bus::MapDirect, 0x20, 0x3f, 0x6000, 0x6fff, *this);
-  bus.map(Bus::MapDirect, 0x20, 0x3f, 0x8000, 0xbfff, *this);
-  bus.map(Bus::MapDirect, 0xa0, 0xbf, 0x6000, 0x6fff, *this);
-  bus.map(Bus::MapDirect, 0xa0, 0xbf, 0x8000, 0xbfff, *this);
 }
 
 void DSP2::power() {

src/chip/dsp3/dsp3.cpp

@@ -15,8 +15,6 @@ void DSP3::init() {
 }
 
 void DSP3::enable() {
-  bus.map(Bus::MapDirect, 0x20, 0x3f, 0x8000, 0xffff, *this);
-  bus.map(Bus::MapDirect, 0xa0, 0xbf, 0x8000, 0xffff, *this);
 }
 
 void DSP3::power() {

src/chip/dsp4/dsp4.cpp

@@ -9,8 +9,6 @@ void DSP4::init() {
 }
 
 void DSP4::enable() {
-  bus.map(Bus::MapDirect, 0x30, 0x3f, 0x8000, 0xffff, *this);
-  bus.map(Bus::MapDirect, 0xb0, 0xbf, 0x8000, 0xffff, *this);
 }
 
 namespace DSP4i {

src/chip/msu1/msu1.cpp

@@ -1,18 +1,18 @@
 #include <../base.hpp>
 
-#define MSU_CPP
+#define MSU1_CPP
 namespace SNES {
 
-MSU msu;
+MSU1 msu1;
 
 #include "serialization.cpp"
 
-void MSU::enter() {
+void MSU1::enter() {
   scheduler.clock.cop_freq = 44100;
 
   while(true) {
-    if(scheduler.sync == Scheduler::SyncAll) {
-      scheduler.exit(Scheduler::SynchronizeEvent);
+    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
+      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
     }
 
     int16 left = 0, right = 0;
@@ -41,26 +41,22 @@ void MSU::enter() {
   }
 }
 
-void MSU::init() {
+void MSU1::init() {
 }
 
-void MSU::enable() {
+void MSU1::enable() {
   audio.coprocessor_enable(true);
   audio.coprocessor_frequency(44100.0);
 
-  for(unsigned i = 0x2000; i <= 0x2007; i++) {
-    memory::mmio.map(i, *this);
-  }
-
   if(datafile.open()) datafile.close();
   datafile.open(string() << basename << ".msu", file::mode_read);
 }
 
-void MSU::power() {
+void MSU1::power() {
   reset();
 }
 
-void MSU::reset() {
+void MSU1::reset() {
   mmio.data_offset  = 0;
   mmio.audio_offset = 0;
   mmio.audio_track  = 0;
@@ -71,7 +67,7 @@ void MSU::reset() {
   mmio.audio_play   = false;
 }
 
-uint8 MSU::mmio_read(unsigned addr) {
+uint8 MSU1::mmio_read(unsigned addr) {
   addr &= 0xffff;
 
   if(addr == 0x2000) {
@@ -99,7 +95,7 @@ uint8 MSU::mmio_read(unsigned addr) {
   return 0x00;
 }
 
-void MSU::mmio_write(unsigned addr, uint8 data) {
+void MSU1::mmio_write(unsigned addr, uint8 data) {
   addr &= 0xffff;
 
   if(addr == 0x2000) {
@@ -147,12 +143,8 @@ void MSU::mmio_write(unsigned addr, uint8 data) {
   }
 }
 
-void MSU::base(const string& name) {
+void MSU1::base(const string& name) {
   basename = name;
 }
 
-bool MSU::exists() {
-  return file::exists(string() << basename << ".msu");
-}
-
 }

src/chip/msu1/msu1.hpp

@@ -1,4 +1,4 @@
-class MSU : public MMIO {
+class MSU1 : public MMIO {
 public:
   void enter();
 
@@ -11,8 +11,6 @@ public:
   void mmio_write(unsigned addr, uint8 data);
 
   void base(const string &name);
-  bool exists();
-
   void serialize(serializer&);
 
 private:
@@ -40,4 +38,4 @@ private:
   } mmio;
 };
 
-extern MSU msu;
+extern MSU1 msu1;

src/chip/msu1/serialization.cpp

@@ -1,6 +1,6 @@
-#ifdef MSU_CPP
+#ifdef MSU1_CPP
 
-void MSU::serialize(serializer &s) {
+void MSU1::serialize(serializer &s) {
   s.integer(mmio.data_offset);
   s.integer(mmio.audio_offset);
   s.integer(mmio.audio_track);

src/chip/obc1/obc1.cpp

@@ -11,8 +11,6 @@ void OBC1::init() {
 }
 
 void OBC1::enable() {
-  bus.map(Bus::MapDirect, 0x00, 0x3f, 0x6000, 0x7fff, *this);
-  bus.map(Bus::MapDirect, 0x80, 0xbf, 0x6000, 0x7fff, *this);
 }
 
 void OBC1::power() {

src/chip/sa1/bus/bus.cpp

@@ -5,13 +5,13 @@ SA1Bus sa1bus;
 
 namespace memory {
   StaticRAM iram(2048);
-                                 //accessed by:
-  VectorSelectionPage vectorsp;  //S-CPU + SA-1
-  CPUIRAM cpuiram;               //S-CPU
-  SA1IRAM sa1iram;               //SA-1
-  SA1BWRAM sa1bwram;             //SA-1
-  CC1BWRAM cc1bwram;             //S-CPU
-  BitmapRAM bitmapram;           //SA-1
+                        //accessed by:
+  VSPROM vsprom;        //S-CPU + SA-1
+  CPUIRAM cpuiram;      //S-CPU
+  SA1IRAM sa1iram;      //SA-1
+  SA1BWRAM sa1bwram;    //SA-1
+  CC1BWRAM cc1bwram;    //S-CPU
+  BitmapRAM bitmapram;  //SA-1
 }
 
 //$230c (VDPL), $230d (VDPH) use this bus to read variable-length data.
@@ -20,53 +20,41 @@ namespace memory {
 //these ports.
 //(* eg, memory::cartram is used directly, as memory::sa1bwram syncs to the S-CPU)
 void VBRBus::init() {
-  map(MapDirect, 0x00, 0xff, 0x0000, 0xffff, memory::memory_unmapped);
+  map(MapMode::Direct, 0x00, 0xff, 0x0000, 0xffff, memory::memory_unmapped);
 
-  map(MapLinear, 0x00, 0x3f, 0x0000, 0x07ff, memory::iram);
-  map(MapLinear, 0x00, 0x3f, 0x3000, 0x37ff, memory::iram);
-  map(MapLinear, 0x00, 0x3f, 0x6000, 0x7fff, memory::cartram);
-  map(MapLinear, 0x00, 0x3f, 0x8000, 0xffff, memory::cartrom);
-  map(MapLinear, 0x40, 0x4f, 0x0000, 0xffff, memory::cartram);
-  map(MapLinear, 0x80, 0xbf, 0x0000, 0x07ff, memory::iram);
-  map(MapLinear, 0x80, 0xbf, 0x3000, 0x37ff, memory::iram);
-  map(MapLinear, 0x80, 0xbf, 0x6000, 0x7fff, memory::cartram);
-  map(MapLinear, 0x80, 0xbf, 0x8000, 0xffff, memory::cartrom);
-  map(MapLinear, 0xc0, 0xff, 0x0000, 0xffff, memory::cartrom);
+  map(MapMode::Linear, 0x00, 0x3f, 0x0000, 0x07ff, memory::iram);
+  map(MapMode::Linear, 0x00, 0x3f, 0x3000, 0x37ff, memory::iram);
+  map(MapMode::Linear, 0x00, 0x3f, 0x6000, 0x7fff, memory::cartram);
+  map(MapMode::Linear, 0x00, 0x3f, 0x8000, 0xffff, memory::vsprom);
+  map(MapMode::Linear, 0x40, 0x4f, 0x0000, 0xffff, memory::cartram);
+  map(MapMode::Linear, 0x80, 0xbf, 0x0000, 0x07ff, memory::iram);
+  map(MapMode::Linear, 0x80, 0xbf, 0x3000, 0x37ff, memory::iram);
+  map(MapMode::Linear, 0x80, 0xbf, 0x6000, 0x7fff, memory::cartram);
+  map(MapMode::Linear, 0x80, 0xbf, 0x8000, 0xffff, memory::vsprom);
+  map(MapMode::Linear, 0xc0, 0xff, 0x0000, 0xffff, memory::vsprom);
 }
 
 void SA1Bus::init() {
-  map(MapDirect, 0x00, 0xff, 0x0000, 0xffff, memory::memory_unmapped);
-  for(unsigned i = 0x2200; i <= 0x23ff; i++) memory::mmio.map(i, sa1);
+  map(MapMode::Direct, 0x00, 0xff, 0x0000, 0xffff, memory::memory_unmapped);
 
-  map(MapLinear, 0x00, 0x3f, 0x0000, 0x07ff, memory::sa1iram);
-  map(MapDirect, 0x00, 0x3f, 0x2200, 0x23ff, memory::mmio);
-  map(MapLinear, 0x00, 0x3f, 0x3000, 0x37ff, memory::sa1iram);
-  map(MapLinear, 0x00, 0x3f, 0x6000, 0x7fff, memory::sa1bwram);
-  map(MapLinear, 0x00, 0x3f, 0x8000, 0xffff, memory::cartrom);
-  map(MapLinear, 0x40, 0x4f, 0x0000, 0xffff, memory::sa1bwram);
-  map(MapLinear, 0x60, 0x6f, 0x0000, 0xffff, memory::bitmapram);
-  map(MapLinear, 0x80, 0xbf, 0x0000, 0x07ff, memory::sa1iram);
-  map(MapDirect, 0x80, 0xbf, 0x2200, 0x23ff, memory::mmio);
-  map(MapLinear, 0x80, 0xbf, 0x3000, 0x37ff, memory::sa1iram);
-  map(MapLinear, 0x80, 0xbf, 0x6000, 0x7fff, memory::sa1bwram);
-  map(MapLinear, 0x80, 0xbf, 0x8000, 0xffff, memory::cartrom);
-  map(MapLinear, 0xc0, 0xff, 0x0000, 0xffff, memory::cartrom);
-
-  bus.map(MapLinear, 0x00, 0x3f, 0x3000, 0x37ff, memory::cpuiram);
-  bus.map(MapLinear, 0x00, 0x3f, 0x6000, 0x7fff, memory::cc1bwram);
-  bus.map(MapLinear, 0x00, 0x3f, 0x8000, 0xffff, memory::cartrom);
-  bus.map(MapLinear, 0x40, 0x4f, 0x0000, 0xffff, memory::cc1bwram);
-  bus.map(MapLinear, 0x80, 0xbf, 0x3000, 0x37ff, memory::cpuiram);
-  bus.map(MapLinear, 0x80, 0xbf, 0x6000, 0x7fff, memory::cc1bwram);
-  bus.map(MapLinear, 0x80, 0xbf, 0x8000, 0xffff, memory::cartrom);
-  bus.map(MapLinear, 0xc0, 0xff, 0x0000, 0xffff, memory::cartrom);
-
-  memory::vectorsp.sync();
+  map(MapMode::Linear, 0x00, 0x3f, 0x0000, 0x07ff, memory::sa1iram);
+  map(MapMode::Direct, 0x00, 0x3f, 0x2200, 0x23ff, memory::mmio);
+  map(MapMode::Linear, 0x00, 0x3f, 0x3000, 0x37ff, memory::sa1iram);
+  map(MapMode::Linear, 0x00, 0x3f, 0x6000, 0x7fff, memory::sa1bwram);
+  map(MapMode::Linear, 0x00, 0x3f, 0x8000, 0xffff, memory::vsprom);
+  map(MapMode::Linear, 0x40, 0x4f, 0x0000, 0xffff, memory::sa1bwram);
+  map(MapMode::Linear, 0x60, 0x6f, 0x0000, 0xffff, memory::bitmapram);
+  map(MapMode::Linear, 0x80, 0xbf, 0x0000, 0x07ff, memory::sa1iram);
+  map(MapMode::Direct, 0x80, 0xbf, 0x2200, 0x23ff, memory::mmio);
+  map(MapMode::Linear, 0x80, 0xbf, 0x3000, 0x37ff, memory::sa1iram);
+  map(MapMode::Linear, 0x80, 0xbf, 0x6000, 0x7fff, memory::sa1bwram);
+  map(MapMode::Linear, 0x80, 0xbf, 0x8000, 0xffff, memory::vsprom);
+  map(MapMode::Linear, 0xc0, 0xff, 0x0000, 0xffff, memory::vsprom);
 }
 
-//===================
-//VectorSelectionPage
-//===================
+//======
+//VSPROM
+//======
 
 //this class maps $00:[ff00-ffff] for the purpose of supporting:
 //$2209.d6 IVSW (S-CPU IRQ vector selection) (0 = cart, 1 = SA-1)
@@ -78,35 +66,22 @@ void SA1Bus::init() {
 //$00:[ffea-ffeb|ffee-ffef] are special cased on read;
 //all other addresses return original mapped data.
 
-uint8 VectorSelectionPage::read(unsigned addr) {
-  switch(0xff00 | (addr & 0xff)) {
-    case 0xffea: case 0xffeb: {
-      if(sa1.mmio.cpu_nvsw == true) return (sa1.mmio.snv >> ((addr & 1) << 3));
-    } break;
-
-    case 0xffee: case 0xffef: {
-      if(sa1.mmio.cpu_ivsw == true) return (sa1.mmio.siv >> ((addr & 1) << 3));
-    } break;
-  }
-
-  return access->read(addr);
+unsigned VSPROM::size() const {
+  return memory::cartrom.size();
 }
 
-void VectorSelectionPage::write(unsigned addr, uint8 data) {
-  return access->write(addr, data);
+uint8 VSPROM::read(unsigned addr) {
+  //use $7fex instead of $ffex due to linear mapping of 32k granularity ROM data
+  if((addr & 0xffffe0) == 0x007fe0) {
+    if(addr == 0x7fea && sa1.mmio.cpu_nvsw) return sa1.mmio.snv >> 0;
+    if(addr == 0x7feb && sa1.mmio.cpu_nvsw) return sa1.mmio.snv >> 8;
+    if(addr == 0x7fee && sa1.mmio.cpu_ivsw) return sa1.mmio.siv >> 0;
+    if(addr == 0x7fef && sa1.mmio.cpu_ivsw) return sa1.mmio.siv >> 8;
+  }
+  return memory::cartrom.read(addr);
 }
 
-//call this whenever bus is remapped.
-//note: S-CPU and SA-1 bus always share $00:[ff00-ffff] as cartridge ROM data;
-//the SA-1 MMC does not allow mapping these independently between processors.
-//this allows this class to be shared for both, caching only ones' access class.
-void VectorSelectionPage::sync() {
-  if(bus.page[0x00ff00 >> 8].access != this) {
-    //bus was re-mapped, hook access routine
-    access = bus.page[0x00ff00 >> 8].access;
-       bus.page[0x00ff00 >> 8].access = this;
-    sa1bus.page[0x00ff00 >> 8].access = this;
-  }
+void VSPROM::write(unsigned addr, uint8 data) {
 }
 
 //=======

src/chip/sa1/bus/bus.hpp

@@ -6,11 +6,10 @@ struct SA1Bus : Bus {
   void init();
 };
 
-struct VectorSelectionPage : Memory {
+struct VSPROM : Memory {
+  unsigned size() const;
   alwaysinline uint8 read(unsigned);
   alwaysinline void write(unsigned, uint8);
-  void sync();
-  Memory *access;
 };
 
 struct CPUIRAM : Memory {
@@ -47,7 +46,7 @@ struct BitmapRAM : Memory {
 namespace memory {
   extern StaticRAM iram;
 
-  extern VectorSelectionPage vectorsp;
+  extern VSPROM vsprom;
   extern CPUIRAM cpuiram;
   extern SA1IRAM sa1iram;
   extern SA1BWRAM sa1bwram;

src/chip/sa1/mmio/mmio.cpp

@@ -2,8 +2,8 @@
 
 //BS-X flash carts, when present, are mapped to 0x400000+
 Memory& SA1::mmio_access(unsigned &addr) {
-  if(!memory::bsxflash.data()) return memory::cartrom;
-  if(addr < 0x400000) return memory::cartrom;
+  if(!memory::bsxflash.data()) return memory::vsprom;
+  if(addr < 0x400000) return memory::vsprom;
   addr &= 0x3fffff;
   return bsxflash;
 }
@@ -156,17 +156,15 @@ void SA1::mmio_w2220(uint8 data) {
   Memory &access = mmio_access(addr);
 
   if(mmio.cbmode == 0) {
-       bus.map(Bus::MapLinear, 0x00, 0x1f, 0x8000, 0xffff, memory::cartrom, 0x000000);
-    sa1bus.map(Bus::MapLinear, 0x00, 0x1f, 0x8000, 0xffff, memory::cartrom, 0x000000);
+       bus.map(Bus::MapMode::Linear, 0x00, 0x1f, 0x8000, 0xffff, memory::vsprom, 0x000000);
+    sa1bus.map(Bus::MapMode::Linear, 0x00, 0x1f, 0x8000, 0xffff, memory::vsprom, 0x000000);
   } else {
-       bus.map(Bus::MapLinear, 0x00, 0x1f, 0x8000, 0xffff, access, addr);
-    sa1bus.map(Bus::MapLinear, 0x00, 0x1f, 0x8000, 0xffff, access, addr);
+       bus.map(Bus::MapMode::Linear, 0x00, 0x1f, 0x8000, 0xffff, access, addr);
+    sa1bus.map(Bus::MapMode::Linear, 0x00, 0x1f, 0x8000, 0xffff, access, addr);
   }
 
-     bus.map(Bus::MapLinear, 0xc0, 0xcf, 0x0000, 0xffff, access, addr);
-  sa1bus.map(Bus::MapLinear, 0xc0, 0xcf, 0x0000, 0xffff, access, addr);
-
-  memory::vectorsp.sync();
+     bus.map(Bus::MapMode::Linear, 0xc0, 0xcf, 0x0000, 0xffff, access, addr);
+  sa1bus.map(Bus::MapMode::Linear, 0xc0, 0xcf, 0x0000, 0xffff, access, addr);
 }
 
 //(DXB) Super MMC bank D
@@ -178,15 +176,15 @@ void SA1::mmio_w2221(uint8 data) {
   Memory &access = mmio_access(addr);
 
   if(mmio.dbmode == 0) {
-       bus.map(Bus::MapLinear, 0x20, 0x3f, 0x8000, 0xffff, memory::cartrom, 0x100000);
-    sa1bus.map(Bus::MapLinear, 0x20, 0x3f, 0x8000, 0xffff, memory::cartrom, 0x100000);
+       bus.map(Bus::MapMode::Linear, 0x20, 0x3f, 0x8000, 0xffff, memory::vsprom, 0x100000);
+    sa1bus.map(Bus::MapMode::Linear, 0x20, 0x3f, 0x8000, 0xffff, memory::vsprom, 0x100000);
   } else {
-       bus.map(Bus::MapLinear, 0x20, 0x3f, 0x8000, 0xffff, access, addr);
-    sa1bus.map(Bus::MapLinear, 0x20, 0x3f, 0x8000, 0xffff, access, addr);
+       bus.map(Bus::MapMode::Linear, 0x20, 0x3f, 0x8000, 0xffff, access, addr);
+    sa1bus.map(Bus::MapMode::Linear, 0x20, 0x3f, 0x8000, 0xffff, access, addr);
   }
 
-     bus.map(Bus::MapLinear, 0xd0, 0xdf, 0x0000, 0xffff, access, addr);
-  sa1bus.map(Bus::MapLinear, 0xd0, 0xdf, 0x0000, 0xffff, access, addr);
+     bus.map(Bus::MapMode::Linear, 0xd0, 0xdf, 0x0000, 0xffff, access, addr);
+  sa1bus.map(Bus::MapMode::Linear, 0xd0, 0xdf, 0x0000, 0xffff, access, addr);
 }
 
 //(EXB) Super MMC bank E
@@ -198,15 +196,15 @@ void SA1::mmio_w2222(uint8 data) {
   Memory &access = mmio_access(addr);
 
   if(mmio.ebmode == 0) {
-       bus.map(Bus::MapLinear, 0x80, 0x9f, 0x8000, 0xffff, memory::cartrom, 0x200000);
-    sa1bus.map(Bus::MapLinear, 0x80, 0x9f, 0x8000, 0xffff, memory::cartrom, 0x200000);
+       bus.map(Bus::MapMode::Linear, 0x80, 0x9f, 0x8000, 0xffff, memory::vsprom, 0x200000);
+    sa1bus.map(Bus::MapMode::Linear, 0x80, 0x9f, 0x8000, 0xffff, memory::vsprom, 0x200000);
   } else {
-       bus.map(Bus::MapLinear, 0x80, 0x9f, 0x8000, 0xffff, access, addr);
-    sa1bus.map(Bus::MapLinear, 0x80, 0x9f, 0x8000, 0xffff, access, addr);
+       bus.map(Bus::MapMode::Linear, 0x80, 0x9f, 0x8000, 0xffff, access, addr);
+    sa1bus.map(Bus::MapMode::Linear, 0x80, 0x9f, 0x8000, 0xffff, access, addr);
   }
 
-     bus.map(Bus::MapLinear, 0xe0, 0xef, 0x0000, 0xffff, access, addr);
-  sa1bus.map(Bus::MapLinear, 0xe0, 0xef, 0x0000, 0xffff, access, addr);
+     bus.map(Bus::MapMode::Linear, 0xe0, 0xef, 0x0000, 0xffff, access, addr);
+  sa1bus.map(Bus::MapMode::Linear, 0xe0, 0xef, 0x0000, 0xffff, access, addr);
 }
 
 //(FXB) Super MMC bank F
@@ -218,23 +216,23 @@ void SA1::mmio_w2223(uint8 data) {
   Memory &access = mmio_access(addr);
 
   if(mmio.fbmode == 0) {
-       bus.map(Bus::MapLinear, 0xa0, 0xbf, 0x8000, 0xffff, memory::cartrom, 0x300000);
-    sa1bus.map(Bus::MapLinear, 0xa0, 0xbf, 0x8000, 0xffff, memory::cartrom, 0x300000);
+       bus.map(Bus::MapMode::Linear, 0xa0, 0xbf, 0x8000, 0xffff, memory::vsprom, 0x300000);
+    sa1bus.map(Bus::MapMode::Linear, 0xa0, 0xbf, 0x8000, 0xffff, memory::vsprom, 0x300000);
   } else {
-       bus.map(Bus::MapLinear, 0xa0, 0xbf, 0x8000, 0xffff, access, addr);
-    sa1bus.map(Bus::MapLinear, 0xa0, 0xbf, 0x8000, 0xffff, access, addr);
+       bus.map(Bus::MapMode::Linear, 0xa0, 0xbf, 0x8000, 0xffff, access, addr);
+    sa1bus.map(Bus::MapMode::Linear, 0xa0, 0xbf, 0x8000, 0xffff, access, addr);
   }
 
-     bus.map(Bus::MapLinear, 0xf0, 0xff, 0x0000, 0xffff, access, addr);
-  sa1bus.map(Bus::MapLinear, 0xf0, 0xff, 0x0000, 0xffff, access, addr);
+     bus.map(Bus::MapMode::Linear, 0xf0, 0xff, 0x0000, 0xffff, access, addr);
+  sa1bus.map(Bus::MapMode::Linear, 0xf0, 0xff, 0x0000, 0xffff, access, addr);
 }
 
 //(BMAPS) S-CPU BW-RAM address mapping
 void SA1::mmio_w2224(uint8 data) {
   mmio.sbm = (data & 0x1f);
 
-  bus.map(Bus::MapLinear, 0x00, 0x3f, 0x6000, 0x7fff, memory::cc1bwram, mmio.sbm * 0x2000, 0x2000);
-  bus.map(Bus::MapLinear, 0x80, 0xbf, 0x6000, 0x7fff, memory::cc1bwram, mmio.sbm * 0x2000, 0x2000);
+  bus.map(Bus::MapMode::Linear, 0x00, 0x3f, 0x6000, 0x7fff, memory::cc1bwram, mmio.sbm * 0x2000, 0x2000);
+  bus.map(Bus::MapMode::Linear, 0x80, 0xbf, 0x6000, 0x7fff, memory::cc1bwram, mmio.sbm * 0x2000, 0x2000);
 }
 
 //(BMAP) SA-1 BW-RAM address mapping
@@ -244,12 +242,12 @@ void SA1::mmio_w2225(uint8 data) {
 
   if(mmio.sw46 == 0) {
     //$[40-43]:[0000-ffff] x  32 projection
-    sa1bus.map(Bus::MapLinear, 0x00, 0x3f, 0x6000, 0x7fff, memory::sa1bwram, (mmio.cbm & 0x1f) * 0x2000, 0x2000);
-    sa1bus.map(Bus::MapLinear, 0x80, 0xbf, 0x6000, 0x7fff, memory::sa1bwram, (mmio.cbm & 0x1f) * 0x2000, 0x2000);
+    sa1bus.map(Bus::MapMode::Linear, 0x00, 0x3f, 0x6000, 0x7fff, memory::sa1bwram, (mmio.cbm & 0x1f) * 0x2000, 0x2000);
+    sa1bus.map(Bus::MapMode::Linear, 0x80, 0xbf, 0x6000, 0x7fff, memory::sa1bwram, (mmio.cbm & 0x1f) * 0x2000, 0x2000);
   } else {
     //$[60-6f]:[0000-ffff] x 128 projection
-    sa1bus.map(Bus::MapLinear, 0x00, 0x3f, 0x6000, 0x7fff, memory::bitmapram, mmio.cbm * 0x2000, 0x2000);
-    sa1bus.map(Bus::MapLinear, 0x80, 0xbf, 0x6000, 0x7fff, memory::bitmapram, mmio.cbm * 0x2000, 0x2000);
+    sa1bus.map(Bus::MapMode::Linear, 0x00, 0x3f, 0x6000, 0x7fff, memory::bitmapram, mmio.cbm * 0x2000, 0x2000);
+    sa1bus.map(Bus::MapMode::Linear, 0x80, 0xbf, 0x6000, 0x7fff, memory::bitmapram, mmio.cbm * 0x2000, 0x2000);
   }
 }
 

src/chip/sa1/sa1.cpp

@@ -13,8 +13,8 @@ SA1 sa1;
 
 void SA1::enter() {
   while(true) {
-    if(scheduler.sync == Scheduler::SyncAll) {
-      scheduler.exit(Scheduler::SynchronizeEvent);
+    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
+      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
     }
 
     if(mmio.sa1_rdyb || mmio.sa1_resb) {
@@ -127,7 +127,6 @@ void SA1::power() {
 }
 
 void SA1::reset() {
-  memory::vectorsp.access = 0;
   memory::cc1bwram.dma = false;
   for(unsigned addr = 0; addr < memory::iram.size(); addr++) {
     memory::iram.write(addr, 0x00);
@@ -152,7 +151,7 @@ void SA1::reset() {
   status.interrupt_pending = false;
   status.interrupt_vector  = 0x0000;
 
-  status.scanlines = (system.region() == System::NTSC ? 262 : 312);
+  status.scanlines = (system.region() == System::Region::NTSC ? 262 : 312);
   status.vcounter  = 0;
   status.hcounter  = 0;
 

src/chip/sa1/serialization.cpp

@@ -16,8 +16,6 @@ void SA1::serialize(serializer &s) {
   //bus/bus.hpp
   s.array(memory::iram.data(), memory::iram.size());
 
-  memory::vectorsp.sync();
-
   s.integer(memory::cc1bwram.dma);
 
   //dma/dma.hpp

src/chip/sdd1/sdd1.cpp

@@ -17,11 +17,6 @@ void SDD1::enable() {
     cpu_mmio[i & 0x7f] = memory::mmio.mmio[i - 0x2000];
     memory::mmio.map(i, *this);
   }
-
-  //hook S-DD1 MMIO registers
-  for(unsigned i = 0x4800; i <= 0x4807; i++) {
-    memory::mmio.map(i, *this);
-  }
 }
 
 void SDD1::power() {
@@ -43,8 +38,6 @@ void SDD1::reset() {
   }
 
   buffer.ready = false;
-
-  bus.map(Bus::MapDirect, 0xc0, 0xff, 0x0000, 0xffff, *this);
 }
 
 uint8 SDD1::mmio_read(unsigned addr) {

src/chip/spc7110/decomp.cpp

@@ -24,9 +24,9 @@ void SPC7110Decomp::write(uint8 data) {
 }
 
 uint8 SPC7110Decomp::dataread() {
-  unsigned size = memory::cartrom.size() - 0x100000;
+  unsigned size = memory::cartrom.size() - cartridge.spc7110_data_rom_offset();
   while(decomp_offset >= size) decomp_offset -= size;
-  return memory::cartrom.read(0x100000 + decomp_offset++);
+  return memory::cartrom.read(cartridge.spc7110_data_rom_offset() + decomp_offset++);
 }
 
 void SPC7110Decomp::init(unsigned mode, unsigned offset, unsigned index) {

src/chip/spc7110/spc7110.cpp

@@ -4,6 +4,9 @@
 namespace SNES {
 
 SPC7110 spc7110;
+SPC7110MCU spc7110mcu;
+SPC7110DCU spc7110dcu;
+SPC7110RAM spc7110ram;
 
 #include "serialization.cpp"
 #include "decomp.cpp"
@@ -11,11 +14,7 @@ SPC7110 spc7110;
 const unsigned SPC7110::months[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
 void SPC7110::init() {}
-
-void SPC7110::enable() {
-  uint16_t limit = (cartridge.has_spc7110rtc() ? 0x4842 : 0x483f);
-  for(uint16_t i = 0x4800; i <= limit; i++) memory::mmio.map(i, *this);
-}
+void SPC7110::enable() {}
 
 void SPC7110::power() {
   reset();
@@ -85,9 +84,9 @@ void SPC7110::reset() {
 }
 
 unsigned SPC7110::datarom_addr(unsigned addr) {
-  unsigned size = memory::cartrom.size() - 0x100000;
+  unsigned size = memory::cartrom.size() - cartridge.spc7110_data_rom_offset();
   while(addr >= size) addr -= size;
-  return addr + 0x100000;
+  return cartridge.spc7110_data_rom_offset() + addr;
 }
 
 unsigned SPC7110::data_pointer()   { return r4811 + (r4812 << 8) + (r4813 << 16); }
@@ -632,46 +631,52 @@ void SPC7110::mmio_write(unsigned addr, uint8 data) {
   }
 }
 
-uint8 SPC7110::read(unsigned addr) {
-  //$[00-0f|80-8f]:[8000-ffff], $[c0-cf]:[0000-ffff] mapped directly to memory::cartrom
-
-  if((addr & 0xffe000) == 0x006000 || (addr & 0xffe000) == 0x306000) {
-    //$[00|30]:[6000-7fff]
-    return memory::cartram.read(addr & 0x1fff);
-  }
-
-  if((addr & 0xff0000) == 0x500000) {
-    //$[50]:[0000-ffff]
-    return mmio_read(0x4800);
-  }
-
-  if((addr & 0xf00000) == 0xd00000) {
-    //$[d0-df]:[0000-ffff]
-    return memory::cartrom.read(dx_offset + (addr & 0x0fffff));
-  }
-
-  if((addr & 0xf00000) == 0xe00000) {
-    //$[e0-ef]:[0000-ffff]
-    return memory::cartrom.read(ex_offset + (addr & 0x0fffff));
-  }
-
-  if((addr & 0xf00000) == 0xf00000) {
-    //$[f0-ff]:[0000-ffff]
-    return memory::cartrom.read(fx_offset + (addr & 0x0fffff));
-  }
-
-  return cpu.regs.mdr;
-}
-
-void SPC7110::write(unsigned addr, uint8 data) {
-  if((addr & 0xffe000) == 0x006000 || (addr & 0xffe000) == 0x306000) {
-    //$[00|30]:[6000-7fff]
-    if(r4830 & 0x80) memory::cartram.write(addr & 0x1fff, data);
-    return;
-  }
-}
-
 SPC7110::SPC7110() {
 }
 
+//==========
+//SPC7110MCU
+//==========
+
+unsigned SPC7110MCU::size() const {
+  return 0x300000;
+}
+
+uint8 SPC7110MCU::read(unsigned addr) {
+  if(addr <= 0xdfffff) return memory::cartrom.read(spc7110.dx_offset + (addr & 0x0fffff));
+  if(addr <= 0xefffff) return memory::cartrom.read(spc7110.ex_offset + (addr & 0x0fffff));
+  if(addr <= 0xffffff) return memory::cartrom.read(spc7110.fx_offset + (addr & 0x0fffff));
+  return cpu.regs.mdr;
+}
+
+void SPC7110MCU::write(unsigned addr, uint8 data) {
+}
+
+//==========
+//SPC7110DCU
+//==========
+
+uint8 SPC7110DCU::read(unsigned) {
+  return spc7110.mmio_read(0x4800);
+}
+
+void SPC7110DCU::write(unsigned, uint8) {
+}
+
+//==========
+//SPC7110RAM
+//==========
+
+unsigned SPC7110RAM::size() const {
+  return 0x2000;
+}
+
+uint8 SPC7110RAM::read(unsigned addr) {
+  return memory::cartram.read(addr & 0x1fff);
+}
+
+void SPC7110RAM::write(unsigned addr, uint8 data) {
+  if(spc7110.r4830 & 0x80) memory::cartram.write(addr & 0x1fff, data);
+}
+
 };

src/chip/spc7110/spc7110.hpp

@@ -1,6 +1,6 @@
 /*****
- * SPC7110 emulator - version 0.03 (2008-08-10)
- * Copyright (c) 2008, byuu and neviksti
+ * SPC7110 emulator - version 0.04 (2010-02-14)
+ * Copyright (c) 2008-2010, byuu and neviksti
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -17,7 +17,7 @@
 
 #include "decomp.hpp"
 
-class SPC7110 : public MMIO, public Memory {
+class SPC7110 : public MMIO {
 public:
   void init();
   void enable();
@@ -38,9 +38,6 @@ public:
   uint8 mmio_read(unsigned addr);
   void mmio_write(unsigned addr, uint8 data);
 
-  uint8 read(unsigned addr);
-  void write(unsigned addr, uint8 data);
-
   //spc7110decomp
   void decomp_init();
   uint8 decomp_read();
@@ -131,6 +128,32 @@ private:
   unsigned rtc_index;
 
   static const unsigned months[12];
+  friend class SPC7110MCU;
+  friend class SPC7110DCU;
+  friend class SPC7110RAM;
+};
+
+class SPC7110MCU : public Memory {
+public:
+  unsigned size() const;
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
+};
+
+class SPC7110DCU : public Memory {
+public:
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
+};
+
+class SPC7110RAM : public Memory {
+public:
+  unsigned size() const;
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
 };
 
 extern SPC7110 spc7110;
+extern SPC7110MCU spc7110mcu;
+extern SPC7110DCU spc7110dcu;
+extern SPC7110RAM spc7110ram;

src/chip/srtc/srtc.cpp

@@ -13,8 +13,6 @@ void SRTC::init() {
 }
 
 void SRTC::enable() {
-  memory::mmio.map(0x2800, *this);
-  memory::mmio.map(0x2801, *this);
 }
 
 void SRTC::power() {

src/chip/st0010/data.hpp

@@ -1,4 +1,6 @@
-const int16 ST010::sin_table[256] = {
+#ifdef ST0010_CPP
+
+const int16 ST0010::sin_table[256] = {
    0x0000,  0x0324,  0x0648,  0x096a,  0x0c8c,  0x0fab,  0x12c8,  0x15e2,
    0x18f9,  0x1c0b,  0x1f1a,  0x2223,  0x2528,  0x2826,  0x2b1f,  0x2e11,
    0x30fb,  0x33df,  0x36ba,  0x398c,  0x3c56,  0x3f17,  0x41ce,  0x447a,
@@ -33,7 +35,7 @@ const int16 ST010::sin_table[256] = {
   -0x18f8, -0x15e2, -0x12c8, -0x0fab, -0x0c8b, -0x096a, -0x0647, -0x0324
 };
 
-const int16 ST010::mode7_scale[176] = {
+const int16 ST0010::mode7_scale[176] = {
   0x0380,  0x0325,  0x02da,  0x029c,  0x0268,  0x023b,  0x0215,  0x01f3,
   0x01d5,  0x01bb,  0x01a3,  0x018e,  0x017b,  0x016a,  0x015a,  0x014b,
   0x013e,  0x0132,  0x0126,  0x011c,  0x0112,  0x0109,  0x0100,  0x00f8,
@@ -58,7 +60,7 @@ const int16 ST010::mode7_scale[176] = {
   0x002d,  0x002c,  0x002c,  0x002c,  0x002c,  0x002b,  0x002b,  0x002b
 };
 
-const uint8 ST010::arctan[32][32] = {
+const uint8 ST0010::arctan[32][32] = {
   { 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
     0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 },
   { 0x80, 0xa0, 0xad, 0xb3, 0xb6, 0xb8, 0xb9, 0xba, 0xbb, 0xbb, 0xbc, 0xbc, 0xbd, 0xbd, 0xbd, 0xbd,
@@ -124,3 +126,5 @@ const uint8 ST010::arctan[32][32] = {
   { 0x80, 0x81, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92,
     0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9c, 0x9d, 0x9e, 0x9f, 0x9f, 0xa0 }
 };
+
+#endif

src/chip/st0010/opcodes.cpp

@@ -1,9 +1,9 @@
-#ifdef ST010_CPP
+#ifdef ST0010_CPP
 
-//ST-010 emulation code - Copyright (C) 2003 The Dumper, Matthew Kendora, Overload, Feather
+//ST-0010 emulation code - Copyright (C) 2003 The Dumper, Matthew Kendora, Overload, Feather
 //bsnes port - Copyright (C) 2007 byuu
 
-void ST010::op_01(int16 x0, int16 y0, int16 &x1, int16 &y1, int16 &quadrant, int16 &theta) {
+void ST0010::op_01(int16 x0, int16 y0, int16 &x1, int16 &y1, int16 &quadrant, int16 &theta) {
   if((x0 < 0) && (y0 < 0)) {
     x1 = -x0;
     y1 = -y0;
@@ -34,7 +34,7 @@ void ST010::op_01(int16 x0, int16 y0, int16 &x1, int16 &y1, int16 &quadrant, int
 
 //
 
-void ST010::op_01() {
+void ST0010::op_01() {
   int16 x0 = readw(0x0000);
   int16 y0 = readw(0x0002);
   int16 x1, y1, quadrant, theta;
@@ -48,7 +48,7 @@ void ST010::op_01() {
   writew(0x0010, theta);
 }
 
-void ST010::op_02() {
+void ST0010::op_02() {
   int16 positions = readw(0x0024);
   uint16 *places  = (uint16*)(ram + 0x0040);
   uint16 *drivers = (uint16*)(ram + 0x0080);
@@ -76,7 +76,7 @@ void ST010::op_02() {
   }
 }
 
-void ST010::op_03() {
+void ST0010::op_03() {
   int16 x0 = readw(0x0000);
   int16 y0 = readw(0x0002);
   int16 multiplier = readw(0x0004);
@@ -89,7 +89,7 @@ void ST010::op_03() {
   writed(0x0014, y1);
 }
 
-void ST010::op_04() {
+void ST0010::op_04() {
   int16 x = readw(0x0000);
   int16 y = readw(0x0002);
   int16 square;
@@ -99,7 +99,7 @@ void ST010::op_04() {
   writew(0x0010, square);
 }
 
-void ST010::op_05() {
+void ST0010::op_05() {
   int32 dx, dy;
   int16 a1, b1, c1;
   uint16 o1;
@@ -217,7 +217,7 @@ void ST010::op_05() {
   writew(0x00dc, flags);
 }
 
-void ST010::op_06() {
+void ST0010::op_06() {
   int16 multiplicand = readw(0x0000);
   int16 multiplier = readw(0x0002);
   int32 product;
@@ -227,7 +227,7 @@ void ST010::op_06() {
   writed(0x0010, product);
 }
 
-void ST010::op_07() {
+void ST0010::op_07() {
   int16 theta = readw(0x0000);
 
   int16 data;
@@ -245,7 +245,7 @@ void ST010::op_07() {
   }
 }
 
-void ST010::op_08() {
+void ST0010::op_08() {
   int16 x0 = readw(0x0000);
   int16 y0 = readw(0x0002);
   int16 theta = readw(0x0004);

src/chip/st0010/serialization.cpp

@@ -0,0 +1,7 @@
+#ifdef ST0010_CPP
+
+void ST0010::serialize(serializer &s) {
+  s.array(ram);
+}
+
+#endif

src/chip/st0010/st0010.cpp

@@ -1,56 +1,54 @@
 #include <../base.hpp>
 
-#define ST010_CPP
+#define ST0010_CPP
 namespace SNES {
 
-ST010 st010;
+ST0010 st0010;
 
-#include "st010_data.hpp"
+#include "data.hpp"
+#include "opcodes.cpp"
 #include "serialization.cpp"
-#include "st010_op.cpp"
 
-void ST010::init() {
+void ST0010::init() {
 }
 
-void ST010::enable() {
-  bus.map(Bus::MapDirect, 0x68, 0x6f, 0x0000, 0x0fff, *this);
-  bus.map(Bus::MapDirect, 0xe8, 0xef, 0x0000, 0x0fff, *this);
+void ST0010::enable() {
 }
 
-int16 ST010::sin(int16 theta) {
+int16 ST0010::sin(int16 theta) {
   return sin_table[(theta >> 8) & 0xff];
 }
 
-int16 ST010::cos(int16 theta) {
+int16 ST0010::cos(int16 theta) {
   return sin_table[((theta + 0x4000) >> 8) & 0xff];
 }
 
-uint8 ST010::readb(uint16 addr) {
+uint8 ST0010::readb(uint16 addr) {
   return ram[addr & 0xfff];
 }
 
-uint16 ST010::readw(uint16 addr) {
+uint16 ST0010::readw(uint16 addr) {
   return (readb(addr + 0) <<  0) |
          (readb(addr + 1) <<  8);
 }
 
-uint32 ST010::readd(uint16 addr) {
+uint32 ST0010::readd(uint16 addr) {
   return (readb(addr + 0) <<  0) |
          (readb(addr + 1) <<  8) |
          (readb(addr + 2) << 16) |
          (readb(addr + 3) << 24);
 }
 
-void ST010::writeb(uint16 addr, uint8 data) {
+void ST0010::writeb(uint16 addr, uint8 data) {
   ram[addr & 0xfff] = data;
 }
 
-void ST010::writew(uint16 addr, uint16 data) {
+void ST0010::writew(uint16 addr, uint16 data) {
   writeb(addr + 0, data >> 0);
   writeb(addr + 1, data >> 8);
 }
 
-void ST010::writed(uint16 addr, uint32 data) {
+void ST0010::writed(uint16 addr, uint32 data) {
   writeb(addr + 0, data >>  0);
   writeb(addr + 1, data >>  8);
   writeb(addr + 2, data >> 16);
@@ -59,21 +57,21 @@ void ST010::writed(uint16 addr, uint32 data) {
 
 //
 
-void ST010::power() {
+void ST0010::power() {
   reset();
 }
 
-void ST010::reset() {
+void ST0010::reset() {
   memset(ram, 0x00, sizeof ram);
 }
 
 //
 
-uint8 ST010::read(unsigned addr) {
+uint8 ST0010::read(unsigned addr) {
   return readb(addr);
 }
 
-void ST010::write(unsigned addr, uint8 data) {
+void ST0010::write(unsigned addr, uint8 data) {
   writeb(addr, data);
 
   if((addr & 0xfff) == 0x0021 && (data & 0x80)) {