Update to v087 release.

byuu says:

This release adds ST018 emulation. As this was the final unsupported
SNES coprocessor, this means that bsnes v087 is the first SNES emulator
to be able to claim 100% known compatibility with all officially
released games. And it does this with absolutely no hacks.

Again, I really have to stress the word known. No emulator is perfect.
No emulator ever really can be perfect for a system of this complexity.
The concept doesn't even really exist, since every SNES behaves subtly
different. What I mean by this, is that every single game ever
officially sold has been tested, and zero bugs (of any severity level)
are currently known.

It is of course extremely likely that bugs will be found in this
release, as well as in future releases. But this will always be
a problem for every emulator ever made: there is no way to test every
possible codepath of every single game to guarantee perfection. I will,
of course, continue to do my best to fix newfound bugs so long as I'm
around.

I'd really like to thank Cydrak and LostTemplar for their assistance in
emulating the ST018. I could not have done it without their help.

The ST018 ROM, like the other coprocessor ROMs, is copyrighted. This
means I am unable to distribute the image.

Changelog (since v086):
- emulated the 21.47MHz ST018 (ARMv3) coprocessor used by Hayazashi
  Nidan Morita Shougi 2
- fixed PPU TM/TS edge case; fixes bottom scanline of text boxes in
  Moryo Senki Madara 2
- fixed saving and loading of Super Game Boy save RAM
- NEC uPD7725,96050 ROMs now stored in little-endian format for
  consistency
- cartridge folder concept has been reworked to use fixed file names
- added emulation of serial USART interface (replaces asynchronous UART
  support previously)

bsnes/Makefile

@@ -4,15 +4,14 @@ nes := nes
 snes := snes
 gameboy := gameboy
 profile := accuracy
-ui := ui
+target := ui
 
 # options += console
-# options += debugger
 
 # compiler
 c       := $(compiler) -std=gnu99
 cpp     := $(subst cc,++,$(compiler)) -std=gnu++0x
-flags   := -O3 -fomit-frame-pointer -I.
+flags   := -I. -O3 -fomit-frame-pointer
 link    :=
 objects := libco
 
@@ -29,8 +28,6 @@ endif
 
 # platform
 ifeq ($(platform),x)
-  # tree vectorization causes code generation errors with Linux/GCC 4.6.1
-  flags += -fno-tree-vectorize
   link += -s -ldl -lX11 -lXext
 else ifeq ($(platform),osx)
 else ifeq ($(platform),win)
@@ -41,7 +38,7 @@ else
   unknown_platform: help;
 endif
 
-flags := $(flags) $(foreach o,$(call strupper,$(options)),-D$o)
+ui := target-$(target)
 
 # implicit rules
 compile = \
@@ -61,6 +58,7 @@ all: build;
 obj/libco.o: libco/libco.c libco/*
 
 include $(ui)/Makefile
+flags := $(flags) $(foreach o,$(call strupper,$(options)),-D$o)
 
 # targets
 clean:
@@ -76,7 +74,23 @@ clean:
 	-@$(call delete,*.pdb)
 	-@$(call delete,*.manifest)
 
+sync:
+	if [ -d ./libco ]; then rm -r ./libco; fi
+	if [ -d ./nall ]; then rm -r ./nall; fi
+	if [ -d ./ruby ]; then rm -r ./ruby; fi
+	if [ -d ./phoenix ]; then rm -r ./phoenix; fi
+	cp -r ../libco ./libco
+	cp -r ../nall ./nall
+	cp -r ../ruby ./ruby
+	cp -r ../phoenix ./phoenix
+	rm -r libco/doc
+	rm -r libco/test
+	rm -r nall/test
+	rm -r ruby/_test
+	rm -r phoenix/nall
+	rm -r phoenix/test
+
 archive-all:
-	tar -cjf bsnes.tar.bz2 data gameboy libco nall nes obj out phoenix ruby snes ui ui-libsnes Makefile cc.bat clean.bat sync.sh
+	tar -cjf bsnes.tar.bz2 base data gameboy libco nall nes obj out phoenix ruby snes target-debugger target-libsnes target-ui Makefile cc.bat purge.bat
 
 help:;

bsnes/base/base.hpp

@@ -0,0 +1,129 @@
+#ifndef BASE_HPP
+#define BASE_HPP
+
+const char Version[] = "087";
+
+#include <nall/platform.hpp>
+#include <nall/algorithm.hpp>
+#include <nall/any.hpp>
+#include <nall/array.hpp>
+#include <nall/dl.hpp>
+#include <nall/dsp.hpp>
+#include <nall/endian.hpp>
+#include <nall/file.hpp>
+#include <nall/function.hpp>
+#include <nall/moduloarray.hpp>
+#include <nall/priorityqueue.hpp>
+#include <nall/property.hpp>
+#include <nall/random.hpp>
+#include <nall/serializer.hpp>
+#include <nall/stdint.hpp>
+#include <nall/string.hpp>
+#include <nall/utility.hpp>
+#include <nall/varint.hpp>
+#include <nall/vector.hpp>
+using namespace nall;
+
+//debugging function hook:
+//no overhead (and no debugger invocation) if not compiled with -DDEBUGGER
+//wraps testing of function to allow invocation without a defined callback
+template<typename T> struct hook;
+template<typename R, typename... P> struct hook<R (P...)> {
+  function<R (P...)> callback;
+
+  R operator()(P... p) const {
+    #if defined(DEBUGGER)
+    if(callback) return callback(std::forward<P>(p)...);
+    #endif
+    return R();
+  }
+
+  hook() {}
+  hook(const hook &hook) { callback = hook.callback; }
+  hook(void *function) { callback = function; }
+  hook(R (*function)(P...)) { callback = function; }
+  template<typename C> hook(R (C::*function)(P...), C *object) { callback = { function, object }; }
+  template<typename C> hook(R (C::*function)(P...) const, C *object) { callback = { function, object }; }
+  template<typename L> hook(const L& function) { callback = function; }
+
+  hook& operator=(const hook& hook) { callback = hook.callback; return *this; }
+};
+
+#if defined(DEBUGGER)
+  #define privileged public
+#else
+  #define privileged private
+#endif
+
+typedef  int1_t int1;
+typedef  int2_t int2;
+typedef  int3_t int3;
+typedef  int4_t int4;
+typedef  int5_t int5;
+typedef  int6_t int6;
+typedef  int7_t int7;
+typedef  int8_t int8;
+typedef  int9_t int9;
+typedef int10_t int10;
+typedef int11_t int11;
+typedef int12_t int12;
+typedef int13_t int13;
+typedef int14_t int14;
+typedef int15_t int15;
+typedef int16_t int16;
+typedef int17_t int17;
+typedef int18_t int18;
+typedef int19_t int19;
+typedef int20_t int20;
+typedef int21_t int21;
+typedef int22_t int22;
+typedef int23_t int23;
+typedef int24_t int24;
+typedef int25_t int25;
+typedef int26_t int26;
+typedef int27_t int27;
+typedef int28_t int28;
+typedef int29_t int29;
+typedef int30_t int30;
+typedef int31_t int31;
+typedef int32_t int32;
+typedef int64_t int64;
+
+typedef  uint1_t uint1;
+typedef  uint2_t uint2;
+typedef  uint3_t uint3;
+typedef  uint4_t uint4;
+typedef  uint5_t uint5;
+typedef  uint6_t uint6;
+typedef  uint7_t uint7;
+typedef  uint8_t uint8;
+typedef  uint9_t uint9;
+typedef uint10_t uint10;
+typedef uint11_t uint11;
+typedef uint12_t uint12;
+typedef uint13_t uint13;
+typedef uint14_t uint14;
+typedef uint15_t uint15;
+typedef uint16_t uint16;
+typedef uint17_t uint17;
+typedef uint18_t uint18;
+typedef uint19_t uint19;
+typedef uint20_t uint20;
+typedef uint21_t uint21;
+typedef uint22_t uint22;
+typedef uint23_t uint23;
+typedef uint24_t uint24;
+typedef uint25_t uint25;
+typedef uint26_t uint26;
+typedef uint27_t uint27;
+typedef uint28_t uint28;
+typedef uint29_t uint29;
+typedef uint30_t uint30;
+typedef uint31_t uint31;
+typedef uint32_t uint32;
+typedef uint_t<33> uint33;
+typedef uint64_t uint64;
+
+typedef varuint_t varuint;
+
+#endif

bsnes/gameboy/Makefile

@@ -1,3 +1,5 @@
+options += gameboy
+
 gameboy_objects := gameboy-interface gameboy-system gameboy-scheduler
 gameboy_objects += gameboy-memory gameboy-cartridge
 gameboy_objects += gameboy-cpu gameboy-apu gameboy-lcd

bsnes/gameboy/cartridge/cartridge.cpp

@@ -30,9 +30,9 @@ void Cartridge::load(System::Revision revision, const string &markup, const uint
   info.romsize = 0;
   info.ramsize = 0;
 
-  BML::Document document(markup);
+  XML::Document document(markup);
 
-  auto &mapperid = document["cartridge"]["mapper"].value;
+  auto &mapperid = document["cartridge"]["mapper"].data;
   if(mapperid == "none" ) info.mapper = Mapper::MBC0;
   if(mapperid == "MBC1" ) info.mapper = Mapper::MBC1;
   if(mapperid == "MBC2" ) info.mapper = Mapper::MBC2;
@@ -42,12 +42,12 @@ void Cartridge::load(System::Revision revision, const string &markup, const uint
   if(mapperid == "HuC1" ) info.mapper = Mapper::HuC1;
   if(mapperid == "HuC3" ) info.mapper = Mapper::HuC3;
 
-  info.rtc = document["cartridge"]["rtc"].exists();
-  info.rumble = document["cartridge"]["rumble"].exists();
+  info.rtc = document["cartridge"]["rtc"].data == "true";
+  info.rumble = document["cartridge"]["rumble"].data == "true";
 
-  info.romsize = hex(document["cartridge"]["rom"]["size"].value);
-  info.ramsize = hex(document["cartridge"]["ram"]["size"].value);
-  info.battery = document["cartridge"]["ram"]["non-volatile"].exists();
+  info.romsize = numeral(document["cartridge"]["rom"]["size"].data);
+  info.ramsize = numeral(document["cartridge"]["ram"]["size"].data);
+  info.battery = document["cartridge"]["ram"]["battery"].data == "true";
 
   switch(info.mapper) { default:
     case Mapper::MBC0:  mapper = &mbc0;  break;

bsnes/gameboy/cartridge/huc1/huc1.cpp

@@ -1,53 +1,54 @@
 #ifdef CARTRIDGE_CPP
 
 uint8 Cartridge::HuC1::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
+  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
     return cartridge.rom_read(addr);
   }
 
-  if(within<0x4000, 0x7fff>(addr)) {
+  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
     return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
-    return 0x00;
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
+    return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
   }
 
   return 0x00;
 }
 
 void Cartridge::HuC1::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
-    ram_enable = (data & 0x0f) == 0x0a;
+  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
+    ram_writable = (data & 0x0f) == 0x0a;
     return;
   }
 
-  if(within<0x2000, 0x3fff>(addr)) {
+  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
     rom_select = data;
+    if(rom_select == 0) rom_select = 1;
     return;
   }
 
-  if(within<0x4000, 0x5fff>(addr)) {
+  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
     ram_select = data;
     return;
   }
 
-  if(within<0x6000, 0x7fff>(addr)) {
-    //unknown purpose
+  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
+    model = data & 0x01;
     return;
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
-    if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
-    return;
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
+    if(ram_writable == false) return;
+    return cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
   }
 }
 
 void Cartridge::HuC1::power() {
-  ram_enable = false;
+  ram_writable = false;
   rom_select = 0x01;
   ram_select = 0x00;
+  model = 0;
 }
 
 #endif

bsnes/gameboy/cartridge/huc1/huc1.hpp

@@ -1,7 +1,8 @@
 struct HuC1 : MMIO {
-  bool ram_enable;   //0000-1fff
-  uint8 rom_select;  //2000-3fff
-  uint8 ram_select;  //4000-5fff
+  bool ram_writable;  //$0000-1fff
+  uint8 rom_select;   //$2000-3fff
+  uint8 ram_select;   //$4000-5fff
+  bool model;         //$6000-7fff
 
   uint8 mmio_read(uint16 addr);
   void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/cartridge/huc3/huc3.cpp

@@ -1,15 +1,15 @@
 #ifdef CARTRIDGE_CPP
 
 uint8 Cartridge::HuC3::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
+  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
     return cartridge.rom_read(addr);
   }
 
-  if(within<0x4000, 0x7fff>(addr)) {
+  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
     return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
     return 0x00;
   }
@@ -18,27 +18,27 @@ uint8 Cartridge::HuC3::mmio_read(uint16 addr) {
 }
 
 void Cartridge::HuC3::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
+  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
     ram_enable = (data & 0x0f) == 0x0a;
     return;
   }
 
-  if(within<0x2000, 0x3fff>(addr)) {
+  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
     rom_select = data;
     return;
   }
 
-  if(within<0x4000, 0x5fff>(addr)) {
+  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
     ram_select = data;
     return;
   }
 
-  if(within<0x6000, 0x7fff>(addr)) {
+  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
     //unknown purpose
     return;
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
     return;
   }

bsnes/gameboy/cartridge/huc3/huc3.hpp

@@ -1,7 +1,7 @@
 struct HuC3 : MMIO {
-  bool ram_enable;   //0000-1fff
-  uint8 rom_select;  //2000-3fff
-  uint8 ram_select;  //4000-5fff
+  bool ram_enable;   //$0000-1fff
+  uint8 rom_select;  //$2000-3fff
+  uint8 ram_select;  //$4000-5fff
 
   uint8 mmio_read(uint16 addr);
   void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/cartridge/mbc0/mbc0.cpp

@@ -1,11 +1,11 @@
 #ifdef CARTRIDGE_CPP
 
 uint8 Cartridge::MBC0::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x7fff>(addr)) {
+  if((addr & 0x8000) == 0x0000) {  //$0000-7fff
     return cartridge.rom_read(addr);
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     return cartridge.ram_read(addr & 0x1fff);
   }
 
@@ -13,7 +13,7 @@ uint8 Cartridge::MBC0::mmio_read(uint16 addr) {
 }
 
 void Cartridge::MBC0::mmio_write(uint16 addr, uint8 data) {
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     cartridge.ram_write(addr & 0x1fff, data);
     return;
   }

bsnes/gameboy/cartridge/mbc1/mbc1.cpp

@@ -1,11 +1,11 @@
 #ifdef CARTRIDGE_CPP
 
 uint8 Cartridge::MBC1::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
+  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
     return cartridge.rom_read(addr);
   }
 
-  if(within<0x4000, 0x7fff>(addr)) {
+  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
     if(mode_select == 0) {
       return cartridge.rom_read((ram_select << 19) | (rom_select << 14) | (addr & 0x3fff));
     } else {
@@ -13,7 +13,7 @@ uint8 Cartridge::MBC1::mmio_read(uint16 addr) {
     }
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) {
       if(mode_select == 0) {
         return cartridge.ram_read(addr & 0x1fff);
@@ -28,27 +28,27 @@ uint8 Cartridge::MBC1::mmio_read(uint16 addr) {
 }
 
 void Cartridge::MBC1::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
+  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
     ram_enable = (data & 0x0f) == 0x0a;
     return;
   }
 
-  if(within<0x2000, 0x3fff>(addr)) {
+  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
     rom_select = (data & 0x1f) + ((data & 0x1f) == 0);
     return;
   }
 
-  if(within<0x4000, 0x5fff>(addr)) {
+  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
     ram_select = data & 0x03;
     return;
   }
 
-  if(within<0x6000, 0x7fff>(addr)) {
+  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
     mode_select = data & 0x01;
     return;
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) {
       if(mode_select == 0) {
         cartridge.ram_write(addr & 0x1fff, data);

bsnes/gameboy/cartridge/mbc1/mbc1.hpp

@@ -1,8 +1,8 @@
 struct MBC1 : MMIO {
-  bool  ram_enable;   //0000-1fff
-  uint8 rom_select;   //2000-3fff
-  uint8 ram_select;   //4000-5fff
-  bool  mode_select;  //6000-7fff
+  bool  ram_enable;   //$0000-1fff
+  uint8 rom_select;   //$2000-3fff
+  uint8 ram_select;   //$4000-5fff
+  bool  mode_select;  //$6000-7fff
 
   uint8 mmio_read(uint16 addr);
   void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/cartridge/mbc2/mbc2.cpp

@@ -1,15 +1,15 @@
 #ifdef CARTRIDGE_CPP
 
 uint8 Cartridge::MBC2::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
+  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
     return cartridge.rom_read(addr);
   }
 
-  if(within<0x4000, 0x7fff>(addr)) {
+  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
     return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
   }
 
-  if(within<0xa000, 0xa1ff>(addr)) {
+  if((addr & 0xee00) == 0xa000) {  //$a000-a1ff
     if(ram_enable) return cartridge.ram_read(addr & 0x1ff);
     return 0x00;
   }
@@ -18,17 +18,17 @@ uint8 Cartridge::MBC2::mmio_read(uint16 addr) {
 }
 
 void Cartridge::MBC2::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
+  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
     if(!(addr & 0x0100)) ram_enable = (data & 0x0f) == 0x0a;
     return;
   }
 
-  if(within<0x2000, 0x3fff>(addr)) {
+  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
     if( (addr & 0x0100)) rom_select = (data & 0x0f) + ((data & 0x0f) == 0);
     return;
   }
 
-  if(within<0xa000, 0xa1ff>(addr)) {
+  if((addr & 0xee00) == 0xa000) {  //$a000-a1ff
     if(ram_enable) cartridge.ram_write(addr & 0x1ff, data & 0x0f);
     return;
   }

bsnes/gameboy/cartridge/mbc2/mbc2.hpp

@@ -1,6 +1,6 @@
 struct MBC2 : MMIO {
-  bool  ram_enable;  //0000-1fff
-  uint8 rom_select;  //2000-3fff
+  bool  ram_enable;  //$0000-1fff
+  uint8 rom_select;  //$2000-3fff
 
   uint8 mmio_read(uint16 addr);
   void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/cartridge/mbc3/mbc3.cpp

@@ -19,15 +19,15 @@ void Cartridge::MBC3::second() {
 }
 
 uint8 Cartridge::MBC3::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
+  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
     return cartridge.rom_read(addr);
   }
 
-  if(within<0x4000, 0x7fff>(addr)) {
+  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
     return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) {
       if(ram_select >= 0x00 && ram_select <= 0x03) {
         return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
@@ -45,22 +45,22 @@ uint8 Cartridge::MBC3::mmio_read(uint16 addr) {
 }
 
 void Cartridge::MBC3::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
+  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
     ram_enable = (data & 0x0f) == 0x0a;
     return;
   }
 
-  if(within<0x2000, 0x3fff>(addr)) {
+  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
     rom_select = (data & 0x7f) + ((data & 0x7f) == 0);
     return;
   }
 
-  if(within<0x4000, 0x5fff>(addr)) {
+  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
     ram_select = data;
     return;
   }
 
-  if(within<0x6000, 0x7fff>(addr)) {
+  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
     if(rtc_latch == 0 && data == 1) {
       rtc_latch_second = rtc_second;
       rtc_latch_minute = rtc_minute;
@@ -72,7 +72,7 @@ void Cartridge::MBC3::mmio_write(uint16 addr, uint8 data) {
     return;
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) {
       if(ram_select >= 0x00 && ram_select <= 0x03) {
         cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);

bsnes/gameboy/cartridge/mbc3/mbc3.hpp

@@ -1,8 +1,8 @@
 struct MBC3 : MMIO {
-  bool  ram_enable;  //0000-1fff
-  uint8 rom_select;  //2000-3fff
-  uint8 ram_select;  //4000-5fff
-  bool rtc_latch;    //6000-7fff
+  bool  ram_enable;  //$0000-1fff
+  uint8 rom_select;  //$2000-3fff
+  uint8 ram_select;  //$4000-5fff
+  bool rtc_latch;    //$6000-7fff
 
   bool rtc_halt;
   unsigned rtc_second;

bsnes/gameboy/cartridge/mbc5/mbc5.cpp

@@ -1,15 +1,15 @@
 #ifdef CARTRIDGE_CPP
 
 uint8 Cartridge::MBC5::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x3fff>(addr)) {
+  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
     return cartridge.rom_read(addr);
   }
 
-  if(within<0x4000, 0x7fff>(addr)) {
+  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
     return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
     return 0x00;
   }
@@ -18,27 +18,27 @@ uint8 Cartridge::MBC5::mmio_read(uint16 addr) {
 }
 
 void Cartridge::MBC5::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
+  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
     ram_enable = (data & 0x0f) == 0x0a;
     return;
   }
 
-  if(within<0x2000, 0x2fff>(addr)) {
+  if((addr & 0xf000) == 0x2000) {  //$2000-2fff
     rom_select = (rom_select & 0x0100) | data;
     return;
   }
 
-  if(within<0x3000, 0x3fff>(addr)) {
+  if((addr & 0xf000) == 0x3000) {  //$3000-3fff
     rom_select = ((data & 1) << 8) | (rom_select & 0x00ff);
     return;
   }
 
-  if(within<0x4000, 0x5fff>(addr)) {
+  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
     ram_select = data & 0x0f;
     return;
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
     return;
   }

bsnes/gameboy/cartridge/mbc5/mbc5.hpp

@@ -1,7 +1,7 @@
 struct MBC5 : MMIO {
-  bool ram_enable;    //0000-1fff
-  uint16 rom_select;  //2000-2fff + 3000-3fff
-  uint8 ram_select;   //4000-5fff
+  bool ram_enable;    //$0000-1fff
+  uint16 rom_select;  //$2000-2fff + $3000-3fff
+  uint8 ram_select;   //$4000-5fff
 
   uint8 mmio_read(uint16 addr);
   void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/cartridge/mmm01/mmm01.cpp

@@ -1,19 +1,19 @@
 #ifdef CARTRIDGE_CPP
 
 uint8 Cartridge::MMM01::mmio_read(uint16 addr) {
-  if(within<0x0000, 0x7fff>(addr)) {
+  if((addr & 0x8000) == 0x0000) {  //$0000-7fff
     if(rom_mode == 0) return cartridge.rom_read(addr);
   }
 
-  if(within<0x0000, 0x3fff>(addr)) {
+  if((addr & 0xc000) == 0x0000) {  //$0000-3fff
     return cartridge.rom_read(0x8000 + (rom_base << 14) + (addr & 0x3fff));
   }
 
-  if(within<0x4000, 0x7fff>(addr)) {
+  if((addr & 0xc000) == 0x4000) {  //$4000-7fff
     return cartridge.rom_read(0x8000 + (rom_base << 14) + (rom_select << 14) + (addr & 0x3fff));
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) return cartridge.ram_read((ram_select << 13) + (addr & 0x1fff));
     return 0x00;
   }
@@ -22,7 +22,7 @@ uint8 Cartridge::MMM01::mmio_read(uint16 addr) {
 }
 
 void Cartridge::MMM01::mmio_write(uint16 addr, uint8 data) {
-  if(within<0x0000, 0x1fff>(addr)) {
+  if((addr & 0xe000) == 0x0000) {  //$0000-1fff
     if(rom_mode == 0) {
       rom_mode = 1;
     } else {
@@ -30,7 +30,7 @@ void Cartridge::MMM01::mmio_write(uint16 addr, uint8 data) {
     }
   }
 
-  if(within<0x2000, 0x3fff>(addr)) {
+  if((addr & 0xe000) == 0x2000) {  //$2000-3fff
     if(rom_mode == 0) {
       rom_base = data & 0x3f;
     } else {
@@ -38,17 +38,17 @@ void Cartridge::MMM01::mmio_write(uint16 addr, uint8 data) {
     }
   }
 
-  if(within<0x4000, 0x5fff>(addr)) {
+  if((addr & 0xe000) == 0x4000) {  //$4000-5fff
     if(rom_mode == 1) {
       ram_select = data;
     }
   }
 
-  if(within<0x6000, 0x7fff>(addr)) {
+  if((addr & 0xe000) == 0x6000) {  //$6000-7fff
     //unknown purpose
   }
 
-  if(within<0xa000, 0xbfff>(addr)) {
+  if((addr & 0xe000) == 0xa000) {  //$a000-bfff
     if(ram_enable) cartridge.ram_write((ram_select << 13) + (addr & 0x1fff), data);
   }
 }

bsnes/gameboy/cartridge/serialization.cpp

@@ -41,9 +41,10 @@ void Cartridge::serialize(serializer &s) {
   s.integer(mmm01.rom_select);
   s.integer(mmm01.ram_select);
 
-  s.integer(huc1.ram_enable);
+  s.integer(huc1.ram_writable);
   s.integer(huc1.rom_select);
   s.integer(huc1.ram_select);
+  s.integer(huc1.model);
 
   s.integer(huc3.ram_enable);
   s.integer(huc3.rom_select);

bsnes/gameboy/gameboy.hpp

@@ -1,6 +1,8 @@
 #ifndef GAMEBOY_HPP
 #define GAMEBOY_HPP
 
+#include <base/base.hpp>
+
 namespace GameBoy {
   namespace Info {
     static const char Name[] = "bgameboy";
@@ -16,65 +18,9 @@ namespace GameBoy {
 */
 
 #include <libco/libco.h>
-
-#include <nall/platform.hpp>
-#include <nall/property.hpp>
-#include <nall/random.hpp>
-#include <nall/serializer.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-#include <nall/varint.hpp>
-using namespace nall;
+#include <nall/gameboy/cartridge.hpp>
 
 namespace GameBoy {
-  typedef int8_t  int8;
-  typedef int16_t int16;
-  typedef int32_t int32;
-  typedef int64_t int64;
-
-  typedef uint8_t  uint8;
-  typedef uint16_t uint16;
-  typedef uint32_t uint32;
-  typedef uint64_t uint64;
-
-  typedef uint_t< 1> uint1;
-  typedef uint_t< 2> uint2;
-  typedef uint_t< 3> uint3;
-  typedef uint_t< 4> uint4;
-  typedef uint_t< 5> uint5;
-  typedef uint_t< 6> uint6;
-  typedef uint_t< 7> uint7;
-
-  typedef uint_t< 9> uint9;
-  typedef uint_t<10> uint10;
-  typedef uint_t<11> uint11;
-  typedef uint_t<12> uint12;
-  typedef uint_t<13> uint13;
-  typedef uint_t<14> uint14;
-  typedef uint_t<15> uint15;
-
-  typedef uint_t<17> uint17;
-  typedef uint_t<18> uint18;
-  typedef uint_t<19> uint19;
-  typedef uint_t<20> uint20;
-  typedef uint_t<21> uint21;
-  typedef uint_t<22> uint22;
-  typedef uint_t<23> uint23;
-  typedef uint_t<24> uint24;
-  typedef uint_t<25> uint25;
-  typedef uint_t<26> uint26;
-  typedef uint_t<27> uint27;
-  typedef uint_t<28> uint28;
-  typedef uint_t<29> uint29;
-  typedef uint_t<30> uint30;
-  typedef uint_t<31> uint31;
-
-  template<uint16 lo, uint16 hi>
-  alwaysinline bool within(uint16 addr) {
-    static const uint16 mask = ~(hi ^ lo);
-    return (addr & mask) == lo;
-  }
-
   struct Processor {
     cothread_t thread;
     unsigned frequency;

bsnes/gameboy/lcd/cgb.cpp

@@ -140,7 +140,7 @@ void LCD::cgb_render_ob() {
     unsigned n = sprite[s] << 2;
     unsigned sy = oam[n + 0] - 16;
     unsigned sx = oam[n + 1] -  8;
-    unsigned tile = oam[n + 2];
+    unsigned tile = oam[n + 2] & ~status.ob_size;
     unsigned attr = oam[n + 3];
 
     sy = status.ly - sy;

bsnes/gameboy/lcd/dmg.cpp

@@ -109,7 +109,7 @@ void LCD::dmg_render_ob() {
     unsigned n = sprite[s] << 2;
     unsigned sy = oam[n + 0] - 16;
     unsigned sx = oam[n + 1] -  8;
-    unsigned tile = oam[n + 2];
+    unsigned tile = oam[n + 2] & ~status.ob_size;
     unsigned attr = oam[n + 3];
 
     sy = status.ly - sy;

bsnes/nall/Makefile

@@ -41,6 +41,9 @@ ifeq ($(compiler),)
   endif
 endif
 
+c := $(compiler) -std=gnu99
+cpp := $(subst cc,++,$(compiler)) -std=gnu++0x
+
 ifeq ($(prefix),)
   prefix := /usr/local
 endif

bsnes/nall/any.hpp

@@ -2,17 +2,15 @@
 #define NALL_ANY_HPP
 
 #include <typeinfo>
-#include <type_traits>
-#include <nall/static.hpp>
+#include <nall/type_traits.hpp>
 
 namespace nall {
-  class any {
-  public:
+  struct any {
     bool empty() const { return container; }
     const std::type_info& type() const { return container ? container->type() : typeid(void); }
 
     template<typename T> any& operator=(const T& value_) {
-      typedef typename static_if<
+      typedef typename type_if<
         std::is_array<T>::value,
         typename std::remove_extent<typename std::add_const<T>::type>::type*,
         T

bsnes/nall/array.hpp

@@ -4,138 +4,286 @@
 #include <stdlib.h>
 #include <algorithm>
 #include <initializer_list>
-#include <type_traits>
 #include <utility>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
+#include <nall/sort.hpp>
+#include <nall/type_traits.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
-  //dynamic vector array
-  //neither constructor nor destructor is ever invoked;
-  //thus, this should only be used for POD objects.
-  template<typename T> class array {
-  protected:
-    T *pool;
-    unsigned poolsize, buffersize;
 
-  public:
-    unsigned size() const { return buffersize; }
-    unsigned capacity() const { return poolsize; }
+template<typename T, typename Enable = void> struct array;
 
-    void reset() {
-      if(pool) free(pool);
-      pool = nullptr;
-      poolsize = 0;
-      buffersize = 0;
+//non-reference array
+//===================
+
+template<typename T> struct array<T, typename std::enable_if<!std::is_reference<T>::value>::type> {
+  struct exception_out_of_bounds{};
+
+protected:
+  T *pool;
+  unsigned poolsize, objectsize;
+
+public:
+  unsigned size() const { return objectsize; }
+  unsigned capacity() const { return poolsize; }
+
+  void reset() {
+    if(pool) free(pool);
+    pool = nullptr;
+    poolsize = 0;
+    objectsize = 0;
+  }
+
+  void reserve(unsigned newsize) {
+    if(newsize == poolsize) return;
+
+    pool = (T*)realloc(pool, newsize * sizeof(T));
+    poolsize = newsize;
+    objectsize = min(objectsize, newsize);
+  }
+
+  void resize(unsigned newsize) {
+    if(newsize > poolsize) reserve(bit::round(newsize));  //round reserve size up to power of 2
+    objectsize = newsize;
+  }
+
+  T* get(unsigned minsize = 0) {
+    if(minsize > objectsize) resize(minsize);
+    return pool;
+  }
+
+  void append(const T data) {
+    operator()(objectsize) = data;
+  }
+
+  void append(const T data[], unsigned length) {
+    for(unsigned n = 0; n < length; n++) operator()(objectsize) = data[n];
+  }
+
+  void remove() {
+    if(size > 0) resize(size - 1);  //remove last element only
+  }
+
+  void remove(unsigned index, unsigned count = 1) {
+    for(unsigned i = index; count + i < objectsize; i++) {
+      pool[i] = pool[count + i];
     }
+    if(count + index >= objectsize) resize(index);  //every element >= index was removed
+    else resize(objectsize - count);
+  }
 
-    void reserve(unsigned newsize) {
-      if(newsize == poolsize) return;
+  void sort() {
+    nall::sort(pool, objectsize);
+  }
 
-      pool = (T*)realloc(pool, newsize * sizeof(T));
-      poolsize = newsize;
-      buffersize = min(buffersize, newsize);
+  template<typename Comparator> void sort(const Comparator &lessthan) {
+    nall::sort(pool, objectsize, lessthan);
+  }
+
+  optional<unsigned> find(const T data) {
+    for(unsigned n = 0; n < size(); n++) if(pool[n] == data) return { true, n };
+    return { false, 0u };
+  }
+
+  void clear() {
+    memset(pool, 0, objectsize * sizeof(T));
+  }
+
+  array() : pool(nullptr), poolsize(0), objectsize(0) {
+  }
+
+  array(std::initializer_list<T> list) : pool(nullptr), poolsize(0), objectsize(0) {
+    for(auto &data : list) append(data);
+  }
+
+  ~array() {
+    reset();
+  }
+
+  //copy
+  array& operator=(const array &source) {
+    if(pool) free(pool);
+    objectsize = source.objectsize;
+    poolsize = source.poolsize;
+    pool = (T*)malloc(sizeof(T) * poolsize);            //allocate entire pool size,
+    memcpy(pool, source.pool, sizeof(T) * objectsize);  //... but only copy used pool objects
+    return *this;
+  }
+
+  array(const array &source) : pool(nullptr), poolsize(0), objectsize(0) {
+    operator=(source);
+  }
+
+  //move
+  array& operator=(array &&source) {
+    if(pool) free(pool);
+    pool = source.pool;
+    poolsize = source.poolsize;
+    objectsize = source.objectsize;
+    source.pool = nullptr;
+    source.reset();
+    return *this;
+  }
+
+  array(array &&source) : pool(nullptr), poolsize(0), objectsize(0) {
+    operator=(std::move(source));
+  }
+
+  //access
+  inline T& operator[](unsigned position) {
+    if(position >= objectsize) throw exception_out_of_bounds();
+    return pool[position];
+  }
+
+  inline const T& operator[](unsigned position) const {
+    if(position >= objectsize) throw exception_out_of_bounds();
+    return pool[position];
+  }
+
+  inline T& operator()(unsigned position) {
+    if(position >= objectsize) resize(position + 1);
+    return pool[position];
+  }
+
+  inline const T& operator()(unsigned position, const T& data) {
+    if(position >= objectsize) return data;
+    return pool[position];
+  }
+
+  //iteration
+  T* begin() { return &pool[0]; }
+  T* end() { return &pool[objectsize]; }
+  const T* begin() const { return &pool[0]; }
+  const T* end() const { return &pool[objectsize]; }
+};
+
+//reference array
+//===============
+
+template<typename TR> struct array<TR, typename std::enable_if<std::is_reference<TR>::value>::type> {
+  struct exception_out_of_bounds{};
+
+protected:
+  typedef typename std::remove_reference<TR>::type T;
+  T **pool;
+  unsigned poolsize, objectsize;
+
+public:
+  unsigned size() const { return objectsize; }
+  unsigned capacity() const { return poolsize; }
+
+  void reset() {
+    if(pool) free(pool);
+    pool = nullptr;
+    poolsize = 0;
+    objectsize = 0;
+  }
+
+  void reserve(unsigned newsize) {
+    if(newsize == poolsize) return;
+
+    pool = (T**)realloc(pool, sizeof(T*) * newsize);
+    poolsize = newsize;
+    objectsize = min(objectsize, newsize);
+  }
+
+  void resize(unsigned newsize) {
+    if(newsize > poolsize) reserve(bit::round(newsize));
+    objectsize = newsize;
+  }
+
+  template<typename... Args>
+  bool append(T& data, Args&&... args) {
+    bool result = append(data);
+    append(std::forward<Args>(args)...);
+    return result;
+  }
+
+  bool append(T& data) {
+    if(find(data)) return false;
+    unsigned offset = objectsize++;
+    if(offset >= poolsize) resize(offset + 1);
+    pool[offset] = &data;
+    return true;
+  }
+
+  bool remove(T& data) {
+    if(auto position = find(data)) {
+      for(signed i = position(); i < objectsize - 1; i++) pool[i] = pool[i + 1];
+      resize(objectsize - 1);
+      return true;
     }
+    return false;
+  }
 
-    void resize(unsigned newsize) {
-      if(newsize > poolsize) reserve(bit::round(newsize));  //round reserve size up to power of 2
-      buffersize = newsize;
-    }
+  optional<unsigned> find(const T& data) {
+    for(unsigned n = 0; n < objectsize; n++) if(pool[n] == &data) return { true, n };
+    return { false, 0u };
+  }
 
-    T* get(unsigned minsize = 0) {
-      if(minsize > buffersize) resize(minsize);
-      if(minsize > buffersize) throw "array[] out of bounds";
-      return pool;
-    }
+  template<typename... Args> array(Args&&... args) : pool(nullptr), poolsize(0), objectsize(0) {
+    construct(std::forward<Args>(args)...);
+  }
 
-    void append(const T data) {
-      operator[](buffersize) = data;
-    }
+  ~array() {
+    reset();
+  }
 
-    void append(const T data[], unsigned length) {
-      for(unsigned n = 0; n < length; n++) operator[](buffersize) = data[n];
-    }
+  array& operator=(const array &source) {
+    if(pool) free(pool);
+    objectsize = source.objectsize;
+    poolsize = source.poolsize;
+    pool = (T**)malloc(sizeof(T*) * poolsize);
+    memcpy(pool, source.pool, sizeof(T*) * objectsize);
+    return *this;
+  }
 
-    void remove() {
-      if(size > 0) resize(size - 1);  //remove last element only
-    }
+  array& operator=(const array &&source) {
+    if(pool) free(pool);
+    pool = source.pool;
+    poolsize = source.poolsize;
+    objectsize = source.objectsize;
+    source.pool = nullptr;
+    source.reset();
+    return *this;
+  }
 
-    void remove(unsigned index, unsigned count = 1) {
-      for(unsigned i = index; count + i < buffersize; i++) {
-        pool[i] = pool[count + i];
-      }
-      if(count + index >= buffersize) resize(index);  //every element >= index was removed
-      else resize(buffersize - count);
-    }
+  T& operator[](unsigned position) const {
+    if(position >= objectsize) throw exception_out_of_bounds();
+    return *pool[position];
+  }
 
-    optional<unsigned> find(const T data) {
-      for(unsigned i = 0; i < size(); i++) if(pool[i] == data) return { true, i };
-      return { false, 0 };
-    }
-
-    void clear() {
-      memset(pool, 0, buffersize * sizeof(T));
-    }
-
-    array() : pool(nullptr), poolsize(0), buffersize(0) {
-    }
-
-    array(std::initializer_list<T> list) : pool(nullptr), poolsize(0), buffersize(0) {
-      for(const T *p = list.begin(); p != list.end(); ++p) append(*p);
-    }
-
-    ~array() {
-      reset();
-    }
-
-    //copy
-    array& operator=(const array &source) {
-      if(pool) free(pool);
-      buffersize = source.buffersize;
-      poolsize = source.poolsize;
-      pool = (T*)malloc(sizeof(T) * poolsize);            //allocate entire pool size,
-      memcpy(pool, source.pool, sizeof(T) * buffersize);  //... but only copy used pool objects
-      return *this;
-    }
-
-    array(const array &source) : pool(nullptr), poolsize(0), buffersize(0) {
-      operator=(source);
-    }
-
-    //move
-    array& operator=(array &&source) {
-      if(pool) free(pool);
-      pool = source.pool;
-      poolsize = source.poolsize;
-      buffersize = source.buffersize;
-      source.pool = nullptr;
-      source.reset();
-      return *this;
-    }
-
-    array(array &&source) : pool(nullptr), poolsize(0), buffersize(0) {
-      operator=(std::move(source));
-    }
-
-    //index
-    inline T& operator[](unsigned index) {
-      if(index >= buffersize) resize(index + 1);
-      if(index >= buffersize) throw "array[] out of bounds";
-      return pool[index];
-    }
-
-    inline const T& operator[](unsigned index) const {
-      if(index >= buffersize) throw "array[] out of bounds";
-      return pool[index];
-    }
-
-    //iteration
-    T* begin() { return &pool[0]; }
-    T* end() { return &pool[buffersize]; }
-    const T* begin() const { return &pool[0]; }
-    const T* end() const { return &pool[buffersize]; }
+  //iteration
+  struct iterator {
+    bool operator!=(const iterator &source) const { return position != source.position; }
+    T& operator*() { return source.operator[](position); }
+    iterator& operator++() { position++; return *this; }
+    iterator(const array &source, unsigned position) : source(source), position(position) {}
+  private:
+    const array &source;
+    unsigned position;
   };
+
+  iterator begin() { return iterator(*this, 0); }
+  iterator end() { return iterator(*this, objectsize); }
+  const iterator begin() const { return iterator(*this, 0); }
+  const iterator end() const { return iterator(*this, objectsize); }
+
+private:
+  void construct() {
+  }
+
+  void construct(const array& source) { operator=(source); }
+  void construct(const array&& source) { operator=(std::move(source)); }
+
+  template<typename... Args> void construct(T& data, Args&&... args) {
+    append(data);
+    construct(std::forward<Args>(args)...);
+  }
+};
+
 }
 
 #endif

bsnes/nall/atoi.hpp

@@ -79,6 +79,19 @@ constexpr inline uintmax_t hex(const char *s) {
   );
 }
 
+constexpr inline intmax_t numeral(const char *s) {
+  return (
+    *s == '0' && *(s + 1) == 'X' ? hex_(s + 2) :
+    *s == '0' && *(s + 1) == 'x' ? hex_(s + 2) :
+    *s == '0' && *(s + 1) == 'B' ? binary_(s + 2) :
+    *s == '0' && *(s + 1) == 'b' ? binary_(s + 2) :
+    *s == '0' ? octal_(s + 1) :
+    *s == '+' ? +decimal_(s + 1) :
+    *s == '-' ? -decimal_(s + 1) :
+    decimal_(s)
+  );
+}
+
 inline double fp(const char *s) {
   return atof(s);
 }

bsnes/nall/bit.hpp

@@ -2,45 +2,56 @@
 #define NALL_BIT_HPP
 
 namespace nall {
-  template<int bits> constexpr inline unsigned uclamp(const unsigned x) {
-    enum { y = (1U << (bits - 1)) + ((1U << (bits - 1)) - 1) };
+  template<unsigned bits>
+  constexpr inline uintmax_t uclamp(const uintmax_t x) {
+    enum : uintmax_t { b = 1ull << (bits - 1), y = b * 2 - 1 };
     return y + ((x - y) & -(x < y));  //min(x, y);
   }
 
-  template<int bits> constexpr inline unsigned uclip(const unsigned x) {
-    enum { m = (1U << (bits - 1)) + ((1U << (bits - 1)) - 1) };
+  template<unsigned bits>
+  constexpr inline uintmax_t uclip(const uintmax_t x) {
+    enum : uintmax_t { b = 1ull << (bits - 1), m = b * 2 - 1 };
     return (x & m);
   }
 
-  template<int bits> constexpr inline signed sclamp(const signed x) {
-    enum { b = 1U << (bits - 1), m = (1U << (bits - 1)) - 1 };
+  template<unsigned bits>
+  constexpr inline intmax_t sclamp(const intmax_t x) {
+    enum : intmax_t { b = 1ull << (bits - 1), m = b - 1 };
     return (x > m) ? m : (x < -b) ? -b : x;
   }
 
-  template<int bits> constexpr inline signed sclip(const signed x) {
-    enum { b = 1U << (bits - 1), m = (1U << bits) - 1 };
+  template<unsigned bits>
+  constexpr inline intmax_t sclip(const intmax_t x) {
+    enum : uintmax_t { b = 1ull << (bits - 1), m = b * 2 - 1 };
     return ((x & m) ^ b) - b;
   }
 
   namespace bit {
     //lowest(0b1110) == 0b0010
-    template<typename T> constexpr inline T lowest(const T x) {
+    constexpr inline uintmax_t lowest(const uintmax_t x) {
       return x & -x;
     }
 
     //clear_lowest(0b1110) == 0b1100
-    template<typename T> constexpr inline T clear_lowest(const T x) {
+    constexpr inline uintmax_t clear_lowest(const uintmax_t x) {
       return x & (x - 1);
     }
 
     //set_lowest(0b0101) == 0b0111
-    template<typename T> constexpr inline T set_lowest(const T x) {
+    constexpr inline uintmax_t set_lowest(const uintmax_t x) {
       return x | (x + 1);
     }
 
+    //count number of bits set in a byte
+    inline unsigned count(uintmax_t x) {
+      unsigned count = 0;
+      do count += x & 1; while(x >>= 1);
+      return count;
+    }
+
     //round up to next highest single bit:
     //round(15) == 16, round(16) == 16, round(17) == 32
-    inline unsigned round(unsigned x) {
+    inline uintmax_t round(uintmax_t x) {
       if((x & (x - 1)) == 0) return x;
       while(x & (x - 1)) x &= x - 1;
       return x << 1;

bsnes/nall/compositor.hpp

@@ -8,11 +8,49 @@ namespace nall {
 struct compositor {
   inline static bool enabled();
   inline static bool enable(bool status);
+
+  #if defined(PLATFORM_X)
+  enum class Compositor : unsigned { Unknown, Metacity, Xfwm4 };
+  inline static Compositor detect();
+
+  inline static bool enabled_metacity();
+  inline static bool enable_metacity(bool status);
+
+  inline static bool enabled_xfwm4();
+  inline static bool enable_xfwm4(bool status);
+  #endif
 };
 
 #if defined(PLATFORM_X)
 
-bool compositor::enabled() {
+//Metacity
+
+bool compositor::enabled_metacity() {
+  FILE *fp = popen("gconftool-2 --get /apps/metacity/general/compositing_manager", "r");
+  if(fp == 0) return false;
+
+  char buffer[512];
+  if(fgets(buffer, sizeof buffer, fp) == 0) return false;
+
+  if(!memcmp(buffer, "true", 4)) return true;
+  return false;
+}
+
+bool compositor::enable_metacity(bool status) {
+  FILE *fp;
+  if(status) {
+    fp = popen("gconftool-2 --set --type bool /apps/metacity/general/compositing_manager true", "r");
+  } else {
+    fp = popen("gconftool-2 --set --type bool /apps/metacity/general/compositing_manager false", "r");
+  }
+  if(fp == 0) return false;
+  pclose(fp);
+  return true;
+}
+
+//Xfwm4
+
+bool compositor::enabled_xfwm4() {
   FILE *fp = popen("xfconf-query -c xfwm4 -p '/general/use_compositing'", "r");
   if(fp == 0) return false;
 
@@ -23,7 +61,7 @@ bool compositor::enabled() {
   return false;
 }
 
-bool compositor::enable(bool status) {
+bool compositor::enable_xfwm4(bool status) {
   FILE *fp;
   if(status) {
     fp = popen("xfconf-query -c xfwm4 -p '/general/use_compositing' -t 'bool' -s 'true'", "r");
@@ -35,6 +73,41 @@ bool compositor::enable(bool status) {
   return true;
 }
 
+//General
+
+compositor::Compositor compositor::detect() {
+  Compositor result = Compositor::Unknown;
+
+  FILE *fp;
+  char buffer[512];
+
+  fp = popen("pidof metacity", "r");
+  if(fp && fgets(buffer, sizeof buffer, fp)) result = Compositor::Metacity;
+  pclose(fp);
+
+  fp = popen("pidof xfwm4", "r");
+  if(fp && fgets(buffer, sizeof buffer, fp)) result = Compositor::Xfwm4;
+  pclose(fp);
+
+  return result;
+}
+
+bool compositor::enabled() {
+  switch(detect()) {
+  case Compositor::Metacity: return enabled_metacity();
+  case Compositor::Xfwm4: return enabled_xfwm4();
+  default: return false;
+  }
+}
+
+bool compositor::enable(bool status) {
+  switch(detect()) {
+  case Compositor::Metacity: return enable_metacity(status);
+  case Compositor::Xfwm4: return enable_xfwm4(status);
+  default: return false;
+  }
+}
+
 #elif defined(PLATFORM_WINDOWS)
 
 bool compositor::enabled() {

bsnes/nall/config.hpp

@@ -32,7 +32,7 @@ namespace nall {
       string desc;
       type_t type;
 
-      string get() const {
+      inline string get() const {
         switch(type) {
           case boolean_t:  return { *(bool*)data };
           case signed_t:   return { *(signed*)data };
@@ -43,7 +43,7 @@ namespace nall {
         return "???";
       }
 
-      void set(string s) {
+      inline void set(string s) {
         switch(type) {
           case boolean_t:  *(bool*)data = (s == "true");     break;
           case signed_t:   *(signed*)data = integer(s);      break;
@@ -53,24 +53,27 @@ namespace nall {
         }
       }
     };
-    linear_vector<item_t> list;
+    vector<item_t> list;
 
     template<typename T>
-    void attach(T &data, const char *name, const char *desc = "") {
-      unsigned n = list.size();
-      list[n].data = (uintptr_t)&data;
-      list[n].name = name;
-      list[n].desc = desc;
-
-      if(configuration_traits::is_boolean<T>::value) list[n].type = boolean_t;
-      else if(configuration_traits::is_signed<T>::value) list[n].type = signed_t;
-      else if(configuration_traits::is_unsigned<T>::value) list[n].type = unsigned_t;
-      else if(configuration_traits::is_double<T>::value) list[n].type = double_t;
-      else if(configuration_traits::is_string<T>::value) list[n].type = string_t;
-      else list[n].type = unknown_t;
+    inline void append(T &data, const char *name, const char *desc = "") {
+      item_t item = { (uintptr_t)&data, name, desc };
+      if(configuration_traits::is_boolean<T>::value) item.type = boolean_t;
+      else if(configuration_traits::is_signed<T>::value) item.type = signed_t;
+      else if(configuration_traits::is_unsigned<T>::value) item.type = unsigned_t;
+      else if(configuration_traits::is_double<T>::value) item.type = double_t;
+      else if(configuration_traits::is_string<T>::value) item.type = string_t;
+      else item.type = unknown_t;
+      list.append(item);
     }
 
-    virtual bool load(const string &filename) {
+    //deprecated
+    template<typename T>
+    inline void attach(T &data, const char *name, const char *desc = "") {
+      append(data, name, desc);
+    }
+
+    inline virtual bool load(const string &filename) {
       string data;
       if(data.readfile(filename) == true) {
         data.replace("\r", "");
@@ -100,7 +103,7 @@ namespace nall {
       }
     }
 
-    virtual bool save(const string &filename) const {
+    inline virtual bool save(const string &filename) const {
       file fp;
       if(fp.open(filename, file::mode::write)) {
         for(unsigned i = 0; i < list.size(); i++) {

bsnes/nall/directory.hpp

@@ -56,7 +56,7 @@ struct directory {
       }
       FindClose(handle);
     }
-    if(list.size() > 0) sort(&list[0], list.size());
+    if(list.size() > 0) list.sort();
     for(auto &name : list) name.append("/");  //must append after sorting
     return list;
   }
@@ -83,7 +83,7 @@ struct directory {
       }
       FindClose(handle);
     }
-    if(list.size() > 0) sort(&list[0], list.size());
+    if(list.size() > 0) list.sort();
     return list;
   }
 
@@ -116,7 +116,7 @@ struct directory {
       }
       closedir(dp);
     }
-    if(list.size() > 0) sort(&list[0], list.size());
+    if(list.size() > 0) list.sort();
     for(auto &name : list) name.append("/");  //must append after sorting
     return list;
   }
@@ -136,7 +136,7 @@ struct directory {
       }
       closedir(dp);
     }
-    if(list.size() > 0) sort(&list[0], list.size());
+    if(list.size() > 0) list.sort();
     return list;
   }
 

bsnes/nall/file.hpp

@@ -134,12 +134,12 @@ namespace nall {
       file_offset = req_offset;
     }
 
-    int offset() {
+    int offset() const {
       if(!fp) return -1;  //file not open
       return file_offset;
     }
 
-    int size() {
+    int size() const {
       if(!fp) return -1;  //file not open
       return file_size;
     }
@@ -194,7 +194,7 @@ namespace nall {
       }
     }
 
-    bool open() {
+    bool open() const {
       return fp;
     }
 

bsnes/nall/filemap.hpp

@@ -1,6 +1,7 @@
 #ifndef NALL_FILEMAP_HPP
 #define NALL_FILEMAP_HPP
 
+#include <nall/file.hpp>
 #include <nall/stdint.hpp>
 #include <nall/windows/utf8.hpp>
 

bsnes/nall/gameboy/cartridge.hpp

@@ -100,6 +100,16 @@ GameBoyCartridge::GameBoyCartridge(uint8_t *romdata, unsigned romsize) {
 
   if(info.mapper == "MBC2") info.ramsize = 512;  //512 x 4-bit
 
+  markup.append(
+    "<?xml version='1.0' encoding='UTF-8'?>\n",
+    "<cartridge mapper='", info.mapper, "' rtc='", info.rtc, "' rumble='", info.rumble, "'>\n",
+    "  <rom size='0x", hex(romsize), "'/>\n");
+  if(info.ramsize > 0) markup.append(
+    "  <ram size='0x", hex(info.ramsize), "' battery='", info.battery, "'/>\n");
+  markup.append(
+    "</cartridge>\n");
+
+/*
   markup.append("cartridge mapper=", info.mapper);
   if(info.rtc) markup.append(" rtc");
   if(info.rumble) markup.append(" rumble");
@@ -109,6 +119,7 @@ GameBoyCartridge::GameBoyCartridge(uint8_t *romdata, unsigned romsize) {
 
   if(info.ramsize > 0)
   markup.append("\t" "ram size=", hex(info.ramsize), info.battery ? " non-volatile\n" : "\n");
+*/
 }
 
 }

bsnes/nall/gzip.hpp

@@ -11,11 +11,11 @@ struct gzip {
   uint8_t *data;
   unsigned size;
 
-  bool decompress(const string &filename);
-  bool decompress(const uint8_t *data, unsigned size);
+  inline bool decompress(const string &filename);
+  inline bool decompress(const uint8_t *data, unsigned size);
 
-  gzip();
-  ~gzip();
+  inline gzip();
+  inline ~gzip();
 };
 
 bool gzip::decompress(const string &filename) {

bsnes/nall/http.hpp

@@ -117,7 +117,7 @@ struct http {
         }
       }
     } else if(auto position = header.iposition("\r\nContent-Length: ")) {
-      unsigned length = decimal((const char*)header + position() + 16);
+      unsigned length = decimal((const char*)header + position() + 18);
       while(length) {
         char buffer[256];
         int packetlength = recv(serversocket, buffer, min(256, length), 0);

bsnes/nall/image.hpp

@@ -0,0 +1,465 @@
+#ifndef NALL_IMAGE_HPP
+#define NALL_IMAGE_HPP
+
+#include <nall/bmp.hpp>
+#include <nall/filemap.hpp>
+#include <nall/interpolation.hpp>
+#include <nall/png.hpp>
+#include <nall/stdint.hpp>
+#include <algorithm>
+
+namespace nall {
+
+struct image {
+  uint8_t *data;
+  unsigned width;
+  unsigned height;
+  unsigned pitch;
+
+  bool endian;  //0 = little, 1 = big
+  unsigned depth;
+  unsigned stride;
+
+  struct Channel {
+    uint64_t mask;
+    unsigned depth;
+    unsigned shift;
+  } alpha, red, green, blue;
+
+  typedef double (*interpolation)(double, double, double, double, double);
+  static inline unsigned bitDepth(uint64_t color);
+  static inline unsigned bitShift(uint64_t color);
+  static inline uint64_t normalize(uint64_t color, unsigned sourceDepth, unsigned targetDepth);
+
+  inline image& operator=(const image &source);
+  inline image& operator=(image &&source);
+  inline image(const image &source);
+  inline image(image &&source);
+  inline image(bool endian, unsigned depth, uint64_t alphaMask, uint64_t redMask, uint64_t greenMask, uint64_t blueMask);
+  inline image();
+  inline ~image();
+
+  inline uint64_t read(const uint8_t *data) const;
+  inline void write(uint8_t *data, uint64_t value) const;
+
+  inline void free();
+  inline void allocate(unsigned width, unsigned height);
+  inline void clear(uint64_t color);
+  inline bool load(const string &filename);
+//inline bool loadBMP(const uint8_t *data, unsigned size);
+  inline bool loadPNG(const uint8_t *data, unsigned size);
+  inline void scale(unsigned width, unsigned height, interpolation op);
+  inline void transform(bool endian, unsigned depth, uint64_t alphaMask, uint64_t redMask, uint64_t greenMask, uint64_t blueMask);
+  inline void alphaBlend(uint64_t alphaColor);
+
+protected:
+  inline uint64_t interpolate(double mu, const uint64_t *s, interpolation op);
+  inline void scaleX(unsigned width, interpolation op);
+  inline void scaleY(unsigned height, interpolation op);
+  inline bool loadBMP(const string &filename);
+  inline bool loadPNG(const string &filename);
+};
+
+//static
+
+unsigned image::bitDepth(uint64_t color) {
+  unsigned depth = 0;
+  if(color) while((color & 1) == 0) color >>= 1;
+  while((color & 1) == 1) { color >>= 1; depth++; }
+  return depth;
+}
+
+unsigned image::bitShift(uint64_t color) {
+  unsigned shift = 0;
+  if(color) while((color & 1) == 0) { color >>= 1; shift++; }
+  return shift;
+}
+
+uint64_t image::normalize(uint64_t color, unsigned sourceDepth, unsigned targetDepth) {
+  while(sourceDepth < targetDepth) {
+    color = (color << sourceDepth) | color;
+    sourceDepth += sourceDepth;
+  }
+  if(targetDepth < sourceDepth) color >>= (sourceDepth - targetDepth);
+  return color;
+}
+
+//public
+
+image& image::operator=(const image &source) {
+  free();
+
+  width = source.width;
+  height = source.height;
+  pitch = source.pitch;
+
+  endian = source.endian;
+  stride = source.stride;
+
+  alpha = source.alpha;
+  red = source.red;
+  green = source.green;
+  blue = source.blue;
+
+  data = new uint8_t[width * height * stride];
+  memcpy(data, source.data, width * height * stride);
+  return *this;
+}
+
+image& image::operator=(image &&source) {
+  width = source.width;
+  height = source.height;
+  pitch = source.pitch;
+
+  endian = source.endian;
+  stride = source.stride;
+
+  alpha = source.alpha;
+  red = source.red;
+  green = source.green;
+  blue = source.blue;
+
+  data = source.data;
+  source.data = nullptr;
+  return *this;
+}
+
+image::image(const image &source) : data(nullptr) {
+  operator=(source);
+}
+
+image::image(image &&source) : data(nullptr) {
+  operator=(std::forward<image>(source));
+}
+
+image::image(bool endian, unsigned depth, uint64_t alphaMask, uint64_t redMask, uint64_t greenMask, uint64_t blueMask) : data(nullptr) {
+  width = 0, height = 0, pitch = 0;
+
+  this->endian = endian;
+  this->depth = depth;
+  this->stride = (depth / 8) + ((depth & 7) > 0);
+
+  alpha.mask = alphaMask, red.mask = redMask, green.mask = greenMask, blue.mask = blueMask;
+  alpha.depth = bitDepth(alpha.mask), alpha.shift = bitShift(alpha.mask);
+  red.depth = bitDepth(red.mask), red.shift = bitShift(red.mask);
+  green.depth = bitDepth(green.mask), green.shift = bitShift(green.mask);
+  blue.depth = bitDepth(blue.mask), blue.shift = bitShift(blue.mask);
+}
+
+image::image() : data(nullptr) {
+  width = 0, height = 0, pitch = 0;
+
+  this->endian = 0;
+  this->depth = 32;
+  this->stride = 4;
+
+  alpha.mask = 255u << 24, red.mask = 255u << 16, green.mask = 255u << 8, blue.mask = 255u << 0;
+  alpha.depth = bitDepth(alpha.mask), alpha.shift = bitShift(alpha.mask);
+  red.depth = bitDepth(red.mask), red.shift = bitShift(red.mask);
+  green.depth = bitDepth(green.mask), green.shift = bitShift(green.mask);
+  blue.depth = bitDepth(blue.mask), blue.shift = bitShift(blue.mask);
+}
+
+image::~image() {
+  free();
+}
+
+uint64_t image::read(const uint8_t *data) const {
+  uint64_t result = 0;
+  if(endian == 0) {
+    for(signed n = stride - 1; n >= 0; n--) result = (result << 8) | data[n];
+  } else {
+    for(signed n = 0; n < stride; n++) result = (result << 8) | data[n];
+  }
+  return result;
+}
+
+void image::write(uint8_t *data, uint64_t value) const {
+  if(endian == 0) {
+    for(signed n = 0; n < stride; n++) { data[n] = value; value >>= 8; }
+  } else {
+    for(signed n = stride - 1; n >= 0; n--) { data[n] = value; value >>= 8; }
+  }
+}
+
+void image::free() {
+  if(data) delete[] data;
+  data = nullptr;
+}
+
+void image::allocate(unsigned width, unsigned height) {
+  if(data != nullptr && this->width == width && this->height == height) return;
+  free();
+  data = new uint8_t[width * height * stride]();
+  pitch = width * stride;
+  this->width = width;
+  this->height = height;
+}
+
+void image::clear(uint64_t color) {
+  uint8_t *dp = data;
+  for(unsigned n = 0; n < width * height; n++) {
+    write(dp, color);
+    dp += stride;
+  }
+}
+
+bool image::load(const string &filename) {
+  if(loadBMP(filename) == true) return true;
+  if(loadPNG(filename) == true) return true;
+  return false;
+}
+
+void image::scale(unsigned outputWidth, unsigned outputHeight, interpolation op) {
+  if(width != outputWidth) scaleX(outputWidth, op);
+  if(height != outputHeight) scaleY(outputHeight, op);
+}
+
+void image::transform(bool outputEndian, unsigned outputDepth, uint64_t outputAlphaMask, uint64_t outputRedMask, uint64_t outputGreenMask, uint64_t outputBlueMask) {
+  image output(outputEndian, outputDepth, outputAlphaMask, outputRedMask, outputGreenMask, outputBlueMask);
+  output.allocate(width, height);
+
+  #pragma omp parallel for
+  for(unsigned y = 0; y < height; y++) {
+    uint8_t *dp = output.data + output.pitch * y;
+    uint8_t *sp = data + pitch * y;
+    for(unsigned x = 0; x < width; x++) {
+      uint64_t color = read(sp);
+      sp += stride;
+
+      uint64_t a = (color & alpha.mask) >> alpha.shift;
+      uint64_t r = (color & red.mask) >> red.shift;
+      uint64_t g = (color & green.mask) >> green.shift;
+      uint64_t b = (color & blue.mask) >> blue.shift;
+
+      a = normalize(a, alpha.depth, output.alpha.depth);
+      r = normalize(r, red.depth, output.red.depth);
+      g = normalize(g, green.depth, output.green.depth);
+      b = normalize(b, blue.depth, output.blue.depth);
+
+      output.write(dp, (a << output.alpha.shift) | (r << output.red.shift) | (g << output.green.shift) | (b << output.blue.shift));
+      dp += output.stride;
+    }
+  }
+
+  operator=(std::move(output));
+}
+
+void image::alphaBlend(uint64_t alphaColor) {
+  uint64_t alphaR = (alphaColor & red.mask) >> red.shift;
+  uint64_t alphaG = (alphaColor & green.mask) >> green.shift;
+  uint64_t alphaB = (alphaColor & blue.mask) >> blue.shift;
+
+  #pragma omp parallel for
+  for(unsigned y = 0; y < height; y++) {
+    uint8_t *dp = data + pitch * y;
+    for(unsigned x = 0; x < width; x++) {
+      uint64_t color = read(dp);
+
+      uint64_t colorA = (color & alpha.mask) >> alpha.shift;
+      uint64_t colorR = (color & red.mask) >> red.shift;
+      uint64_t colorG = (color & green.mask) >> green.shift;
+      uint64_t colorB = (color & blue.mask) >> blue.shift;
+      double alphaScale = (double)colorA / (double)((1 << alpha.depth) - 1);
+
+      colorA = (1 << alpha.depth) - 1;
+      colorR = (colorR * alphaScale) + (alphaR * (1.0 - alphaScale));
+      colorG = (colorG * alphaScale) + (alphaG * (1.0 - alphaScale));
+      colorB = (colorB * alphaScale) + (alphaB * (1.0 - alphaScale));
+
+      write(dp, (colorA << alpha.shift) | (colorR << red.shift) | (colorG << green.shift) | (colorB << blue.shift));
+      dp += stride;
+    }
+  }
+}
+
+//protected
+
+uint64_t image::interpolate(double mu, const uint64_t *s, double (*op)(double, double, double, double, double)) {
+  uint64_t aa = (s[0] & alpha.mask) >> alpha.shift, ar = (s[0] & red.mask) >> red.shift,
+           ag = (s[0] & green.mask) >> green.shift, ab = (s[0] & blue.mask) >> blue.shift;
+  uint64_t ba = (s[1] & alpha.mask) >> alpha.shift, br = (s[1] & red.mask) >> red.shift,
+           bg = (s[1] & green.mask) >> green.shift, bb = (s[1] & blue.mask) >> blue.shift;
+  uint64_t ca = (s[2] & alpha.mask) >> alpha.shift, cr = (s[2] & red.mask) >> red.shift,
+           cg = (s[2] & green.mask) >> green.shift, cb = (s[2] & blue.mask) >> blue.shift;
+  uint64_t da = (s[3] & alpha.mask) >> alpha.shift, dr = (s[3] & red.mask) >> red.shift,
+           dg = (s[3] & green.mask) >> green.shift, db = (s[3] & blue.mask) >> blue.shift;
+
+  int64_t A = op(mu, aa, ba, ca, da);
+  int64_t R = op(mu, ar, br, cr, dr);
+  int64_t G = op(mu, ag, bg, cg, dg);
+  int64_t B = op(mu, ab, bb, cb, db);
+
+  A = max(0, min(A, (1 << alpha.depth) - 1));
+  R = max(0, min(R, (1 << red.depth) - 1));
+  G = max(0, min(G, (1 << green.depth) - 1));
+  B = max(0, min(B, (1 << blue.depth) - 1));
+
+  return (A << alpha.shift) | (R << red.shift) | (G << green.shift) | (B << blue.shift);
+}
+
+void image::scaleX(unsigned outputWidth, interpolation op) {
+  uint8_t *outputData = new uint8_t[outputWidth * height * stride];
+  unsigned outputPitch = outputWidth * stride;
+  double step = (double)width / (double)outputWidth;
+  const uint8_t *terminal = data + pitch * height;
+
+  #pragma omp parallel for
+  for(unsigned y = 0; y < height; y++) {
+    uint8_t *dp = outputData + outputPitch * y;
+    uint8_t *sp = data + pitch * y;
+
+    double fraction = 0.0;
+    uint64_t s[4] = { sp < terminal ? read(sp) : 0 };  //B,C (0,1) = center of kernel { 0, 0, 1, 2 }
+    s[1] = s[0];
+    s[2] = sp + stride < terminal ? read(sp += stride) : s[1];
+    s[3] = sp + stride < terminal ? read(sp += stride) : s[2];
+
+    for(unsigned x = 0; x < width; x++) {
+      while(fraction <= 1.0) {
+        if(dp >= outputData + outputPitch * height) break;
+        write(dp, interpolate(fraction, (const uint64_t*)&s, op));
+        dp += stride;
+        fraction += step;
+      }
+
+      s[0] = s[1]; s[1] = s[2]; s[2] = s[3];
+      if(sp + stride < terminal) s[3] = read(sp += stride);
+      fraction -= 1.0;
+    }
+  }
+
+  free();
+  data = outputData;
+  width = outputWidth;
+  pitch = width * stride;
+}
+
+void image::scaleY(unsigned outputHeight, interpolation op) {
+  uint8_t *outputData = new uint8_t[width * outputHeight * stride];
+  double step = (double)height / (double)outputHeight;
+  const uint8_t *terminal = data + pitch * height;
+
+  #pragma omp parallel for
+  for(unsigned x = 0; x < width; x++) {
+    uint8_t *dp = outputData + stride * x;
+    uint8_t *sp = data + stride * x;
+
+    double fraction = 0.0;
+    uint64_t s[4] = { sp < terminal ? read(sp) : 0 };
+    s[1] = s[0];
+    s[2] = sp + pitch < terminal ? read(sp += pitch) : s[1];
+    s[3] = sp + pitch < terminal ? read(sp += pitch) : s[2];
+
+    for(unsigned y = 0; y < height; y++) {
+      while(fraction <= 1.0) {
+        if(dp >= outputData + pitch * outputHeight) break;
+        write(dp, interpolate(fraction, (const uint64_t*)&s, op));
+        dp += pitch;
+        fraction += step;
+      }
+
+      s[0] = s[1]; s[1] = s[2]; s[2] = s[3];
+      if(sp + pitch < terminal) s[3] = read(sp += pitch);
+      fraction -= 1.0;
+    }
+  }
+
+  free();
+  data = outputData;
+  height = outputHeight;
+}
+
+bool image::loadBMP(const string &filename) {
+  uint32_t *outputData;
+  unsigned outputWidth, outputHeight;
+  if(bmp::read(filename, outputData, outputWidth, outputHeight) == false) return false;
+
+  allocate(outputWidth, outputHeight);
+  const uint32_t *sp = outputData;
+  uint8_t *dp = data;
+
+  for(unsigned y = 0; y < outputHeight; y++) {
+    for(unsigned x = 0; x < outputWidth; x++) {
+      uint32_t color = *sp++;
+      uint64_t a = normalize((uint8_t)(color >> 24), 8, alpha.depth);
+      uint64_t r = normalize((uint8_t)(color >> 16), 8, red.depth);
+      uint64_t g = normalize((uint8_t)(color >>  8), 8, green.depth);
+      uint64_t b = normalize((uint8_t)(color >>  0), 8, blue.depth);
+      write(dp, (a << alpha.shift) | (r << red.shift) | (g << green.shift) | (b << blue.shift));
+      dp += stride;
+    }
+  }
+
+  delete[] outputData;
+  return true;
+}
+
+bool image::loadPNG(const uint8_t *pngData, unsigned pngSize) {
+  png source;
+  if(source.decode(pngData, pngSize) == false) return false;
+
+  allocate(source.info.width, source.info.height);
+  const uint8_t *sp = source.data;
+  uint8_t *dp = data;
+
+  auto decode = [&]() -> uint64_t {
+    uint64_t p, r, g, b, a;
+
+    switch(source.info.colorType) {
+    case 0:  //L
+      r = g = b = source.readbits(sp);
+      a = (1 << source.info.bitDepth) - 1;
+      break;
+    case 2:  //R,G,B
+      r = source.readbits(sp);
+      g = source.readbits(sp);
+      b = source.readbits(sp);
+      a = (1 << source.info.bitDepth) - 1;
+      break;
+    case 3:  //P
+      p = source.readbits(sp);
+      r = source.info.palette[p][0];
+      g = source.info.palette[p][1];
+      b = source.info.palette[p][2];
+      a = (1 << source.info.bitDepth) - 1;
+      break;
+    case 4:  //L,A
+      r = g = b = source.readbits(sp);
+      a = source.readbits(sp);
+      break;
+    case 6:  //R,G,B,A
+      r = source.readbits(sp);
+      g = source.readbits(sp);
+      b = source.readbits(sp);
+      a = source.readbits(sp);
+      break;
+    }
+
+    a = normalize(a, source.info.bitDepth, alpha.depth);
+    r = normalize(r, source.info.bitDepth, red.depth);
+    g = normalize(g, source.info.bitDepth, green.depth);
+    b = normalize(b, source.info.bitDepth, blue.depth);
+
+    return (a << alpha.shift) | (r << red.shift) | (g << green.shift) | (b << blue.shift);
+  };
+
+  for(unsigned y = 0; y < height; y++) {
+    for(unsigned x = 0; x < width; x++) {
+      write(dp, decode());
+      dp += stride;
+    }
+  }
+
+  return true;
+}
+
+bool image::loadPNG(const string &filename) {
+  filemap map;
+  if(map.open(filename, filemap::mode::read) == false) return false;
+  return loadPNG(map.data(), map.size());
+}
+
+}
+
+#endif

bsnes/nall/interpolation.hpp

@@ -0,0 +1,59 @@
+#ifndef NALL_INTERPOLATION_HPP
+#define NALL_INTERPOLATION_HPP
+
+namespace nall {
+
+struct Interpolation {
+  static inline double Nearest(double mu, double a, double b, double c, double d) {
+    return (mu <= 0.5 ? b : c);
+  }
+
+  static inline double Sublinear(double mu, double a, double b, double c, double d) {
+    mu = ((mu - 0.5) * 2.0) + 0.5;
+    if(mu < 0) mu = 0;
+    if(mu > 1) mu = 1;
+    return b * (1.0 - mu) + c * mu;
+  }
+
+  static inline double Linear(double mu, double a, double b, double c, double d) {
+    return b * (1.0 - mu) + c * mu;
+  }
+
+  static inline double Cosine(double mu, double a, double b, double c, double d) {
+    mu = (1.0 - cos(mu * 3.14159265)) / 2.0;
+    return b * (1.0 - mu) + c * mu;
+  }
+
+  static inline double Cubic(double mu, double a, double b, double c, double d) {
+    double A = d - c - a + b;
+    double B = a - b - A;
+    double C = c - a;
+    double D = b;
+    return A * (mu * mu * mu) + B * (mu * mu) + C * mu + D;
+  }
+
+  static inline double Hermite(double mu1, double a, double b, double c, double d) {
+    const double tension = 0.0;  //-1 = low, 0 = normal, +1 = high
+    const double bias = 0.0;  //-1 = left, 0 = even, +1 = right
+    double mu2, mu3, m0, m1, a0, a1, a2, a3;
+
+    mu2 = mu1 * mu1;
+    mu3 = mu2 * mu1;
+
+    m0  = (b - a) * (1.0 + bias) * (1.0 - tension) / 2.0;
+    m0 += (c - b) * (1.0 - bias) * (1.0 - tension) / 2.0;
+    m1  = (c - b) * (1.0 + bias) * (1.0 - tension) / 2.0;
+    m1 += (d - c) * (1.0 - bias) * (1.0 - tension) / 2.0;
+
+    a0 = +2 * mu3 - 3 * mu2 + 1;
+    a1 =      mu3 - 2 * mu2 + mu1;
+    a2 =      mu3 -     mu2;
+    a3 = -2 * mu3 + 3 * mu2;
+
+    return (a0 * b) + (a1 * m0) + (a2 * m1) + (a3 * c);
+  }
+};
+
+}
+
+#endif

bsnes/nall/map.hpp

@@ -0,0 +1,116 @@
+#ifndef NALL_MAP_HPP
+#define NALL_MAP_HPP
+
+#include <nall/vector.hpp>
+
+namespace nall {
+
+template<typename LHS, typename RHS>
+struct map {
+  struct pair {
+    LHS name;
+    RHS data;
+  };
+
+  inline void reset() {
+    list.reset();
+  }
+
+  inline unsigned size() const {
+    return list.size();
+  }
+
+  //O(log n) find
+  inline optional<unsigned> find(const LHS &name) const {
+    signed first = 0, last = size() - 1;
+    while(first <= last) {
+      signed middle = (first + last) / 2;
+           if(name < list[middle].name) last  = middle - 1;  //search lower half
+      else if(list[middle].name < name) first = middle + 1;  //search upper half
+      else return { true, middle };                          //match found
+    }
+    return { false, 0u };
+  }
+
+  //O(n) insert + O(log n) find
+  inline RHS& insert(const LHS &name, const RHS &data) {
+    if(auto position = find(name)) {
+      list[position()].data = data;
+      return list[position()].data;
+    }
+    signed offset = size();
+    for(unsigned n = 0; n < size(); n++) {
+      if(name < list[n].name) { offset = n; break; }
+    }
+    list.insert(offset, { name, data });
+    return list[offset].data;
+  }
+
+  //O(log n) find
+  inline void modify(const LHS &name, const RHS &data) {
+    if(auto position = find(name)) list[position()].data = data;
+  }
+
+  //O(n) remove + O(log n) find
+  inline void remove(const LHS &name) {
+    if(auto position = find(name)) list.remove(position());
+  }
+
+  //O(log n) find
+  inline RHS& operator[](const LHS &name) {
+    if(auto position = find(name)) return list[position()].data;
+    throw;
+  }
+
+  inline const RHS& operator[](const LHS &name) const {
+    if(auto position = find(name)) return list[position()].data;
+    throw;
+  }
+
+  inline RHS& operator()(const LHS &name) {
+    return insert(name, RHS());
+  }
+
+  inline const RHS& operator()(const LHS &name, const RHS &data) const {
+    if(auto position = find(name)) return list[position()].data;
+    return data;
+  }
+
+  inline pair* begin() { return list.begin(); }
+  inline pair* end() { return list.end(); }
+  inline const pair* begin() const { return list.begin(); }
+  inline const pair* end() const { return list.end(); }
+
+protected:
+  vector<pair> list;
+};
+
+template<typename LHS, typename RHS>
+struct bidirectional_map {
+  const map<LHS, RHS> &lhs;
+  const map<RHS, LHS> &rhs;
+
+  inline void reset() {
+    llist.reset();
+    rlist.reset();
+  }
+
+  inline unsigned size() const {
+    return llist.size();
+  }
+
+  inline void insert(const LHS &ldata, const RHS &rdata) {
+    llist.insert(ldata, rdata);
+    rlist.insert(rdata, ldata);
+  }
+
+  inline bidirectional_map() : lhs(llist), rhs(rlist) {}
+
+protected:
+  map<LHS, RHS> llist;
+  map<RHS, LHS> rlist;
+};
+
+}
+
+#endif

bsnes/nall/mosaic.hpp

@@ -0,0 +1,10 @@
+#ifndef NALL_MOSAIC_HPP
+#define NALL_MOSAIC_HPP
+
+#define NALL_MOSAIC_INTERNAL_HPP
+#include <nall/mosaic/bitstream.hpp>
+#include <nall/mosaic/context.hpp>
+#include <nall/mosaic/parser.hpp>
+#undef NALL_MOSAIC_INTERNAL_HPP
+
+#endif

bsnes/nall/mosaic/bitstream.hpp

@@ -0,0 +1,55 @@
+#ifdef NALL_MOSAIC_INTERNAL_HPP
+
+namespace nall {
+namespace mosaic {
+
+struct bitstream {
+  filemap fp;
+  uint8_t *data;
+  unsigned size;
+  bool readonly;
+  bool endian;
+
+  inline bool read(uint64_t addr) const {
+    if(data == nullptr || (addr >> 3) >= size) return 0;
+    unsigned mask = endian == 0 ? (0x01 << (addr & 7)) : (0x80 >> (addr & 7));
+    return data[addr >> 3] & mask;
+  }
+
+  inline void write(uint64_t addr, bool value) {
+    if(data == nullptr || readonly == true || (addr >> 3) >= size) return;
+    unsigned mask = endian == 0 ? (0x01 << (addr & 7)) : (0x80 >> (addr & 7));
+    if(value == 0) data[addr >> 3] &= ~mask;
+    if(value == 1) data[addr >> 3] |=  mask;
+  }
+
+  inline bool open(const string &filename) {
+    readonly = false;
+    if(fp.open(filename, filemap::mode::readwrite) == false) {
+      readonly = true;
+      if(fp.open(filename, filemap::mode::read) == false) {
+        return false;
+      }
+    }
+    data = fp.data();
+    size = fp.size();
+    return true;
+  }
+
+  inline void close() {
+    fp.close();
+    data = nullptr;
+  }
+
+  inline bitstream() : data(nullptr), endian(1) {
+  }
+
+  inline ~bitstream() {
+    close();
+  }
+};
+
+}
+}
+
+#endif

bsnes/nall/mosaic/context.hpp

@@ -0,0 +1,224 @@
+#ifdef NALL_MOSAIC_INTERNAL_HPP
+
+namespace nall {
+namespace mosaic {
+
+struct context {
+  unsigned offset;
+  unsigned width;
+  unsigned height;
+  unsigned count;
+
+  bool endian;     //0 = lsb, 1 = msb
+  bool order;      //0 = linear, 1 = planar
+  unsigned depth;  //1 - 24bpp
+
+  unsigned blockWidth;
+  unsigned blockHeight;
+  unsigned blockStride;
+  unsigned blockOffset;
+  array<unsigned> block;
+
+  unsigned tileWidth;
+  unsigned tileHeight;
+  unsigned tileStride;
+  unsigned tileOffset;
+  array<unsigned> tile;
+
+  unsigned mosaicWidth;
+  unsigned mosaicHeight;
+  unsigned mosaicStride;
+  unsigned mosaicOffset;
+  array<unsigned> mosaic;
+
+  unsigned paddingWidth;
+  unsigned paddingHeight;
+  unsigned paddingColor;
+  array<unsigned> palette;
+
+  inline unsigned objectWidth() const { return blockWidth * tileWidth * mosaicWidth + paddingWidth; }
+  inline unsigned objectHeight() const { return blockHeight * tileHeight * mosaicHeight + paddingHeight; }
+  inline unsigned objectSize() const {
+    unsigned size = blockStride * tileWidth * tileHeight * mosaicWidth * mosaicHeight
+                  + blockOffset * tileHeight * mosaicWidth * mosaicHeight
+                  + tileStride * mosaicWidth * mosaicHeight
+                  + tileOffset * mosaicHeight;
+    return max(1u, size);
+  }
+
+  inline unsigned eval(const string &expression) {
+    intmax_t result;
+    if(fixedpoint::eval(expression, result) == false) return 0u;
+    return result;
+  }
+
+  inline void eval(array<unsigned> &buffer, const string &expression_) {
+    string expression = expression_;
+    bool function = false;
+    for(auto &c : expression) {
+      if(c == '(') function = true;
+      if(c == ')') function = false;
+      if(c == ',' && function == true) c = ';';
+    }
+
+    lstring list = expression.split(",");
+    for(auto &item : list) {
+      item.trim();
+      if(item.wildcard("f(?*) ?*")) {
+        item.ltrim<1>("f(");
+        lstring part = item.split<1>(") ");
+        lstring args = part[0].split<3>(";");
+        for(auto &item : args) item.trim();
+
+        unsigned length = eval(args(0, "0"));
+        unsigned offset = eval(args(1, "0"));
+        unsigned stride = eval(args(2, "0"));
+        if(args.size() < 2) offset = buffer.size();
+        if(args.size() < 3) stride = 1;
+
+        for(unsigned n = 0; n < length; n++) {
+          string fn = part[1];
+          fn.replace("n", decimal(n));
+          fn.replace("o", decimal(offset));
+          fn.replace("p", decimal(buffer.size()));
+          buffer.resize(offset + 1);
+          buffer[offset] = eval(fn);
+          offset += stride;
+        }
+      } else if(item.wildcard("base64*")) {
+        unsigned offset = 0;
+        item.ltrim<1>("base64");
+        if(item.wildcard("(?*) *")) {
+          item.ltrim<1>("(");
+          lstring part = item.split<1>(") ");
+          offset = eval(part[0]);
+          item = part(1, "");
+        }
+        item.trim();
+        for(auto &c : item) {
+          if(c >= 'A' && c <= 'Z') buffer.append(offset + c - 'A' +  0);
+          if(c >= 'a' && c <= 'z') buffer.append(offset + c - 'a' + 26);
+          if(c >= '0' && c <= '9') buffer.append(offset + c - '0' + 52);
+          if(c == '-') buffer.append(offset + 62);
+          if(c == '_') buffer.append(offset + 63);
+        }
+      } else if(item.wildcard("file *")) {
+        item.ltrim<1>("file ");
+        item.trim();
+        //...
+      } else if(item.empty() == false) {
+        buffer.append(eval(item));
+      }
+    }
+  }
+
+  inline void parse(const string &data) {
+    reset();
+
+    lstring lines = data.split("\n");
+    for(auto &line : lines) {
+      lstring part = line.split<1>(":");
+      if(part.size() != 2) continue;
+      part[0].trim();
+      part[1].trim();
+
+      if(part[0] == "offset") offset = eval(part[1]);
+      if(part[0] == "width") width = eval(part[1]);
+      if(part[0] == "height") height = eval(part[1]);
+      if(part[0] == "count") count = eval(part[1]);
+
+      if(part[0] == "endian") endian = eval(part[1]);
+      if(part[0] == "order") order = eval(part[1]);
+      if(part[0] == "depth") depth = eval(part[1]);
+
+      if(part[0] == "blockWidth") blockWidth = eval(part[1]);
+      if(part[0] == "blockHeight") blockHeight = eval(part[1]);
+      if(part[0] == "blockStride") blockStride = eval(part[1]);
+      if(part[0] == "blockOffset") blockOffset = eval(part[1]);
+      if(part[0] == "block") eval(block, part[1]);
+
+      if(part[0] == "tileWidth") tileWidth = eval(part[1]);
+      if(part[0] == "tileHeight") tileHeight = eval(part[1]);
+      if(part[0] == "tileStride") tileStride = eval(part[1]);
+      if(part[0] == "tileOffset") tileOffset = eval(part[1]);
+      if(part[0] == "tile") eval(tile, part[1]);
+
+      if(part[0] == "mosaicWidth") mosaicWidth = eval(part[1]);
+      if(part[0] == "mosaicHeight") mosaicHeight = eval(part[1]);
+      if(part[0] == "mosaicStride") mosaicStride = eval(part[1]);
+      if(part[0] == "mosaicOffset") mosaicOffset = eval(part[1]);
+      if(part[0] == "mosaic") eval(mosaic, part[1]);
+
+      if(part[0] == "paddingWidth") paddingWidth = eval(part[1]);
+      if(part[0] == "paddingHeight") paddingHeight = eval(part[1]);
+      if(part[0] == "paddingColor") paddingColor = eval(part[1]);
+      if(part[0] == "palette") eval(palette, part[1]);
+    }
+
+    sanitize();
+  }
+
+  inline bool load(const string &filename) {
+    string filedata;
+    if(filedata.readfile(filename) == false) return false;
+    parse(filedata);
+    return true;
+  }
+
+  inline void sanitize() {
+    if(depth < 1) depth = 1;
+    if(depth > 24) depth = 24;
+
+    if(blockWidth < 1) blockWidth = 1;
+    if(blockHeight < 1) blockHeight = 1;
+
+    if(tileWidth < 1) tileWidth = 1;
+    if(tileHeight < 1) tileHeight = 1;
+
+    if(mosaicWidth < 1) mosaicWidth = 1;
+    if(mosaicHeight < 1) mosaicHeight = 1;
+  }
+
+  inline void reset() {
+    offset = 0;
+    width = 0;
+    height = 0;
+    count = 0;
+
+    endian = 1;
+    order = 0;
+    depth = 1;
+
+    blockWidth = 1;
+    blockHeight = 1;
+    blockStride = 0;
+    blockOffset = 0;
+    block.reset();
+
+    tileWidth = 1;
+    tileHeight = 1;
+    tileStride = 0;
+    tileOffset = 0;
+    tile.reset();
+
+    mosaicWidth = 1;
+    mosaicHeight = 1;
+    mosaicStride = 0;
+    mosaicOffset = 0;
+    mosaic.reset();
+
+    paddingWidth = 0;
+    paddingHeight = 0;
+    paddingColor = 0x000000;
+    palette.reset();
+  }
+
+  inline context() {
+    reset();
+  }
+};
+
+}
+}
+
+#endif

bsnes/nall/mosaic/parser.hpp

@@ -0,0 +1,126 @@
+#ifdef NALL_MOSAIC_INTERNAL_HPP
+
+namespace nall {
+namespace mosaic {
+
+struct parser {
+  image canvas;
+
+  //export from bitstream to canvas
+  inline void load(bitstream &stream, uint64_t offset, context &ctx, unsigned width, unsigned height) {
+    canvas.allocate(width, height);
+    canvas.clear(ctx.paddingColor);
+    parse(1, stream, offset, ctx, width, height);
+  }
+
+  //import from canvas to bitstream
+  inline bool save(bitstream &stream, uint64_t offset, context &ctx) {
+    if(stream.readonly) return false;
+    parse(0, stream, offset, ctx, canvas.width, canvas.height);
+    return true;
+  }
+
+  inline parser() : canvas(0, 32, 0u, 255u << 16, 255u << 8, 255u << 0) {
+  }
+
+private:
+  inline uint32_t read(unsigned x, unsigned y) const {
+    unsigned addr = y * canvas.width + x;
+    if(addr >= canvas.width * canvas.height) return 0u;
+    uint32_t *buffer = (uint32_t*)canvas.data;
+    return buffer[addr];
+  }
+
+  inline void write(unsigned x, unsigned y, uint32_t data) {
+    unsigned addr = y * canvas.width + x;
+    if(addr >= canvas.width * canvas.height) return;
+    uint32_t *buffer = (uint32_t*)canvas.data;
+    buffer[addr] = data;
+  }
+
+  inline void parse(bool load, bitstream &stream, uint64_t offset, context &ctx, unsigned width, unsigned height) {
+    stream.endian = ctx.endian;
+    unsigned canvasWidth = width / (ctx.mosaicWidth * ctx.tileWidth * ctx.blockWidth + ctx.paddingWidth);
+    unsigned canvasHeight = height / (ctx.mosaicHeight * ctx.tileHeight * ctx.blockHeight + ctx.paddingHeight);
+    unsigned bitsPerBlock = ctx.depth * ctx.blockWidth * ctx.blockHeight;
+
+    unsigned objectOffset = 0;
+    for(unsigned objectY = 0; objectY < canvasHeight; objectY++) {
+      for(unsigned objectX = 0; objectX < canvasWidth; objectX++) {
+        if(objectOffset >= ctx.count && ctx.count > 0) break;
+        unsigned objectIX = objectX * ctx.objectWidth();
+        unsigned objectIY = objectY * ctx.objectHeight();
+        objectOffset++;
+
+        unsigned mosaicOffset = 0;
+        for(unsigned mosaicY = 0; mosaicY < ctx.mosaicHeight; mosaicY++) {
+          for(unsigned mosaicX = 0; mosaicX < ctx.mosaicWidth; mosaicX++) {
+            unsigned mosaicData = ctx.mosaic(mosaicOffset, mosaicOffset);
+            unsigned mosaicIX = (mosaicData % ctx.mosaicWidth) * (ctx.tileWidth * ctx.blockWidth);
+            unsigned mosaicIY = (mosaicData / ctx.mosaicWidth) * (ctx.tileHeight * ctx.blockHeight);
+            mosaicOffset++;
+
+            unsigned tileOffset = 0;
+            for(unsigned tileY = 0; tileY < ctx.tileHeight; tileY++) {
+              for(unsigned tileX = 0; tileX < ctx.tileWidth; tileX++) {
+                unsigned tileData = ctx.tile(tileOffset, tileOffset);
+                unsigned tileIX = (tileData % ctx.tileWidth) * ctx.blockWidth;
+                unsigned tileIY = (tileData / ctx.tileWidth) * ctx.blockHeight;
+                tileOffset++;
+
+                unsigned blockOffset = 0;
+                for(unsigned blockY = 0; blockY < ctx.blockHeight; blockY++) {
+                  for(unsigned blockX = 0; blockX < ctx.blockWidth; blockX++) {
+                    if(load) {
+                      unsigned palette = 0;
+                      for(unsigned n = 0; n < ctx.depth; n++) {
+                        unsigned index = blockOffset++;
+                        if(ctx.order == 1) index = (index % ctx.depth) * ctx.blockWidth * ctx.blockHeight + (index / ctx.depth);
+                        palette |= stream.read(offset + ctx.block(index, index)) << n;
+                      }
+
+                      write(
+                        objectIX + mosaicIX + tileIX + blockX,
+                        objectIY + mosaicIY + tileIY + blockY,
+                        ctx.palette(palette, palette)
+                      );
+                    } else /* save */ {
+                      uint32_t palette = read(
+                        objectIX + mosaicIX + tileIX + blockX,
+                        objectIY + mosaicIY + tileIY + blockY
+                      );
+
+                      for(unsigned n = 0; n < ctx.depth; n++) {
+                        unsigned index = blockOffset++;
+                        if(ctx.order == 1) index = (index % ctx.depth) * ctx.blockWidth * ctx.blockHeight + (index / ctx.depth);
+                        stream.write(offset + ctx.block(index, index), palette & 1);
+                        palette >>= 1;
+                      }
+                    }
+                  }  //blockX
+                }  //blockY
+
+                offset += ctx.blockStride;
+              }  //tileX
+
+              offset += ctx.blockOffset;
+            }  //tileY
+
+            offset += ctx.tileStride;
+          }  //mosaicX
+
+          offset += ctx.tileOffset;
+        }  //mosaicY
+
+        offset += ctx.mosaicStride;
+      }  //objectX
+
+      offset += ctx.mosaicOffset;
+    }  //objectY
+  }
+};
+
+}
+}
+
+#endif

bsnes/nall/platform.hpp

@@ -64,8 +64,8 @@
   #define mkdir(n, m) _wmkdir(nall::utf16_t(n))
   #define putenv      _putenv
   #define rmdir       _rmdir
-  #define usleep(n)   Sleep(n / 1000)
   #define vsnprintf   _vsnprintf
+  inline void usleep(unsigned milliseconds) { Sleep(milliseconds / 1000); }
 #endif
 
 //================

bsnes/nall/png.hpp

@@ -10,9 +10,12 @@
 namespace nall {
 
 struct png {
-  uint32_t *data;
-  unsigned size;
-
+  //colorType:
+  //0 = L
+  //2 = R,G,B
+  //3 = P
+  //4 = L,A
+  //6 = R,G,B,A
   struct Info {
     unsigned width;
     unsigned height;
@@ -28,13 +31,14 @@ struct png {
     uint8_t palette[256][3];
   } info;
 
-  uint8_t *rawData;
-  unsigned rawSize;
+  uint8_t *data;
+  unsigned size;
 
   inline bool decode(const string &filename);
   inline bool decode(const uint8_t *sourceData, unsigned sourceSize);
-  inline void transform();
-  inline void alphaTransform(uint32_t rgb = 0xffffff);
+  inline unsigned readbits(const uint8_t *&data);
+  unsigned bitpos;
+
   inline png();
   inline ~png();
 
@@ -46,16 +50,11 @@ protected:
     IEND = 0x49454e44,
   };
 
-  unsigned bitpos;
-
   inline unsigned interlace(unsigned pass, unsigned index);
   inline unsigned inflateSize();
   inline bool deinterlace(const uint8_t *&inputData, unsigned pass);
   inline bool filter(uint8_t *outputData, const uint8_t *inputData, unsigned width, unsigned height);
   inline unsigned read(const uint8_t *data, unsigned length);
-  inline unsigned decode(const uint8_t *&data);
-  inline unsigned readbits(const uint8_t *&data);
-  inline unsigned scale(unsigned n);
 };
 
 bool png::decode(const string &filename) {
@@ -146,14 +145,14 @@ bool png::decode(const uint8_t *sourceData, unsigned sourceSize) {
     return false;
   }
 
-  rawSize = info.width * info.height * info.bytesPerPixel;
-  rawData = new uint8_t[rawSize];
+  size = info.width * info.height * info.bytesPerPixel;
+  data = new uint8_t[size];
 
   if(info.interlaceMethod == 0) {
-    if(filter(rawData, interlacedData, info.width, info.height) == false) {
+    if(filter(data, interlacedData, info.width, info.height) == false) {
       delete[] interlacedData;
-      delete[] rawData;
-      rawData = 0;
+      delete[] data;
+      data = 0;
       return false;
     }
   } else {
@@ -161,8 +160,8 @@ bool png::decode(const uint8_t *sourceData, unsigned sourceSize) {
     for(unsigned pass = 0; pass < 7; pass++) {
       if(deinterlace(passData, pass) == false) {
         delete[] interlacedData;
-        delete[] rawData;
-        rawData = 0;
+        delete[] data;
+        data = 0;
         return false;
       }
     }
@@ -216,7 +215,7 @@ bool png::deinterlace(const uint8_t *&inputData, unsigned pass) {
 
   const uint8_t *rd = outputData;
   for(unsigned y = yo; y < info.height; y += yd) {
-    uint8_t *wr = rawData + y * info.pitch;
+    uint8_t *wr = data + y * info.pitch;
     for(unsigned x = xo; x < info.width; x += xd) {
       for(unsigned b = 0; b < info.bytesPerPixel; b++) {
         wr[x * info.bytesPerPixel + b] = *rd++;
@@ -298,42 +297,6 @@ unsigned png::read(const uint8_t *data, unsigned length) {
   return result;
 }
 
-unsigned png::decode(const uint8_t *&data) {
-  unsigned p, r, g, b, a;
-
-  switch(info.colorType) {
-  case 0:  //L
-    r = g = b = scale(readbits(data));
-    a = 0xff;
-    break;
-  case 2:  //R,G,B
-    r = scale(readbits(data));
-    g = scale(readbits(data));
-    b = scale(readbits(data));
-    a = 0xff;
-    break;
-  case 3:  //P
-    p = readbits(data);
-    r = info.palette[p][0];
-    g = info.palette[p][1];
-    b = info.palette[p][2];
-    a = 0xff;
-    break;
-  case 4:  //L,A
-    r = g = b = scale(readbits(data));
-    a = scale(readbits(data));
-    break;
-  case 6:  //R,G,B,A
-    r = scale(readbits(data));
-    g = scale(readbits(data));
-    b = scale(readbits(data));
-    a = scale(readbits(data));
-    break;
-  }
-
-  return (a << 24) | (r << 16) | (g << 8) | (b << 0);
-}
-
 unsigned png::readbits(const uint8_t *&data) {
   unsigned result = 0;
   switch(info.bitDepth) {
@@ -363,62 +326,12 @@ unsigned png::readbits(const uint8_t *&data) {
   return result;
 }
 
-unsigned png::scale(unsigned n) {
-  switch(info.bitDepth) {
-  case  1: return n ? 0xff : 0x00;
-  case  2: return n * 0x55;
-  case  4: return n * 0x11;
-  case  8: return n;
-  case 16: return n >> 8;
-  }
-  return 0;
-}
-
-void png::transform() {
-  if(data) delete[] data;
-  data = new uint32_t[info.width * info.height];
-
+png::png() : data(nullptr) {
   bitpos = 0;
-  const uint8_t *rd = rawData;
-  for(unsigned y = 0; y < info.height; y++) {
-    uint32_t *wr = data + y * info.width;
-    for(unsigned x = 0; x < info.width; x++) {
-      wr[x] = decode(rd);
-    }
-  }
-}
-
-void png::alphaTransform(uint32_t rgb) {
-  transform();
-
-  uint8_t ir = rgb >> 16;
-  uint8_t ig = rgb >>  8;
-  uint8_t ib = rgb >>  0;
-
-  uint32_t *p = data;
-  for(unsigned y = 0; y < info.height; y++) {
-    for(unsigned x = 0; x < info.width; x++) {
-      uint32_t pixel = *p;
-      uint8_t a = pixel >> 24;
-      uint8_t r = pixel >> 16;
-      uint8_t g = pixel >>  8;
-      uint8_t b = pixel >>  0;
-
-      r = (r * a) + (ir * (255 - a)) >> 8;
-      g = (g * a) + (ig * (255 - a)) >> 8;
-      b = (b * a) + (ib * (255 - a)) >> 8;
-
-      *p++ = (255 << 24) | (r << 16) | (g << 8) | (b << 0);
-    }
-  }
-}
-
-png::png() : data(nullptr), rawData(nullptr) {
 }
 
 png::~png() {
   if(data) delete[] data;
-  if(rawData) delete[] rawData;
 }
 
 }

bsnes/nall/resource.hpp

@@ -1,61 +0,0 @@
-#ifndef NALL_RESOURCE_HPP
-#define NALL_RESOURCE_HPP
-
-#include <nall/file.hpp>
-#include <nall/zip.hpp>
-
-namespace nall {
-
-struct resource {
-  //create resource with "zip -9 resource.zip resource"
-  static bool encode(const char *outputFilename, const char *inputFilename) {
-    file fp;
-    if(fp.open(inputFilename, file::mode::read) == false) return false;
-    unsigned size = fp.size();
-    uint8_t *data = new uint8_t[size];
-    fp.read(data, size);
-    fp.close();
-
-    fp.open(outputFilename, file::mode::write);
-    fp.print("static const uint8_t data[", size, "] = {\n");
-    uint8_t *p = data;
-    while(size) {
-      fp.print("  ");
-      for(unsigned n = 0; n < 32 && size; n++, size--) {
-        fp.print((unsigned)*p++, ",");
-      }
-      fp.print("\n");
-    }
-    fp.print("};\n");
-    fp.close();
-
-    delete[] data;
-  }
-
-  uint8_t *data;
-  unsigned size;
-
-  //extract first file from ZIP archive
-  bool decode(const uint8_t *cdata, unsigned csize) {
-    if(data) delete[] data;
-
-    zip archive;
-    if(archive.open(cdata, csize) == false) return false;
-    if(archive.file.size() == 0) return false;
-    bool result = archive.extract(archive.file[0], data, size);
-    archive.close();
-
-    return result;
-  }
-
-  resource() : data(0), size(0) {
-  }
-
-  ~resource() {
-    if(data) delete[] data;
-  }
-};
-
-}
-
-#endif

bsnes/nall/serializer.hpp

@@ -55,10 +55,10 @@ namespace nall {
     template<typename T> void integer(T &value) {
       enum { size = std::is_same<bool, T>::value ? 1 : sizeof(T) };
       if(imode == Save) {
-        for(unsigned n = 0; n < size; n++) idata[isize++] = value >> (n << 3);
+        for(unsigned n = 0; n < size; n++) idata[isize++] = (uintmax_t)value >> (n << 3);
       } else if(imode == Load) {
         value = 0;
-        for(unsigned n = 0; n < size; n++) value |= idata[isize++] << (n << 3);
+        for(unsigned n = 0; n < size; n++) value |= (uintmax_t)idata[isize++] << (n << 3);
       } else if(imode == Size) {
         isize += size;
       }

bsnes/nall/snes/cartridge.hpp

@@ -105,345 +105,439 @@ public:
   bool has_st018;
 };
 
-#define T "\t"
-
 SnesCartridge::SnesCartridge(const uint8_t *data, unsigned size) {
   read_header(data, size);
 
   string xml;
-  markup = "";
+  markup = "<?xml version='1.0' encoding='UTF-8'?>\n";
 
   if(type == TypeBsx) {
-    markup.append("cartridge");
+    markup.append("<cartridge/>\n");
     return;
   }
 
   if(type == TypeSufamiTurbo) {
-    markup.append("cartridge");
+    markup.append("<cartridge/>\n");
     return;
   }
 
   if(type == TypeGameBoy) {
-    markup.append("cartridge rtc=", gameboy_has_rtc(data, size), "\n");
+    markup.append("<cartridge rtc='", gameboy_has_rtc(data, size), "'\n");
     if(gameboy_ram_size(data, size) > 0) {
-      markup.append(T "ram size=0x", hex(gameboy_ram_size(data, size)), "\n");
+      markup.append("  <ram size='0x", hex(gameboy_ram_size(data, size)), "'>\n");
     }
+    markup.append("</cartridge>\n");
     return;
   }
 
-  markup.append("cartridge region=", region == NTSC ? "NTSC\n" : "PAL\n");
+  const char *range = (rom_size > 0x200000) || (ram_size > 32 * 1024) ? "0000-7fff" : "0000-ffff";
+  markup.append("<cartridge region='", region == NTSC ? "NTSC" : "PAL", "'>\n");
 
-  if(type == TypeSuperGameBoy1Bios) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=linear address=00-7f:8000-ffff\n");
-    markup.append(T T "map mode=linear address=80-ff:8000-ffff\n");
-    markup.append(T "icd2 revision=1\n");
-    markup.append(T T "map address=00-3f:6000-7fff\n");
-    markup.append(T T "map address=80-bf:6000-7fff\n");
-  } else if(type == TypeSuperGameBoy2Bios) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=linear address=00-7f:8000-ffff\n");
-    markup.append(T T "map mode=linear address=80-ff:8000-ffff\n");
-    markup.append(T "icd2 revision=1\n");
-    markup.append(T T "map address=00-3f:6000-7fff\n");
-    markup.append(T T "map address=80-bf:6000-7fff\n");
-  } else if(has_cx4) {
-    markup.append(T "hitachidsp model=HG51B169 frequency=20000000 firmware=cx4.bin sha256=ae8d4d1961b93421ff00b3caa1d0f0ce7783e749772a3369c36b3dbf0d37ef18\n");
-    markup.append(T T "rom\n");
-    markup.append(T T T "map mode=linear address=00-7f:8000-ffff\n");
-    markup.append(T T T "map mode=linear address=80-ff:8000-ffff\n");
-    markup.append(T T "mmio\n");
-    markup.append(T T T "map address=00-3f:6000-7fff\n");
-    markup.append(T T T "map address=80-bf:6000-7fff\n");
-  } else if(has_spc7110) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=shadow address=00-0f:8000-ffff\n");
-    markup.append(T T "map mode=shadow address=80-bf:8000-ffff\n");
-    markup.append(T T "map mode=linear address=c0-cf:0000-ffff\n");
+  if(type == TypeSuperGameBoy1Bios || type == TypeSuperGameBoy2Bios) markup.append(
+    "  <rom>\n"
+    "    <map mode='linear' address='00-7f:8000-ffff'/>\n"
+    "    <map mode='linear' address='80-ff:8000-ffff'/>\n"
+    "  </rom>\n"
+    "  <icd2 revision='1'>\n"
+    "    <map address='00-3f:6000-7fff'/>\n"
+    "    <map address='80-bf:6000-7fff'/>\n"
+    "  </icd2>\n"
+  );
 
-    markup.append(T "spc7110\n");
-    markup.append(T T "mcu\n");
-    markup.append(T T T "map address=d0-ff:0000-ffff offset=0x100000 size=0x", hex(size - 0x100000), "\n");
-    markup.append(T T "ram size=0x", hex(ram_size), "\n");
-    markup.append(T T T "map mode=linear address=00:6000-7fff\n");
-    markup.append(T T T "map mode=linear address=30:6000-7fff\n");
-    markup.append(T T "mmio\n");
-    markup.append(T T T "map address=00-3f:4800-483f\n");
-    markup.append(T T T "map address=80-bf:4800-483f\n");
-    if(has_spc7110rtc) {
-      markup.append(T T "rtc\n");
-      markup.append(T T T "map address=00-3f:4840-4842\n");
-      markup.append(T T T "map address=80-bf:4840-4842\n");
-    }
-    markup.append(T T "dcu\n");
-    markup.append(T T T "map address=50:0000-ffff\n");
-  } else if(mapper == LoROM) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=linear address=00-7f:8000-ffff\n");
-    markup.append(T T "map mode=linear address=80-ff:8000-ffff\n");
+  else if(has_cx4) markup.append(
+    "  <hitachidsp model='HG51B169' frequency='20000000' firmware='cx4.rom' sha256='ae8d4d1961b93421ff00b3caa1d0f0ce7783e749772a3369c36b3dbf0d37ef18'>\n"
+    "    <rom>\n"
+    "      <map mode='linear' address='00-7f:8000-ffff'/>\n"
+    "      <map mode='linear' address='80-ff:8000-ffff'/>\n"
+    "    </rom>\n"
+    "    <mmio>\n"
+    "      <map address='00-3f:6000-7fff'/>\n"
+    "      <map address='80-bf:6000-7fff'/>\n"
+    "    </mmio>\n"
+    "  </hitachidsp>\n"
+  );
 
-    if(ram_size > 0) {
-      markup.append(T "ram size=0x", hex(ram_size), "\n");
-      markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
-      markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
-      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
-        markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
-        markup.append(T T "map mode=linear address=f0-ff:0000-7fff\n");
-      } else {
-        markup.append(T T "map mode=linear address=70-7f:0000-ffff\n");
-        markup.append(T T "map mode=linear address=f0-ff:0000-ffff\n");
-      }
-    }
-  } else if(mapper == HiROM) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=shadow address=00-3f:8000-ffff\n");
-    markup.append(T T "map mode=linear address=40-7f:0000-ffff\n");
-    markup.append(T T "map mode=shadow address=80-bf:8000-ffff\n");
-    markup.append(T T "map mode=linear address=c0-ff:0000-ffff\n");
-
-    if(ram_size > 0) {
-      markup.append(T "ram size=0x", hex(ram_size), "\n");
-      markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
-      markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
-      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
-        markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
-      } else {
-        markup.append(T T "map mode=linear address=70-7f:0000-ffff\n");
-      }
-    }
-  } else if(mapper == ExLoROM) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=linear address=00-3f:8000-ffff\n");
-    markup.append(T T "map mode=linear address=40-7f:0000-ffff\n");
-    markup.append(T T "map mode=linear address=80-bf:8000-ffff\n");
-
-    if(ram_size > 0) {
-      markup.append(T "ram size=0x", hex(ram_size), "\n");
-      markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
-      markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
-      markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
-    }
-  } else if(mapper == ExHiROM) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=shadow address=00-3f:8000-ffff offset=0x400000\n");
-    markup.append(T T "map mode=linear address=40-7f:0000-ffff offset=0x400000\n");
-    markup.append(T T "map mode=shadow address=80-bf:8000-ffff offset=0x000000\n");
-    markup.append(T T "map mode=linear address=c0-ff:0000-ffff offset=0x000000\n");
-
-    if(ram_size > 0) {
-      markup.append(T "ram size=0x", hex(ram_size), "\n");
-      markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
-      markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
-      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
-        markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
-      } else {
-        markup.append(T T "map mode=linear address=70-7f:0000-ffff\n");
-      }
-    }
-  } else if(mapper == SuperFXROM) {
-    markup.append(T "superfx revision=2\n");
-    markup.append(T T "rom\n");
-    markup.append(T T T "map mode=linear address=00-3f:8000-ffff\n");
-    markup.append(T T T "map mode=linear address=40-5f:0000-ffff\n");
-    markup.append(T T T "map mode=linear address=80-bf:8000-ffff\n");
-    markup.append(T T T "map mode=linear address=c0-df:0000-ffff\n");
-    markup.append(T T "ram size=0x", hex(ram_size), "\n");
-    markup.append(T T T "map mode=linear address=00-3f:6000-7fff size=0x2000\n");
-    markup.append(T T T "map mode=linear address=60-7f:0000-ffff\n");
-    markup.append(T T T "map mode=linear address=80-bf:6000-7fff size=0x2000\n");
-    markup.append(T T T "map mode=linear address=e0-ff:0000-ffff\n");
-    markup.append(T T "mmio\n");
-    markup.append(T T T "map address=00-3f:3000-32ff\n");
-    markup.append(T T T "map address=80-bf:3000-32ff\n");
-  } else if(mapper == SA1ROM) {
-    markup.append(T "sa1\n");
-    markup.append(T T "mcu\n");
-    markup.append(T T T "rom\n");
-    markup.append(T T T T "map mode=direct address=00-3f:8000-ffff\n");
-    markup.append(T T T T "map mode=direct address=80-bf:8000-ffff\n");
-    markup.append(T T T T "map mode=direct address=c0-ff:0000-ffff\n");
-    markup.append(T T T "ram\n");
-    markup.append(T T T T "map mode=direct address=00-3f:6000-7fff\n");
-    markup.append(T T T T "map mode=direct address=80-bf:6000-7fff\n");
-    markup.append(T T "iram size=0x800\n");
-    markup.append(T T T "map mode=linear address=00-3f:3000-37ff\n");
-    markup.append(T T T "map mode=linear address=80-bf:3000-37ff\n");
-    markup.append(T T "bwram size=0x", hex(ram_size), "\n");
-    markup.append(T T T "map mode=linear address=40-4f:0000-ffff\n");
-    markup.append(T T "mmio\n");
-    markup.append(T T T "map address=00-3f:2200-23ff\n");
-    markup.append(T T T "map address=80-bf:2200-23ff\n");
-  } else if(mapper == BSCLoROM) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=linear address=00-1f:8000-ffff offset=0x000000\n");
-    markup.append(T T "map mode=linear address=20-3f:8000-ffff offset=0x100000\n");
-    markup.append(T T "map mode=linear address=80-9f:8000-ffff offset=0x200000\n");
-    markup.append(T T "map mode=linear address=a0-bf:8000-ffff offset=0x100000\n");
-    markup.append(T "ram size=0x", hex(ram_size), "\n");
-    markup.append(T T "map mode=linear address=70-7f:0000-7fff\n");
-    markup.append(T T "map mode=linear address=f0-ff:0000-7fff\n");
-    markup.append(T "bsx\n");
-    markup.append(T T "slot\n");
-    markup.append(T T T "map mode=linear address=c0-ef:0000-ffff\n");
-  } else if(mapper == BSCHiROM) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=shadow address=00-1f:8000-ffff\n");
-    markup.append(T T "map mode=linear address=40-5f:0000-ffff\n");
-    markup.append(T T "map mode=shadow address=80-9f:8000-ffff\n");
-    markup.append(T T "map mode=linear address=c0-df:0000-ffff\n");
-    markup.append(T "ram size=0x", hex(ram_size), "\n");
-    markup.append(T T "map mode=linear address=20-3f:6000-7fff\n");
-    markup.append(T T "map mode=linear address=a0-bf:6000-7fff\n");
-    markup.append(T "bsx\n");
-    markup.append(T T "slot\n");
-    markup.append(T T T "map mode=shadow address=20-3f:8000-ffff\n");
-    markup.append(T T T "map mode=linear address=60-7f:0000-ffff\n");
-    markup.append(T T T "map mode=shadow address=a0-bf:8000-ffff\n");
-    markup.append(T T T "map mode=linear address=e0-ff:0000-ffff\n");
-  } else if(mapper == BSXROM) {
-    markup.append(T "bsx\n");
-    markup.append(T T "mcu\n");
-    markup.append(T T T "map address=00-3f:8000-ffff\n");
-    markup.append(T T T "map address=80-bf:8000-ffff\n");
-    markup.append(T T T "map address=40-7f:0000-ffff\n");
-    markup.append(T T T "map address=c0-ff:0000-ffff\n");
-    markup.append(T T T "map address=20-3f:6000-7fff\n");
-    markup.append(T T "mmio\n");
-    markup.append(T T T "map address=00-3f:5000-5fff\n");
-    markup.append(T T T "map address=80-bf:5000-5fff\n");
-  } else if(mapper == STROM) {
-    markup.append(T "rom\n");
-    markup.append(T T "map mode=linear address=00-1f:8000-ffff\n");
-    markup.append(T T "map mode=linear address=80-9f:8000-ffff\n");
-    markup.append(T "sufamiturbo\n");
-    markup.append(T T "slot id=A\n");
-    markup.append(T T T "rom\n");
-    markup.append(T T T T "map mode=linear address=20-3f:8000-ffff\n");
-    markup.append(T T T T "map mode=linear address=a0-bf:8000-ffff\n");
-    markup.append(T T T "ram size=0x20000\n");
-    markup.append(T T T T "map mode=linear address=60-63:8000-ffff\n");
-    markup.append(T T T T "map mode=linear address=e0-e3:8000-ffff\n");
-    markup.append(T T "slot id=B\n");
-    markup.append(T T T "rom\n");
-    markup.append(T T T T "map mode=linear address=40-5f:8000-ffff\n");
-    markup.append(T T T T "map mode=linear address=c0-df:8000-ffff\n");
-    markup.append(T T T "ram size=0x20000\n");
-    markup.append(T T T T "map mode=linear address=70-73:8000-ffff\n");
-    markup.append(T T T T "map mode=linear address=f0-f3:8000-ffff\n");
+  else if(has_spc7110) {
+    markup.append(
+      "  <rom>\n"
+      "    <map mode='shadow' address='00-0f:8000-ffff'/>\n"
+      "    <map mode='shadow' address='80-bf:8000-ffff'/>\n"
+      "    <map mode='linear' address='c0-cf:0000-ffff'/>\n"
+      "  </rom>\n"
+      "  <spc7110>\n"
+      "    <ram size='0x", hex(ram_size), "'>\n"
+      "      <map mode='linear' address='00:6000-7fff'/>\n"
+      "      <map mode='linear' address='30:6000-7fff'/>\n"
+      "    </ram>\n"
+      "    <mmio>\n"
+      "      <map address='00-3f:4800-483f'/>\n"
+      "      <map address='80-bf:4800-483f'/>\n"
+      "    </mmio>\n"
+      "    <mcu>\n"
+      "      <map address='d0-ff:0000-ffff' offset='0x100000' size='0x", hex(size - 0x100000), "'/>\n"
+      "    </mcu>\n"
+      "    <dcu>\n"
+      "      <map address='50:0000-ffff'/>\n"
+      "    </dcu>\n"
+    );
+    if(has_spc7110rtc) markup.append(
+      "    <rtc>\n"
+      "      <map address='00-3f:4840-4842'/>\n"
+      "      <map address='80-bf:4840-4842'/>\n"
+      "    </rtc>\n"
+    );
+    markup.append(
+      "  </spc7110>\n"
+    );
   }
 
-  if(has_srtc) {
-    markup.append(T "srtc\n");
-    markup.append(T T "map address=00-3f:2800-2801\n");
-    markup.append(T T "map address=80-bf:2800-2801\n");
+  else if(mapper == LoROM) {
+    markup.append(
+      "  <rom>\n"
+      "    <map mode='linear' address='00-7f:8000-ffff'/>\n"
+      "    <map mode='linear' address='80-ff:8000-ffff'/>\n"
+      "  </rom>\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  <ram size='0x", hex(ram_size), "'>\n"
+      "    <map mode='linear' address='20-3f:6000-7fff'/>\n"
+      "    <map mode='linear' address='a0-bf:6000-7fff'/>\n"
+      "    <map mode='linear' address='70-7f:", range, "'/>\n"
+      "    <map mode='linear' address='f0-ff:", range, "'/>\n"
+      "  </ram>\n"
+    );
   }
 
-  if(has_sdd1) {
-    markup.append(T "sdd1\n");
-    markup.append(T T "mcu\n");
-    markup.append(T T T "map address=c0-ff:0000-ffff\n");
-    markup.append(T T "mmio\n");
-    markup.append(T T T "map address=00-3f:4800-4807\n");
-    markup.append(T T T "map address=80-bf:4800-4807\n");
+  else if(mapper == HiROM) {
+    markup.append(
+      "  <rom>\n"
+      "    <map mode='shadow' address='00-3f:8000-ffff'/>\n"
+      "    <map mode='linear' address='40-7f:0000-ffff'/>\n"
+      "    <map mode='shadow' address='80-bf:8000-ffff'/>\n"
+      "    <map mode='linear' address='c0-ff:0000-ffff'/>\n"
+      "  </rom>\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  <ram size='0x", hex(ram_size), "'>\n"
+      "    <map mode='linear' address='20-3f:6000-7fff'/>\n"
+      "    <map mode='linear' address='a0-bf:6000-7fff'/>\n"
+      "    <map mode='linear' address='70-7f:", range, "'/>\n"
+      "  </ram>\n"
+    );
   }
 
+  else if(mapper == ExLoROM) {
+    markup.append(
+      "  <rom>\n"
+      "    <map mode='linear' address='00-3f:8000-ffff'/>\n"
+      "    <map mode='linear' address='40-7f:0000-ffff'/>\n"
+      "    <map mode='linear' address='80-bf:8000-ffff'/>\n"
+      "  </rom>\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  <ram size='0x", hex(ram_size), "'>\n"
+      "    <map mode='linear' address='20-3f:6000-7fff'/>\n"
+      "    <map mode='linear' address='a0-bf:6000-7fff'/>\n"
+      "    <map mode='linear' address='70-7f:0000-7fff'/>\n"
+      "  </ram>\n"
+    );
+  }
+
+  else if(mapper == ExHiROM) {
+    markup.append(
+      "  <rom>\n"
+      "    <map mode='shadow' address='00-3f:8000-ffff' offset='0x400000'/>\n"
+      "    <map mode='linear' address='40-7f:0000-ffff' offset='0x400000'/>\n"
+      "    <map mode='shadow' address='80-bf:8000-ffff' offset='0x000000'/>\n"
+      "    <map mode='linear' address='c0-ff:0000-ffff' offset='0x000000'/>\n"
+      "  </rom>\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  <ram size='0x", hex(ram_size), "'>\n"
+      "    <map mode='linear' address='20-3f:6000-7fff'/>\n"
+      "    <map mode='linear' address='a0-bf:6000-7fff'/>\n"
+      "    <map mode='linear' address='70-7f:", range, "'/>\n"
+      "  </ram>\n"
+    );
+  }
+
+  else if(mapper == SuperFXROM) markup.append(
+    "  <superfx revision='2'>\n"
+    "    <rom>\n"
+    "      <map mode='linear' address='00-3f:8000-ffff'/>\n"
+    "      <map mode='linear' address='40-5f:0000-ffff'/>\n"
+    "      <map mode='linear' address='80-bf:8000-ffff'/>\n"
+    "      <map mode='linear' address='c0-df:0000-ffff'/>\n"
+    "    </rom>\n"
+    "    <ram size='0x", hex(ram_size), "'>\n"
+    "      <map mode='linear' address='00-3f:6000-7fff' size='0x2000'/>\n"
+    "      <map mode='linear' address='60-7f:0000-ffff'/>\n"
+    "      <map mode='linear' address='80-bf:6000-7fff' size='0x2000'/>\n"
+    "      <map mode='linear' address='e0-ff:0000-ffff'/>\n"
+    "    </ram>\n"
+    "    <mmio>\n"
+    "      <map address='00-3f:3000-32ff'/>\n"
+    "      <map address='80-bf:3000-32ff'/>\n"
+    "    </mmio>\n"
+    "  </superfx>\n"
+  );
+
+  else if(mapper == SA1ROM) markup.append(
+    "  <sa1>\n"
+    "    <mcu>\n"
+    "      <rom>\n"
+    "        <map mode='direct' address='00-3f:8000-ffff'/>\n"
+    "        <map mode='direct' address='80-bf:8000-ffff'/>\n"
+    "        <map mode='direct' address='c0-ff:0000-ffff'/>\n"
+    "      </rom>\n"
+    "      <ram>\n"
+    "        <map mode='direct' address='00-3f:6000-7fff'/>\n"
+    "        <map mode='direct' address='80-bf:6000-7fff'/>\n"
+    "      </ram>\n"
+    "    </mcu>\n"
+    "    <iram size='0x800'>\n"
+    "      <map mode='linear' address='00-3f:3000-37ff'/>\n"
+    "      <map mode='linear' address='80-bf:3000-37ff'/>\n"
+    "    </iram>\n"
+    "    <bwram size='0x", hex(ram_size), "'>\n"
+    "      <map mode='linear' address='40-4f:0000-ffff'/>\n"
+    "    </bwram>\n"
+    "    <mmio>\n"
+    "      <map address='00-3f:2200-23ff'/>\n"
+    "      <map address='80-bf:2200-23ff'/>\n"
+    "    </mmio>\n"
+    "  </sa1>\n"
+  );
+
+  else if(mapper == BSCLoROM) markup.append(
+    "  <rom>\n"
+    "    <map mode='linear' address='00-1f:8000-ffff' offset='0x000000'/>\n"
+    "    <map mode='linear' address='20-3f:8000-ffff' offset='0x100000'/>\n"
+    "    <map mode='linear' address='80-9f:8000-ffff' offset='0x200000'/>\n"
+    "    <map mode='linear' address='a0-bf:8000-ffff' offset='0x100000'/>\n"
+    "  </rom>\n"
+    "  <ram size='0x", hex(ram_size), "'>\n"
+    "    <map mode='linear' address='70-7f:0000-7fff'/>\n"
+    "    <map mode='linear' address='f0-ff:0000-7fff'/>\n"
+    "  </ram>\n"
+    "  <bsx>\n"
+    "    <slot>\n"
+    "      <map mode='linear' address='c0-ef:0000-ffff'/>\n"
+    "    </slot>\n"
+    "  </bsx>\n"
+  );
+
+  else if(mapper == BSCHiROM) markup.append(
+    "  <rom>\n"
+    "    <map mode='shadow' address='00-1f:8000-ffff'/>\n"
+    "    <map mode='linear' address='40-5f:0000-ffff'/>\n"
+    "    <map mode='shadow' address='80-9f:8000-ffff'/>\n"
+    "    <map mode='linear' address='c0-df:0000-ffff'/>\n"
+    "  </rom>\n"
+    "  <ram size='0x", hex(ram_size), "'>\n"
+    "    <map mode='linear' address='20-3f:6000-7fff'/>\n"
+    "    <map mode='linear' address='a0-bf:6000-7fff'/>\n"
+    "  </ram>\n"
+    "  <bsx>\n"
+    "    <slot>\n"
+    "      <map mode='shadow' address='20-3f:8000-ffff'/>\n"
+    "      <map mode='linear' address='60-7f:0000-ffff'/>\n"
+    "      <map mode='shadow' address='a0-bf:8000-ffff'/>\n"
+    "      <map mode='linear' address='e0-ff:0000-ffff'/>\n"
+    "    </slot>\n"
+    "  </bsx>\n"
+  );
+
+  else if(mapper == BSXROM) markup.append(
+    "  <bsx>\n"
+    "    <mcu>\n"
+    "      <map address='00-3f:8000-ffff'/>\n"
+    "      <map address='80-bf:8000-ffff'/>\n"
+    "      <map address='40-7f:0000-ffff'/>\n"
+    "      <map address='c0-ff:0000-ffff'/>\n"
+    "      <map address='20-3f:6000-7fff'/>\n"
+    "    </mcu>\n"
+    "    <mmio>\n"
+    "      <map address='00-3f:5000-5fff'/>\n"
+    "      <map address='80-bf:5000-5fff'/>\n"
+    "    </mmio>\n"
+    "  </bsx>\n"
+  );
+
+  else if(mapper == STROM) markup.append(
+    "  <rom>\n"
+    "    <map mode='linear' address='00-1f:8000-ffff'/>\n"
+    "    <map mode='linear' address='80-9f:8000-ffff'/>\n"
+    "  </rom>\n"
+    "  <sufamiturbo>\n"
+    "    <slot id='A'>\n"
+    "      <rom>\n"
+    "        <map mode='linear' address='20-3f:8000-ffff'/>\n"
+    "        <map mode='linear' address='a0-bf:8000-ffff'/>\n"
+    "      </rom>\n"
+    "      <ram size='0x20000'>\n"
+    "        <map mode='linear' address='60-63:8000-ffff'/>\n"
+    "        <map mode='linear' address='e0-e3:8000-ffff'/>\n"
+    "      </ram>\n"
+    "    </slot>\n"
+    "    <slot id='B'>\n"
+    "      <rom>\n"
+    "        <map mode='linear' address='40-5f:8000-ffff'/>\n"
+    "        <map mode='linear' address='c0-df:8000-ffff'/>\n"
+    "      </rom>\n"
+    "      <ram size='0x20000'>\n"
+    "        <map mode='linear' address='70-73:8000-ffff'/>\n"
+    "        <map mode='linear' address='f0-f3:8000-ffff'/>\n"
+    "      </ram>\n"
+    "    </slot>\n"
+    "  </sufamiturbo>\n"
+  );
+
+  if(has_srtc) markup.append(
+    "  <srtc>\n"
+    "    <map address='00-3f:2800-2801'/>\n"
+    "    <map address='80-bf:2800-2801'/>\n"
+    "  </srtc>\n"
+  );
+
+  if(has_sdd1) markup.append(
+    "  <sdd1>\n"
+    "    <mcu>\n"
+    "      <map address='c0-ff:0000-ffff'/>\n"
+    "    </mcu>\n"
+    "    <mmio>\n"
+    "      <map address='00-3f:4800-4807'/>\n"
+    "      <map address='80-bf:4800-4807'/>\n"
+    "    </mmio>\n"
+    "  </sdd1>\n"
+  );
+
+  if(has_obc1) markup.append(
+    "  <obc1>\n"
+    "    <map address='00-3f:6000-7fff'/>\n"
+    "    <map address='80-bf:6000-7fff'/>\n"
+    "  </obc1>\n"
+  );
+
   if(has_dsp1) {
-    markup.append(T "necdsp model=uPD7725 frequency=8000000 firmware=dsp1b.bin sha256=4d42db0f36faef263d6b93f508e8c1c4ae8fc2605fd35e3390ecc02905cd420c\n");
-    if(dsp1_mapper == DSP1LoROM1MB) {
-      markup.append(T T "dr\n");
-      markup.append(T T T "map address=20-3f:8000-bfff\n");
-      markup.append(T T T "map address=a0-bf:8000-bfff\n");
-      markup.append(T T "sr\n");
-      markup.append(T T T "map address=20-3f:c000-ffff\n");
-      markup.append(T T T "map address=a0-bf:c000-ffff\n");
-    } else if(dsp1_mapper == DSP1LoROM2MB) {
-      markup.append(T T "dr\n");
-      markup.append(T T T "map address=60-6f:0000-3fff\n");
-      markup.append(T T T "map address=e0-ef:0000-3fff\n");
-      markup.append(T T "sr\n");
-      markup.append(T T T "map address=60-6f:4000-7fff\n");
-      markup.append(T T T "map address=e0-ef:4000-7fff\n");
-    } else if(dsp1_mapper == DSP1HiROM) {
-      markup.append(T T "dr\n");
-      markup.append(T T T "map address=00-1f:6000-6fff\n");
-      markup.append(T T T "map address=80-9f:6000-6fff\n");
-      markup.append(T T "sr\n");
-      markup.append(T T T "map address=00-1f:7000-7fff\n");
-      markup.append(T T T "map address=80-9f:7000-7fff\n");
-    }
+    //91e87d11e1c30d172556bed2211cce2efa94ba595f58c5d264809ef4d363a97b  dsp1.rom
+    markup.append("  <necdsp model='uPD7725' frequency='8000000' firmware='dsp1b.rom' sha256='d789cb3c36b05c0b23b6c6f23be7aa37c6e78b6ee9ceac8d2d2aa9d8c4d35fa9'>\n");
+    if(dsp1_mapper == DSP1LoROM1MB) markup.append(
+      "    <dr>\n"
+      "      <map address='20-3f:8000-bfff'/>\n"
+      "      <map address='a0-bf:8000-bfff'/>\n"
+      "    </dr>\n"
+      "    <sr>\n"
+      "      <map address='20-3f:c000-ffff'/>\n"
+      "      <map address='a0-bf:c000-ffff'/>\n"
+      "    </sr>\n"
+    );
+    if(dsp1_mapper == DSP1LoROM2MB) markup.append(
+      "    <dr>\n"
+      "      <map address='60-6f:0000-3fff'/>\n"
+      "      <map address='e0-ef:0000-3fff'/>\n"
+      "    </dr>\n"
+      "    <sr>\n"
+      "      <map address='60-6f:4000-7fff'/>\n"
+      "      <map address='e0-ef:4000-7fff'/>\n"
+      "    </sr>\n"
+    );
+    if(dsp1_mapper == DSP1HiROM) markup.append(
+      "    <dr>\n"
+      "      <map address='00-1f:6000-6fff'/>\n"
+      "      <map address='80-9f:6000-6fff'/>\n"
+      "    </dr>\n"
+      "    <sr>\n"
+      "      <map address='00-1f:7000-7fff'/>\n"
+      "      <map address='80-9f:7000-7fff'/>\n"
+      "    </sr>\n"
+    );
+    markup.append("  </necdsp>\n");
   }
 
-  if(has_dsp2) {
-    markup.append(T "necdsp model=uPD7725 frequency=8000000 firmware=dsp2.bin sha256=5efbdf96ed0652790855225964f3e90e6a4d466cfa64df25b110933c6cf94ea1\n");
-    markup.append(T T "dr\n");
-    markup.append(T T T "map address=20-3f:8000-bfff\n");
-    markup.append(T T T "map address=a0-bf:8000-bfff\n");
-    markup.append(T T "sr\n");
-    markup.append(T T T "map address=20-3f:c000-ffff\n");
-    markup.append(T T T "map address=a0-bf:c000-ffff\n");
-  }
+  if(has_dsp2) markup.append(
+    "  <necdsp model='uPD7725' frequency='8000000' firmware='dsp2.rom' sha256='03ef4ef26c9f701346708cb5d07847b5203cf1b0818bf2930acd34510ffdd717'>\n"
+    "    <dr>\n"
+    "      <map address='20-3f:8000-bfff'/>\n"
+    "      <map address='a0-bf:8000-bfff'/>\n"
+    "    </dr>\n"
+    "    <sr>\n"
+    "      <map address='20-3f:c000-ffff'/>\n"
+    "      <map address='a0-bf:c000-ffff'/>\n"
+    "    </sr>\n"
+    "  </necdsp>\n"
+  );
 
-  if(has_dsp3) {
-    markup.append(T "necdsp model=uPD7725 frequency=8000000 firmware=dsp3.bin sha256=2e635f72e4d4681148bc35429421c9b946e4f407590e74e31b93b8987b63ba90\n");
-    markup.append(T T "dr\n");
-    markup.append(T T T "map address=20-3f:8000-bfff\n");
-    markup.append(T T T "map address=a0-bf:8000-bfff\n");
-    markup.append(T T "sr\n");
-    markup.append(T T T "map address=20-3f:c000-ffff\n");
-    markup.append(T T T "map address=a0-bf:c000-ffff\n");
-  }
+  if(has_dsp3) markup.append(
+    "  <necdsp model='uPD7725' frequency='8000000' firmware='dsp3.rom' sha256='0971b08f396c32e61989d1067dddf8e4b14649d548b2188f7c541b03d7c69e4e'>\n"
+    "    <dr>\n"
+    "      <map address='20-3f:8000-bfff'/>\n"
+    "      <map address='a0-bf:8000-bfff'/>\n"
+    "    </dr>\n"
+    "    <sr>\n"
+    "      <map address='20-3f:c000-ffff'/>\n"
+    "      <map address='a0-bf:c000-ffff'/>\n"
+    "    </sr>\n"
+    "  </necdsp>\n"
+  );
 
-  if(has_dsp4) {
-    markup.append(T "necdsp model=uPD7725 frequency=8000000 firmware=dsp4.bin sha256=63ede17322541c191ed1fdf683872554a0a57306496afc43c59de7c01a6e764a\n");
-    markup.append(T T "dr\n");
-    markup.append(T T T "map address=30-3f:8000-bfff\n");
-    markup.append(T T T "map address=b0-bf:8000-bfff\n");
-    markup.append(T T "sr\n");
-    markup.append(T T T "map address=30-3f:c000-ffff\n");
-    markup.append(T T T "map address=b0-bf:c000-ffff\n");
-  }
+  if(has_dsp4) markup.append(
+    "  <necdsp model='uPD7725' frequency='8000000' firmware='dsp4.rom' sha256='752d03b2d74441e430b7f713001fa241f8bbcfc1a0d890ed4143f174dbe031da'>\n"
+    "    <dr>\n"
+    "      <map address='30-3f:8000-bfff'/>\n"
+    "      <map address='b0-bf:8000-bfff'/>\n"
+    "    </dr>\n"
+    "    <sr>\n"
+    "      <map address='30-3f:c000-ffff'/>\n"
+    "      <map address='b0-bf:c000-ffff'/>\n"
+    "    </sr>\n"
+    "  </necdsp>\n"
+  );
 
-  if(has_obc1) {
-    markup.append(T "obc1\n");
-    markup.append(T T "map address=00-3f:6000-7fff\n");
-    markup.append(T T "map address=80-bf:6000-7fff\n");
-  }
+  if(has_st010) markup.append(
+    "  <necdsp model='uPD96050' frequency='10000000' firmware='st010.rom' sha256='fa9bced838fedea11c6f6ace33d1878024bdd0d02cc9485899d0bdd4015ec24c'>\n"
+    "    <dr>\n"
+    "      <map address='60:0000'/>\n"
+    "      <map address='e0:0000'/>\n"
+    "    </dr>\n"
+    "    <sr>\n"
+    "      <map address='60:0001'/>\n"
+    "      <map address='e0:0001'/>\n"
+    "    </sr>\n"
+    "    <dp>\n"
+    "      <map address='68-6f:0000-0fff'/>\n"
+    "      <map address='e8-ef:0000-0fff'/>\n"
+    "    </dp>\n"
+    "  </necdsp>\n"
+  );
 
-  if(has_st010) {
-    markup.append(T "necdsp model=uPD96050 frequency=10000000 firmware=st0010.bin sha256=55c697e864562445621cdf8a7bf6e84ae91361e393d382a3704e9aa55559041e\n");
-    markup.append(T T "dr\n");
-    markup.append(T T T "map address=60:0000\n");
-    markup.append(T T T "map address=e0:0000\n");
-    markup.append(T T "sr\n");
-    markup.append(T T T "map address=60:0001\n");
-    markup.append(T T T "map address=e0:0001\n");
-    markup.append(T T "dp\n");
-    markup.append(T T T "map address=68-6f:0000-0fff\n");
-    markup.append(T T T "map address=e8-ef:0000-0fff\n");
-  }
+  if(has_st011) markup.append(
+    "  <necdsp model='uPD96050' frequency='15000000' firmware='st011.rom' sha256='8b2b3f3f3e6e29f4d21d8bc736b400bc988b7d2214ebee15643f01c1fee2f364'>\n"
+    "    <dr>\n"
+    "      <map address='60:0000'/>\n"
+    "      <map address='e0:0000'/>\n"
+    "    </dr>\n"
+    "    <sr>\n"
+    "      <map address='60:0001'/>\n"
+    "      <map address='e0:0001'/>\n"
+    "    </sr>\n"
+    "    <dp>\n"
+    "      <map address='68-6f:0000-0fff'/>\n"
+    "      <map address='e8-ef:0000-0fff'/>\n"
+    "    </dp>\n"
+    "  </necdsp>\n"
+  );
 
-  if(has_st011) {
-    markup.append(T "necdsp model=uPD96050 frequency=15000000 firmware=st0011.bin sha256=651b82a1e26c4fa8dd549e91e7f923012ed2ca54c1d9fd858655ab30679c2f0e\n");
-    markup.append(T T "dr\n");
-    markup.append(T T T "map address=60:0000\n");
-    markup.append(T T T "map address=e0:0000\n");
-    markup.append(T T "sr\n");
-    markup.append(T T T "map address=60:0001\n");
-    markup.append(T T T "map address=e0:0001\n");
-    markup.append(T T "dp\n");
-    markup.append(T T T "map address=68-6f:0000-0fff\n");
-    markup.append(T T T "map address=e8-ef:0000-0fff\n");
-  }
+  if(has_st018) markup.append(
+    "  <armdsp firmware='st018.rom' frequency='21477272' sha256='6df209ab5d2524d1839c038be400ae5eb20dafc14a3771a3239cd9e8acd53806'>\n"
+    "    <map address='00-3f:3800-38ff'/>\n"
+    "    <map address='80-bf:3800-38ff'/>\n"
+    "  </armdsp>\n"
+  );
 
-  if(has_st018) {
-    markup.append(T "setarisc firmware=ST-0018\n");
-    markup.append(T T "map address=00-3f:3800-38ff\n");
-    markup.append(T T "map address=80-bf:3800-38ff\n");
-  }
+  markup.append("</cartridge>\n");
 }
 
-#undef T
-
 void SnesCartridge::read_header(const uint8_t *data, unsigned size) {
   type        = TypeUnknown;
   mapper      = LoROM;

bsnes/nall/snes/usart.hpp

@@ -0,0 +1,70 @@
+#ifndef NALL_SNES_USART_HPP
+#define NALL_SNES_USART_HPP
+
+#include <nall/platform.hpp>
+#include <nall/function.hpp>
+#include <nall/serial.hpp>
+#include <nall/stdint.hpp>
+
+#define usartproc dllexport
+
+static nall::function<void (unsigned milliseconds)> usart_usleep;
+static nall::function<uint8_t ()> usart_read;
+static nall::function<void (uint8_t data)> usart_write;
+
+extern "C" usartproc void usart_init(
+  nall::function<void (unsigned milliseconds)> usleep,
+  nall::function<uint8_t ()> read,
+  nall::function<void (uint8_t data)> write
+) {
+  usart_usleep = usleep;
+  usart_read = read;
+  usart_write = write;
+}
+
+extern "C" usartproc void usart_main();
+
+//
+
+static nall::serial usart;
+static bool usart_is_virtual = true;
+
+static bool usart_virtual() {
+  return usart_is_virtual;
+}
+
+//
+
+static void usarthw_usleep(unsigned milliseconds) {
+  usleep(milliseconds);
+}
+
+static uint8_t usarthw_read() {
+  while(true) {
+    uint8_t buffer[1];
+    signed length = usart.read((uint8_t*)&buffer, 1);
+    if(length > 0) return buffer[0];
+  }
+}
+
+static void usarthw_write(uint8_t data) {
+  uint8_t buffer[1] = { data };
+  usart.write((uint8_t*)&buffer, 1);
+}
+
+int main(int argc, char **argv) {
+  bool result = false;
+  if(argc == 1) result = usart.open("/dev/ttyACM0", 57600, true);
+  if(argc == 2) result = usart.open(argv[1], 57600, true);
+  if(result == false) {
+    printf("error: unable to open USART hardware device\n");
+    return 0;
+  }
+  usart_is_virtual = false;
+  usart_init(usarthw_usleep, usarthw_read, usarthw_write);
+  usart_main();
+  usart.close();
+  return 0;
+}
+
+#endif

bsnes/nall/sort.hpp

@@ -1,6 +1,7 @@
 #ifndef NALL_SORT_HPP
 #define NALL_SORT_HPP
 
+#include <algorithm>
 #include <nall/utility.hpp>
 
 //class:   merge sort
@@ -10,53 +11,67 @@
 //stack:   O(log n)
 //stable?: yes
 
-//notes:
-//there are two primary reasons for choosing merge sort
-//over the (usually) faster quick sort*:
-//1: it is a stable sort.
-//2: it lacks O(n^2) worst-case overhead.
-//(* which is also O(n log n) in the average case.)
+//note: merge sort was chosen over quick sort, because:
+//* it is a stable sort
+//* it lacks O(n^2) worst-case overhead
+
+#define NALL_SORT_INSERTION
+//#define NALL_SORT_SELECTION
 
 namespace nall {
-  template<typename T>
-  void sort(T list[], unsigned length) {
-    if(length <= 1) return;  //nothing to sort
+  template<typename T, typename Comparator>
+  void sort(T list[], unsigned size, const Comparator &lessthan) {
+    if(size <= 1) return;  //nothing to sort
 
     //use insertion sort to quickly sort smaller blocks
-    if(length < 64) {
-      for(unsigned i = 0; i < length; i++) {
-        unsigned min = i;
-        for(unsigned j = i + 1; j < length; j++) {
-          if(list[j] < list[min]) min = j;
+    if(size < 64) {
+      #if defined(NALL_SORT_INSERTION)
+      for(signed i = 1, j; i < size; i++) {
+        T copy = std::move(list[i]);
+        for(j = i - 1; j >= 0; j--) {
+          if(lessthan(list[j], copy)) break;
+          list[j + 1] = std::move(list[j]);
         }
-        if(min != i) swap(list[i], list[min]);
+        list[j + 1] = std::move(copy);
       }
+      #elif defined(NALL_SORT_SELECTION)
+      for(unsigned i = 0; i < size; i++) {
+        unsigned min = i;
+        for(unsigned j = i + 1; j < size; j++) {
+          if(lessthan(list[j], list[min])) min = j;
+        }
+        if(min != i) std::swap(list[i], list[min]);
+      }
+      #endif
       return;
     }
 
     //split list in half and recursively sort both
-    unsigned middle = length / 2;
-    sort(list, middle);
-    sort(list + middle, length - middle);
+    unsigned middle = size / 2;
+    sort(list, middle, lessthan);
+    sort(list + middle, size - middle, lessthan);
 
     //left and right are sorted here; perform merge sort
-    T *buffer = new T[length];
-    unsigned offset = 0;
-    unsigned left   = 0;
-    unsigned right  = middle;
-    while(left < middle && right < length) {
-      if(list[left] < list[right]) {
-        buffer[offset++] = list[left++];
+    T *buffer = new T[size];
+    unsigned offset = 0, left = 0, right = middle;
+    while(left < middle && right < size) {
+      if(lessthan(list[left], list[right])) {
+        buffer[offset++] = std::move(list[left++]);
       } else {
-        buffer[offset++] = list[right++];
+        buffer[offset++] = std::move(list[right++]);
       }
     }
-    while(left  < middle) buffer[offset++] = list[left++];
-    while(right < length) buffer[offset++] = list[right++];
+    while(left < middle) buffer[offset++] = std::move(list[left++]);
+    while(right < size)  buffer[offset++] = std::move(list[right++]);
 
-    for(unsigned i = 0; i < length; i++) list[i] = buffer[i];
+    for(unsigned i = 0; i < size; i++) list[i] = std::move(buffer[i]);
     delete[] buffer;
   }
+
+  template<typename T>
+  void sort(T list[], unsigned size) {
+    return sort(list, size, [](const T &l, const T &r) { return l < r; });
+  }
 }
 
 #endif

bsnes/nall/stack.hpp

@@ -1,26 +0,0 @@
-#ifndef NALL_STACK_HPP
-#define NALL_STACK_HPP
-
-#include <nall/vector.hpp>
-
-namespace nall {
-  template<typename T> struct stack : public linear_vector<T> {
-    void push(const T &value) {
-      linear_vector<T>::append(value);
-    }
-
-    T pull() {
-      if(linear_vector<T>::size() == 0) throw;
-      T value = linear_vector<T>::operator[](linear_vector<T>::size() - 1);
-      linear_vector<T>::remove(linear_vector<T>::size() - 1);
-      return value;
-    }
-
-    T& operator()() {
-      if(linear_vector<T>::size() == 0) throw;
-      return linear_vector<T>::operator[](linear_vector<T>::size() - 1);
-    }
-  };
-}
-
-#endif

bsnes/nall/static.hpp

@@ -1,20 +0,0 @@
-#ifndef NALL_STATIC_HPP
-#define NALL_STATIC_HPP
-
-namespace nall {
-  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 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<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

bsnes/nall/stdint.hpp

@@ -1,8 +1,6 @@
 #ifndef NALL_STDINT_HPP
 #define NALL_STDINT_HPP
 
-#include <nall/static.hpp>
-
 #if defined(_MSC_VER)
   typedef signed char int8_t;
   typedef signed short int16_t;

bsnes/nall/stream.hpp

@@ -0,0 +1,26 @@
+#ifndef NALL_STREAM_HPP
+#define NALL_STREAM_HPP
+
+#include <algorithm>
+#include <memory>
+
+#include <nall/file.hpp>
+#include <nall/filemap.hpp>
+#include <nall/gzip.hpp>
+#include <nall/http.hpp>
+#include <nall/stdint.hpp>
+#include <nall/string.hpp>
+#include <nall/zip.hpp>
+
+#define NALL_STREAM_INTERNAL_HPP
+#include <nall/stream/stream.hpp>
+#include <nall/stream/memory.hpp>
+#include <nall/stream/mmap.hpp>
+#include <nall/stream/file.hpp>
+#include <nall/stream/http.hpp>
+#include <nall/stream/gzip.hpp>
+#include <nall/stream/zip.hpp>
+#include <nall/stream/auto.hpp>
+#undef NALL_STREAM_INTERNAL_HPP
+
+#endif

bsnes/nall/stream/auto.hpp

@@ -0,0 +1,24 @@
+#ifdef NALL_STREAM_INTERNAL_HPP
+
+namespace nall {
+
+#define autostream(...) (*makestream(__VA_ARGS__))
+
+inline std::unique_ptr<stream> makestream(const string &path) {
+  if(path.ibeginswith("http://")) return std::unique_ptr<stream>(new httpstream(path, 80));
+  if(path.iendswith(".gz")) return std::unique_ptr<stream>(new gzipstream(filestream{path}));
+  if(path.iendswith(".zip")) return std::unique_ptr<stream>(new zipstream(filestream{path}));
+  return std::unique_ptr<stream>(new mmapstream(path));
+}
+
+inline std::unique_ptr<stream> makestream(uint8_t *data, unsigned size) {
+  return std::unique_ptr<stream>(new memorystream(data, size));
+}
+
+inline std::unique_ptr<stream> makestream(const uint8_t *data, unsigned size) {
+  return std::unique_ptr<stream>(new memorystream(data, size));
+}
+
+}
+
+#endif

bsnes/nall/stream/file.hpp

@@ -0,0 +1,31 @@
+#ifdef NALL_STREAM_INTERNAL_HPP
+
+namespace nall {
+
+struct filestream : stream {
+  inline bool seekable() const { return true; }
+  inline bool readable() const { return true; }
+  inline bool writable() const { return pwritable; }
+  inline bool randomaccess() const { return false; }
+
+  inline unsigned size() const { return pfile.size(); }
+  inline unsigned offset() const { return pfile.offset(); }
+  inline void seek(unsigned offset) const { pfile.seek(offset); }
+
+  inline uint8_t read() const { return pfile.read(); }
+  inline void write(uint8_t data) const { pfile.write(data); }
+
+  inline filestream(const string &filename) {
+    pfile.open(filename, file::mode::readwrite);
+    pwritable = pfile.open();
+    if(!pwritable) pfile.open(filename, file::mode::read);
+  }
+
+private:
+  mutable file pfile;
+  bool pwritable;
+};
+
+}
+
+#endif

bsnes/nall/stream/gzip.hpp

@@ -0,0 +1,28 @@
+#ifdef NALL_STREAM_INTERNAL_HPP
+
+namespace nall {
+
+struct gzipstream : memorystream {
+  inline gzipstream(const stream &stream) {
+    unsigned size = stream.size();
+    uint8_t *data = new uint8_t[size];
+    stream.read(data, size);
+
+    gzip archive;
+    bool result = archive.decompress(data, size);
+    delete[] data;
+    if(result == false) return;
+
+    psize = archive.size;
+    pdata = new uint8_t[psize];
+    memcpy(pdata, archive.data, psize);
+  }
+
+  inline ~gzipstream() {
+    if(pdata) delete[] pdata;
+  }
+};
+
+}
+
+#endif

bsnes/nall/stream/http.hpp

@@ -0,0 +1,43 @@
+#ifdef NALL_STREAM_INTERNAL_HPP
+
+namespace nall {
+
+struct httpstream : stream {
+  inline bool seekable() const { return true; }
+  inline bool readable() const { return true; }
+  inline bool writable() const { return true; }
+  inline bool randomaccess() const { return true; }
+
+  inline unsigned size() const { return psize; }
+  inline unsigned offset() const { return poffset; }
+  inline void seek(unsigned offset) const { poffset = offset; }
+
+  inline uint8_t read() const { return pdata[poffset++]; }
+  inline void write(uint8_t data) const { pdata[poffset++] = data; }
+
+  inline uint8_t read(unsigned offset) const { return pdata[offset]; }
+  inline void write(unsigned offset, uint8_t data) const { pdata[offset] = data; }
+
+  inline httpstream(const string &url, unsigned port) : pdata(nullptr), psize(0), poffset(0) {
+    string uri = url;
+    uri.ltrim<1>("http://");
+    lstring part = uri.split<1>("/");
+    part[1] = { "/", part[1] };
+
+    http connection;
+    if(connection.connect(part[0], port) == false) return;
+    connection.download(part[1], pdata, psize);
+  }
+
+  inline ~httpstream() {
+    if(pdata) delete[] pdata;
+  }
+
+private:
+  mutable uint8_t *pdata;
+  mutable unsigned psize, poffset;
+};
+
+}
+
+#endif

bsnes/nall/stream/memory.hpp

@@ -0,0 +1,40 @@
+#ifdef NALL_STREAM_INTERNAL_HPP
+
+namespace nall {
+
+struct memorystream : stream {
+  inline bool seekable() const { return true; }
+  inline bool readable() const { return true; }
+  inline bool writable() const { return pwritable; }
+  inline bool randomaccess() const { return true; }
+
+  inline unsigned size() const { return psize; }
+  inline unsigned offset() const { return poffset; }
+  inline void seek(unsigned offset) const { poffset = offset; }
+
+  inline uint8_t read() const { return pdata[poffset++]; }
+  inline void write(uint8_t data) const { pdata[poffset++] = data; }
+
+  inline uint8_t read(unsigned offset) const { return pdata[offset]; }
+  inline void write(unsigned offset, uint8_t data) const { pdata[offset] = data; }
+
+  inline memorystream() : pdata(nullptr), psize(0), poffset(0), pwritable(true) {}
+
+  inline memorystream(uint8_t *data, unsigned size) {
+    pdata = data, psize = size, poffset = 0;
+    pwritable = true;
+  }
+
+  inline memorystream(const uint8_t *data, unsigned size) {
+    pdata = (uint8_t*)data, psize = size, poffset = 0;
+    pwritable = false;
+  }
+
+protected:
+  mutable uint8_t *pdata;
+  mutable unsigned psize, poffset, pwritable;
+};
+
+}
+
+#endif

bsnes/nall/stream/mmap.hpp

@@ -0,0 +1,36 @@
+#ifdef NALL_STREAM_INTERNAL_HPP
+
+namespace nall {
+
+struct mmapstream : stream {
+  inline bool seekable() const { return true; }
+  inline bool readable() const { return true; }
+  inline bool writable() const { return pwritable; }
+  inline bool randomaccess() const { return false; }
+
+  inline unsigned size() const { return pmmap.size(); }
+  inline unsigned offset() const { return poffset; }
+  inline void seek(unsigned offset) const { poffset = offset; }
+
+  inline uint8_t read() const { return pdata[poffset++]; }
+  inline void write(uint8_t data) const { pdata[poffset++] = data; }
+
+  inline uint8_t read(unsigned offset) const { return pdata[offset]; }
+  inline void write(unsigned offset, uint8_t data) const { pdata[offset] = data; }
+
+  inline mmapstream(const string &filename) {
+    pmmap.open(filename, filemap::mode::readwrite);
+    pwritable = pmmap.open();
+    if(!pwritable) pmmap.open(filename, filemap::mode::read);
+    pdata = pmmap.data(), poffset = 0;
+  }
+
+private:
+  mutable filemap pmmap;
+  mutable uint8_t *pdata;
+  mutable unsigned pwritable, poffset;
+};
+
+}
+
+#endif

bsnes/nall/stream/stream.hpp

@@ -0,0 +1,90 @@
+#ifndef NALL_STREAM_STREAM_HPP
+#define NALL_STREAM_STREAM_HPP
+
+namespace nall {
+
+struct stream {
+  virtual bool seekable() const = 0;
+  virtual bool readable() const = 0;
+  virtual bool writable() const = 0;
+  virtual bool randomaccess() const = 0;
+
+  virtual unsigned size() const = 0;
+  virtual unsigned offset() const = 0;
+  virtual void seek(unsigned offset) const = 0;
+
+  virtual uint8_t read() const = 0;
+  virtual void write(uint8_t data) const = 0;
+
+  inline virtual uint8_t read(unsigned) const { return 0; }
+  inline virtual void write(unsigned, uint8_t) const {}
+
+  inline bool end() const {
+    return offset() >= size();
+  }
+
+  inline void copy(uint8_t *&data, unsigned &length) const {
+    seek(0);
+    length = size();
+    data = new uint8_t[length];
+    for(unsigned n = 0; n < length; n++) data[n] = read();
+  }
+
+  inline uintmax_t readl(unsigned length = 1) const {
+    uintmax_t data = 0, shift = 0;
+    while(length--) { data |= read() << shift; shift += 8; }
+    return data;
+  }
+
+  inline uintmax_t readm(unsigned length = 1) const {
+    uintmax_t data = 0;
+    while(length--) data = (data << 8) | read();
+    return data;
+  }
+
+  inline void read(uint8_t *data, unsigned length) const {
+    while(length--) *data++ = read();
+  }
+
+  inline void writel(uintmax_t data, unsigned length = 1) const {
+    while(length--) {
+      write(data);
+      data >>= 8;
+    }
+  }
+
+  inline void writem(uintmax_t data, unsigned length = 1) const {
+    uintmax_t shift = 8 * length;
+    while(length--) {
+      shift -= 8;
+      write(data >> shift);
+    }
+  }
+
+  inline void write(const uint8_t *data, unsigned length) const {
+    while(length--) write(*data++);
+  }
+
+  struct byte {
+    inline operator uint8_t() const { return s.read(offset); }
+    inline byte& operator=(uint8_t data) { s.write(offset, data); }
+    inline byte(const stream &s, unsigned offset) : s(s), offset(offset) {}
+
+  private:
+    const stream &s;
+    const unsigned offset;
+  };
+
+  inline byte operator[](unsigned offset) const {
+    return byte(*this, offset);
+  }
+
+  inline stream() {}
+  inline virtual ~stream() {}
+  stream(const stream&) = delete;
+  stream& operator=(const stream&) = delete;
+};
+
+}
+
+#endif

bsnes/nall/stream/zip.hpp

@@ -0,0 +1,30 @@
+#ifdef NALL_STREAM_INTERNAL_HPP
+
+namespace nall {
+
+struct zipstream : memorystream {
+  inline zipstream(const stream &stream, const string &filter = "*") {
+    unsigned size = stream.size();
+    uint8_t *data = new uint8_t[size];
+    stream.read(data, size);
+
+    zip archive;
+    if(archive.open(data, size) == false) return;
+    delete[] data;
+
+    for(auto &file : archive.file) {
+      if(file.name.wildcard(filter)) {
+        archive.extract(file, pdata, psize);
+        return;
+      }
+    }
+  }
+
+  inline ~zipstream() {
+    if(pdata) delete[] pdata;
+  }
+};
+
+}
+
+#endif

bsnes/nall/string.hpp

@@ -16,6 +16,7 @@
 #include <nall/sha256.hpp>
 #include <nall/stdint.hpp>
 #include <nall/utility.hpp>
+#include <nall/varint.hpp>
 #include <nall/vector.hpp>
 
 #include <nall/windows/utf8.hpp>
@@ -24,21 +25,24 @@
 #include <nall/string/base.hpp>
 #include <nall/string/bml.hpp>
 #include <nall/string/bsv.hpp>
-#include <nall/string/core.hpp>
 #include <nall/string/cast.hpp>
 #include <nall/string/compare.hpp>
 #include <nall/string/convert.hpp>
+#include <nall/string/core.hpp>
 #include <nall/string/cstring.hpp>
 #include <nall/string/filename.hpp>
-#include <nall/string/math.hpp>
+#include <nall/string/math-fixed-point.hpp>
+#include <nall/string/math-floating-point.hpp>
 #include <nall/string/platform.hpp>
-#include <nall/string/strl.hpp>
+#include <nall/string/strm.hpp>
 #include <nall/string/strpos.hpp>
 #include <nall/string/trim.hpp>
 #include <nall/string/replace.hpp>
 #include <nall/string/split.hpp>
+#include <nall/string/utf8.hpp>
 #include <nall/string/utility.hpp>
 #include <nall/string/variadic.hpp>
+#include <nall/string/wildcard.hpp>
 #include <nall/string/wrapper.hpp>
 #include <nall/string/xml.hpp>
 #undef NALL_STRING_INTERNAL_HPP

bsnes/nall/string/base.hpp

@@ -23,6 +23,7 @@ namespace nall {
 
   struct string {
     inline void reserve(unsigned);
+    inline bool empty() const;
 
     template<typename... Args> inline string& assign(Args&&... args);
     template<typename... Args> inline string& append(Args&&... args);
@@ -35,6 +36,7 @@ namespace nall {
     template<unsigned Limit = 0> inline string& iqreplace(const char*, const char*);
 
     inline unsigned length() const;
+    inline unsigned capacity() const;
 
     template<unsigned Limit = 0> inline lstring split(const char*) const;
     template<unsigned Limit = 0> inline lstring isplit(const char*) const;
@@ -128,8 +130,6 @@ namespace nall {
   inline char chrlower(char c);
   inline char chrupper(char c);
   inline int istrcmp(const char *str1, const char *str2);
-  inline bool wildcard(const char *str, const char *pattern);
-  inline bool iwildcard(const char *str, const char *pattern);
   inline bool strbegin(const char *str, const char *key);
   inline bool istrbegin(const char *str, const char *key);
   inline bool strend(const char *str, const char *key);
@@ -151,9 +151,12 @@ namespace nall {
   inline string userpath();
   inline string currentpath();
 
-  //strl.hpp
-  inline unsigned strlcpy(char *dest, const char *src, unsigned length);
-  inline unsigned strlcat(char *dest, const char *src, unsigned length);
+  //strm.hpp
+  inline unsigned strmcpy(char *target, const char *source, unsigned length);
+  inline unsigned strmcat(char *target, const char *source, unsigned length);
+  inline bool strccpy(char *target, const char *source, unsigned length);
+  inline bool strccat(char *target, const char *source, unsigned length);
+  inline void strpcpy(char *&target, const char *source, unsigned &length);
 
   //strpos.hpp
   inline optional<unsigned> strpos(const char *str, const char *key);
@@ -171,8 +174,6 @@ namespace nall {
   template<bool Insensitive> alwaysinline bool chrequal(char x, char y);
   template<bool Quoted, typename T> alwaysinline bool quoteskip(T *&p);
   template<bool Quoted, typename T> alwaysinline bool quotecopy(char *&t, T *&p);
-  inline unsigned strlcpy(string &dest, const char *src, unsigned length);
-  inline unsigned strlcat(string &dest, const char *src, unsigned length);
   inline string substr(const char *src, unsigned start = 0, unsigned length = ~0u);
   inline string sha256(const uint8_t *data, unsigned size);
 
@@ -185,11 +186,15 @@ namespace nall {
   template<unsigned length = 0, char padding = ' '> inline string ldecimal(uintmax_t value);
   template<unsigned length = 0, char padding = '0'> inline string hex(uintmax_t value);
   template<unsigned length = 0, char padding = '0'> inline string binary(uintmax_t value);
-  inline unsigned fp(char *str, double value);
-  inline string fp(double value);
+  inline unsigned fp(char *str, long double value);
+  inline string fp(long double value);
 
   //variadic.hpp
   template<typename... Args> inline void print(Args&&... args);
+
+  //wildcard.hpp
+  inline bool wildcard(const char *str, const char *pattern);
+  inline bool iwildcard(const char *str, const char *pattern);
 };
 
 #endif

bsnes/nall/string/bml.hpp

@@ -20,7 +20,7 @@ struct Node {
   cstring value;
 
 private:
-  linear_vector<Node> children;
+  vector<Node> children;
 
   inline bool valid(char p) const {  //A-Za-z0-9-.
     return p - 'A' < 26u | p - 'a' < 26u | p - '0' < 10u | p - '-' < 2u;

bsnes/nall/string/cast.hpp

@@ -2,39 +2,184 @@
 
 namespace nall {
 
-//this is needed, as C++0x does not support explicit template specialization inside classes
-template<> inline const char* to_string<bool>(bool v) { return v ? "true" : "false"; }
-template<> inline const char* to_string<char>(char v) { static char temp[256]; return integer(temp, v); }
+//convert any (supported) type to a const char* without constructing a new nall::string
+//this is used inside istring(...) to build nall::string values
+template<typename T> struct stringify;
 
-template<> inline const char* to_string<signed char>     (signed char v)      { static char temp[256]; return integer(temp, v); }
-template<> inline const char* to_string<signed short>    (signed short v)     { static char temp[256]; return integer(temp, v); }
-template<> inline const char* to_string<signed int>      (signed int v)       { static char temp[256]; return integer(temp, v); }
-template<> inline const char* to_string<signed long>     (signed long v)      { static char temp[256]; return integer(temp, v); }
-template<> inline const char* to_string<signed long long>(signed long long v) { static char temp[256]; return integer(temp, v); }
+// base types
 
-template<> inline const char* to_string<unsigned char>     (unsigned char v)      { static char temp[256]; return decimal(temp, v); }
-template<> inline const char* to_string<unsigned short>    (unsigned short v)     { static char temp[256]; return decimal(temp, v); }
-template<> inline const char* to_string<unsigned int>      (unsigned int v)       { static char temp[256]; return decimal(temp, v); }
-template<> inline const char* to_string<unsigned long>     (unsigned long v)      { static char temp[256]; return decimal(temp, v); }
-template<> inline const char* to_string<unsigned long long>(unsigned long long v) { static char temp[256]; return decimal(temp, v); }
+template<> struct stringify<bool> {
+  bool value;
+  operator const char*() const { return value ? "true" : "false"; }
+  stringify(bool value) : value(value) {}
+};
 
-template<> inline const char* to_string<float>      (float v)       { static char temp[256]; snprintf(temp, 255, "%f", v); return temp; }
-template<> inline const char* to_string<double>     (double v)      { static char temp[256]; snprintf(temp, 255, "%f", v); return temp; }
-template<> inline const char* to_string<long double>(long double v) { static char temp[256]; snprintf(temp, 255, "%Lf", v); return temp; }
+template<> struct stringify<char> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(char value) { integer(data, value); }
+};
 
-template<> inline const char* to_string<char*>         (char *v)          { return v; }
-template<> inline const char* to_string<const char*>   (const char *v)    { return v; }
-template<> inline const char* to_string<string>        (string v)         { return v; }
-template<> inline const char* to_string<const string&> (const string &v)  { return v; }
-template<> inline const char* to_string<cstring>       (cstring v)        { return v; }
-template<> inline const char* to_string<const cstring&>(const cstring &v) { return v; }
+// signed integers
+
+template<> struct stringify<signed char> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(signed char value) { integer(data, value); }
+};
+
+template<> struct stringify<signed short> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(signed short value) { integer(data, value); }
+};
+
+template<> struct stringify<signed int> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(signed int value) { integer(data, value); }
+};
+
+template<> struct stringify<signed long> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(signed long value) { integer(data, value); }
+};
+
+template<> struct stringify<signed long long> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(signed long long value) { integer(data, value); }
+};
+
+template<unsigned bits> struct stringify<int_t<bits>> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(int_t<bits> value) { integer(data, value); }
+};
+
+// unsigned integers
+
+template<> struct stringify<unsigned char> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(unsigned char value) { decimal(data, value); }
+};
+
+template<> struct stringify<unsigned short> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(unsigned short value) { decimal(data, value); }
+};
+
+template<> struct stringify<unsigned int> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(unsigned int value) { decimal(data, value); }
+};
+
+template<> struct stringify<unsigned long> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(unsigned long value) { decimal(data, value); }
+};
+
+template<> struct stringify<unsigned long long> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(unsigned long long value) { decimal(data, value); }
+};
+
+template<unsigned bits> struct stringify<uint_t<bits>> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(uint_t<bits> value) { decimal(data, value); }
+};
+
+// floating-point
+
+template<> struct stringify<float> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(float value) { fp(data, value); }
+};
+
+template<> struct stringify<double> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(double value) { fp(data, value); }
+};
+
+template<> struct stringify<long double> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(long double value) { fp(data, value); }
+};
+
+// strings
+
+template<> struct stringify<char*> {
+  const char *value;
+  operator const char*() const { return value; }
+  stringify(char *value) : value(value) {}
+};
+
+template<> struct stringify<const char*> {
+  const char *value;
+  operator const char*() const { return value; }
+  stringify(const char *value) : value(value) {}
+};
+
+template<> struct stringify<string> {
+  const string &value;
+  operator const char*() const { return value; }
+  stringify(const string &value) : value(value) {}
+};
+
+template<> struct stringify<const string&> {
+  const string &value;
+  operator const char*() const { return value; }
+  stringify(const string &value) : value(value) {}
+};
+
+template<> struct stringify<cstring> {
+  const char *value;
+  operator const char*() const { return value; }
+  stringify(const cstring &value) : value(value) {}
+};
+
+template<> struct stringify<const cstring&> {
+  const char *value;
+  operator const char*() const { return value; }
+  stringify(const cstring &value) : value(value) {}
+};
 
 #if defined(QSTRING_H)
-template<> inline const char* to_string<QString>(QString v) { return v.toUtf8().constData(); }
-template<> inline const char* to_string<const QString&>(const QString &v) { return v.toUtf8().constData(); }
-string::operator QString() const { return QString::fromUtf8(*this); }
+
+template<> struct stringify<QString> {
+  const QString &value;
+  operator const char*() const { return value.toUtf8().constData(); }
+  stringify(const QString &value) : value(value) {}
+};
+
+template<> struct stringify<const QString&> {
+  const QString &value;
+  operator const char*() const { return value.toUtf8().constData(); }
+  stringify(const QString &value) : value(value) {}
+};
+
+string::operator QString() const {
+  return QString::fromUtf8(*this);
+}
+
 #endif
 
+//
+
+template<typename T> stringify<T> make_string(T value) {
+  return stringify<T>(std::forward<T>(value));
+}
+
 }
 
 #endif

bsnes/nall/string/compare.hpp

@@ -18,46 +18,6 @@ int istrcmp(const char *str1, const char *str2) {
   return (int)chrlower(*str1) - (int)chrlower(*str2);
 }
 
-bool wildcard(const char *s, const char *p) {
-  const char *cp = 0, *mp = 0;
-  while(*s && *p != '*') {
-    if(*p != '?' && *s != *p) return false;
-    p++, s++;
-  }
-  while(*s) {
-    if(*p == '*') {
-      if(!*++p) return true;
-      mp = p, cp = s + 1;
-    } else if(*p == '?' || *p == *s) {
-      p++, s++;
-    } else {
-      p = mp, s = cp++;
-    }
-  }
-  while(*p == '*') p++;
-  return !*p;
-}
-
-bool iwildcard(const char *s, const char *p) {
-  const char *cp = 0, *mp = 0;
-  while(*s && *p != '*') {
-    if(*p != '?' && chrlower(*s) != chrlower(*p)) return false;
-    p++, s++;
-  }
-  while(*s) {
-    if(*p == '*') {
-      if(!*++p) return true;
-      mp = p, cp = s + 1;
-    } else if(*p == '?' || chrlower(*p) == chrlower(*s)) {
-      p++, s++;
-    } else {
-      p = mp, s = cp++;
-    }
-  }
-  while(*p == '*') p++;
-  return !*p;
-}
-
 bool strbegin(const char *str, const char *key) {
   int i, ssl = strlen(str), ksl = strlen(key);
 

bsnes/nall/string/core.hpp

@@ -7,7 +7,7 @@ static void istring(string &output) {
 
 template<typename T, typename... Args>
 static void istring(string &output, const T &value, Args&&... args) {
-  output.append_(to_string(value));
+  output.append_(make_string(value));
   istring(output, std::forward<Args>(args)...);
 }
 
@@ -19,6 +19,10 @@ void string::reserve(unsigned size_) {
   }
 }
 
+bool string::empty() const {
+  return !*data;
+}
+
 template<typename... Args> string& string::assign(Args&&... args) {
   *data = 0;
   istring(*this, std::forward<Args>(args)...);

bsnes/nall/string/math-fixed-point.hpp

@@ -0,0 +1,166 @@
+#ifdef NALL_STRING_INTERNAL_HPP
+
+namespace fixedpoint {
+
+static nall::function<intmax_t (const char *&)> eval_fallback;
+
+static intmax_t eval_integer(const char *& s) {
+  if(!*s) throw "unrecognized integer";
+  intmax_t value = 0, x = *s, y = *(s + 1);
+
+  //hexadecimal
+  if(x == '0' && (y == 'X' || y == 'x')) {
+    s += 2;
+    while(true) {
+      if(*s >= '0' && *s <= '9') { value = value * 16 + (*s++ - '0');      continue; }
+      if(*s >= 'A' && *s <= 'F') { value = value * 16 + (*s++ - 'A' + 10); continue; }
+      if(*s >= 'a' && *s <= 'f') { value = value * 16 + (*s++ - 'a' + 10); continue; }
+      return value;
+    }
+  }
+
+  //binary
+  if(x == '0' && (y == 'B' || y == 'b')) {
+    s += 2;
+    while(true) {
+      if(*s == '0' || *s == '1') { value = value * 2 + (*s++ - '0'); continue; }
+      return value;
+    }
+  }
+
+  //octal (or decimal '0')
+  if(x == '0') {
+    s += 1;
+    while(true) {
+      if(*s >= '0' && *s <= '7') { value = value * 8 + (*s++ - '0'); continue; }
+      return value;
+    }
+  }
+
+  //decimal
+  if(x >= '0' && x <= '9') {
+    while(true) {
+      if(*s >= '0' && *s <= '9') { value = value * 10 + (*s++ - '0'); continue; }
+      return value;
+    }
+  }
+
+  //char
+  if(x == '\'' && y != '\'') {
+    s += 1;
+    while(true) {
+      value = value * 256 + *s++;
+      if(*s == '\'') { s += 1; return value; }
+      if(!*s) throw "mismatched char";
+    }
+  }
+
+  throw "unrecognized integer";
+}
+
+static intmax_t eval(const char *&s, int depth = 0) {
+  while(*s == ' ' || *s == '\t') s++;  //trim whitespace
+  if(!*s) throw "unrecognized token";
+  intmax_t value = 0, x = *s, y = *(s + 1);
+
+  if(*s == '(') {
+    value = eval(++s, 1);
+    if(*s++ != ')') throw "mismatched group";
+  }
+
+  else if(x == '!') value = !eval(++s, 13);
+  else if(x == '~') value = ~eval(++s, 13);
+  else if(x == '+') value = +eval(++s, 13);
+  else if(x == '-') value = -eval(++s, 13);
+
+  else if((x >= '0' && x <= '9') || x == '\'') value = eval_integer(s);
+
+  else if(eval_fallback) value = eval_fallback(s);  //optional user-defined syntax parsing
+
+  else throw "unrecognized token";
+
+  while(true) {
+    while(*s == ' ' || *s == '\t') s++;  //trim whitespace
+    if(!*s) break;
+    x = *s, y = *(s + 1);
+
+    if(depth >= 13) break;
+    if(x == '*') { value *= eval(++s, 13); continue; }
+    if(x == '/') { intmax_t result = eval(++s, 13); if(result == 0) throw "division by zero"; value /= result; continue; }
+    if(x == '%') { intmax_t result = eval(++s, 13); if(result == 0) throw "division by zero"; value %= result; continue; }
+
+    if(depth >= 12) break;
+    if(x == '+') { value += eval(++s, 12); continue; }
+    if(x == '-') { value -= eval(++s, 12); continue; }
+
+    if(depth >= 11) break;
+    if(x == '<' && y == '<') { value <<= eval(++++s, 11); continue; }
+    if(x == '>' && y == '>') { value >>= eval(++++s, 11); continue; }
+
+    if(depth >= 10) break;
+    if(x == '<' && y == '=') { value = value <= eval(++++s, 10); continue; }
+    if(x == '>' && y == '=') { value = value >= eval(++++s, 10); continue; }
+    if(x == '<') { value = value < eval(++s, 10); continue; }
+    if(x == '>') { value = value > eval(++s, 10); continue; }
+
+    if(depth >= 9) break;
+    if(x == '=' && y == '=') { value = value == eval(++++s, 9); continue; }
+    if(x == '!' && y == '=') { value = value != eval(++++s, 9); continue; }
+
+    if(depth >= 8) break;
+    if(x == '&' && y != '&') { value = value & eval(++s, 8); continue; }
+
+    if(depth >= 7) break;
+    if(x == '^' && y != '^') { value = value ^ eval(++s, 7); continue; }
+
+    if(depth >= 6) break;
+    if(x == '|' && y != '|') { value = value | eval(++s, 6); continue; }
+
+    if(depth >= 5) break;
+    if(x == '&' && y == '&') { value = eval(++++s, 5) && value; continue; }
+
+    if(depth >= 4) break;
+    if(x == '^' && y == '^') { value = (!eval(++++s, 4) != !value); continue; }
+
+    if(depth >= 3) break;
+    if(x == '|' && y == '|') { value = eval(++++s, 3) || value; continue; }
+
+    if(x == '?') {
+      intmax_t lhs = eval(++s, 2);
+      if(*s != ':') throw "mismatched ternary";
+      intmax_t rhs = eval(++s, 2);
+      value = value ? lhs : rhs;
+      continue;
+    }
+    if(depth >= 2) break;
+
+    if(depth > 0 && x == ')') break;
+
+    throw "unrecognized token";
+  }
+
+  return value;
+}
+
+static bool eval(const char *s, intmax_t &result) {
+  try {
+    result = eval(s);
+    return true;
+  } catch(const char*) {
+    result = 0;
+    return false;
+  }
+}
+
+static intmax_t parse(const char *s) {
+  try {
+    intmax_t result = eval(s);
+    return result;
+  } catch(const char *) {
+    return 0;
+  }
+}
+
+}
+
+#endif

bsnes/nall/string/math-floating-point.hpp

@@ -0,0 +1,157 @@
+#ifdef NALL_STRING_INTERNAL_HPP
+
+namespace floatingpoint {
+
+static nall::function<double (const char *&)> eval_fallback;
+
+static double eval_integer(const char *&s) {
+  if(!*s) throw "unrecognized integer";
+  intmax_t value = 0, radix = 0, x = *s, y = *(s + 1);
+
+  //hexadecimal
+  if(x == '0' && (y == 'X' || y == 'x')) {
+    s += 2;
+    while(true) {
+      if(*s >= '0' && *s <= '9') { value = value * 16 + (*s++ - '0');      continue; }
+      if(*s >= 'A' && *s <= 'F') { value = value * 16 + (*s++ - 'A' + 10); continue; }
+      if(*s >= 'a' && *s <= 'f') { value = value * 16 + (*s++ - 'a' + 10); continue; }
+      return value;
+    }
+  }
+
+  //binary
+  if(x == '0' && (y == 'B' || y == 'b')) {
+    s += 2;
+    while(true) {
+      if(*s == '0' || *s == '1') { value = value * 2 + (*s++ - '0'); continue; }
+      return value;
+    }
+  }
+
+  //octal (or decimal '0')
+  if(x == '0' && y != '.') {
+    s += 1;
+    while(true) {
+      if(*s >= '0' && *s <= '7') { value = value * 8 + (*s++ - '0'); continue; }
+      return value;
+    }
+  }
+
+  //decimal
+  if(x >= '0' && x <= '9') {
+    while(true) {
+      if(*s >= '0' && *s <= '9') { value = value * 10 + (*s++ - '0'); continue; }
+      if(*s == '.') { s++; break; }
+      return value;
+    }
+    //floating-point
+    while(true) {
+      if(*s >= '0' && *s <= '9') { radix = radix * 10 + (*s++ - '0'); continue; }
+      return atof(nall::string{ nall::decimal(value), ".", nall::decimal(radix) });
+    }
+  }
+
+  //char
+  if(x == '\'' && y != '\'') {
+    s += 1;
+    while(true) {
+      value = value * 256 + *s++;
+      if(*s == '\'') { s += 1; return value; }
+      if(!*s) throw "mismatched char";
+    }
+  }
+
+  throw "unrecognized integer";
+}
+
+static double eval(const char *&s, int depth = 0) {
+  while(*s == ' ' || *s == '\t') s++;  //trim whitespace
+  if(!*s) throw "unrecognized token";
+  double value = 0, x = *s, y = *(s + 1);
+
+  if(*s == '(') {
+    value = eval(++s, 1);
+    if(*s++ != ')') throw "mismatched group";
+  }
+
+  else if(x == '!') value = !eval(++s, 9);
+  else if(x == '+') value = +eval(++s, 9);
+  else if(x == '-') value = -eval(++s, 9);
+
+  else if((x >= '0' && x <= '9') || x == '\'') value = eval_integer(s);
+
+  else if(eval_fallback) value = eval_fallback(s);  //optional user-defined syntax parsing
+
+  else throw "unrecognized token";
+
+  while(true) {
+    while(*s == ' ' || *s == '\t') s++;  //trim whitespace
+    if(!*s) break;
+    x = *s, y = *(s + 1);
+
+    if(depth >= 9) break;
+    if(x == '*') { value *= eval(++s, 9); continue; }
+    if(x == '/') { double result = eval(++s, 9); if(result == 0.0) throw "division by zero"; value /= result; continue; }
+
+    if(depth >= 8) break;
+    if(x == '+') { value += eval(++s, 8); continue; }
+    if(x == '-') { value -= eval(++s, 8); continue; }
+
+    if(depth >= 7) break;
+    if(x == '<' && y == '=') { value = value <= eval(++++s, 7); continue; }
+    if(x == '>' && y == '=') { value = value >= eval(++++s, 7); continue; }
+    if(x == '<') { value = value < eval(++s, 7); continue; }
+    if(x == '>') { value = value > eval(++s, 7); continue; }
+
+    if(depth >= 6) break;
+    if(x == '=' && y == '=') { value = value == eval(++++s, 6); continue; }
+    if(x == '!' && y == '=') { value = value != eval(++++s, 6); continue; }
+
+    if(depth >= 5) break;
+    if(x == '&' && y == '&') { value = eval(++++s, 5) && value; continue; }
+
+    if(depth >= 4) break;
+    if(x == '^' && y == '^') { value = (!eval(++++s, 4) != !value); continue; }
+
+    if(depth >= 3) break;
+    if(x == '|' && y == '|') { value = eval(++++s, 3) || value; continue; }
+
+    if(x == '?') {
+      double lhs = eval(++s, 2);
+      if(*s != ':') throw "mismatched ternary";
+      double rhs = eval(++s, 2);
+      value = value ? lhs : rhs;
+      continue;
+    }
+    if(depth >= 2) break;
+
+    if(depth > 0 && x == ')') break;
+
+    throw "unrecognized token";
+  }
+
+  return value;
+}
+
+static bool eval(const char *s, double &result) {
+  try {
+    result = eval(s);
+    return true;
+  } catch(const char*e) {
+    result = 0;
+    return false;
+  }
+}
+
+static double parse(const char *s) {
+  try {
+    double result = eval(s);
+    return result;
+  } catch(const char *) {
+    return 0;
+  }
+}
+
+}
+
+#endif

bsnes/nall/string/strl.hpp

@@ -1,51 +0,0 @@
-#ifdef NALL_STRING_INTERNAL_HPP
-
-namespace nall {
-
-//strlcpy, strlcat based on OpenBSD implementation by Todd C. Miller
-
-//return = strlen(src)
-unsigned strlcpy(char *dest, const char *src, unsigned length) {
-  char *d = dest;
-  const char *s = src;
-  unsigned n = length;
-
-  if(n) {
-    while(--n && (*d++ = *s++)); //copy as many bytes as possible, or until null terminator reached
-  }
-
-  if(!n) {
-    if(length) *d = 0;
-    while(*s++); //traverse rest of s, so that s - src == strlen(src)
-  }
-
-  return (s - src - 1); //return length of copied string, sans null terminator
-}
-
-//return = strlen(src) + min(length, strlen(dest))
-unsigned strlcat(char *dest, const char *src, unsigned length) {
-  char *d = dest;
-  const char *s = src;
-  unsigned n = length;
-
-  while(n-- && *d) d++; //find end of dest
-  unsigned dlength = d - dest;
-  n = length - dlength; //subtract length of dest from maximum string length
-
-  if(!n) return dlength + strlen(s);
-
-  while(*s) {
-    if(n != 1) {
-      *d++ = *s;
-      n--;
-    }
-    s++;
-  }
-  *d = 0;
-
-  return dlength + (s - src); //return length of resulting string, sans null terminator
-}
-
-}
-
-#endif

bsnes/nall/string/strm.hpp

@@ -0,0 +1,45 @@
+#ifdef NALL_STRING_INTERNAL_HPP
+
+namespace nall {
+
+//
+//strmcpy, strmcat created by byuu
+//
+
+//return = strlen(target)
+unsigned strmcpy(char *target, const char *source, unsigned length) {
+  const char *origin = target;
+  if(length) {
+    while(*source && --length) *target++ = *source++;
+    *target = 0;
+  }
+  return target - origin;
+}
+
+//return = strlen(target)
+unsigned strmcat(char *target, const char *source, unsigned length) {
+  const char *origin = target;
+  while(*target && length) target++, length--;
+  return (target - origin) + strmcpy(target, source, length);
+}
+
+//return = true when all of source was copied
+bool strccpy(char *target, const char *source, unsigned length) {
+  return !source[strmcpy(target, source, length)];
+}
+
+//return = true when all of source was copied
+bool strccat(char *target, const char *source, unsigned length) {
+  while(*target && length) target++, length--;
+  return !source[strmcpy(target, source, length)];
+}
+
+//return = reserved for future use
+void strpcpy(char *&target, const char *source, unsigned &length) {
+  unsigned offset = strmcpy(target, source, length);
+  target += offset, length -= offset;
+}
+
+}
+
+#endif

bsnes/nall/string/utf8.hpp

@@ -0,0 +1,43 @@
+#ifdef NALL_STRING_INTERNAL_HPP
+
+namespace nall {
+
+struct UTF8 {
+  unsigned size;       //size of encoded codepoint
+  uint64_t data;       //encoded codepoint
+  unsigned codepoint;  //decoded codepoint
+};
+
+inline UTF8 utf8_read(const char *s) {
+  UTF8 utf8;
+
+       if((*s & 0xfe) == 0xfc) utf8.size = 6;
+  else if((*s & 0xfc) == 0xf8) utf8.size = 5;
+  else if((*s & 0xf8) == 0xf0) utf8.size = 4;
+  else if((*s & 0xf0) == 0xe0) utf8.size = 3;
+  else if((*s & 0xe0) == 0xc0) utf8.size = 2;
+  else                         utf8.size = 1;
+
+  utf8.data = 0;
+  for(unsigned n = 0; n < utf8.size; n++) {
+    utf8.data = (utf8.data << 8) | (uint8_t)s[n];
+  }
+
+  static uint8_t mask[] = { 0, 0x7f, 0x1f, 0x0f, 0x07, 0x03, 0x01 };
+  utf8.codepoint = s[0] & mask[utf8.size];
+  for(unsigned n = 1; n < utf8.size; n++) {
+    utf8.codepoint = (utf8.codepoint << 6) | (s[n] & 0x3f);
+  }
+
+  return utf8;
+}
+
+inline void utf8_write(char *s, const UTF8 &utf8) {
+  for(signed n = utf8.size - 1, shift = 0; n >= 0; n--, shift += 8) {
+    s[n] = utf8.data >> shift;
+  }
+}
+
+}
+
+#endif

bsnes/nall/string/utility.hpp

@@ -34,24 +34,16 @@ bool quotecopy(char *&t, T *&p) {
   return true;
 }
 
-unsigned strlcpy(string &dest, const char *src, unsigned length) {
-  dest.reserve(length);
-  return strlcpy(dest(), src, length);
-}
-
-unsigned strlcat(string &dest, const char *src, unsigned length) {
-  dest.reserve(length);
-  return strlcat(dest(), src, length);
-}
-
 string substr(const char *src, unsigned start, unsigned length) {
   string dest;
   if(length == ~0u) {
     //copy entire string
-    dest = src + start;
+    dest.reserve(strlen(src + start) + 1);
+    strcpy(dest(), src + start);
   } else {
     //copy partial string
-    strlcpy(dest, src + start, length + 1);
+    dest.reserve(length + 1);
+    strmcpy(dest(), src + start, length + 1);
   }
   return dest;
 }
@@ -253,9 +245,14 @@ template<unsigned length_, char padding> string binary(uintmax_t value) {
 //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.
-unsigned fp(char *str, double value) {
+unsigned fp(char *str, long double value) {
   char buffer[256];
-  sprintf(buffer, "%f", value);
+  #ifdef _WIN32
+  //Windows C-runtime does not support long double via sprintf()
+  sprintf(buffer, "%f", (double)value);
+  #else
+  sprintf(buffer, "%Lf", value);
+  #endif
 
   //remove excess 0's in fraction (2.500000 -> 2.5)
   for(char *p = buffer; *p; p++) {
@@ -274,7 +271,7 @@ unsigned fp(char *str, double value) {
   return length + 1;
 }
 
-string fp(double value) {
+string fp(long double value) {
   string temp;
   temp.reserve(fp(0, value));
   fp(temp(), value);

bsnes/nall/string/wildcard.hpp

@@ -0,0 +1,78 @@
+#ifdef NALL_STRING_INTERNAL_HPP
+
+namespace nall {
+
+bool wildcard(const char *s, const char *p) {
+  const char *cp = 0, *mp = 0;
+  while(*s && *p != '*') {
+    if(*p != '?' && *s != *p) return false;
+    p++, s++;
+  }
+  while(*s) {
+    if(*p == '*') {
+      if(!*++p) return true;
+      mp = p, cp = s + 1;
+    } else if(*p == '?' || *p == *s) {
+      p++, s++;
+    } else {
+      p = mp, s = cp++;
+    }
+  }
+  while(*p == '*') p++;
+  return !*p;
+}
+
+bool iwildcard(const char *s, const char *p) {
+  const char *cp = 0, *mp = 0;
+  while(*s && *p != '*') {
+    if(*p != '?' && chrlower(*s) != chrlower(*p)) return false;
+    p++, s++;
+  }
+  while(*s) {
+    if(*p == '*') {
+      if(!*++p) return true;
+      mp = p, cp = s + 1;
+    } else if(*p == '?' || chrlower(*p) == chrlower(*s)) {
+      p++, s++;
+    } else {
+      p = mp, s = cp++;
+    }
+  }
+  while(*p == '*') p++;
+  return !*p;
+}
+
+inline bool tokenize(const char *s, const char *p) {
+  while(*s) {
+    if(*p == '*') {
+      while(*s) if(tokenize(s++, p + 1)) return true;
+      return !*++p;
+    }
+    if(*s++ != *p++) return false;
+  }
+  while(*p == '*') p++;
+  return !*p;
+}
+
+inline bool tokenize(lstring &list, const char *s, const char *p) {
+  while(*s) {
+    if(*p == '*') {
+      const char *b = s;
+      while(*s) {
+        if(tokenize(list, s++, p + 1)) {
+          list.prepend(substr(b, 0, --s - b));
+          return true;
+        }
+      }
+      list.prepend(b);
+      return !*++p;
+    }
+    if(*s++ != *p++) return false;
+  }
+  while(*p == '*') { list.prepend(s); p++; }
+  return !*p;
+}
+
+}
+
+#endif

bsnes/nall/string/wrapper.hpp

@@ -3,6 +3,7 @@
 namespace nall {
 
 unsigned string::length() const { return strlen(data); }
+unsigned string::capacity() const { return size; }
 
 template<unsigned limit> lstring string::split(const char *key) const { lstring result; result.split<limit>(key, data); return result; }
 template<unsigned limit> lstring string::isplit(const char *key) const { lstring result; result.isplit<limit>(key, data); return result; }

bsnes/nall/string/xml-legacy.hpp

@@ -0,0 +1,265 @@
+#ifdef NALL_STRING_INTERNAL_HPP
+
+//XML v1.0 subset parser
+//revision 0.05
+
+namespace nall {
+
+struct xml_attribute {
+  string name;
+  string content;
+  virtual string parse() const;
+};
+
+struct xml_element : xml_attribute {
+  string parse() const;
+  linear_vector<xml_attribute> attribute;
+  linear_vector<xml_element> 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, "<!--")) {
+      if(auto pos = strpos(source, "-->")) {
+        source += pos() + 3;
+        continue;
+      } else {
+        return "";
+      }
+    }
+
+    if(strbegin(source, "<![CDATA[")) {
+      if(auto pos = strpos(source, "]]>")) {
+        if(pos() - 9 > 0) {
+          string cdata = substr(source, 9, pos() - 9);
+          data.append(cdata);
+          offset += strlen(cdata);
+        }
+        source += 9 + offset + 3;
+        continue;
+      } else {
+        return "";
+      }
+    }
+
+    //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, "  ")) data.qreplace("  ", " ");
+  data.qreplace(" =", "=");
+  data.qreplace("= ", "=");
+  data.rtrim();
+
+  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;
+    attr.name = side[0];
+    attr.content = side[1];
+    if(strbegin(attr.content, "\"") && strend(attr.content, "\"")) attr.content.trim<1>("\"");
+    else if(strbegin(attr.content, "'") && strend(attr.content, "'")) attr.content.trim<1>("'");
+    else throw "...";
+    attribute.append(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, "!--")) {
+      if(auto offset = strpos(data, "-->")) {
+        data += offset() + 3;
+        continue;
+      } else {
+        throw "...";
+      }
+    }
+
+    if(strbegin(data, "![CDATA[")) {
+      if(auto offset = strpos(data, "]]>")) {
+        data += offset() + 3;
+        continue;
+      } else {
+        throw "...";
+      }
+    }
+
+    auto offset = strpos(data, ">");
+    if(!offset) 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;
+      tag.rtrim<1>("?");
+    } else if(strend(tag, "/") == true) {
+      self_terminating = true;
+      tag.rtrim<1>("/");
+    }
+
+    parse_head(tag);
+    if(self_terminating) return true;
+
+    while(*data) {
+      unsigned index = element.size();
+      xml_element node;
+      if(node.parse_body(data) == false) {
+        if(*data == '/') {
+          signed length = data - content_begin - 1;
+          if(length > 0) content = substr(content_begin, 0, length);
+
+          data++;
+          auto offset = strpos(data, ">");
+          if(!offset) throw "...";
+
+          tag = substr(data, 0, offset());
+          data += offset() + 1;
+
+          tag.replace("\t", " ");
+          tag.replace("\r", " ");
+          tag.replace("\n", " ");
+          while(strpos(tag, "  ")) tag.replace("  ", " ");
+          tag.rtrim();
+
+          if(name != tag) throw "...";
+          return true;
+        }
+      } else {
+        element.append(node);
+      }
+    }
+  }
+}
+
+//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;
+
+  try {
+    while(*data) {
+      xml_element node;
+      if(node.parse_body(data) == false) {
+        break;
+      } else {
+        self.element.append(node);
+      }
+    }
+
+    if(xml_validate(self) == false) throw "...";
+    return self;
+  } catch(const char*) {
+    xml_element empty;
+    return empty;
+  }
+}
+
+}
+
+#endif

bsnes/nall/string/xml.hpp

@@ -1,265 +1,250 @@
 #ifdef NALL_STRING_INTERNAL_HPP
 
 //XML v1.0 subset parser
-//revision 0.05
+//revision 0.01
 
 namespace nall {
+namespace XML {
 
-struct xml_attribute {
+struct Node {
   string name;
-  string content;
-  virtual string parse() const;
-};
-
-struct xml_element : xml_attribute {
-  string parse() const;
-  linear_vector<xml_attribute> attribute;
-  linear_vector<xml_element> 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;
+  bool attribute;
+  array<Node*> children;
 
-  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++;
+  inline bool exists() const {
+    return !name.empty();
   }
 
-  data[offset] = 0;
-  return data;
-}
+  inline bool isName(char c) const {
+    if(c >= 'A' && c <= 'Z') return true;
+    if(c >= 'a' && c <= 'z') return true;
+    if(c >= '0' && c <= '9') return true;
+    if(c == '.' || c == '_') return true;
+    if(c == '?') return true;
+    return false;
+  }
 
-inline string xml_element::parse() const {
-  string data;
-  unsigned offset = 0;
+  inline bool isWhitespace(char c) const {
+    if(c ==  ' ' || c == '\t') return true;
+    if(c == '\r' || c == '\n') return true;
+    return false;
+  }
 
-  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; }
-    }
+  //copy part of string from source document into target string; decode markup while copying
+  inline void copy(string &target, const char *source, unsigned length) {
+    target.reserve(length + 1);
 
-    if(strbegin(source, "<!--")) {
-      if(auto pos = strpos(source, "-->")) {
-        source += pos() + 3;
-        continue;
-      } else {
-        return "";
+    #if defined(NALL_XML_LITERAL)
+    memcpy(target(), source, length);
+    target[length] = 0;
+    return;
+    #endif
+
+    char *output = target();
+    while(length) {
+      if(*source == '&') {
+        if(!memcmp(source, "&lt;",   4)) { *output++ = '<';  source += 4; length -= 4; continue; }
+        if(!memcmp(source, "&gt;",   4)) { *output++ = '>';  source += 4; length -= 4; continue; }
+        if(!memcmp(source, "&amp;",  5)) { *output++ = '&';  source += 5; length -= 5; continue; }
+        if(!memcmp(source, "&apos;", 6)) { *output++ = '\''; source += 6; length -= 6; continue; }
+        if(!memcmp(source, "&quot;", 6)) { *output++ = '\"'; source += 6; length -= 6; continue; }
       }
-    }
 
-    if(strbegin(source, "<![CDATA[")) {
-      if(auto pos = strpos(source, "]]>")) {
-        if(pos() - 9 > 0) {
-          string cdata = substr(source, 9, pos() - 9);
-          data.append(cdata);
-          offset += strlen(cdata);
+      if(attribute == false && source[0] == '<' && source[1] == '!') {
+        //comment
+        if(!memcmp(source, "<!--", 4)) {
+          source += 4, length -= 4;
+          while(memcmp(source, "-->", 3)) source++, length--;
+          source += 3, length -= 3;
+          continue;
+        }
+
+        //CDATA
+        if(!memcmp(source, "<![CDATA[", 9)) {
+          source += 9, length -= 9;
+          while(memcmp(source, "]]>", 3)) *output++ = *source++, length--;
+          source += 3, length -= 3;
+          continue;
         }
-        source += 9 + offset + 3;
-        continue;
-      } else {
-        return "";
       }
+
+      *output++ = *source++, length--;
     }
-
-    //reject illegal characters
-    if(*source == '&') return "";
-    if(*source == '<') return "";
-    if(*source == '>') return "";
-
-    data[offset++] = *source++;
+    *output = 0;
   }
 
-  data[offset] = 0;
-  return data;
-}
+  inline bool parseExpression(const char *&p) {
+    if(*(p + 1) != '!') return false;
 
-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, "  ")) data.qreplace("  ", " ");
-  data.qreplace(" =", "=");
-  data.qreplace("= ", "=");
-  data.rtrim();
-
-  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;
-    attr.name = side[0];
-    attr.content = side[1];
-    if(strbegin(attr.content, "\"") && strend(attr.content, "\"")) attr.content.trim<1>("\"");
-    else if(strbegin(attr.content, "'") && strend(attr.content, "'")) attr.content.trim<1>("'");
-    else throw "...";
-    attribute.append(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);
+    //comment
+    if(!memcmp(p, "<!--", 4)) {
+      while(*p && memcmp(p, "-->", 3)) p++;
+      if(!*p) throw "unclosed comment";
+      p += 3;
       return true;
     }
 
-    if(strbegin(data, "!--")) {
-      if(auto offset = strpos(data, "-->")) {
-        data += offset() + 3;
-        continue;
-      } else {
-        throw "...";
-      }
+    //CDATA
+    if(!memcmp(p, "<![CDATA[", 9)) {
+      while(*p && memcmp(p, "]]>", 3)) p++;
+      if(!*p) throw "unclosed CDATA";
+      p += 3;
+      return true;
     }
 
-    if(strbegin(data, "![CDATA[")) {
-      if(auto offset = strpos(data, "]]>")) {
-        data += offset() + 3;
-        continue;
-      } else {
-        throw "...";
-      }
+    //DOCTYPE
+    if(!memcmp(p, "<!DOCTYPE", 9)) {
+      unsigned counter = 0;
+      do {
+        char n = *p++;
+        if(!n) throw "unclosed DOCTYPE";
+        if(n == '<') counter++;
+        if(n == '>') counter--;
+      } while(counter);
+      return true;
     }
 
-    auto offset = strpos(data, ">");
-    if(!offset) 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;
-      tag.rtrim<1>("?");
-    } else if(strend(tag, "/") == true) {
-      self_terminating = true;
-      tag.rtrim<1>("/");
-    }
-
-    parse_head(tag);
-    if(self_terminating) return true;
-
-    while(*data) {
-      unsigned index = element.size();
-      xml_element node;
-      if(node.parse_body(data) == false) {
-        if(*data == '/') {
-          signed length = data - content_begin - 1;
-          if(length > 0) content = substr(content_begin, 0, length);
-
-          data++;
-          auto offset = strpos(data, ">");
-          if(!offset) throw "...";
-
-          tag = substr(data, 0, offset());
-          data += offset() + 1;
-
-          tag.replace("\t", " ");
-          tag.replace("\r", " ");
-          tag.replace("\n", " ");
-          while(strpos(tag, "  ")) tag.replace("  ", " ");
-          tag.rtrim();
-
-          if(name != tag) throw "...";
-          return true;
-        }
-      } else {
-        element.append(node);
-      }
-    }
-  }
-}
-
-//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 false;
   }
 
-  return true;
-}
+  //returns true if tag closes itself (<tag/>); false if not (<tag>)
+  inline bool parseHead(const char *&p) {
+    //parse name
+    const char *nameStart = ++p;  //skip '<'
+    while(isName(*p)) p++;
+    const char *nameEnd = p;
+    copy(name, nameStart, nameEnd - nameStart);
+    if(name.empty()) throw "missing element name";
 
-inline xml_element xml_parse(const char *data) {
-  xml_element self;
+    //parse attributes
+    while(*p) {
+      while(isWhitespace(*p)) p++;
+      if(!*p) throw "unclosed attribute";
+      if(*p == '?' || *p == '/' || *p == '>') break;
 
-  try {
-    while(*data) {
-      xml_element node;
-      if(node.parse_body(data) == false) {
-        break;
-      } else {
-        self.element.append(node);
-      }
+      //parse attribute name
+      Node *attribute = new Node;
+      children.append(attribute);
+      attribute->attribute = true;
+
+      const char *nameStart = p;
+      while(isName(*p)) p++;
+      const char *nameEnd = p;
+      copy(attribute->name, nameStart, nameEnd - nameStart);
+      if(attribute->name.empty()) throw "missing attribute name";
+
+      //parse attribute data
+      if(*p++ != '=') throw "missing attribute value";
+      char terminal = *p++;
+      if(terminal != '\'' && terminal != '\"') throw "attribute value not quoted";
+      const char *dataStart = p;
+      while(*p && *p != terminal) p++;
+      if(!*p) throw "missing attribute data terminal";
+      const char *dataEnd = p++;  //skip closing terminal
+
+      copy(attribute->data, dataStart, dataEnd - dataStart);
     }
 
-    if(xml_validate(self) == false) throw "...";
-    return self;
-  } catch(const char*) {
-    xml_element empty;
-    return empty;
+    //parse closure
+    if(*p == '?' && *(p + 1) == '>') { p += 2; return true; }
+    if(*p == '/' && *(p + 1) == '>') { p += 2; return true; }
+    if(*p == '>') { p += 1; return false; }
+    throw "invalid element tag";
   }
-}
 
+  //parse element and all of its child elements
+  inline void parseElement(const char *&p) {
+    Node *node = new Node;
+    children.append(node);
+    if(node->parseHead(p) == true) return;
+    node->parse(p);
+  }
+
+  //return true if </tag> matches this node's name
+  inline bool parseClosureElement(const char *&p) {
+    if(p[0] != '<' || p[1] != '/') return false;
+    p += 2;
+    const char *nameStart = p;
+    while(*p && *p != '>') p++;
+    if(*p != '>') throw "unclosed closure element";
+    const char *nameEnd = p++;
+    if(memcmp(name, nameStart, nameEnd - nameStart)) throw "closure element name mismatch";
+    return true;
+  }
+
+  //parse contents of an element
+  inline void parse(const char *&p) {
+    const char *dataStart = p, *dataEnd = p;
+
+    while(*p) {
+      while(*p && *p != '<') p++;
+      if(!*p) break;
+      dataEnd = p;
+      if(parseClosureElement(p) == true) break;
+      if(parseExpression(p) == true) continue;
+      parseElement(p);
+    }
+
+    copy(data, dataStart, dataEnd - dataStart);
+  }
+
+  inline void reset() {
+    for(auto &child : children) delete child;
+    children.reset();
+  }
+
+  struct iterator {
+    inline bool operator!=(const iterator &source) const { return index != source.index; }
+    inline Node& operator*() { return *node.children[index]; }
+    inline iterator& operator++() { index++; return *this; }
+    inline iterator(const Node &node, unsigned index) : node(node), index(index) {}
+  private:
+    const Node &node;
+    unsigned index;
+  };
+
+  inline iterator begin() { return iterator(*this, 0); }
+  inline iterator end() { return iterator(*this, children.size()); }
+  inline const iterator begin() const { return iterator(*this, 0); }
+  inline const iterator end() const { return iterator(*this, children.size()); }
+
+  inline Node& operator[](const char *name) {
+    for(auto &node : *this) {
+      if(node.name == name) return node;
+    }
+    static Node node;
+    return node;
+  }
+
+  inline Node() : attribute(false) {}
+  inline ~Node() { reset(); }
+
+  Node(const Node&) = delete;
+  Node& operator=(const Node&) = delete;
+};
+
+struct Document : Node {
+  string error;
+
+  inline bool load(const char *document) {
+    if(document == nullptr) return false;
+    reset();
+    try {
+      parse(document);
+    } catch(const char *error) {
+      reset();
+      this->error = error;
+      return false;
+    }
+    return true;
+  }
+
+  inline Document() {}
+  inline Document(const char *document) { load(document); }
+};
+
+}
 }
 
 #endif

bsnes/nall/type_traits.hpp

@@ -0,0 +1,33 @@
+#ifndef NALL_STATIC_HPP
+#define NALL_STATIC_HPP
+
+#include <type_traits>
+
+namespace nall {
+
+template<typename T> class has_default_constructor {
+  template<signed> class receive_size{};
+  template<typename U> static signed sfinae(receive_size<sizeof U()>*);
+  template<typename U> static char sfinae(...);
+
+public:
+  enum : bool { value = sizeof(sfinae<T>(0)) == sizeof(signed) };
+};
+
+template<bool C, typename T = bool> struct enable_if { typedef T type; };
+template<typename T> struct enable_if<false, T> {};
+
+template<bool C, typename T, typename F> struct type_if { typedef T type; };
+template<typename T, typename F> struct type_if<false, T, F> { typedef F type; };
+
+template<bool A, bool B> struct static_and { enum { value = false }; };
+template<> struct static_and<true, true> { enum { value = true }; };
+
+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 }; };
+
+}
+
+#endif

bsnes/nall/utility.hpp

@@ -5,16 +5,6 @@
 #include <utility>
 
 namespace nall {
-  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(std::move(x));
-    x = std::move(y);
-    y = std::move(temp);
-  }
-
   template<typename T> struct base_from_member {
     T value;
     base_from_member(T value_) : value(value_) {}

bsnes/nall/varint.hpp

@@ -1,64 +1,68 @@
 #ifndef NALL_VARINT_HPP
 #define NALL_VARINT_HPP
 
-#include <type_traits>
 #include <nall/bit.hpp>
-#include <nall/static.hpp>
+#include <nall/type_traits.hpp>
 
 namespace nall {
   template<unsigned bits> class uint_t {
   private:
-    unsigned data;
+    typedef typename type_if<bits <= 8 * sizeof(unsigned), unsigned, uintmax_t>::type type_t;
+    type_t data;
 
   public:
-    inline operator unsigned() const { return data; }
-    inline unsigned operator ++(int) { unsigned r = data; data = uclip<bits>(data + 1); return r; }
-    inline unsigned operator --(int) { unsigned r = data; data = uclip<bits>(data - 1); return r; }
-    inline unsigned operator ++() { return data = uclip<bits>(data + 1); }
-    inline unsigned operator --() { return data = uclip<bits>(data - 1); }
-    inline unsigned operator  =(const unsigned i) { return data = uclip<bits>(i); }
-    inline unsigned operator |=(const unsigned i) { return data = uclip<bits>(data  | i); }
-    inline unsigned operator ^=(const unsigned i) { return data = uclip<bits>(data  ^ i); }
-    inline unsigned operator &=(const unsigned i) { return data = uclip<bits>(data  & i); }
-    inline unsigned operator<<=(const unsigned i) { return data = uclip<bits>(data << i); }
-    inline unsigned operator>>=(const unsigned i) { return data = uclip<bits>(data >> i); }
-    inline unsigned operator +=(const unsigned i) { return data = uclip<bits>(data  + i); }
-    inline unsigned operator -=(const unsigned i) { return data = uclip<bits>(data  - i); }
-    inline unsigned operator *=(const unsigned i) { return data = uclip<bits>(data  * i); }
-    inline unsigned operator /=(const unsigned i) { return data = uclip<bits>(data  / i); }
-    inline unsigned operator %=(const unsigned i) { return data = uclip<bits>(data  % i); }
+    inline operator type_t() const { return data; }
+    inline type_t operator ++(int) { type_t r = data; data = uclip<bits>(data + 1); return r; }
+    inline type_t operator --(int) { type_t r = data; data = uclip<bits>(data - 1); return r; }
+    inline type_t operator ++() { return data = uclip<bits>(data + 1); }
+    inline type_t operator --() { return data = uclip<bits>(data - 1); }
+    inline type_t operator  =(const type_t i) { return data = uclip<bits>(i); }
+    inline type_t operator |=(const type_t i) { return data = uclip<bits>(data  | i); }
+    inline type_t operator ^=(const type_t i) { return data = uclip<bits>(data  ^ i); }
+    inline type_t operator &=(const type_t i) { return data = uclip<bits>(data  & i); }
+    inline type_t operator<<=(const type_t i) { return data = uclip<bits>(data << i); }
+    inline type_t operator>>=(const type_t i) { return data = uclip<bits>(data >> i); }
+    inline type_t operator +=(const type_t i) { return data = uclip<bits>(data  + i); }
+    inline type_t operator -=(const type_t i) { return data = uclip<bits>(data  - i); }
+    inline type_t operator *=(const type_t i) { return data = uclip<bits>(data  * i); }
+    inline type_t operator /=(const type_t i) { return data = uclip<bits>(data  / i); }
+    inline type_t operator %=(const type_t i) { return data = uclip<bits>(data  % i); }
 
     inline uint_t() : data(0) {}
-    inline uint_t(const unsigned i) : data(uclip<bits>(i)) {}
+    inline uint_t(const type_t i) : data(uclip<bits>(i)) {}
 
-    template<int s> inline unsigned operator=(const uint_t<s> &i) { return data = uclip<bits>((unsigned)i); }
-    template<int s> inline uint_t(const uint_t<s> &i) : data(uclip<bits>(i)) {}
+    template<unsigned s> inline type_t operator=(const uint_t<s> &i) { return data = uclip<bits>((type_t)i); }
+    template<unsigned s> inline uint_t(const uint_t<s> &i) : data(uclip<bits>(i)) {}
   };
 
   template<unsigned bits> class int_t {
   private:
-    signed data;
+    typedef typename type_if<bits <= 8 * sizeof(signed), signed, intmax_t>::type type_t;
+    type_t data;
 
   public:
-    inline operator signed() const { return data; }
-    inline signed operator ++(int) { signed r = data; data = sclip<bits>(data + 1); return r; }
-    inline signed operator --(int) { signed r = data; data = sclip<bits>(data - 1); return r; }
-    inline signed operator ++() { return data = sclip<bits>(data + 1); }
-    inline signed operator --() { return data = sclip<bits>(data - 1); }
-    inline signed operator  =(const signed i) { return data = sclip<bits>(i); }
-    inline signed operator |=(const signed i) { return data = sclip<bits>(data  | i); }
-    inline signed operator ^=(const signed i) { return data = sclip<bits>(data  ^ i); }
-    inline signed operator &=(const signed i) { return data = sclip<bits>(data  & i); }
-    inline signed operator<<=(const signed i) { return data = sclip<bits>(data << i); }
-    inline signed operator>>=(const signed i) { return data = sclip<bits>(data >> i); }
-    inline signed operator +=(const signed i) { return data = sclip<bits>(data  + i); }
-    inline signed operator -=(const signed i) { return data = sclip<bits>(data  - i); }
-    inline signed operator *=(const signed i) { return data = sclip<bits>(data  * i); }
-    inline signed operator /=(const signed i) { return data = sclip<bits>(data  / i); }
-    inline signed operator %=(const signed i) { return data = sclip<bits>(data  % i); }
+    inline operator type_t() const { return data; }
+    inline type_t operator ++(int) { type_t r = data; data = sclip<bits>(data + 1); return r; }
+    inline type_t operator --(int) { type_t r = data; data = sclip<bits>(data - 1); return r; }
+    inline type_t operator ++() { return data = sclip<bits>(data + 1); }
+    inline type_t operator --() { return data = sclip<bits>(data - 1); }
+    inline type_t operator  =(const type_t i) { return data = sclip<bits>(i); }
+    inline type_t operator |=(const type_t i) { return data = sclip<bits>(data  | i); }
+    inline type_t operator ^=(const type_t i) { return data = sclip<bits>(data  ^ i); }
+    inline type_t operator &=(const type_t i) { return data = sclip<bits>(data  & i); }
+    inline type_t operator<<=(const type_t i) { return data = sclip<bits>(data << i); }
+    inline type_t operator>>=(const type_t i) { return data = sclip<bits>(data >> i); }
+    inline type_t operator +=(const type_t i) { return data = sclip<bits>(data  + i); }
+    inline type_t operator -=(const type_t i) { return data = sclip<bits>(data  - i); }
+    inline type_t operator *=(const type_t i) { return data = sclip<bits>(data  * i); }
+    inline type_t operator /=(const type_t i) { return data = sclip<bits>(data  / i); }
+    inline type_t operator %=(const type_t i) { return data = sclip<bits>(data  % i); }
 
     inline int_t() : data(0) {}
-    inline int_t(const signed i) : data(sclip<bits>(i)) {}
+    inline int_t(const type_t i) : data(sclip<bits>(i)) {}
+
+    template<unsigned s> inline type_t operator=(const int_t<s> &i) { return data = sclip<bits>((type_t)i); }
+    template<unsigned s> inline int_t(const int_t<s> &i) : data(sclip<bits>(i)) {}
   };
 
   class varuint_t {
@@ -118,4 +122,71 @@ namespace nall {
   };
 }
 
+//typedefs
+  typedef nall::uint_t< 1> uint1_t;
+  typedef nall::uint_t< 2> uint2_t;
+  typedef nall::uint_t< 3> uint3_t;
+  typedef nall::uint_t< 4> uint4_t;
+  typedef nall::uint_t< 5> uint5_t;
+  typedef nall::uint_t< 6> uint6_t;
+  typedef nall::uint_t< 7> uint7_t;
+//typedef nall::uint_t< 8> uint8_t;
+  typedef nall::uint_t< 9> uint9_t;
+  typedef nall::uint_t<10> uint10_t;
+  typedef nall::uint_t<11> uint11_t;
+  typedef nall::uint_t<12> uint12_t;
+  typedef nall::uint_t<13> uint13_t;
+  typedef nall::uint_t<14> uint14_t;
+  typedef nall::uint_t<15> uint15_t;
+//typedef nall::uint_t<16> uint16_t;
+  typedef nall::uint_t<17> uint17_t;
+  typedef nall::uint_t<18> uint18_t;
+  typedef nall::uint_t<19> uint19_t;
+  typedef nall::uint_t<20> uint20_t;
+  typedef nall::uint_t<21> uint21_t;
+  typedef nall::uint_t<22> uint22_t;
+  typedef nall::uint_t<23> uint23_t;
+  typedef nall::uint_t<24> uint24_t;
+  typedef nall::uint_t<25> uint25_t;
+  typedef nall::uint_t<26> uint26_t;
+  typedef nall::uint_t<27> uint27_t;
+  typedef nall::uint_t<28> uint28_t;
+  typedef nall::uint_t<29> uint29_t;
+  typedef nall::uint_t<30> uint30_t;
+  typedef nall::uint_t<31> uint31_t;
+//typedef nall::uint_t<32> uint32_t;
+
+  typedef nall::int_t< 1> int1_t;
+  typedef nall::int_t< 2> int2_t;
+  typedef nall::int_t< 3> int3_t;
+  typedef nall::int_t< 4> int4_t;
+  typedef nall::int_t< 5> int5_t;
+  typedef nall::int_t< 6> int6_t;
+  typedef nall::int_t< 7> int7_t;
+//typedef nall::int_t< 8> int8_t;
+  typedef nall::int_t< 9> int9_t;
+  typedef nall::int_t<10> int10_t;
+  typedef nall::int_t<11> int11_t;
+  typedef nall::int_t<12> int12_t;
+  typedef nall::int_t<13> int13_t;
+  typedef nall::int_t<14> int14_t;
+  typedef nall::int_t<15> int15_t;
+//typedef nall::int_t<16> int16_t;
+  typedef nall::int_t<17> int17_t;
+  typedef nall::int_t<18> int18_t;
+  typedef nall::int_t<19> int19_t;
+  typedef nall::int_t<20> int20_t;
+  typedef nall::int_t<21> int21_t;
+  typedef nall::int_t<22> int22_t;
+  typedef nall::int_t<23> int23_t;
+  typedef nall::int_t<24> int24_t;
+  typedef nall::int_t<25> int25_t;
+  typedef nall::int_t<26> int26_t;
+  typedef nall::int_t<27> int27_t;
+  typedef nall::int_t<28> int28_t;
+  typedef nall::int_t<29> int29_t;
+  typedef nall::int_t<30> int30_t;
+  typedef nall::int_t<31> int31_t;
+//typedef nall::int_t<32> int32_t;
+
 #endif

bsnes/nall/vector.hpp

@@ -8,6 +8,7 @@
 #include <utility>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
+#include <nall/sort.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
@@ -55,13 +56,53 @@ namespace nall {
       new(pool + objectsize++) T(data);
     }
 
-    void remove(unsigned index, unsigned count = 1) {
-      for(unsigned n = index; count + n < objectsize; n++) {
-        pool[n] = pool[count + n];
-      }
+    void insert(unsigned position, const T& data) {
+      append(data);
+      for(signed n = size() - 1; n > position; n--) pool[n] = pool[n - 1];
+      pool[position] = data;
+    }
+
+    void prepend(const T& data) {
+      insert(0, data);
+    }
+
+    void remove(unsigned index = ~0u, unsigned count = 1) {
+      if(index == ~0) index = objectsize ? objectsize - 1 : 0;
+      for(unsigned n = index; count + n < objectsize; n++) pool[n] = pool[count + n];
       objectsize = (count + index >= objectsize) ? index : objectsize - count;
     }
 
+    T take(unsigned index = ~0u) {
+      if(index == ~0) index = objectsize ? objectsize - 1 : 0;
+      if(index >= objectsize) throw exception_out_of_bounds();
+      T item = pool[index];
+      remove(index);
+      return item;
+    }
+
+    void sort() {
+      nall::sort(pool, objectsize);
+    }
+
+    template<typename Comparator> void sort(const Comparator &lessthan) {
+      nall::sort(pool, objectsize, lessthan);
+    }
+
+    optional<unsigned> find(const T& data) {
+      for(unsigned n = 0; n < size(); n++) if(pool[n] == data) return { true, n };
+      return { false, 0u };
+    }
+
+    T& first() {
+      if(objectsize == 0) throw exception_out_of_bounds();
+      return pool[0];
+    }
+
+    T& last() {
+      if(objectsize == 0) throw exception_out_of_bounds();
+      return pool[objectsize - 1];
+    }
+
     //access
     inline T& operator[](unsigned position) {
       if(position >= objectsize) throw exception_out_of_bounds();
@@ -73,6 +114,12 @@ namespace nall {
       return pool[position];
     }
 
+    inline T& operator()(unsigned position) {
+      if(position >= poolsize) reserve(position + 1);
+      while(position >= objectsize) append(T());
+      return pool[position];
+    }
+
     inline const T& operator()(unsigned position, const T& data) const {
       if(position >= objectsize) return data;
       return pool[position];
@@ -133,6 +180,8 @@ namespace nall {
   //if objects hold memory address references to themselves (introspection), a
   //valid copy constructor will be needed to keep pointers valid.
 
+  #define NALL_DEPRECATED
+  #if defined(NALL_DEPRECATED)
   template<typename T> struct linear_vector {
   protected:
     T *pool;
@@ -404,6 +453,7 @@ namespace nall {
     const iterator begin() const { return iterator(*this, 0); }
     const iterator end() const { return iterator(*this, objectsize); }
   };
+  #endif
 }
 
 #endif

bsnes/nall/xorg/guard.hpp

@@ -0,0 +1,29 @@
+#ifndef NALL_XORG_GUARD_HPP
+#define NALL_XORG_GUARD_HPP
+
+#define None
+#undef XlibNone
+#define XlibNone 0L
+#define Button1 XlibButton1
+#define Button2 XlibButton2
+#define Button3 XlibButton3
+#define Button4 XlibButton4
+#define Button5 XlibButton5
+#define Display XlibDisplay
+#define Screen XlibScreen
+#define Window XlibWindow
+
+#else
+#undef NALL_XORG_GUARD_HPP
+
+#undef None
+#undef Button1
+#undef Button2
+#undef Button3
+#undef Button4
+#undef Button5
+#undef Display
+#undef Screen
+#undef Window
+
+#endif

bsnes/nall/xorg/xorg.hpp

@@ -0,0 +1,12 @@
+#ifndef NALL_XORG_XORG_HPP
+#define NALL_XORG_XORG_HPP
+
+#include <nall/xorg/guard.hpp>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <nall/xorg/guard.hpp>
+
+#endif

bsnes/nall/zip.hpp

@@ -116,7 +116,7 @@ protected:
   }
 
 public:
-  linear_vector<File> file;
+  vector<File> file;
 };
 
 }

bsnes/nes/cartridge/board/bandai-fcg.cpp

@@ -111,7 +111,7 @@ void serialize(serializer &s) {
   s.integer(irq_latch);
 }
 
-BandaiFCG(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+BandaiFCG(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
 }
 
 };

bsnes/nes/cartridge/board/board.cpp

@@ -86,14 +86,14 @@ void Board::serialize(serializer &s) {
   if(chrram.size) s.array(chrram.data, chrram.size);
 }
 
-Board::Board(BML::Node &board, const uint8_t *data, unsigned size) {
-  information.type = board["type"].value;
-  information.battery = board["prg"]["battery"].value;
+Board::Board(XML::Node &board, const uint8_t *data, unsigned size) {
+  information.type = board["type"].data;
+  information.battery = board["prg"]["battery"].data == "true";
 
-  prgrom.size = decimal(board["prg"]["rom"].value);
-  prgram.size = decimal(board["prg"]["ram"].value);
-  chrrom.size = decimal(board["chr"]["rom"].value);
-  chrram.size = decimal(board["chr"]["ram"].value);
+  prgrom.size = numeral(board["prg"]["rom"].data);
+  prgram.size = numeral(board["prg"]["ram"].data);
+  chrrom.size = numeral(board["chr"]["rom"].data);
+  chrram.size = numeral(board["chr"]["ram"].data);
 
   if(prgrom.size) prgrom.data = new uint8[prgrom.size]();
   if(prgram.size) prgram.data = new uint8[prgram.size]();
@@ -111,9 +111,9 @@ Board::~Board() {
 }
 
 Board* Board::load(const string &markup, const uint8_t *data, unsigned size) {
-  BML::Document document(markup);
+  XML::Document document(markup);
   auto &board = document["cartridge"]["board"];
-  string type = board["type"].value;
+  string type = board["type"].data;
 
   if(type == "BANDAI-FCG") return new BandaiFCG(board, data, size);
 

bsnes/nes/cartridge/board/board.hpp

@@ -31,7 +31,7 @@ struct Board {
   virtual void reset();
 
   virtual void serialize(serializer&);
-  Board(BML::Node &board, const uint8_t *data, unsigned size);
+  Board(XML::Node &board, const uint8_t *data, unsigned size);
   virtual ~Board();
 
   static Board* load(const string &markup, const uint8_t *data, unsigned size);

bsnes/nes/cartridge/board/konami-vrc1.cpp

@@ -34,7 +34,7 @@ void serialize(serializer &s) {
   vrc1.serialize(s);
 }
 
-KonamiVRC1(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc1(*this) {
+KonamiVRC1(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc1(*this) {
 }
 
 };

bsnes/nes/cartridge/board/konami-vrc2.cpp

@@ -49,9 +49,9 @@ void serialize(serializer &s) {
   vrc2.serialize(s);
 }
 
-KonamiVRC2(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc2(*this) {
-  settings.pinout.a0 = 1 << decimal(board["chip"]["pinout"]["a0"].value);
-  settings.pinout.a1 = 1 << decimal(board["chip"]["pinout"]["a1"].value);
+KonamiVRC2(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc2(*this) {
+  settings.pinout.a0 = 1 << decimal(board["chip"]["pinout"]["a0"].data);
+  settings.pinout.a1 = 1 << decimal(board["chip"]["pinout"]["a1"].data);
 }
 
 };

bsnes/nes/cartridge/board/konami-vrc3.cpp

@@ -50,8 +50,8 @@ void serialize(serializer &s) {
   vrc3.serialize(s);
 }
 
-KonamiVRC3(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc3(*this) {
-  settings.mirror = board["mirror"].value == "vertical" ? 1 : 0;
+KonamiVRC3(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc3(*this) {
+  settings.mirror = board["mirror"]["mode"].data == "vertical" ? 1 : 0;
 }
 
 };

bsnes/nes/cartridge/board/konami-vrc4.cpp

@@ -53,9 +53,9 @@ void serialize(serializer &s) {
   vrc4.serialize(s);
 }
 
-KonamiVRC4(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc4(*this) {
-  settings.pinout.a0 = 1 << decimal(board["chip"]["pinout"]["a0"].value);
-  settings.pinout.a1 = 1 << decimal(board["chip"]["pinout"]["a1"].value);
+KonamiVRC4(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc4(*this) {
+  settings.pinout.a0 = 1 << decimal(board["chip"]["pinout"]["a0"].data);
+  settings.pinout.a1 = 1 << decimal(board["chip"]["pinout"]["a1"].data);
 }
 
 };

bsnes/nes/cartridge/board/konami-vrc6.cpp

@@ -36,7 +36,7 @@ void main() { vrc6.main(); }
 void power() { vrc6.power(); }
 void reset() { vrc6.reset(); }
 
-KonamiVRC6(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc6(*this) {
+KonamiVRC6(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc6(*this) {
 }
 
 };

bsnes/nes/cartridge/board/konami-vrc7.cpp

@@ -41,7 +41,7 @@ void serialize(serializer &s) {
   vrc7.serialize(s);
 }
 
-KonamiVRC7(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc7(*this) {
+KonamiVRC7(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc7(*this) {
 }
 
 };

bsnes/nes/cartridge/board/nes-axrom.cpp

@@ -45,7 +45,7 @@ void serialize(serializer &s) {
   s.integer(mirror_select);
 }
 
-NES_AxROM(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+NES_AxROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
 }
 
 };

bsnes/nes/cartridge/board/nes-bnrom.cpp

@@ -45,8 +45,8 @@ void serialize(serializer &s) {
   s.integer(prg_bank);
 }
 
-NES_BNROM(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
-  settings.mirror = board["mirror"].value == "vertical" ? 1 : 0;
+NES_BNROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+  settings.mirror = board["mirror"]["mode"].data == "vertical" ? 1 : 0;
 }
 
 };

bsnes/nes/cartridge/board/nes-cnrom.cpp

@@ -47,8 +47,8 @@ void serialize(serializer &s) {
   s.integer(chr_bank);
 }
 
-NES_CNROM(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
-  settings.mirror = board["mirror"].value == "vertical" ? 1 : 0;
+NES_CNROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+  settings.mirror = board["mirror"]["mode"].data == "vertical" ? 1 : 0;
 }
 
 };

bsnes/nes/cartridge/board/nes-exrom.cpp

@@ -46,7 +46,7 @@ void serialize(serializer &s) {
   mmc5.serialize(s);
 }
 
-NES_ExROM(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), mmc5(*this) {
+NES_ExROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), mmc5(*this) {
   revision = Revision::ELROM;
 }